/*
 *	This program is free software: you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation, either version 2 of the License, or
 *	(at your option) any later version.
 *
 *	Copyright (C) 2013-2019 iopsys Software Solutions AB
 *	  Author Mohamed Kallel <mohamed.kallel@pivasoftware.com>
 *	  Author Ahmed Zribi <ahmed.zribi@pivasoftware.com>
 *
 */

#include <unistd.h>
#include <fcntl.h>
#include "backupSession.h"
#include "xml.h"
#include "log.h"
#include "notifications.h"
#include "event.h"

static mxml_node_t *bkp_tree = NULL;
pthread_mutex_t mutex_backup_session = PTHREAD_MUTEX_INITIALIZER;

void bkp_tree_clean(void)
{
	if (bkp_tree != NULL)
		MXML_DELETE(bkp_tree);
	return;
}

void bkp_session_save()
{
	FILE *fp;

	pthread_mutex_lock(&mutex_backup_session);
	fp = fopen(CWMP_BKP_FILE, "w");
	mxmlSaveFile(bkp_tree, fp, MXML_NO_CALLBACK);
	fclose(fp);
	sync();
	pthread_mutex_unlock(&mutex_backup_session);
}

mxml_node_t *bkp_session_insert(mxml_node_t *tree, char *name, char *value)
{
	mxml_node_t *b;

	b = mxmlNewElement(tree, name);

	if (value != NULL) {
		mxmlNewOpaque(b, value);
	}
	return b;
}
/*
 * The order of key array filling should be the same of insertion function
 */
