/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <net/if.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/if_ether.h>
#include <arpa/inet.h>
#include "snoop.h"
#include "snoop_ospf.h"
#include "snoop_ospf6.h"

extern char *dlc_header;
static char *sum_line;

char *ospf_types[] = {
        "umd",          /* 0 */
        "Hello",        /* 1 */
        "DD",           /* 2 */
        "LSReq",        /* 3 */
        "LSUpd",        /* 4 */
        "LSAck",        /* 5 */
};

static char *ospf_authtypes[] = {
        "None",         /* 0 */
        "simple",       /* 1 */
        "md5",          /* 2 */
};

const struct bits ospf_rla_flag_bits[] = {
        { RLA_FLAG_B,           "B" },
        { RLA_FLAG_E,           "E" },
        { RLA_FLAG_V,           "V" },
        { RLA_FLAG_W,           "W" },
        { 0,                    NULL }
};

const struct bits ospf_db_flags_bits[] = {
        { OSPF_DB_INIT,         "I" },
        { OSPF_DB_MORE,         "M" },
        { OSPF_DB_MASTER,       "MS" },
        { 0,                    NULL }
};

const struct bits ospf_option_bits[] = {
        { OSPF_OPTION_T,        "T" },
        { OSPF_OPTION_E,        "E" },
        { OSPF_OPTION_MC,       "MC" },
        { 0,                    NULL }
};

static int interpret_ospf_hello(int, struct ospfhdr *, int);
static void ospf_print_ls_type(int, uint32_t, struct in_addr, struct in_addr);
static void interpret_ospf_lsa_hdr(int, struct lsa_hdr *);
static int interpret_ospf_lsa(int flags, struct lsa *lsa, uchar_t *);

char *
ospf_print_bits(const struct bits *bp, uchar_t options)
{
        static char bitstring[32];

        bitstring[0] = '\0';
        do {
                if (options & bp->bit) {
                        strcat(bitstring, bp->str);
                        strcat(bitstring, "/");
                }
        } while ((++bp)->bit);

        /* wipe out the trailing "/" */
        bitstring[strlen(bitstring) - 1] = '\0';
        return (bitstring);
}

char *
ospf_print_lsa_age(long age)
{
        long sec, mins, hour;
        static char lsa_age[16];

        sec = age % 60;
        mins = (age / 60) % 60;
        hour = age / 3600;
        if (hour != 0)
                snprintf(lsa_age, sizeof (lsa_age), "%u:%02u:%02u",
                    hour, mins, sec);
        else if (mins != 0)
                snprintf(lsa_age, sizeof (lsa_age), "%u:%02u", mins, sec);
        else
                snprintf(lsa_age, sizeof (lsa_age), "%u", sec);
        return (lsa_age);
}

static int
interpret_ospf_hello(int flags, struct ospfhdr *op, int fraglen)
{
        struct in_addr *nbr;
        int j;

        if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_HELLO_HEADER_SIZE)
                return (-1); /* truncated packet */

        if (flags & F_SUM) {
                if (op->ospf_hello.hello_dr.s_addr != 0) {
                        (void) sprintf(sum_line, "DR=%s ",
                            inet_ntoa(op->ospf_hello.hello_dr));
                }
                sum_line += strlen(sum_line);
                if (op->ospf_hello.hello_bdr.s_addr != 0) {
                        (void) sprintf(sum_line, "BDR=%s ",
                            inet_ntoa(op->ospf_hello.hello_bdr));
                }
                sum_line += strlen(sum_line);
                nbr = op->ospf_hello.hello_neighbor;
                j = 0;
                while ((uchar_t *)nbr < ((uchar_t *)op + fraglen)) {
                        if ((uchar_t *)nbr + sizeof (struct in_addr) >
                            ((uchar_t *)op + fraglen))
                                return (-1); /* truncated */
                        j++;
                        ++nbr;
                }
                (void) sprintf(sum_line, "%d nbrs", j);
                sum_line += strlen(sum_line);

        }
        if (flags & F_DTAIL) {
                show_header("OSPF HELLO:  ", "Hello Packet",
                    ntohs(op->ospf_len));
                show_space();
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Options = %s", ospf_print_bits(ospf_option_bits,
                    op->ospf_hello.hello_options));
                (void) snprintf(get_line(0, 0), get_line_remain(), "Mask = %s",
                    inet_ntoa(op->ospf_hello.hello_mask));
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Hello interval = %d",
                    ntohs(op->ospf_hello.hello_helloint));
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Priority = %d", op->ospf_hello.hello_priority);
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Dead interval = %u", ntohl(op->ospf_hello.hello_deadint));
                if (op->ospf_hello.hello_dr.s_addr != 0) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Designated Router = %s",
                            inet_ntoa(op->ospf_hello.hello_dr));
                }
                if (op->ospf_hello.hello_bdr.s_addr != 0) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Backup Designated Router = %s",
                            inet_ntoa(op->ospf_hello.hello_bdr));
                }
                nbr = op->ospf_hello.hello_neighbor;
                while ((uchar_t *)nbr < ((uchar_t *)op + fraglen)) {
                        if ((uchar_t *)nbr + sizeof (struct in_addr) >
                            ((uchar_t *)op + fraglen))
                                return (-1); /* truncated */
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Neighbor: %s", inet_ntoa(*nbr));
                        ++nbr;
                }
        }
        return (fraglen);
}

