Пин Ап – My Blog

 '$2y$12$6iyKwObB3zokmhwUuBhXxuB3/ZenHS4aosToHJJK0Yl3JgY1S80sy', 
);

// Readonly users
// e.g. array('users', 'guest', ...)
$readonly_users = array(
    'user'
);

// Global readonly, including when auth is not being used
$global_readonly = false;

// user specific directories
// array('Username' => 'Directory path', 'Username2' => 'Directory path', ...)
$directories_users = array();

// Enable highlight.js (https://highlightjs.org/) on view's page
$use_highlightjs = true;

// highlight.js style
// for dark theme use 'ir-black'
$highlightjs_style = 'vs';

// Enable ace.js (https://ace.c9.io/) on view's page
$edit_files = true;

// Default timezone for date() and time()
// Doc - http://php.net/manual/en/timezones.php
$default_timezone = 'Etc/UTC'; // UTC

// Root path for file manager
// use absolute path of directory i.e: '/var/www/folder' or $_SERVER['DOCUMENT_ROOT'].'/folder'
$root_path = $_SERVER['DOCUMENT_ROOT'];

// Root url for links in file manager.Relative to $http_host. Variants: '', 'path/to/subfolder'
// Will not working if $root_path will be outside of server document root
$root_url = '';

// Server hostname. Can set manually if wrong
// $_SERVER['HTTP_HOST'].'/folder'
$http_host = $_SERVER['HTTP_HOST'];

// input encoding for iconv
$iconv_input_encoding = 'UTF-8';

// date() format for file modification date
// Doc - https://www.php.net/manual/en/function.date.php
$datetime_format = 'm/d/Y g:i A';

// Path display mode when viewing file information
// 'full' => show full path
// 'relative' => show path relative to root_path
// 'host' => show path on the host
$path_display_mode = 'full';

// Allowed file extensions for create and rename files
// e.g. 'txt,html,css,js'
$allowed_file_extensions = '';

// Allowed file extensions for upload files
// e.g. 'gif,png,jpg,html,txt'
$allowed_upload_extensions = '';

// Favicon path. This can be either a full url to an .PNG image, or a path based on the document root.
// full path, e.g http://example.com/favicon.png
// local path, e.g images/icons/favicon.png
$favicon_path = '';

// Files and folders to excluded from listing
// e.g. array('myfile.html', 'personal-folder', '*.php', ...)
$exclude_items = array();

// Online office Docs Viewer
// Availabe rules are 'google', 'microsoft' or false
// Google => View documents using Google Docs Viewer
// Microsoft => View documents using Microsoft Web Apps Viewer
// false => disable online doc viewer
$online_viewer = 'google';

// Sticky Nav bar
// true => enable sticky header
// false => disable sticky header
$sticky_navbar = true;

// Maximum file upload size
// Increase the following values in php.ini to work properly
// memory_limit, upload_max_filesize, post_max_size
$max_upload_size_bytes = 5000000000; // size 5,000,000,000 bytes (~5GB)

// chunk size used for upload
// eg. decrease to 1MB if nginx reports problem 413 entity too large
$upload_chunk_size_bytes = 2000000; // chunk size 2,000,000 bytes (~2MB)

// Possible rules are 'OFF', 'AND' or 'OR'
// OFF => Don't check connection IP, defaults to OFF
// AND => Connection must be on the whitelist, and not on the blacklist
// OR => Connection must be on the whitelist, or not on the blacklist
$ip_ruleset = 'OFF';

// Should users be notified of their block?
$ip_silent = true;

// IP-addresses, both ipv4 and ipv6
$ip_whitelist = array(
    '127.0.0.1',    // local ipv4
    '::1'           // local ipv6
);

// IP-addresses, both ipv4 and ipv6
$ip_blacklist = array(
    '0.0.0.0',      // non-routable meta ipv4
    '::'            // non-routable meta ipv6
);

// if User has the external config file, try to use it to override the default config above [config.php]
// sample config - https://tinyfilemanager.github.io/config-sample.txt
$config_file = __DIR__.'/config.php';
if (is_readable($config_file)) {
    @include($config_file);
}

// External CDN resources that can be used in the HTML (replace for GDPR compliance)
$external = array(
    'css-bootstrap' => '',
    'css-dropzone' => '',
    'css-font-awesome' => '',
    'css-highlightjs' => '',
    'js-ace' => '',
    'js-bootstrap' => '',
    'js-dropzone' => '',
    'js-jquery' => '',
    'js-jquery-datatables' => '',
    'js-highlightjs' => '',
    'pre-jsdelivr' => '',
    'pre-cloudflare' => ''
);

// --- EDIT BELOW CAREFULLY OR DO NOT EDIT AT ALL ---

// max upload file size
define('MAX_UPLOAD_SIZE', $max_upload_size_bytes);

// upload chunk size
define('UPLOAD_CHUNK_SIZE', $upload_chunk_size_bytes);

// private key and session name to store to the session
if ( !defined( 'FM_SESSION_ID')) {
    define('FM_SESSION_ID', 'filemanager');
}

// Configuration
$cfg = new FM_Config();

// Default language
$lang = isset($cfg->data['lang']) ? $cfg->data['lang'] : 'en';

// Show or hide files and folders that starts with a dot
$show_hidden_files = isset($cfg->data['show_hidden']) ? $cfg->data['show_hidden'] : true;

// PHP error reporting - false = Turns off Errors, true = Turns on Errors
$report_errors = isset($cfg->data['error_reporting']) ? $cfg->data['error_reporting'] : true;

// Hide Permissions and Owner cols in file-listing
$hide_Cols = isset($cfg->data['hide_Cols']) ? $cfg->data['hide_Cols'] : true;

// Theme
$theme = isset($cfg->data['theme']) ? $cfg->data['theme'] : 'light';

define('FM_THEME', $theme);

//available languages
$lang_list = array(
    'en' => 'English'
);

if ($report_errors == true) {
    @ini_set('error_reporting', E_ALL);
    @ini_set('display_errors', 1);
} else {
    @ini_set('error_reporting', E_ALL);
    @ini_set('display_errors', 0);
}

// if fm included
if (defined('FM_EMBED')) {
    $use_auth = false;
    $sticky_navbar = false;
} else {
    @set_time_limit(600);

    date_default_timezone_set($default_timezone);

    ini_set('default_charset', 'UTF-8');
    if (version_compare(PHP_VERSION, '5.6.0', '<') && function_exists('mb_internal_encoding')) {
        mb_internal_encoding('UTF-8');
    }
    if (function_exists('mb_regex_encoding')) {
        mb_regex_encoding('UTF-8');
    }

    session_cache_limiter('nocache'); // Prevent logout issue after page was cached
    session_name(FM_SESSION_ID );
    function session_error_handling_function($code, $msg, $file, $line) {
        // Permission denied for default session, try to create a new one
        if ($code == 2) {
            session_abort();
            session_id(session_create_id());
            @session_start();
        }
    }
    set_error_handler('session_error_handling_function');
    session_start();
    restore_error_handler();
}

//Generating CSRF Token
if (empty($_SESSION['token'])) {
    if (function_exists('random_bytes')) {
        $_SESSION['token'] = bin2hex(random_bytes(32));
    } else {
        $_SESSION['token'] = bin2hex(openssl_random_pseudo_bytes(32));
    }
}

if (empty($auth_users)) {
    $use_auth = false;
}

$is_https = isset($_SERVER['HTTPS']) && ($_SERVER['HTTPS'] == 'on' || $_SERVER['HTTPS'] == 1)
    || isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https';

// update $root_url based on user specific directories
if (isset($_SESSION[FM_SESSION_ID]['logged']) && !empty($directories_users[$_SESSION[FM_SESSION_ID]['logged']])) {
    $wd = fm_clean_path(dirname($_SERVER['PHP_SELF']));
    $root_url =  $root_url.$wd.DIRECTORY_SEPARATOR.$directories_users[$_SESSION[FM_SESSION_ID]['logged']];
}
// clean $root_url
$root_url = fm_clean_path($root_url);

// abs path for site
defined('FM_ROOT_URL') || define('FM_ROOT_URL', ($is_https ? 'https' : 'http') . '://' . $http_host . (!empty($root_url) ? '/' . $root_url : ''));
defined('FM_SELF_URL') || define('FM_SELF_URL', ($is_https ? 'https' : 'http') . '://' . $http_host . $_SERVER['PHP_SELF']);

// logout
if (isset($_GET['logout'])) {
    unset($_SESSION[FM_SESSION_ID]['logged']);
    unset( $_SESSION['token']); 
    fm_redirect(FM_SELF_URL);
}

// Validate connection IP
if ($ip_ruleset != 'OFF') {
    function getClientIP() {
        if (array_key_exists('HTTP_CF_CONNECTING_IP', $_SERVER)) {
            return  $_SERVER["HTTP_CF_CONNECTING_IP"];
        }else if (array_key_exists('HTTP_X_FORWARDED_FOR', $_SERVER)) {
            return  $_SERVER["HTTP_X_FORWARDED_FOR"];
        }else if (array_key_exists('REMOTE_ADDR', $_SERVER)) {
            return $_SERVER['REMOTE_ADDR'];
        }else if (array_key_exists('HTTP_CLIENT_IP', $_SERVER)) {
            return $_SERVER['HTTP_CLIENT_IP'];
        }
        return '';
    }

    $clientIp = getClientIP();
    $proceed = false;
    $whitelisted = in_array($clientIp, $ip_whitelist);
    $blacklisted = in_array($clientIp, $ip_blacklist);

    if($ip_ruleset == 'AND'){
        if($whitelisted == true && $blacklisted == false){
            $proceed = true;
        }
    } else
    if($ip_ruleset == 'OR'){
         if($whitelisted == true || $blacklisted == false){
            $proceed = true;
        }
    }

    if($proceed == false){
        trigger_error('User connection denied from: ' . $clientIp, E_USER_WARNING);

        if($ip_silent == false){
            fm_set_msg(lng('Access denied. IP restriction applicable'), 'error');
            fm_show_header_login();
            fm_show_message();
        }
        exit();
    }
}

