static GSocketAddressEnumerator * soup_address_connectable_proxy_enumerate (GSocketConnectable *connectable) { SoupAddress *addr = SOUP_ADDRESS (connectable); SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr); GSocketAddressEnumerator *proxy_enum; SoupURI *uri; char *uri_string; /* We cheerily assume "http" here because you shouldn't be * using SoupAddress any more if you're not doing HTTP anyway. */ uri = soup_uri_new (NULL); soup_uri_set_scheme (uri, priv->protocol ? priv->protocol : "http"); soup_uri_set_host (uri, priv->name ? priv->name : soup_address_get_physical (addr)); soup_uri_set_port (uri, priv->port); soup_uri_set_path (uri, ""); uri_string = soup_uri_to_string_internal (uri, FALSE, TRUE); proxy_enum = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR, "connectable", connectable, "uri", uri_string, NULL); g_free (uri_string); soup_uri_free (uri); return proxy_enum; }
static void soup_address_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (object); switch (prop_id) { case PROP_NAME: g_value_set_string (value, priv->name); break; case PROP_FAMILY: if (priv->sockaddr) g_value_set_enum (value, SOUP_ADDRESS_GET_FAMILY (priv)); else g_value_set_enum (value, 0); break; case PROP_PORT: g_value_set_int (value, priv->port); break; case PROP_PHYSICAL: g_value_set_string (value, soup_address_get_physical (SOUP_ADDRESS (object))); break; case PROP_PROTOCOL: g_value_set_string (value, priv->protocol); break; case PROP_SOCKADDR: g_value_set_pointer (value, priv->sockaddr); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void on_address_resolved_complete (SoupAddress *address, guint status, gpointer user_data) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data)); source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res); gchar *server; g_object_get (self, "key-server", &server, NULL); g_return_if_fail (server && server[0]); seahorse_progress_update (closure->cancellable, res, _("Connecting to: %s"), server); g_free (server); /* DNS failed */ if (!SOUP_STATUS_IS_SUCCESSFUL (status)) { g_simple_async_result_set_error (res, SEAHORSE_ERROR, -1, _("Couldn’t resolve address: %s"), soup_address_get_name (address)); g_simple_async_result_complete_in_idle (res); /* Yay resolved */ } else { once_resolved_start_connect (self, res, soup_address_get_physical (address)); } g_object_unref (res); }
/** * soup_client_context_get_host: * @client: a #SoupClientContext * * Retrieves the IP address associated with the remote end of a * connection. (If you want the actual hostname, you'll have to call * soup_client_context_get_address() and then call the appropriate * #SoupAddress method to resolve it.) * * Return value: the IP address associated with the remote end of a * connection. **/ const char * soup_client_context_get_host (SoupClientContext *client) { SoupAddress *address; address = soup_client_context_get_address (client); return soup_address_get_physical (address); }
static void resolve_callback (SoupAddress *addr, guint status, gpointer data) { if (status == SOUP_STATUS_OK) { printf ("Name: %s\n", soup_address_get_name (addr)); printf ("Address: %s\n", soup_address_get_physical (addr)); } else { printf ("Name: %s\n", soup_address_get_name (addr)); printf ("Error: %s\n", soup_status_get_phrase (status)); } printf ("\n"); nlookups--; if (nlookups == 0) g_main_loop_quit (loop); }
static GSocketAddressEnumerator * soup_address_connectable_proxy_enumerate (GSocketConnectable *connectable) { SoupAddress *addr = SOUP_ADDRESS (connectable); SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr); GSocketAddressEnumerator *proxy_enum; char *uri; /* We cheerily assume "http" here because you shouldn't be * using SoupAddress any more if you're not doing HTTP anyway. */ uri = g_strdup_printf ("%s://%s:%u", priv->protocol ? priv->protocol : "http", priv->name ? priv->name : soup_address_get_physical (addr), priv->port); proxy_enum = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR, "connectable", connectable, "uri", uri, NULL); g_free (uri); return proxy_enum; }
void gss_transaction_dump (GssTransaction * t) { SoupMessageHeadersIter iter; const char *name; const char *value; g_print ("Request: %s %s\n", t->msg->method, t->path); if (t->query) { GHashTableIter iter; char *key, *value; g_hash_table_iter_init (&iter, t->query); while (g_hash_table_iter_next (&iter, (gpointer) & key, (gpointer) & value)) { g_print (" %s=%s\n", key, value); } } if (t->msg->method == SOUP_METHOD_POST) { g_print ("Content:\n%s\n", t->msg->request_body->data); } g_print ("From: %s\n", soup_address_get_physical (soup_client_context_get_address (t->client))); g_print ("Status: %d\n", t->msg->status_code); g_print ("Request Headers:\n"); soup_message_headers_iter_init (&iter, t->msg->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { g_print (" %s: %s\n", name, value); } g_print ("Response Headers:\n"); soup_message_headers_iter_init (&iter, t->msg->response_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { g_print (" %s: %s\n", name, value); } g_print ("\n"); }
static guint parse_request_headers (SoupMessage *msg, char *headers, guint headers_len, SoupEncoding *encoding, gpointer sock) { SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); char *req_method, *req_path, *url; SoupHTTPVersion version; const char *req_host; guint status; SoupURI *uri; status = soup_headers_parse_request (headers, headers_len, msg->request_headers, &req_method, &req_path, &version); if (!SOUP_STATUS_IS_SUCCESSFUL (status)) return status; g_object_set (G_OBJECT (msg), SOUP_MESSAGE_METHOD, req_method, SOUP_MESSAGE_HTTP_VERSION, version, NULL); g_free (req_method); /* Handle request body encoding */ *encoding = soup_message_headers_get_encoding (msg->request_headers); if (*encoding == SOUP_ENCODING_UNRECOGNIZED) { if (soup_message_headers_get_list (msg->request_headers, "Transfer-Encoding")) return SOUP_STATUS_NOT_IMPLEMENTED; else return SOUP_STATUS_BAD_REQUEST; } /* Generate correct context for request */ req_host = soup_message_headers_get_one (msg->request_headers, "Host"); if (req_host && strchr (req_host, '/')) { g_free (req_path); return SOUP_STATUS_BAD_REQUEST; } if (!strcmp (req_path, "*") && req_host) { /* Eg, "OPTIONS * HTTP/1.1" */ url = g_strdup_printf ("%s://%s", soup_socket_is_ssl (sock) ? "https" : "http", req_host); uri = soup_uri_new (url); if (uri) soup_uri_set_path (uri, "*"); g_free (url); } else if (*req_path != '/') { /* Must be an absolute URI */ uri = soup_uri_new (req_path); } else if (req_host) { url = g_strdup_printf ("%s://%s%s", soup_socket_is_ssl (sock) ? "https" : "http", req_host, req_path); uri = soup_uri_new (url); g_free (url); } else if (priv->http_version == SOUP_HTTP_1_0) { /* No Host header, no AbsoluteUri */ SoupAddress *addr = soup_socket_get_local_address (sock); uri = soup_uri_new (NULL); soup_uri_set_scheme (uri, soup_socket_is_ssl (sock) ? SOUP_URI_SCHEME_HTTPS : SOUP_URI_SCHEME_HTTP); soup_uri_set_host (uri, soup_address_get_physical (addr)); soup_uri_set_port (uri, soup_address_get_port (addr)); soup_uri_set_path (uri, req_path); } else uri = NULL; g_free (req_path); if (!SOUP_URI_VALID_FOR_HTTP (uri)) { /* certainly not "a valid host on the server" (RFC2616 5.2.3) * SOUP_URI_VALID_FOR_HTTP also guards against uri == NULL */ if (uri) soup_uri_free (uri); return SOUP_STATUS_BAD_REQUEST; } soup_message_set_uri (msg, uri); soup_uri_free (uri); return SOUP_STATUS_OK; }
static void server_api_status_callback (SoupServer * server, SoupMessage * msg, const char *path, GHashTable * query, SoupClientContext * client, gpointer user_data) { (void) server; (void) path; (void) query; (void) client; (void) user_data; char *response = NULL; GPtrArray *r_array = NULL; GPtrArray *unr_array = NULL; GPtrArray *connected_sensors = NULL; GHashTable *hash; GString *st_sensors = NULL; GString *st_unrsensors = NULL; GString *st_csensors = NULL; gchar *per_session_stats = NULL; gchar *engine_stats = NULL; gchar *server_stats = NULL; GTimeVal current_time; SoupSocket *sock = NULL; SoupAddress *sockaddr = NULL; SoupURI *uri = NULL; guint i; /* Only get methods and no params */ g_get_current_time (¤t_time); if (msg->method != SOUP_METHOD_GET || query != NULL) { soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED); return; } /* Verificación anti listos */ if ((sock = soup_client_context_get_socket (client)) == NULL) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } /* If host == 127.0.0.1 or host == localhost, verify that the localaddress == 127.0.0.1 */ if ((uri = soup_message_get_uri (msg)) == NULL) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } if (strcmp (uri->host,"127.0.0.1") == 0 || strcmp (uri->host,"localhost") == 0) { if ((sockaddr = soup_socket_get_local_address (sock)) == NULL) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } else { /* Aquí hay un listo */ if (strcmp ( soup_address_get_physical(sockaddr),"127.0.0.1") != 0) { soup_message_set_status (msg, SOUP_STATUS_UNAUTHORIZED); return; } } } if (server_api_get_info_sensors (&r_array, &unr_array, &hash) == FALSE) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } /* Load the info of connected sensors */ if (sim_server_get_sensor_uuids_unique (ossim.server, &connected_sensors) == FALSE) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } if ((st_sensors = g_string_new ("")) == NULL) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } if ((st_unrsensors = g_string_new ("")) == NULL) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } if ((st_csensors = g_string_new ("")) == NULL) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } /* For the register sensors */ if (r_array->len > 0) { for (i = 0; i < r_array->len; i++) { g_string_append_printf (st_sensors, "\"%s\"", (gchar *) g_ptr_array_index (r_array, i)); if ((i != (r_array->len - 1))) { g_string_append_c (st_sensors, ','); } } g_string_prepend_c (st_sensors, '['); g_string_append_c (st_sensors, ']'); } else { g_string_printf (st_sensors, "[null]"); } /* For the unregister sensors */ if (unr_array->len > 0) { for (i = 0; i < unr_array->len; i++) { g_string_append_printf (st_unrsensors, "\"%s\"", (gchar *) g_ptr_array_index (unr_array, i)); if ((i != (unr_array->len - 1))) { g_string_append_c (st_unrsensors, ','); } } g_string_prepend_c (st_unrsensors, '['); g_string_append_c (st_unrsensors, ']'); } else { g_string_printf (st_unrsensors, "[null]"); } /* The connected sensors */ if (connected_sensors->len > 0) { int count = 0; for (i = 0; i < connected_sensors->len; i++) { char *av_uuid; if ((av_uuid = g_hash_table_lookup (hash, (gchar *) g_ptr_array_index (connected_sensors, i))) != NULL) { g_string_append_printf (st_csensors, "\"%s\"", av_uuid); count++; if ((i != (connected_sensors->len - 1))) { g_string_append_c (st_csensors, ','); } } } if (count > 0) { g_string_prepend_c (st_csensors, '['); g_string_append_c (st_csensors, ']'); } else { g_string_printf (st_csensors, "[null]"); } } else { g_string_printf (st_csensors, "[null]"); } per_session_stats = sim_server_api_get_per_session_stats (); server_stats = server_api_get_server_stats (¤t_time); engine_stats = server_api_get_engine_stats (¤t_time); old_time.tv_sec = current_time.tv_sec; response = g_strdup_printf ("{\"result\":{\"request\":\"/server/status\",\n\"timestamp\":\"%lld\",\n\"rsensors\":%s,\n\"unrsensors\":%s,\n\"csensors\":%s,\n\"engine_stats\":[%s],\n\"server_stats\":%s,\n\"per_session_stats\":%s\n},\n\"status\":\"OK\"\n}", (long long) time (NULL), st_sensors->str, st_unrsensors->str, st_csensors->str, engine_stats, server_stats, per_session_stats ); soup_message_set_response (msg, "application/json", SOUP_MEMORY_TAKE, response, strlen (response)); soup_message_set_status (msg, SOUP_STATUS_OK); if (r_array != NULL) g_ptr_array_unref (r_array); if (unr_array != NULL) g_ptr_array_unref (unr_array); if (hash != NULL) g_hash_table_destroy (hash); if (st_sensors != NULL) { g_string_free (st_sensors, TRUE); } if (st_unrsensors != NULL) { g_string_free (st_unrsensors, TRUE); } if (st_csensors != NULL) { g_string_free (st_csensors, TRUE); } if (connected_sensors != NULL) g_ptr_array_unref (connected_sensors); g_free (per_session_stats); g_free (engine_stats); g_free (server_stats); }