libogc/network_wii.c

   1 /*-------------------------------------------------------------
   2
   3 network_wii.c -- Wii network subsystem
   4
   5 Copyright (C) 2008 bushing
   6
   7 This software is provided 'as-is', without any express or implied
   8 warranty.  In no event will the authors be held liable for any
   9 damages arising from the use of this software.
  10
  11 Permission is granted to anyone to use this software for any
  12 purpose, including commercial applications, and to alter it and
  13 redistribute it freely, subject to the following restrictions:
  14
  15 1.      The origin of this software must not be misrepresented; you
  16 must not claim that you wrote the original software. If you use
  17 this software in a product, an acknowledgment in the product
  18 documentation would be appreciated but is not required.
  19
  20 2.      Altered source versions must be plainly marked as such, and
  21 must not be misrepresented as being the original software.
  22
  23 3.      This notice may not be removed or altered from any source
  24 distribution.
  25
  26 -------------------------------------------------------------*/
  27
  28 #if defined(HW_RVL)
  29
  30
  31 #define MAX_IP_RETRIES          100
  32 #define MAX_INIT_RETRIES        32
  33
  34 //#define DEBUG_NET
  35
  36 #ifdef DEBUG_NET
  37 #define debug_printf(fmt, args...) \
  38         do { \
  39                 fprintf(stderr, "%s:%d:" fmt, __FUNCTION__, __LINE__, ##args); \
  40         } while (0)
  41 #else
  42 #define debug_printf(fmt, args...) do { } while (0)
  43 #endif // DEBUG_NET
  44
  45 #include <stdio.h>
  46 #include <stdarg.h>
  47 #include <string.h>
  48 #define __LINUX_ERRNO_EXTENSIONS__
  49 #include <errno.h>
  50 #include <unistd.h>
  51 #include <fcntl.h>
  52 #include <malloc.h>
  53
  54 #include "ipc.h"
  55 #include "processor.h"
  56 #include "network.h"
  57 #include "ogcsys.h"
  58 #include "lwp_heap.h"
  59
  60 #define NET_HEAP_SIZE                           64*1024
  61
  62 #define IOS_O_NONBLOCK                          0x04                    //(O_NONBLOCK >> 16) - it's in octal representation, so this shift leads to 0 and hence nonblocking sockets didn't work. changed it to the right value.
  63
  64 #define IOCTL_NWC24_STARTUP                     0x06
  65
  66 #define IOCTL_NCD_SETIFCONFIG3          0x03
  67 #define IOCTL_NCD_SETIFCONFIG4          0x04
  68 #define IOCTL_NCD_GETLINKSTATUS         0x07
  69 #define IOCTLV_NCD_GETMACADDRESS    0x08
  70
  71 #define NET_UNKNOWN_ERROR_OFFSET        -10000
  72
  73 enum {
  74         IOCTL_SO_ACCEPT = 1,
  75         IOCTL_SO_BIND,
  76         IOCTL_SO_CLOSE,
  77         IOCTL_SO_CONNECT,
  78         IOCTL_SO_FCNTL,
  79         IOCTL_SO_GETPEERNAME, // todo
  80         IOCTL_SO_GETSOCKNAME, // todo
  81         IOCTL_SO_GETSOCKOPT,  // todo    8
  82         IOCTL_SO_SETSOCKOPT,
  83         IOCTL_SO_LISTEN,
  84         IOCTL_SO_POLL,        // todo    b
  85         IOCTLV_SO_RECVFROM,
  86         IOCTLV_SO_SENDTO,
  87         IOCTL_SO_SHUTDOWN,    // todo    e
  88         IOCTL_SO_SOCKET,
  89         IOCTL_SO_GETHOSTID,
  90         IOCTL_SO_GETHOSTBYNAME,
  91         IOCTL_SO_GETHOSTBYADDR,// todo
  92         IOCTLV_SO_GETNAMEINFO, // todo   13
  93         IOCTL_SO_UNK14,        // todo
  94         IOCTL_SO_INETATON,     // todo
  95         IOCTL_SO_INETPTON,     // todo
  96         IOCTL_SO_INETNTOP,     // todo
  97         IOCTLV_SO_GETADDRINFO, // todo
  98         IOCTL_SO_SOCKATMARK,   // todo
  99         IOCTLV_SO_UNK1A,       // todo
 100         IOCTLV_SO_UNK1B,       // todo
 101         IOCTLV_SO_GETINTERFACEOPT, // todo
 102         IOCTLV_SO_SETINTERFACEOPT, // todo
 103         IOCTL_SO_SETINTERFACE,     // todo
 104         IOCTL_SO_STARTUP,           // 0x1f
 105         IOCTL_SO_ICMPSOCKET =   0x30, // todo
 106         IOCTLV_SO_ICMPPING,         // todo
 107         IOCTL_SO_ICMPCANCEL,        // todo
 108         IOCTL_SO_ICMPCLOSE          // todo
 109 };
 110
 111 struct init_data {
 112         u32 state;
 113         s32 fd;
 114         s32 prevres;
 115         s32 result;
 116         syswd_t alarm;
 117         u32 retries;
 118         netcallback cb;
 119         void *usrdata;
 120         u8 *buf;
 121 };
 122
 123 struct init_default_cb {
 124         lwpq_t queue;
 125         s32 result;
 126 };
 127
 128 struct bind_params {
 129         u32 socket;
 130         u32 has_name;
 131         u8 name[28];
 132 };
 133
 134 struct connect_params {
 135         u32 socket;
 136         u32 has_addr;
 137         u8 addr[28];
 138 };
 139
 140 struct sendto_params {
 141         u32 socket;
 142         u32 flags;
 143         u32 has_destaddr;
 144         u8 destaddr[28];
 145 };
 146
 147 struct setsockopt_params {
 148         u32 socket;
 149         u32 level;
 150         u32 optname;
 151         u32 optlen;
 152         u8 optval[20];
 153 };
 154
 155 // 0 means we don't know what this error code means
 156 // I sense a pattern here...
 157 static u8 _net_error_code_map[] = {
 158         0, // 0
 159         E2BIG,
 160         EACCES,
 161         EADDRINUSE,
 162         EADDRNOTAVAIL,
 163         EAFNOSUPPORT, // 5
 164         EAGAIN,
 165         EALREADY,
 166         EBADFD,
 167         EBADMSG,
 168         EBUSY, // 10
 169         ECANCELED,
 170         ECHILD,
 171         ECONNABORTED,
 172         ECONNREFUSED,
 173         ECONNRESET, // 15
 174         EDEADLK,
 175         EDESTADDRREQ,
 176         EDOM,
 177         EDQUOT,
 178         EEXIST, // 20
 179         EFAULT,
 180         EFBIG,
 181         EHOSTUNREACH,
 182         EIDRM,
 183         EILSEQ, // 25
 184         EINPROGRESS,
 185         EINTR,
 186         EINVAL,
 187         EIO,
 188         EISCONN, // 30
 189         EISDIR,
 190         ELOOP,
 191         EMFILE,
 192         EMLINK,
 193         EMSGSIZE, // 35
 194         EMULTIHOP,
 195         ENAMETOOLONG,
 196         ENETDOWN,
 197         ENETRESET,
 198         ENETUNREACH, // 40
 199         ENFILE,
 200         ENOBUFS,
 201         ENODATA,
 202         ENODEV,
 203         ENOENT, // 45
 204         ENOEXEC,
 205         ENOLCK,
 206         ENOLINK,
 207         ENOMEM,
 208         ENOMSG, // 50
 209         ENOPROTOOPT,
 210         ENOSPC,
 211         ENOSR,
 212         ENOSTR,
 213         ENOSYS, // 55
 214         ENOTCONN,
 215         ENOTDIR,
 216         ENOTEMPTY,
 217         ENOTSOCK,
 218         ENOTSUP, // 60
 219         ENOTTY,
 220         ENXIO,
 221         EOPNOTSUPP,
 222         EOVERFLOW,
 223         EPERM, // 65
 224         EPIPE,
 225         EPROTO,
 226         EPROTONOSUPPORT,
 227         EPROTOTYPE,
 228         ERANGE, // 70
 229         EROFS,
 230         ESPIPE,
 231         ESRCH,
 232         ESTALE,
 233         ETIME, // 75
 234         ETIMEDOUT,
 235 };
 236
 237 static volatile bool _init_busy = false;
 238 static volatile bool _init_abort = false;
 239 static vs32 _last_init_result = -ENETDOWN;
 240 static s32 net_ip_top_fd = -1;
 241 static u8 __net_heap_inited = 0;
 242 static s32 __net_hid=-1;
 243 static heap_cntrl __net_heap;
 244
 245 static char __manage_fs[] ATTRIBUTE_ALIGN(32) = "/dev/net/ncd/manage";
 246 static char __iptop_fs[] ATTRIBUTE_ALIGN(32) = "/dev/net/ip/top";
 247 static char __kd_fs[] ATTRIBUTE_ALIGN(32) = "/dev/net/kd/request";
 248
 249 #define ROUNDDOWN32(v)                          (((u32)(v)-0x1f)&~0x1f)
 250
 251 static s32 NetCreateHeap()
 252 {
 253         u32 level;
 254         void *net_heap_ptr;
 255
 256         _CPU_ISR_Disable(level);
 257
 258         if(__net_heap_inited)
 259         {
 260                 _CPU_ISR_Restore(level);
 261                 return IPC_OK;
 262         }
 263
 264         net_heap_ptr = (void *)ROUNDDOWN32(((u32)SYS_GetArena2Hi() - NET_HEAP_SIZE));
 265         if((u32)net_heap_ptr < (u32)SYS_GetArena2Lo())
 266         {
 267                 _CPU_ISR_Restore(level);
 268                 return IPC_ENOMEM;
 269         }
 270         SYS_SetArena2Hi(net_heap_ptr);
 271         __lwp_heap_init(&__net_heap, net_heap_ptr, NET_HEAP_SIZE, 32);
 272         __net_heap_inited=1;
 273         _CPU_ISR_Restore(level);
 274         return IPC_OK;
 275 }
 276
 277 static void* net_malloc(u32 size)
 278 {
 279         return __lwp_heap_allocate(&__net_heap, size);
 280 }
 281
 282 static BOOL net_free(void *ptr)
 283 {
 284         return __lwp_heap_free(&__net_heap, ptr);
 285 }
 286
 287 static s32 _net_convert_error(s32 ios_retval)
 288 {
 289 //      return ios_retval;
 290         if (ios_retval >= 0) return ios_retval;
 291         if (ios_retval < -sizeof(_net_error_code_map)
 292                 || !_net_error_code_map[-ios_retval])
 293                         return NET_UNKNOWN_ERROR_OFFSET + ios_retval;
 294         return -_net_error_code_map[-ios_retval];
 295 }
 296
 297 u32 net_gethostip(void)
 298 {
 299         u32 ip_addr=0;
 300         int retries;
 301
 302         if (net_ip_top_fd < 0) return 0;
 303         for (retries=0, ip_addr=0; !ip_addr && retries < 5; retries++) {
 304                 ip_addr = IOS_Ioctl(net_ip_top_fd, IOCTL_SO_GETHOSTID, 0, 0, 0, 0);
 305 #ifdef DEBUG_NET
 306                 debug_printf(".");
 307                 fflush(stdout);
 308 #endif
 309                 if (!ip_addr)
 310                         usleep(100000);
 311         }
 312
 313         return ip_addr;
 314 }
 315
 316 static s32 net_init_chain(s32 result, void *usrdata);
 317
 318 static void net_init_alarm(syswd_t alarm, void *cb_arg) {
 319         debug_printf("net_init alarm\n");
 320         net_init_chain(0, cb_arg);
 321 }
 322
 323 static s32 net_init_chain(s32 result, void *usrdata) {
 324         struct init_data *data = (struct init_data *) usrdata;
 325         struct timespec tb;
 326
 327         debug_printf("net_init chain entered: %u %d\n", data->state, result);
 328
 329         if (_init_abort) {
 330                 data->state = 0xff;
 331                 goto error;
 332         }
 333
 334         switch (data->state) {
 335         case 0: // open manage fd
 336                 data->state = 1;
 337                 data->result = IOS_OpenAsync(__manage_fs, 0, net_init_chain, data);
 338                 if (data->result < 0) {
 339                         data->result = _net_convert_error(data->result);
 340                         goto done;
 341                 }
 342                 return 0;
 343
 344         case 1: // get link status
 345                 if (result == IPC_ENOENT) {
 346                         debug_printf("IPC_ENOENT, retrying...\n");
 347                         data->state = 0;
 348                         tb.tv_sec = 0;
 349                         tb.tv_nsec = 100000000;
 350                         data->result = SYS_SetAlarm(data->alarm, &tb, net_init_alarm, data);
 351                         if (data->result) {
 352                                 debug_printf("error setting the alarm: %d\n", data->result);
 353                                 goto done;
 354                         }
 355                         return 0;
 356                 }
 357
 358                 if (result < 0) {
 359                         data->result = _net_convert_error(result);
 360                         debug_printf("error opening the manage fd: %d\n", data->result);
 361                         goto done;
 362                 }
 363
 364                 data->fd = result;
 365                 data->state = 2;
 366                 data->result = IOS_IoctlvFormatAsync(__net_hid, data->fd, IOCTL_NCD_GETLINKSTATUS, net_init_chain, data, ":d", data->buf, 0x20);
 367                 if (data->result < 0) {
 368                         data->result = _net_convert_error(data->result);
 369                         data->state = 0xff;
 370                         if (IOS_CloseAsync(data->fd, net_init_chain, data) < 0)
 371                                 goto done;
 372                 }
 373                 return 0;
 374
 375         case 2: // close manage fd
 376                 data->prevres = result;
 377                 data->state = 3;
 378                 data->result = IOS_CloseAsync(data->fd, net_init_chain, data);
 379                 if (data->result < 0) {
 380                         data->result = _net_convert_error(data->result);
 381                         goto done;
 382                 }
 383                 return 0;
 384
 385         case 3: // open top fd
 386                 if (data->prevres < 0) {
 387                         data->result = _net_convert_error(data->prevres);
 388                         debug_printf("invalid link status %d\n", data->result);
 389                         goto done;
 390                 }
 391
 392                 data->state = 4;
 393                 data->result = IOS_OpenAsync(__iptop_fs, 0, net_init_chain, data);
 394                 if (data->result < 0) {
 395                         data->result = _net_convert_error(data->result);
 396                         goto done;
 397                 }
 398                 return 0;
 399
 400         case 4: // open request fd
 401                 if (result < 0) {
 402                         data->result = _net_convert_error(result);
 403                         debug_printf("error opening the top fd: %d\n", data->result);
 404                         goto done;
 405                 }
 406
 407                 net_ip_top_fd = result;
 408                 data->state = 5;
 409                 data->result = IOS_OpenAsync(__kd_fs, 0, net_init_chain, data);
 410                 if (data->result < 0) {
 411                         data->result = _net_convert_error(data->result);
 412                         data->state = 0xff;
 413                         goto error;
 414                 }
 415                 return 0;
 416
 417         case 5: // NWC24 startup
 418                 if (result < 0) {
 419                         data->result = _net_convert_error(result);
 420                         debug_printf("error opening the request fd: %d\n", data->result);
 421                         data->state = 0xff;
 422                         goto error;
 423                 }
 424
 425                 data->fd = result;
 426                 data->retries = MAX_INIT_RETRIES;
 427         case 6:
 428                 data->state = 7;
 429                 data->result = IOS_IoctlAsync(data->fd, IOCTL_NWC24_STARTUP, NULL, 0, data->buf, 0x20, net_init_chain, data);
 430                 if (data->result < 0) {
 431                         data->result = _net_convert_error(data->result);
 432                         data->state = 0xff;
 433                         if (IOS_CloseAsync(data->fd, net_init_chain, data) < 0)
 434                                 goto done;
 435                 }
 436                 return 0;
 437         case 7:
 438                 if (result==0) {
 439                         memcpy(&result, data->buf, sizeof(result));
 440                         if(result==-29 && --data->retries) {
 441                                 data->state = 6;
 442                                 tb.tv_sec = 0;
 443                                 tb.tv_nsec = 100000000;
 444                                 data->result = SYS_SetAlarm(data->alarm, &tb, net_init_alarm, data);
 445                                 if (data->result) {
 446                                         data->state = 0xff;
 447                                         debug_printf("error setting the alarm: %d\n", data->result);
 448                                         if (IOS_CloseAsync(data->fd, net_init_chain, data) < 0)
 449                                                 goto error;
 450                                 }
 451                                 return 0;
 452                         } else if (result == -15) // this happens if it's already been started
 453                                 result = 0;
 454                 }
 455
 456                 data->prevres = result;
 457                 data->state = 8;
 458                 data->result = IOS_CloseAsync(data->fd, net_init_chain, data);
 459                 if (data->result < 0) {
 460                         data->result = _net_convert_error(data->result);
 461                         data->state = 0xff;
 462                         goto error;
 463                 }
 464                 return 0;
 465
 466         case 8: // socket startup
 467                 if (data->prevres < 0) {
 468                         data->result = _net_convert_error(data->prevres);
 469                         debug_printf("NWC24 startup failed: %d\n", data->result);
 470                         data->state = 0xff;
 471                         goto error;
 472                 }
 473
 474                 data->state = 9;
 475                 data->retries = MAX_IP_RETRIES;
 476                 data->result = IOS_IoctlAsync(net_ip_top_fd, IOCTL_SO_STARTUP, 0, 0, 0, 0, net_init_chain, data);
 477                 if (data->result < 0) {
 478                         data->result = _net_convert_error(data->result);
 479                         data->state = 0xff;
 480                         goto error;
 481                 }
 482                 return 0;
 483
 484         case 9: // check ip
 485                 if (result < 0) {
 486                         data->result = _net_convert_error(result);
 487                         debug_printf("socket startup failed: %d\n", data->result);
 488                         data->state = 0xff;
 489                         goto error;
 490                 }
 491
 492                 data->state = 10;
 493                 data->result = IOS_IoctlAsync(net_ip_top_fd, IOCTL_SO_GETHOSTID, 0, 0, 0, 0, net_init_chain, data);
 494                 if (data->result < 0) {
 495                         data->result = _net_convert_error(data->result);
 496                         data->state = 0xff;
 497                         goto error;
 498                 }
 499                 return 0;
 500
 501         case 10: // done, check result
 502                 if (result == 0) {
 503                         if (!data->retries) {
 504                                 data->result = -ETIMEDOUT;
 505                                 debug_printf("unable to obtain ip\n");
 506                                 data->state = 0xff;
 507                                 goto error;
 508                         }
 509
 510                         debug_printf("unable to obtain ip, retrying...\n");
 511                         data->state = 9;
 512                         data->retries--;
 513                         tb.tv_sec = 0;
 514                         tb.tv_nsec = 100000000;
 515                         data->result = SYS_SetAlarm(data->alarm, &tb, net_init_alarm, data);
 516                         if (data->result) {
 517                                 data->state = 0xff;
 518                                 debug_printf("error setting the alarm: %d\n", data->result);
 519                                 goto error;
 520                         }
 521                         return 0;
 522                 }
 523
 524                 data->result = 0;
 525                 goto done;
 526
 527 error:
 528         case 0xff: // error occured before, last async call finished
 529                 if (net_ip_top_fd >= 0) {
 530                         data->fd = net_ip_top_fd;
 531                         net_ip_top_fd = -1;
 532                         if (IOS_CloseAsync(data->fd, net_init_chain, data) < 0)
 533                                 goto done;
 534                         return 0;
 535                 }
 536                 goto done;
 537
 538         default:
 539                 debug_printf("unknown state in chain %d\n", data->state);
 540                 data->result = -1;
 541
 542                 break;
 543         }
 544
 545 done:
 546         SYS_RemoveAlarm(data->alarm);
 547
 548         _last_init_result = data->result;
 549
 550         if (data->cb)
 551                 data->cb(data->result, data->usrdata);
 552
 553         free(data->buf);
 554         free(data);
 555
 556         _init_busy = false;
 557
 558         return 0;
 559 }
 560
 561 s32 net_init_async(netcallback cb, void *usrdata) {
 562         s32 ret;
 563         struct init_data *data;
 564
 565         if (net_ip_top_fd >= 0)
 566                 return 0;
 567
 568         if (_init_busy)
 569                 return -EBUSY;
 570
 571         ret = NetCreateHeap();
 572         if (ret != IPC_OK)
 573                 return ret;
 574
 575         if (__net_hid == -1)
 576                 __net_hid = iosCreateHeap(1024); //only needed for ios calls
 577
 578         if (__net_hid < 0)
 579                 return __net_hid;
 580
 581         data = malloc(sizeof(struct init_data));
 582         if (!data)
 583                 return -1;
 584
 585         memset(data, 0, sizeof(struct init_data));
 586
 587         if (SYS_CreateAlarm(&data->alarm)) {
 588                 debug_printf("error creating alarm\n");
 589                 free(data);
 590                 return -1;
 591         }
 592
 593         data->buf = memalign(32, 0x20);
 594         if (!data->buf) {
 595                 free(data);
 596                 return -1;
 597         }
 598
 599         data->cb = cb;
 600         data->usrdata = usrdata;
 601
 602         // kick off the callback chain
 603         _init_busy = true;
 604         _init_abort = false;
 605         _last_init_result = -EBUSY;
 606         net_init_chain(IPC_ENOENT, data);
 607
 608         return 0;
 609 }
 610
 611 static void net_init_callback(s32 result, void *usrdata) {
 612         struct init_default_cb *data = (struct init_default_cb *) usrdata;
 613
 614         data->result = result;
 615         LWP_ThreadBroadcast(data->queue);
 616
 617         return;
 618 }
 619
 620 s32 net_init(void) {
 621         struct init_default_cb data;
 622
 623         if (net_ip_top_fd >= 0)
 624                 return 0;
 625
 626         LWP_InitQueue(&data.queue);
 627         net_init_async((netcallback)net_init_callback, &data);
 628         LWP_ThreadSleep(data.queue);
 629         LWP_CloseQueue(data.queue);
 630
 631         return data.result;
 632 }
 633
 634 s32 net_get_status(void) {
 635         return _last_init_result;
 636 }
 637
 638 void net_deinit() {
 639         if (_init_busy) {
 640                 debug_printf("aborting net_init_async\n");
 641                 _init_abort = true;
 642                 while (_init_busy)
 643                         usleep(50);
 644                 debug_printf("net_init_async done\n");
 645         }
 646
 647         if (net_ip_top_fd >= 0) IOS_Close(net_ip_top_fd);
 648         net_ip_top_fd = -1;
 649         _last_init_result = -ENETDOWN;
 650 }
 651
 652 void net_wc24cleanup() {
 653     s32 kd_fd, ret;
 654     STACK_ALIGN(u8, kd_buf, 0x20, 32);
 655
 656     kd_fd = IOS_Open(__kd_fs, 0);
 657     if (kd_fd >= 0) {
 658         ret = IOS_Ioctl(kd_fd, 7, NULL, 0, kd_buf, 0x20);
 659         IOS_Close(kd_fd);
 660     }
 661 }
 662
 663 s32 net_get_mac_address(void *mac_buf) {
 664         s32 fd;
 665         s32 result;
 666         void *_mac_buf;
 667         STACK_ALIGN(u32, manage_buf, 0x20, 32);
 668
 669         if (mac_buf==NULL) return -EINVAL;
 670
 671         result = NetCreateHeap();
 672         if (result!=IPC_OK) return result;
 673
 674         _mac_buf = net_malloc(6);
 675         if (_mac_buf==NULL) return IPC_ENOMEM;
 676
 677         fd = IOS_Open(__manage_fs, 0);
 678         if (fd<0) {
 679                 net_free(_mac_buf);
 680                 return fd;
 681         }
 682
 683         result = IOS_IoctlvFormat(__net_hid, fd, IOCTLV_NCD_GETMACADDRESS, ":dd", manage_buf, 0x20, _mac_buf, 0x06);
 684         IOS_Close(fd);
 685
 686         if (result>=0) {
 687                 memcpy(mac_buf, _mac_buf, 6);
 688                 if (manage_buf[0]) result = manage_buf[0];
 689         }
 690
 691         net_free(_mac_buf);
 692         return result;
 693 }
 694
 695 /* Returned value is a static buffer -- this function is not threadsafe! */
 696 struct hostent * net_gethostbyname(const char *addrString)
 697 {
 698         s32 ret, len, i;
 699         u8 *params;
 700         struct hostent *ipData;
 701         u32 addrOffset;
 702         static u8 ipBuffer[0x460] ATTRIBUTE_ALIGN(32);
 703
 704         memset(ipBuffer, 0, 0x460);
 705
 706         if (net_ip_top_fd < 0) {
 707                 errno = -ENXIO;
 708                 return NULL;
 709         }
 710
 711         len = strlen(addrString) + 1;
 712         params = net_malloc(len);
 713         if (params==NULL) {
 714                 errno = IPC_ENOMEM;
 715                 return NULL;
 716         }
 717
 718         memcpy(params, addrString, len);
 719
 720         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_GETHOSTBYNAME, params, len, ipBuffer, 0x460));
 721
 722         if(params!=NULL) net_free(params);
 723
 724         if (ret < 0) {
 725                 errno = ret;
 726                 return NULL;
 727         }
 728
 729         ipData = ((struct hostent*)ipBuffer);
 730         addrOffset = (u32)MEM_PHYSICAL_TO_K0(ipData->h_name) - ((u32)ipBuffer + 0x10);
 731
 732         ipData->h_name = MEM_PHYSICAL_TO_K0(ipData->h_name) - addrOffset;
 733         ipData->h_aliases = MEM_PHYSICAL_TO_K0(ipData->h_aliases) - addrOffset;
 734
 735         for (i=0; (i < 0x40) && (ipData->h_aliases[i] != 0); i++) {
 736                 ipData->h_aliases[i] = MEM_PHYSICAL_TO_K0(ipData->h_aliases[i]) - addrOffset;
 737         }
 738
 739         ipData->h_addr_list = MEM_PHYSICAL_TO_K0(ipData->h_addr_list) - addrOffset;
 740
 741         for (i=0; (i < 0x40) && (ipData->h_addr_list[i] != 0); i++) {
 742                 ipData->h_addr_list[i] = MEM_PHYSICAL_TO_K0(ipData->h_addr_list[i]) - addrOffset;
 743         }
 744
 745         errno = 0;
 746         return ipData;
 747 }
 748
 749 s32 net_socket(u32 domain, u32 type, u32 protocol)
 750 {
 751         s32 ret;
 752         STACK_ALIGN(u32, params, 3, 32);
 753
 754         if (net_ip_top_fd < 0) return -ENXIO;
 755
 756         params[0] = domain;
 757         params[1] = type;
 758         params[2] = protocol;
 759
 760         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_SOCKET, params, 12, NULL, 0));
 761         if(ret>=0) // set tcp window size to 24kb
 762         {
 763                 int window_size = 24576;
 764                 net_setsockopt(ret, SOL_SOCKET, SO_RCVBUF, (char *) &window_size, sizeof(window_size));
 765         }
 766         debug_printf("net_socket(%d, %d, %d)=%d\n", domain, type, protocol, ret);
 767         return ret;
 768 }
 769
 770 s32 net_shutdown(s32 s, u32 how)
 771 {
 772         s32 ret;
 773         STACK_ALIGN(u32, params, 2, 32);
 774
 775         if (net_ip_top_fd < 0) return -ENXIO;
 776
 777         params[0] = s;
 778         params[1] = how;
 779         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_SHUTDOWN, params, 8, NULL, 0));
 780
 781         debug_printf("net_shutdown(%d, %d)=%d\n", s, how, ret);
 782         return ret;
 783 }
 784
 785 s32 net_bind(s32 s, struct sockaddr *name, socklen_t namelen)
 786 {
 787         s32 ret;
 788         STACK_ALIGN(struct bind_params,params,1,32);
 789
 790         if (net_ip_top_fd < 0) return -ENXIO;
 791         if (name->sa_family != AF_INET) return -EAFNOSUPPORT;
 792
 793         name->sa_len = 8;
 794
 795         memset(params, 0, sizeof(struct bind_params));
 796         params->socket = s;
 797         params->has_name = 1;
 798         memcpy(params->name, name, 8);
 799
 800         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_BIND, params, sizeof (struct bind_params), NULL, 0));
 801         debug_printf("net_bind(%d, %p)=%d\n", s, name, ret);
 802
 803         return ret;
 804 }
 805
 806 s32 net_listen(s32 s, u32 backlog)
 807 {
 808         s32 ret;
 809         STACK_ALIGN(u32, params, 2, 32);
 810
 811         if (net_ip_top_fd < 0) return -ENXIO;
 812
 813         params[0] = s;
 814         params[1] = backlog;
 815
 816         debug_printf("calling ios_ioctl(%d, %d, %p, %d)\n", net_ip_top_fd, IOCTL_SO_SOCKET, params, 8);
 817
 818         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_LISTEN, params, 8, NULL, 0));
 819         debug_printf("net_listen(%d, %d)=%d\n", s, backlog, ret);
 820         return ret;
 821 }
 822
 823 s32 net_accept(s32 s, struct sockaddr *addr, socklen_t *addrlen)
 824 {
 825         s32 ret;
 826         STACK_ALIGN(u32, _socket, 1, 32);
 827
 828         debug_printf("net_accept()\n");
 829
 830         if (net_ip_top_fd < 0) return -ENXIO;
 831
 832         if (!addr) return -EINVAL;
 833         addr->sa_len = 8;
 834         addr->sa_family = AF_INET;
 835
 836         if (!addrlen) return -EINVAL;
 837
 838         if (*addrlen < 8) return -ENOMEM;
 839
 840         *addrlen = 8;
 841
 842         *_socket = s;
 843         debug_printf("calling ios_ioctl(%d, %d, %p, %d)\n", net_ip_top_fd, IOCTL_SO_ACCEPT, _socket, 4);
 844         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_ACCEPT, _socket, 4, addr, *addrlen));
 845
 846         debug_printf("net_accept(%d, %p)=%d\n", s, addr, ret);
 847         return ret;
 848 }
 849
 850 s32 net_connect(s32 s, struct sockaddr *addr, socklen_t addrlen)
 851 {
 852         s32 ret;
 853         STACK_ALIGN(struct connect_params,params,1,32);
 854
 855         if (net_ip_top_fd < 0) return -ENXIO;
 856         if (addr->sa_family != AF_INET) return -EAFNOSUPPORT;
 857         if (addrlen < 8) return -EINVAL;
 858
 859         addr->sa_len = 8;
 860
 861         memset(params, 0, sizeof(struct connect_params));
 862         params->socket = s;
 863         params->has_addr = 1;
 864         memcpy(&params->addr, addr, addrlen);
 865
 866         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_CONNECT, params, sizeof(struct connect_params), NULL, 0));
 867         if (ret < 0)
 868         debug_printf("SOConnect(%d, %p)=%d\n", s, addr, ret);
 869
 870         return ret;
 871 }
 872
 873 s32 net_write(s32 s, const void *data, s32 size)
 874 {
 875     return net_send(s, data, size, 0);
 876 }
 877
 878 s32 net_send(s32 s, const void *data, s32 size, u32 flags)
 879 {
 880         return net_sendto(s, data, size, flags, NULL, 0);
 881 }
 882
 883 s32 net_sendto(s32 s, const void *data, s32 len, u32 flags, struct sockaddr *to, socklen_t tolen)
 884 {
 885         s32 ret;
 886         u8 * message_buf = NULL;
 887         STACK_ALIGN(struct sendto_params,params,1,32);
 888
 889         if (net_ip_top_fd < 0) return -ENXIO;
 890         if (tolen > 28) return -EOVERFLOW;
 891
 892         message_buf = net_malloc(len);
 893         if (message_buf == NULL) {
 894                 debug_printf("net_send: failed to alloc %d bytes\n", len);
 895                 return IPC_ENOMEM;
 896         }
 897
 898         debug_printf("net_sendto(%d, %p, %d, %d, %p, %d)\n", s, data, len, flags, to, tolen);
 899
 900         if (to && to->sa_len != tolen) {
 901                 debug_printf("warning: to->sa_len was %d, setting to %d\n",     to->sa_len, tolen);
 902                 to->sa_len = tolen;
 903         }
 904
 905         memset(params, 0, sizeof(struct sendto_params));
 906         memcpy(message_buf, data, len);   // ensure message buf is aligned
 907
 908         params->socket = s;
 909         params->flags = flags;
 910         if (to) {
 911                 params->has_destaddr = 1;
 912                 memcpy(params->destaddr, to, to->sa_len);
 913         } else {
 914                 params->has_destaddr = 0;
 915         }
 916
 917         ret = _net_convert_error(IOS_IoctlvFormat(__net_hid, net_ip_top_fd, IOCTLV_SO_SENDTO, "dd:", message_buf, len, params, sizeof(struct sendto_params)));
 918         debug_printf("net_send retuned %d\n", ret);
 919
 920         if(message_buf!=NULL) net_free(message_buf);
 921         return ret;
 922 }
 923
 924 s32 net_recv(s32 s, void *mem, s32 len, u32 flags)
 925 {
 926     return net_recvfrom(s, mem, len, flags, NULL, NULL);
 927 }
 928
 929 s32 net_recvfrom(s32 s, void *mem, s32 len, u32 flags, struct sockaddr *from, socklen_t *fromlen)
 930 {
 931         s32 ret;
 932         u8* message_buf = NULL;
 933         STACK_ALIGN(u32, params, 2, 32);
 934
 935         if (net_ip_top_fd < 0) return -ENXIO;
 936         if (len<=0) return -EINVAL;
 937
 938         if (fromlen && from->sa_len != *fromlen) {
 939                 debug_printf("warning: from->sa_len was %d, setting to %d\n",from->sa_len, *fromlen);
 940                 from->sa_len = *fromlen;
 941         }
 942
 943         message_buf = net_malloc(len);
 944         if (message_buf == NULL) {
 945         debug_printf("SORecv: failed to alloc %d bytes\n", len);
 946                 return IPC_ENOMEM;
 947         }
 948
 949         debug_printf("net_recvfrom(%d, '%s', %d, %d, %p, %d)\n", s, (char *)mem, len, flags, from, fromlen?*fromlen:0);
 950
 951         memset(message_buf, 0, len);
 952         params[0] = s;
 953         params[1] = flags;
 954
 955         ret = _net_convert_error(IOS_IoctlvFormat(__net_hid, net_ip_top_fd, IOCTLV_SO_RECVFROM, "d:dd", params, 8, message_buf, len, from, (fromlen?*fromlen:0)));
 956         debug_printf("net_recvfrom returned %d\n", ret);
 957
 958         if (ret > 0) {
 959                 if (ret > len) {
 960                         ret = -EOVERFLOW;
 961                         goto done;
 962                 }
 963
 964                 memcpy(mem, message_buf, ret);
 965         }
 966
 967         if (fromlen && from) *fromlen = from->sa_len;
 968
 969 done:
 970         if(message_buf!=NULL) net_free(message_buf);
 971         return ret;
 972 }
 973
 974 s32 net_read(s32 s, void *mem, s32 len)
 975 {
 976         return net_recvfrom(s, mem, len, 0, NULL, NULL);
 977 }
 978
 979 s32 net_close(s32 s)
 980 {
 981         s32 ret;
 982         STACK_ALIGN(u32, _socket, 1, 32);
 983
 984         if (net_ip_top_fd < 0) return -ENXIO;
 985
 986         *_socket = s;
 987         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_CLOSE, _socket, 4, NULL, 0));
 988
 989         if (ret < 0)
 990                 debug_printf("net_close(%d)=%d\n", s, ret);
 991
 992         return ret;
 993 }
 994
 995 s32 net_select(s32 maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout)
 996 {
 997         // not yet implemented
 998         return -EINVAL;
 999 }
