Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e4da6a1a authored by San Mehat's avatar San Mehat Committed by The Android Open Source Project
Browse files

am cb9ae42c: system/core: Remove old mountd code 

Merge commit 'cb9ae42c'

* commit 'cb9ae42c':
  system/core: Remove old mountd code
parents 9fe0f0d1 cb9ae42c

mountd/ASEC.c

deleted100644 → 0
+0 −774
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * 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.

 */



/*

** Android Secure External Cache 

*/



#include "mountd.h"



#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#include <dirent.h>

#include <ctype.h>

#include <pwd.h>

#include <stdlib.h>

#include <poll.h>

#include <errno.h>



#include <sys/ioctl.h>

#include <sys/mount.h>

#include <sys/stat.h>



#include <linux/dm-ioctl.h>

#include <linux/loop.h>



#include <cutils/properties.h>

#include <cutils/misc.h>



#include "ASEC.h"



//#define MODULE_FAILURE_IS_FATAL



extern int init_module(void *, unsigned long, const char *);

extern int delete_module(const char *, unsigned int);



struct asec_context

{

    char *name;           // Device mapper volume name

    char *srcPath;        // Path to the source (original) mount

    char *backingFile;    // Name of the image file

    unsigned int sectors; // Number of sectors

    char *dstPath;        // Destination mount point

    char *crypt;          // Crypt options



    boolean needs_format;

    boolean started;

    int cacheFd;

    int lo_num;

    int dm_num;

    unsigned char key[16];

};



static const char *MODULES[] = { "dm_mod", "crypto", "crypto_algapi", "crypto_blkcipher", 

                                 "cryptomgr", "dm_crypt", "jbd",  

                                 "twofish_common", "twofish", "cbc",

                                 "mbcache", "ext3",

                                 NULL };

static const char KEY_PATH[] = "/data/system/asec.key";

static const char MODULE_PATH[] = "/system/lib/modules";

static const char MKE2FS_PATH[] = "/system/bin/mke2fs";

static const char E2FSCK_PATH[] = "/system/bin/e2fsck";



boolean AsecIsStarted(void *Handle)

{

    struct asec_context *ctx = (struct asec_context *) Handle;



    return ctx->started;

}



const char *AsecMountPoint(void *Handle)

{

    struct asec_context *ctx = (struct asec_context *) Handle;



    return ctx->dstPath;

}



static boolean AsecIsEnabled()

{

    char value[PROPERTY_VALUE_MAX];

    int  enabled;



    property_get(ASEC_ENABLED, value, "0");



    if (atoi(value) == 1)

        return true;

    return false;

}



void *AsecInit(const char *Name, const char *SrcPath, const char *BackingFile,

               const char *Size, const char *DstPath, const char *Crypt)

{

    struct asec_context *ctx;



    if (!AsecIsEnabled())

        return NULL;



    LOG_ASEC("AsecInit(%s, %s, %s, %s, %s, %s):\n",

             Name, SrcPath, BackingFile, Size, DstPath, Crypt);



    if (!Name || !SrcPath || !BackingFile || !Size || !DstPath || !Crypt) {

        LOG_ERROR("AsecInit(): Invalid arguments\n");

        return NULL;

    }



    if (!(ctx = malloc(sizeof(struct asec_context)))) {

        LOG_ERROR("AsecInit(): Out of memory\n");

        return NULL;

    }



    memset(ctx, 0, sizeof(struct asec_context));

    ctx->name = strdup(Name);

    ctx->srcPath = strdup(SrcPath);

    ctx->backingFile = strdup(BackingFile);

    ctx->sectors = atoi(Size);

    ctx->dstPath = strdup(DstPath);

    ctx->crypt = strdup(Crypt);

    return ctx;

}



void AsecDeinit(void *Handle)

{

    struct asec_context *ctx = (struct asec_context *) Handle;



    free(ctx->name);

    free(ctx->srcPath);

    free(ctx->backingFile);

    free(ctx->dstPath);

    free(ctx->crypt);



    free(ctx);

}



static int AsecLoadModules()

