请教：以下代码是用什么语言实现的，谢谢^_^

MegacoStack stack;

MegacoEntity mgcTcp, mgcUdp;

Priority priority;

MegacoEntityAddress mgcAddr;

/* Initialize system */

MegacoSystemInit();

/* The MEGACO Stack has embedded logging messages which can

be used for debugging purposes. The logging messages can be

turned on or off. */

/* Start-up standard I/O listener */

stdioListener =

(LogListener*)MemAlloc(sizeof(LogListener));

LogListenerConstruct(stdioListener, LOGMASK_ERROR,
....

用到数据库了吗？

协议栈初始化：

MegacoStack stack;

MegacoEntity mgcTcp, mgcUdp;

Priority priority;

MegacoEntityAddress mgcAddr;

/* Initialize system */

MegacoSystemInit();

/* The MEGACO Stack has embedded logging messages which can

be used for debugging purposes. The logging messages can be

turned on or off. */

/* Start-up standard I/O listener */

stdioListener =

(LogListener*)MemAlloc(sizeof(LogListener));

LogListenerConstruct(stdioListener, LOGMASK_ERROR,

LogStdio, stderr);

LogRegisterListener(&Log, stdioListener);

/* Start-up file listener */

fileListener =

(LogListener*)MemAlloc(sizeof(LogListener));

LogListenerConstruct(fileListener, LOGMASK_NONE,

LogFile, (void*)LOG_FILEDEPTH);

LogRegisterListener(&Log, fileListener);

/* Construct stack */

PriorityConstruct(&priority, PRIORITYCLASS_LOW,

priorityValue);

MegacoStackConstruct(&stack, numThreads, &priority);

/* Register stack callbacks */

MegacoStackRegisterSecurityKeyCB(&stack, getKey,

userData);

MegacoStackRegisterAuthenticationCB(&stack, HmacMd5,

MD5_HASHLENGTH);

MegacoStackRegisterRawRecvCB(&stack, rawRecvCallback,

userData);

MegacoStackRegisterRawSendCB(&stack, rawSendCallback,

userData);

/* Construct entity address */

MegacoEntityAddressConstruct(&mgcAddr, "88.42.39.56", 0 /*

use default port */);

/* Construct entities */

MegacoEntityConstructLocal(&mgcTcp, &mgcAddr, True,

MEGACOENTITYTYPE_MGC, TRANSPORTTYPE_TCP,

MEGACOENCODING_TEXT, &stack);

MegacoEntityConstructLocal(&mgcUdp, &mgcAddr, True,

MEGACOENTITYTYPE_MGC, TRANSPORTTYPE_UDP,

MEGACOENCODING_TEXT, &stack);

/* Register callbacks for local entities */

MegacoEntityRegisterRecvRequestCB(&mgcTcp, processRequest,

userData);

MegacoEntityRegisterRecvRequestCB(&mgcUdp, processRequest,

userData);

MegacoEntityRegisterRecvErrorMsgCB(&mgcTcp, processError,

userData);

MegacoEntityRegisterRecvErrorMsgCB(&mgcUdp, processError,

userData);

/* Destroy temporary objects */

MegacoEntityAddressDestruct(&mgcAddr);

PriorityDestruct(&priority);

/* Register stack with the system */

MegacoSystemRegisterStack(&stack);

/* ... */

/* Unregister stack */

MegacoSystemUnregisterStack(&stack);

/* Destroy objects */

MegacoEntityDestruct(&mgcUdp);

MegacoEntityDestruct(&mgcTcp);

MegacoStackDestruct(&stack);

/* System cleanup */

MegacoSystemEnd();

创建和发送H.248事务

MegacoServiceChangeDescriptor services;

MegacoServiceChangeCommand command;

MegacoContextId contextId;

MegacoAction action;

MegacoTransaction transaction;

/* Construct termination ID. (ROOT requires special constructor) */

MegacoTerminationIdConstructRoot(&terminationId);

/* Construct required descriptors */

MegacoServiceChangeDescriptorConstruct(&services);

/* Set desired fields */

MegacoServiceChangeDescriptorSetMethod(&services,

MEGACOSERVICECHANGEMETHOD_RESTART);

/* Construct command */

MegacoServiceChangeCommandConstruct(&command,&terminationId, &services);

/* Construct context ID. (NULL requires special constructor)*/

MegacoContextIdConstructSpecial(&contextId,

MEGACOCONTEXTID_NULL);

/* Construct action */

MegacoActionConstruct(&action, &contextId);

/* Add command to action */

MegacoActionAddCommand(&action, &command);

/* Construct transaction */

MegacoTransactionConstruct(&transaction);

/* Add action to transaction */

MegacoTransactionAddAction(&transaction, &action);

/* Send transaction */

MegacoEntitySendRequest(&remoteEntity, &transaction,

processReply, userData);

/* Destroy objects */

MegacoTransactionDestruct(&transaction);

MegacoActionDestruct(&action);

MegacoContextIdDestruct(&contextId);

MegacoServiceChangeCommandDestruct(&command);

MegacoServiceChangeDescriptorDestruct(&services);

MegacoTerminationIdDestruct(&terminationId);

创建和发送H.248事务响应

void processRequest(MegacoTcb *tcb, const

MegacoTransaction *transaction, void *data)

{

MegacoTransactionReply transReply;

size_t i;

/* Construct transaction reply */

MegacoTransactionReplyConstruct(&transReply, transaction);

for(i=0; i<MegacoTransactionGetNumActions(transaction);

++i)

{

const MegacoAction *action =

MegacoTransactionGetAction(transaction, i);

MegacoActionReply actionReply;

size_t j;

/* Construct action reply for each action */

MegacoActionReplyConstruct(&actionReply, action);

for(j=0; j<MegacoActionGetNumCommands(action); ++j)

{

const MegacoCommand *command =

MegacoActionGetCommand(action, j);

MegacoCommandReply commandReply;

/* Construct command reply for each command */

MegacoCommandReplyConstruct(&commandReply, command);

/* Add descriptors to command reply as necessary */

/* ... */

/* Add command reply to action reply */

MegacoActionReplyAddReply(&actionReply, &commandReply);

/* Destruct command reply */

MegacoCommandReplyDestruct(&commandReply);

"ServiceChange = ROOT {\n"

"Services { Method = Restart } } } }";

if(MegacoTransactionConstructParse(&transaction, text,

NULL) != NULL)

{

MegacoEntitySendRequest(&remoteEntity, &transaction,

processReply, userData);

MegacoTransactionDestruct(&transaction);

}

"ServiceChange = ROOT {\n"

"Services { Method = Restart } } } }";

if(MegacoTransactionConstructParse(&transaction, text,

NULL) != NULL)

{

MegacoEntitySendRequest(&remoteEntity, &transaction,

processReply, userData);

MegacoTransactionDestruct(&transaction);

}