OpenCores
URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /or1k_old/trunk/rc203soc/sw/uClinux/include/net
    from Rev 1765 to Rev 1782
    ↔ Reverse comparison
  •

Rev 1765 → Rev 1782

/udp.h
0,0 → 1,63
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the UDP module.
*
* Version: @(#)udp.h 1.0.2 05/07/93
*
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* Fixes:
* Alan Cox : Turned on udp checksums. I don't want to
* chase 'memory corruption' bugs that aren't!
*
* This program 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.
*/
#ifndef _UDP_H
#define _UDP_H
 
#include <linux/udp.h>
 
#define UDP_HTABLE_SIZE 128
 
/* udp.c: This needs to be shared by v4 and v6 because the lookup
* and hashing code needs to work with different AF's yet
* the port space is shared.
*/
extern struct sock *udp_hash[UDP_HTABLE_SIZE];
 
extern unsigned short udp_good_socknum(void);
 
#define UDP_NO_CHECK 0
 
 
extern struct proto udp_prot;
 
 
extern void udp_err(int type, int code, unsigned char *header, __u32 daddr,
__u32 saddr, struct inet_protocol *protocol, int len);
extern void udp_send_check(struct udphdr *uh, __u32 saddr,
__u32 daddr, int len, struct sock *sk);
extern int udp_recvfrom(struct sock *sk, unsigned char *to,
int len, int noblock, unsigned flags,
struct sockaddr_in *sin, int *addr_len);
extern int udp_read(struct sock *sk, unsigned char *buff,
int len, int noblock, unsigned flags);
extern int udp_connect(struct sock *sk,
struct sockaddr_in *usin, int addr_len);
extern int udp_rcv(struct sk_buff *skb, struct device *dev,
struct options *opt, __u32 daddr,
unsigned short len, __u32 saddr, int redo,
struct inet_protocol *protocol);
extern int udp_ioctl(struct sock *sk, int cmd, unsigned long arg);
 
/* CONFIG_IP_TRANSPARENT_PROXY */
extern int udp_chkaddr(struct sk_buff *skb);
 
#endif /* _UDP_H */
/raw.h
0,0 → 1,44
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the RAW-IP module.
*
* Version: @(#)raw.h 1.0.2 05/07/93
*
* Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* This program 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.
*/
#ifndef _RAW_H
#define _RAW_H
 
 
extern struct proto raw_prot;
 
 
extern void raw_err(int type, int code, unsigned char *header, __u32 daddr,
__u32 saddr, struct inet_protocol *protocol);
extern int raw_recvfrom(struct sock *sk, unsigned char *to,
int len, int noblock, unsigned flags,
struct sockaddr_in *sin, int *addr_len);
extern int raw_read(struct sock *sk, unsigned char *buff,
int len, int noblock, unsigned flags);
extern int raw_rcv(struct sock *, struct sk_buff *, struct device *,
__u32, __u32);
 
/* Note: v4 ICMP wants to get at this stuff, if you change the
* hashing mechanism, make sure you update icmp.c as well.
*/
#define RAWV4_HTABLE_SIZE MAX_INET_PROTOS
extern struct sock *raw_v4_htable[RAWV4_HTABLE_SIZE];
 
 
extern struct sock *raw_v4_lookup(struct sock *sk, unsigned short num,
unsigned long raddr, unsigned long laddr);
 
#endif /* _RAW_H */
/af_unix.h
0,0 → 1,14
#ifndef __LINUX_NET_AFUNIX_H
#define __LINUX_NET_AFUNIX_H
extern void unix_proto_init(struct net_proto *pro);
extern struct proto_ops unix_proto_ops;
extern void unix_inflight(struct file *fp);
extern void unix_notinflight(struct file *fp);
typedef struct sock unix_socket;
extern void unix_gc(void);
 
extern unix_socket *unix_socket_list;
 
#define UNIX_MAX_FD 8
 
#endif
/gc.h
0,0 → 1,46
/*
* Interface routines assumed by gc()
*
* Copyright (C) Barak A. Pearlmutter.
* Released under the GPL version 2 or later.
*
*/
 
typedef struct object *pobj; /* pointer to a guy of the type we gc */
 
/*
* How to mark and unmark objects
*/
 
extern void gc_mark(pobj);
extern void gc_unmark(pobj);
extern int gc_marked(pobj);
 
/*
* How to count and access an object's children
*/
 
extern int n_children(pobj); /* how many children */
extern pobj child_n(pobj, int); /* child i, numbered 0..n-1 */
 
/*
* How to access the root set
*/
 
extern int root_size(void); /* number of things in root set */
extern pobj root_elt(int); /* element i of root set, numbered 0..n-1 */
 
/*
* How to access the free list
*/
 
extern void clear_freelist(void);
extern void add_to_free_list(pobj);
 
/*
* How to iterate through all objects in memory
*/
 
extern int N_OBJS;
extern pobj obj_number(int);
 
/ip_masq.h
0,0 → 1,212
/*
* IP masquerading functionality definitions
*/
 
#ifndef _IP_MASQ_H
#define _IP_MASQ_H
 
#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/config.h>
 
/*
* This define affects the number of ports that can be handled
* by each of the protocol helper modules.
*/
#define MAX_MASQ_APP_PORTS 12
 
/*
* Linux ports don't normally get allocated above 32K.
* I used an extra 4K port-space
*/
 
#define PORT_MASQ_BEGIN 61000
#define PORT_MASQ_END (PORT_MASQ_BEGIN+4096)
 
/*
* Default timeouts for masquerade functions The control channels now
* expire the same as TCP channels (other than being updated by
* packets on their associated data channels.
*/
#define MASQUERADE_EXPIRE_TCP 15*60*HZ
#define MASQUERADE_EXPIRE_TCP_FIN 2*60*HZ
#define MASQUERADE_EXPIRE_UDP 5*60*HZ
/*
* ICMP can no longer be modified on the fly using an ioctl - this
* define is the only way to change the timeouts
*/
#define MASQUERADE_EXPIRE_ICMP 125*HZ
 
#define IP_AUTOFW_EXPIRE 15*HZ
 
#define IP_MASQ_F_OUT_SEQ 0x01 /* must do output seq adjust */
#define IP_MASQ_F_IN_SEQ 0x02 /* must do input seq adjust */
#define IP_MASQ_F_NO_DPORT 0x04 /* no dport set yet */
#define IP_MASQ_F_NO_DADDR 0x08 /* no daddr yet */
#define IP_MASQ_F_HASHED 0x10 /* hashed entry */
#define IP_MASQ_F_SAW_RST 0x20 /* tcp rst pkt seen */
#define IP_MASQ_F_SAW_FIN_IN 0x40 /* tcp fin pkt seen incoming */
#define IP_MASQ_F_SAW_FIN_OUT 0x80 /* tcp fin pkt seen outgoing */
#define IP_MASQ_F_SAW_FIN (IP_MASQ_F_SAW_FIN_IN | \
IP_MASQ_F_SAW_FIN_OUT)
/* tcp fin pkts seen */
#define IP_MASQ_F_CONTROL 0x100 /* this is a control channel */
#define IP_MASQ_F_NO_SPORT 0x200 /* no sport set yet */
#define IP_MASQ_F_FTP_PASV 0x400 /* ftp PASV command just issued */
#define IP_MASQ_F_NO_REPLY 0x800 /* no reply yet from outside */
#define IP_MASQ_F_AFW_PORT 0x1000
 
#ifdef __KERNEL__
 
/*
* Delta seq. info structure
* Each MASQ struct has 2 (output AND input seq. changes).
*/
 
struct ip_masq_seq {
__u32 init_seq; /* Add delta from this seq */
short delta; /* Delta in sequence numbers */
short previous_delta; /* Delta in sequence numbers before last resized pkt */
};
 
/*
* MASQ structure allocated for each masqueraded association
*/
struct ip_masq {
struct ip_masq *m_link, *s_link; /* hashed link ptrs */
struct timer_list timer; /* Expiration timer */
__u16 protocol; /* Which protocol are we talking? */
__u16 sport, dport, mport; /* src, dst & masq ports */
__u32 saddr, daddr, maddr; /* src, dst & masq addresses */
struct ip_masq_seq out_seq, in_seq;
struct ip_masq_app *app; /* bound ip_masq_app object */
void *app_data; /* Application private data */
unsigned flags; /* status flags */
struct ip_masq *control; /* Corresponding control connection */
#ifdef CONFIG_IP_MASQUERADE_IPSEC
struct ip_masq *d_link; /* hashed link ptr */
__u32 ospi, ispi; /* outbound and inbound SPI keys for IPSEC */
/* also the icookie for ISAKMP masquerade */
short ocnt; /* counter of inits sent - limit blocking */
short blocking; /* if we're blocking another host */
#endif /* CONFIG_IP_MASQUERADE_IPSEC */
};
 
/*
* timeout values
*/
 
struct ip_fw_masq {
int tcp_timeout;
int tcp_fin_timeout;
int udp_timeout;
};
 
extern struct ip_fw_masq *ip_masq_expire;
 
/*
* [0]: UDP free_ports
* [1]: TCP free_ports
* [2]: ICMP free ids
*/
 
extern int ip_masq_free_ports[3];
 
/*
* ip_masq initializer (registers symbols and /proc/net entries)
*/
extern int ip_masq_init(void);
 
/*
* functions called from ip layer
*/
extern int ip_fw_masquerade(struct sk_buff **, struct device *);
extern int ip_fw_masq_icmp(struct sk_buff **, struct device *);
extern int ip_fw_demasquerade(struct sk_buff **, struct device *);
 
/*
* ip_masq obj creation/deletion functions.
*/
extern struct ip_masq *ip_masq_new(struct device *dev, int proto, __u32 saddr, __u16 sport, __u32 daddr, __u16 dport, unsigned flags);
extern void ip_masq_set_expire(struct ip_masq *ms, unsigned long tout);
 
#ifdef CONFIG_IP_MASQUERADE_IPAUTOFW
extern void ip_autofw_expire(unsigned long data);
#endif
 
/*
*
* IP_MASQ_APP: IP application masquerading definitions
*
*/
 
struct ip_masq_app
{
struct ip_masq_app *next;
char *name; /* name of application proxy */
unsigned type; /* type = proto<<16 | port (host byte order)*/
int n_attach;
int (*masq_init_1) /* ip_masq initializer */
(struct ip_masq_app *, struct ip_masq *);
int (*masq_done_1) /* ip_masq fin. */
(struct ip_masq_app *, struct ip_masq *);
int (*pkt_out) /* output (masquerading) hook */
(struct ip_masq_app *, struct ip_masq *, struct sk_buff **, struct device *);
int (*pkt_in) /* input (demasq) hook */
(struct ip_masq_app *, struct ip_masq *, struct sk_buff **, struct device *);
};
 
/*
* ip_masq_app initializer
*/
extern int ip_masq_app_init(void);
 
/*
* ip_masq_app object registration functions (port: host byte order)
*/
extern int register_ip_masq_app(struct ip_masq_app *mapp, unsigned short proto, __u16 port);
extern int unregister_ip_masq_app(struct ip_masq_app *mapp);
 
/*
* get ip_masq_app obj by proto,port(net_byte_order)
*/
extern struct ip_masq_app * ip_masq_app_get(unsigned short proto, __u16 port);
 
/*
* ip_masq TO ip_masq_app (un)binding functions.
*/
extern struct ip_masq_app * ip_masq_bind_app(struct ip_masq *ms);
extern int ip_masq_unbind_app(struct ip_masq *ms);
 
/*
* output and input app. masquerading hooks.
*
*/
extern int ip_masq_app_pkt_out(struct ip_masq *, struct sk_buff **skb_p, struct device *dev);
extern int ip_masq_app_pkt_in(struct ip_masq *, struct sk_buff **skb_p, struct device *dev);
 
/*
* service routine(s).
*/
extern struct ip_masq * ip_masq_out_get_2(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port);
extern struct ip_masq * ip_masq_in_get_2(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port);
 
/*
* /proc/net entry
*/
extern int ip_masq_app_getinfo(char *buffer, char **start, off_t offset, int length, int dummy);
 
/*
* skb_replace function used by "client" modules to replace
* a segment of skb.
*/
extern struct sk_buff * ip_masq_skb_replace(struct sk_buff *skb, int pri, char *o_buf, int o_len, char *n_buf, int n_len);
 
#ifdef CONFIG_IP_MASQUERADE_IPAUTOFW
extern struct ip_autofw * ip_autofw_hosts;
#endif /* CONFIG_IP_MASQUERADE_IPAUTOFW */
 
#endif /* __KERNEL__ */
 
#endif /* _IP_MASQ_H */
/ip_forward.h
0,0 → 1,11
#ifndef __NET_IP_FORWARD_H
#define __NET_IP_FORWARD_H
 
#define IPFWD_FRAGMENT 1
#define IPFWD_LASTFRAG 2
#define IPFWD_MASQUERADED 4
#define IPFWD_MULTICASTING 8
#define IPFWD_MULTITUNNEL 0x10
#define IPFWD_NOTTLDEC 0x20
 
#endif
/if.h
0,0 → 1,166
/* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
 
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
 
The GNU C Library 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
Library General Public License for more details.
 
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
 
#ifndef _NET_IF_H
 
#define _NET_IF_H 1
#include <features.h>
 
#include <sys/types.h>
#include <sys/socket.h>
 
/* Standard interface flags. */
enum
{
IFF_UP = 0x1, /* Interface is up. */
#define IFF_UP IFF_UP
IFF_BROADCAST = 0x2, /* Broadcast address valid. */
#define IFF_BROADCAST IFF_BROADCAST
IFF_DEBUG = 0x4, /* Turn on debugging. */
#define IFF_DEBUG IFF_DEBUG
IFF_LOOPBACK = 0x8, /* Is a loopback net. */
#define IFF_LOOPBACK IFF_LOOPBACK
IFF_POINTOPOINT = 0x10, /* Interface is point-to-point link. */
#define IFF_POINTOPOINT IFF_POINTOPOINT
IFF_NOTRAILERS = 0x20, /* Avoid use of trailers. */
#define IFF_NOTRAILERS IFF_NOTRAILERS
IFF_RUNNING = 0x40, /* Resources allocated. */
#define IFF_RUNNING IFF_RUNNING
IFF_NOARP = 0x80, /* No address resolution protocol. */
#define IFF_NOARP IFF_NOARP
IFF_PROMISC = 0x100, /* Receive all packets. */
#define IFF_PROMISC IFF_PROMISC
 
/* Not supported */
IFF_ALLMULTI = 0x200, /* Receive all multicast packets. */
#define IFF_ALLMULTI IFF_ALLMULTI
 
IFF_MASTER = 0x400, /* Master of a load balancer. */
#define IFF_MASTER IFF_MASTER
IFF_SLAVE = 0x800, /* Slave of a load balancer. */
#define IFF_SLAVE IFF_SLAVE
 
IFF_MULTICAST = 0x1000, /* Supports multicast. */
#define IFF_MULTICAST IFF_MULTICAST
 
IFF_PORTSEL = 0x2000, /* Can set media type. */
#define IFF_PORTSEL IFF_PORTSEL
IFF_AUTOMEDIA = 0x4000 /* Auto media select active. */
#define IFF_AUTOMEDIA IFF_AUTOMEDIA
};
 
/* The ifaddr structure contains information about one address of an
interface. They are maintained by the different address families,
are allocated and attached when an address is set, and are linked
together so all addresses for an interface can be located. */
 
struct ifaddr
{
struct sockaddr ifa_addr; /* Address of interface. */
union
{
struct sockaddr ifu_broadaddr;
struct sockaddr ifu_dstaddr;
} ifa_ifu;
struct iface *ifa_ifp; /* Back-pointer to interface. */
struct ifaddr *ifa_next; /* Next address for interface. */
};
 
#define ifa_broadaddr ifa_ifu.ifu_broadaddr /* broadcast address */
#define ifa_dstaddr ifa_ifu.ifu_dstaddr /* other end of link */
 
/* Device mapping structure. I'd just gone off and designed a
beautiful scheme using only loadable modules with arguments for
driver options and along come the PCMCIA people 8)
 
Ah well. The get() side of this is good for WDSETUP, and it'll be
handy for debugging things. The set side is fine for now and being
very small might be worth keeping for clean configuration. */
 
struct ifmap
{
unsigned long int mem_start;
unsigned long int mem_end;
unsigned short int base_addr;
unsigned char irq;
unsigned char dma;
unsigned char port;
/* 3 bytes spare */
};
 
/* Interface request structure used for socket ioctl's. All interface
ioctl's must have parameter definitions which begin with ifr_name.
The remainder may be interface specific. */
 
struct ifreq
{
#define IFHWADDRLEN 6
#define IFNAMSIZ 16
union
{
char ifrn_name[IFNAMSIZ]; /* Interface name, e.g. "en0". */
} ifr_ifrn;
 
union
{
struct sockaddr ifru_addr;
struct sockaddr ifru_dstaddr;
struct sockaddr ifru_broadaddr;
struct sockaddr ifru_netmask;
struct sockaddr ifru_hwaddr;
short int ifru_flags;
int ifru_ivalue;
int ifru_mtu;
struct ifmap ifru_map;
char ifru_slave[IFNAMSIZ]; /* Just fits the size */
__caddr_t ifru_data;
} ifr_ifru;
};
 
#define ifr_name ifr_ifrn.ifrn_name /* interface name */
#define ifr_hwaddr ifr_ifru.ifru_hwaddr /* MAC address */
#define ifr_addr ifr_ifru.ifru_addr /* address */
#define ifr_dstaddr ifr_ifru.ifru_dstaddr /* other end of p-p lnk */
#define ifr_broadaddr ifr_ifru.ifru_broadaddr /* broadcast address */
#define ifr_netmask ifr_ifru.ifru_netmask /* interface net mask */
#define ifr_flags ifr_ifru.ifru_flags /* flags */
#define ifr_metric ifr_ifru.ifru_ivalue /* metric */
#define ifr_mtu ifr_ifru.ifru_mtu /* mtu */
#define ifr_map ifr_ifru.ifru_map /* device map */
#define ifr_slave ifr_ifru.ifru_slave /* slave device */
#define ifr_data ifr_ifru.ifru_data /* for use by interface */
#define ifr_ifindex ifr_ifru.ifru_ivalue /* interface index */
 
 
/* Structure used in SIOCGIFCONF request. Used to retrieve interface
configuration for machine (useful for programs which must know all
networks accessible). */
 
struct ifconf
{
int ifc_len; /* Size of buffer. */
union
{
__caddr_t ifcu_buf;
struct ifreq *ifcu_req;
} ifc_ifcu;
};
#define ifc_buf ifc_ifcu.ifcu_buf /* Buffer address. */
#define ifc_req ifc_ifcu.ifcu_req /* Array of structures. */
 
#endif /* net/if.h */
/sock.h
0,0 → 1,613
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the AF_INET socket handler.
*
* Version: @(#)sock.h 1.0.4 05/13/93
*
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Corey Minyard <wf-rch!minyard@relay.EU.net>
* Florian La Roche <flla@stud.uni-sb.de>
*
* Fixes:
* Alan Cox : Volatiles in skbuff pointers. See
* skbuff comments. May be overdone,
* better to prove they can be removed
* than the reverse.
* Alan Cox : Added a zapped field for tcp to note
* a socket is reset and must stay shut up
* Alan Cox : New fields for options
* Pauline Middelink : identd support
* Alan Cox : Eliminate low level recv/recvfrom
* David S. Miller : New socket lookup architecture for ISS.
* Elliot Poger : New field for SO_BINDTODEVICE option.
*
* This program 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.
*/
#ifndef _SOCK_H
#define _SOCK_H
 
#include <linux/timer.h>
#include <linux/ip.h> /* struct options */
#include <linux/in.h> /* struct sockaddr_in */
#include <linux/tcp.h> /* struct tcphdr */
#include <linux/config.h>
 
#include <linux/netdevice.h>
#include <linux/skbuff.h> /* struct sk_buff */
#include <net/protocol.h> /* struct inet_protocol */
#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
#include <net/ax25.h>
#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
#include <net/netrom.h>
#endif
#if defined(CONFIG_ROSE) || defined(CONFIG_ROSE_MODULE)
#include <net/rose.h>
#endif
#endif
 
#if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE)
#include <net/ipx.h>
#endif
 
#if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
#include <linux/atalk.h>
#endif
 
#include <linux/igmp.h>
 
#include <asm/atomic.h>
 
/*
* The AF_UNIX specific socket options
*/
struct unix_opt
{
int family;
char * name;
int locks;
struct inode * inode;
struct semaphore readsem;
struct sock * other;
int marksweep;
#define MARKED 1
int inflight;
};
 
/*
* IP packet socket options
*/
 
struct inet_packet_opt
{
struct notifier_block notifier; /* Used when bound */
struct device *bound_dev;
unsigned long dev_stamp;
struct packet_type *prot_hook;
char device_name[15];
};
 
/*
* Once the IPX ncpd patches are in these are going into protinfo
*/
 
#if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE)
struct ipx_opt
{
ipx_address dest_addr;
ipx_interface *intrfc;
unsigned short port;
#ifdef CONFIG_IPX_INTERN
unsigned char node[IPX_NODE_LEN];
#endif
unsigned short type;
/*
* To handle asynchronous messages from the NetWare server, we have to
* know the connection this socket belongs to.
*/
struct ncp_server *ncp_server;
/*
* To handle special ncp connection-handling sockets for mars_nwe,
* the connection number must be stored in the socket.
*/
unsigned short ipx_ncp_conn;
};
#endif
 
#ifdef CONFIG_NUTCP
struct tcp_opt
{
/*
* RFC793 variables by their proper names. This means you can
* read the code and the spec side by side (and laugh ...)
* See RFC793 and RFC1122. The RFC writes these in capitals.
*/
__u32 rcv_nxt; /* What we want to receive next */
__u32 rcv_up; /* The urgent point (may not be valid) */
__u32 rcv_wnd; /* Current receiver window */
__u32 snd_nxt; /* Next sequence we send */
__u32 snd_una; /* First byte we want an ack for */
__u32 snd_up; /* Outgoing urgent pointer */
__u32 snd_wl1; /* Sequence for window update */
__u32 snd_wl2; /* Ack sequence for update */
/*
* Slow start and congestion control (see also Nagle, and Karn & Partridge)
*/
__u32 snd_cwnd; /* Sending congestion window */
__u32 snd_ssthresh; /* Slow start size threshold */
/*
* Timers used by the TCP protocol layer
*/
struct timer_list delack_timer; /* Ack delay */
struct timer_list idle_timer; /* Idle watch */
struct timer_list completion_timer; /* Up/Down timer */
struct timer_list probe_timer; /* Probes */
struct timer_list retransmit_timer; /* Resend (no ack) */
};
#endif
/*
* This structure really needs to be cleaned up.
* Most of it is for TCP, and not used by any of
* the other protocols.
*/
struct sock
{
/* This must be first. */
struct sock *sklist_next;
struct sock *sklist_prev;
 
struct options *opt;
atomic_t wmem_alloc;
atomic_t rmem_alloc;
unsigned long allocation; /* Allocation mode */
__u32 write_seq;
__u32 sent_seq;
__u32 acked_seq;
__u32 copied_seq;
__u32 rcv_ack_seq;
unsigned short rcv_ack_cnt; /* count of same ack */
__u32 window_seq;
__u32 fin_seq;
__u32 urg_seq;
__u32 urg_data;
__u32 syn_seq;
int users; /* user count */
/*
* Not all are volatile, but some are, so we
* might as well say they all are.
*/
volatile char dead,
urginline,
intr,
blog,
done,
reuse,
keepopen,
linger,
delay_acks,
destroy,
ack_timed,
no_check,
zapped, /* In ax25 & ipx means not linked */
broadcast,
nonagle,
bsdism;
struct device * bound_device;
unsigned long lingertime;
int proc;
 
struct sock *next;
struct sock **pprev;
struct sock *bind_next;
struct sock **bind_pprev;
struct sock *pair;
int hashent;
struct sock *prev;
struct sk_buff * volatile send_head;
struct sk_buff * volatile send_next;
struct sk_buff * volatile send_tail;
struct sk_buff_head back_log;
struct sk_buff *partial;
struct timer_list partial_timer;
long retransmits;
struct sk_buff_head write_queue,
receive_queue;
struct proto *prot;
struct wait_queue **sleep;
__u32 daddr;
__u32 saddr; /* Sending source */
__u32 rcv_saddr; /* Bound address */
unsigned short max_unacked;
unsigned short window;
__u32 lastwin_seq; /* sequence number when we last updated the window we offer */
__u32 high_seq; /* sequence number when we did current fast retransmit */
volatile unsigned long ato; /* ack timeout */
volatile unsigned long lrcvtime; /* jiffies at last data rcv */
volatile unsigned long idletime; /* jiffies at last rcv */
unsigned int bytes_rcv;
/*
* mss is min(mtu, max_window)
*/
unsigned short mtu; /* mss negotiated in the syn's */
volatile unsigned short mss; /* current eff. mss - can change */
volatile unsigned short user_mss; /* mss requested by user in ioctl */
volatile unsigned short max_window;
unsigned long window_clamp;
unsigned int ssthresh;
unsigned short num;
volatile unsigned short cong_window;
volatile unsigned short cong_count;
volatile unsigned short packets_out;
volatile unsigned short shutdown;
volatile unsigned long rtt;
volatile unsigned long mdev;
volatile unsigned long rto;
 
/*
* currently backoff isn't used, but I'm maintaining it in case
* we want to go back to a backoff formula that needs it
*/
volatile unsigned short backoff;
int err, err_soft; /* Soft holds errors that don't
cause failure but are the cause
of a persistent failure not just
'timed out' */
unsigned char protocol;
volatile unsigned char state;
unsigned short ack_backlog;
unsigned char priority;
unsigned char debug;
int rcvbuf;
int sndbuf;
unsigned short type;
unsigned char localroute; /* Route locally only */
/*
* This is where all the private (optional) areas that don't
* overlap will eventually live.
*/
 
union
{
struct unix_opt af_unix;
#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
ax25_cb *ax25;
#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
nr_cb *nr;
#endif
#if defined(CONFIG_ROSE) || defined(CONFIG_ROSE_MODULE)
rose_cb *rose;
#endif
#endif
#if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
struct atalk_sock af_at;
#endif
#if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE)
struct ipx_opt af_ipx;
#endif
#ifdef CONFIG_INET
struct inet_packet_opt af_packet;
#ifdef CONFIG_NUTCP
struct tcp_opt af_tcp;
#endif
#endif
} protinfo;
 
/*
* IP 'private area' or will be eventually
*/
int ip_ttl; /* TTL setting */
int ip_tos; /* TOS */
struct tcphdr dummy_th;
struct timer_list keepalive_timer; /* TCP keepalive hack */
struct timer_list retransmit_timer; /* TCP retransmit timer */
struct timer_list delack_timer; /* TCP delayed ack timer */
int ip_xmit_timeout; /* Why the timeout is running */
struct rtable *ip_route_cache; /* Cached output route */
unsigned char ip_hdrincl; /* Include headers ? */
#ifdef CONFIG_IP_MULTICAST
int ip_mc_ttl; /* Multicasting TTL */
int ip_mc_loop; /* Loopback */
char ip_mc_name[MAX_ADDR_LEN];/* Multicast device name */
struct ip_mc_socklist *ip_mc_list; /* Group array */
#endif
 
/*
* This part is used for the timeout functions (timer.c).
*/
int timeout; /* What are we waiting for? */
struct timer_list timer; /* This is the TIME_WAIT/receive timer
* when we are doing IP
*/
struct timeval stamp;
 
/*
* Identd
*/
struct socket *socket;
/*
* Callbacks
*/
void (*state_change)(struct sock *sk);
void (*data_ready)(struct sock *sk,int bytes);
void (*write_space)(struct sock *sk);
void (*error_report)(struct sock *sk);
 
/*
* Moved solely for 2.0 to keep binary module compatibility stuff straight.
*/
unsigned short max_ack_backlog;
struct sock *listening;
};
 
/*
* IP protocol blocks we attach to sockets.
*/
struct proto
{
/* These must be first. */
struct sock *sklist_next;
struct sock *sklist_prev;
 
void (*close)(struct sock *sk, unsigned long timeout);
int (*build_header)(struct sk_buff *skb,
__u32 saddr,
__u32 daddr,
struct device **dev, int type,
struct options *opt, int len,
int tos, int ttl, struct rtable ** rp);
int (*connect)(struct sock *sk,
struct sockaddr_in *usin, int addr_len);
struct sock * (*accept) (struct sock *sk, int flags);
void (*queue_xmit)(struct sock *sk,
struct device *dev, struct sk_buff *skb,
int free);
void (*retransmit)(struct sock *sk, int all);
void (*write_wakeup)(struct sock *sk);
void (*read_wakeup)(struct sock *sk);
int (*rcv)(struct sk_buff *buff, struct device *dev,
struct options *opt, __u32 daddr,
unsigned short len, __u32 saddr,
int redo, struct inet_protocol *protocol);
int (*select)(struct sock *sk, int which,
select_table *wait);
int (*ioctl)(struct sock *sk, int cmd,
unsigned long arg);
int (*init)(struct sock *sk);
void (*shutdown)(struct sock *sk, int how);
int (*setsockopt)(struct sock *sk, int level, int optname,
char *optval, int optlen);
int (*getsockopt)(struct sock *sk, int level, int optname,
char *optval, int *option);
int (*sendmsg)(struct sock *sk, struct msghdr *msg, int len,
int noblock, int flags);
int (*recvmsg)(struct sock *sk, struct msghdr *msg, int len,
int noblock, int flags, int *addr_len);
int (*bind)(struct sock *sk, struct sockaddr *uaddr, int addr_len);
 
/* Keeping track of sk's, looking them up, and port selection methods. */
void (*hash)(struct sock *sk);
void (*unhash)(struct sock *sk);
void (*rehash)(struct sock *sk);
unsigned short (*good_socknum)(void);
int (*verify_bind)(struct sock *sk, unsigned short snum);
 
unsigned short max_header;
unsigned long retransmits;
char name[32];
int inuse, highestinuse;
};
 
#define TIME_WRITE 1
#define TIME_CLOSE 2
#define TIME_KEEPOPEN 3
#define TIME_DESTROY 4
#define TIME_DONE 5 /* Used to absorb those last few packets */
#define TIME_PROBE0 6
 
/*
* About 10 seconds
*/
 
#define SOCK_DESTROY_TIME (10*HZ)
 
/*
* Sockets 0-1023 can't be bound to unless you are superuser
*/
#define PROT_SOCK 1024
 
#define SHUTDOWN_MASK 3
#define RCV_SHUTDOWN 1
#define SEND_SHUTDOWN 2
 
/* Per-protocol hash table implementations use this to make sure
* nothing changes.
*/
#define SOCKHASH_LOCK() start_bh_atomic()
#define SOCKHASH_UNLOCK() end_bh_atomic()
 
/* Some things in the kernel just want to get at a protocols
* entire socket list commensurate, thus...
*/
static __inline__ void add_to_prot_sklist(struct sock *sk)
{
SOCKHASH_LOCK();
if(!sk->sklist_next) {
struct proto *p = sk->prot;
 
sk->sklist_prev = (struct sock *) p;
sk->sklist_next = p->sklist_next;
p->sklist_next->sklist_prev = sk;
p->sklist_next = sk;
 
/* Charge the protocol. */
sk->prot->inuse += 1;
if(sk->prot->highestinuse < sk->prot->inuse)
sk->prot->highestinuse = sk->prot->inuse;
}
SOCKHASH_UNLOCK();
}
 
static __inline__ void del_from_prot_sklist(struct sock *sk)
{
SOCKHASH_LOCK();
if(sk->sklist_next) {
sk->sklist_next->sklist_prev = sk->sklist_prev;
sk->sklist_prev->sklist_next = sk->sklist_next;
sk->sklist_next = NULL;
sk->prot->inuse--;
}
SOCKHASH_UNLOCK();
}
 
/*
* Used by processes to "lock" a socket state, so that
* interrupts and bottom half handlers won't change it
* from under us. It essentially blocks any incoming
* packets, so that we won't get any new data or any
* packets that change the state of the socket.
*
* Note the 'barrier()' calls: gcc may not move a lock
* "downwards" or a unlock "upwards" when optimizing.
*/
extern void __release_sock(struct sock *sk);
 
static inline void lock_sock(struct sock *sk)
{
#if 0
/* debugging code: the test isn't even 100% correct, but it can catch bugs */
/* Note that a double lock is ok in theory - it's just _usually_ a bug */
if (sk->users) {
__label__ here;
printk("double lock on socket at %p\n", &&here);
here:
}
#endif
sk->users++;
barrier();
}
 
static inline void release_sock(struct sock *sk)
{
barrier();
#if 0
/* debugging code: remove me when ok */
if (sk->users == 0) {
__label__ here;
sk->users = 1;
printk("trying to unlock unlocked socket at %p\n", &&here);
here:
}
#endif
if ((sk->users = sk->users-1) == 0)
__release_sock(sk);
}
 
 
extern struct sock * sk_alloc(int priority);
extern void sk_free(struct sock *sk);
extern void destroy_sock(struct sock *sk);
 
extern struct sk_buff *sock_wmalloc(struct sock *sk,
unsigned long size, int force,
int priority);
extern struct sk_buff *sock_rmalloc(struct sock *sk,
unsigned long size, int force,
int priority);
extern void sock_wfree(struct sock *sk,
struct sk_buff *skb);
extern void sock_rfree(struct sock *sk,
struct sk_buff *skb);
extern unsigned long sock_rspace(struct sock *sk);
extern unsigned long sock_wspace(struct sock *sk);
 
extern int sock_setsockopt(struct sock *sk, int level,
int op, char *optval,
int optlen);
 
extern int sock_getsockopt(struct sock *sk, int level,
int op, char *optval,
int *optlen);
extern struct sk_buff *sock_alloc_send_skb(struct sock *skb,
unsigned long size,
unsigned long fallback,
int noblock,
int *errcode);
 
/*
* Queue a received datagram if it will fit. Stream and sequenced
* protocols can't normally use this as they need to fit buffers in
* and play with them.
*
* Inlined as it's very short and called for pretty much every
* packet ever received.
*/
 
extern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
if (sk->rmem_alloc + skb->truesize >= sk->rcvbuf)
return -ENOMEM;
atomic_add(skb->truesize, &sk->rmem_alloc);
skb->sk=sk;
skb_queue_tail(&sk->receive_queue,skb);
if (!sk->dead)
sk->data_ready(sk,skb->len);
return 0;
}
 
extern __inline__ int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
if (sk->rmem_alloc + skb->truesize >= sk->rcvbuf)
return -ENOMEM;
atomic_add(skb->truesize, &sk->rmem_alloc);
skb->sk=sk;
__skb_queue_tail(&sk->receive_queue,skb);
if (!sk->dead)
sk->data_ready(sk,skb->len);
return 0;
}
 
