usb_moded-configfs.c

/**
 * @file usb_moded-configfs.c
 *
 * Copyright (C) 2018 Jolla. All rights reserved.
 *
 * @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 "usb_moded-configfs.h"

#include <sys/types.h>

#include <stdio.h>
#include <dirent.h>
#include <errno.h>

#include <glib.h>

#include "usb_moded.h"
#include "usb_moded-android.h"
#include "usb_moded-log.h"
#include "usb_moded-modesetting.h"
#include "usb_moded-config-private.h"
#include "usb_moded-mac.h"

/* ========================================================================= *
 * Constants
 * ========================================================================= */

#define FUNCTION_MASS_STORAGE "mass_storage.usb0"
#define FUNCTION_RNDIS        "rndis_bam.rndis"
#define FUNCTION_MTP          "ffs.mtp"

#define CONFIGFS_GADGET        "/config/usb_gadget/g1"
#define CONFIGFS_CONFIG        CONFIGFS_GADGET"/configs/b.1"
#define CONFIGFS_FUNCTIONS     CONFIGFS_GADGET"/functions"
#define CONFIGFS_UDC           CONFIGFS_GADGET"/UDC"
#define CONFIGFS_ID_VENDOR     CONFIGFS_GADGET"/idVendor"
#define CONFIGFS_ID_PRODUCT    CONFIGFS_GADGET"/idProduct"
#define CONFIGFS_MANUFACTURER  CONFIGFS_GADGET"/strings/0x409/manufacturer"
#define CONFIGFS_PRODUCT       CONFIGFS_GADGET"/strings/0x409/product"
#define CONFIGFS_SERIAL        CONFIGFS_GADGET"/strings/0x409/serialnumber"

#define CONFIGFS_RNDIS_WCEIS   CONFIGFS_FUNCTIONS"/rndis_bam.rndis/wceis"
#define CONFIGFS_RNDIS_ETHADDR CONFIGFS_FUNCTIONS"/rndis_bam.rndis/ethaddr"

/* ========================================================================= *
 * Prototypes
 * ========================================================================= */

/* -- configfs -- */

static int         configfs_file_type            (const char *path);
static const char *configfs_function_path        (char *buff, size_t size, const char *func);
static const char *configfs_config_path          (char *buff, size_t size, const char *func);
static const char *configfs_register_function    (const char *function);
#ifdef DEAD_CODE
static bool        configfs_unregister_function  (const char *function);
#endif
static bool        configfs_enable_function      (const char *function);
static bool        configfs_disable_function     (const char *function);
static bool        configfs_disable_all_functions(void);
static char       *configfs_strip                (char *str);
bool               configfs_in_use               (void);
static bool        configfs_probe                (void);
static const char *configfs_udc_enable_value     (void);
static bool        configfs_write_file           (const char *path, const char *text);
static bool        configfs_read_file            (const char *path, char *buff, size_t size);
#ifdef DEAD_CODE
static bool        configfs_read_udc             (char *buff, size_t size);
#endif
static bool        configfs_write_udc            (const char *text);
bool               configfs_set_udc              (bool enable);
bool               configfs_init_values          (void);
bool               configfs_set_charging_mode    (void);
bool               configfs_set_productid        (const char *id);
bool               configfs_set_vendorid         (const char *id);

/* ========================================================================= *
 * Data
 * ========================================================================= */

static int configfs_probed = -1;

/* ========================================================================= *
 * Functions
 * ========================================================================= */

static int configfs_file_type(const char *path)
{
    int type = -1;

    if( !path )
        goto EXIT;

    struct stat st;
    if( lstat(path, &st) == -1 )
        goto EXIT;

    type = st.st_mode & S_IFMT;

EXIT:
    return type;
}

static const char *
configfs_function_path(char *buff, size_t size, const char *func)
{
    snprintf(buff, size, "%s/%s", CONFIGFS_FUNCTIONS, func);
    return buff;
}

static const char *
configfs_config_path(char *buff, size_t size, const char *func)
{
    snprintf(buff, size, "%s/%s", CONFIGFS_CONFIG, func);
    return buff;
}

