diff options
| author | Thomas Bushnell <thomas@gnu.org> | 1999-04-26 05:58:44 +0000 |
|---|---|---|
| committer | Thomas Bushnell <thomas@gnu.org> | 1999-04-26 05:58:44 +0000 |
| commit | 86297c41a26f18d924e64fc93321c59cbc4c48dd (patch) | |
| tree | 376954c6b95b735d361875319a1a2a9db6a27527 /linux/src/include/net | |
| parent | 851137902d3e7ad87af177487df3eea53e940a1c (diff) | |
1998-11-30 OKUJI Yoshinori <okuji@kuicr.kyoto-u.ac.jp>
Clean up linux emulation code to make it architecture-independent
as much as possible.
* linux: Renamed from linuxdev.
* Makefile.in (objfiles): Add linux.o instead of linuxdev.o.
(MAKE): New variable. Used for the linux.o target.
* configure.in: Add AC_CHECK_TOOL(MAKE, make).
* i386/i386/spl.h: Include <i386/ipl.h>, for compatibility with
OSF Mach 3.0. Suggested by Elgin Lee <ehl@funghi.com>.
* linux/src: Renamed from linux/linux.
* linux/dev: Renamed from linux/mach.
* linux/Drivers.in (AC_INIT): Use dev/include/linux/autoconf.h,
instead of mach/include/linux/autoconf.h.
* Makefile.in (all): Target ../linux.o instead of ../linuxdev.o.
* linux/dev/drivers/block/genhd.c: Include <machine/spl.h> instead
of <i386/ipl.h>.
* linux/dev/drivers/net/auto_irq.c: Remove unneeded header files,
<i386/ipl.h> and <i386/pic.h>.
* linux/dev/init/main.c: Many i386-dependent codes moved to ...
* linux/dev/arch/i386/irq.c: ... here.
* linux/dev/arch/i386/setup.c: New file.
* linux/dev/arch/i386/linux_emul.h: Likewise.
* linux/dev/arch/i386/glue/timer.c: Merged into sched.c.
* linux/dev/arch/i386/glue/sched.c: Include <machine/spl.h> instead
of <i386/ipl.h>, and moved to ...
* linux/dev/kernel/sched.c: ... here.
* linux/dev/arch/i386/glue/block.c: Include <machine/spl.h> and
<linux_emul.h>, instead of i386-dependent header files, and
moved to ...
* linux/dev/glue/blocl.c: ... here.
* linux/dev/arch/i386/glue/net.c: Include <machine/spl.h> and
<linux_emul.h>, instead of i386-dependent header files, and
moved to ...
* linux/dev/glue/net.c: ... here.
* linux/dev/arch/i386/glue/misc.c: Remove `x86' and moved to ...
* linux/dev/glue/misc.c: ... here.
* linux/dev/arch/i386/glue/kmem.c: Moved to ...
* linux/dev/glue/kmem.c: ... here.
Diffstat (limited to 'linux/src/include/net')
39 files changed, 3371 insertions, 0 deletions
diff --git a/linux/src/include/net/af_unix.h b/linux/src/include/net/af_unix.h new file mode 100644 index 0000000..86b0e1e --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/arp.h b/linux/src/include/net/arp.h new file mode 100644 index 0000000..db7a29c --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/atalkcall.h b/linux/src/include/net/atalkcall.h new file mode 100644 index 0000000..726e33c --- /dev/null +++ b/linux/src/include/net/atalkcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void atalk_proto_init(struct net_proto *pro); diff --git a/linux/src/include/net/ax25.h b/linux/src/include/net/ax25.h new file mode 100644 index 0000000..fce33cf --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/ax25call.h b/linux/src/include/net/ax25call.h new file mode 100644 index 0000000..68b8a70 --- /dev/null +++ b/linux/src/include/net/ax25call.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void ax25_proto_init(struct net_proto *pro); diff --git a/linux/src/include/net/br.h b/linux/src/include/net/br.h new file mode 100644 index 0000000..f1d6678 --- /dev/null +++ b/linux/src/include/net/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; + diff --git a/linux/src/include/net/checksum.h b/linux/src/include/net/checksum.h new file mode 100644 index 0000000..aee4fd4 --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/datalink.h b/linux/src/include/net/datalink.h new file mode 100644 index 0000000..44e5699 --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/gc.h b/linux/src/include/net/gc.h new file mode 100644 index 0000000..0b28c09 --- /dev/null +++ b/linux/src/include/net/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); + diff --git a/linux/src/include/net/icmp.h b/linux/src/include/net/icmp.h new file mode 100644 index 0000000..fa770d2 --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/ip.h b/linux/src/include/net/ip.h new file mode 100644 index 0000000..5437b3d --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/ip_alias.h b/linux/src/include/net/ip_alias.h new file mode 100644 index 0000000..ee9aa33 --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/ip_forward.h b/linux/src/include/net/ip_forward.h new file mode 100644 index 0000000..f1b532f --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/ip_masq.h b/linux/src/include/net/ip_masq.h new file mode 100644 index 0000000..ccfb646 --- /dev/null +++ b/linux/src/include/net/ip_masq.h @@ -0,0 +1,205 @@ +/* + * 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 */ +}; + +/* + * 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 */ diff --git a/linux/src/include/net/ipip.h b/linux/src/include/net/ipip.h new file mode 100644 index 0000000..bba1492 --- /dev/null +++ b/linux/src/include/net/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); + diff --git a/linux/src/include/net/ipx.h b/linux/src/include/net/ipx.h new file mode 100644 index 0000000..13d3dbb --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/ipxcall.h b/linux/src/include/net/ipxcall.h new file mode 100644 index 0000000..eb5bd2b --- /dev/null +++ b/linux/src/include/net/ipxcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void ipx_proto_init(struct net_proto *pro); diff --git a/linux/src/include/net/netlink.h b/linux/src/include/net/netlink.h new file mode 100644 index 0000000..0d7cf3f --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/netrom.h b/linux/src/include/net/netrom.h new file mode 100644 index 0000000..0920f8d --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/nrcall.h b/linux/src/include/net/nrcall.h new file mode 100644 index 0000000..09ee699 --- /dev/null +++ b/linux/src/include/net/nrcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void nr_proto_init(struct net_proto *pro); diff --git a/linux/src/include/net/p8022.h b/linux/src/include/net/p8022.h new file mode 100644 index 0000000..03d7c3d --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/p8022call.h b/linux/src/include/net/p8022call.h new file mode 100644 index 0000000..14f0c2c --- /dev/null +++ b/linux/src/include/net/p8022call.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of Space.c simpler */ +extern void p8022_proto_init(struct net_proto *); diff --git a/linux/src/include/net/p8022tr.h b/linux/src/include/net/p8022tr.h new file mode 100644 index 0000000..f4231ec --- /dev/null +++ b/linux/src/include/net/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 + diff --git a/linux/src/include/net/p8022trcall.h b/linux/src/include/net/p8022trcall.h new file mode 100644 index 0000000..3ce6f3c --- /dev/null +++ b/linux/src/include/net/p8022trcall.h @@ -0,0 +1,3 @@ +/* Separate to keep compilation of Space.c simpler */ +extern void p8022tr_proto_init(struct net_proto *); + diff --git a/linux/src/include/net/protocol.h b/linux/src/include/net/protocol.h new file mode 100644 index 0000000..c21f845 --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/psnap.h b/linux/src/include/net/psnap.h new file mode 100644 index 0000000..49a68f7 --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/psnapcall.h b/linux/src/include/net/psnapcall.h new file mode 100644 index 0000000..9da5763 --- /dev/null +++ b/linux/src/include/net/psnapcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of Space.c simpler */ +extern void snap_proto_init(struct net_proto *); diff --git a/linux/src/include/net/rarp.h b/linux/src/include/net/rarp.h new file mode 100644 index 0000000..7bfb08e --- /dev/null +++ b/linux/src/include/net/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 */ + diff --git a/linux/src/include/net/raw.h b/linux/src/include/net/raw.h new file mode 100644 index 0000000..5b2f97f --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/rose.h b/linux/src/include/net/rose.h new file mode 100644 index 0000000..e868e51 --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/rosecall.h b/linux/src/include/net/rosecall.h new file mode 100644 index 0000000..5bbe69c --- /dev/null +++ b/linux/src/include/net/rosecall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void rose_proto_init(struct net_proto *pro); diff --git a/linux/src/include/net/route.h b/linux/src/include/net/route.h new file mode 100644 index 0000000..7bf32d0 --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/slhc.h b/linux/src/include/net/slhc.h new file mode 100644 index 0000000..c7b39db --- /dev/null +++ b/linux/src/include/net/slhc.h @@ -0,0 +1,6 @@ +#ifndef __NET_SLHC_H +#define __NET_SLHC_H + +extern void slhc_install(void); + +#endif diff --git a/linux/src/include/net/slhc_vj.h b/linux/src/include/net/slhc_vj.h new file mode 100644 index 0000000..471cf71 --- /dev/null +++ b/linux/src/include/net/slhc_vj.h @@ -0,0 +1,187 @@ +#ifndef _SLHC_H +#define _SLHC_H +/* + * Definitions for tcp compression routines. + * + * $Header: cvs/gnumach/linux/src/include/net/Attic/slhc_vj.h,v 1.1 1999/04/26 05:57:54 tb 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 */ diff --git a/linux/src/include/net/snmp.h b/linux/src/include/net/snmp.h new file mode 100644 index 0000000..552292b --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/sock.h b/linux/src/include/net/sock.h new file mode 100644 index 0000000..7a3ec03 --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/spx.h b/linux/src/include/net/spx.h new file mode 100644 index 0000000..3e9b1d1 --- /dev/null +++ b/linux/src/include/net/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 diff --git a/linux/src/include/net/tcp.h b/linux/src/include/net/tcp.h new file mode 100644 index 0000000..b2534ba --- /dev/null +++ b/linux/src/include/net/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 */ diff --git a/linux/src/include/net/udp.h b/linux/src/include/net/udp.h new file mode 100644 index 0000000..d2c7476 --- /dev/null +++ b/linux/src/include/net/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 */ |