コード例 #1
0
static SoupSession *
create_hkp_soup_session (void)
{
	SoupSession *session;
#if WITH_DEBUG
	SoupLogger *logger;
	const gchar *env;
#endif

        session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
                                                       SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
                                                       NULL);


#if WITH_DEBUG
        env = g_getenv ("G_MESSAGES_DEBUG");
        if (env && strstr (env, "seahorse")) {
		logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
		g_object_unref (logger);
	}
#endif

	return session;
}
コード例 #2
0
ファイル: aur-client.c プロジェクト: kevinjen1031/aurena
static void
aur_client_constructed (GObject * object)
{
  AurClient *client = (AurClient *) (object);
  gint max_con = 1;

  if (G_OBJECT_CLASS (aur_client_parent_class)->constructed != NULL)
    G_OBJECT_CLASS (aur_client_parent_class)->constructed (object);

  client->soup =
      soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
      client->context, NULL);
  g_assert (client->soup);
  if (!g_strcmp0 ("1", g_getenv ("AURENA_DEBUG")))
    soup_session_add_feature (client->soup,
        SOUP_SESSION_FEATURE (soup_logger_new (SOUP_LOGGER_LOG_BODY, -1)));

  /* Set a 20 second timeout on pings from the server */
  g_object_set (G_OBJECT (client->soup), "idle-timeout", 20, NULL);
  /* 5 second timeout before retrying with new connections */
  g_object_set (G_OBJECT (client->soup), "timeout", 5, NULL);

  if (client->flags & AUR_CLIENT_PLAYER)
    max_con++;

  if (client->flags & AUR_CLIENT_CONTROLLER)
    max_con++;

  g_object_set (client->soup, "max-conns-per-host", max_con, NULL);

  try_reconnect (client);
}
コード例 #3
0
ファイル: test-utils.c プロジェクト: BabaNina/libsoup
SoupSession *
soup_test_session_new (GType type, ...)
{
	va_list args;
	const char *propname;
	SoupSession *session;

	va_start (args, type);
	propname = va_arg (args, const char *);
	session = (SoupSession *)g_object_new_valist (type, propname, args);
	va_end (args);

	g_object_set (G_OBJECT (session),
		      SOUP_SESSION_SSL_CA_FILE, SRCDIR "/test-cert.pem",
		      SOUP_SESSION_SSL_STRICT, FALSE,
		      NULL);

	if (http_debug_level && !logger) {
		SoupLoggerLogLevel level = MIN ((SoupLoggerLogLevel)http_debug_level, SOUP_LOGGER_LOG_BODY);

		logger = soup_logger_new (level, -1);
	}

	if (logger)
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));

	return session;
}
コード例 #4
0
void
goa_http_client_check (GoaHttpClient       *self,
                       const gchar         *uri,
                       const gchar         *username,
                       const gchar         *password,
                       gboolean             accept_ssl_errors,
                       GCancellable        *cancellable,
                       GAsyncReadyCallback  callback,
                       gpointer             user_data)
{
  CheckData *data;
  CheckAuthData *auth;
  SoupLogger *logger;

  g_return_if_fail (GOA_IS_HTTP_CLIENT (self));
  g_return_if_fail (uri != NULL && uri[0] != '\0');
  g_return_if_fail (username != NULL && username[0] != '\0');
  g_return_if_fail (password != NULL && password[0] != '\0');
  g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

  data = g_slice_new0 (CheckData);
  data->res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, goa_http_client_check);
  data->session = soup_session_new_with_options (SOUP_SESSION_SSL_STRICT, FALSE,
                                                 NULL);

  logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
  soup_logger_set_printer (logger, http_client_log_printer, NULL, NULL);
  soup_session_add_feature (data->session, SOUP_SESSION_FEATURE (logger));
  g_object_unref (logger);

  data->accept_ssl_errors = accept_ssl_errors;

  data->msg = soup_message_new (SOUP_METHOD_GET, uri);
  soup_message_headers_append (data->msg->request_headers, "Connection", "close");

  if (cancellable != NULL)
    {
      data->cancellable = g_object_ref (cancellable);
      data->cancellable_id = g_cancellable_connect (data->cancellable,
                                                    G_CALLBACK (http_client_check_cancelled_cb),
                                                    data,
                                                    NULL);
      g_simple_async_result_set_check_cancellable (data->res, data->cancellable);
    }

  auth = g_slice_new0 (CheckAuthData);
  auth->username = g_strdup (username);
  auth->password = g_strdup (password);
  g_signal_connect_data (data->session,
                         "authenticate",
                         G_CALLBACK (http_client_authenticate),
                         auth,
                         http_client_check_auth_data_free,
                         0);

  g_signal_connect (data->session, "request-started", G_CALLBACK (http_client_request_started), data);
  soup_session_queue_message (data->session, data->msg, http_client_check_response_cb, data);
}
コード例 #5
0
ファイル: net.c プロジェクト: gcampax/liferea
void
network_init (void)
{
	gchar		*useragent;
	SoupCookieJar	*cookies;
	gchar		*filename;
	SoupLogger	*logger;

	/* Set an appropriate user agent */
	if (g_getenv ("LANG")) {
		/* e.g. "Liferea/1.10.0 (Linux; de_DE; https://lzone.de/liferea/) AppleWebKit (KHTML, like Gecko)" */
		useragent = g_strdup_printf ("Liferea/%s (%s; %s; %s) AppleWebKit (KHTML, like Gecko)", VERSION, OSNAME, g_getenv ("LANG"), HOMEPAGE);
	} else {
		/* e.g. "Liferea/1.10.0 (Linux; https://lzone.de/liferea/) AppleWebKit (KHTML, like Gecko)" */
		useragent = g_strdup_printf ("Liferea/%s (%s; %s) AppleWebKit (KHTML, like Gecko)", VERSION, OSNAME, HOMEPAGE);
	}

	/* Cookies */
	filename = common_create_config_filename ("cookies.txt");
	cookies = soup_cookie_jar_text_new (filename, FALSE);
	g_free (filename);

	/* Initialize libsoup */
	session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
						 SOUP_SESSION_TIMEOUT, 120,
						 SOUP_SESSION_IDLE_TIMEOUT, 30,
						 SOUP_SESSION_ADD_FEATURE, cookies,
	                                         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
						 NULL);
	session2 = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
						  SOUP_SESSION_TIMEOUT, 120,
						  SOUP_SESSION_IDLE_TIMEOUT, 30,
						  SOUP_SESSION_ADD_FEATURE, cookies,
	                                          SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
						  SOUP_SESSION_PROXY_URI, NULL,
						  SOUP_SESSION_PROXY_RESOLVER, NULL,
						  NULL);

	/* Only 'session' gets proxy, 'session2' is for non-proxy requests */
	network_set_soup_session_proxy (session, network_get_proxy_detect_mode(),
		network_get_proxy_host (),
		network_get_proxy_port (),
		network_get_proxy_username (),
		network_get_proxy_password ());

	g_signal_connect (session, "authenticate", G_CALLBACK (network_authenticate), NULL);

	/* Soup debugging */
	if (debug_level & DEBUG_NET) {
		logger = soup_logger_new (SOUP_LOGGER_LOG_HEADERS, -1);
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
	}

	g_free (useragent);
}
コード例 #6
0
ファイル: snra-client.c プロジェクト: ndufresne/aurena
static void
snra_client_init (SnraClient * client)
{
  client->soup = soup_session_async_new ();
  client->server_port = 5457;
  client->paused = TRUE;

  if (!g_strcmp0 ("1", g_getenv ("AURENA_DEBUG")))
    soup_session_add_feature (client->soup,
        SOUP_SESSION_FEATURE (soup_logger_new (SOUP_LOGGER_LOG_BODY, -1)));
}
コード例 #7
0
ファイル: callbacks.c プロジェクト: gnutrino/uzbl
void
cmd_http_debug() {
    soup_session_remove_feature
        (uzbl.net.soup_session, SOUP_SESSION_FEATURE(uzbl.net.soup_logger));
    /* do we leak if this doesn't get freed? why does it occasionally crash if freed? */
    /*g_free(uzbl.net.soup_logger);*/

    uzbl.net.soup_logger = soup_logger_new(uzbl.behave.http_debug, -1);
    soup_session_add_feature(uzbl.net.soup_session,
            SOUP_SESSION_FEATURE(uzbl.net.soup_logger));
}
コード例 #8
0
ファイル: SoupNetworkSession.cpp プロジェクト: boska/webkit
void SoupNetworkSession::setupLogger()
{
#if !LOG_DISABLED
    if (LogNetwork.state != WTFLogChannelOn || soup_session_get_feature(m_soupSession.get(), SOUP_TYPE_LOGGER))
        return;

    GRefPtr<SoupLogger> logger = adoptGRef(soup_logger_new(SOUP_LOGGER_LOG_BODY, -1));
    soup_session_add_feature(m_soupSession.get(), SOUP_SESSION_FEATURE(logger.get()));
    soup_logger_set_printer(logger.get(), soupLogPrinter, nullptr, nullptr);
#endif
}
コード例 #9
0
ファイル: seahorse-hkp-source.c プロジェクト: nobled/seahorse
static void 
seahorse_hkp_operation_init (SeahorseHKPOperation *hop)
{
    SoupURI *uri;
    gchar *host;
#if DEBUG_HKP_ENABLE
    SoupLogger *logger;
#endif
    
    if (seahorse_gconf_get_boolean (GCONF_USE_HTTP_PROXY)) {
        
        host = seahorse_gconf_get_string (GCONF_HTTP_PROXY_HOST);
        if (host) {
            uri = soup_uri_new (NULL);
            
            if (!uri) {
                g_warning ("creation of SoupURI from '%s' failed", host);
                
            } else {

                soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
                soup_uri_set_host (uri, host);
                g_free (host);
                soup_uri_set_port (uri, seahorse_gconf_get_integer (GCONF_PROXY_PORT));
                
                if (seahorse_gconf_get_boolean (GCONF_USE_AUTH)) {
                    char *user, *pass;

                    user = seahorse_gconf_get_string (GCONF_AUTH_USER);
                    soup_uri_set_user (uri, user);
                    g_free (user);
                    pass = seahorse_gconf_get_string (GCONF_AUTH_PASS);
                    soup_uri_set_password (uri, pass);
                    g_free (pass);
                }
                
                hop->session = soup_session_async_new_with_options (SOUP_SESSION_PROXY_URI, uri, NULL);
                soup_uri_free (uri);
            }
        }
    }
    
    /* Without a proxy */
    if (!hop->session)
        hop->session = soup_session_async_new ();

#if DEBUG_HKP_ENABLE
    logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
    soup_logger_attach (logger, hop->session);
    g_object_unref (logger);
#endif
}
コード例 #10
0
bool ResourceHandle::startHttp(String urlString)
{
    if (!session) {
        session = soup_session_async_new();

        soup_session_add_feature(session, SOUP_SESSION_FEATURE(getCookieJar()));

        const char* soup_debug = g_getenv("WEBKIT_SOUP_LOGGING");
        if (soup_debug) {
            int soup_debug_level = atoi(soup_debug);

            SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(soup_debug_level), -1);
            soup_logger_attach(logger, session);
            g_object_unref(logger);
        }
    }

    SoupMessage* msg;
    msg = soup_message_new(request().httpMethod().utf8().data(), urlString.utf8().data());
    g_signal_connect(msg, "restarted", G_CALLBACK(restartedCallback), this);

    g_signal_connect(msg, "got-headers", G_CALLBACK(gotHeadersCallback), this);
    g_signal_connect(msg, "got-chunk", G_CALLBACK(gotChunkCallback), this);

    HTTPHeaderMap customHeaders = d->m_request.httpHeaderFields();
    if (!customHeaders.isEmpty()) {
        HTTPHeaderMap::const_iterator end = customHeaders.end();
        for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it)
            soup_message_headers_append(msg->request_headers, it->first.utf8().data(), it->second.utf8().data());
    }

    FormData* httpBody = d->m_request.httpBody();
    if (httpBody && !httpBody->isEmpty()) {
        // Making a copy of the request body isn't the most efficient way to
        // serialize it, but by far the most simple. Dealing with individual
        // FormData elements and shared buffers should be more memory
        // efficient.
        //
        // This possibly isn't handling file uploads/attachments, for which
        // shared buffers or streaming should definitely be used.
        Vector<char> body;
        httpBody->flatten(body);
        soup_message_set_request(msg, d->m_request.httpContentType().utf8().data(),
                                 SOUP_MEMORY_COPY, body.data(), body.size());
    }

    d->m_msg = static_cast<SoupMessage*>(g_object_ref(msg));
    soup_session_queue_message(session, d->m_msg, finishedCallback, this);

    return true;
}
コード例 #11
0
ファイル: net.c プロジェクト: LMephisto/liferea
void
network_init (void)
{
	gchar		*useragent;
	SoupCookieJar	*cookies;
	gchar		*filename;
	SoupLogger	*logger;
	SoupURI		*proxy;

	/* Set an appropriate user agent */
	if (g_getenv ("LANG")) {
		/* e.g. "Liferea/1.6.0 (Linux; de_DE; http://liferea.sf.net/)" */
		useragent = g_strdup_printf ("Liferea/%s (%s; %s; %s)", VERSION, OSNAME, g_getenv ("LANG"), HOMEPAGE);
	} else {
		/* e.g. "Liferea/1.6.0 (Linux; http://liferea.sf.net/)" */
		useragent = g_strdup_printf ("Liferea/%s (%s; %s)", VERSION, OSNAME, HOMEPAGE);
	}

	/* Cookies */
	filename = common_create_cache_filename ("", "cookies", "txt");
	cookies = soup_cookie_jar_text_new (filename, FALSE);
	g_free (filename);

	/* Initialize libsoup */
	proxy = network_get_proxy_uri ();
	session = soup_session_async_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
						       SOUP_SESSION_TIMEOUT, 120,
						       SOUP_SESSION_IDLE_TIMEOUT, 30,
						       SOUP_SESSION_PROXY_URI, proxy,
						       SOUP_SESSION_ADD_FEATURE, cookies,
						       NULL);
	if (proxy)
		soup_uri_free (proxy);
		
	g_signal_connect (session, "authenticate", G_CALLBACK (network_authenticate), NULL);

	/* Soup debugging */
	if (debug_level & DEBUG_NET) {
		logger = soup_logger_new (SOUP_LOGGER_LOG_HEADERS, -1);
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
	}

	g_free (useragent);
}
コード例 #12
0
static void ensureSessionIsInitialized(SoupSession* session)
{
    if (g_object_get_data(G_OBJECT(session), "webkit-init"))
        return;

    SoupCookieJar* jar = reinterpret_cast<SoupCookieJar*>(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR));
    if (!jar)
        soup_session_add_feature(session, SOUP_SESSION_FEATURE(defaultCookieJar()));
    else
        setDefaultCookieJar(jar);

    if (!soup_session_get_feature(session, SOUP_TYPE_LOGGER) && LogNetwork.state == WTFLogChannelOn) {
        SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(SOUP_LOGGER_LOG_BODY), -1);
        soup_logger_attach(logger, session);
        g_object_unref(logger);
    }

    g_object_set_data(G_OBJECT(session), "webkit-init", reinterpret_cast<void*>(0xdeadbeef));
}
コード例 #13
0
ファイル: web-service.c プロジェクト: KapTmaN/gthumb
void
_web_service_send_message (WebService          *self,
			   SoupMessage         *msg,
			   GCancellable        *cancellable,
			   GAsyncReadyCallback  callback,
			   gpointer             user_data,
			   gpointer             source_tag,
			   SoupSessionCallback  soup_session_cb,
			   gpointer             soup_session_cb_data)
{
	if (self->priv->session == NULL) {
		self->priv->session = soup_session_new ();

#ifdef DEBUG_WEB_CONNECTION
		{
			SoupLogger *logger;

			logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
			soup_session_add_feature (self->priv->session, SOUP_SESSION_FEATURE (logger));

			g_object_unref (logger);
		}
#endif
	}

	_g_object_unref (self->priv->cancellable);
	self->priv->cancellable = _g_object_ref (cancellable);

	_g_object_unref (self->priv->result);
	self->priv->result = g_simple_async_result_new (G_OBJECT (self),
							callback,
							user_data,
							source_tag);

	self->priv->msg = msg;
	g_object_add_weak_pointer (G_OBJECT (msg), (gpointer *) &self->priv->msg);

	soup_session_queue_message (self->priv->session,
				    msg,
				    soup_session_cb,
				    soup_session_cb_data);
}
コード例 #14
0
ファイル: grl-net-wc.c プロジェクト: kyoushuu/grilo
/**
 * grl_net_wc_set_log_level:
 * @self: a #GrlNetWc instance
 * @log_level: the libsoup log level to set [0,3]
 *
 * Setting the log level the logger feature is added into
 * the libsoup session.
 */
