void GIOServiceServer::listen() throw(CommunicationModuleException){ assert(listener == nullptr); listener = g_socket_listener_new(); if(listener == nullptr ){ throw CommunicationModuleException("Could not instantiate listener"); } SocketType type; GSocketAddress * gsocketAddr = getSocket(address, type); GError * error = NULL; int ret = g_socket_listener_add_address(listener, gsocketAddr, type == SocketType::IPC ? (GSocketType) SocketType::TCP : (GSocketType) type, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, & error); g_object_unref(gsocketAddr); if (! ret){ CommunicationModuleException e = CommunicationModuleException(error->message); g_error_free(error); throw e; } if(error != NULL){ g_error_free(error); } addAcceptorThread(); }
static gboolean net_createTCPSocket(struct node *n, guint classid) { guint port = 2300+n->classes[classid]; GError * err = NULL; GInetAddress *addr = n->netadr; syslog(LOG_DEBUG,"net_createSockets: Creating tcp socket listener " "on port %u\n", port); GSocketAddress *sa = g_inet_socket_address_new(addr,port); GSocketService *gss = g_socket_service_new(); if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), sa, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &err) == FALSE ){ syslog(LOG_WARNING, "net_createSockets: Error while creating" "socket listener: %s\n", err->message); g_error_free(err); g_object_unref(gss); return FALSE; } n->tcpsockets[classid].n = n; n->tcpsockets[classid].socketservice = gss; n->tcpsockets[classid].socketaddress = sa; n->tcpsockets[classid].classid = classid; g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener), &(n->tcpsockets[classid])); g_socket_service_start(gss); return TRUE; }
static void test_event_signal (void) { gboolean success = FALSE; GInetAddress *iaddr; GSocketAddress *saddr; GSocketListener *listener; GError *error = NULL; iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4); saddr = g_inet_socket_address_new (iaddr, 0); g_object_unref (iaddr); listener = g_socket_listener_new (); g_signal_connect (listener, "event", G_CALLBACK (event_cb), &success); g_socket_listener_add_address (listener, saddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &error); g_assert_no_error (error); g_assert_true (success); g_object_unref (saddr); g_object_unref (listener); }
void owr_image_server_add_image_renderer(OwrImageServer *image_server, OwrImageRenderer *image_renderer, const gchar *tag) { OwrImageServerPrivate *priv; g_return_if_fail(OWR_IS_IMAGE_SERVER(image_server)); g_return_if_fail(OWR_IS_IMAGE_RENDERER(image_renderer)); g_return_if_fail(tag && tag[0]); priv = image_server->priv; g_mutex_lock(&priv->image_renderers_mutex); if (!g_hash_table_contains(priv->image_renderers, tag)) { g_hash_table_insert(priv->image_renderers, g_strdup(tag), image_renderer); g_object_ref(image_renderer); } else g_warning("Image renderer not added, an image renderer is already added for this tag"); g_mutex_unlock(&priv->image_renderers_mutex); if (!priv->socket_service_is_started) { g_socket_listener_add_address(G_SOCKET_LISTENER(priv->socket_service), g_inet_socket_address_new(g_inet_address_new_from_string("127.0.0.1"), (guint16)priv->port), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL); g_socket_service_start(priv->socket_service); priv->socket_service_is_started = TRUE; } }
void socket_listen(char *suffix) { GSocketService *sock; GSocketAddress *sa; GError *err = NULL; char *name, *path; name = g_strdup_printf("%s-%s", __NAME__, suffix); path = g_build_filename(g_get_user_runtime_dir(), name, NULL); g_free(name); unlink(path); sa = g_unix_socket_address_new(path); g_free(path); sock = g_threaded_socket_service_new(-1); if (!g_socket_listener_add_address(G_SOCKET_LISTENER(sock), sa, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, &err)) { fprintf(stderr, "Failed to set up socket: '%s'\n", err->message); exit(EXIT_FAILURE); } g_signal_connect(G_OBJECT(sock), "run", G_CALLBACK(sock_incoming), NULL); g_socket_service_start(sock); }
static gboolean initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { g_debug (G_STRLOC ": %s", G_STRFUNC); DasomServer *server = DASOM_SERVER (initable); GSocketAddress *address; GError *local_error = NULL; server->listener = G_SOCKET_LISTENER (g_socket_service_new ()); /* server->listener = G_SOCKET_LISTENER (g_threaded_socket_service_new (-1)); */ if (g_unix_socket_address_abstract_names_supported ()) address = g_unix_socket_address_new_with_type (server->address, -1, G_UNIX_SOCKET_ADDRESS_ABSTRACT); else { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Abstract UNIX domain socket names are not supported."); return FALSE; } g_socket_listener_add_address (server->listener, address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, &local_error); g_object_unref (address); if (local_error) { g_propagate_error (error, local_error); return FALSE; } server->is_using_listener = TRUE; server->run_signal_handler_id = g_signal_connect (G_SOCKET_SERVICE (server->listener), "incoming", (GCallback) on_new_connection, server); /* server->run_signal_handler_id = g_signal_connect (G_SOCKET_SERVICE (server->listener), "run", G_CALLBACK (on_run), server); */ return TRUE; }
void dirserver_init(gchar* baseaddress) { syslog(LOG_DEBUG,"dirserver_init: starting directory server"); services = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); dirserversocket = multicast_createSocket("directoryserver", 2323, &sa); if( socket != NULL){ syslog(LOG_DEBUG,"dirserver_init: socket open"); GSource *source = g_socket_create_source(dirserversocket, G_IO_IN, NULL); ub_assert(source != NULL); g_source_set_callback(source, (GSourceFunc)dirserver_read, NULL, NULL); g_source_attach(source, g_main_context_default()); }else{ syslog(LOG_WARNING, "directory-server.c: warning: could not create socket"); } GError * e = NULL; GInetAddress *net_base = g_inet_address_new_from_string(baseaddress); if( net_base == NULL ){ syslog(LOG_ERR, "dirserver_init: Could not parse base address"); return; } //set up http tcp listener GSocketAddress *httpsa = g_inet_socket_address_new(net_base,8080); syslog(LOG_DEBUG,"dirserver_init: Creating tcp socket on port 8080\n"); GSocketService *gss = g_socket_service_new(); //TODO: save a reference to the gss somewhere if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), httpsa, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &e) == FALSE ){ syslog(LOG_WARNING, "dirserver_init: error while creating socket listener: %s\n",e->message); g_error_free(e); } g_signal_connect(gss, "incoming", G_CALLBACK(dirserver_tcp_listener),NULL); g_socket_service_start(gss); g_timeout_add_seconds(1,dirserver_tick,NULL); }
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; }
gint net_init(gchar* interface, gchar* baseaddress, gchar *multicastbase) { GError * e = NULL; interface = NULL; //prevent warning net_base = g_inet_address_new_from_string(baseaddress); if( net_base == NULL ){ syslog(LOG_ERR, "net_init: Could not parse base address"); return -1; } struct node n; n.netadr = net_base; n.ubnetd = NULL; syslog(LOG_DEBUG,"creating base address...\n"); interface_createAddress(&n); usleep(3000*1000); syslog(LOG_DEBUG,"done\n"); net_multicastbase = g_inet_address_new_from_string(multicastbase); if( net_multicastbase == NULL ){ syslog(LOG_ERR, "net_init: Could not parse multicast base address"); return -1; } address6_init(net_base, net_multicastbase); tcp_init(); GSocketAddress * sa = g_inet_socket_address_new(net_base,2323); //set up data tcp listener syslog(LOG_DEBUG,"net_init: Creating tcp socket on port 2323\n"); GSocketService *gss = g_socket_service_new(); //TODO: save a reference to the gss somewhere if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), sa, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &e) == FALSE ){ syslog(LOG_WARNING, "net_init: error while creating socket listener: %s\n", e->message); g_error_free(e); } g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener),NULL); g_socket_service_start(gss); g_object_unref(sa); return 0; }
void net_createSockets(struct node *n) { GInetAddress *addr = n->netadr; gchar *tmp = g_inet_address_to_string(addr); syslog(LOG_DEBUG,"net_createSockets: Creating sockets on ip: %s\n",tmp); g_free(tmp); guint i; for(i=0; i<sizeof(n->classes); i++){ if( n->classes[i] != 0 ){ if( !(net_createUDPSocket(n, i) && net_createTCPSocket(n, i)) ) return; } } syslog(LOG_DEBUG,"net_createSockets: Creating tcp management socket listener on port 2324\n"); GError * err = NULL; GSocketAddress * samgt = g_inet_socket_address_new(addr,2324); GSocketService *gss = g_socket_service_new(); if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), samgt, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &err) == FALSE ){ syslog(LOG_WARNING, "net_createSockets: Error while creating socket listener: %s\n", err->message); g_error_free(err); g_object_unref(gss); return; } n->mgtsocket.n = n; n->mgtsocket.socketservice = gss; n->mgtsocket.socketaddress = samgt; g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener), &(n->mgtsocket)); g_socket_service_start(gss); syslog(LOG_DEBUG,"net_createSockets: activating network for this node\n"); avahi_registerServices(n); n->netup = TRUE; }
/** * Register the flare service port */ void create_service(gchar *address, uint16_t port, GCallback *callback, gulong *handler_id) { GSocketService *service = g_socket_service_new(); GInetAddress *inet_address = g_inet_address_new_from_string(address); GSocketAddress *socket_address = g_inet_socket_address_new(inet_address, port); g_socket_listener_add_address( G_SOCKET_LISTENER(service), socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL); g_object_unref(socket_address); g_object_unref(inet_address); *handler_id = g_signal_connect(service, "incoming", G_CALLBACK(callback), NULL); g_socket_service_start(service); g_assert(g_socket_service_is_active(service)); }
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 (); GInetAddress *address = g_inet_address_new_from_string(inet_ntoa(local_ip)); GSocketAddress *socket_address = g_inet_socket_address_new(address, CONTROL_PORT); g_socket_listener_add_address(G_SOCKET_LISTENER(control_service_data.service), socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL); /* 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! %s\n", inet_ntoa(local_ip)); }
int main (int argc, char *argv[]) { GMainLoop *main_loop = NULL; HevSocks5Service *service = NULL; main_loop = g_main_loop_new (NULL, FALSE); service = hev_socks5_service_new (20); GInetAddress *iaddr = g_inet_address_new_from_string ("127.0.0.1"); GSocketAddress *saddr = g_inet_socket_address_new (iaddr, 1082); if (g_socket_listener_add_address (G_SOCKET_LISTENER (service), saddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL)) { g_socket_service_start (G_SOCKET_SERVICE (service)); g_main_loop_run (main_loop); g_socket_service_stop (G_SOCKET_SERVICE (service)); } g_object_unref (service); g_main_loop_unref (main_loop); return 0; }
static void BP_TCPService_BindListener (BPTCPService *filter) { // Don't bind if we're sink-only g_return_if_fail (filter->ready && !filter->init && filter->mode != BP_MODE_SINK_ONLY); filter->service = g_socket_service_new(); filter->inetAddress = g_inet_address_new_from_string(filter->address->str); filter->socketAddress = g_inet_socket_address_new(filter->inetAddress, filter->port); // add server socket to service and attach listener g_socket_listener_add_address(G_SOCKET_LISTENER(filter->service), filter->socketAddress, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL); g_message ("Starting IO service..."); // Connect socket to IO service g_socket_service_start(filter->service); g_message ("IO service is up"); g_message ("Attaching signals ..."); // Pass proxy instance as user data g_signal_connect(filter->service, "incoming", G_CALLBACK(BP_TCPService_IncomingConnection), filter); g_message ("Attached!"); BP_TCPService_ValidateBind (filter); g_message ("Local IP/Port: %s:%u", filter->address->str, filter->port); filter->init = TRUE; }
int main(int argc, char **argv){ GMainLoop *main_loop; GSocketService *service; GInetAddress *iaddr; GSocketAddress *saddr; AppData *app_data; GError *error = NULL; // Init g_set_prgname(argv[0]); g_mem_set_vtable(glib_mem_profiler_table); g_type_init(); // Start the daemon start_daemon(g_get_prgname(), LOG_LOCAL0); syslog(LOG_NOTICE, "-----------------------------------\n"); syslog(LOG_NOTICE, "Daemon has been started\n"); // atexit(cleanup); // Initialize App Data structire app_data = g_slice_new0(AppData); app_data->queue = g_queue_new(); app_data->hosts = NULL; app_data->running_backups = NULL; // For global access to app_data app_data_aux_ptr = app_data; // Read configuration if (!read_config(app_data)){ syslog(LOG_ERR, "Failed to read config file \"%s\"", CONFIG_FILE); exit(-1); } // If no hosts configured in config file, try reading from MySQL if (g_list_length(app_data->hosts) == 0){ syslog(LOG_NOTICE, "No hosts configured in /etc/busy/busy.conf, now reading hosts from MySQL"); app_data->hosts = db_read_hosts(app_data->mysql); } if (g_list_length(app_data->hosts) == 0){ syslog(LOG_ERR, "Absolutely no hosts configured! Please configure at least one host either in %s or use the Web frontend", CONFIG_FILE); //~ syslog(LOG_ERR, "I won't waste any more cpu time now and exit"); //~ exit(0); } else { GList *p; for (p = app_data->hosts; p != NULL; p = p->next){ Host *host = p->data; host_dump(host); syslog(LOG_NOTICE, "%s %f", host_get_name(host), host_get_max_age(host)); } } // Setup listener for incoming TCP (localhost port 4000) service = g_socket_service_new(); iaddr = g_inet_address_new_from_string("127.0.0.1"); saddr = g_inet_socket_address_new(iaddr, 4000); g_socket_listener_add_address(G_SOCKET_LISTENER(service), saddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &error); g_object_unref(iaddr); g_object_unref(saddr); g_socket_service_start(service); g_signal_connect(service, "incoming", (GCallback)on_incoming, app_data); // Call wakeup and archive function once wakeup(app_data); do_archive(app_data); // Check preiodically for backups, queue and archives, g_timeout_add_seconds(WAKEUP_INTERVAL, (GSourceFunc)wakeup, app_data); g_timeout_add_seconds(10, (GSourceFunc)do_backup, app_data); g_timeout_add_seconds(6 * 3600, (GSourceFunc)do_archive, app_data); // Run main loop main_loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(main_loop); return (EXIT_SUCCESS); }
static gboolean cockpit_web_server_initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { CockpitWebServer *server = COCKPIT_WEB_SERVER (initable); GSocketAddress *socket_address = NULL; GSocketAddress *result_address = NULL; 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 { if (server->address) { socket_address = g_inet_socket_address_new (server->address, server->port); if (socket_address) { failed = !g_socket_listener_add_address (G_SOCKET_LISTENER (server->socket_service), socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, &result_address, error); if (!failed) { server->port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (result_address)); g_object_unref (result_address); } g_object_unref (socket_address); } } /* No fds passed in, let's listen on our own. */ else 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; }
GObject* spice_foreign_menu_listener_new (const gchar *address, GError **error) { GObject *listener = NULL; gchar *addr = NULL; g_return_val_if_fail (error == NULL || *error == NULL, NULL); addr = g_strdup (address); #ifdef G_OS_WIN32 if (addr == NULL) addr = g_strdup (g_getenv ("SPICE_FOREIGN_MENU_NAMEDPIPE")); if (addr == NULL) addr = g_strdup_printf ("\\\\.\\pipe\\SpiceForeignMenu-%" G_GUINT64_FORMAT, (guint64)GetCurrentProcessId ()); #else if (addr == NULL) addr = g_strdup (g_getenv ("SPICE_FOREIGN_MENU_SOCKET")); if (addr == NULL) addr = g_strdup_printf ("/tmp/SpiceForeignMenu-%" G_GUINT64_FORMAT ".uds", (guint64)getpid ()); #endif if (addr == NULL) { g_set_error (error, SPICE_FOREIGN_MENU_LISTENER_ERROR, SPICE_FOREIGN_MENU_LISTENER_ERROR_VALUE, #ifdef G_OS_WIN32 "Missing namedpipe address" #else "Missing socket address" #endif ); goto end; } g_unlink (addr); #ifdef G_OS_WIN32 { SpiceNamedPipe *np; listener = G_OBJECT (spice_named_pipe_listener_new ()); np = spice_win32_user_pipe_new (addr, error); if (!np) { g_object_unref (listener); listener = NULL; goto end; } spice_named_pipe_listener_add_named_pipe (SPICE_NAMED_PIPE_LISTENER (listener), np); } #else { listener = G_OBJECT (g_socket_listener_new ()); if (!g_socket_listener_add_address (G_SOCKET_LISTENER (listener), G_SOCKET_ADDRESS (g_unix_socket_address_new (addr)), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, error)) g_warning ("failed to add address"); } #endif end: g_free (addr); return listener; }
int main(int argc, char **argv) { int i; //Get process id ProcessID= getpid(); // default password AppPass = defaultAppPass; // try environment variable first, set to default if failed IvyBus = getenv("IVYBUS"); if (IvyBus == NULL) IvyBus = defaultIvyBus; // Parse options for (i = 1; i < argc; ++i) { if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) { print_help(); exit(0); } else if (strcmp(argv[i], "-t") == 0) { tcp_port = atoi(argv[++i]); } else if (strcmp(argv[i], "-u") == 0) { udp_port = atoi(argv[++i]); } else if (strcmp(argv[i], "-b") == 0) { IvyBus = argv[++i]; } else if (strcmp(argv[i], "-p") == 0) { AppPass = argv[++i]; } else if (strcmp(argv[i], "-v") == 0) { verbose = 1; } else if (strcmp(argv[i], "-utcp") == 0) { uTCP = 1; } else { printf("App Server: Unknown option\n"); print_help(); exit(0); } } if (verbose) { printf("### Paparazzi App Server ###\n"); printf("Server listen port (TCP) : %d\n", tcp_port); if (uTCP) { printf("Server using TCP communication..\n"); }else{ printf("Server broadcast port (UDP) : %d\n", udp_port); } printf("Control Pass : %s\n", AppPass); printf("Ivy Bus : %s\n", IvyBus); fflush(stdout); } //Create tcp listener #if !GLIB_CHECK_VERSION (2, 35, 1) // init GLib type system (only for older version) g_type_init(); #endif GSocketService *service = g_socket_service_new(); GInetAddress *address = g_inet_address_new_any(G_SOCKET_FAMILY_IPV6); //G_SOCKET_FAMILY_IPV4 could be used GSocketAddress *socket_address = g_inet_socket_address_new(address, tcp_port); //Add listener g_socket_listener_add_address(G_SOCKET_LISTENER(service), socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL); g_object_unref(socket_address); g_object_unref(address); g_socket_service_start(service); //Connect listening signal g_signal_connect(service, "incoming", G_CALLBACK(new_connection), NULL); //Here comes the ivy bindings IvyInit ("PPRZ_App_Server", "Papparazzi App Server Ready!", NULL, NULL, NULL, NULL); IvyBindMsg(Ivy_All_Msgs, NULL, "(^ground (\\S*) (\\S*) .*)"); IvyBindMsg(on_app_server_NEW_AC, NULL, "ground NEW_AIRCRAFT (\\S*)"); IvyBindMsg(on_app_server_GET_CONFIG, NULL, "(\\S*) ground CONFIG (\\S*) (\\S*) (\\S*) (\\S*) (\\S*) (\\S*) (\\S*)"); IvyBindMsg(on_app_server_AIRCRAFTS, NULL, "(\\S*) ground AIRCRAFTS (\\S*)"); IvyStart(IvyBus); GMainLoop *loop = g_main_loop_new(NULL, FALSE); if (verbose) { printf("Starting App Server\n"); fflush(stdout); } IvySendMsg("app_server"); g_timeout_add(100, request_ac_list, NULL); g_main_loop_run(loop); if (verbose) { printf("Stoping App Server\n"); fflush(stdout); } return 0; }
/* note that address_entry has already been validated => exactly one of path, tmpdir or abstract keys are set */ static gboolean try_unix (GDBusServer *server, const gchar *address_entry, GHashTable *key_value_pairs, GError **error) { gboolean ret; const gchar *path; const gchar *tmpdir; const gchar *abstract; GSocketAddress *address; ret = FALSE; address = NULL; path = g_hash_table_lookup (key_value_pairs, "path"); tmpdir = g_hash_table_lookup (key_value_pairs, "tmpdir"); abstract = g_hash_table_lookup (key_value_pairs, "abstract"); if (path != NULL) { address = g_unix_socket_address_new (path); } else if (tmpdir != NULL) { gint n; GString *s; GError *local_error; retry: s = g_string_new (tmpdir); g_string_append (s, "/dbus-"); for (n = 0; n < 8; n++) g_string_append_c (s, random_ascii ()); /* prefer abstract namespace if available */ if (g_unix_socket_address_abstract_names_supported ()) address = g_unix_socket_address_new_with_type (s->str, -1, G_UNIX_SOCKET_ADDRESS_ABSTRACT); else address = g_unix_socket_address_new (s->str); g_string_free (s, TRUE); local_error = NULL; if (!g_socket_listener_add_address (server->listener, address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, /* source_object */ NULL, /* effective_address */ &local_error)) { if (local_error->domain == G_IO_ERROR && local_error->code == G_IO_ERROR_ADDRESS_IN_USE) { g_error_free (local_error); goto retry; } g_propagate_error (error, local_error); goto out; } ret = TRUE; goto out; } else if (abstract != NULL) { if (!g_unix_socket_address_abstract_names_supported ()) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Abstract name space not supported")); goto out; } address = g_unix_socket_address_new_with_type (abstract, -1, G_UNIX_SOCKET_ADDRESS_ABSTRACT); } else { g_assert_not_reached (); } if (!g_socket_listener_add_address (server->listener, address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, /* source_object */ NULL, /* effective_address */ error)) goto out; ret = TRUE; out: if (address != NULL) { /* Fill out client_address if the connection attempt worked */ if (ret) { server->is_using_listener = TRUE; switch (g_unix_socket_address_get_address_type (G_UNIX_SOCKET_ADDRESS (address))) { case G_UNIX_SOCKET_ADDRESS_ABSTRACT: server->client_address = g_strdup_printf ("unix:abstract=%s", g_unix_socket_address_get_path (G_UNIX_SOCKET_ADDRESS (address))); break; case G_UNIX_SOCKET_ADDRESS_PATH: server->client_address = g_strdup_printf ("unix:path=%s", g_unix_socket_address_get_path (G_UNIX_SOCKET_ADDRESS (address))); break; default: g_assert_not_reached (); break; } } g_object_unref (address); } return ret; }
int main (int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; GMainLoop *loop; GInetAddress *inet; GSocketAddress *address; GSocketService *listener; char *path, *basename; char *http_address = NULL; char *unixsocket_address = NULL; int http_port = 0; char *ssl_cert = NULL; char *ssl_key = NULL; char *display; int port = 0; const GOptionEntry entries[] = { { "port", 'p', 0, G_OPTION_ARG_INT, &http_port, "Httpd port", "PORT" }, { "address", 'a', 0, G_OPTION_ARG_STRING, &http_address, "Ip address to bind to ", "ADDRESS" }, #ifdef G_OS_UNIX { "unixsocket", 'u', 0, G_OPTION_ARG_STRING, &unixsocket_address, "Unix domain socket address", "ADDRESS" }, #endif { "cert", 'c', 0, G_OPTION_ARG_STRING, &ssl_cert, "SSL certificate path", "PATH" }, { "key", 'k', 0, G_OPTION_ARG_STRING, &ssl_key, "SSL key path", "PATH" }, { NULL } }; setlocale (LC_ALL, ""); context = g_option_context_new ("[:DISPLAY] - broadway display daemon"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("option parsing failed: %s\n", error->message); exit (1); } display = NULL; if (argc > 1) { if (*argv[1] != ':') { g_printerr ("Usage broadwayd [:DISPLAY]\n"); exit (1); } display = argv[1]; } if (display == NULL) { #ifdef G_OS_UNIX if (g_unix_socket_address_abstract_names_supported ()) display = ":0"; else #endif display = ":tcp"; } if (g_str_has_prefix (display, ":tcp")) { port = strtol (display + strlen (":tcp"), NULL, 10); inet = g_inet_address_new_from_string ("127.0.0.1"); g_print ("Listening on 127.0.0.1:%d\n", port + 9090); address = g_inet_socket_address_new (inet, port + 9090); g_object_unref (inet); } #ifdef G_OS_UNIX else if (display[0] == ':' && g_ascii_isdigit(display[1])) { port = strtol (display + strlen (":"), NULL, 10); basename = g_strdup_printf ("broadway%d.socket", port + 1); path = g_build_filename (g_get_user_runtime_dir (), basename, NULL); g_free (basename); g_print ("Listening on %s\n", path); address = g_unix_socket_address_new_with_type (path, -1, G_UNIX_SOCKET_ADDRESS_ABSTRACT); g_free (path); } #endif else { g_printerr ("Failed to parse display %s\n", display); exit (1); } if (http_port == 0) http_port = 8080 + port; if (unixsocket_address != NULL) server = broadway_server_on_unix_socket_new (unixsocket_address, &error); else server = broadway_server_new (http_address, http_port, ssl_cert, ssl_key, &error); if (server == NULL) { g_printerr ("%s\n", error->message); return 1; } listener = g_socket_service_new (); if (!g_socket_listener_add_address (G_SOCKET_LISTENER (listener), address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, G_OBJECT (server), NULL, &error)) { g_printerr ("Can't listen: %s\n", error->message); return 1; } g_object_unref (address); g_signal_connect (listener, "incoming", G_CALLBACK (incoming_client), NULL); g_socket_service_start (G_SOCKET_SERVICE (listener)); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); return 0; }
/** * tp_stream_tube_channel_offer_async: * @self: an outgoing #TpStreamTubeChannel * @params: (allow-none) (transfer none): parameters of the tube, or %NULL * @callback: a callback to call when the tube has been offered * @user_data: data to pass to @callback * * Offer an outgoing stream tube. When the tube has been offered, @callback * will be called. You can then call tp_stream_tube_channel_offer_finish() * to get the result of the operation. * * You have to connect to the #TpStreamTubeChannel::incoming signal to get a * #TpStreamTubeConnection each time a contact establishes a connection to * the tube. * * Since: 0.13.2 */ void tp_stream_tube_channel_offer_async (TpStreamTubeChannel *self, GHashTable *params, GAsyncReadyCallback callback, gpointer user_data) { GHashTable *properties; GHashTable *supported_sockets; GError *error = NULL; g_return_if_fail (TP_IS_STREAM_TUBE_CHANNEL (self)); g_return_if_fail (self->priv->result == NULL); g_return_if_fail (tp_channel_get_requested (TP_CHANNEL (self))); if (self->priv->service != NULL) { g_critical ("Can't reoffer Tube!"); return; } self->priv->result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, tp_stream_tube_channel_offer_async); properties = _tp_channel_get_immutable_properties (TP_CHANNEL (self)); supported_sockets = tp_asv_get_boxed (properties, TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SUPPORTED_SOCKET_TYPES, TP_HASH_TYPE_SUPPORTED_SOCKET_MAP); if (!_tp_set_socket_address_type_and_access_control_type (supported_sockets, &self->priv->socket_type, &self->priv->access_control, &error)) { operation_failed (self, error); g_clear_error (&error); return; } DEBUG ("Using socket type %u with access control %u", self->priv->socket_type, self->priv->access_control); self->priv->service = g_socket_service_new (); switch (self->priv->socket_type) { #ifdef HAVE_GIO_UNIX case TP_SOCKET_ADDRESS_TYPE_UNIX: { self->priv->address = _tp_create_temp_unix_socket ( self->priv->service, &error); /* check there wasn't an error on the final attempt */ if (self->priv->address == NULL) { operation_failed (self, error); g_clear_error (&error); return; } } break; #endif /* HAVE_GIO_UNIX */ case TP_SOCKET_ADDRESS_TYPE_IPV4: case TP_SOCKET_ADDRESS_TYPE_IPV6: { GInetAddress *localhost; GSocketAddress *in_address; localhost = g_inet_address_new_loopback ( self->priv->socket_type == TP_SOCKET_ADDRESS_TYPE_IPV4 ? G_SOCKET_FAMILY_IPV4 : G_SOCKET_FAMILY_IPV6); in_address = g_inet_socket_address_new (localhost, 0); g_socket_listener_add_address ( G_SOCKET_LISTENER (self->priv->service), in_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, &self->priv->address, &error); g_object_unref (localhost); g_object_unref (in_address); if (error != NULL) { operation_failed (self, error); g_clear_error (&error); return; } break; } default: /* should have already errored */ g_assert_not_reached (); break; } tp_g_signal_connect_object (self->priv->service, "incoming", G_CALLBACK (service_incoming_cb), self, 0); g_socket_service_start (self->priv->service); _offer_with_address (self, params); }
int main (int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; GMainLoop *loop; GSocketAddress *address; GSocketService *listener; char *path, *base; char *http_address = NULL; int http_port = 0; int display = 1; const GOptionEntry entries[] = { { "port", 'p', 0, G_OPTION_ARG_INT, &http_port, "Httpd port", "PORT" }, { "address", 'a', 0, G_OPTION_ARG_STRING, &http_address, "Ip address to bind to ", "ADDRESS" }, { NULL } }; context = g_option_context_new ("[:DISPLAY] - broadway display daemon"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("option parsing failed: %s\n", error->message); exit (1); } if (argc > 1) { if (*argv[1] != ':') { g_printerr ("Usage broadwayd [:DISPLAY]\n"); exit (1); } display = strtol(argv[1]+1, NULL, 10); if (display == 0) { g_printerr ("Failed to parse display num %s\n", argv[1]); exit (1); } } if (http_port == 0) http_port = 8080 + (display - 1); server = broadway_server_new (http_address, http_port, &error); if (server == NULL) { g_printerr ("%s\n", error->message); return 1; } base = g_strdup_printf ("broadway%d.socket", display); path = g_build_filename (g_get_user_runtime_dir (), base, NULL); g_free (base); g_print ("Listening on %s\n", path); address = g_unix_socket_address_new_with_type (path, -1, G_UNIX_SOCKET_ADDRESS_ABSTRACT); g_free (path); listener = g_socket_service_new (); if (!g_socket_listener_add_address (G_SOCKET_LISTENER (listener), address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, G_OBJECT (server), NULL, &error)) { g_printerr ("Can't listen: %s\n", error->message); return 1; } g_object_unref (address); g_signal_connect (listener, "incoming", G_CALLBACK (incoming_client), NULL); g_socket_service_start (G_SOCKET_SERVICE (listener)); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); return 0; }
static void _j4status_io_server_add(J4statusIOContext *self, const gchar *server_desc) { GSocketAddress *address = NULL; const gchar *path = NULL; if ( g_str_has_prefix(server_desc, "tcp:") ) { GInetAddress *inet_address; const gchar *uri = server_desc + strlen("tcp:"); gchar *port_str = g_utf8_strrchr(uri, -1, ':'); if ( port_str == NULL ) { /* No host, only port */ port_str = (gchar *) uri; /* If you want IPv4, just use "0.0.0.0" */ inet_address = g_inet_address_new_any(G_SOCKET_FAMILY_IPV6); } else { *port_str = '\0'; ++port_str; inet_address = g_inet_address_new_from_string(uri); } guint64 port; port = g_ascii_strtoull(port_str, NULL, 10); if ( port > 65535 ) return; address = g_inet_socket_address_new(inet_address, port); } #ifdef G_OS_UNIX if ( g_str_has_prefix(server_desc, "unix:") ) { path = server_desc + strlen("unix:"); address = g_unix_socket_address_new(path); } #endif /* G_OS_UNIX */ if ( address == NULL ) return; gboolean need_free_server = _j4status_io_add_server(self); GError *error = NULL; gboolean r; r = g_socket_listener_add_address(G_SOCKET_LISTENER(self->server), address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, &error); g_object_unref(address); if ( r ) { if ( path != NULL ) self->paths_to_unlink = g_list_prepend(self->paths_to_unlink, g_strdup(path)); return; } g_warning("Couldn't add listener for '%s': %s", server_desc, error->message); g_clear_error(&error); if ( need_free_server ) { g_object_unref(self->server); self->server = NULL; } }
/* note that address_entry has already been validated => * both host and port (guaranteed to be a number in [0, 65535]) are set (family is optional) */ static gboolean try_tcp (GDBusServer *server, const gchar *address_entry, GHashTable *key_value_pairs, gboolean do_nonce, GError **error) { gboolean ret; const gchar *host; const gchar *port; gint port_num; GResolver *resolver; GList *resolved_addresses; GList *l; ret = FALSE; resolver = NULL; resolved_addresses = NULL; host = g_hash_table_lookup (key_value_pairs, "host"); port = g_hash_table_lookup (key_value_pairs, "port"); /* family = g_hash_table_lookup (key_value_pairs, "family"); */ if (g_hash_table_lookup (key_value_pairs, "noncefile") != NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, _("Cannot specify nonce file when creating a server")); goto out; } if (host == NULL) host = "localhost"; if (port == NULL) port = "0"; port_num = strtol (port, NULL, 10); resolver = g_resolver_get_default (); resolved_addresses = g_resolver_lookup_by_name (resolver, host, NULL, error); if (resolved_addresses == NULL) goto out; /* TODO: handle family */ for (l = resolved_addresses; l != NULL; l = l->next) { GInetAddress *address = G_INET_ADDRESS (l->data); GSocketAddress *socket_address; GSocketAddress *effective_address; socket_address = g_inet_socket_address_new (address, port_num); if (!g_socket_listener_add_address (server->listener, socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, /* GObject *source_object */ &effective_address, error)) { g_object_unref (socket_address); goto out; } if (port_num == 0) /* make sure we allocate the same port number for other listeners */ port_num = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (effective_address)); g_object_unref (effective_address); g_object_unref (socket_address); } if (do_nonce) { gint fd; guint n; gsize bytes_written; gsize bytes_remaining; char *file_escaped; server->nonce = g_new0 (guchar, 16); for (n = 0; n < 16; n++) server->nonce[n] = g_random_int_range (0, 256); fd = g_file_open_tmp ("gdbus-nonce-file-XXXXXX", &server->nonce_file, error); if (fd == -1) { g_socket_listener_close (server->listener); goto out; } again: bytes_written = 0; bytes_remaining = 16; while (bytes_remaining > 0) { gssize ret; ret = write (fd, server->nonce + bytes_written, bytes_remaining); if (ret == -1) { if (errno == EINTR) goto again; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), _("Error writing nonce file at '%s': %s"), server->nonce_file, strerror (errno)); goto out; } bytes_written += ret; bytes_remaining -= ret; } if (!g_close (fd, error)) goto out; file_escaped = g_uri_escape_string (server->nonce_file, "/\\", FALSE); server->client_address = g_strdup_printf ("nonce-tcp:host=%s,port=%d,noncefile=%s", host, port_num, file_escaped); g_free (file_escaped); } else { server->client_address = g_strdup_printf ("tcp:host=%s,port=%d", host, port_num); } server->is_using_listener = TRUE; ret = TRUE; out: g_list_free_full (resolved_addresses, g_object_unref); g_object_unref (resolver); return ret; }
int main(int argc, char **argv) { int i; // default password AppPass = defaultAppPass; // try environment variable first, set to default if failed IvyBus = getenv("IVYBUS"); if (IvyBus == NULL) IvyBus = defaultIvyBus; // Look for paparazzi folder (PAPARAZZI_HOME or assume local path by default) char* PprzFolder = getenv("PAPARAZZI_HOME"); if (PprzFolder == NULL) PprzFolder = defaultPprzFolder; // Parse options for (i = 1; i < argc; ++i) { if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) { print_help(); exit(0); } else if (strcmp(argv[i], "-t") == 0) { tcp_port = atoi(argv[++i]); } else if (strcmp(argv[i], "-u") == 0) { udp_port = atoi(argv[++i]); } else if (strcmp(argv[i], "-b") == 0) { IvyBus = argv[++i]; } else if (strcmp(argv[i], "-p") == 0) { AppPass = argv[++i]; } else if (strcmp(argv[i], "-v") == 0) { verbose = 1; } else { printf("App Server: Unknown option\n"); print_help(); exit(0); } } if (verbose) { printf("### Paparazzi App Server ###\n"); printf("Using Paparazzi Folder : %s\n", PprzFolder); printf("Server listen port (TCP) : %d\n", tcp_port); printf("Server broadcast port (UDP) : %d\n", udp_port); printf("Control Pass : %s\n", AppPass); printf("Ivy Bus : %s\n", IvyBus); fflush(stdout); } //Parse conf.xml parse_ac_data(PprzFolder); //Create tcp listener #if !GLIB_CHECK_VERSION (2, 35, 1) // init GLib type system (only for older version) g_type_init(); #endif GSocketService *service = g_socket_service_new(); GInetAddress *address = g_inet_address_new_any(G_SOCKET_FAMILY_IPV6); //G_SOCKET_FAMILY_IPV4 could be used GSocketAddress *socket_address = g_inet_socket_address_new(address, tcp_port); //Add listener g_socket_listener_add_address(G_SOCKET_LISTENER(service), socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL); g_object_unref(socket_address); g_object_unref(address); g_socket_service_start(service); //Connect listening signal g_signal_connect(service, "incoming", G_CALLBACK(new_connection), NULL); //Here comes the ivy bindings IvyInit ("PPRZ_App_Server", "Papparazzi App Server Ready", NULL, NULL, NULL, NULL); IvyBindMsg(Ivy_All_Msgs, NULL, "(^ground .*)"); IvyBindMsg(Ivy_All_Msgs, NULL, "(^\\S* AIRSPEED (\\S*) (\\S*) (\\S*) (\\S*))"); IvyStart(IvyBus); GMainLoop *loop = g_main_loop_new(NULL, FALSE); if (verbose) { printf("Starting App Server\n"); fflush(stdout); } g_main_loop_run(loop); if (verbose) { printf("Stoping App Server\n"); fflush(stdout); } return 0; }