bridge_track.c

   1 /*****************************************************************************
   2   Copyright (c) 2006 EMC Corporation.
   3
   4   This program is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU General Public License as published by the Free
   6   Software Foundation; either version 2 of the License, or (at your option)
   7   any later version.
   8
   9   This program is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12   more details.
  13
  14   You should have received a copy of the GNU General Public License along with
  15   this program; if not, write to the Free Software Foundation, Inc., 59
  16   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17
  18   The full GNU General Public License is included in this distribution in the
  19   file called LICENSE.
  20
  21   Authors: Srinivas Aji <Aji_Srinivas@emc.com>
  22
  23 ******************************************************************************/
  24
  25 #include "bridge_ctl.h"
  26 #include "netif_utils.h"
  27 #include "packet.h"
  28
  29 #include <unistd.h>
  30 #include <net/if.h>
  31 #include <stdlib.h>
  32 #include <linux/if_bridge.h>
  33 #include <arpa/inet.h>
  34 #include <sys/types.h>
  35
  36 #include <bitmap.h>
  37 #include <uid_stp.h>
  38 #include <stp_bpdu.h>
  39 #include <stp_in.h>
  40 #include <stp_to.h>
  41
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 #include "log.h"
  46
  47 /*------------------------------------------------------------*/
  48
  49 struct ifdata {
  50         int if_index;
  51         struct ifdata *next;
  52         int up;
  53         char name[IFNAMSIZ];
  54
  55         int is_bridge;
  56         /* If bridge */
  57         struct ifdata *bridge_next;
  58         struct ifdata *port_list;
  59         int do_stp;
  60         int stp_up;
  61         struct stp_instance *stp;
  62         UID_BRIDGE_ID_T bridge_id;
  63         /* Bridge config */
  64         UID_STP_MODE_T stp_enabled;
  65         int bridge_priority;
  66         int max_age;
  67         int hello_time;
  68         int forward_delay;
  69         int force_version;
  70         int hold_time;
  71
  72         /* If port */
  73         int speed;
  74         int duplex;
  75         struct ifdata *master;
  76         struct ifdata *port_next;
  77         /* STP port index */
  78         int port_index;
  79         /* STP port config */
  80         int port_priority;
  81         int admin_port_path_cost;
  82         ADMIN_P2P_T admin_point2point;
  83         unsigned char admin_edge;
  84         unsigned char admin_non_stp;    /* 1- doesn't participate in STP, 1 - regular */
  85
  86         struct epoll_event_handler event;
  87 };
  88
  89 /* Instances */
  90 struct ifdata *current_br = NULL;
  91
  92 void instance_begin(struct ifdata *br)
  93 {
  94         if (current_br) {
  95                 ERROR("BUG: Trying to set instance over existing instance.");
  96                 ERROR("%d", *(int *)0); /* ABORT */
  97         }
  98         current_br = br;
  99         STP_IN_instance_begin(br->stp);
 100 }
 101
 102 void instance_end(void)
 103 {
 104         STP_IN_instance_end(current_br->stp);
 105         current_br = NULL;
 106 }
 107
 108 struct ifdata *find_port(int port_index)
 109 {
 110         struct ifdata *ifc = current_br->port_list;
 111         while (ifc && ifc->port_index != port_index)
 112                 ifc = ifc->port_next;
 113         return ifc;
 114 }
 115
 116 /*************************************************************/
 117 /* Bridge and port defaults */
 118
 119 UID_STP_CFG_T default_bridge_stp_cfg = {
 120         .field_mask = BR_CFG_ALL,
 121         .bridge_priority = DEF_BR_PRIO,
 122         .max_age = DEF_BR_MAXAGE,
 123         .hello_time = DEF_BR_HELLOT,
 124         .forward_delay = DEF_BR_FWDELAY,
 125         .force_version = DEF_FORCE_VERS,        /*NORMAL_RSTP */
 126 };
 127
 128 void update_bridge_stp_config(struct ifdata *br, UID_STP_CFG_T * cfg)
 129 {
 130         if (cfg->field_mask & BR_CFG_PRIO)
 131                 br->bridge_priority = cfg->bridge_priority;
 132         if (cfg->field_mask & BR_CFG_AGE)
 133                 br->max_age = cfg->max_age;
 134         if (cfg->field_mask & BR_CFG_HELLO)
 135                 br->hello_time = cfg->hello_time;
 136         if (cfg->field_mask & BR_CFG_DELAY)
 137                 br->forward_delay = cfg->forward_delay;
 138         if (cfg->field_mask & BR_CFG_FORCE_VER)
 139                 br->force_version = cfg->force_version;
 140 }
 141
 142 UID_STP_PORT_CFG_T default_port_stp_cfg = {
 143         .field_mask = PT_CFG_ALL,
 144         .port_priority = DEF_PORT_PRIO,
 145         .admin_non_stp = DEF_ADMIN_NON_STP,
 146         .admin_edge = False,    // DEF_ADMIN_EDGE,
 147         .admin_port_path_cost = ADMIN_PORT_PATH_COST_AUTO,
 148         .admin_point2point = DEF_P2P,
 149 };
 150
 151 void update_port_stp_config(struct ifdata *ifc, UID_STP_PORT_CFG_T * cfg)
 152 {
 153         if (cfg->field_mask & PT_CFG_PRIO)
 154                 ifc->port_priority = cfg->port_priority;
 155         if (cfg->field_mask & PT_CFG_NON_STP)
 156                 ifc->admin_non_stp = cfg->admin_non_stp;
 157         if (cfg->field_mask & PT_CFG_EDGE)
 158                 ifc->admin_edge = cfg->admin_edge;
 159         if (cfg->field_mask & PT_CFG_COST)
 160                 ifc->admin_port_path_cost = cfg->admin_port_path_cost;
 161         if (cfg->field_mask & PT_CFG_P2P)
 162                 ifc->admin_point2point = cfg->admin_point2point;
 163 }
 164
 165 /**************************************************************/
 166
 167 int add_port_stp(struct ifdata *ifc)
 168 {                               /* Bridge is ifc->master */
 169         TST((ifc->port_index = get_bridge_portno(ifc->name)) >= 0, -1);
 170
 171         /* Add port to STP */
 172         instance_begin(ifc->master);
 173         int r = STP_IN_port_create(0, ifc->port_index);
 174         if (r == 0) {           /* Update bridge ID */
 175                 UID_STP_STATE_T state;
 176                 STP_IN_stpm_get_state(0, &state);
 177                 ifc->master->bridge_id = state.bridge_id;
 178         }
 179         instance_end();
 180         if (r /* check for failure */ ) {
 181                 ERROR("Couldn't add port for ifindex %d to STP", ifc->if_index);
 182                 return -1;
 183         }
 184         return 0;
 185 }
 186
 187 void remove_port_stp(struct ifdata *ifc)
 188 {
 189         /* Remove port from STP */
 190         instance_begin(ifc->master);
 191         int r = STP_IN_port_delete(0, ifc->port_index);
 192         instance_end();
 193         ifc->port_index = -1;
 194         if (r != 0) {
 195                 ERROR("removing port %s failed for bridge %s: %s",
 196                       ifc->name, ifc->master->name,
 197                       STP_IN_get_error_explanation(r));
 198         }
 199 }
 200
 201 int init_rstplib_instance(struct ifdata *br)
 202 {
 203         br->stp = STP_IN_instance_create();
 204         if (br->stp == NULL) {
 205                 ERROR("Couldn't create STP instance for bridge %s", br->name);
 206                 return -1;
 207         }
 208
 209         BITMAP_T ports;
 210         BitmapClear(&ports);
 211         instance_begin(br);
 212         int r = STP_IN_stpm_create(0, br->name, &ports);
 213         instance_end();
 214         if (r != 0) {
 215                 ERROR("stpm create failed for bridge %s: %s",
 216                       br->name, STP_IN_get_error_explanation(r));
 217                 return -1;
 218         }
 219
 220         return 0;
 221 }
 222
 223 void clear_rstplib_instance(struct ifdata *br)
 224 {
 225         instance_begin(br);
 226         int r = STP_IN_delete_all();
 227         instance_end();
 228         if (r != 0) {
 229                 ERROR("stpm delete failed for bridge %s: %s",
 230                       br->name, STP_IN_get_error_explanation(r));
 231         }
 232
 233         STP_IN_instance_delete(br->stp);
 234         br->stp = NULL;
 235 }
 236
 237 int init_bridge_stp(struct ifdata *br)
 238 {
 239         if (br->stp_up) {
 240                 ERROR("STP already started");
 241                 return 0;
 242         }
 243
 244         /* Init STP state */
 245         TST(init_rstplib_instance(br) == 0, -1);
 246
 247         struct ifdata *p = br->port_list;
 248         while (p) {
 249                 if (add_port_stp(p) != 0)
 250                         break;
 251                 p = p->port_next;
 252         }
 253         if (p) {
 254                 struct ifdata *q = br->port_list;
 255                 while (q != p) {
 256                         remove_port_stp(q);
 257                         q = q->port_next;
 258                 }
 259                 /* Clear bridge STP state */
 260                 clear_rstplib_instance(br);
 261                 return -1;
 262         }
 263         br->stp_up = 1;
 264         return 0;
 265 }
 266
 267 void clear_bridge_stp(struct ifdata *br)
 268 {
 269         if (!br->stp_up)
 270                 return;
 271         br->stp_up = 0;
 272         struct ifdata *p = br->port_list;
 273         while (p) {
 274                 remove_port_stp(p);
 275                 p = p->port_next;
 276         }
 277         /* Clear bridge STP state */
 278         clear_rstplib_instance(br);
 279 }
 280
 281 struct ifdata *if_head = NULL;
 282 struct ifdata *br_head = NULL;
 283
 284 struct ifdata *find_if(int if_index)
 285 {
 286         struct ifdata *p = if_head;
 287         while (p && p->if_index != if_index)
 288                 p = p->next;
 289         return p;
 290 }
 291
 292 #define ADD_TO_LIST(_list, _next, _ifc) \
 293     do { \
 294       (_ifc)->_next = (_list); \
 295       (_list) = (_ifc); \
 296     } while (0)
 297
 298 #define REMOVE_FROM_LIST(_list, _next, _ifc, _error_fmt, _args...) \
 299     do { \
 300       struct ifdata **_prev = &(_list); \
 301       while (*_prev && *_prev != (_ifc)) \
 302         _prev = &(*_prev)->_next; \
 303       if (*_prev != (_ifc)) \
 304         ERROR(_error_fmt, ##_args); \
 305       else \
 306         *_prev = (_ifc)->_next; \
 307     } while (0)
 308
 309 /* Caller ensures that there isn't any ifdata with this index */
 310 /* If br is NULL, new interface is a bridge, else it is a port of br */
 311 struct ifdata *create_if(int if_index, struct ifdata *br)
 312 {
 313         struct ifdata *p;
 314         TST((p = malloc(sizeof(*p))) != NULL, NULL);
 315
 316         memset(p, 0, sizeof(*p));
 317
 318         /* Init fields */
 319         p->if_index = if_index;
 320         p->is_bridge = (br == NULL);
 321
 322         /* TODO: purge use of name, due to issue with renameing */
 323         if_indextoname(if_index, p->name);
 324
 325         if (p->is_bridge) {
 326                 INFO("Add bridge %s", p->name);
 327                 /* Init slave list */
 328                 p->port_list = NULL;
 329
 330                 p->do_stp = 0;
 331                 p->up = 0;
 332                 p->stp_up = 0;
 333                 p->stp = NULL;
 334                 update_bridge_stp_config(p, &default_bridge_stp_cfg);
 335                 ADD_TO_LIST(br_head, bridge_next, p);   /* Add to bridge list */
 336         } else {
 337                 INFO("Add iface %s to bridge %s", p->name, br->name);
 338                 p->up = 0;
 339                 p->speed = 0;
 340                 p->duplex = 0;
 341                 p->master = br;
 342
 343                 update_port_stp_config(p, &default_port_stp_cfg);
 344                 ADD_TO_LIST(br->port_list, port_next, p);       /* Add to bridge port list */
 345
 346                 if (br->stp_up) {
 347                         add_port_stp(p);
 348                 }
 349         }
 350
 351         /* Add to interface list */
 352         ADD_TO_LIST(if_head, next, p);
 353
 354         return p;
 355 }
 356
 357 void delete_if(struct ifdata *ifc)
 358 {
 359         INFO("Delete iface %s", ifc->name);
 360         if (ifc->is_bridge) {   /* Bridge: */
 361                 /* Stop STP */
 362                 clear_bridge_stp(ifc);
 363                 /* Delete ports */
 364                 while (ifc->port_list)
 365                         delete_if(ifc->port_list);
 366                 /* Remove from bridge list */
 367                 REMOVE_FROM_LIST(br_head, bridge_next, ifc,
 368                                  "Can't find interface ifindex %d bridge list",
 369                                  ifc->if_index);
 370         } else {                /* Port */
 371                 if (ifc->master->stp_up)
 372                         remove_port_stp(ifc);
 373                 /* Remove from bridge port list */
 374                 REMOVE_FROM_LIST(ifc->master->port_list, port_next, ifc,
 375                                  "Can't find interface ifindex %d on br %d's port list",
 376                                  ifc->if_index, ifc->master->if_index);
 377         }
 378
 379         /* Remove from bridge interface list */
 380         REMOVE_FROM_LIST(if_head, next, ifc,
 381                          "Can't find interface ifindex %d on iflist",
 382                          ifc->if_index);
 383         free(ifc);
 384 }
 385
 386 static int stp_enabled(struct ifdata *br)
 387 {
 388         char path[40 + IFNAMSIZ];
 389         sprintf(path, "/sys/class/net/%s/bridge/stp_state", br->name);
 390         FILE *f = fopen(path, "r");
 391         if (!f) {
 392                 LOG("Open %s failed", path);
 393                 return 0;
 394         }
 395         int enabled = 0;
 396         fscanf(f, "%d", &enabled);
 397         fclose(f);
 398         INFO("STP on %s state %d", br->name, enabled);
 399
 400         return enabled == 2;    /* ie user mode STP */
 401 }
 402
 403 void set_br_up(struct ifdata *br, int up)
 404 {
 405         int stp_up = stp_enabled(br);
 406         INFO("%s was %s stp was %s", br->name,up ? "up" : "down", br->stp_up ? "up" : "down");
 407         INFO("Set bridge %s %s stp %s" , br->name,
 408              up ? "up" : "down", stp_up ? "up" : "down");
 409
 410         if (up != br->up)
 411                 br->up = up;
 412
 413         if (br->stp_up != stp_up) {
 414                 if (stp_up)
 415                         init_bridge_stp(br);
 416                 else
 417                         clear_bridge_stp(br);
 418         }
 419 }
 420
 421 void set_if_up(struct ifdata *ifc, int up)
 422 {
 423         INFO("Port %s : %s", ifc->name, (up ? "up" : "down"));
 424         int speed = -1;
 425         int duplex = -1;
 426         int notify_flags = 0;
 427         const int NOTIFY_UP = 1, NOTIFY_SPEED = 2, NOTIFY_DUPLEX = 4;
 428         if (!up) {              /* Down */
 429                 if (ifc->up) {
 430                         ifc->up = up;
 431                         notify_flags |= NOTIFY_UP;
 432                 }
 433         } else {                /* Up */
 434                 int r = ethtool_get_speed_duplex(ifc->name, &speed, &duplex);
 435                 if (r < 0) {    /* Didn't succeed */
 436                 }
 437                 if (speed < 0)
 438                         speed = 10;
 439                 if (duplex < 0)
 440                         duplex = 0;     /* Assume half duplex */
 441
 442                 if (speed != ifc->speed) {
 443                         ifc->speed = speed;
 444                         notify_flags |= NOTIFY_SPEED;
 445                 }
 446                 if (duplex != ifc->duplex) {
 447                         ifc->duplex = duplex;
 448                         notify_flags |= NOTIFY_DUPLEX;
 449                 }
 450                 if (!ifc->up) {
 451                         ifc->up = 1;
 452                         notify_flags |= NOTIFY_UP;
 453                 }
 454         }
 455         if (notify_flags && ifc->master->stp_up) {
 456                 instance_begin(ifc->master);
 457
 458                 if (notify_flags & NOTIFY_SPEED)
 459                         STP_IN_changed_port_speed(ifc->port_index, speed);
 460                 if (notify_flags & NOTIFY_DUPLEX)
 461                         STP_IN_changed_port_duplex(ifc->port_index);
 462                 if (notify_flags & NOTIFY_UP)
 463                         STP_IN_enable_port(ifc->port_index, ifc->up);
 464
 465                 instance_end();
 466         }
 467 }
 468
 469 /*------------------------------------------------------------*/
 470
 471 int bridge_notify(int br_index, int if_index, int newlink, int up)
 472 {
 473         if (up)
 474                 up = 1;
 475         LOG("br_index %d, if_index %d, up %d", br_index, if_index, up);
 476
 477         struct ifdata *br = NULL;
 478         if (br_index >= 0) {
 479                 br = find_if(br_index);
 480                 if (br && !br->is_bridge) {
 481                         ERROR
 482                             ("Notification shows non bridge interface %d as bridge.",
 483                              br_index);
 484                         return -1;
 485                 }
 486                 if (!br)
 487                         br = create_if(br_index, NULL);
 488                 if (!br) {
 489                         ERROR("Couldn't create data for bridge interface %d",
 490                               br_index);
 491                         return -1;
 492                 }
 493                 /* Bridge must be up if we get such notifications */
 494                 if (!br->up)
 495                         set_br_up(br, 1);
 496         }
 497
 498         struct ifdata *ifc = find_if(if_index);
 499
 500         if (br) {
 501                 if (ifc) {
 502                         if (ifc->is_bridge) {
 503                                 ERROR
 504                                     ("Notification shows bridge interface %d as slave of %d",
 505                                      if_index, br_index);
 506                                 return -1;
 507                         }
 508                         if (ifc->master != br) {
 509                                 INFO("Device %d has come to bridge %d. "
 510                                      "Missed notify for deletion from bridge %d",
 511                                      if_index, br_index, ifc->master->if_index);
 512                                 delete_if(ifc);
 513                                 ifc = NULL;
 514                         }
 515                 }
 516                 if (!ifc) {
 517                         if (!newlink) {
 518                                 INFO("Got DELLINK for unknown port %d on "
 519                                      "bridge %d", if_index, br_index);
 520                                 return -1;
 521                         }
 522                         ifc = create_if(if_index, br);
 523                 }
 524                 if (!ifc) {
 525                         ERROR
 526                             ("Couldn't create data for interface %d (master %d)",
 527                              if_index, br_index);
 528                         return -1;
 529                 }
 530                 if (!newlink) {
 531                         delete_if(ifc);
 532                         return 0;
 533                 }
 534                 if (ifc->up != up)
 535                         set_if_up(ifc, up);     /* And speed and duplex */
 536         } else {                /* No br_index */
 537                 if (!newlink) {
 538                         /* DELLINK not from bridge means interface unregistered. */
 539                         /* Cleanup removed bridge or removed bridge slave */
 540                         if (ifc)
 541                                 delete_if(ifc);
 542                         return 0;
 543                 } else {        /* This may be a new link */
 544                         if (!ifc) {
 545                                 char ifname[IFNAMSIZ];
 546                                 if (if_indextoname(if_index, ifname)
 547                                     && is_bridge(ifname)) {
 548                                         ifc = create_if(if_index, NULL);
 549                                         if (!ifc) {
 550                                                 ERROR
 551                                                     ("Couldn't create data for bridge interface %d",
 552                                                      if_index);
 553                                                 return -1;
 554                                         }
 555                                 }
 556                         }
 557                         if (ifc && ifc->up != up) {
 558                                 if (ifc->is_bridge)
 559                                         set_br_up(ifc, up);
 560                                 else
 561                                         set_if_up(ifc, up);
 562                         }
 563                 }
 564         }
 565         return 0;
 566 }
 567
 568 void bridge_bpdu_rcv(int if_index, const unsigned char *data, int len)
 569 {
 570         struct ifdata *ifc = find_if(if_index);
 571         BPDU_T *bpdu = (BPDU_T *) (data + sizeof(MAC_HEADER_T));
 572
 573         LOG("ifindex %d, len %d", if_index, len);
 574         if (!ifc)
 575                 return;
 576
 577         TST(ifc->up,);
 578         TST(ifc->master->stp_up,);
 579         TST(len > sizeof(MAC_HEADER_T) + sizeof(ETH_HEADER_T) + sizeof(BPDU_HEADER_T),);
 580
 581         /* Do some validation */
 582         if (bpdu->hdr.protocol[0] || bpdu->hdr.protocol[1])
 583                 return;
 584
 585         switch (bpdu->hdr.bpdu_type) {
 586         case BPDU_RSTP:
 587                 TST(len >= 36,);
 588         case BPDU_CONFIG_TYPE:
 589                 TST(len >= 35,);
 590                 /* 802.1w doesn't ask for this */
 591                 //    TST(ntohs(*(uint16_t*)bpdu.body.message_age)
 592                 //        < ntohs(*(uint16_t*)bpdu.body.max_age), );
 593                 TST(memcmp(bpdu->body.bridge_id, &ifc->master->bridge_id, 8) != 0
 594                     || (ntohs(*(uint16_t *) bpdu->body.port_id) & 0xfff) !=
 595                     ifc->port_index,);
 596                 break;
 597         case BPDU_TOPO_CHANGE_TYPE:
 598                 break;
 599         default:
 600                 LOG("Receive unknown bpdu type %x", bpdu->hdr.bpdu_type);
 601                 return;
 602         }
 603
 604         // dump_hex(data, len);
 605         instance_begin(ifc->master);
 606         int r = STP_IN_rx_bpdu(0, ifc->port_index, bpdu, len);
 607         if (r)
 608                 ERROR("STP_IN_rx_bpdu on port %s returned %s", ifc->name,
 609                       STP_IN_get_error_explanation(r));
 610         instance_end();
 611 }
 612
 613 void bridge_one_second(void)
 614 {
 615         //  LOG("");
 616         struct ifdata *br;
 617         for (br = br_head; br; br = br->bridge_next) {
 618                 if (br->stp_up) {
 619                         instance_begin(br);
 620                         STP_IN_one_second();
 621                         instance_end();
 622                 }
 623         }
 624
 625         /* To get information about port changes when bridge is down */
 626         /* But won't work so well since we will not sense deletions */
 627         static int count = 0;
 628         count++;
 629         if (count % 60 == 0)
 630                 bridge_get_configuration();
 631
 632 }
 633
 634 /* Implementing STP_OUT functions */
 635
 636 int flush_port(char *sys_name)
 637 {
 638         FILE *f = fopen(sys_name, "w");
 639         TSTM(f, -1, "Couldn't open flush file %s for write.", sys_name);
 640         int r = fwrite("1", 1, 1, f);
 641         fclose(f);
 642         TST(r == 1, -1);
 643         return 0;
 644 }
 645
 646 int
 647 STP_OUT_flush_lt(IN int port_index, IN int vlan_id,
 648                  IN LT_FLASH_TYPE_T type, IN char *reason)
 649 {
 650         LOG("port index %d, flash type %d, reason %s", port_index, type,
 651             reason);
 652         TST(vlan_id == 0, 0);
 653
 654         char fname[128];
 655         if (port_index == 0) {  /* i.e. passed port_index was 0 */
 656                 sprintf(fname, "/sys/class/net/%s/bridge/flush",
 657                         current_br->name);
 658                 flush_port(fname);
 659         } else if (type == LT_FLASH_ONLY_THE_PORT) {
 660                 struct ifdata *port = find_port(port_index);
 661                 TST(port != NULL, 0);
 662                 sprintf(fname, "/sys/class/net/%s/brif/%s/flush",
 663                         current_br->name, port->name);
 664                 flush_port(fname);
 665         } else if (type == LT_FLASH_ALL_PORTS_EXCLUDE_THIS) {
 666                 struct ifdata *port;
 667                 for (port = current_br->port_list; port; port = port->port_next) {
 668                         if (port->port_index != port_index) {
 669                                 sprintf(fname,
 670                                         "/sys/class/net/%s/brif/%s/flush",
 671                                         current_br->name, port->name);
 672                                 flush_port(fname);
 673                         }
 674                 }
 675         } else
 676                 TST(0, 0);
 677
 678         return 0;
 679 }
 680
 681 void /* for bridge id calculation */ STP_OUT_get_port_mac(IN int port_index,
 682                                                           OUT unsigned char
 683                                                           *mac)
 684 {
 685         LOG("port index %d", port_index);
 686         struct ifdata *port = find_port(port_index);
 687         TST(port != NULL,);
 688         get_hwaddr(port->name, mac);
 689 }
 690
 691 unsigned long STP_OUT_get_port_oper_speed(IN unsigned int port_index)
 692 {
 693         LOG("port index %d", port_index);
 694         struct ifdata *port = find_port(port_index);
 695         TST(port != NULL, 0);
 696         LOG("Speed: %d", port->speed);
 697         return port->speed;
 698 }
 699
 700 int /* 1- Up, 0- Down */ STP_OUT_get_port_link_status(IN int port_index)
 701 {
 702         LOG("port index %d", port_index);
 703         struct ifdata *port = find_port(port_index);
 704         TST(port != NULL, 0);
 705         LOG("Link status: %d", port->up);
 706         return port->up;
 707 }
 708
 709 int /* 1- Full, 0- Half */ STP_OUT_get_duplex(IN int port_index)
 710 {
 711         LOG("port index %d", port_index);
 712         struct ifdata *port = find_port(port_index);
 713         TST(port != NULL, 0);
 714         LOG("Duplex: %d", port->duplex);
 715         return port->duplex;
 716 }
 717
 718 int
 719 STP_OUT_set_port_state(IN int port_index, IN int vlan_id,
 720                        IN RSTP_PORT_STATE state)
 721 {
 722         LOG("port index %d, state %d", port_index, state);
 723         struct ifdata *port = find_port(port_index);
 724         TST(port != NULL, 0);
 725         TST(vlan_id == 0, 0);
 726
 727         int br_state;
 728         switch (state) {
 729         case UID_PORT_DISCARDING:
 730                 br_state = BR_STATE_BLOCKING;
 731                 break;
 732         case UID_PORT_LEARNING:
 733                 br_state = BR_STATE_LEARNING;
 734                 break;
 735         case UID_PORT_FORWARDING:
 736                 br_state = BR_STATE_FORWARDING;
 737                 break;
 738         default:
 739                 fprintf(stderr, "set_port_state: Unexpected state %d\n", state);
 740                 return -1;
 741         }
 742         if (port->up)
 743                 bridge_set_state(port->if_index, br_state);
 744         return 0;
 745 }
 746
 747 int STP_OUT_set_hardware_mode(int vlan_id, UID_STP_MODE_T mode)
 748 {
 749         LOG("vlan id %d, mode %d", vlan_id, mode);
 750         return 0;
 751 }
 752
 753 int
 754 STP_OUT_tx_bpdu(IN int port_index, IN int vlan_id,
 755                 IN unsigned char *bpdu, IN size_t bpdu_len)
 756 {
 757         LOG("port index %d, len %zd", port_index, bpdu_len);
 758         struct ifdata *port = find_port(port_index);
 759         TST(port != NULL, 0);
 760         TST(vlan_id == 0, 0);
 761
 762         packet_send(port->if_index, bpdu,
 763                     bpdu_len + sizeof(MAC_HEADER_T) + sizeof(ETH_HEADER_T));
 764         return 0;
 765 }
 766
 767 const char *STP_OUT_get_port_name(IN int port_index)
 768 {
 769         LOG("port index %d", port_index);
 770         struct ifdata *port = find_port(port_index);
 771         TST(port != NULL, 0);
 772         return port->name;
 773 }
 774
 775 int STP_OUT_get_init_stpm_cfg(IN int vlan_id, INOUT UID_STP_CFG_T * cfg)
 776 {
 777         LOG("");
 778         TST(vlan_id == 0, 0);
 779
 780         cfg->bridge_priority = current_br->bridge_priority;
 781         cfg->max_age = current_br->max_age;
 782         cfg->hello_time = current_br->hello_time;
 783         cfg->forward_delay = current_br->forward_delay;
 784         cfg->force_version = current_br->force_version;
 785
 786         return 0;
 787 }
 788
 789 int
 790 STP_OUT_get_init_port_cfg(IN int vlan_id,
 791                           IN int port_index, INOUT UID_STP_PORT_CFG_T * cfg)
 792 {
 793         LOG("port index %d", port_index);
 794         struct ifdata *port = find_port(port_index);
 795         TST(port != NULL, 0);
 796         TST(vlan_id == 0, 0);
 797
 798         cfg->port_priority = port->port_priority;
 799         cfg->admin_non_stp = port->admin_non_stp;
 800         cfg->admin_edge = port->admin_edge;
 801         cfg->admin_port_path_cost = port->admin_port_path_cost;
 802         cfg->admin_point2point = port->admin_point2point;
 803
 804         return 0;
 805 }
 806
 807 extern void stp_trace(const char *fmt, ...)
 808 {
 809         va_list ap;
 810         va_start(ap, fmt);
 811         vDprintf(LOG_LEVEL_RSTPLIB, fmt, ap);
 812         va_end(ap);
 813 }
 814
 815 /* Commands and status */
 816 #include "ctl_functions.h"
 817
 818 #define CTL_CHECK_BRIDGE \
 819   struct ifdata *br = find_if(br_index); \
 820   if (br == NULL || !br->is_bridge) return Err_Interface_not_a_bridge; \
 821   if (!br->do_stp) return Err_Bridge_RSTP_not_enabled; \
 822   if (!br->stp_up) return Err_Bridge_is_down; \
 823   do { } while (0)
 824
 825 #define CTL_CHECK_BRIDGE_PORT \
 826   CTL_CHECK_BRIDGE; \
 827   struct ifdata *port = find_if(port_index); \
 828   if (port == NULL || port->is_bridge || port->master != br) \
 829     return Err_Port_does_not_belong_to_bridge; \
 830   do { } while (0)
 831
 832 int CTL_enable_bridge_rstp(int br_index, int enable)
 833 {
 834         INFO("bridge %d, enable %d", br_index, enable);
 835         int r = 0;
 836         if (enable)
 837                 enable = 1;
 838         struct ifdata *br = find_if(br_index);
 839         if (br == NULL) {
 840                 char ifname[IFNAMSIZ];
 841                 if (if_indextoname(br_index, ifname) && is_bridge(ifname))
 842                         br = create_if(br_index, NULL);
 843         }
 844         if (br == NULL || !br->is_bridge)
 845                 return Err_Interface_not_a_bridge;
 846         if (br->do_stp != enable) {
 847                 br->do_stp = enable;
 848                 if (br->up)
 849                         r = enable ? init_bridge_stp(br)
 850                             : (clear_bridge_stp(br), 0);
 851         }
 852         return r;
 853 }
 854
 855 int CTL_get_bridge_state(int br_index,
 856                          UID_STP_CFG_T * cfg, UID_STP_STATE_T * state)
 857 {
 858         LOG("bridge %d", br_index);
 859         CTL_CHECK_BRIDGE;
 860         int r;
 861         instance_begin(br);
 862         r = STP_IN_stpm_get_state(0, state);
 863         if (r) {
 864                 ERROR("Error getting bridge state for %d: %s", br_index,
 865                       STP_IN_get_error_explanation(r));
 866                 instance_end();
 867                 return r;
 868         }
 869         r = STP_IN_stpm_get_cfg(0, cfg);
 870         if (r) {
 871                 ERROR("Error getting bridge config for %d: %s", br_index,
 872                       STP_IN_get_error_explanation(r));
 873                 instance_end();
 874                 return r;
 875         }
 876         instance_end();
 877         return 0;
 878 }
 879
 880 int CTL_set_bridge_config(int br_index, UID_STP_CFG_T * cfg)
 881 {
 882         INFO("bridge %d, flags %#lx", br_index, cfg->field_mask);
 883         CTL_CHECK_BRIDGE;
 884         int r;
 885         instance_begin(br);
 886         r = STP_IN_stpm_set_cfg(0, NULL, cfg);
 887         if (r) {
 888                 ERROR("Error setting bridge config for %d: %s", br_index,
 889                       STP_IN_get_error_explanation(r));
 890                 instance_end();
 891                 return r;
 892         }
 893         instance_end();
 894         /* Change init config in ifdata so it will be applied if we
 895            disable and enable rstp */
 896         update_bridge_stp_config(br, cfg);
 897         return 0;
 898 }
 899
 900 int CTL_get_port_state(int br_index, int port_index,
 901                        UID_STP_PORT_CFG_T * cfg, UID_STP_PORT_STATE_T * state)
 902 {
 903         LOG("bridge %d port %d", br_index, port_index);
 904         CTL_CHECK_BRIDGE_PORT;
 905         int r;
 906         instance_begin(br);
 907         state->port_no = port->port_index;
 908         r = STP_IN_port_get_state(0, state);
 909         if (r) {
 910                 ERROR("Error getting port state for port %d, bridge %d: %s",
 911                       port->port_index, br_index,
 912                       STP_IN_get_error_explanation(r));
 913                 instance_end();
 914                 return r;
 915         }
 916         r = STP_IN_port_get_cfg(0, port->port_index, cfg);
 917         if (r) {
 918                 ERROR("Error getting port config for port %d, bridge %d: %s",
 919                       port->port_index, br_index,
 920                       STP_IN_get_error_explanation(r));
 921                 instance_end();
 922                 return r;
 923         }
 924         instance_end();
 925         return 0;
 926
 927 }
 928
 929 int CTL_set_port_config(int br_index, int port_index, UID_STP_PORT_CFG_T * cfg)
 930 {
 931         INFO("bridge %d, port %d, flags %#lx", br_index, port_index,
 932              cfg->field_mask);
 933         CTL_CHECK_BRIDGE_PORT;
 934         int r;
 935         instance_begin(br);
 936         r = STP_IN_set_port_cfg(0, port->port_index, cfg);
 937         if (r) {
 938                 ERROR("Error setting port config for port %d, bridge %d: %s",
 939                       port->port_index, br_index,
 940                       STP_IN_get_error_explanation(r));
 941                 instance_end();
 942                 return r;
 943         }
 944         instance_end();
 945         /* Change init config in ifdata so it will be applied if we
 946            disable and enable rstp */
 947         update_port_stp_config(port, cfg);
 948         return 0;
 949 }
 950
 951 int CTL_set_debug_level(int level)
 952 {
 953         INFO("level %d", level);
 954         log_level = level;
 955         return 0;
 956 }
 957
 958 #undef CTL_CHECK_BRIDGE_PORT
 959 #undef CTL_CHECK_BRIDGE