mxml_node_t *bkp_session_node_found(mxml_node_t *tree, char *name, struct search_keywords *keys, int size)
{
	mxml_node_t *b = tree, *c, *d;
	struct search_keywords;
	int i = 0;

	b = mxmlFindElement(b, b, name, NULL, NULL, MXML_DESCEND_FIRST);
	while (b) {
		if (b && b->child) {
			c = b->child;
			i = 0;
			while (c && i < size) {
				if (c->type == MXML_ELEMENT && strcmp(keys[i].name, c->value.element.name) == 0) {
					d = c;
					d = mxmlWalkNext(d, c, MXML_DESCEND);
					if ((keys[i].value == NULL) || (d && d->type == MXML_OPAQUE && keys[i].value != NULL && strcmp(keys[i].value, d->value.opaque) == 0))
						i++;
				}
				c = mxmlWalkNext(c, b, MXML_NO_DESCEND);
			}
		}
		if (i == size) {
			break;
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	return b;
}

mxml_node_t *bkp_session_insert_event(int index, char *command_key, int id, char *status)
{
	struct search_keywords keys[1];
	char parent_name[32];
	char event_id[32];
	char event_idx[32];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(parent_name, "%s_event", status);
	sprintf(event_id, "%d", id);
	sprintf(event_idx, "%d", index);
	keys[0].name = "id";
	keys[0].value = event_id;
	b = bkp_session_node_found(bkp_tree, parent_name, keys, 1);
	if (!b) {
		b = bkp_session_insert(bkp_tree, parent_name, NULL);
		bkp_session_insert(b, "index", event_idx);
		bkp_session_insert(b, "id", event_id);
		bkp_session_insert(b, "command_key", command_key);
	}
	pthread_mutex_unlock(&mutex_backup_session);
	return b;
}

void bkp_session_delete_event(int id, char *status)
{
	struct search_keywords keys[1];
	char parent_name[32];
	char event_id[32];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(parent_name, "%s_event", status);
	sprintf(event_id, "%d", id);
	keys[0].name = "id";
	keys[0].value = event_id;
	b = bkp_session_node_found(bkp_tree, parent_name, keys, 1);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_parameter(mxml_node_t *b, char *name)
{
	pthread_mutex_lock(&mutex_backup_session);
	bkp_session_insert(b, "parameter", name);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_simple_insert(char *parent, char *child, char *value)
{
	mxml_node_t *b = bkp_tree;

	pthread_mutex_lock(&mutex_backup_session);
	b = mxmlFindElement(b, b, parent, NULL, NULL, MXML_DESCEND);
	if (b)
		mxmlDelete(b);
	b = bkp_session_insert(bkp_tree, parent, NULL);
	bkp_session_insert(b, child, value);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_simple_insert_in_parent(char *parent, char *child, char *value)
{
	mxml_node_t *n, *b = bkp_tree;

	pthread_mutex_lock(&mutex_backup_session);
	n = mxmlFindElement(b, b, parent, NULL, NULL, MXML_DESCEND);
	if (!n)
		n = bkp_session_insert(bkp_tree, parent, NULL);
	b = mxmlFindElement(n, n, child, NULL, NULL, MXML_DESCEND);
	if (b)
		mxmlDelete(b);
	bkp_session_insert(n, child, value);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_move_inform_to_inform_send()
{
	mxml_node_t *b = bkp_tree;

	pthread_mutex_lock(&mutex_backup_session);
	while (b) {
		if (b && b->type == MXML_ELEMENT && !strcmp(b->value.element.name, "queue_event") && b->parent->type == MXML_ELEMENT && !strcmp(b->parent->value.element.name, "cwmp")) {
			FREE(b->value.element.name);
			b->value.element.name = strdup("send_event");
		}
		b = mxmlWalkNext(b, bkp_tree, MXML_DESCEND);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_move_inform_to_inform_queue()
{
	mxml_node_t *b = bkp_tree;

	pthread_mutex_lock(&mutex_backup_session);
	while (b) {
		if (b && b->type == MXML_ELEMENT && !strcmp(b->value.element.name, "send_event") && b->parent->type == MXML_ELEMENT && !strcmp(b->parent->value.element.name, "cwmp")) {
			FREE(b->value.element.name);
			b->value.element.name = strdup("queue_event");
		}
		b = mxmlWalkNext(b, bkp_tree, MXML_DESCEND);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_schedule_inform(time_t time, char *command_key)
{
	struct search_keywords keys[2];
	char schedule_time[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", time);
	keys[0].name = "command_key";
	keys[0].value = command_key;
	keys[1].name = "time";
	keys[1].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "schedule_inform", keys, 2);
	if (!b) {
		b = bkp_session_insert(bkp_tree, "schedule_inform", NULL);
		bkp_session_insert(b, "command_key", command_key);
		bkp_session_insert(b, "time", schedule_time);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_delete_schedule_inform(time_t time, char *command_key)
{
	struct search_keywords keys[2];
	char schedule_time[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", time);
	keys[0].name = "command_key";
	keys[0].value = command_key;
	keys[1].name = "time";
	keys[1].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "schedule_inform", keys, 2);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_download(struct download *pdownload)
{
	struct search_keywords keys[7];
	char schedule_time[128];
	char file_size[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", pdownload->scheduled_time);
	sprintf(file_size, "%d", pdownload->file_size);
	keys[0].name = "url";
	keys[0].value = pdownload->url;
	keys[1].name = "command_key";
	keys[1].value = pdownload->command_key;
	keys[2].name = "file_type";
	keys[2].value = pdownload->file_type;
	keys[3].name = "username";
	keys[3].value = pdownload->username;
	keys[4].name = "password";
	keys[4].value = pdownload->password;
	keys[5].name = "file_size";
	keys[5].value = file_size;
	keys[6].name = "time";
	keys[6].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "download", keys, 7);
	if (!b) {
		b = bkp_session_insert(bkp_tree, "download", NULL);
		bkp_session_insert(b, "url", pdownload->url);
		bkp_session_insert(b, "command_key", pdownload->command_key);
		bkp_session_insert(b, "file_type", pdownload->file_type);
		bkp_session_insert(b, "username", pdownload->username);
		bkp_session_insert(b, "password", pdownload->password);
		bkp_session_insert(b, "file_size", file_size);
		bkp_session_insert(b, "time", schedule_time);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_schedule_download(struct schedule_download *pschedule_download)
{
	struct search_keywords keys[16];
	char delay[4][128];
	int i;
	char file_size[128];
	char maxretrie[2][128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(file_size, "%d", pschedule_download->file_size);
	for (i = 0; i < 2; i++) {
		sprintf(delay[2 * i], "%ld", pschedule_download->timewindowstruct[i].windowstart);
		sprintf(delay[2 * i + 1], "%ld", pschedule_download->timewindowstruct[i].windowend);
		sprintf(maxretrie[i], "%d", pschedule_download->timewindowstruct[i].maxretries);
	}
	keys[0].name = "url";
	keys[0].value = pschedule_download->url;
	keys[1].name = "command_key";
	keys[1].value = pschedule_download->command_key;
	keys[2].name = "file_type";
	keys[2].value = pschedule_download->file_type;
	keys[3].name = "username";
	keys[3].value = pschedule_download->username;
	keys[4].name = "password";
	keys[4].value = pschedule_download->password;
	keys[5].name = "file_size";
	keys[5].value = file_size;
	keys[6].name = "windowstart1";
	keys[6].value = delay[0];
	keys[7].name = "windowend1";
	keys[7].value = delay[1];
	keys[8].name = "windowmode1";
	keys[8].value = pschedule_download->timewindowstruct[0].windowmode;
	keys[9].name = "usermessage1";
	keys[9].value = pschedule_download->timewindowstruct[0].usermessage;
	keys[10].name = "maxretrie1";
	keys[10].value = maxretrie[0];
	keys[11].name = "windowstart2";
	keys[11].value = delay[2];
	keys[12].name = "windowend2";
	keys[12].value = delay[3];
	keys[13].name = "windowmode2";
	keys[13].value = pschedule_download->timewindowstruct[1].windowmode;
	keys[14].name = "usermessage2";
	keys[14].value = pschedule_download->timewindowstruct[1].usermessage;
	keys[15].name = "maxretrie2";
	keys[15].value = maxretrie[1];
	b = bkp_session_node_found(bkp_tree, "schedule_download", keys, 16);
	if (!b) {
		b = bkp_session_insert(bkp_tree, "schedule_download", NULL);
		bkp_session_insert(b, "url", pschedule_download->url);
		bkp_session_insert(b, "command_key", pschedule_download->command_key);
		bkp_session_insert(b, "file_type", pschedule_download->file_type);
		bkp_session_insert(b, "username", pschedule_download->username);
		bkp_session_insert(b, "password", pschedule_download->password);
		bkp_session_insert(b, "file_size", file_size);
		bkp_session_insert(b, "windowstart1", delay[0]);
		bkp_session_insert(b, "windowend1", delay[1]);
		bkp_session_insert(b, "windowmode1", pschedule_download->timewindowstruct[0].windowmode);
		bkp_session_insert(b, "usermessage1", pschedule_download->timewindowstruct[0].usermessage);
		bkp_session_insert(b, "maxretrie1", maxretrie[0]);
		bkp_session_insert(b, "windowstart2", delay[2]);
		bkp_session_insert(b, "windowend2", delay[3]);
		bkp_session_insert(b, "windowmode2", pschedule_download->timewindowstruct[1].windowmode);
		bkp_session_insert(b, "usermessage2", pschedule_download->timewindowstruct[1].usermessage);
		bkp_session_insert(b, "maxretrie2", maxretrie[1]);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_apply_schedule_download(struct apply_schedule_download *papply_schedule_download)
{
	struct search_keywords keys[9];
	char delay[4][128];
	int i;
	char maxretrie[2][128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);

	for (i = 0; i < 2; i++) {
		sprintf(delay[2 * i], "%ld", papply_schedule_download->timeintervals[i].windowstart);
		sprintf(delay[2 * i + 1], "%ld", papply_schedule_download->timeintervals[i].windowend);
		sprintf(maxretrie[i], "%d", papply_schedule_download->timeintervals[i].maxretries);
	}
	keys[0].name = "command_key";
	keys[0].value = papply_schedule_download->command_key;
	keys[1].name = "file_type";
	keys[1].value = papply_schedule_download->file_type;
	keys[2].name = "start_time";
	keys[2].value = papply_schedule_download->start_time;
	keys[3].name = "windowstart1";
	keys[3].value = delay[0];
	keys[4].name = "windowend1";
	keys[4].value = delay[1];
	keys[5].name = "maxretrie1";
	keys[5].value = maxretrie[0];
	keys[6].name = "windowstart2";
	keys[6].value = delay[2];
	keys[7].name = "windowend2";
	keys[7].value = delay[3];
	keys[8].name = "maxretrie2";
	keys[8].value = maxretrie[1];
	b = bkp_session_node_found(bkp_tree, "apply_schedule_download", keys, 9);
	if (!b) {
		CWMP_LOG(INFO, "New schedule download key %s file", papply_schedule_download->command_key);
		b = bkp_session_insert(bkp_tree, "apply_schedule_download", NULL);
		bkp_session_insert(b, "start_time", papply_schedule_download->start_time);
		bkp_session_insert(b, "command_key", papply_schedule_download->command_key);
		bkp_session_insert(b, "file_type", papply_schedule_download->file_type);
		bkp_session_insert(b, "windowstart1", delay[0]);
		bkp_session_insert(b, "windowend1", delay[1]);
		bkp_session_insert(b, "maxretrie1", maxretrie[0]);

		bkp_session_insert(b, "windowstart2", delay[2]);
		bkp_session_insert(b, "windowend2", delay[3]);
		bkp_session_insert(b, "maxretrie2", maxretrie[1]);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_delete_apply_schedule_download(struct apply_schedule_download *papply_schedule_download) //TODO
{
	struct search_keywords keys[9];
	char delay[4][128];
	char maxretrie[2][128];
	int i;
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	for (i = 0; i < 2; i++) {
		sprintf(delay[2 * i], "%ld", papply_schedule_download->timeintervals[i].windowstart);
		sprintf(delay[2 * i + 1], "%ld", papply_schedule_download->timeintervals[i].windowend);
		sprintf(maxretrie[i], "%d", papply_schedule_download->timeintervals[i].maxretries);
	}

	keys[0].name = "start_time";
	keys[0].value = papply_schedule_download->start_time;
	keys[1].name = "command_key";
	keys[1].value = papply_schedule_download->command_key;
	keys[2].name = "file_type";
	keys[2].value = papply_schedule_download->file_type;
	keys[3].name = "windowstart1";
	keys[3].value = delay[0];
	keys[4].name = "windowend1";
	keys[4].value = delay[1];
	keys[5].name = "maxretrie1";
	keys[5].value = maxretrie[0];
	keys[6].name = "windowstart2";
	keys[6].value = delay[2];
	keys[7].name = "windowend2";
	keys[7].value = delay[3];
	keys[8].name = "maxretrie2";
	keys[8].value = maxretrie[1];
	b = bkp_session_node_found(bkp_tree, "apply_schedule_download", keys, 9);

	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_change_du_state(struct change_du_state *pchange_du_state)
{
	struct operations *p;
	char schedule_time[128];
	mxml_node_t *b, *n;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", pchange_du_state->timeout);
	b = bkp_session_insert(bkp_tree, "change_du_state", NULL);
	bkp_session_insert(b, "command_key", pchange_du_state->command_key);
	bkp_session_insert(b, "time", schedule_time);

	list_for_each_entry (p, &(pchange_du_state->list_operation), list) {
		if (p->type == DU_INSTALL) {
			n = bkp_session_insert(b, "install", NULL);
			bkp_session_insert(n, "url", p->url);
			bkp_session_insert(n, "uuid", p->uuid);
			bkp_session_insert(n, "username", p->username);
			bkp_session_insert(n, "password", p->password);
			bkp_session_insert(n, "executionenvref", p->executionenvref);
		} else if (p->type == DU_UPDATE) {
			n = bkp_session_insert(b, "update", NULL);
			bkp_session_insert(n, "uuid", p->uuid);
			bkp_session_insert(n, "version", p->version);
			bkp_session_insert(n, "url", p->url);
			bkp_session_insert(n, "username", p->username);
			bkp_session_insert(n, "password", p->password);
		} else if (p->type == DU_UNINSTALL) {
			n = bkp_session_insert(b, "uninstall", NULL);
			bkp_session_insert(n, "uuid", p->uuid);
			bkp_session_insert(n, "version", p->version);
			bkp_session_insert(n, "executionenvref", p->executionenvref);
		}
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_delete_change_du_state(struct change_du_state *pchange_du_state)
{
	struct search_keywords keys[2];
	char schedule_time[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	keys[0].name = "command_key";
	keys[0].value = pchange_du_state->command_key;
	keys[1].name = "time";
	sprintf(schedule_time, "%ld", pchange_du_state->timeout);
	keys[1].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "change_du_state", keys, 2);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_upload(struct upload *pupload)
{
	struct search_keywords keys[6];
	char schedule_time[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", pupload->scheduled_time);
	keys[0].name = "url";
	keys[0].value = pupload->url;
	keys[1].name = "command_key";
	keys[1].value = pupload->command_key;
	keys[2].name = "file_type";
	keys[2].value = pupload->file_type;
	keys[3].name = "username";
	keys[3].value = pupload->username;
	keys[4].name = "password";
	keys[4].value = pupload->password;
	keys[5].name = "time";
	keys[5].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "upload", keys, 6);
	if (!b) {
		b = bkp_session_insert(bkp_tree, "upload", NULL);
		bkp_session_insert(b, "url", pupload->url);
		bkp_session_insert(b, "command_key", pupload->command_key);
		bkp_session_insert(b, "file_type", pupload->file_type);
		bkp_session_insert(b, "username", pupload->username);
		bkp_session_insert(b, "password", pupload->password);
		bkp_session_insert(b, "time", schedule_time);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}
void bkp_session_delete_download(struct download *pdownload)
{
	struct search_keywords keys[7];
	char schedule_time[128];
	char file_size[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", pdownload->scheduled_time);
	sprintf(file_size, "%d", pdownload->file_size);
	keys[0].name = "url";
	keys[0].value = pdownload->url;
	keys[1].name = "command_key";
	keys[1].value = pdownload->command_key;
	keys[2].name = "file_type";
	keys[2].value = pdownload->file_type;
	keys[3].name = "username";
	keys[3].value = pdownload->username;
	keys[4].name = "password";
	keys[4].value = pdownload->password;
	keys[5].name = "file_size";
	keys[5].value = file_size;
	keys[6].name = "time";
	keys[6].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "download", keys, 7);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_delete_schedule_download(struct schedule_download *pschedule_download) //TODO
{
	struct search_keywords keys[16];
	char delay[4][128];
	char file_size[128];
	char maxretrie[2][128];
	int i;
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(file_size, "%d", pschedule_download->file_size);
	for (i = 0; i < 2; i++) {
		sprintf(delay[2 * i], "%ld", pschedule_download->timewindowstruct[i].windowstart);
		sprintf(delay[2 * i + 1], "%ld", pschedule_download->timewindowstruct[i].windowend);
		sprintf(maxretrie[i], "%d", pschedule_download->timewindowstruct[i].maxretries);
	}
	keys[0].name = "url";
	keys[0].value = pschedule_download->url;
	keys[1].name = "command_key";
	keys[1].value = pschedule_download->command_key;
	keys[2].name = "file_type";
	keys[2].value = pschedule_download->file_type;
	keys[3].name = "username";
	keys[3].value = pschedule_download->username;
	keys[4].name = "password";
	keys[4].value = pschedule_download->password;
	keys[5].name = "file_size";
	keys[5].value = file_size;
	keys[6].name = "windowstart1";
	keys[6].value = delay[0];
	keys[7].name = "windowend1";
	keys[7].value = delay[1];
	keys[8].name = "windowmode1";
	keys[8].value = pschedule_download->timewindowstruct[0].windowmode;
	keys[9].name = "usermessage1";
	keys[9].value = pschedule_download->timewindowstruct[0].usermessage;
	keys[10].name = "maxretrie1";
	keys[10].value = maxretrie[0];
	keys[11].name = "windowstart2";
	keys[11].value = delay[2];
	keys[12].name = "windowend2";
	keys[12].value = delay[3];
	keys[13].name = "windowmode2";
	keys[13].value = pschedule_download->timewindowstruct[1].windowmode;
	keys[14].name = "usermessage2";
	keys[14].value = pschedule_download->timewindowstruct[1].usermessage;
	keys[15].name = "maxretrie2";
	keys[15].value = maxretrie[1];
	b = bkp_session_node_found(bkp_tree, "schedule_download", keys, 16);

	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}
void bkp_session_delete_upload(struct upload *pupload)
{
	struct search_keywords keys[6];
	char schedule_time[128];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", pupload->scheduled_time);
	keys[0].name = "url";
	keys[0].value = pupload->url;
	keys[1].name = "command_key";
	keys[1].value = pupload->command_key;
	keys[2].name = "file_type";
	keys[2].value = pupload->file_type;
	keys[3].name = "username";
	keys[3].value = pupload->username;
	keys[4].name = "password";
	keys[4].value = pupload->password;
	keys[5].name = "time";
	keys[5].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "upload", keys, 6);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_insert_du_state_change_complete(struct du_state_change_complete *pdu_state_change_complete)
{
	char schedule_time[128], resolved[8], fault_code[8];
	struct opresult *p;
	mxml_node_t *b, *n;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(schedule_time, "%ld", pdu_state_change_complete->timeout);
	b = bkp_session_insert(bkp_tree, "du_state_change_complete", NULL);
	bkp_session_insert(b, "command_key", pdu_state_change_complete->command_key);
	bkp_session_insert(b, "time", schedule_time);
	list_for_each_entry (p, &(pdu_state_change_complete->list_opresult), list) {
		n = bkp_session_insert(b, "opresult", NULL);
		sprintf(resolved, "%d", p->resolved);
		sprintf(fault_code, "%d", p->fault);
		bkp_session_insert(n, "uuid", p->uuid);
		bkp_session_insert(n, "du_ref", p->du_ref);
		bkp_session_insert(n, "version", p->version);
		bkp_session_insert(n, "current_state", p->current_state);
		bkp_session_insert(n, "resolved", resolved);
		bkp_session_insert(n, "execution_unit_ref", p->execution_unit_ref);
		bkp_session_insert(n, "start_time", p->start_time);
		bkp_session_insert(n, "complete_time", p->complete_time);
		bkp_session_insert(n, "fault", fault_code);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_delete_du_state_change_complete(struct du_state_change_complete *pdu_state_change_complete)
{
	struct search_keywords keys[2];
	mxml_node_t *b;
	char schedule_time[128];

	pthread_mutex_lock(&mutex_backup_session);
	keys[0].name = "command_key";
	keys[0].value = pdu_state_change_complete->command_key;
	sprintf(schedule_time, "%ld", pdu_state_change_complete->timeout);
	keys[1].name = "time";
	keys[1].value = schedule_time;
	b = bkp_session_node_found(bkp_tree, "du_state_change_complete", keys, 2);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}
void bkp_session_insert_transfer_complete(struct transfer_complete *ptransfer_complete)
{
	struct search_keywords keys[5];
	char fault_code[16];
	char type[16];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(fault_code, "%d", ptransfer_complete->fault_code);
	keys[0].name = "command_key";
	keys[0].value = ptransfer_complete->command_key;
	keys[1].name = "start_time";
	keys[1].value = ptransfer_complete->start_time;
	keys[2].name = "complete_time";
	keys[2].value = ptransfer_complete->complete_time;
	keys[3].name = "fault_code";
	keys[3].value = fault_code;
	keys[4].name = "type";
	sprintf(type, "%d", ptransfer_complete->type);
	keys[4].value = type;
	b = bkp_session_node_found(bkp_tree, "transfer_complete", keys, 5);
	if (!b) {
		b = bkp_session_insert(bkp_tree, "transfer_complete", NULL);
		bkp_session_insert(b, "command_key", ptransfer_complete->command_key);
		bkp_session_insert(b, "start_time", ptransfer_complete->start_time);
		bkp_session_insert(b, "complete_time", ptransfer_complete->complete_time);
		bkp_session_insert(b, "old_software_version", ptransfer_complete->old_software_version);
		bkp_session_insert(b, "fault_code", fault_code);
		bkp_session_insert(b, "type", type);
	}
	pthread_mutex_unlock(&mutex_backup_session);
}

void bkp_session_delete_transfer_complete(struct transfer_complete *ptransfer_complete)
{
	struct search_keywords keys[5];
	char fault_code[16];
	char type[16];
	mxml_node_t *b;

	pthread_mutex_lock(&mutex_backup_session);
	sprintf(fault_code, "%d", ptransfer_complete->fault_code);
	sprintf(type, "%d", ptransfer_complete->type);
	keys[0].name = "command_key";
	keys[0].value = ptransfer_complete->command_key;
	keys[1].name = "start_time";
	keys[1].value = ptransfer_complete->start_time;
	keys[2].name = "complete_time";
	keys[2].value = ptransfer_complete->complete_time;
	keys[3].name = "fault_code";
	keys[3].value = fault_code;
	keys[4].name = "type";
	keys[4].value = type;
	b = bkp_session_node_found(bkp_tree, "transfer_complete", keys, 5);
	if (b)
		mxmlDelete(b);
	pthread_mutex_unlock(&mutex_backup_session);
}

int save_acs_bkp_config(struct cwmp *cwmp)
{
	struct config *conf;

	conf = &(cwmp->conf);
	bkp_session_simple_insert("acs", "url", conf->acsurl);
	bkp_session_save();
	return CWMP_OK;
}

/*
 * Load backup session
 */
char *load_child_value(mxml_node_t *tree, char *sub_name)
{
	char *value = NULL;
	mxml_node_t *b = tree;

	if (b) {
		b = mxmlFindElement(b, b, sub_name, NULL, NULL, MXML_DESCEND);
		if (b) {
			b = mxmlWalkNext(b, tree, MXML_DESCEND);
			if (b && b->type == MXML_OPAQUE) {
				if (b->value.opaque != NULL) {
					value = strdup(b->value.opaque);
				}
			}
		}
	}
	return value;
}

void load_queue_event(mxml_node_t *tree, struct cwmp *cwmp)
{
	char *command_key = NULL;
	mxml_node_t *b = tree, *c;
	int idx = -1, id = -1;
	struct event_container *event_container_save = NULL;

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "index") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						idx = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "id") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						id = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						command_key = strdup(c->value.opaque);
					}
				}
				if (idx != -1) {
					if (EVENT_CONST[idx].RETRY & EVENT_RETRY_AFTER_REBOOT) {
						event_container_save = cwmp_add_event_container(cwmp, idx, ((command_key != NULL) ? command_key : ""));
						if (event_container_save != NULL) {
							event_container_save->id = id;
						}
					}
				}
				FREE(command_key);
			} else if (strcmp(b->value.element.name, "parameter") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						if (event_container_save != NULL) {
							add_dm_parameter_tolist(&(event_container_save->head_dm_parameter), c->value.opaque, NULL, NULL);
						}
					}
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
}

void load_schedule_inform(mxml_node_t *tree)
{
	char *command_key = NULL;
	mxml_node_t *b = tree, *c;
	time_t scheduled_time = 0;
	struct schedule_inform *schedule_inform = NULL;
	struct list_head *ilist = NULL;

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						scheduled_time = atol(c->value.opaque);
					}
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	list_for_each (ilist, &(list_schedule_inform)) {
		schedule_inform = list_entry(ilist, struct schedule_inform, list);
		if (schedule_inform->scheduled_time > scheduled_time) {
			break;
		}
	}
	schedule_inform = calloc(1, sizeof(struct schedule_inform));
	if (schedule_inform != NULL) {
		schedule_inform->commandKey = command_key;
		schedule_inform->scheduled_time = scheduled_time;
		list_add(&(schedule_inform->list), ilist->prev);
	}
}

void load_download(mxml_node_t *tree)
{
	mxml_node_t *b = tree, *c;
	struct download *download_request = NULL;
	struct list_head *ilist = NULL;
	struct download *idownload_request = NULL;

	download_request = calloc(1, sizeof(struct download));

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "url") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->url = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "file_type") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->file_type = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "username") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->username = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "password") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->password = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "file_size") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->file_size = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->scheduled_time = atol(c->value.opaque);
					}
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	list_for_each (ilist, &(list_download)) {
		idownload_request = list_entry(ilist, struct download, list);
		if (idownload_request->scheduled_time > download_request->scheduled_time) {
			break;
		}
	}
	list_add(&(download_request->list), ilist->prev);
	if (download_request->scheduled_time != 0)
		count_download_queue++;
}

void load_schedule_download(mxml_node_t *tree)
{
	mxml_node_t *b = tree, *c;
	struct schedule_download *download_request = NULL;
	struct list_head *ilist = NULL;
	struct schedule_download *idownload_request = NULL;

	download_request = calloc(1, sizeof(struct schedule_download));

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "url") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->url = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "file_type") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->file_type = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "username") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->username = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "password") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->password = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "file_size") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->file_size = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowstart1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[0].windowstart = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowend1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[0].windowend = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowmode1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[0].windowmode = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "usermessage1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[0].usermessage = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "maxretrie1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[0].maxretries = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowstart2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[1].windowstart = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowend2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[1].windowend = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowmode2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[1].windowmode = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "usermessage2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[1].usermessage = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "maxretrie2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timewindowstruct[1].maxretries = atoi(c->value.opaque);
					}
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	list_for_each (ilist, &(list_schedule_download)) {
		idownload_request = list_entry(ilist, struct schedule_download, list);
		if (idownload_request->timewindowstruct[0].windowstart > download_request->timewindowstruct[0].windowstart) {
			break;
		}
	}
	list_add(&(download_request->list), ilist->prev);
	if (download_request->timewindowstruct[0].windowstart != 0)
		count_download_queue++;
}

void load_apply_schedule_download(mxml_node_t *tree)
{
	mxml_node_t *b = tree, *c;
	struct apply_schedule_download *download_request = NULL;

	download_request = calloc(1, sizeof(struct apply_schedule_download));

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "file_type") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->file_type = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "start_time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->start_time = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowstart1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timeintervals[0].windowstart = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowend1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timeintervals[0].windowend = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "maxretrie1") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timeintervals[0].maxretries = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowstart2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timeintervals[1].windowstart = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "windowend2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timeintervals[1].windowend = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "maxretrie2") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						download_request->timeintervals[1].maxretries = atoi(c->value.opaque);
					}
				}
			}
			/*
			windowstart1",delay[0]);
			bkp_session_insert(b,"windowend1",delay[1]);
			bkp_session_insert(b,"windowmode1",pschedule_download->timewindowstruct[0].windowmode);
			bkp_session_insert(b,"usermessage1",pschedule_download->timewindowstruct[0].usermessage);
			bkp_session_insert(b,"maxretrie1*/
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	list_add_tail(&(download_request->list), &(list_apply_schedule_download));
	if (download_request->timeintervals[0].windowstart != 0)
		count_download_queue++;
}

void load_upload(mxml_node_t *tree)
{
	mxml_node_t *b = tree, *c;
	struct upload *upload_request = NULL;
	struct list_head *ilist = NULL;
	struct upload *iupload_request = NULL;

	upload_request = calloc(1, sizeof(struct upload));

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "url") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						upload_request->url = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						upload_request->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "file_type") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						upload_request->file_type = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "username") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						upload_request->username = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "password") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						upload_request->password = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						upload_request->scheduled_time = atol(c->value.opaque);
					}
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	list_for_each (ilist, &(list_upload)) {
		iupload_request = list_entry(ilist, struct upload, list);
		if (iupload_request->scheduled_time > upload_request->scheduled_time) {
			break;
		}
	}
	list_add(&(upload_request->list), ilist->prev);
	if (upload_request->scheduled_time != 0)
		count_download_queue++;
}

