自学教程：C++ DLEYNA_LOG_DEBUG函数代码示例

void dls_upnp_create_container(dls_upnp_t *upnp, dls_client_t *client,			       dls_task_t *task,			       dls_upnp_task_complete_t cb){	dls_async_task_t *cb_data = (dls_async_task_t *)task;	DLEYNA_LOG_DEBUG("Enter");	cb_data->cb = cb;	DLEYNA_LOG_DEBUG("Root Path %s Id %s", task->target.root_path,			 task->target.id);	dls_device_create_container(client, task, task->target.id);	DLEYNA_LOG_DEBUG("Exit");}

static void prv_free_cb(gpointer data){	dleyna_task_queue_t *task_queue = data;	DLEYNA_LOG_DEBUG("Enter");	g_ptr_array_foreach(task_queue->tasks, prv_task_free_cb, task_queue);	g_ptr_array_unref(task_queue->tasks);	if (task_queue->task_queue_finally_cb)		task_queue->task_queue_finally_cb(task_queue->cancelled,						  task_queue->user_data);	g_free(task_queue);	DLEYNA_LOG_DEBUG("Exit");}

void dld_upnp_get_prop(dld_upnp_t *upnp, dld_task_t *task,		       dld_upnp_task_complete_t cb){	dld_device_t *device;	DLEYNA_LOG_DEBUG("Enter");	DLEYNA_LOG_DEBUG("Path: %s", task->path);	DLEYNA_LOG_DEBUG("Interface %s", task->ut.get_prop.interface_name);	DLEYNA_LOG_DEBUG("Prop.%s", task->ut.get_prop.prop_name);	device = prv_get_and_check_device(upnp, task, cb);	if (device != NULL)		dld_device_get_prop(device, task, cb);	DLEYNA_LOG_DEBUG("Exit");}

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

static void prv_connector_connect(			const gchar *server_name,			dleyna_connector_connected_cb_t connected_cb,			dleyna_connector_disconnected_cb_t disconnected_cb){	DLEYNA_LOG_DEBUG("Enter");	g_context.connected_cb = connected_cb;	g_context.disconnected_cb = disconnected_cb;	g_context.owner_id = g_bus_own_name(G_BUS_TYPE_SESSION,					    server_name,					    G_BUS_NAME_OWNER_FLAGS_NONE,					    prv_bus_acquired, NULL,					    prv_name_lost, NULL, NULL);	DLEYNA_LOG_DEBUG("Exit");}

static void prv_cancel(const dleyna_task_queue_key_t *queue_id,		       dleyna_task_queue_t *task_queue){	if (prv_cancel_only(queue_id, task_queue)) {		DLEYNA_LOG_DEBUG("Removing queue <%s,%s>",				 queue_id->source, queue_id->sink);		g_hash_table_remove(queue_id->processor->task_queues, queue_id);	}}

void dleyna_white_list_enable(dleyna_white_list_t *wl,			      gboolean enabled){	if (wl->gupnp_wl != NULL) {		gupnp_white_list_set_enabled(wl->gupnp_wl, enabled);		DLEYNA_LOG_DEBUG("White List enabled: %d", enabled);	}}

static guint prv_connector_publish_subtree(				dleyna_connector_id_t connection,				const gchar *object_path,				const dleyna_connector_dispatch_cb_t *cb_table,				guint cb_table_size,				dleyna_connector_interface_filter_cb_t cb){	guint flags;	guint object_id;	dleyna_dbus_object_t *object;	guint *object_key;	DLEYNA_LOG_DEBUG("Enter, path = <%s>", object_path);	object = g_new0(dleyna_dbus_object_t, 1);	flags = G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES;	object_id = g_dbus_connection_register_subtree(						(GDBusConnection *)connection,						object_path,						&g_subtree_vtable,						flags,						object,						NULL, NULL);	if (object_id) {		object->id = object_id;		object->root_path = g_strdup(object_path);		object->dispatch_table = cb_table;		object->dispatch_table_size = cb_table_size;		object->filter_cb = cb;		object_key = g_new(guint, 1);		*object_key = object_id;		g_hash_table_insert(g_context.objects, object_key, object);	} else {		g_free(object);	}	DLEYNA_LOG_DEBUG("Exit, object_id = %u", object_id);	return object_id;}