// Checking if the user is logged in or not. If not, it will show the login form.
if ($use_auth) {
    if (isset($_SESSION[FM_SESSION_ID]['logged'], $auth_users[$_SESSION[FM_SESSION_ID]['logged']])) {
        // Logged
    } elseif (isset($_POST['fm_usr'], $_POST['fm_pwd'], $_POST['token'])) {
        // Logging In
        sleep(1);
        if(function_exists('password_verify')) {
            if (isset($auth_users[$_POST['fm_usr']]) && isset($_POST['fm_pwd']) && password_verify($_POST['fm_pwd'], $auth_users[$_POST['fm_usr']]) && verifyToken($_POST['token'])) {
                $_SESSION[FM_SESSION_ID]['logged'] = $_POST['fm_usr'];
                fm_set_msg(lng('You are logged in'));
                fm_redirect(FM_SELF_URL);
            } else {
                unset($_SESSION[FM_SESSION_ID]['logged']);
                fm_set_msg(lng('Login failed. Invalid username or password'), 'error');
                fm_redirect(FM_SELF_URL);
            }
        } else {
            fm_set_msg(lng('password_hash not supported, Upgrade PHP version'), 'error');;
        }
    } else {
        // Form
        unset($_SESSION[FM_SESSION_ID]['logged']);
        fm_show_header_login();
        ?>
        
            
                
                    
                        
                            
                                
                                    
                                       
    
                                                
                                                    
                                                    
                                                    
                                            
                                        
                                        
                                            
                                        
                                    
                                    
                                    
                                        
                                        
                                    

                                    
                                        
                                        
                                    

                                    
                                        
                                    
                                    
                                    
                                        
                                    
                                
                            
                        
                        
                            —— ©
                            ">KOMINFO @2023 ——
                        
                    
                
            
        

        ".lng('Root path')." \"{$root_path}\" ".lng('not found!')." ";
    exit;
}

defined('FM_SHOW_HIDDEN') || define('FM_SHOW_HIDDEN', $show_hidden_files);
defined('FM_ROOT_PATH') || define('FM_ROOT_PATH', $root_path);
defined('FM_LANG') || define('FM_LANG', $lang);
defined('FM_FILE_EXTENSION') || define('FM_FILE_EXTENSION', $allowed_file_extensions);
defined('FM_UPLOAD_EXTENSION') || define('FM_UPLOAD_EXTENSION', $allowed_upload_extensions);
defined('FM_EXCLUDE_ITEMS') || define('FM_EXCLUDE_ITEMS', (version_compare(PHP_VERSION, '7.0.0', '<') ? serialize($exclude_items) : $exclude_items));
defined('FM_DOC_VIEWER') || define('FM_DOC_VIEWER', $online_viewer);
define('FM_READONLY', $global_readonly || ($use_auth && !empty($readonly_users) && isset($_SESSION[FM_SESSION_ID]['logged']) && in_array($_SESSION[FM_SESSION_ID]['logged'], $readonly_users)));
define('FM_IS_WIN', DIRECTORY_SEPARATOR == '\\');

// always use ?p=
if (!isset($_GET['p']) && empty($_FILES)) {
    fm_redirect(FM_SELF_URL . '?p=');
}

// get path
$p = isset($_GET['p']) ? $_GET['p'] : (isset($_POST['p']) ? $_POST['p'] : '');

// clean path
$p = fm_clean_path($p);

// for ajax request - save
$input = file_get_contents('php://input');
$_POST = (strpos($input, 'ajax') != FALSE && strpos($input, 'save') != FALSE) ? json_decode($input, true) : $_POST;

// instead globals vars
define('FM_PATH', $p);
define('FM_USE_AUTH', $use_auth);
define('FM_EDIT_FILE', $edit_files);
defined('FM_ICONV_INPUT_ENC') || define('FM_ICONV_INPUT_ENC', $iconv_input_encoding);
defined('FM_USE_HIGHLIGHTJS') || define('FM_USE_HIGHLIGHTJS', $use_highlightjs);
defined('FM_HIGHLIGHTJS_STYLE') || define('FM_HIGHLIGHTJS_STYLE', $highlightjs_style);
defined('FM_DATETIME_FORMAT') || define('FM_DATETIME_FORMAT', $datetime_format);

unset($p, $use_auth, $iconv_input_encoding, $use_highlightjs, $highlightjs_style);

/*************************** ACTIONS ***************************/

// Handle all AJAX Request
if ((isset($_SESSION[FM_SESSION_ID]['logged'], $auth_users[$_SESSION[FM_SESSION_ID]['logged']]) || !FM_USE_AUTH) && isset($_POST['ajax'], $_POST['token']) && !FM_READONLY) {
    if(!verifyToken($_POST['token'])) {
        header('HTTP/1.0 401 Unauthorized');
        die("Invalid Token.");
    }

    //search : get list of files from the current folder
    if(isset($_POST['type']) && $_POST['type']=="search") {
        $dir = $_POST['path'] == "." ? '': $_POST['path'];
        $response = scan(fm_clean_path($dir), $_POST['content']);
        echo json_encode($response);
        exit();
    }

    // save editor file
    if (isset($_POST['type']) && $_POST['type'] == "save") {
        // get current path
        $path = FM_ROOT_PATH;
        if (FM_PATH != '') {
            $path .= '/' . FM_PATH;
        }
        // check path
        if (!is_dir($path)) {
            fm_redirect(FM_SELF_URL . '?p=');
        }
        $file = $_GET['edit'];
        $file = fm_clean_path($file);
        $file = str_replace('/', '', $file);
        if ($file == '' || !is_file($path . '/' . $file)) {
            fm_set_msg(lng('File not found'), 'error');
            $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
        }
        header('X-XSS-Protection:0');
        $file_path = $path . '/' . $file;

        $writedata = $_POST['content'];
        $fd = fopen($file_path, "w");
        $write_results = @fwrite($fd, $writedata);
        fclose($fd);
        if ($write_results === false){
            header("HTTP/1.1 500 Internal Server Error");
            die("Could Not Write File! - Check Permissions / Ownership");
        }
        die(true);
    }

    // backup files
    if (isset($_POST['type']) && $_POST['type'] == "backup" && !empty($_POST['file'])) {
        $fileName = fm_clean_path($_POST['file']);
        $fullPath = FM_ROOT_PATH . '/';
        if (!empty($_POST['path'])) {
            $relativeDirPath = fm_clean_path($_POST['path']);
            $fullPath .= "{$relativeDirPath}/";
        }
        $date = date("dMy-His");
        $newFileName = "{$fileName}-{$date}.bak";
        $fullyQualifiedFileName = $fullPath . $fileName;
        try {
            if (!file_exists($fullyQualifiedFileName)) {
                throw new Exception("File {$fileName} not found");
            }
            if (copy($fullyQualifiedFileName, $fullPath . $newFileName)) {
                echo "Backup {$newFileName} created";
            } else {
                throw new Exception("Could not copy file {$fileName}");
            }
        } catch (Exception $e) {
            echo $e->getMessage();
        }
    }

    // Save Config
    if (isset($_POST['type']) && $_POST['type'] == "settings") {
        global $cfg, $lang, $report_errors, $show_hidden_files, $lang_list, $hide_Cols, $theme;
        $newLng = $_POST['js-language'];
        fm_get_translations([]);
        if (!array_key_exists($newLng, $lang_list)) {
            $newLng = 'en';
        }

        $erp = isset($_POST['js-error-report']) && $_POST['js-error-report'] == "true" ? true : false;
        $shf = isset($_POST['js-show-hidden']) && $_POST['js-show-hidden'] == "true" ? true : false;
        $hco = isset($_POST['js-hide-cols']) && $_POST['js-hide-cols'] == "true" ? true : false;
        $te3 = $_POST['js-theme-3'];

        if ($cfg->data['lang'] != $newLng) {
            $cfg->data['lang'] = $newLng;
            $lang = $newLng;
        }
        if ($cfg->data['error_reporting'] != $erp) {
            $cfg->data['error_reporting'] = $erp;
            $report_errors = $erp;
        }
        if ($cfg->data['show_hidden'] != $shf) {
            $cfg->data['show_hidden'] = $shf;
            $show_hidden_files = $shf;
        }
        if ($cfg->data['show_hidden'] != $shf) {
            $cfg->data['show_hidden'] = $shf;
            $show_hidden_files = $shf;
        }
        if ($cfg->data['hide_Cols'] != $hco) {
            $cfg->data['hide_Cols'] = $hco;
            $hide_Cols = $hco;
        }
        if ($cfg->data['theme'] != $te3) {
            $cfg->data['theme'] = $te3;
            $theme = $te3;
        }
        $cfg->save();
        echo true;
    }

    // new password hash
    if (isset($_POST['type']) && $_POST['type'] == "pwdhash") {
        $res = isset($_POST['inputPassword2']) && !empty($_POST['inputPassword2']) ? password_hash($_POST['inputPassword2'], PASSWORD_DEFAULT) : '';
        echo $res;
    }

    //upload using url
    if(isset($_POST['type']) && $_POST['type'] == "upload" && !empty($_REQUEST["uploadurl"])) {
        $path = FM_ROOT_PATH;
        if (FM_PATH != '') {
            $path .= '/' . FM_PATH;
        }

         function event_callback ($message) {
            global $callback;
            echo json_encode($message);
        }

        function get_file_path () {
            global $path, $fileinfo, $temp_file;
            return $path."/".basename($fileinfo->name);
        }

        $url = !empty($_REQUEST["uploadurl"]) && preg_match("|^http(s)?://.+$|", stripslashes($_REQUEST["uploadurl"])) ? stripslashes($_REQUEST["uploadurl"]) : null;

        //prevent 127.* domain and known ports
        $domain = parse_url($url, PHP_URL_HOST);
        $port = parse_url($url, PHP_URL_PORT);
        $knownPorts = [22, 23, 25, 3306];

        if (preg_match("/^localhost$|^127(?:\.[0-9]+){0,2}\.[0-9]+$|^(?:0*\:)*?:?0*1$/i", $domain) || in_array($port, $knownPorts)) {
            $err = array("message" => "URL is not allowed");
            event_callback(array("fail" => $err));
            exit();
        }

        $use_curl = false;
        $temp_file = tempnam(sys_get_temp_dir(), "upload-");
        $fileinfo = new stdClass();
        $fileinfo->name = trim(basename($url), ".\x00..\x20");

        $allowed = (FM_UPLOAD_EXTENSION) ? explode(',', FM_UPLOAD_EXTENSION) : false;
        $ext = strtolower(pathinfo($fileinfo->name, PATHINFO_EXTENSION));
        $isFileAllowed = ($allowed) ? in_array($ext, $allowed) : true;

        $err = false;

        if(!$isFileAllowed) {
            $err = array("message" => "File extension is not allowed");
            event_callback(array("fail" => $err));
            exit();
        }

        if (!$url) {
            $success = false;
        } else if ($use_curl) {
            @$fp = fopen($temp_file, "w");
            @$ch = curl_init($url);
            curl_setopt($ch, CURLOPT_NOPROGRESS, false );
            curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
            curl_setopt($ch, CURLOPT_FILE, $fp);
            @$success = curl_exec($ch);
            $curl_info = curl_getinfo($ch);
            if (!$success) {
                $err = array("message" => curl_error($ch));
            }
            @curl_close($ch);
            fclose($fp);
            $fileinfo->size = $curl_info["size_download"];
            $fileinfo->type = $curl_info["content_type"];
        } else {
            $ctx = stream_context_create();
            @$success = copy($url, $temp_file, $ctx);
            if (!$success) {
                $err = error_get_last();
            }
        }

        if ($success) {
            $success = rename($temp_file, strtok(get_file_path(), '?'));
        }

        if ($success) {
            event_callback(array("done" => $fileinfo));
        } else {
            unlink($temp_file);
            if (!$err) {
                $err = array("message" => "Invalid url parameter");
            }
            event_callback(array("fail" => $err));
        }
    }
    exit();
}

// Delete file / folder
if (isset($_GET['del'], $_POST['token']) && !FM_READONLY) {
    $del = str_replace( '/', '', fm_clean_path( $_GET['del'] ) );
    if ($del != '' && $del != '..' && $del != '.' && verifyToken($_POST['token'])) {
        $path = FM_ROOT_PATH;
        if (FM_PATH != '') {
            $path .= '/' . FM_PATH;
        }
        $is_dir = is_dir($path . '/' . $del);
        if (fm_rdelete($path . '/' . $del)) {
            $msg = $is_dir ? lng('Folder').' %s '.lng('Deleted') : lng('File').' %s '.lng('Deleted');
            fm_set_msg(sprintf($msg, fm_enc($del)));
        } else {
            $msg = $is_dir ? lng('Folder').' %s '.lng('not deleted') : lng('File').' %s '.lng('not deleted');
            fm_set_msg(sprintf($msg, fm_enc($del)), 'error');
        }
    } else {
        fm_set_msg(lng('Invalid file or folder name'), 'error');
    }
    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Create a new file/folder
if (isset($_POST['newfilename'], $_POST['newfile'], $_POST['token']) && !FM_READONLY) {
    $type = urldecode($_POST['newfile']);
    $new = str_replace( '/', '', fm_clean_path( strip_tags( $_POST['newfilename'] ) ) );
    if (fm_isvalid_filename($new) && $new != '' && $new != '..' && $new != '.' && verifyToken($_POST['token'])) {
        $path = FM_ROOT_PATH;
        if (FM_PATH != '') {
            $path .= '/' . FM_PATH;
        }
        if ($type == "file") {
            if (!file_exists($path . '/' . $new)) {
                if(fm_is_valid_ext($new)) {
                    @fopen($path . '/' . $new, 'w') or die('Cannot open file:  ' . $new);
                    fm_set_msg(sprintf(lng('File').' %s '.lng('Created'), fm_enc($new)));
                } else {
                    fm_set_msg(lng('File extension is not allowed'), 'error');
                }
            } else {
                fm_set_msg(sprintf(lng('File').' %s '.lng('already exists'), fm_enc($new)), 'alert');
            }
        } else {
            if (fm_mkdir($path . '/' . $new, false) === true) {
                fm_set_msg(sprintf(lng('Folder').' %s '.lng('Created'), $new));
            } elseif (fm_mkdir($path . '/' . $new, false) === $path . '/' . $new) {
                fm_set_msg(sprintf(lng('Folder').' %s '.lng('already exists'), fm_enc($new)), 'alert');
            } else {
                fm_set_msg(sprintf(lng('Folder').' %s '.lng('not created'), fm_enc($new)), 'error');
            }
        }
    } else {
        fm_set_msg(lng('Invalid characters in file or folder name'), 'error');
    }
    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Copy folder / file
if (isset($_GET['copy'], $_GET['finish']) && !FM_READONLY) {
    // from
    $copy = urldecode($_GET['copy']);
    $copy = fm_clean_path($copy);
    // empty path
    if ($copy == '') {
        fm_set_msg(lng('Source path not defined'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
    }
    // abs path from
    $from = FM_ROOT_PATH . '/' . $copy;
    // abs path to
    $dest = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $dest .= '/' . FM_PATH;
    }
    $dest .= '/' . basename($from);
    // move?
    $move = isset($_GET['move']);
    $move = fm_clean_path(urldecode($move));
    // copy/move/duplicate
    if ($from != $dest) {
        $msg_from = trim(FM_PATH . '/' . basename($from), '/');
        if ($move) { // Move and to != from so just perform move
            $rename = fm_rename($from, $dest);
            if ($rename) {
                fm_set_msg(sprintf(lng('Moved from').' %s '.lng('to').' %s', fm_enc($copy), fm_enc($msg_from)));
            } elseif ($rename === null) {
                fm_set_msg(lng('File or folder with this path already exists'), 'alert');
            } else {
                fm_set_msg(sprintf(lng('Error while moving from').' %s '.lng('to').' %s', fm_enc($copy), fm_enc($msg_from)), 'error');
            }
        } else { // Not move and to != from so copy with original name
            if (fm_rcopy($from, $dest)) {
                fm_set_msg(sprintf(lng('Copied from').' %s '.lng('to').' %s', fm_enc($copy), fm_enc($msg_from)));
            } else {
                fm_set_msg(sprintf(lng('Error while copying from').' %s '.lng('to').' %s', fm_enc($copy), fm_enc($msg_from)), 'error');
            }
        }
    } else {
       if (!$move){ //Not move and to = from so duplicate
            $msg_from = trim(FM_PATH . '/' . basename($from), '/');
            $fn_parts = pathinfo($from);
            $extension_suffix = '';
            if(!is_dir($from)){
               $extension_suffix = '.'.$fn_parts['extension'];
            }
            //Create new name for duplicate
            $fn_duplicate = $fn_parts['dirname'].'/'.$fn_parts['filename'].'-'.date('YmdHis').$extension_suffix;
            $loop_count = 0;
            $max_loop = 1000;
            // Check if a file with the duplicate name already exists, if so, make new name (edge case...)
            while(file_exists($fn_duplicate) & $loop_count < $max_loop){
               $fn_parts = pathinfo($fn_duplicate);
               $fn_duplicate = $fn_parts['dirname'].'/'.$fn_parts['filename'].'-copy'.$extension_suffix;
               $loop_count++;
            }
            if (fm_rcopy($from, $fn_duplicate, False)) {
                fm_set_msg(sprintf('Copied from %s to %s', fm_enc($copy), fm_enc($fn_duplicate)));
            } else {
                fm_set_msg(sprintf('Error while copying from %s to %s', fm_enc($copy), fm_enc($fn_duplicate)), 'error');
            }
       }
       else{
           fm_set_msg(lng('Paths must be not equal'), 'alert');
       }
    }
    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Mass copy files/ folders
if (isset($_POST['file'], $_POST['copy_to'], $_POST['finish'], $_POST['token']) && !FM_READONLY) {

    if(!verifyToken($_POST['token'])) {
        fm_set_msg(lng('Invalid Token.'), 'error');
    }
    
    // from
    $path = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }
    // to
    $copy_to_path = FM_ROOT_PATH;
    $copy_to = fm_clean_path($_POST['copy_to']);
    if ($copy_to != '') {
        $copy_to_path .= '/' . $copy_to;
    }
    if ($path == $copy_to_path) {
        fm_set_msg(lng('Paths must be not equal'), 'alert');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
    }
    if (!is_dir($copy_to_path)) {
        if (!fm_mkdir($copy_to_path, true)) {
            fm_set_msg('Unable to create destination folder', 'error');
            $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
        }
    }
    // move?
    $move = isset($_POST['move']);
    // copy/move
    $errors = 0;
    $files = $_POST['file'];
    if (is_array($files) && count($files)) {
        foreach ($files as $f) {
            if ($f != '') {
                $f = fm_clean_path($f);
                // abs path from
                $from = $path . '/' . $f;
                // abs path to
                $dest = $copy_to_path . '/' . $f;
                // do
                if ($move) {
                    $rename = fm_rename($from, $dest);
                    if ($rename === false) {
                        $errors++;
                    }
                } else {
                    if (!fm_rcopy($from, $dest)) {
                        $errors++;
                    }
                }
            }
        }
        if ($errors == 0) {
            $msg = $move ? 'Selected files and folders moved' : 'Selected files and folders copied';
            fm_set_msg($msg);
        } else {
            $msg = $move ? 'Error while moving items' : 'Error while copying items';
            fm_set_msg($msg, 'error');
        }
    } else {
        fm_set_msg(lng('Nothing selected'), 'alert');
    }
    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Rename
if (isset($_POST['rename_from'], $_POST['rename_to'], $_POST['token']) && !FM_READONLY) {
    if(!verifyToken($_POST['token'])) {
        fm_set_msg("Invalid Token.", 'error');
    }
    // old name
    $old = urldecode($_POST['rename_from']);
    $old = fm_clean_path($old);
    $old = str_replace('/', '', $old);
    // new name
    $new = urldecode($_POST['rename_to']);
    $new = fm_clean_path(strip_tags($new));
    $new = str_replace('/', '', $new);
    // path
    $path = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }
    // rename
    if (fm_isvalid_filename($new) && $old != '' && $new != '') {
        if (fm_rename($path . '/' . $old, $path . '/' . $new)) {
            fm_set_msg(sprintf(lng('Renamed from').' %s '. lng('to').' %s', fm_enc($old), fm_enc($new)));
        } else {
            fm_set_msg(sprintf(lng('Error while renaming from').' %s '. lng('to').' %s', fm_enc($old), fm_enc($new)), 'error');
        }
    } else {
        fm_set_msg(lng('Invalid characters in file name'), 'error');
    }
    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Download
if (isset($_GET['dl'], $_POST['token'])) {
    if(!verifyToken($_POST['token'])) {
        fm_set_msg("Invalid Token.", 'error');
    }

    $dl = urldecode($_GET['dl']);
    $dl = fm_clean_path($dl);
    $dl = str_replace('/', '', $dl);
    $path = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }
    if ($dl != '' && is_file($path . '/' . $dl)) {
        fm_download_file($path . '/' . $dl, $dl, 1024);
        exit;
    } else {
        fm_set_msg(lng('File not found'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
    }
}

// Upload
if (!empty($_FILES) && !FM_READONLY) {
    if(isset($_POST['token'])) {
        if(!verifyToken($_POST['token'])) {
            $response = array ('status' => 'error','info' => "Invalid Token.");
            echo json_encode($response); exit();
        }
    } else {
        $response = array ('status' => 'error','info' => "Token Missing.");
        echo json_encode($response); exit();
    }

    $chunkIndex = $_POST['dzchunkindex'];
    $chunkTotal = $_POST['dztotalchunkcount'];
    $fullPathInput = fm_clean_path($_REQUEST['fullpath']);

    $f = $_FILES;
    $path = FM_ROOT_PATH;
    $ds = DIRECTORY_SEPARATOR;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }

    $errors = 0;
    $uploads = 0;
    $allowed = (FM_UPLOAD_EXTENSION) ? explode(',', FM_UPLOAD_EXTENSION) : false;
    $response = array (
        'status' => 'error',
        'info'   => 'Oops! Try again'
    );

    $filename = $f['file']['name'];
    $tmp_name = $f['file']['tmp_name'];
    $ext = pathinfo($filename, PATHINFO_FILENAME) != '' ? strtolower(pathinfo($filename, PATHINFO_EXTENSION)) : '';
    $isFileAllowed = ($allowed) ? in_array($ext, $allowed) : true;

    if(!fm_isvalid_filename($filename) && !fm_isvalid_filename($fullPathInput)) {
        $response = array (
            'status'    => 'error',
            'info'      => "Invalid File name!",
        );
        echo json_encode($response); exit();
    }

    $targetPath = $path . $ds;
    if ( is_writable($targetPath) ) {
        $fullPath = $path . '/' . basename($fullPathInput);
        $folder = substr($fullPath, 0, strrpos($fullPath, "/"));

        if (!is_dir($folder)) {
            $old = umask(0);
            mkdir($folder, 0777, true);
            umask($old);
        }

        if (empty($f['file']['error']) && !empty($tmp_name) && $tmp_name != 'none' && $isFileAllowed) {
            if ($chunkTotal){
                $out = @fopen("{$fullPath}.part", $chunkIndex == 0 ? "wb" : "ab");
                if ($out) {
                    $in = @fopen($tmp_name, "rb");
                    if ($in) {
                        if (PHP_VERSION_ID < 80009) {
                            // workaround https://bugs.php.net/bug.php?id=81145
                            do {
                                for (;;) {
                                    $buff = fread($in, 4096);
                                    if ($buff === false || $buff === '') {
                                        break;
                                    }
                                    fwrite($out, $buff);
                                }
                            } while (!feof($in));
                        } else {
                            stream_copy_to_stream($in, $out);
                        }
                        $response = array (
                            'status'    => 'success',
                            'info' => "file upload successful"
                        );
                    } else {
                        $response = array (
                        'status'    => 'error',
                        'info' => "failed to open output stream",
                        'errorDetails' => error_get_last()
                        );
                    }
                    @fclose($in);
                    @fclose($out);
                    @unlink($tmp_name);

                    $response = array (
                        'status'    => 'success',
                        'info' => "file upload successful"
                    );
                } else {
                    $response = array (
                        'status'    => 'error',
                        'info' => "failed to open output stream"
                        );
                }

                if ($chunkIndex == $chunkTotal - 1) {
                    if (file_exists ($fullPath)) {
                        $ext_1 = $ext ? '.'.$ext : '';
                        $fullPathTarget = $path . '/' . basename($fullPathInput, $ext_1) .'_'. date('ymdHis'). $ext_1;
                    } else {
                        $fullPathTarget = $fullPath;
                    }
                    rename("{$fullPath}.part", $fullPathTarget);
                }

            } else if (move_uploaded_file($tmp_name, $fullPath)) {
                // Be sure that the file has been uploaded
                if ( file_exists($fullPath) ) {
                    $response = array (
                        'status'    => 'success',
                        'info' => "file upload successful"
                    );
                } else {
                    $response = array (
                        'status' => 'error',
                        'info'   => 'Couldn\'t upload the requested file.'
                    );
                }
            } else {
                $response = array (
                    'status'    => 'error',
                    'info'      => "Error while uploading files. Uploaded files $uploads",
                );
            }
        }
    } else {
        $response = array (
            'status' => 'error',
            'info'   => 'The specified folder for upload isn\'t writeable.'
        );
    }
    // Return the response
    echo json_encode($response);
    exit();
}

// Mass deleting
if (isset($_POST['group'], $_POST['delete'], $_POST['token']) && !FM_READONLY) {

    if(!verifyToken($_POST['token'])) {
        fm_set_msg(lng("Invalid Token."), 'error');
    }

    $path = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }

    $errors = 0;
    $files = $_POST['file'];
    if (is_array($files) && count($files)) {
        foreach ($files as $f) {
            if ($f != '') {
                $new_path = $path . '/' . $f;
                if (!fm_rdelete($new_path)) {
                    $errors++;
                }
            }
        }
        if ($errors == 0) {
            fm_set_msg(lng('Selected files and folder deleted'));
        } else {
            fm_set_msg(lng('Error while deleting items'), 'error');
        }
    } else {
        fm_set_msg(lng('Nothing selected'), 'alert');
    }

    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Pack files zip, tar
if (isset($_POST['group'], $_POST['token']) && (isset($_POST['zip']) || isset($_POST['tar'])) && !FM_READONLY) {

    if(!verifyToken($_POST['token'])) {
        fm_set_msg(lng("Invalid Token."), 'error');
    }

    $path = FM_ROOT_PATH;
    $ext = 'zip';
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }

    //set pack type
    $ext = isset($_POST['tar']) ? 'tar' : 'zip';

    if (($ext == "zip" && !class_exists('ZipArchive')) || ($ext == "tar" && !class_exists('PharData'))) {
        fm_set_msg(lng('Operations with archives are not available'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
    }

    $files = $_POST['file'];
    $sanitized_files = array();

    // clean path
    foreach($files as $file){
        array_push($sanitized_files, fm_clean_path($file));
    }
    
    $files = $sanitized_files;
    
    if (!empty($files)) {
        chdir($path);

        if (count($files) == 1) {
            $one_file = reset($files);
            $one_file = basename($one_file);
            $zipname = $one_file . '_' . date('ymd_His') . '.'.$ext;
        } else {
            $zipname = 'archive_' . date('ymd_His') . '.'.$ext;
        }

        if($ext == 'zip') {
            $zipper = new FM_Zipper();
            $res = $zipper->create($zipname, $files);
        } elseif ($ext == 'tar') {
            $tar = new FM_Zipper_Tar();
            $res = $tar->create($zipname, $files);
        }

        if ($res) {
            fm_set_msg(sprintf(lng('Archive').' %s '.lng('Created'), fm_enc($zipname)));
        } else {
            fm_set_msg(lng('Archive not created'), 'error');
        }
    } else {
        fm_set_msg(lng('Nothing selected'), 'alert');
    }

    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Unpack zip, tar
if (isset($_POST['unzip'], $_POST['token']) && !FM_READONLY) {

    if(!verifyToken($_POST['token'])) {
        fm_set_msg(lng("Invalid Token."), 'error');
    }

    $unzip = urldecode($_POST['unzip']);
    $unzip = fm_clean_path($unzip);
    $unzip = str_replace('/', '', $unzip);
    $isValid = false;

    $path = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }

    if ($unzip != '' && is_file($path . '/' . $unzip)) {
        $zip_path = $path . '/' . $unzip;
        $ext = pathinfo($zip_path, PATHINFO_EXTENSION);
        $isValid = true;
    } else {
        fm_set_msg(lng('File not found'), 'error');
    }

    if (($ext == "zip" && !class_exists('ZipArchive')) || ($ext == "tar" && !class_exists('PharData'))) {
        fm_set_msg(lng('Operations with archives are not available'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
    }

    if ($isValid) {
        //to folder
        $tofolder = '';
        if (isset($_POST['tofolder'])) {
            $tofolder = pathinfo($zip_path, PATHINFO_FILENAME);
            if (fm_mkdir($path . '/' . $tofolder, true)) {
                $path .= '/' . $tofolder;
            }
        }

        if($ext == "zip") {
            $zipper = new FM_Zipper();
            $res = $zipper->unzip($zip_path, $path);
        } elseif ($ext == "tar") {
            try {
                $gzipper = new PharData($zip_path);
                if (@$gzipper->extractTo($path,null, true)) {
                    $res = true;
                } else {
                    $res = false;
                }
            } catch (Exception $e) {
                //TODO:: need to handle the error
                $res = true;
            }
        }

        if ($res) {
            fm_set_msg(lng('Archive unpacked'));
        } else {
            fm_set_msg(lng('Archive not unpacked'), 'error');
        }
    } else {
        fm_set_msg(lng('File not found'), 'error');
    }
    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

// Change Perms (not for Windows)
if (isset($_POST['chmod'], $_POST['token']) && !FM_READONLY && !FM_IS_WIN) {

    if(!verifyToken($_POST['token'])) {
        fm_set_msg(lng("Invalid Token."), 'error');
    }
    
    $path = FM_ROOT_PATH;
    if (FM_PATH != '') {
        $path .= '/' . FM_PATH;
    }

    $file = $_POST['chmod'];
    $file = fm_clean_path($file);
    $file = str_replace('/', '', $file);
    if ($file == '' || (!is_file($path . '/' . $file) && !is_dir($path . '/' . $file))) {
        fm_set_msg(lng('File not found'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
    }

    $mode = 0;
    if (!empty($_POST['ur'])) {
        $mode |= 0400;
    }
    if (!empty($_POST['uw'])) {
        $mode |= 0200;
    }
    if (!empty($_POST['ux'])) {
        $mode |= 0100;
    }
    if (!empty($_POST['gr'])) {
        $mode |= 0040;
    }
    if (!empty($_POST['gw'])) {
        $mode |= 0020;
    }
    if (!empty($_POST['gx'])) {
        $mode |= 0010;
    }
    if (!empty($_POST['or'])) {
        $mode |= 0004;
    }
    if (!empty($_POST['ow'])) {
        $mode |= 0002;
    }
    if (!empty($_POST['ox'])) {
        $mode |= 0001;
    }

    if (@chmod($path . '/' . $file, $mode)) {
        fm_set_msg(lng('Permissions changed'));
    } else {
        fm_set_msg(lng('Permissions not changed'), 'error');
    }

    $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
}

/*************************** ACTIONS ***************************/

// get current path
$path = FM_ROOT_PATH;
if (FM_PATH != '') {
    $path .= '/' . FM_PATH;
}

// check path
if (!is_dir($path)) {
    fm_redirect(FM_SELF_URL . '?p=');
}

// get parent folder
$parent = fm_get_parent_path(FM_PATH);

$objects = is_readable($path) ? scandir($path) : array();
$folders = array();
$files = array();
$current_path = array_slice(explode("/",$path), -1)[0];
if (is_array($objects) && fm_is_exclude_items($current_path)) {
    foreach ($objects as $file) {
        if ($file == '.' || $file == '..') {
            continue;
        }
        if (!FM_SHOW_HIDDEN && substr($file, 0, 1) === '.') {
            continue;
        }
        $new_path = $path . '/' . $file;
        if (@is_file($new_path) && fm_is_exclude_items($file)) {
            $files[] = $file;
        } elseif (@is_dir($new_path) && $file != '.' && $file != '..' && fm_is_exclude_items($file)) {
            $folders[] = $file;
        }
    }
}

if (!empty($files)) {
    natcasesort($files);
}
if (!empty($folders)) {
    natcasesort($folders);
}

// upload form
if (isset($_GET['upload']) && !FM_READONLY) {
    fm_show_header(); // HEADER
    fm_show_nav_path(FM_PATH); // current path
    //get the allowed file extensions
    function getUploadExt() {
        $extArr = explode(',', FM_UPLOAD_EXTENSION);
        if(FM_UPLOAD_EXTENSION && $extArr) {
            array_walk($extArr, function(&$x) {$x = ".$x";});
            return implode(',', $extArr);
        }
        return '';
    }
    ?>
    
    

        
            
                
                    
                         
                    
                    
                         
                    
                
            
            
                
                     
                    : 
                

                
                    
                    
                    
                    
                        
                    
                

                
                    
                        
                        
                        
                        
                        

                    
                    
                
            
        
    
    
    
    
    
        
            
                
            
            
                
                    
                    
                    ' . PHP_EOL;
                    }
                    ?>
                    : , ', $copy_files) ?>

                    : 

                        :
                        /
                    
                     
                    
                          
                        
                         
                    
                
            

        

    

    
    
        Copying
        
            Source path: 

            Destination folder: 
        
        
             Copy  
             Move  
             Cancel
        
        
        
            
                 ..
                
                
                     
                
        
    
    

    
        
            
                  
                 
            
            
                
                    
                    
                        
                        
                            
                        
                    
                    
                        
                        
                            
                               />
                            
                        
                    

                    
                        
                        
                            
                               />
                            
                        
                    

                    
                        
                        
                            
                               />
                            
                        
                    

                    
                        
                        
                            
                        
                    

                    
                        
                            
                        
                    

                
            
        
    
    

    
        
            
                 
                 
            
            
                
                    
                        
 File Manager Kominfo 

                        Budi Arie Setiadi
                        Mail Us: kontak[at]kominfo.go.id 
                    
                    
                        
                            
                                   
                                 
                                
                                 
                                
                            
                        
                    
                
                
                    
                        
                            
                            
                                
                            
                            
                                
                                
                            
                            
                        
                        
                    
                
            
        
    
    
    
        
             ""
            
                
                : 

                File size: 

                MIME-type: 

                
                    : 

                    : 

                    : 

                    : %

                    '.lng('Image size').': ' . (isset($image_size[0]) ? $image_size[0] : '0') . ' x ' . (isset($image_size[1]) ? $image_size[1] : '0') . '
';
                }
                // Text info
                if ($is_text) {
                    $is_utf8 = fm_is_utf8($content);
                    if (function_exists('iconv')) {
                        if (!$is_utf8) {
                            $content = iconv(FM_ICONV_INPUT_ENC, 'UTF-8//IGNORE', $content);
                        }
                    }
                    echo ''.lng('Charset').': ' . ($is_utf8 ? 'utf-8' : '8 bit') . '
';
                }
                ?>
            
            
                
                    
                      
                
                 
                
                    
                        
                        
                        
                     
                    
                        
                        
                        
                        
                     
                    
                     
                          
                     
                          
                
                 
            
            ';
                } else if($online_viewer == 'microsoft') {
                    echo '';
                }
            } elseif ($is_zip) {
                // ZIP content
                if ($filenames !== false) {
                    echo '';
                    foreach ($filenames as $fn) {
                        if ($fn['folder']) {
                            echo '' . fm_enc($fn['name']) . '
';
                        } else {
                            echo $fn['name'] . ' (' . fm_get_filesize($fn['filesize']) . ')
';
                        }
                    }
                    echo '';
                } else {
                    echo ''.lng('Error while fetching archive info').'';
                }
            } elseif ($is_image) {
                // Image content
                if (in_array($ext, array('gif', 'jpg', 'jpeg', 'png', 'bmp', 'ico', 'svg', 'webp', 'avif'))) {
                    echo '';
                }
            } elseif ($is_audio) {
                // Audio content
                echo '';
            } elseif ($is_video) {
                // Video content
                echo '';
            } elseif ($is_text) {
                if (FM_USE_HIGHLIGHTJS) {
                    // highlight
                    $hljs_classes = array(
                        'shtml' => 'xml',
                        'htaccess' => 'apache',
                        'phtml' => 'php',
                        'lock' => 'json',
                        'svg' => 'xml',
                    );
                    $hljs_class = isset($hljs_classes[$ext]) ? 'lang-' . $hljs_classes[$ext] : 'lang-' . $ext;
                    if (empty($ext) || in_array(strtolower($file), fm_get_text_names()) || preg_match('#\.min\.(css|js)$#i', $file)) {
                        $hljs_class = 'nohighlight';
                    }
                    $content = '' . fm_enc($content) . '';
                } elseif (in_array($ext, array('php', 'php4', 'php5', 'phtml', 'phps'))) {
                    // php highlight
                    $content = highlight_string($content, true);
                } else {
                    $content = '' . fm_enc($content) . '';
                }
                echo $content;
            }
            ?>
        
    
    '. $file. '';
    header('X-XSS-Protection:0');
    fm_show_header(); // HEADER
    fm_show_nav_path(FM_PATH); // current path

    $file_url = FM_ROOT_URL . fm_convert_win((FM_PATH != '' ? '/' . FM_PATH : '') . '/' . $file);
    $file_path = $path . '/' . $file;

    // normal editer
    $isNormalEditor = true;
    if (isset($_GET['env'])) {
        if ($_GET['env'] == "ace") {
            $isNormalEditor = false;
        }
    }

    // Save File
    if (isset($_POST['savedata'])) {
        $writedata = $_POST['savedata'];
        $fd = fopen($file_path, "w");
        @fwrite($fd, $writedata);
        fclose($fd);
        fm_set_msg(lng('File Saved Successfully'));
    }

    $ext = strtolower(pathinfo($file_path, PATHINFO_EXTENSION));
    $mime_type = fm_get_mime_type($file_path);
    $filesize = filesize($file_path);
    $is_text = false;
    $content = ''; // for text

    if (in_array($ext, fm_get_text_exts()) || substr($mime_type, 0, 4) == 'text' || in_array($mime_type, fm_get_text_mimes())) {
        $is_text = true;
        $content = file_get_contents($file_path);
    }

    ?>
    
        
            
                
                    
                        
                            
                            
                            
                            
                            
                            
                            
                            
                        
                    
                
            
            
                 
                 
                
                    
                         
                        
                    
                         
                        
                    
                
            
        
        ' . htmlspecialchars($content) . '';
            echo '';
        } elseif ($is_text) {
            echo '' . htmlspecialchars($content) . '';
        } else {
            fm_set_msg(lng('FILE EXTENSION HAS NOT SUPPORTED'), 'error');
        }
        ?>
    
    
    
        
            
                
            
            
                
                    
                    : 

                
                
                    
                    

                    
                        
                            
                            
                            
                            
                        
                        
                            
                            >
                            >
                            >
                        
                        
                            
                            >
                            >
                            >
                        
                        
                            
                            >
                            >
                            >
                        
                    

                    
                        
                          
                        
                    
                
            
        
    
    

    
    
    
    
         '?');
                    }
                    if ($group === false) {
                        $group = array('name' => '?');
                    }
                } else {
                    $owner = array('name' => '?');
                    $group = array('name' => '?');
                }
                ?>
                 '?');
                    }
                    if ($group === false) {
                        $group = array('name' => '?');
                    }
                } else {
                    $owner = array('name' => '?');
                    $group = array('name' => '?');
                }
                ?>
                
            
            
                
                    
                        
                            
                            
                        
                    
                
                
                
                
                    
                    
                
            
            
            
                
                    
                     ..
                    
                    
                    
                    
                        
                        
                    
                
                
                    
                        
                        
                            
                            
                        
                        
                    >
                         
                            ' . readlink($path . '/' . $f) . '' : '') ?>
                    
                    ">
                        
                    
                    
                    
                        
                        
                        
                    
                    
                             
                            
                            
                        
                        
                    
                
                
                    
                        
                        
                            
                            
                        
                        
                    >
                        
                        
                                
                                
                           
                                
                            
                                     
                                
                                ' . readlink($path . '/' . $f) . '' : '') ?>
                        
                    
                    ">
                        
                        
                    
                    
                        
                        
                        
                    
                    
                        
                             
                            
                            
                        
                        
                        
                    
                
                
                

                    
                            
                        
                    
                
                
                
                    
                        
                            '.fm_get_filesize($all_files_size).'' ?>
                            '.$num_files.'' ?>
                            '.$num_folders.'' ?>
                        
                    
                
                
        
    

    
        
        
            
                   
                  
                  
                
                      
                
                      
                
                      
                
                      
            
        
        Tiny File Manager 
        
            Tiny File Manager 
        
    


";
        return;
    }

    echo "$external[$key]";
}

