contentLister/src/erMSDisk.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <gtk/gtk.h>
#include <libermanifest/ermanifest.h>
#include <liberregxml/erregapi.h>
#include "erConnect.h"
#include "system.h"
#include "gtkPincodeScreen.h"
#include "control.h"
#include "erMSDisk.h"
#include "contentListerLog.h"

Go to the source code of this file.

Functions
static int	erMSDiskDisconnectFlash (void)
static int	erMSDiskReconnectFlash (void)
static gboolean	is_device_mounted (const char *dev)
expMemType_e	get_exported_memory_type (void)
expMemType_e	get_memory_type_used (void)
expMemType_e	read_exported_memory_type (void)
void	erMSDiskInit ()
void	erStartMSDiskApp ()
void	erStopMSDiskApp ()
int	erMSDiskSetConnected (int connected)
void	erMSDisk_storage_changed (st_ContentType_e storageType, gboolean storagePresent)
void	erMSDisk_handle_reread_settings ()
Variables
static expMemType_e	g_export_memory_type = expMain
static expMemType_e	g_memory_type_used = expUndefined
static const char *	dev [expUndefined]

---

Function Documentation

void erMSDisk_handle_reread_settings

(

)

Definition at line 334 of file erMSDisk.c.

{
    // Re-read export settings from registry
    g_export_memory_type = read_exported_memory_type();
}

Here is the call graph for this function:

void erMSDisk_storage_changed	(	st_ContentType_e	storageType,
		gboolean	storagePresent
	)

Definition at line 285 of file erMSDisk.c.

{
    CL_LOGPRINTF("storageType = %d, storagePresent = %d", storageType, storagePresent);

    // Convert st_ContentType_e to expMemType_e
    expMemType_e storage_type = expUndefined;
    switch (storageType)
    {
        case st_StorageTypeCF:
            storage_type = expCF;
            break;
        case st_StorageTypeSD:
            storage_type = expMMC;
            break;
        case st_StorageTypeUSB:
            storage_type = expUSB;
            break;
        default:
            break;
    }

    if (getListerState() == STATE_USB_CONNECTED)
    {
        // Connected to PC
        if (storagePresent == FALSE)
        {
            // Card plug out event
            if (storage_type == g_memory_type_used)
            {
                // The memory type we are using is plugged out
                CL_WARNPRINTF("WARNING! Card is plugged out when connected to PC.");

                // Stop msdisk application
                erStopMSDiskApp();
                listerHideUSBScreen();
                setListerState(STATE_NORMAL);
            }
            else
            {
                // Another type of memory is plugged out, don't care
            }
        }
    }
    else if (storage_type == g_export_memory_type)
    {   
        erStartMSDiskApp();
    }
}

Here is the call graph for this function:

static int erMSDiskDisconnectFlash

(

void

)

[static]

Definition at line 231 of file erMSDisk.c.

{
    // stop background connect, if any
    ctrl_disconnect_wait();

    // unmount filesystem(s) exported over USB
    system("sync; sync; sync");

    char cmd[CMD_LEN];
    snprintf(cmd, CMD_LEN, "umount %s", dev[g_memory_type_used]);
    
    int ret = system(cmd);
    if (ret == 0)
    {
        return 0;
    }
    else
    {
        CL_ERRORPRINTF("Mount process returned error %d", ret);
        return -1;
    }
}

Here is the call graph for this function:

void erMSDiskInit

(

)

Definition at line 106 of file erMSDisk.c.

{
    g_export_memory_type = read_exported_memory_type();
}

Here is the call graph for this function:

static int erMSDiskReconnectFlash

(

void

)

[static]

Definition at line 254 of file erMSDisk.c.

{
    int rc;
    int ret = -1;  // return code: 0 = ok
    char cmd[CMD_LEN];
    
    // Determine mount command,
    // note that erStopMSDiskApp() sets g_memory_type_used to "not used"
    snprintf(cmd, CMD_LEN, "mount %s", dev[g_memory_type_used]);

    // stop msdisk application, to free any locks on g_memory_type_used device
    erStopMSDiskApp();

    // mount the filesystem so iLiad can access it
    CL_WARNPRINTF("remounting memory, command [%s]", cmd);
    rc = system(cmd);
    if (rc == 0)
    {
        rc = 0;
    }
    else
    {
        CL_ERRORPRINTF("Mount process returned error %d", rc);
    }

    // start msdisk application again
    erStartMSDiskApp();

    return ret;
}

Here is the call graph for this function:

int erMSDiskSetConnected

(

int

connected

)

Definition at line 181 of file erMSDisk.c.

