API int pkgmgr_set_preload_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, int preload)
{
if (!handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
if (preload < 0 || preload > 1) {
_LOGE("Argument supplied is invalid\n");
return PKGMGR_R_EINVAL;
}
manifest_x *mfx = (manifest_x *)handle;
if (mfx->preload == NULL) {
mfx->preload = (char *)calloc(1, strlen("false"));
if (mfx->preload == NULL) {
_LOGE("Malloc Failed\n");
return PKGMGR_R_ERROR;
}
}
if (preload == 0) {
strcpy(mfx->preload, "false");
} else if (preload == 1) {
strcpy(mfx->preload, "true");
} else {
_LOGE("Invalid preload type\n");
return PKGMGR_R_ERROR;
}
PKGMGR_R_OK;
}
static gboolean
_netns_switch_pop (NMPNetns *self, int ns_types)
{
int errsv;
NMPNetns *current;
int success = TRUE;
if ( NM_FLAGS_HAS (ns_types, CLONE_NEWNET)
&& (!self || !_stack_current_ns_types (self, CLONE_NEWNET))) {
current = _stack_current_netns (CLONE_NEWNET);
if (!current) {
g_warn_if_reached ();
success = FALSE;
} else if (_setns (current, CLONE_NEWNET) != 0) {
errsv = errno;
_LOGE (self, "failed to switch netns: %s", g_strerror (errsv));
success = FALSE;
}
}
if ( NM_FLAGS_HAS (ns_types, CLONE_NEWNS)
&& (!self || !_stack_current_ns_types (self, CLONE_NEWNS))) {
current = _stack_current_netns (CLONE_NEWNS);
if (!current) {
g_warn_if_reached ();
success = FALSE;
} else if (_setns (current, CLONE_NEWNS) != 0) {
errsv = errno;
_LOGE (self, "failed to switch mntns: %s", g_strerror (errsv));
success = FALSE;
}
}
return success;
}
API int pkgmgr_set_description_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, const char *desc_txt, const char *locale)
{
if (!handle || !desc_txt) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
int len = strlen(desc_txt);
manifest_x *mfx = (manifest_x *)handle;
if (len > PKG_VALUE_STRING_LEN_MAX) {
_LOGE("description length exceeds the max limit\n");
return PKGMGR_R_EINVAL;
}
description_x *description = calloc(1, sizeof(description_x));
if (description == NULL) {
_LOGE("Malloc Failed\n");
return PKGMGR_R_ERROR;
}
LISTADD(mfx->description, description);
if (locale)
mfx->description->lang = strdup(locale);
else
mfx->description->lang = strdup(DEFAULT_LOCALE);
mfx->description->text = strdup(desc_txt);
return PKGMGR_R_OK;
}
API int pkgmgr_set_removable_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, int removable)
{
if (!handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
if (removable < 0 || removable > 1) {
_LOGE("Argument supplied is invalid\n");
return PKGMGR_R_EINVAL;
}
manifest_x *mfx = (manifest_x *)handle;
if (mfx->removable == NULL) {
mfx->removable = (char *)calloc(1, strlen("false"));
if (mfx->removable == NULL) {
_LOGE("Malloc Failed\n");
return PKGMGR_R_ERROR;
}
}
if (removable == 0) {
strcpy(mfx->removable, "false");
} else if (removable == 1) {
strcpy(mfx->removable, "true");
} else {
_LOGE("Invalid removable type\n");
return PKGMGR_R_ERROR;
}
PKGMGR_R_OK;
}
API int pkgmgr_set_author_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, const char *author_name,
const char *author_email, const char *author_href, const char *locale)
{
if (!handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
manifest_x *mfx = (manifest_x *)handle;
author_x *author = calloc(1, sizeof(author_x));
if (author == NULL) {
_LOGE("Malloc Failed\n");
return PKGMGR_R_ERROR;
}
LISTADD(mfx->author, author);
if (author_name)
mfx->author->text = strdup(author_name);
if (author_email)
mfx->author->email = strdup(author_email);
if (author_href)
mfx->author->href = strdup(author_href);
if (locale)
mfx->author->lang = strdup(locale);
else
mfx->author->lang = strdup(DEFAULT_LOCALE);
return PKGMGR_R_OK;
}
API int pkgmgr_set_install_location_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, INSTALL_LOCATION location)
{
if (!handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
if (location < 0 || location > 1) {
_LOGE("Argument supplied is invalid\n");
return PKGMGR_R_EINVAL;
}
manifest_x *mfx = (manifest_x *)handle;
if (mfx->installlocation == NULL) {
mfx->installlocation = (char *)calloc(1, strlen("prefer-external"));
if (mfx->installlocation == NULL) {
_LOGE("Malloc Failed\n");
return PKGMGR_R_ERROR;
}
}
if (location == INSTALL_INTERNAL) {
strcpy(mfx->installlocation, "internal-only");
} else if (location == INSTALL_EXTERNAL) {
strcpy(mfx->installlocation, "prefer-external");
} else {
_LOGE("Invalid location type\n");
return PKGMGR_R_ERROR;
}
return PKGMGR_R_OK;
}
static gboolean
_netns_switch_push (NMPNetns *self, int ns_types)
{
int errsv;
if ( NM_FLAGS_HAS (ns_types, CLONE_NEWNET)
&& !_stack_current_ns_types (self, CLONE_NEWNET)
&& _setns (self, CLONE_NEWNET) != 0) {
errsv = errno;
_LOGE (self, "failed to switch netns: %s", g_strerror (errsv));
return FALSE;
}
if ( NM_FLAGS_HAS (ns_types, CLONE_NEWNS)
&& !_stack_current_ns_types (self, CLONE_NEWNS)
&& _setns (self, CLONE_NEWNS) != 0) {
errsv = errno;
_LOGE (self, "failed to switch mntns: %s", g_strerror (errsv));
/* try to fix the mess by returning to the previous netns. */
if ( NM_FLAGS_HAS (ns_types, CLONE_NEWNET)
&& !_stack_current_ns_types (self, CLONE_NEWNET)) {
self = _stack_current_netns (CLONE_NEWNET);
if ( self
&& _setns (self, CLONE_NEWNET) != 0) {
errsv = errno;
_LOGE (self, "failed to restore netns: %s", g_strerror (errsv));
}
}
return FALSE;
}
return TRUE;
}
int
plugin_init (void)
{
GDBusConnection *bus;
GError *error = NULL;
const char *bus_name;
nm_g_type_init ();
g_return_val_if_fail (!gl.proxy, -1);
bus_name = getenv ("NM_DBUS_SERVICE_L2TP");
if (!bus_name)
bus_name = NM_DBUS_SERVICE_L2TP;
gl.log_level = _nm_utils_ascii_str_to_int64 (getenv ("NM_VPN_LOG_LEVEL"),
10, 0, LOG_DEBUG,
LOG_NOTICE);
gl.log_prefix_token = getenv ("NM_VPN_LOG_PREFIX_TOKEN") ?: "???";
_LOGI ("initializing");
bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (!bus) {
_LOGE ("couldn't connect to system bus: %s",
error->message);
g_error_free (error);
return -1;
}
gl.proxy = g_dbus_proxy_new_sync (bus,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
NULL,
bus_name,
NM_DBUS_PATH_L2TP_PPP,
NM_DBUS_INTERFACE_L2TP_PPP,
NULL, &error);
g_object_unref (bus);
if (!gl.proxy) {
_LOGE ("couldn't create D-Bus proxy: %s",
error->message);
g_error_free (error);
return -1;
}
chap_passwd_hook = get_credentials;
chap_check_hook = get_chap_check;
pap_passwd_hook = get_credentials;
pap_check_hook = get_pap_check;
#ifdef USE_EAPTLS
eaptls_passwd_hook = get_credentials;
#endif
add_notifier (&phasechange, nm_phasechange, NULL);
add_notifier (&ip_up_notifier, nm_ip_up, NULL);
add_notifier (&exitnotify, nm_exit_notify, NULL);
return 0;
}
gboolean
nmp_netns_bind_to_path (NMPNetns *self, const char *filename, int *out_fd)
{
gs_free char *dirname = NULL;
int errsv;
int fd;
nm_auto_pop_netns NMPNetns *netns_pop = NULL;
g_return_val_if_fail (NMP_IS_NETNS (self), FALSE);
g_return_val_if_fail (filename && filename[0] == '/', FALSE);
if (!nmp_netns_push_type (self, CLONE_NEWNET))
return FALSE;
netns_pop = self;
dirname = g_path_get_dirname (filename);
if (mkdir (dirname, 0) != 0) {
errsv = errno;
if (errsv != EEXIST) {
_LOGE (self, "bind: failed to create directory %s: %s",
dirname, g_strerror (errsv));
return FALSE;
}
}
if ((fd = creat (filename, S_IRUSR | S_IRGRP | S_IROTH)) == -1) {
errsv = errno;
_LOGE (self, "bind: failed to create %s: %s",
filename, g_strerror (errsv));
return FALSE;
}
close (fd);
if (mount (PROC_SELF_NS_NET, filename, "none", MS_BIND, NULL) != 0) {
errsv = errno;
_LOGE (self, "bind: failed to mount %s to %s: %s",
PROC_SELF_NS_NET, filename, g_strerror (errsv));
unlink (filename);
return FALSE;
}
if (out_fd) {
if ((fd = open (filename, O_RDONLY)) == -1) {
errsv = errno;
_LOGE (self, "bind: failed to open %s: %s", filename, g_strerror (errsv));
umount2 (filename, MNT_DETACH);
unlink (filename);
return FALSE;
}
*out_fd = fd;
}
return TRUE;
}
NMPNetns *
nmp_netns_new (void)
{
NMPNetns *self;
int errsv;
GError *error = NULL;
_stack_ensure_init ();
if (!_stack_peek ()) {
/* there are no netns instances. We cannot create a new one
* (because after unshare we couldn't return to the original one). */
return NULL;
}
if (unshare (_CLONE_NS_ALL) != 0) {
errsv = errno;
_LOGE (NULL, "failed to create new net and mnt namespace: %s", g_strerror (errsv));
return NULL;
}
if (mount ("", "/", "none", MS_SLAVE | MS_REC, NULL) != 0) {
errsv = errno;
_LOGE (NULL, "failed mount --make-rslave: %s", g_strerror (errsv));
goto err_out;
}
if (umount2 ("/sys", MNT_DETACH) != 0) {
errsv = errno;
_LOGE (NULL, "failed umount /sys: %s", g_strerror (errsv));
goto err_out;
}
if (mount ("sysfs", "/sys", "sysfs", 0, NULL) != 0) {
errsv = errno;
_LOGE (NULL, "failed mount /sys: %s", g_strerror (errsv));
goto err_out;
}
self = _netns_new (&error);
if (!self) {
_LOGE (NULL, "failed to create netns after unshare: %s", error->message);
g_clear_error (&error);
goto err_out;
}
_stack_push (self, _CLONE_NS_ALL);
return self;
err_out:
_netns_switch_pop (NULL, _CLONE_NS_ALL);
return NULL;
}
int _pkg_plugin_get_library_path(const char *pkg_type, char *library_path)
{
FILE *fp = NULL;
char buffer[1024] = { 0 };
if (pkg_type == NULL || library_path == NULL) {
_LOGE("invalid argument\n");
return -1;
}
fp = fopen(PKG_CONF_PATH, "r");
if (fp == NULL) {
_LOGE("no matching backendlib\n");
return PKGMGR_R_ERROR;
}
char *path = NULL;
while (fgets(buffer, 1024, fp) != NULL) {
if (buffer[0] == '#')
continue;
_app_str_trim(buffer);
if ((path = strstr(buffer, PKG_BACKENDLIB)) != NULL) {
_LOGD("[%s]\n", buffer);
_LOGD("[%s]\n", path);
path = path + strlen(PKG_BACKENDLIB);
_LOGD("[%s]\n", path);
break;
}
memset(buffer, 0x00, 1024);
}
if (fp != NULL)
fclose(fp);
if (path == NULL) {
_LOGE("no matching backendlib\n");
return PKGMGR_R_ERROR;
}
snprintf(library_path, 1024, "%slib%s.so", path, pkg_type);
return PKGMGR_R_OK;
}
static GObject*
constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
NMDeviceAdsl *self;
NMDeviceAdslPrivate *priv;
object = G_OBJECT_CLASS (nm_device_adsl_parent_class)->constructor (type,
n_construct_params,
construct_params);
if (!object)
return NULL;
self = NM_DEVICE_ADSL (object);
priv = NM_DEVICE_ADSL_GET_PRIVATE (object);
priv->atm_index = get_atm_index (nm_device_get_iface (NM_DEVICE (object)));
if (priv->atm_index < 0) {
_LOGE (LOGD_ADSL, "error reading ATM device index");
g_object_unref (object);
return NULL;
} else
_LOGD (LOGD_ADSL, "ATM device index %d", priv->atm_index);
/* Poll the carrier */
priv->carrier_poll_id = g_timeout_add_seconds (5, carrier_update_cb, object);
return object;
}
static gboolean
set_ip_config_common (NMPPPManager *self,
GVariant *config_dict,
const char *iface_prop,
guint32 *out_mtu)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
NMConnection *applied_connection;
NMSettingPpp *s_ppp;
const char *iface;
if (!g_variant_lookup (config_dict, iface_prop, "&s", &iface)) {
_LOGE ("no interface received!");
return FALSE;
}
if (priv->ip_iface == NULL)
priv->ip_iface = g_strdup (iface);
/* Got successful IP config; obviously the secrets worked */
applied_connection = nm_act_request_get_applied_connection (priv->act_req);
g_object_set_data (G_OBJECT (applied_connection), PPP_MANAGER_SECRET_TRIES, NULL);
if (out_mtu) {
/* Get any custom MTU */
s_ppp = nm_connection_get_setting_ppp (applied_connection);
*out_mtu = s_ppp ? nm_setting_ppp_get_mtu (s_ppp) : 0;
}
monitor_stats (self);
return TRUE;
}
static void
_stack_ensure_init_impl (void)
{
NMPNetns *netns;
GError *error = NULL;
nm_assert (!netns_stack);
netns_stack = g_array_new (FALSE, FALSE, sizeof (NetnsInfo));
/* at the bottom of the stack we must try to create a netns instance
* that we never pop. It's the base to which we need to return. */
netns = _netns_new (&error);
if (!netns) {
/* don't know how to recover from this error. Netns are not supported. */
_LOGE (NULL, "failed to create initial netns: %s", error->message);
g_clear_error (&error);
return;
}
_stack_push (netns, _CLONE_NS_ALL);
/* we leak this instance inside netns_stack. It cannot be popped. */
g_object_unref (netns);
}
static void
update_connection (NMDevice *device, NMConnection *connection)
{
NMDeviceTeam *self = NM_DEVICE_TEAM (device);
NMSettingTeam *s_team = nm_connection_get_setting_team (connection);
NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (self);
if (!s_team) {
s_team = (NMSettingTeam *) nm_setting_team_new ();
nm_connection_add_setting (connection, (NMSetting *) s_team);
}
g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, NULL, NULL);
if (priv->tdc) {
const char *config = NULL;
int err;
err = teamdctl_config_get_raw_direct (NM_DEVICE_TEAM_GET_PRIVATE (device)->tdc,
(char **)&config);
if (err == 0)
g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, config, NULL);
else
_LOGE (LOGD_TEAM, "failed to read teamd config (err=%d)", err);
}
}
API int pkgmgr_create_pkgdbinfo(const char *pkg_name, pkgmgr_pkgdbinfo_h *handle)
{
if (!pkg_name || !handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
manifest_x *mfx = NULL;
mfx = calloc(1, sizeof(manifest_x));
if (!mfx) {
_LOGE("Malloc Failed\n");
return PKGMGR_R_ERROR;
}
mfx->package = strdup(pkg_name);
*handle = (void *)mfx;
return PKGMGR_R_OK;
}
void
nm_dispatcher_init (void)
{
GFile *file;
guint i;
GError *error = NULL;
for (i = 0; i < G_N_ELEMENTS (monitors); i++) {
file = g_file_new_for_path (monitors[i].dir);
monitors[i].monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
if (monitors[i].monitor) {
g_signal_connect (monitors[i].monitor, "changed", G_CALLBACK (dispatcher_dir_changed), &monitors[i]);
dispatcher_dir_changed (monitors[i].monitor, file, NULL, 0, &monitors[i]);
}
g_object_unref (file);
}
dispatcher_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
NULL,
NM_DISPATCHER_DBUS_SERVICE,
NM_DISPATCHER_DBUS_PATH,
NM_DISPATCHER_DBUS_INTERFACE,
NULL, &error);
if (!dispatcher_proxy) {
_LOGE ("could not get dispatcher proxy! %s", error->message);
g_clear_error (&error);
}
}
static void
set_property (GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec)
{
NMConnectivity *self = NM_CONNECTIVITY (object);
NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self);
const char *uri, *response;
guint interval;
gboolean changed;
switch (property_id) {
case PROP_URI:
uri = g_value_get_string (value);
if (uri && !*uri)
uri = NULL;
changed = g_strcmp0 (uri, priv->uri) != 0;
#if WITH_CONCHECK
if (uri) {
SoupURI *soup_uri = soup_uri_new (uri);
if (!soup_uri || !SOUP_URI_VALID_FOR_HTTP (soup_uri)) {
_LOGE ("invalid uri '%s' for connectivity check.", uri);
uri = NULL;
}
if (uri && soup_uri && changed &&
soup_uri_get_scheme(soup_uri) == SOUP_URI_SCHEME_HTTPS)
_LOGW ("use of HTTPS for connectivity checking is not reliable and is discouraged (URI: %s)", uri);
if (soup_uri)
soup_uri_free (soup_uri);
}
#endif
if (changed) {
g_free (priv->uri);
priv->uri = g_strdup (uri);
_reschedule_periodic_checks (self, TRUE);
}
break;
case PROP_INTERVAL:
interval = g_value_get_uint (value);
if (priv->interval != interval) {
priv->interval = interval;
_reschedule_periodic_checks (self, TRUE);
}
break;
case PROP_RESPONSE:
response = g_value_get_string (value);
if (g_strcmp0 (response, priv->response) != 0) {
/* a response %NULL means, NM_CONFIG_DEFAULT_CONNECTIVITY_RESPONSE. Any other response
* (including "") is accepted. */
g_free (priv->response);
priv->response = g_strdup (response);
_reschedule_periodic_checks (self, TRUE);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
constructed (GObject *object)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (object);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
int ifindex = nm_device_get_ifindex (NM_DEVICE (self));
int parent_ifindex = -1, itype;
int vlan_id;
if (G_OBJECT_CLASS (nm_device_vlan_parent_class)->constructed)
G_OBJECT_CLASS (nm_device_vlan_parent_class)->constructed (object);
if (!priv->parent) {
_LOGE (LOGD_VLAN, "no parent specified.");
priv->invalid = TRUE;
return;
}
itype = nm_platform_link_get_type (ifindex);
if (itype != NM_LINK_TYPE_VLAN) {
_LOGE (LOGD_VLAN, "failed to get VLAN interface type.");
priv->invalid = TRUE;
return;
}
if (!nm_platform_vlan_get_info (ifindex, &parent_ifindex, &vlan_id)) {
_LOGW (LOGD_VLAN, "failed to get VLAN interface info.");
priv->invalid = TRUE;
return;
}
if ( parent_ifindex < 0
|| parent_ifindex != nm_device_get_ip_ifindex (priv->parent)
|| vlan_id < 0) {
_LOGW (LOGD_VLAN, "VLAN parent ifindex (%d) or VLAN ID (%d) invalid.",
parent_ifindex, priv->vlan_id);
priv->invalid = TRUE;
return;
}
priv->vlan_id = vlan_id;
_LOGI (LOGD_HW | LOGD_VLAN, "VLAN ID %d with parent %s",
priv->vlan_id, nm_device_get_iface (priv->parent));
}
static gboolean
enslave_slave (NMDevice *device,
NMDevice *slave,
NMConnection *connection,
gboolean configure)
{
NMDeviceTeam *self = NM_DEVICE_TEAM (device);
NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (device);
gboolean success = TRUE, no_firmware = FALSE;
const char *slave_iface = nm_device_get_ip_iface (slave);
NMSettingTeamPort *s_team_port;
nm_device_master_check_slave_physical_port (device, slave, LOGD_TEAM);
if (configure) {
nm_device_take_down (slave, TRUE);
s_team_port = nm_connection_get_setting_team_port (connection);
if (s_team_port) {
const char *config = nm_setting_team_port_get_config (s_team_port);
if (config) {
if (!priv->tdc) {
_LOGW (LOGD_TEAM, "enslaved team port %s config not changed, not connected to teamd",
slave_iface);
} else {
int err;
char *sanitized_config;
sanitized_config = g_strdelimit (g_strdup (config), "\r\n", ' ');
err = teamdctl_port_config_update_raw (priv->tdc, slave_iface, sanitized_config);
g_free (sanitized_config);
if (err != 0) {
_LOGE (LOGD_TEAM, "failed to update config for port %s (err=%d)",
slave_iface, err);
return FALSE;
}
}
}
}
success = nm_platform_link_enslave (NM_PLATFORM_GET,
nm_device_get_ip_ifindex (device),
nm_device_get_ip_ifindex (slave));
nm_device_bring_up (slave, TRUE, &no_firmware);
if (!success)
return FALSE;
_LOGI (LOGD_TEAM, "enslaved team port %s", slave_iface);
} else
_LOGI (LOGD_TEAM, "team port %s was enslaved", slave_iface);
g_object_notify (G_OBJECT (device), NM_DEVICE_TEAM_SLAVES);
return TRUE;
}
API int pkgmgr_set_type_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, const char *type)
{
if (!type || !handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
int len = strlen(type);
manifest_x *mfx = (manifest_x *)handle;
if (len > PKG_TYPE_STRING_LEN_MAX) {
_LOGE("pkg type length exceeds the max limit\n");
return PKGMGR_R_EINVAL;
}
if (mfx->type == NULL)
mfx->type = strndup(type, PKG_TYPE_STRING_LEN_MAX);
else
mfx->type = type;
return PKGMGR_R_OK;
}
API int pkgmgr_set_version_to_pkgdbinfo(pkgmgr_pkgdbinfo_h handle, const char *version)
{
if (!version || !handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
int len = strlen(version);
manifest_x *mfx = (manifest_x *)handle;
if (len > PKG_VERSION_STRING_LEN_MAX) {
_LOGE("pkg version length exceeds the max limit\n");
return PKGMGR_R_EINVAL;
}
if (mfx->version == NULL)
mfx->version = strndup(version, PKG_VERSION_STRING_LEN_MAX);
else
mfx->version = version;
return PKGMGR_R_OK;
}
API int pkgmgr_destroy_pkgdbinfo(pkgmgr_pkgdbinfo_h handle)
{
if (!handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
manifest_x *mfx = NULL;
mfx = (manifest_x *)handle;
pkgmgr_parser_free_manifest_xml(mfx);
return PKGMGR_R_OK;
}
static gboolean
br2684_create_iface (NMDeviceAdsl *self, NMSettingAdsl *s_adsl)
{
NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE (self);
struct atm_newif_br2684 ni;
int err, fd, errsv;
gboolean success = FALSE;
guint num = 0;
g_return_val_if_fail (s_adsl != NULL, FALSE);
fd = socket (PF_ATMPVC, SOCK_DGRAM, ATM_AAL5);
if (fd < 0) {
errsv = errno;
_LOGE (LOGD_ADSL, "failed to open ATM control socket (%d)", errsv);
return FALSE;
}
memset (&ni, 0, sizeof (ni));
ni.backend_num = ATM_BACKEND_BR2684;
ni.media = BR2684_MEDIA_ETHERNET;
ni.mtu = 1500;
/* Loop attempting to create an interface that doesn't exist yet. The
* kernel can create one for us automatically, but due to API issues it
* cannot return that name to us. Since we want to know the name right
* away, just brute-force it.
*/
while (num < 10000) {
memset (&ni.ifname, 0, sizeof (ni.ifname));
g_snprintf (ni.ifname, sizeof (ni.ifname), "nas%d", num);
err = ioctl (fd, ATM_NEWBACKENDIF, &ni);
if (err == 0) {
set_nas_iface (self, -1, ni.ifname);
_LOGI (LOGD_ADSL, "using NAS interface %s (%d)",
priv->nas_ifname, priv->nas_ifindex);
success = TRUE;
break;
} else {
errsv = errno;
if (errsv == -EEXIST) {
/* Try again */
num++;
} else {
_LOGW (LOGD_ADSL, "failed to create br2684 interface (%d)", errsv);
break;
}
}
}
close (fd);
return success;
}
gboolean
nmp_netns_bind_to_path_destroy (NMPNetns *self, const char *filename)
{
int errsv;
g_return_val_if_fail (NMP_IS_NETNS (self), FALSE);
g_return_val_if_fail (filename && filename[0] == '/', FALSE);
if (umount2 (filename, MNT_DETACH) != 0) {
errsv = errno;
_LOGE (self, "bind: failed to unmount2 %s: %s", filename, g_strerror (errsv));
return FALSE;
}
if (unlink (filename) != 0) {
errsv = errno;
_LOGE (self, "bind: failed to unlink %s: %s", filename, g_strerror (errsv));
return FALSE;
}
return TRUE;
}
API int pkgmgr_save_pkgdbinfo(pkgmgr_pkgdbinfo_h handle)
{
if (!handle) {
_LOGE("Argument supplied is NULL\n");
return PKGMGR_R_EINVAL;
}
int ret = 0;
manifest_x *mfx = NULL;
label_x *tmp1 = NULL;
icon_x *tmp2 = NULL;
description_x *tmp3 = NULL;
author_x *tmp4 = NULL;
mfx = (manifest_x *)handle;
/*First move to head of all list pointers*/
if (mfx->label) {
LISTHEAD(mfx->label, tmp1);
mfx->label = tmp1;
}
if (mfx->icon) {
LISTHEAD(mfx->icon, tmp2);
mfx->icon = tmp2;
}
if (mfx->description) {
LISTHEAD(mfx->description, tmp3);
mfx->description= tmp3;
}
if (mfx->author) {
LISTHEAD(mfx->author, tmp4);
mfx->author = tmp4;
}
ret = pkgmgr_parser_insert_manifest_info_in_db(mfx);
if (ret == 0) {
_LOGE("Successfully stored info in DB\n");
return PKGMGR_R_OK;
} else {
_LOGE("Failed to store info in DB\n");
return PKGMGR_R_ERROR;
}
}
static void
run_check_complete (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NMConnectivity *self = NM_CONNECTIVITY (object);
GError *error = NULL;
nm_connectivity_check_finish (self, result, &error);
if (error) {
_LOGE ("check failed: %s", error->message);
g_error_free (error);
}
}
pkg_plugin_set *_package_manager_load_library(const char *pkg_type)
{
char package_path[1024] = { 0 };
pkg_plugin_set *plugin_set = NULL;
if (pkg_type == NULL) {
_LOGE("can not load library - pkg_type is null\n");
return NULL;
}
if (_pkg_plugin_get_library_path(pkg_type, package_path) ==
PKGMGR_R_OK) {
plugin_set = _pkg_plugin_load_library(pkg_type, package_path);
if (plugin_set == NULL) {
_LOGE("can not load library \n");
return NULL;
}
} else {
_LOGE("can not find path \n");
return NULL;
}
return plugin_set;
}
static gboolean
send_rs (NMRDisc *rdisc)
{
NMLNDPRDiscPrivate *priv = NM_LNDP_RDISC_GET_PRIVATE (rdisc);
struct ndp_msg *msg;
int error;
error = ndp_msg_new (&msg, NDP_MSG_RS);
g_assert (!error);
ndp_msg_ifindex_set (msg, rdisc->ifindex);
error = ndp_msg_send (priv->ndp, msg);
ndp_msg_destroy (msg);
if (error) {
_LOGE ("cannot send router solicitation: %d.", error);
return FALSE;
}
return TRUE;
}
static gboolean
ensure_teamd_connection (NMDevice *device)
{
NMDeviceTeam *self = NM_DEVICE_TEAM (device);
NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (self);
int err;
if (priv->tdc)
return TRUE;
priv->tdc = teamdctl_alloc ();
g_assert (priv->tdc);
err = teamdctl_connect (priv->tdc, nm_device_get_iface (device), NULL, NULL);
if (err != 0) {
_LOGE (LOGD_TEAM, "failed to connect to teamd (err=%d)", err);
teamdctl_free (priv->tdc);
priv->tdc = NULL;
}
return !!priv->tdc;
}
