patch-2.0.13 linux/drivers/net/strip.c
Next file: linux/drivers/pci/pci.c
Previous file: linux/drivers/cdrom/sbpcd.c
Back to the patch index
Back to the overall index
- Lines: 3833
- Date:
Wed Aug 14 10:21:03 1996
- Orig file:
v2.0.12/linux/drivers/net/strip.c
- Orig date:
Fri Apr 12 09:49:39 1996
diff -u --recursive --new-file v2.0.12/linux/drivers/net/strip.c linux/drivers/net/strip.c
@@ -14,33 +14,82 @@
* 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.1 3/6/95
+ * Version: @(#)strip.c 0.9.8 June 1996
*
* Author: Stuart Cheshire <cheshire@cs.stanford.edu>
*
- * Fixes:
- * Stuart Cheshire:
- * Original version converted from SLIP driver
- * Jonathan Stone:
- * change to 1.3 calling conventions
- * Stuart Cheshire:
- * 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
+ * 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/segment.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>
@@ -52,82 +101,316 @@
#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
-#ifdef MODULE
-#define STRIP_VERSION "0.9.1-STUART.CHESHIRE-MODULAR"
-#else
-#define STRIP_VERSION "0.9.1-STUART.CHESHIRE"
-#endif
-#define STRIP_MTU 1024
-#define STRIP_MAGIC 0x5303
+/************************************************************************/
+/* Useful structures and definitions */
/*
- * Do we still needs all these flags?
+ * A MetricomKey identifies the protocol being carried inside a Metricom
+ * Starmode packet.
*/
-enum
+typedef union
{
- STR_INUSE = 0, /* Channel in use */
- STR_ESCAPE, /* ESC received */
- STR_ERROR /* Parity, etc. error */
-}
-STRIP_FLAGS;
+ __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.)
+ */
-struct strip
+typedef union
{
- int magic;
- /*
- * Other useful structures.
- */
+ __u8 b[4];
+ __u32 l;
+} IPaddr;
- /*
- * These are pointers to the malloc()ed frame buffers.
- */
+/*
+ * A MetricomAddressString is used to hold a printable representation of
+ * a Metricom address.
+ */
- 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 */
- unsigned char *tx_buff; /* transmitter buffer */
- unsigned char *tx_head; /* pointer to next byte to XMIT */
- int tx_left; /* bytes left in XMIT queue */
+typedef struct
+{
+ __u8 c[24];
+} MetricomAddressString;
- /*
- * 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. */
+/*
+ * 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.
+ */
- /*
- * Internal variables.
- */
-
- struct strip *next; /* The next struct in the list */
- struct strip **referrer; /* The pointer that points to us */
- unsigned char flags; /* Flag values/ mode etc */
- int mtu; /* Our mtu (to spot changes!) */
- int buffsize; /* Max buffers sizes */
- long watchdog_doprobe; /* Next time to test the radio */
- long watchdog_doreset; /* Time to do next reset */
- struct timer_list idle_timer;
-
- struct tty_struct *tty; /* ptr to TTY structure */
- char if_name[8]; /* Dynamically generated name */
- struct device dev; /* Our device structure */
+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;
+
/************************************************************************/
-/* Utility routines for disabling and restoring interrupts */
+/* 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;
@@ -144,62 +427,67 @@
restore_flags(x);
}
-/************************************************************************/
-/* Useful structures and definitions */
-
-typedef struct {
- __u8 c[32];
-} RadioName;
-
-typedef struct {
- __u8 c[ 4];
-} MetricomKey;
+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;
-typedef union {
- __u8 b[ 4];
- __u32 l;
-} IPaddr;
+ *p++ = '\"';
-static const MetricomKey ProtocolKey =
-{
+ while (ptr<end && p < &pkt_text[MAX_DumpData-4])
{
- "SIP0"
+ if (*ptr == '\\')
+ {
+ *p++ = '\\';
+ *p++ = '\\';
+ }
+ else
+ {
+ if (*ptr >= 32 && *ptr <= 126)
+ {
+ *p++ = *ptr;
+ }
+ else
+ {
+ sprintf(p, "\\%02X", *ptr);
+ p+= 3;
+ }
+ }
+ ptr++;
}
-};
-enum
-{
- FALSE = 0,
- TRUE = 1
-};
+ if (ptr == end)
+ {
+ *p++ = '\"';
+ }
-#define LONG_TIME 0x7FFFFFFF
+ *p++ = 0;
-typedef struct
-{
- RadioName name; /* The address, with delimiters eg. *0000-1164* */
- MetricomKey key; /* Protocol type */
-} STRIP_Header;
+ printk(KERN_INFO "%s: %-13s%s\n", strip_info->dev.name, msg, pkt_text);
+}
-typedef struct
+#if 0
+static void HexDump(char *msg, struct strip *strip_info, __u8 *start, __u8 *end)
{
- STRIP_Header h;
- __u8 data[4]; /* Placeholder for payload (The IP packet) */
-} STRIP_Packet;
+ __u8 *ptr = start;
+ printk(KERN_INFO "%s: %s: %d bytes\n", strip_info->dev.name, msg, end-ptr);
-/*
- * STRIP_ENCAP_SIZE of an IP packet is the STRIP header at the front,
- * byte-stuffing overhead of the payload, plus the CR at the end
- */
-
-#define STRIP_ENCAP_SIZE(X) (sizeof(STRIP_Header) + (X)*65L/64L + 2)
-
-/*
- * Note: A Metricom packet looks like this: *<address>*<key><payload><CR>
- * eg. *0000-1164*SIP0<payload><CR>
- */
+ 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
-static struct strip *struct_strip_list = NULL;
/************************************************************************/
/* Byte stuffing/unstuffing routines */
@@ -212,14 +500,14 @@
* C0-FF Run of 1-64 zeroes (ASCII 0)
*/
-typedef enum
+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,
@@ -244,431 +532,1156 @@
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;
- }
+ __u8 *end = src + length;
+ __u8 *code_ptr = *code_ptr_ptr;
+ __u8 code = Stuff_NoCode, count = 0;
- 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). */
+ 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);
+ __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 */
-/* 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.
+/*
+ * Convert a string to a Metricom Address.
*/
-static void strip_changedmtu(struct strip *strip_info)
+static void string_to_radio_address(MetricomAddress *addr, __u8 *p)
{
- struct device *dev = &strip_info->dev;
- unsigned char *tbuff, *rbuff, *sbuff, *otbuff, *orbuff, *osbuff;
- int len;
- InterruptStatus intstat;
-
- len = STRIP_ENCAP_SIZE(dev->mtu);
- if (len < STRIP_ENCAP_SIZE(576))
- len = STRIP_ENCAP_SIZE(576);
-
- tbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
- rbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
- sbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
- if (!tbuff || !rbuff || !sbuff)
- {
- printk("%s: unable to grow strip buffers, MTU change cancelled.\n",
- strip_info->dev.name);
- dev->mtu = strip_info->mtu;
- if (tbuff)
- kfree(tbuff);
- if (rbuff)
- kfree(rbuff);
- if (sbuff)
- kfree(sbuff);
- return;
- }
-
- intstat = DisableInterrupts();
- otbuff = strip_info->tx_buff; strip_info->tx_buff = tbuff;
- orbuff = strip_info->rx_buff; strip_info->rx_buff = rbuff;
- osbuff = strip_info->sx_buff; strip_info->sx_buff = sbuff;
- if (strip_info->tx_left)
- {
- if (strip_info->tx_left <= len)
- 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;
-
- if (strip_info->sx_count)
- {
- if (strip_info->sx_count <= len)
- memcpy(strip_info->sx_buff, osbuff, strip_info->sx_count);
- else
- {
- strip_info->sx_count = 0;
- strip_info->rx_over_errors++;
- set_bit(STR_ERROR, &strip_info->flags);
- }
- }
-
- strip_info->mtu = STRIP_ENCAP_SIZE(dev->mtu);
- strip_info->buffsize = len;
-
- RestoreInterrupts(intstat);
-
- if (otbuff != NULL)
- kfree(otbuff);
- if (orbuff != NULL)
- kfree(orbuff);
- if (osbuff != NULL)
- kfree(osbuff);
+ 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]);
}
-static void strip_unlock(struct strip *strip_info)
+/*
+ * Convert a Metricom Address to a string.
+ */
+
+static __u8 *radio_address_to_string(const MetricomAddress *addr, MetricomAddressString *p)
{
- strip_info->idle_timer.expires = jiffies + 2 * HZ;
- add_timer(&strip_info->idle_timer);
- if (!clear_bit(0, (void *)&strip_info->dev.tbusy))
- printk("%s: trying to unlock already unlocked device!\n",
- strip_info->dev.name);
+ sprintf(p->c, "%02X%02X-%02X%02X", addr->c[2], addr->c[3], addr->c[4], addr->c[5]);
+ return(p->c);
}
-/************************************************************************/
-/* Sending routines */
+/*
+ * 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 void ResetRadio(struct strip *strip_info)
-{
- static const char InitString[] = "ate0dt**starmode\r**";
- 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);
+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);
}
/*
- * Called by the driver when there's room for more data. If we have
- * more packets to send, we send them here.
+ * 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_write_some_more(struct tty_struct *tty)
+static void strip_changedmtu(struct strip *strip_info)
{
- InterruptStatus intstat;
- int num_written;
- 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 */
- /* Must disable interrupts because otherwise the write_wakeup might
- * happen before we've had a chance to update the tx_left and
- * tx_head fields
- */
- intstat = DisableInterrupts();
- 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);
- }
-}
+ 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;
+ }
-/* Encapsulate one IP datagram. */
+ /*
+ * 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();
-static unsigned char *strip_stuff(unsigned char *ptr, struct strip *strip_info, struct sk_buff *skb)
-{
- __u8 *start;
- __u8 *stuffstate = NULL;
- unsigned char *icp = skb->data;
- int len = skb->len;
- MetricomAddress haddr;
+ 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 (len > strip_info->mtu) { /* Sigh, shouldn't occur BUT ... */
- printk("%s: Dropping oversized transmit packet!\n", strip_info->dev.name);
- strip_info->tx_dropped++;
- return(NULL);
+ 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 (!arp_query(haddr.c, skb->raddr, &strip_info->dev)) {
- IPaddr a,b,c;
- a.l = skb->raddr;
- b.l = skb->saddr;
- c.l = skb->daddr;
- printk("%s: Unknown dest %d.%d.%d.%d s=%d.%d.%d.%d d=%d.%d.%d.%d\n",
- strip_info->dev.name,
- a.b[0], a.b[1], a.b[2], a.b[3],
- b.b[0], b.b[1], b.b[2], b.b[3],
- c.b[0], c.b[1], c.b[2], c.b[3]);
- strip_info->tx_dropped++;
- return(NULL);
+ 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;
- *ptr++ = '*';
- ptr[3] = '0' + haddr.s[0] % 10; haddr.s[0] /= 10;
- ptr[2] = '0' + haddr.s[0] % 10; haddr.s[0] /= 10;
- ptr[1] = '0' + haddr.s[0] % 10; haddr.s[0] /= 10;
- ptr[0] = '0' + haddr.s[0] % 10;
- ptr+=4;
- *ptr++ = '-';
- ptr[3] = '0' + haddr.s[1] % 10; haddr.s[1] /= 10;
- ptr[2] = '0' + haddr.s[1] % 10; haddr.s[1] /= 10;
- ptr[1] = '0' + haddr.s[1] % 10; haddr.s[1] /= 10;
- ptr[0] = '0' + haddr.s[1] % 10;
- ptr+=4;
- *ptr++ = '*';
- *ptr++ = ProtocolKey.c[0]; /* Protocol key */
- *ptr++ = ProtocolKey.c[1];
- *ptr++ = ProtocolKey.c[2];
- *ptr++ = ProtocolKey.c[3];
+ RestoreInterrupts(intstat);
- start = ptr;
- ptr = StuffData(icp, len, ptr, &stuffstate); /* Make payload */
+ printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
+ strip_info->dev.name, old_mtu, strip_info->mtu);
- *ptr++ = 0x0D; /* Put on final delimiter */
- return(ptr);
+ if (orbuff) kfree(orbuff);
+ if (osbuff) kfree(osbuff);
+ if (otbuff) kfree(otbuff);
}
-/* Encapsulate one IP datagram and stuff into a TTY queue. */
-static void strip_send(struct strip *strip_info, struct sk_buff *skb)
+static void strip_unlock(struct strip *strip_info)
{
- unsigned char *ptr;
-
- /* See if someone has been ifconfigging */
- if (strip_info->mtu != STRIP_ENCAP_SIZE(strip_info->dev.mtu))
- strip_changedmtu(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)
+ */
- ptr = strip_info->tx_buff;
+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_stuff(ptr, strip_info, skb);
+ 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 */
+ 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 */
@@ -677,238 +1690,528 @@
strip_info->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
/* If watchdog has expired, reset the radio */
- if ((long)jiffies - strip_info->watchdog_doreset >= 0) {
- printk("%s: No response: Resetting radio.\n", strip_info->dev.name);
+ 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;
}
-
- /* 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) {
- /* printk("%s: Routine radio test.\n", strip_info->dev.name); */
- *ptr++ = '*'; /* Tickle to make radio protest */
- *ptr++ = '*';
- strip_info->tx_left += 2;
- strip_info->watchdog_doprobe = jiffies + 10 * HZ;
- strip_info->watchdog_doreset = jiffies + 1 * HZ;
+
+ if (ptr < end)
+ {
+ RecvErr("IP Packet too long", strip_info);
+ return;
}
-
- /* All ready. Start the transmission */
- strip_write_some_more(strip_info->tty);
+
+ 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);
}
-/* Encapsulate an IP datagram and kick it into a TTY queue. */
-static int strip_xmit(struct sk_buff *skb, struct device *dev)
+static void process_ARP_packet(struct strip *strip_info, STRIP_Header *header, __u8 *ptr, __u8 *end)
{
- struct strip *strip_info = (struct strip *)(dev->priv);
+ __u16 packetlen;
+ struct arphdr *arphdr = (struct arphdr *)strip_info->rx_buff;
- if (!dev->start) {
- printk("%s: xmit call when iface is down\n", dev->name);
- return(1);
+#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;
}
- if (set_bit(0, (void *) &strip_info->dev.tbusy)) return(1);
- del_timer(&strip_info->idle_timer);
- strip_send(strip_info, skb);
- if (skb) dev_kfree_skb(skb, FREE_WRITE);
- return(0);
-}
-/* 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 */
+ packetlen = 8 + (arphdr->ar_hln + arphdr->ar_pln) * 2;
-static void strip_IdleTask(unsigned long parameter)
-{
- strip_xmit(NULL, (struct device *)parameter);
-}
+ 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;
+ }
-/************************************************************************/
-/* Receiving routines */
+ /*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;
+ }
-static int strip_receive_room(struct tty_struct *tty)
-{
- return 65536; /* We can handle an infinite amount of data. :-) */
-}
+ if (ptr < end)
+ {
+ RecvErr("ARP Packet too long", strip_info);
+ return;
+ }
-/* Send one completely decapsulated IP datagram to the IP layer. */
+ header->protocol = htons(ETH_P_ARP);
-static void strip_bump(struct strip *strip_info, __u16 packetlen)
-{
- int count = sizeof(STRIP_Header) + packetlen;
- struct sk_buff *skb = dev_alloc_skb(count);
- if (skb == NULL)
- {
- printk("%s: memory squeeze, dropping packet.\n",
- strip_info->dev.name);
- strip_info->rx_dropped++;
- return;
- }
- skb->dev = &strip_info->dev;
- memcpy(skb_put(skb, count), strip_info->rx_buff, count);
- skb->mac.raw=skb->data;
- skb->protocol = htons(ETH_P_IP);
- netif_rx(skb);
- strip_info->rx_packets++;
-}
+#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
-static void RecvErr(char *msg, struct strip *strip_info)
-{
- static const int MAX_RecvErr = 80;
- __u8 *ptr = strip_info->sx_buff;
- __u8 *end = strip_info->sx_buff + strip_info->sx_count;
- __u8 pkt_text[MAX_RecvErr], *p = pkt_text;
- *p++ = '\"';
- while (ptr<end && p < &pkt_text[MAX_RecvErr-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("%-13s%s\n", msg, pkt_text);
- set_bit(STR_ERROR, &strip_info->flags);
- strip_info->rx_errors++;
-}
-
-static void RecvErr_Message(struct strip *strip_info, __u8 *sendername, __u8 *msg)
-{
- static const char ERR_001[] = "ERR_001 Not in StarMode!";
- static const char ERR_002[] = "ERR_002 Remap handle";
- static const char ERR_003[] = "ERR_003 Can't resolve name";
- static const char ERR_004[] = "ERR_004 Name too small or missing";
- static const char ERR_007[] = "ERR_007 Body too big";
- static const char ERR_008[] = "ERR_008 Bad character in name";
-
- if (!strncmp(msg, ERR_001, sizeof(ERR_001)-1))
- printk("Radio %s is not in StarMode\n", sendername);
- else if (!strncmp(msg, ERR_002, sizeof(ERR_002)-1))
- {
-#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("Radio name %s is handle %d\n", newname, handle);
-#endif
- }
- else if (!strncmp(msg, ERR_003, sizeof(ERR_003)-1))
- printk("Radio name <unspecified> is unknown (\"Can't resolve name\" error)\n");
- else if (!strncmp(msg, ERR_004, sizeof(ERR_004)-1))
- strip_info->watchdog_doreset = jiffies + LONG_TIME;
- else if (!strncmp(msg, ERR_007, sizeof(ERR_007)-1))
- {
- /*
- * Note: This error knocks the radio back into
- * command mode.
- */
- printk("Error! Packet size <unspecified> is too big for radio.");
- strip_info->watchdog_doreset = jiffies; /* Do reset ASAP */
- }
- else if (!strncmp(msg, ERR_008, sizeof(ERR_008)-1))
- printk("Name <unspecified> contains illegal character\n");
- else
- RecvErr("Error Msg:", strip_info);
+ 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 *name, *name_end;
- __u16 packetlen;
+ __u8 sendername[32], *sptr = sendername;
+ MetricomKey key;
- /* Ignore empty lines */
- if (strip_info->sx_count == 0) return;
+ /* Ignore 'OK' responses from prior commands */
+ if (strip_info->sx_count == 2 && ptr[0] == 'O' && ptr[1] == 'K') return;
- /* Catch 'OK' responses which show radio has fallen out of starmode */
- if (strip_info->sx_count == 2 && ptr[0] == 'O' && ptr[1] == 'K') {
- printk("%s: Radio is back in AT command mode: Will Reset\n",
- strip_info->dev.name);
- strip_info->watchdog_doreset = jiffies; /* Do reset ASAP */
+ /* 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 != '*') {
+ if (*ptr != '*')
+ {
/* Catch other error messages */
if (ptr[0] == 'E' && ptr[1] == 'R' && ptr[2] == 'R' && ptr[3] == '_')
- RecvErr_Message(strip_info, NULL, strip_info->sx_buff);
+ RecvErr_Message(strip_info, NULL, &ptr[4]);
else RecvErr("No initial *", strip_info);
return;
}
- ptr++;
+ ptr++; /* Skip the initial '*' */
- /* Skip the return address */
- name = ptr;
- while (ptr < end && *ptr != '*') ptr++;
+ /* 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) {
+ if (ptr >= end || *ptr != '*')
+ {
RecvErr("No second *", strip_info);
return;
}
- name_end = ptr++;
+ ptr++; /* Skip the second '*' */
- /* Check for STRIP key, and skip over it */
- if (ptr[0] != ProtocolKey.c[0] ||
- ptr[1] != ProtocolKey.c[1] ||
- ptr[2] != ProtocolKey.c[2] ||
- ptr[3] != ProtocolKey.c[3]) {
- if (ptr[0] == 'E' && ptr[1] == 'R' && ptr[2] == 'R' && ptr[3] == '_') { *name_end = 0; RecvErr_Message(strip_info, name, ptr); }
- else RecvErr("Unrecognized protocol key", strip_info);
+ /* 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;
}
- ptr += 4;
- /* Decode start of the IP packet header */
- ptr = UnStuffData(ptr, end, strip_info->rx_buff, 4);
- if (!ptr) {
- RecvErr("Runt packet", strip_info);
+ if (ptr+4 >= end)
+ {
+ RecvErr("No proto key", strip_info);
return;
}
- packetlen = ((__u16)strip_info->rx_buff[2] << 8) | strip_info->rx_buff[3];
-/* printk("Packet %02X.%02X.%02X.%02X\n",
- strip_info->rx_buff[0], strip_info->rx_buff[1],
- strip_info->rx_buff[2], strip_info->rx_buff[3]);
- printk("Got %d byte packet\n", packetlen);*/
-
- /* Decode remainder of the IP packer */
- ptr = UnStuffData(ptr, end, strip_info->rx_buff+4, packetlen-4);
- if (!ptr) {
- RecvErr("Runt packet", strip_info);
- return;
- }
- strip_bump(strip_info, packetlen);
+ /*printk(KERN_INFO "%s: Got packet from \"%s\".\n", strip_info->dev.name, sendername);*/
- /* This turns out to be a mistake. Taking receipt of a valid packet as
- * evidence that the radio is correctly in Starmode (and resetting the
- * watchdog_doreset timer) is wrong. It turns out that if the radio is
- * in command mode, with character echo on, then the echo of the packet
- * you sent coming back looks like a valid packet and fools this test.
- * We should only accept the "ERR_004 Name too small or missing" message
- * as evidence that the radio is correctly in Starmode.
- strip_info->watchdog_doprobe = jiffies + 10 * HZ;
- strip_info->watchdog_doreset = jiffies + LONG_TIME;
+ /*
+ * 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);
+ }
}
/*
@@ -917,10 +2220,10 @@
* 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 timeval tv;*/
struct strip *strip_info = (struct strip *) tty->disc_data;
const unsigned char *end = cp + count;
@@ -928,104 +2231,86 @@
return;
/* Argh! mtu change time! - costs us the packet part received at the change */
- if (strip_info->mtu != STRIP_ENCAP_SIZE(strip_info->dev.mtu))
+ if (strip_info->mtu != strip_info->dev.mtu)
strip_changedmtu(strip_info);
-/* do_gettimeofday(&tv);
- printk("**** strip_receive_buf: %3d bytes at %d.%06d\n",
- count, tv.tv_sec % 100, tv.tv_usec);*/
+#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++) {
- if (!set_bit(STR_ERROR, &strip_info->flags)) strip_info->rx_errors++;
- }
- else if (*cp == 0x0D) {
- /*printk("Cut a %d byte packet (%d bytes remaining)\n",
- strip_info->sx_count, end-cp-1);*/
- if (!clear_bit(STR_ERROR, &strip_info->flags))
- process_packet(strip_info);
- strip_info->sx_count = 0;
+ 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++;
}
- else if (!test_bit(STR_ERROR, &strip_info->flags) &&
- (strip_info->sx_count > 0 || *cp != 0x0A))
+
+ /* Leading control characters (CR, NL, Tab, etc.) are ignored */
+ if (strip_info->sx_count > 0 || *cp >= ' ')
{
- /* (leading newline characters are ignored) */
- if (strip_info->sx_count < strip_info->buffsize)
- strip_info->sx_buff[strip_info->sx_count++] = *cp;
- else
+ 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 */
{
- set_bit(STR_ERROR, &strip_info->flags);
- strip_info->rx_over_errors++;
+ /* 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 */
-/*
- * Create the Ethernet MAC header for an arbitrary protocol layer
- *
- * saddr=NULL means use device source address
- * daddr=NULL means leave destination address (eg unresolved arp)
- */
-
-static int strip_header(struct sk_buff *skb, struct device *dev,
- unsigned short type, void *daddr, void *saddr, unsigned len)
-{
- return(-dev->hard_header_len);
-}
-
-/*
- * Rebuild the Ethernet 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 *h = (STRIP_Header *)buff;*/
-
-#ifdef CONFIG_INET
- /* I'll use arp_find when I understand it */
- /* 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(eth->h_dest, dst, dev, dev->pa_addr, skb)? 1 : 0;*/
- return(0);
-#else
- return(0);
-#endif
-}
-
static int strip_set_dev_mac_address(struct device *dev, void *addr)
{
- memcpy(dev->dev_addr, addr, 7);
- return 0;
+ 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);
+ static struct enet_statistics stats;
+ struct strip *strip_info = (struct strip *)(dev->priv);
- memset(&stats, 0, sizeof(struct enet_statistics));
+ 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);
+ 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 */
@@ -1055,298 +2340,286 @@
static int strip_open_low(struct device *dev)
{
- struct strip *strip_info = (struct strip *)(dev->priv);
- unsigned long len;
-
- if (strip_info->tty == NULL)
- return(-ENODEV);
+ struct strip *strip_info = (struct strip *)(dev->priv);
- /*
- * Allocate the STRIP frame buffers:
- *
- * rbuff Receive buffer.
- * tbuff Transmit buffer.
- * cbuff Temporary compression buffer.
- */
+ if (strip_info->tty == NULL)
+ return(-ENODEV);
- len = STRIP_ENCAP_SIZE(dev->mtu);
- if (len < STRIP_ENCAP_SIZE(576))
- len = STRIP_ENCAP_SIZE(576);
- strip_info->rx_buff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
- if (strip_info->rx_buff == NULL)
- goto norbuff;
- strip_info->sx_buff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
- if (strip_info->sx_buff == NULL)
- goto nosbuff;
- strip_info->tx_buff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
- if (strip_info->tx_buff == NULL)
- goto notbuff;
-
- strip_info->flags &= (1 << STR_INUSE); /* Clear ESCAPE & ERROR flags */
- strip_info->mtu = STRIP_ENCAP_SIZE(dev->mtu);
- strip_info->buffsize = len;
- strip_info->sx_count = 0;
- strip_info->tx_left = 0;
+ if (!allocate_buffers(strip_info))
+ return(-ENOMEM);
- /*
- * Needed because address '0' is special
- */
-
- if (dev->pa_addr == 0)
- dev->pa_addr=ntohl(0xC0A80001);
- dev->tbusy = 0;
- dev->start = 1;
+ strip_info->discard = 0;
+ strip_info->working = FALSE;
+ strip_info->structured_messages = FALSE;
+ strip_info->sx_count = 0;
+ strip_info->tx_left = 0;
- printk("%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);
+ /*
+ * Needed because address '0' is special
+ */
-notbuff:
- kfree(strip_info->sx_buff);
-nosbuff:
- kfree(strip_info->rx_buff);
-norbuff:
- return(-ENOMEM);
+ 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!
+ * 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);
+ 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;
+ 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
+/*
+ * 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.
- */
+ int i;
- 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 = STRIP_MTU;
- dev->type = ARPHRD_METRICOM; /* dtang */
- dev->hard_header_len = 8; /*sizeof(STRIP_Header);*/
- /*
- * dev->priv Already holds a pointer to our struct strip
- */
+ /*
+ * Finish setting up the DEVICE info.
+ */
- dev->broadcast[0] = 0;
- 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);
+ 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
+ */
- /*
- * Pointer to the interface buffers.
- */
-
- for (i = 0; i < DEV_NUMBUFFS; i++)
- skb_queue_head_init(&dev->buffs[i]);
+ *(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);
- /*
- * Pointers to interface service routines.
- */
+ /*
+ * Pointer to the interface buffers.
+ */
- 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;
+ 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.
+ * Free a STRIP channel.
*/
-
+
static void strip_free(struct strip *strip_info)
{
- *(strip_info->referrer) = strip_info->next;
- if (strip_info->next)
- strip_info->next->referrer = strip_info->referrer;
- strip_info->magic = 0;
- kfree(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
+/*
+ * 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);
+ 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 */
+ if (!strip_info)
+ return(NULL); /* If no more memory, return */
- /*
- * Clear the allocated memory
- */
-
- memset(strip_info, 0, sizeof(struct strip));
+ /*
+ * Clear the allocated memory
+ */
- /*
- * 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;
- }
+ memset(strip_info, 0, sizeof(struct strip));
- /*
- * Fill in the link pointers
- */
-
- strip_info->next = *s;
- if (*s)
- (*s)->referrer = &strip_info->next;
- strip_info->referrer = s;
- *s = strip_info;
-
- set_bit(STR_INUSE, &strip_info->flags);
- strip_info->magic = STRIP_MAGIC;
- strip_info->tty = NULL;
-
- init_timer(&strip_info->idle_timer);
- strip_info->idle_timer.data = (long)&strip_info->dev;
- strip_info->idle_timer.function = strip_IdleTask;
-
- 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);
+ /*
+ * 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...
+ * 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;
+ 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;
+ /*
+ * First make sure we're not already connected.
+ */
- /*
- * OK. Find a free STRIP channel to use.
- */
-
- if ((strip_info = strip_alloc()) == NULL)
- return -ENFILE;
+ if (strip_info && strip_info->magic == STRIP_MAGIC)
+ return -EEXIST;
- /*
- * 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("strip: register_netdev() failed.\n");
- strip_free(strip_info);
- return -ENFILE;
- }
+ /*
+ * OK. Find a free STRIP channel to use.
+ */
+ if ((strip_info = strip_alloc()) == NULL)
+ 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);
+ /*
+ * Register our newly created device so it can be ifconfig'd
+ * strip_dev_init() will be called as a side-effect
+ */
- /*
- * Restore default settings
- */
-
- strip_info->dev.type = ARPHRD_METRICOM; /* dtang */
+ if (register_netdev(&strip_info->dev) != 0)
+ {
+ printk(KERN_ERR "strip: register_netdev() failed.\n");
+ strip_free(strip_info);
+ return -ENFILE;
+ }
- /*
- * Set tty options
- */
+ 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
+ */
- 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 */
+ 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;
+ MOD_INC_USE_COUNT;
#endif
- /*
- * Done. We have linked the TTY line to a channel.
- */
- return(strip_info->dev.base_addr);
+ /*
+ * Done. We have linked the TTY line to a channel.
+ */
+ return(strip_info->dev.base_addr);
}
/*
@@ -1355,80 +2628,108 @@
* 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;
+ struct strip *strip_info = (struct strip *) tty->disc_data;
- /*
- * First make sure we're connected.
- */
-
- if (!strip_info || strip_info->magic != STRIP_MAGIC)
- return;
+ /*
+ * First make sure we're connected.
+ */
- 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;
+ 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;
+ MOD_DEC_USE_COUNT;
#endif
}
/************************************************************************/
-/* Perform I/O control calls on an active STRIP channel. */
+/* 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)
+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;
+ 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;
- memcpy_tofs((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);
+ /*
+ * First make sure we're connected.
+ */
- default:
- return -ENOIOCTLCMD;
- }
+ 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;
+ memcpy_tofs((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 */
/*
- * Initialize the STRIP driver.
- * This routine is called at boot time, to bootstrap the multi-channel
- * STRIP driver
+ * 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
@@ -1436,44 +2737,67 @@
#endif
int strip_init_ctrl_dev(struct device *dummy)
{
- static struct tty_ldisc strip_ldisc;
- int status;
- printk("STRIP: version %s (unlimited channels)\n", STRIP_VERSION);
+ static struct tty_ldisc strip_ldisc;
+ int status;
- /*
- * 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("STRIP: can't register line discipline (err = %d)\n", 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;
+ return status;
#else
- /* Return "not found", so that dev_init() will unlink
- * the placeholder device entry for us.
- */
- return ENODEV;
+
+ /* 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 */
+/* From here down is only used when compiled as an external module */
#ifdef MODULE
@@ -1484,11 +2808,20 @@
void cleanup_module(void)
{
- int i;
- while (struct_strip_list)
- strip_free(struct_strip_list);
+ 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("STRIP: can't unregister line discipline (err = %d)\n", i);
+ if ((i = tty_register_ldisc(N_STRIP, NULL)))
+ printk(KERN_ERR "STRIP: can't unregister line discipline (err = %d)\n", i);
}
#endif /* MODULE */
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov