$expiration = config_item('sess_expiration');
 
        if (isset($params['cookie_lifetime']))
        {
            $params['cookie_lifetime'] = (int) $params['cookie_lifetime'];
        }
        else
        {
            $params['cookie_lifetime'] = ( ! isset($expiration) && config_item('sess_expire_on_close'))
                ? 0 : (int) $expiration;
        }
 
        isset($params['cookie_name']) OR $params['cookie_name'] = config_item('sess_cookie_name');
        if (empty($params['cookie_name']))
        {
            $params['cookie_name'] = ini_get('session.name');
        }
        else
        {
            ini_set('session.name', $params['cookie_name']);
        }
 
        isset($params['cookie_path']) OR $params['cookie_path'] = config_item('cookie_path');
        isset($params['cookie_domain']) OR $params['cookie_domain'] = config_item('cookie_domain');
        isset($params['cookie_secure']) OR $params['cookie_secure'] = (bool) config_item('cookie_secure');
 
        session_set_cookie_params(
            $params['cookie_lifetime'],
            $params['cookie_path'],
            $params['cookie_domain'],
            $params['cookie_secure'],
            TRUE // HttpOnly; Yes, this is intentional and not configurable for security reasons
        );
 
        if (empty($expiration))
        {
            $params['expiration'] = (int) ini_get('session.gc_maxlifetime');
        }
        else
        {

        elseif ( ! empty($params['driver']))
        {
            $this->_driver = $params['driver'];
            unset($params['driver']);
        }
        elseif ($driver = config_item('sess_driver'))
        {
            $this->_driver = $driver;
        }
        // Note: BC workaround
        elseif (config_item('sess_use_database'))
        {
            log_message('debug', 'Session: "sess_driver" is empty; using BC fallback to "sess_use_database".');
            $this->_driver = 'database';
        }
 
        $class = $this->_ci_load_classes($this->_driver);
 
        // Configuration ...
        $this->_configure($params);
        $this->_config['_sid_regexp'] = $this->_sid_regexp;
 
        $class = new $class($this->_config);
        if ($class instanceof SessionHandlerInterface)
        {
            session_set_save_handler($class, TRUE);
        }
        else
        {
            log_message('error', "Session: Driver '".$this->_driver."' doesn't implement SessionHandlerInterface. Aborting.");
            return;
        }
 
        // Sanitize the cookie, because apparently PHP doesn't do that for userspace handlers
        if (isset($_COOKIE[$this->_config['cookie_name']])
            && (
                ! is_string($_COOKIE[$this->_config['cookie_name']])
                OR ! preg_match('#\A'.$this->_sid_regexp.'\z#', $_COOKIE[$this->_config['cookie_name']])
            )
        )

        // Don't overwrite existing properties
        $CI =& get_instance();
        if (isset($CI->$object_name))
        {
            if ($CI->$object_name instanceof $class_name)
            {
                log_message('debug', $class_name." has already been instantiated as '".$object_name."'. Second attempt aborted.");
                return;
            }
 
            show_error("Resource '".$object_name."' already exists and is not a ".$class_name." instance.");
        }
 
        // Save the class name and object name
        $this->_ci_classes[$object_name] = $class;
 
        // Instantiate the class
        $CI->$object_name = isset($config)
            ? new $class_name($config)
            : new $class_name();
    }
 
    // --------------------------------------------------------------------
 
    /**
     * CI Autoloader
     *
     * Loads component listed in the config/autoload.php file.
     *
     * @used-by    CI_Loader::initialize()
     * @return    void
     */
    protected function _ci_autoloader()
    {
        if (file_exists(APPPATH.'config/autoload.php'))
        {
            include(APPPATH.'config/autoload.php');
        }
 
        if (file_exists(APPPATH.'config/'.ENVIRONMENT.'/autoload.php'))

        include_once(BASEPATH.'libraries/'.$file_path.$library_name.'.php');
 
        // Check for extensions
        $subclass = config_item('subclass_prefix').$library_name;
        foreach ($paths as $path)
        {
            if (file_exists($path = $path.'libraries/'.$file_path.$subclass.'.php'))
            {
                include_once($path);
                if (class_exists($subclass, FALSE))
                {
                    $prefix = config_item('subclass_prefix');
                    break;
                }
 
                log_message('debug', $path.' exists, but does not declare '.$subclass);
            }
        }
 
        return $this->_ci_init_library($library_name, $prefix, $params, $object_name);
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Internal CI Library Instantiator
     *
     * @used-by    CI_Loader::_ci_load_stock_library()
     * @used-by    CI_Loader::_ci_load_library()
     *
     * @param    string        $class        Class name
     * @param    string        $prefix        Class name prefix
     * @param    array|null|bool    $config        Optional configuration to pass to the class constructor:
     *                        FALSE to skip;
     *                        NULL to search in config paths;
     *                        array containing configuration data
     * @param    string        $object_name    Optional object name to assign to
     * @return    void
     */
    protected function _ci_init_library($class, $prefix, $config = FALSE, $object_name = NULL)

        // We look for a slash to determine this
        if (($last_slash = strrpos($class, '/')) !== FALSE)
        {
            // Extract the path
            $subdir = substr($class, 0, ++$last_slash);
 
            // Get the filename from the path
            $class = substr($class, $last_slash);
        }
        else
        {
            $subdir = '';
        }
 
        $class = ucfirst($class);
 
        // Is this a stock library? There are a few special conditions if so ...
        if (file_exists(BASEPATH.'libraries/'.$subdir.$class.'.php'))
        {
            return $this->_ci_load_stock_library($class, $subdir, $params, $object_name);
        }
 
        // Safety: Was the class already loaded by a previous call?
        if (class_exists($class, FALSE))
        {
            $property = $object_name;
            if (empty($property))
            {
                $property = strtolower($class);
                isset($this->_ci_varmap[$property]) && $property = $this->_ci_varmap[$property];
            }
 
            $CI =& get_instance();
            if (isset($CI->$property))
            {
                log_message('debug', $class.' class already loaded. Second attempt ignored.');
                return;
            }
 
            return $this->_ci_init_library($class, '', $params, $object_name);

            if ($path === BASEPATH)
            {
                continue;
            }
 
            $filepath = $path.'libraries/'.$subdir.$class.'.php';
            // Does the file exist? No? Bummer...
            if ( ! file_exists($filepath))
            {
                continue;
            }
 
            include_once($filepath);
            return $this->_ci_init_library($class, '', $params, $object_name);
        }
 
        // One last attempt. Maybe the library is in a subdirectory, but it wasn't specified?
        if ($subdir === '')
        {
            return $this->_ci_load_library($class.'/'.$class, $params, $object_name);
        }
 
        // If we got this far we were unable to find the requested class.
        log_message('error', 'Unable to load the requested class: '.$class);
        show_error('Unable to load the requested class: '.$class);
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Internal CI Stock Library Loader
     *
     * @used-by    CI_Loader::_ci_load_library()
     * @uses    CI_Loader::_ci_init_library()
     *
     * @param    string    $library_name    Library name to load
     * @param    string    $file_path    Path to the library filename, relative to libraries/
     * @param    mixed    $params        Optional parameters to pass to the class constructor
     * @param    string    $object_name    Optional object name to assign to
     * @return    void

            {
                if (is_int($key))
                {
                    $this->library($value, $params);
                }
                else
                {
                    $this->library($key, $params, $value);
                }
            }
 
            return $this;
        }
 
        if ($params !== NULL && ! is_array($params))
        {
            $params = NULL;
        }
 
        $this->_ci_load_library($library, $params, $object_name);
        return $this;
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Model Loader
     *
     * Loads and instantiates models.
     *
     * @param    mixed    $model        Model name
     * @param    string    $name        An optional object name to assign to
     * @param    bool    $db_conn    An optional database connection configuration to initialize
     * @return    object
     */
    public function model($model, $name = '', $db_conn = FALSE)
    {
        if (empty($model))
        {
            return $this;

     * Designed to be called from application controllers.
     *
     * @param    mixed    $library    Library name
     * @param    array    $params        Optional parameters to pass to the library class constructor
     * @param    string    $object_name    An optional object name to assign to
     * @return    object
     */
    public function library($library, $params = NULL, $object_name = NULL)
    {
        if (empty($library))
        {
            return $this;
        }
        elseif (is_array($library))
        {
            foreach ($library as $key => $value)
            {
                if (is_int($key))
                {
                    $this->library($value, $params);
                }
                else
                {
                    $this->library($key, $params, $value);
                }
            }
 
            return $this;
        }
 
        if ($params !== NULL && ! is_array($params))
        {
            $params = NULL;
        }
 
        $this->_ci_load_library($library, $params, $object_name);
        return $this;
    }
 
    // --------------------------------------------------------------------

        }
 
        // Autoload drivers
        if (isset($autoload['drivers']))
        {
            $this->driver($autoload['drivers']);
        }
 
        // Load libraries
        if (isset($autoload['libraries']) && count($autoload['libraries']) > 0)
        {
            // Load the database driver.
            if (in_array('database', $autoload['libraries']))
            {
                $this->database();
                $autoload['libraries'] = array_diff($autoload['libraries'], array('database'));
            }
 
            // Load all other libraries
            $this->library($autoload['libraries']);
        }
 
        // Autoload models
        if (isset($autoload['model']))
        {
            $this->model($autoload['model']);
        }
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Prepare variables for _ci_vars, to be later extract()-ed inside views
     *
     * Converts objects to associative arrays and filters-out internal
     * variable names (i.e. keys prefixed with '_ci_').
     *
     * @param    mixed    $vars
     * @return    array
     */

        $this->_ci_ob_level = ob_get_level();
        $this->_ci_classes =& is_loaded();
 
        log_message('info', 'Loader Class Initialized');
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Initializer
     *
     * @todo    Figure out a way to move this to the constructor
     *        without breaking *package_path*() methods.
     * @uses    CI_Loader::_ci_autoloader()
     * @used-by    CI_Controller::__construct()
     * @return    void
     */
    public function initialize()
    {
        $this->_ci_autoloader();
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Is Loaded
     *
     * A utility method to test if a class is in the self::$_ci_classes array.
     *
     * @used-by    Mainly used by Form Helper function _get_validation_object().
     *
     * @param     string        $class    Class name to check for
     * @return     string|bool    Class object name if loaded or FALSE
     */
    public function is_loaded($class)
    {
        return array_search(ucfirst($class), $this->_ci_classes, TRUE);
    }
 
    // --------------------------------------------------------------------

 
    /**
     * Class constructor
     *
     * @return    void
     */
    public function __construct()
    {
        self::$instance =& $this;
 
        // Assign all the class objects that were instantiated by the
        // bootstrap file (CodeIgniter.php) to local class variables
        // so that CI can run as one big super object.
        foreach (is_loaded() as $var => $class)
        {
            $this->$var =& load_class($class);
        }
 
        $this->load =& load_class('Loader', 'core');
        $this->load->initialize();
        log_message('info', 'Controller Class Initialized');
    }
 
    // --------------------------------------------------------------------
 
    /**
     * Get the CI singleton
     *
     * @static
     * @return    object
     */
    public static function &get_instance()
    {
        return self::$instance;
    }
 
}
 

<?php
defined('BASEPATH') OR exit('No direct script access allowed');
 
class Home extends CI_Controller {
 
    public function __construct()
    {
        parent::__construct();
        if($this->global_pref->siteMaintenance())
        {
            redirect('maintenance-mode');
            exit();
        }
 
        if($this->session->userdata('cusLogged')) {
            $status_stage = $this->session->userdata('cus_status');
            $cus_username = $this->session->userdata('cus_username');
 
            if($status_stage != 1) {
                redirect('blocked-status');
            }
        }
    }
 
    public function index()
    {
        if($view['set_fresh_cat'] = $this->Shop_sections_model->fresh_categories()) {
            $tot_fresh_cat = $view['set_fresh_cat']->show_limit;
            $view['top_cats'] = $this->Main_category_model->fresh_cats($tot_fresh_cat);
        }
        $view['cus_user'] = $this->session->userdata('cus_username');
        $mine = $view['cus_user'];
        $view['cus_pages'] = $this->Pages_model->list_pages();
        if($this->session->userdata('cus_id')) {
            $uid = $this->session->userdata('cus_id');
            $view['wishlists'] = $this->Customer_wishlist_model->profileList($uid);
            $view['carts'] = $this->Customer_account_model->loadCarts($uid);
        } else {
            $view['wishlists'] = NULL;
        }

    {
        $params = array_slice($URI->rsegments, 2);
    }
 
/*
 * ------------------------------------------------------
 *  Is there a "pre_controller" hook?
 * ------------------------------------------------------
 */
    $EXT->call_hook('pre_controller');
 
/*
 * ------------------------------------------------------
 *  Instantiate the requested controller
 * ------------------------------------------------------
 */
    // Mark a start point so we can benchmark the controller
    $BM->mark('controller_execution_time_( '.$class.' / '.$method.' )_start');
 
    $CI = new $class();
 
/*
 * ------------------------------------------------------
 *  Is there a "post_controller_constructor" hook?
 * ------------------------------------------------------
 */
    $EXT->call_hook('post_controller_constructor');
 
/*
 * ------------------------------------------------------
 *  Call the requested method
 * ------------------------------------------------------
 */
    call_user_func_array(array(&$CI, $method), $params);
 
    // Mark a benchmark end point
    $BM->mark('controller_execution_time_( '.$class.' / '.$method.' )_end');
 
/*
 * ------------------------------------------------------

 
    if (($_temp = realpath($view_folder)) !== FALSE)
    {
        $view_folder = $_temp.DIRECTORY_SEPARATOR;
    }
    else
    {
        $view_folder = rtrim($view_folder, '/\\').DIRECTORY_SEPARATOR;
    }
 
    define('VIEWPATH', $view_folder);
 
/*
 * --------------------------------------------------------------------
 * LOAD THE BOOTSTRAP FILE
 * --------------------------------------------------------------------
 *
 * And away we go...
 */
require_once BASEPATH.'core/CodeIgniter.php';