rvmegacomg.c

h.248协议源码

/******************************************************************************
Filename:    rvmegacomg.c
Description: sample mg application
*******************************************************************************
                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 "rvmegacogateway.h"
#include "rvstdiologlistener.h"
#include "rvfileloglistener.h"
#include "rvlog.h"
#include "rvplatform.h"
#include <stdio.h>

#define APP_FILELOGLISTENER_ENTRIES 5000

#define APP_TRANSPORT		RV_TRANSPORTTYPE_UDP
#define APP_SIMPREFIX		"70"
#define APP_SIMNUMTERM		0	/* Set to 0 to turn off simulator */
#define APP_MGNAME			"192.168.216.70"
#define APP_MGCNAME			"192.168.216.79"
#define APP_STARTDELAY		10

#if defined(RV_IO_ANSI)
static RvStdioLogListener stdioListener;
#endif

#if defined(RV_FILEIO_ANSI)
static RvFileLogListener fileListener;
#endif

void appLogInit(RvLog* log) {

	rvLogSetMask(log, RV_LOGLEVEL_ERROR | RV_LOGLEVEL_SEND | RV_LOGLEVEL_RECEIVE);

#if defined(RV_IO_ANSI)
	/* Construct the stdio listener */
	rvStdioLogListenerConstruct(&stdioListener, RV_LOGMASK_ALL, NULL);

	/* Register the stdio listener with the log */
	rvLogRegisterListener(log, rvStdioLogListenerGetLogListener(&stdioListener));
#endif 
	
#if defined(RV_FILEIO_ANSI)
	/* Construct the file listener */
	rvFileLogListenerConstruct(&fileListener, RV_LOGMASK_ALL ,"log_mg_", 
	  APP_FILELOGLISTENER_ENTRIES);
    
	/* Register the file listener with the log */
	rvLogRegisterListener(log, rvFileLogListenerGetLogListener(&fileListener));
#endif
}

void appLogEnd(RvLog* log) {
#if defined(RV_IO_ANSI)
	rvLogUnregisterListener(&rvLog, rvStdioLogListenerGetLogListener(&stdioListener));
	rvStdioLogListenerDestruct(&stdioListener);
#endif

#if defined(RV_FILEIO_ANSI)
	rvLogUnregisterListener(&rvLog, rvFileLogListenerGetLogListener(&fileListener));
	rvFileLogListenerDestruct(&fileListener);
#endif
}

int appStart(RvTransportType transportType, const char *simPrefix, 
  unsigned int simTerms, const char *mgIp, const char *mgcLocations, 
  unsigned int startDelay)
{
	RvMegacoEntityAddress mgcAddr;
	RvMegacoGateway gw;
	FILE *mgcFile;
	RvBool firstMgc = rvTrue;
	volatile RvBool keepGoing = rvTrue;

	rvMegacoSystemInit();

	appLogInit(&rvLog);

#if defined(RV_FILEIO_ANSI)
	mgcFile = fopen(mgcLocations, "rt");
	if(mgcFile == NULL)
	{
#if defined(RV_IO_ANSI)
		fprintf(stderr, "Cannot find MGC configuration file %s\n", mgcLocations);
#endif
		return 1;
	}

	for(;;)
	{
		char buf[128], addr[128];
		

		if(fgets(buf, sizeof(buf), mgcFile) == NULL)
			break;
		if(sscanf(buf, "%s", addr) < 1)
			break;
		
		if(rvMegacoEntityAddressConstructAny(&mgcAddr, addr) == NULL)
		{
#if defined(RV_IO_ANSI)
			fprintf(stderr, "Illegal mId: %s\n", addr);
#endif
			continue;
		}
		if(firstMgc)
		{
			rvMegacoGatewayConstruct(&gw, mgIp, transportType, &mgcAddr, startDelay);
			firstMgc = rvFalse;
		}
		else
		{
			rvMegacoGatewayAddRemote(&gw, &mgcAddr);
		}
		rvMegacoEntityAddressDestruct(&mgcAddr);
	}
	
	fclose(mgcFile);
	
	if(firstMgc) {
#if defined(RV_IO_ANSI)
		fprintf(stderr, "No MGCs found in configuration file\n", mgcLocations);
#endif
		return 1;
	}
#else
	rvMegacoEntityAddressConstruct(&mgcAddr, mgcLocations, 0);
	rvMegacoGatewayConstruct(&gw, mgIp, transportType, &mgcAddr, startDelay);
	rvMegacoEntityAddressDestruct(&mgcAddr);
#endif
	if(simTerms)
		rvMegacoGatewayStartSim(&gw, simPrefix, simTerms);

	while(keepGoing)
		rvThreadSleep(3600 * 1000); 
		
	rvMegacoGatewayDestruct(&gw);

	appLogEnd(&rvLog);

	rvMegacoSystemEnd();

	return 0;
}


#if defined(RV_OS_VXWORKS) || defined(RV_OS_OSE) || defined(RV_OS_NUCLEUS)
/* Embedded systems entry point */

void appMain(void) 
{
	exit(appStart(APP_TRANSPORT, APP_SIMPREFIX, APP_SIMNUMTERM, APP_MGNAME,
	  APP_MGCNAME, APP_STARTDELAY));
}

#elif defined(RV_OS_PSOS)
/* pSoS entry point and configuration */
#include <psos.h>
#include <prepc.h>

void appMain(int argc, char **argv, char **env, void *exit_param, const char *console_dev)
{
	appStart(APP_TRANSPORT, APP_SIMPREFIX, APP_SIMNUMTERM, APP_MGNAME,
	  APP_MGCNAME, APP_STARTDELAY);
	psh_exit(exit_param);
}

#else
int main(int argc, char **argv) {
	RvTransportType transportType = RV_TRANSPORTTYPE_TCP;
	const char *mgIp, *mgcFileName, *simPrefix;
	unsigned int startDelay = 3, simTerms = 0;

	while(argc >= 2)
	{
		int skip;
		if(!rvStrIcmp(argv[1], "-u"))
		{
			transportType = RV_TRANSPORTTYPE_UDP;
			skip = 1;
		}
		else if(!rvStrIcmp(argv[1], "-sim") && argc >= 4)
		{
			/* simulator option: [-sim prefix numTerms] */
			simPrefix = argv[2];
			simTerms = atoi(argv[3]);
			skip = 3;
		}
		else
			break;
			
		/* adjust program arguments */
		argv[skip] = argv[0];
		argc -= skip;
		argv += skip;
	}
	
	switch(argc)
	{
	case 4:
		startDelay = atoi(argv[3]);
		/* fall through */
	case 3:
		mgcFileName = argv[2];
		mgIp = argv[1];
		break;
	default:
		fprintf(stderr, "Usage: %s [-u][-sim prefix #terms] mgIp mgcFileName [startDelay]\n", argv[0]);
		return 0;
	}

	return appStart(transportType, simPrefix, simTerms, mgIp, mgcFileName, startDelay);
}
#endif