/*
* Recover an error report and clear atomically
*/
extern __inline__ int sock_error(struct sock *sk)
{
int err=xchg(&sk->err,0);
return -err;
}
 
/*
* Declarations from timer.c
*/
extern struct sock *timer_base;
 
extern void delete_timer (struct sock *);
extern void reset_timer (struct sock *, int, unsigned long);
extern void net_timer (unsigned long);
 
 
/*
* Enable debug/info messages
*/
 
#define NETDEBUG(x) do { } while (0)
 
#endif /* _SOCK_H */
/ipip.h
0,0 → 1,4
extern int ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
__u32 daddr, unsigned short len, __u32 saddr,
int redo, struct inet_protocol *protocol);
/rarp.h
0,0 → 1,12
/* linux/net/inet/rarp.h */
#ifndef _RARP_H
#define _RARP_H
 
extern int rarp_ioctl(unsigned int cmd, void *arg);
extern int rarp_get_info(char *buffer,
char **start,
off_t offset,
int length,
int dummy);
#endif /* _RARP_H */
 
/netrom.h
0,0 → 1,166
/*
* Declarations of NET/ROM type objects.
*
* Jonathan Naylor G4KLX 9/4/95
*/
 
#ifndef _NETROM_H
#define _NETROM_H
#include <linux/netrom.h>
 