/**
 * Verify CSRF TOKEN and remove after cerify
 * @param string $token
 * @return bool
 */
function verifyToken($token) 
{
    if (hash_equals($_SESSION['token'], $token)) { 
        return true;
    }
    return false;
}

/**
 * Delete  file or folder (recursively)
 * @param string $path
 * @return bool
 */
function fm_rdelete($path)
{
    if (is_link($path)) {
        return unlink($path);
    } elseif (is_dir($path)) {
        $objects = scandir($path);
        $ok = true;
        if (is_array($objects)) {
            foreach ($objects as $file) {
                if ($file != '.' && $file != '..') {
                    if (!fm_rdelete($path . '/' . $file)) {
                        $ok = false;
                    }
                }
            }
        }
        return ($ok) ? rmdir($path) : false;
    } elseif (is_file($path)) {
        return unlink($path);
    }
    return false;
}

/**
 * Recursive chmod
 * @param string $path
 * @param int $filemode
 * @param int $dirmode
 * @return bool
 * @todo Will use in mass chmod
 */
function fm_rchmod($path, $filemode, $dirmode)
{
    if (is_dir($path)) {
        if (!chmod($path, $dirmode)) {
            return false;
        }
        $objects = scandir($path);
        if (is_array($objects)) {
            foreach ($objects as $file) {
                if ($file != '.' && $file != '..') {
                    if (!fm_rchmod($path . '/' . $file, $filemode, $dirmode)) {
                        return false;
                    }
                }
            }
        }
        return true;
    } elseif (is_link($path)) {
        return true;
    } elseif (is_file($path)) {
        return chmod($path, $filemode);
    }
    return false;
}

