Request.php

Go to the documentation of this file.

<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */

namespace Xoops\Core;

use Xoops\Core\FilterInput;

class Request
{

    const NOTRIM    = 1;
    const ALLOWRAW  = 2;
    const ALLOWHTML = 4;

    public static function getMethod()
    {
        $method = strtoupper($_SERVER['REQUEST_METHOD']);

        return $method;
    }

    public static function getVar($name, $default = null, $hash = 'default', $type = 'none', $mask = 0)
    {
        // Ensure hash and type are uppercase
        $hash = strtoupper($hash);
        if ($hash === 'METHOD') {
            $hash = self::getMethod();
        }
        $type = strtoupper($type);

        // Get the input hash
        switch ($hash) {
            case 'GET':
                $input = &$_GET;
                break;
            case 'POST':
                $input = &$_POST;
                break;
            case 'FILES':
                $input = &$_FILES;
                break;
            case 'COOKIE':
                $input = &$_COOKIE;
                break;
            case 'ENV':
                $input = &$_ENV;
                break;
            case 'SERVER':
                $input = &$_SERVER;
                break;
            default:
                $input = &$_REQUEST;
                $hash = 'REQUEST';
                break;
        }

        if (isset($input[$name]) && $input[$name] !== null) {
            // Get the variable from the input hash and clean it
            $var = self::cleanVar($input[$name], $mask, $type);

            // Handle magic quotes compatability
            if (get_magic_quotes_gpc() && ($var != $default) && ($hash != 'FILES')) {
                $var = self::stripSlashesRecursive($var);
            }
        } else {
            if ($default !== null) {
                // Clean the default value
                $var = self::cleanVar($default, $mask, $type);
            } else {
                $var = $default;
            }
        }

        return $var;
    }

    public static function getInt($name, $default = 0, $hash = 'default')
    {
        return self::getVar($name, $default, $hash, 'int');
    }

    public static function getFloat($name, $default = 0.0, $hash = 'default')
    {
        return self::getVar($name, $default, $hash, 'float');
    }

    public static function getBool($name, $default = false, $hash = 'default')
    {
        return self::getVar($name, $default, $hash, 'bool');
    }

    public static function getWord($name, $default = '', $hash = 'default')
    {
        return self::getVar($name, $default, $hash, 'word');
    }

    public static function getCmd($name, $default = '', $hash = 'default')
    {
        return self::getVar($name, $default, $hash, 'cmd');
    }

    public static function getString($name, $default = '', $hash = 'default', $mask = 0)
    {
        // Cast to string, in case self::ALLOWRAW was specified for mask
        return (string) self::getVar($name, $default, $hash, 'string', $mask);
    }

    public static function getArray($name, $default = array(), $hash = 'default')
    {
        return self::getVar($name, $default, $hash, 'array');
    }

    public static function getText($name, $default = '', $hash = 'default')
    {
        return (string) self::getVar($name, $default, $hash, 'string', self::ALLOWRAW);
    }

    public static function getUrl($name, $default = '', $hash = 'default')
    {
        return (string) self::getVar($name, $default, $hash, 'weburl');
    }

    public static function getPath($name, $default = '', $hash = 'default')
    {
        return (string) self::getVar($name, $default, $hash, 'path');
    }

    public static function getEmail($name, $default = '', $hash = 'default')
    {
        $ret = (string) self::getVar($name, $default, $hash, 'email');
        return empty($ret) ? $default : $ret;
    }

    public static function getIP($name, $default = '', $hash = 'default')
    {
        $ret = (string) self::getVar($name, $default, $hash, 'ip');
        return empty($ret) ? $default : $ret;
    }

    public static function setVar($name, $value = null, $hash = 'method', $overwrite = true)
    {
        $hash = strtoupper($hash);
        if ($hash === 'METHOD') {
            $hash = strtoupper($_SERVER['REQUEST_METHOD']);
        }

        // Get the requested hash and determine existing value
        $original = self::get($hash, self::ALLOWRAW);
        if (isset($original[$name])) {
            $previous = $original[$name];
            // don't overwrite value unless asked
            if (!$overwrite) {
                return $previous;
            }
        } else {
            $previous = null;
        }

        // set the value
        switch ($hash) {
            case 'GET':
                $_GET[$name] = $value;
                $_REQUEST[$name] = $value;
                break;
            case 'POST':
                $_POST[$name] = $value;
                $_REQUEST[$name] = $value;
                break;
            case 'REQUEST':
                $_REQUEST[$name] = $value;
                break;
            case 'COOKIE':
                $_COOKIE[$name] = $value;
                $_REQUEST[$name] = $value;
                break;
            case 'FILES':
                $_FILES[$name] = $value;
                break;
            case 'ENV':
                $_ENV['name'] = $value;
                break;
            case 'SERVER':
                $_SERVER['name'] = $value;
                break;
        }

        return $previous;
    }

    public static function get($hash = 'default', $mask = 0)
    {
        $hash = strtoupper($hash);

        if ($hash === 'METHOD') {
            $hash = strtoupper($_SERVER['REQUEST_METHOD']);
        }

        switch ($hash) {
            case 'GET':
                $input = $_GET;
                break;
            case 'POST':
                $input = $_POST;
                break;
            case 'FILES':
                $input = $_FILES;
                break;
            case 'COOKIE':
                $input = $_COOKIE;
                break;
            case 'ENV':
                $input = &$_ENV;
                break;
            case 'SERVER':
                $input = &$_SERVER;
                break;
            default:
                $input = $_REQUEST;
                break;
        }

        // Handle magic quotes compatability
        if (get_magic_quotes_gpc() && ($hash != 'FILES')) {
            $input = self::stripSlashesRecursive($input);
        }

        $result = self::cleanVars($input, $mask);

        return $result;
    }

    public static function set($array, $hash = 'default', $overwrite = true)
    {
        foreach ($array as $key => $value) {
            self::setVar($key, $value, $hash, $overwrite);
        }
    }

    private static function cleanVar($var, $mask = 0, $type = null)
    {
        // Static input filters for specific settings
        static $noHtmlFilter = null;
        static $safeHtmlFilter = null;

        // convert $var in array if $type is ARRAY
        if (strtolower($type) == 'array' && !is_array($var)) {
            $var = array($var);
        }

        // If the no trim flag is not set, trim the variable
        if (!($mask & 1) && is_string($var)) {
            $var = trim($var);
        }

        // Now we handle input filtering
        if ($mask & 2) {
            // If the allow raw flag is set, do not modify the variable
        } else {
            if ($mask & 4) {
                // If the allow html flag is set, apply a safe html filter to the variable
                if (is_null($safeHtmlFilter)) {
                    $safeHtmlFilter = FilterInput::getInstance(null, null, 1, 1);
                }
                $var = $safeHtmlFilter->clean($var, $type);
            } else {
                // Since no allow flags were set, we will apply the most strict filter to the variable
                if (is_null($noHtmlFilter)) {
                    $noHtmlFilter = FilterInput::getInstance();
                }
                $var = $noHtmlFilter->clean($var, $type);
            }
        }

        return $var;
    }

    private static function cleanVars($var, $mask = 0, $type = null)
    {
        if (is_string($var)) {
            $var = self::cleanVar($var, $mask, $type);
        } else {
            foreach ($var as $key => &$value) {
                $value = self::cleanVars($value, $mask, $type);
            }
        }

        return $var;
    }


    private static function stripSlashesRecursive($value)
    {
        $value = is_array($value) ? array_map(array('Xoops\Core\Request', 'stripSlashesRecursive'), $value)
            : stripslashes($value);

        return $value;
    }
}