xref: /PHP-5.4/Zend/zend_ini.c (revision c0d060f5)
1 /*
2    +----------------------------------------------------------------------+
3    | Zend Engine                                                          |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 2.00 of the Zend license,     |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.zend.com/license/2_00.txt.                                |
11    | If you did not receive a copy of the Zend license and are unable to  |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@zend.com so we can mail you a copy immediately.              |
14    +----------------------------------------------------------------------+
15    | Author: Zeev Suraski <zeev@zend.com>                                 |
16    +----------------------------------------------------------------------+
17 */
18 
19 /* $Id$ */
20 
21 #include "zend.h"
22 #include "zend_qsort.h"
23 #include "zend_API.h"
24 #include "zend_ini.h"
25 #include "zend_alloc.h"
26 #include "zend_operators.h"
27 #include "zend_strtod.h"
28 
29 static HashTable *registered_zend_ini_directives;
30 
31 #define NO_VALUE_PLAINTEXT		"no value"
32 #define NO_VALUE_HTML			"<i>no value</i>"
33 
34 /*
35  * hash_apply functions
36  */
zend_remove_ini_entries(zend_ini_entry * ini_entry,int * module_number TSRMLS_DC)37 static int zend_remove_ini_entries(zend_ini_entry *ini_entry, int *module_number TSRMLS_DC) /* {{{ */
38 {
39 	if (ini_entry->module_number == *module_number) {
40 		return 1;
41 	} else {
42 		return 0;
43 	}
44 }
45 /* }}} */
46 
zend_restore_ini_entry_cb(zend_ini_entry * ini_entry,int stage TSRMLS_DC)47 static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage TSRMLS_DC) /* {{{ */
48 {
49 	int result = FAILURE;
50 
51 	if (ini_entry->modified) {
52 		if (ini_entry->on_modify) {
53 			zend_try {
54 			/* even if on_modify bails out, we have to continue on with restoring,
55 				since there can be allocated variables that would be freed on MM shutdown
56 				and would lead to memory corruption later ini entry is modified again */
57 				result = ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->orig_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC);
58 			} zend_end_try();
59 		}
60 		if (stage == ZEND_INI_STAGE_RUNTIME && result == FAILURE) {
61 			/* runtime failure is OK */
62 			return 1;
63 		}
64 		if (ini_entry->value != ini_entry->orig_value) {
65 			efree(ini_entry->value);
66 		}
67 		ini_entry->value = ini_entry->orig_value;
68 		ini_entry->value_length = ini_entry->orig_value_length;
69 		ini_entry->modifiable = ini_entry->orig_modifiable;
70 		ini_entry->modified = 0;
71 		ini_entry->orig_value = NULL;
72 		ini_entry->orig_value_length = 0;
73 		ini_entry->orig_modifiable = 0;
74 	}
75 	return 0;
76 }
77 /* }}} */
78 
zend_restore_ini_entry_wrapper(zend_ini_entry ** ini_entry TSRMLS_DC)79 static int zend_restore_ini_entry_wrapper(zend_ini_entry **ini_entry TSRMLS_DC) /* {{{ */
80 {
81 	zend_restore_ini_entry_cb(*ini_entry, ZEND_INI_STAGE_DEACTIVATE TSRMLS_CC);
82 	return 1;
83 }
84 /* }}} */
85 
86 /*
87  * Startup / shutdown
88  */
zend_ini_startup(TSRMLS_D)89 ZEND_API int zend_ini_startup(TSRMLS_D) /* {{{ */
90 {
91 	registered_zend_ini_directives = (HashTable *) malloc(sizeof(HashTable));
92 
93 	EG(ini_directives) = registered_zend_ini_directives;
94 	EG(modified_ini_directives) = NULL;
95 	EG(error_reporting_ini_entry) = NULL;
96 	if (zend_hash_init_ex(registered_zend_ini_directives, 100, NULL, NULL, 1, 0) == FAILURE) {
97 		return FAILURE;
98 	}
99 	return SUCCESS;
100 }
101 /* }}} */
102 
zend_ini_shutdown(TSRMLS_D)103 ZEND_API int zend_ini_shutdown(TSRMLS_D) /* {{{ */
104 {
105 	zend_hash_destroy(EG(ini_directives));
106 	free(EG(ini_directives));
107 	return SUCCESS;
108 }
109 /* }}} */
110 
zend_ini_global_shutdown(TSRMLS_D)111 ZEND_API int zend_ini_global_shutdown(TSRMLS_D) /* {{{ */
112 {
113 	zend_hash_destroy(registered_zend_ini_directives);
114 	free(registered_zend_ini_directives);
115 	return SUCCESS;
116 }
117 /* }}} */
118 
zend_ini_deactivate(TSRMLS_D)119 ZEND_API int zend_ini_deactivate(TSRMLS_D) /* {{{ */
120 {
121 	if (EG(modified_ini_directives)) {
122 		zend_hash_apply(EG(modified_ini_directives), (apply_func_t) zend_restore_ini_entry_wrapper TSRMLS_CC);
123 		zend_hash_destroy(EG(modified_ini_directives));
124 		FREE_HASHTABLE(EG(modified_ini_directives));
125 		EG(modified_ini_directives) = NULL;
126 	}
127 	return SUCCESS;
128 }
129 /* }}} */
130 
131 #ifdef ZTS
zend_copy_ini_directives(TSRMLS_D)132 ZEND_API int zend_copy_ini_directives(TSRMLS_D) /* {{{ */
133 {
134 	zend_ini_entry ini_entry;
135 
136 	EG(modified_ini_directives) = NULL;
137 	EG(error_reporting_ini_entry) = NULL;
138 	EG(ini_directives) = (HashTable *) malloc(sizeof(HashTable));
139 	if (zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, NULL, 1, 0) == FAILURE) {
140 		return FAILURE;
141 	}
142 	zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, NULL, &ini_entry, sizeof(zend_ini_entry));
143 	return SUCCESS;
144 }
145 /* }}} */
146 #endif
147 
ini_key_compare(const void * a,const void * b TSRMLS_DC)148 static int ini_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
149 {
150 	const Bucket *f;
151 	const Bucket *s;
152 
153 	f = *((const Bucket **) a);
154 	s = *((const Bucket **) b);
155 
156 	if (f->nKeyLength == 0 && s->nKeyLength == 0) { /* both numeric */
157 		return ZEND_NORMALIZE_BOOL(f->nKeyLength - s->nKeyLength);
158 	} else if (f->nKeyLength == 0) { /* f is numeric, s is not */
159 		return -1;
160 	} else if (s->nKeyLength == 0) { /* s is numeric, f is not */
161 		return 1;
162 	} else { /* both strings */
163 		return zend_binary_strcasecmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength);
164 	}
165 }
166 /* }}} */
167 
zend_ini_sort_entries(TSRMLS_D)168 ZEND_API void zend_ini_sort_entries(TSRMLS_D) /* {{{ */
169 {
170 	zend_hash_sort(EG(ini_directives), zend_qsort, ini_key_compare, 0 TSRMLS_CC);
171 }
172 /* }}} */
173 
174 /*
175  * Registration / unregistration
176  */
zend_register_ini_entries(const zend_ini_entry * ini_entry,int module_number TSRMLS_DC)177 ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int module_number TSRMLS_DC) /* {{{ */
178 {
179 	const zend_ini_entry *p = ini_entry;
180 	zend_ini_entry *hashed_ini_entry;
181 	zval default_value;
182 	HashTable *directives = registered_zend_ini_directives;
183 	zend_bool config_directive_success = 0;
184 
185 #ifdef ZTS
186 	/* if we are called during the request, eg: from dl(),
187 	 * then we should not touch the global directives table,
188 	 * and should update the per-(request|thread) version instead.
189 	 * This solves two problems: one is that ini entries for dl()'d
190 	 * extensions will now work, and the second is that updating the
191 	 * global hash here from dl() is not mutex protected and can
192 	 * lead to death.
193 	 */
194 	if (directives != EG(ini_directives)) {
195 		directives = EG(ini_directives);
196 	}
197 #endif
198 
199 	while (p->name) {
200 		config_directive_success = 0;
201 		if (zend_hash_add(directives, p->name, p->name_length, (void*)p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry) == FAILURE) {
202 			zend_unregister_ini_entries(module_number TSRMLS_CC);
203 			return FAILURE;
204 		}
205 		hashed_ini_entry->module_number = module_number;
206 		if ((zend_get_configuration_directive(p->name, p->name_length, &default_value)) == SUCCESS) {
207 			if (!hashed_ini_entry->on_modify
208 				|| hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRLEN(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) {
209 				hashed_ini_entry->value = Z_STRVAL(default_value);
210 				hashed_ini_entry->value_length = Z_STRLEN(default_value);
211 				config_directive_success = 1;
212 			}
213 		}
214 
215 		if (!config_directive_success && hashed_ini_entry->on_modify) {
216 			hashed_ini_entry->on_modify(hashed_ini_entry, hashed_ini_entry->value, hashed_ini_entry->value_length, hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC);
217 		}
218 		p++;
219 	}
220 	return SUCCESS;
221 }
222 /* }}} */
223 
zend_unregister_ini_entries(int module_number TSRMLS_DC)224 ZEND_API void zend_unregister_ini_entries(int module_number TSRMLS_DC) /* {{{ */
225 {
226 	zend_hash_apply_with_argument(registered_zend_ini_directives, (apply_func_arg_t) zend_remove_ini_entries, (void *) &module_number TSRMLS_CC);
227 }
228 /* }}} */
229 
230 #ifdef ZTS
zend_ini_refresh_cache(zend_ini_entry * p,int stage TSRMLS_DC)231 static int zend_ini_refresh_cache(zend_ini_entry *p, int stage TSRMLS_DC) /* {{{ */
232 {
233 	if (p->on_modify) {
234 		p->on_modify(p, p->value, p->value_length, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage TSRMLS_CC);
235 	}
236 	return 0;
237 }
238 /* }}} */
239 
zend_ini_refresh_caches(int stage TSRMLS_DC)240 ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC) /* {{{ */
241 {
242 	zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) zend_ini_refresh_cache, (void *)(zend_intptr_t) stage TSRMLS_CC);
243 }
244 /* }}} */
245 #endif
246 
zend_alter_ini_entry(char * name,uint name_length,char * new_value,uint new_value_length,int modify_type,int stage)247 ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage) /* {{{ */
248 {
249 	TSRMLS_FETCH();
250 
251 	return zend_alter_ini_entry_ex(name, name_length, new_value, new_value_length, modify_type, stage, 0 TSRMLS_CC);
252 }
253 /* }}} */
254 
zend_alter_ini_entry_ex(char * name,uint name_length,char * new_value,uint new_value_length,int modify_type,int stage,int force_change TSRMLS_DC)255 ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
256 {
257 	zend_ini_entry *ini_entry;
258 	char *duplicate;
259 	zend_bool modifiable;
260 	zend_bool modified;
261 
262 	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == FAILURE) {
263 		return FAILURE;
264 	}
265 
266 	modifiable = ini_entry->modifiable;
267 	modified = ini_entry->modified;
268 
269 	if (stage == ZEND_INI_STAGE_ACTIVATE && modify_type == ZEND_INI_SYSTEM) {
270 		ini_entry->modifiable = ZEND_INI_SYSTEM;
271 	}
272 
273 	if (!force_change) {
274 		if (!(ini_entry->modifiable & modify_type)) {
275 			return FAILURE;
276 		}
277 	}
278 
279 	if (!EG(modified_ini_directives)) {
280 		ALLOC_HASHTABLE(EG(modified_ini_directives));
281 		zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
282 	}
283 	if (!modified) {
284 		ini_entry->orig_value = ini_entry->value;
285 		ini_entry->orig_value_length = ini_entry->value_length;
286 		ini_entry->orig_modifiable = modifiable;
287 		ini_entry->modified = 1;
288 		zend_hash_add(EG(modified_ini_directives), name, name_length, &ini_entry, sizeof(zend_ini_entry*), NULL);
289 	}
290 
291 	duplicate = estrndup(new_value, new_value_length);
292 
293 	if (!ini_entry->on_modify
294 		|| ini_entry->on_modify(ini_entry, duplicate, new_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC) == SUCCESS) {
295 		if (modified && ini_entry->orig_value != ini_entry->value) { /* we already changed the value, free the changed value */
296 			efree(ini_entry->value);
297 		}
298 		ini_entry->value = duplicate;
299 		ini_entry->value_length = new_value_length;
300 	} else {
301 		efree(duplicate);
302 		return FAILURE;
303 	}
304 
305 	return SUCCESS;
306 }
307 /* }}} */
308 
zend_restore_ini_entry(char * name,uint name_length,int stage)309 ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage) /* {{{ */
310 {
311 	zend_ini_entry *ini_entry;
312 	TSRMLS_FETCH();
313 
314 	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == FAILURE ||
315 		(stage == ZEND_INI_STAGE_RUNTIME && (ini_entry->modifiable & ZEND_INI_USER) == 0)) {
316 		return FAILURE;
317 	}
318 
319 	if (EG(modified_ini_directives)) {
320 		if (zend_restore_ini_entry_cb(ini_entry, stage TSRMLS_CC) == 0) {
321 			zend_hash_del(EG(modified_ini_directives), name, name_length);
322 		} else {
323 			return FAILURE;
324 		}
325 	}
326 
327 	return SUCCESS;
328 }
329 /* }}} */
330 
zend_ini_register_displayer(char * name,uint name_length,void (* displayer)(zend_ini_entry * ini_entry,int type))331 ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
332 {
333 	zend_ini_entry *ini_entry;
334 
335 	if (zend_hash_find(registered_zend_ini_directives, name, name_length, (void **) &ini_entry) == FAILURE) {
336 		return FAILURE;
337 	}
338 
339 	ini_entry->displayer = displayer;
340 	return SUCCESS;
341 }
342 /* }}} */
343 
344 /*
345  * Data retrieval
346  */
347 
zend_ini_long(char * name,uint name_length,int orig)348 ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
349 {
350 	zend_ini_entry *ini_entry;
351 	TSRMLS_FETCH();
352 
353 	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
354 		if (orig && ini_entry->modified) {
355 			return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0);
356 		} else {
357 			return (ini_entry->value      ? strtol(ini_entry->value, NULL, 0)      : 0);
358 		}
359 	}
360 
361 	return 0;
362 }
363 /* }}} */
364 
zend_ini_double(char * name,uint name_length,int orig)365 ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ */
366 {
367 	zend_ini_entry *ini_entry;
368 	TSRMLS_FETCH();
369 
370 	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
371 		if (orig && ini_entry->modified) {
372 			return (double) (ini_entry->orig_value ? zend_strtod(ini_entry->orig_value, NULL) : 0.0);
373 		} else {
374 			return (double) (ini_entry->value      ? zend_strtod(ini_entry->value, NULL)      : 0.0);
375 		}
376 	}
377 
378 	return 0.0;
379 }
380 /* }}} */
381 
zend_ini_string_ex(char * name,uint name_length,int orig,zend_bool * exists)382 ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists) /* {{{ */
383 {
384 	zend_ini_entry *ini_entry;
385 	TSRMLS_FETCH();
386 
387 	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
388 		if (exists) {
389 			*exists = 1;
390 		}
391 
392 		if (orig && ini_entry->modified) {
393 			return ini_entry->orig_value;
394 		} else {
395 			return ini_entry->value;
396 		}
397 	} else {
398 		if (exists) {
399 			*exists = 0;
400 		}
401 		return NULL;
402 	}
403 }
404 /* }}} */
405 
zend_ini_string(char * name,uint name_length,int orig)406 ZEND_API char *zend_ini_string(char *name, uint name_length, int orig) /* {{{ */
407 {
408 	zend_bool exists = 1;
409 	char *return_value;
410 
411 	return_value = zend_ini_string_ex(name, name_length, orig, &exists);
412 	if (!exists) {
413 		return NULL;
414 	} else if (!return_value) {
415 		return_value = "";
416 	}
417 	return return_value;
418 }
419 /* }}} */
420 
421 #if TONY_20070307
zend_ini_displayer_cb(zend_ini_entry * ini_entry,int type)422 static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type) /* {{{ */
423 {
424 	if (ini_entry->displayer) {
425 		ini_entry->displayer(ini_entry, type);
426 	} else {
427 		char *display_string;
428 		uint display_string_length;
429 
430 		if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
431 			if (ini_entry->orig_value) {
432 				display_string = ini_entry->orig_value;
433 				display_string_length = ini_entry->orig_value_length;
434 			} else {
435 				if (zend_uv.html_errors) {
436 					display_string = NO_VALUE_HTML;
437 					display_string_length = sizeof(NO_VALUE_HTML) - 1;
438 				} else {
439 					display_string = NO_VALUE_PLAINTEXT;
440 					display_string_length = sizeof(NO_VALUE_PLAINTEXT) - 1;
441 				}
442 			}
443 		} else if (ini_entry->value && ini_entry->value[0]) {
444 			display_string = ini_entry->value;
445 			display_string_length = ini_entry->value_length;
446 		} else {
447 			if (zend_uv.html_errors) {
448 				display_string = NO_VALUE_HTML;
449 				display_string_length = sizeof(NO_VALUE_HTML) - 1;
450 			} else {
451 				display_string = NO_VALUE_PLAINTEXT;
452 				display_string_length = sizeof(NO_VALUE_PLAINTEXT) - 1;
453 			}
454 		}
455 		ZEND_WRITE(display_string, display_string_length);
456 	}
457 }
458 /* }}} */
459 #endif
460 
ZEND_INI_DISP(zend_ini_boolean_displayer_cb)461 ZEND_INI_DISP(zend_ini_boolean_displayer_cb) /* {{{ */
462 {
463 	int value, tmp_value_len;
464 	char *tmp_value;
465 
466 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
467 		tmp_value = (ini_entry->orig_value ? ini_entry->orig_value : NULL );
468 		tmp_value_len = ini_entry->orig_value_length;
469 	} else if (ini_entry->value) {
470 		tmp_value = ini_entry->value;
471 		tmp_value_len = ini_entry->value_length;
472 	} else {
473 		tmp_value = NULL;
474 		tmp_value_len = 0;
475 	}
476 
477 	if (tmp_value) {
478 		if (tmp_value_len == 4 && strcasecmp(tmp_value, "true") == 0) {
479 			value = 1;
480 		} else if (tmp_value_len == 3 && strcasecmp(tmp_value, "yes") == 0) {
481 			value = 1;
482 		} else if (tmp_value_len == 2 && strcasecmp(tmp_value, "on") == 0) {
483 			value = 1;
484 		} else {
485 			value = atoi(tmp_value);
486 		}
487 	} else {
488 		value = 0;
489 	}
490 
491 	if (value) {
492 		ZEND_PUTS("On");
493 	} else {
494 		ZEND_PUTS("Off");
495 	}
496 }
497 /* }}} */
498 
ZEND_INI_DISP(zend_ini_color_displayer_cb)499 ZEND_INI_DISP(zend_ini_color_displayer_cb) /* {{{ */
500 {
501 	char *value;
502 
503 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
504 		value = ini_entry->orig_value;
505 	} else if (ini_entry->value) {
506 		value = ini_entry->value;
507 	} else {
508 		value = NULL;
509 	}
510 	if (value) {
511 		if (zend_uv.html_errors) {
512 			zend_printf("<font style=\"color: %s\">%s</font>", value, value);
513 		} else {
514 			ZEND_PUTS(value);
515 		}
516 	} else {
517 		if (zend_uv.html_errors) {
518 			ZEND_PUTS(NO_VALUE_HTML);
519 		} else {
520 			ZEND_PUTS(NO_VALUE_PLAINTEXT);
521 		}
522 	}
523 }
524 /* }}} */
525 
ZEND_INI_DISP(display_link_numbers)526 ZEND_INI_DISP(display_link_numbers) /* {{{ */
527 {
528 	char *value;
529 
530 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
531 		value = ini_entry->orig_value;
532 	} else if (ini_entry->value) {
533 		value = ini_entry->value;
534 	} else {
535 		value = NULL;
536 	}
537 
538 	if (value) {
539 		if (atoi(value) == -1) {
540 			ZEND_PUTS("Unlimited");
541 		} else {
542 			zend_printf("%s", value);
543 		}
544 	}
545 }
546 /* }}} */
547 
548 /* Standard message handlers */
ZEND_INI_MH(OnUpdateBool)549 ZEND_API ZEND_INI_MH(OnUpdateBool) /* {{{ */
550 {
551 	zend_bool *p;
552 #ifndef ZTS
553 	char *base = (char *) mh_arg2;
554 #else
555 	char *base;
556 
557 	base = (char *) ts_resource(*((int *) mh_arg2));
558 #endif
559 
560 	p = (zend_bool *) (base+(size_t) mh_arg1);
561 
562 	if (new_value_length == 2 && strcasecmp("on", new_value) == 0) {
563 		*p = (zend_bool) 1;
564 	}
565 	else if (new_value_length == 3 && strcasecmp("yes", new_value) == 0) {
566 		*p = (zend_bool) 1;
567 	}
568 	else if (new_value_length == 4 && strcasecmp("true", new_value) == 0) {
569 		*p = (zend_bool) 1;
570 	}
571 	else {
572 		*p = (zend_bool) atoi(new_value);
573 	}
574 	return SUCCESS;
575 }
576 /* }}} */
577 
ZEND_INI_MH(OnUpdateLong)578 ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
579 {
580 	long *p;
581 #ifndef ZTS
582 	char *base = (char *) mh_arg2;
583 #else
584 	char *base;
585 
586 	base = (char *) ts_resource(*((int *) mh_arg2));
587 #endif
588 
589 	p = (long *) (base+(size_t) mh_arg1);
590 
591 	*p = zend_atol(new_value, new_value_length);
592 	return SUCCESS;
593 }
594 /* }}} */
595 
ZEND_INI_MH(OnUpdateLongGEZero)596 ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
597 {
598 	long *p, tmp;
599 #ifndef ZTS
600 	char *base = (char *) mh_arg2;
601 #else
602 	char *base;
603 
604 	base = (char *) ts_resource(*((int *) mh_arg2));
605 #endif
606 
607 	tmp = zend_atol(new_value, new_value_length);
608 	if (tmp < 0) {
609 		return FAILURE;
610 	}
611 
612 	p = (long *) (base+(size_t) mh_arg1);
613 	*p = tmp;
614 
615 	return SUCCESS;
616 }
617 /* }}} */
618 
ZEND_INI_MH(OnUpdateReal)619 ZEND_API ZEND_INI_MH(OnUpdateReal) /* {{{ */
620 {
621 	double *p;
622 #ifndef ZTS
623 	char *base = (char *) mh_arg2;
624 #else
625 	char *base;
626 
627 	base = (char *) ts_resource(*((int *) mh_arg2));
628 #endif
629 
630 	p = (double *) (base+(size_t) mh_arg1);
631 
632 	*p = zend_strtod(new_value, NULL);
633 	return SUCCESS;
634 }
635 /* }}} */
636 
ZEND_INI_MH(OnUpdateString)637 ZEND_API ZEND_INI_MH(OnUpdateString) /* {{{ */
638 {
639 	char **p;
640 #ifndef ZTS
641 	char *base = (char *) mh_arg2;
642 #else
643 	char *base;
644 
645 	base = (char *) ts_resource(*((int *) mh_arg2));
646 #endif
647 
648 	p = (char **) (base+(size_t) mh_arg1);
649 
650 	*p = new_value;
651 	return SUCCESS;
652 }
653 /* }}} */
654 
ZEND_INI_MH(OnUpdateStringUnempty)655 ZEND_API ZEND_INI_MH(OnUpdateStringUnempty) /* {{{ */
656 {
657 	char **p;
658 #ifndef ZTS
659 	char *base = (char *) mh_arg2;
660 #else
661 	char *base;
662 
663 	base = (char *) ts_resource(*((int *) mh_arg2));
664 #endif
665 
666 	if (new_value && !new_value[0]) {
667 		return FAILURE;
668 	}
669 
670 	p = (char **) (base+(size_t) mh_arg1);
671 
672 	*p = new_value;
673 	return SUCCESS;
674 }
675 /* }}} */
676 
677 /*
678  * Local variables:
679  * tab-width: 4
680  * c-basic-offset: 4
681  * indent-tabs-mode: t
682  * End:
683  */
684