static void tunnel_close (Tunnel *tunnel) { if (tunnel->cancellable) { g_cancellable_cancel (tunnel->cancellable); g_object_unref (tunnel->cancellable); } if (tunnel->client.iostream) { g_io_stream_close (tunnel->client.iostream, NULL, NULL); g_object_unref (tunnel->client.iostream); } if (tunnel->server.iostream) { g_io_stream_close (tunnel->server.iostream, NULL, NULL); g_object_unref (tunnel->server.iostream); } g_free (tunnel->client.buffer); g_free (tunnel->server.buffer); g_object_unref (tunnel->self); g_object_unref (tunnel->msg); g_free (tunnel); }
gboolean g_vfs_afp_connection_close (GVfsAfpConnection *afp_connection, GCancellable *cancellable, GError **error) { GVfsAfpConnectionPrivate *priv = afp_connection->priv; guint16 req_id; gboolean res; /* close DSI session */ req_id = get_request_id (afp_connection); res = send_request_sync (g_io_stream_get_output_stream (priv->conn), DSI_CLOSE_SESSION, req_id, 0, 0, NULL, cancellable, error); if (!res) { g_io_stream_close (priv->conn, cancellable, NULL); g_object_unref (priv->conn); return FALSE; } res = g_io_stream_close (priv->conn, cancellable, error); g_object_unref (priv->conn); return res; }
void codeslayer_utils_save_gobjects (GList *objects, const gchar *file_path, gpointer name, ...) { gchar *contents; GHashTable *table; va_list var_arg; GFile *file; file = g_file_new_for_path (file_path); if (!g_file_query_exists (file, NULL)) { GFileIOStream *stream; stream = g_file_create_readwrite (file, G_FILE_CREATE_NONE, NULL, NULL); if (g_io_stream_close (G_IO_STREAM (stream), NULL, NULL)) g_object_unref (stream); } va_start (var_arg, name); table = codeslayer_xml_create_hashtable (var_arg); va_end (var_arg); contents = codeslayer_xml_serialize_gobjects (objects, name, table); g_file_set_contents (file_path, contents, -1, NULL); g_object_unref (file); g_free (contents); codeslayer_xml_free_hashtable (table); }
static int gio_fclose (VFSFile * file) { FileData * data = vfs_get_handle (file); GError * error = 0; if (data->iostream) { g_io_stream_close (data->iostream, 0, & error); g_object_unref (data->iostream); CHECK_ERROR ("close", vfs_get_filename (file)); } else if (data->istream) { g_input_stream_close (data->istream, 0, & error); g_object_unref (data->istream); CHECK_ERROR ("close", vfs_get_filename (file)); } else if (data->ostream) { g_output_stream_close (data->ostream, 0, & error); g_object_unref (data->ostream); CHECK_ERROR ("close", vfs_get_filename (file)); } if (data->file) g_object_unref (data->file); return 0; FAILED: if (data->file) g_object_unref (data->file); return -1; }
static void synce_device_dispose (GObject *obj) { SynceDevice *self = SYNCE_DEVICE (obj); SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self); if (priv->dispose_has_run) return; priv->dispose_has_run = TRUE; #if USE_GDBUS if (priv->interface) { g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(priv->interface)); g_object_unref(priv->interface); } #endif g_io_stream_close(G_IO_STREAM(priv->conn), NULL, NULL); g_object_unref(priv->conn); #if HAVE_GUDEV g_object_unref(priv->gudev_client); #endif g_hash_table_destroy (priv->requests); if (G_OBJECT_CLASS (synce_device_parent_class)->dispose) G_OBJECT_CLASS (synce_device_parent_class)->dispose (obj); }
void closeFile(PlatformFileHandle& handle) { if (!isHandleValid(handle)) return; g_io_stream_close(G_IO_STREAM(handle), 0, 0); g_object_unref(handle); handle = invalidPlatformFileHandle; }
static void close_immediately (CockpitStream *self, const gchar *problem) { GError *error = NULL; GIOStream *io; if (self->priv->closed) return; if (problem) { g_free (self->priv->problem); self->priv->problem = g_strdup (problem); } if (self->priv->connecting) { cockpit_connectable_unref (self->priv->connecting); self->priv->connecting = NULL; } self->priv->closed = TRUE; g_debug ("%s: closing stream%s%s", self->priv->name, self->priv->problem ? ": " : "", self->priv->problem ? self->priv->problem : ""); if (self->priv->in_source) stop_input (self); if (self->priv->out_source) stop_output (self); if (self->priv->io) { io = self->priv->io; self->priv->io = NULL; if (self->priv->sig_accept_cert) { g_signal_handler_disconnect (io, self->priv->sig_accept_cert); self->priv->sig_accept_cert = 0; } g_io_stream_close (io, NULL, &error); if (error) { g_message ("%s: close failed: %s", self->priv->name, error->message); g_clear_error (&error); } g_object_unref (io); } g_debug ("%s: closed", self->priv->name); g_signal_emit (self, cockpit_stream_sig_close, 0, self->priv->problem); }
static VALUE rg_close(VALUE self, VALUE cancellable) { GError *error = NULL; if (!g_io_stream_close(_SELF(self), RVAL2GCANCELLABLE(cancellable), &error)) rbgio_raise_error(error); return self; }
void gspeechd_client_fail (GSpeechdClient *client) { g_assert(client); client->failed = TRUE; g_io_stream_close(G_IO_STREAM(client->connection), client->cancellable, NULL); }
static void g_io_stream_dispose (GObject *object) { GIOStream *stream; stream = G_IO_STREAM (object); if (!stream->priv->closed) g_io_stream_close (stream, NULL, NULL); G_OBJECT_CLASS (g_io_stream_parent_class)->dispose (object); }
char * ot_editor_prompt (OstreeRepo *repo, const char *input, GCancellable *cancellable, GError **error) { glnx_unref_object GSubprocess *proc = NULL; g_autoptr(GFile) file = NULL; g_autoptr(GFileIOStream) io = NULL; GOutputStream *output; const char *editor; char *ret = NULL; g_autofree char *args = NULL; editor = get_editor (); if (editor == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Terminal is dumb, but EDITOR unset"); goto out; } file = g_file_new_tmp (NULL, &io, error); if (file == NULL) goto out; output = g_io_stream_get_output_stream (G_IO_STREAM (io)); if (!g_output_stream_write_all (output, input, strlen (input), NULL, cancellable, error) || !g_io_stream_close (G_IO_STREAM (io), cancellable, error)) goto out; { g_autofree char *quoted_file = g_shell_quote (gs_file_get_path_cached (file)); args = g_strconcat (editor, " ", quoted_file, NULL); } proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDIN_INHERIT, error, "/bin/sh", "-c", args, NULL); if (!g_subprocess_wait_check (proc, cancellable, error)) { g_prefix_error (error, "There was a problem with the editor '%s'", editor); goto out; } ret = glnx_file_get_contents_utf8_at (AT_FDCWD, gs_file_get_path_cached (file), NULL, cancellable, error); out: if (file) (void )g_file_delete (file, NULL, NULL); return ret; }
static gboolean handle_set_icon_data_url (CockpitAccount *object, GDBusMethodInvocation *invocation, const gchar *arg_data) { GError *error = NULL; Account *acc = ACCOUNT (object); if (!account_auth_check (object, invocation, acc)) return TRUE; if (acc->u) { const gchar *base64_data = strstr (arg_data, "base64,"); if (base64_data == NULL) goto out; base64_data += strlen ("base64,"); gsize raw_size; gs_free gchar *raw_data = (gchar *)g_base64_decode (base64_data, &raw_size); gs_unref_object GFileIOStream *tmp_stream = NULL; gs_unref_object GFile *tmp_file = g_file_new_tmp ("cockpit-user-icon-XXXXXX", &tmp_stream, &error); if (tmp_file == NULL) goto out; GOutputStream *out = g_io_stream_get_output_stream (G_IO_STREAM (tmp_stream)); if (!g_output_stream_write_all (out, raw_data, raw_size, NULL, NULL, &error)) goto out; if (!g_io_stream_close (G_IO_STREAM (tmp_stream), NULL, &error)) goto out; gs_free gchar *tmp_path = g_file_get_path (tmp_file); act_user_set_icon_file (acc->u, tmp_path); g_file_delete (tmp_file, NULL, NULL); } out: if (error) { g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_clear_error (&error); } else cockpit_account_complete_set_icon_data_url (object, invocation); return TRUE; }
static gboolean kixmail_io_stream_close (GIOStream *stream, GCancellable *cancellable, GError **error) { KixmailIOStream *iostream = KIXMAIL_IO_STREAM (stream); if (iostream->priv->disposing && !iostream->priv->close_on_dispose) return TRUE; return g_io_stream_close (iostream->priv->base_iostream, cancellable, error); }
static void gegl_tile_backend_file_finalize (GObject *object) { GeglTileBackendFile *self = (GeglTileBackendFile *) object; if (self->index) g_hash_table_unref (self->index); if (self->exist) { GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "finalizing buffer %s", self->path); #if HAVE_GIO if (self->io) { g_io_stream_close (self->io, NULL, NULL); g_object_unref (self->io); self->io = NULL; } if (self->file) g_file_delete (self->file, NULL, NULL); #else if (self->i != -1) { close (self->i); self->i = -1; } if (self->o != -1) { close (self->o); self->o = -1; } #endif } if (self->path) g_free (self->path); #if HAVE_GIO if (self->monitor) g_object_unref (self->monitor); if (self->file) g_object_unref (self->file); #endif (*G_OBJECT_CLASS (parent_class)->finalize)(object); }
static void connectedCallback(GSocketClient* client, GAsyncResult* result, void* id) { // Always finish the connection, even if this SocketStreamHandle was deactivated earlier. GOwnPtr<GError> error; GSocketConnection* socketConnection = g_socket_client_connect_to_host_finish(client, result, &error.outPtr()); // The SocketStreamHandle has been deactivated, so just close the connection, ignoring errors. SocketStreamHandle* handle = getHandleFromId(id); if (!handle) { g_io_stream_close(G_IO_STREAM(socketConnection), 0, &error.outPtr()); return; } handle->connected(socketConnection, error.get()); }
static void jetdirect_connection_test_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GSocketConnection *connection; PpHostPrivate *priv; PpPrintDevice *device; JetDirectData *data; gpointer result; GError *error = NULL; GTask *task = G_TASK (user_data); data = g_task_get_task_data (task); connection = g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (source_object), res, &error); if (connection != NULL) { g_io_stream_close (G_IO_STREAM (connection), NULL, NULL); g_object_unref (connection); priv = data->host->priv; device = g_new0 (PpPrintDevice, 1); device->device_class = g_strdup ("network"); device->device_uri = g_strdup_printf ("socket://%s:%d", priv->hostname, data->port); /* Translators: The found device is a JetDirect printer */ device->device_name = g_strdup (_("JetDirect Printer")); device->host_name = g_strdup (priv->hostname); device->host_port = data->port; device->acquisition_method = ACQUISITION_METHOD_JETDIRECT; data->devices->devices = g_list_append (data->devices->devices, device); } result = data->devices; data->devices = NULL; g_task_return_pointer (task, result, (GDestroyNotify) pp_devices_list_free); g_object_unref (task); }
static void disconnect_internal (SoupSocket *sock, gboolean close) { SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); g_clear_object (&priv->gsock); if (priv->conn && close) g_io_stream_close (priv->conn, NULL, NULL); if (priv->read_src) { g_source_destroy (priv->read_src); priv->read_src = NULL; } if (priv->write_src) { g_source_destroy (priv->write_src); priv->write_src = NULL; } }
static void zpj_download_stream_ready (GObject *source, GAsyncResult *res, gpointer user_data) { GError *error = NULL; PdfLoadJob *job = (PdfLoadJob *) user_data; const gchar *name; const gchar *extension; job->stream = zpj_skydrive_download_file_to_stream_finish (ZPJ_SKYDRIVE (source), res, &error); if (error != NULL) { pdf_load_job_complete_error (job, error); return; } name = zpj_skydrive_entry_get_name (job->zpj_entry); extension = gd_filename_get_extension_offset (name); /* If it is not a PDF, we need to convert it afterwards. * http://msdn.microsoft.com/en-us/library/live/hh826545#fileformats */ if (g_strcmp0 (extension, ".pdf") != 0) { GFileIOStream *iostream; job->download_file = g_file_new_tmp (NULL, &iostream, &error); if (error != NULL) { pdf_load_job_complete_error (job, error); return; } /* We don't need the iostream. */ g_io_stream_close (G_IO_STREAM (iostream), NULL, NULL); } else job->download_file = g_file_new_for_path (job->pdf_path); g_file_replace_async (job->download_file, NULL, FALSE, G_FILE_CREATE_PRIVATE, G_PRIORITY_DEFAULT, job->cancellable, file_replace_ready_cb, job); }
void SocketStreamHandle::platformClose() { // We remove this handle from the active handles list first, to disable all callbacks. deactivateHandle(this); stopWaitingForSocketWritability(); if (m_socketConnection) { GOwnPtr<GError> error; g_io_stream_close(G_IO_STREAM(m_socketConnection.get()), 0, &error.outPtr()); if (error) m_client->didFail(this, SocketStreamError(error->code)); // FIXME: Provide a sensible error. m_socketConnection = 0; } m_outputStream = 0; m_inputStream = 0; delete m_readBuffer; m_client->didClose(this); }
void SocketStreamHandle::connectedCallback(GSocketClient* client, GAsyncResult* result, SocketStreamHandle* handle) { RefPtr<SocketStreamHandle> protectedThis = adoptRef(handle); // Always finish the connection, even if this SocketStreamHandle was cancelled earlier. GUniqueOutPtr<GError> error; GRefPtr<GSocketConnection> socketConnection = adoptGRef(g_socket_client_connect_to_host_finish(client, result, &error.outPtr())); // The SocketStreamHandle has been cancelled, so just close the connection, ignoring errors. if (g_cancellable_is_cancelled(handle->m_cancellable.get())) { if (socketConnection) g_io_stream_close(G_IO_STREAM(socketConnection.get()), nullptr, nullptr); return; } if (error) handle->didFail(SocketStreamError(error->code, error->message)); else handle->connected(WTFMove(socketConnection)); }
gchar* codeslayer_utils_get_file_path (const gchar *folder_path, const gchar *file_name) { gchar *file_path; GFile *file; file_path = g_build_filename (folder_path, file_name, NULL); file = g_file_new_for_path (file_path); if (!g_file_query_exists (file, NULL)) { GFileIOStream *stream; stream = g_file_create_readwrite (file, G_FILE_CREATE_NONE, NULL, NULL); g_io_stream_close (G_IO_STREAM (stream), NULL, NULL); g_object_unref (stream); } g_object_unref (file); return file_path; }
void SocketStreamHandle::platformClose() { LOG(Network, "SocketStreamHandle %p platformClose", this); // We cancel this handle first to disable all callbacks. g_cancellable_cancel(m_cancellable.get()); stopWaitingForSocketWritability(); if (m_socketConnection) { GUniqueOutPtr<GError> error; g_io_stream_close(G_IO_STREAM(m_socketConnection.get()), nullptr, &error.outPtr()); if (error) didFail(SocketStreamError(error->code, error->message)); m_socketConnection = nullptr; } m_outputStream = nullptr; m_inputStream = nullptr; m_readBuffer = nullptr; m_client.didCloseSocketStream(*this); }
void SocketStreamHandle::platformClose() { LOG(Network, "SocketStreamHandle %p platformClose", this); // We remove this handle from the active handles list first, to disable all callbacks. deactivateHandle(this); stopWaitingForSocketWritability(); if (m_socketConnection) { GUniqueOutPtr<GError> error; g_io_stream_close(G_IO_STREAM(m_socketConnection.get()), 0, &error.outPtr()); if (error) m_client->didFailSocketStream(this, SocketStreamError(error->code, error->message)); m_socketConnection = 0; } m_outputStream = 0; m_inputStream = 0; m_readBuffer = nullptr; m_client->didCloseSocketStream(this); }
static void handshake_cb (GObject *source, GAsyncResult *result, gpointer user_data) { TestConnectorServer *self = TEST_CONNECTOR_SERVER (user_data); TestConnectorServerPrivate *priv = self->priv; WockyTLSConnection *tls_conn; GError *error = NULL; DEBUG ("TLS/SSL handshake finished"); tls_conn = wocky_tls_session_handshake_finish ( WOCKY_TLS_SESSION (source), result, &error); if (server_dec_outstanding (self)) goto out; if (tls_conn == NULL) { DEBUG ("SSL or TLS Server Setup failed: %s", error->message); g_io_stream_close (priv->stream, NULL, NULL); goto out; } if (priv->conn != NULL) g_object_unref (priv->conn); priv->state = SERVER_STATE_START; priv->conn = wocky_xmpp_connection_new (G_IO_STREAM (tls_conn)); g_object_unref (tls_conn); priv->tls_started = TRUE; xmpp_init (NULL,NULL,self); out: if (error != NULL) g_error_free (error); }
/** * g_vfs_ftp_connection_enable_tls: * @conn: a connection without an active data connection * @server_identity: address of the server used to verify the certificate * @cb: callback called if there's a verification error * @user_data: user data passed to @cb * @cancellable: cancellable to interrupt wait * @error: %NULL or location to take a potential error * * Tries to enable TLS on the given @connection. If setting up TLS fails, * %FALSE will be returned and @error will be set. When this function fails, * you need to check if the connection is still usable. It might have been * closed. * * Returns: %TRUE on success, %FALSE otherwise. **/ gboolean g_vfs_ftp_connection_enable_tls (GVfsFtpConnection * conn, GSocketConnectable *server_identity, CertificateCallback cb, gpointer user_data, GCancellable * cancellable, GError ** error) { GIOStream *secure; g_return_val_if_fail (conn != NULL, FALSE); g_return_val_if_fail (conn->data == NULL, FALSE); g_return_val_if_fail (!conn->waiting_for_reply, FALSE); g_return_val_if_fail (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (conn->commands_in)) == 0, FALSE); secure = g_tls_client_connection_new (conn->commands, server_identity, error); if (secure == NULL) return FALSE; g_object_unref (conn->commands); conn->commands = secure; create_input_stream (conn); g_signal_connect (secure, "accept-certificate", G_CALLBACK (cb), user_data); if (!g_tls_connection_handshake (G_TLS_CONNECTION (secure), cancellable, error)) { /* Close here to be sure it won't get used anymore */ g_io_stream_close (secure, cancellable, NULL); return FALSE; } return TRUE; }
/** * g_vfs_ftp_connection_data_connection_enable_tls: * @conn: a connection with an active control connection * @server_identity: address of the server used to verify the certificate * @cb: callback called if there's a verification error * @user_data: user data passed to @cb * @cancellable: cancellable to interrupt wait * @error: %NULL or location to take a potential error * * Tries to enable TLS on the given @connection's data connection. If setting * up TLS fails, %FALSE will be returned and @error will be set. * * Returns: %TRUE on success, %FALSE otherwise. **/ gboolean g_vfs_ftp_connection_data_connection_enable_tls (GVfsFtpConnection *conn, GSocketConnectable *server_identity, CertificateCallback cb, gpointer user_data, GCancellable * cancellable, GError ** error) { GIOStream *secure; g_return_val_if_fail (conn != NULL, FALSE); g_return_val_if_fail (conn->commands != NULL, FALSE); secure = g_tls_client_connection_new (conn->data, server_identity, error); if (secure == NULL) return FALSE; g_object_unref (conn->data); conn->data = secure; g_tls_client_connection_copy_session_state (G_TLS_CLIENT_CONNECTION (secure), G_TLS_CLIENT_CONNECTION (conn->commands)); g_signal_connect (secure, "accept-certificate", G_CALLBACK (cb), user_data); if (!g_tls_connection_handshake (G_TLS_CONNECTION (secure), cancellable, error)) { /* Close here to be sure it won't get used anymore */ g_io_stream_close (secure, cancellable, NULL); return FALSE; } return TRUE; }
int main (int argc, char *argv[]) { GSocket *socket, *new_socket, *recv_socket; GSocketAddress *src_address; GSocketAddress *address; GSocketType socket_type; GSocketFamily socket_family; GError *error = NULL; GOptionContext *context; GCancellable *cancellable; char *display_addr; GTlsCertificate *tlscert = NULL; GIOStream *connection; GInputStream *istream; GOutputStream *ostream; g_type_init (); context = g_option_context_new (" - Test GSocket server stuff"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (unix_socket && argc != 2) { g_printerr ("%s: %s\n", argv[0], "Need to specify unix socket name"); return 1; } if (cancel_timeout) { GThread *thread; cancellable = g_cancellable_new (); thread = g_thread_new ("cancel", cancel_thread, cancellable); g_thread_unref (thread); } else { cancellable = NULL; } if (tls_cert_file) { if (use_udp) { g_printerr ("DTLS (TLS over UDP) is not supported"); return 1; } tlscert = g_tls_certificate_new_from_file (tls_cert_file, &error); if (!tlscert) { g_printerr ("Could not read server certificate '%s': %s\n", tls_cert_file, error->message); return 1; } } loop = g_main_loop_new (NULL, FALSE); if (use_udp) socket_type = G_SOCKET_TYPE_DATAGRAM; else socket_type = G_SOCKET_TYPE_STREAM; if (unix_socket) socket_family = G_SOCKET_FAMILY_UNIX; else socket_family = G_SOCKET_FAMILY_IPV4; socket = g_socket_new (socket_family, socket_type, 0, &error); if (socket == NULL) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (non_blocking) g_socket_set_blocking (socket, FALSE); if (unix_socket) { src_address = socket_address_from_string (argv[1]); if (src_address == NULL) { g_printerr ("%s: Could not parse '%s' as unix socket name\n", argv[0], argv[1]); return 1; } } else { src_address = g_inet_socket_address_new (g_inet_address_new_any (G_SOCKET_FAMILY_IPV4), port); } if (!g_socket_bind (socket, src_address, !dont_reuse_address, &error)) { g_printerr ("Can't bind socket: %s\n", error->message); return 1; } g_object_unref (src_address); if (!use_udp) { if (!g_socket_listen (socket, &error)) { g_printerr ("Can't listen on socket: %s\n", error->message); return 1; } address = g_socket_get_local_address (socket, &error); if (!address) { g_printerr ("Error getting local address: %s\n", error->message); return 1; } display_addr = socket_address_to_string (address); g_print ("listening on %s...\n", display_addr); g_free (display_addr); ensure_socket_condition (socket, G_IO_IN, cancellable); new_socket = g_socket_accept (socket, cancellable, &error); if (!new_socket) { g_printerr ("Error accepting socket: %s\n", error->message); return 1; } if (non_blocking) g_socket_set_blocking (new_socket, FALSE); if (read_timeout) g_socket_set_timeout (new_socket, read_timeout); address = g_socket_get_remote_address (new_socket, &error); if (!address) { g_printerr ("Error getting remote address: %s\n", error->message); return 1; } display_addr = socket_address_to_string (address); g_print ("got a new connection from %s\n", display_addr); g_free(display_addr); g_object_unref (address); recv_socket = new_socket; connection = G_IO_STREAM (g_socket_connection_factory_create_connection (recv_socket)); g_object_unref (new_socket); } else { recv_socket = socket; connection = NULL; } if (tlscert) { GIOStream *tls_conn; tls_conn = g_tls_server_connection_new (connection, tlscert, &error); if (!tls_conn) { g_printerr ("Could not create TLS connection: %s\n", error->message); return 1; } if (!g_tls_connection_handshake (G_TLS_CONNECTION (tls_conn), cancellable, &error)) { g_printerr ("Error during TLS handshake: %s\n", error->message); return 1; } g_object_unref (connection); connection = tls_conn; } if (connection) { istream = g_io_stream_get_input_stream (connection); ostream = g_io_stream_get_output_stream (connection); } else { g_assert (use_udp); istream = NULL; ostream = NULL; } while (TRUE) { gchar buffer[4096]; gssize size; gsize to_send; if (use_udp) { ensure_socket_condition (recv_socket, G_IO_IN, cancellable); size = g_socket_receive_from (recv_socket, &address, buffer, sizeof buffer, cancellable, &error); } else { ensure_connection_condition (connection, G_IO_IN, cancellable); size = g_input_stream_read (istream, buffer, sizeof buffer, cancellable, &error); } if (size < 0) { g_printerr ("Error receiving from socket: %s\n", error->message); return 1; } if (size == 0) break; g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size); if (use_udp) g_print (" from %s", socket_address_to_string (address)); g_print ("\n"); if (verbose) g_print ("-------------------------\n" "%.*s\n" "-------------------------\n", (int)size, buffer); to_send = size; #ifdef __QNXNTO__ if (delay_) #else if (delay) #endif { #ifdef __QNXNTO__ if (verbose) g_print ("delaying %d seconds before response\n", delay_); g_usleep (1000 * 1000 * delay_); #else if (verbose) g_print ("delaying %d seconds before response\n", delay); g_usleep (1000 * 1000 * delay); #endif } while (to_send > 0) { if (use_udp) { ensure_socket_condition (recv_socket, G_IO_OUT, cancellable); size = g_socket_send_to (recv_socket, address, buffer, to_send, cancellable, &error); } else { ensure_connection_condition (connection, G_IO_OUT, cancellable); size = g_output_stream_write (ostream, buffer, to_send, cancellable, &error); } if (size < 0) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_print ("socket send would block, handling\n"); g_error_free (error); error = NULL; continue; } else { g_printerr ("Error sending to socket: %s\n", error->message); return 1; } } g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size); if (size == 0) { g_printerr ("Unexpected short write\n"); return 1; } to_send -= size; } } g_print ("connection closed\n"); if (connection) { if (!g_io_stream_close (connection, NULL, &error)) { g_printerr ("Error closing connection stream: %s\n", error->message); return 1; } g_object_unref (connection); } if (!g_socket_close (socket, &error)) { g_printerr ("Error closing master socket: %s\n", error->message); return 1; } g_object_unref (socket); return 0; }
gboolean rpmostree_compose_builtin_sign (int argc, char **argv, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; GOptionContext *context = g_option_context_new ("- Use rpm-sign to sign an OSTree commit"); gs_unref_object GFile *repopath = NULL; gs_unref_object OstreeRepo *repo = NULL; gs_unref_object GFile *tmp_commitdata_file = NULL; gs_unref_object GFileIOStream *tmp_sig_stream = NULL; gs_unref_object GFile *tmp_sig_file = NULL; gs_unref_object GFileIOStream *tmp_commitdata_stream = NULL; GOutputStream *tmp_commitdata_output = NULL; gs_unref_object GInputStream *commit_data = NULL; gs_free char *checksum = NULL; gs_unref_variant GVariant *commit_variant = NULL; gs_unref_bytes GBytes *commit_bytes = NULL; if (!rpmostree_option_context_parse (context, option_entries, &argc, &argv, error)) goto out; if (!(opt_repo_path && opt_key_id && opt_rev)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Missing required argument"); goto out; } repopath = g_file_new_for_path (opt_repo_path); repo = ostree_repo_new (repopath); if (!ostree_repo_open (repo, cancellable, error)) goto out; if (!ostree_repo_resolve_rev (repo, opt_rev, FALSE, &checksum, error)) goto out; if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, checksum, &commit_variant, error)) goto out; commit_bytes = g_variant_get_data_as_bytes (commit_variant); commit_data = (GInputStream*)g_memory_input_stream_new_from_bytes (commit_bytes); tmp_commitdata_file = g_file_new_tmp ("tmpsigXXXXXX", &tmp_commitdata_stream, error); if (!tmp_commitdata_file) goto out; tmp_commitdata_output = (GOutputStream*)g_io_stream_get_output_stream ((GIOStream*)tmp_commitdata_stream); if (g_output_stream_splice ((GOutputStream*)tmp_commitdata_output, commit_data, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, cancellable, error) < 0) goto out; tmp_sig_file = g_file_new_tmp ("tmpsigoutXXXXXX", &tmp_sig_stream, error); if (!tmp_sig_file) goto out; (void) g_io_stream_close ((GIOStream*)tmp_sig_stream, NULL, NULL); if (!gs_subprocess_simple_run_sync (NULL, GS_SUBPROCESS_STREAM_DISPOSITION_NULL, cancellable, error, "rpm-sign", "--key", opt_key_id, "--detachsign", gs_file_get_path_cached (tmp_commitdata_file), "--output", gs_file_get_path_cached (tmp_sig_file), NULL)) goto out; { char *sigcontent = NULL; gsize len; gs_unref_bytes GBytes *sigbytes = NULL; if (!g_file_load_contents (tmp_sig_file, cancellable, &sigcontent, &len, NULL, error)) goto out; sigbytes = g_bytes_new_take (sigcontent, len); if (!ostree_repo_append_gpg_signature (repo, checksum, sigbytes, cancellable, error)) goto out; } g_print ("Successfully signed OSTree commit=%s with key=%s\n", checksum, opt_key_id); ret = TRUE; out: if (tmp_commitdata_file) (void) gs_file_unlink (tmp_commitdata_file, NULL, NULL); if (tmp_sig_file) (void) gs_file_unlink (tmp_sig_file, NULL, NULL); return ret; }
static void _pp_host_get_lpd_devices_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { GSocketConnection *connection; PpPrintDevice *device; PpHost *host = (PpHost *) source_object; PpHostPrivate *priv = host->priv; GSocketClient *client; PpDevicesList *result; GSDData *data = (GSDData *) task_data; GError *error = NULL; GList *candidates = NULL; GList *iter; gchar *found_queue = NULL; gchar *candidate; gchar *address; gint port; gint i; if (priv->port == PP_HOST_UNSET_PORT) port = PP_HOST_DEFAULT_LPD_PORT; else port = priv->port; address = g_strdup_printf ("%s:%d", priv->hostname, port); if (address == NULL || address[0] == '/') goto out; result = data->devices; data->devices = NULL; client = g_socket_client_new (); connection = g_socket_client_connect_to_host (client, address, port, cancellable, &error); if (connection != NULL) { g_io_stream_close (G_IO_STREAM (connection), NULL, NULL); g_object_unref (connection); /* Most of this list is taken from system-config-printer */ candidates = g_list_append (candidates, g_strdup ("PASSTHRU")); candidates = g_list_append (candidates, g_strdup ("AUTO")); candidates = g_list_append (candidates, g_strdup ("BINPS")); candidates = g_list_append (candidates, g_strdup ("RAW")); candidates = g_list_append (candidates, g_strdup ("TEXT")); candidates = g_list_append (candidates, g_strdup ("ps")); candidates = g_list_append (candidates, g_strdup ("lp")); candidates = g_list_append (candidates, g_strdup ("PORT1")); for (i = 0; i < 8; i++) { candidates = g_list_append (candidates, g_strdup_printf ("LPT%d", i)); candidates = g_list_append (candidates, g_strdup_printf ("LPT%d_PASSTHRU", i)); candidates = g_list_append (candidates, g_strdup_printf ("COM%d", i)); candidates = g_list_append (candidates, g_strdup_printf ("COM%d_PASSTHRU", i)); } for (i = 0; i < 50; i++) candidates = g_list_append (candidates, g_strdup_printf ("pr%d", i)); for (iter = candidates; iter != NULL; iter = iter->next) { candidate = (gchar *) iter->data; if (test_lpd_queue (client, address, port, cancellable, candidate)) { found_queue = g_strdup (candidate); break; } } if (found_queue != NULL) { device = g_new0 (PpPrintDevice, 1); device->device_class = g_strdup ("network"); device->device_uri = g_strdup_printf ("lpd://%s:%d/%s", priv->hostname, port, found_queue); /* Translators: The found device is a Line Printer Daemon printer */ device->device_name = g_strdup (_("LPD Printer")); device->host_name = g_strdup (priv->hostname); device->host_port = port; device->acquisition_method = ACQUISITION_METHOD_LPD; result->devices = g_list_append (result->devices, device); } g_list_free_full (candidates, g_free); } g_object_unref (client); out: g_task_return_pointer (task, result, (GDestroyNotify) pp_devices_list_free); g_object_unref (task); g_free (address); }
int main (int argc, char *argv[]) { GOptionContext *context; GSocketClient *client; GSocketConnection *connection; GSocketAddress *address; GCancellable *cancellable; GOutputStream *out; GError *error = NULL; char buffer[1000]; g_type_init (); context = g_option_context_new (" <hostname>[:port] - send data to tcp host"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (argc != 2) { g_printerr ("%s: %s\n", argv[0], "Need to specify hostname"); return 1; } if (async) loop = g_main_loop_new (NULL, FALSE); if (cancel_timeout) { GThread *thread; cancellable = g_cancellable_new (); thread = g_thread_new ("cancel", cancel_thread, cancellable); g_thread_unref (thread); } else { cancellable = NULL; } client = g_socket_client_new (); if (io_timeout) g_socket_client_set_timeout (client, io_timeout); if (verbose) g_signal_connect (client, "event", G_CALLBACK (socket_client_event), NULL); if (async) { GAsyncResult *res; g_socket_client_connect_to_host_async (client, argv[1], 7777, cancellable, async_cb, &res); g_main_loop_run (loop); connection = g_socket_client_connect_to_host_finish (client, res, &error); g_object_unref (res); } else { connection = g_socket_client_connect_to_host (client, argv[1], 7777, cancellable, &error); } if (connection == NULL) { g_printerr ("%s can't connect: %s\n", argv[0], error->message); return 1; } g_object_unref (client); address = g_socket_connection_get_remote_address (connection, &error); if (!address) { g_printerr ("Error getting remote address: %s\n", error->message); return 1; } g_print ("Connected to address: %s\n", socket_address_to_string (address)); g_object_unref (address); if (graceful) g_tcp_connection_set_graceful_disconnect (G_TCP_CONNECTION (connection), TRUE); out = g_io_stream_get_output_stream (G_IO_STREAM (connection)); while (fgets(buffer, sizeof (buffer), stdin) != NULL) { /* FIXME if (async) */ if (!g_output_stream_write_all (out, buffer, strlen (buffer), NULL, cancellable, &error)) { g_warning ("send error: %s\n", error->message); g_error_free (error); error = NULL; } } g_print ("closing stream\n"); if (async) { GAsyncResult *res; g_io_stream_close_async (G_IO_STREAM (connection), 0, cancellable, async_cb, &res); g_main_loop_run (loop); if (!g_io_stream_close_finish (G_IO_STREAM (connection), res, &error)) { g_object_unref (res); g_warning ("close error: %s\n", error->message); return 1; } g_object_unref (res); } else { if (!g_io_stream_close (G_IO_STREAM (connection), cancellable, &error)) { g_warning ("close error: %s\n", error->message); return 1; } } g_object_unref (connection); return 0; }