1899 lines
60 KiB
C++
1899 lines
60 KiB
C++
#include "precomp.h"
|
|
/**********************************************************************
|
|
* File: gcclog.h
|
|
* Abstract: public function definitions for protocol logging functions
|
|
* added into GCCNC.DLL to read the contents of GCC and MCS PDU
|
|
* contents going over the wire.
|
|
* Created: 12/21/95, Venkatesh Gopalakrishnan
|
|
* Copyright (c) 1995 Microsoft Corpration
|
|
******************************************************************** */
|
|
|
|
|
|
/** Note: the contents of this file are only included if the constant
|
|
** PDULOG is defined. PDULOG is defined by default ONLY in the
|
|
** Win32 Diagnostic build configuration of GCCNC.DLL
|
|
**/
|
|
#ifdef PDULOG
|
|
|
|
#include "ms_util.h"
|
|
#include <ctype.h>
|
|
#include <windows.h>
|
|
|
|
#include "pdutypes.h"
|
|
#include "gcclog.h"
|
|
|
|
|
|
#define outdeb //OutputDebugString
|
|
|
|
/**
|
|
** Maintainance Functions for the Protocol Logging Mechanism
|
|
**/
|
|
|
|
/*********************************************************************/
|
|
int InitializeGCCLog()
|
|
{
|
|
FILE *logfile;
|
|
|
|
/* this should just reset the file pointer */
|
|
logfile = fopen(LOG_FILE_NAME,"w");
|
|
|
|
// this "fake" starting PDU is put in so that the Intel Protocol Browser
|
|
// dosen't go nuts if it is reading dynamically.
|
|
pduLog(logfile,"START_PDU: ============================== START PDU ===========================\n");
|
|
pduLog(logfile,"TIMESTAMP: %s\n",pszTimeStamp());
|
|
pduLog(logfile,"LAYER: GCC\n");
|
|
pduLog(logfile,"DIRECTION: None\n");
|
|
pduLog(logfile,"RAW_PDU: - - - - - - - - RAW PDU - - - - - - - -\n");
|
|
pduLog(logfile,"DECODED_PDU: - - - - - - - DECODED PDU - - - - - - -\n");
|
|
pduLog(logfile,"PDU_TYPE: Bogus PDU to start the logging.\n");
|
|
pduLog(logfile,"END_PDU: ================================ END PDU =============================\n");
|
|
|
|
fclose(logfile);
|
|
return(0);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
char *pszTimeStamp()
|
|
{
|
|
char *timestring;
|
|
timestring = (char *) malloc (13*sizeof(char));
|
|
_strtime(timestring);
|
|
return(timestring);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduFragmentation(FILE *logfile,unsigned int i)
|
|
{
|
|
pduLog(logfile," PDU Fragmentation: ");
|
|
if(i==1)
|
|
{
|
|
pduLog(logfile,"Complete PDU\n");
|
|
}
|
|
else
|
|
{
|
|
pduLog(logfile,"!!!! Icomplete PDU !!!!\n");
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduRawOutput (FILE *logfile,unsigned char *data, unsigned long length)
|
|
{
|
|
unsigned int i=0,j=0;
|
|
|
|
pduLog(logfile," ");
|
|
for (i=0; i<length; i++)
|
|
{
|
|
pduLog(logfile,"%02x ",*(data+i));
|
|
j++;
|
|
if (j >= 16)
|
|
{
|
|
pduLog(logfile,"\n ");
|
|
j=0;
|
|
}
|
|
}
|
|
pduLog(logfile,"\n");
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void gccLog(PPacket packet, PGCCPDU gcc_pdu, unsigned int direction, int mcs_pdu)
|
|
{
|
|
FILE *logfile;
|
|
logfile = fopen(LOG_FILE_NAME,"a+");
|
|
|
|
pduLog(logfile,"START_PDU: ============================== START PDU ===========================\n");
|
|
pduLog(logfile,"TIMESTAMP: %s\n",pszTimeStamp());
|
|
pduLog(logfile,"LAYER: GCC\n");
|
|
pduDirection(logfile,direction);
|
|
pduLog(logfile,"RAW_PDU: - - - - - - - - RAW PDU - - - - - - - -\n");
|
|
pduLog(logfile," %d octets (hex output):\n",packet->GetEncodedDataLength());
|
|
pduRawOutput(logfile,packet->GetEncodedData(1),packet->GetEncodedDataLength());
|
|
pduLog(logfile,"DECODED_PDU: - - - - - - - DECODED PDU - - - - - - -\n");
|
|
pduFragmentation(logfile,packet->IsValid());
|
|
pduLogGCCInformation(logfile,gcc_pdu);
|
|
pduLog(logfile,"END_PDU: ================================ END PDU =============================\n");
|
|
|
|
fclose(logfile);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void gccConnectLog(PPacket packet, PConnectGCCPDU connect_pdu, unsigned int direction, int mcs_pdu)
|
|
{
|
|
FILE *logfile;
|
|
logfile = fopen(LOG_FILE_NAME,"a+");
|
|
|
|
pduLog(logfile,"START_PDU: ============================== START PDU ===========================\n");
|
|
pduLog(logfile,"TIMESTAMP: %s\n",pszTimeStamp());
|
|
pduLog(logfile,"LAYER: GCC\n");
|
|
pduDirection(logfile,direction);
|
|
pduLog(logfile,"RAW_PDU: - - - - - - - - RAW PDU - - - - - - - -\n");
|
|
pduLog(logfile," %d octets (hex output):\n",packet->GetEncodedDataLength());
|
|
if(direction==RECEIVED)
|
|
pduRawOutput(logfile,packet->GetEncodedData(1),packet->GetEncodedDataLength());
|
|
pduLog(logfile,"DECODED_PDU: - - - - - - - DECODED PDU - - - - - - -\n");
|
|
pduFragmentation(logfile,packet->IsValid());
|
|
pduLogGCCConnectInfo(logfile,connect_pdu);
|
|
pduLog(logfile,"END_PDU: ================================ END PDU =============================\n");
|
|
|
|
fclose(logfile);
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
void pduDirection(FILE *logfile,unsigned int direction)
|
|
{
|
|
switch(direction)
|
|
{
|
|
case SENT:
|
|
pduLog(logfile,"DIRECTION: Sent\n");
|
|
break;
|
|
case RECEIVED:
|
|
pduLog(logfile,"DIRECTION: Received\n");
|
|
break;
|
|
case FORWARDED:
|
|
pduLog(logfile,"DIRECTION: Forwarded\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"DIRECTION: Unknown\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLog (FILE *pFile, char * format,...)
|
|
{
|
|
char *argument_ptr;
|
|
|
|
argument_ptr = (char *) &format + sizeof (format);
|
|
vfprintf (pFile, format, argument_ptr);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogUserIDIndication(FILE *logfile,PGCCPDU gcc_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_UserIDIndication\n");
|
|
pduLog(logfile," Tag: %d\n",gcc_pdu->u.indication.u.user_id_indication.tag);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogRosterUpdateIndication(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RosterUpdateIndication\n");
|
|
pduLog(logfile,"Conference Information\n");
|
|
pduLog(logfile,"\tFull refresh flag: %d\n",
|
|
gcc_pdu->u.indication.u.roster_update_indication.refresh_is_full);
|
|
PrintConferenceRoster(logfile,gcc_pdu->u.indication.u.roster_update_indication.node_information);
|
|
PrintApplicationRoster(logfile,gcc_pdu->u.indication.u.roster_update_indication.application_information);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogTextMessageIndication(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
Char print_buffer[255];
|
|
pduLog(logfile,"PDU_TYPE: GCC_TextMessageIndication\n");
|
|
pduLog(logfile,"Message: %d octets (hex output) \n",
|
|
gcc_pdu->u.indication.u.text_message_indication.message.length);
|
|
pduRawOutput(logfile,
|
|
(unsigned char *) gcc_pdu->u.indication.u.text_message_indication.message.value,
|
|
gcc_pdu->u.indication.u.text_message_indication.message.length);
|
|
if(CopyTextToChar(print_buffer,gcc_pdu->u.indication.u.text_message_indication.message))
|
|
pduLog(logfile,"Text: %s\n",print_buffer);
|
|
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceTerminateIndication(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
char szReason[255];
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTerminateIndication\n");
|
|
if(gcc_pdu->u.indication.u.conference_terminate_indication.reason == 0)
|
|
strcpy(szReason,"User Initiated");
|
|
else
|
|
strcpy(szReason,"Terminated Confernece");
|
|
|
|
pduLog(logfile,"\tReason: %s\n",szReason);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceEjectUserIndication(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceEjectUserIndication\n");
|
|
pduLog(logfile,"\tNode to Eject: %u\n",
|
|
gcc_pdu->u.indication.u.conference_eject_user_indication.node_to_eject);
|
|
|
|
switch(gcc_pdu->u.indication.u.conference_eject_user_indication.reason)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tReason: USER_INITIATED\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tReason: HIGHER_NODE_DISCONNECTED\n");
|
|
break;
|
|
case 2:
|
|
pduLog(logfile,"\tReason: HIGHER_NODE_EJECTED\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tReason: >>> Unkown Reason for Ejection <<<\n");
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceJoinRequest(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
outdeb("TOP: pduLogConferenceJoinRequest\n");
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceJoinRequest\n");
|
|
PrintConferenceName(logfile,
|
|
gcc_pdu->u.request.u.conference_join_request.conference_name);
|
|
|
|
pduLog(logfile,"\tTag: %u\n",
|
|
gcc_pdu->u.request.u.conference_join_request.tag);
|
|
|
|
if(gcc_pdu->u.request.u.conference_join_request.bit_mask & 0x10)
|
|
{
|
|
PrintPasswordChallengeRequestResponse(logfile,
|
|
gcc_pdu->u.request.u.conference_join_request.cjrq_password);
|
|
}
|
|
if(gcc_pdu->u.request.u.conference_join_request.bit_mask & 0x08)
|
|
{
|
|
pduLog(logfile,"\tConvener ");
|
|
PrintPasswordSelector(logfile,
|
|
gcc_pdu->u.request.u.conference_join_request.cjrq_convener_password);
|
|
}
|
|
//insert caller id here.
|
|
outdeb("Botton: pduLogConferenceJoinRequest\n");
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConnectJoinRequest(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
outdeb("TOP: pduLogConnectJoinRequest\n");
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceJoinRequest\n");
|
|
PrintConferenceName(logfile,
|
|
connect_pdu->u.connect_join_request.conference_name);
|
|
pduLog(logfile,"\tTag: %u\n",
|
|
connect_pdu->u.connect_join_request.tag);
|
|
if(connect_pdu->u.connect_join_request.bit_mask & 0x10)
|
|
{
|
|
PrintPasswordChallengeRequestResponse(logfile,
|
|
connect_pdu->u.connect_join_request.cjrq_password);
|
|
}
|
|
if(connect_pdu->u.connect_join_request.bit_mask & 0x10)
|
|
{
|
|
pduLog(logfile,"\tConvener ");
|
|
PrintPasswordSelector(logfile,
|
|
connect_pdu->u.connect_join_request.cjrq_convener_password);
|
|
}
|
|
//insert caller id here.
|
|
outdeb("BOTTOM: pduLogConnectJoinRequest\n");
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogQueryResponse(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
UShort i=0;
|
|
SetOfConferenceDescriptors * conference_list;
|
|
CHAR print_buffer[255] = " ";
|
|
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceQueryResponse\n");
|
|
pduLog(logfile,"Node Query Information:\n");
|
|
switch(connect_pdu->u.conference_query_response.node_type)
|
|
{
|
|
case GCC_TERMINAL:
|
|
pduLog( logfile, "\tnode_type = GCC_TERMINAL\n");
|
|
break;
|
|
case GCC_MULTIPORT_TERMINAL:
|
|
pduLog( logfile,
|
|
"\tnode_type = GCC_MULTIPORT_TERMINAL\n");
|
|
break;
|
|
case GCC_MCU:
|
|
pduLog( logfile, "\tnode_type = GCC_MCU\n");
|
|
break;
|
|
default:
|
|
pduLog( logfile,
|
|
"\tGCCNODE: ERROR: UNKNOWN NODE TYPE\n");
|
|
break;
|
|
}
|
|
|
|
// get a pointer to the returned conference list
|
|
conference_list = connect_pdu->u.conference_query_response.conference_list;
|
|
|
|
for(i=0;conference_list != NULL;i++)
|
|
{
|
|
pduLog(logfile,"\t**** Conference Record %u ****\n",i);
|
|
pduLog(logfile,"\tConference Numeric Name: %s\n",
|
|
conference_list->value.conference_name.numeric);
|
|
CopySimpleTextToChar(print_buffer,
|
|
conference_list->value.conference_name.conference_name_text);
|
|
pduLog(logfile,"\tConference Text Name: %s\n",print_buffer);
|
|
|
|
PrintT120Boolean(logfile,"conference_is_locked = ",
|
|
conference_list->value.conference_is_locked);
|
|
PrintT120Boolean(logfile,"clear_password_required = ",
|
|
conference_list->value.clear_password_required);
|
|
conference_list = conference_list->next;
|
|
}
|
|
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceCreateRequest(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
char print_buffer[255] = "";
|
|
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceCreateRequest\n");
|
|
pduLog(logfile,"\tConference Numeric Name: %s\n",
|
|
connect_pdu->u.conference_create_request.conference_name.numeric);
|
|
CopySimpleTextToChar(print_buffer,
|
|
connect_pdu->u.conference_create_request.conference_name.conference_name_text);
|
|
pduLog(logfile,"\tConference Text Name: %s\n",print_buffer);
|
|
PrintT120Boolean(logfile,
|
|
"\tConference Is Locked: ",
|
|
connect_pdu->u.conference_create_request.conference_is_locked);
|
|
PrintT120Boolean(logfile,
|
|
"\tConference Is Listed: ",
|
|
connect_pdu->u.conference_create_request.conference_is_locked);
|
|
PrintT120Boolean(logfile,
|
|
"\tConference Is Conductible: ",
|
|
connect_pdu->u.conference_create_request.conference_is_conductible);
|
|
switch(connect_pdu->u.conference_create_request.termination_method)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tTermination Method: AUTOMATIC\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tTermination Method: MANUAL \n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tTermination Method: UNKOWN \n");
|
|
break;
|
|
}
|
|
|
|
CopyTextToChar(print_buffer,
|
|
connect_pdu->u.conference_create_request.ccrq_caller_id);
|
|
pduLog(logfile,"\tCaller ID: %s\n",print_buffer);
|
|
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceCreateResponse(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceCreateResponse\n");
|
|
pduLog(logfile,"\tNode ID: %u\n",
|
|
connect_pdu->u.conference_create_response.node_id);
|
|
pduLog(logfile,"\tTag: %d\n",connect_pdu->u.conference_create_response.tag);
|
|
|
|
switch(connect_pdu->u.conference_create_response.result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tResult: SUCCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tResult: USER_REJECTED\n");
|
|
break;
|
|
case 2:
|
|
pduLog(logfile,"\tResult: LOW_RESOURCES\n");
|
|
break;
|
|
case 3:
|
|
pduLog(logfile,"\tResult: REJECTED_FOR_BREAKING_SYMMETRY\n");
|
|
break;
|
|
case 4:
|
|
pduLog(logfile,"\tResult: LOCKED_CONFERENCE_NOT_SUPPORTED\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tResult: >>> Unkown Result Type\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConnectJoinResponse(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceJoinResponse\n");
|
|
pduLog(logfile,"\tcjrs_node_id [%u]\n",
|
|
connect_pdu->u.connect_join_response.cjrs_node_id);
|
|
pduLog(logfile,"\ttop_node_id [%u]\n",
|
|
connect_pdu->u.connect_join_response.top_node_id);
|
|
PrintConferenceName(logfile,
|
|
connect_pdu->u.connect_join_response.conference_name_alias);
|
|
PrintT120Boolean(logfile,"\tclear_password_required = ",
|
|
connect_pdu->u.connect_join_response.clear_password_required);
|
|
PrintT120Boolean(logfile,"\tconference_is_locked = ",
|
|
connect_pdu->u.connect_join_response.conference_is_locked);
|
|
PrintT120Boolean(logfile,"\tconference_is_listed = ",
|
|
connect_pdu->u.connect_join_response.conference_is_listed);
|
|
PrintT120Boolean(logfile,"\tconference_is_conductible = ",
|
|
connect_pdu->u.connect_join_response.conference_is_conductible);
|
|
|
|
switch(connect_pdu->u.connect_join_response.termination_method)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tTermination Method: AUTOMATIC\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tTermination Method: MANUAL \n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tTermination Method: UNKOWN \n");
|
|
break;
|
|
}
|
|
|
|
switch(connect_pdu->u.connect_join_response.result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tResult: RESULT_SUCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tResult: USER_REJECTED\n");
|
|
break;
|
|
case 2:
|
|
pduLog(logfile,"\tResult: INVALID_CONFERENCE\n");
|
|
break;
|
|
case 3:
|
|
pduLog(logfile,"\tResult: INALID_PASSWORD\n");
|
|
break;
|
|
case 4:
|
|
pduLog(logfile,"\tResult: INVALID_CONVENER_PASSWORD\n");
|
|
break;
|
|
case 5:
|
|
pduLog(logfile,"\tResult: CHALLENGE_RESPONSE_REQUIRED\n");
|
|
break;
|
|
case 6:
|
|
pduLog(logfile,"\tResult: INVALID_CHALLENGE_RESPONSE\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tResult: >>>> Unkown Result <<<< \n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceJoinResponse(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceJoinResponse\n");
|
|
pduLog(logfile,"\tcjrs_node_id [%u]\n",
|
|
gcc_pdu->u.response.u.conference_join_response.cjrs_node_id);
|
|
pduLog(logfile,"\ttop_node_id [%u]\n",
|
|
gcc_pdu->u.response.u.conference_join_response.top_node_id);
|
|
PrintConferenceName(logfile,
|
|
gcc_pdu->u.response.u.conference_join_response.conference_name_alias);
|
|
PrintT120Boolean(logfile,"\tclear_password_required = ",
|
|
gcc_pdu->u.response.u.conference_join_response.clear_password_required);
|
|
PrintT120Boolean(logfile,"\tconference_is_locked = ",
|
|
gcc_pdu->u.response.u.conference_join_response.conference_is_locked);
|
|
PrintT120Boolean(logfile,"\tconference_is_listed = ",
|
|
gcc_pdu->u.response.u.conference_join_response.conference_is_listed);
|
|
PrintT120Boolean(logfile,"\tconference_is_conductible = ",
|
|
gcc_pdu->u.response.u.conference_join_response.conference_is_conductible);
|
|
|
|
switch(gcc_pdu->u.response.u.conference_join_response.termination_method)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tTermination Method: AUTOMATIC\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tTermination Method: MANUAL \n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tTermination Method: UNKOWN \n");
|
|
break;
|
|
}
|
|
|
|
switch(gcc_pdu->u.response.u.conference_join_response.result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tResult: RESULT_SUCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tResult: USER_REJECTED\n");
|
|
break;
|
|
case 2:
|
|
pduLog(logfile,"\tResult: INVALID_CONFERENCE\n");
|
|
break;
|
|
case 3:
|
|
pduLog(logfile,"\tResult: INALID_PASSWORD\n");
|
|
break;
|
|
case 4:
|
|
pduLog(logfile,"\tResult: INVALID_CONVENER_PASSWORD\n");
|
|
break;
|
|
case 5:
|
|
pduLog(logfile,"\tResult: CHALLENGE_RESPONSE_REQUIRED\n");
|
|
break;
|
|
case 6:
|
|
pduLog(logfile,"\tResult: INVALID_CHALLENGE_RESPONSE\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tResult: >>>> Unkown Result <<<< \n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceInviteRequest(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
char print_buffer[255] = " ";
|
|
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceInviteRequest\n");
|
|
pduLog(logfile,"\tConference Numeric Name: %s\n",
|
|
connect_pdu->u.conference_invite_request.conference_name.numeric);
|
|
CopySimpleTextToChar(print_buffer,
|
|
connect_pdu->u.conference_invite_request.conference_name.conference_name_text);
|
|
pduLog(logfile,"\tConference Text Name: %s\n",print_buffer);
|
|
pduLog(logfile,"\tnode_id [%u]\n",
|
|
connect_pdu->u.conference_invite_request.node_id);
|
|
pduLog(logfile,"\top_node_id [%u]\n",
|
|
connect_pdu->u.conference_invite_request.top_node_id);
|
|
PrintT120Boolean(logfile,"\tclear_password_required = ",
|
|
connect_pdu->u.conference_invite_request.clear_password_required);
|
|
PrintT120Boolean(logfile,"\tconference_is_locked = ",
|
|
connect_pdu->u.conference_invite_request.conference_is_locked);
|
|
PrintT120Boolean(logfile,"\tconference_is_conductible = ",
|
|
connect_pdu->u.conference_invite_request.conference_is_conductible);
|
|
|
|
switch(connect_pdu->u.conference_invite_request.termination_method)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tTermination Method: AUTOMATIC\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tTermination Method: MANUAL \n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tTermination Method: UNKOWN \n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceInviteResponse(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceInviteResponse\n");
|
|
|
|
switch(connect_pdu->u.conference_invite_response.result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tResult: RESULT_SUCCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tResult: USER_REJECTED\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\t>>>> Unkonw Result <<<<\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceAddRequest(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceAddRequest\n");
|
|
pduLog(logfile,"\tNot printing add_request_net_address -- todo later\n");
|
|
pduLog(logfile,"\trequesting_node = [%u]\n",gcc_pdu->u.request.u.conference_add_request.requesting_node);
|
|
pduLog(logfile,"\ttag = [%l]\n",gcc_pdu->u.request.u.conference_add_request.tag);
|
|
if(gcc_pdu->u.request.u.conference_add_request.bit_mask & 0x80) // adding mcu presnt
|
|
{
|
|
pduLog(logfile,"\tadding_mcu = [%u]\n",
|
|
gcc_pdu->u.request.u.conference_add_request.adding_mcu);
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogConferenceAddResponse(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceAddResponse\n");
|
|
pduLog(logfile,"\ttag = [%l]\n",gcc_pdu->u.response.u.conference_add_response.tag);
|
|
PrintConferenceAddResult(logfile,gcc_pdu->u.response.u.conference_add_response.result);
|
|
// user data is optional.
|
|
}
|
|
/*********************************************************************/
|
|
void pduLogGCCConnectInfo(FILE *logfile, PConnectGCCPDU connect_pdu)
|
|
{
|
|
switch(connect_pdu->choice)
|
|
{
|
|
case CONFERENCE_CREATE_REQUEST_CHOSEN:
|
|
{
|
|
pduLogConferenceCreateRequest(logfile,connect_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_CREATE_RESPONSE_CHOSEN:
|
|
{
|
|
pduLogConferenceCreateResponse(logfile, connect_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_QUERY_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceQueryRequest\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_QUERY_RESPONSE_CHOSEN:
|
|
{
|
|
pduLogQueryResponse(logfile,connect_pdu);
|
|
//pduLog(logfile,"PDU_TYPE: GCC_ConferenceQueryResponse\n");
|
|
}
|
|
break;
|
|
case CONNECT_JOIN_REQUEST_CHOSEN:
|
|
{
|
|
pduLogConnectJoinRequest(logfile,connect_pdu);
|
|
}
|
|
break;
|
|
case CONNECT_JOIN_RESPONSE_CHOSEN:
|
|
{
|
|
pduLogConnectJoinResponse(logfile,connect_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_INVITE_REQUEST_CHOSEN:
|
|
{
|
|
pduLogConferenceInviteRequest(logfile,connect_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_INVITE_RESPONSE_CHOSEN:
|
|
{
|
|
pduLogConferenceInviteResponse(logfile,connect_pdu);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: ERROR -- Cannot decode the ConnectGCCPDU\n");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void pduLogGCCInformation(FILE *logfile, PGCCPDU gcc_pdu)
|
|
{
|
|
switch(gcc_pdu->choice)
|
|
{
|
|
case INDICATION_CHOSEN:
|
|
{
|
|
switch(gcc_pdu->u.indication.choice)
|
|
{
|
|
case USER_ID_INDICATION_CHOSEN:
|
|
{
|
|
pduLogUserIDIndication(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case ROSTER_UPDATE_INDICATION_CHOSEN:
|
|
{
|
|
pduLogRosterUpdateIndication(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case TEXT_MESSAGE_INDICATION_CHOSEN:
|
|
{
|
|
pduLogTextMessageIndication(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_LOCK_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceLockIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_UNLOCK_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceUnlockIndication\n");
|
|
}
|
|
break;
|
|
case CONDUCTOR_RELEASE_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConductorRelaseIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_TERMINATE_INDICATION_CHOSEN:
|
|
{
|
|
pduLogConferenceTerminateIndication(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case CONDUCTOR_ASSIGN_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConductorAssignIndication\n");
|
|
pduLog(logfile," User ID: %d\n",
|
|
gcc_pdu->u.indication.u.conductor_assign_indication.user_id);
|
|
}
|
|
break;
|
|
case CONDUCTOR_PERMISSION_ASK_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConductorPermissionAskIndication\n");
|
|
pduLog(logfile," Permission Granted Flag: %d\n",
|
|
gcc_pdu->u.indication.u.conductor_permission_ask_indication.permission_is_granted);
|
|
}
|
|
break;
|
|
case CONDUCTOR_PERMISSION_GRANT_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConductorPermissionGrantIndication\n");
|
|
}
|
|
break;
|
|
case APPLICATION_INVOKE_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ApplicationInvokeIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_TRANSFER_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTransferIndication\n");
|
|
}
|
|
break;
|
|
case REGISTRY_MONITOR_ENTRY_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryMonitorEntryIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_TIME_REMAINING_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTimeRemainingIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_TIME_INQUIRE_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTimeInquireIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_TIME_EXTEND_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTimeExtendIndication\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_EJECT_USER_INDICATION_CHOSEN:
|
|
{
|
|
pduLogConferenceEjectUserIndication(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case NON_STANDARD_INDICATION_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_NonStandardPDU\n");
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: ERROR -- Cannot decode the Indication GCCPDU\n");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case RESPONSE_CHOSEN:
|
|
{
|
|
switch(gcc_pdu->u.response.choice)
|
|
{
|
|
case CONFERENCE_JOIN_RESPONSE_CHOSEN:
|
|
{
|
|
pduLogConferenceJoinResponse(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_ADD_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceAddResponse\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_LOCK_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceLockResponse\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_UNLOCK_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceUnlockResponse\n");
|
|
}
|
|
case CONFERENCE_TERMINATE_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTerminateResponse\n");
|
|
switch(gcc_pdu->u.response.u.conference_terminate_response.result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tResult: RESULT_SUCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tResult: INVALID_REQUESTOR\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tResult: >>> Unknown Result <<<\n");
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case CONFERENCE_EJECT_USER_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_EjectUserResponse\n");
|
|
pduLog(logfile,"\tnode_to_eject: [%u]\n",
|
|
gcc_pdu->u.response.u.conference_eject_user_response.node_to_eject);
|
|
switch(gcc_pdu->u.response.u.conference_eject_user_response.result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tResult: RESULT_SUCCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tResult: INVALID_REQUESTER\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tResult: >>> Unkown Result <<<\n");
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case CONFERENCE_TRANSFER_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTransferResponse\n");
|
|
}
|
|
break;
|
|
case REGISTRY_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryResponse\n");
|
|
}
|
|
break;
|
|
case REGISTRY_ALLOCATE_HANDLE_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryAllocateHandleResponse\n");
|
|
}
|
|
break;
|
|
case FUNCTION_NOT_SUPPORTED_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_FunctionNotSupported\n");
|
|
}
|
|
break;
|
|
case NON_STANDARD_RESPONSE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_NonStandardResponse\n");
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: ERROR -- Cannot decode Response GCC PDU\n");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case REQUEST_CHOSEN:
|
|
{
|
|
switch(gcc_pdu->u.request.choice)
|
|
{
|
|
case CONFERENCE_JOIN_REQUEST_CHOSEN:
|
|
{
|
|
pduLogConferenceJoinRequest(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_ADD_REQUEST_CHOSEN:
|
|
{
|
|
//pduLog(logfile,"PDU_TYPE: GCC_ConferenceAddRequest\n");
|
|
pduLogConferenceAddRequest(logfile,gcc_pdu);
|
|
}
|
|
break;
|
|
case CONFERENCE_LOCK_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceLockRequest\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_UNLOCK_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceUnlockRequest\n");
|
|
}
|
|
break;
|
|
case CONFERENCE_TERMINATE_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTerminateRequest\n");
|
|
switch(gcc_pdu->u.request.u.conference_terminate_request.reason)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"\tReason: USER_INITIATED\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"\tReason: CONFERENCE_TERMINATED\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tReason: >>> Unkown Reason <<<\n");
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case CONFERENCE_EJECT_USER_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_EjectUserRequest\n");
|
|
pduLog(logfile,"\tnode_to_eject: [%u]\n",
|
|
gcc_pdu->u.request.u.conference_eject_user_request.node_to_eject);
|
|
pduLog(logfile,"\tReason: USER_INITIATED\n");
|
|
// Note there is only one reason for a eject request
|
|
}
|
|
break;
|
|
case CONFERENCE_TRANSFER_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_ConferenceTransferRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_REGISTER_CHANNEL_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryRegisterChannelRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_ASSIGN_TOKEN_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_AssignTokenRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_SET_PARAMETER_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistrySetParameterRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_RETRIEVE_ENTRY_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryRetrieveEntryRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_DELETE_ENTRY_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryDeleteEntryRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_MONITOR_ENTRY_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryMonitorEntryRequest\n");
|
|
}
|
|
break;
|
|
case REGISTRY_ALLOCATE_HANDLE_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_RegistryAllocateHandleRequest\n");
|
|
}
|
|
break;
|
|
case NON_STANDARD_REQUEST_CHOSEN:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: GCC_NonStandardRequest\n");
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
pduLog(logfile,"PDU_TYPE: ERROR Cannot decode the Request GCC PDU\n");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
// write something, just so we know we got a PDU.
|
|
pduLog(logfile,"PDU_TYPE: ERROR -- Cannot decode unkown PDU");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// ********************************************************************************
|
|
/// PDU PRINTING FUNCTIONS
|
|
/// ********************************************************************************
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CopyCharToNumeric( GCCNumericString numeric_string,
|
|
Char * temp_buffer )
|
|
{
|
|
if( strcpy((Char *)numeric_string, (const Char *) temp_buffer ) == NULL )
|
|
return(FALSE);
|
|
else
|
|
return(TRUE);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CopyCharToText(LPWSTR text_string, Char *temp_buffer )
|
|
{
|
|
UShort length;
|
|
UShort i;
|
|
|
|
length = strlen( temp_buffer );
|
|
|
|
for(i=0;i < length;i++)
|
|
{
|
|
text_string[i] = (UShort) temp_buffer[i];
|
|
}
|
|
text_string[length] = 0x0000;
|
|
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CompareTextToNULL( LPWSTR unicode_string )
|
|
{
|
|
/*
|
|
* If the entry from GCCNODE.INI is the text string NULL, then we will
|
|
* pass NULL for this parameter. A LPWSTR is a UShort array.
|
|
*/
|
|
//TODO: resolve this and remove
|
|
if( unicode_string == 0x0000 )
|
|
return( FALSE );
|
|
if( ( unicode_string[0] == 0x004E ) &&
|
|
( unicode_string[1] == 0x0055 ) &&
|
|
( unicode_string[2] == 0x004C ) &&
|
|
( unicode_string[3] == 0x004C ) )
|
|
return( TRUE );
|
|
else
|
|
return( FALSE );
|
|
}
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CompareNumericToNULL( GCCNumericString numeric_string )
|
|
{
|
|
/*
|
|
* If the entry from GCCNODE.INI is the text string NULL, then we will
|
|
* pass NULL for this parameter. A GCCNumericString is an array of UChar.
|
|
*/
|
|
//TODO: resolve this and remove
|
|
if( numeric_string == NULL )
|
|
return( FALSE );
|
|
if( strcmp( (const Char *) numeric_string, "NULL" ) == 0 )
|
|
return( TRUE );
|
|
else
|
|
return( FALSE );
|
|
}
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CopySimpleTextToChar (Char * print_string,
|
|
SimpleTextString text_string)
|
|
{
|
|
UShort i;
|
|
UShort text_string_length;
|
|
LPWSTR text_string_value;
|
|
|
|
text_string_length = text_string.length;
|
|
text_string_value = text_string.value;
|
|
|
|
//TODO: clean the next few lines up -- its a temp workaround
|
|
// because databeam does not initialize the length field to 0
|
|
// when there is no string.
|
|
if(print_string==NULL)
|
|
return(FALSE);
|
|
|
|
if((text_string_length<=0)||(text_string_value == NULL))
|
|
return(FALSE);
|
|
|
|
if((*text_string_value == 0x0000))
|
|
return (FALSE);
|
|
|
|
for(i=0; i<text_string_length;i++)
|
|
{
|
|
if( ((text_string_value+i)==NULL) || (*(text_string_value+i) == 0x0000) )
|
|
break;
|
|
print_string[i] = (Char) text_string_value[i];
|
|
}
|
|
print_string[i] = 0;
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CopyTextToChar(Char * print_string,
|
|
TextString text_string)
|
|
{
|
|
UShort i;
|
|
UShort text_string_length;
|
|
LPWSTR text_string_value;
|
|
|
|
outdeb("TOP: CopyTextToChar\n");
|
|
if(print_string==NULL)
|
|
return(FALSE);
|
|
|
|
text_string_length = text_string.length;
|
|
text_string_value = text_string.value;
|
|
|
|
outdeb("CopyTextToChar: length and values copied\n");
|
|
|
|
if((text_string_length <= 0)||(text_string_value == NULL))
|
|
return( FALSE );
|
|
outdeb("length is not 0 && value is not NULL\n");
|
|
|
|
if (*text_string_value == 0x0000)
|
|
return (FALSE);
|
|
outdeb("content is not empty\n");
|
|
|
|
for(i=0;i < text_string_length;i++)
|
|
{
|
|
if( ((text_string_value+i)==NULL) || (*(text_string_value+i) == 0x0000))
|
|
break;
|
|
print_string[i] = (Char) text_string_value[i];
|
|
outdeb(print_string);
|
|
outdeb("..copied\n");
|
|
|
|
}
|
|
print_string[i] = 0;
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
T120Boolean CopyUnicodeToChar(Char *print_string, LPWSTR text_string)
|
|
{
|
|
UShort i;
|
|
UShort text_string_length;
|
|
|
|
if( text_string == NULL )
|
|
return( FALSE );
|
|
else
|
|
{
|
|
text_string_length = 0;
|
|
while(text_string[text_string_length] != 0x0000)
|
|
text_string_length++;
|
|
|
|
for(i=0;i < text_string_length;i++)
|
|
{
|
|
print_string[i] = (Char) text_string[i];
|
|
}
|
|
print_string[text_string_length] = 0;
|
|
}
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
** These functions print common sturcture entries.
|
|
*/
|
|
/*********************************************************************/
|
|
Void PrintPrivilegeList(
|
|
GCCConferencePrivileges FAR * privilege_list,
|
|
Char FAR * print_text,
|
|
FILE * logfile )
|
|
{
|
|
if( privilege_list->terminate_is_allowed )
|
|
pduLog( logfile,
|
|
"%sterminate_is_allowed = TRUE",
|
|
print_text);
|
|
else
|
|
pduLog( logfile,
|
|
"%sterminate_is_allowed = FALSE",
|
|
print_text);
|
|
|
|
if( privilege_list->eject_user_is_allowed )
|
|
pduLog( logfile,
|
|
"%seject_user_is_allowed = TRUE",
|
|
print_text);
|
|
else
|
|
pduLog( logfile,
|
|
"%seject_user_is_allowed = FALSE",
|
|
print_text);
|
|
|
|
if( privilege_list->add_is_allowed )
|
|
pduLog( logfile,
|
|
"%sadd_is_allowed = TRUE",
|
|
print_text);
|
|
else
|
|
pduLog( logfile,
|
|
"%sadd_is_allowed = FALSE",
|
|
print_text);
|
|
|
|
if( privilege_list->lock_unlock_is_allowed )
|
|
pduLog( logfile,
|
|
"%slock_unlock_is_allowed = TRUE",
|
|
print_text);
|
|
else
|
|
pduLog( logfile,
|
|
"%slock_unlock_is_allowed = FALSE",
|
|
print_text);
|
|
|
|
if( privilege_list->transfer_is_allowed )
|
|
pduLog( logfile,
|
|
"%stransfer_is_allowed = TRUE",
|
|
print_text);
|
|
else
|
|
pduLog( logfile,
|
|
"%stransfer_is_allowed = FALSE",
|
|
print_text);
|
|
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
Void PrintPasswordChallengeRequestResponse(FILE * logfile,
|
|
PasswordChallengeRequestResponse chrqrs_password)
|
|
{
|
|
switch(chrqrs_password.choice)
|
|
{
|
|
case CHALLENGE_CLEAR_PASSWORD_CHOSEN:
|
|
pduLog(logfile,"\tClear ");
|
|
PrintPasswordSelector(logfile,chrqrs_password.u.challenge_clear_password);
|
|
break;
|
|
case CHALLENGE_REQUEST_RESPONSE_CHOSEN:
|
|
pduLog(logfile,"\t Challenge Request Response Password not implemented\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\t Conference Password is NULL\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
Void PrintConferenceName(FILE * logfile,
|
|
ConferenceNameSelector conference_name )
|
|
{
|
|
Char print_buffer[255] = "";
|
|
|
|
switch(conference_name.choice)
|
|
{
|
|
case NAME_SELECTOR_NUMERIC_CHOSEN:
|
|
pduLog(logfile,
|
|
"\tNumeric Name Selector: [%s]\n",
|
|
conference_name.u.name_selector_numeric);
|
|
break;
|
|
case NAME_SELECTOR_TEXT_CHOSEN:
|
|
CopySimpleTextToChar(print_buffer,
|
|
conference_name.u.name_selector_text);
|
|
pduLog(logfile,
|
|
"\tText Name Selector: [%s]\n",
|
|
print_buffer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
Void PrintPasswordSelector(FILE *logfile, PasswordSelector password_selector)
|
|
{
|
|
Char print_buffer[255] = "";
|
|
|
|
switch(password_selector.choice)
|
|
{
|
|
case PASSWORD_SELECTOR_NUMERIC_CHOSEN:
|
|
pduLog(logfile,
|
|
"Numeric Password Selector: [%s]\n",
|
|
password_selector.u.password_selector_numeric);
|
|
break;
|
|
case PASSWORD_SELECTOR_TEXT_CHOSEN:
|
|
CopySimpleTextToChar(print_buffer,
|
|
password_selector.u.password_selector_text);
|
|
pduLog(logfile,
|
|
"Text Password Selector: [%s]\n",
|
|
print_buffer);
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\tPassword Selector: [none]\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
int PrintObjectID(FILE *logfile, ObjectID object_id)
|
|
{
|
|
if((object_id==NULL)||(logfile==NULL))
|
|
return FALSE;
|
|
|
|
pduLog(logfile,"\tObject ID = { ");
|
|
for(; object_id != NULL; object_id = object_id->next)
|
|
{
|
|
pduLog(logfile,"%ul ",object_id->value);
|
|
}
|
|
pduLog(logfile,"}\n");
|
|
return TRUE;
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintH221NonStandardIdentifier(FILE *logfile, H221NonStandardIdentifier h221_id)
|
|
{
|
|
char print_buffer[255];
|
|
strncpy(print_buffer,(char *)h221_id.value,h221_id.length);
|
|
pduLog(logfile,"\t\tH221_Non_Standard_Identifier = [%s]\n",print_buffer);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintKey(FILE *logfile, Key key)
|
|
{
|
|
switch(key.choice)
|
|
{
|
|
case OBJECT_CHOSEN:
|
|
PrintObjectID(logfile,key.u.object);
|
|
break;
|
|
case H221_NON_STANDARD_CHOSEN:
|
|
PrintH221NonStandardIdentifier(logfile,key.u.h221_non_standard);
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\t\t>>>> Cannot print Key\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintChannelType(FILE *logfile, ChannelType channel_type)
|
|
{
|
|
pduLog(logfile,"\t\tChannel Type = ");
|
|
switch(channel_type)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"CHANNEL_TYPE_STATIC\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"DYNAMIC_MULTICAST\n");
|
|
break;
|
|
case 2:
|
|
pduLog(logfile,"DYNAMIC_PRIVATE\n");
|
|
break;
|
|
case 3:
|
|
pduLog(logfile,"DYNAMIC_USERID\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"ERROR: cannot determinte channel type \n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintSessionKey(FILE *logfile, SessionKey session_key)
|
|
{
|
|
PrintKey(logfile, session_key.application_protocol_key);
|
|
if(session_key.bit_mask & 0x80)
|
|
pduLog(logfile,"\t\tsession_id = [%u]\n",session_key.session_id);
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintCapabilityID(FILE *logfile, CapabilityID capability_id)
|
|
{
|
|
switch(capability_id.choice)
|
|
{
|
|
case STANDARD_CHOSEN:
|
|
pduLog(logfile,"\t\tCapability ID: standard = [%u]\n",
|
|
capability_id.u.standard);
|
|
break;
|
|
case CAPABILITY_NON_STANDARD_CHOSEN:
|
|
pduLog(logfile,"\t\tNon Stnadard Capability Key:\n");
|
|
PrintKey(logfile,capability_id.u.capability_non_standard);
|
|
break;
|
|
default:
|
|
pduLog(logfile,"ERROR: cannot determine capability id\n");
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
Void PrintApplicationRecord(FILE *logfile, ApplicationRecord application_record)
|
|
{
|
|
unsigned int i=0;
|
|
char print_buffer[255];
|
|
|
|
PrintT120Boolean(logfile,
|
|
"\t\tapplication_is_active = ",
|
|
application_record.application_is_active);
|
|
PrintT120Boolean(logfile,
|
|
"\t\tis_conducting_capable = ",
|
|
application_record.is_conducting_capable);
|
|
if(application_record.bit_mask & RECORD_STARTUP_CHANNEL_PRESENT)
|
|
{
|
|
PrintChannelType(logfile, application_record.record_startup_channel);
|
|
}
|
|
if(application_record.bit_mask & APPLICATION_USER_ID_PRESENT)
|
|
{
|
|
pduLog(logfile,"\t\tapplication_user_id = [%u] \n",
|
|
application_record.application_user_id);
|
|
}
|
|
if(application_record.bit_mask & NON_COLLAPSING_CAPABILITIES_PRESENT)
|
|
{
|
|
for(i=0;application_record.non_collapsing_capabilities != NULL; i++)
|
|
{
|
|
pduLog(logfile,"\t**** non collapsing capabilities record [%u] ****\n",i);
|
|
PrintCapabilityID(logfile,application_record.non_collapsing_capabilities->value.capability_id);
|
|
if((application_record.non_collapsing_capabilities->value.bit_mask & APPLICATION_DATA_PRESENT) &&
|
|
(application_record.non_collapsing_capabilities->value.application_data.value != NULL))
|
|
{
|
|
pduLog(logfile,"\tApplication Data :\n");
|
|
pduRawOutput(logfile,application_record.non_collapsing_capabilities->value.application_data.value,
|
|
application_record.non_collapsing_capabilities->value.application_data.length);
|
|
strncpy(print_buffer, (char *) application_record.non_collapsing_capabilities->value.application_data.value,
|
|
application_record.non_collapsing_capabilities->value.application_data.length);
|
|
pduLog(logfile,"\tApplication Data (text): %s\n",print_buffer);
|
|
|
|
}
|
|
application_record.non_collapsing_capabilities =
|
|
application_record.non_collapsing_capabilities->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintCapabilityClass(FILE *logfile, CapabilityClass capability_class)
|
|
{
|
|
pduLog(logfile,"\t\tCapability Class: ");
|
|
switch(capability_class.choice)
|
|
{
|
|
case LOGICAL_CHOSEN:
|
|
pduLog(logfile,"Logical.\n");
|
|
break;
|
|
case UNSIGNED_MINIMUM_CHOSEN:
|
|
pduLog(logfile,"unsigned_minimum = [%u]\n",capability_class.u.unsigned_minimum);
|
|
break;
|
|
case UNSIGNED_MAXIMUM_CHOSEN:
|
|
pduLog(logfile,"unsigned_maximum = [%u]\n",capability_class.u.unsigned_maximum);
|
|
break;
|
|
default:
|
|
pduLog(logfile,"ERROR: unable to decode capability class\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
void PrintApplicationUpdate(FILE *logfile, ApplicationUpdate application_update)
|
|
{
|
|
pduLog(logfile,"*** Application Update ***\n");
|
|
|
|
switch(application_update.choice)
|
|
{
|
|
case APPLICATION_ADD_RECORD_CHOSEN:
|
|
pduLog(logfile,"Update Type = application_add_record\n");
|
|
PrintApplicationRecord(logfile, application_update.u.application_add_record);
|
|
break;
|
|
case APPLICATION_REPLACE_RECORD_CHOSEN:
|
|
pduLog(logfile,"Update Type = application_replace_record\n");
|
|
PrintApplicationRecord(logfile, application_update.u.application_replace_record);
|
|
break;
|
|
case APPLICATION_REMOVE_RECORD_CHOSEN:
|
|
pduLog(logfile,"Update Type = application_remove_record\n");
|
|
pduLog(logfile,"\tApplication is removed\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"ERROR: Cannot decode Application Update\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintApplicationRecordList(FILE *logfile, ApplicationRecordList application_record_list)
|
|
{
|
|
int i = 0;
|
|
switch(application_record_list.choice)
|
|
{
|
|
case APPLICATION_NO_CHANGE_CHOSEN:
|
|
pduLog(logfile,"No Change in Application Record List\n");
|
|
break;
|
|
case APPLICATION_RECORD_REFRESH_CHOSEN:
|
|
pduLog(logfile,"Application Record Refresh:\n");
|
|
for(i=0; application_record_list.u.application_record_refresh !=NULL; i++)
|
|
{
|
|
pduLog(logfile,"\t**** Application record refresh [%u] ***\n",i);
|
|
pduLog(logfile,"\t\tnode_id = [%u]\n",
|
|
application_record_list.u.application_record_refresh->value.node_id);
|
|
pduLog(logfile,"\t\tentity_id = [%u]\n",
|
|
application_record_list.u.application_record_refresh->value.entity_id);
|
|
PrintApplicationRecord(logfile,application_record_list.u.application_record_refresh->value.application_record);
|
|
|
|
application_record_list.u.application_record_refresh =
|
|
application_record_list.u.application_record_refresh->next;
|
|
}
|
|
break;
|
|
case APPLICATION_RECORD_UPDATE_CHOSEN:
|
|
pduLog(logfile,"Application Record Update:\n");
|
|
for(i=0; application_record_list.u.application_record_update !=NULL; i++)
|
|
{
|
|
pduLog(logfile,"\t**** Application record update [%u] ***\n",i);
|
|
pduLog(logfile,"\t\tnode_id = [%u]\n",
|
|
application_record_list.u.application_record_update->value.node_id);
|
|
pduLog(logfile,"\t\tentity_id = [%u]\n",
|
|
application_record_list.u.application_record_update->value.entity_id);
|
|
PrintApplicationUpdate(logfile,application_record_list.u.application_record_update->value.application_update);
|
|
|
|
application_record_list.u.application_record_refresh =
|
|
application_record_list.u.application_record_refresh->next;
|
|
}
|
|
break;
|
|
default:
|
|
pduLog(logfile,"ERROR: Application Record List could not be decoded\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintApplicationCapabilitiesList(FILE *logfile, ApplicationCapabilitiesList application_capabilities_list)
|
|
{
|
|
unsigned int i = 0;
|
|
|
|
pduLog(logfile,"Application Capabilities List\n");
|
|
switch(application_capabilities_list.choice)
|
|
{
|
|
case CAPABILITY_NO_CHANGE_CHOSEN:
|
|
pduLog(logfile,"\tNo change in capabilities\n");
|
|
break;
|
|
case APPLICATION_CAPABILITY_REFRESH_CHOSEN:
|
|
pduLog(logfile,"\tCapability Refreshes:\n");
|
|
for(i=0; application_capabilities_list.u.application_capability_refresh != NULL; i++)
|
|
{
|
|
pduLog(logfile,"\t**** capability refresh [%u] ****\n",i);
|
|
PrintCapabilityID(logfile,application_capabilities_list.u.application_capability_refresh->value.capability_id);
|
|
PrintCapabilityClass(logfile,application_capabilities_list.u.application_capability_refresh->value.capability_class);
|
|
pduLog(logfile,"\t\tnumber_of_entities = [%u]\n",
|
|
application_capabilities_list.u.application_capability_refresh->value.number_of_entities);
|
|
|
|
application_capabilities_list.u.application_capability_refresh =
|
|
application_capabilities_list.u.application_capability_refresh->next;
|
|
}
|
|
break;
|
|
default:
|
|
pduLog(logfile,"ERROR: Cannot decode capabilities list\n");
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
void PrintConferenceAddResult(FILE *logfile, ConferenceAddResult result)
|
|
{
|
|
pduLog(logfile,"\tResult = ");
|
|
switch(result)
|
|
{
|
|
case 0:
|
|
pduLog(logfile,"SUCCESS\n");
|
|
break;
|
|
case 1:
|
|
pduLog(logfile,"INVALID_REQUESTER\n");
|
|
break;
|
|
case 2:
|
|
pduLog(logfile,"INVALID_NETWORK_ADDRESS\n");
|
|
break;
|
|
case 3:
|
|
pduLog(logfile,"ADDED_NODE_BUSY\n");
|
|
break;
|
|
case 4:
|
|
pduLog(logfile,"NETWORK_BUSY\n");
|
|
break;
|
|
case 5:
|
|
pduLog(logfile,"NO_PORTS_AVAILABLE\n");
|
|
break;
|
|
case 6:
|
|
pduLog(logfile,"CONNECTION_UNSUCCESSFUL\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,">>> undecodable result <<<\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
Void PrintConferenceRoster(FILE *logfile, NodeInformation node_information)
|
|
{
|
|
UShort i;
|
|
NodeRecordList node_record_list;
|
|
Char print_buffer[255] = "";
|
|
|
|
outdeb("TOP: PrintConferenceRoster\n");
|
|
|
|
pduLog(logfile,
|
|
"\tinstance_number [%u]\n",
|
|
node_information.roster_instance_number );
|
|
|
|
PrintT120Boolean(logfile,
|
|
"\tnodes_are_added",
|
|
node_information.nodes_are_added);
|
|
|
|
PrintT120Boolean(logfile,
|
|
"\tnodes_are_removed",
|
|
node_information.nodes_are_removed );
|
|
|
|
/*
|
|
* Extract the node_information_list pointer from the
|
|
* conf_roster structure.
|
|
*/
|
|
node_record_list = node_information.node_record_list;
|
|
|
|
switch (node_record_list.choice)
|
|
{
|
|
case NODE_NO_CHANGE_CHOSEN:
|
|
{
|
|
pduLog(logfile,"\tConference Roster: No Change\n");
|
|
}
|
|
break;
|
|
case NODE_RECORD_REFRESH_CHOSEN:
|
|
{
|
|
outdeb("Node record refresh chosen \n");
|
|
for(i=0; node_record_list.u.node_record_refresh != NULL; i++)
|
|
{
|
|
pduLog( logfile,"\tConference Refresh Record [%u]************************\n", i );
|
|
pduLog( logfile,
|
|
"\t\tnode_id [%u]\n",
|
|
node_record_list.u.node_record_refresh->value.node_id );
|
|
pduLog( logfile,
|
|
"\t\tsuperior_node_id [%u]\n",
|
|
node_record_list.u.node_record_refresh->value.node_record.superior_node);
|
|
|
|
/* figure out the node type */
|
|
switch( node_record_list.u.node_record_refresh->value.node_record.node_type)
|
|
{
|
|
case GCC_TERMINAL:
|
|
pduLog( logfile, "\t\tnode_type = GCC_TERMINAL\n");
|
|
break;
|
|
case GCC_MULTIPORT_TERMINAL:
|
|
pduLog( logfile,
|
|
"\t\tnode_type = GCC_MULTIPORT_TERMINAL\n");
|
|
break;
|
|
case GCC_MCU:
|
|
pduLog( logfile, "\t\tnode_type = GCC_MCU\n");
|
|
break;
|
|
default:
|
|
pduLog( logfile,
|
|
"\t\tGCCNODE: ERROR: UNKNOWN NODE TYPE\n");
|
|
break;
|
|
}
|
|
|
|
pduLog(logfile,"\t\tdevice_is_manager: [%u]\n",
|
|
node_record_list.u.node_record_refresh->value.node_record.node_properties.device_is_manager);
|
|
|
|
pduLog(logfile,"\t\tdevice_is_peripheral: [%u] \n",
|
|
node_record_list.u.node_record_refresh->value.node_record.node_properties.device_is_peripheral);
|
|
|
|
/* print the node_name field */
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_refresh->value.node_record.node_name))
|
|
pduLog( logfile, "\t\tnode_name is [%s]\n", print_buffer );
|
|
else
|
|
pduLog( logfile, "\t\tnode_name is NULL\n");
|
|
|
|
print_buffer[0] = 0;
|
|
|
|
/* print the participants_list fields */
|
|
if((node_record_list.u.node_record_refresh->value.node_record.participants_list != NULL)
|
|
&& (node_record_list.u.node_record_refresh->value.node_record.bit_mask & 0x20))
|
|
{
|
|
for(i=0;node_record_list.u.node_record_refresh->value.node_record.participants_list->next!=NULL;i++)
|
|
{
|
|
if(CopyTextToChar(print_buffer,node_record_list.u.node_record_refresh->value.node_record.participants_list->value))
|
|
pduLog(logfile, "\t\tparticipant %u is: [%s]\n", print_buffer);
|
|
else
|
|
pduLog(logfile, "\t\tparticipant_list record is NULL\n");
|
|
|
|
node_record_list.u.node_record_refresh->value.node_record.participants_list =
|
|
node_record_list.u.node_record_refresh->value.node_record.participants_list->next;
|
|
}
|
|
}
|
|
|
|
|
|
/* print the site_information field */
|
|
outdeb("printing site information\n");
|
|
if(node_record_list.u.node_record_refresh->value.node_record.bit_mask & 0x10)
|
|
{
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_refresh->value.node_record.site_information))
|
|
pduLog( logfile,
|
|
"\t\tsite_information is [%s]\n",
|
|
print_buffer );
|
|
else
|
|
pduLog( logfile, "\t\tsite_information is NULL\n");
|
|
}
|
|
|
|
node_record_list.u.node_record_refresh =
|
|
node_record_list.u.node_record_refresh->next;
|
|
} // end of for loop
|
|
}
|
|
break;
|
|
case NODE_RECORD_UPDATE_CHOSEN:
|
|
{
|
|
outdeb("Node Record Update Chosen\n");
|
|
for(i=0;node_record_list.u.node_record_update!=NULL;i++)
|
|
{
|
|
pduLog(logfile,"\t**********Conference Update Record [%u] **********\n",i);
|
|
pduLog(logfile,"\t\tnode_id [%u]\n",
|
|
node_record_list.u.node_record_update->value.node_id);
|
|
switch(node_record_list.u.node_record_update->value.node_update.choice)
|
|
{
|
|
case NODE_ADD_RECORD_CHOSEN:
|
|
outdeb("Node Add Record Chosen\n");
|
|
pduLog(logfile,"\t\t*** Node is Added ***\n");
|
|
pduLog(logfile,
|
|
"\t\tsuperior_node_id [%u]\n",
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.superior_node);
|
|
|
|
switch( node_record_list.u.node_record_update->value.node_update.u.node_add_record.node_type)
|
|
{
|
|
case GCC_TERMINAL:
|
|
pduLog( logfile, "\t\tnode_type = GCC_TERMINAL\n");
|
|
break;
|
|
case GCC_MULTIPORT_TERMINAL:
|
|
pduLog(logfile,"\t\tnode_type = GCC_MULTIPORT_TERMINAL\n");
|
|
break;
|
|
case GCC_MCU:
|
|
pduLog(logfile, "\t\tnode_type = GCC_MCU\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\t\tGCCNODE: ERROR: UNKNOWN NODE TYPE\n");
|
|
break;
|
|
}
|
|
|
|
pduLog(logfile,"\t\tdevice_is_manager: [%u]\n",
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.node_properties.device_is_manager);
|
|
|
|
pduLog(logfile,"\t\tdevice_is_peripheral: [%u] \n",
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.node_properties.device_is_peripheral);
|
|
|
|
|
|
/* print the node_name */
|
|
outdeb("Printing node name\n");
|
|
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.node_name))
|
|
pduLog( logfile, "\t\tnode_name is [%s]\n", print_buffer );
|
|
else
|
|
pduLog( logfile, "\t\tnode_name is NULL\n");
|
|
|
|
/* print the participants_list fields */
|
|
outdeb("Printing participants list fields\n");
|
|
if((node_record_list.u.node_record_update->value.node_update.u.node_add_record.participants_list != NULL)
|
|
&& (node_record_list.u.node_record_update->value.node_update.u.node_add_record.bit_mask & 0x20))
|
|
{
|
|
outdeb("participants list is not NULL\n");
|
|
for(i=0;node_record_list.u.node_record_update->value.node_update.u.node_add_record.participants_list->next!=NULL;i++)
|
|
{
|
|
outdeb("participants_list->next is not NULL\n");
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.participants_list->value))
|
|
pduLog(logfile, "\t\tparticipant %u is: [%s]\n", print_buffer);
|
|
else
|
|
pduLog(logfile, "\t\tparticipant_list record is NULL\n");
|
|
|
|
outdeb("incrementing participant list node\n");
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.participants_list =
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.participants_list->next;
|
|
}
|
|
}
|
|
|
|
/* print the site information */
|
|
outdeb("printing site information\n");
|
|
if(node_record_list.u.node_record_update->value.node_update.u.node_add_record.bit_mask & 0x10)
|
|
{
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_update->value.node_update.u.node_add_record.site_information))
|
|
pduLog(logfile,"\t\tsite_information is [%s]\n",print_buffer );
|
|
else
|
|
pduLog( logfile, "\t\tsite_information is NULL\n");
|
|
}
|
|
break;
|
|
|
|
case NODE_REPLACE_RECORD_CHOSEN:
|
|
outdeb("Node Replace Record Chosen\n");
|
|
|
|
pduLog(logfile,"\t\t*** Node is Replaced ***\n");
|
|
pduLog(logfile,
|
|
"\t\tsuperior_node_id [%u]\n",
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.superior_node);
|
|
|
|
switch( node_record_list.u.node_record_update->value.node_update.u.node_replace_record.node_type)
|
|
{
|
|
case GCC_TERMINAL:
|
|
pduLog( logfile, "\t\tnode_type = GCC_TERMINAL\n");
|
|
break;
|
|
case GCC_MULTIPORT_TERMINAL:
|
|
pduLog(logfile,"\t\tnode_type = GCC_MULTIPORT_TERMINAL\n");
|
|
break;
|
|
case GCC_MCU:
|
|
pduLog(logfile, "\t\tnode_type = GCC_MCU\n");
|
|
break;
|
|
default:
|
|
pduLog(logfile,"\t\tGCCNODE: ERROR: UNKNOWN NODE TYPE\n");
|
|
break;
|
|
}
|
|
|
|
pduLog(logfile,"\t\tdevice_is_manager: [%u]\n",
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.node_properties.device_is_manager);
|
|
|
|
pduLog(logfile,"\t\tdevice_is_peripheral: [%u] \n",
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.node_properties.device_is_peripheral);
|
|
|
|
/* print the node name */
|
|
outdeb("printing node name\n");
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.node_name))
|
|
pduLog( logfile, "\t\tnode_name is [%s]\n", print_buffer );
|
|
else
|
|
pduLog( logfile, "\t\tnode_name is NULL\n");
|
|
print_buffer[0] = 0;
|
|
|
|
/* print the participant list */
|
|
outdeb("printing participants list info\n");
|
|
|
|
if((node_record_list.u.node_record_update->value.node_update.u.node_replace_record.participants_list != NULL)
|
|
&& (node_record_list.u.node_record_update->value.node_update.u.node_replace_record.bit_mask & 0x20))
|
|
{
|
|
for(i=0;node_record_list.u.node_record_update->value.node_update.u.node_replace_record.participants_list->next!=NULL;i++)
|
|
{
|
|
if(CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.participants_list->value))
|
|
pduLog(logfile, "\t\tparticipant %u is: [%s]\n", print_buffer);
|
|
else
|
|
pduLog(logfile, "\t\tparticipant_list record is NULL\n");
|
|
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.participants_list =
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.participants_list->next;
|
|
}
|
|
}
|
|
|
|
print_buffer[0] = 0;
|
|
/* print the site information */
|
|
outdeb("printing site information\n");
|
|
if(node_record_list.u.node_record_update->value.node_update.u.node_replace_record.bit_mask & 0x10)
|
|
{
|
|
if( CopyTextToChar(print_buffer,
|
|
node_record_list.u.node_record_update->value.node_update.u.node_replace_record.site_information))
|
|
pduLog(logfile,"\t\tsite_information is [%s]\n",print_buffer );
|
|
else
|
|
pduLog( logfile, "\t\tsite_information is NULL\n");
|
|
}
|
|
break;
|
|
|
|
case NODE_REMOVE_RECORD_CHOSEN:
|
|
outdeb("Node remove record chosen\n");
|
|
pduLog(logfile,"\t\t*** UPDATE: Node is REMOVED ***\n");
|
|
break;
|
|
|
|
default:
|
|
pduLog(logfile,"\t\t>>>>ERROR: UNKNOWN UPDATE ACTION\n");
|
|
break;
|
|
|
|
}
|
|
node_record_list.u.node_record_update =
|
|
node_record_list.u.node_record_update->next;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
pduLog(logfile,">>>> Unknown Roster Update Type\n");
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/****************************************************************/
|
|
void PrintApplicationRoster(FILE *logfile, SetOfApplicationInformation *application_information)
|
|
{
|
|
int i = 0;
|
|
|
|
pduLog(logfile,"Application Information: \n");
|
|
|
|
for(i=0; application_information != NULL; i++)
|
|
{
|
|
pduLog(logfile,"\t*** application information record [%u] ***\n",i);
|
|
PrintSessionKey(logfile,application_information->value.session_key);
|
|
PrintApplicationRecordList(logfile,application_information->value.application_record_list);
|
|
PrintApplicationCapabilitiesList(logfile,application_information->value.application_capabilities_list);
|
|
pduLog(logfile,"\t\troster_instance_number = %u\n",application_information->value.roster_instance_number);
|
|
PrintT120Boolean(logfile,"\t\tpeer_entities_are_added",application_information->value.peer_entities_are_added);
|
|
PrintT120Boolean(logfile,"\t\tpeer_entities_are_removed",application_information->value.peer_entities_are_removed);
|
|
|
|
application_information = application_information->next;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/****************************************************************/
|
|
void PrintT120Boolean(FILE * logfile,
|
|
Char * print_text,
|
|
T120Boolean T120Boolean)
|
|
{
|
|
if( T120Boolean == FALSE )
|
|
pduLog( logfile, "%s = FALSE\n", print_text );
|
|
else
|
|
pduLog( logfile, "%s = TRUE\n", print_text );
|
|
}
|
|
|
|
|
|
|
|
#endif /// PDULOG
|
|
|
|
|
|
|
|
|
|
|