+3 -2

chardev/char-socket.c

··· 707 707 qio_channel_tls_handshake(tioc, 708 708 tcp_chr_tls_handshake, 709 709 chr, 710 710 + NULL, 710 711 NULL); 711 712 } 712 713 ··· 871 872 tcp_chr_set_client_ioc_name(chr, sioc); 872 873 qio_channel_socket_connect_async(sioc, s->addr, 873 874 qemu_chr_socket_connected, 874 874 - chr, NULL); 875 875 + chr, NULL, NULL); 875 876 876 877 return false; 877 878 } ··· 955 956 tcp_chr_set_client_ioc_name(chr, sioc); 956 957 qio_channel_socket_connect_async(sioc, s->addr, 957 958 qemu_chr_socket_connected, 958 958 - chr, NULL); 959 959 + chr, NULL, NULL); 959 960 } else { 960 961 if (s->is_listen) { 961 962 char *name;

+12 -3

include/io/channel-socket.h

··· 101 101 * @callback: the function to invoke on completion 102 102 * @opaque: user data to pass to @callback 103 103 * @destroy: the function to free @opaque 104 104 + * @context: the context to run the async task. If %NULL, the default 105 105 + * context will be used. 104 106 * 105 107 * Attempt to connect to the address @addr. This method 106 108 * will run in the background so the caller will regain ··· 113 115 SocketAddress *addr, 114 116 QIOTaskFunc callback, 115 117 gpointer opaque, 116 116 - GDestroyNotify destroy); 118 118 + GDestroyNotify destroy, 119 119 + GMainContext *context); 117 120 118 121 119 122 /** ··· 138 141 * @callback: the function to invoke on completion 139 142 * @opaque: user data to pass to @callback 140 143 * @destroy: the function to free @opaque 144 144 + * @context: the context to run the async task. If %NULL, the default 145 145 + * context will be used. 141 146 * 142 147 * Attempt to listen to the address @addr. This method 143 148 * will run in the background so the caller will regain ··· 150 155 SocketAddress *addr, 151 156 QIOTaskFunc callback, 152 157 gpointer opaque, 153 153 - GDestroyNotify destroy); 158 158 + GDestroyNotify destroy, 159 159 + GMainContext *context); 154 160 155 161 156 162 /** ··· 179 185 * @callback: the function to invoke on completion 180 186 * @opaque: user data to pass to @callback 181 187 * @destroy: the function to free @opaque 188 188 + * @context: the context to run the async task. If %NULL, the default 189 189 + * context will be used. 182 190 * 183 191 * Attempt to initialize a datagram socket bound to 184 192 * @localAddr and communicating with peer @remoteAddr. ··· 194 202 SocketAddress *remoteAddr, 195 203 QIOTaskFunc callback, 196 204 gpointer opaque, 197 197 - GDestroyNotify destroy); 205 205 + GDestroyNotify destroy, 206 206 + GMainContext *context); 198 207 199 208 200 209 /**

+4 -1

include/io/channel-tls.h

··· 116 116 * @func: the callback to invoke when completed 117 117 * @opaque: opaque data to pass to @func 118 118 * @destroy: optional callback to free @opaque 119 119 + * @context: the context that TLS handshake will run with. If %NULL, 120 120 + * the default context will be used 119 121 * 120 122 * Perform the TLS session handshake. This method 121 123 * will return immediately and the handshake will ··· 126 128 void qio_channel_tls_handshake(QIOChannelTLS *ioc, 127 129 QIOTaskFunc func, 128 130 gpointer opaque, 129 129 - GDestroyNotify destroy); 131 131 + GDestroyNotify destroy, 132 132 + GMainContext *context); 130 133 131 134 /** 132 135 * qio_channel_tls_get_session:

+44

include/io/channel.h

··· 648 648 gpointer user_data, 649 649 GDestroyNotify notify); 650 650 651 651 + /** 652 652 + * qio_channel_add_watch_full: 653 653 + * @ioc: the channel object 654 654 + * @condition: the I/O condition to monitor 655 655 + * @func: callback to invoke when the source becomes ready 656 656 + * @user_data: opaque data to pass to @func 657 657 + * @notify: callback to free @user_data 658 658 + * @context: the context to run the watch source 659 659 + * 660 660 + * Similar as qio_channel_add_watch(), but allows to specify context 661 661 + * to run the watch source. 662 662 + * 663 663 + * Returns: the source ID 664 664 + */ 665 665 + guint qio_channel_add_watch_full(QIOChannel *ioc, 666 666 + GIOCondition condition, 667 667 + QIOChannelFunc func, 668 668 + gpointer user_data, 669 669 + GDestroyNotify notify, 670 670 + GMainContext *context); 671 671 + 672 672 + /** 673 673 + * qio_channel_add_watch_source: 674 674 + * @ioc: the channel object 675 675 + * @condition: the I/O condition to monitor 676 676 + * @func: callback to invoke when the source becomes ready 677 677 + * @user_data: opaque data to pass to @func 678 678 + * @notify: callback to free @user_data 679 679 + * @context: gcontext to bind the source to 680 680 + * 681 681 + * Similar as qio_channel_add_watch(), but allows to specify context 682 682 + * to run the watch source, meanwhile return the GSource object 683 683 + * instead of tag ID, with the GSource referenced already. 684 684 + * 685 685 + * Note: callers is responsible to unref the source when not needed. 686 686 + * 687 687 + * Returns: the source pointer 688 688 + */ 689 689 + GSource *qio_channel_add_watch_source(QIOChannel *ioc, 690 690 + GIOCondition condition, 691 691 + QIOChannelFunc func, 692 692 + gpointer user_data, 693 693 + GDestroyNotify notify, 694 694 + GMainContext *context); 651 695 652 696 /** 653 697 * qio_channel_attach_aio_context:

+20 -2

include/io/net-listener.h

··· 53 53 54 54 char *name; 55 55 QIOChannelSocket **sioc; 56 56 - gulong *io_tag; 56 56 + GSource **io_source; 57 57 size_t nsioc; 58 58 59 59 bool connected; ··· 120 120 QIOChannelSocket *sioc); 121 121 122 122 /** 123 123 - * qio_net_listener_set_client_func: 123 123 + * qio_net_listener_set_client_func_full: 124 124 * @listener: the network listener object 125 125 * @func: the callback function 126 126 * @data: opaque data to pass to @func 127 127 * @notify: callback to free @data 128 128 + * @context: the context that the sources will be bound to. If %NULL, 129 129 + * the default context will be used. 128 130 * 129 131 * Register @func to be invoked whenever a new client 130 132 * connects to the listener. @func will be invoked 131 133 * passing in the QIOChannelSocket instance for the 132 134 * client. 135 135 + */ 136 136 + void qio_net_listener_set_client_func_full(QIONetListener *listener, 137 137 + QIONetListenerClientFunc func, 138 138 + gpointer data, 139 139 + GDestroyNotify notify, 140 140 + GMainContext *context); 141 141 + 142 142 + /** 143 143 + * qio_net_listener_set_client_func: 144 144 + * @listener: the network listener object 145 145 + * @func: the callback function 146 146 + * @data: opaque data to pass to @func 147 147 + * @notify: callback to free @data 148 148 + * 149 149 + * Wrapper of qio_net_listener_set_client_func_full(), only that the 150 150 + * sources will always be bound to default main context. 133 151 */ 134 152 void qio_net_listener_set_client_func(QIONetListener *listener, 135 153 QIONetListenerClientFunc func,

+5 -2

include/io/task.h

··· 227 227 * @worker: the function to invoke in a thread 228 228 * @opaque: opaque data to pass to @worker 229 229 * @destroy: function to free @opaque 230 230 + * @context: the context to run the complete hook. If %NULL, the 231 231 + * default context will be used. 230 232 * 231 233 * Run a task in a background thread. When @worker 232 234 * returns it will call qio_task_complete() in 233 233 - * the main event thread context. 235 235 + * the event thread context that provided. 234 236 */ 235 237 void qio_task_run_in_thread(QIOTask *task, 236 238 QIOTaskWorker worker, 237 239 gpointer opaque, 238 238 - GDestroyNotify destroy); 240 240 + GDestroyNotify destroy, 241 241 + GMainContext *context); 239 242 240 243 /** 241 244 * qio_task_complete:

+12 -6

io/channel-socket.c

··· 174 174 SocketAddress *addr, 175 175 QIOTaskFunc callback, 176 176 gpointer opaque, 177 177 - GDestroyNotify destroy) 177 177 + GDestroyNotify destroy, 178 178 + GMainContext *context) 178 179 { 179 180 QIOTask *task = qio_task_new( 180 181 OBJECT(ioc), callback, opaque, destroy); ··· 188 189 qio_task_run_in_thread(task, 189 190 qio_channel_socket_connect_worker, 190 191 addrCopy, 191 191 - (GDestroyNotify)qapi_free_SocketAddress); 192 192 + (GDestroyNotify)qapi_free_SocketAddress, 193 193 + context); 192 194 } 193 195 194 196 ··· 233 235 SocketAddress *addr, 234 236 QIOTaskFunc callback, 235 237 gpointer opaque, 236 236 - GDestroyNotify destroy) 238 238 + GDestroyNotify destroy, 239 239 + GMainContext *context) 237 240 { 238 241 QIOTask *task = qio_task_new( 239 242 OBJECT(ioc), callback, opaque, destroy); ··· 246 249 qio_task_run_in_thread(task, 247 250 qio_channel_socket_listen_worker, 248 251 addrCopy, 249 249 - (GDestroyNotify)qapi_free_SocketAddress); 252 252 + (GDestroyNotify)qapi_free_SocketAddress, 253 253 + context); 250 254 } 251 255 252 256 ··· 308 312 SocketAddress *remoteAddr, 309 313 QIOTaskFunc callback, 310 314 gpointer opaque, 311 311 - GDestroyNotify destroy) 315 315 + GDestroyNotify destroy, 316 316 + GMainContext *context) 312 317 { 313 318 QIOTask *task = qio_task_new( 314 319 OBJECT(ioc), callback, opaque, destroy); ··· 322 327 qio_task_run_in_thread(task, 323 328 qio_channel_socket_dgram_worker, 324 329 data, 325 325 - qio_channel_socket_dgram_worker_free); 330 330 + qio_channel_socket_dgram_worker_free, 331 331 + context); 326 332 } 327 333 328 334

+34 -11

io/channel-tls.c

··· 140 140 return NULL; 141 141 } 142 142 143 143 + struct QIOChannelTLSData { 144 144 + QIOTask *task; 145 145 + GMainContext *context; 146 146 + }; 147 147 + typedef struct QIOChannelTLSData QIOChannelTLSData; 143 148 144 149 static gboolean qio_channel_tls_handshake_io(QIOChannel *ioc, 145 150 GIOCondition condition, 146 151 gpointer user_data); 147 152 148 153 static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, 149 149 - QIOTask *task) 154 154 + QIOTask *task, 155 155 + GMainContext *context) 150 156 { 151 157 Error *err = NULL; 152 158 QCryptoTLSSessionHandshakeStatus status; ··· 171 177 qio_task_complete(task); 172 178 } else { 173 179 GIOCondition condition; 180 180 + QIOChannelTLSData *data = g_new0(typeof(*data), 1); 181 181 + 182 182 + data->task = task; 183 183 + data->context = context; 184 184 + 185 185 + if (context) { 186 186 + g_main_context_ref(context); 187 187 + } 188 188 + 174 189 if (status == QCRYPTO_TLS_HANDSHAKE_SENDING) { 175 190 condition = G_IO_OUT; 176 191 } else { ··· 178 193 } 179 194 180 195 trace_qio_channel_tls_handshake_pending(ioc, status); 181 181 - qio_channel_add_watch(ioc->master, 182 182 - condition, 183 183 - qio_channel_tls_handshake_io, 184 184 - task, 185 185 - NULL); 196 196 + qio_channel_add_watch_full(ioc->master, 197 197 + condition, 198 198 + qio_channel_tls_handshake_io, 199 199 + data, 200 200 + NULL, 201 201 + context); 186 202 } 187 203 } 188 204 ··· 191 207 GIOCondition condition, 192 208 gpointer user_data) 193 209 { 194 194 - QIOTask *task = user_data; 210 210 + QIOChannelTLSData *data = user_data; 211 211 + QIOTask *task = data->task; 212 212 + GMainContext *context = data->context; 195 213 QIOChannelTLS *tioc = QIO_CHANNEL_TLS( 196 214 qio_task_get_source(task)); 197 215 198 198 - qio_channel_tls_handshake_task( 199 199 - tioc, task); 216 216 + g_free(data); 217 217 + qio_channel_tls_handshake_task(tioc, task, context); 218 218 + 219 219 + if (context) { 220 220 + g_main_context_unref(context); 221 221 + } 200 222 201 223 return FALSE; 202 224 } ··· 204 226 void qio_channel_tls_handshake(QIOChannelTLS *ioc, 205 227 QIOTaskFunc func, 206 228 gpointer opaque, 207 207 - GDestroyNotify destroy) 229 229 + GDestroyNotify destroy, 230 230 + GMainContext *context) 208 231 { 209 232 QIOTask *task; 210 233 ··· 212 235 func, opaque, destroy); 213 236 214 237 trace_qio_channel_tls_handshake_start(ioc); 215 215 - qio_channel_tls_handshake_task(ioc, task); 238 238 + qio_channel_tls_handshake_task(ioc, task, context); 216 239 } 217 240 218 241

+34 -6

io/channel.c

··· 299 299 klass->io_set_aio_fd_handler(ioc, ctx, io_read, io_write, opaque); 300 300 } 301 301 302 302 - guint qio_channel_add_watch(QIOChannel *ioc, 303 303 - GIOCondition condition, 304 304 - QIOChannelFunc func, 305 305 - gpointer user_data, 306 306 - GDestroyNotify notify) 302 302 + guint qio_channel_add_watch_full(QIOChannel *ioc, 303 303 + GIOCondition condition, 304 304 + QIOChannelFunc func, 305 305 + gpointer user_data, 306 306 + GDestroyNotify notify, 307 307 + GMainContext *context) 307 308 { 308 309 GSource *source; 309 310 guint id; ··· 312 313 313 314 g_source_set_callback(source, (GSourceFunc)func, user_data, notify); 314 315 315 315 - id = g_source_attach(source, NULL); 316 316 + id = g_source_attach(source, context); 316 317 g_source_unref(source); 317 318 318 319 return id; 320 320 + } 321 321 + 322 322 + guint qio_channel_add_watch(QIOChannel *ioc, 323 323 + GIOCondition condition, 324 324 + QIOChannelFunc func, 325 325 + gpointer user_data, 326 326 + GDestroyNotify notify) 327 327 + { 328 328 + return qio_channel_add_watch_full(ioc, condition, func, 329 329 + user_data, notify, NULL); 330 330 + } 331 331 + 332 332 + GSource *qio_channel_add_watch_source(QIOChannel *ioc, 333 333 + GIOCondition condition, 334 334 + QIOChannelFunc func, 335 335 + gpointer user_data, 336 336 + GDestroyNotify notify, 337 337 + GMainContext *context) 338 338 + { 339 339 + GSource *source; 340 340 + guint id; 341 341 + 342 342 + id = qio_channel_add_watch_full(ioc, condition, func, 343 343 + user_data, notify, context); 344 344 + source = g_main_context_find_source_by_id(context, id); 345 345 + g_source_ref(source); 346 346 + return source; 319 347 } 320 348 321 349

+2 -1

io/dns-resolver.c

··· 234 234 qio_task_run_in_thread(task, 235 235 qio_dns_resolver_lookup_worker, 236 236 data, 237 237 - qio_dns_resolver_lookup_data_free); 237 237 + qio_dns_resolver_lookup_data_free, 238 238 + NULL); 238 239 } 239 240 240 241

+36 -22

io/net-listener.c

··· 118 118 119 119 listener->sioc = g_renew(QIOChannelSocket *, listener->sioc, 120 120 listener->nsioc + 1); 121 121 - listener->io_tag = g_renew(gulong, listener->io_tag, listener->nsioc + 1); 121 121 + listener->io_source = g_renew(typeof(listener->io_source[0]), 122 122 + listener->io_source, 123 123 + listener->nsioc + 1); 122 124 listener->sioc[listener->nsioc] = sioc; 123 123 - listener->io_tag[listener->nsioc] = 0; 125 125 + listener->io_source[listener->nsioc] = NULL; 124 126 125 127 object_ref(OBJECT(sioc)); 126 128 listener->connected = true; 127 129 128 130 if (listener->io_func != NULL) { 129 131 object_ref(OBJECT(listener)); 130 130 - listener->io_tag[listener->nsioc] = qio_channel_add_watch( 132 132 + listener->io_source[listener->nsioc] = qio_channel_add_watch_source( 131 133 QIO_CHANNEL(listener->sioc[listener->nsioc]), G_IO_IN, 132 134 qio_net_listener_channel_func, 133 133 - listener, (GDestroyNotify)object_unref); 135 135 + listener, (GDestroyNotify)object_unref, NULL); 134 136 } 135 137 136 138 listener->nsioc++; 137 139 } 138 140 139 141 140 140 - void qio_net_listener_set_client_func(QIONetListener *listener, 141 141 - QIONetListenerClientFunc func, 142 142 - gpointer data, 143 143 - GDestroyNotify notify) 142 142 + void qio_net_listener_set_client_func_full(QIONetListener *listener, 143 143 + QIONetListenerClientFunc func, 144 144 + gpointer data, 145 145 + GDestroyNotify notify, 146 146 + GMainContext *context) 144 147 { 145 148 size_t i; 146 149 ··· 152 155 listener->io_notify = notify; 153 156 154 157 for (i = 0; i < listener->nsioc; i++) { 155 155 - if (listener->io_tag[i]) { 156 156 - g_source_remove(listener->io_tag[i]); 157 157 - listener->io_tag[i] = 0; 158 158 + if (listener->io_source[i]) { 159 159 + g_source_destroy(listener->io_source[i]); 160 160 + g_source_unref(listener->io_source[i]); 161 161 + listener->io_source[i] = NULL; 158 162 } 159 163 } 160 164 161 165 if (listener->io_func != NULL) { 162 166 for (i = 0; i < listener->nsioc; i++) { 163 167 object_ref(OBJECT(listener)); 164 164 - listener->io_tag[i] = qio_channel_add_watch( 168 168 + listener->io_source[i] = qio_channel_add_watch_source( 165 169 QIO_CHANNEL(listener->sioc[i]), G_IO_IN, 166 170 qio_net_listener_channel_func, 167 167 - listener, (GDestroyNotify)object_unref); 171 171 + listener, (GDestroyNotify)object_unref, context); 168 172 } 169 173 } 170 174 } 171 175 176 176 + void qio_net_listener_set_client_func(QIONetListener *listener, 177 177 + QIONetListenerClientFunc func, 178 178 + gpointer data, 179 179 + GDestroyNotify notify) 180 180 + { 181 181 + qio_net_listener_set_client_func_full(listener, func, data, 182 182 + notify, NULL); 183 183 + } 172 184 173 185 struct QIONetListenerClientWaitData { 174 186 QIOChannelSocket *sioc; ··· 211 223 size_t i; 212 224 213 225 for (i = 0; i < listener->nsioc; i++) { 214 214 - if (listener->io_tag[i]) { 215 215 - g_source_remove(listener->io_tag[i]); 216 216 - listener->io_tag[i] = 0; 226 226 + if (listener->io_source[i]) { 227 227 + g_source_destroy(listener->io_source[i]); 228 228 + g_source_unref(listener->io_source[i]); 229 229 + listener->io_source[i] = NULL; 217 230 } 218 231 } 219 232 ··· 241 254 if (listener->io_func != NULL) { 242 255 for (i = 0; i < listener->nsioc; i++) { 243 256 object_ref(OBJECT(listener)); 244 244 - listener->io_tag[i] = qio_channel_add_watch( 257 257 + listener->io_source[i] = qio_channel_add_watch_source( 245 258 QIO_CHANNEL(listener->sioc[i]), G_IO_IN, 246 259 qio_net_listener_channel_func, 247 247 - listener, (GDestroyNotify)object_unref); 260 260 + listener, (GDestroyNotify)object_unref, NULL); 248 261 } 249 262 } 250 263 ··· 260 273 } 261 274 262 275 for (i = 0; i < listener->nsioc; i++) { 263 263 - if (listener->io_tag[i]) { 264 264 - g_source_remove(listener->io_tag[i]); 265 265 - listener->io_tag[i] = 0; 276 276 + if (listener->io_source[i]) { 277 277 + g_source_destroy(listener->io_source[i]); 278 278 + g_source_unref(listener->io_source[i]); 279 279 + listener->io_source[i] = NULL; 266 280 } 267 281 qio_channel_close(QIO_CHANNEL(listener->sioc[i]), NULL); 268 282 } ··· 285 299 for (i = 0; i < listener->nsioc; i++) { 286 300 object_unref(OBJECT(listener->sioc[i])); 287 301 } 288 288 - g_free(listener->io_tag); 302 302 + g_free(listener->io_source); 289 303 g_free(listener->sioc); 290 304 g_free(listener->name); 291 305 }

+19 -3

io/task.c

··· 77 77 QIOTaskWorker worker; 78 78 gpointer opaque; 79 79 GDestroyNotify destroy; 80 80 + GMainContext *context; 80 81 }; 81 82 82 83 83 83 - static gboolean gio_task_thread_result(gpointer opaque) 84 84 + static gboolean qio_task_thread_result(gpointer opaque) 84 85 { 85 86 struct QIOTaskThreadData *data = opaque; 86 87 ··· 91 92 data->destroy(data->opaque); 92 93 } 93 94 95 95 + if (data->context) { 96 96 + g_main_context_unref(data->context); 97 97 + } 98 98 + 94 99 g_free(data); 95 100 96 101 return FALSE; ··· 100 105 static gpointer qio_task_thread_worker(gpointer opaque) 101 106 { 102 107 struct QIOTaskThreadData *data = opaque; 108 108 + GSource *idle; 103 109 104 110 trace_qio_task_thread_run(data->task); 105 111 data->worker(data->task, data->opaque); ··· 110 116 * the worker results 111 117 */ 112 118 trace_qio_task_thread_exit(data->task); 113 113 - g_idle_add(gio_task_thread_result, data); 119 119 + 120 120 + idle = g_idle_source_new(); 121 121 + g_source_set_callback(idle, qio_task_thread_result, data, NULL); 122 122 + g_source_attach(idle, data->context); 123 123 + 114 124 return NULL; 115 125 } 116 126 ··· 118 128 void qio_task_run_in_thread(QIOTask *task, 119 129 QIOTaskWorker worker, 120 130 gpointer opaque, 121 121 - GDestroyNotify destroy) 131 131 + GDestroyNotify destroy, 132 132 + GMainContext *context) 122 133 { 123 134 struct QIOTaskThreadData *data = g_new0(struct QIOTaskThreadData, 1); 124 135 QemuThread thread; 125 136 137 137 + if (context) { 138 138 + g_main_context_ref(context); 139 139 + } 140 140 + 126 141 data->task = task; 127 142 data->worker = worker; 128 143 data->opaque = opaque; 129 144 data->destroy = destroy; 145 145 + data->context = context; 130 146 131 147 trace_qio_task_thread_start(task, worker, opaque); 132 148 qemu_thread_create(&thread,

+2 -1

migration/socket.c

··· 103 103 saddr, 104 104 socket_outgoing_migration, 105 105 data, 106 106 - socket_connect_data_free); 106 106 + socket_connect_data_free, 107 107 + NULL); 107 108 qapi_free_SocketAddress(saddr); 108 109 } 109 110

