Linux Platform Api Porting

#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);
}