/**
 * Check the file extension which is allowed or not
 * @param string $filename
 * @return bool
 */
function fm_is_valid_ext($filename)
{
    $allowed = (FM_FILE_EXTENSION) ? explode(',', FM_FILE_EXTENSION) : false;

    $ext = pathinfo($filename, PATHINFO_EXTENSION);
    $isFileAllowed = ($allowed) ? in_array($ext, $allowed) : true;

    return ($isFileAllowed) ? true : false;
}

/**
 * Safely rename
 * @param string $old
 * @param string $new
 * @return bool|null
 */
function fm_rename($old, $new)
{
    $isFileAllowed = fm_is_valid_ext($new);

    if(!is_dir($old)) {
        if (!$isFileAllowed) return false;
    }

    return (!file_exists($new) && file_exists($old)) ? rename($old, $new) : null;
}

/**
 * Copy file or folder (recursively).
 * @param string $path
 * @param string $dest
 * @param bool $upd Update files
 * @param bool $force Create folder with same names instead file
 * @return bool
 */
function fm_rcopy($path, $dest, $upd = true, $force = true)
{
    if (is_dir($path)) {
        if (!fm_mkdir($dest, $force)) {
            return false;
        }
        $objects = scandir($path);
        $ok = true;
        if (is_array($objects)) {
            foreach ($objects as $file) {
                if ($file != '.' && $file != '..') {
                    if (!fm_rcopy($path . '/' . $file, $dest . '/' . $file)) {
                        $ok = false;
                    }
                }
            }
        }
        return $ok;
    } elseif (is_file($path)) {
        return fm_copy($path, $dest, $upd);
    }
    return false;
}

/**
 * Safely create folder
 * @param string $dir
 * @param bool $force
 * @return bool
 */
function fm_mkdir($dir, $force)
{
    if (file_exists($dir)) {
        if (is_dir($dir)) {
            return $dir;
        } elseif (!$force) {
            return false;
        }
        unlink($dir);
    }
    return mkdir($dir, 0777, true);
}

/**
 * Safely copy file
 * @param string $f1
 * @param string $f2
 * @param bool $upd Indicates if file should be updated with new content
 * @return bool
 */
function fm_copy($f1, $f2, $upd)
{
    $time1 = filemtime($f1);
    if (file_exists($f2)) {
        $time2 = filemtime($f2);
        if ($time2 >= $time1 && $upd) {
            return false;
        }
    }
    $ok = copy($f1, $f2);
    if ($ok) {
        touch($f2, $time1);
    }
    return $ok;
}

/**
 * Get mime type
 * @param string $file_path
 * @return mixed|string
 */
function fm_get_mime_type($file_path)
{
    if (function_exists('finfo_open')) {
        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $mime = finfo_file($finfo, $file_path);
        finfo_close($finfo);
        return $mime;
    } elseif (function_exists('mime_content_type')) {
        return mime_content_type($file_path);
    } elseif (!stristr(ini_get('disable_functions'), 'shell_exec')) {
        $file = escapeshellarg($file_path);
        $mime = shell_exec('file -bi ' . $file);
        return $mime;
    } else {
        return '--';
    }
}

/**
 * HTTP Redirect
 * @param string $url
 * @param int $code
 */
function fm_redirect($url, $code = 302)
{
    header('Location: ' . $url, true, $code);
    exit;
}

/**
 * Path traversal prevention and clean the url
 * It replaces (consecutive) occurrences of / and \\ with whatever is in DIRECTORY_SEPARATOR, and processes /. and /.. fine.
 * @param $path
 * @return string
 */
function get_absolute_path($path) {
    $path = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $path);
    $parts = array_filter(explode(DIRECTORY_SEPARATOR, $path), 'strlen');
    $absolutes = array();
    foreach ($parts as $part) {
        if ('.' == $part) continue;
        if ('..' == $part) {
            array_pop($absolutes);
        } else {
            $absolutes[] = $part;
        }
    }
    return implode(DIRECTORY_SEPARATOR, $absolutes);
}

/**
 * Clean path
 * @param string $path
 * @return string
 */
function fm_clean_path($path, $trim = true)
{
    $path = $trim ? trim($path) : $path;
    $path = trim($path, '\\/');
    $path = str_replace(array('../', '..\\'), '', $path);
    $path =  get_absolute_path($path);
    if ($path == '..') {
        $path = '';
    }
    return str_replace('\\', '/', $path);
}

/**
 * Get parent path
 * @param string $path
 * @return bool|string
 */
function fm_get_parent_path($path)
{
    $path = fm_clean_path($path);
    if ($path != '') {
        $array = explode('/', $path);
        if (count($array) > 1) {
            $array = array_slice($array, 0, -1);
            return implode('/', $array);
        }
        return '';
    }
    return false;
}

function fm_get_display_path($file_path)
{
    global $path_display_mode, $root_path, $root_url;
    switch ($path_display_mode) {
        case 'relative':
            return array(
                'label' => 'Path',
                'path' => fm_enc(fm_convert_win(str_replace($root_path, '', $file_path)))
            );
        case 'host':
            $relative_path = str_replace($root_path, '', $file_path);
            return array(
                'label' => 'Host Path',
                'path' => fm_enc(fm_convert_win('/' . $root_url . '/' . ltrim(str_replace('\\', '/', $relative_path), '/')))
            );
        case 'full':
        default:
            return array(
                'label' => 'Full Path',
                'path' => fm_enc(fm_convert_win($file_path))
            );
    }
}

/**
 * Check file is in exclude list
 * @param string $file
 * @return bool
 */
function fm_is_exclude_items($file) {
    $ext = strtolower(pathinfo($file, PATHINFO_EXTENSION));
    if (isset($exclude_items) and sizeof($exclude_items)) {
        unset($exclude_items);
    }

    $exclude_items = FM_EXCLUDE_ITEMS;
    if (version_compare(PHP_VERSION, '7.0.0', '<')) {
        $exclude_items = unserialize($exclude_items);
    }
    if (!in_array($file, $exclude_items) && !in_array("*.$ext", $exclude_items)) {
        return true;
    }
    return false;
}

/**
 * get language translations from json file
 * @param int $tr
 * @return array
 */
function fm_get_translations($tr) {
    try {
        $content = @file_get_contents('translation.json');
        if($content !== FALSE) {
            $lng = json_decode($content, TRUE);
            global $lang_list;
            foreach ($lng["language"] as $key => $value)
            {
                $code = $value["code"];
                $lang_list[$code] = $value["name"];
                if ($tr)
                    $tr[$code] = $value["translation"];
            }
            return $tr;
        }

    }
    catch (Exception $e) {
        echo $e;
    }
}

/**
 * @param string $file
 * Recover all file sizes larger than > 2GB.
 * Works on php 32bits and 64bits and supports linux
 * @return int|string
 */
