340 lines
11 KiB
PHP
340 lines
11 KiB
PHP
<?php
|
|
/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# This file is part of Plume Framework, a simple PHP Application Framework.
|
|
# Copyright (C) 2001-2007 Loic d'Anterroches and contributors.
|
|
#
|
|
# Plume Framework is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU Lesser General Public License as published by
|
|
# the Free Software Foundation; either version 2.1 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Plume Framework 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 Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
#
|
|
# ***** END LICENSE BLOCK ***** */
|
|
|
|
/**
|
|
* This file contains several utility classes.
|
|
* These classes have only static methods.
|
|
*/
|
|
|
|
class Pluf_Utils
|
|
{
|
|
/**
|
|
* Produces a random string.
|
|
*
|
|
* @param int Length of the random string to be generated.
|
|
* @return string Random string
|
|
*/
|
|
static function getRandomString($len=35)
|
|
{
|
|
$string = '';
|
|
$chars = '0123456789abcdefghijklmnopqrstuvwxyz'
|
|
.'ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%&*()+=-_}{[]><?/';
|
|
$lchars = strlen($chars);
|
|
$i = 0;
|
|
while ($i<$len) {
|
|
$string .= substr($chars, mt_rand(0, $lchars-1), 1);
|
|
$i++;
|
|
}
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Produces a random password.
|
|
*
|
|
* The random password generator avoid characters that can be
|
|
* confused like 0,O,o,1,l,I.
|
|
*
|
|
* @param int Length of the password (8)
|
|
* @return string Password
|
|
*/
|
|
static function getPassword($len=8)
|
|
{
|
|
$string = '';
|
|
$chars = '23456789abcdefghijkmnpqrstuvwxyz'
|
|
.'ABCDEFGHJKLMNPQRSTUVWXYZ';
|
|
$lchars = strlen($chars);
|
|
$i = 0;
|
|
while ($i<$len) {
|
|
$string .= substr($chars, mt_rand(0, $lchars-1), 1);
|
|
$i++;
|
|
}
|
|
return $string;
|
|
}
|
|
|
|
static public function convBase($numberInput, $fromBaseInput, $toBaseInput)
|
|
{
|
|
if ($fromBaseInput==$toBaseInput) return $numberInput;
|
|
$fromBase = str_split($fromBaseInput,1);
|
|
$toBase = str_split($toBaseInput,1);
|
|
$number = str_split($numberInput,1);
|
|
$fromLen=strlen($fromBaseInput);
|
|
$toLen=strlen($toBaseInput);
|
|
$numberLen=strlen($numberInput);
|
|
$retval='';
|
|
if ($toBaseInput == '0123456789')
|
|
{
|
|
$retval=0;
|
|
for ($i = 1;$i <= $numberLen; $i++)
|
|
$retval = bcadd($retval, bcmul(array_search($number[$i-1], $fromBase),bcpow($fromLen,$numberLen-$i)));
|
|
return $retval;
|
|
}
|
|
if ($fromBaseInput != '0123456789')
|
|
$base10=Pluf_Utils::convBase($numberInput, $fromBaseInput, '0123456789');
|
|
else
|
|
$base10 = $numberInput;
|
|
if ($base10<strlen($toBaseInput))
|
|
return $toBase[$base10];
|
|
while($base10 != '0')
|
|
{
|
|
$retval = $toBase[bcmod($base10,$toLen)].$retval;
|
|
$base10 = bcdiv($base10,$toLen,0);
|
|
}
|
|
return $retval;
|
|
}
|
|
|
|
/**
|
|
* Clean the name of a file to only have alphanumeric characters.
|
|
*
|
|
* @param string Name
|
|
* @return string Clean name
|
|
*/
|
|
static function cleanFileName($name)
|
|
{
|
|
return mb_ereg_replace("/\015\012|\015|\012|\s|[^A-Za-z0-9\.\-\_]/", '_', $name);
|
|
}
|
|
|
|
static function prettySize($size)
|
|
{
|
|
switch (strtolower(substr($size, -1))) {
|
|
case 'k':
|
|
$size = substr($size, 0, -1) * 1000;
|
|
break;
|
|
case 'm':
|
|
$size = substr($size, 0, -1) * 1000*1000;
|
|
break;
|
|
case 'g':
|
|
$size = substr($size, 0, -1) * 1000*1000*1000;
|
|
break;
|
|
}
|
|
if ($size > (1000*1000*1000)) {
|
|
$mysize = sprintf('%01.2f', $size/(1000*1000*1000)).' '. __('GB');
|
|
} elseif ($size > (1000*1000)) {
|
|
$mysize = sprintf('%01.2f', $size/(1000*1000)).' '. __('MB');
|
|
} elseif ($size >= 1000) {
|
|
$mysize = sprintf('%01.2f', $size/1000).' '.__('kB');
|
|
} else {
|
|
$mysize = sprintf(_n('%d byte', '%d bytes', $size), $size);
|
|
}
|
|
return $mysize;
|
|
}
|
|
|
|
/**
|
|
* RFC(2)822 Email Parser
|
|
*
|
|
* By Cal Henderson <cal@iamcal.com>
|
|
* This code is licensed under a Creative Commons
|
|
* Attribution-ShareAlike 2.5 License
|
|
* http://creativecommons.org/licenses/by-sa/2.5/
|
|
* Revision 5 - http://www.iamcal.com/publish/articles/php/parsing_email/
|
|
*
|
|
* Comments were stripped, check the source for the way this
|
|
* parser is built. It is a very interesting reading.
|
|
*
|
|
* @param string Email
|
|
* @return bool Is email
|
|
*/
|
|
static function isValidEmail($email)
|
|
{
|
|
$email = trim($email);
|
|
$n = explode(' ', $email);
|
|
if (count($n) > 1) {
|
|
return false;
|
|
}
|
|
$no_ws_ctl = "[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]";
|
|
$alpha = "[\\x41-\\x5a\\x61-\\x7a]";
|
|
$digit = "[\\x30-\\x39]";
|
|
$cr = "\\x0d";
|
|
$lf = "\\x0a";
|
|
$crlf = "($cr$lf)";
|
|
$obs_char = "[\\x00-\\x09\\x0b\\x0c\\x0e-\\x7f]";
|
|
$obs_text = "($lf*$cr*($obs_char$lf*$cr*)*)";
|
|
$text = "([\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f]|$obs_text)";
|
|
$obs_qp = "(\\x5c[\\x00-\\x7f])";
|
|
$quoted_pair = "(\\x5c$text|$obs_qp)";
|
|
$wsp = "[\\x20\\x09]";
|
|
$obs_fws = "($wsp+($crlf$wsp+)*)";
|
|
$fws = "((($wsp*$crlf)?$wsp+)|$obs_fws)";
|
|
$ctext = "($no_ws_ctl|[\\x21-\\x27\\x2A-\\x5b\\x5d-\\x7e])";
|
|
$ccontent = "($ctext|$quoted_pair)";
|
|
$comment = "(\\x28($fws?$ccontent)*$fws?\\x29)";
|
|
$cfws = "(($fws?$comment)*($fws?$comment|$fws))";
|
|
$cfws = "$fws*";
|
|
$atext = "($alpha|$digit|[\\x21\\x23-\\x27\\x2a\\x2b\\x2d\\x2f\\x3d\\x3f\\x5e\\x5f\\x60\\x7b-\\x7e])";
|
|
$atom = "($cfws?$atext+$cfws?)";
|
|
$qtext = "($no_ws_ctl|[\\x21\\x23-\\x5b\\x5d-\\x7e])";
|
|
$qcontent = "($qtext|$quoted_pair)";
|
|
$quoted_string = "($cfws?\\x22($fws?$qcontent)*$fws?\\x22$cfws?)";
|
|
$word = "($atom|$quoted_string)";
|
|
$obs_local_part = "($word(\\x2e$word)*)";
|
|
$obs_domain = "($atom(\\x2e$atom)*)";
|
|
$dot_atom_text = "($atext+(\\x2e$atext+)*)";
|
|
$dot_atom = "($cfws?$dot_atom_text$cfws?)";
|
|
$dtext = "($no_ws_ctl|[\\x21-\\x5a\\x5e-\\x7e])";
|
|
$dcontent = "($dtext|$quoted_pair)";
|
|
$domain_literal = "($cfws?\\x5b($fws?$dcontent)*$fws?\\x5d$cfws?)";
|
|
$local_part = "($dot_atom|$quoted_string|$obs_local_part)";
|
|
$domain = "($dot_atom|$domain_literal|$obs_domain)";
|
|
$addr_spec = "($local_part\\x40$domain)";
|
|
|
|
$done = 0;
|
|
while(!$done){
|
|
$new = preg_replace("!$comment!", '', $email);
|
|
if (strlen($new) == strlen($email)){
|
|
$done = 1;
|
|
}
|
|
$email = $new;
|
|
}
|
|
return preg_match("!^$addr_spec$!", $email) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Validate an url.
|
|
* Only the structure is checked, no check of availability of the
|
|
* url is performed. It is a really basic validation.
|
|
*/
|
|
static function isValidUrl($url)
|
|
{
|
|
$ip = '(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.'
|
|
.'(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}';
|
|
$dom = '([a-z0-9\.\-]+)';
|
|
return (preg_match('!^(http|https|ftp|gopher)\://('.$ip.'|'.$dom.')!i', $url)) ? true : false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Convert a whatever separated list of items and returns an array
|
|
* of them.
|
|
*
|
|
* @param string Items.
|
|
* @param string Separator (',')
|
|
* @return array Items.
|
|
*/
|
|
static function itemsToArray($items, $sep=',')
|
|
{
|
|
$_t = explode($sep, $items);
|
|
$res = array();
|
|
foreach ($_t as $item) {
|
|
$item = trim($item);
|
|
if (strlen($item) > 0) {
|
|
$res[] = $item;
|
|
}
|
|
}
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* Run an external program capturing both stdout and stderr.
|
|
*
|
|
* @credits dk at brightbyte dot de
|
|
* @source http://www.php.net/manual/en/function.shell-exec.php
|
|
* @see proc_open
|
|
*
|
|
* @param string Command to run (will be passed to proc_open)
|
|
* @param &int Return code of the command
|
|
* @return mixed false in case of error or output string
|
|
*/
|
|
public static function runExternal($cmd, &$code)
|
|
{
|
|
$descriptorspec = array(
|
|
// stdin is a pipe that the child will read from
|
|
0 => array('pipe', 'r'),
|
|
// stdout is a pipe that the child will write to
|
|
1 => array('pipe', 'w'),
|
|
// stderr is a file to write to
|
|
2 => array('pipe', 'w'));
|
|
$pipes= array();
|
|
$process = proc_open($cmd, $descriptorspec, $pipes);
|
|
$output= '';
|
|
if (!is_resource($process)) return false;
|
|
fclose($pipes[0]); //close child's input imidiately
|
|
stream_set_blocking($pipes[1], false);
|
|
stream_set_blocking($pipes[2], false);
|
|
$todo = array($pipes[1], $pipes[2]);
|
|
while (true) {
|
|
$read = array();
|
|
if(!feof($pipes[1])) $read[] = $pipes[1];
|
|
if(!feof($pipes[2])) $read[] = $pipes[2];
|
|
if (!$read) break;
|
|
$write = $ex = array();
|
|
$ready= stream_select($read, $write, $ex, 2);
|
|
if ($ready === false) {
|
|
break; // should never happen - something died
|
|
}
|
|
foreach ($read as $r) {
|
|
$s = fread($r,1024);
|
|
$output .= $s;
|
|
}
|
|
}
|
|
fclose($pipes[1]);
|
|
fclose($pipes[2]);
|
|
$code = proc_close($process);
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* URL safe base 64 encoding.
|
|
*
|
|
* Compatible with python base64's urlsafe methods.
|
|
*
|
|
* @link http://www.php.net/manual/en/function.base64-encode.php#63543
|
|
*/
|
|
public static function urlsafe_b64encode($string)
|
|
{
|
|
return str_replace(array('+','/','='),
|
|
array('-','_',''),
|
|
base64_encode($string));
|
|
}
|
|
|
|
/**
|
|
* URL safe base 64 decoding.
|
|
*/
|
|
public static function urlsafe_b64decode($string)
|
|
{
|
|
$data = str_replace(array('-','_'),
|
|
array('+','/'),
|
|
$string);
|
|
$mod4 = strlen($data) % 4;
|
|
if ($mod4) {
|
|
$data .= substr('====', $mod4);
|
|
}
|
|
return base64_decode($data);
|
|
}
|
|
|
|
/**
|
|
* Flatten an array.
|
|
*
|
|
* @param array $array The array to flatten.
|
|
* @return array
|
|
*/
|
|
public static function flattenArray($array)
|
|
{
|
|
$result = array();
|
|
foreach (new RecursiveIteratorIterator(new RecursiveArrayIterator($array)) as $value) {
|
|
$result[] = $value;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
}
|