prodinstlib.cpp

linux下的一款播放器

        {
            if (i > 1)
            {
                i--;
                arg++;
            }
        }

        else
        {
            if(!m_bSilent && m_pCUI)
                m_pCUI->ShowErrorMessage  ("ERROR: unknown command-line option: %s\n", *arg);
        }
    }
}

/************************************************************************
 * ProductInstaller::RandomPort - Allocate a random port within the given range.
 */
int
ProductInstaller::RandomPort (int nMin, int nMax)
{
    int nPort;
    int* pUsedPorts = new int[m_ulNumPorts + 1];

    for(UINT32 i = 0; i <= m_ulNumPorts; i++)
    {
        pUsedPorts[i] = m_pPorts[i].nPort; 
    }
    pUsedPorts[m_ulNumPorts] = 0;

    nPort = GenerateRandomPort (nMin, nMax, pUsedPorts);
    delete[] pUsedPorts;

    return nPort;
}

/************************************************************************
 * GenerateRandomPort - Allocate a random port within the given range.
 */
int
ProductInstaller::GenerateRandomPort(int nMin, int nMax, int pUsedPorts[])
{
    int nPort=0;
    int i=0;

    while (1)
    {
        nPort = random() % (nMax - nMin) + nMin;
        if (nPort == 554 ||
            nPort == 1090 ||
            nPort == 1337 ||
            nPort == 1091 ||
            nPort == 3030 ||
            nPort == 4040 ||
            nPort == 5050 ||
            nPort == 6060 ||
            nPort == 7070 ||
            nPort == 8080 ||
            nPort == 7802 ||
            nPort == 7878 ||
            nPort == 31337)
        {
            continue;
        }
        for (i=0; pUsedPorts[i]; ++i)
        {
            if (nPort == pUsedPorts[i])
                continue;
        }

        break;
    }

    return nPort;
}


/************************************************************************
 * ProductInstaller::GenerateRandomPasswords
 *
 * Used for non-interactive install.
 */
void
ProductInstaller::GenerateRandomPasswords(void)
{
    if (!m_szAdminPass)
    {
        m_szAdminPass = PasswordTool::GenerateRandomPassword();
    }
    if (!m_szEncPass)
    {
        m_szEncPass = PasswordTool::GenerateRandomPassword();
    }
    if (!m_szMonPass)
    {
        m_szMonPass = PasswordTool::GenerateRandomPassword();
    }
}


/************************************************************************
 * ProductInstaller::UpdatePasswordDatabase - update the flat-file password 
 * database
 *
 * XXXDC -- our password databases are lame -- FIXME
 */
void
ProductInstaller::UpdatePasswordDatabases()
{
    char szSaveDir[PATH_MAX];
    getcwd(szSaveDir, PATH_MAX);
    if (chdir(m_szDestDir) != 0)
    {
        m_pCUI->ShowErrorMessage("Error accessing directory %s (%s)\n",
            m_szDestDir, strerror(errno));
        return;
    }

    // need to make sure these directories exist
    mkdir("adm_b_db/users", 0755);
    mkdir("adm_b_db/guids", 0755);
    mkdir("adm_b_db/logs", 0755);
    mkdir("adm_b_db/redirect", 0755);

    PasswordTool::AddPasswordFileEntry("adm_b_db", m_szAdminUser,
                                       m_szAdminPass, NULL);

    chdir(szSaveDir);
}

/************************************************************************
 * ProductInstaller::CreateConfigFile - Create a custom config file.
 */
void
ProductInstaller::CreateConfigFile(const char* szOutputCfg)
{
    FILE* fp=0;

    char szSaveDir[PATH_MAX];
    getcwd(szSaveDir, PATH_MAX);
    if (chdir(m_szDestDir) != 0)
    {
        if(!m_bSilent)
        {
            m_pCUI->ShowErrorMessage("Error accessing directory %s (%s)\n",
                m_szDestDir, strerror(errno));
        }
        return;
    }

    char* szConfig = FormatConfigFile();

    fp = fopen(szOutputCfg, "w");
    if (fp)
    {
        fprintf(fp, "%s", szConfig);
        fclose(fp);
    }
    else
    {
        m_pCUI->ShowErrorMessage("Error creating %s (%s)\n", szOutputCfg, 
            strerror(errno));
    }

    chdir(szSaveDir);
    HX_VECTOR_DELETE(szConfig);
}

