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