rvportrange.c

基于h323协议的软phone

/***********************************************************************
Filename   : rvportrange.c
Description: port range implementation.
************************************************************************
                Copyright (c) 2001 RADVISION Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVISION LTD.
No part of this publication may be reproduced in any form whatsoever
without written prior approval by RADVISION LTD..

RADVISION LTD. reserves the right to revise this publication and make
changes without obligation to notify any person of such revisions or
changes.
************************************************************************/

#include "rvmemory.h"
#include "rvportrange.h"


/* Lets make error codes a little easier to type */
#define RvPortRangeErrorCode(_e) RvErrorCode(RV_ERROR_LIBCODE_CCORE, RV_CCORE_MODULE_PORTRANGE, (_e))



/********************************************************************************************
 * RvPortRangeConstruct
 *
 * purpose : Create a port-range object.
 * input   : portRange  - Object to construct
 *           fromPort   - Port to start from in the range
 *           toPort     - Last port in the range
 * output  : None
 * return  : RV_OK on success, other on failure
 ********************************************************************************************/
RVCOREAPI
RvStatus RVCALLCONV  RvPortRangeConstruct(
    IN RvPortRange* portRange,
    IN RvUint       fromPort,
    IN RvUint       toPort)
{
    RvStatus status = RV_OK;

#if defined(RV_NULLCHECK)
    if (portRange == NULL)
        return RvPortRangeErrorCode(RV_ERROR_NULLPTR);
#endif

#if defined(RV_RANGECHECK)
    if ((toPort > RvUintConst(0xffff)) || (fromPort > toPort))
        return RvPortRangeErrorCode(RV_ERROR_BADPARAM);
#endif

    portRange->fromPort = (RvUint16)fromPort;
    portRange->toPort = (RvUint16)toPort;
    portRange->numberOfFreePorts = toPort - fromPort + 1;

#if (RV_PORTRANGE_TYPE == RV_PORTRANGE_SLIM)
    portRange->next = portRange->fromPort;

#elif (RV_PORTRANGE_TYPE == RV_PORTRANGE_FAST)
    portRange->nextToAllocate = 0;
    portRange->lastToAllocate = (RvUint16)portRange->numberOfFreePorts;

    /* Allocate linked list of ports */
    status = RvMemoryAlloc(NULL, (void**)&portRange->range,
        sizeof(RvUint16) * portRange->numberOfFreePorts);
    if (status != RV_OK)
        return status;

    {
        RvUint i;

        /* Fill in the linked list with all of the ports within the range */
        for (i = 0; i < portRange->numberOfFreePorts; i++)
            portRange->range[i] = (RvUint16)(i + 1);
    }
#endif

    return status;
}


/********************************************************************************************
 * RvPortRangeDestruct
 *
 * purpose : Kill a port-range object.
 * input   : portRange  - Object to destruct
 * output  : None
 * return  : RV_OK on success, other on failure
 ********************************************************************************************/
RVCOREAPI
RvStatus RVCALLCONV  RvPortRangeDestruct(
    IN RvPortRange* portRange)
{
    RvStatus res = RV_OK;
#if defined(RV_NULLCHECK)
    if (portRange == NULL)
        return RvPortRangeErrorCode(RV_ERROR_NULLPTR);
#endif

#if (RV_PORTRANGE_TYPE == RV_PORTRANGE_FAST)
    res = RvMemoryFree(portRange->range);
#endif

    return res;
}


/********************************************************************************************
 * RvPortRangeGetRange
 *
 * purpose : Returns a range of ports the port-range object deals with
 * input   : portRange  - Port range object to use
 * output  : fromPort   - Port we're starting from
 *           toPort     - Last port in range
 * return  : RV_OK on success, other on failure
 ********************************************************************************************/
RvStatus RvPortRangeGetRange(
    IN  RvPortRange*    portRange,
    OUT RvUint*         fromPort,
    OUT RvUint*         toPort)
{
#if defined(RV_NULLCHECK)
    if (portRange == NULL)
        return RvPortRangeErrorCode(RV_ERROR_NULLPTR);
#endif

    if (fromPort != NULL)
        *fromPort = (RvUint)portRange->fromPort;
    if (toPort != NULL)
        *toPort = (RvUint)portRange->toPort;
    
    return RV_OK;
}


/********************************************************************************************
 * RvPortRangeGetNumberOfFreePorts
 *
 * purpose : Returns the number of free ports in port range
 * input   : portRange  - Port range object to use
 * output  : freePorts  - The number of free ports
 * return  : RV_OK on success, other on failure
 ********************************************************************************************/
RvStatus RvPortRangeGetNumberOfFreePorts(
    IN  RvPortRange*    portRange,
    OUT RvUint*         freePorts)
{
#if defined(RV_NULLCHECK)
    if ((portRange == NULL) || (freePorts == NULL))
        return RvPortRangeErrorCode(RV_ERROR_NULLPTR);
#endif

    *freePorts = portRange->numberOfFreePorts;
    
    return RV_OK;
}


/********************************************************************************************
 * RvPortRangeGetPort
 *
 * purpose : Returns a port from the port range
 * input   : portRange  - Port range object to use
 * output  : port       - Free port for the application's use
 * return  : RV_OK on success, other on failure
 ********************************************************************************************/
