* @file usb_moded-config.c

*

* Copyright (C) 2010 Nokia Corporation. All rights reserved.

* Copyright (C) 2012-2018 Jolla. All rights reserved.

*

* @author: Philippe De Swert <philippe.de-swert@nokia.com>

* @author: Philippe De Swert <phdeswer@lumi.maa>

* @author: Philippe De Swert <philippedeswert@gmail.com>

* @author: Philippe De Swert <philippe.deswert@jollamobile.com>

* @author: Reto Zingg <reto.zingg@jollamobile.com>

* @author: Thomas Perl <m@thp.io>

* @author: Slava Monich <slava.monich@jolla.com>

* @author: Martin Jones <martin.jones@jollamobile.com>

* @author: Jarko Poutiainen <jarko.poutiainen@jollamobile.com>

* @author: Simo Piiroinen <simo.piiroinen@jollamobile.com>

* @author: Andrew den Exter <andrew.den.exter@jolla.com>

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the Lesser GNU General Public License

* version 2 as published by the Free Software Foundation.

*

* This program is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* General Public License for more details.

*

* You should have received a copy of the Lesser GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA

*/

#include "usb_moded-control.h"

#include "usb_moded-dbus-private.h"

#include "usb_moded-dyn-config.h"

#ifdef USE_MER_SSU

# include "usb_moded-ssu.h"

#endif

#include <sys/stat.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#include <glob.h>

/* ========================================================================= *

* Prototypes

* ========================================================================= */

/* -- config -- */

static int config_validate_ip (const char *ipadd);

char *config_find_mounts (void);

int config_find_sync (void);

char *config_find_alt_mount (void);

char *config_find_udev_path (void);

char *config_find_udev_subsystem (void);

char *config_check_trigger (void);

char *config_get_trigger_subsystem (void);

char *config_get_trigger_mode (void);

char *config_get_trigger_property (void);

char *config_get_trigger_value (void);

static char *config_get_network_ip (void);

static char *config_get_network_interface (void);

static char *config_get_network_gateway (void);

static char *config_get_network_netmask (void);

static char *config_get_network_nat_interface(void);

static void config_create_conf_file (void);

static int config_get_conf_int (const gchar *entry, const gchar *key);

static char *config_get_conf_string (const gchar *entry, const gchar *key);

static char *config_get_kcmdline_string (const char *entry);

char *config_get_mode_setting (void);

int config_value_changed (GKeyFile *settingsfile, const char *entry, const char *key, const char *new_value);

set_config_result_t config_set_config_setting (const char *entry, const char *key, const char *value);

set_config_result_t config_set_mode_setting (const char *mode);

static char *config_make_modes_string (const char *key, const char *mode_name, int include);

set_config_result_t config_set_hide_mode_setting (const char *mode);

set_config_result_t config_set_unhide_mode_setting (const char *mode);

set_config_result_t config_set_mode_whitelist (const char *whitelist);

set_config_result_t config_set_mode_in_whitelist (const char *mode, int allowed);

set_config_result_t config_set_network_setting (const char *config, const char *setting);

char *config_get_network_setting (const char *config);

static void config_merge_key (GKeyFile *dest, GKeyFile *srce, const char *grp, const char *key);

static void config_merge_group (GKeyFile *dest, GKeyFile *srce, const char *grp);

static void config_merge_file (GKeyFile *dest, GKeyFile *srce);

static int config_glob_error_cb (const char *path, int err);

static GKeyFile *config_read_ini_files (void);

int config_merge_conf_file (void);

char *config_get_android_manufacturer (void);

char *config_get_android_vendor_id (void);

char *config_get_android_product (void);

char *config_get_android_product_id (void);

char *config_get_hidden_modes (void);

char *config_get_mode_whitelist (void);

int config_is_roaming_not_allowed (void);

/* ========================================================================= *

* Functions

* ========================================================================= */

static int config_validate_ip(const char *ipadd)

{

unsigned int b1, b2, b3, b4;

unsigned char c;

if (sscanf(ipadd, "%3u.%3u.%3u.%3u%c", &b1, &b2, &b3, &b4, &c) != 4)

return(-1);

/* all ok */

return 0;

}

{

char *ret = NULL;

ret = config_get_conf_string(FS_MOUNT_ENTRY, FS_MOUNT_KEY);

if(ret == NULL)

{

ret = g_strdup(FS_MOUNT_DEFAULT);

log_debug("Default mount = %s\n", ret);

}

return(ret);

}

{

}

}

}

}

}

