SECStatus
sslMutex_Init(sslMutex *pMutex, int shared)
{
int err;
PR_ASSERT(pMutex);
pMutex->isMultiProcess = (PRBool)(shared != 0);
if (!shared) {
return single_process_sslMutex_Init(pMutex);
}
pMutex->u.pipeStr.mPipes[0] = -1;
pMutex->u.pipeStr.mPipes[1] = -1;
pMutex->u.pipeStr.mPipes[2] = -1;
pMutex->u.pipeStr.nWaiters = 0;
err = pipe(pMutex->u.pipeStr.mPipes);
if (err) {
nss_MD_unix_map_default_error(errno);
return err;
}
#if NONBLOCKING_POSTS
err = setNonBlocking(pMutex->u.pipeStr.mPipes[1], 1);
if (err)
goto loser;
#endif
pMutex->u.pipeStr.mPipes[2] = SSL_MUTEX_MAGIC;
#if defined(LINUX) && defined(i386)
/* Pipe starts out empty */
return SECSuccess;
#else
/* Pipe starts with one byte. */
return sslMutex_Unlock(pMutex);
#endif
loser:
nss_MD_unix_map_default_error(errno);
close(pMutex->u.pipeStr.mPipes[0]);
close(pMutex->u.pipeStr.mPipes[1]);
return SECFailure;
}
void nss_MD_unix_map_mmap_error(int err)
{
PRErrorCode prError;
switch (err) {
case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
case EMFILE: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
case ENODEV: prError = PR_OPERATION_NOT_SUPPORTED_ERROR; break;
case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break;
default: nss_MD_unix_map_default_error(err); return;
}
PR_SetError(prError, err);
}
void nss_MD_unix_map_rmdir_error(int err)
{
PRErrorCode prError;
switch (err) {
case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
case EINVAL: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
default: nss_MD_unix_map_default_error(err); return;
}
PR_SetError(prError, err);
}
void nss_MD_unix_map_open_error(int err)
{
PRErrorCode prError;
switch (err) {
case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
case EBUSY: prError = PR_IO_ERROR; break;
case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break;
case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
default: nss_MD_unix_map_default_error(err); return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_getsockname_error(int err)
{
PRErrorCode prError;
switch (err) {
case ENOMEM:
prError = PR_INSUFFICIENT_RESOURCES_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_closedir_error(int err)
{
PRErrorCode prError;
switch (err) {
case EINVAL:
prError = PR_BAD_DESCRIPTOR_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_accept_error(int err)
{
PRErrorCode prError;
switch (err) {
case ENODEV:
prError = PR_NOT_TCP_SOCKET_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_rename_error(int err)
{
PRErrorCode prError;
switch (err) {
case EEXIST:
prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_unlink_error(int err)
{
PRErrorCode prError;
switch (err) {
case EPERM:
prError = PR_IS_DIRECTORY_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_stat_error(int err)
{
PRErrorCode prError;
switch (err) {
case ETIMEDOUT:
prError = PR_REMOTE_FILE_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void nss_MD_unix_map_connect_error(int err)
{
PRErrorCode prError;
switch (err) {
case EACCES: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
#if defined(UNIXWARE) || defined(SNI) || defined(NEC)
case EIO: prError = PR_CONNECT_REFUSED_ERROR; break;
#endif
case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case ENXIO: prError = PR_IO_ERROR; break;
default: nss_MD_unix_map_default_error(err); return;
}
PR_SetError(prError, err);
}
void nss_MD_unix_readdir_error(int err)
{
PRErrorCode prError;
switch (err) {
case ENOENT: prError = PR_NO_MORE_FILES_ERROR; break;
#ifdef EOVERFLOW
case EOVERFLOW: prError = PR_IO_ERROR; break;
#endif
case EINVAL: prError = PR_IO_ERROR; break;
case ENXIO: prError = PR_IO_ERROR; break;
default: nss_MD_unix_map_default_error(err); return;
}
PR_SetError(prError, err);
}
void nss_MD_unix_map_bind_error(int err)
{
PRErrorCode prError;
switch (err) {
case EINVAL: prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break;
case EIO: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case EISDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case ENOTDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
case EROFS: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
default: nss_MD_unix_map_default_error(err); return;
}
PR_SetError(prError, err);
}
SECStatus
sslMutex_Lock(sslMutex *pMutex)
{
int rv;
if (PR_FALSE == pMutex->isMultiProcess) {
return single_process_sslMutex_Lock(pMutex);
}
do {
rv = sem_wait(&pMutex->u.sem);
} while (rv < 0 && errno == EINTR);
if (rv < 0) {
nss_MD_unix_map_default_error(errno);
return SECFailure;
}
return SECSuccess;
}
void
nss_MD_unix_map_read_error(int err)
{
PRErrorCode prError;
switch (err) {
case EINVAL:
prError = PR_INVALID_METHOD_ERROR;
break;
case ENXIO:
prError = PR_INVALID_ARGUMENT_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_lockf_error(int err)
{
PRErrorCode prError;
switch (err) {
case EACCES:
prError = PR_FILE_IS_LOCKED_ERROR;
break;
case EDEADLK:
prError = PR_INSUFFICIENT_RESOURCES_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_flock_error(int err)
{
PRErrorCode prError;
switch (err) {
case EINVAL:
prError = PR_BAD_DESCRIPTOR_ERROR;
break;
case EWOULDBLOCK:
prError = PR_FILE_IS_LOCKED_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_setsockopt_error(int err)
{
PRErrorCode prError;
switch (err) {
case EINVAL:
prError = PR_BUFFER_OVERFLOW_ERROR;
break;
case ENOMEM:
prError = PR_INSUFFICIENT_RESOURCES_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
void
nss_MD_unix_map_fsync_error(int err)
{
PRErrorCode prError;
switch (err) {
case ETIMEDOUT:
prError = PR_REMOTE_FILE_ERROR;
break;
case EINVAL:
prError = PR_INVALID_METHOD_ERROR;
break;
default:
nss_MD_unix_map_default_error(err);
return;
}
PR_SetError(prError, err);
}
SECStatus
sslMutex_Init(sslMutex *pMutex, int shared)
{
int rv;
PR_ASSERT(pMutex);
pMutex->isMultiProcess = (PRBool)(shared != 0);
if (!shared) {
return single_process_sslMutex_Init(pMutex);
}
do {
rv = sem_init(&pMutex->u.sem, shared, 1);
} while (rv < 0 && errno == EINTR);
if (rv < 0) {
nss_MD_unix_map_default_error(errno);
return SECFailure;
}
return SECSuccess;
}
SECStatus
sslMutex_Destroy(sslMutex *pMutex, PRBool processLocal)
{
int rv;
if (PR_FALSE == pMutex->isMultiProcess) {
return single_process_sslMutex_Destroy(pMutex);
}
/* semaphores are global resources. See SEM_DESTROY(3) man page */
if (processLocal) {
return SECSuccess;
}
do {
rv = sem_destroy(&pMutex->u.sem);
} while (rv < 0 && errno == EINTR);
if (rv < 0) {
nss_MD_unix_map_default_error(errno);
return SECFailure;
}
return SECSuccess;
}
void nss_MD_unix_map_listen_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_hpux_map_sendfile_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_select_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_gethostname_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_opendir_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_shutdown_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_lseek_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_writev_error(int err)
{
nss_MD_unix_map_default_error(err);
}
void nss_MD_unix_map_recvfrom_error(int err)
{
nss_MD_unix_map_default_error(err);
}
