Discussion :

[Lcf.vs]

Bonjour à tous,

Pour commencer, je ne comprends absolument rien en C.

Pour mes besoins et parce que les extensions semblables ne sont plus maintenues, une âme charitable (stealth35) m'a développé approximativement ce dont j'ai besoin.

Il s'agit d'une extension permettant de renommer une fonction PHP (même native), au moyen de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

function_rename($old_name,$new_name);

Cette extension remplit bien son rôle, au bout de quelques fois (variable), il y a quelque chose qui coince, la fonction native que je renomme se retrouve "définitivement" renommée, (jusqu'à ce que je redémarre Apache). Vous avouerez que c'est fâcheux... :p

Le deuxième point est bien moins grave mais pas top non-plus, actuellement, je ne peux renommer ma fonction que par ^[a-z]+$ au lieu de ^[a-zA-Z_][a-zA-Z0-9_]+$

Pourriez-vous m'aider, svp? voici les sources :

[Bktero]

J'ai regardé le code et j'avoue qu'il m'est très ésotérique

Pourrais-tu en dire un peu plus sur l'utilisation de ce module ? Tu fais appel à ce qu'il contient dans du code PHP ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

function_rename($old_name,$new_name);

est une fonction PHP ?

En regardant, je ne vois pas d'endroits où il y aurait une limitation sur le format de la chaîne nommant la fonction. Pourquoi dis-tu que tu ne peux pas renommer tes fonctions ? As-tu une erreur lorsque tu essayes ? Les caractères non "reconnus" sont-ils sauvagement oubliés ?

[Lcf.vs]

Yeah, une réponse! Merci

Alors, function_rename($old_name,$new_name) est une fonction PHP définie par l'extension. C'est la seule chose qui soit exploitable, dans cette extension et, à vrai dire, je n'ai rien besoin de plus.

En gros, l'idée est d'imiter la fonction rename_function() de APD.

Pour ce qui est des caractères, dès qu'il y a une majuscule, un underscore ou un chiffre, PHP me renvoie une fatal error (nom de fonction invalide).

Pourtant, ça ne vient pas directement de PHP, puisque j'ai testé une extension semblable qui, elle, me permet tous les caractères désirés.

PS: cette autre extension génère le même bug, par contre.

[Bktero]

Je n'y connais rien de rien en PHP, ça n'aide pas.

Si j'ai bien suivi, tu as 2 soucis. Le premier est un soucis de renommage permanent et non temporaire. Pour celle-là, j'aurais bien du mal à l'expliquer. Le fait qu'une autre extension fasse la même chose laisse penser que cela ne viendrait pas des extensions.

Le second est celui des caractères possibles. Tu as lu le code comme moi, l'extension en elle-même ne semble rien faire d'autres que d'appeler des fonctions du framework Zend. La version que tu utilises est-elle à jour ? Correspond t-elle à celle utilise par le créateur de l'extension (en gros, la question sous-jacente est "l'extension a t-elle un jour marcher" ?).

On voit souvent des appels à zend_error(). Vois-tu ces messages s'afficher ou sont-ils écrits dans un quelconque fichier de logs ?

Pourrais-tu nous "montrer" l'erreur que tu obtiens ?

[Lcf.vs]

Ben, merci d'essayer tout de même, c'est moins décourageant que de rester sans réponse du tout

Le truc qui est vraiment étrange, c'est que cette modification permanente n'arrive pas à chaque fois.

J'ai bien entendu pensé que cela pouvait provenir de PHP-même, et j'ai donc posté un rapport de bug.

Sinon, concernant les mentions de Zend, apparemment, il ne s'agit pas du Framework mais bien du module Zend (interne à PHP).

Enfin, pour l'erreur, je ne saurais pas te la copier, puisque je suis en pleine compilation de PHP sur ma VM, néanmoins, je peux te dire qu'il s'agit du cas indiquant que la fonction n'a pu être trouvée.

[ok.Idriss]

Bonjour.

As-tu pu tester sur PHP en mode client sans passer par Apache ? Ça permettrai de savoir si c'est bien au niveau de PHP qu'il y a un problème ...

(Activer l’extension dans le bon php.ini qui devrait se trouver dans /etc/php5/cli sous Ubuntu/Debian).

Cordialement,
Idriss

[Lcf.vs]

C'est prévu, juste qu'étant sous Windows 7, avec Debian en VM, le tout avec 1Go de ram, sur mon netbook, la compilation d'un PHP tout neuf prend du temps...

[Bousk]

Je n'ai pas possibilité de lire le zip, le code est-il très long ou tu peux le poster directement en message ?
Ca m'intéresse à voir

edit: ha si le dl est enfin passé !

Au risque de dire une bétise, cette ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
	if(zend_hash_del(EG(function_table), orig_func, orig_func_len + 1) == FAILURE) {
		zend_error(E_WARNING, "cannot rename %s()", orig_func);
		RETURN_FALSE;
	}

ne sert-elle pas à supprimer justement l'ancienne fonction ?
Pourquoi ne pas la supprimer, et avoir du coup 2 allias d'une même fonction, est-ce que ça dérange ?

[Lcf.vs]

Bonjour,

Désolé pour le délai de réponse, je cherchais à comprendre un petit peu ce qui se passe dans ce code...

Alors, bon, pour la question du renommage, c'est réglé.

En fait, le script proposé par stealth35 renvoyait directement mon nom de fonction, tel qu'il est, alors qu'apparemment, le zend_hash_* n'accepte que des noms de fonctions en minuscules, voici donc mon rename.c actuel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_rename.h"
 
static int le_rename;
 
ZEND_BEGIN_ARG_INFO_EX(arginfo_function_rename, 0, 0, 2)
	ZEND_ARG_INFO(0, orig_func)
	ZEND_ARG_INFO(0, new_func)
ZEND_END_ARG_INFO()
 
/* {{{ rename_functions[]
 *
 * Every user visible function must have an entry in rename_functions[].
 */
const zend_function_entry rename_functions[] = {
	PHP_FE(function_rename, arginfo_function_rename)
	{NULL,NULL,NULL}
};
/* }}} */
 
/* {{{ rename_module_entry
 */
zend_module_entry rename_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
	STANDARD_MODULE_HEADER,
#endif
	"rename",
	rename_functions,
	PHP_MINIT(rename),
	PHP_MSHUTDOWN(rename),
	NULL,
	NULL,
	PHP_MINFO(rename),
#if ZEND_MODULE_API_NO >= 20010901
	"0.1",
#endif
	STANDARD_MODULE_PROPERTIES
};
/* }}} */
 
