/*
* Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and this paragraph in its entirety, (2)
* distributions including binary code include the above copyright notice and
* this paragraph in its entirety in the documentation or other materials
* provided with the distribution, and (3) all advertising materials mentioning
* features or use of this software display the following acknowledgement:
* ``This product includes software developed by the University of California,
* Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
* the University nor the names of its contributors may be used to endorse
* or promote products derived from this software without specific prior
* written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

/* \summary: AppleTalk printer */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: print-atalk.c,v 1.9 2024/09/02 16:15:30 christos Exp $");
#endif

#include <config.h>

#include "netdissect-stdinc.h"

#include <stdio.h>
#include <string.h>

#include "netdissect.h"
#include "addrtoname.h"
#include "ethertype.h"
#include "extract.h"
#include "appletalk.h"


static const struct tok type2str[] = {
       { ddpRTMP,              "rtmp" },
       { ddpRTMPrequest,       "rtmpReq" },
       { ddpECHO,              "echo" },
       { ddpIP,                "IP" },
       { ddpARP,               "ARP" },
       { ddpKLAP,              "KLAP" },
       { 0,                    NULL }
};

struct aarp {
       nd_uint16_t     htype, ptype;
       nd_uint8_t      halen, palen;
       nd_uint16_t     op;
       nd_mac_addr     hsaddr;
       uint8_t         psaddr[4];
       nd_mac_addr     hdaddr;
       uint8_t         pdaddr[4];
};

static void atp_print(netdissect_options *, const struct atATP *, u_int);
static void atp_bitmap_print(netdissect_options *, u_char);
static void nbp_print(netdissect_options *, const struct atNBP *, u_int, u_short, u_char, u_char);
static const struct atNBPtuple *nbp_tuple_print(netdissect_options *ndo, const struct atNBPtuple *,
                                               const u_char *,
                                               u_short, u_char, u_char);
static const struct atNBPtuple *nbp_name_print(netdissect_options *, const struct atNBPtuple *,
                                              const u_char *);
static const char *ataddr_string(netdissect_options *, u_short, u_char);
static void ddp_print(netdissect_options *, const u_char *, u_int, u_int, u_short, u_char, u_char);
static const char *ddpskt_string(netdissect_options *, u_int);

/*
* Print LLAP packets received on a physical LocalTalk interface.
*/
void
ltalk_if_print(netdissect_options *ndo,
              const struct pcap_pkthdr *h, const u_char *p)
{
       u_int hdrlen;

       ndo->ndo_protocol = "ltalk";
       hdrlen = llap_print(ndo, p, h->len);
       if (hdrlen == 0) {
               /* Cut short by the snapshot length. */
               ndo->ndo_ll_hdr_len += h->caplen;
               return;
       }
       ndo->ndo_ll_hdr_len += hdrlen;
}

/*
* Print AppleTalk LLAP packets.
*/
u_int
llap_print(netdissect_options *ndo,
          const u_char *bp, u_int length)
{
       const struct LAP *lp;
       const struct atDDP *dp;
       const struct atShortDDP *sdp;
       u_short snet;
       u_int hdrlen;

       ndo->ndo_protocol = "llap";
       if (length < sizeof(*lp)) {
               ND_PRINT(" [|llap %u]", length);
               return (length);
       }
       if (!ND_TTEST_LEN(bp, sizeof(*lp))) {
               nd_print_trunc(ndo);
               return (0);     /* cut short by the snapshot length */
       }
       lp = (const struct LAP *)bp;
       bp += sizeof(*lp);
       length -= sizeof(*lp);
       hdrlen = sizeof(*lp);
       switch (GET_U_1(lp->type)) {

       case lapShortDDP:
               if (length < ddpSSize) {
                       ND_PRINT(" [|sddp %u]", length);
                       return (length);
               }
               if (!ND_TTEST_LEN(bp, ddpSSize)) {
                       ND_PRINT(" [|sddp]");
                       return (0);     /* cut short by the snapshot length */
               }
               sdp = (const struct atShortDDP *)bp;
               ND_PRINT("%s.%s",
                   ataddr_string(ndo, 0, GET_U_1(lp->src)),
                   ddpskt_string(ndo, GET_U_1(sdp->srcSkt)));
               ND_PRINT(" > %s.%s:",
                   ataddr_string(ndo, 0, GET_U_1(lp->dst)),
                   ddpskt_string(ndo, GET_U_1(sdp->dstSkt)));
               bp += ddpSSize;
               length -= ddpSSize;
               hdrlen += ddpSSize;
               ddp_print(ndo, bp, length, GET_U_1(sdp->type), 0,
                         GET_U_1(lp->src), GET_U_1(sdp->srcSkt));
               break;

       case lapDDP:
               if (length < ddpSize) {
                       ND_PRINT(" [|ddp %u]", length);
                       return (length);
               }
               if (!ND_TTEST_LEN(bp, ddpSize)) {
                       ND_PRINT(" [|ddp]");
                       return (0);     /* cut short by the snapshot length */
               }
               dp = (const struct atDDP *)bp;
               snet = GET_BE_U_2(dp->srcNet);
               ND_PRINT("%s.%s",
                        ataddr_string(ndo, snet, GET_U_1(dp->srcNode)),
                        ddpskt_string(ndo, GET_U_1(dp->srcSkt)));
               ND_PRINT(" > %s.%s:",
                   ataddr_string(ndo, GET_BE_U_2(dp->dstNet), GET_U_1(dp->dstNode)),
                   ddpskt_string(ndo, GET_U_1(dp->dstSkt)));
               bp += ddpSize;
               length -= ddpSize;
               hdrlen += ddpSize;
               ddp_print(ndo, bp, length, GET_U_1(dp->type), snet,
                         GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));
               break;

#ifdef notdef
       case lapKLAP:
               klap_print(bp, length);
               break;
#endif

       default:
               ND_PRINT("%u > %u at-lap#%u %u",
                   GET_U_1(lp->src), GET_U_1(lp->dst), GET_U_1(lp->type),
                   length);
               break;
       }
       return (hdrlen);
}

