/*
 * Copyright (c) 2008-2016 Solarflare Communications Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of the FreeBSD Project.
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/strsubr.h>
#include <sys/pattr.h>

#include <sys/ethernet.h>
#include <inet/ip.h>

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

#include "sfxge.h"

#include "efx.h"


/*
 * Parse packet headers and return:
 *	etherhpp	Ethernet MAC header
 *	iphpp		IPv4 header (NULL for non-IPv4 packet)
 *	thpp		TCP header (NULL for non-TCP packet)
 *	offp		Offset to TCP payload
 *	sizep		Size of TCP payload
 *	dportp		TCP/UDP/SCTP dest. port (network order), otherwise zero
 *	sportp		TCP/UDP/SCTP source port, (network order) otherwise zero
 */
sfxge_packet_type_t
sfxge_pkthdr_parse(mblk_t *mp, struct ether_header **etherhpp,
    struct ip **iphpp, struct tcphdr **thpp,
    size_t *offp, size_t *sizep,
    uint16_t *sportp, uint16_t *dportp)
{
	struct ether_header *etherhp;
	uint16_t ether_type;
	size_t etherhs;
	struct ip *iphp;
	size_t iphs;
	struct tcphdr *thp;
	size_t len;
	size_t ths;
	size_t off;
	size_t size;
	uint16_t sport;
	uint16_t dport;
	sfxge_packet_type_t pkt_type = SFXGE_PACKET_TYPE_UNKNOWN;

	etherhp = NULL;
	iphp = NULL;
	thp = NULL;
	off = 0;
	size = 0;
	sport = 0;
	dport = 0;

	/* Grab the MAC header */
	etherhs = sizeof (struct ether_header);
	if ((MBLKL(mp) < etherhs) && (pullupmsg(mp, etherhs) == 0))
		goto done;

	/*LINTED*/
	etherhp = (struct ether_header *)(mp->b_rptr);
	ether_type = etherhp->ether_type;

	if (ether_type == htons(ETHERTYPE_VLAN)) {
		struct ether_vlan_header *ethervhp;

		etherhs = sizeof (struct ether_vlan_header);
		if ((MBLKL(mp) < etherhs) && (pullupmsg(mp, etherhs) == 0))
			goto done;

		/*LINTED*/
		ethervhp = (struct ether_vlan_header *)(mp->b_rptr);
		ether_type = ethervhp->ether_type;
	}

	if (ether_type != htons(ETHERTYPE_IP))
		goto done;

	/* Skip over the MAC header */
	off += etherhs;

	/* Grab the IP header */
	len = off + sizeof (struct ip);
	if ((MBLKL(mp) < len) && (pullupmsg(mp, len) == 0))
		goto done;

	/*LINTED*/
	iphp = (struct ip *)(mp->b_rptr + off);
	iphs = iphp->ip_hl * 4;

	if (iphp->ip_v != IPV4_VERSION)
		goto done;

	/* Get the size of the packet */
	size = ntohs(iphp->ip_len);

	ASSERT3U(etherhs + size, <=, msgdsize(mp));

	pkt_type = SFXGE_PACKET_TYPE_IPV4_OTHER;

	/* Skip over the IP header */
	off += iphs;
	size -= iphs;

	if (iphp->ip_p == IPPROTO_TCP) {
		/* Grab the TCP header */
		len = off + sizeof (struct tcphdr);
		if ((MBLKL(mp) < len) && (pullupmsg(mp, len) == 0))
			goto done;

		/*LINTED*/
		thp = (struct tcphdr *)(mp->b_rptr + off);
		ths = thp->th_off * 4;

		dport = thp->th_dport;
		sport = thp->th_sport;

		/* Skip over the TCP header */
		off += ths;
		size -= ths;

		pkt_type = SFXGE_PACKET_TYPE_IPV4_TCP;

	} else if (iphp->ip_p == IPPROTO_UDP) {
		struct udphdr *uhp;

		/* Grab the UDP header */
		len = off + sizeof (struct udphdr);
		if ((MBLKL(mp) < len) && (pullupmsg(mp, len) == 0))
			goto done;

		/*LINTED*/
		uhp = (struct udphdr *)(mp->b_rptr + off);
		dport = uhp->uh_dport;
		sport = uhp->uh_sport;

		/* Skip over the UDP header */
		off += sizeof (struct udphdr);
		size -= sizeof (struct udphdr);

		pkt_type = SFXGE_PACKET_TYPE_IPV4_UDP;

	} else if (iphp->ip_p == IPPROTO_SCTP) {
		struct sctp_hdr *shp;

		/* Grab the SCTP header */
		len = off + sizeof (struct sctp_hdr);
		if ((MBLKL(mp) < len) && (pullupmsg(mp, len) == 0))
			goto done;

		/*LINTED*/
		shp = (struct sctp_hdr *)(mp->b_rptr + off);
		dport = shp->sh_dport;
		sport = shp->sh_sport;

		/* Skip over the SCTP header */
		off += sizeof (struct sctp_hdr);
		size -= sizeof (struct sctp_hdr);

		pkt_type = SFXGE_PACKET_TYPE_IPV4_SCTP;
	}

	if (MBLKL(mp) < off)
		(void) pullupmsg(mp, off);

done:
	*etherhpp = etherhp;
	*iphpp = iphp;
	*thpp = thp;
	*offp = off;
	*sizep = size;
	*sportp = sport;
	*dportp = dport;

	return (pkt_type);
}