void load_change_du_state(mxml_node_t *tree)
{
	mxml_node_t *b = tree, *c, *d;
	struct change_du_state *change_du_state_request = NULL;
	struct operations *elem;

	change_du_state_request = calloc(1, sizeof(struct change_du_state));
	INIT_LIST_HEAD(&(change_du_state_request->list_operation));
	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						change_du_state_request->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						change_du_state_request->timeout = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "update") == 0) {
				elem = (operations *)calloc(1, sizeof(operations));
				elem->type = DU_UPDATE;
				list_add_tail(&(elem->list), &(change_du_state_request->list_operation));
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				while (c) {
					//
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "uuid") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->uuid = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "version") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->version = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "url") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->url = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "username") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->username = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "password") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->password = strdup(d->value.opaque);
								}
							}
						}
					}
					c = mxmlWalkNext(c, b, MXML_NO_DESCEND);
				}
			} else if (strcmp(b->value.element.name, "install") == 0) {
				elem = (operations *)calloc(1, sizeof(operations));
				elem->type = DU_INSTALL;
				list_add_tail(&(elem->list), &(change_du_state_request->list_operation));
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				while (c) {
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "uuid") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->uuid = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "executionenvref") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->executionenvref = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "url") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->url = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "username") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->username = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "password") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->password = strdup(d->value.opaque);
								}
							}
						}
					}
					c = mxmlWalkNext(c, b, MXML_NO_DESCEND);
				}
			} else if (strcmp(b->value.element.name, "uninstall") == 0) {
				elem = (operations *)calloc(1, sizeof(operations));
				elem->type = DU_UNINSTALL;
				list_add_tail(&(elem->list), &(change_du_state_request->list_operation));
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				while (c) {
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "uuid") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->uuid = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "executionenvref") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->executionenvref = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "version") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->version = strdup(d->value.opaque);
								}
							}
						}
					}
					c = mxmlWalkNext(c, b, MXML_NO_DESCEND);
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	list_add_tail(&(change_du_state_request->list_operation), &(list_change_du_state));
}

