static inline void _http_response_object_declare_default_properties(TSRMLS_D) { zend_class_entry *ce = http_response_object_ce; DCL_STATIC_PROP(PRIVATE, bool, sent, 0); DCL_STATIC_PROP(PRIVATE, bool, catch, 0); DCL_STATIC_PROP(PRIVATE, long, mode, -1); DCL_STATIC_PROP(PRIVATE, long, stream, 0); DCL_STATIC_PROP_N(PRIVATE, file); DCL_STATIC_PROP_N(PRIVATE, data); DCL_STATIC_PROP(PROTECTED, bool, cache, 0); DCL_STATIC_PROP(PROTECTED, bool, gzip, 0); DCL_STATIC_PROP_N(PROTECTED, eTag); DCL_STATIC_PROP(PROTECTED, long, lastModified, 0); DCL_STATIC_PROP_N(PROTECTED, cacheControl); DCL_STATIC_PROP_N(PROTECTED, contentType); DCL_STATIC_PROP_N(PROTECTED, contentDisposition); DCL_STATIC_PROP(PROTECTED, long, bufferSize, HTTP_SENDBUF_SIZE); DCL_STATIC_PROP(PROTECTED, double, throttleDelay, 0.0); #ifndef WONKY DCL_CONST(long, "REDIRECT", HTTP_REDIRECT); DCL_CONST(long, "REDIRECT_PERM", HTTP_REDIRECT_PERM); DCL_CONST(long, "REDIRECT_POST", HTTP_REDIRECT_POST); DCL_CONST(long, "REDIRECT_TEMP", HTTP_REDIRECT_TEMP); DCL_CONST(long, "ETAG_MD5", HTTP_ETAG_MD5); DCL_CONST(long, "ETAG_SHA1", HTTP_ETAG_SHA1); DCL_CONST(long, "ETAG_CRC32", HTTP_ETAG_CRC32); # ifdef HTTP_HAVE_MHASH { int l, i, c = mhash_count(); for (i = 0; i <= c; ++i) { char const_name[256] = {0}; const char *hash_name = mhash_get_hash_name_static(i); if (hash_name) { l = snprintf(const_name, 255, "ETAG_MHASH_%s", hash_name); zend_declare_class_constant_long(ce, const_name, l, i TSRMLS_CC); } } } # endif /* HTTP_HAVE_MHASH */ #endif /* WONKY */ }
int main(void) { hashid hashid; const char *s; int ok, allok = 1; for(hashid = 0; hashid <= mhash_count(); hashid++) if ((s = mhash_get_hash_name_static(hashid)) && mhash_get_hash_pblock(hashid)) { printf("Checking fragmentation capabilities of %s: ", s); fflush(stdout); printf((ok = frag_test(hashid)) ? "OK\n" : "Failed\n"); allok &= ok; } return allok ? 0 : 1; }
int main(void) { int i, buf_len; MHASH td1, td2, td3; const unsigned char *buf = "This is a test buffer to test saving and restoring, see?"; unsigned char *hash1, *hash2; hashid alg; char mem[1024]; int mem_size = sizeof(mem); buf_len = strlen(buf); /* NOTE: For laziness sake, I just loop through the enum, skipping invalid integers. If the enum should change, this loop will have to change! */ for (alg = 0; alg <= mhash_count(); ++alg) { /* if algorithm does not exist */ if (mhash_get_hash_name_static( alg)==NULL) continue; printf("Testing save/restore for algorithm %s: ", mhash_get_hash_name(alg)); td1 = mhash_init(alg); if (td1 == MHASH_FAILED) { fprintf(stderr, "Failed to init td1.\n"); exit(1); } for (i = 0; i < buf_len; ++i) mhash(td1, buf+i, 1); hash1 = mhash_end(td1); /* printf("Hash 1: "); for (i = 0; i < mhash_get_block_size(alg); ++i) printf("%.2x", hash1[i]); printf("\n"); */ td2 = mhash_init(alg); if (td2 == MHASH_FAILED) { fprintf(stderr, "Failed to init td2.\n"); exit(1); } for (i = 0; i < buf_len/2; ++i) mhash(td2, buf+i, 1); if (mhash_save_state_mem(td2, mem, &mem_size)!=0) { fprintf(stderr, "Error saving state. Size: %d\n", mem_size); exit(1); } td3 = mhash_restore_state_mem( mem); if (td3 == MHASH_FAILED) { fprintf(stderr, "Error restoring state.\n"); exit(1); } for (i = buf_len/2; i < buf_len; ++i) mhash(td3, buf+i, 1); hash2 = mhash_end(td3); /* printf("Hash 2: "); for (i = 0; i < mhash_get_block_size(alg); ++i) printf("%.2x", hash2[i]); printf("\n"); */ if (memcmp(hash1, hash2, mhash_get_block_size(alg)) == 0) { printf("Ok\n"); } else { printf("Failed\n"); exit(1); } } exit(0); }
int main(void) { mutils_word32 i; mutils_word32 buf_len; MHASH td1, td2, td3; const mutils_word8 *buf = (mutils_word8 *) "This is a test buffer to test saving and restoring, see?"; mutils_word8 *hash1; mutils_word8 *hash2; hashid alg; mutils_word8 mem[1024]; mutils_word32 mem_size = sizeof(mem); buf_len = mutils_strlen(buf); /* * NOTE: For laziness sake, I just loop through the enum, * skipping invalid integers. * * If the enum should change, this loop will have to change! */ for (alg = 0; alg <= mhash_count(); ++alg) { /* if algorithm does not exist */ if (mhash_get_hash_name_static(alg) == (mutils_word8 *) NULL) continue; printf("Testing save/restore for algorithm %s: ", mhash_get_hash_name(alg)); td1 = mhash_init(alg); if (td1 == MHASH_FAILED) { fprintf(stderr, "Failed to init td1.\n"); exit(MUTILS_INVALID_FUNCTION); } for (i = 0; i < buf_len; ++i) { mhash(td1, buf+i, 1); } hash1 = mhash_end(td1); td2 = mhash_init(alg); if (td2 == MHASH_FAILED) { fprintf(stderr, "Failed to init td2.\n"); exit(MUTILS_INVALID_FUNCTION); } for (i = 0; i < buf_len/2; ++i) { mhash(td2, buf+i, 1); } if (mhash_save_state_mem(td2, mem, &mem_size)!=0) { fprintf(stderr, "Error saving state. Size: %d\n", mem_size); exit(MUTILS_INVALID_RESULT); } td3 = mhash_restore_state_mem( mem); if (td3 == MHASH_FAILED) { fprintf(stderr, "Error restoring state.\n"); exit(MUTILS_INVALID_RESULT); } for (i = buf_len/2; i < buf_len; ++i) { mhash(td3, buf+i, 1); } hash2 = mhash_end(td3); if (mutils_memcmp(hash1, hash2, mhash_get_block_size(alg)) == 0) { printf("Ok\n"); } else { printf("Failed\n"); exit(MUTILS_INVALID_RESULT); } } exit(MUTILS_OK); }