Wie kann ich verhindern, dass PHP Punktzeichen in GET-, POST- oder COOKIE-Namen ersetzt?

Wenn ich Anforderungsfelder oder Cookies mit einem Punkt/Punkt im Namen übergebe, ersetzt PHP diese automatisch durch Unterstriche. Wenn ich zum Beispiel diesen Code einfüge https://example.com/test.php?x.y=a.b:

<?php
echo $_SERVER['REQUEST_URI'];
echo $_GET['x.y'];
echo $_GET['x_y'];

Die Ausgabe ist:

/test.php?x.y=a.b

a.b

Gibt es beliebig Wie kann ich dieses Verhalten verhindern?

Hier ist die Erklärung von PHP.net, warum das so ist:

Punkte in eingehenden Variablennamen

Normalerweise ändert PHP die Namen von Variablen nicht, wenn sie an ein Skript übergeben werden. Es ist jedoch zu beachten, dass der Punkt (Punkt, Punkt) kein gültiges Zeichen in einem PHP-Variablennamen ist. Schauen Sie sich den Grund dafür an:

<?php
$varname.ext;  /* invalid variable name */
?>

Was der Parser nun sieht, ist eine Variable mit dem Namen $varname, gefolgt vom String-Verkettungsoperator, gefolgt vom Barestring (dh einem String ohne Anführungszeichen, der keinem bekannten Schlüssel oder reservierten Wort entspricht) „ext“. Offensichtlich hat dies nicht das beabsichtigte Ergebnis.

Aus diesem Grund ist es wichtig zu beachten, dass PHP alle Punkte in eingehenden Variablennamen automatisch durch Unterstriche ersetzt.

Das ist von http://ca.php.net/variables.external.

Auch gem dieser Kommentar Diese anderen Zeichen werden in Unterstriche umgewandelt:

Die vollständige Liste der Feldnamenszeichen, die PHP in _ (Unterstrich) umwandelt, ist die folgende (nicht nur ein Punkt):