void load_du_state_change_complete(mxml_node_t *tree, struct cwmp *cwmp)
{
	mxml_node_t *b = tree, *c, *d;
	struct du_state_change_complete *du_state_change_complete_request = NULL;
	struct opresult *elem;

	du_state_change_complete_request = calloc(1, sizeof(struct du_state_change_complete));
	INIT_LIST_HEAD(&(du_state_change_complete_request->list_opresult));
	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						du_state_change_complete_request->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						du_state_change_complete_request->timeout = atol(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "opresult") == 0) {
				elem = (opresult *)calloc(1, sizeof(opresult));
				list_add_tail(&(elem->list), &(du_state_change_complete_request->list_opresult));
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				while (c) {
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "uuid") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->uuid = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "version") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->version = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "du_ref") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->du_ref = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "current_state") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->current_state = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "resolved") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->resolved = d->value.opaque;
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "start_time") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->start_time = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "complete_time") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->complete_time = strdup(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "fault") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->fault = atoi(d->value.opaque);
								}
							}
						}
					}
					if (c && c->type == MXML_ELEMENT) {
						if (strcmp(c->value.element.name, "execution_unit_ref") == 0) {
							d = mxmlWalkNext(c, c, MXML_DESCEND);
							if (d && d->type == MXML_OPAQUE) {
								if (d->value.opaque != NULL) {
									elem->execution_unit_ref = strdup(d->value.opaque);
								}
							}
						}
					}
					c = mxmlWalkNext(c, b, MXML_NO_DESCEND);
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	cwmp_root_cause_changedustate_complete(cwmp, du_state_change_complete_request);
}

