summaryrefslogtreecommitdiffstats
path: root/drivers/net/strip.c
diff options
context:
space:
mode:
authorRalf Baechle <ralf@linux-mips.org>1997-01-07 02:33:00 +0000
committer <ralf@linux-mips.org>1997-01-07 02:33:00 +0000
commitbeb116954b9b7f3bb56412b2494b562f02b864b1 (patch)
tree120e997879884e1b9d93b265221b939d2ef1ade1 /drivers/net/strip.c
parent908d4681a1dc3792ecafbe64265783a86c4cccb6 (diff)
Import of Linux/MIPS 2.1.14
Diffstat (limited to 'drivers/net/strip.c')
-rw-r--r--drivers/net/strip.c2827
1 files changed, 2827 insertions, 0 deletions
diff --git a/drivers/net/strip.c b/drivers/net/strip.c
new file mode 100644
index 000000000..a09e0b9ae
--- /dev/null
+++ b/drivers/net/strip.c
@@ -0,0 +1,2827 @@
+/*
+ * Copyright 1996 The Board of Trustees of The Leland Stanford
+ * Junior University. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies. Stanford University
+ * makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without
+ * express or implied warranty.
+ *
+ * strip.c This module implements Starmode Radio IP (STRIP)
+ * for kernel-based devices like TTY. It interfaces between a
+ * raw TTY, and the kernel's INET protocol layers (via DDI).
+ *
+ * Version: @(#)strip.c 0.9.8 June 1996
+ *
+ * Author: Stuart Cheshire <cheshire@cs.stanford.edu>
+ *
+ * Fixes: v0.9 12th Feb 1996.
+ * New byte stuffing (2+6 run-length encoding)
+ * New watchdog timer task
+ * New Protocol key (SIP0)
+ *
+ * v0.9.1 3rd March 1996
+ * Changed to dynamic device allocation -- no more compile
+ * time (or boot time) limit on the number of STRIP devices.
+ *
+ * v0.9.2 13th March 1996
+ * Uses arp cache lookups (but doesn't send arp packets yet)
+ *
+ * v0.9.3 17th April 1996
+ * Fixed bug where STR_ERROR flag was getting set unneccessarily
+ *
+ * v0.9.4 27th April 1996
+ * First attempt at using "&COMMAND" Starmode AT commands
+ *
+ * v0.9.5 29th May 1996
+ * First attempt at sending (unicast) ARP packets
+ *
+ * v0.9.6 5th June 1996
+ * Elliot put "message level" tags in every "printk" statement
+ *
+ * v0.9.7 13th June 1996
+ * Added support for the /proc fs (laik)
+ *
+ * v0.9.8 July 1996
+ * Added packet logging (Mema)
+ */
+
+/*
+ * Undefine this symbol if you don't have PROC_NET_STRIP_STATUS
+ * defined in include/linux/proc_fs.h
+ */
+
+#define DO_PROC_NET_STRIP_STATUS 1
+
+/*
+ * Define this symbol if you want to enable STRIP packet tracing.
+ */
+
+#define DO_PROC_NET_STRIP_TRACE 0
+
+
+/************************************************************************/
+/* Header files */
+
+#include <linux/config.h>
+
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#endif
+
+#include <stdlib.h>
+#include <asm/system.h>
+#include <asm/uaccess.h>
+#include <asm/bitops.h>
+
+/*
+ * isdigit() and isspace() use the ctype[] array, which is not available
+ * to kernel modules. If compiling as a module, use a local definition
+ * of isdigit() and isspace() until _ctype is added to ksyms.
+ */
+#ifdef MODULE
+# define isdigit(c) ('0' <= (c) && (c) <= '9')
+# define isspace(c) ((c) == ' ' || (c) == '\t')
+#else
+# include <linux/ctype.h>
+#endif
+
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/in.h>
+#include <linux/tty.h>
+#include <linux/errno.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/if_arp.h>
+#include <linux/if_strip.h>
+#include <linux/proc_fs.h>
+#include <net/arp.h>
+
+#ifdef CONFIG_INET
+#include <linux/ip.h>
+#include <linux/tcp.h>
+#include <linux/time.h>
+#endif
+
+
+/************************************************************************/
+/* Useful structures and definitions */
+
+/*
+ * A MetricomKey identifies the protocol being carried inside a Metricom
+ * Starmode packet.
+ */
+
+typedef union
+{
+ __u8 c[4];
+ __u32 l;
+} MetricomKey;
+
+/*
+ * An IP address can be viewed as four bytes in memory (which is what it is) or as
+ * a single 32-bit long (which is convenient for assignment, equality testing etc.)
+ */
+
+typedef union
+{
+ __u8 b[4];
+ __u32 l;
+} IPaddr;
+
+/*
+ * A MetricomAddressString is used to hold a printable representation of
+ * a Metricom address.
+ */
+
+typedef struct
+{
+ __u8 c[24];
+} MetricomAddressString;
+
+/*
+ * Note: A Metricom packet looks like this: *<address>*<key><payload><CR>
+ * eg. *0000-1234*SIP0<payload><CR>
+ * A STRIP_Header is never really sent over the radio, but making a dummy header
+ * for internal use within the kernel that looks like an Ethernet header makes
+ * certain other software happier. For example, tcpdump already understands
+ * Ethernet headers.
+ */
+
+typedef struct
+{
+ MetricomAddress dst_addr; /* Destination address, e.g. "0000-1234" */
+ MetricomAddress src_addr; /* Source address, e.g. "0000-5678" */
+ unsigned short protocol; /* The protocol type, using Ethernet codes */
+} STRIP_Header;
+
+typedef struct GeographicLocation
+{
+ char s[18];
+} GeographicLocation;
+
+typedef enum {
+ NodeValid = 0x1,
+ NodeHasWAN = 0x2,
+ NodeIsRouter = 0x4
+} NodeType;
+
+typedef struct MetricomNode
+{
+ NodeType type; /* Some flags about the type of node */
+ GeographicLocation gl; /* The location of the node. */
+ MetricomAddress addr; /* The metricom address of this node */
+ int poll_latency; /* The latency to poll that node ? */
+ int rssi; /* The Receiver Signal Strength Indicator */
+ struct MetricomNode *next; /* The next node */
+} MetricomNode;
+
+enum { FALSE = 0, TRUE = 1 };
+
+/*
+ * Holds the packet signature for an IP packet.
+ */
+typedef struct
+{
+ IPaddr src;
+ /* Data is stored in the following field in network byte order. */
+ __u16 id;
+} IPSignature;
+
+/*
+ * Holds the packet signature for an ARP packet.
+ */
+typedef struct
+{
+ IPaddr src;
+ /* Data is stored in the following field in network byte order. */
+ __u16 op;
+} ARPSignature;
+
+/*
+ * Holds the signature of a packet.
+ */
+typedef union
+{
+ IPSignature ip_sig;
+ ARPSignature arp_sig;
+ __u8 print_sig[6];
+} PacketSignature;
+
+typedef enum {
+ EntrySend = 0,
+ EntryReceive = 1
+} LogEntry;
+
+/* Structure for Packet Logging */
+typedef struct stripLog
+{
+ LogEntry entry_type;
+ u_long seqNum;
+ int packet_type;
+ PacketSignature sig;
+ MetricomAddress src;
+ MetricomAddress dest;
+ struct timeval timeStamp;
+ u_long rawSize;
+ u_long stripSize;
+ u_long slipSize;
+ u_long valid;
+} StripLog;
+
+#define ENTRY_TYPE_TO_STRING(X) ((X) ? "r" : "s")
+
+#define BOOLEAN_TO_STRING(X) ((X) ? "true" : "false")
+
+/*
+ * Holds the radio's firmware version.
+ */
+typedef struct
+{
+ char c[50];
+} MetricomFirmwareVersion;
+
+/*
+ * Holds the radio's serial number.
+ */
+typedef struct
+{
+ char c[18];
+} MetricomSerialNumber;
+
+/*
+ * Holds the radio's battery voltage.
+ */
+typedef struct
+{
+ char c[11];
+} MetricomBatteryVoltage;
+
+struct strip
+{
+ int magic;
+ /*
+ * These are pointers to the malloc()ed frame buffers.
+ */
+
+ unsigned char *rx_buff; /* buffer for received IP packet*/
+ unsigned char *sx_buff; /* buffer for received serial data*/
+ int sx_count; /* received serial data counter */
+ int sx_size; /* Serial buffer size */
+ unsigned char *tx_buff; /* transmitter buffer */
+ unsigned char *tx_head; /* pointer to next byte to XMIT */
+ int tx_left; /* bytes left in XMIT queue */
+ int tx_size; /* Serial buffer size */
+
+ /*
+ * STRIP interface statistics.
+ */
+
+ unsigned long rx_packets; /* inbound frames counter */
+ unsigned long tx_packets; /* outbound frames counter */
+ unsigned long rx_errors; /* Parity, etc. errors */
+ unsigned long tx_errors; /* Planned stuff */
+ unsigned long rx_dropped; /* No memory for skb */
+ unsigned long tx_dropped; /* When MTU change */
+ unsigned long rx_over_errors; /* Frame bigger then STRIP buf. */
+
+ /*
+ * Internal variables.
+ */
+
+ struct strip *next; /* The next struct in the list */
+ struct strip **referrer; /* The pointer that points to us*/
+ int discard; /* Set if serial error */
+ int working; /* Is radio working correctly? */
+ int structured_messages; /* Parsable AT response msgs? */
+ int mtu; /* Our mtu (to spot changes!) */
+ long watchdog_doprobe; /* Next time to test the radio */
+ long watchdog_doreset; /* Time to do next reset */
+ long gratuitous_arp; /* Time to send next ARP refresh*/
+ long arp_interval; /* Next ARP interval */
+ struct timer_list idle_timer; /* For periodic wakeup calls */
+ MetricomNode *neighbor_list; /* The list of neighbor nodes */
+ int neighbor_list_locked; /* Indicates the list is locked */
+ MetricomFirmwareVersion firmware_version; /* The radio's firmware version */
+ MetricomSerialNumber serial_number; /* The radio's serial number */
+ MetricomBatteryVoltage battery_voltage; /* The radio's battery voltage */
+
+ /*
+ * Other useful structures.
+ */
+
+ struct tty_struct *tty; /* ptr to TTY structure */
+ char if_name[8]; /* Dynamically generated name */
+ struct device dev; /* Our device structure */
+
+ /*
+ * Packet Logging Structures.
+ */
+
+ u_long num_sent;
+ u_long num_received;
+
+ int next_entry; /* The index of the oldest packet; */
+ /* Also the next to be logged. */
+ StripLog packetLog[610];
+};
+
+
+/************************************************************************/
+/* Constants */
+
+#ifdef MODULE
+static const char StripVersion[] = "0.9.8-STUART.CHESHIRE-MODULAR";
+#else
+static const char StripVersion[] = "0.9.8-STUART.CHESHIRE";
+#endif
+
+static const char TickleString1[] = "***&COMMAND*ATS305?\r";
+static const char TickleString2[] = "***&COMMAND*ATS305?\r\r"
+ "*&COMMAND*ATS300?\r\r*&COMMAND*ATS325?\r\r*&COMMAND*AT~I2 nn\r\r";
+
+static const char hextable[16] = "0123456789ABCDEF";
+
+static const MetricomAddress zero_address;
+static const MetricomAddress broadcast_address = { { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF } };
+
+static const MetricomKey SIP0Key = { { "SIP0" } };
+static const MetricomKey ARP0Key = { { "ARP0" } };
+static const MetricomKey ERR_Key = { { "ERR_" } };
+static const MetricomKey ATR_Key = { { "ATR " } };
+
+static const long MaxARPInterval = 60 * HZ; /* One minute */
+
+/*
+ * Maximum Starmode packet length (including starmode address) is 1183 bytes.
+ * Allowing 32 bytes for header, and 65/64 expansion for STRIP encoding,
+ * that translates to a maximum payload MTU of 1132.
+ */
+static const unsigned short MAX_STRIP_MTU = 1132;
+static const unsigned short DEFAULT_STRIP_MTU = 1024;
+static const int STRIP_MAGIC = 0x5303;
+static const long LongTime = 0x7FFFFFFF;
+
+static const int STRIP_NODE_LEN = 64;
+static const char STRIP_PORTABLE_CHAR = 'P';
+static const char STRIP_ROUTER_CHAR = 'r';
+static const int STRIP_PROC_BUFFER_SIZE = 4096;
+static const int STRIP_LOG_INT_SIZE = 10;
+
+/************************************************************************/
+/* Global variables */
+
+static struct strip *struct_strip_list = NULL;
+
+
+/************************************************************************/
+/* Macros */
+
+#define READHEX(X) ((X)>='0' && (X)<='9' ? (X)-'0' : \
+ (X)>='a' && (X)<='f' ? (X)-'a'+10 : \
+ (X)>='A' && (X)<='F' ? (X)-'A'+10 : 0 )
+
+#define READDEC(X) ((X)>='0' && (X)<='9' ? (X)-'0' : 0)
+
+#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
+#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
+#define ELEMENTS_OF(X) (sizeof(X) / sizeof((X)[0]))
+#define ARRAY_END(X) (&((X)[ELEMENTS_OF(X)]))
+
+/* Encapsulation can expand packet of size x to 65/64x + 1 */
+/* Sent packet looks like "*<address>*<key><encaps payload><CR>" */
+/* 1 1-18 1 4 ? 1 */
+/* We allow 31 bytes for the stars, the key, the address and the <CR> */
+#define STRIP_ENCAP_SIZE(X) (32 + (X)*65L/64L)
+
+#define IS_RADIO_ADDRESS(p) ( \
+ isdigit((p)[0]) && isdigit((p)[1]) && isdigit((p)[2]) && isdigit((p)[3]) && \
+ (p)[4] == '-' && \
+ isdigit((p)[5]) && isdigit((p)[6]) && isdigit((p)[7]) && isdigit((p)[8]) )
+
+#define JIFFIE_TO_SEC(X) ((X) / HZ)
+
+
+/************************************************************************/
+/* Utility routines */
+
+typedef unsigned long InterruptStatus;
+
+extern __inline__ InterruptStatus DisableInterrupts(void)
+{
+ InterruptStatus x;
+ save_flags(x);
+ cli();
+ return(x);
+}
+
+extern __inline__ void RestoreInterrupts(InterruptStatus x)
+{
+ restore_flags(x);
+}
+
+static void DumpData(char *msg, struct strip *strip_info, __u8 *ptr, __u8 *end)
+{
+ static const int MAX_DumpData = 80;
+ __u8 pkt_text[MAX_DumpData], *p = pkt_text;
+
+ *p++ = '\"';
+
+ while (ptr<end && p < &pkt_text[MAX_DumpData-4])
+ {
+ if (*ptr == '\\')
+ {
+ *p++ = '\\';
+ *p++ = '\\';
+ }
+ else
+ {
+ if (*ptr >= 32 && *ptr <= 126)
+ {
+ *p++ = *ptr;
+ }
+ else
+ {
+ sprintf(p, "\\%02X", *ptr);
+ p+= 3;
+ }
+ }
+ ptr++;
+ }
+
+ if (ptr == end)
+ {
+ *p++ = '\"';
+ }
+
+ *p++ = 0;
+
+ printk(KERN_INFO "%s: %-13s%s\n", strip_info->dev.name, msg, pkt_text);
+}
+
+#if 0
+static void HexDump(char *msg, struct strip *strip_info, __u8 *start, __u8 *end)
+{
+ __u8 *ptr = start;
+ printk(KERN_INFO "%s: %s: %d bytes\n", strip_info->dev.name, msg, end-ptr);
+
+ while (ptr < end)
+ {
+ long offset = ptr - start;
+ __u8 text[80], *p = text;
+ while (ptr < end && p < &text[16*3])
+ {
+ *p++ = hextable[*ptr >> 4];
+ *p++ = hextable[*ptr++ & 0xF];
+ *p++ = ' ';
+ }
+ p[-1] = 0;
+ printk(KERN_INFO "%s: %4lX %s\n", strip_info->dev.name, offset, text);
+ }
+}
+#endif
+
+
+/************************************************************************/
+/* Byte stuffing/unstuffing routines */
+
+/* Stuffing scheme:
+ * 00 Unused (reserved character)
+ * 01-3F Run of 2-64 different characters
+ * 40-7F Run of 1-64 different characters plus a single zero at the end
+ * 80-BF Run of 1-64 of the same character
+ * C0-FF Run of 1-64 zeroes (ASCII 0)
+ */
+
+typedef enum
+{
+ Stuff_Diff = 0x00,
+ Stuff_DiffZero = 0x40,
+ Stuff_Same = 0x80,
+ Stuff_Zero = 0xC0,
+ Stuff_NoCode = 0xFF, /* Special code, meaning no code selected */
+
+ Stuff_CodeMask = 0xC0,
+ Stuff_CountMask = 0x3F,
+ Stuff_MaxCount = 0x3F,
+ Stuff_Magic = 0x0D /* The value we are eliminating */
+} StuffingCode;
+
+/* StuffData encodes the data starting at "src" for "length" bytes.
+ * It writes it to the buffer pointed to by "dst" (which must be at least
+ * as long as 1 + 65/64 of the input length). The output may be up to 1.6%
+ * larger than the input for pathological input, but will usually be smaller.
+ * StuffData returns the new value of the dst pointer as its result.
+ * "code_ptr_ptr" points to a "__u8 *" which is used to hold encoding state
+ * between calls, allowing an encoded packet to be incrementally built up
+ * from small parts. On the first call, the "__u8 *" pointed to should be
+ * initialized to NULL; between subsequent calls the calling routine should
+ * leave the value alone and simply pass it back unchanged so that the
+ * encoder can recover its current state.
+ */
+
+#define StuffData_FinishBlock(X) \
+(*code_ptr = (X) ^ Stuff_Magic, code = Stuff_NoCode)
+
+static __u8 *StuffData(__u8 *src, __u32 length, __u8 *dst, __u8 **code_ptr_ptr)
+{
+ __u8 *end = src + length;
+ __u8 *code_ptr = *code_ptr_ptr;
+ __u8 code = Stuff_NoCode, count = 0;
+
+ if (!length)
+ return(dst);
+
+ if (code_ptr)
+ {
+ /*
+ * Recover state from last call, if applicable
+ */
+ code = (*code_ptr ^ Stuff_Magic) & Stuff_CodeMask;
+ count = (*code_ptr ^ Stuff_Magic) & Stuff_CountMask;
+ }
+
+ while (src < end)
+ {
+ switch (code)
+ {
+ /* Stuff_NoCode: If no current code, select one */
+ case Stuff_NoCode:
+ /* Record where we're going to put this code */
+ code_ptr = dst++;
+ count = 0; /* Reset the count (zero means one instance) */
+ /* Tentatively start a new block */
+ if (*src == 0)
+ {
+ code = Stuff_Zero;
+ src++;
+ }
+ else
+ {
+ code = Stuff_Same;
+ *dst++ = *src++ ^ Stuff_Magic;
+ }
+ /* Note: We optimistically assume run of same -- */
+ /* which will be fixed later in Stuff_Same */
+ /* if it turns out not to be true. */
+ break;
+
+ /* Stuff_Zero: We already have at least one zero encoded */
+ case Stuff_Zero:
+ /* If another zero, count it, else finish this code block */
+ if (*src == 0)
+ {
+ count++;
+ src++;
+ }
+ else
+ {
+ StuffData_FinishBlock(Stuff_Zero + count);
+ }
+ break;
+
+ /* Stuff_Same: We already have at least one byte encoded */
+ case Stuff_Same:
+ /* If another one the same, count it */
+ if ((*src ^ Stuff_Magic) == code_ptr[1])
+ {
+ count++;
+ src++;
+ break;
+ }
+ /* else, this byte does not match this block. */
+ /* If we already have two or more bytes encoded, finish this code block */
+ if (count)
+ {
+ StuffData_FinishBlock(Stuff_Same + count);
+ break;
+ }
+ /* else, we only have one so far, so switch to Stuff_Diff code */
+ code = Stuff_Diff;
+ /* and fall through to Stuff_Diff case below */
+
+ /* Stuff_Diff: We have at least two *different* bytes encoded */
+ case Stuff_Diff:
+ /* If this is a zero, must encode a Stuff_DiffZero, and begin a new block */
+ if (*src == 0)
+ {
+ StuffData_FinishBlock(Stuff_DiffZero + count);
+ }
+ /* else, if we have three in a row, it is worth starting a Stuff_Same block */
+ else if ((*src ^ Stuff_Magic)==dst[-1] && dst[-1]==dst[-2])
+ {
+ /* Back off the last two characters we encoded */
+ code += count-2;
+ /* Note: "Stuff_Diff + 0" is an illegal code */
+ if (code == Stuff_Diff + 0)
+ {
+ code = Stuff_Same + 0;
+ }
+ StuffData_FinishBlock(code);
+ code_ptr = dst-2;
+ /* dst[-1] already holds the correct value */
+ count = 2; /* 2 means three bytes encoded */
+ code = Stuff_Same;
+ }
+ /* else, another different byte, so add it to the block */
+ else
+ {
+ *dst++ = *src ^ Stuff_Magic;
+ count++;
+ }
+ src++; /* Consume the byte */
+ break;
+ }
+ if (count == Stuff_MaxCount)
+ {
+ StuffData_FinishBlock(code + count);
+ }
+ }
+ if (code == Stuff_NoCode)
+ {
+ *code_ptr_ptr = NULL;
+ }
+ else
+ {
+ *code_ptr_ptr = code_ptr;
+ StuffData_FinishBlock(code + count);
+ }
+ return(dst);
+}
+
+/*
+ * UnStuffData decodes the data at "src", up to (but not including) "end".
+ * It writes the decoded data into the buffer pointed to by "dst", up to a
+ * maximum of "dst_length", and returns the new value of "src" so that a
+ * follow-on call can read more data, continuing from where the first left off.
+ *
+ * There are three types of results:
+ * 1. The source data runs out before extracting "dst_length" bytes:
+ * UnStuffData returns NULL to indicate failure.
+ * 2. The source data produces exactly "dst_length" bytes:
+ * UnStuffData returns new_src = end to indicate that all bytes were consumed.
+ * 3. "dst_length" bytes are extracted, with more remaining.
+ * UnStuffData returns new_src < end to indicate that there are more bytes
+ * to be read.
+ *
+ * Note: The decoding may be destructive, in that it may alter the source
+ * data in the process of decoding it (this is necessary to allow a follow-on
+ * call to resume correctly).
+ */
+
+static __u8 *UnStuffData(__u8 *src, __u8 *end, __u8 *dst, __u32 dst_length)
+{
+ __u8 *dst_end = dst + dst_length;
+ /* Sanity check */
+ if (!src || !end || !dst || !dst_length)
+ return(NULL);
+ while (src < end && dst < dst_end)
+ {
+ int count = (*src ^ Stuff_Magic) & Stuff_CountMask;
+ switch ((*src ^ Stuff_Magic) & Stuff_CodeMask)
+ {
+ case Stuff_Diff:
+ if (src+1+count >= end)
+ return(NULL);
+ do
+ {
+ *dst++ = *++src ^ Stuff_Magic;
+ }
+ while(--count >= 0 && dst < dst_end);
+ if (count < 0)
+ src += 1;
+ else
+ {
+ if (count == 0)
+ *src = Stuff_Same ^ Stuff_Magic;
+ else
+ *src = (Stuff_Diff + count) ^ Stuff_Magic;
+ }
+ break;
+ case Stuff_DiffZero:
+ if (src+1+count >= end)
+ return(NULL);
+ do
+ {
+ *dst++ = *++src ^ Stuff_Magic;
+ }
+ while(--count >= 0 && dst < dst_end);
+ if (count < 0)
+ *src = Stuff_Zero ^ Stuff_Magic;
+ else
+ *src = (Stuff_DiffZero + count) ^ Stuff_Magic;
+ break;
+ case Stuff_Same:
+ if (src+1 >= end)
+ return(NULL);
+ do
+ {
+ *dst++ = src[1] ^ Stuff_Magic;
+ }
+ while(--count >= 0 && dst < dst_end);
+ if (count < 0)
+ src += 2;
+ else
+ *src = (Stuff_Same + count) ^ Stuff_Magic;
+ break;
+ case Stuff_Zero:
+ do
+ {
+ *dst++ = 0;
+ }
+ while(--count >= 0 && dst < dst_end);
+ if (count < 0)
+ src += 1;
+ else
+ *src = (Stuff_Zero + count) ^ Stuff_Magic;
+ break;
+ }
+ }
+ if (dst < dst_end)
+ return(NULL);
+ else
+ return(src);
+}
+
+
+/************************************************************************/
+/* General routines for STRIP */
+
+/*
+ * Convert a string to a Metricom Address.
+ */
+
+static void string_to_radio_address(MetricomAddress *addr, __u8 *p)
+{
+ addr->c[0] = 0;
+ addr->c[1] = 0;
+ addr->c[2] = READHEX(p[0]) << 4 | READHEX(p[1]);
+ addr->c[3] = READHEX(p[2]) << 4 | READHEX(p[3]);
+ addr->c[4] = READHEX(p[5]) << 4 | READHEX(p[6]);
+ addr->c[5] = READHEX(p[7]) << 4 | READHEX(p[8]);
+}
+
+/*
+ * Convert a Metricom Address to a string.
+ */
+
+static __u8 *radio_address_to_string(const MetricomAddress *addr, MetricomAddressString *p)
+{
+ sprintf(p->c, "%02X%02X-%02X%02X", addr->c[2], addr->c[3], addr->c[4], addr->c[5]);
+ return(p->c);
+}
+
+/*
+ * Note: Must make sure sx_size is big enough to receive a stuffed
+ * MAX_STRIP_MTU packet. Additionally, we also want to ensure that it's
+ * big enough to receive a large radio neighbour list (currently 4K).
+ */
+
+static int allocate_buffers(struct strip *strip_info)
+{
+ struct device *dev = &strip_info->dev;
+ int stuffedlen = STRIP_ENCAP_SIZE(dev->mtu);
+ int sx_size = MAX(stuffedlen, 4096);
+ int tx_size = stuffedlen + sizeof(TickleString2);
+ __u8 *r = kmalloc(MAX_STRIP_MTU, GFP_ATOMIC);
+ __u8 *s = kmalloc(sx_size, GFP_ATOMIC);
+ __u8 *t = kmalloc(tx_size, GFP_ATOMIC);
+ if (r && s && t)
+ {
+ strip_info->rx_buff = r;
+ strip_info->sx_buff = s;
+ strip_info->tx_buff = t;
+ strip_info->sx_size = sx_size;
+ strip_info->tx_size = tx_size;
+ strip_info->mtu = dev->mtu;
+ return(1);
+ }
+ if (r) kfree(r);
+ if (s) kfree(s);
+ if (t) kfree(t);
+ return(0);
+}
+
+/*
+ * MTU has been changed by the IP layer. Unfortunately we are not told
+ * about this, but we spot it ourselves and fix things up. We could be in
+ * an upcall from the tty driver, or in an ip packet queue.
+ */
+
+static void strip_changedmtu(struct strip *strip_info)
+{
+ int old_mtu = strip_info->mtu;
+ struct device *dev = &strip_info->dev;
+ unsigned char *orbuff = strip_info->rx_buff;
+ unsigned char *osbuff = strip_info->sx_buff;
+ unsigned char *otbuff = strip_info->tx_buff;
+ InterruptStatus intstat;
+
+ if (dev->mtu > MAX_STRIP_MTU)
+ {
+ printk(KERN_ERR "%s: MTU exceeds maximum allowable (%d), MTU change cancelled.\n",
+ strip_info->dev.name, MAX_STRIP_MTU);
+ dev->mtu = old_mtu;
+ return;
+ }
+
+ /*
+ * Have to disable interrupts here because we're reallocating and resizing
+ * the serial buffers, and we can't have data arriving in them while we're
+ * moving them around in memory. This may cause data to be lost on the serial
+ * port, but hopefully people won't change MTU that often.
+ * Also note, this may not work on a symmetric multi-processor system.
+ */
+ intstat = DisableInterrupts();
+
+ if (!allocate_buffers(strip_info))
+ {
+ RestoreInterrupts(intstat);
+ printk(KERN_ERR "%s: unable to grow strip buffers, MTU change cancelled.\n",
+ strip_info->dev.name);
+ dev->mtu = old_mtu;
+ return;
+ }
+
+ if (strip_info->sx_count)
+ {
+ if (strip_info->sx_count <= strip_info->sx_size)
+ memcpy(strip_info->sx_buff, osbuff, strip_info->sx_count);
+ else
+ {
+ strip_info->sx_count = 0;
+ strip_info->rx_over_errors++;
+ strip_info->discard = 1;
+ }
+ }
+
+ if (strip_info->tx_left)
+ {
+ if (strip_info->tx_left <= strip_info->tx_size)
+ memcpy(strip_info->tx_buff, strip_info->tx_head, strip_info->tx_left);
+ else
+ {
+ strip_info->tx_left = 0;
+ strip_info->tx_dropped++;
+ }
+ }
+ strip_info->tx_head = strip_info->tx_buff;
+
+ RestoreInterrupts(intstat);
+
+ printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
+ strip_info->dev.name, old_mtu, strip_info->mtu);
+
+ if (orbuff) kfree(orbuff);
+ if (osbuff) kfree(osbuff);
+ if (otbuff) kfree(otbuff);
+}
+
+static void strip_unlock(struct strip *strip_info)
+{
+ /*
+ * Set the time to go off in one second.
+ */
+ strip_info->idle_timer.expires = jiffies + HZ;
+ add_timer(&strip_info->idle_timer);
+ if (!clear_bit(0, (void *)&strip_info->dev.tbusy))
+ printk(KERN_ERR "%s: trying to unlock already unlocked device!\n",
+ strip_info->dev.name);
+}
+
+
+/************************************************************************/
+/* Callback routines for exporting information through /proc */
+
+#if DO_PROC_NET_STRIP_STATUS | DO_PROC_NET_STRIP_TRACE
+
+/*
+ * This function updates the total amount of data printed so far. It then
+ * determines if the amount of data printed into a buffer has reached the
+ * offset requested. If it hasn't, then the buffer is shifted over so that
+ * the next bit of data can be printed over the old bit. If the total
+ * amount printed so far exceeds the total amount requested, then this
+ * function returns 1, otherwise 0.
+ */
+static int
+shift_buffer(char *buffer, int requested_offset, int requested_len,
+ int *total, int *slop, char **buf)
+{
+ int printed;
+
+ /* printk(KERN_DEBUG "shift: buffer: %d o: %d l: %d t: %d buf: %d\n",
+ (int) buffer, requested_offset, requested_len, *total,
+ (int) *buf); */
+ printed = *buf - buffer;
+ if (*total + printed <= requested_offset) {
+ *total += printed;
+ *buf = buffer;
+ }
+ else {
+ if (*total < requested_offset) {
+ *slop = requested_offset - *total;
+ }
+ *total = requested_offset + printed - *slop;
+ }
+ if (*total > requested_offset + requested_len) {
+ return 1;
+ }
+ else {
+ return 0;
+ }
+}
+
+/*
+ * This function calculates the actual start of the requested data
+ * in the buffer. It also calculates actual length of data returned,
+ * which could be less that the amount of data requested.
+ */
+static int
+calc_start_len(char *buffer, char **start, int requested_offset,
+ int requested_len, int total, char *buf)
+{
+ int return_len, buffer_len;
+
+ buffer_len = buf - buffer;
+ if (buffer_len >= STRIP_PROC_BUFFER_SIZE - 1) {
+ printk(KERN_ERR "STRIP: exceeded /proc buffer size\n");
+ }
+
+ /*
+ * There may be bytes before and after the
+ * chunk that was actually requested.
+ */
+ return_len = total - requested_offset;
+ if (return_len < 0) {
+ return_len = 0;
+ }
+ *start = buf - return_len;
+ if (return_len > requested_len) {
+ return_len = requested_len;
+ }
+ /* printk(KERN_DEBUG "return_len: %d\n", return_len); */
+ return return_len;
+}
+
+#endif DO_PROC_NET_STRIP_STATUS | DO_PROC_NET_STRIP_TRACE
+
+#if DO_PROC_NET_STRIP_STATUS
+
+/*
+ * If the time is in the near future, time_delta prints the number of
+ * seconds to go into the buffer and returns the address of the buffer.
+ * If the time is not in the near future, it returns the address of the
+ * string "Not scheduled" The buffer must be long enough to contain the
+ * ascii representation of the number plus 9 charactes for the " seconds"
+ * and the null character.
+ */
+static char *time_delta(char buffer[], long time)
+{
+ time -= jiffies;
+ if (time > LongTime / 2) return("Not scheduled");
+ if(time < 0) time = 0; /* Don't print negative times */
+ sprintf(buffer, "%ld seconds", time / HZ);
+ return(buffer);
+}
+
+/*
+ * This function prints radio status information into the specified
+ * buffer.
+ */
+static int
+sprintf_status_info(char *buffer, struct strip *strip_info)
+{
+ char temp_buffer[32];
+ MetricomAddressString addr_string;
+ char *buf;
+
+ buf = buffer;
+ buf += sprintf(buf, "Interface name\t\t%s\n", strip_info->if_name);
+ buf += sprintf(buf, " Radio working:\t\t%s\n",
+ strip_info->working &&
+ (long)jiffies - strip_info->watchdog_doreset < 0 ? "Yes" : "No");
+ (void) radio_address_to_string((MetricomAddress *)
+ &strip_info->dev.dev_addr,
+ &addr_string);
+ buf += sprintf(buf, " Device address:\t%s\n", addr_string.c);
+ buf += sprintf(buf, " Firmware version:\t%s\n",
+ !strip_info->working ? "Unknown" :
+ !strip_info->structured_messages ? "Should be upgraded" :
+ strip_info->firmware_version.c);
+ buf += sprintf(buf, " Serial number:\t\t%s\n", strip_info->serial_number.c);
+ buf += sprintf(buf, " Battery voltage:\t%s\n", strip_info->battery_voltage.c);
+ buf += sprintf(buf, " Transmit queue (bytes):%d\n", strip_info->tx_left);
+ buf += sprintf(buf, " Next watchdog probe:\t%s\n",
+ time_delta(temp_buffer, strip_info->watchdog_doprobe));
+ buf += sprintf(buf, " Next watchdog reset:\t%s\n",
+ time_delta(temp_buffer, strip_info->watchdog_doreset));
+ buf += sprintf(buf, " Next gratuitous ARP:\t%s\n",
+ time_delta(temp_buffer, strip_info->gratuitous_arp));
+ buf += sprintf(buf, " Next ARP interval:\t%ld seconds\n",
+ JIFFIE_TO_SEC(strip_info->arp_interval));
+ return buf - buffer;
+}
+
+static int
+sprintf_portables(char *buffer, struct strip *strip_info)
+{
+
+ MetricomAddressString addr_string;
+ MetricomNode *node;
+ char *buf;
+
+ buf = buffer;
+ buf += sprintf(buf, " portables: name\t\tpoll_latency\tsignal strength\n");
+ for (node = strip_info->neighbor_list; node != NULL;
+ node = node->next) {
+ if (!(node->type & NodeValid)) {
+ break;
+ }
+ if (node->type & NodeHasWAN) {
+ continue;
+ }
+ (void) radio_address_to_string(&node->addr, &addr_string);
+ buf += sprintf(buf, " %s\t\t\t\t%d\t\t%d\n",
+ addr_string.c, node->poll_latency, node->rssi);
+ }
+ return buf - buffer;
+}
+
+static int
+sprintf_poletops(char *buffer, struct strip *strip_info)
+{
+ MetricomNode *node;
+ char *buf;
+
+ buf = buffer;
+ buf += sprintf(buf, " poletops: GPS\t\t\tpoll_latency\tsignal strength\n");
+ for (node = strip_info->neighbor_list;
+ node != NULL; node = node->next) {
+ if (!(node->type & NodeValid)) {
+ break;
+ }
+ if (!(node->type & NodeHasWAN)) {
+ continue;
+ }
+ buf += sprintf(buf, " %s\t\t\t%d\t\t%d\n",
+ node->gl.s, node->poll_latency, node->rssi);
+ }
+ return buf - buffer;
+}
+
+/*
+ * This function is exports status information from the STRIP driver through
+ * the /proc file system. /proc filesystem should be fixed:
+ * 1) slow (sprintfs here, a memory copy in the proc that calls this one)
+ * 2) length of buffer not passed
+ * 3) dummy isn't client data set when the callback was registered
+ * 4) poorly documented (this function is called until the requested amount
+ * of data is returned, buffer is only 4K long, dummy is the permissions
+ * of the file (?), the proc_dir_entry passed to proc_net_register must
+ * be kmalloc-ed)
+ */
+
+static int
+strip_get_status_info(char *buffer, char **start, off_t requested_offset,
+ int requested_len, int dummy)
+{
+ char *buf;
+ int total = 0, slop = 0, len_exceeded;
+ InterruptStatus i_status;
+ struct strip *strip_info;
+
+ buf = buffer;
+ buf += sprintf(buf, "strip_version: %s\n", StripVersion);
+
+ i_status = DisableInterrupts();
+ strip_info = struct_strip_list;
+ RestoreInterrupts(i_status);
+
+ while (strip_info != NULL) {
+ i_status = DisableInterrupts();
+ buf += sprintf_status_info(buf, strip_info);
+ RestoreInterrupts(i_status);
+ len_exceeded = shift_buffer(buffer, requested_offset, requested_len,
+ &total, &slop, &buf);
+ if (len_exceeded) {
+ goto done;
+ }
+ strip_info->neighbor_list_locked = TRUE;
+ buf += sprintf_portables(buf, strip_info);
+ strip_info->neighbor_list_locked = FALSE;
+ len_exceeded = shift_buffer(buffer, requested_offset, requested_len,
+ &total, &slop, &buf);
+ if (len_exceeded) {
+ goto done;
+ }
+ strip_info->neighbor_list_locked = TRUE;
+ buf += sprintf_poletops(buf, strip_info);
+ strip_info->neighbor_list_locked = FALSE;
+ len_exceeded = shift_buffer(buffer, requested_offset, requested_len,
+ &total, &slop, &buf);
+ if (len_exceeded) {
+ goto done;
+ }
+ strip_info = strip_info->next;
+ }
+done:
+ return calc_start_len(buffer, start, requested_offset, requested_len,
+ total, buf);
+}
+
+#endif DO_PROC_NET_STRIP_STATUS
+
+#if DO_PROC_NET_STRIP_TRACE
+
+/*
+ * Convert an Ethernet protocol to a string
+ * Returns the number of characters printed.
+ */
+
+static int protocol_to_string(int protocol, __u8 *p)
+{
+ int printed;
+
+ switch (protocol) {
+ case ETH_P_IP:
+ printed = sprintf(p, "IP");
+ break;
+ case ETH_P_ARP:
+ printed = sprintf(p, "ARP");
+ break;
+ default:
+ printed = sprintf(p, "%d", protocol);
+ }
+ return printed;
+}
+
+static int
+sprintf_log_entry(char *buffer, struct strip *strip_info, int packet_index)
+{
+ StripLog *entry;
+ MetricomAddressString addr_string;
+ __u8 sig_buf[24], *s;
+ char *buf, proto_buf[10];
+
+ entry = &strip_info->packetLog[packet_index];
+ if (!entry->valid) {
+ return 0;
+ }
+ buf = buffer;
+ buf += sprintf(buf, "%-4s %s %7lu ", strip_info->if_name,
+ ENTRY_TYPE_TO_STRING(entry->entry_type), entry->seqNum);
+ (void) protocol_to_string(entry->packet_type, proto_buf);
+ buf += sprintf(buf, "%-4s", proto_buf);
+ s = entry->sig.print_sig;
+ sprintf(sig_buf, "%d.%d.%d.%d.%d.%d", s[0], s[1], s[2], s[3], s[4], s[5]);
+ buf += sprintf(buf, "%-24s", sig_buf);
+ (void) radio_address_to_string((MetricomAddress *) &entry->src,
+ &addr_string);
+ buf += sprintf(buf, "%-10s", addr_string.c);
+ (void) radio_address_to_string((MetricomAddress *) &entry->dest,
+ &addr_string);
+ buf += sprintf(buf, "%-10s", addr_string.c);
+ buf += sprintf(buf, "%8d %6d %5lu %6lu %5lu\n", entry->timeStamp.tv_sec,
+ entry->timeStamp.tv_usec, entry->rawSize,
+ entry->stripSize, entry->slipSize);
+ return buf - buffer;
+}
+
+/*
+ * This function exports trace information from the STRIP driver through the
+ * /proc file system.
+ */
+
+static int
+strip_get_trace_info(char *buffer, char **start, off_t requested_offset,
+ int requested_len, int dummy)
+{
+ char *buf;
+ int len_exceeded, total = 0, slop = 0, packet_index, oldest;
+ InterruptStatus i_status;
+ struct strip *strip_info;
+
+ buf = buffer;
+ buf += sprintf(buf, "if s/r seqnum t signature ");
+ buf += sprintf(buf,
+ "src dest sec usec raw strip slip\n");
+
+ i_status = DisableInterrupts();
+ strip_info = struct_strip_list;
+ oldest = strip_info->next_entry;
+ RestoreInterrupts(i_status);
+
+ /*
+ * If we disable interrupts for this entire loop,
+ * characters from the serial port could be lost,
+ * so we only disable interrupts when accessing
+ * a log entry. If more than STRIP_LOG_INT_SIZE
+ * packets are logged before the first entry is
+ * printed, then some of the entries could be
+ * printed out of order.
+ */
+ while (strip_info != NULL) {
+ for (packet_index = oldest + STRIP_LOG_INT_SIZE;
+ packet_index != oldest;
+ packet_index = (packet_index + 1) %
+ ELEMENTS_OF(strip_info->packetLog)) {
+ i_status = DisableInterrupts();
+ buf += sprintf_log_entry(buf, strip_info, packet_index);
+ RestoreInterrupts(i_status);
+ len_exceeded = shift_buffer(buffer, requested_offset,
+ requested_len, &total, &slop, &buf);
+ if (len_exceeded) {
+ goto done;
+ }
+ }
+ strip_info = strip_info->next;
+ }
+done:
+ return calc_start_len(buffer, start, requested_offset, requested_len,
+ total, buf);
+}
+
+static int slip_len(unsigned char *data, int len)
+{
+ static const unsigned char SLIP_END=0300; /* indicates end of SLIP frame */
+ static const unsigned char SLIP_ESC=0333; /* indicates SLIP byte stuffing */
+ int count = len;
+ while (--len >= 0)
+ {
+ if (*data == SLIP_END || *data == SLIP_ESC) count++;
+ data++;
+ }
+ return(count);
+}
+
+/* Copied from kernel/sched.c */
+static void jiffiestotimeval(unsigned long jiffies, struct timeval *value)
+{
+ value->tv_usec = (jiffies % HZ) * (1000000.0 / HZ);
+ value->tv_sec = jiffies / HZ;
+ return;
+}
+
+/*
+ * This function logs a packet.
+ * A pointer to the packet itself is passed so that some of the data can be
+ * used to compute a signature. The pointer should point the the
+ * part of the packet following the STRIP_header.
+ */
+
+static void packet_log(struct strip *strip_info, __u8 *packet,
+ LogEntry entry_type, STRIP_Header *hdr,
+ int raw_size, int strip_size, int slip_size)
+{
+ StripLog *entry;
+ struct iphdr *iphdr;
+ struct arphdr *arphdr;
+
+ entry = &strip_info->packetLog[strip_info->next_entry];
+ if (entry_type == EntrySend) {
+ entry->seqNum = strip_info->num_sent++;
+ }
+ else {
+ entry->seqNum = strip_info->num_received++;
+ }
+ entry->entry_type = entry_type;
+ entry->packet_type = ntohs(hdr->protocol);
+ switch (entry->packet_type) {
+ case ETH_P_IP:
+ /*
+ * The signature for IP is the sender's ip address and
+ * the identification field.
+ */
+ iphdr = (struct iphdr *) packet;
+ entry->sig.ip_sig.id = iphdr->id;
+ entry->sig.ip_sig.src.l = iphdr->saddr;
+ break;
+ case ETH_P_ARP:
+ /*
+ * The signature for ARP is the sender's ip address and
+ * the operation.
+ */
+ arphdr = (struct arphdr *) packet;
+ entry->sig.arp_sig.op = arphdr->ar_op;
+ memcpy(&entry->sig.arp_sig.src.l, packet + 8 + arphdr->ar_hln,
+ sizeof(entry->sig.arp_sig.src.l));
+ entry->sig.arp_sig.src.l = entry->sig.arp_sig.src.l;
+ break;
+ default:
+ printk(KERN_DEBUG "STRIP: packet_log: unknown packet type: %d\n",
+ entry->packet_type);
+ break;
+ }
+ memcpy(&entry->src, &hdr->src_addr, sizeof(MetricomAddress));
+ memcpy(&entry->dest, &hdr->dst_addr, sizeof(MetricomAddress));
+
+ jiffiestotimeval(jiffies, &(entry->timeStamp));
+ entry->rawSize = raw_size;
+ entry->stripSize = strip_size;
+ entry->slipSize = slip_size;
+ entry->valid = 1;
+
+ strip_info->next_entry = (strip_info->next_entry + 1) %
+ ELEMENTS_OF(strip_info->packetLog);
+}
+
+#endif DO_PROC_NET_STRIP_TRACE
+
+/*
+ * This function parses the response to the ATS300? command,
+ * extracting the radio version and serial number.
+ */
+static void get_radio_version(struct strip *strip_info, __u8 *ptr, __u8 *end)
+{
+ __u8 *p, *value_begin, *value_end;
+ int len;
+
+ /* Determine the beginning of the second line of the payload */
+ p = ptr;
+ while (p < end && *p != 10) p++;
+ if (p >= end) return;
+ p++;
+ value_begin = p;
+
+ /* Determine the end of line */
+ while (p < end && *p != 10) p++;
+ if (p >= end) return;
+ value_end = p;
+ p++;
+
+ len = value_end - value_begin;
+ len = MIN(len, sizeof(MetricomFirmwareVersion) - 1);
+ sprintf(strip_info->firmware_version.c, "%.*s", len, value_begin);
+
+ /* Look for the first colon */
+ while (p < end && *p != ':') p++;
+ if (p >= end) return;
+ /* Skip over the space */
+ p += 2;
+ len = sizeof(MetricomSerialNumber) - 1;
+ if (p + len <= end) {
+ sprintf(strip_info->serial_number.c, "%.*s", len, p);
+ }
+ else {
+ printk(KERN_ERR "STRIP: radio serial number shorter (%d) than expected (%d)\n",
+ end - p, len);
+ }
+}
+
+/*
+ * This function parses the response to the ATS325? command,
+ * extracting the radio battery voltage.
+ */
+static void get_radio_voltage(struct strip *strip_info, __u8 *ptr, __u8 *end)
+{
+ int len;
+
+ len = sizeof(MetricomBatteryVoltage) - 1;
+ if (ptr + len <= end) {
+ sprintf(strip_info->battery_voltage.c, "%.*s", len, ptr);
+ }
+ else {
+ printk(KERN_ERR "STRIP: radio voltage string shorter (%d) than expected (%d)\n",
+ end - ptr, len);
+ }
+}
+
+/*
+ * This function parses the response to the AT~I2 command,
+ * which gives the names of the radio's nearest neighbors.
+ * It relies on the format of the response.
+ */
+static void get_radio_neighbors(struct strip *strip_info, __u8 *ptr, __u8 *end)
+{
+ __u8 *p, *line_begin;
+ int num_nodes_reported, num_nodes_counted;
+ MetricomNode *node, *last;
+
+ /* Check if someone is reading the list */
+ if (strip_info->neighbor_list_locked) {
+ return;
+ }
+
+ /* Determine the number of Nodes */
+ p = ptr;
+ num_nodes_reported = simple_strtoul(p, NULL, 10);
+ /* printk(KERN_DEBUG "num_nodes: %d\n", num_nodes_reported); */
+
+ /* Determine the beginning of the next line */
+ while (p < end && *p != 10) p++;
+ if (p >= end) return;
+ p++;
+
+ /*
+ * The node list should never be empty because we allocate one empty
+ * node when the strip_info is allocated. The nodes which were allocated
+ * when the number of neighbors was high but are no longer needed because
+ * there aren't as many neighbors any more are marked invalid. Invalid nodes
+ * are kept at the end of the list.
+ */
+ node = strip_info->neighbor_list;
+ last = node;
+ if (node == NULL) {
+ DumpData("Neighbor list is NULL:", strip_info, p, end);
+ return;
+ }
+ line_begin = p;
+ num_nodes_counted = 0;
+ while (line_begin < end) {
+ /* Check to see if the format is what we expect. */
+ if ((line_begin + STRIP_NODE_LEN) > end) {
+ printk(KERN_ERR "STRIP: radio neighbor node string shorter (%d) than expected (%d)\n",
+ end - line_begin, STRIP_NODE_LEN);
+ break;
+ }
+
+ /* Get a node */
+ if (node == NULL) {
+ node = kmalloc(sizeof(MetricomNode), GFP_ATOMIC);
+ node->next = NULL;
+ }
+ node->type = NodeValid;
+
+ /* Fill the node in */
+
+ /* Determine if it has a GPS location and fill it in if it does. */
+ p = line_begin;
+ /* printk(KERN_DEBUG "node: %64s\n", p); */
+ if (p[0] != STRIP_PORTABLE_CHAR) {
+ node->type |= NodeHasWAN;
+ sprintf(node->gl.s, "%.*s", (int) sizeof(GeographicLocation) - 1, p);
+ }
+
+ /* Determine if it is a router */
+ p = line_begin + 18;
+ if (p[0] == STRIP_ROUTER_CHAR) {
+ node->type |= NodeIsRouter;
+ }
+
+ /* Could be a radio address or some weird poletop address. */
+ p = line_begin + 20;
+ /* printk(KERN_DEBUG "before addr: %6s\n", p); */
+ string_to_radio_address(&node->addr, p);
+ /* radio_address_to_string(&node->addr, addr_string);
+ printk(KERN_DEBUG "after addr: %s\n", addr_string); */
+
+ if (IS_RADIO_ADDRESS(p)) {
+ string_to_radio_address(&node->addr, p);
+ }
+ else {
+ memset(&node->addr, 0, sizeof(MetricomAddress));
+ }
+
+ /* Get the poll latency. %$#!@ simple_strtoul can't skip white space */
+ p = line_begin + 41;
+ while (isspace(*p) && (p < end)) {
+ p++;
+ }
+ node->poll_latency = simple_strtoul(p, NULL, 10);
+
+ /* Get the signal strength. simple_strtoul doesn't do minus signs */
+ p = line_begin + 60;
+ node->rssi = -simple_strtoul(p, NULL, 10);
+
+ if (last != node) {
+ last->next = node;
+ last = node;
+ }
+ node = node->next;
+ line_begin += STRIP_NODE_LEN;
+ num_nodes_counted++;
+ }
+
+ /* invalidate all remaining nodes */
+ for (;node != NULL; node = node->next) {
+ node->type &= ~NodeValid;
+ }
+
+ /*
+ * If the number of nodes reported is different
+ * from the number counted, might need to up the number
+ * requested.
+ */
+ if (num_nodes_reported != num_nodes_counted) {
+ printk(KERN_DEBUG "nodes reported: %d \tnodes counted: %d\n",
+ num_nodes_reported, num_nodes_counted);
+ }
+}
+
+
+/************************************************************************/
+/* Sending routines */
+
+static void ResetRadio(struct strip *strip_info)
+{
+ static const char InitString[] = "\rat\r\rate0q1dt**starmode\r\r**";
+
+ /* If the radio isn't working anymore, we should clear the old status information. */
+ if (strip_info->working)
+ {
+ printk(KERN_INFO "%s: No response: Resetting radio.\n", strip_info->dev.name);
+ strip_info->firmware_version.c[0] = '\0';
+ strip_info->serial_number.c[0] = '\0';
+ strip_info->battery_voltage.c[0] = '\0';
+ }
+ /* Mark radio address as unknown */
+ *(MetricomAddress*)&strip_info->dev.dev_addr = zero_address;
+ strip_info->working = FALSE;
+ strip_info->structured_messages = FALSE;
+ strip_info->watchdog_doprobe = jiffies + 10 * HZ;
+ strip_info->watchdog_doreset = jiffies + 1 * HZ;
+ strip_info->tty->driver.write(strip_info->tty, 0, (char *)InitString, sizeof(InitString)-1);
+}
+
+/*
+ * Called by the driver when there's room for more data. If we have
+ * more packets to send, we send them here.
+ */
+
+static void strip_write_some_more(struct tty_struct *tty)
+{
+ struct strip *strip_info = (struct strip *) tty->disc_data;
+
+ /* First make sure we're connected. */
+ if (!strip_info || strip_info->magic != STRIP_MAGIC || !strip_info->dev.start)
+ return;
+
+ if (strip_info->tx_left > 0)
+ {
+ /*
+ * If some data left, send it
+ * Note: There's a kernel design bug here. The write_wakeup routine has to
+ * know how many bytes were written in the previous call, but the number of
+ * bytes written is returned as the result of the tty->driver.write call,
+ * and there's no guarantee that the tty->driver.write routine will have
+ * returned before the write_wakeup routine is invoked. If the PC has fast
+ * Serial DMA hardware, then it's quite possible that the write could complete
+ * almost instantaneously, meaning that my write_wakeup routine could be
+ * called immediately, before tty->driver.write has had a chance to return
+ * the number of bytes that it wrote. In an attempt to guard against this,
+ * I disable interrupts around the call to tty->driver.write, although even
+ * this might not work on a symmetric multi-processor system.
+ */
+ InterruptStatus intstat = DisableInterrupts();
+ int num_written = tty->driver.write(tty, 0, strip_info->tx_head, strip_info->tx_left);
+ strip_info->tx_left -= num_written;
+ strip_info->tx_head += num_written;
+ RestoreInterrupts(intstat);
+ }
+ else /* Else start transmission of another packet */
+ {
+ tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
+ strip_unlock(strip_info);
+ mark_bh(NET_BH);
+ }
+}
+
+static unsigned char *strip_make_packet(unsigned char *ptr, struct strip *strip_info, struct sk_buff *skb)
+{
+#if DO_PROC_NET_STRIP_TRACE
+ unsigned char *start_ptr;
+#endif DO_PROC_NET_STRIP_TRACE
+
+ __u8 *stuffstate = NULL;
+ STRIP_Header *header = (STRIP_Header *)skb->data;
+ MetricomAddress haddr = header->dst_addr;
+ int len = skb->len - sizeof(STRIP_Header);
+ MetricomKey key;
+
+ /*HexDump("strip_make_packet", strip_info, skb->data, skb->data + skb->len);*/
+
+ if (header->protocol == htons(ETH_P_IP)) key = SIP0Key;
+ else if (header->protocol == htons(ETH_P_ARP)) key = ARP0Key;
+ else
+ {
+ printk(KERN_ERR "%s: strip_make_packet: Unknown packet type 0x%04X\n",
+ strip_info->dev.name, ntohs(header->protocol));
+ strip_info->tx_dropped++;
+ return(NULL);
+ }
+
+ if (len > strip_info->mtu)
+ {
+ printk(KERN_ERR "%s: Dropping oversized transmit packet: %d bytes\n",
+ strip_info->dev.name, len);
+ strip_info->tx_dropped++;
+ return(NULL);
+ }
+
+ /*
+ * If this is a broadcast packet, send it to our designated Metricom
+ * 'broadcast hub' radio (First byte of address being 0xFF means broadcast)
+ */
+ if (haddr.c[0] == 0xFF)
+ {
+ /*IPaddr a;
+ a.l = strip_info->dev.pa_brdaddr;
+ printk(KERN_INFO "%s: Broadcast packet! Sending to %d.%d.%d.%d\n",
+ strip_info->dev.name, a.b[0], a.b[1], a.b[2], a.b[3]);*/
+
+ if (!arp_query(haddr.c, strip_info->dev.pa_brdaddr, &strip_info->dev))
+ {
+ /*IPaddr a;
+ a.l = strip_info->dev.pa_brdaddr;
+ printk(KERN_INFO "%s: No ARP cache entry for %d.%d.%d.%d\n",
+ strip_info->dev.name, a.b[0], a.b[1], a.b[2], a.b[3]);
+ strip_info->tx_dropped++;*/
+ return(NULL);
+ }
+ }
+
+ *ptr++ = '*';
+ *ptr++ = hextable[haddr.c[2] >> 4];
+ *ptr++ = hextable[haddr.c[2] & 0xF];
+ *ptr++ = hextable[haddr.c[3] >> 4];
+ *ptr++ = hextable[haddr.c[3] & 0xF];
+ *ptr++ = '-';
+ *ptr++ = hextable[haddr.c[4] >> 4];
+ *ptr++ = hextable[haddr.c[4] & 0xF];
+ *ptr++ = hextable[haddr.c[5] >> 4];
+ *ptr++ = hextable[haddr.c[5] & 0xF];
+ *ptr++ = '*';
+ *ptr++ = key.c[0];
+ *ptr++ = key.c[1];
+ *ptr++ = key.c[2];
+ *ptr++ = key.c[3];
+
+#if DO_PROC_NET_STRIP_TRACE
+ start_ptr = ptr;
+#endif DO_PROC_NET_STRIP_TRACE
+
+ ptr = StuffData(skb->data + sizeof(STRIP_Header), len, ptr, &stuffstate);
+
+#if DO_PROC_NET_STRIP_TRACE
+ packet_log(strip_info, skb->data + sizeof(STRIP_Header), EntrySend,
+ header, len, ptr-start_ptr,
+ slip_len(skb->data + sizeof(STRIP_Header), len));
+#endif DO_PROC_NET_STRIP_TRACE
+
+ *ptr++ = 0x0D;
+ return(ptr);
+}
+
+static void strip_send(struct strip *strip_info, struct sk_buff *skb)
+{
+ unsigned char *ptr = strip_info->tx_buff;
+
+ /* If we have a packet, encapsulate it and put it in the buffer */
+ if (skb)
+ {
+ ptr = strip_make_packet(ptr, strip_info, skb);
+ /* If error, unlock and return */
+ if (!ptr) { strip_unlock(strip_info); return; }
+ strip_info->tx_packets++; /* Count another successful packet */
+ /*DumpData("Sending:", strip_info, strip_info->tx_buff, ptr);*/
+ /*HexDump("Sending", strip_info, strip_info->tx_buff, ptr);*/
+ }
+
+ /* Set up the strip_info ready to send the data */
+ strip_info->tx_head = strip_info->tx_buff;
+ strip_info->tx_left = ptr - strip_info->tx_buff;
+ strip_info->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
+
+ /* If watchdog has expired, reset the radio */
+ if ((long)jiffies - strip_info->watchdog_doreset >= 0)
+ {
+ ResetRadio(strip_info);
+ return;
+ /* Note: if there's a packet to send, strip_write_some_more
+ will do it after the reset has finished */
+ }
+
+ /* No reset.
+ * If it is time for another tickle, tack it on the end of the packet
+ */
+ if ((long)jiffies - strip_info->watchdog_doprobe >= 0)
+ {
+ /* Send tickle to make radio protest */
+ /*printk(KERN_INFO "%s: Routine radio test.\n", strip_info->dev.name);*/
+ const char *TickleString = TickleString1;
+ int length = sizeof(TickleString1)-1;
+ if (strip_info->structured_messages)
+ {
+ TickleString = TickleString2;
+ length = sizeof(TickleString2)-1;
+ }
+ memcpy(ptr, TickleString, length);
+ strip_info->tx_left += length;
+ strip_info->watchdog_doprobe = jiffies + 10 * HZ;
+ strip_info->watchdog_doreset = jiffies + 1 * HZ;
+ }
+
+ /*
+ * If it is time for a periodic ARP, queue one up to be sent
+ */
+ if (strip_info->working && (long)jiffies - strip_info->gratuitous_arp >= 0 &&
+ memcmp(strip_info->dev.dev_addr, zero_address.c, sizeof(zero_address)))
+ {
+ /*printk(KERN_INFO "%s: Sending gratuitous ARP with interval %ld\n",
+ strip_info->dev.name, strip_info->arp_interval / HZ);*/
+ strip_info->gratuitous_arp = jiffies + strip_info->arp_interval;
+ strip_info->arp_interval *= 2;
+ if (strip_info->arp_interval > MaxARPInterval)
+ strip_info->arp_interval = MaxARPInterval;
+ arp_send(ARPOP_REPLY, ETH_P_ARP, strip_info->dev.pa_addr,
+ &strip_info->dev, strip_info->dev.pa_addr,
+ NULL, strip_info->dev.dev_addr, NULL);
+ }
+
+ if (strip_info->tx_size - strip_info->tx_left < 20)
+ printk(KERN_ERR "%s: Sending%5d bytes;%5d bytes free.\n", strip_info->dev.name,
+ strip_info->tx_left, strip_info->tx_size - strip_info->tx_left);
+
+ /* All ready. Start the transmission */
+ strip_write_some_more(strip_info->tty);
+}
+
+/* Encapsulate a datagram and kick it into a TTY queue. */
+static int strip_xmit(struct sk_buff *skb, struct device *dev)
+{
+ struct strip *strip_info = (struct strip *)(dev->priv);
+
+ if (!dev->start)
+ {
+ printk(KERN_ERR "%s: xmit call when iface is down\n", dev->name);
+ return(1);
+ }
+ if (set_bit(0, (void *) &strip_info->dev.tbusy)) return(1);
+ del_timer(&strip_info->idle_timer);
+
+ /* See if someone has been ifconfigging */
+ if (strip_info->mtu != strip_info->dev.mtu)
+ strip_changedmtu(strip_info);
+
+ strip_send(strip_info, skb);
+
+ if (skb) dev_kfree_skb(skb, FREE_WRITE);
+ return(0);
+}
+
+/*
+ * Create the MAC header for an arbitrary protocol layer
+ *
+ * saddr!=NULL means use this specific address (n/a for Metricom)
+ * saddr==NULL means use default device source address
+ * daddr!=NULL means use this destination address
+ * daddr==NULL means leave destination address alone
+ * (e.g. unresolved arp -- kernel will call
+ * rebuild_header later to fill in the address)
+ */
+
+static int strip_header(struct sk_buff *skb, struct device *dev,
+ unsigned short type, void *daddr, void *saddr, unsigned len)
+{
+ STRIP_Header *header = (STRIP_Header *)skb_push(skb, sizeof(STRIP_Header));
+
+ /*printk(KERN_INFO "%s: strip_header 0x%04X %s\n", dev->name, type,
+ type == ETH_P_IP ? "IP" : type == ETH_P_ARP ? "ARP" : "");*/
+
+ memcpy(header->src_addr.c, dev->dev_addr, dev->addr_len);
+ header->protocol = htons(type);
+
+ /*HexDump("strip_header", (struct strip *)(dev->priv), skb->data, skb->data + skb->len);*/
+
+ if (!daddr) return(-dev->hard_header_len);
+
+ memcpy(header->dst_addr.c, daddr, dev->addr_len);
+ return(dev->hard_header_len);
+}
+
+/*
+ * Rebuild the MAC header. This is called after an ARP
+ * (or in future other address resolution) has completed on this
+ * sk_buff. We now let ARP fill in the other fields.
+ * I think this should return zero if packet is ready to send,
+ * or non-zero if it needs more time to do an address lookup
+ */
+
+static int strip_rebuild_header(void *buff, struct device *dev,
+ unsigned long dst, struct sk_buff *skb)
+{
+ STRIP_Header *header = (STRIP_Header *)buff;
+
+ /*printk(KERN_INFO "%s: strip_rebuild_header\n", dev->name);*/
+
+#ifdef CONFIG_INET
+ /* Arp find returns zero if if knows the address, */
+ /* or if it doesn't know the address it sends an ARP packet and returns non-zero */
+ return arp_find(header->dst_addr.c, dst, dev, dev->pa_addr, skb)? 1 : 0;
+#else
+ return 0;
+#endif
+}
+
+/*
+ * IdleTask periodically calls strip_xmit, so even when we have no IP packets
+ * to send for an extended period of time, the watchdog processing still gets
+ * done to ensure that the radio stays in Starmode
+ */
+
+static void strip_IdleTask(unsigned long parameter)
+{
+ strip_xmit(NULL, (struct device *)parameter);
+}
+
+
+/************************************************************************/
+/* Receiving routines */
+
+static int strip_receive_room(struct tty_struct *tty)
+{
+ return 0x10000; /* We can handle an infinite amount of data. :-) */
+}
+
+static void get_radio_address(struct strip *strip_info, __u8 *p)
+{
+ MetricomAddress addr;
+
+ string_to_radio_address(&addr, p);
+
+ /* See if our radio address has changed */
+ if (memcmp(strip_info->dev.dev_addr, addr.c, sizeof(addr)))
+ {
+ MetricomAddressString addr_string;
+ radio_address_to_string(&addr, &addr_string);
+ printk(KERN_INFO "%s: My radio address = %s\n", strip_info->dev.name, addr_string.c);
+ memcpy(strip_info->dev.dev_addr, addr.c, sizeof(addr));
+ /* Give the radio a few seconds to get its head straight, then send an arp */
+ strip_info->gratuitous_arp = jiffies + 6 * HZ;
+ strip_info->arp_interval = 1 * HZ;
+ }
+}
+
+static void RecvErr(char *msg, struct strip *strip_info)
+{
+ __u8 *ptr = strip_info->sx_buff;
+ __u8 *end = strip_info->sx_buff + strip_info->sx_count;
+ DumpData(msg, strip_info, ptr, end);
+ strip_info->rx_errors++;
+}
+
+static void RecvErr_Message(struct strip *strip_info, __u8 *sendername, const __u8 *msg)
+{
+ static const char ERR_001[] = "001"; /* Not in StarMode! */
+ static const char ERR_002[] = "002"; /* Remap handle */
+ static const char ERR_003[] = "003"; /* Can't resolve name */
+ static const char ERR_004[] = "004"; /* Name too small or missing */
+ static const char ERR_005[] = "005"; /* Bad count specification */
+ static const char ERR_006[] = "006"; /* Header too big */
+ static const char ERR_007[] = "007"; /* Body too big */
+ static const char ERR_008[] = "008"; /* Bad character in name */
+ static const char ERR_009[] = "009"; /* No count or line terminator */
+
+ if (!strncmp(msg, ERR_001, sizeof(ERR_001)-1))
+ {
+ RecvErr("Error Msg:", strip_info);
+ printk(KERN_INFO "%s: Radio %s is not in StarMode\n",
+ strip_info->dev.name, sendername);
+ }
+ else if (!strncmp(msg, ERR_002, sizeof(ERR_002)-1))
+ {
+ RecvErr("Error Msg:", strip_info);
+#ifdef notyet /*Kernel doesn't have scanf!*/
+ int handle;
+ __u8 newname[64];
+ sscanf(msg, "ERR_002 Remap handle &%d to name %s", &handle, newname);
+ printk(KERN_INFO "%s: Radio name %s is handle %d\n",
+ strip_info->dev.name, newname, handle);
+#endif
+ }
+ else if (!strncmp(msg, ERR_003, sizeof(ERR_003)-1))
+ {
+ RecvErr("Error Msg:", strip_info);
+ printk(KERN_INFO "%s: Destination radio name is unknown\n",
+ strip_info->dev.name);
+ }
+ else if (!strncmp(msg, ERR_004, sizeof(ERR_004)-1))
+ {
+ strip_info->watchdog_doreset = jiffies + LongTime;
+ if (!strip_info->working)
+ {
+ strip_info->working = TRUE;
+ printk(KERN_INFO "%s: Radio now in starmode\n",
+ strip_info->dev.name);
+ /*
+ * If the radio has just entered a working state, we should do our first
+ * probe ASAP, so that we find out our radio address etc. without delay.
+ */
+ strip_info->watchdog_doprobe = jiffies;
+ }
+ if (!strip_info->structured_messages && sendername)
+ {
+ strip_info->structured_messages = TRUE;
+ printk(KERN_INFO "%s: Radio provides structured messages\n",
+ strip_info->dev.name);
+ }
+ }
+ else if (!strncmp(msg, ERR_005, sizeof(ERR_005)-1))
+ RecvErr("Error Msg:", strip_info);
+ else if (!strncmp(msg, ERR_006, sizeof(ERR_006)-1))
+ RecvErr("Error Msg:", strip_info);
+ else if (!strncmp(msg, ERR_007, sizeof(ERR_007)-1))
+ {
+ /*
+ * Note: This error knocks the radio back into
+ * command mode.
+ */
+ RecvErr("Error Msg:", strip_info);
+ printk(KERN_ERR "%s: Error! Packet size too big for radio.",
+ strip_info->dev.name);
+ strip_info->watchdog_doreset = jiffies; /* Do reset ASAP */
+ }
+ else if (!strncmp(msg, ERR_008, sizeof(ERR_008)-1))
+ {
+ RecvErr("Error Msg:", strip_info);
+ printk(KERN_ERR "%s: Radio name contains illegal character\n",
+ strip_info->dev.name);
+ }
+ else if (!strncmp(msg, ERR_009, sizeof(ERR_009)-1))
+ RecvErr("Error Msg:", strip_info);
+ else
+ RecvErr("Error Msg:", strip_info);
+}
+
+static void process_AT_response(struct strip *strip_info, __u8 *ptr, __u8 *end)
+{
+ static const char ATS305[] = "ATS305?";
+ static const char ATS300[] = "ATS300?";
+ static const char ATS325[] = "ATS325?";
+ static const char ATI2[] = "AT~I2 nn";
+
+ /* Skip to the first newline character */
+ __u8 *p = ptr;
+ while (p < end && *p != 10) p++;
+ if (p >= end) return;
+ p++;
+
+ if (!strncmp(ptr, ATS305, sizeof(ATS305)-1))
+ {
+ if (IS_RADIO_ADDRESS(p)) get_radio_address(strip_info, p);
+ }
+ else if (!strncmp(ptr, ATS300, sizeof(ATS300)-1)) {
+ get_radio_version(strip_info, p, end);
+ }
+ else if (!strncmp(ptr, ATS325, sizeof(ATS325)-1)) {
+ get_radio_voltage(strip_info, p, end);
+ }
+ else if (!strncmp(ptr, ATI2, sizeof(ATI2)-1)) {
+ get_radio_neighbors(strip_info, p, end);
+ }
+ else RecvErr("Unknown AT Response:", strip_info);
+}
+
+/*
+ * Send one completely decapsulated datagram to the next layer.
+ */
+
+static void deliver_packet(struct strip *strip_info, STRIP_Header *header, __u16 packetlen)
+{
+ struct sk_buff *skb = dev_alloc_skb(sizeof(STRIP_Header) + packetlen);
+ if (!skb)
+ {
+ printk(KERN_INFO "%s: memory squeeze, dropping packet.\n", strip_info->dev.name);
+ strip_info->rx_dropped++;
+ }
+ else
+ {
+ memcpy(skb_put(skb, sizeof(STRIP_Header)), header, sizeof(STRIP_Header));
+ memcpy(skb_put(skb, packetlen), strip_info->rx_buff, packetlen);
+ skb->dev = &strip_info->dev;
+ skb->protocol = header->protocol;
+ skb->mac.raw = skb->data;
+
+ /* Having put a fake header on the front of the sk_buff for the */
+ /* benefit of tools like tcpdump, skb_pull now 'consumes' that */
+ /* fake header before we hand the packet up to the next layer. */
+ skb_pull(skb, sizeof(STRIP_Header));
+
+ /* Finally, hand the packet up to the next layer (e.g. IP or ARP, etc.) */
+ strip_info->rx_packets++;
+ netif_rx(skb);
+ }
+}
+
+static void process_IP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
+{
+ __u16 packetlen;
+
+#if DO_PROC_NET_STRIP_TRACE
+ __u8 *start_ptr = ptr;
+#endif DO_PROC_NET_STRIP_TRACE
+
+ /* Decode start of the IP packet header */
+ ptr = UnStuffData(ptr, end, strip_info->rx_buff, 4);
+ if (!ptr)
+ {
+ RecvErr("IP Packet too short", strip_info);
+ return;
+ }
+
+ packetlen = ((__u16)strip_info->rx_buff[2] << 8) | strip_info->rx_buff[3];
+
+ if (packetlen > MAX_STRIP_MTU)
+ {
+ printk(KERN_ERR "%s: Dropping oversized receive packet: %d bytes\n",
+ strip_info->dev.name, packetlen);
+ strip_info->rx_dropped++;
+ return;
+ }
+
+ /*printk(KERN_INFO "%s: Got %d byte IP packet\n", strip_info->dev.name, packetlen);*/
+
+ /* Decode remainder of the IP packet */
+ ptr = UnStuffData(ptr, end, strip_info->rx_buff+4, packetlen-4);
+ if (!ptr)
+ {
+ RecvErr("IP Packet too short", strip_info);
+ return;
+ }
+
+ if (ptr < end)
+ {
+ RecvErr("IP Packet too long", strip_info);
+ return;
+ }
+
+ header->protocol = htons(ETH_P_IP);
+
+#if DO_PROC_NET_STRIP_TRACE
+ packet_log(strip_info, strip_info->rx_buff, EntryReceive, header,
+ packetlen, end-start_ptr, slip_len(strip_info->rx_buff, packetlen));
+#endif DO_PROC_NET_STRIP_TRACE
+
+ deliver_packet(strip_info, header, packetlen);
+}
+
+static void process_ARP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
+{
+ __u16 packetlen;
+ struct arphdr *arphdr = (struct arphdr *)strip_info->rx_buff;
+
+#if DO_PROC_NET_STRIP_TRACE
+ __u8 *start_ptr = ptr;
+#endif DO_PROC_NET_STRIP_TRACE
+
+ /* Decode start of the ARP packet */
+ ptr = UnStuffData(ptr, end, strip_info->rx_buff, 8);
+ if (!ptr)
+ {
+ RecvErr("ARP Packet too short", strip_info);
+ return;
+ }
+
+ packetlen = 8 + (arphdr->ar_hln + arphdr->ar_pln) * 2;
+
+ if (packetlen > MAX_STRIP_MTU)
+ {
+ printk(KERN_ERR "%s: Dropping oversized receive packet: %d bytes\n",
+ strip_info->dev.name, packetlen);
+ strip_info->rx_dropped++;
+ return;
+ }
+
+ /*printk(KERN_INFO "%s: Got %d byte ARP %s\n",
+ strip_info->dev.name, packetlen,
+ ntohs(arphdr->ar_op) == ARPOP_REQUEST ? "request" : "reply");*/
+
+ /* Decode remainder of the ARP packet */
+ ptr = UnStuffData(ptr, end, strip_info->rx_buff+8, packetlen-8);
+ if (!ptr)
+ {
+ RecvErr("ARP Packet too short", strip_info);
+ return;
+ }
+
+ if (ptr < end)
+ {
+ RecvErr("ARP Packet too long", strip_info);
+ return;
+ }
+
+ header->protocol = htons(ETH_P_ARP);
+
+#if DO_PROC_NET_STRIP_TRACE
+ packet_log(strip_info, strip_info->rx_buff, EntryReceive, header,
+ packetlen, end-start_ptr, slip_len(strip_info->rx_buff, packetlen));
+#endif DO_PROC_NET_STRIP_TRACE
+
+ deliver_packet(strip_info, header, packetlen);
+}
+
+static void process_packet(struct strip *strip_info)
+{
+ STRIP_Header header = { zero_address, zero_address, 0 };
+ __u8 *ptr = strip_info->sx_buff;
+ __u8 *end = strip_info->sx_buff + strip_info->sx_count;
+ __u8 sendername[32], *sptr = sendername;
+ MetricomKey key;
+
+ /* Ignore 'OK' responses from prior commands */
+ if (strip_info->sx_count == 2 && ptr[0] == 'O' && ptr[1] == 'K') return;
+
+ /* Check for anything that looks like it might be our radio name: dddd-dddd */
+ /* (This is here for backwards compatibility with old firmware) */
+ if (strip_info->sx_count == 9 && IS_RADIO_ADDRESS(ptr))
+ {
+ get_radio_address(strip_info, ptr);
+ return;
+ }
+
+ /*HexDump("Receiving", strip_info, ptr, end);*/
+
+ /* Check for start of address marker, and then skip over it */
+ if (*ptr != '*')
+ {
+ /* Catch other error messages */
+ if (ptr[0] == 'E' && ptr[1] == 'R' && ptr[2] == 'R' && ptr[3] == '_')
+ RecvErr_Message(strip_info, NULL, &ptr[4]);
+ else RecvErr("No initial *", strip_info);
+ return;
+ }
+ ptr++; /* Skip the initial '*' */
+
+ /* Copy out the return address */
+ while (ptr < end && *ptr != '*' && sptr < ARRAY_END(sendername)-1) *sptr++ = *ptr++;
+ *sptr = 0; /* Null terminate the sender name */
+
+ /* Check for end of address marker, and skip over it */
+ if (ptr >= end || *ptr != '*')
+ {
+ RecvErr("No second *", strip_info);
+ return;
+ }
+ ptr++; /* Skip the second '*' */
+
+ /* If the sender name is "&COMMAND", ignore this 'packet' */
+ /* (This is here for backwards compatibility with old firmware) */
+ if (!strcmp(sendername, "&COMMAND"))
+ {
+ strip_info->structured_messages = FALSE;
+ return;
+ }
+
+ if (ptr+4 >= end)
+ {
+ RecvErr("No proto key", strip_info);
+ return;
+ }
+
+ /*printk(KERN_INFO "%s: Got packet from \"%s\".\n", strip_info->dev.name, sendername);*/
+
+ /*
+ * Fill in (pseudo) source and destination addresses in the packet.
+ * We assume that the destination address was our address (the radio does not
+ * tell us this). If the radio supplies a source address, then we use it.
+ */
+ memcpy(&header.dst_addr, strip_info->dev.dev_addr, sizeof(MetricomAddress));
+ if (IS_RADIO_ADDRESS(sendername)) string_to_radio_address(&header.src_addr, sendername);
+
+ /* Get the protocol key out of the buffer */
+ key.c[0] = *ptr++;
+ key.c[1] = *ptr++;
+ key.c[2] = *ptr++;
+ key.c[3] = *ptr++;
+
+ if (key.l == SIP0Key.l) process_IP_packet(strip_info, &header, ptr, end);
+ else if (key.l == ARP0Key.l) process_ARP_packet(strip_info, &header, ptr, end);
+ else if (key.l == ATR_Key.l) process_AT_response(strip_info, ptr, end);
+ else if (key.l == ERR_Key.l) RecvErr_Message(strip_info, sendername, ptr);
+ else /* RecvErr("Unrecognized protocol key", strip_info); */
+
+ /* Note, this "else" block is temporary, until Metricom fix their */
+ /* packet corruption bug */
+ {
+ RecvErr("Unrecognized protocol key (retrying)", strip_info);
+ ptr -= 3; /* Back up and try again */
+ key.c[0] = *ptr++;
+ key.c[1] = *ptr++;
+ key.c[2] = *ptr++;
+ key.c[3] = *ptr++;
+ if (key.l == SIP0Key.l) process_IP_packet(strip_info, &header, ptr, end);
+ else if (key.l == ARP0Key.l) process_ARP_packet(strip_info, &header, ptr, end);
+ else if (key.l == ATR_Key.l) process_AT_response(strip_info, ptr, end);
+ else if (key.l == ERR_Key.l) RecvErr_Message(strip_info, sendername, ptr);
+ else RecvErr("Unrecognized protocol key", strip_info);
+ }
+}
+
+/*
+ * Handle the 'receiver data ready' interrupt.
+ * This function is called by the 'tty_io' module in the kernel when
+ * a block of STRIP data has been received, which can now be decapsulated
+ * and sent on to some IP layer for further processing.
+ */
+
+static void
+strip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
+{
+ struct strip *strip_info = (struct strip *) tty->disc_data;
+ const unsigned char *end = cp + count;
+
+ if (!strip_info || strip_info->magic != STRIP_MAGIC || !strip_info->dev.start)
+ return;
+
+ /* Argh! mtu change time! - costs us the packet part received at the change */
+ if (strip_info->mtu != strip_info->dev.mtu)
+ strip_changedmtu(strip_info);
+
+#if 0
+ {
+ struct timeval tv;
+ do_gettimeofday(&tv);
+ printk(KERN_INFO "**** strip_receive_buf: %3d bytes at %d.%06d\n",
+ count, tv.tv_sec % 100, tv.tv_usec);
+ }
+#endif
+
+ /* Read the characters out of the buffer */
+ while (cp < end)
+ {
+ if (fp && *fp++ && !strip_info->discard) /* If there's a serial error, record it */
+ {
+ strip_info->discard = 1;
+ strip_info->rx_errors++;
+ }
+
+ /* Leading control characters (CR, NL, Tab, etc.) are ignored */
+ if (strip_info->sx_count > 0 || *cp >= ' ')
+ {
+ if (*cp == 0x0D) /* If end of packet, decide what to do with it */
+ {
+ if (strip_info->sx_count > 3000)
+ printk(KERN_INFO "Cut a %d byte packet (%d bytes remaining)%s\n",
+ strip_info->sx_count, end-cp-1,
+ strip_info->discard ? " (discarded)" : "");
+ if (strip_info->sx_count > strip_info->sx_size)
+ {
+ strip_info->discard = 1;
+ strip_info->rx_over_errors++;
+ printk(KERN_INFO "%s: sx_buff overflow (%d bytes total)\n",
+ strip_info->dev.name, strip_info->sx_count);
+ }
+ if (!strip_info->discard) process_packet(strip_info);
+ strip_info->discard = 0;
+ strip_info->sx_count = 0;
+ }
+ else if (!strip_info->discard) /* If we're not discarding, store the character */
+ {
+ /* Make sure we have space in the buffer */
+ if (strip_info->sx_count < strip_info->sx_size)
+ strip_info->sx_buff[strip_info->sx_count] = *cp;
+ strip_info->sx_count++;
+ }
+ }
+ cp++;
+ }
+}
+
+
+/************************************************************************/
+/* General control routines */
+
+static int strip_set_dev_mac_address(struct device *dev, void *addr)
+{
+ return -1; /* You cannot override a Metricom radio's address */
+}
+
+static struct enet_statistics *strip_get_stats(struct device *dev)
+{
+ static struct enet_statistics stats;
+ struct strip *strip_info = (struct strip *)(dev->priv);
+
+ memset(&stats, 0, sizeof(struct enet_statistics));
+
+ stats.rx_packets = strip_info->rx_packets;
+ stats.tx_packets = strip_info->tx_packets;
+ stats.rx_dropped = strip_info->rx_dropped;
+ stats.tx_dropped = strip_info->tx_dropped;
+ stats.tx_errors = strip_info->tx_errors;
+ stats.rx_errors = strip_info->rx_errors;
+ stats.rx_over_errors = strip_info->rx_over_errors;
+ return(&stats);
+}
+
+
+/************************************************************************/
+/* Opening and closing */
+
+/*
+ * Here's the order things happen:
+ * When the user runs "slattach -p strip ..."
+ * 1. The TTY module calls strip_open
+ * 2. strip_open calls strip_alloc
+ * 3. strip_alloc calls register_netdev
+ * 4. register_netdev calls strip_dev_init
+ * 5. then strip_open finishes setting up the strip_info
+ *
+ * When the user runs "ifconfig st<x> up address netmask ..."
+ * 6. strip_open_low gets called
+ *
+ * When the user runs "ifconfig st<x> down"
+ * 7. strip_close_low gets called
+ *
+ * When the user kills the slattach process
+ * 8. strip_close gets called
+ * 9. strip_close calls dev_close
+ * 10. if the device is still up, then dev_close calls strip_close_low
+ * 11. strip_close calls strip_free
+ */
+
+/* Open the low-level part of the STRIP channel. Easy! */
+
+static int strip_open_low(struct device *dev)
+{
+ struct strip *strip_info = (struct strip *)(dev->priv);
+
+ if (strip_info->tty == NULL)
+ return(-ENODEV);
+
+ if (!allocate_buffers(strip_info))
+ return(-ENOMEM);
+
+ strip_info->discard = 0;
+ strip_info->working = FALSE;
+ strip_info->structured_messages = FALSE;
+ strip_info->sx_count = 0;
+ strip_info->tx_left = 0;
+
+ /*
+ * Needed because address '0' is special
+ */
+
+ if (dev->pa_addr == 0)
+ dev->pa_addr=ntohl(0xC0A80001);
+ dev->tbusy = 0;
+ dev->start = 1;
+
+ printk(KERN_INFO "%s: Initializing Radio.\n", strip_info->dev.name);
+ ResetRadio(strip_info);
+ strip_info->idle_timer.expires = jiffies + 2 * HZ;
+ add_timer(&strip_info->idle_timer);
+ return(0);
+}
+
+
+/*
+ * Close the low-level part of the STRIP channel. Easy!
+ */
+
+static int strip_close_low(struct device *dev)
+{
+ struct strip *strip_info = (struct strip *)(dev->priv);
+
+ if (strip_info->tty == NULL)
+ return -EBUSY;
+ strip_info->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
+ dev->tbusy = 1;
+ dev->start = 0;
+
+ /*
+ * Free all STRIP frame buffers.
+ */
+ if (strip_info->rx_buff)
+ {
+ kfree(strip_info->rx_buff);
+ strip_info->rx_buff = NULL;
+ }
+ if (strip_info->sx_buff)
+ {
+ kfree(strip_info->sx_buff);
+ strip_info->sx_buff = NULL;
+ }
+ if (strip_info->tx_buff)
+ {
+ kfree(strip_info->tx_buff);
+ strip_info->tx_buff = NULL;
+ }
+ del_timer(&strip_info->idle_timer);
+ return 0;
+}
+
+/*
+ * This routine is called by DDI when the
+ * (dynamically assigned) device is registered
+ */
+
+static int strip_dev_init(struct device *dev)
+{
+ int i;
+
+ /*
+ * Finish setting up the DEVICE info.
+ */
+
+ dev->trans_start = 0;
+ dev->last_rx = 0;
+ dev->tx_queue_len = 30; /* Drop after 30 frames queued */
+
+ dev->flags = 0;
+ dev->family = AF_INET;
+ dev->metric = 0;
+ dev->mtu = DEFAULT_STRIP_MTU;
+ dev->type = ARPHRD_METRICOM; /* dtang */
+ dev->hard_header_len = sizeof(STRIP_Header);
+ /*
+ * dev->priv Already holds a pointer to our struct strip
+ */
+
+ *(MetricomAddress*)&dev->broadcast = broadcast_address;
+ dev->dev_addr[0] = 0;
+ dev->addr_len = sizeof(MetricomAddress);
+ dev->pa_addr = 0;
+ dev->pa_brdaddr = 0;
+ dev->pa_mask = 0;
+ dev->pa_alen = sizeof(unsigned long);
+
+ /*
+ * Pointer to the interface buffers.
+ */
+
+ for (i = 0; i < DEV_NUMBUFFS; i++)
+ skb_queue_head_init(&dev->buffs[i]);
+
+ /*
+ * Pointers to interface service routines.
+ */
+
+ dev->open = strip_open_low;
+ dev->stop = strip_close_low;
+ dev->hard_start_xmit = strip_xmit;
+ dev->hard_header = strip_header;
+ dev->rebuild_header = strip_rebuild_header;
+ /* dev->type_trans unused */
+ /* dev->set_multicast_list unused */
+ dev->set_mac_address = strip_set_dev_mac_address;
+ /* dev->do_ioctl unused */
+ /* dev->set_config unused */
+ dev->get_stats = strip_get_stats;
+ return 0;
+}
+
+/*
+ * Free a STRIP channel.
+ */
+
+static void strip_free(struct strip *strip_info)
+{
+ MetricomNode *node, *free;
+
+ *(strip_info->referrer) = strip_info->next;
+ if (strip_info->next)
+ strip_info->next->referrer = strip_info->referrer;
+ strip_info->magic = 0;
+
+ for (node = strip_info->neighbor_list; node != NULL; )
+ {
+ free = node;
+ node = node->next;
+ kfree(free);
+ }
+ kfree(strip_info);
+}
+
+/*
+ * Allocate a new free STRIP channel
+ */
+
+static struct strip *strip_alloc(void)
+{
+ int channel_id = 0;
+ struct strip **s = &struct_strip_list;
+ struct strip *strip_info = (struct strip *)
+ kmalloc(sizeof(struct strip), GFP_KERNEL);
+
+ if (!strip_info)
+ return(NULL); /* If no more memory, return */
+
+ /*
+ * Clear the allocated memory
+ */
+
+ memset(strip_info, 0, sizeof(struct strip));
+
+ /*
+ * Search the list to find where to put our new entry
+ * (and in the process decide what channel number it is
+ * going to be)
+ */
+
+ while (*s && (*s)->dev.base_addr == channel_id)
+ {
+ channel_id++;
+ s = &(*s)->next;
+ }
+
+ /*
+ * Fill in the link pointers
+ */
+
+ strip_info->next = *s;
+ if (*s)
+ (*s)->referrer = &strip_info->next;
+ strip_info->referrer = s;
+ *s = strip_info;
+
+ strip_info->magic = STRIP_MAGIC;
+ strip_info->tty = NULL;
+
+ strip_info->gratuitous_arp = jiffies + LongTime;
+ strip_info->arp_interval = 0;
+ init_timer(&strip_info->idle_timer);
+ strip_info->idle_timer.data = (long)&strip_info->dev;
+ strip_info->idle_timer.function = strip_IdleTask;
+
+ strip_info->neighbor_list = kmalloc(sizeof(MetricomNode), GFP_KERNEL);
+ strip_info->neighbor_list->type = 0;
+ strip_info->neighbor_list->next = NULL;
+
+ /* Note: strip_info->if_name is currently 8 characters long */
+ sprintf(strip_info->if_name, "st%d", channel_id);
+ strip_info->dev.name = strip_info->if_name;
+ strip_info->dev.base_addr = channel_id;
+ strip_info->dev.priv = (void*)strip_info;
+ strip_info->dev.next = NULL;
+ strip_info->dev.init = strip_dev_init;
+
+ return(strip_info);
+}
+
+/*
+ * Open the high-level part of the STRIP channel.
+ * This function is called by the TTY module when the
+ * STRIP line discipline is called for. Because we are
+ * sure the tty line exists, we only have to link it to
+ * a free STRIP channel...
+ */
+
+static int strip_open(struct tty_struct *tty)
+{
+ struct strip *strip_info = (struct strip *) tty->disc_data;
+
+ /*
+ * First make sure we're not already connected.
+ */
+
+ if (strip_info && strip_info->magic == STRIP_MAGIC)
+ return -EEXIST;
+
+ /*
+ * OK. Find a free STRIP channel to use.
+ */
+ if ((strip_info = strip_alloc()) == NULL)
+ return -ENFILE;
+
+ /*
+ * Register our newly created device so it can be ifconfig'd
+ * strip_dev_init() will be called as a side-effect
+ */
+
+ if (register_netdev(&strip_info->dev) != 0)
+ {
+ printk(KERN_ERR "strip: register_netdev() failed.\n");
+ strip_free(strip_info);
+ return -ENFILE;
+ }
+
+ strip_info->tty = tty;
+ tty->disc_data = strip_info;
+ if (tty->driver.flush_buffer)
+ tty->driver.flush_buffer(tty);
+ if (tty->ldisc.flush_buffer)
+ tty->ldisc.flush_buffer(tty);
+
+ /*
+ * Restore default settings
+ */
+
+ strip_info->dev.type = ARPHRD_METRICOM; /* dtang */
+
+ /*
+ * Set tty options
+ */
+
+ tty->termios->c_iflag |= IGNBRK |IGNPAR;/* Ignore breaks and parity errors. */
+ tty->termios->c_cflag |= CLOCAL; /* Ignore modem control signals. */
+ tty->termios->c_cflag &= ~HUPCL; /* Don't close on hup */
+
+#ifdef MODULE
+ MOD_INC_USE_COUNT;
+#endif
+ /*
+ * Done. We have linked the TTY line to a channel.
+ */
+ return(strip_info->dev.base_addr);
+}
+
+/*
+ * Close down a STRIP channel.
+ * This means flushing out any pending queues, and then restoring the
+ * TTY line discipline to what it was before it got hooked to STRIP
+ * (which usually is TTY again).
+ */
+
+static void strip_close(struct tty_struct *tty)
+{
+ struct strip *strip_info = (struct strip *) tty->disc_data;
+
+ /*
+ * First make sure we're connected.
+ */
+
+ if (!strip_info || strip_info->magic != STRIP_MAGIC)
+ return;
+
+ dev_close(&strip_info->dev);
+ unregister_netdev(&strip_info->dev);
+
+ tty->disc_data = 0;
+ strip_info->tty = NULL;
+ strip_free(strip_info);
+ tty->disc_data = NULL;
+#ifdef MODULE
+ MOD_DEC_USE_COUNT;
+#endif
+}
+
+
+/************************************************************************/
+/* Perform I/O control calls on an active STRIP channel. */
+
+static int strip_ioctl(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct strip *strip_info = (struct strip *) tty->disc_data;
+ int err;
+
+ /*
+ * First make sure we're connected.
+ */
+
+ if (!strip_info || strip_info->magic != STRIP_MAGIC)
+ return -EINVAL;
+
+ switch(cmd)
+ {
+ case SIOCGIFNAME:
+ err = verify_area(VERIFY_WRITE, (void*)arg, 16);
+ if (err)
+ return -err;
+ copy_to_user((void*)arg, strip_info->dev.name,
+ strlen(strip_info->dev.name) + 1);
+ return 0;
+
+ case SIOCSIFHWADDR:
+ return -EINVAL;
+
+ /*
+ * Allow stty to read, but not set, the serial port
+ */
+
+ case TCGETS:
+ case TCGETA:
+ return n_tty_ioctl(tty, (struct file *) file, cmd,
+ (unsigned long) arg);
+
+ default:
+ return -ENOIOCTLCMD;
+ }
+}
+
+
+/************************************************************************/
+/* Initialization */
+
+/*
+ * Registers with the /proc file system to create different /proc/net files.
+ */
+
+static int strip_proc_net_register(unsigned short type, char *file_name,
+ int (*get_info)(char *, char **, off_t, int, int))
+{
+ struct proc_dir_entry *strip_entry;
+
+ strip_entry = kmalloc(sizeof(struct proc_dir_entry), GFP_ATOMIC);
+
+ memset(strip_entry, 0, sizeof(struct proc_dir_entry));
+ strip_entry->low_ino = type;
+ strip_entry->namelen = strlen(file_name);
+ strip_entry->name = file_name;
+ strip_entry->mode = S_IFREG | S_IRUGO;
+ strip_entry->nlink = 1;
+ strip_entry->uid = 0;
+ strip_entry->gid = 0;
+ strip_entry->size = 0;
+ strip_entry->ops = &proc_net_inode_operations;
+ strip_entry->get_info = get_info;
+
+ return proc_net_register(strip_entry);
+}
+
+/*
+ * Initialize the STRIP driver.
+ * This routine is called at boot time, to bootstrap the multi-channel
+ * STRIP driver
+ */
+
+#ifdef MODULE
+static
+#endif
+int strip_init_ctrl_dev(struct device *dummy)
+{
+ static struct tty_ldisc strip_ldisc;
+ int status;
+
+ printk("STRIP: version %s (unlimited channels)\n", StripVersion);
+
+ /*
+ * Fill in our line protocol discipline, and register it
+ */
+
+ memset(&strip_ldisc, 0, sizeof(strip_ldisc));
+ strip_ldisc.magic = TTY_LDISC_MAGIC;
+ strip_ldisc.flags = 0;
+ strip_ldisc.open = strip_open;
+ strip_ldisc.close = strip_close;
+ strip_ldisc.read = NULL;
+ strip_ldisc.write = NULL;
+ strip_ldisc.ioctl = strip_ioctl;
+ strip_ldisc.select = NULL;
+ strip_ldisc.receive_buf = strip_receive_buf;
+ strip_ldisc.receive_room = strip_receive_room;
+ strip_ldisc.write_wakeup = strip_write_some_more;
+ status = tty_register_ldisc(N_STRIP, &strip_ldisc);
+ if (status != 0)
+ {
+ printk(KERN_ERR "STRIP: can't register line discipline (err = %d)\n", status);
+ }
+
+ /*
+ * Register the status and trace files with /proc
+ */
+
+#if DO_PROC_NET_STRIP_STATUS
+ if (strip_proc_net_register(PROC_NET_STRIP_STATUS, "strip_status",
+ &strip_get_status_info) != 0)
+ {
+ printk(KERN_ERR "strip: status strip_proc_net_register() failed.\n");
+ }
+#endif
+
+#if DO_PROC_NET_STRIP_TRACE
+ if (strip_proc_net_register(PROC_NET_STRIP_TRACE, "strip_trace",
+ &strip_get_trace_info) != 0)
+ {
+ printk(KERN_ERR "strip: trace strip_proc_net_register() failed.\n");
+ }
+#endif
+
+#ifdef MODULE
+ return status;
+#else
+
+ /* Return "not found", so that dev_init() will unlink
+ * the placeholder device entry for us.
+ */
+ return ENODEV;
+#endif
+}
+
+
+/************************************************************************/
+/* From here down is only used when compiled as an external module */
+
+#ifdef MODULE
+
+int init_module(void)
+{
+ return strip_init_ctrl_dev(0);
+}
+
+void cleanup_module(void)
+{
+ int i;
+ while (struct_strip_list)
+ strip_free(struct_strip_list);
+
+ /* Unregister with the /proc/net files here. */
+
+#if DO_PROC_NET_STRIP_TRACE
+ proc_net_unregister(PROC_NET_STRIP_TRACE);
+#endif
+#if DO_PROC_NET_STRIP_STATUS
+ proc_net_unregister(PROC_NET_STRIP_STATUS);
+#endif
+
+ if ((i = tty_register_ldisc(N_STRIP, NULL)))
+ printk(KERN_ERR "STRIP: can't unregister line discipline (err = %d)\n", i);
+}
+#endif /* MODULE */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 02:49:31 +0000