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

void ZoomNavigator::OnPreviewClicked(wxMouseEvent& e){    IEditor* curEditor = m_mgr->GetActiveEditor();    // user clicked on the preview    CHECK_CONDITION(m_startupCompleted);    CHECK_CONDITION(curEditor);    CHECK_CONDITION(m_enabled);    // the first line is taken from the preview    int pos = m_text->PositionFromPoint(e.GetPosition());    if(pos == wxSTC_INVALID_POSITION) {        return;    }    int first = m_text->LineFromPosition(pos);    int nLinesOnScreen = curEditor->GetCtrl()->LinesOnScreen();    first -= (nLinesOnScreen / 2);    if(first < 0) first = 0;    // however, the last line is set according to the actual editor    int last = nLinesOnScreen + first;    PatchUpHighlights(first, last);    curEditor->GetCtrl()->SetFirstVisibleLine(first);    curEditor->SetCaretAt(curEditor->PosFromLine(first + (nLinesOnScreen / 2)));    // reset the from/last members to avoid unwanted movements in the 'OnTimer' function    m_markerFirstLine = curEditor->GetCtrl()->GetFirstVisibleLine();    m_markerLastLine = m_markerFirstLine + curEditor->GetCtrl()->LinesOnScreen();}

const config_file::value& config_file::value::operator[](const char* rec_name) const{  CHECK_CONDITION(this->type_ == RECORD, "Not a record type");  mapci it = record_.find(rec_name);  CHECK_CONDITION(it != this->record_.end(), "Record not found");  return it->second;}

bool AES_KW_Encrypt(COSE_RecipientInfo * pcose, const byte * pbKeyIn, int cbitKey, const byte *  pbContent, int  cbContent, cose_errback * perr){	byte  *pbOut = NULL;	AES_KEY key;#ifdef USE_CBOR_CONTEXT	cn_cbor_context * context = &pcose->m_encrypt.m_message.m_allocContext;#endif	cn_cbor * cnTmp = NULL;	pbOut = COSE_CALLOC(cbContent + 8, 1, context);	CHECK_CONDITION(AES_set_encrypt_key(pbKeyIn, cbitKey, &key) == 0, COSE_ERR_CRYPTO_FAIL);	CHECK_CONDITION(AES_wrap_key(&key, NULL, pbOut, pbContent, cbContent), COSE_ERR_CRYPTO_FAIL);	cnTmp = cn_cbor_data_create(pbOut, (int)cbContent + 8, CBOR_CONTEXT_PARAM_COMMA NULL);	CHECK_CONDITION(cnTmp != NULL, COSE_ERR_CBOR);	pbOut = NULL;	CHECK_CONDITION(_COSE_array_replace(&pcose->m_encrypt.m_message, cnTmp, INDEX_BODY, CBOR_CONTEXT_PARAM_COMMA NULL), COSE_ERR_CBOR);	cnTmp = NULL;	return true;errorReturn:	COSE_FREE(cnTmp, context);	if (pbOut != NULL) COSE_FREE(pbOut, context);	return false;}

// Function Specification//// Name: errlTestTime//// Description: errlTestTime//// End Function Specificationuint32_t errlTestTime(){    uint32_t l_rc = 0;    do    {        ERRL_DBG("START");        errlHndl_t l_handle = NULL;        uint64_t l_start = 0;        uint64_t l_end = 0;        /****************************************************/        // Check timeStamp        // Create one log        l_start = ssx_timebase_get();        l_handle = createErrl( 0x1716, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_CALLHOME_DATA, g_trac_inf, 128, 0x1, 0x2);        CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);        // check time stamp        errlHndl_t l_handle2 = l_handle;        commitErrl( &l_handle );        l_end = ssx_timebase_get();        CHECK_CONDITION( (l_handle2->iv_userDetails.iv_timeStamp >= l_start) &&                         (l_handle2->iv_userDetails.iv_timeStamp <= l_end ), l_rc);        deleteErrl(&l_handle2);        ERRL_DBG("END /n");    }while(0);    return l_rc;}

bool ECDSA_Sign(COSE * pSigner, int index, const cn_cbor * pKey, int cbitDigest, const byte * rgbToSign, size_t cbToSign, cose_errback * perr){	EC_KEY * eckey = NULL;	byte rgbDigest[EVP_MAX_MD_SIZE];	unsigned int cbDigest = sizeof(rgbDigest);	byte  * pbSig = NULL;	const EVP_MD * digest;#ifdef USE_CBOR_CONTEXT	cn_cbor_context * context = &pSigner->m_allocContext;#endif	cn_cbor * p = NULL;	ECDSA_SIG * psig = NULL;	cn_cbor_errback cbor_error;	int cbR;	byte rgbSig[66];	int cb;		eckey = ECKey_From(pKey, &cbR, perr);	if (eckey == NULL) {	errorReturn:		if (p != NULL) CN_CBOR_FREE(p, context);		if (eckey != NULL) EC_KEY_free(eckey);		return false;	}	switch (cbitDigest) {	case 256: digest = EVP_sha256(); break;	case 512: digest = EVP_sha512(); break;	case 384: digest = EVP_sha384(); break;	default:		FAIL_CONDITION(COSE_ERR_INVALID_PARAMETER);	}	EVP_Digest(rgbToSign, cbToSign, rgbDigest, &cbDigest, digest, NULL);	psig = ECDSA_do_sign(rgbDigest, cbDigest, eckey);	CHECK_CONDITION(psig != NULL, COSE_ERR_CRYPTO_FAIL);	pbSig = COSE_CALLOC(cbR, 2, context);	CHECK_CONDITION(pbSig != NULL, COSE_ERR_OUT_OF_MEMORY);	cb = BN_bn2bin(psig->r, rgbSig);	CHECK_CONDITION(cb <= cbR, COSE_ERR_INVALID_PARAMETER);	memcpy(pbSig + cbR - cb, rgbSig, cb);	cb = BN_bn2bin(psig->s, rgbSig);	CHECK_CONDITION(cb <= cbR, COSE_ERR_INVALID_PARAMETER);	memcpy(pbSig + 2*cbR - cb, rgbSig, cb);	p = cn_cbor_data_create(pbSig, cbR*2, CBOR_CONTEXT_PARAM_COMMA &cbor_error);	CHECK_CONDITION_CBOR(p != NULL, cbor_error);	CHECK_CONDITION(_COSE_array_replace(pSigner, p, index, CBOR_CONTEXT_PARAM_COMMA NULL), COSE_ERR_CBOR);		return true;}

bool COSE_Enveloped_SetContent(HCOSE_ENVELOPED h, const byte * rgb, size_t cb, cose_errback * perr){	CHECK_CONDITION(IsValidEnvelopedHandle(h), COSE_ERR_INVALID_HANDLE);	CHECK_CONDITION(rgb != NULL, COSE_ERR_INVALID_PARAMETER);	return _COSE_Enveloped_SetContent((COSE_Enveloped *)h, rgb, cb, perr);errorReturn:	return false;}

bool COSE_Enveloped_SetExternal(HCOSE_ENVELOPED hcose, const byte * pbExternalData, size_t cbExternalData, cose_errback * perr){	CHECK_CONDITION(IsValidEnvelopedHandle(hcose), COSE_ERR_INVALID_HANDLE)	CHECK_CONDITION((pbExternalData != NULL) || (cbExternalData == 0), COSE_ERR_INVALID_PARAMETER);	return _COSE_SetExternal(&((COSE_Enveloped *)hcose)->m_message, pbExternalData, cbExternalData, perr);errorReturn:	return false;}

bool COSE_Enveloped_map_put_int(HCOSE_ENVELOPED h, int key, cn_cbor * value, int flags, cose_errback * perr){	CHECK_CONDITION(IsValidEnvelopedHandle(h), COSE_ERR_INVALID_HANDLE);	CHECK_CONDITION(value != NULL, COSE_ERR_INVALID_PARAMETER);	return _COSE_map_put(&((COSE_Enveloped *)h)->m_message, key, value, flags, perr);errorReturn:	return false;}

bool COSE_Encrypt_encrypt(HCOSE_ENCRYPT h, const byte * pbKey, size_t cbKey, cose_errback * perr){	CHECK_CONDITION(IsValidEncryptHandle(h), COSE_ERR_INVALID_HANDLE);	CHECK_CONDITION(pbKey != NULL, COSE_ERR_INVALID_PARAMETER);	return _COSE_Enveloped_encrypt((COSE_Encrypt *)h, pbKey, cbKey, "Encrypt0", perr);errorReturn:	return false;}

bool _COSE_Encrypt_Build_AAD(COSE * pMessage, byte ** ppbAAD, size_t * pcbAAD, const char * szContext, cose_errback * perr){#ifdef USE_CBOR_CONTEXT	cn_cbor_context * context = &pMessage->m_allocContext;#endif	cn_cbor_errback cbor_error;	byte  * pbAuthData;	size_t cbAuthData;	cn_cbor * pAuthData;	cn_cbor * pItem;	cn_cbor * ptmp = NULL;	//  Build authenticated data	pbAuthData = NULL;	pAuthData = cn_cbor_array_create(CBOR_CONTEXT_PARAM_COMMA &cbor_error);	CHECK_CONDITION_CBOR(pAuthData != NULL, cbor_error);	ptmp = cn_cbor_string_create(szContext, CBOR_CONTEXT_PARAM_COMMA &cbor_error);	CHECK_CONDITION_CBOR(ptmp != NULL, cbor_error);	CHECK_CONDITION_CBOR(cn_cbor_array_append(pAuthData, ptmp, &cbor_error), cbor_error);	ptmp = NULL;	pItem = _COSE_arrayget_int(pMessage, INDEX_PROTECTED);	CHECK_CONDITION(pItem != NULL, COSE_ERR_INVALID_PARAMETER);	if ((pItem->length == 1) && (pItem->v.bytes[0] == 0xa0)) {		ptmp = cn_cbor_data_create(NULL, 0, CBOR_CONTEXT_PARAM_COMMA &cbor_error);	}	else {		ptmp = cn_cbor_data_create(pItem->v.bytes, (int)pItem->length, CBOR_CONTEXT_PARAM_COMMA &cbor_error);	}	CHECK_CONDITION_CBOR(ptmp != NULL, cbor_error);	CHECK_CONDITION_CBOR(cn_cbor_array_append(pAuthData, ptmp, &cbor_error), cbor_error);	ptmp = NULL;	ptmp = cn_cbor_data_create(pMessage->m_pbExternal, (int) pMessage->m_cbExternal, CBOR_CONTEXT_PARAM_COMMA &cbor_error);	CHECK_CONDITION_CBOR(ptmp != NULL, cbor_error);	CHECK_CONDITION_CBOR(cn_cbor_array_append(pAuthData, ptmp, &cbor_error), cbor_error);	ptmp = NULL;	cbAuthData = cn_cbor_encoder_write(RgbDontUse, 0, sizeof(RgbDontUse), pAuthData);	pbAuthData = (byte *)COSE_CALLOC(cbAuthData, 1, context);	CHECK_CONDITION(pbAuthData != NULL, COSE_ERR_OUT_OF_MEMORY);	CHECK_CONDITION((size_t)cn_cbor_encoder_write(pbAuthData, 0, cbAuthData, pAuthData) == cbAuthData, COSE_ERR_CBOR);	*ppbAAD = pbAuthData;	*pcbAAD = cbAuthData;	return true;errorReturn:	if (pbAuthData != NULL) COSE_FREE(pbAuthData, context);	if (ptmp != NULL) CN_CBOR_FREE(ptmp, NULL);	if (pAuthData != NULL) CN_CBOR_FREE(pAuthData, context);	return false;}

bool COSE_Enveloped_encrypt(HCOSE_ENVELOPED h, cose_errback * perr){	COSE_Enveloped * pcose = (COSE_Enveloped *)h;	CHECK_CONDITION(IsValidEnvelopedHandle(h), COSE_ERR_INVALID_HANDLE);	CHECK_CONDITION(pcose->m_recipientFirst != NULL, COSE_ERR_INVALID_HANDLE);	return _COSE_Enveloped_encrypt(pcose, NULL, 0, "Encrypt", perr);errorReturn:	return false;}

TEST(ModelBase, SimpleModelCreation){	Model model;	CHECK_CONDITION( model.root() == nullptr );	TestNodes::BinaryNode* root = dynamic_cast<TestNodes::BinaryNode*> (model.createRoot("BinaryNode"));	CHECK_CONDITION( model.root() == root );	CHECK_CONDITION( root->model() == &model );	CHECK_CONDITION( root->name()->model() == &model );}

TEST(OOModel, SimpleClassTest){	Model::Model model;	Class* root = dynamic_cast<Class*> (model.createRoot("Class"));	CHECK_CONDITION(root != nullptr);	CHECK_CONDITION(root->name().isEmpty());	model.beginModification(root, "setName");	root->setName("Test");	model.endModification();	CHECK_STR_EQUAL("Test", root->name());}

pipeline_data_queue::~pipeline_data_queue(){  while(!free_list_.empty()){    delete free_list_.front();    free_list_.pop_front();  }  while(!active_queue_.empty()){    delete active_queue_.front();    active_queue_.pop_front();  }  CHECK_CONDITION(active_queue_.empty(), "active_queue_ not properly destroyed");  CHECK_CONDITION(free_list_.empty(), "free_list_ not properly destroyed");}

bool AES_CBC_MAC_Validate(COSE_MacMessage * pcose, int TSize, const byte * pbKey, size_t cbKey, const byte * pbAuthData, size_t cbAuthData, cose_errback * perr){	const EVP_CIPHER * pcipher = NULL;	EVP_CIPHER_CTX ctx;	int cbOut;	byte rgbIV[16] = { 0 };	byte rgbTag[16] = { 0 };	bool f = false;	unsigned int i;	switch (cbKey*8) {	case 128:		pcipher = EVP_aes_128_cbc();		break;	case 256:		pcipher = EVP_aes_256_cbc();		break;	default:		FAIL_CONDITION(COSE_ERR_INVALID_PARAMETER);	}	//  Setup and run the OpenSSL code	EVP_CIPHER_CTX_init(&ctx);	CHECK_CONDITION(EVP_EncryptInit_ex(&ctx, pcipher, NULL, pbKey, rgbIV), COSE_ERR_CRYPTO_FAIL);	TSize /= 8;	for (i = 0; i < (unsigned int) cbAuthData / 16; i++) {		CHECK_CONDITION(EVP_EncryptUpdate(&ctx, rgbTag, &cbOut, pbAuthData+(i*16), 16), COSE_ERR_CRYPTO_FAIL);	}	if (cbAuthData % 16 != 0) {		CHECK_CONDITION(EVP_EncryptUpdate(&ctx, rgbTag, &cbOut, pbAuthData + (i * 16), cbAuthData % 16), COSE_ERR_CRYPTO_FAIL);		CHECK_CONDITION(EVP_EncryptUpdate(&ctx, rgbTag, &cbOut, rgbIV, 16 - (cbAuthData % 16)), COSE_ERR_CRYPTO_FAIL);	}	cn_cbor * cn = _COSE_arrayget_int(&pcose->m_message, INDEX_MAC_TAG);	CHECK_CONDITION(cn != NULL, COSE_ERR_CBOR);	for (i = 0; i < (unsigned int)TSize; i++) f |= (cn->v.bytes[i] != rgbTag[i]);	EVP_CIPHER_CTX_cleanup(&ctx);	return !f;errorReturn:	EVP_CIPHER_CTX_cleanup(&ctx);	return false;}

bool ECDSA_Verify(COSE * pSigner, int index, const cn_cbor * pKey, int cbitDigest, const byte * rgbToSign, size_t cbToSign, cose_errback * perr){	EC_KEY * eckey = NULL;	byte rgbDigest[EVP_MAX_MD_SIZE];	unsigned int cbDigest = sizeof(rgbDigest);	const EVP_MD * digest;#ifdef USE_CBOR_CONTEXT	cn_cbor_context * context = &pSigner->m_allocContext;#endif	cn_cbor * p = NULL;	ECDSA_SIG sig = { NULL, NULL };	int cbR;	cn_cbor * pSig;	size_t cbSignature;	eckey = ECKey_From(pKey, &cbR, perr);	if (eckey == NULL) {	errorReturn:		if (sig.r != NULL) BN_free(sig.r);		if (sig.s != NULL) BN_free(sig.s);		if (p != NULL) CN_CBOR_FREE(p, context);		if (eckey != NULL) EC_KEY_free(eckey);		return false;	}	switch (cbitDigest) {	case 256: digest = EVP_sha256(); break;	case 512: digest = EVP_sha512(); break;	case 384: digest = EVP_sha384(); break;	default:		FAIL_CONDITION(COSE_ERR_INVALID_PARAMETER);	}	EVP_Digest(rgbToSign, cbToSign, rgbDigest, &cbDigest, digest, NULL);	pSig = _COSE_arrayget_int(pSigner, index);	CHECK_CONDITION(pSig != NULL, CN_CBOR_ERR_INVALID_PARAMETER);	cbSignature = pSig->length;	CHECK_CONDITION(cbSignature / 2 == cbR, COSE_ERR_INVALID_PARAMETER);	sig.r = BN_bin2bn(pSig->v.bytes,(int) cbSignature/2, NULL);	sig.s = BN_bin2bn(pSig->v.bytes+cbSignature/2, (int) cbSignature/2, NULL);	CHECK_CONDITION(ECDSA_do_verify(rgbDigest, cbDigest, &sig, eckey) == 1, COSE_ERR_CRYPTO_FAIL);	BN_free(sig.r);	BN_free(sig.s);	if (eckey != NULL) EC_KEY_free(eckey);	return true;}

/////////////////////////////////////////////////////////////////////////////////// ConstructWriterDefinition/////////////////////////////////////////////////////////////////////////////////bool ConstructWriterDefinition(    __in    IVssCreateExpressWriterMetadata *pMetadata){    HRESULT hr              = S_OK;    bool    bResult         = false;    PCWSTR  wszComponent    = L"SampleComponent";    wprintf(L"INFO: ConstructWriterDefinition called/n");    //    // Select restore method    //    wprintf(L"INFO: Selecting restore method.../n");    CHECK_CONDITION(        SetRestoreMethod(            pMetadata,            VSS_RME_RESTORE_IF_CAN_REPLACE,     // VSS_RESTOREMETHOD_ENUM            NULL,                               // Service name, if method is VSS_RME_STOP_RESTORE_RESTART            false),                             // Reboot required        L"SetRestoreMethod failed");    //    // Add components and files    //    wprintf(L"INFO: Adding basic component.../n");    CHECK_CONDITION(        AddComponent(            pMetadata,            VSS_CT_FILEGROUP,                   // VSS_COMPONENT_TYPE            wszComponent),                      // Component name        L"AddComponent failed");    CHECK_CONDITION(        AddFilesToFileGroup(            pMetadata,            wszComponent,                       // Component name            L"c://xwdata",                      // Directory covered            L"*.*",                             // Files covered            true,                               // Recursive            VSS_FSBT_ALL_SNAPSHOT_REQUIRED |            VSS_FSBT_FULL_BACKUP_REQUIRED),     // Backup type mask        L"AddFilesToFileGroup failed");    bResult = true;_exit:    return bResult;}

TEST(FilePersistence, LoadMultipleUnits){	QString testDir = ":/FilePersistence/test/persisted";	Model::Model model;	FileStore store;	store.setBaseFolder(testDir);	model.load(&store, "units");	TestNodes::BinaryNode* root = dynamic_cast<TestNodes::BinaryNode*> (model.root());	CHECK_STR_EQUAL("BinaryNode", root->typeName() );	CHECK_STR_EQUAL("Root", root->name()->get() );	CHECK_CONDITION(root->left() != nullptr);	CHECK_CONDITION(root->right() != nullptr);	CHECK_STR_EQUAL("BinaryNodePersistenceUnit", root->left()->typeName() );	CHECK_STR_EQUAL("Left child", root->left()->name()->get() );	CHECK_CONDITION(root->left()->left() != nullptr);	CHECK_CONDITION(root->left()->right() == nullptr);	CHECK_STR_EQUAL("BinaryNode", root->left()->left()->typeName() );	CHECK_STR_EQUAL("in a new unit", root->left()->left()->name()->get() );	CHECK_CONDITION(root->left()->left()->left() == nullptr);	CHECK_CONDITION(root->left()->left()->right() == nullptr);	CHECK_STR_EQUAL("BinaryNode", root->right()->typeName() );	CHECK_STR_EQUAL("Right child", root->right()->name()->get() );	CHECK_CONDITION(root->right()->left() == nullptr);	CHECK_CONDITION(root->right()->right() == nullptr);}

/////////////////////////////////////////////////////////////////////////////////// CreateAndSaveToFile/////////////////////////////////////////////////////////////////////////////////bool CreateAndSaveToFile(){    HRESULT hr              = S_OK;    bool    bResult         = false;    CComPtr<IVssExpressWriter>                  spExpressWriter;    CComPtr<IVssCreateExpressWriterMetadata>    spMetadata;    wprintf(L"INFO: CreateAndSaveToFile called/n");    //    // Create Express Writer    //    wprintf(L"INFO: Creating Express Writer.../n");    CHECK_HR(        CreateVssExpressWriter(&spExpressWriter),        L"CreateVssExpressWriter failed");    //    // Create metadata    //    wprintf(L"INFO: Creating metadata.../n");    CHECK_HR(        spExpressWriter->CreateMetadata(            EXPRESS_WRITER_SAMPLE_GUID,         // Express Writer GUID            L"Sample Express Writer",           // Express Writer friendly name            VSS_UT_BOOTABLESYSTEMSTATE,         // VSS_USAGE_TYPE            1,                                  // Major version            0,                                  // Minor version            0,                                  // Reserved (must be 0)            &spMetadata),        L"CreateVssExpressWriter failed");    CHECK_CONDITION(        ConstructWriterDefinition(spMetadata),        L"ConstructWriterDefinition failed");    bResult = true;    //    // Save results    //    CHECK_CONDITION(SaveToFile(spMetadata, g_wszFileName), L"SaveToFile failed");    bResult = true;_exit:    return bResult;}

// Function Specification//// Name: errlTestWordAlign//// Description: errlTestWordAlign//// End Function Specificationuint32_t errlTestWordAlign(){    uint32_t l_rc = 0;    uint16_t l_entrySizeBefore = 0;    uint16_t l_entrySizeAfter = 0;    ERRL_DBG("START");    do    {        /****************************************************/        // Test word align for addUsrDtlsToErrl        // Create log        errlHndl_t l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_PREDICTIVE, NULL, 0, 0x1, 0x2);        CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);        // l_handle will set to NULL after calling the commitErrl, so we need to store it        errlHndl_t l_handleX = l_handle;        ppdumpslot();        // add 13 bytes of "user details"        l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;        memset( G_data, 0xAA, sizeof( G_data ) );        addUsrDtlsToErrl( l_handle, G_data, 13, ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_TRACE_DATA );        l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;        ERRL_DBG("Slots after create + 13 bytes" );        ppdumpslot();        // (header + WORDALIGN(13)) is the size that add to entry        CHECK_CONDITION( l_entrySizeAfter == (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+16), l_rc);        /****************************************************/        // Test word align for addTraceToErrl        // add 21 bytes of trace        l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;        addTraceToErrl(g_trac_inf, 21, l_handle); // @at012c        l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;        ERRL_DBG("Slots after create + 21 bytes" );        ppdumpslot();        // (header + WORDALIGN(21)) is the size that add to entry        CHECK_CONDITION( l_entrySizeAfter <= (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+24), l_rc);        commitErrl( &l_handle );        deleteErrl(&l_handleX);        ERRL_DBG("Slots should now be empty");        ppdumpslot();        ERRL_DBG("END /n");    }while(0);    return l_rc;}

bool COSE_Enveloped_decrypt(HCOSE_ENVELOPED h, HCOSE_RECIPIENT hRecip, cose_errback * perr){	COSE_Enveloped * pcose = (COSE_Enveloped *)h;	COSE_RecipientInfo * pRecip = (COSE_RecipientInfo *)hRecip;	bool f = false;	CHECK_CONDITION(IsValidEnvelopedHandle(h), COSE_ERR_INVALID_HANDLE);	CHECK_CONDITION(IsValidRecipientHandle(hRecip), COSE_ERR_INVALID_HANDLE);	CHECK_CONDITION(pcose->m_recipientFirst != NULL, COSE_ERR_INVALID_PARAMETER);	f = _COSE_Enveloped_decrypt(pcose, pRecip, NULL, 0, "Encrypt", perr);	errorReturn:	return f;}

bool AES_CCM_Decrypt(COSE_Enveloped * pcose, int TSize, int LSize, const byte * pbKey, size_t cbKey, const byte * pbCrypto, size_t cbCrypto, const byte * pbAuthData, size_t cbAuthData, cose_errback * perr){	mbedtls_ccm_context ctx;	int cbOut;	byte * rgbOut = NULL;	int NSize = 15 - (LSize/8);	byte rgbIV[15] = { 0 };	const cn_cbor * pIV = NULL;	mbedtls_cipher_id_t cipher;#ifdef USE_CBOR_CONTEXT	cn_cbor_context * context = &pcose->m_message.m_allocContext;#endif	mbedtls_ccm_init(&ctx);	        //  Setup the IV/Nonce and put it into the message	pIV = _COSE_map_get_int(&pcose->m_message, COSE_Header_IV, COSE_BOTH, NULL);	if ((pIV == NULL) || (pIV->type!= CN_CBOR_BYTES)) {		if (perr != NULL) perr->err = COSE_ERR_INVALID_PARAMETER;	errorReturn:		if (rgbOut != NULL) COSE_FREE(rgbOut, context);		mbedtls_ccm_free(&ctx);		return false;	}	CHECK_CONDITION(pIV->length == NSize, COSE_ERR_INVALID_PARAMETER);	memcpy(rgbIV, pIV->v.str, pIV->length);	//  Setup and run the mbedTLS code	cipher = MBEDTLS_CIPHER_ID_AES;	        CHECK_CONDITION(!mbedtls_ccm_setkey(&ctx, cipher, pbKey, cbKey*8), COSE_ERR_CRYPTO_FAIL);	TSize /= 8; // Comes in in bits not bytes.	cbOut = (int)  cbCrypto - TSize;	rgbOut = (byte *)COSE_CALLOC(cbOut, 1, context);	CHECK_CONDITION(rgbOut != NULL, COSE_ERR_OUT_OF_MEMORY);        			CHECK_CONDITION(!mbedtls_ccm_auth_decrypt(&ctx, cbOut, rgbIV, NSize, pbAuthData, cbAuthData, pbCrypto, rgbOut, &pbCrypto[cbOut], TSize), COSE_ERR_CRYPTO_FAIL);        	mbedtls_ccm_free(&ctx);	pcose->pbContent = rgbOut;	pcose->cbContent = cbOut;	return true;}

size_t FileImpl::Write(const t_byte *buf, size_t len){		if(!IsOpen()) return 0;				t_ulong nwritten = 0;		CHECK_CONDITION		(		::WriteFile(m_fhdl, buf, (DWORD)len, &nwritten, NULL), 		"FileImpl::Write "		);				CHECK_CONDITION((nwritten == len), "FileImpl::Write ");		return len;		}

double loadGraphFile(void *graph, const char *filename, BOOL (*lineHandleFun)(void*,int,int,int)){    int fromId, toId, lineCounter = 0, count;    clock_t begin, end;    FILE *fp;    begin = clock();    fp = fopen(filename, "r");    CHECK_CONDITION(fp != NULL, "Cannot Open Graph File!");    while(!feof(fp)){        count = fscanf(fp, "%d/t%d", &fromId, &toId);        if(count != 2){ // check reading count of ids            continue;        }        if(!lineHandleFun(graph, lineCounter, fromId, toId)){            break;        }        if(lineCounter % 1000000 == 0 && lineCounter != 0){            logMsg("read %d lines/n", lineCounter);        }        lineCounter += 1;    }    fclose(fp);    end = clock();    return (double)(end - begin) / CLOCKS_PER_SEC;}

HCOSE_MAC0 _COSE_Mac0_Init_From_Object(cn_cbor * cbor, COSE_Mac0Message * pIn, CBOR_CONTEXT_COMMA cose_errback * perr){	COSE_Mac0Message * pobj = pIn;	cn_cbor * pRecipients = NULL;	// cn_cbor * tmp;	cose_errback error = { COSE_ERR_NONE };	if (perr == NULL) perr = &error;	if (pobj == NULL) pobj = (COSE_Mac0Message *)COSE_CALLOC(1, sizeof(COSE_Mac0Message), context);	if (pobj == NULL) {		perr->err = COSE_ERR_OUT_OF_MEMORY;	errorReturn:		if ((pIn == NULL) && (pobj != NULL)) COSE_FREE(pobj, context);		return NULL;	}	if (!_COSE_Init_From_Object(&pobj->m_message, cbor, CBOR_CONTEXT_PARAM_COMMA perr)) {		goto errorReturn;	}	pRecipients = _COSE_arrayget_int(&pobj->m_message, INDEX_MAC_RECIPIENTS);	CHECK_CONDITION(pRecipients == NULL, COSE_ERR_INVALID_PARAMETER);	return(HCOSE_MAC0)pobj;}

HCOSE_ENCRYPT _COSE_Encrypt_Init_From_Object(cn_cbor * cbor, COSE_Encrypt * pIn, CBOR_CONTEXT_COMMA cose_errback * perr){	COSE_Encrypt * pobj = pIn;	cn_cbor * pRecipients = NULL;	cose_errback error = { 0 };	if (perr == NULL) perr = &error;	if (pobj == NULL) pobj = (COSE_Encrypt *)COSE_CALLOC(1, sizeof(COSE_Encrypt), context);	if (pobj == NULL) {		perr->err = COSE_ERR_OUT_OF_MEMORY;	errorReturn:		if ((pIn == NULL) && (pobj != NULL)) COSE_FREE(pobj, context);		return NULL;	}	if (!_COSE_Init_From_Object(&pobj->m_message, cbor, CBOR_CONTEXT_PARAM_COMMA perr)) {		goto errorReturn;	}	pRecipients = _COSE_arrayget_int(&pobj->m_message, INDEX_RECIPIENTS);	CHECK_CONDITION(pRecipients == NULL, COSE_ERR_INVALID_PARAMETER);	_COSE_InsertInList(&EncryptRoot, &pobj->m_message);	return(HCOSE_ENCRYPT) pobj;}