One Hat Cyber Team

View File Name : ZebraZ.php

<?php

/**
 * ZebraZ, ZebraZ methods for general usages
 * 
 * @copyright Copyright (c) 2007 DotRoll Kft. (http://www.dotroll.com)
 * @author Zoltán Istvanovszki <zoltan.istvanovszki@dotroll.com>
 * @since 2015.04.30.
 * @package backend
 */
class ZebraZ {

	/**
	 * @var Singleton
	 */
	private static $instance;

	/**
	 * Get instance
	 * 
	 * @return \ZebraZ
	 */
	public static function getInstance(): \ZebraZ {
		if (\is_null(self::$instance)) {
			self::$instance = new self();
		}
		return self::$instance;
	}

	/**
	 * Get declared variable from define
	 *
	 * @param string $file File path
	 * @param string $variable Constant name
	 * @return string|null
	 */
	public static function getVariableFromDefine(string $file, string $constant): ?string {
		if (!\is_file($file)) {
			return null;
		}
		$resource = \fopen($file, 'r');
		while (!\feof($resource)) {
			$line = \fgets($resource);
			\preg_match('/\s*define\s*\(\s*["\']' . $constant . '["\']\s*,\s*["\']([^\'"]+)["\']\s*\);/', $line, $match);
			if (!empty($match[1])) {
				return (string) $match[1];
			}
		}
		return null;
	}

	/**
	 * Get declared variable from file
	 * 
	 * @param string $file File path
	 * @param string $variable Variable name
	 * @return mixed
	 */
	public static function getVariableFromFile(string $file, string $variable) {
		if (!\is_file($file)) {
			return null;
		}
		\ob_start();
		include $file;
		\ob_end_clean();
		if (!isset($$variable)) {
			return null;
		}
		return $$variable;
	}

	/**
	 * Get declared variable from file
	 *
	 * @param string $file File path
	 * @param string $class Class name
	 * @param string $variable Variable name
	 * @return mixed
	 */
	public static function getVariableFromClass(string $file, string $class, string $variable) {
		if (!\is_file($file)) {
			return null;
		}
		\ob_start();
		include $file;
		$instance = new $class();
		\ob_end_clean();
		if (!isset($instance->$variable)) {
			unset($instance);
			return null;
		}
		$version = $instance->$variable;
		unset($instance);
		return $version;
	}

	/**
	 * Print several parameters depending usage type
	 */
	public static function l() {
		for ($i = 0; $i < \func_num_args(); $i++) {
			$a[] = \func_get_arg($i);
		}
		if (!isset($a)) {
			$a = null;
		}

		if (!\defined('STDIN')) {
			$trace = \debug_backtrace();
			$function = '';
			if (isset($trace[1]['class'])) {
				$function .= $trace[1]['class'] . '->';
			}
			if (isset($trace[1]['function'])) {
				$function .= $trace[1]['function'] . '()';
			}
			echo '<fieldset style="width: 99%; border: 1px solid red; background-color: white;">';
			echo "<legend style='color: red; background-color: white; border: 1px solid red; padding: 2px; font-size: 14px;'>Debug result from {$trace[0]['file']} on line {$trace[0]['line']} [$function]:</legend>";
			echo '<xmp style="width: 99%; text-align: left; color: black;">';
		}

		if (\is_array($a)) {
			foreach ($a as $o) {
				\ZebraZ::printZ($o);
				echo "\n";
			}
		} else {
			\ZebraZ::printZ($a);
			echo "\n";
		}
		if (!\defined('STDIN')) {
			echo "</xmp>";
			echo '</fieldset>';
		}
	}