/*
* Print EtherTalk/TokenTalk packets (or FDDITalk, or whatever it's called
* when it runs over FDDI; yes, I've seen FDDI captures with AppleTalk
* packets in them).
*/
void
atalk_print(netdissect_options *ndo,
           const u_char *bp, u_int length)
{
       const struct atDDP *dp;
       u_short snet;

       ndo->ndo_protocol = "atalk";
       if(!ndo->ndo_eflag)
           ND_PRINT("AT ");

       if (length < ddpSize) {
               ND_PRINT(" [|ddp %u]", length);
               return;
       }
       if (!ND_TTEST_LEN(bp, ddpSize)) {
               ND_PRINT(" [|ddp]");
               return;
       }
       dp = (const struct atDDP *)bp;
       snet = GET_BE_U_2(dp->srcNet);
       ND_PRINT("%s.%s", ataddr_string(ndo, snet, GET_U_1(dp->srcNode)),
                ddpskt_string(ndo, GET_U_1(dp->srcSkt)));
       ND_PRINT(" > %s.%s: ",
              ataddr_string(ndo, GET_BE_U_2(dp->dstNet), GET_U_1(dp->dstNode)),
              ddpskt_string(ndo, GET_U_1(dp->dstSkt)));
       bp += ddpSize;
       length -= ddpSize;
       ddp_print(ndo, bp, length, GET_U_1(dp->type), snet,
                 GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));
}

/* XXX should probably pass in the snap header and do checks like arp_print() */
void
aarp_print(netdissect_options *ndo,
          const u_char *bp, u_int length)
{
       const struct aarp *ap;

#define AT(member) ataddr_string(ndo, (ap->member[1]<<8)|ap->member[2],ap->member[3])

       ndo->ndo_protocol = "aarp";
       ND_PRINT("aarp ");
       ap = (const struct aarp *)bp;
       if (!ND_TTEST_SIZE(ap)) {
               /* Just bail if we don't have the whole chunk. */
               nd_print_trunc(ndo);
               return;
       }
       if (length < sizeof(*ap)) {
               ND_PRINT(" [|aarp %u]", length);
               return;
       }
       if (GET_BE_U_2(ap->htype) == 1 &&
           GET_BE_U_2(ap->ptype) == ETHERTYPE_ATALK &&
           GET_U_1(ap->halen) == MAC_ADDR_LEN && GET_U_1(ap->palen) == 4)
               switch (GET_BE_U_2(ap->op)) {

               case 1:                         /* request */
                       ND_PRINT("who-has %s tell %s", AT(pdaddr), AT(psaddr));
                       return;

               case 2:                         /* response */
                       ND_PRINT("reply %s is-at %s", AT(psaddr), GET_ETHERADDR_STRING(ap->hsaddr));
                       return;

               case 3:                         /* probe (oy!) */
                       ND_PRINT("probe %s tell %s", AT(pdaddr), AT(psaddr));
                       return;
               }
       ND_PRINT("len %u op %u htype %u ptype %#x halen %u palen %u",
           length, GET_BE_U_2(ap->op), GET_BE_U_2(ap->htype),
           GET_BE_U_2(ap->ptype), GET_U_1(ap->halen), GET_U_1(ap->palen));
}

