/*
 * 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 (c) 2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sysmacros.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/pppoe.h>
#include "snoop.h"

/*
 * These two macros extract the version and type fields respectively from
 * the first byte of the PPPoE header.
 */
#define POE_VERS(x)     (((x) >> 4) & 0x0f)
#define POE_TYPE(x)     ((x) & 0x0f)

typedef void interpret_func_t(uint8_t *, uint16_t);

typedef struct taginfo {
        char *tag_name;
        uint16_t tag_type;
        interpret_func_t *interpret_tagvalue;
} taginfo_t;


static char *pppoe_codetoname(int, boolean_t);
static taginfo_t *pppoe_gettaginfo(uint16_t);
static void print_hexdata(char *, uint8_t *, uint16_t);
static void print_utf8string(char *, char *, uint16_t);
static char *print_linetag(char *);
static interpret_func_t interpret_tags;
static interpret_func_t interpret_hexdata;
static interpret_func_t interpret_service;
static interpret_func_t interpret_access;
static interpret_func_t interpret_cookie;
static interpret_func_t interpret_vendor;
static interpret_func_t interpret_relay;
static interpret_func_t interpret_error;
static interpret_func_t interpret_hurl;
static interpret_func_t interpret_motm;
static interpret_func_t interpret_rteadd;


static taginfo_t taginfo_array[] = {
        { "End-Of-List",        POETT_END,      interpret_hexdata },
        { "Service-Name",       POETT_SERVICE,  interpret_service },
        { "AC-Name",            POETT_ACCESS,   interpret_access },
        { "Host-Uniq",          POETT_UNIQ,     interpret_hexdata },
        { "AC-Cookie",          POETT_COOKIE,   interpret_cookie },
        { "Vendor-Specific",    POETT_VENDOR,   interpret_vendor },
        { "Relay-Session-Id",   POETT_RELAY,    interpret_relay },
        { "Service-Name-Error", POETT_NAMERR,   interpret_error },
        { "AC-System-Error",    POETT_SYSERR,   interpret_error },
        { "Generic-Error",      POETT_GENERR,   interpret_error },
        { "Multicast-Capable",  POETT_MULTI,    interpret_hexdata },
        { "Host-URL",           POETT_HURL,     interpret_hurl },
        { "Message-Of-The-Minute", POETT_MOTM,  interpret_motm },
        { "IP-Route-Add",       POETT_RTEADD,   interpret_rteadd },
        { "Unknown TAG",        0,              NULL }
};


int
interpret_pppoe(int flags, poep_t *poep, int len)
{
        uint8_t code = poep->poep_code;
        uint8_t *payload;

        if (len < sizeof (poep_t))
                return (len);

        payload = (uint8_t *)poep + sizeof (poep_t);

        if (flags & F_SUM) {
                (void) sprintf(get_sum_line(), "PPPoE %s",
                    pppoe_codetoname(code, B_FALSE));
        } else { /* flags & F_DTAIL */
                show_header("PPPoE:  ", "PPP Over Ethernet", len);
                show_space();

                (void) sprintf(get_line(0, 0),
                    "Version = %d", POE_VERS(poep->poep_version_type));

                (void) sprintf(get_line(0, 0),
                    "Type = %d", POE_TYPE(poep->poep_version_type));

                (void) sprintf(get_line(0, 0),
                    "Code = %d (%s)", code, pppoe_codetoname(code, B_TRUE));

                (void) sprintf(get_line(0, 0),
                    "Session Id = %d", ntohs(poep->poep_session_id));

                (void) sprintf(get_line(0, 0),
                    "Length = %d bytes", ntohs(poep->poep_length));

                show_space();

                len -= sizeof (poep_t);
                len = MIN(len, ntohs(poep->poep_length));

                if (poep->poep_code != 0 && poep->poep_length > 0) {
                        interpret_tags(payload, len);
                }
        }

        if (poep->poep_code == 0) {
                return (interpret_ppp(flags, payload, len));
        }
        return (len);
}


/*
 * interpret_tags() prints PPPoE Discovery Stage TAGs in detail.
 */
static void
interpret_tags(uint8_t *payload, uint16_t length)
{
        uint8_t *tagptr = payload;
        uint16_t tag_length;
        uint16_t tag_type;
        uint8_t *tag_value;
        taginfo_t *tinfo;

        while (length >= POET_HDRLEN) {
                tag_type = POET_GET_TYPE(tagptr);
                tag_length = POET_GET_LENG(tagptr);

                tinfo = pppoe_gettaginfo(tag_type);

                show_header("PPPoE:  ", tinfo->tag_name,
                    tag_length + POET_HDRLEN);

                (void) sprintf(get_line(0, 0),
                    "Tag Type = %d", tag_type);

                (void) sprintf(get_line(0, 0),
                    "Tag Length = %d bytes", tag_length);

                length -= POET_HDRLEN;
                if (tag_length > length) {
                        (void) sprintf(get_line(0, 0),
                            "Warning: Truncated Packet");
                        show_space();
                        break;
                }

                /*
                 * unknown tags or tags which should always have 0 length
                 * are not interpreted any further.
                 */
                tag_value = POET_DATA(tagptr);
                if (tag_length != 0 && tinfo->interpret_tagvalue != NULL)
                        tinfo->interpret_tagvalue(tag_value, tag_length);

                show_space();
                length -= tag_length;
                tagptr = POET_NEXT(tagptr);
        }
}

