/*

* Copyright (c) 2003-2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "s_lib.h"

#include "instreg.h"

/* Exit codes */

#define EXITCODE_SUCCESS    0   /* successful completion */

#define EXITCODE_HELP       1   /* help printed, nothing done */

#define EXITCODE_CMDLINE    2   /* command line parse error */

#define EXITCODE_IOERR      3   /* cannot write installation registry */

#define EXITCODE_NOMEM      4   /* out of memory (very unlikely) */

/* Data structures */

struct _MemContext {

    const MemHook * next;

};

typedef struct _AppContext {

    Bool unregister;            /* true if we are unregistering the product */

    StrBuf sb;                  /* temporary string buffer */

    DOMNode* root;              /* root node of the DOM tree */

    Str name;                   /* product name */

    Str ver;                    /* product version, NULL if unknown */

    Str loc;                    /* product location */

    Str exe;                    /* product executable */

    Str type;                   /* product type */

    Str nameEsc;                /* XML-escaped product name */

    Str typeEsc;                /* XML-escaped product type */

    Str verEsc;                 /* XML-escaped version */

    Str exeEsc;                 /* XML-escaped path */

    Str locEsc;                 /* XML-escaped location */

} AppContext;

/* Tags in the installation registry file */

#define REGISTRY_TAG    "registry"

#define PRODUCT_TAG     "product"

#define NAME_TAG        "name"

#define VERSION_TAG     "version"

#define EXECUTABLE_TAG  "executable"

#define LOCATION_TAG    "location"

#define TYPE_ATTR       "type"

#define EMULATOR_TYPE   "emulator"

#define ROOT_TAG        REGISTRY_TAG

/*

 * Some default values. Note that we are making an assumption that the

 * default values don't need to be XML-escaped.

 */

#define DEFAULT_TYPE    EMULATOR_TYPE

#define DEFAULT_VERSION "1.0"

/* Desctiption of the command line parameters */

#define CMDLINE_PARAM   "PRODUCT"

/* Modifiable global data */

static Char* pname = "instreg";

static Char regfile[] = "C:\\Nokia\\Registry\\installationRegistry.xml";

/* Constants */

static const Str commonHeader = "\

<?xml version=\"1.0\" standalone=\"yes\"?>\n\

\n\