static const char *
configfs_register_function(const char *function)
{
    const char *res = 0;

    static char fpath[256];
    configfs_function_path(fpath, sizeof fpath, function);

    if( mkdir(fpath, 0775) == -1 && errno != EEXIST ) {
        log_err("%s: mkdir failed: %m", fpath);
        goto EXIT;
    }

    if( configfs_file_type(fpath) != S_IFDIR ) {
        log_err("%s: is not a directory", fpath);
        goto EXIT;
    }

    log_debug("function %s is registered", function);

    res = fpath;

EXIT:
    return res;
}

#ifdef DEAD_CODE
static bool
configfs_unregister_function(const char *function)
{
    bool ack = false;

    char fpath[256];
    configfs_function_path(fpath, sizeof fpath, function);

    if( rmdir(fpath) == -1 && errno != ENOENT ) {
        log_err("%s: rmdir failed: %m", fpath);
        goto EXIT;
    }

    log_debug("function %s is unregistered", function);
    ack = true;

EXIT:
    return ack;
}
#endif

static bool
configfs_enable_function(const char *function)
{
    bool ack = false;

    const char *fpath = configfs_register_function(function);
    if( !fpath ) {
        log_err("function %s is not registered", function);
        goto EXIT;
    }

    char cpath[256];
    configfs_config_path(cpath, sizeof cpath, function);

    switch( configfs_file_type(cpath) ) {
    case S_IFLNK:
        if( unlink(cpath) == -1 ) {
            log_err("%s: unlink failed: %m", cpath);
            goto EXIT;
        }
        /* fall through */
    case -1:
        if( symlink(fpath, cpath) == -1 ) {
            log_err("%s: failed to symlink to %s: %m", cpath, fpath);
            goto EXIT;
        }
        break;
    default:
        log_err("%s: is not a symlink", cpath);
        goto EXIT;
    }

    log_debug("function %s is enabled", function);
    ack = true;

EXIT:
    return ack;
}

static bool
configfs_disable_function(const char *function)
{
    bool ack = false;

    char cpath[256];
    configfs_config_path(cpath, sizeof cpath, function);

    if( configfs_file_type(cpath) != S_IFLNK ) {
        log_err("%s: is not a symlink", cpath);
        goto EXIT;
    }

    if( unlink(cpath) == -1 ) {
        log_err("%s: unlink failed: %m", cpath);
        goto EXIT;
    }

    log_debug("function %s is disabled", function);
    ack = true;

EXIT:
    return ack;
}

static bool
configfs_disable_all_functions(void)
{
    bool  ack = false;
    DIR  *dir = 0;

    if( !(dir = opendir(CONFIGFS_CONFIG)) ) {
        log_err("%s: opendir failed: %m", CONFIGFS_CONFIG);
        goto EXIT;
    }

    ack = true;

    struct dirent *de;
    while( (de = readdir(dir)) ) {
        if( de->d_type != DT_LNK )
            continue;

        if( !configfs_disable_function(de->d_name) )
            ack = false;
    }

    if( ack )
        log_debug("all functions are disabled");

EXIT:
    if( dir )
        closedir(dir);

    return ack;
}

static char *configfs_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;
}

bool
configfs_in_use(void)
{
    if( configfs_probed < 0 )
        log_debug("configfs_in_use() called before configfs_probe()");
    return configfs_probed > 0;
}

static bool
configfs_probe(void)
{
    if( configfs_probed <= 0 ) {
        configfs_probed = access(CONFIGFS_GADGET, F_OK) == 0;
        log_warning("CONFIGFS %sdetected", configfs_probed ? "" : "not ");
    }
    return configfs_in_use();
}

static const char *
configfs_udc_enable_value(void)
{
    static bool  probed = false;
    static char *value  = 0;

    if( !probed ) {
        probed = true;

        /* Find first symlink in /sys/class/udc directory */
        struct dirent *de;
        DIR *dir = opendir("/sys/class/udc");
        if( dir ) {
            while( (de = readdir(dir)) ) {
                if( de->d_type != DT_LNK )
                    continue;
                if( de->d_name[0] == '.' )
                    continue;
                value = strdup(de->d_name);
                break;
            }
            closedir(dir);
        }
    }

    return value ?: "";
}

