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