ospossys.h

mgcp协议源代码。支持多种编码：g711

/*
*########################################################################
*########################################################################
*########################################################################
* 
*   COPYRIGHT (c) 1998, 1999 by TransNexus, LLC                          
*                                                                    
*   This software contains proprietary and confidential information  
*   of TransNexus, LLC. Except as may be set forth in the license    
*   agreement under which this software is supplied, use, disclosure, 
*   or reproduction is prohibited without the prior, express, written
*   consent of TransNexus, LLC.                                      
*                                     
*
*
*
*
*
*
*#########################################################################
*#########################################################################
*#########################################################################
*/

/*
 * ospossys.h - OS dependent system macros.
 */
#ifndef _OSPOSSYS_H
#define _OSPOSSYS_H

#include "ospdebug.h"

/*
 * =============================================
 * Memory Management Macros
 * =============================================
 */
#define OSPM_MALLOC(p,t,z) { \
    p = (t *)malloc(z); \
    OSPM_DBG(p == (t *)OSPC_OSNULL, \
        ("%s failed. %s\n", "malloc", strerror(errno))); \
}

#define OSPM_REALLOC(n,p,t,z) { \
    n = (t *)realloc(p, z); \
    OSPM_DBG(p == (t *)OSPC_OSNULL, \
        ("%s failed. %s\n", "realloc", strerror(errno))); \
}

#define OSPM_FREE(p)  if(p!=NULL) { free(p); p=NULL;  }

#define OSPM_MEMCPY(p,s,z) (void)memcpy((void *)p,s,z)

#define OSPM_MEMSET(p,c,z) (void)memset((void *)p,c,z)

#define OSPM_MEMCMP(p1,p2,z) memcmp(p1,p2,z) 

#define OSPM_MEMMOVE(p,s,z) memmove(p,s,z)

#define OSPM_SSCANF(s,f,r) sscanf((const char*)s,f,&r[0])

/*
 * =============================================
 * Thread Macros
 * =============================================
 */

#define OSPPOSEnterCriticalSection()    /* null for now */
#define OSPPOSExitCriticalSection()     /* null for now */

#ifndef _WIN32

#ifdef _POSIX_THREADS
#define OSPM_CREATE_THREAD(t,a,f,p,e) { \
    e = pthread_create(&t, a, f, p); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_create", strerror(errno))); \
}

#define OSPM_THRATTR_INIT(a,e) { \
    e = pthread_attr_init(&a); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_attr_init", strerror(errno))); \
}

#define OSPM_THRATTR_DESTROY(a) { \
    int e = 0; \
    e = pthread_attr_destroy(&a); \
    OSPM_DBG(e, ("%s failed. %s\n", "pthread_attr_destroy", strerror(errno))); \
}

#define OSPM_SETDETACHED_STATE(a,e) { \
    e = pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_attr_setdetachstate", strerror(errno))); \
}

/* Mutexes (POSIX) */
#define OSPM_MUTEX_INIT(m,a,e) { \
    e = pthread_mutex_init(&m,a); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_mutex_init", strerror(errno))); \
}

#define OSPM_MUTEX_DESTROY(m,e) { \
    e = pthread_mutex_destroy(&m); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_mutex_destroy", strerror(errno))); \
}

#define OSPM_MUTEX_LOCK(m,e) { \
    e = pthread_mutex_lock(&m); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_mutex_lock", strerror(errno))); \
}

#define OSPM_MUTEX_UNLOCK(m,e) { \
    e = pthread_mutex_unlock(&m); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_mutex_unlock", strerror(errno))); \
}

/* Conditional Variables (POSIX) */
#define OSPM_CONDVAR_INIT(c,a,e) { \
    e = pthread_cond_init(&c,a); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_cond_init", strerror(errno))); \
}

#define OSPM_CONDVAR_DESTROY(c,e) { \
    e = pthread_cond_destroy(&c); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_cond_destroy", strerror(errno))); \
}

#define OSPM_CONDVAR_WAIT(c,m,e) { \
    e = pthread_cond_wait(&c,&m); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_cond_wait", strerror(errno))); \
}

#define OSPM_CONDVAR_TIMEDWAIT(c,m,t,e) { \
    struct timespec abstime; \
    abstime.tv_sec = time((time_t *)0) + t; abstime.tv_nsec = 0; \
    e = pthread_cond_timedwait(&c,&m,&abstime); \
    e = (e == ETIMEDOUT ? OSPC_ERR_OS_CONDVAR_TIMEOUT : e); \
}

#define OSPM_CONDVAR_SIGNAL(c,e) { \
    e = pthread_cond_signal(&c); \
    OSPM_DBG(e,("%s failed. %s\n", "pthread_cond_signal", strerror(errno))); \
}
#endif /* POSIX THREADS */
#else 

/* MS Threads */
#define OSPM_CREATE_THREAD(t,a,f,p,e) { \
    t = _beginthread(f,0,(void *)p); \
    OSPM_DBG((t < 0),("%s failed. %d\n", "_beginthread", GetLastError())); \
    if (t < 0) \
        e = GetLastError(); \
}

/* currently unused in Win32 Threads */
#define OSPM_THRATTR_INIT(a,e) a = 0, e = OSPC_ERR_NO_ERROR; 
#define OSPM_THRATTR_DESTROY(a) a = 0;
#define OSPM_SETDETACHED_STATE(a,e) a = a, e = OSPC_ERR_NO_ERROR;

/* Mutexes (WIN32) */
#define OSPM_MUTEX_INIT(m,a,e) { \
    m = CreateMutex(NULL, FALSE, NULL); \
    OSPM_DBG(m == NULL,("%s failed. %d\n", "CreateMutex", GetLastError())); \
    e = GetLastError(); \
}

