static gboolean init_client (GUPnPContext *context) { GUPnPControlPoint *cp; cp = gupnp_control_point_new (context, NETWORK_LIGHT); g_signal_connect (cp, "device-proxy-available", G_CALLBACK (on_network_light_available), NULL); g_signal_connect (cp, "device-proxy-unavailable", G_CALLBACK (on_network_light_unavailable), NULL); gssdp_resource_browser_set_active (GSSDP_RESOURCE_BROWSER (cp), TRUE); /* Let context manager take care of the control point life cycle */ gupnp_context_manager_manage_control_point (context_manager, cp); /* We don't need to keep our own references to the control points */ g_object_unref (cp); return TRUE; }
static void gssdp_resource_browser_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GSSDPResourceBrowser *resource_browser; resource_browser = GSSDP_RESOURCE_BROWSER (object); switch (property_id) { case PROP_CLIENT: gssdp_resource_browser_set_client (resource_browser, g_value_get_object (value)); break; case PROP_TARGET: gssdp_resource_browser_set_target (resource_browser, g_value_get_string (value)); break; case PROP_MX: gssdp_resource_browser_set_mx (resource_browser, g_value_get_uint (value)); break; case PROP_ACTIVE: gssdp_resource_browser_set_active (resource_browser, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
int main (G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv) { GError *error; GUPnPContext *context; GUPnPControlPoint *cp; #ifndef G_OS_WIN32 struct sigaction sig_action; #endif /* G_OS_WIN32 */ #if !GLIB_CHECK_VERSION(2,35,0) g_type_init (); #endif setlocale (LC_ALL, ""); error = NULL; context = g_initable_new (GUPNP_TYPE_CONTEXT, NULL, &error, NULL); if (error) { g_printerr ("Error creating the GUPnP context: %s\n", error->message); g_error_free (error); return EXIT_FAILURE; } /* We're interested in everything */ cp = gupnp_control_point_new (context, "urn:schemas-upnp-org:service:ContentDirectory:1"); g_signal_connect (cp, "service-proxy-available", G_CALLBACK (service_proxy_available_cb), NULL); g_signal_connect (cp, "service-proxy-unavailable", G_CALLBACK (service_proxy_unavailable_cb), NULL); gssdp_resource_browser_set_active (GSSDP_RESOURCE_BROWSER (cp), TRUE); main_loop = g_main_loop_new (NULL, FALSE); /* Hook the handler for SIGTERM */ #ifndef G_OS_WIN32 memset (&sig_action, 0, sizeof (sig_action)); sig_action.sa_handler = interrupt_signal_handler; sigaction (SIGINT, &sig_action, NULL); #else signal(SIGINT,interrupt_signal_handler); #endif /* G_OS_WIN32 */ g_main_loop_run (main_loop); g_main_loop_unref (main_loop); g_object_unref (cp); g_object_unref (context); return EXIT_SUCCESS; }
static void context_found(GUPnPContextManager* mngr, GUPnPContext* context, gpointer userData) { const gchar* ipaddr = 0; ipaddr = gupnp_context_get_host_ip(context); printf("Found physical router for address %s\n",ipaddr); GUPnPControlPoint* controlPoint = gupnp_control_point_new(context,"upnp:rootdevice"); g_signal_connect(controlPoint,"device-proxy-available",G_CALLBACK(device_proxy_found),context); gssdp_resource_browser_set_active(GSSDP_RESOURCE_BROWSER(controlPoint),TRUE); g_object_unref(context); }
int main (int argc, char **argv) { GError *error = NULL; GUPnPContext *context; GUPnPControlPoint *cp; #ifndef G_OS_WIN32 struct sigaction sig_action; #endif /* G_OS_WIN32 */ error = NULL; context = g_initable_new (GUPNP_TYPE_CONTEXT, NULL, &error, NULL); if (error) { g_printerr ("Error creating the GUPnP context: %s\n", error->message); g_error_free (error); return EXIT_FAILURE; } cancellable = g_cancellable_new (); /* We're interested in everything */ cp = gupnp_control_point_new (context, "ssdp:all"); g_signal_connect (cp, "service-proxy-available", G_CALLBACK (service_proxy_available_cb), NULL); g_signal_connect (cp, "service-proxy-unavailable", G_CALLBACK (service_proxy_unavailable_cb), NULL); gssdp_resource_browser_set_active (GSSDP_RESOURCE_BROWSER (cp), TRUE); main_loop = g_main_loop_new (NULL, FALSE); /* Hook the handler for SIGTERM */ #ifndef G_OS_WIN32 memset (&sig_action, 0, sizeof (sig_action)); sig_action.sa_handler = interrupt_signal_handler; sigaction (SIGINT, &sig_action, NULL); #else signal(SIGINT,interrupt_signal_handler); #endif /* G_OS_WIN32 */ g_main_loop_run (main_loop); g_main_loop_unref (main_loop); g_object_unref (cp); g_object_unref (context); return EXIT_SUCCESS; }
void UpnpControlPointService::Run() { g_signal_connect (m_controlPoint, "service-proxy-available", G_CALLBACK (UpnpControlPointService::serviceProxyAdded), this); g_signal_connect (m_controlPoint, "service-proxy-unavailable", G_CALLBACK (UpnpControlPointService::serviceProxyRemoved), this); g_signal_connect (m_controlPoint, "device-proxy-available", G_CALLBACK (UpnpControlPointService::deviceProxyAdded), this); g_signal_connect (m_controlPoint, "device-proxy-unavailable", G_CALLBACK (UpnpControlPointService::deviceProxyRemoved), this); gssdp_resource_browser_set_active (GSSDP_RESOURCE_BROWSER (m_controlPoint), TRUE); // g_signal_connect (m_discoverer, "done", G_CALLBACK (UpnpControlPointService::discoverCompleted), this); for(;;) { pthread_cond_wait(&m_cond, &m_lck); } }
static void gupnp_control_point_dispose (GObject *object) { GUPnPControlPoint *control_point; GSSDPResourceBrowser *browser; GObjectClass *object_class; control_point = GUPNP_CONTROL_POINT (object); browser = GSSDP_RESOURCE_BROWSER (control_point); gssdp_resource_browser_set_active (browser, FALSE); if (control_point->priv->factory) { g_object_unref (control_point->priv->factory); control_point->priv->factory = NULL; } /* Cancel any pending description file GETs */ while (control_point->priv->pending_gets) { GetDescriptionURLData *data; GUPnPContext *context; SoupSession *session; data = control_point->priv->pending_gets->data; context = gupnp_control_point_get_context (control_point); session = gupnp_context_get_session (context); soup_session_cancel_message (session, data->message, SOUP_STATUS_CANCELLED); get_description_url_data_free (data); } /* Release weak references on remaining cached documents */ g_hash_table_foreach (control_point->priv->doc_cache, weak_unref_doc, control_point); /* Call super */ object_class = G_OBJECT_CLASS (gupnp_control_point_parent_class); object_class->dispose (object); }
int main(int argc, char *argv[]) { GMainLoop *main_loop; g_type_init(); for (;;) { int option = getopt_long(argc, argv, options, long_options, NULL); if (option == -1) break; switch (option) { case 'i': interface = optarg; break; case 'p': port = atoi(optarg); break; case '?': case 'h': print_usage(); exit(EXIT_SUCCESS); case 'v': print_version(); exit(EXIT_SUCCESS); default: exit(EXIT_FAILURE); } } if (yasc_get_control_point() == NULL) exit(EXIT_FAILURE); gssdp_resource_browser_set_active(GSSDP_RESOURCE_BROWSER(yasc_get_control_point()), TRUE); main_loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(main_loop); g_main_loop_unref(main_loop); return 0; }
static void prv_on_context_available(GUPnPContextManager *context_manager, GUPnPContext *context, gpointer user_data) { dld_upnp_t *upnp = user_data; GUPnPControlPoint *cp; cp = gupnp_control_point_new(context, "upnp:rootdevice"); g_signal_connect(cp, "device-proxy-available", G_CALLBACK(prv_device_available_cb), upnp); g_signal_connect(cp, "device-proxy-unavailable", G_CALLBACK(prv_device_unavailable_cb), upnp); gssdp_resource_browser_set_active(GSSDP_RESOURCE_BROWSER(cp), TRUE); gupnp_context_manager_manage_control_point(upnp->context_manager, cp); g_object_unref(cp); }
static void gupnp_simple_igd_add_control_point (GUPnPSimpleIgd *self, GUPnPContext *gupnp_context, const char *target) { GUPnPControlPoint *cp; cp = gupnp_control_point_new (gupnp_context, target); g_return_if_fail (cp); g_signal_connect_object (cp, "service-proxy-available", G_CALLBACK (_cp_service_avail), self, 0); g_signal_connect_object (cp, "service-proxy-unavailable", G_CALLBACK (_cp_service_unavail), self, 0); gssdp_resource_browser_set_active (GSSDP_RESOURCE_BROWSER (cp), TRUE); gupnp_context_manager_manage_control_point ( self->priv->gupnp_context_manager, cp); g_object_unref (cp); }
static gboolean init_upnp (void) { GError *error; error = NULL; client = g_initable_new (GSSDP_TYPE_CLIENT, NULL, &error, "interface", interface, NULL); if (error) { g_printerr ("Error creating the GSSDP client: %s\n", error->message); g_error_free (error); return FALSE; } resource_browser = gssdp_resource_browser_new (client, GSSDP_ALL_RESOURCES); g_signal_connect (client, "message-received", G_CALLBACK (on_ssdp_message), NULL); g_signal_connect (resource_browser, "resource-available", G_CALLBACK (resource_available_cb), NULL); g_signal_connect (resource_browser, "resource-unavailable", G_CALLBACK (resource_unavailable_cb), NULL); gssdp_resource_browser_set_active (resource_browser, TRUE); return TRUE; }
int main (int argc, char **argv) { GError *error = NULL; GUPnPContext *context; GUPnPControlPoint *cp; #if !GLIB_CHECK_VERSION(2,35,0) g_type_init (); #endif /* Check and parse command line arguments */ if (argc != 2) { usage (); return EXIT_FAILURE; } if (g_str_equal (argv[1], "on")) { mode = ON; } else if (g_str_equal (argv[1], "off")) { mode = OFF; } else if (g_str_equal (argv[1], "toggle")) { mode = TOGGLE; } else { usage (); return EXIT_FAILURE; } /* Create the UPnP context */ context = gupnp_context_new (NULL, NULL, 0, &error); if (error) { g_printerr ("Error creating the GUPnP context: %s\n", error->message); g_error_free (error); return EXIT_FAILURE; } /* Create the control point, searching for SwitchPower services */ cp = gupnp_control_point_new (context, "urn:schemas-upnp-org:service:SwitchPower:1"); /* Connect to the service-found callback */ g_signal_connect (cp, "service-proxy-available", G_CALLBACK (service_proxy_available_cb), NULL); /* Start searching when the main loop runs */ gssdp_resource_browser_set_active (GSSDP_RESOURCE_BROWSER (cp), TRUE); /* Run the main loop */ main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (main_loop); /* Cleanup */ g_main_loop_unref (main_loop); g_object_unref (cp); g_object_unref (context); return EXIT_SUCCESS; }