#define NR_SLOWHZ 10 /* Run timing at 1/10 second */
 
#define NR_NETWORK_LEN 15
#define NR_TRANSPORT_LEN 5
 
#define NR_PROTO_IP 0x0C
 
#define NR_PROTOEXT 0x00
#define NR_CONNREQ 0x01
#define NR_CONNACK 0x02
#define NR_DISCREQ 0x03
#define NR_DISCACK 0x04
#define NR_INFO 0x05
#define NR_INFOACK 0x06
 
#define NR_CHOKE_FLAG 0x80
#define NR_NAK_FLAG 0x40
#define NR_MORE_FLAG 0x20
 
/* Define Link State constants. */
 
#define NR_STATE_0 0
#define NR_STATE_1 1
#define NR_STATE_2 2
#define NR_STATE_3 3
 
#define NR_COND_ACK_PENDING 0x01
#define NR_COND_REJECT 0x02
#define NR_COND_PEER_RX_BUSY 0x04
#define NR_COND_OWN_RX_BUSY 0x08
 
#define NR_DEFAULT_T1 (120 * NR_SLOWHZ) /* Outstanding frames - 120 seconds */
#define NR_DEFAULT_T2 (5 * NR_SLOWHZ) /* Response delay - 5 seconds */
#define NR_DEFAULT_N2 3 /* Number of Retries - 3 */
#define NR_DEFAULT_T4 (180 * NR_SLOWHZ) /* Busy Delay - 180 seconds */
#define NR_DEFAULT_WINDOW 4 /* Default Window Size - 4 */
#define NR_DEFAULT_OBS 6 /* Default Obsolescence Count - 6 */
#define NR_DEFAULT_QUAL 10 /* Default Neighbour Quality - 10 */
#define NR_DEFAULT_TTL 16 /* Default Time To Live - 16 */
#define NR_DEFAULT_ROUTING 1 /* Is routing enabled ? */
#define NR_DEFAULT_FAILS 2 /* Link fails until route fails */
 
#define NR_MODULUS 256
#define NR_MAX_WINDOW_SIZE 127 /* Maximum Window Allowable - 127 */
#define NR_MAX_PACKET_SIZE 236 /* Maximum Packet Length - 236 */
 
typedef struct {
ax25_address user_addr, source_addr, dest_addr;
struct device *device;
unsigned char my_index, my_id;
unsigned char your_index, your_id;
unsigned char state, condition, bpqext, window;
unsigned short vs, vr, va, vl;
unsigned char n2, n2count;
unsigned short t1, t2, t4;
unsigned short t1timer, t2timer, t4timer;
unsigned short fraglen;
struct sk_buff_head ack_queue;
struct sk_buff_head reseq_queue;
struct sk_buff_head frag_queue;
struct sock *sk; /* Backlink to socket */
} nr_cb;
 
struct nr_neigh {
struct nr_neigh *next;
ax25_address callsign;
ax25_digi *digipeat;
ax25_cb *ax25;
struct device *dev;
unsigned char quality;
unsigned char locked;
unsigned short count;
unsigned int number;
unsigned char failed;
};
 
struct nr_route {
unsigned char quality;
unsigned char obs_count;
struct nr_neigh *neighbour;
};
 
struct nr_node {
struct nr_node *next;
ax25_address callsign;
char mnemonic[7];
unsigned char which;
unsigned char count;
struct nr_route routes[3];
};
 
/* af_netrom.c */
extern int sysctl_netrom_default_path_quality;
extern int sysctl_netrom_obsolescence_count_initialiser;
extern int sysctl_netrom_network_ttl_initialiser;
extern int sysctl_netrom_transport_timeout;
extern int sysctl_netrom_transport_maximum_tries;
extern int sysctl_netrom_transport_acknowledge_delay;
extern int sysctl_netrom_transport_busy_delay;
extern int sysctl_netrom_transport_requested_window_size;
extern int sysctl_netrom_routing_control;
extern int sysctl_netrom_link_fails_count;
extern int nr_rx_frame(struct sk_buff *, struct device *);
extern void nr_destroy_socket(struct sock *);
 
/* nr_dev.c */
extern int nr_rx_ip(struct sk_buff *, struct device *);
extern int nr_init(struct device *);
 
#include <net/nrcall.h>
 
/* nr_in.c */
extern int nr_process_rx_frame(struct sock *, struct sk_buff *);
 
/* nr_out.c */
extern void nr_output(struct sock *, struct sk_buff *);
extern void nr_send_nak_frame(struct sock *);
extern void nr_kick(struct sock *);
extern void nr_transmit_buffer(struct sock *, struct sk_buff *);
extern void nr_establish_data_link(struct sock *);
extern void nr_enquiry_response(struct sock *);
extern void nr_check_iframes_acked(struct sock *, unsigned short);
 
/* nr_route.c */
extern void nr_rt_device_down(struct device *);
extern struct device *nr_dev_first(void);
extern struct device *nr_dev_get(ax25_address *);
extern int nr_rt_ioctl(unsigned int, void *);
extern void nr_link_failed(ax25_cb *, int);
extern int nr_route_frame(struct sk_buff *, ax25_cb *);
extern int nr_nodes_get_info(char *, char **, off_t, int, int);
extern int nr_neigh_get_info(char *, char **, off_t, int, int);
extern void nr_rt_free(void);
 
/* nr_subr.c */
extern void nr_clear_queues(struct sock *);
extern void nr_frames_acked(struct sock *, unsigned short);
extern void nr_requeue_frames(struct sock *);
extern int nr_validate_nr(struct sock *, unsigned short);
extern int nr_in_rx_window(struct sock *, unsigned short);
extern void nr_write_internal(struct sock *, int);
extern void nr_transmit_dm(struct sk_buff *, int);
 
/* nr_timer.c */
extern void nr_set_timer(struct sock *);
 
/* sysctl_net_netrom.c */
extern void nr_register_sysctl(void);
extern void nr_unregister_sysctl(void);
 
/* nr_loopback.c */
extern void nr_loopback_init(void);
extern void nr_loopback_clear(void);
extern int nr_loopback_queue(struct sk_buff *);
 
#endif
/p8022call.h
0,0 → 1,2
/* Separate to keep compilation of Space.c simpler */
extern void p8022_proto_init(struct net_proto *);
/ip.h
0,0 → 1,159
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the IP module.
*
* Version: @(#)ip.h 1.0.2 05/07/93
*
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Alan Cox, <gw4pts@gw4pts.ampr.org>
*
* This program 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.
*/
#ifndef _IP_H
#define _IP_H
 
 
#include <linux/config.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/ip.h>
#include <linux/netdevice.h>
#include <net/route.h>
 
#ifndef _SNMP_H
#include <net/snmp.h>
#endif
 
#include <net/sock.h> /* struct sock */
 
/* IP flags. */
#define IP_CE 0x8000 /* Flag: "Congestion" */
#define IP_DF 0x4000 /* Flag: "Don't Fragment" */
#define IP_MF 0x2000 /* Flag: "More Fragments" */
#define IP_OFFSET 0x1FFF /* "Fragment Offset" part */
 
#define IP_FRAG_TIME (30 * HZ) /* fragment lifetime */
 
#ifdef CONFIG_IP_MULTICAST
extern void ip_mc_dropsocket(struct sock *);
extern void ip_mc_dropdevice(struct device *dev);
extern int ip_mc_procinfo(char *, char **, off_t, int, int);
#endif
 
#include <net/ip_forward.h>
 
/* Describe an IP fragment. */
struct ipfrag
{
int offset; /* offset of fragment in IP datagram */
int end; /* last byte of data in datagram */
int len; /* length of this fragment */
struct sk_buff *skb; /* complete received fragment */
unsigned char *ptr; /* pointer into real fragment data */
struct ipfrag *next; /* linked list pointers */
struct ipfrag *prev;
};
 
/*
* Describe an entry in the "incomplete datagrams" queue.
*/
struct ipq
{
unsigned char *mac; /* pointer to MAC header */
struct iphdr *iph; /* pointer to IP header */
int len; /* total length of original datagram */
short ihlen; /* length of the IP header */
short maclen; /* length of the MAC header */
struct timer_list timer; /* when will this queue expire? */
struct ipfrag *fragments; /* linked list of received fragments */
struct ipq *next; /* linked list pointers */
struct ipq *prev;
struct device *dev; /* Device - for icmp replies */
};
 
/*
* Functions provided by ip.c
*/
 
extern void ip_print(const struct iphdr *ip);
extern int ip_ioctl(struct sock *sk, int cmd, unsigned long arg);
extern void ip_route_check(__u32 daddr);
extern int ip_send(struct rtable *rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr);
extern int ip_build_header(struct sk_buff *skb,
__u32 saddr,
__u32 daddr,
struct device **dev, int type,
struct options *opt, int len,
int tos,int ttl,struct rtable **rp);
extern int ip_rcv(struct sk_buff *skb, struct device *dev,
struct packet_type *pt);
extern int ip_options_echo(struct options * dopt, struct options * sopt,
__u32 daddr, __u32 saddr,
struct sk_buff * skb);
extern int ip_options_compile(struct options * opt, struct sk_buff * skb);
extern void ip_send_check(struct iphdr *ip);
extern int ip_id_count;
extern void ip_queue_xmit(struct sock *sk,
struct device *dev, struct sk_buff *skb,
int free);
extern void ip_init(void);
extern int ip_build_xmit(struct sock *sk,
void getfrag (const void *,
__u32,
char *,
unsigned int,
unsigned int),
const void *frag,
unsigned short int length,
__u32 daddr,
__u32 saddr,
struct options * opt,
int flags,
int type,
int noblock);
 
extern struct ip_mib ip_statistics;
 
extern int sysctl_ip_dynaddr;
int ip_rewrite_addrs(struct sock *sk, struct sk_buff *skb, struct device *dev);
 
/*
* Functions provided by ip_fragment.o
*/
struct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev);
void ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag);
 
