path: root/mountd/Server.c

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

/*
**	mountd server support
*/

#include "mountd.h"
#include "ASEC.h"

#include <cutils/properties.h>
#include <cutils/sockets.h>

#include <pthread.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>

#include <private/android_filesystem_config.h>


// current client file descriptor
static int sFD = -1;

// to synchronize writing to client
static pthread_mutex_t sWriteMutex = PTHREAD_MUTEX_INITIALIZER;

// path for media that failed to mount before the runtime is connected
static char* sDeferredUnmountableMediaPath = NULL;

// last asec msg before the runtime was connected
static char* sAsecDeferredMessage = NULL;
static char* sAsecDeferredArgument = NULL;

static int Write(const char* message)
{
    int result = -1;

    pthread_mutex_lock(&sWriteMutex);
    
    LOG_SERVER("Write: %s\n", message);
    if (sFD >= 0)
        result = write(sFD, message, strlen(message) + 1);

    pthread_mutex_unlock(&sWriteMutex); 
    
    return result;
}

static int Write2(const char* message, const char* data)
{
    int result = -1;

    char* buffer = (char *)alloca(strlen(message) + strlen(data) + 1);
    if (!buffer)
    {
        LOG_ERROR("alloca failed in Write2\n");
        return -1;
    }

    strcpy(buffer, message);
    strcat(buffer, data);
    return Write(buffer);
}

static void SendStatus()
{
    Write(IsMassStorageConnected() ? MOUNTD_UMS_CONNECTED : MOUNTD_UMS_DISCONNECTED);
    Write(IsMassStorageEnabled() ? MOUNTD_UMS_ENABLED : MOUNTD_UMS_DISABLED);
}

static void DoCommand(const char* command)
{
    LOG_SERVER("DoCommand %s\n", command);
    
    if (strcmp(command, MOUNTD_ENABLE_UMS) == 0)
    {
        EnableMassStorage(true);
        Write(MOUNTD_UMS_ENABLED);
     }
    else if (strcmp(command, MOUNTD_DISABLE_UMS) == 0) 
    {
        EnableMassStorage(false);
        Write(MOUNTD_UMS_DISABLED);
    }
    else if (strcmp(command, MOUNTD_SEND_STATUS) == 0)
    {
        SendStatus();
    }
    else if (strncmp(command, MOUNTD_MOUNT_MEDIA, strlen(MOUNTD_MOUNT_MEDIA)) == 0)
    {
        const char* path = command + strlen(MOUNTD_MOUNT_MEDIA);
        MountMedia(path);
    }
    else if (strncmp(command, MOUNTD_EJECT_MEDIA, strlen(MOUNTD_EJECT_MEDIA)) == 0)
    {
        const char* path = command + strlen(MOUNTD_EJECT_MEDIA);
        UnmountMedia(path);
    } 
    else if (strncmp(command, ASEC_CMD_ENABLE, strlen(ASEC_CMD_ENABLE)) == 0) {
        LOG_ASEC("Got ASEC_CMD_ENABLE\n");
	// XXX: SAN: Impliment
    }
    else if (strncmp(command, ASEC_CMD_DISABLE, strlen(ASEC_CMD_DISABLE)) == 0) {
        LOG_ASEC("Got ASEC_CMD_DISABLE\n");
	// XXX: SAN: Impliment
    }
    else if (strncmp(command, ASEC_CMD_SEND_STATUS, strlen(ASEC_CMD_SEND_STATUS)) == 0) {
        LOG_ASEC("Got ASEC_CMD_SEND_STATUS\n");
	// XXX: SAN: Impliment
    }
    else
        LOGE("unknown command %s\n", command);
}

int RunServer()
{
    int socket = android_get_control_socket(MOUNTD_SOCKET);
    if (socket < 0) {
        LOGE("Obtaining file descriptor for socket '%s' failed: %s",
             MOUNTD_SOCKET, strerror(errno));
        return -1;
    }

    if (listen(socket, 4) < 0) {
        LOGE("Unable to listen on file descriptor '%d' for socket '%s': %s",
             socket, MOUNTD_SOCKET, strerror(errno));
        return -1;
    }

    while (1)
    {
        struct sockaddr addr;
        socklen_t alen;
        struct ucred cred;
        socklen_t size;
        
        alen = sizeof(addr);
        sFD = accept(socket, &addr, &alen);
        if (sFD < 0)
            continue;
            
        if (sDeferredUnmountableMediaPath) {
            NotifyMediaState(sDeferredUnmountableMediaPath, MEDIA_UNMOUNTABLE, false);
            free(sDeferredUnmountableMediaPath);
            sDeferredUnmountableMediaPath = NULL;
        }

        if (sAsecDeferredMessage) {
    
            if (Write2(sAsecDeferredMessage, sAsecDeferredArgument) < 0)
                LOG_ERROR("Failed to deliver deferred ASEC msg to framework\n");
            free(sAsecDeferredMessage);
            free(sAsecDeferredArgument);
            sAsecDeferredMessage = sAsecDeferredArgument = NULL;
        }

        while (1)
        {    
            char    buffer[101];
            int result = read(sFD, buffer, sizeof(buffer) - 1);
            if (result > 0)
            {
                int start = 0;
                int i;
                // command should be zero terminated, but just in case
                buffer[result] = 0;
                for (i = 0; i < result; i++) 
                {
                    if (buffer[i] == 0) 
                    {
                        DoCommand(buffer + start);
                        start = i + 1;
                    }                   
                }
            }
            else
            {
                close(sFD);
                sFD = -1;
                break;
            }
        }
    }  

    // should never get here
    return 0;
}

