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(); 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) { // 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; }
void _start(void) { // Pass address of a syscall gadget in rcx register f rcx asm("rcx"); directSyscall = rcx; // Load modules int libNet = 14; // Resolve functions int (*sceNetSocket)(const char *, int, int, int); int (*sceNetSocketClose)(int); int (*sceNetBind)(int, struct sockaddr_in *, int); int (*sceNetListen)(int, int); int (*sceNetAccept)(int, struct sockaddr_in *, int *); int (*sceNetRecv)(int, void *, size_t, int); STACK_RESOLVE(libNet, sceNetSocket); STACK_RESOLVE(libNet, sceNetSocketClose); STACK_RESOLVE(libNet, sceNetBind); STACK_RESOLVE(libNet, sceNetListen); STACK_RESOLVE(libNet, sceNetAccept); STACK_RESOLVE(libNet, sceNetRecv); // Fetch code char socketName[] = "loader"; struct sockaddr_in serverAddress; serverAddress.sin_family = htons(AF_INET); serverAddress.sin_addr.s_addr = IN_ADDR_ANY; serverAddress.sin_port = htons(9023); serverAddress.sin_zero[0] = 0; serverAddress.sin_zero[1] = 0; serverAddress.sin_zero[2] = 0; serverAddress.sin_zero[3] = 0; serverAddress.sin_zero[4] = 0; serverAddress.sin_zero[5] = 0; serverAddress.sin_zero[6] = 0; serverAddress.sin_zero[7] = 0; int server = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0); sceNetBind(server, &serverAddress, sizeof(serverAddress)); sceNetListen(server, 10); int client = sceNetAccept(server, NULL, NULL); void *write = DATA; int length; while((length = sceNetRecv(client, write, 4096, 0)) > 0) { write += length; } sceNetSocketClose(server); sceNetSocketClose(client); }
/*-------------------------------------------------------------------------*\ * Creates and sets up a socket \*-------------------------------------------------------------------------*/ int socket_create(p_socket ps, int domain, int type, int protocol) { #if PE_PLAT_IS_PSVITA *ps = sceNetSocket("scoket_name", domain, type, protocol); #else *ps = socket(domain, type, protocol); #endif if (*ps != SOCKET_INVALID) return IO_DONE; else return peusock_errno; }
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; }
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; }
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 _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; }
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; }
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; }
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 socket_create( const char *name, enum socket_domain domain_type, enum socket_type socket_type, enum socket_protocol protocol_type) { int type = 0; int protocol = 0; int domain = domain_get(domain_type); #ifdef VITA switch (socket_type) { case SOCKET_TYPE_DATAGRAM: type = SCE_NET_SOCK_DGRAM; break; case SOCKET_TYPE_STREAM: type = SCE_NET_SOCK_STREAM; break; case SOCKET_TYPE_SEQPACKET: /* TODO/FIXME - implement */ break; } switch (protocol_type) { case SOCKET_PROTOCOL_NONE: protocol = 0; break; case SOCKET_PROTOCOL_TCP: protocol = SCE_NET_IPPROTO_TCP; break; case SOCKET_PROTOCOL_UDP: protocol = SCE_NET_IPPROTO_UDP; break; } return sceNetSocket(name, domain, type, protocol); #else switch (socket_type) { case SOCKET_TYPE_DATAGRAM: type = SOCK_DGRAM; break; case SOCKET_TYPE_STREAM: type = SOCK_STREAM; break; case SOCKET_TYPE_SEQPACKET: /* TODO/FIXME - implement */ break; } switch (protocol_type) { case SOCKET_PROTOCOL_NONE: protocol = 0; break; case SOCKET_PROTOCOL_TCP: protocol = IPPROTO_TCP; break; case SOCKET_PROTOCOL_UDP: protocol = IPPROTO_UDP; break; } return socket(domain, type, protocol); #endif }
/** * 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; }
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; }