void
grl_net_wc_set_log_level (GrlNetWc *self,
                          guint log_level)
{
  SoupLogger *logger;

  g_return_if_fail (log_level <= 3);
  g_return_if_fail (GRL_IS_NET_WC (self));

  if (self->priv->log_level == log_level)
    return;

  soup_session_remove_feature_by_type (self->priv->session, SOUP_TYPE_LOGGER);

  logger = soup_logger_new ((SoupLoggerLogLevel) log_level, -1);
  soup_session_add_feature (self->priv->session, SOUP_SESSION_FEATURE (logger));
  g_object_unref (logger);

  self->priv->log_level = (SoupLoggerLogLevel) log_level;
}
コード例 #15
0
static void
e_cal_backend_http_constructed (GObject *object)
{
	ECalBackendHttp *backend;
	SoupSession *soup_session;

	/* Chain up to parent's constructed() method. */
	G_OBJECT_CLASS (e_cal_backend_http_parent_class)->constructed (object);

	soup_session = soup_session_sync_new ();
	g_object_set (
		soup_session,
		SOUP_SESSION_TIMEOUT, 90,
		SOUP_SESSION_SSL_STRICT, TRUE,
		SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
		SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
		NULL);

	backend = E_CAL_BACKEND_HTTP (object);
	backend->priv->soup_session = soup_session;

	e_binding_bind_property (
		backend, "proxy-resolver",
		backend->priv->soup_session, "proxy-resolver",
		G_BINDING_SYNC_CREATE);

	g_signal_connect (
		backend->priv->soup_session, "authenticate",
		G_CALLBACK (soup_authenticate), backend);

	if (g_getenv ("WEBCAL_DEBUG") != NULL) {
		SoupLogger *logger;

		logger = soup_logger_new (
			SOUP_LOGGER_LOG_BODY, 1024 * 1024);
		soup_session_add_feature (
			backend->priv->soup_session,
			SOUP_SESSION_FEATURE (logger));
		g_object_unref (logger);
	}
}
コード例 #16
0
ファイル: test-utils.c プロジェクト: gcorvala/gsoc-2009
SoupSession *
soup_test_session_new (GType type, ...)
{
	va_list args;
	const char *propname;
	SoupSession *session;

	va_start (args, type);
	propname = va_arg (args, const char *);
	session = (SoupSession *)g_object_new_valist (type, propname, args);
	va_end (args);

	if (http_debug_level && !logger) {
		SoupLoggerLogLevel level = MIN ((SoupLoggerLogLevel)http_debug_level, SOUP_LOGGER_LOG_BODY);

		logger = soup_logger_new (level, -1);
	}

	if (logger)
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));

	return session;
}
コード例 #17
0
static void
webdav_debug_setup (SoupSession *session)
{
	const gchar *debug_str;
	SoupLogger *logger;
	SoupLoggerLogLevel level;

	g_return_if_fail (session != NULL);

	debug_str = g_getenv ("WEBDAV_DEBUG");
	if (!debug_str || !*debug_str)
		return;

	if (g_ascii_strcasecmp (debug_str, "all") == 0)
		level = SOUP_LOGGER_LOG_BODY;
	else if (g_ascii_strcasecmp (debug_str, "headers") == 0)
		level = SOUP_LOGGER_LOG_HEADERS;
	else
		level = SOUP_LOGGER_LOG_MINIMAL;

	logger = soup_logger_new (level, 100 * 1024 * 1024);
	soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
	g_object_unref (logger);
}
コード例 #18
0
ファイル: login.c プロジェクト: tripcodeuser/piiptyyt
bool oauth_login(
	GtkBuilder *builder,
	char **username_p,
	char **auth_token_p,
	char **auth_secret_p,
	uint64_t *userid_p,
	GError **err_p)
{
#if !USE_LOCAL_CGI
	const char *token_uri = "https://api.twitter.com/oauth/request_token";
	const char *access_uri = "https://api.twitter.com/oauth/access_token";
#else
	const char *token_uri = "https://localhost/cgi-bin/oauth.cgi/request_token";
	const char *access_uri = "https://localhost/cgi-bin/oauth.cgi/access_token";
#endif

	SoupSession *ss = soup_session_async_new();
#if 0
	SoupLogger *logger = soup_logger_new(1, -1);
	soup_session_add_feature(ss, SOUP_SESSION_FEATURE(logger));
	g_object_unref(logger);
#endif

	SoupMessage *msg = make_token_request_msg(token_uri, CONSUMER_KEY,
		CONSUMER_SECRET);
	if(msg == NULL) {
		/* FIXME */
		abort();
	}
	soup_session_send_message(ss, msg);

	bool ok;
	if(msg->status_code != SOUP_STATUS_OK) {
		fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
			msg->status_code, soup_status_get_phrase(msg->status_code));
		ok = false;
		goto end;
	}

	/* interpret the response. */
	char **rt_output = oa_parse_response(msg->response_body->data,
		"oauth_token", "oauth_token_secret", NULL);
	if(rt_output == NULL) {
		g_set_error(err_p, 0, EINVAL, "can't parse response data");
		ok = false;
		goto end;
	}

	/* do out-of-band OAuth */
	const char *req_token = rt_output[0], *req_secret = rt_output[1];
