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 sslcContextInitSharedmem(sslcContext *context, u8 *buf, u32 size)
{
Result ret=0;
ret = svcCreateMemoryBlock(&context->sharedmem_handle, (u32)buf, size, 1, 3);
if(R_FAILED(ret))return ret;
ret = sslcipc_ContextInitSharedmem(context, size);
if(R_FAILED(ret))
{
svcCloseHandle(context->sharedmem_handle);
context->sharedmem_handle = 0;
}
return ret;
}
static Result uds_Initialize(u32 sharedmem_size, const char *username)
{
Result ret=0;
udsNodeInfo nodeinfo;
ret = udsGenerateNodeInfo(&nodeinfo, username);
if (R_FAILED(ret))return ret;
__uds_sharedmem_size = sharedmem_size;
__uds_sharedmem_handle = 0;
__uds_sharedmem_addr = memalign(0x1000, __uds_sharedmem_size);
if(__uds_sharedmem_addr==NULL)ret = -1;
if (R_SUCCEEDED(ret))
{
memset(__uds_sharedmem_addr, 0, __uds_sharedmem_size);
ret = svcCreateMemoryBlock(&__uds_sharedmem_handle, (u32)__uds_sharedmem_addr, __uds_sharedmem_size, 0x0, MEMPERM_READ | MEMPERM_WRITE);
}
if (R_SUCCEEDED(ret))ret = udsipc_InitializeWithVersion(&nodeinfo, __uds_sharedmem_handle, __uds_sharedmem_size, &__uds_connectionstatus_event);
if (R_FAILED(ret) && __uds_sharedmem_handle)
{
svcCloseHandle(__uds_sharedmem_handle);
__uds_sharedmem_handle = 0;
__uds_sharedmem_size = 0;
}
if(R_FAILED(ret) && __uds_sharedmem_addr)
{
free(__uds_sharedmem_addr);
__uds_sharedmem_addr = NULL;
}
if(R_FAILED(ret) && __uds_connectionstatus_event)
{
svcCloseHandle(__uds_connectionstatus_event);
__uds_connectionstatus_event = 0;
}
return ret;
}
Result socInit(u32* context_addr, u32 context_size)
{
Result ret = 0;
/* check that the "soc" device doesn't already exist */
int dev = FindDevice("soc:");
if(dev >= 0)
return -1;
ret = svcCreateMemoryBlock(&socMemhandle, (u32)context_addr, context_size, 0, 3);
if(ret != 0) return ret;
ret = srvGetServiceHandle(&SOCU_handle, "soc:U");
if(ret != 0)
{
svcCloseHandle(socMemhandle);
socMemhandle = 0;
return ret;
}
ret = SOCU_Initialize(socMemhandle, context_size);
if(ret != 0)
{
svcCloseHandle(socMemhandle);
svcCloseHandle(SOCU_handle);
socMemhandle = 0;
SOCU_handle = 0;
return ret;
}
/* add the "soc" device */
dev = AddDevice(&soc_devoptab);
if(dev < 0)
{
svcCloseHandle(socMemhandle);
svcCloseHandle(SOCU_handle);
socMemhandle = 0;
SOCU_handle = 0;
return dev;
}
return 0;
}
Result IRU_Initialize(u32 *sharedmem_addr, u32 sharedmem_size)
{
Result ret = 0;
if(iru_handle)return 0;
ret = srvGetServiceHandle(&iru_handle, "ir:u");
if(ret!=0)return ret;
ret = irucmd_Initialize();
if(ret!=0)return ret;
ret = svcCreateMemoryBlock(&iru_sharedmem_handle, (u32)sharedmem_addr, sharedmem_size, 1, 3);
if(ret!=0)return ret;
iru_sharedmem = sharedmem_addr;
iru_sharedmem_size = sharedmem_size;
return ret;
}
int execute_cmd(int sock, cmd_t* cmd) {
memset(&resp, 0, sizeof(resp));
resp.numarg=7;
switch(cmd->type) {
case 0: // exit
return 0xDEAD;
case 1: { // read u32
u32* p = (u32*) cmd->args[0];
resp.args[0] = *p;
break;
}
case 2: { // write u32
u32* p = (u32*) cmd->args[0];
*p = cmd->args[1];
break;
}
case 3: { // get tls
resp.args[0] = (u32) getThreadCommandBuffer();
break;
}
case 4: { // querymem
MemInfo info;
PageInfo flags;
memset(&info, 0, sizeof(info));
memset(&flags, 0, sizeof(flags));
int ret = svcQueryMemory(&info, &flags, cmd->args[0]);
resp.args[0] = ret;
resp.args[1] = info.base_addr;
resp.args[2] = info.size;
resp.args[3] = info.perm;
resp.args[4] = info.state;
resp.args[5] = flags.flags;
break;
}
case 5: { // creatememblock
u32 handle = 0;
int ret = svcCreateMemoryBlock(&handle, cmd->args[0],
cmd->args[1], cmd->args[2], cmd->args[3]);
resp.args[0] = ret;
resp.args[1] = handle;
break;
}
case 6: { // controlmem
u32 outaddr = 0;
int ret = svcControlMemory(&outaddr, cmd->args[0], cmd->args[1],
cmd->args[2], cmd->args[3], cmd->args[4]);
resp.args[0] = ret;
resp.args[1] = outaddr;
break;
}
case 7: { // getservicehandle
Handle handle = 0;
int ret = srvGetServiceHandle(&handle, (const char*) &cmd->args[0]);
resp.args[0] = ret;
resp.args[1] = handle;
break;
}
case 8: { // syncrequest
int ret = svcSendSyncRequest(cmd->args[0]);
resp.args[0] = ret;
break;
}
case 9: { // closehandle
int ret = svcCloseHandle(cmd->args[0]);
resp.args[0] = ret;
break;
}
case 10: { // getctrulibhandle
switch(cmd->args[0]) {
case 0: { // gsp_handle
extern Handle gspGpuHandle;
resp.args[0] = gspGpuHandle;
break;
}
}
break;
}
case 11: { // malloc/free
char* p = NULL;
switch(cmd->args[0]) {
case 0: { // normal-mem
p = malloc(0x100);
break;
}
case 1: { // linear-mem
p = linearAlloc(0x100);
break;
}
case 2: { // free normal-mem
free((void*)cmd->args[1]);
break;
}
case 3: { // free linear-mem
linearFree((void*)cmd->args[1]);
break;
}
}
resp.args[0] = (u32) p;
break;
}
case 12: { // enable/disable drawing
enable_draw = cmd->args[0];
break;
}
default:
return 0xDEAD; // unknown cmd
}
return 0;
}
SwkbdButton swkbdInputText(SwkbdState* swkbd, char* buf, size_t bufsize)
{
SwkbdExtra extra = swkbd->extra; // Struct copy
// Calculate sharedmem size
size_t sharedMemSize = 0;
sharedMemSize += (sizeof(u16)*(swkbd->max_text_len+1) + 3) &~ 3;
size_t dictOff = sharedMemSize;
sharedMemSize += (sizeof(SwkbdDictWord)*swkbd->dict_word_count + 3) &~ 3;
size_t statusOff = sharedMemSize;
sharedMemSize += swkbd->initial_status_offset >= 0 ? sizeof(SwkbdStatusData) : 0;
size_t learningOff = sharedMemSize;
sharedMemSize += swkbd->initial_learning_offset >= 0 ? sizeof(SwkbdLearningData) : 0;
if (swkbd->save_state_flags & BIT(0))
{
swkbd->status_offset = sharedMemSize;
sharedMemSize += sizeof(SwkbdStatusData);
}
if (swkbd->save_state_flags & BIT(1))
{
swkbd->learning_offset = sharedMemSize;
sharedMemSize += sizeof(SwkbdLearningData);
}
sharedMemSize = (sharedMemSize + 0xFFF) &~ 0xFFF;
swkbd->shared_memory_size = sharedMemSize;
// Allocate sharedmem
swkbdSharedMem = (char*)memalign(0x1000, sharedMemSize);
if (!swkbdSharedMem)
{
swkbd->result = SWKBD_OUTOFMEM;
return SWKBD_BUTTON_NONE;
}
// Create sharedmem block
Result res = svcCreateMemoryBlock(&swkbdSharedMemHandle, (u32)swkbdSharedMem, sharedMemSize, MEMPERM_READ|MEMPERM_WRITE, MEMPERM_READ|MEMPERM_WRITE);
if (R_FAILED(res))
{
free(swkbdSharedMem);
swkbd->result = SWKBD_OUTOFMEM;
return SWKBD_BUTTON_NONE;
}
// Copy stuff to shared mem
if (extra.initial_text)
{
swkbd->initial_text_offset = 0;
swkbdConvertToUTF16((u16*)swkbdSharedMem, extra.initial_text, swkbd->max_text_len);
}
if (extra.dict)
{
swkbd->dict_offset = dictOff;
memcpy(swkbdSharedMem+dictOff, extra.dict, sizeof(SwkbdDictWord)*swkbd->dict_word_count);
}
if (swkbd->initial_status_offset >= 0)
{
swkbd->initial_status_offset = statusOff;
memcpy(swkbdSharedMem+statusOff, extra.status_data, sizeof(SwkbdStatusData));
}
if (swkbd->initial_learning_offset >= 0)
{
swkbd->initial_learning_offset = learningOff;
memcpy(swkbdSharedMem+learningOff, extra.learning_data, sizeof(SwkbdLearningData));
}
if (extra.callback) swkbd->filter_flags |= SWKBD_FILTER_CALLBACK;
else swkbd->filter_flags &= ~SWKBD_FILTER_CALLBACK;
// Launch swkbd
memset(swkbd->reserved, 0, sizeof(swkbd->reserved));
if (extra.callback) aptSetMessageCallback(swkbdMessageCallback, &extra);
bool ret = aptLaunchLibraryApplet(APPID_SOFTWARE_KEYBOARD, swkbd, sizeof(*swkbd), swkbdSharedMemHandle);
if (extra.callback) aptSetMessageCallback(NULL, NULL);
svcCloseHandle(swkbdSharedMemHandle);
SwkbdButton button = SWKBD_BUTTON_NONE;
if (ret)
{
u16* text16 = (u16*)(swkbdSharedMem+swkbd->text_offset);
text16[swkbd->text_length] = 0;
swkbdConvertToUTF8(buf, text16, bufsize-1);
if (swkbd->save_state_flags & BIT(0)) memcpy(extra.status_data, swkbdSharedMem+swkbd->status_offset, sizeof(SwkbdStatusData));
if (swkbd->save_state_flags & BIT(1)) memcpy(extra.learning_data, swkbdSharedMem+swkbd->learning_offset, sizeof(SwkbdLearningData));
switch (swkbd->result)
{
case SWKBD_D1_CLICK0:
case SWKBD_D2_CLICK0:
button = SWKBD_BUTTON_LEFT;
break;
case SWKBD_D2_CLICK1:
button = SWKBD_BUTTON_MIDDLE;
break;
case SWKBD_D0_CLICK:
case SWKBD_D1_CLICK1:
case SWKBD_D2_CLICK2:
button = SWKBD_BUTTON_RIGHT;
break;
default:
break;
}
}
free(swkbdSharedMem);
return button;
}
