void remote_client_connect (RemoteClient* self)
{
/* Clean up after the previous connection, if we need to */
if (self->gconn) {
gnet_conn_delete(self->gconn);
self->gconn = NULL;
}
remote_client_empty_queue(self);
/* Reset our speed counters and rate limiting timers */
self->iter_accumulator = 0;
self->byte_accumulator = 0;
self->iters_per_sec = 0;
self->bytes_per_sec = 0;
g_timer_start(self->stream_request_timer);
g_timer_start(self->status_speed_timer);
g_timer_start(self->stream_speed_timer);
/* Create the new connection object */
self->gconn = gnet_conn_new(self->host, self->port, remote_client_callback, self);
gnet_conn_set_watch_error(self->gconn, TRUE);
gnet_conn_connect(self->gconn);
gnet_conn_readline(self->gconn);
remote_client_update_status(self, "Connecting...");
}
static void
ob_client_func (GConn* conn, GConnEvent* event, gpointer user_data)
{
gchar* buf2;
switch (event->type)
{
case GNET_CONN_READ:
{
event->buffer[event->length-1] = '\n';
buf2= g_memdup (event->buffer, event->length+1);
buf2[event->length]='\0';
g_list_foreach(connection_list,send_to,buf2);
gnet_conn_readline (conn);
break;
}
case GNET_CONN_WRITE:
{
; /* Do nothing */
break;
}
case GNET_CONN_CLOSE:
case GNET_CONN_TIMEOUT:
case GNET_CONN_ERROR:
{
connection_list = g_list_remove(connection_list, conn );
gnet_conn_delete (conn);
break;
}
default:
g_assert_not_reached ();
}
}
static void
ob_client_func (GConn* conn, GConnEvent* event, gpointer user_data)
{
switch (event->type)
{
case GNET_CONN_READ:
{
event->buffer[event->length-1] = '\n';
gnet_conn_write (conn, event->buffer, event->length);
/* fwrite (event->buffer, event->length, 1, stdout); */
gnet_conn_readline (conn);
break;
}
case GNET_CONN_WRITE:
{
; /* Do nothing */
break;
}
case GNET_CONN_CLOSE:
case GNET_CONN_TIMEOUT:
case GNET_CONN_ERROR:
{
gnet_conn_delete (conn);
break;
}
default:
g_assert_not_reached ();
}
}
static void remote_client_recv_line (RemoteClient* self,
GConnEvent* event)
{
RemoteResponse *response = g_new0(RemoteResponse, 1);
RemoteClosure *closure;
response->code = strtol(event->buffer, &response->message, 10);
if (*response->message)
response->message++;
response->message = g_strdup(response->message);
if (response->code == FYRE_RESPONSE_BINARY) {
/* Extract the length of the binary response, then start
* reading the binary data itself. Note that if we
* have a zero-length binary message, skip the next
* stage and fall through to processing a normal message.
*/
response->data_length = strtol(response->message, NULL, 10);
if (response->data_length > 0) {
self->current_binary_response = response;
gnet_conn_readn(self->gconn, response->data_length);
return;
}
}
/* We're done, signal the callback and start waiting
* for another normal response line.
*/
closure = g_queue_pop_tail(self->response_queue);
if (closure) {
/* This was an answer to some request. Invoke the callback
* if one was specified.
*/
if (closure->callback)
closure->callback(self, response, closure->user_data);
g_free(closure);
}
else {
/* This was unsolicited- should only occur for the server ready message */
if (response->code == FYRE_RESPONSE_READY) {
self->is_ready = TRUE;
remote_client_update_status(self, "Ready");
}
else {
remote_client_update_status(self, "Protocol error");
}
}
g_free(response->message);
g_free(response);
gnet_conn_readline(self->gconn);
}
static void
ob_server_func (GServer* server, GConn* conn, gpointer user_data)
{
if (conn)
{
gnet_conn_set_callback (conn, ob_client_func, NULL);
gnet_conn_set_watch_error (conn, TRUE);
gnet_conn_readline (conn);
}
else /* Error */
{
gnet_server_delete (server);
exit (EXIT_FAILURE);
}
}
static void remote_client_recv_binary (RemoteClient* self,
GConnEvent* event)
{
RemoteClosure* closure = g_queue_pop_tail(self->response_queue);
RemoteResponse* response = self->current_binary_response;
self->current_binary_response = NULL;
g_assert(closure != NULL);
response->data = event->buffer;
if (closure->callback)
closure->callback(self, response, closure->user_data);
g_free(closure);
g_free(response->message);
g_free(response);
gnet_conn_readline(self->gconn);
}
static void remote_server_connect (GServer* gserver,
GConn* gconn,
gpointer user_data)
{
RemoteServerConn* self = g_new0(RemoteServerConn, 1);
self->server = (RemoteServer*) user_data;
self->gconn = gconn;
self->map = ITERATIVE_MAP(de_jong_new());
gnet_conn_set_callback(gconn, remote_server_callback, self);
gnet_conn_set_watch_error(gconn, TRUE);
gnet_conn_readline(gconn);
remote_server_send_response(self, FYRE_RESPONSE_READY,
"Fyre rendering server ready");
if (self->server->verbose)
printf("[%s:%d] Connected\n", gconn->hostname, gconn->port);
}
static void remote_server_callback (GConn* gconn,
GConnEvent* event,
gpointer user_data)
{
RemoteServerConn* self = (RemoteServerConn*) user_data;
switch (event->type) {
case GNET_CONN_READ:
remote_server_dispatch_line(self, event->buffer);
gnet_conn_readline(gconn);
break;
case GNET_CONN_CLOSE:
case GNET_CONN_TIMEOUT:
case GNET_CONN_ERROR:
remote_server_disconnect(self);
break;
default:
break;
}
}
static void ob_server_func (GServer* server, GServerStatus status, struct _GConn* conn, gpointer user_data)
{
switch (status)
{
case GNET_SERVER_STATUS_CONNECT:
{
if (debug) {
LOG(LOG_DEBUG, "New connection from %s", gnet_inetaddr_get_canonical_name(conn->inetaddr));
}
conn->func = ob_client_func;
conn->user_data = calloc(1, sizeof(struct conn_stat));
gnet_conn_write (conn, strdup(hello), strlen(hello), 0);
gnet_conn_readline (conn, NULL, 1024, 30000);
break;
}
case GNET_SERVER_STATUS_ERROR:
{
gnet_server_delete (server);
exit (1);
break;
}
}
}
/* Handle GConn events */
static void
ob_conn_func (GConn* conn, GConnEvent* event, gpointer user_data)
{
switch (event->type)
{
case GNET_CONN_CONNECT:
{
gnet_conn_timeout (conn, 0); /* reset timeout */
gnet_conn_readline (conn);
break;
}
case GNET_CONN_READ:
{
/* Write line out */
event->buffer[event->length - 1] = '\n';
if (fwrite (event->buffer, event->length, 1, stdout) != 1) {
fprintf (stderr, "Error: fwrite to stdout failed: %s\n", g_strerror (errno));
}
/* Check if done */
lines_pending--;
if (lines_pending == 0 && read_eof)
exit (EXIT_SUCCESS);
/* Read another line */
gnet_conn_readline (conn);
break;
}
case GNET_CONN_WRITE:
{
; /* do nothing */
break;
}
case GNET_CONN_CLOSE:
{
gnet_conn_delete (conn);
exit (EXIT_SUCCESS);
break;
}
case GNET_CONN_TIMEOUT:
{
gnet_conn_delete (conn);
fprintf (stderr, "Connection timeout\n");
exit (EXIT_FAILURE);
break;
}
case GNET_CONN_ERROR:
{
gnet_conn_delete (conn);
fprintf (stderr, "Connection failure\n");
exit (EXIT_FAILURE);
break;
}
default:
g_assert_not_reached ();
}
}
