/**

@file usb_moded-modesetting.c

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

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

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

@author: Bernd Wachter <bernd.wachter@jollamobile.com>

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

@author: Simo Piiroinen <simo.piiroinen@jollamobile.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 <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <stdio.h>

#include <glib.h>

#include "usb_moded.h"

#include "usb_moded-modules.h"

#include "usb_moded-log.h"

#include "usb_moded-dbus.h"

#include "usb_moded-dbus-private.h"

#include "usb_moded-appsync.h"

#include "usb_moded-config.h"

#include "usb_moded-modesetting.h"

#if LOG_ENABLE_DEBUG

static char *strip(char *str)

{

unsigned char *src = (unsigned char *)str;

unsigned char *dst = (unsigned char *)str;

while( *src > 0 && *src <= 32 ) ++src;

for( ;; )

{

while( *src > 32 ) *dst++ = *src++;

while( *src > 0 && *src <= 32 ) ++src;

if( *src == 0 ) break;

*dst++ = ' ';

}

*dst = 0;

return str;

}

static char *read_from_file(const char *path, size_t maxsize)

{

int fd = -1;

ssize_t done = 0;

char *data = 0;

char *text = 0;

if((fd = open(path, O_RDONLY)) == -1)

{

/* Silently ignore things that could result

* from missing / read-only files */

if( errno != ENOENT && errno != EACCES )

log_warning("%s: open: %m", path);

goto cleanup;

}

if( !(data = malloc(maxsize + 1)) )

goto cleanup;

if((done = read(fd, data, maxsize)) == -1)

{

log_warning("%s: read: %m", path);

goto cleanup;

}

text = realloc(data, done + 1), data = 0;

text[done] = 0;

strip(text);

cleanup:

free(data);

if(fd != -1) close(fd);

return text;

}

#endif /* LOG_ENABLE_DEBUG */

int write_to_file(const char *path, const char *text)

{

int err = -1;

int fd = -1;

size_t todo = 0;

/* if either path or the text to be written are not there

we return an error */

if(!text || !path)

return err;

#if LOG_ENABLE_DEBUG

if(log_level >= LOG_DEBUG)

{

char *prev = read_from_file(path, 0x1000);

log_debug("WRITE '%s' : '%s' --> '%s'", path, prev ?: "???", text);

free(prev);

}

#endif

/* no O_CREAT -> writes only to already existing files */

if( (fd = TEMP_FAILURE_RETRY(open(path, O_WRONLY))) == -1 )

{

goto cleanup;

}

while( todo > 0 )

{

ssize_t n = TEMP_FAILURE_RETRY(write(fd, text, todo));

if( n < 0 )

{

goto cleanup;

}

todo -= n;

text += n;

}

err = 0;

cleanup:

if( fd != -1 ) TEMP_FAILURE_RETRY(close(fd));

return err;

}

static gboolean network_retry(gpointer data)

{

usb_network_up(data);

return(FALSE);

}

{

gchar *command;

gchar **mounts;

int ret = 0, i = 0, mountpoints = 0, fua = 0, try = 0;

/* send unmount signal so applications can release their grasp on the fs, do this here so they have time to act */

usb_moded_send_signal(USB_PRE_UNMOUNT);

fua = find_sync();

mount = find_mounts();

if(mount)

{

mounts = g_strsplit(mount, ",", 0);

/* check amount of mountpoints */

for(i=0 ; mounts[i] != NULL; i++)

{

mountpoints++;

}

if(strcmp(data->mode_module, MODULE_NONE))

{

/* check if the file storage module has been loaded with sufficient luns in the parameter,

if not, unload and reload or load it. Since mountpoints start at 0 the amount of them is one more than their id */

sprintf(command2, "/sys/devices/platform/musb_hdrc/gadget/gadget-lun%d/file", (mountpoints - 1) );

if(access(command2, R_OK) == -1)

{

log_debug("%s does not exist, unloading and reloading mass_storage\n", command2);

usb_moded_unload_module(MODULE_MASS_STORAGE);

sprintf(command2, "modprobe %s luns=%d \n", MODULE_MASS_STORAGE, mountpoints);

log_debug("usb-load command = %s \n", command2);

if(ret)

return(ret);

}

}

/* umount filesystems */

for(i=0 ; mounts[i] != NULL; i++)

{

/* check if filesystem is mounted or not, if ret = 1 it is already unmounted */

real_path = realpath(mounts[i], NULL);

if(real_path)

mountpath = real_path;

else

mountpath = mounts[i];

umount: command = g_strconcat("mount | grep ", mountpath, NULL);

g_free(command);

if(!ret)

{

g_free(command);

if(ret != 0)

{

{

try++;

sleep(1);

log_err("Umount failed. Retrying\n");

goto umount;

}

else

{

log_err("Unmounting %s failed\n", mount);

usb_moded_send_error_signal(UMOUNT_ERROR);

return(ret);

}

}

}

else

/* already unmounted. Set return value to 0 since there is no error */

ret = 0;

}

if(strcmp(data->mode_module, MODULE_NONE))

{

sprintf(command2, "echo %i > /sys/devices/platform/musb_hdrc/gadget/gadget-lun%d/nofua", fua, i);

log_debug("usb lun = %s active\n", command2);

sprintf(command2, "/sys/devices/platform/musb_hdrc/gadget/gadget-lun%d/file", i);

log_debug("usb lun = %s active\n", command2);

write_to_file(command2, mounts[i]);

}

else

{

write_to_file("/sys/class/android_usb/android0/enable", "0");

write_to_file("/sys/class/android_usb/android0/functions", "mass_storage");

//write_to_file("/sys/class/android_usb/f_mass_storage/lun/nofua", fua);

write_to_file("/sys/class/android_usb/f_mass_storage/lun/file", mount);

write_to_file("/sys/class/android_usb/android0/enable", "1");

}

}

g_strfreev(mounts);

if(real_path)

free(real_path);

}

