void debug_user_exception_message(int (*printfn)(const char *format, ...),
seL4_Word* mrs)
{
/* See section 5.2.3 of the manual. */
printfn(" PC = %p\n"
" SP = %p\n"
" CPSR = %p\n"
" exception number = %p\n"
" exception code = %p\n",
(void*)mrs[0], (void*)mrs[1], (void*)mrs[2], (void*)mrs[3],
(void*)mrs[4]);
}
template<class T, size_t N> static bool
printlist (strbuf &sb, const rpc_vec<T, N> &v, bool (*printfn) (strbuf &, T))
{
bool first = true;
for (const T *tp = v.base (); tp < v.lim (); tp++) {
if (first)
first = false;
else
sb << ",";
if (!printfn (sb, *tp))
return false;
}
return true;
}
/*
* Print bootp requests
*/
void
bootp_print(struct bootp *bp, int length, u_short sport, u_short dport)
{
static char tstr[] = " [|bootp]";
static unsigned char vm_cmu[4] = VM_CMU;
static unsigned char vm_rfc1048[4] = VM_RFC1048;
u_char *ep;
int vdlen;
#define TCHECK(var, l) if ((u_char *)&(var) > ep - l) goto trunc
/* Note funny sized packets */
if (length != sizeof(struct bootp))
(void) printf(" [len=%d]", length);
/* 'ep' points to the end of avaible data. */
ep = (u_char *) snapend;
switch (bp->bp_op) {
case BOOTREQUEST:
/* Usually, a request goes from a client to a server */
if (sport != IPPORT_BOOTPC || dport != IPPORT_BOOTPS)
printf(" (request)");
break;
case BOOTREPLY:
/* Usually, a reply goes from a server to a client */
if (sport != IPPORT_BOOTPS || dport != IPPORT_BOOTPC)
printf(" (reply)");
break;
default:
printf(" bootp-#%d", bp->bp_op);
}
/* The usual hardware address type is 1 (10Mb Ethernet) */
if (bp->bp_htype != 1)
printf(" htype:%d", bp->bp_htype);
/* The usual length for 10Mb Ethernet address is 6 bytes */
if (bp->bp_hlen != 6)
printf(" hlen:%d", bp->bp_hlen);
/* Client's Hardware address */
if (bp->bp_hlen) {
struct ether_header *eh;
char *e;
TCHECK(bp->bp_chaddr[0], 6);
eh = (struct ether_header *) packetp;
if (bp->bp_op == BOOTREQUEST)
e = (char *) ESRC(eh);
else if (bp->bp_op == BOOTREPLY)
e = (char *) EDST(eh);
else
e = NULL;
if (e == NULL || bcmp((char *) bp->bp_chaddr, e, 6))
dump_hex(bp->bp_chaddr, bp->bp_hlen);
}
/* Only print interesting fields */
if (bp->bp_hops)
printf(" hops:%d", bp->bp_hops);
if (bp->bp_xid)
printf(" xid:%ld", (long)ntohl(bp->bp_xid));
if (bp->bp_secs)
printf(" secs:%d", ntohs(bp->bp_secs));
/* Client's ip address */
TCHECK(bp->bp_ciaddr, sizeof(bp->bp_ciaddr));
if (bp->bp_ciaddr.s_addr)
printf(" C:%s", ipaddr_string(&bp->bp_ciaddr));
/* 'your' ip address (bootp client) */
TCHECK(bp->bp_yiaddr, sizeof(bp->bp_yiaddr));
if (bp->bp_yiaddr.s_addr)
printf(" Y:%s", ipaddr_string(&bp->bp_yiaddr));
/* Server's ip address */
TCHECK(bp->bp_siaddr, sizeof(bp->bp_siaddr));
if (bp->bp_siaddr.s_addr)
printf(" S:%s", ipaddr_string(&bp->bp_siaddr));
/* Gateway's ip address */
TCHECK(bp->bp_giaddr, sizeof(bp->bp_giaddr));
if (bp->bp_giaddr.s_addr)
printf(" G:%s", ipaddr_string(&bp->bp_giaddr));
TCHECK(bp->bp_sname[0], sizeof(bp->bp_sname));
if (*bp->bp_sname) {
printf(" sname:");
if (printfn(bp->bp_sname, ep)) {
fputs(tstr + 1, stdout);
return;
}
}
TCHECK(bp->bp_file[0], sizeof(bp->bp_file));
if (*bp->bp_file) {
printf(" file:");
if (printfn(bp->bp_file, ep)) {
fputs(tstr + 1, stdout);
return;
}
}
/* Don't try to decode the vendor buffer unless we're verbose */
if (vflag <= 0)
return;
vdlen = sizeof(bp->bp_vend);
/* Vendor data can extend to the end of the packet. */
if (vdlen < (ep - bp->bp_vend))
vdlen = (ep - bp->bp_vend);
TCHECK(bp->bp_vend[0], vdlen);
printf(" vend");
if (!bcmp(bp->bp_vend, vm_rfc1048, sizeof(u_int32)))
rfc1048_print(bp->bp_vend, vdlen);
else if (!bcmp(bp->bp_vend, vm_cmu, sizeof(u_int32)))
cmu_print(bp->bp_vend, vdlen);
else
other_print(bp->bp_vend, vdlen);
return;
trunc:
fputs(tstr, stdout);
#undef TCHECK
}
static void
rfc1048_print(u_char *bp, int length)
{
u_char tag;
u_char *ep;
int len;
u_int32 ul;
u_short us;
struct in_addr ia;
char *optstr;
printf("-rfc1395");
/* Step over magic cookie */
bp += sizeof(int32);
/* Setup end pointer */
ep = bp + length;
while (bp < ep) {
tag = *bp++;
/* Check for tags with no data first. */
if (tag == TAG_PAD)
continue;
if (tag == TAG_END)
return;
if (tag < KNOWN_OPTIONS) {
optstr = rfc1048_opts[tag];
printf(" %s:", optstr + 1);
} else {
printf(" T%d:", tag);
optstr = "?";
}
/* Now scan the length byte. */
len = *bp++;
if (bp + len > ep) {
/* truncated option */
printf(" |(%d>%d)", len, ep - bp);
return;
}
/* Print the option value(s). */
switch (optstr[0]) {
case 'a': /* ASCII string */
printfn(bp, bp + len);
bp += len;
len = 0;
break;
case 's': /* Word formats */
while (len >= 2) {
bcopy((char *) bp, (char *) &us, 2);
printf("%d", ntohs(us));
bp += 2;
len -= 2;
if (len) printf(",");
}
if (len) printf("(junk=%d)", len);
break;
case 'l': /* Long words */
while (len >= 4) {
bcopy((char *) bp, (char *) &ul, 4);
printf("%ld", (long)ntohl(ul));
bp += 4;
len -= 4;
if (len) printf(",");
}
if (len) printf("(junk=%d)", len);
break;
case 'i': /* INET addresses */
while (len >= 4) {
bcopy((char *) bp, (char *) &ia, 4);
printf("%s", ipaddr_string(&ia));
bp += 4;
len -= 4;
if (len) printf(",");
}
if (len) printf("(junk=%d)", len);
break;
case 'b':
default:
break;
} /* switch */
/* Print as characters, if appropriate. */
if (len) {
dump_hex(bp, len);
if (isascii(*bp) && isprint(*bp)) {
printf("(");
printfn(bp, bp + len);
printf(")");
}
bp += len;
len = 0;
}
} /* while bp < ep */
}
static int
printf_core(const char *format, void (*printfn)(char c, void *data),
void *data, va_list args)
{
int ret = 0;
char c, f, buf[32];
size_t buflen;
const char *s = NULL;
while ((f = *format++)) {
if (f != '%') {
printfn(f, data);
ret++;
} else {
switch ((f = *format++)) {
case '%':
printfn(f, data);
ret++;
break;
case 'c':
c = va_arg(args, int);
printfn(c, data);
ret++;
break;
case 's':
s = va_arg(args, char *);
break;
case 'f':
if (dtostr(va_arg(args, double), buf, sizeof(buf)) != EXIT_SUCCESS)
return EXIT_FAILURE;
s = buf;
break;
case 'd':
if (itostr(va_arg(args, int), 10, 0, buf, sizeof(buf)) != EXIT_SUCCESS)
return EXIT_FAILURE;
s = buf;
break;
case 'u':
if (utostr(va_arg(args, unsigned int), 10, 0, buf, sizeof(buf)) != EXIT_SUCCESS)
return EXIT_FAILURE;
s = buf;
break;
case 'x':
case 'X':
if (utostr(va_arg(args, unsigned int), 16, isupper(f), buf, sizeof(buf)) != EXIT_SUCCESS)
return EXIT_FAILURE;
// Pad out with 8 zeros
if ((buflen = cgc_strlen(buf)) < 2 * sizeof(unsigned int)) {
memmove(buf + (2 * sizeof(unsigned int) - buflen), buf, buflen + 1);
cgc_memset(buf, '0', 2 * sizeof(unsigned int) - buflen);
}
s = buf;
break;
default:
return EXIT_FAILURE;
}
while (s && *s) {
printfn(*s++, data);
ret++;
}
s = NULL;
}
}
return ret;
}
int
main(int argc, char *argv[])
{
struct stat sb;
const char *fn;
FILE *fp;
off_t off;
enum STYLE style;
int i, ch, first;
file_info_t *file;
char *p;
/*
* Tail's options are weird. First, -n10 is the same as -n-10, not
* -n+10. Second, the number options are 1 based and not offsets,
* so -n+1 is the first line, and -c-1 is the last byte. Third, the
* number options for the -r option specify the number of things that
* get displayed, not the starting point in the file. The one major
* incompatibility in this version as compared to historical versions
* is that the 'r' option couldn't be modified by the -lbc options,
* i.e. it was always done in lines. This version treats -rc as a
* number of characters in reverse order. Finally, the default for
* -r is the entire file, not 10 lines.
*/
#define ARG(units, forward, backward) { \
if (style) \
usage(); \
off = strtoll(optarg, &p, 10) * (units); \
if (*p) \
errx(1, "illegal offset -- %s", optarg); \
switch(optarg[0]) { \
case '+': \
if (off) \
off -= (units); \
style = (forward); \
break; \
case '-': \
off = -off; \
/* FALLTHROUGH */ \
default: \
style = (backward); \
break; \
} \
}
obsolete(argv);
style = NOTSET;
off = 0;
while ((ch = getopt(argc, argv, "Fb:c:fn:qr")) != -1)
switch(ch) {
case 'F': /* -F is superset of (and implies) -f */
Fflag = fflag = 1;
break;
case 'b':
ARG(512, FBYTES, RBYTES);
break;
case 'c':
ARG(1, FBYTES, RBYTES);
break;
case 'f':
fflag = 1;
break;
case 'n':
ARG(1, FLINES, RLINES);
break;
case 'q':
qflag = 1;
break;
case 'r':
rflag = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
no_files = argc ? argc : 1;
/*
* If displaying in reverse, don't permit follow option, and convert
* style values.
*/
if (rflag) {
if (fflag)
usage();
if (style == FBYTES)
style = RBYTES;
else if (style == FLINES)
style = RLINES;
}
/*
* If style not specified, the default is the whole file for -r, and
* the last 10 lines if not -r.
*/
if (style == NOTSET) {
if (rflag) {
off = 0;
style = REVERSE;
} else {
off = 10;
style = RLINES;
}
}
if (*argv && fflag) {
files = (struct file_info *) malloc(no_files *
sizeof(struct file_info));
if (!files)
err(1, "Couldn't malloc space for file descriptors.");
for (file = files; (fn = *argv++); file++) {
file->file_name = strdup(fn);
if (! file->file_name)
errx(1, "Couldn't malloc space for file name.");
if ((file->fp = fopen(file->file_name, "r")) == NULL ||
fstat(fileno(file->fp), &file->st)) {
if (file->fp != NULL) {
fclose(file->fp);
file->fp = NULL;
}
if (!Fflag || errno != ENOENT)
ierr(file->file_name);
}
}
follow(files, style, off);
for (i = 0, file = files; i < no_files; i++, file++) {
free(file->file_name);
}
free(files);
} else if (*argv) {
for (first = 1; (fn = *argv++);) {
if ((fp = fopen(fn, "r")) == NULL ||
fstat(fileno(fp), &sb)) {
ierr(fn);
continue;
}
if (argc > 1 && !qflag) {
printfn(fn, !first);
first = 0;
}
if (rflag)
reverse(fp, fn, style, off, &sb);
else
forward(fp, fn, style, off, &sb);
}
} else {
fn = "stdin";
if (fstat(fileno(stdin), &sb)) {
ierr(fn);
exit(1);
}
/*
* Determine if input is a pipe. 4.4BSD will set the SOCKET
* bit in the st_mode field for pipes. Fix this then.
*/
if (lseek(fileno(stdin), (off_t)0, SEEK_CUR) == -1 &&
errno == ESPIPE) {
errno = 0;
fflag = 0; /* POSIX.2 requires this. */
}
if (rflag)
reverse(stdin, fn, style, off, &sb);
else
forward(stdin, fn, style, off, &sb);
}
exit(rval);
}
/** Print the data contained in an BST; BST/User provides how to print the data */
void
bst_node_print (bst_node_t *node, void (*printfn)(void *))
{
printfn(node->data);
}