	/**
	 * Prints human-readable information about a variable
	 *
	 * @param mixed $var The expression to be printed.
	 * @param int $delim Tghe left space delimiting
	 * @param bool $return If you would like to capture the output, use the return parameter. When this parameter is set to TRUE, will return the information rather than print it.
	 * @return string
	 */
	public static function printZ($var, $delim = 0, $return = false) {
		$output = null;
		$type = \gettype($var);
		$spaceOut = \str_repeat(' ', $delim * 4);
		$delim++;
		$spaceIn = \str_repeat(' ', $delim * 4);
		if ($type == 'resource' || ($type == 'object' && \get_class($var) != 'stdClass')) {
			$idx = 0;
			foreach (\explode(\PHP_EOL, \print_r($var, true)) as $line) {
				$output .= ($idx++ === 0 ? $line : $spaceIn . $line) . \PHP_EOL;
			}
		} elseif ($type == 'NULL') {
			$output = 'NULL';
		} elseif ($type == 'boolean') {
			$output = $var === true ? 'true' : 'false';
		} elseif ($type == 'string') {
			$output = $delim == 1 && \strpos($var, \PHP_EOL) !== false ? $var : "\"$var\"";
		} elseif (\in_array($type, ['integer', 'double', 'float'])) {
			$output = $var;
		} elseif (\in_array($type, ['object', 'array'])) {
			$output .= ($type == 'array' ? 'Array' : 'stdClass Object') . \PHP_EOL . $spaceOut . '(' . \PHP_EOL;
			foreach ($var as $key => $val) {
				$output .= ($spaceIn . '[' . $key . '] => ' . \ZebraZ::printZ($val, (\is_array($val) ? $delim + 1 : $delim), true) . \PHP_EOL);
			}
			$output .= $spaceOut . ')' . \PHP_EOL;
		} else {
			foreach (\explode(\PHP_EOL, \var_dump($var, true)) as $line) {
				$output .= $spaceIn . $line . \PHP_EOL;
			}
		}
		if ($return === true) {
			return $output;
		}
		echo $output;
	}

	/**
	 * General SQL injection and input validation protection tool :)
	 *
	 * @param mixed $obj Input variable
	 * @return mixed
	 */
	public static function its($obj) {
		if (\is_array($obj)) {
			foreach ($obj as $key => $value) {
				$obj[$key] = \ZebraZ::its($value);
			}
			return $obj;
		} else {
			return \ZebraZ::input(\trim(\strip_tags($obj)));
		}
	}

	/**
	 * Replace an a ' and " chars to HTML codes
	 * 
	 * @param string $var Input string
	 * @return string
	 */
	public static function input(string $var): string {
		$var = \str_replace('"', '&quot;', $var);
		$var = \str_replace("'", '&#39;', $var);
		return $var;
	}

	/**
	 * Replace back an a ' and " chars to HTML codes
	 * 
	 * @param string $var Input string
	 * @return string
	 */
	public static function rinput(string $var): string {
		$var = \str_replace('&quot;', '"', $var);
		$var = \str_replace('&#39;', "'", $var);
		return $var;
	}

	/**
	 * Convert std class to array
	 * 
	 * @param object|array $d
	 * @return object|array
	 */
	public static function stdClassToArray($d) {
		if (\is_object($d) && $d instanceof stdClass) {
			// Gets the properties of the given object
			// with get_object_vars function
			$d = \get_object_vars($d);
		}

		if (\is_array($d)) {
			/*
			 * Return array converted to object
			 * Using __FUNCTION__ (Magic constant)
			 * for recursive call
			 */
			return \array_map(__METHOD__, $d);
		} else {
			// Return array
			return $d;
		}
	}

	/**
	 * Get a valid visitor IP
	 * 
	 * @return string
	 */
	public static function getIp(): string {
		return \getenv('HTTP_CLIENT_IP') ?:
			\getenv('HTTP_X_FORWARDED_FOR') ?:
			\getenv('HTTP_X_FORWARDED') ?:
			\getenv('HTTP_FORWARDED_FOR') ?:
			\getenv('HTTP_FORWARDED') ?:
			\getenv('REMOTE_ADDR') ?:
			\reset((\explode(' ', \getenv('SSH_CLIENT'))));
	}

	/**
	 * Generate a strong password
	 * 
	 * @param int $length Password length, Default is 8 char
	 * @param bool $add_dashes Add dash or not, Defaolt NOT
	 * @param string $available_sets Which type password will be generate, Default: lud, Available l: lovercase u: uppercase, d: decimals, s: special, i: include exlided chars and decimals
	 * @return string
	 */
	public static function generateStrongPassword($length = 8, $add_dashes = FALSE, $available_sets = 'lud'): string {
		$sets = [];
		if (\strpos($available_sets, 'l') !== FALSE)
			$sets[] = 'abcdefghjkmnpqrstuvwxyz';
		if (\strpos($available_sets, 'u') !== FALSE)
			$sets[] = 'ABCDEFGHJKMNPQRSTUVWXYZ';
		if (\strpos($available_sets, 'd') !== FALSE)
			$sets[] = '23456789';
		if (\strpos($available_sets, 's') !== FALSE)
			$sets[] = '!@#$%&*?';
		if (\strpos($available_sets, 'i') !== FALSE)
			$sets[] = 'iIlLoO01';

		$all = '';
		$password = '';
		foreach ($sets as $set) {
			$password .= $set[\array_rand(\str_split($set))];
			$all .= $set;
		}

		$all = \str_split($all);
		for ($i = 0; $i < $length - \count($sets); $i++)
			$password .= $all[\array_rand($all)];

		$password = \str_shuffle($password);

		if (!$add_dashes)
			return $password;

		$dash_len = \floor(\sqrt($length));
		$dash_str = '';
		while (\strlen($password) > $dash_len) {
			$dash_str .= \substr($password, 0, $dash_len) . '-';
			$password = \substr($password, $dash_len);
		}
		$dash_str .= $password;
		return $dash_str;
	}

