Linux Platform Api Porting

来源：互联网发布：hive数据倾斜优化编辑：程序博客网时间：2024/06/07 03:50

#include <fcntl.h>#include <sys/types.h>#include <sys/socket.h>#include <string.h>#include <stdio.h>#include <netinet/in.h>#include <stdlib.h>#include <errno.h>#include <sys/wait.h>#include <netdb.h>#include <sys/ioctl.h>#include <sys/wait.h>#include <semaphore.h>#include <sys/time.h>#include <signal.h>#include <unistd.h>#include <pthread.h>#include <stdarg.h>#include <assert.h>C_U32 CStb_GetUpTime() {    C_U32 currentTime;    struct timeval current;    gettimeofday(&current, NULL);    currentTime = current.tv_sec * 1000 + current.tv_usec / 1000;    return (1.0 * currentTime + (current.tv_usec % 1000) * 0.001);}void * CStb_Malloc( IN C_U32 uLength) {    return malloc(uLength);}void CStb_Free(IN void * pBuf) {    free(pBuf);}C_RESULT CStb_CreateThread( OUT C_ThreadHandle *pThreadHandle,        IN char const* szName, IN C_U8 uPriority, IN void (*pThreadFunc)(void*),        IN void * pParam, IN C_U16 uStackSize) {    CStb_Print("Enter FUNC %s\n", __func__);    int ret_code;    pthread_t *thread;    pthread_attr_t attr;    struct sched_param param;    pthread_attr_init(&attr);

/*<pre style="white-space: pre-wrap; word-wrap: break-word; color: rgb(51, 51, 51); font-size: 14px; line-height: 26px; background-color: rgb(255, 255, 255);"><code>SCHED_OTHER</code>是不支持优先级使用的，而<code>SCHED_FIFO和SCHED_RR支持优先级的使用，他们分别为1和99，数值越大</code>优先级越高。 从上面的结果我们可以看出，如果程序控制线程的优先级，一般是用<code>pthread_attr_getschedpolicy来获取系统使用的调度策略，如果是SCHED_OTHER的话，表明当前策略不支持线程优先级的使用，否则可以。当然所设定的优先级范围必须在最大和最小值之间。我们可以通过</code><code>sched_get_priority_max</code>和<code>sched_get_priority_min来获取。*/</code>

pthread_attr_setschedpolicy(&attr, SCHED_RR); param.sched_priority = uPriority; pthread_attr_setschedparam(&attr, &param); /*在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。一个可结合的线程能够被其他线程收回其资源和杀死；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。*/