static bool
configfs_write_file(const char *path, const char *text)
{
    bool ack = false;
    int  fd  = -1;

    if( !path || !text )
        goto EXIT;

    log_debug("WRITE %s '%s'", path, text);

    char buff[64];
    snprintf(buff, sizeof buff, "%s\n", text);
    size_t size = strlen(buff);

    if( (fd = open(path, O_WRONLY)) == -1 ) {
        log_err("%s: can't open for writing: %m", path);
        goto EXIT;
    }

    int rc = write(fd, text, size);
    if( rc == -1 ) {
        log_err("%s: write failure: %m", path);
        goto EXIT;
    }

    if( (size_t)rc != size ) {
        log_err("%s: write failure: partial success", path);
        goto EXIT;
    }

    ack = true;

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

    return ack;
}

static bool
configfs_read_file(const char *path, char *buff, size_t size)
{
    bool ack = false;
    int  fd  = -1;

    if( !path || !buff )
        goto EXIT;

    if( size < 2 )
        goto EXIT;

    if( (fd = open(path, O_RDONLY)) == -1 ) {
        log_err("%s: can't open for reading: %m", path);
        goto EXIT;
    }

    int rc = read(fd, buff, size - 1);
    if( rc == -1 ) {
        log_err("%s: read failure: %m", path);
        goto EXIT;
    }

    buff[rc] = 0;
    configfs_strip(buff);

    ack = true;

    log_debug("READ %s '%s'", path, buff);

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

    return ack;
}

#ifdef DEAD_CODE
static bool
configfs_read_udc(char *buff, size_t size)
{
    return configfs_read_file(CONFIGFS_UDC, buff, size);
}
#endif

static bool
configfs_write_udc(const char *text)
{
    bool ack = false;

    char prev[64];

    if( !configfs_read_file(CONFIGFS_UDC, prev, sizeof prev) )
        goto EXIT;

    if( strcmp(prev, text) ) {
        if( !configfs_write_file(CONFIGFS_UDC, text) )
            goto EXIT;
    }

    ack = true;

EXIT:
    return ack;

}

bool
configfs_set_udc(bool enable)
{
    log_debug("UDC - %s", enable ? "ENABLE" : "DISABLE");

    const char *value = "";

    if( enable )
        value = configfs_udc_enable_value();

    return configfs_write_udc(value);
}

/** initialize the basic configfs values
 */
bool
configfs_init_values(void)
{
    if( !configfs_probe() )
        goto EXIT;

    /* Disable */
    configfs_set_udc(false);

    /* Configure */
    gchar *text;
    if( (text = config_get_android_vendor_id()) ) {
        configfs_write_file(CONFIGFS_ID_VENDOR, text);
        g_free(text);
    }

    if( (text = config_get_android_product_id()) ) {
        configfs_write_file(CONFIGFS_ID_PRODUCT, text);
        g_free(text);
    }

    if( (text = config_get_android_manufacturer()) ) {
        configfs_write_file(CONFIGFS_MANUFACTURER, text);
        g_free(text);
    }

    if( (text = config_get_android_product()) ) {
        configfs_write_file(CONFIGFS_PRODUCT, text);
        g_free(text);
    }

    if( (text = android_get_serial()) ) {
        configfs_write_file(CONFIGFS_SERIAL, text);
        g_free(text);
    }

    /* Prep: charging_only */
    configfs_register_function(FUNCTION_MASS_STORAGE);

    /* Prep: mtp_mode */
    configfs_register_function(FUNCTION_MTP);
    if( access("/dev/mtp/ep0", F_OK) == -1 ) {
        usbmoded_system("/bin/mount -o uid=100000,gid=100000 -t functionfs mtp /dev/mtp");
    }

    /* Prep: developer_mode */
    configfs_register_function(FUNCTION_RNDIS);
    if( (text = mac_read_mac()) ) {
        configfs_write_file(CONFIGFS_RNDIS_ETHADDR, text);
        g_free(text);
    }
    /* For rndis to be discovered correctly in M$ Windows (vista and later) */
    configfs_write_file(CONFIGFS_RNDIS_WCEIS, "1");

    /* Leave disabled, will enable on cable connect detected */
EXIT:
    return configfs_in_use();
}

