From: Roland Häder Date: Fri, 19 May 2017 17:10:09 +0000 (+0200) Subject: Needs to be here, no way! X-Git-Url: https://git.mxchange.org/?p=core.git;a=commitdiff_plain;h=197d364f62d39e6f731ff62001ac6cafccc0d9cc Needs to be here, no way! Signed-off-by: Roland Häder --- diff --git a/framework/main/classes/class_BaseFrameworkSystem.php b/framework/main/classes/class_BaseFrameworkSystem.php index 9262934f..d61c9f77 100644 --- a/framework/main/classes/class_BaseFrameworkSystem.php +++ b/framework/main/classes/class_BaseFrameworkSystem.php @@ -401,6 +401,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { const EXCEPTION_PATH_CANNOT_BE_WRITTEN = 0x03b; const EXCEPTION_DATABASE_UPDATED_NOT_ALLOWED = 0x03c; const EXCEPTION_FILTER_CHAIN_INTERCEPTED = 0x03d; + const EXCEPTION_INVALID_SOCKET = 0x03e; /** * Hexadecimal->Decimal translation array diff --git a/framework/main/classes/tools/.htaccess b/framework/main/classes/tools/.htaccess new file mode 100644 index 00000000..3a428827 --- /dev/null +++ b/framework/main/classes/tools/.htaccess @@ -0,0 +1 @@ +Deny from all diff --git a/framework/main/classes/tools/console/.htaccess b/framework/main/classes/tools/console/.htaccess new file mode 100644 index 00000000..3a428827 --- /dev/null +++ b/framework/main/classes/tools/console/.htaccess @@ -0,0 +1 @@ +Deny from all diff --git a/framework/main/classes/tools/console/class_ConsoleTools.php b/framework/main/classes/tools/console/class_ConsoleTools.php new file mode 100644 index 00000000..c1d252d5 --- /dev/null +++ b/framework/main/classes/tools/console/class_ConsoleTools.php @@ -0,0 +1,422 @@ + + * @version 0.0.0 + * @copyright Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2017 Hub Developer Team + * @license GNU GPL 3.0 or any newer version + * @link http://www.shipsimu.org + * + * 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, either version 3 of the License, or + * (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +class ConsoleTools extends BaseFrameworkSystem { + // Constants + const HTTP_EOL = "\r\n"; + const HTTP_USER_AGENT = 'ConsoleTools/1.0'; + + /** + * Protected constructor + * + * @return void + */ + protected function __construct () { + // Call parent constructor + parent::__construct(__CLASS__); + } + + /** + * Checks wether proxy configuration is used + * + * @return $isUsed Wether proxy is used + */ + protected function isProxyUsed () { + // Do we have cache? + if (!isset($GLOBALS[__METHOD__])) { + // Determine it + $GLOBALS[__METHOD__] = (($this->getConfigInstance()->getConfigEntry('proxy_host') != '') && ($this->getConfigInstance()->getConfigEntry('proxy_port') > 0)); + } // END - if + + // Return cache + return $GLOBALS[__METHOD__]; + } + + /** + * Sets up a proxy tunnel for given hostname and through resource + * + * @param $host Host to connect to + * @param $port Port number to connect to + * @param $socketResource Resource of a socket + * @return $response Response array + */ + protected function setupProxyTunnel ($host, $port, $socketResource) { + // Initialize array + $response = array('', '', ''); + $proxyTunnel = ''; + + // Generate CONNECT request header + $proxyTunnel .= 'CONNECT ' . $host . ':' . $port . ' HTTP/1.1' . self::HTTP_EOL; + $proxyTunnel .= 'Host: ' . $host . ':' . $port . self::HTTP_EOL; + $proxyTunnel .= 'Proxy-Connection: Keep-Alive' . self::HTTP_EOL; + + // Use login data to proxy? (username at least!) + if ($this->getConfigInstance()->getConfigEntry('proxy_username') != '') { + // Add it as well + $encodedAuth = base64_encode($this->getConfigInstance()->getConfigEntry('proxy_username') . ':' . $this->getConfigInstance()->getConfigEntry('proxy_password')); + $proxyTunnel .= 'Proxy-Authorization: Basic ' . $encodedAuth . self::HTTP_EOL; + } // END - if + + // Add last new-line + $proxyTunnel .= self::HTTP_EOL; + //* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('CONSOLE-TOOLS[' . __METHOD__ . ':' . __LINE__ . ']: proxyTunnel=' . $proxyTunnel); + + // Write request + fwrite($socketResource, $proxyTunnel); + + // Got response? + if (feof($socketResource)) { + // No response received + return $response; + } // END - if + + // Read the first line + $resp = trim(fgets($socketResource, 10240)); + $respArray = explode(' ', $resp); + if (((strtolower($respArray[0]) !== 'http/1.0') && (strtolower($respArray[0]) !== 'http/1.1')) || ($respArray[1] != '200')) { + // Invalid response! + return $response; + } // END - if + + // All fine! + return $respArray; + } + + /** + * Tried to extract hostname from given raw data. On a Genntoo system, this could be multiple lines with # as comments. So try to get rid of it + * + * @param $rawData Raw data from /etc/hostname file + * @return $hostname Extracted host name + */ + protected function extractHostnameFromRawData ($rawData) { + // Default is invalid + $hostname = 'invalid'; + + // Try to "explode" it + $data = explode(PHP_EOL, $rawData); + + // "Walk" through it + foreach ($data as $line) { + // Trim it + $line = trim($line); + + // Begins with a hash (#) = comment? + if (substr($line, 0, 1) == '#') { + // Then skip it + continue; + } // END - if + + // Has an equals sign? + if (strpos($line, '=') !== false) { + // Then "explode" it again, right part is hostname in quotes + $hostData = explode('=', $line); + + // Make sure only a key=value pair goes through + assert(count($hostData) == 2); + + // Try to get it and abort + $hostname = str_replace(array('"', chr(39)), array('', ''), $hostData[1]); + break; + } else { + // Use it directly + $hostname = $line; + break; + } + } // END - foreach + + // Return it + return $hostname; + } + + /** + * Tries to resolve an IP address from given hostname. Currently only IPv + * addresses are resolved. + * + * @param $hostname Host name we shall resolve + * @return $ipAddress IPv4 address resolved from host name + * @todo This should be connected to a caching class to cache DNS requests + */ + public static function resolveIpAddress ($hostname) { + // Debug message + self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('[%s:] Host name to resolve is: %s', + __CLASS__, + $hostname + )); + + // Default is false + $ipAddress = false; + + // Is a dot at the end? + if (substr($hostname, -1, 1) != '.') { + /* + * Then append it to prevent lookup of invalid host names through + * all search-domains. This will greatly improve lookup performance + * and has no disadvantages for anybody. A dot at the end of a + * domain btw means full-qualified domain, do not prepend to any + * other domain, basically. + */ + $hostname .= '.'; + } // END - if + + // Resolve it + // @TODO Here should the cacher be implemented + $ipResolved = gethostbyname($hostname); + + // Was it fine? + if (($ipResolved !== false) && ($ipResolved != $hostname)) { + // Okay, this works! + $ipAddress = $ipResolved; + + // Debug message + self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('[%s:] Resolved IP address is: %s', + __CLASS__, + $ipAddress + )); + } else { + // Problem while resolving IP address + self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('[%s:] Problem resolving IP address for host %s. Please check your /etc/hosts file.', + __CLASS__, + $hostname + )); + } + + // Return resolved IP + return $ipAddress; + } + + /** + * Aquires the IP address of this host by reading the /etc/hostname file + * and solving it. It is now stored in configuration + * + * @return $ipAddress Aquired IPv4 address + */ + public static function acquireSelfIPAddress () { + // Local IP by default + $ipAddress = '127.0.0.1'; + + // Get a new instance + $helperInstance = new ConsoleTools(); + + try { + // Get a file pointer + $fileInstance = ObjectFactory::createObjectByConfiguredName('file_raw_input_class', array($helperInstance->getConfigInstance()->getConfigEntry('hostname_file'))); + + // Read the file + $rawData = trim($fileInstance->readFromFile()); + + // Close the file + $fileInstance->closeFile(); + + // Extract hostname from it + $hostname = $helperInstance->extractHostnameFromRawData($rawData); + + // Resolve the IP number + $ipAddress = self::resolveIpAddress($hostname); + } catch (FileNotFoundException $e) { + // Fall-back to 'SESSION_SVR' which found on my Sun Station + if (isset($_SERVER['SESSION_SVR'])) { + // Resolve it + $ipAddress = self::resolveIpAddress($_SERVER['SESSION_SVR']); + } elseif (isset($_SERVER['COMPUTERNAME'])) { + // May happen on some Windows XP systems, so also try this + $ipAddress = self::resolveIpAddress($_SERVER['COMPUTERNAME']); + } else { + // Could not find our hostname + self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('[%s:] WARNING: Cannot resolve my own IP address.', + $helperInstance->__toString() + )); + } + } catch (FrameworkException $e) { + // Output debug message + self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('[%s:] Problem while resolving own IP address: [%s|%s]:%s', + $helperInstance->__toString(), + $e->__toString(), + $e->getHexCode(), + $e->getMessage() + )); + } + + // Set it in configuration + FrameworkConfiguration::getSelfInstance()->setServerAddress($ipAddress); + + // Return it + return $ipAddress; + } + + /** + * Determines own remote IP address (e.g. can be used to probe if we are + * reachable from outside by determining external address and then connect to it. + * This is accomblished by connecting to the IP of www.shipsimu.org which + * should default to 188.138.90.169 and requesting /ip.php which does only + * return the content of $_SERVER['REMOTE_ADDR']. Of course, this method + * requires a working Internet connection. + * + * This method is taken from a user comment on php.net and heavily rewritten. + * Compare to following link: + * http://de.php.net/manual/en/function.socket-create.php#49368 + * + * @return $externalAddress The determined external address address + * @throws InvalidSocketException If socket initialization wents wrong or if an errors occurs + * @todo This should be moved out to an external class, e.g. HttpClient + * @todo Make IP, host name, port and script name configurable + */ + public static function determineExternalAddress () { + // Get helper instance + $helperInstance = new ConsoleTools(); + + // First get a socket + // @TODO Add some DNS caching here + + // Open connection + if ($helperInstance->isProxyUsed() === true) { + // Resolve hostname into IP address + $ipAddress = self::resolveIpAddress($helperInstance->getConfigInstance()->getConfigEntry('proxy_host')); + + // Connect to host through proxy connection + $socketResource = fsockopen($ipAddress, $helperInstance->getConfigInstance()->getConfigEntry('proxy_port'), $errorNo, $errorStr, 30); + } else { + // Connect to host directly + $socketResource = fsockopen('188.138.90.169', 80, $errorNo, $errorStr, 30); + } + + // Check if there was an error else + if ($errorNo > 0) { + // Then throw again + throw new InvalidSocketException(array($helperInstance, $socketResource, $errorNo, $errorStr), BaseFrameworkSystem::EXCEPTION_INVALID_SOCKET); + } // END - if + + // Prepare the GET request + $request = 'GET ' . ($helperInstance->isProxyUsed() === true ? 'http://shipsimu.org' : '') . '/ip.php HTTP/1.0' . self::HTTP_EOL; + $request .= 'Host: shipsimu.org' . self::HTTP_EOL; + $request .= 'User-Agent: ' . self::HTTP_USER_AGENT . self::HTTP_EOL; + $request .= 'Connection: close' . self::HTTP_EOL; + + // Do we use proxy? + if ($helperInstance->isProxyUsed() === true) { + // CONNECT method? + if ($helperInstance->getConfigInstance()->getConfigEntry('proxy_connect_method') == 'Y') { + // Setup proxy tunnel + $response = $helperInstance->setupProxyTunnel('shipsimu.org', 80, $socketResource); + + // If the response is invalid, abort + if ((count($response) == 3) && (empty($response[0])) && (empty($response[1])) && (empty($response[2]))) { + // Invalid response! + $helperInstance->debugBackTrace('Proxy tunnel not working: response=' . print_r($response, true)); + } // END - if + } else { + // Add header for proxy + $request .= 'Proxy-Connection: Keep-Alive' . self::HTTP_EOL; + } + } // END - if + + // Add last HTTP_EOL + $request .= self::HTTP_EOL; + + // Send it to the socket + fwrite($socketResource, $request); + + // Init IP (this will always be the last line) + $externalAddress = 'invalid'; + + // And read the reply + while (!feof($socketResource)) { + // Get line + $externalAddress = trim(fgets($socketResource, 128)); + + // Detect HTTP response + if ((substr($externalAddress, 0, 7) == 'HTTP/1.') && (substr($externalAddress, -6, 6) != '200 OK')) { + // Stop processing + break; + } // END - if + } // END - while + + // Close socket + fclose($socketResource); + + + // Debug message + /* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('CONSOLE-TOOLS[' . __METHOD__ . ':' . __LINE__ . ']: Resolved external address: ' . $externalAddress); + + // Return determined external address + return $externalAddress; + } + + /** + * Analyzes the 'environment', mostly $_SERVER, for presence of elements + * which indicates clearly that e.g. this script has been executed from + * console or web. + * + * @return $type The analyzed type, can be 'http' or 'console' + */ + public static function analyzeEnvironmentForType () { + // Default is the console + $type = 'console'; + + // Now, do we have a request method, or query string set? + if ((isset($_SERVER['REQUEST_METHOD'])) || (isset($_SERVER['QUERY_STRING']))) { + // Possibly HTTP request + $type = 'http'; + } // END - if + + // Return it + return $type; + } + + /** + * Analyzes the 'environment', mostly $_SERVER, for presence of elements + * which indicates clearly that e.g. this script has been executed from + * console or web. This method should be used for class names, they + * currently are named differently. Here is a list to clarify this: + * + * Request type | Class type + * ----------------------------- + * http | web + * console | console + * + * @return $type The analyzed type, can be 'http' or 'console' + */ + public static function analyzeEnvironmentForClassType () { + // Default is the console + $type = 'console'; + + // Now, do we have a request method, or query string set? + if (self::analyzeEnvironmentForType() == 'http') { + // Possibly HTTP request + $type = 'web'; + } // END - if + + // Return it + return $type; + } + +}