/* only send data in use signal in case we actually succeed */

if(!ret)

usb_moded_send_signal(DATA_IN_USE);

return(ret);

}

{

gchar *command;

gchar **mounts;

int ret = 1, i = 0;

mount = find_mounts();

if(mount)

{

mounts = g_strsplit(mount, ",", 0);

for(i=0 ; mounts[i] != NULL; i++)

{

/* check if it is still or already mounted, if so (ret==0) skip mounting */

real_path = realpath(mounts[i], NULL);

if(real_path)

mountpath = real_path;

else

mountpath = mounts[i];

command = g_strconcat("mount | grep ", mountpath, NULL);

g_free(command);

if(ret)

{

/* mount returns 0 if success */

if(ret != 0 )

{

log_err("Mounting %s failed\n", mount);

if(ret)

{

mount = find_alt_mount();

if(mount)

{

command = g_strconcat("mount -t tmpfs tmpfs -o ro --size=512K ", mount, NULL);

log_debug("Total failure, mount ro tmpfs as fallback\n");

g_free(command);

}

}

}

}

if(data != NULL)

{

log_debug("Disable android mass storage\n");

write_to_file("/sys/class/android_usb/f_mass_storage/lun/file", "0");

write_to_file("/sys/class/android_usb/android0/enable", "0");

}

}

else

{

sprintf(command2, "echo \"\" > /sys/devices/platform/musb_hdrc/gadget/gadget-lun%d/file", i);

log_debug("usb lun = %s inactive\n", command2);

}

g_strfreev(mounts);

if(real_path)

free(real_path);

}

return(ret);

}

{

FILE *stream = 0;

gchar *lsof_command = 0;

int count = 0;

lsof_command = g_strconcat("lsof ", mountpoint, NULL);

if( (stream = popen(lsof_command, "r")) )

{

char *text = 0;

size_t size = 0;

while( getline(&text, &size, stream) >= 0 )

{

/* skip the first line as it does not contain process info */

if(count != 0)

{

gchar **split = 0;

split = g_strsplit((const gchar*)text, " ", 2);

usb_moded_send_error_signal(split[0]);

g_strfreev(split);

}

count++;

}

pclose(stream);

}

g_free(lsof_command);

if(try == 2)

log_err("Setting Mass storage blocked. Giving up.\n");

}

struct mode_list_elem *data;

data = get_usb_mode_data();

}

{

log_debug("Appsync failure");

{

write_to_file(data->softconnect_path, data->softconnect_disconnect);

}

if(data->android_extra_sysfs_value && data->android_extra_sysfs_path)

{

}

if(data->android_extra_sysfs_value2 && data->android_extra_sysfs_path2)

{

write_to_file(data->android_extra_sysfs_path2, data->android_extra_sysfs_value2);

}

if(data->sysfs_path)

{

write_to_file(data->sysfs_path, data->sysfs_value);

}

if(data->idProduct)

{

/* only works for android since the idProduct is a module parameter */

set_android_productid(data->idProduct);

}

if(data->idVendorOverride)

{

/* only works for android since the idProduct is a module parameter */

set_android_vendorid(data->idVendorOverride);

}

if(data->softconnect)

{

/* try a second time to bring up the network if it failed the first time,

this can happen with functionfs based gadgets (which is why we sleep for a bit */

if(delayed_network)

g_source_remove(delayed_network);

}

/* Needs to be called before application post synching so

that the dhcp server has the right config */

if(data->nat || data->dhcp_server)

/* no need to execute the post sync if there was an error setting the mode */

if(data->appsync && !ret)

{

/* let's sleep for a bit (350ms) to allow interfaces to settle before running postsync */

usleep(350000);

#ifdef CONNMAN

if(data->connman_tethering)

connman_set_tethering(data->connman_tethering, TRUE);

#endif

if(ret)

usb_moded_send_error_signal(MODE_SETTING_FAILED);

return(ret);

void unset_dynamic_mode(void)

{

struct mode_list_elem *data;

data = get_usb_mode_data();

if(delayed_network)

{

g_source_remove(delayed_network);

delayed_network = 0;

}

/* the modelist could be empty */

if(!data)

return;

if(!strcmp(data->mode_name, MODE_MASS_STORAGE))

{

return;

}

#ifdef CONNMAN

if(data->connman_tethering)

connman_set_tethering(data->connman_tethering, FALSE);

#endif

if(data->network)

{

usb_network_down(data);

}

{

write_to_file(data->softconnect_path, data->softconnect_disconnect);

}

if(data->sysfs_path)

{

write_to_file(data->sysfs_path, data->sysfs_reset_value);

}

/* restore vendorid if the mode had an override */

if(data->idVendorOverride)

{

char *id;

id = get_android_vendor_id();

set_android_vendorid(id);

g_free(id);

}

/* enable after the changes have been made */

if(data->softconnect)

{

write_to_file(data->softconnect_path, data->softconnect);

}

/** clean up mode changes or extra actions to perform after a mode change

* @param module Name of module currently in use

* @return 0 on success, non-zero on failure

*

*/

int usb_moded_mode_cleanup(const char *module)

{

log_debug("Cleaning up mode\n");

if(!module)

{

return 0;

}

/* no clean-up needs to be done when we come from charging mode. We need

to check since we use fake mass-storage for charging */

}