/*

 *  $Id: libnet_link_pf.c,v 1.3 2004/01/03 20:31:02 mike Exp $

 *

 *  libnet

 *  libnet_pf.c - pf routines

 *

 *  Copyright (c) 1998 - 2004 Mike D. Schiffman <mike@infonexus.com>

 *  All rights reserved.

 *

 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996

 *	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.

 *

 * packet filter subroutines for tcpdump

 *	Extraction/creation by Jeffrey Mogul, DECWRL

 */

#if (HAVE_CONFIG_H)

#include "../include/config.h"

#endif

#include "../include/low_libnet.h"

#include "../include/gnuc.h"

#ifdef HAVE_OS_PROTO_H

#include "../include/os-proto.h"

#endif

struct libnet_link_int *

libnet_open_link_interface(int8_t *device, int8_t *ebuf)

{

    register struct libnet_link_int *l;

    int16_t enmode;

    int backlog = -1;   /* request the most */

    struct enfilter Filter;

    struct endevp devparams;

    l = (struct libnet_link_int *)malloc(sizeof(*l));

    if (l == NULL)

    {

        sprintf(ebuf, "libnet_open_link_int: %s", strerror(errno));

        return (0);

    }

    memset(l, 0, sizeof(*l));

    l->fd = pfopen(device, O_RDWR);

    if (l->fd < 0)

    {

        sprintf(ebuf, "pf open: %s: %s\n\your system may not be properly configured; see \"man packetfilter(4)\"\n",

            device, strerror(errno));

        goto bad;

    }

    enmode = ENTSTAMP|ENBATCH|ENNONEXCL;

    if (ioctl(l->fd, EIOCMBIS, (caddr_t)&enmode) < 0)

    {

        sprintf(ebuf, "EIOCMBIS: %s", strerror(errno));

        goto bad;

    }

#ifdef	ENCOPYALL

    /* Try to set COPYALL mode so that we see packets to ourself */

    enmode = ENCOPYALL;

    ioctl(l->fd, EIOCMBIS, (caddr_t)&enmode);   /* OK if this fails */

#endif

	/* set the backlog */

    if (ioctl(l->fd, EIOCSETW, (caddr_t)&backlog) < 0)

    {

        sprintf(ebuf, "EIOCSETW: %s", strerror(errno));

        goto bad;

    }

    /*

     *  discover interface type

     */

    if (ioctl(l->fd, EIOCDEVP, (caddr_t)&devparams) < 0)

    {

        sprintf(ebuf, "EIOCDEVP: %s", strerror(errno));

        goto bad;

    }

    /* HACK: to compile prior to Ultrix 4.2 */

#ifndef	ENDT_FDDI

#define	ENDT_FDDI   4

#endif

    switch (devparams.end_dev_type)

    {

        case ENDT_10MB:

            l->linktype = DLT_EN10MB;

            break;

        case ENDT_FDDI:

            l->linktype = DLT_FDDI;

            break;

        default:

            /*

             * XXX

             * Currently, the Ultrix packet filter supports only

             * Ethernet and FDDI.  Eventually, support for SLIP and PPP

             * (and possibly others: T1?) should be added.

             */

            l->linktype = DLT_EN10MB;

            break;

	}

    /*

     *  acceptag all packets

     */

    bzero((int8_t *)&Filter, sizeof(Filter));

    Filter.enf_Priority = 37;	/* anything > 2 */

    Filter.enf_FilterLen = 0;	/* means "always true" */

    if (ioctl(l->fd, EIOCSETF, (caddr_t)&Filter) < 0)

    {

        sprintf(ebuf, "EIOCSETF: %s", strerror(errno));

        goto bad;

    }

    return (l);

bad:

    free(l);

    return (NULL);

}

int

libnet_close_link_interface(struct libnet_link_int *l)

{

    if (close(l->fd) == 0)

    {

        free(l);

        return (1);

    }

    else

    {

        free(l);

        return (-1);

    }

}

int

libnet_write_link_layer(struct libnet_link_int *l, const int8_t *device,

            const uint8_t *buf, int len)

{

    int c;

    c = write(l->fd, buf, len);

    if (c != len)

    {

        snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,

            "libnet_write_link: %d bytes written (%s)\n", c,

            strerror(errno));

    }

    return (c);

}