PHP Fonction pt_register

Question

Je suis un débutant avec PHP, je suis exposé à des formulaires HTML traitées et je suis d'apprendre à l'utiliser pour faire de plus en plus ...

J'utilise cette fonction (et basé sur Google sont donc beaucoup de gens) mais je veux vraiment comprendre ce qu'il fait ....

function pt_register() 
{ 
    $num_args = func_num_args(); 
    $vars = array(); 

    if ($num_args >= 2) { 
     $method = strtoupper(func_get_arg(0)); 

     if (($method != 'SESSION') && ($method != 'GET') && ($method != 'POST') && ($method != 'SERVER') && ($method != 'COOKIE') && ($method != 'ENV')) { 
      die('The first argument of pt_register must be one of the following: GET, POST, SESSION, SERVER, COOKIE, or ENV'); 
    } 

     $varname = "HTTP_{$method}_VARS"; 
     global ${$varname}; 

     for ($i = 1; $i < $num_args; $i++) { 
      $parameter = func_get_arg($i); 

      if (isset(${$varname}[$parameter])) { 
       global $$parameter; 
       $$parameter = ${$varname}[$parameter]; 
      } 

     } 

    } else { 
     die('You must specify at least two arguments'); 
    } 

} 

quelqu'un peut-il marcher à travers cela en anglais pour moi?

Answer 1

On dirait qu'il essaie d'être un remplacement pour register_globals

function pt_register() 
{ 
    // Look at the arguments passed in... 
    $num_args = func_num_args(); 
    $vars = array(); 

    // .. we need at least 2 arguments 
    if ($num_args >= 2) { 

     // $method is the middle part of name of one of PHPs old-style variables 
     $method = strtoupper(func_get_arg(0)); 

     if (($method != 'SESSION') && ($method != 'GET') && ($method != 'POST') && ($method != 'SERVER') && ($method != 'COOKIE') && ($method != 'ENV')) { 
      die('The first argument of pt_register must be one of the following: GET, POST, SESSION, SERVER, COOKIE, or ENV'); 
    } 

     // $varname is the whole name of the variable 
     $varname = "HTTP_{$method}_VARS"; 

     // Make the global variable (for example HTTP_SESSION_VARS) accessible from this function 
     // ${$varname} is using a technique called "variable variables" 
     // If $varname == "HTTP_SESSION_VARS" then $$varname (or ${$varname}) is the same as $HTTP_SESSION_VARS 
     global ${$varname}; 

     // For each argument after the method 
     for ($i = 1; $i < $num_args; $i++) { 
      $parameter = func_get_arg($i); 

      // If the parameter exists in the global variable... 
      if (isset(${$varname}[$parameter])) { 
       // .. make it global... 
       global $$parameter; 
       // ... and set its value 
       $$parameter = ${$varname}[$parameter]; 
      } 

     } 

    } else { 
     die('You must specify at least two arguments'); 
    } 

} 

Ainsi, un exemple: pt_register('SESSION', 'foo'); fait, en effet

function example() 
{ 
    global $HTTP_SESSION_VARS; 
    global $foo; 
    $foo = $HTTP_SESSION_VARS['foo']; 
} 

à mon humble avis, ce script est obsolète et le mal! superglobales _SESSION $ etc signifie que vous ne devriez pas faire ce

Answer 2

On dirait qu'il est l'extraction de variables stockées dans des tableaux comme $ _POST et $ _GET et de les rendre globale, donc au lieu d'accéder à une variable de poste avec $_POST['var'], vous pouvez il suffit d'utiliser $var. Il n'y a pas vraiment de bonne raison pour cela, et cela ouvre des failles de sécurité inutiles si vous oubliez de nettoyer correctement les entrées. Par exemple:

if (/* some condition */) 
    $admin = true; 

... 

if ($admin) 
{ 
    //do powerful stuff here 
} 

cela pourrait être rompu par un utilisateur malveillant d'appeler la page avec quelque chose comme

page.php?admin=1 

Answer 3

Ow my,
qui ressemble à un code de snipped qui remplace le paramètre register_globals dépréciée.

Retour en PHP4, tous les types d'arguments générés par l'utilisateur sont générés directement en tant que variables dans votre oscilloscope.
En clair, cela signifie qu'un appel à index.php?test=helloWorld entraînerait

<?php 
    echo "$test<br/>"; 
?> 

délivrer en sortie:

helloWorld<br/> 

Ceci est considéré pour les programmeurs d'être une chance maire de se tirer dans le pied. il a depuis été aboli. Et pour une bonne raison.

Consultez le code suivant:

<?php 

if (isAuthorised($userId, $sessionId)) { 
    $hasAccess = true; 
} 
// some lines 
// of code... 

if ($hasAccess) { 
    echo 'sensitive information'; 
} 

?> 

et ce que whould passerait-il si vous appelez cela avec index.php?hasAccess=1
C'est vrai, la mauvaise personne appelant votre script vient de gagner l'accès à la partie qui est réservée aux utilisateurs autorisés seulement.

En résumé
Il est une fonction qui imite le comportement des fonctionnalités qui ne sont plus utilisés (PHP5) parce qu'il a été considéré comme un risque majeur de sécurité.

Au lieu d'utiliser le code ci-dessus, vous devez accéder à l'utilisateur fourni des arguments tels que

<?php 
    echo $_GET['test'].'<br />'; 
?> 

Hope this helps :)

Answer 4

Je ne sais absolument pas pourquoi on voudrait utiliser cette fonction. Il copie essentiellement les variables de la session, de la requête ou de l'environnement vers l'espace de noms global.

Comment l'utilisez vous? Si vous souhaitez accéder à des champs de formulaire, utilisez $ _POST:

$value = $_POST['value']; 

Au lieu de:

pt_register('POST', 'value'); 

Answer 5

Fondamentalement, il est fonction de prendre des variables sur des tableaux globaux prédéfinis _SESSION $, $ _GET, $ _POST, $ _SERVER, $ _COOKIE et $ _ENV et les déplacez dans des variables globales avec des noms équivalents. Par exemple, si vous avez chargé la page "test.php? Value = 5", vous y accéderez normalement via $ _GET ["value"]. Cependant, vous pouvez appeler:

pt_register('GET', 'value'); 

Et cela va créer une variable globale appelée valeur de $ mis à 5. Il accepte un certain nombre d'arguments du même tableau global, donc pour une page « test.php value =? 5 & another_value = 6 & yet_another_value = 7" vous pouvez faire:

pt_register('GET', 'value', 'another_value', 'yet_another_value'); 

pour avoir une valeur de $, another_value de $ et yet_another_value $ tous créés et attribués aux valeurs qu'ils ont été donnés dans l'URL. Comme RoBorg l'a dit, il fait un travail similaire à l'ancien register_globals, mais il vous donne un peu plus de contrôle sur les variables qui sont définies.

Answer 6

function pt_register() 
{ 
    $num_args = func_num_args(); // Get the number of arguments passed to this function 
    $vars = array(); 

    if ($num_args >= 2) { 
     $method = strtoupper(func_get_arg(0)); 
     // if the number of arguments is larger than or equal to 2, get the first one and make it uppercase, assign it to the varible $method 

     if (($method != 'SESSION') && ($method != 'GET') && ($method != 'POST') && ($method != 'SERVER') && ($method != 'COOKIE') && ($method != 'ENV')) { 
      die('The first argument of pt_register must be one of the following: GET, POST, SESSION, SERVER, COOKIE, or ENV'); 
    } 
     // check if $method = GET, POST, SESSION, SERVER, COOKIE, or ENV' if not, die and kill the script 

     $varname = "HTTP_{$method}_VARS"; 
     /* assign the method to the var name 
     * i.e. HTTP_GET_VARS, HTTP_POST_VARS etc 
     */ 

     global ${$varname}; 
     // put the varible into the global varibles 

     for ($i = 1; $i < $num_args; $i++) { // iterate through the arguments 
      $parameter = func_get_arg($i); // assign to parameter 

      if (isset(${$varname}[$parameter])) { 
       // check if a parameter is set in the HTTP var array 
       // i.e HTTP_GET_VARS[$parameter] 
       global $$parameter; 
       //assign the varible name of parameter to the varible name 
       // say parameter was 'content', create a varible named 'content' and make it global 
       $$parameter = ${$varname}[$parameter]; 
       // update the parameter to match its value in the HTTP vars array 
       // i.e $content = HTTP_GET_VARS['content']; 
      } 

     } 


    } else { 
     die('You must specify at least two arguments'); 
    } 

} 

