/**
* Return Transport. example: TransportFactory::GetTransport('SSH', $ssh_host, $ssh_port, $ssh_user, $ssh_pass);
*
* @static
* @param string $transportname
* @return Object
*/
public static function GetTransport($transportname)
{
$path_to_transports = dirname(__FILE__) . "/Transports";
if (file_exists("{$path_to_transports}/class.{$transportname}Transport.php")) {
Core::Load("class.{$transportname}Transport.php", $path_to_transports);
if (class_exists("{$transportname}Transport") && self::IsTransport("{$transportname}Transport")) {
// Get Constructor Reflection
if (is_callable(array("{$transportname}Transport", "__construct"))) {
$reflect = new ReflectionMethod("{$transportname}Transport", "__construct");
}
// Delete $objectname from arguments
$num_args = func_num_args() - 1;
$args = func_get_args();
array_shift($args);
if ($reflect) {
$required_params = $reflect->getNumberOfRequiredParameters();
if ($required_params > $num_args) {
$params = $reflect->getParameters();
//TODO: Show what params are missing in error
Core::RaiseError(sprintf(_("Missing some required arguments for %s Transport constructor. Passed: %s, expected: %s."), $transportname, $num_args, $required_params));
}
}
$reflect = new ReflectionClass("{$transportname}Transport");
if (count($args) > 0) {
return $reflect->newInstanceArgs($args);
} else {
return $reflect->newInstance(true);
}
} else {
Core::RaiseError(sprintf(_("Class '%s' not found or doesn't implements ITransport interface"), "{$transportname}Transport"));
}
}
}
public static function GetFileMimeType($path)
{
if (file_exists($path)) {
try {
if (class_exists("finfo")) {
// Probe magick database file
$magic_db_path = dirname(__FILE__) . "/magic";
if (!file_exists($magic_db_path)) {
$magic_db_path = "/usr/share/file/magic";
}
// Create fifo instance
$finfo = new finfo(FILEINFO_MIME, $magic_db_path);
if ($finfo) {
$retval = @$finfo->file($path);
} else {
Core::RaiseError("Cannot open FIFO database. Tried {$magic_db_path}", E_ERROR);
}
return $retval;
} elseif (function_exists("mime_content_type")) {
return mime_content_type($path);
} else {
Core::RaiseError("Cannot determine file mime type.", E_ERROR);
return "";
}
} catch (Exception $e) {
Core::RaiseError($e->getMessage(), E_ERROR);
}
} else {
Core::RaiseWarning("File not found.");
return "";
}
}
function __construct($process_classes_folder)
{
$processes = @glob("{$process_classes_folder}/class.*Process.php");
$jobs = array();
if (count($processes) > 0)
{
foreach ($processes as $process)
{
$filename = basename($process);
$directory = dirname($process);
Core::Load($filename, $directory);
preg_match("/class.(.*)Process.php/s", $filename, $tmp);
$process_name = $tmp[1];
if (class_exists("{$process_name}Process"))
{
$reflect = new ReflectionClass("{$process_name}Process");
if ($reflect)
{
if ($reflect->implementsInterface("IProcess"))
{
$job = array(
"name" => $process_name,
"description" => $reflect->getProperty("ProcessDescription")->getValue($reflect->newInstance())
);
array_push($jobs, $job);
}
else
Core::RaiseError("Class '{$process_name}Process' doesn't implement 'IProcess' interface.", E_ERROR);
}
else
Core::RaiseError("Cannot use ReflectionAPI for class '{$process_name}Process'", E_ERROR);
}
else
Core::RaiseError("'{$process}' does not contain definition for '{$process_name}Process'", E_ERROR);
}
}
else
Core::RaiseError(_("No job classes found in {$ProcessClassesFolder}"), E_ERROR);
$options = array();
foreach($jobs as $job)
$options[$job["name"]] = $job["description"];
$options["help"] = "Print this help";
$Getopt = new Getopt($options);
$opts = $Getopt->getOptions();
if (in_array("help", $opts) || count($opts) == 0 || !$options[$opts[0]])
{
print $Getopt->getUsageMessage();
exit();
}
else
{
$this->ProcessName = $opts[0];
}
}
public static function GetPublicKeyFromPrivateKey($private_key)
{
try {
$key_resource = openssl_pkey_get_private($private_key);
$info = openssl_pkey_get_details($key_resource);
return $info["key"];
} catch (Exception $e) {
Core::RaiseError($e->getMessage(), E_ERROR);
}
}
/**
* Constructor
*
* @param string path to vbulletin config
*/
function __construct($config_path)
{
if (!file_exists($config_path))
return false;
// version checking
$includes = dirname($config_path);
if (file_exists("$includes/class_core.php"))
{
require_once("$includes/class_core.php");
preg_match("/^(\d)\.(\d)/", FILE_VERSION, $m);
$ver = intval($m[1] . $m[2]);
}
if (!$ver || $ver < self::MIN_VERSION)
Core::RaiseError(sprintf(_("vBulletin forum version '%s' installed. %s or higher required."), $ver, self::MIN_VERSION));
$config = array();
require($config_path);
$this->TablePrefix = $config['Database']['tableprefix'];
$this->CookiePrefix = $config['Misc']['cookieprefix'];
$conf = array(
'host' => $config['MasterServer']['servername'],
'user' => $config['MasterServer']['username'],
'pass' => $config['MasterServer']['password'],
'name' => $config['Database']['dbname']
);
$this->DB = Core::GetDBInstance($conf, true, $config['Database']['dbtype']);
$this->Crypto = Core::GetInstance('Crypto', CF_CRYPTOKEY);
// user groups
$groups = $this->DB->GetAll("SELECT * FROM {$this->TablePrefix}usergroup");
foreach($groups as $group)
{
$this->Groups[$group['title']] = $group['usergroupid'];
}
}
/**
* Execute script
*
* @param string $script
* @return string
*/
public function SendLine($command)
{
Core::RaiseError("SendLine not supported in MySQLScriptingAdapter");
}
/**
* Upload file from URL
*
* @param string $url
* @return bool
* @todo Pass custom headers, like User-Agent
*/
public function UploadFromURL($url, $headers = array())
{
$urlinfo = parse_url($url);
$file = array("name" => $this->NormalizeFileName(basename($url)));
// Open socket connection
$sock = @fsockopen($urlinfo['host'], $urlinfo["port"] ? $urlinfo["port"] : 80, $errno, $errstr, 10);
@stream_set_blocking($sock, 1);
// If cannot open socket connection raise warning and return false
if (!$sock) {
$this->RaiseWarning(_("Failed to copy a file. Cannot connect to " . $urlinfo['host'] . "."), false);
return false;
} else {
if (substr($urlinfo['path'], 0, 1) != '/') {
$urlinfo['path'] = "/{$urlinfo['path']}";
}
// Define request
$request = "GET " . $urlinfo['path'] . ($urlinfo['query'] ? "?{$urlinfo['query']}" : "") . " HTTP/1.1\r\n";
if (count($headers) > 0 && is_array($headers)) {
$request .= implode("\r\n", $headers) . "\r\n";
}
$request .= "Host: {$urlinfo['host']}\r\n";
$request .= "Connection: Close\r\n\r\n";
// Send request
@fwrite($sock, $request);
$headers = "";
while ($str != "\r\n") {
$str = @fgets($sock, 2048);
$headers .= $str;
}
if (stristr($headers, "200 OK")) {
while (!feof($sock) && !$meta['eof']) {
@file_put_contents($this->Destination, @fgets($sock, 2048), FILE_APPEND);
$meta = stream_get_meta_data($sock);
}
// Generate real file info
$this->File = array("name" => basename($url), "type" => IOTool::GetFileMimeType($this->Destination), "size" => @filesize($this->Destination));
// Validate real file info
if ($this->Validate()) {
if (file_exists($this->Destination)) {
return true;
} else {
Core::RaiseError(_("Cannot write file."), E_ERROR);
}
}
@unlink($this->Destination);
return false;
} else {
$tmp = split("\n", $headers);
$error = trim($tmp[0]);
Core::RaiseWarning($error);
return false;
}
@fclose($sock);
}
}
/**
* Adds WHERE filter to SQL, depending on SESSION and POST filters.
* @access private
* @return string Usable SQL string
*/
public function ApplyFilter($filter, $fields)
{
if ($this->PagingApplied) {
Core::RaiseError(_("Cannot call ApplyFilter after ApplySQLPaging has been called"));
}
$filter = stripslashes($filter);
// Same filter - unchecking button
if ($filter == $_SESSION["filter"]) {
$filter = NULL;
$_SESSION["filter"] = NULL;
$this->Display["filter"] = false;
} else {
if (!$_GET["pf"]) {
$this->PageNo = 1;
}
$filter = $filter ? $filter : $_GET["pf"];
$filter = stripslashes($filter);
// Add template vars
$this->Display["filter_q"] = $filter;
$this->Display["filter"] = true;
$_SESSION["filter"] = $filter;
}
if ($filter) {
$this->URLFormat = "?pn=%d&pt=%d&pf=" . urlencode($filter);
$this->Filter = $filter;
//SQL
$filter = mysql_escape_string($filter);
foreach ($fields as $f) {
$likes[] = "{$f} LIKE '%{$filter}%'";
}
$like = implode(" OR ", $likes);
if (!stristr($this->SQL, "WHERE")) {
$this->SQL .= " WHERE {$like}";
} else {
$this->SQL .= " AND ({$like})";
}
// Additional SQL
if (!stristr($this->SQL, $this->AdditionalSQL)) {
$this->SQL .= " " . $this->AdditionalSQL . " ";
}
// Downgrade total records count
if ((int) $_GET["pt"] > 0) {
$this->Total = (int) $_GET["pt"];
} else {
$this->ExecuteSQL();
}
}
return $this->SQL;
}
/**
* Update data in RRD
*
* @param array $data
* @param integer $timestamp UNIX TimeStamp
* @return bool
*/
function Update($data, $timestamp = "N")
{
$arg = "{$timestamp}";
foreach ($data as $val)
$arg .= ":{$val}";
if(rrd_update($this->DBPath, $arg))
return true;
else
Core::RaiseError(_("Cannot update RRD: ".rrd_error()));
}
/**
* Get password hash
* @access public
* @return string Password hash, $this->PwdHash
*/
public final function GetPwdHash()
{
if (!is_readable($this->PassFilePath)) {
Core::RaiseError(_("{$this->PassFilePath} not readable"));
}
$res = $this->Shell->QueryRaw("cat {$this->PassFilePath} | grep ^{$this->Username}:");
$rowarr = explode(":", $res);
$this->PwdHash = $rowarr[1];
return $this->PwdHash;
}
public function Handle($request = false, $defaultNS = "")
{
if (!$request) {
$request = $_REQUEST;
} else {
if (!is_array($request)) {
@parse_str($request, $request);
}
}
if (!$request["method"]) {
Core::RaiseError("Malformed request", E_USER_ERROR);
}
$this->Request = $request;
// Determine namespace & method
if ($this->Methods[$request["method"]] instanceof ReflectionMethodEx) {
$reflection_method = $this->Methods[$request["method"]];
$req_args = $reflection_method->getParameters();
foreach ($req_args as $arg) {
if ($request[$arg->getName()] || $arg->isOptional()) {
$given_args++;
$args[$arg->getName()] = $request[$arg->getName()];
} else {
$missing_args = $arg->getName();
}
}
if (count($req_args) != $given_args) {
Core::RaiseError("Invalid Method Call to '{$this->Request['method']}'. Requires '" . count($req_args) . "' arguments, '" . count($given_args) . "' given.", E_USER_ERROR);
}
try {
if ($req_args == 0) {
$result = $reflection_method->invoke();
} else {
$result = $reflection_method->invokeArgs($args);
}
} catch (Exception $e) {
Core::RaiseError($e->getMessage(), E_ERROR);
}
} elseif ($this->Methods[$request["method"]] instanceof ReflectionFunction) {
$req_args = $this->Methods[$request["method"]]->getParameters();
foreach ($req_args as $arg) {
if ($request[$arg->getName()] || $arg->isOptional()) {
$given_args++;
$args[$arg->getName()] = $request[$arg->getName()];
} else {
$missing_args = $arg->getName();
}
}
if (count($req_args) != $given_args) {
Core::RaiseError("Invalid Method Call to '{$this->Request['method']}'. Requires '" . count($req_args) . "' arguments, '" . count($given_args) . "' given.", E_USER_ERROR);
}
try {
if ($req_args == 0) {
$result = $this->Methods[$request["method"]]->invoke();
} else {
$result = $this->Methods[$request["method"]]->invokeArgs($args);
}
} catch (Exception $e) {
Core::RaiseError($e->getMessage(), E_ERROR);
}
} else {
Core::RaiseError("Method not implemented", E_USER_ERROR);
}
if ($result instanceof SimpleXMLElement) {
$response = $result->asXML();
} elseif ($result instanceof DOMDocument) {
$response = $result->saveXML();
} elseif ($result instanceof DOMNode) {
$response = $result->ownerDocument->saveXML($result);
} elseif (is_array($result) || is_object($result)) {
$response = $this->HandleStruct($result);
} else {
$response = $this->HandleScalar($result);
}
@header("Content-type: text/xml");
@header("Content-length: " . strlen($response));
print $response;
}
function __doRequest($request, $location, $saction, $version)
{
$doc = new DOMDocument('1.0');
$doc->loadXML($request);
$objWSSE = new WSSESoap($doc);
#echo "<pre>"; var_dump($request); #die();
/* add Timestamp with no expiration timestamp */
$objWSSE->addTimestamp();
/* create new XMLSec Key using RSA SHA-1 and type is private key */
$objKey = new XMLSecurityKey(XMLSecurityKey::RSA_SHA1, array('type'=>'private'));
/* load the private key from file - last arg is bool if key in file (TRUE) or is string (FALSE) */
$objKey->loadKey($this->KeyPath, TRUE);
try
{
/* Sign the message - also signs appropraite WS-Security items */
$objWSSE->signSoapDoc($objKey);
}
catch (Exception $e)
{
Core::RaiseError("[".__METHOD__."] ".$e->getMessage(), E_ERROR);
}
/* Add certificate (BinarySecurityToken) to the message and attach pointer to Signature */
$token = $objWSSE->addBinaryToken(file_get_contents($this->CertPath));
$objWSSE->attachTokentoSig($token);
try
{
return parent::__doRequest($objWSSE->saveXML(), $location, $saction, $version);
}
catch (Exception $e)
{
Core::RaiseError("[".__METHOD__."] ".$e->__toString(), E_ERROR);
}
}
public function AddAddon($domain, $foldername = "", $pass = "")
{
Core::RaiseError("Fixme: Add \$crypto instance here.");
if (!$foldername) $foldername = preg_replace("/[\-\_]/i", "", $domain);
if (!$pass) $pass = $crypto->Sault(13);
$this->Fetch("addon/doadddomain.html?domain=".$domain."&user="******"&pass="******"user" => $foldername, "pass" => $pass);
}
/**
* Constructor
*
* @param string $host
* @param string $port
* @param array $authinfo
* @param string $rndc_path
* @param string $namedconf_path
* @param string $nameddb_path
* @param string $zonetemplate
*/
function __construct($host, $port, $authinfo, $rndc_path, $namedconf_path, $nameddb_path, $zonetemplate, $inittransport= true)
{
// Call Bind class construct
parent::__construct($namedconf_path, $nameddb_path, $zonetemplate, $rndc_path, false);
$this->Host = $host;
$this->Port = $port;
$this->Authinfo = $authinfo;
$this->Transport = self::DEFAULT_TRANSPORT;
if ($inittransport)
if (!$this->InitTransport())
Core::RaiseError("Cannot init transport");
$this->DoMakeBackup = false;
$this->HaveNewZones = 0;
}
/**
* Execute script
*
* @param string $script
* @return bool
* @static
*/
static public function Execute($script, $params)
{
if (!self::$Adapter)
Core::RaiseError("Please define Adapter using ScriptingClient::SetAdapter() method");
return self::$Adapter->Execute($script, $params);
}
/**
* Connect to SSH Server
*
* @access private
* @return bool
* @return bool
*/
private function Connect()
{
if (!$this->SSHConnection->Connect($this->SSHHost, $this->SSHPort))
Core::RaiseError(sprintf(_("Transports/SSHTransport: Cannot connect to %s:%s."), $this->SSHHost, $this->SSHPort));
else
return true;
}
/**
* Execute commands chain.
* @access public
* @var mixed $stdin Optional STDIN string to write to a 1st proccess in chain
* @var string $in_file_path Optional input file path that input for the last proccess will be read from
* @var string $out_file_path Optional output file path that output of the last proccess will be written to
* @return int The return value of the command (0 on success) or strict false on failure.
* @todo may be it worths rewriting interptoccess piping from | binary usage to posix_mkfifo()
*/
function Execute($stdin = null, $out_file_path = null, $in_file_path = null)
{
if (count($this->Links) == 0) {
Core::RaiseError("Cannot call PipedChain->Execute() - no links in chain");
}
// Build a piped string
$cmd = implode(" | ", $this->Links);
$MProcess = new ManagedProcess($cmd, $stdin);
$retval = $MProcess->Execute($cmd, $stdin, $out_file_path, $in_file_path);
$this->StdOut = $MProcess->StdOut;
$this->StdErr = $MProcess->StdErr;
return $retval;
}
/**
*
* @return string Resulting image binary string.
*/
public function Process()
{
$result = $this->PChain->Execute($this->StdIn, $this->OutFilePath, $this->InFilePath);
if (!empty($this->PChain->StdErr)) {
Core::RaiseError(trim($this->PChain->StdErr), E_ERROR);
} elseif (!$this->OutFilePath) {
$retval = $this->PChain->StdOut;
} else {
$retval = $result;
}
// Reset some stuff for a fresh new chain
$this->Init();
return $retval;
}
/**
* Transfer file over SFTP
* @access public
* @param string $remote_path Remote file path
* @param string $local_path Local file path
* @param string $write_type Write path
* @param bool $read_content_from_file If True we read content from '$source' else content = $source
* @return bool
*/
public function SendFile($remote_path, $source, $write_type = "w+", $read_content_from_file = true)
{
try
{
if ($this->Connection)
{
if (!$this->SFTP || !is_resource($this->SFTP))
$this->SFTP = @ssh2_sftp($this->Connection);
if ($this->SFTP && is_resource($this->SFTP))
{
$stream = @fopen("ssh2.sftp://{$this->SFTP}".$remote_path, $write_type);
if ($stream)
{
if ($read_content_from_file)
$content = @file_get_contents($source);
else
$content = $source;
if (fwrite($stream, $content) === FALSE)
{
Core::RaiseError(sprintf(_("SFTP: Cannot write to file '%s'"), $remote_path));
return false;
}
@fclose($stream);
return true;
}
else
{
Core::RaiseWarning(sprintf(_("SFTP: Cannot open remote file '%s'"), $remote_path));
return false;
}
}
else
return false;
}
else
return false;
}
catch (Exception $e)
{
return false;
}
}
/**
* Sets a specific value in the SOA field.
*
* This function updates the list of SOA data we have.
* List of accepted key => value pairs:
* <pre>
* Array
* (
* [name] => example.com.
* [ttl] => 345600
* [class] => IN
* [origin] => ns1.example.com.
* [person] => hostmaster.example.com.
* [serial] => 204041514
* [refresh] => 14400
* [retry] => 1800
* [expire] => 86400
* [minimum] => 10800
* )
* </pre>
*
* @param array $values A list of key -> value pairs
* @return bool true on success, false failure.
* @see SOA
*/
public function SetSOAValue($values)
{
Core::ClearWarnings();
$soa = array();
if (!is_array($values)) {
Core::RaiseError(_("Unable to set SOA value"));
}
$validKeys = array('name', 'ttl', 'class', 'origin', 'person', 'serial', 'refresh', 'retry', 'expire', 'minimum');
foreach ((array) $values as $key => $value) {
if (array_search($key, $validKeys) === false) {
Core::RaiseWarning(sprintf(_("Unable to set SOA value. %s not recognized"), $key));
}
switch (strtolower($key)) {
case 'person':
$value = str_replace('@', '.', $value);
$value = trim($value, '.') . '.';
case 'name':
case 'origin':
$valid = '/^[A-Za-z0-9\\-\\_\\.]*\\.$/';
$value = $this->Dottify($value);
if (preg_match($valid, $value)) {
$soa[$key] = $value;
} else {
Core::RaiseWarning(sprintf(_("Unable to set SOA value. %s not valid"), $key));
}
break;
case 'class':
$soa[$key] = $value;
break;
case 'ttl':
$soa[$key] = $value;
break;
case 'serial':
$value = $this->RaiseSerial($value);
$soa[$key] = $value;
case 'refresh':
case 'retry':
case 'expire':
case 'minimum':
// Normalize time
$value = $this->ParseTimeToSeconds($value);
if (is_numeric($value)) {
$soa[$key] = $value;
} else {
Core::RaiseWarning(sprintf(_("Unable to set SOA value. %s not recognized"), $key));
}
break;
}
// Set zone name
if (strtolower($key) == "name") {
$this->Name = $this->UnDottify($value);
}
}
// Default serial
if (!$soa["serial"]) {
$soa["serial"] = $this->RaiseSerial();
}
//If all got parsed, save values.
$this->SOA = array_merge($this->SOA, $soa);
return !self::HasWarnings();
}
/**
* The CreateBucket operation creates a bucket. Not every string is an acceptable bucket name.
*
* @param string $bucket_name
* @return string
*/
public function CreateBucket($bucket_name)
{
$timestamp = $this->GetTimestamp();
try
{
$res = $this->S3SoapClient->CreateBucket(
array(
"Bucket" => $bucket_name,
"AWSAccessKeyId" => $this->AWSAccessKeyId,
"Timestamp" => $timestamp,
"Signature" => $this->GetSOAPSignature("CreateBucket", $timestamp)
)
);
if (!($res instanceof SoapFault))
return true;
else
Core::RaiseError($res->faultString, E_ERROR);
}
catch (SoapFault $e)
{
Core::RaiseError($e->faultString, E_ERROR);
}
}
/**
* Fetching post from server
*
* @param string $group
* @return object
*/
function FetchPosting($group)
{
if ($this->GroupName !== $group->GetName())
{
$res = $this->NNTP->SelectGroup($group->GetName());
if ($res !== FALSE)
{
$group->SetFirst($res['first']);
$group->SetLast($res['last']);
}
else
Core::RaiseError('Fetch Posting: select group error');
}
if ($group->GetUnreadPostingsNumber() > 0)
{
if ($group->GetUnreadPostingsNumber() > $this->PostsLimit && $this->PostsLimit)
$current = $group->GetLast() - $this->PostsLimit;
else
$current = $group->GetLastRead() >= $group->GetFirst() ? $group->GetLastRead() + 1 : $group->GetFirst();
if ($current)
$overview = $this->NNTP->GetOverview($current);
while (($overview === FALSE || $overview["Bytes"] == 0) && ($current <= $group->GetLast()))
{
Log::Log("NNTP: Skipping Article #{$current}. Empty overwiew.", 1, "NNTPLog");
$group->SetLastRead($current);
$this->SetGroupStatus($group);
$current++;
$overview = $this->NNTP->GetOverview($current);
}
if (isset($overview["Bytes"]) && $overview["Bytes"] > 0)
{
$header = $this->NNTP->GetArticleHead($current);
$body = $this->NNTP->GetArticleBody($current, true);
if ($this->FilterPosting($header->fields, $body))
{
$posting = new UsenetPosting($header, $body, $group->getId(), $group->getName(), $current, $group->GetEncoding());
if ($posting->GetEnc())
$group->SetDetectedEncoding = $posting->GetEnc();
$this->Status = 0;
Log::Log("NNTP: Fetching Article #{$current}", 1, "NNTPLog");
$this->Report[$group->GetName()]++;
}
else
{
Log::Log("NNTP: Skipping Article #{$current}. Filtered", 1, "NNTPLog");
$this->Status = 2; // skipped posting
$posting = false;
}
$group->SetLastRead($current);
$this->SetGroupStatus($group);
return $posting;
}
else
{
$this->Status = 1;
return false;
}
}
else
{
$this->Status = 1; // end of group
return false;
}
}
/**
* Find user by username
* @access public
* @param string $username username
* @return SystemUser SystemUser object
*/
public function GetUserByUID($uid)
{
if (!is_readable("/etc/passwd"))
Core::RaiseError(_("/etc/passwd not readable"));
$res = $this->Shell->QueryRaw("cat /etc/passwd | grep ':[\*x]:$uid:'");
$rowarr = explode(":", $res);
$retval = new SystemUser($rowarr[2]);
return $retval;
}
/**
* Converts CIDR range to IPS array
* @access public
* @param string $ip IP range in CIDR notation
* @return array
*/
public final function CIDR2List($ip)
{
// validate IP address
$num = "([0-9]|1?\\d\\d|2[0-4]\\d|25[0-5])";
$range = "([1-9]|1\\d|2\\d|3[0-2])";
if (!preg_match("/^{$num}\\.{$num}\\.{$num}\\.{$num}\\/{$range}\$/", $ip)) {
return false;
}
// Separate CIDR structure into network-IP and netmask
$ip_arr = explode("/", $ip);
// Calculate number of hosts in the subnet
$mask_bits = $ip_arr[1];
if ($mask_bits > 31 || $mask_bits < 0) {
Core::RaiseError(_("Nonsense mask"));
}
$host_bits = 32 - $mask_bits;
$num_hosts = pow(2, $host_bits) - 1;
// Netmask in decimal for use later: (hack around PHP always using signed ints)
$netmask = ip2long("255.255.255.255") - $num_hosts;
// Calculate start and end
// Store IP-addresses internally as longs, to ease compare of two
// addresses in a sorted structure.
$ip_start = ip2long($ip_arr[0]);
if ($ip_start != ($ip_start & $netmask)) {
Core::RaiseWarning(_("Address {$ip} not on network boundary"));
}
$ip_end = $ip_start + $num_hosts;
for ($i = 0; $i <= $num_hosts; $i++) {
$ip_range[] = long2ip($ip_start + $i);
}
return $ip_range;
}
public function CreateKeyPair($keyName)
{
try
{
$response = $this->EC2SoapClient->CreateKeyPair(array('keyName' => $keyName));
if ($response instanceof SoapFault)
Core::RaiseError($response->faultstring, E_ERROR);
}
catch (SoapFault $e)
{
Core::RaiseError($e->getMessage(), E_ERROR);
}
return $response;
}
/**
* Prepare system command
*
* @param integer $command
* @param integer $option
*/
private function PrepareCommand($command, $option = false)
{
if ($command == 253) {
# respond to DO commands
switch ($option)
{
case 31: # Window size
case 32: # Term speed
case 33: # Remote flow control
case 34: # LINEMODE
case 35: # X Display
case 36: # Old Env.
case 39: # New Env.
case 37: # Authentication
default:
$this->SendCommand(252, $option);
break;
case 24: # TERMINAL-TYPE
$this->SendCommand(251, $option);
break;
}
}
else if ($command == 251)
{
# respond to WILL commands
switch ($option)
{
case 3: # Suppress go ahead
case 5: # Give status
$this->SendCommand(253, $option);
break;
case 1: # Echo
case 38: # Encrypt
default:
$this->SendCommand(254, $option);
break;
}
}
else if ($command == 250)
{
$option = $this->ReadCharFromBuffer();
$params = array();
$next = $this->ReadCharFromBuffer();
while ($next !== 255)
{
$params[] = $next;
$next = $this->ReadCharFromBuffer();
}
$end = $this->ReadCharFromBuffer();
if ($end != 240)
Core::RaiseError("Telnet::PrepareCommand - error in subnegotiation");
if ($option == 24)
{
if ($params[0] == 1)
{
$prm = array(chr(0),$this->ttype);
$this->SendCommand(250, 24);
for ($i=0; $i<count($prm); $i++)
$this->Send($prm[$i], false);
$this->SendCommand(240);
}
}
else
Core::RaiseError("Telnet::PrepareCommand - unsupported option");
}
else
Core::RaiseError("Telnet::PrepareCommand - unsupported command ({$command})");
}
/**
* Return true if the parameter is in a valid format for
* the option $flag.
* Throw an exception in most other cases.
*
* @param string $flag
* @param string $param
*/
protected function checkParameterType($flag, $param)
{
if (!isset($this->_rules[$flag]['param']) || $this->_rules[$flag]['param'] == 'none') {
if (isset($param)) {
Core::RaiseError("Option \"{$flag}\" requires no parameter." . $this->getUsageMessage());
} else {
return true;
}
} else {
if (!isset($param) && $this->_rules[$flag]['param'] == 'optional') {
return true;
} else {
if (!isset($param) && $this->_rules[$flag]['param'] == 'required') {
$this->PrintError("Option \"{$flag}\" requires a parameter.");
}
}
}
switch ($this->_rules[$flag]['paramType']) {
case 'string':
break;
case 'word':
if (preg_match('/\\W/', $param)) {
$this->PrintError("Option \"{$flag}\" requires a single-word parameter, but was given \"{$param}\"");
}
break;
case 'integer':
if (preg_match('/\\D/', $param)) {
$this->PrintError("Option \"{$flag}\" requires an integer parameter, but was given \"{$param}\".");
}
break;
default:
$this->PrintError("Unknown parameter type: \"{$this->_rules[$flag]['paramType']}\".");
}
return true;
}
/**
* Parse xml/rss into structured array
*
* @param string valid xml string
*/
public function Parse($xml)
{
if (!$xml) return;
$this->ResetParser();
$this->XMLParser = xml_parser_create();
xml_set_object($this->XMLParser, $this);
xml_parser_set_option($this->XMLParser, XML_OPTION_CASE_FOLDING, true);
xml_set_element_handler($this->XMLParser, "OpenTag", "CloseTag");
xml_set_character_data_handler($this->XMLParser, "ParseTag");
if(!@xml_parse($this->XMLParser, $xml))
{
$error = xml_error_string(xml_get_error_code($this->XMLParser));
Core::RaiseError($error);
}
xml_parser_free($this->XMLParser);
}
public static function SetExceptionClassName($name)
{
if (class_exists($name)) {
self::$ExceptionClassName = $name;
self::$ReflectionException = new ReflectionClass($name);
} else {
Core::RaiseError("Core::SetExceptionClassName failed. Class '{$name}' not found");
}
}
/**
* Register Failed Transaction function
*
* @param string $functionname
*/
public function RegisterFailedTransactionFunction($functionname)
{
if (function_exists($functionname))
$this->FailedTransactionFunction = $functionname;
else
Core::RaiseError(_("Failed Transaction Function is not defined!"));
}