/*
* Functions provided by ip_forward.c
*/
extern int ip_forward(struct sk_buff *skb, struct device *dev, int is_frag, __u32 target_addr);
extern int sysctl_ip_forward;
 
/*
* Functions provided by ip_options.c
*/
extern void ip_options_build(struct sk_buff *skb, struct options *opt, __u32 daddr, __u32 saddr, int is_frag);
extern int ip_options_echo(struct options *dopt, struct options *sopt, __u32 daddr, __u32 saddr, struct sk_buff *skb);
extern void ip_options_fragment(struct sk_buff *skb);
extern int ip_options_compile(struct options *opt, struct sk_buff *skb);
 
/*
* Functions provided by ip_sockglue.c
*/
 
extern int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen);
extern int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
#endif /* _IP_H */
/p8022.h
0,0 → 1,7
#ifndef _NET_P8022_H
#define _NET_P8022_H
 
extern struct datalink_proto *register_8022_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
extern void unregister_8022_client(unsigned char type);
 
#endif
/snmp.h
0,0 → 1,107
/*
*
* SNMP MIB entries for the IP subsystem.
*
* Alan Cox <gw4pts@gw4pts.ampr.org>
*
* We don't chose to implement SNMP in the kernel (this would
* be silly as SNMP is a pain in the backside in places). We do
* however need to collect the MIB statistics and export them
* out of /proc (eventually)
*
* This program 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.
*
*/
#ifndef _SNMP_H
#define _SNMP_H
/*
* We use all unsigned longs. Linux will soon be so reliable that even these
* will rapidly get too small 8-). Seriously consider the IpInReceives count
* on the 20Gb/s + networks people expect in a few years time!
*/
struct ip_mib
{
unsigned long IpForwarding;
unsigned long IpDefaultTTL;
unsigned long IpInReceives;
unsigned long IpInHdrErrors;
unsigned long IpInAddrErrors;
unsigned long IpForwDatagrams;
unsigned long IpInUnknownProtos;
unsigned long IpInDiscards;
unsigned long IpInDelivers;
unsigned long IpOutRequests;
unsigned long IpOutDiscards;
unsigned long IpOutNoRoutes;
unsigned long IpReasmTimeout;
unsigned long IpReasmReqds;
unsigned long IpReasmOKs;
unsigned long IpReasmFails;
unsigned long IpFragOKs;
unsigned long IpFragFails;
unsigned long IpFragCreates;
};
struct icmp_mib
{
unsigned long IcmpInMsgs;
unsigned long IcmpInErrors;
unsigned long IcmpInDestUnreachs;
unsigned long IcmpInTimeExcds;
unsigned long IcmpInParmProbs;
unsigned long IcmpInSrcQuenchs;
unsigned long IcmpInRedirects;
unsigned long IcmpInEchos;
unsigned long IcmpInEchoReps;
unsigned long IcmpInTimestamps;
unsigned long IcmpInTimestampReps;
unsigned long IcmpInAddrMasks;
unsigned long IcmpInAddrMaskReps;
unsigned long IcmpOutMsgs;
unsigned long IcmpOutErrors;
unsigned long IcmpOutDestUnreachs;
unsigned long IcmpOutTimeExcds;
unsigned long IcmpOutParmProbs;
unsigned long IcmpOutSrcQuenchs;
unsigned long IcmpOutRedirects;
unsigned long IcmpOutEchos;
unsigned long IcmpOutEchoReps;
unsigned long IcmpOutTimestamps;
unsigned long IcmpOutTimestampReps;
unsigned long IcmpOutAddrMasks;
unsigned long IcmpOutAddrMaskReps;
};
struct tcp_mib
{
unsigned long TcpRtoAlgorithm;
unsigned long TcpRtoMin;
unsigned long TcpRtoMax;
unsigned long TcpMaxConn;
unsigned long TcpActiveOpens;
unsigned long TcpPassiveOpens;
unsigned long TcpAttemptFails;
unsigned long TcpEstabResets;
unsigned long TcpCurrEstab;
unsigned long TcpInSegs;
unsigned long TcpOutSegs;
unsigned long TcpRetransSegs;
};
struct udp_mib
{
unsigned long UdpInDatagrams;
unsigned long UdpNoPorts;
unsigned long UdpInErrors;
unsigned long UdpOutDatagrams;
};
#endif
/arp.h
0,0 → 1,17
/* linux/net/inet/arp.h */
#ifndef _ARP_H
#define _ARP_H
 
extern void arp_init(void);
extern int arp_rcv(struct sk_buff *skb, struct device *dev,
struct packet_type *pt);
extern int arp_query(unsigned char *haddr, u32 paddr, struct device *dev);
extern int arp_find(unsigned char *haddr, u32 paddr,
struct device *dev, u32 saddr, struct sk_buff *skb);
extern int arp_ioctl(unsigned int cmd, void *arg);
extern void arp_send(int type, int ptype, u32 dest_ip,
struct device *dev, u32 src_ip,
unsigned char *dest_hw, unsigned char *src_hw, unsigned char *th);
extern int arp_bind_cache(struct hh_cache ** hhp, struct device *dev, unsigned short type, __u32 daddr);
extern int arp_update_cache(struct hh_cache * hh);
#endif /* _ARP_H */
/datalink.h
0,0 → 1,16
#ifndef _NET_INET_DATALINK_H_
#define _NET_INET_DATALINK_H_
 
struct datalink_proto {
unsigned short type_len;
unsigned char type[8];
const char *string_name;
unsigned short header_length;
int (*rcvfunc)(struct sk_buff *, struct device *,
struct packet_type *);
void (*datalink_header)(struct datalink_proto *, struct sk_buff *,
unsigned char *);
struct datalink_proto *next;
};
 
#endif
/slhc_vj.h
0,0 → 1,187
#ifndef _SLHC_H
#define _SLHC_H
/*
* Definitions for tcp compression routines.
*
* $Header: /home/marcus/revision_ctrl_test/oc_cvs/cvs/or1k/rc203soc/sw/uClinux/include/net/slhc_vj.h,v 1.1 2005-12-20 11:33:02 jcastillo Exp $
*
* Copyright (c) 1989 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not 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.
*
* Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
* - Initial distribution.
*
*
* modified for KA9Q Internet Software Package by
* Katie Stevens (dkstevens@ucdavis.edu)
* University of California, Davis
* Computing Services
* - 01-31-90 initial adaptation
*
* - Feb 1991 Bill_Simpson@um.cc.umich.edu
* variable number of conversation slots
* allow zero or one slots
* separate routines
* status display
*/
 
/*
* Compressed packet format:
*
* The first octet contains the packet type (top 3 bits), TCP
* 'push' bit, and flags that indicate which of the 4 TCP sequence
* numbers have changed (bottom 5 bits). The next octet is a
* conversation number that associates a saved IP/TCP header with
* the compressed packet. The next two octets are the TCP checksum
* from the original datagram. The next 0 to 15 octets are
* sequence number changes, one change per bit set in the header
* (there may be no changes and there are two special cases where
* the receiver implicitly knows what changed -- see below).
*
* There are 5 numbers which can change (they are always inserted
* in the following order): TCP urgent pointer, window,
* acknowledgment, sequence number and IP ID. (The urgent pointer
* is different from the others in that its value is sent, not the
* change in value.) Since typical use of SLIP links is biased
* toward small packets (see comments on MTU/MSS below), changes
* use a variable length coding with one octet for numbers in the
* range 1 - 255 and 3 octets (0, MSB, LSB) for numbers in the
* range 256 - 65535 or 0. (If the change in sequence number or
* ack is more than 65535, an uncompressed packet is sent.)
*/
 
/*
* Packet types (must not conflict with IP protocol version)
*
* The top nibble of the first octet is the packet type. There are
* three possible types: IP (not proto TCP or tcp with one of the
* control flags set); uncompressed TCP (a normal IP/TCP packet but
* with the 8-bit protocol field replaced by an 8-bit connection id --
* this type of packet syncs the sender & receiver); and compressed
* TCP (described above).
*
* LSB of 4-bit field is TCP "PUSH" bit (a worthless anachronism) and
* is logically part of the 4-bit "changes" field that follows. Top
* three bits are actual packet type. For backward compatibility
* and in the interest of conserving bits, numbers are chosen so the
* IP protocol version number (4) which normally appears in this nibble
* means "IP packet".
*/
 
/* SLIP compression masks for len/vers byte */
#define SL_TYPE_IP 0x40
#define SL_TYPE_UNCOMPRESSED_TCP 0x70
#define SL_TYPE_COMPRESSED_TCP 0x80
#define SL_TYPE_ERROR 0x00
 
/* Bits in first octet of compressed packet */
#define NEW_C 0x40 /* flag bits for what changed in a packet */
#define NEW_I 0x20
#define NEW_S 0x08
#define NEW_A 0x04
#define NEW_W 0x02
#define NEW_U 0x01
 
/* reserved, special-case values of above */
#define SPECIAL_I (NEW_S|NEW_W|NEW_U) /* echoed interactive traffic */
#define SPECIAL_D (NEW_S|NEW_A|NEW_W|NEW_U) /* unidirectional data */
#define SPECIALS_MASK (NEW_S|NEW_A|NEW_W|NEW_U)
 
#define TCP_PUSH_BIT 0x10
 
/*
* data type and sizes conversion assumptions:
*
* VJ code KA9Q style generic
* u_char byte_t unsigned char 8 bits
* u_short int16 unsigned short 16 bits
* u_int int16 unsigned short 16 bits
* u_long unsigned long unsigned long 32 bits
* int int32 long 32 bits
*/
 
typedef unsigned char byte_t;
typedef unsigned long int32;
 
/*
* "state" data for each active tcp conversation on the wire. This is
* basically a copy of the entire IP/TCP header from the last packet
* we saw from the conversation together with a small identifier
* the transmit & receive ends of the line use to locate saved header.
*/
struct cstate {
byte_t cs_this; /* connection id number (xmit) */
struct cstate *next; /* next in ring (xmit) */
struct iphdr cs_ip; /* ip/tcp hdr from most recent packet */
struct tcphdr cs_tcp;
unsigned char cs_ipopt[64];
unsigned char cs_tcpopt[64];
int cs_hsize;
};
#define NULLSLSTATE (struct cstate *)0
 
/*
* all the state data for one serial line (we need one of these per line).
*/
struct slcompress {
struct cstate *tstate; /* transmit connection states (array)*/
struct cstate *rstate; /* receive connection states (array)*/
 
byte_t tslot_limit; /* highest transmit slot id (0-l)*/
byte_t rslot_limit; /* highest receive slot id (0-l)*/
 
byte_t xmit_oldest; /* oldest xmit in ring */
byte_t xmit_current; /* most recent xmit id */
byte_t recv_current; /* most recent rcvd id */
 
byte_t flags;
#define SLF_TOSS 0x01 /* tossing rcvd frames until id received */
 
int32 sls_o_nontcp; /* outbound non-TCP packets */
int32 sls_o_tcp; /* outbound TCP packets */
int32 sls_o_uncompressed; /* outbound uncompressed packets */
int32 sls_o_compressed; /* outbound compressed packets */
int32 sls_o_searches; /* searches for connection state */
int32 sls_o_misses; /* times couldn't find conn. state */
 
int32 sls_i_uncompressed; /* inbound uncompressed packets */
int32 sls_i_compressed; /* inbound compressed packets */
int32 sls_i_error; /* inbound error packets */
int32 sls_i_tossed; /* inbound packets tossed because of error */
 
int32 sls_i_runt;
int32 sls_i_badcheck;
};
#define NULLSLCOMPR (struct slcompress *)0
 
#define __ARGS(x) x
 
/* In slhc.c: */
struct slcompress *slhc_init __ARGS((int rslots, int tslots));
void slhc_free __ARGS((struct slcompress *comp));
 
int slhc_compress __ARGS((struct slcompress *comp, unsigned char *icp,
int isize, unsigned char *ocp, unsigned char **cpp,
int compress_cid));
int slhc_uncompress __ARGS((struct slcompress *comp, unsigned char *icp,
int isize));
int slhc_remember __ARGS((struct slcompress *comp, unsigned char *icp,
int isize));
int slhc_toss __ARGS((struct slcompress *comp));
 
void slhc_i_status __ARGS((struct slcompress *comp));
void slhc_o_status __ARGS((struct slcompress *comp));
 
#endif /* _SLHC_H */
/atalkcall.h
0,0 → 1,2
/* Separate to keep compilation of protocols.c simpler */
extern void atalk_proto_init(struct net_proto *pro);
/slhc.h
0,0 → 1,6
#ifndef __NET_SLHC_H
#define __NET_SLHC_H
 
extern void slhc_install(void);
 