/*
* Print AppleTalk Datagram Delivery Protocol packets.
*/
static void
ddp_print(netdissect_options *ndo,
         const u_char *bp, u_int length, u_int t,
         u_short snet, u_char snode, u_char skt)
{

       switch (t) {

       case ddpNBP:
               nbp_print(ndo, (const struct atNBP *)bp, length, snet, snode, skt);
               break;

       case ddpATP:
               atp_print(ndo, (const struct atATP *)bp, length);
               break;

       case ddpEIGRP:
               eigrp_print(ndo, bp, length);
               break;

       default:
               ND_PRINT(" at-%s %u", tok2str(type2str, NULL, t), length);
               break;
       }
}

static void
atp_print(netdissect_options *ndo,
         const struct atATP *ap, u_int length)
{
       uint8_t control;
       uint32_t data;

       if ((const u_char *)(ap + 1) > ndo->ndo_snapend) {
               /* Just bail if we don't have the whole chunk. */
               nd_print_trunc(ndo);
               return;
       }
       if (length < sizeof(*ap)) {
               ND_PRINT(" [|atp %u]", length);
               return;
       }
       length -= sizeof(*ap);
       control = GET_U_1(ap->control);
       switch (control & 0xc0) {

       case atpReqCode:
               ND_PRINT(" atp-req%s %u",
                            control & atpXO? " " : "*",
                            GET_BE_U_2(ap->transID));

               atp_bitmap_print(ndo, GET_U_1(ap->bitmap));

               if (length != 0)
                       ND_PRINT(" [len=%u]", length);

               switch (control & (atpEOM|atpSTS)) {
               case atpEOM:
                       ND_PRINT(" [EOM]");
                       break;
               case atpSTS:
                       ND_PRINT(" [STS]");
                       break;
               case atpEOM|atpSTS:
                       ND_PRINT(" [EOM,STS]");
                       break;
               }
               break;

       case atpRspCode:
               ND_PRINT(" atp-resp%s%u:%u (%u)",
                            control & atpEOM? "*" : " ",
                            GET_BE_U_2(ap->transID), GET_U_1(ap->bitmap),
                            length);
               switch (control & (atpXO|atpSTS)) {
               case atpXO:
                       ND_PRINT(" [XO]");
                       break;
               case atpSTS:
                       ND_PRINT(" [STS]");
                       break;
               case atpXO|atpSTS:
                       ND_PRINT(" [XO,STS]");
                       break;
               }
               break;

       case atpRelCode:
               ND_PRINT(" atp-rel  %u", GET_BE_U_2(ap->transID));

               atp_bitmap_print(ndo, GET_U_1(ap->bitmap));

               /* length should be zero */
               if (length)
                       ND_PRINT(" [len=%u]", length);

               /* there shouldn't be any control flags */
               if (control & (atpXO|atpEOM|atpSTS)) {
                       char c = '[';
                       if (control & atpXO) {
                               ND_PRINT("%cXO", c);
                               c = ',';
                       }
                       if (control & atpEOM) {
                               ND_PRINT("%cEOM", c);
                               c = ',';
                       }
                       if (control & atpSTS) {
                               ND_PRINT("%cSTS", c);
                       }
                       ND_PRINT("]");
               }
               break;

       default:
               ND_PRINT(" atp-0x%x  %u (%u)", control,
                            GET_BE_U_2(ap->transID), length);
               break;
       }
       data = GET_BE_U_4(ap->userData);
       if (data != 0)
               ND_PRINT(" 0x%x", data);
}

static void
atp_bitmap_print(netdissect_options *ndo,
                u_char bm)
{
       u_int i;

       /*
        * The '& 0xff' below is needed for compilers that want to sign
        * extend a u_char, which is the case with the Ultrix compiler.
        * (gcc is smart enough to eliminate it, at least on the Sparc).
        */
       if ((bm + 1) & (bm & 0xff)) {
               char c = '<';
               for (i = 0; bm; ++i) {
                       if (bm & 1) {
                               ND_PRINT("%c%u", c, i);
                               c = ',';
                       }
                       bm >>= 1;
               }
               ND_PRINT(">");
       } else {
               for (i = 0; bm; ++i)
                       bm >>= 1;
               if (i > 1)
                       ND_PRINT("<0-%u>", i - 1);
               else
                       ND_PRINT("<0>");
       }
}

