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); }
static void client_close_data_connection(ClientInfo *client) { sceNetSocketClose(client->data_sockfd); /* In passive mode we have to close the client pasv socket too */ if (client->data_con_type == FTP_DATA_CONNECTION_PASSIVE) { sceNetSocketClose(client->pasv_sockfd); } client->data_con_type = FTP_DATA_CONNECTION_NONE; }
void ftp_fini() { if (ftp_initialized) { /* In order to "stop" the blocking sceNetAccept, * we have to close the server socket; this way * the accept call will return an error */ sceNetSocketClose(server_sockfd); /* Wait until the server threads ends */ sceKernelWaitThreadEnd(server_thid, NULL, NULL); /* To close the clients we have to do the same: * we have to iterate over all the clients * and shutdown their sockets */ client_list_thread_end(); /* Delete the client list mutex */ sceKernelDeleteMutex(client_list_mtx); client_list = NULL; sceNetCtlTerm(); sceNetTerm(); if (net_memory) { free(net_memory); net_memory = NULL; } ftp_initialized = 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; }
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 ps4link_close_socket(void) { int ret; ret = sceNetSocketClose(ps4LinkGetValue(FILEIO_SOCK)); if (ret < 0) { debugNetPrintf(DEBUG,"[PS4LINK] close ps4link_fileio_sock returned error 0x%08X\n", ret); } configuration->ps4link_fileio_sock = -1; }
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 console_fini() { if (console_initialzed) { sceKernelDeleteMutex(console_mtx); sceNetSocketClose(sock); sceNetTerm(); if (net_memory) { free(net_memory); net_memory = NULL; } } }
int socket_close(int fd) { #if defined(_WIN32) && !defined(_XBOX360) /* WinSock has headers from the stone age. */ return closesocket(fd); #elif defined(__CELLOS_LV2__) || defined(WIIU) return socketclose(fd); #elif defined(VITA) return sceNetSocketClose(fd); #else return close(fd); #endif }
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 int network_interface_down(struct sockaddr_in *target, int *s) { int ret = 0; #if defined(_WIN32) && !defined(_XBOX360) /* WinSock has headers from the stone age. */ ret = closesocket(*s); #elif defined(__CELLOS_LV2__) ret = socketclose(*s); #elif defined(VITA) if (net_memory) free(net_memory); sceNetSocketClose(*s); #else ret = close(*s); #endif #if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__) cellNetCtlTerm(); #elif defined(GEKKO) && !defined(HW_DOL) net_deinit(); #endif return ret; }
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; }
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; }
static int client_thread(SceSize args, void *argp) { char cmd[16]; cmd_dispatch_func dispatch_func; ClientInfo *client = (ClientInfo *)argp; DEBUG("Client thread %i started!\n", client->num); client_send_ctrl_msg(client, "220 FTPVita Server ready.\n"); while (1) { memset(client->recv_buffer, 0, sizeof(client->recv_buffer)); client->n_recv = sceNetRecv(client->ctrl_sockfd, client->recv_buffer, sizeof(client->recv_buffer), 0); if (client->n_recv > 0) { DEBUG("Received %i bytes from client number %i:\n", client->n_recv, client->num); INFO("\t%i> %s", client->num, client->recv_buffer); /* The command are the first chars until the first space */ sscanf(client->recv_buffer, "%s", cmd); /* Wait 1 ms before sending any data */ sceKernelDelayThread(1*1000); if ((dispatch_func = get_dispatch_func(cmd))) { dispatch_func(client); } else { client_send_ctrl_msg(client, "502 Sorry, command not implemented. :(\n"); } } else if (client->n_recv == 0) { /* Value 0 means connection closed by the remote peer */ INFO("Connection closed by the client %i.\n", client->num); /* Delete itself from the client list */ client_list_delete(client); break; } else if (client->n_recv == PSP2_NET_ERROR_ECANCELED) { /* PSP2_NET_ERROR_ECANCELED means socket shutdown */ DEBUG("Client %i socket shutdown\n", client->num); break; } else { /* Other errors */ INFO("Socket error client %i.\n", client->num); client_list_delete(client); break; } } /* Close the client's socket */ sceNetSocketClose(client->ctrl_sockfd); /* If there's an open data connection, close it */ if (client->data_con_type != FTP_DATA_CONNECTION_NONE) { sceNetSocketClose(client->data_sockfd); if (client->data_con_type == FTP_DATA_CONNECTION_PASSIVE) { sceNetSocketClose(client->pasv_sockfd); } } DEBUG("Client thread %i exiting!\n", client->num); /* Temporary newlib thread malloc bug fix */ // free(client); sceKernelExitDeleteThread(0); return 0; }
void blob_transfer_close() { sceNetSocketClose(blobs_sockfd); }