<div style="text-align: justify;"></div><span style="font-family: 宋体; font-size: 16px; line-height: 24px; text-align: justify; background-color: rgb(192, 192, 192);">   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);</span>

   thread = (pthread_t*) malloc(sizeof(pthread_t));    if (thread != NULL) {        ret_code = pthread_create(thread, &attr, (void* (*)(void*)) pThreadFunc,                pParam);        if (ret_code != 0) {            free(thread);            thread = NULL;        }    }    pthread_attr_destroy(&attr);    *pThreadHandle = (C_ThreadHandle) thread;    return CLOUD_OK;}void CStb_DeleteThread( IN C_ThreadHandle hThreadHandle) {    CStb_Print("Enter FUNC %s\n", __func__);    pthread_t *thread;    char *d;    if (hThreadHandle == NULL) {        return;    }    thread = (pthread_t*) hThreadHandle;    pthread_join(*thread, NULL);    free(thread);}void CStb_Sleep( IN C_U32 uMicroSeconds) {    usleep(uMicroSeconds);}void CStb_Sleep( IN C_U32 uMicroSeconds) {    usleep(uMicroSeconds);}C_RESULT CStb_CreateSemaphore( OUT C_SemaphoreHandle *pHandle, IN C_U32 uCount) {    sem_t *sem;    int retCode;    assert(pHandle != NULL);    sem = (sem_t*) malloc(sizeof(sem_t));    if (sem == NULL) {        *pHandle = NULL;        return CLOUD_FAILURE;    }    // Initialize event semaphore    retCode = sem_init(sem, 0, uCount);    if (retCode != 0) {        *pHandle = NULL;        free(sem);        return CLOUD_FAILURE;    }    *pHandle = (C_SemaphoreHandle) sem;    return CLOUD_OK;}void CStb_SemaphoreSignal( IN C_SemaphoreHandle hHandle) {    if (!hHandle) {        CStb_Print("%s--%d  handle is null\n", __FUNCTION__, __LINE__);    }    assert(hHandle != NULL);    sem_post((sem_t*) hHandle);}C_RESULT CStb_SemaphoreWait( IN C_SemaphoreHandle hHandle, IN C_U32 uTimeout) {    struct timespec ts;    assert(hHandle != NULL);    clock_gettime(CLOCK_REALTIME, &ts);    ts.tv_sec += uTimeout / 1000;    ts.tv_nsec += (uTimeout % 1000) * 1000 * 1000;    ts.tv_sec += ts.tv_nsec / 1000000000;    ts.tv_nsec = ts.tv_nsec % 1000000000;    return sem_timedwait((sem_t*) hHandle, &ts) == 0 ? CLOUD_OK : CLOUD_TIMEOUT;}void CStb_DeleteSemaphore( IN C_SemaphoreHandle hHandle) {    assert(hHandle != NULL);    sem_destroy((sem_t*) hHandle);    free((sem_t*) hHandle);}C_RESULT CStb_SocketOpen( OUT C_SocketHandle *pSocketHandle,        IN C_SocketType uType, IN C_BOOL bIsBlocking) {    CStb_Print("Enter FUNC %s\n", __func__);    int ms = 0;    C_U32 flags;    ms = socket(AF_INET, (uType == 1 ? SOCK_STREAM : SOCK_DGRAM), 0);    if (ms < 0) {        return CLOUD_FAILURE;    }    flags = fcntl((C_U32) ms, F_GETFL, 0);    if (bIsBlocking) {        //fcntl((C_U32)ms, F_SETFL, flags|O_NONBLOCK);        if (fcntl((C_U32) ms, F_SETFL, flags & ~O_NONBLOCK) < 0) {            CStb_Print("Open Socket opt ERROR line:%d\n", __LINE__);        }    } else {        //fcntl((C_U32)ms, F_SETFL, flags&~O_NONBLOCK);        if (fcntl((C_U32) ms, F_SETFL, flags | O_NONBLOCK) < 0) {            CStb_Print("Open Socket opt ERROR line:%d\n", __LINE__);        }    }    *pSocketHandle = (C_SocketHandle*) ms;    return CLOUD_OK;}C_RESULT CStb_SocketConnect( IN C_SocketHandle hSocketHandle,        IN C_SocketAddr const *pDstSocketAddr) {    CStb_Print("Enter FUNC %s\n", __func__);    struct sockaddr_in serv_addr;    C_U32 p_connect = 0;    C_U32 flags;    bzero(&serv_addr, sizeof(serv_addr));    serv_addr.sin_family = AF_INET;    serv_addr.sin_addr.s_addr = pDstSocketAddr->uIP;    serv_addr.sin_port = pDstSocketAddr->uPort;    p_connect = connect((C_U32) hSocketHandle, (struct sockaddr *) &serv_addr,            sizeof(serv_addr));    flags = fcntl((C_U32) hSocketHandle, F_GETFL, 0);    if (flags & O_NONBLOCK) {        CStb_Print("Cable Connect Socket is NoBlock\n");        return CLOUD_OK;    } else {        if (!p_connect) {            return CLOUD_OK;        } else {            return CLOUD_FAILURE;        }    }}C_RESULT CStb_SocketSetOpt( IN C_SocketHandle hSocketHandle,        IN C_SocketOptLevel uLevel, IN C_SocketOptName uOptname,        IN C_U8 const * pOptval, IN C_U32 uOptlen) {    CStb_Print("Enter FUNC %s\n", __func__);    C_RESULT ret = CLOUD_OK;    if (uLevel == SocketOptLevel_IPPROTO_TCP            && uOptname == SocketOptName_TCP_NODELAY) {        unsigned long nodelay = *(C_BOOL*) pOptval;        if (setsockopt((C_U32) hSocketHandle, IPPROTO_TCP, 1, pOptval, uOptlen)                != 0) {            ret = CLOUD_FAILURE;        }    } else if (uLevel == SocketOptLevel_SOL_SOCKET) {        short optName = 0;        switch (uOptname) {        case SocketOptName_SO_RCVBUF:            optName = SO_RCVBUF;            break;        case SocketOptName_SO_BROADCAST:            optName = SO_BROADCAST;            break;        case SocketOptName_SO_SNDBUF:            optName = SO_SNDBUF;            break;        case SocketOptName_SO_REUSEADDR:            optName = SO_REUSEADDR;            break;        default:            return CLOUD_FAILURE;        }        if (setsockopt((C_U32) hSocketHandle, SOL_SOCKET, optName, pOptval,                uOptlen) != 0) {            ret = CLOUD_FAILURE;        }    } else if (uLevel == SocketOptLevel_FILEIO            && uOptname == SocketOptName_FILEIO_NBIO) {        C_BOOL g_pOptval = *pOptval;        C_U32 flags;        flags = fcntl((C_U32) hSocketHandle, F_GETFL, 0);        if (g_pOptval) {            if (fcntl((C_U32) hSocketHandle, F_SETFL, flags | O_NONBLOCK) < 0)                CStb_Print("set opt ERROR line:%d\n", __LINE__);        } else {            if (fcntl((C_U32) hSocketHandle, F_SETFL, flags & ~O_NONBLOCK) < 0)                CStb_Print("set opt ERROR line:%d\n", __LINE__);        }    }    return ret;}C_NetworkIP CStb_SocketGetHostByName( IN char const *pDomainName) {    CStb_Print("Enter FUNC %s\n", __func__);    struct hostent *pHost = NULL;    C_NetworkIP iphost = 0;    pHost = gethostbyname(pDomainName);    if (pHost) {        iphost = ((struct in_addr *) (pHost->h_addr_list[0]))->s_addr;        return iphost;    } else {        return 0;    }}C_RESULT CStb_SocketSelect( INOUT C_SocketHandle *pReadSockets,        IN C_U32 uReadSocketCount, INOUT C_SocketHandle *pWriteSockets,        IN C_U32 uWriteSocketCount, INOUT C_SocketHandle *pExceptSockets,        IN C_U32 uExceptSocketCount, IN C_U32 uTimeout) {    C_U32 sockfd_read[FD_SETSIZE];    C_U32 sockfd_write[FD_SETSIZE];    C_U32 sockfd_error[FD_SETSIZE];    fd_set fd_read, fd_write, fd_error;    C_U32 ix, jx = 0;    struct timeval timeOut;    int ret = 0;    FD_ZERO(&fd_read);    FD_ZERO(&fd_write);    FD_ZERO(&fd_error);    timeOut.tv_sec = uTimeout / 1000;    timeOut.tv_usec = (uTimeout % 1000) * 1000;    memset(sockfd_read, 0, sizeof(C_U32) * FD_SETSIZE);    memset(sockfd_write, 0, sizeof(C_U32) * FD_SETSIZE);    memset(sockfd_error, 0, sizeof(C_U32) * FD_SETSIZE);    memcpy((void*) sockfd_read, pReadSockets, sizeof(C_U32) * uReadSocketCount);    memcpy((void*) sockfd_write, pWriteSockets,            sizeof(C_U32) * uWriteSocketCount);    memcpy((void*) sockfd_error, pExceptSockets,            sizeof(C_U32) * uExceptSocketCount);    sockfd_read[uReadSocketCount] = 0;    sockfd_write[uWriteSocketCount] = 0;    sockfd_error[uExceptSocketCount] = 0;    for (ix = 0; ix < uReadSocketCount; ix++) {        FD_SET(*(sockfd_read + ix), &fd_read);    }    for (ix = 0; ix < uWriteSocketCount; ix++) {        FD_SET(*(sockfd_write + ix), &fd_write);    }    for (ix = 0; ix < uExceptSocketCount; ix++) {        FD_SET(*(sockfd_error + ix), &fd_error);    }    memset(pReadSockets, 0, sizeof(C_U32) * uReadSocketCount);    memset(pWriteSockets, 0, sizeof(C_U32) * uWriteSocketCount);    memset(pExceptSockets, 0, sizeof(C_U32) * uExceptSocketCount);    ret = select(FD_SETSIZE, &fd_read, &fd_write, &fd_error, &timeOut);    if (ret < 0) {        return CLOUD_FAILURE;    } else if (ret == 0) {        return CLOUD_TIMEOUT;    }    int error = 0;        int ret_test = 0;        socklen_t len = sizeof(error);        struct sockaddr t_addr ;    if(uWriteSocketCount == 1){            ret_test = getpeername(*((C_U32*)sockfd_write),&t_addr,&error);            if (ret_test != 0) {                CStb_Print("ret_test <0 :%d\n", ret_test);                return CLOUD_FAILURE;            }        }    for (ix = 0; ix < uReadSocketCount; ix++) {        if (FD_ISSET(*(sockfd_read + ix), &fd_read) != 0) {            *((C_U32*) pReadSockets + jx) = *(sockfd_read + ix);            jx++;        }    }    jx = 0;    for (ix = 0; ix < uWriteSocketCount; ix++) {        if (FD_ISSET(*(sockfd_write + ix), &fd_write) != 0) {            *((C_U32*) pWriteSockets + jx) = *(sockfd_write + ix);            jx++;        }    }    jx = 0;    for (ix = 0; ix < uExceptSocketCount; ix++) {        if (FD_ISSET(*(sockfd_error + ix), &fd_error) != 0) {            *((C_U32*) pExceptSockets + jx) = *(sockfd_error + ix);            jx++;        }    }    jx = 0;    return CLOUD_OK;}C_RESULT CStb_SocketSend( IN C_SocketHandle hSocketHandle, IN C_U8 const *pBuf,        IN C_U32 uBytesToSend, OUT C_U32 *puBytesSent) {    C_U32 count = 0;    count = (C_U32) send((C_U32) hSocketHandle, (void*) pBuf, uBytesToSend, 0);    *puBytesSent = count;    if ((int) count > 0)        return CLOUD_OK;    CStb_Print("CStb_SocketSend sendsize=%d, error=%d, \n", (int) count, errno);    return CLOUD_FAILURE;}C_RESULT CStb_SocketRecv( IN C_SocketHandle hSocketHandle, OUT C_U8 *pBuf,        IN C_U32 uBytesToReceive, OUT C_U32 *puBytesReceived) {    C_U32 p_recv = 0;    p_recv = recv((C_U32) hSocketHandle, pBuf, uBytesToReceive, 0);    *puBytesReceived = p_recv;    if (p_recv > 0 && p_recv != 0xFFFFFFFF) {        //CStb_Print("p_recv = %ld\n", p_recv);        return CLOUD_OK;    }    *puBytesReceived = 0;    CStb_Print("%s--%d\n", __func__, errno);    return CLOUD_FAILURE;}C_RESULT CStb_SocketSendTo( IN C_SocketHandle hSocketHandle,        IN C_SocketAddr const *pSocketAddr, IN C_U8 const *pBuf,        IN C_U32 uBytesToSend, OUT C_U32 *puBytesSent) {    struct sockaddr_in addr;    C_U32 p_sendto = 0;    addr.sin_family = AF_INET;    addr.sin_port = pSocketAddr->uPort;    addr.sin_addr.s_addr = pSocketAddr->uIP;    p_sendto = sendto((C_U32) hSocketHandle, pBuf, uBytesToSend, 0,            (struct sockaddr *) &addr, sizeof(addr));    *puBytesSent = p_sendto;    if (*puBytesSent)        return CLOUD_OK;    CStb_Print("CStb_SocketSendTo error\n");    return CLOUD_FAILURE;}C_RESULT CStb_SocketReceiveFrom( IN C_SocketHandle hSocketHandle,        OUT C_SocketAddr *pSocketAddr, OUT C_U8 *pBuf, IN C_U32 uBytesToReceive,        OUT C_U32 *pBytesReceived) {    struct sockaddr_in addr;    int len = sizeof(addr);    C_U32 p_revfrom = 0;    p_revfrom = recvfrom((C_U32) hSocketHandle, (void*) pBuf, uBytesToReceive,            0, (struct sockaddr *) &addr, &len);    pSocketAddr->uIP = addr.sin_addr.s_addr;    pSocketAddr->uPort = addr.sin_port;    *pBytesReceived = p_revfrom;    if (p_revfrom)        return CLOUD_OK;    CStb_Print("CStb_SocketReceiveFrom error\n");    return CLOUD_FAILURE;}C_RESULT CStb_SocketClose( IN C_SocketHandle hSocketHandle) {    C_U32 p_close = 0;    CStb_Print("SocketClose=%ld\n", (C_U32) hSocketHandle);    p_close = (C_U32) close((C_U32) hSocketHandle);    return CLOUD_OK;}C_PIDParam g_pIdParam;unsigned int get_up_time() {    unsigned int currentTime = 0;    struct timeval current;    gettimeofday(&current, NULL);    currentTime = current.tv_sec * 1000 + current.tv_usec / 1000;    return (1.0 * currentTime + (current.tv_usec % 1000) * 0.001);}

0 0