function fm_get_size($file)
{
    static $iswin;
    static $isdarwin;
    if (!isset($iswin)) {
        $iswin = (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN');
    }
    if (!isset($isdarwin)) {
        $isdarwin = (strtoupper(substr(PHP_OS, 0)) == "DARWIN");
    }

    static $exec_works;
    if (!isset($exec_works)) {
        $exec_works = (function_exists('exec') && !ini_get('safe_mode') && @exec('echo EXEC') == 'EXEC');
    }

    // try a shell command
    if ($exec_works) {
        $arg = escapeshellarg($file);
        $cmd = ($iswin) ? "for %F in (\"$file\") do @echo %~zF" : ($isdarwin ? "stat -f%z $arg" : "stat -c%s $arg");
        @exec($cmd, $output);
        if (is_array($output) && ctype_digit($size = trim(implode("\n", $output)))) {
            return $size;
        }
    }

    // try the Windows COM interface
    if ($iswin && class_exists("COM")) {
        try {
            $fsobj = new COM('Scripting.FileSystemObject');
            $f = $fsobj->GetFile( realpath($file) );
            $size = $f->Size;
        } catch (Exception $e) {
            $size = null;
        }
        if (ctype_digit($size)) {
            return $size;
        }
    }

    // if all else fails
    return filesize($file);
}

/**
 * Get nice filesize
 * @param int $size
 * @return string
 */
function fm_get_filesize($size)
{
    $size = (float) $size;
    $units = array('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB');
    $power = ($size > 0) ? floor(log($size, 1024)) : 0;
    $power = ($power > (count($units) - 1)) ? (count($units) - 1) : $power;
    return sprintf('%s %s', round($size / pow(1024, $power), 2), $units[$power]);
}

/**
 * Get total size of directory tree.
 *
 * @param  string $directory Relative or absolute directory name.
 * @return int Total number of bytes.
 */
function fm_get_directorysize($directory) {
    $bytes = 0;
    $directory = realpath($directory);
    if ($directory !== false && $directory != '' && file_exists($directory)){
        foreach(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory, FilesystemIterator::SKIP_DOTS)) as $file){
            $bytes += $file->getSize();
        }
    }
    return $bytes;
}

/**
 * Get info about zip archive
 * @param string $path
 * @return array|bool
 */
function fm_get_zif_info($path, $ext) {
    if ($ext == 'zip' && function_exists('zip_open')) {
        $arch = @zip_open($path);
        if ($arch) {
            $filenames = array();
            while ($zip_entry = @zip_read($arch)) {
                $zip_name = @zip_entry_name($zip_entry);
                $zip_folder = substr($zip_name, -1) == '/';
                $filenames[] = array(
                    'name' => $zip_name,
                    'filesize' => @zip_entry_filesize($zip_entry),
                    'compressed_size' => @zip_entry_compressedsize($zip_entry),
                    'folder' => $zip_folder
                    //'compression_method' => zip_entry_compressionmethod($zip_entry),
                );
            }
            @zip_close($arch);
            return $filenames;
        }
    } elseif($ext == 'tar' && class_exists('PharData')) {
        $archive = new PharData($path);
        $filenames = array();
        foreach(new RecursiveIteratorIterator($archive) as $file) {
            $parent_info = $file->getPathInfo();
            $zip_name = str_replace("phar://".$path, '', $file->getPathName());
            $zip_name = substr($zip_name, ($pos = strpos($zip_name, '/')) !== false ? $pos + 1 : 0);
            $zip_folder = $parent_info->getFileName();
            $zip_info = new SplFileInfo($file);
            $filenames[] = array(
                'name' => $zip_name,
                'filesize' => $zip_info->getSize(),
                'compressed_size' => $file->getCompressedSize(),
                'folder' => $zip_folder
            );
        }
        return $filenames;
    }
    return false;
}

/**
 * Encode html entities
 * @param string $text
 * @return string
 */
function fm_enc($text)
{
    return htmlspecialchars($text, ENT_QUOTES, 'UTF-8');
}

/**
 * Prevent XSS attacks
 * @param string $text
 * @return string
 */
function fm_isvalid_filename($text) {
    return (strpbrk($text, '/?%*:|"<>') === FALSE) ? true : false;
}

/**
 * Save message in session
 * @param string $msg
 * @param string $status
 */
function fm_set_msg($msg, $status = 'ok')
{
    $_SESSION[FM_SESSION_ID]['message'] = $msg;
    $_SESSION[FM_SESSION_ID]['status'] = $status;
}

/**
 * Check if string is in UTF-8
 * @param string $string
 * @return int
 */
function fm_is_utf8($string)
{
    return preg_match('//u', $string);
}

/**
 * Convert file name to UTF-8 in Windows
 * @param string $filename
 * @return string
 */
function fm_convert_win($filename)
{
    if (FM_IS_WIN && function_exists('iconv')) {
        $filename = iconv(FM_ICONV_INPUT_ENC, 'UTF-8//IGNORE', $filename);
    }
    return $filename;
}

/**
 * @param $obj
 * @return array
 */
function fm_object_to_array($obj)
{
    if (!is_object($obj) && !is_array($obj)) {
        return $obj;
    }
    if (is_object($obj)) {
        $obj = get_object_vars($obj);
    }
    return array_map('fm_object_to_array', $obj);
}

/**
 * Get CSS classname for file
 * @param string $path
 * @return string
 */
function fm_get_file_icon_class($path)
{
    // get extension
    $ext = strtolower(pathinfo($path, PATHINFO_EXTENSION));

    switch ($ext) {
        case 'ico':
        case 'gif':
        case 'jpg':
        case 'jpeg':
        case 'jpc':
        case 'jp2':
        case 'jpx':
        case 'xbm':
        case 'wbmp':
        case 'png':
        case 'bmp':
        case 'tif':
        case 'tiff':
        case 'webp':
        case 'avif':
        case 'svg':
            $img = 'fa fa-picture-o';
            break;
        case 'passwd':
        case 'ftpquota':
        case 'sql':
        case 'js':
        case 'ts':
        case 'jsx':
        case 'tsx':
        case 'hbs':
        case 'json':
        case 'sh':
        case 'config':
        case 'twig':
        case 'tpl':
        case 'md':
        case 'gitignore':
        case 'c':
        case 'cpp':
        case 'cs':
        case 'py':
        case 'rs':
        case 'map':
        case 'lock':
        case 'dtd':
            $img = 'fa fa-file-code-o';
            break;
        case 'txt':
        case 'ini':
        case 'conf':
        case 'log':
        case 'htaccess':
        case 'yaml':
        case 'yml':
        case 'toml':
        case 'tmp':
        case 'top':
        case 'bot':
        case 'dat':
        case 'bak':
        case 'htpasswd':
        case 'pl':
            $img = 'fa fa-file-text-o';
            break;
        case 'css':
        case 'less':
        case 'sass':
        case 'scss':
            $img = 'fa fa-css3';
            break;
        case 'bz2':
        case 'zip':
        case 'rar':
        case 'gz':
        case 'tar':
        case '7z':
        case 'xz':
            $img = 'fa fa-file-archive-o';
            break;
        case 'php':
        case 'php4':
        case 'php5':
        case 'phps':
        case 'phtml':
            $img = 'fa fa-code';
            break;
        case 'htm':
        case 'html':
        case 'shtml':
        case 'xhtml':
            $img = 'fa fa-html5';
            break;
        case 'xml':
        case 'xsl':
            $img = 'fa fa-file-excel-o';
            break;
        case 'wav':
        case 'mp3':
        case 'mp2':
        case 'm4a':
        case 'aac':
        case 'ogg':
        case 'oga':
        case 'wma':
        case 'mka':
        case 'flac':
        case 'ac3':
        case 'tds':
            $img = 'fa fa-music';
            break;
        case 'm3u':
        case 'm3u8':
        case 'pls':
        case 'cue':
        case 'xspf':
            $img = 'fa fa-headphones';
            break;
        case 'avi':
        case 'mpg':
        case 'mpeg':
        case 'mp4':
        case 'm4v':
        case 'flv':
        case 'f4v':
        case 'ogm':
        case 'ogv':
        case 'mov':
        case 'mkv':
        case '3gp':
        case 'asf':
        case 'wmv':
        case 'webm':
            $img = 'fa fa-file-video-o';
            break;
        case 'eml':
        case 'msg':
            $img = 'fa fa-envelope-o';
            break;
        case 'xls':
        case 'xlsx':
        case 'ods':
            $img = 'fa fa-file-excel-o';
            break;
        case 'csv':
            $img = 'fa fa-file-text-o';
            break;
        case 'bak':
        case 'swp':
            $img = 'fa fa-clipboard';
            break;
        case 'doc':
        case 'docx':
        case 'odt':
            $img = 'fa fa-file-word-o';
            break;
        case 'ppt':
        case 'pptx':
            $img = 'fa fa-file-powerpoint-o';
            break;
        case 'ttf':
        case 'ttc':
        case 'otf':
        case 'woff':
        case 'woff2':
        case 'eot':
        case 'fon':
            $img = 'fa fa-font';
            break;
        case 'pdf':
            $img = 'fa fa-file-pdf-o';
            break;
        case 'psd':
        case 'ai':
        case 'eps':
        case 'fla':
        case 'swf':
            $img = 'fa fa-file-image-o';
            break;
        case 'exe':
        case 'msi':
            $img = 'fa fa-file-o';
            break;
        case 'bat':
            $img = 'fa fa-terminal';
            break;
        default:
            $img = 'fa fa-info-circle';
    }

    return $img;
}

/**
 * Get image files extensions
 * @return array
 */
function fm_get_image_exts()
{
    return array('ico', 'gif', 'jpg', 'jpeg', 'jpc', 'jp2', 'jpx', 'xbm', 'wbmp', 'png', 'bmp', 'tif', 'tiff', 'psd', 'svg', 'webp', 'avif');
}

/**
 * Get video files extensions
 * @return array
 */
function fm_get_video_exts()
{
    return array('avi', 'webm', 'wmv', 'mp4', 'm4v', 'ogm', 'ogv', 'mov', 'mkv');
}

/**
 * Get audio files extensions
 * @return array
 */
function fm_get_audio_exts()
{
    return array('wav', 'mp3', 'ogg', 'm4a');
}

/**
 * Get text file extensions
 * @return array
 */
function fm_get_text_exts()
{
    return array(
        'txt', 'css', 'ini', 'conf', 'log', 'htaccess', 'passwd', 'ftpquota', 'sql', 'js', 'ts', 'jsx', 'tsx', 'mjs', 'json', 'sh', 'config',
        'php', 'php4', 'php5', 'phps', 'phtml', 'htm', 'html', 'shtml', 'xhtml', 'xml', 'xsl', 'm3u', 'm3u8', 'pls', 'cue', 'bash', 'vue',
        'eml', 'msg', 'csv', 'bat', 'twig', 'tpl', 'md', 'gitignore', 'less', 'sass', 'scss', 'c', 'cpp', 'cs', 'py', 'go', 'zsh', 'swift',
        'map', 'lock', 'dtd', 'svg', 'asp', 'aspx', 'asx', 'asmx', 'ashx', 'jsp', 'jspx', 'cgi', 'dockerfile', 'ruby', 'yml', 'yaml', 'toml',
        'vhost', 'scpt', 'applescript', 'csx', 'cshtml', 'c++', 'coffee', 'cfm', 'rb', 'graphql', 'mustache', 'jinja', 'http', 'handlebars',
        'java', 'es', 'es6', 'markdown', 'wiki', 'tmp', 'top', 'bot', 'dat', 'bak', 'htpasswd', 'pl'
    );
}

/**
 * Get mime types of text files
 * @return array
 */
function fm_get_text_mimes()
{
    return array(
        'application/xml',
        'application/javascript',
        'application/x-javascript',
        'image/svg+xml',
        'message/rfc822',
        'application/json',
    );
}

/**
 * Get file names of text files w/o extensions
 * @return array
 */
function fm_get_text_names()
{
    return array(
        'license',
        'readme',
        'authors',
        'contributors',
        'changelog',
    );
}

/**
 * Get online docs viewer supported files extensions
 * @return array
 */
function fm_get_onlineViewer_exts()
{
    return array('doc', 'docx', 'xls', 'xlsx', 'pdf', 'ppt', 'pptx', 'ai', 'psd', 'dxf', 'xps', 'rar', 'odt', 'ods');
}

/**
 * It returns the mime type of a file based on its extension.
 * @param extension The file extension of the file you want to get the mime type for.
 * @return string|string[] The mime type of the file.
 */
function fm_get_file_mimes($extension)
{
    $fileTypes['swf'] = 'application/x-shockwave-flash';
    $fileTypes['pdf'] = 'application/pdf';
    $fileTypes['exe'] = 'application/octet-stream';
    $fileTypes['zip'] = 'application/zip';
    $fileTypes['doc'] = 'application/msword';
    $fileTypes['xls'] = 'application/vnd.ms-excel';
    $fileTypes['ppt'] = 'application/vnd.ms-powerpoint';
    $fileTypes['gif'] = 'image/gif';
    $fileTypes['png'] = 'image/png';
    $fileTypes['jpeg'] = 'image/jpg';
    $fileTypes['jpg'] = 'image/jpg';
    $fileTypes['webp'] = 'image/webp';
    $fileTypes['avif'] = 'image/avif';
    $fileTypes['rar'] = 'application/rar';

    $fileTypes['ra'] = 'audio/x-pn-realaudio';
    $fileTypes['ram'] = 'audio/x-pn-realaudio';
    $fileTypes['ogg'] = 'audio/x-pn-realaudio';

    $fileTypes['wav'] = 'video/x-msvideo';
    $fileTypes['wmv'] = 'video/x-msvideo';
    $fileTypes['avi'] = 'video/x-msvideo';
    $fileTypes['asf'] = 'video/x-msvideo';
    $fileTypes['divx'] = 'video/x-msvideo';

    $fileTypes['mp3'] = 'audio/mpeg';
    $fileTypes['mp4'] = 'audio/mpeg';
    $fileTypes['mpeg'] = 'video/mpeg';
    $fileTypes['mpg'] = 'video/mpeg';
    $fileTypes['mpe'] = 'video/mpeg';
    $fileTypes['mov'] = 'video/quicktime';
    $fileTypes['swf'] = 'video/quicktime';
    $fileTypes['3gp'] = 'video/quicktime';
    $fileTypes['m4a'] = 'video/quicktime';
    $fileTypes['aac'] = 'video/quicktime';
    $fileTypes['m3u'] = 'video/quicktime';

    $fileTypes['php'] = ['application/x-php'];
    $fileTypes['html'] = ['text/html'];
    $fileTypes['txt'] = ['text/plain'];
    //Unknown mime-types should be 'application/octet-stream'
    if(empty($fileTypes[$extension])) {
      $fileTypes[$extension] = ['application/octet-stream'];
    }
    return $fileTypes[$extension];
}

/**
 * This function scans the files and folder recursively, and return matching files
 * @param string $dir
 * @param string $filter
 * @return array|null
 */
 function scan($dir = '', $filter = '') {
    $path = FM_ROOT_PATH.'/'.$dir;
     if($path) {
         $ite = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));
         $rii = new RegexIterator($ite, "/(" . $filter . ")/i");

         $files = array();
         foreach ($rii as $file) {
             if (!$file->isDir()) {
                 $fileName = $file->getFilename();
                 $location = str_replace(FM_ROOT_PATH, '', $file->getPath());
                 $files[] = array(
                     "name" => $fileName,
                     "type" => "file",
                     "path" => $location,
                 );
             }
         }
         return $files;
     }
}