#if !USE_LOCAL_CGI
	GError *err = NULL;
	if(!launch_authorization_browser(req_token, &err)) {
		fprintf(stderr, "warning: browser launching failed: %s\n",
			err->message);
		g_error_free(err);
	}
#endif

	char *pin = query_pin(builder);
	printf("PIN is: `%s'\n", pin);

	/* get an access token */
	g_object_unref(msg);
	msg = make_access_token_request_msg(access_uri, req_token, req_secret,
		pin, CONSUMER_KEY, CONSUMER_SECRET);
	g_free(pin);
	if(msg == NULL) {
		fprintf(stderr, "can't sign access request message!\n");
		abort();
	}
	soup_session_send_message(ss, msg);

	if(msg->status_code != SOUP_STATUS_OK) {
		fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
			msg->status_code, soup_status_get_phrase(msg->status_code));
		/* FIXME: handle */
		abort();
	}
	char **at_output = oa_parse_response(msg->response_body->data,
		"oauth_token", "oauth_token_secret", "user_id", "screen_name", NULL);
	if(at_output == NULL) {
		/* FIXME: response data parsing fail */
		abort();
	}
	/* the payoff */
	*auth_token_p = g_strdup(at_output[0]);
	*auth_secret_p = g_strdup(at_output[1]);
	*userid_p = strtoull(at_output[2], NULL, 10);
	*username_p = g_strdup(at_output[3]);

	printf("login successful! username `%s', userid %llu\n", *username_p,
		(unsigned long long)*userid_p);

	g_strfreev(at_output);
	g_strfreev(rt_output);

	ok = true;

