1 /*---------------------------------------------------------------------------* 2 Project: Horizon 3 File: socket_Berkeley.h 4 5 Copyright (C)2010 Nintendo Co., Ltd. All rights reserved. 6 7 These coded instructions, statements, and computer programs contain 8 proprietary information of Nintendo of America Inc. and/or Nintendo 9 Company Ltd., and are protected by Federal copyright law. They may 10 not be disclosed to third parties or copied or duplicated in any form, 11 in whole or in part, without the prior written consent of Nintendo. 12 13 $Rev: 35860 $ 14 *---------------------------------------------------------------------------*/ 15 16 #ifndef NN_SOCKET_SOCKET_BERKLEY_H_ 17 #define NN_SOCKET_SOCKET_BERKLEY_H_ 18 19 #include <nn/socket/socket_Types.h> 20 #include <nn/socket/socket_Const.h> 21 #include <nn/socket/socket_IpcWrapper.h> 22 #include <nn/socket/socket_Result.h> 23 24 /* 25 Uses IPC to mask the differences in return values and arguments 26 */ 27 28 namespace nn { 29 namespace socket { 30 /* Please see man pages for details 31 32 33 34 */ 35 36 /* Please see man pages for details 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 */ Socket(s32 af,s32 type,s32 protocol)62 inline s32 Socket(s32 af, s32 type, s32 protocol) 63 { 64 s32 rval = 0; 65 Result result = detail::Socket(&rval, af, type, protocol); 66 NN_SOCKET_RETURN_IF_FAILED(result); 67 return rval; 68 } 69 70 /* Please see man pages for details 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 */ Listen(s32 s,s32 backlog)89 inline s32 Listen(s32 s, s32 backlog) 90 { 91 s32 rval = 0; 92 Result result = detail::Listen(&rval, s, backlog); 93 NN_SOCKET_RETURN_IF_FAILED(result); 94 return rval; 95 } 96 97 /* Please see man pages for details 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 */ Accept(s32 s,SockAddrIn * sockAddr)135 inline s32 Accept(s32 s, SockAddrIn* sockAddr) 136 { 137 s32 rval = 0; 138 Result result = detail::Accept(&rval, s, reinterpret_cast<u8*>(sockAddr), sizeof(SockAddrIn)); 139 NN_SOCKET_RETURN_IF_FAILED(result); 140 return rval; 141 } 142 143 /* Please see man pages for details 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 */ Bind(s32 s,const SockAddrIn * sockAddr)167 inline s32 Bind(s32 s, const SockAddrIn* sockAddr) 168 { 169 s32 rval = 0; 170 Result result = detail::Bind(&rval, s, reinterpret_cast<const u8*>(sockAddr), sizeof(SockAddrIn)); 171 NN_SOCKET_RETURN_IF_FAILED(result); 172 return rval; 173 } 174 175 /* Please see man pages for details 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 */ Connect(s32 s,const SockAddrIn * sockAddr)218 inline s32 Connect(s32 s, const SockAddrIn* sockAddr) 219 { 220 s32 rval = 0; 221 Result result = detail::Connect(&rval, s, reinterpret_cast<const u8*>(sockAddr), sizeof(SockAddrIn)); 222 NN_SOCKET_RETURN_IF_FAILED(result); 223 return rval; 224 } 225 226 /* Please see man pages for details 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 */ RecvFrom(s32 s,void * buf,s32 len,s32 flags,SockAddrIn * sockFrom)281 inline s32 RecvFrom(s32 s, void* buf, s32 len, s32 flags, SockAddrIn* sockFrom) 282 { 283 s32 rval; 284 Result result; 285 if (len <= detail::COPY_OR_MAP_THRESHOLD) 286 { 287 result = detail::RecvFromSmall(&rval, s, reinterpret_cast<u8*>(buf), len, flags, reinterpret_cast<u8*>(sockFrom), sizeof(SockAddrIn)); 288 } 289 else 290 { 291 result = detail::RecvFrom(&rval, s, reinterpret_cast<u8*>(buf), len, flags, reinterpret_cast<u8*>(sockFrom), sizeof(SockAddrIn)); 292 } 293 NN_SOCKET_RETURN_IF_FAILED(result); 294 return rval; 295 } 296 297 /* Please see man pages for details 298 299 300 301 302 303 304 305 306 307 308 309 */ Recv(s32 s,void * buf,s32 len,s32 flags)310 inline s32 Recv(s32 s, void* buf, s32 len, s32 flags) 311 { 312 return RecvFrom(s, buf, len, flags, NULL); 313 } 314 315 /* Please see man pages for details 316 317 318 319 320 321 322 323 324 325 326 */ Read(s32 s,void * buf,s32 len)327 inline s32 Read(s32 s, void* buf, s32 len) 328 { 329 return RecvFrom(s, buf, len, 0, NULL); 330 } 331 332 /* Please see man pages for details 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 */ SendTo(s32 s,const void * buf,s32 len,s32 flags,const SockAddrIn * sockTo)381 inline s32 SendTo(s32 s, const void* buf, s32 len, s32 flags, const SockAddrIn* sockTo) 382 { 383 s32 rval; 384 Result result; 385 if (len <= detail::COPY_OR_MAP_THRESHOLD) 386 { 387 result = detail::SendToSmall(&rval, s, 388 reinterpret_cast<const u8*>(buf), len, 389 flags, 390 reinterpret_cast<const u8*>(sockTo), sizeof(SockAddrIn)); 391 } 392 else 393 { 394 result = detail::SendTo(&rval, s, 395 reinterpret_cast<const u8*>(buf), len, 396 flags, 397 reinterpret_cast<const u8*>(sockTo), sizeof(SockAddrIn)); 398 } 399 NN_SOCKET_RETURN_IF_FAILED(result); 400 return rval; 401 } 402 SendToMulti(s32 s,const void * buf,s32 len,s32 flags,const SockAddrIn * sockTo,s32 saCount)403 inline s32 SendToMulti(s32 s, const void* buf, s32 len, s32 flags, const SockAddrIn* sockTo, s32 saCount) 404 { 405 s32 rval; 406 Result result; 407 result = detail::SendToSmallMulti(&rval, s, 408 reinterpret_cast<const u8*>(buf), len, 409 flags, 410 reinterpret_cast<const u8*>(sockTo), sizeof(SockAddrIn), sizeof(SockAddrIn) * saCount); 411 NN_SOCKET_RETURN_IF_FAILED(result); 412 return rval; 413 } 414 /* Please see man pages for details 415 416 417 418 419 420 421 422 423 424 425 426 */ Send(s32 s,const void * buf,s32 len,s32 flags)427 inline s32 Send(s32 s, const void* buf, s32 len, s32 flags) 428 { 429 return SendTo(s, buf, len, flags, NULL); 430 } 431 432 /* Please see man pages for details 433 434 435 436 437 438 439 440 441 442 443 */ Write(s32 s,const void * buf,s32 len)444 inline s32 Write(s32 s, const void* buf, s32 len) 445 { 446 return SendTo(s, buf, len, 0, NULL); 447 } 448 449 /* Please see man pages for details 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 */ Close(s32 s)471 inline s32 Close(s32 s) 472 { 473 s32 rval = 0; 474 Result result = detail::Close(&rval, s); 475 NN_SOCKET_RETURN_IF_FAILED(result); 476 return rval; 477 } 478 479 /* Please see man pages for details 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 */ Shutdown(s32 s,s32 how)499 inline s32 Shutdown(s32 s, s32 how) 500 { 501 s32 rval = 0; 502 Result result = detail::Shutdown(&rval, s, how); 503 NN_SOCKET_RETURN_IF_FAILED(result); 504 return rval; 505 } 506 507 /* Please see man pages for details 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 */ GetSockOpt(s32 s,s32 level,int optname,void * optval,int * optlen)526 inline s32 GetSockOpt(s32 s, s32 level, int optname, void* optval, int* optlen) 527 { 528 s32 rval = 0; 529 Result result = detail::GetSockOpt(&rval, s, level, optname, reinterpret_cast<u8*>(optval), optlen); 530 NN_SOCKET_RETURN_IF_FAILED(result); 531 return rval; 532 } 533 534 /* Please see man pages for details 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 */ SetSockOpt(s32 s,s32 level,s32 optname,const void * optval,s32 optlen)554 inline s32 SetSockOpt(s32 s, s32 level, s32 optname, const void* optval, s32 optlen) 555 { 556 s32 rval = 0; 557 Result result = detail::SetSockOpt(&rval, s, level, optname, reinterpret_cast<const u8*>(optval), optlen); 558 NN_SOCKET_RETURN_IF_FAILED(result); 559 return rval; 560 } 561 562 /* Please see man pages for details 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 */ Fcntl(s32 s,s32 cmd,s32 val)588 inline s32 Fcntl( s32 s, s32 cmd, s32 val ) 589 { 590 s32 rval = 0; 591 Result result = detail::Fcntl(&rval, s, cmd, val); 592 NN_SOCKET_RETURN_IF_FAILED(result); 593 return rval; 594 } 595 596 /* Please see man pages for details 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 */ Poll(PollFd fds[],u32 nfds,s32 timeout)621 inline s32 Poll( PollFd fds[], u32 nfds, s32 timeout ) 622 { 623 s32 rval = 0; 624 Result result = detail::Poll(&rval, fds, nfds, timeout); 625 NN_SOCKET_RETURN_IF_FAILED(result); 626 return rval; 627 } 628 629 /* Please see man pages for details 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 */ SockAtMark(s32 s)653 inline s32 SockAtMark( s32 s ) 654 { 655 s32 rval = 0; 656 Result result = detail::SockAtMark(&rval, s); 657 NN_SOCKET_RETURN_IF_FAILED(result); 658 return rval; 659 } 660 661 /* Please see man pages for details 662 663 664 665 666 667 */ GetHostId(void)668 inline u32 GetHostId( void ) 669 { 670 u32 rval = 0; 671 detail::GetHostId(&rval); 672 return rval; 673 } 674 675 /* Please see man pages for details 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 */ GetSockName(s32 s,SockAddrIn * sockAddr)694 inline s32 GetSockName( s32 s, SockAddrIn* sockAddr ) 695 { 696 s32 rval = 0; 697 Result result = detail::GetSockName(&rval, s, reinterpret_cast<u8*>(sockAddr), sizeof(SockAddrIn)); 698 NN_SOCKET_RETURN_IF_FAILED(result); 699 return rval; 700 } 701 702 /* Please see man pages for details 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 */ GetPeerName(s32 s,SockAddrIn * sockAddr)718 inline s32 GetPeerName( s32 s, SockAddrIn* sockAddr ) 719 { 720 s32 rval = 0; 721 Result result = detail::GetPeerName(&rval, s, reinterpret_cast<u8*>(sockAddr), sizeof(SockAddrIn)); 722 NN_SOCKET_RETURN_IF_FAILED(result); 723 return rval; 724 } 725 GetNetworkOpt(s32 level,s32 optname,void * optval,s32 * optlen)726 inline s32 GetNetworkOpt( s32 level, s32 optname, void* optval, s32* optlen ) 727 { 728 s32 rval = 0; 729 Result result = detail::GetNetworkOpt(&rval, level, optname, reinterpret_cast<u8*>(optval), optlen); 730 NN_SOCKET_RETURN_IF_FAILED(result); 731 return rval; 732 } 733 GetResolverInfo(nn::socket::DnsServerInfo * pDnsServerInfo)734 inline s32 GetResolverInfo( nn::socket::DnsServerInfo* pDnsServerInfo ) 735 { 736 s32 rval = 0; 737 Result result = detail::GetResolverInfo(&rval, pDnsServerInfo); 738 NN_SOCKET_RETURN_IF_FAILED(result); 739 return rval; 740 } 741 742 // DnsUserClient 743 /* Please see man pages for details 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 */ 760 HostEnt* GetHostByName(const char8* name); 761 762 /* Please see man pages for details 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 */ 779 HostEnt* GetHostByAddr(const void* addr, s32 len, s32 type); 780 781 /* Please see man pages for details 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 */ 810 s32 GetAddrInfo(const char8* nodeName, const char8* servName, const AddrInfo* hints, AddrInfo** res); 811 812 /* Please see man pages for details 813 814 815 816 817 818 819 820 821 */ 822 void FreeAddrInfo(AddrInfo* head); 823 824 /* Please see man pages for details 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 */ 850 s32 GetNameInfo(const void* sa, char8* node, s32 nodeLen, char8* service, s32 serviceLen, s32 flags); 851 852 /* Please see man pages for details 853 854 855 856 857 */ 858 859 // InetUtils 860 /* Please see man pages for details 861 862 863 864 865 866 867 868 869 870 871 872 873 */ 874 s32 InetAtoN(const char* cp, InAddr* inp); 875 876 /* Please see man pages for details 877 878 879 880 881 882 883 884 885 886 887 888 889 890 */ 891 char* InetNtoA(InAddr in); 892 893 /* Please see man pages for details 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 */ 912 s32 InetPtoN(int af, const char* src, void* dst); 913 914 /* Please see man pages for details 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 */ 938 const char* InetNtoP(int af, const void* src, char* dst, unsigned len); 939 940 // byteorder 941 /* Please see man pages for details 942 943 944 945 946 947 948 949 950 */ HtoNl(bit32 v)951 inline bit32 HtoNl(bit32 v) 952 { 953 return NN_SOCKET_HtoNl(v); 954 } 955 956 /* Please see man pages for details 957 958 959 960 961 962 963 964 */ NtoHl(bit32 v)965 inline bit32 NtoHl(bit32 v) 966 { 967 return NN_SOCKET_NtoHl(v); 968 } 969 /* Please see man pages for details 970 971 972 973 974 975 976 977 */ HtoNs(bit16 v)978 inline bit16 HtoNs(bit16 v) 979 { 980 return NN_SOCKET_HtoNs(v); 981 } 982 /* Please see man pages for details 983 984 985 986 987 988 989 990 */ NtoHs(bit16 v)991 inline bit16 NtoHs(bit16 v) 992 { 993 return NN_SOCKET_NtoHs(v); 994 } 995 } 996 } 997 998 #endif // ifndef NN_SOCKET_SOCKET_BERKLEY_H_ 999