1000
1001 s32 net_setsockopt(s32 s, u32 level, u32 optname, const void *optval, socklen_t optlen)
1002 {
1003         s32 ret;
1004         STACK_ALIGN(struct setsockopt_params,params,1,32);
1005
1006         if (net_ip_top_fd < 0) return -ENXIO;
1007         if (optlen < 0 || optlen > 20) return -EINVAL;
1008
1009         memset(params, 0, sizeof(struct setsockopt_params));
1010         params->socket = s;
1011         params->level = level;
1012         params->optname = optname;
1013         params->optlen = optlen;
1014         if (optval && optlen) memcpy (params->optval, optval, optlen);
1015
1016         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_SETSOCKOPT, params, sizeof(struct setsockopt_params), NULL, 0));
1017
1018         debug_printf("net_setsockopt(%d, %u, %u, %p, %d)=%d\n", s, level, optname, optval, optlen, ret);
1019         return ret;
1020 }
1021
1022 s32 net_ioctl(s32 s, u32 cmd, void *argp)
1023 {
1024         u32 flags;
1025         u32 *intp = (u32 *)argp;
1026
1027         if (net_ip_top_fd < 0) return -ENXIO;
1028         if (!intp) return -EINVAL;
1029
1030         switch (cmd) {
1031                 case FIONBIO:
1032                         flags = net_fcntl(s, F_GETFL, 0);
1033                         flags &= ~IOS_O_NONBLOCK;
1034                         if (*intp) flags |= IOS_O_NONBLOCK;
1035                         return net_fcntl(s, F_SETFL, flags);
1036                 default:
1037                         return -EINVAL;
1038         }
1039 }
1040
1041 s32 net_fcntl(s32 s, u32 cmd, u32 flags)
1042 {
1043         s32 ret;
1044         STACK_ALIGN(u32, params, 3, 32);
1045
1046         if (net_ip_top_fd < 0) return -ENXIO;
1047         if (cmd != F_GETFL && cmd != F_SETFL) return -EINVAL;
1048
1049
1050         params[0] = s;
1051         params[1] = cmd;
1052         params[2] = flags;
1053
1054         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_FCNTL, params, 12, NULL, 0));
1055
1056         debug_printf("net_fcntl(%d, %d, %x)=%d\n", params[0], params[1], params[2], ret);
1057
1058         return ret;
1059 }
1060
1061
1062 /*!
1063  * \fn s32 net_poll(struct pollsd *sds, u32 nsds, s64 timeout)
1064  * \brief Poll a set of sockets for a set of events.
1065  *
1066  * \param[in] sds a pointer to an array of pollsd structures
1067  * \param[in] nsds the number of elements in the sds array
1068  * \param[in] time in milliseconds before the function should timeout
1069  *
1070  * \return the number of structures in sds that now have non-zero revent fields
1071  */
1072 s32 net_poll(struct pollsd *sds,s32 nsds,s32 timeout)
1073 {
1074         union ullc {
1075                 u64 ull;
1076                 u32 ul[2];
1077         };
1078
1079         s32 ret;
1080         union ullc outv;
1081         struct pollsd *psds;
1082         STACK_ALIGN(u64,params,1,32);
1083
1084         if(net_ip_top_fd<0) return -ENXIO;
1085         if(sds==NULL || nsds==0) return -EINVAL;
1086
1087         psds = net_malloc((nsds*sizeof(struct pollsd)));
1088         if(psds==NULL) {
1089                 debug_printf("net_poll: failed to alloc %d bytes\n", nsds * sizeof(struct pollsd));
1090                 return IPC_ENOMEM;
1091         }
1092
1093         outv.ul[0] = 0;
1094         outv.ul[1] = timeout;
1095         params[0] = outv.ull;
1096         memcpy(psds,sds,(nsds*sizeof(struct pollsd)));
1097
1098         ret = _net_convert_error(IOS_Ioctl(net_ip_top_fd, IOCTL_SO_POLL, params, 8, psds, (nsds * sizeof(struct pollsd))));
1099
1100         memcpy(sds,psds,(nsds*sizeof(struct pollsd)));
1101
1102         net_free(psds);
1103
1104         debug_printf("net_poll(sds, %d, %lld)=%d\n", nsds, params[0], ret);
1105
1106         return ret;
1107 }
1108
1109 s32 if_config(char *local_ip, char *netmask, char *gateway,bool use_dhcp)
1110 {
1111         s32 i,ret;
1112         struct in_addr hostip;
1113
1114         if (!use_dhcp)
1115                 return -EINVAL;
1116
1117         for (i = 0; i < MAX_INIT_RETRIES; ++i) {
1118                 ret = net_init();
1119
1120                 if ((ret != -EAGAIN) && (ret != -ETIMEDOUT))
1121                         break;
1122
1123                 usleep(50 * 1000);
1124         }
1125
1126         if (ret < 0)
1127                 return ret;
1128
1129         hostip.s_addr = net_gethostip();
1130         if (local_ip && hostip.s_addr) {
1131                 strcpy(local_ip, inet_ntoa(hostip));
1132                 return 0;
1133         }
1134
1135         return -1;
1136 }
1137
1138 s32 if_configex(struct in_addr *local_ip, struct in_addr *netmask, struct in_addr *gateway,bool use_dhcp)
1139 {
1140         s32 i,ret;
1141         struct in_addr hostip;
1142
1143         if (!use_dhcp)
1144                 return -EINVAL;
1145
1146         for (i = 0; i < MAX_INIT_RETRIES; ++i) {
1147                 ret = net_init();
1148
1149                 if ((ret != -EAGAIN) && (ret != -ETIMEDOUT))
1150                         break;
1151
1152                 usleep(50 * 1000);
1153         }
1154
1155         if (ret < 0)
1156                 return ret;
1157
1158         hostip.s_addr = net_gethostip();
1159         if (local_ip && hostip.s_addr) {
1160                 *local_ip = hostip;
1161                 return 0;
1162         }
1163
1164         return -1;
1165 }
1166
1167 #endif /* defined(HW_RVL) */