Example #1
0
static void
client_connected_cb (GServer *server,
                     GConn *conn,
                     gpointer user_data)
{
  OdccmDeviceManager *self = ODCCM_DEVICE_MANAGER (user_data);
  OdccmDeviceManagerPrivate *priv = ODCCM_DEVICE_MANAGER_GET_PRIVATE (self);
  struct in_addr addr;
  OdccmDevice *dev = NULL;
  GSList *cur;

  if (conn == NULL)
    {
      g_warning ("%s: an error occurred", G_STRFUNC);
      return;
    }

  gnet_inetaddr_get_bytes (gnet_tcp_socket_get_remote_inetaddr (conn->socket),
                           (gchar *) &(addr.s_addr));

  for (cur = priv->devices; cur != NULL && dev == NULL; cur = cur->next)
    {
      guint32 cur_addr;

      g_object_get (cur->data, "ip-address", &cur_addr, NULL);

      if (cur_addr == addr.s_addr)
        {
          dev = cur->data;
        }
    }

  if (dev != NULL)
    {
      _odccm_device_client_connected (dev, conn);
    }
  else
    {
#ifdef ENABLE_LEGACY_SUPPORT
      GInetAddr *local_inet_addr = gnet_tcp_socket_get_local_inetaddr (conn->socket);
      if (gnet_inetaddr_get_port(local_inet_addr) == 5679) {
	dev = g_object_new (ODCCM_TYPE_DEVICE_LEGACY, "connection", conn, NULL);
	g_signal_connect(dev, "device-legacy-noping", G_CALLBACK(legacy_device_noping_cb), self);
      }
      else
	dev = g_object_new (ODCCM_TYPE_DEVICE, "connection", conn, NULL);
      gnet_inetaddr_unref(local_inet_addr);
#else
      dev = g_object_new (ODCCM_TYPE_DEVICE, "connection", conn, NULL);
#endif

      priv->devices = g_slist_append (priv->devices, dev);

      g_signal_connect (dev, "notify::object-path",
                        (GCallback) device_obj_path_changed_cb,
                        self);

      gnet_conn_unref (conn);
    }
}
Example #2
0
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);
}
Example #3
0
GTcpSocket*
initialize_server(gint server_port) {
  GTcpSocket *server;
  GInetAddr *addr;
  gint port;
  gchar *name;

  server = gnet_tcp_socket_server_new_with_port(server_port);
  
  addr = gnet_tcp_socket_get_local_inetaddr(server);
  g_assert(addr);

  name = gnet_inetaddr_get_canonical_name(addr);
  g_assert(name);

  port = gnet_inetaddr_get_port(addr);
  g_print("Voyager1 started at %s:%d\n\n", name, port);

  gnet_inetaddr_delete (addr);
  g_free(name);

  return server;
}
Example #4
0
int
main(int argc, char** argv)
{
  gchar* hostname;
  gint port;
  GInetAddr* addr;
  GTcpSocket* socket;
  GIOChannel* iochannel;
  GIOError error = G_IO_ERROR_NONE;
  gchar buffer[1024];
  gsize n;

  gnet_init ();

  /* Parse args */
  if (argc != 3)
    {  
      g_print ("usage: %s <server> <port>\n", argv[0]);
      exit(EXIT_FAILURE);
    }
  hostname = argv[1];
  port = atoi(argv[2]);

  /* Create the address */
  addr = gnet_inetaddr_new (hostname, port);
  if (!addr)
    {
      fprintf (stderr, "Error: Name lookup for %s failed\n", hostname);
      exit (EXIT_FAILURE);
    }

  /* Create the socket */
  socket = gnet_tcp_socket_new (addr);
  gnet_inetaddr_delete (addr);
  if (!socket)
    {
      fprintf (stderr, "Error: Could not connect to %s:%d\n", hostname, port);
      exit (EXIT_FAILURE);
    }

#if 0
  {
    gchar* cname;

    /* Print local address */
    addr = gnet_tcp_socket_get_local_inetaddr (socket);
    g_assert (addr);
    cname = gnet_inetaddr_get_canonical_name (addr);
    g_assert (cname);
    g_print ("Local address: %s:%d\n", cname, gnet_inetaddr_get_port(addr));
    g_free (cname);
    gnet_inetaddr_delete (addr);

    /* Print remote address */
    addr = gnet_tcp_socket_get_remote_inetaddr (socket);
    g_assert (addr);
    cname = gnet_inetaddr_get_canonical_name (addr);
    g_assert (cname);
    g_print ("Remote address: %s:%d\n", cname, gnet_inetaddr_get_port(addr));
    g_free (cname);
    gnet_inetaddr_delete (addr);
  }
#endif

  /* Get the IOChannel */
  iochannel = gnet_tcp_socket_get_io_channel (socket);
  g_assert (iochannel != NULL);

  while (fgets(buffer, sizeof(buffer), stdin) != 0)
    {
      n = strlen(buffer);
      error = gnet_io_channel_writen (iochannel, buffer, n, &n);
      if (error != G_IO_ERROR_NONE) break;

      error = gnet_io_channel_readn (iochannel, buffer, n, &n);
      if (error != 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 (error != G_IO_ERROR_NONE) 
    fprintf (stderr, "Error: IO error (%d)\n", error);

  gnet_tcp_socket_delete (socket);

  return 0;
}