Modules/IPStack/main.c

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