自学教程：C++ soup_message_new_from_uri函数代码示例

static SoupMessage *soup_form_request_for_data (const char *method, const char *uri_string,			    char *form_data){	SoupMessage *msg;	SoupURI *uri;	uri = soup_uri_new (uri_string);	if (!uri)		return NULL;	if (!strcmp (method, "GET")) {		g_free (uri->query);		uri->query = form_data;		msg = soup_message_new_from_uri (method, uri);	} else if (!strcmp (method, "POST") || !strcmp (method, "PUT")) {		msg = soup_message_new_from_uri (method, uri);		soup_message_set_request (			msg, SOUP_FORM_MIME_TYPE_URLENCODED,			SOUP_MEMORY_TAKE,			form_data, strlen (form_data));	} else {		g_warning ("invalid method passed to soup_form_request_new");		g_free (form_data);		/* Don't crash */		msg = soup_message_new_from_uri (method, uri);	}	soup_uri_free (uri);	return msg;}

static voiddo_content_length_framing_test (void){	SoupSession *session;	SoupMessage *msg;	SoupURI *request_uri;	goffset declared_length;	debug_printf (1, "/nInvalid Content-Length framing tests/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	debug_printf (1, "  Content-Length larger than message body length/n");	request_uri = soup_uri_new_with_base (base_uri, "/content-length/long");	msg = soup_message_new_from_uri ("GET", request_uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "    Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	} else {		declared_length = soup_message_headers_get_content_length (msg->response_headers);		debug_printf (2, "    Content-Length: %lu, body: %s/n",			      (gulong)declared_length, msg->response_body->data);		if (msg->response_body->length >= declared_length) {			debug_printf (1, "    Body length %lu >= declared length %lu/n",				      (gulong)msg->response_body->length,				      (gulong)declared_length);			errors++;		}	}	soup_uri_free (request_uri);	g_object_unref (msg);	debug_printf (1, "  Server claims 'Connection: close' but doesn't/n");	request_uri = soup_uri_new_with_base (base_uri, "/content-length/noclose");	msg = soup_message_new_from_uri ("GET", request_uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "    Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	} else {		declared_length = soup_message_headers_get_content_length (msg->response_headers);		debug_printf (2, "    Content-Length: %lu, body: %s/n",			      (gulong)declared_length, msg->response_body->data);		if (msg->response_body->length != declared_length) {			debug_printf (1, "    Body length %lu != declared length %lu/n",				      (gulong)msg->response_body->length,				      (gulong)declared_length);			errors++;		}	}	soup_uri_free (request_uri);	g_object_unref (msg);	soup_test_session_abort_unref (session);}

static voiddo_cookies_accept_policy_test (void){	SoupSession *session;	SoupMessage *msg;	SoupURI *uri;	SoupCookieJar *jar;	GSList *l, *p;	int i;	debug_printf (1, "SoupCookieJarAcceptPolicy test/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);	jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));	for (i = 0; i < G_N_ELEMENTS (validResults); i++) {		soup_cookie_jar_set_accept_policy (jar, validResults[i].policy);		uri = soup_uri_new_with_base (first_party_uri, "/index.html");		msg = soup_message_new_from_uri ("GET", uri);		soup_message_set_first_party (msg, first_party_uri);		soup_session_send_message (session, msg);		soup_uri_free (uri);		g_object_unref (msg);		/* We can't use two servers due to limitations in		 * test_server, so let's swap first and third party here		 * to simulate a cookie coming from a third party.		 */		uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg");		msg = soup_message_new_from_uri ("GET", uri);		soup_message_set_first_party (msg, third_party_uri);		soup_session_send_message (session, msg);		soup_uri_free (uri);		g_object_unref (msg);		l = soup_cookie_jar_all_cookies (jar);		if (g_slist_length (l) < validResults[i].n_cookies) {			debug_printf (1, " accepted less cookies than it should have/n");			errors++;		} else if (g_slist_length (l) > validResults[i].n_cookies) {			debug_printf (1, " accepted more cookies than it should have/n");			errors++;		}		for (p = l; p; p = p->next) {			soup_cookie_jar_delete_cookie (jar, p->data);			soup_cookie_free (p->data);		}		g_slist_free (l);	}	soup_test_session_abort_unref (session);}

static voiddo_timeout_test_for_session (SoupSession *session){	SoupMessage *msg;	SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL };	SoupURI *timeout_uri;	int i;	g_signal_connect (session, "request-started",			  G_CALLBACK (request_started_socket_collector),			  &sockets);	debug_printf (1, "    First message/n");	timeout_uri = soup_uri_new_with_base (base_uri, "/timeout-persistent");	msg = soup_message_new_from_uri ("GET", timeout_uri);	soup_uri_free (timeout_uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "      Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	if (sockets[1]) {		debug_printf (1, "      Message was retried??/n");		errors++;		sockets[1] = sockets[2] = sockets[3] = NULL;	}	g_object_unref (msg);	debug_printf (1, "    Second message/n");	msg = soup_message_new_from_uri ("GET", base_uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "      Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	if (sockets[1] != sockets[0]) {		debug_printf (1, "      Message was not retried on existing connection/n");		errors++;	} else if (!sockets[2]) {		debug_printf (1, "      Message was not retried after disconnect/n");		errors++;	} else if (sockets[2] == sockets[1]) {		debug_printf (1, "      Message was retried on closed connection??/n");		errors++;	} else if (sockets[3]) {		debug_printf (1, "      Message was retried again??/n");		errors++;	}	g_object_unref (msg);	for (i = 0; sockets[i]; i++)		g_object_unref (sockets[i]);}

static voiddo_ipv6_test (void){	SoupServer *ipv6_server;	SoupURI *ipv6_uri;	SoupAddress *ipv6_addr;	SoupSession *session;	SoupMessage *msg;	debug_printf (1, "/nIPv6 server test/n");	ipv6_addr = soup_address_new ("::1", SOUP_ADDRESS_ANY_PORT);	soup_address_resolve_sync (ipv6_addr, NULL);	ipv6_server = soup_server_new (SOUP_SERVER_INTERFACE, ipv6_addr,				       NULL);	g_object_unref (ipv6_addr);	soup_server_add_handler (ipv6_server, NULL, ipv6_server_callback, NULL, NULL);	soup_server_run_async (ipv6_server);	ipv6_uri = soup_uri_new ("http://[::1]/");	soup_uri_set_port (ipv6_uri, soup_server_get_port (ipv6_server));	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	debug_printf (1, "  HTTP/1.1/n");	msg = soup_message_new_from_uri ("GET", ipv6_uri);	soup_session_send_message (session, msg);	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "    request failed: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);	debug_printf (1, "  HTTP/1.0/n");	msg = soup_message_new_from_uri ("GET", ipv6_uri);	soup_message_set_http_version (msg, SOUP_HTTP_1_0);	soup_session_send_message (session, msg);	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "    request failed: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);	soup_uri_free (ipv6_uri);	soup_test_session_abort_unref (session);	soup_test_server_quit_unref (ipv6_server);}

