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);
}
