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

int cwmp_agent_upload_file(upload_arg_t * ularg){    int faultcode = 0;    FUNCTION_TRACE();    char * fromfile;	if(strcpy(ularg->filetype, "1 Vendor Configuration File") == 0)	{		//根据实际情况, 修改这里的配置文件路径				fromfile = "/tmp/mysystem.cfg";	}	else if(strcpy(ularg->filetype, "2 Vendor Log File") == 0)	{		//根据实际情况, 修改这里的配置文件路径		fromfile = "/tmp/mysystem.log";	}	else	{		fromfile = "/tmp/mysystem.cfg";	}	    faultcode = http_send_file(fromfile, ularg->url);    if(faultcode != CWMP_OK)    {	faultcode = 9001;    }       return faultcode;}

acpi_statuspr_remove_device (	void			**context){	acpi_status		status = AE_OK;	PR_CONTEXT		*processor= NULL;	FUNCTION_TRACE("pr_remove_device");	if (!context || !*context) {		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	processor = (PR_CONTEXT*)(*context);	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing processor device [%02x]./n", processor->device_handle));	pr_osl_remove_device(processor);	pr_perf_remove_device(processor);	pr_power_remove_device(processor);	acpi_os_free(processor);	return_ACPI_STATUS(status);}

voidpr_print (	PR_CONTEXT              *processor){#ifdef ACPI_DEBUG	acpi_buffer             buffer;	FUNCTION_TRACE("pr_print");	buffer.length = 256;	buffer.pointer = acpi_os_callocate(buffer.length);	if (!buffer.pointer) {		return;	}	/*	 * Get the full pathname for this ACPI object.	 */	acpi_get_name(processor->acpi_handle, ACPI_FULL_PATHNAME, &buffer);	/*	 * Print out basic processor information.	 */	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------/n"));	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| Processor[%02x]:[%p] uid[%02x] %s/n", processor->device_handle, processor->acpi_handle, processor->uid, (char*)buffer.pointer));	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "|   power: %cC0 %cC1 %cC2[%d] %cC3[%d]/n", (processor->power.state[0].is_valid?'+':'-'), (processor->power.state[1].is_valid?'+':'-'), (processor->power.state[2].is_valid?'+':'-'), processor->power.state[2].latency, (processor->power.state[3].is_valid?'+':'-'), processor->power.state[3].latency));	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "|   performance: states[%d]/n", processor->performance.state_count));	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------/n"));	acpi_os_free(buffer.pointer);#endif /* ACPI_DEBUG */	return;}

ACPI_STATUSAcpiDsMethodDataSetEntry (    UINT16                  Opcode,    UINT32                  Index,    ACPI_OPERAND_OBJECT     *Object,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     **Entry;    FUNCTION_TRACE ("DsMethodDataSetEntry");    /* Get a pointer to the stack entry to set */    Status = AcpiDsMethodDataGetEntry (Opcode, Index, WalkState, &Entry);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Increment ref count so object can't be deleted while installed */    AcpiUtAddReference (Object);    /* Install the object into the stack entry */    *Entry = Object;    return_ACPI_STATUS (AE_OK);}

acpi_statusacpi_ds_scope_stack_pop (	acpi_walk_state         *walk_state){	acpi_generic_state      *scope_info;	FUNCTION_TRACE ("Ds_scope_stack_pop");	/*	 * Pop scope info object off the stack.	 */	scope_info = acpi_ut_pop_generic_state (&walk_state->scope_info);	if (!scope_info) {		return_ACPI_STATUS (AE_STACK_UNDERFLOW);	}	ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,		"Popped object type %X/n", scope_info->common.value));	acpi_ut_delete_generic_state (scope_info);	return_ACPI_STATUS (AE_OK);}

acpi_statusacpi_ns_unload_namespace (	acpi_handle             handle){	acpi_status             status;	FUNCTION_TRACE ("Ns_unload_name_space");	/* Parameter validation */	if (!acpi_gbl_root_node) {		return_ACPI_STATUS (AE_NO_NAMESPACE);	}	if (!handle) {		return_ACPI_STATUS (AE_BAD_PARAMETER);	}	/* This function does the real work */	status = acpi_ns_delete_subtree (handle);	return_ACPI_STATUS (status);}

acpi_statusec_notify (	BM_NOTIFY               notify,	BM_HANDLE               device_handle,	void                    **context){	acpi_status             status = AE_OK;	FUNCTION_TRACE("ec_notify");	switch (notify) {	case BM_NOTIFY_DEVICE_ADDED:		status = ec_add_device(device_handle, context);		break;	case BM_NOTIFY_DEVICE_REMOVED:		status = ec_remove_device(context);		break;	default:		status = AE_SUPPORT;		break;	}	return_ACPI_STATUS(status);}

acpi_statusacpi_get_firmware_waking_vector (	ACPI_PHYSICAL_ADDRESS *physical_address){	FUNCTION_TRACE ("Acpi_get_firmware_waking_vector");	if (!physical_address) {		return_ACPI_STATUS (AE_BAD_PARAMETER);	}	/* Make sure that we have an FACS */	if (!acpi_gbl_FACS) {		return_ACPI_STATUS (AE_NO_ACPI_TABLES);	}	/* Get the vector */	if (acpi_gbl_FACS->vector_width == 32) {		*physical_address = * (u32 *) acpi_gbl_FACS->firmware_waking_vector;	}	else {		*physical_address = *acpi_gbl_FACS->firmware_waking_vector;	}	return_ACPI_STATUS (AE_OK);}

voidtz_policy_run (	unsigned long           data){	acpi_status             status = AE_OK;	FUNCTION_TRACE("tz_policy_run");	if (!data) {		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid (NULL) context./n"));		return_VOID;	}	/*	 * Defer to Non-Interrupt Level:	 * -----------------------------	 * Note that all Linux kernel timers run at interrupt-level (ack!).	 */	status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,  tz_policy_check, (void*)data);	if (ACPI_FAILURE(status)) {		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Error invoking thermal policy./n"));	}	return_VOID;}

acpi_statusacpi_leave_sleep_state (	u8                  sleep_state){	acpi_object_list    arg_list;	acpi_object         arg;	FUNCTION_TRACE ("Acpi_leave_sleep_state");	MEMSET (&arg_list, 0, sizeof(arg_list));	arg_list.count = 1;	arg_list.pointer = &arg;	MEMSET (&arg, 0, sizeof(arg));	arg.type = ACPI_TYPE_INTEGER;	arg.integer.value = sleep_state;	acpi_evaluate_object (NULL, "//_BFS", &arg_list, NULL);	acpi_evaluate_object (NULL, "//_WAK", &arg_list, NULL);	/* _WAK returns stuff - do we want to look at it? */	acpi_hw_enable_non_wakeup_gpes();	return_ACPI_STATUS (AE_OK);}

acpi_statusacpi_set_firmware_waking_vector (	ACPI_PHYSICAL_ADDRESS physical_address){	FUNCTION_TRACE ("Acpi_set_firmware_waking_vector");	/* Make sure that we have an FACS */	if (!acpi_gbl_FACS) {		return_ACPI_STATUS (AE_NO_ACPI_TABLES);	}	/* Set the vector */	if (acpi_gbl_FACS->vector_width == 32) {		* (u32 *) acpi_gbl_FACS->firmware_waking_vector = (u32) physical_address;	}	else {		*acpi_gbl_FACS->firmware_waking_vector = physical_address;	}	return_ACPI_STATUS (AE_OK);}

acpi_statusacpi_ex_pci_config_space_handler (	u32                     function,	ACPI_PHYSICAL_ADDRESS   address,	u32                     bit_width,	u32                     *value,	void                    *handler_context,	void                    *region_context){	acpi_status             status = AE_OK;	acpi_pci_id             *pci_id;	u16                     pci_register;	FUNCTION_TRACE ("Ex_pci_config_space_handler");	/*	 *  The arguments to Acpi_os(Read|Write)Pci_cfg(Byte|Word|Dword) are:	 *	 *  Pci_segment is the PCI bus segment range 0-31	 *  Pci_bus     is the PCI bus number range 0-255	 *  Pci_device  is the PCI device number range 0-31	 *  Pci_function is the PCI device function number	 *  Pci_register is the Config space register range 0-255 bytes	 *	 *  Value - input value for write, output address for read	 *	 */	pci_id      = (acpi_pci_id *) region_context;	pci_register = (u16) address;	ACPI_DEBUG_PRINT ((ACPI_DB_INFO,		"Pci_config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)/n",		function, bit_width, pci_id->segment, pci_id->bus, pci_id->device,		pci_id->function, pci_register));	switch (function) {	case ACPI_READ_ADR_SPACE:		*value = 0;		status = acpi_os_read_pci_configuration (pci_id, pci_register, value, bit_width);		break;	case ACPI_WRITE_ADR_SPACE:		status = acpi_os_write_pci_configuration (pci_id, pci_register, *value, bit_width);		break;	default:		status = AE_BAD_PARAMETER;		break;	}	return_ACPI_STATUS (status);}

acpi_statusbn_terminate (void){	acpi_status		status = AE_OK;	BM_DEVICE_ID		criteria;	BM_DRIVER		driver;	FUNCTION_TRACE("bn_terminate");	MEMSET(&criteria, 0, sizeof(BM_DEVICE_ID));	MEMSET(&driver, 0, sizeof(BM_DRIVER));	driver.notify = &bn_notify;	driver.request = &bn_request;	/*	 * Unregister for power buttons.	 */	MEMCPY(criteria.hid, BN_HID_POWER_BUTTON, sizeof(BN_HID_POWER_BUTTON));	status = bm_unregister_driver(&criteria, &driver);	/*	 * Unregister for sleep buttons.	 */	MEMCPY(criteria.hid, BN_HID_SLEEP_BUTTON, sizeof(BN_HID_SLEEP_BUTTON));	status = bm_unregister_driver(&criteria, &driver);	/*	 * Unregister for LID switches.	 */	MEMCPY(criteria.hid, BN_HID_LID_SWITCH, sizeof(BN_HID_LID_SWITCH));	status = bm_unregister_driver(&criteria, &driver);	return_ACPI_STATUS(status);}

ACPI_PARSE_STATE *AcpiPsCreateState (    UINT8                   *Aml,    UINT32                  AmlSize){    ACPI_PARSE_STATE        *ParserState;    FUNCTION_TRACE ("PsCreateState");    ParserState = ACPI_MEM_CALLOCATE (sizeof (ACPI_PARSE_STATE));    if (!ParserState)    {        return_PTR (NULL);    }    ParserState->Aml       = Aml;    ParserState->AmlEnd    = Aml + AmlSize;    ParserState->PkgEnd    = ParserState->AmlEnd;    ParserState->AmlStart  = Aml;    return_PTR (ParserState);}

acpi_statusacpi_ns_initialize_devices (	void){	acpi_status             status;	acpi_device_walk_info   info;	FUNCTION_TRACE ("Ns_initialize_devices");	info.device_count = 0;	info.num_STA = 0;	info.num_INI = 0;	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "Executing device _INI methods:"));	status = acpi_ns_walk_namespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,			  ACPI_UINT32_MAX, FALSE, acpi_ns_init_one_device, &info, NULL);	if (ACPI_FAILURE (status)) {		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Walk_namespace failed! %x/n", status));	}	ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,		"/n%d Devices found: %d _STA, %d _INI/n",		info.device_count, info.num_STA, info.num_INI));	return_ACPI_STATUS (status);}

acpi_statustz_policy_remove_device(	TZ_CONTEXT		*tz){	u32			i = 0;	FUNCTION_TRACE("tz_remove_device");	if (!tz) {		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing policy for thermal zone [%02x]./n", tz->device_handle));	/*	 * Delete the thermal zone policy timer entry, if exists.	 */	if (timer_pending(&(tz->policy.timer)))		del_timer(&(tz->policy.timer));	/*	 * Reset thermal performance limit on all processors back to max.	 */	if (tz->policy.thresholds.passive.is_valid) {		for (i=0; i<tz->policy.thresholds.passive.devices.count; i++)			set_performance_limit(tz->policy.thresholds.passive.devices.handles[i], PR_PERF_MAX);	}	return_ACPI_STATUS(AE_OK);}

acpi_statusacpi_ns_load_table (	acpi_table_desc         *table_desc,	acpi_namespace_node     *node){	acpi_status             status;	FUNCTION_TRACE ("Ns_load_table");	if (!table_desc->aml_start) {		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null AML pointer/n"));		return_ACPI_STATUS (AE_BAD_PARAMETER);	}	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AML block at %p/n", table_desc->aml_start));	if (!table_desc->aml_length) {		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Zero-length AML block/n"));		return_ACPI_STATUS (AE_BAD_PARAMETER);	}	/*	 * Parse the table and load the namespace with all named	 * objects found within.  Control methods are NOT parsed	 * at this time.  In fact, the control methods cannot be	 * parsed until the entire namespace is loaded, because	 * if a control method makes a forward reference (call)	 * to another control method, we can't continue parsing	 * because we don't know how many arguments to parse next!	 */	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Loading table into namespace ****/n"));	acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);	status = acpi_ns_parse_table (table_desc, node->child);	acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);	if (ACPI_FAILURE (status)) {		return_ACPI_STATUS (status);	}	/*	 * Now we can parse the control methods.  We always parse	 * them here for a sanity check, and if configured for	 * just-in-time parsing, we delete the control method	 * parse trees.	 */	ACPI_DEBUG_PRINT ((ACPI_DB_INFO,		"**** Begin Table Method Parsing and Object Initialization ****/n"));	status = acpi_ds_initialize_objects (table_desc, node);	ACPI_DEBUG_PRINT ((ACPI_DB_INFO,		"**** Completed Table Method Parsing and Object Initialization ****/n"));	return_ACPI_STATUS (status);}

