Modules/IPStack/main.c

   1 /*
   2  * Acess2 IP Stack
   3  * - Stack Initialisation
   4  */
   5 #define DEBUG   0
   6 #define VERSION VER2(0,10)
   7 #include "ipstack.h"
   8 #include "link.h"
   9 #include <modules.h>
  10 #include <fs_devfs.h>
  11 #include <tpl_drv_common.h>
  12 #include <tpl_drv_network.h>
  13
  14 // === CONSTANTS ===
  15 //! Default timeout value, 30 seconds
  16 #define DEFAULT_TIMEOUT (30*1000)
  17
  18 // === IMPORTS ===
  19 extern int      ARP_Initialise();
  20 extern void     UDP_Initialise();
  21 extern void     TCP_Initialise();
  22 extern int      IPv4_Initialise();
  23 extern int      IPv4_Ping(tInterface *Iface, tIPv4 Addr);
  24 extern int      IPv6_Initialise();
  25 //extern int    IPv6_Ping(tInterface *Iface, tIPv6 Addr);
  26
  27 // === PROTOTYPES ===
  28  int    IPStack_Install(char **Arguments);
  29  int    IPStack_IOCtlRoot(tVFS_Node *Node, int ID, void *Data);
  30 char    *IPStack_Root_ReadDir(tVFS_Node *Node, int Pos);
  31 tVFS_Node       *IPStack_Root_FindDir(tVFS_Node *Node, const char *Name);
  32  int    IPStack_Root_IOCtl(tVFS_Node *Node, int ID, void *Data);
  33
  34  int    IPStack_AddInterface(char *Device);
  35 tAdapter        *IPStack_GetAdapter(char *Path);
  36 char    *IPStack_Iface_ReadDir(tVFS_Node *Node, int Pos);
  37 tVFS_Node       *IPStack_Iface_FindDir(tVFS_Node *Node, const char *Name);
  38  int    IPStack_Iface_IOCtl(tVFS_Node *Node, int ID, void *Data);
  39
  40 // === GLOBALS ===
  41 MODULE_DEFINE(0, VERSION, IPStack, IPStack_Install, NULL, NULL);
  42 tDevFS_Driver   gIP_DriverInfo = {
  43         NULL, "ip",
  44         {
  45         .Size = 0,      // Number of interfaces
  46         .NumACLs = 1,
  47         .ACLs = &gVFS_ACL_EveryoneRX,
  48         .Flags = VFS_FFLAG_DIRECTORY,
  49         .ReadDir = IPStack_Root_ReadDir,
  50         .FindDir = IPStack_Root_FindDir,
  51         .IOCtl = IPStack_Root_IOCtl
  52         }
  53 };
  54 tShortSpinlock  glIP_Interfaces;
  55 //! Loopback (127.0.0.0/8, ::1) Pseudo-Interface
  56 tInterface      gIP_LoopInterface = {
  57         Node: {
  58                 ImplPtr: &gIP_LoopInterface,
  59                 Flags: VFS_FFLAG_DIRECTORY,
  60                 Size: -1,
  61                 NumACLs: 1,
  62                 ACLs: &gVFS_ACL_EveryoneRX,
  63                 ReadDir: IPStack_Iface_ReadDir,
  64                 FindDir: IPStack_Iface_FindDir,
  65                 IOCtl: IPStack_Iface_IOCtl
  66         },
  67         Adapter: NULL,
  68         Type: 0
  69 };
  70 tInterface      *gIP_Interfaces = NULL;
  71 tInterface      *gIP_Interfaces_Last = NULL;
  72  int    giIP_NextIfaceId = 1;
  73 tMutex  glIP_Adapters;
  74 tAdapter        *gIP_Adapters = NULL;
  75 tSocketFile     *gIP_FileTemplates;
  76
  77 // === CODE ===
  78 /**
  79  * \fn int IPStack_Install(char **Arguments)
  80  * \brief Intialise the relevant parts of the stack and register with DevFS
  81  */
  82 int IPStack_Install(char **Arguments)
  83 {
  84          int    i = 0;
  85
  86         // Layer 3 - Network Layer Protocols
  87         ARP_Initialise();
  88         IPv4_Initialise();
  89         IPv6_Initialise();
  90         // Layer 4 - Transport Layer Protocols
  91         TCP_Initialise();
  92         UDP_Initialise();
  93
  94         if(Arguments)
  95         {
  96                 // Parse module arguments
  97                 for( i = 0; Arguments[i]; i++ )
  98                 {
  99                         // TODO:
 100                         // Define interfaces by <Device>,<Type>,<HexStreamAddress>,<Bits>
 101                         // Where:
 102                         // - <Device> is the device path (E.g. /Devices/ne2k/0)
 103                         // - <Type> is a number (e.g. 4) or symbol (e.g. AF_INET4)
 104                         // - <HexStreamAddress> is a condensed hexadecimal stream (in big endian)
 105                         //      (E.g. 0A000201 for 10.0.2.1 IPv4)
 106                         // - <Bits> is the number of subnet bits (E.g. 24 for an IPv4 Class C)
 107                 }
 108         }
 109
 110         gIP_LoopInterface.Adapter = IPStack_GetAdapter("/Devices/fifo/anon");
 111
 112         DevFS_AddDevice( &gIP_DriverInfo );
 113
 114         return MODULE_ERR_OK;
 115 }
 116
 117 /**
 118  * \brief Adds a file to the socket list
 119  */
 120 int IPStack_AddFile(tSocketFile *File)
 121 {
 122         Log_Log("IPStack", "Added file '%s'", File->Name);
 123         File->Next = gIP_FileTemplates;
 124         gIP_FileTemplates = File;
 125         return 0;
 126 }
 127
 128 /**
 129  * \brief Read from the IP Stack's Device Directory
 130  */
 131 char *IPStack_Root_ReadDir(tVFS_Node *Node, int Pos)
 132 {
 133         tInterface      *iface;
 134         char    *name;
 135         ENTER("pNode iPos", Node, Pos);
 136
 137
 138         // Routing Subdir
 139         if( Pos == 0 ) {
 140                 return strdup("routes");
 141         }
 142         // Pseudo Interfaces
 143         if( Pos == 1 ) {
 144                 return strdup("lo");
 145         }
 146         Pos -= 2;
 147
 148         // Traverse the list
 149         for( iface = gIP_Interfaces; iface && Pos--; iface = iface->Next ) ;
 150
 151         // Did we run off the end?
 152         if(!iface) {
 153                 LEAVE('n');
 154                 return NULL;
 155         }
 156
 157         name = malloc(4);
 158         if(!name) {
 159                 Log_Warning("IPStack", "IPStack_Root_ReadDir - malloc error");
 160                 LEAVE('n');
 161                 return NULL;
 162         }
 163
 164         // Create the name
 165         Pos = iface->Node.ImplInt;
 166         if(Pos < 10) {
 167                 name[0] = '0' + Pos;
 168                 name[1] = '\0';
 169         }
 170         else if(Pos < 100) {
 171                 name[0] = '0' + Pos/10;
 172                 name[1] = '0' + Pos%10;
 173                 name[2] = '\0';
 174         }
 175         else {
 176                 name[0] = '0' + Pos/100;
 177                 name[1] = '0' + (Pos/10)%10;
 178                 name[2] = '0' + Pos%10;
 179                 name[3] = '\0';
 180         }
 181
 182         LEAVE('s', name);
 183         // Return the pre-generated name
 184         return name;
 185 }
 186
 187 /**
 188  * \brief Get the node of an interface
 189  */
 190 tVFS_Node *IPStack_Root_FindDir(tVFS_Node *Node, const char *Name)
 191 {
 192          int    i, num;
 193         tInterface      *iface;
 194
 195         ENTER("pNode sName", Node, Name);
 196
 197         // Routing subdir
 198         if( strcmp(Name, "routes") == 0 ) {
 199                 return &gIP_RouteNode;
 200         }
 201
 202         // Loopback
 203         if( strcmp(Name, "lo") == 0 ) {
 204                 return &gIP_LoopInterface.Node;
 205         }
 206
 207         i = 0;  num = 0;
 208         while('0' <= Name[i] && Name[i] <= '9')
 209         {
 210                 num *= 10;
 211                 num += Name[i] - '0';
 212                 i ++;
 213         }
 214         if(Name[i] != '\0') {
 215                 LEAVE('n');
 216                 return NULL;
 217         }
 218
 219         for( iface = gIP_Interfaces; iface; iface = iface->Next )
 220         {
 221                 if( (int)iface->Node.ImplInt == num )
 222                 {
 223                         LEAVE('p', &iface->Node);
 224                         return &iface->Node;
 225                 }
 226         }
 227         LEAVE('p', NULL);
 228         return NULL;
 229 }
 230
 231 static const char *casIOCtls_Root[] = { DRV_IOCTLNAMES, "add_interface", NULL };
 232 /**
 233  * \brief Handles IOCtls for the IPStack root
 234  */
 235 int IPStack_Root_IOCtl(tVFS_Node *Node, int ID, void *Data)
 236 {
 237          int    tmp;
 238         ENTER("pNode iID pData", Node, ID, Data);
 239
 240         switch(ID)
 241         {
 242         // --- Standard IOCtls (0-3) ---
 243         case DRV_IOCTL_TYPE:
 244                 LEAVE('i', DRV_TYPE_MISC);
 245                 return DRV_TYPE_MISC;
 246
 247         case DRV_IOCTL_IDENT:
 248                 tmp = ModUtil_SetIdent(Data, "IPStack");
 249                 LEAVE('i', 1);
 250                 return 1;
 251
 252         case DRV_IOCTL_VERSION:
 253                 LEAVE('x', VERSION);
 254                 return VERSION;
 255
 256         case DRV_IOCTL_LOOKUP:
 257                 tmp = ModUtil_LookupString( (char**)casIOCtls_Root, (char*)Data );
 258                 LEAVE('i', tmp);
 259                 return tmp;
 260
 261                 /*
 262                  * add_interface
 263                  * - Adds a new IP interface and binds it to a device
 264                  */
 265         case 4:
 266                 if( Threads_GetUID() != 0 )     LEAVE_RET('i', -1);
 267                 if( !CheckString( Data ) )      LEAVE_RET('i', -1);
 268                 {
 269                         char    name[4] = "";
 270                         tmp = IPStack_AddInterface(Data, name);
 271                 }
 272                 LEAVE_RET('i', tmp);
 273         }
 274         LEAVE('i', 0);
 275         return 0;
 276 }
 277
 278 /**
 279  * \brief Read from an interface's directory
 280  */
 281 char *IPStack_Iface_ReadDir(tVFS_Node *Node, int Pos)
 282 {
 283         tSocketFile     *file = gIP_FileTemplates;
 284         while(Pos-- && file) {
 285                 file = file->Next;
 286         }
 287
 288         if(!file)       return NULL;
 289
 290         return strdup(file->Name);
 291 }
 292
 293 /**
 294  * \brief Gets a named node from an interface directory
 295  */
 296 tVFS_Node *IPStack_Iface_FindDir(tVFS_Node *Node, const char *Name)
 297 {
 298         tSocketFile     *file = gIP_FileTemplates;
 299
 300         // Get file definition
 301         for(;file;file = file->Next)
 302         {
 303                 if( strcmp(file->Name, Name) == 0 )     break;
 304         }
 305         if(!file)       return NULL;
 306
 307         // Pass the buck!
 308         return file->Init(Node->ImplPtr);
 309 }
 310
 311 /**
 312  * \brief Names for interface IOCtl Calls
 313  */
 314 static const char *casIOCtls_Iface[] = {
 315         DRV_IOCTLNAMES,
 316         "getset_type",
 317         "get_address", "set_address",
 318         "getset_subnet",
 319         "get_gateway", "set_gateway",
 320         "get_device",
 321         "ping",
 322         NULL
 323         };
 324 /**
 325  * \brief Handles IOCtls for the IPStack interfaces
 326  */
 327 int IPStack_Iface_IOCtl(tVFS_Node *Node, int ID, void *Data)
 328 {
 329          int    tmp;
 330         tInterface      *iface = (tInterface*)Node->ImplPtr;
 331         ENTER("pNode iID pData", Node, ID, Data);
 332
 333         switch(ID)
 334         {
 335         // --- Standard IOCtls (0-3) ---
 336         case DRV_IOCTL_TYPE:
 337                 LEAVE('i', DRV_TYPE_MISC);
 338                 return DRV_TYPE_MISC;
 339
 340         case DRV_IOCTL_IDENT:
 341                 tmp = ModUtil_SetIdent(Data, STR(IDENT));
 342                 LEAVE('i', 1);
 343                 return 1;
 344
 345         case DRV_IOCTL_VERSION:
 346                 LEAVE('x', VERSION);
 347                 return VERSION;
 348
 349         case DRV_IOCTL_LOOKUP:
 350                 tmp = ModUtil_LookupString( (char**)casIOCtls_Iface, (char*)Data );
 351                 LEAVE('i', tmp);
 352                 return tmp;
 353
 354         /*
 355          * getset_type
 356          * - Get/Set the interface type
 357          */
 358         case 4:
 359                 // Set Type?
 360                 if( Data )
 361                 {
 362                         // Ok, it's set type
 363                         if( Threads_GetUID() != 0 ) {
 364                                 LOG("Attempt by non-root to alter an interface (%i)", Threads_GetUID());
 365                                 LEAVE('i', -1);
 366                                 return -1;
 367                         }
 368                         if( !CheckMem( Data, sizeof(int) ) ) {
 369                                 LOG("Invalid pointer %p", Data);
 370                                 LEAVE('i', -1);
 371                                 return -1;
 372                         }
 373                         switch( *(int*)Data )
 374                         {
 375                         case 0: // Disable
 376                                 iface->Type = 0;
 377                                 memset(&iface->IP6, 0, sizeof(tIPv6));  // Clear address
 378                                 break;
 379                         case 4: // IPv4
 380                                 iface->Type = 4;
 381                                 memset(&iface->IP4, 0, sizeof(tIPv4));
 382                                 break;
 383                         case 6: // IPv6
 384                                 iface->Type = 6;
 385                                 memset(&iface->IP6, 0, sizeof(tIPv6));
 386                                 break;
 387                         default:
 388                                 LEAVE('i', -1);
 389                                 return -1;
 390                         }
 391                 }
 392                 LEAVE('i', iface->Type);
 393                 return iface->Type;
 394
 395         /*
 396          * get_address
 397          * - Get the interface's address
 398          */
 399         case 5:
 400                 switch(iface->Type)
 401                 {
 402                 case 0: LEAVE_RET('i', 1);
 403                 case 4:
 404                         if( !CheckMem( Data, sizeof(tIPv4) ) )  LEAVE_RET('i', -1);
 405                         memcpy( Data, &iface->IP4.Address, sizeof(tIPv4) );
 406                         LEAVE_RET('i', 1);
 407                 case 6:
 408                         if( !CheckMem( Data, sizeof(tIPv6) ) )  LEAVE_RET('i', -1);
 409                         memcpy( Data, &iface->IP6.Address, sizeof(tIPv6) );
 410                         LEAVE_RET('i', 1);
 411                 }
 412                 LEAVE_RET('i', 0);
 413
 414         /*
 415          * set_address
 416          * - Get the interface's address
 417          */
 418         case 6:
 419                 if( Threads_GetUID() != 0 )     LEAVE_RET('i', -1);
 420                 switch(iface->Type)
 421                 {
 422                 case 0: LEAVE_RET('i', 1);
 423                 case 4:
 424                         if( !CheckMem( Data, sizeof(tIPv4) ) )  LEAVE_RET('i', -1);
 425                         iface->Type = 0;        // One very hacky mutex/trash protector
 426                         memcpy( &iface->IP4.Address, Data, sizeof(tIPv4) );
 427                         iface->Type = 4;
 428                         LEAVE_RET('i', 1);
 429                 case 6:
 430                         if( !CheckMem( Data, sizeof(tIPv6) ) )  LEAVE_RET('i', -1);
 431                         iface->Type = 0;
 432                         memcpy( &iface->IP6.Address, Data, sizeof(tIPv6) );
 433                         iface->Type = 6;
 434                         LEAVE_RET('i', 1);
 435                 }
 436                 LEAVE_RET('i', 0);
 437
 438         /*
 439          * getset_subnet
 440          * - Get/Set the bits in the address subnet
 441          */
 442         case 7:
 443                 // Get?
 444                 if( Data == NULL )
 445                 {
 446                         switch( iface->Type )
 447                         {
 448                         case 4:         LEAVE_RET('i', iface->IP4.SubnetBits);
 449                         case 6:         LEAVE_RET('i', iface->IP6.SubnetBits);
 450                         default:        LEAVE_RET('i', 0);
 451                         }
 452                 }
 453
 454                 // Ok, set.
 455                 if( Threads_GetUID() != 0 )     LEAVE_RET('i', -1);
 456                 if( !CheckMem(Data, sizeof(int)) )      LEAVE_RET('i', -1);
 457
 458                 // Check and set the subnet bits
 459                 switch( iface->Type )
 460                 {
 461                 case 4:
 462                         if( *(int*)Data < 0 || *(int*)Data > 31 )       LEAVE_RET('i', -1);
 463                         iface->IP4.SubnetBits = *(int*)Data;
 464                         LEAVE_RET('i', iface->IP4.SubnetBits);
 465                 case 6:
 466                         if( *(int*)Data < 0 || *(int*)Data > 127 )      LEAVE_RET('i', -1);
 467                         iface->IP6.SubnetBits = *(int*)Data;
 468                         LEAVE_RET('i', iface->IP6.SubnetBits);
 469                 default:
 470                         break;
 471                 }
 472
 473                 LEAVE('i', 0);
 474                 return 0;
 475
 476         /*
 477          * get_gateway
 478          * - Get the interface's IPv4 gateway
 479          */
 480         case 8:
 481                 switch(iface->Type)
 482                 {
 483                 case 0:
 484                         LEAVE_RET('i', 1);
 485                 case 4:
 486                         if( !CheckMem( Data, sizeof(tIPv4) ) )  LEAVE_RET('i', -1);
 487                         memcpy( Data, &iface->IP4.Gateway, sizeof(tIPv4) );
 488                         LEAVE_RET('i', 1);
 489                 case 6:
 490                         LEAVE_RET('i', 1);
 491                 }
 492                 LEAVE('i', 0);
 493                 return 0;
 494
 495         /*
 496          * set_gateway
 497          * - Get/Set the interface's IPv4 gateway
 498          */
 499         case 9:
 500                 if( Threads_GetUID() != 0 )     LEAVE_RET('i', -1);
 501                 switch(iface->Type)
 502                 {
 503                 case 0:
 504                         LEAVE_RET('i', 1);
 505
 506                 case 4:
 507                         if( !CheckMem( Data, sizeof(tIPv4) ) )  LEAVE_RET('i', -1);
 508                         iface->Type = 0;        // One very hacky mutex/trash protector
 509                         memcpy( &iface->IP4.Gateway, Data, sizeof(tIPv4) );
 510                         iface->Type = 4;
 511                         LEAVE_RET('i', 1);
 512
 513                 case 6:
 514                         LEAVE_RET('i', 1);
 515                 }
 516                 break;
 517
 518         /*
 519          * get_device
 520          * - Gets the name of the attached device
 521          */
 522         case 10:
 523                 if( Data == NULL )
 524                         LEAVE_RET('i', iface->Adapter->DeviceLen);
 525                 if( !CheckMem( Data, iface->Adapter->DeviceLen+1 ) )
 526                         LEAVE_RET('i', -1);
 527                 strcpy( Data, iface->Adapter->Device );
 528                 return iface->Adapter->DeviceLen;
 529
 530         /*
 531          * ping
 532          * - Send an ICMP Echo
 533          */
 534         case 11:
 535                 switch(iface->Type)
 536                 {
 537                 case 0:
 538                         LEAVE_RET('i', 1);
 539
 540                 case 4:
 541                         if( !CheckMem( Data, sizeof(tIPv4) ) )  LEAVE_RET('i', -1);
 542                         tmp = IPv4_Ping(iface, *(tIPv4*)Data);
 543                         LEAVE('i', tmp);
 544                         return tmp;
 545
 546                 case 6:
 547                         LEAVE_RET('i', 1);
 548                 }
 549                 break;
 550
 551         }
 552
 553         LEAVE('i', 0);
 554         return 0;
 555 }
 556
 557 // --- Internal ---
 558 /**
 559  * \fn int IPStack_AddInterface(char *Device)
 560  * \brief Adds an interface to the list
 561  */
 562 int IPStack_AddInterface(const char *Device, const char *Name)
 563 {
 564         tInterface      *iface;
 565         tAdapter        *card;
 566
 567         ENTER("sDevice", Device);
 568
 569         card = IPStack_GetAdapter(Device);
 570
 571         iface = malloc(sizeof(tInterface) + strlen(Name));
 572         if(!iface) {
 573                 LEAVE('i', -2);
 574                 return -2;      // Return ERR_MYBAD
 575         }
 576
 577         iface->Next = NULL;
 578         iface->Type = 0;        // Unset type
 579
 580         // Create Node
 581         iface->Node.ImplPtr = iface;
 582         iface->Node.Flags = VFS_FFLAG_DIRECTORY;
 583         iface->Node.Size = -1;
 584         iface->Node.NumACLs = 1;
 585         iface->Node.ACLs = &gVFS_ACL_EveryoneRX;
 586         iface->Node.ReadDir = IPStack_Iface_ReadDir;
 587         iface->Node.FindDir = IPStack_Iface_FindDir;
 588         iface->Node.IOCtl = IPStack_Iface_IOCtl;
 589         iface->Node.MkNod = NULL;
 590         iface->Node.Link = NULL;
 591         iface->Node.Relink = NULL;
 592         iface->Node.Close = NULL;
 593
 594         // Set Defaults
 595         iface->TimeoutDelay = DEFAULT_TIMEOUT;
 596
 597         // Get adapter handle
 598         iface->Adapter = IPStack_GetAdapter(Device);
 599         if( !iface->Adapter ) {
 600                 free( iface );
 601                 LEAVE('i', -1);
 602                 return -1;      // Return ERR_YOUFAIL
 603         }
 604
 605         // Delay setting ImplInt until after the adapter is opened
 606         // Keeps things simple
 607         iface->Node.ImplInt = giIP_NextIfaceId++;
 608
 609         // Append to list
 610         SHORTLOCK( &glIP_Interfaces );
 611         if( gIP_Interfaces ) {
 612                 gIP_Interfaces_Last->Next = iface;
 613                 gIP_Interfaces_Last = iface;
 614         }
 615         else {
 616                 gIP_Interfaces = iface;
 617                 gIP_Interfaces_Last = iface;
 618         }
 619         SHORTREL( &glIP_Interfaces );
 620
 621         gIP_DriverInfo.RootNode.Size ++;
 622
 623         // Success!
 624         LEAVE('i', iface->Node.ImplInt);
 625         return iface->Node.ImplInt;
 626 }
 627
 628 /**
 629  * \fn tAdapter *IPStack_GetAdapter(char *Path)
 630  * \brief Gets/opens an adapter given the path
 631  */
 632 tAdapter *IPStack_GetAdapter(char *Path)
 633 {
 634         tAdapter        *dev;
 635          int    tmp;
 636
 637         ENTER("sPath", Path);
 638
 639         Mutex_Acquire( &glIP_Adapters );
 640
 641         // Check if this adapter is already open
 642         for( dev = gIP_Adapters; dev; dev = dev->Next )
 643         {
 644                 if( strcmp(dev->Device, Path) == 0 ) {
 645                         dev->NRef ++;
 646                         Mutex_Release( &glIP_Adapters );
 647                         LEAVE('p', dev);
 648                         return dev;
 649                 }
 650         }
 651
 652         // Ok, so let's open it
 653         dev = malloc( sizeof(tAdapter) + strlen(Path) + 1 );
 654         if(!dev) {
 655                 Mutex_Release( &glIP_Adapters );
 656                 LEAVE('n');
 657                 return NULL;
 658         }
 659
 660         // Fill Structure
 661         strcpy( dev->Device, Path );
 662         dev->NRef = 1;
 663         dev->DeviceLen = strlen(Path);
 664
 665         // Open Device
 666         dev->DeviceFD = VFS_Open( dev->Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE );
 667         if( dev->DeviceFD == -1 ) {
 668                 free( dev );
 669                 Mutex_Release( &glIP_Adapters );
 670                 LEAVE('n');
 671                 return NULL;
 672         }
 673
 674         // Check that it is a network interface
 675         tmp = VFS_IOCtl(dev->DeviceFD, 0, NULL);
 676         LOG("Device type = %i", tmp);
 677         if( tmp != DRV_TYPE_NETWORK ) {
 678                 Warning("IPStack_GetAdapter: '%s' is not a network interface", dev->Device);
 679                 VFS_Close( dev->DeviceFD );
 680                 free( dev );
 681                 Mutex_Release( &glIP_Adapters );
 682                 LEAVE('n');
 683                 return NULL;
 684         }
 685
 686         // Get MAC Address
 687         VFS_IOCtl(dev->DeviceFD, NET_IOCTL_GETMAC, &dev->MacAddr);
 688
 689         // Add to list
 690         dev->Next = gIP_Adapters;
 691         gIP_Adapters = dev;
 692
 693         Mutex_Release( &glIP_Adapters );
 694
 695         // Start watcher
 696         Link_WatchDevice( dev );
 697
 698         LEAVE('p', dev);
 699         return dev;
 700 }
 701
 702 /**
 703  * \brief Gets the size (in bytes) of a specified form of address
 704  */
 705 int IPStack_GetAddressSize(int AddressType)
 706 {
 707         switch(AddressType)
 708         {
 709         default:
 710         case AF_NULL:
 711                 return 0;
 712         case AF_INET4:
 713                 return sizeof(tIPv4);
 714         case AF_INET6:
 715                 return sizeof(tIPv6);
 716         }
 717 }