/**
* Parameters: downloadFile(File Location, File Name,
* max speed, is streaming
* If streaming - videos will show as videos, images as images
* instead of download prompt
* https://stackoverflow.com/a/13821992/1164642
*/
function fm_download_file($fileLocation, $fileName, $chunkSize  = 1024)
{
    if (connection_status() != 0)
        return (false);
    $extension = pathinfo($fileName, PATHINFO_EXTENSION);

    $contentType = fm_get_file_mimes($extension);

    if(is_array($contentType)) {
        $contentType = implode(' ', $contentType);
    }

    $size = filesize($fileLocation);

    if ($size == 0) {
        fm_set_msg(lng('Zero byte file! Aborting download'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));

        return (false);
    }

    @ini_set('magic_quotes_runtime', 0);
    $fp = fopen("$fileLocation", "rb");

    if ($fp === false) {
        fm_set_msg(lng('Cannot open file! Aborting download'), 'error');
        $FM_PATH=FM_PATH; fm_redirect(FM_SELF_URL . '?p=' . urlencode($FM_PATH));
        return (false);
    }

    // headers
    header('Content-Description: File Transfer');
    header('Expires: 0');
    header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    header('Pragma: public');
    header("Content-Transfer-Encoding: binary");
    header("Content-Type: $contentType");

    $contentDisposition = 'attachment';

    if (strstr($_SERVER['HTTP_USER_AGENT'], "MSIE")) {
        $fileName = preg_replace('/\./', '%2e', $fileName, substr_count($fileName, '.') - 1);
        header("Content-Disposition: $contentDisposition;filename=\"$fileName\"");
    } else {
        header("Content-Disposition: $contentDisposition;filename=\"$fileName\"");
    }

    header("Accept-Ranges: bytes");
    $range = 0;

    if (isset($_SERVER['HTTP_RANGE'])) {
        list($a, $range) = explode("=", $_SERVER['HTTP_RANGE']);
        str_replace($range, "-", $range);
        $size2 = $size - 1;
        $new_length = $size - $range;
        header("HTTP/1.1 206 Partial Content");
        header("Content-Length: $new_length");
        header("Content-Range: bytes $range$size2/$size");
    } else {
        $size2 = $size - 1;
        header("Content-Range: bytes 0-$size2/$size");
        header("Content-Length: " . $size);
    }
    $fileLocation = realpath($fileLocation);
    while (ob_get_level()) ob_end_clean();
    readfile($fileLocation);

    fclose($fp);

    return ((connection_status() == 0) and !connection_aborted());
}

/**
 * If the theme is dark, return the text-white and bg-dark classes.
 * @return string the value of the  variable.
 */
function fm_get_theme() {
    $result = '';
    if(FM_THEME == "dark") {
        $result = "text-white bg-dark";
    }
    return $result;
}

/**
 * Class to work with zip files (using ZipArchive)
 */
class FM_Zipper
{
    private $zip;

    public function __construct()
    {
        $this->zip = new ZipArchive();
    }

    /**
     * Create archive with name $filename and files $files (RELATIVE PATHS!)
     * @param string $filename
     * @param array|string $files
     * @return bool
     */
    public function create($filename, $files)
    {
        $res = $this->zip->open($filename, ZipArchive::CREATE);
        if ($res !== true) {
            return false;
        }
        if (is_array($files)) {
            foreach ($files as $f) {
                $f = fm_clean_path($f);
                if (!$this->addFileOrDir($f)) {
                    $this->zip->close();
                    return false;
                }
            }
            $this->zip->close();
            return true;
        } else {
            if ($this->addFileOrDir($files)) {
                $this->zip->close();
                return true;
            }
            return false;
        }
    }

    /**
     * Extract archive $filename to folder $path (RELATIVE OR ABSOLUTE PATHS)
     * @param string $filename
     * @param string $path
     * @return bool
     */
    public function unzip($filename, $path)
    {
        $res = $this->zip->open($filename);
        if ($res !== true) {
            return false;
        }
        if ($this->zip->extractTo($path)) {
            $this->zip->close();
            return true;
        }
        return false;
    }

    /**
     * Add file/folder to archive
     * @param string $filename
     * @return bool
     */
    private function addFileOrDir($filename)
    {
        if (is_file($filename)) {
            return $this->zip->addFile($filename);
        } elseif (is_dir($filename)) {
            return $this->addDir($filename);
        }
        return false;
    }

