C++ CLEANUP函数代码示例

iMX27RtpInterface::~iMX27RtpInterface() {
	RTP_FUNCLOG;
	CLEANUP(m_pSendWrapper);
	CLEANUP(m_pReceiveWrapper);
#ifndef MINIMAL_MODE
	if ((Configuration::GetCfg()->GetIntVal("SendPacketsFromAnxbFile") || Configuration::GetCfg()->GetIntVal("SendPacketsFromPcapFile")) && !Configuration::GetCfg()->GetIntVal("RenderVideo")) {
		return;
	}
	pMutexLock scopedLock(m_VpuMutex);

	// De-initialize VPU hardware and release data structures/resources
	vpu_UnInit();
#endif
}

SendVideoWrapper::~SendVideoWrapper() {
	if (m_pEncoder) {
		m_pEncoder->m_pVCap = NULL;
		m_pEncoder->StopEncoding();
	}
	if (m_pCapturer) {
		m_pCapturer->StopCapturing();
	}

	CLEANUP(m_pSendRtpDump);
	CLEANUP(m_pSendAnxbDump);
	CLEANUP(m_pCapturer);
	CLEANUP(m_pEncoder);
}

int main(int ac, char **av)
{
	int lc, i;
	char *msg;
	struct timespec spec;
	clockid_t clocks[2] = { CLOCK_REALTIME, CLOCK_MONOTONIC };

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	TST_TOTAL = sizeof(clocks) / sizeof(clocks[0]);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		Tst_count = 0;

		for (i = 0; i < TST_TOTAL; i++) {
			TEST(syscall(__NR_clock_gettime, clocks[i], &spec));
			tst_resm((TEST_RETURN < 0 ? TFAIL | TTERRNO : TPASS),
				 "%s",
				 (TEST_RETURN == 0 ? "passed" : "failed"));
		}
	}

	CLEANUP();
	tst_exit();
}

bool SkypekitTestEngine::StopPlayback() {
	TI_FUNCLOG;

	CLEANUP(m_pReceiveWrapper);

	return true;
}

/*
 * child_fn1() - Inside container
*/
static int child_fn1(void *ttype)
{
	pid_t cpid, ppid;
	cpid = getpid();
	ppid = getppid();
	char mesg[] = "I was not killed !";
       	/* Child process closes up read side of pipe */
       	close(fd[0]);

	/* Comparing the values to make sure pidns is created correctly */
	if(( cpid == CHILD_PID) && ( ppid == PARENT_PID ) ) {
		tst_resm(TINFO, "PIDNS test is running inside container");
		kill(INIT_PID, SIGKILL);
		/* Verifying whether the container init is not killed, "
		 If so writing into the pipe created in the parent NS" */

        	/* Send "mesg" through the write side of pipe */
        	write(fd[1], mesg, (strlen(mesg)+1));
	}
	else {
		tst_resm(TFAIL, "got unexpected result of cpid=%d ppid=%d",
				cpid, ppid);
	}
	CLEANUP();
	close(fd[1]);
	tst_exit();
}

void *
read_from_pngfile(char * filename,
	void *(*alloc)(int w, int h, int bpp, void** datap))
{
	struct read_file_cleanup * clup;
	void * retval;

	VERBOSE(SYSTEM, "read bitmap data from png file %s\n",
			filename);

	FILE * fp = fopen(filename, "rb");
	if (NULL == fp) {
		WARNING(SYSTEM, "open file %s for read failed\n", filename);
		THROW(EXCEPTION_RESOURCE_LOST,
				"open file for read error\n");
	}

	clup = GC_TRIVAL_CALLOC(clup);
	assert(clup != NULL);
	clup->base.function = do_read_file_cleanup;

	struct png_reader * reader = &clup->reader;
	reader->io_ptr = fp;
	reader->read_fn = file_reader;
	reader->read_ptr = NULL;
	reader->info_ptr = NULL;

	make_cleanup(&clup->base);

	retval = do_png_read(reader, alloc);
	CLEANUP(&clup->base);
	return retval;
}

