Can set maximum packet length. Updated help patch.

svn path=/trunk/externals/mrpeach/; revision=14147

1 files changed, 101 insertions, 79 deletions

diff --git a/slipenc/slipenc.c b/slipenc/slipenc.c
index 814b5cd..74b1b29 100644
--- a/slipenc/slipenc.c
+++ b/slipenc/slipenc.c
@@ -1,38 +1,37 @@
-/* slipenc.c 20070711 Martin Peach */
-/**encode a list of bytes as SLIP /
+/* slipenc.c 20100513 Martin Peach */
+/* encode a list of bytes as SLIP */
 /*
-/*
-From RFC 1055:
-PROTOCOL
-
-   The SLIP protocol defines two special characters: SLIP_END and SLIP_ESC. SLIP_END is
-   octal 300 (decimal 192) and SLIP_ESC is octal 333 (decimal 219) not to be
-   confused with the ASCII ESCape character; for the purposes of this
-   discussion, SLIP_ESC will indicate the SLIP SLIP_ESC character.  To send a
-   packet, a SLIP host simply starts sending the data in the packet.  If
-   a data byte is the same code as SLIP_END character, a two byte sequence of
-   SLIP_ESC and octal 334 (decimal 220) is sent instead.  If it the same as
-   an SLIP_ESC character, an two byte sequence of SLIP_ESC and octal 335 (decimal
-   221) is sent instead.  When the last byte in the packet has been
-   sent, an SLIP_END character is then transmitted.
-
-   Phil Karn suggests a simple change to the algorithm, which is to
-   begin as well as end packets with an SLIP_END character.  This will flush
-   any erroneous bytes which have been caused by line noise.  In the
-   normal case, the receiver will simply see two back-to-back SLIP_END
-   characters, which will generate a bad IP packet.  If the SLIP
-   implementation does not throw away the zero-length IP packet, the IP
-   implementation certainly will.  If there was line noise, the data
-   received due to it will be discarded without affecting the following
-   packet.
-
-   Because there is no 'standard' SLIP specification, there is no real
-   defined maximum packet size for SLIP.  It is probably best to accept
-   the maximum packet size used by the Berkeley UNIX SLIP drivers: 1006
-   bytes including the IP and transport protocol headers (not including
-   the framing characters).  Therefore any new SLIP implementations
-   should be prepared to accept 1006 byte datagrams and should not send
-   more than 1006 bytes in a datagram.
+*   From RFC 1055:
+*   PROTOCOL
+*
+*   The SLIP protocol defines two special characters: SLIP_END and SLIP_ESC. SLIP_END is
+*   octal 300 (decimal 192) and SLIP_ESC is octal 333 (decimal 219) not to be
+*   confused with the ASCII ESCape character; for the purposes of this
+*   discussion, SLIP_ESC will indicate the SLIP SLIP_ESC character.  To send a
+*   packet, a SLIP host simply starts sending the data in the packet.  If
+*   a data byte is the same code as SLIP_END character, a two byte sequence of
+*   SLIP_ESC and octal 334 (decimal 220) is sent instead.  If it the same as
+*   an SLIP_ESC character, an two byte sequence of SLIP_ESC and octal 335 (decimal
+*   221) is sent instead.  When the last byte in the packet has been
+*   sent, an SLIP_END character is then transmitted.
+*
+*   Phil Karn suggests a simple change to the algorithm, which is to
+*   begin as well as end packets with an SLIP_END character.  This will flush
+*   any erroneous bytes which have been caused by line noise.  In the
+*   normal case, the receiver will simply see two back-to-back SLIP_END
+*   characters, which will generate a bad IP packet.  If the SLIP
+*   implementation does not throw away the zero-length IP packet, the IP
+*   implementation certainly will.  If there was line noise, the data
+*   received due to it will be discarded without affecting the following
+*   packet.
+*
+*   Because there is no 'standard' SLIP specification, there is no real
+*   defined maximum packet size for SLIP.  It is probably best to accept
+*   the maximum packet size used by the Berkeley UNIX SLIP drivers: 1006
+*   bytes including the IP and transport protocol headers (not including
+*   the framing characters).  Therefore any new SLIP implementations
+*   should be prepared to accept 1006 byte datagrams and should not send
+*   more than 1006 bytes in a datagram.
 */
 
 #include "m_pd.h" 
@@ -40,11 +39,11 @@ PROTOCOL
 /* -------------------------- slipenc -------------------------- */
 #ifndef _SLIPCODES
 /* SLIP special character codes */
-#define SLIP_END     0300 /* indicates end of packet */
-#define SLIP_ESC     0333 /* indicates byte stuffing */
-#define SLIP_ESC_END 0334 /* SLIP_ESC SLIP_ESC_END means SLIP_END data byte */
-#define SLIP_ESC_ESC 0335 /* SLIP_ESC SLIP_ESC_ESC means SLIP_ESC data byte */
-#define MAX_SLIP 1006 /* maximum SLIP packet size */
+#define SLIP_END        0300 /* indicates end of packet */
+#define SLIP_ESC        0333 /* indicates byte stuffing */
+#define SLIP_ESC_END    0334 /* SLIP_ESC SLIP_ESC_END means SLIP_END data byte */
+#define SLIP_ESC_ESC    0335 /* SLIP_ESC SLIP_ESC_ESC means SLIP_ESC data byte */
+#define MAX_SLIP        1006 /* maximum SLIP packet size */
 #define _SLIPCODES
 #endif // _SLIPCODES
 
@@ -56,6 +55,7 @@ typedef struct _slipenc
     t_outlet    *x_slipenc_out;
     t_atom      *x_slip_buf;
     t_int       x_slip_length;
