vm_socket_win32.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//       Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "vm_socket.h"
#include "vm_time.h"

#if defined(_WIN32) || defined(_WIN64)

#if defined(_WIN32_WINNT) && (WINVER < 0x0501)
#include <ws2tcpip.h>
#endif /* defined(_WIN32_WINNT) && (WINVER < 0x0501) */

static
int fill_sockaddr(struct sockaddr_in *iaddr, vm_socket_host *host)
{
    struct hostent *ent;
    char hostname[128];

    memset(iaddr, 0, sizeof(*iaddr));

    iaddr->sin_family      = AF_INET;
    iaddr->sin_port        = host ? htons(host->port) : 0;
    iaddr->sin_addr.s_addr = htons(INADDR_ANY);

    if (!host)
        return 0;
    if (!host->hostname)
        return 0;

#if defined(UNICODE) || defined(_UNICODE)
    wcstombs(hostname, host->hostname, 128);
#else /* defined(UNICODE) || defined(_UNICODE) */
    strncpy(hostname, host->hostname, 128);
#endif /* defined(UNICODE) || defined(_UNICODE) */
    iaddr->sin_addr.s_addr = inet_addr(hostname);
    if (iaddr->sin_addr.s_addr != INADDR_NONE)
        return 0;

    ent = gethostbyname(hostname);
    if (!ent)
        return 1;
    iaddr->sin_addr.s_addr = *((u_long *)ent->h_addr_list[0]);

    return 0;

} /* int fill_sockaddr(struct sockaddr_in *iaddr, vm_socket_host *host) */


vm_status vm_socket_init(vm_socket *hd,
                         vm_socket_host *local,
                         vm_socket_host *remote,
                         int flags)
{
    int i;

    /* clean everything */
    for (i = 0; i <= VM_SOCKET_QUEUE; i++)
    {
        hd->chns[i] = INVALID_SOCKET;
    }

    FD_ZERO(&hd->r_set);
    FD_ZERO(&hd->w_set);

    /* flags shaping */
    if (flags & VM_SOCKET_MCAST)
    {    flags |= VM_SOCKET_UDP; }

    hd->flags=flags;

    /* create socket */
    hd->chns[0] = socket(AF_INET,
                         (flags&VM_SOCKET_UDP) ? SOCK_DGRAM : SOCK_STREAM,
                         0);

    if (hd->chns[0] == INVALID_SOCKET)
        return VM_OPERATION_FAILED;


    if (fill_sockaddr(&hd->sal, local))
        return VM_OPERATION_FAILED;

    if (fill_sockaddr(&hd->sar, remote))
        return VM_OPERATION_FAILED;

    if (bind(hd->chns[0], (struct sockaddr*)&hd->sal, sizeof(hd->sal)))
        return VM_OPERATION_FAILED;

    if (flags & VM_SOCKET_SERVER)
    {
        if (flags & VM_SOCKET_UDP)
            return VM_OK;
        if (listen(hd->chns[0], VM_SOCKET_QUEUE))
            return VM_OPERATION_FAILED;

        return VM_OK;
    }

    /* network client */
    if (flags & VM_SOCKET_MCAST)
    {
        struct ip_mreq imr;

        imr.imr_multiaddr.s_addr = hd->sar.sin_addr.s_addr;
        imr.imr_interface.s_addr = INADDR_ANY;
        setsockopt(hd->chns[0],
                   IPPROTO_IP,
                   IP_ADD_MEMBERSHIP,
                   (char *) &imr,
                   sizeof(imr));
    }

    if (flags & VM_SOCKET_UDP)
        return VM_OK;

    while (connect(hd->chns[0], (struct sockaddr *)&hd->sar, sizeof(hd->sar)))
    {
        vm_time_sleep(1);
    }

    return VM_OK;

} /* vm_status vm_socket_init(vm_socket *hd, */

