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 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 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 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); }
int ps4link_request_open(void *packet) { struct { unsigned int number; unsigned short length; int flags; char pathname[256]; } PACKED *request = packet; int result = -1; struct stat stats; // Fix the arguments. fix_pathname(request->pathname); if(request->pathname[0]==0) { return ps4link_response_open(-1); } request->flags = fix_flags(ntohl(request->flags)); debugNetPrintf(DEBUG,"Opening %s flags %x\n",request->pathname,request->flags); if(((stat(request->pathname, &stats) == 0) && (!S_ISDIR(stats.st_mode))) || (request->flags & O_CREAT)) { // Perform the request. #if defined (__CYGWIN__) || defined (__MINGW32__) result = open(request->pathname, request->flags | O_BINARY, 0644); #else result = open(request->pathname, request->flags, 0644); #endif } // Send the response. debugNetPrintf(DEBUG,"Open return %d\n",result); return ps4link_response_open(result); }
int cli_verbose() { if (VERBOSE) { debugNetPrintf(DEBUG," Verbose off\n"); VERBOSE = 0; } else { VERBOSE = 1; debugNetPrintf(DEBUG," Verbose on\n"); } return 0; }
int cli_status() { debugNetPrintf(INFO," TCP srv fd = %d\n", request_socket); debugNetPrintf(INFO," UDP log fd = %d\n", console_socket); debugNetPrintf(INFO," PS4SH cmd fd = %d\n", ps4sh_socket); if ( log_to_file ) debugNetPrintf(INFO," Logging to file\n"); else debugNetPrintf(INFO," Logging to stdout\n"); if ( VERBOSE ) debugNetPrintf(INFO," Verbose mode is on\n"); else debugNetPrintf(INFO," Verbose mode is off\n"); if(ps4link_debug()) { debugNetPrintf(INFO," Debug is on\n"); } else { debugNetPrintf(INFO," Debug is off\n"); } /* if ( DUMPSCREEN ) { printf(" Exception dumps to screen\n"); } else { printf(" Exception dumps to console\n"); }*/ return 0; }
int main() { int ret; ret=debugNetInit(ip_server,port_server,DEBUG); debugNetPrintf(DEBUG,"Test debug level %d\n",ret); debugNetPrintf(ERROR,"Test error level %d\n",ret); debugNetPrintf(INFO,"Test info level %d\n",ret); debugNetFinish(); sceKernelExitProcess(0); return 0; }
void psp2LinkCommandsAbort() { int ret; if(psp2LinkGetValue(COMMANDS_SOCK)) { debugNetPrintf(DEBUG,"[PSP2LINK] Aborting psp2link_commands_sock\n"); ret = sceNetSocketAbort(psp2LinkGetValue(COMMANDS_SOCK),1); if (ret < 0) { debugNetPrintf(DEBUG,"[PSP2LINK] abort psp2link_commands_sock returned error 0x%08X\n", ret); } } }
void ps4LinkRequestsAbort() { int ret; if(ps4LinkGetValue(REQUESTS_SOCK)) { debugNetPrintf(DEBUG,"[PS4LINK] Aborting ps4link_requests_sock\n"); ret = sceNetSocketAbort(ps4LinkGetValue(REQUESTS_SOCK),1); if (ret < 0) { debugNetPrintf(DEBUG,"[PS4LINK] abort ps4link_requests_sock returned error 0x%08X\n", ret); } } }
void psp2LinkCmdExit(psp2link_pkt_exec_cmd *pkg) { debugNetPrintf(DEBUG,"[PSP2LINK] Received command exit. Closing PSP2Link...\n"); psp2LinkFinish(); }
int network_connect(char *hostname, int port, int type) { int sock = -1; struct sockaddr_in sockaddr; // Populate the sockaddr structure. sockaddr.sin_family = AF_INET; sockaddr.sin_port = htons(port); sockaddr.sin_addr = *(struct in_addr *)gethostbyname(hostname)->h_addr; // Open the socket. sock = socket(AF_INET, type, 0); if (sock < 0) { return -1; } //int ret; // Connect the socket. //ret=connect(sock, (struct sockaddr *)&sockaddr, sizeof(struct sockaddr)); //debugNetPrintf(INFO,("connect return %d\n",ret); //while(ret<0) //{ // ret=connect(sock, (struct sockaddr *)&sockaddr, sizeof(struct sockaddr)); // sleep(1); // debugNetPrintf(INFO,("waiting psp2 connection...\n"); //} if (connect(sock, (struct sockaddr *)&sockaddr, sizeof(struct sockaddr)) < 0) { debugNetPrintf(DEBUG,"error connecting\n");return -2; } // Return the socket. return sock; }
void psp2LinkCmdExecElf(psp2link_pkt_exec_cmd *pkg) { char *buf;//buffer for elf file int fd; //descriptor to manage file from host0 int filesize;//variable to control file size int numread;//control read debugNetPrintf(DEBUG,"[PSP2LINK] Received command execelf argc=%x argv=%s\n",sceNetNtohl(pkg->argc),pkg->argv); //we open file in read only from host0 ps4sh include the full path with host0:/....... fd=psp2LinkIoOpen(pkg->argv,SCE_O_RDONLY,0); //If we can't open file from host0 print the error and return if(fd<0) { debugNetPrintf(DEBUG,"[PSP2LINK] psp2LinkOpen returned error %d\n",fd); return; } //Seek to final to get file size filesize=psp2LinkIoLseek(fd,0,SCE_SEEK_END); //If we get an error print it and return if(filesize<0) { debugNetPrintf(DEBUG,"[PSP2LINK] psp2LinkSeek returned error %d\n",fd); psp2LinkIoClose(fd); return; } //Seek back to start psp2LinkIoLseek(fd,0,SCE_SEEK_SET); //Reserve memory for read buffer buf=malloc(filesize); //Read filsesize bytes to buf numread=psp2LinkIoRead(fd,buf,filesize); //if we don't get filesize bytes we are in trouble if(numread!=filesize) { debugNetPrintf(DEBUG,"[PSP2LINK] ps4LinkRead returned error %d\n",numread); psp2LinkIoClose(fd); return; } //Close file psp2LinkIoClose(fd); //buffer with elf it's ready time to call load elf stuff.... return; }
int cli_execsprx(char *arg) { int ret; char *newarg; unsigned int argc, argvlen; unsigned char argv[MAX_PATH]; argc = fix_cmd_arg(argv, arg, &argvlen); debugNetPrintf(DEBUG,"[PS4SH] argc=%d argv=%s\n",argc,argv); ps4link_command_exesprx(argc,argv,argvlen); 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 cli_exitps4(char *arg) { int ret; char *newarg; unsigned int argc, argvlen; unsigned char argv[MAX_PATH]; argc = fix_cmd_arg(argv, arg, &argvlen); debugNetPrintf(DEBUG,"argc=%d argv=%s\n",argc,argv); ps4link_command_exit(argc,argv,argvlen); doloop=0; return 0; }
int ps4link_request_lseek(void *packet) { struct { unsigned int number; unsigned short length; int fd; int offset; int whence; } PACKED *request = packet; int result = -1; // Perform the request. result = lseek(ntohl(request->fd), ntohl(request->offset), ntohl(request->whence)); debugNetPrintf(DEBUG,"%d result of lseek %d offset %d whence\n",result,ntohl(request->offset), ntohl(request->whence)); // Send the response. return ps4link_response_lseek(result); }
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(int argc, char *argv[]) { int ret; uintptr_t intptr=0; sscanf(argv[1],"%p",&intptr); debugNetConfiguration *conf=(debugNetConfiguration *)intptr; ret=debugNetInitWithConf(conf); sleep(3); debugNetPrintf(DEBUG,"[SAMPLE] %d elfname=%s ps4linkconf=%s %p %d\n",argc,argv[0],argv[1],conf,conf->SocketFD); debugNetFinish(); while(1); }
static inline int ps4link_send(int sock, void *buf, int len, int flag) { int ret; ret = sceNetSend(sock, buf, len, flag); if (ret < 0) { debugNetPrintf(DEBUG,"[PS4LINK] sceNetSend error %d\n", ret); ps4link_close_socket(); return -1; } else { return ret; } }
int ps4link_request_close(void *packet) { struct { unsigned int number; unsigned short length; int fd; } PACKED *request = packet; int result = -1; // Perform the request. result = close(ntohl(request->fd)); debugNetPrintf(DEBUG,"close return %d",result); // Send the response. return ps4link_response_close(result); }
int cli_log(char *arg) { trim(arg); if ( (strcmp(arg, "stdout"))==0 || !*arg) { if ( log_to_file ) { if (VERBOSE) debugNetPrintf(DEBUG,"Closing log file fd\n"); close(log_f_fd); } if (VERBOSE) debugNetPrintf(DEBUG,"Logging to stdout\n"); log_to_file = 0; } else { if (VERBOSE) debugNetPrintf(DEBUG,"Open file %s for logging\n", arg); log_to_file = 1; log_f_fd = open(arg, LOG_F_CREAT, LOG_F_MODE); } return 0; }
int ps4link_request_read(void *packet) { struct { unsigned int number; unsigned short length; int fd; int size; } PACKED *request = packet; int result = -1, size = -1; char buffer[65536], *bigbuffer; // If a big read is requested... if (ntohl(request->size) > sizeof(buffer)) { // Allocate the bigbuffer. bigbuffer = malloc(ntohl(request->size)); // Perform the request. result = size = read(ntohl(request->fd), bigbuffer, ntohl(request->size)); // Send the response. ps4link_response_read(result, size); // Send the response data. network_send(request_socket, bigbuffer, size); // Free the bigbuffer. free(bigbuffer); // Else, a normal read is requested... } else { // Perform the request. size = read(ntohl(request->fd), buffer, ntohl(request->size)); //int error=errno ; //debugNetPrintf(DEBUG,"Error reading file: %s %s\n", strerror( error ),buffer); result=size; debugNetPrintf(DEBUG,"read %d bytes of file descritor %d\n",result,ntohl(request->fd)); // Send the response. ps4link_response_read(result, size); // Send the response data. network_send(request_socket, buffer, size); } // End function. return 0; }
int ps4sh_log_read(int fd) { int ret; int size = sizeof(struct sockaddr_in); static char buf[1024]; static int loc = 0; struct sockaddr_in dest_addr; if(loc == 0) memset(buf, 0x0, sizeof(buf)); memset(&(dest_addr), '\0', size); /* Receive from, size must be at least 1 smaller than buffer for a NULL */ ret = recvfrom(fd, buf + loc, sizeof(buf) - loc - 1, 0,(struct sockaddr *)&dest_addr, &size); if (ret == -1) { debugNetPrintf(ERROR,"recvfrom error %s\n",strerror(errno)); } loc += ret; if (log_to_file) { write(log_f_fd, buf, strlen(buf)); loc = 0; /* log to file isn't line orientated */ } else { if(((strchr(buf, '\n')) || (sizeof(buf) - loc - 1) <= 0)) { /* Ideally we want entire lines but just in case check for NL at end of string */ int str_size = strlen(buf); if(buf[str_size - 1] != '\n') buf[str_size - 1] = '\n'; write_log_line(buf); fflush(stdout); loc = 0; } } return ret; }
int ps4link_connect(char *hostname) { // Listen datagram socket port for debugnet console. console_socket = network_listen(0x4712, SOCK_DGRAM); // Create the console thread. if (console_socket > 0) { pthread_create(&console_thread_id, NULL, ps4link_thread_console, (void *)&console_thread_id); } // Connect to the request port. request_socket = network_connect(hostname, 0x4711, SOCK_STREAM); // request_socket = network_listen(0x4711, SOCK_STREAM); // Create the request thread. while(request_socket<0) { request_socket = network_connect(hostname, 0x4711, SOCK_STREAM); sleep(1); debugNetPrintf(DEBUG,"waiting ps4...\n"); } if (request_socket > 0) { pthread_create(&request_thread_id, NULL, ps4link_thread_request, (void *)&request_thread_id); } // Connect to the command port future use to send commands to psp2 //command_socket = network_connect(hostname, 0x4712, SOCK_DGRAM); // Delay for a moment to let ps2link finish setup. #ifdef _WIN32 Sleep(1); #else sleep(1); #endif // End function. return 0; }
int cli_cd(char *arg) { char line[MAXPATHLEN]; char key[MAXPATHLEN]; char value[MAXPATHLEN]; if (strlen(arg) == 0) { get_home(line); read_pair(line, key, value); chdir(value); cli_pwd(); return 0; } if (chdir(arg) == -1) { debugNetPrintf(ERROR,"%s %s\n",strerror(errno)); return 1; } cli_pwd(); return (0); }
int ps4link_accept_pkt(int sock, char *buf, int len, int pkt_type) { int length; ps4link_pkt_hdr *hdr; unsigned int hcmd; unsigned short hlen; length = ps4link_recv_bytes(sock, buf, sizeof(ps4link_pkt_hdr)); if (length < 0) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_accept_pkt recv error\n"); return -1; } if (length < sizeof(ps4link_pkt_hdr)) { debugNetPrintf(DEBUG,"[PS4LINK] did not receive a full header!!!! " "Fix this! (%d)\n", length); } hdr = (ps4link_pkt_hdr *)buf; hcmd = sceNetNtohl(hdr->cmd); hlen = sceNetNtohs(hdr->len); if (hcmd != pkt_type) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_accept_pkt: Expected %x, got %x\n",pkt_type, hcmd); return 0; } if (hlen > len) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_accept_pkt: hdr->len is too large!! " "(%d, can only receive %d)\n", hlen, len); return 0; } // get the actual packet data length = ps4link_recv_bytes(sock, buf + sizeof(ps4link_pkt_hdr),hlen - sizeof(ps4link_pkt_hdr)); if (length < 0) { debugNetPrintf(DEBUG,"[PS4LINK] accept recv2 error!!\n"); return 0; } if (length < (hlen - sizeof(ps4link_pkt_hdr))) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_accept_pkt: Did not receive full packet!!! " ,"Fix this! (%d)\n", length); } return 1; }
int ps4link_recv_bytes(int sock, char *buf, int bytes) { size_t left; int len; left =(size_t) bytes; while (left > 0) { len = sceNetRecv(sock, &buf[bytes - left], left, MSG_WAITALL); //len = read(sock, &buf[bytes - left], left); if (len < 0) { debugNetPrintf(DEBUG,"[PS4LINK] ps4link_recv_bytes error!! 0x%08X\n",len); return -1; } left -= len; } return bytes; }
void psp2LinkCmdExecSprx(psp2link_pkt_exec_cmd *pkg) { debugNetPrintf(DEBUG,"[PSP2LINK] Received command execsprx argc=%d argv=%s\n",sceNetNtohl(pkg->argc),pkg->argv); //TODO check psp2LinkCmdExecElf }
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; }