{
    CL_WARNPRINTF("connected = %d", connected);

    if (connected == 1)
    {
        listerShowUSBScreen();
        setListerState(STATE_USB_CONNECTED);

#ifdef ENABLE_CONFIG_EXPORT_IMPORT
        ctrl_export_config();
#endif

        // For USB stick, if we umount USB memory before exporting it, it fails.
        // So just handle USB memory as an exeception, still don't know why.
        if (g_export_memory_type != expUSB)
        {
            erMSDiskDisconnectFlash();
        }

        return 0;
    }
    else if (connected == 0)
    {
        // Again, it can't work for USB stick...
        if (g_export_memory_type != expUSB)
        {
            erMSDiskReconnectFlash();
        }

        listerHideUSBScreen();
        setListerState(STATE_NORMAL);

#ifdef ENABLE_CONFIG_EXPORT_IMPORT
        ctrl_handle_import_config();
#endif

        mdsRecreateArchives(st_StorageTypeMain);
        mdsRecreateArchives(st_StorageTypeCF);
        mdsRecreateArchives(st_StorageTypeSD);
        mdsRecreateArchives(st_StorageTypeUSB);
        
        return 0;
    }
    else
    {
        return -1;
    }
}

Here is the call graph for this function:

void erStartMSDiskApp

(

)

Definition at line 139 of file erMSDisk.c.

{
    char cmd[CMD_LEN];
    expMemType_e memory_type_new = expMain;  // memory to be exported, default is internal memory

    CL_WARNPRINTF("entry: g_export_memory_type [%d] g_memory_type_used [%d]", g_export_memory_type, g_memory_type_used);

    // Use export type only when mounted
    if ( is_device_mounted(dev[g_export_memory_type]) )
    {
        memory_type_new = g_export_memory_type;
    }

    if (g_memory_type_used == memory_type_new)
    {
        ;  // msdisk application already running on required memory type: do nothing
    }
    else
    {
        // Stop msdisk application if running
        if (g_memory_type_used != expUndefined)
        {
            erStopMSDiskApp();
        }

        // Start msdisk application
        g_memory_type_used = memory_type_new;
        snprintf(cmd, sizeof(cmd), "sync ; msdisk %s &", dev[g_memory_type_used]);
        CL_WARNPRINTF("-- starting msdisk [%s]", cmd);
        system(cmd);
    }
}

Here is the call graph for this function:

void erStopMSDiskApp

(

)

Definition at line 172 of file erMSDisk.c.

{
    // TODO: The better solution is using fork/exec and then sending SIGTERM signal
    CL_WARNPRINTF("-- stopping msdisk");
    system("killall msdisk; sync; sync;");

    g_memory_type_used = expUndefined;
}

expMemType_e get_exported_memory_type

(

void

)

Definition at line 54 of file erMSDisk.c.

{
    return g_export_memory_type;
}

expMemType_e get_memory_type_used

(

void

)

[inline]

Definition at line 59 of file erMSDisk.c.

{
    return g_memory_type_used;
}

static gboolean is_device_mounted

(

const char *

dev

)

[static]

Definition at line 112 of file erMSDisk.c.

{
    FILE* fp = fopen(PROCFS_MOUNT_FILE, "r");
    if (NULL == fp)
    {
        printf("Can NOT open %s\n", PROCFS_MOUNT_FILE);
        return -1;
    }

    char buf[128];
    int len = strlen(dev);
    gboolean bFound = FALSE;
    while (!feof(fp))
    {
        fgets(buf, 128, fp);
        if (strncmp(buf, dev, len) == 0)
        {
            // Mount point found
            bFound = TRUE;
            break;
        }
    }

    fclose(fp);
    return bFound;
}

expMemType_e read_exported_memory_type

(

void

)

Definition at line 64 of file erMSDisk.c.

{
    regExportMemType_t* theExportMemType = NULL;
    expMemType_e        theExpMemType    = expMain;

    // Get settings from registry
    theExportMemType = erRegGetExportMemType();
    if (theExportMemType)
    {
        // Remember settings
        if (strcmp(theExportMemType->location, MAIN_CATEGORY) == 0)
        {
            theExpMemType =  expMain; 
        }
        else if (strcmp(theExportMemType->location, SD_CATEGORY) == 0)
        {
            theExpMemType = expMMC;
        }
        else if (strcmp(theExportMemType->location, USB_CATEGORY) == 0)
        {
            theExpMemType = expUSB;
        }
        else if (strcmp(theExportMemType->location, CF_CATEGORY) == 0)
        {
            theExpMemType =  expCF;
        }
        else
        {
            CL_ERRORPRINTF("Invalid exporting memory type: %s", theExportMemType->location);
        }

        erRegFreeExportMemType(theExportMemType);
    }
    else
    {
        CL_ERRORPRINTF("erRegGetExportMemType returns NULL");
    }
    
    CL_LOGPRINTF("leave, return [%d]", theExpMemType);
    return theExpMemType; 
}

Here is the call graph for this function:

---

Variable Documentation

const char* dev[expUndefined] [static]

Initial value:

 
{
    "/dev/tffsa6",
    "/dev/mmc1",
    "/dev/sda1",
    "/dev/hda1"
}

Definition at line 46 of file erMSDisk.c.

expMemType_e g_export_memory_type = expMain [static]

Copyright (C) 2005-2008 iRex Technologies B.V. All rights reserved.

Definition at line 39 of file erMSDisk.c.

expMemType_e g_memory_type_used = expUndefined [static]

Definition at line 40 of file erMSDisk.c.