int vm_socket_select(vm_socket *hds, int nhd, int masks)
{
    int i, j;

    FD_ZERO(&hds->r_set);
    FD_ZERO(&hds->w_set);

    for (i = 0; i < nhd; i++)
    {
        int flags = hds[i].flags;
        if (hds[i].chns[0] == INVALID_SOCKET)
            continue;

        if (masks & VM_SOCKET_ACCEPT ||
            (masks & VM_SOCKET_READ &&
            (flags & VM_SOCKET_UDP || !(flags & VM_SOCKET_SERVER))))
            FD_SET(hds[i].chns[0], &hds->r_set);

        if (masks & VM_SOCKET_WRITE &&
            (flags & VM_SOCKET_UDP || !(flags & VM_SOCKET_SERVER)))
            FD_SET(hds[i].chns[0], &hds->w_set);

        for (j = 1; j <= VM_SOCKET_QUEUE; j++)
        {
            if (hds[i].chns[j] == INVALID_SOCKET)
                continue;

            if (masks & VM_SOCKET_READ)
                FD_SET(hds[i].chns[j], &hds->r_set);
            if (masks & VM_SOCKET_WRITE)
                FD_SET(hds[i].chns[j], &hds->w_set);
        }
    }

    i = select(0, &hds->r_set, &hds->w_set, 0, 0);

    return (i < 0) ? -1 : i;

} /* int vm_socket_select(vm_socket *hds, int nhd, int masks) */

int vm_socket_next(vm_socket *hds, int nhd, int *idx, int *chn, int *type)
{
    int i, j;

    for (i = 0; i < nhd; i++)
    {
        for (j = 0; j <= VM_SOCKET_QUEUE; j++)
        {
            int flags = hds[i].flags;
            if (hds[i].chns[j] == INVALID_SOCKET)
                continue;

            if (FD_ISSET(hds[i].chns[j], &hds->r_set))
            {
                FD_CLR(hds[i].chns[j],&hds->r_set);

                if (idx)
                    *idx=i;
                if (chn)
                    *chn=j;
                if (type)
                {
                    *type = VM_SOCKET_READ;
                    if (j > 0)
                        return 1;
                    if (flags&VM_SOCKET_UDP)
                        return 1;
                    if (flags&VM_SOCKET_SERVER)
                        *type=VM_SOCKET_ACCEPT;
                }
                return 1;
            }

            if (FD_ISSET(hds[i].chns[j],&hds->w_set))
            {
                FD_CLR(hds[i].chns[j],&hds->w_set);

                if (idx)
                    *idx=i;
                if (chn)
                    *chn=j;
                if (type)
                    *type=VM_SOCKET_WRITE;
                return 1;
            }
        }
    }

    return 0;

} /* int vm_socket_next(vm_socket *hds, int nhd, int *idx, int *chn, int *type) */

int vm_socket_accept(vm_socket *hd)
{
    int psize, chn;

    if (hd->chns[0] == INVALID_SOCKET)
        return -1;
    if (hd->flags & VM_SOCKET_UDP)
        return 0;
    if (!(hd->flags & VM_SOCKET_SERVER))
        return 0;

    for (chn = 1; chn <= VM_SOCKET_QUEUE; chn++)
    {
      if (hd->chns[chn] == INVALID_SOCKET)
          break;
    }
    if (chn > VM_SOCKET_QUEUE)
        return -1;

    psize = sizeof(hd->peers[chn]);
    hd->chns[chn] = accept(hd->chns[0], (struct sockaddr *)&(hd->peers[chn]), &psize);
    if (hd->chns[chn] == INVALID_SOCKET)
    {
        memset(&(hd->peers[chn]), 0, sizeof(hd->peers[chn]));
        return -1;
    }

    return chn;

} /* int vm_socket_accept(vm_socket *hd) */

int vm_socket_read(vm_socket *hd, int chn, void *buffer, int nbytes)
{
    int retr;

    if (chn < 0 || chn > VM_SOCKET_QUEUE)
        return -1;
    if (hd->chns[chn] == INVALID_SOCKET)
        return -1;

    if (hd->flags & VM_SOCKET_UDP)
    {
        int ssize = sizeof(hd->sar);
        retr = recvfrom(hd->chns[chn],
                        buffer,
                        nbytes,
                        0,
                        (struct sockaddr *)&hd->sar,
                        &ssize);
    }
    else
    {
        retr = recv(hd->chns[chn], buffer, nbytes, 0);
    }

    if (retr < 1)
        vm_socket_close_chn(hd, chn);

    return retr;

} /* int vm_socket_read(vm_socket *hd, int chn, void *buffer, int nbytes) */

