void gfxExit(void)
{
if (screenFree == NULL) return;
// Exit event handler
gspExitEventHandler();
// Free framebuffers
screenFree(gfxTopRightFramebuffers[1]);
screenFree(gfxTopRightFramebuffers[0]);
screenFree(gfxBottomFramebuffers[1]);
screenFree(gfxBottomFramebuffers[0]);
screenFree(gfxTopLeftFramebuffers[1]);
screenFree(gfxTopLeftFramebuffers[0]);
//unmap GSP shared mem
svcUnmapMemoryBlock(gspSharedMemHandle, (u32)gfxSharedMemory);
GSPGPU_UnregisterInterruptRelayQueue();
svcCloseHandle(gspSharedMemHandle);
if(gfxSharedMemory != NULL)
{
mappableFree(gfxSharedMemory);
gfxSharedMemory = NULL;
}
svcCloseHandle(gspEvent);
GSPGPU_ReleaseRight();
gspExit();
screenFree = NULL;
}
void hidExit()
{
if(!hidInitialised) return;
// Unmap HID sharedmem and close handles.
u8 val=0;
int i; for(i=0; i<5; i++)svcCloseHandle(hidEvents[i]);
svcUnmapMemoryBlock(hidMemHandle, (u32)hidSharedMem);
svcCloseHandle(hidMemHandle);
svcCloseHandle(hidHandle);
APT_CheckNew3DS(NULL, &val);
if(val)
{
irrstExit();
}
if(hidSharedMem != NULL)
{
mappableFree((void*) hidSharedMem);
hidSharedMem = NULL;
}
hidInitialised = false;
}
void gfxExit()
{
// Exit event handler
gspExitEventHandler();
// Free framebuffers
linearFree(gfxTopRightFramebuffers[1]);
linearFree(gfxTopRightFramebuffers[0]);
linearFree(gfxBottomFramebuffers[1]);
linearFree(gfxBottomFramebuffers[0]);
linearFree(gfxTopLeftFramebuffers[1]);
linearFree(gfxTopLeftFramebuffers[0]);
//unmap GSP shared mem
svcUnmapMemoryBlock(gspSharedMemHandle, 0x10002000);
GSPGPU_UnregisterInterruptRelayQueue(NULL);
svcCloseHandle(gspSharedMemHandle);
svcCloseHandle(gspEvent);
GSPGPU_ReleaseRight(NULL);
gspExit();
}
Result task_capture_cam(capture_cam_data* data) {
if(data == NULL || data->buffer == NULL || data->width <= 0 || data->width > 640 || data->height <= 0 || data->height > 480) {
return R_APP_INVALID_ARGUMENT;
}
data->mutex = 0;
data->finished = false;
data->result = 0;
data->cancelEvent = 0;
Result res = 0;
if(R_SUCCEEDED(res = svcCreateEvent(&data->cancelEvent, RESET_STICKY)) && R_SUCCEEDED(res = svcCreateMutex(&data->mutex, false))) {
if(threadCreate(task_capture_cam_thread, data, 0x10000, 0x1A, 0, true) == NULL) {
res = R_APP_THREAD_CREATE_FAILED;
}
}
if(R_FAILED(res)) {
data->finished = true;
if(data->cancelEvent != 0) {
svcCloseHandle(data->cancelEvent);
data->cancelEvent = 0;
}
if(data->mutex != 0) {
svcCloseHandle(data->mutex);
data->mutex = 0;
}
}
return res;
}
Result httpcOpenContext(httpcContext *context, char* url, u32 use_defaultproxy)
{
Result ret=0;
ret = HTTPC_CreateContext(__httpc_servhandle, url, &context->httphandle);
if(ret!=0)return ret;
ret = srvGetServiceHandle(&context->servhandle, "http:C");
if(ret!=0) {
HTTPC_CloseContext(__httpc_servhandle, context->httphandle);
return ret;
}
ret = HTTPC_InitializeConnectionSession(context->servhandle, context->httphandle);
if(ret!=0) {
svcCloseHandle(context->servhandle);
HTTPC_CloseContext(__httpc_servhandle, context->httphandle);
return ret;
}
if(use_defaultproxy==0)return 0;
ret = HTTPC_SetProxyDefault(context->servhandle, context->httphandle);
if(ret!=0) {
svcCloseHandle(context->servhandle);
HTTPC_CloseContext(__httpc_servhandle, context->httphandle);
return ret;
}
return 0;
}
static void ndspFinalize(bool suspend)
{
LightLock_Lock(&ndspMutex);
u16 val = suspend ? 3 : 1;
DSP_WriteProcessPipe(2, &val, 4);
for (;;)
{
bool ready;
DSP_RecvDataIsReady(0, &ready);
if (ready)
{
DSP_RecvData(0, &val);
if (val == 1)
break;
}
}
if (suspend)
memcpy(dspVar5Backup, ndspVars[5][0], sizeof(dspVar5Backup));
DSP_RegisterInterruptEvents(0, 2, 2);
svcCloseHandle(irqEvent);
svcCloseHandle(dspSem);
DSP_UnloadComponent();
bComponentLoaded = false;
bDspReady = false;
LightLock_Unlock(&ndspMutex);
}
void aptExit()
{
if (!aptInitialised) return;
if(!(__system_runflags&RUNFLAG_APTWORKAROUND))aptAppletUtility_Exit_RetToApp(0);
// This is only executed when application-termination was triggered via the home-menu power-off screen.
if(aptGetStatusPower() == 1)
{
aptOpenSession();
APT_ReplySleepQuery(NULL, currentAppId, 0x0);
aptCloseSession();
}
if(!(__system_runflags&RUNFLAG_APTWORKAROUND))
{
aptOpenSession();
APT_PrepareToCloseApplication(NULL, 0x1);
aptCloseSession();
aptOpenSession();
APT_CloseApplication(NULL, 0x0, 0x0, 0x0);
aptCloseSession();
}
svcCloseHandle(aptSleepSync);
svcCloseHandle(aptStatusMutex);
svcCloseHandle(aptLockHandle);
svcCloseHandle(aptStatusEvent);
aptInitialised = false;
}
static inline void exitPXI(void)
{
unbindPXIInterrupts(&PXISyncInterrupt, NULL, NULL);
svcCloseHandle(PXITransferMutex);
svcCloseHandle(PXISyncInterrupt);
PXIReset();
}
Result miniSocInit()
{
if(AtomicPostIncrement(&miniSocRefCount))
return 0;
u32 tmp = 0;
Result ret = 0;
bool isSocURegistered;
ret = srvIsServiceRegistered(&isSocURegistered, "soc:U");
if(ret != 0) goto cleanup;
if(!isSocURegistered)
{
ret = -1;
goto cleanup;
}
ret = srvGetServiceHandle(&SOCU_handle, "soc:U");
if(ret != 0) goto cleanup;
ret = svcControlMemory(&tmp, socContextAddr, 0, socContextSize, MEMOP_ALLOC, MEMPERM_READ | MEMPERM_WRITE);
if(ret != 0) goto cleanup;
socContextAddr = tmp;
ret = svcCreateMemoryBlock(&socMemhandle, (u32)socContextAddr, socContextSize, 0, 3);
if(ret != 0) goto cleanup;
ret = SOCU_Initialize(socMemhandle, socContextSize);
if(ret != 0) goto cleanup;
svcKernelSetState(0x10000, 2);
miniSocEnabled = true;
return 0;
cleanup:
AtomicDecrement(&miniSocRefCount);
if(socMemhandle != 0)
{
svcCloseHandle(socMemhandle);
socMemhandle = 0;
}
if(SOCU_handle != 0)
{
SOCU_Shutdown();
svcCloseHandle(SOCU_handle);
SOCU_handle = 0;
}
if(tmp != 0)
svcControlMemory(&tmp, socContextAddr, socContextAddr, socContextSize, MEMOP_FREE, MEMPERM_DONTCARE);
return ret;
}
// ==================================================
Result FS_filesysExit(Handle* sdHandle, Handle* saveHandle, FS_archive* sdArchive, FS_archive* saveArchive)
// --------------------------------------------------
{
FSUSER_CloseArchive(saveHandle, saveArchive);
FSUSER_CloseArchive(sdHandle, sdArchive);
svcCloseHandle(*saveHandle);
svcCloseHandle(*sdHandle);
return 0;
}
void exitPhysicsThread(physicsThread_s* p)
{
if(!p)return;
p->exit=true;
svcWaitSynchronization(p->thread, U64_MAX);
svcCloseHandle(p->requestMutex);
svcCloseHandle(p->thread);
}
Result filesystemExit()
{
Result ret;
ret = FSUSER_CloseArchive(&saveGameFsHandle, &saveGameArchive);
ret = FSUSER_CloseArchive(&sdmcFsHandle, &sdmcArchive);
ret = svcCloseHandle(saveGameFsHandle);
ret = svcCloseHandle(sdmcFsHandle);
return ret;
}
// this is called after main exits
void __appExit()
{
srvExit();
exitPXI();
svcCloseHandle(terminationRequestedEvent);
svcCloseHandle(sessionManager.sendAllBuffersToArm9Event);
svcCloseHandle(sessionManager.replySemaphore);
svcCloseHandle(sessionManager.PXISRV11CommandReceivedEvent);
svcCloseHandle(sessionManager.PXISRV11ReplySentEvent);
}
int main(int argc, char** argv) {
gfxInitDefault();
consoleInit(GFX_TOP, NULL);
svcCreateEvent(&threadRequest,0);
u32 *threadStack = memalign(32, STACKSIZE);
Result ret = svcCreateThread(&threadHandle, threadMain, 0, &threadStack[STACKSIZE/4], 0x3f, 0);
printf("thread create returned %x\n", ret);
// Main loop
while (aptMainLoop())
{
gspWaitForVBlank();
hidScanInput();
printf("\x1b[5;0H");
printf("thread counter = %d\n",threadcount);
u32 kDown = hidKeysDown();
if (kDown & KEY_START)
break; // break in order to return to hbmenu
if (kDown & KEY_A)
svcSignalEvent(threadRequest);
// Flush and swap framebuffers
gfxFlushBuffers();
gfxSwapBuffers();
}
// tell thread to exit
threadExit = true;
// signal the thread
svcSignalEvent(threadRequest);
// give it time to exit
svcSleepThread(10000000ULL);
// close handles and free allocated stack
svcCloseHandle(threadRequest);
svcCloseHandle(threadHandle);
free(threadStack);
gfxExit();
return 0;
}
Result sslcDestroyContext(sslcContext *context)
{
Result ret=0;
svcCloseHandle(context->servhandle);
ret = sslcipc_DestroyContext(context);
if(context->sharedmem_handle)svcCloseHandle(context->sharedmem_handle);
memset(context, 0, sizeof(sslcContext));
return ret;
}
int saveBitmap(const char* filename, u8* buffer, u32 w, u32 h)
{
u8* temp=(u8*)malloc(w*h*3+sizeof(INFOHEADER)+sizeof(HEADER));
HEADER* header=(HEADER*)temp;
INFOHEADER* infoheader=(INFOHEADER*)(temp+sizeof(HEADER));
write16(&header->type, 0x4D42);
write32(&header->size, w*h*3+sizeof(INFOHEADER)+sizeof(HEADER));
write32(&header->offset, sizeof(INFOHEADER)+sizeof(HEADER));
write16(&header->reserved1, 0);
write16(&header->reserved2, 0);
write16(&infoheader->bits, 24);
write32(&infoheader->size, sizeof(INFOHEADER));
write32(&infoheader->compression, 0);
write32(&infoheader->width, w);
write32(&infoheader->height, h);
write16(&infoheader->planes, 1);
write32(&infoheader->imagesize, w*h*3);
write32(&infoheader->xresolution, 0);
write32(&infoheader->yresolution, 0);
write32(&infoheader->importantcolours, 0);
write32(&infoheader->ncolours, 0);
int y,x;
for(y=0;y<h;y++)
{
for(x=0;x<w;x++)
{
temp[((y*w)+x)*3+sizeof(INFOHEADER)+sizeof(HEADER)]=buffer[(x*h+y)*3+0];
temp[((y*w)+x)*3+1+sizeof(INFOHEADER)+sizeof(HEADER)]=buffer[(x*h+y)*3+1];
temp[((y*w)+x)*3+2+sizeof(INFOHEADER)+sizeof(HEADER)]=buffer[(x*h+y)*3+2];
}
}
Handle file;
Result ret=FSUSER_OpenFile(NULL, &file, configuration.sdmc, FS_makePath(PATH_CHAR, filename), FS_OPEN_WRITE|FS_OPEN_CREATE, FS_ATTRIBUTE_NONE);
if(ret){svcCloseHandle(file); return -2;}
u32 size=w*h*3+sizeof(INFOHEADER)+sizeof(HEADER);
u32 bytesWritten=0;
ret=FSFILE_Write(file, &bytesWritten, 0, temp, size, FS_WRITE_FLUSH);
if(ret || bytesWritten!=size)return -2;
FSFILE_Close(file);
svcCloseHandle(file);
free(temp);
return 0;
}
void aptExit(void)
{
if (AtomicDecrement(&aptRefCount)) return;
if(!aptIsCrippled())aptAppletUtility_Exit_RetToApp(0);
// This is only executed when application-termination was triggered via the home-menu power-off screen.
if(aptGetStatusPower() == 1)
{
aptOpenSession();
APT_ReplySleepQuery(currentAppId, 0x0);
aptCloseSession();
}
if(!aptIsCrippled())
{
bool isReinit = aptIsReinit();
if (aptGetStatus() == APP_EXITING || !isReinit)
{
aptOpenSession();
APT_PrepareToCloseApplication(0x1);
aptCloseSession();
aptOpenSession();
APT_CloseApplication(0x0, 0x0, 0x0);
aptCloseSession();
if (isReinit)
{
extern void (*__system_retAddr)(void);
__system_retAddr = NULL;
}
} else if (isReinit)
{
aptOpenSession();
APT_Finalize(currentAppId);
aptCloseSession();
}
}
svcSignalEvent(aptEvents[2]);
threadJoin(aptEventHandlerThread, U64_MAX);
svcCloseHandle(aptEvents[2]);
svcCloseHandle(aptSleepSync);
svcCloseHandle(aptLockHandle);
svcCloseHandle(aptStatusEvent);
}
Result hidInit(void)
{
u8 val=0;
Result ret=0;
if (AtomicPostIncrement(&hidRefCount)) return 0;
// Request service.
ret = srvGetServiceHandle(&hidHandle, "hid:USER");
if (R_FAILED(ret)) ret = srvGetServiceHandle(&hidHandle, "hid:SPVR");
if (R_FAILED(ret)) goto cleanup0;
// Get sharedmem handle.
if(R_FAILED(ret=HIDUSER_GetHandles(&hidMemHandle, &hidEvents[HIDEVENT_PAD0], &hidEvents[HIDEVENT_PAD1], &hidEvents[HIDEVENT_Accel], &hidEvents[HIDEVENT_Gyro], &hidEvents[HIDEVENT_DebugPad]))) goto cleanup1;
// Map HID shared memory.
hidSharedMem=(vu32*)mappableAlloc(0x2b0);
if(!hidSharedMem)
{
ret = -1;
goto cleanup1;
}
if(R_FAILED(ret=svcMapMemoryBlock(hidMemHandle, (u32)hidSharedMem, MEMPERM_READ, 0x10000000)))goto cleanup2;
APT_CheckNew3DS(&val);
if(val)
{
ret = irrstInit();
}
// Reset internal state.
kOld = kHeld = kDown = kUp = 0;
return ret;
cleanup2:
svcCloseHandle(hidMemHandle);
if(hidSharedMem != NULL)
{
mappableFree((void*) hidSharedMem);
hidSharedMem = NULL;
}
cleanup1:
svcCloseHandle(hidHandle);
cleanup0:
AtomicDecrement(&hidRefCount);
return ret;
}
void sslcExit(void)
{
if (AtomicDecrement(&__sslc_refcount)) return;
svcCloseHandle(__sslc_servhandle);
__sslc_servhandle = 0;
}
Result sslcCreateContext(sslcContext *context, int sockfd, u32 input_opt, char *hostname)
{
Result ret=0;
memset(context, 0, sizeof(sslcContext));
ret = SOCU_AddGlobalSocket(sockfd);
if(R_FAILED(ret))return ret;
sockfd = soc_get_fd(sockfd);
if(sockfd < 0) {
errno = -sockfd;
return -1;
}
ret = sslcipc_CreateContext(context, sockfd, input_opt, hostname);
if(R_FAILED(ret))return ret;
ret = srvGetServiceHandle(&context->servhandle, "ssl:C");
if(R_FAILED(ret)) {
sslcipc_DestroyContext(context);
return ret;
}
ret = sslcipc_InitializeConnectionSession(context);
if(R_FAILED(ret)) {
svcCloseHandle(context->servhandle);
sslcipc_DestroyContext(context);
}
return ret;
}
void srvExit(void)
{
if (AtomicDecrement(&srvRefCount)) return;
if (srvHandle != 0) svcCloseHandle(srvHandle);
srvHandle = 0;
}
Result exitCfgu()
{
Result ret = svcCloseHandle(CFGU_handle);
CFGU_handle = 0;
return ret;
}
bool _vf3dClose(struct VFile* vf) {
struct VFile3DS* vf3d = (struct VFile3DS*) vf;
FSFILE_Close(vf3d->handle);
svcCloseHandle(vf3d->handle);
return true;
}
// Test access to "am" service, which we shouldn't have access to, unless khax succeeds.
Result test_am_access_inner()
{
Handle testHandle;
Result res = srvGetServiceHandleDirect(&testHandle, "am:u");
if (testHandle) svcCloseHandle(testHandle);
return res;
}
Result task_data_op(data_op_data* data) {
if(data == NULL) {
return R_APP_INVALID_ARGUMENT;
}
data->processed = 0;
data->currProcessed = 0;
data->currTotal = 0;
data->finished = false;
data->result = 0;
data->cancelEvent = 0;
Result res = 0;
if(R_SUCCEEDED(res = svcCreateEvent(&data->cancelEvent, RESET_STICKY))) {
if(threadCreate(task_data_op_thread, data, 0x10000, 0x18, 1, true) == NULL) {
res = R_APP_THREAD_CREATE_FAILED;
}
}
if(R_FAILED(res)) {
data->finished = true;
if(data->cancelEvent != 0) {
svcCloseHandle(data->cancelEvent);
data->cancelEvent = 0;
}
}
aptSetSleepAllowed(false);
return res;
}
int plat_mem_set_exec(void *ptr, size_t size)
{
#ifdef _WIN32
int ret = VirtualProtect(ptr,size,PAGE_EXECUTE_READWRITE,0);
if (ret == 0 && log_cb)
log_cb(RETRO_LOG_ERROR, "mprotect(%p, %zd) failed: %d\n", ptr, size, 0);
#elif defined(_3DS)
int ret = -1;
if (ctr_svchack_successful)
{
unsigned int currentHandle;
svcDuplicateHandle(¤tHandle, 0xFFFF8001);
ret = svcControlProcessMemory(currentHandle, ptr, 0x0,
size, MEMOP_PROT, 0b111);
svcCloseHandle(currentHandle);
ctr_flush_invalidate_cache();
}
else
{
if (log_cb)
log_cb(RETRO_LOG_ERROR, "plat_mem_set_exec called with no svcControlProcessMemory access\n");
exit(1);
}
#else
int ret = mprotect(ptr, size, PROT_READ | PROT_WRITE | PROT_EXEC);
if (ret != 0 && log_cb)
log_cb(RETRO_LOG_ERROR, "mprotect(%p, %zd) failed: %d\n", ptr, size, errno);
#endif
return ret;
}
void plat_munmap(void *ptr, size_t size)
{
if (ctr_svchack_successful)
{
pico_mmap_t* pico_mmap;
for (pico_mmap = pico_mmaps; pico_mmap->requested_map; pico_mmap++)
{
if ((pico_mmap->requested_map == (unsigned int)ptr))
{
unsigned int ptr_aligned;
unsigned int currentHandle;
size = (size + 0xFFF) & ~0xFFF;
ptr_aligned = (((unsigned int)pico_mmap->buffer) + 0xFFF) & ~0xFFF;
svcDuplicateHandle(¤tHandle, 0xFFFF8001);
svcControlProcessMemory(currentHandle, (void*)pico_mmap->requested_map, (void*)ptr_aligned, size, MEMOP_UNMAP, 0b011);
svcCloseHandle(currentHandle);
free(pico_mmap->buffer);
pico_mmap->buffer = NULL;
return;
}
}
}
free(ptr);
}
Result task_populate_files(populate_files_data* data) {
if(data == NULL || data->items == NULL) {
return R_FBI_INVALID_ARGUMENT;
}
task_clear_files(data->items);
data->finished = false;
data->result = 0;
data->cancelEvent = 0;
Result res = 0;
if(R_SUCCEEDED(res = svcCreateEvent(&data->cancelEvent, RESET_STICKY))) {
if(threadCreate(task_populate_files_thread, data, 0x10000, 0x19, 1, true) == NULL) {
res = R_FBI_THREAD_CREATE_FAILED;
}
}
if(R_FAILED(res)) {
data->finished = true;
if(data->cancelEvent != 0) {
svcCloseHandle(data->cancelEvent);
data->cancelEvent = 0;
}
}
return res;
}
void poweroff() {
if (khaxInit() != 0) {
debug("Err: khaxInit");
return;
}
Handle handle;
Result ret = srvGetServiceHandle(&handle, "ptm:s");
if (ret != 0) {
debug("Err: srvGetServiceHandle(ptm:s)");
return;
}
u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = 0x040700C0; //ShutdownAsync
cmdbuf[1] = 0; //?
cmdbuf[2] = 0; //?
cmdbuf[3] = 0; //?
ret = svcSendSyncRequest(handle);
if (ret != 0) {
debug("Err: srvGetServiceHandle(ptm:s)");
}
svcCloseHandle(handle);
}
void
pxipmExit(void)
{
if (AtomicDecrement(&pxipmRefCount))
return;
svcCloseHandle(pxipmHandle);
}
