| //SPDX-License-Identifier: MediaTekProprietary |
| /* Copyright Statement: |
| * |
| * This software/firmware and related documentation ("MediaTek Software") are |
| * protected under relevant copyright laws. The information contained herein |
| * is confidential and proprietary to MediaTek Inc. and/or its licensors. |
| * Without the prior written permission of MediaTek inc. and/or its licensors, |
| * any reproduction, modification, use or disclosure of MediaTek Software, |
| * and information contained herein, in whole or in part, shall be strictly prohibited. |
| */ |
| /* MediaTek Inc. (C) 2010. All rights reserved. |
| * |
| * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES |
| * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") |
| * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON |
| * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT. |
| * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE |
| * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR |
| * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH |
| * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES |
| * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES |
| * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK |
| * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR |
| * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND |
| * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, |
| * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, |
| * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO |
| * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. |
| * |
| * The following software/firmware and/or related documentation ("MediaTek Software") |
| * have been modified by MediaTek Inc. All revisions are subject to any receiver's |
| * applicable license agreements with MediaTek Inc. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <binder/Parcel.h> |
| #include <vendor-ril/telephony/ril.h> |
| #include <pal/pal_nm.h> |
| #include <string.h> |
| #include <log/log.h> |
| #include <strings.h> |
| #include <apn_interface.h> |
| #include <vector> |
| #include <string> |
| |
| #include "data/data.h" |
| #include "common.h" |
| |
| #include "data/data_gdbus.h" |
| #include "Radio_capability_switch_util.h" |
| #include "util/utils.h" |
| |
| /*Warren add forT800 platform 2021/12/25 start*/ |
| #include "lynq_common.h" |
| #include "lynq_interface.h" |
| using android::Parcel; |
| /*Warren add for t800 ril service 2021/12/25 end*/ |
| #undef LOG_TAG |
| #define LOG_TAG "DEMO_DATA" |
| |
| #define SKIP_DATA_SETTINGS -2 |
| |
| typedef struct { |
| char apn_type[10]; |
| int cid; |
| int net_id; |
| char ifname[16]; |
| }map_cid; |
| |
| struct apntype_2_bitmask { |
| char *type; |
| int typebitmask; |
| }; |
| |
| #define APN_TYPE_ALL "*" |
| #define TEXT_APN_TYPE_DEFAULT "default" |
| #define TEXT_APN_TYPE_IMS "ims" |
| #define TEXT_APN_TYPE_MMS "mms" |
| #define TEXT_APN_TYPE_SUPL "supl" |
| #define TEXT_APN_TYPE_DUN "dun" |
| #define TEXT_APN_TYPE_HIPRI "hipri" |
| #define TEXT_APN_TYPE_FOTA "fota" |
| #define TEXT_APN_TYPE_CBS "cbs" |
| #define TEXT_APN_TYPE_EMERGENCY "emergency" |
| #define TEXTAPN_TYPE_IA "ia" |
| #define TEXT_APN_TYPE_DM "dm" |
| #define TEXT_APN_TYPE_WAP "wap" |
| #define TEXT_APN_TYPE_NET "net" |
| #define TEXT_APN_TYPE_CMMAIL "cmmail" |
| #define TEXT_APN_TYPE_TETHERING "tethering" |
| #define TEXT_APN_TYPE_RCSE "rcse" |
| #define TEXT_APN_TYPE_XCAP "xcap" |
| #define TEXT_APN_TYPE_RCS "rcs" |
| |
| //for IOT card type |
| #define IOT_TEXT_APN_TYPE_DEFAULT "iot_default" |
| #define IOT_TEXT_APN_TYPE_NET_0 "iot_net_0" |
| #define IOT_TEXT_APN_TYPE_NET_1 "iot_net_1" |
| #define IOT_TEXT_APN_TYPE_NET_2 "iot_net_2" |
| #define IOT_TEXT_APN_TYPE_NET_3 "iot_net_3" |
| #define IOT_TEXT_APN_TYPE_NET_4 "iot_net_4" |
| #define IOT_TEXT_APN_TYPE_NET_5 "iot_net_5" |
| #define IOT_TEXT_APN_TYPE_NET_6 "iot_net_6" |
| |
| #ifdef TARGET_PLATFORM_MT2731 |
| #define DATAASST_PDN_APN_TYPE_UNKNOWN 0x0 |
| #define DATAASST_PDN_APN_TYPE_DEFAULT 0x1 |
| #define DATAASST_PDN_APN_TYPE_MMS 0x2 |
| #define DATAASST_PDN_APN_TYPE_SUPL 0x4 |
| #define DATAASST_PDN_APN_TYPE_DUN 0x8 |
| #define DATAASST_PDN_APN_TYPE_HIPRI 0x10 |
| #define DATAASST_PDN_APN_TYPE_FOTA 0x20 |
| #define DATAASST_PDN_APN_TYPE_IMS 0x40 |
| #define DATAASST_PDN_APN_TYPE_CBS 0x80 |
| #define DATAASST_PDN_APN_TYPE_IA 0x100 |
| #define DATAASST_PDN_APN_TYPE_EMERGENCY 0x200 |
| #define DATAASST_PDN_APN_TYPE_WAP 0x400 |
| #define DATAASST_PDN_APN_TYPE_XCAP 0x800 |
| #define DATAASST_PDN_APN_TYPE_RCS 0x1000 |
| #define DATAASST_PDN_APN_TYPE_BIP 0x2000 |
| #define DATAASST_PDN_APN_TYPE_VSIM 0x4000 |
| #else |
| #define DATAASST_PDN_APN_TYPE_UNKNOWN (0x00000000) |
| #define DATAASST_PDN_APN_TYPE_DEFAULT (0x00000001) |
| #define DATAASST_PDN_APN_TYPE_IMS (0x00000002) |
| #define DATAASST_PDN_APN_TYPE_MMS (0x00000004) |
| #define DATAASST_PDN_APN_TYPE_SUPL (0x00000008) |
| #define DATAASST_PDN_APN_TYPE_DUN (0x00000010) |
| #define DATAASST_PDN_APN_TYPE_HIPRI (0x00000020) |
| #define DATAASST_PDN_APN_TYPE_FOTA (0x00000040) |
| #define DATAASST_PDN_APN_TYPE_CBS (0x00000080) |
| #define DATAASST_PDN_APN_TYPE_EMERGENCY (0x00000100) |
| #define DATAASST_PDN_APN_TYPE_IA (0x00000200) |
| #define DATAASST_PDN_APN_TYPE_DM (0x00000400) |
| #define DATAASST_PDN_APN_TYPE_WAP (0x00000800) |
| #define DATAASST_PDN_APN_TYPE_NET (0x00001000) |
| #define DATAASST_PDN_APN_TYPE_CMMAIL (0x00002000) |
| #define DATAASST_PDN_APN_TYPE_TETHERING (0x00004000) |
| #define DATAASST_PDN_APN_TYPE_RCSE (0x00008000) |
| #define DATAASST_PDN_APN_TYPE_XCAP (0x00010000) |
| #define DATAASST_PDN_APN_TYPE_RCS (0x00020000) |
| #endif |
| //for IOT |
| #define IOT_DATAASST_PDN_APN_TYPE_DEFAULT (0x00100000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_0 (0x00200000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_1 (0x00400000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_2 (0x00800000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_3 (0x01000000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_4 (0x02000000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_5 (0x04000000) |
| #define IOT_DATAASST_PDN_APN_TYPE_NET_6 (0x08000000) |
| |
| #define LEN 128 |
| char line[LEN] = {0}; |
| char csname[27] = {0}; |
| static int net_id = 1000; |
| |
| int ims_type_in_db = 0; |
| |
| static int data_call_num = 0; |
| |
| RIL_Data_Call_Response_v6 *data_call_response = NULL; |
| const int INVALID_VALUE = -1; |
| const int INVALID = -2; |
| int gcid = -1; |
| bool isEnable = false; |
| |
| char cur_apn_type[12]={0}; |
| |
| int SETUP_DATA_AUTH_NONE = 0; |
| int SETUP_DATA_AUTH_PAP = 1; |
| int SETUP_DATA_AUTH_CHAP = 2; |
| int SETUP_DATA_AUTH_PAP_CHAP = 3; |
| |
| char* SETUP_DATA_PROTOCOL_IPV4 = "IP"; |
| char* SETUP_DATA_PROTOCOL_IPV6 = "IPV6"; |
| char* SETUP_DATA_PROTOCOL_IPV4V6 = "IPV4V6"; |
| |
| map_cid current_cid[8] = { |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""}, \ |
| {"", -1, -1, ""} |
| }; |
| |
| //when 1, libvendor-ril manage the PDN retry , network configuration than create from ril request. |
| bool isEnableLocalconf(){ |
| bool isEnable = false; |
| RLOGD("enable configuration: %d", isEnable); |
| |
| char prop_value[64] = { 0 }; |
| |
| utils::mtk_property_get("persist.pdnby.vendor",prop_value,"0"); |
| |
| isEnable = atoi(prop_value); |
| |
| RLOGD("mtk_property_get configuration: %d", isEnable); |
| return isEnable; |
| } |
| |
| /* Deactivate data call reasons */ |
| int DEACTIVATE_REASON_NONE = 0; |
| int DEACTIVATE_REASON_RADIO_OFF = 1; |
| int DEACTIVATE_REASON_PDP_RESET = 2; |
| |
| char dns[4][40] = {0}; |
| int dnsNum = 0; |
| |
| int findCellularName(char *s) |
| { |
| int i = 0; |
| while (i < LEN) { |
| if (strncmp((s + i), "cellular_", 9) == 0) { |
| strncpy(csname, (s + i), 26); |
| csname[26] = '\0'; |
| RLOGD("cellular service name is %s\n", csname); |
| return i; |
| } else { |
| i++; |
| } |
| } |
| return -1; |
| } |
| |
| int getCellularService() |
| { |
| FILE *cmd = popen("connmanctl services | grep cellular", "r"); |
| |
| if (cmd == NULL) { |
| RLOGD("open pipe fail!\n"); |
| return -1; |
| } |
| |
| fgets(line, LEN, cmd); |
| RLOGD("line is %s\n", line); |
| |
| pclose(cmd); |
| return 0; |
| } |
| |
| char* checkParameters(char* para) |
| { |
| if (strcasecmp(para, "null") == 0) { |
| return ""; |
| } else { |
| return para; |
| } |
| } |
| |
| void updateApntype(char* apntype) |
| { |
| if(strcasecmp(cur_apn_type, "ims") == 0 |
| || strcasecmp(cur_apn_type, "xcap") == 0 |
| || strcasecmp(cur_apn_type, "ia") == 0) |
| { |
| RLOGD("the current apn type: %s, don't set router, so just return", cur_apn_type); |
| return; |
| } |
| |
| for(int i =0; i < 8; i++) |
| { |
| if((strcmp(current_cid[i].apn_type, "") == 0) || (current_cid[i].cid == INVALID_VALUE)) |
| { |
| memset(current_cid[i].apn_type,0, strlen(current_cid[i].apn_type)); |
| strcpy(current_cid[i].apn_type, apntype); |
| RLOGD("updateApntype[%d]: %s", i, apntype); |
| break; |
| } |
| } |
| } |
| |
| void updatenetId(char* apntype, int net_id) |
| { |
| for(int i =0; i < 8; i++) |
| { |
| for (int i = 0; i < 8 ; i++) |
| { |
| if(current_cid[i].net_id== INVALID_VALUE |
| && (strcmp(current_cid[i].apn_type, apntype) == 0)) |
| { |
| current_cid[i].net_id = net_id; |
| RLOGD("updatenetId[%d]: %d", i, net_id); |
| } |
| } |
| } |
| } |
| |
| void updateInterfaceName(char* apntype,char* interface_name) |
| { |
| for (int i = 0; i < 8 ; i++) |
| { |
| if((strcmp(current_cid[i].ifname, "") == 0) |
| && (strcmp(current_cid[i].apn_type, apntype) == 0)) |
| { |
| memset(current_cid[i].ifname,0, strlen(current_cid[i].ifname)); |
| strncpy(current_cid[i].ifname, interface_name, sizeof(current_cid[i].ifname) - 1); |
| current_cid[i].ifname[sizeof(current_cid[i].ifname) - 1] = '\0'; |
| RLOGD("updateinterfaceName[%d]: %s", i, current_cid[i].ifname); |
| break; |
| } |
| } |
| } |
| void destroyCid(char* apntype) |
| { |
| for(int i =0; i < 8; i++) |
| { |
| if(strcmp(current_cid[i].apn_type, apntype) == 0) |
| { |
| strcpy(current_cid[i].apn_type, ""); |
| current_cid[i].cid = -1; |
| current_cid[i].net_id = -1; |
| strcpy(current_cid[i].ifname, ""); |
| RLOGD("destroyCid[%d]: %s",i, apntype); |
| break; |
| } |
| } |
| } |
| |
| int getcid(char* apntype) |
| { |
| int cid = INVALID_VALUE; |
| for(int i = 0; i < 8; i++) |
| { |
| if(strcmp(current_cid[i].apn_type, apntype) == 0) |
| { |
| cid = current_cid[i].cid; |
| break; |
| } |
| } |
| RLOGD("getcid: %d , apntype: %s", cid, apntype); |
| return cid; |
| } |
| |
| int getnetId(char* apntype) |
| { |
| int netid = INVALID_VALUE; |
| for(int i = 0; i < 8; i++) |
| { |
| if(strcmp(current_cid[i].apn_type, apntype) == 0) |
| { |
| netid = current_cid[i].net_id; |
| break; |
| } |
| } |
| RLOGD("getnetId: %d , apntype: %s", netid, apntype); |
| return netid; |
| } |
| |
| char* getIfnameFromCache(char* apnType) |
| { |
| char* interfaceName = NULL; |
| for(int i = 0; i < 8; i++) |
| { |
| if(strcmp(current_cid[i].apn_type, apnType) == 0) |
| { |
| interfaceName = current_cid[i].ifname; |
| break; |
| } |
| } |
| RLOGD("getIfnameFromCache: %s, apntype: %s", interfaceName, apnType); |
| return interfaceName; |
| } |
| |
| char* getDns(char* apnType) |
| { |
| RLOGD("getDns start data_call_num: %d", data_call_num); |
| char dnses[150] = ""; |
| int cid = getcid(apnType); |
| if(cid == INVALID_VALUE) |
| { |
| RLOGD("cid is invalid"); |
| return NULL; |
| } |
| for(int i = 0 ; i < data_call_num; i++) |
| { |
| if((data_call_response != NULL) && (data_call_response[i].cid == cid)) |
| { |
| strncpy(dnses, data_call_response[i].dnses, sizeof(dnses)-1); |
| dnses[sizeof(dnses) -1] = '\0'; |
| } |
| } |
| RLOGD("dnses: %s", dnses); |
| if (strcmp(dnses, "") == 0) |
| { |
| RLOGD("dnses is null"); |
| return NULL; |
| } |
| |
| memset(dns,0,4*40); |
| dnsNum = 0; |
| |
| RLOGD("fill data"); |
| if(strstr(dnses, " ")) |
| { |
| char* p = strtok(dnses, " "); |
| while(p) |
| { |
| if(dnsNum < 4) |
| { |
| RLOGD("dns[%d]: %s",dnsNum, p); |
| strcpy(dns[dnsNum],p); |
| dnsNum++; |
| } |
| p = strtok(NULL, " "); |
| } |
| } else { |
| RLOGD("dns: %s, only one", dnses); |
| strcpy(dns[dnsNum],dnses); |
| dnsNum++; |
| } |
| return NULL; |
| } |
| |
| char* getAddress(char* apnType, const char token) |
| { |
| char* ip = NULL; |
| char* addrs = NULL; |
| int cid = getcid(apnType); |
| if(cid == INVALID_VALUE) |
| { |
| RLOGD("cid is invalid"); |
| return NULL; |
| } |
| for(int i = 0 ; i < data_call_num; i++) |
| { |
| if((data_call_response != NULL) && (data_call_response[i].cid == cid)) |
| { |
| addrs = data_call_response[i].addresses; |
| } |
| } |
| if(!addrs) |
| { |
| RLOGD("addresss is null"); |
| return NULL; |
| } |
| if(strstr(addrs, " ")) |
| { |
| char* p = strtok(addrs, " "); |
| while(p) |
| { |
| if(strchr(p, token)) |
| { |
| ip = p; |
| break; |
| } else { |
| p = strtok(p, " "); |
| } |
| } |
| } else { |
| if(strchr(addrs, token)) |
| { |
| ip = addrs; |
| } |
| } |
| RLOGD("ip: %s", ip); |
| return ip; |
| } |
| |
| char* getGateWay(char* apnType, const char token) |
| { |
| char* gateway = NULL; |
| char* gateways = NULL; |
| int cid = getcid(apnType); |
| if(cid == INVALID_VALUE) |
| { |
| RLOGD("cid is invalid"); |
| return NULL; |
| } |
| for(int i = 0 ; i < data_call_num; i++) |
| { |
| if((data_call_response != NULL) && (data_call_response[i].cid == cid)) |
| { |
| gateways = data_call_response[i].gateways; |
| } |
| } |
| if(!gateways) |
| { |
| RLOGD("gateways is null"); |
| return NULL; |
| } |
| if(strstr(gateways, " ")) |
| { |
| char* p = strtok(gateways, " "); |
| while(p) |
| { |
| if(strchr(p, token)) |
| { |
| gateway = p; |
| break; |
| } else { |
| p = strtok(p, " "); |
| } |
| } |
| } else { |
| if(strchr(gateways, token)) |
| { |
| gateway = gateways; |
| } |
| } |
| RLOGD("gateway : %s", gateway); |
| return gateway; |
| } |
| char* getInterfaceNameFromLocal(char* apnType) |
| { |
| char* interfaceName = NULL; |
| int cid = getcid(apnType); |
| if(cid == INVALID_VALUE) |
| { |
| RLOGD("cid is invalid"); |
| return NULL; |
| } |
| for(int i = 0 ; i < 8; i++) |
| { |
| if(current_cid[i].cid == cid) |
| { |
| interfaceName = current_cid[i].ifname; |
| } |
| } |
| RLOGD("interfaceName: %s", interfaceName); |
| return interfaceName; |
| } |
| char* getInterfaceName(char* apnType) |
| { |
| char* interfaceName = NULL; |
| int cid = getcid(apnType); |
| if(cid == INVALID_VALUE) |
| { |
| RLOGD("cid is invalid"); |
| return NULL; |
| } |
| for(int i = 0 ; i < data_call_num; i++) |
| { |
| if((data_call_response != NULL) && (data_call_response[i].cid == cid)) |
| { |
| interfaceName= data_call_response[i].ifname; |
| } |
| } |
| RLOGD("interfaceName: %s", interfaceName); |
| return interfaceName; |
| } |
| |
| void configInterNetNetwork(char * apnType) |
| { |
| //if route had filled. do fill the router information |
| char* interface_name = getInterfaceName(apnType); |
| if(!interface_name) |
| { |
| RLOGW("config fail, interface_name is nul"); |
| return; |
| } |
| //if mal had set the route, don't set it. |
| unsigned int netid = 0; |
| int value = nm_interface_get_netid(interface_name, &netid); |
| if(netid > 0) { |
| RLOGW("the netid exsited. value: %d, netid: %d ", value, netid); |
| return; |
| } |
| if(net_id +1 >= 2000 ) { |
| net_id = 1001; |
| } else { |
| net_id++; |
| } |
| |
| RLOGD("NET_ID: %d", net_id); |
| updatenetId(apnType,net_id); |
| |
| char* temp_gateway = NULL; |
| char ipv4_gateway[16] = ""; |
| char ipv6_gateway[40] = ""; |
| temp_gateway = getGateWay(apnType, '.'); |
| if(temp_gateway != NULL) { |
| strcpy(ipv4_gateway, temp_gateway); |
| } |
| temp_gateway = NULL; |
| temp_gateway = getGateWay(apnType,':'); |
| if(temp_gateway != NULL) { |
| strcpy(ipv6_gateway, temp_gateway); |
| } |
| |
| |
| int prefix_len_ipv4 = 8; |
| int prefix_len_ipv6 = 64; |
| char* temp_dns[4] = {0}; |
| |
| updateInterfaceName(apnType,interface_name); |
| getDns(apnType); |
| char* DESTIONNATION_IPV4 = "0.0.0.0/0"; |
| char* DESTIONNATION_IPV6 = "::/0"; |
| |
| RLOGD("nm_network_create() netid: %d", net_id); |
| if(nm_network_create(net_id, NULL) != 0) |
| { |
| RLOGD("nm_network_create() fail"); |
| goto DEMO_CONFIG_NET_IF_ERR_1; |
| } |
| |
| RLOGD("nm_network_interface_add() netid: %d, interface_name: %s", net_id, interface_name); |
| if(nm_network_interface_add(net_id, interface_name) != 0) |
| { |
| RLOGD("nm_network_interface_add() fail"); |
| goto DEMO_CONFIG_NET_IF_ERR_2; |
| } |
| |
| RLOGD("nm_network_route_add() netid: %d, ifname: %s, destion_ipv4: %s, ipv4_gateway: %s", net_id, interface_name, DESTIONNATION_IPV4,ipv4_gateway); |
| if (strlen(ipv4_gateway) != 0 && nm_network_route_add(net_id, interface_name, DESTIONNATION_IPV4,ipv4_gateway, 0, 1) != 0) |
| { |
| RLOGD("nm_network_route_add() gateway_v4 fail"); |
| goto DEMO_CONFIG_NET_IF_ERR_2; |
| } |
| |
| RLOGD("nm_network_route_add() netid: %d, ifname: %s, destion_ipv6: %s, ipv6_gateway: %s", net_id, interface_name, DESTIONNATION_IPV6,ipv6_gateway); |
| if (strlen(ipv6_gateway) != 0 && nm_network_route_add(net_id, interface_name, DESTIONNATION_IPV6,ipv6_gateway, 0, 1) != 0) |
| { |
| RLOGD("nm_network_route_add() gateway_v6 fail"); |
| goto DEMO_CONFIG_NET_IF_ERR_2; |
| } |
| |
| for (int k = 0 ; k < dnsNum; k++) |
| { |
| temp_dns[k] = dns[k]; |
| } |
| |
| if (nm_resolver_dns_set(net_id, interface_name, temp_dns, dnsNum, NM_NETWORK_TYPE_INTERNET) !=0) |
| { |
| RLOGD("nm_resolver_dns_set() fail"); |
| goto DEMO_CONFIG_NET_IF_ERR_3; |
| } |
| |
| if(strstr(apnType, "default") != NULL) { |
| RLOGD("nm_network_default_set(): netid: %d", net_id); |
| if(nm_network_default_set(net_id) != 0) |
| { |
| RLOGD("nm_network_default_set() fail"); |
| return; |
| } |
| } |
| |
| RLOGD("Demo App config network Done"); |
| return; |
| |
| DEMO_CONFIG_NET_IF_ERR_3: |
| if(nm_resolver_dns_clear(net_id) != 0) |
| { |
| RLOGD("nm_resolver_dns_clear fail."); |
| } |
| |
| DEMO_CONFIG_NET_IF_ERR_2: |
| if(nm_network_interface_remove(net_id, interface_name) != 0) |
| { |
| RLOGD("nm_network_interface_remove fail."); |
| } |
| |
| DEMO_CONFIG_NET_IF_ERR_1: |
| if(nm_network_destroy(net_id) != 0) |
| { |
| RLOGD("nm_network_destroy fail."); |
| } |
| destroyCid(apnType); |
| } |
| |
| void releaseInternetNetworkconfig(char* apnType) |
| { |
| if(strcasecmp(cur_apn_type, "ims") == 0 |
| || strcasecmp(cur_apn_type, "xcap") == 0 |
| || strcasecmp(cur_apn_type, "ia") == 0) |
| { |
| RLOGD("the current apn type: %s, don't set router, so just return", cur_apn_type); |
| return; |
| } |
| |
| char* ifname = getInterfaceNameFromLocal(apnType); |
| |
| if((ifname == NULL)||(strcmp("", ifname) == 0)) |
| { |
| RLOGD("interface_name is \"\""); |
| return; |
| } |
| |
| //if mal had set the route, don't set it. |
| unsigned int netid = 0; |
| int value = nm_interface_get_netid(ifname, &netid); |
| RLOGD("query netid. value: %d, netid: %d ", value, netid); |
| if(netid <= 0) return; |
| |
| if(nm_resolver_dns_clear(netid) != 0) |
| { |
| RLOGD("nm_resolver_dns_clear fail."); |
| } |
| |
| if(nm_network_interface_remove(netid, ifname) != 0) |
| { |
| RLOGD("nm_network_interface_remove fail."); |
| } |
| |
| if(nm_network_destroy(netid) != 0) |
| { |
| RLOGD("nm_network_destroy fail."); |
| } |
| } |
| |
| int getApnProfileID(char *apnType) |
| { |
| int profile_id; |
| if (strcasecmp(apnType, "mms") == 0) { |
| profile_id = DATA_PROFILE_MMS; |
| } else if (strcasecmp(apnType, "supl") == 0) { |
| profile_id =DATA_PROFILE_SUPL; |
| } else if (strcasecmp(apnType, "dun") == 0) { |
| profile_id = DATA_PROFILE_TETHERED; |
| } else if (strcasecmp(apnType, "hipri") == 0) { |
| profile_id = DATA_PROFILE_HIPRI; // DEFAULT for now |
| } else if (strcasecmp(apnType, "fota") == 0) { |
| profile_id = DATA_PROFILE_FOTA; |
| }else if (strcasecmp(apnType, "ims") == 0) { |
| profile_id = DATA_PROFILE_IMS; |
| }else if (strcasecmp(apnType, "cbs") == 0) { |
| profile_id = DATA_PROFILE_CBS; |
| } else if (strcasecmp(apnType, "emergency") == 0) { |
| profile_id = DATA_PROFILE_EMERGENCY; |
| } else if (strcasecmp(apnType, "wap") == 0) { |
| profile_id = DATA_PROFILE_WAP; |
| }else if (strcasecmp(apnType, "xcap") == 0) { |
| profile_id = DATA_PROFILE_XCAP; |
| }else if (strcasecmp(apnType, "rcs") == 0) { |
| profile_id = DATA_PROFILE_RCS; |
| }else if (strcasecmp(apnType, "bip") == 0) { |
| profile_id = DATA_PROFILE_BIP; |
| }else if (strcasecmp(apnType, "vsim") == 0) { |
| profile_id = DATA_PROFILE_VSIM; |
| }else { |
| profile_id = DATA_PROFILE_DEFAULT; |
| } |
| |
| RLOGD("getApnProfileID apn type :%s, profile_id: %d",apnType, profile_id); |
| return profile_id; |
| } |
| |
| int setDataAllowed(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| if(argc != 2) |
| { |
| free(pRI); |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| |
| android::Parcel p; |
| size_t pos = p.dataPosition(); |
| p.writeInt32(1); |
| p.writeInt32(atoi(argv[1])); //allowed ? 1:0 |
| p.setDataPosition(pos); |
| pRI->pCI->dispatchFunction(p, pRI); |
| |
| return 0; |
| } |
| |
| int setupDataCall(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| Parcel p; |
| /*jb.qi change for switch card after dial on 20221025 start*/ |
| if((argc == 0) && (pRI == NULL)) |
| { |
| printf("pRI is null, argc is zero !!!\n"); |
| char cmd[256]; |
| getCellularService(); |
| findCellularName(line); |
| sprintf(cmd, "connmanctl connect %s", csname); |
| int ret = system(cmd); |
| memset(line, LEN*sizeof(char), 0); |
| memset(line, 27*sizeof(char), 0); |
| updataDataConnectState(get_default_sim_data(), true); |
| /* no response from telecore, free pRI prevent memory leak */ |
| return ret; |
| } |
| /*jb.qi change for switch card after dial on 20221025 end*/ |
| if(argc > 2) |
| { |
| /*Warren add for t800 ril service 2021/12/25 start*/ |
| char* apnType = argv[2]; |
| int result=0; |
| RLOGD("[setupDataCall] apn_count1:%d\n",apn_count); |
| for(int i = 0;i< LYNQ_APN_CHANNEL_MAX;i++)//代表已经有argv[1]类型的APN 已经被建立， |
| { |
| RLOGD("apnType:%s,argv[2]:%s\n",apn_table[i].apntype,argv[2]); |
| if(strcmp(apn_table[i].apntype,argv[2])==0) |
| { |
| /*此处直接返回response，给client成功的结果码，并返回iface*/ |
| Parcel urc_p; |
| p.writeInt32(0); |
| p.writeInt32(pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32(0); |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| urc_p.writeInt32(1); |
| urc_p.writeInt32(LYNQ_URC_DATA_CALL_STATUS_IND); |
| urc_p.writeInt32(socket_id); |
| urc_p.writeInt32(apn_table[i].apnstatus); |
| writeStringToParcel(urc_p, apn_table[i].apn); |
| writeStringToParcel(urc_p, apn_table[i].apntype); |
| writeStringToParcel(urc_p, apn_table[i].ifaceName); |
| android::LYNQ_RIL_urcBroadcast(urc_p,LYNQ_URC_DATA_CALL_STATUS_IND); |
| RLOGD("apn:%s,apntype:%s",apn_table[i].apn,apn_table[i].apntype); |
| return -1; |
| } |
| } |
| result = setupDataCallargc(argc,argv,socket_id,pRI); |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (0); |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| if (pRI != NULL) |
| { |
| free(pRI); |
| } |
| return result; |
| /*Warren add for t800 ril service 2021/12/25 end*/ |
| } |
| RLOGD("[setupDataCall] apn_count2:%d\n",apn_count); |
| for(int i = 0;i< LYNQ_APN_CHANNEL_MAX;i++) |
| { |
| RLOGD("id:%dapnType:%s,default\n",i,apn_table[i].apntype); |
| if(strcmp(apn_table[i].apntype,"default")==0)//代表已经有default类型的APN 已经被建立， |
| { |
| /*此处直接返回response，给client成功的结果码，并返回iface*/ |
| Parcel urc_p; |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (0); |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| urc_p.writeInt32(1); |
| urc_p.writeInt32(LYNQ_URC_DATA_CALL_STATUS_IND); |
| urc_p.writeInt32(socket_id); |
| urc_p.writeInt32(apn_table[i].apnstatus); |
| writeStringToParcel(urc_p, apn_table[i].apn); |
| writeStringToParcel(urc_p, apn_table[i].apntype); |
| writeStringToParcel(urc_p, apn_table[i].ifaceName); |
| android::LYNQ_RIL_urcBroadcast(urc_p,LYNQ_URC_DATA_CALL_STATUS_IND); |
| RLOGD("apn:%s,apntype:%s",apn_table[i].apn,apn_table[i].apntype); |
| return -1; |
| } |
| } |
| char cmd[256]; |
| getCellularService(); |
| findCellularName(line); |
| sprintf(cmd, "connmanctl connect %s", csname); |
| int ret = system(cmd); |
| memset(line, 0, LEN*sizeof(char)); |
| |
| updataDataConnectState(get_default_sim_data(), true); |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (0); |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| /* no response from telecore, free pRI prevent memory leak */ |
| if (pRI != NULL) { |
| free(pRI); |
| } |
| return ret; |
| } |
| |
| int getIntefaceId(char * apnType) { |
| int all_interface_id[5] = {1,2,3,7,0}; |
| int temp_cid = INVALID_VALUE; |
| if (getcid(apnType) == INVALID_VALUE) { |
| bool is_find = false; |
| for(int i=0; i<5; i++) |
| { |
| temp_cid = all_interface_id[i]; |
| bool is_exsited = false; |
| for (int j=0; j < 8; j++) |
| { |
| if (current_cid[j].cid != INVALID_VALUE && current_cid[j].cid == temp_cid) |
| { |
| is_exsited = true; |
| break; |
| } |
| } |
| if(!is_exsited) |
| { |
| is_find = true; |
| break; |
| } |
| } |
| if(!is_find) |
| { |
| RLOGE("PDN numbers is max, cann't create new PDN"); |
| temp_cid = INVALID_VALUE; |
| } else { |
| // for *default* type. should use interface 0 as interface id. |
| if (strstr(apnType, "default") != NULL && temp_cid != 0) |
| { |
| temp_cid = 0; |
| } |
| } |
| } |
| RLOGD("getInterfaceId apn type: %s, inteface id : %d", apnType, temp_cid); |
| return temp_cid; |
| } |
| |
| int setupDataCallargc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| if(argc != 8) |
| { |
| //free(pRI);//Warren chenge for t800 ril service 2021/12/28 start |
| RLOGD("the parameters numbers isn't right , so return"); |
| return -1; |
| } |
| |
| char radioTechnoloy[2]; |
| char profile[8]={}; |
| char* apnType = argv[2]; |
| if(strcasecmp(apnType, "null") == 0) |
| { |
| //free(pRI); |
| RLOGD("apnType shouldn't is null"); |
| return -1; |
| } |
| if(!isEnableLocalconf()) { |
| //free(pRI); |
| return enableData(true, apnType); |
| } |
| for(int i =0; i < 8; i++) |
| { |
| if(apnType != NULL && strcmp(current_cid[i].apn_type, apnType) == 0) |
| { |
| //free(pRI); |
| RLOGD("PDN existed, only return. type: %s",apnType); |
| return -1; |
| } |
| } |
| //cur_apn_type = apnType; |
| memset(cur_apn_type, 0, sizeof(cur_apn_type)); |
| memcpy(cur_apn_type,apnType,sizeof(cur_apn_type)); |
| RLOGD("cur_apn_Type is %s",cur_apn_type); |
| |
| char* apn = argv[1]; |
| if(strcasecmp(apn, "null") == 0) |
| { |
| //free(pRI); |
| RLOGD("apn shouldn't is null"); |
| return -1; |
| } |
| char* user = checkParameters(argv[3]); |
| char* password = checkParameters(argv[4]); |
| char* protocol; |
| sprintf(radioTechnoloy, "%d",get_reg_data_radio_tech(Radio_capability_switch_util::get_main_capability_phone_id())); |
| |
| sprintf(profile, "%d", getApnProfileID(apnType)); |
| char authtype[2]; |
| if(strcasecmp(argv[5], "null") == 0) |
| { |
| int temp = (strcmp(user, "") == 0) ? SETUP_DATA_AUTH_NONE : SETUP_DATA_AUTH_PAP_CHAP; |
| sprintf(authtype, "%d", temp); |
| } else { |
| strcpy(authtype, argv[5]); |
| } |
| authtype[1] = '\0'; |
| //TBD |
| if(/*getDataRoamingFromRegistration()*/ false) |
| { |
| if(strcasecmp(argv[7], "null") == 0) |
| { |
| protocol = SETUP_DATA_PROTOCOL_IPV4; |
| } else { |
| protocol = argv[7]; |
| } |
| } else { |
| if(strcasecmp(argv[6], "null") == 0) |
| { |
| protocol = SETUP_DATA_PROTOCOL_IPV4; |
| } else { |
| protocol = argv[6]; |
| } |
| } |
| |
| if(getIntefaceId(apnType) == INVALID_VALUE) |
| { |
| //free(pRI); |
| RLOGE("the PDN exsited for %s type or PDN number max", apnType); |
| return -1; |
| } |
| |
| char interface_id[2] = {0}; |
| sprintf(interface_id, "%d", (getIntefaceId(apnType) + 1)); |
| interface_id[1] = '\0'; |
| android::Parcel p; |
| size_t pos = p.dataPosition(); |
| p.writeInt32(8); |
| writeStringToParcel(p,radioTechnoloy); |
| writeStringToParcel(p,profile); |
| writeStringToParcel(p,apn); |
| writeStringToParcel(p,user); |
| writeStringToParcel(p,password); |
| writeStringToParcel(p,authtype); |
| writeStringToParcel(p,protocol); |
| writeStringToParcel(p, interface_id); |
| p.setDataPosition(pos); |
| updateApntype(apnType); |
| RLOGD("setupDataCallargc: \nradioTechnoloy: %s\nprofileId: %s\napn: %s\n \ |
| username: %s\npassword: %s\nauthType: %s\nprotocol %s\napnType: %s\ninterface_id: %s",radioTechnoloy,profile,apn, |
| user,password,authtype,protocol,apnType, interface_id); |
| pRI->pCI->dispatchFunction(p, pRI); |
| return 0; |
| } |
| |
| int deactivateDataCallarc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| if(argc != 2) |
| { |
| //free(pRI); |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| |
| char* apnType = argv[1]; |
| if(!isEnableLocalconf()) { |
| //free(pRI); |
| return enableData(false, apnType); |
| } |
| char cid[8]; |
| char reason[8]; |
| int temp_cid = getcid(apnType); |
| if(temp_cid == INVALID_VALUE) |
| { |
| //free(pRI); |
| RLOGD("cid is invalid"); |
| return -1; |
| } |
| sprintf(cid, "%d", temp_cid); |
| |
| sprintf(reason,"%d",DEACTIVATE_REASON_NONE); |
| |
| android::Parcel p; |
| size_t pos = p.dataPosition(); |
| p.writeInt32(2); |
| writeStringToParcel(p,cid); |
| writeStringToParcel(p,reason); |
| p.setDataPosition(pos); |
| pRI->pCI->dispatchFunction(p, pRI); |
| releaseInternetNetworkconfig(apnType); |
| destroyCid(apnType); |
| RLOGD("deactivateDataCall() done"); |
| return 0; |
| } |
| |
| int deactivateDataCall(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| bool hasDeactivate = TRUE; |
| Parcel p; |
| /*jb.qi change for swtich card after dial on 20221025 start*/ |
| if((pRI == NULL) && (argc == 0)) |
| { |
| for(int i = 0;i< LYNQ_APN_CHANNEL_MAX;i++) |
| { |
| memset(apn_table[i].apntype,0,sizeof(apn_table[i].apntype)); |
| memset(apn_table[i].ifaceName,0,sizeof(apn_table[i].ifaceName)); |
| memset(apn_table[i].apn,0,sizeof(apn_table[i].apn)); |
| apn_table[i].apnstatus = 0; |
| apn_table[i].netId = 0; |
| apn_table[i].used = 0; |
| } |
| apn_count = 0; |
| printf("pRI is null, argc is zero !!!\n"); |
| char cmd[256]; |
| getCellularService(); |
| findCellularName(line); |
| sprintf(cmd, "connmanctl disconnect %s", csname); |
| int ret = system(cmd); |
| memset(line, LEN*sizeof(char), 0); |
| memset(line, 27*sizeof(char), 0); |
| updataDataConnectState(get_default_sim_data(), false); |
| return ret; |
| } |
| /*jb.qi change for swtich card after dial on 20221025 end*/ |
| if(argc == 2) |
| { |
| char* apnType = argv[1]; |
| int re=0; |
| RLOGD("[deactivateDataCall] apn_count1:%d\n",apn_count); |
| if(apn_count>0) |
| { |
| for(int i = 0;i< LYNQ_APN_CHANNEL_MAX;i++) |
| { |
| RLOGD("[deactivateDataCall] apnType:%s,argv[1]:%s\n",apn_table[i].apntype,argv[1]); |
| if(strcmp(apn_table[i].apntype,argv[1])==0) |
| { |
| apn_table[i].apnstatus=0; |
| RLOGD("need remove apn:%s,apntype:%s",apn_table[i].apn,apn_table[i].apntype); |
| hasDeactivate = FALSE; |
| break; |
| } |
| } |
| if(hasDeactivate) |
| { |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (2);//RIL_E_GENERIC_FAILURE |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| return -1; |
| } |
| } |
| else |
| { |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (2);//RIL_E_GENERIC_FAILURE |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| return -1; |
| } |
| re = deactivateDataCallarc(argc,argv,socket_id,pRI); |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (0);//RIL_E_GENERIC_FAILURE |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| if (pRI != NULL) |
| { |
| free(pRI); |
| } |
| return re; |
| } |
| RLOGD("[deactivateDataCall] apn_count2:%d\n",apn_count); |
| if(apn_count>0) |
| { |
| for(int i = 0;i< LYNQ_APN_CHANNEL_MAX;i++) |
| { |
| RLOGD("id:%dapnType:%s,default\n",i,apn_table[i].apntype); |
| if(strcmp(apn_table[i].apntype,"default")==0) |
| { |
| apn_table[i].apnstatus=0; |
| RLOGD("remove apn:%s,apntype:%s",apn_table[i].apn,apn_table[i].apntype); |
| hasDeactivate = FALSE; |
| break; |
| } |
| } |
| if(hasDeactivate) |
| { |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (2);//RIL_E_GENERIC_FAILURE |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| return -1; |
| } |
| } |
| else |
| { |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (2);//RIL_E_GENERIC_FAILURE |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| return -1; |
| } |
| char cmd[256]; |
| getCellularService(); |
| findCellularName(line); |
| sprintf(cmd, "connmanctl disconnect %s", csname); |
| int ret = system(cmd); |
| memset(line, 0, LEN*sizeof(char)); |
| memset(csname, 0, 27*sizeof(char)); |
| updataDataConnectState(get_default_sim_data(), false); |
| p.writeInt32 (0); |
| p.writeInt32 (pRI->pCI->requestNumber); |
| p.writeInt32(socket_id); |
| p.writeInt32 (0);//RIL_E_GENERIC_FAILURE |
| android::LYNQ_RIL_respSocket(p, (void *)pRI); |
| /* no response from telecore, free pRI prevent memory leak */ |
| if (pRI != NULL) { |
| free(pRI); |
| } |
| return ret; |
| } |
| |
| #if 0 |
| int apnSetting(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| //apn show add delete update |
| free(pRI); |
| if(argc < 2){ |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| int ret = APN_ERR; |
| apn_list_t* g_apnlist = NULL; |
| if(strncmp(argv[1], "show", 4) == 0){ |
| apn_record_t* record = apn_malloc_record(); |
| apn_build_cRecord(record, APN_PROP_MCC, mcc); |
| apn_build_iRecord(record, APN_PROP_iMNC, mnc); |
| if(g_apnlist){ |
| apn_free_list(g_apnlist); |
| g_apnlist = NULL; |
| } |
| apn_query_db(record, &g_apnlist); |
| RLOGD("apn list count %d\n",g_apnlist->count); |
| apn_record_t* instance = g_apnlist->top; |
| char apn_list[2048] = {0}; |
| int len = 0; |
| while(instance != NULL) { |
| for (int i = 0; i < instance->count; i++) { |
| if (instance->values[i] != NULL) { |
| if (i == (instance->count - 1)) { |
| sprintf(apn_list+len,"%s/%s\n ",apn_get_prop_name(instance->columnIdx[i]),instance->values[i]); |
| }else{ |
| sprintf(apn_list+len,"%s/%s; ",apn_get_prop_name(instance->columnIdx[i]),instance->values[i]); |
| } |
| len = strlen(apn_list); |
| } |
| } |
| instance = (apn_record_t* )instance->next; |
| } |
| apn_free_record(record); |
| android::emResultNotify(apn_list); |
| RLOGD("Apn list: /%s",apn_list); |
| } |
| if(strncmp(argv[1], "add", 3) == 0){ |
| int i = 0; |
| int apnidx = APN_ERR; |
| apn_record_t* record = apn_malloc_record(); |
| RLOGD("add record count = %d",(argc-2)); |
| for (i = 0; i < (argc - 2 ) ; i+=2){ |
| apnidx = apn_get_idx_by_name(argv[i+2]); |
| if(apnidx != APN_ERR){ |
| apn_build_iRecord(record,apnidx,argv[i+3]); |
| }else{ |
| RLOGD("record name [%s] is not invalid",argv[i+2]); |
| } |
| } |
| ret = apn_insert_record_db(record); |
| apn_free_record(record); |
| if(ret == -1){ |
| android::emResultNotify("add apn fail.\n"); |
| }else{ |
| android::emResultNotify("add apn success.\n"); |
| } |
| } |
| if(strncmp(argv[1], "delete", 6) == 0){ |
| if(argc < 3){ |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| int apnid = atoi(argv[2]); |
| RLOGD("delete id %d",apnid); |
| ret = apn_delete_record_db(apnid); |
| if(ret == -1){ |
| android::emResultNotify("delete apn fail.\n"); |
| }else{ |
| android::emResultNotify("delete apn success.\n"); |
| } |
| } |
| if(strncmp(argv[1], "update", 6) == 0){ |
| if(argc < 3){ |
| RLOGD("the peremeters numbers isn't right , so return"); |
| } |
| int apnid = atoi(argv[2]); |
| char *updateid_str = NULL; |
| //get the select record and update it : _id |
| apn_record_t* instance = g_apnlist->top; |
| while(instance != NULL) { |
| char *value = NULL; |
| value = (char *)apn_get_prop_from_record(instance,APN_PROP_iId); |
| if(value != NULL){ |
| if(apnid == atoi(value)){ |
| updateid_str = value; |
| break; |
| } |
| }else{ |
| RLOGD("warning: record has no id"); |
| } |
| instance = (apn_record_t* )instance->next; |
| } |
| if(updateid_str == NULL){ |
| RLOGD("the apn id(%d) is not exist in apn database, please check" ,apnid); |
| android::emResultNotify("update fail, the apn id to update is not exist in apn database"); |
| return -1; |
| } |
| apn_record_t* record = apn_malloc_record(); |
| int columnidx = -1; |
| apn_build_iRecord(record,APN_PROP_iId,updateid_str); |
| for(int i = 0; i < (argc - 3) ; i+=2){ |
| columnidx = apn_get_idx_by_name(argv[i+3]); |
| if(columnidx != APN_ERR){ |
| apn_build_iRecord(record,columnidx,argv[i+4]); |
| }else{ |
| RLOGD("record name [%s] is not invalid",argv[i+2]); |
| } |
| } |
| ret = apn_update_record_db(record); |
| apn_free_record(record); |
| if(ret == -1){ |
| android::emResultNotify("update apn fail.\n"); |
| }else{ |
| android::emResultNotify("update apn success.\n"); |
| } |
| } |
| |
| } |
| #endif |
| |
| int setInitialAttachApnargc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| if(argc != 6) |
| { |
| free(pRI); |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| |
| android::Parcel p; |
| size_t pos = p.dataPosition(); |
| char* apn = checkParameters(argv[1]); |
| char* protocol; |
| if(strcasecmp(argv[2], "null") == 0) |
| { |
| protocol = SETUP_DATA_PROTOCOL_IPV4; |
| } else { |
| protocol = argv[2]; |
| } |
| int authType = -1; |
| if(strcasecmp("null", argv[3]) != 0) |
| { |
| authType = atoi(argv[3]); |
| } |
| char* username = checkParameters(argv[4]); |
| char* password = checkParameters(argv[5]); |
| writeStringToParcel(p,apn); //apn |
| writeStringToParcel(p,protocol); //protocol |
| p.writeInt32(authType); //authType |
| writeStringToParcel(p,username);//username |
| writeStringToParcel(p,password);//password |
| p.setDataPosition(pos); |
| |
| pRI->pCI->dispatchFunction(p, pRI); |
| return 0; |
| } |
| |
| int getDataCallList(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| if(argc != 1) |
| { |
| free(pRI); |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| |
| android::Parcel p; |
| pRI->pCI->dispatchFunction(p, pRI); |
| return 0; |
| } |
| |
| int getLastDataCallFailCause(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| if(argc != 1) |
| { |
| free(pRI); |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| |
| android::Parcel p; |
| pRI->pCI->dispatchFunction(p, pRI); |
| return 0; |
| } |
| |
| void updateRILDataCallResponsev6(int num ,RIL_Data_Call_Response_v6* p_cur) |
| { |
| if(!isEnableLocalconf()) return; |
| data_call_num = num; |
| if(strcasecmp(cur_apn_type, "ims") == 0 |
| || strcasecmp(cur_apn_type, "xcap") == 0 |
| || strcasecmp(cur_apn_type, "ia") == 0) |
| { |
| RLOGD("the current apn type: %s, don't set router, so just return", cur_apn_type); |
| return; |
| } |
| |
| if(data_call_response != NULL) |
| { |
| free(data_call_response); |
| } |
| |
| data_call_response = (RIL_Data_Call_Response_v6 *)calloc(1, num*sizeof(RIL_Data_Call_Response_v6)); |
| if(p_cur) |
| { |
| memcpy(data_call_response,p_cur, num*sizeof(RIL_Data_Call_Response_v6)); |
| int j; |
| RLOGD("num: %d", num); |
| for (j = num-1; j >=0 ; j--) |
| { |
| int temp_cid = data_call_response[j].cid; |
| int k; |
| for(k = 0; k < 8 ; k++) |
| { |
| if(current_cid[k].cid == temp_cid) |
| { |
| break; |
| } |
| } |
| |
| if (k >= 8) |
| { |
| break; |
| } |
| } |
| |
| RLOGD("updateRILDataCallResponsev6()... j: %d", j); |
| if(j < 0) |
| { |
| RLOGD("don't update data map_cid"); |
| return; |
| } |
| |
| int new_cid = data_call_response[j].cid; |
| RLOGD("updateRILDataCallResponsev6()... j: %d, new_cid: %d",j, new_cid); |
| |
| for (int i = 0; i < 8 ; i++) |
| { |
| if((strcmp(current_cid[i].apn_type, "") != 0) && current_cid[i].cid == INVALID_VALUE) |
| { |
| RLOGD("update current_cid[%d]: %d", i , new_cid); |
| current_cid[i].cid = new_cid; |
| break; |
| } |
| } |
| configInterNetNetwork(cur_apn_type); |
| } else { |
| RLOGD("updateRILDataCallResponsev6 fail"); |
| } |
| } |
| |
| void handleUnsolDataCalllistChange(int num ,RIL_Data_Call_Response_v6* p_cur){ |
| for(int i =0; i < 8; i++) |
| { |
| int temp_cid = current_cid[i].cid; |
| if(temp_cid != -1){ |
| int j; |
| bool isContant = false; |
| for(j=0; j < num; j++){ |
| if(p_cur[i].cid == temp_cid){ |
| isContant = true; |
| break; |
| } |
| } |
| RLOGD("isContant = %d, curent_cid[%d].cid = %d", isContant, i, temp_cid); |
| if(!isContant){ |
| releaseInternetNetworkconfig(current_cid[i].apn_type); |
| destroyCid(current_cid[i].apn_type); |
| } |
| } |
| } |
| } |
| |
| static int getApntypeBitmask(const char *type) |
| { |
| struct apntype_2_bitmask apntypebitmask[] = { |
| {TEXT_APN_TYPE_DEFAULT,DATAASST_PDN_APN_TYPE_DEFAULT}, |
| {TEXT_APN_TYPE_IMS,DATAASST_PDN_APN_TYPE_IMS}, |
| {TEXT_APN_TYPE_MMS,DATAASST_PDN_APN_TYPE_MMS}, |
| {TEXT_APN_TYPE_SUPL,DATAASST_PDN_APN_TYPE_SUPL}, |
| {TEXT_APN_TYPE_DUN,DATAASST_PDN_APN_TYPE_DUN}, |
| {TEXT_APN_TYPE_HIPRI,DATAASST_PDN_APN_TYPE_HIPRI}, |
| {TEXT_APN_TYPE_FOTA,DATAASST_PDN_APN_TYPE_FOTA}, |
| {TEXT_APN_TYPE_CBS,DATAASST_PDN_APN_TYPE_CBS}, |
| {TEXT_APN_TYPE_EMERGENCY,DATAASST_PDN_APN_TYPE_EMERGENCY}, |
| {TEXTAPN_TYPE_IA,DATAASST_PDN_APN_TYPE_IA}, |
| #if !(defined(TARGET_PLATFORM_MT2731)) |
| {TEXT_APN_TYPE_DM,DATAASST_PDN_APN_TYPE_DM}, |
| #endif |
| {TEXT_APN_TYPE_WAP,DATAASST_PDN_APN_TYPE_WAP}, |
| #if !(defined(TARGET_PLATFORM_MT2731)) |
| {TEXT_APN_TYPE_NET,DATAASST_PDN_APN_TYPE_NET}, |
| {TEXT_APN_TYPE_CMMAIL,DATAASST_PDN_APN_TYPE_CMMAIL}, |
| {TEXT_APN_TYPE_TETHERING,DATAASST_PDN_APN_TYPE_TETHERING}, |
| {TEXT_APN_TYPE_RCSE,DATAASST_PDN_APN_TYPE_RCSE}, |
| #endif |
| {TEXT_APN_TYPE_XCAP,DATAASST_PDN_APN_TYPE_XCAP}, |
| {TEXT_APN_TYPE_RCS,DATAASST_PDN_APN_TYPE_RCS}, |
| {IOT_TEXT_APN_TYPE_DEFAULT ,IOT_DATAASST_PDN_APN_TYPE_DEFAULT}, //for IOT |
| {IOT_TEXT_APN_TYPE_NET_0 ,IOT_DATAASST_PDN_APN_TYPE_NET_0},//for IOT |
| {IOT_TEXT_APN_TYPE_NET_1 ,IOT_DATAASST_PDN_APN_TYPE_NET_1},//for IOT |
| {IOT_TEXT_APN_TYPE_NET_2 ,IOT_DATAASST_PDN_APN_TYPE_NET_2},//for IOT |
| {IOT_TEXT_APN_TYPE_NET_3 ,IOT_DATAASST_PDN_APN_TYPE_NET_3},//for IOT |
| {IOT_TEXT_APN_TYPE_NET_4 ,IOT_DATAASST_PDN_APN_TYPE_NET_4},//for IOT |
| {IOT_TEXT_APN_TYPE_NET_5 ,IOT_DATAASST_PDN_APN_TYPE_NET_5},//for IOT |
| {IOT_TEXT_APN_TYPE_NET_6 ,IOT_DATAASST_PDN_APN_TYPE_NET_6},//for IOT |
| }; |
| int len = sizeof(apntypebitmask)/sizeof(apntype_2_bitmask); |
| for(int i = 0; i < len ; i++){ |
| if(strcasecmp(type,apntypebitmask[i].type) == 0) |
| return apntypebitmask[i].typebitmask; |
| } |
| return DATAASST_PDN_APN_TYPE_UNKNOWN; |
| } |
| |
| static int check_is_number(char* str) { |
| if(utils::is_number(str)){ |
| return atoi(str); |
| } else { |
| return INVALID; |
| } |
| } |
| |
| //RIL_REQUEST_SET_DATA_PROFILE |
| int setDataProfile(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) |
| { |
| int count = check_is_number(argv[1]); |
| if(count == INVALID) { |
| free(pRI); |
| printf("the peremeters count(%s) isn't invalid , so return\n", argv[1]); |
| RLOGD("the peremeters count(%s) isn't invalid , so return", argv[1]); |
| return -1; |
| } |
| |
| if((argc-2) != 11*count) { |
| free(pRI); |
| printf("the peremeters numbers isn't right , so return\n"); |
| RLOGD("the peremeters numbers isn't right , so return"); |
| return -1; |
| } |
| android::Parcel p; |
| size_t pos = p.dataPosition(); |
| p.writeInt32(count); //profileId |
| for (int i=2; i < argc; i++) { |
| int profileId = 0; |
| std::vector<std::string> v; |
| utils::tokenize(std::string(argv[i]),',',v); |
| int index = 0; |
| for(auto s: v) { |
| RLOGD("%d:%s",index, s.c_str()); |
| profileId |= getApntypeBitmask(s.c_str()); |
| index++; |
| } |
| p.writeInt32(profileId); //profileId |
| char* apn = checkParameters(argv[i+1]); |
| writeStringToParcel(p,apn); //apn |
| char* protocol; |
| if(strcasecmp(argv[i+2], "null") == 0) |
| { |
| protocol = SETUP_DATA_PROTOCOL_IPV4V6; |
| } else { |
| protocol = argv[i+2]; |
| } |
| writeStringToParcel(p,protocol); //protocol |
| int authType = -1; |
| if((strcasecmp("null", argv[i+3]) != 0) && (strcasecmp("-1", argv[i+3]) != 0)) |
| { |
| authType = check_is_number(argv[i+3]); |
| if (authType == INVALID) { |
| free(pRI); |
| printf("the peremeters authType(%s) isn't invalid , so return\n", argv[i+3]); |
| return -1; |
| } |
| } |
| p.writeInt32(authType); //authType |
| char* username = checkParameters(argv[i+4]); |
| writeStringToParcel(p,username);//username |
| char* password = checkParameters(argv[i+5]); |
| writeStringToParcel(p,password);//password |
| int type = check_is_number(argv[i+6]); |
| if(type == INVALID) { |
| free(pRI); |
| printf("the peremeters type(%s) isn't invalid , so return\n", argv[i+6]); |
| RLOGD("the peremeters type(%s) isn't invalid , so return", argv[i+6]); |
| return -1; |
| } |
| p.writeInt32(type); //type |
| int maxConnsTime = check_is_number(argv[i+7]); |
| if(maxConnsTime == INVALID) { |
| free(pRI); |
| printf("the peremeters maxConnsTime(%s) isn't invalid , so return\n", argv[i+7]); |
| RLOGD("the peremeters maxConnsTime(%s) isn't invalid , so return", argv[i+7]); |
| return -1; |
| } |
| p.writeInt32(maxConnsTime); //maxConnsTime |
| int maxConns = check_is_number(argv[i+8]); |
| if(maxConns == INVALID) { |
| free(pRI); |
| printf("the peremeters maxConns(%s) isn't invalid , so return\n", argv[i+8]); |
| RLOGD("the peremeters maxConns(%s) isn't invalid , so return", argv[i+8]); |
| return -1; |
| } |
| p.writeInt32(maxConns); //maxConns |
| int waitTime = check_is_number(argv[i+9]); |
| if(waitTime == INVALID) { |
| free(pRI); |
| printf("the peremeters waitTime(%s) isn't invalid , so return\n", argv[i+9]); |
| RLOGD("the peremeters waitTime(%s) isn't invalid , so return", argv[i+9]); |
| return -1; |
| } |
| p.writeInt32(waitTime); //waitTime |
| int enabled = check_is_number(argv[i+10]); |
| if(enabled == INVALID) { |
| free(pRI); |
| printf("the peremeters enabled(%s) isn't invalid , so return\n", argv[i+10]); |
| RLOGD("the peremeters enabled(%s) isn't invalid , so return", argv[i+10]); |
| return -1; |
| } |
| p.writeInt32(enabled); //enabled |
| RLOGD("index=%d",i); |
| i = i+10; |
| } |
| p.setDataPosition(pos); |
| |
| pRI->pCI->dispatchFunction(p, pRI); |
| |
| return 0; |
| } |
| |
| /** |
| * RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD |
| * |
| * Set data features. |
| * The domestic roaming/international roaming should not set with roaming in the same project. |
| * The default data SIM should not set by this RIL request directly |
| * |
| * "data" is const int * |
| * ((const int*)data)[0] specify if data enable or not,-2 means skip this setting. |
| * ((const int*)data)[1] specify the roaming setting, -2 means skip this setting. |
| * ((const int*)data)[2] specify the default data sim, -2 means skip this setting. |
| * ((const int*)data)[3] specify the domestic roaming setting, -2 means skip this setting. |
| * ((const int*)data)[4] specify the international roaming setting, -2 means skip this setting. |
| * |
| * "response" is the NULL. |
| * |
| * Valid errors: |
| * SUCCESS |
| * GENERIC_FAILURE |
| */ |
| int syncDataSettingsToMd(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) { |
| if (argc != 6){ |
| RLOGD("syncDataSettingsToMd parameters number isn't enough"); |
| free(pRI); |
| return -1; |
| } |
| int32_t data_enable = std::stoi(argv[1]); |
| int32_t roaming = std::stoi(argv[2]); |
| int32_t default_data = std::stoi(argv[3]); |
| int32_t domes_roa = std::stoi(argv[4]); |
| int32_t inter_roa = std::stoi(argv[5]); |
| RLOGD("syncDataSettingsToMd data_enable=%d, roaming=%d, default_data=%d, domes_roa=%d inter_roa=%d", |
| data_enable, roaming, default_data, domes_roa, inter_roa); |
| android::Parcel p; |
| size_t pos = p.dataPosition(); |
| p.writeInt32(5); |
| p.writeInt32(data_enable); |
| p.writeInt32(roaming); |
| p.writeInt32(default_data); |
| p.writeInt32(domes_roa); |
| p.writeInt32(inter_roa); |
| |
| p.setDataPosition(pos); |
| pRI->pCI->dispatchFunction(p, pRI); |
| return 0; |
| } |
| |
| int syncDataSettings(RIL_SOCKET_ID socket_id) { |
| char* slotID = "1"; |
| if(socket_id == 0) { |
| slotID = "0"; |
| } |
| char* tmp[6] = {"RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD", "-2", "-2", slotID, "-2", "-2"}; |
| RequestInfo *pRI = creatRILInfoAndInit(RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD, OTHER, socket_id); |
| if(pRI == NULL) return -1; |
| syncDataSettingsToMd(6,tmp,socket_id,pRI); |
| return 0; |
| } |
| |
| int modifyApnRecord(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) { |
| free(pRI); |
| if (argc < 3){ |
| RLOGD("%s parameters number isn't enough", __FUNCTION__); |
| return -1; |
| } |
| RLOGD("%s,cmd:%s,record:%s", __FUNCTION__,argv[1],argv[2]); |
| int cmd = std::stoi(argv[1]); |
| char* record = argv[2]; |
| modifyApnDB(cmd, record); |
| return 0; |
| } |
| |
| int resetApnRecord(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) { |
| RLOGD("%s", __FUNCTION__); |
| free(pRI); |
| resetApnDB(); |
| return 0; |
| } |