static int UPopBuildMessageList(UserInfo *pUI, SysListHead *pMsgList,
int *piMsgCount, SYS_OFF_T *pllMBSize)
{
char szMBPath[SYS_MAX_PATH];
UsrGetMailboxPath(pUI, szMBPath, sizeof(szMBPath), 0);
char szResLock[SYS_MAX_PATH];
RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMBPath, szResLock,
sizeof(szResLock)));
if (hResLock == INVALID_RLCK_HANDLE)
return ErrGetErrorCode();
SYS_INIT_LIST_HEAD(pMsgList);
int iMsgCount = 0;
SYS_OFF_T llMBSize = 0;
if (iMailboxType == XMAIL_MAILBOX) {
if (UPopFillMessageList(szMBPath, NULL, pMsgList, iMsgCount,
llMBSize) < 0) {
ErrorPush();
UPopFreeMessageList(pMsgList);
RLckUnlockEX(hResLock);
return ErrorPop();
}
} else {
int iScanCur = UsrGetUserInfoVarInt(pUI, "Pop3ScanCur", 0);
if (UPopFillMessageList(szMBPath, "new", pMsgList, iMsgCount,
llMBSize) < 0 ||
(iScanCur > 0 &&
UPopFillMessageList(szMBPath, "cur", pMsgList, iMsgCount,
llMBSize) < 0)) {
ErrorPush();
UPopFreeMessageList(pMsgList);
RLckUnlockEX(hResLock);
return ErrorPop();
}
}
RLckUnlockEX(hResLock);
if (piMsgCount != NULL)
*piMsgCount = iMsgCount;
if (pllMBSize != NULL)
*pllMBSize = llMBSize;
return 0;
}
int UPopGetMailboxSize(UserInfo *pUI, SYS_OFF_T &llMBSize, unsigned long &ulNumMessages)
{
char szMBPath[SYS_MAX_PATH];
UsrGetMailboxPath(pUI, szMBPath, sizeof(szMBPath), 0);
char szResLock[SYS_MAX_PATH];
RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szMBPath, szResLock,
sizeof(szResLock)));
if (hResLock == INVALID_RLCK_HANDLE)
return ErrGetErrorCode();
llMBSize = 0;
ulNumMessages = 0;
if (MscGetDirectorySize(szMBPath, true, llMBSize, ulNumMessages,
UPopMailFileNameFilter) < 0) {
ErrorPush();
RLckUnlockSH(hResLock);
return ErrorPop();
}
RLckUnlockSH(hResLock);
return 0;
}
static int BSslCtx__SendFile(void *pPrivate, char const *pszFilePath, SYS_OFF_T llOffStart,
SYS_OFF_T llOffEnd, int iTimeo)
{
SslBindCtx *pCtx = (SslBindCtx *) pPrivate;
SYS_MMAP hMap;
SYS_OFF_T llSize, llAlnOff;
void *pMapAddr;
char *pCurAddr;
if ((hMap = SysCreateMMap(pszFilePath, SYS_MMAP_READ)) == SYS_INVALID_MMAP)
return ErrGetErrorCode();
llSize = SysMMapSize(hMap);
if (llOffEnd == -1)
llOffEnd = llSize;
if (llOffStart > llSize || llOffEnd > llSize || llOffStart > llOffEnd) {
SysCloseMMap(hMap);
ErrSetErrorCode(ERR_INVALID_PARAMETER);
return ERR_INVALID_PARAMETER;
}
llAlnOff = SysMMapOffsetAlign(hMap, llOffStart);
if ((pMapAddr = SysMapMMap(hMap, llAlnOff,
(SYS_SIZE_T) (llOffEnd - llAlnOff))) == NULL) {
ErrorPush();
SysCloseMMap(hMap);
return ErrorPop();
}
pCurAddr = (char *) pMapAddr + (llOffStart - llAlnOff);
while (llOffStart < llOffEnd) {
int iSize = (int) Min(BSSL_WRITE_BLKSIZE, llOffEnd - llOffStart), iWrite;
if ((iWrite = BSslWriteLL(pCtx, pCurAddr, iSize, iTimeo)) < 0) {
ErrorPush();
SysUnmapMMap(hMap, pMapAddr, (SYS_SIZE_T) (llOffEnd - llAlnOff));
SysCloseMMap(hMap);
return ErrorPop();
}
pCurAddr += iWrite;
llOffStart += iWrite;
}
SysUnmapMMap(hMap, pMapAddr, (SYS_SIZE_T) (llOffEnd - llAlnOff));
SysCloseMMap(hMap);
return 0;
}
int RLckInitLockers(void)
{
/* Create resource locking mutex */
if ((hRLMutex = SysCreateMutex()) == SYS_INVALID_MUTEX)
return ErrGetErrorCode();
/* Initialize wait gates */
for (int i = 0; i < STD_WAIT_GATES; i++) {
if ((RLGates[i].hSemaphore = SysCreateSemaphore(0,
SYS_DEFAULT_MAXCOUNT)) ==
SYS_INVALID_SEMAPHORE) {
ErrorPush();
for (--i; i >= 0; i--) {
SysFree(RLGates[i].pResList);
SysCloseSemaphore(RLGates[i].hSemaphore);
}
SysCloseMutex(hRLMutex);
return ErrorPop();
}
RLGates[i].iWaitingProcesses = 0;
RLGates[i].iHashSize = STD_RES_HASH_SIZE;
if ((RLGates[i].pResList = (SysListHead *)
SysAlloc(RLGates[i].iHashSize * sizeof(SysListHead))) == NULL) {
ErrorPush();
SysCloseSemaphore(RLGates[i].hSemaphore);
for (--i; i >= 0; i--) {
SysFree(RLGates[i].pResList);
SysCloseSemaphore(RLGates[i].hSemaphore);
}
SysCloseMutex(hRLMutex);
return ErrorPop();
}
for (int j = 0; j < RLGates[i].iHashSize; j++)
SYS_INIT_LIST_HEAD(&RLGates[i].pResList[j]);
}
return 0;
}
static int UPopFillMessageList(char const *pszBasePath, char const *pszSubPath,
SysListHead *pMsgList, int &iMsgCount, SYS_OFF_T &llMBSize)
{
SYS_HANDLE hFind;
char szScanPath[SYS_MAX_PATH], szFileName[SYS_MAX_PATH];
if (pszSubPath == NULL)
StrSNCpy(szScanPath, pszBasePath);
else
SysSNPrintf(szScanPath, sizeof(szScanPath) - 1, "%s" SYS_SLASH_STR "%s",
pszBasePath, pszSubPath);
if ((hFind = SysFirstFile(szScanPath, szFileName,
sizeof(szFileName))) != SYS_INVALID_HANDLE) {
do {
POP3MsgData *pPOPMD;
if (SysIsDirectory(hFind) ||
!UPopMailFileNameFilter(szFileName))
continue;
if ((pPOPMD = (POP3MsgData *)
SysAlloc(sizeof(POP3MsgData))) == NULL) {
ErrorPush();
SysFindClose(hFind);
return ErrorPop();
}
if (pszSubPath == NULL)
StrSNCpy(pPOPMD->szMsgName, szFileName);
else
SysSNPrintf(pPOPMD->szMsgName, sizeof(pPOPMD->szMsgName) - 1,
"%s" SYS_SLASH_STR "%s", pszSubPath, szFileName);
pPOPMD->llMsgSize = SysGetSize(hFind);
pPOPMD->ulFlags = 0;
/* Insert entry in message list */
SYS_LIST_ADDT(&pPOPMD->LLnk, pMsgList);
/* Update mailbox information */
llMBSize += pPOPMD->llMsgSize;
++iMsgCount;
} while (SysNextFile(hFind, szFileName, sizeof(szFileName)));
SysFindClose(hFind);
}
return 0;
}
int BSckVSendString(BSOCK_HANDLE hBSock, int iTimeout, char const *pszFormat, ...)
{
char *pszBuffer = NULL;
StrVSprint(pszBuffer, pszFormat, pszFormat);
if (pszBuffer == NULL)
return ErrGetErrorCode();
if (BSckSendString(hBSock, pszBuffer, iTimeout) < 0) {
ErrorPush();
SysFree(pszBuffer);
return ErrorPop();
}
SysFree(pszBuffer);
return 0;
}
int BSslInit(void)
{
int i, iNumLocks = CRYPTO_num_locks();
if ((pSslMtxs = (SYS_MUTEX *) SysAlloc(iNumLocks * sizeof(SYS_MUTEX))) == NULL)
return ErrGetErrorCode();
for (i = 0; i < iNumLocks; i++) {
if ((pSslMtxs[i] = SysCreateMutex()) == SYS_INVALID_MUTEX) {
ErrorPush();
for (i--; i >= 0; i--)
SysCloseMutex(pSslMtxs[i]);
SysFreeNullify(pSslMtxs);
return ErrorPop();
}
}
SSL_load_error_strings();
SSLeay_add_ssl_algorithms();
CRYPTO_set_id_callback(SysGetCurrentThreadId);
CRYPTO_set_locking_callback(BSslLockingCB);
SysAddThreadExitHook(BSslThreadExit, NULL);
return 0;
}
int BSslBindServer(BSOCK_HANDLE hBSock, SslServerBind const *pSSLB,
int (*pfEnvCB)(void *, int, void const *), void *pPrivate)
{
int iError;
SYS_SOCKET SockFD;
SSL_METHOD const *pMethod;
SSL_CTX *pSCtx;
SSL *pSSL;
X509 *pCert;
SslBindCtx *pCtx;
pMethod = SSLv23_server_method();
if ((pSCtx = SSL_CTX_new((SSL_METHOD *) pMethod)) == NULL) {
ErrSetErrorCode(ERR_SSLCTX_CREATE);
return ERR_SSLCTX_CREATE;
}
SSL_CTX_set_session_cache_mode(pSCtx, SSL_SESS_CACHE_OFF);
if (BSslSetupVerify(pSCtx, pSSLB) < 0) {
SSL_CTX_free(pSCtx);
return ErrGetErrorCode();
}
if ((pSSL = SSL_new(pSCtx)) == NULL) {
SSL_CTX_free(pSCtx);
ErrSetErrorCode(ERR_SSL_CREATE);
return ERR_SSL_CREATE;
}
SockFD = BSckGetAttachedSocket(hBSock);
/*
* We want blocking sockets during the initial SSL negotiation.
*/
SysBlockSocket(SockFD, 1);
SSL_set_fd(pSSL, SockFD);
if (SSL_accept(pSSL) == -1) {
SysBlockSocket(SockFD, -1);
SSL_free(pSSL);
SSL_CTX_free(pSCtx);
ErrSetErrorCode(ERR_SSL_ACCEPT);
return ERR_SSL_ACCEPT;
}
SSL_CTX_set_app_data(pSCtx, NULL);
/*
* Client may not supply a certificate.
*/
iError = 0;
if (pfEnvCB != NULL &&
(pCert = SSL_get_peer_certificate(pSSL)) != NULL) {
iError = BSslEnvExport(pSCtx, pSSL, pCert, pfEnvCB, pPrivate);
X509_free(pCert);
}
if (iError < 0 ||
BSslAllocCtx(&pCtx, SockFD, pSCtx, pSSL) < 0) {
ErrorPush();
SysBlockSocket(SockFD, -1);
SSL_free(pSSL);
SSL_CTX_free(pSCtx);
return ErrorPop();
}
/*
* Need to use non-blocking socket to implement read/write timeouts.
*/
SysBlockSocket(SockFD, 0);
BSckSetIOops(hBSock, &pCtx->IOOps);
return 0;
}
