rvsocketaddr.c

h.248协议源码

        offset += sprintf(str, "Undefined Address Type");
    }

    return offset;
}


RvIpv4Addr* rvSocketAddrGetIpv4Addr(const RvSocketAddr* thisPtr)
{
    RvIpv4Addr* ipv4 = NULL;
    
    rvLogEnter(&rvLog, "rvSocketAddrGetIpv4Addr");
    
    if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV4) 
    {
        struct sockaddr_in* protocolAddr = (struct sockaddr_in*)&thisPtr->address;
        ipv4 = (RvIpv4Addr *)&protocolAddr->sin_addr;
    }
    
    rvLogLeave(&rvLog, "rvSocketAddrGetIpv4Addr");
    
    return ipv4;
}

#if defined(RV_INET_IPV6)
RvIpv6Addr* rvSocketAddrGetIpv6Addr(const RvSocketAddr* thisPtr) {
    
    RvIpv6Addr *ipv6Ptr = NULL;

    rvLogEnter(&rvLog, "rvSocketAddrGetIpv6Addr");
    
    if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV6) 
    {
        struct sockaddr_in6* protocolAddr = (struct sockaddr_in6*)&thisPtr->address;
        ipv6Ptr = &protocolAddr->sin6_addr;
    }
    
    rvLogLeave(&rvLog, "rvSocketAddrGetIpv6Addr");
    
    return ipv6Ptr;
}


RvBool rvSocketAddrGetIpv6FlowInfo(const RvSocketAddr* thisPtr, RvUint32 *flowInfo)
{
    RvUint32 succeeded = rvFalse; 
        
    if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV6) 
    {
        struct sockaddr_in6* protocolAddr = (struct sockaddr_in6*)&thisPtr->address;

        *flowInfo = (RvUint32)protocolAddr->sin6_flowinfo;

        succeeded = rvTrue;
    }

    return succeeded;
}

RvBool rvSocketAddrSetIpv6FlowInfo(const RvSocketAddr* thisPtr, RvUint32 flowInfo)
{
    RvUint32 succeeded = rvFalse; 

    if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV6) 
    {
        struct sockaddr_in6* protocolAddr = (struct sockaddr_in6*)&thisPtr->address;

        protocolAddr->sin6_flowinfo = flowInfo;

        succeeded = rvTrue;
    }

    return succeeded;
}

#endif

RvInetPort rvSocketAddrGetInetPort(const RvSocketAddr* thisPtr) 
{
    
    RvInetPort port = 0;
    
    rvLogEnter(&rvLog, "rvSocketAddrGetInetPort");
    
    if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV4) 
    {
        port = ntohs(((struct sockaddr_in*)&thisPtr->address)->sin_port);
    } 
#if defined(RV_INET_IPV6)
    else if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV6) 
    {
        port = ntohs(((struct sockaddr_in6*)&thisPtr->address)->sin6_port);
    }
#endif
    else if (thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPANYADDR)
    {
        port = *(RvInetPort*)&thisPtr->address;
    }

    rvLogLeave(&rvLog, "rvSocketAddrGetInetPort");
    
    return port;
}


void  rvSocketAddrSetInetPort(RvSocketAddr* thisPtr,RvInetPort port)
{
    rvLogEnter(&rvLog, "rvSocketAddrSetInetPort");
    
    if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV4) 
    {
        ((struct sockaddr_in*)&thisPtr->address)->sin_port = htons(port);
    } 
#if defined(RV_INET_IPV6)
    else if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV6) 
    {
        ((struct sockaddr_in6*)&thisPtr->address)->sin6_port = htons(port) ;
    }
#endif
    else if (thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPANYADDR)
    {
        *(RvInetPort*)&thisPtr->address = port;
    }

    rvLogLeave(&rvLog, "rvSocketAddrSetInetPort");
}


RvBool rvSocketAddrEqual(const RvSocketAddr *thisPtr, const RvSocketAddr *bPtr)
{
    RvBool result = rvFalse;

    rvLogEnter(&rvLog, "rvSocketAddrEqual");
    
    if((thisPtr->protocol == bPtr->protocol) && (thisPtr->length   == bPtr->length)) {
        if(thisPtr->protocol == RV_SOCKETADDR_PROTOCOL_IPV4) {
            if(memcmp(&thisPtr->address, &bPtr->address, 8) == 0)
                result = rvTrue;
        } else {
            if(memcmp(&thisPtr->address, &bPtr->address, thisPtr->length) == 0)
                result = rvTrue;
        }
    }

    rvLogLeave(&rvLog, "rvSocketAddrEqual");
    
    return result;
}

