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