void load_transfer_complete(mxml_node_t *tree, struct cwmp *cwmp)
{
	mxml_node_t *b = tree, *c;
	struct transfer_complete *ptransfer_complete;

	b = mxmlWalkNext(b, tree, MXML_DESCEND);

	ptransfer_complete = calloc(1, sizeof(struct transfer_complete));

	while (b) {
		if (b && b->type == MXML_ELEMENT) {
			if (strcmp(b->value.element.name, "command_key") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						ptransfer_complete->command_key = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "start_time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						ptransfer_complete->start_time = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "complete_time") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						ptransfer_complete->complete_time = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "old_software_version") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						ptransfer_complete->old_software_version = strdup(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "fault_code") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						ptransfer_complete->fault_code = atoi(c->value.opaque);
					}
				}
			} else if (strcmp(b->value.element.name, "type") == 0) {
				c = mxmlWalkNext(b, b, MXML_DESCEND);
				if (c && c->type == MXML_OPAQUE) {
					if (c->value.opaque != NULL) {
						ptransfer_complete->type = atoi(c->value.opaque);
					}
				}
			}
		}
		b = mxmlWalkNext(b, tree, MXML_NO_DESCEND);
	}
	cwmp_root_cause_transfer_complete(cwmp, ptransfer_complete);
	sotfware_version_value_change(cwmp, ptransfer_complete);
}

