Result acInit(void)
{
Result ret;
if (AtomicPostIncrement(&acRefCount)) return 0;
ret = srvGetServiceHandle(&acHandle, "ac:u");
if(R_FAILED(ret)) ret = srvGetServiceHandle(&acHandle, "ac:i");
if(R_FAILED(ret)) AtomicDecrement(&acRefCount);
return ret;
}
Result qtmInit()
{
Result ret=0;
if(qtmInitialized)return 0;
if((ret=srvGetServiceHandle(&qtmHandle, "qtm:u")) && (ret=srvGetServiceHandle(&qtmHandle, "qtm:s")) && (ret=srvGetServiceHandle(&qtmHandle, "qtm:sp")))return ret;
qtmInitialized = true;
return 0;
}
Result amInit(void)
{
Result ret;
if (AtomicPostIncrement(&amRefCount)) return 0;
ret = srvGetServiceHandle(&amHandle, "am:net");
if (R_FAILED(ret)) ret = srvGetServiceHandle(&amHandle, "am:u");
if (R_FAILED(ret)) ret = srvGetServiceHandle(&amHandle, "am:sys");
if (R_FAILED(ret)) ret = srvGetServiceHandle(&amHandle, "am:app");
if (R_FAILED(ret)) AtomicDecrement(&amRefCount);
return ret;
}
Result cfguInit(void)
{
Result ret;
if (AtomicPostIncrement(&cfguRefCount)) return 0;
// cfg:i has the most commands, then cfg:s, then cfg:u
ret = srvGetServiceHandle(&cfguHandle, "cfg:i");
if(R_FAILED(ret)) ret = srvGetServiceHandle(&cfguHandle, "cfg:s");
if(R_FAILED(ret)) ret = srvGetServiceHandle(&cfguHandle, "cfg:u");
if(R_FAILED(ret)) AtomicDecrement(&cfguRefCount);
return ret;
}
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;
}
Result pxiDevInit(void) {
Result res;
if (AtomicPostIncrement(&pxiDevRefCount)) return 0;
res = srvGetServiceHandle(&pxiDevHandle, "pxi:dev");
if (R_FAILED(res)) AtomicDecrement(&pxiDevRefCount);
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);
}
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;
}
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;
}
// ==================================================
Result FS_filesysInit(Handle* sdHandle, Handle* saveHandle, FS_archive* sdArchive, FS_archive* saveArchive)
// --------------------------------------------------
{
Result ret;
printf(" Getting SD Card handle\n");
ret = srvGetServiceHandle(sdHandle, "fs:USER");
if (ret) return ret;
printf(" Opening SD Card archive\n");
*sdArchive = (FS_archive){0x9, (FS_path){PATH_EMPTY, 1, (u8*)""}, 0, 0};
ret = FSUSER_OpenArchive(sdHandle, sdArchive);
if (ret) return ret;
printf(" Getting save handle\n");
ret = _srvGetServiceHandle(saveHandle, "fs:USER");
if (ret) return ret;
printf(" Initializing save handle\n");
ret = FSUSER_Initialize(saveHandle);
if (ret) return ret;
printf(" Opening save archive\n");
*saveArchive = (FS_archive){0x4, (FS_path){PATH_EMPTY, 0, NULL}, 0, 0};
ret = FSUSER_OpenArchive(saveHandle, saveArchive);
return ret;
}
Result ptmuxInit(void)
{
if (AtomicPostIncrement(&ptmuxRefCount)) return 0;
Result res = srvGetServiceHandle(&ptmuxHandle, "ptm:u");
if (R_FAILED(res)) AtomicDecrement(&ptmuxRefCount);
return res;
}
Result hbInit(void)
{
Result res=0;
if (AtomicPostIncrement(&hbRefCount)) return 0;
res = srvGetServiceHandle(&hbHandle, "hb:HB");
if (R_FAILED(res)) AtomicDecrement(&hbRefCount);
return res;
}
Result loaderInit(void)
{
Result res;
if (AtomicPostIncrement(&loaderRefCount)) return 0;
res = srvGetServiceHandle(&loaderHandle, "Loader");
if (R_FAILED(res)) AtomicDecrement(&loaderRefCount);
return res;
}
Result gspLcdInit(void)
{
Result res=0;
if (AtomicPostIncrement(&gspLcdRefCount)) return 0;
res = srvGetServiceHandle(&gspLcdHandle, "gsp::Lcd");
if (R_FAILED(res)) AtomicDecrement(&gspLcdRefCount);
return res;
}
Result pmDbgInit(void)
{
Result res;
if (AtomicPostIncrement(&pmDbgRefcount)) return 0;
res = srvGetServiceHandle(&pmDbgHandle, "pm:dbg");
if (R_FAILED(res)) AtomicDecrement(&pmDbgRefcount);
return res;
}
Result psInit(void)
{
Result res;
if (AtomicPostIncrement(&psRefCount)) return 0;
res = srvGetServiceHandle(&psHandle, "ps:ps");
if (R_FAILED(res)) AtomicDecrement(&psRefCount);
return res;
}
/*! Initialize FS service
*
* @returns error
*/
Result
fsInit(void)
{
Result ret;
if((ret=srvGetServiceHandle(&fsuHandle, "fs:USER"))!=0)return ret;
if(__get_handle_from_list("fs:USER")==0)ret=FSUSER_Initialize(NULL);
return ret;
}
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 regionFreeInit()
{
Result ret = srvGetServiceHandle(&nssHandle, "ns:s");
if(!ret)regionFreeAvailable = true;
regionFreeGamecardIn = false;
return ret;
}
static Result _psInit(Handle handle)
{
Result res=0;
if (AtomicPostIncrement(&psRefCount)) return 0;
if(handle==0)res = srvGetServiceHandle(&handle, "ps:ps");
if (R_FAILED(res)) AtomicDecrement(&psRefCount);
if (R_SUCCEEDED(res)) psHandle = handle;
return res;
}
static int lua_service(lua_State *L){
int argc = lua_gettop(L);
#ifndef SKIP_ERROR_HANDLING
if(argc != 1) return luaL_error(L, "wrong number of arguments.");
#endif
const char* srv = luaL_checkstring(L,1);
Handle tmp;
srvGetServiceHandle(&tmp, srv);
lua_pushboolean(L, tmp);
return 1;
}
static Result __apt_initservicehandle(void)
{
Result ret=0;
u32 i;
if(__apt_servicestr)
{
return srvGetServiceHandle(&aptuHandle, __apt_servicestr);
}
for(i=0; i<3; i++)
{
ret = srvGetServiceHandle(&aptuHandle, __apt_servicenames[i]);
if(R_SUCCEEDED(ret))
{
__apt_servicestr = __apt_servicenames[i];
return ret;
}
}
return ret;
}
Result sslcInit(Handle session_handle)
{
Result ret=0;
if (AtomicPostIncrement(&__sslc_refcount)) return 0;
__sslc_servhandle = session_handle;
if(__sslc_servhandle==0)ret = srvGetServiceHandle(&__sslc_servhandle, "ssl:C");
if(session_handle==0 && R_SUCCEEDED(ret))ret = sslcipc_Initialize();
if (R_FAILED(ret)) AtomicDecrement(&__sslc_refcount);
return ret;
}
Result httpcInit()
{
Result ret=0;
if(__httpc_servhandle)return 0;
if((ret=srvGetServiceHandle(&__httpc_servhandle, "http:C")))return ret;
//*((u32*)0x600) = __httpc_servhandle;
ret = HTTPC_Initialize(__httpc_servhandle);
if(ret!=0)return ret;
return 0;
}
/*
Shutdown code contributed by daxtsu from gbatemp
*/
void shutdown3DS()
{
Handle ptmSysmHandle = 0;
Result result = srvGetServiceHandle(&ptmSysmHandle, "ns:s");
if (result != 0)
return;
// http://3dbrew.org/wiki/NSS:ShutdownAsync
u32 *commandBuffer = getThreadCommandBuffer();
commandBuffer[0] = 0x000E0000;
svcSendSyncRequest(ptmSysmHandle);
svcCloseHandle(ptmSysmHandle);
}
Result camInit(void) {
Result ret = 0;
if (AtomicPostIncrement(&camRefCount)) return 0;
ret = srvGetServiceHandle(&camHandle, "cam:u");
if (R_SUCCEEDED(ret))
{
ret = CAMU_DriverInitialize();
if (R_FAILED(ret)) svcCloseHandle(camHandle);
}
if (R_FAILED(ret)) AtomicDecrement(&camRefCount);
return ret;
}
Result y2rInit(void)
{
Result ret = 0;
if (AtomicPostIncrement(&y2rRefCount)) return 0;
ret = srvGetServiceHandle(&y2rHandle, "y2r:u");
if (R_SUCCEEDED(ret))
{
ret = Y2RU_DriverInitialize();
if (R_FAILED(ret)) svcCloseHandle(y2rHandle);
}
if (R_FAILED(ret)) AtomicDecrement(&y2rRefCount);
return ret;
}
Result nfcInit(void)
{
Result ret=0;
if (AtomicPostIncrement(&nfcRefCount)) return 0;
ret = srvGetServiceHandle(&nfcHandle, "nfc:u");
if (R_SUCCEEDED(ret))
{
ret = NFC_Initialize(0x02);
if (R_FAILED(ret)) svcCloseHandle(nfcHandle);
}
if (R_FAILED(ret)) AtomicDecrement(&nfcRefCount);
return ret;
}
Result CFGNOR_Initialize(u8 value)
{
Result ret = 0;
u32 *cmdbuf = getThreadCommandBuffer();
ret = srvGetServiceHandle(&CFGNOR_handle, "cfg:nor");
if(ret!=0)return ret;
cmdbuf[0] = 0x00010040;
cmdbuf[1] = (u32)value;
if((ret = svcSendSyncRequest(CFGNOR_handle))!=0)return ret;
ret = (Result)cmdbuf[1];
return ret;
}
Result udsInit(size_t sharedmem_size, const char *username)
{
Result ret=0;
u32 ndm_state = 0;
if (AtomicPostIncrement(&__uds_refcount)) return 0;
ret = ndmuInit();
if(R_SUCCEEDED(ret))
{
ndm_state = 1;
ret = ndmuEnterExclusiveState(EXCLUSIVE_STATE_LOCAL_COMMUNICATIONS);
if(R_SUCCEEDED(ret))
{
ndm_state = 2;
}
}
if(R_SUCCEEDED(ret))
{
ret = srvGetServiceHandle(&__uds_servhandle, "nwm::UDS");
if(R_SUCCEEDED(ret))
{
ret = uds_Initialize(sharedmem_size, username);
if (R_FAILED(ret))
{
svcCloseHandle(__uds_servhandle);
__uds_servhandle = 0;
}
}
}
if (R_FAILED(ret))
{
if(ndm_state)
{
if(ndm_state==2)ndmuLeaveExclusiveState();
ndmuExit();
}
AtomicDecrement(&__uds_refcount);
}
bind_allocbitmask = 0;
return ret;
}
