static gboolean gst_tcp_server_src_stop (GstBaseSrc * bsrc) { GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); GError *err = NULL; if (src->client_socket) { GST_DEBUG_OBJECT (src, "closing socket"); if (!g_socket_close (src->client_socket, &err)) { GST_ERROR_OBJECT (src, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_object_unref (src->client_socket); src->client_socket = NULL; } if (src->server_socket) { GST_DEBUG_OBJECT (src, "closing socket"); if (!g_socket_close (src->server_socket, &err)) { GST_ERROR_OBJECT (src, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_object_unref (src->server_socket); src->server_socket = NULL; } GST_OBJECT_FLAG_UNSET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; }
static gboolean fusion_tls_output_stream_real_close (GOutputStream* base, GCancellable* cancellable, GError** error) { FusionTLSOutputStream * self; gboolean result = FALSE; GError * _inner_error_ = NULL; self = (FusionTLSOutputStream*) base; { GSocket* _tmp0_ = NULL; _tmp0_ = self->priv->socket; g_socket_close (_tmp0_, &_inner_error_); if (_inner_error_ != NULL) { goto __catch5_g_error; } result = TRUE; return result; } goto __finally5; __catch5_g_error: { GError* e = NULL; e = _inner_error_; _inner_error_ = NULL; result = FALSE; _g_error_free0 (e); return result; } __finally5: g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return FALSE; }
void kms_sctp_connection_close (KmsSCTPConnection * conn) { GError *err = NULL; g_return_if_fail (conn != NULL); if (conn->socket == NULL) return; if (g_socket_is_closed (conn->socket)) { GST_DEBUG ("Socket is already closed"); return; } if (!g_socket_shutdown (conn->socket, TRUE, TRUE, &err)) { GST_DEBUG ("%s", err->message); g_clear_error (&err); } GST_DEBUG ("Closing socket"); if (!g_socket_close (conn->socket, &err)) { GST_ERROR ("Failed to close socket %p: %s", conn->socket, err->message); g_clear_error (&err); } }
static int remote_disconnect(void* connectiondata) { g_message("disconnecting remote socket"); GSocket* sock = (GSocket*) connectiondata; g_socket_close(sock, NULL); g_object_unref(sock); return 0; }
static void gst_net_client_clock_finalize (GObject * object) { GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object); if (self->priv->thread) { gst_net_client_clock_stop (self); } g_free (self->priv->address); self->priv->address = NULL; if (self->priv->servaddr != NULL) { g_object_unref (self->priv->servaddr); self->priv->servaddr = NULL; } if (self->priv->socket != NULL) { g_socket_close (self->priv->socket, NULL); g_object_unref (self->priv->socket); self->priv->socket = NULL; } G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gst_net_client_internal_clock_finalize (GObject * object) { GstNetClientInternalClock *self = GST_NET_CLIENT_INTERNAL_CLOCK (object); if (self->thread) { gst_net_client_internal_clock_stop (self); } g_free (self->address); self->address = NULL; if (self->servaddr != NULL) { g_object_unref (self->servaddr); self->servaddr = NULL; } if (self->socket != NULL) { if (!g_socket_close (self->socket, NULL)) GST_ERROR_OBJECT (self, "Failed to close socket"); g_object_unref (self->socket); self->socket = NULL; } g_warn_if_fail (self->busses == NULL); G_OBJECT_CLASS (gst_net_client_internal_clock_parent_class)->finalize (object); }
static void g_network_monitor_netlink_finalize (GObject *object) { GNetworkMonitorNetlink *nl = G_NETWORK_MONITOR_NETLINK (object); if (nl->priv->sock) { g_socket_close (nl->priv->sock, NULL); g_object_unref (nl->priv->sock); } if (nl->priv->source) { g_source_destroy (nl->priv->source); g_source_unref (nl->priv->source); } if (nl->priv->dump_source) { g_source_destroy (nl->priv->dump_source); g_source_unref (nl->priv->dump_source); } G_OBJECT_CLASS (g_network_monitor_netlink_parent_class)->finalize (object); }
static void gst_multiudpsink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMultiUDPSink *udpsink; udpsink = GST_MULTIUDPSINK (object); switch (prop_id) { case PROP_SOCKET: if (udpsink->socket != NULL && udpsink->socket != udpsink->used_socket && udpsink->close_socket) { GError *err = NULL; if (!g_socket_close (udpsink->socket, &err)) { GST_ERROR ("failed to close socket %p: %s", udpsink->socket, err->message); g_clear_error (&err); } } if (udpsink->socket) g_object_unref (udpsink->socket); udpsink->socket = g_value_dup_object (value); GST_DEBUG_OBJECT (udpsink, "setting socket to %p", udpsink->socket); break; case PROP_CLOSE_SOCKET: udpsink->close_socket = g_value_get_boolean (value); break; case PROP_CLIENTS: gst_multiudpsink_set_clients_string (udpsink, g_value_get_string (value)); break; case PROP_AUTO_MULTICAST: udpsink->auto_multicast = g_value_get_boolean (value); break; case PROP_TTL: udpsink->ttl = g_value_get_int (value); break; case PROP_TTL_MC: udpsink->ttl_mc = g_value_get_int (value); break; case PROP_LOOP: udpsink->loop = g_value_get_boolean (value); break; case PROP_QOS_DSCP: udpsink->qos_dscp = g_value_get_int (value); gst_multiudpsink_setup_qos_dscp (udpsink); break; case PROP_SEND_DUPLICATES: udpsink->send_duplicates = g_value_get_boolean (value); break; case PROP_BUFFER_SIZE: udpsink->buffer_size = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/* system or coroutine context */ static void channel_disconnect(SpiceChannel *channel) { spice_channel *c = SPICE_CHANNEL_GET_PRIVATE(channel); g_return_if_fail(c != NULL); if (c->state == SPICE_CHANNEL_STATE_UNCONNECTED) { return; } c->has_error = TRUE; /* break the loop */ if (c->connect_delayed_id) { g_source_remove(c->connect_delayed_id); c->connect_delayed_id = 0; } spice_openssl_verify_free(c->sslverify); c->sslverify = NULL; if (c->ssl) { SSL_free(c->ssl); c->ssl = NULL; } if (c->ctx) { SSL_CTX_free(c->ctx); c->ctx = NULL; } if (c->sock) { g_socket_close(c->sock, NULL); g_object_unref(c->sock); c->sock = NULL; } c->fd = -1; free(c->peer_msg); c->peer_msg = NULL; c->peer_pos = 0; if (c->xmit_buffer) { g_free(c->xmit_buffer); c->xmit_buffer = NULL; c->xmit_buffer_size = 0; c->xmit_buffer_capacity = 0; } g_array_set_size(c->remote_common_caps, 0); g_array_set_size(c->remote_caps, 0); g_array_set_size(c->common_caps, 0); g_array_set_size(c->caps, 0); if (c->state == SPICE_CHANNEL_STATE_READY) emit_main_context(channel, SPICE_CHANNEL_EVENT, SPICE_CHANNEL_CLOSED); c->state = SPICE_CHANNEL_STATE_UNCONNECTED; }
/** * gst_switch_server_output_client_socket_removed: * * Invoked when a client socket is removed on the output port. The socket * is required to be freed manually here. */ static void gst_switch_server_output_client_socket_removed (GstElement * element, GSocket * socket, GstSwitchServer * srv) { g_return_if_fail (G_IS_SOCKET (socket)); //INFO ("client-socket-removed: %d", g_socket_get_fd (socket)); g_socket_close (socket, NULL); }
/** * @param rec The GstRecorder instance. * @param element * @param socket * @memberof GstRecorder * * Invoked when the client socket on the encoding out port is closed. We need * to manually close the socket to avoid FD leaks. */ static void gst_recorder_client_socket_removed (GstElement * element, GSocket * socket, GstRecorder * rec) { g_return_if_fail (G_IS_SOCKET (socket)); INFO ("client-socket-removed: %d", g_socket_get_fd (socket)); g_socket_close (socket, NULL); }
//Bfoadcast ivy msgs to clients void broadcast_to_clients () { int i; if (uTCP) { //broadcast using tcp connection GError *error = NULL; for (i = 0; i < MAXCLIENT; i++) { if (ConnectedClients[i].used > 0) { GOutputStream * ostream = g_io_stream_get_output_stream (ConnectedClients[i].ClientTcpData); g_output_stream_write(ostream, ivybuffer, strlen(ivybuffer), NULL, &error); } } return; } i=0; for (i = 0; i < MAXCLIENT; i++) { if (ConnectedClients[i].used > 0) { //Send data GInetAddress *udpAddress; GSocketAddress *udpSocketAddress; GSocket *udpSocket; udpAddress = g_inet_address_new_from_string(ConnectedClients[i].client_ip); udpSocketAddress = g_inet_socket_address_new(udpAddress, udp_port); udpSocket = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, 17, NULL); if (g_socket_connect(udpSocket, udpSocketAddress, NULL, NULL) == FALSE) { printf("App Server: stg wrong with socket connect\n"); fflush(stdout); } if (g_socket_send(udpSocket, ivybuffer, strlen(ivybuffer) , NULL, NULL) < 0) { printf("App Server: stg wrong with send func\n"); fflush(stdout); } if (g_socket_close(udpSocket, NULL) == FALSE) { printf("App Server: stg wrong with socket close\n"); fflush(stdout); } //Unref objects g_object_unref(udpAddress); g_object_unref(udpSocketAddress); g_object_unref(udpSocket); } } }
static gboolean gst_multiudpsink_stop (GstBaseSink * bsink) { GstMultiUDPSink *udpsink; udpsink = GST_MULTIUDPSINK (bsink); if (udpsink->used_socket) { if (udpsink->close_socket || !udpsink->external_socket) { GError *err = NULL; if (!g_socket_close (udpsink->used_socket, &err)) { GST_ERROR_OBJECT (udpsink, "Failed to close socket: %s", err->message); g_clear_error (&err); } } g_object_unref (udpsink->used_socket); udpsink->used_socket = NULL; } if (udpsink->used_socket_v6) { if (udpsink->close_socket || !udpsink->external_socket) { GError *err = NULL; if (!g_socket_close (udpsink->used_socket_v6, &err)) { GST_ERROR_OBJECT (udpsink, "Failed to close socket: %s", err->message); g_clear_error (&err); } } g_object_unref (udpsink->used_socket_v6); udpsink->used_socket_v6 = NULL; } return TRUE; }
static void tear_down_mock_xdg_runtime_dir (void) { GError *error = NULL; g_socket_close (mock_bus, &error); g_assert_no_error (error); if (g_unlink (mock_bus_path) < 0) g_error ("g_unlink(\"%s\"): %s", mock_bus_path, g_strerror (errno)); if (g_rmdir (tmpdir) < 0) g_error ("g_rmdir(\"%s\"): %s", tmpdir, g_strerror (errno)); g_clear_object (&mock_bus); g_clear_pointer (&mock_bus_path, g_free); }
NiceSocket * nice_tcp_passive_socket_accept (NiceSocket *sock) { union { struct sockaddr_storage storage; struct sockaddr addr; } name; TcpPassivePriv *priv = sock->priv; GSocket *gsock = NULL; GSocketAddress *gaddr; NiceAddress remote_addr; NiceSocket *new_socket = NULL; gsock = g_socket_accept (sock->fileno, NULL, NULL); if (gsock == NULL) { return NULL; } /* GSocket: All socket file descriptors are set to be close-on-exec. */ g_socket_set_blocking (gsock, false); gaddr = g_socket_get_remote_address (gsock, NULL); if (gaddr == NULL || !g_socket_address_to_native (gaddr, &name.addr, sizeof (name), NULL)) { g_socket_close (gsock, NULL); g_object_unref (gsock); return NULL; } g_object_unref (gaddr); nice_address_set_from_sockaddr (&remote_addr, &name.addr); new_socket = nice_tcp_bsd_socket_new_from_gsock (priv->context, gsock, &sock->addr, &remote_addr, TRUE); g_object_unref (gsock); if (new_socket) { NiceAddress *key = nice_address_dup (&remote_addr); nice_socket_set_writable_callback (new_socket, _child_writable_cb, sock); g_hash_table_insert (priv->connections, key, new_socket); } return new_socket; }
GInetAddress *interface_getConfiguredAddress(struct node *n) { GInetAddress *ret = NULL; GSocket *s = n->ubnetd; if( s != NULL ){ if( g_socket_condition_check(s, G_IO_IN) & G_IO_IN ){ gchar buf[1]; g_socket_receive(s,buf,1,NULL,NULL); if( buf[0] == 'A' ) ret = n->netadr; g_socket_close(s, NULL); g_object_unref(s); n->ubnetd = NULL; } } return ret; }
/** * g_socket_listener_close: * @listener: a #GSocketListener * * Closes all the sockets in the listener. * * Since: 2.22 */ void g_socket_listener_close (GSocketListener *listener) { GSocket *socket; int i; g_return_if_fail (G_IS_SOCKET_LISTENER (listener)); if (listener->priv->closed) return; for (i = 0; i < listener->priv->sockets->len; i++) { socket = listener->priv->sockets->pdata[i]; g_socket_close (socket, NULL); } listener->priv->closed = TRUE; }
static void net_removeUDPSocket(struct node *n, guint classid) { GError *err = NULL; syslog(LOG_DEBUG,"net_removeSockets: Closing udp socket\n"); g_source_destroy(n->udpsockets[classid].source); g_source_unref(n->udpsockets[classid].source); //gboolean rc = g_socket_shutdown(n->udp, FALSE, FALSE, &err); gboolean rc = g_socket_close(n->udpsockets[classid].socket, &err); if( rc == TRUE ){ syslog(LOG_DEBUG,"success\n"); }else{ //TODO: log error syslog(LOG_WARNING, "error in g_socket_close: %s\n", err->message); g_error_free(err); } g_object_unref(n->udpsockets[classid].socket); }
static gboolean gst_udpsrc_close (GstUDPSrc * src) { GST_DEBUG ("closing sockets"); if (src->used_socket) { if (src->auto_multicast && g_inet_address_get_is_multicast (g_inet_socket_address_get_address (src->addr))) { GError *err = NULL; GST_DEBUG_OBJECT (src, "leaving multicast group %s", src->address); if (!g_socket_leave_multicast_group (src->used_socket, g_inet_socket_address_get_address (src->addr), FALSE, src->multi_iface, &err)) { GST_ERROR_OBJECT (src, "Failed to leave multicast group: %s", err->message); g_clear_error (&err); } } if (src->close_socket || !src->external_socket) { GError *err = NULL; if (!g_socket_close (src->used_socket, &err)) { GST_ERROR_OBJECT (src, "Failed to close socket: %s", err->message); g_clear_error (&err); } } g_object_unref (src->used_socket); src->used_socket = NULL; g_object_unref (src->addr); src->addr = NULL; } gst_udpsrc_reset_memory_allocator (src); gst_udpsrc_free_cancellable (src); return TRUE; }
static gboolean gst_udpsrc_stop (GstBaseSrc * bsrc) { GstUDPSrc *src; src = GST_UDPSRC (bsrc); GST_DEBUG ("stopping, closing sockets"); if (src->used_socket) { if (src->auto_multicast && g_inet_address_get_is_multicast (g_inet_socket_address_get_address (src->addr))) { GError *err = NULL; GST_DEBUG_OBJECT (src, "leaving multicast group %s", src->host); if (!g_socket_leave_multicast_group (src->used_socket, g_inet_socket_address_get_address (src->addr), FALSE, src->multi_iface, &err)) { GST_ERROR_OBJECT (src, "Failed to leave multicast group: %s", err->message); g_clear_error (&err); } } if (src->close_socket || !src->external_socket) { GError *err = NULL; if (!g_socket_close (src->used_socket, &err)) { GST_ERROR_OBJECT (src, "Failed to close socket: %s", err->message); g_clear_error (&err); } } g_object_unref (src->used_socket); src->used_socket = NULL; g_object_unref (src->addr); src->addr = NULL; } return TRUE; }
static void gst_sctp_base_sink_destroy_socket (GstSCTPBaseSink * self) { GError *err = NULL; if (!GST_OBJECT_FLAG_IS_SET (self, GST_SCTP_BASE_SINK_OPEN)) return; if (self->priv->socket != NULL) { GST_DEBUG_OBJECT (self, "closing socket"); if (!g_socket_close (self->priv->socket, &err)) { GST_ERROR_OBJECT (self, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_clear_object (&self->priv->socket); } GST_OBJECT_FLAG_UNSET (self, GST_SCTP_BASE_SINK_OPEN); }
gint interface_createAddress(struct node *n) //GInetAddress *addr) { GError * e = NULL; GInetAddress *lo = g_inet_address_new_loopback( G_SOCKET_FAMILY_IPV6); GSocketAddress *sa = g_inet_socket_address_new( lo, 42); GSocket *s = n->ubnetd; if( s != NULL ){ g_socket_close(s,NULL); g_object_unref(s); } s = g_socket_new(G_SOCKET_FAMILY_IPV6, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, &e); if( e != NULL ){ syslog(LOG_ERR,"interface_pushAddress: Error while creating socket: %s\n", e->message); g_error_free(e); return -1; } g_socket_connect(s, sa, NULL, &e); if( e != NULL ){ syslog(LOG_ERR,"interface_pushAddress: Error while connecting: %s\n", e->message); g_error_free(e); return -1; } g_socket_send(s,"A",1,NULL,NULL); gchar *bytes = (gchar*)g_inet_address_to_bytes(n->netadr); g_socket_send(s,bytes,16,NULL,NULL); n->ubnetd = s; //gchar buf[1]; //g_socket_receive(s,buf,1,NULL,NULL); return 0; }
static void gssdp_socket_source_dispose (GObject *object) { GSSDPSocketSource *self; self = GSSDP_SOCKET_SOURCE (object); if (self->priv->source != NULL) { g_source_unref (self->priv->source); g_source_destroy (self->priv->source); self->priv->source = NULL; } if (self->priv->socket != NULL) { g_socket_close (self->priv->socket, NULL); g_object_unref (self->priv->socket); self->priv->socket = NULL; } G_OBJECT_CLASS (gssdp_socket_source_parent_class)->dispose (object); }
static void g_socket_input_stream_finalize (GObject *object) { GSocketInputStreamX *stream = G_SOCKET_INPUT_STREAM (object); if (stream->priv->socket) { GError *error = NULL; /* g_print ("%s:%d: %s, %d\n", __FILE__, __LINE__, __FUNCTION__, g_socket_get_fd (stream->priv->socket)); */ g_socket_close (stream->priv->socket, &error); if (error) { //ERROR ("%s", error->message); } g_object_unref (stream->priv->socket); } if (G_OBJECT_CLASS (g_socket_input_stream_parent_class)->finalize) (*G_OBJECT_CLASS (g_socket_input_stream_parent_class)->finalize) (object); }
static void socket_close (NiceSocket *sock) { TcpPriv *priv = sock->priv; if (sock->fileno) { g_socket_close (sock->fileno, NULL); g_object_unref (sock->fileno); sock->fileno = NULL; } if (priv->io_source) { g_source_destroy (priv->io_source); g_source_unref (priv->io_source); } g_queue_foreach (&priv->send_queue, (GFunc) free_to_be_sent, NULL); g_queue_clear (&priv->send_queue); if (priv->context) g_main_context_unref (priv->context); g_slice_free(TcpPriv, sock->priv); }
static gboolean gst_tcp_mix_src_stop (GstTCPMixSrc * src, GstTCPMixSrcPad * pad) { GError *err = NULL; GList *item; GST_OBJECT_LOCK (src); GST_DEBUG_OBJECT (src, "Closing client sockets"); for (item = GST_ELEMENT_PADS (src); item; item = g_list_next (item)) { GstPad *p = GST_PAD (item->data); if (GST_PAD_IS_SRC (p)) { gst_tcp_mix_src_pad_reset (GST_TCP_MIX_SRC_PAD (p)); } } GST_OBJECT_UNLOCK (src); if (src->server_socket) { GST_DEBUG_OBJECT (src, "Closing server socket"); if (!g_socket_close (src->server_socket, &err)) { GST_ERROR_OBJECT (src, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_object_unref (src->server_socket); src->server_socket = NULL; gst_tcp_mix_src_stop_acceptor (src); g_atomic_int_set (&src->bound_port, 0); g_object_notify (G_OBJECT (src), "bound-port"); } GST_OBJECT_FLAG_UNSET (src, GST_TCP_MIX_SRC_OPEN); return TRUE; }
//Bfoadcast ivy msgs to clients void broadcast_to_clients () { int i; for (i = 0; i < MAXCLIENT; i++) { if (ConnectedClients[i].used > 0) { //Send data GInetAddress *udpAddress; GSocketAddress *udpSocketAddress; GSocket *udpSocket; udpAddress = g_inet_address_new_from_string(ConnectedClients[i].client_ip); udpSocketAddress = g_inet_socket_address_new(udpAddress, udp_port); udpSocket = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, 17, NULL); if (g_socket_connect(udpSocket, udpSocketAddress, NULL, NULL) == FALSE) { printf("App Server: stg wrong with socket connect\n"); fflush(stdout); } if (g_socket_send(udpSocket, ivybuffer, strlen(ivybuffer) , NULL, NULL) < 0) { printf("App Server: stg wrong with send func\n"); fflush(stdout); } if (g_socket_close(udpSocket, NULL) == FALSE) { printf("App Server: stg wrong with socket close\n"); fflush(stdout); } //Unref objects g_object_unref(udpAddress); g_object_unref(udpSocketAddress); g_object_unref(udpSocket); } } }
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; }
int main(void) { GSocket *sock; sock = create_socket(); committed = g_string_new(""); puts("Emacs-fcitx is ready."); while (TRUE) { GSource *source; GSocket *connection; GMainLoop *main_loop; if ((connection = g_socket_accept(sock, NULL, NULL)) == NULL) { perror("g_socket_accept"); exit(1); } puts("Opening connection."); client = fcitx_client_new(); g_signal_connect(client, "connected", G_CALLBACK(connect_cb), NULL); g_signal_connect(client, "disconnected", G_CALLBACK(destroy_cb), NULL); g_signal_connect(client, "enable-im", G_CALLBACK(enable_im_cb), NULL); g_signal_connect(client, "close-im", G_CALLBACK(close_im_cb), NULL); g_signal_connect(client, "forward-key", G_CALLBACK(forward_key_cb), NULL); g_signal_connect(client, "commit-string", G_CALLBACK(commit_string_cb), NULL); g_signal_connect(client, "update-client-side-ui", G_CALLBACK(update_client_side_ui_cb), connection); main_loop = g_main_loop_new(NULL, FALSE); source = g_socket_create_source( connection, (GIOCondition)(G_IO_IN | G_IO_HUP | G_IO_ERR), NULL); g_source_set_callback( source, (GSourceFunc)source_cb, main_loop, NULL); g_source_attach(source, NULL); g_main_loop_run(main_loop); puts("main loop finished."); g_socket_close(connection, NULL); g_object_unref(client); g_source_unref(source); g_object_unref(connection); g_main_loop_unref(main_loop); } g_object_unref(sock); g_string_free(committed, TRUE); return 0; }
static gboolean on_incoming_message (GSocket *socket, GIOCondition condition, gpointer user_data) { g_debug (G_STRLOC ": %s: socket fd:%d", G_STRFUNC, g_socket_get_fd (socket)); DasomIM *im = DASOM_IM (user_data); dasom_message_unref (im->result->reply); im->result->is_dispatched = TRUE; if (condition & (G_IO_HUP | G_IO_ERR)) { /* Because two GSource is created over one socket, * when G_IO_HUP | G_IO_ERR, callback can run two times. * the following code avoid that callback runs two times. */ GSource *source = g_main_current_source (); if (source == im->default_context_source) g_source_destroy (im->sockets_context_source); else if (source == im->sockets_context_source) g_source_destroy (im->default_context_source); if (!g_socket_is_closed (socket)) g_socket_close (socket, NULL); im->result->reply = NULL; g_critical (G_STRLOC ": %s: G_IO_HUP | G_IO_ERR", G_STRFUNC); return G_SOURCE_REMOVE; } DasomMessage *message; message = dasom_recv_message (socket); im->result->reply = message; gboolean retval; if (G_UNLIKELY (message == NULL)) { g_critical (G_STRLOC ": NULL message"); return G_SOURCE_CONTINUE; } switch (message->header->type) { /* reply */ case DASOM_MESSAGE_FILTER_EVENT_REPLY: case DASOM_MESSAGE_RESET_REPLY: case DASOM_MESSAGE_FOCUS_IN_REPLY: case DASOM_MESSAGE_FOCUS_OUT_REPLY: case DASOM_MESSAGE_SET_SURROUNDING_REPLY: case DASOM_MESSAGE_GET_SURROUNDING_REPLY: case DASOM_MESSAGE_SET_CURSOR_LOCATION_REPLY: case DASOM_MESSAGE_SET_USE_PREEDIT_REPLY: break; /* signals */ case DASOM_MESSAGE_PREEDIT_START: g_signal_emit_by_name (im, "preedit-start"); dasom_send_message (socket, DASOM_MESSAGE_PREEDIT_START_REPLY, NULL, 0, NULL); break; case DASOM_MESSAGE_PREEDIT_END: g_signal_emit_by_name (im, "preedit-end"); dasom_send_message (socket, DASOM_MESSAGE_PREEDIT_END_REPLY, NULL, 0, NULL); break; case DASOM_MESSAGE_PREEDIT_CHANGED: g_free (im->preedit_string); im->preedit_string = g_strndup (message->data, message->header->data_len - 1 - sizeof (gint)); im->cursor_pos = *(gint *) (message->data + message->header->data_len - sizeof (gint)); g_signal_emit_by_name (im, "preedit-changed"); dasom_send_message (socket, DASOM_MESSAGE_PREEDIT_CHANGED_REPLY, NULL, 0, NULL); break; case DASOM_MESSAGE_COMMIT: dasom_message_ref (message); g_signal_emit_by_name (im, "commit", (const gchar *) message->data); dasom_message_unref (message); dasom_send_message (socket, DASOM_MESSAGE_COMMIT_REPLY, NULL, 0, NULL); break; case DASOM_MESSAGE_RETRIEVE_SURROUNDING: g_signal_emit_by_name (im, "retrieve-surrounding", &retval); dasom_send_message (socket, DASOM_MESSAGE_RETRIEVE_SURROUNDING_REPLY, &retval, sizeof (gboolean), NULL); break; case DASOM_MESSAGE_DELETE_SURROUNDING: dasom_message_ref (message); g_signal_emit_by_name (im, "delete-surrounding", ((gint *) message->data)[0], ((gint *) message->data)[1], &retval); dasom_message_unref (message); dasom_send_message (socket, DASOM_MESSAGE_DELETE_SURROUNDING_REPLY, &retval, sizeof (gboolean), NULL); break; default: g_warning (G_STRLOC ": %s: Unknown message type: %d", G_STRFUNC, message->header->type); break; } return G_SOURCE_CONTINUE; }