static GBytes *download_file (SoupURI *uri){  g_autoptr(GBytes) contents = NULL;  if (soup_uri_get_scheme (uri) == SOUP_URI_SCHEME_FILE)    {      g_autoptr(GFile) file = g_file_new_for_path (soup_uri_get_path (uri));      eos_updater_read_file_to_bytes (file, NULL, &contents, NULL);    }  else    {      g_autoptr(SoupSession) soup = soup_session_new ();      g_autoptr(SoupMessage) msg = soup_message_new_from_uri ("GET", uri);      guint status = soup_session_send_message (soup, msg);      if (SOUP_STATUS_IS_SUCCESSFUL (status))        g_object_get (msg,                      SOUP_MESSAGE_RESPONSE_BODY_DATA, &contents,                      NULL);    }  return g_steal_pointer (&contents);}

static voidimpl_start (RBPodcastSearch *bsearch, const char *text, int max_results){	SoupURI *uri;	SoupMessage *message;	char *limit;	RBPodcastSearchMiroGuide *search = RB_PODCAST_SEARCH_MIROGUIDE (bsearch);	search->session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,							       SOUP_TYPE_PROXY_RESOLVER_DEFAULT,							       NULL);	uri = soup_uri_new (MIROGUIDE_SEARCH_URI);	limit = g_strdup_printf ("%d", max_results);	soup_uri_set_query_from_fields (uri,					"filter", "audio",					"filter_value", "1",					"filter", "name",					"filter_value", text,					"sort", "popular",	/* hmm */					"limit", limit,					"datatype", "json",					NULL);	g_free (limit);	message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);	soup_uri_free (uri);	soup_session_queue_message (search->session, message, (SoupSessionCallback) search_response_cb, search);}

