//------------------------------------------------------------------------------ int main(int argc, char *argv[]) { GMainLoop *loop; GError * err = NULL; // Sensors Sensors s; s.scan(); // Bluetooth scan // Bluetooth b; b.scan(); #if 0 GIOChannel *channel = g_io_channel_unix_new(b.Handle()); g_io_add_watch(channel, (GIOCondition)(G_IO_IN | G_IO_OUT | G_IO_ERR | G_IO_HUP), onEvent, channel); #endif //b.close(); // socket server // GSocketService * server = g_socket_service_new(); g_socket_listener_add_inet_port((GSocketListener*)server, PORT, NULL, &err); if (err != NULL) { g_error("ERROR: %s", err->message); } g_signal_connect (server, "incoming", G_CALLBACK(onConnection), NULL); g_socket_service_start(server); // mainloop and timer // loop = g_main_loop_new ( NULL , FALSE ); g_timeout_add (5000 , OnTimer , loop); g_main_loop_run (loop); g_main_loop_unref(loop); return 0; }
/** * @brief Function that will listen for new connections to the server sockets. * * This creates a g_socket_listener and will loop waiting for new connections until * the scheduler is closed. * * @param scheduler Relevant scheduler structure * @return (void*)0 on failure, (void*)1 on success */ void* interface_listen_thread(scheduler_t* scheduler) { GSocketListener* server_socket; GSocketConnection* new_connection; GError* error = NULL; /* validate new thread */ if(scheduler->i_terminate || !scheduler->i_created) { ERROR("Could not create server socket thread\n"); return (void*)0; } /* create the server socket to listen for connections on */ server_socket = g_socket_listener_new(); if(server_socket == NULL) FATAL("could not create the server socket"); g_socket_listener_add_inet_port(server_socket, scheduler->i_port, NULL, &error); if(error) FATAL("[port:%d]: %s", scheduler->i_port, error->message); scheduler->cancel = g_cancellable_new(); V_INTERFACE("INTERFACE: listening port is %d\n", scheduler->i_port); /* wait for new connections */ for(;;) { new_connection = g_socket_listener_accept(server_socket, NULL, scheduler->cancel, &error); if(scheduler->i_terminate) break; V_INTERFACE("INTERFACE: new interface connection\n"); if(error) FATAL("INTERFACE closing for %s", error->message); interface_conn_init(new_connection, scheduler->workers); } V_INTERFACE("INTERFACE: socket listening thread closing\n"); g_socket_listener_close(server_socket); g_object_unref(server_socket); return (void*)1; }
int main (int argc, char **argv) { gtk_init_check(&argc, &argv); GMainLoop *loop; loop = g_main_loop_new(NULL, TRUE); GtkListStore *store_library = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT); GSocketListener *listener; GSocketListener *listener_next_song; GSocketListener *listener_quit; gsize i; listener = g_socket_listener_new(); listener_next_song = g_socket_listener_new(); listener_quit = g_socket_listener_new(); g_socket_listener_add_inet_port(listener_next_song, 12512, NULL, NULL); g_socket_listener_add_inet_port(listener, 1292, NULL, NULL); g_socket_listener_add_inet_port(listener_quit, 11912, NULL, NULL); g_socket_listener_accept_async(listener, NULL, lllp_connected_cb, store_library); g_socket_listener_accept_async(listener_next_song, NULL, lllp_next_song_cb, store_library); g_socket_listener_accept_async(listener_quit, NULL, lllp_quit_cb, store_library); // g_timeout_add(4000, test, lllp_array); gtk_main(); return 0; }
void cortrol_service_init() { GError * error = NULL; control_service_data.cmd_buf = NULL; /* create the new socketservice */ control_service_data.service = g_socket_service_new (); /* connect to the port */ g_socket_listener_add_inet_port ((GSocketListener*)control_service_data.service, CONTROL_PORT, NULL, &error); /* don't forget to check for errors */ if (error != NULL) { g_error ("%s", error->message); } /* listen to the 'incoming' signal */ g_signal_connect (control_service_data.service, "incoming", G_CALLBACK (incoming_callback), NULL); /* start the socket service */ g_socket_service_start (control_service_data.service); /* enter mainloop */ g_print ("Waiting for client!\n"); }
GLibJsonRpcServer *glib_jsonrpc_server_new(int port) { GLibJsonRpcServerPrivate *jsonrpc_server = g_new0(GLibJsonRpcServerPrivate, 1); GError *error = NULL; jsonrpc_server->service = g_threaded_socket_service_new (10); jsonrpc_server->async_busy = FALSE; jsonrpc_server->allow_non_loopback_connections = FALSE; if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (jsonrpc_server->service), port, NULL, &error)) { // Silently ignore failed servers and return a NULL server. // g_printerr ("%s\n", error->message); g_error_free(error); g_free(jsonrpc_server); return NULL; } g_signal_connect (jsonrpc_server->service, "run", G_CALLBACK (handler), jsonrpc_server); jsonrpc_server->command_hash = g_hash_table_new(g_str_hash, g_str_equal); return (GLibJsonRpcServer*)jsonrpc_server; }
static void identd_start_server (void) { GError *error = NULL; int enabled, port = 113; if (hextor_get_prefs (ph, "identd", NULL, &enabled) == 3) { if (!enabled) return; } if (hextor_get_prefs (ph, "identd_port", NULL, &port) == 2 && (port <= 0 || port > G_MAXUINT16)) { port = 113; } service = g_socket_service_new (); g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service), port, NULL, &error); if (error) { hextor_printf (ph, _("*\tError starting identd server: %s"), error->message); g_object_unref (service); service = NULL; return; } /*hextor_printf (ph, "*\tIdentd listening on port: %d", port); */ g_signal_connect (G_OBJECT (service), "incoming", G_CALLBACK(identd_incoming_cb), NULL); g_socket_service_start (service); }
int main (int argc, char *argv[]) { GSocketService *service; GOptionContext *context; GError *error = NULL; 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; } service = g_threaded_socket_service_new (10); if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service), port, NULL, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } g_print ("Echo service listening on port %d\n", port); g_signal_connect (service, "run", G_CALLBACK (handler), NULL); g_main_loop_run (g_main_loop_new (NULL, FALSE)); g_assert_not_reached (); }
void start(Server* server) { GError * error = NULL; GSocketService * service = g_socket_service_new(); g_socket_listener_add_inet_port((GSocketListener*)service, server->port, /* your port goes here */ NULL, &error); if (error != NULL) { g_error(error->message); } g_signal_connect(service, "incoming", G_CALLBACK(incoming_callback), NULL); g_socket_service_start (service); }
gboolean xr_server_bind(xr_server* server, const char* bind_addr, GError** err) { GError* local_err = NULL; char* addr = NULL; int port = 0; xr_trace(XR_DEBUG_SERVER_TRACE, "(server=%p, bind_addr=%s, err=%p)", server, bind_addr, err); g_return_val_if_fail(server != NULL, FALSE); g_return_val_if_fail(bind_addr != NULL, FALSE); g_return_val_if_fail(err == NULL || *err == NULL, FALSE); g_return_val_if_fail(_parse_addr(bind_addr, &addr, &port), FALSE); if (addr[0] == '*') { g_socket_listener_add_inet_port(G_SOCKET_LISTENER(server->service), (guint16)port, NULL, &local_err); } else { // build address GInetAddress* iaddr = g_inet_address_new_from_string(addr); if (!iaddr) { g_error_new(XR_SERVER_ERROR, XR_SERVER_ERROR_FAILED, "Invalid address: %s", bind_addr); g_free(addr); xr_server_stop(server); return FALSE; } GSocketAddress* isaddr = g_inet_socket_address_new(iaddr, (guint16)port); g_socket_listener_add_address(G_SOCKET_LISTENER(server->service), isaddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &local_err); } g_free(addr); if (local_err) { g_propagate_prefixed_error(err, local_err, "Port listen failed: "); xr_server_stop(server); return FALSE; } return TRUE; }
void ArvfbInit(void) { GError * error = NULL; gboolean isOK; ArPortType port = 8000; /* create the new socketservice */ pGSocketService = g_socket_service_new (); do{ /* connect to the port */ isOK = g_socket_listener_add_inet_port ((GSocketListener*)pGSocketService, port, NULL, &error); }while((isOK!=TRUE) && (port<9000)); /* don't forget to check for errors */ if (error != NULL) { Arch_Trace("VFB: Init Error <%s>\n!",error->message); //g_error (error->message); } else { Arch_Trace("VFB: Listener on localhost:%d\n",port); } /* listen to the 'incoming' signal */ g_signal_connect (pGSocketService, "incoming", G_CALLBACK (arvfb_incoming_callback), NULL); /* start the socket service */ g_socket_service_start (pGSocketService); }
static void gum_duk_debug_server_on_message (const gchar * message, GumDukDebugServer * self) { g_print ("<<< %s\n", message); if (g_str_has_prefix (message, "EMIT ")) { guint id; gchar * end; GumDukDebugChannel * channel; guchar * data; gsize size; GBytes * bytes; id = (guint) g_ascii_strtoull (message + 5, &end, 10); g_assert (end != message + 5); channel = g_hash_table_lookup (self->channels, GSIZE_TO_POINTER (id)); if (channel == NULL) return; data = g_base64_decode (end + 1, &size); bytes = g_bytes_new_take (data, size); gum_duk_debug_channel_broadcast (channel, bytes); g_bytes_unref (bytes); } else if (g_str_has_prefix (message, "SYNC\n")) { guint script_index; gchar ** tokens, ** token; script_index = 0; tokens = g_strsplit (message + 5, "\n", -1); for (token = tokens; *token != NULL; token++) { gchar * line = *token; GumDukDebugChannel * channel; gchar * end; gboolean port_available; channel = g_object_new (GUM_DUK_TYPE_DEBUG_CHANNEL, NULL); channel->id = (guint) g_ascii_strtoull (line, &end, 10); g_assert (end != line); channel->name = g_strdup (end + 1); channel->server = self; g_hash_table_insert (self->channels, GSIZE_TO_POINTER (channel->id), channel); port_available = g_socket_listener_add_inet_port ( G_SOCKET_LISTENER (self->service), self->base_port + script_index, G_OBJECT (channel), NULL); g_assert (port_available); script_index++; } g_strfreev (tokens); } else if (g_str_has_prefix (message, "ADD ")) { /* TODO: once our test exposes this */ } else if (g_str_has_prefix (message, "REMOVE ")) { /* TODO: once our test exposes this */ } else if (g_str_has_prefix (message, "DETACH ")) { guint id; gchar * end; GumDukDebugChannel * channel; id = (guint) g_ascii_strtoull (message + 7, &end, 10); g_assert (end != message + 7); channel = g_hash_table_lookup (self->channels, GSIZE_TO_POINTER (id)); if (channel == NULL) return; channel->attached = FALSE; gum_duk_debug_channel_remove_all_sessions (channel); } else { g_assert_not_reached (); } }
static gboolean cockpit_web_server_initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { CockpitWebServer *server = COCKPIT_WEB_SERVER (initable); gboolean ret = FALSE; gboolean failed = FALSE; int n, fd; server->socket_service = g_socket_service_new (); n = sd_listen_fds (0); if (n > 0) { /* We got file descriptors passed in, use those. */ for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) { GSocket *s = NULL; gboolean b; int type; socklen_t l = sizeof (type); /* * HACK: Workaround g_error() happy code in GSocket * https://bugzilla.gnome.org/show_bug.cgi?id=746339 */ if (getsockopt (fd, SOL_SOCKET, SO_TYPE, &type, &l) < 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "invalid socket passed via systemd activation: %d: %s", fd, g_strerror (errno)); goto out; } s = g_socket_new_from_fd (fd, error); if (s == NULL) { g_prefix_error (error, "Failed to acquire passed socket %i: ", fd); goto out; } b = cockpit_web_server_add_socket (server, s, error); g_object_unref (s); if (!b) { g_prefix_error (error, "Failed to add listener for socket %i: ", fd); goto out; } } server->socket_activated = TRUE; } else { /* No fds passed in, let's listen on our own. */ if (server->port == 0) { server->port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (server->socket_service), NULL, error); failed = (server->port == 0); } else if (server->port > 0) { failed = !g_socket_listener_add_inet_port (G_SOCKET_LISTENER (server->socket_service), server->port, NULL, error); } if (failed) { g_prefix_error (error, "Failed to bind to port %d: ", server->port); goto out; } } g_signal_connect (server->socket_service, "incoming", G_CALLBACK (on_incoming), server); ret = TRUE; out: return ret; }
static gboolean cockpit_web_server_initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { CockpitWebServer *server = COCKPIT_WEB_SERVER (initable); gboolean ret = FALSE; gboolean failed; int n, fd; server->socket_service = g_socket_service_new (); n = sd_listen_fds (0); if (n > 0) { /* We got file descriptors passed in, use those. */ for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) { GSocket *s = NULL; gboolean b; s = g_socket_new_from_fd (fd, error); if (s == NULL) { g_prefix_error (error, "Failed to acquire passed socket %i: ", fd); goto out; } b = g_socket_listener_add_socket (G_SOCKET_LISTENER (server->socket_service), s, NULL, error); g_object_unref (s); if (!b) { g_prefix_error (error, "Failed to add listener for socket %i: ", fd); goto out; } } server->socket_activated = TRUE; } else { /* No fds passed in, let's listen on our own. */ if (server->port == 0) { server->port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (server->socket_service), NULL, error); failed = (server->port == 0); } else { failed = !g_socket_listener_add_inet_port (G_SOCKET_LISTENER (server->socket_service), server->port, NULL, error); } if (failed) { g_prefix_error (error, "Failed to bind to port %d: ", server->port); goto out; } } g_signal_connect (server->socket_service, "incoming", G_CALLBACK (on_incoming), server); ret = TRUE; out: return ret; }
int main(int argc, char *argv[]) { GMainLoop* main_loop; GSocketService* socket; GError* error = NULL; GstBus *bus; guint bus_watch_id; config_t * conf; video_server_t* server; guint major = glib_major_version; guint minor = glib_minor_version; guint micro = glib_micro_version; guint nano = 0; fprintf(stderr, "Glib version %d.%d.%d\n", major, minor, micro); /* initialise gsatreamer */ gst_init(&argc, &argv); gst_version(&major, &minor, µ, &nano); fprintf(stderr, "GStreamer version %d.%d.%d (%d)\n", major, minor, micro, nano); conf = config_create(argc, argv); server = video_server_create(conf); main_loop = g_main_loop_new (NULL, FALSE); g_unix_signal_add(SIGHUP, signal_handler, main_loop); g_unix_signal_add(SIGTERM, signal_handler, main_loop); g_unix_signal_add(SIGINT, signal_handler, main_loop); /* Message handler */ bus = gst_pipeline_get_bus(GST_PIPELINE(server->pipeline)); bus_watch_id = gst_bus_add_watch(bus, bus_cb, main_loop); gst_object_unref(bus); /* command socket */ socket = g_socket_service_new(); g_socket_listener_add_inet_port((GSocketListener *) socket, conf->cmd_port, NULL, &error); if (error != NULL) fprintf(stderr, "%s\n", error->message); g_signal_connect(socket, "incoming", G_CALLBACK(socket_callback), server); g_socket_service_start(socket); /* Set the pipeline to "playing" state */ fprintf(stderr, "Video server playing\n"); gst_element_set_state(server->pipeline, GST_STATE_PLAYING); /* Iterate */ fprintf(stderr, "Running...\n"); g_main_loop_run(main_loop); /* Stop */ fprintf(stderr, "Stopping video server\n"); gst_element_set_state(server->pipeline, GST_STATE_NULL); fprintf(stderr, "Deleting pipeline\n"); video_server_delete(server); g_source_remove(bus_watch_id); g_main_loop_unref(main_loop); return 0; }
void* RendStreamer::run() { cout << "rendstreamer started " << endl; gchar * description=(gchar *) g_malloc(1000); g_sprintf(description, //"webmmux name=stream appsrc name=mysrc ! video/x-raw,format=RGB,width=%d,height=%d,framerate=20/1 ! videoconvert ! vp8enc ! stream.", "webmmux name=stream appsrc name=mysrc ! video/x-raw,format=RGB,width=%d,height=%d,framerate=5/1 ! videoconvert ! vp8enc ! stream.", this->pconf->width,this->pconf->height); gint argc=0; gst_init (&argc, NULL); GError *err = NULL; GstElement * bin = gst_parse_launch (description, &err); g_free(description); if ( (!bin) || (err)) { g_print ("invalid pipeline: %s\n", err->message); g_clear_error (&err); exit(-2); } multisocketsink = gst_element_factory_make ("multisocketsink", NULL); printf("parsed %d, %d\n",this->pconf->width,this->pconf->height); /* setup appsrc */ GstElement *appsrc = gst_bin_get_by_name (GST_BIN (bin), "mysrc"); if (!appsrc) { g_print ("no element with name \"appsrc\" found\n"); gst_object_unref (bin); exit(-3); } /* g_object_set (G_OBJECT (appsrc), "caps", gst_caps_new_simple ("video/x-raw", "format", G_TYPE_STRING, "RGB", "width", G_TYPE_INT, this->width, "height", G_TYPE_INT, this->height, "framerate", GST_TYPE_FRACTION, 1, 2, NULL), NULL); */ gst_app_src_set_size (GST_APP_SRC (appsrc), (gint64) -1); // total stream size is not known gst_app_src_set_stream_type(GST_APP_SRC (appsrc),GST_APP_STREAM_TYPE_STREAM); g_object_set (G_OBJECT (appsrc),"format", GST_FORMAT_TIME, NULL); /*setup muxer*/ GstElement *stream = gst_bin_get_by_name (GST_BIN (bin), "stream"); if (!stream) { g_print ("no element with name \"stream\" found\n"); gst_object_unref (bin); exit(-3); } GstPad *srcpad = gst_element_get_static_pad (stream, "src"); if (!srcpad) { g_print ("no \"src\" pad in element \"stream\" found\n"); gst_object_unref (stream); gst_object_unref (bin); exit(-4); } GstPad *ghostpad = gst_ghost_pad_new ("src", srcpad); gst_element_add_pad (GST_ELEMENT (bin), ghostpad); gst_object_unref (srcpad); /* add to pipeline */ pipeline = gst_pipeline_new ("pipeline"); gst_bin_add_many (GST_BIN (pipeline), bin,multisocketsink, NULL); /* link with multi socket */ GstPad *sinkpad = gst_element_get_static_pad (multisocketsink, "sink"); gst_pad_link (ghostpad, sinkpad); gst_object_unref (sinkpad); /*get the bus */ GstBus *bus = gst_element_get_bus (pipeline); gst_bus_add_signal_watch (bus); g_signal_connect (bus, "message", G_CALLBACK (on_message), NULL); gst_object_unref (bus); /*call backs */ g_signal_connect (multisocketsink, "client-socket-removed",G_CALLBACK (on_client_socket_removed), NULL); g_signal_connect (appsrc, "need-data", G_CALLBACK (cb_need_data), this); /* setup main loop */ loop = g_main_loop_new (NULL, FALSE); if (gst_element_set_state (pipeline,GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) { gst_object_unref (pipeline); g_main_loop_unref (loop); g_print ("Failed to set pipeline to ready\n"); exit(-5); } /*setup server*/ service = g_socket_service_new (); g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service), this->pconf->port, NULL,NULL); g_signal_connect (service, "incoming", G_CALLBACK (on_new_connection), NULL); g_socket_service_start (service); g_print ("Listening on http://127.0.0.1:%u/\n",this->pconf->port); /* start main loop */ g_main_loop_run (loop); cout << "F**k " << endl; return NULL; }