![[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 / src / smblib|
Return to smbhash.c CVS log | Up to [Synchronet] / sbbs / src / smblib |
1.1 root 1: /* smbhash.c */
2:
3: /* Synchronet message base (SMB) hash-related functions */
4:
5: /* $Id: smbhash.c,v 1.15 2005/10/02 23:28:57 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 2005 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((char *)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=(char *)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: if((hashes=(hash_t**)malloc(sizeof(hash_t*)*(SMB_HASH_SOURCE_TYPES+1)))==NULL)
232: return(NULL);
233:
234: memset(hashes, 0, sizeof(hash_t*)*(SMB_HASH_SOURCE_TYPES+1));
235:
236: if(msg->id!=NULL &&
237: (hash=smb_hashstr(msg->hdr.number, t, SMB_HASH_SOURCE_MSG_ID, flags, msg->id))!=NULL)
238: hashes[h++]=hash;
239:
240: if(msg->ftn_msgid!=NULL &&
241: (hash=smb_hashstr(msg->hdr.number, t, SMB_HASH_SOURCE_FTN_ID, flags, msg->ftn_msgid))!=NULL)
242: hashes[h++]=hash;
243:
244: flags|=SMB_HASH_STRIP_WSP;
245: if(body!=NULL &&
246: (hash=smb_hashstr(msg->hdr.number, t, SMB_HASH_SOURCE_BODY, flags, body))!=NULL)
247: hashes[h++]=hash;
248:
249: return(hashes);
250: }
251:
252: /* Calculates and stores the hashes for a single message */
253: int SMBCALL smb_hashmsg(smb_t* smb, smbmsg_t* msg, const uchar* text, BOOL update)
254: {
255: size_t n;
256: int retval=SMB_SUCCESS;
257: hash_t found;
258: hash_t** hashes; /* This is a NULL-terminated list of hashes */
259:
260: if(smb->status.attr&SMB_EMAIL)
261: return(SMB_SUCCESS);
262:
263: hashes=smb_msghashes(msg,text);
264:
265: if(smb_findhash(smb, hashes, &found, SMB_HASH_SOURCE_ALL, update)==SMB_SUCCESS && !update) {
266: retval=SMB_DUPE_MSG;
267: safe_snprintf(smb->last_error,sizeof(smb->last_error)
268: ,"duplicate %s: %s found in message #%lu"
269: ,smb_hashsourcetype(found.source)
270: ,smb_hashsource(msg,found.source)
271: ,found.number);
272: } else
273: if((retval=smb_addhashes(smb,hashes,/* skip_marked? */TRUE))==SMB_SUCCESS)
274: msg->flags|=MSG_FLAG_HASHED;
275:
276: FREE_LIST(hashes,n);
277:
278: return(retval);
279: }
280:
281: /* length=0 specifies ASCIIZ data */
282: int SMBCALL smb_getmsgidx_by_hash(smb_t* smb, smbmsg_t* msg, unsigned source
283: ,unsigned flags, const void* data, size_t length)
284: {
285: int retval;
286: size_t n;
287: hash_t** hashes;
288: hash_t found;
289:
290: if((hashes=(hash_t**)malloc(sizeof(hash_t*)*2))==NULL)
291: return(SMB_ERR_MEM);
292:
293: if(length==0)
294: hashes[0]=smb_hashstr(0,0,source,flags,data);
295: else
296: hashes[0]=smb_hash(0,0,source,flags,data,length);
297: if(hashes[0]==NULL)
298: return(SMB_ERR_MEM);
299:
300: hashes[1]=NULL; /* terminate list */
301:
302: if((retval=smb_findhash(smb, hashes, &found, 1<<source, FALSE))==SMB_SUCCESS) {
303: if(found.number==0)
304: retval=SMB_FAILURE; /* use better error value here? */
305: else {
306: msg->hdr.number=found.number;
307: retval=smb_getmsgidx(smb, msg);
308: }
309: }
310:
311: FREE_LIST(hashes,n);
312:
313: return(retval);
314: }
315:
316: int SMBCALL smb_getmsghdr_by_hash(smb_t* smb, smbmsg_t* msg, unsigned source
317: ,unsigned flags, const void* data, size_t length)
318: {
319: int retval;
320:
321: if((retval=smb_getmsgidx_by_hash(smb,msg,source,flags,data,length))!=SMB_SUCCESS)
322: return(retval);
323:
324: if((retval=smb_lockmsghdr(smb,msg))!=SMB_SUCCESS)
325: return(retval);
326:
327: retval=smb_getmsghdr(smb,msg);
328:
329: smb_unlockmsghdr(smb,msg);
330:
331: return(retval);
332: }
333:
334: ushort SMBCALL smb_subject_crc(const char* subj)
335: {
336: char* str;
337: ushort crc;
338:
339: if(subj==NULL)
340: return(0xffff);
341:
342: while(!strnicmp(subj,"RE:",3)) {
343: subj+=3;
344: while(*subj==' ')
345: subj++;
346: }
347:
348: if((str=strdup(subj))==NULL)
349: return(0xffff);
350:
351: strlwr(str);
352: crc=crc16(str,0 /* auto-length */);
353: free(str);
354:
355: return(crc);
356: }
357:
358: ushort SMBCALL smb_name_crc(const char* name)
359: {
360: char* str;
361: ushort crc;
362:
363: if(name==NULL)
364: return(0xffff);
365:
366: if((str=strdup(name))==NULL)
367: return(0xffff);
368:
369: strlwr(str);
370: crc=crc16(str,0 /* auto-length */);
371: free(str);
372:
373: return(crc);
374: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.