/* Set a charging mode for the configfs gadget
 *
 * @return true if successful, false on failure
 */
bool
configfs_set_charging_mode(void)
{
    bool ack = false;

    if( !configfs_set_function("mass_storage") )
        goto EXIT;

    /* TODO: make this configurable */
    configfs_set_productid("0AFE");

    if( !configfs_set_udc(true) )
        goto EXIT;

    ack = true;

EXIT:
    log_debug("CONFIGFS %s() -> %d", __func__, ack);
    return ack;
}

/* Set a product id for the configfs gadget
 *
 * @return true if successful, false on failure
 */
bool
configfs_set_productid(const char *id)
{
    bool ack = false;

    if( id && configfs_in_use() ) {
        /* Config files have things like "0A02".
         * Kernel wants to see "0x0a02" ... */
        char *end = 0;
        unsigned num = strtol(id, &end, 16);
        char     str[16];
        if( end > id && *end == 0 ) {
            snprintf(str, sizeof str, "0x%04x", num);
            id = str;
        }
        ack = configfs_write_file(CONFIGFS_ID_PRODUCT, id);
    }

    log_debug("CONFIGFS %s(%s) -> %d", __func__, id, ack);
    return ack;
}

/* Set a vendor id for the configfs gadget
 *
 * @return true if successful, false on failure
 */
bool
configfs_set_vendorid(const char *id)
{
    bool ack = false;

    if( id && configfs_in_use() ) {
        log_debug("%s(%s) was called", __func__, id);

        /* Config files have things like "0A02".
         * Kernel wants to see "0x0a02" ... */
        char *end = 0;
        unsigned num = strtol(id, &end, 16);
        char     str[16];

        if( end > id && *end == 0 ) {
            snprintf(str, sizeof str, "0x%04x", num);
            id = str;
        }

        ack = configfs_write_file(CONFIGFS_ID_VENDOR, id);
    }

    log_debug("CONFIGFS %s(%s) -> %d", __func__, id, ack);
    return ack;
}

static const char *
configfs_map_function(const char *func)
{
    if( !strcmp(func, "mass_storage") )
        func = FUNCTION_MASS_STORAGE;
    else if( !strcmp(func, "rndis") )
        func = FUNCTION_RNDIS;
    else if( !strcmp(func, "mtp") )
        func = FUNCTION_MTP;
    else if( !strcmp(func, "ffs") ) // existing config files ...
        func = FUNCTION_MTP;
    return func;
}

/* Set a function
 *
 * @return true if successful, false on failure
 */
bool
configfs_set_function(const char *func)
{
    bool ack = false;

    if( !func )
        goto EXIT;

    if( !configfs_in_use() )
        goto EXIT;

    /* Normalize names used by usb-moded itself and already
     * existing configuration files etc.
     */
    func = configfs_map_function(func);

    /* HACK: Stop mtp daemon when enabling any other function
     *       after bootup is finished (assumption being it
     *       can't be started before init done and we do not
     *       want to spam bootup journal with warnings.
     */
    if( strcmp(func, FUNCTION_MTP) && usbmoded_init_done_p() )
        usbmoded_system("systemctl-user stop buteo-mtp.service");

    if( !configfs_set_udc(false) )
        goto EXIT;

    if( !configfs_disable_all_functions() )
        goto EXIT;

    if( !configfs_enable_function(func) )
        goto EXIT;

    /* HACK: Start mtp daemon when enabling mtp function.
     *       Then wait "a bit" since udc can't be enabled
     *       before mtpd has written suitable configuration
     *       to control endpoint.
     */
    if( !strcmp(func, FUNCTION_MTP) ) {
        usbmoded_system("systemctl-user start buteo-mtp.service");
        usbmoded_msleep(1500);
    }

    /* Leave disabled, so that caller can adjust attributes
     * etc before enabling */

    ack = true;

EXIT:
    log_debug("CONFIGFS %s(%s) -> %d", __func__, func, ack);
    return ack;
}