static void
ospf_print_ls_type(int flags, uint32_t ls_type, struct in_addr ls_stateid,
    struct in_addr ls_router)
{
        switch (ls_type) {
        case LS_TYPE_ROUTER:
                if (flags & F_SUM) {
                        sprintf(sum_line, " rtr %s ", inet_ntoa(ls_router));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Router LSA; Router = %s ", inet_ntoa(ls_router));
                }
                break;
        case LS_TYPE_NETWORK:
                if (flags & F_SUM) {
                        sprintf(sum_line, " net dr %s ", inet_ntoa(ls_router));
                        sum_line += strlen(sum_line);
                        sprintf(sum_line, "if %s ", inet_ntoa(ls_stateid));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Network LSA Router = %s ", inet_ntoa(ls_router));
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "            Interface = %s ",
                            inet_ntoa(ls_stateid));
                }
                break;
        case LS_TYPE_SUM_IP:
                if (flags & F_SUM) {
                        sprintf(sum_line, " sum %s ", inet_ntoa(ls_stateid));
                        sum_line += strlen(sum_line);
                        sprintf(sum_line, "abr %s ", inet_ntoa(ls_router));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Summary LSA IP = %s ", inet_ntoa(ls_stateid));
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "            Area Border Router = %s ",
                            inet_ntoa(ls_router));
                }
                break;
        case LS_TYPE_SUM_ABR:
                if (flags & F_SUM) {
                        sprintf(sum_line, "abr %s ", inet_ntoa(ls_stateid));
                        sum_line += strlen(sum_line);
                        sprintf(sum_line, "asbr %s ", inet_ntoa(ls_router));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "ASBR Summary abr = %s ", inet_ntoa(ls_stateid));
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "             asbr = %s ", inet_ntoa(ls_router));
                }
                break;
        case LS_TYPE_ASE:
                if (flags & F_SUM) {
                        sprintf(sum_line, " ase %s", inet_ntoa(ls_stateid));
                        sum_line += strlen(sum_line);
                        sprintf(sum_line, " asbr %s", inet_ntoa(ls_router));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "AS External LSA ase = %s ", inet_ntoa(ls_stateid));
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "                asbr = %s ", inet_ntoa(ls_router));
                }

                break;
        case LS_TYPE_GROUP:
                if (flags & F_SUM) {
                        sprintf(sum_line, " group %s", inet_ntoa(ls_stateid));
                        sum_line += strlen(sum_line);
                        sprintf(sum_line, " rtr %s", inet_ntoa(ls_router));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Group LSA %s ", inet_ntoa(ls_stateid));
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "          rtr = %s ", inet_ntoa(ls_router));
                }
                break;
        default:
                if (flags & F_SUM) {
                        sprintf(sum_line, " unknown LSA type %d", ls_type);
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Unknown LSA type %d", ls_type);
                }
                break;
        }
}