end:
	g_object_unref(msg);
	g_object_unref(ss);

	return ok;
}
コード例 #19
0
ファイル: uzbl.c プロジェクト: dusanx/uzbl
static void
settings_init () {
    GKeyFile* config;
    gboolean res  = FALSE;
    char *saveptr;
    gchar** keys = NULL;

    if (!config_file) {
        const char* XDG_CONFIG_HOME = getenv ("XDG_CONFIG_HOME");
        if (! XDG_CONFIG_HOME || ! strcmp (XDG_CONFIG_HOME, "")) {
          XDG_CONFIG_HOME = (char*)XDG_CONFIG_HOME_default;
        }
        printf("XDG_CONFIG_HOME: %s\n", XDG_CONFIG_HOME);
    
        strcpy (config_file_path, XDG_CONFIG_HOME);
        strcat (config_file_path, "/uzbl/config");
        if (file_exists (config_file_path)) {
          printf ("Config file %s found.\n", config_file_path);
          config_file = &config_file_path[0];
        } else {
            // Now we check $XDG_CONFIG_DIRS
            char *XDG_CONFIG_DIRS = getenv ("XDG_CONFIG_DIRS");
            if (! XDG_CONFIG_DIRS || ! strcmp (XDG_CONFIG_DIRS, ""))
                XDG_CONFIG_DIRS = XDG_CONFIG_DIRS_default;

            printf("XDG_CONFIG_DIRS: %s\n", XDG_CONFIG_DIRS);

            char buffer[512];
            strcpy (buffer, XDG_CONFIG_DIRS);
            const gchar* dir = (char *) strtok_r (buffer, ":", &saveptr);
            while (dir && ! file_exists (config_file_path)) {
                strcpy (config_file_path, dir);
                strcat (config_file_path, "/uzbl/config_file_pathig");
                if (file_exists (config_file_path)) {
                    printf ("Config file %s found.\n", config_file_path);
                    config_file = &config_file_path[0];
                }
                dir = (char * ) strtok_r (NULL, ":", &saveptr);
            }
        }
    }

    if (config_file) {
        config = g_key_file_new ();
        res = g_key_file_load_from_file (config, config_file, G_KEY_FILE_NONE, NULL);
          if (res) {
            printf ("Config %s loaded\n", config_file);
          } else {
            fprintf (stderr, "Config %s loading failed\n", config_file);
        }
    } else {
        printf ("No configuration.\n");
    }

    if (res) {
        history_handler    = g_key_file_get_value   (config, "behavior", "history_handler",    NULL);
        download_handler   = g_key_file_get_value   (config, "behavior", "download_handler",   NULL);
        always_insert_mode = g_key_file_get_boolean (config, "behavior", "always_insert_mode", NULL);
        show_status        = g_key_file_get_boolean (config, "behavior", "show_status",        NULL);
        modkey             = g_key_file_get_value   (config, "behavior", "modkey",             NULL);
        status_top         = g_key_file_get_boolean (config, "behavior", "status_top",         NULL);
        if (! fifo_dir)
            fifo_dir        = g_key_file_get_value  (config, "behavior", "fifo_dir",           NULL);
        if (! socket_dir)
            socket_dir     = g_key_file_get_value   (config, "behavior", "socket_dir",         NULL);
        keys               = g_key_file_get_keys    (config, "bindings", NULL,                 NULL);
    }

    printf ("History handler: %s\n",    (history_handler    ? history_handler  : "disabled"));
    printf ("Download manager: %s\n",   (download_handler   ? download_handler : "disabled"));
    printf ("Fifo directory: %s\n",     (fifo_dir           ? fifo_dir         : "disabled"));
    printf ("Socket directory: %s\n",   (socket_dir         ? socket_dir       : "disabled"));
    printf ("Always insert mode: %s\n", (always_insert_mode ? "TRUE"           : "FALSE"));
    printf ("Show status: %s\n",        (show_status        ? "TRUE"           : "FALSE"));
    printf ("Status top: %s\n",         (status_top         ? "TRUE"           : "FALSE"));
    printf ("Modkey: %s\n",             (modkey             ? modkey           : "disabled"));

    if (! modkey)
        modkey = "";

    //POSSIBLE MODKEY VALUES (COMBINATIONS CAN BE USED)
    gchar* modkeyup = g_utf8_strup (modkey, -1);
    if (g_strrstr (modkeyup,"SHIFT") != NULL)    modmask |= GDK_SHIFT_MASK;    //the Shift key.
    if (g_strrstr (modkeyup,"LOCK") != NULL)     modmask |= GDK_LOCK_MASK;     //a Lock key (depending on the modifier mapping of the X server this may either be CapsLock or ShiftLock).
    if (g_strrstr (modkeyup,"CONTROL") != NULL)  modmask |= GDK_CONTROL_MASK;  //the Control key.
    if (g_strrstr (modkeyup,"MOD1") != NULL)     modmask |= GDK_MOD1_MASK;     //the fourth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier, but normally it is the Alt key).
    if (g_strrstr (modkeyup,"MOD2") != NULL)     modmask |= GDK_MOD2_MASK;     //the fifth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
    if (g_strrstr (modkeyup,"MOD3") != NULL)     modmask |= GDK_MOD3_MASK;     //the sixth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
    if (g_strrstr (modkeyup,"MOD4") != NULL)     modmask |= GDK_MOD4_MASK;     //the seventh modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
    if (g_strrstr (modkeyup,"MOD5") != NULL)     modmask |= GDK_MOD5_MASK;     //the eighth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
    if (g_strrstr (modkeyup,"BUTTON1") != NULL)  modmask |= GDK_BUTTON1_MASK;  //the first mouse button.
    if (g_strrstr (modkeyup,"BUTTON2") != NULL)  modmask |= GDK_BUTTON2_MASK;  //the second mouse button.
    if (g_strrstr (modkeyup,"BUTTON3") != NULL)  modmask |= GDK_BUTTON3_MASK;  //the third mouse button.
    if (g_strrstr (modkeyup,"BUTTON4") != NULL)  modmask |= GDK_BUTTON4_MASK;  //the fourth mouse button.
    if (g_strrstr (modkeyup,"BUTTON5") != NULL)  modmask |= GDK_BUTTON5_MASK;  //the fifth mouse button.
    if (g_strrstr (modkeyup,"SUPER") != NULL)    modmask |= GDK_SUPER_MASK;    //the Super modifier. Since 2.10
    if (g_strrstr (modkeyup,"HYPER") != NULL)    modmask |= GDK_HYPER_MASK;    //the Hyper modifier. Since 2.10
    if (g_strrstr (modkeyup,"META") != NULL)     modmask |= GDK_META_MASK;     //the Meta modifier. Since 2.10  */
    free (modkeyup);

    if (keys) {
        int i;
        for (i = 0; keys[i]; i++) {
            gchar *value = g_key_file_get_string (config, "bindings", keys[i], NULL);
            
            add_binding(g_strstrip(keys[i]), value);
            g_free(value);
        }

        g_strfreev(keys);
    }

    /* networking options */
    if (res) {
        proxy_url      = g_key_file_get_value   (config, "network", "proxy_server",       NULL);
        http_debug     = g_key_file_get_integer (config, "network", "http_debug",         NULL);
        useragent      = g_key_file_get_value   (config, "network", "user-agent",         NULL);
        max_conns      = g_key_file_get_integer (config, "network", "max_conns",          NULL);
        max_conns_host = g_key_file_get_integer (config, "network", "max_conns_per_host", NULL);
    }

    if(proxy_url){
        g_object_set(G_OBJECT(soup_session), SOUP_SESSION_PROXY_URI, soup_uri_new(proxy_url), NULL);
    }
	
    if(!(http_debug <= 3)){
        http_debug = 0;
        fprintf(stderr, "Wrong http_debug level, ignoring.\n");
    } else if (http_debug > 0) {
        soup_logger = soup_logger_new(http_debug, -1);
        soup_session_add_feature(soup_session, SOUP_SESSION_FEATURE(soup_logger));
    }
	
    if(useragent){
        char* newagent  = malloc(1024);

        strcpy(newagent, str_replace("%webkit-major%", itos(WEBKIT_MAJOR_VERSION), useragent));
        strcpy(newagent, str_replace("%webkit-minor%", itos(WEBKIT_MINOR_VERSION), newagent));
        strcpy(newagent, str_replace("%webkit-micro%", itos(WEBKIT_MICRO_VERSION), newagent));

        if (uname (&unameinfo) == -1) {
            printf("Error getting uname info. Not replacing system-related user agent variables.\n");
        } else {
            strcpy(newagent, str_replace("%sysname%",     unameinfo.sysname, newagent));
            strcpy(newagent, str_replace("%nodename%",    unameinfo.nodename, newagent));
            strcpy(newagent, str_replace("%kernrel%",     unameinfo.release, newagent));
            strcpy(newagent, str_replace("%kernver%",     unameinfo.version, newagent));
            strcpy(newagent, str_replace("%arch-system%", unameinfo.machine, newagent));

            #ifdef _GNU_SOURCE
                strcpy(newagent, str_replace("%domainname%", unameinfo.domainname, newagent));
            #endif
        }

        strcpy(newagent, str_replace("%arch-uzbl%",    ARCH,                       newagent));
        strcpy(newagent, str_replace("%commit%",       COMMIT,                     newagent));

        useragent = malloc(1024);
        strcpy(useragent, newagent);
        g_object_set(G_OBJECT(soup_session), SOUP_SESSION_USER_AGENT, useragent, NULL);
    }

    if(max_conns >= 1){
        g_object_set(G_OBJECT(soup_session), SOUP_SESSION_MAX_CONNS, max_conns, NULL);
    }

    if(max_conns_host >= 1){
        g_object_set(G_OBJECT(soup_session), SOUP_SESSION_MAX_CONNS_PER_HOST, max_conns_host, NULL);
    }

    printf("Proxy configured: %s\n", proxy_url ? proxy_url : "none");
    printf("HTTP logging level: %d\n", http_debug);
    printf("User-agent: %s\n", useragent? useragent : "default");
    printf("Maximum connections: %d\n", max_conns ? max_conns : 0);
    printf("Maximum connections per host: %d\n", max_conns_host ? max_conns_host: 0);

    //Cookies
    cookie_text_file = g_key_file_get_value (config, "behavior", "cookie_text_file",   NULL);
    if (cookie_text_file) {
        printf("Cookie text file location: %s\n", cookie_text_file);        
        soup_cookie = soup_cookie_jar_text_new (cookie_text_file, FALSE);
        soup_session_add_feature(soup_session, SOUP_SESSION_FEATURE(soup_cookie));
    }
}
コード例 #20
0
ファイル: get.c プロジェクト: Distrotech/libsoup
int
main (int argc, char **argv)
{
	GOptionContext *opts;
	const char *url;
	SoupURI *proxy_uri, *parsed;
	GError *error = NULL;
	SoupLogger *logger = NULL;

	opts = g_option_context_new (NULL);
	g_option_context_add_main_entries (opts, entries, NULL);
	if (!g_option_context_parse (opts, &argc, &argv, &error)) {
		g_printerr ("Could not parse arguments: %s\n",
			    error->message);
		g_printerr ("%s",
			    g_option_context_get_help (opts, TRUE, NULL));
		exit (1);
	}

	if (argc != 2) {
		g_printerr ("%s",
			    g_option_context_get_help (opts, TRUE, NULL));
		exit (1);
	}
	g_option_context_free (opts);

	url = argv[1];
	parsed = soup_uri_new (url);
	if (!parsed) {
		g_printerr ("Could not parse '%s' as a URL\n", url);
		exit (1);
	}
	soup_uri_free (parsed);

	session = g_object_new (SOUP_TYPE_SESSION,
				SOUP_SESSION_SSL_CA_FILE, ca_file,
				SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
				SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
				SOUP_SESSION_USER_AGENT, "get ",
				SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
				NULL);
	if (ntlm)
		soup_session_add_feature_by_type (session, SOUP_TYPE_AUTH_NTLM);

	if (debug) {
		logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
		g_object_unref (logger);
	}

	if (proxy) {
		proxy_uri = soup_uri_new (proxy);
		if (!proxy_uri) {
			g_printerr ("Could not parse '%s' as URI\n",
				    proxy);
			exit (1);
		}

		g_object_set (G_OBJECT (session),
			      SOUP_SESSION_PROXY_URI, proxy_uri,
			      NULL);
		soup_uri_free (proxy_uri);
	}

	if (!synchronous)
		loop = g_main_loop_new (NULL, TRUE);

	get_url (url);

	if (!synchronous)
		g_main_loop_unref (loop);

	return 0;
}
コード例 #21
0
ファイル: gvfsbackendhttp.c プロジェクト: GNOME/gvfs
static void
g_vfs_backend_http_class_init (GVfsBackendHttpClass *klass)
{
  const char         *debug;
  SoupSessionFeature *cookie_jar;

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GVfsBackendClass *backend_class;

  gobject_class->finalize  = g_vfs_backend_http_finalize;

  backend_class = G_VFS_BACKEND_CLASS (klass);

  backend_class->try_mount              = try_mount;
  backend_class->try_open_for_read      = try_open_for_read;
  backend_class->try_read               = try_read;
  backend_class->try_seek_on_read       = try_seek_on_read;
  backend_class->try_close_read         = try_close_read;
  backend_class->try_query_info         = try_query_info;
  backend_class->try_query_info_on_read = try_query_info_on_read;
  backend_class->try_query_fs_info      = try_query_fs_info;

  /* Initialize the SoupSession, common to all backend instances */
  the_session = soup_session_new_with_options ("user-agent",
                                               "gvfs/" VERSION,
                                               NULL);

  g_object_set (the_session, "ssl-strict", FALSE, NULL);

  /* Cookie handling - stored temporarlly in memory, mostly useful for
   * authentication in WebDAV. */
  cookie_jar = g_object_new (SOUP_TYPE_COOKIE_JAR, NULL);
  soup_session_add_feature (the_session, cookie_jar);
  g_object_unref (cookie_jar);

  /* Send Accept-Language header (see bug 166795) */
  g_object_set (the_session, "accept-language-auto", TRUE, NULL);

  /* Prevent connection timeouts during long operations like COPY. */
  g_object_set (the_session, "timeout", 0, NULL);

  /* Logging */
  debug = g_getenv ("GVFS_HTTP_DEBUG");
  if (debug)
    {
      SoupLogger         *logger;
      SoupLoggerLogLevel  level;

      if (g_ascii_strcasecmp (debug, "all") == 0 ||
          g_ascii_strcasecmp (debug, "body") == 0)
        level = SOUP_LOGGER_LOG_BODY;
      else if (g_ascii_strcasecmp (debug, "header") == 0)
        level = SOUP_LOGGER_LOG_HEADERS;
      else
        level = SOUP_LOGGER_LOG_MINIMAL;

      logger = soup_logger_new (level, DEBUG_MAX_BODY_SIZE);
      soup_session_add_feature (the_session, SOUP_SESSION_FEATURE (logger));
      g_object_unref (logger);
    }
}
コード例 #22
0
ファイル: gvfsbackendhttp.c プロジェクト: DarkProfit/gvfs
static void
g_vfs_backend_http_init (GVfsBackendHttp *backend)
{
  const char         *debug;
  SoupSessionFeature *proxy_resolver;
  SoupSessionFeature *cookie_jar;
  SoupSessionFeature *content_decoder;

  g_vfs_backend_set_user_visible (G_VFS_BACKEND (backend), FALSE);  

  backend->session = soup_session_sync_new_with_options ("user-agent",
                                                         "gvfs/" VERSION,
                                                         NULL);

  backend->session_async = soup_session_async_new_with_options ("user-agent",
                                                                "gvfs/" VERSION,
                                                                NULL);
  /* SoupRequester seems to depend on use-thread-context */
  g_object_set (G_OBJECT (backend->session_async), "use-thread-context", TRUE, NULL);

  /* Proxy handling */
  proxy_resolver = g_object_new (SOUP_TYPE_PROXY_RESOLVER_GNOME, NULL);
  soup_session_add_feature (backend->session, proxy_resolver);
  soup_session_add_feature (backend->session_async, proxy_resolver);
  g_object_unref (proxy_resolver);

  /* Cookie handling - stored temporarlly in memory, mostly useful for
   * authentication in WebDAV. */
  cookie_jar = g_object_new (SOUP_TYPE_COOKIE_JAR, NULL);
  soup_session_add_feature (backend->session, cookie_jar);
  soup_session_add_feature (backend->session_async, cookie_jar);
  g_object_unref (cookie_jar);

  /* Send Accept-Language header (see bug 166795) */
  g_object_set (backend->session, "accept-language-auto", TRUE, NULL);
  g_object_set (backend->session_async, "accept-language-auto", TRUE, NULL);

  /* Handle decompression automatically */
  content_decoder = g_object_new (SOUP_TYPE_CONTENT_DECODER, NULL);
  soup_session_add_feature (backend->session, content_decoder);
  soup_session_add_feature (backend->session_async, content_decoder);
  g_object_unref (content_decoder);

  /* Request API */
  soup_session_add_feature_by_type (backend->session, SOUP_TYPE_REQUESTER);
  soup_session_add_feature_by_type (backend->session_async, SOUP_TYPE_REQUESTER);

  /* Logging */
  debug = g_getenv ("GVFS_HTTP_DEBUG");
  if (debug)
    {
      SoupLogger         *logger;
      SoupLoggerLogLevel  level;

      if (g_ascii_strcasecmp (debug, "all") ||
          g_ascii_strcasecmp (debug, "body"))
        level = SOUP_LOGGER_LOG_BODY;
      else if (g_ascii_strcasecmp (debug, "header"))
        level = SOUP_LOGGER_LOG_HEADERS;
      else
        level = SOUP_LOGGER_LOG_MINIMAL;

      logger = soup_logger_new (level, DEBUG_MAX_BODY_SIZE);
      soup_session_add_feature (backend->session, SOUP_SESSION_FEATURE (logger));
      soup_session_add_feature (backend->session_async, SOUP_SESSION_FEATURE (logger));
      g_object_unref (logger);
    }

}