char * ip = config_get_kcmdline_string(NETWORK_IP_KEY);

if (ip != NULL)

if(!config_validate_ip(ip))

return(ip);

}

}

char * gw = config_get_kcmdline_string(NETWORK_GATEWAY_KEY);

if (gw != NULL)

return(gw);

}

char * netmask = config_get_kcmdline_string(NETWORK_NETMASK_KEY);

if (netmask != NULL)

return(netmask);

}

}

GKeyFile *settingsfile;

gchar *keyfile;

int dir = 1;

struct stat dir_stat;

if(stat(CONFIG_FILE_DIR, &dir_stat))

{

dir = mkdir(CONFIG_FILE_DIR, 0755);

if(dir < 0)

{

log_warning("Could not create confdir, continuing without configuration!\n");

/* no point in trying to generate the config file if the dir cannot be created */

return;

}

}

settingsfile = g_key_file_new();

g_key_file_set_string(settingsfile, MODE_SETTING_ENTRY, MODE_SETTING_KEY, MODE_DEVELOPER );

keyfile = g_key_file_to_data (settingsfile, NULL, NULL);

if(g_file_set_contents(FS_MOUNT_CONFIG_FILE, keyfile, -1, NULL) == 0)

log_debug("Conffile creation failed. Continuing without configuration!\n");

free(keyfile);

g_key_file_free(settingsfile);

}

static int config_get_conf_int(const gchar *entry, const gchar *key)

{

GKeyFile *settingsfile;

gboolean test = FALSE;

gchar **keys, **origkeys;

int ret = 0;

settingsfile = g_key_file_new();

test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL);

if(!test)

{

log_debug("no conffile, Creating\n");

config_create_conf_file();

}

keys = g_key_file_get_keys (settingsfile, entry, NULL, NULL);

if(keys == NULL)

origkeys = keys;

while (*keys != NULL)

{

if(!strcmp(*keys, key))

{

ret = g_key_file_get_integer(settingsfile, entry, *keys, NULL);

log_debug("%s key value = %d\n", key, ret);

}

keys++;

}

g_strfreev(origkeys);

g_key_file_free(settingsfile);

return(ret);

}

static char * config_get_conf_string(const gchar *entry, const gchar *key)

{

GKeyFile *settingsfile;

gboolean test = FALSE;

gchar **keys, **origkeys, *tmp_char = NULL;

settingsfile = g_key_file_new();

test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL);

if(!test)

{

log_debug("No conffile. Creating\n");

config_create_conf_file();

/* should succeed now */

g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL);

}

keys = g_key_file_get_keys (settingsfile, entry, NULL, NULL);

if(keys == NULL)

origkeys = keys;

while (*keys != NULL)

{

if(!strcmp(*keys, key))

{

tmp_char = g_key_file_get_string(settingsfile, entry, *keys, NULL);

if(tmp_char)

{

log_debug("key %s value = %s\n", key, tmp_char);

}

}

keys++;

}

g_strfreev(origkeys);

g_key_file_free(settingsfile);

return(tmp_char);

int fd;

char cmdLine[1024];

char *ret = NULL;

int len;

gint argc = 0;

gchar **argv = NULL;

gchar **arg_tokens = NULL, **network_tokens = NULL;

GError *optErr = NULL;

int i;

if ((fd = open("/proc/cmdline", O_RDONLY)) < 0)

{

log_debug("could not read /proc/cmdline");

return(ret);

}

len = read(fd, cmdLine, sizeof(cmdLine) - 1);

close(fd);

if (len <= 0)

{

log_debug("kernel command line was empty");

return(ret);

}

if (!g_shell_parse_argv(cmdLine, &argc, &argv, &optErr))

{

g_error_free(optErr);

return(ret);

}

/* find the ip token */

for (i=0; i < argc; i++)

arg_tokens = g_strsplit(argv[i], "=", 2);

if (!g_ascii_strcasecmp(arg_tokens[0], "usb_moded_ip"))

{

network_tokens = g_strsplit(arg_tokens[1], ":", 7);

/* check if it is for the usb or rndis interface */

if(g_strrstr(network_tokens[5], "usb")|| (g_strrstr(network_tokens[5], "rndis")))

{

if(!strcmp(entry, NETWORK_IP_KEY))

{

g_free(ret), ret = g_strdup(network_tokens[0]);

log_debug("Command line ip = %s\n", ret);

}

if(!strcmp(entry, NETWORK_GATEWAY_KEY))

{

/* gateway might be empty, so we do not want to return an empty string */

if(strlen(network_tokens[2]) > 2)

{

g_free(ret), ret = g_strdup(network_tokens[2]);

log_debug("Command line gateway = %s\n", ret);

}

}

if(!strcmp(entry, NETWORK_NETMASK_KEY))

{

g_free(ret), ret = g_strdup(network_tokens[3]);

log_debug("Command line netmask = %s\n", ret);

}

}

}

