Annotation of sbbs/sbbs2/bulkmail.c, revision 1.1.1.2

1.1       root        1: #line 1 "BULKMAIL.C"
                      2: 
                      3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
                      4: 
                      5: #include "sbbs.h"
                      6: 
                      7: int bulkmailhdr(int usernum, smbmsg_t *msg, ushort msgattr, ulong offset
                      8:     , ulong length, char *title)
                      9: {
                     10:     char str[256];
                     11:     int i,j;
                     12:     node_t node;
                     13: 
                     14: memset(msg,0,sizeof(smbmsg_t));
                     15: memcpy(msg->hdr.id,"SHD\x1a",4);
1.1.1.2 ! root       16: msg->hdr.version=smb_ver();
1.1       root       17: msg->hdr.attr=msg->idx.attr=msgattr;
                     18: msg->hdr.when_written.time=msg->hdr.when_imported.time=time(NULL);
                     19: msg->hdr.when_written.zone=msg->hdr.when_imported.zone=sys_timezone;
                     20: msg->hdr.offset=msg->idx.offset=offset;
                     21: 
                     22: username(usernum,str);
                     23: smb_hfield(msg,RECIPIENT,strlen(str),str);
                     24: strlwr(str);
                     25: 
                     26: sprintf(str,"%u",usernum);
                     27: smb_hfield(msg,RECIPIENTEXT,strlen(str),str);
                     28: msg->idx.to=usernum;
                     29: 
                     30: strcpy(str,useron.alias);
                     31: smb_hfield(msg,SENDER,strlen(str),str);
                     32: strlwr(str);
                     33: 
                     34: sprintf(str,"%u",useron.number);
                     35: smb_hfield(msg,SENDEREXT,strlen(str),str);
                     36: msg->idx.from=useron.number;
                     37: 
                     38: strcpy(str,title);
                     39: smb_hfield(msg,SUBJECT,strlen(str),str);
                     40: strlwr(str);
                     41: msg->idx.subj=crc16(str);
                     42: 
                     43: smb_dfield(msg,TEXT_BODY,length);
                     44: 
                     45: j=smb_addmsghdr(&smb,msg,SMB_SELFPACK);
                     46: if(j)
                     47:     return(j);
                     48: 
                     49: // smb_incdat(&smb,offset,length,1); Remove 04/15/96
                     50: lncntr=0;
                     51: bprintf("Bulk Mailed %s #%d\r\n",username(usernum,tmp),usernum);
                     52: sprintf(str,"Bulk Mailed %s #%d",username(usernum,tmp),usernum);
                     53: logline("E+",str);
                     54: useron.emails++;
                     55: logon_emails++;
                     56: useron.etoday++;
                     57: for(i=1;i<=sys_nodes;i++) { /* Tell user, if online */
                     58:     getnodedat(i,&node,0);
                     59:     if(node.useron==usernum && !(node.misc&NODE_POFF)
                     60:         && (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
                     61:         sprintf(str,text[EmailNodeMsg],node_num,useron.alias);
                     62:         putnmsg(i,str);
                     63:         break; } }
                     64: if(i>sys_nodes) {   /* User wasn't online, so leave short msg */
                     65:     sprintf(str,text[UserSentYouMail],useron.alias);
                     66:     putsmsg(usernum,str); }
                     67: return(0);
                     68: }
                     69: 
                     70: void bulkmail(uchar *ar)
                     71: {
                     72:        char    str[256],str2[256],msgpath[256],title[LEN_TITLE+1],ch
                     73:                        ,buf[SDT_BLOCK_LEN],found=0;
                     74:        ushort  xlat=XLAT_NONE,msgattr=0;
                     75:        int     i,j,k,x,file;
                     76:        long    l,msgs=0;
                     77:        ulong   length,offset;
                     78:        FILE    *instream;
                     79:        user_t  user;
                     80:        smbmsg_t msg;
                     81: 
                     82: memset(&msg,0,sizeof(smbmsg_t));
                     83: 
                     84: title[0]=0;
                     85: action=NODE_SMAL;
                     86: nodesync();
                     87: 
                     88: if(sys_misc&SM_ANON_EM && (SYSOP || useron.exempt&FLAG('A'))
                     89:     && !noyes(text[AnonymousQ]))
                     90:        msgattr|=MSG_ANONYMOUS;
                     91: 
                     92: sprintf(msgpath,"%sINPUT.MSG",node_dir);
                     93: sprintf(str2,"Bulk Mailing");
                     94: if(!writemsg(msgpath,nulstr,title,WM_EMAIL,0,str2)) {
                     95:     bputs(text[Aborted]);
                     96:     return; }
                     97: 
                     98: bputs(text[WritingIndx]);
                     99: CRLF;
                    100: 
                    101: if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
                    102:        errormsg(WHERE,ERR_OPEN,"MAIL",i);
                    103:        return; }
                    104: sprintf(smb.file,"%sMAIL",data_dir);
                    105: smb.retry_time=smb_retry_time;
                    106: if((i=smb_open(&smb))!=0) {
                    107:        smb_stack(&smb,SMB_STACK_POP);
                    108:        errormsg(WHERE,ERR_OPEN,smb.file,i);
                    109:        return; }
                    110: 
                    111: if(filelength(fileno(smb.shd_fp))<1) {  /* Create it if it doesn't exist */
                    112:        smb.status.max_crcs=mail_maxcrcs;
                    113:        smb.status.max_msgs=MAX_SYSMAIL;
                    114:        smb.status.max_age=mail_maxage;
                    115:        smb.status.attr=SMB_EMAIL;
                    116:        if((i=smb_create(&smb))!=0) {
                    117:                smb_close(&smb);
                    118:                smb_stack(&smb,SMB_STACK_POP);
                    119:                errormsg(WHERE,ERR_CREATE,smb.file,i);
                    120:                return; } }
                    121: 
                    122: length=flength(msgpath)+2;      /* +2 for translation string */
                    123: 
                    124: if(length&0xfff00000UL) {
                    125:        smb_close(&smb);
                    126:        smb_stack(&smb,SMB_STACK_POP);
                    127:        errormsg(WHERE,ERR_LEN,smb.file,length);
                    128:     return; }
                    129: 
                    130: if((i=smb_open_da(&smb))!=0) {
                    131:        smb_close(&smb);
                    132:        smb_stack(&smb,SMB_STACK_POP);
                    133:        errormsg(WHERE,ERR_OPEN,smb.file,i);
                    134:        return; }
                    135: if(sys_misc&SM_FASTMAIL)
                    136:        offset=smb_fallocdat(&smb,length,1);
                    137: else
                    138:        offset=smb_allocdat(&smb,length,1);
                    139: smb_close_da(&smb);
                    140: 
                    141: if((file=open(msgpath,O_RDONLY|O_BINARY))==-1
                    142:        || (instream=fdopen(file,"rb"))==NULL) {
                    143:        smb_freemsgdat(&smb,offset,length,1);
                    144:        smb_close(&smb);
                    145:        smb_stack(&smb,SMB_STACK_POP);
                    146:        errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY|O_BINARY);
                    147:        return; }
                    148: 
                    149: setvbuf(instream,NULL,_IOFBF,2*1024);
                    150: fseek(smb.sdt_fp,offset,SEEK_SET);
                    151: xlat=XLAT_NONE;
                    152: fwrite(&xlat,2,1,smb.sdt_fp);
                    153: x=SDT_BLOCK_LEN-2;                             /* Don't read/write more than 255 */
                    154: while(!feof(instream)) {
                    155:        memset(buf,0,x);
                    156:        j=fread(buf,1,x,instream);
                    157:        if((j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
                    158:                buf[j-1]=buf[j-2]=0;
                    159:        fwrite(buf,j,1,smb.sdt_fp);
                    160:        x=SDT_BLOCK_LEN; }
                    161: fflush(smb.sdt_fp);
                    162: fclose(instream);
                    163: 
                    164: j=lastuser();
                    165: x=0;
                    166: 
                    167: if(*ar)
                    168:        for(i=1;i<=j;i++) {
                    169:                user.number=i;
                    170:                getuserdat(&user);
                    171:                if(user.misc&(DELETED|INACTIVE))
                    172:                        continue;
                    173:                if(chk_ar(ar,user)) {
                    174:                        if(found)
                    175:                                smb_freemsgmem(&msg);
                    176:                        x=bulkmailhdr(i,&msg,msgattr,offset,length,title);
                    177:                        if(x)
                    178:                                break;
                    179:                        msgs++;
                    180:                        found=1; } }
                    181: else
                    182:        while(1) {
                    183:                bputs(text[EnterAfterLastDestUser]);
                    184:                if(!getstr(str,LEN_ALIAS,K_UPRLWR))
                    185:                        break;
                    186:                if((i=finduser(str))!=0) {
                    187:                        if(found)
                    188:                                smb_freemsgmem(&msg);
                    189:                        x=bulkmailhdr(i,&msg,msgattr,offset,length,title);
                    190:                        if(x)
                    191:                                break;
                    192:                        msgs++; }
                    193:                found=1; }
                    194: 
                    195: if((i=smb_open_da(&smb))!=0) {
                    196:        smb_close(&smb);
                    197:        smb_stack(&smb,SMB_STACK_POP);
                    198:        errormsg(WHERE,ERR_OPEN,smb.file,i);
                    199:        return; }
                    200: if(!msgs)
                    201:        smb_freemsgdat(&smb,offset,length,1);
                    202: else if(msgs>1)
                    203:        smb_incdat(&smb,offset,length,msgs-1);
                    204: smb_close_da(&smb);
                    205: 
                    206: smb_close(&smb);
                    207: smb_stack(&smb,SMB_STACK_POP);
                    208: 
                    209: smb_freemsgmem(&msg);
                    210: if(x) {
                    211:        smb_freemsgdat(&smb,offset,length,1);
                    212:        errormsg(WHERE,ERR_WRITE,smb.file,x);
                    213:        return; }
                    214: 
                    215: putuserrec(useron.number,U_EMAILS,5,itoa(useron.emails,tmp,10));
                    216: putuserrec(useron.number,U_ETODAY,5,itoa(useron.etoday,tmp,10));
                    217: }
                    218: 
                    219: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.