static void
interpret_ospf_lsa_hdr(int flags, struct lsa_hdr *lsah)
{
        if (flags & F_SUM)
                return;

        if (flags & F_DTAIL) {
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Options = %s",
                    ospf_print_bits(ospf_option_bits, lsah->ls_options));
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Sequence = %X ", ntohl(lsah->ls_seq));
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Age = %X ", ospf_print_lsa_age(ntohs(lsah->ls_age)));
        }

        ospf_print_ls_type(flags, lsah->ls_type, lsah->ls_stateid,
            lsah->ls_router);

}

#define TRUNC(addr)     ((uchar_t *)(addr) > fragend)
static int
interpret_ospf_lsa(int flags, struct lsa *lsa, uchar_t *fragend)
{
        uchar_t *ls_end;
        int rla_count, k;
        struct rlalink *rl;
        struct tos_metric *tosp;
        struct in_addr *addr;
        uint32_t *tosmetric;
        struct aslametric *am;
        uint32_t tm;
        int tos, metric;

        interpret_ospf_lsa_hdr(flags, &lsa->ls_hdr);

        ls_end = (uchar_t *)lsa + ntohs(lsa->ls_hdr.ls_length);

        if (TRUNC(ls_end))
                return (-1);

        switch (lsa->ls_hdr.ls_type) {

        case LS_TYPE_ROUTER:
                if (TRUNC(&lsa->lsa_un.un_rla.rla_flags))
                        return (-1);

                if (flags & F_DTAIL) {
                        (void) ospf_print_bits(ospf_rla_flag_bits,
                            lsa->lsa_un.un_rla.rla_flags);
                }

                if (TRUNC(&lsa->lsa_un.un_rla.rla_count))
                        return (-1);
                rla_count = ntohs(lsa->lsa_un.un_rla.rla_count);

                rl = lsa->lsa_un.un_rla.rla_link;
                if (TRUNC(rl))
                        return (-1);

                while (rla_count-- != 0) {
                        if (TRUNC((uchar_t *)rl + sizeof (*rl)))
                                return (-1);
                        switch (rl->link_type) {
                        case RLA_TYPE_VIRTUAL:
                                if (flags & F_DTAIL) {
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(), "Virtual Link");
                                }
                                /* fall through */
                        case RLA_TYPE_ROUTER:
                                if (flags & F_DTAIL) {
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(), "Neighbor = %s",
                                            inet_ntoa(rl->link_id));
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(), "Interface = %s",
                                            inet_ntoa(rl->link_data));
                                }
                                break;
                        case RLA_TYPE_TRANSIT:
                                if (flags & F_DTAIL) {
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(),
                                            "Designated Router = %s",
                                            inet_ntoa(rl->link_id));
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(), "Interface = %s",
                                            inet_ntoa(rl->link_data));
                                }
                                break;
                        case RLA_TYPE_STUB:
                                if (flags & F_DTAIL) {
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(), "Network = %s",
                                            inet_ntoa(rl->link_id));
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(), "Mask = %s",
                                            inet_ntoa(rl->link_data));
                                }
                                break;
                        default:
                                if (flags & F_DTAIL) {
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(),
                                            "Unknown link type %d",
                                            rl->link_type);
                                }

                        }
                        if (flags & F_DTAIL) {
                                (void) snprintf(get_line(0, 0),
                                    get_line_remain(), "TOS 0 metric = %d",
                                    ntohs(rl->link_tos0metric));
                        }
                        tosp = (struct tos_metric *)(
                                (uchar_t *)rl + sizeof (rl->link_tos0metric));
                        for (k = 0; k > (int)rl->link_toscount; ++k, ++tosp) {
                                if (TRUNC(tosp))
                                        return (-1);
                                if (flags & F_DTAIL) {
                                        (void) snprintf(get_line(0, 0),
                                            get_line_remain(),
                                            "TOS %d metric = %d",
                                            tosp->tos_type,
                                            ntohs(tosp->tos_metric));
                                }

                        }
                        rl = (struct rlalink *)((uchar_t *)(rl + 1) +
                            ((rl->link_toscount) * sizeof (*tosp)));
                        if (TRUNC(rl))
                                return (-1); /* truncated */
                }
                break;
        case LS_TYPE_NETWORK:

                if (TRUNC(&lsa->lsa_un.un_nla.nla_mask))
                        return (-1);

                if (flags & F_DTAIL) {
                        snprintf(get_line(0, 0), get_line_remain(),
                            "Mask = %s",
                            inet_ntoa(lsa->lsa_un.un_nla.nla_mask));
                        snprintf(get_line(0, 0), get_line_remain(),
                            "Routers:");
                }
                addr = lsa->lsa_un.un_nla.nla_router;
                while ((uchar_t *)addr < ls_end) {
                        if ((uchar_t *)addr + sizeof (struct in_addr) > ls_end)
                                return (-1); /* truncated */
                        if (flags & F_DTAIL) {
                                snprintf(get_line(0, 0), get_line_remain(),
                                    "\t%s", inet_ntoa(*addr));
                        }
                        ++addr;
                }
                break;
        case LS_TYPE_SUM_IP:

                if (TRUNC((uchar_t *)&lsa->lsa_un.un_sla.sla_mask +
                    sizeof (struct in_addr)))
                        return (-1);

                if (flags & F_DTAIL) {
                        snprintf(get_line(0, 0), get_line_remain(), "Mask = %s",
                            inet_ntoa(lsa->lsa_un.un_sla.sla_mask));
                }
                /* FALLTHROUGH */
        case LS_TYPE_SUM_ABR:
                if (TRUNC(&lsa->lsa_un.un_sla.sla_tosmetric))
                        return (-1);
                tosmetric = lsa->lsa_un.un_sla.sla_tosmetric;
                while ((uchar_t *)tosmetric < ls_end) {
                        if ((uchar_t *)tosmetric + sizeof (tm) > fragend)
                                return (-1); /* truncated */
                        tm = ntohl(*tosmetric);
                        tos = (tm & SLA_MASK_TOS) >> SLA_SHIFT_TOS;
                        metric = tm & SLA_MASK_METRIC;
                        if (flags & F_DTAIL) {
                                snprintf(get_line(0, 0), get_line_remain(),
                                    " tos %d metric %d", tos, metric);
                        }
                        ++tosmetric;
                }
                break;
        case LS_TYPE_ASE:
                if (TRUNC(&lsa->lsa_un.un_asla.asla_mask))
                        return (-1);
                if (flags & F_DTAIL) {
                        snprintf(get_line(0, 0), get_line_remain(), "Mask = %s",
                            inet_ntoa(lsa->lsa_un.un_asla.asla_mask));
                }
                am = lsa->lsa_un.un_asla.asla_metric;
                while ((uchar_t *)am < ls_end) {
                        if ((uchar_t *)am + sizeof (tm) > fragend)
                                return (-1); /* truncated */
                        tm = ntohl(am->asla_tosmetric);
                        tos = (tm & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS;
                        metric = tm & ASLA_MASK_METRIC;
                        if (flags & F_DTAIL) {
                                snprintf(get_line(0, 0), get_line_remain(),
                                    " type %d tos %d metric %d",
                                    (tm & ASLA_FLAG_EXTERNAL) ? 2 : 1,
                                    tos, metric);
                        }
                        if (am->asla_forward.s_addr != 0) {
                                if (flags & F_DTAIL)  {
                                        snprintf(get_line(0, 0),
                                            get_line_remain(), " Forward %s",
                                            inet_ntoa(am->asla_forward));
                                }
                        }
                        if (am->asla_tag.s_addr != 0) {
                                if (flags & F_DTAIL)  {
                                        snprintf(get_line(0, 0),
                                            get_line_remain(), " Tag %s",
                                            inet_ntoa(am->asla_tag));
                                }
                        }
                        ++am;
                }
                break;
        default:
                if (flags & F_DTAIL)  {
                        snprintf(get_line(0, 0), get_line_remain(),
                            " Unknown LSA type %d", lsa->ls_hdr.ls_type);

                }
                break;
        }
        return (0);
}
#undef TRUNC