/************************************************************************
 * ProductInstaller::BackupOldFiles
 */
void
ProductInstaller::BackupOldFiles()
{
    char szSaveDir[PATH_MAX];
    getcwd(szSaveDir, PATH_MAX);
    if (chdir(m_szDestDir) != 0)
    {
        if(!m_bSilent)
        {
            m_pCUI->ShowErrorMessage("Error accessing directory %s (%s)\n",
                m_szDestDir, strerror(errno));
        }
        return;
    }

    BackupIfPresent("Bin");
    BackupIfPresent("Plugins");
    BackupIfPresent("Lib");
    BackupIfPresent(m_szOutputCfg);
    BackupIfPresent(m_szBackupCfg);

    chdir(szSaveDir);
}


/************************************************************************
 * ProductInstaller::ReadInstallerDefaults
 *
 * Read external installer configuration file, setting various defaults
 *
 * Lines look like:
 *  DefInstallPath=/some/directory
 *  AdminPassword=red
 *  AdminPort=5004
 *  AdminUserID=color
 *  EncoderPassword=red
 *  EncoderUserID=color
 *  EncoderRealm=jedi.dev.prognet.com.EncoderRealm
 *  HTTPPort=8081
 *  InstallService=0
 *  MonitorPassword=red
 *  MonitorPort=5005
 *  PNAPort=5003
 *  RTSPPort=5001
 * 
 * NOTE: If you change this list be sure to updat the -h help text
 * in package_info.h!
 */
int
ProductInstaller::ReadInstallerDefaults(const char* szFile)
{
    InstCfgItem pCfgItem[] =
    {
        //config file settings
        { "DefInstallPath",   (void**)&m_szDestDir,        CFG_STR },
        { "AdminUserID",      (void**)&m_szAdminUser,      CFG_STR },
        { "AdminPassword",    (void**)&m_szAdminPass,      CFG_STR },
        { "AdminRealm",       (void**)&m_szAdminRealm,     CFG_STR },
        { "AdminPort",        (void**)&m_pPorts[ADMIN_PORT].nPort, 
                                                           CFG_INT },
        { "EncoderUserID",    (void**)&m_szEncUser,        CFG_STR },
        { "EncoderPassword",  (void**)&m_szEncPass,        CFG_STR },
        { "EncoderRealm",     (void**)&m_szEncRealm,       CFG_STR },
        { "ContentRealm",     (void**)&m_szContentRealm,   CFG_STR },
        { "MonitorPassword",  (void**)&m_szMonPass,        CFG_STR },
        { "MonitorPort",      (void**)&m_pPorts[MON_PORT].nPort,
                                                           CFG_INT },
        { "HTTPPort",         (void**)&m_pPorts[HTTP_PORT].nPort,
                                                           CFG_INT },
        { "RTSPPort",         (void**)&m_pPorts[RTSP_PORT].nPort,
                                                           CFG_INT },
        { "PNAPort",          (void**)&m_pPorts[PNA_PORT].nPort,
                                                           CFG_INT },
        { "LoggingStyle",     (void**)&m_szLoggingStyle,   CFG_STR },

        //other behavior flags
        { "BackupOldFiles",        (void**)&m_bBackupOldFiles, CFG_BOOL },
        { "SilentInstall",         (void**)&m_bSilent,         CFG_BOOL },
        { "NonInteractiveInstall", (void**)&m_bNonInteractive, CFG_BOOL },
        { "DebugInstall",          (void**)&m_bDebug,          CFG_BOOL },
#ifdef _WIN32
        { "InstallService",   (void**)&m_bNTService,      CFG_BOOL },
        { "Service.Logon",    (void**)&m_szServiceUser,   CFG_STR },  //XXX NT
        { "Service.Name",     (void**)&m_szServiceName,   CFG_STR },  //XXX NT
        { "Service.Password", (void**)&m_szServicePass,   CFG_STR },  //XXX NT
#endif // _WIN32
        //this must be the last entry!
        { 0, 0, CFG_STR }
    };

    return ReadInstallerConfigItems(szFile, (const InstCfgItem*)pCfgItem, NULL);
}


