1 /* 2 * Copyright 2006-2010, 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 return B_BAD_ADDRESS; 472 473 // TODO: see above. 474 if (interface->device->module->control(interface->device, 475 SIOCGIFMEDIA, &request, 476 sizeof(struct ifmediareq)) != B_OK) { 477 memset(&request, 0, sizeof(struct ifmediareq)); 478 request.ifm_active = request.ifm_current 479 = interface->device->media; 480 } 481 482 return user_memcpy(value, &request, sizeof(struct ifmediareq)); 483 } 484 485 case SIOCSPACKETCAP: 486 { 487 // Only root is allowed to capture packets 488 if (geteuid() != 0) 489 return B_NOT_ALLOWED; 490 491 struct ifreq request; 492 if (user_memcpy(&request, value, IF_NAMESIZE) != B_OK) 493 return B_BAD_ADDRESS; 494 495 return protocol->StartMonitoring(request.ifr_name); 496 } 497 498 case SIOCCPACKETCAP: 499 { 500 struct ifreq request; 501 if (user_memcpy(&request, value, IF_NAMESIZE) != B_OK) 502 return B_BAD_ADDRESS; 503 504 return protocol->StopMonitoring(request.ifr_name); 505 } 506 } 507 508 return gNetDatalinkModule.control(sDomain, option, value, _length); 509 } 510 511 512 static status_t 513 link_getsockopt(net_protocol* protocol, int level, int option, void* value, 514 int* length) 515 { 516 if (protocol->next != NULL) { 517 return protocol->next->module->getsockopt(protocol, level, option, 518 value, length); 519 } 520 521 return gNetSocketModule.get_option(protocol->socket, level, option, value, 522 length); 523 } 524 525 526 static status_t 527 link_setsockopt(net_protocol* protocol, int level, int option, 528 const void* value, int length) 529 { 530 if (protocol->next != NULL) { 531 return protocol->next->module->setsockopt(protocol, level, option, 532 value, length); 533 } 534 535 return gNetSocketModule.set_option(protocol->socket, level, option, 536 value, length); 537 } 538 539 540 static status_t 541 link_bind(net_protocol* _protocol, const struct sockaddr* address) 542 { 543 LinkProtocol* protocol = (LinkProtocol*)_protocol; 544 return protocol->Bind(address); 545 } 546 547 548 static status_t 549 link_unbind(net_protocol* _protocol, struct sockaddr* address) 550 { 551 LinkProtocol* protocol = (LinkProtocol*)_protocol; 552 return protocol->Unbind(); 553 } 554 555 556 static status_t 557 link_listen(net_protocol* protocol, int count) 558 { 559 return B_NOT_SUPPORTED; 560 } 561 562 563 static status_t 564 link_shutdown(net_protocol* protocol, int direction) 565 { 566 return B_NOT_SUPPORTED; 567 } 568 569 570 static status_t 571 link_send_data(net_protocol* protocol, net_buffer* buffer) 572 { 573 return gNetDatalinkModule.send_data(protocol, sDomain, buffer); 574 } 575 576 577 static status_t 578 link_send_routed_data(net_protocol* protocol, struct net_route* route, 579 net_buffer* buffer) 580 { 581 if (buffer->destination->sa_family != buffer->source->sa_family 582 || buffer->destination->sa_family != AF_LINK) 583 return B_BAD_VALUE; 584 585 // The datalink layer will take care of the framing 586 587 return gNetDatalinkModule.send_routed_data(route, buffer); 588 } 589 590 591 static ssize_t 592 link_send_avail(net_protocol* _protocol) 593 { 594 LinkProtocol* protocol = (LinkProtocol*)_protocol; 595 if (!protocol->IsBound()) 596 return B_ERROR; 597 598 return protocol->socket->send.buffer_size; 599 } 600 601 602 static status_t 603 link_read_data(net_protocol* protocol, size_t numBytes, uint32 flags, 604 net_buffer** _buffer) 605 { 606 return ((LinkProtocol*)protocol)->Dequeue(flags, _buffer); 607 } 608 609 610 static ssize_t 611 link_read_avail(net_protocol* protocol) 612 { 613 return ((LinkProtocol*)protocol)->AvailableData(); 614 } 615 616 617 static struct net_domain* 618 link_get_domain(net_protocol* protocol) 619 { 620 return sDomain; 621 } 622 623 624 static size_t 625 link_get_mtu(net_protocol* _protocol, const struct sockaddr* address) 626 { 627 LinkProtocol* protocol = (LinkProtocol*)_protocol; 628 return protocol->MTU(); 629 } 630 631 632 static status_t 633 link_receive_data(net_buffer* buffer) 634 { 635 // We never receive any data this way 636 return B_ERROR; 637 } 638 639 640 static status_t 641 link_error_received(net_error error, net_buffer* data) 642 { 643 // We don't do any error processing 644 return B_ERROR; 645 } 646 647 648 static status_t 649 link_error_reply(net_protocol* protocol, net_buffer* cause, net_error error, 650 net_error_data* errorData) 651 { 652 // We don't do any error processing 653 return B_ERROR; 654 } 655 656 657 static status_t 658 link_std_ops(int32 op, ...) 659 { 660 switch (op) { 661 case B_MODULE_INIT: 662 return register_domain(AF_LINK, "link", NULL, NULL, &sDomain); 663 664 case B_MODULE_UNINIT: 665 unregister_domain(sDomain); 666 return B_OK; 667 668 default: 669 return B_ERROR; 670 } 671 } 672 673 674 // #pragma mark - 675 676 677 void 678 link_init() 679 { 680 register_domain_protocols(AF_LINK, SOCK_DGRAM, 0, "network/stack/link/v1", 681 NULL); 682 683 // TODO: this should actually be registered for all types (besides local) 684 register_domain_datalink_protocols(AF_LINK, IFT_ETHER, 685 "network/datalink_protocols/ethernet_frame/v1", 686 NULL); 687 } 688 689 690 net_protocol_module_info gLinkModule = { 691 { 692 "network/stack/link/v1", 693 0, 694 link_std_ops 695 }, 696 NET_PROTOCOL_ATOMIC_MESSAGES, 697 698 link_init_protocol, 699 link_uninit_protocol, 700 link_open, 701 link_close, 702 link_free, 703 link_connect, 704 link_accept, 705 link_control, 706 link_getsockopt, 707 link_setsockopt, 708 link_bind, 709 link_unbind, 710 link_listen, 711 link_shutdown, 712 link_send_data, 713 link_send_routed_data, 714 link_send_avail, 715 link_read_data, 716 link_read_avail, 717 link_get_domain, 718 link_get_mtu, 719 link_receive_data, 720 NULL, // deliver_data 721 link_error_received, 722 link_error_reply, 723 NULL, // add_ancillary_data() 724 NULL, // process_ancillary_data() 725 NULL, // process_ancillary_data_no_container() 726 NULL, // send_data_no_buffer() 727 NULL // read_data_no_buffer() 728 }; 729