root/freepbx/trunk/install_amp

#!/usr/bin/php -q
<?php

// define versions. latest version must be last
$versions = array(
        '1.10.005',
        '1.10.006',
        '1.10.007beta1',
        '1.10.007beta2',
        '1.10.007',
        '1.10.007a',
        '1.10.008beta1',
        '1.10.008beta2',
        '1.10.008beta3',
        '1.10.008',
        '1.10.009beta1',
        '1.10.009beta2',
        '1.10.009',
        '1.10.010beta1',
        '1.10.010',
        '2.0beta1',
        '2.0beta2',
        '2.0beta3',
        '2.0beta4',
        '2.0beta5',
        '2.0.0',
        '2.0.1',
        '2.1beta1',
        '2.1beta2',
        '2.1beta3',
        '2.1.0',
        '2.1.1',
        '2.2.0beta1'
    );

define("AMP_CONF", "/etc/amportal.conf");

define("ASTERISK_CONF", "/etc/asterisk/asterisk.conf");

define("UPGRADE_DIR", dirname(__FILE__)."/upgrades");

/********************************************************************************************************************/

function out($text) {
    echo $text."\n";
}

function outn($text) {
    echo $text;
}

function error($text) {
    echo "[ERROR] ".$text."\n";
}

function fatal($text) {
    echo "[FATAL] ".$text."\n";
    exit(1);
}

function debug($text) {
    global $debug;
    
    if ($debug) echo "[DEBUG] ".$text."\n";
}

function showHelp() {
    out("Optional parameters:");
    out("  --help, -h, -?           Show this help");
    out("  --dbhost <ip address>    Use a remote database server");
    out("  --dbname databasename    Use database name specified, instead of 'asterisk'");
    out("  --username <user>        Use <user> to connect to db and write config");
    out("  --password <pass>        Use <pass> to connect to db and write config");
/*    out("  --fopwebroot <path>      Web path where fop will be installed");
    out("  --webroot <path>         Web root where freepbx will be installed");
    out("  --cgibin <path>          Path where cgi-bin's lives");
    out("  --bin <path>             Path of asterisk binaries");
    out("  --sbin <path>            Path of system admin binaries");
    out("  --asteriskuser <user>    Asterisk Manager username");
    out("  --asteriskpass <pass>    Asterisk Manager password");
    out("  --systemconfig <path>    System config files"); */
    out("  --debug                  Enable debug output");
    out("  --dry-run                Don't actually do anything");
    out("  --force-version <ver>    Force upgrade from version <ver>");
    out("  --no-files               Just run updates without installing files");
}

function install_parse_amportal_conf($filename) {
    $file = file($filename);
    foreach ($file as $line) {
        if (preg_match("/^\s*([a-zA-Z0-9]+)\s*=\s*(.*)\s*([;#].*)?/",$line,$matches)) { 
            $conf[ $matches[1] ] = $matches[2];
        }
    }
    return $conf;
}

function install_parse_asterisk_conf($filename) {
    $file = file($filename);
    foreach ($file as $line) {
        if (preg_match("/^\s*([a-zA-Z0-9]+)\s* => \s*(.*)\s*([;#].*)?/",$line,$matches)) { 
            $conf[ $matches[1] ] = $matches[2];
        }
    }
    return $conf;
}

//get the version number
function install_getversion() {
    global $db;
    $sql = "SELECT value FROM admin WHERE variable = 'version'";
    $results = $db->getAll($sql);
    if(DB::IsError($results)) {
        return false;
    }
    return $results[0][0];
}

//set the version number
function setversion($version) {
    global $db;
    $sql = "UPDATE admin SET value = '".$version."' WHERE variable = 'version'";
    debug($sql);
    $result = $db->query($sql); 
    if(DB::IsError($result)) {     
        die($result->getMessage()); 
    }
}

function write_amportal_conf($filename, $conf) {
    $file = file($filename);
    // parse through the file
    foreach (array_keys($file) as $key) {
        if (preg_match("/^\s*([a-zA-Z0-9]+)\s*=\s*(.*)\s*([;#].*)?/",$file[$key],$matches)) {
            // this is an option=value line
            if (isset($conf[ $matches[1] ])) {
                // rewrite the line, if we have this in $conf
                $file[$key] = $matches[1]."=".$conf[ $matches[1] ]."\n";
                // unset it so we know what's new
                unset($conf[ $matches[1] ]);
            }
        }
    }
    
    // add new entries
    foreach ($conf as $key=>$val) {
        $file[] = $key."=".$val."\n";
    }
    
    // write the file
    if (!$fd = fopen($filename, "w")) {
        fatal("Could not open ".$filename." for writing");
    }
    fwrite($fd, implode("",$file));
    fclose($fd);
}

