Advertisement
Guest User

Untitled

a guest
Sep 1st, 2018
251
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 24.73 KB | None
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3. Copyright (C) 2007 Peter Mackay and Chris Swindle.
  4.  
  5. This program is free software; you can redistribute it and/or
  6. modify it under the terms of the GNU General Public License
  7. as published by the Free Software Foundation; either version 2
  8. of the License, or (at your option) any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  13.  
  14. See the GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20. */
  21.  
  22. //#include <psputility_netmodules.h>
  23. #include <pspkernel.h>
  24. #include <psputility.h>
  25. #include <pspnet.h>
  26. #include <pspwlan.h>
  27. #include <pspnet_apctl.h>
  28. #include <pspnet_adhoc.h>
  29. #include <pspnet_adhocctl.h>
  30.  
  31. #include "network_psp.hpp"
  32.  
  33. #include <arpa/inet.h>  // inet_addr
  34. #include <netinet/in.h> // sockaddr_in
  35. #include <sys/socket.h> // PSP socket API.
  36. #include <sys/fcntl.h>
  37. #include <sys/ioctl.h>
  38. #include <unistd.h>
  39. #include <netdb.h>
  40.  
  41. #include <gethost.hpp>
  42.  
  43. #include <pspsdk.h>
  44.  
  45. #define ADHOC_NET 29
  46. #define ADHOC_EWOULDBLOCK   0x80410709
  47.  
  48. #define MAXHOSTNAMELEN  64
  49. #define EWOULDBLOCK     111
  50. #define ECONNREFUSED    11
  51.  
  52. int totalAccessPoints = 0;
  53. cvar_t accesspoint = {"accesspoint", "1", qtrue};
  54. int accessPointNumber[100];
  55.  
  56.  
  57. typedef struct sockaddr_adhoc
  58. {
  59.         char   len;
  60.         short family;
  61.         u16 port;
  62.         char mac[6];
  63.     char zero[6];
  64. } sockaddr_adhoc;
  65.  
  66. #ifdef PROFILE
  67. #define sceUtilityLoadNetModule
  68. #define sceUtilityUnLoadNetModule
  69. #endif
  70.  
  71. static pdpStatStruct gPdpStat;
  72. pdpStatStruct *findPdpStat(int socket, pdpStatStruct *pdpStat)
  73. {
  74.     if(socket == pdpStat->pdpId) {
  75.         memcpy(&gPdpStat, pdpStat, sizeof(pdpStatStruct));
  76.         return &gPdpStat;
  77.     }
  78.         if(pdpStat->next) return findPdpStat(socket, pdpStat->next);
  79.         return (pdpStatStruct *)-1;
  80. }
  81.  
  82.  
  83. namespace quake
  84. {
  85.     namespace network
  86.     {
  87.         namespace infrastructure
  88.         {
  89.             static int accept_socket = -1;      // socket for fielding new connections
  90.             static int control_socket = -1;
  91.             static int broadcast_socket = 0;
  92.             static struct qsockaddr broadcast_addr;
  93.             static int my_addr = 0;
  94.  
  95.             int init (void)
  96.             {
  97.                 if(totalAccessPoints == 0)
  98.                 {
  99.                     int iNetIndex;
  100.                     memset(accessPointNumber, 0, sizeof(accessPointNumber));
  101.                     for (iNetIndex = 1; iNetIndex < 100; iNetIndex++) // skip the 0th connection
  102.                     {
  103.                         if (sceUtilityCheckNetParam(iNetIndex) == 0)
  104.                         {
  105.                             totalAccessPoints++;
  106.                             accessPointNumber[totalAccessPoints] = iNetIndex;
  107.                         }
  108.                     }
  109.                     if(accesspoint.value > totalAccessPoints)
  110.                         Cvar_SetValue("accesspoint", 1);
  111.                 }
  112.  
  113.                 if(!host_initialized)
  114.                 {
  115.                     Cvar_RegisterVariable(&accesspoint);
  116.                 }
  117.  
  118.                 if(!tcpipAvailable)
  119.                     return -1;
  120.  
  121.                 char szMyIPAddr[32];
  122.                 struct qsockaddr addr;
  123.                 char *colon;
  124.  
  125.                 char    buff[MAXHOSTNAMELEN];
  126.  
  127.                 S_ClearBuffer ();       // so dma doesn't loop current sound
  128.  
  129.                 // Load the network modules when they are required
  130.                 sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
  131.                 sceUtilityLoadNetModule(PSP_NET_MODULE_INET);
  132.  
  133.                 // Initialise the network.
  134.                 const int err = pspSdkInetInit();
  135.                 if (err)
  136.                 {
  137.                     Con_Printf("Couldn't initialise the network %08X\n", err);
  138.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_INET);
  139.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  140.                     return -1;
  141.                 }
  142.  
  143.                 if(!connect_to_apctl(accessPointNumber[(int)accesspoint.value]))
  144.                 {
  145.                     Con_Printf("Unable to connect to access point\n");
  146.                     pspSdkInetTerm();
  147.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_INET);
  148.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  149.  
  150.                     return -1;
  151.                 }
  152.  
  153.                 // connected, get my IPADDR and run test
  154. if (sceNetApctlGetInfo(8, (union SceNetApctlInfo*)szMyIPAddr) != 0) // determine my name & address
  155.                     strcpy(szMyIPAddr, "unknown IP address");
  156.  
  157.                 // determine my name & address
  158.                 gethostname(buff, MAXHOSTNAMELEN);
  159.  
  160.                 my_addr = inet_addr(szMyIPAddr);
  161.  
  162.                 // if the quake hostname isn't set, set it to the machine name
  163.                 if (Q_strcmp(hostname.string, "UNNAMED") == 0)
  164.                 {
  165.                     buff[15] = 0;
  166.                     Cvar_Set ("hostname", buff);
  167.                 }
  168.  
  169.                 if ((control_socket = open_socket(0)) == -1)
  170.                 {
  171.                     pspSdkInetTerm();
  172.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_INET);
  173.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  174.                     Sys_Error("init: Unable to open control socket\n");
  175.                 }
  176.  
  177.                 ((struct sockaddr_in *)&broadcast_addr)->sin_family = AF_INET;
  178.                 ((struct sockaddr_in *)&broadcast_addr)->sin_addr.s_addr = INADDR_BROADCAST;
  179.                 ((struct sockaddr_in *)&broadcast_addr)->sin_port = htons(net_hostport);
  180.  
  181.                 get_socket_addr (control_socket, &addr);
  182.                 Q_strcpy(my_tcpip_address,  addr_to_string(&addr));
  183.                 colon = Q_strrchr (my_tcpip_address, ':');
  184.                 if (colon)
  185.                     *colon = 0;
  186.  
  187.                 Con_Printf("UDP Initialized\n");
  188.                 tcpipAvailable = qtrue;
  189.  
  190.                 return control_socket;
  191.             }
  192.  
  193.             //=============================================================================
  194.  
  195.             void shut_down (void)
  196.             {
  197.                 listen(qfalse);
  198.                 close_socket(control_socket);
  199.  
  200.                 pspSdkInetTerm();
  201.  
  202.                 // Now to unload the network modules, no need to keep them loaded all the time
  203.                 sceUtilityUnloadNetModule(PSP_NET_MODULE_INET);
  204.                 sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  205.             }
  206.  
  207.             //=============================================================================
  208.  
  209.             void listen (qboolean state)
  210.             {
  211.                 // enable listening
  212.                 if (state)
  213.                 {
  214.                     if (accept_socket != -1)
  215.                         return;
  216.                     if ((accept_socket = open_socket(net_hostport)) == -1)
  217.                         Sys_Error ("listen: Unable to open accept socket\n");
  218.                     return;
  219.                 }
  220.  
  221.                 // disable listening
  222.                 if (accept_socket == -1)
  223.                     return;
  224.                 close_socket(accept_socket);
  225.  
  226.                 accept_socket = -1;
  227.             }
  228.  
  229.             //=============================================================================
  230.  
  231.             int open_socket (int port)
  232.             {
  233.                 int newsocket;
  234.                 struct sockaddr_in address;
  235.  
  236.                 if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
  237.                     return -1;
  238.  
  239.                 int val = 1;
  240.                 if(setsockopt(newsocket, SOL_SOCKET, SO_NONBLOCK, &val, sizeof(val)) < 0)
  241.                     goto ErrorReturn;
  242.  
  243.                 address.sin_family = AF_INET;
  244.                 address.sin_addr.s_addr = INADDR_ANY;
  245.                 address.sin_port = htons(port);
  246.                 if( bind (newsocket, (sockaddr *)&address, sizeof(address)) == -1)
  247.                     goto ErrorReturn;
  248.  
  249.                 printf("got here4\n");
  250.                 return newsocket;
  251.  
  252.             ErrorReturn:
  253.                 close(newsocket);
  254.                 return -1;
  255.             }
  256.  
  257.             //=============================================================================
  258.  
  259.             int close_socket (int socket)
  260.             {
  261.                 if (socket == broadcast_socket)
  262.                     broadcast_socket = 0;
  263.                 return close(socket);
  264.             }
  265.  
  266.             int connect (int socket, struct qsockaddr *addr)
  267.             {
  268.                 return 0;
  269.             }
  270.  
  271.             //=============================================================================
  272.  
  273.             int check_new_connections (void)
  274.             {
  275.                 byte buf[1000];
  276.  
  277.                 if (accept_socket == -1)
  278.                     return -1;
  279.  
  280.                 // Peek at the message and if there is a message waiting then return the
  281.                 // socket
  282.                 int ret = recvfrom(accept_socket, buf, 1000, MSG_PEEK, NULL, NULL);
  283.  
  284.                 if(ret > 0)
  285.                     return accept_socket;
  286.  
  287.                 return -1;
  288.             }
  289.  
  290.             //=============================================================================
  291.  
  292.             int read (int socket, byte *buf, int len, struct qsockaddr *addr)
  293.             {
  294.                 int addrlen = sizeof (struct qsockaddr);
  295.                 int ret;
  296.  
  297.                 ret = recvfrom (socket, buf, len, 0, (struct sockaddr *)addr, (socklen_t*)&addrlen);
  298.                 if (ret == -1)
  299.                 {
  300.                     int errno = sceNetInetGetErrno();
  301.                     if(errno == EWOULDBLOCK || errno == ECONNREFUSED)
  302.                     {
  303.                         return 0;
  304.                     }
  305.                 }
  306.  
  307.                 return ret;
  308.             }
  309.  
  310.             //=============================================================================
  311.  
  312.             static int make_socket_broadcast_capable (int socket)
  313.             {
  314.                 int             i = 1;
  315.  
  316.                 // make this socket broadcast capable
  317.                 if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, &i, sizeof(i)) < 0)
  318.                     return -1;
  319.                 broadcast_socket = socket;
  320.  
  321.                 return 0;
  322.             }
  323.  
  324.             //=============================================================================
  325.  
  326.             int broadcast (int socket, byte *buf, int len)
  327.             {
  328.                 int ret;
  329.  
  330.                 if (socket != broadcast_socket)
  331.                 {
  332.                     if (broadcast_socket != 0)
  333.                         Sys_Error("Attempted to use multiple broadcasts sockets\n");
  334.                     ret = make_socket_broadcast_capable (socket);
  335.                     if (ret == -1)
  336.                     {
  337.                         Con_Printf("Unable to make socket broadcast capable\n");
  338.                         return ret;
  339.                     }
  340.                 }
  341.  
  342.                 return write(socket, buf, len, &broadcast_addr);
  343.             }
  344.  
  345.             //=============================================================================
  346.  
  347.             int write (int socket, byte *buf, int len, struct qsockaddr *addr)
  348.             {
  349.                 int ret;
  350.  
  351.                 ret = sendto (socket, buf, len, 0, (struct sockaddr *)addr, sizeof(struct qsockaddr));
  352.                 if (ret == -1)
  353.                 {
  354.                     int errno = sceNetInetGetErrno();
  355.                     if(errno == EWOULDBLOCK || errno == ECONNREFUSED)
  356.                     {
  357.                         return 0;
  358.                     }
  359.                     Con_Printf("Failed to send message, errno=%08X\n", errno);
  360.                 }
  361.                 return ret;
  362.             }
  363.  
  364.             //=============================================================================
  365.  
  366.             char* addr_to_string (struct qsockaddr *addr)
  367.             {
  368.                 static char buffer[22];
  369.                 int haddr;
  370.  
  371.                 haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
  372.                 sprintf(buffer, "%d.%d.%d.%d:%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff, ntohs(((struct sockaddr_in *)addr)->sin_port));
  373.                 return buffer;
  374.             }
  375.  
  376.             //=============================================================================
  377.  
  378.             int string_to_addr (char *string, struct qsockaddr *addr)
  379.             {
  380.                 int ha1, ha2, ha3, ha4, hp;
  381.                 int ipaddr;
  382.  
  383.                 sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
  384.                 ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
  385.  
  386.                 addr->sa_family = AF_INET;
  387.                 ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
  388.                 ((struct sockaddr_in *)addr)->sin_port = htons(hp);
  389.                 return 0;
  390.             }
  391.  
  392.             //=============================================================================
  393.  
  394.             int get_socket_addr (int socket, struct qsockaddr *addr)
  395.             {
  396.                 socklen_t addrlen = sizeof(struct qsockaddr);
  397.                 unsigned int a;
  398.  
  399.                 Q_memset(addr, 0, sizeof(struct qsockaddr));
  400.                 getsockname(socket, (struct sockaddr *)addr, &addrlen);
  401.                 a = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
  402.                 if (a == 0 || a == inet_addr("127.0.0.1"))
  403.                     ((struct sockaddr_in *)addr)->sin_addr.s_addr = my_addr;
  404.  
  405.                 return 0;
  406.             }
  407.  
  408.             //=============================================================================
  409.  
  410.             int get_name_from_addr (struct qsockaddr *addr, char *name)
  411.             {
  412.                 struct hostent *hostentry;
  413.  
  414.                 hostentry = gethostbyaddr ((char *)&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr), AF_INET);
  415.                 if (hostentry)
  416.                 {
  417.                     Q_strncpy (name, (char *)hostentry->h_name, NET_NAMELEN - 1);
  418.                     return 0;
  419.                 }
  420.  
  421.                 Q_strcpy (name, addr_to_string (addr));
  422.                 return 0;
  423.             }
  424.  
  425.             //=============================================================================
  426.  
  427.             int get_addr_from_name(char *name, struct qsockaddr *addr)
  428.             {
  429.                 struct hostent *hostentry;
  430.  
  431.                 if (name[0] >= '0' && name[0] <= '9')
  432.                     return PartialIPAddress (name, addr);
  433.                
  434.                 hostentry = gethostbyname (name);
  435.                 if (!hostentry)
  436.                     return -1;
  437.  
  438.                 addr->sa_family = AF_INET;
  439.                 ((struct sockaddr_in *)addr)->sin_port = htons(net_hostport);  
  440.                 ((struct sockaddr_in *)addr)->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
  441.  
  442.                 return 0;
  443.             }
  444.  
  445.             //=============================================================================
  446.  
  447.             int addr_compare (struct qsockaddr *addr1, struct qsockaddr *addr2)
  448.             {
  449.                 if (addr1->sa_family != addr2->sa_family)
  450.                     return -1;
  451.  
  452.                 if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
  453.                     return -1;
  454.  
  455.                 if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
  456.                     return 1;
  457.  
  458.                 return 0;
  459.             }
  460.  
  461.             //=============================================================================
  462.  
  463.             int get_socket_port (struct qsockaddr *addr)
  464.             {
  465.                 return ntohs(((struct sockaddr_in *)addr)->sin_port);
  466.             }
  467.  
  468.  
  469.             int set_socket_port (struct qsockaddr *addr, int port)
  470.             {
  471.                 ((struct sockaddr_in *)addr)->sin_port = htons(port);
  472.                 return 0;
  473.             }
  474.  
  475.             /*
  476.             ============
  477.             PartialIPAddress
  478.  
  479.             this lets you type only as much of the net address as required, using
  480.             the local network components to fill in the rest
  481.             ============
  482.             */
  483.             int PartialIPAddress (char *in, struct qsockaddr *hostaddr)
  484.             {
  485.                 char buff[256];
  486.                 char *b;
  487.                 int addr;
  488.                 int num;
  489.                 int mask;
  490.                 int run;
  491.                 int port;
  492.                
  493.                 buff[0] = '.';
  494.                 b = buff;
  495.                 strcpy(buff+1, in);
  496.                 if (buff[1] == '.')
  497.                     b++;
  498.  
  499.                 addr = 0;
  500.                 mask=-1;
  501.                 while (*b == '.')
  502.                 {
  503.                     b++;
  504.                     num = 0;
  505.                     run = 0;
  506.                     while (!( *b < '0' || *b > '9'))
  507.                     {
  508.                       num = num*10 + *b++ - '0';
  509.                       if (++run > 3)
  510.                         return -1;
  511.                     }
  512.                     if ((*b < '0' || *b > '9') && *b != '.' && *b != ':' && *b != 0)
  513.                         return -1;
  514.                     if (num < 0 || num > 255)
  515.                         return -1;
  516.                     mask<<=8;
  517.                     addr = (addr<<8) + num;
  518.                 }
  519.                
  520.                 if (*b++ == ':')
  521.                     port = Q_atoi(b);
  522.                 else
  523.                     port = net_hostport;
  524.  
  525.                 hostaddr->sa_family = AF_INET;
  526.                 ((struct sockaddr_in *)hostaddr)->sin_port = htons((short)port);   
  527.                 ((struct sockaddr_in *)hostaddr)->sin_addr.s_addr = (my_addr & htonl(mask)) | htonl(addr);
  528.                
  529.                 return 0;
  530.             }
  531.             //=============================================================================
  532.             /* Connect to an access point */
  533.             int connect_to_apctl(int config)
  534.             {
  535.                 int err;
  536.                 int stateLast = -1;
  537.                 int timeout = 0;
  538.  
  539.                 /* Connect using the first profile */
  540.                 err = sceNetApctlConnect(config);
  541.                 if (err != 0)
  542.                 {
  543.                     return 0;
  544.                 }
  545.  
  546.                 while (1)
  547.                 {
  548.                     int state;
  549.                     err = sceNetApctlGetState(&state);
  550.                     if (err != 0)
  551.                     {
  552.                         break;
  553.                     }
  554.                     if (state > stateLast)
  555.                     {
  556.                         stateLast = state;
  557.                         timeout = 0;
  558.                     }
  559.                     if (state == 4)
  560.                         break;  // connected with static IP
  561.  
  562.                     // wait a little before polling again
  563.                     sceKernelDelayThread(50*1000); // 50ms
  564.  
  565.                     timeout++;
  566.                     if(timeout > 200)
  567.                     {
  568.                         Con_Printf("Timeout connecting to access point. State=%d\n", state);
  569.                         return 0;
  570.                     }
  571.                 }
  572.  
  573.                 if(err != 0)
  574.                 {
  575.                     return 0;
  576.                 }
  577.  
  578.                 return 1;
  579.             }
  580.             //=============================================================================
  581.         }
  582.         namespace adhoc
  583.         {
  584.             static int accept_socket = -1;      // socket for fielding new connections
  585.             static int control_socket = -1;
  586.             static int broadcast_socket = 0;
  587.             static struct qsockaddr broadcast_addr;
  588.             static int my_addr = 0;
  589.  
  590.             int init (void)
  591.             {
  592.                 if(!tcpipAvailable) return -1;
  593.  
  594.                 struct qsockaddr addr;
  595.                 char *colon;
  596.                 char    buff[MAXHOSTNAMELEN];
  597.                 int i,rc;
  598.  
  599.                 S_ClearBuffer ();
  600.  
  601.                 sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
  602.                 sceUtilityLoadNetModule(PSP_NET_MODULE_ADHOC);
  603.  
  604.                 int stateLast = -1;
  605.                
  606.                 rc = pspSdkAdhocInit("ULUS00443");
  607.                 if(rc < 0) {
  608.                     Con_Printf("Couldn't initialise the network %08X\n", rc);
  609.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_ADHOC);
  610.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  611.                     return -1;
  612.                 }
  613.                
  614.                 rc = sceNetAdhocctlConnect((char *)"quake");
  615.                 if(rc < 0) {
  616.                     Con_Printf("Couldn't initialise the network %08X\n", rc);
  617.                     pspSdkAdhocTerm();
  618.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_ADHOC);
  619.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  620.                     return -1;
  621.                 }
  622.            
  623.                 while (1) {
  624.                     int state;
  625.                     rc = sceNetAdhocctlGetState(&state);
  626.                     if (rc != 0) {
  627.                         Con_Printf("Couldn't initialise the network %08X\n", rc);
  628.                         pspSdkAdhocTerm();
  629.                         sceUtilityUnloadNetModule(PSP_NET_MODULE_ADHOC);
  630.                         sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  631.                         return -1;
  632.                     }
  633.                     if (state > stateLast) {
  634.                         stateLast = state;
  635.                     }
  636.                     if (state == 1) {
  637.                         break;
  638.                     }
  639.                     sceKernelDelayThread(50*1000); // 50ms
  640.                 }
  641.            
  642.                 gethostname(buff, MAXHOSTNAMELEN);
  643.                 if (Q_strcmp(hostname.string, "UNNAMED") == 0)
  644.                 {
  645.                     buff[15] = 0;
  646.                     Cvar_Set ("hostname", buff);
  647.                 }
  648.  
  649.                 if ((control_socket = open_socket(0)) == -1) {
  650.                     pspSdkAdhocTerm();
  651.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_ADHOC);
  652.                     sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  653.                     Sys_Error("init: Unable to open control socket\n");
  654.                 }
  655.  
  656.                 ((sockaddr_adhoc *)&broadcast_addr)->family = ADHOC_NET;
  657.                 for(i=0; i<6; i++) ((sockaddr_adhoc *)&broadcast_addr)->mac[i] = 0xFF;
  658.                 ((sockaddr_adhoc *)&broadcast_addr)->port = net_hostport;
  659.  
  660.                 get_socket_addr (control_socket, &addr);
  661.                 Q_strcpy(my_tcpip_address,  addr_to_string(&addr));
  662.                 colon = Q_strrchr(my_tcpip_address, ':');
  663.                 if (colon) *colon = 0;
  664.  
  665.                 listen(qtrue);
  666.  
  667.                 Con_Printf("AdHoc Initialized\n");
  668.                 tcpipAvailable = qtrue;
  669.                 tcpipAdhoc = qtrue;
  670.                 return control_socket;
  671.             }
  672.  
  673.             //=============================================================================
  674.  
  675.             void shut_down (void)
  676.             {
  677.                 listen(qfalse);
  678.                 close_socket(control_socket);
  679.                 pspSdkAdhocTerm();
  680.  
  681.                 // Now to unload the network modules, no need to keep them loaded all the time
  682.                 sceUtilityUnloadNetModule(PSP_NET_MODULE_ADHOC);
  683.                 sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
  684.             }
  685.  
  686.             //=============================================================================
  687.  
  688.             void listen (qboolean state)
  689.             {
  690.                 // enable listening
  691.                 if (state)
  692.                 {
  693.                     if (accept_socket != -1)
  694.                         return;
  695.                     if ((accept_socket = open_socket(net_hostport)) == -1)
  696.                         Sys_Error ("listen: Unable to open accept socket\n");
  697.                     return;
  698.                 }
  699.  
  700.                 // disable listening
  701.                 if (accept_socket == -1)
  702.                     return;
  703.                 close_socket(accept_socket);
  704.                 accept_socket = -1;
  705.             }
  706.  
  707.             //=============================================================================
  708.  
  709.             int open_socket (int port)
  710.             {
  711.                 u8 mac[8];
  712.                 sceWlanGetEtherAddr(mac);
  713.                 int rc = sceNetAdhocPdpCreate(mac, port, 0x2000, 0);
  714.                 if(rc < 0) return -1;
  715.                 return rc;
  716.             }
  717.  
  718.             //=============================================================================
  719.  
  720.             int close_socket (int socket)
  721.             {
  722.                 if (socket == broadcast_socket) broadcast_socket = 0;
  723.                 return sceNetAdhocPdpDelete(socket, 0);
  724.             }
  725.  
  726.             int connect (int socket, struct qsockaddr *addr)
  727.             {
  728.                 return 0;
  729.             }
  730.  
  731.             //=============================================================================
  732.  
  733.             int check_new_connections (void)
  734.             {
  735.                 pdpStatStruct pdpStat[20];
  736.                 int length = sizeof(pdpStatStruct) * 20;
  737.  
  738.                 if (accept_socket == -1)
  739.                     return -1;
  740.  
  741.                 int err = sceNetAdhocGetPdpStat(&length, pdpStat);
  742.                 if(err < 0) return -1;
  743.  
  744.                 pdpStatStruct *tempPdp = findPdpStat(accept_socket, pdpStat);
  745.  
  746.                 if(tempPdp < 0) return -1;
  747.  
  748.                 if(tempPdp->rcvdData > 0) return accept_socket;
  749.  
  750.                 return -1;
  751.             }
  752.  
  753.             //=============================================================================
  754.  
  755.             int read (int socket, byte *buf, int len, struct qsockaddr *addr)
  756.             {
  757.                 unsigned short port;
  758.                 int datalength = len;
  759.                 unsigned int ret;
  760.  
  761.                 sceKernelDelayThread(1);
  762.  
  763.                 ret = sceNetAdhocPdpRecv(socket, (unsigned char *)((sockaddr_adhoc *)addr)->mac, &port, buf, &datalength, 0, 1);
  764.                 if(ret == ADHOC_EWOULDBLOCK) return 0;
  765.  
  766.                 ((sockaddr_adhoc *)addr)->port = port;
  767.  
  768.                 return datalength;
  769.             }
  770.  
  771.             //=============================================================================
  772.  
  773.             static int make_socket_broadcast_capable (int socket)
  774.             {
  775.                 broadcast_socket = socket;
  776.                 return 0;
  777.             }
  778.  
  779.             //=============================================================================
  780.  
  781.             int broadcast (int socket, byte *buf, int len)
  782.             {
  783.                 int ret;
  784.  
  785.                 if (socket != broadcast_socket)
  786.                 {
  787.                     if (broadcast_socket != 0)
  788.                         Sys_Error("Attempted to use multiple broadcasts sockets\n");
  789.                     ret = make_socket_broadcast_capable (socket);
  790.                     if (ret == -1)
  791.                     {
  792.                         Con_Printf("Unable to make socket broadcast capable\n");
  793.                         return ret;
  794.                     }
  795.                 }
  796.  
  797.                 return write(socket, buf, len, &broadcast_addr);
  798.             }
  799.  
  800.             //=============================================================================
  801.  
  802.             int write (int socket, byte *buf, int len, struct qsockaddr *addr)
  803.             {
  804.                 int ret = -1;
  805.  
  806.                 ret = sceNetAdhocPdpSend(socket, (unsigned char*)((sockaddr_adhoc *)addr)->mac, ((sockaddr_adhoc *)addr)->port, buf, len, 0, 1);
  807.  
  808.                 if(ret < 0) Con_Printf("Failed to send message, errno=%08X\n", ret);
  809.                 return ret;
  810.             }
  811.  
  812.             //=============================================================================
  813.  
  814.             char* addr_to_string (struct qsockaddr *addr)
  815.             {
  816.                 static char buffer[22];
  817.  
  818.                 sceNetEtherNtostr((unsigned char *)((sockaddr_adhoc *)addr)->mac, buffer);
  819.                 sprintf(buffer + strlen(buffer), ":%d", ((sockaddr_adhoc *)addr)->port);
  820.                 return buffer;
  821.             }
  822.  
  823.             //=============================================================================
  824.  
  825.             int string_to_addr (char *string, struct qsockaddr *addr)
  826.             {
  827.                 int ha1, ha2, ha3, ha4, ha5, ha6, hp;
  828.  
  829.                 sscanf(string, "%x:%x:%x:%x:%x:%x:%d", &ha1, &ha2, &ha3, &ha4, &ha5, &ha6, &hp);
  830.                 addr->sa_family = ADHOC_NET;
  831.                 ((struct sockaddr_adhoc *)addr)->mac[0] = ha1 & 0xFF;
  832.                 ((struct sockaddr_adhoc *)addr)->mac[1] = ha2 & 0xFF;
  833.                 ((struct sockaddr_adhoc *)addr)->mac[2] = ha3 & 0xFF;
  834.                 ((struct sockaddr_adhoc *)addr)->mac[3] = ha4 & 0xFF;
  835.                 ((struct sockaddr_adhoc *)addr)->mac[4] = ha5 & 0xFF;
  836.                 ((struct sockaddr_adhoc *)addr)->mac[5] = ha6 & 0xFF;
  837.                 ((struct sockaddr_adhoc *)addr)->port = hp & 0xFFFF;
  838.                 return 0;
  839.             }
  840.  
  841.             //=============================================================================
  842.  
  843.             int get_socket_addr (int socket, struct qsockaddr *addr)
  844.             {
  845.                 pdpStatStruct pdpStat[20];
  846.                 int length = sizeof(pdpStatStruct) * 20;
  847.  
  848.                 int err = sceNetAdhocGetPdpStat(&length, pdpStat);
  849.                 if(err<0) return -1;
  850.  
  851.                 pdpStatStruct *tempPdp = findPdpStat(socket, pdpStat);
  852.                 if(tempPdp < 0) return -1;
  853.  
  854.                 memcpy(((struct sockaddr_adhoc *)addr)->mac, tempPdp->mac, 6);
  855.                 ((struct sockaddr_adhoc *)addr)->port = tempPdp->port;
  856.                 addr->sa_family = ADHOC_NET;
  857.                 return 0;
  858.             }
  859.  
  860.             //=============================================================================
  861.  
  862.             int get_name_from_addr (struct qsockaddr *addr, char *name)
  863.             {
  864.                 strcpy(name, addr_to_string(addr));
  865.                 return 0;
  866.             }
  867.  
  868.             //=============================================================================
  869.  
  870.             int get_addr_from_name(char *name, struct qsockaddr *addr)
  871.             {
  872.                 return string_to_addr(name, addr);
  873.             }
  874.  
  875.             //=============================================================================
  876.  
  877.             int addr_compare (struct qsockaddr *addr1, struct qsockaddr *addr2)
  878.             {
  879.                 //if (addr1->sa_family != addr2->sa_family) return -1;
  880.                 if (memcmp(((struct sockaddr_adhoc *)addr1)->mac, ((struct sockaddr_adhoc *)addr2)->mac, 6) != 0) return -1;
  881.                 if (((struct sockaddr_adhoc *)addr1)->port != ((struct sockaddr_adhoc *)addr2)->port) return 1;
  882.                 return 0;
  883.             }
  884.  
  885.             //=============================================================================
  886.  
  887.             int get_socket_port (struct qsockaddr *addr)
  888.             {
  889.                 return ((struct sockaddr_adhoc *)addr)->port;
  890.             }
  891.  
  892.  
  893.             int set_socket_port (struct qsockaddr *addr, int port)
  894.             {
  895.                 ((struct sockaddr_adhoc *)addr)->port = port;
  896.                 return 0;
  897.             }
  898.  
  899.             //=============================================================================
  900.  
  901.             int pspSdkAdhocInit(char *product)
  902.             {
  903.                 u32 retVal;
  904.                 struct productStruct temp;
  905.  
  906.                 retVal = sceNetInit(0x20000, 0x20, 0x1000, 0x20, 0x1000);
  907.                 if (retVal != 0) return retVal;
  908.  
  909.                 retVal = sceNetAdhocInit();
  910.                 if (retVal != 0) return retVal;
  911.  
  912.                 strcpy(temp.product, product);
  913.                 temp.unknown = 0;
  914.    
  915.                 retVal = sceNetAdhocctlInit(0x2000, 0x20, &temp);
  916.                 if (retVal != 0) return retVal;
  917.  
  918.                 return 0;
  919.             }
  920.  
  921.             //=============================================================================
  922.  
  923.             void pspSdkAdhocTerm()
  924.             {
  925.                 sceNetAdhocctlTerm();
  926.                 sceNetAdhocTerm();
  927.                 sceNetTerm();
  928.             }
  929.  
  930.             //=============================================================================
  931.  
  932.         }
  933.     }
  934. }
Advertisement
RAW Paste Data Copied
Advertisement