	/**
	 * Syslog
	 * 
	 * @param string $ident Which ident
	 * @param string $message text message
	 * @param integer $priority Default LOG_INFO
	 */
	public static function logTo($ident, $message, $priority = \LOG_INFO) {
		\openlog($ident, \LOG_CONS, \LOG_AUTHPRIV);
		\syslog($priority, $message);
		\closelog();
	}

	/**
	 * Send default web header
	 */
	public static function sendDefaultWebHeader() {
		\ini_set('session.bug_compat_42', '0');
		\ini_set('session.bug_compat_warn', '0');
		\ini_set('session.cookie_lifetime', '0');
		\header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
		\header("Last-Modified: " . \gmdate("D, d M Y H:i:s") . " GMT");
		\header("Cache-Control: no-store, no-cache, must-revalidate");
		\header("Cache-Control: post-check=0, pre-check=0", FALSE);
		\header("Pragma: no-cache");
		\header('Content-Type: text/html; charset=utf-8');
	}

	/**
	 * validate string is valid Base 64 string
	 *
	 * @param string $param Base 64 string
	 * @return bool
	 */
	public static function validBase64(string $string): bool {
		// Check if there is no invalid character in strin
		if (!\preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $string))
			return FALSE;

		// Decode the string in strict mode and send the responce
		if (!\base64_decode($string, TRUE))
			return FALSE;

		// Encode and compare it to origional one
		if (\base64_encode(\base64_decode($string)) != $string)
			return FALSE;

