Annotation of embedaddon/php/ext/hash/hash.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP 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.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Author: Sara Golemon <pollita@php.net> |
! 16: | Scott MacVicar <scottmac@php.net> |
! 17: +----------------------------------------------------------------------+
! 18: */
! 19:
! 20: /* $Id: hash.c 321634 2012-01-01 13:15:04Z felipe $ */
! 21:
! 22: #ifdef HAVE_CONFIG_H
! 23: #include "config.h"
! 24: #endif
! 25:
! 26: #include "php_hash.h"
! 27: #include "ext/standard/info.h"
! 28: #include "ext/standard/file.h"
! 29:
! 30: static int php_hash_le_hash;
! 31: HashTable php_hash_hashtable;
! 32:
! 33: #if (PHP_MAJOR_VERSION >= 5)
! 34: # define DEFAULT_CONTEXT FG(default_context)
! 35: #else
! 36: # define DEFAULT_CONTEXT NULL
! 37: #endif
! 38:
! 39: #ifdef PHP_MHASH_BC
! 40: struct mhash_bc_entry {
! 41: char *mhash_name;
! 42: char *hash_name;
! 43: int value;
! 44: };
! 45:
! 46: #define MHASH_NUM_ALGOS 29
! 47:
! 48: static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {
! 49: {"CRC32", "crc32", 0},
! 50: {"MD5", "md5", 1},
! 51: {"SHA1", "sha1", 2},
! 52: {"HAVAL256", "haval256,3", 3},
! 53: {NULL, NULL, 4},
! 54: {"RIPEMD160", "ripemd160", 5},
! 55: {NULL, NULL, 6},
! 56: {"TIGER", "tiger192,3", 7},
! 57: {"GOST", "gost", 8},
! 58: {"CRC32B", "crc32b", 9},
! 59: {"HAVAL224", "haval224,3", 10},
! 60: {"HAVAL192", "haval192,3", 11},
! 61: {"HAVAL160", "haval160,3", 12},
! 62: {"HAVAL128", "haval128,3", 13},
! 63: {"TIGER128", "tiger128,3", 14},
! 64: {"TIGER160", "tiger160,3", 15},
! 65: {"MD4", "md4", 16},
! 66: {"SHA256", "sha256", 17},
! 67: {"ADLER32", "adler32", 18},
! 68: {"SHA224", "sha224", 19},
! 69: {"SHA512", "sha512", 20},
! 70: {"SHA384", "sha384", 21},
! 71: {"WHIRLPOOL", "whirlpool", 22},
! 72: {"RIPEMD128", "ripemd128", 23},
! 73: {"RIPEMD256", "ripemd256", 24},
! 74: {"RIPEMD320", "ripemd320", 25},
! 75: {NULL, NULL, 26}, /* support needs to be added for snefru 128 */
! 76: {"SNEFRU256", "snefru256", 27},
! 77: {"MD2", "md2", 28}
! 78: };
! 79: #endif
! 80:
! 81: /* Hash Registry Access */
! 82:
! 83: PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, int algo_len) /* {{{ */
! 84: {
! 85: php_hash_ops *ops;
! 86: char *lower = estrndup(algo, algo_len);
! 87:
! 88: zend_str_tolower(lower, algo_len);
! 89: if (SUCCESS != zend_hash_find(&php_hash_hashtable, lower, algo_len + 1, (void*)&ops)) {
! 90: ops = NULL;
! 91: }
! 92: efree(lower);
! 93:
! 94: return ops;
! 95: }
! 96: /* }}} */
! 97:
! 98: PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops) /* {{{ */
! 99: {
! 100: int algo_len = strlen(algo);
! 101: char *lower = estrndup(algo, algo_len);
! 102:
! 103: zend_str_tolower(lower, algo_len);
! 104: zend_hash_add(&php_hash_hashtable, lower, algo_len + 1, (void*)ops, sizeof(php_hash_ops), NULL);
! 105: efree(lower);
! 106: }
! 107: /* }}} */
! 108:
! 109: PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context) /* {{{ */
! 110: {
! 111: php_hash_ops *hash_ops = (php_hash_ops *)ops;
! 112:
! 113: memcpy(dest_context, orig_context, hash_ops->context_size);
! 114: return SUCCESS;
! 115: }
! 116: /* }}} */
! 117:
! 118: /* Userspace */
! 119:
! 120: static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
! 121: {
! 122: char *algo, *data, *digest;
! 123: int algo_len, data_len;
! 124: zend_bool raw_output = raw_output_default;
! 125: const php_hash_ops *ops;
! 126: void *context;
! 127: php_stream *stream = NULL;
! 128:
! 129: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &algo, &algo_len, &data, &data_len, &raw_output) == FAILURE) {
! 130: return;
! 131: }
! 132:
! 133: ops = php_hash_fetch_ops(algo, algo_len);
! 134: if (!ops) {
! 135: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
! 136: RETURN_FALSE;
! 137: }
! 138: if (isfilename) {
! 139: stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL, DEFAULT_CONTEXT);
! 140: if (!stream) {
! 141: /* Stream will report errors opening file */
! 142: RETURN_FALSE;
! 143: }
! 144: }
! 145:
! 146: context = emalloc(ops->context_size);
! 147: ops->hash_init(context);
! 148:
! 149: if (isfilename) {
! 150: char buf[1024];
! 151: int n;
! 152:
! 153: while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
! 154: ops->hash_update(context, (unsigned char *) buf, n);
! 155: }
! 156: php_stream_close(stream);
! 157: } else {
! 158: ops->hash_update(context, (unsigned char *) data, data_len);
! 159: }
! 160:
! 161: digest = emalloc(ops->digest_size + 1);
! 162: ops->hash_final((unsigned char *) digest, context);
! 163: efree(context);
! 164:
! 165: if (raw_output) {
! 166: digest[ops->digest_size] = 0;
! 167: RETURN_STRINGL(digest, ops->digest_size, 0);
! 168: } else {
! 169: char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);
! 170:
! 171: php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
! 172: hex_digest[2 * ops->digest_size] = 0;
! 173: efree(digest);
! 174: RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
! 175: }
! 176: }
! 177: /* }}} */
! 178:
! 179: /* {{{ proto string hash(string algo, string data[, bool raw_output = false])
! 180: Generate a hash of a given input string
! 181: Returns lowercase hexits by default */
! 182: PHP_FUNCTION(hash)
! 183: {
! 184: php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
! 185: }
! 186: /* }}} */
! 187:
! 188: /* {{{ proto string hash_file(string algo, string filename[, bool raw_output = false])
! 189: Generate a hash of a given file
! 190: Returns lowercase hexits by default */
! 191: PHP_FUNCTION(hash_file)
! 192: {
! 193: php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
! 194: }
! 195: /* }}} */
! 196:
! 197: static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
! 198: {
! 199: char *algo, *data, *digest, *key, *K;
! 200: int algo_len, data_len, key_len, i;
! 201: zend_bool raw_output = raw_output_default;
! 202: const php_hash_ops *ops;
! 203: void *context;
! 204: php_stream *stream = NULL;
! 205:
! 206: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|b", &algo, &algo_len, &data, &data_len,
! 207: &key, &key_len, &raw_output) == FAILURE) {
! 208: return;
! 209: }
! 210:
! 211: ops = php_hash_fetch_ops(algo, algo_len);
! 212: if (!ops) {
! 213: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
! 214: RETURN_FALSE;
! 215: }
! 216: if (isfilename) {
! 217: stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL, DEFAULT_CONTEXT);
! 218: if (!stream) {
! 219: /* Stream will report errors opening file */
! 220: RETURN_FALSE;
! 221: }
! 222: }
! 223:
! 224: context = emalloc(ops->context_size);
! 225: ops->hash_init(context);
! 226:
! 227: K = emalloc(ops->block_size);
! 228: memset(K, 0, ops->block_size);
! 229:
! 230: if (key_len > ops->block_size) {
! 231: /* Reduce the key first */
! 232: ops->hash_update(context, (unsigned char *) key, key_len);
! 233: ops->hash_final((unsigned char *) K, context);
! 234: /* Make the context ready to start over */
! 235: ops->hash_init(context);
! 236: } else {
! 237: memcpy(K, key, key_len);
! 238: }
! 239:
! 240: /* XOR ipad */
! 241: for(i=0; i < ops->block_size; i++) {
! 242: K[i] ^= 0x36;
! 243: }
! 244: ops->hash_update(context, (unsigned char *) K, ops->block_size);
! 245:
! 246: if (isfilename) {
! 247: char buf[1024];
! 248: int n;
! 249:
! 250: while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
! 251: ops->hash_update(context, (unsigned char *) buf, n);
! 252: }
! 253: php_stream_close(stream);
! 254: } else {
! 255: ops->hash_update(context, (unsigned char *) data, data_len);
! 256: }
! 257:
! 258: digest = emalloc(ops->digest_size + 1);
! 259: ops->hash_final((unsigned char *) digest, context);
! 260:
! 261: /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */
! 262: for(i=0; i < ops->block_size; i++) {
! 263: K[i] ^= 0x6A;
! 264: }
! 265:
! 266: /* Feed this result into the outter hash */
! 267: ops->hash_init(context);
! 268: ops->hash_update(context, (unsigned char *) K, ops->block_size);
! 269: ops->hash_update(context, (unsigned char *) digest, ops->digest_size);
! 270: ops->hash_final((unsigned char *) digest, context);
! 271:
! 272: /* Zero the key */
! 273: memset(K, 0, ops->block_size);
! 274: efree(K);
! 275: efree(context);
! 276:
! 277: if (raw_output) {
! 278: digest[ops->digest_size] = 0;
! 279: RETURN_STRINGL(digest, ops->digest_size, 0);
! 280: } else {
! 281: char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);
! 282:
! 283: php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
! 284: hex_digest[2 * ops->digest_size] = 0;
! 285: efree(digest);
! 286: RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
! 287: }
! 288: }
! 289: /* }}} */
! 290:
! 291: /* {{{ proto string hash_hmac(string algo, string data, string key[, bool raw_output = false])
! 292: Generate a hash of a given input string with a key using HMAC
! 293: Returns lowercase hexits by default */
! 294: PHP_FUNCTION(hash_hmac)
! 295: {
! 296: php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
! 297: }
! 298: /* }}} */
! 299:
! 300: /* {{{ proto string hash_hmac_file(string algo, string filename, string key[, bool raw_output = false])
! 301: Generate a hash of a given file with a key using HMAC
! 302: Returns lowercase hexits by default */
! 303: PHP_FUNCTION(hash_hmac_file)
! 304: {
! 305: php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
! 306: }
! 307: /* }}} */
! 308:
! 309:
! 310: /* {{{ proto resource hash_init(string algo[, int options, string key])
! 311: Initialize a hashing context */
! 312: PHP_FUNCTION(hash_init)
! 313: {
! 314: char *algo, *key = NULL;
! 315: int algo_len, key_len = 0, argc = ZEND_NUM_ARGS();
! 316: long options = 0;
! 317: void *context;
! 318: const php_hash_ops *ops;
! 319: php_hash_data *hash;
! 320:
! 321: if (zend_parse_parameters(argc TSRMLS_CC, "s|ls", &algo, &algo_len, &options, &key, &key_len) == FAILURE) {
! 322: return;
! 323: }
! 324:
! 325: ops = php_hash_fetch_ops(algo, algo_len);
! 326: if (!ops) {
! 327: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
! 328: RETURN_FALSE;
! 329: }
! 330:
! 331: if (options & PHP_HASH_HMAC &&
! 332: key_len <= 0) {
! 333: /* Note: a zero length key is no key at all */
! 334: php_error_docref(NULL TSRMLS_CC, E_WARNING, "HMAC requested without a key");
! 335: RETURN_FALSE;
! 336: }
! 337:
! 338: context = emalloc(ops->context_size);
! 339: ops->hash_init(context);
! 340:
! 341: hash = emalloc(sizeof(php_hash_data));
! 342: hash->ops = ops;
! 343: hash->context = context;
! 344: hash->options = options;
! 345: hash->key = NULL;
! 346:
! 347: if (options & PHP_HASH_HMAC) {
! 348: char *K = emalloc(ops->block_size);
! 349: int i;
! 350:
! 351: memset(K, 0, ops->block_size);
! 352:
! 353: if (key_len > ops->block_size) {
! 354: /* Reduce the key first */
! 355: ops->hash_update(context, (unsigned char *) key, key_len);
! 356: ops->hash_final((unsigned char *) K, context);
! 357: /* Make the context ready to start over */
! 358: ops->hash_init(context);
! 359: } else {
! 360: memcpy(K, key, key_len);
! 361: }
! 362:
! 363: /* XOR ipad */
! 364: for(i=0; i < ops->block_size; i++) {
! 365: K[i] ^= 0x36;
! 366: }
! 367: ops->hash_update(context, (unsigned char *) K, ops->block_size);
! 368: hash->key = (unsigned char *) K;
! 369: }
! 370:
! 371: ZEND_REGISTER_RESOURCE(return_value, hash, php_hash_le_hash);
! 372: }
! 373: /* }}} */
! 374:
! 375: /* {{{ proto bool hash_update(resource context, string data)
! 376: Pump data into the hashing algorithm */
! 377: PHP_FUNCTION(hash_update)
! 378: {
! 379: zval *zhash;
! 380: php_hash_data *hash;
! 381: char *data;
! 382: int data_len;
! 383:
! 384: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &zhash, &data, &data_len) == FAILURE) {
! 385: return;
! 386: }
! 387:
! 388: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
! 389:
! 390: hash->ops->hash_update(hash->context, (unsigned char *) data, data_len);
! 391:
! 392: RETURN_TRUE;
! 393: }
! 394: /* }}} */
! 395:
! 396: /* {{{ proto int hash_update_stream(resource context, resource handle[, integer length])
! 397: Pump data into the hashing algorithm from an open stream */
! 398: PHP_FUNCTION(hash_update_stream)
! 399: {
! 400: zval *zhash, *zstream;
! 401: php_hash_data *hash;
! 402: php_stream *stream = NULL;
! 403: long length = -1, didread = 0;
! 404:
! 405: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|l", &zhash, &zstream, &length) == FAILURE) {
! 406: return;
! 407: }
! 408:
! 409: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
! 410: php_stream_from_zval(stream, &zstream);
! 411:
! 412: while (length) {
! 413: char buf[1024];
! 414: long n, toread = 1024;
! 415:
! 416: if (length > 0 && toread > length) {
! 417: toread = length;
! 418: }
! 419:
! 420: if ((n = php_stream_read(stream, buf, toread)) <= 0) {
! 421: /* Nada mas */
! 422: RETURN_LONG(didread);
! 423: }
! 424: hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
! 425: length -= n;
! 426: didread += n;
! 427: }
! 428:
! 429: RETURN_LONG(didread);
! 430: }
! 431: /* }}} */
! 432:
! 433: /* {{{ proto bool hash_update_file(resource context, string filename[, resource context])
! 434: Pump data into the hashing algorithm from a file */
! 435: PHP_FUNCTION(hash_update_file)
! 436: {
! 437: zval *zhash, *zcontext = NULL;
! 438: php_hash_data *hash;
! 439: php_stream_context *context;
! 440: php_stream *stream;
! 441: char *filename, buf[1024];
! 442: int filename_len, n;
! 443:
! 444: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|r", &zhash, &filename, &filename_len, &zcontext) == FAILURE) {
! 445: return;
! 446: }
! 447:
! 448: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
! 449: context = php_stream_context_from_zval(zcontext, 0);
! 450:
! 451: stream = php_stream_open_wrapper_ex(filename, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL, context);
! 452: if (!stream) {
! 453: /* Stream will report errors opening file */
! 454: RETURN_FALSE;
! 455: }
! 456:
! 457: while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
! 458: hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
! 459: }
! 460: php_stream_close(stream);
! 461:
! 462: RETURN_TRUE;
! 463: }
! 464: /* }}} */
! 465:
! 466: /* {{{ proto string hash_final(resource context[, bool raw_output=false])
! 467: Output resulting digest */
! 468: PHP_FUNCTION(hash_final)
! 469: {
! 470: zval *zhash;
! 471: php_hash_data *hash;
! 472: zend_bool raw_output = 0;
! 473: zend_rsrc_list_entry *le;
! 474: char *digest;
! 475: int digest_len;
! 476:
! 477: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|b", &zhash, &raw_output) == FAILURE) {
! 478: return;
! 479: }
! 480:
! 481: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
! 482:
! 483: digest_len = hash->ops->digest_size;
! 484: digest = emalloc(digest_len + 1);
! 485: hash->ops->hash_final((unsigned char *) digest, hash->context);
! 486: if (hash->options & PHP_HASH_HMAC) {
! 487: int i;
! 488:
! 489: /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */
! 490: for(i=0; i < hash->ops->block_size; i++) {
! 491: hash->key[i] ^= 0x6A;
! 492: }
! 493:
! 494: /* Feed this result into the outter hash */
! 495: hash->ops->hash_init(hash->context);
! 496: hash->ops->hash_update(hash->context, (unsigned char *) hash->key, hash->ops->block_size);
! 497: hash->ops->hash_update(hash->context, (unsigned char *) digest, hash->ops->digest_size);
! 498: hash->ops->hash_final((unsigned char *) digest, hash->context);
! 499:
! 500: /* Zero the key */
! 501: memset(hash->key, 0, hash->ops->block_size);
! 502: efree(hash->key);
! 503: hash->key = NULL;
! 504: }
! 505: digest[digest_len] = 0;
! 506: efree(hash->context);
! 507: hash->context = NULL;
! 508:
! 509: /* zend_list_REAL_delete() */
! 510: if (zend_hash_index_find(&EG(regular_list), Z_RESVAL_P(zhash), (void *) &le)==SUCCESS) {
! 511: /* This is a hack to avoid letting the resource hide elsewhere (like in separated vars)
! 512: FETCH_RESOURCE is intelligent enough to handle dealing with any issues this causes */
! 513: le->refcount = 1;
! 514: } /* FAILURE is not an option */
! 515: zend_list_delete(Z_RESVAL_P(zhash));
! 516:
! 517: if (raw_output) {
! 518: RETURN_STRINGL(digest, digest_len, 0);
! 519: } else {
! 520: char *hex_digest = safe_emalloc(digest_len,2,1);
! 521:
! 522: php_hash_bin2hex(hex_digest, (unsigned char *) digest, digest_len);
! 523: hex_digest[2 * digest_len] = 0;
! 524: efree(digest);
! 525: RETURN_STRINGL(hex_digest, 2 * digest_len, 0);
! 526: }
! 527: }
! 528: /* }}} */
! 529:
! 530: /* {{{ proto resource hash_copy(resource context)
! 531: Copy hash resource */
! 532: PHP_FUNCTION(hash_copy)
! 533: {
! 534: zval *zhash;
! 535: php_hash_data *hash, *copy_hash;
! 536: void *context;
! 537: int res;
! 538:
! 539: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zhash) == FAILURE) {
! 540: return;
! 541: }
! 542:
! 543: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
! 544:
! 545:
! 546: context = emalloc(hash->ops->context_size);
! 547: hash->ops->hash_init(context);
! 548:
! 549: res = hash->ops->hash_copy(hash->ops, hash->context, context);
! 550: if (res != SUCCESS) {
! 551: efree(context);
! 552: RETURN_FALSE;
! 553: }
! 554:
! 555: copy_hash = emalloc(sizeof(php_hash_data));
! 556: copy_hash->ops = hash->ops;
! 557: copy_hash->context = context;
! 558: copy_hash->options = hash->options;
! 559: copy_hash->key = ecalloc(1, hash->ops->block_size);
! 560: if (hash->key) {
! 561: memcpy(copy_hash->key, hash->key, hash->ops->block_size);
! 562: }
! 563: ZEND_REGISTER_RESOURCE(return_value, copy_hash, php_hash_le_hash);
! 564: }
! 565: /* }}} */
! 566:
! 567: /* {{{ proto array hash_algos(void)
! 568: Return a list of registered hashing algorithms */
! 569: PHP_FUNCTION(hash_algos)
! 570: {
! 571: HashPosition pos;
! 572: char *str;
! 573: uint str_len;
! 574: long type;
! 575: ulong idx;
! 576:
! 577: array_init(return_value);
! 578: for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
! 579: (type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, &str_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT;
! 580: zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
! 581: add_next_index_stringl(return_value, str, str_len-1, 1);
! 582: }
! 583: }
! 584: /* }}} */
! 585:
! 586: /* Module Housekeeping */
! 587:
! 588: static void php_hash_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
! 589: {
! 590: php_hash_data *hash = (php_hash_data*)rsrc->ptr;
! 591:
! 592: /* Just in case the algo has internally allocated resources */
! 593: if (hash->context) {
! 594: unsigned char *dummy = emalloc(hash->ops->digest_size);
! 595: hash->ops->hash_final(dummy, hash->context);
! 596: efree(dummy);
! 597: efree(hash->context);
! 598: }
! 599:
! 600: if (hash->key) {
! 601: memset(hash->key, 0, hash->ops->block_size);
! 602: efree(hash->key);
! 603: }
! 604: efree(hash);
! 605: }
! 606: /* }}} */
! 607:
! 608: #define PHP_HASH_HAVAL_REGISTER(p,b) php_hash_register_algo("haval" #b "," #p , &php_hash_##p##haval##b##_ops);
! 609:
! 610: #ifdef PHP_MHASH_BC
! 611:
! 612: PHP_MINFO_FUNCTION(mhash)
! 613: {
! 614: php_info_print_table_start();
! 615: php_info_print_table_row(2, "MHASH support", "Enabled");
! 616: php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
! 617: php_info_print_table_end();
! 618: }
! 619:
! 620: zend_module_entry mhash_module_entry = {
! 621: STANDARD_MODULE_HEADER,
! 622: "mhash",
! 623: NULL,
! 624: NULL,
! 625: NULL,
! 626: NULL,
! 627: NULL,
! 628: PHP_MINFO(mhash),
! 629: NO_VERSION_YET,
! 630: STANDARD_MODULE_PROPERTIES,
! 631: };
! 632:
! 633: static void mhash_init(INIT_FUNC_ARGS)
! 634: {
! 635: char buf[128];
! 636: int len;
! 637: int algo_number = 0;
! 638:
! 639: for (algo_number = 0; algo_number < MHASH_NUM_ALGOS; algo_number++) {
! 640: struct mhash_bc_entry algorithm = mhash_to_hash[algo_number];
! 641: if (algorithm.mhash_name == NULL) {
! 642: continue;
! 643: }
! 644:
! 645: len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name, strlen(algorithm.mhash_name));
! 646: zend_register_long_constant(buf, len + 1, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
! 647: }
! 648: zend_register_internal_module(&mhash_module_entry TSRMLS_CC);
! 649: }
! 650:
! 651: /* {{{ proto string mhash(int hash, string data [, string key])
! 652: Hash data with hash */
! 653: PHP_FUNCTION(mhash)
! 654: {
! 655: zval **z_algorithm;
! 656: long algorithm;
! 657:
! 658: if (zend_parse_parameters(1 TSRMLS_CC, "Z", &z_algorithm) == FAILURE) {
! 659: return;
! 660: }
! 661:
! 662: SEPARATE_ZVAL(z_algorithm);
! 663: convert_to_long_ex(z_algorithm);
! 664: algorithm = Z_LVAL_PP(z_algorithm);
! 665:
! 666: /* need to convert the first parameter from int constant to string algorithm name */
! 667: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
! 668: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
! 669: if (algorithm_lookup.hash_name) {
! 670: ZVAL_STRING(*z_algorithm, algorithm_lookup.hash_name, 1);
! 671: }
! 672: }
! 673:
! 674: if (ZEND_NUM_ARGS() == 3) {
! 675: php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
! 676: } else if (ZEND_NUM_ARGS() == 2) {
! 677: php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
! 678: } else {
! 679: WRONG_PARAM_COUNT;
! 680: }
! 681: }
! 682: /* }}} */
! 683:
! 684: /* {{{ proto string mhash_get_hash_name(int hash)
! 685: Gets the name of hash */
! 686: PHP_FUNCTION(mhash_get_hash_name)
! 687: {
! 688: long algorithm;
! 689:
! 690: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &algorithm) == FAILURE) {
! 691: return;
! 692: }
! 693:
! 694: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
! 695: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
! 696: if (algorithm_lookup.mhash_name) {
! 697: RETURN_STRING(algorithm_lookup.mhash_name, 1);
! 698: }
! 699: }
! 700: RETURN_FALSE;
! 701: }
! 702: /* }}} */
! 703:
! 704: /* {{{ proto int mhash_count(void)
! 705: Gets the number of available hashes */
! 706: PHP_FUNCTION(mhash_count)
! 707: {
! 708: if (zend_parse_parameters_none() == FAILURE) {
! 709: return;
! 710: }
! 711: RETURN_LONG(MHASH_NUM_ALGOS - 1);
! 712: }
! 713: /* }}} */
! 714:
! 715: /* {{{ proto int mhash_get_block_size(int hash)
! 716: Gets the block size of hash */
! 717: PHP_FUNCTION(mhash_get_block_size)
! 718: {
! 719: long algorithm;
! 720:
! 721: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &algorithm) == FAILURE) {
! 722: return;
! 723: }
! 724: RETVAL_FALSE;
! 725:
! 726: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
! 727: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
! 728: if (algorithm_lookup.mhash_name) {
! 729: const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
! 730: if (ops) {
! 731: RETVAL_LONG(ops->digest_size);
! 732: }
! 733: }
! 734: }
! 735: }
! 736: /* }}} */
! 737:
! 738: #define SALT_SIZE 8
! 739:
! 740: /* {{{ proto string mhash_keygen_s2k(int hash, string input_password, string salt, int bytes)
! 741: Generates a key using hash functions */
! 742: PHP_FUNCTION(mhash_keygen_s2k)
! 743: {
! 744: long algorithm, l_bytes;
! 745: int bytes;
! 746: char *password, *salt;
! 747: int password_len, salt_len;
! 748: char padded_salt[SALT_SIZE];
! 749:
! 750: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) {
! 751: return;
! 752: }
! 753:
! 754: bytes = (int)l_bytes;
! 755: if (bytes <= 0){
! 756: php_error_docref(NULL TSRMLS_CC, E_WARNING, "the byte parameter must be greater than 0");
! 757: RETURN_FALSE;
! 758: }
! 759:
! 760: salt_len = MIN(salt_len, SALT_SIZE);
! 761:
! 762: memcpy(padded_salt, salt, salt_len);
! 763: if (salt_len < SALT_SIZE) {
! 764: memset(padded_salt + salt_len, 0, SALT_SIZE - salt_len);
! 765: }
! 766: salt_len = SALT_SIZE;
! 767:
! 768: RETVAL_FALSE;
! 769: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
! 770: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
! 771: if (algorithm_lookup.mhash_name) {
! 772: const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
! 773: if (ops) {
! 774: unsigned char null = '\0';
! 775: void *context;
! 776: char *key, *digest;
! 777: int i = 0, j = 0;
! 778: int block_size = ops->digest_size;
! 779: int times = bytes / block_size;
! 780: if (bytes % block_size != 0) times++;
! 781:
! 782: context = emalloc(ops->context_size);
! 783: ops->hash_init(context);
! 784:
! 785: key = ecalloc(1, times * block_size);
! 786: digest = emalloc(ops->digest_size + 1);
! 787:
! 788: for (i = 0; i < times; i++) {
! 789: ops->hash_init(context);
! 790:
! 791: for (j=0;j<i;j++) {
! 792: ops->hash_update(context, &null, 1);
! 793: }
! 794: ops->hash_update(context, (unsigned char *)padded_salt, salt_len);
! 795: ops->hash_update(context, (unsigned char *)password, password_len);
! 796: ops->hash_final((unsigned char *)digest, context);
! 797: memcpy( &key[i*block_size], digest, block_size);
! 798: }
! 799:
! 800: RETVAL_STRINGL(key, bytes, 1);
! 801: memset(key, 0, bytes);
! 802: efree(digest);
! 803: efree(context);
! 804: efree(key);
! 805: }
! 806: }
! 807: }
! 808: }
! 809: /* }}} */
! 810:
! 811: #endif
! 812:
! 813: /* {{{ PHP_MINIT_FUNCTION
! 814: */
! 815: PHP_MINIT_FUNCTION(hash)
! 816: {
! 817: php_hash_le_hash = zend_register_list_destructors_ex(php_hash_dtor, NULL, PHP_HASH_RESNAME, module_number);
! 818:
! 819: zend_hash_init(&php_hash_hashtable, 35, NULL, NULL, 1);
! 820:
! 821: php_hash_register_algo("md2", &php_hash_md2_ops);
! 822: php_hash_register_algo("md4", &php_hash_md4_ops);
! 823: php_hash_register_algo("md5", &php_hash_md5_ops);
! 824: php_hash_register_algo("sha1", &php_hash_sha1_ops);
! 825: php_hash_register_algo("sha224", &php_hash_sha224_ops);
! 826: php_hash_register_algo("sha256", &php_hash_sha256_ops);
! 827: php_hash_register_algo("sha384", &php_hash_sha384_ops);
! 828: php_hash_register_algo("sha512", &php_hash_sha512_ops);
! 829: php_hash_register_algo("ripemd128", &php_hash_ripemd128_ops);
! 830: php_hash_register_algo("ripemd160", &php_hash_ripemd160_ops);
! 831: php_hash_register_algo("ripemd256", &php_hash_ripemd256_ops);
! 832: php_hash_register_algo("ripemd320", &php_hash_ripemd320_ops);
! 833: php_hash_register_algo("whirlpool", &php_hash_whirlpool_ops);
! 834: php_hash_register_algo("tiger128,3", &php_hash_3tiger128_ops);
! 835: php_hash_register_algo("tiger160,3", &php_hash_3tiger160_ops);
! 836: php_hash_register_algo("tiger192,3", &php_hash_3tiger192_ops);
! 837: php_hash_register_algo("tiger128,4", &php_hash_4tiger128_ops);
! 838: php_hash_register_algo("tiger160,4", &php_hash_4tiger160_ops);
! 839: php_hash_register_algo("tiger192,4", &php_hash_4tiger192_ops);
! 840: php_hash_register_algo("snefru", &php_hash_snefru_ops);
! 841: php_hash_register_algo("snefru256", &php_hash_snefru_ops);
! 842: php_hash_register_algo("gost", &php_hash_gost_ops);
! 843: php_hash_register_algo("adler32", &php_hash_adler32_ops);
! 844: php_hash_register_algo("crc32", &php_hash_crc32_ops);
! 845: php_hash_register_algo("crc32b", &php_hash_crc32b_ops);
! 846: php_hash_register_algo("salsa10", &php_hash_salsa10_ops);
! 847: php_hash_register_algo("salsa20", &php_hash_salsa20_ops);
! 848:
! 849: PHP_HASH_HAVAL_REGISTER(3,128);
! 850: PHP_HASH_HAVAL_REGISTER(3,160);
! 851: PHP_HASH_HAVAL_REGISTER(3,192);
! 852: PHP_HASH_HAVAL_REGISTER(3,224);
! 853: PHP_HASH_HAVAL_REGISTER(3,256);
! 854:
! 855: PHP_HASH_HAVAL_REGISTER(4,128);
! 856: PHP_HASH_HAVAL_REGISTER(4,160);
! 857: PHP_HASH_HAVAL_REGISTER(4,192);
! 858: PHP_HASH_HAVAL_REGISTER(4,224);
! 859: PHP_HASH_HAVAL_REGISTER(4,256);
! 860:
! 861: PHP_HASH_HAVAL_REGISTER(5,128);
! 862: PHP_HASH_HAVAL_REGISTER(5,160);
! 863: PHP_HASH_HAVAL_REGISTER(5,192);
! 864: PHP_HASH_HAVAL_REGISTER(5,224);
! 865: PHP_HASH_HAVAL_REGISTER(5,256);
! 866:
! 867: REGISTER_LONG_CONSTANT("HASH_HMAC", PHP_HASH_HMAC, CONST_CS | CONST_PERSISTENT);
! 868:
! 869: #ifdef PHP_MHASH_BC
! 870: mhash_init(INIT_FUNC_ARGS_PASSTHRU);
! 871: #endif
! 872:
! 873: return SUCCESS;
! 874: }
! 875: /* }}} */
! 876:
! 877: /* {{{ PHP_MSHUTDOWN_FUNCTION
! 878: */
! 879: PHP_MSHUTDOWN_FUNCTION(hash)
! 880: {
! 881: zend_hash_destroy(&php_hash_hashtable);
! 882:
! 883: return SUCCESS;
! 884: }
! 885: /* }}} */
! 886:
! 887: /* {{{ PHP_MINFO_FUNCTION
! 888: */
! 889: PHP_MINFO_FUNCTION(hash)
! 890: {
! 891: HashPosition pos;
! 892: char buffer[2048];
! 893: char *s = buffer, *e = s + sizeof(buffer), *str;
! 894: ulong idx;
! 895: long type;
! 896:
! 897: for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
! 898: (type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, NULL, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT;
! 899: zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
! 900: s += slprintf(s, e - s, "%s ", str);
! 901: }
! 902: *s = 0;
! 903:
! 904: php_info_print_table_start();
! 905: php_info_print_table_row(2, "hash support", "enabled");
! 906: php_info_print_table_row(2, "Hashing Engines", buffer);
! 907: php_info_print_table_end();
! 908: }
! 909: /* }}} */
! 910:
! 911: /* {{{ arginfo */
! 912: #ifdef PHP_HASH_MD5_NOT_IN_CORE
! 913: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5, 0, 0, 1)
! 914: ZEND_ARG_INFO(0, str)
! 915: ZEND_ARG_INFO(0, raw_output)
! 916: ZEND_END_ARG_INFO()
! 917:
! 918: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5_file, 0, 0, 1)
! 919: ZEND_ARG_INFO(0, filename)
! 920: ZEND_ARG_INFO(0, raw_output)
! 921: ZEND_END_ARG_INFO()
! 922: #endif
! 923:
! 924: #ifdef PHP_HASH_SHA1_NOT_IN_CORE
! 925: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1, 0, 0, 1)
! 926: ZEND_ARG_INFO(0, str)
! 927: ZEND_ARG_INFO(0, raw_output)
! 928: ZEND_END_ARG_INFO()
! 929:
! 930: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1_file, 0, 0, 1)
! 931: ZEND_ARG_INFO(0, filename)
! 932: ZEND_ARG_INFO(0, raw_output)
! 933: ZEND_END_ARG_INFO()
! 934: #endif
! 935:
! 936: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash, 0, 0, 2)
! 937: ZEND_ARG_INFO(0, algo)
! 938: ZEND_ARG_INFO(0, data)
! 939: ZEND_ARG_INFO(0, raw_output)
! 940: ZEND_END_ARG_INFO()
! 941:
! 942: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_file, 0, 0, 2)
! 943: ZEND_ARG_INFO(0, algo)
! 944: ZEND_ARG_INFO(0, filename)
! 945: ZEND_ARG_INFO(0, raw_output)
! 946: ZEND_END_ARG_INFO()
! 947:
! 948: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac, 0, 0, 3)
! 949: ZEND_ARG_INFO(0, algo)
! 950: ZEND_ARG_INFO(0, data)
! 951: ZEND_ARG_INFO(0, key)
! 952: ZEND_ARG_INFO(0, raw_output)
! 953: ZEND_END_ARG_INFO()
! 954:
! 955: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac_file, 0, 0, 3)
! 956: ZEND_ARG_INFO(0, algo)
! 957: ZEND_ARG_INFO(0, filename)
! 958: ZEND_ARG_INFO(0, key)
! 959: ZEND_ARG_INFO(0, raw_output)
! 960: ZEND_END_ARG_INFO()
! 961:
! 962: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_init, 0, 0, 1)
! 963: ZEND_ARG_INFO(0, algo)
! 964: ZEND_ARG_INFO(0, options)
! 965: ZEND_ARG_INFO(0, key)
! 966: ZEND_END_ARG_INFO()
! 967:
! 968: ZEND_BEGIN_ARG_INFO(arginfo_hash_update, 0)
! 969: ZEND_ARG_INFO(0, context)
! 970: ZEND_ARG_INFO(0, data)
! 971: ZEND_END_ARG_INFO()
! 972:
! 973: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_stream, 0, 0, 2)
! 974: ZEND_ARG_INFO(0, context)
! 975: ZEND_ARG_INFO(0, handle)
! 976: ZEND_ARG_INFO(0, length)
! 977: ZEND_END_ARG_INFO()
! 978:
! 979: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_file, 0, 0, 2)
! 980: ZEND_ARG_INFO(0, context)
! 981: ZEND_ARG_INFO(0, filename)
! 982: ZEND_ARG_INFO(0, context)
! 983: ZEND_END_ARG_INFO()
! 984:
! 985: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_final, 0, 0, 1)
! 986: ZEND_ARG_INFO(0, context)
! 987: ZEND_ARG_INFO(0, raw_output)
! 988: ZEND_END_ARG_INFO()
! 989:
! 990: ZEND_BEGIN_ARG_INFO(arginfo_hash_copy, 0)
! 991: ZEND_ARG_INFO(0, context)
! 992: ZEND_END_ARG_INFO()
! 993:
! 994: ZEND_BEGIN_ARG_INFO(arginfo_hash_algos, 0)
! 995: ZEND_END_ARG_INFO()
! 996:
! 997: /* BC Land */
! 998: #ifdef PHP_MHASH_BC
! 999: ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_block_size, 0)
! 1000: ZEND_ARG_INFO(0, hash)
! 1001: ZEND_END_ARG_INFO()
! 1002:
! 1003: ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_hash_name, 0)
! 1004: ZEND_ARG_INFO(0, hash)
! 1005: ZEND_END_ARG_INFO()
! 1006:
! 1007: ZEND_BEGIN_ARG_INFO(arginfo_mhash_keygen_s2k, 0)
! 1008: ZEND_ARG_INFO(0, hash)
! 1009: ZEND_ARG_INFO(0, input_password)
! 1010: ZEND_ARG_INFO(0, salt)
! 1011: ZEND_ARG_INFO(0, bytes)
! 1012: ZEND_END_ARG_INFO()
! 1013:
! 1014: ZEND_BEGIN_ARG_INFO(arginfo_mhash_count, 0)
! 1015: ZEND_END_ARG_INFO()
! 1016:
! 1017: ZEND_BEGIN_ARG_INFO_EX(arginfo_mhash, 0, 0, 2)
! 1018: ZEND_ARG_INFO(0, hash)
! 1019: ZEND_ARG_INFO(0, data)
! 1020: ZEND_ARG_INFO(0, key)
! 1021: ZEND_END_ARG_INFO()
! 1022: #endif
! 1023:
! 1024: /* }}} */
! 1025:
! 1026: /* {{{ hash_functions[]
! 1027: */
! 1028: const zend_function_entry hash_functions[] = {
! 1029: PHP_FE(hash, arginfo_hash)
! 1030: PHP_FE(hash_file, arginfo_hash_file)
! 1031:
! 1032: PHP_FE(hash_hmac, arginfo_hash_hmac)
! 1033: PHP_FE(hash_hmac_file, arginfo_hash_hmac_file)
! 1034:
! 1035: PHP_FE(hash_init, arginfo_hash_init)
! 1036: PHP_FE(hash_update, arginfo_hash_update)
! 1037: PHP_FE(hash_update_stream, arginfo_hash_update_stream)
! 1038: PHP_FE(hash_update_file, arginfo_hash_update_file)
! 1039: PHP_FE(hash_final, arginfo_hash_final)
! 1040: PHP_FE(hash_copy, arginfo_hash_copy)
! 1041:
! 1042: PHP_FE(hash_algos, arginfo_hash_algos)
! 1043:
! 1044: /* BC Land */
! 1045: #ifdef PHP_HASH_MD5_NOT_IN_CORE
! 1046: PHP_NAMED_FE(md5, php_if_md5, arginfo_hash_md5)
! 1047: PHP_NAMED_FE(md5_file, php_if_md5_file, arginfo_hash_md5_file)
! 1048: #endif /* PHP_HASH_MD5_NOT_IN_CORE */
! 1049:
! 1050: #ifdef PHP_HASH_SHA1_NOT_IN_CORE
! 1051: PHP_NAMED_FE(sha1, php_if_sha1, arginfo_hash_sha1)
! 1052: PHP_NAMED_FE(sha1_file, php_if_sha1_file, arginfo_hash_sha1_file)
! 1053: #endif /* PHP_HASH_SHA1_NOT_IN_CORE */
! 1054:
! 1055: #ifdef PHP_MHASH_BC
! 1056: PHP_FE(mhash_keygen_s2k, arginfo_mhash_keygen_s2k)
! 1057: PHP_FE(mhash_get_block_size, arginfo_mhash_get_block_size)
! 1058: PHP_FE(mhash_get_hash_name, arginfo_mhash_get_hash_name)
! 1059: PHP_FE(mhash_count, arginfo_mhash_count)
! 1060: PHP_FE(mhash, arginfo_mhash)
! 1061: #endif
! 1062:
! 1063: PHP_FE_END
! 1064: };
! 1065: /* }}} */
! 1066:
! 1067: /* {{{ hash_module_entry
! 1068: */
! 1069: zend_module_entry hash_module_entry = {
! 1070: #if ZEND_MODULE_API_NO >= 20010901
! 1071: STANDARD_MODULE_HEADER,
! 1072: #endif
! 1073: PHP_HASH_EXTNAME,
! 1074: hash_functions,
! 1075: PHP_MINIT(hash),
! 1076: PHP_MSHUTDOWN(hash),
! 1077: NULL, /* RINIT */
! 1078: NULL, /* RSHUTDOWN */
! 1079: PHP_MINFO(hash),
! 1080: #if ZEND_MODULE_API_NO >= 20010901
! 1081: PHP_HASH_EXTVER, /* Replace with version number for your extension */
! 1082: #endif
! 1083: STANDARD_MODULE_PROPERTIES
! 1084: };
! 1085: /* }}} */
! 1086:
! 1087: #ifdef COMPILE_DL_HASH
! 1088: ZEND_GET_MODULE(hash)
! 1089: #endif
! 1090:
! 1091: /*
! 1092: * Local variables:
! 1093: * tab-width: 4
! 1094: * c-basic-offset: 4
! 1095: * End:
! 1096: * vim600: noet sw=4 ts=4 fdm=marker
! 1097: * vim<600: noet sw=4 ts=4
! 1098: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hash.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / hash