static voidforce_io_streams_init (void){	SoupServer *server;	SoupSession *session;	guint port;	SoupURI *base_uri;	SoupMessage *msg;	/* Poke libsoup enough to cause SoupBodyInputStream and	 * SoupBodyOutputStream to get defined, so we can find them	 * via g_type_from_name() later.	 */	server = soup_test_server_new (TRUE);	port = 	soup_server_get_port (server);	base_uri = soup_uri_new ("http://127.0.0.1");	soup_uri_set_port (base_uri, port);	session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);	msg = soup_message_new_from_uri ("POST", base_uri);	soup_session_send_message (session, msg);	g_object_unref (msg);	soup_test_session_abort_unref (session);	soup_uri_free (base_uri);	soup_test_server_quit_unref (server);}

static gbooleanrun_check (gpointer user_data){	NMConnectivity *self = NM_CONNECTIVITY (user_data);	NMConnectivityPrivate *priv;	SoupURI *soup_uri;	SoupMessage *msg;	g_return_val_if_fail (NM_IS_CONNECTIVITY (self), FALSE);	priv = NM_CONNECTIVITY_GET_PRIVATE (self);	/* check given url async */	soup_uri = soup_uri_new (priv->uri);	if (soup_uri && SOUP_URI_VALID_FOR_HTTP (soup_uri)) {		msg = soup_message_new_from_uri ("GET", soup_uri);		soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);		soup_session_queue_message (priv->soup_session,		                            msg,		                            nm_connectivity_check_cb,		                            self);		priv->running = TRUE;		g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_RUNNING);		nm_log_dbg (LOGD_CORE, "Connectivity check with uri '%s' started.", priv->uri);	} else		nm_log_err (LOGD_CORE, "Invalid uri '%s' for connectivity check.", priv->uri);	if (soup_uri)		soup_uri_free (soup_uri);	return TRUE;  /* keep firing */}

static voiddo_aliases_test_for_session (SoupSession *session,			     const char *redirect_protocol){	SoupMessage *msg;	SoupURI *uri;	const char *redirected_protocol;	uri = soup_uri_new_with_base (base_uri, "/alias-redirect");	msg = soup_message_new_from_uri ("GET", uri);	if (redirect_protocol)		soup_message_headers_append (msg->request_headers, "X-Redirect-Protocol", redirect_protocol);	soup_uri_free (uri);	soup_session_send_message (session, msg);	redirected_protocol = soup_message_headers_get_one (msg->response_headers, "X-Redirected-Protocol");	if (g_strcmp0 (redirect_protocol, redirected_protocol)) {		debug_printf (1, "    redirect went to %s, should have gone to %s!/n",			      redirected_protocol ? redirected_protocol : "(none)",			      redirect_protocol ? redirect_protocol : "(none)");		errors++;	} else if (redirect_protocol && !SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "    msg failed? (%d %s)/n",			      msg->status_code, msg->reason_phrase);		errors++;	} else if (!redirect_protocol && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "    msg succeeded? (%d %s)/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);}

static voiddo_idle_on_dispose_test (void){	SoupSession *session;	SoupMessage *msg;	GMainContext *async_context;	debug_printf (1, "/nTesting SoupSessionAsync dispose behavior/n");	async_context = g_main_context_new ();	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_ASYNC_CONTEXT, async_context,					 NULL);	msg = soup_message_new_from_uri ("GET", base_uri);	soup_session_send_message (session, msg);	g_object_unref (msg);	while (g_main_context_iteration (async_context, FALSE))		;	g_object_run_dispose (G_OBJECT (session));	if (g_main_context_iteration (async_context, FALSE)) {		debug_printf (1, "  idle was queued!/n");		errors++;	}	g_object_unref (session);	g_main_context_unref (async_context);}

static voiddo_dot_dot_test (void){	SoupSession *session;	SoupMessage *msg;	SoupURI *uri;	debug_printf (1, "/n'..' smuggling test/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	uri = soup_uri_new_with_base (base_uri, "/..%2ftest");	msg = soup_message_new_from_uri ("GET", uri);	soup_uri_free (uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_BAD_REQUEST) {		debug_printf (1, "      FAILED: %d %s (expected Bad Request)/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);	soup_test_session_abort_unref (session);}

