Modules/IPStack/main.c

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