~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/bpf/bpf_dbg.c

Version: ~ [ linux-4.19-rc4 ] ~ [ linux-4.18.8 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.70 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.127 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.156 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.122 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Minimal BPF debugger
  3  *
  4  * Minimal BPF debugger that mimics the kernel's engine (w/o extensions)
  5  * and allows for single stepping through selected packets from a pcap
  6  * with a provided user filter in order to facilitate verification of a
  7  * BPF program. Besides others, this is useful to verify BPF programs
  8  * before attaching to a live system, and can be used in socket filters,
  9  * cls_bpf, xt_bpf, team driver and e.g. PTP code; in particular when a
 10  * single more complex BPF program is being used. Reasons for a more
 11  * complex BPF program are likely primarily to optimize execution time
 12  * for making a verdict when multiple simple BPF programs are combined
 13  * into one in order to prevent parsing same headers multiple times.
 14  *
 15  * More on how to debug BPF opcodes see Documentation/networking/filter.txt
 16  * which is the main document on BPF. Mini howto for getting started:
 17  *
 18  *  1) `./bpf_dbg` to enter the shell (shell cmds denoted with '>'):
 19  *  2) > load bpf 6,40 0 0 12,21 0 3 20... (output from `bpf_asm` or
 20  *     `tcpdump -iem1 -ddd port 22 | tr '\n' ','` to load as filter)
 21  *  3) > load pcap foo.pcap
 22  *  4) > run <n>/disassemble/dump/quit (self-explanatory)
 23  *  5) > breakpoint 2 (sets bp at loaded BPF insns 2, do `run` then;
 24  *       multiple bps can be set, of course, a call to `breakpoint`
 25  *       w/o args shows currently loaded bps, `breakpoint reset` for
 26  *       resetting all breakpoints)
 27  *  6) > select 3 (`run` etc will start from the 3rd packet in the pcap)
 28  *  7) > step [-<n>, +<n>] (performs single stepping through the BPF)
 29  *
 30  * Copyright 2013 Daniel Borkmann <borkmann@redhat.com>
 31  * Licensed under the GNU General Public License, version 2.0 (GPLv2)
 32  */
 33 
 34 #include <stdio.h>
 35 #include <unistd.h>
 36 #include <stdlib.h>
 37 #include <ctype.h>
 38 #include <stdbool.h>
 39 #include <stdarg.h>
 40 #include <setjmp.h>
 41 #include <linux/filter.h>
 42 #include <linux/if_packet.h>
 43 #include <readline/readline.h>
 44 #include <readline/history.h>
 45 #include <sys/types.h>
 46 #include <sys/socket.h>
 47 #include <sys/stat.h>
 48 #include <sys/mman.h>
 49 #include <fcntl.h>
 50 #include <errno.h>
 51 #include <signal.h>
 52 #include <arpa/inet.h>
 53 #include <net/ethernet.h>
 54 
 55 #define TCPDUMP_MAGIC   0xa1b2c3d4
 56 
 57 #define BPF_LDX_B       (BPF_LDX | BPF_B)
 58 #define BPF_LDX_W       (BPF_LDX | BPF_W)
 59 #define BPF_JMP_JA      (BPF_JMP | BPF_JA)
 60 #define BPF_JMP_JEQ     (BPF_JMP | BPF_JEQ)
 61 #define BPF_JMP_JGT     (BPF_JMP | BPF_JGT)
 62 #define BPF_JMP_JGE     (BPF_JMP | BPF_JGE)
 63 #define BPF_JMP_JSET    (BPF_JMP | BPF_JSET)
 64 #define BPF_ALU_ADD     (BPF_ALU | BPF_ADD)
 65 #define BPF_ALU_SUB     (BPF_ALU | BPF_SUB)
 66 #define BPF_ALU_MUL     (BPF_ALU | BPF_MUL)
 67 #define BPF_ALU_DIV     (BPF_ALU | BPF_DIV)
 68 #define BPF_ALU_MOD     (BPF_ALU | BPF_MOD)
 69 #define BPF_ALU_NEG     (BPF_ALU | BPF_NEG)
 70 #define BPF_ALU_AND     (BPF_ALU | BPF_AND)
 71 #define BPF_ALU_OR      (BPF_ALU | BPF_OR)
 72 #define BPF_ALU_XOR     (BPF_ALU | BPF_XOR)
 73 #define BPF_ALU_LSH     (BPF_ALU | BPF_LSH)
 74 #define BPF_ALU_RSH     (BPF_ALU | BPF_RSH)
 75 #define BPF_MISC_TAX    (BPF_MISC | BPF_TAX)
 76 #define BPF_MISC_TXA    (BPF_MISC | BPF_TXA)
 77 #define BPF_LD_B        (BPF_LD | BPF_B)
 78 #define BPF_LD_H        (BPF_LD | BPF_H)
 79 #define BPF_LD_W        (BPF_LD | BPF_W)
 80 
 81 #ifndef array_size
 82 # define array_size(x)  (sizeof(x) / sizeof((x)[0]))
 83 #endif
 84 
 85 #ifndef __check_format_printf
 86 # define __check_format_printf(pos_fmtstr, pos_fmtargs) \
 87         __attribute__ ((format (printf, (pos_fmtstr), (pos_fmtargs))))
 88 #endif
 89 
 90 enum {
 91         CMD_OK,
 92         CMD_ERR,
 93         CMD_EX,
 94 };
 95 
 96 struct shell_cmd {
 97         const char *name;
 98         int (*func)(char *args);
 99 };
