/** * soup_session_cancel_message: * @session: a #SoupSession * @msg: the message to cancel * @status_code: status code to set on @msg (generally * %SOUP_STATUS_CANCELLED) * * Causes @session to immediately finish processing @msg (regardless * of its current state) with a final status_code of @status_code. You * may call this at any time after handing @msg off to @session; if * @session has started sending the request but has not yet received * the complete response, then it will close the request's connection. * Note that with non-idempotent requests (eg, %POST, %PUT, %DELETE) * it is possible that you might cancel the request after the server * acts on it, but before it returns a response, leaving the remote * resource in an unknown state. * * If the message is cancelled while its response body is being read, * then the response body in @msg will be left partially-filled-in. * The response headers, on the other hand, will always be either * empty or complete. * * For messages queued with soup_session_queue_message() (and * cancelled from the same thread), the callback will be invoked * before soup_session_cancel_message() returns. **/ void soup_session_cancel_message (SoupSession *session, SoupMessage *msg, guint status_code) { g_return_if_fail (SOUP_IS_SESSION (session)); g_return_if_fail (SOUP_IS_MESSAGE (msg)); /* If the message is already ending, don't do anything */ if (soup_message_get_io_status (msg) == SOUP_MESSAGE_IO_STATUS_FINISHED) return; SOUP_SESSION_GET_CLASS (session)->cancel_message (session, msg, status_code); }
static guint send_message (SoupSession *session, SoupMessage *req) { GMainContext *async_context = soup_session_get_async_context (session); /* Balance out the unref that final_finished will do */ g_object_ref (req); queue_message (session, req, NULL, NULL); while (soup_message_get_io_status (req) != SOUP_MESSAGE_IO_STATUS_FINISHED && !SOUP_STATUS_IS_TRANSPORT_ERROR (req->status_code)) g_main_context_iteration (async_context, TRUE); return req->status_code; }