function ask_overwrite($file1, $file2) {
    global $check_md5s;
    do {
        out($file2." has been changed from the original version.");
        outn("Overwrite (y=yes/a=all/n=no/d=diff/s=shell/x=exit)? ");
        $key = fgets(STDIN,1024);
        switch (strtolower($key[0])) {
            case "y": return true; 
            case "a": $check_md5s=false; return true;
            case "n": return false;
            case "d": 
                out("");
                passthru("diff -u ".$file2." ".$file1);
            break;
            case "s":
                if (function_exists("pcntl_fork")) {
                    out("");
                    $shell = (isset($_ENV["SHELL"]) ? $_ENV["SHELL"] : "/bin/bash");
                    out("Dropping to shell. Type 'exit' to return");
                    out("-> Original file:  ".$file2);
                    out("-> New file:       ".$file1);
                    
                    $pid = pcntl_fork();
                    if ($pid == -1) {
                        out("[ERROR] cannot fork");
                    } else if ($pid) {
                        // parent
                        pcntl_waitpid($pid, $status);
                        // we wait till the child exits/dies/whatever
                    } else {
                        pcntl_exec($shell, array(), $_ENV);
                    }
                    
                    out("Returned from shell");
                } else {
                    out("[ERROR] PHP not built with process control (--enable-pcntl) support: cannot spawn shell");
                }
                
            break;
            case "x": 
                out("-> Original file:  ".$file2);
                out("-> New file:       ".$file1);
                out("Exiting install program.");
                exit(1);
            break;
        }
        out("");
    } while(1);
}

function amp_mkdir($directory, $mode = "0755", $recursive = false) {
    debug("mkdir ".$directory.", ".$mode);
    $ntmp = sscanf($mode,"%o",$modenum); //assumes all inputs are octal
    if (version_compare(phpversion(), 5.0) < 0) {
        // php <5 can't recursively create directories
        if ($recursive) {
            $output = false;
            $return_value = false;
            exec("mkdir -m ".$mode." -p ".$directory,  $output, $return_value);
            return ($return_value == 0);
        } else {
            return mkdir($directory, $modenum);
        }
    } else {
        return mkdir($directory, $modenum, $recursive);
    }
}

/** Recursively copy a directory
 */
function recursive_copy($dirsourceparent, $dirdest, &$md5sums, $dirsource = "") {
    global $dryrun;
    global $check_md5s;
    global $amp_conf;
    global $asterisk_conf;
    
    if ($dirsource && ($dirsource[0] != "/")) $dirsource = "/".$dirsource;
    
    if (is_dir($dirsourceparent.$dirsource)) $dir_handle = opendir($dirsourceparent.$dirsource);
    
    /*
    echo "dirsourceparent: "; var_dump($dirsourceparent);
    echo "dirsource: "; var_dump($dirsource);
    echo "dirdest: "; var_dump($dirdest);
    */
    
    while (isset($dir_handle) && ($file = readdir($dir_handle))) {
        if (($file!=".") && ($file!="..") && ($file != "CVS") && ($file != ".svn")) {
            $source = $dirsourceparent.$dirsource."/".$file;
            $destination =  $dirdest.$dirsource."/".$file;
            
            // configurable in amportal.conf
            if (strpos($destination,"htdocs_panel")) {
                $destination=str_replace("/htdocs_panel",trim($amp_conf["FOPWEBROOT"]),$destination);
            } else {
                $destination=str_replace("/htdocs",trim($amp_conf["AMPWEBROOT"]),$destination);
            }
            $destination=str_replace("/htdocs_panel",trim($amp_conf["FOPWEBROOT"]),$destination);
//            $destination=str_replace("/cgi-bin",trim($amp_conf["AMPCGIBIN"]),$destination);
            $destination=str_replace("/bin",trim($amp_conf["AMPBIN"]),$destination);
            $destination=str_replace("/sbin",trim($amp_conf["AMPSBIN"]),$destination);
            
            // the following are configurable in asterisk.conf
            $destination=str_replace("/astetc",trim($asterisk_conf["astetcdir"]),$destination);
            $destination=str_replace("/mohmp3",trim($asterisk_conf["astvarlibdir"])."/mohmp3",$destination);
            $destination=str_replace("/astvarlib",trim($asterisk_conf["astvarlibdir"]),$destination);
            $destination=str_replace("/agi-bin",trim($asterisk_conf["astagidir"]),$destination);
            $destination=str_replace("/sounds",trim($asterisk_conf["astvarlibdir"])."/sounds",$destination);
            
            // if this is a directory, ensure destination exists
            if (is_dir($source)) {
                if (!file_exists($destination)) {
                    if ((!$dryrun) && ($destination != "")) {
                        amp_mkdir($destination, "0750", true);
                    }
                }
            }
            
            if (!is_dir($source)) {
                if ($check_md5s && file_exists($destination) && isset($md5sums[$destination]) && (md5_file($destination) != $md5sums[$destination])) {
                    $overwrite = ask_overwrite($source, $destination, $md5sums);
                } else {
                    $overwrite = true;
                }
                
                if ($overwrite) {
                    debug("copy ".$source." -> ".$destination);
                    if (!$dryrun) {
                        copy($source, $destination);
                    }
                } else {
                    debug("not overwriting ".$destination);
                }
            } else {
                //echo "recursive_copy($dirsourceparent, $dirdest, $md5sums, $dirsource/$file)";
                recursive_copy($dirsourceparent, $dirdest, $md5sums, $dirsource."/".$file);
            }
        }
    }
    
    if (isset($dir_handle)) closedir($dir_handle);
    
    return true;
}