+2

migration/tls.c

··· 105 105 qio_channel_tls_handshake(tioc, 106 106 migration_tls_incoming_handshake, 107 107 NULL, 108 108 + NULL, 108 109 NULL); 109 110 } 110 111 ··· 159 160 qio_channel_tls_handshake(tioc, 160 161 migration_tls_outgoing_handshake, 161 162 s, 163 163 + NULL, 162 164 NULL); 163 165 }

+1

nbd/client.c

··· 579 579 qio_channel_tls_handshake(tioc, 580 580 nbd_tls_handshake, 581 581 &data, 582 582 + NULL, 582 583 NULL); 583 584 584 585 if (!data.complete) {

+1

nbd/server.c

··· 599 599 qio_channel_tls_handshake(tioc, 600 600 nbd_tls_handshake, 601 601 &data, 602 602 + NULL, 602 603 NULL); 603 604 604 605 if (!data.complete) {

+2 -2

tests/test-io-channel-socket.c

··· 179 179 lioc = qio_channel_socket_new(); 180 180 qio_channel_socket_listen_async( 181 181 lioc, listen_addr, 182 182 - test_io_channel_complete, &data, NULL); 182 182 + test_io_channel_complete, &data, NULL, NULL); 183 183 184 184 g_main_loop_run(data.loop); 185 185 g_main_context_iteration(g_main_context_default(), FALSE); ··· 200 200 201 201 qio_channel_socket_connect_async( 202 202 QIO_CHANNEL_SOCKET(*src), connect_addr, 203 203 - test_io_channel_complete, &data, NULL); 203 203 + test_io_channel_complete, &data, NULL, NULL); 204 204 205 205 g_main_loop_run(data.loop); 206 206 g_main_context_iteration(g_main_context_default(), FALSE);

