freeotfe4pdaoptions.c

文件驱动加密,功能强大,可产生加密分区,支持AES,MD2,MD4,MD5MD2, MD4, MD5, RIPEMD-128, RIPEMD-160, SHA-1, SHA-224, SHA-256,

    retval = GetValueInt(hFile, Name, &intValue);
    if (retval)
        {
        *Value = itob(intValue);
        }

    return retval;
}


// =========================================================================
BOOL GetValueBoolDflt(FILE* hFile, WCHAR* Name, BOOL* Value, BOOL Default)
{
    BOOL retval;

    retval = GetValueBool(hFile, Name, Value);
    if (!(retval))
        {
        *Value = Default;
        }

    return retval;
}


// =========================================================================
OPTIONS* OptionsCopy(OPTIONS* SrcOpts)
{
    OPTIONS* retval;
    WCHAR* tmpMntPntDefault;
    WCHAR* tmpExplorerExe;

    retval = malloc(sizeof(*retval));
    // +1 to include terminating NULL
    tmpMntPntDefault = calloc(
                              (wcslen(SrcOpts->MntPntDefault) + 1),
                              sizeof(*tmpMntPntDefault)
                             );
    // +1 to include terminating NULL
    tmpExplorerExe = calloc(
                            (wcslen(SrcOpts->ExplorerExe) + 1),
                            sizeof(*tmpExplorerExe)
                           );

    if (
        (retval == NULL) ||
        (tmpMntPntDefault == NULL) ||
        (tmpExplorerExe == NULL)
       )
        {
        DEBUGOUTDRV(DEBUGLEV_ERROR, (TEXT("Unable to malloc enough memory to make copy of options\n")));
        SecZeroAndFreeMemory(retval, sizeof(*retval));
        SecZeroAndFreeMemory(
                             tmpMntPntDefault,
                             (wcslen(SrcOpts->MntPntDefault) * sizeof(*tmpMntPntDefault))
                            );
        SecZeroAndFreeMemory(
                             tmpExplorerExe,
                             (wcslen(SrcOpts->ExplorerExe) * sizeof(*tmpExplorerExe))
                            );
        }
    else
        {
        memcpy(retval, SrcOpts, sizeof(*SrcOpts));
        wcscpy(tmpMntPntDefault, SrcOpts->MntPntDefault);
        wcscpy(tmpExplorerExe, SrcOpts->ExplorerExe);
        retval->MntPntDefault = tmpMntPntDefault;
        retval->ExplorerExe = tmpExplorerExe;
        }

    return retval;
}


// =========================================================================
// Note: This will *not* free off "Opts"
void OptionsFree(OPTIONS* Opts)
{
    if (Opts != NULL)
        {
        SecZeroAndFreeWCHARMemory(Opts->MntPntDefault);
        SecZeroAndFreeWCHARMemory(Opts->ExplorerExe);
        SecZeroMemory(Opts, sizeof(*Opts));
        }
}


