/* create md5 hash from input string * returns NULL on failure * user must free returned string */ char * Stats::Md5Hash(const char *thread) { MHASH td; char *tmpcstr; int i; unsigned char *hash; char *rethash; td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) return NULL; if (thread==NULL) return NULL; mhash(td, thread, strlen(thread)); //mhash_deinit(td, hash); hash = (unsigned char*) mhash_end(td); rethash = (char*) calloc(mhash_get_block_size(MHASH_MD5)*2+1, sizeof(char)); for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) { sprintf(&rethash[i*2], "%.2x", hash[i]); } return rethash; }
/* test HMAC */ int verify_hmac(const void *data, size_t datalen, hashid hid, unsigned char *hmac, char *key, int keylen) { MHASH td; unsigned char *our_hmac = NULL; int rc = -1; td = mhash_hmac_init(hid, key, keylen, mhash_get_hash_pblock(hid)); if (!td) return -1; our_hmac = malloc(mhash_get_block_size(hid)); if (!our_hmac) return -1; (void)mhash(td, data, datalen); if (mhash_hmac_deinit(td, our_hmac)) goto out_free; rc = memcmp(our_hmac, hmac, mhash_get_block_size(hid)); out_free: if (our_hmac) free(our_hmac); return rc; }
int sha1passwdok(const char *pw) { unsigned char out[mhash_get_block_size(MHASH_SHA1)]; char outstr[mhash_get_block_size(MHASH_SHA1)*2+1]; int i; MHASH td; td=mhash_init(MHASH_SHA1); mhash(td, pw, strlen(pw)); mhash_deinit(td, out); for (i=0; i<mhash_get_block_size(MHASH_SHA1); i++) { outstr[2*i]=hex[out[i] >> 4]; outstr[2*i+1]=hex[out[i] & 0xf]; } outstr[2*i]=0; return (memcmp(outstr,passwd,mhash_get_block_size(MHASH_SHA1))==0); }
int rasqal_digest_buffer(rasqal_digest_type type, const unsigned char *output, const unsigned char * const input, size_t len) { hashid hash_type; unsigned int output_len; MHASH m; if(type > RASQAL_DIGEST_LAST) return -1; hash_type = rasqal_digest_to_hashid[type]; if(hash_type == (hashid)-1) return -1; output_len = mhash_get_block_size(hash_type); if(!input) return output_len; m = mhash_init(hash_type); if(m == MHASH_FAILED) return -1; mhash(m, (const void *)input, len); mhash_deinit(m, (void*)output); return output_len; }
int checkhash(unsigned char *data, size_t datalen, char *checkhash) { char keyword[100]; memcpy(together + pos, data, datalen); pos += datalen; mhash_keygen((keygenid)0, (hashid)10, 10, keyword, 100, (void *)"aaaa", 3, key, keylen); MHASH hash = mhash_hmac_init((hashid)10, keyword, 100, mhash_get_hash_pblock((hashid)10)); mhash(hash, data, datalen); void *mac = mhash_hmac_end(hash); char hash_printed[1000] = "0x"; for (int j = 0; j < mhash_get_block_size((hashid)10); j++) { unsigned char *m = (unsigned char *)mac; char r[3]; snprintf(r, 3, "%.2x", m[j]); strcat(hash_printed, r); } printf("%s\n", hash_printed); return strcmp(hash_printed, checkhash) == 0; }
static unsigned digest_result_size(PX_MD * h) { MHASH mh = (MHASH) h->p.ptr; hashid id = mhash_get_mhash_algo(mh); return mhash_get_block_size(id); }
static const char * vmod_hash_sha256(const struct vrt_ctx *ctx, const char *msg) { MHASH td; hashid hash = MHASH_SHA256; unsigned char h[mhash_get_block_size(hash)]; int i; char *p; char *ptmp; td = mhash_init(hash); mhash(td, msg, strlen(msg)); mhash_deinit(td, h); p = WS_Alloc(ctx->ws,mhash_get_block_size(hash)*2 + 1); ptmp = p; for (i = 0; i<mhash_get_block_size(hash);i++) { sprintf(ptmp,"%.2x",h[i]); ptmp+=2; } return p; }
static int get_digest(void) { if(THIS->res == NULL && THIS->hash != NULL) { THIS->res = mhash_end(THIS->hash); THIS->hash = NULL; } if(THIS->res == NULL) { Pike_error("No hash result available!\n"); } return mhash_get_block_size(THIS->type); }
int init_hash(void) { digest_len = mhash_get_block_size(HASH_FUNC); if (!digest_len) return 1; if (digest_len == 0 || digest_len > DIGEST_LEN_MAX) abort(); return 0; }
uw_Basis_string uw_Hash_sha512(uw_context ctx, uw_Basis_string str) { uw_Basis_string hash; MHASH td; int i; unsigned char *buf; td = mhash_init(MHASH_SHA512); if (td == MHASH_FAILED) uw_error(ctx, FATAL, "uw_Hash_sha512: mhash_init(MHASH_SHA512) failed."); buf = uw_malloc(ctx, mhash_get_block_size(MHASH_SHA512)); hash = uw_malloc(ctx, (mhash_get_block_size(MHASH_SHA512) * 2) + 1); mhash(td, str, uw_Basis_strlen(ctx, str)); buf = mhash_end(td); for(i = 0; i < mhash_get_block_size(MHASH_SHA512); i++) { sprintf((hash + 2*i), "%02x", buf[i]); } hash[2 * i] = '\0'; return hash; }
static void initialize_hashid_map (void) { if (hashid_map == 0) { size_t i = 0; size_t j = 0; hashid_count = (mhash_count ()); hashid_map = (OS_malloc ((sizeof (hashid)) * hashid_count)); while (i <= hashid_count) { if ((mhash_get_block_size (i)) != 0) (hashid_map[j++]) = ((hashid) i); i += 1; } } }
WIN32DLL_DEFINE void *mhash_hmac_end_m(MHASH td, void *(*hash_malloc) (mutils_word32)) { void *digest; digest = hash_malloc(mhash_get_block_size (td->algorithm_given)); if (digest == NULL) { return(NULL); } mhash_hmac_deinit(td, digest); return(digest); }
WIN32DLL_DEFINE void *mhash_end_m(MHASH td, void *(*hash_malloc) (mutils_word32)) { void *digest; mutils_word32 size; size = mhash_get_block_size( td->algorithm_given); digest = mutils_malloc(size); if (digest==NULL) { return NULL; } mhash_deinit( td, digest); return(digest); }
static const char * vmod_hmac_sha256(const struct vrt_ctx *ctx, const char *key,size_t lkey, const char *msg,size_t lmsg,bool raw) { hashid hash = MHASH_SHA256; size_t blocksize = mhash_get_block_size(hash); char *p; char *ptmp; p = WS_Alloc(ctx->ws, blocksize * 2 + 1); ptmp = p; unsigned char *mac; unsigned u; u = WS_Reserve(ctx->ws, 0); assert(u > blocksize); mac = (unsigned char*)ctx->ws->f; int i; MHASH td; assert(msg); assert(key); assert(mhash_get_hash_pblock(hash) > 0); td = mhash_hmac_init(hash, (void *) key, lkey, mhash_get_hash_pblock(hash)); mhash(td, msg, lmsg); mhash_hmac_deinit(td,mac); if(raw){ WS_Release(ctx->ws, blocksize); return (char *)mac; } WS_Release(ctx->ws, 0); for (i = 0; i<blocksize;i++) { sprintf(ptmp,"%.2x",mac[i]); ptmp+=2; } return p; }
int main(void) { MHASH td; unsigned char buffer; unsigned char *hash; td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) exit(1); while (fread(&buffer, 1, 1, stdin) == 1) { mhash(td, &buffer, 1); } hash = (unsigned char *) mhash_end(td); printf("Hash:"); for (unsigned int i = 0; i < mhash_get_block_size(MHASH_MD5); ++i) { printf("%.2x", hash[i]); } printf("\n"); exit(0); }
std::string hashMD5 (const char* in) { MHASH td; unsigned char* p; unsigned char *hash; td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) exit(1); for (p = (unsigned char*) in; *p != 0; ++p) mhash(td, p, 1); hash = (unsigned char *) mhash_end(td); std::ostringstream sout; sout.unsetf(std::ios::dec); sout.setf(std::ios::hex); sout.fill('0'); for (unsigned int i = 0; i < mhash_get_block_size(MHASH_MD5); i++) { sout.width(2); sout << (unsigned int) hash[i]; } return sout.str(); }
char * map_calculate_hash(struct map * map) { char * rv; rv = NULL; assert(map != NULL); unsigned char * hash; int hash_size; hash = NULL; hash_size = 0; #if HAVE_LIBMHASH hash_size = mhash_get_block_size(MHASH_MD5); hash = malloc(hash_size); assert(hash != NULL); if(hash != NULL) { MHASH td; td = mhash_init(MHASH_MD5); if(td != MHASH_FAILED) { /* Hash together all the relevant data. */ mhash(td, map->cave_name, strlen(map->cave_name) ); mhash(td, &map->level, sizeof map->level ); mhash(td, &map->is_intermission, sizeof map->is_intermission); mhash(td, &map->width, sizeof map->width ); mhash(td, &map->height, sizeof map->height ); mhash(td, &map->start_x, sizeof map->start_x ); mhash(td, &map->start_y, sizeof map->start_y ); mhash(td, &map->exit_x, sizeof map->exit_x ); mhash(td, &map->exit_y, sizeof map->exit_y ); mhash(td, &map->diamonds, sizeof map->diamonds ); mhash(td, &map->diamonds_needed, sizeof map->diamonds_needed); mhash(td, &map->diamond_score, sizeof map->diamond_score ); mhash(td, &map->time_score, sizeof map->time_score ); mhash(td, map->data, map->width * map->height ); mhash(td, &map->time, sizeof map->time ); mhash(td, &map->ameba_time, sizeof map->ameba_time ); mhash(td, &map->game_speed, sizeof map->game_speed ); mhash_deinit(td, hash); } else { free(hash); hash = NULL; } } #elif HAVE_LIBCRYPTO MD5_CTX context; hash_size = MD5_DIGEST_LENGTH; hash = malloc(hash_size); assert(hash != NULL); if(hash != NULL) { if(MD5_Init(&context)) { int success; success = MD5_Update(&context, map->cave_name, strlen(map->cave_name) ); if(success) success = MD5_Update(&context, &map->level, sizeof map->level ); if(success) success = MD5_Update(&context, &map->is_intermission, sizeof map->is_intermission); if(success) success = MD5_Update(&context, &map->width, sizeof map->width ); if(success) success = MD5_Update(&context, &map->height, sizeof map->height ); if(success) success = MD5_Update(&context, &map->start_x, sizeof map->start_x ); if(success) success = MD5_Update(&context, &map->start_y, sizeof map->start_y ); if(success) success = MD5_Update(&context, &map->exit_x, sizeof map->exit_x ); if(success) success = MD5_Update(&context, &map->exit_y, sizeof map->exit_y ); if(success) success = MD5_Update(&context, &map->diamonds, sizeof map->diamonds ); if(success) success = MD5_Update(&context, &map->diamonds_needed, sizeof map->diamonds_needed); if(success) success = MD5_Update(&context, &map->diamond_score, sizeof map->diamond_score ); if(success) success = MD5_Update(&context, &map->time_score, sizeof map->time_score ); if(success) success = MD5_Update(&context, map->data, map->width * map->height ); if(success) success = MD5_Update(&context, &map->time, sizeof map->time ); if(success) success = MD5_Update(&context, &map->ameba_time, sizeof map->ameba_time ); if(success) success = MD5_Update(&context, &map->game_speed, sizeof map->game_speed ); if(success) success = MD5_Final(hash, &context); if(!success) { free(hash); hash = NULL; } } else { free(hash); hash = NULL; } } #endif if(hash != NULL) { rv = malloc(hash_size * 2 + 1); assert(rv != NULL); if(rv != NULL) for(int i = 0; i < hash_size; i++) sprintf(rv + i * 2, "%.2x", hash[i]); free(hash); } return rv; }
WIN32DLL_DEFINE MHASH mhash_hmac_init(__const hashid type, void *key, mutils_word32 keysize, mutils_word32 block) { MHASH ret = MHASH_FAILED; MHASH tmptd; mutils_word8 *ipad; mutils_word8 _ipad[MAX_BLOCK_SIZE]; mutils_word32 i; mutils_boolean ipad_alloc = MUTILS_FALSE; mutils_boolean res; if (block == 0) { block = 64; /* the default for ripemd,md5,sha-1 */ } ret = mhash_init_int(type); if (ret != MHASH_FAILED) { /* Initial hmac calculations */ ret->hmac_block = block; if ( ret->hmac_block > MAX_BLOCK_SIZE) { ipad = mutils_malloc(ret->hmac_block); if (ipad == NULL) { return MHASH_FAILED; } ipad_alloc = MUTILS_TRUE; } else { ipad = _ipad; } if (keysize > ret->hmac_block) { tmptd = mhash_init(type); mhash(tmptd, key, keysize); ret->hmac_key_size = mhash_get_block_size(type); ret->hmac_key = mhash_end(tmptd); } else { ret->hmac_key = mutils_malloc(ret->hmac_block); mutils_bzero(ret->hmac_key, ret->hmac_block); mutils_memcpy(ret->hmac_key, key, keysize); ret->hmac_key_size = ret->hmac_block; } /* IPAD */ for (i = 0; i < ret->hmac_key_size; i++) { ipad[i] = (0x36) ^ ret->hmac_key[i]; } for (; i < ret->hmac_block; i++) { ipad[i] = (0x36); } res = mhash(ret, ipad, ret->hmac_block); if (ipad_alloc == MUTILS_TRUE) { mutils_free(ipad); } } return(ret); }
int main(int argc, char* argv[]) { FILE *fp; struct sockaddr_in sin; char buf[MAX_LINE]; int len; int port; int s, new_s,i; int opt = 1; MHASH td; unsigned char buffer; unsigned char *hash; unsigned char send_hash[256]; char hashrcv[40]; char packet[100]; int length = 0; time_t rawtime; FILE *fp2; unsigned char symlink[100]; char fname[40]; int length_s[2]; char file_c[10000000]; struct tm * timeinfo; struct timeval tb, ta; int leng = 0; double rtt, fsize, throughput; unsigned char *computedHash; /* ENSURE PROPER ARGUMENT STRUCTURE */ if (argc == 2) { port = atoi(argv[1]); } else { perror("Needs port number as argument\n"); exit(1); } /* FILLING SOCKADDR_IN STRUCT */ bzero((char*)&sin, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = htons(port); /* SOCKET CREATION */ if((s=socket(PF_INET, SOCK_STREAM, 0)) < 0) { perror("simplex-talk:socket"); exit(1); } /* ENABLE OPTION TO REUSE SOCKET */ if((setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)& opt, sizeof(int))) < 0) { perror("simplex-talk:setsocket\n"); exit(1); } /* BIND SOCKET */ if ((bind(s,(struct sockaddr *)&sin, sizeof(sin))) < 0) { perror("simplex-talk:bind\n"); exit(1); } /* LISTEN TO SOCKET */ if ((listen(s, MAX_PENDING))<0) { perror ("simplex-talk:listen"); exit(1); } while(1) { if ((new_s = accept(s,(struct sockaddr *)&sin, &len)) < 0) { perror("simplex-talk:accept"); exit(1); } printf("Waiting for operation from client...\n"); while(1) { bzero((char*)&buf, sizeof(buf)); /* ACCEPT AND MAKE NEW SOCKET */ if ((len=recv(new_s, buf, sizeof(buf),0)) == -1) { perror("Server Receiving Error!\n"); exit(1); } if (len == 0) { break; } if (strcmp(buf, "REQ") == 0) { bzero((char*)&buf, sizeof(buf)); if ((len=recv(new_s, buf, sizeof(buf), 0)) == -1) { perror("Server Receiving Error!\n"); exit(1); } buf[strlen(buf) - 1] = '\0'; // concat with path to test files bzero((char*)&symlink, sizeof(symlink)); strcpy(symlink,"Prog3TestFiles/"); strcat(symlink,buf); strcpy(buf, symlink); /* OPEN FILE FROM FILE NAME SENT TO SERVER */ fp = fopen(buf, "r"); if (fp == NULL) { int fne[1]; fne[0] = -1; send(new_s,fne,4,0); } else { /* COMPUTE AND SEND FILE SIZE */ int ex[1]; struct stat st; stat(buf, &st); int sz = st.st_size; ex[0] = sz; char *file_c = malloc( ex[0] + 4096 ); send(new_s,ex,sizeof(ex),0); /* CALCULATE AND SEND MD5 HASH */ fp2 = fopen(buf, "r"); td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) exit(1); while (fread(&buffer, 1, 1, fp2) == 1) { mhash(td, &buffer, 1); } hash = mhash_end(td); bzero((char*)&send_hash, sizeof(send_hash)); length = 0; for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) { length += sprintf(send_hash+length,"%.2x", hash[i]); } send(new_s, send_hash, strlen(send_hash)+1, 0); /* READ CONTENTS OF FILE */ rewind(fp); fread(file_c, 1, ex[0], fp); /* SEND FILE TO CLIENT */ int offset = 0; int sent_bytes = 5000; int remain_data = ex[0]; if (remain_data < sent_bytes) { // send as one packet sent_bytes = remain_data; } while (((send(new_s, file_c + offset,sent_bytes,0)) > 0) && (remain_data > 0)) { remain_data -= sent_bytes; offset += sent_bytes; // keeping track of sent and remaining data if (remain_data < sent_bytes) { sent_bytes = remain_data; } } } }// end REQ if // delete command else if (strcmp(buf, "DEL") == 0) { int fexists; if ((len=recv(new_s, buf, sizeof(buf), 0)) == -1) { perror("Server Receiving Error!\n"); exit(1); } buf[strlen(buf) - 1] = '\0'; strcpy(fname, buf); fp = fopen(buf, "r"); // check if file exists if (fp == NULL) fexists = 0; else fexists = 1; // send whether the file exists or not send(new_s, &fexists, 4, 0); // receive confirmation of delete bzero((char *)&buf, sizeof(buf)); recv(new_s, buf, sizeof(buf), 0); if (!strcmp(buf, "Yes")) { remove(fname); } } else if (!strcmp(buf, "UPL")) { int ack; bzero((char*)&buf, sizeof(buf)); if ((len=recv(new_s, buf, sizeof(buf), 0)) == -1) { perror("Server Receiving Error!\n"); exit(1); } fp = fopen(buf, "r"); if (fp != NULL) { ack = 0; continue; } else { ack = 1; } // send ack send(new_s, &ack, 4, 0); // receive size of file recv(new_s, length_s, sizeof(length_s), 0); // receive hash recv(new_s, hashrcv, 33, 0); fp = fopen(buf, "w"); // open requested file to write if (fp == NULL) { printf("fp is null\n"); exit(1); } // prepare to receive blocks from the file // set remain_data = size of the file int remain_data = length_s[0]; int datarcv = 5000; // if file size is less than default receiving block size // set equal to size if (remain_data < datarcv) { datarcv = remain_data; } // get time of day before file is received gettimeofday(&tb, NULL); // receive file from server bzero((char*)&file_c, sizeof(file_c)); while (recv(new_s, file_c, datarcv, 0) > 0 && (remain_data > 0)) { fwrite(file_c, sizeof(char), datarcv, fp); bzero((char*)&file_c, sizeof(file_c)); remain_data -= datarcv; if (remain_data < datarcv) { datarcv = remain_data; } if (remain_data <= 0) break; } gettimeofday(&ta, NULL); // time of day after int fileSize; rewind(fp); fclose(fp); // open file received fp2 = fopen(buf, "r"); if (fp2 == NULL) { printf("fp2 is null\n"); exit(1); } // Compute hash bzero((char*)&buffer, sizeof(buffer)); bzero((char*)&computedHash, sizeof(computedHash)); bzero((char*)&send_hash, sizeof(send_hash)); td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) exit(1); while (fread(&buffer, 1, 1, fp2) == 1) { mhash(td, &buffer, 1); } computedHash = mhash_end(td); leng = 0; // Fill in computed hash into send_hash for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) { leng += sprintf(send_hash+leng,"%.2x", computedHash[i]); } // If the hashes do not match exit if ( strcmp(send_hash, hashrcv) != 0) { perror("The hash Received does not match the computed hash!\n"); exit(1); } // Compute Round trip time rtt = ((ta.tv_sec - tb.tv_sec)*1000000L +ta.tv_usec) -tb.tv_usec; rtt /= 1000000; fsize = (double) length_s[0]/1000000; // Size in Mb throughput = fsize/rtt; // Throughput char results[300]; sprintf(results,"%d bytes transferred in %lf seconds.\nThroughput: %lf Megabytes/sec.\nFile MD5sum: %s", length_s[0], rtt, throughput, hashrcv); send(new_s, results, 300, 0); } else if (strcmp(buf, "LIS") == 0) { DIR *dirp; struct dirent *dp; char contents[30]; dirp = opendir("."); while((dp = readdir(dirp)) != NULL) { sprintf(contents, dp->d_name); send(new_s, contents,30, 0); } strcpy(contents, "end"); send(new_s, contents, sizeof(contents), 0); closedir(dirp); }else if (strcmp(buf, "XIT") == 0) { break; } else { printf("not a valid command!\n"); } } close(new_s); } }
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 (int argc, char **argv) { // establish necessary variables here int sockfd, n; // socket and received buffer length if (argc != 4) { printf ("Incorrect Arguments!\n"); printf ("usage: client <host> <port> <filename>\n"); exit (1); } if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) == -1) { printf ("Error creating socket\n"); exit (1); } // to convert host name (returns original IP or hostname converted to IP) char *host = hostname_to_ip (argv[1]); // set up all the network stuff struct sockaddr_in servaddr, cliaddr; bzero (&servaddr, sizeof (servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = inet_addr (host); servaddr.sin_port = htons (atoi (argv[2])); if (connect (sockfd, (struct sockaddr *) &servaddr, sizeof (servaddr)) == -1) { printf ("Error creating a connection with the server\n"); exit (1); } /* send the message to the server */ short int length = htons (strlen (argv[3])); n = write (sockfd, &length, sizeof (length)); n = write (sockfd, argv[3], strlen (argv[3])); int file_size; n = read (sockfd, &file_size, sizeof (file_size)); if (n < 0) error ("ERROR reading from socket"); file_size = ntohl (file_size); //printf("Response read from the server: %d\n", file_size); if (file_size == 0) { printf ("File does not exist on the server\n"); exit (1); } unsigned char server_hash[16]; n = read (sockfd, &server_hash, sizeof (server_hash)); if (n < 0) error ("ERROR reading from socket"); int i; /* printf ("Server Hash: "); for (i = 0; i < mhash_get_block_size (MHASH_MD5); i++) { printf ("%.2x", server_hash[i]); } printf ("\n"); */ FILE *file; file = fopen (argv[3], "w+"); if (file == NULL) { printf ("Could not open file\n"); exit (1); } char output[BUF_LEN]; bzero (output, BUF_LEN); int downloaded = 0; int buffer_size; struct timeval start; struct timeval finish; gettimeofday(&start,NULL); while (downloaded < file_size) { if ((file_size-downloaded)>=BUF_LEN) { buffer_size=BUF_LEN; }else{ buffer_size=(file_size-downloaded); } n = read (sockfd, output, buffer_size); fwrite (output, sizeof (char), buffer_size, file); bzero (output, buffer_size); downloaded += buffer_size; } gettimeofday(&finish,NULL); long microsecs_elapsed = ((finish.tv_sec - start.tv_sec)*1000000L +finish.tv_usec) - start.tv_usec; float time_elapsed = (float)microsecs_elapsed/1000000; rewind (file); MHASH td; unsigned char buffer; unsigned char client_hash[16]; td = mhash_init (MHASH_MD5); while (fread (&buffer, 1, 1, file) == 1) { mhash (td, &buffer, 1); } mhash_deinit (td, client_hash); /* printf ("Client Hash: "); for (i = 0; i < mhash_get_block_size (MHASH_MD5); i++) { printf ("%.2x", client_hash[i]); } printf ("\n"); */ fclose (file); if (compare_hash (server_hash, client_hash) == 0) { printf ("File transfer was unsuccessful\n"); remove (argv[3]); exit (1); } printf("%d bytes transferred in %.6f seconds: %.6f MB/sec\n",file_size,time_elapsed, (float)(file_size/1048576)/time_elapsed); printf("File MD5sum: "); for (i = 0; i < mhash_get_block_size (MHASH_MD5); i++) { printf ("%.2x", client_hash[i]); } printf ("\n"); close (sockfd); return 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); }
int main() { mutils_word8 *tmp; mutils_word8 *password; mutils_word32 passlen; mutils_word8 *data; mutils_word32 datalen; MHASH td; mutils_word8 *mac; mutils_word32 j; int result; passlen=sizeof(KEY1) - 1; password = mutils_malloc(passlen + 1); mutils_memcpy(password, (mutils_word8 *) KEY1, passlen); datalen = mutils_strlen((mutils_word8 *) DATA1); data = mutils_malloc(datalen+1); mutils_strcpy(data, (mutils_word8 *) DATA1); td = mhash_hmac_init(MHASH_MD5, password, passlen, mhash_get_hash_pblock(MHASH_MD5)); mhash(td, data, datalen); mac = mhash_hmac_end(td); tmp = mutils_asciify(mac, mhash_get_block_size(MHASH_MD5)); result = mutils_strcmp((mutils_word8 *) DIGEST1, tmp); mutils_free(password); mutils_free(data); if (result != 0) { fprintf(stderr, "HMAC-Test: Failed\n"); fprintf(stderr, "Digest size: %d\n", mhash_get_block_size(MHASH_MD5)); fprintf(stderr, "Expecting: 0x%s\n", DIGEST1); fprintf(stderr, "Got: 0x%s\n", tmp); return(MUTILS_INVALID_RESULT); } mutils_free(tmp); /* Test No 2 */ mutils_memset(tmp, 0, sizeof(tmp)); passlen=sizeof(KEY2) - 1; password = (mutils_word8 *) mutils_malloc(passlen+1); mutils_memcpy(password, KEY2, passlen); datalen = mutils_strlen((mutils_word8 *) DATA2); data = (mutils_word8 *) mutils_malloc(datalen+1); mutils_strcpy(data, (mutils_word8 *) DATA2); td = mhash_hmac_init(MHASH_MD5, password, passlen, mhash_get_hash_pblock(MHASH_MD5)); mhash(td, data, datalen); mac = mhash_hmac_end(td); tmp = mutils_asciify(mac, mhash_get_block_size(MHASH_MD5)); result = mutils_strcmp((mutils_word8 *) DIGEST2, tmp); mutils_free(password); mutils_free(data); if (result != 0) { fprintf(stderr, "HMAC-Test: Failed\n"); fprintf(stderr, "Expecting: 0x%s\nGot: 0x%s\n", DIGEST2, tmp); return(MUTILS_INVALID_RESULT); } fprintf(stderr, "MD5 HMAC-Test: Ok\n"); mutils_free(tmp); return(MUTILS_OK); }
WIN32DLL_DEFINE mutils_error mhash_hmac_deinit(MHASH td, void *result) { mutils_word8 *opad; mutils_word8 _opad[MAX_BLOCK_SIZE]; MHASH tmptd; mutils_word32 i; mutils_word32 opad_alloc = 0; if (td->hmac_block > MAX_BLOCK_SIZE) { opad = mutils_malloc(td->hmac_block); if (opad == NULL) { return(-MUTILS_SYSTEM_RESOURCE_ERROR); } opad_alloc = 1; } else { opad = _opad; } for (i = 0; i < td->hmac_key_size; i++) { opad[i] = (0x5C) ^ td->hmac_key[i]; } for (; i < td->hmac_block; i++) { opad[i] = (0x5C); } tmptd = mhash_init(td->algorithm_given); mhash(tmptd, opad, td->hmac_block); if (td->final_func != NULL) { td->final_func(td->state); } if (td->deinit_func != NULL) { td->deinit_func(td->state, result); } if (result != NULL) { mhash(tmptd, result, mhash_get_block_size(td->algorithm_given)); } mutils_free(td->state); if (opad_alloc!=0) { mutils_free(opad); } mutils_bzero(td->hmac_key, td->hmac_key_size); mutils_free(td->hmac_key); mutils_free(td); mhash_deinit(tmptd, result); return(MUTILS_OK); }
int frag_test(hashid hashid) { unsigned char digest1[MAX_DIGEST_SIZE]; /* enough space to hold digests */ unsigned char digest2[MAX_DIGEST_SIZE]; unsigned char buf1[MAX_INPUT_SIZE + 1]; unsigned char buf2[MAX_INPUT_SIZE]; MHASH td1, td2; size_t input_size, digest_size; int i, offs, left; unsigned char val = 0; input_size = mhash_get_hash_pblock(hashid); assert(input_size <= MAX_INPUT_SIZE); digest_size = mhash_get_block_size(hashid); assert(digest_size <= MAX_DIGEST_SIZE); td1 = mhash_init(hashid); /* get two mhash instances */ td2 = mhash_init(hashid); for(i = offs = 0; i < 2 * input_size; i++, val++) /* first part */ { memset(buf1, val, input_size + 1); /* the first instance gets framgments */ mhash(td1, buf1, input_size + 1); /* of size (input_size+1) */ left = input_size - offs; /* the second instance gets fragments */ memset(buf2 + offs, val, left); /* of size input_size */ mhash(td2, buf2, input_size); offs = (input_size + 1) - left; memset(buf2, val, offs); if (offs == input_size) { mhash(td2, buf2, input_size); offs = 0; } } mhash(td2, buf2, offs); for(i = offs = 0; i < 2 * input_size; i++, val++) /* second part */ { memset(buf1, val, input_size - 1); /* the first instance gets framgments */ mhash(td1, buf1, input_size - 1); /* of size (input_size-1) */ if (offs == 0) /* the second instance gets fragments */ { /* of size input_size */ offs = input_size - 1; memset(buf2, val, offs); } else { left = input_size - offs; memset(buf2 + offs, val, left); mhash(td2, buf2, input_size); offs = (input_size - 1) - left; memset(buf2, val, offs); } } mhash(td2, buf2, offs); mhash_deinit(td1, digest1); /* return 1 if the calculated hash values match */ mhash_deinit(td2, digest2); return ! strncmp(digest1, digest2, digest_size); }
ERRORCODE_T Checksum_Calculate( const char *pPathname,CHECKSUMTYPE_E Type,const char **ppChecksum) { ERRORCODE_T ErrorCode; ERRORCODE_T TempErrorCode; unsigned int MHASHType; struct stat FileStats; MHASH HashData; FILE *pFile; unsigned int Count; unsigned int ReadSize; char pReadBuffer[CHECKSUM_READBUFFER_SIZE]; unsigned char *pHash; DEBUGLOG_Printf4("Checksum_Calculate(%p(%s),%u,%p)", pPathname,pPathname,Type,ppChecksum); DEBUGLOG_Login(); /* Parameter checking. */ if ( (pPathname==NULL) || (ppChecksum==NULL) ) ErrorCode=ERRORCODE_NULLPARAMETER; else if (CHECKSUMTYPE_ISVALID(Type)==0) ErrorCode=ERRORCODE_INVALIDPARAMETER; else { #if !defined(USE_MHASH) ErrorCode=ERRORCODE_UNSUPPORTED; #else /* !defined(USE_MHASH) */ /* Convert from CHECKSUM_ value to MHASH value. */ ErrorCode=ERRORCODE_SUCCESS; switch(Type) { case CHECKSUMTYPE_CRC32: MHASHType=MHASH_CRC32; break; case CHECKSUMTYPE_MD5: MHASHType=MHASH_MD5; break; default: ErrorCode=ERRORCODE_INVALIDPARAMETER; break; } if (ErrorCode>0) { /* Get the file size. */ if (stat(pPathname,&FileStats)==-1) ErrorCode=ERRORCODE_SYSTEMFAILURE; else { /* Initialize the hash. */ HashData=mhash_init(MHASHType); if (HashData==MHASH_FAILED) ErrorCode=ERRORCODE_LIBRARYFAILURE; else { /* Open the file. */ pFile=fopen(pPathname,"rb"); if (pFile==NULL) ErrorCode=ERRORCODE_SYSTEMFAILURE; else { /* Read the file in chunks, computing the hash on each chunk. */ ErrorCode=ERRORCODE_SUCCESS; Count=FileStats.st_size; while( (feof(pFile)==0) && (ferror(pFile)==0) && (Count!=0) ) { if (Count>=CHECKSUM_READBUFFER_SIZE) ReadSize=CHECKSUM_READBUFFER_SIZE; else ReadSize=Count; Count-=ReadSize; if (fread(pReadBuffer,ReadSize,1,pFile)!=1) { ErrorCode=ERRORCODE_SYSTEMFAILURE; break; } if (mhash(HashData,pReadBuffer,ReadSize)!=MUTILS_FALSE) { ErrorCode=ERRORCODE_LIBRARYFAILURE; break; } } TempErrorCode=ERRORCODE_SUCCESS; if (fclose(pFile)!=0) TempErrorCode=ERRORCODE_SYSTEMFAILURE; if ( (TempErrorCode<0) && (ErrorCode>0) ) ErrorCode=TempErrorCode; } /* Get the hash value. */ pHash=mhash_end(HashData); if ( (pHash==NULL) && (ErrorCode>0) ) ErrorCode=ERRORCODE_LIBRARYFAILURE; if (ErrorCode>0) { /* Convert the hash value to a string to be returned. */ *ppChecksum=malloc(2*mhash_get_block_size(MHASHType)+1); if (*ppChecksum==NULL) ErrorCode=ERRORCODE_SYSTEMFAILURE; else for(Count=0; Count<mhash_get_block_size(MHASHType); Count++) sprintf((char*)&((*ppChecksum)[2*Count]),"%.2x",pHash[Count]); } } } } #endif /* !defined(USE_MHASH) */ } DEBUGLOG_Logout(); return(ErrorCode); }
int main(int argc, char * argv[]) { FILE *fp; FILE *fp2; struct hostent *hp; struct sockaddr_in sin; char *host; char hashrcv[MAX_LINE]; char command[10]; char file_c[10000000]; char buf[MAX_LINE]; int length_s[1]; int length; int s; int port; int len; int r_val; double rtt; double throughput; double fsize; struct tm * timeinfo; struct timeval tb, ta; clock_t start_t, end_t, total_t; int fd; unsigned char buffer; unsigned char *computedHash; unsigned char *hash; unsigned char send_hash[4096]; int leng = 0; int i; MHASH td; // Check if the arguments are appropriate if (argc==3) { host = argv[1]; port = atoi(argv[2]); } else { fprintf(stderr, "usage: simplex-talk host\n"); exit(1); } // convert to IP hp = gethostbyname(host); if (!hp) { fprintf(stderr, "simplex-talk: unknown host: %s\n", host); exit(1); } // Fill in Socket bzero((char *)&sin, sizeof(sin)); sin.sin_family = AF_INET; bcopy(hp->h_addr, (char*)&sin.sin_addr, hp->h_length); sin.sin_port = htons(port); // Exit if socket can't be created if ((s=socket(PF_INET, SOCK_STREAM, 0)) < 0) { perror("simplex-talk: socket"); exit(1); } // Exit if Connection refused if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0) { perror("simplex-talk: connect"); close(s); exit(1); } while (1) { bzero((char*)&buf, sizeof(buf)); bzero((char*)&command, sizeof(command)); printf("Please enter command--REQ, UPL, LIS, DEL, XIT: "); fgets(command, 50, stdin); command[strlen(command) - 1] = '\0'; if (strcmp(command, "REQ") == 0) { if (send(s,command,strlen(command) + 1,0)==-1) { perror("client send error!"); exit (1); } printf("Enter name of file to download from server: "); fgets(buf, 50, stdin); // send name of file to server if (send(s, buf, strlen(buf) + 1, 0) == -1) { perror("client send error!"); exit(1); } buf[strlen(buf) - 1] = '\0'; // Receive the size recv(s,length_s,sizeof(length_s), 0); // if -1, file doesn't exist and exit if (length_s[0] == -1) { perror("File does not exist\n"); continue; } // File exists=>Receive file hash from server else { recv(s, hashrcv, 33, 0); fp = fopen(buf, "w"); // open requested file to write if (fp == NULL) { exit(1); } // prepare to receive blocks from the file // set remain_data = size of the file int remain_data = length_s[0]; int datarcv = 5000; // if file size is less than default receiving block size // set equal to size if (remain_data < datarcv) { datarcv = remain_data; } // get time of day before file is received gettimeofday(&tb, NULL); // receive file from server bzero((char*)&file_c, sizeof(file_c)); while (recv(s, file_c, datarcv, 0) > 0 && (remain_data > 0)) { fwrite(file_c, sizeof(char), datarcv, fp); bzero((char*)&file_c, sizeof(file_c)); remain_data -= datarcv; if (remain_data < datarcv) { datarcv = remain_data; } if (remain_data <= 0) break; } gettimeofday(&ta, NULL); // time of day after int fileSize; rewind(fp); fclose(fp); // open file received fp2 = fopen(buf, "r"); // Compute hash bzero((char*)&buffer, sizeof(buffer)); bzero((char*)&computedHash, sizeof(computedHash)); bzero((char*)&send_hash, sizeof(send_hash)); td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) exit(1); while (fread(&buffer, 1, 1, fp2) == 1) { mhash(td, &buffer, 1); } computedHash = mhash_end(td); leng = 0; // Fill in computed hash into send_hash for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) { leng += sprintf(send_hash+leng,"%.2x", computedHash[i]); } // If the hashes do not match exit if ( strcmp(send_hash, hashrcv) != 0) { perror("The hash Received does not match the computed hash!\n"); exit(1); } // Compute Round trip time rtt = ((ta.tv_sec - tb.tv_sec)*1000000L +ta.tv_usec) -tb.tv_usec; rtt /= 1000000; } fsize = (double) length_s[0]/1000000; // Size in Mb throughput = fsize/rtt; // Throughput printf("%d bytes transferred in %lf seconds.\nThroughput: %lf Megabytes/sec.\nFile MD5sum: %s\n", length_s[0], rtt, throughput, hashrcv); } else if (strcmp(command, "DEL") == 0) { int fexists; if (send(s,command,strlen(command) + 1,0)==-1) { perror("client send error!"); exit (1); } printf("Enter name of file to delete: "); fgets(buf, 40, stdin); // send name of file to server if (send(s, buf, strlen(buf) + 1, 0) == -1) { perror("client send error!"); exit(1); } buf[strlen(buf) - 1] = '\0'; //printf("buf to delete is %s\n", buf); recv(s, &fexists, 4, 0); if (fexists) { while (1) { printf("'Yes' to delete, 'No' to ignore. "); bzero((char*)&buf, sizeof(buf)); fgets(buf, sizeof(buf), stdin); buf[strlen(buf) - 1] = '\0'; if (!strcmp(buf, "Yes")) { send(s, buf, strlen(buf) + 1, 0); break; } else if (!strcmp(buf, "No")) { send(s, buf, strlen(buf) + 1, 0); break; } else { continue; } } } else { printf("The file does not exist on the server\n"); continue; } } else if (!strcmp(command, "UPL")) { // ********* UPlOAD **************** int ack; if (send(s,command,strlen(command) + 1,0)==-1) { perror("client send error!"); exit (1); } while (1) { printf("Enter name of file to upload to server: "); fgets(buf, 40, stdin); buf[strlen(buf) - 1] = '\0'; fp = fopen(buf, "r"); if (fp != NULL) { break; } } // send name of file to server if (send(s, buf, strlen(buf) + 1, 0) == -1) { perror("client send error!"); exit(1); } // receive acknowledgement recv(s, &ack, 4, 0); // break if acknowledge is 0 if (!ack) { printf("Server acknowledges 0 because it already has the file\n"); continue; } // COMPUTE AND SEND FILE SIZE int ex[1]; //fseek(fp, 0L, SEEK_END); //ex[0] = ftell(fp); struct stat st; stat(buf, &st); int sz = st.st_size; ex[0] = sz; char *file_c = malloc( ex[0] + 4096 ); send(s,ex,sizeof(ex),0); // CALCULATE AND SEND MD5 HASH fp2 = fopen(buf, "r"); if (fp2 == NULL ) { printf("fp2 is NULL: \n", buf); } td = mhash_init(MHASH_MD5); if (td == MHASH_FAILED) exit(1); while (fread(&buffer, 1, 1, fp2) == 1) { mhash(td, &buffer, 1); } hash = mhash_end(td); bzero((char*)&send_hash, sizeof(send_hash)); length = 0; for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) { length += sprintf(send_hash+length,"%.2x", hash[i]); } //printf("SENDING HASH: %s\n", send_hash); send(s, send_hash, strlen(send_hash)+1, 0); // READ CONTENTS OF FILE // rewind(fp); fread(file_c, 1, ex[0], fp); //printf("size is %d\n", ex[0]); // SEND FILE TO SERVER / int offset = 0; int sent_bytes = 5000; int remain_data = ex[0]; if (remain_data < sent_bytes) { // send as one packet sent_bytes = remain_data; } while (((send(s, file_c + offset,sent_bytes,0)) > 0) && (remain_data > 0)) { remain_data -= sent_bytes; offset += sent_bytes; // keeping track of sent and remaining data if (remain_data < sent_bytes) { sent_bytes = remain_data; } } char results[200]; recv(s, results, 200, 0); printf("%s\n", results); } else if (strcmp(command, "LIS") == 0) { char files[30]; if (send(s,command,strlen(command) + 1,0)==-1) { perror("client send error!"); exit (1); } while (recv(s, files, sizeof(files), 0) > 0) { if (strcmp(files, "end") != 0) { printf("%s\n",files); // bzero((char*)files, sizeof(files)); } else break; } } else if (strcmp(command, "XIT") == 0) { break; } else { printf("Not a valid command!\n"); continue; } } // end while printf("Session closed\n"); close (s); }
char* db_get_sql(db_line* line,db_config* dbconf){ int i; char* s=(char*) malloc(sizeof(char)*10240); /* FIXME .. */ if (s==NULL) { error(0,"\nCannot allocate memory..\n"); abort(); } s[0]=0; /* Insertion was hardcoded into aide-table, now we will use the provided name from the configfile */ s = strcat(s,"INSERT INTO "); s = strcat(s, ((psql_data*)dbconf->db_out)->table); s = strcat(s," values("); for(i=0;i<dbconf->db_out_size;i++){ switch (dbconf->db_out_order[i]) { case db_filename : { char* tmp; if ( i!=0 ) { s = strcat(s,","); } strcat(s,"'"); tmp=encode_string(line->filename); s = strcat(s,tmp); free(tmp); strcat(s,"'"); break; } case db_linkname : { if ( i!=0 ) { s = strcat(s,","); } strcat(s,"'"); if (line->linkname != NULL) { char* tmp; tmp=encode_string(line->linkname); s = strcat(s,tmp); free(tmp); } strcat(s,"'"); break; } case db_attr : { sql_writeint(line->attr,s,i); break; } case db_bcount : { sql_writeint(line->bcount,s,i); break; } case db_mtime : { sql_write_time_base64(line->mtime,s,i); break; } case db_atime : { sql_write_time_base64(line->atime,s,i); break; } case db_ctime : { sql_write_time_base64(line->ctime,s,i); break; } case db_inode : { sql_writeint(line->inode,s,i); break; } case db_lnkcount : { sql_writeint(line->nlink,s,i); break; } case db_uid : { sql_writeint(line->uid,s,i); break; } case db_gid : { sql_writeint(line->gid,s,i); break; } case db_size : { sql_writeint(line->size,s,i); break; } case db_md5 : { sql_write_byte_base64(line->md5, gcry_md_get_algo_dlen(GCRY_MD_MD5),s,i); break; } case db_sha1 : { sql_write_byte_base64(line->sha1, gcry_md_get_algo_dlen(GCRY_MD_SHA1),s,i); break; } case db_rmd160 : { sql_write_byte_base64(line->rmd160, gcry_md_get_algo_dlen(GCRY_MD_RMD160), s,i); break; } case db_tiger : { sql_write_byte_base64(line->tiger, gcry_md_get_algo_dlen(GCRY_MD_TIGER), s,i); break; } case db_perm : { sql_writeint(line->perm,s,i); break; } #ifdef WITH_MHASH case db_crc32 : { sql_write_byte_base64(line->crc32, mhash_get_block_size(MHASH_CRC32), s,i); break; } case db_crc32b : { sql_write_byte_base64(line->crc32b, mhash_get_block_size(MHASH_CRC32B), s,i); break; } case db_haval : { sql_write_byte_base64(line->haval, mhash_get_block_size(MHASH_HAVAL256), s,i); break; } case db_gost : { sql_write_byte_base64(line->gost , mhash_get_block_size(MHASH_GOST), s,i); break; } #endif case db_acl : { error(0,"TODO db_acl write to db_sql.c"); /* TODO */ break; } case db_xattrs : { error(0,"TODO db_xattrs write to db_sql.c"); /* TODO */ break; } case db_checkmask : { sql_writeoct(line->attr,s,i); break; } default : { error(0,"Not implemented in sql_writeline_file %i\n", dbconf->db_out_order[i]); return NULL; } } } strcat(s,");"); return s; }