Two externals to process HTTP/1.1 requests and responses in conjunction with net exernals like [tcpclient] or

[slipenc]/[slipdec]. So far only GET requests work.

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

1 files changed, 214 insertions, 0 deletions

diff --git a/net/httpreceive.c b/net/httpreceive.c
new file mode 100644
index 0000000..6c9e5a2
--- /dev/null
+++ b/net/httpreceive.c
@@ -0,0 +1,214 @@
+/* httpreceive.c Started by Martin Peach 20110111 */
+/* httpreceive will process http 1.1 responses received as lists of bytes from something like [tcpclient] */
+/* See http://www.w3.org/Protocols/rfc2616/rfc2616.html */
+
+#include "m_pd.h"
+#include <stdio.h>
+#include <string.h>
+
+static t_class *httpreceive_class;
+
+#define STATUS_BUF_LEN 1024
+
+typedef struct _httpreceive
+{
+    t_object    x_obj;
+    t_outlet    *x_status_out;
+    t_outlet    *x_message_out;
+    t_outlet    *x_statuscode_out;
+    int         x_state;
+    int         x_remaining;
+    int         x_verbosity;
+    char        *x_status_buf;
+    size_t      x_status_buf_len;
+    int         x_status_buf_write_index;
+} t_httpreceive;
+
+#define MAX_GETSTRING 256
+
+static void httpreceive_bang(t_httpreceive *x);
+static void httpreceive_list(t_httpreceive *x, t_symbol *s, int argc, t_atom *argv);
+static void httpreceive_verbosity(t_httpreceive *x, t_floatarg verbosity);
+static void httpreceive_free (t_httpreceive *x);
+static void *httpreceive_new (void);
+void httpreceive_setup(void);
+
+static void httpreceive_bang(t_httpreceive *x)
+{
+  post("httpreceive_bang %p", x);
+}
+
+static void httpreceive_list(t_httpreceive *x, t_symbol *s, int argc, t_atom *argv)
+{
+    int     i, j, k, m, n, message_len = 0;
+    char    buf[256];
+    t_atom  status_list[2];
+
+    /* first check that all the atoms are integer floats on 0-255 */
+    for (i = 0; i < argc; ++i)
+    {
+        if (argv[i].a_type != A_FLOAT)
+        {
+            pd_error(x, "list element %d is not a float", i);
+            return;
+        }
+        j = argv[i].a_w.w_float;
+        if (j != argv[i].a_w.w_float)
+        {
+            pd_error(x, "list element %d is not an integer", i);
+            return;
+        }
+        if ((j < -128) || (j > 255))
+        {
+            pd_error(x, "list element %d is not on [0...255]", i);
+            return;
+        }
+    }
+    if (x->x_verbosity) post ("httpreceive_list %d elements, x_state %d x_remaining %d", i, x->x_state, x->x_remaining);
+
+ 
+    for (i = 0; ((i < argc) && (x->x_state == 0)); ++i)
+    {
+        j = argv[i].a_w.w_float;
+        x->x_status_buf[x->x_status_buf_write_index] = j;
+        /* status ends with CRLFCRLF */
+        if
+        (
+            (x->x_status_buf_write_index > 3)
+            && (j == 10) && (x->x_status_buf[x->x_status_buf_write_index-1] == 13)
+            && (x->x_status_buf[x->x_status_buf_write_index-2] == 10)
+            && (x->x_status_buf[x->x_status_buf_write_index-3] == 13)
+        )
+        {
+            x->x_state = 1;/* complete status header is in x->x_status_buf */
+            x->x_status_buf[x->x_status_buf_write_index+1] = 0;
+            if (x->x_verbosity) post("httpreceive_list: status: %s", x->x_status_buf);
+            /* get status code from first line */
+            if (1 != sscanf(x->x_status_buf, "HTTP/1.1 %d", &j))
+            {
+                pd_error(x, "httpreceive_list: malformed status line");
+                post("httpreceive_list: status: %s", x->x_status_buf);
+            }
+            else
+            {
+                outlet_float(x->x_statuscode_out, j);
+                if (x->x_verbosity) post("httpreceive_list: status code: %d", j);
+                for (j = 8; j < x->x_status_buf_write_index; ++j)
+                if (x->x_status_buf[j] >= 'A') break; /* skip to start of reason phrase */
+                for (k = 0; j < x->x_status_buf_write_index; ++j, ++k)
+                {
+                    if  (13 == x->x_status_buf[j]) break;
+                    buf[k] = x->x_status_buf[j];/* copy reason phrase to buf */
+                }
+                buf[k] = 0;
+                /* make buf into a symbol */
+                SETSYMBOL(&status_list[0], gensym(buf));
+                /* output it through status outlet */ 
+                outlet_anything(x->x_status_out, gensym("reason"), 1, &status_list[0]);
+                /* loop through all the response header fields */                        
+
+                do
+                {
+                    /* skip to first non-whitespace on next line: */
+                    for (; j < x->x_status_buf_write_index; ++j)
+                    if (x->x_status_buf[j] > 32) break;
+                    /* copy the field name to buf */
+                    for (k = 0; j < x->x_status_buf_write_index; ++j, ++k)
+                    {
+                        if (':' == x->x_status_buf[j]) break;
+                        buf[k] = x->x_status_buf[j];
+                    }
+                    j++; /* skip the colon */
+                    buf[k] = 0;
+                    SETSYMBOL(&status_list[0], gensym(buf)); /* field name */
+                    /* skip whitespace: */
+                    for (; j < x->x_status_buf_write_index; ++j)
+                    if (x->x_status_buf[j] != 32) break;
+                    /* copy the token to buf */
+                    for (k = 0; j < x->x_status_buf_write_index; ++j, ++k)
+                    {
+                        if (13 == x->x_status_buf[j]) break;
+                        buf[k] = x->x_status_buf[j];
+                    }
+                    buf[k] = 0;
+                    /* if the value is a number, set it to a float, else it's a symbol */
+                    for (m = 0; m < k; ++m) if ((buf[m] < '0' || buf[m] > '9')) break;
+                    if (m == k)
+                    {                            
+                        sscanf(buf, "%d", &n);
+                        SETFLOAT(&status_list[1], n);
+                        /* if this is Content-Length, we know the message_length */
+                        if (atom_getsymbol(&status_list[0]) == gensym("Content-Length")) x->x_remaining = n;
+                    }
+                    else SETSYMBOL(&status_list[1], gensym(buf));
+                    outlet_anything(x->x_status_out, status_list[0].a_w.w_symbol, 1, &status_list[1]);
+                } while (j < x->x_status_buf_write_index-3);
+
+            }
+        } // if end of status response
+        else x->x_status_buf_write_index++;
+        if (x->x_status_buf_write_index >= STATUS_BUF_LEN)
+        {
+            pd_error(x, "httpreceive_list: status buffer full");
+            x->x_status_buf_write_index = 0;
+            x->x_state = 0;
+            x->x_remaining = 0;
+        }
+    } // for each byte
+    if (1 == x->x_state)
+    {
+        /* any remaining atoms are the message body. For now just output them */
+        /* but if the incoming bytes are in more than one list this won't work, */
+        /*we'll need to cache them until we have Content-Length */
+        if (x->x_verbosity) post ("httpreceive_list: x->x_remaining is %d", x->x_remaining);
+        message_len = argc - i;
+        if (x->x_verbosity) post ("httpreceive_list: message_len is %d", message_len);
+        if (message_len <= x->x_remaining) x->x_remaining -= message_len;
+        outlet_list(x->x_message_out, &s_list, message_len, &argv[i]);
+        x->x_status_buf_write_index = 0;
+        if (0 == x->x_remaining) x->x_state = 0;
+    }
+}
+
+static void httpreceive_verbosity(t_httpreceive *x, t_float verbosity)
+{
+    x->x_verbosity = verbosity;
+    if (x->x_verbosity != 0) post ("httpreceive_verbosity %d", x->x_verbosity);
+}
+
+static void httpreceive_free (t_httpreceive *x)
+{
+    if ((NULL != x->x_status_buf)&&(0 != x->x_status_buf_len)) freebytes(x->x_status_buf, x->x_status_buf_len);
+}
+
+static void *httpreceive_new (void)
+{
+    t_httpreceive *x = (t_httpreceive *)pd_new(httpreceive_class);
+    if (NULL != x)
+    {
+        x->x_message_out = outlet_new(&x->x_obj, &s_anything);
+        x->x_status_out = outlet_new(&x->x_obj, &s_anything);
+        x->x_statuscode_out = outlet_new(&x->x_obj, &s_float);  /* rightmost outlet */
+        x->x_state = 0; /* waiting for a list of bytes */
+        x->x_status_buf_len = STATUS_BUF_LEN;
+        if (NULL == (x->x_status_buf = getbytes(STATUS_BUF_LEN)))
+        {
+            pd_error(x, "httpreceive_new: no memory available for x_status_buf");
+            x->x_status_buf_len = 0;
+        }
+        x->x_status_buf_write_index = 0;
+        x->x_remaining = 0;
+        x->x_verbosity = 0;
+    }
+    
+    return (void *)x;
+}
+
+void httpreceive_setup(void)
+{
+    httpreceive_class = class_new(gensym("httpreceive"), (t_newmethod)httpreceive_new, (t_method)httpreceive_free, sizeof(t_httpreceive), CLASS_DEFAULT, 0);
+    class_addbang(httpreceive_class, httpreceive_bang);
+    class_addlist (httpreceive_class, (t_method)httpreceive_list);
+    class_addmethod(httpreceive_class, (t_method)httpreceive_verbosity, gensym("verbosity"), A_FLOAT, 0);
+}
+/* fin httpreceive.c */