![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dupefind.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / dupefind|
Return to dupefind.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / dupefind |
1.1 root 1: /* DUPEFIND.C */
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6: #include "crc32.h"
7:
8: #define DUPEFIND_VER "1.01"
9:
10: void bail(int code)
11: {
12: exit(code);
13: }
14: /****************************************************************************/
15: /* Returns 32-crc of string (not counting terminating NULL) */
16: /****************************************************************************/
17: ulong crc32(char *str)
18: {
19: int i=0;
20: ulong crc=0xffffffffUL;
21:
22: while(str[i])
23: crc=ucrc32(str[i++],crc);
24: crc=~crc;
25: return(crc);
26: }
27: long lputs(char FAR16 *str)
28: {
29: char tmp[256];
30: int i,j,k;
31:
32: j=strlen(str);
33: for(i=k=0;i<j;i++) /* remove CRs */
34: if(str[i]==CR && str[i+1]==LF)
35: continue;
36: else
37: tmp[k++]=str[i];
38: tmp[k]=0;
39: return(fputs(tmp,stderr));
40: }
41:
42: /****************************************************************************/
43: /* Network open function. Opens all files DENYALL and retries LOOP_NOPEN */
44: /* number of times if the attempted file is already open or denying access */
45: /* for some other reason. All files are opened in BINARY mode. */
46: /****************************************************************************/
47: int nopen(char *str, int access)
48: {
49: char logstr[256];
50: int file,share,count=0;
51:
52: if(access==O_RDONLY) share=SH_DENYWR;
53: else share=SH_DENYRW;
54: while(((file=sopen(str,O_BINARY|access,share,S_IWRITE))==-1)
55: && errno==EACCES && count++<LOOP_NOPEN);
56: if(file==-1 && errno==EACCES)
57: lputs("\7\r\nNOPEN: ACCESS DENIED\r\n\7");
58: return(file);
59: }
60:
61: /****************************************************************************/
62: /* Performs printf() through local assembly routines */
63: /* Called from everywhere */
64: /****************************************************************************/
65: int lprintf(char *fmat, ...)
66: {
67: va_list argptr;
68: char sbuf[256];
69: int chcount;
70:
71: va_start(argptr,fmat);
72: chcount=vsprintf(sbuf,fmat,argptr);
73: va_end(argptr);
74: lputs(sbuf);
75: return(chcount);
76: }
77:
78: /****************************************************************************/
79: /* This function performs an nopen, but returns a file stream with a buffer */
80: /* allocated. */
81: /****************************************************************************/
82: FILE *fnopen(int *file, char *str, int access)
83: {
84: char mode[128];
85: FILE *stream;
86:
87: if(access&O_WRONLY) access|=O_RDWR; /* fdopen can't open WRONLY */
88:
89: if(((*file)=nopen(str,access))==-1)
90: return(NULL);
91:
92: if(access&O_APPEND) {
93: if(access&(O_RDONLY|O_RDWR))
94: strcpy(mode,"a+");
95: else
96: strcpy(mode,"a"); }
97: else {
98: if(access&(O_WRONLY|O_RDWR))
99: strcpy(mode,"r+");
100: else
101: strcpy(mode,"r"); }
102: stream=fdopen((*file),mode);
103: if(stream==NULL) {
104: close(*file);
105: return(NULL); }
106: setvbuf(stream,NULL,_IOFBF,16*1024);
107: return(stream);
108: }
109:
110: /****************************************************************************/
111: /* Puts a backslash on path strings */
112: /****************************************************************************/
113: void backslash(char *str)
114: {
115: int i;
116:
117: i=strlen(str);
118: if(i && str[i-1]!='\\') {
119: str[i]='\\'; str[i+1]=0; }
120: }
121: /****************************************************************************/
122: /* Truncates white-space chars off end of 'str' and terminates at first tab */
123: /****************************************************************************/
124: void truncsp(char *str)
125: {
126: int c;
127:
128: str[strcspn(str,"\t")]=0;
129: c=strlen(str);
130: while(c && (uchar)str[c-1]<=SP) c--;
131: str[c]=0;
132: }
133: char *display_filename(ushort dir_num,ushort fil_off)
134: {
135: static char str[256];
136: char fname[13];
137: int file;
138:
139: sprintf(str,"%s%s.IXB",dir[dir_num]->data_dir,dir[dir_num]->code);
140: if((file=nopen(str,O_RDONLY))==-1)
141: return("UNKNOWN");
142: lseek(file,(long)(22*(fil_off-1)),SEEK_SET);
143: read(file,fname,11);
144: close(file);
145:
146: sprintf(str,"%-8.8s.%c%c%c",fname,fname[8],fname[9],fname[10]);
147: return(str);
148: }
149:
150: void main(int argc,char **argv)
151: {
152: char str[256],*ixbbuf,*p;
153: ulong **fcrc,*foundcrc,total_found=0L;
154: ushort i,j,k,h,g,start_lib=0,end_lib=0,found=-1;
155: int file;
156: long l,m;
157: read_cfg_text_t txt;
158:
159: putenv("TZ=UCT0");
160: _fmode=O_BINARY;
161: setvbuf(stdout,NULL,_IONBF,0);
162:
163: fprintf(stderr,"\nDUPEFIND Version %s (%s) - Synchronet Duplicate File "
164: "Finder\n"
165: ,DUPEFIND_VER
166: #if defined(__OS2__)
167: ,"OS/2"
168: #elif defined(__NT__)
169: ,"Win32"
170: #elif defined(__DOS4G__)
171: ,"DOS4G"
172: #elif defined(__FLAT__)
173: ,"DOS32"
174: #else
175: ,"DOS16"
176: #endif
177: );
178:
179: p=getenv("SBBSNODE");
180: if(p==NULL) {
181: fprintf(stderr,"\nSBBSNODE environment variable must be set.\n");
182: fprintf(stderr,"\nExample: SET SBBSNODE=C:\\SBBS\\NODE1\n");
183: exit(1); }
184:
185: if(!stricmp(argv[1],"/?") || !stricmp(argv[1],"?")) {
186: fprintf(stderr,"\n");
187: fprintf(stderr,"usage: DUPEFIND [start] [end]\n");
188: fprintf(stderr,"where: [start] is the starting library number to check\n");
189: fprintf(stderr," [end] is the final library number to check\n");
190: return; }
191:
192:
193: strcpy(node_dir,p);
194: if(node_dir[strlen(node_dir)-1]!='\\')
195: strcat(node_dir,"\\");
196:
197: txt.openerr="\7\nError opening %s for read.\n";
198: txt.reading="\nReading %s...";
199: txt.readit="\rRead %s ";
200: txt.allocerr="\7\nError allocating %u bytes of memory\n";
201: txt.error="\7\nERROR: Offset %lu in %s\r\n\n";
202:
203: read_node_cfg(txt);
204: if(ctrl_dir[0]=='.') {
205: strcpy(str,ctrl_dir);
206: sprintf(ctrl_dir,"%s%s",node_dir,str);
207: if(_fullpath(str,ctrl_dir,40))
208: strcpy(ctrl_dir,str); }
209: backslash(ctrl_dir);
210: read_main_cfg(txt);
211: if(data_dir[0]=='.') {
212: strcpy(str,data_dir);
213: sprintf(data_dir,"%s%s",node_dir,str);
214: if(_fullpath(str,data_dir,40))
215: strcpy(data_dir,str); }
216: backslash(data_dir);
217: read_file_cfg(txt);
218: lputs("\n");
219:
220: start_lib=0;
221: end_lib=total_libs-1;
222: if(argc>1)
223: start_lib=end_lib=atoi(argv[1])-1;
224: if(argc>2)
225: end_lib=atoi(argv[2])-1;
226:
227: if((fcrc=(ulong **)MALLOC(total_dirs*sizeof(ulong *)))==NULL) {
228: printf("Not enough memory for CRCs.\r\n");
229: exit(1); }
230:
231: for(i=0;i<total_dirs;i++) {
232: fprintf(stderr,"Reading directory index %u of %u\r",i+1,total_dirs);
233: sprintf(str,"%s%s.IXB",dir[i]->data_dir,dir[i]->code);
234: if((file=nopen(str,O_RDONLY))==-1) {
235: fcrc[i]=(ulong *)MALLOC(1*sizeof(ulong));
236: fcrc[i][0]=0;
237: continue; }
238: l=filelength(file);
239: if(!l || (dir[i]->lib<start_lib || dir[i]->lib>end_lib)) {
240: close(file);
241: fcrc[i]=(ulong *)MALLOC(1*sizeof(ulong));
242: fcrc[i][0]=0;
243: continue; }
244: if((fcrc[i]=(ulong *)MALLOC((l/22+2)*sizeof(ulong)))==NULL) {
245: printf("Not enough memory for CRCs.\r\n");
246: exit(1); }
247: fcrc[i][0]=(ulong)(l/22);
248: if((ixbbuf=(char *)MALLOC(l))==NULL) {
249: close(file);
250: printf("\7Error allocating memory for index %s.\r\n",str);
251: continue; }
252: if(read(file,ixbbuf,l)!=l) {
253: close(file);
254: printf("\7Error reading %s.\r\n",str);
255: FREE(ixbbuf);
256: continue; }
257: close(file);
258: j=1;
259: m=0L;
260: while(m<l) {
261: sprintf(str,"%-11.11s",(ixbbuf+m));
262: strupr(str);
263: fcrc[i][j++]=crc32(str);
264: m+=22; }
265: FREE(ixbbuf); }
266: lputs("\n");
267:
268: foundcrc=0L;
269: for(i=0;i<total_dirs;i++) {
270: if(dir[i]->lib<start_lib || dir[i]->lib>end_lib)
271: continue;
272: lprintf("Scanning %s %s\n",lib[dir[i]->lib]->sname,dir[i]->sname);
273: for(k=1;k<fcrc[i][0];k++) {
274: for(j=i+1;j<total_dirs;j++) {
275: if(dir[j]->lib<start_lib || dir[j]->lib>end_lib)
276: continue;
277: for(h=1;h<fcrc[j][0];h++) {
278: if(fcrc[i][k]==fcrc[j][h]) {
279: if(found!=k) {
280: found=k;
281: for(g=0;g<total_found;g++) {
282: if(foundcrc[g]==fcrc[i][k])
283: g=total_found+1; }
284: if(g==total_found) {
285: ++total_found;
286: if((foundcrc=(ulong *)REALLOC(foundcrc
287: ,total_found*sizeof(ulong)))==NULL) {
288: printf("Out of memory reallocating\r\n");
289: exit(1); } }
290: else
291: found=0;
292: printf("\n%-12s is located in : %-*s %s\n"
293: "%-12s and : %-*s %s\n"
294: ,display_filename(i,k)
295: ,LEN_GSNAME
296: ,lib[dir[i]->lib]->sname
297: ,dir[i]->sname
298: ,""
299: ,LEN_GSNAME
300: ,lib[dir[j]->lib]->sname
301: ,dir[j]->sname
302: ); }
303: else
304: printf("%-12s and : %-*s %s\n"
305: ,""
306: ,LEN_GSNAME
307: ,lib[dir[j]->lib]->sname
308: ,dir[j]->sname
309: ); } } } } }
310: }
311:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.