installmgr.h

Go to the documentation of this file.

/******************************************************************************
 *
 * installmgr.h -   class InstallMgr: primary class to access all
 *          module installation functionality
 *
 * $Id: installmgr.h 3805 2020-09-19 12:19:28Z scribe $
 *
 * Copyright 2002-2013 CrossWire Bible Society (http://www.crosswire.org)
 *  CrossWire Bible Society
 *  P. O. Box 2528
 *  Tempe, AZ  85280-2528
 *
 * 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 version 2.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

#ifndef INSTALLMGR_H
#define INSTALLMGR_H

#include <defs.h>
#include <swbuf.h>
#include <map>
#include <set>

SWORD_NAMESPACE_START

class SWMgr;
class SWModule;
class SWConfig;
class RemoteTransport;
class StatusReporter;

class SWDLLEXPORT InstallSource {
    SWMgr *mgr;
public:
    InstallSource(const char *type, const char *confEnt = 0);
    virtual ~InstallSource();
    SWBuf getConfEnt() {
        return caption +"|" + source + "|" + directory + "|" + u + "|" + p + "|" + uid;
    }
    SWBuf caption;
    SWBuf source;
    SWBuf directory;
    SWBuf u;
    SWBuf p;
    SWBuf uid;

    SWBuf type;
    SWBuf localShadow;
    void *userData;
    SWMgr *getMgr();
    void flush();
};

typedef std::map<SWBuf, InstallSource *> InstallSourceMap;

class SWDLLEXPORT InstallMgr {

protected:
    std::set<SWBuf> defaultMods;
    char *privatePath;
    SWBuf confPath;
    StatusReporter *statusReporter;
    bool passive;
    long timeoutMillis;
    SWBuf u, p;
    bool unverifiedPeerAllowed;

    virtual RemoteTransport *createFTPTransport(const char *host, StatusReporter *statusReporter);

    virtual RemoteTransport *createHTTPTransport(const char *host, StatusReporter *statusReporter);


    RemoteTransport *transport;

public:

    static bool userDisclaimerConfirmed;
    static const unsigned int MODSTAT_OLDER;
    static const unsigned int MODSTAT_SAMEVERSION;
    static const unsigned int MODSTAT_UPDATED;
    static const unsigned int MODSTAT_NEW;
    static const unsigned int MODSTAT_CIPHERED;
    static const unsigned int MODSTAT_CIPHERKEYPRESENT;

    SWConfig *installConf;

    InstallSourceMap sources;

    InstallMgr(const char *privatePath = "./", StatusReporter *statusReporter = 0, SWBuf u="ftp", SWBuf p="installmgr@user.com");
    virtual ~InstallMgr();

    void readInstallConf();

    void saveInstallConf();

    void clearSources();

    virtual int removeModule(SWMgr *manager, const char *modName);

    virtual int remoteCopy(InstallSource *is, const char *src, const char *dest, bool dirTransfer = false, const char *suffix = "");

    virtual int installModule(SWMgr *destMgr, const char *fromLocation, const char *modName, InstallSource *is = 0);


    virtual int refreshRemoteSource(InstallSource *is);


    virtual int refreshRemoteSourceConfiguration();


    virtual bool isUserDisclaimerConfirmed() const; /* {

        bool confirmed = userDisclaimerConfirmed;
        
        if (!confirmed) {
            cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
            cout << "                -=+* WARNING *+=- -=+* WARNING *+=-\n\n\n";
            cout << "Although Install Manager provides a convenient way for installing\n";
            cout << "and upgrading SWORD components, it also uses a systematic method\n";
            cout << "for accessing sites which gives packet sniffers a target to lock\n";
            cout << "into for singling out users. \n\n\n";
            cout << "IF YOU LIVE IN A PERSECUTED COUNTRY AND DO NOT WISH TO RISK DETECTION,\n";
            cout << "YOU SHOULD *NOT* USE INSTALL MANAGER'S REMOTE SOURCE FEATURES.\n\n\n";
            cout << "Also, Remote Sources other than CrossWire may contain less than\n";
            cout << "quality modules, modules with unorthodox content, or even modules\n";
            cout << "which are not legitimately distributable.  Many repositories\n";
            cout << "contain wonderfully useful content.  These repositories simply\n";
            cout << "are not reviewed or maintained by CrossWire and CrossWire\n";
            cout << "cannot be held responsible for their content. CAVEAT EMPTOR.\n\n\n";
            cout << "If you understand this and are willing to enable remote source features\n";
            cout << "then type yes at the prompt\n\n";
            cout << "enable? [no] ";

            char prompt[10];
            fgets(prompt, 9, stdin);
            confirmed = (!strcmp(prompt, "yes\n"));
            cout << "\n";
        }
        return confirmed;
    } */


    void setUserDisclaimerConfirmed(bool val) { InstallMgr::userDisclaimerConfirmed = val; }


    virtual bool getCipherCode(const char *modName, SWConfig *config) {
        (void) modName; (void) config;  // to avoid "unused variable" warnings
        return false;

        /*
        A sample implementation, roughly taken from the windows installmgr:

        SectionMap::iterator section;
        ConfigEntMap::iterator entry;
        SWBuf tmpBuf;
        section = config->Sections.find(modName);
        if (section != config->Sections.end()) {
            entry = section->second.find("CipherKey");
            if (entry != section->second.end()) {
                entry->second = ASK_USER_FOR_CIPHER_CODE();
                config->Save();

                // LET'S SHOW THE USER SOME SAMPLE TEXT FROM THE MODULE
                SWMgr *mgr = new SWMgr();
                SWModule *mod = mgr->getModule(modName);
                mod->setKey("Ipet 2:12");
                tmpBuf = mod->StripText();
                mod->setKey("gen 1:10");
                tmpBuf += "\n\n";
                tmpBuf += mod->StripText();
                if (SOME_DIALOG_CONFIRMATION(SWBuf(
                            "Using your provided cipher code,   \
                            here is the data from the module.   \
                            Does this look good?\n\n") + tmpBuf.c_str())) {

                    // if USER CLICKS OK means we should return true
                    return true;
                }
                delete mgr;
            }
        }
        return false;
        */
    }



    void setFTPPassive(bool passive) { this->passive = passive; }
    bool isFTPPassive() { return passive; }

    void setTimeoutMillis(long timeoutMillis) { this->timeoutMillis = timeoutMillis; }
    long getTimeoutMillis() { return timeoutMillis; }

    void setUnverifiedPeerAllowed(bool allowed) { this->unverifiedPeerAllowed = allowed; }
    bool isUnverifiedPeerAllowed() { return unverifiedPeerAllowed; }

    void terminate();

    /************************************************************************
     * getModuleStatus - compare the modules of two SWMgrs and return a
     *  vector describing the status of each.  See MODSTAT_*
     * @param base The base SWMgr to compare-- usually represents what is currently installed
     * @param other The other SWMgr to compare to base-- usually represents an install source's SWMgr
     * @param utilModules whether to show user modules or utility modules; user modules is the default
     */
    static std::map<SWModule *, int> getModuleStatus(const SWMgr &base, const SWMgr &other, bool utilModules = false);

    /************************************************************************
     * isDefaultModule - allows an installation to provide a set of modules
     *   in installMgr.conf like:
     *     [General]
     *     DefaultMod=KJV
     *     DefaultMod=StrongsGreek
     *     DefaultMod=Personal
     *   This method allows a user interface to ask if a module is specified
     *   as a default in the above way.  The logic is, if no modules are
     *   installed then all default modules should be automatically selected for install
     *   to help the user select a basic foundation of useful modules
     */
    bool isDefaultModule(const char *modName);
};


SWORD_NAMESPACE_END

#endif