Modules/IPStack/main.c

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