void dleyna_connector_mgr_release(const dleyna_connector_t *connector){	GModule *module;	DLEYNA_LOG_DEBUG("Enter");	module = g_hash_table_lookup(g_connectors, connector);	if (module) {		g_module_close(module);		g_hash_table_remove(g_connectors, connector);		if (g_hash_table_size(g_connectors) == 0) {			g_hash_table_unref(g_connectors);			g_connectors = NULL;		}	}	DLEYNA_LOG_DEBUG("Exit");}

void dls_upnp_create_reference(dls_upnp_t *upnp, dls_client_t *client,			       dls_task_t *task,			       dls_upnp_task_complete_t cb){	dls_async_task_t *cb_data = (dls_async_task_t *)task;	DLEYNA_LOG_DEBUG("Enter");	cb_data->cb = cb;	DLEYNA_LOG_DEBUG("Root Path: %s - Id: %s", task->target.root_path,			 task->target.id);	dls_device_create_reference(client, task);	DLEYNA_LOG_DEBUG("Exit");	return;}

dleyna_task_processor_t *dleyna_task_processor_new(GSourceFunc on_quit_cb){	dleyna_task_processor_t *processor;	DLEYNA_LOG_DEBUG("Enter");	processor = g_malloc(sizeof(*processor));	processor->task_queues = g_hash_table_new_full(prv_key_hash_cb,						       prv_key_equal_cb,						       prv_key_free_cb,						       prv_free_cb);	processor->running_tasks = 0;	processor->quitting = FALSE;	processor->on_quit_cb = on_quit_cb;	DLEYNA_LOG_DEBUG("Exit");	return processor;}

static void prv_dump_wl_entries(GUPnPWhiteList *wl){	GList *l;	l = gupnp_white_list_get_entries(wl);	DLEYNA_LOG_DEBUG_NL();	DLEYNA_LOG_DEBUG("White List entries:");	if (l != NULL) {		while (l != NULL) {			DLEYNA_LOG_DEBUG("     Entry: [%s].", (char *)l->data);			l = l->next;		}	} else {		DLEYNA_LOG_DEBUG("     White List Empty.");	}	DLEYNA_LOG_DEBUG_NL();}