int vm_socket_write(vm_socket *hd, int chn, void *buffer, int nbytes)
{
    int retw;

    if (chn < 0 || chn > VM_SOCKET_QUEUE)
        return -1;
    if (hd->chns[chn] == INVALID_SOCKET)
        return -1;

    if (hd->flags & VM_SOCKET_UDP)
    {
        retw = sendto(hd->chns[chn],
                      buffer,
                      nbytes,
                      0,
                      (struct sockaddr *)&hd->sar,
                      sizeof(hd->sar));
    }
    else
    {
        retw = send(hd->chns[chn], buffer, nbytes, 0);
    }

    if (retw < 1)
        vm_socket_close_chn(hd, chn);

    return retw;

} /* int vm_socket_write(vm_socket *hd, int chn, void *buffer, int nbytes) */

void vm_socket_close_chn(vm_socket *hd, int chn)
{
    if (hd->chns[chn] != INVALID_SOCKET)
        closesocket(hd->chns[chn]);

    hd->chns[chn] = INVALID_SOCKET;

} /* void vm_socket_close_chn(vm_socket *hd, int chn) */

void vm_socket_close(vm_socket *hd)
{
   int i;

   for (i= VM_SOCKET_QUEUE; i >= 0; i--)
       vm_socket_close_chn(hd, i);

} /* void vm_socket_close(vm_socket *hd) */

#endif /* defined(_WIN32) || defined(_WIN64) */

/* Old part */
#if defined(_WIN32) || defined(_WIN64) || defined(_WIN32_WCE)

int vm_sock_startup(vm_char a, vm_char b)
{
    WORD wVersionRequested = MAKEWORD(a, b);
    WSADATA wsaData;
    int nRet;

    /*
    // Initialize WinSock and check version
    */
    nRet = WSAStartup(wVersionRequested, &wsaData);
    if (wsaData.wVersion != wVersionRequested)
    {
        return 1;
    }

    return 0;

} /* int vm_sock_startup(vm_char a, vm_char b) */

int vm_sock_cleanup(void)

{
    return WSACleanup();

} /* int vm_sock_cleanup(void) */

unsigned long vm_inet_addr(const vm_char *szName)
{
    unsigned long ulRes;

#if defined(UNICODE)||defined(_UNICODE)

    int iStrSize = vm_string_strlen(szName);
    char *szAnciStr = malloc(iStrSize + 2);

    if (NULL == szAnciStr)
        return INADDR_NONE;
    if (0 == WideCharToMultiByte(CP_ACP, 0, szName, iStrSize, szAnciStr,
                                 iStrSize + 2, 0, NULL))
    {
        free(szAnciStr);
        return INADDR_NONE;
    }
    ulRes = inet_addr(szAnciStr);
    free(szAnciStr);

#else /* defined(UNICODE)||defined(_UNICODE) */

    ulRes = inet_addr(szName);

#endif /* defined(UNICODE)||defined(_UNICODE) */

    return ulRes;

} /* unsigned long vm_inet_addr(const vm_char *szName) */

struct hostent *vm_gethostbyname(const vm_char *szName)
{
    struct hostent *pRes = NULL;

#if defined(UNICODE)||defined(_UNICODE)

    int iStrSize = vm_string_strlen(szName);
    char *szAnciStr = malloc(iStrSize + 2);

    if (NULL == szAnciStr)
        return NULL;
    if (0 == WideCharToMultiByte(CP_ACP, 0, szName, iStrSize, szAnciStr,
                                 iStrSize + 2, 0, NULL))
    {
        free(szAnciStr);
        return NULL;
    }

    pRes = gethostbyname(szAnciStr);
    free(szAnciStr);

#else /* defined(UNICODE)||defined(_UNICODE) */

    pRes = gethostbyname(szName);

#endif /* defined(UNICODE)||defined(_UNICODE) */

    return pRes;

} /* struct hostent *vm_gethostbyname(const vm_char *szName) */

int vm_sock_host_by_name(vm_char * name,struct in_addr * paddr)
{
    LPHOSTENT lpHostEntry;

    paddr->S_un.S_addr = vm_inet_addr(name);

    if (paddr->S_un.S_addr == INADDR_NONE)
    {
        lpHostEntry = vm_gethostbyname(name);
        if (NULL == lpHostEntry)
            return 1;
        else
            *paddr = *((LPIN_ADDR)*lpHostEntry->h_addr_list);
    }

    return 0;

} /* int vm_sock_host_by_name(vm_char * name,struct in_addr * paddr) */

#endif /* defined(_WIN32) || defined(_WIN64) || defined(_WIN32_WCE) */