Home | History | Annotate | Download | only in tcpdump
      1 /*
      2  * Copyright (c) 1993, 1994, 1995, 1996
      3  *	The Regents of the University of California.  All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that: (1) source code distributions
      7  * retain the above copyright notice and this paragraph in its entirety, (2)
      8  * distributions including binary code include the above copyright notice and
      9  * this paragraph in its entirety in the documentation or other materials
     10  * provided with the distribution, and (3) all advertising materials mentioning
     11  * features or use of this software display the following acknowledgement:
     12  * ``This product includes software developed by the University of California,
     13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
     14  * the University nor the names of its contributors may be used to endorse
     15  * or promote products derived from this software without specific prior
     16  * written permission.
     17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
     18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
     19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
     20  */
     21 
     22 #ifndef lint
     23 static const char rcsid[] _U_ =
     24     "@(#) $Header: /tcpdump/master/tcpdump/print-wb.c,v 1.33 2004/03/24 04:06:28 guy Exp $ (LBL)";
     25 #endif
     26 
     27 #ifdef HAVE_CONFIG_H
     28 #include "config.h"
     29 #endif
     30 
     31 #include <tcpdump-stdinc.h>
     32 
     33 #include <stdio.h>
     34 
     35 #include "interface.h"
     36 #include "addrtoname.h"
     37 #include "extract.h"
     38 
     39 /* XXX need to add byte-swapping macros! */
     40 /* XXX - you mean like the ones in "extract.h"? */
     41 
     42 /*
     43  * Largest packet size.  Everything should fit within this space.
     44  * For instance, multiline objects are sent piecewise.
     45  */
     46 #define MAXFRAMESIZE 1024
     47 
     48 /*
     49  * Multiple drawing ops can be sent in one packet.  Each one starts on a
     50  * an even multiple of DOP_ALIGN bytes, which must be a power of two.
     51  */
     52 #define DOP_ALIGN 4
     53 #define DOP_ROUNDUP(x)	((((int)(x)) + (DOP_ALIGN - 1)) & ~(DOP_ALIGN - 1))
     54 #define DOP_NEXT(d)\
     55 	((struct dophdr *)((u_char *)(d) + \
     56 			  DOP_ROUNDUP(EXTRACT_16BITS(&(d)->dh_len) + sizeof(*(d)))))
     57 
     58 /*
     59  * Format of the whiteboard packet header.
     60  * The transport level header.
     61  */
     62 struct pkt_hdr {
     63 	u_int32_t ph_src;		/* site id of source */
     64 	u_int32_t ph_ts;		/* time stamp (for skew computation) */
     65 	u_int16_t ph_version;	/* version number */
     66 	u_char ph_type;		/* message type */
     67 	u_char ph_flags;	/* message flags */
     68 };
     69 
     70 /* Packet types */
     71 #define PT_DRAWOP	0	/* drawing operation */
     72 #define PT_ID		1	/* announcement packet */
     73 #define PT_RREQ		2	/* repair request */
     74 #define PT_RREP		3	/* repair reply */
     75 #define PT_KILL		4	/* terminate participation */
     76 #define PT_PREQ         5       /* page vector request */
     77 #define PT_PREP         7       /* page vector reply */
     78 
     79 #ifdef PF_USER
     80 #undef PF_USER			/* {Digital,Tru64} UNIX define this, alas */
     81 #endif
     82 
     83 /* flags */
     84 #define PF_USER		0x01	/* hint that packet has interactive data */
     85 #define PF_VIS		0x02	/* only visible ops wanted */
     86 
     87 struct PageID {
     88 	u_int32_t p_sid;		/* session id of initiator */
     89 	u_int32_t p_uid;		/* page number */
     90 };
     91 
     92 struct dophdr {
     93 	u_int32_t  dh_ts;		/* sender's timestamp */
     94 	u_int16_t	dh_len;		/* body length */
     95 	u_char	dh_flags;
     96 	u_char	dh_type;	/* body type */
     97 	/* body follows */
     98 };
     99 /*
    100  * Drawing op sub-types.
    101  */
    102 #define DT_RECT         2
    103 #define DT_LINE         3
    104 #define DT_ML           4
    105 #define DT_DEL          5
    106 #define DT_XFORM        6
    107 #define DT_ELL          7
    108 #define DT_CHAR         8
    109 #define DT_STR          9
    110 #define DT_NOP          10
    111 #define DT_PSCODE       11
    112 #define DT_PSCOMP       12
    113 #define DT_REF          13
    114 #define DT_SKIP         14
    115 #define DT_HOLE         15
    116 #define DT_MAXTYPE      15
    117 
    118 /*
    119  * A drawing operation.
    120  */
    121 struct pkt_dop {
    122 	struct PageID pd_page;	/* page that operations apply to */
    123 	u_int32_t	pd_sseq;	/* start sequence number */
    124 	u_int32_t	pd_eseq;	/* end sequence number */
    125 	/* drawing ops follow */
    126 };
    127 
    128 /*
    129  * A repair request.
    130  */
    131 struct pkt_rreq {
    132         u_int32_t pr_id;           /* source id of drawops to be repaired */
    133         struct PageID pr_page;           /* page of drawops */
    134         u_int32_t pr_sseq;         /* start seqno */
    135         u_int32_t pr_eseq;         /* end seqno */
    136 };
    137 
    138 /*
    139  * A repair reply.
    140  */
    141 struct pkt_rrep {
    142 	u_int32_t pr_id;	/* original site id of ops  */
    143 	struct pkt_dop pr_dop;
    144 	/* drawing ops follow */
    145 };
    146 
    147 struct id_off {
    148         u_int32_t id;
    149         u_int32_t off;
    150 };
    151 
    152 struct pgstate {
    153 	u_int32_t slot;
    154 	struct PageID page;
    155 	u_int16_t nid;
    156 	u_int16_t rsvd;
    157         /* seqptr's */
    158 };
    159 
    160 /*
    161  * An announcement packet.
    162  */
    163 struct pkt_id {
    164 	u_int32_t pi_mslot;
    165         struct PageID    pi_mpage;        /* current page */
    166 	struct pgstate pi_ps;
    167         /* seqptr's */
    168         /* null-terminated site name */
    169 };
    170 
    171 struct pkt_preq {
    172         struct PageID  pp_page;
    173         u_int32_t  pp_low;
    174         u_int32_t  pp_high;
    175 };
    176 
    177 struct pkt_prep {
    178         u_int32_t  pp_n;           /* size of pageid array */
    179         /* pgstate's follow */
    180 };
    181 
    182 static int
    183 wb_id(const struct pkt_id *id, u_int len)
    184 {
    185 	int i;
    186 	const char *cp;
    187 	const struct id_off *io;
    188 	char c;
    189 	int nid;
    190 
    191 	printf(" wb-id:");
    192 	if (len < sizeof(*id) || (u_char *)(id + 1) > snapend)
    193 		return (-1);
    194 	len -= sizeof(*id);
    195 
    196 	printf(" %u/%s:%u (max %u/%s:%u) ",
    197 	       EXTRACT_32BITS(&id->pi_ps.slot),
    198 	       ipaddr_string(&id->pi_ps.page.p_sid),
    199 	       EXTRACT_32BITS(&id->pi_ps.page.p_uid),
    200 	       EXTRACT_32BITS(&id->pi_mslot),
    201 	       ipaddr_string(&id->pi_mpage.p_sid),
    202 	       EXTRACT_32BITS(&id->pi_mpage.p_uid));
    203 
    204 	nid = EXTRACT_16BITS(&id->pi_ps.nid);
    205 	len -= sizeof(*io) * nid;
    206 	io = (struct id_off *)(id + 1);
    207 	cp = (char *)(io + nid);
    208 	if ((u_char *)cp + len <= snapend) {
    209 		putchar('"');
    210 		(void)fn_print((u_char *)cp, (u_char *)cp + len);
    211 		putchar('"');
    212 	}
    213 
    214 	c = '<';
    215 	for (i = 0; i < nid && (u_char *)(io + 1) <= snapend; ++io, ++i) {
    216 		printf("%c%s:%u",
    217 		    c, ipaddr_string(&io->id), EXTRACT_32BITS(&io->off));
    218 		c = ',';
    219 	}
    220 	if (i >= nid) {
    221 		printf(">");
    222 		return (0);
    223 	}
    224 	return (-1);
    225 }
    226 
    227 static int
    228 wb_rreq(const struct pkt_rreq *rreq, u_int len)
    229 {
    230 	printf(" wb-rreq:");
    231 	if (len < sizeof(*rreq) || (u_char *)(rreq + 1) > snapend)
    232 		return (-1);
    233 
    234 	printf(" please repair %s %s:%u<%u:%u>",
    235 	       ipaddr_string(&rreq->pr_id),
    236 	       ipaddr_string(&rreq->pr_page.p_sid),
    237 	       EXTRACT_32BITS(&rreq->pr_page.p_uid),
    238 	       EXTRACT_32BITS(&rreq->pr_sseq),
    239 	       EXTRACT_32BITS(&rreq->pr_eseq));
    240 	return (0);
    241 }
    242 
    243 static int
    244 wb_preq(const struct pkt_preq *preq, u_int len)
    245 {
    246 	printf(" wb-preq:");
    247 	if (len < sizeof(*preq) || (u_char *)(preq + 1) > snapend)
    248 		return (-1);
    249 
    250 	printf(" need %u/%s:%u",
    251 	       EXTRACT_32BITS(&preq->pp_low),
    252 	       ipaddr_string(&preq->pp_page.p_sid),
    253 	       EXTRACT_32BITS(&preq->pp_page.p_uid));
    254 	return (0);
    255 }
    256 
    257 static int
    258 wb_prep(const struct pkt_prep *prep, u_int len)
    259 {
    260 	int n;
    261 	const struct pgstate *ps;
    262 	const u_char *ep = snapend;
    263 
    264 	printf(" wb-prep:");
    265 	if (len < sizeof(*prep)) {
    266 		return (-1);
    267 	}
    268 	n = EXTRACT_32BITS(&prep->pp_n);
    269 	ps = (const struct pgstate *)(prep + 1);
    270 	while (--n >= 0 && (u_char *)(ps + 1) <= ep) {
    271 		const struct id_off *io, *ie;
    272 		char c = '<';
    273 
    274 		printf(" %u/%s:%u",
    275 		    EXTRACT_32BITS(&ps->slot),
    276 		    ipaddr_string(&ps->page.p_sid),
    277 		    EXTRACT_32BITS(&ps->page.p_uid));
    278 		io = (struct id_off *)(ps + 1);
    279 		for (ie = io + ps->nid; io < ie && (u_char *)(io + 1) <= ep; ++io) {
    280 			printf("%c%s:%u", c, ipaddr_string(&io->id),
    281 			    EXTRACT_32BITS(&io->off));
    282 			c = ',';
    283 		}
    284 		printf(">");
    285 		ps = (struct pgstate *)io;
    286 	}
    287 	return ((u_char *)ps <= ep? 0 : -1);
    288 }
    289 
    290 
    291 const char *dopstr[] = {
    292 	"dop-0!",
    293 	"dop-1!",
    294 	"RECT",
    295 	"LINE",
    296 	"ML",
    297 	"DEL",
    298 	"XFORM",
    299 	"ELL",
    300 	"CHAR",
    301 	"STR",
    302 	"NOP",
    303 	"PSCODE",
    304 	"PSCOMP",
    305 	"REF",
    306 	"SKIP",
    307 	"HOLE",
    308 };
    309 
    310 static int
    311 wb_dops(const struct dophdr *dh, u_int32_t ss, u_int32_t es)
    312 {
    313 	printf(" <");
    314 	for ( ; ss <= es; ++ss) {
    315 		register int t = dh->dh_type;
    316 
    317 		if (t > DT_MAXTYPE)
    318 			printf(" dop-%d!", t);
    319 		else {
    320 			printf(" %s", dopstr[t]);
    321 			if (t == DT_SKIP || t == DT_HOLE) {
    322 				u_int32_t ts = EXTRACT_32BITS(&dh->dh_ts);
    323 				printf("%d", ts - ss + 1);
    324 				if (ss > ts || ts > es) {
    325 					printf("[|]");
    326 					if (ts < ss)
    327 						return (0);
    328 				}
    329 				ss = ts;
    330 			}
    331 		}
    332 		dh = DOP_NEXT(dh);
    333 		if ((u_char *)dh > snapend) {
    334 			printf("[|wb]");
    335 			break;
    336 		}
    337 	}
    338 	printf(" >");
    339 	return (0);
    340 }
    341 
    342 static int
    343 wb_rrep(const struct pkt_rrep *rrep, u_int len)
    344 {
    345 	const struct pkt_dop *dop = &rrep->pr_dop;
    346 
    347 	printf(" wb-rrep:");
    348 	if (len < sizeof(*rrep) || (u_char *)(rrep + 1) > snapend)
    349 		return (-1);
    350 	len -= sizeof(*rrep);
    351 
    352 	printf(" for %s %s:%u<%u:%u>",
    353 	    ipaddr_string(&rrep->pr_id),
    354 	    ipaddr_string(&dop->pd_page.p_sid),
    355 	    EXTRACT_32BITS(&dop->pd_page.p_uid),
    356 	    EXTRACT_32BITS(&dop->pd_sseq),
    357 	    EXTRACT_32BITS(&dop->pd_eseq));
    358 
    359 	if (vflag)
    360 		return (wb_dops((const struct dophdr *)(dop + 1),
    361 		    EXTRACT_32BITS(&dop->pd_sseq),
    362 		    EXTRACT_32BITS(&dop->pd_eseq)));
    363 	return (0);
    364 }
    365 
    366 static int
    367 wb_drawop(const struct pkt_dop *dop, u_int len)
    368 {
    369 	printf(" wb-dop:");
    370 	if (len < sizeof(*dop) || (u_char *)(dop + 1) > snapend)
    371 		return (-1);
    372 	len -= sizeof(*dop);
    373 
    374 	printf(" %s:%u<%u:%u>",
    375 	    ipaddr_string(&dop->pd_page.p_sid),
    376 	    EXTRACT_32BITS(&dop->pd_page.p_uid),
    377 	    EXTRACT_32BITS(&dop->pd_sseq),
    378 	    EXTRACT_32BITS(&dop->pd_eseq));
    379 
    380 	if (vflag)
    381 		return (wb_dops((const struct dophdr *)(dop + 1),
    382 				EXTRACT_32BITS(&dop->pd_sseq),
    383 				EXTRACT_32BITS(&dop->pd_eseq)));
    384 	return (0);
    385 }
    386 
    387 /*
    388  * Print whiteboard multicast packets.
    389  */
    390 void
    391 wb_print(register const void *hdr, register u_int len)
    392 {
    393 	register const struct pkt_hdr *ph;
    394 
    395 	ph = (const struct pkt_hdr *)hdr;
    396 	if (len < sizeof(*ph) || (u_char *)(ph + 1) > snapend) {
    397 		printf("[|wb]");
    398 		return;
    399 	}
    400 	len -= sizeof(*ph);
    401 
    402 	if (ph->ph_flags)
    403 		printf("*");
    404 	switch (ph->ph_type) {
    405 
    406 	case PT_KILL:
    407 		printf(" wb-kill");
    408 		return;
    409 
    410 	case PT_ID:
    411 		if (wb_id((struct pkt_id *)(ph + 1), len) >= 0)
    412 			return;
    413 		break;
    414 
    415 	case PT_RREQ:
    416 		if (wb_rreq((struct pkt_rreq *)(ph + 1), len) >= 0)
    417 			return;
    418 		break;
    419 
    420 	case PT_RREP:
    421 		if (wb_rrep((struct pkt_rrep *)(ph + 1), len) >= 0)
    422 			return;
    423 		break;
    424 
    425 	case PT_DRAWOP:
    426 		if (wb_drawop((struct pkt_dop *)(ph + 1), len) >= 0)
    427 			return;
    428 		break;
    429 
    430 	case PT_PREQ:
    431 		if (wb_preq((struct pkt_preq *)(ph + 1), len) >= 0)
    432 			return;
    433 		break;
    434 
    435 	case PT_PREP:
    436 		if (wb_prep((struct pkt_prep *)(ph + 1), len) >= 0)
    437 			return;
    438 		break;
    439 
    440 	default:
    441 		printf(" wb-%d!", ph->ph_type);
    442 		return;
    443 	}
    444 }
    445