acpi_statustz_remove_device (	void			**context){	acpi_status		status = AE_OK;	TZ_CONTEXT		*tz = NULL;	FUNCTION_TRACE("tz_remove_device");	if (!context || !*context) {		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	tz = (TZ_CONTEXT*)(*context);	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing thermal zone [%02x]./n", tz->device_handle));	status = tz_osl_remove_device(tz);	/*	 * Remove Policy:	 * --------------	 * TBD: Move all thermal zone policy to user-mode daemon...	 */	status = tz_policy_remove_device(tz);	if (ACPI_FAILURE(status)) {		return_ACPI_STATUS(status);	}	acpi_os_free(tz);	return_ACPI_STATUS(status);}

acpi_statusec_remove_device(	void                    **context){	acpi_status             status = AE_OK;	EC_CONTEXT              *ec = NULL;	FUNCTION_TRACE("ec_remove_device");	if (!context || !*context) {		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	ec = (EC_CONTEXT*)*context;	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing EC device [%02x]./n", ec->device_handle));	ec_remove_space_handler(ec);	ec_remove_gpe_handler(ec);	if (ec->mutex) {		acpi_os_delete_semaphore(ec->mutex);	}	acpi_os_free(ec);	*context = NULL;	return_ACPI_STATUS(status);}

acpi_statustz_request (	BM_REQUEST		*request,	void                    *context){	acpi_status             status = AE_OK;	TZ_CONTEXT              *tz = NULL;	FUNCTION_TRACE("tz_request");	/*	 * Must have a valid request structure and context.	 */	if (!request || !context) {		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	tz = (TZ_CONTEXT*)context;	/*	 * Handle request:	 * ---------------	 */	switch (request->command) {	default:		status = AE_SUPPORT;		break;	}	request->status = status;	return_ACPI_STATUS(status);}

//InternetGatewayDevice.DeviceInfo.Manufacturerint cpe_get_igd_di_manufacturer(cwmp_t * cwmp, const char * name, char ** value, pool_t * pool){    FUNCTION_TRACE();    *value = cwmp_conf_pool_get(pool, "cwmp:cpe_manufacture");    cwmp_log_debug("cpe_get_igd_di_manufacturer: value is %s", *value);    return	FAULT_CODE_OK;}

voidec_query_handler (	void                    *context){	EC_CONTEXT		*ec = (EC_CONTEXT*)context;	static char		object_name[5] = {'_','Q','0','0','/0'};	const char		hex[] = {'0','1','2','3','4','5','6','7','8',					'9','A','B','C','D','E','F'};	FUNCTION_TRACE("ec_query_handler");	if (!ec) {		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid (NULL) context./n"));		return_VOID;	}	/*	 * Evaluate _Qxx:	 * --------------	 * Evaluate corresponding _Qxx method.  Note that a zero query value	 * indicates a spurious EC_SCI (no such thing as _Q00).	 */	object_name[2] = hex[((ec->query_data >> 4) & 0x0F)];	object_name[3] = hex[(ec->query_data & 0x0F)];	ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Evaluating [%s] for ec [%02x]./n", object_name, ec->device_handle));	bm_evaluate_object(ec->acpi_handle, object_name, NULL, NULL);	return_VOID;}

voidAcpiNsDumpTables (    ACPI_HANDLE             SearchBase,    UINT32                  MaxDepth){    ACPI_HANDLE             SearchHandle = SearchBase;    FUNCTION_TRACE ("NsDumpTables");    if (!AcpiGbl_RootNode)    {        /*         * If the name space has not been initialized,         * there is nothing to dump.         */        ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "name space not initialized!/n"));        return_VOID;    }    if (NS_ALL == SearchBase)    {        /*  entire namespace    */        SearchHandle = AcpiGbl_RootNode;        ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "///n"));    }    AcpiNsDumpObjects (ACPI_TYPE_ANY, MaxDepth, ACPI_UINT32_MAX, SearchHandle);    return_VOID;}