{

    int i;



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

	const char *moduleName = MODULES[i];

        char moduleFile[255];

        int rc = 0;

        void *module;

        unsigned int size;



        sprintf(moduleFile, "%s/%s.ko", MODULE_PATH, moduleName);

        module = load_file(moduleFile, &size);

        if (!module) {

            LOG_ERROR("Failed to load module %s (%d)\n", moduleFile, errno);

            return -1;

        }



        rc = init_module(module, size, "");

        free(module);

        if (rc && errno != EEXIST) {

            LOG_ERROR("Failed to init module %s (%d)\n", moduleFile, errno);

            return -errno;

        }

    }

    return 0;

}



static int AsecUnloadModules()

{

    int i, j, rc;



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



    for (j = (i - 1); j >= 0; j--) {

	const char *moduleName = MODULES[j];

        int maxretry = 10;

        while(maxretry-- > 0) {

            rc = delete_module(moduleName, O_NONBLOCK | O_EXCL);

            if (rc < 0 && errno == EAGAIN)

                usleep(500000);

            else

                break;

        }

        if (rc != 0) {

            LOG_ERROR("Failed to unload module %s\n", moduleName);

            return -errno;

        }

    }

    return 0;

}



static int AsecGenerateKey(struct asec_context *ctx)

{

    LOG_ASEC("AsecGenerateKey():\n");



    memset((void *) ctx->key, 0x69, sizeof(ctx->key));

    return 0;

}



static int AsecLoadGenerateKey(struct asec_context *ctx)

{

    int fd;

    int rc = 0;



    if ((fd = open(KEY_PATH, O_RDWR | O_CREAT, 0600)) < 0) {

        LOG_ERROR("Error opening / creating keyfile (%d)\n", errno);

        return -errno;

    }



    if (read(fd, ctx->key, sizeof(ctx->key)) != sizeof(ctx->key)) {

        LOG_ASEC("Generating key\n");

        if ((rc = AsecGenerateKey(ctx)) < 0) {

            LOG_ERROR("Error generating key (%d)\n", rc);

            goto out;

        }

        if (write(fd, ctx->key, sizeof(ctx->key)) != sizeof(ctx->key)) {

            LOG_ERROR("Error writing keyfile (%d)\n", errno);

            rc = -1;

            goto out;

        }

    }

    

 out:

    close (fd);

    return rc;

}



static int AsecFormatFilesystem(struct asec_context *ctx)

{

    char cmdline[255];

    int rc;



    sprintf(cmdline,

            "%s -b 4096 -m 1 -j -L \"%s\" /dev/block/dm-%d",

            MKE2FS_PATH, ctx->name, ctx->dm_num);



    LOG_ASEC("Formatting filesystem (%s)\n", cmdline);

    // XXX: PROTECT FROM VIKING KILLER

    if ((rc = system(cmdline)) < 0) {

        LOG_ERROR("Error executing format command (%d)\n", errno);

        return -errno;

    }



    rc = WEXITSTATUS(rc);



    if (!rc) {

        LOG_ASEC("Format completed\n");

    } else {

        LOG_ASEC("Format failed (%d)\n", rc);

    }



    return rc;

}



static int AsecCheckFilesystem(struct asec_context *ctx)

{

    char cmdline[255];

    int rc;



    sprintf(cmdline, "%s -p /dev/block/dm-%d", E2FSCK_PATH, ctx->dm_num);



    LOG_ASEC("Checking filesystem (%s)\n", cmdline);

    // XXX: PROTECT FROM VIKING KILLER

    if ((rc = system(cmdline)) < 0) {

        LOG_ERROR("Error executing check command (%d)\n", errno);

        return -errno;

    }



    rc = WEXITSTATUS(rc);



    if (rc == 0) {

        LOG_ASEC("ASEC volume '%s' had no errors\n", ctx->name);

    } else if (rc == 1) {

        LOG_ASEC("ASEC volume '%s' had corrected errors\n", ctx->name);

        rc = 0;

    } else if (rc == 2) {

        LOG_ERROR("ASEC volume '%s' had corrected errors (system should be rebooted)\n", ctx->name);

    } else if (rc == 4) {

        LOG_ERROR("ASEC volume '%s' had uncorrectable errors\n", ctx->name);

    } else if (rc == 8) {

        LOG_ERROR("Operational error while checking volume '%s'\n", ctx->name);

    } else {

        LOG_ERROR("Unknown e2fsck exit code (%d)\n", rc);

    }

    return rc;

}



static int AsecOpenCreateCache(struct asec_context *ctx)

