2012-04-23 17:50:30 +04:00
< ? php
/**
2013-11-03 16:51:39 +04:00
* ownCloud
*
* @ author Frank Karlitschek
* @ copyright 2012 Frank Karlitschek frank @ owncloud . org
*
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation ; either
* version 3 of the License , or any later version .
*
* This library 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 AFFERO GENERAL PUBLIC LICENSE for more details .
*
* You should have received a copy of the GNU Affero General Public
* License along with this library . If not , see < http :// www . gnu . org / licenses />.
*
*/
2012-04-23 17:50:30 +04:00
/**
* Public interface of ownCloud for apps to use .
* Utility Class .
*
*/
2012-07-02 22:24:26 +04:00
// use OCP namespace for all classes that are considered public.
2012-04-23 17:50:30 +04:00
// This means that they should be used by apps instead of the internal ownCloud classes
namespace OCP ;
2012-05-19 12:36:57 +04:00
/**
* This class provides different helper functions to make the life of a developer easier
*/
2012-04-23 17:50:30 +04:00
class Util {
2012-05-01 19:38:27 +04:00
// consts for Logging
const DEBUG = 0 ;
const INFO = 1 ;
const WARN = 2 ;
const ERROR = 3 ;
const FATAL = 4 ;
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* get the current installed version of ownCloud
2012-05-01 23:07:08 +04:00
* @ return array
*/
2012-09-07 17:22:01 +04:00
public static function getVersion () {
2012-05-01 23:07:08 +04:00
return ( \OC_Util :: getVersion ());
}
2012-04-23 17:50:30 +04:00
/**
2013-10-31 22:00:53 +04:00
* send an email
2012-04-23 17:50:30 +04:00
* @ param string $toaddress
* @ param string $toname
* @ param string $subject
* @ param string $mailtext
* @ param string $fromaddress
* @ param string $fromname
* @ param bool $html
2013-10-31 22:00:53 +04:00
* @ param string $altbody
* @ param string $ccaddress
* @ param string $ccname
* @ param string $bcc
2012-04-23 17:50:30 +04:00
*/
2013-02-11 20:44:02 +04:00
public static function sendMail ( $toaddress , $toname , $subject , $mailtext , $fromaddress , $fromname ,
$html = 0 , $altbody = '' , $ccaddress = '' , $ccname = '' , $bcc = '' ) {
2012-04-23 17:50:30 +04:00
// call the internal mail class
2013-02-11 20:44:02 +04:00
\OC_MAIL :: send ( $toaddress , $toname , $subject , $mailtext , $fromaddress , $fromname ,
$html , $altbody , $ccaddress , $ccname , $bcc );
2012-04-23 17:50:30 +04:00
}
2012-09-08 18:18:47 +04:00
/**
2013-10-31 22:00:53 +04:00
* write a message in the log
2012-05-01 11:39:12 +04:00
* @ param string $app
* @ param string $message
2012-12-25 21:17:32 +04:00
* @ param int $level
2012-09-08 18:18:47 +04:00
*/
public static function writeLog ( $app , $message , $level ) {
// call the internal log class
\OC_LOG :: write ( $app , $message , $level );
}
2012-05-01 11:39:12 +04:00
2013-10-23 12:47:26 +04:00
/**
2013-10-31 22:00:53 +04:00
* write exception into the log . Include the stack trace
2013-10-23 12:47:26 +04:00
* if DEBUG mode is enabled
2013-10-31 22:00:53 +04:00
* @ param string $app app name
2013-10-23 12:47:26 +04:00
* @ param Exception $ex exception to log
*/
2013-10-23 15:58:42 +04:00
public static function logException ( $app , \Exception $ex ) {
2014-01-23 15:11:53 +04:00
$class = get_class ( $ex );
2014-03-20 13:23:40 +04:00
$message = $class . ': ' . $ex -> getMessage ();
2013-10-23 12:47:26 +04:00
if ( $ex -> getCode ()) {
$message .= ' [' . $ex -> getCode () . ']' ;
}
2014-03-20 13:23:40 +04:00
\OCP\Util :: writeLog ( $app , $message , \OCP\Util :: FATAL );
2013-10-23 12:47:26 +04:00
if ( defined ( 'DEBUG' ) and DEBUG ) {
// also log stack trace
2014-01-23 15:11:53 +04:00
$stack = explode ( " \n " , $ex -> getTraceAsString ());
2013-10-23 12:47:26 +04:00
// first element is empty
array_shift ( $stack );
foreach ( $stack as $s ) {
2013-10-23 15:58:42 +04:00
\OCP\Util :: writeLog ( $app , 'Exception: ' . $s , \OCP\Util :: FATAL );
2013-10-23 12:47:26 +04:00
}
// include cause
while ( method_exists ( $ex , 'getPrevious' ) && $ex = $ex -> getPrevious ()) {
2013-12-16 18:04:02 +04:00
$message .= ' - Caused by:' . ' ' ;
2013-10-23 12:47:26 +04:00
$message .= $ex -> getMessage ();
if ( $ex -> getCode ()) {
$message .= '[' . $ex -> getCode () . '] ' ;
}
2013-10-23 15:58:42 +04:00
\OCP\Util :: writeLog ( $app , 'Exception: ' . $message , \OCP\Util :: FATAL );
2013-10-23 12:47:26 +04:00
}
}
}
2013-07-19 13:40:11 +04:00
/**
2013-10-31 22:00:53 +04:00
* get l10n object
* @ param string $application
2014-01-13 17:28:49 +04:00
* @ return \OC_L10N
2013-07-19 13:40:11 +04:00
*/
public static function getL10N ( $application ) {
2013-07-22 17:52:02 +04:00
return \OC_L10N :: get ( $application );
2012-09-08 18:18:47 +04:00
}
2012-05-01 11:39:12 +04:00
/**
2013-10-31 22:00:53 +04:00
* add a css file
* @ param string $application
* @ param string $file
2012-05-01 11:39:12 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function addStyle ( $application , $file = null ) {
2012-05-07 00:02:16 +04:00
\OC_Util :: addStyle ( $application , $file );
2012-09-08 18:18:47 +04:00
}
2012-05-07 00:02:16 +04:00
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* add a javascript file
2012-12-25 21:17:32 +04:00
* @ param string $application
2013-10-31 22:00:53 +04:00
* @ param string $file
2012-05-01 23:07:08 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function addScript ( $application , $file = null ) {
2012-05-07 00:02:16 +04:00
\OC_Util :: addScript ( $application , $file );
2012-09-08 18:18:47 +04:00
}
2012-04-23 17:50:30 +04:00
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* Add a custom element to the header
2012-12-25 21:17:32 +04:00
* @ param string $tag tag name of the element
2012-05-01 23:07:08 +04:00
* @ param array $attributes array of attributes for the element
* @ param string $text the text content for the element
*/
2012-09-07 17:22:01 +04:00
public static function addHeader ( $tag , $attributes , $text = '' ) {
2012-05-09 17:17:40 +04:00
\OC_Util :: addHeader ( $tag , $attributes , $text );
2012-05-01 23:07:08 +04:00
}
2012-04-23 17:50:30 +04:00
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* formats a timestamp in the " right " way
2012-12-25 21:17:32 +04:00
* @ param int $timestamp $timestamp
* @ param bool $dateOnly option to omit time from the result
2012-05-01 23:07:08 +04:00
*/
2012-11-02 22:53:02 +04:00
public static function formatDate ( $timestamp , $dateOnly = false ) {
return ( \OC_Util :: formatDate ( $timestamp , $dateOnly ));
2012-05-01 23:07:08 +04:00
}
2012-04-23 17:50:30 +04:00
2013-08-12 19:25:27 +04:00
/**
2013-10-31 22:00:53 +04:00
* check if some encrypted files are stored
2013-08-12 19:25:27 +04:00
* @ return bool
*/
public static function encryptedFiles () {
return \OC_Util :: encryptedFiles ();
}
2013-10-31 22:00:53 +04:00
2012-05-02 01:19:39 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an absolute url to the given app and file .
2012-12-25 21:17:32 +04:00
* @ param string $app app
* @ param string $file file
* @ param array $args array with param => value , will be appended to the returned url
2012-09-29 00:27:52 +04:00
* The value of $args will be urlencoded
2013-10-31 22:00:53 +04:00
* @ return string the url
2012-05-02 01:19:39 +04:00
*/
2012-09-03 20:13:45 +04:00
public static function linkToAbsolute ( $app , $file , $args = array () ) {
return ( \OC_Helper :: linkToAbsolute ( $app , $file , $args ));
2012-05-02 01:19:39 +04:00
}
2012-05-02 00:59:38 +04:00
2012-05-07 22:22:55 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an absolute url for remote use .
2012-12-25 21:17:32 +04:00
* @ param string $service id
2013-10-31 22:00:53 +04:00
* @ return string the url
2012-05-07 22:22:55 +04:00
*/
public static function linkToRemote ( $service ) {
return ( \OC_Helper :: linkToRemote ( $service ));
}
2012-08-27 23:46:05 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an absolute url for public use
2012-12-25 21:17:32 +04:00
* @ param string $service id
2013-10-31 22:00:53 +04:00
* @ return string the url
2012-08-27 23:46:05 +04:00
*/
public static function linkToPublic ( $service ) {
return \OC_Helper :: linkToPublic ( $service );
}
2012-06-14 14:57:30 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an url using a defined route
2013-02-09 01:05:13 +04:00
* @ param $route
* @ param array $parameters
* @ return
* @ internal param array $args with param => value , will be appended to the returned url
2013-10-31 22:00:53 +04:00
* @ return the url
2013-02-09 01:05:13 +04:00
*/
public static function linkToRoute ( $route , $parameters = array () ) {
return \OC_Helper :: linkToRoute ( $route , $parameters );
}
/**
2013-10-31 22:00:53 +04:00
* Creates an url to the given app and file
2012-12-25 21:17:32 +04:00
* @ param string $app app
* @ param string $file file
* @ param array $args array with param => value , will be appended to the returned url
2012-09-29 00:27:52 +04:00
* The value of $args will be urlencoded
2013-10-31 22:00:53 +04:00
* @ return string the url
2012-06-14 14:57:30 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function linkTo ( $app , $file , $args = array () ) {
2012-09-03 20:13:45 +04:00
return ( \OC_Helper :: linkTo ( $app , $file , $args ));
2012-05-02 01:19:39 +04:00
}
2012-05-02 00:59:38 +04:00
2012-05-02 01:19:39 +04:00
/**
2013-10-31 22:00:53 +04:00
* Returns the server host , even if the website uses one or more reverse proxy
* @ return string the server host
2012-05-02 01:19:39 +04:00
*/
public static function getServerHost () {
2012-08-07 00:16:45 +04:00
return ( \OC_Request :: serverHost ());
2012-05-02 01:19:39 +04:00
}
2012-05-02 00:59:38 +04:00
2012-12-19 04:09:14 +04:00
/**
* Returns the server host name without an eventual port number
2013-10-31 22:00:53 +04:00
* @ return string the server hostname
2012-12-19 04:09:14 +04:00
*/
public static function getServerHostName () {
$host_name = self :: getServerHost ();
// strip away port number (if existing)
$colon_pos = strpos ( $host_name , ':' );
if ( $colon_pos != FALSE ) {
$host_name = substr ( $host_name , 0 , $colon_pos );
}
return $host_name ;
}
/**
2013-10-31 22:00:53 +04:00
* Returns the default email address
2012-12-25 21:17:32 +04:00
* @ param string $user_part the user part of the address
2013-10-31 22:00:53 +04:00
* @ return string the default email address
2012-12-19 04:09:14 +04:00
*
* Assembles a default email address ( using the server hostname
* and the given user part , and returns it
* Example : when given lostpassword - noreply as $user_part param ,
* and is currently accessed via http ( s ) :// example . com / ,
* it would return 'lostpassword-noreply@example.com'
2014-01-24 17:22:42 +04:00
*
* If the configuration value 'mail_from_address' is set in
* config . php , this value will override the $user_part that
* is passed to this function
2012-12-19 04:09:14 +04:00
*/
public static function getDefaultEmailAddress ( $user_part ) {
2014-01-24 17:04:37 +04:00
$user_part = \OC_Config :: getValue ( 'mail_from_address' , $user_part );
2012-12-19 04:09:14 +04:00
$host_name = self :: getServerHostName ();
2013-03-22 13:07:06 +04:00
$host_name = \OC_Config :: getValue ( 'mail_domain' , $host_name );
2013-03-02 01:24:19 +04:00
$defaultEmailAddress = $user_part . '@' . $host_name ;
2013-03-05 00:10:18 +04:00
if ( \OC_Mail :: ValidateAddress ( $defaultEmailAddress )) {
2013-03-02 01:24:19 +04:00
return $defaultEmailAddress ;
2012-12-19 04:09:14 +04:00
}
2013-03-02 01:24:19 +04:00
2013-03-05 00:10:18 +04:00
// in case we cannot build a valid email address from the hostname let's fallback to 'localhost.localdomain'
2013-03-02 01:24:19 +04:00
return $user_part . '@localhost.localdomain' ;
2012-12-19 04:09:14 +04:00
}
2012-06-01 12:38:44 +04:00
/**
* Returns the server protocol . It respects reverse proxy servers and load balancers
2013-10-31 22:00:53 +04:00
* @ return string the server protocol
2012-06-01 12:38:44 +04:00
*/
public static function getServerProtocol () {
2012-08-07 00:16:45 +04:00
return ( \OC_Request :: serverProtocol ());
2012-06-01 12:38:44 +04:00
}
2012-09-09 14:54:47 +04:00
/**
2013-10-31 22:00:53 +04:00
* Returns the request uri , even if the website uses one or more reverse proxies
2012-09-09 14:54:47 +04:00
*
2013-10-31 22:00:53 +04:00
* @ return the request uri
2012-09-09 14:54:47 +04:00
*/
public static function getRequestUri () {
return ( \OC_Request :: requestUri ());
}
/**
2013-10-31 22:00:53 +04:00
* Returns the script name , even if the website uses one or more reverse proxies
2012-09-09 14:54:47 +04:00
*
2013-10-31 22:00:53 +04:00
* @ return the script name
2012-09-09 14:54:47 +04:00
*/
public static function getScriptName () {
return ( \OC_Request :: scriptName ());
}
2012-05-02 02:20:45 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates path to an image
2012-12-25 21:17:32 +04:00
* @ param string $app app
* @ param string $image image name
2013-10-31 22:00:53 +04:00
* @ return string the url
2012-05-02 02:20:45 +04:00
*/
2012-09-08 18:18:47 +04:00
public static function imagePath ( $app , $image ) {
2012-05-02 02:20:45 +04:00
return ( \OC_Helper :: imagePath ( $app , $image ));
}
/**
2013-10-31 22:00:53 +04:00
* Make a human file size ( 2048 to 2 kB )
2012-12-25 21:17:32 +04:00
* @ param int $bytes file size in bytes
2013-10-31 22:00:53 +04:00
* @ return string a human readable file size
2012-05-02 02:20:45 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function humanFileSize ( $bytes ) {
2012-05-02 02:20:45 +04:00
return ( \OC_Helper :: humanFileSize ( $bytes ));
}
/**
2013-10-31 22:00:53 +04:00
* Make a computer file size ( 2 kB to 2048 )
2012-12-25 21:17:32 +04:00
* @ param string $str file size in a fancy format
2013-10-31 22:00:53 +04:00
* @ return int a file size in bytes
2012-05-02 02:20:45 +04:00
*
* Inspired by : http :// www . php . net / manual / en / function . filesize . php #92418
*/
2012-09-07 17:22:01 +04:00
public static function computerFileSize ( $str ) {
2012-05-02 02:20:45 +04:00
return ( \OC_Helper :: computerFileSize ( $str ));
}
2012-05-05 12:18:45 +04:00
/**
2013-10-31 22:00:53 +04:00
* connects a function to a hook
2012-12-25 21:17:32 +04:00
* @ param string $signalclass class name of emitter
* @ param string $signalname name of signal
* @ param string $slotclass class name of slot
* @ param string $slotname name of slot
2013-10-31 22:00:53 +04:00
* @ return bool
2012-05-05 12:18:45 +04:00
*
* This function makes it very easy to connect to use hooks .
*
* TODO : write example
*/
2012-09-07 17:22:01 +04:00
static public function connectHook ( $signalclass , $signalname , $slotclass , $slotname ) {
2012-05-05 12:18:45 +04:00
return ( \OC_Hook :: connect ( $signalclass , $signalname , $slotclass , $slotname ));
}
2012-05-02 02:20:45 +04:00
2012-05-05 12:18:45 +04:00
/**
2013-10-31 22:00:53 +04:00
* Emits a signal . To get data from the slot use references !
2012-12-25 21:17:32 +04:00
* @ param string $signalclass class name of emitter
* @ param string $signalname name of signal
* @ param string $params defautl : array () array with additional data
2013-10-31 22:00:53 +04:00
* @ return bool true if slots exists or false if not
2012-05-05 12:18:45 +04:00
*
* TODO : write example
*/
2012-09-07 17:22:01 +04:00
static public function emitHook ( $signalclass , $signalname , $params = array ()) {
2012-05-05 12:18:45 +04:00
return ( \OC_Hook :: emit ( $signalclass , $signalname , $params ));
}
2012-05-02 00:59:38 +04:00
2012-06-09 17:05:14 +04:00
/**
2012-08-29 22:34:44 +04:00
* Register an get / post call . This is important to prevent CSRF attacks
2012-06-09 17:05:14 +04:00
* TODO : write example
*/
2012-09-07 17:22:01 +04:00
public static function callRegister () {
2012-06-09 17:05:14 +04:00
return ( \OC_Util :: callRegister ());
}
/**
* Check an ajax get / post call if the request token is valid . exit if not .
* Todo : Write howto
*/
2012-09-07 17:22:01 +04:00
public static function callCheck () {
2013-01-07 02:59:02 +04:00
\OC_Util :: callCheck ();
2012-06-09 17:05:14 +04:00
}
2012-07-02 22:24:26 +04:00
/**
2013-10-31 22:00:53 +04:00
* Used to sanitize HTML
2012-07-02 22:24:26 +04:00
*
2013-02-11 20:44:02 +04:00
* This function is used to sanitize HTML and should be applied on any
* string or array of strings before displaying it on a web page .
2012-07-02 22:24:26 +04:00
*
2012-12-25 21:17:32 +04:00
* @ param string | array of strings
2012-07-02 22:24:26 +04:00
* @ return array with sanitized strings or a single sinitized string , depends on the input parameter .
*/
2012-09-07 17:22:01 +04:00
public static function sanitizeHTML ( $value ) {
2012-07-02 22:24:26 +04:00
return ( \OC_Util :: sanitizeHTML ( $value ));
}
2013-10-31 22:00:53 +04:00
2013-07-04 20:21:49 +04:00
/**
2013-10-31 22:00:53 +04:00
* Public function to encode url parameters
2013-07-04 20:21:49 +04:00
*
* This function is used to encode path to file before output .
* Encoding is done according to RFC 3986 with one exception :
2013-10-31 22:00:53 +04:00
* Character '/' is preserved as is .
2013-07-04 20:21:49 +04:00
*
* @ param string $component part of URI to encode
2013-10-31 22:00:53 +04:00
* @ return string
2013-07-04 20:21:49 +04:00
*/
public static function encodePath ( $component ) {
return ( \OC_Util :: encodePath ( $component ));
}
2012-07-02 22:24:26 +04:00
/**
2013-10-31 22:00:53 +04:00
* Returns an array with all keys from input lowercased or uppercased . Numbered indices are left as is .
*
* @ param array $input The array to work on
* @ param int $case Either MB_CASE_UPPER or MB_CASE_LOWER ( default )
* @ param string $encoding The encoding parameter is the character encoding . Defaults to UTF - 8
* @ return array
*/
2012-09-07 17:22:01 +04:00
public static function mb_array_change_key_case ( $input , $case = MB_CASE_LOWER , $encoding = 'UTF-8' ) {
2012-07-02 22:24:26 +04:00
return ( \OC_Helper :: mb_array_change_key_case ( $input , $case , $encoding ));
}
/**
2013-10-31 22:00:53 +04:00
* replaces a copy of string delimited by the start and ( optionally ) length parameters with the string given in replacement .
*
* @ param string $string The input string . Opposite to the PHP build - in function does not accept an array .
* @ param string $replacement The replacement string .
* @ param int $start If start is positive , the replacing will begin at the start 'th offset into string. If start is negative, the replacing will begin at the start' th character from the end of string .
* @ param int $length Length of the part to be replaced
* @ param string $encoding The encoding parameter is the character encoding . Defaults to UTF - 8
* @ return string
*/
2012-07-02 22:24:26 +04:00
public static function mb_substr_replace ( $string , $replacement , $start , $length = null , $encoding = 'UTF-8' ) {
return ( \OC_Helper :: mb_substr_replace ( $string , $replacement , $start , $length , $encoding ));
}
/**
2013-10-31 22:00:53 +04:00
* Replace all occurrences of the search string with the replacement string
*
* @ param string $search The value being searched for , otherwise known as the needle . String .
* @ param string $replace The replacement string .
* @ param string $subject The string or array being searched and replaced on , otherwise known as the haystack .
* @ param string $encoding The encoding parameter is the character encoding . Defaults to UTF - 8
* @ param int $count If passed , this will be set to the number of replacements performed .
* @ return string
*/
2012-07-02 22:24:26 +04:00
public static function mb_str_replace ( $search , $replace , $subject , $encoding = 'UTF-8' , & $count = null ) {
return ( \OC_Helper :: mb_str_replace ( $search , $replace , $subject , $encoding , $count ));
2012-06-19 19:20:19 +04:00
}
2012-07-24 12:54:56 +04:00
/**
2013-10-31 22:00:53 +04:00
* performs a search in a nested array
*
* @ param array $haystack the array to be searched
* @ param string $needle the search string
* @ param int $index optional , only search this key name
* @ return mixed the key of the matching field , otherwise false
*/
2012-07-24 12:54:56 +04:00
public static function recursiveArraySearch ( $haystack , $needle , $index = null ) {
return ( \OC_Helper :: recursiveArraySearch ( $haystack , $needle , $index ));
}
2012-12-20 20:16:01 +04:00
2013-01-18 23:09:03 +04:00
/**
2013-10-31 22:00:53 +04:00
* calculates the maximum upload size respecting system settings , free space and user quota
2013-01-18 23:09:03 +04:00
*
2014-01-27 18:56:57 +04:00
* @ param string $dir the current folder where the user currently operates
* @ param int $free the number of bytes free on the storage holding $dir , if not set this will be received from the storage directly
2013-01-18 23:09:03 +04:00
* @ return number of bytes representing
*/
2014-01-27 18:56:57 +04:00
public static function maxUploadFilesize ( $dir , $free = null ) {
return \OC_Helper :: maxUploadFilesize ( $dir , $free );
2013-01-18 23:09:03 +04:00
}
2013-12-08 18:59:46 +04:00
/**
* Calculate free space left within user quota
*
* @ param $dir the current folder where the user currently operates
* @ return number of bytes representing
*/
public static function freeSpace ( $dir ) {
return \OC_Helper :: freeSpace ( $dir );
}
/**
* Calculate PHP upload limit
*
* @ return number of bytes representing
*/
public static function uploadLimit () {
return \OC_Helper :: uploadLimit ();
}
2014-01-10 19:14:37 +04:00
/**
* Returns whether the given file name is valid
* @ param $file string file name to check
* @ return bool true if the file name is valid , false otherwise
*/
public static function isValidFileName ( $file ) {
return \OC_Util :: isValidFileName ( $file );
}
2014-03-19 14:42:22 +04:00
/**
* @ brief Generates a cryptographic secure pseudo - random string
* @ param Int $length of the random string
* @ return String
*/
public static function generateRandomBytes ( $length = 30 ) {
return \OC_Util :: generateRandomBytes ( $length );
}
2012-05-01 23:07:08 +04:00
}