int _main(void) { // Init and resolve libraries initKernel(); initLibc(); initNetwork(); initPthread(); // Init netdebug struct sockaddr_in server; server.sin_family = sceNetHtons(AF_INET); server.sin_addr.s_addr = IP(192, 168, 0, 4); server.sin_port = sceNetHtons(9023); memset(server.sin_zero, 0, sizeof(server.sin_zero)); netdbg_sock = sceNetSocket("netdebug", AF_INET, SOCK_STREAM, 0); sceNetConnect(netdbg_sock, (struct sockaddr *)&server, sizeof(server)); ftp_init(PS4_IP, PS4_PORT); //INFO("PS4 listening on IP %s Port %i\n", PS4_IP, PS4_PORT); while (1) { sceKernelUsleep(100 * 1000); } ftp_fini(); return 0; }
int _main(void) { // Pass address of a syscall gadget in rcx register f rcx asm("rcx"); directSyscall = rcx; // Init and resolve libraries initLibc(); initNetwork(); // Connect to server and send message char socketName[] = "debug"; struct sockaddr_in server; server.sin_family = sceNetHtons(AF_INET); server.sin_addr.s_addr = IP(192, 168, 0, 4); server.sin_port = sceNetHtons(9023); memset(server.sin_zero, 0, sizeof(server.sin_zero)); int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0); sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server)); char buffer[512]; struct dirent *dent; int dfd = open("/", O_RDONLY, 0); if(dfd < 0) { debug(sock, "Invalid directory.\n"); return 1; } while(getdents(dfd, buffer, sizeof(buffer)) != 0) { dent = (struct dirent *)buffer; while(dent->d_fileno) { debug(sock, "%s\n", dent->d_name); dent = (struct dirent *)((void *)dent + dent->d_reclen); } memset(buffer, 0, sizeof(buffer)); } // Return to browser close(dfd); sceNetSocketClose(sock); return 0; }
int ps4LinkLseek(int fd, int offset, int whence) { ps4link_pkt_lseek_req *lseekreq; ps4link_pkt_file_rly *lseekrly; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } debugNetPrintf(DEBUG,"[PS4LINK] file lseek req (fd: %d)\n", fd); lseekreq = (ps4link_pkt_lseek_req *)&send_packet[0]; lseekrly = (ps4link_pkt_file_rly *)&recv_packet[0]; lseekreq->cmd = sceNetHtonl(PS4LINK_LSEEK_CMD); lseekreq->len = sceNetHtons((unsigned short)sizeof(ps4link_pkt_lseek_req)); lseekreq->fd = sceNetHtonl(fd); lseekreq->offset = sceNetHtonl(offset); lseekreq->whence = sceNetHtonl(whence); if(ps4link_send(ps4LinkGetValue(FILEIO_SOCK), lseekreq, sizeof(ps4link_pkt_lseek_req), MSG_DONTWAIT) < 0) { return -1; } if(!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), (char *)lseekrly,sizeof(ps4link_pkt_file_rly), PS4LINK_LSEEK_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_lseek_file: did not receive PS4LINK_LSEEK_RLY\n"); return -1; } debugNetPrintf(DEBUG,"[PS4LINK] ps4link_lseek_file: lseek reply received (ret %d)\n",sceNetNtohl(lseekrly->retval)); return sceNetNtohl(lseekrly->retval); }
int ps4LinkRmdir(const char *dirname) { ps4link_pkt_rmdir_req *rmdirreq; ps4link_pkt_file_rly *rmdirrly; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } debugNetPrintf(DEBUG,"[PS4LINK] ps4link_file: remove dir req (%s)\n", dirname); rmdirreq = (ps4link_pkt_rmdir_req *)&send_packet[0]; // Build packet rmdirreq->cmd = sceNetHtonl(PS4LINK_RMDIR_CMD); rmdirreq->len = sceNetHtons((unsigned short)sizeof(ps4link_pkt_rmdir_req)); strncpy(rmdirreq->name, dirname, PS4LINK_MAX_PATH); rmdirreq->name[PS4LINK_MAX_PATH - 1] = 0; // Make sure it's null-terminated if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), rmdirreq, sizeof(ps4link_pkt_rmdir_req), MSG_DONTWAIT) < 0) { return -1; } if (!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), recv_packet, sizeof(ps4link_pkt_file_rly), PS4LINK_RMDIR_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_file: ps4link_rmdir: did not receive RMDIR_RLY\n"); return -1; } rmdirrly = (ps4link_pkt_file_rly *)recv_packet; debugNetPrintf(DEBUG,"[PS4LINK] ps4link_file: remove dir reply received (ret %d)\n", sceNetNtohl(rmdirrly->retval)); return sceNetNtohl(rmdirrly->retval); }
int ps4LinkDopen(const char *dirname) { ps4link_pkt_open_req *openreq; ps4link_pkt_file_rly *openrly; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } debugNetPrintf(DEBUG,"[PS4LINK] dir open req (%s)\n", dirname); openreq = (ps4link_pkt_open_req *)&send_packet[0]; // Build packet openreq->cmd = sceNetHtonl(PS4LINK_OPENDIR_CMD); openreq->len = sceNetHtons((unsigned short)sizeof(ps4link_pkt_open_req)); openreq->flags = sceNetHtonl(0); strncpy(openreq->path, dirname, PS4LINK_MAX_PATH); openreq->path[PS4LINK_MAX_PATH - 1] = 0; // Make sure it's null-terminated if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), openreq, sizeof(ps4link_pkt_open_req), MSG_DONTWAIT) < 0) { return -1; } if (!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), recv_packet, sizeof(ps4link_pkt_file_rly), PS4LINK_OPENDIR_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_open_dir: did not receive OPENDIR_RLY\n"); return -1; } openrly = (ps4link_pkt_file_rly *)recv_packet; debugNetPrintf(DEBUG,"[PS4LINK] dir open reply received (ret %d)\n", sceNetNtohl(openrly->retval)); return sceNetNtohl(openrly->retval); }
int ps4LinkDclose(int fd) { ps4link_pkt_close_req *closereq; ps4link_pkt_file_rly *closerly; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } debugNetPrintf(DEBUG,"[PS4LINK] ps4link_file: dir close req (fd: %d)\n", fd); closereq = (ps4link_pkt_close_req *)&send_packet[0]; closerly = (ps4link_pkt_file_rly *)&recv_packet[0]; closereq->cmd = sceNetHtonl(PS4LINK_CLOSEDIR_CMD); closereq->len = sceNetHtons((unsigned short)sizeof(ps4link_pkt_close_req)); closereq->fd = sceNetHtonl(fd); if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), closereq, sizeof(ps4link_pkt_close_req), MSG_DONTWAIT) < 0) { return -1; } if(!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), (char *)closerly, sizeof(ps4link_pkt_file_rly), PS4LINK_CLOSEDIR_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_close_dir: did not receive PS4LINK_CLOSEDIR_RLY\n"); return -1; } debugNetPrintf(DEBUG,"[PS4LINK] dir close reply received (ret %d)\n", sceNetNtohl(closerly->retval)); return sceNetNtohl(closerly->retval); }
void console_init() { SceNetInitParam initparam; if (console_initialzed) { return; } console_mtx = sceKernelCreateMutex("console_mutex", 0, 0, NULL); if (sceSysmoduleIsLoaded(SCE_SYSMODULE_NET) != SCE_SYSMODULE_LOADED) sceSysmoduleLoadModule(SCE_SYSMODULE_NET); if (sceNetShowNetstat() == SCE_NET_ERROR_ENOTINIT) { net_memory = malloc(NET_INIT_SIZE); initparam.memory = net_memory; initparam.size = NET_INIT_SIZE; initparam.flags = 0; sceNetInit(&initparam); } sock = sceNetSocket("netdbg", SCE_NET_AF_INET, SCE_NET_SOCK_DGRAM, 0); memset(&target, 0, sizeof(target)); target.sin_family = SCE_NET_AF_INET; target.sin_port = sceNetHtons(3490); sceNetInetPton(SCE_NET_AF_INET, "192.168.1.104", &target.sin_addr); console_initialzed = 1; }
int _main(void) { // Init and resolve libraries initKernel(); initLibc(); initNetwork(); // Connect to server and send message char socketName[] = "debug"; struct sockaddr_in server; server.sin_len = sizeof(server); server.sin_family = AF_INET; server.sin_addr.s_addr = IP(192, 168, 0, 4); server.sin_port = sceNetHtons(9023); memset(server.sin_zero, 0, sizeof(server.sin_zero)); int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0); sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server)); debug(sock, "PID: %d", syscall(20)); sceNetSocketClose(sock); // Return to browser return 0; }
static void cmd_PASV_func(ClientInfo *client) { int ret; UNUSED(ret); char cmd[512]; unsigned int namelen; SceNetSockaddrIn picked; /* Create data mode socket name */ char data_socket_name[64]; sprintf(data_socket_name, "FTPVita_client_%i_data_socket", client->num); /* Create the data socket */ client->data_sockfd = sceNetSocket(data_socket_name, PSP2_NET_AF_INET, PSP2_NET_SOCK_STREAM, 0); DEBUG("PASV data socket fd: %d\n", client->data_sockfd); /* Fill the data socket address */ client->data_sockaddr.sin_family = PSP2_NET_AF_INET; client->data_sockaddr.sin_addr.s_addr = sceNetHtonl(PSP2_NET_INADDR_ANY); /* Let the PSVita choose a port */ client->data_sockaddr.sin_port = sceNetHtons(0); /* Bind the data socket address to the data socket */ ret = sceNetBind(client->data_sockfd, (SceNetSockaddr *)&client->data_sockaddr, sizeof(client->data_sockaddr)); DEBUG("sceNetBind(): 0x%08X\n", ret); /* Start listening */ ret = sceNetListen(client->data_sockfd, 128); DEBUG("sceNetListen(): 0x%08X\n", ret); /* Get the port that the PSVita has chosen */ namelen = sizeof(picked); sceNetGetsockname(client->data_sockfd, (SceNetSockaddr *)&picked, &namelen); DEBUG("PASV mode port: 0x%04X\n", picked.sin_port); /* Build the command */ sprintf(cmd, "227 Entering Passive Mode (%hhu,%hhu,%hhu,%hhu,%hhu,%hhu)\n", (vita_addr.s_addr >> 0) & 0xFF, (vita_addr.s_addr >> 8) & 0xFF, (vita_addr.s_addr >> 16) & 0xFF, (vita_addr.s_addr >> 24) & 0xFF, (picked.sin_port >> 0) & 0xFF, (picked.sin_port >> 8) & 0xFF); client_send_ctrl_msg(client, cmd); /* Set the data connection type to passive! */ client->data_con_type = FTP_DATA_CONNECTION_PASSIVE; }
uint16_t inet_htons(uint16_t hostshort) { #if defined(VITA) || defined(__ORBIS__) return sceNetHtons(hostshort); #else return htons(hostshort); #endif }
int _main(void) { // Init and resolve libraries initKernel(); initLibc(); initNetwork(); // Connect to server char socketName[] = "debug"; struct sockaddr_in server; server.sin_len = sizeof(server); server.sin_family = AF_INET; server.sin_addr.s_addr = IP(192, 168, 0, 4); server.sin_port = sceNetHtons(9023); memset(server.sin_zero, 0, sizeof(server.sin_zero)); int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0); sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server)); // Get font path char path[256] = "/"; int length = 11; getSandboxDirectory(path + 1, &length); strcpy(path + 11, "/common/font/DFHEI5-SONY.ttf"); // Open for reading, and get size int fd = open(path, O_RDONLY, 0); struct stat s; fstat(fd, &s); // Allocate buffer and read char *buffer = malloc(s.st_size); read(fd, buffer, s.st_size); close(fd); // Send sceNetSend(sock, buffer, s.st_size, 0); free(buffer); sceNetSocketClose(sock); // Return to browser return 0; }
void blob_transfer_init() { struct sockaddr_in server; memset(&server, 0, sizeof(server)); server.sin_len = sizeof(server); server.sin_family = AF_INET; server.sin_addr.s_addr = BLOBS_ADDR; server.sin_port = sceNetHtons(BLOBS_PORT); blobs_sockfd = sceNetSocket("blobs", AF_INET, SOCK_STREAM, 0); sceNetConnect(blobs_sockfd, (struct sockaddr *)&server, sizeof(server)); }
int _main(void) { // Init and resolve libraries initLibc(); initNetwork(); // Connect to server char socketName[] = "debug"; struct sockaddr_in server; server.sin_len = sizeof(server); server.sin_family = AF_INET; server.sin_addr.s_addr = IP(192, 168, 0, 4); server.sin_port = sceNetHtons(9023); memset(server.sin_zero, 0, sizeof(server.sin_zero)); int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0); sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server)); // Read / directory char buffer[512]; struct dirent *dent; int dfd = open("/", O_RDONLY, 0); if(dfd < 0) { debug(sock, "Invalid directory.\n"); return 1; } while(getdents(dfd, buffer, sizeof(buffer)) != 0) { dent = (struct dirent *)buffer; while(dent->d_fileno) { debug(sock, "[%s]: %s\n", entryName(dent->d_type), dent->d_name); dent = (struct dirent *)((void *)dent + dent->d_reclen); } memset(buffer, 0, sizeof(buffer)); } // Return to browser close(dfd); sceNetSocketClose(sock); return 0; }
static void cmd_PORT_func(ClientInfo *client) { unsigned char data_ip[4]; unsigned char porthi, portlo; unsigned short data_port; char ip_str[16]; SceNetInAddr data_addr; sscanf(client->recv_buffer, "%*s %hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &data_ip[0], &data_ip[1], &data_ip[2], &data_ip[3], &porthi, &portlo); data_port = portlo + porthi*256; /* Convert to an X.X.X.X IP string */ sprintf(ip_str, "%d.%d.%d.%d", data_ip[0], data_ip[1], data_ip[2], data_ip[3]); /* Convert the IP to a SceNetInAddr */ sceNetInetPton(PSP2_NET_AF_INET, ip_str, &data_addr); DEBUG("PORT connection to client's IP: %s Port: %d\n", ip_str, data_port); /* Create data mode socket name */ char data_socket_name[64]; sprintf(data_socket_name, "FTPVita_client_%i_data_socket", client->num); /* Create data mode socket */ client->data_sockfd = sceNetSocket(data_socket_name, PSP2_NET_AF_INET, PSP2_NET_SOCK_STREAM, 0); DEBUG("Client %i data socket fd: %d\n", client->num, client->data_sockfd); /* Prepare socket address for the data connection */ client->data_sockaddr.sin_family = PSP2_NET_AF_INET; client->data_sockaddr.sin_addr = data_addr; client->data_sockaddr.sin_port = sceNetHtons(data_port); /* Set the data connection type to active! */ client->data_con_type = FTP_DATA_CONNECTION_ACTIVE; client_send_ctrl_msg(client, "200 PORT command successful!\n"); }
int ps4LinkDread(int fd, struct dirent *dir) { ps4link_pkt_dread_req *dirreq; ps4link_pkt_dread_rly *dirrly; struct dirent *dirent; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } debugNetPrintf(DEBUG,"[PS4LINK] dir read req (%x)\n", fd); dirreq = (ps4link_pkt_dread_req *)&send_packet[0]; // Build packet dirreq->cmd = sceNetHtonl(PS4LINK_READDIR_CMD); dirreq->len = sceNetHtons((unsigned short)sizeof(ps4link_pkt_dread_req)); dirreq->fd = sceNetHtonl(fd); if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), dirreq, sizeof(ps4link_pkt_dread_req), MSG_DONTWAIT) < 0) { return -1; } if (!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), recv_packet, sizeof(ps4link_pkt_dread_rly), PS4LINK_READDIR_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_read_dir: did not receive OPENDIR_RLY\n"); return -1; } dirrly = (ps4link_pkt_dread_rly *)recv_packet; debugNetPrintf(DEBUG,"[PS4LINK] dir read reply received (ret %d)\n", sceNetNtohl(dirrly->retval)); dirent = (struct dirent *) dir; strncpy(dirent->d_name,dirrly->name,256); dirent->d_type=dirrly->type; return sceNetNtohl(dirrly->retval); }
int _main(void) { // Init and resolve libraries initLibc(); initNetwork(); initPad(); // Connect to debug server char socketName[] = "debug"; struct sockaddr_in server; server.sin_len = sizeof(server); server.sin_family = AF_INET; server.sin_addr.s_addr = IP(192, 168, 0, 4); server.sin_port = sceNetHtons(9023); memset(server.sin_zero, 0, sizeof(server.sin_zero)); int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0); sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server)); // Browser /user/home/ to see all user IDs (in hex) int userID = 0x10000000; int pad = scePadOpen(userID, 0, 0, NULL); while(1) { scePadReadState(pad, data); sceNetSend(sock, data, 0x60, 0); } // Return to browser scePadClose(pad); sceNetSocketClose(sock); return 0; }
/* connecthostport() * return a socket connected (TCP) to the host and port * or -1 in case of error */ int connecthostport(const char * host, unsigned short port) { printk("Connect Attempt: %s:%u\n", host, port); // Target Address SceNetInetSockaddrIn in; // Clear Memory memset(&in, 0, sizeof(in)); // Set Address Family in.sin_family = AF_INET; // Set Structure Length in.sin_len = sizeof(in); // Translate Port in.sin_port = sceNetHtons(port); // Resolve Domain if(sceNetResolverStartNtoA(_rid, host, &in.sin_addr, 500000, 2) != 0) { // Attempt IP Conversion sceNetInetInetAton(host, &in.sin_addr); } // Create Socket int s = sceNetInetSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Valid Socket if(s > 0) { // Enabler int one = 1; // Enable Port Re-use sceNetInetSetsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); sceNetInetSetsockopt(s, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one)); // Set 3-Second Timeout uint32_t timeout = 3000000; sceNetInetSetsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); sceNetInetSetsockopt(s, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)); // Connect to Destination if(sceNetInetConnect(s, (SceNetInetSockaddr *)&in, sizeof(in)) == 0/* || sceNetInetGetErrno() == 106*/) { printk("Connection Success\n"); // Return Socket return s; } printk("Errno: %d\n", sceNetInetGetErrno()); // Close Socket sceNetInetClose(s); logSockets(); } // Error State return -1; }
/** * Init debugnet library * * @par Example: * @code * #define LOGLEVEL 3 * int ret; * ret = debugNetInit("172.26.0.2", 18194, DEBUG); * @endcode * * @param serverIP - your pc/mac server ip * @param port - udp port server * @param level - DEBUG,ERROR,INFO or NONE */ int debugNetInit(char *serverIp, int port, int level) { int ret; SceNetInitParam initparam; SceNetCtlInfo info; struct SceNetSockaddrIn stSockAddr; debugNetSetLogLevel(level); if (debugnet_initialized) { return debugnet_initialized; } /*net initialazation code from xerpi at https://github.com/xerpi/FTPVita/blob/master/ftp.c*/ /* Init Net */ if (sceNetShowNetstat() == PSP2_NET_ERROR_ENOTINIT) { net_memory = malloc(NET_INIT_SIZE); initparam.memory = net_memory; initparam.size = NET_INIT_SIZE; initparam.flags = 0; ret = sceNetInit(&initparam); //printf("sceNetInit(): 0x%08X\n", ret); } else { //printf("Net is already initialized.\n"); } /* Init NetCtl */ ret = sceNetCtlInit(); //printf("sceNetCtlInit(): 0x%08X\n", ret); /* Get IP address */ ret = sceNetCtlInetGetInfo(PSP2_NETCTL_INFO_GET_IP_ADDRESS, &info); //printf("sceNetCtlInetGetInfo(): 0x%08X\n", ret); /* Save the IP of PSVita to a global variable */ sceNetInetPton(PSP2_NET_AF_INET, info.ip_address, &vita_addr); /* Create datagram udp socket*/ SocketFD = sceNetSocket("debugnet_socket", PSP2_NET_AF_INET , PSP2_NET_SOCK_DGRAM, PSP2_NET_IPPROTO_UDP); memset(&stSockAddr, 0, sizeof stSockAddr); /*Populate SceNetSockaddrIn structure values*/ stSockAddr.sin_family = PSP2_NET_AF_INET; stSockAddr.sin_port = sceNetHtons(port); sceNetInetPton(PSP2_NET_AF_INET, serverIp, &stSockAddr.sin_addr); /*Connect socket to server*/ sceNetConnect(SocketFD, (struct SceNetSockaddr *)&stSockAddr, sizeof stSockAddr); /*Show log on pc/mac side*/ debugNetUDPPrintf("debugnet initialized\n"); debugNetUDPPrintf("Copyright (C) 2010,2015 Antonio Jose Ramos Marquez aka bigboss @psxdev\n"); debugNetUDPPrintf("This Program is subject to the terms of the Mozilla Public\n" "License, v. 2.0. If a copy of the MPL was not distributed with this\n" "file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"); debugNetUDPPrintf("ready to have a lot of fun...\n"); /*library debugnet initialized*/ debugnet_initialized = 1; return debugnet_initialized; }
/* upnpDiscover() : * return a chained list of all devices found or NULL if * no devices was found. * It is up to the caller to free the chained list * delay is in millisecond (poll) */ struct UPNPDev * upnpDiscover(int delay, const char * multicastif, const char * minissdpdsock, int sameport, int ipv6, //unused in psp port int * error) { struct UPNPDev * tmp; struct UPNPDev * devlist = 0; int opt = 1; static const char MSearchMsgFmt[] = "M-SEARCH * HTTP/1.1\r\n" "HOST: %s:" XSTR(PORT) "\r\n" "ST: %s\r\n" "MAN: \"ssdp:discover\"\r\n" "MX: %u\r\n" "\r\n"; static const char * const deviceList[] = { #if 0 "urn:schemas-upnp-org:device:InternetGatewayDevice:2", "urn:schemas-upnp-org:service:WANIPConnection:2", #endif "urn:schemas-upnp-org:device:InternetGatewayDevice:1", "urn:schemas-upnp-org:service:WANIPConnection:1", "urn:schemas-upnp-org:service:WANPPPConnection:1", "upnp:rootdevice", 0 }; int deviceIndex = 0; char bufr[1536]; /* reception and emission buffer */ int sudp; int n; SceNetInetSockaddrIn sockudp_r; unsigned int mx; SceNetInetSockaddrIn sockudp_w; int linklocal = 1; if(error) *error = UPNPDISCOVER_UNKNOWN_ERROR; /* fallback to direct discovery */ //sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0); sudp = sceNetInetSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if(sudp < 0) { if(error) *error = UPNPDISCOVER_SOCKET_ERROR; return NULL; } /* reception */ memset(&sockudp_r, 0, sizeof(SceNetInetSockaddrIn)); SceNetInetSockaddrIn * p = (SceNetInetSockaddrIn *)&sockudp_r; p->sin_family = AF_INET; if(sameport) p->sin_port = sceNetHtons(PORT); p->sin_addr = INADDR_ANY; // Enable Port Re-use sceNetInetSetsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); sceNetInetSetsockopt(sudp, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)); /* Avant d'envoyer le paquet on bind pour recevoir la reponse */ if (sceNetInetBind(sudp, (const struct SceNetInetSockaddr *)&sockudp_r, sizeof(SceNetInetSockaddrIn)) != 0) { if(error) *error = UPNPDISCOVER_SOCKET_ERROR; sceNetInetClose(sudp); return NULL; } if(error) *error = UPNPDISCOVER_SUCCESS; /* Calculating maximum response time in seconds */ mx = ((unsigned int)delay) / 1000u; /* receiving SSDP response packet */ for(n = 0; deviceList[deviceIndex]; deviceIndex++) { if(n == 0) { /* sending the SSDP M-SEARCH packet */ n = snprintf(bufr, sizeof(bufr), MSearchMsgFmt, UPNP_MCAST_ADDR, deviceList[deviceIndex], mx); /* the following code is not using getaddrinfo */ /* emission */ memset(&sockudp_w, 0, sizeof(SceNetInetSockaddrIn)); SceNetInetSockaddrIn * p = (SceNetInetSockaddrIn *)&sockudp_w; p->sin_family = AF_INET; p->sin_port = sceNetHtons(PORT); sceNetInetInetAton(UPNP_MCAST_ADDR, &p->sin_addr); n = sceNetInetSendto(sudp, bufr, n, 0, (SceNetInetSockaddr *)&sockudp_w, sizeof(SceNetInetSockaddrIn)); if (n < 0) { if(error) *error = UPNPDISCOVER_SOCKET_ERROR; break; } } /* Waiting for SSDP REPLY packet to M-SEARCH */ n = receivedata(sudp, bufr, sizeof(bufr), delay); if (n < 0) { /* error */ if(error) *error = UPNPDISCOVER_SOCKET_ERROR; break; } else if (n == 0) { /* no data or Time Out */ if (devlist) { /* no more device type to look for... */ if(error) *error = UPNPDISCOVER_SUCCESS; break; } if(ipv6) { if(linklocal) { linklocal = 0; --deviceIndex; } else { linklocal = 1; } } } else { const char * descURL=NULL; int urlsize=0; const char * st=NULL; int stsize=0; /*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */ parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize); if(st&&descURL) { for(tmp=devlist; tmp; tmp = tmp->pNext) { if(memcmp(tmp->descURL, descURL, urlsize) == 0 && tmp->descURL[urlsize] == '\0' && memcmp(tmp->st, st, stsize) == 0 && tmp->st[stsize] == '\0') break; } /* at the exit of the loop above, tmp is null if * no duplicate device was found */ if(tmp) continue; tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize); if(!tmp) { /* memory allocation error */ if(error) *error = UPNPDISCOVER_MEMORY_ERROR; break; } tmp->pNext = devlist; tmp->descURL = tmp->buffer; tmp->st = tmp->buffer + 1 + urlsize; memcpy(tmp->buffer, descURL, urlsize); tmp->buffer[urlsize] = '\0'; memcpy(tmp->buffer + urlsize + 1, st, stsize); tmp->buffer[urlsize+1+stsize] = '\0'; devlist = tmp; } } } sceNetInetClose(sudp); return devlist; }
static int network_interface_up(struct sockaddr_in *target, int index, const char *ip_address, unsigned udp_port, int *s) { (void)index; #if defined(VITA) if (sceNetShowNetstat() == PSP2_NET_ERROR_ENOTINIT) { SceNetInitParam initparam; net_memory = malloc(NET_INIT_SIZE); initparam.memory = net_memory; initparam.size = NET_INIT_SIZE; initparam.flags = 0; sceNetInit(&initparam); } *s = sceNetSocket("RA_netlogger", PSP2_NET_AF_INET, PSP2_NET_SOCK_DGRAM, 0); target->sin_family = PSP2_NET_AF_INET; target->sin_port = sceNetHtons(udp_port); sceNetInetPton(PSP2_NET_AF_INET, ip_address, &target->sin_addr); #else #if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__) int ret = 0; int state, timeout_count = 10; ret = cellNetCtlInit(); if (ret < 0) return -1; for (;;) { ret = cellNetCtlGetState(&state); if (ret < 0) return -1; if (state == CELL_NET_CTL_STATE_IPObtained) break; retro_sleep(500); timeout_count--; if (index && timeout_count < 0) return 0; } #elif defined(GEKKO) char t[16]; if (if_config(t, NULL, NULL, TRUE) < 0) ret = -1; #endif if (ret < 0) return -1; *s = socket(AF_INET, SOCK_DGRAM, 0); target->sin_family = AF_INET; target->sin_port = htons(udp_port); #ifdef GEKKO target->sin_len = 8; #endif inet_pton(AF_INET, ip_address, &target->sin_addr); #endif return 0; }
/** * Initialize Networking Components for Adhocctl Emulator * @param adhoc_id Game Product Code * @param server_ip Server IP * @return 0 on success or... -1 */ int _initNetwork(const SceNetAdhocctlAdhocId * adhoc_id, const char * server_ip) { // WLAN Switch Check if(sceWlanGetSwitchState() == 1) { // Initialize Access Point Control if(sceNetApctlInit(0x1800, 0x30) == 0) { // Attempt Counter int attemptmax = 10; // Attempt Number int attempt = 0; // Attempt Connection Setup for(; attempt < attemptmax; attempt++) { // Start Connection if(sceNetApctlConnect(_hotspot) == 0) { // Wait for Connection int statebefore = 0; int state = 0; while(state != 4) { // Query State int getstate = sceNetApctlGetState(&state); // Log State Change if(statebefore != state) printk("New Connection State: %d\n", state); // Query Success if(getstate == 0 && state != 4) { // Wait for Retry sceKernelDelayThread(1000000); } // Query Error else break; // Save Before State statebefore = state; } // Connected if(state == 4) { // Create Friend Finder Socket int socket = sceNetInetSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Created Socket if(socket > 0) { // Enable Port Re-use sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &_one, sizeof(_one)); sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEPORT, &_one, sizeof(_one)); // Apply Receive Timeout Settings to Socket // uint32_t timeout = ADHOCCTL_RECV_TIMEOUT; // sceNetInetSetsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); // Server IP uint32_t ip = 0; // Initialize DNS Resolver if(sceNetResolverInit() == 0) { // Create DNS Resolver unsigned char rbuf[512]; int rid = 0; if(sceNetResolverCreate(&rid, rbuf, sizeof(rbuf)) == 0) { // Resolve Domain if(sceNetResolverStartNtoA(rid, server_ip, &ip, 500000, 2) != 0) { // Attempt IP Conversion sceNetInetInetAton(server_ip, &ip); } // Delete DNS Resolver sceNetResolverDelete(rid); } // Shutdown DNS Resolver sceNetResolverTerm(); } // Prepare Server Address SceNetInetSockaddrIn addr; addr.sin_len = sizeof(addr); addr.sin_family = AF_INET; addr.sin_addr = ip; addr.sin_port = sceNetHtons(ADHOCCTL_METAPORT); // Connect to Server if(sceNetInetConnect(socket, (SceNetInetSockaddr *)&addr, sizeof(addr)) == 0) { // Save Meta Socket _metasocket = socket; // Save Product Code _product_code = *adhoc_id; // Clear Event Handler memset(_event_handler, 0, sizeof(_event_handler[0]) * ADHOCCTL_MAX_HANDLER); memset(_event_args, 0, sizeof(_event_args[0]) * ADHOCCTL_MAX_HANDLER); // Clear Internal Control Status memset(&_parameter, 0, sizeof(_parameter)); // Read PSP Player Name sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME, (char *)_parameter.nickname.data, ADHOCCTL_NICKNAME_LEN); // Read Adhoc Channel sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_ADHOC_CHANNEL, &_parameter.channel); // Fake Channel Number 1 on Automatic Channel if(_parameter.channel == 0) _parameter.channel = 1; // Read PSP MAC Address sceWlanGetEtherAddr((void *)&_parameter.bssid.mac_addr.data); // Prepare Login Packet SceNetAdhocctlLoginPacketC2S packet; // Set Packet Opcode packet.base.opcode = OPCODE_LOGIN; // Set MAC Address packet.mac = _parameter.bssid.mac_addr; // Set Nickname packet.name = _parameter.nickname; // Set Game Product ID memcpy(packet.game.data, adhoc_id->data, ADHOCCTL_ADHOCID_LEN); // Acquire Network Layer Lock _acquireNetworkLock(); // Send Login Packet sceNetInetSend(_metasocket, &packet, sizeof(packet), INET_MSG_DONTWAIT); // Free Network Layer Lock _freeNetworkLock(); // Load UPNP Library _upnp_uid = sceKernelLoadModule("ms0:/kd/pspnet_miniupnc.prx", 0, NULL); // Start UPNP Library int status = 0; sceKernelStartModule(_upnp_uid, 0, NULL, &status, NULL); // Return Success return 0; } // Delete Socket sceNetInetClose(socket); } // Close Hotspot Connection sceNetApctlDisconnect(); } } } // Terminate Access Point Control sceNetApctlTerm(); } } // Generic Error return -1; }
/** * Adhoc Emulator PTP Active Socket Creator * @param saddr Local MAC (Unused) * @param sport Local Binding Port * @param daddr Target MAC * @param dport Target Port * @param bufsize Socket Buffer Size * @param rexmt_int Retransmit Interval (in Microseconds) * @param rexmt_cnt Retransmit Count * @param flag Bitflags (Unused) * @return Socket ID > 0 on success or... ADHOC_NOT_INITIALIZED, ADHOC_INVALID_ARG, ADHOC_INVALID_ADDR, ADHOC_INVALID_PORT */ int proNetAdhocPtpOpen(const SceNetEtherAddr * saddr, uint16_t sport, const SceNetEtherAddr * daddr, uint16_t dport, uint32_t bufsize, uint32_t rexmt_int, int rexmt_cnt, int flag) { // Library is initialized if(_init) { // Valid Addresses if(saddr != NULL && _IsLocalMAC(saddr) && daddr != NULL && !_isBroadcastMAC(daddr)) { // Random Port required if(sport == 0) { // Find unused Port while(sport == 0 || _IsPTPPortInUse(sport)) { // Generate Port Number sport = (uint16_t)_getRandomNumber(65535); } } // Valid Ports if(!_IsPTPPortInUse(sport) && dport != 0) { // Valid Arguments if(bufsize > 0 && rexmt_int > 0 && rexmt_cnt > 0) { // Create Infrastructure Socket int socket = sceNetInetSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Valid Socket produced if(socket > 0) { // Enable Port Re-use sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &_one, sizeof(_one)); sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEPORT, &_one, sizeof(_one)); // Binding Information for local Port SceNetInetSockaddrIn addr; addr.sin_len = sizeof(addr); addr.sin_family = AF_INET; addr.sin_addr = INADDR_ANY; addr.sin_port = sceNetHtons(sport); // Bound Socket to local Port if(sceNetInetBind(socket, (SceNetInetSockaddr *)&addr, sizeof(addr)) == 0) { // Allocate Memory SceNetAdhocPtpStat * internal = (SceNetAdhocPtpStat *)malloc(sizeof(SceNetAdhocPtpStat)); // Allocated Memory if(internal != NULL) { // Find Free Translator ID int i = 0; for(; i < 255; i++) if(_ptp[i] == NULL) break; // Found Free Translator ID if(i < 255) { // Clear Memory memset(internal, 0, sizeof(SceNetAdhocPtpStat)); // Copy Infrastructure Socket ID internal->id = socket; // Copy Address Information internal->laddr = *saddr; internal->paddr = *daddr; internal->lport = sport; internal->pport = dport; // Set Buffer Size internal->rcv_sb_cc = bufsize; // Link PTP Socket _ptp[i] = internal; // Add Port Forward to Router sceNetPortOpen("TCP", sport); // Return PTP Socket Pointer return i + 1; } // Free Memory free(internal); } } // Close Socket sceNetInetClose(socket); } } // Invalid Arguments return ADHOC_INVALID_ARG; } // Invalid Ports return ADHOC_INVALID_PORT; } // Invalid Addresses return ADHOC_INVALID_ADDR; } // Library is uninitialized return ADHOC_NOT_INITIALIZED; }
/** * Adhoc Emulator PDP Socket Creator * @param saddr Local MAC (Unused) * @param sport Local Binding Port * @param bufsize Socket Buffer Size * @param flag Bitflags (Unused) * @return Socket ID > 0 on success or... ADHOC_NOT_INITIALIZED, ADHOC_INVALID_ARG, ADHOC_SOCKET_ID_NOT_AVAIL, ADHOC_INVALID_ADDR, ADHOC_PORT_NOT_AVAIL, ADHOC_INVALID_PORT, ADHOC_PORT_IN_USE, NET_NO_SPACE */ int proNetAdhocPdpCreate(const SceNetEtherAddr * saddr, uint16_t sport, int bufsize, int flag) { // Library is initialized if(_init) { // Valid Arguments are supplied if(saddr != NULL && bufsize > 0) { // Valid MAC supplied if(_IsLocalMAC(saddr)) { // Random Port required if(sport == 0) { // Find unused Port while(sport == 0 || _IsPDPPortInUse(sport)) { // Generate Port Number sport = (uint16_t)_getRandomNumber(65535); } } // Unused Port supplied if(!_IsPDPPortInUse(sport)) { // Create Internet UDP Socket int socket = sceNetInetSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Valid Socket produced if(socket > 0) { // Enable Port Re-use sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &_one, sizeof(_one)); sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEPORT, &_one, sizeof(_one)); // Binding Information for local Port SceNetInetSockaddrIn addr; addr.sin_len = sizeof(addr); addr.sin_family = AF_INET; addr.sin_addr = INADDR_ANY; addr.sin_port = sceNetHtons(sport); // Bound Socket to local Port if(sceNetInetBind(socket, (SceNetInetSockaddr *)&addr, sizeof(addr)) == 0) { // Allocate Memory for Internal Data SceNetAdhocPdpStat * internal = (SceNetAdhocPdpStat *)malloc(sizeof(SceNetAdhocPdpStat)); // Allocated Memory if(internal != NULL) { // Clear Memory memset(internal, 0, sizeof(SceNetAdhocPdpStat)); // Find Free Translator Index int i = 0; for(; i < 255; i++) if(_pdp[i] == NULL) break; // Found Free Translator Index if(i < 255) { // Fill in Data internal->id = socket; internal->laddr = *saddr; internal->lport = sport; internal->rcv_sb_cc = bufsize; // Link Socket to Translator ID _pdp[i] = internal; // Forward Port on Router sceNetPortOpen("UDP", sport); // Success return i + 1; } // Free Memory for Internal Data free(internal); } } // Close Socket sceNetInetClose(socket); } // Default to No-Space Error return NET_NO_SPACE; } // Port is in use by another PDP Socket return ADHOC_PORT_IN_USE; } // Invalid MAC supplied return ADHOC_INVALID_ADDR; } // Invalid Arguments were supplied return ADHOC_INVALID_ARG; } // Library is uninitialized return ADHOC_NOT_INITIALIZED; }
void *ps4link_requests_thread(void * args) { int ret; struct sockaddr_in serveraddr; ps4link_requests_connected=0; /* Create server socket */ configuration->ps4link_requests_sock = sceNetSocket("requests_server_sock",AF_INET,SOCK_STREAM,0); if(ps4LinkGetValue(REQUESTS_SOCK)>=0) { debugNetPrintf(DEBUG,"[PS4LINK] Created ps4link_requests_sock: %d\n", ps4LinkGetValue(REQUESTS_SOCK)); } /* Fill the server's address */ serveraddr.sin_len = 16; serveraddr.sin_family = 2; serveraddr.sin_addr.s_addr = sceNetHtonl(INADDR_ANY); serveraddr.sin_port = sceNetHtons(ps4LinkGetValue(REQUESTS_PORT)); memset(serveraddr.sin_zero, 0, sizeof(serveraddr.sin_zero)); /* Bind the server's address to the socket */ ret = sceNetBind(ps4LinkGetValue(REQUESTS_SOCK), (struct sockaddr *)&serveraddr, sizeof(serveraddr)); if(ret<0) { debugNetPrintf(DEBUG,"[PS4LINK] sceNetBind error: 0x%08X\n", ret); sceNetSocketClose(ps4LinkGetValue(REQUESTS_SOCK)); return NULL; } debugNetPrintf(DEBUG,"[PS4LINK] bind to ps4link_requests_sock done\n"); /* Start listening */ ret = sceNetListen(ps4LinkGetValue(REQUESTS_SOCK), 5); if(ret<0) { debugNetPrintf(DEBUG,"[PS4LINK] sceNetListen error: 0x%08X\n", ret); sceNetSocketClose(ps4LinkGetValue(REQUESTS_SOCK)); return NULL; } debugNetPrintf(DEBUG,"[PS4LINK] Ready for connection %d\n", ps4LinkGetValue(FILEIO_ACTIVE)); while(ps4LinkGetValue(FILEIO_ACTIVE)) { debugNetPrintf(DEBUG,"[PS4LINK] Waiting for connection\n", ret); /* Accept clients */ struct sockaddr_in clientaddr; int client_sock; unsigned int addrlen = sizeof(clientaddr); client_sock = sceNetAccept(ps4LinkGetValue(REQUESTS_SOCK), (struct sockaddr *)&clientaddr, &addrlen); if (client_sock < 0) { debugNetPrintf(DEBUG,"[PS4LINK] sceNetAccept error (0x%08X)\n", client_sock); continue; } /* Get the client's IP address */ remote_pc_addr = clientaddr.sin_addr.s_addr; char remote_ip[16]; sceNetInetNtop(AF_INET,&clientaddr.sin_addr.s_addr,remote_ip,sizeof(remote_ip)); debugNetPrintf(DEBUG,"[PS4LINK] Client connected from %s port: %i\n ",remote_ip, clientaddr.sin_port); if (ps4LinkGetValue(FILEIO_SOCK) > 0) { debugNetPrintf(DEBUG,"[PS4LINK] Client reconnected\n"); // sceNetSocketClose(ps4LinkGetValue(FILEIO_SOCK)); } configuration->ps4link_fileio_sock = client_sock; ps4link_requests_connected=1; debugNetPrintf(DEBUG,"[PS4LINK] sock ps4link_fileio set %d connected %d\n",ps4LinkGetValue(FILEIO_SOCK),ps4link_requests_connected); } debugNetPrintf(DEBUG,"[PS4LINK] exit thread requests\n"); if(ps4LinkGetValue(FILEIO_SOCK)) { debugNetPrintf(DEBUG,"[PS4LINK] closing fileio_sock\n"); sceNetSocketClose(ps4LinkGetValue(FILEIO_SOCK)); configuration->ps4link_fileio_sock=-1; } if(ps4LinkGetValue(REQUESTS_SOCK)) { debugNetPrintf(DEBUG,"[PS4LINK] closing server_request_sock\n"); sceNetSocketClose(ps4LinkGetValue(REQUESTS_SOCK)); configuration->ps4link_requests_sock=-1; } ps4link_requests_connected=0; //sceKernelExitDeleteThread(0); return NULL; }
int ps4LinkRead(int fd, void *data, size_t size) { int readbytes; int nbytes; int i; ps4link_pkt_read_req *readcmd; ps4link_pkt_read_rly *readrly; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } readcmd = (ps4link_pkt_read_req *)&send_packet[0]; readrly = (ps4link_pkt_read_rly *)&recv_packet[0]; readbytes = 0; readcmd->cmd = sceNetHtonl(PS4LINK_READ_CMD); readcmd->len = sceNetHtons((unsigned short)sizeof(ps4link_pkt_read_req)); readcmd->fd = sceNetHtonl(fd); readbytes = 0; /*if (size < 0) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_read_file: illegal req!! (whish to read < 0 bytes!)\n"); return -1; }*/ readcmd->nbytes = sceNetHtonl(size); i = ps4link_send(ps4LinkGetValue(FILEIO_SOCK), readcmd, sizeof(ps4link_pkt_read_req), MSG_DONTWAIT); if (i<0) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_file: ps4link_read_file: send failed (%d)\n", i); return -1; } if(!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), (char *)readrly, sizeof(ps4link_pkt_read_rly), PS4LINK_READ_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_read_file: " "did not receive PS4LINK_READ_RLY\n"); return -1; } nbytes = sceNetNtohl(readrly->nbytes); debugNetPrintf(DEBUG,"[PS4LINK] ps4link_read_file: Reply said there's %d bytes to read " "(wanted %d)\n", nbytes, size); // Now read the actual file data divide in chunk int numread=nbytes/PACKET_MAXSIZE; int lastread=nbytes%PACKET_MAXSIZE; int j; for(j=0;j<numread;j++) { if(j<numread-1) { i = ps4link_recv_bytes(ps4LinkGetValue(FILEIO_SOCK), data+j*PACKET_MAXSIZE, PACKET_MAXSIZE); } else { i = ps4link_recv_bytes(ps4LinkGetValue(FILEIO_SOCK), data+j*PACKET_MAXSIZE, PACKET_MAXSIZE+lastread); } if (i < 0) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_read_file, data read error\n"); return -1; } debugNetPrintf(DEBUG,"[PS4LINK] ps4link_read_file: chunk %d readed %d\n", j,i); } return nbytes; }
int psp2link_commands_thread(SceSize args, void *argp) { struct SceNetSockaddrIn serveraddr; struct SceNetSockaddrIn remote_addr; int ret; int len; unsigned int addrlen; unsigned int cmd; psp2link_pkt_hdr *header; debugNetPrintf(DEBUG,"[PSP2LINK] Command Thread Started.\n" ); configuration->psp2link_commands_sock = sceNetSocket("commands_server_sock",SCE_NET_AF_INET, SCE_NET_SOCK_DGRAM, SCE_NET_IPPROTO_UDP); if (psp2LinkGetValue(COMMANDS_SOCK) >=0) { debugNetPrintf(DEBUG,"[PSP2LINK] Created psp2link_commands_sock: %d\n", psp2LinkGetValue(COMMANDS_SOCK)); } else { debugNetPrintf(DEBUG,"[PSP2LINK] Error creating socket psp2link_commands_sock 0x%08X\n", psp2LinkGetValue(COMMANDS_SOCK)); psp2LinkFinish(); return -1; } /* Fill the server's address */ memset(&serveraddr, 0, sizeof serveraddr); serveraddr.sin_family = SCE_NET_AF_INET; serveraddr.sin_addr.s_addr = sceNetHtonl(SCE_NET_INADDR_ANY); serveraddr.sin_port = sceNetHtons(psp2LinkGetValue(COMMANDS_PORT)); ret = sceNetBind(psp2LinkGetValue(COMMANDS_SOCK), (SceNetSockaddr *)&serveraddr, sizeof(serveraddr)); if (ret < 0) { debugNetPrintf(DEBUG,"[PSP2LINK] command listener sceNetBind error: 0x%08X\n", ret); sceNetSocketClose(psp2LinkGetValue(COMMANDS_SOCK)); psp2LinkFinish(); return -1; } // Do tha thing debugNetPrintf(DEBUG,"[PSP2LINK] Command listener waiting for commands...\n"); while(psp2LinkGetValue(CMDSIO_ACTIVE)) { addrlen = sizeof(remote_addr); //wait for new command len = sceNetRecvfrom(psp2LinkGetValue(COMMANDS_SOCK), &recvbuf[0], BUF_SIZE, 0, (struct SceNetSockaddr *)&remote_addr,&addrlen); debugNetPrintf(DEBUG,"[PSP2LINK] commands listener received packet size (%d)\n", len); if (len < 0) { debugNetPrintf(DEBUG,"[PSP2LINK] commands listener recvfrom size error (%d)\n", len); continue; } if (len < sizeof(psp2link_pkt_hdr)) { debugNetPrintf(DEBUG,"[PSP2LINK] commands listener recvfrom header size error (%d)\n", len); continue; } header = (psp2link_pkt_hdr *)recvbuf; cmd = sceNetHtonl(header->cmd); switch (cmd) { case PSP2LINK_EXECELF_CMD: psp2LinkCmdExecElf((psp2link_pkt_exec_cmd *)recvbuf); break; case PSP2LINK_EXECSPRX_CMD: psp2LinkCmdExecSprx((psp2link_pkt_exec_cmd *)recvbuf); break; case PSP2LINK_EXIT_CMD: psp2LinkCmdExit((psp2link_pkt_exec_cmd *)recvbuf); break; default: debugNetPrintf(DEBUG,"[PSP2LINK] Unknown command received\n"); break; } debugNetPrintf(DEBUG,"[PSP2LINK] commands listener waiting for next command\n"); } debugNetPrintf(DEBUG,"[PSP2LINK] exit commands listener thread\n"); if(psp2LinkGetValue(COMMANDS_SOCK)) { debugNetPrintf(DEBUG,"[PSP2LINK] closing server_commands_sock\n"); sceNetSocketClose(psp2LinkGetValue(COMMANDS_SOCK)); configuration->psp2link_commands_sock=-1; } sceKernelExitDeleteThread(0); return 0; }
int ps4LinkWrite(int fd, const void *data, size_t size) { ps4link_pkt_write_req *writecmd; ps4link_pkt_file_rly *writerly; int hlen; int writtenbytes; int nbytes; int retval; if (ps4LinkGetValue(FILEIO_SOCK) < 0) { return -1; } debugNetPrintf(DEBUG,"[PS4LINK] file write req (fd: %d)\n", fd); writecmd = (ps4link_pkt_write_req *)&send_packet[0]; writerly = (ps4link_pkt_file_rly *)&recv_packet[0]; hlen = (unsigned short)sizeof(ps4link_pkt_write_req); writecmd->cmd = sceNetHtonl(PS4LINK_WRITE_CMD); writecmd->len = sceNetHtons(hlen); writecmd->fd = sceNetHtonl(fd); // Divide the write request writtenbytes = 0; while (writtenbytes < size) { if ((size - writtenbytes) > PS4LINK_MAX_WRITE_SEGMENT) { // Need to split in several read reqs nbytes = PS4LINK_MAX_READ_SEGMENT; } else { nbytes = size - writtenbytes; } writecmd->nbytes = sceNetHtonl(nbytes); #ifdef ZEROCOPY /* Send the packet header. */ if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), writecmd, hlen, MSG_DONTWAIT) < 0) return -1; /* Send the write() data. */ if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), &data[writtenbytes], nbytes, MSG_DONTWAIT) < 0) return -1; #else // Copy data to the acutal packet memcpy(&send_packet[sizeof(ps4link_pkt_write_req)], &data[writtenbytes],nbytes); if (ps4link_send(ps4LinkGetValue(FILEIO_SOCK), writecmd, hlen + nbytes, MSG_DONTWAIT) < 0) return -1; #endif // Get reply if(!ps4link_accept_pkt(ps4LinkGetValue(FILEIO_SOCK), (char *)writerly, sizeof(ps4link_pkt_file_rly), PS4LINK_WRITE_RLY)) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_write_file: " "did not receive PS4LINK_WRITE_RLY\n"); return -1; } retval = sceNetNtohl(writerly->retval); debugNetPrintf(DEBUG,"[PS4LINK] wrote %d bytes (asked for %d)\n", retval, nbytes); if (retval < 0) { // Error debugNetPrintf(DEBUG,"[PS4LINK] ps4link_write_file: received error on write req (%d)\n",retval); return retval; } writtenbytes += retval; if (retval < nbytes) { // EOF? break; } } return writtenbytes; }
/** * Adhoc Emulator PDP Send Call * @param id Socket File Descriptor * @param daddr Target MAC Address * @param dport Target Port * @param data Data Payload * @param len Payload Length * @param timeout Send Timeout * @param flag Nonblocking Flag * @return 0 on success or... ADHOC_INVALID_ARG, ADHOC_NOT_INITIALIZED, ADHOC_INVALID_SOCKET_ID, ADHOC_SOCKET_DELETED, ADHOC_INVALID_ADDR, ADHOC_INVALID_PORT, ADHOC_INVALID_DATALEN, ADHOC_SOCKET_ALERTED, ADHOC_TIMEOUT, ADHOC_THREAD_ABORTED, ADHOC_WOULD_BLOCK, NET_NO_SPACE, NET_INTERNAL */ int proNetAdhocPdpSend(int id, const SceNetEtherAddr * daddr, uint16_t dport, const void * data, int len, uint32_t timeout, int flag) { // Library is initialized if(_init) { // Valid Port if(dport != 0) { // Valid Data Length if(len > 0) { // Valid Socket ID if(id > 0 && id <= 255 && _pdp[id - 1] != NULL) { // Cast Socket SceNetAdhocPdpStat * socket = _pdp[id - 1]; // Valid Data Buffer if(data != NULL) { // Valid Destination Address if(daddr != NULL) { // Log Destination #ifdef DEBUG printk("Attempting PDP Send to %02X:%02X:%02X:%02X:%02X:%02X on Port %u\n", daddr->data[0], daddr->data[1], daddr->data[2], daddr->data[3], daddr->data[4], daddr->data[5], dport); #endif // Schedule Timeout Removal if(flag) timeout = 0; // Apply Send Timeout Settings to Socket sceNetInetSetsockopt(socket->id, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)); // Single Target if(!_isBroadcastMAC(daddr)) { // Fill in Target Structure SceNetInetSockaddrIn target; target.sin_family = AF_INET; target.sin_port = sceNetHtons(dport); // Get Peer IP if(_resolveMAC((SceNetEtherAddr *)daddr, &target.sin_addr) == 0) { // Acquire Network Lock _acquireNetworkLock(); // Send Data int sent = sceNetInetSendto(socket->id, data, len, ((flag != 0) ? (INET_MSG_DONTWAIT) : (0)), (SceNetInetSockaddr *)&target, sizeof(target)); // Free Network Lock _freeNetworkLock(); // Sent Data if(sent == len) { // Success return 0; } // Blocking Situation if(flag) return ADHOC_WOULD_BLOCK; // Timeout return ADHOC_TIMEOUT; } } // Broadcast Target else { // Acquire Network Lock _acquireNetworkLock(); #ifdef BROADCAST_TO_LOCALHOST // Get Local IP Address union SceNetApctlInfo info; if(sceNetApctlGetInfo(PSP_NET_APCTL_INFO_IP, &info) == 0) { // Fill in Target Structure SceNetInetSockaddrIn target; target.sin_family = AF_INET; sceNetInetInetAton(info.ip, &target.sin_addr); target.sin_port = sceNetHtons(dport); // Send Data sceNetInetSendto(socket->id, data, len, ((flag != 0) ? (INET_MSG_DONTWAIT) : (0)), (SceNetInetSockaddr *)&target, sizeof(target)); } #endif // Acquire Peer Lock _acquirePeerLock(); // Iterate Peers SceNetAdhocctlPeerInfo * peer = _getInternalPeerList(); for(; peer != NULL; peer = peer->next) { // Fill in Target Structure SceNetInetSockaddrIn target; target.sin_family = AF_INET; target.sin_addr = peer->ip_addr; target.sin_port = sceNetHtons(dport); // Send Data sceNetInetSendto(socket->id, data, len, ((flag != 0) ? (INET_MSG_DONTWAIT) : (0)), (SceNetInetSockaddr *)&target, sizeof(target)); } // Free Peer Lock _freePeerLock(); // Free Network Lock _freeNetworkLock(); // Broadcast never fails! return 0; } } // Invalid Destination Address return ADHOC_INVALID_ADDR; } // Invalid Argument return ADHOC_INVALID_ARG; } // Invalid Socket ID return ADHOC_INVALID_SOCKET_ID; } // Invalid Data Length return ADHOC_INVALID_DATALEN; } // Invalid Destination Port return ADHOC_INVALID_PORT; } // Library is uninitialized return ADHOC_NOT_INITIALIZED; }
static int server_thread(SceSize args, void *argp) { int ret; UNUSED(ret); SceNetSockaddrIn serveraddr; DEBUG("Server thread started!\n"); /* Create server socket */ server_sockfd = sceNetSocket("FTPVita_server_sock", PSP2_NET_AF_INET, PSP2_NET_SOCK_STREAM, 0); DEBUG("Server socket fd: %d\n", server_sockfd); /* Fill the server's address */ serveraddr.sin_family = PSP2_NET_AF_INET; serveraddr.sin_addr.s_addr = sceNetHtonl(PSP2_NET_INADDR_ANY); serveraddr.sin_port = sceNetHtons(FTP_PORT); /* Bind the server's address to the socket */ ret = sceNetBind(server_sockfd, (SceNetSockaddr *)&serveraddr, sizeof(serveraddr)); DEBUG("sceNetBind(): 0x%08X\n", ret); /* Start listening */ ret = sceNetListen(server_sockfd, 128); DEBUG("sceNetListen(): 0x%08X\n", ret); while (1) { /* Accept clients */ SceNetSockaddrIn clientaddr; int client_sockfd; unsigned int addrlen = sizeof(clientaddr); DEBUG("Waiting for incoming connections...\n"); client_sockfd = sceNetAccept(server_sockfd, (SceNetSockaddr *)&clientaddr, &addrlen); if (client_sockfd >= 0) { DEBUG("New connection, client fd: 0x%08X\n", client_sockfd); /* Get the client's IP address */ char remote_ip[16]; sceNetInetNtop(PSP2_NET_AF_INET, &clientaddr.sin_addr.s_addr, remote_ip, sizeof(remote_ip)); INFO("Client %i connected, IP: %s port: %i\n", number_clients, remote_ip, clientaddr.sin_port); /* Create a new thread for the client */ char client_thread_name[64]; sprintf(client_thread_name, "FTPVita_client_%i_thread", number_clients); SceUID client_thid = sceKernelCreateThread( client_thread_name, client_thread, 0x10000100, 0x10000, 0, 0, NULL); DEBUG("Client %i thread UID: 0x%08X\n", number_clients, client_thid); /* Allocate the ClientInfo struct for the new client */ ClientInfo *client = malloc(sizeof(*client)); client->num = number_clients; client->thid = client_thid; client->ctrl_sockfd = client_sockfd; client->data_con_type = FTP_DATA_CONNECTION_NONE; sprintf(client->cur_path, "%s%s", FTP_DEFAULT_PREFIX, FTP_DEFAULT_PATH); memcpy(&client->addr, &clientaddr, sizeof(client->addr)); /* Add the new client to the client list */ client_list_add(client); /* Start the client thread */ sceKernelStartThread(client_thid, sizeof(*client), client); number_clients++; } else { /* if sceNetAccept returns < 0, it means that the listening * socket has been closed, this means that we want to * finish the server thread */ DEBUG("Server socket closed, 0x%08X\n", client_sockfd); break; } } DEBUG("Server thread exiting!\n"); sceKernelExitDeleteThread(0); return 0; }