lundi 6 juillet 2009

Exécution avec des backticks en PHP

Publié par Infinite Loop, à 16 h 44 0 commentaire

En lisant un exemple de code source PHP qui démontrait comment récupérer le process id (pid) d'un processus roulant sur un serveur Linux, j'ai découvert une notation que je ne soupçonnais pas. En me référant à la documentation PHP, j'ai vu qu'on pouvait substituer l'appel à la fonction shell_exec() par l'opérateur backtick (``). Attention, ce n'est pas une erreur de typo, c'est bel et bien le caractère pour les accents graves (ALT+96 sur le clavier numérique) et non des guillemets simples.

Les deux instructions suivantes sont équivalentes :

$pid = `pidof firefox`;

$pid = shell_exec('pidof firefox');

echo $pid; // 3216

# voir ps -A pour obtenir la liste de tous les processus

Même si je connais maintenant cette alternative, je crois que je vais quand même préférer utiliser la notation qui facilitera le plus la compréhension au moment de relire le code dans un futur plus ou moins rapproché (à moins bien sûr de laisser un commentaire concernant le backtick pour éclairer le prochain programmeur qui y mettera son nez).

Tags: Linux, PHP

dimanche 5 juillet 2009

Ne volez pas cette regex de courriel !

Publié par Infinite Loop, à 10 h 56 2 commentaires

Pour valider une adresse électronique avec une expression régulière compatible Perl (PCRE), on pourrait supposer qu'une regex comme celle-ci suffirait :

[\w-]+@([\w-]+\.)+[\w-]+

Cependant, ça pourrait être beaucoup plus complexe ! En effet, si on veut respecter le standard RFC822, on devrait valider beaucoup plus d'éléments et ses restrictions :

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

Comme disait Jeffrey Friedl, la taille de la regex n'a rien à voir avec son efficacité. Elle permet simplement de déterminer plus rapidement si le match est un succès ou un échec.

Malheureusement, on ne peut pas se fier à cette longue expression pour valider les courriels. Elle respecte la définition officielle de la syntaxe d'une adresse électronique définie en 1982 donc avant même l'apparition d'Internet tel qu'on le connaît aujourd'hui. Elle a depuis été remplacée par le RFC5322.

La regex suivante pourrait être plus appropriée pour valider un courriel :

^[^0-9][a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)*[@][a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)*[.][a-zA-Z]{2,4}$

Rappelez-vous que même en composant l'expression la plus précise, cela ne vous garantira pas que l'adresse existe.

Tags: Perl, PHP, Programmation

Citation no. 37 sur le doute

Publié par Infinite Loop, à 08 h 41 0 commentaire

When in doubt, use brute force

- Ken Thompson

Tags: Citations

samedi 4 juillet 2009

Instruction GOTO de PHP 5.3

Publié par Infinite Loop, à 19 h 32 0 commentaire

L'arrivée officielle de PHP 5.3 annonce aussi l'apparition de l'instruction controversée "goto". Certains l'apprécient, d'autres la détestent, mais une chose est sûre, c'est qu'on devra traiter avec elle à l'avenir.

Présent dans plusieurs autres langages, le programmeur qui voudra utiliser GOTO pourra le faire en indiquant une étiquette (label) où le script fera le saut à l'endroit spécifié dans le code pour poursuivre l'exécution. Heureusement, le goto de PHP est restrictif : le saut et le label d'arrivée doivent se trouver dans le même fichier et le même contexte pour que ça fonctionne. L'utilisation suggérée est de faire un bris (break) à l'intérieur de boucles imbriquées:

for($i=0,$j=50; $i<100; $i++) {
   while($j--) {
       if($j==17) goto end;
   }
}
echo "i = $i";
end:
echo 'j hit 17';

Toutefois, bien que ça puisse rendre service dans certaines circonstances, l'apparition de cette commande présente aussi un côté négatif : certains développeurs risquent d'en abuser. Non seulement le résultat devient du code spaghetti, il ne sera pas compatible avec les plus vieilles versions de PHP et sera plus difficile à suivre. D'ailleurs, il y a un excellent comic à lire à ce sujet sur xkcd.

Comme le mentionnait Johannes Schlüter (release manager pour la version PHP 5.3), il existe au moins deux cas où ça peut être pratique:

