//------------------------------------------------------------------------------
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;
}