g_strfreev(arg_tokens);

}

g_strfreev(argv);

g_strfreev(network_tokens);

return(ret);

}

char * config_get_mode_setting(void)

{

char * mode = config_get_kcmdline_string(MODE_SETTING_KEY);

if (mode != NULL)

return(mode);

return(config_get_conf_string(MODE_SETTING_ENTRY, MODE_SETTING_KEY));

/*

* @param settingsfile: already opened settingsfile we want to read an entry from

* @param entry: entry we want to read

* @param key: key value of the entry we want to read

* @new_value: potentially new value we want to compare against

*

*/

int config_value_changed(GKeyFile *settingsfile, const char *entry, const char *key, const char *new_value)

{

char *old_value = g_key_file_get_string(settingsfile, entry, key, NULL);

int changed = (g_strcmp0(old_value, new_value) != 0);

g_free(old_value);

return changed;

}

set_config_result_t config_set_config_setting(const char *entry, const char *key, const char *value)

{

GKeyFile *settingsfile;

gboolean test = FALSE;

set_config_result_t ret = SET_CONFIG_ERROR;

gchar *keyfile;

settingsfile = g_key_file_new();

test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL);

if(test)

{

if(!config_value_changed(settingsfile, entry, key, value))

{

g_key_file_free(settingsfile);

return SET_CONFIG_UNCHANGED;

}

}

else

{

log_debug("No conffile. Creating.\n");

config_create_conf_file();

}

g_key_file_set_string(settingsfile, entry, key, value);

keyfile = g_key_file_to_data (settingsfile, NULL, NULL);

/* free the settingsfile before writing things out to be sure

* the contents will be correctly written to file afterwards.

* Just a precaution. */

g_key_file_free(settingsfile);

if (g_file_set_contents(FS_MOUNT_CONFIG_FILE, keyfile, -1, NULL))

ret = SET_CONFIG_UPDATED;

g_free(keyfile);

return (ret);

return SET_CONFIG_ERROR;

return (config_set_config_setting(MODE_SETTING_ENTRY, MODE_SETTING_KEY, mode));

}

static char * config_make_modes_string(const char *key, const char *mode_name, int include)

{

char *modes_new = 0;

char *modes_old = 0;

gchar **modes_arr = 0;

GString *modes_tmp = 0;

int i;

/* Get current comma separated list of hidden modes */

modes_old = config_get_conf_string(MODE_SETTING_ENTRY, key);

if(!modes_old)

{

modes_old = g_strdup("");

}

if(strlen(modes_arr[i]) == 0)

{

/* Skip any empty strings */

continue;

}

if(!strcmp(modes_arr[i], mode_name))

{

/* When unhiding, just skip all matching entries */

if(!include)

continue;

/* When hiding, keep the 1st match and ignore the rest */

include = 0;

}

if(modes_tmp->len > 0)

modes_tmp = g_string_append(modes_tmp, ",");

modes_tmp = g_string_append(modes_tmp, modes_arr[i]);

}

if(include)

{

/* Adding a hidden mode and no matching entry was found */

if(modes_tmp->len > 0)

modes_tmp = g_string_append(modes_tmp, ",");

modes_tmp = g_string_append(modes_tmp, mode_name);

}

}

if( hidden_modes ) {

ret = config_set_config_setting(MODE_SETTING_ENTRY, MODE_HIDE_KEY, hidden_modes);

}

common_send_hidden_modes_signal();

common_send_supported_modes_signal();

common_send_available_modes_signal();

}

if( hidden_modes ) {

ret = config_set_config_setting(MODE_SETTING_ENTRY, MODE_HIDE_KEY, hidden_modes);

}

common_send_hidden_modes_signal();

common_send_supported_modes_signal();

common_send_available_modes_signal();

}

if(ret == SET_CONFIG_UPDATED) {

char *mode_setting;

const char *current_mode;

config_set_mode_setting(MODE_ASK);

g_free(mode_setting);

if (!strcmp(current_mode, MODE_UNDEFINED)) {

/* Disconnected -> do nothing */

}

/* Invalid mode that is not MODE_ASK or MODE_CHARGING_FALLBACK

* -> switch to MODE_CHARGING_FALLBACK */