Home | History | Annotate | Line # | Download | only in netstat
route.c revision 1.10
      1 /*
      2  * Copyright (c) 1983, 1988, 1993
      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 the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  * 3. All advertising materials mentioning features or use of this software
     14  *    must display the following acknowledgement:
     15  *	This product includes software developed by the University of
     16  *	California, Berkeley and its contributors.
     17  * 4. Neither the name of the University nor the names of its contributors
     18  *    may be used to endorse or promote products derived from this software
     19  *    without specific prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     31  * SUCH DAMAGE.
     32  */
     33 
     34 #ifndef lint
     35 /*static char sccsid[] = "from: @(#)route.c	8.3 (Berkeley) 3/9/94";*/
     36 static char *rcsid = "$Id: route.c,v 1.10 1994/05/13 08:08:22 mycroft Exp $";
     37 #endif /* not lint */
     38 
     39 #include <sys/param.h>
     40 #include <sys/protosw.h>
     41 #include <sys/socket.h>
     42 #include <sys/mbuf.h>
     43 
     44 #include <net/if.h>
     45 #include <net/if_dl.h>
     46 #include <net/if_types.h>
     47 #define  KERNEL
     48 #include <net/route.h>
     49 #undef KERNEL
     50 #include <netinet/in.h>
     51 
     52 #include <netns/ns.h>
     53 
     54 #include <sys/sysctl.h>
     55 
     56 #include <netdb.h>
     57 #include <stdio.h>
     58 #include <stdlib.h>
     59 #include <string.h>
     60 #include <unistd.h>
     61 #include "netstat.h"
     62 
     63 #define kget(p, d) (kread((u_long)(p), (char *)&(d), sizeof (d)))
     64 
     65 /*
     66  * Definitions for showing gateway flags.
     67  */
     68 struct bits {
     69 	short	b_mask;
     70 	char	b_val;
     71 } bits[] = {
     72 	{ RTF_UP,	'U' },
     73 	{ RTF_GATEWAY,	'G' },
     74 	{ RTF_HOST,	'H' },
     75 	{ RTF_REJECT,	'R' },
     76 	{ RTF_DYNAMIC,	'D' },
     77 	{ RTF_MODIFIED,	'M' },
     78 	{ RTF_DONE,	'd' }, /* Completed -- for routing messages only */
     79 	{ RTF_MASK,	'm' }, /* Mask Present -- for routing messages only */
     80 	{ RTF_CLONING,	'C' },
     81 	{ RTF_XRESOLVE,	'X' },
     82 	{ RTF_LLINFO,	'L' },
     83 	{ RTF_STATIC,	'S' },
     84 	{ RTF_PROTO1,	'1' },
     85 	{ RTF_PROTO2,	'2' },
     86 	{ 0 }
     87 };
     88 
     89 static union {
     90 	struct	sockaddr u_sa;
     91 	u_short	u_data[128];
     92 } pt_u;
     93 
     94 int	do_rtent = 0;
     95 struct	rtentry rtentry;
     96 struct	radix_node rnode;
     97 struct	radix_mask rmask;
     98 
     99 int	NewTree = 0;
    100 
    101 static struct sockaddr *kgetsa __P((struct sockaddr *));
    102 static void p_tree __P((struct radix_node *));
    103 static void p_rtnode __P(());
    104 static void ntreestuff __P(());
    105 static void np_rtentry __P((struct rt_msghdr *));
    106 static void p_sockaddr __P((struct sockaddr *, int, int));
    107 static void p_flags __P((int, char *));
    108 static void p_rtentry __P((struct rtentry *));
    109 
    110 /*
    111  * Print routing tables.
    112  */
    113 void
    114 routepr(rtree)
    115 	u_long rtree;
    116 {
    117 	struct radix_node_head *rnh, head;
    118 	int i;
    119 
    120 	printf("Routing tables\n");
    121 
    122 	if (Aflag == 0 && NewTree)
    123 		ntreestuff();
    124 	else {
    125 		if (rtree == 0) {
    126 			printf("rt_tables: symbol not in namelist\n");
    127 			return;
    128 		}
    129 
    130 		kget(rtree, rt_tables);
    131 		for (i = 0; i <= AF_MAX; i++) {
    132 			if ((rnh = rt_tables[i]) == 0)
    133 				continue;
    134 			kget(rnh, head);
    135 			if (i == AF_UNSPEC) {
    136 				if (Aflag && af == 0) {
    137 					printf("Netmasks:\n");
    138 					p_tree(head.rnh_treetop);
    139 				}
    140 			} else if (af == AF_UNSPEC || af == i) {
    141 				pr_family(i);
    142 				do_rtent = 1;
    143 				pr_rthdr();
    144 				p_tree(head.rnh_treetop);
    145 			}
    146 		}
    147 	}
    148 }
    149 
    150 /*
    151  * Print address family header before a section of the routing table.
    152  */
    153 void
    154 pr_family(af)
    155 	int af;
    156 {
    157 	char *afname;
    158 
    159 	switch (af) {
    160 	case AF_INET:
    161 		afname = "Internet";
    162 		break;
    163 	case AF_NS:
    164 		afname = "XNS";
    165 		break;
    166 	case AF_ISO:
    167 		afname = "ISO";
    168 		break;
    169 	case AF_CCITT:
    170 		afname = "X.25";
    171 		break;
    172 	default:
    173 		afname = NULL;
    174 		break;
    175 	}
    176 	if (afname)
    177 		printf("\n%s:\n", afname);
    178 	else
    179 		printf("\nProtocol Family %d:\n", af);
    180 }
    181 
    182 /* column widths; each followed by one space */
    183 #define	WID_DST		16	/* width of destination column */
    184 #define	WID_GW		18	/* width of gateway column */
    185 
    186 /*
    187  * Print header for routing table columns.
    188  */
    189 void
    190 pr_rthdr()
    191 {
    192 
    193 	if (Aflag)
    194 		printf("%-8.8s ","Address");
    195 	printf("%-*.*s %-*.*s %-6.6s  %6.6s%8.8s  %s\n",
    196 		WID_DST, WID_DST, "Destination",
    197 		WID_GW, WID_GW, "Gateway",
    198 		"Flags", "Refs", "Use", "Interface");
    199 }
    200 
    201 static struct sockaddr *
    202 kgetsa(dst)
    203 	register struct sockaddr *dst;
    204 {
    205 
    206 	kget(dst, pt_u.u_sa);
    207 	if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa))
    208 		kread((u_long)dst, (char *)pt_u.u_data, pt_u.u_sa.sa_len);
    209 	return (&pt_u.u_sa);
    210 }
    211 
    212 static void
    213 p_tree(rn)
    214 	struct radix_node *rn;
    215 {
    216 
    217 again:
    218 	kget(rn, rnode);
    219 	if (rnode.rn_b < 0) {
    220 		if (Aflag)
    221 			printf("%-8.8x ", rn);
    222 		if (rnode.rn_flags & RNF_ROOT) {
    223 			if (Aflag)
    224 				printf("(root node)%s",
    225 				    rnode.rn_dupedkey ? " =>\n" : "\n");
    226 		} else if (do_rtent) {
    227 			kget(rn, rtentry);
    228 			p_rtentry(&rtentry);
    229 			if (Aflag)
    230 				p_rtnode();
    231 		} else {
    232 			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key),
    233 			    0, 44);
    234 			putchar('\n');
    235 		}
    236 		if (rn = rnode.rn_dupedkey)
    237 			goto again;
    238 	} else {
    239 		if (Aflag && do_rtent) {
    240 			printf("%-8.8x ", rn);
    241 			p_rtnode();
    242 		}
    243 		rn = rnode.rn_r;
    244 		p_tree(rnode.rn_l);
    245 		p_tree(rn);
    246 	}
    247 }
    248 
    249 char	nbuf[20];
    250 
    251 static void
    252 p_rtnode()
    253 {
    254 	struct radix_mask *rm = rnode.rn_mklist;
    255 
    256 	if (rnode.rn_b < 0) {
    257 		if (rnode.rn_mask) {
    258 			printf("\t  mask ");
    259 			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_mask),
    260 				    0, -1);
    261 		} else if (rm == 0)
    262 			return;
    263 	} else {
    264 		sprintf(nbuf, "(%d)", rnode.rn_b);
    265 		printf("%6.6s %8.8x : %8.8x", nbuf, rnode.rn_l, rnode.rn_r);
    266 	}
    267 	while (rm) {
    268 		kget(rm, rmask);
    269 		sprintf(nbuf, " %d refs, ", rmask.rm_refs);
    270 		printf(" mk = %8.8x {(%d),%s",
    271 			rm, -1 - rmask.rm_b, rmask.rm_refs ? nbuf : " ");
    272 		p_sockaddr(kgetsa((struct sockaddr *)rmask.rm_mask), 0, -1);
    273 		putchar('}');
    274 		if (rm = rmask.rm_mklist)
    275 			printf(" ->");
    276 	}
    277 	putchar('\n');
    278 }
    279 
    280 static void
    281 ntreestuff()
    282 {
    283 	size_t needed;
    284 	int mib[6];
    285 	char *buf, *next, *lim;
    286 	register struct rt_msghdr *rtm;
    287 
    288         mib[0] = CTL_NET;
    289         mib[1] = PF_ROUTE;
    290         mib[2] = 0;
    291         mib[3] = 0;
    292         mib[4] = NET_RT_DUMP;
    293         mib[5] = 0;
    294         if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
    295 		{ perror("route-sysctl-estimate"); exit(1);}
    296 	if ((buf = malloc(needed)) == 0)
    297 		{ printf("out of space\n"); exit(1);}
    298         if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
    299 		{ perror("sysctl of routing table"); exit(1);}
    300 	lim  = buf + needed;
    301 	for (next = buf; next < lim; next += rtm->rtm_msglen) {
    302 		rtm = (struct rt_msghdr *)next;
    303 		np_rtentry(rtm);
    304 	}
    305 }
    306 
    307 static void
    308 np_rtentry(rtm)
    309 	register struct rt_msghdr *rtm;
    310 {
    311 	register struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
    312 #ifdef notdef
    313 	static int masks_done, banner_printed;
    314 #endif
    315 	static int old_af;
    316 	int af = 0, interesting = RTF_UP | RTF_GATEWAY | RTF_HOST;
    317 
    318 #ifdef notdef
    319 	/* for the moment, netmasks are skipped over */
    320 	if (!banner_printed) {
    321 		printf("Netmasks:\n");
    322 		banner_printed = 1;
    323 	}
    324 	if (masks_done == 0) {
    325 		if (rtm->rtm_addrs != RTA_DST ) {
    326 			masks_done = 1;
    327 			af = sa->sa_family;
    328 		}
    329 	} else
    330 #endif
    331 		af = sa->sa_family;
    332 	if (af != old_af) {
    333 		pr_family(af);
    334 		old_af = af;
    335 	}
    336 	if (rtm->rtm_addrs == RTA_DST)
    337 		p_sockaddr(sa, 0, 36);
    338 	else {
    339 		p_sockaddr(sa, rtm->rtm_flags, 16);
    340 		if (sa->sa_len == 0)
    341 			sa->sa_len = sizeof(long);
    342 		sa = (struct sockaddr *)(sa->sa_len + (char *)sa);
    343 		p_sockaddr(sa, 0, 18);
    344 	}
    345 	p_flags(rtm->rtm_flags & interesting, "%-6.6s ");
    346 	putchar('\n');
    347 }
    348 
    349 static void
    350 p_sockaddr(sa, flags, width)
    351 	struct sockaddr *sa;
    352 	int flags, width;
    353 {
    354 	char workbuf[128], *cplim;
    355 	register char *cp = workbuf;
    356 
    357 	switch(sa->sa_family) {
    358 	case AF_INET:
    359 	    {
    360 		register struct sockaddr_in *sin = (struct sockaddr_in *)sa;
    361 
    362 		cp = (sin->sin_addr.s_addr == 0) ? "default" :
    363 		      ((flags & RTF_HOST) ?
    364 			routename(sin->sin_addr.s_addr) :
    365 			netname(sin->sin_addr.s_addr, 0L));
    366 		break;
    367 	    }
    368 
    369 	case AF_NS:
    370 		cp = ns_print(sa);
    371 		break;
    372 
    373 	case AF_LINK:
    374 	    {
    375 		register struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;
    376 
    377 		if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 &&
    378 		    sdl->sdl_slen == 0)
    379 			(void) sprintf(workbuf, "link#%d", sdl->sdl_index);
    380 		else switch (sdl->sdl_type) {
    381 		case IFT_ETHER:
    382 		    {
    383 			register int i;
    384 			register u_char *lla = (u_char *)sdl->sdl_data +
    385 			    sdl->sdl_nlen;
    386 
    387 			cplim = "";
    388 			for (i = 0; i < sdl->sdl_alen; i++, lla++) {
    389 				cp += sprintf(cp, "%s%x", cplim, *lla);
    390 				cplim = ":";
    391 			}
    392 			cp = workbuf;
    393 			break;
    394 		    }
    395 		default:
    396 			cp = link_ntoa(sdl);
    397 			break;
    398 		}
    399 		break;
    400 	    }
    401 
    402 	default:
    403 	    {
    404 		register u_char *s = (u_char *)sa->sa_data, *slim;
    405 
    406 		slim =  sa->sa_len + (u_char *) sa;
    407 		cplim = cp + sizeof(workbuf) - 6;
    408 		cp += sprintf(cp, "(%d)", sa->sa_family);
    409 		while (s < slim && cp < cplim) {
    410 			cp += sprintf(cp, " %02x", *s++);
    411 			if (s < slim)
    412 			    cp += sprintf(cp, "%02x", *s++);
    413 		}
    414 		cp = workbuf;
    415 	    }
    416 	}
    417 	if (width < 0 )
    418 		printf("%s ", cp);
    419 	else {
    420 		if (nflag)
    421 			printf("%-*s ", width, cp);
    422 		else
    423 			printf("%-*.*s ", width, width, cp);
    424 	}
    425 }
    426 
    427 static void
    428 p_flags(f, format)
    429 	register int f;
    430 	char *format;
    431 {
    432 	char name[33], *flags;
    433 	register struct bits *p = bits;
    434 
    435 	for (flags = name; p->b_mask; p++)
    436 		if (p->b_mask & f)
    437 			*flags++ = p->b_val;
    438 	*flags = '\0';
    439 	printf(format, name);
    440 }
    441 
    442 static void
    443 p_rtentry(rt)
    444 	register struct rtentry *rt;
    445 {
    446 	static struct ifnet ifnet, *lastif;
    447 	static char name[16];
    448 
    449 	p_sockaddr(kgetsa(rt_key(rt)), rt->rt_flags, WID_DST);
    450 	p_sockaddr(kgetsa(rt->rt_gateway), RTF_HOST, WID_GW);
    451 	p_flags(rt->rt_flags, "%-6.6s ");
    452 	printf("%6d %8d ", rt->rt_refcnt, rt->rt_use);
    453 	if (rt->rt_ifp) {
    454 		if (rt->rt_ifp != lastif) {
    455 			kget(rt->rt_ifp, ifnet);
    456 			kread((u_long)ifnet.if_name, name, 16);
    457 			lastif = rt->rt_ifp;
    458 		}
    459 		printf(" %.15s%d%s", name, ifnet.if_unit,
    460 			rt->rt_nodes[0].rn_dupedkey ? " =>" : "");
    461 	}
    462 	putchar('\n');
    463 }
    464 
    465 char *
    466 routename(in)
    467 	u_long in;
    468 {
    469 	register char *cp;
    470 	static char line[MAXHOSTNAMELEN + 1];
    471 	struct hostent *hp;
    472 	static char domain[MAXHOSTNAMELEN + 1];
    473 	static int first = 1;
    474 
    475 	if (first) {
    476 		first = 0;
    477 		if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
    478 		    (cp = index(domain, '.')))
    479 			(void) strcpy(domain, cp + 1);
    480 		else
    481 			domain[0] = 0;
    482 	}
    483 	cp = 0;
    484 	if (!nflag) {
    485 		hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
    486 			AF_INET);
    487 		if (hp) {
    488 			if ((cp = index(hp->h_name, '.')) &&
    489 			    !strcmp(cp + 1, domain))
    490 				*cp = 0;
    491 			cp = hp->h_name;
    492 		}
    493 	}
    494 	if (cp)
    495 		strncpy(line, cp, sizeof(line) - 1);
    496 	else {
    497 #define C(x)	((x) & 0xff)
    498 		in = ntohl(in);
    499 		sprintf(line, "%u.%u.%u.%u",
    500 		    C(in >> 24), C(in >> 16), C(in >> 8), C(in));
    501 	}
    502 	return (line);
    503 }
    504 
    505 /*
    506  * Return the name of the network whose address is given.
    507  * The address is assumed to be that of a net or subnet, not a host.
    508  */
    509 char *
    510 netname(in, mask)
    511 	u_long in, mask;
    512 {
    513 	char *cp = 0;
    514 	static char line[MAXHOSTNAMELEN + 1];
    515 	struct netent *np = 0;
    516 	u_long net;
    517 	register int i;
    518 	int subnetshift;
    519 
    520 	i = ntohl(in);
    521 	if (!nflag && i) {
    522 		if (mask == 0) {
    523 			if (IN_CLASSA(i)) {
    524 				mask = IN_CLASSA_NET;
    525 				subnetshift = 8;
    526 			} else if (IN_CLASSB(i)) {
    527 				mask = IN_CLASSB_NET;
    528 				subnetshift = 8;
    529 			} else {
    530 				mask = IN_CLASSC_NET;
    531 				subnetshift = 4;
    532 			}
    533 			/*
    534 			 * If there are more bits than the standard mask
    535 			 * would suggest, subnets must be in use.
    536 			 * Guess at the subnet mask, assuming reasonable
    537 			 * width subnet fields.
    538 			 */
    539 			while (i &~ mask)
    540 				mask = (long)mask >> subnetshift;
    541 		}
    542 		net = i & mask;
    543 		while ((mask & 1) == 0)
    544 			mask >>= 1, net >>= 1;
    545 		np = getnetbyaddr(net, AF_INET);
    546 		if (np)
    547 			cp = np->n_name;
    548 	}
    549 	if (cp)
    550 		strncpy(line, cp, sizeof(line) - 1);
    551 	else if ((i & 0xffffff) == 0)
    552 		sprintf(line, "%u", C(i >> 24));
    553 	else if ((i & 0xffff) == 0)
    554 		sprintf(line, "%u.%u", C(i >> 24) , C(i >> 16));
    555 	else if ((i & 0xff) == 0)
    556 		sprintf(line, "%u.%u.%u", C(i >> 24), C(i >> 16), C(i >> 8));
    557 	else
    558 		sprintf(line, "%u.%u.%u.%u", C(i >> 24),
    559 			C(i >> 16), C(i >> 8), C(i));
    560 	return (line);
    561 }
    562 
    563 /*
    564  * Print routing statistics
    565  */
    566 void
    567 rt_stats(off)
    568 	u_long off;
    569 {
    570 	struct rtstat rtstat;
    571 
    572 	if (off == 0) {
    573 		printf("rtstat: symbol not in namelist\n");
    574 		return;
    575 	}
    576 	kread(off, (char *)&rtstat, sizeof (rtstat));
    577 	printf("routing:\n");
    578 	printf("\t%u bad routing redirect%s\n",
    579 		rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
    580 	printf("\t%u dynamically created route%s\n",
    581 		rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
    582 	printf("\t%u new gateway%s due to redirects\n",
    583 		rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
    584 	printf("\t%u destination%s found unreachable\n",
    585 		rtstat.rts_unreach, plural(rtstat.rts_unreach));
    586 	printf("\t%u use%s of a wildcard route\n",
    587 		rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
    588 }
    589 short ns_nullh[] = {0,0,0};
    590 short ns_bh[] = {-1,-1,-1};
    591 
    592 char *
    593 ns_print(sa)
    594 	register struct sockaddr *sa;
    595 {
    596 	register struct sockaddr_ns *sns = (struct sockaddr_ns*)sa;
    597 	struct ns_addr work;
    598 	union { union ns_net net_e; u_long long_e; } net;
    599 	u_short port;
    600 	static char mybuf[50], cport[10], chost[25];
    601 	char *host = "";
    602 	register char *p; register u_char *q;
    603 
    604 	work = sns->sns_addr;
    605 	port = ntohs(work.x_port);
    606 	work.x_port = 0;
    607 	net.net_e  = work.x_net;
    608 	if (ns_nullhost(work) && net.long_e == 0) {
    609 		if (port ) {
    610 			sprintf(mybuf, "*.%xH", port);
    611 			upHex(mybuf);
    612 		} else
    613 			sprintf(mybuf, "*.*");
    614 		return (mybuf);
    615 	}
    616 
    617 	if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) {
    618 		host = "any";
    619 	} else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
    620 		host = "*";
    621 	} else {
    622 		q = work.x_host.c_host;
    623 		sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
    624 			q[0], q[1], q[2], q[3], q[4], q[5]);
    625 		for (p = chost; *p == '0' && p < chost + 12; p++)
    626 			continue;
    627 		host = p;
    628 	}
    629 	if (port)
    630 		sprintf(cport, ".%xH", htons(port));
    631 	else
    632 		*cport = 0;
    633 
    634 	sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
    635 	upHex(mybuf);
    636 	return(mybuf);
    637 }
    638 
    639 char *
    640 ns_phost(sa)
    641 	struct sockaddr *sa;
    642 {
    643 	register struct sockaddr_ns *sns = (struct sockaddr_ns *)sa;
    644 	struct sockaddr_ns work;
    645 	static union ns_net ns_zeronet;
    646 	char *p;
    647 
    648 	work = *sns;
    649 	work.sns_addr.x_port = 0;
    650 	work.sns_addr.x_net = ns_zeronet;
    651 
    652 	p = ns_print((struct sockaddr *)&work);
    653 	if (strncmp("0H.", p, 3) == 0) p += 3;
    654 	return(p);
    655 }
    656 
    657 void
    658 upHex(p0)
    659 	char *p0;
    660 {
    661 	register char *p = p0;
    662 	for (; *p; p++) switch (*p) {
    663 
    664 	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
    665 		*p += ('A' - 'a');
    666 	}
    667 }
    668