自学教程：C++ svcCloseHandle函数代码示例

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 exitsvoid __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(&currentHandle, 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(&currentHandle, 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);}

voidpxipmExit(void){    if (AtomicDecrement(&pxipmRefCount))        return;    svcCloseHandle(pxipmHandle);}