+    t_int       x_slip_max_length;
 } t_slipenc;
 
 static void *slipenc_new(t_symbol *s, int argc, t_atom *argv);
@@ -65,17 +65,35 @@ void slipenc_setup(void);
 
 static void *slipenc_new(t_symbol *s, int argc, t_atom *argv)
 {
-    int i;
+    int i, max_len;
     t_slipenc  *x = (t_slipenc *)pd_new(slipenc_class);
 
-    x->x_slip_buf = (t_atom *)getbytes(sizeof(t_atom)*MAX_SLIP);
+    if (x == NULL) return x;
+    
+    x->x_slip_max_length = MAX_SLIP; // default unless float argument given
+    for (i = 0; i < argc; ++i)
+    {
+        if (argv[i].a_type == A_FLOAT)
+        {
+            max_len = atom_getfloat(&argv[i]);
+            if (max_len > 3)
+            {
+                x->x_slip_max_length = max_len;
+                post("slipenc: maximum packet length is %d", x->x_slip_max_length);
+            }
+            else
+                post("slipenc: maximum packet length must be greater than 3, using %d", x->x_slip_max_length);
+            break;
+        }
+    }
+    x->x_slip_buf = (t_atom *)getbytes(sizeof(t_atom)*x->x_slip_max_length);
     if(x->x_slip_buf == NULL)
     {
-        error("slipenc: unable to allocate %lu bytes for x_slip_buf", (long)sizeof(t_atom)*MAX_SLIP);
+        error("slipenc: unable to allocate %lu bytes for x_slip_buf", (long)sizeof(t_atom)*x->x_slip_max_length);
         return NULL;
     }
     /* Initialize all the slip buf atoms to float type */
-    for (i = 0; i < MAX_SLIP; ++i) x->x_slip_buf[i].a_type = A_FLOAT;
+    for (i = 0; i < x->x_slip_max_length; ++i) x->x_slip_buf[i].a_type = A_FLOAT;
     x->x_slipenc_out = outlet_new(&x->x_obj, &s_list);
     return (x);
 }
@@ -86,51 +104,55 @@ static void slipenc_list(t_slipenc *x, t_symbol *s, int ac, t_atom *av)
     float   f;
     int     i, c;
 
-    i = x->x_slip_length = 0;
-    /* send an initial SLIP_END character to flush out any data that may */
-    /* have accumulated in the receiver due to line noise */
-    x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_END;
-
+    i = 0;    
     /* for each byte in the packet, send the appropriate character sequence */
-    while((i < ac) && (x->x_slip_length < (MAX_SLIP-1)))
+    while (i < ac)
     {
-        /* check each atom for byteness */
-        f = atom_getfloat(&av[i++]);
-        c = (((int)f) & 0x0FF);
-        if (c != f)
-        {
-            /* abort, bad input character */
-            pd_error (x, "slipenc: input %f out of range [0..255]", f);
-            return;
-        }
-        if(SLIP_END == c)
-        {
-            /* If it's the same code as a SLIP_END character, replace it with a */
-            /* special two-character code so as not to make the receiver think we sent SLIP_END */
-            x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC;
-            x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC_END;
-        }
-        else if (SLIP_ESC == c)
-        {
-            /* If it's the same code as a SLIP_ESC character, replace it with a special two-character code */
-            /* so as not to make the receiver think we sent SLIP_ESC */
-            x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC;
-            x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC_ESC;
-        }
-        else
+        x->x_slip_length = 0;
+        /* send an initial SLIP_END character to flush out any data that may */
+        /* have accumulated in the receiver due to line noise */
+        x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_END;
+
+        while((i < ac)&&(x->x_slip_length < (x->x_slip_max_length-2)))
         {
-            /* Otherwise, pass the character */
-            x->x_slip_buf[x->x_slip_length++].a_w.w_float = c;
+            /* check each atom for byteness */
+            f = atom_getfloat(&av[i++]);
+            c = (((int)f) & 0x0FF);
+            if (c != f)
+            {
+                /* abort, bad input character */
+                pd_error (x, "slipenc: input %f out of range [0..255]", f);
+                return;
+            }
+            if(SLIP_END == c)
+            {
+                /* If it's the same code as a SLIP_END character, replace it with a */
+                /* special two-character code so as not to make the receiver think we sent SLIP_END */
+                x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC;
+                x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC_END;
+            }
+            else if (SLIP_ESC == c)
+            {
+                /* If it's the same code as a SLIP_ESC character, replace it with a special two-character code */
+                /* so as not to make the receiver think we sent SLIP_ESC */
+                x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC;
+                x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_ESC_ESC;
+            }
+            else
+            {
+                /* Otherwise, pass the character */
+                x->x_slip_buf[x->x_slip_length++].a_w.w_float = c;
+            }
         }
+        /* Add the SLIP_END code to tell the receiver that the packet is complete */
+        x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_END;
+        outlet_list(x->x_slipenc_out, &s_list, x->x_slip_length, x->x_slip_buf);
     }
-    /* Add the SLIP_END code to tell the receiver that the packet is complete */
-    x->x_slip_buf[x->x_slip_length++].a_w.w_float = SLIP_END;
-    outlet_list(x->x_slipenc_out, &s_list, x->x_slip_length, x->x_slip_buf);
 }
 
 static void slipenc_free(t_slipenc *x)
 {
-    if (x->x_slip_buf != NULL) freebytes((void *)x->x_slip_buf, sizeof(t_atom)*MAX_SLIP);
+    if (x->x_slip_buf != NULL) freebytes((void *)x->x_slip_buf, sizeof(t_atom)*x->x_slip_max_length);
 }
 
 void slipenc_setup(void)