![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smbhash.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / smblib|
Return to smbhash.c CVS log | Up to [Synchronet] / sbbs / smblib |
1.1 root 1: /* smbhash.c */
2:
3: /* Synchronet message base (SMB) hash-related functions */
4:
5: /* $Id: smbhash.c,v 1.10 2004/12/29 10:13:08 rswindell Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2004 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This library is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU Lesser General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU Lesser General Public License for more details: lgpl.txt or *
18: * http://www.fsf.org/copyleft/lesser.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include <time.h> /* time() */
39: #include <string.h> /* strdup() */
40: #include "smblib.h"
41: #include "md5.h"
42: #include "crc16.h"
43: #include "crc32.h"
44: #include "genwrap.h"
45:
46: /* If return value is SMB_ERROR_NOT_FOUND, hash file is left open */
47: int SMBCALL smb_findhash(smb_t* smb, hash_t** compare, hash_t* found_hash,
48: long source_mask, BOOL mark)
49: {
50: int retval;
51: BOOL found=FALSE;
52: size_t c,count;
53: hash_t hash;
54:
55: if(found_hash!=NULL)
56: memset(found_hash,0,sizeof(hash_t));
57:
58: if((retval=smb_open_hash(smb))!=SMB_SUCCESS)
59: return(retval);
60:
61: COUNT_LIST_ITEMS(compare, count);
62:
63: if(count) {
64:
65: rewind(smb->hash_fp);
66: while(!feof(smb->hash_fp)) {
67: if(smb_fread(smb,&hash,sizeof(hash),smb->hash_fp)!=sizeof(hash))
68: break;
69:
70: if(hash.flags==0)
71: continue; /* invalid hash record (!?) */
72:
73: if((source_mask&(1<<hash.source))==0) /* not checking this source type */
74: continue;
75:
76: for(c=0;compare[c]!=NULL;c++) {
77:
78: if(compare[c]->source!=hash.source)
79: continue; /* wrong source */
80: if(compare[c]->length!=hash.length)
81: continue; /* wrong source length */
82: if(compare[c]->flags&SMB_HASH_MARKED)
83: continue; /* already marked */
84: if((compare[c]->flags&SMB_HASH_PROC_MASK)!=(hash.flags&SMB_HASH_PROC_MASK))
85: continue; /* wrong pre-process flags */
86: if((compare[c]->flags&hash.flags&SMB_HASH_MASK)==0)
87: continue; /* no matching hashes */
88: if(compare[c]->flags&hash.flags&SMB_HASH_CRC16
89: && compare[c]->crc16!=hash.crc16)
90: continue; /* wrong crc-16 */
91: if(compare[c]->flags&hash.flags&SMB_HASH_CRC32
92: && compare[c]->crc32!=hash.crc32)
93: continue; /* wrong crc-32 */
94: if(compare[c]->flags&hash.flags&SMB_HASH_MD5
95: && memcmp(compare[c]->md5,hash.md5,sizeof(hash.md5)))
96: continue; /* wrong crc-16 */
97:
98: /* successful match! */
99: break; /* can't match more than one, so stop comparing */
100: }
101:
102: if(compare[c]==NULL)
103: continue; /* no match */
104:
105: found=TRUE;
106:
107: if(found_hash!=NULL)
108: memcpy(found_hash,&hash,sizeof(hash));
109:
110: if(!mark)
111: break;
112:
113: compare[c]->flags|=SMB_HASH_MARKED;
114: }
115: if(found) {
116: smb_close_hash(smb);
117: return(SMB_SUCCESS);
118: }
119: }
120:
121: /* hash file left open */
122: return(SMB_ERR_NOT_FOUND);
123: }
124:
125: int SMBCALL smb_addhashes(smb_t* smb, hash_t** hashes, BOOL skip_marked)
126: {
127: int retval;
128: size_t h;
129:
130: COUNT_LIST_ITEMS(hashes, h);
131: if(!h) /* nothing to add */
132: return(SMB_SUCCESS);
133:
134: if((retval=smb_open_hash(smb))!=SMB_SUCCESS)
135: return(retval);
136:
137: fseek(smb->hash_fp,0,SEEK_END);
138:
139: for(h=0;hashes[h]!=NULL;h++) {
140:
141: /* skip hashes marked by smb_findhash() */
142: if(skip_marked && hashes[h]->flags&SMB_HASH_MARKED)
143: continue;
144:
145: /* can't think of any reason to strip SMB_HASH_MARKED flag right now */
146: if(smb_fwrite(smb,hashes[h],sizeof(hash_t),smb->hash_fp)!=sizeof(hash_t)) {
147: retval=SMB_ERR_WRITE;
148: break;
149: }
150: }
151:
152: smb_close_hash(smb);
153:
154: return(retval);
155: }
156:
157: static char* strip_chars(uchar* dst, const uchar* src, uchar* set)
158: {
159: while(*src) {
160: if(strchr(set,*src)==NULL)
161: *(dst++)=*src;
162: src++;
163: }
164: *dst=0;
165:
166: return(dst);
167: }
168:
169: /* Allocates and calculates hashes of data (based on flags) */
170: /* Returns NULL on failure */
171: hash_t* SMBCALL smb_hash(ulong msgnum, ulong t, unsigned source, unsigned flags
172: ,const void* data, size_t length)
173: {
174: hash_t* hash;
175:
176: if((hash=(hash_t*)malloc(sizeof(hash_t)))==NULL)
177: return(NULL);
178:
179: memset(hash,0,sizeof(hash_t));
180: hash->number=msgnum;
181: hash->time=t;
182: hash->length=length;
183: hash->source=source;
184: hash->flags=flags;
185: if(flags&SMB_HASH_CRC16)
186: hash->crc16=crc16((char*)data,length);
187: if(flags&SMB_HASH_CRC32)
188: hash->crc32=crc32((char*)data,length);
189: if(flags&SMB_HASH_MD5)
190: MD5_calc(hash->md5,data,length);
191:
192: return(hash);
193: }
194:
195: /* Allocates and calculates hashes of data (based on flags) */
196: /* Supports string hash "pre-processing" (e.g. lowercase, strip whitespace) */
197: /* Returns NULL on failure */
198: hash_t* SMBCALL smb_hashstr(ulong msgnum, ulong t, unsigned source, unsigned flags
199: ,const char* str)
200: {
201: char* p=(uchar*)str;
202: hash_t* hash;
203:
204: if(flags&SMB_HASH_PROC_MASK) { /* string pre-processing */
205: if((p=strdup(str))==NULL)
206: return(NULL);
207: if(flags&SMB_HASH_STRIP_WSP)
208: strip_chars(p,str," \t\r\n");
209: if(flags&SMB_HASH_LOWERCASE)
210: strlwr(p);
211: }
212:
213: hash=smb_hash(msgnum, t, source, flags, p, strlen(p));
214:
215: if(p!=str) /* duped string */
216: free(p);
217:
218: return(hash);
219: }
220:
221: /* Allocatese and calculates all hashes for a single message */
222: /* Returns NULL on failure */
223: hash_t** SMBCALL smb_msghashes(smbmsg_t* msg, const uchar* body)
224: {
225: size_t h=0;
226: uchar flags=SMB_HASH_CRC16|SMB_HASH_CRC32|SMB_HASH_MD5;
227: hash_t** hashes; /* This is a NULL-terminated list of hashes */
228: hash_t* hash;
229: time_t t=time(NULL);
230:
231: #define SMB_MAX_HASH_COUNT 4
232:
233: if((hashes=(hash_t**)malloc(sizeof(hash_t*)*SMB_MAX_HASH_COUNT))==NULL)
234: return(NULL);
235:
236: memset(hashes, 0, sizeof(hash_t*)*SMB_MAX_HASH_COUNT);
237:
238: if(msg->id!=NULL &&
239: (hash=smb_hashstr(msg->hdr.number, t, SMB_HASH_SOURCE_MSG_ID, flags, msg->id))!=NULL)
240: hashes[h++]=hash;
241:
242: if(msg->ftn_msgid!=NULL &&
243: (hash=smb_hashstr(msg->hdr.number, t, SMB_HASH_SOURCE_FTN_ID, flags, msg->ftn_msgid))!=NULL)
244: hashes[h++]=hash;
245:
246: flags|=SMB_HASH_STRIP_WSP;
247: if(body!=NULL &&
248: (hash=smb_hashstr(msg->hdr.number, t, SMB_HASH_SOURCE_BODY, flags, body))!=NULL)
249: hashes[h++]=hash;
250:
251: return(hashes);
252: }
253:
254: /* Calculates and stores the hashes for a single message */
255: int SMBCALL smb_hashmsg(smb_t* smb, smbmsg_t* msg, const uchar* text, BOOL update)
256: {
257: size_t n;
258: int retval=SMB_SUCCESS;
259: hash_t found;
260: hash_t** hashes; /* This is a NULL-terminated list of hashes */
261:
262: hashes=smb_msghashes(msg,text);
263:
264: if(smb_findhash(smb, hashes, &found, SMB_HASH_SOURCE_ALL, update)==SMB_SUCCESS && !update) {
265: retval=SMB_DUPE_MSG;
266: safe_snprintf(smb->last_error,sizeof(smb->last_error)
267: ,"duplicate %s: %s found in message #%lu"
268: ,smb_hashsourcetype(found.source)
269: ,smb_hashsource(msg,found.source)
270: ,found.number);
271: } else
272: if((retval=smb_addhashes(smb,hashes,/* skip_marked? */TRUE))==SMB_SUCCESS)
273: msg->flags|=MSG_FLAG_HASHED;
274:
275: FREE_LIST(hashes,n);
276:
277: return(retval);
278: }
279:
280: /* length=0 specifies ASCIIZ data */
281: int SMBCALL smb_getmsgidx_by_hash(smb_t* smb, smbmsg_t* msg, unsigned source
282: ,unsigned flags, const void* data, size_t length)
283: {
284: int retval;
285: size_t n;
286: hash_t** hashes;
287: hash_t found;
288:
289: if((hashes=(hash_t**)malloc(sizeof(hash_t*)*2))==NULL)
290: return(SMB_ERR_MEM);
291:
292: if(length==0)
293: hashes[0]=smb_hashstr(0,0,source,flags,data);
294: else
295: hashes[0]=smb_hash(0,0,source,flags,data,length);
296: if(hashes[0]==NULL)
297: return(SMB_ERR_MEM);
298:
299: hashes[1]=NULL; /* terminate list */
300:
301: if((retval=smb_findhash(smb, hashes, &found, 1<<source, FALSE))==SMB_SUCCESS) {
302: if(found.number==0)
303: retval=SMB_FAILURE; /* use better error value here? */
304: else {
305: msg->hdr.number=found.number;
306: retval=smb_getmsgidx(smb, msg);
307: }
308: }
309:
310: FREE_LIST(hashes,n);
311:
312: return(retval);
313: }
314:
315: int SMBCALL smb_getmsghdr_by_hash(smb_t* smb, smbmsg_t* msg, unsigned source
316: ,unsigned flags, const void* data, size_t length)
317: {
318: int retval;
319:
320: if((retval=smb_getmsgidx_by_hash(smb,msg,source,flags,data,length))!=SMB_SUCCESS)
321: return(retval);
322:
323: if((retval=smb_lockmsghdr(smb,msg))!=SMB_SUCCESS)
324: return(retval);
325:
326: retval=smb_getmsghdr(smb,msg);
327:
328: smb_unlockmsghdr(smb,msg);
329:
330: return(retval);
331: }
332:
333: ushort SMBCALL smb_subject_crc(const char* subj)
334: {
335: char* str;
336: ushort crc;
337:
338: if(subj==NULL)
339: return(0xffff);
340:
341: while(!strnicmp(subj,"RE:",3)) {
342: subj+=3;
343: while(*subj==' ')
344: subj++;
345: }
346:
347: if((str=strdup(subj))==NULL)
348: return(0xffff);
349:
350: strlwr(str);
351: crc=crc16(str,0 /* auto-length */);
352: free(str);
353:
354: return(crc);
355: }
356:
357: ushort SMBCALL smb_name_crc(const char* name)
358: {
359: char* str;
360: ushort crc;
361:
362: if(name==NULL)
363: return(0xffff);
364:
365: if((str=strdup(name))==NULL)
366: return(0xffff);
367:
368: strlwr(str);
369: crc=crc16(str,0 /* auto-length */);
370: free(str);
371:
372: return(crc);
373: }
374:
375: int SMBCALL smb_init_idx(smb_t* smb, smbmsg_t* msg)
376: {
377: msg->idx.subj=smb_subject_crc(msg->subj);
378: if(smb->status.attr&SMB_EMAIL) {
379: if(msg->to_ext)
380: msg->idx.to=atoi(msg->to_ext);
381: else
382: msg->idx.to=0;
383: if(msg->from_ext)
384: msg->idx.from=atoi(msg->from_ext);
385: else
386: msg->idx.from=0;
387: } else {
388: msg->idx.to=smb_name_crc(msg->to);
389: msg->idx.from=smb_name_crc(msg->from);
390: }
391:
392: return(SMB_SUCCESS);
393: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.