lib/plugin/xum1541/WINDOWS/install.c

Go to the documentation of this file.

/*
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version
 *  2 of the License, or (at your option) any later version.
 *
 *  Copyright 2008 Spiro Trikaliotis
*/

#include <windows.h>
#include <windowsx.h>

#define DBG_USERMODE

#ifndef DBG_PROGNAME
    #define DBG_PROGNAME "OPENCBM-XUM1541.DLL"
#endif // #ifndef DBG_PROGNAME

#include "debug.h"

#include <stdio.h>
#include <stdlib.h>

#include <getopt.h>

#include "cbmioctl.h"
#include "libmisc.h"
#include "version.h"

#define OPENCBM_PLUGIN 1 
#include "archlib.h"
#include "archlib-windows.h"


typedef
struct xu1541_parameter_s
{
    osversion_t OsVersion;

} xu1541_parameter_t;


static const struct option longopts[] =
{
    { "help",       no_argument,       NULL, 'h' },
    { "version",    no_argument,       NULL, 'V' },

    { NULL,         0,                 NULL, 0   }
};

static const char shortopts[] = "-hV";

static const char usagetext[] =
            "\n\nUsage: instcbm [options] xum1541 [plugin-options]\n"
            "Install the XUM1541 plugin and driver on the system, or remove it.\n"
            "\n"
            "plugin-options is one of:\n"
            "  -h, --help       display this help and exit\n"
            "  -V, --version    display version information about cbm4win\n"
            "\n";


static opencbm_plugin_install_neededfiles_t NeededFilesXUM1541[] = 
{
    { SYSTEM_DIR, "opencbm-xum1541.dll", NULL },
    { LIST_END,   "",                   NULL }
};

static void
hint(void)
{
    fprintf(stderr, "Try \"instcbm xum1541 --help\" for more information.\n");
}


static VOID
version(VOID)
{
    printf("opencbm xum1541 plugin version " /* OPENCBM_VERSION */ ", built on " __DATE__ " at " __TIME__ "\n");
}

static void
usage(void)
{
    version();

    printf("%s", usagetext);
}


static BOOL
processNumber(const PCHAR Argument, PCHAR *NextChar, PBOOL ParameterGiven, PULONG ParameterValue)
{
    PCHAR p;
    BOOL error;
    int base;

    FUNC_ENTER();

    DBG_ASSERT(ParameterValue != NULL);

    error = FALSE;
    p = Argument;

    if (p)
    {
        // Find out which base to use (0***, 0x***, or anything else)

        switch (*p)
        {
        case 0:
            error = TRUE;
            break;

        case '0':
            switch (*++p)
            {
            case 'x': case 'X':
                base = 16;
                ++p;
                break;

            default:
                base = 8;
                break;
            };
            break;

        default:
            base = 10;
            break;
        }

        // Convert the value

        if (!error)
        {
            *ParameterValue = strtoul(p, &p, base);

            if (NextChar)
            {
                error = ((*p != 0) && (*p != ',')) ? TRUE : FALSE;
            }
            else
            {
                error = *p != 0 ? TRUE : FALSE;
            }

            if (!error)
            {
                if (NextChar != NULL)
                {
                    *NextChar = p + ((*p) ? 1 : 0);
                }

                if (ParameterGiven != NULL)
                {
                    *ParameterGiven = TRUE;
                }
            }
        }
    }

    FUNC_LEAVE_BOOL(error);
}

/*-------------------------------------------------------------------*/
/*--------- OPENCBM INSTALL HELPER FUNCTIONS ------------------------*/

unsigned int CBMAPIDECL
opencbm_plugin_install_process_commandline(CbmPluginInstallProcessCommandlineData_t * Data)
{
    int error = 0;
    char **localOptarg = Data->OptArg;

    xu1541_parameter_t *parameter = Data->OptionMemory;

    BOOL quitLocalProcessing = FALSE;

    FUNC_ENTER();

    DBG_ASSERT(Data);


    do {
        int c;

        /* special handling for first call: Determine the length of the OptionMemory to be allocated */

        if (Data->Argc == 0) {
            error = sizeof(xu1541_parameter_t);
            break;
        }

        DBG_ASSERT(Data->OptionMemory != NULL);
        DBG_ASSERT(Data->GetoptLongCallback != NULL);
        DBG_ASSERT(Data->OptInd != NULL);
        DBG_ASSERT(Data->OptErr != NULL);
        DBG_ASSERT(Data->OptOpt != NULL);
        DBG_ASSERT(Data->InstallParameter != NULL);

        /* as we are interested in the OS version for installation, copy it */

        parameter->OsVersion = Data->InstallParameter->OsVersion;

        if (Data->Argv) {
        while ( ! quitLocalProcessing && (c = Data->GetoptLongCallback(Data->Argc, Data->Argv, shortopts, longopts)) != -1) {
            switch (c) {
                case 'h':
                    usage();
                    Data->InstallParameter->NoExecute = TRUE;
                    break;

                case 'V':
                    version();
                    Data->InstallParameter->NoExecute = TRUE;
                    break;

                case 1:
                    quitLocalProcessing = 1;
                    -- * Data->OptInd;
                    break;

                default:
                    fprintf(stderr, "error...\n");
                    error = TRUE;
                    hint();
                    break;
            }
        }
        }

    } while (0);

    FUNC_LEAVE_UINT(error);
}

BOOL CBMAPIDECL
opencbm_plugin_install_do_install(void * Context)
{
    BOOL error = TRUE;

    FUNC_ENTER();

    DBG_PRINT((DBG_PREFIX "-- xum1541.install" ));

    do {
        error = FALSE;
    } while (0);

    FUNC_LEAVE_BOOL(error);
}

BOOL CBMAPIDECL
opencbm_plugin_install_do_uninstall(void * Context)
{
    BOOL error = TRUE;

    FUNC_ENTER();

    DBG_PRINT((DBG_PREFIX "-- xum1541.uninstall" ));

    do {
        error = FALSE;
    } while (0);

    FUNC_LEAVE_BOOL(error);
}

unsigned int CBMAPIDECL
opencbm_plugin_install_get_needed_files(CbmPluginInstallProcessCommandlineData_t * Data, opencbm_plugin_install_neededfiles_t * Destination)
{
    unsigned int size = sizeof(NeededFilesXUM1541);
    xu1541_parameter_t *parameter = Data->OptionMemory;

    FUNC_ENTER();

    do {
        if (NULL == Destination) {
            break;
        }

        memcpy(Destination, NeededFilesXUM1541, size);

    } while (0);

    FUNC_LEAVE_UINT(size);
}