rvudp.c

h.248协议源码

/*****************************************************************************
Filename   : rvudp.c
Description: Socket UDP interface definition.
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision Inc.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision Inc.

RADVision Inc. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:$
$Author: S. Cipolli$
*****************************************************************************/

#include <string.h>
#include "rvplatform.h"
#include "rvlog.h"
#include "rvsocket_.h"
#include "rvsocket.h"
#include <stdio.h>


RvSocket* rvSocketConstructUdp(RvSocket* s, RvInetPort port) 
{
    RvSocketAddr localAddr;

    rvLogEnter(&rvLog, "rvSocketConstructUdp");

    /* Initialize socket */
#if defined(RV_INET_IPV6)
    *s = rvSocketOpen_(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
    {
        RvIpv6Addr ipv6;
        rvIpv6AddrConstruct(&ipv6, &RV_INET_ADDRANY);
        rvSocketAddrConstructIpv6(&localAddr, &ipv6, port);
    }
#else
    *s = rvSocketOpen_(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    {
        RvIpv4Addr ipv4;
        rvIpv4AddrConstruct(&ipv4, htonl(RV_INET_ADDRANY));
        rvSocketAddrConstructIpv4(&localAddr, &ipv4, port);
    }
#endif

    if (*s >= 0)
    {
        /* Bind socket */
        if (rvSocketBind(s, &localAddr))
        {
            rvLogInt4(&rvLog, "rvSocketConstructUdp: UdpPort", (int)port, 10);
        }
        else
        {
            rvSocketClose_(*s);
            s = NULL;
        }
    }
    else
    {
        rvLogError(&rvLog, "rvSocketConstructUdp: Can't create socket");
        s = NULL;
    }

    rvLogLeave(&rvLog, "rvSocketConstructUdp");

    return s;
}

/* create an anyaddress anyport socket and assign a port */
RvSocket* rvSocketConstructUdpAnyPort(RvSocket* s)
{
    RvSocketAddr localAddr;

    rvLogEnter(&rvLog, "rvSocketConstructUdpAnyPort");

    /* Initialize socket */
#if defined(RV_INET_IPV6)
    *s = rvSocketOpen_(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
    {
        RvIpv6Addr ipv6;
        rvIpv6AddrConstruct(&ipv6, &RV_INET_ADDRANY);
        rvSocketAddrConstructIpv6(&localAddr, &ipv6, 0);
    }
#else
    *s = rvSocketOpen_(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    {
        RvIpv4Addr ipv4;
        rvIpv4AddrConstruct(&ipv4, htonl(RV_INET_ADDRANY));
        rvSocketAddrConstructIpv4(&localAddr, &ipv4, 0);
    }
#endif

    if (*s >= 0)
    {
        /* Bind socket */
        if (rvSocketBindAnyPort(s, &localAddr))
        {
            rvLogInt4(&rvLog, "rvSocketConstructUdpAnyPort: UdpPort", (int)rvSocketGetPort(s), 10);
        }
        else
        {
            rvSocketClose_(*s);
            s = NULL;
        }
    }
    else
    {
        rvLogError(&rvLog, "rvSocketConstructUdpAnyPort: Can't create socket");
        s = NULL;
    }

    rvLogLeave(&rvLog, "rvSocketConstructUdpAnyPort");

    return s;
}

RvSocket* rvSocketConstructUdpEx(RvSocket* s,  const RvSocketAddr *addressPtr) 
{
    rvLogEnter(&rvLog, "rvSocketConstructUdpEx");

    /* Initialize socket */
    if(rvSocketAddrGetAddressFamily(addressPtr) != -1)
        *s = rvSocketOpen_(rvSocketAddrGetAddressFamily(addressPtr), SOCK_DGRAM, IPPROTO_UDP);
    else
    {
        rvLogError(&rvLog, "rvSocketConstructUdp: Invalid Address family");
        rvLogLeave(&rvLog, "rvSocketConstructUdp");
        return NULL;
    }

    if (*s < 0) 
    {
        rvLogError(&rvLog, "rvSocketConstructUdp: Can't create socket");
        rvLogLeave(&rvLog, "rvSocketConstructUdp");
        return NULL;
    }

    /* Bind socket */
    if (!rvSocketBind(s, addressPtr))
    {
        rvLogLeave(&rvLog, "rvSocketConstructUdp");
        rvSocketClose_(*s);
        return NULL;
    }

    rvLogLeave(&rvLog, "rvSocketConstructUdpEx");

    return s;
}


int rvSocketRecvFrom(RvSocket* s, void* pkt, int len, RvSocketAddr* fromAddr) {
    int recvLen;

    rvLogEnter(&rvLog, "rvSocketRecvFrom");

    if ((recvLen = rvSocketRecvFrom_(*s, (char*)pkt, len, 0, fromAddr)) < 0) {
#if (defined(RV_DEBUG_ON) && (RV_LOGMASK & RV_LOGLEVEL_ERROR))
        char buffer[128]; 
        int  error = rvGetLastError();

        sprintf(buffer,"rvSocketRecvFrom: %s (Error=%i)",
          rvGetLastErrorAsString(error), error);
        rvLogError(&rvLog,buffer);
#endif
    }

    rvLogLeave(&rvLog, "rvSocketRecvFrom");

    return recvLen;
}

RvBool rvSocketSendTo(RvSocket* s, const void* pkt, int len, 
  const RvSocketAddr* toAddr) 
{
    RvBool r = rvFalse;

    rvLogEnter(&rvLog, "rvSocketSendTo");

    if (rvSocketSendTo_(*s, (char*)pkt, len, 0, toAddr) < 0) {
#if (defined(RV_DEBUG_ON) && (RV_LOGMASK & RV_LOGLEVEL_ERROR))
        char buffer[192]; 
        char addrString[40];
        int error = rvGetLastError();

        rvSocketAddrToString(toAddr, addrString);
        sprintf(buffer,"rvSocketSendTo: %s (Error=%i). Dest=%s:%i",
          rvGetLastErrorAsString(error), error, addrString, 
        rvSocketAddrGetInetPort(toAddr));
        rvLogError(&rvLog,buffer);
#endif
    } else
        r = rvTrue;

    rvLogLeave(&rvLog, "rvSocketSendTo");

    return r;
}

RvBool rvSocketSendToInet(RvSocket* s, const void* pkt, int len, RvHost* h, size_t n,
  RvInetPort port) 
{
    RvBool r = rvFalse;
    RvSocketAddr toAddr;
    
    rvLogEnter(&rvLog, "rvSocketSendToInet");

    if (!rvSocketAddrConstructInet(&toAddr, h, n, port))
        rvLogError(&rvLog, "rvSocketSendToInet: unknown destination");
    else
        if (rvSocketSendTo_(*s, (char*)pkt, len, 0, &toAddr) < 0)
            rvLogError(&rvLog, "rvSocketSendToInet: sendto failed");
        else
            r = rvTrue;

    rvLogLeave(&rvLog, "rvSocketSendToInet");

    return rvTrue;
}

RvBool rvSocketSendToInetEx(RvSocket* s, const void* pkt, int len, const char* dnsOrIp, 
  RvInetPort port) {
    RvBool r = rvFalse;
    RvHost host;
    RvSocketAddr toAddr;
    
    rvLogEnter(&rvLog, "rvSocketSendToInetEx");

    if (rvHostConstruct(&host, dnsOrIp) == NULL)
        rvLogError(&rvLog, "rvSocketSendToInetEx: unknown destination");
    else
        if (!rvSocketAddrConstructInet(&toAddr, &host, 0, port))
            rvLogError(&rvLog, "rvSocketSendToInetEx: unknown destination");
        else
            if (rvSocketSendTo_(*s, (char*)pkt, len, 0, &toAddr) < 0)
                rvLogError(&rvLog, "rvSocketSendToInetEx: sendto failed");
            else
                r = rvTrue;

    rvLogLeave(&rvLog, "rvSocketSendToInetEx");

    return rvTrue;
}