/*      $OpenBSD: print-ip6.c,v 1.30 2020/01/24 22:46:37 procter Exp $  */

/*
 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994
 *      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.
 */

#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <netinet/tcp.h>

#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "interface.h"
#include "addrtoname.h"

#include <netinet/ip6.h>

/*
 * print an IP6 datagram.
 */
void
ip6_print(const u_char *bp, u_int length)
{
        const struct ip6_hdr *ip6;
        int hlen;
        int len;
        const u_char *cp;
        const u_char *pktp = packetp;
        const u_char *send = snapend;
        int nh;
        u_int flow;

        ip6 = (const struct ip6_hdr *)bp;
        if ((u_char *)(ip6 + 1) > snapend) {
                printf("[|ip6]");
                return;
        }

        /*
         * The IP header is not word aligned, so copy into abuf.
         * This will never happen with BPF.  It does happen with
         * raw packet dumps from -r.
         */
        if ((intptr_t)ip6 & (sizeof(u_int32_t)-1)) {
                static u_char *abuf = NULL;
                static int didwarn = 0;
                int clen = snapend - bp;
                if (clen > snaplen)
                        clen = snaplen;

                if (abuf == NULL) {
                        abuf = malloc(snaplen);
                        if (abuf == NULL)
                                error("ip6_print: malloc");
                }
                memmove((char *)abuf, (char *)ip6, min(length, clen));
                snapend = abuf + clen;
                packetp = bp = abuf;
                ip6 = (struct ip6_hdr *)abuf;
                /* We really want libpcap to give us aligned packets */
                if (!didwarn) {
                        warning("compensating for unaligned libpcap packets");
                        ++didwarn;
                }
        }

        if (length < sizeof (struct ip6_hdr)) {
                printf("truncated-ip6 %d", length);
                goto out;
        }
        if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {
                printf("bad-ip6-version %u", ip6->ip6_vfc >> 4);
                goto out;
        }
        hlen = sizeof(struct ip6_hdr);

        len = ntohs(ip6->ip6_plen);
        if (length < len + hlen)
                printf("truncated-ip6 - %d bytes missing!",
                    len + hlen - length);

        cp = (const u_char *)ip6;
        nh = ip6->ip6_nxt;
        while (cp + hlen <= snapend) {
                cp += hlen;

#ifndef IPPROTO_IPV4
#define IPPROTO_IPV4    4
#endif
                if (cp == (u_char *)(ip6 + 1) &&
                    nh != IPPROTO_TCP && nh != IPPROTO_UDP &&
                    nh != IPPROTO_AH &&
                    (vflag || (nh != IPPROTO_IPV4 && nh != IPPROTO_IPV6))) {
                        printf("%s > %s: ", ip6addr_string(&ip6->ip6_src),
                            ip6addr_string(&ip6->ip6_dst));
                }

                switch (nh) {
                case IPPROTO_HOPOPTS:
                        hlen = hbhopt_print(cp);
                        nh = *cp;
                        break;
                case IPPROTO_DSTOPTS:
                        hlen = dstopt_print(cp);
                        nh = *cp;
                        break;
                case IPPROTO_FRAGMENT:
                        hlen = frag6_print(cp, (const u_char *)ip6);
                        if (snapend < cp + hlen)
                                goto end;
                        nh = *cp;
                        break;
                case IPPROTO_ROUTING:
                        hlen = rt6_print(cp, (const u_char *)ip6);
                        nh = *cp;
                        break;
                case IPPROTO_TCP:
                        tcp_print(cp, len + sizeof(struct ip6_hdr) - (cp - bp),
                                (const u_char *)ip6);
                        goto end;
                case IPPROTO_UDP:
                        udp_print(cp, len + sizeof(struct ip6_hdr) - (cp - bp),
                                (const u_char *)ip6);
                        goto end;
                case IPPROTO_ESP:
                        esp_print(cp, len + sizeof(struct ip6_hdr) - (cp - bp),
                                (const u_char *)ip6);
                        goto end;
                case IPPROTO_AH:
                        ah_print(cp, len + sizeof(struct ip6_hdr) - (cp - bp),
                                (const u_char *)ip6);
                        goto end;
                case IPPROTO_ICMPV6:
                        icmp6_print(cp, len + sizeof(struct ip6_hdr) - (cp - bp),
                                (const u_char *)ip6);
                        goto end;
                case IPPROTO_PIM:
                        printf("PIM");
                        pim_print(cp, len);
                        goto end;
#ifndef IPPROTO_OSPF
#define IPPROTO_OSPF 89
#endif
                case IPPROTO_OSPF:
                        ospf6_print(cp, len);
                        goto end;
                case IPPROTO_IPV6:
                        ip6_print(cp, len);
                        if (! vflag)
                                printf(" (encap)");
                        goto end;
                case IPPROTO_IPV4:
                        ip_print(cp, len);
                        if (! vflag)
                                printf(" (encap)");
                        goto end;

#ifndef IPPROTO_GRE
#define IPPROTO_GRE 47
#endif
                case IPPROTO_GRE:
                        gre_print(cp, len);
                        goto end;

                case IPPROTO_NONE:
                        printf("no next header");
                        goto end;

#ifndef IPPROTO_ETHERIP
#define IPPROTO_ETHERIP 97
#endif
                case IPPROTO_ETHERIP:
                        etherip_print(cp, snapend - cp, len);
                        goto end;

#ifndef IPPROTO_CARP  
#define IPPROTO_CARP 112
#endif
                case IPPROTO_CARP:
                        if (packettype == PT_VRRP)
                                vrrp_print(cp, len, ip6->ip6_hlim);
                        else
                                carp_print(cp, len, ip6->ip6_hlim);
                        break;

                default:
                        printf("ip-proto-%d %d", ip6->ip6_nxt, len);
                        goto end;
                }
                if (hlen == 0)
                        break;
        }

 end:

        flow = ntohl(ip6->ip6_flow);
        if (flow & 0x0ff00000)
                printf(" [class 0x%x]", (flow & 0x0ff00000) >> 20);
        if (flow & 0x000fffff)
                printf(" [flowlabel 0x%x]", flow & 0x000fffff);

        if (ip6->ip6_hlim <= 1)
                printf(" [hlim %d]", (int)ip6->ip6_hlim);

        if (vflag) {
                printf(" (");
                printf("len %d", len);
                if (ip6->ip6_hlim > 1)
                        printf(", hlim %d", (int)ip6->ip6_hlim);
                printf(")");
        }

 out:
        packetp = pktp;
        snapend = send;
}