void fault_handler (int signal, siginfo_t * siginfo, void *context)
{
#define MAX_FRAMES 25
void * frames[MAX_FRAMES];
int num_frames;
struct timespec timestamp;
char ** symbols;
int i;
/* Grab time stamp */
clock_gettime(CLOCK_REALTIME, ×tamp);
fprintf (stderr,
"\n********************"
"\n* EXCEPTION CAUGHT *"
"\n********************\n"
"Process ID: %d\n"
"Thread ID: %d\n"
"Exception: %s\n"
"Reason: %s\n"
"Fault Address: %p\n"
"Signal error: %s\n"
"Last error: %s\n"
"Time stamp: %s",
getpid(),
gettid(),
strsignal(signal),
code2str(siginfo->si_code, signal),
siginfo->si_addr,
strerror(siginfo->si_errno),
strerror(errno),
ctime(×tamp.tv_sec)
);
/* Get the backtrace. */
num_frames=backtrace(frames, MAX_FRAMES);
symbols=backtrace_symbols(frames, num_frames);
if(symbols) {
for(i=0; i< num_frames; i++) {
fprintf(stderr, "%s\n", symbols[i]);
}
}
fflush(NULL);
free(symbols);
/* Produce a core dump for in depth debugging */
abort();
return;
}
SciErr getPolyVariableName(void* _pvCtx, int* _piAddress, char* _pstVarName, int* _piVarNameLen)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
char *pstVarName = NULL;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getPolyVariableName");
return sciErr;
}
if (_piAddress[0] != sci_poly)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), "getPolyVariableName", _("polynomial matrix"));
return sciErr;
}
*_piVarNameLen = 4;
pstVarName = (char*)MALLOC(sizeof(char) * 5);
code2str(&pstVarName, &_piAddress[4], *_piVarNameLen);
for (int i = 0 ; i < *_piVarNameLen ; i++)
{
if (pstVarName[i] == ' ')
{
memset(pstVarName + i, 0x00, *_piVarNameLen - i);
*_piVarNameLen = i;
break;
}
}
pstVarName[4] = 0;
if (_pstVarName == NULL)
{
return sciErr;
}
strcpy(_pstVarName, pstVarName);
return sciErr;
}
void
tcp_print(struct sbuf *sbuf, register const u_char *bp, register u_int length,
register const u_char *bp2)
{
register const struct tcphdr *tp;
register const struct ip *ip;
register u_char flags;
register u_int hlen;
register char ch;
u_int16_t sport, dport, win, urp;
u_int32_t seq, ack;
register const struct ip6_hdr *ip6;
tp = (struct tcphdr *)bp;
hlen = (tp->th_off & 0x0f) * 4;
if (hlen < sizeof(*tp)) {
sbuf_printf(sbuf, "errormsg='tcp %d [bad hdr length %u - too short < %lu]',",
length - hlen, hlen, (unsigned long)sizeof(*tp));
return;
}
ip = (struct ip *)bp2;
if (IP_V(ip) == 6)
ip6 = (struct ip6_hdr *)bp2;
else
ip6 = NULL;
ch = '\0';
sport = EXTRACT_16BITS(&tp->th_sport);
dport = EXTRACT_16BITS(&tp->th_dport);
sbuf_printf(sbuf, "%u,%u,%d,", sport, dport, length - hlen);
seq = EXTRACT_32BITS(&tp->th_seq);
ack = EXTRACT_32BITS(&tp->th_ack);
win = EXTRACT_16BITS(&tp->th_win);
urp = EXTRACT_16BITS(&tp->th_urp);
flags = tp->th_flags;
sbuf_printf(sbuf, "%s%s%s", flags & TH_FIN ? "F" : "", flags & TH_SYN ? "S" : "", flags & TH_RST ? "R" : "");
sbuf_printf(sbuf, "%s%s%s", flags & TH_PUSH ? "P" : "", flags & TH_ACK ? "A" : "", flags & TH_URG ? "U" : "");
sbuf_printf(sbuf, "%s%s,", flags & TH_ECE ? "E" : "", flags & TH_CWR ? "C" : "");
if (hlen > length) {
sbuf_printf(sbuf, "errormsg='[bad hdr length %u - too long, > %u]',",
hlen, length);
return;
}
length -= hlen;
if (length > 0 || flags & (TH_SYN | TH_FIN | TH_RST)) {
if (length > 0)
sbuf_printf(sbuf, "%u:%u,", seq, seq + length);
else
sbuf_printf(sbuf, "%u,", seq);
} else
sbuf_printf(sbuf, ",");
if (flags & TH_ACK)
sbuf_printf(sbuf, "%u,", ack);
else
sbuf_printf(sbuf, ",");
sbuf_printf(sbuf, "%d,", win);
if (flags & TH_URG)
sbuf_printf(sbuf, "%d,", urp);
else
sbuf_printf(sbuf, ",");
/*
* Handle any options.
*/
if (hlen > sizeof(*tp)) {
register const u_char *cp;
register u_int opt, datalen;
register u_int len;
hlen -= sizeof(*tp);
cp = (const u_char *)tp + sizeof(*tp);
while (hlen > 0) {
if (ch != '\0')
sbuf_printf(sbuf, "%c", ch);
opt = *cp++;
if (ZEROLENOPT(opt))
len = 1;
else {
len = *cp++; /* total including type, len */
if (len < 2 || len > hlen)
goto bad;
--hlen; /* account for length byte */
}
--hlen; /* account for type byte */
datalen = 0;
sbuf_printf(sbuf, "%s", code2str(tcp_option_values, "Unknown Option %u", opt));
switch (opt) {
case TCPOPT_MAXSEG:
datalen = 2;
break;
case TCPOPT_WSCALE:
datalen = 1;
break;
case TCPOPT_SACK:
datalen = len - 2;
break;
case TCPOPT_CC:
case TCPOPT_CCNEW:
case TCPOPT_CCECHO:
case TCPOPT_ECHO:
case TCPOPT_ECHOREPLY:
datalen = 4;
break;
case TCPOPT_TIMESTAMP:
datalen = 8;
break;
case TCPOPT_SIGNATURE:
datalen = TCP_SIGLEN;
break;
case TCPOPT_AUTH:
datalen = len - 3;
break;
case TCPOPT_EOL:
case TCPOPT_NOP:
case TCPOPT_SACKOK:
/*
* Nothing interesting.
* fall through
*/
break;
case TCPOPT_UTO:
datalen = 2;
break;
default:
datalen = len - 2;
break;
}
/* Account for data printed */
cp += datalen;
hlen -= datalen;
/* Check specification against observed length */
++datalen; /* option octet */
if (!ZEROLENOPT(opt))
++datalen; /* size octet */
ch = ';';
if (opt == TCPOPT_EOL)
break;
}
}
if (length <= 0)
return;
return;
bad:
sbuf_printf(sbuf, "[bad opt],");
if (ch != '\0')
sbuf_printf(sbuf, ">,");
return;
}
