src/add-ons/kernel/network/stack/link.cpp

   1 /*
   2  * Copyright 2006-2013, Haiku, Inc. All Rights Reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Axel Dörfler, axeld@pinc-software.de
   7  */
   8
   9
  10 //! The net_protocol one talks to when using the AF_LINK protocol
  11
  12
  13 #include "link.h"
  14
  15 #include <net/if_dl.h>
  16 #include <net/if_types.h>
  17 #include <new>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/sockio.h>
  21
  22 #include <KernelExport.h>
  23
  24 #include <lock.h>
  25 #include <net_datalink.h>
  26 #include <net_device.h>
  27 #include <ProtocolUtilities.h>
  28 #include <util/AutoLock.h>
  29
  30 #include "device_interfaces.h"
  31 #include "domains.h"
  32 #include "interfaces.h"
  33 #include "stack_private.h"
  34 #include "utility.h"
  35
  36
  37 class LocalStackBundle {
  38 public:
  39         static net_stack_module_info* Stack() { return &gNetStackModule; }
  40         static net_buffer_module_info* Buffer() { return &gNetBufferModule; }
  41 };
  42
  43 typedef DatagramSocket<MutexLocking, LocalStackBundle> LocalDatagramSocket;
  44
  45 class LinkProtocol : public net_protocol, public LocalDatagramSocket {
  46 public:
  47                                                                 LinkProtocol(net_socket* socket);
  48         virtual                                         ~LinkProtocol();
  49
  50                         status_t                        StartMonitoring(const char* deviceName);
  51                         status_t                        StopMonitoring(const char* deviceName);
  52
  53                         status_t                        Bind(const sockaddr* address);
  54                         status_t                        Unbind();
  55                         bool                            IsBound() const
  56                                                                         { return fBoundToDevice != NULL; }
  57
  58                         size_t                          MTU();
  59
  60 protected:
  61                         status_t                        SocketStatus(bool peek) const;
  62
  63 private:
  64                         status_t                        _Unregister();
  65
  66         static  status_t                        _MonitorData(net_device_monitor* monitor,
  67                                                                         net_buffer* buffer);
  68         static  void                            _MonitorEvent(net_device_monitor* monitor,
  69                                                                         int32 event);
  70         static  status_t                        _ReceiveData(void* cookie, net_device* device,
  71                                                                         net_buffer* buffer);
  72
  73 private:
  74                         net_device_monitor      fMonitor;
  75                         net_device_interface* fMonitoredDevice;
  76                         net_device_interface* fBoundToDevice;
  77                         uint32                          fBoundType;
  78 };
  79
  80
  81 struct net_domain* sDomain;
  82
  83
  84 LinkProtocol::LinkProtocol(net_socket* socket)
  85         :
  86         LocalDatagramSocket("packet capture", socket),
  87         fMonitoredDevice(NULL),
  88         fBoundToDevice(NULL)
  89 {
  90         fMonitor.cookie = this;
  91         fMonitor.receive = _MonitorData;
  92         fMonitor.event = _MonitorEvent;
  93 }
  94
  95
  96 LinkProtocol::~LinkProtocol()
  97 {
  98         if (fMonitoredDevice != NULL) {
  99                 unregister_device_monitor(fMonitoredDevice->device, &fMonitor);
 100                 put_device_interface(fMonitoredDevice);
 101         } else
 102                 Unbind();
 103 }
 104
 105
 106 status_t
 107 LinkProtocol::StartMonitoring(const char* deviceName)
 108 {
 109         MutexLocker locker(fLock);
 110
 111         if (fMonitoredDevice != NULL)
 112                 return B_BUSY;
 113
 114         net_device_interface* interface = get_device_interface(deviceName);
 115         if (interface == NULL)
 116                 return B_DEVICE_NOT_FOUND;
 117
 118         status_t status = register_device_monitor(interface->device, &fMonitor);
 119         if (status < B_OK) {
 120                 put_device_interface(interface);
 121                 return status;
 122         }
 123
 124         fMonitoredDevice = interface;
 125         return B_OK;
 126 }
 127
 128
 129 status_t
 130 LinkProtocol::StopMonitoring(const char* deviceName)
 131 {
 132         MutexLocker locker(fLock);
 133
 134         if (fMonitoredDevice == NULL
 135                 || strcmp(fMonitoredDevice->device->name, deviceName) != 0)
 136                 return B_BAD_VALUE;
 137
 138         return _Unregister();
 139 }
 140
 141
 142 status_t
 143 LinkProtocol::Bind(const sockaddr* address)
 144 {
 145         // Only root is allowed to bind to a link layer interface
 146         if (address == NULL || geteuid() != 0)
 147                 return B_NOT_ALLOWED;
 148
 149         MutexLocker locker(fLock);
 150
 151         if (fMonitoredDevice != NULL)
 152                 return B_BUSY;
 153
 154         Interface* interface = get_interface_for_link(sDomain, address);
 155         if (interface == NULL)
 156                 return B_BAD_VALUE;
 157
 158         net_device_interface* boundTo
 159                 = acquire_device_interface(interface->DeviceInterface());
 160
 161         interface->ReleaseReference();
 162
 163         if (boundTo == NULL)
 164                 return B_BAD_VALUE;
 165
 166         sockaddr_dl& linkAddress = *(sockaddr_dl*)address;
 167
 168         if (linkAddress.sdl_type != 0) {
 169                 fBoundType = B_NET_FRAME_TYPE(linkAddress.sdl_type,
 170                         ntohs(linkAddress.sdl_e_type));
 171                 // Bind to the type requested - this is needed in order to
 172                 // receive any buffers
 173                 // TODO: this could be easily changed by introducing catch all or rule
 174                 // based handlers!
 175                 status_t status = register_device_handler(boundTo->device, fBoundType,
 176                         &LinkProtocol::_ReceiveData, this);
 177                 if (status != B_OK)
 178                         return status;
 179         } else
 180                 fBoundType = 0;
 181
 182         fBoundToDevice = boundTo;
 183         socket->bound_to_device = boundTo->device->index;
 184
 185         memcpy(&socket->address, address, sizeof(struct sockaddr_storage));
 186         socket->address.ss_len = sizeof(struct sockaddr_storage);
 187
 188         return B_OK;
 189 }
 190
 191
 192 status_t
 193 LinkProtocol::Unbind()
 194 {
 195         MutexLocker locker(fLock);
 196
 197         if (fBoundToDevice == NULL)
 198                 return B_BAD_VALUE;
 199
 200         unregister_device_handler(fBoundToDevice->device, fBoundType);
 201         put_device_interface(fBoundToDevice);
 202
 203         socket->bound_to_device = 0;
 204         socket->address.ss_len = 0;
 205         return B_OK;
 206 }
 207
 208
 209 size_t
 210 LinkProtocol::MTU()
 211 {
 212         MutexLocker locker(fLock);
 213
 214         if (!IsBound())
 215                 return 0;
 216
 217         return fBoundToDevice->device->mtu;
 218 }
 219
 220
 221 status_t
 222 LinkProtocol::SocketStatus(bool peek) const
 223 {
 224         if (fMonitoredDevice == NULL && !IsBound())
 225                 return B_DEVICE_NOT_FOUND;
 226
 227         return LocalDatagramSocket::SocketStatus(peek);
 228 }
 229
 230
 231 status_t
 232 LinkProtocol::_Unregister()
 233 {
 234         if (fMonitoredDevice == NULL)
 235                 return B_BAD_VALUE;
 236
 237         status_t status = unregister_device_monitor(fMonitoredDevice->device,
 238                 &fMonitor);
 239         put_device_interface(fMonitoredDevice);
 240         fMonitoredDevice = NULL;
 241
 242         return status;
 243 }
 244
 245
 246 /*static*/ status_t
 247 LinkProtocol::_MonitorData(net_device_monitor* monitor, net_buffer* packet)
 248 {
 249         return ((LinkProtocol*)monitor->cookie)->EnqueueClone(packet);
 250 }
 251
 252
 253 /*static*/ void
 254 LinkProtocol::_MonitorEvent(net_device_monitor* monitor, int32 event)
 255 {
 256         LinkProtocol* protocol = (LinkProtocol*)monitor->cookie;
 257
 258         if (event == B_DEVICE_GOING_DOWN) {
 259                 MutexLocker _(protocol->fLock);
 260
 261                 protocol->_Unregister();
 262                 if (protocol->IsEmpty()) {
 263                         protocol->WakeAll();
 264                         notify_socket(protocol->socket, B_SELECT_READ, B_DEVICE_NOT_FOUND);
 265                 }
 266         }
 267 }
 268
 269
 270 /*static*/ status_t
 271 LinkProtocol::_ReceiveData(void* cookie, net_device* device, net_buffer* buffer)
 272 {
 273         LinkProtocol* protocol = (LinkProtocol*)cookie;
 274
 275         return protocol->Enqueue(buffer);
 276 }
 277
 278
 279 //      #pragma mark -
 280
 281
 282 static bool
 283 user_request_get_device_interface(void* value, struct ifreq& request,
 284         net_device_interface*& interface)
 285 {
 286         if (user_memcpy(&request, value, IF_NAMESIZE) < B_OK)
 287                 return false;
 288
 289         interface = get_device_interface(request.ifr_name);
 290         return true;
 291 }
 292
 293
 294 //      #pragma mark - net_protocol module
 295
 296
 297 static net_protocol*
 298 link_init_protocol(net_socket* socket)
 299 {
 300         LinkProtocol* protocol = new (std::nothrow) LinkProtocol(socket);
 301         if (protocol != NULL && protocol->InitCheck() < B_OK) {
 302                 delete protocol;
 303                 return NULL;
 304         }
 305
 306         return protocol;
 307 }
 308
 309
 310 static status_t
 311 link_uninit_protocol(net_protocol* protocol)
 312 {
 313         delete (LinkProtocol*)protocol;
 314         return B_OK;
 315 }
 316
 317
 318 static status_t
 319 link_open(net_protocol* protocol)
 320 {
 321         return B_OK;
 322 }
 323
 324
 325 static status_t
 326 link_close(net_protocol* protocol)
 327 {
 328         return B_OK;
 329 }
 330
 331
 332 static status_t
 333 link_free(net_protocol* protocol)
 334 {
 335         return B_OK;
 336 }
 337
 338
 339 static status_t
 340 link_connect(net_protocol* protocol, const struct sockaddr* address)
 341 {
 342         return B_NOT_SUPPORTED;
 343 }
 344
 345
 346 static status_t
 347 link_accept(net_protocol* protocol, struct net_socket** _acceptedSocket)
 348 {
 349         return B_NOT_SUPPORTED;
 350 }
 351
 352
 353 static status_t
 354 link_control(net_protocol* _protocol, int level, int option, void* value,
 355         size_t* _length)
 356 {
 357         LinkProtocol* protocol = (LinkProtocol*)_protocol;
 358
 359         switch (option) {
 360                 case SIOCGIFINDEX:
 361                 {
 362                         // get index of interface
 363                         net_device_interface* interface;
 364                         struct ifreq request;
 365                         if (!user_request_get_device_interface(value, request, interface))
 366                                 return B_BAD_ADDRESS;
 367
 368                         if (interface != NULL) {
 369                                 request.ifr_index = interface->device->index;
 370                                 put_device_interface(interface);
 371                         } else
 372                                 request.ifr_index = 0;
 373
 374                         return user_memcpy(value, &request, sizeof(struct ifreq));
 375                 }
 376                 case SIOCGIFNAME:
 377                 {
 378                         // get name of interface via index
 379                         struct ifreq request;
 380                         if (user_memcpy(&request, value, sizeof(struct ifreq)) < B_OK)
 381                                 return B_BAD_ADDRESS;
 382
 383                         net_device_interface* interface
 384                                 = get_device_interface(request.ifr_index);
 385                         if (interface == NULL)
 386                                 return B_DEVICE_NOT_FOUND;
 387
 388                         strlcpy(request.ifr_name, interface->device->name, IF_NAMESIZE);
 389                         put_device_interface(interface);
 390
 391                         return user_memcpy(value, &request, sizeof(struct ifreq));
 392                 }
 393
 394                 case SIOCGIFCOUNT:
 395                 {
 396                         // count number of interfaces
 397                         struct ifconf config;
 398                         config.ifc_value = count_device_interfaces();
 399
 400                         return user_memcpy(value, &config, sizeof(struct ifconf));
 401                 }
 402
 403                 case SIOCGIFCONF:
 404                 {
 405                         // retrieve available interfaces
 406                         struct ifconf config;
 407                         if (user_memcpy(&config, value, sizeof(struct ifconf)) < B_OK)
 408                                 return B_BAD_ADDRESS;
 409
 410                         status_t result = list_device_interfaces(config.ifc_buf,
 411                                 (size_t*)&config.ifc_len);
 412                         if (result != B_OK)
 413                                 return result;
 414
 415                         return user_memcpy(value, &config, sizeof(struct ifconf));
 416                 }
 417
 418                 case SIOCGIFADDR:
 419                 {
 420                         // get address of interface
 421                         net_device_interface* interface;
 422                         struct ifreq request;
 423                         if (!user_request_get_device_interface(value, request, interface))
 424                                 return B_BAD_ADDRESS;
 425
 426                         if (interface == NULL)
 427                                 return B_DEVICE_NOT_FOUND;
 428
 429                         sockaddr_storage address;
 430                         get_device_interface_address(interface, (sockaddr*)&address);
 431                         put_device_interface(interface);
 432
 433                         return user_memcpy(&((struct ifreq*)value)->ifr_addr,
 434                                 &address, address.ss_len);
 435                 }
 436
 437                 case SIOCGIFFLAGS:
 438                 {
 439                         // get flags of interface
 440                         net_device_interface* interface;
 441                         struct ifreq request;
 442                         if (!user_request_get_device_interface(value, request, interface))
 443                                 return B_BAD_ADDRESS;
 444
 445                         if (interface == NULL)
 446                                 return B_DEVICE_NOT_FOUND;
 447
 448                         request.ifr_flags = interface->device->flags;
 449                         put_device_interface(interface);
 450
 451                         return user_memcpy(&((struct ifreq*)value)->ifr_flags,
 452                                 &request.ifr_flags, sizeof(request.ifr_flags));
 453                 }
 454
 455                 case SIOCGIFMEDIA:
 456                 {
 457                         // get media
 458                         if (*_length < sizeof(ifmediareq))
 459                                 return B_BAD_VALUE;
 460
 461                         net_device_interface* interface;
 462                         struct ifmediareq request;
 463                         if (!user_request_get_device_interface(value, (ifreq&)request,
 464                                         interface))
 465                                 return B_BAD_ADDRESS;
 466
 467                         if (interface == NULL)
 468                                 return B_DEVICE_NOT_FOUND;
 469
 470                         if (user_memcpy(&request, value, sizeof(ifmediareq)) != B_OK) {
 471                                 put_device_interface(interface);
 472                                 return B_BAD_ADDRESS;
 473                         }
 474
 475                         // TODO: see above.
 476                         if (interface->device->module->control(interface->device,
 477                                         SIOCGIFMEDIA, &request,
 478                                         sizeof(struct ifmediareq)) != B_OK) {
 479                                 memset(&request, 0, sizeof(struct ifmediareq));
 480                                 request.ifm_active = request.ifm_current
 481                                         = interface->device->media;
 482                         }
 483                         put_device_interface(interface);
 484
 485                         return user_memcpy(value, &request, sizeof(struct ifmediareq));
 486                 }
 487
 488                 case SIOCSPACKETCAP:
 489                 {
 490                         // Only root is allowed to capture packets
 491                         if (geteuid() != 0)
 492                                 return B_NOT_ALLOWED;
 493
 494                         struct ifreq request;
 495                         if (user_memcpy(&request, value, IF_NAMESIZE) != B_OK)
 496                                 return B_BAD_ADDRESS;
 497
 498                         return protocol->StartMonitoring(request.ifr_name);
 499                 }
 500
 501                 case SIOCCPACKETCAP:
 502                 {
 503                         struct ifreq request;
 504                         if (user_memcpy(&request, value, IF_NAMESIZE) != B_OK)
 505                                 return B_BAD_ADDRESS;
 506
 507                         return protocol->StopMonitoring(request.ifr_name);
 508                 }
 509         }
 510
 511         return gNetDatalinkModule.control(sDomain, option, value, _length);
 512 }
 513
 514
 515 static status_t
 516 link_getsockopt(net_protocol* protocol, int level, int option, void* value,
 517         int* length)
 518 {
 519         if (protocol->next != NULL) {
 520                 return protocol->next->module->getsockopt(protocol, level, option,
 521                         value, length);
 522         }
 523
 524         return gNetSocketModule.get_option(protocol->socket, level, option, value,
 525                 length);
 526 }
 527
 528
 529 static status_t
 530 link_setsockopt(net_protocol* protocol, int level, int option,
 531         const void* value, int length)
 532 {
 533         if (protocol->next != NULL) {
 534                 return protocol->next->module->setsockopt(protocol, level, option,
 535                         value, length);
 536         }
 537
 538         return gNetSocketModule.set_option(protocol->socket, level, option,
 539                 value, length);
 540 }
 541
 542
 543 static status_t
 544 link_bind(net_protocol* _protocol, const struct sockaddr* address)
 545 {
 546         LinkProtocol* protocol = (LinkProtocol*)_protocol;
 547         return protocol->Bind(address);
 548 }
 549
 550
 551 static status_t
 552 link_unbind(net_protocol* _protocol, struct sockaddr* address)
 553 {
 554         LinkProtocol* protocol = (LinkProtocol*)_protocol;
 555         return protocol->Unbind();
 556 }
 557
 558
 559 static status_t
 560 link_listen(net_protocol* protocol, int count)
 561 {
 562         return B_NOT_SUPPORTED;
 563 }
 564
 565
 566 static status_t
 567 link_shutdown(net_protocol* protocol, int direction)
 568 {
 569         return B_NOT_SUPPORTED;
 570 }
 571
 572
 573 static status_t
 574 link_send_data(net_protocol* protocol, net_buffer* buffer)
 575 {
 576         return gNetDatalinkModule.send_data(protocol, sDomain, buffer);
 577 }
 578
 579
 580 static status_t
 581 link_send_routed_data(net_protocol* protocol, struct net_route* route,
 582         net_buffer* buffer)
 583 {
 584         if (buffer->destination->sa_family != buffer->source->sa_family
 585                 || buffer->destination->sa_family != AF_LINK)
 586                 return B_BAD_VALUE;
 587
 588         // The datalink layer will take care of the framing
 589
 590         return gNetDatalinkModule.send_routed_data(route, buffer);
 591 }
 592
 593
 594 static ssize_t
 595 link_send_avail(net_protocol* _protocol)
 596 {
 597         LinkProtocol* protocol = (LinkProtocol*)_protocol;
 598         if (!protocol->IsBound())
 599                 return B_ERROR;
 600
 601         return protocol->socket->send.buffer_size;
 602 }
 603
 604
 605 static status_t
 606 link_read_data(net_protocol* protocol, size_t numBytes, uint32 flags,
 607         net_buffer** _buffer)
 608 {
 609         return ((LinkProtocol*)protocol)->Dequeue(flags, _buffer);
 610 }
 611
 612
 613 static ssize_t
 614 link_read_avail(net_protocol* protocol)
 615 {
 616         return ((LinkProtocol*)protocol)->AvailableData();
 617 }
 618
 619
 620 static struct net_domain*
 621 link_get_domain(net_protocol* protocol)
 622 {
 623         return sDomain;
 624 }
 625
 626
 627 static size_t
 628 link_get_mtu(net_protocol* _protocol, const struct sockaddr* address)
 629 {
 630         LinkProtocol* protocol = (LinkProtocol*)_protocol;
 631         return protocol->MTU();
 632 }
 633
 634
 635 static status_t
 636 link_receive_data(net_buffer* buffer)
 637 {
 638         // We never receive any data this way
 639         return B_ERROR;
 640 }
 641
 642
 643 static status_t
 644 link_error_received(net_error error, net_buffer* data)
 645 {
 646         // We don't do any error processing
 647         return B_ERROR;
 648 }
 649
 650
 651 static status_t
 652 link_error_reply(net_protocol* protocol, net_buffer* cause, net_error error,
 653         net_error_data* errorData)
 654 {
 655         // We don't do any error processing
 656         return B_ERROR;
 657 }
 658
 659
 660 static status_t
 661 link_std_ops(int32 op, ...)
 662 {
 663         switch (op) {
 664                 case B_MODULE_INIT:
 665                         return register_domain(AF_LINK, "link", NULL, NULL, &sDomain);
 666
 667                 case B_MODULE_UNINIT:
 668                         unregister_domain(sDomain);
 669                         return B_OK;
 670
 671                 default:
 672                         return B_ERROR;
 673         }
 674 }
 675
 676
 677 //      #pragma mark -
 678
 679
 680 void
 681 link_init()
 682 {
 683         register_domain_protocols(AF_LINK, SOCK_DGRAM, 0, "network/stack/link/v1",
 684                 NULL);
 685
 686         // TODO: this should actually be registered for all types (besides local)
 687         register_domain_datalink_protocols(AF_LINK, IFT_ETHER,
 688                 "network/datalink_protocols/ethernet_frame/v1",
 689                 NULL);
 690 }
 691
 692
 693 net_protocol_module_info gLinkModule = {
 694         {
 695                 "network/stack/link/v1",
 696                 0,
 697                 link_std_ops
 698         },
 699         NET_PROTOCOL_ATOMIC_MESSAGES,
 700
 701         link_init_protocol,
 702         link_uninit_protocol,
 703         link_open,
 704         link_close,
 705         link_free,
 706         link_connect,
 707         link_accept,
 708         link_control,
 709         link_getsockopt,
 710         link_setsockopt,
 711         link_bind,
 712         link_unbind,
 713         link_listen,
 714         link_shutdown,
 715         link_send_data,
 716         link_send_routed_data,
 717         link_send_avail,
 718         link_read_data,
 719         link_read_avail,
 720         link_get_domain,
 721         link_get_mtu,
 722         link_receive_data,
 723         NULL,           // deliver_data
 724         link_error_received,
 725         link_error_reply,
 726         NULL,           // add_ancillary_data()
 727         NULL,           // process_ancillary_data()
 728         NULL,           // process_ancillary_data_no_container()
 729         NULL,           // send_data_no_buffer()
 730         NULL            // read_data_no_buffer()
 731 };