1/* 2 * print.c - common print support functions for lsof 3 */ 4 5 6/* 7 * Copyright 1994 Purdue Research Foundation, West Lafayette, Indiana 8 * 47907. All rights reserved. 9 * 10 * Written by Victor A. Abell 11 * 12 * This software is not subject to any license of the American Telephone 13 * and Telegraph Company or the Regents of the University of California. 14 * 15 * Permission is granted to anyone to use this software for any purpose on 16 * any computer system, and to alter it and redistribute it freely, subject 17 * to the following restrictions: 18 * 19 * 1. Neither the authors nor Purdue University are responsible for any 20 * consequences of the use of this software. 21 * 22 * 2. The origin of this software must not be misrepresented, either by 23 * explicit claim or by omission. Credit to the authors and Purdue 24 * University must appear in documentation and sources. 25 * 26 * 3. Altered versions must be plainly marked as such, and must not be 27 * misrepresented as being the original software. 28 * 29 * 4. This notice may not be removed or altered. 30 */ 31 32#ifndef lint 33static char copyright[] = 34"@(#) Copyright 1994 Purdue Research Foundation.\nAll rights reserved.\n"; 35static char *rcsid = "$Id: print.c,v 1.54 2012/04/10 16:30:51 abe Exp abe $"; 36#endif 37 38 39#include "lsof.h" 40 41 42/* 43 * Local definitions, structures and function prototypes 44 */ 45 46#define HCINC 64 /* host cache size increase chunk */ 47#define PORTHASHBUCKETS 128 /* port hash bucket count 48 * !!MUST BE A POWER OF 2!! */ 49#define PORTTABTHRESH 10 /* threshold at which we will switch 50 * from using getservbyport() to 51 * getservent() -- see lkup_port() 52 * and fill_porttab() */ 53 54struct hostcache { 55 unsigned char a[MAX_AF_ADDR]; /* numeric address */ 56 int af; /* address family -- e.g., AF_INET 57 * or AF_INET6 */ 58 char *name; /* name */ 59}; 60 61struct porttab { 62 int port; 63 MALLOC_S nl; /* name length (excluding '\0') */ 64 int ss; /* service name status, 0 = lookup not 65 * yet performed */ 66 char *name; 67 struct porttab *next; 68}; 69 70 71#if defined(HASNORPC_H) 72static struct porttab **Pth[2] = { NULL, NULL }; 73 /* port hash buckets: 74 * Pth[0] for TCP service names 75 * Pth[1] for UDP service names 76 */ 77#else /* !defined(HASNORPC_H) */ 78static struct porttab **Pth[4] = { NULL, NULL, NULL, NULL }; 79 /* port hash buckets: 80 * Pth[0] for TCP service names 81 * Pth[1] for UDP service names 82 * Pth[2] for TCP portmap info 83 * Pth[3] for UDP portmap info 84 */ 85#endif /* defined(HASNORPC_H) */ 86 87#define HASHPORT(p) (((((int)(p)) * 31415) >> 3) & (PORTHASHBUCKETS - 1)) 88 89 90#if !defined(HASNORPC_H) 91_PROTOTYPE(static void fill_portmap,(void)); 92_PROTOTYPE(static void update_portmap,(struct porttab *pt, char *pn)); 93#endif /* !defined(HASNORPC_H) */ 94 95_PROTOTYPE(static void fill_porttab,(void)); 96_PROTOTYPE(static char *lkup_port,(int p, int pr, int src)); 97_PROTOTYPE(static char *lkup_svcnam,(int h, int p, int pr, int ss)); 98_PROTOTYPE(static int printinaddr,(void)); 99 100 101/* 102 * endnm() - locate end of Namech 103 */ 104 105char * 106endnm(sz) 107 size_t *sz; /* returned remaining size */ 108{ 109 register char *s; 110 register size_t tsz; 111 112 for (s = Namech, tsz = Namechl; *s; s++, tsz--) 113 ; 114 *sz = tsz; 115 return(s); 116} 117 118 119#if !defined(HASNORPC_H) 120/* 121 * fill_portmap() -- fill the RPC portmap program name table via a conversation 122 * with the portmapper 123 * 124 * The following copyright notice acknowledges that this function was adapted 125 * from getrpcportnam() of the source code of the OpenBSD netstat program. 126 */ 127 128/* 129* Copyright (c) 1983, 1988, 1993 130* The Regents of the University of California. All rights reserved. 131* 132* Redistribution and use in source and binary forms, with or without 133* modification, are permitted provided that the following conditions 134* are met: 135* 1. Redistributions of source code must retain the above copyright 136* notice, this list of conditions and the following disclaimer. 137* 2. Redistributions in binary form must reproduce the above copyright 138* notice, this list of conditions and the following disclaimer in the 139* documentation and/or other materials provided with the distribution. 140* 3. All advertising materials mentioning features or use of this software 141* must display the following acknowledgement: 142* This product includes software developed by the University of 143* California, Berkeley and its contributors. 144* 4. Neither the name of the University nor the names of its contributors 145* may be used to endorse or promote products derived from this software 146* without specific prior written permission. 147* 148* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 149* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 150* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 151* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 152* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 153* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 154* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 155* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 156* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 157* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 158* SUCH DAMAGE. 159*/ 160 161static void 162fill_portmap() 163{ 164 char buf[128], *cp, *nm; 165 CLIENT *c; 166 int h, port, pr; 167 MALLOC_S nl; 168 struct pmaplist *p = (struct pmaplist *)NULL; 169 struct porttab *pt; 170 struct rpcent *r; 171 struct TIMEVAL_LSOF tm; 172 173#if !defined(CAN_USE_CLNT_CREATE) 174 struct hostent *he; 175 struct sockaddr_in ia; 176 int s = RPC_ANYSOCK; 177#endif /* !defined(CAN_USE_CLNT_CREATE) */ 178 179/* 180 * Construct structures for communicating with the portmapper. 181 */ 182 183#if !defined(CAN_USE_CLNT_CREATE) 184 zeromem(&ia, sizeof(ia)); 185 ia.sin_family = AF_INET; 186 if ((he = gethostbyname("localhost"))) 187 MEMMOVE((caddr_t)&ia.sin_addr, he->h_addr, he->h_length); 188 ia.sin_port = htons(PMAPPORT); 189#endif /* !defined(CAN_USE_CLNT_CREATE) */ 190 191 tm.tv_sec = 60; 192 tm.tv_usec = 0; 193/* 194 * Get an RPC client handle. Then ask for a dump of the port map. 195 */ 196 197#if defined(CAN_USE_CLNT_CREATE) 198 if (!(c = clnt_create("localhost", PMAPPROG, PMAPVERS, "tcp"))) 199#else /* !defined(CAN_USE_CLNT_CREATE) */ 200 if (!(c = clnttcp_create(&ia, PMAPPROG, PMAPVERS, &s, 0, 0))) 201#endif /* defined(CAN_USE_CLNT_CREATE) */ 202 203 return; 204 if (clnt_call(c, PMAPPROC_DUMP, XDR_VOID, NULL, XDR_PMAPLIST, 205 (caddr_t)&p, tm) 206 != RPC_SUCCESS) { 207 clnt_destroy(c); 208 return; 209 } 210/* 211 * Loop through the port map dump, creating portmap table entries from TCP 212 * and UDP members. 213 */ 214 for (; p; p = p->pml_next) { 215 216 /* 217 * Determine the port map entry's protocol; ignore all but TCP and UDP. 218 */ 219 if (p->pml_map.pm_prot == IPPROTO_TCP) 220 pr = 2; 221 else if (p->pml_map.pm_prot == IPPROTO_UDP) 222 pr = 3; 223 else 224 continue; 225 /* 226 * See if there's already a portmap entry for this port. If there is, 227 * ignore this entry. 228 */ 229 h = HASHPORT((port = (int)p->pml_map.pm_port)); 230 for (pt = Pth[pr][h]; pt; pt = pt->next) { 231 if (pt->port == port) 232 break; 233 } 234 if (pt) 235 continue; 236 /* 237 * Save the registration name or number. 238 */ 239 cp = (char *)NULL; 240 if ((r = (struct rpcent *)getrpcbynumber(p->pml_map.pm_prog))) { 241 if (r->r_name && strlen(r->r_name)) 242 cp = r->r_name; 243 } 244 if (!cp) { 245 (void) snpf(buf, sizeof(buf), "%lu", 246 (unsigned long)p->pml_map.pm_prog); 247 cp = buf; 248 } 249 if (!strlen(cp)) 250 continue; 251 /* 252 * Allocate space for the portmap name entry and copy it there. 253 */ 254 if (!(nm = mkstrcpy(cp, &nl))) { 255 (void) fprintf(stderr, 256 "%s: can't allocate space for portmap entry: ", Pn); 257 safestrprt(cp, stderr, 1); 258 Exit(1); 259 } 260 if (!nl) { 261 (void) free((FREE_P *)nm); 262 continue; 263 } 264 /* 265 * Allocate and fill a porttab struct entry for the portmap table. 266 * Link it to the head of its hash bucket, and make it the new head. 267 */ 268 if (!(pt = (struct porttab *)malloc(sizeof(struct porttab)))) { 269 (void) fprintf(stderr, 270 "%s: can't allocate porttab entry for portmap: ", Pn); 271 safestrprt(nm, stderr, 1); 272 Exit(1); 273 } 274 pt->name = nm; 275 pt->nl = nl; 276 pt->port = port; 277 pt->next = Pth[pr][h]; 278 pt->ss = 0; 279 Pth[pr][h] = pt; 280 } 281 clnt_destroy(c); 282} 283#endif /* !defined(HASNORPC_H) */ 284 285 286/* 287 * fill_porttab() -- fill the TCP and UDP service name port table with a 288 * getservent() scan 289 */ 290 291static void 292fill_porttab() 293{ 294 int h, p, pr; 295 MALLOC_S nl; 296 char *nm; 297 struct porttab *pt; 298 struct servent *se; 299 300 (void) endservent(); 301/* 302 * Scan the services data base for TCP and UDP entries that have a non-null 303 * name associated with them. 304 */ 305 (void) setservent(1); 306 while ((se = getservent())) { 307 if (!se->s_name || !se->s_proto) 308 continue; 309 if (strcasecmp(se->s_proto, "TCP") == 0) 310 pr = 0; 311 else if (strcasecmp(se->s_proto, "UDP") == 0) 312 pr = 1; 313 else 314 continue; 315 if (!se->s_name || !strlen(se->s_name)) 316 continue; 317 p = ntohs(se->s_port); 318 /* 319 * See if a port->service entry is already cached for this port and 320 * prototcol. If it is, leave it alone. 321 */ 322 h = HASHPORT(p); 323 for (pt = Pth[pr][h]; pt; pt = pt->next) { 324 if (pt->port == p) 325 break; 326 } 327 if (pt) 328 continue; 329 /* 330 * Add a new entry to the cache for this port and protocol. 331 */ 332 if (!(nm = mkstrcpy(se->s_name, &nl))) { 333 (void) fprintf(stderr, 334 "%s: can't allocate %d bytes for port %d name: %s\n", 335 Pn, (int)(nl + 1), p, se->s_name); 336 Exit(1); 337 } 338 if (!nl) { 339 (void) free((FREE_P *)nm); 340 continue; 341 } 342 if (!(pt = (struct porttab *)malloc(sizeof(struct porttab)))) { 343 (void) fprintf(stderr, 344 "%s: can't allocate porttab entry for port %d: %s\n", 345 Pn, p, se->s_name); 346 Exit(1); 347 } 348 pt->name = nm; 349 pt->nl = nl - 1; 350 pt->port = p; 351 pt->next = Pth[pr][h]; 352 pt->ss = 0; 353 Pth[pr][h] = pt; 354 } 355 (void) endservent(); 356} 357 358 359/* 360 * gethostnm() - get host name 361 */ 362 363char * 364gethostnm(ia, af) 365 unsigned char *ia; /* Internet address */ 366 int af; /* address family -- e.g., AF_INET 367 * or AF_INET6 */ 368{ 369 int al = MIN_AF_ADDR; 370 char hbuf[256]; 371 static struct hostcache *hc = (struct hostcache *)NULL; 372 static int hcx = 0; 373 char *hn, *np; 374 struct hostent *he = (struct hostent *)NULL; 375 int i, j; 376 MALLOC_S len; 377 static int nhc = 0; 378/* 379 * Search cache. 380 */ 381 382#if defined(HASIPv6) 383 if (af == AF_INET6) 384 al = MAX_AF_ADDR; 385#endif /* defined(HASIPv6) */ 386 387 for (i = 0; i < hcx; i++) { 388 if (af != hc[i].af) 389 continue; 390 for (j = 0; j < al; j++) { 391 if (ia[j] != hc[i].a[j]) 392 break; 393 } 394 if (j >= al) 395 return(hc[i].name); 396 } 397/* 398 * If -n has been specified, construct a numeric address. Otherwise, look up 399 * host name by address. If that fails, or if there is no name in the returned 400 * hostent structure, construct a numeric version of the address. 401 */ 402 if (Fhost) 403 he = gethostbyaddr((char *)ia, al, af); 404 if (!he || !he->h_name) { 405 406#if defined(HASIPv6) 407 if (af == AF_INET6) { 408 409 /* 410 * Since IPv6 numeric addresses use `:' as a separator, enclose 411 * them in brackets. 412 */ 413 hbuf[0] = '['; 414 if (!inet_ntop(af, ia, hbuf + 1, sizeof(hbuf) - 3)) { 415 (void) snpf(&hbuf[1], (sizeof(hbuf) - 1), 416 "can't format IPv6 address]"); 417 } else { 418 len = strlen(hbuf); 419 (void) snpf(&hbuf[len], sizeof(hbuf) - len, "]"); 420 } 421 } else 422#endif /* defined(HASIPv6) */ 423 424 if (af == AF_INET) 425 (void) snpf(hbuf, sizeof(hbuf), "%u.%u.%u.%u", ia[0], ia[1], 426 ia[2], ia[3]); 427 else 428 (void) snpf(hbuf, sizeof(hbuf), "(unknown AF value: %d)", af); 429 hn = hbuf; 430 } else 431 hn = (char *)he->h_name; 432/* 433 * Allocate space for name and copy name to it. 434 */ 435 if (!(np = mkstrcpy(hn, (MALLOC_S *)NULL))) { 436 (void) fprintf(stderr, "%s: no space for host name: ", Pn); 437 safestrprt(hn, stderr, 1); 438 Exit(1); 439 } 440/* 441 * Add address/name entry to cache. Allocate cache space in HCINC chunks. 442 */ 443 if (hcx >= nhc) { 444 nhc += HCINC; 445 len = (MALLOC_S)(nhc * sizeof(struct hostcache)); 446 if (!hc) 447 hc = (struct hostcache *)malloc(len); 448 else 449 hc = (struct hostcache *)realloc((MALLOC_P *)hc, len); 450 if (!hc) { 451 (void) fprintf(stderr, "%s: no space for host cache\n", Pn); 452 Exit(1); 453 } 454 } 455 hc[hcx].af = af; 456 for (i = 0; i < al; i++) { 457 hc[hcx].a[i] = ia[i]; 458 } 459 hc[hcx++].name = np; 460 return(np); 461} 462 463 464/* 465 * lkup_port() - look up port for protocol 466 */ 467 468static char * 469lkup_port(p, pr, src) 470 int p; /* port number */ 471 int pr; /* protocol index: 0 = tcp, 1 = udp */ 472 int src; /* port source: 0 = local 473 * 1 = foreign */ 474{ 475 int h, nh; 476 MALLOC_S nl; 477 char *nm, *pn; 478 static char pb[128]; 479 static int pm = 0; 480 struct porttab *pt; 481/* 482 * If the hash buckets haven't been allocated, do so. 483 */ 484 if (!Pth[0]) { 485 486#if defined(HASNORPC_H) 487 nh = 2; 488#else /* !defined(HASNORPC_H) */ 489 nh = FportMap ? 4 : 2; 490#endif /* defined(HASNORPC_H) */ 491 492 for (h = 0; h < nh; h++) { 493 if (!(Pth[h] = (struct porttab **)calloc(PORTHASHBUCKETS, 494 sizeof(struct porttab *)))) 495 { 496 (void) fprintf(stderr, 497 "%s: can't allocate %d bytes for %s %s hash buckets\n", 498 Pn, 499 (int)(2 * (PORTHASHBUCKETS * sizeof(struct porttab *))), 500 (h & 1) ? "UDP" : "TCP", 501 (h > 1) ? "portmap" : "port"); 502 Exit(1); 503 } 504 } 505 } 506 507#if !defined(HASNORPC_H) 508/* 509 * If we're looking up program names for portmapped ports, make sure the 510 * portmap table has been loaded. 511 */ 512 if (FportMap && !pm) { 513 (void) fill_portmap(); 514 pm++; 515 } 516#endif /* !defined(HASNORPC_H) */ 517 518/* 519 * Hash the port and see if its name has been cached. Look for a local 520 * port first in the portmap, if portmap searching is enabled. 521 */ 522 h = HASHPORT(p); 523 524#if !defined(HASNORPC_H) 525 if (!src && FportMap) { 526 for (pt = Pth[pr+2][h]; pt; pt = pt->next) { 527 if (pt->port != p) 528 continue; 529 if (!pt->ss) { 530 pn = Fport ? lkup_svcnam(h, p, pr, 0) : (char *)NULL; 531 if (!pn) { 532 (void) snpf(pb, sizeof(pb), "%d", p); 533 pn = pb; 534 } 535 (void) update_portmap(pt, pn); 536 } 537 return(pt->name); 538 } 539 } 540#endif /* !defined(HASNORPC_H) */ 541 542 for (pt = Pth[pr][h]; pt; pt = pt->next) { 543 if (pt->port == p) 544 return(pt->name); 545 } 546/* 547 * Search for a possible service name, unless the -P option has been specified. 548 * 549 * If there is no service name, return a %d conversion. 550 * 551 * Don't cache %d conversions; a zero port number is a %d conversion that 552 * is represented by "*". 553 */ 554 pn = Fport ? lkup_svcnam(h, p, pr, 1) : (char *)NULL; 555 if (!pn || !strlen(pn)) { 556 if (p) { 557 (void) snpf(pb, sizeof(pb), "%d", p); 558 return(pb); 559 } else 560 return("*"); 561 } 562/* 563 * Allocate a new porttab entry for the TCP or UDP service name. 564 */ 565 if (!(pt = (struct porttab *)malloc(sizeof(struct porttab)))) { 566 (void) fprintf(stderr, 567 "%s: can't allocate porttab entry for port %d\n", Pn, p); 568 Exit(1); 569 } 570/* 571 * Allocate space for the name; copy it to the porttab entry; and link the 572 * porttab entry to its hash bucket. 573 * 574 * Return a pointer to the name. 575 */ 576 if (!(nm = mkstrcpy(pn, &nl))) { 577 (void) fprintf(stderr, 578 "%s: can't allocate space for port name: ", Pn); 579 safestrprt(pn, stderr, 1); 580 Exit(1); 581 } 582 pt->name = nm; 583 pt->nl = nl; 584 pt->port = p; 585 pt->next = Pth[pr][h]; 586 pt->ss = 0; 587 Pth[pr][h] = pt; 588 return(nm); 589} 590 591 592/* 593 * lkup_svcnam() - look up service name for port 594 */ 595 596static char * 597lkup_svcnam(h, p, pr, ss) 598 int h; /* porttab hash index */ 599 int p; /* port number */ 600 int pr; /* protocol: 0 = TCP, 1 = UDP */ 601 int ss; /* search status: 1 = Pth[pr][h] 602 * already searched */ 603{ 604 static int fl[PORTTABTHRESH]; 605 static int fln = 0; 606 static int gsbp = 0; 607 int i; 608 struct porttab *pt; 609 static int ptf = 0; 610 struct servent *se; 611/* 612 * Do nothing if -P has been specified. 613 */ 614 if (!Fport) 615 return((char *)NULL); 616 617 for (;;) { 618 619 /* 620 * Search service name cache, if it hasn't already been done. 621 * Return the name of a match. 622 */ 623 if (!ss) { 624 for (pt = Pth[pr][h]; pt; pt = pt->next) { 625 if (pt->port == p) 626 return(pt->name); 627 } 628 } 629/* 630 * If fill_porttab() has been called, there is no service name. 631 * 632 * Do PORTTABTHRES getservbport() calls, remembering the failures, so they 633 * won't be repeated. 634 * 635 * After PORTABTHRESH getservbyport() calls, call fill_porttab() once, 636 */ 637 if (ptf) 638 break; 639 if (gsbp < PORTTABTHRESH) { 640 for (i = 0; i < fln; i++) { 641 if (fl[i] == p) 642 return((char *)NULL); 643 } 644 gsbp++; 645 if ((se = getservbyport(htons(p), pr ? "udp" : "tcp"))) 646 return(se->s_name); 647 if (fln < PORTTABTHRESH) 648 fl[fln++] = p; 649 return((char *)NULL); 650 } 651 (void) fill_porttab(); 652 ptf++; 653 ss = 0; 654 } 655 return((char *)NULL); 656} 657 658 659/* 660 * print_file() - print file 661 */ 662 663void 664print_file() 665{ 666 char buf[128]; 667 char *cp = (char *)NULL; 668 dev_t dev; 669 int devs, len; 670 671 if (PrPass && !Hdr) { 672 673 /* 674 * Print the header line if this is the second pass and the 675 * header hasn't already been printed. 676 */ 677 (void) printf("%-*.*s %*s", CmdColW, CmdColW, CMDTTL, PidColW, 678 PIDTTL); 679 680#if defined(HASTASKS) 681 if (TaskPrtFl) 682 (void) printf(" %*s", TidColW, TIDTTL); 683#endif /* defined(HASTASKS) */ 684 685#if defined(HASZONES) 686 if (Fzone) 687 (void) printf(" %-*s", ZoneColW, ZONETTL); 688#endif /* defined(HASZONES) */ 689 690#if defined(HASSELINUX) 691 if (Fcntx) 692 (void) printf(" %-*s", CntxColW, CNTXTTL); 693#endif /* defined(HASSELINUX) */ 694 695#if defined(HASPPID) 696 if (Fppid) 697 (void) printf(" %*s", PpidColW, PPIDTTL); 698#endif /* defined(HASPPID) */ 699 700 if (Fpgid) 701 (void) printf(" %*s", PgidColW, PGIDTTL); 702 (void) printf(" %*s %*s %*s", 703 UserColW, USERTTL, 704 FdColW - 2, FDTTL, 705 TypeColW, TYPETTL); 706 707#if defined(HASFSTRUCT) 708 if (Fsv) { 709 710# if !defined(HASNOFSADDR) 711 if (Fsv & FSV_FA) 712 (void) printf(" %*s", FsColW, FSTTL); 713# endif /* !defined(HASNOFSADDR) */ 714 715# if !defined(HASNOFSCOUNT) 716 if (Fsv & FSV_CT) 717 (void) printf(" %*s", FcColW, FCTTL); 718# endif /* !defined(HASNOFSCOUNT) */ 719 720# if !defined(HASNOFSFLAGS) 721 if (Fsv & FSV_FG) 722 (void) printf(" %*s", FgColW, FGTTL); 723# endif /* !defined(HASNOFSFLAGS) */ 724 725# if !defined(HASNOFSNADDR) 726 if (Fsv & FSV_NI) 727 (void) printf(" %*s", NiColW, NiTtl); 728# endif /* !defined(HASNOFSNADDR) */ 729 730 } 731#endif /* defined(HASFSTRUCT) */ 732 733 (void) printf(" %*s", DevColW, DEVTTL); 734 if (Foffset) 735 (void) printf(" %*s", SzOffColW, OFFTTL); 736 else if (Fsize) 737 (void) printf(" %*s", SzOffColW, SZTTL); 738 else 739 (void) printf(" %*s", SzOffColW, SZOFFTTL); 740 if (Fnlink) 741 (void) printf(" %*s", NlColW, NLTTL); 742 (void) printf(" %*s %s\n", NodeColW, NODETTL, NMTTL); 743 Hdr++; 744 } 745/* 746 * Size or print the command. 747 */ 748 cp = (Lp->cmd && *Lp->cmd != '\0') ? Lp->cmd : "(unknown)"; 749 if (!PrPass) { 750 len = safestrlen(cp, 2); 751 if (CmdLim && (len > CmdLim)) 752 len = CmdLim; 753 if (len > CmdColW) 754 CmdColW = len; 755 } else 756 safestrprtn(cp, CmdColW, stdout, 2); 757/* 758 * Size or print the process ID. 759 */ 760 if (!PrPass) { 761 (void) snpf(buf, sizeof(buf), "%d", Lp->pid); 762 if ((len = strlen(buf)) > PidColW) 763 PidColW = len; 764 } else 765 (void) printf(" %*d", PidColW, Lp->pid); 766 767#if defined(HASTASKS) 768/* 769 * Size or print task ID. 770 */ 771 if (!PrPass) { 772 if (Lp->tid) { 773 (void) snpf(buf, sizeof(buf), "%d", Lp->tid); 774 if ((len = strlen(buf)) > TidColW) 775 TidColW = len; 776 TaskPrtFl = 1; 777 } 778 } else if (TaskPrtFl) { 779 if (Lp->tid) 780 (void) printf(" %*d", TidColW, Lp->tid); 781 else 782 (void) printf(" %*s", TidColW, ""); 783 } 784#endif /* defined(HASTASKS) */ 785 786#if defined(HASZONES) 787/* 788 * Size or print the zone. 789 */ 790 if (Fzone) { 791 if (!PrPass) { 792 if (Lp->zn) { 793 if ((len = strlen(Lp->zn)) > ZoneColW) 794 ZoneColW = len; 795 } 796 } else 797 (void) printf(" %-*s", ZoneColW, Lp->zn ? Lp->zn : ""); 798 } 799#endif /* defined(HASZONES) */ 800 801#if defined(HASSELINUX) 802/* 803 * Size or print the context. 804 */ 805 if (Fcntx) { 806 if (!PrPass) { 807 if (Lp->cntx) { 808 if ((len = strlen(Lp->cntx)) > CntxColW) 809 CntxColW = len; 810 } 811 } else 812 (void) printf(" %-*s", CntxColW, Lp->cntx ? Lp->cntx : ""); 813 } 814#endif /* defined(HASSELINUX) */ 815 816#if defined(HASPPID) 817 if (Fppid) { 818 819 /* 820 * Size or print the parent process ID. 821 */ 822 if (!PrPass) { 823 (void) snpf(buf, sizeof(buf), "%d", Lp->ppid); 824 if ((len = strlen(buf)) > PpidColW) 825 PpidColW = len; 826 } else 827 (void) printf(" %*d", PpidColW, Lp->ppid); 828 } 829#endif /* defined(HASPPID) */ 830 831 if (Fpgid) { 832 833 /* 834 * Size or print the process group ID. 835 */ 836 if (!PrPass) { 837 (void) snpf(buf, sizeof(buf), "%d", Lp->pgid); 838 if ((len = strlen(buf)) > PgidColW) 839 PgidColW = len; 840 } else 841 (void) printf(" %*d", PgidColW, Lp->pgid); 842 } 843/* 844 * Size or print the user ID or login name. 845 */ 846 if (!PrPass) { 847 if ((len = strlen(printuid((UID_ARG)Lp->uid, NULL))) > UserColW) 848 UserColW = len; 849 } else 850 (void) printf(" %*.*s", UserColW, UserColW, 851 printuid((UID_ARG)Lp->uid, NULL)); 852/* 853 * Size or print the file descriptor, access mode and lock status. 854 */ 855 if (!PrPass) { 856 (void) snpf(buf, sizeof(buf), "%s%c%c", 857 Lf->fd, 858 (Lf->lock == ' ') ? Lf->access 859 : (Lf->access == ' ') ? '-' 860 : Lf->access, 861 Lf->lock); 862 if ((len = strlen(buf)) > FdColW) 863 FdColW = len; 864 } else 865 (void) printf(" %*.*s%c%c", FdColW - 2, FdColW - 2, Lf->fd, 866 (Lf->lock == ' ') ? Lf->access 867 : (Lf->access == ' ') ? '-' 868 : Lf->access, 869 Lf->lock); 870/* 871 * Size or print the type. 872 */ 873 if (!PrPass) { 874 if ((len = strlen(Lf->type)) > TypeColW) 875 TypeColW = len; 876 } else 877 (void) printf(" %*.*s", TypeColW, TypeColW, Lf->type); 878 879#if defined(HASFSTRUCT) 880/* 881 * Size or print the file structure address, file usage count, and node 882 * ID (address). 883 */ 884 885 if (Fsv) { 886 887# if !defined(HASNOFSADDR) 888 if (Fsv & FSV_FA) { 889 cp = (Lf->fsv & FSV_FA) ? print_kptr(Lf->fsa, buf, sizeof(buf)) 890 : ""; 891 if (!PrPass) { 892 if ((len = strlen(cp)) > FsColW) 893 FsColW = len; 894 } else 895 (void) printf(" %*.*s", FsColW, FsColW, cp); 896 897 } 898# endif /* !defined(HASNOFSADDR) */ 899 900# if !defined(HASNOFSCOUNT) 901 if (Fsv & FSV_CT) { 902 if (Lf->fsv & FSV_CT) { 903 (void) snpf(buf, sizeof(buf), "%ld", Lf->fct); 904 cp = buf; 905 } else 906 cp = ""; 907 if (!PrPass) { 908 if ((len = strlen(cp)) > FcColW) 909 FcColW = len; 910 } else 911 (void) printf(" %*.*s", FcColW, FcColW, cp); 912 } 913# endif /* !defined(HASNOFSCOUNT) */ 914 915# if !defined(HASNOFSFLAGS) 916 if (Fsv & FSV_FG) { 917 if ((Lf->fsv & FSV_FG) && (FsvFlagX || Lf->ffg || Lf->pof)) 918 cp = print_fflags(Lf->ffg, Lf->pof); 919 else 920 cp = ""; 921 if (!PrPass) { 922 if ((len = strlen(cp)) > FgColW) 923 FgColW = len; 924 } else 925 (void) printf(" %*.*s", FgColW, FgColW, cp); 926 } 927# endif /* !defined(HASNOFSFLAGS) */ 928 929# if !defined(HASNOFSNADDR) 930 if (Fsv & FSV_NI) { 931 cp = (Lf->fsv & FSV_NI) ? print_kptr(Lf->fna, buf, sizeof(buf)) 932 : ""; 933 if (!PrPass) { 934 if ((len = strlen(cp)) > NiColW) 935 NiColW = len; 936 } else 937 (void) printf(" %*.*s", NiColW, NiColW, cp); 938 } 939# endif /* !defined(HASNOFSNADDR) */ 940 941 } 942#endif /* defined(HASFSTRUCT) */ 943 944/* 945 * Size or print the device information. 946 */ 947 948 if (Lf->rdev_def) { 949 dev = Lf->rdev; 950 devs = 1; 951 } else if (Lf->dev_def) { 952 dev = Lf->dev; 953 devs = 1; 954 } else 955 devs = 0; 956 if (devs) { 957 958#if defined(HASPRINTDEV) 959 cp = HASPRINTDEV(Lf, &dev); 960#else /* !defined(HASPRINTDEV) */ 961 (void) snpf(buf, sizeof(buf), "%u,%u", GET_MAJ_DEV(dev), 962 GET_MIN_DEV(dev)); 963 cp = buf; 964#endif /* defined(HASPRINTDEV) */ 965 966 } 967 968 if (!PrPass) { 969 if (devs) 970 len = strlen(cp); 971 else if (Lf->dev_ch) 972 len = strlen(Lf->dev_ch); 973 else 974 len = 0; 975 if (len > DevColW) 976 DevColW = len; 977 } else { 978 if (devs) 979 (void) printf(" %*.*s", DevColW, DevColW, cp); 980 else { 981 if (Lf->dev_ch) 982 (void) printf(" %*.*s", DevColW, DevColW, Lf->dev_ch); 983 else 984 (void) printf(" %*.*s", DevColW, DevColW, ""); 985 } 986 } 987/* 988 * Size or print the size or offset. 989 */ 990 if (!PrPass) { 991 if (Lf->sz_def) { 992 993#if defined(HASPRINTSZ) 994 cp = HASPRINTSZ(Lf); 995#else /* !defined(HASPRINTSZ) */ 996 (void) snpf(buf, sizeof(buf), SzOffFmt_d, Lf->sz); 997 cp = buf; 998#endif /* defined(HASPRINTSZ) */ 999 1000 len = strlen(cp); 1001 } else if (Lf->off_def) { 1002 1003#if defined(HASPRINTOFF) 1004 cp = HASPRINTOFF(Lf, 0); 1005#else /* !defined(HASPRINTOFF) */ 1006 (void) snpf(buf, sizeof(buf), SzOffFmt_0t, Lf->off); 1007 cp = buf; 1008#endif /* defined(HASPRINTOFF) */ 1009 1010 len = strlen(cp); 1011 if (OffDecDig && len > (OffDecDig + 2)) { 1012 1013#if defined(HASPRINTOFF) 1014 cp = HASPRINTOFF(Lf, 1); 1015#else /* !defined(HASPRINTOFF) */ 1016 (void) snpf(buf, sizeof(buf), SzOffFmt_x, Lf->off); 1017 cp = buf; 1018#endif /* defined(HASPRINTOFF) */ 1019 1020 len = strlen(cp); 1021 } 1022 } else 1023 len = 0; 1024 if (len > SzOffColW) 1025 SzOffColW = len; 1026 } else { 1027 putchar(' '); 1028 if (Lf->sz_def) 1029 1030#if defined(HASPRINTSZ) 1031 (void) printf("%*.*s", SzOffColW, SzOffColW, HASPRINTSZ(Lf)); 1032#else /* !defined(HASPRINTSZ) */ 1033 (void) printf(SzOffFmt_dv, SzOffColW, Lf->sz); 1034#endif /* defined(HASPRINTSZ) */ 1035 1036 else if (Lf->off_def) { 1037 1038#if defined(HASPRINTOFF) 1039 cp = HASPRINTOFF(Lf, 0); 1040#else /* !defined(HASPRINTOFF) */ 1041 (void) snpf(buf, sizeof(buf), SzOffFmt_0t, Lf->off); 1042 cp = buf; 1043#endif /* defined(HASPRINTOFF) */ 1044 1045 if (OffDecDig && (int)strlen(cp) > (OffDecDig + 2)) { 1046 1047#if defined(HASPRINTOFF) 1048 cp = HASPRINTOFF(Lf, 1); 1049#else /* !defined(HASPRINTOFF) */ 1050 (void) snpf(buf, sizeof(buf), SzOffFmt_x, Lf->off); 1051 cp = buf; 1052#endif /* defined(HASPRINTOFF) */ 1053 1054 } 1055 (void) printf("%*.*s", SzOffColW, SzOffColW, cp); 1056 } else 1057 (void) printf("%*.*s", SzOffColW, SzOffColW, ""); 1058 } 1059/* 1060 * Size or print the link count. 1061 */ 1062 if (Fnlink) { 1063 if (Lf->nlink_def) { 1064 (void) snpf(buf, sizeof(buf), " %ld", Lf->nlink); 1065 cp = buf; 1066 } else 1067 cp = ""; 1068 if (!PrPass) { 1069 if ((len = strlen(cp)) > NlColW) 1070 NlColW = len; 1071 } else 1072 (void) printf(" %*s", NlColW, cp); 1073 } 1074/* 1075 * Size or print the inode information. 1076 */ 1077 switch (Lf->inp_ty) { 1078 case 1: 1079 1080#if defined(HASPRINTINO) 1081 cp = HASPRINTINO(Lf); 1082#else /* !defined(HASPRINTINO) */ 1083 (void) snpf(buf, sizeof(buf), InodeFmt_d, Lf->inode); 1084 cp = buf; 1085#endif /* defined(HASPRINTINO) */ 1086 1087 break; 1088 case 2: 1089 if (Lf->iproto[0]) 1090 cp = Lf->iproto; 1091 else 1092 cp = ""; 1093 break; 1094 case 3: 1095 (void) snpf(buf, sizeof(buf), InodeFmt_x, Lf->inode); 1096 cp = buf; 1097 break; 1098 default: 1099 cp = ""; 1100 } 1101 if (!PrPass) { 1102 if ((len = strlen(cp)) > NodeColW) 1103 NodeColW = len; 1104 } else { 1105 (void) printf(" %*.*s", NodeColW, NodeColW, cp); 1106 } 1107/* 1108 * If this is the second pass, print the name column. (It doesn't need 1109 * to be sized.) 1110 */ 1111 if (PrPass) { 1112 putchar(' '); 1113 1114#if defined(HASPRINTNM) 1115 HASPRINTNM(Lf); 1116#else /* !defined(HASPRINTNM) */ 1117 printname(1); 1118#endif /* defined(HASPRINTNM) */ 1119 1120 } 1121} 1122 1123 1124/* 1125 * printinaddr() - print Internet addresses 1126 */ 1127 1128static int 1129printinaddr() 1130{ 1131 int i, len, src; 1132 char *host, *port; 1133 int nl = Namechl - 1; 1134 char *np = Namech; 1135 char pbuf[32]; 1136/* 1137 * Process local network address first. If there's a foreign address, 1138 * separate it from the local address with "->". 1139 */ 1140 for (i = 0, *np = '\0'; i < 2; i++) { 1141 if (!Lf->li[i].af) 1142 continue; 1143 host = port = (char *)NULL; 1144 if (i) { 1145 1146 /* 1147 * If this is the foreign address, insert the separator. 1148 */ 1149 if (nl < 2) 1150 1151addr_too_long: 1152 1153 { 1154 (void) snpf(Namech, Namechl, 1155 "network addresses too long"); 1156 return(1); 1157 } 1158 (void) snpf(np, nl, "->"); 1159 np += 2; 1160 nl -= 2; 1161 } 1162 /* 1163 * Convert the address to a host name. 1164 */ 1165 1166#if defined(HASIPv6) 1167 if ((Lf->li[i].af == AF_INET6 1168 && IN6_IS_ADDR_UNSPECIFIED(&Lf->li[i].ia.a6)) 1169 || (Lf->li[i].af == AF_INET 1170 && Lf->li[i].ia.a4.s_addr == INADDR_ANY)) 1171 host ="*"; 1172 else 1173 host = gethostnm((unsigned char *)&Lf->li[i].ia, Lf->li[i].af); 1174#else /* !defined(HASIPv6) */ 1175 if (Lf->li[i].ia.a4.s_addr == INADDR_ANY) 1176 host ="*"; 1177 else 1178 host = gethostnm((unsigned char *)&Lf->li[i].ia, Lf->li[i].af); 1179#endif /* defined(HASIPv6) */ 1180 1181 /* 1182 * Process the port number. 1183 */ 1184 if (Lf->li[i].p > 0) { 1185 1186 if (Fport 1187 1188#if !defined(HASNORPC_H) 1189 || FportMap 1190#endif /* defined(HASNORPC_H) */ 1191 1192 ) { 1193 1194 /* 1195 * If converting port numbers to service names, or looking 1196 * up portmap program names and numbers, do so by protocol. 1197 * 1198 * Identify the port source as local if: 1) it comes from the 1199 * local entry (0) of the file's Internet address array; or 1200 * 2) it comes from the foreign entry (1), and the foreign 1201 * Internet address matches the local one; or 3) it is the 1202 * loopback address 127.0.0.1. (Test 2 may not always work 1203 * -- e.g., on hosts with multiple interfaces.) 1204 */ 1205#if !defined(HASNORPC_H) 1206 if ((src = i) && FportMap) { 1207 1208# if defined(HASIPv6) 1209 if (Lf->li[0].af == AF_INET6) { 1210 if (IN6_IS_ADDR_LOOPBACK(&Lf->li[i].ia.a6) 1211 || IN6_ARE_ADDR_EQUAL(&Lf->li[0].ia.a6, 1212 &Lf->li[1].ia.a6) 1213 ) 1214 src = 0; 1215 } else 1216# endif /* defined(HASIPv6) */ 1217 1218 if (Lf->li[0].af == AF_INET) { 1219 if (Lf->li[i].ia.a4.s_addr == htonl(INADDR_LOOPBACK) 1220 || Lf->li[0].ia.a4.s_addr == Lf->li[1].ia.a4.s_addr 1221 ) 1222 src = 0; 1223 } 1224 } 1225#endif /* !defined(HASNORPC_H) */ 1226 1227 if (strcasecmp(Lf->iproto, "TCP") == 0) 1228 port = lkup_port(Lf->li[i].p, 0, src); 1229 else if (strcasecmp(Lf->iproto, "UDP") == 0) 1230 port = lkup_port(Lf->li[i].p, 1, src); 1231 } 1232 if (!port) { 1233 (void) snpf(pbuf, sizeof(pbuf), "%d", Lf->li[i].p); 1234 port = pbuf; 1235 } 1236 } else if (Lf->li[i].p == 0) 1237 port = "*"; 1238 /* 1239 * Enter the host name. 1240 */ 1241 if (host) { 1242 if ((len = strlen(host)) > nl) 1243 goto addr_too_long; 1244 if (len) { 1245 (void) snpf(np, nl, "%s", host); 1246 np += len; 1247 nl -= len; 1248 } 1249 } 1250 /* 1251 * Enter the port number, preceded by a colon. 1252 */ 1253 if (port) { 1254 if (((len = strlen(port)) + 1) >= nl) 1255 goto addr_too_long; 1256 (void) snpf(np, nl, ":%s", port); 1257 np += len + 1; 1258 nl -= len - 1; 1259 } 1260 } 1261 if (Namech[0]) { 1262 safestrprt(Namech, stdout, 0); 1263 return(1); 1264 } 1265 return(0); 1266} 1267 1268 1269/* 1270 * print_init() - initialize for printing 1271 */ 1272 1273void 1274print_init() 1275{ 1276 1277/* 1278 * Preset standard values. 1279 */ 1280 PrPass = (Ffield || Fterse) ? 1 : 0; 1281 LastPid = -1; 1282 TaskPrtFl = 0; 1283/* 1284 * Size columns by their titles. 1285 */ 1286 CmdColW = strlen(CMDTTL); 1287 DevColW = strlen(DEVTTL); 1288 FdColW = strlen(FDTTL); 1289 if (Fnlink) 1290 NlColW = strlen(NLTTL); 1291 NmColW = strlen(NMTTL); 1292 NodeColW = strlen(NODETTL); 1293 PgidColW = strlen(PGIDTTL); 1294 PidColW = strlen(PIDTTL); 1295 PpidColW = strlen(PPIDTTL); 1296 if (Fsize) 1297 SzOffColW = strlen(SZTTL); 1298 else if (Foffset) 1299 SzOffColW = strlen(OFFTTL); 1300 else 1301 SzOffColW = strlen(SZOFFTTL); 1302 1303#if defined(HASTASKS) 1304 TidColW = strlen(TIDTTL); 1305#endif /* defined(HASTASKS) */ 1306 1307 TypeColW = strlen(TYPETTL); 1308 UserColW = strlen(USERTTL); 1309 1310#if defined(HASFSTRUCT) 1311 1312# if !defined(HASNOFSADDR) 1313 FsColW = strlen(FSTTL); 1314# endif /* !defined(HASNOFSADDR) */ 1315 1316# if !defined(HASNOFSCOUNT) 1317 FcColW = strlen(FCTTL); 1318# endif /* !defined(HASNOFSCOUNT) */ 1319 1320# if !defined(HASNOFSFLAGS) 1321 FgColW = strlen(FGTTL); 1322# endif /* !defined(HASNOFSFLAGS) */ 1323 1324# if !defined(HASNOFSNADDR) 1325 NiColW = strlen(NiTtl); 1326# endif /* !defined(HASNOFSNADDR) */ 1327#endif /* defined(HASFSTRUCT) */ 1328 1329#if defined(HASSELINUX) 1330 if (Fcntx) 1331 CntxColW = strlen(CNTXTTL); 1332#endif /* defined(HASSELINUX) */ 1333 1334#if defined(HASZONES) 1335 if (Fzone) 1336 ZoneColW = strlen(ZONETTL); 1337#endif /* defined(HASZONES) */ 1338 1339} 1340 1341 1342#if !defined(HASPRIVPRIPP) 1343/* 1344 * printiproto() - print Internet protocol name 1345 */ 1346 1347void 1348printiproto(p) 1349 int p; /* protocol number */ 1350{ 1351 int i; 1352 static int m = -1; 1353 char *s; 1354 1355 switch (p) { 1356 1357#if defined(IPPROTO_TCP) 1358 case IPPROTO_TCP: 1359 s = "TCP"; 1360 break; 1361#endif /* defined(IPPROTO_TCP) */ 1362 1363#if defined(IPPROTO_UDP) 1364 case IPPROTO_UDP: 1365 s = "UDP"; 1366 break; 1367#endif /* defined(IPPROTO_UDP) */ 1368 1369#if defined(IPPROTO_IP) 1370# if !defined(IPPROTO_HOPOPTS) || IPPROTO_IP!=IPPROTO_HOPOPTS 1371 case IPPROTO_IP: 1372 s = "IP"; 1373 break; 1374# endif /* !defined(IPPROTO_HOPOPTS) || IPPROTO_IP!=IPPROTO_HOPOPTS */ 1375#endif /* defined(IPPROTO_IP) */ 1376 1377#if defined(IPPROTO_ICMP) 1378 case IPPROTO_ICMP: 1379 s = "ICMP"; 1380 break; 1381#endif /* defined(IPPROTO_ICMP) */ 1382 1383#if defined(IPPROTO_ICMPV6) 1384 case IPPROTO_ICMPV6: 1385 s = "ICMPV6"; 1386 break; 1387#endif /* defined(IPPROTO_ICMPV6) */ 1388 1389#if defined(IPPROTO_IGMP) 1390 case IPPROTO_IGMP: 1391 s = "IGMP"; 1392 break; 1393#endif /* defined(IPPROTO_IGMP) */ 1394 1395#if defined(IPPROTO_GGP) 1396 case IPPROTO_GGP: 1397 s = "GGP"; 1398 break; 1399#endif /* defined(IPPROTO_GGP) */ 1400 1401#if defined(IPPROTO_EGP) 1402 case IPPROTO_EGP: 1403 s = "EGP"; 1404 break; 1405#endif /* defined(IPPROTO_EGP) */ 1406 1407#if defined(IPPROTO_PUP) 1408 case IPPROTO_PUP: 1409 s = "PUP"; 1410 break; 1411#endif /* defined(IPPROTO_PUP) */ 1412 1413#if defined(IPPROTO_IDP) 1414 case IPPROTO_IDP: 1415 s = "IDP"; 1416 break; 1417#endif /* defined(IPPROTO_IDP) */ 1418 1419#if defined(IPPROTO_ND) 1420 case IPPROTO_ND: 1421 s = "ND"; 1422 break; 1423#endif /* defined(IPPROTO_ND) */ 1424 1425#if defined(IPPROTO_RAW) 1426 case IPPROTO_RAW: 1427 s = "RAW"; 1428 break; 1429#endif /* defined(IPPROTO_RAW) */ 1430 1431#if defined(IPPROTO_HELLO) 1432 case IPPROTO_HELLO: 1433 s = "HELLO"; 1434 break; 1435#endif /* defined(IPPROTO_HELLO) */ 1436 1437#if defined(IPPROTO_PXP) 1438 case IPPROTO_PXP: 1439 s = "PXP"; 1440 break; 1441#endif /* defined(IPPROTO_PXP) */ 1442 1443#if defined(IPPROTO_RAWIP) 1444 case IPPROTO_RAWIP: 1445 s = "RAWIP"; 1446 break; 1447#endif /* defined(IPPROTO_RAWIP) */ 1448 1449#if defined(IPPROTO_RAWIF) 1450 case IPPROTO_RAWIF: 1451 s = "RAWIF"; 1452 break; 1453#endif /* defined(IPPROTO_RAWIF) */ 1454 1455#if defined(IPPROTO_HOPOPTS) 1456 case IPPROTO_HOPOPTS: 1457 s = "HOPOPTS"; 1458 break; 1459#endif /* defined(IPPROTO_HOPOPTS) */ 1460 1461#if defined(IPPROTO_IPIP) 1462 case IPPROTO_IPIP: 1463 s = "IPIP"; 1464 break; 1465#endif /* defined(IPPROTO_IPIP) */ 1466 1467#if defined(IPPROTO_ST) 1468 case IPPROTO_ST: 1469 s = "ST"; 1470 break; 1471#endif /* defined(IPPROTO_ST) */ 1472 1473#if defined(IPPROTO_PIGP) 1474 case IPPROTO_PIGP: 1475 s = "PIGP"; 1476 break; 1477#endif /* defined(IPPROTO_PIGP) */ 1478 1479#if defined(IPPROTO_RCCMON) 1480 case IPPROTO_RCCMON: 1481 s = "RCCMON"; 1482 break; 1483#endif /* defined(IPPROTO_RCCMON) */ 1484 1485#if defined(IPPROTO_NVPII) 1486 case IPPROTO_NVPII: 1487 s = "NVPII"; 1488 break; 1489#endif /* defined(IPPROTO_NVPII) */ 1490 1491#if defined(IPPROTO_ARGUS) 1492 case IPPROTO_ARGUS: 1493 s = "ARGUS"; 1494 break; 1495#endif /* defined(IPPROTO_ARGUS) */ 1496 1497#if defined(IPPROTO_EMCON) 1498 case IPPROTO_EMCON: 1499 s = "EMCON"; 1500 break; 1501#endif /* defined(IPPROTO_EMCON) */ 1502 1503#if defined(IPPROTO_XNET) 1504 case IPPROTO_XNET: 1505 s = "XNET"; 1506 break; 1507#endif /* defined(IPPROTO_XNET) */ 1508 1509#if defined(IPPROTO_CHAOS) 1510 case IPPROTO_CHAOS: 1511 s = "CHAOS"; 1512 break; 1513#endif /* defined(IPPROTO_CHAOS) */ 1514 1515#if defined(IPPROTO_MUX) 1516 case IPPROTO_MUX: 1517 s = "MUX"; 1518 break; 1519#endif /* defined(IPPROTO_MUX) */ 1520 1521#if defined(IPPROTO_MEAS) 1522 case IPPROTO_MEAS: 1523 s = "MEAS"; 1524 break; 1525#endif /* defined(IPPROTO_MEAS) */ 1526 1527#if defined(IPPROTO_HMP) 1528 case IPPROTO_HMP: 1529 s = "HMP"; 1530 break; 1531#endif /* defined(IPPROTO_HMP) */ 1532 1533#if defined(IPPROTO_PRM) 1534 case IPPROTO_PRM: 1535 s = "PRM"; 1536 break; 1537#endif /* defined(IPPROTO_PRM) */ 1538 1539#if defined(IPPROTO_TRUNK1) 1540 case IPPROTO_TRUNK1: 1541 s = "TRUNK1"; 1542 break; 1543#endif /* defined(IPPROTO_TRUNK1) */ 1544 1545#if defined(IPPROTO_TRUNK2) 1546 case IPPROTO_TRUNK2: 1547 s = "TRUNK2"; 1548 break; 1549#endif /* defined(IPPROTO_TRUNK2) */ 1550 1551#if defined(IPPROTO_LEAF1) 1552 case IPPROTO_LEAF1: 1553 s = "LEAF1"; 1554 break; 1555#endif /* defined(IPPROTO_LEAF1) */ 1556 1557#if defined(IPPROTO_LEAF2) 1558 case IPPROTO_LEAF2: 1559 s = "LEAF2"; 1560 break; 1561#endif /* defined(IPPROTO_LEAF2) */ 1562 1563#if defined(IPPROTO_RDP) 1564 case IPPROTO_RDP: 1565 s = "RDP"; 1566 break; 1567#endif /* defined(IPPROTO_RDP) */ 1568 1569#if defined(IPPROTO_IRTP) 1570 case IPPROTO_IRTP: 1571 s = "IRTP"; 1572 break; 1573#endif /* defined(IPPROTO_IRTP) */ 1574 1575#if defined(IPPROTO_TP) 1576 case IPPROTO_TP: 1577 s = "TP"; 1578 break; 1579#endif /* defined(IPPROTO_TP) */ 1580 1581#if defined(IPPROTO_BLT) 1582 case IPPROTO_BLT: 1583 s = "BLT"; 1584 break; 1585#endif /* defined(IPPROTO_BLT) */ 1586 1587#if defined(IPPROTO_NSP) 1588 case IPPROTO_NSP: 1589 s = "NSP"; 1590 break; 1591#endif /* defined(IPPROTO_NSP) */ 1592 1593#if defined(IPPROTO_INP) 1594 case IPPROTO_INP: 1595 s = "INP"; 1596 break; 1597#endif /* defined(IPPROTO_INP) */ 1598 1599#if defined(IPPROTO_SEP) 1600 case IPPROTO_SEP: 1601 s = "SEP"; 1602 break; 1603#endif /* defined(IPPROTO_SEP) */ 1604 1605#if defined(IPPROTO_3PC) 1606 case IPPROTO_3PC: 1607 s = "3PC"; 1608 break; 1609#endif /* defined(IPPROTO_3PC) */ 1610 1611#if defined(IPPROTO_IDPR) 1612 case IPPROTO_IDPR: 1613 s = "IDPR"; 1614 break; 1615#endif /* defined(IPPROTO_IDPR) */ 1616 1617#if defined(IPPROTO_XTP) 1618 case IPPROTO_XTP: 1619 s = "XTP"; 1620 break; 1621#endif /* defined(IPPROTO_XTP) */ 1622 1623#if defined(IPPROTO_DDP) 1624 case IPPROTO_DDP: 1625 s = "DDP"; 1626 break; 1627#endif /* defined(IPPROTO_DDP) */ 1628 1629#if defined(IPPROTO_CMTP) 1630 case IPPROTO_CMTP: 1631 s = "CMTP"; 1632 break; 1633#endif /* defined(IPPROTO_CMTP) */ 1634 1635#if defined(IPPROTO_TPXX) 1636 case IPPROTO_TPXX: 1637 s = "TPXX"; 1638 break; 1639#endif /* defined(IPPROTO_TPXX) */ 1640 1641#if defined(IPPROTO_IL) 1642 case IPPROTO_IL: 1643 s = "IL"; 1644 break; 1645#endif /* defined(IPPROTO_IL) */ 1646 1647#if defined(IPPROTO_IPV6) 1648 case IPPROTO_IPV6: 1649 s = "IPV6"; 1650 break; 1651#endif /* defined(IPPROTO_IPV6) */ 1652 1653#if defined(IPPROTO_SDRP) 1654 case IPPROTO_SDRP: 1655 s = "SDRP"; 1656 break; 1657#endif /* defined(IPPROTO_SDRP) */ 1658 1659#if defined(IPPROTO_ROUTING) 1660 case IPPROTO_ROUTING: 1661 s = "ROUTING"; 1662 break; 1663#endif /* defined(IPPROTO_ROUTING) */ 1664 1665#if defined(IPPROTO_FRAGMENT) 1666 case IPPROTO_FRAGMENT: 1667 s = "FRAGMNT"; 1668 break; 1669#endif /* defined(IPPROTO_FRAGMENT) */ 1670 1671#if defined(IPPROTO_IDRP) 1672 case IPPROTO_IDRP: 1673 s = "IDRP"; 1674 break; 1675#endif /* defined(IPPROTO_IDRP) */ 1676 1677#if defined(IPPROTO_RSVP) 1678 case IPPROTO_RSVP: 1679 s = "RSVP"; 1680 break; 1681#endif /* defined(IPPROTO_RSVP) */ 1682 1683#if defined(IPPROTO_GRE) 1684 case IPPROTO_GRE: 1685 s = "GRE"; 1686 break; 1687#endif /* defined(IPPROTO_GRE) */ 1688 1689#if defined(IPPROTO_MHRP) 1690 case IPPROTO_MHRP: 1691 s = "MHRP"; 1692 break; 1693#endif /* defined(IPPROTO_MHRP) */ 1694 1695#if defined(IPPROTO_BHA) 1696 case IPPROTO_BHA: 1697 s = "BHA"; 1698 break; 1699#endif /* defined(IPPROTO_BHA) */ 1700 1701#if defined(IPPROTO_ESP) 1702 case IPPROTO_ESP: 1703 s = "ESP"; 1704 break; 1705#endif /* defined(IPPROTO_ESP) */ 1706 1707#if defined(IPPROTO_AH) 1708 case IPPROTO_AH: 1709 s = "AH"; 1710 break; 1711#endif /* defined(IPPROTO_AH) */ 1712 1713#if defined(IPPROTO_INLSP) 1714 case IPPROTO_INLSP: 1715 s = "INLSP"; 1716 break; 1717#endif /* defined(IPPROTO_INLSP) */ 1718 1719#if defined(IPPROTO_SWIPE) 1720 case IPPROTO_SWIPE: 1721 s = "SWIPE"; 1722 break; 1723#endif /* defined(IPPROTO_SWIPE) */ 1724 1725#if defined(IPPROTO_NHRP) 1726 case IPPROTO_NHRP: 1727 s = "NHRP"; 1728 break; 1729#endif /* defined(IPPROTO_NHRP) */ 1730 1731#if defined(IPPROTO_NONE) 1732 case IPPROTO_NONE: 1733 s = "NONE"; 1734 break; 1735#endif /* defined(IPPROTO_NONE) */ 1736 1737#if defined(IPPROTO_DSTOPTS) 1738 case IPPROTO_DSTOPTS: 1739 s = "DSTOPTS"; 1740 break; 1741#endif /* defined(IPPROTO_DSTOPTS) */ 1742 1743#if defined(IPPROTO_AHIP) 1744 case IPPROTO_AHIP: 1745 s = "AHIP"; 1746 break; 1747#endif /* defined(IPPROTO_AHIP) */ 1748 1749#if defined(IPPROTO_CFTP) 1750 case IPPROTO_CFTP: 1751 s = "CFTP"; 1752 break; 1753#endif /* defined(IPPROTO_CFTP) */ 1754 1755#if defined(IPPROTO_SATEXPAK) 1756 case IPPROTO_SATEXPAK: 1757 s = "SATEXPK"; 1758 break; 1759#endif /* defined(IPPROTO_SATEXPAK) */ 1760 1761#if defined(IPPROTO_KRYPTOLAN) 1762 case IPPROTO_KRYPTOLAN: 1763 s = "KRYPTOL"; 1764 break; 1765#endif /* defined(IPPROTO_KRYPTOLAN) */ 1766 1767#if defined(IPPROTO_RVD) 1768 case IPPROTO_RVD: 1769 s = "RVD"; 1770 break; 1771#endif /* defined(IPPROTO_RVD) */ 1772 1773#if defined(IPPROTO_IPPC) 1774 case IPPROTO_IPPC: 1775 s = "IPPC"; 1776 break; 1777#endif /* defined(IPPROTO_IPPC) */ 1778 1779#if defined(IPPROTO_ADFS) 1780 case IPPROTO_ADFS: 1781 s = "ADFS"; 1782 break; 1783#endif /* defined(IPPROTO_ADFS) */ 1784 1785#if defined(IPPROTO_SATMON) 1786 case IPPROTO_SATMON: 1787 s = "SATMON"; 1788 break; 1789#endif /* defined(IPPROTO_SATMON) */ 1790 1791#if defined(IPPROTO_VISA) 1792 case IPPROTO_VISA: 1793 s = "VISA"; 1794 break; 1795#endif /* defined(IPPROTO_VISA) */ 1796 1797#if defined(IPPROTO_IPCV) 1798 case IPPROTO_IPCV: 1799 s = "IPCV"; 1800 break; 1801#endif /* defined(IPPROTO_IPCV) */ 1802 1803#if defined(IPPROTO_CPNX) 1804 case IPPROTO_CPNX: 1805 s = "CPNX"; 1806 break; 1807#endif /* defined(IPPROTO_CPNX) */ 1808 1809#if defined(IPPROTO_CPHB) 1810 case IPPROTO_CPHB: 1811 s = "CPHB"; 1812 break; 1813#endif /* defined(IPPROTO_CPHB) */ 1814 1815#if defined(IPPROTO_WSN) 1816 case IPPROTO_WSN: 1817 s = "WSN"; 1818 break; 1819#endif /* defined(IPPROTO_WSN) */ 1820 1821#if defined(IPPROTO_PVP) 1822 case IPPROTO_PVP: 1823 s = "PVP"; 1824 break; 1825#endif /* defined(IPPROTO_PVP) */ 1826 1827#if defined(IPPROTO_BRSATMON) 1828 case IPPROTO_BRSATMON: 1829 s = "BRSATMN"; 1830 break; 1831#endif /* defined(IPPROTO_BRSATMON) */ 1832 1833#if defined(IPPROTO_WBMON) 1834 case IPPROTO_WBMON: 1835 s = "WBMON"; 1836 break; 1837#endif /* defined(IPPROTO_WBMON) */ 1838 1839#if defined(IPPROTO_WBEXPAK) 1840 case IPPROTO_WBEXPAK: 1841 s = "WBEXPAK"; 1842 break; 1843#endif /* defined(IPPROTO_WBEXPAK) */ 1844 1845#if defined(IPPROTO_EON) 1846 case IPPROTO_EON: 1847 s = "EON"; 1848 break; 1849#endif /* defined(IPPROTO_EON) */ 1850 1851#if defined(IPPROTO_VMTP) 1852 case IPPROTO_VMTP: 1853 s = "VMTP"; 1854 break; 1855#endif /* defined(IPPROTO_VMTP) */ 1856 1857#if defined(IPPROTO_SVMTP) 1858 case IPPROTO_SVMTP: 1859 s = "SVMTP"; 1860 break; 1861#endif /* defined(IPPROTO_SVMTP) */ 1862 1863#if defined(IPPROTO_VINES) 1864 case IPPROTO_VINES: 1865 s = "VINES"; 1866 break; 1867#endif /* defined(IPPROTO_VINES) */ 1868 1869#if defined(IPPROTO_TTP) 1870 case IPPROTO_TTP: 1871 s = "TTP"; 1872 break; 1873#endif /* defined(IPPROTO_TTP) */ 1874 1875#if defined(IPPROTO_IGP) 1876 case IPPROTO_IGP: 1877 s = "IGP"; 1878 break; 1879#endif /* defined(IPPROTO_IGP) */ 1880 1881#if defined(IPPROTO_DGP) 1882 case IPPROTO_DGP: 1883 s = "DGP"; 1884 break; 1885#endif /* defined(IPPROTO_DGP) */ 1886 1887#if defined(IPPROTO_TCF) 1888 case IPPROTO_TCF: 1889 s = "TCF"; 1890 break; 1891#endif /* defined(IPPROTO_TCF) */ 1892 1893#if defined(IPPROTO_IGRP) 1894 case IPPROTO_IGRP: 1895 s = "IGRP"; 1896 break; 1897#endif /* defined(IPPROTO_IGRP) */ 1898 1899#if defined(IPPROTO_OSPFIGP) 1900 case IPPROTO_OSPFIGP: 1901 s = "OSPFIGP"; 1902 break; 1903#endif /* defined(IPPROTO_OSPFIGP) */ 1904 1905#if defined(IPPROTO_SRPC) 1906 case IPPROTO_SRPC: 1907 s = "SRPC"; 1908 break; 1909#endif /* defined(IPPROTO_SRPC) */ 1910 1911#if defined(IPPROTO_LARP) 1912 case IPPROTO_LARP: 1913 s = "LARP"; 1914 break; 1915#endif /* defined(IPPROTO_LARP) */ 1916 1917#if defined(IPPROTO_MTP) 1918 case IPPROTO_MTP: 1919 s = "MTP"; 1920 break; 1921#endif /* defined(IPPROTO_MTP) */ 1922 1923#if defined(IPPROTO_AX25) 1924 case IPPROTO_AX25: 1925 s = "AX25"; 1926 break; 1927#endif /* defined(IPPROTO_AX25) */ 1928 1929#if defined(IPPROTO_IPEIP) 1930 case IPPROTO_IPEIP: 1931 s = "IPEIP"; 1932 break; 1933#endif /* defined(IPPROTO_IPEIP) */ 1934 1935#if defined(IPPROTO_MICP) 1936 case IPPROTO_MICP: 1937 s = "MICP"; 1938 break; 1939#endif /* defined(IPPROTO_MICP) */ 1940 1941#if defined(IPPROTO_SCCSP) 1942 case IPPROTO_SCCSP: 1943 s = "SCCSP"; 1944 break; 1945#endif /* defined(IPPROTO_SCCSP) */ 1946 1947#if defined(IPPROTO_ETHERIP) 1948 case IPPROTO_ETHERIP: 1949 s = "ETHERIP"; 1950 break; 1951#endif /* defined(IPPROTO_ETHERIP) */ 1952 1953#if defined(IPPROTO_ENCAP) 1954# if !defined(IPPROTO_IPIP) || IPPROTO_IPIP!=IPPROTO_ENCAP 1955 case IPPROTO_ENCAP: 1956 s = "ENCAP"; 1957 break; 1958# endif /* !defined(IPPROTO_IPIP) || IPPROTO_IPIP!=IPPROTO_ENCAP */ 1959#endif /* defined(IPPROTO_ENCAP) */ 1960 1961#if defined(IPPROTO_APES) 1962 case IPPROTO_APES: 1963 s = "APES"; 1964 break; 1965#endif /* defined(IPPROTO_APES) */ 1966 1967#if defined(IPPROTO_GMTP) 1968 case IPPROTO_GMTP: 1969 s = "GMTP"; 1970 break; 1971#endif /* defined(IPPROTO_GMTP) */ 1972 1973#if defined(IPPROTO_DIVERT) 1974 case IPPROTO_DIVERT: 1975 s = "DIVERT"; 1976 break; 1977#endif /* defined(IPPROTO_DIVERT) */ 1978 1979 default: 1980 s = (char *)NULL; 1981 } 1982 if (s) 1983 (void) snpf(Lf->iproto, sizeof(Lf->iproto), "%.*s", IPROTOL-1, s); 1984 else { 1985 if (m < 0) { 1986 for (i = 0, m = 1; i < IPROTOL-2; i++) 1987 m *= 10; 1988 } 1989 if (m > p) 1990 (void) snpf(Lf->iproto, sizeof(Lf->iproto), "%d?", p); 1991 else 1992 (void) snpf(Lf->iproto, sizeof(Lf->iproto), "*%d?", p % (m/10)); 1993 } 1994} 1995#endif /* !defined(HASPRIVPRIPP) */ 1996 1997 1998/* 1999 * printname() - print output name field 2000 */ 2001 2002void 2003printname(nl) 2004 int nl; /* NL status */ 2005{ 2006 2007#if defined(HASNCACHE) 2008 char buf[MAXPATHLEN]; 2009 char *cp; 2010 int fp; 2011#endif /* defined(HASNCACHE) */ 2012 2013 int ps = 0; 2014 2015 if (Lf->nm && Lf->nm[0]) { 2016 2017 /* 2018 * Print the name characters, if there are some. 2019 */ 2020 safestrprt(Lf->nm, stdout, 0); 2021 ps++; 2022 if (!Lf->li[0].af && !Lf->li[1].af) 2023 goto print_nma; 2024 } 2025 if (Lf->li[0].af || Lf->li[1].af) { 2026 if (ps) 2027 putchar(' '); 2028 /* 2029 * If the file has Internet addresses, print them. 2030 */ 2031 if (printinaddr()) 2032 ps++; 2033 goto print_nma; 2034 } 2035 if (((Lf->ntype == N_BLK) || (Lf->ntype == N_CHR)) 2036 && Lf->dev_def && Lf->rdev_def 2037 && printdevname(&Lf->dev, &Lf->rdev, 0, Lf->ntype)) 2038 { 2039 2040 /* 2041 * If this is a block or character device and it has a name, print it. 2042 */ 2043 ps++; 2044 goto print_nma; 2045 } 2046 if (Lf->is_com) { 2047 2048 /* 2049 * If this is a common node, print that fact. 2050 */ 2051 (void) fputs("COMMON: ", stdout); 2052 ps++; 2053 goto print_nma; 2054 } 2055 2056#if defined(HASPRIVNMCACHE) 2057 if (HASPRIVNMCACHE(Lf)) { 2058 ps++; 2059 goto print_nma; 2060 } 2061#endif /* defined(HASPRIVNMCACHE) */ 2062 2063 if (Lf->lmi_srch) { 2064 struct mounts *mp; 2065 /* 2066 * Do a deferred local mount info table search for the file system 2067 * (mounted) directory name and inode number, and mounted device name. 2068 */ 2069 for (mp = readmnt(); mp; mp = mp->next) { 2070 if (Lf->dev == mp->dev) { 2071 Lf->fsdir = mp->dir; 2072 Lf->fsdev = mp->fsname; 2073 2074#if defined(HASFSINO) 2075 Lf->fs_ino = mp->inode; 2076#endif /* defined(HASFSINO) */ 2077 2078 break; 2079 } 2080 } 2081 Lf->lmi_srch = 0; 2082 } 2083 if (Lf->fsdir || Lf->fsdev) { 2084 2085 /* 2086 * Print the file system directory name, device name, and 2087 * possible path name components. 2088 */ 2089 2090#if !defined(HASNCACHE) || HASNCACHE<2 2091 if (Lf->fsdir) { 2092 safestrprt(Lf->fsdir, stdout, 0); 2093 ps++; 2094 } 2095#endif /* !defined(HASNCACHE) || HASNCACHE<2 */ 2096 2097#if defined(HASNCACHE) 2098 2099# if HASNCACHE<2 2100 if (Lf->na) { 2101 if (NcacheReload) { 2102 2103# if defined(NCACHELDPFX) 2104 NCACHELDPFX 2105# endif /* defined(NCACHELDPFX) */ 2106 2107 (void) ncache_load(); 2108 2109# if defined(NCACHELDSFX) 2110 NCACHELDSFX 2111# endif /* defined(NCACHELDSFX) */ 2112 2113 NcacheReload = 0; 2114 } 2115 if ((cp = ncache_lookup(buf, sizeof(buf), &fp))) { 2116 char *cp1; 2117 2118 if (*cp == '\0') 2119 goto print_nma; 2120 if (fp && Lf->fsdir) { 2121 if (*cp != '/') { 2122 cp1 = strrchr(Lf->fsdir, '/'); 2123 if (cp1 == (char *)NULL || *(cp1 + 1) != '\0') 2124 putchar('/'); 2125 } 2126 } else 2127 (void) fputs(" -- ", stdout); 2128 safestrprt(cp, stdout, 0); 2129 ps++; 2130 goto print_nma; 2131 } 2132 } 2133# else /* HASNCACHE>1 */ 2134 if (NcacheReload) { 2135 2136# if defined(NCACHELDPFX) 2137 NCACHELDPFX 2138# endif /* defined(NCACHELDPFX) */ 2139 2140 (void) ncache_load(); 2141 2142# if defined(NCACHELDSFX) 2143 NCACHELDSFX 2144# endif /* defined(NCACHELDSFX) */ 2145 2146 NcacheReload = 0; 2147 } 2148 if ((cp = ncache_lookup(buf, sizeof(buf), &fp))) { 2149 if (fp) { 2150 safestrprt(cp, stdout, 0); 2151 ps++; 2152 } else { 2153 if (Lf->fsdir) { 2154 safestrprt(Lf->fsdir, stdout, 0); 2155 ps++; 2156 } 2157 if (*cp) { 2158 (void) fputs(" -- ", stdout); 2159 safestrprt(cp, stdout, 0); 2160 ps++; 2161 } 2162 } 2163 goto print_nma; 2164 } 2165 if (Lf->fsdir) { 2166 safestrprt(Lf->fsdir, stdout, 0); 2167 ps++; 2168 } 2169# endif /* HASNCACHE<2 */ 2170#endif /* defined(HASNCACHE) */ 2171 2172 if (Lf->fsdev) { 2173 if (Lf->fsdir) 2174 (void) fputs(" (", stdout); 2175 else 2176 (void) putchar('('); 2177 safestrprt(Lf->fsdev, stdout, 0); 2178 (void) putchar(')'); 2179 ps++; 2180 } 2181 } 2182/* 2183 * Print the NAME column addition, if there is one. If there isn't 2184 * make sure a NL is printed, as requested. 2185 */ 2186 2187print_nma: 2188 2189 if (Lf->nma) { 2190 if (ps) 2191 putchar(' '); 2192 safestrprt(Lf->nma, stdout, 0); 2193 ps++; 2194 } 2195/* 2196 * If this file has TCP/IP state information, print it. 2197 */ 2198 if (!Ffield && Ftcptpi 2199 && (Lf->lts.type >= 0 2200 2201#if defined(HASTCPTPIQ) 2202 || ((Ftcptpi & TCPTPI_QUEUES) && (Lf->lts.rqs || Lf->lts.sqs)) 2203#endif /* defined(HASTCPTPIQ) */ 2204 2205#if defined(HASTCPTPIW) 2206 || ((Ftcptpi & TCPTPI_WINDOWS) && (Lf->lts.rws || Lf->lts.wws)) 2207#endif /* defined(HASTCPTPIW) */ 2208 2209 )) { 2210 if (ps) 2211 putchar(' '); 2212 (void) print_tcptpi(0); 2213 } 2214 if (nl) 2215 putchar('\n'); 2216} 2217 2218 2219/* 2220 * printrawaddr() - print raw socket address 2221 */ 2222 2223void 2224printrawaddr(sa) 2225 struct sockaddr *sa; /* socket address */ 2226{ 2227 char *ep; 2228 size_t sz; 2229 2230 ep = endnm(&sz); 2231 (void) snpf(ep, sz, "%u/%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u", 2232 sa->sa_family, 2233 (unsigned char)sa->sa_data[0], 2234 (unsigned char)sa->sa_data[1], 2235 (unsigned char)sa->sa_data[2], 2236 (unsigned char)sa->sa_data[3], 2237 (unsigned char)sa->sa_data[4], 2238 (unsigned char)sa->sa_data[5], 2239 (unsigned char)sa->sa_data[6], 2240 (unsigned char)sa->sa_data[7], 2241 (unsigned char)sa->sa_data[8], 2242 (unsigned char)sa->sa_data[9], 2243 (unsigned char)sa->sa_data[10], 2244 (unsigned char)sa->sa_data[11], 2245 (unsigned char)sa->sa_data[12], 2246 (unsigned char)sa->sa_data[13]); 2247} 2248 2249 2250/* 2251 * printsockty() - print socket type 2252 */ 2253 2254char * 2255printsockty(ty) 2256 int ty; /* socket type -- e.g., from so_type */ 2257{ 2258 static char buf[64]; 2259 char *cp; 2260 2261 switch (ty) { 2262 2263#if defined(SOCK_STREAM) 2264 case SOCK_STREAM: 2265 cp = "STREAM"; 2266 break; 2267#endif /* defined(SOCK_STREAM) */ 2268 2269#if defined(SOCK_STREAM) 2270 case SOCK_DGRAM: 2271 cp = "DGRAM"; 2272 break; 2273#endif /* defined(SOCK_DGRAM) */ 2274 2275#if defined(SOCK_RAW) 2276 case SOCK_RAW: 2277 cp = "RAW"; 2278 break; 2279#endif /* defined(SOCK_RAW) */ 2280 2281#if defined(SOCK_RDM) 2282 case SOCK_RDM: 2283 cp = "RDM"; 2284 break; 2285#endif /* defined(SOCK_RDM) */ 2286 2287#if defined(SOCK_SEQPACKET) 2288 case SOCK_SEQPACKET: 2289 cp = "SEQPACKET"; 2290 break; 2291#endif /* defined(SOCK_SEQPACKET) */ 2292 2293 default: 2294 (void) snpf(buf, sizeof(buf), "SOCK_%#x", ty); 2295 return(buf); 2296 } 2297 (void) snpf(buf, sizeof(buf), "SOCK_%s", cp); 2298 return(buf); 2299} 2300 2301 2302/* 2303 * printuid() - print User ID or login name 2304 */ 2305 2306char * 2307printuid(uid, ty) 2308 UID_ARG uid; /* User IDentification number */ 2309 int *ty; /* returned UID type pointer (NULL 2310 * (if none wanted). If non-NULL 2311 * then: *ty = 0 = login name 2312 * = 1 = UID number */ 2313{ 2314 int i; 2315 struct passwd *pw; 2316 struct stat sb; 2317 static struct stat sbs; 2318 static struct uidcache { 2319 uid_t uid; 2320 char nm[LOGINML+1]; 2321 struct uidcache *next; 2322 } **uc = (struct uidcache **)NULL; 2323 struct uidcache *up, *upn; 2324 static char user[USERPRTL+1]; 2325 2326 if (Futol) { 2327 if (CkPasswd) { 2328 2329 /* 2330 * Get the mtime and ctime of /etc/passwd, as required. 2331 */ 2332 if (stat("/etc/passwd", &sb) != 0) { 2333 (void) fprintf(stderr, "%s: can't stat(/etc/passwd): %s\n", 2334 Pn, strerror(errno)); 2335 Exit(1); 2336 } 2337 } 2338 /* 2339 * Define the UID cache, if necessary. 2340 */ 2341 if (!uc) { 2342 if (!(uc = (struct uidcache **)calloc(UIDCACHEL, 2343 sizeof(struct uidcache *)))) 2344 { 2345 (void) fprintf(stderr, 2346 "%s: no space for %d byte UID cache hash buckets\n", 2347 Pn, (int)(UIDCACHEL * (sizeof(struct uidcache *)))); 2348 Exit(1); 2349 } 2350 if (CkPasswd) { 2351 sbs = sb; 2352 CkPasswd = 0; 2353 } 2354 } 2355 /* 2356 * If it's time to check /etc/passwd and if its the mtime/ctime has 2357 * changed, destroy the existing UID cache. 2358 */ 2359 if (CkPasswd) { 2360 if (sbs.st_mtime != sb.st_mtime || sbs.st_ctime != sb.st_ctime) 2361 { 2362 for (i = 0; i < UIDCACHEL; i++) { 2363 if ((up = uc[i])) { 2364 do { 2365 upn = up->next; 2366 (void) free((FREE_P *)up); 2367 } while ((up = upn) != (struct uidcache *)NULL); 2368 uc[i] = (struct uidcache *)NULL; 2369 } 2370 } 2371 sbs = sb; 2372 } 2373 CkPasswd = 0; 2374 } 2375 /* 2376 * Search the UID cache. 2377 */ 2378 i = (int)((((unsigned long)uid * 31415L) >> 7) & (UIDCACHEL - 1)); 2379 for (up = uc[i]; up; up = up->next) { 2380 if (up->uid == (uid_t)uid) { 2381 if (ty) 2382 *ty = 0; 2383 return(up->nm); 2384 } 2385 } 2386 /* 2387 * The UID is not in the cache. 2388 * 2389 * Look up the login name from the UID for a new cache entry. 2390 */ 2391 if (!(pw = getpwuid((uid_t)uid))) { 2392 if (!Fwarn) { 2393 (void) fprintf(stderr, "%s: no pwd entry for UID %lu\n", 2394 Pn, (unsigned long)uid); 2395 } 2396 } else { 2397 2398 /* 2399 * Allocate and fill a new cache entry. Link it to its hash bucket. 2400 */ 2401 if (!(upn = (struct uidcache *)malloc(sizeof(struct uidcache)))) 2402 { 2403 (void) fprintf(stderr, 2404 "%s: no space for UID cache entry for: %lu, %s)\n", 2405 Pn, (unsigned long)uid, pw->pw_name); 2406 Exit(1); 2407 } 2408 (void) strncpy(upn->nm, pw->pw_name, LOGINML); 2409 upn->nm[LOGINML] = '\0'; 2410 upn->uid = (uid_t)uid; 2411 upn->next = uc[i]; 2412 uc[i] = upn; 2413 if (ty) 2414 *ty = 0; 2415 return(upn->nm); 2416 } 2417 } 2418/* 2419 * Produce a numeric conversion of the UID. 2420 */ 2421 (void) snpf(user, sizeof(user), "%*lu", USERPRTL, (unsigned long)uid); 2422 if (ty) 2423 *ty = 1; 2424 return(user); 2425} 2426 2427 2428/* 2429 * printunkaf() - print unknown address family 2430 */ 2431 2432void 2433printunkaf(fam, ty) 2434 int fam; /* unknown address family */ 2435 int ty; /* output type: 0 = terse; 1 = full */ 2436{ 2437 char *p, *s; 2438 2439 p = ""; 2440 switch (fam) { 2441 2442#if defined(AF_UNSPEC) 2443 case AF_UNSPEC: 2444 s = "UNSPEC"; 2445 break; 2446#endif /* defined(AF_UNSPEC) */ 2447 2448#if defined(AF_UNIX) 2449 case AF_UNIX: 2450 s = "UNIX"; 2451 break; 2452#endif /* defined(AF_UNIX) */ 2453 2454#if defined(AF_INET) 2455 case AF_INET: 2456 s = "INET"; 2457 break; 2458#endif /* defined(AF_INET) */ 2459 2460#if defined(AF_INET6) 2461 case AF_INET6: 2462 s = "INET6"; 2463 break; 2464#endif /* defined(AF_INET6) */ 2465 2466#if defined(AF_IMPLINK) 2467 case AF_IMPLINK: 2468 s = "IMPLINK"; 2469 break; 2470#endif /* defined(AF_IMPLINK) */ 2471 2472#if defined(AF_PUP) 2473 case AF_PUP: 2474 s = "PUP"; 2475 break; 2476#endif /* defined(AF_PUP) */ 2477 2478#if defined(AF_CHAOS) 2479 case AF_CHAOS: 2480 s = "CHAOS"; 2481 break; 2482#endif /* defined(AF_CHAOS) */ 2483 2484#if defined(AF_NS) 2485 case AF_NS: 2486 s = "NS"; 2487 break; 2488#endif /* defined(AF_NS) */ 2489 2490#if defined(AF_ISO) 2491 case AF_ISO: 2492 s = "ISO"; 2493 break; 2494#endif /* defined(AF_ISO) */ 2495 2496#if defined(AF_NBS) 2497# if !defined(AF_ISO) || AF_NBS!=AF_ISO 2498 case AF_NBS: 2499 s = "NBS"; 2500 break; 2501# endif /* !defined(AF_ISO) || AF_NBS!=AF_ISO */ 2502#endif /* defined(AF_NBS) */ 2503 2504#if defined(AF_ECMA) 2505 case AF_ECMA: 2506 s = "ECMA"; 2507 break; 2508#endif /* defined(AF_ECMA) */ 2509 2510#if defined(AF_DATAKIT) 2511 case AF_DATAKIT: 2512 s = "DATAKIT"; 2513 break; 2514#endif /* defined(AF_DATAKIT) */ 2515 2516#if defined(AF_CCITT) 2517 case AF_CCITT: 2518 s = "CCITT"; 2519 break; 2520#endif /* defined(AF_CCITT) */ 2521 2522#if defined(AF_SNA) 2523 case AF_SNA: 2524 s = "SNA"; 2525 break; 2526#endif /* defined(AF_SNA) */ 2527 2528#if defined(AF_DECnet) 2529 case AF_DECnet: 2530 s = "DECnet"; 2531 break; 2532#endif /* defined(AF_DECnet) */ 2533 2534#if defined(AF_DLI) 2535 case AF_DLI: 2536 s = "DLI"; 2537 break; 2538#endif /* defined(AF_DLI) */ 2539 2540#if defined(AF_LAT) 2541 case AF_LAT: 2542 s = "LAT"; 2543 break; 2544#endif /* defined(AF_LAT) */ 2545 2546#if defined(AF_HYLINK) 2547 case AF_HYLINK: 2548 s = "HYLINK"; 2549 break; 2550#endif /* defined(AF_HYLINK) */ 2551 2552#if defined(AF_APPLETALK) 2553 case AF_APPLETALK: 2554 s = "APPLETALK"; 2555 break; 2556#endif /* defined(AF_APPLETALK) */ 2557 2558#if defined(AF_BSC) 2559 case AF_BSC: 2560 s = "BSC"; 2561 break; 2562#endif /* defined(AF_BSC) */ 2563 2564#if defined(AF_DSS) 2565 case AF_DSS: 2566 s = "DSS"; 2567 break; 2568#endif /* defined(AF_DSS) */ 2569 2570#if defined(AF_ROUTE) 2571 case AF_ROUTE: 2572 s = "ROUTE"; 2573 break; 2574#endif /* defined(AF_ROUTE) */ 2575 2576#if defined(AF_RAW) 2577 case AF_RAW: 2578 s = "RAW"; 2579 break; 2580#endif /* defined(AF_RAW) */ 2581 2582#if defined(AF_LINK) 2583 case AF_LINK: 2584 s = "LINK"; 2585 break; 2586#endif /* defined(AF_LINK) */ 2587 2588#if defined(pseudo_AF_XTP) 2589 case pseudo_AF_XTP: 2590 p = "pseudo_"; 2591 s = "XTP"; 2592 break; 2593#endif /* defined(pseudo_AF_XTP) */ 2594 2595#if defined(AF_RMP) 2596 case AF_RMP: 2597 s = "RMP"; 2598 break; 2599#endif /* defined(AF_RMP) */ 2600 2601#if defined(AF_COIP) 2602 case AF_COIP: 2603 s = "COIP"; 2604 break; 2605#endif /* defined(AF_COIP) */ 2606 2607#if defined(AF_CNT) 2608 case AF_CNT: 2609 s = "CNT"; 2610 break; 2611#endif /* defined(AF_CNT) */ 2612 2613#if defined(pseudo_AF_RTIP) 2614 case pseudo_AF_RTIP: 2615 p = "pseudo_"; 2616 s = "RTIP"; 2617 break; 2618#endif /* defined(pseudo_AF_RTIP) */ 2619 2620#if defined(AF_NETMAN) 2621 case AF_NETMAN: 2622 s = "NETMAN"; 2623 break; 2624#endif /* defined(AF_NETMAN) */ 2625 2626#if defined(AF_INTF) 2627 case AF_INTF: 2628 s = "INTF"; 2629 break; 2630#endif /* defined(AF_INTF) */ 2631 2632#if defined(AF_NETWARE) 2633 case AF_NETWARE: 2634 s = "NETWARE"; 2635 break; 2636#endif /* defined(AF_NETWARE) */ 2637 2638#if defined(AF_NDD) 2639 case AF_NDD: 2640 s = "NDD"; 2641 break; 2642#endif /* defined(AF_NDD) */ 2643 2644#if defined(AF_NIT) 2645# if !defined(AF_ROUTE) || AF_ROUTE!=AF_NIT 2646 case AF_NIT: 2647 s = "NIT"; 2648 break; 2649# endif /* !defined(AF_ROUTE) || AF_ROUTE!=AF_NIT */ 2650#endif /* defined(AF_NIT) */ 2651 2652#if defined(AF_802) 2653# if !defined(AF_RAW) || AF_RAW!=AF_802 2654 case AF_802: 2655 s = "802"; 2656 break; 2657# endif /* !defined(AF_RAW) || AF_RAW!=AF_802 */ 2658#endif /* defined(AF_802) */ 2659 2660#if defined(AF_X25) 2661 case AF_X25: 2662 s = "X25"; 2663 break; 2664#endif /* defined(AF_X25) */ 2665 2666#if defined(AF_CTF) 2667 case AF_CTF: 2668 s = "CTF"; 2669 break; 2670#endif /* defined(AF_CTF) */ 2671 2672#if defined(AF_WAN) 2673 case AF_WAN: 2674 s = "WAN"; 2675 break; 2676#endif /* defined(AF_WAN) */ 2677 2678#if defined(AF_OSINET) 2679# if defined(AF_INET) && AF_INET!=AF_OSINET 2680 case AF_OSINET: 2681 s = "OSINET"; 2682 break; 2683# endif /* defined(AF_INET) && AF_INET!=AF_OSINET */ 2684#endif /* defined(AF_OSINET) */ 2685 2686#if defined(AF_GOSIP) 2687 case AF_GOSIP: 2688 s = "GOSIP"; 2689 break; 2690#endif /* defined(AF_GOSIP) */ 2691 2692#if defined(AF_SDL) 2693 case AF_SDL: 2694 s = "SDL"; 2695 break; 2696#endif /* defined(AF_SDL) */ 2697 2698#if defined(AF_IPX) 2699 case AF_IPX: 2700 s = "IPX"; 2701 break; 2702#endif /* defined(AF_IPX) */ 2703 2704#if defined(AF_SIP) 2705 case AF_SIP: 2706 s = "SIP"; 2707 break; 2708#endif /* defined(AF_SIP) */ 2709 2710#if defined(psuedo_AF_PIP) 2711 case psuedo_AF_PIP: 2712 p = "pseudo_"; 2713 s = "PIP"; 2714 break; 2715#endif /* defined(psuedo_AF_PIP) */ 2716 2717#if defined(AF_OTS) 2718 case AF_OTS: 2719 s = "OTS"; 2720 break; 2721#endif /* defined(AF_OTS) */ 2722 2723#if defined(pseudo_AF_BLUE) 2724 case pseudo_AF_BLUE: /* packets for Blue box */ 2725 p = "pseudo_"; 2726 s = "BLUE"; 2727 break; 2728#endif /* defined(pseudo_AF_BLUE) */ 2729 2730#if defined(AF_NDRV) /* network driver raw access */ 2731 case AF_NDRV: 2732 s = "NDRV"; 2733 break; 2734#endif /* defined(AF_NDRV) */ 2735 2736#if defined(AF_SYSTEM) /* kernel event messages */ 2737 case AF_SYSTEM: 2738 s = "SYSTEM"; 2739 break; 2740#endif /* defined(AF_SYSTEM) */ 2741 2742#if defined(AF_USER) 2743 case AF_USER: 2744 s = "USER"; 2745 break; 2746#endif /* defined(AF_USER) */ 2747 2748#if defined(pseudo_AF_KEY) 2749 case pseudo_AF_KEY: 2750 p = "pseudo_"; 2751 s = "KEY"; 2752 break; 2753#endif /* defined(pseudo_AF_KEY) */ 2754 2755#if defined(AF_KEY) /* Security Association DB socket */ 2756 case AF_KEY: 2757 s = "KEY"; 2758 break; 2759#endif /* defined(AF_KEY) */ 2760 2761#if defined(AF_NCA) /* NCA socket */ 2762 case AF_NCA: 2763 s = "NCA"; 2764 break; 2765#endif /* defined(AF_NCA) */ 2766 2767#if defined(AF_POLICY) /* Security Policy DB socket */ 2768 case AF_POLICY: 2769 s = "POLICY"; 2770 break; 2771#endif /* defined(AF_POLICY) */ 2772 2773#if defined(AF_PPP) /* PPP socket */ 2774 case AF_PPP: 2775 s = "PPP"; 2776 break; 2777#endif /* defined(AF_PPP) */ 2778 2779 default: 2780 if (!ty) 2781 (void) snpf(Namech, Namechl, "%#x", fam); 2782 else 2783 (void) snpf(Namech, Namechl, 2784 "no further information on family %#x", fam); 2785 return; 2786 } 2787 if (!ty) 2788 (void) snpf(Namech, Namechl, "%sAF_%s", p, s); 2789 else 2790 (void) snpf(Namech, Namechl, "no further information on %sAF_%s", 2791 p, s); 2792 return; 2793} 2794 2795 2796#if !defined(HASNORPC_H) 2797/* 2798 * update_portmap() - update a portmap entry with its port number or service 2799 * name 2800 */ 2801 2802static void 2803update_portmap(pt, pn) 2804 struct porttab *pt; /* porttab entry */ 2805 char *pn; /* port name */ 2806{ 2807 MALLOC_S al, nl; 2808 char *cp; 2809 2810 if (pt->ss) 2811 return; 2812 if (!(al = strlen(pn))) { 2813 pt->ss = 1; 2814 return; 2815 } 2816 nl = al + pt->nl + 2; 2817 if (!(cp = (char *)malloc(nl + 1))) { 2818 (void) fprintf(stderr, 2819 "%s: can't allocate %d bytes for portmap name: %s[%s]\n", 2820 Pn, (int)(nl + 1), pn, pt->name); 2821 Exit(1); 2822 } 2823 (void) snpf(cp, nl + 1, "%s[%s]", pn, pt->name); 2824 (void) free((FREE_P *)pt->name); 2825 pt->name = cp; 2826 pt->nl = nl; 2827 pt->ss = 1; 2828} 2829#endif /* !defined(HASNORPC_H) */ 2830