void SendMassStorageConnected(boolean connected)
{
    Write(connected ? MOUNTD_UMS_CONNECTED : MOUNTD_UMS_DISCONNECTED);
}

void SendUnmountRequest(const char* path)
{
    Write2(MOUNTD_REQUEST_EJECT, path);
}

void NotifyAsecState(AsecState state, const char *argument)
{
    const char *event = NULL;
    const char *status = NULL;
    boolean deferr = true;;

    switch (state) {
        case ASEC_DISABLED:
            event = ASEC_EVENT_DISABLED;
            status = ASEC_STATUS_DISABLED;
            break;
        case ASEC_AVAILABLE:
            event = ASEC_EVENT_AVAILABLE;
            status = ASEC_STATUS_AVAILABLE;
            break;
        case ASEC_BUSY:
            event = ASEC_EVENT_BUSY;
            status = ASEC_STATUS_BUSY;
            deferr = false;
            break;
        case ASEC_FAILED_INTERR:
            event = ASEC_EVENT_FAILED_INTERR;
            status = ASEC_STATUS_FAILED_INTERR;
            break;
        case ASEC_FAILED_NOMEDIA:
            event = ASEC_EVENT_FAILED_NOMEDIA;
            status = ASEC_STATUS_FAILED_NOMEDIA;
            break;
        case ASEC_FAILED_BADMEDIA:
            event = ASEC_EVENT_FAILED_BADMEDIA;
            status = ASEC_STATUS_FAILED_BADMEDIA;
            break;
        case ASEC_FAILED_BADKEY:
            event = ASEC_EVENT_FAILED_BADKEY;
            status = ASEC_STATUS_FAILED_BADKEY;
            break;
        default:
            LOG_ERROR("unknown AsecState %d in NotifyAsecState\n", state);
            return;
    }

    property_set(ASEC_STATUS, status);

    int result = Write2(event, argument);
    if ((result < 0) && deferr) {
        if (sAsecDeferredMessage) 
            free(sAsecDeferredMessage);
        sAsecDeferredMessage = strdup(event);
        if (sAsecDeferredArgument)
            free(sAsecDeferredArgument);
        sAsecDeferredArgument = strdup(argument);
        LOG_ASEC("Deferring event '%s' arg '%s' until framework connects\n", event, argument);
    }
}

void NotifyMediaState(const char* path, MediaState state, boolean readOnly)
{
    const char* event = NULL;
    const char* propertyValue = NULL;
    
    switch (state) {
        case MEDIA_REMOVED:
            event = MOUNTD_MEDIA_REMOVED;
            propertyValue = EXTERNAL_STORAGE_REMOVED;
            break;
        case MEDIA_UNMOUNTED:
            event = MOUNTD_MEDIA_UNMOUNTED;
            propertyValue = EXTERNAL_STORAGE_UNMOUNTED;
            break;
        case MEDIA_MOUNTED:
            event = (readOnly ? MOUNTD_MEDIA_MOUNTED_READ_ONLY : MOUNTD_MEDIA_MOUNTED);
             propertyValue = (readOnly ? EXTERNAL_STORAGE_MOUNTED_READ_ONLY : EXTERNAL_STORAGE_MOUNTED);
           break;
        case MEDIA_SHARED:
            event = MOUNTD_MEDIA_SHARED;
            propertyValue = EXTERNAL_STORAGE_SHARED;
            break;
        case MEDIA_BAD_REMOVAL:
            event = MOUNTD_MEDIA_BAD_REMOVAL;
            propertyValue = EXTERNAL_STORAGE_BAD_REMOVAL;
            break;
        case MEDIA_UNMOUNTABLE:
            event = MOUNTD_MEDIA_UNMOUNTABLE;
            propertyValue = EXTERNAL_STORAGE_UNMOUNTABLE;
            break;
        default:
            LOG_ERROR("unknown MediaState %d in NotifyMediaState\n", state);
            return;
    }
    
    property_set(EXTERNAL_STORAGE_STATE, propertyValue);
    int result = Write2(event, path);
    if (result < 0 && state == MEDIA_UNMOUNTABLE) {
    
        // if we cannot communicate with the runtime, defer this message until the runtime is available
        sDeferredUnmountableMediaPath = strdup(path);
    }
}