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