static void cmd_dump_log(int argc ATTR_UNUSED, char *argv[])
{
uint64_t modseq;
int fd, ret;
fd = open(argv[1], O_RDONLY);
if (fd < 0)
i_fatal("open(%s) failed: %m", argv[1]);
dump_hdr(fd, &modseq);
do {
T_BEGIN {
ret = dump_record(fd, &modseq);
} T_END;
} while (ret > 0);
}
static int parse_buffer(int fdin, int fdout)
{
struct dbg_line *line;
struct ptldebug_header *hdr;
char buf[4097];
char *ptr;
unsigned long dropped = 0;
unsigned long kept = 0;
unsigned long bad = 0;
struct dbg_line **linev = NULL;
int linev_len = 0;
int rc;
hdr = (void *)buf;
while (1) {
int first_bad = 1;
int count;
count = HDR_SIZE;
ptr = buf;
readhdr:
rc = read(fdin, ptr, count);
if (rc <= 0)
goto print;
ptr += rc;
count -= rc;
if (count > 0)
goto readhdr;
if (hdr->ph_len > 4094 || /* is this header bogus? */
hdr->ph_stack > 65536 ||
hdr->ph_sec < (1 << 30) ||
hdr->ph_usec > 1000000000 ||
hdr->ph_line_num > 65536) {
if (first_bad)
dump_hdr(lseek(fdin, 0, SEEK_CUR), hdr);
bad += first_bad;
first_bad = 0;
/* try to restart on next line */
while (count < HDR_SIZE && buf[count] != '\n')
count++;
if (buf[count] == '\n')
count++; /* move past '\n' */
if (HDR_SIZE - count > 0) {
int left = HDR_SIZE - count;
memmove(buf, buf + count, left);
ptr = buf + left;
goto readhdr;
}
continue;
}
if (hdr->ph_len == 0)
continue;
count = hdr->ph_len - HDR_SIZE;
readmore:
rc = read(fdin, ptr, count);
if (rc <= 0)
break;
ptr += rc;
count -= rc;
if (count > 0)
goto readmore;
first_bad = 1;
if ((hdr->ph_subsys && !(subsystem_mask & hdr->ph_subsys)) ||
(hdr->ph_mask && !(debug_mask & hdr->ph_mask))) {
dropped++;
continue;
}
retry_alloc:
line = malloc(sizeof(*line));
if (line == NULL) {
if (linev) {
fprintf(stderr, "error: line malloc(%u): "
"printing accumulated records\n",
(unsigned int)sizeof(*line));
print_rec(&linev, kept, fdout);
goto retry_alloc;
}
fprintf(stderr, "error: line malloc(%u): exiting\n",
(unsigned int)sizeof(*line));
break;
}
line->hdr = malloc(hdr->ph_len + 1);
if (line->hdr == NULL) {
free(line);
if (linev) {
fprintf(stderr, "error: hdr malloc(%u): "
"printing accumulated records\n",
hdr->ph_len + 1);
print_rec(&linev, kept, fdout);
goto retry_alloc;
}
fprintf(stderr, "error: hdr malloc(%u): exiting\n",
hdr->ph_len + 1);
break;
}
ptr = (void *)line->hdr;
memcpy(line->hdr, buf, hdr->ph_len);
ptr[hdr->ph_len] = '\0';
ptr += sizeof(*hdr);
line->file = ptr;
ptr += strlen(line->file) + 1;
line->fn = ptr;
ptr += strlen(line->fn) + 1;
line->text = ptr;
retry_add:
if (add_rec(line, &linev, &linev_len, kept) < 0) {
if (linev) {
fprintf(stderr, "error: add_rec[%u] failed; "
"print accumulated records\n",
linev_len);
print_rec(&linev, kept, fdout);
goto retry_add;
}
fprintf(stderr, "error: add_rec[0] failed; exiting\n");
break;
}
kept++;
}
print:
if (linev)
print_rec(&linev, kept, fdout);
printf("Debug log: %lu lines, %lu kept, %lu dropped, %lu bad.\n",
dropped + kept + bad, kept, dropped, bad);
return 0;
}
int main(int argc, char**argv)
{
// test state
const int NUM_TESTS = 1;
int verbose = 0;
int success = 0;
int failure = 0;
int getopt_char;
while ((getopt_char = getopt(argc, argv, "v")) != -1) {
switch (getopt_char) {
case 'v':
++verbose;
break;
default:
printf(
"usage: test_count_rg [-v]\n\n"
" -v verbose output\n"
);
break;
}
}
// Setup stderr redirect
size_t len = 0;
char* res = NULL;
FILE* orig_stderr = fdopen(dup(STDERR_FILENO), "a"); // Save stderr
char* tempfname = (optind < argc)? argv[optind] : "test_count_rg.tmp";
FILE* check = NULL;
// setup
if (verbose) printf("BEGIN test 1\n"); // TID test
bam_hdr_t* hdr1;
size_t count;
char** output;
setup_test_1(&hdr1);
if (verbose > 1) {
printf("hdr1\n");
dump_hdr(hdr1);
}
if (verbose) printf("RUN test 1\n");
// test
xfreopen(tempfname, "w", stderr); // Redirect stderr to pipe
bool result_1 = count_RG(hdr1, &count, &output);
fclose(stderr);
if (verbose) printf("END RUN test 1\n");
if (verbose > 1) {
printf("b\n");
dump_hdr(hdr1);
}
// check result
check = fopen(tempfname, "r");
if (result_1 && count == 1 && !strcmp(output[0], "fish")
&& (getline(&res, &len, check) == -1)
&& (feof(check) || (res && !strcmp("",res)))) {
++success;
} else {
++failure;
if (verbose) printf("FAIL test 1\n");
}
fclose(check);
// teardown
int i;
for (i = 0; i < count; i++){
free(output[i]);
}
free(output);
bam_hdr_destroy(hdr1);
if (verbose) printf("END test 1\n");
// Cleanup
free(res);
remove(tempfname);
if (failure > 0)
fprintf(orig_stderr, "%d failures %d successes\n", failure, success);
fclose(orig_stderr);
return (success == NUM_TESTS)? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char**argv)
{
// test state
const int NUM_TESTS = 2;
int verbose = 0;
int success = 0;
int failure = 0;
int getopt_char;
while ((getopt_char = getopt(argc, argv, "v")) != -1) {
switch (getopt_char) {
case 'v':
++verbose;
break;
default:
printf(
"usage: test_filter_header_rg [-v]\n\n"
" -v verbose output\n"
);
break;
}
}
// Setup pysamerr redirect
kstring_t res = { 0, 0, NULL };
FILE* orig_pysamerr = fdopen(dup(STDERR_FILENO), "a"); // Save pysamerr
char* tempfname = (optind < argc)? argv[optind] : "test_count_rg.tmp";
FILE* check = NULL;
// setup
if (verbose) printf("BEGIN test 1\n"); // test eliminating a tag that isn't there
bam_hdr_t* hdr1;
const char* id_to_keep_1 = "1#2.3";
setup_test_1(&hdr1);
if (verbose > 1) {
printf("hdr1\n");
dump_hdr(hdr1);
}
if (verbose) printf("RUN test 1\n");
// test
xfreopen(tempfname, "w", pysamerr); // Redirect pysamerr to pipe
bool result_1 = filter_header_rg(hdr1, id_to_keep_1);
fclose(pysamerr);
if (verbose) printf("END RUN test 1\n");
if (verbose > 1) {
printf("hdr1\n");
dump_hdr(hdr1);
}
// check result
res.l = 0;
check = fopen(tempfname, "r");
if ( result_1
&& check_test_1(hdr1)
&& kgetline(&res, (kgets_func *)fgets, check) < 0
&& (feof(check) || res.l == 0)) {
++success;
} else {
++failure;
if (verbose) printf("FAIL test 1\n");
}
fclose(check);
// teardown
bam_hdr_destroy(hdr1);
if (verbose) printf("END test 1\n");
if (verbose) printf("BEGIN test 2\n"); // test eliminating a tag that is there
bam_hdr_t* hdr2;
const char* id_to_keep_2 = "fish";
setup_test_2(&hdr2);
if (verbose > 1) {
printf("hdr2\n");
dump_hdr(hdr2);
}
if (verbose) printf("RUN test 2\n");
// test
xfreopen(tempfname, "w", pysamerr); // Redirect pysamerr to pipe
bool result_2 = filter_header_rg(hdr2, id_to_keep_2);
fclose(pysamerr);
if (verbose) printf("END RUN test 2\n");
if (verbose > 1) {
printf("hdr2\n");
dump_hdr(hdr2);
}
// check result
res.l = 0;
check = fopen(tempfname, "r");
if ( result_2
&& check_test_2(hdr2)
&& kgetline(&res, (kgets_func *)fgets, check) < 0
&& (feof(check) || res.l == 0)) {
++success;
} else {
++failure;
if (verbose) printf("FAIL test 2\n");
}
fclose(check);
// teardown
bam_hdr_destroy(hdr2);
if (verbose) printf("END test 2\n");
// Cleanup
free(res.s);
remove(tempfname);
if (failure > 0)
fprintf(orig_pysamerr, "%d failures %d successes\n", failure, success);
fclose(orig_pysamerr);
return (success == NUM_TESTS)? EXIT_SUCCESS : EXIT_FAILURE;
}
static void
prompt(void)
{
char input[256];
char prev_input[256];
char * tok = NULL;
afs_uint32 x, y, z;
enum {
PR_GLOBAL_MODE,
PR_H_MODE,
PR_FE_MODE,
PR_CB_MODE
} mode = PR_GLOBAL_MODE, next_mode;
next_mode = mode;
input[0] = prev_input[0] = '\0';
while (1) {
if (!tok) {
switch(mode) {
case PR_GLOBAL_MODE:
printf(PROGNAME "> ");
break;
case PR_H_MODE:
printf(PROGNAME ": h(%d)> ", he_cursor.idx);
break;
case PR_FE_MODE:
printf(PROGNAME ": fe(%d)> ", fe_cursor.idx);
break;
case PR_CB_MODE:
printf(PROGNAME ": fe(%d):cb(%d)> ", fe_cursor.idx, cb_cursor.idx);
break;
default:
fprintf(stderr, "prompt state broken; aborting\n");
return;
}
fgets(input, 256, stdin);
if (!strcmp(input, "")) {
/* repeat last command */
if (!strcmp(prev_input, "")) {
continue;
}
strlcpy(input, prev_input, sizeof(input));
} else {
/* save command for repetition */
strlcpy(prev_input, input, sizeof(prev_input));
}
tok = strtok(input, " \t\n");
}
while (tok && !strcmp(tok, ";")) {
tok = strtok(NULL, "; \t\n");
}
if (!tok) {
continue;
}
if (!strcasecmp(tok, "exit")) {
return;
} else if (!strcasecmp(tok, "quit")) {
switch(mode) {
case PR_CB_MODE:
next_mode = PR_FE_MODE;
break;
case PR_FE_MODE:
case PR_H_MODE:
next_mode = PR_GLOBAL_MODE;
break;
default:
return;
}
} else if (!strcasecmp(tok, "h")) {
tok = strtok(NULL, " \t");
mode = PR_H_MODE;
if (!tok) {
next_mode = mode;
}
continue;
} else if (!strcasecmp(tok, "fe")) {
tok = strtok(NULL, " \t");
mode = PR_FE_MODE;
if (!tok) {
next_mode = mode;
}
continue;
} else if (!strcasecmp(tok, "fs")) {
tok = strtok(NULL, " \t");
mode = PR_GLOBAL_MODE;
if (!tok) {
next_mode = mode;
}
continue;
} else if (!strcasecmp(tok, "cb")) {
tok = strtok(NULL, " \t");
mode = PR_CB_MODE;
if (!tok) {
next_mode = mode;
}
continue;
} else if (!strcasecmp(tok, "help")) {
switch(mode) {
case PR_H_MODE:
print_h_help();
break;
case PR_FE_MODE:
print_fe_help();
break;
case PR_CB_MODE:
print_cb_help();
break;
default:
print_global_help();
}
print_help();
} else if (!strcasecmp(tok, "hexdump")) {
tok = strtok(NULL, " \t");
if (!tok) {
hexdump_map(0, map_len);
continue;
}
if (sscanf(tok, "%u", &x) != 1) {
fprintf(stderr, "hexdump parse error 1\n");
tok = NULL;
continue;
}
tok = strtok(NULL, " \t");
if (!tok) {
hexdump_map(x, map_len - x);
continue;
}
if (sscanf(tok, "%u", &y) != 1) {
fprintf(stderr, "hexdump parse error 2\n");
continue;
}
hexdump_map(x,y);
} else if (!strcasecmp(tok, "hdr")) {
switch(mode) {
case PR_H_MODE:
dump_h_hdr();
break;
case PR_FE_MODE:
dump_cb_hdr();
break;
case PR_CB_MODE:
dump_this_fe();
break;
default:
dump_hdr();
}
} else if (!strcasecmp(tok, "this")) {
switch(mode) {
case PR_H_MODE:
dump_this_he();
break;
case PR_FE_MODE:
dump_this_fe();
break;
case PR_CB_MODE:
dump_this_cb();
break;
default:
fprintf(stderr, "command not valid for this mode\n");
}
} else if (!strcasecmp(tok, "next")) {
switch(mode) {
case PR_H_MODE:
dump_next_he();
break;
case PR_FE_MODE:
dump_next_fe();
break;
case PR_CB_MODE:
dump_next_cb();
break;
default:
fprintf(stderr, "command not valid for this mode\n");
}
} else if (!strcasecmp(tok, "prev")) {
switch(mode) {
case PR_H_MODE:
dump_prev_he();
break;
case PR_FE_MODE:
dump_prev_fe();
break;
case PR_CB_MODE:
dump_prev_cb();
break;
default:
fprintf(stderr, "command not valid for this mode\n");
}
} else if (!strcasecmp(tok, "first")) {
switch(mode) {
case PR_H_MODE:
dump_first_he();
break;
case PR_FE_MODE:
dump_first_fe();
break;
case PR_CB_MODE:
dump_first_cb();
break;
default:
fprintf(stderr, "command not valid for this mode\n");
}
} else if (!strcasecmp(tok, "last")) {
switch(mode) {
case PR_H_MODE:
dump_last_he();
break;
case PR_FE_MODE:
dump_last_fe();
break;
case PR_CB_MODE:
dump_last_cb();
break;
default:
fprintf(stderr, "command not valid for this mode\n");
}
} else if (!strcasecmp(tok, "dump")) {
switch(mode) {
case PR_H_MODE:
dump_all_hes();
break;
case PR_FE_MODE:
dump_all_fes();
break;
case PR_CB_MODE:
dump_all_cbs();
break;
default:
fprintf(stderr, "command not valid for this mode\n");
}
} else if (!strcasecmp(tok, "find")) {
tok = strtok(NULL, " \t");
if (!tok || strcasecmp(tok, "by")) {
tok = NULL;
fprintf(stderr, "find syntax error 1 (%s)\n",
(tok) ? tok : "nil");
continue;
}
tok = strtok(NULL, " \t");
if (!tok) {
fprintf(stderr, "find syntax error 2\n");
continue;
}
switch(mode) {
case PR_H_MODE:
fprintf(stderr, "not implemented yet\n");
break;
case PR_FE_MODE:
if (!strcasecmp(tok, "index")) {
tok = strtok(NULL, " \t");
if (!tok || sscanf(tok, "%u", &x) != 1) {
tok = NULL;
fprintf(stderr, "find syntax error 3\n");
continue;
}
if (find_fe_by_index(x)) {
fprintf(stderr, "find returned no results\n");
}
} else if (!strcasecmp(tok, "fid")) {
tok = strtok(NULL, "(), \t");
if (!tok || sscanf(tok, "%u", &x) != 1) {
tok = NULL;
fprintf(stderr, "find syntax error 4\n");
continue;
}
tok = strtok(NULL, "(), \t");
if (!tok || sscanf(tok, "%u", &y) != 1) {
tok = NULL;
fprintf(stderr, "find syntax error 5\n");
continue;
}
tok = strtok(NULL, "(), \t");
if (!tok || sscanf(tok, "%u", &z) != 1) {
tok = NULL;
fprintf(stderr, "find syntax error 6\n");
continue;
}
if (find_fe_by_fid(x,y,z)) {
fprintf(stderr, "find returned no results\n");
}
} else {
fprintf(stderr, "unsupported filter type\n");
}
break;
case PR_CB_MODE:
if (!strcasecmp(tok, "index")) {
tok = strtok(NULL, " \t");
if (!tok || sscanf(tok, "%u", &x) != 1) {
tok = NULL;
fprintf(stderr, "find syntax error 3\n");
continue;
}
if (find_cb_by_index(x)) {
fprintf(stderr, "find returned no results\n");
}
} else {
fprintf(stderr, "unsupported filter type\n");
}
break;
default:
fprintf(stderr, "find not supported for this menu\n");
}
} else if (!strcspn(tok, "0123456789")) {
if (sscanf(tok, "%u", &x) == 1) {
switch(mode) {
case PR_H_MODE:
dump_he(x);
break;
case PR_FE_MODE:
dump_fe(x);
break;
case PR_CB_MODE:
dump_cb(x);
break;
default:
fprintf(stderr, "command not available from this menu\n");
}
} else {
fprintf(stderr, "input parse error ('%s')\n", tok);
}
} else if (mode == PR_FE_MODE) {
if (!strcmp(tok, "timeout")) {
dump_cb_timeout();
} else if (!strcmp(tok, "hash")) {
dump_cb_fehash();
}
} else {
fprintf(stderr, "unknown command\n");
}
tok = strtok(NULL, " \t");
mode = next_mode;
}
}
int main(int argc, char *argv[])
{
boot_img_hdr hdr;
char *bootimg, *kernel = NULL, *ramdisk = NULL, *second = NULL, *dt = NULL;
int bootfd;
int pagesize;
int opt;
int dump = 0;
if (argc < 2) {
usage();
return 0;
}
memset(&hdr, 0, sizeof(hdr));
while ((opt = getopt(argc, argv, "i:k:r:s:t:dh")) != -1) {
switch (opt) {
case 'i':
bootimg = strdup(optarg);
break;
case 'k':
kernel = strdup(optarg);
break;
case 'r':
ramdisk = strdup(optarg);
break;
case 's':
second = strdup(optarg);
break;
case 't':
dt = strdup(optarg);
break;
case 'd':
dump = 1;
break;
case 'h':
default:
usage();
return 0;
}
}
bootfd = open(bootimg, O_RDONLY);
if (bootfd <= 0) {
perror("open");
return -1;
}
if (read(bootfd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
perror("read");
return -1;
}
if (dump) {
dump_hdr(&hdr);
return 0;
}
if (kernel)
if (extract(bootfd, &hdr, kernel, "kernel") < 0)
goto out;
if (ramdisk)
if (extract(bootfd, &hdr, ramdisk, "ramdisk") < 0)
goto out;
if (second)
if (extract(bootfd, &hdr, second, "second") < 0)
goto out;
if (dt)
if (extract(bootfd, &hdr, dt, "dt") < 0)
goto out;
if (!(kernel || ramdisk || second || dt)) {
extract(bootfd, &hdr, "kernel.img", "kernel");
extract(bootfd, &hdr, "ramdisk.img", "ramdisk");
extract(bootfd, &hdr, "second.img", "second");
extract(bootfd, &hdr, "dt.img", "dt");
}
out:
close(bootfd);
return 0;
}
