void sbbs_t::telluser(smbmsg_t* msg)
{
char str[256];
uint usernumber,n;
node_t node;
if(msg->from_net.type)
return;
if(msg->from_ext)
usernumber=atoi(msg->from_ext);
else {
usernumber=matchuser(&cfg,msg->from,TRUE /*sysop_alias*/);
if(!usernumber)
return;
}
for(n=1;n<=cfg.sys_nodes;n++) { /* Tell user */
getnodedat(n,&node,0);
if(node.useron==usernumber
&& (node.status==NODE_INUSE
|| node.status==NODE_QUIET)) {
sprintf(str
,text[UserReadYourMailNodeMsg]
,cfg.node_num,useron.alias);
putnmsg(&cfg,n,str);
break;
}
}
if(n>cfg.sys_nodes) {
now=time(NULL);
sprintf(str,text[UserReadYourMail]
,useron.alias,timestr(now));
putsmsg(&cfg,usernumber,str);
}
}
int sbbs_t::bulkmailhdr(smb_t* smb, smbmsg_t* msg, uint usernum)
{
char str[256];
int i,j;
ushort nettype=NET_UNKNOWN;
node_t node;
user_t user;
smbmsg_t newmsg;
user.number=usernum;
if(getuserdat(&cfg, &user)!=0)
return(0);
if((i=smb_copymsgmem(NULL,&newmsg,msg))!=SMB_SUCCESS)
return(i);
SAFECOPY(str,user.alias);
smb_hfield_str(&newmsg,RECIPIENT,str);
if(cfg.sys_misc&SM_FWDTONET && user.misc&NETMAIL && user.netmail[0]) {
bprintf(text[UserNetMail],user.netmail);
smb_hfield_netaddr(&newmsg,RECIPIENTNETADDR,user.netmail,&nettype);
smb_hfield_bin(&newmsg,RECIPIENTNETTYPE,nettype);
} else {
sprintf(str,"%u",usernum);
smb_hfield_str(&newmsg,RECIPIENTEXT,str);
}
j=smb_addmsghdr(smb,&newmsg,SMB_SELFPACK);
smb_freemsgmem(&newmsg);
if(j!=SMB_SUCCESS)
return(j);
lncntr=0;
bprintf(text[Emailing],user.alias,usernum);
sprintf(str,"%s bulk-mailed %s #%d"
,useron.alias,user.alias,usernum);
logline("E+",str);
useron.emails++;
logon_emails++;
useron.etoday++;
for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
getnodedat(i,&node,0);
if(node.useron==usernum && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
sprintf(str,text[EmailNodeMsg],cfg.node_num,useron.alias);
putnmsg(&cfg,i,str);
break;
}
}
if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
sprintf(str,text[UserSentYouMail],useron.alias);
putsmsg(&cfg,usernum,str);
}
return(0);
}
bool sbbs_t::email(int usernumber, const char *top, const char *subj, long mode)
{
char str[256],str2[256],msgpath[256],title[LEN_TITLE+1],ch
,buf[SDT_BLOCK_LEN];
char tmp[512];
char pid[128];
char* editor=NULL;
ushort msgattr=0;
uint16_t xlat=XLAT_NONE;
ushort nettype;
int i,j,x,file;
long l;
long length;
ulong offset;
uint32_t crc=0xffffffffUL;
FILE* instream;
node_t node;
smbmsg_t msg;
SAFECOPY(title,subj);
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP && !(useron.exempt&FLAG('M'))) {
bputs(text[TooManyEmailsToday]);
return(false);
}
if(usernumber==1 && useron.rest&FLAG('S')
&& (cfg.node_valuser!=1 || useron.fbacks || useron.emails)) { /* ! val fback */
bprintf(text[R_Feedback],cfg.sys_op);
return(false);
}
if(usernumber!=1 && useron.rest&FLAG('E')
&& (cfg.node_valuser!=usernumber || useron.fbacks || useron.emails)) {
bputs(text[R_Email]);
return(false);
}
if(!usernumber) {
bputs(text[UnknownUser]);
return(false);
}
getuserrec(&cfg,usernumber,U_MISC,8,str);
l=ahtoul(str);
if(l&(DELETED|INACTIVE)) { /* Deleted or Inactive User */
bputs(text[UnknownUser]);
return(false);
}
if((l&NETMAIL) && (cfg.sys_misc&SM_FWDTONET)) {
getuserrec(&cfg,usernumber,U_NETMAIL,LEN_NETMAIL,str);
bprintf(text[UserNetMail],str);
if((mode & WM_FORCEFWD) || text[ForwardMailQ][0]==0 || yesno(text[ForwardMailQ])) /* Forward to netmail address */
return(netmail(str,subj,mode));
}
bprintf(text[Emailing],username(&cfg,usernumber,tmp),usernumber);
action=NODE_SMAL;
nodesync();
sprintf(str,"%sfeedback.*", cfg.exec_dir);
if(usernumber==cfg.node_valuser && useron.fbacks && fexist(str)) {
exec_bin("feedback",&main_csi);
if(main_csi.logic!=LOGIC_TRUE)
return(false);
}
if(cfg.sys_misc&SM_ANON_EM && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ]))
msgattr|=MSG_ANONYMOUS;
if(cfg.sys_misc&SM_DELREADM)
msgattr|=MSG_KILLREAD;
msg_tmp_fname(useron.xedit, msgpath, sizeof(msgpath));
username(&cfg,usernumber,str2);
if(!writemsg(msgpath,top,title,mode,INVALID_SUB,str2,&editor)) {
bputs(text[Aborted]);
return(false);
}
if(mode&WM_FILE && !SYSOP && !(cfg.sys_misc&SM_FILE_EM))
mode&=~WM_FILE;
if(mode&WM_FILE) {
sprintf(str2,"%sfile/%04u.in", cfg.data_dir,usernumber);
MKDIR(str2);
sprintf(str2,"%sfile/%04u.in/%s", cfg.data_dir,usernumber,title);
if(fexistcase(str2)) {
bputs(text[FileAlreadyThere]);
remove(msgpath);
return(false);
}
{ /* Remote */
xfer_prot_menu(XFER_UPLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str,"Q");
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && chk_ar(cfg.prot[x]->ar,&useron,&client)) {
sprintf(tmp,"%c",cfg.prot[x]->mnemonic);
strcat(str,tmp);
}
ch=(char)getkeys(str,0);
if(ch=='Q' || sys_status&SS_ABORT) {
bputs(text[Aborted]);
remove(msgpath);
return(false);
}
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && cfg.prot[x]->mnemonic==ch
&& chk_ar(cfg.prot[x]->ar,&useron,&client))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,str2,nulstr,true);
}
safe_snprintf(tmp,sizeof(tmp),"%s%s",cfg.temp_dir,title);
if(!fexistcase(str2) && fexistcase(tmp))
mv(tmp,str2,0);
l=(long)flength(str2);
if(l>0)
bprintf(text[FileNBytesReceived],title,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],title);
remove(msgpath);
return(false);
}
}
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
return(false);
}
sprintf(smb.file,"%smail", cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(smb_fgetlength(smb.shd_fp)<1) { /* Create it if it doesn't exist */
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_age=cfg.mail_maxage;
smb.status.max_msgs=0;
smb.status.attr=SMB_EMAIL;
if((i=smb_create(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i,smb.last_error);
return(false);
}
}
if((i=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(false);
}
length=(long)flength(msgpath)+2; /* +2 for translation string */
if(length&0xfff00000UL) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LEN,msgpath,length);
return(false);
}
if((i=smb_open_da(&smb))!=0) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
if((instream=fnopen(&file,msgpath,O_RDONLY|O_BINARY))==NULL) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY|O_BINARY);
return(false);
}
setvbuf(instream,NULL,_IOFBF,2*1024);
smb_fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
smb_fwrite(&smb,&xlat,2,smb.sdt_fp);
x=SDT_BLOCK_LEN-2; /* Don't read/write more than 255 */
while(!feof(instream)) {
memset(buf,0,x);
j=fread(buf,1,x,instream);
if(j<1)
break;
if(j>1 && (j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
buf[j-1]=buf[j-2]=0;
if(cfg.mail_maxcrcs) {
for(i=0;i<j;i++)
crc=ucrc32(buf[i],crc);
}
smb_fwrite(&smb,buf,j,smb.sdt_fp);
x=SDT_BLOCK_LEN;
}
smb_fflush(smb.sdt_fp);
fclose(instream);
crc=~crc;
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
msg.hdr.attr=msgattr;
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time32(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
if(cfg.mail_maxcrcs) {
i=smb_addcrc(&smb,crc);
if(i) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
attr(cfg.color[clr_err]);
bputs(text[CantPostMsg]);
return(false);
}
}
msg.hdr.offset=offset;
username(&cfg,usernumber,str);
smb_hfield_str(&msg,RECIPIENT,str);
sprintf(str,"%u",usernumber);
smb_hfield_str(&msg,RECIPIENTEXT,str);
SAFECOPY(str,useron.alias);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
if(useron.misc&NETMAIL) {
if(useron.rest&FLAG('G'))
smb_hfield_str(&msg,REPLYTO,useron.name);
nettype=smb_netaddr_type(useron.netmail);
if(nettype!=NET_NONE && nettype!=NET_UNKNOWN) {
smb_hfield(&msg,REPLYTONETTYPE,sizeof(nettype),&nettype);
smb_hfield_str(&msg,REPLYTONETADDR,useron.netmail);
}
}
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SENDERSERVER,startup->host_name);
smb_hfield_str(&msg,SUBJECT,title);
/* Generate FidoNet Program Identifier */
smb_hfield_str(&msg,FIDOPID,msg_program_id(pid));
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK); // calls smb_unlocksmbhdr()
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
smb_freemsgdat(&smb,offset,length,1);
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
return(false);
}
if(usernumber==1)
logon_fbacks++;
else
logon_emails++;
user_sent_email(&cfg, &useron, 1, usernumber==1);
bprintf(text[Emailed],username(&cfg,usernumber,tmp),usernumber);
safe_snprintf(str,sizeof(str),"%s sent e-mail to %s #%d"
,useron.alias,username(&cfg,usernumber,tmp),usernumber);
logline("E+",str);
if(mode&WM_FILE && online==ON_REMOTE)
autohangup();
if(msgattr&MSG_ANONYMOUS) /* Don't tell user if anonymous */
return(true);
for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
getnodedat(i,&node,0);
if(node.useron==usernumber && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
safe_snprintf(str,sizeof(str),text[EmailNodeMsg],cfg.node_num,useron.alias);
putnmsg(&cfg,i,str);
break;
}
}
if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
safe_snprintf(str,sizeof(str),text[UserSentYouMail],useron.alias);
putsmsg(&cfg,usernumber,str);
}
return(true);
}
bool sbbs_t::logon()
{
char str[256],c;
char tmp[512];
int file;
uint i,j,mailw;
long kmode;
ulong totallogons;
node_t node;
struct tm tm;
now=time(NULL);
if(localtime_r(&now,&tm)==NULL)
return(false);
if(!useron.number)
return(false);
client.user=useron.alias;
client_on(client_socket,&client,TRUE /* update */);
#ifdef JAVASCRIPT
js_create_user_objects();
#endif
if(useron.rest&FLAG('Q'))
qwklogon=1;
if(SYSOP && !(cfg.sys_misc&SM_R_SYSOP))
return(false);
if(useron.rest&FLAG('G')) { /* Guest account */
useron.misc=(cfg.new_misc&(~ASK_NSCAN));
useron.rows=0;
useron.misc&=~(ANSI|RIP|WIP|NO_EXASCII|COLOR|HTML);
useron.misc|=autoterm;
if(!(useron.misc&ANSI) && text[AnsiTerminalQ][0] && yesno(text[AnsiTerminalQ]))
useron.misc|=ANSI;
if(useron.misc&(RIP|WIP|HTML)
|| (useron.misc&ANSI && text[ColorTerminalQ][0] && yesno(text[ColorTerminalQ])))
useron.misc|=COLOR;
if(text[ExAsciiTerminalQ][0] && !yesno(text[ExAsciiTerminalQ]))
useron.misc|=NO_EXASCII;
for(i=0;i<cfg.total_xedits;i++)
if(!stricmp(cfg.xedit[i]->code,cfg.new_xedit)
&& chk_ar(cfg.xedit[i]->ar,&useron,&client))
break;
if(i<cfg.total_xedits)
useron.xedit=i+1;
else
useron.xedit=0;
useron.prot=cfg.new_prot;
useron.shell=cfg.new_shell;
}
if(!chk_ar(cfg.node_ar,&useron,&client)) {
bputs(text[NoNodeAccess]);
sprintf(str,"(%04u) %-25s Insufficient node access"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
return(false);
}
getnodedat(cfg.node_num,&thisnode,1);
if(thisnode.misc&NODE_LOCK) {
putnodedat(cfg.node_num,&thisnode); /* must unlock! */
if(!SYSOP && !(useron.exempt&FLAG('N'))) {
bputs(text[NodeLocked]);
sprintf(str,"(%04u) %-25s Locked node logon attempt"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
return(false);
}
if(yesno(text[RemoveNodeLockQ])) {
getnodedat(cfg.node_num,&thisnode,1);
logline("S-","Removed Node Lock");
thisnode.misc&=~NODE_LOCK;
}
else
getnodedat(cfg.node_num,&thisnode,1);
}
if(useron.exempt&FLAG('H'))
console|=CON_NO_INACT;
if((useron.exempt&FLAG('Q') && useron.misc&QUIET))
thisnode.status=NODE_QUIET;
else
thisnode.status=NODE_INUSE;
action=thisnode.action=NODE_LOGN;
thisnode.connection=node_connection;
thisnode.misc&=~(NODE_ANON|NODE_INTR|NODE_MSGW|NODE_POFF|NODE_AOFF);
if(useron.chat&CHAT_NOACT)
thisnode.misc|=NODE_AOFF;
if(useron.chat&CHAT_NOPAGE)
thisnode.misc|=NODE_POFF;
thisnode.useron=useron.number;
putnodedat(cfg.node_num,&thisnode);
getusrsubs();
getusrdirs();
if(useron.misc&CURSUB && !(useron.rest&FLAG('G'))) {
for(i=0;i<usrgrps;i++) {
for(j=0;j<usrsubs[i];j++) {
if(!strcmp(cfg.sub[usrsub[i][j]]->code,useron.cursub))
break;
}
if(j<usrsubs[i]) {
curgrp=i;
cursub[i]=j;
break;
}
}
for(i=0;i<usrlibs;i++) {
for(j=0;j<usrdirs[i];j++)
if(!strcmp(cfg.dir[usrdir[i][j]]->code,useron.curdir))
break;
if(j<usrdirs[i]) {
curlib=i;
curdir[i]=j;
break;
}
}
}
if(useron.misc&AUTOTERM) {
useron.misc&=~(ANSI|RIP|WIP|HTML);
useron.misc|=autoterm;
}
if(!chk_ar(cfg.shell[useron.shell]->ar,&useron,&client)) {
useron.shell=cfg.new_shell;
if(!chk_ar(cfg.shell[useron.shell]->ar,&useron,&client)) {
for(i=0;i<cfg.total_shells;i++)
if(chk_ar(cfg.shell[i]->ar,&useron,&client))
break;
if(i==cfg.total_shells)
useron.shell=0;
}
}
logon_ml=useron.level;
logontime=time(NULL);
starttime=logontime;
useron.logontime=(time32_t)logontime;
last_ns_time=ns_time=useron.ns_time;
// ns_time-=(useron.tlast*60); /* file newscan time == last logon time */
delfiles(cfg.temp_dir,ALLFILES);
sprintf(str,"%smsgs/n%3.3u.msg",cfg.data_dir,cfg.node_num);
remove(str); /* remove any pending node messages */
sprintf(str,"%smsgs/n%3.3u.ixb",cfg.data_dir,cfg.node_num);
remove(str); /* remove any pending node message indices */
if(!SYSOP && online==ON_REMOTE && !qwklogon) {
rioctl(IOCM|ABORT); /* users can't abort anything */
rioctl(IOCS|ABORT);
}
CLS;
if(useron.rows)
rows=useron.rows;
unixtodstr(&cfg,(time32_t)logontime,str);
if(!strncmp(str,useron.birth,5) && !(useron.rest&FLAG('Q'))) {
bputs(text[HappyBirthday]);
pause();
CLS;
user_event(EVENT_BIRTHDAY);
}
useron.ltoday++;
gettimeleft();
sprintf(str,"%sfile/%04u.dwn",cfg.data_dir,useron.number);
batch_add_list(str);
if(!qwklogon) { /* QWK Nodes don't go through this */
if(cfg.sys_pwdays
&& (ulong)logontime>(useron.pwmod+((ulong)cfg.sys_pwdays*24UL*60UL*60UL))) {
bprintf(text[TimeToChangePw],cfg.sys_pwdays);
c=0;
while(c<LEN_PASS) { /* Create random password */
str[c]=sbbs_random(43)+'0';
if(isalnum(str[c]))
c++;
}
str[c]=0;
bprintf(text[YourPasswordIs],str);
if(cfg.sys_misc&SM_PWEDIT && yesno(text[NewPasswordQ]))
while(online) {
bputs(text[NewPassword]);
getstr(str,LEN_PASS,K_UPPER|K_LINE);
truncsp(str);
if(chkpass(str,&useron,true))
break;
CRLF;
}
while(online) {
if(cfg.sys_misc&SM_PWEDIT) {
CRLF;
bputs(text[VerifyPassword]);
}
else
bputs(text[NewUserPasswordVerify]);
console|=CON_R_ECHOX;
getstr(tmp,LEN_PASS*2,K_UPPER);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
if(strcmp(str,tmp)) {
bputs(text[Wrong]);
continue;
}
break;
}
strcpy(useron.pass,str);
useron.pwmod=time32(NULL);
putuserrec(&cfg,useron.number,U_PWMOD,8,ultoa((ulong)useron.pwmod,str,16));
bputs(text[PasswordChanged]);
pause();
}
if(useron.ltoday>cfg.level_callsperday[useron.level]
&& !(useron.exempt&FLAG('L'))) {
bputs(text[NoMoreLogons]);
sprintf(str,"(%04u) %-25s Out of logons"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
hangup();
return(false);
}
if(useron.rest&FLAG('L') && useron.ltoday>1) {
bputs(text[R_Logons]);
sprintf(str,"(%04u) %-25s Out of logons"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
hangup();
return(false);
}
kmode=(cfg.uq&UQ_NOEXASC);
if(!(cfg.uq&UQ_NOUPRLWR))
kmode|=K_UPRLWR;
if(!(useron.rest&FLAG('G'))) {
if(!useron.name[0] && ((cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME)
|| cfg.uq&UQ_COMPANY))
while(online) {
if(cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME)
bputs(text[EnterYourRealName]);
else
bputs(text[EnterYourCompany]);
getstr(useron.name,LEN_NAME,kmode);
if(cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME) {
if(trashcan(useron.name,"name") || !useron.name[0]
|| !strchr(useron.name,' ')
|| strchr(useron.name,0xff)
|| (cfg.uq&UQ_DUPREAL
&& userdatdupe(useron.number,U_NAME,LEN_NAME
,useron.name,0,0)))
bputs(text[YouCantUseThatName]);
else
break;
}
else
break;
}
if(cfg.uq&UQ_HANDLE && !useron.handle[0]) {
sprintf(useron.handle,"%.*s",LEN_HANDLE,useron.alias);
while(online) {
bputs(text[EnterYourHandle]);
if(!getstr(useron.handle,LEN_HANDLE
,K_LINE|K_EDIT|K_AUTODEL|(cfg.uq&UQ_NOEXASC))
|| strchr(useron.handle,0xff)
|| (cfg.uq&UQ_DUPHAND
&& userdatdupe(useron.number,U_HANDLE,LEN_HANDLE
,useron.handle,0,0))
|| trashcan(useron.handle,"name"))
bputs(text[YouCantUseThatName]);
else
break;
}
}
if(cfg.uq&UQ_LOCATION && !useron.location[0])
while(online) {
bputs(text[EnterYourCityState]);
if(getstr(useron.location,LEN_LOCATION,kmode))
break;
}
if(cfg.uq&UQ_ADDRESS && !useron.address[0])
while(online) {
bputs(text[EnterYourAddress]);
if(getstr(useron.address,LEN_ADDRESS,kmode))
break;
}
if(cfg.uq&UQ_ADDRESS && !useron.zipcode[0])
while(online) {
bputs(text[EnterYourZipCode]);
if(getstr(useron.zipcode,LEN_ZIPCODE,K_UPPER|(cfg.uq&UQ_NOEXASC)))
break;
}
if(cfg.uq&UQ_PHONE && !useron.phone[0]) {
if(text[CallingFromNorthAmericaQ][0])
i=yesno(text[CallingFromNorthAmericaQ]);
else
i=0;
while(online) {
bputs(text[EnterYourPhoneNumber]);
if(i) {
if(gettmplt(useron.phone,cfg.sys_phonefmt
,K_LINE|(cfg.uq&UQ_NOEXASC))<strlen(cfg.sys_phonefmt))
continue;
} else {
if(getstr(useron.phone,LEN_PHONE
,K_UPPER|(cfg.uq&UQ_NOEXASC))<5)
continue;
}
if(!trashcan(useron.phone,"phone"))
break;
}
}
if(!(cfg.uq&UQ_NONETMAIL) && !useron.netmail[0]) {
while(online) {
bputs(text[EnterNetMailAddress]);
if(getstr(useron.netmail,LEN_NETMAIL,K_EDIT|K_AUTODEL|K_LINE)
&& !trashcan(useron.netmail,"email"))
break;
}
if(useron.netmail[0] && cfg.sys_misc&SM_FWDTONET && !noyes(text[ForwardMailQ]))
useron.misc|=NETMAIL;
else
useron.misc&=~NETMAIL;
}
if(cfg.new_sif[0]) {
sprintf(str,"%suser/%4.4u.dat",cfg.data_dir,useron.number);
if(flength(str)<1L)
create_sif_dat(cfg.new_sif,str);
}
}
}
if(!online) {
sprintf(str,"(%04u) %-25s Unsuccessful logon"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
return(false);
}
SAFECOPY(useron.modem,connection);
useron.logons++;
putuserdat(&cfg,&useron);
getmsgptrs();
sys_status|=SS_USERON; /* moved from further down */
if(useron.rest&FLAG('Q')) {
sprintf(str,"(%04u) %-25s QWK Network Connection"
,useron.number,useron.alias);
logline("++",str);
return(true);
}
/********************/
/* SUCCESSFUL LOGON */
/********************/
totallogons=logonstats();
sprintf(str,"(%04u) %-25s Logon %lu - %u"
,useron.number,useron.alias,totallogons,useron.ltoday);
logline("++",str);
if(!qwklogon && cfg.logon_mod[0])
exec_bin(cfg.logon_mod,&main_csi);
if(thisnode.status!=NODE_QUIET && (!REALSYSOP || cfg.sys_misc&SM_SYSSTAT)) {
sprintf(str,"%slogon.lst",cfg.data_dir);
if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_CREAT|O_APPEND);
return(false);
}
getuserrec(&cfg,useron.number,U_NOTE,LEN_NOTE,useron.note);
getuserrec(&cfg,useron.number,U_LOCATION,LEN_LOCATION,useron.location);
sprintf(str,text[LastFewCallersFmt],cfg.node_num
,totallogons,useron.alias
,cfg.sys_misc&SM_LISTLOC ? useron.location : useron.note
,tm.tm_hour,tm.tm_min
,connection,useron.ltoday > 999 ? 999 : useron.ltoday);
write(file,str,strlen(str));
close(file);
}
if(cfg.sys_logon[0]) /* execute system logon event */
external(cmdstr(cfg.sys_logon,nulstr,nulstr,NULL),EX_STDOUT); /* EX_SH */
if(qwklogon)
return(true);
sys_status|=SS_PAUSEON; /* always force pause on during this section */
mailw=getmail(&cfg,useron.number,0);
if(!(cfg.sys_misc&SM_NOSYSINFO)) {
bprintf(text[SiSysName],cfg.sys_name);
//bprintf(text[SiNodeNumberName],cfg.node_num,cfg.node_name);
bprintf(text[LiUserNumberName],useron.number,useron.alias);
bprintf(text[LiLogonsToday],useron.ltoday
,cfg.level_callsperday[useron.level]);
bprintf(text[LiTimeonToday],useron.ttoday
,cfg.level_timeperday[useron.level]+useron.min);
bprintf(text[LiMailWaiting],mailw);
strcpy(str,text[LiSysopIs]);
if(startup->options&BBS_OPT_SYSOP_AVAILABLE
|| (cfg.sys_chat_ar[0] && chk_ar(cfg.sys_chat_ar,&useron,&client)))
strcat(str,text[LiSysopAvailable]);
else
strcat(str,text[LiSysopNotAvailable]);
bprintf("%s\r\n\r\n",str);
}
if(sys_status&SS_EVENT)
bprintf(text[ReducedTime],timestr(event_time));
getnodedat(cfg.node_num,&thisnode,1);
thisnode.misc&=~(NODE_AOFF|NODE_POFF);
if(useron.chat&CHAT_NOACT)
thisnode.misc|=NODE_AOFF;
if(useron.chat&CHAT_NOPAGE)
thisnode.misc|=NODE_POFF;
putnodedat(cfg.node_num,&thisnode);
getsmsg(useron.number); /* Moved from further down */
SYNC;
c=0;
for(i=1;i<=cfg.sys_nodes;i++)
if(i!=cfg.node_num) {
getnodedat(i,&node,0);
if(!(cfg.sys_misc&SM_NONODELIST)
&& (node.status==NODE_INUSE
|| ((node.status==NODE_QUIET || node.errors) && SYSOP))) {
if(!c)
bputs(text[NodeLstHdr]);
printnodedat(i,&node);
c=1;
}
if(node.status==NODE_INUSE && i!=cfg.node_num && node.useron==useron.number
&& !SYSOP && !(useron.exempt&FLAG('G'))) {
SAFEPRINTF2(str,"(%04u) %-25s On two nodes at the same time"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
bputs(text[UserOnTwoNodes]);
hangup();
return(false);
}
if(thisnode.status!=NODE_QUIET
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)
&& !(node.misc&NODE_AOFF) && node.useron!=useron.number) {
sprintf(str,text[NodeLoggedOnAtNbps]
,cfg.node_num
,thisnode.misc&NODE_ANON ? text[UNKNOWN_USER] : useron.alias
,connection);
putnmsg(&cfg,i,str);
}
}
if(cfg.sys_exp_warn && useron.expire && useron.expire>now /* Warn user of coming */
&& (useron.expire-now)/(1440L*60L)<=cfg.sys_exp_warn) /* expiration */
bprintf(text[AccountWillExpireInNDays],(useron.expire-now)/(1440L*60L));
if(criterrs && SYSOP)
bprintf(text[CriticalErrors],criterrs);
if((i=getuserxfers(0,useron.number,0))!=0)
bprintf(text[UserXferForYou],i,i>1 ? "s" : nulstr);
if((i=getuserxfers(useron.number,0,0))!=0)
bprintf(text[UnreceivedUserXfer],i,i>1 ? "s" : nulstr);
SYNC;
sys_status&=~SS_PAUSEON; /* Turn off the pause override flag */
if(online==ON_REMOTE)
rioctl(IOSM|ABORT); /* Turn abort ability on */
if(text[ReadYourMailNowQ][0] && mailw) {
if(yesno(text[ReadYourMailNowQ]))
readmail(useron.number,MAIL_YOUR);
}
if(usrgrps && useron.misc&ASK_NSCAN && text[NScanAllGrpsQ][0] && yesno(text[NScanAllGrpsQ]))
scanallsubs(SCAN_NEW);
if(usrgrps && useron.misc&ASK_SSCAN && text[SScanAllGrpsQ][0] && yesno(text[SScanAllGrpsQ]))
scanallsubs(SCAN_TOYOU);
return(true);
}
void sbbs_t::logout()
{
char str[256];
char tmp[512];
int i,j;
ushort ttoday;
node_t node;
struct tm tm;
now=time(NULL);
if(localtime_r(&now,&tm)==NULL)
return;
if(!useron.number) { /* Not logged in, so do nothing */
if(!online) {
sprintf(str,"%s T:%3u sec\r\n"
,hhmmtostr(&cfg,&tm,tmp)
,(uint)(now-answertime));
logline("@-",str);
}
return;
}
strcpy(lastuseron,useron.alias); /* for use with WFC status display */
if(useron.rest&FLAG('G')) { /* Reset guest's msg scan cfg */
putuserrec(&cfg,useron.number,U_NAME,LEN_NAME,nulstr);
batdn_total=0;
}
batch_create_list();
if(sys_status&SS_USERON && thisnode.status!=NODE_QUIET && !(useron.rest&FLAG('Q')))
for(i=1;i<=cfg.sys_nodes;i++)
if(i!=cfg.node_num) {
getnodedat(i,&node,0);
if((node.status==NODE_INUSE || node.status==NODE_QUIET)
&& !(node.misc&NODE_AOFF) && node.useron!=useron.number) {
sprintf(str,text[NodeLoggedOff],cfg.node_num
,thisnode.misc&NODE_ANON
? text[UNKNOWN_USER] : useron.alias);
putnmsg(&cfg,i,str); }
}
if(!online) { /* NOT re-login */
#if 0 /* too soon, handled in node_thread */
getnodedat(cfg.node_num,&thisnode,1);
thisnode.status=NODE_WFC;
thisnode.misc&=~(NODE_INTR|NODE_MSGW|NODE_NMSG
|NODE_UDAT|NODE_POFF|NODE_AOFF|NODE_EXT);
putnodedat(cfg.node_num,&thisnode);
#endif
#if 0 /* beep? */
if(sys_status&SS_SYSALERT) {
mswait(500);
offhook();
CLS;
lputs("\r\n\r\nAlerting Sysop...");
while(!lkbrd(1)) {
sbbs_beep(1000,200);
nosound();
mswait(200);
}
lkbrd(0);
}
#endif
sys_status&=~SS_SYSALERT;
if(cfg.sys_logout[0]) /* execute system logout event */
external(cmdstr(cfg.sys_logout,nulstr,nulstr,NULL),EX_OUTL|EX_OFFLINE);
}
if(cfg.logout_mod[0])
exec_bin(cfg.logout_mod,&main_csi);
backout();
sprintf(str,"%smsgs/%4.4u.msg",cfg.data_dir,useron.number);
if(!flength(str)) /* remove any 0 byte message files */
remove(str);
delfiles(cfg.temp_dir,ALLFILES);
putmsgptrs();
if(!REALSYSOP)
logofflist();
useron.laston=(time32_t)now;
ttoday=useron.ttoday-useron.textra; /* billable time used prev calls */
if(ttoday>=cfg.level_timeperday[useron.level])
i=0;
else
i=cfg.level_timeperday[useron.level]-ttoday;
if(i>cfg.level_timepercall[useron.level]) /* i=amount of time without min */
i=cfg.level_timepercall[useron.level];
j=(int)(now-starttime)/60; /* j=billable time online in min */
if(i<0) i=0;
if(j<0) j=0;
if(useron.min && j>i) {
j-=i; /* j=time to deduct from min */
sprintf(str,"Minute Adjustment: %d",-j);
logline(">>",str);
if(useron.min>(ulong)j)
useron.min-=j;
else
useron.min=0L;
putuserrec(&cfg,useron.number,U_MIN,10,ultoa(useron.min,str,10));
}
if(timeleft>0 && starttime-logontime>0) /* extra time */
useron.textra+=(ushort)((starttime-logontime)/60);
putuserrec(&cfg,useron.number,U_TEXTRA,5,ultoa(useron.textra,str,10));
putuserrec(&cfg,useron.number,U_NS_TIME,8,ultoa((ulong)last_ns_time,str,16));
logoutuserdat(&cfg, &useron, now, logontime);
getusrsubs();
getusrdirs();
if(usrgrps>0)
putuserrec(&cfg,useron.number,U_CURSUB,0,cfg.sub[usrsub[curgrp][cursub[curgrp]]]->code);
if(usrlibs>0)
putuserrec(&cfg,useron.number,U_CURDIR,0,cfg.dir[usrdir[curlib][curdir[curlib]]]->code);
hhmmtostr(&cfg,&tm,str);
strcat(str," ");
if(sys_status&SS_USERON)
sprintf(tmp,"T:%3u R:%3lu P:%3lu E:%3lu F:%3lu "
"U:%3luk %lu D:%3luk %lu"
,(uint)(now-logontime)/60,posts_read,logon_posts
,logon_emails,logon_fbacks,logon_ulb/1024UL,logon_uls
,logon_dlb/1024UL,logon_dls);
else
sprintf(tmp,"T:%3u sec",(uint)(now-answertime));
strcat(str,tmp);
strcat(str,"\r\n");
logline("@-",str);
sys_status&=~SS_USERON;
answertime=now; // Incase we're relogging on
}
bool sbbs_t::unpack_rep(char* repfile)
{
char str[MAX_PATH+1],fname[MAX_PATH+1]
,*AttemptedToUploadREPpacket="Attempted to upload REP packet";
char tmp[512];
char from[26];
char to[26];
char inbox[MAX_PATH+1];
char block[QWK_BLOCK_LEN];
int file;
uint i,j,k,lastsub=INVALID_SUB;
long l,size,misc;
ulong n;
ulong ex;
node_t node;
FILE* rep;
DIR* dir;
DIRENT* dirent;
BOOL twit_list;
sprintf(fname,"%stwitlist.cfg",cfg.ctrl_dir);
twit_list=fexist(fname);
if(repfile!=NULL)
strcpy(str,repfile);
else
sprintf(str,"%s%s.rep",cfg.temp_dir,cfg.sys_id);
if(!fexistcase(str)) {
bputs(text[QWKReplyNotReceived]);
logline("U!",AttemptedToUploadREPpacket);
logline(nulstr,"REP file not received");
return(false);
}
for(k=0;k<cfg.total_fextrs;k++)
if(!stricmp(cfg.fextr[k]->ext,useron.tmpext) && chk_ar(cfg.fextr[k]->ar,&useron))
break;
if(k>=cfg.total_fextrs)
k=0;
ex=EX_OUTL|EX_OUTR;
if(online!=ON_REMOTE)
ex|=EX_OFFLINE;
i=external(cmdstr(cfg.fextr[k]->cmd,str,ALLFILES,NULL),ex);
if(i) {
bputs(text[QWKExtractionFailed]);
logline("U!",AttemptedToUploadREPpacket);
logline(nulstr,"Extraction failed");
return(false);
}
sprintf(str,"%s%s.msg",cfg.temp_dir,cfg.sys_id);
if(!fexistcase(str)) {
bputs(text[QWKReplyNotReceived]);
logline("U!",AttemptedToUploadREPpacket);
logline(nulstr,"MSG file not received");
return(false);
}
if((rep=fnopen(&file,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(false);
}
size=filelength(file);
fread(block,QWK_BLOCK_LEN,1,rep);
if(strnicmp((char *)block,cfg.sys_id,strlen(cfg.sys_id))) {
fclose(rep);
bputs(text[QWKReplyNotReceived]);
logline("U!",AttemptedToUploadREPpacket);
logline(nulstr,"Incorrect BBSID");
return(false);
}
logline("U+","Uploaded REP packet");
/********************/
/* Process messages */
/********************/
bputs(text[QWKUnpacking]);
for(l=QWK_BLOCK_LEN;l<size;l+=i*QWK_BLOCK_LEN) {
if(terminated) {
bprintf("!Terminated");
break;
}
lncntr=0; /* defeat pause */
if(fseek(rep,l,SEEK_SET)!=0) {
sprintf(str,"%s.msg", cfg.sys_id);
errormsg(WHERE,ERR_SEEK,str,l);
break;
}
if(fread(block,1,QWK_BLOCK_LEN,rep)!=QWK_BLOCK_LEN) {
sprintf(str,"%s.msg", cfg.sys_id);
errormsg(WHERE,ERR_READ,str,ftell(rep));
break;
}
sprintf(tmp,"%.6s",block+116);
i=atoi(tmp); /* i = number of blocks */
if(i<2) {
sprintf(str,"%s.msg blocks (read '%s' at offset %ld)", cfg.sys_id, tmp, l);
errormsg(WHERE,ERR_CHK,str,i);
i=1;
continue;
}
if(atoi(block+1)==0) { /**********/
if(useron.rest&FLAG('E')) { /* E-mail */
bputs(text[R_Email]); /**********/
continue;
}
sprintf(str,"%25.25s",block+21);
truncsp(str);
if(!stricmp(str,"NETMAIL")) { /* QWK to FidoNet NetMail */
qwktonetmail(rep,block,NULL,0);
continue;
}
if(strchr(str,'@')) {
qwktonetmail(rep,block,str,0);
continue;
}
if(!stricmp(str,"SBBS")) { /* to SBBS, config stuff */
qwkcfgline(block+71,INVALID_SUB);
continue;
}
if(useron.etoday>=cfg.level_emailperday[useron.level]
&& !(useron.rest&FLAG('Q'))) {
bputs(text[TooManyEmailsToday]);
continue;
}
j=atoi(str);
if(j && j>lastuser(&cfg))
j=0;
if(!j)
j=matchuser(&cfg,str,TRUE /* sysop_alias */);
if(!j) {
bputs(text[UnknownUser]);
continue;
}
if(j==1 && useron.rest&FLAG('S')) {
bprintf(text[R_Feedback],cfg.sys_op);
continue;
}
getuserrec(&cfg,j,U_MISC,8,str);
misc=ahtoul(str);
if(misc&NETMAIL && cfg.sys_misc&SM_FWDTONET) {
getuserrec(&cfg,j,U_NETMAIL,LEN_NETMAIL,str);
qwktonetmail(rep,block,str,0);
continue;
}
sprintf(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
if(lastsub!=INVALID_SUB) {
smb_close(&smb);
lastsub=INVALID_SUB;
}
smb.subnum=INVALID_SUB;
if((k=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error);
continue;
}
if(!filelength(fileno(smb.shd_fp))) {
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_msgs=0;
smb.status.max_age=cfg.mail_maxage;
smb.status.attr=SMB_EMAIL;
if((k=smb_create(&smb))!=0) {
smb_close(&smb);
errormsg(WHERE,ERR_CREATE,smb.file,k);
continue;
}
}
if((k=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
errormsg(WHERE,ERR_LOCK,smb.file,k);
continue;
}
if((k=smb_getstatus(&smb))!=0) {
smb_close(&smb);
errormsg(WHERE,ERR_READ,smb.file,k);
continue;
}
smb_unlocksmbhdr(&smb);
if(!qwktomsg(rep,block,0,INVALID_SUB,j)) {
smb_close(&smb);
continue;
}
smb_close(&smb);
if(j==1) {
useron.fbacks++;
logon_fbacks++;
putuserrec(&cfg,useron.number,U_FBACKS,5
,ultoa(useron.fbacks,tmp,10));
}
else {
useron.emails++;
logon_emails++;
putuserrec(&cfg,useron.number,U_EMAILS,5
,ultoa(useron.emails,tmp,10));
}
useron.etoday++;
putuserrec(&cfg,useron.number,U_ETODAY,5
,ultoa(useron.etoday,tmp,10));
bprintf(text[Emailed],username(&cfg,j,tmp),j);
sprintf(str,"%s sent e-mail to %s #%d"
,useron.alias,username(&cfg,j,tmp),j);
logline("E+",str);
if(useron.rest&FLAG('Q')) {
sprintf(tmp,"%-25.25s",block+46);
truncsp(tmp);
}
else
strcpy(tmp,useron.alias);
for(k=1;k<=cfg.sys_nodes;k++) { /* Tell user, if online */
getnodedat(k,&node,0);
if(node.useron==j && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE
|| node.status==NODE_QUIET)) {
sprintf(str,text[EmailNodeMsg]
,cfg.node_num,tmp);
putnmsg(&cfg,k,str);
break;
}
}
if(k>cfg.sys_nodes) {
sprintf(str,text[UserSentYouMail],tmp);
putsmsg(&cfg,j,str);
}
} /* end of email */
/**************************/
else { /* message on a sub-board */
/**************************/
n=atol((char *)block+1); /* conference number */
for(j=0;j<usrgrps;j++) {
for(k=0;k<usrsubs[j];k++)
if(cfg.sub[usrsub[j][k]]->qwkconf==n)
break;
if(k<usrsubs[j])
break;
}
if(j>=usrgrps) {
if(n<1000) { /* version 1 method, start at 101 */
j=n/100;
k=n-(j*100);
}
else { /* version 2 method, start at 1001 */
j=n/1000;
k=n-(j*1000);
}
j--; /* j is group */
k--; /* k is sub */
if(j>=usrgrps || k>=usrsubs[j] || cfg.sub[usrsub[j][k]]->qwkconf) {
bprintf(text[QWKInvalidConferenceN],n);
sprintf(str,"%s: Invalid conference number %lu",useron.alias,n);
logline("P!",str);
continue;
}
}
n=usrsub[j][k];
/* if posting, add to new-scan config for QWKnet nodes automatically */
if(useron.rest&FLAG('Q'))
subscan[n].cfg|=SUB_CFG_NSCAN;
sprintf(str,"%-25.25s","SBBS");
if(!strnicmp((char *)block+21,str,25)) { /* to SBBS, config stuff */
qwkcfgline((char *)block+71,n);
continue;
}
if(!SYSOP && cfg.sub[n]->misc&SUB_QNET) { /* QWK Netted */
sprintf(str,"%-25.25s","DROP"); /* Drop from new-scan? */
if(!strnicmp((char *)block+71,str,25)) /* don't allow post */
continue;
sprintf(str,"%-25.25s","ADD"); /* Add to new-scan? */
if(!strnicmp((char *)block+71,str,25)) /* don't allow post */
continue;
}
if(useron.rest&FLAG('Q') && !(cfg.sub[n]->misc&SUB_QNET)) {
bputs(text[CantPostOnSub]);
logline("P!","Attempted to post on non-QWKnet sub");
continue;
}
if(useron.rest&FLAG('P')) {
bputs(text[R_Post]);
logline("P!","Post attempted");
continue;
}
if(useron.ptoday>=cfg.level_postsperday[useron.level]
&& !(useron.rest&FLAG('Q'))) {
bputs(text[TooManyPostsToday]);
continue;
}
if(useron.rest&FLAG('N')
&& cfg.sub[n]->misc&(SUB_FIDO|SUB_PNET|SUB_QNET|SUB_INET)) {
bputs(text[CantPostOnSub]);
logline("P!","Networked post attempted");
continue;
}
if(!chk_ar(cfg.sub[n]->post_ar,&useron)) {
bputs(text[CantPostOnSub]);
logline("P!","Post attempted");
continue;
}
if((block[0]=='*' || block[0]=='+')
&& !(cfg.sub[n]->misc&SUB_PRIV)) {
bputs(text[PrivatePostsNotAllowed]);
logline("P!","Private post attempt");
continue;
}
if(block[0]=='*' || block[0]=='+' /* Private post */
|| cfg.sub[n]->misc&SUB_PONLY) {
sprintf(str,"%-25.25s",nulstr);
sprintf(tmp,"%-25.25s","ALL");
if(!strnicmp((char *)block+21,str,25)
|| !strnicmp((char *)block+21,tmp,25)) { /* to blank */
bputs(text[NoToUser]); /* or all */
continue;
}
}
if(!SYSOP && !(useron.rest&FLAG('Q'))) {
sprintf(str,"%-25.25s","SYSOP");
if(!strnicmp((char *)block+21,str,25)) {
sprintf(str,"%-25.25s",username(&cfg,1,tmp));
memcpy((char *)block+21,str,25); /* change from sysop */
} /* to user name */
}
/* TWIT FILTER */
if(twit_list) {
sprintf(fname,"%stwitlist.cfg",cfg.ctrl_dir);
sprintf(from,"%25.25s",block+46); /* From user */
truncsp(from);
sprintf(to,"%25.25s",block+21); /* To user */
truncsp(to);
if(findstr(from,fname) || findstr(to,fname)) {
sprintf(str,"Filtering post from %s to %s on %s %s"
,from
,to
,cfg.grp[cfg.sub[n]->grp]->sname,cfg.sub[n]->lname);
logline("P!",str);
continue;
}
}
if(n!=lastsub) {
if(lastsub!=INVALID_SUB)
smb_close(&smb);
lastsub=INVALID_SUB;
sprintf(smb.file,"%s%s",cfg.sub[n]->data_dir,cfg.sub[n]->code);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=n;
if((j=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,j,smb.last_error);
continue;
}
if(!filelength(fileno(smb.shd_fp))) {
smb.status.max_crcs=cfg.sub[n]->maxcrcs;
smb.status.max_msgs=cfg.sub[n]->maxmsgs;
smb.status.max_age=cfg.sub[n]->maxage;
smb.status.attr=cfg.sub[n]->misc&SUB_HYPER ? SMB_HYPERALLOC:0;
if((j=smb_create(&smb))!=0) {
smb_close(&smb);
lastsub=INVALID_SUB;
errormsg(WHERE,ERR_CREATE,smb.file,j);
continue;
}
}
if((j=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
lastsub=INVALID_SUB;
errormsg(WHERE,ERR_LOCK,smb.file,j);
continue;
}
if((j=smb_getstatus(&smb))!=0) {
smb_close(&smb);
lastsub=INVALID_SUB;
errormsg(WHERE,ERR_READ,smb.file,j);
continue;
}
smb_unlocksmbhdr(&smb);
lastsub=n;
}
if(!qwktomsg(rep,block,0,n,0))
continue;
logon_posts++;
user_posted_msg(&cfg, &useron, 1);
bprintf(text[Posted],cfg.grp[cfg.sub[n]->grp]->sname
,cfg.sub[n]->lname);
sprintf(str,"%s posted on %s %s"
,useron.alias,cfg.grp[cfg.sub[n]->grp]->sname,cfg.sub[n]->lname);
signal_sub_sem(&cfg,n);
logline("P+",str);
if(!(useron.rest&FLAG('Q')))
user_event(EVENT_POST);
} /* end of public message */
}
update_qwkroute(NULL); /* Write ROUTE.DAT */
if(lastsub!=INVALID_SUB)
smb_close(&smb);
fclose(rep);
if(useron.rest&FLAG('Q')) { /* QWK Net Node */
sprintf(str,"%s%s.msg",cfg.temp_dir,cfg.sys_id);
if(fexistcase(str))
remove(str);
sprintf(str,"%s%s.rep",cfg.temp_dir,cfg.sys_id);
if(fexistcase(str))
remove(str);
sprintf(str,"%sATTXREF.DAT",cfg.temp_dir);
if(fexistcase(str))
remove(str);
dir=opendir(cfg.temp_dir);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) { /* Extra files */
// Move files
sprintf(str,"%s%s",cfg.temp_dir,dirent->d_name);
if(isdir(str))
continue;
// Create directory if necessary
sprintf(inbox,"%sqnet/%s.in",cfg.data_dir,useron.alias);
MKDIR(inbox);
sprintf(fname,"%s/%s",inbox,dirent->d_name);
mv(str,fname,1);
sprintf(str,text[ReceivedFileViaQWK],dirent->d_name,useron.alias);
putsmsg(&cfg,1,str);
}
if(dir!=NULL)
closedir(dir);
sprintf(str,"%sqnet-rep.now",cfg.data_dir);
ftouch(str);
}
bputs(text[QWKUnpacked]);
CRLF;
/**********************************************/
/* Hang-up now if that's what the user wanted */
/**********************************************/
autohangup();
return(true);
}
