int
bgp_dump_unset (struct vty *vty, struct bgp_dump *bgp_dump)
{
/* Set file name. */
if (bgp_dump->filename)
{
free (bgp_dump->filename);
bgp_dump->filename = NULL;
}
/* This should be called when interval is expired. */
if (bgp_dump->fp)
{
fclose (bgp_dump->fp);
bgp_dump->fp = NULL;
}
/* Create interval thread. */
if (bgp_dump->t_interval)
{
thread_cancel (bgp_dump->t_interval);
bgp_dump->t_interval = NULL;
}
bgp_dump->interval = 0;
if (bgp_dump->interval_str)
{
free (bgp_dump->interval_str);
bgp_dump->interval_str = NULL;
}
return CMD_SUCCESS;
}
void mpls_socket_writelist_del(mpls_socket_mgr_handle handle,
mpls_socket_handle socket)
{
if (socket) {
thread_cancel(socket->write);
socket->write = NULL;
}
}
/* Close a netlink socket */
int
netlink_close(nl_handle_t *nl)
{
/* First of all release pending thread */
thread_cancel(nl->thread);
close(nl->fd);
return 0;
}
void mpls_socket_readlist_del(mpls_socket_mgr_handle handle,
mpls_socket_handle socket)
{
if (socket && socket->read) {
thread_cancel(socket->read);
socket->read = NULL;
}
}
void
rip_interface_reset (void)
{
struct listnode *node;
struct interface *ifp;
struct rip_interface *ri;
for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
{
ri = ifp->info;
ri->enable_network = 0;
ri->enable_interface = 0;
ri->running = 0;
ri->ri_send = RI_RIP_UNSPEC;
ri->ri_receive = RI_RIP_UNSPEC;
ri->auth_type = RIP_NO_AUTH;
if (ri->auth_str)
{
free (ri->auth_str);
ri->auth_str = NULL;
}
if (ri->key_chain)
{
free (ri->key_chain);
ri->key_chain = NULL;
}
ri->split_horizon = RIP_NO_SPLIT_HORIZON;
ri->split_horizon_default = RIP_NO_SPLIT_HORIZON;
ri->list[RIP_FILTER_IN] = NULL;
ri->list[RIP_FILTER_OUT] = NULL;
ri->prefix[RIP_FILTER_IN] = NULL;
ri->prefix[RIP_FILTER_OUT] = NULL;
if (ri->t_wakeup)
{
thread_cancel (ri->t_wakeup);
ri->t_wakeup = NULL;
}
ri->recv_badpackets = 0;
ri->recv_badroutes = 0;
ri->sent_updates = 0;
ri->passive = 0;
}
}
int LCUI_Thread_Cancel(thread_t thread)
/* 功能：撤销一个线程 */
{
//printf("cancel thread:%lu\n", thread);
int tmp;
tmp = thread_cancel(thread);
/* 从线程树中删除这个线程的结点 */
if(tmp == 0) {
Thread_TreeNode_Delete(&LCUI_Sys.thread_tree, thread);
}
return tmp;
}
int Disable_TouchScreen_Input()
/* 功能：撤销触屏输入处理 */
{
#ifdef USE_TSLIB
if(LCUI_Sys.ts.status == INSIDE) {
return thread_cancel ( LCUI_Sys.ts.thread );
}
return 0;
#else
return -1;
#endif
}
/* Close a netlink socket */
static int
netlink_close(nl_handle_t *nl)
{
/* First of all release pending thread */
thread_cancel(nl->thread);
#ifdef _HAVE_LIBNL3_
nl_socket_free(nl->sk);
#else
close(nl->fd);
#endif
return 0;
}
/* Clear all SMUX related resources. */
static void
smux_stop (void)
{
if (smux_read_thread)
{
thread_cancel (smux_read_thread);
smux_read_thread = NULL;
}
if (smux_connect_thread)
{
thread_cancel (smux_connect_thread);
smux_connect_thread = NULL;
}
if (smux_sock >= 0)
{
close (smux_sock);
smux_sock = -1;
}
}
void frrzmq_thread_cancel(struct frrzmq_cb **cb, struct cb_core *core)
{
if (!cb || !*cb)
return;
core->cancelled = 1;
if (core->thread) {
thread_cancel(core->thread);
core->thread = NULL;
}
if ((*cb)->read.cancelled && !(*cb)->read.thread
&& (*cb)->write.cancelled && (*cb)->write.thread)
XFREE(MTYPE_ZEROMQ_CB, *cb);
}
void
ospf6_area_delete (struct ospf6_area *o6a)
{
listnode n;
struct ospf6_interface *o6i;
CALL_REMOVE_HOOK (&area_hook, o6a);
/* ospf6 interface list */
for (n = listhead (o6a->if_list); n; nextnode (n))
{
o6i = (struct ospf6_interface *) getdata (n);
/* ospf6_interface_delete (o6i); */
}
list_delete (o6a->if_list);
/* terminate LSDB */
ospf6_lsdb_remove_all (o6a->lsdb);
/* spf tree terminate */
/* xxx */
/* threads */
if (o6a->spf_calc)
thread_cancel (o6a->spf_calc);
o6a->spf_calc = (struct thread *) NULL;
if (o6a->route_calc)
thread_cancel (o6a->route_calc);
o6a->route_calc = (struct thread *) NULL;
/* new */
ospf6_route_table_delete (o6a->route_table);
ospf6_spftree_delete (o6a->spf_tree);
ospf6_route_table_delete (o6a->table_topology);
/* free area */
XFREE (MTYPE_OSPF6_AREA, o6a);
}
int tl_program_pause(tl_program_t *pProgram)
{
if(NULL == pProgram)
return ERROR;
pProgram->iState = TL_PROGRAM_PAUSE;
tl_program_invalid();
if(pProgram->pDelayThread)
thread_cancel(pProgram->pDelayThread);
pProgram->pDelayThread = NULL;
if(TL_IS_DEBUG(PROGRAM))
tl_log_info("Pause current program");
return OK;
}
void
bgp_close (void)
{
struct listnode *node, *next;
struct bgp_listener *listener;
for (ALL_LIST_ELEMENTS (bm->listen_sockets, node, next, listener))
{
thread_cancel (listener->thread);
close (listener->fd);
listnode_delete (bm->listen_sockets, listener);
XFREE (MTYPE_BGP_LISTENER, listener);
}
}
void tl_program_free(tl_program_t **ppProgram)
{
if(NULL == ppProgram || NULL == (*ppProgram))
return;
tl_program_invalid();
if((*ppProgram)->pDelayThread)
thread_cancel((*ppProgram)->pDelayThread);
if((*ppProgram)->szProgramFile)
free((*ppProgram)->szProgramFile);
if((*ppProgram)->arrInstructions)
free((*ppProgram)->arrInstructions);
free((*ppProgram));
(*ppProgram) = NULL;
}
void thread_pool_cancel(struct thread_pool *pool)
{
if (!pool->single) {
int i;
for (i=0; i<pool->count; ++i) {
if (pool->threads[i] && pool->threads[i]->state == STATE_RUNNING) {
if (!thread_cancel(pool->threads[i]->thread)) {
LOG_FATAL(core, "%s", clear_error());
}
pool->threads[i]->state = STATE_CANCELED;
}
}
}
}
int
bgp_damp_disable (struct bgp *bgp, afi_t afi, safi_t safi)
{
/* Cancel reuse thread. */
if (damp->t_reuse )
thread_cancel (damp->t_reuse);
damp->t_reuse = NULL;
/* Clean BGP dampening information. */
bgp_damp_info_clean ();
/* Clear configuration */
bgp_damp_config_clean (&bgp_damp_cfg);
UNSET_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING);
return 0;
}
void del_from_rs_list(salt_real_server_t *rs)
{
int index = check_ipaddr_exist(rs->ipaddr);
int i;
if( index == -1)
return;
thread_cancel(global_vs->entrytable[index].thread);
for(i = index; i < global_vs->num_dests-1; i++)
{
global_vs->entrytable[i].ipaddr = global_vs->entrytable[i+1].ipaddr;
global_vs->entrytable[i].port = global_vs->entrytable[i+1].port;
}
global_vs->num_dests--;
/* this function closes vrf socket
* this should be called only for vrf socket with netns backend
*/
void bgp_close_vrf_socket(struct bgp *bgp)
{
struct listnode *node, *next;
struct bgp_listener *listener;
if (!bgp)
return;
if (bm->listen_sockets == NULL)
return;
for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) {
if (listener->bgp == bgp) {
thread_cancel(listener->thread);
close(listener->fd);
listnode_delete(bm->listen_sockets, listener);
XFREE(MTYPE_BGP_LISTENER, listener);
}
}
}
int
isis_area_destroy (const char *area_tag)
{
struct isis_area *area;
struct listnode *node, *nnode;
struct isis_circuit *circuit;
area = isis_area_lookup (area_tag);
if (area == NULL)
{
Log(LOG_WARNING, "WARN ( %s/core/ISIS ): Can't find ISIS instance %s\n", config.name, area_tag);
return TRUE;
}
if (area->circuit_list)
{
for (ALL_LIST_ELEMENTS (area->circuit_list, node, nnode, circuit))
{
/* The fact that it's in circuit_list means that it was configured */
isis_csm_state_change (ISIS_DISABLE, circuit, area);
isis_circuit_down (circuit);
isis_circuit_deconfigure (circuit, area);
}
isis_list_delete (area->circuit_list);
}
isis_listnode_delete (isis->area_list, area);
if (area->t_remove_aged)
thread_cancel (area->t_remove_aged);
THREAD_TIMER_OFF (area->spftree[0]->t_spf);
THREAD_TIMER_OFF (area->spftree[1]->t_spf);
free(area);
isis->sysid_set=0;
return FALSE;
}
void
ripng_interface_clean (void)
{
struct listnode *node, *nnode;
struct interface *ifp;
struct ripng_interface *ri;
for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
{
ri = ifp->info;
ri->enable_network = 0;
ri->enable_interface = 0;
ri->running = 0;
if (ri->t_wakeup)
{
thread_cancel (ri->t_wakeup);
ri->t_wakeup = NULL;
}
}
}
void
ripng_interface_clean ()
{
struct listnode *node;
struct interface *ifp;
struct ripng_interface *ri;
for (node = listhead (iflist); node; nextnode (node))
{
ifp = getdata (node);
ri = ifp->info;
ri->enable_network = 0;
ri->enable_interface = 0;
ri->running = 0;
if (ri->t_wakeup)
{
thread_cancel (ri->t_wakeup);
ri->t_wakeup = NULL;
}
}
}
/**
* Free client state.
*/
void quit_client_state() {
int input_error;
/* free enet structures */
if (client.client) enet_peer_disconnect(client.client, 0);
if (client.host) enet_host_destroy(client.host);
/* get thread status */
mutex_lock(&client.input_lock);
input_error = client.input_error;
mutex_unlock(&client.input_lock);
/* cancel the input thread if needed */
if (!input_error) {
mutex_lock(&client.input_lock);
thread_cancel(client.input_thread);
mutex_unlock(&client.input_lock);
}
/* join a canceled thread */
thread_join(client.input_thread);
/* destroy the input lock */
mutex_destroy(&client.input_lock);
mutex_destroy(&client.network_lock);
/* free other input resources */
free(client.input_buffer);
dlist_free(client.input_queue);
dfree(client.server_host_addr);
dfree(client.server_host_name);
free_server_info();
}
int _main( int argc, char *argv[] )
{
//BSS is in DATA section so IOS doesnt touch it, we need to manually clear it
//dbgprintf("memset32(%08x, 0, %08x)\n", &__bss_start, &__bss_end - &__bss_start);
memset32(&__bss_start, 0, &__bss_end - &__bss_start);
sync_after_write(&__bss_start, &__bss_end - &__bss_start);
s32 ret = 0;
u32 HID_Thread = 0, DI_Thread = 0;
u8 MessageHeap[0x10];
//u32 MessageQueue=0xFFFFFFFF;
BootStatus(0, 0, 0);
thread_set_priority( 0, 0x79 ); // do not remove this, this waits for FS to be ready!
thread_set_priority( 0, 0x50 );
thread_set_priority( 0, 0x79 );
//MessageQueue = ES_Init( MessageHeap );
ES_Init( MessageHeap );
BootStatus(1, 0, 0);
#ifndef NINTENDONT_USB
BootStatus(2, 0, 0);
ret = SDHCInit();
if(!ret)
{
dbgprintf("SD:SDHCInit() failed:%d\r\n", ret );
BootStatusError(-2, ret);
mdelay(2000);
Shutdown();
}
#endif
BootStatus(3, 0, 0);
fatfs = (FATFS*)malloca( sizeof(FATFS), 32 );
s32 res = f_mount( 0, fatfs );
if( res != FR_OK )
{
dbgprintf("ES:f_mount() failed:%d\r\n", res );
BootStatusError(-3, res);
mdelay(2000);
Shutdown();
}
BootStatus(4, 0, 0);
BootStatus(5, 0, 0);
int MountFail = 0;
s32 fres = -1;
FIL fp;
while(fres != FR_OK)
{
fres = f_open(&fp, "/bladie", FA_READ|FA_OPEN_EXISTING);
switch(fres)
{
case FR_OK:
f_close(&fp);
case FR_NO_PATH:
case FR_NO_FILE:
{
fres = FR_OK;
} break;
default:
case FR_DISK_ERR:
{
f_mount(0, NULL); //unmount drive todo: retry could never work
MountFail++;
if(MountFail == 10)
{
BootStatusError(-5, fres);
mdelay(2000);
Shutdown();
}
mdelay(5);
} break;
}
if(STATUS_ERROR == -7) { // FS check timed out on PPC side
dbgprintf("FS check timed out\r\n");
mdelay(3000);
Shutdown();
}
}
#ifndef NINTENDONT_USB
s_size = 512;
s_cnt = fatfs->n_fatent * fatfs->csize;
#endif
BootStatus(6, s_size, s_cnt);
#ifdef NINTENDONT_USB
s32 r = LoadModules(55);
//dbgprintf("ES:ES_LoadModules(%d):%d\r\n", 55, r );
if( r < 0 )
{
BootStatusError(-6, r);
mdelay(2000);
Shutdown();
}
#endif
BootStatus(7, s_size, s_cnt);
ConfigInit();
if (ConfigGetConfig(NIN_CFG_LOG))
SDisInit = 1; // Looks okay after threading fix
dbgprintf("Game path: %s\r\n", ConfigGetGamePath());
BootStatus(8, s_size, s_cnt);
memset32((void*)0x13002800, 0, 0x30);
sync_after_write((void*)0x13002800, 0x30);
memset32((void*)0x13160000, 0, 0x20);
sync_after_write((void*)0x13160000, 0x20);
memset32((void*)0x13026500, 0, 0x100);
sync_after_write((void*)0x13026500, 0x100);
bool UseHID = ConfigGetConfig(NIN_CFG_HID);
if( UseHID )
{
ret = HIDInit();
if(ret < 0 )
{
dbgprintf("ES:HIDInit() failed\r\n" );
BootStatusError(-8, ret);
mdelay(2000);
Shutdown();
}
write32(0x13003004, 0);
sync_after_write((void*)0x13003004, 0x20);
HID_Thread = thread_create(HID_Run, NULL, HID_ThreadStack, 0x400, 0x78, 1);
thread_continue(HID_Thread);
}
BootStatus(9, s_size, s_cnt);
DIRegister();
DI_Thread = thread_create(DIReadThread, NULL, DI_ThreadStack, 0x400, 0x78, 1);
thread_continue(DI_Thread);
DIinit(true);
BootStatus(10, s_size, s_cnt);
GCAMInit();
EXIInit();
ret = Check_Cheats();
if(ret < 0 )
{
dbgprintf("Check_Cheats failed\r\n" );
BootStatusError(-10, ret);
mdelay(4000);
Shutdown();
}
BootStatus(11, s_size, s_cnt);
bool PatchSI = !ConfigGetConfig(NIN_CFG_NATIVE_SI);
if (PatchSI)
SIInit();
StreamInit();
PatchInit();
//This bit seems to be different on japanese consoles
u32 ori_ppcspeed = read32(HW_PPCSPEED);
if((ConfigGetGameID() & 0xFF) == 'J')
set32(HW_PPCSPEED, (1<<17));
else
clear32(HW_PPCSPEED, (1<<17));
//write32( 0x1860, 0xdeadbeef ); // Clear OSReport area
//Tell PPC side we are ready!
cc_ahbMemFlush(1);
mdelay(1000);
BootStatus(0xdeadbeef, s_size, s_cnt);
u32 Now = read32(HW_TIMER);
u32 PADTimer = Now;
u32 DiscChangeTimer = Now;
u32 ResetTimer = Now;
#ifdef NINTENDONT_USB
u32 USBReadTimer = Now;
#endif
u32 Reset = 0;
bool SaveCard = false;
if( ConfigGetConfig(NIN_CFG_LED) )
{
set32(HW_GPIO_ENABLE, GPIO_SLOT_LED);
clear32(HW_GPIO_DIR, GPIO_SLOT_LED);
clear32(HW_GPIO_OWNER, GPIO_SLOT_LED);
}
EnableAHBProt(-1); //disable AHBPROT
write32(0xd8006a0, 0x30000004), mask32(0xd8006a8, 0, 2); //widescreen fix
while (1)
{
_ahbMemFlush(0);
//Check this. Purpose is to send another interrupt if wasn't processed
/*if (((read32(0x14) != 0) || (read32(0x13026514) != 0))
&& (read32(HW_ARMIRQFLAG) & (1 << 30)) == 0)
{
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
}*/
#ifdef PATCHALL
if (EXI_IRQ == true)
{
if(EXICheckTimer())
EXIInterrupt();
}
#endif
if ((PatchSI) && (SI_IRQ != 0))
{
if (((read32(HW_TIMER) - PADTimer) > 7910) || (SI_IRQ & 0x2)) // about 240 times a second
{
SIInterrupt();
PADTimer = read32(HW_TIMER);
}
}
if(DI_IRQ == true)
{
if(DI_CallbackMsg.result == 0)
DIInterrupt();
}
else if(SaveCard == true) /* DI IRQ indicates we might read async, so dont write at the same time */
{
if((read32(HW_TIMER) - Now) / 1898437 > 2) /* after 3 second earliest */
{
EXISaveCard();
SaveCard = false;
}
}
#ifdef NINTENDONT_USB
else if((read32(HW_TIMER) - USBReadTimer) / 1898437 > 9) /* Read random sector after about 10 seconds */
{
DI_CallbackMsg.result = -1;
sync_after_write(&DI_CallbackMsg, 0x20);
IOS_IoctlAsync( DI_Handle, 2, NULL, 0, NULL, 0, DI_MessageQueue, &DI_CallbackMsg );
while(DI_CallbackMsg.result)
{
udelay(10); //wait for other threads
BTUpdateRegisters();
}
USBReadTimer = read32(HW_TIMER);
}
#endif
udelay(10); //wait for other threads
//Baten Kaitos save hax
/*if( read32(0) == 0x474B4245 )
{
if( read32( 0x0073E640 ) == 0xFFFFFFFF )
{
write32( 0x0073E640, 0 );
}
}*/
if ( DiscChangeIRQ == 1 )
{
DiscChangeTimer = read32(HW_TIMER);
DiscChangeIRQ = 2;
}
else if ( DiscChangeIRQ == 2 )
{
if ( (read32(HW_TIMER) - DiscChangeTimer ) > 2 * 243000000 / 128)
{
//dbgprintf("DIP:IRQ mon!\r\n");
set32( DI_SSTATUS, 0x3A );
sync_after_write((void*)DI_SSTATUS, 4);
DIInterrupt();
DiscChangeIRQ = 0;
}
}
_ahbMemFlush(1);
DIUpdateRegisters();
#ifdef PATCHALL
EXIUpdateRegistersNEW();
GCAMUpdateRegisters();
BTUpdateRegisters();
#endif
StreamUpdateRegisters();
CheckOSReport();
if(EXICheckCard())
{
Now = read32(HW_TIMER);
SaveCard = true;
}
if (PatchSI)
{
SIUpdateRegisters();
if (read32(DIP_IMM) == 0x1DEA)
{
DIFinishAsync();
break;
}
if (read32(DIP_IMM) == 0x3DEA)
{
if (Reset == 0)
{
dbgprintf("Fake Reset IRQ\n");
write32(EXI2DATA, 0x2); // Reset irq
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
Reset = 1;
}
}
else if (Reset == 1)
{
write32(EXI2DATA, 0x10000); // send pressed
ResetTimer = read32(HW_TIMER);
Reset = 2;
}
/* The cleanup is not connected to the button press */
if (Reset == 2)
{
if ((read32(HW_TIMER) - ResetTimer) / 949219 > 0) //free after half a second
{
write32(EXI2DATA, 0); // done, clear
write32(DIP_IMM, 0);
Reset = 0;
}
}
}
if(read32(DIP_IMM) == 0x4DEA)
PatchGame();
CheckPatchPrs();
if(read32(HW_GPIO_IN) & GPIO_POWER)
{
DIFinishAsync();
#ifdef PATCHALL
BTE_Shutdown();
#endif
Shutdown();
}
//sync_before_read( (void*)0x1860, 0x20 );
//if( read32(0x1860) != 0xdeadbeef )
//{
// if( read32(0x1860) != 0 )
// {
// dbgprintf( (char*)(P2C(read32(0x1860))),
// (char*)(P2C(read32(0x1864))),
// (char*)(P2C(read32(0x1868))),
// (char*)(P2C(read32(0x186C))),
// (char*)(P2C(read32(0x1870))),
// (char*)(P2C(read32(0x1874)))
// );
// }
// write32(0x1860, 0xdeadbeef);
// sync_after_write( (void*)0x1860, 0x20 );
//}
cc_ahbMemFlush(1);
}
if( UseHID )
{
/* we're done reading inputs */
thread_cancel(HID_Thread, 0);
}
IOS_Close(DI_Handle); //close game
thread_cancel(DI_Thread, 0);
DIUnregister();
write32( DIP_IMM, 0 );
/* reset time */
while(1)
{
if(read32(DIP_IMM) == 0x2DEA)
break;
wait_for_ppc(1);
}
if( ConfigGetConfig(NIN_CFG_LED) )
clear32(HW_GPIO_OUT, GPIO_SLOT_LED);
if( ConfigGetConfig(NIN_CFG_MEMCARDEMU) )
EXIShutdown();
if (ConfigGetConfig(NIN_CFG_LOG))
closeLog();
#ifdef PATCHALL
BTE_Shutdown();
#endif
//unmount FAT device
f_mount(0, NULL);
#ifndef NINTENDONT_USB
SDHCShutdown();
#endif
//make sure we set that back to the original
write32(HW_PPCSPEED, ori_ppcspeed);
IOSBoot((char*)0x13003020, 0, read32(0x13003000));
return 0;
}
static int frrzmq_write_msg(struct thread *t)
{
struct frrzmq_cb **cbp = THREAD_ARG(t);
struct frrzmq_cb *cb;
unsigned char written = 0;
int ret;
if (!cbp)
return 1;
cb = (*cbp);
if (!cb || !cb->zmqsock)
return 1;
while (1) {
zmq_pollitem_t polli = {.socket = cb->zmqsock,
.events = ZMQ_POLLOUT};
ret = zmq_poll(&polli, 1, 0);
if (ret < 0)
goto out_err;
if (!(polli.revents & ZMQ_POLLOUT))
break;
if (cb->write.cb_msg) {
cb->write.cb_msg(cb->write.arg, cb->zmqsock);
written = 1;
if (cb->write.cancelled) {
frrzmq_check_events(cbp, &cb->read, ZMQ_POLLIN);
cb->write.thread = NULL;
if (cb->read.cancelled && !cb->read.thread)
XFREE(MTYPE_ZEROMQ_CB, cb);
return 0;
}
continue;
}
}
if (written)
frrzmq_check_events(cbp, &cb->read, ZMQ_POLLIN);
funcname_thread_add_read_write(THREAD_WRITE, t->master,
frrzmq_write_msg, cbp, cb->fd,
&cb->write.thread, t->funcname,
t->schedfrom, t->schedfrom_line);
return 0;
out_err:
flog_err(LIB_ERR_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
errno);
if (cb->write.cb_error)
cb->write.cb_error(cb->write.arg, cb->zmqsock);
return 1;
}
int funcname_frrzmq_thread_add_write(struct thread_master *master,
void (*msgfunc)(void *arg, void *zmqsock),
void (*errfunc)(void *arg, void *zmqsock),
void *arg, void *zmqsock,
struct frrzmq_cb **cbp, debugargdef)
{
int fd, events;
size_t len;
struct frrzmq_cb *cb;
if (!cbp)
return -1;
if (!msgfunc)
return -1;
len = sizeof(fd);
if (zmq_getsockopt(zmqsock, ZMQ_FD, &fd, &len))
return -1;
len = sizeof(events);
if (zmq_getsockopt(zmqsock, ZMQ_EVENTS, &events, &len))
return -1;
if (*cbp)
cb = *cbp;
else {
cb = XCALLOC(MTYPE_ZEROMQ_CB, sizeof(struct frrzmq_cb));
if (!cb)
return -1;
cb->read.cancelled = 1;
*cbp = cb;
}
cb->zmqsock = zmqsock;
cb->fd = fd;
cb->write.arg = arg;
cb->write.cb_msg = msgfunc;
cb->write.cb_part = NULL;
cb->write.cb_error = errfunc;
cb->write.cancelled = 0;
if (events & ZMQ_POLLOUT) {
if (cb->write.thread) {
thread_cancel(cb->write.thread);
cb->write.thread = NULL;
}
funcname_thread_add_event(master, frrzmq_write_msg, cbp, fd,
&cb->write.thread, funcname,
schedfrom, fromln);
} else
funcname_thread_add_read_write(
THREAD_WRITE, master, frrzmq_write_msg, cbp, fd,
&cb->write.thread, funcname, schedfrom, fromln);
return 0;
}
void bfd_recvtimer_update(struct bfd_session *bs)
{
struct timeval tv = {.tv_sec = 0, .tv_usec = bs->detect_TO};
/* Don't add event if peer is deactivated. */
if (BFD_CHECK_FLAG(bs->flags, BFD_SESS_FLAG_SHUTDOWN))
return;
tv_normalize(&tv);
#ifdef BFD_EVENT_DEBUG
log_debug("%s: sec = %ld, usec = %ld", __func__, tv.tv_sec, tv.tv_usec);
#endif /* BFD_EVENT_DEBUG */
/* Remove previous schedule if any. */
if (bs->recvtimer_ev)
bfd_recvtimer_delete(bs);
thread_add_timer_tv(master, bfd_recvtimer_cb, bs, &tv,
&bs->recvtimer_ev);
}
void bfd_echo_recvtimer_update(struct bfd_session *bs)
{
struct timeval tv = {.tv_sec = 0, .tv_usec = bs->echo_detect_TO};
/* Don't add event if peer is deactivated. */
if (BFD_CHECK_FLAG(bs->flags, BFD_SESS_FLAG_SHUTDOWN))
return;
tv_normalize(&tv);
#ifdef BFD_EVENT_DEBUG
log_debug("%s: sec = %ld, usec = %ld", __func__, tv.tv_sec, tv.tv_usec);
#endif /* BFD_EVENT_DEBUG */
/* Remove previous schedule if any. */
if (bs->echo_recvtimer_ev)
bfd_echo_recvtimer_delete(bs);
thread_add_timer_tv(master, bfd_echo_recvtimer_cb, bs, &tv,
&bs->echo_recvtimer_ev);
}
void bfd_xmttimer_update(struct bfd_session *bs, uint64_t jitter)
{
struct timeval tv = {.tv_sec = 0, .tv_usec = jitter};
/* Don't add event if peer is deactivated. */
if (BFD_CHECK_FLAG(bs->flags, BFD_SESS_FLAG_SHUTDOWN))
return;
tv_normalize(&tv);
#ifdef BFD_EVENT_DEBUG
log_debug("%s: sec = %ld, usec = %ld", __func__, tv.tv_sec, tv.tv_usec);
#endif /* BFD_EVENT_DEBUG */
/* Remove previous schedule if any. */
if (bs->xmttimer_ev)
bfd_xmttimer_delete(bs);
thread_add_timer_tv(master, bfd_xmt_cb, bs, &tv, &bs->xmttimer_ev);
}
void bfd_echo_xmttimer_update(struct bfd_session *bs, uint64_t jitter)
{
struct timeval tv = {.tv_sec = 0, .tv_usec = jitter};
/* Don't add event if peer is deactivated. */
if (BFD_CHECK_FLAG(bs->flags, BFD_SESS_FLAG_SHUTDOWN))
return;
tv_normalize(&tv);
#ifdef BFD_EVENT_DEBUG
log_debug("%s: sec = %ld, usec = %ld", __func__, tv.tv_sec, tv.tv_usec);
#endif /* BFD_EVENT_DEBUG */
/* Remove previous schedule if any. */
if (bs->echo_xmttimer_ev)
bfd_echo_xmttimer_delete(bs);
thread_add_timer_tv(master, bfd_echo_xmt_cb, bs, &tv,
&bs->echo_xmttimer_ev);
}
void bfd_recvtimer_delete(struct bfd_session *bs)
{
if (bs->recvtimer_ev == NULL)
return;
thread_cancel(bs->recvtimer_ev);
bs->recvtimer_ev = NULL;
}
void bfd_echo_recvtimer_delete(struct bfd_session *bs)
{
if (bs->echo_recvtimer_ev == NULL)
return;
thread_cancel(bs->echo_recvtimer_ev);
bs->echo_recvtimer_ev = NULL;
}
void bfd_xmttimer_delete(struct bfd_session *bs)
{
if (bs->xmttimer_ev == NULL)
return;
thread_cancel(bs->xmttimer_ev);
bs->xmttimer_ev = NULL;
}
void bfd_echo_xmttimer_delete(struct bfd_session *bs)
{
if (bs->echo_xmttimer_ev == NULL)
return;
thread_cancel(bs->echo_xmttimer_ev);
bs->echo_xmttimer_ev = NULL;
}
static int frrzmq_read_msg(struct thread *t)
{
struct frrzmq_cb **cbp = THREAD_ARG(t);
struct frrzmq_cb *cb;
zmq_msg_t msg;
unsigned partno;
unsigned char read = 0;
int ret, more;
size_t moresz;
if (!cbp)
return 1;
cb = (*cbp);
if (!cb || !cb->zmqsock)
return 1;
while (1) {
zmq_pollitem_t polli = {.socket = cb->zmqsock,
.events = ZMQ_POLLIN};
ret = zmq_poll(&polli, 1, 0);
if (ret < 0)
goto out_err;
if (!(polli.revents & ZMQ_POLLIN))
break;
if (cb->read.cb_msg) {
cb->read.cb_msg(cb->read.arg, cb->zmqsock);
read = 1;
if (cb->read.cancelled) {
frrzmq_check_events(cbp, &cb->write,
ZMQ_POLLOUT);
cb->read.thread = NULL;
if (cb->write.cancelled && !cb->write.thread)
XFREE(MTYPE_ZEROMQ_CB, cb);
return 0;
}
continue;
}
partno = 0;
if (zmq_msg_init(&msg))
goto out_err;
do {
ret = zmq_msg_recv(&msg, cb->zmqsock, ZMQ_NOBLOCK);
if (ret < 0) {
if (errno == EAGAIN)
break;
zmq_msg_close(&msg);
goto out_err;
}
read = 1;
cb->read.cb_part(cb->read.arg, cb->zmqsock, &msg,
partno);
if (cb->read.cancelled) {
zmq_msg_close(&msg);
frrzmq_check_events(cbp, &cb->write,
ZMQ_POLLOUT);
cb->read.thread = NULL;
if (cb->write.cancelled && !cb->write.thread)
XFREE(MTYPE_ZEROMQ_CB, cb);
return 0;
}
/* cb_part may have read additional parts of the
* message; don't use zmq_msg_more here */
moresz = sizeof(more);
more = 0;
ret = zmq_getsockopt(cb->zmqsock, ZMQ_RCVMORE, &more,
&moresz);
if (ret < 0) {
zmq_msg_close(&msg);
goto out_err;
}
partno++;
} while (more);
zmq_msg_close(&msg);
}
if (read)
frrzmq_check_events(cbp, &cb->write, ZMQ_POLLOUT);
funcname_thread_add_read_write(
THREAD_READ, t->master, frrzmq_read_msg, cbp, cb->fd,
&cb->read.thread, t->funcname, t->schedfrom, t->schedfrom_line);
return 0;
out_err:
flog_err(LIB_ERR_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
errno);
if (cb->read.cb_error)
cb->read.cb_error(cb->read.arg, cb->zmqsock);
return 1;
}
int funcname_frrzmq_thread_add_read(struct thread_master *master,
void (*msgfunc)(void *arg, void *zmqsock),
void (*partfunc)(void *arg, void *zmqsock,
zmq_msg_t *msg,
unsigned partnum),
void (*errfunc)(void *arg, void *zmqsock),
void *arg, void *zmqsock,
struct frrzmq_cb **cbp, debugargdef)
{
int fd, events;
size_t len;
struct frrzmq_cb *cb;
if (!cbp)
return -1;
if (!(msgfunc || partfunc) || (msgfunc && partfunc))
return -1;
len = sizeof(fd);
if (zmq_getsockopt(zmqsock, ZMQ_FD, &fd, &len))
return -1;
len = sizeof(events);
if (zmq_getsockopt(zmqsock, ZMQ_EVENTS, &events, &len))
return -1;
if (*cbp)
cb = *cbp;
else {
cb = XCALLOC(MTYPE_ZEROMQ_CB, sizeof(struct frrzmq_cb));
if (!cb)
return -1;
cb->write.cancelled = 1;
*cbp = cb;
}
cb->zmqsock = zmqsock;
cb->fd = fd;
cb->read.arg = arg;
cb->read.cb_msg = msgfunc;
cb->read.cb_part = partfunc;
cb->read.cb_error = errfunc;
cb->read.cancelled = 0;
if (events & ZMQ_POLLIN) {
if (cb->read.thread) {
thread_cancel(cb->read.thread);
cb->read.thread = NULL;
}
funcname_thread_add_event(master, frrzmq_read_msg, cbp, fd,
&cb->read.thread, funcname, schedfrom,
fromln);
} else
funcname_thread_add_read_write(
THREAD_READ, master, frrzmq_read_msg, cbp, fd,
&cb->read.thread, funcname, schedfrom, fromln);
return 0;
}
int main(int argc, char **argv)
{
struct prng *prng;
int i;
struct thread **timers;
struct timeval tv_start, tv_lap, tv_stop;
unsigned long t_schedule, t_remove;
master = thread_master_create();
prng = prng_new(0);
timers = calloc(SCHEDULE_TIMERS, sizeof(*timers));
/* create thread structures so they won't be allocated during the
* time measurement */
for (i = 0; i < SCHEDULE_TIMERS; i++)
timers[i] = thread_add_timer_msec(master, dummy_func, NULL, 0);
for (i = 0; i < SCHEDULE_TIMERS; i++)
thread_cancel(timers[i]);
quagga_gettime(QUAGGA_CLK_MONOTONIC, &tv_start);
for (i = 0; i < SCHEDULE_TIMERS; i++)
{
long interval_msec;
interval_msec = prng_rand(prng) % (100 * SCHEDULE_TIMERS);
timers[i] = thread_add_timer_msec(master, dummy_func,
NULL, interval_msec);
}
quagga_gettime(QUAGGA_CLK_MONOTONIC, &tv_lap);
for (i = 0; i < REMOVE_TIMERS; i++)
{
int index;
index = prng_rand(prng) % SCHEDULE_TIMERS;
if (timers[index])
thread_cancel(timers[index]);
timers[index] = NULL;
}
quagga_gettime(QUAGGA_CLK_MONOTONIC, &tv_stop);
t_schedule = 1000 * (tv_lap.tv_sec - tv_start.tv_sec);
t_schedule += (tv_lap.tv_usec - tv_start.tv_usec) / 1000;
t_remove = 1000 * (tv_stop.tv_sec - tv_lap.tv_sec);
t_remove += (tv_stop.tv_usec - tv_lap.tv_usec) / 1000;
printf("Scheduling %d random timers took %ld.%03ld seconds.\n",
SCHEDULE_TIMERS, t_schedule/1000, t_schedule%1000);
printf("Removing %d random timers took %ld.%03ld seconds.\n",
REMOVE_TIMERS, t_remove/1000, t_remove%1000);
fflush(stdout);
free(timers);
thread_master_free(master);
prng_free(prng);
return 0;
}
int main(int argc, char **argv)
{
int i, j;
struct thread t;
struct timeval **alarms;
master = thread_master_create();
log_buf_len = SCHEDULE_TIMERS * (TIMESTR_LEN + 1) + 1;
log_buf_pos = 0;
log_buf = XMALLOC(MTYPE_TMP, log_buf_len);
expected_buf_len = SCHEDULE_TIMERS * (TIMESTR_LEN + 1) + 1;
expected_buf_pos = 0;
expected_buf = XMALLOC(MTYPE_TMP, expected_buf_len);
prng = prng_new(0);
timers = XMALLOC(MTYPE_TMP, SCHEDULE_TIMERS * sizeof(*timers));
for (i = 0; i < SCHEDULE_TIMERS; i++)
{
long interval_msec;
int ret;
char *arg;
/* Schedule timers to expire in 0..5 seconds */
interval_msec = prng_rand(prng) % 5000;
arg = XMALLOC(MTYPE_TMP, TIMESTR_LEN + 1);
timers[i] = thread_add_timer_msec(master, timer_func, arg, interval_msec);
ret = snprintf(arg, TIMESTR_LEN + 1, "%ld.%06ld",
timers[i]->u.sands.tv_sec, timers[i]->u.sands.tv_usec);
assert(ret > 0);
assert((size_t)ret < TIMESTR_LEN + 1);
timers_pending++;
}
for (i = 0; i < REMOVE_TIMERS; i++)
{
int index;
index = prng_rand(prng) % SCHEDULE_TIMERS;
if (!timers[index])
continue;
XFREE(MTYPE_TMP, timers[index]->arg);
thread_cancel(timers[index]);
timers[index] = NULL;
timers_pending--;
}
/* We create an array of pointers to the alarm times and sort
* that array. That sorted array is used to generate a string
* representing the expected "output" of the timers when they
* are run. */
j = 0;
alarms = XMALLOC(MTYPE_TMP, timers_pending * sizeof(*alarms));
for (i = 0; i < SCHEDULE_TIMERS; i++)
{
if (!timers[i])
continue;
alarms[j++] = &timers[i]->u.sands;
}
qsort(alarms, j, sizeof(*alarms), cmp_timeval);
for (i = 0; i < j; i++)
{
int ret;
ret = snprintf(expected_buf + expected_buf_pos,
expected_buf_len - expected_buf_pos,
"%ld.%06ld\n", alarms[i]->tv_sec, alarms[i]->tv_usec);
assert(ret > 0);
expected_buf_pos += ret;
assert(expected_buf_pos < expected_buf_len);
}
XFREE(MTYPE_TMP, alarms);
while (thread_fetch(master, &t))
thread_call(&t);
return 0;
}
int _main( int argc, char *argv[] )
{
//BSS is in DATA section so IOS doesnt touch it, we need to manually clear it
//dbgprintf("memset32(%08x, 0, %08x)\n", &__bss_start, &__bss_end - &__bss_start);
memset32(&__bss_start, 0, &__bss_end - &__bss_start);
sync_after_write(&__bss_start, &__bss_end - &__bss_start);
s32 ret = 0;
u32 DI_Thread = 0;
u8 MessageHeap[0x10];
BootStatus(0, 0, 0);
thread_set_priority( 0, 0x79 ); // do not remove this, this waits for FS to be ready!
thread_set_priority( 0, 0x50 );
thread_set_priority( 0, 0x79 );
//Disable AHBPROT
EnableAHBProt(-1);
//Load IOS Modules
ES_Init( MessageHeap );
//Early HID for loader
HIDInit();
//Enable DVD Access
write32(HW_DIFLAGS, read32(HW_DIFLAGS) & ~DI_DISABLEDVD);
dbgprintf("Sending signal to loader\r\n");
BootStatus(1, 0, 0);
mdelay(10);
//Loader running, selects games
while(1)
{
sync_before_read((void*)RESET_STATUS, 0x20);
vu32 reset_status = read32(RESET_STATUS);
if(reset_status != 0)
{
if(reset_status == 0x0DEA)
break; //game selected
else if(reset_status == 0x1DEA)
goto DoIOSBoot; //exit
write32(RESET_STATUS, 0);
sync_after_write((void*)RESET_STATUS, 0x20);
}
HIDUpdateRegisters(1);
mdelay(10);
}
ConfigSyncBeforeRead();
u32 UseUSB = ConfigGetConfig(NIN_CFG_USB);
SetDiskFunctions(UseUSB);
BootStatus(2, 0, 0);
if(UseUSB)
{
ret = USBStorage_Startup();
dbgprintf("USB:Drive size: %dMB SectorSize:%d\r\n", s_cnt / 1024 * s_size / 1024, s_size);
}
else
{
s_size = PAGE_SIZE512; //manually set s_size
ret = SDHCInit();
}
if(ret != 1)
{
dbgprintf("Device Init failed:%d\r\n", ret );
BootStatusError(-2, ret);
mdelay(4000);
Shutdown();
}
//Verification if we can read from disc
if(memcmp(ConfigGetGamePath(), "di", 3) == 0)
RealDI_Init(); //will shutdown on fail
BootStatus(3, 0, 0);
fatfs = (FATFS*)malloca( sizeof(FATFS), 32 );
s32 res = f_mount( fatfs, fatDevName, 1 );
if( res != FR_OK )
{
dbgprintf("ES:f_mount() failed:%d\r\n", res );
BootStatusError(-3, res);
mdelay(4000);
Shutdown();
}
BootStatus(4, 0, 0);
BootStatus(5, 0, 0);
FIL fp;
s32 fres = f_open_char(&fp, "/bladie", FA_READ|FA_OPEN_EXISTING);
switch(fres)
{
case FR_OK:
f_close(&fp);
case FR_NO_PATH:
case FR_NO_FILE:
{
fres = FR_OK;
} break;
default:
case FR_DISK_ERR:
{
BootStatusError(-5, fres);
mdelay(4000);
Shutdown();
} break;
}
if(!UseUSB) //Use FAT values for SD
s_cnt = fatfs->n_fatent * fatfs->csize;
BootStatus(6, s_size, s_cnt);
BootStatus(7, s_size, s_cnt);
ConfigInit();
if (ConfigGetConfig(NIN_CFG_LOG))
SDisInit = 1; // Looks okay after threading fix
dbgprintf("Game path: %s\r\n", ConfigGetGamePath());
BootStatus(8, s_size, s_cnt);
memset32((void*)RESET_STATUS, 0, 0x20);
sync_after_write((void*)RESET_STATUS, 0x20);
memset32((void*)0x13002800, 0, 0x30);
sync_after_write((void*)0x13002800, 0x30);
memset32((void*)0x13160000, 0, 0x20);
sync_after_write((void*)0x13160000, 0x20);
memset32((void*)0x13026500, 0, 0x100);
sync_after_write((void*)0x13026500, 0x100);
BootStatus(9, s_size, s_cnt);
DIRegister();
DI_Thread = thread_create(DIReadThread, NULL, ((u32*)&__di_stack_addr), ((u32)(&__di_stack_size)) / sizeof(u32), 0x78, 1);
thread_continue(DI_Thread);
DIinit(true);
BootStatus(10, s_size, s_cnt);
GCAMInit();
EXIInit();
BootStatus(11, s_size, s_cnt);
SIInit();
StreamInit();
PatchInit();
//Tell PPC side we are ready!
cc_ahbMemFlush(1);
mdelay(1000);
BootStatus(0xdeadbeef, s_size, s_cnt);
mdelay(1000); //wait before hw flag changes
dbgprintf("Kernel Start\r\n");
//write32( 0x1860, 0xdeadbeef ); // Clear OSReport area
//sync_after_write((void*)0x1860, 0x20);
u32 Now = read32(HW_TIMER);
u32 PADTimer = Now;
u32 DiscChangeTimer = Now;
u32 ResetTimer = Now;
u32 InterruptTimer = Now;
USBReadTimer = Now;
u32 Reset = 0;
bool SaveCard = false;
if( ConfigGetConfig(NIN_CFG_LED) )
{
set32(HW_GPIO_ENABLE, GPIO_SLOT_LED);
clear32(HW_GPIO_DIR, GPIO_SLOT_LED);
clear32(HW_GPIO_OWNER, GPIO_SLOT_LED);
}
set32(HW_GPIO_ENABLE, GPIO_SENSOR_BAR);
clear32(HW_GPIO_DIR, GPIO_SENSOR_BAR);
clear32(HW_GPIO_OWNER, GPIO_SENSOR_BAR);
set32(HW_GPIO_OUT, GPIO_SENSOR_BAR); //turn on sensor bar
write32( HW_PPCIRQMASK, (1<<30) );
write32( HW_PPCIRQFLAG, read32(HW_PPCIRQFLAG) );
//This bit seems to be different on japanese consoles
u32 ori_ppcspeed = read32(HW_PPCSPEED);
if((ConfigGetGameID() & 0xFF) == 'J')
set32(HW_PPCSPEED, (1<<17));
else
clear32(HW_PPCSPEED, (1<<17));
u32 ori_widesetting = read32(0xd8006a0);
if(IsWiiU)
{
if( ConfigGetConfig(NIN_CFG_WIIU_WIDE) )
write32(0xd8006a0, 0x30000004);
else
write32(0xd8006a0, 0x30000002);
mask32(0xd8006a8, 0, 2);
}
while (1)
{
_ahbMemFlush(0);
//Does interrupts again if needed
if(TimerDiffTicks(InterruptTimer) > 15820) //about 120 times a second
{
sync_before_read((void*)INT_BASE, 0x80);
if((read32(RSW_INT) & 2) || (read32(DI_INT) & 4) ||
(read32(SI_INT) & 8) || (read32(EXI_INT) & 0x10))
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
InterruptTimer = read32(HW_TIMER);
}
#ifdef PATCHALL
if (EXI_IRQ == true)
{
if(EXICheckTimer())
EXIInterrupt();
}
#endif
if (SI_IRQ != 0)
{
if ((TimerDiffTicks(PADTimer) > 7910) || (SI_IRQ & 0x2)) // about 240 times a second
{
SIInterrupt();
PADTimer = read32(HW_TIMER);
}
}
if(DI_IRQ == true)
{
if(DiscCheckAsync())
DIInterrupt();
else
udelay(200); //let the driver load data
}
else if(SaveCard == true) /* DI IRQ indicates we might read async, so dont write at the same time */
{
if(TimerDiffSeconds(Now) > 2) /* after 3 second earliest */
{
EXISaveCard();
SaveCard = false;
}
}
else if(UseUSB && TimerDiffSeconds(USBReadTimer) > 149) /* Read random sector every 2 mins 30 secs */
{
DIFinishAsync(); //if something is still running
DI_CallbackMsg.result = -1;
sync_after_write(&DI_CallbackMsg, 0x20);
IOS_IoctlAsync( DI_Handle, 2, NULL, 0, NULL, 0, DI_MessageQueue, &DI_CallbackMsg );
DIFinishAsync();
USBReadTimer = read32(HW_TIMER);
}
udelay(10); //wait for other threads
//Baten Kaitos save hax
/*if( read32(0) == 0x474B4245 )
{
if( read32( 0x0073E640 ) == 0xFFFFFFFF )
{
write32( 0x0073E640, 0 );
}
}*/
if( WaitForRealDisc == 1 )
{
if(RealDI_NewDisc())
{
DiscChangeTimer = read32(HW_TIMER);
WaitForRealDisc = 2; //do another flush round, safety!
}
}
else if( WaitForRealDisc == 2 )
{
if(TimerDiffSeconds(DiscChangeTimer))
{
//identify disc after flushing everything
RealDI_Identify(false);
//clear our fake regs again
sync_before_read((void*)DI_BASE, 0x40);
write32(DI_IMM, 0);
write32(DI_COVER, 0);
sync_after_write((void*)DI_BASE, 0x40);
//mask and clear interrupts
write32( DIP_STATUS, 0x54 );
//disable cover irq which DIP enabled
write32( DIP_COVER, 4 );
DIInterrupt();
WaitForRealDisc = 0;
}
}
if ( DiscChangeIRQ == 1 )
{
DiscChangeTimer = read32(HW_TIMER);
DiscChangeIRQ = 2;
}
else if ( DiscChangeIRQ == 2 )
{
if ( TimerDiffSeconds(DiscChangeTimer) > 2 )
{
DIInterrupt();
DiscChangeIRQ = 0;
}
}
_ahbMemFlush(1);
DIUpdateRegisters();
#ifdef PATCHALL
EXIUpdateRegistersNEW();
GCAMUpdateRegisters();
BTUpdateRegisters();
HIDUpdateRegisters(0);
if(DisableSIPatch == 0) SIUpdateRegisters();
#endif
StreamUpdateRegisters();
CheckOSReport();
if(EXICheckCard())
{
Now = read32(HW_TIMER);
SaveCard = true;
}
sync_before_read((void*)RESET_STATUS, 0x20);
vu32 reset_status = read32(RESET_STATUS);
if (reset_status == 0x1DEA)
{
write32(RESET_STATUS, 0);
sync_after_write((void*)RESET_STATUS, 0x20);
DIFinishAsync();
break;
}
if (reset_status == 0x3DEA)
{
if (Reset == 0)
{
dbgprintf("Fake Reset IRQ\n");
write32( RSW_INT, 0x2 ); // Reset irq
sync_after_write( (void*)RSW_INT, 0x20 );
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
Reset = 1;
}
}
else if (Reset == 1)
{
write32( RSW_INT, 0x10000 ); // send pressed
sync_after_write( (void*)RSW_INT, 0x20 );
ResetTimer = read32(HW_TIMER);
Reset = 2;
}
/* The cleanup is not connected to the button press */
if (Reset == 2)
{
if (TimerDiffTicks(ResetTimer) > 949219) //free after half a second
{
write32( RSW_INT, 0 ); // done, clear
sync_after_write( (void*)RSW_INT, 0x20 );
Reset = 0;
}
}
if(reset_status == 0x4DEA)
PatchGame();
if(reset_status == 0x5DEA)
{
SetIPL();
PatchGame();
}
if(reset_status == 0x6DEA)
{
SetIPL_TRI();
write32(RESET_STATUS, 0);
sync_after_write((void*)RESET_STATUS, 0x20);
}
if(read32(HW_GPIO_IN) & GPIO_POWER)
{
DIFinishAsync();
#ifdef PATCHALL
BTE_Shutdown();
#endif
Shutdown();
}
//sync_before_read( (void*)0x1860, 0x20 );
//if( read32(0x1860) != 0xdeadbeef )
//{
// if( read32(0x1860) != 0 )
// {
// dbgprintf( (char*)(P2C(read32(0x1860))),
// (char*)(P2C(read32(0x1864))),
// (char*)(P2C(read32(0x1868))),
// (char*)(P2C(read32(0x186C))),
// (char*)(P2C(read32(0x1870))),
// (char*)(P2C(read32(0x1874)))
// );
// }
// write32(0x1860, 0xdeadbeef);
// sync_after_write( (void*)0x1860, 0x20 );
//}
cc_ahbMemFlush(1);
}
//if( UseHID )
HIDClose();
IOS_Close(DI_Handle); //close game
thread_cancel(DI_Thread, 0);
DIUnregister();
/* reset time */
while(1)
{
sync_before_read( (void*)RESET_STATUS, 0x20 );
if(read32(RESET_STATUS) == 0x2DEA)
break;
wait_for_ppc(1);
}
if( ConfigGetConfig(NIN_CFG_LED) )
clear32(HW_GPIO_OUT, GPIO_SLOT_LED);
if( ConfigGetConfig(NIN_CFG_MEMCARDEMU) )
EXIShutdown();
if (ConfigGetConfig(NIN_CFG_LOG))
closeLog();
#ifdef PATCHALL
BTE_Shutdown();
#endif
//unmount FAT device
free(fatfs);
fatfs = NULL;
f_mount(NULL, fatDevName, 1);
if(UseUSB)
USBStorage_Shutdown();
else
SDHCShutdown();
//make sure we set that back to the original
write32(HW_PPCSPEED, ori_ppcspeed);
if(IsWiiU)
{
write32(0xd8006a0, ori_widesetting);
mask32(0xd8006a8, 0, 2);
}
DoIOSBoot:
sync_before_read((void*)0x13003000, 0x420);
IOSBoot((char*)0x13003020, 0, read32(0x13003000));
return 0;
}
/*This is the function on which server wait for new client connection. */
int ISocketCommunication::Socket_Process_Clients(void)
{
pid_t ichild_process_id;
struct sockaddr_storage client_address;
socklen_t addrlen;
char addrStr[ADDRSTRLEN] = {0}, host[NI_MAXHOST] = {0}, service[NI_MAXSERV] = {0};
std::map<pid_t,int>::iterator it;
int client_sock_fd = 0;
if(sock_fd <= 0) {
return -1; /* socket has not been initialized, hence return with error.. */
}
/* This chat server is create one child process for each client request.
All the child process are grouped under parent process. Hence parent and all child proecss are treated as one job in Linux/Unix OS
If parent is terminated due to any signal (e.g. ctrl c), OS will kill, all the child processes. */
setpgid(getpid(), getpid());
addrlen = sizeof(struct sockaddr_storage);
for (;;) {
memset(&client_address, 0, sizeof(struct sockaddr_storage) );
/* Wait for connection from client */
client_sock_fd = accept(sock_fd, (struct sockaddr *) &client_address, &addrlen) ;
if(client_sock_fd == -1 || errno)
{
if(errno == EINTR) {
continue;
}
else { //if(errno == EBADF || errno == EINVAL)
errno = ENOTCONN;
break;
}
}
if (getnameinfo((struct sockaddr *) &client_address, addrlen, host, NI_MAXHOST, service, NI_MAXSERV, 0) == 0)
snprintf(addrStr, ADDRSTRLEN, "(%s, %s)", host, service);
else
snprintf(addrStr, ADDRSTRLEN, "(?UNKNOWN?)");
if(m_iCntClientConnections == socketCommunication_namespace::MAX_CLIENT_CONNECTION) {
std::cout << std::endl << "Client Connection from : " << addrStr << " is refused, as maximum supported client is reached. " << std::endl;
close(client_sock_fd); /* As maximum supported clients is reached, no more new client connection are allowed.. */
continue;
}
/* Handle each client request in a new child process */
switch (ichild_process_id = fork() ) {
case -1:
perror("\n Fork creation : ");
close(client_sock_fd); /* Give up on this client */
break;/* May be temporary; try next client */
case 0: /* Child */
std::cout << std::endl << "Client Connection from : " << addrStr << std::endl;
close(sock_fd); /* Unneeded copy of listening socket */
sock_fd = client_sock_fd;
handleClientRequest();
/*two threads(for (Rx/Tx)) created for each client connection, This has a design of one process for each client connection, internally for each client process, two new thread are created, if client connection is lost for any reason, these two thread have to be cancelled, so that process can be closed and release its memory.. */
if(m_bThreadCreated) {
thread_cancel(0);
thread_cancel(1);
}
break;
default: /* Parent */
char buf[128] = {0};
m_pSemaphore->sem_Wait();
m_childProcessMap.insert( std::make_pair(ichild_process_id, client_sock_fd) );
m_iCntClientConnections++;
m_psharedMem->sharedMem_addClient(ichild_process_id);
m_pSemaphore->sem_Post();
sprintf(buf, "Child is created : %d", ichild_process_id);
m_pLogger->log_write(buf);
/* If client requires, client can be informed events like new client connection established etc... */
//if(m_pChatEvtCmd)
//m_pChatEvtCmd->executeChatEvtCmd(chatevtcmd_namespace::eNewClientCreated);
close(client_sock_fd); /* Unneeded copy of connected socket */
break; /* Loop to accept next connection */
} /*End of switch case */
} /*End of for loop */
return 0;
}