void bkp_session_create_file()
{
	FILE *pFile;

	pthread_mutex_lock(&mutex_backup_session);
	pFile = fopen(CWMP_BKP_FILE, "w");
	if (pFile == NULL) {
		CWMP_LOG(ERROR, "Unable to create %s file", CWMP_BKP_FILE);
		pthread_mutex_unlock(&mutex_backup_session);
		return;
	}
	fprintf(pFile, "%s", CWMP_BACKUP_SESSION);
	if (bkp_tree != NULL)
		MXML_DELETE(bkp_tree);
	bkp_tree = mxmlLoadString(NULL, CWMP_BACKUP_SESSION, MXML_OPAQUE_CALLBACK);
	fclose(pFile);
	pthread_mutex_unlock(&mutex_backup_session);
}

int bkp_session_check_file()
{
	FILE *pFile;

	if (access(CWMP_BKP_FILE, F_OK) == -1) {
		bkp_session_create_file();
		return -1;
	}

	if (bkp_tree == NULL) {
		pFile = fopen(CWMP_BKP_FILE, "r");
		bkp_tree = mxmlLoadFile(NULL, pFile, MXML_OPAQUE_CALLBACK);
		fclose(pFile);
	}

	if (bkp_tree == NULL) {
		bkp_session_create_file();
		return -1;
	}
	bkp_session_move_inform_to_inform_queue();
	bkp_session_save();
	return 0;
}

