ANSC_STATUS
CosaTSIPRemove
(
ANSC_HANDLE hThisObject
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PCOSA_DATAMODEL_TSIP pMyObject = (PCOSA_DATAMODEL_TSIP)hThisObject;
PSINGLE_LINK_ENTRY pSLinkEntry = NULL;
PCOSA_CONTEXT_LINK_OBJECT pCosaContext = NULL;
/* Remove necessary resounce */
if (AnscSListQueryDepth(&pMyObject->SubnetList) != 0)
{
pSLinkEntry = AnscSListGetFirstEntry(&pMyObject->SubnetList);
while ( pSLinkEntry )
{
pCosaContext = ACCESS_COSA_CONTEXT_LINK_OBJECT(pSLinkEntry);
pSLinkEntry = AnscSListGetNextEntry(pSLinkEntry);
AnscSListPopEntryByLink(&pMyObject->SubnetList, &pCosaContext->Linkage);
AnscFreeMemory(pCosaContext->hContext);
AnscFreeMemory(pCosaContext);
}
}
if (AnscSListQueryDepth(&pMyObject->RuleList) != 0)
{
pSLinkEntry = AnscSListGetFirstEntry(&pMyObject->RuleList);
while ( pSLinkEntry )
{
pCosaContext = ACCESS_COSA_CONTEXT_LINK_OBJECT(pSLinkEntry);
pSLinkEntry = AnscSListGetNextEntry(pSLinkEntry);
AnscSListPopEntryByLink(&pMyObject->RuleList, &pCosaContext->Linkage);
AnscFreeMemory(pCosaContext->hContext);
AnscFreeMemory(pCosaContext);
}
}
/* Remove self */
AnscFreeMemory((ANSC_HANDLE)pMyObject);
return returnStatus;
}
ULONG
IPv6rdIF_GetEntryCount(
ANSC_HANDLE hInsContext)
{
PCOSA_DATAMODEL_IPV6RD pMyObject = (PCOSA_DATAMODEL_IPV6RD)g_pCosaBEManager->hIPv6rd;
if (!pMyObject)
return -1;
return AnscSListQueryDepth(&pMyObject->IfList);
}
ULONG
IPv4PingServerTable_GetEntryCount
(
ANSC_HANDLE hInsContext
)
{
PCOSA_DATAMODEL_SELFHEAL pMyObject = (PCOSA_DATAMODEL_SELFHEAL)g_pCosaBEManager->hSelfHeal;
return AnscSListQueryDepth( &pMyObject->IPV4PingServerList );
}
ANSC_STATUS
AnscDetoSnapshot
(
ANSC_HANDLE hThisObject,
ANSC_HANDLE hForm
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PANSC_DAEMON_ENGINE_TCP_OBJECT pMyObject = (PANSC_DAEMON_ENGINE_TCP_OBJECT)hThisObject;
ansc_fd_set* pRecvSet = (ansc_fd_set* )pMyObject->RecvSocketSet;
ansc_fd_set* pSendSet = (ansc_fd_set* )pMyObject->SendSocketSet;
PANSC_DSTO_SNAPSHOT_FORM pSnapshotForm = (PANSC_DSTO_SNAPSHOT_FORM )hForm;
ULONG ulClientCount = 0;
ULONG i = 0;
AnscAcquireLock(&pMyObject->SocketTableLock);
for ( i = 0; i < ANSC_DETO_SOCKET_TABLE_SIZE; i++ )
{
ulClientCount += AnscSListQueryDepth(&pMyObject->SocketTable[i]);
}
AnscReleaseLock(&pMyObject->SocketTableLock);
pSnapshotForm->StartTime = pMyObject->StartTime;
pSnapshotForm->MaxClientCount = pMyObject->MaxSocketCount;
pSnapshotForm->OffClientCount = pMyObject->CurSocketCount;
pSnapshotForm->CurClientCount = ulClientCount;
#if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX)
pSnapshotForm->CurRecvSetSize = (ULONG)pRecvSet->fd_count;
pSnapshotForm->CurSendSetSize = (ULONG)pSendSet->fd_count;
#endif
pSnapshotForm->AvgServingTime = pMyObject->AvgServingTime;
pSnapshotForm->TtcCount = pMyObject->TtcCount;
pSnapshotForm->MtcCount = pMyObject->MtcCount;
pSnapshotForm->TrcCount = pMyObject->TrcCount;
pSnapshotForm->MrcCount = pMyObject->MrcCount;
pSnapshotForm->TscCount = pMyObject->TscCount;
pSnapshotForm->MscCount = pMyObject->MscCount;
return ANSC_STATUS_SUCCESS;
}
ULONG
BwrmPmoGetPageCount
(
ANSC_HANDLE hThisObject
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PBWRM_PAGE_MANAGER_OBJECT pMyObject = (PBWRM_PAGE_MANAGER_OBJECT )hThisObject;
PBWRM_PAGE_MANAGER_PROPERTY pProperty = (PBWRM_PAGE_MANAGER_PROPERTY )&pMyObject->Property;
PANSC_TIMER_DESCRIPTOR_OBJECT pCacheTimerObject = (PANSC_TIMER_DESCRIPTOR_OBJECT)pMyObject->hCacheTimerObject;
ULONG ulPageCount = 0;
ULONG i = 0;
AnscAcquireLock(&pMyObject->CpoTableLock);
for ( i = 0; i < BWRM_PMO_CPO_TABLE_SIZE; i++ )
{
ulPageCount += AnscSListQueryDepth(&pMyObject->CpoTable[i]);
}
AnscReleaseLock(&pMyObject->CpoTableLock);
return ulPageCount;
}
ANSC_STATUS
HttpAuthcoAddAuthInfo
(
ANSC_HANDLE hThisObject,
ANSC_HANDLE hRequest,
ANSC_HANDLE hChallenge
)
{
ANSC_STATUS status = ANSC_STATUS_SUCCESS;
PHTTP_AUTH_CLIENT_OBJECT pMyObject = (PHTTP_AUTH_CLIENT_OBJECT)hThisObject;
PHTTP_BMO_REQ_OBJECT pRequest = (PHTTP_BMO_REQ_OBJECT )hRequest;
PHTTP_AUTH_CHALLENGE pChallenge = (PHTTP_AUTH_CHALLENGE )hChallenge;
PHTTP_AUTHO_INFO pAuthInfo = NULL;
PHTTP_AUTHO_DIGEST_INFO pDigestInfo = NULL;
PHTTP_ACM_INTERFACE pHttpAcmIf = (PHTTP_ACM_INTERFACE )pMyObject->hAcmIf;
BOOL bDigestAuth = (pChallenge->AuthType == HTTP_AUTH_TYPE_DIGEST);
PUCHAR pHostName = NULL;
PUCHAR pUriPath = NULL;
USHORT HostPort = 0;
BOOL bParentUri = FALSE;
if ( !pHttpAcmIf )
{
return ANSC_STATUS_INTERNAL_ERROR;
}
status = pMyObject->GetRequestHostUri((ANSC_HANDLE)pMyObject, hRequest, &pHostName, &HostPort, &pUriPath);
if ( status != ANSC_STATUS_SUCCESS )
{
status = ANSC_STATUS_INTERNAL_ERROR;
goto ABNORM;
}
AnscAcquireLock(&pMyObject->AuthInfoListLock);
pAuthInfo = (PHTTP_AUTHO_INFO)pMyObject->FindAuthInfo2((ANSC_HANDLE)pMyObject, hRequest, &bParentUri);
if ( pAuthInfo )
{
AnscSListPopEntryByLink(&pMyObject->AuthInfoList, &pAuthInfo->Linkage);
HttpAuthInfoRemove(pAuthInfo);
pAuthInfo = NULL;
}
HttpAuthInfoCreate(pAuthInfo);
if ( !pAuthInfo )
{
status = ANSC_STATUS_RESOURCES;
goto EXIT;
}
if ( bDigestAuth )
{
HttpAuthDigestInfoCreate(pAuthInfo->pDigest);
if ( !pAuthInfo->pDigest )
{
status = ANSC_STATUS_RESOURCES;
goto EXIT;
}
}
/* set up authentication info */
pAuthInfo->AuthType = pChallenge->AuthType;
status =
pHttpAcmIf->GetCredential
(
pHttpAcmIf->hOwnerContext,
pHostName,
HostPort,
pUriPath,
&pAuthInfo->pUserName,
&pAuthInfo->pPassword
);
if ( status != ANSC_STATUS_SUCCESS )
{
goto EXIT;
}
pAuthInfo->pHostName = pHostName;
pAuthInfo->HostPort = HostPort;
pAuthInfo->pUri = pUriPath;
if ( !bDigestAuth )
{
/* basic authentication */
PHTTP_CHALLENGE_BASIC pBasicChal = &pChallenge->Challenge.Basic;
pAuthInfo->pRealm = AnscCloneString(pBasicChal->Realm);
}
else
{
/* digest authentication */
PHTTP_CHALLENGE_DIGEST pDigestChal = &pChallenge->Challenge.Digest;
PUCHAR pChal = (PUCHAR)pDigestChal->Realm;
pMyObject->GetDigestAuthInfo
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pAuthInfo,
pChal
);
}
/* sweep out old entries */
if ( TRUE )
{
ULONG ulCount = (ULONG)AnscSListQueryDepth(&pMyObject->AuthInfoList);
while ( ulCount >= pMyObject->AuthInfoMaxCount )
{
PSINGLE_LINK_ENTRY pLastEntry = NULL;
pLastEntry = AnscSListGetLastEntry(&pMyObject->AuthInfoList);
AnscSListPopEntryByLink(&pMyObject->AuthInfoList, pLastEntry);
ulCount --;
}
}
AnscSListPushEntry(&pMyObject->AuthInfoList, &pAuthInfo->Linkage);
status = ANSC_STATUS_SUCCESS;
EXIT:
AnscReleaseLock(&pMyObject->AuthInfoListLock);
ABNORM:
if ( status != ANSC_STATUS_SUCCESS )
{
if ( pHostName )
{
AnscFreeMemory(pHostName);
}
if ( pUriPath )
{
AnscFreeMemory(pUriPath);
}
if ( pAuthInfo )
{
HttpAuthInfoRemove(pAuthInfo);
}
}
return status;
}
ANSC_HANDLE
IPv4PingServerTable_AddEntry
(
ANSC_HANDLE hInsContext,
ULONG* pInsNumber
)
{
PCOSA_DATAMODEL_SELFHEAL pSelfHeal = (PCOSA_DATAMODEL_SELFHEAL)g_pCosaBEManager->hSelfHeal;
PCOSA_DML_SELFHEAL_IPv4_SERVER_TABLE pServerIpv4 = NULL;
PCOSA_CONTEXT_SELFHEAL_LINK_OBJECT pSelfHealCxtLink = NULL;
PSINGLE_LINK_ENTRY pSListEntry = NULL;
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
CHAR tmpBuff[64] = {0};
CHAR buf[8];
BOOL bridgeMode;
PCOSA_DATAMODEL_SELFHEAL pMyObject = (PCOSA_DATAMODEL_SELFHEAL)g_pCosaBEManager->hSelfHeal;
int Qdepth = 0;
pServerIpv4 = (PCOSA_DML_SELFHEAL_IPv4_SERVER_TABLE)AnscAllocateMemory(sizeof(COSA_DML_SELFHEAL_IPv4_SERVER_TABLE));
if ( !pServerIpv4 )
{
CcspTraceWarning(("%s resource allocation failed\n",__FUNCTION__));
return NULL;
}
pSelfHealCxtLink = (PCOSA_CONTEXT_SELFHEAL_LINK_OBJECT)AnscAllocateMemory(sizeof(COSA_CONTEXT_SELFHEAL_LINK_OBJECT));
if ( !pSelfHealCxtLink )
{
goto EXIT;
}
Qdepth = AnscSListQueryDepth( &pSelfHeal->IPV4PingServerList );
pSelfHealCxtLink->InstanceNumber = pSelfHeal->ulIPv4NextInstanceNumber;
pServerIpv4->InstanceNumber = pSelfHeal->ulIPv4NextInstanceNumber;
pSelfHeal->ulIPv4NextInstanceNumber++;
if (pSelfHeal->ulIPv4NextInstanceNumber == 0)
pSelfHeal->ulIPv4NextInstanceNumber = 1;
/* now we have this link content */
pSelfHealCxtLink->hContext = (ANSC_HANDLE)pServerIpv4;
pSelfHeal->pConnTest->IPv4EntryCount++;
printf("*** pSelfHeal->pConnTest->IPv4EntryCount = %d ***\n",pSelfHeal->pConnTest->IPv4EntryCount);
snprintf(buf,sizeof(buf),"%d",pSelfHeal->pConnTest->IPv4EntryCount);
if (syscfg_set(NULL, "Ipv4PingServer_Count", buf) != 0)
{
CcspTraceWarning(("syscfg_set failed\n"));
}
else
{
if (syscfg_commit() != 0)
{
CcspTraceWarning(("syscfg_commit failed\n"));
}
}
CosaSListPushEntryByInsNum(&pSelfHeal->IPV4PingServerList, (PCOSA_CONTEXT_LINK_OBJECT)pSelfHealCxtLink);
return (ANSC_HANDLE)pSelfHealCxtLink;
EXIT:
AnscFreeMemory(pServerIpv4);
return NULL;
}
ANSC_STATUS
AnscDetoRecvTask
(
ANSC_HANDLE hThisObject
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PANSC_DAEMON_ENGINE_TCP_OBJECT pMyObject = (PANSC_DAEMON_ENGINE_TCP_OBJECT)hThisObject;
PANSC_DAEMON_SERVER_TCP_OBJECT pServer = (PANSC_DAEMON_SERVER_TCP_OBJECT)pMyObject->hDaemonServer;
PANSC_DSTO_WORKER_OBJECT pWorker = (PANSC_DSTO_WORKER_OBJECT )pServer->hWorker;
#if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX)
ansc_fd_set* pRecvSet1 = (ansc_fd_set* )pMyObject->RecvSocketSet;
xskt_fd_set* pRecvSet2 = (xskt_fd_set* )pMyObject->RecvSocketSet;
#endif
PANSC_DAEMON_SOCKET_TCP_OBJECT pSocket = NULL;
ULONG ulLastCleanAt = AnscGetTickInSecondsAbs();
ANSC_SOCKET s_socket = ANSC_SOCKET_INVALID_SOCKET;
int s_result = 0;
int s_result_excp = 0;
int s_error = 0;
int i = 0;
#if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX)
ansc_fd_set* read_fd_set1 = NULL;
xskt_fd_set* read_fd_set2 = NULL;
ansc_fd_set* excp_fd_set1 = NULL;
xskt_fd_set* excp_fd_set2 = NULL;
ansc_timeval timeval1;
xskt_timeval timeval2;
#endif
AnscTrace("AnscDetoRecvTask is activated ...!\n");
#if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX)
read_fd_set1 = (ansc_fd_set*)AnscAllocateMemory(sizeof(ansc_fd_set));
read_fd_set2 = (xskt_fd_set*)AnscAllocateMemory(sizeof(xskt_fd_set));
excp_fd_set1 = (ansc_fd_set*)AnscAllocateMemory(sizeof(ansc_fd_set));
excp_fd_set2 = (xskt_fd_set*)AnscAllocateMemory(sizeof(xskt_fd_set));
if ( !read_fd_set1 || !read_fd_set2 || !excp_fd_set1 || !excp_fd_set2 )
{
goto EXIT1;
}
#endif
/*
* 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 )
{
ANSC_COMMIT_TASK();
/*
* To avoid letting the old half-dead sockets hogging up the system resource, we need to
* periodically invoke the cleaning routine. The default interval is 10 seconds, and the
* idle timeout value is 90 seconds.
*/
#if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX)
if ( pMyObject->bCleaningDemanded )
#else
if ( FALSE ) /*if ( pMyObject->bCleaningDemanded )*/
#endif
{
pMyObject->Clean((ANSC_HANDLE)pMyObject);
ulLastCleanAt = AnscGetTickInSecondsAbs();
pMyObject->bCleaningDemanded = FALSE;
}
else if ( (AnscGetTickInSecondsAbs() - ulLastCleanAt) >= ANSC_DETO_CLEAN_TASK_INTERVAL )
{
pMyObject->Clean((ANSC_HANDLE)pMyObject);
ulLastCleanAt = AnscGetTickInSecondsAbs();
pMyObject->bCleaningDemanded = FALSE;
}
/*
* Since the original bsd compatible socket api doesn't support asynchronous operation, the
* nonblocking status polling is the best we can get. As a matter of fact, the current unix
* and linux actually still don't support asynchronous notification on any socket operation.
*/
#if defined(_ANSC_KERNEL) && defined(_ANSC_LINUX)
if ( !pMyObject->CurSocketCount)
{
if ( pServer->Mode & ANSC_DSTO_MODE_EVENT_SYNC )
{
AnscWaitEvent (&pMyObject->NewSocketEvent, ANSC_DETO_WAIT_EVENT_INTERVAL);
AnscResetEvent(&pMyObject->NewSocketEvent);
if (!pMyObject->CurSocketCount)
{
AnscTaskRelinquish();
continue;
}
}
else
{
AnscSleep(ANSC_DETO_TASK_BREAK_INTERVAL);
continue;
}
}
#else
if ( pServer->Mode & ANSC_DSTO_MODE_XSOCKET )
{
AnscAcquireLock(&pMyObject->RecvSocketSetLock);
*read_fd_set2 = *pRecvSet2;
AnscReleaseLock(&pMyObject->RecvSocketSetLock);
}
else
{
AnscAcquireLock(&pMyObject->RecvSocketSetLock);
*read_fd_set1 = *pRecvSet1;
AnscReleaseLock(&pMyObject->RecvSocketSetLock);
}
if ( ( (pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && XSKT_SOCKET_FD_ISNUL(read_fd_set2)) ||
(!(pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && ANSC_SOCKET_FD_ISNUL(read_fd_set1)) )
{
if ( pServer->Mode & ANSC_DSTO_MODE_EVENT_SYNC )
{
AnscWaitEvent (&pMyObject->NewSocketEvent, ANSC_DETO_WAIT_EVENT_INTERVAL);
AnscResetEvent(&pMyObject->NewSocketEvent);
if ( pServer->Mode & ANSC_DSTO_MODE_XSOCKET )
{
AnscAcquireLock(&pMyObject->RecvSocketSetLock);
*read_fd_set2 = *pRecvSet2;
AnscReleaseLock(&pMyObject->RecvSocketSetLock);
}
else
{
AnscAcquireLock(&pMyObject->RecvSocketSetLock);
*read_fd_set1 = *pRecvSet1;
AnscReleaseLock(&pMyObject->RecvSocketSetLock);
}
if ( ( (pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && XSKT_SOCKET_FD_ISNUL(read_fd_set2)) ||
(!(pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && ANSC_SOCKET_FD_ISNUL(read_fd_set1)) )
{
AnscTaskRelinquish();
continue;
}
}
else
{
AnscSleep(ANSC_DETO_TASK_BREAK_INTERVAL);
continue;
}
}
if ( pServer->Mode & ANSC_DSTO_MODE_XSOCKET )
{
timeval2.tv_sec = (ANSC_DETO_POLL_INTERVAL_MS / 1000); /* number of seconds */
timeval2.tv_usec = (ANSC_DETO_POLL_INTERVAL_MS % 1000) * 1000; /* number of microseconds */
}
else
{
timeval1.tv_sec = (ANSC_DETO_POLL_INTERVAL_MS / 1000); /* number of seconds */
timeval1.tv_usec = (ANSC_DETO_POLL_INTERVAL_MS % 1000) * 1000; /* number of microseconds */
}
/*
* The _ansc_select() function returns the total number of socket handles that are ready
* and contained in the fd_set structures, zero if the time limit expired, or SOCKET_ERROR
* if an error occurred. Upon return, the structures are updated to reflect the subset of
* these sockets that meet the specified condition.
*/
if ( pServer->Mode & ANSC_DSTO_MODE_XSOCKET )
{
s_result = _xskt_select(XSKT_SOCKET_FD_SETSIZE, read_fd_set2, NULL, NULL, &timeval2);
}
else
{
s_result = _ansc_select(ANSC_SOCKET_FD_SETSIZE, read_fd_set1, NULL, NULL, &timeval1);
}
if ( s_result == 0 )
{
continue;
}
else if ( ( (pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && (s_result == XSKT_SOCKET_ERROR)) ||
(!(pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && (s_result == ANSC_SOCKET_ERROR)) )
{
s_error = (pServer->Mode & ANSC_DSTO_MODE_XSOCKET)? _xskt_get_last_error() : _ansc_get_last_error();
/*
* Previously we simply reset everything when _ansc_select() fails, which is not a good
* solution: we shall notify the worker module and gracefully shutdown the socket(s)
* that caused the error.
*/
/*
pMyObject->Reset((ANSC_HANDLE)pMyObject);
*/
pMyObject->ExpAllSockets((ANSC_HANDLE)pMyObject);
continue;
}
else if ( !pMyObject->bStarted )
{
break;
}
#endif
/*
* If there're multiple sockets are receiving data, we loop through the returned fd_set
* structure and process them one-by-one. However, we have a slight problem: the resulted
* fd_set consists of only the native socket handles, not the associated Socket Objects.
* We have to first retrieve the peer's IP address from the socket, and use it to find
* the associated socket object.
*/
#if defined(_ANSC_KERNEL) && defined(_ANSC_LINUX)
if (TRUE)
{
int i;
PSINGLE_LINK_ENTRY pSLinkEntry;
for ( i = 0; i < ANSC_DETO_SOCKET_TABLE_SIZE ; i++)
{
if (!AnscSListQueryDepth(&pMyObject->SocketTable[i]))
{
continue;
}
AnscAcquireLock(&pMyObject->SocketTableLock);
pSLinkEntry = AnscSListGetFirstEntry(&pMyObject->SocketTable[i]);
AnscReleaseLock(&pMyObject->SocketTableLock);
while ( pSLinkEntry )
{
pSocket = ACCESS_ANSC_DAEMON_SOCKET_TCP_OBJECT(pSLinkEntry);
pSLinkEntry = AnscSListGetNextEntry(pSLinkEntry);
if ( pSocket->bTlsEnabled )
{
pMyObject->bBusy = TRUE;
returnStatus =
pMyObject->Recv2
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pSocket
);
pMyObject->bBusy = FALSE;
}
else
{
pMyObject->bBusy = TRUE;
returnStatus =
pMyObject->Recv
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pSocket
);
pMyObject->bBusy = FALSE;
}
}
if ( !pMyObject->bStarted )
{
break;
}
}
AnscSleep(10);
}
#else
for ( i = 0; i < s_result; i++ )
{
if ( pServer->Mode & ANSC_DSTO_MODE_XSOCKET )
{
XSKT_SOCKET_FD_GET(read_fd_set2, s_socket, (ULONG)i);
}
else
{
ANSC_SOCKET_FD_GET(read_fd_set1, s_socket, (ULONG)i);
}
if ( ( (pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && (s_socket == XSKT_SOCKET_INVALID_SOCKET)) ||
(!(pServer->Mode & ANSC_DSTO_MODE_XSOCKET) && (s_socket == ANSC_SOCKET_INVALID_SOCKET)) )
{
break;
}
else
{
pSocket =
(PANSC_DAEMON_SOCKET_TCP_OBJECT)pMyObject->GetSocketByOsocket
(
(ANSC_HANDLE)pMyObject,
s_socket
);
/*
* We should make sure this socket is still valid before proceeding with the socket
* receive operations. For example, the peer may have already closed or reset the
* TCP connection while we're serving the previous socket request.
*
* 10/06/04 - It's believed this modification is slowing down the GUI and we're not
* seeing tangible evidence that GUI responsivenss has been improved. So we disable
* it for now.
*/
/*
if ( pServer->Mode & ANSC_DSTO_MODE_XSOCKET )
{
XSKT_SOCKET_FD_ZERO(excp_fd_set2);
XSKT_SOCKET_FD_SET ((XSKT_SOCKET)s_socket, excp_fd_set2);
timeval2.tv_sec = 0;
timeval2.tv_usec = 0;
s_result_excp = _xskt_select(XSKT_SOCKET_FD_SETSIZE, NULL, NULL, excp_fd_set2, &timeval2);
}
else
{
ANSC_SOCKET_FD_ZERO(excp_fd_set1);
ANSC_SOCKET_FD_SET (s_socket, excp_fd_set1);
timeval1.tv_sec = 0;
timeval1.tv_usec = 0;
s_result_excp = _ansc_select(ANSC_SOCKET_FD_SETSIZE, NULL, NULL, excp_fd_set1, &timeval1);
}
*/
}
/*
if ( ((s_result_excp == 1 ) ) ||
((s_result_excp == XSKT_SOCKET_ERROR) && (pServer->Mode & ANSC_DSTO_MODE_XSOCKET)) ||
((s_result_excp == ANSC_SOCKET_ERROR) && !(pServer->Mode & ANSC_DSTO_MODE_XSOCKET)) )
{
if ( TRUE )
{
pSocket->bBroken = TRUE;
pMyObject->EnableRecv((ANSC_HANDLE)pMyObject, (ANSC_HANDLE)pSocket, FALSE);
pMyObject->EnableSend((ANSC_HANDLE)pMyObject, (ANSC_HANDLE)pSocket, FALSE);
}
if ( pSocket->bTlsEnabled )
{
if ( pSocket->bTlsEnabled && pSocket->bTlsConnected && !pSocket->bTlsInitializing )
{
returnStatus =
pWorker->Notify
(
pWorker->hWorkerContext,
(ANSC_HANDLE)pSocket,
ANSC_DSTOWO_EVENT_SOCKET_ERROR,
(ANSC_HANDLE)NULL
);
}
else
{
AnscSetEvent(&pSocket->TlsConnEvent);
}
}
else
{
returnStatus =
pWorker->Notify
(
pWorker->hWorkerContext,
(ANSC_HANDLE)pSocket,
ANSC_DSTOWO_EVENT_SOCKET_ERROR,
(ANSC_HANDLE)NULL
);
}
if ( pServer->Mode & ANSC_DSTO_MODE_AUTO_CLOSE )
{
pMyObject->DelSocket((ANSC_HANDLE)pMyObject, (ANSC_HANDLE)pSocket);
}
pMyObject->TrcCount++;
continue;
}
else
{
pSocket =
(PANSC_DAEMON_SOCKET_TCP_OBJECT)pMyObject->GetSocketByOsocket
(
(ANSC_HANDLE)pMyObject,
s_socket
);
}
*/
if ( !pSocket )
{
continue;
}
else if ( pSocket->bTlsEnabled )
{
#ifdef _ANSC_USE_OPENSSL_
pMyObject->bBusy = TRUE;
returnStatus =
pMyObject->Recv
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pSocket
);
pMyObject->bBusy = FALSE;
#else
pMyObject->bBusy = TRUE;
returnStatus =
pMyObject->Recv2
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pSocket
);
pMyObject->bBusy = FALSE;
#endif
}
else
{
pMyObject->bBusy = TRUE;
returnStatus =
pMyObject->Recv
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pSocket
);
pMyObject->bBusy = FALSE;
}
/*
* Check whether 'bToBeCleaned' flag is set for this socket: if it is, we should close
* this socket right away; otherwise, we continue the processing. WARNING!!! This new
* change seems to incur instability in SLAP, we have to roll back to the initial
* approach.
*/
/*
if ( pSocket->bToBeCleaned )
{
returnStatus =
pMyObject->DelSocket
(
(ANSC_HANDLE)pMyObject,
(ANSC_HANDLE)pSocket
);
}
*/
if ( !pMyObject->bStarted )
{
break;
}
}
#endif
}
/******************************************************************
GRACEFUL ROLLBACK PROCEDURES AND EXIT DOORS
******************************************************************/
EXIT1:
AnscSetEvent(&pMyObject->RecvEvent);
#if !defined(_ANSC_KERNEL) || !defined(_ANSC_LINUX)
if ( read_fd_set1 )
{
AnscFreeMemory(read_fd_set1);
}
if ( read_fd_set2 )
{
AnscFreeMemory(read_fd_set2);
}
if ( excp_fd_set1 )
{
AnscFreeMemory(excp_fd_set1);
}
if ( excp_fd_set2 )
{
AnscFreeMemory(excp_fd_set2);
}
#endif
return ANSC_STATUS_SUCCESS;
}