// =========================================================================
OPTIONS* OptionsRead()
{
    OPTIONS* retval;
    FILE* hFile = NULL;
    WCHAR* iniFilename;
    BOOL allOK;

    allOK = TRUE;

    if (allOK)
        {
        retval = malloc(sizeof(*retval));
        allOK = (retval != NULL);
        }

    if (allOK)
        {
        iniFilename = _AllocMainINIFullFilename();
        if (iniFilename == NULL)
            {
            allOK = FALSE;
            }
        }

    if (allOK)
        {
        hFile = _wfopen(iniFilename, TEXT("r"));
        if (hFile == NULL)
            {
            allOK = FALSE;
            }
        }

    if (allOK)
        {
        allOK = GotoSection(hFile, F4P_INI_SECTION);
        }

    // NOTE: We *DO* call the GetValue...Dlft(...) in order to default
    //       the options

    if (retval != NULL)
        {
        GetValueIntDflt(
                        hFile,
                        F4P_INI_CONFIGVERSION,
                        &(retval->ConfigVersion),
                        F4P_INIDFLT_CONFIGVERSION
                       );

        GetValueBoolDflt(
                        hFile,
                        F4P_INI_MNTPNTUSEVOLFILEMAME,
                        &(retval->MntPntUseVolFilename),
                        F4P_INIDFLT_MNTPNTUSEVOLFILEMAME
                       );
        GetValueStringDflt(
                           hFile,
                           F4P_INI_MNTPNTDEFAULT,
                           &(retval->MntPntDefault),
                           F4P_INIDFLT_MNTPNTDEFAULT
                          );

        GetValueStringDflt(
                           hFile,
                           F4P_INI_EXPLORER,
                           &(retval->ExplorerExe),
                           F4P_INIDFLT_EXPLORER
                          );
        GetValueBoolDflt(
                        hFile,
                        F4P_INI_EXPLOREONMOUNT,
                        &(retval->ExploreOnMount),
                        F4P_INIDFLT_EXPLOREONMOUNT
                       );    

        GetValueBoolDflt(
                        hFile,
                        F4P_INI_LARGEICONS,
                        &(retval->LargeIcons),
                        F4P_INIDFLT_LARGEICONS
                       );    

        GetValueBoolDflt(
                        hFile,
                        F4P_INI_SAVESETTINGS,
                        &(retval->SaveSettings),
                        F4P_INIDFLT_SAVESETTINGS
                       );
        }

    if (hFile != NULL)
        {
        fclose(hFile);
        }

    return retval;
}


// =========================================================================
// Convert BOOL into integer
// This function is to ensure that if the definition of TRUE/FALSE (i.e. 1/0)
// changes, the values stored within the config file can still be read/written
// correctly
int btoi(BOOL Value)
{
    int retval;

    retval = 0;
    if (Value)
        {
        retval = 1;
        }

    return retval;
}

// =========================================================================
// Convert integer into BOOL
// This function is to ensure that if the definition of TRUE/FALSE (i.e. 1/0)
// changes, the values stored within the config file can still be read/written
// correctly
BOOL itob(int Value)
{
    BOOL retval;

    retval = FALSE;
    if (Value == 1)
        {
        retval = TRUE;
        }

    return retval;
}


// =========================================================================
BOOL OptionsWrite(OPTIONS* Opts)
{
    BOOL retval;
    WCHAR* iniFilename;
    FILE* hFile;

    retval = TRUE;

    if (retval)
        {
        iniFilename = _AllocMainINIFullFilename();
        if (iniFilename == NULL)
            {
            retval = FALSE;
            }
        }


    if (!(Opts->SaveSettings))
        {
        DeleteFile(iniFilename);
        }
    else
        {
        hFile = _wfopen(iniFilename, TEXT("w"));
        if (hFile == NULL)
            {
            retval = FALSE;
            }

        if (retval)
            {
            // This is crude, but effective...
            fwprintf(hFile, TEXT("[%s]\n"), F4P_INI_SECTION);
            fwprintf(hFile, TEXT("%s=%d\n"), F4P_INI_CONFIGVERSION, F4P_INIDFLT_CONFIGVERSION);
            fwprintf(hFile, TEXT("%s=%d\n"), F4P_INI_SAVESETTINGS, btoi(Opts->SaveSettings));
            fwprintf(hFile, TEXT("%s=%d\n"), F4P_INI_MNTPNTUSEVOLFILEMAME, btoi(Opts->MntPntUseVolFilename));
            fwprintf(hFile, TEXT("%s=%s\n"), F4P_INI_MNTPNTDEFAULT, Opts->MntPntDefault);
            fwprintf(hFile, TEXT("%s=%s\n"), F4P_INI_EXPLORER, Opts->ExplorerExe);
            fwprintf(hFile, TEXT("%s=%d\n"), F4P_INI_EXPLOREONMOUNT, btoi(Opts->ExploreOnMount));
            fwprintf(hFile, TEXT("%s=%d\n"), F4P_INI_LARGEICONS, btoi(Opts->LargeIcons));
            }

        if (hFile != NULL)
            {
            fclose(hFile);
            }

        }

    _FreeMainINIFullFilename(iniFilename);

    return retval;
}


// =========================================================================

// =========================================================================
// =========================================================================