/* Read line from stdin asynchronously */
static gboolean
ob_in_iofunc (GIOChannel* iochannel, GIOCondition condition,
gpointer data)
{
GConn* conn = (GConn*) data;
/* Check for socket error */
if (condition & G_IO_ERR)
{
fprintf (stderr, "Error: Socket error\n");
goto error;
}
/* Check for data to be read (or if the stdin was closed (?)) */
if (condition & G_IO_IN)
{
GIOError error;
gchar buffer[1024];
gsize bytes_read;
/* Read the data into our buffer */
error = gnet_io_channel_readline (iochannel, buffer,
sizeof(buffer), &bytes_read);
/* Check for stdin error */
if (error != G_IO_ERROR_NONE)
{
fprintf (stderr, "Read error (%d)\n", error);
goto error;
}
/* Check for EOF */
else if (bytes_read == 0)
{
if (lines_pending == 0)
exit (EXIT_SUCCESS);
else
read_eof = TRUE;
return FALSE;
}
/* Otherwise, we read something */
else
{
gnet_conn_write (conn, buffer, bytes_read);
lines_pending++;
}
}
return TRUE;
error:
exit (EXIT_FAILURE);
return FALSE;
}
void
handle_client(GTcpSocket *client) {
RequestHeader *request_header;
GIOChannel *ioclient;
GInetAddr *addr;
GIOError error;
GPtrArray *request_query;
gchar* name;
gint port;
gchar read_buffer[1024];
gchar write_buffer[1024];
gsize read_buffer_n;
gsize write_buffer_n;
ioclient = gnet_tcp_socket_get_io_channel(client);
g_assert (ioclient);
addr = gnet_tcp_socket_get_remote_inetaddr(client);
g_assert (addr);
name = gnet_inetaddr_get_canonical_name (addr);
g_assert (name);
port = gnet_inetaddr_get_port (addr);
g_print ("Accepted connection from %s:%d\n", name, port);
g_free(name);
request_query = g_ptr_array_new();
while ((error = gnet_io_channel_readline(ioclient,
read_buffer,
sizeof(read_buffer),
&read_buffer_n)) == G_IO_ERROR_NONE && (read_buffer_n > 0))
{
if(g_strcmp0(read_buffer, BLANK_LINE) == 0) {
break;
}else {
g_ptr_array_add(request_query, g_strdup(read_buffer));
}
}
request_header = voy_request_header_initialize();
voy_request_header_create(request_query, request_header);
voy_request_header_print(request_header);
g_stpcpy(write_buffer, "HTTP/1.0 200 OK\r\nContent-type: text/html; charset=utf-8\r\n\r\n<h1>Hello from server!</h1>");
write_buffer_n = strlen(write_buffer);
gnet_io_channel_writen(ioclient, write_buffer, write_buffer_n, &write_buffer_n);
g_ptr_array_free(request_query, TRUE);
gnet_inetaddr_delete (addr);
voy_request_header_free(request_header);
}
static void
normal_echoserver(gchar *path, gboolean abstract)
{
GUnixSocket *client = NULL;
gchar buffer[1024];
gsize n;
GIOChannel *ioclient = NULL;
GIOError e;
g_assert(path != NULL);
/* Create the server */
if (abstract)
server = gnet_unix_socket_server_new_abstract(path);
else
server = gnet_unix_socket_server_new(path);
g_assert(server != NULL);
while ((client = gnet_unix_socket_server_accept(server)) != NULL) {
ioclient = gnet_unix_socket_get_io_channel(client);
g_assert(ioclient != NULL);
while ((e = gnet_io_channel_readline(ioclient, buffer,
sizeof(buffer), &n))
== G_IO_ERROR_NONE && (n > 0)) {
e = gnet_io_channel_writen(ioclient, buffer, n, &n);
if (e != G_IO_ERROR_NONE)
break;
if (fwrite(buffer, n, 1, stdout) != 1) {
fprintf (stderr, "Error: fwrite to stdout failed: %s\n", g_strerror (errno));
}
}
if (e != G_IO_ERROR_NONE)
fprintf(stderr,
"\nRecieved error %d (closing socket).\n",
e);
gnet_unix_socket_delete (client);
}
}
int gnet_xmlrpc_client_call(GNetXmlRpcClient *_client,
const gchar *method,
const gchar *param,
// output
gchar **reply)
{
GNetXmlRpcClientPrivate *client = (GNetXmlRpcClientPrivate*)_client;
gchar *xmlrpc_message = build_xmlrpc_message(method, param);
gchar *msg_start, *msg_end;
gchar *p;
GString *xmlrpc_string = g_string_new("");
GString *reply_string = g_string_new("");
gsize n;
gchar buffer[1024];
gint error;
n = strlen(xmlrpc_message);
// printf("Writing...\n"); fflush(stdout);
error = gnet_io_channel_writen (client->client.gnet_channel,
xmlrpc_message, n, &n);
// printf("error = %d\n", error); fflush(stdout);
if (error != G_IO_ERROR_NONE)
return -1;
// fprintf(stderr, "entering while loop\n");
while (gnet_io_channel_readline (client->client.gnet_channel, buffer, sizeof(buffer), &n) == G_IO_ERROR_NONE)
{
if (client->in_header)
{
// Check for a valid response
if (client->header_lineno == 0)
{
// If we don't have HTTP we've got a problem
if (g_strstr_len(buffer, 5, "HTTP") == NULL)
{
return -1;
}
}
else if (n==1)
{
client->in_header = FALSE;
}
else
{
// Look for the content-length string case independant.
char *p;
// Lower case buf
p = buffer;
while(*p)
{
*p = g_ascii_tolower(*p);
p++;
}
// Search for string
if ((p = g_strstr_len(buffer, n-1,
"content-length:")) != NULL)
{
p += strlen("Content-length:");
client->message_size = atoi(p);
}
}
client->header_lineno++;
}
// If we are not in the header then append the line to the xmlrpc string.
else
{
g_string_append_len(xmlrpc_string, buffer, n-1);
g_string_append_c(xmlrpc_string, '\n');
}
// Check if we are finished
if (xmlrpc_string->len
&& xmlrpc_string->len >= client->message_size)
{
// Quit and reset parsing for next message
client->in_header = 1;
client->header_lineno = 0;
break;
}
}
// Extract the response. Should be exchanged to some more robust
// XML parsing.
msg_start = g_strstr_len(xmlrpc_string->str,
xmlrpc_string->len,
"<value><string>");
if (msg_start == NULL)
return -1;
msg_start += strlen("<value><string>");
msg_end = g_strrstr(msg_start, "</string></value>");
// Decode the response
p = msg_start;
while(*p != '<')
{
gchar c = *p++;
if (c == '&')
{
if (g_strstr_len(p, 4, "amp;") == p)
{
g_string_append_c(reply_string, '&');
p+= 4;
}
else if (g_strstr_len(p, 3, "lt;") == p)
{
g_string_append_c(reply_string, '<');
p+= 3;
}
else if (g_strstr_len(p, 3, "gt;") == p)
{
g_string_append_c(reply_string, '>');
p+= 3;
}
else
{
// Don't know what to do. Just add the ampersand..
g_string_append_c(reply_string, '&');
}
}
else
g_string_append_c(reply_string, c);
}
*reply = reply_string->str;
g_string_free(reply_string, FALSE);
g_string_free(xmlrpc_string, TRUE);
return 0;
}