static voiddo_test (SoupSession *session, SoupURI *base_uri, int n){    SoupURI *uri;    SoupMessage *msg;    TestRequest *req;    debug_printf (1, "%2d. %s %s/n", n + 1,                  tests[n].requests[0].method,                  tests[n].requests[0].path);    uri = soup_uri_new_with_base (base_uri, tests[n].requests[0].path);    msg = soup_message_new_from_uri (tests[n].requests[0].method, uri);    soup_uri_free (uri);    if (msg->method == SOUP_METHOD_POST) {        soup_message_set_request (msg, "text/plain",                                  SOUP_MEMORY_STATIC,                                  "post body",                                  strlen ("post body"));    }    req = &tests[n].requests[0];    g_signal_connect (msg, "got_headers",                      G_CALLBACK (got_headers), &req);    g_signal_connect (msg, "restarted",                      G_CALLBACK (restarted), &req);    soup_session_send_message (session, msg);    g_object_unref (msg);    debug_printf (2, "/n");}

static voiddo_non_persistent_test_for_session (SoupSession *session){	SoupMessage *msg;	SoupSocket *socket = NULL;	loop = g_main_loop_new (NULL, FALSE);	g_signal_connect (session, "request-started",			  G_CALLBACK (np_request_started),			  &socket);	g_signal_connect (session, "request-unqueued",			  G_CALLBACK (np_request_unqueued),			  &socket);	msg = soup_message_new_from_uri ("GET", base_uri);	soup_message_headers_append (msg->request_headers, "Connection", "close");	g_object_ref (msg);	soup_session_queue_message (session, msg, NULL, NULL);	g_main_loop_run (loop);	g_main_loop_unref (loop);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "      Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);	g_object_unref (socket);}

static voiddo_large_chunk_test (SoupSession *session, SoupURI *base_uri){	SoupMessage *msg;	char *buf_data;	int i;	LargeChunkData lcd;	debug_printf (1, "PUT w/ large chunk/n");	msg = soup_message_new_from_uri ("PUT", base_uri);	buf_data = g_malloc0 (LARGE_CHUNK_SIZE);	for (i = 0; i < LARGE_CHUNK_SIZE; i++)		buf_data[i] = i & 0xFF;	lcd.buf = soup_buffer_new (SOUP_MEMORY_TAKE, buf_data, LARGE_CHUNK_SIZE);	lcd.offset = 0;	soup_message_body_append_buffer (msg->request_body, lcd.buf);	soup_message_body_set_accumulate (msg->request_body, FALSE);	g_signal_connect (msg, "wrote_body_data",			  G_CALLBACK (large_wrote_body_data), &lcd);	soup_session_send_message (session, msg);	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "  message failed: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	soup_buffer_free (lcd.buf);	g_object_unref (msg);}

static voidimpl_start (RBPodcastSearch *bsearch, const char *text, int max_results){	SoupURI *uri;	SoupMessage *message;	char *limit;	RBPodcastSearchITunes *search = RB_PODCAST_SEARCH_ITUNES (bsearch);	search->session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,							       SOUP_TYPE_PROXY_RESOLVER_DEFAULT,							       NULL);	uri = soup_uri_new (ITUNES_SEARCH_URI);	limit = g_strdup_printf ("%d", max_results);	soup_uri_set_query_from_fields (uri,					"term", text,					"media", "podcast",					"entity", "podcast",					"limit", limit,					"version", "2",					"output", "json",					NULL);	g_free (limit);	message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);	soup_uri_free (uri);	soup_session_queue_message (search->session, message, (SoupSessionCallback) search_response_cb, search);}

static voiddo_proxy_fragment_test (SoupURI *base_uri){	SoupSession *session;	SoupURI *proxy_uri, *req_uri;	SoupMessage *msg;	debug_printf (1, "/nTesting request with fragment via proxy/n");	proxy_uri = soup_uri_new (proxies[SIMPLE_PROXY]);	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_PROXY_URI, proxy_uri,					 NULL);	soup_uri_free (proxy_uri);	req_uri = soup_uri_new_with_base (base_uri, "/#foo");	msg = soup_message_new_from_uri (SOUP_METHOD_GET, req_uri);	soup_uri_free (req_uri);	soup_session_send_message (session, msg);	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "  unexpected status %d %s!/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);	soup_test_session_abort_unref (session);}

static gbooleantry_query_info (GVfsBackend           *backend,                GVfsJobQueryInfo      *job,                const char            *filename,                GFileQueryInfoFlags    flags,                GFileInfo             *info,                GFileAttributeMatcher *attribute_matcher){  SoupMessage *msg;  SoupURI     *uri;  if (g_file_attribute_matcher_matches_only (attribute_matcher,                                             G_FILE_ATTRIBUTE_THUMBNAIL_PATH))    {      g_vfs_job_succeeded (G_VFS_JOB (job));      return TRUE;    }  uri = http_backend_get_mount_base (backend);  msg = soup_message_new_from_uri (SOUP_METHOD_HEAD, uri);  http_backend_queue_message (backend, msg, query_info_ready, job);  return TRUE;}