#ifdef COMPILE_DL_RENAME
ZEND_GET_MODULE(rename)
#endif
 
/* {{{ PHP_MINIT_FUNCTION
 */
PHP_MINIT_FUNCTION(rename)
{
	return SUCCESS;
}
/* }}} */
 
/* {{{ PHP_MSHUTDOWN_FUNCTION
 */
PHP_MSHUTDOWN_FUNCTION(rename)
{
	return SUCCESS;
}
/* }}} */
 
/* {{{ PHP_RINIT_FUNCTION
*/
PHP_RINIT_FUNCTION(comuto)
{
	return SUCCESS;
}
/* }}} */
 
/* {{{ PHP_RSHUTDOWN_FUNCTION
*/
PHP_RSHUTDOWN_FUNCTION(comuto)
{
	return SUCCESS;
}
 
/* {{{ PHP_MINFO_FUNCTION
 */
PHP_MINFO_FUNCTION(rename)
{
	php_info_print_table_start();
	php_info_print_table_header(2, "rename support", "enabled");
	php_info_print_table_end();
}
/* }}} */
 
/* {{{ proto string function_rename(string orig_func, string new_func)
*/
PHP_FUNCTION(function_rename)
{
 
	char *orig_func, *new_func, *orig_lower, *new_lower;
	int orig_func_len, new_func_len, i;
	zend_function *func;
 
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &orig_func, &orig_func_len, &new_func, &new_func_len) == FAILURE) {
	return;
	}
 
	// Normalize the source function name to lower case.
	orig_lower = malloc(orig_func_len+1);
	for (i = 0; i < orig_func_len; i ++) {
	orig_lower[i] = tolower(orig_func[i]);
	}
	orig_lower[i] = 0;
 
	// Normalize the destination function name to lower case.
	new_lower = malloc(new_func_len + 1);
	for (i = 0; i < new_func_len; i++) {
	new_lower[i] = tolower(new_func[i]);
	}
	new_lower[i] = 0;
 
	if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &orig_func, &orig_func_len, &new_func, &new_func_len) == FAILURE) {
		return;
	}
 
	if(zend_hash_find(EG(function_table), orig_lower, orig_func_len + 1, (void **) &func) == FAILURE) {
		zend_error(E_WARNING, "cannot find %s()", orig_func);
		RETURN_FALSE;
	}
 
	if(zend_hash_exists(EG(function_table), new_lower, new_func_len + 1)) {
		zend_error(E_WARNING, "%s() already exists", new_func);
		RETURN_FALSE;
	}
 
	if(zend_hash_add(EG(function_table), new_lower, new_func_len + 1, func, sizeof(zend_function), NULL) == FAILURE) {
		zend_error(E_WARNING, "cannot rename %s()", orig_func);
		RETURN_FALSE;
	}
 
	if(zend_hash_del(EG(function_table), orig_lower, orig_func_len + 1) == FAILURE) {
		zend_error(E_WARNING, "cannot rename %s()", orig_func);
		RETURN_FALSE;
	}
 
	RETURN_TRUE;
}