{

    char filepath[255];



    sprintf(filepath, "%s/%s", ctx->srcPath, ctx->backingFile);



    if ((ctx->cacheFd = open(filepath, O_RDWR)) < 0) {

        if (errno == ENOENT) {

            int rc = 0;



            LOG_ASEC("Creating cache file (%u sectors)\n", ctx->sectors);

            if ((ctx->cacheFd = creat(filepath, 0600)) < 0) {

                LOG_ERROR("Error creating cache (%d)\n", errno);

                return -errno;

            }

            if (ftruncate(ctx->cacheFd, ctx->sectors * 512) < 0) {

                LOG_ERROR("Error truncating cache (%d)\n", errno);

                close(ctx->cacheFd);

                unlink(filepath);

                return -errno;

            }

            LOG_ASEC("Cache created (%u sectors) \n", ctx->sectors);

            close(ctx->cacheFd); // creat() is WRONLY

           

            if ((ctx->cacheFd = open(filepath, O_RDWR)) < 0) {

               LOG_ERROR("Error opening cache file (%d)\n", errno);

                close(ctx->cacheFd);

                unlink(filepath);

                return -errno;

            }



            ctx->needs_format = 1;

        } else

            return -errno;

    } else {

        struct stat stat_buf;



        if (fstat(ctx->cacheFd, &stat_buf) < 0) {

            LOG_ERROR("Failed to fstat cache (%d)\n", errno);

            close(ctx->cacheFd);

            return -errno;

        }

        if (stat_buf.st_size != ctx->sectors * 512) {

            LOG_ERROR("Cache size %lld != configured size %u\n",

                      stat_buf.st_size, ctx->sectors * 512);

        }



        // XXX: Verify volume label matches ctx->name

    }



    return 0;

}



static void AsecCloseCache(struct asec_context *ctx)

{

    close(ctx->cacheFd);

}



static void *_align(void *ptr, unsigned int a)

{

        register unsigned long agn = --a;



        return (void *) (((unsigned long) ptr + agn) & ~agn);

}



static struct dm_ioctl *_dm_ioctl_setup(struct asec_context *ctx, int flags)

{

    void *buffer;

    void *p;

    const size_t min_size = 16 * 1024;

    size_t len = sizeof(struct dm_ioctl);

    struct dm_ioctl *io;

    struct dm_target_spec *tgt;

    int i;

    char params[1024];

    char key[80];



    key[0] = '\0';



    for (i = 0; i < (int) sizeof(ctx->key); i++) {

        char tmp[8];



        sprintf(tmp, "%02x", ctx->key[i]);

        strcat(key, tmp);

    }



    // XXX: Handle ctx->crypt 

    sprintf(params, "twofish %s 0 /dev/block/loop%d 0", key, ctx->lo_num);

 

    if (len < min_size)

        len = min_size;



    if (!(buffer = malloc(len))) {

        LOG_ERROR("Unable to allocate memory\n");

        return NULL;

    }



    memset(buffer, 0, len);

    io = buffer;

    tgt = (struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)];

    

    io->version[0] = 4;

    io->version[1] = 0;

    io->version[2] = 0;



    io->data_size = len;

    io->data_start = sizeof(struct dm_ioctl);



    io->flags = flags;

    io->dev = 0; 



    io->target_count = 1;

    io->event_nr = 1;

    strncpy(io->name, ctx->name, sizeof(io->name));



    tgt->status = 0;

    tgt->sector_start = 0;

    tgt->length = ctx->sectors;

    strncpy(tgt->target_type, "crypt", sizeof(tgt->target_type));



    p = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);

    strcpy((char *) p, params);

    p+= strlen(params) + 1;



    p = _align(p, 8);

    tgt->next = p - buffer;



    return io;

}



static int FindNextAvailableDm()

{

    int i;



    for (i = 0; i < 8; i++) {

        char path[255];

        sprintf(path, "/dev/block/dm-%d", i);

        if ((access(path, F_OK) < 0) && (errno == ENOENT))

            return i;

    }



    LOG_ERROR("Out of device mapper numbers\n");

    return -1;

}



static int AsecCreateDeviceMapping(struct asec_context *ctx)

