dnl *** Checks for glib ***
dnl ***********************
-AM_PATH_GLIB_2_0(2.30.0,,,gobject gio)
+AM_PATH_GLIB_2_0(2.31.0,,,gobject gio)
if test "$GLIB_LIBS" = ""; then
- AC_MSG_ERROR(GLIB 2.30.0 or later is required to build libsoup)
+ AC_MSG_ERROR(GLIB 2.31.0 or later is required to build libsoup)
fi
GLIB_CFLAGS="$GLIB_CFLAGS -DG_DISABLE_SINGLE_INCLUDES"
SCAN_OPTIONS=--deprecated-guards=LIBSOUP_DISABLE_DEPRECATED --rebuild-types
# Extra options to supply to gtkdoc-scangobj.
-SCANGOBJ_OPTIONS=--type-init-func 'g_type_init(); g_thread_init(NULL)'
+SCANGOBJ_OPTIONS=
# Extra options to supply to gtkdoc-mkdb.
MKDB_OPTIONS=--sgml-mode --output-format=xml
char *name, *physical;
guint port;
- GMutex *lock;
+ GMutex lock;
GSList *async_lookups;
} SoupAddressPrivate;
#define SOUP_ADDRESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_ADDRESS, SoupAddressPrivate))
{
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr);
- priv->lock = g_mutex_new ();
+ g_mutex_init (&priv->lock);
}
static void
if (priv->physical)
g_free (priv->physical);
- g_mutex_free (priv->lock);
+ g_mutex_clear (&priv->lock);
G_OBJECT_CLASS (soup_address_parent_class)->finalize (object);
}
* priv->sockaddr and priv->name, unlock it around the
* blocking op, and then re-lock it to modify @addr.
*/
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
if (!priv->sockaddr) {
GList *addrs;
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
addrs = g_resolver_lookup_by_name (resolver, priv->name,
cancellable, &my_err);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
status = update_addrs (addr, addrs, my_err);
g_resolver_free_addresses (addrs);
GInetAddress *gia;
char *name;
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
gia = soup_address_make_inet_address (addr);
name = g_resolver_lookup_by_address (resolver, gia,
cancellable, &my_err);
g_object_unref (gia);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
status = update_name (addr, name, my_err);
g_free (name);
} else
status = SOUP_STATUS_OK;
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
if (my_err)
g_propagate_error (error, my_err);
g_return_val_if_fail (SOUP_IS_ADDRESS (addr), FALSE);
priv = SOUP_ADDRESS_GET_PRIVATE (addr);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
resolved = priv->sockaddr && priv->name;
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
return resolved;
}
xml_string = g_markup_escape_text (file_name, -1);
escaped = g_uri_escape_string (file_name, NULL, FALSE);
path = g_strconcat (stream->uri, G_DIR_SEPARATOR_S, escaped, NULL);
- size = g_format_size_for_display (g_file_info_get_size (info));
+ size = g_format_size (g_file_info_get_size (info));
g_file_info_get_modification_time (info, &modified);
modification_time = g_date_time_new_from_timeval_local (&modified);
time = g_date_time_format (modification_time, "%X %x");
/* We use a mutex so that if requests are being run in
* multiple threads, we don't mix up the output.
*/
- GMutex *lock;
+ GMutex lock;
GQuark tag;
GHashTable *ids;
{
SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger);
- priv->lock = g_mutex_new ();
+ g_mutex_init (&priv->lock);
priv->tag = g_quark_from_static_string (g_strdup_printf ("SoupLogger-%p", logger));
priv->ids = g_hash_table_new (NULL, NULL);
}
if (priv->printer_dnotify)
priv->printer_dnotify (priv->printer_data);
- g_mutex_free (priv->lock);
+ g_mutex_clear (&priv->lock);
G_OBJECT_CLASS (soup_logger_parent_class)->finalize (object);
}
SoupLogger *logger = user_data;
SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
print_response (logger, msg);
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, ' ', "");
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, ' ', "");
}
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
}
static void
SoupLogger *logger = user_data;
SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
print_response (logger, msg);
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, ' ', "");
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
}
static void
struct _SoupMessageQueue {
SoupSession *session;
- GMutex *mutex;
+ GMutex mutex;
SoupMessageQueueItem *head, *tail;
};
queue = g_slice_new0 (SoupMessageQueue);
queue->session = session;
- queue->mutex = g_mutex_new ();
+ g_mutex_init (&queue->mutex);
return queue;
}
{
g_return_if_fail (queue->head == NULL);
- g_mutex_free (queue->mutex);
+ g_mutex_clear (&queue->mutex);
g_slice_free (SoupMessageQueue, queue);
}
*/
item->ref_count = 1;
- g_mutex_lock (queue->mutex);
+ g_mutex_lock (&queue->mutex);
if (queue->head) {
queue->tail->next = item;
item->prev = queue->tail;
} else
queue->head = queue->tail = item;
- g_mutex_unlock (queue->mutex);
+ g_mutex_unlock (&queue->mutex);
return item;
}
void
soup_message_queue_item_unref (SoupMessageQueueItem *item)
{
- g_mutex_lock (item->queue->mutex);
+ g_mutex_lock (&item->queue->mutex);
/* Decrement the ref_count; if it's still non-zero OR if the
* item is still in the queue, then return.
*/
if (--item->ref_count || !item->removed) {
- g_mutex_unlock (item->queue->mutex);
+ g_mutex_unlock (&item->queue->mutex);
return;
}
else
item->queue->tail = item->prev;
- g_mutex_unlock (item->queue->mutex);
+ g_mutex_unlock (&item->queue->mutex);
/* And free it */
g_signal_handlers_disconnect_by_func (item->msg,
{
SoupMessageQueueItem *item;
- g_mutex_lock (queue->mutex);
+ g_mutex_lock (&queue->mutex);
item = queue->tail;
while (item && (item->removed || item->msg != msg))
if (item)
item->ref_count++;
- g_mutex_unlock (queue->mutex);
+ g_mutex_unlock (&queue->mutex);
return item;
}
{
SoupMessageQueueItem *item;
- g_mutex_lock (queue->mutex);
+ g_mutex_lock (&queue->mutex);
item = queue->head;
while (item && item->removed)
if (item)
item->ref_count++;
- g_mutex_unlock (queue->mutex);
+ g_mutex_unlock (&queue->mutex);
return item;
}
{
SoupMessageQueueItem *next;
- g_mutex_lock (queue->mutex);
+ g_mutex_lock (&queue->mutex);
next = item->next;
while (next && next->removed)
if (next)
next->ref_count++;
- g_mutex_unlock (queue->mutex);
+ g_mutex_unlock (&queue->mutex);
soup_message_queue_item_unref (item);
return next;
}
{
g_return_if_fail (!item->removed);
- g_mutex_lock (queue->mutex);
+ g_mutex_lock (&queue->mutex);
item->removed = TRUE;
- g_mutex_unlock (queue->mutex);
+ g_mutex_unlock (&queue->mutex);
}
**/
typedef struct {
- GMutex *lock;
- GCond *cond;
+ GMutex lock;
+ GCond cond;
} SoupSessionSyncPrivate;
#define SOUP_SESSION_SYNC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncPrivate))
{
SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (ss);
- priv->lock = g_mutex_new ();
- priv->cond = g_cond_new ();
+ g_mutex_init (&priv->lock);
+ g_cond_init (&priv->cond);
}
static void
{
SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (object);
- g_mutex_free (priv->lock);
- g_cond_free (priv->cond);
+ g_mutex_clear (&priv->lock);
+ g_cond_clear (&priv->cond);
G_OBJECT_CLASS (soup_session_sync_parent_class)->finalize (object);
}
item->state = SOUP_MESSAGE_STARTING;
do {
if (item->paused) {
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
while (item->paused)
- g_cond_wait (priv->cond, priv->lock);
- g_mutex_unlock (priv->lock);
+ g_cond_wait (&priv->cond, &priv->lock);
+ g_mutex_unlock (&priv->lock);
}
switch (item->state) {
break;
case SOUP_MESSAGE_AWAITING_CONNECTION:
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
do {
get_connection (item);
if (item->state == SOUP_MESSAGE_AWAITING_CONNECTION)
- g_cond_wait (priv->cond, priv->lock);
+ g_cond_wait (&priv->cond, &priv->lock);
} while (item->state == SOUP_MESSAGE_AWAITING_CONNECTION);
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
break;
case SOUP_MESSAGE_READY:
item->state = SOUP_MESSAGE_FINISHED;
soup_message_finished (item->msg);
soup_session_unqueue_item (session, item);
- g_cond_broadcast (priv->cond);
+ g_cond_broadcast (&priv->cond);
break;
default:
SoupSessionCallback callback, gpointer user_data)
{
SoupMessageQueueItem *item;
+ GThread *thread;
SOUP_SESSION_CLASS (soup_session_sync_parent_class)->
queue_message (g_object_ref (session), msg, callback, user_data);
item = soup_message_queue_lookup (soup_session_get_queue (session), msg);
g_return_if_fail (item != NULL);
- g_thread_create (queue_message_thread, item, FALSE, NULL);
+ thread = g_thread_new ("SoupSessionSync:queue_message",
+ queue_message_thread, item);
+ g_thread_unref (thread);
}
static guint
{
SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
SOUP_SESSION_CLASS (soup_session_sync_parent_class)->cancel_message (session, msg, status_code);
- g_cond_broadcast (priv->cond);
- g_mutex_unlock (priv->lock);
+ g_cond_broadcast (&priv->cond);
+ g_mutex_unlock (&priv->lock);
}
static void
* try to cancel those requests as well, since we'd likely
* just end up looping forever.)
*/
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
do {
done = TRUE;
for (item = soup_message_queue_first (queue);
}
if (!done)
- g_cond_wait (priv->cond, priv->lock);
+ g_cond_wait (&priv->cond, &priv->lock);
} while (!done);
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
g_hash_table_destroy (current);
}
{
SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session);
- g_mutex_lock (priv->lock);
- g_cond_broadcast (priv->cond);
- g_mutex_unlock (priv->lock);
+ g_mutex_lock (&priv->lock);
+ g_cond_broadcast (&priv->cond);
+ g_mutex_unlock (&priv->lock);
}
* new SoupSessionHost, or adding/removing a connection.
* Must not emit signals or destroy objects while holding it.
*/
- GMutex *host_lock;
+ GMutex host_lock;
GMainContext *async_context;
gboolean use_thread_context;
priv->queue = soup_message_queue_new (session);
- priv->host_lock = g_mutex_new ();
+ g_mutex_init (&priv->host_lock);
priv->hosts = g_hash_table_new_full (soup_uri_host_hash,
soup_uri_host_equal,
NULL, (GDestroyNotify)free_host);
soup_message_queue_destroy (priv->queue);
- g_mutex_free (priv->host_lock);
+ g_mutex_clear (&priv->host_lock);
g_hash_table_destroy (priv->hosts);
g_hash_table_destroy (priv->conns);
gpointer conn, host;
SoupConnectionState state;
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
g_hash_table_iter_init (&iter, priv->conns);
while (g_hash_table_iter_next (&iter, &conn, &host)) {
state = soup_connection_get_state (conn);
(prune_idle && state == SOUP_CONNECTION_IDLE))
conns = g_slist_prepend (conns, g_object_ref (conn));
}
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
if (!conns)
return FALSE;
SoupSessionHost *host = (SoupSessionHost *) user_data;
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (host->session);
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
/* This will free the host in addition to removing it from the
* hash table
*/
g_hash_table_remove (priv->hosts, host->uri);
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
return FALSE;
}
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupSessionHost *host;
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
host = g_hash_table_lookup (priv->conns, conn);
if (host) {
g_signal_handlers_disconnect_by_func (conn, connection_disconnected, session);
priv->num_conns--;
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
g_object_unref (conn);
}
return TRUE;
}
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
host = get_host_for_message (session, item->msg);
for (conns = host->connections; conns; conns = conns->next) {
if (soup_connection_get_state (conns->data) == SOUP_CONNECTION_IDLE) {
soup_connection_set_state (conns->data, SOUP_CONNECTION_IN_USE);
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
item->conn = g_object_ref (conns->data);
soup_message_set_https_status (item->msg, item->conn);
return TRUE;
* is somewhat arbitrary...
*/
if (num_pending > host->num_messages / 2) {
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
return FALSE;
}
if (host->num_conns >= priv->max_conns_per_host) {
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
return FALSE;
}
if (priv->num_conns >= priv->max_conns) {
*try_pruning = TRUE;
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
return FALSE;
}
host->keep_alive_src = NULL;
}
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
item->conn = g_object_ref (conn);
return TRUE;
}
soup_message_queue_remove (priv->queue, item);
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
host = get_host_for_message (session, item->msg);
host->num_messages--;
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
/* g_signal_handlers_disconnect_by_func doesn't work if you
* have a metamarshal, meaning it doesn't work with
item = soup_message_queue_append (priv->queue, msg, callback, user_data);
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
host = get_host_for_message (session, item->msg);
host->num_messages++;
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
if (!(soup_message_get_flags (msg) & SOUP_MESSAGE_NO_REDIRECT)) {
soup_message_add_header_handler (
SOUP_SESSION_GET_CLASS (session)->flush_queue (session);
/* Close all connections */
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
conns = NULL;
g_hash_table_foreach (priv->conns, gather_conns, &conns);
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
for (c = conns; c; c = c->next) {
soup_connection_disconnect (c->data);
g_object_unref (c->data);
priv = SOUP_SESSION_GET_PRIVATE (session);
- g_mutex_lock (priv->host_lock);
+ g_mutex_lock (&priv->host_lock);
host = get_host_for_uri (session, uri);
addr = g_object_ref (host->addr);
- g_mutex_unlock (priv->host_lock);
+ g_mutex_unlock (&priv->host_lock);
soup_address_resolve_async (addr,
soup_session_get_async_context (session),
GSource *read_src, *write_src;
GByteArray *read_buf;
- GMutex *iolock, *addrlock;
+ GMutex iolock, addrlock;
guint timeout;
GCancellable *connect_cancel;
SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
priv->non_blocking = TRUE;
- priv->addrlock = g_mutex_new ();
- priv->iolock = g_mutex_new ();
+ g_mutex_init (&priv->addrlock);
+ g_mutex_init (&priv->iolock);
}
static void
if (priv->read_buf)
g_byte_array_free (priv->read_buf, TRUE);
- g_mutex_free (priv->addrlock);
- g_mutex_free (priv->iolock);
+ g_mutex_clear (&priv->addrlock);
+ g_mutex_clear (&priv->iolock);
G_OBJECT_CLASS (soup_socket_parent_class)->finalize (object);
}
if (priv->connect_cancel) {
g_cancellable_cancel (priv->connect_cancel);
return;
- } else if (g_mutex_trylock (priv->iolock)) {
+ } else if (g_mutex_trylock (&priv->iolock)) {
if (priv->conn)
disconnect_internal (sock);
else
already_disconnected = TRUE;
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
} else {
/* Another thread is currently doing IO, so
* we can't close the socket. So just shutdown
g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
priv = SOUP_SOCKET_GET_PRIVATE (sock);
- g_mutex_lock (priv->addrlock);
+ g_mutex_lock (&priv->addrlock);
if (!priv->local_addr) {
GSocketAddress *addr;
struct sockaddr_storage sa;
priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
g_object_unref (addr);
}
- g_mutex_unlock (priv->addrlock);
+ g_mutex_unlock (&priv->addrlock);
return priv->local_addr;
}
g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
priv = SOUP_SOCKET_GET_PRIVATE (sock);
- g_mutex_lock (priv->addrlock);
+ g_mutex_lock (&priv->addrlock);
if (!priv->remote_addr) {
GSocketAddress *addr;
struct sockaddr_storage sa;
priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
g_object_unref (addr);
}
- g_mutex_unlock (priv->addrlock);
+ g_mutex_unlock (&priv->addrlock);
return priv->remote_addr;
}
priv = SOUP_SOCKET_GET_PRIVATE (sock);
- g_mutex_lock (priv->iolock);
+ g_mutex_lock (&priv->iolock);
if (priv->read_buf)
status = read_from_buf (sock, buffer, len, nread);
else
status = read_from_network (sock, buffer, len, nread, cancellable, error);
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
return status;
}
priv = SOUP_SOCKET_GET_PRIVATE (sock);
- g_mutex_lock (priv->iolock);
+ g_mutex_lock (&priv->iolock);
*got_boundary = FALSE;
read_buf->len = prev_len + *nread;
if (status != SOUP_SOCKET_OK) {
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
return status;
}
}
match_len = p - read_buf->data;
status = read_from_buf (sock, buffer, MIN (len, match_len), nread);
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
return status;
}
priv = SOUP_SOCKET_GET_PRIVATE (sock);
- g_mutex_lock (priv->iolock);
+ g_mutex_lock (&priv->iolock);
if (!priv->conn) {
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
return SOUP_SOCKET_EOF;
}
if (priv->write_src) {
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
return SOUP_SOCKET_WOULD_BLOCK;
}
}
if (my_nwrote > 0) {
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
g_clear_error (&my_err);
*nwrote = my_nwrote;
return SOUP_SOCKET_OK;
}
if (g_error_matches (my_err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
g_clear_error (&my_err);
priv->write_src =
return SOUP_SOCKET_WOULD_BLOCK;
}
- g_mutex_unlock (priv->iolock);
+ g_mutex_unlock (&priv->iolock);
g_propagate_error (error, my_err);
return SOUP_SOCKET_ERROR;
}
static gboolean idle_start_test1_thread (gpointer loop);
static gpointer test1_thread (gpointer user_data);
-static GCond *test1_cond;
-static GMutex *test1_mutex;
+static GCond test1_cond;
+static GMutex test1_mutex;
static GMainLoop *test1_loop;
static void
else
debug_printf (1, "(Using SOUP_SESSION_ASYNC_CONTEXT)\n");
- test1_cond = g_cond_new ();
- test1_mutex = g_mutex_new ();
-
test1_loop = g_main_loop_new (NULL, FALSE);
g_idle_add (idle_start_test1_thread, GINT_TO_POINTER (use_thread_context));
g_main_loop_run (test1_loop);
g_main_loop_unref (test1_loop);
-
- g_mutex_free (test1_mutex);
- g_cond_free (test1_cond);
}
static gboolean
idle_start_test1_thread (gpointer use_thread_context)
{
- GTimeVal time;
+ guint64 time;
GThread *thread;
- g_mutex_lock (test1_mutex);
- thread = g_thread_create (test1_thread, use_thread_context, TRUE, NULL);
+ g_mutex_lock (&test1_mutex);
+ thread = g_thread_new ("test1_thread", test1_thread, use_thread_context);
- g_get_current_time (&time);
- time.tv_sec += 5;
- if (g_cond_timed_wait (test1_cond, test1_mutex, &time))
+ time = g_get_monotonic_time () + 5000000;
+ if (g_cond_wait_until (&test1_cond, &test1_mutex, time))
g_thread_join (thread);
else {
debug_printf (1, " timeout!\n");
+ g_thread_unref (thread);
errors++;
}
- g_mutex_unlock (test1_mutex);
+ g_mutex_unlock (&test1_mutex);
g_main_loop_quit (test1_loop);
return FALSE;
}
GMainLoop *loop;
/* Wait for main thread to be waiting on test1_cond */
- g_mutex_lock (test1_mutex);
- g_mutex_unlock (test1_mutex);
+ g_mutex_lock (&test1_mutex);
+ g_mutex_unlock (&test1_mutex);
async_context = g_main_context_new ();
if (use_thread_context) {
soup_test_session_abort_unref (session);
g_free (uri);
- g_cond_signal (test1_cond);
+ g_cond_signal (&test1_cond);
if (use_thread_context)
g_main_context_pop_thread_default (async_context);
SoupServer *server;
SoupURI *base_uri;
-GMutex *server_mutex;
+GMutex server_mutex;
static gboolean
auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
* need to hold it through the whole function, so it's simpler
* to just release it right away.
*/
- g_mutex_lock (server_mutex);
- g_mutex_unlock (server_mutex);
+ g_mutex_lock (&server_mutex);
+ g_mutex_unlock (&server_mutex);
soup_message_headers_append (msg->response_headers,
"X-Handled-By", "server_callback");
static gboolean
idle_start_server (gpointer data)
{
- g_mutex_unlock (server_mutex);
+ g_mutex_unlock (&server_mutex);
return FALSE;
}
max_conns_loop = g_main_loop_new (NULL, TRUE);
- g_mutex_lock (server_mutex);
+ g_mutex_lock (&server_mutex);
g_signal_connect (session, "request-started",
G_CALLBACK (max_conns_request_started), NULL);
if (SOUP_IS_SESSION_ASYNC (session))
g_timeout_add (100, cancel_message_timeout, msg);
else
- thread = g_thread_create (cancel_message_thread, msg, TRUE, NULL);
+ thread = g_thread_new ("cancel_message_thread", cancel_message_thread, msg);
soup_session_send_message (session, msg);
test_init (argc, argv, NULL);
- server_mutex = g_mutex_new ();
-
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
base_uri = soup_uri_new ("http://127.0.0.1/");
soup_uri_free (base_uri);
soup_test_server_quit_unref (server);
- g_mutex_free (server_mutex);
test_cleanup ();
return errors != 0;
debug_printf (1, "Streaming in another thread\n");
- thread = g_thread_create ((GThreadFunc)do_test_with_context,
- (gpointer)uri, TRUE, NULL);
+ thread = g_thread_new ("do_test_with_context",
+ (GThreadFunc)do_test_with_context,
+ (gpointer)uri);
g_thread_join (thread);
}
if (in_own_thread) {
GThread *thread;
- thread = g_thread_create (run_server_thread, server,
- TRUE, NULL);
+ thread = g_thread_new ("server_thread", run_server_thread, server);
g_object_set_data (G_OBJECT (server), "thread", thread);
} else
soup_server_run_async (server);
projects / platform / upstream / libsoup.git / commitdiff