src/add-ons/kernel/network/ppp/pppoe/pppoe.cpp

   1 /*
   2  * Copyright 2003-2006, Waldemar Kornewald <wkornew@gmx.net>
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6 #include <KernelExport.h>
   7 #include <driver_settings.h>
   8
   9 #include <lock.h>
  10 #include <util/AutoLock.h>
  11 #include <ByteOrder.h>
  12
  13 #include <net/if_types.h>
  14 #include <net/if_dl.h>
  15 #include <net/if.h>
  16 #include <sys/sockio.h>
  17
  18 #include <net_buffer.h>
  19 #include <net_datalink.h> // for get_interface and control
  20 #include <net_stack.h>
  21 #include <NetBufferUtilities.h>
  22
  23 #include <KPPPInterface.h>
  24 #include <KPPPModule.h>
  25 #include <KPPPUtils.h>
  26
  27 #include "PPPoEDevice.h"
  28 #include "DiscoveryPacket.h"
  29
  30
  31 typedef struct pppoe_query {
  32         net_device *ethernetIfnet;
  33         uint32 hostUniq;
  34         thread_id receiver;
  35 } pppoe_query;
  36
  37 #define PPPoE_MODULE_NAME       "network/ppp/pppoe"
  38
  39 net_stack_module_info *gStackModule = NULL;
  40 net_buffer_module_info *gBufferModule = NULL;
  41 net_datalink_module_info *sDatalinkModule = NULL;
  42
  43 static int32 sHostUniq = 0;
  44 status_t std_ops(int32 op, ...);
  45
  46 // static mutex sLock("PPPoEList");
  47
  48 static TemplateList<PPPoEDevice*> *sDevices;
  49 static TemplateList<pppoe_query*> *sQueries;
  50
  51
  52 static
  53 void
  54 SendQueryPacket(pppoe_query *query, DiscoveryPacket& discovery)
  55 {
  56         char data[PPPoE_QUERY_REPORT_SIZE];
  57         uint32 position = sizeof(uint32);
  58         pppoe_tag *acName = discovery.TagWithType(AC_NAME);
  59
  60         if (acName) {
  61                 if (acName->length >= PPPoE_QUERY_REPORT_SIZE)
  62                         return;
  63
  64                 memcpy(data + position, acName->data, acName->length);
  65                 position += acName->length;
  66         }
  67
  68         data[position++] = 0;
  69
  70         pppoe_tag *tag;
  71         for (int32 index = 0; index < discovery.CountTags(); index++) {
  72                 tag = discovery.TagAt(index);
  73                 if (tag && tag->type == SERVICE_NAME) {
  74                         if (position + tag->length >= PPPoE_QUERY_REPORT_SIZE)
  75                                 return;
  76
  77                         memcpy(data + position, tag->data, tag->length);
  78                         position += tag->length;
  79                         data[position++] = 0;
  80                 }
  81         }
  82
  83         memcpy(data, &position, sizeof(uint32));
  84                 // add the total length
  85
  86         send_data_with_timeout(query->receiver, PPPoE_QUERY_REPORT, data,
  87                 PPPoE_QUERY_REPORT_SIZE, 700000);
  88 }
  89
  90
  91 net_interface *
  92 get_interface_by_name(net_domain *domain, const char *name)
  93 {
  94         ifreq request;
  95         memset(&request, 0, sizeof(request));
  96         size_t size = sizeof(request);
  97
  98         strlcpy(request.ifr_name, name, IF_NAMESIZE);
  99
 100         if (sDatalinkModule->control(domain, SIOCGIFINDEX, &request, &size) != B_OK) {
 101                 TRACE("sDatalinkModule->control failure\n");
 102                 return NULL;
 103         }
 104         return sDatalinkModule->get_interface(domain, request.ifr_index);
 105 }
 106
 107
 108 net_device*
 109 FindPPPoEInterface(const char *name)
 110 {
 111         if (!name)
 112                 return NULL;
 113
 114         net_interface* ethernetInterfaceOfPPPOE = NULL;
 115         net_domain* domain = NULL;
 116
 117         domain = gStackModule->get_domain(AF_INET);
 118         ethernetInterfaceOfPPPOE = get_interface_by_name(domain, name);
 119
 120         if (ethernetInterfaceOfPPPOE == NULL) {
 121                 TRACE("get_interface_by_name can not find eth\n");
 122                 return NULL;
 123         }
 124
 125         if (ethernetInterfaceOfPPPOE->device)
 126                 return ethernetInterfaceOfPPPOE->device;
 127
 128         return NULL;
 129 }
 130
 131
 132 uint32
 133 NewHostUniq()
 134 {
 135         return (uint32) atomic_add(&sHostUniq, 1);
 136 }
 137
 138
 139 void
 140 add_device(PPPoEDevice *device)
 141 {
 142         TRACE("PPPoE: add_device()\n");
 143
 144         // MutexLocker locker(sLock);
 145         if (!sDevices->HasItem(device))
 146                 sDevices->AddItem(device);
 147 }
 148
 149
 150 void
 151 remove_device(PPPoEDevice *device)
 152 {
 153         TRACE("PPPoE: remove_device()\n");
 154
 155         // MutexLocker locker(sLock);
 156         sDevices->RemoveItem(device);
 157 }
 158
 159
 160 status_t
 161 pppoe_input(void *cookie, net_device *_device, net_buffer *packet)
 162 {
 163         if (!packet)
 164                 return B_ERROR;
 165
 166         NetBufferHeaderReader<pppoe_header> bufferheader(packet);
 167         if (bufferheader.Status() != B_OK)
 168                 return B_ERROR;
 169
 170         pppoe_header &header = bufferheader.Data();
 171
 172         // remove the following lines when pppoe server is enabled
 173         if (header.code == PADI) {
 174                 TRACE("PADI packet received, ignoreing!\n");
 175                 gBufferModule->free(packet);
 176                 return B_OK;
 177         }
 178
 179         if (header.code == PADO || header.code == PADR || header.code == PADS || header.code == PADT)
 180         {
 181                 uint8 peerEtherAddr[ETHER_ADDRESS_LENGTH];
 182                 struct sockaddr_dl& source = *(struct sockaddr_dl*)packet->source;
 183                 memcpy(peerEtherAddr, source.sdl_data, ETHER_ADDRESS_LENGTH);
 184                 const char *str = header.code == PADI ? "PADI" :
 185                         header.code == PADO ? "PADO" :
 186                         header.code == PADR ? "PADR" :
 187                         header.code == PADS ? "PADS" :
 188                         "PADT" ;
 189
 190                 dprintf("%s from:%02x:%02x:%02x:%02x:%02x:%02x code:%02x\n", str,
 191                         peerEtherAddr[0], peerEtherAddr[1], peerEtherAddr[2],
 192                         peerEtherAddr[3], peerEtherAddr[4], peerEtherAddr[5],
 193                         header.code);
 194         }
 195
 196         PPPoEDevice *device;
 197         pppoe_query *query;
 198
 199         sockaddr_dl& linkAddress = *(sockaddr_dl*)packet->source;
 200         int32 specificType = B_NET_FRAME_TYPE(linkAddress.sdl_type,
 201                                 ntohs(linkAddress.sdl_e_type));
 202
 203         // MutexLocker locker(sLock);
 204
 205         if (specificType == B_NET_FRAME_TYPE_PPPOE_DISCOVERY
 206                         && ntohs(header.length) <= PPPoE_QUERY_REPORT_SIZE) {
 207                 for (int32 index = 0; index < sDevices->CountItems(); index++) {
 208                         query = sQueries->ItemAt(index);
 209
 210                         if (query) {// && query->ethernetIfnet == sourceIfnet) {
 211                                 if (header.code == PADO) {
 212                                         DiscoveryPacket discovery(packet, ETHER_HDR_LEN);
 213                                         if (discovery.InitCheck() != B_OK) {
 214                                                 ERROR("PPPoE: received corrupted discovery packet!\n");
 215                                                 // gBufferModule->free(packet);
 216                                                 return B_ERROR;
 217                                         }
 218
 219                                         pppoe_tag *hostTag = discovery.TagWithType(HOST_UNIQ);
 220                                         if (hostTag && hostTag->length == 4
 221                                                         && *((uint32*)hostTag->data) == query->hostUniq) {
 222                                                 SendQueryPacket(query, discovery);
 223                                                 // gBufferModule->free(packet);
 224                                                 return B_ERROR;
 225                                         }
 226                                 }
 227                         }
 228                 }
 229         }
 230
 231         TRACE("in pppoed processing sDevices->CountItems(): %" B_PRId32 "\n",
 232                 sDevices->CountItems());
 233
 234         for (int32 index = 0; index < sDevices->CountItems(); index++) {
 235                 device = sDevices->ItemAt(index);
 236
 237                 TRACE("device->SessionID() %d, header.sessionID: %d\n", device->SessionID(),
 238                                                 header.sessionID);
 239
 240                 if (device) { // && device->EthernetIfnet() == sourceIfnet) {
 241                         if (specificType == B_NET_FRAME_TYPE_PPPOE
 242                                         && header.sessionID == device->SessionID()) {
 243                                 TRACE("PPPoE: session packet\n");
 244                                 device->Receive(packet);
 245                                 return B_OK;
 246                         }
 247
 248                         if (specificType == B_NET_FRAME_TYPE_PPPOE_DISCOVERY
 249                                         && header.code != PADI
 250                                         && header.code != PADR
 251                                         && !device->IsDown()) {
 252                                 TRACE("PPPoE: discovery packet\n");
 253
 254                                 DiscoveryPacket discovery(packet, ETHER_HDR_LEN);
 255                                 if (discovery.InitCheck() != B_OK) {
 256                                         ERROR("PPPoE: received corrupted discovery packet!\n");
 257                                         gBufferModule->free(packet);
 258                                         return B_OK;
 259                                 }
 260
 261                                 pppoe_tag *tag = discovery.TagWithType(HOST_UNIQ);
 262                                 if (header.code == PADT || (tag && tag->length == 4
 263                                         && *((uint32*)tag->data) == device->HostUniq())) {
 264                                         device->Receive(packet);
 265                                         return B_OK;
 266                                 }
 267                         }
 268                 }
 269         }
 270
 271         ERROR("PPPoE: No device found for packet from: %s\n", "ethernet");
 272         // gBufferModule->free(packet);
 273         return B_ERROR;
 274 }
 275
 276
 277 static
 278 bool
 279 add_to(KPPPInterface& mainInterface, KPPPInterface *subInterface,
 280         driver_parameter *settings, ppp_module_key_type type)
 281 {
 282         if (mainInterface.Mode() != PPP_CLIENT_MODE || type != PPP_DEVICE_KEY_TYPE)
 283                 return B_ERROR;
 284
 285         PPPoEDevice *device;
 286         bool success;
 287         if (subInterface) {
 288                 device = new PPPoEDevice(*subInterface, settings);
 289                 success = subInterface->SetDevice(device);
 290         } else {
 291                 device = new PPPoEDevice(mainInterface, settings);
 292                 success = mainInterface.SetDevice(device);
 293         }
 294
 295         TRACE("PPPoE: add_to(): %s\n",
 296                 success && device && device->InitCheck() == B_OK ? "OK" : "ERROR");
 297
 298         return success && device && device->InitCheck() == B_OK;
 299 }
 300
 301
 302 static
 303 status_t
 304 control(uint32 op, void *data, size_t length)
 305 {
 306         switch (op) {
 307                 case PPPoE_GET_INTERFACES: {
 308                         int32 position = 0, count = 0;
 309                         char *names = (char*) data;
 310
 311                         net_device *current = NULL; // get_interfaces();
 312                         for (; current; current = NULL) {
 313                                 if (current->type == IFT_ETHER && current->name) {
 314                                         if (position + strlen(current->name) + 1 > length)
 315                                                 return B_NO_MEMORY;
 316
 317                                         strcpy(names + position, current->name);
 318                                         position += strlen(current->name);
 319                                         names[position++] = 0;
 320                                         ++count;
 321                                 }
 322                         }
 323
 324                         return count;
 325                 }
 326
 327                 case PPPoE_QUERY_SERVICES: {
 328                         // XXX: as all modules are loaded on-demand we must wait for the results
 329
 330                         if (!data || length != sizeof(pppoe_query_request))
 331                                 return B_ERROR;
 332
 333                         pppoe_query_request *request = (pppoe_query_request*) data;
 334
 335                         pppoe_query query;
 336                         query.ethernetIfnet = FindPPPoEInterface(request->interfaceName);
 337                         if (!query.ethernetIfnet)
 338                                 return B_BAD_VALUE;
 339
 340                         query.hostUniq = NewHostUniq();
 341                         query.receiver = request->receiver;
 342
 343                         {
 344                                 // MutexLocker tlocker(sLock);
 345                                 TRACE("add query\n");
 346                                 sQueries->AddItem(&query);
 347                         }
 348
 349                         snooze(2000000);
 350                                 // wait two seconds for results
 351                         {
 352                                 // MutexLocker tlocker(sLock);
 353                                 TRACE("remove query\n");
 354                                 sQueries->RemoveItem(&query);
 355                         }
 356                 } break;
 357
 358                 default:
 359                         return B_ERROR;
 360         }
 361
 362         return B_OK;
 363 }
 364
 365
 366 static ppp_module_info pppoe_module = {
 367         {
 368                 PPPoE_MODULE_NAME,
 369                 0,
 370                 std_ops
 371         },
 372         control,
 373         add_to
 374 };
 375
 376
 377 _EXPORT
 378 status_t
 379 std_ops(int32 op, ...)
 380 {
 381         switch(op) {
 382                 case B_MODULE_INIT:
 383                         if (get_module(NET_STACK_MODULE_NAME,
 384                                 (module_info**)&gStackModule) != B_OK)
 385                                 return B_ERROR;
 386
 387                         if (get_module(NET_DATALINK_MODULE_NAME,
 388                                 (module_info **)&sDatalinkModule) != B_OK) {
 389                                 put_module(NET_STACK_MODULE_NAME);
 390                                 return B_ERROR;
 391                         }
 392
 393                         if (get_module(NET_BUFFER_MODULE_NAME,
 394                                 (module_info **)&gBufferModule) != B_OK) {
 395                                 put_module(NET_DATALINK_MODULE_NAME);
 396                                 put_module(NET_STACK_MODULE_NAME);
 397                                 return B_ERROR;
 398                         }
 399
 400                         // set_max_linkhdr(2 + PPPoE_HEADER_SIZE + ETHER_HDR_LEN);
 401                                 // 2 bytes for PPP header
 402                         sDevices = new TemplateList<PPPoEDevice*>;
 403                         sQueries = new TemplateList<pppoe_query*>;
 404
 405                         TRACE("PPPoE: Registered PPPoE receiver.\n");
 406                         return B_OK;
 407
 408                 case B_MODULE_UNINIT:
 409                         delete sQueries;
 410                         delete sDevices;
 411                         TRACE("PPPoE: Unregistered PPPoE receiver.\n");
 412                         put_module(NET_BUFFER_MODULE_NAME);
 413                         put_module(NET_DATALINK_MODULE_NAME);
 414                         put_module(NET_STACK_MODULE_NAME);
 415                         break;
 416
 417                 default:
 418                         return B_ERROR;
 419         }
 420
 421         return B_OK;
 422 }
 423
 424
 425 _EXPORT
 426 module_info *modules[] = {
 427         (module_info*) &pppoe_module,
 428         NULL
 429 };