RvStatus RvPortRangeGetPort(
    IN  RvPortRange*    portRange,
    OUT RvUint*         port)
{
    RvStatus status = RV_OK;

#if defined(RV_NULLCHECK)
    if ((portRange == NULL) || (port == NULL))
        return RvPortRangeErrorCode(RV_ERROR_NULLPTR);
#endif

    if (portRange->numberOfFreePorts > 0)
    {
#if (RV_PORTRANGE_TYPE == RV_PORTRANGE_FAST)
        /* We have some vacant ports - give next one away */
        *port = portRange->fromPort + portRange->nextToAllocate;

        /* Fix the list of ports in range */
        portRange->nextToAllocate = portRange->range[portRange->nextToAllocate];

#elif (RV_PORTRANGE_TYPE == RV_PORTRANGE_SLIM)
        /* Try the next port and continue (round robin) */
        *port = (RvUint)portRange->next;
        if (portRange->next < portRange->toPort)
            portRange->next++;
        else
            portRange->next = portRange->fromPort;
#endif
        portRange->numberOfFreePorts--;
    }
    else
    {
        /* No more free ports... */
        status = RvPortRangeErrorCode(RV_ERROR_OUTOFRESOURCES);
    }

    return status;
}


/********************************************************************************************
 * RvPortRangeReleasePort
 *
 * purpose : Returns the port into the port range
 * input   : portRange      - Port range object to use
 *           portToRelease  - Port to return to the port range
 * output  : None
 * return  : RV_OK on success, other on failure
 ********************************************************************************************/
RvStatus RvPortRangeReleasePort(
    IN  RvPortRange*    portRange,
    IN  RvUint          portToRelease)
{
    RvStatus status = RV_OK;

#if defined(RV_NULLCHECK)
    if (portRange == NULL)
        return RvPortRangeErrorCode(RV_ERROR_NULLPTR);
#endif

#if defined(RV_RANGECHECK)
    if ((portToRelease < portRange->fromPort) || (portToRelease > portRange->toPort))
        return RvPortRangeErrorCode(RV_ERROR_OUTOFRANGE);
#endif

#if (RV_PORTRANGE_TYPE == RV_PORTRANGE_FAST)
    {
        RvUint16 portIndex;

        /* Calculate index of this released port */
        portIndex = (RvUint16)(portToRelease - portRange->fromPort);

        if (portRange->numberOfFreePorts > 0)
        {
            /* We have some vacant ports - add this one after the last one */
            portRange->range[portRange->lastToAllocate] = portIndex;
        }
        else
        {
            /* No ports at all - add as first one (and last at the same time) */
            portRange->nextToAllocate = portRange->lastToAllocate = portIndex;
        }

        portRange->lastToAllocate = portIndex;
        portRange->numberOfFreePorts++;
    }

#elif (RV_PORTRANGE_TYPE == RV_PORTRANGE_SLIM)
    /* Slim port range feature ignores the release of ports and just increases the number of
       free ports */
    portRange->numberOfFreePorts++;
#endif

    return status;
}





#if defined(RV_TEST_CODE)

#include "rvstdio.h"

#define RvPortRangePrintError(_r) RvPrintf("Error %d/%d/%d\n",  RvErrorGetLib((_r)), RvErrorGetModule((_r)), RvErrorGetCode((_r)))


void RvPortRangeTest(void)
{
    RvStatus res;
    RvPortRange portRange;
    RvUint ports[20];
    RvUint i, maxPorts;

    RvCCoreInit();

    RvPrintf("RvPortRangeConstruct(10, 20): ");
    res = RvPortRangeConstruct(&portRange, 10, 20);
    if (res != RV_OK) {
        RvPortRangePrintError(res);
    } else RvPrintf("OK\n");

    RvPrintf("RvPortRangeGetNumberOfFreePorts: ");
    res = RvPortRangeGetNumberOfFreePorts(&portRange, &maxPorts);
    if (res != RV_OK) {
        RvPortRangePrintError(res);
    } else RvPrintf("OK (%d)\n", maxPorts);

    if (maxPorts != 11)
    {
        RvPrintf("ERROR: Wrong number of ports returned...\n");
    }

    /* See if we can allocate all ports in range */
    for (i = 0; i < maxPorts; i++)
    {
        RvPrintf("RvPortRangeGetPort: ");
        res = RvPortRangeGetPort(&portRange, &ports[i]);
        if (res != RV_OK) {
            RvPortRangePrintError(res);
        } else RvPrintf("OK (%d)\n", ports[i]);
    }

    /* Try to get another port and make sure we fail */
    res = RvPortRangeGetPort(&portRange, &ports[i]);
    if (res == RV_OK)
    {
        RvPrintf("ERROR: Succeeded to get a port when list should be empty\n");
    }

    /* Free all ports */
    for (i = 0; i < maxPorts; i++)
    {
        RvPrintf("RvPortRangeReleasePort(%d): ", ports[i]);
        res = RvPortRangeReleasePort(&portRange, ports[i]);
        if (res != RV_OK) {
            RvPortRangePrintError(res);
        } else RvPrintf("OK\n");
    }

    /* Try to get another port - we should have one available */
    RvPrintf("RvPortRangeGetPort: ");
    res = RvPortRangeGetPort(&portRange, &ports[0]);
    if (res != RV_OK) {
        RvPortRangePrintError(res);
    } else RvPrintf("OK (%d)\n", ports[0]);

    RvPrintf("RvPortRangeDestruct: ");
    res = RvPortRangeDestruct(&portRange);
    if (res != RV_OK) {
        RvPortRangePrintError(res);
    } else RvPrintf("OK\n");

    RvCCoreEnd();
}


#endif  /* RV_TEST_CODE */