int agent_register(u32 agent_id, const char *seq)
{
//pack the login xml
xmlDocPtr doc = create_xml_doc();
xmlNodePtr devnode;
xmlNodePtr childnode;
xmlNodePtr rootnode = create_xml_root_node(doc,"AGENT_REGISTER");
struct timeval now;
gettimeofday(&now, NULL);
char * time = PRINTTIME(now);
add_xml_child(rootnode, "timestamp",time); free(time);
devnode = add_xml_child(rootnode, "device", NULL);
char aid[24];
sprintf(aid,"%d", get_pma_id());
add_xml_child_prop(devnode, "id",aid);
char dev_type[10];
if( get_protocol_type() == OSPF_ROUTER )
sprintf(dev_type, "ospf");
else if( get_protocol_type() == BGP_ROUTER )
sprintf(dev_type, "bgp");
else {}
add_xml_child(devnode, "type", dev_type);
char* xmlbuff;
int len = 0;
xmlDocDumpFormatMemoryEnc( doc, &xmlbuff, &len, "UTF-8", 0);
char* buff = (char*)malloc(len+1);
memcpy(buff, xmlbuff, len);
buff[len] = 0;
xmlFree(xmlbuff);
xmlFreeDoc(doc);
struct req_args *login_args =
(struct req_args *)malloc(sizeof(struct req_args)+len);
memset(login_args->ip, 0, sizeof(login_args->ip));
char *ip = get_server_address();
memcpy(login_args->ip, ip, strlen(ip));
login_args->port = get_server_port();
login_args->ops_type = OPS_PMA_LOGIN;
login_args->len = len;
memcpy(login_args->data, buff, len);
free(buff);
if (login(login_args) == ((void *)-1)) {
free(login_args);
return -1;
}
free(login_args);
agent_login_status = AGENT_LOGIN;
return SUCCESS;
}
/* Change name from requestSetupDefaultPDP to requestSetupDataCall */
void requestSetupDataCall(void * data, size_t datalen, RIL_Token t)
{
/* In GSM with CDMA version: DOUNT - data[0] is radioType(GSM/UMTS or CDMA), data[1] is profile,
* data[2] is apn, data[3] is username, data[4] is passwd, data[5] is authType (added by Android2.1)
* data[6] is cid field added by mtk for Multiple PDP contexts setup support 2010-04
*/
const char* profile = ((const char **)data)[1];
const char* apn = ((const char **)data)[2];
const char* username = ((const char **)data)[3];
const char* passwd = ((const char **)data)[4];
const int authType = getAuthType(((const char **)data)[5]);
const int protocol = get_protocol_type(((const char **)data)[6]);
const int interfaceId = atoi(((const char **)data)[7]) - 1;
LOGD("requestSetupData profile=%s, apn=%s, username=%s, password=xxxx, authType=%d, protocol=%d, interfaceId=%d",
profile, apn, username, authType, protocol, interfaceId);
int requestParamNumber = (datalen/sizeof(char*));
LOGD("requestSetupData with datalen=%d and parameter number=%d", datalen, requestParamNumber);
if (requestParamNumber != 8) {
/* Last parm is the authType instaed of cid */
LOGD("requestSetupData with incorrect parameters");
goto error;
}
#if defined(PURE_AP_USE_EXTERNAL_MODEM) && !defined(MT6280_SUPER_DONGLE)
if (strcmp(profile, "1002") == 0) {
// Always request for CID 1 for default connection
requestSetupDataCallOverIPv6(apn, username, passwd, authType, protocol, 0, 1, profile, t);
} else {
requestSetupDataCallOverIPv6(apn, username, passwd, authType, protocol, 1, 2, profile, t);
}
#else
//genenal project
requestSetupDataCallOverIPv6(apn, username, passwd, authType, protocol, interfaceId, profile, t);
#endif
return;
error:
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
}
void dst_entry::configure_ip_header(header *h, uint16_t packet_id)
{
h->configure_ip_header(get_protocol_type(), m_bound_ip ? m_bound_ip : m_p_net_dev_val->get_local_addr(), m_dst_ip.get_in_addr(), m_ttl, m_tos, packet_id);
}
bool C_ProtocolControl::fromXml (C_XmlData *P_data,
T_pConfigValueList P_config_value_list,
bool P_display_protocol_stats) {
bool L_ret = true ;
T_pXmlData_List L_subList ;
T_XmlData_List::iterator L_subListIt ;
C_XmlData *L_data ;
char *L_protocol_name,
*L_protocol_type ;
int L_protocol_id ;
T_ProtocolInstList L_protocol_inst_list ;
T_pProtocolInstanceInfo L_protocol_info ;
T_ProtocolInstList::iterator L_it ;
GEN_DEBUG(1, "C_ProtocolControl::fromXml() start");
if (P_data != NULL) {
if ((L_subList = P_data->get_sub_data()) != NULL) {
for (L_subListIt = L_subList->begin() ;
L_subListIt != L_subList->end() ;
L_subListIt++) {
L_data = *L_subListIt ;
if (L_data != NULL) {
if (strcmp(L_data->get_name(), XML_PROTOCOL_SECTION) == 0) {
// protocol section definition found
L_protocol_name = get_protocol_name (L_data) ;
// check protocol type for creation
L_protocol_type = get_protocol_type (L_data) ;
// check name/type presence
if (L_protocol_name == NULL) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"name mandatory for section " << XML_PROTOCOL_SECTION);
L_ret = false ;
break ;
}
if (L_protocol_type == NULL) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"type mandatory for section " << XML_PROTOCOL_SECTION);
L_ret = false ;
break ;
}
// check protocol name unicity
if (m_name_map->find(T_ProtocolNameMap::key_type(L_protocol_name))
!= m_name_map->end()) {
GEN_ERROR(E_GEN_FATAL_ERROR,
XML_PROTOCOL_SECTION << " with name ["
<< L_protocol_name << "] already defined");
L_ret = false ;
break ;
}
// check protocol type or sub type
if (strcmp(L_protocol_type, "binary") == 0) {
// create protocol instance
C_ProtocolBinary *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolBinary());
L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "binary-tlv") == 0) {
// create protocol instance
C_ProtocolTlv *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolTlv());
L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "binary-body-not-interpreted") == 0) {
// create protocol instance
C_ProtocolBinaryBodyNotInterpreted *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolBinaryBodyNotInterpreted());
L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "binary-separator") == 0) {
// create protocol instance
C_ProtocolBinarySeparator *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolBinarySeparator());
L_protocol_instance
->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "external-library") == 0) {
C_ProtocolExternal *L_protocol_instance = NULL ;
T_ConstructorResult L_res = E_CONSTRUCTOR_OK ;
NEW_VAR(L_protocol_instance,
C_ProtocolExternal(m_transport_control,
L_data, &L_protocol_name,
P_config_value_list,
&L_res));
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
// store new instance
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "text") == 0) {
C_ProtocolText *L_protocol_instance = NULL ;
T_ConstructorResult L_res = E_CONSTRUCTOR_OK ;
NEW_VAR(L_protocol_instance,
C_ProtocolText());
L_protocol_instance->analyze_data(L_data,
&L_protocol_name,
P_config_value_list,
&L_res);
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
// store new instance
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else {
GEN_ERROR(E_GEN_FATAL_ERROR,
XML_PROTOCOL_SECTION
<< " ["
<< L_protocol_name
<< "] with type ["
<< L_protocol_type << "] unsupported");
L_ret = false ;
}
}
}
}
if (L_ret != false) {
if (!L_protocol_inst_list.empty()) {
m_protocol_table_size = L_protocol_inst_list.size() ;
ALLOC_TABLE(m_protocol_table,
T_pC_ProtocolFrame*,
sizeof(T_pC_ProtocolFrame),
m_protocol_table_size) ;
ALLOC_TABLE(m_protocol_name_table,
char**,
sizeof(char*),
m_protocol_table_size) ;
for (L_it = L_protocol_inst_list.begin();
L_it != L_protocol_inst_list.end() ;
L_it++) {
L_protocol_info = *L_it ;
m_protocol_table[L_protocol_info->m_id]
= L_protocol_info->m_instance ;
m_protocol_name_table[L_protocol_info->m_id]
= L_protocol_info->m_name ;
}
} else {
GEN_ERROR(E_GEN_FATAL_ERROR,
"No protocol definition found");
L_ret = false ;
}
} // if L_ret != false
if (!L_protocol_inst_list.empty()) {
for (L_it = L_protocol_inst_list.begin();
L_it != L_protocol_inst_list.end() ;
L_it++) {
FREE_VAR(*L_it);
}
L_protocol_inst_list.erase(L_protocol_inst_list.begin(),
L_protocol_inst_list.end());
}
}
int agent_init_request(char* routerid)
{
//pack the login xml
xmlDocPtr doc = create_xml_doc();
xmlNodePtr devnode;
xmlNodePtr childnode;
xmlNodePtr rootnode = create_xml_root_node(doc,"AGENT_INIT");
struct timeval now;
gettimeofday(&now, NULL);
char * time = PRINTTIME(now);
add_xml_child(rootnode, "timestamp",time); free(time);
devnode = add_xml_child(rootnode, "device", NULL);
char aid[24];
sprintf(aid,"%d", get_pma_id());
add_xml_child_prop(devnode, "id",aid);
char dev_type[10];
if( get_protocol_type() == OSPF_ROUTER )
{
sprintf(dev_type, "ospf");
add_xml_child(devnode, "type", dev_type);
}
else if( get_protocol_type() == BGP_ROUTER )
{
sprintf(dev_type, "bgp");
add_xml_child(devnode, "type", dev_type);
}
else {}
char asid[24];
inet_ntop(AF_INET, &pma_conf.as_num , asid, 24);
add_xml_child(devnode, "as_id", asid);
add_xml_child(devnode, "router_id", routerid);
char ctlip[24];
inet_ntop(AF_INET, &pma_conf.ic_config.hello_ip, ctlip,24);
add_xml_child(devnode, "agent_control_ip", ctlip);
char* xmlbuff;
int len = 0;
xmlDocDumpFormatMemoryEnc( doc, &xmlbuff, &len, "UTF-8", 0);
char* buff = (char*)malloc(len+1);
memcpy(buff, xmlbuff, len);
buff[len] = 0;
xmlFree(xmlbuff);
xmlFreeDoc(doc);
len = strlen(buff);
char rid[24];
strcpy(rid,routerid);
struct req_args *req_arg =
(struct req_args *)malloc(sizeof(struct req_args));
memset(req_arg->ip, 0, sizeof(req_arg->ip));
char *ip = get_server_address();
memcpy(req_arg->ip, ip, strlen(ip));
req_arg->port = get_server_port();
req_arg->ops_type = OPS_PMA_INIT_REQUEST;
req_arg->len = 0;
int ret = send_message_to_pms(req_arg->ip,
req_arg->port,
req_arg->ops_type,
buff,
len);
free(req_arg);
free(buff);
return ret;
}
void dst_entry::configure_ip_header(uint16_t packet_id)
{
m_header.configure_ip_header(get_protocol_type(), m_p_net_dev_val->get_local_addr(), m_dst_ip.get_in_addr(), m_ttl, m_tos, packet_id);
}