dans un générateur de code
pour annuler l'exécution d'une portion de code tout en s'assurant d'effectuer le nettoyage à la fin

function process_file($filename) {
   $fp = fopen($filename, "r");
   if (!$fp) {
       goto cleanup;
   }

   $row = fread($fp, 1024);
   // do something with the row
   if ($error_while_processing) {
       goto cleanup;
   }

   $a_few_bytes = fread($fp, 4);
   // do something again ...
   if ($error_while_processing) {
       goto cleanup;
   }

   /* ... */cleanup:
   fclose($fp);
}

Gardez en tête que c'est présent mais surtout, évitez de l'utiliser le plus possible, sauf en cas d'extrême nécessité. Il y a toujours une autre approche possible (il suggère un break ou un try/catch).

Tags: PHP

vendredi 3 juillet 2009

Cacher un fichier dans une image

Publié par Infinite Loop, à 20 h 21 0 commentaire

Voici un truc simple pour cacher un fichier à l'intérieur d'une image. Le fichier sera incorporé au coeur du code binaire de l'image ce qui aura pour effet qu'elle pourra être vue normalement suite à la fusion, sans se douter qu'elle contient un fichier!

D'abord, choisissez une image (j'ai essayé avec succès un JPG et un PNG)
Identifiez un fichier à cacher (j'ai essayé avec un PDF)
Pour simplifier l'opération, regroupez vos fichiers dans le même répertoire
Ouvrez un invite de commande (Start / Run / cmd)
Rendez-vous au dossier où vous avez placé les fichiers
Lancez la copie en mode binaire (/b) :

copy /b image-originale.jpg + document.pdf image-injectee.jpg

où on additionne les fichiers avec l'opérateur + pour créer en sortie le fichier image-injectee.jpg
Vous pouvez ouvrir la nouvelle image normalement. Vous remarquerez que sa taille est plus élevée en raison du fichier dissimulé

Pour récupérer le fichier, il suffit de renommer l'extension .jpg par .rar et d'ouvrir l'archive avec WinRar pour l'extraire.

Après l'injection, j'ai réussi à convertir le format de l'image trafiquée avec ImageMagick mais la récupération du fichier caché fût impossible par la suite (évidemment). J'aurais aimé vous fournir le résultat ici pour que vous puissez le constater mais comme Blogger redimentionne les images automatiquement au moment du transfert, vous n'aurez pas le choix de le tester par vous-même.

Tags: Sécurité

jeudi 2 juillet 2009

Obtenir le statut d'exécution d'une requête PostgreSQL

Publié par Infinite Loop, à 19 h 31 0 commentaire

Vous savez que lorsqu'on exécute un énoncé SQL, le serveur répond habituellement avec un message indiquant le nombre d'enregistrements qui ont été affectés par la requête.

Sur PostgreSQL, si on utilise un éditeur comme pgAdmin III, on peut voir le statut dans l'onglet Message de l'Output Pane.

Avec une table comme celle-ci (excusez mon exemple simpliste) :

CREATE TABLE tbl
(
   id serial NOT NULL,
   title character varying(255)
)

Si on effectue une mise à jour en lot (mieux connu sous le nom de "batch update") ou une insertion de plusieurs enregistrements à partir du même énoncé :

INSERT INTO tbl(title)
VALUES ('ABC'), ('DEF'), ('XYZ');

-- OU

UPDATE tbl
SET title = lower(title);

On verra apparaître un statut semblable au suivant :

Query returned successfully: 3 rows affected, 31 ms execution time.

Qu'est-ce qu'on peut faire si on veut récupérer le nombre d'enregistrements affectés par la commande (comme ce fût le cas pour moi aujourd'hui) ?

Il suffit de faire exécuter la requête SQL à l'intérieur d'une fonction PostgreSQL et d'utiliser immédiatement après une instruction du langage PL/pgSQL qu'on attribue à une variable.

CREATE OR REPLACE FUNCTION insert_some_rows() RETURNS integer AS
$BODY$
DECLARE
   cnt integer;
BEGIN
   UPDATE tbl
   SET title = lower(title);

   // c'est ici que ça se passe
   GET DIAGNOSTICS cnt := ROW_COUNT;

   RETURN cnt;