+2

tests/test-io-channel-tls.c

··· 203 203 qio_channel_tls_handshake(clientChanTLS, 204 204 test_tls_handshake_done, 205 205 &clientHandshake, 206 206 + NULL, 206 207 NULL); 207 208 qio_channel_tls_handshake(serverChanTLS, 208 209 test_tls_handshake_done, 209 210 &serverHandshake, 211 211 + NULL, 210 212 NULL); 211 213 212 214 /*

+2

tests/test-io-task.c

··· 187 187 qio_task_run_in_thread(task, 188 188 test_task_thread_worker, 189 189 &data, 190 190 + NULL, 190 191 NULL); 191 192 192 193 g_main_loop_run(data.loop); ··· 228 229 qio_task_run_in_thread(task, 229 230 test_task_thread_worker, 230 231 &data, 232 232 + NULL, 231 233 NULL); 232 234 233 235 g_main_loop_run(data.loop);

+1

ui/vnc-auth-vencrypt.c

··· 128 128 qio_channel_tls_handshake(tls, 129 129 vnc_tls_handshake_done, 130 130 vs, 131 131 + NULL, 131 132 NULL); 132 133 } 133 134 return 0;

+1

ui/vnc-ws.c

··· 81 81 qio_channel_tls_handshake(tls, 82 82 vncws_tls_handshake_done, 83 83 vs, 84 84 + NULL, 84 85 NULL); 85 86 86 87 return TRUE;