		return TRUE;
	}

	/**
	 * Calculate an a valid expiration date
	 *
	 * @param string   $whmcsExpiration Domain expiration in WHMCS
	 * @param string   $huregRegDate Domain registration date (Firt reg date in a past) on hureg
	 *
	 * @return string   Corrected expiration date
	 */
	public static function getHuregExpiration(string $whmcsExpiration, string $huregRegDate): string {
		$reg = new \DateTime($huregRegDate);
		// 1. Ha a reg date < 1998-01-01, akkor nicsen fenntartási díj, return -1
		$start = new \DateTime('1998-01-01');
		if ($reg < $start) {
			return $whmcsExpiration;
		}
		// 2. Ha nem telt még el egy év a reg dat óta, akkor domain reg date plusz két év minumum
		$oneYear = new \DateTime($huregRegDate);
		$oneYear->add(new \DateInterval('P1Y'));
		$today = new \DateTime('today');
		if ($oneYear > $today) {
			$reg->add(new \DateInterval('P2Y'));
			if ($reg->format('Y-m-d') != $whmcsExpiration) {
				return \ZebraZ::getCorrectedExpiration($whmcsExpiration, $reg->format('Y-m-d'));
			} else {
				return $reg->format('Y-m-d');
			}
		}
		// 3. Minden más esetben, a következő fizetési évforduló
		$years = \intval($reg->diff($today)->format('%y'));
		$expiration = new \DateTime($huregRegDate);
		$expiration->add(new \DateInterval('P' . $years . 'Y'));
		if ($expiration >= $today) {
			if ($expiration->format('Y-m-d') != $whmcsExpiration) {
				return \ZebraZ::getCorrectedExpiration($whmcsExpiration, $expiration->format('Y-m-d'));
			} else {
				return $expiration->format('Y-m-d');
			}
		}
		$expiration->add(new \DateInterval('P1Y'));
		if ($expiration->format('Y-m-d') != $whmcsExpiration) {
			return \ZebraZ::getCorrectedExpiration($whmcsExpiration, $expiration->format('Y-m-d'));
		} else {
			return $expiration->format('Y-m-d');
		}
	}

	/**
	 * Return the next paypent date
	 *
	 * @param string   $whmcsExpiration Domain expiration in WHMCS
	 * @param string   $huregExpiration Previously calculated HUreg expiration
	 *
	 * @return string   Corrected expiration date
	 */
	public static function getCorrectedExpiration(string $whmcsExpiration, string $huregExpiration): string {
		$datetimeHureg = new \DateTime($huregExpiration);
		$datetimePanda = new \DateTime($whmcsExpiration);
		while (1 == 1) {
			$interval = $datetimeHureg->diff($datetimePanda);
			// Ha a WHMCS lejárart max 0 nappal nagyobb, mint a hureg, akkor hureg
			if (\intval($interval->format('%R%a')) < 1) {
				return $huregExpiration;
			}
			$datetimeHureg->add(new \DateInterval('P1Y'));
			$huregExpiration = $datetimeHureg->format('Y-m-d');
		}
	}

	/**
	 * Validate IP address is in loopback ranges
	 *
	 * @param string $value IP address
	 * @return bool
	 */
	public static function FILTER_FLAG_NO_LOOPBACK_RANGE(string $value): bool {
		// Fails validation for the following loopback IPv4 range: 127.0.0.0/8
		// This flag does not apply to IPv6 addresses
		return \filter_var($value, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) ? $value :
			(((\ip2long($value) & 0xff000000) == 0x7f000000) ? FALSE : $value);
	}

	/**
	 * Get Gearman client status code string
	 *
	 * @param int $code Gearman status code
	 * @return string
	 */
	public static function getGearmanStatus(int $code): string {
		switch ($code) {
			case \GEARMAN_SUCCESS:
				return 'GEARMAN_SUCCESS';
				break;
			case \GEARMAN_IO_WAIT:
				return 'GEARMAN_IO_WAIT';
				break;
			case \GEARMAN_SHUTDOWN:
				return 'GEARMAN_SHUTDOWN';
				break;
			case \GEARMAN_SHUTDOWN_GRACEFUL:
				return 'GEARMAN_SHUTDOWN_GRACEFUL';
				break;
			case \GEARMAN_ERRNO:
				return 'GEARMAN_ERRNO';
				break;
			case \GEARMAN_EVENT:
				return 'GEARMAN_EVENT';
				break;
			case \GEARMAN_TOO_MANY_ARGS:
				return 'GEARMAN_TOO_MANY_ARGS';
				break;
			case \GEARMAN_NO_ACTIVE_FDS:
				return 'GEARMAN_NO_ACTIVE_FDS';
				break;
			case \GEARMAN_INVALID_MAGIC:
				return 'GEARMAN_INVALID_MAGIC';
				break;
			case \GEARMAN_INVALID_COMMAND:
				return 'GEARMAN_INVALID_COMMAND';
				break;
			case \GEARMAN_INVALID_PACKET:
				return 'GEARMAN_INVALID_PACKET';
				break;
			case \GEARMAN_UNEXPECTED_PACKET:
				return 'GEARMAN_UNEXPECTED_PACKET';
				break;
			case \GEARMAN_GETADDRINFO:
				return 'GEARMAN_GETADDRINFO';
				break;
			case \GEARMAN_NO_SERVERS:
				return 'GEARMAN_NO_SERVERS';
				break;
			case \GEARMAN_LOST_CONNECTION:
				return 'GEARMAN_LOST_CONNECTION';
				break;
			case \GEARMAN_MEMORY_ALLOCATION_FAILURE:
				return 'GEARMAN_MEMORY_ALLOCATION_FAILURE';
				break;
			case \GEARMAN_JOB_EXISTS:
				return 'GEARMAN_JOB_EXISTS';
				break;
			case \GEARMAN_JOB_QUEUE_FULL:
				return 'GEARMAN_JOB_QUEUE_FULL';
				break;
			case \GEARMAN_SERVER_ERROR:
				return 'GEARMAN_SERVER_ERROR';
				break;
			case \GEARMAN_WORK_ERROR:
				return 'GEARMAN_WORK_ERROR';
				break;
			case \GEARMAN_WORK_DATA:
				return 'GEARMAN_WORK_DATA';
				break;
			case \GEARMAN_WORK_WARNING:
				return 'GEARMAN_WORK_WARNING';
				break;
			case \GEARMAN_WORK_STATUS:
				return 'GEARMAN_WORK_STATUS';
				break;
			case \GEARMAN_WORK_EXCEPTION:
				return 'GEARMAN_WORK_EXCEPTION';
				break;
			case \GEARMAN_WORK_FAIL:
				return 'GEARMAN_WORK_FAIL';
				break;
			case \GEARMAN_NOT_CONNECTED:
				return 'GEARMAN_NOT_CONNECTED';
				break;
			case \GEARMAN_COULD_NOT_CONNECT:
				return 'GEARMAN_COULD_NOT_CONNECT';
				break;
			case \GEARMAN_SEND_IN_PROGRESS:
				return 'GEARMAN_SEND_IN_PROGRESS';
				break;
			case \GEARMAN_RECV_IN_PROGRESS:
				return 'GEARMAN_RECV_IN_PROGRESS';
				break;
			case \GEARMAN_NOT_FLUSHING:
				return 'GEARMAN_NOT_FLUSHING';
				break;
			case \GEARMAN_DATA_TOO_LARGE:
				return 'GEARMAN_DATA_TOO_LARGE';
				break;
			case \GEARMAN_INVALID_FUNCTION_NAME:
				return 'GEARMAN_INVALID_FUNCTION_NAME';
				break;
			case \GEARMAN_INVALID_WORKER_FUNCTION:
				return 'GEARMAN_INVALID_WORKER_FUNCTION';
				break;
			case \GEARMAN_NO_REGISTERED_FUNCTIONS:
				return 'GEARMAN_NO_REGISTERED_FUNCTIONS';
				break;
			case \GEARMAN_NO_JOBS:
				return 'GEARMAN_NO_JOBS';
				break;
			case \GEARMAN_ECHO_DATA_CORRUPTION:
				return 'GEARMAN_ECHO_DATA_CORRUPTION';
				break;
			case \GEARMAN_NEED_WORKLOAD_FN:
				return 'GEARMAN_NEED_WORKLOAD_FN';
				break;
			case \GEARMAN_PAUSE:
				return 'GEARMAN_PAUSE';
				break;
			case \GEARMAN_UNKNOWN_STATE:
				return 'GEARMAN_UNKNOWN_STATE';
				break;
			case \GEARMAN_PTHREAD:
				return 'GEARMAN_PTHREAD';
				break;
			case \GEARMAN_PIPE_EOF:
				return 'GEARMAN_PIPE_EOF';
				break;
			case \GEARMAN_QUEUE_ERROR:
				return 'GEARMAN_QUEUE_ERROR';
				break;
			case \GEARMAN_FLUSH_DATA:
				return 'GEARMAN_FLUSH_DATA';
				break;
			case \GEARMAN_SEND_BUFFER_TOO_SMALL:
				return 'GEARMAN_SEND_BUFFER_TOO_SMALL';
				break;
			case \GEARMAN_IGNORE_PACKET:
				return 'GEARMAN_IGNORE_PACKET';
				break;
			case \GEARMAN_UNKNOWN_OPTION:
				return 'GEARMAN_UNKNOWN_OPTION';
				break;
			case \GEARMAN_MAX_RETURN:
				return 'GEARMAN_MAX_RETURN';
				break;
			case \GEARMAN_TIMEOUT:
				return 'GEARMAN_TIMEOUT';
				break;
			case \GEARMAN_ARGUMENT_TOO_LARGE:
				return 'GEARMAN_ARGUMENT_TOO_LARGE';
				break;
			case \GEARMAN_MAX_RETURN:
				return 'GEARMAN_MAX_RETURN';
				break;
			default:
				return 'UNKNOWN GEARMAN RETURN CODE';
				break;
		}
	}

	/**
	 * Format a phone number
	 * 
	 * @param string $phoneNumber Unfomatted phone number
	 * @param string $delimiter Delimiter between country and national number
	 * @return string
	 */
	public static function formatPhoneNumber(string $phoneNumber, string $delimiter = '.'): string {
		if (empty($phoneNumber)) {
			return '';
		}
		if (\substr($phoneNumber, 0, 1) != '+') {
			$phoneNumber = "+$phoneNumber";
		}
		$phoneUtil = \libphonenumber\PhoneNumberUtil::getInstance();
		try {
			$phoneNumber = $phoneUtil->parse($phoneNumber, 'HU');
			if ($phoneUtil->isValidNumber($phoneNumber)) {
				return '+' . $phoneNumber->getCountryCode() . $delimiter . $phoneNumber->getNationalNumber();
			}
			return '';
		} catch (\Exception $e) {
			return '';
		}
	}

}