100 
101 struct pcap_filehdr {
102         uint32_t magic;
103         uint16_t version_major;
104         uint16_t version_minor;
105         int32_t  thiszone;
106         uint32_t sigfigs;
107         uint32_t snaplen;
108         uint32_t linktype;
109 };
110 
111 struct pcap_timeval {
112         int32_t tv_sec;
113         int32_t tv_usec;
114 };
115 
116 struct pcap_pkthdr {
117         struct pcap_timeval ts;
118         uint32_t caplen;
119         uint32_t len;
120 };
121 
122 struct bpf_regs {
123         uint32_t A;
124         uint32_t X;
125         uint32_t M[BPF_MEMWORDS];
126         uint32_t R;
127         bool     Rs;
128         uint16_t Pc;
129 };
130 
131 static struct sock_filter bpf_image[BPF_MAXINSNS + 1];
132 static unsigned int bpf_prog_len;
133 
134 static int bpf_breakpoints[64];
135 static struct bpf_regs bpf_regs[BPF_MAXINSNS + 1];
136 static struct bpf_regs bpf_curr;
137 static unsigned int bpf_regs_len;
138 
139 static int pcap_fd = -1;
140 static unsigned int pcap_packet;
141 static size_t pcap_map_size;
142 static char *pcap_ptr_va_start, *pcap_ptr_va_curr;
143 
144 static const char * const op_table[] = {
145         [BPF_ST]        = "st",
146         [BPF_STX]       = "stx",
147         [BPF_LD_B]      = "ldb",
148         [BPF_LD_H]      = "ldh",
149         [BPF_LD_W]      = "ld",
150         [BPF_LDX]       = "ldx",
151         [BPF_LDX_B]     = "ldxb",
152         [BPF_JMP_JA]    = "ja",
153         [BPF_JMP_JEQ]   = "jeq",
154         [BPF_JMP_JGT]   = "jgt",
155         [BPF_JMP_JGE]   = "jge",
156         [BPF_JMP_JSET]  = "jset",
157         [BPF_ALU_ADD]   = "add",
158         [BPF_ALU_SUB]   = "sub",
159         [BPF_ALU_MUL]   = "mul",
160         [BPF_ALU_DIV]   = "div",
161         [BPF_ALU_MOD]   = "mod",
162         [BPF_ALU_NEG]   = "neg",
163         [BPF_ALU_AND]   = "and",
164         [BPF_ALU_OR]    = "or",
165         [BPF_ALU_XOR]   = "xor",
166         [BPF_ALU_LSH]   = "lsh",
167         [BPF_ALU_RSH]   = "rsh",
168         [BPF_MISC_TAX]  = "tax",
169         [BPF_MISC_TXA]  = "txa",
170         [BPF_RET]       = "ret",
171 };
172 
173 static __check_format_printf(1, 2) int rl_printf(const char *fmt, ...)
174 {
175         int ret;
176         va_list vl;
177 
178         va_start(vl, fmt);
179         ret = vfprintf(rl_outstream, fmt, vl);
180         va_end(vl);
181 
182         return ret;
183 }
184 
185 static int matches(const char *cmd, const char *pattern)
186 {
187         int len = strlen(cmd);
188 
189         if (len > strlen(pattern))
190                 return -1;
191 
192         return memcmp(pattern, cmd, len);
193 }
194 
195 static void hex_dump(const uint8_t *buf, size_t len)
196 {
197         int i;
198 
199         rl_printf("%3u: ", 0);
200         for (i = 0; i < len; i++) {
201                 if (i && !(i % 16))
202                         rl_printf("\n%3u: ", i);
203                 rl_printf("%02x ", buf[i]);
204         }
205         rl_printf("\n");
206 }
207 
208 static bool bpf_prog_loaded(void)
209 {
210         if (bpf_prog_len == 0)
211                 rl_printf("no bpf program loaded!\n");
212 
213         return bpf_prog_len > 0;
214 }
215 
216 static void bpf_disasm(const struct sock_filter f, unsigned int i)
217 {
218         const char *op, *fmt;
219         int val = f.k;
220         char buf[256];
221 
222         switch (f.code) {
223         case BPF_RET | BPF_K:
224                 op = op_table[BPF_RET];
225                 fmt = "#%#x";
226                 break;
227         case BPF_RET | BPF_A:
228                 op = op_table[BPF_RET];
229                 fmt = "a";
230                 break;
231         case BPF_RET | BPF_X:
232                 op = op_table[BPF_RET];
233                 fmt = "x";
234                 break;
235         case BPF_MISC_TAX:
236                 op = op_table[BPF_MISC_TAX];
237                 fmt = "";
238                 break;
239         case BPF_MISC_TXA:
240                 op = op_table[BPF_MISC_TXA];
241                 fmt = "";
242                 break;
243         case BPF_ST:
244                 op = op_table[BPF_ST];
245                 fmt = "M[%d]";
246                 break;
247         case BPF_STX:
248                 op = op_table[BPF_STX];
249                 fmt = "M[%d]";
250                 break;
251         case BPF_LD_W | BPF_ABS:
252                 op = op_table[BPF_LD_W];
253                 fmt = "[%d]";
254                 break;
255         case BPF_LD_H | BPF_ABS:
256                 op = op_table[BPF_LD_H];
257                 fmt = "[%d]";
258                 break;
259         case BPF_LD_B | BPF_ABS:
260                 op = op_table[BPF_LD_B];
261                 fmt = "[%d]";
262                 break;
263         case BPF_LD_W | BPF_LEN:
264                 op = op_table[BPF_LD_W];
265                 fmt = "#len";
266                 break;
267         case BPF_LD_W | BPF_IND:
268                 op = op_table[BPF_LD_W];
269                 fmt = "[x+%d]";
270                 break;
271         case BPF_LD_H | BPF_IND:
272                 op = op_table[BPF_LD_H];
273                 fmt = "[x+%d]";
274                 break;
275         case BPF_LD_B | BPF_IND:
276                 op = op_table[BPF_LD_B];
277                 fmt = "[x+%d]";
278                 break;
279         case BPF_LD | BPF_IMM:
280                 op = op_table[BPF_LD_W];
281                 fmt = "#%#x";
282                 break;
283         case BPF_LDX | BPF_IMM:
284                 op = op_table[BPF_LDX];
285                 fmt = "#%#x";
286                 break;
287         case BPF_LDX_B | BPF_MSH:
288                 op = op_table[BPF_LDX_B];
289                 fmt = "4*([%d]&0xf)";
290                 break;
291         case BPF_LD | BPF_MEM:
292                 op = op_table[BPF_LD_W];
293                 fmt = "M[%d]";
294                 break;
295         case BPF_LDX | BPF_MEM:
296                 op = op_table[BPF_LDX];
297                 fmt = "M[%d]";
298                 break;
299         case BPF_JMP_JA:
300                 op = op_table[BPF_JMP_JA];
301                 fmt = "%d";
302                 val = i + 1 + f.k;
303                 break;
304         case BPF_JMP_JGT | BPF_X:
305                 op = op_table[BPF_JMP_JGT];
306                 fmt = "x";
307                 break;
308         case BPF_JMP_JGT | BPF_K:
309                 op = op_table[BPF_JMP_JGT];
310                 fmt = "#%#x";
311                 break;
312         case BPF_JMP_JGE | BPF_X:
313                 op = op_table[BPF_JMP_JGE];
314                 fmt = "x";
315                 break;
316         case BPF_JMP_JGE | BPF_K:
317                 op = op_table[BPF_JMP_JGE];
318                 fmt = "#%#x";
319                 break;
320         case BPF_JMP_JEQ | BPF_X:
321                 op = op_table[BPF_JMP_JEQ];
322                 fmt = "x";
323                 break;
324         case BPF_JMP_JEQ | BPF_K:
325                 op = op_table[BPF_JMP_JEQ];
326                 fmt = "#%#x";
327                 break;
328         case BPF_JMP_JSET | BPF_X:
329                 op = op_table[BPF_JMP_JSET];
330                 fmt = "x";
331                 break;
332         case BPF_JMP_JSET | BPF_K:
333                 op = op_table[BPF_JMP_JSET];
334                 fmt = "#%#x";
335                 break;
336         case BPF_ALU_NEG:
337                 op = op_table[BPF_ALU_NEG];
338                 fmt = "";
339                 break;
340         case BPF_ALU_LSH | BPF_X:
341                 op = op_table[BPF_ALU_LSH];
342                 fmt = "x";
343                 break;
344         case BPF_ALU_LSH | BPF_K:
345                 op = op_table[BPF_ALU_LSH];
346                 fmt = "#%d";
347                 break;
348         case BPF_ALU_RSH | BPF_X:
349                 op = op_table[BPF_ALU_RSH];
350                 fmt = "x";
351                 break;
352         case BPF_ALU_RSH | BPF_K:
353                 op = op_table[BPF_ALU_RSH];
354                 fmt = "#%d";
355                 break;
356         case BPF_ALU_ADD | BPF_X:
357                 op = op_table[BPF_ALU_ADD];
358                 fmt = "x";
359                 break;
360         case BPF_ALU_ADD | BPF_K:
361                 op = op_table[BPF_ALU_ADD];
362                 fmt = "#%d";
363                 break;
364         case BPF_ALU_SUB | BPF_X:
365                 op = op_table[BPF_ALU_SUB];
366                 fmt = "x";
367                 break;
368         case BPF_ALU_SUB | BPF_K:
369                 op = op_table[BPF_ALU_SUB];
370                 fmt = "#%d";
371                 break;
372         case BPF_ALU_MUL | BPF_X:
373                 op = op_table[BPF_ALU_MUL];
374                 fmt = "x";
375                 break;
376         case BPF_ALU_MUL | BPF_K:
377                 op = op_table[BPF_ALU_MUL];
378                 fmt = "#%d";
379                 break;
380         case BPF_ALU_DIV | BPF_X:
381                 op = op_table[BPF_ALU_DIV];
382                 fmt = "x";
383                 break;
384         case BPF_ALU_DIV | BPF_K:
385                 op = op_table[BPF_ALU_DIV];
386                 fmt = "#%d";
387                 break;
388         case BPF_ALU_MOD | BPF_X:
389                 op = op_table[BPF_ALU_MOD];
390                 fmt = "x";
391                 break;
392         case BPF_ALU_MOD | BPF_K:
393                 op = op_table[BPF_ALU_MOD];
394                 fmt = "#%d";
395                 break;
396         case BPF_ALU_AND | BPF_X:
397                 op = op_table[BPF_ALU_AND];
398                 fmt = "x";
399                 break;
400         case BPF_ALU_AND | BPF_K:
401                 op = op_table[BPF_ALU_AND];
402                 fmt = "#%#x";
403                 break;
404         case BPF_ALU_OR | BPF_X:
405                 op = op_table[BPF_ALU_OR];
406                 fmt = "x";
407                 break;
408         case BPF_ALU_OR | BPF_K:
409                 op = op_table[BPF_ALU_OR];
410                 fmt = "#%#x";
411                 break;
412         case BPF_ALU_XOR | BPF_X:
413                 op = op_table[BPF_ALU_XOR];
414                 fmt = "x";
415                 break;
416         case BPF_ALU_XOR | BPF_K:
417                 op = op_table[BPF_ALU_XOR];
418                 fmt = "#%#x";
419                 break;
420         default:
421                 op = "nosup";
422                 fmt = "%#x";
423                 val = f.code;
424                 break;
425         }
426 
427         memset(buf, 0, sizeof(buf));
428         snprintf(buf, sizeof(buf), fmt, val);
429         buf[sizeof(buf) - 1] = 0;
430 
431         if ((BPF_CLASS(f.code) == BPF_JMP && BPF_OP(f.code) != BPF_JA))
432                 rl_printf("l%d:\t%s %s, l%d, l%d\n", i, op, buf,
433                           i + 1 + f.jt, i + 1 + f.jf);
434         else
435                 rl_printf("l%d:\t%s %s\n", i, op, buf);
436 }
437 
438 static void bpf_dump_curr(struct bpf_regs *r, struct sock_filter *f)
439 {
440         int i, m = 0;
441 
442         rl_printf("pc:       [%u]\n", r->Pc);
443         rl_printf("code:     [%u] jt[%u] jf[%u] k[%u]\n",
444                   f->code, f->jt, f->jf, f->k);
445         rl_printf("curr:     ");
446         bpf_disasm(*f, r->Pc);
447 
448         if (f->jt || f->jf) {
449                 rl_printf("jt:       ");
450                 bpf_disasm(*(f + f->jt + 1), r->Pc + f->jt + 1);
451                 rl_printf("jf:       ");
452                 bpf_disasm(*(f + f->jf + 1), r->Pc + f->jf + 1);
453         }
454 
455         rl_printf("A:        [%#08x][%u]\n", r->A, r->A);
456         rl_printf("X:        [%#08x][%u]\n", r->X, r->X);
457         if (r->Rs)
458                 rl_printf("ret:      [%#08x][%u]!\n", r->R, r->R);
459 
460         for (i = 0; i < BPF_MEMWORDS; i++) {
461                 if (r->M[i]) {
462                         m++;
463                         rl_printf("M[%d]: [%#08x][%u]\n", i, r->M[i], r->M[i]);
464                 }
465         }
466         if (m == 0)
467                 rl_printf("M[0,%d]:  [%#08x][%u]\n", BPF_MEMWORDS - 1, 0, 0);
468 }
469 
470 static void bpf_dump_pkt(uint8_t *pkt, uint32_t pkt_caplen, uint32_t pkt_len)
471 {
472         if (pkt_caplen != pkt_len)
473                 rl_printf("cap: %u, len: %u\n", pkt_caplen, pkt_len);
474         else
475                 rl_printf("len: %u\n", pkt_len);
476 
477         hex_dump(pkt, pkt_caplen);
478 }
479 
480 static void bpf_disasm_all(const struct sock_filter *f, unsigned int len)
481 {
482         unsigned int i;
483 
484         for (i = 0; i < len; i++)
485                 bpf_disasm(f[i], i);
486 }
487 
488 static void bpf_dump_all(const struct sock_filter *f, unsigned int len)
489 {
490         unsigned int i;
491 
492         rl_printf("/* { op, jt, jf, k }, */\n");
493         for (i = 0; i < len; i++)
494                 rl_printf("{ %#04x, %2u, %2u, %#010x },\n",
495                           f[i].code, f[i].jt, f[i].jf, f[i].k);
496 }
497 
498 static bool bpf_runnable(struct sock_filter *f, unsigned int len)
499 {
500         int sock, ret, i;
501         struct sock_fprog bpf = {
502                 .filter = f,
503                 .len = len,
504         };
505 
506         sock = socket(AF_INET, SOCK_DGRAM, 0);
507         if (sock < 0) {
508                 rl_printf("cannot open socket!\n");
509                 return false;
510         }
511         ret = setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf));
512         close(sock);
513         if (ret < 0) {
514                 rl_printf("program not allowed to run by kernel!\n");
515                 return false;
516         }
517         for (i = 0; i < len; i++) {
518                 if (BPF_CLASS(f[i].code) == BPF_LD &&
519                     f[i].k > SKF_AD_OFF) {
520                         rl_printf("extensions currently not supported!\n");
521                         return false;
522                 }
523         }
524 
525         return true;
526 }
527 
528 static void bpf_reset_breakpoints(void)
529 {
530         int i;
531 
532         for (i = 0; i < array_size(bpf_breakpoints); i++)
533                 bpf_breakpoints[i] = -1;
534 }
535 
536 static void bpf_set_breakpoints(unsigned int where)
537 {
538         int i;
539         bool set = false;
540 
541         for (i = 0; i < array_size(bpf_breakpoints); i++) {
542                 if (bpf_breakpoints[i] == (int) where) {
543                         rl_printf("breakpoint already set!\n");
544                         set = true;
545                         break;
546                 }
547 
548                 if (bpf_breakpoints[i] == -1 && set == false) {
549                         bpf_breakpoints[i] = where;
550                         set = true;
551                 }
552         }
553 
554         if (!set)
555                 rl_printf("too many breakpoints set, reset first!\n");
556 }
557 
558 static void bpf_dump_breakpoints(void)
559 {
560         int i;
561 
562         rl_printf("breakpoints: ");
563 
564         for (i = 0; i < array_size(bpf_breakpoints); i++) {
565                 if (bpf_breakpoints[i] < 0)
566                         continue;
567                 rl_printf("%d ", bpf_breakpoints[i]);
568         }
569 
570         rl_printf("\n");
571 }
572 
573 static void bpf_reset(void)
574 {
575         bpf_regs_len = 0;
576 
577         memset(bpf_regs, 0, sizeof(bpf_regs));
578         memset(&bpf_curr, 0, sizeof(bpf_curr));
579 }
580 
581 static void bpf_safe_regs(void)
582 {
583         memcpy(&bpf_regs[bpf_regs_len++], &bpf_curr, sizeof(bpf_curr));
584 }
585 
586 static bool bpf_restore_regs(int off)
587 {
588         unsigned int index = bpf_regs_len - 1 + off;
589 
590         if (index == 0) {
591                 bpf_reset();
592                 return true;
593         } else if (index < bpf_regs_len) {
594                 memcpy(&bpf_curr, &bpf_regs[index], sizeof(bpf_curr));
595                 bpf_regs_len = index;
596                 return true;
597         } else {
598                 rl_printf("reached bottom of register history stack!\n");
599                 return false;
600         }
601 }
602 
603 static uint32_t extract_u32(uint8_t *pkt, uint32_t off)
604 {
605         uint32_t r;
606 
607         memcpy(&r, &pkt[off], sizeof(r));
608 
609         return ntohl(r);
610 }
611 
612 static uint16_t extract_u16(uint8_t *pkt, uint32_t off)
613 {
614         uint16_t r;
615 
616         memcpy(&r, &pkt[off], sizeof(r));
617 
618         return ntohs(r);
619 }
620 
621 static uint8_t extract_u8(uint8_t *pkt, uint32_t off)
622 {
623         return pkt[off];
624 }
625 
626 static void set_return(struct bpf_regs *r)
627 {
628         r->R = 0;
629         r->Rs = true;
630 }
631 
632 static void bpf_single_step(struct bpf_regs *r, struct sock_filter *f,
633                             uint8_t *pkt, uint32_t pkt_caplen,
634                             uint32_t pkt_len)
635 {
636         uint32_t K = f->k;
637         int d;
638 
639         switch (f->code) {
640         case BPF_RET | BPF_K:
641                 r->R = K;
642                 r->Rs = true;
643                 break;
644         case BPF_RET | BPF_A:
645                 r->R = r->A;
646                 r->Rs = true;
647                 break;
648         case BPF_RET | BPF_X:
649                 r->R = r->X;
650                 r->Rs = true;
651                 break;
652         case BPF_MISC_TAX:
653                 r->X = r->A;
654                 break;
655         case BPF_MISC_TXA:
656                 r->A = r->X;
657                 break;
658         case BPF_ST:
659                 r->M[K] = r->A;
660                 break;
661         case BPF_STX:
662                 r->M[K] = r->X;
663                 break;
664         case BPF_LD_W | BPF_ABS:
665                 d = pkt_caplen - K;
666                 if (d >= sizeof(uint32_t))
667                         r->A = extract_u32(pkt, K);
668                 else
669                         set_return(r);
670                 break;
671         case BPF_LD_H | BPF_ABS:
672                 d = pkt_caplen - K;
673                 if (d >= sizeof(uint16_t))
674                         r->A = extract_u16(pkt, K);
675                 else
676                         set_return(r);
677                 break;
678         case BPF_LD_B | BPF_ABS:
679                 d = pkt_caplen - K;
680                 if (d >= sizeof(uint8_t))
681                         r->A = extract_u8(pkt, K);
682                 else
683                         set_return(r);
684                 break;
685         case BPF_LD_W | BPF_IND:
686                 d = pkt_caplen - (r->X + K);
687                 if (d >= sizeof(uint32_t))
688                         r->A = extract_u32(pkt, r->X + K);
689                 break;
690         case BPF_LD_H | BPF_IND:
691                 d = pkt_caplen - (r->X + K);
692                 if (d >= sizeof(uint16_t))
693                         r->A = extract_u16(pkt, r->X + K);
694                 else
695                         set_return(r);
696                 break;
697         case BPF_LD_B | BPF_IND:
698                 d = pkt_caplen - (r->X + K);
699                 if (d >= sizeof(uint8_t))
700                         r->A = extract_u8(pkt, r->X + K);
701                 else
702                         set_return(r);
703                 break;
704         case BPF_LDX_B | BPF_MSH:
705                 d = pkt_caplen - K;
706                 if (d >= sizeof(uint8_t)) {
707                         r->X = extract_u8(pkt, K);
708                         r->X = (r->X & 0xf) << 2;
709                 } else
710                         set_return(r);
711                 break;
712         case BPF_LD_W | BPF_LEN:
713                 r->A = pkt_len;
714                 break;
715         case BPF_LDX_W | BPF_LEN:
716                 r->A = pkt_len;
717                 break;
718         case BPF_LD | BPF_IMM:
719                 r->A = K;
720                 break;
721         case BPF_LDX | BPF_IMM:
722                 r->X = K;
723                 break;
724         case BPF_LD | BPF_MEM:
725                 r->A = r->M[K];
726                 break;
727         case BPF_LDX | BPF_MEM:
728                 r->X = r->M[K];
729                 break;
730         case BPF_JMP_JA:
731                 r->Pc += K;
732                 break;
733         case BPF_JMP_JGT | BPF_X:
734                 r->Pc += r->A > r->X ? f->jt : f->jf;
735                 break;
736         case BPF_JMP_JGT | BPF_K:
737                 r->Pc += r->A > K ? f->jt : f->jf;
738                 break;
739         case BPF_JMP_JGE | BPF_X:
740                 r->Pc += r->A >= r->X ? f->jt : f->jf;
741                 break;
742         case BPF_JMP_JGE | BPF_K:
743                 r->Pc += r->A >= K ? f->jt : f->jf;
744                 break;
745         case BPF_JMP_JEQ | BPF_X:
746                 r->Pc += r->A == r->X ? f->jt : f->jf;
747                 break;
748         case BPF_JMP_JEQ | BPF_K:
749                 r->Pc += r->A == K ? f->jt : f->jf;
750                 break;
751         case BPF_JMP_JSET | BPF_X:
752                 r->Pc += r->A & r->X ? f->jt : f->jf;
753                 break;
754         case BPF_JMP_JSET | BPF_K:
755                 r->Pc += r->A & K ? f->jt : f->jf;
756                 break;
757         case BPF_ALU_NEG:
758                 r->A = -r->A;
759                 break;
760         case BPF_ALU_LSH | BPF_X:
761                 r->A <<= r->X;
762                 break;
763         case BPF_ALU_LSH | BPF_K:
764                 r->A <<= K;
765                 break;
766         case BPF_ALU_RSH | BPF_X:
767                 r->A >>= r->X;
768                 break;
769         case BPF_ALU_RSH | BPF_K:
770                 r->A >>= K;
771                 break;
772         case BPF_ALU_ADD | BPF_X:
773                 r->A += r->X;
774                 break;
775         case BPF_ALU_ADD | BPF_K:
776                 r->A += K;
777                 break;
778         case BPF_ALU_SUB | BPF_X:
779                 r->A -= r->X;
780                 break;
781         case BPF_ALU_SUB | BPF_K:
782                 r->A -= K;
783                 break;
784         case BPF_ALU_MUL | BPF_X:
785                 r->A *= r->X;
786                 break;
787         case BPF_ALU_MUL | BPF_K:
788                 r->A *= K;
789                 break;
790         case BPF_ALU_DIV | BPF_X:
791         case BPF_ALU_MOD | BPF_X:
792                 if (r->X == 0) {
793                         set_return(r);
794                         break;
795                 }
796                 goto do_div;
797         case BPF_ALU_DIV | BPF_K:
798         case BPF_ALU_MOD | BPF_K:
799                 if (K == 0) {
800                         set_return(r);
801                         break;
802                 }
803 do_div:
804                 switch (f->code) {
805                 case BPF_ALU_DIV | BPF_X:
806                         r->A /= r->X;
807                         break;
808                 case BPF_ALU_DIV | BPF_K:
809                         r->A /= K;
810                         break;
811                 case BPF_ALU_MOD | BPF_X:
812                         r->A %= r->X;
813                         break;
814                 case BPF_ALU_MOD | BPF_K:
815                         r->A %= K;
816                         break;
817                 }
818                 break;
819         case BPF_ALU_AND | BPF_X:
820                 r->A &= r->X;
821                 break;
822         case BPF_ALU_AND | BPF_K:
823                 r->A &= K;
824                 break;
825         case BPF_ALU_OR | BPF_X:
826                 r->A |= r->X;
827                 break;
828         case BPF_ALU_OR | BPF_K:
829                 r->A |= K;
830                 break;
831         case BPF_ALU_XOR | BPF_X:
832                 r->A ^= r->X;
833                 break;
834         case BPF_ALU_XOR | BPF_K:
835                 r->A ^= K;
836                 break;
837         }
838 }
839 
840 static bool bpf_pc_has_breakpoint(uint16_t pc)
841 {
842         int i;
843 
844         for (i = 0; i < array_size(bpf_breakpoints); i++) {
845                 if (bpf_breakpoints[i] < 0)
846                         continue;
847                 if (bpf_breakpoints[i] == pc)
848                         return true;
849         }
850 
851         return false;
852 }
853 
854 static bool bpf_handle_breakpoint(struct bpf_regs *r, struct sock_filter *f,
855                                   uint8_t *pkt, uint32_t pkt_caplen,
856                                   uint32_t pkt_len)
857 {
858         rl_printf("-- register dump --\n");
859         bpf_dump_curr(r, &f[r->Pc]);
860         rl_printf("-- packet dump --\n");
861         bpf_dump_pkt(pkt, pkt_caplen, pkt_len);
862         rl_printf("(breakpoint)\n");
863         return true;
864 }
865 
866 static int bpf_run_all(struct sock_filter *f, uint16_t bpf_len, uint8_t *pkt,
867                        uint32_t pkt_caplen, uint32_t pkt_len)
868 {
869         bool stop = false;
870 
871         while (bpf_curr.Rs == false && stop == false) {
872                 bpf_safe_regs();
873 
874                 if (bpf_pc_has_breakpoint(bpf_curr.Pc))
875                         stop = bpf_handle_breakpoint(&bpf_curr, f, pkt,
876                                                      pkt_caplen, pkt_len);
877 
878                 bpf_single_step(&bpf_curr, &f[bpf_curr.Pc], pkt, pkt_caplen,
879                                 pkt_len);
880                 bpf_curr.Pc++;
881         }
882 
883         return stop ? -1 : bpf_curr.R;
884 }
885 
886 static int bpf_run_stepping(struct sock_filter *f, uint16_t bpf_len,
887                             uint8_t *pkt, uint32_t pkt_caplen,
888                             uint32_t pkt_len, int next)
889 {
890         bool stop = false;
891         int i = 1;
892 
893         while (bpf_curr.Rs == false && stop == false) {
894                 bpf_safe_regs();
895 
896                 if (i++ == next)
897                         stop = bpf_handle_breakpoint(&bpf_curr, f, pkt,
898                                                      pkt_caplen, pkt_len);
899 
900                 bpf_single_step(&bpf_curr, &f[bpf_curr.Pc], pkt, pkt_caplen,
901                                 pkt_len);
902                 bpf_curr.Pc++;
903         }
904 
905         return stop ? -1 : bpf_curr.R;
906 }
907 
908 static bool pcap_loaded(void)
909 {
910         if (pcap_fd < 0)
911                 rl_printf("no pcap file loaded!\n");
912 
913         return pcap_fd >= 0;
914 }
915 
916 static struct pcap_pkthdr *pcap_curr_pkt(void)
917 {
918         return (void *) pcap_ptr_va_curr;
919 }
920 
921 static bool pcap_next_pkt(void)
922 {
923         struct pcap_pkthdr *hdr = pcap_curr_pkt();
924 
925         if (pcap_ptr_va_curr + sizeof(*hdr) -
926             pcap_ptr_va_start >= pcap_map_size)
927                 return false;
928         if (hdr->caplen == 0 || hdr->len == 0 || hdr->caplen > hdr->len)
929                 return false;
930         if (pcap_ptr_va_curr + sizeof(*hdr) + hdr->caplen -
931             pcap_ptr_va_start >= pcap_map_size)
932                 return false;
933 
934         pcap_ptr_va_curr += (sizeof(*hdr) + hdr->caplen);
935         return true;
936 }
937 
938 static void pcap_reset_pkt(void)
939 {
940         pcap_ptr_va_curr = pcap_ptr_va_start + sizeof(struct pcap_filehdr);
941 }
942 
943 static int try_load_pcap(const char *file)
944 {
945         struct pcap_filehdr *hdr;
946         struct stat sb;
947         int ret;
948 
949         pcap_fd = open(file, O_RDONLY);
950         if (pcap_fd < 0) {
951                 rl_printf("cannot open pcap [%s]!\n", strerror(errno));
952                 return CMD_ERR;
953         }
954 
955         ret = fstat(pcap_fd, &sb);
956         if (ret < 0) {
957                 rl_printf("cannot fstat pcap file!\n");
958                 return CMD_ERR;
959         }
960 
961         if (!S_ISREG(sb.st_mode)) {
962                 rl_printf("not a regular pcap file, duh!\n");
963                 return CMD_ERR;
964         }
965 
966         pcap_map_size = sb.st_size;
967         if (pcap_map_size <= sizeof(struct pcap_filehdr)) {
968                 rl_printf("pcap file too small!\n");
969                 return CMD_ERR;
970         }
971 
972         pcap_ptr_va_start = mmap(NULL, pcap_map_size, PROT_READ,
973                                  MAP_SHARED | MAP_LOCKED, pcap_fd, 0);
974         if (pcap_ptr_va_start == MAP_FAILED) {
975                 rl_printf("mmap of file failed!");
976                 return CMD_ERR;
977         }
978 
979         hdr = (void *) pcap_ptr_va_start;
980         if (hdr->magic != TCPDUMP_MAGIC) {
981                 rl_printf("wrong pcap magic!\n");
982                 return CMD_ERR;
983         }
984 
985         pcap_reset_pkt();
986 
987         return CMD_OK;
988 
989 }
990 
991 static void try_close_pcap(void)
992 {
993         if (pcap_fd >= 0) {
994                 munmap(pcap_ptr_va_start, pcap_map_size);
995                 close(pcap_fd);
996 
997                 pcap_ptr_va_start = pcap_ptr_va_curr = NULL;
998                 pcap_map_size = 0;
999                 pcap_packet = 0;
1000                 pcap_fd = -1;
1001         }
1002 }
1003 
1004 static int cmd_load_bpf(char *bpf_string)
1005 {
1006         char sp, *token, separator = ',';
1007         unsigned short bpf_len, i = 0;
1008         struct sock_filter tmp;
1009 
1010         bpf_prog_len = 0;
1011         memset(bpf_image, 0, sizeof(bpf_image));
1012 
1013         if (sscanf(bpf_string, "%hu%c", &bpf_len, &sp) != 2 ||
1014             sp != separator || bpf_len > BPF_MAXINSNS || bpf_len == 0) {
1015                 rl_printf("syntax error in head length encoding!\n");
1016                 return CMD_ERR;
1017         }
1018 
1019         token = bpf_string;
1020         while ((token = strchr(token, separator)) && (++token)[0]) {
1021                 if (i >= bpf_len) {
1022                         rl_printf("program exceeds encoded length!\n");
1023                         return CMD_ERR;
1024                 }
1025 
1026                 if (sscanf(token, "%hu %hhu %hhu %u,",
1027                            &tmp.code, &tmp.jt, &tmp.jf, &tmp.k) != 4) {
1028                         rl_printf("syntax error at instruction %d!\n", i);
1029                         return CMD_ERR;
1030                 }
1031 
1032                 bpf_image[i].code = tmp.code;
1033                 bpf_image[i].jt = tmp.jt;
1034                 bpf_image[i].jf = tmp.jf;
1035                 bpf_image[i].k = tmp.k;
1036 
1037                 i++;
1038         }
1039 
1040         if (i != bpf_len) {
1041                 rl_printf("syntax error exceeding encoded length!\n");
1042                 return CMD_ERR;
1043         } else
1044                 bpf_prog_len = bpf_len;
1045         if (!bpf_runnable(bpf_image, bpf_prog_len))
1046                 bpf_prog_len = 0;
1047 
1048         return CMD_OK;
1049 }
1050 
1051 static int cmd_load_pcap(char *file)
1052 {
1053         char *file_trim, *tmp;
1054 
1055         file_trim = strtok_r(file, " ", &tmp);
1056         if (file_trim == NULL)
1057                 return CMD_ERR;
1058 
1059         try_close_pcap();
1060 
1061         return try_load_pcap(file_trim);
1062 }
1063 
1064 static int cmd_load(char *arg)
1065 {
1066         char *subcmd, *cont = NULL, *tmp = strdup(arg);
1067         int ret = CMD_OK;
1068 
1069         subcmd = strtok_r(tmp, " ", &cont);
1070         if (subcmd == NULL)
1071                 goto out;
1072         if (matches(subcmd, "bpf") == 0) {
1073                 bpf_reset();
1074                 bpf_reset_breakpoints();
1075 
1076                 if (!cont)
1077                         ret = CMD_ERR;
1078                 else
1079                         ret = cmd_load_bpf(cont);
1080         } else if (matches(subcmd, "pcap") == 0) {
1081                 ret = cmd_load_pcap(cont);
1082         } else {
1083 out:
1084                 rl_printf("bpf <code>:  load bpf code\n");
1085                 rl_printf("pcap <file>: load pcap file\n");
1086                 ret = CMD_ERR;
1087         }
1088 
1089         free(tmp);
1090         return ret;
1091 }
1092 
1093 static int cmd_step(char *num)
1094 {
1095         struct pcap_pkthdr *hdr;
1096         int steps, ret;
1097 
1098         if (!bpf_prog_loaded() || !pcap_loaded())
1099                 return CMD_ERR;
1100 
1101         steps = strtol(num, NULL, 10);
1102         if (steps == 0 || strlen(num) == 0)
1103                 steps = 1;
1104         if (steps < 0) {
1105                 if (!bpf_restore_regs(steps))
1106                         return CMD_ERR;
1107                 steps = 1;
1108         }
1109 
1110         hdr = pcap_curr_pkt();
1111         ret = bpf_run_stepping(bpf_image, bpf_prog_len,
1112                                (uint8_t *) hdr + sizeof(*hdr),
1113                                hdr->caplen, hdr->len, steps);
1114         if (ret >= 0 || bpf_curr.Rs) {
1115                 bpf_reset();
1116                 if (!pcap_next_pkt()) {
1117                         rl_printf("(going back to first packet)\n");
1118                         pcap_reset_pkt();
1119                 } else {
1120                         rl_printf("(next packet)\n");
1121                 }
1122         }
1123 
1124         return CMD_OK;
1125 }
1126 
1127 static int cmd_select(char *num)
1128 {
1129         unsigned int which, i;
1130         bool have_next = true;
1131 
1132         if (!pcap_loaded() || strlen(num) == 0)
1133                 return CMD_ERR;
1134 
1135         which = strtoul(num, NULL, 10);
1136         if (which == 0) {
1137                 rl_printf("packet count starts with 1, clamping!\n");
1138                 which = 1;
1139         }
1140 
1141         pcap_reset_pkt();
1142         bpf_reset();
1143 
1144         for (i = 0; i < which && (have_next = pcap_next_pkt()); i++)
1145                 /* noop */;
1146         if (!have_next || pcap_curr_pkt() == NULL) {
1147                 rl_printf("no packet #%u available!\n", which);
1148                 pcap_reset_pkt();
1149                 return CMD_ERR;
1150         }
1151 
1152         return CMD_OK;
1153 }
1154 
1155 static int cmd_breakpoint(char *subcmd)
1156 {
1157         if (!bpf_prog_loaded())
1158                 return CMD_ERR;
1159         if (strlen(subcmd) == 0)
1160                 bpf_dump_breakpoints();
1161         else if (matches(subcmd, "reset") == 0)
1162                 bpf_reset_breakpoints();
1163         else {
1164                 unsigned int where = strtoul(subcmd, NULL, 10);
1165 
1166                 if (where < bpf_prog_len) {
1167                         bpf_set_breakpoints(where);
1168                         rl_printf("breakpoint at: ");
1169                         bpf_disasm(bpf_image[where], where);
1170                 }
1171         }
1172 
1173         return CMD_OK;
1174 }
1175 
1176 static int cmd_run(char *num)
1177 {
1178         static uint32_t pass, fail;
1179         bool has_limit = true;
1180         int pkts = 0, i = 0;
1181 
1182         if (!bpf_prog_loaded() || !pcap_loaded())
1183                 return CMD_ERR;
1184 
1185         pkts = strtol(num, NULL, 10);
1186         if (pkts == 0 || strlen(num) == 0)
1187                 has_limit = false;
1188 
1189         do {
1190                 struct pcap_pkthdr *hdr = pcap_curr_pkt();
1191                 int ret = bpf_run_all(bpf_image, bpf_prog_len,
1192                                       (uint8_t *) hdr + sizeof(*hdr),
1193                                       hdr->caplen, hdr->len);
1194                 if (ret > 0)
1195                         pass++;
1196                 else if (ret == 0)
1197                         fail++;
1198                 else
1199                         return CMD_OK;
1200                 bpf_reset();
1201         } while (pcap_next_pkt() && (!has_limit || (has_limit && ++i < pkts)));
1202 
1203         rl_printf("bpf passes:%u fails:%u\n", pass, fail);
1204 
1205         pcap_reset_pkt();
1206         bpf_reset();
1207 
1208         pass = fail = 0;
1209         return CMD_OK;
1210 }
1211 
1212 static int cmd_disassemble(char *line_string)
1213 {
1214         bool single_line = false;
1215         unsigned long line;
1216 
1217         if (!bpf_prog_loaded())
1218                 return CMD_ERR;
1219         if (strlen(line_string) > 0 &&
1220             (line = strtoul(line_string, NULL, 10)) < bpf_prog_len)
1221                 single_line = true;
1222         if (single_line)
1223                 bpf_disasm(bpf_image[line], line);
1224         else
1225                 bpf_disasm_all(bpf_image, bpf_prog_len);
1226 
1227         return CMD_OK;
1228 }
1229 
1230 static int cmd_dump(char *dontcare)
1231 {
1232         if (!bpf_prog_loaded())
1233                 return CMD_ERR;
1234 
1235         bpf_dump_all(bpf_image, bpf_prog_len);
1236 
1237         return CMD_OK;
1238 }
1239 
1240 static int cmd_quit(char *dontcare)
1241 {
1242         return CMD_EX;
1243 }
1244 
1245 static const struct shell_cmd cmds[] = {
1246         { .name = "load", .func = cmd_load },
1247         { .name = "select", .func = cmd_select },
1248         { .name = "step", .func = cmd_step },
1249         { .name = "run", .func = cmd_run },
1250         { .name = "breakpoint", .func = cmd_breakpoint },
1251         { .name = "disassemble", .func = cmd_disassemble },
1252         { .name = "dump", .func = cmd_dump },
1253         { .name = "quit", .func = cmd_quit },
1254 };
1255 
1256 static int execf(char *arg)
1257 {
1258         char *cmd, *cont, *tmp = strdup(arg);
1259         int i, ret = 0, len;
1260 
1261         cmd = strtok_r(tmp, " ", &cont);
1262         if (cmd == NULL)
1263                 goto out;
1264         len = strlen(cmd);
1265         for (i = 0; i < array_size(cmds); i++) {
1266                 if (len != strlen(cmds[i].name))
1267                         continue;
1268                 if (strncmp(cmds[i].name, cmd, len) == 0) {
1269                         ret = cmds[i].func(cont);
1270                         break;
1271                 }
1272         }
1273 out:
1274         free(tmp);
1275         return ret;
1276 }
1277 
1278 static char *shell_comp_gen(const char *buf, int state)
1279 {
1280         static int list_index, len;
1281 
1282         if (!state) {
1283                 list_index = 0;
1284                 len = strlen(buf);
1285         }
1286 
1287         for (; list_index < array_size(cmds); ) {
1288                 const char *name = cmds[list_index].name;
1289 
1290                 list_index++;
1291                 if (strncmp(name, buf, len) == 0)
1292                         return strdup(name);
1293         }
1294 
1295         return NULL;
1296 }
1297 
1298 static char **shell_completion(const char *buf, int start, int end)
1299 {
1300         char **matches = NULL;
1301 
1302         if (start == 0)
1303                 matches = rl_completion_matches(buf, shell_comp_gen);
1304 
1305         return matches;
1306 }
1307 
1308 static void intr_shell(int sig)
1309 {
1310         if (rl_end)
1311                 rl_kill_line(-1, 0);
1312 
1313         rl_crlf();
1314         rl_refresh_line(0, 0);
1315         rl_free_line_state();
1316 }
1317 
1318 static void init_shell(FILE *fin, FILE *fout)
1319 {
1320         char file[128];
1321 
1322         snprintf(file, sizeof(file), "%s/.bpf_dbg_history", getenv("HOME"));
1323         read_history(file);
1324 
1325         rl_instream = fin;
1326         rl_outstream = fout;
1327 
1328         rl_readline_name = "bpf_dbg";
1329         rl_terminal_name = getenv("TERM");
1330 
1331         rl_catch_signals = 0;
1332         rl_catch_sigwinch = 1;
1333 
1334         rl_attempted_completion_function = shell_completion;
1335 
1336         rl_bind_key('\t', rl_complete);
1337 
1338         rl_bind_key_in_map('\t', rl_complete, emacs_meta_keymap);
1339         rl_bind_key_in_map('\033', rl_complete, emacs_meta_keymap);
1340 
1341         snprintf(file, sizeof(file), "%s/.bpf_dbg_init", getenv("HOME"));
1342         rl_read_init_file(file);
1343 
1344         rl_prep_terminal(0);
1345         rl_set_signals();
1346 
1347         signal(SIGINT, intr_shell);
1348 }
1349 
1350 static void exit_shell(FILE *fin, FILE *fout)
1351 {
1352         char file[128];
1353 
1354         snprintf(file, sizeof(file), "%s/.bpf_dbg_history", getenv("HOME"));
1355         write_history(file);
1356 
1357         clear_history();
1358         rl_deprep_terminal();
1359 
1360         try_close_pcap();
1361 
1362         if (fin != stdin)
1363                 fclose(fin);
1364         if (fout != stdout)
1365                 fclose(fout);
1366 }
1367 
1368 static int run_shell_loop(FILE *fin, FILE *fout)
1369 {
1370         char *buf;
1371 
1372         init_shell(fin, fout);
1373 
1374         while ((buf = readline("> ")) != NULL) {
1375                 int ret = execf(buf);
1376                 if (ret == CMD_EX)
1377                         break;
1378                 if (ret == CMD_OK && strlen(buf) > 0)
1379                         add_history(buf);
1380 
1381                 free(buf);
1382         }
1383 
1384         exit_shell(fin, fout);
1385         return 0;
1386 }
1387 
1388 int main(int argc, char **argv)
1389 {
1390         FILE *fin = NULL, *fout = NULL;
1391 
1392         if (argc >= 2)
1393                 fin = fopen(argv[1], "r");
1394         if (argc >= 3)
1395                 fout = fopen(argv[2], "w");
1396 
1397         return run_shell_loop(fin ? : stdin, fout ? : stdout);
1398 }
1399 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp