home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / filesbbs / dos / sbbs_src.exe / SBBS / SMM / SMM2MSG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-25  |  13.7 KB  |  540 lines
  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.  
  540.