void
CAudioScrobbler::Handshake()
{
	std::string username="";
	for(unsigned int i = 0; i < Config->getLUsername().length(); i++) {
		username.append(1, tolower(Config->getLUsername().c_str()[i]));
	}
	std::string authtoken(md5sum((char*)"%s%s", username.c_str(), Config->getLPassword().c_str()));

	std::ostringstream query, sig;
	query << "method=auth.getMobileSession&username=" << Config->getLUsername() << "&authToken=" << authtoken << "&api_key=" << APIKEY;

	sig << "api_key" << APIKEY << "authToken" << authtoken << "methodauth.getMobileSessionusername" << Config->getLUsername() << SECRET;
	std::string sighash(md5sum((char*)"%s", sig.str().c_str()));

	query << "&api_sig=" << sighash;

	OpenURL(ROOTURL, query.str().c_str());

	if(_response.find("<lfm status=\"ok\">") != std::string::npos) {
		size_t start, end;
		start = _response.find("<key>") + 5;
		end = _response.find("</key>");
		_sessionid = _response.substr(start, end-start);
		iprintf("%s%s", "Last.fm handshake successful. SessionID: ", _sessionid.c_str());
		_authed = true;
	}
	else if(_response.find("<lfm status=\"failed\">") != std::string::npos) {
		CheckFailure(_response);
		exit(EXIT_FAILURE);
	}

	CLEANUP();
}

bool
CAudioScrobbler::Scrobble(centry_t* entry)
{
	bool retval = false;
	if(!_authed) {
		eprintf("Handshake hasn't been done yet.");
		Handshake();
		return retval;
	}
	iprintf("Scrobbling: %s - %s", entry->artist.c_str(), entry->title.c_str());
	
	OpenURL(ROOTURL, CreateScrobbleMessage(0, entry).c_str());
	if(_response.find("<lfm status=\"ok\">") != std::string::npos) {
		iprintf("%s", "Scrobbled successfully.");
		retval = true;
	}
	else if(_response.find("<lfm status=\"failed\">") != std::string::npos) {
		eprintf("%s%s", "Last.fm returned an error while scrobbling:\n", _response.c_str());
		if(CheckFailure(_response))
			Failure();
	}
	CLEANUP();

	return retval;
}

void cleanOptions(Options* inOptions)
/*
**  Clean up any open handles.
*/
{
    unsigned loop = 0;

    CLEANUP(inOptions->mInputName);
    CLEANUP(inOptions->mOutputName);
    if(NULL != inOptions->mOutput && stdout != inOptions->mOutput)
    {
        fclose(inOptions->mOutput);
    }

    memset(inOptions, 0, sizeof(Options));
}

 //***********************************************
 uint8_t ColYuvRgb::reset(uint32_t ww, uint32_t hh)
 {
 int flags=0;
	
    CLEANUP();
    FLAGS();
    PixelFormat fmt=TARGET_COLORSPACE;
    if(_inverted) fmt=ALTERNATE_COLORSPACE;
    if(!ww || !hh) return 0;

	if (_context)
		sws_freeContext((SwsContext *)_context);

	/* 
	FIXME: remove when ffmpeg is fixed
	Without SWS_ACCURATE_RND the quality is bad 
	for YUV->RGB (caused by libswscale r28700) 
	*/
	flags |= SWS_ACCURATE_RND;

	 _context=(void *)sws_getContext(
                      ww,hh,
                      PIX_FMT_YUV420P ,
                      ww,hh,
                      fmt,
                      flags, NULL, NULL,NULL);

    if(!_context) ADM_assert(0);
    w=ww;
    h=hh;
    return 1;
}

DWORD WINAPI   CardDeleteContext
               (
                  __inout PCARD_DATA  pCardData
               )
{
   DWORD             dwReturn    = 0;

   LogTrace(LOGTYPE_INFO, WHERE, "Enter API...");

   /********************/
   /* Check Parameters */
   /********************/
   if ( pCardData == NULL )
   {
      LogTrace(LOGTYPE_ERROR, WHERE, "Invalid parameter [pCardData]");
      CLEANUP(SCARD_E_INVALID_PARAMETER);
   }

   LogTrace(LOGTYPE_INFO, WHERE, "Context:[0x%08X]", pCardData->hSCardCtx);
   if (pCardData->pvVendorSpecific != NULL)
   {
	   pCardData->pfnCspFree(pCardData->pvVendorSpecific);
	   pCardData->pvVendorSpecific = NULL;
   }
	
cleanup:

   LogTrace(LOGTYPE_INFO, WHERE, "Exit API...");

   return (dwReturn);
}

int main(int argc, char *argv[])
{
	int status;
	pid_t pid;

	setup();

	pid = getpid();

	/* Container creation on PID namespace */
	TEST(do_clone_unshare_test(T_CLONE, CLONE_NEWPID, child_fn, NULL));
	if (TEST_RETURN == -1) {
		tst_brkm(TBROK | TTERRNO, CLEANUP, "clone failed");
	}

	sleep(1);
	if (wait(&status) < 0)
		tst_resm(TWARN, "parent: waitpid() failed.");

	if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
		tst_resm(TBROK, "container was terminated abnormally");

	CLEANUP();
	tst_exit();
}

CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID,
	CK_MECHANISM_TYPE type,
	CK_MECHANISM_INFO_PTR pInfo)
{
	CK_RV ret;
	log_trace(WHERE, "I: enter");

	if (p11_get_init() != BEIDP11_INITIALIZED)
	{
		log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
		return (CKR_CRYPTOKI_NOT_INITIALIZED);
	}		

	ret = p11_lock();
	if (ret != CKR_OK)
	{
		log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
		return ret;
	}

	log_trace(WHERE, "S: C_GetMechanismInfo(slot %d)", slotID);

	if (pInfo == NULL_PTR)
	{
		CLEANUP(CKR_ARGUMENTS_BAD);
	}

	/*ret = cal_get_mechanism_info(slotID, type, pInfo);
	if (ret != CKR_OK)
	{
		log_trace(WHERE, "E: p11_get_mechanism_info(slotid=%d) returns %d", slotID, ret);
		goto cleanup;
	}*/
    if (g_aseP11Handle == NULL)
    {
        log_trace(WHERE, "E: leave, CKR_CRYPTOKI_NOT_INITIALIZED - g_aseP11Handle is NULL");
        CLEANUP(CKR_ARGUMENTS_BAD);
    }

    ret = (pFunctions->C_GetMechanismInfo) ( slotID,  type, pInfo);


cleanup:        
	p11_unlock();
	log_trace(WHERE, "I: leave, ret = %i",ret);
	return ret;
}

DWORD WINAPI   CardQueryKeySizes
               (
                  __in      PCARD_DATA       pCardData,
                  __in      DWORD            dwKeySpec,
                  __in      DWORD            dwFlags,
                  __in      PCARD_KEY_SIZES  pKeySizes
               )
{
   DWORD             dwReturn = 0;

   LogTrace(LOGTYPE_INFO, WHERE, "Enter API...");

   /********************/
   /* Check Parameters */
   /********************/
   if ( pCardData == NULL )
   {
      LogTrace(LOGTYPE_ERROR, WHERE, "Invalid parameter [pCardData]");
      CLEANUP(SCARD_E_INVALID_PARAMETER);
   }
   if ( dwKeySpec != AT_SIGNATURE )
   {
      LogTrace(LOGTYPE_ERROR, WHERE, "Invalid parameter [dwKeySpec]");
      CLEANUP(SCARD_E_INVALID_PARAMETER);
   }
   if ( dwFlags != 0 )
   {
      LogTrace(LOGTYPE_ERROR, WHERE, "Invalid parameter [dwKeySpec]");
      CLEANUP(SCARD_E_INVALID_PARAMETER);
   }
   if ( pKeySizes == NULL )
   {
      LogTrace(LOGTYPE_ERROR, WHERE, "Invalid parameter [pKeySizes]");
      CLEANUP(SCARD_E_INVALID_PARAMETER);
   }

   pKeySizes->dwVersion           = CARD_KEY_SIZES_CURRENT_VERSION;
   pKeySizes->dwMinimumBitlen     = 1024;
   pKeySizes->dwDefaultBitlen     = 1024;
   pKeySizes->dwMaximumBitlen     = 1024;
   pKeySizes->dwIncrementalBitlen = 0;

cleanup:
   LogTrace(LOGTYPE_INFO, WHERE, "Exit API...");
   return(dwReturn);
}

int main(int argc, char *argv[])
{
	int ret, status, nbytes;
        char    readbuffer[80];

	pipe(fd);
	ret = do_clone_unshare_test(T_CLONE, CLONE_NEWPID, child_fn1, NULL);
	if ((wait(&status)) < 0) {
		tst_resm(TWARN, "wait() failed, skipping this test case");
		/* Cleanup & continue with next test case */
		CLEANUP();
	}
	if (ret == -1) {
		tst_resm(TFAIL, "clone() Failed, errno = %d :"
			" %s", ret, strerror(ret));
		/* Cleanup & continue with next test case */
		CLEANUP();
	}

	/* Parent process closes up write side of pipe */
	close(fd[1]);
	/* Read in a string from the pipe */
	nbytes = read(fd[0], readbuffer, sizeof(readbuffer));

	if (nbytes !=0 ) {
		tst_resm(TPASS, "Container init : %s", readbuffer);
	}
	else {
		tst_resm(TFAIL, "Container init is killed by SIGKILL !!!");
	}

	if (WTERMSIG(status)) {
		tst_resm(TFAIL, "Container init pid got killed by signal %d",
		WTERMSIG(status));
	}
        /* cleanup and exit */
	CLEANUP();
	close(fd[0]);

	tst_exit();

}	/* End main */