static void
nbp_print(netdissect_options *ndo,
         const struct atNBP *np, u_int length, u_short snet,
         u_char snode, u_char skt)
{
       const struct atNBPtuple *tp =
               (const struct atNBPtuple *)((const u_char *)np + nbpHeaderSize);
       uint8_t control;
       u_int i;
       const u_char *ep;

       if (length < nbpHeaderSize) {
               ND_PRINT(" truncated-nbp %u", length);
               return;
       }

       length -= nbpHeaderSize;
       if (length < 8) {
               /* must be room for at least one tuple */
               ND_PRINT(" truncated-nbp %u", length + nbpHeaderSize);
               return;
       }
       /* ep points to end of available data */
       ep = ndo->ndo_snapend;
       if ((const u_char *)tp > ep) {
               nd_print_trunc(ndo);
               return;
       }
       control = GET_U_1(np->control);
       switch (i = (control & 0xf0)) {

       case nbpBrRq:
       case nbpLkUp:
               ND_PRINT(i == nbpLkUp? " nbp-lkup %u:":" nbp-brRq %u:",
                        GET_U_1(np->id));
               if ((const u_char *)(tp + 1) > ep) {
                       nd_print_trunc(ndo);
                       return;
               }
               (void)nbp_name_print(ndo, tp, ep);
               /*
                * look for anomalies: the spec says there can only
                * be one tuple, the address must match the source
                * address and the enumerator should be zero.
                */
               if ((control & 0xf) != 1)
                       ND_PRINT(" [ntup=%u]", control & 0xf);
               if (GET_U_1(tp->enumerator))
                       ND_PRINT(" [enum=%u]", GET_U_1(tp->enumerator));
               if (GET_BE_U_2(tp->net) != snet ||
                   GET_U_1(tp->node) != snode ||
                   GET_U_1(tp->skt) != skt)
                       ND_PRINT(" [addr=%s.%u]",
                           ataddr_string(ndo, GET_BE_U_2(tp->net),
                                         GET_U_1(tp->node)),
                           GET_U_1(tp->skt));
               break;

       case nbpLkUpReply:
               ND_PRINT(" nbp-reply %u:", GET_U_1(np->id));

               /* print each of the tuples in the reply */
               for (i = control & 0xf; i != 0 && tp; i--)
                       tp = nbp_tuple_print(ndo, tp, ep, snet, snode, skt);
               break;

       default:
               ND_PRINT(" nbp-0x%x  %u (%u)", control, GET_U_1(np->id),
                        length);
               break;
       }
}

/* print a counted string */
static const u_char *
print_cstring(netdissect_options *ndo,
             const u_char *cp, const u_char *ep)
{
       u_int length;

       if (cp >= ep) {
               nd_print_trunc(ndo);
               return (0);
       }
       length = GET_U_1(cp);
       cp++;

       /* Spec says string can be at most 32 bytes long */
       if (length > 32) {
               ND_PRINT("[len=%u]", length);
               return (0);
       }
       while (length != 0) {
               if (cp >= ep) {
                       nd_print_trunc(ndo);
                       return (0);
               }
               fn_print_char(ndo, GET_U_1(cp));
               cp++;
               length--;
       }
       return (cp);
}

static const struct atNBPtuple *
nbp_tuple_print(netdissect_options *ndo,
               const struct atNBPtuple *tp, const u_char *ep,
               u_short snet, u_char snode, u_char skt)
{
       const struct atNBPtuple *tpn;

       if ((const u_char *)(tp + 1) > ep) {
               nd_print_trunc(ndo);
               return 0;
       }
       tpn = nbp_name_print(ndo, tp, ep);

       /* if the enumerator isn't 1, print it */
       if (GET_U_1(tp->enumerator) != 1)
               ND_PRINT("(%u)", GET_U_1(tp->enumerator));

       /* if the socket doesn't match the src socket, print it */
       if (GET_U_1(tp->skt) != skt)
               ND_PRINT(" %u", GET_U_1(tp->skt));

       /* if the address doesn't match the src address, it's an anomaly */
       if (GET_BE_U_2(tp->net) != snet ||
           GET_U_1(tp->node) != snode)
               ND_PRINT(" [addr=%s]",
                   ataddr_string(ndo, GET_BE_U_2(tp->net), GET_U_1(tp->node)));

       return (tpn);
}