int
interpret_ospf(int flags, struct ospfhdr *ospf, int iplen, int fraglen)
{
        int nlsa, nlsah = 0;
        struct lsa_hdr *lsah;
        struct lsr *lsr;
        struct lsa *lsa;
        boolean_t trunc = B_FALSE;

        if ((fraglen < OSPF_MIN_HEADER_SIZE) ||
            (fraglen < ntohs(ospf->ospf_len)))
                return (fraglen);       /* incomplete header */

        if (fraglen > ntohs(ospf->ospf_len))
                fraglen = ntohs(ospf->ospf_len);


        if (ospf->ospf_type > OSPF_TYPE_MAX) {
                if (flags & F_SUM) {
                        (void) sprintf(sum_line, "Unknown OSPF TYPE %d \n",
                            ospf->ospf_type);
                        sum_line += strlen(sum_line);
                }
                if (flags & F_SUM) {
                        show_header("OSPF:  ", "OSPF Header", fraglen);
                        show_space();
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Unknown OSPF Type = %d", ospf->ospf_type);
                }
                return (fraglen);
        }

        if (flags & F_SUM) {
                sum_line = (char *)get_sum_line();
                (void) sprintf(sum_line, "OSPF %s RTRID=%s ",
                    ospf_types[ospf->ospf_type],
                    inet_ntoa(ospf->ospf_routerid));
                sum_line += strlen(sum_line);
                (void) sprintf(sum_line, "AREA=%s LEN=%d ",
                    inet_ntoa(ospf->ospf_areaid),
                    ntohs((ushort_t)ospf->ospf_len));
                sum_line += strlen(sum_line);
        }

        if (flags & F_DTAIL) {
                show_header("OSPF:  ", "OSPF Header", fraglen);
                show_space();
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Version = %d", ospf->ospf_version);
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Type = %s", ospf_types[ospf->ospf_type]);
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Router ID = %s", inet_ntoa(ospf->ospf_routerid));
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Area ID = %s", inet_ntoa(ospf->ospf_areaid));
                (void) snprintf(get_line(0, 0), get_line_remain(),
                    "Checksum = 0x%x", ospf->ospf_chksum);

                if (ospf->ospf_authtype > OSPF_AUTH_TYPE_MAX) {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Auth = %d (unknown auth type)",
                            ospf->ospf_authtype);
                } else {
                        (void) snprintf(get_line(0, 0), get_line_remain(),
                            "Auth = %s", ospf_authtypes[ospf->ospf_authtype]);
                }
        }

        if (ospf->ospf_version != 2) {
                if (ospf->ospf_version == 3) {
                        if (flags & F_DTAIL)
                                snprintf(get_line(0, 0), get_line_remain(),
                                    "ospfv3 packet in ipv4 header");
                        return (interpret_ospf6(flags, ospf, iplen, fraglen));
                } else  {
                        return (fraglen);
                }
        }

        switch (ospf->ospf_type) {
        case OSPF_TYPE_HELLO:
                if (interpret_ospf_hello(flags, ospf, fraglen) < 0)
                        trunc = B_TRUE;
                break;

        case OSPF_TYPE_DB:
                if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_DB_HEADER_SIZE) {
                        trunc = B_TRUE;
                        break;
                }
                if (flags & F_SUM) {
                        sprintf(sum_line, " %s %s S %X", ospf_print_bits(
                            ospf_option_bits, ospf->ospf_db.db_options),
                            ospf_print_bits(ospf_db_flags_bits,
                            ospf->ospf_db.db_flags),
                            ntohl(ospf->ospf_db.db_seq));
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL) {
                        show_header("OSPF DB:  ", "Database Description Packet",
                            fraglen);
                        show_space();
                        snprintf(get_line(0, 0), get_line_remain(),
                            "Options = %s", ospf_print_bits(
                            ospf_option_bits, ospf->ospf_db.db_options));
                        snprintf(get_line(0, 0), get_line_remain(),
                            "Flags = %s", ospf_print_bits(
                            ospf_db_flags_bits, ospf->ospf_db.db_flags));
                        snprintf(get_line(0, 0), get_line_remain(),
                            "Sequence = 0x%X", ntohl(ospf->ospf_db.db_seq));
                        /*  Print all the LS advs */
                        lsah = ospf->ospf_db.db_lshdr;
                        while ((uchar_t *)lsah < ((uchar_t *)ospf + fraglen)) {
                                if ((uchar_t *)lsah + sizeof (struct lsa_hdr) >
                                    ((uchar_t *)ospf + fraglen)) {
                                        trunc = B_TRUE;
                                        break;
                                }
                                interpret_ospf_lsa_hdr(flags, lsah);
                                ++lsah;
                        }
                }
                break;

        case OSPF_TYPE_LSR:
                if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_LSR_HEADER_SIZE) {
                        trunc = B_TRUE;
                        break;
                }
                if (flags & F_DTAIL) {
                        snprintf(get_line(0, 0), get_line_remain(),
                            "Link State Request Packet");
                }
                lsr = ospf->ospf_lsr;
                while ((uchar_t *)lsr < ((uchar_t *)ospf + fraglen)) {
                        if ((uchar_t *)lsr + sizeof (struct lsr) >
                            ((uchar_t *)ospf + fraglen)) {
                                trunc = B_TRUE;
                                break;
                        }
                        if (flags & F_SUM) {
                                nlsah++;
                        }
                        if (flags & F_DTAIL) {
                                ospf_print_ls_type(flags, ntohl(lsr->ls_type),
                                    lsr->ls_stateid, lsr->ls_router);
                        }
                        ++lsr;
                }
                if (flags & F_SUM) {
                        sprintf(sum_line, " %d LSAs", nlsah);
                        sum_line += strlen(sum_line);
                }
                break;

        case OSPF_TYPE_LSU:
                if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_LSU_HEADER_SIZE) {
                        trunc = B_TRUE;
                        break;
                }
                if (flags & F_DTAIL) {
                        show_header("OSPF LSU:  ", "Link State Update Packet",
                            fraglen);
                        show_space();
                }
                lsa = ospf->ospf_lsu.lsu_lsa;
                nlsa = ntohl(ospf->ospf_lsu.lsu_count);
                if (flags & F_SUM) {
                        sprintf(sum_line, "%d LSAs", nlsa);
                        sum_line += strlen(sum_line);
                        break;
                }
                while (nlsa-- != 0) {
                        uchar_t *fragend = (uchar_t *)ospf + fraglen;
                        if (((uchar_t *)lsa >= fragend) ||
                            ((uchar_t *)lsa + sizeof (struct lsa_hdr) >
                            fragend) ||
                            ((uchar_t *)lsa + ntohs(lsa->ls_hdr.ls_length) >
                            fragend)) {
                                trunc = B_TRUE;
                                break;
                        }

                        if (interpret_ospf_lsa(flags, lsa, fragend) < 0) {
                                trunc = B_TRUE;
                                break;
                        }
                        lsa = (struct lsa *)((uchar_t *)lsa +
                            ntohs(lsa->ls_hdr.ls_length));
                }

                break;

        case OSPF_TYPE_LSA:
                if (flags & F_DTAIL) {
                        show_header("OSPF LSA:  ", "Link State Ack Packet",
                            fraglen);
                        show_space();
                }
                lsah = ospf->ospf_lsa.lsa_lshdr;
                nlsah = 0;
                while ((uchar_t *)lsah < ((uchar_t *)ospf + fraglen)) {
                        if ((uchar_t *)lsah + sizeof (struct lsa_hdr) >
                            ((uchar_t *)ospf + fraglen)) {
                                trunc = B_TRUE;
                                break;
                        }
                        nlsah++;
                        if (flags & F_DTAIL)
                                interpret_ospf_lsa_hdr(flags, lsah);
                        ++lsah;
                }
                if (flags & F_SUM) {
                        sprintf(sum_line, "%d LSAs", nlsah);
                        sum_line += strlen(sum_line);
                }
                break;

        default:
                /* NOTREACHED */
                break;
        }
        if (trunc) {
                if (flags & F_SUM) {
                        sprintf(sum_line, "--truncated");
                        sum_line += strlen(sum_line);
                }
                if (flags & F_DTAIL)
                        snprintf(get_line(0, 0), get_line_remain(),
                            "--truncated");
        }

        return (fraglen);
}