Version bump.

[unet] / unet.h

/* -*-c-*-
 *
 * $Id: unet.h,v 1.2 2001/02/19 19:10:28 mdw Exp $
 *
 * User-space network device support.
 *
 * (c) 1998 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Usernet.
 *
 * Usernet is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Usernet is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Usernet; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: unet.h,v $
 * Revision 1.2  2001/02/19 19:10:28  mdw
 * New option to allow changing interface flags.
 *
 * Revision 1.1  2001/01/25 22:03:39  mdw
 * Initial check-in (somewhat belated).
 *
 */

#ifndef _LINUX_UNET_H
#define _LINUX_UNET_H

#ifdef __cplusplus
  extern "C" {
#endif

/*----- What's the story? -------------------------------------------------*
 *
 * Based on a conversation with Clive Jones about FreeBSD's tunnel device,
 * I've decided to try to write something similar.  The basic idea is to
 * tie together a character device and a network interface, so that anything
 * written to one pops out the other.  I create a device /dev/unet.
 * Each open(2) of my device creates a network device, whose name can be
 * read by calling ioctl(2).  A read(2) on the device fetches the next
 * packet received from the network interface; conversely, a write(2) sends
 * a network packet through the interface.
 *
 * Permissions on /dev/unet ought to be fairly strict.  Remember that
 * anyone who can get access to it can inject arbitrary IP packets.
 *
 * This is my first stab at hacking Linux, so there'll be mistakes and
 * infelicities.  All I ask is that you tell me what they are.
 *
 *						[mdw]
 *						mdw@excessus.demon.co.uk
 */

/*----- @ioctl@(2) calls supported ----------------------------------------*/

/* --- @UNIOCGINFO@ --- *
 *
 * Reads useful information about a unet.  The argument is a pointer to a
 * @unet_info@ structure, which is filled in by the call.  As a special case,
 * the argument may be a null pointer, in which case the call does nothing
 * and may be used to verify that a file descriptor refers to a Usernet
 * attachment.
 */

#define UNIOCGINFO _IOR('U', 0, sizeof(struct unet_info))

#define UNET_NAMEMAX 20

struct unet_info {
  char uni_ifname[UNET_NAMEMAX];	/* Interface name string */
  unsigned short uni_mtu;		/* Maximum transmission unit */
  unsigned short uni_family;		/* My address family */
  unsigned short uni_proto;		/* Protocol to stamp on packets */
  unsigned int uni_flags;		/* Various useful flags */
};

#define UNIF_TRANS 1			/* This device is transient */
#define UNIF_OPEN 2			/* Not useful to users */
#define UNIF_DEBUG 4			/* Debugging enable flag */

/* --- @UNIOCSDEBUG@ --- *
 *
 * Sets the debugging state for the attachment.  When the debug flag is set,
 * all packets sent and received by the device will be logged, as will other
 * events.
 */

#define UNIOCSDEBUG _IO('U', 1)

/* --- @UNIOCGPROTO@ --- *
 *
 * Reads the protocol stamped on packets received through the character
 * device interface.  The default is @ETH_P_IP@; the various values are
 * defined in @<linux/if_ether.h>@.
 */

#define UNIOCGPROTO _IO('U', 2)

/* --- @UNIOCSPROTO@ --- *
 *
 * Sets the protocol to be stamped on outgoing packets.
 */

#define UNIOCSPROTO _IO('U', 3)

/* --- @UNIOCGGDEBUG@ --- *
 *
 * Gets the global debugging flag.
 */

#define UNIOCGGDEBUG _IO('U', 4)

/* --- @UNIOCSGDEBUG@ --- *
 *
 * Sets the global debugging flag.  This is only available when runtime
 * debugging configuration is compiled in.
 */

#define UNIOCSGDEBUG _IO('U', 5)

/* --- @UNIOCDUMP@ --- *
 *
 * Dumps a unet block's information to the debug device.
 */

#define UNIOCDUMP _IO('U', 6)

/* --- @UNIOCGMAXIF@ --- *
 *
 * Returns the maximum number of interfaces allowed.
 */

#define UNIOCGMAXIF _IO('U', 7)

/* --- @UNIOCGMAXIF@ --- *
 *
 * Sets the maximum number of interfaces allowed.  It's an error to lower
 * this below the number of the highest currently-used interface.
 */

#define UNIOCSMAXIF _IO('U', 8)

/* --- @UNIOCGIFFLAGS@ --- *
 *
 * Gets interface flags.  To complement @UNIOCSIFFLAGS@.
 */

#define UNIOCGIFFLAGS _IO('U', 9)

/* --- @UNIOCSIFFLAGS@ --- *
 *
 * Sets interface flags.  This is required because there's no other sensible
 * way to (e.g.) change the point-to-point flag.
 */

#define UNIOCSIFFLAGS _IO('U', 10)

/*----- That's all, folks -------------------------------------------------*/

#ifdef __cplusplus
  }
#endif

#endif