static voiddo_non_idempotent_test_for_session (SoupSession *session){	SoupMessage *msg;	SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL };	int i;	g_signal_connect (session, "request-started",			  G_CALLBACK (request_started_socket_collector),			  &sockets);	debug_printf (2, "    GET/n");	msg = soup_message_new_from_uri ("GET", base_uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "      Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	if (sockets[1]) {		debug_printf (1, "      Message was retried??/n");		errors++;		sockets[1] = sockets[2] = sockets[3] = NULL;	}	g_object_unref (msg);	debug_printf (2, "    POST/n");	msg = soup_message_new_from_uri ("POST", base_uri);	soup_session_send_message (session, msg);	if (msg->status_code != SOUP_STATUS_OK) {		debug_printf (1, "      Unexpected response: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	if (sockets[1] == sockets[0]) {		debug_printf (1, "      Message was sent on existing connection!/n");		errors++;	}	if (sockets[2]) {		debug_printf (1, "      Too many connections used.../n");		errors++;	}	g_object_unref (msg);	for (i = 0; sockets[i]; i++)		g_object_unref (sockets[i]);}

static voiddo_max_conns_test_for_session (SoupSession *session){	SoupMessage *msgs[TEST_CONNS];	int i;	max_conns_loop = g_main_loop_new (NULL, TRUE);	g_mutex_lock (&server_mutex);	g_signal_connect (session, "request-started",			  G_CALLBACK (max_conns_request_started), NULL);	msgs_done = 0;	for (i = 0; i < TEST_CONNS; i++) {		msgs[i] = soup_message_new_from_uri ("GET", base_uri);		g_object_ref (msgs[i]);		soup_session_queue_message (session, msgs[i],					    max_conns_message_complete, NULL);	}	g_main_loop_run (max_conns_loop);	if (msgs_done != MAX_CONNS) {		debug_printf (1, "  Queued %d connections out of max %d?",			      msgs_done, MAX_CONNS);		errors++;	}	g_signal_handlers_disconnect_by_func (session, max_conns_request_started, NULL);	msgs_done = 0;	g_idle_add (idle_start_server, NULL);	quit_loop_timeout = g_timeout_add (1000, quit_loop, NULL);	g_main_loop_run (max_conns_loop);	for (i = 0; i < TEST_CONNS; i++) {		if (!SOUP_STATUS_IS_SUCCESSFUL (msgs[i]->status_code)) {			debug_printf (1, "    Message %d failed? %d %s/n",				      i, msgs[i]->status_code,				      msgs[i]->reason_phrase ? msgs[i]->reason_phrase : "-");			errors++;		}	}	if (msgs_done != TEST_CONNS) {		/* Clean up so we don't get a spurious "Leaked		 * session" error.		 */		for (i = 0; i < TEST_CONNS; i++)			soup_session_cancel_message (session, msgs[i], SOUP_STATUS_CANCELLED);		g_main_loop_run (max_conns_loop);	}	g_main_loop_unref (max_conns_loop);	if (quit_loop_timeout)		g_source_remove (quit_loop_timeout);	for (i = 0; i < TEST_CONNS; i++)		g_object_unref (msgs[i]);}