{

    struct dm_ioctl       *io;

    int                   dmFd;

    int                   rc = 0;



    ctx->dm_num = FindNextAvailableDm();



    if ((dmFd = open("/dev/device-mapper", O_RDWR)) < 0) {

        LOG_ERROR("Error opening device mapper (%d)\n", errno);

        return -errno;

    }



    if (!(io = _dm_ioctl_setup(ctx, 0))) {

        LOG_ERROR("Unable to setup ioctl (out of memory)\n");

        close(dmFd);

        return -ENOMEM;

    }



    if ((rc = ioctl(dmFd, DM_DEV_CREATE, io)) < 0) {

        LOG_ERROR("device-mapper create ioctl failed (%d)\n", errno);

        rc = -errno;

        goto out_free;

    } 



    free(io);



    if (!(io = _dm_ioctl_setup(ctx, DM_STATUS_TABLE_FLAG))) {

        LOG_ERROR("Unable to setup ioctl (out of memory)\n");

        rc = -ENOMEM;

        goto out_nofree;

    }

 

    if ((rc = ioctl(dmFd, DM_TABLE_LOAD, io)) < 0) {

        LOG_ERROR("device-mapper load ioctl failed (%d)\n", errno);

        rc = -errno;

        goto out_free;

    }



    free(io);

 

    if (!(io = _dm_ioctl_setup(ctx, 0))) {

        LOG_ERROR("Unable to setup ioctl (out of memory)\n");

        rc = -ENOMEM;

        goto out_nofree;

    }



    if ((rc = ioctl(dmFd, DM_DEV_SUSPEND, io)) < 0) {

        LOG_ERROR("device-mapper resume ioctl failed (%d)\n", errno);

        rc = -errno;

        goto out_free;

    }



out_free:

    free (io);

out_nofree:

    close (dmFd);

    return rc;

}



static int AsecDestroyDeviceMapping(struct asec_context *ctx)

{

    struct dm_ioctl       *io;

    int                   dmFd;

    int                   rc = 0;



    if ((dmFd = open("/dev/device-mapper", O_RDWR)) < 0) {

        LOG_ERROR("Error opening device mapper (%d)\n", errno);

        return -errno;

    }



    if (!(io = _dm_ioctl_setup(ctx, DM_PERSISTENT_DEV_FLAG))) {

        LOG_ERROR("Unable to setup ioctl (out of memory)\n");

        rc = -ENOMEM;

        goto out_nofree;

    }



    if ((rc = ioctl(dmFd, DM_DEV_REMOVE, io)) < 0) {

        LOG_ERROR("device-mapper remove ioctl failed (%d)\n", errno);

        rc = -errno;

        goto out_free;

    } 



out_free:

    free (io);

out_nofree:

    close (dmFd);

    return rc;

}



static int AsecMountCache(struct asec_context *ctx)

{

    int flags = MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_NOATIME | MS_NODIRATIME;

    char devname[255];



    if (access(ctx->dstPath, R_OK)) {

        LOG_ERROR("Destination mount point '%s' unavailable (%d)\n", ctx->dstPath, errno);

        return -errno;

    }



    sprintf(devname, "/dev/block/dm-%d", ctx->dm_num);



    if (mount(devname, ctx->dstPath, "ext3", flags, NULL)) {

        LOG_ERROR("ASEC mount failed (%d)\n", errno);

        return -errno;

    }

    

    return 0;

}



static int AsecUnmountCache(struct asec_context *ctx)

{

    if (umount(ctx->dstPath)) {

        if (errno == EBUSY) {

            LOG_ASEC("ASEC volume '%s' still busy\n", ctx->name);

        } else {

            LOG_ERROR("ASEC umount failed (%d)\n", errno);

        }

        return -errno;

    }

    LOG_ASEC("ASEC volume '%s' unmounted\n", ctx->name);

    return 0;

}



static int FindNextAvailableLoop()

{

    int i;



    for (i = 0; i < MAX_LOOP; i++) {

        struct loop_info info;

        char devname[255];

        int fd;



        sprintf(devname, "/dev/block/loop%d", i);



        if ((fd = open(devname, O_RDONLY)) < 0) {

            LOG_ERROR("Unable to open %s (%d)\n", devname, errno);

            return -errno;

        }



        if (ioctl(fd, LOOP_GET_STATUS, &info) < 0) {

            close(fd);



            if (errno == ENXIO)

                return i;



            LOG_ERROR("Unable to get loop status for %s (%d)\n", devname, errno);

            return -errno;

        }

        close(fd);

    }

    return -ENXIO;

}



static int AsecCreateLoop(struct asec_context *ctx)