END
$BODY$
LANGUAGE 'plpgsql' VOLATILE

Tags: PostgreSQL

mercredi 1 juillet 2009

Partager des librairies entre plusieurs projets

Publié par Infinite Loop, à 11 h 44 0 commentaire

Quand on possède un serveur de production qui héberge plusieurs projets web qu'on a nous-même développé, on a tendance à dupliquer les librairies d'un projet à l'autre, que ce soit le volumineux Zend Framework ou tout simplement des librairies JavaScript utiles comme jQuery ou Prototype.

Sans compter l'espace occupé par la duplication des fichiers, qu'arrive-t-il lorsque vient le temps de mettre à jour les versions ? On doit nécessairement appliquer les changements à chaque projet.

Il existe une façon de le faire d'un seul coup pour en faire bénéficier tout le monde en partageant les librairies. Mais ceci nécessitera quelques configurations au niveau du serveur Apache et de PHP.

Dans le fichier de configuration d'Apache httpd.conf, assurez-vous que le module mod_alias soit activé :

LoadModule alias_module modules/mod_alias.so
Créez un alias :

Linux :
Alias /shared chemin/vers/répertoire/partagé/

Windows :
Alias /shared "D:/répertoire/partagé/"

Lorsque le serveur reconnaîtra l'alias /shared, il résoudra automatiquement vers le chemin spécifié comme deuxième argument. Dans nos pages web, on pourra faire référence à une librairie comme ceci :

<script type="text/javascript" src="shared/jquery/jquery-1.3.2.min.js"></script>

Jusqu'à maintenant, nous avons solutionné la première partie du problème. En effet, les deux premières étapes permettent de résoudre tout ce qui est statique (applicable aux fichiers JavaScript, images, etc). À partir d'ici, nous verrons comment résoudre ce qui se passe côté serveur.

Le truc : passer par un include path que nous attacherons automatiquement à tous nos fichiers grâce à l'instruction prepend file.

Créer un fichier prepend.php qui contiendra les trois lignes suivantes :

<?php
$path = 'chemin/vers/librairies/php/';
set_include_path(get_include_path() . PATH_SEPARATOR . $path);
- Indiquez le chemin vers votre/vos librairie(s) à partager, par exemple le Zend Framework.
- Ne fermez pas la balise PHP! Ceci évitera qu'un espace ou un saut de ligne se retrouve envoyé par erreur dans les headers de vos autres fichiers PHP.
- Il est important d'utiliser get_include_path() pour conserver les anciens chemins définis ailleurs dans l'application, autrement nous écraserions la liste qui ne contiendrait que $path.
Déposez le fichier prepend.php sur le serveur
Maintenant, il faut donner l'instruction à PHP d'inclure prepend.php à chaque fois qu'un fichier PHP est appelé. Nous avons deux choix : soit l'inclure de façon globale dans php.ini, soit le mettre dans chaque projet par le fichier .htaccess.

php.ini :
auto_prepend_file /chemin/vers/prepend.php

.htaccess :
php_value auto_prepend_file /chemin/vers/prepend.php

À partir de maintenant, vous devriez être capable d'inclure des librairies PHP partagées. Par exemple, si votre répertoire partagé contient le Zend Framework, vous devriez pouvoir l'inclure comme s'il faisait réellement parti de votre projet :

require_once('Zend/Mail.php');

Pour être certain que tout fonctionne correctement, assurez-vous de bien tester cette configuration sur un serveur de développement.

Enfin, pour chaque composant, je vous recommande de toujours créer un répertoire /latest/ qui contiendra la version la plus récente de la librairie. Lorsque vous développerez, vous pourrez y référer plutôt qu'à une version spécifique et il sera beaucoup plus facile de mettre à jour tous vos sites en même temps.

Tags: Apache, PHP

Exécution avec des backticks en PHP

Ne volez pas cette regex de courriel !

Citation no. 37 sur le doute

Instruction GOTO de PHP 5.3

Cacher un fichier dans une image

Obtenir le statut d'exécution d'une requête PostgreSQL

Partager des librairies entre plusieurs projets

Catégories

Divers

Archives

Abonnés