void listener_thread(void *unused)
{
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(ftp_port);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
int list_s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(bind(list_s, (struct sockaddr *)&sa, sizeof(sa)) == -1
|| listen(list_s, OFTP_LISTEN_BACKLOG) == -1)
{
appstate = 1;
}
int conn_s;
sys_ppu_thread_t id;
while(appstate != 1)
{
if((conn_s = accept(list_s, NULL, NULL)) > 0)
{
sysThreadCreate(&id, client_thread, (void *)&conn_s, 1337, 0x2000, THREAD_JOINABLE, "client");
sysThreadYield();
} else sysUsleep(250000);
}
closesocket(list_s);
sysThreadExit(0);
}
void listener_thread(void *unused)
{
sys_ppu_thread_t id;
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(2002);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
int list_s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
// only 1 socket connection is allowed at once
if(bind(list_s, (struct sockaddr *)&sa, sizeof(sa)) == -1 || listen(list_s, 1) == -1)
{
sysThreadExit(0);
}
int conn_s;
while (!user_requested_exit())
{
if((conn_s = accept(list_s, NULL, NULL)) > 0)
{
sysThreadCreate(&id, client_thread, (void *)&conn_s, 1337, 0x2000, 0, "client");
sysThreadYield();
}
}
closesocket(list_s);
sysThreadExit(0);
}
/*
* This has to be cancellable, so we can't just call sceKernelWaitThreadEnd.
* Instead, poll on this in a loop, like we do for a cancellable semaphore.
*/
pte_osResult pte_osThreadWaitForEnd(pte_osThreadHandle threadHandle)
{
pte_osResult osResult;
psl1ghtThreadData *pThreadData;
u64 result;
pThreadData = getThreadData(threadHandle);
if (pThreadData == NULL)
{
sysThreadJoin (threadHandle, &result);
osResult = PTE_OS_OK;
}
else
{
while (1)
{
if (pThreadData->ended == 1)
{
/* Thread has ended */
osResult = PTE_OS_OK;
break;
}
else
{
s32 count;
if (sysSemGetValue (pThreadData->cancelSem, &count) == 0)
{
if (count > 0)
{
osResult = PTE_OS_INTERRUPTED;
break;
}
else
{
/* Nothing found and not timed out yet; let's yield so we're not
* in busy loop.
*/
sysThreadYield ();
}
}
else
{
osResult = PTE_OS_GENERAL_FAILURE;
break;
}
}
}
}
return osResult;
}
static void thread_start(void *arg)
{
s32 running = 0;
sys_ppu_thread_t id;
sys_ppu_thread_stack_t stackinfo;
sysThreadGetId(&id);
sysThreadGetStackInformation(&stackinfo);
printf("stack\naddr: %p, size: %d\n",stackinfo.addr,stackinfo.size);
while(running<5) {
printf("Thread: %08llX\n",(unsigned long long int)id);
sysThreadYield();
sleep(2);
running++;
}
sysThreadExit(0);
}
/*
* Pend on a semaphore- and allow the pend to be cancelled.
*
* PS3 OS provides no functionality to asynchronously interrupt a blocked call. We simulte
* this by polling on the main semaphore and the cancellation semaphore and sleeping in a loop.
*/
pte_osResult pte_osSemaphoreCancellablePend(pte_osSemaphoreHandle semHandle, unsigned int *pTimeout)
{
psl1ghtThreadData *pThreadData;
sys_ppu_thread_t threadId;
sysThreadGetId (&threadId);
pThreadData = getThreadData(threadId);
clock_t start_time;
s32 result = 0;
u64 timeout;
unsigned char timeoutEnabled;
start_time = clock();
// clock() is in microseconds, timeout as passed in was in milliseconds
if (pTimeout == NULL)
{
timeout = 0;
timeoutEnabled = 0;
}
else
{
timeout = *pTimeout * 1000;
timeoutEnabled = 1;
}
while (1)
{
int status;
/* Poll semaphore */
status = sysSemTryWait(semHandle);
if (status == 0)
{
/* User semaphore posted to */
result = PTE_OS_OK;
break;
}
else if ((timeoutEnabled) && ((clock() - start_time) > timeout))
{
/* Timeout expired */
result = PTE_OS_TIMEOUT;
break;
}
else
{
if (pThreadData != NULL)
{
s32 count;
s32 osResult;
osResult = sysSemGetValue (pThreadData->cancelSem, &count);
if (osResult == 0)
{
if (count > 0)
{
result = PTE_OS_INTERRUPTED;
break;
}
else
{
/* Nothing found and not timed out yet; let's yield so we're not
* in busy loop.
*/
sysThreadYield ();
}
}
else
{
result = PTE_OS_GENERAL_FAILURE;
break;
}
}
}
}
return result;
}