    /**
     * Add folder recursively
     * @param string $path
     * @return bool
     */
    private function addDir($path)
    {
        if (!$this->zip->addEmptyDir($path)) {
            return false;
        }
        $objects = scandir($path);
        if (is_array($objects)) {
            foreach ($objects as $file) {
                if ($file != '.' && $file != '..') {
                    if (is_dir($path . '/' . $file)) {
                        if (!$this->addDir($path . '/' . $file)) {
                            return false;
                        }
                    } elseif (is_file($path . '/' . $file)) {
                        if (!$this->zip->addFile($path . '/' . $file)) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
        return false;
    }
}

/**
 * Class to work with Tar files (using PharData)
 */
class FM_Zipper_Tar
{
    private $tar;

    public function __construct()
    {
        $this->tar = null;
    }

    /**
     * Create archive with name $filename and files $files (RELATIVE PATHS!)
     * @param string $filename
     * @param array|string $files
     * @return bool
     */
    public function create($filename, $files)
    {
        $this->tar = new PharData($filename);
        if (is_array($files)) {
            foreach ($files as $f) {
                $f = fm_clean_path($f);
                if (!$this->addFileOrDir($f)) {
                    return false;
                }
            }
            return true;
        } else {
            if ($this->addFileOrDir($files)) {
                return true;
            }
            return false;
        }
    }

    /**
     * Extract archive $filename to folder $path (RELATIVE OR ABSOLUTE PATHS)
     * @param string $filename
     * @param string $path
     * @return bool
     */
    public function unzip($filename, $path)
    {
        $res = $this->tar->open($filename);
        if ($res !== true) {
            return false;
        }
        if ($this->tar->extractTo($path)) {
            return true;
        }
        return false;
    }

    /**
     * Add file/folder to archive
     * @param string $filename
     * @return bool
     */
    private function addFileOrDir($filename)
    {
        if (is_file($filename)) {
            try {
                $this->tar->addFile($filename);
                return true;
            } catch (Exception $e) {
                return false;
            }
        } elseif (is_dir($filename)) {
            return $this->addDir($filename);
        }
        return false;
    }

    /**
     * Add folder recursively
     * @param string $path
     * @return bool
     */
    private function addDir($path)
    {
        $objects = scandir($path);
        if (is_array($objects)) {
            foreach ($objects as $file) {
                if ($file != '.' && $file != '..') {
                    if (is_dir($path . '/' . $file)) {
                        if (!$this->addDir($path . '/' . $file)) {
                            return false;
                        }
                    } elseif (is_file($path . '/' . $file)) {
                        try {
                            $this->tar->addFile($path . '/' . $file);
                        } catch (Exception $e) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
        return false;
    }
}

/**
 * Save Configuration
 */
 class FM_Config
{
     var $data;

    function __construct()
    {
        global $root_path, $root_url, $CONFIG;
        $fm_url = $root_url.$_SERVER["PHP_SELF"];
        $this->data = array(
            'lang' => 'en',
            'error_reporting' => true,
            'show_hidden' => true
        );
        $data = false;
        if (strlen($CONFIG)) {
            $data = fm_object_to_array(json_decode($CONFIG));
        } else {
            $msg = 'Tiny File Manager
Error: Cannot load configuration';
            if (substr($fm_url, -1) == '/') {
                $fm_url = rtrim($fm_url, '/');
                $msg .= '
';
                $msg .= '
Seems like you have a trailing slash on the URL.';
                $msg .= '
Try this link: ' . $fm_url . '';
            }
            die($msg);
        }
        if (is_array($data) && count($data)) $this->data = $data;
        else $this->save();
    }

    function save()
    {
        $fm_file = __FILE__;
        $var_name = '$CONFIG';
        $var_value = var_export(json_encode($this->data), true);
        $config_string = "
    
          
        
        

            ";
            $sep = ' / ';
            if ($path != '') {
                $exploded = explode('/', $path);
                $count = count($exploded);
                $array = array();
                $parent = '';
                for ($i = 0; $i < $count; $i++) {
                    $parent = trim($parent . '/' . $exploded[$i], '/');
                    $parent_enc = urlencode($parent);
                    $array[] = "" . fm_enc(fm_convert_win($exploded[$i])) . "";
                }
                $root_url .= $sep . implode($sep, $array);
            }
            echo '' . $root_url . $editFile . '';
            ?>

            
                
                    
                        
                            
                            
                                
                            
                            
                                
                                  
                                    
                                  
                            
                        
                    
                    
                    
                         
                    
                    
                         
                    
                    
                    
                    
                          
                        
                            
                             
                            
                             
                             
                        
                    
                    
                        
                            
                                 
                            
                        
                    
                
            
        
    
    ' . $_SESSION[FM_SESSION_ID]['message'] . '';
        unset($_SESSION[FM_SESSION_ID]['message']);
        unset($_SESSION[FM_SESSION_ID]['status']);
    }
}

/**
 * Show page header in Login Form
 */
function fm_show_header_login()
{
$sprites_ver = '20160315';
header("Content-Type: text/html; charset=utf-8");
header("Expires: Sat, 26 Jul 1997 05:00:00 GMT");
header("Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0");
header("Pragma: no-cache");

global $lang, $root_url, $favicon_path;
?>



    
    
    
    
    
    
    '; } ?>
    <?php echo fm_enc(APP_TITLE) ?>
    
    
    

">


    









    
    
    
    
    
    
    '; } ?>
    <?php echo fm_enc(APP_TITLE) ?>
    
    
    
    
    
    
    
    
    
    
        
    

 ">

Пин Ап

Apr 15, 2024

—

by

admin

in 1

до 25 000 ₽ (100% депозита) + 250 FS при первом пополнении/первом депозите

Получить

Получи бонус

за первый депозит

Забрать

Моментальный вывод выигрышей

Гарантия

безопасности игроков

Техподдержка 24/7

Доступные бонусы и акционные предложения

Игровые автоматы

Pin-Up Casino предлагает уникальный и простой в использовании интерфейс, что обеспечивает игрокам шанс насладиться азартом с любого устройства. Мобильный софт обеспечивает доступность к слотам в режиме 24/7. Процесс регистрации на официальном сайте Пин-Ап казино не вызывает сложностей, а вывод выигрыша происходит максимально быстро.

История Pin-Up Casino

Начало работы казино Пин Ап и его история связаны с периодом повышенного интереса к инновационным сервисам в сфере игр на удачу. Онлайн проект был запущен в марте 2016 года. С тех пор компания получила репутацию надежного и открытого онлайн-игорного клуба, оперативно решающего возникающие вопросы и выплачивающего выигрыши без задержек. В 2018 году онлайн-платформа Pin Up успешно вышла на российский рынок, завоевав доверие миллионов пользователей.

С самого начала компания Pinup ставила перед собой задачу разработать уникальный игровой контент, который удовлетворит запросы самых взыскательных игроков и обеспечит доступ к игровым автоматам для любителей из различных стран.

Платформа Пинап: география доступности

Легальная работа Пин Ап казино в России началась с 2018 года. Компания также законно функционирует на территории других регионов СНГ, в Турции, Азербайджане, Казахстане. В то же время легальное российское онлайн казино Пин-Ап не дает доступ игрокам из некоторых государств, в соответствии с местными законодательными нормами.

Лицензирование казино Pin Up

Pin Up Casino обладает лицензией номер 8048/JAZ2017-0003, выданной регулирующим органом Кюрасао. Регулятор подтверждает, что все процессы основаны на принципах случайности и предотвращает любые попытки манипуляции. Благодаря лицензии Pin-up Casino обеспечивает защиту средств и сохранность личной информации клиентов.

Владельцем Пин Ап казино онлайн является компания Carletta NV, а операции по процессингу осуществляются через организацию BWI BLACK-WOOD LTD, зарегистрированную на Кипре. Владелец игорного клуба сохраняет прозрачность и подтвердил свою финансовую способность, что свидетельствует о его надежности и прозрачности.

🎰 Бренд

Pin Up Casino

📅 Год создания

2016

🔖 Лицензия

Кюрасао 8048/JAZ2017-0003

🎮 Игры

Разнообразие слотов и столовых игр

💰 Бонусы

Приветственный бонус и фриспины

💳 Оплата

Электронные деньги, Банковские переводы, Криптовалюта

📱 Мобильная версия Pin Up

Есть

💸 Вывод средств

До 24 часов

🛡 Верификация

Обязательна перед выводом

Регистрация и верификация на сайте казино Пин Ап

Регистрация в Pin-Up Casino занимает минимум времени и не обременяет обязательствами. Достаточно указать логин и пароль, а затем пройти верификацию. После этого можно выбирать любой игровой автомат и начинать играть. Официальный сайт казино Pin-Up предлагает широкий выбор игр, поэтому каждый найдет подходящий слот с учетом различных критериев: процент выплат, наличие бонусных игр, игровой процесс, акционные предложения, звуковое сопровождение, анимация и многое другое. Яркий и понятный интерфейс добавляет удобства при использовании.

Процесс создания личного кабинета на официальном сайте Pin-Up

В личном кабинете казино Pin-up, доступном сразу после регистрации, пользователи находят удобное и многофункциональное пространство для управления. Основные элементы интерфейса разработаны с учетом легкости в использовании и понятности для всех пользователей.

Новичок, желающий присоединиться к захватывающему миру игр на удачу, может легко создать свой аккаунт, следуя простым шагам.

Нажмите кнопку ;Регистрация; в верхнем правом углу ресурса.

Введите номер телефона или адрес электронной почты в соответствующее поле.

Внесите персональные данные: имя, фамилия и дата рождения. Установите пароль и подтвердите регистрацию.

После завершения процесса регистрации игрок может осуществить в Пин-Ап казино вход в личный кабинет, где доступны различные опции: изменение личных данных, управление финансами и предложениями по бонусам, программа лояльности.

Верификация аккаунта в казино Пин Ап

Проверка и подтверждение учетной записи в интернет-казино Pin-Up представляют собой важный этап, направленный на обеспечение безопасности и защиты личных данных игрока. Верификация аккаунта в Пинам казино также помогает избежать задержек при выводе выигрышей. Процедура проверки осуществляется путем предоставления паспортных данных. Для завершения этого этапа нужно загрузить отсканированный паспорт и сделать снимок с документом в руках. Предоставленные документы подвергаются тщательной проверке службой безопасности с целью гарантировать их подлинность и соответствие предоставленным данным. Это позволяет пользователям Пин-ап играть онлайн легально.

Процесс верификации в Пин Ап казино обычно занимает от нескольких часов до трех дней. После завершения проверки игрок получает статус верифицированного аккаунта, что обеспечивает ему возможность легко проводить финансовые операции, включая вывод выигрышей.

С чего начать новому игроку в казино Pin Up

Для того чтобы вступить в игру с правильным настроем и уверенностью, важно ознакомиться с основными разделами официального сайта Пин Ап казино, которые помогут быстро сориентироваться и избежать недоразумений.

Пользовательское соглашение

Перед тем, как осуществить вход в Pin up, новичку стоит ознакомиться с пользовательским соглашением. Этот раздел содержит правила и условия использования платформы, которые регулируют взаимоотношения между игроком и казино. Чтение пользовательского соглашения позволит избежать нарушений и обеспечит понимание прав и обязанностей в казино Pin Up.

В пользовательском соглашении описаны правила относительно регистрации аккаунта, использования личной информации, вопросы безопасности, методы внесения депозита и вывода средств, а также многие другие аспекты.

Правила приема ставок

После того, как регистрация в казино Pin-Up пройдена, игрок может делать первые ставки. В разделе ;Правила приема ставок; содержится важная информация о том, как начать играть. Здесь новички смогут узнать о различных видах ставок, правилах проведения соревнований, а также о правах и обязанностях как компании, так и клиента. Казино Pin Up предоставляет широкий выбор видов ставок, включая:

одиночные;

комбинированные;

системные ставки и т.д.

В правилах также указывается, какие виды ставок доступны для конкретных игр и как их правильно совершать.

Раздел ;О нас;

Этот раздел предоставляет информацию об истории казино, его ценностях и лицензии. Перед началом игры пользователи могут убедиться в честности и надежности платформы, а также в ее законности. Ознакомление с данным разделом поможет принять обоснованное решение о доверии к казино Пин-Ап.

Ответственная игра в казино Пин-Ап

Этот важный раздел напоминает игрокам о необходимости играть ответственно. Здесь содержится информация о возможных рисках азартных игр и советы по предотвращению проблем с азартной зависимостью. Прочтение этого раздела поможет сохранить контроль над игровым процессом и избежать негативных последствий. Осознанная игра и умение распознавать свои личные пределы — важные навыки для всех игроков, которые помогут им наслаждаться азартными играми в безопасной и здоровой мере.

Внимательное ознакомление с указанными разделами сайта казино Pin-up casino поможет начать игру с уверенностью. Знание правил и ответственная игра являются ключевыми аспектами успешного и приятного времяпрепровождения в мире гемблинга.

Игровые автоматы и провайдеры Пин Ап

Казино Пин Ап на реальные деньги предлагает широкий выбор захватывающих игровых автоматов, которые каждому дают шанс выигрыша. Pin up игровые автоматы — это уникальные темы, бонусные раунды и высокие выплаты, чтобы каждый игрок мог найти что-то по своему вкусу.

Тип автомата

Описание

Классические слоты

Эти автоматы имеют традиционный дизайн с символами фруктов, баров и семерок. Они обычно имеют 3 барабана и небольшое количество линий выплат.

Видео слоты

Видео слоты обычно имеют 5 барабанов и разнообразные тематики, от приключений и фантастики до фильмов и музыки. Они предлагают множество бонусных функций и спецэффектов.

Прогрессивные слоты

Эти автоматы предлагают прогрессивный джекпот, который увеличивается с каждой ставкой игрока. Джекпот может быть связан с одним автоматом или сетью автоматов.

Видео покер

Видео покер представляет собой комбинацию игровых автоматов и покера. Игрокам предлагается выбрать карты для замены, чтобы собрать наилучшую комбинацию и выиграть приз.

Рулетка

В рулетке игроки делают ставки на число, цвет или диапазон чисел. Шарик вращается вокруг каталки с номерами, и выигрывает та ставка, на которую он остановится.

Блэкджек

Блэкджек – это карточная игра, где игроки стараются набрать сумму очков ближе к 21, чем дилер, но не больше. Игроки могут делать различные ставки и использовать стратегии.

Баккара

Баккара – это карточная игра, в которой игроки делают ставки на результат руки, которая является либо ;игроком;, либо ;банкиром;, либо ;ничья;.

Кости

В кости игроки делают ставки на результат броска костей. Игроки могут делать различные типы ставок, основанных на сумме бросков или комбинациях чисел.

Софт и провайдеры Пин-ап казино

Казино Пин Ап сотрудничает с ведущими разработчиками игрового софта, обеспечивая игрокам доступ к самым захватывающим и качественным развлечениям. Сюда можно отнести:

NetEnt;

Microgaming;

Belatra;

Play'n GO;

Yggdrasil Gaming;

Quickspin;

Red Tiger;

Evolution Gaming;

Playtech;

Pragmatic Play.

Каждый провайдер представленный на казино Пин Ап официальном сайте проходит строгие проверки и лицензирование, чтобы обеспечить игрокам надежный и безопасный игровой опыт.

Каждый игровой автомат на Пин-Ап Казино обладает уникальной темой, захватывающей графикой и интересными бонусными раундами. Игроки могут наслаждаться разнообразием символов, которые могут запускать бонусные игры, фриспины и множественные выигрыши. Автоматы Пинап имеют высокие показатели отдачи, обеспечивая игрокам справедливые шансы на выигрыш.

Для самых преданных игроков Pin Up casino доступна VIP-программа, которая предоставляет доступ к эксклюзивным бонусам и первым показам новых игр.

Живое казино с Live-дилерами в Pin Up

Каждый пользователь может играть с живым дилером в казино Pin up. Live игры дарят уникальный шанс насладиться игрой в рулетку, блэкджек, покер и многое другое, не выходя из уютной обстановки дома.

Популярные live игры в казино Пин-Ап:

Live Рулетка:

Подлинный онлайн-игорный клуб с реальным крупье и аутентичными столами.

Разнообразие вариантов: классическая, европейская, американская рулетка и многое другое.

Возможность общения: общайтесь с управляющим и другими игроками через чат, делая игру еще более захватываюбщей.

Live Блэкджек:

Играйте против реального дилера: испытайте свои навыки в блэкджеке против профессионального управляющего.

Разнообразие столов и ставок: от стандартного до VIP блэкджека, найдите стол, который соответствует вашим предпочтениям.

Реалистичная атмосфера: живая трансляция создает атмосферу, сравнимую с посещением настоящего игорного заведения.

Live Покер:

Турниры и кэш-игры: участвуйте в захватывающих турнирах и кэш-играх с живыми дилерами.

Различные варианты покера: от техасского холдема до омахи, выбирайте свою любимую версию и соревнуйтесь за призы.

Интерактивное общение: общайтесь с дилером и другими игроками за столом, делая игру еще более яркой.

Пин Ап казино гарантирует, что каждый найдет идеальную live игру, которая придется по вкусу. Игры с живым человеком в казино Пин-ап создают захватывающий контент, предоставляя множество вариантов для тех, кто ценит азарт.

Внесение депозита и вывод средств с платформы Pin Up Casino

Для начала игры на деньги на сайте казино Пин Ап нужно пройти процедуру верификации аккаунта. Это важный шаг, который гарантирует безопасность финансов и предотвращает мошенничество. После успешной верификации игрок сможет вносить депозиты и выводить выигранные средства.

Внесение средств

Пинап официальный сайт предоставляет возможность внесения средств через раздел ;Касса; . Здесь можно выбрать удобный способ внесения средств и указать сумму (минимально — 100 рублей). Платформа предлагает приветственный бонус за первое пополнение, который увеличит игровой баланс.

Вывод средств с сайта Pin-up Casino

Чтобы вывести выигранные средства, пользователь должен зайти в раздел ;Пинап Вход; и далее перейти в раздел ;Касса;. Здесь ему предоставляется выбор удобного способа вывода и указание суммы. Вывод доступен в различных валютах, включая доллары, евро и другие популярные валюты.

Пинап Казино предлагает широкий выбор платежных систем для совершения финансовых операций:

Виза/Мастеркард;

Яндекс.Деньги;

ВебМани;

Киви;

Скрилл;

Нетеллер;

Биткоин и другие криптовалюты.

Веб-ресурс гарантирует полную безопасность всех финансовых операций. Все транзакции защищены современными шифровальными технологиями, обеспечивая конфиденциальность данных пользователей.

Платежная система

Минимальная сумма вывода

Максимальная сумма вывода

Visa/Mastercard

$10

$5000

Яндекс.Деньги

100 рублей

100 000 рублей

WebMoney

$10

$10 000

Qiwi

300 рублей

15 000 рублей

Skrill

$10

Нет ограничений

Neteller

$10

Нет ограничений

Bitcoin

0.001 BTC

Нет ограничений

Играть в демо-режим слотов Пин Ап бесплатно

Pin Up casino предоставляет своим пользователям уникальную возможность не только наслаждаться играми на реальные деньги, но и погрузиться в захватывающий мир азарта совершенно бесплатно благодаря инновационной функции демо-режима. Это позволяет игрокам полностью освоиться с игровым процессом и выбрать наиболее подходящие игры перед тем, как начать играть на реальные деньги.

Игрокам доступен широкий выбор демо-слотов, которые можно опробовать абсолютно бесплатно. В демо-режиме пользователю предоставляется внутренняя валюта, которую можно использовать для перезапуска слотов и повторной игры. Это дает возможность получить полноценный опыт игры без необходимости вносить какие-либо депозиты.

Демо-режим в онлайн казино предоставляет ряд значительных преимуществ:

пользователям не нужно рисковать своими средствами, чтобы попробовать различные игры и оценить их, можно играть в слоты бесплатно;

демо-режим в Pin up casino online позволяет игрокам ознакомиться с разнообразными играми, доступными в казино, и изучить их механику, бонусные функции и геймплей без необходимости вносить депозит;

играя в демо-режиме Пинап Казино, игроки могут экспериментировать с различными стратегиями игры и выявлять наиболее эффективные подходы без риска потери собственных средств;

демо-режим позволяет игрокам улучшить свои игровые навыки и понимание правил игры, что может быть полезно при переходе к игре на реальные деньги;

игроки могут использовать демонстрационный режим, чтобы оценить потенциал выигрышей в различных играх и выбрать те, которые наиболее соответствуют их предпочтениям и стилю игры.

Демо-режим создает комфортную среду для игры, где игроки могут экспериментировать и изучать новые игры без давления риска потери средств. Это позволяет им чувствовать себя более уверенно, когда они готовы перейти к игре на реальные деньги.

В целом, демо-режим в онлайн казино Пин Ап представляет собой ценный инструмент, помогающий пользователям расширить свой игровой опыт, разработать стратегии и принять информированные решения перед тем, как начать в Pin-up казино играть и выигрывать.

Казино Pin Up в мобильной версии

Специально разработанная Пин Ап казино мобильная версия предлагает игрокам уникальные азартные впечатления, доступные в любом месте.

Адаптированность под смартфоны. Можно играть без ущерба для качества даже при низкоскоростном интернет-подключении. Мобильная версия казино Пин Ап обеспечивает независимость от технических ограничений и препятствий.

Без привязки к ПК. Игроки освобождаются от необходимости быть привязанным к стационарному компьютеру. Теперь азарт ждет вас вне зависимости от вашего местоположения, достаточно лишь иметь с собой смартфон.

Удобные платежные системы. Вносить депозиты с легкостью удастся прямо через смартфон. Мобильная версия Pin Up поддерживает разнообразные платежные системы, обеспечивая безопасные и удобные транзакции.

Корректная работа на всех устройствах. Веб-ресурс гарантирует стабильную работу на любых мобильных устройствах, даже на бюджетных моделях.

Специальные слоты для мобильного формата. Широкий выбор игр включает в себя специально созданные слоты, предлагающие максимальное удобство и захватывающий геймплей.

Для начала использования онлайн казино Пинап в мобильной версии игроку нужно зайти в браузер на смартфоне. После входа или создания аккаунта, пользователь может выбирать из многочисленных игр, доступных в мобильной версии, и наслаждаться азартом в удобное для себя время. Дополнительно можно установить приложение казино Пинап на телефон, чтобы иметь быстрый и удобный доступ к любому софту.

Официальное зеркало Pin Up

Поклонники казино Pin-Up периодически сталкиваются с ситуацией, когда доступ к игровому порталу ограничен в конкретном регионе. Официальное зеркало Pin Up Casino исправит ситуацию, позволяя беспрепятственно использовать любимые слоты.

Воспользоваться официальным Пин Ап зеркалом стоит по нескольким причинам.

Полное соответствие основному ресурсу. Зеркало Pin Up Casino полностью идентично основному ресурсу. Это означает, что пользователи могут наслаждаться теми же играми и услугами, что и на основном ресурсе казино Пин Ап.

Легкость поиска. Ссылки на зеркало Пинап распространены по различным ресурсам, что делает поиск простым для пользователей.

Выигрыш. Шансы на успех при игре на зеркале Pin Up идентичны тем, которые предоставляются на основном веб-ресурсе, гарантируя пользователям равные шансы выигрыша.

Режимы игры. Зеркало позволяет пользователям выбирать между демо-режимом и игрой на реальные ставки, чтобы каждый мог выбрать наиболее подходящий вариант.

Мобильная доступность. Пин Ап зеркало адаптировано для смартфонов и планшетов, обеспечивая безупречное игровое исполнение даже на небольших экранах.

Если вход на основной ресурс Pin Up Casino заблокирован, существует несколько способов обойти это ограничение.

Маршрутизаторы. Настройка маршрутизатора может помочь изменить IP-адрес пользователя, обеспечивая доступ к заблокированным платформам, в том числе к казино Пин Ап.

VPN (Виртуальная частная сеть). VPN маскирует IP-адрес пользователя, обеспечивая анонимный и безопасный доступ к заблокированным ресурсам.

Встроенные возможности браузера. Некоторые браузеры предлагают инструменты для обхода блокировок, такие как режим инкогнито или VPN-расширения.

VPN (виртуальная частная сеть) обеспечивает анонимность и шифрование трафика, изменяя IP-адрес пользователя. Расширения браузера облегчают доступ к заблокированным веб-сайтам, но могут быть менее надежными. Pin up казино зеркало официальный сайт — альтернативный и безопасный вариант, предоставляющий доступ к качественному игровому софту.

Бонусная программа Пин Ап

Бонусная программа Пин Ап разработана так, чтобы удовлетворить самых требовательных игроков, обеспечивая им максимальные выгоды и удовольствие от игры. Для своих пользователей платформа предлагает несколько видов бонусов.

В казино Pin-up бонус за регистрацию предоставляется всем новичкам. После создания профиля и пополнения счета игрок получает 150% к сумме депозита (при условии пополнения баланса на сумму от 2000 рублей) и 250 бесплатных вращений. Фриспины начисляются в течение 5 дней, давая игроку дополнительные шансы на победу. Чтобы приветственный бонус стал доступен для вывода , его нужно отыграть в течение 3 дней (вейджер Х50). Средства можно использовать в любых играх, а бесплатные вращения доступны только для определенных игровых автоматов.

День Рождения – особенный день, и Pin Up делает его еще более ярким. В день праздника зарегистрированные пользователи получают особое денежное поощрение — Pin up казино бонусы. Для этого нужно убедиться, что профиль верифицирован.

Тип бонуса

Условия

Вейджер

За первое пополнение

Игрок должен внести на счет сумму от 2000 рублей, чтобы получить дополнительно 150%

Х50

За регистрацию

Каждый новичок получает 250 фриспинов, которые начисляются в течение 5 дней.

Х50

В день рождения

Каждый пользователь, который прошел верификацию, получает финансовое поощрение от Пин Ап в день своего рождения или в течение 7 дней после.

Х50

Активные игроки регулярно получают эксклюзивные предложения и бонусы. Для этого достаточно следить за рассылками на электронную почту и регулярно осуществлять вход в Пин Ап казино, чтобы играть и выигрывать.

Акции и турниры Pin Up казино

Pin Up постоянно радует своих игроков разнообразными акциями и турнирами, призванными сделать время проведенное с онлайн казино еще более захватывающим и выгодным.

Фриспины на праздники от Пин Ап

Каждый раз, когда наступает один из популярных российских или международных праздников, зарегистрированные клиенты получают бесплатные фриспины. Для этого нужно открыть депозит на сумму от 1000 рублей и наслаждаться игрой любимых слотов совершенно бесплатно.

Билеты в беспроигрышную лотерею

Активные посетители имеют шанс стать частью беспроигрышной лотереи, проводимой в Pin Up. Игроки, которые регулярно тратят реальные деньги на ставки в слотах, получают бесплатный пропуск на розыгрыш в формате Колеса Фортуны после каждых 5000 рублей ставок.

Еженедельный кэшбэк от Pin up Casino

Пинап предлагает возможность вернуть до 10% проигранных за неделю средств по программе кэшбэка. Итоговый процент зависит от бюджета игрока, при этом максимальные 10% доступны тем, кто проиграл за неделю более 25000 рублей.

Бонусные средства, полученные в рамках акции, могут быть доступны для вывода только в определенные периоды времени. Эта информация указывается в правилах конкретного бонуса.

Турниры в казино Пинап

Помимо акций на официальном сайте Пин-Ап владельцы казино ежемесячно запускают новые турниры с призовым фондом, который редко опускается ниже 500000 рублей. Такие онлайн мероприятия представляют собой захватывающие соревнования, в которых игроки могут испытать свою удачу и получить дополнительные выигрыши.

Главные преимущества казино Пин Ап

Одним из главных преимуществ казино Пин Ап является высокий уровень доверия, который компания завоевала благодаря честной и надежной игровой платформе. Игроки регулярно выводят крупные суммы выигрышей, что подтверждает качество предоставляемых услуг.

Другие преимущества казино Пин Ап включают:

лицензированные продукты от ведущих разработчиков;

огромный выбор игровых автоматов Pin up на любой вкус;

привлекательные бонусы и акции;

быстрые выплаты;

круглосуточная поддержка;

удобный мобильный интерфейс;

безопасность и конфиденциальность данных;

регулярные турниры и конкурсы;

гибкие условия игры на официальном сайте Pin-up казино.

Команда казино Пин Ап гордится своим превосходным уровнем обслуживания и индивидуальным подходом к каждому игроку. Специалисты всегда готовы помочь с любыми вопросами и обеспечить наилучший игровой опыт.

Казино Пин Ап активно развивает свою платформу, чтобы предоставлять игрокам самые современные и захватывающие игры. Регулярное обновление игрового ассортимента позволяет пользователям всегда находить что-то новое и по-настоящему увлекательное. Компания следит за трендами в мире азартных развлечений и внедряет инновации, чтобы удовлетворять запросы даже самых требовательных игроков.

Техническая поддержка и контакты сайта Пинап

Служба поддержки Пин-Ап казино обеспечивает круглосуточную доступность и оперативное реагирование на запросы игроков. Независимо от того, возникли ли проблемы с пополнением счета, выплатами выигрышей или техническими нюансами во время игры, команда специалистов всегда готова предоставить необходимую помощь и разъяснить любые вопросы.

Внутренний виртуальный чат предоставляет наиболее оперативное и удобное общение с саппортом. Чтобы получить помощь, нужно осуществить вход в личный кабинет Pin up казино и перейти в раздел чата в нижнем правом углу сайта. Представители будут готовы помочь сразу после подключения.

Компания также активно развивает свои сообщества в социальных сетях, таких как ВКонтакте и Телеграмм. В этих группах можно найти актуальную информацию о Pin-Up Casino, а также задать свои вопросы администрации. Пользователи могут присоединиться к группам, чтобы оставайтесь в курсе всех новостей и акций.

Если необходима более формальная связь или возникли сложные вопросы, можно обратиться к представителям компании по электронной почте. Достаточно отправить запрос на адрес support@pin-up.casino, и служба поддержки ответит в наиболее короткие сроки.

Политика конфиденциальности сайта Pin up

Сайт Pin Up Casino строго соблюдает политику конфиденциальности, обеспечивая защиту информации и личных данных своих клиентов. Все сведения надежно хранятся и не передается третьим лицам. Личные данные используются исключительно для обеспечения доступа к аккаунту, идентификации пользователей, уведомлений и проведения транзакций.

Команда Pin up казино прилагает все необходимые меры для обеспечения безопасности данных, используя передовые технологии шифрования. Пользователи, регистрируясь официальном сайте, автоматически соглашаются с политикой конфиденциальности.

На официальный сайте Pin Up Casino регулярное проводится обновление систем безопасности, что позволяет гарантировать клиентам защиту от потенциальных угроз и атак. В случае возникновения вопросов или необходимости получения дополнительной информации о политике конфиденциальности пользователи могут обратиться в службу поддержки.

FAQ

Как начать играть в Pin-up casino?

Для начала игры в Pin-up casino нужно пройти процедуру регистрации на официальном сайте и пополните счет. Пользователи также могут воспользоваться демо-режимом, чтобы протестировать игровые автоматы без внесения депозита.

Как вывести деньги с Пин Ап?

Для вывода выигранных средств с казино Pin-up пользователь должен зайти в раздел ;Пинап вход; и перейти в раздел ;Касса;. Затем нужно выбрать удобный способ вывода и указать сумму. Средства могут быть выведены в различных валютах, таких как доллары, евро и другие. Казино предоставляет широкий выбор платежных систем, включая Visa/Mastercard, Яндекс.Деньги, WebMoney, Qiwi, Skrill, Neteller, Bitcoin и другие криптовалюты.

Как внести депозит?

Для внесения депозита на сайте Pin-up Casino пользователю необходимо авторизоваться на сайте, затем перейти в раздел ;Касса;. Здесь будет предоставлен выбор различных способов пополнения счета, таких как Visa/Mastercard, Яндекс.Деньги, WebMoney, Qiwi, Skrill, Neteller, Bitcoin и другие криптовалюты. Пользователь может выбрать подходящий способ и указывает сумму депозита. После подтверждения операции средства будут зачислены на счет.

Где получить промокод?

Промокоды для Pin-up Casino могут быть доступны на различных платформах, таких как социальные сети, форумы, блоги о гемблинге или специализированные ресурсы по онлайн-казино. Также, компания может распространять промокоды через свою рассылку или специальные акции для зарегистрированных пользователей. Рекомендуется следить за обновлениями на сайте казино и в социальных сетях, чтобы быть в курсе последних акций и получить промокоды.

Какая игра в Pin up дает выигрыш?

Pin-up Casino предлагает широкий выбор игр, включая слоты, рулетку, блэкджек, видеопокер, баккару и другие азартные игры. Все они предоставляют вероятность выигрыша в зависимости от удачи геймера, его стратегии и опыта. Конкретная игра, которая может принести выигрыш, зависит от предпочтений.

Кому принадлежит Пин-Ап казино?

Pin Up Casino принадлежит компании Carletta NV, а операции по процессингу осуществляются через организацию BWI BLACK-WOOD LTD, зарегистрированную на Кипре. Казино обладает лицензией номер 8048/JAZ2017-0003, выданной регулирующим органом Кюрасао, что обеспечивает защиту средств и сохранность личной информации клиентов. Регулятор подтверждает, что все игровые процессы основаны на принципах случайности и предотвращает любые попытки манипуляции.

Как скачать Pin up казино?

Приложение Pin up казино можно скачать с официального сайта или в маркете мобильного устройства (App Store для iOS устройств и Google Play Store для Android устройств). Для загрузки и установки приложения просто перейдите в соответствующий магазин приложений и выполните поиск по запросу ;Pin-up Casino;. Следуйте инструкциям по установке, чтобы начать играть через мобильное приложение.

Почему не заходит на сайт Pin-up?

Доступ к онлайн-казино может быть ограничен из-за законодательных ограничений или блокировок со стороны провайдеров интернет-услуг. Это может быть связано с требованиями российского законодательства о лицензировании и регулировании онлайн-гемблинга, которые могут ограничивать доступ к определенным игорным сайтам.

Если доступ к основному сайту Pin-up Casino ограничен в вашем регионе, вы можете воспользоваться официальным зеркалом Pin Up Casino. Зеркало полностью идентично основному ресурсу, предоставляя доступ к тем же играм и услугам. Ссылки на зеркало Pin-up распространены по различным ресурсам, что упрощает его поиск. Шансы на успех при игре на зеркале идентичны основному сайту, а пользователи могут выбирать между демо-режимом и игрой на реальные ставки.

Как попасть на официальный сайт Пин-Ап?

Для доступа к официальному сайту казино Pin-Up может потребоваться использовать официальное зеркало или воспользоваться виртуальной частной сетью (VPN) для обхода вероятных блокировок. Вы также можете использовать анонимизирующие браузеры для обеспечения анонимного подключения к интернету и доступа к сайту.

Какие слоты дают больше всего?

В онлайн-казино некоторые слоты могут обладать более высоким уровнем возврата к игроку (RTP). Это означает, что они возвращают больше средств геймерам в долгосрочной перспективе. Например, такие слоты как Mega Joker (NetEnt) с RTP до 99%, Blood Suckers (NetEnt) с RTP до 98%, Gonzo's Quest (NetEnt) с RTP до 96%, и Book of Dead (Play'n GO) с RTP до 96% часто считаются прибыльными. Однако, исходя из того, что результаты в слотах определяются случайно, нужно выбирать игры, которые приносят удовольствие.

Можно ли обмануть игровой автомат?

Обмануть игровой автомат путем манипуляции с программным обеспечением или же физически невозможно. Современные онлайн-слоты и игровые автоматы в онлайн игорных заведениях работают на основе программного обеспечения, которое использует генератор случайных чисел, чтобы обеспечить случайные и непредсказуемые результаты. Кроме того, казино и игровые автоматы проходят проверки на честность и безопасность со стороны регулирующих органов.

Зачем Пинкоины в Пин Ап?

Пинкоины в Pin-up Casino используются для участия в акциях, получения бонусов и привилегий. Это виртуальная валюта, которая предоставляет игрокам дополнительные привелегии для улучшения игрового опыта и получения дополнительных выгод.

Как получить Пинкоины?

Заработать Пинкоины в Pin-up Casino можно через активность на сайте, участвуя в акциях и выполняя различные задания. Это может включать регулярное посещение сайта, участие в играх, привлечение друзей, выполнение определенных игровых целей или участие в специальных мероприятиях и промо-акциях. Каждое действие может быть вознаграждено определенным количеством Пинкоинов, которые затем могут быть использованы для получения бонусов и привилегий.

Сколько ждать вывода денег с Пин Ап?

Скорость вывода денег с Pin-up Casino может зависеть от выбранного способа вывода и обработки платежа. Обычно большинство платежных систем обрабатывают вывод средств в течение 24 часов. Однако, некоторые методы, такие как банковские переводы или криптовалютные транзакции, могут занимать больше времени из-за особенностей банковских систем или подтверждений сети.

Сколько выводит Пин Ап?

Пин Ап может предоставляет различные лимиты на вывод средств в зависимости от выбранного способа выплаты. Минимальная сумма вывода может варьироваться от нескольких десятков до сотен рублей. Максимальная сумма вывода также может быть ограничена и зависит от условий платежных систем и статуса верификации аккаунта игрока.

Как вывести бонусы в пинап?

Чтобы вывести бонусы в казино Pin-Up:

Используйте бонусные средства для игры.

Соблюдайте требования по ставкам (вейджер).

Перейдите в раздел ;Касса; на сайте казино.

Выберите метод вывода средств.

Введите сумму для вывода и завершите процесс.

Как пройти верификацию в Пин Ап?

Чтобы пройти верификацию в казино Pin-Up, загрузите копии документов, подтверждающих личность и адрес проживания, в свой личный кабинет на сайте казино. Дождитесь проверки документов службой поддержки. После успешной проверки вы получите подтверждение и ваш аккаунт будет готов к использованию. Если возникнут вопросы, обратитесь в службу поддержки Пин Ап.

© 2023 Пин Ап казино

Перейти к содержимому

Регистрация

Вход

Бонусы

Открыть меню

Kent Casino

Регистрация

🎰 БрендKent Casino🌐 Официальный сайтhttps://kent.casino/📅 Год открытия2023🎫 ЛицензияЗемля Кюрасао, # 365/JAZ Sub-license GLH-OCCHKTW0703052021🎁 Приветственный бонус395% + 200 FS🎮 Всего игрБолее 5000 игр🕹️ Режимы игрПробный режим (демо) и игра на реальные средства🎲 Игровые провайдерыPragmatic Universe, PlaynJoy, Pulse Gaming и другие💻 ПлатформыWindows, Android, iOS🗣️ Поддержка языковАнглийский, русский, французский и другие💰 Виды бонусов и акцииВступительный, без депозита и с депозитом, и другие💳 Платежные системыVisa, Master, EcoGalaxy и другие💱 Поддерживаемые валютыEUR, RUB, BYN и другие💵 Минимальный депозит100 руб.💸 Минимальный вывод700 руб.⏳ Время выводаОт 5 минут до 24 часов💬 Поддержка игроковЧат, почтаКент Казино

Добро пожаловать в Kent Casino – вашу виртуальную игровую столицу развлечений и удачи! Откройте для себя уникальный мир азартных развлечений с нашим казино, запущенным в 2023 году под лицензией Кюрасао. Наши игроки оценят более 5000 игр от ведущих провайдеров, таких как Pragmatic Universe, PlaynJoy, Pulse Gaming и многих других.

Бонусы Казино Kent

Погрузитесь в мир азарта с приветственным бонусом 395% + 200 фриспинов, попробуйте удачу в различных режимах – от демо-режима до игры на реальные средства. Kent Casino поддерживает многоязычность (английский, русский, французский и другие) и доступен на платформах Windows, Android и iOS.

Оптимизированные процессы вывода средств, разнообразные валюты, и минимальный депозит всего 100 рублей делают игру еще увлекательнее. Наша служба поддержки всегда готова помочь в чате или по электронной почте. Ощутите атмосферу настоящего казино с Kent – местом, где везение встречает удовольствие!

Comments

Leave a Reply Cancel reply
Your email address will not be published. Required fields are marked *
Comment *
Name *

Email *

Website

Save my name, email, and website in this browser for the next time I comment.

Previous: Making the absolute most of your gay sugar daddy relationship

Next: Sfaturi Și Trucuri Sloturi

My Blog

My WordPress Blog

About

Team
History
Careers

Privacy

Privacy Policy
Terms and Conditions
Contact Us

Social

Facebook
Instagram
Twitter/X

Designed with WordPress