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; }