--- a/render_remote.c	Fri Jun 06 16:05:26 2008 +0300
+++ b/render_remote.c	Fri Jun 06 18:35:46 2008 +0300
@@ -7,6 +7,7 @@
 #include <event2/event.h>
 #include <event2/bufferevent.h>
 
+#include "render_internal.h"    // for render_cmd_build
 #include "render_remote.h"
 #include "common.h"
 
@@ -14,8 +15,6 @@
     struct event *ev_conn;
     struct bufferevent *data_bev;
 
-    struct remote_node *remote_node;
-
     #pragma pack(push)
     #pragma pack(1)
 
@@ -41,33 +40,27 @@
     void *cb_arg;
 };
 
-void _remote_render_ctx_free (struct remote_render_ctx *ctx) {
-    // close the socket (ctx->ev_conn remains valid even after we're done with it...)
-    close(event_get_fd(ctx->ev_conn));
-    
-    // free the connect event
-    event_free(ctx->ev_conn);
-
+void _remote_render_ctx_free (struct remote_render_ctx **ctx) {
     // free the data_bev
-    if (ctx->data_bev) {
-        bufferevent_free(ctx->data_bev);
-        ctx->data_bev = NULL;
+    if ((*ctx)->data_bev) {
+        bufferevent_free((*ctx)->data_bev);
+        (*ctx)->data_bev = NULL;
     }
 
-    // update remote_node load
-    ctx->remote_node->current_load--;
+    // and the event
+    event_free((*ctx)->ev_conn);
     
     // free the context structure
-    free(ctx);
+    free(*ctx);
     
-    ctx = NULL;
+    *ctx = NULL;
 }
 
 #define RENDER_FAILED(ctx, desc) \
     do {                                        \
         perror(desc);                           \
         ctx->cb_fail(ctx->cb_arg);              \
-        _remote_render_ctx_free(ctx);          \
+        _remote_render_ctx_free(&ctx);          \
         return;                                 \
     } while (0)
 
@@ -125,7 +118,7 @@
     }
 
     // free resources
-    _remote_render_ctx_free(ctx);
+    _remote_render_ctx_free(&ctx);
 }
 
 void _remote_connected (int fd, short event, void *arg) {
@@ -144,19 +137,19 @@
         RENDER_FAILED(ctx, "render_remote: bufferevent_enable");
 }
 
-void render_cmd_build (render_t *rctx, struct remote_render_ctx *rrctx) {
+void render_cmd_build (struct render *render, struct remote_render_ctx *ctx) {
     // just copy over the render params to the render_cmd
-    rrctx->render_cmd.mode = rctx->mode;
-    rrctx->render_cmd.img_w = htonl(rctx->img_w);
-    rrctx->render_cmd.img_h = htonl(rctx->img_h);
-    rrctx->render_cmd.x1 = rctx->x1;
-    rrctx->render_cmd.y1 = rctx->y1;
-    rrctx->render_cmd.x2 = rctx->x2;
-    rrctx->render_cmd.y2 = rctx->y2;
+    ctx->render_cmd.mode = render->mode;
+    ctx->render_cmd.img_w = htonl(render->img_w);
+    ctx->render_cmd.img_h = htonl(render->img_h);
+    ctx->render_cmd.x1 = render->x1;
+    ctx->render_cmd.y1 = render->y1;
+    ctx->render_cmd.x2 = render->x2;
+    ctx->render_cmd.y2 = render->y2;
 }
 
 struct remote_render_ctx *render_remote (
-        render_t *render_ctx,
+        struct render *render,
         struct remote_node *remote_node,
         void (*cb_sent)(void *arg),
         void (*cb_data)(struct evbuffer *buf, void *arg),
@@ -164,15 +157,14 @@
         void (*cb_fail)(void *arg),
         void *cb_arg
 ) {    
-    printf("render_remote: remote render load: %d/%d\n", remote_node->current_load, remote_node->parallel_renders);
+    struct remote_render_ctx *ctx;
+    int sock;
+
+    printf("remote_node render load: %d/%d\n", remote_node->current_load, remote_node->parallel_renders);
 
     // alloc the remote render ctx
-    struct remote_render_ctx *ctx = malloc(sizeof(struct remote_render_ctx));
-
-    if (!ctx) {
-        error("render_remote: malloc");
-        return NULL;
-    }
+    if (!(ctx = calloc(1, sizeof(struct remote_render_ctx))))
+        ERROR("calloc");
     
     // store the provided callback functions
     ctx->cb_sent = cb_sent;
@@ -180,50 +172,30 @@
     ctx->cb_done = cb_done;
     ctx->cb_fail = cb_fail;
     ctx->cb_arg = cb_arg;
-
-    // keep a reference to remote_node so we can decr it's load
-    ctx->remote_node = remote_node;
     
     // copy the relevant stuff from the render_ctx
-    render_cmd_build(render_ctx, ctx);
+    render_cmd_build(render, ctx);
     
     // create the socket
-    int sock = socket(remote_node->addr.ss_family, SOCK_STREAM, 0);
-
-    if (sock < 0) {
-        perror("render_remote: socket");
-        goto error;
-    }
+    if ((sock = socket(remote_node->addr.ss_family, SOCK_STREAM, 0)) < 0)
+        PERROR("socket");
 
     // mark it as nonblocking
-    if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
-        perror("render_remote: fcntl");
-        goto error;
-    }
+    if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1)
+        PERROR("fcntl");
     
     // initiate the connect
     int err = connect(sock, (struct sockaddr *) &remote_node->addr, sizeof(remote_node->addr));
 
-    if (err != -1 || errno != EINPROGRESS) {
-        perror("render_remote: connect");
-        goto error;
-    }
+    if (err != -1 || errno != EINPROGRESS)
+        PERROR("connect");
 
     // do the libevent dance
-    ctx->ev_conn = event_new(NULL, sock, EV_WRITE, &_remote_connected, ctx);
-
-    if (!ctx->ev_conn) {
-        error("render_remote: event_new");
-        goto error;
-    }
+    if (!(ctx->ev_conn = event_new(NULL, sock, EV_WRITE, &_remote_connected, ctx)))
+        ERROR("event_new");
 
-    if (event_add(ctx->ev_conn, NULL)) {
-        error("render_remote: event_add");
-        goto error;
-    }
-
-    // update remote_node load
-    remote_node->current_load++;
+    if (event_add(ctx->ev_conn, NULL))
+        ERROR("event_add");
     
     // success
     return ctx;
@@ -259,9 +231,13 @@
     // if it's still just connecting, cancel that
     if (event_pending(ctx->ev_conn, EV_WRITE, NULL)) {
         event_del(ctx->ev_conn);
+
     }
     
+    // close the socket (ctx->ev_conn remains valid even after we're done with it...)
+    close(event_get_fd(ctx->ev_conn));
+    
     // this takes care of the rest
-    _remote_render_ctx_free (ctx);
+    _remote_render_ctx_free (&ctx);
 }