/// Test routine called when an otherwise-unclaimed NetIO packet is received.
gboolean
gotnetpkt(Listener* l, ///<[in/out] Input GSource
FrameSet* fs, ///<[in/out] @ref FrameSet "FrameSet"s received
NetAddr* srcaddr ///<[in] Source address of this packet
)
{
(void)l; (void)srcaddr;
++wirepktcount;
switch(fs->fstype) {
case FRAMESETTYPE_HBDEAD:
g_message("CMA Received dead host notification (type %d) over the 'wire'."
, fs->fstype);
break;
case FRAMESETTYPE_SWDISCOVER:
g_message("CMA Received switch discovery data (type %d) over the 'wire'."
, fs->fstype);
break;
case FRAMESETTYPE_JSDISCOVERY:
g_message("CMA Received JSON discovery data (type %d) over the 'wire'."
, fs->fstype);
check_JSON(fs);
break;
case FRAMESETTYPE_RSCOPREPLY:
g_message("CMA Received resource operation data (type %d) over the 'wire'."
, fs->fstype);
check_JSON(fs);
break;
default:{
char * fsstr = fs->baseclass.toString(&fs->baseclass);
g_message("CMA Received a FrameSet of type %d [%s] over the 'wire'."
, fs->fstype, fsstr);
FREE(fsstr); fsstr = NULL;
}
}
l->transport->_netio->ackmessage(l->transport->_netio, srcaddr, fs);
UNREF(fs);
if (wirepktcount >= maxpkts) {
g_message("QUITTING NOW - wirepktcount!");
nano_initiate_shutdown();
return FALSE;
}
return TRUE;
}
/// Routine to pretend to be the initial CMA
void
fakecma_startup(AuthListener* auth, FrameSet* ifs, NetAddr* nanoaddr)
{
FrameSet* pkt;
NetGSource* netpkt = auth->baseclass.transport;
char * nanostr = nanoaddr->baseclass.toString(nanoaddr);
GSList* thisgsf;
const char * keyid = NULL;
(void)ifs;
g_message("CMA received startup message from nanoprobe at address %s/%d."
, nanostr, nanoaddr->port(nanoaddr));
g_free(nanostr); nanostr = NULL;
check_JSON(ifs);
netpkt->_netio->addalias(netpkt->_netio, nanoaddr, destaddr);
// Set up our crypto...
cryptframe_set_dest_key_id(nanoaddr, cryptframe_get_signing_key_id());
cryptframe_set_dest_key_id(destaddr, cryptframe_get_signing_key_id());
cryptframe_associate_identity(CMA_IDENTITY_NAME, cryptframe_get_signing_key_id());
cryptframe_set_encryption_method(cryptcurve25519_new_generic);
for (thisgsf = ifs->framelist; thisgsf; thisgsf=thisgsf->next) {
Frame* thisframe = CASTTOCLASS(Frame, thisgsf->data);
if (thisframe->type == FRAMETYPE_KEYID) {
CstringFrame* csf = CASTTOCLASS(CstringFrame, thisframe);
keyid = (const char *)csf->baseclass.value;
}else if (keyid && thisframe->type == FRAMETYPE_PUBKEYCURVE25519) {
cryptcurve25519_save_public_key(keyid, thisframe->value
, thisframe->length);
}
}
// Send the configuration data to our new "client"
pkt = create_setconfig(nanoconfig);
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
// Now tell them to send/expect heartbeats to various places
pkt = create_sendexpecthb(auth->baseclass.config, FRAMESETTYPE_SENDEXPECTHB, destaddr, 1);
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
{
const char * monopjson[] = { START, MONITOR, STOP};
unsigned j;
// Create a frameset for a few resource operations
pkt = frameset_new(FRAMESETTYPE_DORSCOP);
for (j=0; j < DIMOF(monopjson); j++) {
CstringFrame* csf = cstringframe_new(FRAMETYPE_RSCJSON,0);
csf->baseclass.setvalue(&csf->baseclass, g_strdup(monopjson[j])
, strlen(monopjson[j])+1, g_free);
frameset_append_frame(pkt, &csf->baseclass);
UNREF2(csf);
}
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
}
{
const char * discoverjson[] = {SWITCHDISCOVER, ARPDISCOVER};
const char * discoverinstnm[] = {SWINSTNM, ARPINSTNM};
unsigned j;
// Create a frameset for a few discovery operations
pkt = frameset_new(FRAMESETTYPE_DODISCOVER);
for (j=0; j < DIMOF(discoverjson); j++) {
CstringFrame* csf = cstringframe_new(FRAMETYPE_DISCJSON,0);
CstringFrame* inst = cstringframe_new(FRAMETYPE_DISCNAME,0);
fprintf(stderr, "Creating discovery frameset: %s: %s\n"
, discoverinstnm[j]
, discoverjson[j]);
inst->baseclass.setvalue(&inst->baseclass, g_strdup(discoverjson[j])
, strlen(discoverjson[j])+1, g_free);
frameset_append_frame(pkt, &inst->baseclass);
UNREF2(inst);
csf->baseclass.setvalue(&csf->baseclass, g_strdup(discoverjson[j])
, strlen(discoverjson[j])+1, g_free);
frameset_append_frame(pkt, &csf->baseclass);
UNREF2(csf);
}
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
}
pkt = frameset_new(FRAMESETTYPE_ACKSTARTUP);
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
g_info("ACKSTARTUP packet queued to send");
}
int main(int argc, const char* argv[])
{
/* Sadly svchax crashes too much, so only allow install mode when running as a CIA
// Trigger svchax so we can install CIAs
if(argc > 0) {
svchax_init(true);
if(!__ctr_svchax || !__ctr_svchax_srv) {
bSvcHaxAvailable = false;
//printf("Failed to acquire kernel access. Install mode disabled.\n");
}
}
*/
// argc is 0 when running as a CIA, and 1 when running as a 3dsx
if (argc > 0)
{
bSvcHaxAvailable = false;
}
u32 *soc_sharedmem, soc_sharedmem_size = 0x100000;
gfxInitDefault();
consoleInit(GFX_TOP, NULL);
httpcInit(0);
soc_sharedmem = (u32 *)memalign(0x1000, soc_sharedmem_size);
socInit(soc_sharedmem, soc_sharedmem_size);
sslcInit(0);
hidInit();
acInit();
cfguInit();
if (bSvcHaxAvailable)
{
amInit();
AM_InitializeExternalTitleDatabase(false);
}
init_menu(GFX_TOP);
// Make sure all CIAngel directories exists on the SD card
mkpath("/CIAngel", 0777);
mkpath("/CIAngel/tmp/", 0777);
loadConfig();
// Set up the reading of json
check_JSON();
load_JSON_data();
menu_main();
if (bSvcHaxAvailable)
{
amExit();
}
cfguExit();
acExit();
gfxExit();
hidExit();
httpcExit();
socExit();
sslcExit();
}