| /************************************************************************ | |
| * * | |
| * Netcwmp/Opencwmp Project * | |
| * A software client for enabling TR-069 in embedded devices (CPE). * | |
| * * | |
| * Copyright (C) 2013-2014 netcwmp.netcwmp group * | |
| * * | |
| * 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. * | |
| * * | |
| * This program is distributed in the hope that it will be useful, * | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of * | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * | |
| * GNU General Public License for more details. * | |
| * * | |
| * You should have received a copy of the GNU Lesser General Public * | |
| * License along with this library; if not, write to the * | |
| * Free Software Foundation, Inc., 59 Temple Place, Suite 330, * | |
| * Boston, MA 02111-1307 USA * | |
| * * | |
| * Copyright 2013-2014 Mr.x(Mr.x) <netcwmp@gmail.com> * | |
| * * | |
| ***********************************************************************/ | |
| #include "cwmp/periodic.h" | |
| #include "cwmp_module.h" | |
| #include "cwmp_agent.h" | |
| #include <cwmp/session.h> | |
| //#include "modules/data_model.h" | |
| #include "soft_timer.h" | |
| #define CWMP_TRUE 1 | |
| #define MAX_SESSION_RETRY 3 | |
| enum | |
| { | |
| CWMP_ST_START = 0, | |
| CWMP_ST_INFORM, | |
| CWMP_ST_SEND, | |
| CWMP_ST_RESEMD, | |
| CWMP_ST_RECV, | |
| CWMP_ST_ANSLYSE, | |
| CWMP_ST_RETRY, | |
| CWMP_ST_END, | |
| CWMP_ST_EXIT | |
| }; | |
| #define SECHEDULE_INFORM_TIMER (31) | |
| schedule_inform_info_st g_si; | |
| int get_session_status() | |
| { | |
| return g_si.cwmp->session_running; | |
| } | |
| void *schedule_inform_timeout(void *arg) | |
| { | |
| FUNCTION_TRACE(); | |
| int i = 0; | |
| schedule_inform_info_st *psi = (schedule_inform_info_st *)arg; | |
| cwmp_log_info("push begin"); | |
| psi->timer_running = 2; | |
| // while(1) | |
| // { | |
| // if(SESSION_NO_RUNNING == get_session_status()) | |
| // { | |
| psi->cwmp->new_request = CWMP_YES; | |
| cwmp_event_set_value(psi->cwmp, INFORM_SCHEDULED, 1, psi->commandKey, 0, 0, 0); | |
| cwmp_log_info("commandkey is:%s", psi->commandKey); | |
| psi->timer_running = 0; | |
| cwmp_log_info("push ok"); | |
| return NULL; | |
| // } | |
| // else | |
| // { | |
| // cwmp_log_info("there is session running"); | |
| // psi->timer_running = 0; | |
| // g_si.delaytime += 1; | |
| // if(CWMP_OK != schedule_inform_create_timer(&g_si)) | |
| // { | |
| // ; | |
| // } | |
| // } | |
| // } | |
| return NULL; | |
| } | |
| int schedule_inform_create_timer(schedule_inform_info_st* psi) | |
| { | |
| FUNCTION_TRACE(); | |
| if(2 == g_si.timer_running){ | |
| cwmp_log_info("there is other schedule inform running!"); | |
| return CWMP_OK; | |
| } | |
| else if(1 == g_si.timer_running) | |
| { | |
| // if exist one schedule inform timer, update | |
| cwmp_log_info("there is other schedule inform active!"); | |
| sc_timer_delete(SECHEDULE_INFORM_TIMER); | |
| } | |
| else | |
| { | |
| cwmp_log_info("update schedule inform info, create timer"); | |
| } | |
| TRstrncpy(g_si.commandKey, psi->commandKey, COMMAND_KEY_LEN); | |
| g_si.delaytime = psi->delaytime; | |
| g_si.cwmp = psi->cwmp; | |
| cwmp_log_info("begin to create timer!"); | |
| long result = sc_timer_create(SECHEDULE_INFORM_TIMER, TIMER_FLAG_ONCE, psi->delaytime*1000, schedule_inform_timeout, &g_si); | |
| g_si.timer_running = 1; | |
| cwmp_log_info("end to create timer!"); | |
| cwmp_log_info("commandkey is:%s, delaytime:%d", psi->commandKey, psi->delaytime); | |
| return CWMP_OK; | |
| } | |
| int cwmp_agent_retry_session(cwmp_session_t * session) | |
| { | |
| int sec = 0; | |
| int count = 1; | |
| srand(time(NULL)); | |
| switch (session->retry_count) | |
| { | |
| case 0: | |
| { | |
| count = 5; //5~10 | |
| break; | |
| } | |
| case 1: | |
| { | |
| count = 10; //5~15 | |
| break; | |
| } | |
| case 2: | |
| { | |
| count = 20; //5~25 | |
| break; | |
| } | |
| default: | |
| { | |
| count = 30; //5~35 | |
| break; | |
| } | |
| } | |
| sec = 5 + rand()% count; | |
| while (sec>0) | |
| { | |
| sleep(1); | |
| sec--; | |
| } | |
| if (session->retry_count > MAX_SESSION_RETRY) | |
| { | |
| session->retry_count = 0; | |
| return CWMP_TIMEOUT; | |
| } | |
| else | |
| { | |
| session->retry_count ++; | |
| return CWMP_OK; | |
| } | |
| } | |
| int cwmp_agent_create_datetimes(datatime_t *nowtime) | |
| { | |
| struct tm *t; | |
| time_t tn; | |
| //FUNCTION_TRACE(); | |
| tn = time(NULL); | |
| #ifdef WIN32 | |
| cwmp_log_debug("inform datatime"); | |
| //localtime_s(&t, &tn); | |
| t = MALLOC(sizeof(struct tm)); | |
| memset(t, 0, sizeof(struct tm)); | |
| #else | |
| t = localtime(&tn); | |
| #endif | |
| if(NULL != t) | |
| { | |
| nowtime->year = t->tm_year + 1900; | |
| nowtime->month = t->tm_mon + 1; | |
| nowtime->day = t->tm_mday; | |
| nowtime->hour = t->tm_hour; | |
| nowtime->min = t->tm_min; | |
| nowtime->sec = t->tm_sec; | |
| } | |
| else | |
| { | |
| cwmp_log_error("localtime return null"); | |
| } | |
| return CWMP_OK; | |
| } | |
| //È¡µÃactive eventÒÔ¼°count | |
| int cwmp_agent_get_active_event(cwmp_t *cwmp, cwmp_session_t * session, event_list_t **pevent_list) | |
| { | |
| event_list_t * el; | |
| event_code_t * ev; | |
| int i=0; | |
| FUNCTION_TRACE(); | |
| el = cwmp_create_event_list(session->env, INFORM_MAX); | |
| if(NULL == el) | |
| { | |
| cwmp_log_error("el cwmp_create_event_list return NULL"); | |
| return CWMP_ERROR; | |
| } | |
| event_code_t ** pec = cwmp->el->events; | |
| int elsize = cwmp->el->count; | |
| for(i=0; i<elsize; i++) | |
| { | |
| if(pec[i] && pec[i]->ref > 0) | |
| { | |
| event_code_t * ec = pec[i]; | |
| ev = cwmp_create_event_code(session->env); | |
| if(NULL == ev) | |
| { | |
| cwmp_log_error("ev cwmp_create_event_code return null"); | |
| return CWMP_ERROR; | |
| } | |
| ev->event = ec->event; | |
| ev->code = ec->code; | |
| if (pec[i]->event == INFORM_MREBOOT || pec[i]->event == INFORM_BOOTSTRAP) | |
| { | |
| strncpy(ev->command_key , ec->command_key, COMMAND_KEY_LEN); | |
| } | |
| el->events[el->count++] = ev; | |
| ev = NULL; | |
| } | |
| } | |
| if (el->count == 0) | |
| { | |
| ev = cwmp_create_event_code(session->env); | |
| if(NULL == ev) | |
| { | |
| cwmp_log_error("ev cwmp_create_event_code return null"); | |
| return CWMP_ERROR; | |
| } | |
| ev->event = INFORM_BOOT; | |
| ev->code = CWMP_INFORM_EVENT_CODE_1; | |
| el->events[el->count++] = ev; | |
| } | |
| *pevent_list = el; | |
| return CWMP_OK; | |
| } | |
| int cwmp_agent_send_request(cwmp_session_t * session) | |
| { | |
| FUNCTION_TRACE(); | |
| return cwmp_session_send_request(session); | |
| } | |
| int cwmp_agent_recv_response(cwmp_session_t * session) | |
| { | |
| return cwmp_session_recv_response(session); | |
| } | |
| void cwmp_agent_start_session(cwmp_t * cwmp) | |
| { | |
| int rv; | |
| cwmp_session_t * session; | |
| int session_close = CWMP_NO; | |
| xmldoc_t * newdoc; | |
| FUNCTION_TRACE(); | |
| event_list_t *evtlist; | |
| while (TRUE) | |
| { | |
| if (cwmp->new_request == CWMP_NO) | |
| { | |
| cwmp_log_debug("No new request from ACS\n"); | |
| sleep(2); | |
| //cwmp->new_request = CWMP_YES; | |
| continue; | |
| } | |
| cwmp_log_debug("New request from ACS\n"); | |
| cwmp_clean_periodic_inform(cwmp); | |
| cwmp->new_request = CWMP_NO; | |
| session = cwmp_session_create(cwmp); | |
| if(NULL == session) | |
| { | |
| cwmp_log_error("session cwmp_session_create return NULL"); | |
| cwmp->new_request = CWMP_YES; | |
| continue; | |
| } | |
| session_close = CWMP_NO; | |
| session->timeout = cwmp_conf_get_int("cwmpd:http_timeout"); | |
| //cwmp_session_set_timeout(cwmp_conf_get_int("cwmpd:http_timeout")); | |
| cwmp_log_debug("session timeout is %d", session->timeout); | |
| cwmp_session_open(session); | |
| while (!session_close) | |
| { | |
| //cwmp_log_debug("session status: %d", session->status); | |
| switch (session->status) | |
| { | |
| case CWMP_ST_START: | |
| //create a new connection to acs | |
| cwmp_log_debug("session stutus: New START\n"); | |
| if (cwmp_session_connect(session, cwmp->acs_url) != CWMP_OK) | |
| { | |
| cwmp_log_error("connect to acs: %s failed.\n", cwmp->acs_url); | |
| session->status = CWMP_ST_RETRY; | |
| } | |
| else | |
| { | |
| session->status = CWMP_ST_INFORM; | |
| } | |
| break; | |
| case CWMP_ST_INFORM: | |
| evtlist = NULL; | |
| cwmp_log_debug("session stutus: INFORM\n"); | |
| cwmp_agent_get_active_event(cwmp, session, & evtlist); | |
| if(evtlist != NULL) | |
| { | |
| cwmp_event_clear_active(cwmp); | |
| } | |
| else | |
| { | |
| cwmp_log_debug("evtlist is null"); | |
| session->status = CWMP_ST_EXIT; | |
| break; | |
| } | |
| cwmp_log_debug("session stutus: INFORM2\n"); | |
| if (cwmp->acs_auth) | |
| { | |
| cwmp_session_set_auth(session, cwmp->acs_user, cwmp->acs_pwd ); | |
| } | |
| cwmp_log_debug("session stutus: INFORM3\n"); | |
| newdoc = cwmp_session_create_inform_message(session, evtlist, session->envpool); | |
| if(NULL != newdoc) | |
| { | |
| cwmp_write_doc_to_chunk(newdoc, session->writers, session->envpool); | |
| session->last_method = CWMP_INFORM_METHOD; | |
| session->status = CWMP_ST_SEND; | |
| } | |
| else | |
| { | |
| cwmp_log_error("newdoc is null"); | |
| session->last_method = CWMP_INFORM_METHOD; | |
| session->status = CWMP_ST_EXIT; | |
| } | |
| break; | |
| case CWMP_ST_SEND: | |
| cwmp_log_debug("session stutus: SEND"); | |
| cwmp_log_debug("session data request length: %d", cwmp_chunk_length(session->writers)); | |
| session->newdata = CWMP_NO; | |
| rv = cwmp_agent_send_request(session); | |
| if (rv == CWMP_OK) | |
| { | |
| cwmp_log_debug("session data sended OK, rv=%d", rv); | |
| session->status = CWMP_ST_RECV; | |
| } | |
| else | |
| { | |
| cwmp_log_debug("session data sended faild! rv=%d", rv); | |
| session->status = CWMP_ST_EXIT; | |
| /* | |
| if (rv == CWMP_COULDNOT_CONNECT) | |
| { | |
| session->status = CWMP_ST_RETRY; | |
| } | |
| else | |
| { | |
| session->status = CWMP_ST_EXIT; | |
| } | |
| */ | |
| } | |
| break; | |
| case CWMP_ST_RECV: | |
| cwmp_log_debug("session stutus: RECV"); | |
| cwmp_chunk_clear(session->readers); | |
| rv = cwmp_agent_recv_response(session); | |
| if (rv == CWMP_OK) | |
| { | |
| session->status = CWMP_ST_ANSLYSE; | |
| } | |
| else | |
| { | |
| session->status = CWMP_ST_END; | |
| } | |
| break; | |
| case CWMP_ST_ANSLYSE: | |
| cwmp_log_debug("session stutus: ANSLYSE"); | |
| rv = cwmp_agent_analyse_session(session); | |
| if (rv == CWMP_OK) | |
| { | |
| session->status = CWMP_ST_SEND; | |
| } | |
| else | |
| { | |
| session->status = CWMP_ST_END; | |
| } | |
| break; | |
| case CWMP_ST_RETRY: | |
| cwmp_log_debug("session stutus: RETRY"); | |
| if (cwmp_agent_retry_session(session) == CWMP_TIMEOUT) | |
| { | |
| cwmp_log_debug("session retry timeover, go out"); | |
| session->status = CWMP_ST_EXIT; | |
| } | |
| else | |
| { | |
| session->status = CWMP_ST_START; | |
| } | |
| break; | |
| case CWMP_ST_END: | |
| //close connection of ACS | |
| cwmp_log_debug("session stutus: END"); | |
| //run task from queue | |
| if (session->newdata == CWMP_YES) | |
| { | |
| session->status = CWMP_ST_SEND; | |
| } | |
| else | |
| { | |
| session->status = CWMP_ST_EXIT; | |
| } | |
| break; | |
| case CWMP_ST_EXIT: | |
| cwmp_log_debug("session stutus: EXIT"); | |
| cwmp_session_close(session); | |
| if (session->reconnect == CWMP_YES) | |
| { | |
| session->reconnect = CWMP_NO; | |
| session->status = CWMP_ST_START; | |
| break; | |
| } | |
| session_close = CWMP_YES; | |
| break; | |
| default: | |
| cwmp_log_debug("Unknown session stutus"); | |
| break; | |
| }//end switch | |
| }//end while(!session_close) | |
| cwmp_log_debug("session stutus: EXIT"); | |
| cwmp_session_free(session); | |
| session = NULL; | |
| cwmp->session_running = SESSION_NO_RUNNING; | |
| int newtaskres = cwmp_agent_run_tasks(cwmp); | |
| if(newtaskres == CWMP_YES) | |
| { | |
| cwmp->new_request = CWMP_YES; | |
| } | |
| cwmp_reset_periodic_inform(cwmp); | |
| }//end while(TRUE) | |
| } | |
| int cwmp_agent_analyse_session(cwmp_session_t * session) | |
| { | |
| pool_t * doctmppool = NULL; | |
| char * xmlbuf; | |
| cwmp_uint32_t len; | |
| xmldoc_t * doc; | |
| char * method; | |
| xmldoc_t * newdoc = NULL; | |
| int rc = CWMP_OK; | |
| static char * xml_fault = "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:cwmp=\"urn:dslforum-org:cwmp-1-0\" xmlns=\"urn:dslforum-org:cwmp-1-0\"><SOAP-ENV:Body SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\" id=\"_0\"><SOAP-ENV:Fault>Error Message</SOAP-ENV:Fault></SOAP-ENV:Body></SOAP-ENV:Envelope>"; | |
| cwmp_uint32_t msglength = 0; | |
| FUNCTION_TRACE(); | |
| if(NULL == session) | |
| { | |
| cwmp_log_error("session is null"); | |
| return CWMP_ERROR; | |
| } | |
| cwmp_t * cwmp = session->cwmp; | |
| if(NULL == cwmp) | |
| { | |
| cwmp_log_error("cwmp is null"); | |
| return CWMP_ERROR; | |
| } | |
| msglength = cwmp_chunk_length(session->readers); | |
| if (msglength<= 0) | |
| { | |
| session->newdata = CWMP_NO; | |
| cwmp_log_debug("analyse receive length is 0"); | |
| goto eventcheck; | |
| // return CWMP_ERROR; | |
| } | |
| doctmppool = pool_create(POOL_DEFAULT_SIZE); | |
| if(NULL == doctmppool) | |
| { | |
| cwmp_log_error("doctmppool is null"); | |
| return CWMP_ERROR; | |
| } | |
| xmlbuf = pool_palloc(doctmppool, msglength+32); | |
| if(NULL == xmlbuf) | |
| { | |
| cwmp_log_error("xmlbuf is null"); | |
| return CWMP_ERROR; | |
| } | |
| len = sprintf(xmlbuf,"<cwmp>"); | |
| cwmp_chunk_copy(xmlbuf + len, session->readers, msglength); | |
| strncpy(xmlbuf+len+msglength, "</cwmp>", 32-len-1); | |
| cwmp_log_debug("agent analyse xml: \n%s", xmlbuf); | |
| doc = XmlParseBuffer(doctmppool, xmlbuf); | |
| if (!doc) | |
| { | |
| cwmp_log_debug("analyse create doc null\n"); | |
| cwmp_chunk_write_string(session->writers, xml_fault, TRstrlen(xml_fault), session->envpool); | |
| goto finished; | |
| } | |
| method = cwmp_get_rpc_method_name(doc); | |
| cwmp_log_debug("analyse method is: %s\n", method); | |
| cwmp_chunk_clear(session->writers); | |
| pool_clear(session->envpool); | |
| cwmp_log_info("----------------------------"); | |
| if (TRstrcmp(method, CWMP_RPC_GETRPCMETHODS) == 0) | |
| { | |
| newdoc = cwmp_session_create_getrpcmethods_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_INFORMRESPONSE) == 0) | |
| { | |
| newdoc = NULL; | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_GETPARAMETERNAMES) == 0) | |
| { | |
| newdoc = cwmp_session_create_getparameternames_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_GETPARAMETERVALUES) == 0) | |
| { | |
| newdoc = cwmp_session_create_getparametervalues_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_SETPARAMETERVALUES) == 0) | |
| { | |
| newdoc = cwmp_session_create_setparametervalues_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_DOWNLOAD) == 0) | |
| { | |
| newdoc = cwmp_session_create_download_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_UPLOAD) == 0) | |
| { | |
| newdoc = cwmp_session_create_upload_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_TRANSFERCOMPLETERESPONSE) == 0) | |
| { | |
| newdoc = NULL; | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_REBOOT) == 0) | |
| { | |
| newdoc = cwmp_session_create_reboot_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_ADDOBJECT) == 0) | |
| { | |
| newdoc = cwmp_session_create_addobject_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_DELETEOBJECT) == 0) | |
| { | |
| newdoc = cwmp_session_create_deleteobject_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_FACTORYRESET) == 0) | |
| { | |
| newdoc = cwmp_session_create_factoryreset_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_GETPARAMETERATTRIBUTES) == 0) | |
| { | |
| newdoc = cwmp_session_create_getparamterattributes_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_SETPARAMETERATTRIBUTES) == 0) | |
| { | |
| newdoc = cwmp_session_create_setparamterattributes_response_message(session, doc, doctmppool); | |
| } | |
| else if (TRstrcmp(method, CWMP_RPC_SCHEDULEINFORM) == 0) | |
| { | |
| schedule_inform_info_st si; | |
| si.cwmp = session->cwmp; | |
| newdoc = cwmp_session_create_scheduleinform_response_message(session, doc, doctmppool, &si); | |
| int rc = schedule_inform_create_timer(&si); | |
| } | |
| else | |
| { | |
| //check event queue | |
| //newdoc = cwmp_session_create_event_response_message(session, doc, doctmppool); | |
| cwmp_log_info("unknown method type:%s", method); | |
| } | |
| cwmp_log_info("----------------------------"); | |
| // cwmp_t * cwmp = session->cwmp; | |
| if(newdoc == NULL) | |
| { | |
| cwmp_log_debug("agent analyse newdoc is null. "); | |
| eventcheck: | |
| { | |
| cwmp_log_debug("agent analyse begin check global event, %d", cwmp->event_global.event_flag); | |
| //check global event for transfercomplete | |
| if(cwmp->event_global.event_flag & EVENT_REBOOT_TRANSFERCOMPLETE_FLAG) | |
| { | |
| cwmp->event_global.event_flag &= ~EVENT_REBOOT_TRANSFERCOMPLETE_FLAG; | |
| if(!doctmppool) | |
| { | |
| doctmppool = pool_create(POOL_DEFAULT_SIZE); | |
| } | |
| if(!doctmppool) | |
| { | |
| cwmp_log_error("doctmppool pool create return null"); | |
| return CWMP_ERROR; | |
| } | |
| event_code_t ec; | |
| ec.event = INFORM_TRANSFERCOMPLETE; | |
| TRstrncpy(ec.command_key, cwmp->event_global.event_key, COMMAND_KEY_LEN); | |
| ec.fault_code = cwmp->event_global.fault_code; | |
| ec.start = cwmp->event_global.start; | |
| ec.end = cwmp->event_global.end; | |
| newdoc = cwmp_session_create_transfercomplete_message(session, &ec, doctmppool); | |
| } | |
| } | |
| } | |
| cwmp_log_debug("newdoc %p, msglength: %d", newdoc, msglength ); | |
| if(newdoc != NULL) // || (newdoc == NULL && msglength == 0 && session->retry_count < 2)) | |
| { | |
| session->newdata = CWMP_YES; | |
| cwmp_write_doc_to_chunk(newdoc, session->writers, session->envpool); | |
| rc = CWMP_OK; | |
| } | |
| else if(/*newdoc == NULL && */msglength != 0) | |
| { | |
| session->newdata = CWMP_YES; | |
| cwmp_write_doc_to_chunk(newdoc, session->writers, session->envpool); | |
| rc = CWMP_OK; | |
| } | |
| else | |
| { | |
| rc = CWMP_ERROR; | |
| } | |
| finished: | |
| if(doctmppool != NULL) | |
| { | |
| pool_destroy(doctmppool); | |
| } | |
| return rc; | |
| } | |
| static void print_param(parameter_node_t * param, int level) | |
| { | |
| if(!param) return; | |
| parameter_node_t * child; | |
| char fmt[128]; | |
| //cwmp_log_debug("name: %s, type: %s, level: %d\n", param->name, cwmp_get_type_string(param->type), level); | |
| int i=0; | |
| snprintf(fmt, 127, "|%%-%ds%%s, get:%%p set:%%p refresh:%%p\n", level*4); | |
| cwmp_log_debug_src(fmt, "----", param->name, param->get, param->set, param->refresh); | |
| child = param->child; | |
| if(!child) | |
| return; | |
| print_param(child, level+1); | |
| parameter_node_t * next = child->next_sibling; | |
| while(next) | |
| { | |
| print_param(next, level+1); | |
| next = next->next_sibling; | |
| } | |
| } | |
| void cwmp_agent_session(cwmp_t * cwmp) | |
| { | |
| char name[1024] = {0}; | |
| char value[1024]= {0}; | |
| char local_ip[256]; | |
| char * envstr; | |
| char * encstr; | |
| envstr = "SOAP-ENV"; //cwmp_conf_get("cwmp:soap_env"); | |
| encstr = "SOAP-ENC"; // cwmp_conf_get("cwmp:soap_enc"); | |
| cwmp_set_envelope_ns(envstr, encstr); | |
| #if 0 | |
| if (cwmp_session_get_localip(local_ip) == -1) | |
| { | |
| cwmp_log_error("get local ip error. exited.\n"); | |
| exit(-1); | |
| } | |
| #else | |
| cwmp_session_get_localip(local_ip); | |
| #endif | |
| print_param(cwmp->root, 0); | |
| CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, ManagementServerModule, URLModule); | |
| cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->acs_url, TRstrlen(cwmp->acs_url), cwmp->pool); | |
| CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, ManagementServerModule, ConnectionRequestURLModule); | |
| TRsnprintf(value, 1024, "http://%s:%d", local_ip, cwmp->httpd_port); | |
| cwmp_data_set_parameter_value(cwmp, cwmp->root, name, value, TRstrlen(value), cwmp->pool); | |
| cwmp_log_debug("set request name:%s, value:%s", name, value); | |
| CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, ManufacturerModule); | |
| cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_mf, TRstrlen(cwmp->cpe_mf), cwmp->pool); | |
| CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, ManufacturerOUIModule); | |
| cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_oui, TRstrlen(cwmp->cpe_oui), cwmp->pool); | |
| CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, ProductClassModule); | |
| cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_pc, TRstrlen(cwmp->cpe_pc), cwmp->pool); | |
| CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, SerialNumberModule); | |
| cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_sn, TRstrlen(cwmp->cpe_sn), cwmp->pool); | |
| cwmp_agent_start_session(cwmp); | |
| } | |
| /* | |
| int cwmp_agent_download_file(download_arg_t * dlarg) | |
| { | |
| int faultcode = 0; | |
| char url[255]; | |
| if (TRstrncasecmp(dlarg->url, "ftp://", 6) == 0) | |
| { | |
| if (dlarg->username != NULL && strlen(dlarg->username) != 0) | |
| { | |
| TRsnprintf(url, 255, "ftp://%s:%s@%s", dlarg->username, dlarg->password, dlarg->url+6); | |
| } | |
| else | |
| { | |
| TRstrncpy(url, dlarg->url, 255); | |
| } | |
| } | |
| else | |
| { | |
| TRstrncpy(url, dlarg->url, 255); | |
| } | |
| fetchIO * downfile = fetchGetURL(url, ""); | |
| if (!downfile) | |
| { | |
| cwmp_log_debug("download file fail: %s", url); | |
| faultcode = 9001; | |
| } | |
| else | |
| { | |
| char readbuf[1024]; | |
| int readlen; | |
| char targetfile[64]; | |
| if (dlarg->targetname != NULL && strlen(dlarg->targetname) != 0) | |
| { | |
| TRsnprintf(targetfile, 64, "/tmp/%s", dlarg->targetname); | |
| } | |
| else | |
| { | |
| TRsnprintf(targetfile, 64, "/tmp/%d.file", time(NULL)); | |
| } | |
| FILE * df = fopen(targetfile, "wb+"); | |
| while (df != NULL) | |
| { | |
| readlen = fetchIO_read(downfile, readbuf, 1023); | |
| if (readlen <= 0) | |
| { | |
| cwmp_log_debug("fetch io read zero. %s", readlen); | |
| break; | |
| } | |
| readbuf[readlen] = 0; | |
| fwrite(readbuf, readlen, 1, df); | |
| } | |
| if (df) | |
| { | |
| fclose(df); | |
| } | |
| else | |
| { | |
| faultcode = 9001; | |
| } | |
| cwmp_log_debug("download file ok: %s, %s", url, targetfile); | |
| fetchIO_close(downfile); | |
| } | |
| return faultcode; | |
| } | |
| int cwmp_agent_upload_file(upload_arg_t * ularg) | |
| { | |
| int faultcode = 0; | |
| char url[255]; | |
| if (TRstrncasecmp(ularg->url, "ftp://", 6) == 0) | |
| { | |
| if (ularg->username != NULL && strlen(ularg->username) != 0) | |
| { | |
| TRsnprintf(url, 255, "ftp://%s:%s@%s", ularg->username, ularg->password, ularg->url+6); | |
| } | |
| else | |
| { | |
| TRstrncpy(url, ularg->url, 255); | |
| } | |
| } | |
| else | |
| { | |
| TRstrncpy(url, ularg->url, 255); | |
| } | |
| fetchIO * uploadfile = fetchPutURL(url, ""); | |
| if (!uploadfile) | |
| { | |
| cwmp_log_debug("upload file fail: %s", url); | |
| faultcode = 9001; | |
| } | |
| else | |
| { | |
| char readbuf[1024]; | |
| int readlen; | |
| char targetfile[64]; | |
| FILE * uf; | |
| int rc; | |
| if(strcmp(ularg->filetype, "1 Vendor Configuration File") == 0) | |
| { | |
| //¸ù¾Ýʵ¼ÊÇé¿ö, ÐÞ¸ÄÕâÀïµÄÅäÖÃÎļþ·¾¶ | |
| uf = fopen("/tmp/mysystem.cfg", "rb"); | |
| } | |
| else if(strcmp(ularg->filetype, "2 Vendor Log File") == 0) | |
| { | |
| //¸ù¾Ýʵ¼ÊÇé¿ö, ÐÞ¸ÄÕâÀïµÄÅäÖÃÎļþ·¾¶ | |
| uf = fopen("/tmp/mysystem.log", "rb"); | |
| } | |
| else | |
| { | |
| uf = fopen("/tmp/mysystem.log", "rb"); | |
| } | |
| while (uf != NULL) | |
| { | |
| readlen = fread(readbuf, 1024, 1, uf); | |
| if (readlen <= 0) | |
| { | |
| cwmp_log_debug("fetch io read zero. %s", readlen); | |
| break; | |
| } | |
| readbuf[readlen] = 0; | |
| rc = fetchIO_write(uploadfile, readbuf, readlen); | |
| if(rc <= 0) | |
| { | |
| faultcode = 9001; | |
| break; | |
| } | |
| } | |
| if(uf) | |
| { | |
| fclose(uf); | |
| } | |
| else | |
| { | |
| faultcode = 9001; | |
| } | |
| cwmp_log_debug("upload file finished: %s, file:%s", url, targetfile); | |
| fetchIO_close(uploadfile); | |
| } | |
| return faultcode; | |
| } | |
| */ | |
| int cwmp_agent_download_file(download_arg_t * dlarg) | |
| { | |
| int faultcode = 0; | |
| char * fromurl = dlarg->url; | |
| char tofile[256+1] = {0}; | |
| char downloadroot[256+1] = {0}; | |
| FUNCTION_TRACE(); | |
| if(!fromurl) | |
| { | |
| cwmp_log_error("download src file path is null!"); | |
| return 9001; | |
| } | |
| if(NULL == dlarg->targetname) | |
| { | |
| if(TRstrcmp(dlarg->filetype, "1 Firmware Upgrade Image") == 0) | |
| { | |
| cwmp_conf_get("file:download_img_path", tofile); | |
| } | |
| else if(TRstrcmp(dlarg->filetype, "3 Vendor Configuration File") == 0) | |
| { | |
| cwmp_conf_get("file:download_cfg_path", tofile); | |
| } | |
| else | |
| { | |
| cwmp_conf_get("file:download_unknown_path", tofile); | |
| } | |
| } | |
| else | |
| { | |
| cwmp_conf_get("file:download_root", downloadroot); | |
| TRsnprintf(tofile, 256, "%s/%s", downloadroot, dlarg->targetname); | |
| } | |
| cwmp_log_info("file type:%s, save file(%s) to path:%s", dlarg->filetype, fromurl, tofile); | |
| if(/*dlarg->url &&*/ TRstrncasecmp("ftp://", dlarg->url, 6) == 0) | |
| { | |
| cwmp_log_debug("Download url:%s", dlarg->url); | |
| return 9001; | |
| } | |
| faultcode = http_receive_file(fromurl, tofile); | |
| if(faultcode != CWMP_OK) | |
| { | |
| cwmp_log_debug("faultcode:%d", faultcode); | |
| faultcode = 9001; | |
| } | |
| return faultcode; | |
| } | |
| int cwmp_agent_upload_file(upload_arg_t * ularg) | |
| { | |
| int faultcode = 0; | |
| FUNCTION_TRACE(); | |
| char * fromfile; | |
| char cfg_path[256] = {0}; | |
| char log_path[256] = {0}; | |
| FUNCTION_TRACE(); | |
| cwmp_conf_get("file:upload_cfg_path", cfg_path); | |
| cwmp_conf_get("file:upload_log_path", log_path); | |
| if(TRstrcmp(ularg->filetype, "1 Vendor Configuration File") == 0) | |
| { | |
| fromfile = cfg_path; | |
| } | |
| else if(TRstrcmp(ularg->filetype, "2 Vendor Log File") == 0) | |
| { | |
| fromfile = log_path; | |
| } | |
| else | |
| { | |
| fromfile = cfg_path; | |
| } | |
| cwmp_log_info("upload type:%s, send file:%s, url:%s", ularg->filetype, fromfile, ularg->url); | |
| faultcode = http_send_file(fromfile, ularg->url); | |
| if(faultcode != CWMP_OK) | |
| { | |
| cwmp_log_error("http send file return[%d], not CWMP_OK, set faultcode 9001", faultcode); | |
| faultcode = 9001; | |
| } | |
| return faultcode; | |
| } | |
| int cwmp_agent_run_tasks(cwmp_t * cwmp) | |
| { | |
| void * data; | |
| int tasktype = 0;; | |
| int ok = CWMP_NO; | |
| int rc = 0; | |
| FUNCTION_TRACE(); | |
| while(1) | |
| { | |
| tasktype = queue_pop(cwmp->queue, &data); | |
| if(tasktype == -1) | |
| { | |
| cwmp_log_debug("no more task to run"); | |
| break; | |
| } | |
| ok = CWMP_YES; | |
| switch(tasktype) | |
| { | |
| case TASK_DOWNLOAD_TAG: | |
| { | |
| cwmp_log_debug("Download begin....."); | |
| download_arg_t * dlarg = (download_arg_t*)data; | |
| //begin download file | |
| time_t starttime = time(NULL); | |
| int faultcode = 0; | |
| faultcode = cwmp_agent_download_file(dlarg); | |
| time_t endtime = time(NULL); | |
| cwmp_event_set_value(cwmp, INFORM_TRANSFERCOMPLETE, 1,dlarg->cmdkey, faultcode, starttime, endtime); | |
| FREE(dlarg); | |
| cwmp_log_debug("Download OK....."); | |
| } | |
| break; | |
| case TASK_UPLOAD_TAG: | |
| { | |
| cwmp_log_debug("Upload begin....."); | |
| upload_arg_t * ularg = (upload_arg_t*)data; | |
| //begin download file | |
| time_t starttime = time(NULL); | |
| int faultcode = 0; | |
| faultcode = cwmp_agent_upload_file(ularg); | |
| time_t endtime = time(NULL); | |
| cwmp_event_set_value(cwmp, INFORM_TRANSFERCOMPLETE, 1,ularg->cmdkey, faultcode, starttime, endtime); | |
| FREE(ularg); | |
| cwmp_log_debug("Upload OK....."); | |
| } | |
| break; | |
| case TASK_REBOOT_TAG: | |
| { | |
| //begin reboot system | |
| cwmp_log_debug("reboot ..."); | |
| cwmp_event_set_value(cwmp, INFORM_MREBOOT, 1, NULL, 0, 0, 0); | |
| cwmp_event_clear_active(cwmp); | |
| // inorder to save file ok | |
| sleep(20); | |
| rc = restart_request(MODULE_ID_TR069); | |
| if(0 != rc) | |
| { | |
| cwmp_log_info("restart request fail! rc:%d", rc); | |
| } | |
| } | |
| break; | |
| case TASK_FACTORYRESET_TAG: | |
| { | |
| //begin factory reset system | |
| cwmp_log_debug("factory reset begin..."); | |
| cwmp_event_clear_active(cwmp); | |
| rc = reset_request(MODULE_ID_TR069); | |
| if(0 != rc) | |
| { | |
| cwmp_log_info("reset request fail! rc:%d", rc); | |
| } | |
| cwmp_log_debug("factory reset OK....."); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return ok; | |
| } | |