* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
- * limitations under the License.
+ * limitations under the License.
*/
+#include <glib.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
-#include <glib.h>
+#include <arpa/inet.h>
#include <vconf/vconf.h>
+
#include "net_connection_private.h"
#define HTTP_PROXY "http_proxy"
+#define MAX_PREFIX_LENGTH 6
static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
{
case NET_DEVICE_WIFI:
return &profile_info->ProfileInfo.Wlan.net_info;
case NET_DEVICE_ETHERNET:
- return &profile_info->ProfileInfo.Ethernet.net_info;
+ return &profile_info->ProfileInfo.Ethernet.net_info; //LCOV_EXCL_LINE
case NET_DEVICE_BLUETOOTH:
return &profile_info->ProfileInfo.Bluetooth.net_info;
case NET_DEVICE_DEFAULT:
}
}
-static char* __profile_convert_ip_to_string(net_addr_t *ip_addr)
+static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
{
- unsigned char *ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
+ unsigned char *ipaddr = NULL;
+ char *ipstr = NULL;
- char *ipstr = g_try_malloc0(16);
- if (ipstr == NULL)
- return NULL;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+ ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
+ ipstr = g_try_malloc0(INET_ADDRSTRLEN);
+ if (ipstr == NULL)
+ return NULL;
- snprintf(ipstr, 16, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
+ inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
+ } else {
+ //LCOV_EXCL_START
+ ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
+ ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
+ if (ipstr == NULL)
+ return NULL;
+
+ inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
+ //LCOV_EXCL_STOP
+ }
return ipstr;
}
static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
{
+ int default_subscriber_id = 0;
+ connection_profile_h profile = NULL;
+
profile_info->profile_type = NET_DEVICE_CELLULAR;
profile_info->ProfileState = NET_STATE_TYPE_IDLE;
+ profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
+ profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
+
+ if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
+ &default_subscriber_id) != 0)
+ CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
+ "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
+
+ profile = (connection_profile_h)profile_info;
+ _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
}
static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
}
-static const char* __profile_get_ethernet_proxy(void)
+//LCOV_EXCL_START
+static char* __profile_get_ethernet_proxy(void)
{
char *proxy;
- proxy = getenv(HTTP_PROXY);
+ proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
- if(proxy == NULL) {
+ if (proxy == NULL) {
CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
return NULL;
}
- CONNECTION_LOG(CONNECTION_INFO, "Get system proxy: %s", proxy);
return proxy;
}
+//LCOV_EXCL_STOP
+
+static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
+{
+ if (netmask == NULL)
+ return 0;
+
+ in_addr_t mask = inet_network(netmask);
+ in_addr_t host = ~mask;
+ unsigned char prefix_len = 0;
+
+ /* a valid netmask must be 2^n - 1 */
+ if ((host & (host + 1)) != 0)
+ return -1;
+
+ for (; mask; mask <<= 1)
+ ++prefix_len;
+
+ return prefix_len;
+}
+static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
+{
+ return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
+}
+
+//LCOV_EXCL_START
connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
{
switch (svc_type) {
return libnet_state;
}
+//LCOV_EXCL_STOP
+
+/* Connection profile ********************************************************/
+EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
+ if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+ else if (type == CONNECTION_PROFILE_TYPE_WIFI)
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
-/* Connection profile module *********************************************************************/
+ if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
+ type != CONNECTION_PROFILE_TYPE_WIFI) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
-int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
-{
- if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
- type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ if (profile == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
+ int rv = _connection_libnet_check_profile_privilege();
+ if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
+ return rv;
+ else if (rv != CONNECTION_ERROR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
+ return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ }
+
net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
if (profile_info == NULL)
return CONNECTION_ERROR_OUT_OF_MEMORY;
- switch (type) {
- case CONNECTION_PROFILE_TYPE_CELLULAR:
+ if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
if (keyword == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ g_free(profile_info);
return CONNECTION_ERROR_INVALID_PARAMETER;
}
__profile_init_cellular_profile(profile_info, keyword);
- break;
- case CONNECTION_PROFILE_TYPE_WIFI:
+ } else if (type == CONNECTION_PROFILE_TYPE_WIFI) {
__profile_init_wifi_profile(profile_info);
- break;
- default:
- break;
}
*profile = (connection_profile_h)profile_info;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_destroy(connection_profile_h profile)
+EXPORT_API int connection_profile_destroy(connection_profile_h profile)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile))) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
+EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_id(connection_profile_h profile, char** profile_id)
+EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_name(connection_profile_h profile, char** profile_name)
+EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
*profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
break;
case NET_DEVICE_ETHERNET:
- *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
- break;
+ *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
+ break; //LCOV_EXCL_LINE
case NET_DEVICE_BLUETOOTH: {
char *bt_name = strrchr(profile_info->ProfileName, '/');
if (bt_name == NULL)
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
+EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
*type = CONNECTION_PROFILE_TYPE_WIFI;
break;
case NET_DEVICE_ETHERNET:
- *type = CONNECTION_PROFILE_TYPE_ETHERNET;
- break;
+ *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
+ break; //LCOV_EXCL_LINE
case NET_DEVICE_BLUETOOTH:
*type = CONNECTION_PROFILE_TYPE_BT;
break;
default:
- CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
return CONNECTION_ERROR_OPERATION_FAILED;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
+EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_refresh(connection_profile_h profile)
+EXPORT_API int connection_profile_refresh(connection_profile_h profile)
{
+ int rv;
+
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile))) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t profile_info_local;
net_profile_info_t *profile_info = profile;
- if (net_get_profile_info(profile_info->ProfileName, &profile_info_local) != NET_ERR_NONE) {
- CONNECTION_LOG(CONNECTION_ERROR, "Error!!! net_get_profile_info() failed\n");
- return CONNECTION_ERROR_OPERATION_FAILED;
+ rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+ return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+ } else if (rv != NET_ERR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
+ return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
}
memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
+EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
*state = _profile_convert_to_cp_state(profile_info->ProfileState);
- if (*state < 0)
- return CONNECTION_ERROR_OPERATION_FAILED;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_ip_config_type(connection_profile_h profile,
- connection_address_family_e address_family, connection_ip_config_type_e* type)
+EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
+ connection_address_family_e address_family, connection_ip_config_type_e *type)
{
+ net_ip_config_type_t profile_type;
+
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
net_profile_info_t *profile_info = profile;
net_dev_info_t *net_info = __profile_get_net_info(profile_info);
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- switch (net_info->IpConfigType) {
- case NET_IP_CONFIG_TYPE_STATIC:
- *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
- break;
- case NET_IP_CONFIG_TYPE_DYNAMIC:
- *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
- break;
- case NET_IP_CONFIG_TYPE_AUTO_IP:
- *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
- break;
- case NET_IP_CONFIG_TYPE_FIXED:
- *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
- break;
- case NET_IP_CONFIG_TYPE_OFF:
- *type = CONNECTION_IP_CONFIG_TYPE_NONE;
- break;
- default:
- return CONNECTION_ERROR_OPERATION_FAILED;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
+ profile_type = net_info->IpConfigType;
+ else
+ profile_type = net_info->IpConfigType6;
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+ switch (profile_type) {
+ //LCOV_EXCL_START
+ case NET_IP_CONFIG_TYPE_STATIC:
+ *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
+ break;
+
+ case NET_IP_CONFIG_TYPE_DYNAMIC:
+ *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
+ break;
+
+ case NET_IP_CONFIG_TYPE_AUTO_IP:
+ *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
+ break;
+
+ case NET_IP_CONFIG_TYPE_FIXED:
+ *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
+ break;
+
+ case NET_IP_CONFIG_TYPE_OFF:
+ *type = CONNECTION_IP_CONFIG_TYPE_NONE;
+ break;
+ default:
+ return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
+ }
+ } else {
+ //LCOV_EXCL_START
+ switch (profile_type) {
+ case NET_IP_CONFIG_TYPE_STATIC:
+ *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
+ break;
+
+ case NET_IP_CONFIG_TYPE_AUTO_IP:
+ *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
+ break;
+
+ case NET_IP_CONFIG_TYPE_OFF:
+ *type = CONNECTION_IP_CONFIG_TYPE_NONE;
+ break;
+
+ default:
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ }
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_ip_address(connection_profile_h profile,
+EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
connection_address_family_e address_family, char** ip_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
ip_address == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+ *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
+ address_family);
+ } else {
+ if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address");
+ *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
+ address_family);
+ }
+ }
- *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr);
if (*ip_address == NULL)
return CONNECTION_ERROR_OUT_OF_MEMORY;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_subnet_mask(connection_profile_h profile,
+EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
connection_address_family_e address_family, char** subnet_mask)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
subnet_mask == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ CONNECTION_LOG(CONNECTION_ERROR,
+ "Please uses connection_profile_get_prefix_length()");
+ return CONNECTION_ERROR_NOT_SUPPORTED;
+ }
+
net_profile_info_t *profile_info = profile;
net_dev_info_t *net_info = __profile_get_net_info(profile_info);
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
+ *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
+ address_family);
- *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask);
if (*subnet_mask == NULL)
return CONNECTION_ERROR_OUT_OF_MEMORY;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_gateway_address(connection_profile_h profile,
+EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
connection_address_family_e address_family, char** gateway_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
gateway_address == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_OPERATION_FAILED;
if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
+ *gateway_address = __profile_convert_ip_to_string(
+ &net_info->GatewayAddr6, address_family);
+ else
+ *gateway_address = __profile_convert_ip_to_string(
+ &net_info->GatewayAddr, address_family);
- *gateway_address = __profile_convert_ip_to_string(&net_info->GatewayAddr);
if (*gateway_address == NULL)
return CONNECTION_ERROR_OUT_OF_MEMORY;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_dns_address(connection_profile_h profile, int order,
+EXPORT_API int connection_profile_get_dhcp_server_address(
+ connection_profile_h profile,
+ connection_address_family_e address_family, char** dhcp_server)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
+ return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
+ }
+
+ if (!(_connection_libnet_check_profile_validity(profile)) ||
+ (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
+ dhcp_server == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+ net_dev_info_t *net_info = __profile_get_net_info(profile_info);
+ if (net_info == NULL)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
+ net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
+
+ *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
+ address_family);
+
+ if (*dhcp_server == NULL)
+ return CONNECTION_ERROR_OUT_OF_MEMORY;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_get_dhcp_lease_duration(
+ connection_profile_h profile,
+ connection_address_family_e address_family, int* dhcp_lease_duration)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) ||
+ (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
+ address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
+ dhcp_lease_duration == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
+ return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
+ }
+
+ net_profile_info_t *profile_info = profile;
+ net_dev_info_t *net_info = __profile_get_net_info(profile_info);
+ if (net_info == NULL)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
+ net_info->DHCPLeaseDuration);
+
+ *dhcp_lease_duration = net_info->DHCPLeaseDuration;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
connection_address_family_e address_family, char** dns_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
dns_address == NULL ||
order <= 0 ||
order > NET_DNS_ADDR_MAX) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
+ *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
+ address_family);
+ else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
+ *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
+ address_family);
- *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1]);
if (*dns_address == NULL)
return CONNECTION_ERROR_OUT_OF_MEMORY;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
+EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- const char *proxy;
net_profile_info_t *profile_info = profile;
net_dev_info_t *net_info = __profile_get_net_info(profile_info);
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_START
if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
- proxy = __profile_get_ethernet_proxy();
- if (proxy == NULL)
+ char *proxy = __profile_get_ethernet_proxy();
+ if (proxy == NULL) {
*type = CONNECTION_PROXY_TYPE_DIRECT;
- else
+ } else {
*type = CONNECTION_PROXY_TYPE_MANUAL;
+ free(proxy);
+ }
return CONNECTION_ERROR_NONE;
}
+ //LCOV_EXCL_STOP
switch (net_info->ProxyMethod) {
+ //LCOV_EXCL_START
case NET_PROXY_TYPE_DIRECT:
*type = CONNECTION_PROXY_TYPE_DIRECT;
break;
case NET_PROXY_TYPE_UNKNOWN:
default:
return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_proxy_address(connection_profile_h profile,
+EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
connection_address_family_e address_family, char** proxy_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
proxy_address == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- const char *proxy;
net_profile_info_t *profile_info = profile;
net_dev_info_t *net_info = __profile_get_net_info(profile_info);
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
- if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
- proxy = __profile_get_ethernet_proxy();
- if (proxy == NULL)
- return CONNECTION_ERROR_OPERATION_FAILED;
-
- *proxy_address = g_strdup(proxy);
- } else
- *proxy_address = g_strdup(net_info->ProxyAddr);
+ *proxy_address = g_strdup(net_info->ProxyAddr);
if (*proxy_address == NULL)
return CONNECTION_ERROR_OUT_OF_MEMORY;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_ip_config_type(connection_profile_h profile,
+EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
connection_address_family_e address_family, connection_ip_config_type_e type)
{
+ net_ip_config_type_t *profile_type = NULL;
+
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
- switch (type) {
- case CONNECTION_IP_CONFIG_TYPE_STATIC:
- net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
- net_info->IpAddr.Data.Ipv4.s_addr = 0;
- net_info->SubnetMask.Data.Ipv4.s_addr = 0;
- net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
- break;
- case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
- net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
- break;
- case CONNECTION_IP_CONFIG_TYPE_AUTO:
- net_info->IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
- break;
- case CONNECTION_IP_CONFIG_TYPE_FIXED:
- net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
- break;
- case CONNECTION_IP_CONFIG_TYPE_NONE:
- net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF;
- break;
- default:
- return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
+ profile_type = &net_info->IpConfigType ;
+ else
+ profile_type = &net_info->IpConfigType6 ;
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+ switch (type) {
+ //LCOV_EXCL_START
+ case CONNECTION_IP_CONFIG_TYPE_STATIC:
+ *profile_type = NET_IP_CONFIG_TYPE_STATIC;
+ net_info->IpAddr.Data.Ipv4.s_addr = 0;
+ net_info->SubnetMask.Data.Ipv4.s_addr = 0;
+ net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
+ break;
+
+ case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
+ *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
+ break;
+
+ case CONNECTION_IP_CONFIG_TYPE_AUTO:
+ *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
+ break;
+
+ case CONNECTION_IP_CONFIG_TYPE_FIXED:
+ net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
+ break;
+
+ case CONNECTION_IP_CONFIG_TYPE_NONE:
+ *profile_type = NET_IP_CONFIG_TYPE_OFF;
+ break;
+
+ default:
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
+ }
+ } else {
+ //LCOV_EXCL_START
+ switch (type) {
+ case CONNECTION_IP_CONFIG_TYPE_STATIC:
+ *profile_type = NET_IP_CONFIG_TYPE_STATIC;
+ inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
+ net_info->PrefixLen6 = 0 ;
+ inet_pton(AF_INET6, "::",
+ &net_info->GatewayAddr6.Data.Ipv6);
+ break;
+
+ case CONNECTION_IP_CONFIG_TYPE_AUTO:
+ *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
+ break;
+
+ case CONNECTION_IP_CONFIG_TYPE_NONE:
+ *profile_type = NET_IP_CONFIG_TYPE_OFF;
+ break;
+
+ default:
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_ip_address(connection_profile_h profile,
+EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
connection_address_family_e address_family, const char* ip_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
- if (ip_address == NULL)
- net_info->IpAddr.Data.Ipv4.s_addr = 0;
- else if (inet_aton(ip_address, &(net_info->IpAddr.Data.Ipv4)) == 0)
- return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ //LCOV_EXCL_START
+ if (ip_address == NULL)
+ inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
+ else if (inet_pton(AF_INET6, ip_address,
+ &net_info->IpAddr6.Data.Ipv6) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
+ } else {
+ if (ip_address == NULL)
+ net_info->IpAddr.Data.Ipv4.s_addr = 0;
+ else if (inet_pton(AF_INET, ip_address,
+ &net_info->IpAddr.Data.Ipv4) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_subnet_mask(connection_profile_h profile,
+EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
connection_address_family_e address_family, const char* subnet_mask)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
- (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
- address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
+ address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ CONNECTION_LOG(CONNECTION_ERROR,
+ "Please uses connection_profile_set_prefix_length()");
+ return CONNECTION_ERROR_NOT_SUPPORTED;
+ }
+
net_profile_info_t *profile_info = profile;
net_dev_info_t *net_info = __profile_get_net_info(profile_info);
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
if (subnet_mask == NULL)
net_info->SubnetMask.Data.Ipv4.s_addr = 0;
- else if (inet_aton(subnet_mask, &(net_info->SubnetMask.Data.Ipv4)) == 0)
+ else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+
+ net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
+ if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen);
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_gateway_address(connection_profile_h profile,
+EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
connection_address_family_e address_family, const char* gateway_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
- if (gateway_address == NULL)
- net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
- else if (inet_aton(gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) == 0)
- return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ //LCOV_EXCL_START
+ if (gateway_address == NULL)
+ inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
+ else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
+ } else {
+ if (gateway_address == NULL)
+ net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
+ else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_dns_address(connection_profile_h profile, int order,
+EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
connection_address_family_e address_family, const char* dns_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
order <= 0 ||
order > NET_DNS_ADDR_MAX) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
- if (dns_address == NULL)
- net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
- else if (inet_aton(dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) == 0)
- return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
+ //LCOV_EXCL_START
+ net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
+ if (dns_address == NULL)
+ inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
+ else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (net_info->DnsCount6 < order)
+ net_info->DnsCount6 = order;
+ //LCOV_EXCL_STOP
+ } else {
+ net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
+ if (dns_address == NULL)
+ net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
+ else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (net_info->DnsCount < order)
+ net_info->DnsCount = order;
+ }
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
+EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile))) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_OPERATION_FAILED;
switch (type) {
+ //LCOV_EXCL_START
case CONNECTION_PROXY_TYPE_DIRECT:
net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
break;
break;
default:
return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_proxy_address(connection_profile_h profile,
+EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
connection_address_family_e address_family, const char* proxy_address)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
if (!(_connection_libnet_check_profile_validity(profile)) ||
(address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (net_info == NULL)
return CONNECTION_ERROR_OPERATION_FAILED;
- if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
- return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
-
if (proxy_address == NULL)
net_info->ProxyAddr[0] = '\0';
else
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_state_changed_cb(connection_profile_h profile,
+EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
connection_profile_state_changed_cb callback, void* user_data)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
return CONNECTION_ERROR_NONE;
- return CONNECTION_ERROR_OPERATION_FAILED;
+ return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
}
-int connection_profile_unset_state_changed_cb(connection_profile_h profile)
+EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
{
- if (!(_connection_libnet_check_profile_cb_validity(profile))) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile))) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- _connection_libnet_remove_from_profile_cb_list(profile);
+ if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
+ return CONNECTION_ERROR_INVALID_PARAMETER;
return CONNECTION_ERROR_NONE;
}
-/* Wi-Fi profile module **************************************************************************/
-
-int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
+/* Wi-Fi profile *************************************************************/
+EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
+EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
+EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
+EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
+EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
if (profile_info->profile_type != NET_DEVICE_WIFI)
return CONNECTION_ERROR_INVALID_PARAMETER;
- *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
+ *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
+EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_INVALID_PARAMETER;
switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
+ //LCOV_EXCL_START
case WLAN_SEC_MODE_NONE:
*type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
break;
break;
default:
return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
+EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_INVALID_PARAMETER;
switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
+ //LCOV_EXCL_START
case WLAN_ENC_MODE_NONE:
*type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
break;
break;
default:
return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
+EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
}
switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
+ //LCOV_EXCL_START
case WLAN_SEC_MODE_NONE:
*required = false;
break;
break;
default:
return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
+EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
+EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
{
+ CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
}
-/* Cellular profile module ***********************************************************************/
-
-int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
-{
- if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
- return CONNECTION_ERROR_INVALID_PARAMETER;
- }
-
- int network_type;
- net_profile_info_t *profile_info = profile;
-
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
- return CONNECTION_ERROR_INVALID_PARAMETER;
-
- if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
- CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
- return CONNECTION_ERROR_OPERATION_FAILED;
- }
-
- CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
-
- switch (network_type) {
- case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
- *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
- break;
- case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
- *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
- break;
- case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
- *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
- break;
- case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
- *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
- break;
- default:
- return CONNECTION_ERROR_OPERATION_FAILED;
- }
-
- return CONNECTION_ERROR_NONE;
-}
-
-int connection_profile_get_cellular_service_type(connection_profile_h profile,
+/* Cellular profile **********************************************************/
+EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
connection_cellular_service_type_e* type)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
- CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
*type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
- CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
- return CONNECTION_ERROR_OPERATION_FAILED;
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
+ return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
+EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
- return CONNECTION_ERROR_INVALID_PARAMETER;
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
+ return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ }
*apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
if (*apn == NULL)
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_cellular_auth_info(connection_profile_h profile,
- connection_cellular_auth_type_e* type, char** user_name, char** password)
+EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
+ connection_cellular_auth_type_e *type, char** user_name, char** password)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
type == NULL || user_name == NULL || password == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
+ //LCOV_EXCL_START
case NET_PDP_AUTH_NONE:
*type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
break;
break;
default:
return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
}
*user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
*password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
if (*password == NULL) {
- g_free(*user_name);
- return CONNECTION_ERROR_OUT_OF_MEMORY;
+ g_free(*user_name); //LCOV_EXCL_LINE
+ return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
+EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
*home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
if (*home_url == NULL)
return CONNECTION_ERROR_NONE;
}
-int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
+EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ switch (profile_info->ProfileInfo.Pdp.PdnType) {
+ //LCOV_EXCL_START
+ case NET_PDN_TYPE_UNKNOWN:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
+ break;
+ case NET_PDN_TYPE_IPV4:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
+ break;
+ case NET_PDN_TYPE_IPV6:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
+ break;
+ case NET_PDN_TYPE_IPV4_IPV6:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
+ break;
+ default:
+ return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
+ }
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
+ //LCOV_EXCL_START
+ case NET_PDN_TYPE_UNKNOWN:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
+ break;
+ case NET_PDN_TYPE_IPV4:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
+ break;
+ case NET_PDN_TYPE_IPV6:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
+ break;
+ case NET_PDN_TYPE_IPV4_IPV6:
+ *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
+ break;
+ default:
+ return CONNECTION_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
+ }
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
if (profile_info->ProfileInfo.Pdp.Roaming)
*is_roaming = true;
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_cellular_service_type(connection_profile_h profile,
+EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ if (profile_info->ProfileInfo.Pdp.Hidden)
+ *is_hidden = true;
+ else
+ *is_hidden = false;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ if (profile_info->ProfileInfo.Pdp.Editable)
+ *is_editable = true;
+ else
+ *is_editable = false;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ if (profile_info->ProfileInfo.Pdp.DefaultConn)
+ *is_default = true;
+ else
+ *is_default = false;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
connection_cellular_service_type_e service_type)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile))) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
switch (service_type) {
+ //LCOV_EXCL_START
case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
break;
case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
default:
return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
}
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
+EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_cellular_auth_info(connection_profile_h profile,
+EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
connection_cellular_auth_type_e type, const char* user_name, const char* password)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) ||
user_name == NULL || password == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
switch (type) {
+ //LCOV_EXCL_START
case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
break;
break;
default:
return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
}
g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
return CONNECTION_ERROR_NONE;
}
-int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
+EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
- CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
net_profile_info_t *profile_info = profile;
- if (profile_info->profile_type != NET_DEVICE_CELLULAR)
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
return CONNECTION_ERROR_NONE;
}
+EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile))) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ switch (type) {
+ //LCOV_EXCL_START
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
+ profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
+ break;
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
+ profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
+ break;
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
+ profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
+ CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
+ "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
+ break;
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
+ profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
+ break;
+ default:
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
+ }
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile))) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+
+ if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ switch (type) {
+ //LCOV_EXCL_START
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
+ profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
+ break;
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
+ profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
+ break;
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
+ profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
+ CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
+ "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
+ break;
+ case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
+ profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
+ break;
+ default:
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ //LCOV_EXCL_STOP
+ }
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
+ TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) ||
+ state == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+ *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
+ if (*state < 0)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
+ connection_address_family_e address_family, connection_dns_config_type_e type)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
+ TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile))) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
+ address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
+ (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
+ type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_dns_config_type_t *profileType = NULL;
+ net_dns_config_type_t *profileType6 = NULL;
+ net_profile_info_t *profile_info = profile;
+
+ net_dev_info_t *net_info = __profile_get_net_info(profile_info);
+ if (net_info == NULL)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+ profileType = &net_info->DnsConfigType;
+ net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
+ net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
+ *profileType = type;
+ } else {
+ profileType6 = &net_info->DnsConfigType6;
+ inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
+ inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
+ *profileType6 = type;
+ }
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
+ connection_address_family_e address_family, connection_dns_config_type_e *type)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
+ TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) ||
+ (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
+ address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
+ type == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_dns_config_type_t profileType;
+ net_profile_info_t *profile_info = profile;
+ net_dev_info_t *net_info = __profile_get_net_info(profile_info);
+ if (net_info == NULL)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
+ profileType = net_info->DnsConfigType;
+ else
+ profileType = net_info->DnsConfigType6;
+
+ switch (profileType) {
+ case NET_DNS_CONFIG_TYPE_STATIC:
+ *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
+ break;
+ case NET_DNS_CONFIG_TYPE_DYNAMIC:
+ *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
+ break;
+ default:
+ *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
+ break;
+ }
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
+ connection_address_family_e address_family, int prefix_len)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
+ TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) ||
+ (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
+ address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+ net_dev_info_t *net_info = __profile_get_net_info(profile_info);
+ if (net_info == NULL)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+ net_info->PrefixLen = prefix_len;
+ net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
+ } else
+ net_info->PrefixLen6 = prefix_len;
+
+ return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
+ connection_address_family_e address_family, int *prefix_len)
+{
+ CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
+ TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+ if (!(_connection_libnet_check_profile_validity(profile)) ||
+ (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
+ address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
+ prefix_len == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ net_profile_info_t *profile_info = profile;
+ net_dev_info_t *net_info = __profile_get_net_info(profile_info);
+ if (net_info == NULL)
+ return CONNECTION_ERROR_OPERATION_FAILED;
+
+ if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
+ *prefix_len = net_info->PrefixLen;
+ else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
+ *prefix_len = net_info->PrefixLen6;
+
+ return CONNECTION_ERROR_NONE;
+}
projects / platform / core / api / connection.git / blobdiff