static const struct atNBPtuple *
nbp_name_print(netdissect_options *ndo,
              const struct atNBPtuple *tp, const u_char *ep)
{
       const u_char *cp = (const u_char *)tp + nbpTupleSize;

       ND_PRINT(" ");

       /* Object */
       ND_PRINT("\"");
       if ((cp = print_cstring(ndo, cp, ep)) != NULL) {
               /* Type */
               ND_PRINT(":");
               if ((cp = print_cstring(ndo, cp, ep)) != NULL) {
                       /* Zone */
                       ND_PRINT("@");
                       if ((cp = print_cstring(ndo, cp, ep)) != NULL)
                               ND_PRINT("\"");
               }
       }
       return ((const struct atNBPtuple *)cp);
}


#define HASHNAMESIZE 4096

struct hnamemem {
       u_int addr;
       char *name;
       struct hnamemem *nxt;
};

static struct hnamemem hnametable[HASHNAMESIZE];

static const char *
ataddr_string(netdissect_options *ndo,
             u_short atnet, u_char athost)
{
       struct hnamemem *tp, *tp2;
       u_int i = (atnet << 8) | athost;
       char nambuf[256+1];
       static int first = 1;
       FILE *fp;

       /*
        * Are we doing address to name resolution?
        */
       if (!ndo->ndo_nflag) {
               /*
                * Yes.  Have we tried to open and read an AppleTalk
                * number to name map file?
                */
               if (!first) {
                       /*
                        * No; try to do so.
                        */
                       first = 0;
                       fp = fopen("/etc/atalk.names", "r");
                       if (fp != NULL) {
                               char line[256];
                               u_int i1, i2;

                               while (fgets(line, sizeof(line), fp)) {
                                       if (line[0] == '\n' || line[0] == 0 ||
                                           line[0] == '#')
                                               continue;
                                       if (sscanf(line, "%u.%u %256s", &i1,
                                           &i2, nambuf) == 3)
                                               /* got a hostname. */
                                               i2 |= (i1 << 8);
                                       else if (sscanf(line, "%u %256s", &i1,
                                           nambuf) == 2)
                                               /* got a net name */
                                               i2 = (i1 << 8) | 255;
                                       else
                                               continue;

                                       for (tp = &hnametable[i2 & (HASHNAMESIZE-1)];
                                            tp->nxt; tp = tp->nxt)
                                               ;
                                       tp->addr = i2;
                                       tp->nxt = newhnamemem(ndo);
                                       tp->name = strdup(nambuf);
                                       if (tp->name == NULL)
                                               (*ndo->ndo_error)(ndo,
                                                   S_ERR_ND_MEM_ALLOC,
                                                   "%s: strdup(nambuf)", __func__);
                               }
                               fclose(fp);
                       }
               }
       }

       /*
        * Now try to look up the address in the table.
        */
       for (tp = &hnametable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
               if (tp->addr == i)
                       return (tp->name);

       /* didn't have the node name -- see if we've got the net name */
       i |= 255;
       for (tp2 = &hnametable[i & (HASHNAMESIZE-1)]; tp2->nxt; tp2 = tp2->nxt)
               if (tp2->addr == i) {
                       tp->addr = (atnet << 8) | athost;
                       tp->nxt = newhnamemem(ndo);
                       (void)snprintf(nambuf, sizeof(nambuf), "%s.%u",
                           tp2->name, athost);
                       tp->name = strdup(nambuf);
                       if (tp->name == NULL)
                               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                                       "%s: strdup(nambuf)", __func__);
                       return (tp->name);
               }

       tp->addr = (atnet << 8) | athost;
       tp->nxt = newhnamemem(ndo);
       if (athost != 255)
               (void)snprintf(nambuf, sizeof(nambuf), "%u.%u", atnet, athost);
       else
               (void)snprintf(nambuf, sizeof(nambuf), "%u", atnet);
       tp->name = strdup(nambuf);
       if (tp->name == NULL)
               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                                 "%s: strdup(nambuf)", __func__);

       return (tp->name);
}

static const struct tok skt2str[] = {
       { rtmpSkt,      "rtmp" },       /* routing table maintenance */
       { nbpSkt,       "nis" },        /* name info socket */
       { echoSkt,      "echo" },       /* AppleTalk echo protocol */
       { zipSkt,       "zip" },        /* zone info protocol */
       { 0,            NULL }
};

static const char *
ddpskt_string(netdissect_options *ndo,
             u_int skt)
{
       static char buf[8];

       if (ndo->ndo_nflag) {
               (void)snprintf(buf, sizeof(buf), "%u", skt);
               return (buf);
       }
       return (tok2str(skt2str, "%u", skt));
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.