static char *
pppoe_codetoname(int code, boolean_t verbose)
{
        char *name;

        switch (code) {
        case POECODE_DATA:
                name = "Session";
                break;
        case POECODE_PADO:
                if (verbose)
                        name = "Active Discovery Offer";
                else
                        name = "PADO";
                break;
        case POECODE_PADI:
                if (verbose)
                        name = "Active Discovery Initiation";
                else
                        name = "PADI";
                break;
        case POECODE_PADR:
                if (verbose)
                        name = "Active Discovery Request";
                else
                        name = "PADR";
                break;
        case POECODE_PADS:
                if (verbose)
                        name = "Active Discovery Session-Confirmation";
                else
                        name = "PADS";
                break;
        case POECODE_PADT:
                if (verbose)
                        name = "Active Discovery Terminate";
                else
                        name = "PADT";
                break;
        case POECODE_PADM:
                if (verbose)
                        name = "Active Discovery Message";
                else
                        name = "PADM";
                break;
        case POECODE_PADN:
                if (verbose)
                        name = "Active Discovery Network";
                else
                        name = "PADN";
                break;
        default:
                name = "Unknown Code";
        }

        return (name);
}

static taginfo_t *
pppoe_gettaginfo(uint16_t type)
{
        taginfo_t *taginfo_ptr = &taginfo_array[0];
        int i = 0;

        while (taginfo_ptr->tag_type != type &&
            taginfo_ptr->interpret_tagvalue != NULL) {
                taginfo_ptr = &taginfo_array[++i];
        }

        return (taginfo_ptr);
}

static void
interpret_hexdata(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("Data = ");
        print_hexdata(endofline, tag_value, tag_length);
}

static void
interpret_service(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("Service Name = ");
        print_utf8string(endofline, (char *)tag_value, tag_length);
}

static void
interpret_access(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("AC Name = ");
        print_utf8string(endofline, (char *)tag_value, tag_length);
}

static void
interpret_cookie(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("Cookie = ");
        print_hexdata(endofline, tag_value, tag_length);
}

static void
interpret_vendor(uint8_t *tag_value, uint16_t tag_length)
{
        uint8_t *vendor_data;
        uint32_t vendorid;
        char *endofline;

        vendorid = ntohl(*(uint32_t *)tag_value);
        (void) sprintf(get_line(0, 0),
            "Vendor ID = %d", vendorid);

        if (tag_length > 4) {
                vendor_data = tag_value + 4;
                endofline = print_linetag("Vendor Data = ");
                print_hexdata(endofline, vendor_data, tag_length - 4);
        }
}

static void
interpret_relay(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("ID = ");
        print_hexdata(endofline, tag_value, tag_length);
}

static void
interpret_error(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("Error = ");
        print_utf8string(endofline, (char *)tag_value, tag_length);
}

static void
interpret_hurl(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("URL = ");
        print_utf8string(endofline, (char *)tag_value, tag_length);
}

static void
interpret_motm(uint8_t *tag_value, uint16_t tag_length)
{
        char *endofline;

        endofline = print_linetag("Message = ");
        print_utf8string(endofline, (char *)tag_value, tag_length);
}

static void
interpret_rteadd(uint8_t *tag_value, uint16_t tag_length)
{
        char dest[INET_ADDRSTRLEN];
        char mask[INET_ADDRSTRLEN];
        char gateway[INET_ADDRSTRLEN];
        uint32_t metric;

        if (tag_length == 16) {
                (void) inet_ntop(AF_INET, tag_value, dest,
                    INET_ADDRSTRLEN);
                (void) inet_ntop(AF_INET, &tag_value[4], mask,
                    INET_ADDRSTRLEN);
                (void) inet_ntop(AF_INET, &tag_value[8], gateway,
                    INET_ADDRSTRLEN);
                metric = ntohl(*(uint32_t *)&tag_value[12]);
                sprintf(get_line(0, 0),
                    "Destination\tNetmask\tGateway\tMetric");
                sprintf(get_line(0, 0),
                    "%s\t%s\t%s\t%d", dest, mask, gateway, metric);
        }
}

static void
print_hexdata(char *line, uint8_t *data, uint16_t length)
{
        uint16_t index = 0;

        line += sprintf(line, "0x");

        while (index < length) {
                line += sprintf(line, "%02x", data[index++]);
        }
}

static void
print_utf8string(char *firstline, char *string, uint16_t length)
{
        (void) sprintf(firstline, "%.*s", length, string);
}

static char *
print_linetag(char *string)
{
        char *line = get_line(0, 0);
        return (line + sprintf(line, string));
}