function read_md5_file($filename) {
    $md5 = array();
    if (file_exists($filename)) {
        foreach (file($filename) as $line) {
            if (preg_match("/^([a-f0-9]{32})\s+(.*)$/", $line, $matches)) {
                $md5[ "/".$matches[2] ] = $matches[1];
            }
        }
    }
    return $md5;
}

/** Include a .php file
 * This is a function just to keep a seperate context
 */
function run_included($file) {
    global $db;
    global $amp_conf;
    
    include($file);
}


function install_sqlupdate( $file )
{
    global $db;
    global $dryrun;

    out("-> Running SQL script ".UPGRADE_DIR."/".$version."/".$file);
    // run sql script
    $fd = fopen(UPGRADE_DIR."/".$version."/".$file, "r");
    $data = "";
    while (!feof($fd)) {
        $data .= fread($fd, 1024);
    }
    fclose($fd);

    preg_match_all("/((SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER).*);\s*\n/Us", $data, $matches);
    
    foreach ($matches[1] as $sql) {
        debug($sql);
        if (!$dryrun) {
            $result = $db->query($sql); 
            if(DB::IsError($result)) {     
                fatal($result->getDebugInfo()."\" while running ".$file."\n"); 
            }
        }
    }
}

/** Install a particular version
 */
function install_upgrade($version) {
    global $db;
    global $dryrun;
    global $amp_conf;
    
    $db_engine = $amp_conf["AMPDBENGINE"];
    
    if (is_dir(UPGRADE_DIR."/".$version)) {
        // sql scripts first
        $dir = opendir(UPGRADE_DIR."/".$version);
        while ($file = readdir($dir)) {
            if (($file[0] != ".") && is_file(UPGRADE_DIR."/".$version."/".$file)) {
                if ( (strtolower(substr($file,-4)) == ".sqlite") && ($db_engine == "sqlite") ) {
                    install_sqlupdate( $file );
                }
                elseif ((strtolower(substr($file,-4)) == ".sql") && ( ($db_engine  == "mysql")  ||  ($db_engine  == "pgsql")) ) {
                    install_sqlupdate( $file );
                }
            }
        }

                // now non sql scripts
                $dir = opendir(UPGRADE_DIR."/".$version);
                while ($file = readdir($dir)) {
                        if (($file[0] != ".") && is_file(UPGRADE_DIR."/".$version."/".$file)) {
                                if (strtolower(substr($file,-4)) == ".sql") {
                    // sql scripts were dealt with first
                                } else if (strtolower(substr($file,-4)) == ".php") {
                                        out("-> Running PHP script ".UPGRADE_DIR."/".$version."/".$file);
                                        if (!$dryrun) {
                                                run_included(UPGRADE_DIR."/".$version."/".$file);
                                        }

                                } else if (is_executable(UPGRADE_DIR."/".$version."/".$file)) {
                                        out("-> Executing ".UPGRADE_DIR."/".$version."/".$file);
                                        if (!$dryrun) {
                                                exec(UPGRADE_DIR."/".$version."/".$file);
                                        }
                                } else {
                                        error("-> Don't know what to do with ".UPGRADE_DIR."/".$version."/".$file);
                                }
                        }
                }

    }
}

