diff --git a/ngx_rtmp.h b/ngx_rtmp.h
index 7e47bf9..43ca233 100644
--- a/ngx_rtmp.h
+++ b/ngx_rtmp.h
@@ -17,6 +17,8 @@
 
 #define NGX_RTMP_DEFAULT_CHUNK_SIZE 128
 
+#define NGX_LOG_DEBUG_RTMP NGX_LOG_DEBUG_CORE
+
 
 typedef struct {
     void                  **main_conf;
@@ -119,7 +121,7 @@ typedef struct {
 #define NGX_RTMP_SUBSCRIBER  0x02
 
 
-typedef struct {
+struct ngx_rtmp_session_s {
     uint32_t                signature;         /* "RTMP" */
 
     ngx_connection_t       *connection;
@@ -128,6 +130,8 @@ typedef struct {
     void                  **main_conf;
     void                  **srv_conf;
 
+    ngx_str_t              *addr_text;
+
     ngx_uint_t              chunk_size;
     ngx_chain_t            *free;
 
@@ -148,10 +152,13 @@ typedef struct {
     ngx_rtmp_packet_hdr_t   out_hdr;
 
     /* broadcast */
-    ngx_str_t              *name;
-    ngx_rtmp_session_t     *next;
+    ngx_str_t               name;
+    struct ngx_rtmp_session_s
+                            *next;
     ngx_uint_t              flags;
-} ngx_rtmp_session_t;
+};
+
+typedef struct ngx_rtmp_session_s ngx_rtmp_session_t;
 
 
 #define NGX_RTMP_SESSION_HASH_SIZE 16384
@@ -235,13 +242,11 @@ typedef struct {
 void ngx_rtmp_init_connection(ngx_connection_t *c);    
 void ngx_rtmp_close_session(ngx_rtmp_session_t *s);
 u_char * ngx_rtmp_log_error(ngx_log_t *log, u_char *buf, size_t len);
-void ngx_rtmp_send(ngx_event_t *wev);
-void ngx_rtmp_recv(ngx_event_t *wev);
 
 void ngx_rtmp_set_chunk_size(ngx_rtmp_session_t *s, uint32_t chunk_size);
 void ngx_rtmp_set_bytes_read(ngx_rtmp_session_t *s, uint32_t bytes_read);
 void ngx_rtmp_set_client_buffer_time(ngx_rtmp_session_t *s, int16_t msec);
-void ngx_rtmp_clear_buffer(ngx_rtmp_sesion_t *s);
+void ngx_rtmp_clear_buffer(ngx_rtmp_session_t *s);
 void ngx_rtmp_set_ping_time(ngx_rtmp_session_t *s, int16_t msec);
 void ngx_rtmp_set_server_bw(ngx_rtmp_session_t *s, uint32_t bw, 
     uint8_t limit_type);
@@ -260,6 +265,7 @@ void ngx_rtmp_send_packet(ngx_rtmp_session_t *s,
 
 /* NetConnection methods */
 ngx_int_t ngx_rtmp_connect(ngx_rtmp_session_t *s, ngx_chain_t **l);
+ngx_int_t ngx_rtmp_call(ngx_rtmp_session_t *s, ngx_chain_t **l);
 ngx_int_t ngx_rtmp_close(ngx_rtmp_session_t *s, ngx_chain_t **l);
 ngx_int_t ngx_rtmp_createstream(ngx_rtmp_session_t *s, ngx_chain_t **l);
 
diff --git a/ngx_rtmp_amf0.c b/ngx_rtmp_amf0.c
index e38f1a9..fd52f51 100644
--- a/ngx_rtmp_amf0.c
+++ b/ngx_rtmp_amf0.c
@@ -8,12 +8,13 @@
 static ngx_int_t
 ngx_rtmp_amf0_get(ngx_chain_t **l, void *p, size_t n)
 {
-    ngx_buf_t              *b;
+    ngx_buf_t       *b;
+    size_t          size;
 
     if (!n)
-        return;
+        return NGX_OK;
 
-    for(; *l; l = &l->next) {
+    for(; *l; l = &(*l)->next) {
 
         b = (*l)->buf;
 
@@ -24,8 +25,10 @@ ngx_rtmp_amf0_get(ngx_chain_t **l, void *p, size_t n)
             return NGX_OK;
         }
 
+        size = b->last - b->pos;
+
         if (p)
-            p = ngx_cpymem(p, b->pos, b->last - b->pos);
+            p = ngx_cpymem(p, b->pos, size);
 
         n -= size;
     }
@@ -37,7 +40,8 @@ ngx_rtmp_amf0_get(ngx_chain_t **l, void *p, size_t n)
 static ngx_int_t
 ngx_rtmp_amf0_put(ngx_chain_t **l, ngx_chain_t **free, void *p, size_t n)
 {
-    ngx_buf_t              *b;
+    ngx_buf_t       *b;
+    size_t          size;
 
     while(n) {
         b = (*l) ? (*l)->buf : NULL;
@@ -59,20 +63,24 @@ ngx_rtmp_amf0_put(ngx_chain_t **l, ngx_chain_t **free, void *p, size_t n)
             b->pos = b->last = b->start;
         }
 
-        if (b->end - b->last <= n) {
+        size = b->end - b->last;
+
+        if (size <= n) {
             b->last = ngx_cpymem(b->last, p, n);
             return NGX_OK;
         }
 
-        b->last = ngx_cpymem(b->last, p, b->end - b->last);
-        p += (b->end - b->last);
-        n -= (b->end - b->last);
+        b->last = ngx_cpymem(b->last, p, size);
+        p = (u_char*)p + size;
+        n -= size;
     }
+
+    return NGX_OK;
 }
 
 
 static ngx_int_t 
-ngx_rtmp_amf0_read_object(ngx_chain_t **l, ngx_rtmp_amf0_objelt_t *elts, 
+ngx_rtmp_amf0_read_object(ngx_chain_t **l, ngx_rtmp_amf0_elt_t *elts, 
         size_t nelts)
 {
     uint8_t                 type;
@@ -81,8 +89,8 @@ ngx_rtmp_amf0_read_object(ngx_chain_t **l, ngx_rtmp_amf0_objelt_t *elts,
     ngx_int_t               rc;
 
     maxlen = 0;
-    for(i = 0; i < n; ++i) {
-        namelen = strlen(v[n].name);
+    for(n = 0; n < nelts; ++n) {
+        namelen = strlen(elts[n].name);
         if (namelen > maxlen)
             maxlen = namelen;
     }
@@ -117,11 +125,11 @@ ngx_rtmp_amf0_read_object(ngx_chain_t **l, ngx_rtmp_amf0_objelt_t *elts,
          * then we could be able to use binary search */
         for(n = 0; n < nelts && strcmp(name, elts[n].name); ++n);
 
-        if (ngx_rtmp_amf0_read(s, n < nelts ? &elts[n] : NULL, 1) != NGX_OK)
+        if (ngx_rtmp_amf0_read(l, n < nelts ? &elts[n] : NULL, 1) != NGX_OK)
             return NGX_ERROR;
     }
 
-    if (ngx_rtmp_amf0_get(l, type, 1) != NGX_OK
+    if (ngx_rtmp_amf0_get(l, &type, 1) != NGX_OK
         || type != NGX_RTMP_AMF0_END)
     {
         return NGX_ERROR;
@@ -130,14 +138,14 @@ ngx_rtmp_amf0_read_object(ngx_chain_t **l, ngx_rtmp_amf0_objelt_t *elts,
     return NGX_OK;
 }
 
-#define NGX_RTMP_AMF0_TILL_END_FLAG (size_t(1) << (sizeof(size_t) * 8 - 1))
+#define NGX_RTMP_AMF0_TILL_END_FLAG ((size_t)1 << (sizeof(size_t) * 8 - 1))
 
 ngx_int_t 
 ngx_rtmp_amf0_read(ngx_chain_t **l, ngx_rtmp_amf0_elt_t *elts, size_t nelts)
 {
     void                   *data;
     uint8_t                 type;
-    size_t                  n, clen;
+    size_t                  n;
     uint16_t                len;
     ngx_int_t               rc;
     int                     till_end;
@@ -176,16 +184,16 @@ ngx_rtmp_amf0_read(ngx_chain_t **l, ngx_rtmp_amf0_elt_t *elts, size_t nelts)
                 if (data == NULL) {
                     rc = ngx_rtmp_amf0_get(l, data, len);
 
-                } else if (elts->len <= len)
+                } else if (elts->len <= len) {
                     rc = ngx_rtmp_amf0_get(l, data, elts->len - 1);
                     if (rc != NGX_OK)
                         return NGX_ERROR;
-                    data[elts->len - 1] = 0;
+                    ((char*)data)[elts->len - 1] = 0;
                     rc = ngx_rtmp_amf0_get(l, NULL, len - elts->len + 1);
 
                 } else {
                     rc = ngx_rtmp_amf0_get(l, data, len);
-                    data[len] = 0;
+                    ((char*)data)[len] = 0;
                 }
 
                 if (rc != NGX_OK)
@@ -264,7 +272,6 @@ ngx_rtmp_amf0_write(ngx_chain_t **l, ngx_chain_t **free,
         ngx_rtmp_amf0_elt_t *elts, size_t nelts)
 {
     size_t                  n;
-    ngx_int_t               rc;
     uint8_t                 type;
     void                   *data;
     uint16_t                len;
diff --git a/ngx_rtmp_amf0.h b/ngx_rtmp_amf0.h
index 93b0336..fcc03a9 100644
--- a/ngx_rtmp_amf0.h
+++ b/ngx_rtmp_amf0.h
@@ -15,6 +15,9 @@
 #define NGX_RTMP_AMF0_ARRAY     0x08
 #define NGX_RTMP_AMF0_END       0x09
 
+#include <ngx_config.h>
+#include <ngx_core.h>
+
 typedef struct {
     ngx_int_t               type;
     char                   *name;
diff --git a/ngx_rtmp_core_module.c b/ngx_rtmp_core_module.c
index 5937bb2..7665847 100644
--- a/ngx_rtmp_core_module.c
+++ b/ngx_rtmp_core_module.c
@@ -18,8 +18,6 @@ static char *ngx_rtmp_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
     void *conf);
 static char *ngx_rtmp_core_listen(ngx_conf_t *cf, ngx_command_t *cmd,
     void *conf);
-static char *ngx_rtmp_core_protocol(ngx_conf_t *cf, ngx_command_t *cmd,
-    void *conf);
 static char *ngx_rtmp_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
     void *conf);
 
@@ -156,13 +154,10 @@ ngx_rtmp_core_create_srv_conf(ngx_conf_t *cf)
     cscf->timeout = NGX_CONF_UNSET_MSEC;
     cscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
     cscf->so_keepalive = NGX_CONF_UNSET;
-    cssf->buffers = NGX_CONF_UNSET;
+    cscf->buffers = NGX_CONF_UNSET;
 
     cscf->resolver = NGX_CONF_UNSET_PTR;
 
-    cscf->file_name = cf->conf_file->file.name.data;
-    cscf->line = cf->conf_file->line;
-
     return cscf;
 }
 
@@ -265,8 +260,6 @@ ngx_rtmp_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 static char *
 ngx_rtmp_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 {
-    ngx_rtmp_core_srv_conf_t  *cscf = conf;
-
     size_t                      len, off;
     in_port_t                   port;
     ngx_str_t                  *value;
@@ -361,17 +354,6 @@ ngx_rtmp_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
         }
 
         module = ngx_modules[m]->ctx;
-
-        if (module->protocol == NULL) {
-            continue;
-        }
-
-        for (i = 0; module->protocol->port[i]; i++) {
-            if (module->protocol->port[i] == u.port) {
-                cscf->protocol = module->protocol;
-                break;
-            }
-        }
     }
 
     for (i = 2; i < cf->args->nelts; i++) {
diff --git a/ngx_rtmp_handler.c b/ngx_rtmp_handler.c
index 76c2be6..cf7ba31 100644
--- a/ngx_rtmp_handler.c
+++ b/ngx_rtmp_handler.c
@@ -136,8 +136,8 @@ ngx_rtmp_init_connection(ngx_connection_t *c)
     c->data = s;
     s->connection = c;
 
-    ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%ui client %V connected to %V",
-                  c->number, &c->addr_text, s->addr_text);
+    ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%ui client connected",
+                  c->number, &c->addr_text);
 
     ctx = ngx_palloc(c->pool, sizeof(ngx_rtmp_log_ctx_t));
     if (ctx == NULL) {
@@ -174,7 +174,7 @@ ngx_rtmp_init_session(ngx_connection_t *c)
 
     s->ctx = ngx_pcalloc(c->pool, sizeof(void *) * ngx_rtmp_max_module);
     if (s->ctx == NULL) {
-        ngx_rtmp_session_internal_server_error(s);
+        ngx_rtmp_close_session(s);
         return;
     }
 
@@ -223,7 +223,7 @@ ngx_rtmp_handshake_recv(ngx_event_t *rev)
         ngx_del_timer(rev);
     }
 
-    b = s->buf;
+    b = &s->buf;
 
     while(b->last != b->end) {
 
@@ -231,7 +231,7 @@ ngx_rtmp_handshake_recv(ngx_event_t *rev)
 
         if (n == NGX_ERROR || n == 0) {
             ngx_rtmp_close_session(s);
-            return NGX_ERROR;
+            return;
         }
 
         ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
@@ -244,7 +244,7 @@ ngx_rtmp_handshake_recv(ngx_event_t *rev)
             {
                 ngx_log_error(NGX_LOG_INFO, c->log, NGX_ERROR, 
                         "invalid handshake signature");
-                ngx_rtmp_session_internal_server_error(s);
+                ngx_rtmp_close_session(s);
                 return;
             }
             b->last += n;
@@ -255,7 +255,7 @@ ngx_rtmp_handshake_recv(ngx_event_t *rev)
             ngx_add_timer(rev, cscf->timeout);
 
             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
-                ngx_rtmp_session_internal_server_error(s);
+                ngx_rtmp_close_session(s);
             }
 
             return;
@@ -265,14 +265,13 @@ ngx_rtmp_handshake_recv(ngx_event_t *rev)
     ngx_del_event(c->read, NGX_READ_EVENT, 0);
 
     if (s->hs_stage++ == 0) {
-        ngx_rtmp_handshake_send(c->wev);
+        ngx_rtmp_handshake_send(c->write);
         return;
     }
 
     /* handshake done */
 
-    ngx_pfree(c->pool, s->buf->start);
-    s->buf = NULL;
+    ngx_pfree(c->pool, s->buf.start);
 
     c->read->handler =  ngx_rtmp_recv;
     c->write->handler = ngx_rtmp_send;
@@ -305,7 +304,7 @@ ngx_rtmp_handshake_send(ngx_event_t *wev)
         ngx_del_timer(wev);
     }
 
-    b = s->buf;
+    b = &s->buf;
 
 restart:
     while(b->pos != b->last) {
@@ -359,6 +358,7 @@ ngx_rtmp_recv(ngx_event_t *rev)
     u_char                     h, *p;
     ngx_chain_t               *lin;
 
+
     c = rev->data;
     s = c->data;
     cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
@@ -373,24 +373,27 @@ ngx_rtmp_recv(ngx_event_t *rev)
         s->free = s->free->next;
         s->in->next = NULL;
         b = s->in->buf;
-        b->pos = b->last = b->begin;
+        b->pos = b->last = b->start;
     }
 
-
     for(;;) {
 
+        /* find the last buf buf */
         for(lin = s->in; lin->next; lin = lin->next);
 
         b = lin->buf;
 
-        if (b->last >= b->end)
-            break;
+        if (b->last == b->end) {
+            ngx_rtmp_close_session(s);
+            return;
+        }
 
+        /* receive data from client */
         n = c->recv(c, b->last, b->end - b->last);
 
         if (n == NGX_ERROR || n == 0) {
             ngx_rtmp_close_session(s);
-            return NGX_ERROR;
+            return;
         }
 
         ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
@@ -399,7 +402,7 @@ ngx_rtmp_recv(ngx_event_t *rev)
 
         if (n == NGX_AGAIN) {
             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
-                ngx_rtmp_session_internal_server_error(s);
+                ngx_rtmp_close_session(s);
             }
             return;
         }
@@ -418,17 +421,17 @@ ngx_rtmp_recv(ngx_event_t *rev)
 
         /* basic header */
         do {
+            p = b->start + 1;
+
             if (s->in_hdr.hsize < 4)
                 break;
 
             /* TODO: check endians here */
 
-            p = b->start + 1;
 /*
             if (s->in_hdr.channel == 1) {
                 p += 2;
-                */
-            }
+            }*/
 
             s->in_hdr.timer = 0;
             ngx_memcpy(&s->in_hdr.timer, p, 3);
@@ -453,10 +456,10 @@ ngx_rtmp_recv(ngx_event_t *rev)
         } while(0);
 
 
-        if (b->last - p < ngx_min(s->in_hdr.size, s->chunk_size)) 
+        if (b->last - p < (ngx_int_t)ngx_min(s->in_hdr.size, s->chunk_size)) 
             continue;
 
-        b->pos = b;
+        b->pos = p;
 
         if (s->in_hdr.size > s->chunk_size) {
 
@@ -473,6 +476,8 @@ ngx_rtmp_recv(ngx_event_t *rev)
             lin = lin->next;
             lin->next = NULL;
             s->in_hdr.size -= s->chunk_size;
+            bb = lin->buf;
+            bb->pos = bb->last = bb->start;
             continue;
 
         }
@@ -484,11 +489,11 @@ ngx_rtmp_recv(ngx_event_t *rev)
         }
 
         bb = s->in->buf;
-        bb->pos = bb->last = bb->begin;
+        bb->pos = bb->last = bb->start;
 
         /* copy remained data to first buffer */
         if (s->in_hdr.size < b->last - b->pos) {
-            bb->last = ngx_movemem(bb->begin, 
+            bb->last = ngx_movemem(bb->start, 
                     b->pos + s->in_hdr.size, 
                     b->last - b->pos - s->in_hdr.size);
         }
@@ -510,8 +515,7 @@ ngx_rtmp_send(ngx_event_t *wev)
     ngx_connection_t          *c;
     ngx_rtmp_session_t        *s;
     ngx_rtmp_core_srv_conf_t  *cscf;
-    ngx_buf_t                 *b;
-    ngc_chain_t               *l, *ll;
+    ngx_chain_t               *l, *ll;
 
     c = wev->data;
     s = c->data;
@@ -532,15 +536,15 @@ ngx_rtmp_send(ngx_event_t *wev)
 
         l = c->send_chain(c, s->out, 0);
 
-        if (n == NGX_CHAIN_ERROR) {
+        if (l == NGX_CHAIN_ERROR) {
             ngx_rtmp_close_session(s);
             return;
         }
 
         n = 0;
 
-        if (l != c->out) {
-            for(ll = c->out; ll->next && ll->next != l; ll = ll->next);
+        if (l != s->out) {
+            for(ll = s->out; ll->next && ll->next != l; ll = ll->next);
             ll->next = s->free;
             s->out = l;
         }
@@ -567,7 +571,7 @@ ngx_rtmp_send(ngx_event_t *wev)
 }
 
 
-void ngx_rtmp_session_t**
+ngx_rtmp_session_t**
 ngx_rtmp_get_session_head(ngx_rtmp_session_t *s)
 {
     ngx_rtmp_core_srv_conf_t  *cscf;
@@ -575,7 +579,7 @@ ngx_rtmp_get_session_head(ngx_rtmp_session_t *s)
     cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
 
     return &cscf->sessions[
-        ngx_hash_key(s->name->data, s->name->len) 
+        ngx_hash_key(s->name.data, s->name.len) 
         % NGX_RTMP_SESSION_HASH_SIZE];
 }
 
@@ -583,7 +587,10 @@ ngx_rtmp_get_session_head(ngx_rtmp_session_t *s)
 void
 ngx_rtmp_join(ngx_rtmp_session_t *s, ngx_str_t *name, ngx_uint_t flags)
 {
-    ngx_rtmp_session_t       **ps;
+    ngx_rtmp_session_t    **ps;
+    ngx_connection_t       *c;
+
+    c = s->connection;
 
     if (s->name.len) {
         ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0,
@@ -591,12 +598,12 @@ ngx_rtmp_join(ngx_rtmp_session_t *s, ngx_str_t *name, ngx_uint_t flags)
         return;
     }
 
-    ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
+    ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "join name='%V' fd=%d", 
                    &name, c->fd);
 
-    s->name = name;
-    ps = ngx_rtmp_get_session_head(s):
+    s->name = *name;
+    ps = ngx_rtmp_get_session_head(s);
     s->next = *ps;
     s->flags = flags;
     *ps = s;
@@ -606,18 +613,21 @@ ngx_rtmp_join(ngx_rtmp_session_t *s, ngx_str_t *name, ngx_uint_t flags)
 void
 ngx_rtmp_leave(ngx_rtmp_session_t *s)
 {
-    ngx_rtmp_session_t       **ps;
+    ngx_rtmp_session_t    **ps;
+    ngx_connection_t       *c;
+
+    c = s->connection;
 
     if (!s->name.len)
         return;
 
-    ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
+    ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "leave name='%V' fd=%d", 
                    &s->name, c->fd);
 
     ps = ngx_rtmp_get_session_head(s);
 
-    ngx_str_null(&s->name):
+    ngx_str_null(&s->name);
 
     for(; *ps; ps = &(*ps)->next) {
         if (*ps == s) {
@@ -632,11 +642,11 @@ void
 ngx_rtmp_send_packet(ngx_rtmp_session_t *s, ngx_rtmp_packet_hdr_t *h, 
         ngx_chain_t *l)
 {
-    ngx_rtmp_packet_hdr_t   *lh;
-    size_t                   hsel, size;
-    ngx_chain_t             *ll, **pl;
-    ngx_buf_t               *b, *bb;
-    u_char                  *p, *pp;
+    ngx_rtmp_packet_hdr_t  *lh;
+    size_t                  hsel, hsize, size;
+    ngx_chain_t            *ll, **pl;
+    ngx_buf_t              *b, *bb;
+    u_char                 *p, *pp;
 
     if (l == NULL)
         return;
@@ -704,7 +714,7 @@ ngx_rtmp_send_packet(ngx_rtmp_session_t *s, ngx_rtmp_packet_hdr_t *h,
         
         pp = bb->pos;
 
-        *pp++ = (((u8)hsel & 0x03) << 6) | (h->channel & 0x3f);
+        *pp++ = (((uint8_t)hsel & 0x03) << 6) | (h->channel & 0x3f);
 
         if (hsize == 1)
             continue;
@@ -727,7 +737,7 @@ ngx_rtmp_send_packet(ngx_rtmp_session_t *s, ngx_rtmp_packet_hdr_t *h,
 }
 
 
-ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
+ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session_t *s,
         ngx_rtmp_packet_hdr_t *h, ngx_chain_t *l)
 {
     ngx_rtmp_core_srv_conf_t   *cscf;
@@ -738,11 +748,11 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
         uint16_t               *v2;
         uint16_t               *v3;
     }                           ping;
-    ngx_session_t              *ss;
+    ngx_rtmp_session_t         *ss;
     static char                 invoke_name[64]; 
-    static ngx_rtmp_amf0_elt   *invoke_name_elt = { 
+    static ngx_rtmp_amf0_elt_t  invoke_name_elt = { 
         NGX_RTMP_AMF0_STRING,     
-        0,
+        NULL,
         invoke_name,       
         sizeof(invoke_name)        
     };
@@ -756,17 +766,17 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
 #ifdef NGX_DEBUG
     {
         int             nch;
-        ngx_chain_t     ch;
+        ngx_chain_t    *ch;
 
         for(nch = 1, ch = l; ch->next; ch = ch->next, ++nch);
 
-        ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
+        ngx_log_debug8(NGX_LOG_DEBUG_RTMP, c->log, 0,
                 "RTMP packet received type=%d channel=%d hsize=%d "
                 "size=%d timer=%D stream=%D nbufs=%d fd=%d", 
-                int(h->type), 
-                int(h->channel), 
-                int(h->hsize), 
-                int(h->size), 
+                (int)h->type, 
+                (int)h->channel, 
+                (int)h->hsize, 
+                (int)h->size, 
                 h->timer,
                 h->stream,
                 nch,
@@ -783,13 +793,13 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
         case NGX_RTMP_PACKET_CHUNK_SIZE:
             if (b->last - b->pos < 4)
                 return NGX_ERROR;
-            ngx_rtmp_set_chunk_size(s, *(uint32_t*)(b->pos));
+            /*ngx_rtmp_set_chunk_size(s, *(uint32_t*)(b->pos));*/
             break;
 
         case NGX_RTMP_PACKET_BYTES_READ:
             if (b->last - b->pos < 4)
                 return NGX_ERROR;
-            ngx_rtmp_set_bytes_read(s, *(uint32_t*)(b->pos));
+            /*ngx_rtmp_set_bytes_read(s, *(uint32_t*)(b->pos));*/
             break;
 
         case NGX_RTMP_PACKET_PING:
@@ -834,20 +844,20 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
             if (b->last - b->pos < 4)
                 return NGX_ERROR;
 
-            ngx_rtmp_set_server_bw(s, *(uint32_t*)b->pos,
+            /*ngx_rtmp_set_server_bw(s, *(uint32_t*)b->pos,
                     b->last - b->pos >= 5
                     ? *(uint8_t*)(b->pos + 4)
-                    : 0);
+                    : 0);*/
             break;
 
         case NGX_RTMP_PACKET_CLIENT_BW:
             if (b->last - b->pos < 4)
                 return NGX_ERROR;
 
-            ngx_rtmp_set_client_bw(s, *(uint32_t*)b->pos,
+            /*ngx_rtmp_set_client_bw(s, *(uint32_t*)b->pos,
                     b->last - b->pos >= 5
                     ? *(uint8_t*)(b->pos + 4)
-                    : 0);
+                    : 0);*/
             break;
 
         case NGX_RTMP_PACKET_AUDIO:
@@ -896,7 +906,6 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
 
             memset(invoke_name, 0, sizeof(invoke_name));
             if (ngx_rtmp_amf0_read(&l, &invoke_name_elt, 1) != NGX_OK) {
-            {
                 return NGX_ERROR;
             }
 
@@ -906,7 +915,7 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
 
 
 #define INVOKE_CALL(name) \
-            if (!strncasecmp(invoke_name, #name)) { \
+            if (!strcasecmp(invoke_name, #name)) { \
                 return ngx_rtmp_##name(s, &l); \
             }
 
@@ -937,13 +946,13 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
             /* no support for flex */
             ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "flex packets are not supported type=%d fd=%d", 
-                   int(h->type), c->fd);
+                   (int)h->type, c->fd);
             break;
 
         default:
             ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "unsupported packet type type=%d fd=%d", 
-                   int(h->type), c->fd);
+                   (int)h->type, c->fd);
     }
 
     return NGX_OK;
@@ -953,11 +962,6 @@ ngx_int_t ngx_rtmp_receive_packet(ngx_rtmp_session *s,
 void
 ngx_rtmp_close_session(ngx_rtmp_session_t *s)
 {
-    ngx_pool_t              *pool;
-    ngx_connection_t        *c;
-    ngx_rtmp_session_t      *ps;
-    ngx_rtmp_broadcast_t    *bc;
-
     ngx_rtmp_leave(s);
 
     ngx_rtmp_close_connection(s->connection);
@@ -967,6 +971,7 @@ ngx_rtmp_close_session(ngx_rtmp_session_t *s)
 void
 ngx_rtmp_close_connection(ngx_connection_t *c)
 {
+    ngx_pool_t  *pool;
 
     ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "close connection: %d", c->fd);
diff --git a/ngx_rtmp_netconn.c b/ngx_rtmp_netconn.c
index 31ce876..5a8f53b 100644
--- a/ngx_rtmp_netconn.c
+++ b/ngx_rtmp_netconn.c
@@ -10,6 +10,12 @@ ngx_rtmp_connect(ngx_rtmp_session_t *s, ngx_chain_t **l)
     return NGX_OK;
 }
 
+ngx_int_t 
+ngx_rtmp_call(ngx_rtmp_session_t *s, ngx_chain_t **l)
+{
+    return NGX_OK;
+}
+
 ngx_int_t 
 ngx_rtmp_close(ngx_rtmp_session_t *s, ngx_chain_t **l)
 {