daemons/mrpd/mrp.c

   1 /****************************************************************************
   2   Copyright (c) 2012, Intel Corporation
   3   All rights reserved.
   4
   5   Redistribution and use in source and binary forms, with or without
   6   modification, are permitted provided that the following conditions are met:
   7
   8    1. Redistributions of source code must retain the above copyright notice,
   9       this list of conditions and the following disclaimer.
  10
  11    2. Redistributions in binary form must reproduce the above copyright
  12       notice, this list of conditions and the following disclaimer in the
  13       documentation and/or other materials provided with the distribution.
  14
  15    3. Neither the name of the Intel Corporation nor the names of its
  16       contributors may be used to endorse or promote products derived from
  17       this software without specific prior written permission.
  18
  19   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29   POSSIBILITY OF SUCH DAMAGE.
  30
  31 ******************************************************************************/
  32 /*
  33  * MRP protocol (part of 802.1Q-2011)
  34  */
  35
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <stddef.h>
  39 #include <string.h>
  40
  41 #include "mrpd.h"
  42 #include "mrp.h"
  43
  44 /* state machine controls */
  45 int p2pmac;
  46
  47 static int client_lookup(client_t * list, struct sockaddr_in *newclient)
  48 {
  49         client_t *client_item;
  50
  51         client_item = list;
  52
  53         if (NULL == newclient)
  54                 return 0;
  55
  56         while (NULL != client_item) {
  57                 if (client_item->client.sin_port == newclient->sin_port)
  58                         return 1;
  59                 client_item = client_item->next;
  60         }
  61         return 0;
  62 }
  63
  64 int mrp_client_add(client_t ** list, struct sockaddr_in *newclient)
  65 {
  66         client_t *client_item;
  67
  68         client_item = *list;
  69
  70         if (NULL == newclient)
  71                 return -1;
  72
  73         if (client_lookup(client_item, newclient))
  74                 return 0;       /* already present */
  75
  76         /* handle 1st entry into list */
  77         if (NULL == client_item) {
  78                 client_item = malloc(sizeof(client_t));
  79                 if (NULL == client_item)
  80                         return -1;
  81                 client_item->next = NULL;
  82                 client_item->client = *newclient;
  83                 *list = client_item;
  84                 return 0;
  85         }
  86
  87         while (client_item) {
  88                 if (NULL == client_item->next) {
  89                         client_item->next = malloc(sizeof(client_t));
  90                         if (NULL == client_item->next)
  91                                 return -1;
  92                         client_item = client_item->next;
  93                         client_item->next = NULL;
  94                         client_item->client = *newclient;
  95                         return 0;
  96                 }
  97                 client_item = client_item->next;
  98         }
  99         return -1;
 100 }
 101
 102 int mrp_client_delete(client_t ** list, struct sockaddr_in *newclient)
 103 {
 104         client_t *client_item;
 105         client_t *client_last;
 106
 107         client_item = *list;
 108         client_last = NULL;
 109
 110         if (NULL == newclient)
 111                 return 0;
 112
 113         if (NULL == client_item)
 114                 return 0;
 115
 116         while (NULL != client_item) {
 117                 if (0 == memcmp((uint8_t *) newclient,
 118                                 (uint8_t *) & client_item->client,
 119                                 sizeof(struct sockaddr_in))) {
 120
 121                         if (client_last) {
 122                                 client_last->next = client_item->next;
 123                                 free(client_item);
 124                         } else {
 125                                 /* reset the head pointer */
 126                                 *list = client_item->next;
 127                                 free(client_item);
 128                         }
 129                         return 0;
 130                 }
 131                 client_last = client_item;
 132                 client_item = client_item->next;
 133         }
 134         /* not found ... no error */
 135         return 0;
 136 }
 137
 138 int mrp_jointimer_start(struct mrp_database *mrp_db)
 139 {
 140         /* 10.7.4.1 - interval between transmit opportunities
 141          * for applicant state machine
 142          */
 143         return mrpd_timer_start(mrp_db->join_timer, MRP_LVTIMER_VAL);
 144 }
 145
 146 int mrp_jointimer_stop(struct mrp_database *mrp_db)
 147 {
 148         return mrpd_timer_stop(mrp_db->join_timer);
 149 }
 150
 151 int mrp_lvtimer_start(struct mrp_database *mrp_db)
 152 {
 153         /* leavetimer has expired (10.7.5.21)
 154          * controls how long the Registrar state machine stays in the
 155          * LV state before transitioning to the MT state.
 156          */
 157         return mrpd_timer_start(mrp_db->lv_timer, MRP_LVTIMER_VAL);
 158 }
 159
 160 int mrp_lvtimer_stop(struct mrp_database *mrp_db)
 161 {
 162         return mrpd_timer_stop(mrp_db->lv_timer);
 163 }
 164
 165 static unsigned long lva_next;
 166
 167 int mrp_lvatimer_start(struct mrp_database *mrp_db)
 168 {
 169         /* leavealltimer has expired. (10.7.5.22)
 170          * on expire, sends a LEAVEALL message
 171          * value is RANDOM in range (LeaveAllTime , 1.5xLeaveAllTime)
 172          * timer is for all attributes of a given application and port, but
 173          * expires each listed attribute individually (per application)
 174          */
 175         return mrpd_timer_start(mrp_db->lva_timer,
 176                                 MRP_LVATIMER_VAL +
 177                                 (random() % (MRP_LVATIMER_VAL / 2)));
 178 }
 179
 180 int mrp_lvatimer_stop(struct mrp_database *mrp_db)
 181 {
 182         return mrpd_timer_stop(mrp_db->lva_timer);
 183 }
 184
 185 int mrp_lvatimer_fsm(struct mrp_database *mrp_db, int event)
 186 {
 187         int la_state;
 188         int sndmsg = MRP_SND_NONE;
 189         int tx = 0;
 190
 191         if (NULL == mrp_db)
 192                 return -1;
 193
 194         la_state = mrp_db->lva.state;
 195
 196         switch (event) {
 197         case MRP_EVENT_BEGIN:
 198                 la_state = MRP_TIMER_PASSIVE;
 199                 mrp_lvatimer_start(mrp_db);
 200                 break;
 201         case MRP_EVENT_TX:
 202                 if (la_state == MRP_TIMER_ACTIVE) {
 203                         tx = 1;
 204                         sndmsg = MRP_SND_LVA;
 205                         la_state = MRP_TIMER_PASSIVE;
 206                 }
 207                 break;
 208         case MRP_EVENT_RLA:
 209                 la_state = MRP_TIMER_PASSIVE;
 210                 mrp_lvatimer_start(mrp_db);
 211                 break;
 212         case MRP_EVENT_LVATIMER:
 213                 la_state = MRP_TIMER_ACTIVE;
 214                 mrp_lvatimer_start(mrp_db);
 215                 break;
 216         default:
 217                 printf("mrp_lvatimer_fsm:unexpected event (%d)\n", event);
 218                 return -1;
 219                 break;
 220         }
 221         mrp_db->lva.state = la_state;
 222         mrp_db->lva.sndmsg = sndmsg;
 223         mrp_db->lva.tx = tx;
 224
 225         return 0;
 226 }
 227
 228 #ifdef LATER
 229 int mrp_periodictimer_fsm(struct mrp_database *mrp_db, int event)
 230 {
 231         int p_state;
 232         int sndmsg = MRP_SND_NONE;
 233         int tx = 0;
 234
 235         if (NULL == mrp_db)
 236                 return -1;
 237
 238         p_state = mrp_db->periodic.state;
 239
 240         switch (event) {
 241         case MRP_EVENT_BEGIN:
 242                 p_state = MRP_TIMER_ACTIVE;
 243                 mrp_periodictimer_start();
 244                 break;
 245         case MRP_EVENT_PERIODIC:
 246                 if (p_state == MRP_TIMER_ACTIVE) {
 247                         mrp_periodictimer_start();
 248                 }
 249                 break;
 250         case MRP_EVENT_PERIODIC_DISABLE:
 251                 p_state = MRP_TIMER_PASSIVE;
 252                 /* this lets the timer expire without rescheduling */
 253                 break;
 254         case MRP_EVENT_PERIODIC_ENABLE:
 255                 if (p_state == MRP_TIMER_PASSIVE) {
 256                         p_state = MRP_TIMER_ACTIVE;
 257                         mrp_periodictimer_start();
 258                 }
 259                 break;
 260         default:
 261                 printf("mrp_periodictimer_fsm:unexpected event (%d)\n", event);
 262                 return;
 263                 break;
 264         }
 265         mrp_db->periodic.state = p_state;
 266         mrp_db->periodic.sndmsg = sndmsg;
 267         mrp_db->periodic.tx = tx;
 268 }
 269 #endif
 270
 271 /*
 272  * per-attribute MRP FSM
 273  */
 274
 275 int mrp_applicant_fsm(mrp_applicant_attribute_t * attrib, int event)
 276 {
 277         int tx = 0;
 278         int optional = 0;
 279         int mrp_state = attrib->mrp_state;
 280         int sndmsg = MRP_SND_NULL;
 281
 282         switch (event) {
 283         case MRP_EVENT_BEGIN:
 284                 mrp_state = MRP_VO_STATE;
 285                 break;
 286         case MRP_EVENT_NEW:
 287                 /*
 288                  * New declaration (publish) event as a result
 289                  * of a mad_join request
 290                  */
 291                 switch (mrp_state) {
 292                 case MRP_VN_STATE:
 293                 case MRP_AN_STATE:
 294                         /* do nothing */
 295                         break;
 296                 default:
 297                         mrp_state = MRP_VN_STATE;
 298                         break;
 299                 }
 300                 break;
 301         case MRP_EVENT_JOIN:
 302                 /*
 303                  * declaration (of interest) event as a result of
 304                  * a mad_join request
 305                  */
 306                 switch (mrp_state) {
 307                 case MRP_LO_STATE:
 308                 case MRP_VO_STATE:
 309                         mrp_state = MRP_VP_STATE;
 310                         break;
 311                 case MRP_LA_STATE:
 312                         mrp_state = MRP_AA_STATE;
 313                         break;
 314                 case MRP_AO_STATE:
 315                         mrp_state = MRP_AP_STATE;
 316                         break;
 317                 case MRP_QO_STATE:
 318                         mrp_state = MRP_QP_STATE;
 319                         break;
 320                 default:
 321                         break;
 322                 }
 323                 break;
 324         case MRP_EVENT_LV:
 325                 /*
 326                  * declaration removal event as a result of a mad_leave request
 327                  */
 328                 switch (mrp_state) {
 329                 case MRP_VN_STATE:
 330                 case MRP_AN_STATE:
 331                 case MRP_AA_STATE:
 332                 case MRP_QA_STATE:
 333                         mrp_state = MRP_LA_STATE;
 334                         break;
 335                 case MRP_VP_STATE:
 336                         mrp_state = MRP_VO_STATE;
 337                         break;
 338                 case MRP_AP_STATE:
 339                         mrp_state = MRP_AO_STATE;
 340                         break;
 341                 case MRP_QP_STATE:
 342                         mrp_state = MRP_QO_STATE;
 343                         break;
 344                 default:
 345                         break;
 346                 }
 347                 break;
 348         case MRP_EVENT_TXLA:
 349                 /*
 350                  * transmit leaveall is signaled (overrides a TX)
 351                  */
 352                 switch (mrp_state) {
 353                 case MRP_VO_STATE:
 354                         /* send <NULL> only if it improves encoding */
 355                         optional = 1;
 356                         tx = 1;
 357                         sndmsg = MRP_SND_IN;
 358                         mrp_state = MRP_LO_STATE;
 359                         break;
 360                 case MRP_VP_STATE:
 361                         tx = 1;
 362                         sndmsg = MRP_SND_IN;
 363                         mrp_state = MRP_AA_STATE;
 364                         break;
 365                 case MRP_VN_STATE:
 366                         /* send NEW */
 367                         tx = 1;
 368                         sndmsg = MRP_SND_NEW;
 369                         mrp_state = MRP_AN_STATE;
 370                         break;
 371                 case MRP_AN_STATE:
 372                         /* send NEW */
 373                         tx = 1;
 374                         sndmsg = MRP_SND_NEW;
 375                         mrp_state = MRP_QA_STATE;
 376                         break;
 377                 case MRP_QP_STATE:
 378                 case MRP_AP_STATE:
 379                 case MRP_AA_STATE:
 380                         /* send JOIN */
 381                         tx = 1;
 382                         sndmsg = MRP_SND_JOIN;
 383                         mrp_state = MRP_QA_STATE;
 384                         break;
 385                 case MRP_QA_STATE:
 386                         /* send JOIN */
 387                         tx = 1;
 388                         sndmsg = MRP_SND_JOIN;
 389                         break;
 390                 case MRP_LA_STATE:
 391                 case MRP_AO_STATE:
 392                 case MRP_QO_STATE:
 393                         /* send <NULL> only if it improves encoding */
 394                         optional = 1;
 395                         tx = 1;
 396                         sndmsg = MRP_SND_IN;
 397                         mrp_state = MRP_LO_STATE;
 398                         break;
 399                 case MRP_LO_STATE:
 400                         /* send <NULL> */
 401                         optional = 1;
 402                         tx = 1;
 403                         sndmsg = MRP_SND_IN;
 404                         mrp_state = MRP_VO_STATE;
 405                         break;
 406                 default:
 407                         break;
 408                 }
 409                 break;
 410         case MRP_EVENT_TXLAF:
 411                 /*
 412                  * transmit leaveall failure (no room)
 413                  */
 414                 switch (mrp_state) {
 415                 case MRP_VO_STATE:
 416                         mrp_state = MRP_LO_STATE;
 417                         break;
 418                 case MRP_LO_STATE:
 419                 case MRP_VP_STATE:
 420                 case MRP_VN_STATE:
 421                         /* don't advance state */
 422                         break;
 423                 case MRP_AN_STATE:
 424                         mrp_state = MRP_VN_STATE;
 425                         break;
 426                 case MRP_QP_STATE:
 427                 case MRP_AP_STATE:
 428                 case MRP_AA_STATE:
 429                 case MRP_QA_STATE:
 430                         mrp_state = MRP_VP_STATE;
 431                         break;
 432                 case MRP_QO_STATE:
 433                 case MRP_AO_STATE:
 434                 case MRP_LA_STATE:
 435                         mrp_state = MRP_LO_STATE;
 436                         break;
 437                 default:
 438                         break;
 439                 }
 440                 break;
 441         case MRP_EVENT_TX:
 442                 /*
 443                  * transmit updates unless leaveall is signaled
 444                  * (then it becomes a TXLA)
 445                  */
 446                 switch (mrp_state) {
 447                 case MRP_VO_STATE:
 448                         /* send <NULL> only if it improves encoding */
 449                         tx = 1;
 450                         optional = 1;
 451                         sndmsg = MRP_SND_IN;
 452                         break;
 453                 case MRP_VP_STATE:
 454                         /* send JOIN */
 455                         tx = 1;
 456                         sndmsg = MRP_SND_JOIN;
 457                         mrp_state = MRP_AA_STATE;
 458                         break;
 459                 case MRP_VN_STATE:
 460                         /* send NEW */
 461                         tx = 1;
 462                         sndmsg = MRP_SND_NEW;
 463                         mrp_state = MRP_AN_STATE;
 464                         break;
 465                 case MRP_AN_STATE:
 466                         /* send NEW */
 467                         tx = 1;
 468                         sndmsg = MRP_SND_NEW;
 469                         mrp_state = MRP_QA_STATE;
 470                         break;
 471                 case MRP_AP_STATE:
 472                 case MRP_AA_STATE:
 473                         /* send JOIN */
 474                         tx = 1;
 475                         sndmsg = MRP_SND_JOIN;
 476                         mrp_state = MRP_QA_STATE;
 477                         break;
 478                 case MRP_QA_STATE:
 479                         /* send JOIN only if it improves encoding */
 480                         tx = 1;
 481                         optional = 1;
 482                         sndmsg = MRP_SND_JOIN;
 483                         break;
 484                 case MRP_LA_STATE:
 485                         /* send LV */
 486                         tx = 1;
 487                         sndmsg = MRP_SND_LV;
 488                         mrp_state = MRP_VO_STATE;
 489                         break;
 490                 case MRP_AO_STATE:
 491                 case MRP_QO_STATE:
 492                 case MRP_QP_STATE:
 493                         /* send <NULL> only if it improves encoding */
 494                         tx = 1;
 495                         optional = 1;
 496                         sndmsg = MRP_SND_IN;
 497                         break;
 498                 case MRP_LO_STATE:
 499                         /* send <NULL> */
 500                         tx = 1;
 501                         sndmsg = MRP_SND_IN;
 502                         mrp_state = MRP_VO_STATE;
 503                         break;
 504                 default:
 505                         break;
 506                 }
 507                 break;
 508         case MRP_EVENT_RNEW:
 509                 /* do nothing */
 510                 break;
 511
 512         case MRP_EVENT_RJOININ:
 513                 switch (mrp_state) {
 514                 case MRP_VO_STATE:
 515                         if (0 == p2pmac)
 516                                 mrp_state = MRP_AO_STATE;
 517                         break;
 518                 case MRP_VP_STATE:
 519                         if (0 == p2pmac) {
 520                                 mrp_state = MRP_AP_STATE;
 521                         }
 522                         break;
 523                 case MRP_AA_STATE:
 524                         mrp_state = MRP_QA_STATE;
 525                         break;
 526                 case MRP_AO_STATE:
 527                         mrp_state = MRP_QO_STATE;
 528                         break;
 529                 case MRP_AP_STATE:
 530                         mrp_state = MRP_QP_STATE;
 531                         break;
 532                 default:
 533                         break;
 534                 }
 535                 break;
 536         case MRP_EVENT_RIN:
 537                 switch (mrp_state) {
 538                 case MRP_AA_STATE:
 539                         if (1 == p2pmac)
 540                                 mrp_state = MRP_QA_STATE;
 541                         break;
 542                 default:
 543                         break;
 544                 }
 545                 break;
 546         case MRP_EVENT_RJOINMT:
 547         case MRP_EVENT_RMT:
 548                 switch (mrp_state) {
 549                 case MRP_QA_STATE:
 550                         mrp_state = MRP_AA_STATE;
 551                         break;
 552                 case MRP_QO_STATE:
 553                         mrp_state = MRP_AO_STATE;
 554                         break;
 555                 case MRP_QP_STATE:
 556                         mrp_state = MRP_AP_STATE;
 557                         break;
 558                 case MRP_LO_STATE:
 559                         mrp_state = MRP_VO_STATE;
 560                         break;
 561                 default:
 562                         break;
 563                 }
 564                 break;
 565
 566         case MRP_EVENT_RLV:
 567         case MRP_EVENT_RLA:
 568         case MRP_EVENT_REDECLARE:
 569                 switch (mrp_state) {
 570                 case MRP_VO_STATE:
 571                         mrp_state = MRP_LO_STATE;
 572                         break;
 573                 case MRP_AN_STATE:
 574                         mrp_state = MRP_VN_STATE;
 575                         break;
 576                 case MRP_QA_STATE:
 577                 case MRP_AA_STATE:
 578                         mrp_state = MRP_VP_STATE;
 579                         break;
 580                 case MRP_AO_STATE:
 581                 case MRP_QO_STATE:
 582                         mrp_state = MRP_LO_STATE;
 583                         break;
 584                 case MRP_AP_STATE:
 585                 case MRP_QP_STATE:
 586                         mrp_state = MRP_VP_STATE;
 587                         break;
 588                 default:
 589                         break;
 590                 }
 591                 break;
 592         case MRP_EVENT_PERIODIC:
 593                 switch (mrp_state) {
 594                 case MRP_QA_STATE:
 595                         mrp_state = MRP_AA_STATE;
 596                         break;
 597                 case MRP_QP_STATE:
 598                         mrp_state = MRP_AP_STATE;
 599                         break;
 600                 default:
 601                         break;
 602                 }
 603                 break;
 604
 605         default:
 606                 printf("mrp_applicant_fsm:unexpected event (%d)\n", event);
 607                 return -1;
 608                 break;
 609         }
 610
 611         attrib->tx = tx;
 612         attrib->mrp_state = mrp_state;
 613         attrib->sndmsg = sndmsg;
 614         attrib->encode = (optional ? MRP_ENCODE_OPTIONAL : MRP_ENCODE_YES);
 615         return 0;
 616 }
 617
 618 int
 619 mrp_registrar_fsm(mrp_registrar_attribute_t * attrib,
 620                   struct mrp_database *mrp_db, int event)
 621 {
 622         int mrp_state = attrib->mrp_state;
 623         int notify = MRP_NOTIFY_NONE;
 624
 625         switch (event) {
 626         case MRP_EVENT_BEGIN:
 627                 mrp_state = MRP_MT_STATE;
 628                 break;
 629         case MRP_EVENT_RLV:
 630                 notify = MRP_NOTIFY_LV;
 631                 /* fall thru */
 632         case MRP_EVENT_TXLA:
 633         case MRP_EVENT_RLA:
 634         case MRP_EVENT_REDECLARE:
 635                 /*
 636                  * on link-status-change
 637                  * trigger Applicant and Registrar state machines to re-declare
 638                  * previously registered attributes.
 639                  */
 640                 switch (mrp_state) {
 641                 case MRP_IN_STATE:
 642                         mrp_lvtimer_start(mrp_db);
 643                         mrp_state = MRP_LV_STATE;
 644                 default:
 645                         break;
 646                 }
 647                 break;
 648         case MRP_EVENT_RNEW:
 649                 notify = MRP_NOTIFY_NEW;
 650                 switch (mrp_state) {
 651                 case MRP_MT_STATE:
 652                 case MRP_IN_STATE:
 653                         mrp_state = MRP_IN_STATE;
 654                         break;
 655                 case MRP_LV_STATE:
 656                         /* should stop leavetimer - but we have only 1 lvtimer
 657                          * for all attributes, and recieving a LVTIMER event
 658                          * is a don't-care if the attribute is in the IN state.
 659                          */
 660                         mrp_state = MRP_IN_STATE;
 661                         break;
 662                 default:
 663                         break;
 664                 }
 665                 break;
 666         case MRP_EVENT_RJOININ:
 667         case MRP_EVENT_RJOINMT:
 668                 switch (mrp_state) {
 669                 case MRP_MT_STATE:
 670                         notify = MRP_NOTIFY_JOIN;
 671                         mrp_state = MRP_IN_STATE;
 672                         break;
 673                 case MRP_IN_STATE:
 674                         mrp_state = MRP_IN_STATE;
 675                         break;
 676                 case MRP_LV_STATE:
 677                         /* should stop leavetimer - but we have only 1 lvtimer
 678                          * for all attributes, and recieving a LVTIMER event
 679                          * is a don't-care if the attribute is in the IN state.
 680                          */
 681                         notify = MRP_NOTIFY_JOIN;
 682                         mrp_state = MRP_IN_STATE;
 683                         break;
 684                 default:
 685                         break;
 686                 }
 687                 break;
 688
 689         case MRP_EVENT_LVTIMER:
 690                 switch (mrp_state) {
 691                 case MRP_LV_STATE:
 692                         mrp_state = MRP_MT_STATE;
 693                         break;
 694                 case MRP_MT_STATE:
 695                         mrp_state = MRP_MT_STATE;
 696                         break;
 697                 case MRP_IN_STATE:
 698                 default:
 699                         break;
 700                 }
 701                 break;
 702         case MRP_EVENT_FLUSH:
 703                 notify = MRP_NOTIFY_LV;
 704                 switch (mrp_state) {
 705                 case MRP_LV_STATE:
 706                         mrp_state = MRP_MT_STATE;
 707                         break;
 708                 case MRP_MT_STATE:
 709                 case MRP_IN_STATE:
 710                         mrp_state = MRP_MT_STATE;
 711                         break;
 712                 default:
 713                         break;
 714                 }
 715                 break;
 716         case MRP_EVENT_RMT:
 717                 /* ignore on soon to be deleted attributes */
 718                 break;
 719         default:
 720                 printf("mrp_registrar_fsm:unexpected event (%d)\n", event);
 721                 return -1;
 722                 break;
 723         }
 724
 725         attrib->mrp_state = mrp_state;
 726         attrib->notify = notify;
 727         return 0;
 728 }
 729
 730 int mrp_decode_state(mrp_registrar_attribute_t * rattrib,
 731                      mrp_applicant_attribute_t * aattrib, char *str, int strlen)
 732 {
 733         char reg_stat[8];
 734
 735         switch (rattrib->mrp_state) {
 736         case MRP_IN_STATE:
 737                 snprintf(reg_stat, sizeof(reg_stat) - 1, "IN");
 738                 break;
 739         case MRP_LV_STATE:
 740                 snprintf(reg_stat, sizeof(reg_stat) - 1, "LV");
 741                 break;
 742         case MRP_MT_STATE:
 743                 snprintf(reg_stat, sizeof(reg_stat) - 1, "MT");
 744                 break;
 745         default:
 746                 snprintf(reg_stat, sizeof(reg_stat) - 1, "%d",
 747                          rattrib->mrp_state);
 748                 break;
 749         }
 750
 751         switch (aattrib->mrp_state) {
 752         case MRP_VO_STATE:
 753                 snprintf(str, strlen - 1, "VO/%s", reg_stat);
 754                 break;
 755         case MRP_VP_STATE:
 756                 snprintf(str, strlen - 1, "VP/%s", reg_stat);
 757                 break;
 758         case MRP_VN_STATE:
 759                 snprintf(str, strlen - 1, "VN/%s", reg_stat);
 760                 break;
 761         case MRP_AN_STATE:
 762                 snprintf(str, strlen - 1, "AN/%s", reg_stat);
 763                 break;
 764         case MRP_AA_STATE:
 765                 snprintf(str, strlen - 1, "AA/%s", reg_stat);
 766                 break;
 767         case MRP_QA_STATE:
 768                 snprintf(str, strlen - 1, "QA/%s", reg_stat);
 769                 break;
 770         case MRP_LA_STATE:
 771                 snprintf(str, strlen - 1, "LA/%s", reg_stat);
 772                 break;
 773         case MRP_AO_STATE:
 774                 snprintf(str, strlen - 1, "AO/%s", reg_stat);
 775                 break;
 776         case MRP_QO_STATE:
 777                 snprintf(str, strlen - 1, "QO/%s", reg_stat);
 778                 break;
 779         case MRP_AP_STATE:
 780                 snprintf(str, strlen - 1, "AP/%s", reg_stat);
 781                 break;
 782         case MRP_QP_STATE:
 783                 snprintf(str, strlen - 1, "QP/%s", reg_stat);
 784                 break;
 785         case MRP_LO_STATE:
 786                 snprintf(str, strlen - 1, "LO/%s", reg_stat);
 787                 break;
 788         default:
 789                 snprintf(str, strlen - 1, "%d/%s", aattrib->mrp_state,
 790                          reg_stat);
 791                 break;
 792         }
 793         return 0;
 794 }
 795
 796 int mrp_init(void)
 797 {
 798         p2pmac = 0;             /* operPointToPointMAC false by default */
 799         lva_next = MRP_LVATIMER_VAL;    /* leaveall timeout in msec */
 800
 801         return 0;
 802 }