RvSocketAddr* rvSocketAddrCopy(RvSocketAddr *thisPtr, const RvSocketAddr *srcPtr)
{
    rvLogEnter(&rvLog, "rvSocketAddrCopy");
    
    thisPtr->length = srcPtr->length;
    thisPtr->protocol = srcPtr->protocol;
    memcpy(&thisPtr->address, &srcPtr->address, srcPtr->length);

    rvLogLeave(&rvLog, "rvSocketAddrCopy");
    
    return thisPtr;
}

void rvSocketAddrSetProtocolFromSockAddr(RvSocketAddr *thisPtr)
{
    rvLogEnter(&rvLog, "rvSocketAddrSetProtocolFromSockAddr");
    
    switch(((const struct sockaddr *)&thisPtr->address)->sa_family)
    {
        case AF_INET:
            thisPtr->protocol = RV_SOCKETADDR_PROTOCOL_IPV4;
            break;
#if defined(RV_INET_IPV6)
        case AF_INET6:
            thisPtr->protocol = RV_SOCKETADDR_PROTOCOL_IPV6;
            break;
#endif
        default:
            thisPtr->protocol = RV_SOCKETADDR_PROTOCOL_UNKNOWN;
            break;
    }

    rvLogLeave(&rvLog, "rvSocketAddrSetProtocolFromSockAddr");
    
}

int rvSocketAddrGetAddressFamily(const RvSocketAddr* thisPtr)
{
    int retVal = -1;
    
    rvLogEnter(&rvLog, "rvSocketAddrSetProtocolFromSockAddr");
    
    switch(thisPtr->protocol)
    {
        case RV_SOCKETADDR_PROTOCOL_IPV4:
            retVal = AF_INET;
            break;
#if defined(RV_INET_IPV6)
        case RV_SOCKETADDR_PROTOCOL_IPV6:
            retVal = AF_INET6;
            break;
#endif
     }

    rvLogLeave(&rvLog, "rvSocketAddrSetProtocolFromSockAddr");

    return retVal;
}

RvBool rvSocketAddrIsMulticast(const RvSocketAddr* thisPtr)
{
    RvBool retVal = rvFalse;

    switch(thisPtr->protocol)
    {
        case RV_SOCKETADDR_PROTOCOL_IPV4:
        {
            struct sockaddr_in* protocolAddr = (struct sockaddr_in*)&thisPtr->address;
            RvUint32 highByte = ntohl(*((RvUint32 *)&protocolAddr->sin_addr)) >> 24;

            retVal = ((highByte >= 224) && (highByte < 240));

            break;
        }
#if defined(RV_INET_IPV6)
        case RV_SOCKETADDR_PROTOCOL_IPV6:
        {
            struct sockaddr_in6* protocolAddr = (struct sockaddr_in6*)&thisPtr->address;
 
            retVal = (protocolAddr->sin6_addr.s6_addr[0] == 0xFF);

            break;
        }
#endif
    }

    return retVal;
}

#define BITS_IN_int     (sizeof(int) * CHAR_BIT)
#define THREE_QUARTERS  ((int)((BITS_IN_int * 3) / 4))
#define ONE_EIGHTH      ((int)(BITS_IN_int / 8))
#define HIGH_BITS       (~((unsigned int)(~0) >> ONE_EIGHTH))

size_t rvSocketAddrHash(const RvSocketAddr *addr)
{
    size_t hash_value = 0;
    const unsigned char *datum = (const unsigned char *)rvSocketAddrGetRawAddress(addr);
    const unsigned char *end = datum + rvSocketAddrGetLength(addr);

    datum += 2;
    if(rvSocketAddrGetProtocol(addr) == RV_SOCKETADDR_PROTOCOL_IPV4)
        end = datum + 6; 

    while(datum < end)
    {
        size_t i;
        hash_value = (hash_value << ONE_EIGHTH) + *datum;
        if((i = hash_value & HIGH_BITS) != 0)
            hash_value = (hash_value ^ (i >> THREE_QUARTERS)) & ~HIGH_BITS;
        ++datum;
    }

    return hash_value;
}