{

    char devname[255];

    int device_fd;

    int rc = 0;



    ctx->lo_num = FindNextAvailableLoop();

    if (ctx->lo_num < 0) {

        LOG_ERROR("No loop devices available\n");

        return -ENXIO;

    }



    sprintf(devname, "/dev/block/loop%d", ctx->lo_num);

    device_fd = open(devname, O_RDWR);

    if (device_fd < 0) {

        LOG_ERROR("failed to open loop device (%d)\n", errno);

        return -errno;

    }



    if (ioctl(device_fd, LOOP_SET_FD, ctx->cacheFd) < 0) {

        LOG_ERROR("loop_set_fd ioctl failed (%d)\n", errno);

        rc = -errno;

    }

    close(device_fd);

    return rc;

}



static int AsecDestroyLoop(struct asec_context *ctx)

{

    char devname[255];

    int device_fd;

    int rc = 0;



    sprintf(devname, "/dev/block/loop%d", ctx->lo_num);

    device_fd = open(devname, O_RDONLY);

    if (device_fd < 0) {

        LOG_ERROR("Failed to open loop (%d)\n", errno);

        return -errno;

    }



    if (ioctl(device_fd, LOOP_CLR_FD, 0) < 0) {

        LOG_ERROR("Failed to destroy loop (%d)\n", errno);

        rc = -errno;

    }



    close(device_fd);

    return rc;

}



int AsecStart(void *Handle)

{

    struct asec_context *ctx = (struct asec_context *) Handle;

    char value[PROPERTY_VALUE_MAX];

    int rc = 0;



    if (!ctx)

        return -EINVAL;



    if (ctx->started)

        return -EBUSY;



    LOG_ASEC("AsecStart(%s):\n", ctx->name);



    NotifyAsecState(ASEC_BUSY, ctx->dstPath);



    if ((rc = AsecLoadModules()) < 0) {

        LOG_ERROR("AsecStart: Failed to load kernel modules\n");

#ifdef MODULE_FAILURE_IS_FATAL

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	return rc;

#endif

    }



    if ((rc = AsecLoadGenerateKey(ctx))) {

        LOG_ERROR("AsecStart: Failed to load / generate key\n");

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	return rc;

    }

    

    if ((rc = AsecOpenCreateCache(ctx)) < 0) {

        LOG_ERROR("AsecStart: Failed to open / create cache\n");

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	return rc;

    }



    if ((rc = AsecCreateLoop(ctx)) < 0) {

        LOG_ERROR("AsecStart: Failed to create loop\n");

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	goto fail_closecache;

    }



    if ((rc = AsecCreateDeviceMapping(ctx)) < 0) {

        LOG_ERROR("AsecStart: Failed to create devmapping (%d)\n", rc);

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

        goto fail_destroyloop;

    }

    

    if (ctx->needs_format) {

        if ((rc = AsecFormatFilesystem(ctx))) {

            LOG_ERROR("AsecStart: Failed to format cache (%d)\n", rc);

            NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

            goto fail_destroydm;

        }

        ctx->needs_format = 0;

    } else {

        if ((rc = AsecCheckFilesystem(ctx))) {

            LOG_ERROR("AsecStart: Failed to check filesystem (%d)\n", rc);

            NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

            goto fail_destroydm;

        }

    }



    if ((rc = AsecMountCache(ctx)) < 0) {

        LOG_ERROR("AsecStart: Failed to mount cache (%d)\n", rc);

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

        goto fail_destroydm;

    }

    

    NotifyAsecState(ASEC_AVAILABLE, ctx->dstPath);

    ctx->started = true;



    return rc;



 fail_destroydm:

    AsecDestroyDeviceMapping(ctx);

 fail_destroyloop:

    AsecDestroyLoop(ctx);

 fail_closecache:

    AsecCloseCache(ctx);

    return rc;

}



int AsecStop(void *Handle)