int cwmp_init_backup_session(struct cwmp *cwmp, char **ret, enum backup_loading load)
{
	int error;

	if (bkp_session_check_file())
		return 0;

	error = cwmp_load_saved_session(cwmp, ret, load);
	return error;
}

int cwmp_load_saved_session(struct cwmp *cwmp, char **ret, enum backup_loading load)
{
	mxml_node_t *b;

	b = bkp_tree;
	b = mxmlWalkNext(b, bkp_tree, MXML_DESCEND);
	while (b) {
		if (load == ACS) {
			if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "acs") == 0) {
				*ret = load_child_value(b, "url");
				break;
			}
		}
		if (load == CR_IP) {
			if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "connection_request") == 0) {
				*ret = load_child_value(b, "ip");
				break;
			}
		}
		if (load == CR_IPv6) {
			if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "connection_request") == 0) {
				*ret = load_child_value(b, "ipv6");
				break;
			}
		}
		if (load == CR_PORT) {
			if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "connection_request") == 0) {
				*ret = load_child_value(b, "port");
				break;
			}
		}
		if (load == ALL) {
			if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "queue_event") == 0) {
				load_queue_event(b, cwmp);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "download") == 0) {
				load_download(b);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "upload") == 0) {
				load_upload(b);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "transfer_complete") == 0) {
				load_transfer_complete(b, cwmp);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "schedule_inform") == 0) {
				load_schedule_inform(b);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "change_du_state") == 0) {
				load_change_du_state(b);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "du_state_change_complete") == 0) {
				load_du_state_change_complete(b, cwmp);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "schedule_download") == 0) {
				load_schedule_download(b);
			} else if (b->type == MXML_ELEMENT && strcmp(b->value.element.name, "apply_schedule_download") == 0) {
				load_apply_schedule_download(b);
			}
		}
		b = mxmlWalkNext(b, bkp_tree, MXML_NO_DESCEND);
	}

	return CWMP_OK;
}