Result audinGetAudioInState(AudioInState *State) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 0;
Result rc = serviceIpcDispatch(&g_audinIAudioIn);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 state;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && State)
*State = resp->state;
}
return rc;
}
static Result action_paste_files_make_dst_directory(void* data, u32 index) {
paste_files_data* pasteData = (paste_files_data*) data;
Result res = 0;
char dstPath[FILE_PATH_MAX];
action_paste_files_get_dst_path(pasteData, index, dstPath);
if(R_SUCCEEDED(res = util_ensure_dir(pasteData->target->archive, dstPath))) {
char parentPath[FILE_PATH_MAX];
util_get_parent_path(parentPath, dstPath, FILE_PATH_MAX);
char baseDstPath[FILE_PATH_MAX];
if(pasteData->target->attributes & FS_ATTRIBUTE_DIRECTORY) {
strncpy(baseDstPath, pasteData->target->path, FILE_PATH_MAX);
} else {
util_get_parent_path(baseDstPath, pasteData->target->path, FILE_PATH_MAX);
}
if(strncmp(parentPath, baseDstPath, FILE_PATH_MAX) == 0) {
list_item* dstItem = NULL;
if(R_SUCCEEDED(res) && R_SUCCEEDED(task_create_file_item(&dstItem, pasteData->target->archive, dstPath))) {
linked_list_add(pasteData->items, dstItem);
}
}
}
return res;
}
Result FSCIA_Init(u64 titleid, FS_MediaType mediatype)
{
Result ret = 1;
debug_print("FSCIA_Init:\n");
if (!saveInitialized)
{
lowPath[0] = mediatype;
lowPath[1] = titleid; /// titleid & 0xFFFFFFFF
lowPath[2] = titleid >> 32; // (titleid >> 32) & 0xFFFFFFFF
debug_print(" > [0]: 0x%016lx\n", lowPath[0]);
debug_print(" > [1]: 0x%016lx\n", lowPath[1]);
debug_print(" > [2]: 0x%016lx\n", lowPath[2]);
ret = FSUSER_OpenArchive(&saveArchive, ARCHIVE_USER_SAVEDATA, (FS_Path) { PATH_BINARY, 12, lowPath });
r(" > FSUSER_OpenArchive: %lx\n", ret);
saveInitialized = R_SUCCEEDED(ret); // true
if (!saveInitialized)
{
ret = FSUSER_OpenArchive(&saveArchive, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, NULL));
r(" > FSUSER_OpenArchive: %lx\n", ret);
saveInitialized = R_SUCCEEDED(ret); // true
}
}
static Result task_data_op_check_running(data_op_data* data, u32 index, u32* srcHandle, u32* dstHandle) {
Result res = 0;
if(task_is_quit_all() || svcWaitSynchronization(data->cancelEvent, 0) == 0) {
res = R_APP_CANCELLED;
} else {
bool suspended = svcWaitSynchronization(task_get_suspend_event(), 0) != 0;
if(suspended) {
if(data->op == DATAOP_COPY && srcHandle != NULL && dstHandle != NULL && data->suspendTransfer != NULL && R_SUCCEEDED(res)) {
res = data->suspendTransfer(data->data, index, srcHandle, dstHandle);
}
if(data->suspend != NULL && R_SUCCEEDED(res)) {
res = data->suspend(data->data, index);
}
}
svcWaitSynchronization(task_get_pause_event(), U64_MAX);
if(suspended) {
if(data->restore != NULL && R_SUCCEEDED(res)) {
res = data->restore(data->data, index);
}
if(data->op == DATAOP_COPY && srcHandle != NULL && dstHandle != NULL && data->restoreTransfer != NULL && R_SUCCEEDED(res)) {
res = data->restoreTransfer(data->data, index, srcHandle, dstHandle);
}
}
}
return res;
}
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 audinInitialize(void)
{
atomicIncrement64(&g_refCnt);
if (serviceIsActive(&g_audinSrv))
return 0;
Result rc = 0;
rc = smGetService(&g_audinSrv, "audin:u");
// Setup the default device
if (R_SUCCEEDED(rc))
{
// Passing an empty device name will open the default "BuiltInHeadset"
char DeviceNameIn[DEVICE_NAME_LENGTH] = {0};
char DeviceNameOut[DEVICE_NAME_LENGTH] = {0};
// Open audio input device
rc = audinOpenAudioIn(DeviceNameIn, DeviceNameOut, DEFAULT_SAMPLE_RATE, DEFAULT_CHANNEL_COUNT, &g_sampleRate, &g_channelCount, &g_pcmFormat, &g_deviceState);
}
// Register global handle for buffer events
if (R_SUCCEEDED(rc))
rc = _audinRegisterBufferEvent(&g_audinBufferEventHandle);
if (R_FAILED(rc))
audinExit();
return rc;
}
static int loadTitleCodeSection(u64 progId, u8 *code, u32 size)
{
/* Here we look for "/luma/code_sections/[u64 titleID in hex, uppercase].bin"
If it exists it should be a decompressed binary code file */
char path[] = "/luma/code_sections/0000000000000000.bin";
progIdToStr(path + 35, progId);
IFile file;
Result ret = fileOpen(&file, ARCHIVE_SDMC, path, FS_OPEN_READ);
if(R_SUCCEEDED(ret))
{
u64 fileSize, total;
ret = IFile_GetSize(&file, &fileSize);
if(!R_SUCCEEDED(ret) || fileSize > size) return -1;
ret = IFile_Read(&file, &total, code, fileSize);
IFile_Close(&file);
if(!R_SUCCEEDED(ret)) return -1;
else if(total < fileSize) return -2; //Shouldn't happen
}
return ret;
}
static Result _audinRegisterBufferEvent(Handle *BufferEvent) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 4;
Result rc = serviceIpcDispatch(&g_audinIAudioIn);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && BufferEvent)
*BufferEvent = r.Handles[0];
}
return rc;
}
Result fsDirGetEntryCount(FsDir* d, u64* count) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 1;
Result rc = serviceIpcDispatch(&d->s);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 count;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && count) *count = resp->count;
}
return rc;
}
static Result action_paste_files_open_dst(void* data, u32 index, void* initialReadBlock, u64 size, u32* handle) {
paste_files_data* pasteData = (paste_files_data*) data;
Result res = 0;
char dstPath[FILE_PATH_MAX];
action_paste_files_get_dst_path(pasteData, index, dstPath);
FS_Path* fsPath = util_make_path_utf8(dstPath);
if(fsPath != NULL) {
Handle currHandle;
pasteData->currExists = R_SUCCEEDED(FSUSER_OpenFile(&currHandle, pasteData->target->archive, *fsPath, FS_OPEN_READ, 0));
if(pasteData->currExists) {
FSFILE_Close(currHandle);
} else {
res = FSUSER_CreateFile(pasteData->target->archive, *fsPath, 0, size);
}
if(R_SUCCEEDED(res)) {
res = FSUSER_OpenFile(handle, pasteData->target->archive, *fsPath, FS_OPEN_WRITE, 0);
}
util_free_path_utf8(fsPath);
} else {
res = R_FBI_OUT_OF_MEMORY;
}
return res;
}
Result fsFileGetSize(FsFile* f, u64* out) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 4;
Result rc = serviceIpcDispatch(&f->s);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 size;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && out) *out = resp->size;
}
return rc;
}
Result fsMountSdcard(FsFileSystem* out) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 18;
Result rc = serviceIpcDispatch(&g_fsSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
serviceCreate(&out->s, r.Handles[0]);
}
}
return rc;
}
Result fsOpenDataStorageByCurrentProcess(FsStorage* out) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 200;
Result rc = serviceIpcDispatch(&g_fsSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
serviceCreate(&out->s, r.Handles[0]);
}
}
return rc;
}
static Result action_paste_files_close_dst(void* data, u32 index, bool succeeded, u32 handle) {
paste_files_data* pasteData = (paste_files_data*) data;
Result res = 0;
if(R_SUCCEEDED(res = FSFILE_Close(handle))) {
char dstPath[FILE_PATH_MAX];
action_paste_files_get_dst_path(pasteData, index, dstPath);
char parentPath[FILE_PATH_MAX];
util_get_parent_path(parentPath, dstPath, FILE_PATH_MAX);
char baseDstPath[FILE_PATH_MAX];
if(pasteData->target->attributes & FS_ATTRIBUTE_DIRECTORY) {
strncpy(baseDstPath, pasteData->target->path, FILE_PATH_MAX);
} else {
util_get_parent_path(baseDstPath, pasteData->target->path, FILE_PATH_MAX);
}
if(strncmp(parentPath, baseDstPath, FILE_PATH_MAX) == 0) {
list_item* dstItem = NULL;
if(R_SUCCEEDED(task_create_file_item(&dstItem, pasteData->target->archive, dstPath, ((file_info*) ((list_item*) linked_list_get(&pasteData->contents, index))->data)->attributes & ~FS_ATTRIBUTE_READ_ONLY))) {
linked_list_add(pasteData->items, dstItem);
}
}
}
return res;
}
static u32 openLumaFile(IFile *file, const char *path)
{
Result res = fileOpen(file, ARCHIVE_SDMC, path, FS_OPEN_READ);
if(R_SUCCEEDED(res)) return ARCHIVE_SDMC;
//Returned if SD is not mounted
return (u32)res == 0xC88044AB && R_SUCCEEDED(fileOpen(file, ARCHIVE_NAND_RW, path, FS_OPEN_READ)) ? ARCHIVE_NAND_RW : 0;
}
static void loadCustomVerString(u16 *out, u32 *verStringSize, u32 currentNand)
{
static const char *paths[] = { "/puma/customversion_sys.txt",
"/puma/customversion_emu.txt",
"/puma/customversion_emu2.txt",
"/puma/customversion_emu3.txt",
"/puma/customversion_emu4.txt" };
IFile file;
if(R_SUCCEEDED(fileOpen(&file, ARCHIVE_SDMC, paths[currentNand], FS_OPEN_READ)))
{
u64 fileSize;
if(R_SUCCEEDED(IFile_GetSize(&file, &fileSize)) && fileSize <= 62)
{
u8 buf[fileSize];
u64 total;
if(R_SUCCEEDED(IFile_Read(&file, &total, buf, fileSize)))
{
static const u8 bom[] = {0xEF, 0xBB, 0xBF};
u32 finalSize = 0;
//Convert from UTF-8 to UTF-16 (Nintendo doesn't support 4-byte UTF-16, so 4-byte UTF-8 is unsupported)
for(u32 increase, fileSizeTmp = (u32)fileSize, i = (fileSizeTmp > 2 && memcmp(buf, bom, 3) == 0) ? 3 : 0;
i < fileSizeTmp && finalSize < 19; i += increase, finalSize++)
{
if((buf[i] & 0x80) == 0 && !(buf[i] == 0xA || buf[i] == 0xD))
{
increase = 1;
out[finalSize] = (u16)buf[i];
}
else if((buf[i] & 0xE0) == 0xC0 && i + 1 < fileSizeTmp && (buf[i + 1] & 0xC0) == 0x80)
{
increase = 2;
out[finalSize] = (u16)(((buf[i] & 0x1F) << 6) | (buf[i + 1] & 0x3F));
}
else if((buf[i] & 0xF0) == 0xE0 && i + 2 < fileSizeTmp && (buf[i + 1] & 0xC0) == 0x80 && (buf[i + 2] & 0xC0) == 0x80)
{
increase = 3;
out[finalSize] = (u16)(((buf[i] & 0xF) << 12) | ((buf[i + 1] & 0x3F) << 6) | (buf[i + 2] & 0x3F));
}
else break;
}
if(finalSize > 0)
{
if(finalSize > 5 && finalSize < 19) out[finalSize++] = 0;
*verStringSize = finalSize * 2;
}
}
}
IFile_Close(&file);
}
}
Result ndspInit(void)
{
Result rc = 0;
if (AtomicPostIncrement(&ndspRefCount)) return 0;
if (!componentBin && !ndspFindAndLoadComponent())
{
rc = MAKERESULT(RL_PERMANENT, RS_NOTFOUND, 41, RD_NOT_FOUND);
goto _fail0;
}
LightLock_Init(&ndspMutex);
ndspInitMaster();
ndspiInitChn();
rc = cfguInit();
if (R_SUCCEEDED(rc))
{
u8 outMode;
rc = CFGU_GetConfigInfoBlk2(sizeof(outMode), 0x70001, &outMode);
if (R_SUCCEEDED(rc))
ndspMaster.outputMode = outMode;
cfguExit();
}
rc = dspInit();
if (R_FAILED(rc)) return rc;
rc = ndspInitialize(false);
if (R_FAILED(rc)) goto _fail1;
rc = svcCreateEvent(&sleepEvent, 0);
if (R_FAILED(rc)) goto _fail2;
ndspThread = threadCreate(ndspThreadMain, 0x0, NDSP_THREAD_STACK_SIZE, 0x18, -2, true);
if (!ndspThread) goto _fail3;
aptHook(&aptCookie, ndspAptHook, NULL);
return 0;
_fail3:
svcCloseHandle(sleepEvent);
_fail2:
ndspFinalize(false);
_fail1:
dspExit();
if (componentFree)
{
free((void*)componentBin);
componentBin = NULL;
}
_fail0:
AtomicDecrement(&ndspRefCount);
return rc;
}
static int loadTitleLocaleConfig(u64 progId, u8 *regionId, u8 *languageId)
{
/* Here we look for "/luma/locales/[u64 titleID in hex, uppercase].txt"
If it exists it should contain, for example, "EUR IT" */
char path[] = "/luma/locales/0000000000000000.txt";
u32 i = 29;
while(progId)
{
static const char hexDigits[] = "0123456789ABCDEF";
path[i--] = hexDigits[(u32)(progId & 0xF)];
progId >>= 4;
}
IFile file;
Result ret = fileOpen(&file, ARCHIVE_SDMC, path, FS_OPEN_READ);
if(R_SUCCEEDED(ret))
{
char buf[6];
u64 total;
ret = IFile_Read(&file, &total, buf, 6);
IFile_Close(&file);
if(!R_SUCCEEDED(ret) || total < 6) return -1;
for(u32 i = 0; i < 7; ++i)
{
static const char *regions[] = {"JPN", "USA", "EUR", "AUS", "CHN", "KOR", "TWN"};
if(memcmp(buf, regions[i], 3) == 0)
{
*regionId = (u8)i;
break;
}
}
for(u32 i = 0; i < 12; ++i)
{
static const char *languages[] = {"JP", "EN", "FR", "DE", "IT", "ES", "ZH", "KO", "NL", "PT", "RU", "TW"};
if(memcmp(buf + 4, languages[i], 2) == 0)
{
*languageId = (u8)i;
break;
}
}
}
return ret;
}
static Result task_populate_pending_titles_from(populate_pending_titles_data* data, FS_MediaType mediaType) {
Result res = 0;
u32 pendingTitleCount = 0;
if(R_SUCCEEDED(res = AM_GetPendingTitleCount(&pendingTitleCount, mediaType, AM_STATUS_MASK_INSTALLING | AM_STATUS_MASK_AWAITING_FINALIZATION))) {
u64* pendingTitleIds = (u64*) calloc(pendingTitleCount, sizeof(u64));
if(pendingTitleIds != NULL) {
if(R_SUCCEEDED(res = AM_GetPendingTitleList(&pendingTitleCount, pendingTitleCount, mediaType, AM_STATUS_MASK_INSTALLING | AM_STATUS_MASK_AWAITING_FINALIZATION, pendingTitleIds))) {
qsort(pendingTitleIds, pendingTitleCount, sizeof(u64), util_compare_u64);
AM_PendingTitleEntry* pendingTitleInfos = (AM_PendingTitleEntry*) calloc(pendingTitleCount, sizeof(AM_PendingTitleEntry));
if(pendingTitleInfos != NULL) {
if(R_SUCCEEDED(res = AM_GetPendingTitleInfo(pendingTitleCount, mediaType, pendingTitleIds, pendingTitleInfos))) {
for(u32 i = 0; i < pendingTitleCount && i < data->max; i++) {
if(task_is_quit_all() || svcWaitSynchronization(data->cancelEvent, 0) == 0) {
break;
}
pending_title_info* pendingTitleInfo = (pending_title_info*) calloc(1, sizeof(pending_title_info));
if(pendingTitleInfo != NULL) {
pendingTitleInfo->mediaType = mediaType;
pendingTitleInfo->titleId = pendingTitleIds[i];
pendingTitleInfo->version = pendingTitleInfos[i].version;
list_item* item = &data->items[*data->count];
snprintf(item->name, NAME_MAX, "%016llX", pendingTitleIds[i]);
if(mediaType == MEDIATYPE_NAND) {
item->rgba = COLOR_NAND;
} else if(mediaType == MEDIATYPE_SD) {
item->rgba = COLOR_SD;
}
item->data = pendingTitleInfo;
(*data->count)++;
}
}
}
free(pendingTitleInfos);
} else {
res = MAKERESULT(RL_PERMANENT, RS_INVALIDSTATE, 254, RD_OUT_OF_MEMORY);
}
}
free(pendingTitleIds);
} else {
res = MAKERESULT(RL_PERMANENT, RS_INVALIDSTATE, 254, RD_OUT_OF_MEMORY);
}
}
return res;
}
Result fsOpenSaveDataIterator(FsSaveDataIterator* out, s32 SaveDataSpaceId) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
struct {
u64 magic;
u64 cmd_id;
u8 SaveDataSpaceId;
} *raw2;
if (SaveDataSpaceId == FsSaveDataSpaceId_All) {
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 60;
}
else {
raw2 = ipcPrepareHeader(&c, sizeof(*raw2));
raw2->magic = SFCI_MAGIC;
raw2->cmd_id = 61;
raw2->SaveDataSpaceId = SaveDataSpaceId;
}
Result rc = serviceIpcDispatch(&g_fsSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
serviceCreate(&out->s, r.Handles[0]);
}
}
return rc;
}
static void loadTitleLocaleConfig(u64 progId, u8 *regionId, u8 *languageId)
{
/* Here we look for "/puma/locales/[u64 titleID in hex, uppercase].txt"
If it exists it should contain, for example, "EUR IT" */
char path[] = "/puma/locales/0000000000000000.txt";
progIdToStr(path + 29, progId);
IFile file;
if(R_SUCCEEDED(fileOpen(&file, ARCHIVE_SDMC, path, FS_OPEN_READ)))
{
u64 fileSize;
if(R_SUCCEEDED(IFile_GetSize(&file, &fileSize)) && fileSize > 5 && fileSize < 9)
{
char buf[fileSize];
u64 total;
if(R_SUCCEEDED(IFile_Read(&file, &total, buf, fileSize)))
{
for(u32 i = 0; i < 7; i++)
{
static const char *regions[] = {"JPN", "USA", "EUR", "AUS", "CHN", "KOR", "TWN"};
if(memcmp(buf, regions[i], 3) == 0)
{
*regionId = (u8)i;
break;
}
}
for(u32 i = 0; i < 12; i++)
{
static const char *languages[] = {"JP", "EN", "FR", "DE", "IT", "ES", "ZH", "KO", "NL", "PT", "RU", "TW"};
if(memcmp(buf + 4, languages[i], 2) == 0)
{
*languageId = (u8)i;
break;
}
}
}
}
IFile_Close(&file);
}
}
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;
}
static void action_paste_files_update(ui_view* view, void* data, float* progress, char* text) {
paste_files_data* pasteData = (paste_files_data*) data;
if(pasteData->pasteInfo.finished) {
FSUSER_ControlArchive(pasteData->target->archive, ARCHIVE_ACTION_COMMIT_SAVE_DATA, NULL, 0, NULL, 0);
linked_list_sort(pasteData->items, util_compare_file_infos);
ui_pop();
info_destroy(view);
if(R_SUCCEEDED(pasteData->pasteInfo.result)) {
prompt_display("Success", "Contents pasted.", COLOR_TEXT, false, NULL, NULL, NULL);
}
action_paste_files_free_data(pasteData);
return;
}
if((hidKeysDown() & KEY_B) && !pasteData->pasteInfo.finished) {
svcSignalEvent(pasteData->pasteInfo.cancelEvent);
}
*progress = pasteData->pasteInfo.currTotal != 0 ? (float) ((double) pasteData->pasteInfo.currProcessed / (double) pasteData->pasteInfo.currTotal) : 0;
snprintf(text, PROGRESS_TEXT_MAX, "%lu / %lu\n%.2f %s / %.2f %s", pasteData->pasteInfo.processed, pasteData->pasteInfo.total, util_get_display_size(pasteData->pasteInfo.currProcessed), util_get_display_size_units(pasteData->pasteInfo.currProcessed), util_get_display_size(pasteData->pasteInfo.currTotal), util_get_display_size_units(pasteData->pasteInfo.currTotal));
}
Result acWaitInternetConnection(void)
{
Result ret = 0;
u32 status = 0;
while(R_SUCCEEDED(ret = ACU_GetWifiStatus(&status)) && status == 0);
return ret;
}
Result udsGetApplicationData(void *buf, size_t size, size_t *actual_size)
{
u32* cmdbuf=getThreadCommandBuffer();
u32 saved_threadstorage[2];
cmdbuf[0]=IPC_MakeHeader(0x11,1,0); // 0x110040
cmdbuf[1]=size;
u32 * staticbufs = getThreadStaticBuffers();
saved_threadstorage[0] = staticbufs[0];
saved_threadstorage[1] = staticbufs[1];
staticbufs[0] = IPC_Desc_StaticBuffer(size,0);
staticbufs[1] = (u32)buf;
Result ret=0;
ret=svcSendSyncRequest(__uds_servhandle);
staticbufs[0] = saved_threadstorage[0];
staticbufs[1] = saved_threadstorage[1];
if(R_FAILED(ret))return ret;
ret = cmdbuf[1];
if(R_SUCCEEDED(ret))
{
if(actual_size)*actual_size = cmdbuf[2];
}
return ret;
}
std::tuple<Result, MovedHandle> ProcessManagerService::create_process(u64 flags, u64 index, CopiedHandle reslimit_h) {
Result rc;
Registration::TidSid tid_sid;
LaunchQueue::LaunchItem *launch_item;
char nca_path[FS_MAX_PATH] = {0};
Handle process_h = 0;
fprintf(stderr, "CreateProcess(%016lx, %016lx, %08x);\n", flags, index, reslimit_h.handle);
rc = Registration::GetRegisteredTidSid(index, &tid_sid);
if (R_FAILED(rc)) {
return {rc, MovedHandle{process_h}};
}
rc = ContentManagement::ResolveContentPathForTidSid(nca_path, &tid_sid);
if (R_FAILED(rc)) {
return {rc, MovedHandle{process_h}};
}
launch_item = LaunchQueue::get_item(tid_sid.title_id);
rc = ProcessCreation::CreateProcess(&process_h, index, nca_path, launch_item, flags, reslimit_h.handle);
if (R_SUCCEEDED(rc)) {
ContentManagement::SetCreatedTitle(tid_sid.title_id);
}
return {rc, MovedHandle{process_h}};
}
Result fsldrSetCurrentProcess() {
IpcCommand c;
ipcInitialize(&c);
ipcSendPid(&c);
struct {
u64 magic;
u64 cmd_id;
u64 unk;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 2;
raw->unk = 0;
Result rc = serviceIpcDispatch(&g_fsldrSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
}
static void aptHookFunc(APT_HookType hookType, void *param) {
OSystem_3DS *osys = (OSystem_3DS *)g_system;
switch (hookType) {
case APTHOOK_ONSUSPEND:
case APTHOOK_ONSLEEP:
if (g_engine)
g_engine->pauseEngine(true);
osys->sleeping = true;
if (R_SUCCEEDED(gspLcdInit())) {
GSPLCD_PowerOnBacklight(GSPLCD_SCREEN_BOTH);
gspLcdExit();
}
break;
case APTHOOK_ONRESTORE:
case APTHOOK_ONWAKEUP:
if (g_engine)
g_engine->pauseEngine(false);
osys->sleeping = false;
loadConfig();
break;
default: {
Common::StackLock lock(*eventMutex);
Common::Event event;
event.type = Common::EVENT_QUIT;
g_system->getEventManager()->pushEvent(event);
}
}
}
Result smMitMUninstall(const char *name) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 service_name;
u64 reserved;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 65001;
raw->service_name = smEncodeName(name);
Result rc = ipcDispatch(g_smMitmHandle);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
}
void updateSystemLanguage(void)
{
cfguInit();
Result ret;
u8 language = 0;
ret = CFGU_GetConfigInfoBlk2(1, 0xA0002, &language);
if (R_SUCCEEDED(ret))
{
switch (language)
{
case CFG_LANGUAGE_JP: userlang = LANGUAGE_JP; break;
case CFG_LANGUAGE_FR: userlang = LANGUAGE_FR; break;
case CFG_LANGUAGE_IT: userlang = LANGUAGE_IT; break;
case CFG_LANGUAGE_DE: userlang = LANGUAGE_DE; break;
case CFG_LANGUAGE_ES: userlang = LANGUAGE_ES; break;
case CFG_LANGUAGE_KO: userlang = LANGUAGE_KR; break;
default: userlang = LANGUAGE_EN;
}
}
cfguExit();
}
