![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smm2msg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / smm|
Return to smm2msg.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / smm |
1.1 root 1: /* SMM2MSG.C */
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: /* Scans SMM database and posts any additions/updates into an MSG file */
6:
7: #define uint unsigned int
8:
9: #include <dos.h>
10: #include "smblib.h"
11: #include "smmdefs.h"
12:
13: #define VERSION "1.00�"
14:
15: smb_t smb;
16: extern int daylight=0;
17: extern long timezone=0L;
18:
19: unsigned _stklen=16000; /* Set stack size in code, not header */
20:
21: uchar cryptchar(uchar ch, ulong seed)
22: {
23: if(ch==1)
24: return(0xfe);
25: if(ch<0x20 || ch&0x80) /* Ctrl chars and ex-ASCII are not xlated */
26: return(ch);
27: return(ch^(seed&0x1f));
28: }
29:
30: char *encrypt(uchar *str, ulong seed)
31: {
32: static uchar out[1024];
33: int i,j;
34:
35: j=strlen(str);
36: for(i=0;i<j;i++)
37: out[i]=cryptchar(str[i],seed^(i&7));
38: out[i]=0;
39: return(out);
40: }
41:
42: /****************************************************************************/
43: /* Checks the disk drive for the existence of a file. Returns 1 if it */
44: /* exists, 0 if it doesn't. */
45: /****************************************************************************/
46: char fexist(char *filespec)
47: {
48: struct ffblk f;
49:
50: if(findfirst(filespec,&f,0)==0)
51: return(1);
52: return(0);
53: }
54:
55:
56: /****************************************************************************/
57: /* Updates 16-bit "rcrc" with character 'ch' */
58: /****************************************************************************/
59: void ucrc16(uchar ch, ushort *rcrc) {
60: ushort i, cy;
61: uchar nch=ch;
62:
63: for (i=0; i<8; i++) {
64: cy=*rcrc & 0x8000;
65: *rcrc<<=1;
66: if (nch & 0x80) *rcrc |= 1;
67: nch<<=1;
68: if (cy) *rcrc ^= 0x1021; }
69: }
70:
71: /****************************************************************************/
72: /* Returns 16-crc of string (not counting terminating NULL) */
73: /****************************************************************************/
74: ushort crc16(char *str)
75: {
76: int i=0;
77: ushort crc=0;
78:
79: ucrc16(0,&crc);
80: while(str[i])
81: ucrc16(str[i++],&crc);
82: ucrc16(0,&crc);
83: ucrc16(0,&crc);
84: return(crc);
85: }
86:
87:
88: /****************************************************************************/
89: /* Converts unix time format (long - time_t) into a char str MM/DD/YY */
90: /****************************************************************************/
91: char *unixtodstr(time_t unix, char *str)
92: {
93: struct time curtime;
94: struct date date;
95:
96: if(!unix)
97: strcpy(str,"00/00/00");
98: else {
99: unixtodos(unix,&date,&curtime);
100: if((unsigned)date.da_mon>12) { /* DOS leap year bug */
101: date.da_mon=1;
102: date.da_year++; }
103: if((unsigned)date.da_day>31)
104: date.da_day=1;
105: sprintf(str,"%02u/%02u/%02u",date.da_mon,date.da_day
106: ,date.da_year>=2000 ? date.da_year-2000 : date.da_year-1900); }
107: return(str);
108: }
109:
110: time_t checktime()
111: {
112: struct tm tm;
113:
114: memset(&tm,0,sizeof(tm));
115: tm.tm_year=94;
116: tm.tm_mday=1;
117: return(mktime(&tm)^0x2D24BD00L);
118: }
119:
120: #define BUF_LEN 8192
121:
122: int main(int argc, char **argv)
123: {
124: uchar str[128],tmp[128],msg_dir[128],buf[BUF_LEN],telegram[513],*p;
125: int i,j,file;
126: ushort xlat;
127: long length;
128: ulong offset;
129: time_t last,t;
130: user_t user,from;
131: wall_t wall;
132: smbmsg_t msg;
133: FILE *stream;
134:
135: fprintf(stderr,"\nSMM2MSG v%s - Write SMM data to MSG - Developed 1995-1997 "
136: "Rob Swindell\n\n",VERSION);
137:
138: if(checktime()) {
139: printf("Time problem!\n");
140: return(-1); }
141:
142: if(argc<3) {
143: fprintf(stderr,"usage: smm2msg <smm.dab> <msg_dir>\n\n");
144: fprintf(stderr,"example: smm2msg c:\\sbbs\\xtrn\\smm\\smm.dab "
145: "c:\\im\\mail\n");
146: return(1); }
147:
148:
149: strcpy(msg_dir,argv[2]);
150: strupr(msg_dir);
151:
152: strcpy(str,argv[1]);
153: strupr(str);
154: if((file=open(str,O_RDONLY|O_BINARY|O_DENYNONE))==-1) {
155: printf("error opening %s\n",str);
156: return(1); }
157: if((stream=fdopen(file,"rb"))==NULL) {
158: printf("error fdopening %s\n",str);
159: return(1); }
160: setvbuf(stream,NULL,_IOFBF,4096);
161:
162: strcpy(tmp,str);
163: p=strrchr(tmp,'.');
164: if(p) {
165: (*p)=0;
166: strcat(tmp,"2MSG.DAB");
167: if((file=open(tmp,O_RDWR|O_BINARY|O_CREAT,S_IWRITE|S_IREAD))==-1) {
168: printf("error opening %s\n",str);
169: return(1); }
170: t=time(NULL);
171: if(read(file,&last,sizeof(time_t))!=sizeof(time_t))
172: last=0;
173: lseek(file,0L,SEEK_SET);
174: write(file,&t,sizeof(time_t));
175: close(file); }
176:
177: //sprintf(str,"%s.SHD",smb.file);
178: //if(!fexist(str)) {
179: // printf("%s doesn't exist\n",smb.file);
180: // return(0); }
181: //fprintf(stderr,"Opening %s\n",smb.file);
182: //smb.retry_time=30;
183: //if((i=smb_open(&smb))!=0) {
184: // printf("smb_open returned %d\n",i);
185: // return(1); }
186:
187: strcpy(str,argv[1]);
188: strupr(str);
189: p=strrchr(str,'\\');
190: if(p) p++;
191: else p=str;
192: strcpy(p,"TELEGRAM.DAB");
193: if((file=open(str,O_RDWR|O_DENYNONE|O_BINARY))!=-1) {
194: while(!eof(file)) {
195: read(file,from.system,sizeof(user.system));
196: read(file,user.system,sizeof(user.system));
197: read(file,&user.number,sizeof(user.number));
198: printf("Telegram to: %lu@%s\n",user.number,user.system);
199: read(file,telegram,512);
200: telegram[512]=0;
201: sprintf(buf,"}%lx\r\n%s",user.number,encrypt(telegram,user.number));
202: strcat(buf,"\r\n"); /* blank line terminates telegram */
203: strcat(buf,"\r\n--- SMM2MSG v");
204: strcat(buf,VERSION);
205:
206: length=strlen(buf); /* +2 for translation string */
207:
208: if(smb.status.attr&SMB_HYPERALLOC)
209: offset=smb_hallocdat(&smb);
210: else {
211: i=smb_open_da(&smb);
212: if(i) {
213: printf("smb_open_da returned %d\n",i);
214: exit(1); }
215: offset=smb_allocdat(&smb,length+2,1);
216: fclose(smb.sda_fp); }
217:
218: fseek(smb.sdt_fp,offset,SEEK_SET);
219: xlat=XLAT_NONE;
220: fwrite(&xlat,2,1,smb.sdt_fp);
221: fwrite(buf,length,1,smb.sdt_fp);
222: length+=2;
223:
224: memset(&msg,0,sizeof(smbmsg_t));
225: memcpy(msg.hdr.id,"SHD\x1a",4);
226: msg.hdr.version=SMB_VERSION;
227: msg.hdr.when_written.time=time(NULL);
228:
229: msg.hdr.offset=offset;
230:
231: strcpy(str,"SMM");
232: i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
233: if(i) {
234: printf("smb_hfield returned %d\n",i);
235: smb_freemsgdat(&smb,offset,length,1);
236: exit(1); }
237: strlwr(str);
238: msg.idx.to=crc16(str);
239:
240: strcpy(str,from.system);
241: i=smb_hfield(&msg,SENDER,strlen(str),str);
242: if(i) {
243: printf("smb_hfield returned %d\n",i);
244: smb_freemsgdat(&smb,offset,length,1);
245: exit(1); }
246: strlwr(str);
247: msg.idx.from=crc16(str);
248:
249: strcpy(str,user.system);
250: i=smb_hfield(&msg,SUBJECT,strlen(str),str);
251: if(i) {
252: printf("smb_hfield returned %d\n",i);
253: smb_freemsgdat(&smb,offset,length,1);
254: exit(1); }
255: strlwr(str);
256: msg.idx.subj=crc16(str);
257:
258: i=smb_dfield(&msg,TEXT_BODY,length);
259: if(i) {
260: printf("smb_dfield returned %d\n",i);
261: smb_freemsgdat(&smb,offset,length,1);
262: exit(1); }
263:
264: i=smb_addmsghdr(&smb,&msg,smb.status.attr&SMB_HYPERALLOC);
265: if(i) {
266: printf("smb_addmsghdr returned %d\n",i);
267: smb_freemsgdat(&smb,offset,length,1);
268: exit(1); }
269: smb_freemsgmem(&msg); }
270: chsize(file,0L);
271: close(file); }
272:
273: strcpy(str,argv[1]);
274: strupr(str);
275: p=strrchr(str,'\\');
276: if(p) p++;
277: else p=str;
278: strcpy(p,"WALL.DAB");
279: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYNO))!=-1) {
280: while(!eof(file)) {
281: if(!read(file,&wall,sizeof(wall_t)))
282: break;
283: if(last && wall.imported<last)
284: continue;
285:
286: if(wall.imported!=wall.written) /* Imported from SMB */
287: continue;
288:
289: printf("Wall writing from: %s\n",wall.name);
290: sprintf(buf,"%s\r\n",encrypt(wall.name,wall.written));
291: sprintf(str,"%s\r\n",encrypt(wall.system,wall.written));
292: strcat(buf,str);
293: for(i=0;i<5;i++) {
294: sprintf(str,"%s\r\n",encrypt(wall.text[i],wall.written));
295: strcat(buf,str); }
296: sprintf(str,"%lx\r\n",wall.written);
297: strcat(buf,str);
298: strcat(buf,"\r\n--- SMM2SMB v");
299: strcat(buf,VERSION);
300:
301: length=strlen(buf); /* +2 for translation string */
302:
303: if(smb.status.attr&SMB_HYPERALLOC)
304: offset=smb_hallocdat(&smb);
305: else {
306: i=smb_open_da(&smb);
307: if(i) {
308: printf("smb_open_da returned %d\n",i);
309: exit(1); }
310: offset=smb_allocdat(&smb,length+2,1);
311: fclose(smb.sda_fp); }
312:
313: fseek(smb.sdt_fp,offset,SEEK_SET);
314: xlat=XLAT_NONE;
315: fwrite(&xlat,2,1,smb.sdt_fp);
316: fwrite(buf,length,1,smb.sdt_fp);
317: length+=2;
318:
319: memset(&msg,0,sizeof(smbmsg_t));
320: memcpy(msg.hdr.id,"SHD\x1a",4);
321: msg.hdr.version=SMB_VERSION;
322: msg.hdr.when_written.time=time(NULL);
323:
324: msg.hdr.offset=offset;
325:
326: strcpy(str,"SMM");
327: i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
328: if(i) {
329: printf("smb_hfield returned %d\n",i);
330: smb_freemsgdat(&smb,offset,length,1);
331: exit(1); }
332: strlwr(str);
333: msg.idx.to=crc16(str);
334:
335: strcpy(str,wall.system);
336: i=smb_hfield(&msg,SENDER,strlen(str),str);
337: if(i) {
338: printf("smb_hfield returned %d\n",i);
339: smb_freemsgdat(&smb,offset,length,1);
340: exit(1); }
341: strlwr(str);
342: msg.idx.from=crc16(str);
343:
344: strcpy(str,"->WALL<-");
345: i=smb_hfield(&msg,SUBJECT,strlen(str),str);
346: if(i) {
347: printf("smb_hfield returned %d\n",i);
348: smb_freemsgdat(&smb,offset,length,1);
349: exit(1); }
350: strlwr(str);
351: msg.idx.subj=crc16(str);
352:
353: i=smb_dfield(&msg,TEXT_BODY,length);
354: if(i) {
355: printf("smb_dfield returned %d\n",i);
356: smb_freemsgdat(&smb,offset,length,1);
357: exit(1); }
358:
359: i=smb_addmsghdr(&smb,&msg,smb.status.attr&SMB_HYPERALLOC);
360: if(i) {
361: printf("smb_addmsghdr returned %d\n",i);
362: smb_freemsgdat(&smb,offset,length,1);
363: exit(1); }
364: smb_freemsgmem(&msg); }
365: close(file); }
366:
367:
368: while(!feof(stream)) {
369: if(!fread(&user,sizeof(user_t),1,stream))
370: break;
371: if(user.misc&(USER_FROMSMB|USER_DELETED)
372: || (last && user.updated<last && user.created<last)
373: || user.number&0xffff0000L
374: || user.number==0
375: || user.system[0]<SP
376: || user.name[0]<SP
377: || user.realname[0]<SP
378: || user.location[0]<SP
379: || user.zipcode[0]<SP
380: || user.birth[0]<SP)
381: continue;
382:
383: printf("Profile: %s\n",user.name);
384: memset(buf,0,BUF_LEN);
385:
386: sprintf(str,"0:%.25s\r\n",encrypt(user.name,user.number));
387: strcat(buf,str);
388: sprintf(str,"1:%.25s\r\n",encrypt(user.realname,user.number));
389: strcat(buf,str);
390:
391: sprintf(str,"2:%.8s\r\n",encrypt(user.birth,user.number));
392: strcat(buf,str);
393:
394: sprintf(str,"3:%.30s\r\n",encrypt(user.location,user.number));
395: strcat(buf,str);
396:
397: sprintf(str,"4:%.10s\r\n",encrypt(user.zipcode,user.number));
398: strcat(buf,str);
399: sprintf(str,"5:%.10s\r\n",encrypt(user.min_zipcode,user.number));
400: strcat(buf,str);
401: sprintf(str,"6:%.10s\r\n",encrypt(user.max_zipcode,user.number));
402: strcat(buf,str);
403: sprintf(str,"7:%.4s\r\n",encrypt(user.mbtype,user.number));
404: strcat(buf,str);
405:
406: sprintf(str,"A:%.50s\r\n",encrypt(user.note[0],user.number));
407: strcat(buf,str);
408: sprintf(str,"B:%.50s\r\n",encrypt(user.note[1],user.number));
409: strcat(buf,str);
410: sprintf(str,"C:%.50s\r\n",encrypt(user.note[2],user.number));
411: strcat(buf,str);
412: sprintf(str,"D:%.50s\r\n",encrypt(user.note[3],user.number));
413: strcat(buf,str);
414: sprintf(str,"E:%.50s\r\n",encrypt(user.note[4],user.number));
415: strcat(buf,str);
416:
417: sprintf(str,"F:%c%c\r\n",user.sex,user.pref_sex);
418: strcat(buf,str);
419:
420: sprintf(str,"G:%x\r\n",user.marital);
421: strcat(buf,str);
422: sprintf(str,"H:%x\r\n",user.pref_marital);
423: strcat(buf,str);
424:
425: sprintf(str,"I:%x\r\n",user.race);
426: strcat(buf,str);
427: sprintf(str,"J:%x\r\n",user.pref_race);
428: strcat(buf,str);
429:
430: sprintf(str,"K:%x\r\n",user.hair);
431: strcat(buf,str);
432: sprintf(str,"L:%x\r\n",user.pref_hair);
433: strcat(buf,str);
434:
435: sprintf(str,"M:%x\r\n",user.eyes);
436: strcat(buf,str);
437: sprintf(str,"N:%x\r\n",user.pref_eyes);
438: strcat(buf,str);
439:
440: sprintf(str,"O:%x\r\nP:%x\r\nQ:%x\r\n"
441: ,user.weight,user.min_weight,user.max_weight);
442: strcat(buf,str);
443:
444: sprintf(str,"R:%x\r\nS:%x\r\nT:%x\r\n"
445: ,user.height,user.min_height,user.max_height);
446: strcat(buf,str);
447:
448: sprintf(str,"U:%x\r\nV:%x\r\nW:%x\r\n"
449: ,user.min_age,user.max_age,user.purity);
450: strcat(buf,str);
451:
452: sprintf(str,"X:%lx\r\nY:%lx\r\nZ:%lx\r\n!:%lx\r\n"
453: ,user.income,user.min_income,user.max_income,time(NULL));
454: strcat(buf,str);
455:
456: for(i=0;i<5;i++) {
457: if(!user.queans[i].name[0])
458: continue;
459: sprintf(str,"*%d%.8s\r\n",i,encrypt(user.queans[i].name,user.number));
460: strcat(buf,str);
461: for(j=0;j<20;j++) {
462: sprintf(str," %04x %04x"
463: ,user.queans[i].self[j]
464: ,user.queans[i].pref[j]);
465: strcat(buf,str);
466: if(!((j+1)%7))
467: strcat(buf,"\r\n"); }
468: strcat(buf,"\r\n"); }
469:
470: strcat(buf,"\r\n--- SMM2MSG v");
471: strcat(buf,VERSION);
472:
473: length=strlen(buf); /* +2 for translation string */
474:
475: if(smb.status.attr&SMB_HYPERALLOC)
476: offset=smb_hallocdat(&smb);
477: else {
478: i=smb_open_da(&smb);
479: if(i) {
480: printf("smb_open_da returned %d\n",i);
481: exit(1); }
482: offset=smb_allocdat(&smb,length+2,1);
483: fclose(smb.sda_fp); }
484:
485: fseek(smb.sdt_fp,offset,SEEK_SET);
486: xlat=XLAT_NONE;
487: fwrite(&xlat,2,1,smb.sdt_fp);
488: fwrite(buf,length,1,smb.sdt_fp);
489: length+=2;
490:
491: memset(&msg,0,sizeof(smbmsg_t));
492: memcpy(msg.hdr.id,"SHD\x1a",4);
493: msg.hdr.version=SMB_VERSION;
494: msg.hdr.when_written.time=time(NULL);
495:
496: msg.hdr.offset=offset;
497:
498: strcpy(str,"SMM");
499: i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
500: if(i) {
501: printf("smb_hfield returned %d\n",i);
502: smb_freemsgdat(&smb,offset,length,1);
503: exit(1); }
504: strlwr(str);
505: msg.idx.to=crc16(str);
506:
507: strcpy(str,user.system);
508: i=smb_hfield(&msg,SENDER,strlen(str),str);
509: if(i) {
510: printf("smb_hfield returned %d\n",i);
511: smb_freemsgdat(&smb,offset,length,1);
512: exit(1); }
513: strlwr(str);
514: msg.idx.from=crc16(str);
515:
516: sprintf(str,"%lu",user.number);
517: i=smb_hfield(&msg,SUBJECT,strlen(str),str);
518: if(i) {
519: printf("smb_hfield returned %d\n",i);
520: smb_freemsgdat(&smb,offset,length,1);
521: exit(1); }
522: strlwr(str);
523: msg.idx.subj=crc16(str);
524:
525: i=smb_dfield(&msg,TEXT_BODY,length);
526: if(i) {
527: printf("smb_dfield returned %d\n",i);
528: smb_freemsgdat(&smb,offset,length,1);
529: exit(1); }
530:
531: i=smb_addmsghdr(&smb,&msg,smb.status.attr&SMB_HYPERALLOC);
532: if(i) {
533: printf("smb_addmsghdr returned %d\n",i);
534: smb_freemsgdat(&smb,offset,length,1);
535: exit(1); }
536: smb_freemsgmem(&msg); }
537: return(0);
538: }
539:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.