Modules/IPStack/interface.c

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