#define OSPM_MUTEX_DESTROY(m,e) { \
    e = CloseHandle(m); \
    if(e) \
        e = OSPC_ERR_NO_ERROR; \
    else \
        OSPM_DBG(e == 0,("%s failed. %d\n", "CloseHandle", GetLastError())); \
}

#define OSPM_MUTEX_LOCK(m,e) { \
    e = WaitForSingleObject(m,INFINITE); \
    OSPM_DBG(e == WAIT_FAILED,("%s failed. %d\n", "WaitForSingleObject", GetLastError())); \
}

#define OSPM_MUTEX_UNLOCK(m,e) { \
    e = ReleaseMutex(m); \
    OSPM_DBG(e == 0,("%s failed. %d\n", "ReleaseMutex", GetLastError())); \
    e = (e == 0 ? GetLastError() : OSPC_ERR_NO_ERROR); \
}

/* Conditional Variables (not natively supported in WIN32) */
#define OSPM_CONDVAR_INIT(c,a,e) { \
    c.Semaphore = CreateSemaphore(NULL,0,1,NULL); \
    e = GetLastError(); \
    OSPM_DBG(e,("%s failed. %d\n", "CreateSemaphore", GetLastError())); \
    if (e == 0) { \
        c.SemaCount = 0; \
        c.WaitLimit = 5000; \
    } \
}

#define OSPM_CONDVAR_DESTROY(c,e) { \
    e = CloseHandle(c.Semaphore); \
    OSPM_DBG(e == 0,("%s failed. %d\n", "CloseHandle", GetLastError())); \
}

#define OSPM_CONDVAR_WAIT(c,m,e) { \
    c.SemaCount++; \
    ReleaseMutex(m); \
    e = WaitForSingleObject(c.Semaphore, INFINITE); \
    if (e != WAIT_FAILED) \
        e = WaitForSingleObject(m, INFINITE); \
    c.SemaCount--; \
    OSPM_DBG(e == WAIT_FAILED,("%s failed. %d\n", \
        "WaitForSingleObject", GetLastError())); \
}

#define OSPM_CONDVAR_TIMEDWAIT(c,m,t,e) { \
    c.SemaCount++; \
    ReleaseMutex(m); \
    e = WaitForSingleObject(c.Semaphore, t * 1000); \
    if (e != WAIT_TIMEOUT && e != WAIT_FAILED) { \
        e = WaitForSingleObject(m, t * 1000); \
     } \
    c.SemaCount--; \
    OSPM_DBG(e == WAIT_FAILED,("%s failed. %s\n", \
        "WaitForSingleObject", GetLastError())); \
    e = (e == WAIT_TIMEOUT ? OSPC_ERR_OS_CONDVAR_TIMEOUT : e); \
}

#define OSPM_CONDVAR_SIGNAL(c,e) { \
    if (c.SemaCount > 0) \
        e = (ReleaseSemaphore(c.Semaphore, 1, NULL) ? \
            OSPC_ERR_NO_ERROR : OSPC_ERR_OS_FAILURE); \
}

#endif /* !_WIN32 */

/*
 * =============================================
 * Socket Macros
 * =============================================
 */

/* -----------------------------*/
/* WIN32 Winsock Macros         */
/* -----------------------------*/
#ifdef _WIN32

#define OSPM_INITWINSOCK(e) { \
    WORD wVersionRequested; \
    WSADATA wsaData; \
    wVersionRequested = MAKEWORD( 2, 0 ); \
    e = WSAStartup( wVersionRequested, &wsaData ); \
    OSPM_DBG(e,("%s failed. %s\n", "initwinsock", strerror(errno))); \
}

#define OSPM_CLEANUPWINSOCK()   WSACleanup()

#define OSPM_BLOCKIO(s,f,e) { \
    e = ioctlsocket(s, FIONBIO, (unsigned long *)&f); \
    OSPM_DBG(e,("%s failed. %s\n", "ioctlsocket", strerror(errno))); \
}

#define OSPM_GETHOSTBYNAME(h,ip,e) { \
    struct hostent *pHost; \
    struct sockaddr_in sSockAddr; \
    if ((pHost = gethostbyname((const char *)h)) == (struct hostent *)NULL) \
    { \
        e = GetLastError(); \
        OSPM_DBG(e,("%s failed for %s. %s\n", "gethostbyname", h, strerror(errno))); \
        ip = 0; \
    } \
    else \
    { \
        OSPM_MEMSET(&sSockAddr, 0, sizeof(sSockAddr)); \
            OSPM_MEMCPY((char *)&sSockAddr.sin_addr, \
            pHost->h_addr, pHost->h_length); \
        ip = sSockAddr.sin_addr.s_addr; \
    } \
}

#define OSPM_GETSOCKERR(h,e) { \
    int err = 0, err_sz = sizeof(int); \
    e = getsockopt(h->SockFd, SOL_SOCKET, SO_ERROR, (char *)&err, &err_sz); \
    if (err != 0) e = OSPC_ERR_SOCK_RESET; \
}

#define OSPM_SEND(fd,n,b,l,e) { \
    e = 0; \
        errno=0; \
    n = send(fd, (char *)b, l, 0); \
    e = WSAGetLastError(); \
    if (e == (int)WSAENOTCONN || e == (int)WSAECONNABORTED || e == (int)WSAECONNRESET) \
        e = OSPC_ERR_SOCK_RESET; \
    OSPM_DBG(e || (OSPTSSIZE_T)n != (OSPTSSIZE_T)l,("%s failed. %s\n", "send", strerror(errno))); \
}

#define OSPM_RECV(h,b,l,e) { \
    e = 0; \
        errno=0; \
    h->ByteCount = recv(h->SockFd, (char *)b, l, 0); \