← Back to branch summary

~ubuntu-branches/debian/sid/ppp/sid

« back to all changes in this revision

Viewing changes to pppdump/pppdump.c

  • Committer: Bazaar Package Importer
  • Author(s): Eddy Petrișor
  • Date: 2007-03-17 22:31:45 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070317223145-felzh5yrmh8fwi8t
Tags: 2.4.4rel-8
http://bugs.debian.org/415077
* urgency high since fixes an RC bug
* make sure the /etc/resolv.conf file is world readable (Closes: #415077)

Show diffs side-by-side

added added

removed removed

Lines of Context:
pppdump/pppdump.c
1
 
/*
2
 
 * pppdump - print out the contents of a record file generated by
3
 
 * pppd in readable form.
4
 
 *
5
 
 * Copyright (C) 1999  Paul Mackerras.  All rights reserved.
6
 
 *
7
 
 * Redistribution and use in source and binary forms are permitted
8
 
 * provided that the above copyright notice and this paragraph are
9
 
 * duplicated in all such forms.  The name of the author
10
 
 * may not be used to endorse or promote products derived
11
 
 * from this software without specific prior written permission.
12
 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
13
 
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
14
 
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
15
 
 */
16
 
#include <stdio.h>
17
 
#include <unistd.h>
18
 
#include <time.h>
19
 
#include <sys/types.h>
20
 
#include "ppp_defs.h"
21
 
#include "ppp-comp.h"
22
 
 
23
 
int hexmode;
24
 
int pppmode;
25
 
int reverse;
26
 
int decompress;
27
 
int mru = 1500;
28
 
int abs_times;
29
 
time_t start_time;
30
 
int start_time_tenths;
31
 
int tot_sent, tot_rcvd;
32
 
 
33
 
extern int optind;
34
 
extern char *optarg;
35
 
 
36
 
main(ac, av)
37
 
    int ac;
38
 
    char **av;
39
 
{
40
 
    int i;
41
 
    char *p;
42
 
    FILE *f;
43
 
 
44
 
    while ((i = getopt(ac, av, "hprdm:a")) != -1) {
45
 
        switch (i) {
46
 
        case 'h':
47
 
            hexmode = 1;
48
 
            break;
49
 
        case 'p':
50
 
            pppmode = 1;
51
 
            break;
52
 
        case 'r':
53
 
            reverse = 1;
54
 
            break;
55
 
        case 'd':
56
 
            decompress = 1;
57
 
            break;
58
 
        case 'm':
59
 
            mru = atoi(optarg);
60
 
            break;
61
 
        case 'a':
62
 
            abs_times = 1;
63
 
            break;
64
 
        default:
65
 
            fprintf(stderr, "Usage: %s [-h | -p[d]] [-r] [-m mru] [-a] [file ...]\n", av[0]);
66
 
            exit(1);
67
 
        }
68
 
    }
69
 
    if (optind >= ac)
70
 
        dumplog(stdin);
71
 
    else {
72
 
        for (i = optind; i < ac; ++i) {
73
 
            p = av[i];
74
 
            if ((f = fopen(p, "r")) == NULL) {
75
 
                perror(p);
76
 
                exit(1);
77
 
            }
78
 
            if (pppmode)
79
 
                dumpppp(f);
80
 
            else
81
 
                dumplog(f);
82
 
            fclose(f);
83
 
        }
84
 
    }
85
 
    exit(0);
86
 
}
87
 
 
88
 
dumplog(f)
89
 
    FILE *f;
90
 
{
91
 
    int c, n, k, col;
92
 
    int nb, c2;
93
 
    unsigned char buf[16];
94
 
 
95
 
    while ((c = getc(f)) != EOF) {
96
 
        switch (c) {
97
 
        case 1:
98
 
        case 2:
99
 
            if (reverse)
100
 
                c = 3 - c;
101
 
            printf("%s %c", c==1? "sent": "rcvd", hexmode? ' ': '"');
102
 
            col = 6;
103
 
            n = getc(f);
104
 
            n = (n << 8) + getc(f);
105
 
            *(c==1? &tot_sent: &tot_rcvd) += n;
106
 
            nb = 0;
107
 
            for (; n > 0; --n) {
108
 
                c = getc(f);
109
 
                if (c == EOF) {
110
 
                    printf("\nEOF\n");
111
 
                    exit(0);
112
 
                }
113
 
                if (hexmode) {
114
 
                    if (nb >= 16) {
115
 
                        printf("  ");
116
 
                        for (k = 0; k < nb; ++k) {
117
 
                            c2 = buf[k];
118
 
                            putchar((' ' <= c2 && c2 <= '~')? c2: '.');
119
 
                        }
120
 
                        printf("\n      ");
121
 
                        nb = 0;
122
 
                    }
123
 
                    buf[nb++] = c;
124
 
                    printf(" %.2x", c);
125
 
                } else {
126
 
                    k = (' ' <= c && c <= '~')? (c != '\\' && c != '"')? 1: 2: 3;
127
 
                    if ((col += k) >= 78) {
128
 
                        printf("\n      ");
129
 
                        col = 6 + k;
130
 
                    }
131
 
                    switch (k) {
132
 
                    case 1:
133
 
                        putchar(c);
134
 
                        break;
135
 
                    case 2:
136
 
                        printf("\\%c", c);
137
 
                        break;
138
 
                    case 3:
139
 
                        printf("\\%.2x", c);
140
 
                        break;
141
 
                    }
142
 
                }
143
 
            }
144
 
            if (hexmode) {
145
 
                for (k = nb; k < 16; ++k)
146
 
                    printf("   ");
147
 
                printf("  ");
148
 
                for (k = 0; k < nb; ++k) {
149
 
                    c2 = buf[k];
150
 
                    putchar((' ' <= c2 && c2 <= '~')? c2: '.');
151
 
                }
152
 
            } else
153
 
                putchar('"');
154
 
            printf("\n");
155
 
            break;
156
 
        case 3:
157
 
        case 4:
158
 
            printf("end %s\n", c==3? "send": "recv");
159
 
            break;
160
 
        case 5:
161
 
        case 6:
162
 
        case 7:
163
 
            show_time(f, c);
164
 
            break;
165
 
        default:
166
 
            printf("?%.2x\n");
167
 
        }
168
 
    }
169
 
}
170
 
 
171
 
/*
172
 
 * FCS lookup table as calculated by genfcstab.
173
 
 */
174
 
static u_short fcstab[256] = {
175
 
        0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
176
 
        0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
177
 
        0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
178
 
        0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
179
 
        0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
180
 
        0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
181
 
        0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
182
 
        0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
183
 
        0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
184
 
        0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
185
 
        0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
186
 
        0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
187
 
        0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
188
 
        0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
189
 
        0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
190
 
        0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
191
 
        0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
192
 
        0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
193
 
        0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
194
 
        0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
195
 
        0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
196
 
        0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
197
 
        0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
198
 
        0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
199
 
        0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
200
 
        0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
201
 
        0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
202
 
        0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
203
 
        0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
204
 
        0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
205
 
        0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
206
 
        0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
207
 
};
208
 
 
209
 
struct pkt {
210
 
    int cnt;
211
 
    int esc;
212
 
    int flags;
213
 
    struct compressor *comp;
214
 
    void *state;
215
 
    unsigned char buf[8192];
216
 
} spkt, rpkt;
217
 
 
218
 
/* Values for flags */
219
 
#define CCP_ISUP        1
220
 
#define CCP_ERROR       2
221
 
#define CCP_FATALERROR  4
222
 
#define CCP_ERR         (CCP_ERROR | CCP_FATALERROR)
223
 
#define CCP_DECOMP_RUN  8
224
 
 
225
 
unsigned char dbuf[8192];
226
 
 
227
 
dumpppp(f)
228
 
    FILE *f;
229
 
{
230
 
    int c, n, k;
231
 
    int nb, nl, dn, proto, rv;
232
 
    char *dir, *q;
233
 
    unsigned char *p, *r, *endp;
234
 
    unsigned char *d;
235
 
    unsigned short fcs;
236
 
    struct pkt *pkt;
237
 
 
238
 
    spkt.cnt = rpkt.cnt = 0;
239
 
    spkt.esc = rpkt.esc = 0;
240
 
    while ((c = getc(f)) != EOF) {
241
 
        switch (c) {
242
 
        case 1:
243
 
        case 2:
244
 
            if (reverse)
245
 
                c = 3 - c;
246
 
            dir = c==1? "sent": "rcvd";
247
 
            pkt = c==1? &spkt: &rpkt;
248
 
            n = getc(f);
249
 
            n = (n << 8) + getc(f);
250
 
            *(c==1? &tot_sent: &tot_rcvd) += n;
251
 
            for (; n > 0; --n) {
252
 
                c = getc(f);
253
 
                switch (c) {
254
 
                case EOF:
255
 
                    printf("\nEOF\n");
256
 
                    if (spkt.cnt > 0)
257
 
                        printf("[%d bytes in incomplete send packet]\n",
258
 
                               spkt.cnt);
259
 
                    if (rpkt.cnt > 0)
260
 
                        printf("[%d bytes in incomplete recv packet]\n",
261
 
                               rpkt.cnt);
262
 
                    exit(0);
263
 
                case '~':
264
 
                    if (pkt->cnt > 0) {
265
 
                        q = dir;
266
 
                        if (pkt->esc) {
267
 
                            printf("%s aborted packet:\n     ", dir);
268
 
                            q = "    ";
269
 
                        }
270
 
                        nb = pkt->cnt;
271
 
                        p = pkt->buf;
272
 
                        pkt->cnt = 0;
273
 
                        pkt->esc = 0;
274
 
                        if (nb <= 2) {
275
 
                            printf("%s short packet [%d bytes]:", q, nb);
276
 
                            for (k = 0; k < nb; ++k)
277
 
                                printf(" %.2x", p[k]);
278
 
                            printf("\n");
279
 
                            break;
280
 
                        }
281
 
                        fcs = PPP_INITFCS;
282
 
                        for (k = 0; k < nb; ++k)
283
 
                            fcs = PPP_FCS(fcs, p[k]);
284
 
                        fcs &= 0xFFFF;
285
 
                        nb -= 2;
286
 
                        endp = p + nb;
287
 
                        r = p;
288
 
                        if (r[0] == 0xff && r[1] == 3)
289
 
                            r += 2;
290
 
                        if ((r[0] & 1) == 0)
291
 
                            ++r;
292
 
                        ++r;
293
 
                        if (endp - r > mru)
294
 
                            printf("     ERROR: length (%d) > MRU (%d)\n",
295
 
                                   endp - r, mru);
296
 
                        if (decompress && fcs == PPP_GOODFCS) {
297
 
                            /* See if this is a CCP or compressed packet */
298
 
                            d = dbuf;
299
 
                            r = p;
300
 
                            if (r[0] == 0xff && r[1] == 3) {
301
 
                                *d++ = *r++;
302
 
                                *d++ = *r++;
303
 
                            }
304
 
                            proto = r[0];
305
 
                            if ((proto & 1) == 0)
306
 
                                proto = (proto << 8) + r[1];
307
 
                            if (proto == PPP_CCP) {
308
 
                                handle_ccp(pkt, r + 2, endp - r - 2);
309
 
                            } else if (proto == PPP_COMP) {
310
 
                                if ((pkt->flags & CCP_ISUP)
311
 
                                    && (pkt->flags & CCP_DECOMP_RUN)
312
 
                                    && pkt->state
313
 
                                    && (pkt->flags & CCP_ERR) == 0) {
314
 
                                    rv = pkt->comp->decompress(pkt->state, r,
315
 
                                                        endp - r, d, &dn);
316
 
                                    switch (rv) {
317
 
                                    case DECOMP_OK:
318
 
                                        p = dbuf;
319
 
                                        nb = d + dn - p;
320
 
                                        if ((d[0] & 1) == 0)
321
 
                                            --dn;
322
 
                                        --dn;
323
 
                                        if (dn > mru)
324
 
                                            printf("     ERROR: decompressed length (%d) > MRU (%d)\n", dn, mru);
325
 
                                        break;
326
 
                                    case DECOMP_ERROR:
327
 
                                        printf("     DECOMPRESSION ERROR\n");
328
 
                                        pkt->flags |= CCP_ERROR;
329
 
                                        break;
330
 
                                    case DECOMP_FATALERROR:
331
 
                                        printf("     FATAL DECOMPRESSION ERROR\n");
332
 
                                        pkt->flags |= CCP_FATALERROR;
333
 
                                        break;
334
 
                                    }
335
 
                                }
336
 
                            } else if (pkt->state
337
 
                                       && (pkt->flags & CCP_DECOMP_RUN)) {
338
 
                                pkt->comp->incomp(pkt->state, r, endp - r);
339
 
                            }
340
 
                        }
341
 
                        do {
342
 
                            nl = nb < 16? nb: 16;
343
 
                            printf("%s ", q);
344
 
                            for (k = 0; k < nl; ++k)
345
 
                                printf(" %.2x", p[k]);
346
 
                            for (; k < 16; ++k)
347
 
                                printf("   ");
348
 
                            printf("  ");
349
 
                            for (k = 0; k < nl; ++k) {
350
 
                                c = p[k];
351
 
                                putchar((' ' <= c && c <= '~')? c: '.');
352
 
                            }
353
 
                            printf("\n");
354
 
                            q = "    ";
355
 
                            p += nl;
356
 
                            nb -= nl;
357
 
                        } while (nb > 0);
358
 
                        if (fcs != PPP_GOODFCS)
359
 
                            printf("     BAD FCS: (residue = %x)\n", fcs);
360
 
                    }
361
 
                    break;
362
 
                case '}':
363
 
                    if (!pkt->esc) {
364
 
                        pkt->esc = 1;
365
 
                        break;
366
 
                    }
367
 
                    /* else fall through */
368
 
                default:
369
 
                    if (pkt->esc) {
370
 
                        c ^= 0x20;
371
 
                        pkt->esc = 0;
372
 
                    }
373
 
                    pkt->buf[pkt->cnt++] = c;
374
 
                    break;
375
 
                }
376
 
            }
377
 
            break;
378
 
        case 3:
379
 
        case 4:
380
 
            if (reverse)
381
 
                c = 7 - c;
382
 
            dir = c==3? "send": "recv";
383
 
            pkt = c==3? &spkt: &rpkt;
384
 
            printf("end %s", dir);
385
 
            if (pkt->cnt > 0)
386
 
                printf("  [%d bytes in incomplete packet]", pkt->cnt);
387
 
            printf("\n");
388
 
            break;
389
 
        case 5:
390
 
        case 6:
391
 
        case 7:
392
 
            show_time(f, c);
393
 
            break;
394
 
        default:
395
 
            printf("?%.2x\n");
396
 
        }
397
 
    }
398
 
}
399
 
 
400
 
extern struct compressor ppp_bsd_compress, ppp_deflate;
401
 
 
402
 
struct compressor *compressors[] = {
403
 
#if DO_BSD_COMPRESS
404
 
    &ppp_bsd_compress,
405
 
#endif
406
 
#if DO_DEFLATE
407
 
    &ppp_deflate,
408
 
#endif
409
 
    NULL
410
 
};
411
 
 
412
 
handle_ccp(cp, dp, len)
413
 
    struct pkt *cp;
414
 
    u_char *dp;
415
 
    int len;
416
 
{
417
 
    int clen;
418
 
    struct compressor **comp;
419
 
 
420
 
    if (len < CCP_HDRLEN)
421
 
        return;
422
 
    clen = CCP_LENGTH(dp);
423
 
    if (clen > len)
424
 
        return;
425
 
 
426
 
    switch (CCP_CODE(dp)) {
427
 
    case CCP_CONFACK:
428
 
        cp->flags &= ~(CCP_DECOMP_RUN | CCP_ISUP);
429
 
        if (clen < CCP_HDRLEN + CCP_OPT_MINLEN
430
 
            || clen < CCP_HDRLEN + CCP_OPT_LENGTH(dp + CCP_HDRLEN))
431
 
            break;
432
 
        dp += CCP_HDRLEN;
433
 
        clen -= CCP_HDRLEN;
434
 
        for (comp = compressors; *comp != NULL; ++comp) {
435
 
            if ((*comp)->compress_proto == dp[0]) {
436
 
                if (cp->state != NULL) {
437
 
                    (*cp->comp->decomp_free)(cp->state);
438
 
                    cp->state = NULL;
439
 
                }
440
 
                cp->comp = *comp;
441
 
                cp->state = (*comp)->decomp_alloc(dp, CCP_OPT_LENGTH(dp));
442
 
                cp->flags |= CCP_ISUP;
443
 
                if (cp->state != NULL
444
 
                    && (*cp->comp->decomp_init)
445
 
                        (cp->state, dp, clen, 0, 0, 8192, 1))
446
 
                    cp->flags = (cp->flags & ~CCP_ERR) | CCP_DECOMP_RUN;
447
 
                break;
448
 
            }
449
 
        }
450
 
        break;
451
 
 
452
 
    case CCP_CONFNAK:
453
 
    case CCP_CONFREJ:
454
 
        cp->flags &= ~(CCP_DECOMP_RUN | CCP_ISUP);
455
 
        break;
456
 
 
457
 
    case CCP_RESETACK:
458
 
        if (cp->flags & CCP_ISUP) {
459
 
            if (cp->state && (cp->flags & CCP_DECOMP_RUN)) {
460
 
                (*cp->comp->decomp_reset)(cp->state);
461
 
                cp->flags &= ~CCP_ERROR;
462
 
            }
463
 
        }
464
 
        break;
465
 
    }
466
 
}
467
 
 
468
 
show_time(f, c)
469
 
    FILE *f;
470
 
    int c;
471
 
{
472
 
    time_t t;
473
 
    int n;
474
 
    struct tm *tm;
475
 
 
476
 
    if (c == 7) {
477
 
        t = getc(f);
478
 
        t = (t << 8) + getc(f);
479
 
        t = (t << 8) + getc(f);
480
 
        t = (t << 8) + getc(f);
481
 
        printf("start %s", ctime(&t));
482
 
        start_time = t;
483
 
        start_time_tenths = 0;
484
 
        tot_sent = tot_rcvd = 0;
485
 
    } else {
486
 
        n = getc(f);
487
 
        if (c == 5) {
488
 
            for (c = 3; c > 0; --c)
489
 
                n = (n << 8) + getc(f);
490
 
        }
491
 
        if (abs_times) {
492
 
            n += start_time_tenths;
493
 
            start_time += n / 10;
494
 
            start_time_tenths = n % 10;
495
 
            tm = localtime(&start_time);
496
 
            printf("time  %.2d:%.2d:%.2d.%d", tm->tm_hour, tm->tm_min,
497
 
                   tm->tm_sec, start_time_tenths);
498
 
            printf("  (sent %d, rcvd %d)\n", tot_sent, tot_rcvd);
499
 
        } else
500
 
            printf("time  %.1fs\n", (double) n / 10);
501
 
    }
502
 
}