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;
}
}
