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;
}
