ANSC_STATUS AnscAsn1PKCS10AfterDecoding ( ANSC_HANDLE hThisObject, PVOID* ppEncoding ) { PANSC_ASN1_CERTIFICATEREQUEST pThisObject = (PANSC_ASN1_CERTIFICATEREQUEST)hThisObject; ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; if( pThisObject == NULL) { return returnStatus; } if( !pThisObject->Verify(pThisObject)) { AnscTrace("Failed to verify the PKCS10 request.\n"); returnStatus = ANSC_ASN1_FAILED_TO_VERIFY; } else { AnscTrace("Verify the PKCS10 Request successsfully.\n"); } return returnStatus; }
/********************************************************************** caller: owner of this object prototype: ANSC_HANDLE DslhCpecoGetInterfaceByName ( ANSC_HANDLE hThisObject, char* ifName ); description: This function is called to retrieve the interface handle specified by the interface name; argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. char* ifName The specified interface name; return: status of operation. **********************************************************************/ ANSC_HANDLE DslhCpecoGetInterfaceByName ( ANSC_HANDLE hThisObject, char* ifName ) { PDSLH_CPE_CONTROLLER_OBJECT pMyObject = (PDSLH_CPE_CONTROLLER_OBJECT )hThisObject; PANSC_INTERFACE_OBJECT pInterface = (PANSC_INTERFACE_OBJECT)NULL; ULONG i = 0; if( ifName == NULL || AnscSizeOfString(ifName) == 0) { AnscTrace("Unable to retrieve interface in DslhCpeController.\n"); return NULL; } for( i = 0; i < pMyObject->uIfCount; i ++) { pInterface = (PANSC_INTERFACE_OBJECT)pMyObject->hIfArray[i]; if( pInterface != NULL && AnscEqualString(pInterface->Name, ifName, TRUE)) { return (ANSC_HANDLE)pInterface; } } AnscTrace("Unable to retrieve interface '%s' in DslhCpeController.\n", ifName); return NULL; }
/********************************************************************** caller: owner of this object prototype: BOOLEAN AnscAsn1NULLTraceObject ( ANSC_HANDLE hThisObject, LONG layer, BOOLEAN bShowValue, BOOLEAN bRecursive ); description: This function dump out the values in a tree structure. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. LONG layer, Specifies the layer of current object. BOOLEAN bShowValue Specifies showing the value or not; BOOLEAN bRecursive Trace recursive or not; return: status of operation. **********************************************************************/ BOOLEAN AnscAsn1NULLTraceObject ( ANSC_HANDLE hThisObject, LONG layer, BOOLEAN bShowValue, BOOLEAN bRecursive ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PANSC_ASN1_NULL pMyObject = (PANSC_ASN1_NULL)hThisObject; CHAR pAttrBuffer[512] = { 0 }; ULONG attrLength = 512; PCHAR pName; TraceTabs(layer); AttrListDump( &pMyObject->sAttrList, pAttrBuffer, &attrLength); if( layer == 0) { pName = pMyObject->ClassName; } else { pName = pMyObject->Name; } if( pName == NULL) { return FALSE; } if( pMyObject->bOptional) { AnscTrace ( "%s ::=%s %s (Optional)\n", pName, pAttrBuffer, ASN1Type2String(pMyObject->uType) ); } else { AnscTrace ( "%s ::=%s %s \n", pName, pAttrBuffer, ASN1Type2String(pMyObject->uType) ); } return TRUE; }
void AnscPrintBinaryMessage ( PVOID buffer, ULONG ulSize ) { PUCHAR hex_stream = (PUCHAR)buffer; ULONG i = 0; ULONG j = 0; AnscTrace(" ***** binary message size %04d bytes: ***** \n", ulSize); for ( i = 0; i < ulSize / 16; i++ ) { AnscTrace ( "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", hex_stream[i * 16 + 0 ], hex_stream[i * 16 + 1 ], hex_stream[i * 16 + 2 ], hex_stream[i * 16 + 3 ], hex_stream[i * 16 + 4 ], hex_stream[i * 16 + 5 ], hex_stream[i * 16 + 6 ], hex_stream[i * 16 + 7 ], hex_stream[i * 16 + 8 ], hex_stream[i * 16 + 9 ], hex_stream[i * 16 + 10], hex_stream[i * 16 + 11], hex_stream[i * 16 + 12], hex_stream[i * 16 + 13], hex_stream[i * 16 + 14], hex_stream[i * 16 + 15] ); } if ( ulSize % 16 ) { for ( j = 0; j < ulSize % 16; j++ ) { AnscTrace("%02X ", hex_stream[i * 16 + j]); } AnscTrace("\n"); } AnscTrace(" ***** ***************************** ***** \n\n"); return; }
/********************************************************************** caller: owner of this object prototype: BOOLEAN AnscAsn1EnumerateEqualsTo ( ANSC_HANDLE hThisObject, ANSC_HANDLE hOtherObject, BOOLEAN bValueOnly ); description: This function compares the value of the 2 ASN.1 objects. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. ANSC_HANDLE hOtherObject This handle is the other object will be compared to; BOOLEAN bValueOnly Check the value only or not; return: If they have the same type and value, return TRUE; otherwise return FALSE. **********************************************************************/ BOOLEAN AnscAsn1EnumerateEqualsTo ( ANSC_HANDLE hThisObject, ANSC_HANDLE hOtherObject, BOOLEAN bValueOnly ) { PANSC_ASN1_ENUMERATE pMyObject = (PANSC_ASN1_ENUMERATE)hThisObject; PANSC_ASN1_ENUMERATE pNewObject = (PANSC_ASN1_ENUMERATE)hOtherObject; /* check the pointer first */ if( hThisObject == hOtherObject) { return TRUE; } if( hThisObject == NULL || hOtherObject == NULL) { AnscTrace("One of the parameter in AnscAsn1EnumerateEqualsTo() is NULL pointer.\n"); return FALSE; } /* check the type */ if( pMyObject->uType != pNewObject->uType) { AnscTrace("Different type in AnscAsn1EnumerateEqualsTo().\n"); return FALSE; } /* check the attribute list */ if(!AttrListCompareAttributeList(&pMyObject->sAttrList, &pNewObject->sAttrList)) { return FALSE; } /* check the optional state */ if( pMyObject->bOptional != pNewObject->bOptional) { return FALSE; } if(!pMyObject->bOptional) { return (pMyObject->uValue == pNewObject->uValue); } return TRUE; }
ANSC_STATUS AnscLpccoAddPartyAddr ( ANSC_HANDLE hThisObject, ANSC_HANDLE party_addr ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PANSC_LPC_CONNECTOR_OBJECT pMyObject = (PANSC_LPC_CONNECTOR_OBJECT)hThisObject; PANSC_LPC_PARTY_ADDR pPartyAddr = (PANSC_LPC_PARTY_ADDR )party_addr; char* pPartyName = (char* )pPartyAddr->PartyName; ULONG ulHashIndex = AnscHashString(pPartyName, AnscSizeOfString(pPartyName), ANSC_LPCCO_PARTY_TABLE_SIZE); if ( pMyObject->GetPartyAddr ( (ANSC_HANDLE)pMyObject, pPartyName ) != (ANSC_HANDLE)NULL ) { AnscTrace ( "[AnscLpccoAddPartyAddr] collison found, failed to add party <%s> from %d.%d.%d.%d (%d)\n", pPartyAddr->PartyName, pPartyAddr->PartyAddr.Dot[0], pPartyAddr->PartyAddr.Dot[1], pPartyAddr->PartyAddr.Dot[2], pPartyAddr->PartyAddr.Dot[3], pPartyAddr->PartyPort ); return ANSC_STATUS_COLLISION; } AnscAcquireLock (&pMyObject->PartyTableLock); AnscQueuePushEntry(&pMyObject->PartyTable[ulHashIndex], &pPartyAddr->Linkage); AnscReleaseLock (&pMyObject->PartyTableLock); AnscTrace ( "[AnscLpccoAddPartyAddr] party <%s> from %d.%d.%d.%d (%d) has been added.\n", pPartyAddr->PartyName, pPartyAddr->PartyAddr.Dot[0], pPartyAddr->PartyAddr.Dot[1], pPartyAddr->PartyAddr.Dot[2], pPartyAddr->PartyAddr.Dot[3], pPartyAddr->PartyPort ); return ANSC_STATUS_SUCCESS; }
ANSC_STATUS AnscCryptoGzipCompress ( PVOID plain, ULONG size, PVOID compact, PULONG pOutSize ) { #ifdef _ANSC_GZIP_USED_ ULONG length = 0; if( plain == NULL || compact == NULL || size == 0 || pOutSize == NULL) { return ANSC_STATUS_FAILURE; } length = gz_al_compress(plain, size, compact, *pOutSize); if( length == 0) { return ANSC_STATUS_FAILURE; } *pOutSize = length; #else AnscTrace("WARNING: GZIP is disabled!!!\n"); #endif return ANSC_STATUS_SUCCESS; }
/********************************************************************** caller: owner of this object prototype: LONG AnscAsn1NULLGetSizeOfEncoded ( ANSC_HANDLE hThisObject ) description: This function returns the encoding size of the ASN.1 object. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. return: The encoding size of the ASN.1 object. If the object is not ready-to-encode, -1 will be returned. **********************************************************************/ LONG AnscAsn1NULLGetSizeOfEncoded ( ANSC_HANDLE hThisObject ) { PANSC_ASN1_NULL pMyObject = (PANSC_ASN1_NULL)hThisObject; ULONG ulSize = 0; ULONG i = 0; /* * If it's optional, don't need encode */ if( pMyObject->bOptional) { return 0; } if( !pMyObject->ReadyToEncode(pMyObject)) { AnscTrace("The value of the NULL object is not ready to encode.\n"); return -1; } ulSize = 0; /* * check the attribute list, from the end of the list; * the tag length value is 1. */ return AttrListGetSizeOfEncoded(&pMyObject->sAttrList, ulSize, 1); }
/********************************************************************** caller: owner of the object prototype: ANSC_HANDLE AnscAsn1NULLClone ( ANSC_HANDLE hThisObject ); description: This function clones a same ASN.1 object. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. return: The cloned container object. **********************************************************************/ ANSC_HANDLE AnscAsn1NULLClone ( ANSC_HANDLE hThisObject ) { PANSC_ASN1_NULL pMyObject = (PANSC_ASN1_NULL)hThisObject; PANSC_ASN1_NULL pNewObject = NULL; pNewObject = (PANSC_ASN1_NULL) pMyObject->Create ( pMyObject->hContainerContext ); if( pNewObject == NULL) { AnscTrace("Failed to clone at AnscAsn1NULLClone()\n"); return NULL; } /* * Copy all the attributes; */ /* AttrListCopyAllAttributes( &pNewObject->sAttrList, &pMyObject->sAttrList);*/ pNewObject->SetName(pNewObject, pMyObject->Name); pMyObject->CopyTo(pMyObject, pNewObject); return pNewObject; }
ANSC_STATUS TlsCpoDecrypt_RSA ( ANSC_HANDLE hThisObject, ANSC_X509_KEY* i_prv_key, void* i_data, ULONG i_data_size, void* o_data, PULONG o_data_size ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PTLS_CRYPTO_PROVIDER_OBJECT pMyObject = (PTLS_CRYPTO_PROVIDER_OBJECT)hThisObject; PANSC_CRYPTO_PUB_OBJECT pSSLCrypto = (PANSC_CRYPTO_PUB_OBJECT )pMyObject->hAnscCryptoPub; ANSC_CRYPTO_PUB_KEY_PARAMS params; PANSC_CRYPTO_PUB_KEY_GEN_PARAMS pGenParams; ANSC_CRYPTO_PUB_ALGORITHM Alg; ANSC_CRYPTO_PUB_OPERATION Op; if( i_prv_key == NULL) { return ANSC_STATUS_FAILURE; } if( i_prv_key->KeyType != ANSC_CERT_keyType_rsa) { AnscTrace("TlsCpoEncrypt_RSA(): Invalid key type."); return ANSC_STATUS_FAILURE; } pGenParams = (PANSC_CRYPTO_PUB_KEY_GEN_PARAMS)i_prv_key->KeyData; params.Key.RSA.RsaPrivateKey = pGenParams->PrivateKey.RSA; Alg = ANSC_CRYPTO_PUB_ALGORITHM_RSA_ENCRYPTION; Op = ANSC_CRYPTO_PUB_OPERATION_DECRYPT; params.InputSize = i_data_size; params.pInput = (PVOID)i_data; params.OutputSize = *o_data_size; params.pOutput = (PVOID)o_data; returnStatus = pSSLCrypto->Request ( Alg, Op, (ANSC_HANDLE)¶ms, NULL, NULL ); *o_data_size = params.OutputSize; return returnStatus; }
ANSC_STATUS HttpWcsoClose ( ANSC_HANDLE hThisObject ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PHTTP_WEBC_SESSION_OBJECT pMyObject = (PHTTP_WEBC_SESSION_OBJECT )hThisObject; PHTTP_WEBC_SESSION_PROPERTY pProperty = (PHTTP_WEBC_SESSION_PROPERTY )&pMyObject->Property; PANSC_SIMPLE_CLIENT_TCP_OBJECT pTcpSimpleClient = (PANSC_SIMPLE_CLIENT_TCP_OBJECT)pMyObject->hTcpSimpleClient; PANSC_BUFFER_DESCRIPTOR pBufferDesp = (PANSC_BUFFER_DESCRIPTOR )pTcpSimpleClient->GetBufferContext((ANSC_HANDLE)pTcpSimpleClient); PHTTP_WEBC_TRANS_OBJECT pWebcTrans = (PHTTP_WEBC_TRANS_OBJECT )NULL; if ( pMyObject->SessionState == HTTP_WCSO_STATE_FINISHED ) { return ANSC_STATUS_SUCCESS; } else { pMyObject->SessionState = HTTP_WCSO_STATE_FINISHED; } AnscTrace("Http Webc Session Object is to be closed!\n"); if ( !pMyObject->bRemoveMe ) { pWebcTrans = (PHTTP_WEBC_TRANS_OBJECT)pMyObject->GetEndWcto((ANSC_HANDLE)pMyObject); if ( pWebcTrans ) { if ( pWebcTrans->GetTransState((ANSC_HANDLE)pWebcTrans) != HTTP_WCTO_STATE_FINISHED ) { returnStatus = pWebcTrans->Abort ( (ANSC_HANDLE)pWebcTrans, HTTP_BSP_EVENT_TIMEOUT ); } pWebcTrans->ReleaseAccess((ANSC_HANDLE)pWebcTrans); } } pMyObject->DelAllWctos((ANSC_HANDLE)pMyObject); pTcpSimpleClient->Cancel((ANSC_HANDLE)pTcpSimpleClient); if ( pBufferDesp ) { AnscFreeBdo((ANSC_HANDLE)pBufferDesp); } return ANSC_STATUS_SUCCESS; }
BOOLEAN AnscAsn1PKCS10InitWithCryptoAPI ( ANSC_HANDLE hThisObject, ANSC_HANDLE hCryptAPI ) { PANSC_ASN1_CERTIFICATEREQUEST pThisObject = (PANSC_ASN1_CERTIFICATEREQUEST)hThisObject; PCRYPT_API_STRUCT pCryptAPI = (PCRYPT_API_STRUCT)hCryptAPI; PANSC_ASN1_SUBJECTPUBLICKEYINFO pPublicKeyInfo; PANSC_ASN1_CERTIFICATIONREQUESTINFO pInfo; PKI_KEY_TYPE keyType; ANSC_CRYPTO_PUB_KEY_GEN_PARAMS genParams; if( pThisObject == NULL || hCryptAPI == NULL) { return FALSE; } pInfo = (PANSC_ASN1_CERTIFICATIONREQUESTINFO) pThisObject->GetCertificateRequestInfo(pThisObject); if( pInfo == NULL) { return FALSE; } pPublicKeyInfo = (PANSC_ASN1_SUBJECTPUBLICKEYINFO) pInfo->GetChildByIndex(pInfo,2); if( pPublicKeyInfo == NULL) { return FALSE; } /* set the public key */ pCryptAPI->pGetPublicKey(pCryptAPI,&keyType, &genParams); if(!pPublicKeyInfo->GenerateKey ( pPublicKeyInfo, keyType, &genParams )) { AnscTrace("Failed to set the public key.\n"); return FALSE; } /* sign it */ pThisObject->SignWithCryptAPI(pThisObject, hCryptAPI); return TRUE; }
void CcspCcMbi_CurrentSessionIdSignal ( int priority, /* Can be ignored by Common Components */ int sessionID, void * user_data ) { AnscTrace("!!! set curent session id to %d !!!\n", sessionID); g_currentSessionID = sessionID; }
BOOL HttpApoPubwoAccept ( ANSC_HANDLE hThisObject, ANSC_HANDLE hSocket, PANSC_HANDLE phClientContext ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PHTTP_ADVANCED_PROXY_OBJECT pMyObject = (PHTTP_ADVANCED_PROXY_OBJECT )hThisObject; PHTTP_ADVANCED_PROXY_PROPERTY pProperty = (PHTTP_ADVANCED_PROXY_PROPERTY )&pMyObject->Property; PANSC_SIMPLE_PROXY_TCP_OBJECT pSimpleProxy = (PANSC_SIMPLE_PROXY_TCP_OBJECT )pMyObject->hSimpleProxy; PHTTP_WAM_INTERFACE pWamIf = (PHTTP_WAM_INTERFACE )pMyObject->hWamIf; PHTTP_SBC_INTERFACE pSbcIf = (PHTTP_SBC_INTERFACE )pMyObject->hSbcIf; PHTTP_CBC_INTERFACE pCbcIf = (PHTTP_CBC_INTERFACE )pMyObject->hCbcIf; PHTTP_PBC_INTERFACE pPbcIf = (PHTTP_PBC_INTERFACE )pMyObject->hPbcIf; PANSC_BROKER_SOCKET_TCP_OBJECT pServerSocket = (PANSC_BROKER_SOCKET_TCP_OBJECT)hSocket; PHTTP_PSO_VER2_OBJECT pPsoVer2 = NULL; PHTTP_TRANS_RECORD_OBJECT pTransRecord = NULL; PANSC_BUFFER_DESCRIPTOR pBufferDesp = NULL; AnscTrace ( "PubwoAccept creates a new server connection to %d.%d.%d.%d / TCP %d\n", pServerSocket->PeerAddress.Dot[0], pServerSocket->PeerAddress.Dot[1], pServerSocket->PeerAddress.Dot[2], pServerSocket->PeerAddress.Dot[3], pServerSocket->PeerPort ); pBufferDesp = (PANSC_BUFFER_DESCRIPTOR)AnscAllocateBdo ( HTTP_APO_MAX_MESSAGE_SIZE, 0, 0 ); if ( pBufferDesp ) { pServerSocket->SetBufferContext ( (ANSC_HANDLE)pServerSocket, AnscBdoGetEndOfBlock(pBufferDesp), AnscBdoGetLeftSize (pBufferDesp), (ANSC_HANDLE)pBufferDesp ); } return TRUE; }
/********************************************************************** caller: owner of this object prototype: ANSC_STATUS DslhCpecoAddInterface ( ANSC_HANDLE hThisObject, ANSC_HANDLE hInterface ); description: This function is called to add interface to CPE Controller. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. ANSC_HANDLE hInterface The new added interface return: status of operation. **********************************************************************/ ANSC_STATUS DslhCpecoAddInterface ( ANSC_HANDLE hThisObject, ANSC_HANDLE hInterface ) { PDSLH_CPE_CONTROLLER_OBJECT pMyObject = (PDSLH_CPE_CONTROLLER_OBJECT )hThisObject; PANSC_INTERFACE_OBJECT pInterface = (PANSC_INTERFACE_OBJECT)hInterface; if( hInterface == NULL || pMyObject->uIfCount >= CPECONTROLLER_MAX_INTERFACE_COUNT) { AnscTrace("Unable to add interface in DslhCpeController.\n"); return ANSC_STATUS_FAILURE; } pMyObject->hIfArray[ pMyObject->uIfCount ++] = hInterface; AnscTrace("Interface '%s' is added into CpeController.\n", pInterface->Name); return ANSC_STATUS_SUCCESS; }
/********************************************************************** OBJECT -- ANSC_ASN1_CERTIFICATEREQUEST CertificateRequest ::= Sequence { certificateRequestInfo CertificationRequestInfo signatureAlgorithmIdentifier SignatureAlgorithmIdentifier signature BitString } **********************************************************************/ ANSC_HANDLE AnscAsn1GenPKCS10RequestWithCryptoAPI ( ANSC_HANDLE hReserved, PALCERTIFICATE_ATTRIBUTE pAttrObject, ANSC_HANDLE hCryptAPI ) { PANSC_ASN1_CERTIFICATEREQUEST pThisObject = NULL; PCRYPT_API_STRUCT pCryptAPI = (PCRYPT_API_STRUCT)hCryptAPI; if( pAttrObject == NULL || hCryptAPI == NULL) { return NULL; } if( pCryptAPI->pGetPublicKey == NULL || pCryptAPI->pSignData == NULL) { AnscTrace("Invalid Smartcard APIs.\n"); return NULL; } pThisObject = (PANSC_ASN1_CERTIFICATEREQUEST) AnscAsn1CreateCertificateRequest ( hReserved ); if( pThisObject == NULL) { return NULL; } pThisObject->InitName ( pThisObject, pAttrObject ); pThisObject->InitWithCryptAPI ( pThisObject, hCryptAPI ); return pThisObject; }
BOOL TlsCpoVerify ( ANSC_HANDLE hThisObject, ULONG key_type, ANSC_X509_KEY* i_key, void* i_data, ULONG i_data_size, void* i_sig, ULONG i_sig_size ) { if( key_type == ANSC_CERT_keyType_rsa) { return TlsCpoVerify_RSA ( hThisObject, i_key, i_data, i_data_size, i_sig, i_sig_size ); } else if( key_type == ANSC_CERT_keyType_dsa) { return TlsCpoVerify_DSA ( hThisObject, i_key, i_data, i_data_size, i_sig, i_sig_size ); } AnscTrace("Unsupported sign key type : '%d'\n", key_type); return FALSE; }
ANSC_STATUS TlsCpoSign ( ANSC_HANDLE hThisObject, ULONG key_type, ANSC_X509_KEY* i_key, void* i_data, ULONG i_data_size, void* o_sig, PULONG o_sig_size ) { if( key_type == ANSC_CERT_keyType_rsa) { return TlsCpoSign_RSA ( hThisObject, i_key, i_data, i_data_size, o_sig, o_sig_size ); } else if( key_type == ANSC_CERT_keyType_dsa) { return TlsCpoSign_DSA ( hThisObject, i_key, i_data, i_data_size, o_sig, o_sig_size ); } AnscTrace("Unsupported sign key type : '%d'\n", key_type); return ANSC_STATUS_FAILURE; }
ULONG AnscCryptoMd4Digest ( PVOID buffer, ULONG size, PANSC_CRYPTO_HASH hash ) { #ifdef _ANSC_MD4_USED_ MD4_CTX context; MD4_Init (&context); MD4_Update(&context, (PUCHAR)buffer, size); MD4_Final (hash->Value, &context); hash->Length = ANSC_MD4_OUTPUT_SIZE; #else AnscTrace("WARNING: MD4 digest is disabled!!!\n"); #endif return hash->Length; }
/********************************************************************** caller: owner of this object prototype: LONG AnscAsn1EnumerateGetSizeOfEncoded ( ANSC_HANDLE hThisObject ) description: This function returns the encoding size of the ASN.1 object. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. return: The encoding size of the ASN.1 object. If the object is not ready-to-encode, -1 will be returned. **********************************************************************/ LONG AnscAsn1EnumerateGetSizeOfEncoded ( ANSC_HANDLE hThisObject ) { PANSC_ASN1_ENUMERATE pMyObject = (PANSC_ASN1_ENUMERATE)hThisObject; ULONG ulSize = 0; ULONG tagSize = 0; /* * If it's optional, don't need encode */ if( pMyObject->bOptional) { return 0; } if( !pMyObject->ReadyToEncode(pMyObject)) { AnscTrace("The value of the ENUMERATE object is not ready to encode.\n"); return -1; } ulSize = pMyObject->uLength; /* * The tag size is 1; */ tagSize = 1; /* * check the attribute list, from the end of the list; */ return AttrListGetSizeOfEncoded(&pMyObject->sAttrList, ulSize, 1); }
ANSC_STATUS ssp_cancel_wifi ( PCCSP_COMPONENT_CFG pStartCfg ) { int nRet = 0; char CrName[256]; char CpName[256]; if( pDslhCpeController == NULL) { return ANSC_STATUS_SUCCESS; } if ( g_Subsystem[0] != 0 ) { _ansc_sprintf(CrName, "%s%s", g_Subsystem, CCSP_DBUS_INTERFACE_CR); _ansc_sprintf(CpName, "%s%s", g_Subsystem, pStartCfg->ComponentName); } else { _ansc_sprintf(CrName, "%s", CCSP_DBUS_INTERFACE_CR); _ansc_sprintf(CpName, "%s", pStartCfg->ComponentName); } /* unregister component */ nRet = CcspBaseIf_unregisterComponent(bus_handle, CrName, CpName ); AnscTrace("unregisterComponent returns %d\n", nRet); pDslhCpeController->Cancel((ANSC_HANDLE)pDslhCpeController); AnscFreeMemory(pDslhCpeController); pDslhCpeController = NULL; return ANSC_STATUS_SUCCESS; }
ANSC_HANDLE HttpScoAddWcso ( ANSC_HANDLE hThisObject, char* host, USHORT port, ANSC_HANDLE hReqContext, BOOL bUseTls ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PHTTP_SIMPLE_CLIENT_OBJECT pMyObject = (PHTTP_SIMPLE_CLIENT_OBJECT )hThisObject; PHTTP_SIMPLE_CLIENT_PROPERTY pProperty = (PHTTP_SIMPLE_CLIENT_PROPERTY)&pMyObject->Property; PHTTP_BSP_INTERFACE pBspIf = (PHTTP_BSP_INTERFACE )pMyObject->hBspIf; PHTTP_HFP_INTERFACE pHfpIf = (PHTTP_HFP_INTERFACE )pMyObject->hHfpIf; PHTTP_WEBC_SESSION_OBJECT pWebcSession = (PHTTP_WEBC_SESSION_OBJECT )pMyObject->AcquireWcso((ANSC_HANDLE)pMyObject); ULONG ulHashIndex = AnscHashString2(host, AnscSizeOfString(host), HTTP_SCO_WCSO_TABLE_SIZE); if ( !pWebcSession ) { AnscTrace("HttpScoAddWcso - can't acquire web client session object!\n"); return (ANSC_HANDLE)NULL; } else { ULONG ulWebcSessionMode = bUseTls? HTTP_WCSO_FLAG_tlsEnabled : 0; if ( pMyObject->ClientMode & HTTP_SCO_MODE_XSOCKET ) { ulWebcSessionMode |= HTTP_WCSO_FLAG_xsocketEnabled; } if ( pMyObject->ClientMode & HTTP_SCO_MODE_NOTIFY_ON_ALL_CONN_ONCE ) { ulWebcSessionMode |= HTTP_WCSO_FLAG_BspNotifyOnAllConnOnce; } pWebcSession->hBspReqContext = hReqContext; pWebcSession->Timestamp = AnscGetTickInSeconds(); pWebcSession->HashIndex = ulHashIndex; pWebcSession->SetPeerName ((ANSC_HANDLE)pWebcSession, host ); pWebcSession->SetPeerPort ((ANSC_HANDLE)pWebcSession, port ); pWebcSession->SetHostPort ((ANSC_HANDLE)pWebcSession, 0 ); pWebcSession->SetSessionFlags((ANSC_HANDLE)pWebcSession, ulWebcSessionMode ); pWebcSession->SetBspIf ((ANSC_HANDLE)pWebcSession, (ANSC_HANDLE)pBspIf); pWebcSession->SetHfpIf ((ANSC_HANDLE)pWebcSession, (ANSC_HANDLE)pHfpIf); } returnStatus = pWebcSession->Open((ANSC_HANDLE)pWebcSession); if ( returnStatus != ANSC_STATUS_SUCCESS ) { pWebcSession->Return((ANSC_HANDLE)pWebcSession); return (ANSC_HANDLE)NULL; } AnscAcquireLock (&pMyObject->WcsoTableLock); AnscSListPushEntry(&pMyObject->WcsoTable[ulHashIndex], &pWebcSession->Linkage); pWebcSession->AcquireAccess((ANSC_HANDLE)pWebcSession); AnscReleaseLock (&pMyObject->WcsoTableLock); return (ANSC_HANDLE)pWebcSession; }
ANSC_HANDLE HttpSmpoUtilParseHeader ( ANSC_HANDLE hHttpSmpo, PVOID buffer, ULONG ulSize ) { PHTTP_SIMPLE_MSG_PARSER pMyObject = (PHTTP_SIMPLE_MSG_PARSER)hHttpSmpo; PUCHAR pLast = ((PUCHAR)buffer) + ulSize - 1; ANSC_HANDLE hHeader = (ANSC_HANDLE)NULL; PUCHAR pHeader; ULONG ulHeaderSize; PUCHAR pValue; ULONG ulValueSize; PHTTP_SMPO_HEADER_XINFO pXinfo; BOOL bUnknown = FALSE; /* get header name and call corresponding function to parse it */ pHeader = (PUCHAR)buffer; pValue = _ansc_memchr(pHeader, HTTP_SMPO_CHAR_COLON, ulSize); if (!pValue) { #ifdef _DEBUG ULONG i; AnscTrace("Failed to parse header:\n"); for (i = 0; i < ulSize; i ++) { AnscTrace("%c", ((char *)buffer) + i); } AnscTrace("\n\n"); #endif return (ANSC_HANDLE)NULL; } ulHeaderSize = pValue - pHeader; pValue ++; pValue = HttpSmpoUtilLinearWhiteSpace(pValue, pLast - pValue + 1); ulValueSize = pLast - pValue + 1; pXinfo = pMyObject->GetHeaderXInfo((ANSC_HANDLE)pMyObject, pHeader, ulHeaderSize); if (pXinfo) { if ( !pValue || ulValueSize == 0 ) { hHeader = (ANSC_HANDLE)NULL; } else { hHeader = (pXinfo->xFunc)(hHttpSmpo, (PVOID)pValue, ulValueSize); } } if (!hHeader) { /* extension header */ PHTTP_HEADER_FIELD pHeader; pHeader = (PHTTP_HEADER_FIELD)AnscAllocateMemory(sizeof(HTTP_HEADER_FIELD)); hHeader = (ANSC_HANDLE)pHeader; bUnknown = TRUE; } if (hHeader) { PHTTP_HEADER_FIELD pHeaderField = (PHTTP_HEADER_FIELD)hHeader; HttpSmpoUtilCopyHeaderString((PUCHAR)buffer, ulSize, pHeaderField->HeaderLine, HTTP_HEADER_LINE_SIZE); pHeaderField->Flags |= HTTP_FIELD_FLAG_LINE_PRESENT; if ( bUnknown ) { pHeaderField->HeaderId = HTTP_HEADER_ID_EXTENSION; } else { pHeaderField->HeaderId = pXinfo?pXinfo->HeaderId:HTTP_HEADER_ID_EXTENSION; } pHeaderField->Linkage.Next = NULL; pHeaderField->HashIndex = 0; } return hHeader; }
ANSC_STATUS AnscSctoEngage ( ANSC_HANDLE hThisObject ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PANSC_SIMPLE_CLIENT_TCP_OBJECT pMyObject = (PANSC_SIMPLE_CLIENT_TCP_OBJECT)hThisObject; PANSC_SCTO_WORKER_OBJECT pWorker = (PANSC_SCTO_WORKER_OBJECT )pMyObject->hWorker; int s_error = 0; ansc_socket_addr_in ansc_client_addr; ansc_socket_addr_in ansc_server_addr; xskt_socket_addr_in xskt_client_addr; xskt_socket_addr_in xskt_server_addr; #ifdef _ANSC_IPV6_COMPATIBLE_ ansc_addrinfo ansc_hints = {0}; ansc_addrinfo* pansc_server_addrinfo = NULL; ansc_addrinfo* pansc_client_addrinfo = NULL; xskt_addrinfo xskt_hints = {0}; xskt_addrinfo* pxskt_server_addrinfo = NULL; xskt_addrinfo* pxskt_client_addrinfo = NULL; USHORT usPort = 0; char port[6] = {0}; #endif if ( pMyObject->bActive ) { return ANSC_STATUS_SUCCESS; } else if ( !pWorker ) { return ANSC_STATUS_UNAPPLICABLE; } else { /* * Just like any other socket-based ANSC object, we will create a separate async recv task * which is dedicated to receiving packets. This async recv task is controlled by 'bActive' * flag. What if at this moment right before we're about to enable the socket operation and * setting 'bActive' flag to TRUE, the old recv task created by the last call of Engage() * is still running? While it may not cause crash, but it certainly confuses the owner * object because all async recv tasks share the same worker interface. The most obvious * solution is to wait for previous recv task to exit before creating a new one. */ while ( pMyObject->EngineTaskCount != 0 ) { AnscSleep(50); } pMyObject->bActive = TRUE; pMyObject->bClosed = FALSE; } /* * The underlying socket wrapper may require an explicit startup() call, such is the case on * Microsoft windows platforms. The wrapper initialization has to done for each task. On most * real-time operating systems, this call is not required. */ if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { AnscStartupXsocketWrapper((ANSC_HANDLE)pMyObject); } else { AnscStartupSocketWrapper((ANSC_HANDLE)pMyObject); } #ifdef _ANSC_IPV6_COMPATIBLE_ if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { xskt_hints.ai_family = AF_UNSPEC; xskt_hints.ai_socktype = XSKT_SOCKET_STREAM; xskt_hints.ai_flags = AI_CANONNAME; usPort = pMyObject->GetPeerPort((ANSC_HANDLE)pMyObject); _ansc_sprintf(port, "%d", usPort); AnscTrace("!!! Peer Port: %s !!!\n", port); char * pPeerName = pMyObject->GetPeerName((ANSC_HANDLE)pMyObject); AnscTrace("Peer Name: %s!!!\n", pPeerName); /* struct addrinfo hints,*res=NULL; memset(&hints,0,sizeof(hints)); hints.ai_family=PF_UNSPEC; hints.ai_socktype=SOCK_DGRAM; hints.ai_protocol=IPPROTO_UDP; s_error=getaddrinfo("127.0.0.1","123",&hints,&res); */ /* s_error = _xskt_getaddrinfo ( "10.74.52.92", port, &xskt_hints, &pxskt_server_addrinfo ); AnscTrace("!!!!!! _xskt_getaddrinfo returns: %d %s !!!\n", s_error, gai_strerror(s_error)); */ if ( _xskt_getaddrinfo ( pMyObject->GetPeerName((ANSC_HANDLE)pMyObject), port, &xskt_hints, &pxskt_server_addrinfo ) || _xskt_getaddrinfo ( "localhost", NULL, &xskt_hints, &pxskt_client_addrinfo ) ) { AnscTrace("!!! error 1 !!!\n"); if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT1; } AnscTrace("!!! after getaddrinfo !!!\n"); } else { ansc_hints.ai_family = AF_UNSPEC; ansc_hints.ai_socktype = ANSC_SOCKET_STREAM; ansc_hints.ai_flags = AI_CANONNAME; usPort = pMyObject->GetPeerPort((ANSC_HANDLE)pMyObject); _ansc_sprintf(port, "%d", usPort); if ( _ansc_getaddrinfo ( pMyObject->GetPeerName((ANSC_HANDLE)pMyObject), port, &ansc_hints, &pansc_server_addrinfo ) || _ansc_getaddrinfo ( "localhost", NULL, &ansc_hints, &pansc_client_addrinfo ) ) { if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT1; } } #endif /* * To engage the Tcp Client, we need to perform following acts in the respective order: * * (1) create the os-dependent socket * (2) bind to the newly socket * (3) connect to the specified server address * (4) allocate a buffer for receiving * (5) spawn a separate thread and start receiving */ if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { #ifdef _ANSC_IPV6_COMPATIBLE_ pMyObject->Socket = (ANSC_SOCKET)_xskt_socket(pxskt_server_addrinfo->ai_family, pxskt_server_addrinfo->ai_socktype, 0); #else pMyObject->Socket = (ANSC_SOCKET)_xskt_socket(XSKT_SOCKET_AF_INET, XSKT_SOCKET_STREAM, 0); #endif if ( (XSKT_SOCKET)pMyObject->Socket == XSKT_SOCKET_INVALID_SOCKET ) { AnscTrace("!!!!!!!!!! _xskt_socket error !!!!!!!!!!\n"); if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT1; } else AnscTrace("Opening IPv4 socket Ok\n"); } else { #ifdef _ANSC_IPV6_COMPATIBLE_ pMyObject->Socket = _ansc_socket(pansc_server_addrinfo->ai_family, pansc_server_addrinfo->ai_socktype, 0); #else pMyObject->Socket = _ansc_socket(ANSC_SOCKET_AF_INET, ANSC_SOCKET_STREAM, 0); #endif if ( pMyObject->Socket == ANSC_SOCKET_INVALID_SOCKET ) { if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT1; } } /* * Normally we don't need to know which local network interface we shall bind to, and the * underlying operating system usually supports such notation as "any address". */ #ifndef _ANSC_IPV6_COMPATIBLE_ if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { xskt_client_addr.sin_family = XSKT_SOCKET_AF_INET; xskt_client_addr.sin_port = _xskt_htons(pMyObject->HostPort); if (pMyObject->bSocketBindToDevice && *(pMyObject->SocketDeviceName)) { if (_xskt_setsocketopt ( pMyObject->Socket, XSKT_SOCKET_SOL_SOCKET, XSKT_SOCKET_SO_BINDTODEVICE, pMyObject->SocketDeviceName, _ansc_strlen(pMyObject->SocketDeviceName) + 1 ) < 0) { perror("setsockopt-SOL_SOCKET-SO_BINDTODEVICE"); returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } } // fprintf(stderr, "<RT XSKT> Binding socket to Device '%s'.\n", pMyObject->SocketDeviceName); if ( pMyObject->HostAddress.Value == 0 ) { ((pansc_socket_addr_in)&xskt_client_addr)->sin_addr.s_addr = XSKT_SOCKET_ANY_ADDRESS; } else { ((pansc_socket_addr_in)&xskt_client_addr)->sin_addr.s_addr = pMyObject->HostAddress.Value; } if ( _xskt_bind((XSKT_SOCKET)pMyObject->Socket, (xskt_socket_addr*)&xskt_client_addr, sizeof(xskt_client_addr)) != 0 ) { AnscTrace("!!!!!!!!!! _xskt_bind error: socket=%d, error=%d !!!!!!!!!!\n", (XSKT_SOCKET)pMyObject->Socket, errno); { int j; char s[256]; char *ptr1 = ((xskt_socket_addr*)(&xskt_client_addr))->sa_data; char stmp[16]; s[0] = '\0'; for(j=0; j<13; j++) { sprintf(stmp, "%.2x:", *(ptr1++)); strcat(s, stmp); } sprintf(stmp, "%.2x", *ptr1); strcat(s, stmp); AnscTrace("!!!!!!!!!! _xskt_bind error: client_addr=%s\n", s); } perror("_xskt_bind error"); if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } } else { ansc_client_addr.sin_family = ANSC_SOCKET_AF_INET; ansc_client_addr.sin_port = _ansc_htons(pMyObject->HostPort); if (pMyObject->bSocketBindToDevice && *(pMyObject->SocketDeviceName)) { if (_xskt_setsocketopt ( pMyObject->Socket, ANSC_SOCKET_SOL_SOCKET, ANSC_SOCKET_SO_BINDTODEVICE, pMyObject->SocketDeviceName, _ansc_strlen(pMyObject->SocketDeviceName) + 1 ) < 0) { perror("setsockopt-SOL_SOCKET-SO_BINDTODEVICE"); returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } } // fprintf(stderr, "<RT AnscSKT> Binding socket to Device '%s'.\n", pMyObject->SocketDeviceName); if ( pMyObject->HostAddress.Value == 0 ) { ansc_client_addr.sin_addr.s_addr = ANSC_SOCKET_ANY_ADDRESS; } else { ansc_client_addr.sin_addr.s_addr = pMyObject->HostAddress.Value; } if ( _ansc_bind(pMyObject->Socket, (ansc_socket_addr*)&ansc_client_addr, sizeof(ansc_client_addr)) != 0 ) { AnscTrace("!!!!!!!!!! _ansc_bind error: socket=%d, error=%d !!!!!!!!!!\n", (XSKT_SOCKET)pMyObject->Socket, errno); { int j; char s[256]; char *ptr1 = ((ansc_socket_addr*)(&ansc_client_addr))->sa_data; char stmp[16]; s[0] = '\0'; for(j=0; j<13; j++) { sprintf(stmp, "%.2x:", *(ptr1++)); strcat(s, stmp); } sprintf(stmp, "%.2x", *ptr1); strcat(s, stmp); AnscTrace("!!!!!!!!!! _ansc_bind error: client_addr=%s\n", s); } perror("_ansc_bind error"); if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } } #endif /* * As a Tcp client application, we now try to connect the network server, whose address is * specified by the "peer address" and "peer port" fields. */ if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { #ifdef _ANSC_IPV6_COMPATIBLE_ BOOL bNoConn = TRUE; #endif _ansc_memset(&xskt_server_addr, 0, sizeof(xskt_server_addr)); xskt_server_addr.sin_family = XSKT_SOCKET_AF_INET; xskt_server_addr.sin_addr.s_addr = pMyObject->PeerAddress.Value; xskt_server_addr.sin_port = _xskt_htons(pMyObject->PeerPort); #ifdef _ANSC_IPV6_COMPATIBLE_ while ( bNoConn && pxskt_server_addrinfo ) { if ( _xskt_connect((XSKT_SOCKET)pMyObject->Socket, pxskt_server_addrinfo->ai_addr, pxskt_server_addrinfo->ai_addrlen) != 0 ) { pxskt_server_addrinfo = pxskt_server_addrinfo->ai_next; /* try next ip address */ } else { bNoConn = FALSE; break; } } if ( bNoConn ) #else if ( _xskt_connect((XSKT_SOCKET)pMyObject->Socket, (xskt_socket_addr*)&xskt_server_addr, sizeof(xskt_server_addr)) != 0 ) #endif { AnscTrace("!!!!!!!!!! _xskt_connect error: socket=%d, error=%d !!!!!!!!!!\n", (XSKT_SOCKET)pMyObject->Socket, errno); { int j; char s[256]; char *ptr1 = ((xskt_socket_addr*)(&xskt_server_addr))->sa_data; char stmp[16]; s[0] = '\0'; for(j=0; j<13; j++) { sprintf(stmp, "%.2x:", *(ptr1++)); strcat(s, stmp); } sprintf(stmp, "%.2x", *ptr1); strcat(s, stmp); AnscTrace("!!!!!!!!!! _xskt_connect error: server_addr=%s\n", s); } perror("_xskt_connect error"); s_error = _xskt_get_last_error(); if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_TIMEOUT, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } } else { _ansc_memset(&ansc_server_addr, 0, sizeof(ansc_server_addr)); ansc_server_addr.sin_family = ANSC_SOCKET_AF_INET; ansc_server_addr.sin_addr.s_addr = pMyObject->PeerAddress.Value; ansc_server_addr.sin_port = _ansc_htons(pMyObject->PeerPort); #ifdef _ANSC_IPV6_COMPATIBLE_ if ( _ansc_connect(pMyObject->Socket, pansc_server_addrinfo->ai_addr, pansc_server_addrinfo->ai_addrlen) != 0 ) #else if ( _ansc_connect(pMyObject->Socket, (ansc_socket_addr*)&ansc_server_addr, sizeof(ansc_server_addr)) != 0 ) #endif { s_error = _ansc_get_last_error(); AnscTrace("!!! Connect error: %d, %s !!!\n", s_error, strerror(s_error)); if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_SOCKET_TIMEOUT, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } } /* * We have gone so far that all socket operations succeeded, we want to allocate a buffer that * is big enough for any incoming message. */ if ( !pMyObject->RecvBuffer && !(pMyObject->Mode & ANSC_SCTO_MODE_FOREIGN_BUFFER) ) { pMyObject->RecvBuffer = AnscAllocateMemory(pMyObject->RecvBufferSize); pMyObject->RecvPacketSize = 0; pMyObject->RecvOffset = 0; if ( !pMyObject->RecvBuffer ) { returnStatus = ANSC_STATUS_RESOURCES; goto EXIT2; } } pMyObject->RecvBytesCount = 0; pMyObject->SendBytesCount = 0; pMyObject->LastRecvAt = AnscGetTickInSeconds(); pMyObject->LastSendAt = AnscGetTickInSeconds(); /* * If the compilation option '_ANSC_SOCKET_TLS_LAYER_' is enabled, we can simply let the ANSC * socket layer to perform the SSL/TLS functionality; otherwise, we need to prepare for doing * SSL/TLS internally. */ if ( pMyObject->Mode & ANSC_SCTO_MODE_TLS_ENABLED ) { #ifdef _ANSC_USE_OPENSSL_ pMyObject->bTlsEnabled = TRUE; if ( !openssl_init(SSL_CLIENT_CALLS) ) { AnscTrace("AnscSctoEngage - openssl_init() failed!\n"); returnStatus = ANSC_STATUS_FAILURE; goto EXIT2; } #else #ifdef _ANSC_SOCKET_TLS_LAYER_ { _ansc_en_usetls(pMyObject->Socket); pMyObject->bTlsEnabled = FALSE; } #else { pMyObject->hTlsScsIf = (pMyObject->hTlsScsIf != NULL)? pMyObject->hTlsScsIf : AnscSocketTlsGetScsIf(); pMyObject->bTlsEnabled = TRUE; } #endif #endif } /* * To save the worker object from having to deal with blocking/non-blocking/async receiving * functions provided by underlying socket layer, we create a separate task to do that. */ returnStatus = pMyObject->SpawnTask3 ( (ANSC_HANDLE)pMyObject, (void* )pMyObject->RecvTask, (ANSC_HANDLE)pMyObject, ANSC_SCTO_RECV_TASK_NAME, USER_DEFAULT_TASK_PRIORITY, 11*USER_DEFAULT_TASK_STACK_SIZE ); #ifdef _ANSC_USE_OPENSSL_ if ( pMyObject->bTlsEnabled ) { SSL *ssl = NULL; ssl = openssl_connect (pMyObject->Socket); if ( !ssl ) { pMyObject->bTlsConnected = FALSE; returnStatus = ANSC_STATUS_FAILURE; //PANSC_SCTO_WORKER_OBJECT pWorker = (PANSC_SCTO_WORKER_OBJECT)pMyObject->hWorker; if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_TLS_ERROR, (ANSC_HANDLE)0L ); } } else { s_error = openssl_validate_certificate (pMyObject->Socket, pMyObject->HostName, ssl, SSL_CLIENT_CALLS); if ( s_error == 0 ) { AnscTrace("AnscSctoEngage - openssl_validate_certificate() failed %p.\n", ssl); //PANSC_SCTO_WORKER_OBJECT pWorker = (PANSC_SCTO_WORKER_OBJECT )pMyObject->hWorker; if ( pMyObject->Mode & ANSC_SCTO_MODE_NO_BSP_NOTIFY_CONN_ERR == 0 ) { pWorker->Notify ( pWorker->hWorkerContext, ANSC_SCTOWO_EVENT_TLS_ERROR, (ANSC_HANDLE)NULL ); } returnStatus = ANSC_STATUS_FAILURE; } pMyObject->hTlsConnection = ssl; pMyObject->bTlsConnected = TRUE; } } #else /* * If SSL/TLS is enabled, we should complete TLS handshake before returning from Engage(). This * behavior allows a single consistent API to used between this object and the worker object. * Since the handshake will take multiple messages to complete, we need to block the current * task until being notified by the TLS module. */ if ( pMyObject->bTlsEnabled && pMyObject->hTlsScsIf ) { pMyObject->bTlsConnected = FALSE; pMyObject->InitTlsClient((ANSC_HANDLE)pMyObject); } #endif if ( returnStatus != ANSC_STATUS_SUCCESS ) { goto EXIT2; } return ANSC_STATUS_SUCCESS; /****************************************************************** GRACEFUL ROLLBACK PROCEDURES AND EXIT DOORS ******************************************************************/ EXIT2: AnscTrace("AnscSctoEngage - failed with status %lu, socket error %d!\n", returnStatus, s_error); if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { _xskt_closesocket((XSKT_SOCKET)pMyObject->Socket); } else { _ansc_closesocket(pMyObject->Socket); } EXIT1: if ( returnStatus != ANSC_STATUS_SUCCESS ) { pMyObject->bActive = FALSE; pMyObject->Reset((ANSC_HANDLE)pMyObject); } return returnStatus; }
ANSC_STATUS AnscSctoCancel ( ANSC_HANDLE hThisObject ) { PANSC_SIMPLE_CLIENT_TCP_OBJECT pMyObject = (PANSC_SIMPLE_CLIENT_TCP_OBJECT)hThisObject; if ( !pMyObject->bActive ) { return ANSC_STATUS_SUCCESS; } else { pMyObject->bShuttingDown = TRUE; pMyObject->bActive = FALSE; pMyObject->bClosed = TRUE; while ( pMyObject->EngineTaskCount != 0 ) { AnscSleep(500); } } #ifdef _ANSC_USE_OPENSSL_ if ( pMyObject->hTlsConnection ) { SSL *ssl = (SSL *) pMyObject->hTlsConnection; AnscTrace ("SSL connection %p is closed.\n", ssl); SSL_shutdown (ssl); SSL_free (ssl); } #else if ( pMyObject->bTlsEnabled && pMyObject->hTlsScsIf ) { PTLS_SCS_INTERFACE pTlsScsIf = (PTLS_SCS_INTERFACE )pMyObject->hTlsScsIf; AnscSetEvent(&pMyObject->TlsConnEvent); if ( pMyObject->hTlsConnection ) { if ( pMyObject->bTlsConnected ) { pTlsScsIf->CloseConnection ( pTlsScsIf->hOwnerContext, pMyObject->hTlsConnection ); } pTlsScsIf->RemoveConnection ( pTlsScsIf->hOwnerContext, pMyObject->hTlsConnection ); } pMyObject->bTlsConnected = FALSE; } #endif if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { if ( (XSKT_SOCKET)pMyObject->Socket != XSKT_SOCKET_INVALID_SOCKET ) { _xskt_shutdown (((XSKT_SOCKET)pMyObject->Socket), XSKT_SOCKET_SD_RECV); _xskt_closesocket(((XSKT_SOCKET)pMyObject->Socket)); pMyObject->Socket = (ANSC_SOCKET)XSKT_SOCKET_INVALID_SOCKET; } } else { if ( pMyObject->Socket != ANSC_SOCKET_INVALID_SOCKET ) { _ansc_shutdown (pMyObject->Socket, ANSC_SOCKET_SD_RECV); _ansc_closesocket(pMyObject->Socket); pMyObject->Socket = ANSC_SOCKET_INVALID_SOCKET; } } /* * The underlying socket wrapper may require an explicit cleanup() call, such is the case on * Microsoft windows platforms. The wrapper initialization has to done for each task. On most * real-time operating systems, this call is not required. */ if ( pMyObject->Mode & ANSC_SCTO_MODE_XSOCKET ) { AnscCleanupXsocketWrapper((ANSC_HANDLE)pMyObject); } else { AnscCleanupSocketWrapper((ANSC_HANDLE)pMyObject); } pMyObject->Reset((ANSC_HANDLE)pMyObject); return ANSC_STATUS_SUCCESS; }
/********************************************************************** caller: owner of this object prototype: ANSC_STATUS AnscAsn1EnumerateDecodingData ( ANSC_HANDLE hThisObject, PVOID* ppEncoding ); description: This function is decoding data for ASN.1 object. argument: ANSC_HANDLE hThisObject This handle is actually the pointer of this object itself. PVOID* ppEncoding The pointer of the input binary data return: status of decoding operation **********************************************************************/ ANSC_STATUS AnscAsn1EnumerateDecodingData ( ANSC_HANDLE hThisObject, PVOID* ppEncoding ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PANSC_ASN1_ENUMERATE pMyObject = (PANSC_ASN1_ENUMERATE)hThisObject; PANSC_TAGINFO_OBJECT pTagInfo = NULL; BOOLEAN bTagIncluded = TRUE; ULONG uLeftSize,uInfiniteTags; /* * pointer to the start of unexamined raw encoding data */ PUCHAR pEncodingUnit; /* check the parameters */ if( hThisObject == NULL || ppEncoding == NULL) { return ANSC_ASN1_BAD_PARAMETER; } /* * check before decoding; */ if( pMyObject->BeforeDecoding != NULL) { returnStatus = pMyObject->BeforeDecoding(pMyObject, ppEncoding); if( ANSC_STATUS_SUCCESS != returnStatus) { return returnStatus; } } /* parsing the data */ pEncodingUnit = (PUCHAR)*ppEncoding; /* * Decode the attrlist first; */ returnStatus = AttrListDecodingData ( &pMyObject->sAttrList, (PVOID*)&pEncodingUnit, pMyObject->IsConstructive(pMyObject), &bTagIncluded, &uLeftSize, &uInfiniteTags ); if( ANSC_STATUS_SUCCESS != returnStatus) { return returnStatus; } /* if tag included, decode the tag */ if( bTagIncluded) { pTagInfo = (PANSC_TAGINFO_OBJECT)AnscTagInfoCreate(); if( pTagInfo == NULL) { return ANSC_STATUS_RESOURCES; } returnStatus = pTagInfo->ParsingData((ANSC_HANDLE)pTagInfo, pEncodingUnit); if( returnStatus != ANSC_STATUS_SUCCESS) { pTagInfo->Remove((ANSC_HANDLE)pTagInfo); return returnStatus; } /* check the tag matched or not */ if( pTagInfo->FirstOctetOfTag != pMyObject->GetFirstOctet((ANSC_HANDLE)pMyObject) || pTagInfo->GetSizeOfTag(pTagInfo) != 1 ) { /* AnscTrace ( "Unexpected tag in ASN1_ENUMERATE - '0x%.2X', expected - '0x%.2X'\n", pTagInfo->FirstOctetOfTag, pMyObject->GetFirstOctet((ANSC_HANDLE)pMyObject) ); */ pTagInfo->Remove((ANSC_HANDLE)pTagInfo); return ANSC_ASN1_UNEXPECTED_TAG; } if( pTagInfo->ulContentLength == 0) { AnscTrace("The length of ENUMERATE value is 0, unacceptable.\n"); pTagInfo->Remove((ANSC_HANDLE)pTagInfo); return ANSC_ASN1_UNACCEPTABLE_VALUE_SIZE; } if( pTagInfo->ulContentLength < 0) { AnscTrace("Infinite form is unacceptable for ENUMERATE object.\n"); pTagInfo->Remove((ANSC_HANDLE)pTagInfo); return ANSC_ASN1_UNACCEPTABLE_VALUE_SIZE; } pEncodingUnit += pTagInfo->GetSizeOfLength(pTagInfo) + 1; uLeftSize = pTagInfo->ulContentLength; pTagInfo->Remove((ANSC_HANDLE)pTagInfo); } if( uInfiniteTags > 0) { AnscTrace("Infinite form is unacceptable for NUMERATE object.\n"); return ANSC_ASN1_INVALID_ENCODE_LENGTH; } if( uLeftSize > sizeof(ULONG)) { AnscTrace("The length of ENUMERATE value is '%d', unacceptable.\n", uLeftSize); return ANSC_ASN1_UNACCEPTABLE_VALUE_SIZE; } /************************************************** * * Decode the value; * **************************************************/ pMyObject->uLength = uLeftSize; pMyObject->uValue = GetLengthFromBuffer( pEncodingUnit, uLeftSize); if( pEncodingUnit[0] == 0x00 && uLeftSize != 1) { pMyObject->bFirstZero = TRUE; } else { pMyObject->bFirstZero = FALSE; } pEncodingUnit += uLeftSize; /* * check after decoding; */ if( pMyObject->AfterDecoding != NULL) { returnStatus = pMyObject->AfterDecoding(pMyObject, (PVOID*)&pEncodingUnit); if( ANSC_STATUS_SUCCESS != returnStatus) { return returnStatus; } } *ppEncoding = (PVOID)pEncodingUnit; pMyObject->bOptional = FALSE; return returnStatus; }
ANSC_STATUS HttpSpoPrvwoRemove ( ANSC_HANDLE hThisObject, ANSC_HANDLE hSocket ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PHTTP_SIMPLE_PROXY_OBJECT pMyObject = (PHTTP_SIMPLE_PROXY_OBJECT )hThisObject; PHTTP_SIMPLE_PROXY_PROPERTY pProperty = (PHTTP_SIMPLE_PROXY_PROPERTY )&pMyObject->Property; PANSC_SIMPLE_PROXY_TCP_OBJECT pSimpleProxy = (PANSC_SIMPLE_PROXY_TCP_OBJECT )pMyObject->hSimpleProxy; PHTTP_WAM_INTERFACE pWamIf = (PHTTP_WAM_INTERFACE )pMyObject->hWamIf; PANSC_DAEMON_SOCKET_TCP_OBJECT pClientSocket = (PANSC_DAEMON_SOCKET_TCP_OBJECT)hSocket; PANSC_BROKER_SOCKET_TCP_OBJECT pServerSocket = (PANSC_BROKER_SOCKET_TCP_OBJECT)NULL; PANSC_BUFFER_DESCRIPTOR pBufferDesp = (PANSC_BUFFER_DESCRIPTOR )pClientSocket->GetBufferContext((ANSC_HANDLE)pClientSocket); PHTTP_PROXY_SESSION_OBJECT pSession = NULL; AnscTrace ( "PrvwoRemove removes the client connection of %d.%d.%d.%d / TCP %d\n", pClientSocket->PeerAddress.Dot[0], pClientSocket->PeerAddress.Dot[1], pClientSocket->PeerAddress.Dot[2], pClientSocket->PeerAddress.Dot[3], pClientSocket->PeerPort ); AnscAcquireLock(&pMyObject->SyncLock); pSession = (PHTTP_PROXY_SESSION_OBJECT)pClientSocket->GetClientContext((ANSC_HANDLE)pClientSocket); if ( pSession ) { pSession->AcquireAccess((ANSC_HANDLE)pSession); pServerSocket = (PANSC_BROKER_SOCKET_TCP_OBJECT)pSession->GetServerSocket((ANSC_HANDLE)pSession); } else { pServerSocket = NULL; } if ( pServerSocket ) { pServerSocket->SetClientContext((ANSC_HANDLE)pServerSocket, (ANSC_HANDLE)NULL ); pServerSocket->ToClean ((ANSC_HANDLE)pServerSocket, TRUE, HTTP_SPO_SOCKET_TTC); } AnscReleaseLock(&pMyObject->SyncLock); /* * Just a couple regular clean-up tasks to do: * * (1) dis-associate the proxy session object from the client socket * (2) clean the foreign buffer associated with the client socket * (3) dis-associate the proxy session object from the server socket * * Note that we CANNOT clean the foreign buffer associated with the server socket because the * access to that buffer is NOT synchornized between the prv_recv() and pub_recv routines. It * SHOULD be done in the pub_remove() function. */ pClientSocket->SetClientContext((ANSC_HANDLE)pClientSocket, (ANSC_HANDLE)NULL); pClientSocket->SetBufferContext((ANSC_HANDLE)pClientSocket, NULL, 0, (ANSC_HANDLE)NULL); if ( pBufferDesp ) { AnscFreeBdo((ANSC_HANDLE)pBufferDesp); } if ( !pSession ) { return ANSC_STATUS_SUCCESS; } pSession->ReleaseAccess((ANSC_HANDLE)pSession); pSession->Close ((ANSC_HANDLE)pSession); pSession->Return ((ANSC_HANDLE)pSession); return ANSC_STATUS_SUCCESS; }
ANSC_STATUS HttpSpoPrvwoNotify ( ANSC_HANDLE hThisObject, ANSC_HANDLE hSocket, ULONG ulEvent, ANSC_HANDLE hReserved ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PHTTP_SIMPLE_PROXY_OBJECT pMyObject = (PHTTP_SIMPLE_PROXY_OBJECT )hThisObject; PHTTP_SIMPLE_PROXY_PROPERTY pProperty = (PHTTP_SIMPLE_PROXY_PROPERTY )&pMyObject->Property; PANSC_SIMPLE_PROXY_TCP_OBJECT pSimpleProxy = (PANSC_SIMPLE_PROXY_TCP_OBJECT )pMyObject->hSimpleProxy; PANSC_DAEMON_SOCKET_TCP_OBJECT pClientSocket = (PANSC_DAEMON_SOCKET_TCP_OBJECT)hSocket; PANSC_BROKER_SOCKET_TCP_OBJECT pServerSocket = (PANSC_BROKER_SOCKET_TCP_OBJECT)NULL; PANSC_BUFFER_DESCRIPTOR pBufferDesp = (PANSC_BUFFER_DESCRIPTOR )pClientSocket->GetBufferContext((ANSC_HANDLE)pClientSocket); PHTTP_PROXY_SESSION_OBJECT pSession = NULL; AnscTrace ( "Event = %d is indicated on client connection of %d.%d.%d.%d / TCP %d\n", ulEvent, pClientSocket->PeerAddress.Dot[0], pClientSocket->PeerAddress.Dot[1], pClientSocket->PeerAddress.Dot[2], pClientSocket->PeerAddress.Dot[3], pClientSocket->PeerPort ); switch ( ulEvent ) { case ANSC_SPTOWO_EVENT_SOCKET_ERROR : pClientSocket->ToClean((ANSC_HANDLE)pClientSocket, TRUE, HTTP_SPO_SOCKET_TTC); break; case ANSC_SPTOWO_EVENT_SOCKET_CLOSED : AnscAcquireLock(&pMyObject->SyncLock); pSession = (PHTTP_PROXY_SESSION_OBJECT)pClientSocket->GetClientContext((ANSC_HANDLE)pClientSocket); if ( !pSession ) { AnscReleaseLock(&pMyObject->SyncLock); pClientSocket->Finish((ANSC_HANDLE)pClientSocket); break; } else { pSession->AcquireAccess((ANSC_HANDLE)pSession); } AnscReleaseLock(&pMyObject->SyncLock); pBufferDesp->BlockSize += pClientSocket->RecvPacketSize; returnStatus = pClientSocket->SetBufferContext ( (ANSC_HANDLE)pClientSocket, NULL, 0, (ANSC_HANDLE)NULL ); returnStatus = pSession->FinishedByClient ( (ANSC_HANDLE)pSession, AnscBdoGetBlock (pBufferDesp), AnscBdoGetBlockSize(pBufferDesp), (ANSC_HANDLE)pBufferDesp ); pSession->ReleaseAccess((ANSC_HANDLE)pSession); pClientSocket->Finish((ANSC_HANDLE)pClientSocket); break; case ANSC_SPTOWO_EVENT_RESOURCES : break; case ANSC_SPTOWO_EVENT_TIME_OUT : break; default : break; } return ANSC_STATUS_SUCCESS; }
ANSC_STATUS AnscBetoSendTask ( ANSC_HANDLE hThisObject ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS; PANSC_BROKER_ENGINE_TCP_OBJECT pMyObject = (PANSC_BROKER_ENGINE_TCP_OBJECT)hThisObject; ansc_fd_set* pSendSet1 = (ansc_fd_set* )pMyObject->SendSocketSet; xskt_fd_set* pSendSet2 = (xskt_fd_set* )pMyObject->SendSocketSet; PANSC_BROKER_SERVER_TCP_OBJECT pServer = (PANSC_BROKER_SERVER_TCP_OBJECT)pMyObject->hBrokerServer; PANSC_BSTO_WORKER_OBJECT pWorker = (PANSC_BSTO_WORKER_OBJECT )pServer->hWorker; PANSC_BETO_PACKET_OBJECT pPacket = NULL; PANSC_BROKER_SOCKET_TCP_OBJECT pSocket = NULL; PSINGLE_LINK_ENTRY pSLinkEntry = NULL; BOOL bSendable = FALSE; int s_result = 0; int s_error = 0; AnscTrace("AnscBetoSendTask is activated ...!\n"); /* * As a scalable server implemention, we shall accept as many incoming client connections as * possible and can only be limited by the system resources. Once the listening socket becomes * readable, which means an incoming connection attempt has arrived. We create a new socket * object and associate it with the client. This is a repeated process until the socket owner * closes the socket. */ while ( pMyObject->bStarted ) { AnscAcquireLock(&pMyObject->PacketQueueLock); pSLinkEntry = AnscQueuePopEntry(&pMyObject->PacketQueue); AnscReleaseLock(&pMyObject->PacketQueueLock); if ( !pSLinkEntry ) { continue; } else { pPacket = ACCESS_ANSC_BETO_PACKET_OBJECT(pSLinkEntry); pSocket = (PANSC_BROKER_SOCKET_TCP_OBJECT)pPacket->hSocket; } #if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX) AnscAcquireLock(&pMyObject->SendSocketSetLock); bSendable = (pServer->Mode & ANSC_BSTO_MODE_XSOCKET)? XSKT_SOCKET_FD_ISSET(pSocket->Socket, pSendSet2) : ANSC_SOCKET_FD_ISSET(pSocket->Socket, pSendSet1); AnscReleaseLock(&pMyObject->SendSocketSetLock); if ( !bSendable ) { returnStatus = pWorker->SendComplete ( pWorker->hWorkerContext, (ANSC_HANDLE)pSocket, pPacket->hWorkerReserved, ANSC_STATUS_FAILURE ); AnscFreeMemory(pPacket); continue; } #endif if ( pServer->Mode & ANSC_BSTO_MODE_XSOCKET ) { s_result = _xskt_send(((XSKT_SOCKET)pSocket->Socket), pPacket->PacketBuffer, (int)pPacket->PacketSize, 0); } else { s_result = _ansc_send(pSocket->Socket, pPacket->PacketBuffer, (int)pPacket->PacketSize, 0); } if ( ((s_result == XSKT_SOCKET_ERROR) && (pServer->Mode & ANSC_BSTO_MODE_XSOCKET)) || ((s_result == ANSC_SOCKET_ERROR) && !(pServer->Mode & ANSC_BSTO_MODE_XSOCKET)) ) { s_error = (pServer->Mode & ANSC_BSTO_MODE_XSOCKET)? _xskt_get_last_error() : _ansc_get_last_error(); returnStatus = pWorker->SendComplete ( pWorker->hWorkerContext, (ANSC_HANDLE)pSocket, pPacket->hWorkerReserved, ANSC_STATUS_FAILURE ); if ( pServer->Mode & ANSC_BSTO_MODE_AUTO_CLOSE ) { pMyObject->DelSocket((ANSC_HANDLE)pMyObject, (ANSC_HANDLE)pSocket); } } else { returnStatus = pWorker->SendComplete ( pWorker->hWorkerContext, (ANSC_HANDLE)pSocket, pPacket->hWorkerReserved, ANSC_STATUS_SUCCESS ); pSocket->SendBytesCount += pPacket->PacketSize; pSocket->LastSendAt = AnscGetTickInSeconds(); } } AnscSetEvent(&pMyObject->SendEvent); return ANSC_STATUS_SUCCESS; }
/************************************************************************* * * This is the api to init the KeyGenParams from the given certificate * and private key info * *************************************************************************/ ANSC_STATUS PKIUtilityInitKeyGenParams ( ANSC_HANDLE hSSLCrypto, PANSC_ASN1_CERTIFICATE pCert, PANSC_ASN1_PRIVATEKEYINFO pKeyInfo, ANSC_HANDLE hKeyGenParams ) { PANSC_CRYPTO_PUB_KEY_GEN_PARAMS pKeyGenParams = (PANSC_CRYPTO_PUB_KEY_GEN_PARAMS)hKeyGenParams; PANSC_CRYPTO_PUB_SSLEAY_OBJECT pSSLCrypto = (PANSC_CRYPTO_PUB_SSLEAY_OBJECT)hSSLCrypto; BOOLEAN bKeyPair = TRUE; PKI_KEY_TYPE keyType; if( pCert == NULL || pKeyInfo == NULL || hKeyGenParams == NULL) { return ANSC_STATUS_FAILURE; } keyType = pCert->GetKeyType(pCert); if( keyType != PKI_RSA_KEY && keyType != PKI_DSA_KEY) { return ANSC_STATUS_FAILURE; } if( keyType != pKeyInfo->GetKeyType(pKeyInfo)) { AnscTrace("The key pair is not in the same key type.\n"); return ANSC_STATUS_FAILURE; } /* init the public key */ if( ANSC_STATUS_SUCCESS != pCert->ExportPublicKey ( pCert, hKeyGenParams )) { return ANSC_STATUS_FAILURE; } /* init the private key */ if( ANSC_STATUS_SUCCESS != pKeyInfo->ExportKey ( pKeyInfo, hKeyGenParams )) { return ANSC_STATUS_FAILURE; } /* verify the key pair */ if( pSSLCrypto != NULL) { if( keyType == PKI_RSA_KEY) { bKeyPair = pSSLCrypto->KeyPairMatch ( pSSLCrypto, ANSC_CRYPTO_PUB_KEY_RSA, &pKeyGenParams->PublicKey.RSA, &pKeyGenParams->PrivateKey.RSA ); } else { bKeyPair = pSSLCrypto->KeyPairMatch ( pSSLCrypto, ANSC_CRYPTO_PUB_KEY_DSA, &pKeyGenParams->PublicKey.DSA, &pKeyGenParams->PrivateKey.DSA ); } } if( bKeyPair) { return ANSC_STATUS_SUCCESS; } else { return ANSC_STATUS_FAILURE; } }