ACPI_STATUSAcpiDisable (void){    ACPI_STATUS             Status;    FUNCTION_TRACE ("AcpiDisable");    /* Ensure that ACPI has been initialized */    ACPI_IS_INITIALIZATION_COMPLETE (Status);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Restore original mode  */    Status = AcpiHwSetMode (AcpiGbl_OriginalMode);    if (ACPI_FAILURE (Status))    {        ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unable to transition to original mode"));        return_ACPI_STATUS (Status);    }    /* Unload the SCI interrupt handler  */    AcpiEvRemoveSciHandler ();    AcpiEvRestoreAcpiState ();    return_ACPI_STATUS (Status);}

acpi_statusacpi_tb_install_table (    acpi_table_header       *table_ptr,    acpi_table_desc         *table_info){    acpi_status             status;    FUNCTION_TRACE ("Tb_install_table");    /*     * Check the table signature and make sure it is recognized     * Also checks the header checksum     */    status = acpi_tb_recognize_table (table_ptr, table_info);    if (ACPI_FAILURE (status)) {        return_ACPI_STATUS (status);    }    /* Lock tables while installing */    acpi_ut_acquire_mutex (ACPI_MTX_TABLES);    /* Install the table into the global data structure */    status = acpi_tb_init_table_descriptor (table_info->type, table_info);    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s located at %p/n",                       acpi_gbl_acpi_table_data[table_info->type].name, table_info->pointer));    acpi_ut_release_mutex (ACPI_MTX_TABLES);    return_ACPI_STATUS (status);}

void *acpi_ut_allocate_object_desc_dbg (	NATIVE_CHAR             *module_name,	u32                     line_number,	u32                     component_id){	acpi_operand_object     *object;	FUNCTION_TRACE ("Ut_allocate_object_desc_dbg");	object = acpi_ut_acquire_from_cache (ACPI_MEM_LIST_OPERAND);	if (!object) {		_REPORT_ERROR (module_name, line_number, component_id,				  ("Could not allocate an object descriptor/n"));		return_PTR (NULL);	}	/* Mark the descriptor type */	object->common.data_type = ACPI_DESC_TYPE_INTERNAL;	ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X/n",			object, sizeof (acpi_operand_object)));	return_PTR (object);}

acpi_statuspr_terminate (void){	acpi_status             status = AE_OK;	BM_DEVICE_ID		criteria;	BM_DRIVER		driver;	FUNCTION_TRACE("pr_terminate");	memset(&criteria, 0, sizeof(BM_DEVICE_ID));	memset(&driver, 0, sizeof(BM_DRIVER));	/*	 * Terminate power (Cx state) policy.	 */	status = pr_power_terminate();	if (ACPI_FAILURE(status)) {		return_ACPI_STATUS(status);	}	/*	 * Unegister driver for processor devices.	 */	criteria.type = BM_TYPE_PROCESSOR;	driver.notify = &pr_notify;	driver.request = &pr_request;	status = bm_unregister_driver(&criteria, &driver);	return_ACPI_STATUS(status);}

static void test_getset_parameter_node_value (abts_case *tc, void *data){    cwmp_t * c = (cwmp_t*)data;    parameter_node_t * param;    char * name = "InternetGatewayDevice.DeviceInfo.SoftwareVersion";    char * retval;    char * value ;        pool_t * pool = pool_create(POOL_DEFAULT_SIZE);    FUNCTION_TRACE();    param = cwmp_get_parameter_path_node(c->root, name);    ASSERT_NOTNULL(param);        value = "V1.3.x";    cwmp_set_parameter_node_value(c, param, name, value, strlen(value));        retval = cwmp_data_get_parameter_value(c, param, name, pool);    printf("retval ------------------is %s/n", retval);    ASSERT_STR_EQ(value, retval);           value = "V1.4.x";    cwmp_set_parameter_node_value(c, param, name, value, strlen(value));    retval = cwmp_data_get_parameter_value(c, param, name, pool);    ASSERT_STR_EQ(value, retval);            pool_destroy(pool);}

acpi_nameacpi_ns_find_parent_name (	acpi_namespace_node     *child_node){	acpi_namespace_node     *parent_node;	FUNCTION_TRACE ("Ns_find_parent_name");	if (child_node) {		/* Valid entry.  Get the parent Node */		parent_node = acpi_ns_get_parent_object (child_node);		if (parent_node) {			ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Parent of %p [%4.4s] is %p [%4.4s]/n",				child_node, (char*)&child_node->name, parent_node, (char*)&parent_node->name));			if (parent_node->name) {				return_VALUE (parent_node->name);			}		}		ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "unable to find parent of %p (%4.4s)/n",			child_node, (char*)&child_node->name));	}	return_VALUE (ACPI_UNKNOWN_NAME);}

int cwmp_agent_download_file(download_arg_t * dlarg){    int faultcode = 0;    char * fromurl = dlarg->url;    char * tofile = "/tmp/download.img";    FUNCTION_TRACE();    if(dlarg->url && TRstrncasecmp("ftp://", dlarg->url, 6) == 0)    {	    return 9001;	  }    faultcode = http_receive_file(fromurl, tofile);    if(faultcode != CWMP_OK)    {	     faultcode = 9001;    }       return faultcode;}