void dleyna_white_list_clear(dleyna_white_list_t *wl){	if (wl->gupnp_wl != NULL) {		DLEYNA_LOG_DEBUG("Clear white list");		gupnp_white_list_clear(wl->gupnp_wl);#if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_DEBUG		prv_dump_wl_entries(wl->gupnp_wl);#endif	}}

const dleyna_connector_t *dleyna_connector_mgr_load(const gchar *name){	GModule *module;	const dleyna_connector_t *connector;	dleyna_connector_get_interface_t get_interface;	gchar *path;	DLEYNA_LOG_DEBUG("Enter");	path = g_strdup_printf("%s/%s%s.so", CONNECTOR_DIR,			       DLEYNA_CONNECTOR_LIB_PATTERN, name);	module = g_module_open(path, G_MODULE_BIND_LAZY);	g_free(path);	if (module) {		if (!g_connectors)			g_connectors = g_hash_table_new(g_direct_hash,							g_direct_equal);		if (g_module_symbol(module, "dleyna_connector_get_interface",				    (gpointer *)&get_interface)) {			connector = get_interface();			g_hash_table_insert(g_connectors, (gpointer)connector,					    module);		} else {			connector = NULL;			g_module_close(module);			DLEYNA_LOG_CRITICAL(					"Connector '%s' entry point not found",					name);		}	} else {		connector = NULL;		DLEYNA_LOG_CRITICAL("Connector '%s' not found", name);	}	DLEYNA_LOG_DEBUG("Exit");	return connector;}

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

GVariant *dlr_upnp_get_server_ids(dlr_upnp_t *upnp){	GVariantBuilder vb;	GHashTableIter iter;	gpointer value;	dlr_device_t *device;	DLEYNA_LOG_DEBUG("Enter");	g_variant_builder_init(&vb, G_VARIANT_TYPE("as"));	g_hash_table_iter_init(&iter, upnp->server_udn_map);	while (g_hash_table_iter_next(&iter, NULL, &value)) {		device = value;		g_variant_builder_add(&vb, "s", device->path);	}	DLEYNA_LOG_DEBUG("Exit");	return g_variant_ref_sink(g_variant_builder_end(&vb));}

void dleyna_white_list_add_entries(dleyna_white_list_t *wl,				   GVariant *entries){	GVariantIter viter;	gchar *entry;	DLEYNA_LOG_DEBUG("Enter");	if ((entries != NULL) && (wl->gupnp_wl != NULL)) {		(void) g_variant_iter_init(&viter, entries);		while (g_variant_iter_next(&viter, "&s", &entry))			(void) gupnp_white_list_add_entry(wl->gupnp_wl, entry);#if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_DEBUG		prv_dump_wl_entries(wl->gupnp_wl);#endif	}	DLEYNA_LOG_DEBUG("Exit");}

static gboolean prv_process_task(gpointer user_data){	dleyna_task_queue_key_t *queue_id = user_data;	dleyna_task_queue_t *queue;	DLEYNA_LOG_DEBUG("Enter - Start task processing for queue <%s,%s>",			 queue_id->source, queue_id->sink);	queue = g_hash_table_lookup(queue_id->processor->task_queues, queue_id);	queue->cancelled = FALSE;	queue->idle_id = 0;	queue->current_task = g_ptr_array_index(queue->tasks, 0);	g_ptr_array_remove_index(queue->tasks, 0);	queue_id->processor->running_tasks++;	queue->task_process_cb(queue->current_task, queue->user_data);	DLEYNA_LOG_DEBUG("Exit");	return FALSE;}

void dls_upnp_get_prop(dls_upnp_t *upnp, dls_client_t *client,		       dls_task_t *task,		       dls_upnp_task_complete_t cb){	gboolean root_object;	dls_async_task_t *cb_data = (dls_async_task_t *)task;	dls_async_get_prop_t *cb_task_data;	dls_prop_map_t *prop_map;	dls_task_get_prop_t *task_data;	DLEYNA_LOG_DEBUG("Enter");	DLEYNA_LOG_DEBUG("Path: %s", task->target.path);	DLEYNA_LOG_DEBUG("Interface %s", task->ut.get_prop.interface_name);	DLEYNA_LOG_DEBUG("Prop.%s", task->ut.get_prop.prop_name);	task_data = &task->ut.get_prop;	cb_data->cb = cb;	cb_task_data = &cb_data->ut.get_prop;	root_object = task->target.id[0] == '0' && task->target.id[1] == 0;	DLEYNA_LOG_DEBUG("Root Object = %d", root_object);	cb_task_data->protocol_info = client->protocol_info;	prop_map = g_hash_table_lookup(upnp->filter_map, task_data->prop_name);	dls_device_get_prop(client, task, prop_map, root_object);	DLEYNA_LOG_DEBUG("Exit with SUCCESS");}

void dls_upnp_upload_to_any(dls_upnp_t *upnp, dls_client_t *client,			    dls_task_t *task,			    dls_upnp_task_complete_t cb){	dls_async_task_t *cb_data = (dls_async_task_t *)task;	dls_async_upload_t *cb_task_data;	DLEYNA_LOG_DEBUG("Enter");	cb_data->cb = cb;	cb_task_data = &cb_data->ut.upload;	DLEYNA_LOG_DEBUG("Root Path %s Id %s", task->target.root_path,			 task->target.id);	if (strcmp(task->target.id, "0")) {		DLEYNA_LOG_WARNING("Bad path %s", task->target.path);		cb_data->error =			g_error_new(DLEYNA_SERVER_ERROR, DLEYNA_ERROR_BAD_PATH,				    "UploadToAnyContainer must be executed on a root path");		goto on_error;	}	if (!prv_compute_mime_and_class(task, cb_task_data, &cb_data->error))		goto on_error;	DLEYNA_LOG_DEBUG("MIME Type %s", cb_task_data->mime_type);	DLEYNA_LOG_DEBUG("Object class %s", cb_task_data->object_class);	dls_device_upload(client, task, "DLNA.ORG_AnyContainer");on_error:	if (!cb_data->action)		(void) g_idle_add(dls_async_task_complete, cb_data);	DLEYNA_LOG_DEBUG("Exit");}

static guint prv_connector_publish_object(			dleyna_connector_id_t connection,			const gchar *object_path,			gboolean root,			const gchar* interface_name,			const dleyna_connector_dispatch_cb_t *cb_table_1){	guint object_id;	GDBusInterfaceInfo *info;	dleyna_dbus_object_t *object;	guint *object_key;	DLEYNA_LOG_DEBUG("Enter, path = <%s>", object_path);	object = g_new0(dleyna_dbus_object_t, 1);	info = prv_find_interface_info(root, interface_name);	object_id = g_dbus_connection_register_object(						(GDBusConnection *)connection,						object_path,						info,						&g_object_vtable,						object, NULL, NULL);	if (object_id) {		object->id = object_id;		object->dispatch_table = cb_table_1;		object->dispatch_table_size = 1;		object_key = g_new(guint, 1);		*object_key = object_id;		g_hash_table_insert(g_context.objects, object_key, object);	} else {		g_free(object);	}	DLEYNA_LOG_DEBUG("Exit, object_id = %u", object_id);	return object_id;}

void dls_upnp_get_children(dls_upnp_t *upnp, dls_client_t *client,			   dls_task_t *task,			   dls_upnp_task_complete_t cb){	dls_async_task_t *cb_data = (dls_async_task_t *)task;	dls_async_bas_t *cb_task_data;	gchar *upnp_filter = NULL;	gchar *sort_by = NULL;	DLEYNA_LOG_DEBUG("Enter");	DLEYNA_LOG_DEBUG("Path: %s", task->target.path);	DLEYNA_LOG_DEBUG("Start: %u", task->ut.get_children.start);	DLEYNA_LOG_DEBUG("Count: %u", task->ut.get_children.count);	cb_data->cb = cb;	cb_task_data = &cb_data->ut.bas;	cb_task_data->filter_mask =		dls_props_parse_filter(upnp->filter_map,				       task->ut.get_children.filter,				       &upnp_filter);	DLEYNA_LOG_DEBUG("Filter Mask 0x%"G_GUINT64_FORMAT"x",			 cb_task_data->filter_mask);	sort_by = dls_sort_translate_sort_string(upnp->filter_map,						 task->ut.get_children.sort_by);	if (!sort_by) {		DLEYNA_LOG_WARNING("Invalid Sort Criteria");		cb_data->error = g_error_new(DLEYNA_SERVER_ERROR,					     DLEYNA_ERROR_BAD_QUERY,					     "Sort Criteria are not valid");		goto on_error;	}	DLEYNA_LOG_DEBUG("Sort By %s", sort_by);	cb_task_data->protocol_info = client->protocol_info;	dls_device_get_children(client, task, upnp_filter, sort_by);on_error:	if (!cb_data->action)		(void) g_idle_add(dls_async_task_complete, cb_data);	g_free(sort_by);	g_free(upnp_filter);	DLEYNA_LOG_DEBUG("Exit with %s", !cb_data->action ? "FAIL" : "SUCCESS");}

void dlr_manager_get_prop(dlr_manager_t *manager,			  dleyna_settings_t *settings,			  dlr_task_t *task,			  dlr_manager_task_complete_t cb){	dlr_async_task_t *cb_data = (dlr_async_task_t *)task;	dlr_task_get_prop_t *task_data = &task->ut.get_prop;	gchar *i_name = task_data->interface_name;	gchar *name = task_data->prop_name;	DLEYNA_LOG_DEBUG("Enter");	DLEYNA_LOG_DEBUG("Path: %s", task->path);	DLEYNA_LOG_DEBUG("Interface %s", i_name);	DLEYNA_LOG_DEBUG("Prop.%s", name);	cb_data->cb = cb;	if (!strcmp(i_name, DLEYNA_SERVER_INTERFACE_MANAGER) ||	    !strcmp(i_name, "")) {		cb_data->task.result = prv_get_prop(settings, name);		if (!cb_data->task.result)			cb_data->error = g_error_new(						DLEYNA_SERVER_ERROR,						DLEYNA_ERROR_UNKNOWN_PROPERTY,						"Unknown property");	} else {		DLEYNA_LOG_WARNING("Interface is unknown.");		cb_data->error = g_error_new(DLEYNA_SERVER_ERROR,					     DLEYNA_ERROR_UNKNOWN_INTERFACE,					     "Interface is unknown.");	}	(void) g_idle_add(dlr_async_task_complete, cb_data);	DLEYNA_LOG_DEBUG("Exit");}

static gboolean prv_cancel_cb(gpointer key, gpointer value, gpointer user_data){	dleyna_task_queue_key_t *queue_id = key;	dleyna_task_queue_t *task_queue = value;	gboolean retval = prv_cancel_only(queue_id, task_queue);#if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_DEBUG	if (retval)		DLEYNA_LOG_DEBUG("Removing queue <%s,%s>", queue_id->source,				 queue_id->sink);#endif	return retval;}

static void prv_connector_shutdown(void){	DLEYNA_LOG_DEBUG("Enter");	if (g_context.objects)		g_hash_table_unref(g_context.objects);	if (g_context.clients)		g_hash_table_unref(g_context.clients);	prv_connector_disconnect();	if (g_context.connection)		g_object_unref(g_context.connection);	if (g_context.server_node_info)		g_dbus_node_info_unref(g_context.server_node_info);	if (g_context.root_node_info)		g_dbus_node_info_unref(g_context.root_node_info);	DLEYNA_LOG_DEBUG("Exit");}

void dlr_upnp_remove_uri(dlr_upnp_t *upnp, dlr_task_t *task,			 dlr_upnp_task_complete_t cb){	dlr_device_t *device;	dlr_async_task_t *cb_data = (dlr_async_task_t *)task;	DLEYNA_LOG_DEBUG("Enter");	device = dlr_device_from_path(task->path, upnp->server_udn_map);	if (!device) {		cb_data->cb = cb;		cb_data->error = g_error_new(DLEYNA_SERVER_ERROR,					     DLEYNA_ERROR_OBJECT_NOT_FOUND,					     "Cannot locate a device for the specified object");		(void) g_idle_add(dlr_async_task_complete, cb_data);	} else {		dlr_device_remove_uri(device, task, upnp->host_service, cb);	}	DLEYNA_LOG_DEBUG("Exit");}

static gboolean prv_connector_initialize(const gchar *server_info,					 const gchar *root_info,					 GQuark error_quark,					 gpointer user_data){	gboolean success = TRUE;	DLEYNA_LOG_DEBUG("Enter");	memset(&g_context, 0, sizeof(g_context));	g_context.objects = g_hash_table_new_full(g_direct_hash, g_direct_equal,						  g_free, prv_free_dbus_object);	g_context.clients = g_hash_table_new_full(g_str_hash, g_str_equal,						  g_free, NULL);	g_context.root_node_info = g_dbus_node_info_new_for_xml(root_info,								NULL);	if (!g_context.root_node_info) {		success = FALSE;		goto out;	}	g_context.server_node_info = g_dbus_node_info_new_for_xml(server_info,								  NULL);	if (!g_context.server_node_info) {		success = FALSE;		goto out;	}	prv_connector_init_error_domain(error_quark);out:	DLEYNA_LOG_DEBUG("Exit");	return success;}

static gboolean prv_connector_watch_client(const gchar *client_name){	guint watch_id;	gboolean added = TRUE;	DLEYNA_LOG_DEBUG("Enter");	if (g_hash_table_lookup(g_context.clients, client_name)) {		added = FALSE;		goto out;	}	watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION, client_name,				      G_BUS_NAME_WATCHER_FLAGS_NONE,				      NULL, prv_lost_client, NULL,				      NULL);	g_hash_table_insert(g_context.clients, g_strdup(client_name),			    GUINT_TO_POINTER(watch_id));out:	DLEYNA_LOG_DEBUG("Exit");	return added;}

void dlr_manager_get_all_props(dlr_manager_t *manager,			       dleyna_settings_t *settings,			       dlr_task_t *task,			       dlr_manager_task_complete_t cb){	dlr_async_task_t *cb_data = (dlr_async_task_t *)task;	dlr_task_get_props_t *task_data = &task->ut.get_props;	gchar *i_name = task_data->interface_name;	GVariantBuilder vb;	DLEYNA_LOG_DEBUG("Enter");	DLEYNA_LOG_DEBUG("Path: %s", task->path);	DLEYNA_LOG_DEBUG("Interface %s", i_name);	cb_data->cb = cb;	g_variant_builder_init(&vb, G_VARIANT_TYPE("a{sv}"));	if (!strcmp(i_name, DLEYNA_SERVER_INTERFACE_MANAGER) ||	    !strcmp(i_name, "")) {		prv_add_all_props(settings, &vb);		cb_data->task.result = g_variant_ref_sink(						g_variant_builder_end(&vb));	} else {		DLEYNA_LOG_WARNING("Interface is unknown.");		cb_data->error = g_error_new(DLEYNA_SERVER_ERROR,					     DLEYNA_ERROR_UNKNOWN_INTERFACE,					     "Interface is unknown.");	}	(void) g_idle_add(dlr_async_task_complete, cb_data);	DLEYNA_LOG_DEBUG("Exit");}