{

    struct asec_context *ctx = (struct asec_context *) Handle;

    int rc = 0;



    if (!ctx->started)

        return -EINVAL;



    LOG_ASEC("AsecStop(%s):\n", ctx->name);



    NotifyAsecState(ASEC_BUSY, ctx->dstPath);



    if ((rc = AsecUnmountCache(ctx)) < 0) {

        LOG_ERROR("AsecStop: Failed to unmount cache (%d)\n", rc);

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	return rc;

    }



    if ((rc = AsecDestroyDeviceMapping(ctx)) < 0) {

        LOG_ERROR("AsecStop: Failed to destroy devmapping (%d)\n", rc);

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	return rc;

    }



    if ((rc = AsecDestroyLoop(ctx)) < 0) {

        LOG_ERROR("AsecStop: Failed to destroy loop device (%d)\n", rc);

        NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	return rc;

    }



    AsecCloseCache(ctx);

 

    if ((rc = AsecUnloadModules()) < 0) {

        if (rc == -EAGAIN) {

            LOG_ASEC("AsecStop: Kernel modules still in use\n");

        } else {

            LOG_ERROR("AsecStop: Failed to unload kernel modules (%d)\n", rc);

#ifdef MODULE_FAILURE_IS_FATAL

            NotifyAsecState(ASEC_FAILED_INTERR, ctx->dstPath);

	    return rc;

#endif

        }

    }



    ctx->started = false;

    NotifyAsecState(ASEC_DISABLED, ctx->dstPath);

    return rc;

}

mountd/ASEC.h

deleted100644 → 0
+0 −66
Original line number Diff line number Diff line 
#ifndef _ASEC_H

#define _ASEC_H



#define ASEC_STORES_MAX 4

#define MAX_LOOP 8



typedef enum AsecState {

    // Feature disabled

    ASEC_DISABLED,



    // Feature enabled and operational

    ASEC_AVAILABLE,



    // Busy

    ASEC_BUSY,



    // Internal Error

    ASEC_FAILED_INTERR,



    // No media available

    ASEC_FAILED_NOMEDIA,



    // Media is corrupt

    ASEC_FAILED_BADMEDIA,



    // Key mismatch

    ASEC_FAILED_BADKEY,

} AsecState;



/*

 * ASEC commands

 */

#define ASEC_CMD_SEND_STATUS		"asec_send_status"

#define ASEC_CMD_ENABLE			"asec_enable"

#define ASEC_CMD_DISABLE		"asec_disable"



/*

 * ASEC events

 */



// These events correspond to the states in the AsecState enum.

// A path to the ASEC mount point follows the colon

#define ASEC_EVENT_DISABLED		"asec_disabled:"

#define ASEC_EVENT_AVAILABLE		"asec_available:"

#define ASEC_EVENT_BUSY			"asec_busy:"

#define ASEC_EVENT_FAILED_INTERR	"asec_failed_interror:"

#define ASEC_EVENT_FAILED_NOMEDIA	"asec_failed_nomedia"

#define ASEC_EVENT_FAILED_BADMEDIA	"asec_failed_badmedia:"

#define ASEC_EVENT_FAILED_BADKEY	"asec_failed_badkey:"



/*

 * System Properties

 */



#define ASEC_ENABLED			"asec.enabled"



#define ASEC_STATUS			"ro.asec.status"

#define ASEC_STATUS_DISABLED		"disabled"

#define ASEC_STATUS_AVAILABLE		"available"

#define ASEC_STATUS_BUSY			"busy"

#define ASEC_STATUS_FAILED_INTERR	"internal_error"

#define ASEC_STATUS_FAILED_NOMEDIA	"no_media"

#define ASEC_STATUS_FAILED_BADMEDIA	"bad_media"

#define ASEC_STATUS_FAILED_BADKEY	"bad_key"



#endif

mountd/Android.mk

deleted100644 → 0
+0 −22
Original line number Diff line number Diff line 
LOCAL_PATH:= $(call my-dir)



include $(CLEAR_VARS)



LOCAL_SRC_FILES:=        \

    AutoMount.c          \

    ProcessKiller.c      \

    Server.c             \

    mountd.c		 \

    ASEC.c		 \

    logwrapper.c



LOCAL_MODULE:= mountd



LOCAL_C_INCLUDES := $(KERNEL_HEADERS)



LOCAL_CFLAGS := -DCREATE_MOUNT_POINTS=0



LOCAL_SHARED_LIBRARIES := libcutils



# disabled - we are using vold now instead

# include $(BUILD_EXECUTABLE)

mountd/AutoMount.c

deleted100644 → 0
+0 −1062

File deleted.

Preview size limit exceeded, changes collapsed.

mountd/MODULE_LICENSE_APACHE2

deleted100644 → 0
+0 −0

Empty file deleted.