• chr(32) ( ) (Leerzeichen)
• chr(46) (.) (Punkt)
• chr(91) ([) (open square bracket)
• chr(128) – chr(159) (various)

So it looks like you’re stuck with it, so you’ll have to convert the underscores back to dots in your script using dawnerd’s suggestion (I’d just use str_replace though.)

Long-since answered question, but there is actually a better answer (or work-around). PHP lets you at the raw input stream, so you can do something like this:

$query_string = file_get_contents('php://input');

which will give you the $_POST array in query string format, periods as they should be.

You can then parse it if you need (as per POSTer’s comment)

<?php
// Function to fix up PHP's messing up input containing dots, etc.
// `$source` can be either 'POST' or 'GET'
function getRealInput($source) {
    $pairs = explode("&", $source == 'POST' ? file_get_contents("php://input") : $_SERVER['QUERY_STRING']);  $vars = array();  foreach ($pairs as $pair) { $nv = explosion("=", $pair);  $name = urldecode($nv[0]);  $value = urldecode($nv[1]);  $vars[$name] = $value;  } return $vars;  } // Wrapper-Funktionen speziell für GET und POST: function getRealGET() { return getRealInput('GET');  } function getRealPOST() { return getRealInput('POST');  } ?>

Äußerst nützlich für OpenID-Parameter, die sowohl „.“ als auch „.“ enthalten. und „_“, jeweils mit einer bestimmten Bedeutung!

Ich möchte eine tatsächliche Antwort von Johan in einem Kommentar oben hervorheben: Ich habe gerade meinen gesamten Beitrag in ein Array der obersten Ebene eingepackt, das das Problem vollständig umgeht, ohne dass eine umfangreiche Verarbeitung erforderlich ist.

In der Form, die Sie tun

<input name="data[database.username]">  
<input name="data[database.password]">  
<input name="data[something.else.really.deep]">  

anstatt

<input name="database.username"> 
<input name="database.password"> 
<input name="something.else.really.deep">  

und im Post-Handler packen Sie es einfach aus:

$posdata = $_POST['data'];

Für mich war dies eine zweizeilige Änderung, da meine Ansichten vollständig auf Vorlagen beruhten.

Zu Ihrer Information. Ich verwende Punkte in meinen Feldnamen, um Bäume gruppierter Daten zu bearbeiten.

Wollen Sie eine Lösung? normenkonform, und arbeitet mit tiefe Arrays (Zum Beispiel: ?param[2][5]=10) ?

Um alle möglichen Ursachen dieses Problems zu beheben, können Sie ganz oben in Ihrem PHP-Code Folgendes anwenden:

$_GET    = fix( $_SERVER['QUERY_STRING'] );
$_POST   = fix( file_get_contents('php://input') );
$_COOKIE = fix( $_SERVER['HTTP_COOKIE'] );

Die Funktionsweise dieser Funktion ist eine nette Idee, die mir während meiner Sommerferien 2013 gekommen ist. Lassen Sie sich von einer einfachen Regex nicht entmutigen, sie erfasst einfach alle Abfragenamen, codiert sie (damit Punkte erhalten bleiben) und verwendet dann einen Normalen parse_str() Funktion.

function fix($source) {
    $source = preg_replace_callback(
        '/(^|(?<=&))[^=[&]+/',
        function($key) { return bin2hex(urldecode($key[0])); },
        $source
    );

    parse_str($source, $post);
    
    $result = array();
    foreach ($post as $key => $val) {
        $result[hex2bin($key)] = $val;
    }
    return $result;
}

Dies liegt daran, dass ein Punkt ein ungültiges Zeichen im Variablennamen ist Grund Das liegt sehr tief in der PHP-Implementierung, daher gibt es (noch) keine einfachen Lösungen.

In der Zwischenzeit können Sie dieses Problem folgendermaßen umgehen:

1. Zugriff auf die rohen Abfragedaten über beides php://input für POST-Daten oder $_SERVER['QUERY_STRING'] für GET-Daten
2. Verwendung einer Konvertierungsfunktion.

Die folgende Konvertierungsfunktion (PHP >= 5.4) kodiert die Namen jedes Schlüssel-Wert-Paares in eine hexadezimale Darstellung und führt dann eine reguläre aus parse_str(); Sobald dies erledigt ist, werden die hexadezimalen Namen wieder in ihre ursprüngliche Form zurückversetzt:

function parse_qs($data)
{
    $data = preg_replace_callback('/(?:^|(?<=&))[^=[]+/', function($match) {
        return bin2hex(urldecode($match[0]));
    }, $data);

    parse_str($data, $values);

    return array_combine(array_map('hex2bin', array_keys($values)), $values);
}

// work with the raw query string
$data = parse_qs($_SERVER['QUERY_STRING']);

Oder:

// handle posted data (this only works with application/x-www-form-urlencoded)
$data = parse_qs(file_get_contents('php://input'));

Dieser Ansatz ist eine veränderte Version von Rok Kraljs, jedoch mit einigen Optimierungen, um die Effizienz zu verbessern (unnötige Rückrufe, Kodierung und Dekodierung nicht betroffener Schlüssel werden vermieden) und Array-Schlüssel korrekt zu verarbeiten.

A Kern mit Tests ist verfügbar und Feedback oder Vorschläge sind hier und da willkommen.

public function fix(&$target, $source, $keep = false) {                        
    if (!$source) {                                                            
        return;                                                                
    }                                                                          
    $keys = array();                                                           

    $source = preg_replace_callback(                                           
        '/                                                                     
        # Match at start of string or &                                        
        (?:^|(?<=&))                                                           
        # Exclude cases where the period is in brackets, e.g. foo[bar.blarg]
        [^=&\[]*                                                               
        # Affected cases: periods and spaces                                   
        (?:\.|%20)                                                             
        # Keep matching until assignment, next variable, end of string or   
        # start of an array                                                    
        [^=&\[]*                                                               
        /x',                                                                   
        function ($key) use (&$keys) {                                         
            $keys[] = $key = base64_encode(urldecode($key[0]));                
            return urlencode($key);                                            
        },                                                                     
    $source                                                                    
    );                                                                         

    if (!$keep) {                                                              
        $target = array();                                                     
    }                                                                          

    parse_str($source, $data);                                                 
    foreach ($data as $key => $val) {                                          
        // Only unprocess encoded keys                                      
        if (!in_array($key, $keys)) {                                          
            $target[$key] = $val;                                              
            continue;                                                          
        }                                                                      

        $key = base64_decode($key);                                            
        $target[$key] = $val;                                                  

        if ($keep) {                                                           
            // Keep a copy in the underscore key version                       
            $key = preg_replace('/(\.| )/', '_', $key);                        
            $target[$key] = $val;                                              
        }                                                                      
    }                                                                          
}                                                                              

Der Grund dafür ist die alte PHP-Funktionalität „register_globals“. Der . Das Zeichen ist kein gültiges Zeichen in einem Variablennamen, daher wandelt PHP es in einen Unterstrich um, um die Kompatibilität sicherzustellen.

Kurz gesagt: Es ist keine gute Praxis, Punkte in URL-Variablen einzufügen.