/************************************************************************
 * VersionBanner - Return the version banner string
 */
const char*
ProductInstaller::VersionBanner(void)
{
    static char* pMsg=0;
    if (!pMsg)
    {
        pMsg = new char[256];
        sprintf (pMsg, "\n%s Installer", PackageInfo::VersionString());
    }
    return pMsg;
}


/************************************************************************
 * SetDefaultDir:
 * Sets the global directory to the default value.
 * On Unix platforms, just the current working directory.
 * On Windows, it's the current install directory if there is one, 
 * otherwise a subdir of Program Files.
 */
#ifdef _WIN32
extern const char* SZ_DEFAULT_PATH;

void
ProductInstaller::SetDefaultDir(char* &szDestDir)
{
    HX_VECTOR_DELETE(szDestDir);

    szDestDir = new char[MAX_PATH+1];
    if(!szDestDir)
    {
        return;
    }

    HKEY hKey;
    int res;
    DWORD dwSize;
    DWORD dwType;

    /* 
     * Default to "Program Files\Prog Name".
     */

    // Open the Software\Windows\CurrentVersion key
    res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, SZ_PROGFILES_KEY, 0, KEY_READ, 
            &hKey);

    if(res == ERROR_SUCCESS)
    {
        dwSize = MAX_PATH+1;

        // Get the ProgramFilesDir value
        res = RegQueryValueEx(hKey, SZ_PROGFILES_VAL, NULL, &dwType,
                (LPBYTE)szDestDir, &dwSize);

        RegCloseKey(hKey);
        if(res == ERROR_SUCCESS && dwType == REG_SZ)
        {
            // We got the program files directory, now add the rest
            size_t unLen = strlen(szDestDir);
            if(unLen != 0)
            {
                strncat(szDestDir, SZ_DEFAULT_PATH, MAX_PATH - unLen);
                return;
            }
        }
    }

    /*
     * We couldn't get ProgramFilesDir! just go with '.'
     */
    if(!_getcwd(szDestDir, MAX_PATH))
    {
        // give up.
        szDestDir[0] = '\0';
    }
}

BOOL
ProductInstaller::GetLocalHostName(char*& szHostname)
{
    szHostname = new char[MAX_COMPUTERNAME_LENGTH + 1];
    if(!szHostname)
    {
        return FALSE;
    }

    szHostname[0] = '\0';

    DWORD dwLen = MAX_COMPUTERNAME_LENGTH + 1;
    BOOL bRes = GetComputerName(szHostname, &dwLen);

    if(!bRes && dwLen > MAX_COMPUTERNAME_LENGTH)
    {
        // The string was not big enough
        delete[] szHostname;
        szHostname = new char[dwLen++];
        
        bRes = GetComputerName(szHostname, &dwLen);
    }

    return bRes;
}

#else // _WIN32

void
ProductInstaller::SetDefaultDir(char* &szDestDir)
{
    char szTemp[PATH_MAX];
    getcwd(szTemp, PATH_MAX);
    int i = strlen(szTemp);
    while (i >= 0)
    {
        if (szTemp[i] == '/')
        {
            szTemp[i] = '\0';  //wack off the final (temp) directory
            i=0;
        }
        --i;
    }

    // get the product name and remove whitespace
    const char* pProdName = ProductVersion::ProductName();
    char szTemp2[PATH_MAX];
    char* pCursor = szTemp2;
    while (*pProdName && pCursor != szTemp2 + PATH_MAX)