KernelLand/Modules/IPStack/routing.c

   1 /*
   2  * Acess2 IP Stack
   3  * - Routing Tables
   4  */
   5 #define DEBUG   0
   6 #define VERSION VER2(0,10)
   7 #include <acess.h>
   8 #include <api_drv_common.h>
   9 #include "ipstack.h"
  10 #include "link.h"
  11
  12 #define DEFAUTL_METRIC  30
  13
  14 // === IMPORTS ===
  15 extern tInterface       *gIP_Interfaces;
  16 extern tVFS_Node        *IPStack_Root_FindDir(tVFS_Node *Node, const char *Filename);
  17
  18 // === PROTOTYPES ===
  19 // - Routes directory
  20 char    *IPStack_RouteDir_ReadDir(tVFS_Node *Node, int Pos);
  21 tVFS_Node       *IPStack_RouteDir_FindDir(tVFS_Node *Node, const char *Name);
  22  int    IPStack_RouteDir_MkNod(tVFS_Node *Node, const char *Name, Uint Flags);
  23  int    IPStack_RouteDir_Relink(tVFS_Node *Node, const char *OldName, const char *NewName);
  24 tRoute  *_Route_FindExactRoute(int Type, void *Network, int Subnet, int Metric);
  25  int    _Route_ParseRouteName(const char *Name, void *Addr, int *SubnetBits, int *Metric);
  26  int    IPStack_RouteDir_IOCtl(tVFS_Node *Node, int ID, void *Data);
  27 // - Route Management
  28 tRoute  *IPStack_Route_Create(int AddrType, void *Network, int SubnetBits, int Metric);
  29 tRoute  *IPStack_AddRoute(const char *Interface, void *Network, int SubnetBits, void *NextHop, int Metric);
  30 tRoute  *_Route_FindInterfaceRoute(int AddressType, void *Address);
  31 tRoute  *IPStack_FindRoute(int AddressType, tInterface *Interface, void *Address);
  32 // - Individual Routes
  33  int    IPStack_Route_IOCtl(tVFS_Node *Node, int ID, void *Data);
  34
  35 // === GLOBALS ===
  36  int    giIP_NextRouteId = 1;
  37 tRoute  *gIP_Routes;
  38 tRoute  *gIP_RoutesEnd;
  39 tVFS_NodeType   gIP_RouteNodeType = {
  40         .IOCtl = IPStack_Route_IOCtl
  41 };
  42 tVFS_NodeType   gIP_RouteDirNodeType = {
  43         .ReadDir = IPStack_RouteDir_ReadDir,
  44         .FindDir = IPStack_RouteDir_FindDir,
  45         .MkNod = IPStack_RouteDir_MkNod,
  46         .Relink = IPStack_RouteDir_Relink,
  47         .IOCtl = IPStack_RouteDir_IOCtl
  48 };
  49 tVFS_Node       gIP_RouteNode = {
  50         .Flags = VFS_FFLAG_DIRECTORY,
  51         .Size = -1,
  52         .NumACLs = 1,
  53         .ACLs = &gVFS_ACL_EveryoneRX,
  54         .Type = &gIP_RouteDirNodeType
  55 };
  56
  57 // === CODE ===
  58 /**
  59  * \brief ReadDir for the /Devices/ip/routes/ directory
  60  */
  61 char *IPStack_RouteDir_ReadDir(tVFS_Node *Node, int Pos)
  62 {
  63         tRoute  *rt;
  64
  65         for(rt = gIP_Routes; rt && Pos --; rt = rt->Next);
  66         if( !rt )       return NULL;
  67
  68         {
  69                  int    addrlen = IPStack_GetAddressSize(rt->AddressType);
  70                  int    len = sprintf(NULL, "%i::%i:%i", rt->AddressType, rt->SubnetBits, rt->Metric) + addrlen*2;
  71                 char    buf[len+1];
  72                  int    ofs;
  73                 ofs = sprintf(buf, "%i:", rt->AddressType);
  74                 ofs += Hex(buf+ofs, addrlen, rt->Network);
  75                 sprintf(buf+ofs, ":%i:%i", rt->SubnetBits, rt->Metric);
  76                 return strdup(buf);
  77         }
  78 }
  79
  80 /**
  81  * \brief FindDir for the /Devices/ip/routes/ directory
  82  */
  83 tVFS_Node *IPStack_RouteDir_FindDir(tVFS_Node *Node, const char *Name)
  84 {
  85         // Interpret the name as <type>:<addr>, returning the interface for
  86         // needed to access that address.
  87         //   E.g. '@4:0A02000A' - 10.2.0.10
  88         // Hm... It could do with a way to have a better address type representation
  89         if( Name[0] == '@' )
  90         {
  91                 tRoute  *rt;
  92                  int    ofs = 1;
  93                  int    type;
  94
  95                 ofs += ParseInt(Name+ofs, &type);
  96                  int    addrSize = IPStack_GetAddressSize(type);
  97                 Uint8   addrData[addrSize];
  98
  99                 // Separator
 100                 if( Name[ofs] != ':' )  return NULL;
 101                 ofs ++;
 102
 103                 // Error if the size is invalid
 104                 if( strlen(Name+ofs) != addrSize*2 )
 105                         return NULL;
 106
 107                 // Parse the address
 108                 // - Error if the address data is not fully hex
 109                 if( UnHex(addrData, addrSize, Name + ofs) != addrSize )
 110                         return NULL;
 111
 112                 // Find the route
 113                 rt = IPStack_FindRoute(type, NULL, addrData);
 114                 if(!rt) return NULL;
 115
 116                 if( !rt->Interface )
 117                 {
 118                         LOG("Why does this route not have a node? trying to find an iface for the next hop");
 119
 120                         rt = _Route_FindInterfaceRoute(type, rt->NextHop);
 121                         if(!rt) {
 122                                 Log_Notice("Cannot find route to next hop '%s'",
 123                                         IPStack_PrintAddress(type, rt->NextHop));
 124                                 return NULL;
 125                         }
 126                 }
 127                 if( !rt->Interface ) {
 128                         Log_Notice("Routes", "No interface for route %p, what the?", rt);
 129                         return NULL;
 130                 }
 131                 // Return the interface node
 132                 // - Sure it's hijacking it from inteface.c's area, but it's
 133                 //   simpler this way
 134                 return &rt->Interface->Node;
 135         }
 136         else if( Name[0] == '#' )
 137         {
 138                 int num, ofs = 1;
 139
 140                 ofs = ParseInt(Name+ofs, &num);
 141                 if( ofs == 1 )  return NULL;
 142                 if( Name[ofs] != '\0' ) return NULL;
 143                 if( num < 0)    return NULL;
 144
 145                 for( tRoute *rt = gIP_Routes; rt; rt = rt->Next )
 146                 {
 147                         if( rt->Node.Inode > num )      return NULL;
 148                         if( rt->Node.Inode == num )     return &rt->Node;
 149                 }
 150                 return NULL;
 151         }
 152         else
 153         {
 154                  int    type = _Route_ParseRouteName(Name, NULL, NULL, NULL);
 155                 if( type <= 0 ) return NULL;
 156
 157                  int    addrSize = IPStack_GetAddressSize(type);
 158                 Uint8   addrData[addrSize];
 159                  int    subnet_bits, metric;
 160
 161                 _Route_ParseRouteName(Name, addrData, &subnet_bits, &metric);
 162
 163                 tRoute *rt = _Route_FindExactRoute(type, addrData, subnet_bits, metric);
 164                 if(rt)  return &rt->Node;
 165                 return NULL;
 166         }
 167 }
 168
 169 /**
 170  * \brief Create a new route node
 171  */
 172 int IPStack_RouteDir_MkNod(tVFS_Node *Node, const char *Name, Uint Flags)
 173 {
 174         if( Flags )     return -EINVAL;
 175         if( Threads_GetUID() != 0 )     return -EACCES;
 176
 177          int    type = _Route_ParseRouteName(Name, NULL, NULL, NULL);
 178         if( type <= 0 ) return -EINVAL;
 179
 180          int    size = IPStack_GetAddressSize(type);
 181         Uint8   addrdata[size];
 182          int    subnet, metric;
 183
 184         _Route_ParseRouteName(Name, addrdata, &subnet, &metric);
 185
 186         // Check for duplicates
 187         if( _Route_FindExactRoute(type, addrdata, subnet, metric) )
 188                 return -EEXIST;
 189
 190         IPStack_Route_Create(type, addrdata, subnet, metric);
 191
 192         return 0;
 193 }
 194
 195 /**
 196  * \brief Rename / Delete a route
 197  */
 198 int IPStack_RouteDir_Relink(tVFS_Node *Node, const char *OldName, const char *NewName)
 199 {
 200         tRoute  *rt;
 201
 202         if( Threads_GetUID() != 0 )     return -EACCES;
 203
 204         // Get the original route entry
 205         {
 206                  int    type = _Route_ParseRouteName(OldName, NULL, NULL, NULL);
 207                 if(type <= 0)   return -EINVAL;
 208                 Uint8   addr[IPStack_GetAddressSize(type)];
 209                  int    subnet, metric;
 210                 _Route_ParseRouteName(OldName, addr, &subnet, &metric);
 211
 212                 rt = _Route_FindExactRoute(type, addr, subnet, metric);
 213         }
 214
 215         if( NewName == NULL )
 216         {
 217                 // Delete the route
 218                 tRoute  *prev = NULL;
 219                 for(tRoute *r = gIP_Routes; r && r != rt; prev = r, r = r->Next);
 220
 221                 if(prev)
 222                         prev->Next = rt->Next;
 223                 else
 224                         gIP_Routes = rt->Next;
 225                 free(rt);
 226         }
 227         else
 228         {
 229                 // Change the route
 230                  int    type = _Route_ParseRouteName(NewName, NULL, NULL, NULL);
 231                 if(type <= 0)   return -EINVAL;
 232                 Uint8   addr[IPStack_GetAddressSize(type)];
 233                  int    subnet, metric;
 234                 _Route_ParseRouteName(NewName, addr, &subnet, &metric);
 235
 236                 return -ENOTIMPL;
 237         }
 238         return 0;
 239 }
 240
 241 tRoute *_Route_FindExactRoute(int Type, void *Network, int Subnet, int Metric)
 242 {
 243         for(tRoute *rt = gIP_Routes; rt; rt = rt->Next)
 244         {
 245                 if( rt->AddressType != Type )   continue;
 246                 if( rt->Metric != Metric )      continue;
 247                 if( rt->SubnetBits != Subnet )  continue;
 248                 if( IPStack_CompareAddress(Type, rt->Network, Network, -1) == 0 )
 249                         continue ;
 250                 return rt;
 251         }
 252         return NULL;
 253 }
 254
 255 int _Route_ParseRouteName(const char *Name, void *Addr, int *SubnetBits, int *Metric)
 256 {
 257          int    type, addrlen;
 258          int    ofs = 0, ilen;
 259
 260         ENTER("sName pAddr pSubnetBits pMetric", Name, Addr, SubnetBits, Metric);
 261
 262         ilen = ParseInt(Name, &type);
 263         if(ilen == 0) {
 264                 LOG("Type failed to parse");
 265                 LEAVE_RET('i', -1);
 266         }
 267         ofs += ilen;
 268
 269         if(Name[ofs] != ':')    LEAVE_RET('i', -1);
 270         ofs ++;
 271
 272         addrlen = IPStack_GetAddressSize(type);
 273         if( Addr )
 274         {
 275                 if( UnHex(Addr, addrlen, Name + ofs) != addrlen )
 276                         return -1;
 277         }
 278         ofs += addrlen*2;
 279
 280         if(Name[ofs] != ':')    LEAVE_RET('i', -1);
 281         ofs ++;
 282
 283         ilen = ParseInt(Name+ofs, SubnetBits);
 284         if(ilen == 0) {
 285                 LOG("Subnet failed to parse");
 286                 LEAVE_RET('i', -1);
 287         }
 288         ofs += ilen;
 289
 290         if(Name[ofs] != ':')    LEAVE_RET('i', -1);
 291         ofs ++;
 292
 293         ilen = ParseInt(Name+ofs, Metric);
 294         if(ilen == 0) {
 295                 LOG("Metric failed to parse");
 296                 LEAVE_RET('i', -1);
 297         }
 298         ofs += ilen;
 299
 300         if(Name[ofs] != '\0')   LEAVE_RET('i', -1);
 301
 302         LEAVE('i', type);
 303         return type;
 304 }
 305
 306 /**
 307  * \brief Names for the route list IOCtl Calls
 308  */
 309 static const char *casIOCtls_RouteDir[] = {
 310         DRV_IOCTLNAMES,
 311         "locate_route", // Find the best route for an address - struct {int Type, char Address[]} *
 312         NULL
 313         };
 314
 315 /**
 316  * \brief IOCtl for /Devices/ip/routes/
 317  */
 318 int IPStack_RouteDir_IOCtl(tVFS_Node *Node, int ID, void *Data)
 319 {
 320         tRoute  *rt;
 321         ENTER("pNode iID pData", Node, ID, Data);
 322         switch(ID)
 323         {
 324         // --- Standard IOCtls (0-3) ---
 325         BASE_IOCTLS(DRV_TYPE_MISC, STR(IDENT), VERSION, casIOCtls_RouteDir)
 326
 327         case 4: // Locate Route
 328                 {
 329                         struct {
 330                                  int    Type;
 331                                 Uint8   Addr[];
 332                         }       *data = Data;
 333
 334                         if( !CheckMem(Data, sizeof(int)) )
 335                                 LEAVE_RET('i', -1);
 336                         if( !CheckMem(Data, sizeof(int) + IPStack_GetAddressSize(data->Type)) )
 337                                 LEAVE_RET('i', -1);
 338
 339                         Log_Debug("IPStack", "Route_RouteDir_IOCtl - FindRoute %i, %s",
 340                                 data->Type, IPStack_PrintAddress(data->Type, data->Addr) );
 341                         rt = IPStack_FindRoute(data->Type, NULL, data->Addr);
 342
 343                         if( !rt )
 344                                 LEAVE_RET('i', 0);
 345
 346                         LEAVE('i', rt->Node.Inode);
 347                         return rt->Node.Inode;
 348                 }
 349                 break;
 350         }
 351         LEAVE('i', 0);
 352         return 0;
 353 }
 354
 355 /**
 356  * \brief Create a new route entry
 357  * \param InterfaceName Name of the interface using this route
 358  */
 359 tRoute *IPStack_Route_Create(int AddrType, void *Network, int SubnetBits, int Metric)
 360 {
 361         tRoute  *rt;
 362          int    size;
 363
 364         // Get the size of the specified address type
 365         size = IPStack_GetAddressSize(AddrType);
 366         if( size == 0 ) {
 367                 return NULL;
 368         }
 369
 370         // Allocate space
 371         rt = calloc(1, sizeof(tRoute) + size*2 );
 372
 373         // Set up node
 374         rt->Node.ImplPtr = rt;
 375         rt->Node.Inode = giIP_NextRouteId ++;
 376         rt->Node.Size = 0;
 377         rt->Node.NumACLs = 1,
 378         rt->Node.ACLs = &gVFS_ACL_EveryoneRO;
 379         rt->Node.Type = &gIP_RouteNodeType;
 380
 381         // Set up state
 382         rt->AddressType = AddrType;
 383         rt->Network = (void *)( (tVAddr)rt + sizeof(tRoute) );
 384         rt->SubnetBits = SubnetBits;
 385         rt->NextHop = (void *)( (tVAddr)rt + sizeof(tRoute) + size );
 386         rt->Interface = NULL;
 387         rt->Metric = Metric;
 388         memcpy(rt->Network, Network, size);
 389         memset(rt->NextHop, 0, size);
 390
 391         // Clear non-fixed bits
 392         {
 393                 Uint8   *data = rt->Network;
 394                  int    i;
 395                 i = SubnetBits / 8;
 396                 if( SubnetBits % 8 ) {
 397                         data[i] &= ~((1 << (8 - SubnetBits % 8)) - 1);
 398                         i ++;
 399                 }
 400                 memset(data + i, 0, size - i);
 401         }
 402
 403
 404         // Add to list
 405         if( gIP_RoutesEnd ) {
 406                 gIP_RoutesEnd->Next = rt;
 407                 gIP_RoutesEnd = rt;
 408         }
 409         else {
 410                 gIP_Routes = gIP_RoutesEnd = rt;
 411         }
 412
 413 //      Log_Log("IPStack", "Route entry for '%s' created", InterfaceName);
 414
 415         return rt;
 416 }
 417
 418 /**
 419  * \brief Add and fill a route
 420  */
 421 tRoute *IPStack_AddRoute(const char *Interface, void *Network, int SubnetBits, void *NextHop, int Metric)
 422 {
 423         tInterface      *iface;
 424         tRoute  *rt;
 425          int    addrSize;
 426
 427         {
 428                 tVFS_Node       *tmp;
 429                 tmp = IPStack_Root_FindDir(NULL, Interface);
 430                 if(!tmp)        return NULL;
 431                 iface = tmp->ImplPtr;
 432                 if(tmp->Type->Close)    tmp->Type->Close(tmp);
 433         }
 434
 435         rt = IPStack_Route_Create(iface->Type, Network, SubnetBits, Metric);
 436         if( !rt )       return NULL;
 437
 438         addrSize = IPStack_GetAddressSize(iface->Type);
 439         rt->Interface = iface;
 440
 441         if( NextHop )
 442                 memcpy(rt->NextHop, NextHop, addrSize);
 443
 444         return rt;
 445 }
 446
 447 /**
 448  * \brief Locates what interface should be used to get directly to an address
 449  */
 450 tRoute *_Route_FindInterfaceRoute(int AddressType, void *Address)
 451 {
 452         tRoute  *best = NULL, *rt;
 453          int addrSize = IPStack_GetAddressSize(AddressType);
 454         for( tInterface *iface = gIP_Interfaces; iface; iface = iface->Next )
 455         {
 456                 if( iface->Type != AddressType )        continue;
 457
 458                 // Check if the address matches
 459                 if( !IPStack_CompareAddress(AddressType, iface->Address, Address, iface->SubnetBits) )
 460                         continue;
 461
 462                 rt = &iface->Route;
 463                 if( !rt->Interface )
 464                 {
 465                         memcpy(rt->Network, iface->Address, addrSize);
 466                         memset(rt->NextHop, 0, addrSize);
 467                         rt->Metric = DEFAUTL_METRIC;
 468                         rt->SubnetBits = iface->SubnetBits;
 469                         rt->Interface = iface;
 470                 }
 471
 472                 if( best ) {
 473                         // More direct routes are preferred
 474                         if( best->SubnetBits > rt->SubnetBits ) {
 475                                 LOG("Skipped - less direct (%i < %i)", rt->SubnetBits, best->SubnetBits);
 476                                 continue;
 477                         }
 478                         // If equally direct, choose the best metric
 479                         if( best->SubnetBits == rt->SubnetBits && best->Metric < rt->Metric ) {
 480                                 LOG("Skipped - higher metric (%i > %i)", rt->Metric, best->Metric);
 481                                 continue;
 482                         }
 483                 }
 484
 485                 best = rt;
 486         }
 487
 488         return best;
 489 }
 490
 491 /**
 492  */
 493 tRoute *IPStack_FindRoute(int AddressType, tInterface *Interface, void *Address)
 494 {
 495         tRoute  *rt;
 496         tRoute  *best = NULL;
 497          int    addrSize;
 498
 499         ENTER("iAddressType pInterface sAddress",
 500                 AddressType, Interface, IPStack_PrintAddress(AddressType, Address));
 501
 502         if( Interface && AddressType != Interface->Type ) {
 503                 LOG("Interface->Type (%i) != AddressType", Interface->Type);
 504                 LEAVE('n');
 505                 return NULL;
 506         }
 507
 508         // Get address size
 509         addrSize = IPStack_GetAddressSize(AddressType);
 510
 511         // Check against explicit routes
 512         for( rt = gIP_Routes; rt; rt = rt->Next )
 513         {
 514                 // Check interface
 515                 if( Interface && rt->Interface && rt->Interface != Interface )  continue;
 516                 // Check address type
 517                 if( rt->AddressType != AddressType )    continue;
 518
 519                 LOG("Checking network %s/%i", IPStack_PrintAddress(AddressType, rt->Network), rt->SubnetBits);
 520
 521                 // Check if the address matches
 522                 if( !IPStack_CompareAddress(AddressType, rt->Network, Address, rt->SubnetBits) )
 523                         continue;
 524
 525                 if( best ) {
 526                         // More direct routes are preferred
 527                         if( best->SubnetBits > rt->SubnetBits ) {
 528                                 LOG("Skipped - less direct (%i < %i)", rt->SubnetBits, best->SubnetBits);
 529                                 continue;
 530                         }
 531                         // If equally direct, choose the best metric
 532                         if( best->SubnetBits == rt->SubnetBits && best->Metric < rt->Metric ) {
 533                                 LOG("Skipped - higher metric (%i > %i)", rt->Metric, best->Metric);
 534                                 continue;
 535                         }
 536                 }
 537
 538                 best = rt;
 539         }
 540
 541         // Check against implicit routes
 542         if( !best && !Interface )
 543         {
 544                 best = _Route_FindInterfaceRoute(AddressType, Address);
 545         }
 546         if( !best && Interface )
 547         {
 548                 rt = &Interface->Route;
 549                 // Make sure route is up to date
 550                 memcpy(rt->Network, Interface->Address, addrSize);
 551                 memset(rt->NextHop, 0, addrSize);
 552                 rt->Metric = DEFAUTL_METRIC;
 553                 rt->SubnetBits = Interface->SubnetBits;
 554
 555                 if( IPStack_CompareAddress(AddressType, rt->Network, Address, rt->SubnetBits) )
 556                 {
 557                         best = rt;
 558                 }
 559         }
 560
 561         LEAVE('p', best);
 562         return best;
 563 }
 564
 565 /**
 566  * \brief Names for route IOCtl Calls
 567  */
 568 static const char *casIOCtls_Route[] = {
 569         DRV_IOCTLNAMES,
 570         "get_nexthop",  // Get next hop - (void *Data), returns boolean success
 571         "set_nexthop",  // Set next hop - (void *Data), returns boolean success
 572         "get_interface",        // Get interface name - (char *Name), returns name length, NULL OK
 573         "set_interface",        // Set interface - (const char *Name)
 574         NULL
 575         };
 576
 577 /**
 578  * \brief IOCtl for /Devices/ip/routes/#
 579  */
 580 int IPStack_Route_IOCtl(tVFS_Node *Node, int ID, void *Data)
 581 {
 582         tRoute  *rt = Node->ImplPtr;
 583          int    addrSize = IPStack_GetAddressSize(rt->AddressType);
 584
 585         ENTER("pNode iID pData", Node, ID, Data);
 586
 587         switch(ID)
 588         {
 589         // --- Standard IOCtls (0-3) ---
 590         BASE_IOCTLS(DRV_TYPE_MISC, STR(IDENT), VERSION, casIOCtls_Route)
 591
 592         // Get Next Hop
 593         case 4:
 594                 if( !CheckMem(Data, addrSize) ) LEAVE_RET('i', -1);
 595                 memcpy(Data, rt->NextHop, addrSize);
 596                 LEAVE_RET('i', 1);
 597         // Set Next Hop
 598         case 5:
 599                 if( Threads_GetUID() != 0 )     LEAVE_RET('i', -1);
 600                 if( !CheckMem(Data, addrSize) ) LEAVE_RET('i', -1);
 601                 memcpy(rt->NextHop, Data, addrSize);
 602                 LEAVE_RET('i', 1);
 603
 604         // Get interface name
 605         case 6:
 606                 if( !rt->Interface ) {
 607                         if(Data && !CheckMem(Data, 1) )
 608                                 LEAVE_RET('i', -1);
 609                         if(Data)
 610                                 *(char*)Data = 0;
 611                         LEAVE_RET('i', 0);
 612                 }
 613                 if( Data ) {
 614                         if( !CheckMem(Data, strlen(rt->Interface->Name) + 1) )
 615                                 LEAVE_RET('i', -1);
 616                         strcpy(Data, rt->Interface->Name);
 617                 }
 618                 LEAVE_RET('i', strlen(rt->Interface->Name));
 619         // Set interface name
 620         case 7:
 621                 if( Threads_GetUID() != 0 )
 622                         LEAVE_RET('i', -1);
 623                 if( !CheckString(Data) )
 624                         LEAVE_RET('i', -1);
 625                 else
 626                 {
 627                         tInterface      *iface;
 628                         tVFS_Node       *tmp;
 629                         tmp = IPStack_Root_FindDir(NULL, Data);
 630                         if(!tmp)
 631                                 LEAVE_RET('i', -1);
 632                         iface = tmp->ImplPtr;
 633                         if(tmp->Type->Close)    tmp->Type->Close(tmp);
 634
 635                         if( iface->Type != rt->AddressType )
 636                                 LEAVE_RET('i', -1);
 637
 638                         // TODO: Other checks?
 639
 640                         rt->Interface = iface;
 641                 }
 642                 LEAVE_RET('i', 0);
 643
 644         default:
 645                 LEAVE_RET('i', -1);
 646         }
 647 }