source: rtems-libbsd/freebsd/contrib/tcpdump/addrtoname.c @ 24631e2

5
Last change on this file since 24631e2 was 24631e2, checked in by Sebastian Huber <sebastian.huber@…>, on 03/11/19 at 08:33:28

tcpdump: Move static variables to special section

This fixes some issues if tcpdump is invoked a second time.

  • Property mode set to 100644
File size: 33.8 KB
Line 
1#include <machine/rtems-bsd-user-space.h>
2
3#ifdef __rtems__
4#include <machine/rtems-bsd-program.h>
5#include "rtems-bsd-tcpdump-namespace.h"
6#endif /* __rtems__ */
7/*
8 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
9 *      The Regents of the University of California.  All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that: (1) source code distributions
13 * retain the above copyright notice and this paragraph in its entirety, (2)
14 * distributions including binary code include the above copyright notice and
15 * this paragraph in its entirety in the documentation or other materials
16 * provided with the distribution, and (3) all advertising materials mentioning
17 * features or use of this software display the following acknowledgement:
18 * ``This product includes software developed by the University of California,
19 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
20 * the University nor the names of its contributors may be used to endorse
21 * or promote products derived from this software without specific prior
22 * written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
24 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
26 *
27 *  Internet, ethernet, port, and protocol string to address
28 *  and address to string conversion routines
29 */
30
31#ifdef HAVE_CONFIG_H
32#include "config.h"
33#endif
34
35#ifdef HAVE_CASPER
36#include <libcasper.h>
37#include <casper/cap_dns.h>
38#endif /* HAVE_CASPER */
39
40#include <netdissect-stdinc.h>
41
42#ifdef USE_ETHER_NTOHOST
43#ifdef HAVE_NETINET_IF_ETHER_H
44struct mbuf;            /* Squelch compiler warnings on some platforms for */
45struct rtentry;         /* declarations in <net/if.h> */
46#include <net/if.h>     /* for "struct ifnet" in "struct arpcom" on Solaris */
47#include <netinet/if_ether.h>
48#endif /* HAVE_NETINET_IF_ETHER_H */
49#ifdef NETINET_ETHER_H_DECLARES_ETHER_NTOHOST
50#include <netinet/ether.h>
51#endif /* NETINET_ETHER_H_DECLARES_ETHER_NTOHOST */
52
53#if !defined(HAVE_DECL_ETHER_NTOHOST) || !HAVE_DECL_ETHER_NTOHOST
54#ifndef HAVE_STRUCT_ETHER_ADDR
55struct ether_addr {
56        unsigned char ether_addr_octet[6];
57};
58#endif
59extern int ether_ntohost(char *, const struct ether_addr *);
60#endif
61
62#endif /* USE_ETHER_NTOHOST */
63
64#include <pcap.h>
65#include <pcap-namedb.h>
66#include <signal.h>
67#include <stdio.h>
68#include <string.h>
69#include <stdlib.h>
70
71#include "netdissect.h"
72#include "addrtoname.h"
73#include "addrtostr.h"
74#include "ethertype.h"
75#include "llc.h"
76#include "setsignal.h"
77#include "extract.h"
78#include "oui.h"
79
80#ifndef ETHER_ADDR_LEN
81#define ETHER_ADDR_LEN  6
82#endif
83
84/*
85 * hash tables for whatever-to-name translations
86 *
87 * ndo_error() called on strdup(3) failure
88 */
89
90#define HASHNAMESIZE 4096
91
92struct hnamemem {
93        uint32_t addr;
94        const char *name;
95        struct hnamemem *nxt;
96};
97
98static struct hnamemem hnametable[HASHNAMESIZE];
99static struct hnamemem tporttable[HASHNAMESIZE];
100static struct hnamemem uporttable[HASHNAMESIZE];
101static struct hnamemem eprototable[HASHNAMESIZE];
102static struct hnamemem dnaddrtable[HASHNAMESIZE];
103static struct hnamemem ipxsaptable[HASHNAMESIZE];
104
105#ifdef _WIN32
106/*
107 * fake gethostbyaddr for Win2k/XP
108 * gethostbyaddr() returns incorrect value when AF_INET6 is passed
109 * to 3rd argument.
110 *
111 * h_name in struct hostent is only valid.
112 */
113static struct hostent *
114win32_gethostbyaddr(const char *addr, int len, int type)
115{
116        static struct hostent host;
117        static char hostbuf[NI_MAXHOST];
118        char hname[NI_MAXHOST];
119        struct sockaddr_in6 addr6;
120
121        host.h_name = hostbuf;
122        switch (type) {
123        case AF_INET:
124                return gethostbyaddr(addr, len, type);
125                break;
126        case AF_INET6:
127                memset(&addr6, 0, sizeof(addr6));
128                addr6.sin6_family = AF_INET6;
129                memcpy(&addr6.sin6_addr, addr, len);
130                if (getnameinfo((struct sockaddr *)&addr6, sizeof(addr6),
131                    hname, sizeof(hname), NULL, 0, 0)) {
132                        return NULL;
133                } else {
134                        strcpy(host.h_name, hname);
135                        return &host;
136                }
137                break;
138        default:
139                return NULL;
140        }
141}
142#define gethostbyaddr win32_gethostbyaddr
143#endif /* _WIN32 */
144
145struct h6namemem {
146        struct in6_addr addr;
147        char *name;
148        struct h6namemem *nxt;
149};
150
151static struct h6namemem h6nametable[HASHNAMESIZE];
152
153struct enamemem {
154        u_short e_addr0;
155        u_short e_addr1;
156        u_short e_addr2;
157        const char *e_name;
158        u_char *e_nsap;                 /* used only for nsaptable[] */
159        struct enamemem *e_nxt;
160};
161
162static struct enamemem enametable[HASHNAMESIZE];
163static struct enamemem nsaptable[HASHNAMESIZE];
164
165struct bsnamemem {
166        u_short bs_addr0;
167        u_short bs_addr1;
168        u_short bs_addr2;
169        const char *bs_name;
170        u_char *bs_bytes;
171        unsigned int bs_nbytes;
172        struct bsnamemem *bs_nxt;
173};
174
175static struct bsnamemem bytestringtable[HASHNAMESIZE];
176
177struct protoidmem {
178        uint32_t p_oui;
179        u_short p_proto;
180        const char *p_name;
181        struct protoidmem *p_nxt;
182};
183
184static struct protoidmem protoidtable[HASHNAMESIZE];
185
186/*
187 * A faster replacement for inet_ntoa().
188 */
189const char *
190intoa(uint32_t addr)
191{
192        register char *cp;
193        register u_int byte;
194        register int n;
195        static char buf[sizeof(".xxx.xxx.xxx.xxx")];
196
197        NTOHL(addr);
198        cp = buf + sizeof(buf);
199        *--cp = '\0';
200
201        n = 4;
202        do {
203                byte = addr & 0xff;
204                *--cp = byte % 10 + '0';
205                byte /= 10;
206                if (byte > 0) {
207                        *--cp = byte % 10 + '0';
208                        byte /= 10;
209                        if (byte > 0)
210                                *--cp = byte + '0';
211                }
212                *--cp = '.';
213                addr >>= 8;
214        } while (--n > 0);
215
216        return cp + 1;
217}
218
219static uint32_t f_netmask;
220static uint32_t f_localnet;
221#ifdef HAVE_CASPER
222extern cap_channel_t *capdns;
223#endif
224
225/*
226 * Return a name for the IP address pointed to by ap.  This address
227 * is assumed to be in network byte order.
228 *
229 * NOTE: ap is *NOT* necessarily part of the packet data (not even if
230 * this is being called with the "ipaddr_string()" macro), so you
231 * *CANNOT* use the ND_TCHECK{2}/ND_TTEST{2} macros on it.  Furthermore,
232 * even in cases where it *is* part of the packet data, the caller
233 * would still have to check for a null return value, even if it's
234 * just printing the return value with "%s" - not all versions of
235 * printf print "(null)" with "%s" and a null pointer, some of them
236 * don't check for a null pointer and crash in that case.
237 *
238 * The callers of this routine should, before handing this routine
239 * a pointer to packet data, be sure that the data is present in
240 * the packet buffer.  They should probably do those checks anyway,
241 * as other data at that layer might not be IP addresses, and it
242 * also needs to check whether they're present in the packet buffer.
243 */
244const char *
245getname(netdissect_options *ndo, const u_char *ap)
246{
247        register struct hostent *hp;
248        uint32_t addr;
249        struct hnamemem *p;
250
251        memcpy(&addr, ap, sizeof(addr));
252        p = &hnametable[addr & (HASHNAMESIZE-1)];
253        for (; p->nxt; p = p->nxt) {
254                if (p->addr == addr)
255                        return (p->name);
256        }
257        p->addr = addr;
258        p->nxt = newhnamemem(ndo);
259
260        /*
261         * Print names unless:
262         *      (1) -n was given.
263         *      (2) Address is foreign and -f was given. (If -f was not
264         *          given, f_netmask and f_localnet are 0 and the test
265         *          evaluates to true)
266         */
267        if (!ndo->ndo_nflag &&
268            (addr & f_netmask) == f_localnet) {
269#ifdef HAVE_CASPER
270                if (capdns != NULL) {
271                        hp = cap_gethostbyaddr(capdns, (char *)&addr, 4,
272                            AF_INET);
273                } else
274#endif
275                        hp = gethostbyaddr((char *)&addr, 4, AF_INET);
276                if (hp) {
277                        char *dotp;
278
279                        p->name = strdup(hp->h_name);
280                        if (p->name == NULL)
281                                (*ndo->ndo_error)(ndo,
282                                                  "getname: strdup(hp->h_name)");
283                        if (ndo->ndo_Nflag) {
284                                /* Remove domain qualifications */
285                                dotp = strchr(p->name, '.');
286                                if (dotp)
287                                        *dotp = '\0';
288                        }
289                        return (p->name);
290                }
291        }
292        p->name = strdup(intoa(addr));
293        if (p->name == NULL)
294                (*ndo->ndo_error)(ndo, "getname: strdup(intoa(addr))");
295        return (p->name);
296}
297
298/*
299 * Return a name for the IP6 address pointed to by ap.  This address
300 * is assumed to be in network byte order.
301 */
302const char *
303getname6(netdissect_options *ndo, const u_char *ap)
304{
305        register struct hostent *hp;
306        union {
307                struct in6_addr addr;
308                struct for_hash_addr {
309                        char fill[14];
310                        uint16_t d;
311                } addra;
312        } addr;
313        struct h6namemem *p;
314        register const char *cp;
315        char ntop_buf[INET6_ADDRSTRLEN];
316
317        memcpy(&addr, ap, sizeof(addr));
318        p = &h6nametable[addr.addra.d & (HASHNAMESIZE-1)];
319        for (; p->nxt; p = p->nxt) {
320                if (memcmp(&p->addr, &addr, sizeof(addr)) == 0)
321                        return (p->name);
322        }
323        p->addr = addr.addr;
324        p->nxt = newh6namemem(ndo);
325
326        /*
327         * Do not print names if -n was given.
328         */
329        if (!ndo->ndo_nflag) {
330#ifdef HAVE_CASPER
331                if (capdns != NULL) {
332                        hp = cap_gethostbyaddr(capdns, (char *)&addr,
333                            sizeof(addr), AF_INET6);
334                } else
335#endif
336                        hp = gethostbyaddr((char *)&addr, sizeof(addr),
337                            AF_INET6);
338                if (hp) {
339                        char *dotp;
340
341                        p->name = strdup(hp->h_name);
342                        if (p->name == NULL)
343                                (*ndo->ndo_error)(ndo,
344                                                  "getname6: strdup(hp->h_name)");
345                        if (ndo->ndo_Nflag) {
346                                /* Remove domain qualifications */
347                                dotp = strchr(p->name, '.');
348                                if (dotp)
349                                        *dotp = '\0';
350                        }
351                        return (p->name);
352                }
353        }
354        cp = addrtostr6(ap, ntop_buf, sizeof(ntop_buf));
355        p->name = strdup(cp);
356        if (p->name == NULL)
357                (*ndo->ndo_error)(ndo, "getname6: strdup(cp)");
358        return (p->name);
359}
360
361static const char hex[16] = "0123456789abcdef";
362
363
364/* Find the hash node that corresponds the ether address 'ep' */
365
366static inline struct enamemem *
367lookup_emem(netdissect_options *ndo, const u_char *ep)
368{
369        register u_int i, j, k;
370        struct enamemem *tp;
371
372        k = (ep[0] << 8) | ep[1];
373        j = (ep[2] << 8) | ep[3];
374        i = (ep[4] << 8) | ep[5];
375
376        tp = &enametable[(i ^ j) & (HASHNAMESIZE-1)];
377        while (tp->e_nxt)
378                if (tp->e_addr0 == i &&
379                    tp->e_addr1 == j &&
380                    tp->e_addr2 == k)
381                        return tp;
382                else
383                        tp = tp->e_nxt;
384        tp->e_addr0 = i;
385        tp->e_addr1 = j;
386        tp->e_addr2 = k;
387        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
388        if (tp->e_nxt == NULL)
389                (*ndo->ndo_error)(ndo, "lookup_emem: calloc");
390
391        return tp;
392}
393
394/*
395 * Find the hash node that corresponds to the bytestring 'bs'
396 * with length 'nlen'
397 */
398
399static inline struct bsnamemem *
400lookup_bytestring(netdissect_options *ndo, register const u_char *bs,
401                  const unsigned int nlen)
402{
403        struct bsnamemem *tp;
404        register u_int i, j, k;
405
406        if (nlen >= 6) {
407                k = (bs[0] << 8) | bs[1];
408                j = (bs[2] << 8) | bs[3];
409                i = (bs[4] << 8) | bs[5];
410        } else if (nlen >= 4) {
411                k = (bs[0] << 8) | bs[1];
412                j = (bs[2] << 8) | bs[3];
413                i = 0;
414        } else
415                i = j = k = 0;
416
417        tp = &bytestringtable[(i ^ j) & (HASHNAMESIZE-1)];
418        while (tp->bs_nxt)
419                if (nlen == tp->bs_nbytes &&
420                    tp->bs_addr0 == i &&
421                    tp->bs_addr1 == j &&
422                    tp->bs_addr2 == k &&
423                    memcmp((const char *)bs, (const char *)(tp->bs_bytes), nlen) == 0)
424                        return tp;
425                else
426                        tp = tp->bs_nxt;
427
428        tp->bs_addr0 = i;
429        tp->bs_addr1 = j;
430        tp->bs_addr2 = k;
431
432        tp->bs_bytes = (u_char *) calloc(1, nlen);
433        if (tp->bs_bytes == NULL)
434                (*ndo->ndo_error)(ndo, "lookup_bytestring: calloc");
435
436        memcpy(tp->bs_bytes, bs, nlen);
437        tp->bs_nbytes = nlen;
438        tp->bs_nxt = (struct bsnamemem *)calloc(1, sizeof(*tp));
439        if (tp->bs_nxt == NULL)
440                (*ndo->ndo_error)(ndo, "lookup_bytestring: calloc");
441
442        return tp;
443}
444
445/* Find the hash node that corresponds the NSAP 'nsap' */
446
447static inline struct enamemem *
448lookup_nsap(netdissect_options *ndo, register const u_char *nsap,
449            register u_int nsap_length)
450{
451        register u_int i, j, k;
452        struct enamemem *tp;
453        const u_char *ensap;
454
455        if (nsap_length > 6) {
456                ensap = nsap + nsap_length - 6;
457                k = (ensap[0] << 8) | ensap[1];
458                j = (ensap[2] << 8) | ensap[3];
459                i = (ensap[4] << 8) | ensap[5];
460        }
461        else
462                i = j = k = 0;
463
464        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];
465        while (tp->e_nxt)
466                if (nsap_length == tp->e_nsap[0] &&
467                    tp->e_addr0 == i &&
468                    tp->e_addr1 == j &&
469                    tp->e_addr2 == k &&
470                    memcmp((const char *)nsap,
471                        (char *)&(tp->e_nsap[1]), nsap_length) == 0)
472                        return tp;
473                else
474                        tp = tp->e_nxt;
475        tp->e_addr0 = i;
476        tp->e_addr1 = j;
477        tp->e_addr2 = k;
478        tp->e_nsap = (u_char *)malloc(nsap_length + 1);
479        if (tp->e_nsap == NULL)
480                (*ndo->ndo_error)(ndo, "lookup_nsap: malloc");
481        tp->e_nsap[0] = (u_char)nsap_length;    /* guaranteed < ISONSAP_MAX_LENGTH */
482        memcpy((char *)&tp->e_nsap[1], (const char *)nsap, nsap_length);
483        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
484        if (tp->e_nxt == NULL)
485                (*ndo->ndo_error)(ndo, "lookup_nsap: calloc");
486
487        return tp;
488}
489
490/* Find the hash node that corresponds the protoid 'pi'. */
491
492static inline struct protoidmem *
493lookup_protoid(netdissect_options *ndo, const u_char *pi)
494{
495        register u_int i, j;
496        struct protoidmem *tp;
497
498        /* 5 octets won't be aligned */
499        i = (((pi[0] << 8) + pi[1]) << 8) + pi[2];
500        j =   (pi[3] << 8) + pi[4];
501        /* XXX should be endian-insensitive, but do big-endian testing  XXX */
502
503        tp = &protoidtable[(i ^ j) & (HASHNAMESIZE-1)];
504        while (tp->p_nxt)
505                if (tp->p_oui == i && tp->p_proto == j)
506                        return tp;
507                else
508                        tp = tp->p_nxt;
509        tp->p_oui = i;
510        tp->p_proto = j;
511        tp->p_nxt = (struct protoidmem *)calloc(1, sizeof(*tp));
512        if (tp->p_nxt == NULL)
513                (*ndo->ndo_error)(ndo, "lookup_protoid: calloc");
514
515        return tp;
516}
517
518const char *
519etheraddr_string(netdissect_options *ndo, register const u_char *ep)
520{
521        register int i;
522        register char *cp;
523        register struct enamemem *tp;
524        int oui;
525        char buf[BUFSIZE];
526
527        tp = lookup_emem(ndo, ep);
528        if (tp->e_name)
529                return (tp->e_name);
530#ifdef USE_ETHER_NTOHOST
531        if (!ndo->ndo_nflag) {
532                char buf2[BUFSIZE];
533
534                if (ether_ntohost(buf2, (const struct ether_addr *)ep) == 0) {
535                        tp->e_name = strdup(buf2);
536                        if (tp->e_name == NULL)
537                                (*ndo->ndo_error)(ndo,
538                                                  "etheraddr_string: strdup(buf2)");
539                        return (tp->e_name);
540                }
541        }
542#endif
543        cp = buf;
544        oui = EXTRACT_24BITS(ep);
545        *cp++ = hex[*ep >> 4 ];
546        *cp++ = hex[*ep++ & 0xf];
547        for (i = 5; --i >= 0;) {
548                *cp++ = ':';
549                *cp++ = hex[*ep >> 4 ];
550                *cp++ = hex[*ep++ & 0xf];
551        }
552
553        if (!ndo->ndo_nflag) {
554                snprintf(cp, BUFSIZE - (2 + 5*3), " (oui %s)",
555                    tok2str(oui_values, "Unknown", oui));
556        } else
557                *cp = '\0';
558        tp->e_name = strdup(buf);
559        if (tp->e_name == NULL)
560                (*ndo->ndo_error)(ndo, "etheraddr_string: strdup(buf)");
561        return (tp->e_name);
562}
563
564const char *
565le64addr_string(netdissect_options *ndo, const u_char *ep)
566{
567        const unsigned int len = 8;
568        register u_int i;
569        register char *cp;
570        register struct bsnamemem *tp;
571        char buf[BUFSIZE];
572
573        tp = lookup_bytestring(ndo, ep, len);
574        if (tp->bs_name)
575                return (tp->bs_name);
576
577        cp = buf;
578        for (i = len; i > 0 ; --i) {
579                *cp++ = hex[*(ep + i - 1) >> 4];
580                *cp++ = hex[*(ep + i - 1) & 0xf];
581                *cp++ = ':';
582        }
583        cp --;
584
585        *cp = '\0';
586
587        tp->bs_name = strdup(buf);
588        if (tp->bs_name == NULL)
589                (*ndo->ndo_error)(ndo, "le64addr_string: strdup(buf)");
590
591        return (tp->bs_name);
592}
593
594const char *
595linkaddr_string(netdissect_options *ndo, const u_char *ep,
596                const unsigned int type, const unsigned int len)
597{
598        register u_int i;
599        register char *cp;
600        register struct bsnamemem *tp;
601
602        if (len == 0)
603                return ("<empty>");
604
605        if (type == LINKADDR_ETHER && len == ETHER_ADDR_LEN)
606                return (etheraddr_string(ndo, ep));
607
608        if (type == LINKADDR_FRELAY)
609                return (q922_string(ndo, ep, len));
610
611        tp = lookup_bytestring(ndo, ep, len);
612        if (tp->bs_name)
613                return (tp->bs_name);
614
615        tp->bs_name = cp = (char *)malloc(len*3);
616        if (tp->bs_name == NULL)
617                (*ndo->ndo_error)(ndo, "linkaddr_string: malloc");
618        *cp++ = hex[*ep >> 4];
619        *cp++ = hex[*ep++ & 0xf];
620        for (i = len-1; i > 0 ; --i) {
621                *cp++ = ':';
622                *cp++ = hex[*ep >> 4];
623                *cp++ = hex[*ep++ & 0xf];
624        }
625        *cp = '\0';
626        return (tp->bs_name);
627}
628
629const char *
630etherproto_string(netdissect_options *ndo, u_short port)
631{
632        register char *cp;
633        register struct hnamemem *tp;
634        register uint32_t i = port;
635        char buf[sizeof("0000")];
636
637        for (tp = &eprototable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
638                if (tp->addr == i)
639                        return (tp->name);
640
641        tp->addr = i;
642        tp->nxt = newhnamemem(ndo);
643
644        cp = buf;
645        NTOHS(port);
646        *cp++ = hex[port >> 12 & 0xf];
647        *cp++ = hex[port >> 8 & 0xf];
648        *cp++ = hex[port >> 4 & 0xf];
649        *cp++ = hex[port & 0xf];
650        *cp++ = '\0';
651        tp->name = strdup(buf);
652        if (tp->name == NULL)
653                (*ndo->ndo_error)(ndo, "etherproto_string: strdup(buf)");
654        return (tp->name);
655}
656
657const char *
658protoid_string(netdissect_options *ndo, register const u_char *pi)
659{
660        register u_int i, j;
661        register char *cp;
662        register struct protoidmem *tp;
663        char buf[sizeof("00:00:00:00:00")];
664
665        tp = lookup_protoid(ndo, pi);
666        if (tp->p_name)
667                return tp->p_name;
668
669        cp = buf;
670        if ((j = *pi >> 4) != 0)
671                *cp++ = hex[j];
672        *cp++ = hex[*pi++ & 0xf];
673        for (i = 4; (int)--i >= 0;) {
674                *cp++ = ':';
675                if ((j = *pi >> 4) != 0)
676                        *cp++ = hex[j];
677                *cp++ = hex[*pi++ & 0xf];
678        }
679        *cp = '\0';
680        tp->p_name = strdup(buf);
681        if (tp->p_name == NULL)
682                (*ndo->ndo_error)(ndo, "protoid_string: strdup(buf)");
683        return (tp->p_name);
684}
685
686#define ISONSAP_MAX_LENGTH 20
687const char *
688isonsap_string(netdissect_options *ndo, const u_char *nsap,
689               register u_int nsap_length)
690{
691        register u_int nsap_idx;
692        register char *cp;
693        register struct enamemem *tp;
694
695        if (nsap_length < 1 || nsap_length > ISONSAP_MAX_LENGTH)
696                return ("isonsap_string: illegal length");
697
698        tp = lookup_nsap(ndo, nsap, nsap_length);
699        if (tp->e_name)
700                return tp->e_name;
701
702        tp->e_name = cp = (char *)malloc(sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx"));
703        if (cp == NULL)
704                (*ndo->ndo_error)(ndo, "isonsap_string: malloc");
705
706        for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {
707                *cp++ = hex[*nsap >> 4];
708                *cp++ = hex[*nsap++ & 0xf];
709                if (((nsap_idx & 1) == 0) &&
710                     (nsap_idx + 1 < nsap_length)) {
711                        *cp++ = '.';
712                }
713        }
714        *cp = '\0';
715        return (tp->e_name);
716}
717
718const char *
719tcpport_string(netdissect_options *ndo, u_short port)
720{
721        register struct hnamemem *tp;
722        register uint32_t i = port;
723        char buf[sizeof("00000")];
724
725        for (tp = &tporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
726                if (tp->addr == i)
727                        return (tp->name);
728
729        tp->addr = i;
730        tp->nxt = newhnamemem(ndo);
731
732        (void)snprintf(buf, sizeof(buf), "%u", i);
733        tp->name = strdup(buf);
734        if (tp->name == NULL)
735                (*ndo->ndo_error)(ndo, "tcpport_string: strdup(buf)");
736        return (tp->name);
737}
738
739const char *
740udpport_string(netdissect_options *ndo, register u_short port)
741{
742        register struct hnamemem *tp;
743        register uint32_t i = port;
744        char buf[sizeof("00000")];
745
746        for (tp = &uporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
747                if (tp->addr == i)
748                        return (tp->name);
749
750        tp->addr = i;
751        tp->nxt = newhnamemem(ndo);
752
753        (void)snprintf(buf, sizeof(buf), "%u", i);
754        tp->name = strdup(buf);
755        if (tp->name == NULL)
756                (*ndo->ndo_error)(ndo, "udpport_string: strdup(buf)");
757        return (tp->name);
758}
759
760const char *
761ipxsap_string(netdissect_options *ndo, u_short port)
762{
763        register char *cp;
764        register struct hnamemem *tp;
765        register uint32_t i = port;
766        char buf[sizeof("0000")];
767
768        for (tp = &ipxsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
769                if (tp->addr == i)
770                        return (tp->name);
771
772        tp->addr = i;
773        tp->nxt = newhnamemem(ndo);
774
775        cp = buf;
776        NTOHS(port);
777        *cp++ = hex[port >> 12 & 0xf];
778        *cp++ = hex[port >> 8 & 0xf];
779        *cp++ = hex[port >> 4 & 0xf];
780        *cp++ = hex[port & 0xf];
781        *cp++ = '\0';
782        tp->name = strdup(buf);
783        if (tp->name == NULL)
784                (*ndo->ndo_error)(ndo, "ipxsap_string: strdup(buf)");
785        return (tp->name);
786}
787
788static void
789init_servarray(netdissect_options *ndo)
790{
791        struct servent *sv;
792        register struct hnamemem *table;
793        register int i;
794        char buf[sizeof("0000000000")];
795
796        while ((sv = getservent()) != NULL) {
797                int port = ntohs(sv->s_port);
798                i = port & (HASHNAMESIZE-1);
799                if (strcmp(sv->s_proto, "tcp") == 0)
800                        table = &tporttable[i];
801                else if (strcmp(sv->s_proto, "udp") == 0)
802                        table = &uporttable[i];
803                else
804                        continue;
805
806                while (table->name)
807                        table = table->nxt;
808                if (ndo->ndo_nflag) {
809                        (void)snprintf(buf, sizeof(buf), "%d", port);
810                        table->name = strdup(buf);
811                } else
812                        table->name = strdup(sv->s_name);
813                if (table->name == NULL)
814                        (*ndo->ndo_error)(ndo, "init_servarray: strdup");
815
816                table->addr = port;
817                table->nxt = newhnamemem(ndo);
818        }
819        endservent();
820}
821
822static const struct eproto {
823        const char *s;
824        u_short p;
825} eproto_db[] = {
826        { "pup", ETHERTYPE_PUP },
827        { "xns", ETHERTYPE_NS },
828        { "ip", ETHERTYPE_IP },
829        { "ip6", ETHERTYPE_IPV6 },
830        { "arp", ETHERTYPE_ARP },
831        { "rarp", ETHERTYPE_REVARP },
832        { "sprite", ETHERTYPE_SPRITE },
833        { "mopdl", ETHERTYPE_MOPDL },
834        { "moprc", ETHERTYPE_MOPRC },
835        { "decnet", ETHERTYPE_DN },
836        { "lat", ETHERTYPE_LAT },
837        { "sca", ETHERTYPE_SCA },
838        { "lanbridge", ETHERTYPE_LANBRIDGE },
839        { "vexp", ETHERTYPE_VEXP },
840        { "vprod", ETHERTYPE_VPROD },
841        { "atalk", ETHERTYPE_ATALK },
842        { "atalkarp", ETHERTYPE_AARP },
843        { "loopback", ETHERTYPE_LOOPBACK },
844        { "decdts", ETHERTYPE_DECDTS },
845        { "decdns", ETHERTYPE_DECDNS },
846        { (char *)0, 0 }
847};
848
849static void
850init_eprotoarray(netdissect_options *ndo)
851{
852        register int i;
853        register struct hnamemem *table;
854
855        for (i = 0; eproto_db[i].s; i++) {
856                int j = htons(eproto_db[i].p) & (HASHNAMESIZE-1);
857                table = &eprototable[j];
858                while (table->name)
859                        table = table->nxt;
860                table->name = eproto_db[i].s;
861                table->addr = htons(eproto_db[i].p);
862                table->nxt = newhnamemem(ndo);
863        }
864}
865
866static const struct protoidlist {
867        const u_char protoid[5];
868        const char *name;
869} protoidlist[] = {
870        {{ 0x00, 0x00, 0x0c, 0x01, 0x07 }, "CiscoMLS" },
871        {{ 0x00, 0x00, 0x0c, 0x20, 0x00 }, "CiscoCDP" },
872        {{ 0x00, 0x00, 0x0c, 0x20, 0x01 }, "CiscoCGMP" },
873        {{ 0x00, 0x00, 0x0c, 0x20, 0x03 }, "CiscoVTP" },
874        {{ 0x00, 0xe0, 0x2b, 0x00, 0xbb }, "ExtremeEDP" },
875        {{ 0x00, 0x00, 0x00, 0x00, 0x00 }, NULL }
876};
877
878/*
879 * SNAP proto IDs with org code 0:0:0 are actually encapsulated Ethernet
880 * types.
881 */
882static void
883init_protoidarray(netdissect_options *ndo)
884{
885        register int i;
886        register struct protoidmem *tp;
887        const struct protoidlist *pl;
888        u_char protoid[5];
889
890        protoid[0] = 0;
891        protoid[1] = 0;
892        protoid[2] = 0;
893        for (i = 0; eproto_db[i].s; i++) {
894                u_short etype = htons(eproto_db[i].p);
895
896                memcpy((char *)&protoid[3], (char *)&etype, 2);
897                tp = lookup_protoid(ndo, protoid);
898                tp->p_name = strdup(eproto_db[i].s);
899                if (tp->p_name == NULL)
900                        (*ndo->ndo_error)(ndo,
901                                          "init_protoidarray: strdup(eproto_db[i].s)");
902        }
903        /* Hardwire some SNAP proto ID names */
904        for (pl = protoidlist; pl->name != NULL; ++pl) {
905                tp = lookup_protoid(ndo, pl->protoid);
906                /* Don't override existing name */
907                if (tp->p_name != NULL)
908                        continue;
909
910                tp->p_name = pl->name;
911        }
912}
913
914static const struct etherlist {
915        const u_char addr[6];
916        const char *name;
917} etherlist[] = {
918        {{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, "Broadcast" },
919        {{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, NULL }
920};
921
922/*
923 * Initialize the ethers hash table.  We take two different approaches
924 * depending on whether or not the system provides the ethers name
925 * service.  If it does, we just wire in a few names at startup,
926 * and etheraddr_string() fills in the table on demand.  If it doesn't,
927 * then we suck in the entire /etc/ethers file at startup.  The idea
928 * is that parsing the local file will be fast, but spinning through
929 * all the ethers entries via NIS & next_etherent might be very slow.
930 *
931 * XXX pcap_next_etherent doesn't belong in the pcap interface, but
932 * since the pcap module already does name-to-address translation,
933 * it's already does most of the work for the ethernet address-to-name
934 * translation, so we just pcap_next_etherent as a convenience.
935 */
936static void
937init_etherarray(netdissect_options *ndo)
938{
939        register const struct etherlist *el;
940        register struct enamemem *tp;
941#ifdef USE_ETHER_NTOHOST
942        char name[256];
943#else
944        register struct pcap_etherent *ep;
945        register FILE *fp;
946
947        /* Suck in entire ethers file */
948        fp = fopen(PCAP_ETHERS_FILE, "r");
949        if (fp != NULL) {
950                while ((ep = pcap_next_etherent(fp)) != NULL) {
951                        tp = lookup_emem(ndo, ep->addr);
952                        tp->e_name = strdup(ep->name);
953                        if (tp->e_name == NULL)
954                                (*ndo->ndo_error)(ndo,
955                                                  "init_etherarray: strdup(ep->addr)");
956                }
957                (void)fclose(fp);
958        }
959#endif
960
961        /* Hardwire some ethernet names */
962        for (el = etherlist; el->name != NULL; ++el) {
963                tp = lookup_emem(ndo, el->addr);
964                /* Don't override existing name */
965                if (tp->e_name != NULL)
966                        continue;
967
968#ifdef USE_ETHER_NTOHOST
969                /*
970                 * Use YP/NIS version of name if available.
971                 */
972                if (ether_ntohost(name, (const struct ether_addr *)el->addr) == 0) {
973                        tp->e_name = strdup(name);
974                        if (tp->e_name == NULL)
975                                (*ndo->ndo_error)(ndo,
976                                                  "init_etherarray: strdup(name)");
977                        continue;
978                }
979#endif
980                tp->e_name = el->name;
981        }
982}
983
984static const struct tok ipxsap_db[] = {
985        { 0x0000, "Unknown" },
986        { 0x0001, "User" },
987        { 0x0002, "User Group" },
988        { 0x0003, "PrintQueue" },
989        { 0x0004, "FileServer" },
990        { 0x0005, "JobServer" },
991        { 0x0006, "Gateway" },
992        { 0x0007, "PrintServer" },
993        { 0x0008, "ArchiveQueue" },
994        { 0x0009, "ArchiveServer" },
995        { 0x000a, "JobQueue" },
996        { 0x000b, "Administration" },
997        { 0x000F, "Novell TI-RPC" },
998        { 0x0017, "Diagnostics" },
999        { 0x0020, "NetBIOS" },
1000        { 0x0021, "NAS SNA Gateway" },
1001        { 0x0023, "NACS AsyncGateway" },
1002        { 0x0024, "RemoteBridge/RoutingService" },
1003        { 0x0026, "BridgeServer" },
1004        { 0x0027, "TCP/IP Gateway" },
1005        { 0x0028, "Point-to-point X.25 BridgeServer" },
1006        { 0x0029, "3270 Gateway" },
1007        { 0x002a, "CHI Corp" },
1008        { 0x002c, "PC Chalkboard" },
1009        { 0x002d, "TimeSynchServer" },
1010        { 0x002e, "ARCserve5.0/PalindromeBackup" },
1011        { 0x0045, "DI3270 Gateway" },
1012        { 0x0047, "AdvertisingPrintServer" },
1013        { 0x004a, "NetBlazerModems" },
1014        { 0x004b, "BtrieveVAP" },
1015        { 0x004c, "NetwareSQL" },
1016        { 0x004d, "XtreeNetwork" },
1017        { 0x0050, "BtrieveVAP4.11" },
1018        { 0x0052, "QuickLink" },
1019        { 0x0053, "PrintQueueUser" },
1020        { 0x0058, "Multipoint X.25 Router" },
1021        { 0x0060, "STLB/NLM" },
1022        { 0x0064, "ARCserve" },
1023        { 0x0066, "ARCserve3.0" },
1024        { 0x0072, "WAN CopyUtility" },
1025        { 0x007a, "TES-NetwareVMS" },
1026        { 0x0092, "WATCOM Debugger/EmeraldTapeBackupServer" },
1027        { 0x0095, "DDA OBGYN" },
1028        { 0x0098, "NetwareAccessServer" },
1029        { 0x009a, "Netware for VMS II/NamedPipeServer" },
1030        { 0x009b, "NetwareAccessServer" },
1031        { 0x009e, "PortableNetwareServer/SunLinkNVT" },
1032        { 0x00a1, "PowerchuteAPC UPS" },
1033        { 0x00aa, "LAWserve" },
1034        { 0x00ac, "CompaqIDA StatusMonitor" },
1035        { 0x0100, "PIPE STAIL" },
1036        { 0x0102, "LAN ProtectBindery" },
1037        { 0x0103, "OracleDataBaseServer" },
1038        { 0x0107, "Netware386/RSPX RemoteConsole" },
1039        { 0x010f, "NovellSNA Gateway" },
1040        { 0x0111, "TestServer" },
1041        { 0x0112, "HP PrintServer" },
1042        { 0x0114, "CSA MUX" },
1043        { 0x0115, "CSA LCA" },
1044        { 0x0116, "CSA CM" },
1045        { 0x0117, "CSA SMA" },
1046        { 0x0118, "CSA DBA" },
1047        { 0x0119, "CSA NMA" },
1048        { 0x011a, "CSA SSA" },
1049        { 0x011b, "CSA STATUS" },
1050        { 0x011e, "CSA APPC" },
1051        { 0x0126, "SNA TEST SSA Profile" },
1052        { 0x012a, "CSA TRACE" },
1053        { 0x012b, "NetwareSAA" },
1054        { 0x012e, "IKARUS VirusScan" },
1055        { 0x0130, "CommunicationsExecutive" },
1056        { 0x0133, "NNS DomainServer/NetwareNamingServicesDomain" },
1057        { 0x0135, "NetwareNamingServicesProfile" },
1058        { 0x0137, "Netware386 PrintQueue/NNS PrintQueue" },
1059        { 0x0141, "LAN SpoolServer" },
1060        { 0x0152, "IRMALAN Gateway" },
1061        { 0x0154, "NamedPipeServer" },
1062        { 0x0166, "NetWareManagement" },
1063        { 0x0168, "Intel PICKIT CommServer/Intel CAS TalkServer" },
1064        { 0x0173, "Compaq" },
1065        { 0x0174, "Compaq SNMP Agent" },
1066        { 0x0175, "Compaq" },
1067        { 0x0180, "XTreeServer/XTreeTools" },
1068        { 0x018A, "NASI ServicesBroadcastServer" },
1069        { 0x01b0, "GARP Gateway" },
1070        { 0x01b1, "Binfview" },
1071        { 0x01bf, "IntelLanDeskManager" },
1072        { 0x01ca, "AXTEC" },
1073        { 0x01cb, "ShivaNetModem/E" },
1074        { 0x01cc, "ShivaLanRover/E" },
1075        { 0x01cd, "ShivaLanRover/T" },
1076        { 0x01ce, "ShivaUniversal" },
1077        { 0x01d8, "CastelleFAXPressServer" },
1078        { 0x01da, "CastelleLANPressPrintServer" },
1079        { 0x01dc, "CastelleFAX/Xerox7033 FaxServer/ExcelLanFax" },
1080        { 0x01f0, "LEGATO" },
1081        { 0x01f5, "LEGATO" },
1082        { 0x0233, "NMS Agent/NetwareManagementAgent" },
1083        { 0x0237, "NMS IPX Discovery/LANternReadWriteChannel" },
1084        { 0x0238, "NMS IP Discovery/LANternTrapAlarmChannel" },
1085        { 0x023a, "LANtern" },
1086        { 0x023c, "MAVERICK" },
1087        { 0x023f, "NovellSMDR" },
1088        { 0x024e, "NetwareConnect" },
1089        { 0x024f, "NASI ServerBroadcast Cisco" },
1090        { 0x026a, "NMS ServiceConsole" },
1091        { 0x026b, "TimeSynchronizationServer Netware 4.x" },
1092        { 0x0278, "DirectoryServer Netware 4.x" },
1093        { 0x027b, "NetwareManagementAgent" },
1094        { 0x0280, "Novell File and Printer Sharing Service for PC" },
1095        { 0x0304, "NovellSAA Gateway" },
1096        { 0x0308, "COM/VERMED" },
1097        { 0x030a, "GalacticommWorldgroupServer" },
1098        { 0x030c, "IntelNetport2/HP JetDirect/HP Quicksilver" },
1099        { 0x0320, "AttachmateGateway" },
1100        { 0x0327, "MicrosoftDiagnostiocs" },
1101        { 0x0328, "WATCOM SQL Server" },
1102        { 0x0335, "MultiTechSystems MultisynchCommServer" },
1103        { 0x0343, "Xylogics RemoteAccessServer/LANModem" },
1104        { 0x0355, "ArcadaBackupExec" },
1105        { 0x0358, "MSLCD1" },
1106        { 0x0361, "NETINELO" },
1107        { 0x037e, "Powerchute UPS Monitoring" },
1108        { 0x037f, "ViruSafeNotify" },
1109        { 0x0386, "HP Bridge" },
1110        { 0x0387, "HP Hub" },
1111        { 0x0394, "NetWare SAA Gateway" },
1112        { 0x039b, "LotusNotes" },
1113        { 0x03b7, "CertusAntiVirus" },
1114        { 0x03c4, "ARCserve4.0" },
1115        { 0x03c7, "LANspool3.5" },
1116        { 0x03d7, "LexmarkPrinterServer" },
1117        { 0x03d8, "LexmarkXLE PrinterServer" },
1118        { 0x03dd, "BanyanENS NetwareClient" },
1119        { 0x03de, "GuptaSequelBaseServer/NetWareSQL" },
1120        { 0x03e1, "UnivelUnixware" },
1121        { 0x03e4, "UnivelUnixware" },
1122        { 0x03fc, "IntelNetport" },
1123        { 0x03fd, "PrintServerQueue" },
1124        { 0x040A, "ipnServer" },
1125        { 0x040D, "LVERRMAN" },
1126        { 0x040E, "LVLIC" },
1127        { 0x0414, "NET Silicon (DPI)/Kyocera" },
1128        { 0x0429, "SiteLockVirus" },
1129        { 0x0432, "UFHELPR???" },
1130        { 0x0433, "Synoptics281xAdvancedSNMPAgent" },
1131        { 0x0444, "MicrosoftNT SNA Server" },
1132        { 0x0448, "Oracle" },
1133        { 0x044c, "ARCserve5.01" },
1134        { 0x0457, "CanonGP55" },
1135        { 0x045a, "QMS Printers" },
1136        { 0x045b, "DellSCSI Array" },
1137        { 0x0491, "NetBlazerModems" },
1138        { 0x04ac, "OnTimeScheduler" },
1139        { 0x04b0, "CD-Net" },
1140        { 0x0513, "EmulexNQA" },
1141        { 0x0520, "SiteLockChecks" },
1142        { 0x0529, "SiteLockChecks" },
1143        { 0x052d, "CitrixOS2 AppServer" },
1144        { 0x0535, "Tektronix" },
1145        { 0x0536, "Milan" },
1146        { 0x055d, "Attachmate SNA gateway" },
1147        { 0x056b, "IBM8235 ModemServer" },
1148        { 0x056c, "ShivaLanRover/E PLUS" },
1149        { 0x056d, "ShivaLanRover/T PLUS" },
1150        { 0x0580, "McAfeeNetShield" },
1151        { 0x05B8, "NLM to workstation communication (Revelation Software)" },
1152        { 0x05BA, "CompatibleSystemsRouters" },
1153        { 0x05BE, "CheyenneHierarchicalStorageManager" },
1154        { 0x0606, "JCWatermarkImaging" },
1155        { 0x060c, "AXISNetworkPrinter" },
1156        { 0x0610, "AdaptecSCSIManagement" },
1157        { 0x0621, "IBM AntiVirus" },
1158        { 0x0640, "Windows95 RemoteRegistryService" },
1159        { 0x064e, "MicrosoftIIS" },
1160        { 0x067b, "Microsoft Win95/98 File and Print Sharing for NetWare" },
1161        { 0x067c, "Microsoft Win95/98 File and Print Sharing for NetWare" },
1162        { 0x076C, "Xerox" },
1163        { 0x079b, "ShivaLanRover/E 115" },
1164        { 0x079c, "ShivaLanRover/T 115" },
1165        { 0x07B4, "CubixWorldDesk" },
1166        { 0x07c2, "Quarterdeck IWare Connect V2.x NLM" },
1167        { 0x07c1, "Quarterdeck IWare Connect V3.x NLM" },
1168        { 0x0810, "ELAN License Server Demo" },
1169        { 0x0824, "ShivaLanRoverAccessSwitch/E" },
1170        { 0x086a, "ISSC Collector" },
1171        { 0x087f, "ISSC DAS AgentAIX" },
1172        { 0x0880, "Intel Netport PRO" },
1173        { 0x0881, "Intel Netport PRO" },
1174        { 0x0b29, "SiteLock" },
1175        { 0x0c29, "SiteLockApplications" },
1176        { 0x0c2c, "LicensingServer" },
1177        { 0x2101, "PerformanceTechnologyInstantInternet" },
1178        { 0x2380, "LAI SiteLock" },
1179        { 0x238c, "MeetingMaker" },
1180        { 0x4808, "SiteLockServer/SiteLockMetering" },
1181        { 0x5555, "SiteLockUser" },
1182        { 0x6312, "Tapeware" },
1183        { 0x6f00, "RabbitGateway" },
1184        { 0x7703, "MODEM" },
1185        { 0x8002, "NetPortPrinters" },
1186        { 0x8008, "WordPerfectNetworkVersion" },
1187        { 0x85BE, "Cisco EIGRP" },
1188        { 0x8888, "WordPerfectNetworkVersion/QuickNetworkManagement" },
1189        { 0x9000, "McAfeeNetShield" },
1190        { 0x9604, "CSA-NT_MON" },
1191        { 0xb6a8, "OceanIsleReachoutRemoteControl" },
1192        { 0xf11f, "SiteLockMetering" },
1193        { 0xf1ff, "SiteLock" },
1194        { 0xf503, "Microsoft SQL Server" },
1195        { 0xF905, "IBM TimeAndPlace" },
1196        { 0xfbfb, "TopCallIII FaxServer" },
1197        { 0xffff, "AnyService/Wildcard" },
1198        { 0, (char *)0 }
1199};
1200
1201static void
1202init_ipxsaparray(netdissect_options *ndo)
1203{
1204        register int i;
1205        register struct hnamemem *table;
1206
1207        for (i = 0; ipxsap_db[i].s != NULL; i++) {
1208                int j = htons(ipxsap_db[i].v) & (HASHNAMESIZE-1);
1209                table = &ipxsaptable[j];
1210                while (table->name)
1211                        table = table->nxt;
1212                table->name = ipxsap_db[i].s;
1213                table->addr = htons(ipxsap_db[i].v);
1214                table->nxt = newhnamemem(ndo);
1215        }
1216}
1217
1218/*
1219 * Initialize the address to name translation machinery.  We map all
1220 * non-local IP addresses to numeric addresses if ndo->ndo_fflag is true
1221 * (i.e., to prevent blocking on the nameserver).  localnet is the IP address
1222 * of the local network.  mask is its subnet mask.
1223 */
1224void
1225init_addrtoname(netdissect_options *ndo, uint32_t localnet, uint32_t mask)
1226{
1227        if (ndo->ndo_fflag) {
1228                f_localnet = localnet;
1229                f_netmask = mask;
1230        }
1231        if (ndo->ndo_nflag)
1232                /*
1233                 * Simplest way to suppress names.
1234                 */
1235                return;
1236
1237        init_etherarray(ndo);
1238        init_servarray(ndo);
1239        init_eprotoarray(ndo);
1240        init_protoidarray(ndo);
1241        init_ipxsaparray(ndo);
1242}
1243
1244const char *
1245dnaddr_string(netdissect_options *ndo, u_short dnaddr)
1246{
1247        register struct hnamemem *tp;
1248
1249        for (tp = &dnaddrtable[dnaddr & (HASHNAMESIZE-1)]; tp->nxt != NULL;
1250             tp = tp->nxt)
1251                if (tp->addr == dnaddr)
1252                        return (tp->name);
1253
1254        tp->addr = dnaddr;
1255        tp->nxt = newhnamemem(ndo);
1256        if (ndo->ndo_nflag)
1257                tp->name = dnnum_string(ndo, dnaddr);
1258        else
1259                tp->name = dnname_string(ndo, dnaddr);
1260
1261        return(tp->name);
1262}
1263
1264/* Return a zero'ed hnamemem struct and cuts down on calloc() overhead */
1265struct hnamemem *
1266newhnamemem(netdissect_options *ndo)
1267{
1268        register struct hnamemem *p;
1269#ifdef __rtems__
1270        __section(".rtemsrwset.bsd_prog_tcpdump.content")
1271#endif /* __rtems__ */
1272        static struct hnamemem *ptr = NULL;
1273#ifdef __rtems__
1274        __section(".rtemsrwset.bsd_prog_tcpdump.content")
1275#endif /* __rtems__ */
1276        static u_int num = 0;
1277
1278        if (num  <= 0) {
1279                num = 64;
1280                ptr = (struct hnamemem *)calloc(num, sizeof (*ptr));
1281                if (ptr == NULL)
1282                        (*ndo->ndo_error)(ndo, "newhnamemem: calloc");
1283        }
1284        --num;
1285        p = ptr++;
1286        return (p);
1287}
1288
1289/* Return a zero'ed h6namemem struct and cuts down on calloc() overhead */
1290struct h6namemem *
1291newh6namemem(netdissect_options *ndo)
1292{
1293        register struct h6namemem *p;
1294#ifdef __rtems__
1295        __section(".rtemsrwset.bsd_prog_tcpdump.content")
1296#endif /* __rtems__ */
1297        static struct h6namemem *ptr = NULL;
1298#ifdef __rtems__
1299        __section(".rtemsrwset.bsd_prog_tcpdump.content")
1300#endif /* __rtems__ */
1301        static u_int num = 0;
1302
1303        if (num  <= 0) {
1304                num = 64;
1305                ptr = (struct h6namemem *)calloc(num, sizeof (*ptr));
1306                if (ptr == NULL)
1307                        (*ndo->ndo_error)(ndo, "newh6namemem: calloc");
1308        }
1309        --num;
1310        p = ptr++;
1311        return (p);
1312}
1313
1314/* Represent TCI part of the 802.1Q 4-octet tag as text. */
1315const char *
1316ieee8021q_tci_string(const uint16_t tci)
1317{
1318        static char buf[128];
1319        snprintf(buf, sizeof(buf), "vlan %u, p %u%s",
1320                 tci & 0xfff,
1321                 tci >> 13,
1322                 (tci & 0x1000) ? ", DEI" : "");
1323        return buf;
1324}
1325#ifdef __rtems__
1326#include "rtems-bsd-tcpdump-addrtoname-data.h"
1327#endif /* __rtems__ */
Note: See TracBrowser for help on using the repository browser.