Answer 7

Trop de réponses utiles pour les commenter, alors je vais répondre à mes propres questions avec un grand MERCI.

Dans mes formes les plus récentes, j'ai écrit mon propre script de traitement au format suggéré par Ferdinand.

$ value = $ _POST ['valeur']; Je regardais des choses plus anciennes, encore en cours d'utilisation, et j'essayais de comprendre ce qu'il faisait, et pourquoi, pour déterminer si je prenais un raccourci dangereux dans mon nouveau code. En fait, le contraire est vrai et j'ai besoin de mettre à jour l'ancien code pour utiliser la même approche que celle que j'utilise maintenant ... et tout ce qui doit être réparé doit être corrigé d'une autre manière. Les problèmes de sécurité de Globals ne me sont pas perdus. Il est très surprenant que dans 20 pages de résultats de Google pour "pt_register", j'ai trouvé des tonnes de personnes utilisant exactement la même fonction (je me demande d'où il venait) et aucune mention de ses risques inhérents/evilness.

Merci à tous pour les réponses instantanées et les informations utiles. Ce site a un nouveau fan.

Answer 8

Les gens qui ont dit que c'est un remplacement pour les globals de registre sont sur la bonne voie, mais ce n'est pas tout à fait ce qui se passe.

À l'époque où les dinosaures parcouraient Internet, PHP n'avait pas de $ _POST, $ _GET, $ _COOKIE, $ _SESSION, $ _SERVER, $ _ETC super globals. Au lieu de cela (en plus des register globals infâmes), il y avait des tableaux globaux réguliers nommés

$HTTP_GET_VARS 
$HTTP_POST_VARS 
$HTTP_SERVER_VARS 
etc.. 

Ces tableaux, en plus d'avoir des noms longs unweildy, nécessaires pour être déclarée mondiale (ils wern't « super/automatique comme gLOBALS $ _POST, $ _GET, etc.) avant d'être utilisé.

Qu'est-ce que pt_regsiter ne vous permettent d'exporter est une variable individuelle d'un de ces tableaux dans l'environnement global. Ainsi, au lieu d'écrire

global  $HTTP_SERVER_VARS 
global  $php_self; 
$php_self = $HTTP_SERVER_VARS['PHP_SELF'] 

Vous pourriez écrire.

pt_register('SERVER','PHP_SELF'); 

Et vous auriez une variable $ php_self dans la portée globale.

D'autres ont déjà commenté la mécanique spécifique, donc je vais conclure en disant qu'il serait stupide d'utiliser cette fonction aujourd'hui. Cependant, il semblerait que cela provienne du code GNU back in 2002. Étant donné que PHP3 était encore largement utilisé (les gens étaient en transition vers PHP4), cette fonction avait du sens.

La plupart des modèles de codage autour de PHP à l'époque reposaient sur l'espace de noms global pour faire avancer les choses. Cette fonction a réellement aidé à LIMITER les problèmes avec register_globals. Selon les notes dans le lien ci-dessus, l'auteur voulait que vous désactiviez register_globals et que vous utilisiez cette fonction pour exporter UNIQUEMENT les éléments dont vous aviez besoin.

Le mal? Non. Incroyablement stupide à utiliser de nos jours? Oui

Answer 9

Il peut provenir d'ailleurs, mais il est inclus dans le code généré par phpFormGenerator.

Vous ne savez pas si la dernière version utilise un code différent, mais (beaucoup?) Les sociétés d'hébergement donnent toujours accès à l'ancien via Fantastico, c'est pourquoi il est encore largement répandu.