#endif
/ipxcall.h
0,0 → 1,2
/* Separate to keep compilation of protocols.c simpler */
extern void ipx_proto_init(struct net_proto *pro);
/route.h
0,0 → 1,189
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the IP router.
*
* Version: @(#)route.h 1.0.4 05/27/93
*
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Fixes:
* Alan Cox : Reformatted. Added ip_rt_local()
* Alan Cox : Support for TCP parameters.
* Alexey Kuznetsov: Major changes for new routing code.
* Elliot Poger : Added support for SO_BINDTODEVICE.
* Wolfgang Walter,
* Daniel Ryde,
* Ingo Molinar : fixed bug in ip_rt_put introduced
* by SO_BINDTODEVICE support causing
* a memory leak
*
* FIXME:
* Make atomic ops more generic and hide them in asm/...
*
* This program 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.
*/
#ifndef _ROUTE_H
#define _ROUTE_H
 
#include <linux/config.h>
 
/*
* 0 - no debugging messages
* 1 - rare events and bugs situations (default)
* 2 - trace mode.
*/
#define RT_CACHE_DEBUG 0
 
#define RT_HASH_DIVISOR 256
#define RT_CACHE_SIZE_MAX 256
 
#define RTZ_HASH_DIVISOR 256
 
#if RT_CACHE_DEBUG >= 2
#define RTZ_HASHING_LIMIT 0
#else
#define RTZ_HASHING_LIMIT 16
#endif
 
/*
* Maximal time to live for unused entry.
*/
#define RT_CACHE_TIMEOUT (HZ*300)
 
/*
* Prevents LRU trashing, entries considered equivalent,
* if the difference between last use times is less then this number.
*/
#define RT_CACHE_BUBBLE_THRESHOLD (HZ*5)
 
#include <linux/route.h>
 
#ifdef __KERNEL__
#define RTF_LOCAL 0x8000
#endif
 
struct rtable
{
struct rtable *rt_next;
__u32 rt_dst;
__u32 rt_src;
__u32 rt_gateway;
atomic_t rt_refcnt;
atomic_t rt_use;
unsigned long rt_window;
atomic_t rt_lastuse;
struct hh_cache *rt_hh;
struct device *rt_dev;
unsigned short rt_flags;
unsigned short rt_mtu;
unsigned short rt_irtt;
unsigned char rt_tos;
};
 
extern void ip_rt_flush(struct device *dev);
extern void ip_rt_update(int event, struct device *dev);
extern void ip_rt_redirect(__u32 src, __u32 dst, __u32 gw, struct device *dev);
extern struct rtable *ip_rt_slow_route(__u32 daddr, int local, struct device *dev);
extern struct device *ip_rt_dev(__u32 addr);
extern int rt_get_info(char * buffer, char **start, off_t offset, int length, int dummy);
extern int rt_cache_get_info(char *buffer, char **start, off_t offset, int length, int dummy);
extern int ip_rt_ioctl(unsigned int cmd, void *arg);
extern int ip_rt_new(struct rtentry *rt);
extern int ip_rt_kill(struct rtentry *rt);
extern void ip_rt_check_expire(void);
extern void ip_rt_advice(struct rtable **rp, int advice);
 
extern void ip_rt_run_bh(void);
extern atomic_t ip_rt_lock;
extern unsigned ip_rt_bh_mask;
extern struct rtable *ip_rt_hash_table[RT_HASH_DIVISOR];
extern void rt_free(struct rtable * rt);
 
extern __inline__ void ip_rt_fast_lock(void)
{
atomic_inc(&ip_rt_lock);
}
 
extern __inline__ void ip_rt_fast_unlock(void)
{
atomic_dec(&ip_rt_lock);
}
 
extern __inline__ void ip_rt_unlock(void)
{
if (atomic_dec_and_test(&ip_rt_lock) && ip_rt_bh_mask)
ip_rt_run_bh();
}
 
extern __inline__ unsigned ip_rt_hash_code(__u32 addr)
{
unsigned tmp = addr + (addr>>16);
return (tmp + (tmp>>8)) & 0xFF;
}
 
 
extern __inline__ void ip_rt_put(struct rtable * rt)
#ifndef MODULE
{
/* If this rtable entry is not in the cache, we'd better free
* it once the refcnt goes to zero, because nobody else will.
*/
if (rt&&atomic_dec_and_test(&rt->rt_refcnt)&&(rt->rt_flags&RTF_NOTCACHED))
rt_free(rt);
}
#else
;
#endif
 
#ifdef CONFIG_KERNELD
extern struct rtable * ip_rt_route(__u32 daddr, int local, struct device *dev);
#else
extern __inline__ struct rtable * ip_rt_route(__u32 daddr, int local, struct device *dev)
#ifndef MODULE
{
struct rtable * rth;
 
ip_rt_fast_lock();
 
for (rth=ip_rt_hash_table[ip_rt_hash_code(daddr)^local]; rth; rth=rth->rt_next)
{
/* If an interface is specified, make sure this route points to it. */
if ( (rth->rt_dst == daddr) && ((dev==NULL) || (dev==rth->rt_dev)) )
{
rth->rt_lastuse = jiffies;
atomic_inc(&rth->rt_use);
atomic_inc(&rth->rt_refcnt);
ip_rt_unlock();
return rth;
}
}
return ip_rt_slow_route (daddr, local, dev);
}
#else
;
#endif
#endif
 
extern __inline__ struct rtable * ip_check_route(struct rtable ** rp, __u32 daddr,
int local, struct device *dev)
{
struct rtable * rt = *rp;
 
if (!rt || rt->rt_dst != daddr || !(rt->rt_flags&RTF_UP) || (dev!=NULL)
|| ((local==1)^((rt->rt_flags&RTF_LOCAL) != 0)))
{
ip_rt_put(rt);
rt = ip_rt_route(daddr, local, dev);
*rp = rt;
}
return rt;
}
 
 
#endif /* _ROUTE_H */
/ipx.h
0,0 → 1,88
 
/*
* The following information is in its entirety obtained from:
*
* Novell 'IPX Router Specification' Version 1.10
* Part No. 107-000029-001
*
* Which is available from ftp.novell.com
*/
 
#ifndef _NET_INET_IPX_H_
#define _NET_INET_IPX_H_
 
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <net/datalink.h>
#include <linux/ipx.h>
 
/* #define CONFIG_IPX_INTERN 1 */
 
typedef struct
{
unsigned long net;
unsigned char node[IPX_NODE_LEN];
unsigned short sock;
} ipx_address;
 
#define ipx_broadcast_node "\377\377\377\377\377\377"
#define ipx_this_node "\0\0\0\0\0\0"
 
typedef struct ipx_packet
{
unsigned short ipx_checksum;
#define IPX_NO_CHECKSUM 0xFFFF
unsigned short ipx_pktsize;
unsigned char ipx_tctrl;
unsigned char ipx_type;
#define IPX_TYPE_UNKNOWN 0x00
#define IPX_TYPE_RIP 0x01 /* may also be 0 */
#define IPX_TYPE_SAP 0x04 /* may also be 0 */
#define IPX_TYPE_SPX 0x05 /* Not yet implemented */
#define IPX_TYPE_NCP 0x11 /* $lots for docs on this (SPIT) */
#define IPX_TYPE_PPROP 0x14 /* complicated flood fill brdcast [Not supported] */
ipx_address ipx_dest __attribute__ ((packed));
ipx_address ipx_source __attribute__ ((packed));
} ipx_packet;
 
 
typedef struct sock ipx_socket;
 
#include <net/ipxcall.h>
extern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
extern void ipxrtr_device_down(struct device *dev);
 
typedef struct ipx_interface {
/* IPX address */
unsigned long if_netnum;
unsigned char if_node[IPX_NODE_LEN];
 
/* physical device info */
struct device *if_dev;
struct datalink_proto *if_dlink;
unsigned short if_dlink_type;
 
/* socket support */
unsigned short if_sknum;
ipx_socket *if_sklist;
 
/* administrative overhead */
int if_ipx_offset;
unsigned char if_internal;
unsigned char if_primary;
struct ipx_interface *if_next;
} ipx_interface;
 
typedef struct ipx_route {
unsigned long ir_net;
ipx_interface *ir_intrfc;
unsigned char ir_routed;
unsigned char ir_router_node[IPX_NODE_LEN];
struct ipx_route *ir_next;
} ipx_route;
 
#define IPX_MIN_EPHEMERAL_SOCKET 0x4000
#define IPX_MAX_EPHEMERAL_SOCKET 0x7fff
 
#endif
/protocol.h
0,0 → 1,55
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the protocol dispatcher.
*
* Version: @(#)protocol.h 1.0.2 05/07/93
*
* Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* This program 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.
*
* Changes:
* Alan Cox : Added a name field and a frag handler
* field for later.
* Alan Cox : Cleaned up, and sorted types.
*/
#ifndef _PROTOCOL_H
#define _PROTOCOL_H
 
#define MAX_INET_PROTOS 32 /* Must be a power of 2 */
 
 
/* This is used to register protocols. */
struct inet_protocol {
int (*handler)(struct sk_buff *skb, struct device *dev,
struct options *opt, __u32 daddr,
unsigned short len, __u32 saddr,
int redo, struct inet_protocol *protocol);
void (*err_handler)(int type, int code, unsigned char *buff,
__u32 daddr,
__u32 saddr,
struct inet_protocol *protocol, int len);
struct inet_protocol *next;
unsigned char protocol;
unsigned char copy:1;
void *data;
const char *name;
};
 
 
extern struct inet_protocol *inet_protocol_base;
extern struct inet_protocol *inet_protos[MAX_INET_PROTOS];
 
 
extern void inet_add_protocol(struct inet_protocol *prot);
extern int inet_del_protocol(struct inet_protocol *prot);
 
 
#endif /* _PROTOCOL_H */
/checksum.h
0,0 → 1,25
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Checksumming functions for IP, TCP, UDP and so on
*
* Authors: Jorge Cwik, <jorge@laser.satlink.net>
* Arnt Gulbrandsen, <agulbra@nvg.unit.no>
* Borrows very liberally from tcp.c and ip.c, see those
* files for more names.
*
* This program 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.
*/
#ifndef _CHECKSUM_H
#define _CHECKSUM_H
 
#include <asm/byteorder.h>
#include <net/ip.h>
#include <asm/checksum.h>
 
#endif
/br.h
0,0 → 1,270
/*
* Constants and structure definitions for the bridging code
*/
 
#if !defined(One)
#define Zero 0
#define One 1
#endif /* !defined(One) */
 
#if !defined(TRUE)
#define FALSE 0
#define TRUE 1
#endif /* !defined(TRUE) */
 
/** port states. **/
#define Disabled 0 /* (4.4 5) */
#define Listening 1 /* (4.4.2) */
#define Learning 2 /* (4.4.3) */
#define Forwarding 3 /* (4 4 4) */
#define Blocking 4 /* (4.4.1) */
 
#define No_of_ports 8
/* arbitrary choice, to allow the code below to compile */
 
#define All_ports (No_of_ports + 1)
 
/*
* We time out our entries in the FDB after this many seconds.
*/
#define FDB_TIMEOUT 300
 
/*
* the following defines are the initial values used when the
* bridge is booted. These may be overridden when this bridge is
* not the root bridge. These are the recommended default values
* from the 802.1d specification.
*/
#define BRIDGE_MAX_AGE 20
#define BRIDGE_HELLO_TIME 2
#define BRIDGE_FORWARD_DELAY 15
#define HOLD_TIME 1
 
#define Default_path_cost 10
 
/*
* minimum increment possible to avoid underestimating age, allows for BPDU
* transmission time
*/
#define Message_age_increment 1
 
#define No_port 0
/*
* reserved value for Bridge's root port parameter indicating no root port,
* used when Bridge is the root - also used to indicate the source when
* a frame is being generated by a higher layer protocol on this host
*/
 
/** Configuration BPDU Parameters (4.5.1) **/
 
typedef struct {
union {
struct {
unsigned short priority;
unsigned char ula[6];
} p_u;
unsigned int id[2];
} bi;
} bridge_id_t;
 
#define BRIDGE_PRIORITY bi.p_u.priority
#define BRIDGE_ID_ULA bi.p_u.ula
#define BRIDGE_ID bi.id
 
typedef struct {
unsigned short protocol_id;
unsigned char protocol_version_id;
unsigned char type;
unsigned char flags;
#define TOPOLOGY_CHANGE 0x01
#define TOPOLOGY_CHANGE_ACK 0x80
bridge_id_t root_id; /* (4.5.1.1) */
unsigned int root_path_cost; /* (4.5.1.2) */
bridge_id_t bridge_id; /* (4.5.1.3) */
unsigned short port_id; /* (4.5.1.4) */
unsigned short message_age; /* (4.5.1.5) */
unsigned short max_age; /* (4.5.1.6) */
unsigned short hello_time; /* (4.5.1.7) */
unsigned short forward_delay; /* (4.5.1.8) */
} Config_bpdu;
 
 
/** Topology Change Notification BPDU Parameters (4.5.2) **/
 
typedef struct {
unsigned short protocol_id;
unsigned char protocol_version_id;
unsigned char type;
} Tcn_bpdu;
 
#define BPDU_TYPE_CONFIG 0
#define BPDU_TYPE_TOPO_CHANGE 128
 
/** Bridge Parameters (4.5.3) **/
typedef struct {
bridge_id_t designated_root; /* (4.5.3.1) */
unsigned int root_path_cost; /* (4.5.3.2) */
unsigned int root_port; /* (4.5.3.3) */
unsigned short max_age; /* (4.5.3.4) */
unsigned short hello_time; /* (4.5.3.5) */
unsigned short forward_delay; /* (4.5.3.6) */
bridge_id_t bridge_id; /* (4.5.3.7) */
unsigned short bridge_max_age; /* (4.5.3.8) */
unsigned short bridge_hello_time; /* (4.5.3.9) */
unsigned short bridge_forward_delay; /* (4.5.3.10) */
unsigned int topology_change_detected; /* (4.5.3.11) */
unsigned int topology_change; /* (4.5.3.12) */
unsigned short topology_change_time; /* (4.5.3.13) */
unsigned short hold_time; /* (4.5.3.14) */
unsigned int top_change;
unsigned int top_change_detected;
} Bridge_data;
 
/** Port Parameters (4.5.5) **/
typedef struct {
unsigned short port_id; /* (4.5.5.1) */
unsigned int state; /* (4.5.5.2) */
unsigned int path_cost; /* (4.5.5.3) */
bridge_id_t designated_root; /* (4.5.5.4) */
unsigned int designated_cost; /* (4.5.5.5) */
bridge_id_t designated_bridge; /* (4.5.5.6) */
unsigned short designated_port; /* (4.5.5.7) */
unsigned int top_change_ack; /* (4.5.5.8) */
unsigned int config_pending; /* (4.5.5.9) */
struct device *dev;
struct fdb *fdb; /* head of per port fdb chain */
} Port_data;
 
 
 
/** types to support timers for this pseudo-implementation. **/
typedef struct {
unsigned int active; /* timer in use. */
unsigned int value; /* current value of timer,
* counting up. */
} Timer;
 
struct fdb {
unsigned char ula[6];
unsigned char pad[2];
unsigned short port;
unsigned int timer;
unsigned int flags;
#define FDB_ENT_VALID 0x01
/* AVL tree of all addresses, sorted by address */
short fdb_avl_height;
struct fdb *fdb_avl_left;
struct fdb *fdb_avl_right;
/* linked list of addresses for each port */
struct fdb *fdb_next;
};
 
#define IS_BRIDGED 0x2e
 
struct br_stat {
unsigned int flags;
Bridge_data bridge_data;
Port_data port_data[No_of_ports];
};
 
/* defined flags for br_stat.flags */
#define BR_UP 0x0001 /* bridging enabled */
#define BR_DEBUG 0x0002 /* debugging enabled */
 
struct br_cf {
unsigned int cmd;
unsigned int arg1;
unsigned int arg2;
};
 
/* defined cmds */
#define BRCMD_BRIDGE_ENABLE 1
#define BRCMD_BRIDGE_DISABLE 2
#define BRCMD_PORT_ENABLE 3 /* arg1 = port */
#define BRCMD_PORT_DISABLE 4 /* arg1 = port */
#define BRCMD_SET_BRIDGE_PRIORITY 5 /* arg1 = priority */
#define BRCMD_SET_PORT_PRIORITY 6 /* arg1 = port, arg2 = priority */
#define BRCMD_SET_PATH_COST 7 /* arg1 = port, arg2 = cost */
#define BRCMD_DISPLAY_FDB 8 /* arg1 = port */
#define BRCMD_ENABLE_DEBUG 9
#define BRCMD_DISABLE_DEBUG 10
 
/* prototypes of all bridging functions... */
 
void transmit_config(int port_no);
int root_bridge(void);
int supersedes_port_info(int port_no, Config_bpdu *config);
void record_config_information(int port_no, Config_bpdu *config);
void record_config_timeout_values(Config_bpdu *config);
void config_bpdu_generation(void);
int designated_port(int port_no);
void reply(int port_no);
void transmit_tcn(void);
void configuration_update(void);
void root_selection(void);
void designated_port_selection(void);
void become_designated_port(int port_no);
void port_state_selection(void);
void make_forwarding(int port_no);
void topology_change_detection(void);
void topology_change_acknowledged(void);
void acknowledge_topology_change(int port_no);
void make_blocking(int port_no);
void set_port_state(int port_no, int state);
void received_config_bpdu(int port_no, Config_bpdu *config);
void received_tcn_bpdu(int port_no, Tcn_bpdu *tcn);
void hello_timer_expiry(void);
void message_age_timer_expiry(int port_no);
void forward_delay_timer_expiry(int port_no);
int designated_for_some_port(void);
void tcn_timer_expiry(void);
void topology_change_timer_expiry(void);
void hold_timer_expiry(int port_no);
void br_init(void);
void br_init_port(int port_no);
void enable_port(int port_no);
void disable_port(int port_no);
void set_bridge_priority(bridge_id_t *new_bridge_id);
void set_port_priority(int port_no, unsigned short new_port_id);
void set_path_cost(int port_no, unsigned short path_cost);
void start_hello_timer(void);
void stop_hello_timer(void);
int hello_timer_expired(void);
void start_tcn_timer(void);
void stop_tcn_timer(void);
int tcn_timer_expired(void);
void start_topology_change_timer(void);
void stop_topology_change_timer(void);
int topology_change_timer_expired(void);
void start_message_age_timer(int port_no, unsigned short message_age);
void stop_message_age_timer(int port_no);
int message_age_timer_expired(int port_no);
void start_forward_delay_timer(int port_no);
void stop_forward_delay_timer(int port_no);
int forward_delay_timer_expired(int port_no);
void start_hold_timer(int port_no);
void stop_hold_timer(int port_no);
int hold_timer_expired(int port_no);
 
struct fdb *br_avl_find_addr(unsigned char addr[6]);
int br_avl_insert (struct fdb * new_node);
int br_avl_remove (struct fdb * node_to_delete);
 
int send_tcn_bpdu(int port_no, Tcn_bpdu *bpdu);
int send_config_bpdu(int port_no, Config_bpdu *config_bpdu);
int find_port(struct device *dev);
int br_flood(struct sk_buff *skb, int port);
int br_drop(struct sk_buff *skb);
int br_learn(struct sk_buff *skb, int port); /* 3.8 */
 
int br_receive_frame(struct sk_buff *skb); /* 3.5 */
int br_tx_frame(struct sk_buff *skb);
int br_ioctl(unsigned int cmd, void *arg);
 
void free_fdb(struct fdb *);
struct fdb *get_fdb(void);
 
/* externs */
 
extern struct br_stat br_stats;
 
/netlink.h
0,0 → 1,32
#ifndef __NET_NETLINK_H
#define __NET_NETLINK_H
 
#define NET_MAJOR 36 /* Major 18 is reserved for networking */
#define MAX_LINKS 11 /* 18,0 for route updates, 18,1 for SKIP, 18,2 debug tap 18,3 PPP reserved */
/* 4-7 are psi0-psi3 8 is arpd 9 is ppp */
/* 10 is for IPSEC <John Ioannidis> */
#define MAX_QBYTES 32768 /* Maximum bytes in the queue */
 
#include <linux/config.h>
 
extern int netlink_attach(int unit, int (*function)(struct sk_buff *skb));
extern int netlink_donothing(struct sk_buff *skb);
extern void netlink_detach(int unit);
extern int netlink_post(int unit, struct sk_buff *skb);
extern int init_netlink(void);
 
#define NETLINK_ROUTE 0 /* Routing/device hook */
#define NETLINK_SKIP 1 /* Reserved for ENskip */
#define NETLINK_USERSOCK 2 /* Reserved for user mode socket protocols */
#define NETLINK_FIREWALL 3 /* Firewalling hook */
#define NETLINK_PSI 4 /* PSI devices - 4 to 7 */
#define NETLINK_ARPD 8
#define NETLINK_NET_PPP 9 /* Non tty PPP devices */
#define NETLINK_IPSEC 10 /* IPSEC */
 
#ifdef CONFIG_RTNETLINK
extern void ip_netlink_msg(unsigned long, __u32, __u32, __u32, short, short, char *);
#else
#define ip_netlink_msg(a,b,c,d,e,f,g)
#endif
#endif
/rosecall.h
0,0 → 1,2
/* Separate to keep compilation of protocols.c simpler */
extern void rose_proto_init(struct net_proto *pro);
/rose.h
0,0 → 1,233
/*
* Declarations of Rose type objects.
*
* Jonathan Naylor G4KLX 25/8/96
*/
 
#ifndef _ROSE_H
#define _ROSE_H
#include <linux/rose.h>
 
#define ROSE_SLOWHZ 10 /* Run timing at 1/10 second */
 
#define ROSE_ADDR_LEN 5
 
#define ROSE_MIN_LEN 3
 
#define ROSE_GFI 0x10
#define ROSE_Q_BIT 0x80
#define ROSE_D_BIT 0x40
#define ROSE_M_BIT 0x10
#define M_BIT 0x10
 
#define ROSE_CALL_REQUEST 0x0B
#define ROSE_CALL_ACCEPTED 0x0F
#define ROSE_CLEAR_REQUEST 0x13
#define ROSE_CLEAR_CONFIRMATION 0x17
#define ROSE_DATA 0x00
#define ROSE_INTERRUPT 0x23
#define ROSE_INTERRUPT_CONFIRMATION 0x27
#define ROSE_RR 0x01
#define ROSE_RNR 0x05
#define ROSE_REJ 0x09
#define ROSE_RESET_REQUEST 0x1B
#define ROSE_RESET_CONFIRMATION 0x1F
#define ROSE_REGISTRATION_REQUEST 0xF3
#define ROSE_REGISTRATION_CONFIRMATION 0xF7
#define ROSE_RESTART_REQUEST 0xFB
#define ROSE_RESTART_CONFIRMATION 0xFF
#define ROSE_DIAGNOSTIC 0xF1
#define ROSE_ILLEGAL 0xFD
 
/* Define Link State constants. */
 
#define ROSE_STATE_0 0 /* Ready */
#define ROSE_STATE_1 1 /* Awaiting Call Accepted */
#define ROSE_STATE_2 2 /* Awaiting Clear Confirmation */
#define ROSE_STATE_3 3 /* Data Transfer */
#define ROSE_STATE_4 4 /* Awaiting Reset Confirmation */
#define ROSE_STATE_5 5 /* Deferred Call Acceptance */
 
#define ROSE_DEFAULT_T0 (180 * ROSE_SLOWHZ) /* Default T10 T20 value */
#define ROSE_DEFAULT_T1 (200 * ROSE_SLOWHZ) /* Default T11 T21 value */
#define ROSE_DEFAULT_T2 (180 * ROSE_SLOWHZ) /* Default T12 T22 value */
#define ROSE_DEFAULT_T3 (180 * ROSE_SLOWHZ) /* Default T13 T23 value */
#define ROSE_DEFAULT_HB (5 * ROSE_SLOWHZ) /* Default Holdback value */
#define ROSE_DEFAULT_ROUTING 1 /* Default routing flag */
#define ROSE_DEFAULT_FAIL_TIMEOUT (120 * ROSE_SLOWHZ) /* Time until link considered usable */
#define ROSE_DEFAULT_MAXVC 50 /* Maximum number of VCs per neighbour */
#define ROSE_DEFAULT_WINDOW_SIZE 7 /* Default window value */
 
#define ROSE_MODULUS 8
#define ROSE_MAX_PACKET_SIZE 251 /* Maximum Packet Size */
 
#define ROSE_MAX_WINDOW_LEN ((AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN + 300) * 7)
 
#define ROSE_COND_ACK_PENDING 0x01
#define ROSE_COND_PEER_RX_BUSY 0x02
#define ROSE_COND_OWN_RX_BUSY 0x04
 
#define FAC_NATIONAL 0x00
#define FAC_CCITT 0x0F
 
#define FAC_NATIONAL_RAND 0x7F
#define FAC_NATIONAL_FLAGS 0x3F
#define FAC_NATIONAL_DEST_DIGI 0xE9
#define FAC_NATIONAL_SRC_DIGI 0xEB
#define FAC_NATIONAL_FAIL_CALL 0xED
#define FAC_NATIONAL_FAIL_ADD 0xEE
#define FAC_NATIONAL_DIGIS 0xEF
 
#define FAC_CCITT_DEST_NSAP 0xC9
#define FAC_CCITT_SRC_NSAP 0xCB
 
struct rose_neigh {
struct rose_neigh *next;
ax25_address callsign;
ax25_digi *digipeat;
ax25_cb *ax25;
struct device *dev;
unsigned short count;
unsigned short use;
unsigned int number;
char restarted;
char dce_mode;
struct sk_buff_head queue;
unsigned short t0timer, ftimer;
struct timer_list timer;
};
 
#define ROSE_MAX_ALTERNATE 3
struct rose_node {
struct rose_node *next;
rose_address address;
unsigned short mask;
unsigned char count;
struct rose_neigh *neighbour[ROSE_MAX_ALTERNATE];
};
 
typedef struct {
unsigned int lci;
struct rose_neigh *neigh;
unsigned short vs, vr, va, vl;
unsigned short pending;
unsigned char state, condition;
struct timer_list timer;
} rose_tr;
 
struct rose_route {
struct rose_route *next;
rose_address src_addr, dest_addr;
ax25_address src_call, dest_call;
rose_tr tr1, tr2;
unsigned int rand;
};
 
typedef struct {
rose_address source_addr, dest_addr;
ax25_address source_call, dest_call;
unsigned char source_ndigis, dest_ndigis;
ax25_address source_digis[ROSE_MAX_DIGIS];
ax25_address dest_digis[ROSE_MAX_DIGIS];
struct rose_neigh *neighbour;
struct device *device;
unsigned int lci, rand;
unsigned char state, condition, qbitincl, defer;
unsigned char cause, diagnostic;
unsigned short vs, vr, va, vl;
unsigned short timer;
unsigned short t1, t2, t3, hb;
#ifdef M_BIT
unsigned short fraglen;
struct sk_buff_head frag_queue;
#endif
struct sk_buff_head ack_queue;
struct rose_facilities_struct facilities;
struct sock *sk; /* Backlink to socket */
} rose_cb;
 
/* af_rose.c */
extern ax25_address rose_callsign;
extern int sysctl_rose_restart_request_timeout;
extern int sysctl_rose_call_request_timeout;
extern int sysctl_rose_reset_request_timeout;
extern int sysctl_rose_clear_request_timeout;
extern int sysctl_rose_ack_hold_back_timeout;
extern int sysctl_rose_routing_control;
extern int sysctl_rose_link_fail_timeout;
extern int sysctl_rose_maximum_vcs;
extern int sysctl_rose_window_size;
extern int rosecmp(rose_address *, rose_address *);
extern int rosecmpm(rose_address *, rose_address *, unsigned short);
extern char *rose2asc(rose_address *);
extern void rose_kill_by_neigh(struct rose_neigh *);
extern struct sock *rose_find_socket(unsigned int, struct rose_neigh *);
extern unsigned int rose_new_lci(struct rose_neigh *);
extern int rose_rx_call_request(struct sk_buff *, struct device *, struct rose_neigh *, unsigned int);
extern void rose_destroy_socket(struct sock *);
 
/* rose_dev.c */
extern int rose_rx_ip(struct sk_buff *, struct device *);
extern int rose_init(struct device *);
 
#include <net/rosecall.h>
 
/* rose_in.c */
extern int rose_process_rx_frame(struct sock *, struct sk_buff *);
 
/* rose_link.c */
extern void rose_link_set_timer(struct rose_neigh *);
extern void rose_link_rx_restart(struct sk_buff *, struct rose_neigh *, unsigned short);
extern void rose_transmit_restart_request(struct rose_neigh *);
extern void rose_transmit_restart_confirmation(struct rose_neigh *);
extern void rose_transmit_diagnostic(struct rose_neigh *, unsigned char);
extern void rose_transmit_clear_request(struct rose_neigh *, unsigned int, unsigned char, unsigned char);
extern void rose_transmit_link(struct sk_buff *, struct rose_neigh *);
 
/* rose_loopback.c */
extern void rose_loopback_init(void);
extern void rose_loopback_clear(void);
extern int rose_loopback_queue(struct sk_buff *, struct rose_neigh *);
 
/* rose_out.c */
extern void rose_kick(struct sock *);
extern void rose_enquiry_response(struct sock *);
 
/* rose_route.c */
extern void rose_rt_device_down(struct device *);
extern void rose_link_device_down(struct device *);
extern void rose_clean_neighbour(struct rose_neigh *);
extern struct device *rose_dev_first(void);
extern struct device *rose_dev_get(rose_address *);
extern struct rose_route *rose_route_free_lci(unsigned int, struct rose_neigh *);
extern struct device *rose_ax25_dev_get(char *);
extern struct rose_neigh *rose_get_neigh(rose_address *, unsigned char *, unsigned char *);
extern int rose_rt_ioctl(unsigned int, void *);
extern void rose_link_failed(ax25_cb *, int);
extern int rose_route_frame(struct sk_buff *, ax25_cb *);
extern int rose_nodes_get_info(char *, char **, off_t, int, int);
extern int rose_neigh_get_info(char *, char **, off_t, int, int);
extern int rose_routes_get_info(char *, char **, off_t, int, int);
extern void rose_rt_free(void);
 
/* rose_subr.c */
extern void rose_clear_queues(struct sock *);
extern void rose_frames_acked(struct sock *, unsigned short);
extern int rose_validate_nr(struct sock *, unsigned short);
extern void rose_write_internal(struct sock *, int);
extern int rose_decode(struct sk_buff *, int *, int *, int *, int *, int *);
extern int rose_parse_facilities(unsigned char *, struct rose_facilities_struct *);
extern int rose_create_facilities(unsigned char *, rose_cb *);
 
/* rose_timer.c */
extern void rose_set_timer(struct sock *);
 
/* sysctl_net_rose.c */
extern void rose_register_sysctl(void);
extern void rose_unregister_sysctl(void);
 
/* rose_transit.c */
void rose_transit(struct sk_buff *, rose_tr *, rose_tr *);
void rose_init_transit(rose_tr *, unsigned int, struct rose_neigh *);
 
#endif
/spx.h
0,0 → 1,38
#ifndef __NET_SPX_H
#define __NET_SPX_H
 
/*
* Internal definitions for the SPX protocol.
*/
/*
* The SPX header following an IPX header.
*/
struct spxhdr
{
__u8 cctl;
#define CCTL_SPXII_XHD 0x01 /* SPX2 extended header */
#define CCTL_SPX_UNKNOWN 0x02 /* Unknown (unused ??) */
#define CCTL_SPXII_NEG 0x04 /* Negotiate size */
#define CCTL_SPXII 0x08 /* Set for SPX2 */
#define CCTL_EOM 0x10 /* End of message marker */
#define CCTL_URG 0x20 /* Urgent marker in SPP (not used in SPX?) */
#define CCTL_ACK 0x40 /* Send me an ACK */
#define CCTL_CTL 0x80 /* Control message */
__u8 dtype;
#define SPX_DTYPE_ECONN 0xFE /* Finished */
#define SPX_DTYPE_ECACK 0xFF /* Ok */
__u16 sconn; /* Connection ID */
__u16 dconn; /* Connection ID */
__u16 sequence;
__u16 ackseq;
__u16 allocseq;
};
 
#define IPXTYPE_SPX 5
 
#endif
/ax25call.h
0,0 → 1,2
/* Separate to keep compilation of protocols.c simpler */
extern void ax25_proto_init(struct net_proto *pro);
/nrcall.h
0,0 → 1,2
/* Separate to keep compilation of protocols.c simpler */
extern void nr_proto_init(struct net_proto *pro);
/psnapcall.h
0,0 → 1,2
/* Separate to keep compilation of Space.c simpler */
extern void snap_proto_init(struct net_proto *);
/p8022trcall.h
0,0 → 1,3
/* Separate to keep compilation of Space.c simpler */
extern void p8022tr_proto_init(struct net_proto *);
 
/ax25.h
0,0 → 1,292
/*
* Declarations of AX.25 type objects.
*
* Alan Cox (GW4PTS) 10/11/93
*/
#ifndef _AX25_H
#define _AX25_H
#include <linux/ax25.h>
 
#define AX25_SLOWHZ 10 /* Run timing at 1/10 second - gives us better resolution for 56kbit links */
 
#define AX25_T1CLAMPLO (1 * AX25_SLOWHZ) /* If defined, clamp at 1 second **/
#define AX25_T1CLAMPHI (30 * AX25_SLOWHZ) /* If defined, clamp at 30 seconds **/
 
#define AX25_BPQ_HEADER_LEN 16
#define AX25_KISS_HEADER_LEN 1
 
#define AX25_HEADER_LEN 17
#define AX25_ADDR_LEN 7
#define AX25_DIGI_HEADER_LEN (AX25_MAX_DIGIS * AX25_ADDR_LEN)
#define AX25_MAX_HEADER_LEN (AX25_HEADER_LEN + AX25_DIGI_HEADER_LEN)
 
/* AX.25 Protocol IDs */
#define AX25_P_ROSE 0x01
#define AX25_P_IP 0xCC
#define AX25_P_ARP 0xCD
#define AX25_P_TEXT 0xF0
#define AX25_P_NETROM 0xCF
#define AX25_P_SEGMENT 0x08
 
/* AX.25 Segment control values */
#define AX25_SEG_REM 0x7F
#define AX25_SEG_FIRST 0x80
 
#define AX25_CBIT 0x80 /* Command/Response bit */
#define AX25_EBIT 0x01 /* HDLC Address Extension bit */
#define AX25_HBIT 0x80 /* Has been repeated bit */
 
#define AX25_SSSID_SPARE 0x60 /* Unused bits in SSID for standard AX.25 */
#define AX25_ESSID_SPARE 0x20 /* Unused bits in SSID for extended AX.25 */
#define AX25_DAMA_FLAG 0x20 /* Well, it is *NOT* unused! (dl1bke 951121 */
 
#define AX25_COND_ACK_PENDING 0x01
#define AX25_COND_REJECT 0x02
#define AX25_COND_PEER_RX_BUSY 0x04
#define AX25_COND_OWN_RX_BUSY 0x08
 
#ifndef _LINUX_NETDEVICE_H
#include <linux/netdevice.h>
#endif
 
/*
* These headers are taken from the KA9Q package by Phil Karn. These specific
* files have been placed under the GPL (not the whole package) by Phil.
*
*
* Copyright 1991 Phil Karn, KA9Q
*
* This program 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; version 2 dated June, 1991.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave., Cambridge, MA 02139, USA.
*/
 
/* Upper sub-layer (LAPB) definitions */
 
/* Control field templates */
#define AX25_I 0x00 /* Information frames */
#define AX25_S 0x01 /* Supervisory frames */
#define AX25_RR 0x01 /* Receiver ready */
#define AX25_RNR 0x05 /* Receiver not ready */
#define AX25_REJ 0x09 /* Reject */
#define AX25_U 0x03 /* Unnumbered frames */
#define AX25_SABM 0x2f /* Set Asynchronous Balanced Mode */
#define AX25_SABME 0x6f /* Set Asynchronous Balanced Mode Extended */
#define AX25_DISC 0x43 /* Disconnect */
#define AX25_DM 0x0f /* Disconnected mode */
#define AX25_UA 0x63 /* Unnumbered acknowledge */
#define AX25_FRMR 0x87 /* Frame reject */
#define AX25_UI 0x03 /* Unnumbered information */
 
#define AX25_PF 0x10 /* Poll/final bit for standard AX.25 */
#define AX25_EPF 0x01 /* Poll/final bit for extended AX.25 */
 
#define AX25_ILLEGAL 0x100 /* Impossible to be a real frame type */
 
#define AX25_POLLOFF 0
#define AX25_POLLON 1
 
/* AX25 L2 C-bit */
#define AX25_COMMAND 1
#define AX25_RESPONSE 2
 
/* Define Link State constants. */
 
enum {
AX25_STATE_0,
AX25_STATE_1,
AX25_STATE_2,
AX25_STATE_3,
AX25_STATE_4
};
 
#define AX25_MAX_DEVICES 20 /* Max No of AX.25 devices */
 
#define AX25_MODULUS 8 /* Standard AX.25 modulus */
#define AX25_EMODULUS 128 /* Extended AX.25 modulus */
 
enum {
AX25_VALUES_IPDEFMODE, /* 0=DG 1=VC */
AX25_VALUES_AXDEFMODE, /* 0=Normal 1=Extended Seq Nos */
AX25_VALUES_BACKOFF, /* 0=None 1=Linear 2=Exponential */
AX25_VALUES_CONMODE, /* Allow connected modes - 0=No 1=no "PID text" 2=all PIDs */
AX25_VALUES_WINDOW, /* Default window size for standard AX.25 */
AX25_VALUES_EWINDOW, /* Default window size for extended AX.25 */
AX25_VALUES_T1, /* Default T1 timeout value */
AX25_VALUES_T2, /* Default T2 timeout value */
AX25_VALUES_T3, /* Default T3 timeout value */
AX25_VALUES_IDLE, /* Connected mode idle timer */
AX25_VALUES_N2, /* Default N2 value */
AX25_VALUES_PACLEN, /* AX.25 MTU */
AX25_MAX_VALUES /* THIS MUST REMAIN THE LAST ENTRY OF THIS LIST */
};
 
#define AX25_DEF_IPDEFMODE 0 /* Datagram */
#define AX25_DEF_AXDEFMODE 0 /* Normal */
#define AX25_DEF_BACKOFF 1 /* Linear backoff */
#define AX25_DEF_CONMODE 2 /* Connected mode allowed */
#define AX25_DEF_WINDOW 2 /* Window=2 */
#define AX25_DEF_EWINDOW 32 /* Module-128 Window=32 */
#define AX25_DEF_T1 (10 * AX25_SLOWHZ) /* T1=10s */
#define AX25_DEF_T2 (3 * AX25_SLOWHZ) /* T2=3s */
#define AX25_DEF_T3 (300 * AX25_SLOWHZ) /* T3=300s */
#define AX25_DEF_N2 10 /* N2=10 */
#define AX25_DEF_IDLE (0 * 60 * AX25_SLOWHZ) /* Idle=None */
#define AX25_DEF_PACLEN 256 /* Paclen=256 */
 
typedef struct ax25_uid_assoc {
struct ax25_uid_assoc *next;
uid_t uid;
ax25_address call;
} ax25_uid_assoc;
 
typedef struct {
ax25_address calls[AX25_MAX_DIGIS];
unsigned char repeated[AX25_MAX_DIGIS];
unsigned char ndigi;
char lastrepeat;
} ax25_digi;
 
typedef struct ax25_cb {
struct ax25_cb *next;
ax25_address source_addr, dest_addr;
struct device *device;
unsigned char dama_slave, iamdigi;
unsigned char state, modulus, pidincl;
unsigned short vs, vr, va;
unsigned char condition, backoff;
unsigned char n2, n2count;
unsigned short t1, t2, t3, idle, rtt;
unsigned short t1timer, t2timer, t3timer, idletimer;
unsigned short paclen;
unsigned short fragno, fraglen;
ax25_digi *digipeat;
struct sk_buff_head write_queue;
struct sk_buff_head reseq_queue;
struct sk_buff_head ack_queue;
struct sk_buff_head frag_queue;
unsigned char window;
struct timer_list timer;
struct sock *sk; /* Backlink to socket */
} ax25_cb;
 
#ifndef _LINUX_SYSCTL_H
#include <linux/sysctl.h>
#endif
 
struct ax25_dev {
char name[20];
struct device *dev;
struct device *forward;
struct ctl_table systable[AX25_MAX_VALUES+1];
int values[AX25_MAX_VALUES];
};
 
/* af_ax25.c */
extern ax25_address null_ax25_address;
extern char *ax2asc(ax25_address *);
extern ax25_address *asc2ax(char *);
extern int ax25cmp(ax25_address *, ax25_address *);
extern ax25_cb *ax25_send_frame(struct sk_buff *, int, ax25_address *, ax25_address *, ax25_digi *, struct device *);
extern ax25_cb *ax25_find_cb(ax25_address *, ax25_address *, ax25_digi *, struct device *);
extern void ax25_destroy_socket(ax25_cb *);
extern struct device *ax25rtr_get_dev(ax25_address *);
extern int ax25_encapsulate(struct sk_buff *, struct device *, unsigned short,
void *, void *, unsigned int);
extern int ax25_rebuild_header(void *, struct device *, unsigned long, struct sk_buff *);
extern ax25_uid_assoc *ax25_uid_list;
extern int ax25_uid_policy;
extern ax25_address *ax25_findbyuid(uid_t);
extern void ax25_queue_xmit(struct sk_buff *, struct device *, int);
extern int ax25_dev_is_dama_slave(struct device *); /* dl1bke 951121 */
 
#include <net/ax25call.h>
 
/* ax25_in.c */
extern int ax25_process_rx_frame(ax25_cb *, struct sk_buff *, int, int);
 
/* ax25_out.c */
extern void ax25_output(ax25_cb *, int, struct sk_buff *);
extern void ax25_kick(ax25_cb *);
extern void ax25_transmit_buffer(ax25_cb *, struct sk_buff *, int);
extern void ax25_nr_error_recovery(ax25_cb *);
extern void ax25_establish_data_link(ax25_cb *);
extern void ax25_transmit_enquiry(ax25_cb *);
extern void ax25_enquiry_response(ax25_cb *);
extern void ax25_timeout_response(ax25_cb *);
extern void ax25_check_iframes_acked(ax25_cb *, unsigned short);
extern void dama_enquiry_response(ax25_cb *); /* dl1bke 960114 */
extern void dama_establish_data_link(ax25_cb *);
 
/* ax25_route.c */
extern struct ax25_dev ax25_device[];
extern int ax25_rt_get_info(char *, char **, off_t, int, int);
extern int ax25_cs_get_info(char *, char **, off_t, int, int);
extern int ax25_rt_autobind(ax25_cb *, ax25_address *);
extern ax25_digi *ax25_rt_find_path(ax25_address *, struct device *);
extern void ax25_rt_build_path(struct sk_buff *, ax25_address *, ax25_address *, ax25_digi *);
extern void ax25_rt_device_down(struct device *);
extern int ax25_rt_ioctl(unsigned int, void *);
extern char ax25_rt_mode_get(ax25_address *, struct device *);
extern int ax25_dev_get_value(struct device *, int);
extern void ax25_dev_device_up(struct device *);
extern void ax25_dev_device_down(struct device *);
extern int ax25_fwd_ioctl(unsigned int, struct ax25_fwd_struct *);
extern struct device *ax25_fwd_dev(struct device *);
extern void ax25_rt_free(void);
 
/* ax25_subr.c */
extern void ax25_clear_queues(ax25_cb *);
extern void ax25_frames_acked(ax25_cb *, unsigned short);
extern void ax25_requeue_frames(ax25_cb *);
extern int ax25_validate_nr(ax25_cb *, unsigned short);
extern int ax25_decode(ax25_cb *, struct sk_buff *, int *, int *, int *);
extern void ax25_send_control(ax25_cb *, int, int, int);
extern unsigned short ax25_calculate_t1(ax25_cb *);
extern void ax25_calculate_rtt(ax25_cb *);
extern unsigned char *ax25_parse_addr(unsigned char *, int, ax25_address *,
ax25_address *, ax25_digi *, int *, int *); /* dl1bke 951121 */
extern int build_ax25_addr(unsigned char *, ax25_address *, ax25_address *,
ax25_digi *, int, int);
extern int size_ax25_addr(ax25_digi *);
extern void ax25_digi_invert(ax25_digi *, ax25_digi *);
extern void ax25_return_dm(struct device *, ax25_address *, ax25_address *, ax25_digi *);
extern void ax25_dama_on(ax25_cb *); /* dl1bke 951121 */
extern void ax25_dama_off(ax25_cb *); /* dl1bke 951121 */
extern void ax25_disconnect(ax25_cb *, int);
 
/* ax25_timer.c */
extern void ax25_set_timer(ax25_cb *);
extern void ax25_t1_timeout(ax25_cb *);
extern void ax25_link_failed(ax25_cb *, int);
extern int (*ax25_protocol_function(unsigned int))(struct sk_buff *, ax25_cb *);
extern int ax25_listen_mine(ax25_address *, struct device *);
 
/* sysctl_net_ax25.c */
extern void ax25_register_sysctl(void);
extern void ax25_unregister_sysctl(void);
 
/* ... */
 
extern ax25_cb *volatile ax25_list;
 
/* support routines for modules that use AX.25, in ax25_timer.c */
extern int ax25_protocol_register(unsigned int, int (*)(struct sk_buff *, ax25_cb *));
extern void ax25_protocol_release(unsigned int);
extern int ax25_linkfail_register(void (*)(ax25_cb *, int));
extern void ax25_linkfail_release(void (*)(ax25_cb *, int));
extern int ax25_listen_register(ax25_address *, struct device *);
extern void ax25_listen_release(ax25_address *, struct device *);
extern int ax25_protocol_is_registered(unsigned int);
 
#endif
/psnap.h
0,0 → 1,7
#ifndef _NET_PSNAP_H
#define _NET_PSNAP_H
 
extern struct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
extern void unregister_snap_client(unsigned char *desc);
 
#endif
/p8022tr.h
0,0 → 1,8
#ifndef _NET_P8022TR_H
#define _NET_P8022TR_H
 
extern struct datalink_proto *register_8022tr_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
extern void unregister_8022tr_client(unsigned char type);
 
#endif
 
/ip_alias.h
0,0 → 1,23
/*
* IP_ALIAS (AF_INET) aliasing definitions.
*
*
* Version: @(#)ip_alias.h 0.50 4/20/97
*
* Author: Juan Jose Ciarlante, <jjciarla@raiz.uncu.edu.ar>
*
*
* This program 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.
*
*/
 
#ifndef _IP_ALIAS_H
#define _IP_ALIAS_H
 
extern int ip_alias_init(void);
extern int ip_alias_done(void);
 
#endif /* _IP_ALIAS_H */
/tcp.h
0,0 → 1,374
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the TCP module.
*
* Version: @(#)tcp.h 1.0.5 05/23/93
*
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* This program 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.
*/
#ifndef _TCP_H
#define _TCP_H
 
#include <linux/tcp.h>
#include <net/checksum.h>
 
/* This is for all connections with a full identity, no wildcards. */
#define TCP_HTABLE_SIZE 256
 
/* This is for listening sockets, thus all sockets which possess wildcards. */
#define TCP_LHTABLE_SIZE 32 /* Yes, really, this is all you need. */
 
/* This is for all sockets, to keep track of the local port allocations. */
#define TCP_BHTABLE_SIZE 64
 
/* tcp_ipv4.c: These need to be shared by v4 and v6 because the lookup
* and hashing code needs to work with different AF's yet
* the port space is shared.
*/
extern struct sock *tcp_established_hash[TCP_HTABLE_SIZE];
extern struct sock *tcp_listening_hash[TCP_LHTABLE_SIZE];
extern struct sock *tcp_bound_hash[TCP_BHTABLE_SIZE];
 
/* These are AF independant. */
static __inline__ int tcp_bhashfn(__u16 lport)
{
return (lport ^ (lport >> 7)) & (TCP_BHTABLE_SIZE-1);
}
 
/* Find the next port that hashes h that is larger than lport.
* If you change the hash, change this function to match, or you will
* break TCP port selection. This function must also NOT wrap around
* when the next number exceeds the largest possible port (2^16-1).
*/
static __inline__ int tcp_bhashnext(__u16 lport, __u16 h)
{
__u32 s; /* don't change this to a smaller type! */
 
s = (lport ^ (h ^ tcp_bhashfn(lport)));
if (s > lport)
return s;
s = lport + TCP_BHTABLE_SIZE;
return (s ^ (h ^ tcp_bhashfn(s)));
}
 
static __inline__ int tcp_sk_bhashfn(struct sock *sk)
{
__u16 lport = sk->num;
return tcp_bhashfn(lport);
}
 
/* These can have wildcards, don't try too hard.
* XXX deal with thousands of IP aliases for listening ports later
*/
static __inline__ int tcp_lhashfn(unsigned short num)
{
return num & (TCP_LHTABLE_SIZE - 1);
}
 
static __inline__ int tcp_sk_listen_hashfn(struct sock *sk)
{
return tcp_lhashfn(sk->num);
}
 
/* This is IPv4 specific. */
static __inline__ int tcp_hashfn(__u32 laddr, __u16 lport,
__u32 faddr, __u16 fport)
{
return ((laddr ^ lport) ^ (faddr ^ fport)) & (TCP_HTABLE_SIZE - 1);
}
 
static __inline__ int tcp_sk_hashfn(struct sock *sk)
{
__u32 laddr = sk->rcv_saddr;
__u16 lport = sk->num;
__u32 faddr = sk->daddr;
__u16 fport = sk->dummy_th.dest;
 
return tcp_hashfn(laddr, lport, faddr, fport);
}
 
/* Only those holding the sockhash lock call these two things here.
* Note the slightly gross overloading of sk->prev, AF_UNIX is the
* only other main benefactor of that member of SK, so who cares.
*/
static __inline__ void tcp_sk_bindify(struct sock *sk)
{
int hashent = tcp_sk_bhashfn(sk);
struct sock **htable = &tcp_bound_hash[hashent];
 
if((sk->bind_next = *htable) != NULL)
(*htable)->bind_pprev = &sk->bind_next;
*htable = sk;
sk->bind_pprev = htable;
}
 
static __inline__ void tcp_sk_unbindify(struct sock *sk)
{
if(sk->bind_next)
sk->bind_next->bind_pprev = sk->bind_pprev;
*(sk->bind_pprev) = sk->bind_next;
}
 
/*
* 40 is maximal IP options size
* 4 is TCP option size (MSS)
*/
#define MAX_SYN_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + 4 + MAX_HEADER + 15)
#define MAX_FIN_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
#define MAX_ACK_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
#define MAX_RESET_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
 
#define MAX_WINDOW 32767 /* Never offer a window over 32767 without using
window scaling (not yet supported). Some poor
stacks do signed 16bit maths! */
#define MIN_WINDOW 2048
#define MAX_ACK_BACKLOG 2
#define MAX_DUP_ACKS 3
#define MIN_WRITE_SPACE 2048
#define TCP_WINDOW_DIFF 2048
 
/* urg_data states */
#define URG_VALID 0x0100
#define URG_NOTYET 0x0200
#define URG_READ 0x0400
 
#define TCP_RETR1 7 /*
* This is how many retries it does before it
* tries to figure out if the gateway is
* down.
*/
 
#define TCP_RETR2 15 /*
* This should take at least
* 90 minutes to time out.
*/
 
#define TCP_TIMEOUT_LEN (15*60*HZ) /* should be about 15 mins */
#define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to successfully
* close the socket, about 60 seconds */
#define TCP_FIN_TIMEOUT (3*60*HZ) /* BSD style FIN_WAIT2 deadlock breaker */
#define TCP_ACK_TIME (3*HZ) /* time to delay before sending an ACK */
#define TCP_DONE_TIME (5*HZ/2)/* maximum time to wait before actually
* destroying a socket */
#define TCP_WRITE_TIME (30*HZ) /* initial time to wait for an ACK,
* after last transmit */
#define TCP_TIMEOUT_INIT (3*HZ) /* RFC 1122 initial timeout value */
#define TCP_SYN_RETRIES 5 /* number of times to retry opening a
* connection (TCP_RETR2-....) */
#define TCP_PROBEWAIT_LEN (1*HZ)/* time to wait between probes when
* I've got something to write and
* there is no window */
 
#define TCP_NO_CHECK 0 /* turn to one if you want the default
* to be no checksum */
 
 
/*
* TCP option
*/
#define TCPOPT_NOP 1 /* Padding */
#define TCPOPT_EOL 0 /* End of options */
#define TCPOPT_MSS 2 /* Segment size negotiating */
/*
* We don't use these yet, but they are for PAWS and big windows
*/
#define TCPOPT_WINDOW 3 /* Window scaling */
#define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */
 
 
/*
* The next routines deal with comparing 32 bit unsigned ints
* and worry about wraparound (automatic with unsigned arithmetic).
*/
 
extern __inline int before(__u32 seq1, __u32 seq2)
{
return (__s32)(seq1-seq2) < 0;
}
 
extern __inline int after(__u32 seq1, __u32 seq2)
{
return (__s32)(seq2-seq1) < 0;
}
 
 
/* is s2<=s1<=s3 ? */
extern __inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
{
return (after(seq1+1, seq2) && before(seq1, seq3+1));
}
 
static __inline__ int min(unsigned int a, unsigned int b)
{
if (a > b)
a = b;
return a;
}
 
static __inline__ int max(unsigned int a, unsigned int b)
{
if (a < b)
a = b;
return a;
}
 
extern struct proto tcp_prot;
extern struct tcp_mib tcp_statistics;
 
extern unsigned short tcp_good_socknum(void);
 
extern void tcp_err(int type, int code, unsigned char *header, __u32 daddr,
__u32, struct inet_protocol *protocol, int len);
extern void tcp_shutdown (struct sock *sk, int how);
extern int tcp_rcv(struct sk_buff *skb, struct device *dev,
struct options *opt, __u32 daddr,
unsigned short len, __u32 saddr, int redo,
struct inet_protocol *protocol);
 
extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
 
extern void tcp_v4_unhash(struct sock *sk);
 
extern void tcp_read_wakeup(struct sock *);
extern void tcp_write_xmit(struct sock *);
extern void tcp_time_wait(struct sock *);
extern void tcp_retransmit(struct sock *, int);
extern void tcp_do_retransmit(struct sock *, int);
extern void tcp_send_check(struct tcphdr *th, unsigned long saddr,
unsigned long daddr, int len, struct sk_buff *skb);
 
/* tcp_output.c */
 
extern void tcp_send_probe0(struct sock *);
extern void tcp_send_partial(struct sock *);
extern void tcp_write_wakeup(struct sock *);
extern void tcp_send_fin(struct sock *sk);
extern void tcp_send_synack(struct sock *, struct sock *, struct sk_buff *, int);
extern void tcp_send_skb(struct sock *, struct sk_buff *);
extern void tcp_send_ack(struct sock *sk);
extern void tcp_send_delayed_ack(struct sock *sk, int max_timeout, unsigned long timeout);
extern void tcp_send_reset(unsigned long saddr, unsigned long daddr, struct tcphdr *th,
struct proto *prot, struct options *opt, struct device *dev, int tos, int ttl);
 
extern void tcp_enqueue_partial(struct sk_buff *, struct sock *);
extern struct sk_buff * tcp_dequeue_partial(struct sock *);
extern void tcp_shrink_skb(struct sock *,struct sk_buff *,u32);
 
/* CONFIG_IP_TRANSPARENT_PROXY */
extern int tcp_chkaddr(struct sk_buff *);
 
/* tcp_timer.c */
#define tcp_reset_msl_timer(x,y,z) reset_timer(x,y,z)
extern void tcp_reset_xmit_timer(struct sock *, int, unsigned long);
extern void tcp_delack_timer(unsigned long);
extern void tcp_retransmit_timer(unsigned long);
 
static __inline__ int tcp_old_window(struct sock * sk)
{
return sk->window - (sk->acked_seq - sk->lastwin_seq);
}
 
extern int tcp_new_window(struct sock *);
 
/*
* Return true if we should raise the window when we
* have cleaned up the receive queue. We don't want to
* do this normally, only if it makes sense to avoid
* zero window probes..
*
* We do this only if we can raise the window noticeably.
*/
static __inline__ int tcp_raise_window(struct sock * sk)
{
int new = tcp_new_window(sk);
return new && (new >= 2*tcp_old_window(sk));
}
 
static __inline__ unsigned short tcp_select_window(struct sock *sk)
{
int window = tcp_new_window(sk);
int oldwin = tcp_old_window(sk);
 
/* Don't allow a shrinking window */
if (window > oldwin) {
sk->window = window;
sk->lastwin_seq = sk->acked_seq;
oldwin = window;
}
return oldwin;
}
 
/*
* List all states of a TCP socket that can be viewed as a "connected"
* state. This now includes TCP_SYN_RECV, although I am not yet fully
* convinced that this is the solution for the 'getpeername(2)'
* problem. Thanks to Stephen A. Wood <saw@cebaf.gov> -FvK
*/
 
extern __inline const int tcp_connected(const int state)
{
return(state == TCP_ESTABLISHED || state == TCP_CLOSE_WAIT ||
state == TCP_FIN_WAIT1 || state == TCP_FIN_WAIT2 ||
state == TCP_SYN_RECV);
}
 
/*
* Calculate(/check) TCP checksum
*/
static __inline__ u16 tcp_check(struct tcphdr *th, int len,
unsigned long saddr, unsigned long daddr, unsigned long base)
{
return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
}
 
#undef STATE_TRACE
 
#ifdef STATE_TRACE
static char *statename[]={
"Unused","Established","Syn Sent","Syn Recv",
"Fin Wait 1","Fin Wait 2","Time Wait", "Close",
"Close Wait","Last ACK","Listen","Closing"
};
#endif
 
static __inline__ void tcp_set_state(struct sock *sk, int state)
{
int oldstate = sk->state;
 
sk->state = state;
 
#ifdef STATE_TRACE
if(sk->debug)
printk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
#endif
 
switch (state) {
case TCP_ESTABLISHED:
if (oldstate != TCP_ESTABLISHED) {
tcp_statistics.TcpCurrEstab++;
}
break;
 
case TCP_CLOSE:
/* Preserve the invariant */
tcp_v4_unhash(sk);
/* Should be about 2 rtt's */
reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
/* fall through */
default:
if (oldstate==TCP_ESTABLISHED)
tcp_statistics.TcpCurrEstab--;
}
}
 
#endif /* _TCP_H */
/icmp.h
0,0 → 1,43
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the ICMP module.
*
* Version: @(#)icmp.h 1.0.4 05/13/93
*
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* This program 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.
*/
#ifndef _ICMP_H
#define _ICMP_H
 
#include <linux/icmp.h>
#include <linux/skbuff.h>
 
#include <net/sock.h>
#include <net/protocol.h>
 
extern struct icmp_err icmp_err_convert[];
extern struct icmp_mib icmp_statistics;
 
extern void icmp_send(struct sk_buff *skb_in, int type, int code,
unsigned long info, struct device *dev);
extern int icmp_rcv(struct sk_buff *skb1, struct device *dev,
struct options *opt, __u32 daddr,
unsigned short len, __u32 saddr,
int redo, struct inet_protocol *protocol);
extern int icmp_ioctl(struct sock *sk, int cmd,
unsigned long arg);
extern void icmp_init(struct proto_ops *ops);
 
/* CONFIG_IP_TRANSPARENT_PROXY */
extern int icmp_chkaddr(struct sk_buff *skb);
 
#endif /* _ICMP_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.