/** Invoke upgrades
 * @param $versions array    The version upgrade scripts to run
 */
function run_upgrade($versions) {
    global $dryrun;
    
    foreach ($versions as $version) {
        out("Upgrading to ".$version."..");
        install_upgrade($version);
        if (!$dryrun) {
            setversion($version);
        }
        out("Upgrading to ".$version."..OK");
    }
}

/** Write AMP-generated configuration files
 */
function generate_configs() {
    global $amp_conf;
    global $dryrun;
    global $debug;
    
    out("Generating Configurations.conf..");
    if (!$dryrun)
        passthru("su - asterisk -c ".trim($amp_conf["AMPBIN"])."/retrieve_conf ".($debug ? ' --debug' : ''));
}


/** Set reload flag for AMP admin
 */
function install_needreload() {
    global $db;
    $sql = "UPDATE admin SET value = 'true' WHERE variable = 'need_reload'"; 
    $result = $db->query($sql); 
    if(DB::IsError($result)) {     
        die($result->getMessage()); 
    }
}


/** Collect AMP settings
 */
function collect_settings($filename, $dbhost = '', $dbuser = '', $dbpass = '', $dbname = 'asterisk') {
    out("Creating new $filename");
    
    outn("Enter your USERNAME to connect to the '$dbname' database:\n [".($dbuser ? $dbuser : "asteriskuser")."] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPDBUSER"] = ($dbuser ? $dbuser : "asteriskuser");
    else $amp_conf["AMPDBUSER"] = $key;
    
    outn("Enter your PASSWORD to connect to the '$dbname' database:\n [".($dbpass ? $dbpass : "amp109")."] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPDBPASS"] = ($dbpass ? $dbpass : "amp109");
    else $amp_conf["AMPDBPASS"] = $key;
    
    outn("Enter the hostname of the '$dbname' database:\n [".($dbhost ? $dbhost : "localhost")."] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPDBHOST"] = ($dbhost ? $dbhost : "localhost");
    else $amp_conf["AMPDBHOST"] = $key;
    
    outn("Enter a USERNAME to connect to the Asterisk Manager interface:\n [admin] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPMGRUSER"] = "admin";
    else $amp_conf["AMPMGRUSER"] = $key;
    
    outn("Enter a PASSWORD to connect to the Asterisk Manager interface:\n [amp111] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPMGRPASS"] = "amp111";
    else $amp_conf["AMPMGRPASS"] = $key;
    
    do {
        out("Enter the path to use for your AMP web root:\n [/var/www/html] ");
        $key = trim(fgets(STDIN,1024));
        if (preg_match('/^$/',$key)) $amp_conf["AMPWEBROOT"] = "/var/www/html";
        else $amp_conf["AMPWEBROOT"] = rtrim($key,'/');
        if (is_dir($amp_conf["AMPWEBROOT"])) {
            break;
        } else if (amp_mkdir($amp_conf["AMPWEBROOT"],"0755",true)){
            out("Created ".$amp_conf["AMPWEBROOT"]);
            break;
        } else {
            fatal("Cannot create ".$amp_conf["AMPWEBROOT"]."!");
        }
    } while(1);
    
    do {
        out("Enter the path to use for your FOP web root:\n [/var/www/html/panel] ");
        $key = trim(fgets(STDIN,1024));
        if (preg_match('/^$/',$key)) $amp_conf["FOPWEBROOT"] = "/var/www/html/panel";
        else $amp_conf["FOPWEBROOT"] = rtrim($key,'/');
        if (is_dir($amp_conf["FOPWEBROOT"])) {
            break;
        } else if (amp_mkdir($amp_conf["FOPWEBROOT"],"0755",true)){
            out("Created ".$amp_conf["FOPWEBROOT"]);
            break;
        } else {
            fatal("Cannot create ".$amp_conf["FOPWEBROOT"]."!");
        }
    } while(1);
    
//    do {
//        outn("Enter the path to your Apache cgi-bin:\n [/var/www/cgi-bin] ");
//        $key = trim(fgets(STDIN,1024));
//        if (preg_match('/^$/',$key)) $amp_conf["AMPCGIBIN"] = "/var/www/cgi-bin";
//        else $amp_conf["AMPCGIBIN"] = rtrim($key,'/');
//        if (is_dir($amp_conf["AMPCGIBIN"])) break;
//        else fatal($amp_conf["AMPCGIBIN"]." is not a directory!");
//    } while(1);
    
    outn("Enter the IP ADDRESS or hostname used to access the AMP web-admin:\n [xx.xx.xx.xx] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPWEBADDRESS"] = "xx.xx.xx.xx";
    else $amp_conf["AMPWEBADDRESS"] = $key;
    
    outn("Enter a PASSWORD to perform call transfers with the Flash Operator Panel:\n [passw0rd] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["FOPPASSWORD"] = "passw0rd";
    else $amp_conf["FOPPASSWORD"] = $key;
    
    outn("Use simple Extensions [extensions] admin or separate Devices and Users [deviceanduser]?\n [extensions] ");
    $key = trim(fgets(STDIN,1024));
    if (preg_match('/^$/',$key)) $amp_conf["AMPEXTENSIONS"] = "extensions";
    else $amp_conf["AMPEXTENSIONS"] = $key;
    
    do {
        out("Enter directory in which to store AMP executable scripts:\n [/var/lib/asterisk/bin] ");
        $key = trim(fgets(STDIN,1024));
        if (preg_match('/^$/',$key)) $amp_conf["AMPBIN"] = "/var/lib/asterisk/bin";
        else $amp_conf["AMPBIN"] = rtrim($key,'/');
        if (is_dir($amp_conf["AMPBIN"])) {
            break;
        } else if (amp_mkdir($amp_conf["AMPBIN"],"0755",true)){
            out("Created ".$amp_conf["AMPBIN"]);
            break;
        } else {
            fatal("Cannot create ".$amp_conf["AMPBIN"]."!");
        }
    } while(1);
    
    do {
        out("Enter directory in which to store super-user scripts:\n [/usr/sbin] ");
        $key = trim(fgets(STDIN,1024));
        if (preg_match('/^$/',$key)) $amp_conf["AMPSBIN"] = "/usr/sbin";
        else $amp_conf["AMPSBIN"] = rtrim($key,'/');
        if (is_dir($amp_conf["AMPSBIN"])) {
            break;
        } else if (amp_mkdir($amp_conf["AMPSBIN"],"0755",true)){
            out("Created ".$amp_conf["AMPSBIN"]);
            break;
        } else {
            fatal("Cannot create ".$amp_conf["AMPSBIN"]."!");
        }
    } while(1);
    
    // write amportal.conf
    write_amportal_conf($filename, $amp_conf);
    outn(AMP_CONF." written");
}

/********************************************************************************************************************/

// **** Make sure we have STDIN etc

// from  ben-php dot net at efros dot com   at  php.net/install.unix.commandline
if (version_compare(phpversion(),'4.3.0','<') || !defined("STDIN")) {
    define('STDIN',fopen("php://stdin","r"));
    define('STDOUT',fopen("php://stdout","r"));
    define('STDERR',fopen("php://stderr","r"));
    register_shutdown_function( create_function( '' , 'fclose(STDIN); fclose(STDOUT); fclose(STDERR); return true;' ) );
}
   
// **** Make sure we have PEAR's DB.php, and include it

outn("Checking for PEAR DB..");
if (! @ include('DB.php')) {
    out("FAILED");
    fatal("PEAR must be installed (requires DB.php). Include path: ".ini_get("include_path"));
}
out("OK");

// **** Make sure we have PEAR's GetOpts.php, and include it

outn("Checking for PEAR Console::Getopt..");
if (! @ include("Console/Getopt.php")) {
    out("FAILED");
    fatal("PEAR must be installed (requires Console/Getopt.php). Include path: ".ini_get("include_path"));
}
out("OK");

// **** Parse out command-line options
$shortopts = "h?u:p:";
$longopts = array("help","debug","dry-run","username=","password=","force-version=","dbhost=","no-files","dbname=");

$args = Console_Getopt::getopt(Console_Getopt::readPHPArgv(), $shortopts, $longopts);
if (is_object($args)) {
    // assume it's PEAR_ERROR
    out($args->message);
    exit(255);
}

$debug = false;
$dryrun = false;
$install_files = true;

//initialize variables to avoid php notices
$dbhost = null; 
$dbname = null; 
$new_username = null;
$new_password = null;

foreach ($args[0] as $arg) {
    switch ($arg[0]) {
        case "--help": case "h": case "?":
            showHelp();
            exit(10);
        break;
        case "--dry-run":
            out("Dry-run only, nothing will be changed");
            $dryrun = true;
        break;
        case "--debug":
            $debug = true;
            debug("Debug mode enabled");
        break;
        case "--username": case "u":
            out("Using username: ".$arg[1]);
            $new_username = $arg[1];
        break;
        case "--password": case "p":
            out("Using password: ".str_repeat("*",strlen($arg[1])));
            $new_password = $arg[1];
        break;
        case "--force-version":
            $version = $arg[1];
            out("Forcing upgrade from version ".$version);
        break;
        case "--dbhost":
            $dbhost = $arg[1];
            out("Using remote database server at ".$dbhost);
        break;
        case "--dbname":
            $dbname = $arg[1];
            out("Using database ".$dbname);
        break;
        case "--no-files":
            $install_files = false;
            out("Running upgrade only, without installing files.");
        break;
/*        case "--fopwebroot":
            $fopwebroot = $arg[1];
            out("Using fop at ".$fopwebroot);
        break;
        case "--webroot":
            $webroot = $arg[1];
            out("Using Webroot at ".$webroot);
        break;
        case "--cgibin":
            $cgibin = $arg[1];
            out("Using CGI-BIN at ".$cgibin);
        break;
        case "--bin":
            $bin = $arg[1];
            out("Using bin at ".$bin);
        break;
        case "--sbin":
            $sbin = $arg[1];
            out("Using sbin ar ".$sbin);
        break;
        case "--asteriskuser":
            $asteriskuser = $arg[1];
            out("Using Asterisk user ".$asteriskuser);
        break;
        case "--asteriskpass":
            $asteriskpass = $arg[1];
            out("Using asteriskpass ".str_repeat("*",strlen($arg[1])));
        break;
        case "--systemconfig":
            $systemconfig = $arg[1];
            out("Using system config at ". $systemconfig);
        break; */

    }
}


// **** Look for user = root

outn("Checking user..");
//$current_user=(isset($_ENV["USER"]) ? $_ENV["USER"] : exec('whoami',$output));
$euid = (posix_getpwuid(posix_geteuid()));
$current_user = $euid['name'];
if ($current_user != "root"){
    out("FAILED");
    fatal($argv[0]." must be run as root");
}
out("OK");


// **** Check for amportal.conf, create if necessary

outn("Checking for ".AMP_CONF."..");
if (!file_exists(AMP_CONF)) {
    out(AMP_CONF." does not exist, copying default");
    copy("amportal.conf", AMP_CONF);
    collect_settings(AMP_CONF, $dbhost, $new_username, $new_password, 'asterisk');
}
out("OK");

// **** read amportal.conf

outn("Reading ".AMP_CONF."..");
$amp_conf = install_parse_amportal_conf(AMP_CONF);
if (count($amp_conf) == 0) {
    fatal("FAILED");
}
out("OK");

// Ensure our "critical" variables are set.  We absolutely need these to copy in files.

if (!array_key_exists("AMPWEBROOT",$amp_conf)) {
    out("Adding AMPWEBROOT option to amportal.conf - using AMP default");
    $amp_conf["AMPWEBROOT"] = "/var/www/html";
}

if (!array_key_exists("FOPWEBROOT",$amp_conf)) {
    out("Adding FOPWEBROOT option to amportal.conf - using AMP default");
    $amp_conf["FOPWEBROOT"] = $amp_conf["AMPWEBROOT"]."/panel";
}

if (!array_key_exists("AMPBIN",$amp_conf)) {
    out("Adding AMPBIN option to amportal.conf - using AMP default");
    $amp_conf["AMPBIN"] = "/var/lib/asterisk/bin";
}

if (!array_key_exists("AMPSBIN",$amp_conf)) {
    out("Adding AMPSBIN option to amportal.conf - using AMP default");
    $amp_conf["AMPSBIN"] = "/usr/sbin";
}

if (!array_key_exists("AMPDBENGINE",$amp_conf)) {
    out("Adding AMPDBENGINE option to amportal.conf - using AMP default");
    $amp_conf["AMPDBENGINE"] = "mysql";
}
if (!array_key_exists("AMPDBNAME",$amp_conf)) {
    out("Adding AMPDBNAME option to amportal.conf - using AMP default");
    $amp_conf["AMPDBNAME"] = "asterisk";
}

if (isset($new_username)) {
    $amp_conf["AMPDBUSER"] = $new_username;
}

if (isset($new_password)) {
    $amp_conf["AMPDBPASS"] = $new_password;
}

if (isset($dbhost)) {
    $amp_conf["AMPDBHOST"] = $dbhost;
}

if (isset($dbname)) {
    $amp_conf["AMPDBNAME"] = $dbname;
}
    
// write amportal.conf
write_amportal_conf(AMP_CONF, $amp_conf);

// **** Check for amportal.conf, create if necessary

outn("Checking for ".ASTERISK_CONF."..");
if (!file_exists(ASTERISK_CONF)) {
    out(ASTERISK_CONF." does not exist, copying default");
    copy("asterisk.conf", ASTERISK_CONF);
}
out("OK");

// **** read asterisk.conf

outn("Reading ".ASTERISK_CONF."..");
$asterisk_conf = install_parse_asterisk_conf(ASTERISK_CONF);
if (count($asterisk_conf) == 0) {
    fatal("FAILED. Have you installed Asterisk?");
}
out("OK");

/* deprecated on freepbx 2.2, from now pages need to read this information 
   from $asterik_conf and not $amp_conf.
   
   this code will stay in 2.2, but in 2.3 it will be gone. developers - please
   update your code
 */
if (isset($asterisk_conf['astetcdir'])) { $amp_conf['ASTETCDIR'] = $asterisk_conf['astetcdir']; }
if (isset($asterisk_conf['astmoddir'])) { $amp_conf['ASTMODDIR'] = $asterisk_conf['astmoddir']; }
if (isset($asterisk_conf['astvarlibdir'])) { $amp_conf['ASTVARLIBDIR'] = $asterisk_conf['astvarlibdir']; }
if (isset($asterisk_conf['astagidir'])) { $amp_conf['ASTAGIDIR'] = $asterisk_conf['astagidir']; }
if (isset($asterisk_conf['astspooldir'])) { $amp_conf['ASTSPOOLDIR'] = $asterisk_conf['astspooldir']; }
if (isset($asterisk_conf['astrundir'])) { $amp_conf['ASTRUNDIR'] = $asterisk_conf['astrundir']; }
if (isset($asterisk_conf['astlogdir'])) { $amp_conf['ASTLOGDIR'] = $asterisk_conf['astlogdir']; }

write_amportal_conf(AMP_CONF, $amp_conf);

// **** Check for func_callerid.so - this is only in asterisk 1.2

outn("Checking for Asterisk 1.2..");
if (!file_exists($amp_conf["ASTMODDIR"]."/func_callerid.so")) {
    fatal("Asterisk 1.2 is required for this version of freePBX");
}
out("OK");

// **** Make sure selinux isn't enabled

outn("Checking for selinux..");
$tmpout = exec("selinuxenabled 2>&1", $tmpoutput, $sereturn);
if ($sereturn == 0) {
    fatal("selinux is ENABLED. This is not supported. Please disable selinux before using freePBX");
}
out("OK");

// **** Connect to database

outn("Connecting to database..");

$db_user = $amp_conf["AMPDBUSER"];
$db_pass = $amp_conf["AMPDBPASS"];
$db_host = $amp_conf["AMPDBHOST"];
$db_engine = $amp_conf["AMPDBENGINE"];
$db_name = $amp_conf["AMPDBNAME"];

// we still support older configurations,  and fall back 
// into mysql when no other engine is defined
if ($db_engine == "")
{
    $db_engine = "mysql";
}
    
switch ($db_engine)
{
    case "pgsql":
    case "mysql":
        // datasource in in this style: dbengine://username:password@host/database 
        if (!function_exists($db_engine.'_connect')) {
            out("FAILED");
            fatal($db_engine." PHP libraries not installed");
        }
    
        $datasource = $db_engine.'://'.$db_user.':'.$db_pass.'@'.$db_host.'/'.$db_name;
        $db = DB::connect($datasource); // attempt connection
        break;
    
    case "sqlite":
        if (! @ include('DB/sqlite.php'))
        {
            out("FAILED");
            fatal( "Your PHP installation lacks SQLite support" );
        }
    
        if (!isset($amp_conf["AMPDBFILE"]))
            die("You must setup properly AMPDBFILE in ".AMP_CONF);
    
        if (isset($amp_conf["AMPDBFILE"]) == "")
            die("AMPDBFILE in ".AMP_CONF." cannot be blank");
    
        $DSN = array (
            "database" => $amp_conf["AMPDBFILE"],
            "mode" => 0666
        );
    
        $db = new DB_sqlite();
        $db->connect( $DSN );
        break;
    
    default:
        die( "Unknown SQL engine: [$db_engine]");
}

if(DB::isError($db)) {
    out("FAILED");
    debug($db->userinfo);
    out("Try running ".$argv[0]." --username=user --password=pass  (using your own user and pass)");
    fatal("Cannot connect to database");
    
}
out("OK");


// **** Read DB for version info

if (!isset($version)) {
    outn("Checking current version of AMP..");
    $version = install_getversion();
    if (!$version) {
        out("no version information");
        out("Assuming new installation");
    } else {
        out($version);
    }
}


// **** Copy files

if ($install_files)
{
    outn("Installing new AMP files..");
    $check_md5s=true;
    $md5sums = read_md5_file(UPGRADE_DIR."/".$version.".md5");
    recursive_copy("amp_conf", "", $md5sums);
    if (!is_file("/etc/asterisk/voicemail.conf")) copy("/etc/asterisk/voicemail.conf.template","/etc/asterisk/voicemail.conf");
    if (!is_dir("/var/spool/asterisk/voicemail/device")) amp_mkdir("/var/spool/asterisk/voicemail/device", "0755", true);
    out("OK");
}

// **** Apply amportal.conf configuration to files
debug("Running ".dirname(__FILE__)."/apply_conf.sh");
outn("Configuring install for your environment..");
if (!$dryrun) {
    if (file_exists($amp_conf["AMPSBIN"]."/amportal"))
        exec("chmod u+x ".$amp_conf["AMPSBIN"]."/amportal");
    exec(dirname(__FILE__)."/apply_conf.sh");
}
out("OK");

// **** Create spool directories for monitor and fax
if (!is_dir($asterisk_conf["astspooldir"]."/monitor"))
    amp_mkdir($asterisk_conf["astspooldir"]."/monitor","0766",true);
if (!is_dir($asterisk_conf["astspooldir"]."/fax"))
    amp_mkdir($asterisk_conf["astspooldir"]."/fax","0766",true);


// **** Set permissions all files

if ($install_files)
{
    outn("Setting permissions on files..");
    if (!$dryrun) {
        exec($amp_conf["AMPSBIN"]."/amportal chown");
    }
    out("OK");
}


// **** Read upgrades/ directory

outn("Checking for upgrades..");

// read it from ugprades/ unless $version has already been defined
if (!isset($versions)) {
    $versions = array();
    $dir = opendir(UPGRADE_DIR);
    while ($file = readdir($dir)) {
        if (($file[0] != ".") && is_dir(UPGRADE_DIR."/".$file)) {
            $versions[] = $file;
        }
    }
    closedir($dir);

    // callback to use php's version_compare() to sort    
    usort($versions, "version_compare");
}

if (false !== ($pos = array_search($version, $versions))) {
    $upgrades = array_slice($versions, $pos+1);
    out(count($upgrades)." found");
    
    run_upgrade($upgrades);
} else {
    out("Current version not found");
}


// **** Generate AMP configs
out("Generating AMP configs..");
generate_configs();
out("Generating AMP configs..OK");

// **** Bounce FOP
outn("Restarting Flash Operator Panel..");
exec('su - asterisk -c "'.$amp_conf["AMPWEBROOT"].'/admin/bounce_op.sh"');
out("OK");

$version = install_getversion();
$filename = $amp_conf["AMPWEBROOT"]."/admin/version.txt";
if (!$fd = fopen($filename, "w")) {
    fatal("Could not open ".$filename." for writing");
}
fwrite($fd, $version);
fclose($fd);



// **** Set reload flag for AMP admin
install_needreload();

if ($amp_conf["AMPWEBADDRESS"])
{
    out("Please Reload Asterisk by visiting http://".$amp_conf["AMPWEBADDRESS"]."/admin");
}
else
{
    out("Please Reload Asterisk by browsing your server.");
}

?>