static void _request_access_token(GSignondOauthPlugin *self,                              GSignondSessionData *session_data,                             GError** error                                 ){    //GSignondPlugin* plugin = GSIGNOND_PLUGIN(self);    const gchar* endpoint_url_s = gsignond_dictionary_get_string(session_data,                                                               "TokenEndpoint");    if (endpoint_url_s == NULL) {        *error = g_error_new(GSIGNOND_ERROR,                             GSIGNOND_ERROR_MISSING_DATA,                             "Client did not supply TokenEndpoint");        return;    }    SoupURI* endpoint_uri = soup_uri_new(endpoint_url_s);    if (endpoint_uri == NULL) {        *error = g_error_new(GSIGNOND_ERROR,                             GSIGNOND_ERROR_MISSING_DATA,                             "Client did not supply a valid TokenEndpoint");        return;    }        if (g_strcmp0(soup_uri_get_scheme(endpoint_uri), "https") != 0) {        soup_uri_free(endpoint_uri);        *error = g_error_new(GSIGNOND_ERROR,                             GSIGNOND_ERROR_MISSING_DATA,                             "TokenEndpoint must use https");        return;    }    gsignond_oauth_plugin_check_host(soup_uri_get_host(endpoint_uri),        gsignond_session_data_get_allowed_realms (session_data), error);    if (*error != NULL) {        soup_uri_free(endpoint_uri);        return;    }        gchar* authorization_header = _make_authorization_header(                                                             session_data,                                                              endpoint_uri,                                                             error                                                            );    if (*error == NULL) {        SoupMessage *msg = soup_message_new_from_uri ("POST", endpoint_uri);        soup_message_headers_append(msg->request_headers, "Authorization",                                    authorization_header);        g_free(authorization_header);        soup_session_queue_message (self->soup_session,                                     msg,                                     _access_token_callback,                                     self);    }    soup_uri_free(endpoint_uri);}

static voiddo_disappearing_auth_test (void){	SoupServer *server;	SoupAuthDomain *auth_domain;	SoupURI *uri;	SoupMessage *msg;	SoupSession *session;	int counter;	debug_printf (1, "/nTesting auth when server does not repeat challenge on failure:/n");	server = soup_test_server_new (FALSE);	soup_server_add_handler (server, NULL,				 server_callback, NULL, NULL);	uri = soup_uri_new ("http://127.0.0.1/");	soup_uri_set_port (uri, soup_server_get_port (server));	auth_domain = soup_auth_domain_basic_new (						  SOUP_AUTH_DOMAIN_REALM, "auth-test",						  SOUP_AUTH_DOMAIN_ADD_PATH, "/",						  SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, server_basic_auth_callback,						  NULL);	soup_server_add_auth_domain (server, auth_domain);	g_signal_connect (server, "request-read",			  G_CALLBACK (disappear_request_read), NULL);	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	counter = 0;	g_signal_connect (session, "authenticate",			  G_CALLBACK (disappear_authenticate), &counter);	msg = soup_message_new_from_uri ("GET", uri);	soup_session_send_message (session, msg);	if (counter > 2) {		debug_printf (1, "    FAILED: Got stuck in loop");		errors++;	} else if (msg->status_code != SOUP_STATUS_UNAUTHORIZED) {		debug_printf (1, "    Final status wrong: expected 401, got %u/n",			      msg->status_code);		errors++;	}	g_object_unref (msg);	soup_test_session_abort_unref (session);	g_object_unref (auth_domain);	soup_uri_free (uri);	soup_test_server_quit_unref (server);}

static gbooleansoup_request_http_check_uri (SoupRequest  *request,			     SoupURI      *uri,			     GError      **error){	SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request);	if (!SOUP_URI_VALID_FOR_HTTP (uri))		return FALSE;	http->priv->msg = soup_message_new_from_uri (SOUP_METHOD_GET, uri);	return TRUE;}

static voiddo_response_test (SoupSession *session, SoupURI *base_uri){	GetTestData gtd;	SoupMessage *msg;	const char *client_md5, *server_md5;	debug_printf (1, "GET/n");	gtd.current_chunk = NULL;	gtd.length = 0;	gtd.check = g_checksum_new (G_CHECKSUM_MD5);	msg = soup_message_new_from_uri ("GET", base_uri);	soup_message_body_set_accumulate (msg->response_body, FALSE);	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;	soup_message_set_chunk_allocator (msg, chunk_allocator, &gtd, NULL);	G_GNUC_END_IGNORE_DEPRECATIONS;	g_signal_connect (msg, "got_chunk",			  G_CALLBACK (got_chunk), &gtd);	soup_session_send_message (session, msg);	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "  message failed: %d %s/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	if (msg->response_body->data) {		debug_printf (1, "  msg->response_body set!/n");		errors++;	}	if (soup_message_headers_get_content_length (msg->response_headers) != gtd.length) {		debug_printf (1, "  received length mismatch: %d vs %d/n",			      (int)soup_message_headers_get_content_length (msg->response_headers), gtd.length);		errors++;	}	client_md5 = g_checksum_get_string (gtd.check);	server_md5 = soup_message_headers_get_one (msg->response_headers,						   "Content-MD5");	if (!server_md5 || strcmp (client_md5, server_md5) != 0) {		debug_printf (1, "  client/server data mismatch: %s vs %s/n",			      client_md5, server_md5 ? server_md5 : "(null)");		errors++;	}	g_object_unref (msg);	g_checksum_free (gtd.check);}