bool MapFile::LoadSegment(char *Line)
{
// ID:BASE LENGTH NAME CLASS
char tokens[8][256];
memset(tokens, 0, sizeof(tokens));
// Skip spaces and make a copy
while (*Line == ' ' || *Line == '\t')
Line++;
char buf[256];
strncpy_s(buf, Line, 255);
// Parse each token
char *bufPtr = buf;
int tokenIndex = 0;
for (int i = 0; i < ARRAYSIZE(tokens); i++)
{
bufPtr = GrabToken(tokens[i], bufPtr);
if (!bufPtr)
break;
}
MapFileSegment segdef;
strcpy_s(segdef.Name, tokens[3]);
strcpy_s(segdef.Class, tokens[4]);
if (sscanf_s(tokens[0], "%x", &segdef.Id) <= 0)
return false;
if (sscanf_s(tokens[1], "%llx", &segdef.Start) <= 0)
return false;
if (sscanf_s(tokens[2], "%llxH", &segdef.Length) <= 0)
return false;
m_Segments.push_back(segdef);
return true;
}
bool MapFile::LoadSymbol(char *Line)
{
// ID:OFFSET NAME
char tokens[5][256];
memset(tokens, 0, sizeof(tokens));
// Skip spaces and make a copy
while (*Line == ' ' || *Line == '\t')
Line++;
char buf[256];
strncpy_s(buf, Line, 255);
// Parse each token
char *bufPtr = buf;
int tokenIndex = 0;
for (int i = 0; i < ARRAYSIZE(tokens); i++)
{
bufPtr = GrabToken(tokens[i], bufPtr);
if (!bufPtr)
break;
}
MapFileSymbol symdef;
strcpy_s(symdef.Name, tokens[2]);
if (sscanf_s(tokens[0], "%x", &symdef.Id) <= 0)
return false;
if (sscanf_s(tokens[1], "%llx", &symdef.Offset) <= 0)
return false;
m_Symbols.push_back(symdef);
return true;
}
bool XMLLexer::
PeekToken(Token *token)
{
bool have_token;
if (token_is_valid) {
have_token = true;
} else {
have_token = GrabToken();
}
if (have_token) {
if (token != NULL) {
*token = current_token;
}
token_is_valid = true;
/*
printf("Peeking token: ");
current_token.DumpToken();
*/
}
return have_token;
}
bool TrySip200Ok(EthernetHeaderStruct* ethernetHeader, IpHeaderStruct* ipHeader, UdpHeaderStruct* udpHeader, u_char* udpPayload, u_char* packetEnd)
{
bool result = false;
if(DLLCONFIG.m_sipTreat200OkAsInvite == true)
{
return false;
}
int sipLength = ntohs(udpHeader->len) - sizeof(UdpHeaderStruct);
char* sipEnd = (char*)udpPayload + sipLength;
if(sipLength < SIP_RESPONSE_200_OK_SIZE || sipEnd > (char*)packetEnd)
{
; // packet too short
}
else if (memcmp(SIP_RESPONSE_200_OK, (void*)udpPayload, SIP_RESPONSE_200_OK_SIZE) == 0)
{
result = true;
Sip200OkInfoRef info(new Sip200OkInfo());
char* fromField = memFindAfter("From:", (char*)udpPayload, sipEnd);
if(!fromField)
{
fromField = memFindAfter("\nf:", (char*)udpPayload, sipEnd);
}
char* toField = memFindAfter("To:", (char*)udpPayload, sipEnd);
if(!toField)
{
toField = memFindAfter("\nt:", (char*)udpPayload, sipEnd);
}
char* callIdField = memFindAfter("Call-ID:", (char*)udpPayload, sipEnd);
if(!callIdField)
{
callIdField = memFindAfter("\ni:", (char*)udpPayload, sipEnd);
}
char* audioField = NULL;
char* connectionAddressField = NULL;
if(callIdField)
{
GrabTokenSkipLeadingWhitespaces(callIdField, sipEnd, info->m_callId);
audioField = memFindAfter("m=audio ", callIdField, sipEnd);
connectionAddressField = memFindAfter("c=IN IP4 ", callIdField, sipEnd);
}
if(audioField && connectionAddressField)
{
info->m_hasSdp = true;
GrabToken(audioField, sipEnd, info->m_mediaPort);
CStdString connectionAddress;
GrabToken(connectionAddressField, sipEnd, connectionAddress);
struct in_addr mediaIp;
if(connectionAddress.size())
{
if(ACE_OS::inet_aton((PCSTR)connectionAddress, &mediaIp))
{
info->m_mediaIp = mediaIp;
}
}
}
if(fromField)
{
if(s_sipExtractionLog->isDebugEnabled())
{
CStdString from;
GrabLine(fromField, sipEnd, from);
LOG4CXX_DEBUG(s_sipExtractionLog, "from: " + from);
}
char* fromFieldEnd = memFindEOL(fromField, sipEnd);
char* sipUser = memFindAfter("sip:", fromField, fromFieldEnd);
if(sipUser)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUser, fromFieldEnd, info->m_from);
}
else
{
GrabSipUriUser(sipUser, fromFieldEnd, info->m_from);
}
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(fromField, fromFieldEnd, info->m_from);
}
else
{
GrabSipUriUser(fromField, fromFieldEnd, info->m_from);
}
}
}
if(toField)
{
CStdString to;
char* toFieldEnd = GrabLine(toField, sipEnd, to);
LOG4CXX_DEBUG(s_sipExtractionLog, "to: " + to);
char* sipUser = memFindAfter("sip:", toField, toFieldEnd);
if(sipUser)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUser, toFieldEnd, info->m_to);
}
else
{
GrabSipUriUser(sipUser, toFieldEnd, info->m_to);
}
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(toField, toFieldEnd, info->m_to);
}
else
{
GrabSipUriUser(toField, toFieldEnd, info->m_to);
}
}
}
info->m_senderIp = ipHeader->ip_src;
info->m_receiverIp = ipHeader->ip_dest;
CStdString logMsg;
info->ToString(logMsg);
logMsg = "200 OK: " + logMsg;
if(info->m_hasSdp)
{
LOG4CXX_INFO(s_sipPacketLog, logMsg);
}
else
{
LOG4CXX_DEBUG(s_sipPacketLog, logMsg);
}
VoIpSessionsSingleton::instance()->ReportSip200Ok(info);
}
return result;
}
bool TrySipInvite(EthernetHeaderStruct* ethernetHeader, IpHeaderStruct* ipHeader, UdpHeaderStruct* udpHeader, u_char* udpPayload, u_char* packetEnd)
{
CStdString logMsg;
bool result = false;
bool drop = false;
CStdString sipMethod;
int sipLength = ntohs(udpHeader->len) - sizeof(UdpHeaderStruct);
char* sipEnd = (char*)udpPayload + sipLength;
if (DLLCONFIG.m_ipFragmentsReassemble == false && sipEnd > (char*)packetEnd && ipHeader->offset() == 0) {
FLOG_DEBUG(s_sipExtractionLog, "Will try to process incomplete first fragment with id:%u",ipHeader->packetId());
sipEnd = (char*)packetEnd;
}
if(sipLength < 3 || sipEnd > (char*)packetEnd)
{
drop = true; // packet too short
}
else if(memcmp(SIP_METHOD_INVITE, (void*)udpPayload, SIP_METHOD_INVITE_SIZE) == 0)
{
sipMethod = SIP_METHOD_INVITE;
}
else if(memcmp(SIP_METHOD_ACK, (void*)udpPayload, SIP_METHOD_ACK_SIZE) == 0)
{
sipMethod = SIP_METHOD_ACK;
}
else if((DLLCONFIG.m_sipTreat200OkAsInvite == true) && (memcmp(SIP_RESPONSE_200_OK, (void*)udpPayload, SIP_RESPONSE_200_OK_SIZE) == 0))
{
sipMethod = SIP_METHOD_200_OK;
LOG4CXX_DEBUG(s_sipExtractionLog, "TrySipInvite: packet matches 200 OK and SipTreat200OkAsInvite is enabled");
}
else if((DLLCONFIG.m_sipDetectSessionProgress == true) && (memcmp(SIP_RESPONSE_SESSION_PROGRESS, (void*)udpPayload, SIP_RESPONSE_SESSION_PROGRESS_SIZE) == 0))
{
sipMethod = SIP_RESPONSE_SESSION_PROGRESS;
}
else
{
drop = true;
}
if (drop == false)
{
result = true;
SipInviteInfoRef info(new SipInviteInfo());
info->m_sipMethod = sipMethod;
char* fromField = memFindAfter("From:", (char*)udpPayload, sipEnd);
if(!fromField)
{
fromField = memFindAfter("\nf:", (char*)udpPayload, sipEnd);
}
char* toField = memFindAfter("To:", (char*)udpPayload, sipEnd);
if(!toField)
{
toField = memFindAfter("\nt:", (char*)udpPayload, sipEnd);
}
char* callIdField = memFindAfter("Call-ID:", (char*)udpPayload, sipEnd);
if(!callIdField)
{
callIdField = memFindAfter("\ni:", (char*)udpPayload, sipEnd);
}
char* replacesField = memFindAfter("Replaces:", (char*)udpPayload, sipEnd);
if(!replacesField)
{
replacesField = memFindAfter("\nr:", (char*)udpPayload, sipEnd);
}
char * dialedNumber = NULL;
if(!(DLLCONFIG.m_sipDialedNumberFieldName.length()==0) )
{
dialedNumber = memFindAfter(DLLCONFIG.m_sipDialedNumberFieldName + ":", (char*)udpPayload,sipEnd);
}
char * sipRemoteParty = NULL;
if(!(DLLCONFIG.m_sipRemotePartyFieldName.length()==0) )
{
sipRemoteParty = memFindAfter(DLLCONFIG.m_sipRemotePartyFieldName + ":", (char*)udpPayload,sipEnd);
}
char* contactField = memFindAfter("Contact:", (char*)udpPayload, sipEnd);
if(!contactField)
{
contactField = memFindAfter("\nc:", (char*)udpPayload, sipEnd);
}
char * audioSdpStart = (char*) udpPayload;;
char * audioSdpEnd = (char*) sipEnd;;
char* audioStart = memFindAfter("m=audio", (char*)udpPayload, sipEnd);
char* videoStart = memFindAfter("m=video", (char*)udpPayload, sipEnd);
if (audioStart < videoStart) {
audioSdpEnd = videoStart;
}
if (audioStart > videoStart) {
audioSdpStart = audioStart;
}
char* localExtensionField = memFindAfter(DLLCONFIG.m_sipLocalPartyFieldName, (char*)udpPayload, sipEnd);
char* audioField = NULL;
char* connectionAddressField = NULL;
char* attribSendonly = memFindAfter("a=sendonly", (char*)audioSdpStart, audioSdpEnd);
char* attribInactive = memFindAfter("a=inactive", (char*)audioSdpStart, audioSdpEnd);
char* rtpmapAttribute = memFindAfter("\na=rtpmap:", (char*)audioSdpStart, audioSdpEnd);
char* userAgentField = memFindAfter("\nUser-Agent:", (char*)udpPayload, sipEnd);
if(DLLCONFIG.m_sipRequestUriAsLocalParty == true)
{
char* sipUriAttribute = memFindAfter("INVITE ", (char*)udpPayload, sipEnd);
if(sipUriAttribute)
{
if(s_sipExtractionLog->isDebugEnabled())
{
CStdString uri;
GrabLine(sipUriAttribute, sipEnd, uri);
LOG4CXX_DEBUG(s_sipExtractionLog, "uri: " + uri);
}
char* sipUriAttributeEnd = memFindEOL(sipUriAttribute, sipEnd);
char* sipUser = memFindAfter("sip:", sipUriAttribute, sipUriAttributeEnd);
if(sipUser)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUser, sipUriAttributeEnd, info->m_requestUri);
}
else
{
GrabSipUriUser(sipUser, sipUriAttributeEnd, info->m_requestUri);
}
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUriAttribute, sipUriAttributeEnd, info->m_requestUri);
}
else
{
GrabSipUriUser(sipUriAttribute, sipUriAttributeEnd, info->m_requestUri);
}
}
if(s_sipExtractionLog->isDebugEnabled())
{
LOG4CXX_DEBUG(s_sipExtractionLog, "extracted uri: " + info->m_requestUri);
}
}
}
if(fromField)
{
if(s_sipExtractionLog->isDebugEnabled())
{
CStdString from;
GrabLine(fromField, sipEnd, from);
LOG4CXX_DEBUG(s_sipExtractionLog, "from: " + from);
}
char* fromFieldEnd = memFindEOL(fromField, sipEnd);
GrabSipName(fromField, fromFieldEnd, info->m_fromName);
char* sipUser = memFindAfter("sip:", fromField, fromFieldEnd);
if(sipUser)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUser, fromFieldEnd, info->m_from);
}
else
{
GrabSipUriUser(sipUser, fromFieldEnd, info->m_from);
}
GrabSipUriDomain(sipUser, fromFieldEnd, info->m_fromDomain);
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(fromField, fromFieldEnd, info->m_from);
}
else
{
GrabSipUriUser(fromField, fromFieldEnd, info->m_from);
}
GrabSipUriDomain(fromField, fromFieldEnd, info->m_fromDomain);
}
}
if(toField)
{
CStdString to;
char* toFieldEnd = GrabLine(toField, sipEnd, to);
LOG4CXX_DEBUG(s_sipExtractionLog, "to: " + to);
GrabSipName(toField, toFieldEnd, info->m_toName);
char* sipUser = memFindAfter("sip:", toField, toFieldEnd);
if(sipUser)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUser, toFieldEnd, info->m_to);
}
else
{
GrabSipUriUser(sipUser, toFieldEnd, info->m_to);
}
GrabSipUriDomain(sipUser, toFieldEnd, info->m_toDomain);
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(toField, toFieldEnd, info->m_to);
}
else
{
GrabSipUriUser(toField, toFieldEnd, info->m_to);
}
GrabSipUriDomain(toField, toFieldEnd, info->m_toDomain);
}
if(DLLCONFIG.m_sipGroupPickUpPattern == info->m_to)
{
info->m_SipGroupPickUpPatternDetected = true;
}
}
if(dialedNumber)
{
CStdString token;
GrabTokenSkipLeadingWhitespaces(dialedNumber, sipEnd, token);
info->m_sipDialedNumber = token;
}
if(sipRemoteParty)
{
CStdString token;
char* sip = memFindAfter("sip:", sipRemoteParty, sipEnd);
if(sip)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sip, sipEnd, token);
}
else
{
GrabSipUriUser(sip, sipEnd, token);
}
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipRemoteParty, sipEnd, token);
}
else
{
GrabSipUriUser(sipRemoteParty, sipEnd, token);
}
}
info->m_sipRemoteParty = token;
}
if(callIdField)
{
GrabTokenSkipLeadingWhitespaces(callIdField, sipEnd, info->m_callId);
audioField = memFindAfter("m=audio ", callIdField, sipEnd);
connectionAddressField = memFindAfter("c=IN IP4 ", callIdField, sipEnd);
}
if(replacesField)
{
CStdString fieldContent;
GrabTokenSkipLeadingWhitespaces(replacesField, sipEnd, fieldContent);
int firstsemicoma;
firstsemicoma = fieldContent.Find(';');
if(firstsemicoma != -1)
{
info->m_replacesId = fieldContent.substr(0, firstsemicoma);
}
LOG4CXX_DEBUG(s_sipExtractionLog, "replaces CallId:" + info->m_replacesId);
}
if(localExtensionField)
{
CStdString localExtension;
GrabTokenSkipLeadingWhitespaces(localExtensionField, sipEnd, localExtension);
if(localExtension.size() > 0)
{
info->m_from = localExtension;
}
}
if(userAgentField)
{
GrabTokenSkipLeadingWhitespaces(userAgentField, sipEnd, info->m_userAgent);
}
if(audioField)
{
GrabToken(audioField, sipEnd, info->m_fromRtpPort);
}
if(attribSendonly || attribInactive)
{
info->m_attrSendonly = true;
}
if(connectionAddressField)
{
CStdString connectionAddress;
GrabToken(connectionAddressField, sipEnd, connectionAddress);
struct in_addr fromIp;
if(connectionAddress.size())
{
if(ACE_OS::inet_aton((PCSTR)connectionAddress, &fromIp))
{
info->m_fromRtpIp = fromIp;
if (DLLCONFIG.m_sipDropIndirectInvite)
{
if((unsigned int)fromIp.s_addr != (unsigned int)ipHeader->ip_src.s_addr)
{
// SIP invite SDP connection address does not match with SIP packet origin
drop =true;
}
}
}
}
}
if(contactField && sipMethod == SIP_METHOD_INVITE)
{
CStdString contact;
char* contactFieldEnd = GrabLine(contactField, sipEnd, contact);
LOG4CXX_DEBUG(s_sipExtractionLog, "contact: " + contact);
GrabSipName(contactField, contactFieldEnd, info->m_contactName);
char* sipUser = memFindAfter("sip:", contactField, contactFieldEnd);
if(sipUser)
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(sipUser, contactFieldEnd, info->m_contact);
}
else
{
GrabSipUriUser(sipUser, contactFieldEnd, info->m_contact);
}
GrabSipUriDomain(sipUser, contactFieldEnd, info->m_contactDomain);
}
else
{
if(DLLCONFIG.m_sipReportFullAddress)
{
GrabSipUserAddress(contactField, contactFieldEnd, info->m_contact);
}
else
{
GrabSipUriUser(contactField, contactFieldEnd, info->m_contact);
}
GrabSipUriDomain(contactField, contactFieldEnd, info->m_contactDomain);
}
}
// SIP fields extraction
for(std::list<CStdString>::iterator it = DLLCONFIG.m_sipExtractFields.begin(); it != DLLCONFIG.m_sipExtractFields.end(); it++)
{
CStdString fieldName = *it + ":";
char* szField = memFindAfter((PSTR)(PCSTR)fieldName, (char*)udpPayload, sipEnd);
if(szField)
{
CStdString field;
// XXX
// The line below was replaced because I experienced
// cases where we would have a leading whitespace in the
// tag which has been extracted. However, since we are
// dealing with SIP, RFC 3261, section 7.3.1 illustrates
// that any leading whitespaces after the colon is not
// in fact part of the header value. Therefore, I
// created the GrabLineSkipLeadingWhitespace() function
// which I use in this particular case.
//
// Hope this is ok.
//
// --Gerald
//
//GrabLine(szField, sipEnd, field);
GrabLineSkipLeadingWhitespace(szField, sipEnd, field);
info->m_extractedFields.insert(std::make_pair(*it, field));
}
}
if(DLLCONFIG.m_rtpReportDtmf)
{
if(rtpmapAttribute)
{
CStdString rtpPayloadType, nextToken;
char *nextStep = NULL;
while(rtpmapAttribute && rtpmapAttribute < sipEnd)
{
rtpPayloadType = "";
GrabTokenSkipLeadingWhitespaces(rtpmapAttribute, audioSdpEnd, rtpPayloadType);
nextToken.Format("%s ", rtpPayloadType);
nextStep = memFindAfter((char*)nextToken.c_str(), rtpmapAttribute, audioSdpEnd);
/* We need our "nextStep" to contain at least the length
* of the string "telephone-event", 15 characters */
if(nextStep && ((sipEnd - nextStep) >= 15))
{
if(ACE_OS::strncasecmp(nextStep, "telephone-event", 15) == 0)
{
/* Our DTMF packets are indicated using
* the payload type rtpPayloadType */
info->m_telephoneEventPayloadType = rtpPayloadType;
info->m_telephoneEventPtDefined = true;
break;
}
}
rtpmapAttribute = memFindAfter("\na=rtpmap:", rtpmapAttribute, audioSdpEnd);
}
}
}
//Determine the being used codec: should be the first rtpmap
if(sipMethod == SIP_METHOD_200_OK || sipMethod == SIP_RESPONSE_SESSION_PROGRESS)
{
rtpmapAttribute = memFindAfter("\na=rtpmap:", (char*)audioSdpStart, audioSdpEnd);
if(rtpmapAttribute)
{
CStdString line;
GrabLineSkipLeadingWhitespace(rtpmapAttribute, sipEnd, line);
info->m_orekaRtpPayloadType = GetOrekaRtpPayloadTypeForSdpRtpMap(line);
}
}
if((unsigned int)info->m_fromRtpIp.s_addr == 0)
{
// In case connection address could not be extracted, use SIP invite sender IP address
if(DLLCONFIG.m_dahdiIntercept == true)
{
info->m_fromRtpIp = ipHeader->ip_dest;
}
else
{
info->m_fromRtpIp = ipHeader->ip_src;
}
}
if(sipMethod == SIP_METHOD_200_OK)
{
info->m_senderIp = ipHeader->ip_dest;
info->m_receiverIp = ipHeader->ip_src;
}
else
{
info->m_senderIp = ipHeader->ip_src;
info->m_receiverIp = ipHeader->ip_dest;
}
info->m_originalSenderIp = ipHeader->ip_src;
info->m_recvTime = time(NULL);
memcpy(info->m_senderMac, ethernetHeader->sourceMac, sizeof(info->m_senderMac));
memcpy(info->m_receiverMac, ethernetHeader->destinationMac, sizeof(info->m_receiverMac));
if(sipMethod.Equals(SIP_METHOD_INVITE) || info->m_fromRtpPort.size())
{
// Only log SIP non-INVITE messages that contain SDP (i.e. with a valid RTP port)
info->ToString(logMsg);
logMsg = sipMethod + ": " + logMsg;
LOG4CXX_INFO(s_sipPacketLog, logMsg);
}
//Sip INVITE without sdp will be reported, but other methods without sdp will not be
if(drop == false && sipMethod == SIP_METHOD_INVITE && info->m_from.size() && info->m_to.size() && info->m_callId.size())
{
VoIpSessionsSingleton::instance()->ReportSipInvite(info);
}
else if(drop == false && info->m_fromRtpPort.size() && info->m_from.size() && info->m_to.size() && info->m_callId.size())
{
VoIpSessionsSingleton::instance()->ReportSipInvite(info);
}
}
return result;
}