Pour l'autre bug, j'ai testé en PHP-CLI et au bout de plus de 1000 tests, pas une erreur.

Donc, ok.Idriss, si tu as une idée de l'origine du problème...

[ok.Idriss]

Re bonjour.

Donc, ok.Idriss, si tu as une idée de l'origine du problème...

Dans ce cas, je situe le problème au niveau d'apache et non de PHP ... je m'en doutais lorsque tu disait qu'en restartant apache, la fonction ré-apparaissait.

La piste de Bousk est aussi à explorer ... (mettre des traces dans ces passages pour voir ce qui se passe exactement) => ) voir et en mode shell, et en mode apache (pour noter les différences entre les deux).

Voir aussi si en commentant tout simplement le zend_hash_del, ça résoudrait le problème ... mais du coup '(logiquement) tu n'aurais plus un renommage mais une simple copie (à vérifier). Qu'est-ce que tu veux exactement en fait ?

Sinon le C c'est pas du script

Cordialement,
Idriss

[Lcf.vs]

Comme je disais, je ne connais rien au C, donc je ne sais pas comment fonctionnent ces traces...

Sinon, petit topo sur ce que je voudrais faire, j'ai une classe PHP permettant d'ajouter des listeners (pouvant poser des contraintes) sur les appels à des fonctions (natives ou non):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<?php
	ini_set('display_errors','On');
	error_reporting(-1);
	class FuncCallObserver{
		private static $functions=array();
		private static function generate(){
			$chars=str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789');
			$string='_';
			$length=mt_rand(25,75);
			for($i=0;$i<$length;$i++){
				$string.=$chars[mt_rand(0,strlen($chars)-1)];
			}
			return $string;
		}
		public static function addListener($old_name,$listener){
			if(!isset(self::$functions[$old_name])){
				while(function_exists($new_name=self::generate()));
				self::$functions[$old_name]=array('name'=>$new_name,'listeners'=>array($listener));
				function_rename($old_name,$new_name);
				eval('function '.$old_name.'(){return '.__CLASS__.'::call("'.$old_name.'",func_get_args());}');
			}
			else{
				array_push(self::$functions[$old_name]['listeners'],$listener);
			}
		}
		public static function call($name,$args){
			if(isset(self::$functions[$name])){
				$i=0; 
				foreach(self::$functions[$name]['listeners'] as $num=>$listener){
					if(call_user_func_array($listener,func_get_args())){
						$i++;
					}
				}
				if($i==count(self::$functions[$name]['listeners'])){
					return call_user_func_array(self::$functions[$name]['name'],$args);
				}
			}
			throw new RuntimeException('Call to undefined function '.$name);
		}
	}
	// EXEMPLE :
	// Ajout des contraintes, si l'une d'elle retourne false l'appel ne peut se faire
	FuncCallObserver::addListener('str_replace',function(){
		echo '<p>Appel de str_replace</p>';
		return true;
	});
	echo str_replace('-','','a-b-c');
	FuncCallObserver::addListener('include',function($path){
		return is_file($path)?true:throw new RuntimeException('<p>Échec de l\'inclusion de : '.$path.'<br />Motif : fichier inexistant</p>');;
	});
	include('un fichier inexistant');
?>

L'idée est que si le listener retourne false, la fonction appelée ne peut être exécutée, je ne peux donc pas ne pas supprimer la fonction de départ, du coup, le zend_hash_del() doit rester.

[ok.Idriss]

Mettre des traces c'est pour debugger tout simplement, pour noter les différences entre le passage via Apache et PHP-CLI (est-ce que je rentre dans le if, + afficher l'état des variables orig_func, etc debugger quoi ). L'idéal serait d'écrire dans un fichier de log par exemple (avec fopen, fprintf et fclose tout simplement).

Cordialement,
Idriss