<!DOCTYPE "REGISTRY_TAG" [\n\

<!ELEMENT "REGISTRY_TAG" ("PRODUCT_TAG")*>\n\

<!ELEMENT "PRODUCT_TAG" ("NAME_TAG", "VERSION_TAG", "EXECUTABLE_TAG", "\

LOCATION_TAG")>\n\

<!ELEMENT "NAME_TAG" (#PCDATA)>\n\

<!ELEMENT "VERSION_TAG" (#PCDATA)>\n\

<!ELEMENT "EXECUTABLE_TAG" (#PCDATA)>\n\

<!ELEMENT "LOCATION_TAG" (#PCDATA)>\n\

<!ATTLIST "PRODUCT_TAG" "TYPE_ATTR" CDATA #IMPLIED>\n\

]>\n\

\n\

";

/* This template is used when we are creating a new file */

static const Str newTemplate = "%s\

<"REGISTRY_TAG">\n\

    <"PRODUCT_TAG" "TYPE_ATTR"=\"%s\">\n\

        <"NAME_TAG">\n\

            %s\n\

        </"NAME_TAG">\n\

        <"VERSION_TAG">\n\

            %s\n\

        </"VERSION_TAG">\n\

        <"EXECUTABLE_TAG">\n\

            %s\n\

        </"EXECUTABLE_TAG">\n\

        <"LOCATION_TAG">\n\

            %s\n\

        </"LOCATION_TAG">\n\

    </"PRODUCT_TAG">\n\

</"REGISTRY_TAG">\n\

";

/* This template is used when we are updating the existing entry */

static const Str updateTemplate = "\

<"PRODUCT_TAG" "TYPE_ATTR"=\"%s\">\n\

        <"NAME_TAG">\n\

            %s\n\

        </"NAME_TAG">\n\

        <"VERSION_TAG">\n\

            %s\n\

        </"VERSION_TAG">\n\

        <"EXECUTABLE_TAG">\n\

            %s\n\

        </"EXECUTABLE_TAG">\n\

        <"LOCATION_TAG">\n\

            %s\n\

        </"LOCATION_TAG">\n\

    </"PRODUCT_TAG">\

";

/* Template for appending a new entry to the existing file */

static const Str appendTemplate = "\

    <"PRODUCT_TAG" "TYPE_ATTR"=\"%s\">\n\

        <"NAME_TAG">\n\

            %s\n\

        </"NAME_TAG">\n\

        <"VERSION_TAG">\n\

            %s\n\

        </"VERSION_TAG">\n\

        <"EXECUTABLE_TAG">\n\

            %s\n\

        </"EXECUTABLE_TAG">\n\

        <"LOCATION_TAG">\n\

            %s\n\

        </"LOCATION_TAG">\n\

    </"PRODUCT_TAG">\n\

";

/**

 * Memory hooks. If memory allocation fails, we exit the program with

 * EXITCODE_NOMEM status. Therefore, we don't need for check for memory

 * allocation failures in the code.

 */

static Bool APP_MemInit(MemContext* ctx, const MemHook* next)

{

    ctx->next = next;

    return True;

}

static void* APP_MemAlloc(MemContext* ctx, size_t size)

{

    void* ptr = MEM_Alloc2(ctx->next, size);

    if (!ptr) {

        TRACE_Error("Out of memory!\n");

        exit(EXITCODE_NOMEM);

    }

    return ptr;

}

static Bool APP_PrintTag(File* out, Str tag, const XMLAttr* a, StrBuf* sb)

{

    if (FILE_Puts(out, TEXT("<")) && FILE_Puts(out, tag)) {

        int i;

        int n = XML_AttrCount(a);

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

            Str name = XML_AttrNameAt(a, i);

            Str value = XML_AttrValueAt(a, i);

            Str esc = XML_Escape(NULL, value);

            if (!esc) esc = XML_Escape(sb, value);

            if (FILE_Printf(out, TEXT(" %s=\"%s\""), name, esc) < 0) {

                return False;

            }

        }

        return (FILE_Puts(out, TEXT(">")) > 0);

    }

    return False;

}

/**

 * Prints the DOM node to the specified stream.

 */

static Bool APP_PrintDOM(File* out, DOMNode* node, StrBuf* sb)

{

    if (APP_PrintTag(out, DOM_TagName(node),DOM_Attr(node), sb)) {

        if (DOM_ChunkCount(node) == 0) {

            Str charData = DOM_CharData(node);

            if (charData && FILE_Printf(out, TEXT("%s"), charData) < 0) {

                return False;

            }

        } else {

            DOMChunk* chunk = DOM_FirstChunk(node);

            while (chunk) {

                DOMNode* child = DOM_ChunkNode(chunk);

                Str text = DOM_ChunkText(chunk);

                ASSERT(text || child);

                if ((text && !FILE_Puts(out, text)) ||

                    (child && !APP_PrintDOM(out, child, sb))) {

                    return False;

                }

                chunk=DOM_NextChunk(chunk);

            }

        }

        return (FILE_Printf(out, TEXT("</%s>"),DOM_TagName(node)) > 0);

    }

    return False;

}

/**

 * Matches the child tag of the product node against the expected value

 */

static Bool APP_MatchInfo(DOMNode* p, Str tag, Str expect, StrBuf* sb)

{

    if (expect) {

        DOMNode* node = DOM_FindFirst(p, tag);

        if (node) {

            Str data = DOM_CharData(node);

            if (data && StrStr(data, expect)) {

                STRBUF_Copy(sb, data);

                STRBUF_Trim(sb);

                return STRBUF_EqualsTo(sb, expect);

            }

        }

        /* no match */

        return False;

    } else {

        /* nothing is expected, anything will do */

        return True;

    }

}

/**

 * Checks whether the node matches the product criteria specified on

 * the command line. This serves dual purpose. When registering the

 * product, this is how we find the existing entry to update. The

 * first entry that matches the criteria will be updated, all others

 * ignored. When unregistering the product, all matching entries are

 * removed.

 */

static Bool APP_MatchProduct(DOMNode* product, AppContext* app)

{

    Bool match = False;

    if (product && StrCmp(DOM_TagName(product),PRODUCT_TAG) == 0) {

        Str type = XML_AttrValue(DOM_Attr(product),TYPE_ATTR);

        if (!app->type || (type && StrCmp(type,app->type) == 0)) {

            /* compare product information */

            if (APP_MatchInfo(product, NAME_TAG,  app->name, &app->sb) &&

                APP_MatchInfo(product, VERSION_TAG,  app->ver, &app->sb) &&

                APP_MatchInfo(product, LOCATION_TAG,  app->loc, &app->sb) &&

                APP_MatchInfo(product, EXECUTABLE_TAG,  app->exe, &app->sb)) {

                match = True;

            }

        }

    }

    return match;

}

/**

 * FILE_Save callback. If invoked from FILE_Save, this callback is actually

 * writing to a temporary file. The temporary file then gets renamed into the

 * actual output file. This guarantees that we either successfully update the

 * file, or don't change it at all. Note that we also invoke this callback 

 * directly, to write to stdout.

 */

static Bool APP_FileSaveCB(File* out, Str fname, void * ctx)

{

    AppContext* app = ctx;

    Str tag = DOM_TagName(app->root);

    if (FILE_Puts(out, commonHeader) &&

        APP_PrintTag(out, tag, DOM_Attr(app->root), &app->sb)) {

        Bool updated = False;

        DOMChunk* chunk = DOM_FirstChunk(app->root);

        while (chunk) {

            DOMNode* child = DOM_ChunkNode(chunk);

            Str text = DOM_ChunkText(chunk);

            if (child) {

                if (APP_MatchProduct(child, app)) {

                    /* 

                     * If unregistering, skip this entry. Also, when 

                     * we find more that one matching entry when we are

                     * registering the product, we update the first one

                     * and remove the others.

                     */

                    if (!app->unregister && !updated) {

                        /* update the existing entry */

                        if (!FILE_Puts(out, text) ||

                             FILE_Printf(out, updateTemplate, 

                                        app->typeEsc, app->nameEsc, 

                                        app->verEsc, app->exeEsc, 

                                        app->locEsc) > 0) {

                            updated = True;

                        } else {

                            return False;

                        }

                    }

                } else if (!FILE_Puts(out, text) ||

                           !APP_PrintDOM(out, child, &app->sb)) {

                    return False;

                }

            } else if (text) {

                if (!FILE_Puts(out, text)) {

                    return False;

                }

            }

            chunk = DOM_NextChunk(chunk);

        }

        if (!updated) {

            if (DOM_ChunkCount(app->root) == 0) {

                Str charData = DOM_CharData(app->root);

                if (charData && FILE_Printf(out, TEXT("%s"), charData) < 0) {

                    return False;

                }

            }

            if (!app->unregister) {

                /* append a new entry */

                if (FILE_Printf(out,appendTemplate, app->typeEsc, 

                                app->nameEsc, app->verEsc, app->exeEsc,

                                app->locEsc) < 0) {

                    return False;

                }

            }

        }

        return (FILE_Printf(out, TEXT("</%s>\n"),tag) > 0);

    }

    /* some kind of I/O error */

    return False;

}

/**

 * The program entry point.

 */

int main(int argc, char* argv[]) 

{

    AppContext app;

    Bool toStdout = False;

    Bool help = False;

    Vector params;

    CmdLine* c;

    Str prog;

    int status;

    Char sysDirBuf[MAX_PATH +1];

    MemProc mp;

    MemContext mc;

    /* install memory hook so that we don't have to check for NULL */

    MEM_InitModule();    

    memset(&mc, 0, sizeof(mc));

    memset(&mp, 0, sizeof(mp));

    mp.memInit = APP_MemInit;

    mp.memAlloc = APP_MemAlloc;

    MEM_Hook(&mp, &mc);

    RANDOM_InitModule();    

    /* figure out the program name */

    prog = FILE_FilePart(argv[0]);

#ifdef _WIN32

    if (STRING_EndsWith(prog, ".exe")) {

        int n = StrLen(prog)-4;

        pname = MEM_NewArray(Char, n+1);

        StrnCpy(pname, prog, n);

        pname[n] = 0;

    } else 

#endif /* _WIN32 */

    pname = STRING_Dup(prog);

    /* 

     * determine the drive where Windows is installed. That's the drive

     * where installationRegistry.xml file is located.

     */

#ifdef _WIN32

    if (GetSystemDirectory(sysDirBuf, COUNT(sysDirBuf))) {

        TRACE1("system drive is %c:\n",sysDirBuf[0]);

        regfile[0] = sysDirBuf[0];

    }

#endif /* _WIN32 */

    memset(&app, 0, sizeof(app));

    c = CMDLINE_Create(pname);

#ifdef _CONSOLE

    CMDLINE_AddTrueOpt(c,'h',"help","print this help and exit",&help);

    CMDLINE_AddTrueOpt(c,'c',"stdout","write updated installation registry "

        "to stdout",&toStdout);

#endif /* _CONSOLE */

    CMDLINE_SetParamName(CMDLINE_AddStrOpt(c,'e',"executable",

        "path to the executable (required to register)",&app.exe), "FILE");

    CMDLINE_SetParamName(CMDLINE_AddStrOpt(c,'v',"version",

        "product version (default is "DEFAULT_VERSION")",&app.ver),"VERSION");

    CMDLINE_SetParamName(CMDLINE_AddStrOpt(c,'l',"location",

        "product location (default is the executable folder)",&app.loc),"DIR");

    CMDLINE_SetParamName(CMDLINE_AddStrOpt(c,'t',"type",

        "product type (default is "DEFAULT_TYPE")",&app.type),"TYPE");

    CMDLINE_AddTrueOpt(c,'u',"unregister","unregister the product "

        "(default is to register)",&app.unregister);

    VECTOR_Init(&params, 0, vectorEqualsString, NULL);

    if (!CMDLINE_Parse(c,argv+1,argc-1,PARSE_NO_DUP,&params) || 

        VECTOR_IsEmpty(&params) || help) {

        TRACE_Output(PRODUCT_NAME " Version %d.%d.%d\nCopyright (C) "

            PRODUCT_COPYRIGHT ". All rights reserved.\n\n", 

            PRODUCT_VERSION_MAJOR, PRODUCT_VERSION_MINOR,

            PRODUCT_VERSION_MICRO);

        CMDLINE_Usage(c, CMDLINE_PARAM, 0);

        status = (help ? EXITCODE_HELP : EXITCODE_CMDLINE);

    } else if (VECTOR_Size(&params) > 1) {

        TRACE_Error("%s: unexpected command line parameters\n", pname);

        CMDLINE_Usage(c, CMDLINE_PARAM, 0);

        status = EXITCODE_CMDLINE;

    } else if (!app.exe && !app.unregister) {

        TRACE_Error("%s: product executable is required\n", pname);

        CMDLINE_Usage(c, CMDLINE_PARAM, 0);

        status = EXITCODE_CMDLINE;

    } else {

        StrBuf typeBuf;

        StrBuf nameBuf;

        StrBuf verBuf;

        StrBuf exeBuf;

        StrBuf locBuf;

        Char* dir = NULL;

        if (app.exe && !app.loc) {

            /* default location */

            if (FILE_FilePart(app.exe) == app.exe) {

                int n = GetCurrentDirectory(0,NULL)+1;

                dir = MEM_NewArray(Char,n);

                dir[GetCurrentDirectory(n,dir)] = 0;

            } else {

                dir = FILE_DirName(app.exe, 0);

            }

            if (STRING_EndsWith(dir, FILE_SEPARATOR)) {

                dir[StrLen(dir)-1] = 0;

            }

            app.loc = dir;

        }

        status = EXITCODE_SUCCESS;

        /* XML escape the strings */

        STRBUF_Init(&typeBuf);

        STRBUF_Init(&nameBuf);

        STRBUF_Init(&verBuf);

        STRBUF_Init(&exeBuf);

        STRBUF_Init(&locBuf);

        STRBUF_Init(&app.sb);

        app.name = VECTOR_Get(&params, 0);

        app.nameEsc = XML_Escape(&nameBuf, app.name);

        if (app.exe) app.exeEsc = XML_Escape(&exeBuf, app.exe);

        if (app.loc) app.locEsc = XML_Escape(&locBuf, app.loc);

        if (app.type) {

            app.typeEsc = XML_Escape(&typeBuf, app.type);

        } else {

            /* we know there's nothing to escape here */

            app.typeEsc = DEFAULT_TYPE;

        }

        if (app.ver) {

            app.verEsc = XML_Escape(&verBuf, app.ver);

        } else {

            /* we know there's nothing to escape here */

            app.verEsc = DEFAULT_VERSION;

        }

        app.root = DOM_Load(regfile);

        if (app.root && StrCmp(DOM_TagName(app.root),ROOT_TAG) == 0) {

            if (toStdout) {

                File* out = FILE_AttachToFile(stdout,"stdout");

                APP_FileSaveCB(out, FILE_Name(out), &app);

                FILE_Close(out);

            } else {

                if (!FILE_Save(regfile, APP_FileSaveCB, &app, NULL)) {

                    status = EXITCODE_IOERR;

                }

            }

        } else if (!app.unregister) {

            /*

             * either the file does not exist, or else it exists but 

             * contains some garbage (root tag does not match the 

             * expectation). Create a new file, unless the user has

             * given us -u (unregister) option in which case we have

             * nothing to do.

             */

            if (toStdout) {

                printf(newTemplate, commonHeader, app.typeEsc, app.nameEsc,

                    app.verEsc, app.exeEsc, app.locEsc);

            } else {

                /* create a new file */

                File* f = FILE_Open(regfile, WRITE_TEXT_MODE, NULL);

                if (!f) {

                    /* perhaps, the directory does not exist? */

                    Char* regdir = FILE_DirName(regfile, 0);

                    FILE_MkDir(regdir);

                    MEM_Free(regdir);

                }

                /* try again */

                f = FILE_Open(regfile, WRITE_TEXT_MODE, NULL);

                if (f) {

                    if (FILE_Printf(f, newTemplate, commonHeader, 

                                    app.typeEsc, app.nameEsc, 

                                    app.verEsc, app.exeEsc, 

                                    app.locEsc) < 0) {

                        status = EXITCODE_IOERR;

                    }

                    FILE_Close(f);

                } else {

                    status = EXITCODE_IOERR;

                }

            }

        }

        STRBUF_Destroy(&app.sb);

        DOM_Delete(app.root);