void xr_client_set_timeout(xr_client_conn* conn, gint timeout)
{
g_return_if_fail(conn != NULL);
g_return_if_fail(timeout > 0);
g_socket_client_set_timeout(conn->client, timeout);
}
static void
g_socket_client_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GSocketClient *client = G_SOCKET_CLIENT (object);
switch (prop_id)
{
case PROP_FAMILY:
g_socket_client_set_family (client, g_value_get_enum (value));
break;
case PROP_TYPE:
g_socket_client_set_socket_type (client, g_value_get_enum (value));
break;
case PROP_PROTOCOL:
g_socket_client_set_protocol (client, g_value_get_enum (value));
break;
case PROP_LOCAL_ADDRESS:
g_socket_client_set_local_address (client, g_value_get_object (value));
break;
case PROP_TIMEOUT:
g_socket_client_set_timeout (client, g_value_get_uint (value));
break;
case PROP_ENABLE_PROXY:
g_socket_client_set_enable_proxy (client, g_value_get_boolean (value));
break;
case PROP_TLS:
g_socket_client_set_tls (client, g_value_get_boolean (value));
break;
case PROP_TLS_VALIDATION_FLAGS:
g_socket_client_set_tls_validation_flags (client, g_value_get_flags (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void mega_http_client_init(MegaHttpClient *http_client)
{
MegaHttpClientPrivate* priv = http_client->priv = G_TYPE_INSTANCE_GET_PRIVATE(http_client, MEGA_TYPE_HTTP_CLIENT, MegaHttpClientPrivate);
priv->client = g_socket_client_new();
g_socket_client_set_timeout(priv->client, 60);
g_socket_client_set_family(priv->client, G_SOCKET_FAMILY_IPV4);
priv->request_headers = g_hash_table_new_full(stri_hash, stri_equal, g_free, g_free);
priv->response_headers = g_hash_table_new_full(stri_hash, stri_equal, g_free, g_free);
priv->regex_url = g_regex_new("^([a-z]+)://([a-z0-9.-]+(?::([0-9]+))?)(/.+)?$", G_REGEX_CASELESS, 0, NULL);
priv->regex_status = g_regex_new("^HTTP/([0-9]+\\.[0-9]+) ([0-9]+) (.+)$", 0, 0, NULL);
// set default headers
mega_http_client_set_header(http_client, "Referer", "https://mega.co.nz/");
mega_http_client_set_header(http_client, "User-Agent", "Megatools (" VERSION ")");
mega_http_client_set_header(http_client, "Connection", "keep-alive");
}
static GSocketClient *
new_socket_client (SoupSocket *sock)
{
SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
GSocketClient *client = g_socket_client_new ();
g_signal_connect (client, "event",
G_CALLBACK (re_emit_socket_client_event), sock);
if (priv->proxy_resolver) {
g_socket_client_set_proxy_resolver (client, priv->proxy_resolver);
g_socket_client_add_application_proxy (client, "http");
} else
g_socket_client_set_enable_proxy (client, FALSE);
if (priv->timeout)
g_socket_client_set_timeout (client, priv->timeout);
if (priv->local_addr)
g_socket_client_set_local_address (client, soup_address_get_gsockaddr (priv->local_addr));
return client;
}
int
main (int argc, char *argv[])
{
GOptionContext *context;
GSocketClient *client;
GSocketConnection *connection;
GSocketAddress *address;
GCancellable *cancellable;
GOutputStream *out;
GError *error = NULL;
char buffer[1000];
g_type_init ();
context = g_option_context_new (" <hostname>[:port] - send data to tcp host");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (argc != 2)
{
g_printerr ("%s: %s\n", argv[0], "Need to specify hostname");
return 1;
}
if (async)
loop = g_main_loop_new (NULL, FALSE);
if (cancel_timeout)
{
GThread *thread;
cancellable = g_cancellable_new ();
thread = g_thread_new ("cancel", cancel_thread, cancellable);
g_thread_unref (thread);
}
else
{
cancellable = NULL;
}
client = g_socket_client_new ();
if (io_timeout)
g_socket_client_set_timeout (client, io_timeout);
if (verbose)
g_signal_connect (client, "event", G_CALLBACK (socket_client_event), NULL);
if (async)
{
GAsyncResult *res;
g_socket_client_connect_to_host_async (client, argv[1], 7777,
cancellable, async_cb, &res);
g_main_loop_run (loop);
connection = g_socket_client_connect_to_host_finish (client, res, &error);
g_object_unref (res);
}
else
{
connection = g_socket_client_connect_to_host (client,
argv[1],
7777,
cancellable, &error);
}
if (connection == NULL)
{
g_printerr ("%s can't connect: %s\n", argv[0], error->message);
return 1;
}
g_object_unref (client);
address = g_socket_connection_get_remote_address (connection, &error);
if (!address)
{
g_printerr ("Error getting remote address: %s\n",
error->message);
return 1;
}
g_print ("Connected to address: %s\n",
socket_address_to_string (address));
g_object_unref (address);
if (graceful)
g_tcp_connection_set_graceful_disconnect (G_TCP_CONNECTION (connection), TRUE);
out = g_io_stream_get_output_stream (G_IO_STREAM (connection));
while (fgets(buffer, sizeof (buffer), stdin) != NULL)
{
/* FIXME if (async) */
if (!g_output_stream_write_all (out, buffer, strlen (buffer),
NULL, cancellable, &error))
{
g_warning ("send error: %s\n", error->message);
g_error_free (error);
error = NULL;
}
}
g_print ("closing stream\n");
if (async)
{
GAsyncResult *res;
g_io_stream_close_async (G_IO_STREAM (connection),
0, cancellable, async_cb, &res);
g_main_loop_run (loop);
if (!g_io_stream_close_finish (G_IO_STREAM (connection),
res, &error))
{
g_object_unref (res);
g_warning ("close error: %s\n", error->message);
return 1;
}
g_object_unref (res);
}
else
{
if (!g_io_stream_close (G_IO_STREAM (connection), cancellable, &error))
{
g_warning ("close error: %s\n", error->message);
return 1;
}
}
g_object_unref (connection);
return 0;
}
static gboolean
run_server (guint * http_port, guint * https_port)
{
guint port = SOUP_ADDRESS_ANY_PORT;
guint ssl_port = SOUP_ADDRESS_ANY_PORT;
const char *ssl_cert_file = GST_TEST_FILES_PATH "/test-cert.pem";
const char *ssl_key_file = GST_TEST_FILES_PATH "/test-key.pem";
static int server_running = 0;
GSocketAddress *address;
GError *err = NULL;
SoupAuthDomain *domain = NULL;
if (server_running)
return TRUE;
server_running = 1;
*http_port = *https_port = 0;
server = soup_server_new (NULL, NULL);
if (!server) {
GST_DEBUG ("Unable to create server");
return FALSE;
}
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
domain = soup_auth_domain_basic_new (SOUP_AUTH_DOMAIN_REALM, realm,
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, basic_auth_cb,
SOUP_AUTH_DOMAIN_ADD_PATH, basic_auth_path, NULL);
soup_server_add_auth_domain (server, domain);
g_object_unref (domain);
domain = soup_auth_domain_digest_new (SOUP_AUTH_DOMAIN_REALM, realm,
SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK, digest_auth_cb,
SOUP_AUTH_DOMAIN_ADD_PATH, digest_auth_path, NULL);
soup_server_add_auth_domain (server, domain);
g_object_unref (domain);
address = g_inet_socket_address_new_from_string ("0.0.0.0", port);
soup_server_listen (server, address, 0, &err);
g_object_unref (address);
if (err) {
stop_server ();
g_clear_error (&err);
return FALSE;
}
*http_port = get_port_from_server (server);
GST_DEBUG ("HTTP server listening on port %u", *http_port);
if (ssl_cert_file && ssl_key_file) {
GTlsBackend *backend = g_tls_backend_get_default ();
if (backend != NULL && g_tls_backend_supports_tls (backend)) {
ssl_server = soup_server_new (SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
SOUP_SERVER_SSL_KEY_FILE, ssl_key_file, NULL);
} else {
GST_INFO ("No TLS support");
}
if (ssl_server) {
GST_INFO ("HTTPS server listening on port %u", *https_port);
soup_server_add_handler (ssl_server, NULL, server_callback, NULL, NULL);
address = g_inet_socket_address_new_from_string ("0.0.0.0", ssl_port);
soup_server_listen (ssl_server, address, SOUP_SERVER_LISTEN_HTTPS, &err);
g_object_unref (address);
if (err) {
GST_ERROR ("Failed to start HTTPS server: %s", err->message);
stop_server ();
g_clear_error (&err);
return FALSE;
}
*https_port = get_port_from_server (ssl_server);
GST_DEBUG ("HTTPS server listening on port %u", *https_port);
}
}
/* check if we can connect to our local http server */
{
GSocketConnection *conn;
GSocketClient *client;
client = g_socket_client_new ();
g_socket_client_set_timeout (client, 2);
conn = g_socket_client_connect_to_host (client, "127.0.0.1", *http_port,
NULL, NULL);
if (conn == NULL) {
GST_INFO ("Couldn't connect to http server 127.0.0.1:%u", *http_port);
g_object_unref (client);
stop_server ();
return FALSE;
}
g_object_unref (conn);
if (ssl_server == NULL)
goto skip_https_check;
conn = g_socket_client_connect_to_host (client, "127.0.0.1", *https_port,
NULL, NULL);
if (conn == NULL) {
GST_INFO ("Couldn't connect to https server 127.0.0.1:%u", *https_port);
g_object_unref (client);
stop_server ();
return FALSE;
}
g_object_unref (conn);
skip_https_check:
g_object_unref (client);
}
return TRUE;
}
