예제 #1
0
static void
on_network_light_available (GUPnPControlPoint *cp,
                            GUPnPDeviceProxy  *light_proxy,
                            gpointer           user_data)
{
        GUPnPServiceProxy *switch_proxy;
        GUPnPServiceProxy *dimming_proxy;
        GUPnPServiceInfo  *info;

        info = gupnp_device_info_get_service (GUPNP_DEVICE_INFO (light_proxy),
                                              SWITCH_SERVICE);
        switch_proxy = GUPNP_SERVICE_PROXY (info);

        if (switch_proxy) {
                switch_proxies = g_list_append (switch_proxies, switch_proxy);
        }

        info = gupnp_device_info_get_service (GUPNP_DEVICE_INFO (light_proxy),
                                              DIMMING_SERVICE);
        dimming_proxy = GUPNP_SERVICE_PROXY (info);

        if (dimming_proxy) {
                dimming_proxies = g_list_append (dimming_proxies,
                                                 dimming_proxy);
        }
}
예제 #2
0
static gboolean
init_server (GUPnPContext *context)
{
        NetworkLight *network_light;
        GUPnPRootDevice *dev;
        GUPnPServiceInfo *switch_power;
        GUPnPServiceInfo *dimming;
        GError *error = NULL;

        /* Create root device */
        dev = gupnp_root_device_new_full (context,
                                          gupnp_resource_factory_get_default (),
                                          doc,
                                          desc_location,
                                          DATA_DIR);

        switch_power = gupnp_device_info_get_service (GUPNP_DEVICE_INFO (dev),
                                                      SWITCH_SERVICE);

        if (switch_power) {
                gupnp_service_signals_autoconnect
                                (GUPNP_SERVICE (switch_power),
                                 NULL,
                                 &error);

                g_signal_connect (switch_power,
                                  "notify-failed",
                                  G_CALLBACK (on_notify_failed),
                                  NULL);
        }

        dimming = gupnp_device_info_get_service (GUPNP_DEVICE_INFO (dev),
                                                 DIMMING_SERVICE);

        if (dimming) {
                gupnp_service_signals_autoconnect (GUPNP_SERVICE (dimming),
                                                   NULL,
                                                   &error);

                g_signal_connect (dimming,
                                  "notify-failed",
                                  G_CALLBACK (on_notify_failed),
                                  NULL);
        }

        network_light = network_light_new (dev, switch_power, dimming);
        g_hash_table_insert (nl_hash, g_object_ref (context), network_light);

        /* Run */
        gupnp_root_device_set_available (dev, TRUE);

        g_print ("Attaching to IP/Host %s on port %d\n",
                 gupnp_context_get_host_ip (context),
                 gupnp_context_get_port (context));

        return TRUE;
}
void upnpConnectionManagerServiceConnect(UpnpConnectionManagerService *self) {
	UpnpConnectionManagerServicePrivate *priv = UPNP_CONNECTION_MANAGER_SERVICE_GET_PRIVATE(self);
	
	priv->service = gupnp_device_info_get_service(GUPNP_DEVICE_INFO(priv->device), "urn:schemas-upnp-org:service:ConnectionManager:3");
	if(!priv->service) {
//		g_printerr("Cannot get ConnectionManager service\n");
		
		exit(EXIT_FAILURE);
	}


/* ACTION CONNECT */
	g_signal_connect(GUPNP_SERVICE(priv->service), "action-invoked::GetProtocolInfo", G_CALLBACK(getProtocolInfo), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "action-invoked::GetCurrentConnectionIDs", G_CALLBACK(getCurrentConnectionIDs), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "action-invoked::GetCurrentConnectionInfo", G_CALLBACK(getCurrentConnectionInfo), self);

/* QUERY CONNECT */
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::SourceProtocolInfo", G_CALLBACK(querySourceProtocolInfo), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::SinkProtocolInfo", G_CALLBACK(querySinkProtocolInfo), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::CurrentConnectionIDs", G_CALLBACK(queryCurrentConnectionIDs), self);
//	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::FeatureList", G_CALLBACK(queryFeatureList), self);
//	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::ClockUpdateID", G_CALLBACK(queryClockUpdateID), self);
//	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::DeviceClockInfoUpdates", G_CALLBACK(queryDeviceClockInfoUpdates), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_ConnectionStatus", G_CALLBACK(queryConnectionStatus), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_ConnectionManager", G_CALLBACK(queryConnectionManager), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_Direction", G_CALLBACK(queryDirection), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_ProtocolInfo", G_CALLBACK(queryProtocolInfo), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_ConnectionID", G_CALLBACK(queryConnectionID), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_AVTransportID", G_CALLBACK(queryAVTransportID), self);
	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_RcsID", G_CALLBACK(queryRcsID), self);
//	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_ItemInfoFilter", G_CALLBACK(queryItemInfoFilter), self);
//	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_Result", G_CALLBACK(queryResult), self);
//	g_signal_connect(GUPNP_SERVICE(priv->service), "query-variable::A_ARG_TYPE_RenderingInfoList", G_CALLBACK(queryRenderingInfoList), self);
}
예제 #4
0
파일: rawudp-upnp.c 프로젝트: zsx/ossbuild
GObject *
start_upnp_server (void)
{
  GUPnPContext *context;
  GUPnPRootDevice *dev;
  GUPnPServiceInfo *service;
  GUPnPDeviceInfo *subdev1;
  GUPnPDeviceInfo *subdev2;

  context = gupnp_context_new (NULL, NULL, 0, NULL);
  ts_fail_if (context == NULL, "Can't get gupnp context");

  if (g_getenv ("UPNP_XML_PATH"))
  {
    gchar **paths = g_strsplit (g_getenv ("UPNP_XML_PATH"), ":", 0);
    gint i;

    for (i=0; paths[i]; i++)
    {
      gupnp_context_host_path (context, paths[i], "");
    }
    g_strfreev (paths);
  }
  else
  {
    gupnp_context_host_path (context, "upnp/InternetGatewayDevice.xml", "/InternetGatewayDevice.xml");
    gupnp_context_host_path (context, "upnp/WANIPConnection.xml", "/WANIPConnection.xml");
  }

  dev = gupnp_root_device_new (context, "/InternetGatewayDevice.xml");
  ts_fail_if (dev == NULL, "could not get root dev");

  subdev1 = gupnp_device_info_get_device (GUPNP_DEVICE_INFO (dev),
      "urn:schemas-upnp-org:device:WANDevice:1");
  ts_fail_if (subdev1 == NULL, "Could not get WANDevice");

  subdev2 = gupnp_device_info_get_device (subdev1,
      "urn:schemas-upnp-org:device:WANConnectionDevice:1");
  ts_fail_if (subdev2 == NULL, "Could not get WANConnectionDevice");
  g_object_unref (subdev1);

  service = gupnp_device_info_get_service (subdev2,
      "urn:schemas-upnp-org:service:WANIPConnection:1");
  ts_fail_if (service == NULL, "Could not get WANIPConnection");
  g_object_unref (subdev2);

  g_signal_connect (service, "action-invoked::GetExternalIPAddress",
      G_CALLBACK (get_external_ip_address_cb), NULL);
  g_signal_connect (service, "action-invoked::AddPortMapping",
      G_CALLBACK (add_port_mapping_cb), NULL);
  g_signal_connect (service, "action-invoked::DeletePortMapping",
      G_CALLBACK (delete_port_mapping_cb), NULL);

  gupnp_root_device_set_available (dev, TRUE);

  return G_OBJECT (context);
}
예제 #5
0
static void
on_network_light_unavailable (GUPnPControlPoint *control_point,
                              GUPnPDeviceProxy  *light_proxy,
                              gpointer           user_data)
{
        GUPnPServiceInfo *info;

        info = gupnp_device_info_get_service (GUPNP_DEVICE_INFO (light_proxy),
                                              SWITCH_SERVICE);
        if (info) {
                remove_service_from_list (info, &switch_proxies);
        }

        info = gupnp_device_info_get_service (GUPNP_DEVICE_INFO (light_proxy),
                                              DIMMING_SERVICE);
        if (info) {
                remove_service_from_list (info, &dimming_proxies);
        }
}
예제 #6
0
static GUPnPServiceInfo *prv_remove_bm_service_sub_devices(
						GUPnPDeviceInfo *device_info,
						dld_upnp_t *upnp,
						const gchar *ip_address)
{
	GList *child_devices;
	GList *next;
	GUPnPDeviceInfo *child_info = NULL;
	GUPnPServiceInfo *service_info = NULL;

	DLEYNA_LOG_DEBUG("Enter");

	child_devices = gupnp_device_info_list_devices(device_info);

	next = child_devices;
	while (next != NULL) {
		child_info = (GUPnPDeviceInfo *)next->data;

		service_info = gupnp_device_info_get_service(child_info,
					  DLD_BASIC_MANAGEMENT_SERVICE_TYPE);

		if (service_info != NULL)
			prv_remove_sub_device(upnp,
					      (GUPnPDeviceProxy *)child_info,
					      (GUPnPServiceProxy *)service_info,
					      ip_address);

		service_info = prv_remove_bm_service_sub_devices(child_info,
								 upnp,
								 ip_address);

		if (service_info != NULL)
			prv_remove_sub_device(upnp,
					      (GUPnPDeviceProxy *)child_info,
					      (GUPnPServiceProxy *)service_info,
					      ip_address);

		next = g_list_next(next);
	}

	g_list_free_full(child_devices, g_object_unref);

	DLEYNA_LOG_DEBUG("Exit");

	return service_info;
}
예제 #7
0
static void prv_device_available_cb(GUPnPControlPoint *cp,
				    GUPnPDeviceProxy *proxy,
				    gpointer user_data)
{
	dld_upnp_t *upnp = user_data;
	const char *udn;
	const gchar *ip_address;
	GUPnPServiceProxy *bms_proxy;

	DLEYNA_LOG_DEBUG("Enter");

	udn = gupnp_device_info_get_udn((GUPnPDeviceInfo *)proxy);

	ip_address = gupnp_context_get_host_ip(
					gupnp_control_point_get_context(cp));

	if (!udn || !ip_address)
		goto on_error;

	DLEYNA_LOG_DEBUG("UDN %s", udn);
	DLEYNA_LOG_DEBUG("IP Address %s", ip_address);

	bms_proxy = (GUPnPServiceProxy *)
			gupnp_device_info_get_service(
					(GUPnPDeviceInfo *)proxy,
					DLD_BASIC_MANAGEMENT_SERVICE_TYPE);

	if (bms_proxy != NULL)
		prv_add_device(upnp, proxy, bms_proxy, ip_address, udn);

	(void) prv_add_bm_service_sub_devices((GUPnPDeviceInfo *)proxy,
					      upnp,
					      ip_address);

on_error:

	DLEYNA_LOG_DEBUG("Exit");
	DLEYNA_LOG_DEBUG_NL();

	return;
}
static void
run_gupnp_simple_igd_test (GMainContext *mainctx, GUPnPSimpleIgd *igd,
    guint requested_port)
{
  GUPnPContext *context;
  GUPnPRootDevice *dev;
  GUPnPDeviceInfo *subdev1;
  GUPnPDeviceInfo *subdev2;
  const gchar *xml_path = ".";

  if (mainctx)
    g_main_context_push_thread_default (mainctx);
  context = gupnp_context_new (NULL, NULL, 0, NULL);
  g_assert (context);

  if (g_getenv ("XML_PATH"))
    xml_path = g_getenv ("XML_PATH");

  gupnp_context_host_path (context, xml_path, "");

  /*
  gupnp_context_host_path (context, "InternetGatewayDevice.xml", "/InternetGatewayDevice.xml");
  gupnp_context_host_path (context, "WANIPConnection.xml", "/WANIPConnection.xml");
  gupnp_context_host_path (context, "WANPPPConnection.xml", "/WANPPPConnection.xml");
  */

  dev = gupnp_root_device_new (context, "InternetGatewayDevice.xml", xml_path);
  g_assert (dev);

  subdev1 = gupnp_device_info_get_device (GUPNP_DEVICE_INFO (dev),
      "urn:schemas-upnp-org:device:WANDevice:1");
  g_assert (subdev1);

  subdev2 = gupnp_device_info_get_device (subdev1,
      "urn:schemas-upnp-org:device:WANConnectionDevice:1");
  g_assert (subdev2);
  g_object_unref (subdev1);

  ipservice = gupnp_device_info_get_service (subdev2,
      "urn:schemas-upnp-org:service:WANIPConnection:1");
  g_assert (ipservice);
  pppservice = gupnp_device_info_get_service (subdev2,
      "urn:schemas-upnp-org:service:WANPPPConnection:1");
  g_assert (pppservice);
  g_object_unref (subdev2);

  g_signal_connect (ipservice, "action-invoked::GetExternalIPAddress",
      G_CALLBACK (get_external_ip_address_cb), GINT_TO_POINTER (CONNECTION_IP));
  g_signal_connect (ipservice, "action-invoked::AddPortMapping",
      G_CALLBACK (add_port_mapping_cb), GUINT_TO_POINTER (requested_port));;
  g_signal_connect (ipservice, "action-invoked::DeletePortMapping",
      G_CALLBACK (delete_port_mapping_cb), GUINT_TO_POINTER (requested_port));

  g_signal_connect (pppservice, "action-invoked::GetExternalIPAddress",
      G_CALLBACK (get_external_ip_address_cb),
      GINT_TO_POINTER (CONNECTION_PPP));
  g_signal_connect (pppservice, "action-invoked::AddPortMapping",
      G_CALLBACK (add_port_mapping_cb), GUINT_TO_POINTER (requested_port));
  g_signal_connect (pppservice, "action-invoked::DeletePortMapping",
      G_CALLBACK (delete_port_mapping_cb), GUINT_TO_POINTER (requested_port));


  gupnp_root_device_set_available (dev, TRUE);


  g_signal_connect (igd, "mapped-external-port",
      G_CALLBACK (mapped_external_port_cb), GUINT_TO_POINTER (requested_port));
  g_signal_connect (igd, "error-mapping-port",
      G_CALLBACK (error_mapping_port_cb), NULL);

  gupnp_simple_igd_add_port (igd, "UDP", requested_port, "192.168.4.22",
      INTERNAL_PORT, 10, "GUPnP Simple IGD test");

  loop = g_main_loop_new (mainctx, FALSE);
  g_main_loop_run (loop);
  g_main_loop_unref (loop);

  gupnp_root_device_set_available (dev, FALSE);
  g_object_unref (dev);

  if (mainctx)
    g_main_context_pop_thread_default (mainctx);
  g_object_unref (context);

}
예제 #9
0
파일: light-server.c 프로젝트: Ham22/gupnp
int
main (G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv)
{
  GOptionContext *optionContext;
  GMainLoop *main_loop;
  GError *error = NULL;
  GUPnPContext *context;
  GUPnPRootDevice *dev;
  GUPnPServiceInfo *service;
  
#if !GLIB_CHECK_VERSION(2,35,0)
  g_type_init ();
#endif

  optionContext = g_option_context_new (NULL);
  g_option_context_add_main_entries (optionContext, entries, NULL);
  if (!g_option_context_parse (optionContext, &argc, &argv, &error))
  {
    g_print ("option parsing failed: %s\n", error->message);
    exit (1);
  }

  /* By default the light is off */
  status = FALSE;
  if (!quiet)
  {
    g_print ("The light is now %s.\n", status ? "on" : "off");
  }

  /* 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 root device */
  dev = gupnp_root_device_new (context, "BinaryLight1.xml", ".");
  gupnp_root_device_set_available (dev, TRUE);

  /* Get the switch service from the root device */
  service = gupnp_device_info_get_service
    (GUPNP_DEVICE_INFO (dev), "urn:schemas-upnp-org:service:SwitchPower:1");
  if (!service) {
    g_printerr ("Cannot get SwitchPower1 service\n");

    return EXIT_FAILURE;
  }
  
  /* Autoconnect the action and state variable handlers.  This connects
     query_target_cb and query_status_cb to the Target and Status state
     variables query callbacks, and set_target_cb, get_target_cb and
     get_status_cb to SetTarget, GetTarget and GetStatus actions
     respectively. */
  gupnp_service_signals_autoconnect (GUPNP_SERVICE (service), NULL, &error);
  if (error) {
    g_printerr ("Failed to autoconnect signals: %s\n", error->message);
    g_error_free (error);

    return EXIT_FAILURE;
  }
  
  /* 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 (service);
  g_object_unref (dev);
  g_object_unref (context);
  
  return EXIT_SUCCESS;
}