int sbbs_t::getuserxfers(int fromuser, int destuser, char *fname)
{
char str[256];
int file,found=0;
FILE *stream;
SAFEPRINTF(str,"%sxfer.ixt",cfg.data_dir);
if(!fexist(str))
return(0);
if(!flength(str)) {
remove(str);
return(0);
}
if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(0);
}
while(!ferror(stream)) {
if(!fgets(str,81,stream))
break;
str[22]=0;
if(fname!=NULL && fname[0] && !strncmp(str+5,fname,12))
found++;
else if(fromuser && atoi(str+18)==fromuser)
found++;
else if(destuser && atoi(str)==destuser)
found++;
}
fclose(stream);
return(found);
}
bool sbbs_t::lookup_netuser(char *into)
{
char to[128],name[26],str[256],q[128];
int i;
FILE *stream;
if(strchr(into,'@'))
return(false);
strcpy(to,into);
strupr(to);
sprintf(str,"%sqnet/users.dat", cfg.data_dir);
if((stream=fnopen(&i,str,O_RDONLY))==NULL)
return(false);
while(!feof(stream)) {
if(!fgets(str,sizeof(str),stream))
break;
str[25]=0;
truncsp(str);
strcpy(name,str);
strupr(name);
str[35]=0;
truncsp(str+27);
sprintf(q,"Do you mean %s @%s",str,str+27);
if(strstr(name,to) && yesno(q)) {
fclose(stream);
sprintf(into,"%s@%s",str,str+27);
return(true);
}
if(sys_status&SS_ABORT)
break;
}
fclose(stream);
return(false);
}
BOOL read_attr_cfg(scfg_t* cfg, char* error)
{
char* p;
char str[256],fname[13];
long offset=0;
FILE *instream;
strcpy(fname,"attr.cfg");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d opening %s",errno,str);
return(FALSE);
}
FREE_AND_NULL(cfg->color);
if((cfg->color=malloc(MIN_COLORS))==NULL) {
sprintf(error,"Error allocating memory (%u bytes) for colors"
,MIN_COLORS);
return(FALSE);
}
memset(cfg->color,LIGHTGRAY|HIGH,MIN_COLORS);
for(cfg->total_colors=0;!feof(instream) && !ferror(instream);cfg->total_colors++) {
if(readline(&offset,str,4,instream)==NULL)
break;
if(cfg->total_colors>=MIN_COLORS) {
if((p=realloc(cfg->color,cfg->total_colors+1))==NULL)
break;
cfg->color=p;
}
cfg->color[cfg->total_colors]=attrstr(str);
}
fclose(instream);
if(cfg->total_colors<MIN_COLORS)
cfg->total_colors=MIN_COLORS;
return(TRUE);
}
extern "C" int DLLCALL errorlog(scfg_t* cfg, const char* host, const char* text)
{
FILE* fp;
char buf[128];
char path[MAX_PATH+1];
sprintf(path,"%serror.log",cfg->logs_dir);
if((fp=fnopen(NULL,path,O_WRONLY|O_CREAT|O_APPEND))==NULL)
return -1;
fprintf(fp,"%s %s\r\n%s\r\n\r\n", timestr(cfg,time32(NULL),buf), host==NULL ? "":host, text);
fclose(fp);
return 0;
}
extern "C" BOOL DLLCALL getmsgptrs(scfg_t* cfg, uint usernumber, subscan_t* subscan)
{
char str[256];
uint i;
int file;
long length;
FILE* stream;
/* Initialize to configured defaults */
for(i=0;i<cfg->total_subs;i++) {
subscan[i].ptr=subscan[i].sav_ptr=0;
subscan[i].last=subscan[i].sav_last=0;
subscan[i].cfg=0xff;
if(!(cfg->sub[i]->misc&SUB_NSDEF))
subscan[i].cfg&=~SUB_CFG_NSCAN;
if(!(cfg->sub[i]->misc&SUB_SSDEF))
subscan[i].cfg&=~SUB_CFG_SSCAN;
subscan[i].sav_cfg=subscan[i].cfg;
}
if(!usernumber)
return(FALSE);
sprintf(str,"%suser/ptrs/%4.4u.ixb", cfg->data_dir,usernumber);
if((stream=fnopen(&file,str,O_RDONLY))==NULL)
return(TRUE);
length=(long)filelength(file);
for(i=0;i<cfg->total_subs;i++) {
if(length>=(cfg->sub[i]->ptridx+1)*10L) {
fseek(stream,(long)cfg->sub[i]->ptridx*10L,SEEK_SET);
fread(&subscan[i].ptr,sizeof(subscan[i].ptr),1,stream);
fread(&subscan[i].last,sizeof(subscan[i].last),1,stream);
fread(&subscan[i].cfg,sizeof(subscan[i].cfg),1,stream);
}
subscan[i].sav_ptr=subscan[i].ptr;
subscan[i].sav_last=subscan[i].last;
subscan[i].sav_cfg=subscan[i].cfg;
}
fclose(stream);
return(TRUE);
}
void sbbs_t::msgtotxt(smbmsg_t* msg, char *str, int header, int tails)
{
char *buf;
char tmp[128];
int i;
FILE *out;
if((out=fnopen(&i,str,O_WRONLY|O_CREAT|O_APPEND))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return;
}
if(header) {
fprintf(out,"\r\n");
fprintf(out,"Subj : %s\r\n",msg->subj);
fprintf(out,"To : %s",msg->to);
if(msg->to_ext)
fprintf(out," #%s",msg->to_ext);
if(msg->to_net.addr)
fprintf(out," (%s)",smb_netaddrstr(&msg->to_net,tmp));
fprintf(out,"\r\nFrom : %s",msg->from);
if(msg->from_ext && !(msg->hdr.attr&MSG_ANONYMOUS))
fprintf(out," #%s",msg->from_ext);
if(msg->from_net.addr)
fprintf(out," (%s)",smb_netaddrstr(&msg->from_net,tmp));
fprintf(out,"\r\nDate : %.24s %s"
,timestr(msg->hdr.when_written.time)
,smb_zonestr(msg->hdr.when_written.zone,NULL));
fprintf(out,"\r\n\r\n");
}
buf=smb_getmsgtxt(&smb,msg,tails);
if(buf!=NULL) {
strip_invalid_attr(buf);
fputs(buf,out);
smb_freemsgtxt(buf);
} else if(smb_getmsgdatlen(msg)>2)
errormsg(WHERE,ERR_READ,smb.file,smb_getmsgdatlen(msg));
fclose(out);
}
bool sbbs_t::pack_rep(uint hubnum)
{
char str[MAX_PATH+1];
char tmp[MAX_PATH+1],tmp2[MAX_PATH+1];
char hubid_upper[LEN_QWKID+1];
char hubid_lower[LEN_QWKID+1];
int file,mode;
uint i,j,k;
long msgcnt,submsgs,packedmail,netfiles=0,deleted;
uint32_t u;
uint32_t posts;
uint32_t mailmsgs;
ulong msgs;
uint32_t last;
post_t* post;
mail_t* mail;
FILE* rep;
FILE* hdrs=NULL;
DIR* dir;
DIRENT* dirent;
smbmsg_t msg;
msgcnt=0L;
delfiles(cfg.temp_dir,ALLFILES);
SAFECOPY(hubid_upper,cfg.qhub[hubnum]->id);
strupr(hubid_upper);
SAFECOPY(hubid_lower,cfg.qhub[hubnum]->id);
strlwr(hubid_lower);
SAFEPRINTF2(str,"%s%s.REP",cfg.data_dir,hubid_upper);
if(fexistcase(str)) {
eprintf(LOG_INFO,"Updating %s", str);
external(cmdstr(cfg.qhub[hubnum]->unpack,str,ALLFILES,NULL),EX_OFFLINE);
} else
eprintf(LOG_INFO,"Creating %s", str);
/*************************************************/
/* Create SYSID.MSG, write header and leave open */
/*************************************************/
SAFEPRINTF2(str,"%s%s.MSG",cfg.temp_dir,hubid_upper);
fexistcase(str);
if((rep=fnopen(&file,str,O_CREAT|O_WRONLY|O_TRUNC))==NULL) {
errormsg(WHERE,ERR_CREATE,str,O_CREAT|O_WRONLY|O_TRUNC);
return(false);
}
if(filelength(file)<1) { /* New REP packet */
SAFEPRINTF2(str,"%-*s"
,QWK_BLOCK_LEN,hubid_upper); /* So write header */
fwrite(str,QWK_BLOCK_LEN,1,rep);
}
fseek(rep,0L,SEEK_END);
/* Always includes HEADERS.DAT in .REP packets which are only for QWKnet hubs */
/* And *usually* a Synchronet system */
SAFEPRINTF(str,"%sHEADERS.DAT",cfg.temp_dir);
fexistcase(str);
if((hdrs=fopen(str,"a"))==NULL)
errormsg(WHERE,ERR_CREATE,str,0);
/*********************/
/* Pack new messages */
/*********************/
SAFEPRINTF(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
fclose(rep);
if(hdrs!=NULL)
fclose(hdrs);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
/***********************/
/* Pack E-mail, if any */
/***********************/
qwkmail_last=0;
mail=loadmail(&smb,&mailmsgs,0,MAIL_YOUR,0);
packedmail=0;
if(mailmsgs) {
eprintf(LOG_INFO,"Packing NetMail for %s", cfg.qhub[hubnum]->id);
for(u=0;u<mailmsgs;u++) {
// bprintf("\b\b\b\b\b%-5lu",u+1);
memset(&msg,0,sizeof(msg));
msg.idx=mail[u];
if(msg.idx.number>qwkmail_last)
qwkmail_last=msg.idx.number;
if(!loadmsg(&msg,mail[u].number))
continue;
SAFEPRINTF(str,"%s/",cfg.qhub[hubnum]->id);
if(msg.to_net.type!=NET_QWK
|| (strcmp((char *)msg.to_net.addr,cfg.qhub[hubnum]->id)
&& strncmp((char *)msg.to_net.addr,str,strlen(str)))) {
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
continue;
}
msgtoqwk(&msg,rep,QM_TO_QNET|QM_REP|A_LEAVE,INVALID_SUB,0,hdrs);
packedmail++;
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
YIELD(); /* yield */
}
eprintf(LOG_INFO,"Packed %d NetMail messages",packedmail);
}
smb_close(&smb); /* Close the e-mail */
if(mailmsgs)
free(mail);
for(i=0;i<cfg.qhub[hubnum]->subs;i++) {
j=cfg.qhub[hubnum]->sub[i]; /* j now equals the real sub num */
msgs=getlastmsg(j,&last,0);
lncntr=0; /* defeat pause */
if(!msgs || last<=subscan[j].ptr) {
if(subscan[j].ptr>last) {
subscan[j].ptr=last;
subscan[j].last=last;
}
eprintf(LOG_INFO,remove_ctrl_a(text[NScanStatusFmt],tmp)
,cfg.grp[cfg.sub[j]->grp]->sname
,cfg.sub[j]->lname,0L,msgs);
continue;
}
SAFEPRINTF2(smb.file,"%s%s"
,cfg.sub[j]->data_dir,cfg.sub[j]->code);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=j;
if((k=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error);
continue;
}
post=loadposts(&posts,j,subscan[j].ptr,LP_BYSELF|LP_OTHERS|LP_PRIVATE|LP_REP,NULL);
eprintf(LOG_INFO,remove_ctrl_a(text[NScanStatusFmt],tmp)
,cfg.grp[cfg.sub[j]->grp]->sname
,cfg.sub[j]->lname,posts,msgs);
if(!posts) { /* no new messages */
smb_close(&smb);
continue;
}
subscan[j].ptr=last; /* set pointer */
eprintf(LOG_INFO,"%s",remove_ctrl_a(text[QWKPackingSubboard],tmp)); /* ptr to last msg */
submsgs=0;
for(u=0;u<posts;u++) {
// bprintf("\b\b\b\b\b%-5lu",u+1);
memset(&msg,0,sizeof(msg));
msg.idx=post[u];
if(!loadmsg(&msg,post[u].number))
continue;
if(msg.from_net.type && msg.from_net.type!=NET_QWK &&
!(cfg.sub[j]->misc&SUB_GATE)) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
continue;
}
if(!strnicmp(msg.subj,"NE:",3) || (msg.from_net.type==NET_QWK &&
route_circ((char *)msg.from_net.addr,cfg.qhub[hubnum]->id))) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
continue;
}
mode=cfg.qhub[hubnum]->mode[i]|QM_TO_QNET|QM_REP;
if(mode&A_LEAVE) mode|=(QM_VIA|QM_TZ|QM_MSGID);
if(msg.from_net.type!=NET_QWK)
mode|=QM_TAGLINE;
msgtoqwk(&msg,rep,mode,j,cfg.qhub[hubnum]->conf[i],hdrs);
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
msgcnt++;
submsgs++;
if(!(u%50))
YIELD(); /* yield */
}
eprintf(LOG_INFO,remove_ctrl_a(text[QWKPackedSubboard],tmp),submsgs,msgcnt);
free(post);
smb_close(&smb);
YIELD(); /* yield */
}
if(hdrs!=NULL)
fclose(hdrs);
fclose(rep); /* close HUB_ID.MSG */
CRLF;
/* Look for extra files to send out */
SAFEPRINTF2(str,"%sqnet/%s.out",cfg.data_dir,hubid_lower);
dir=opendir(str);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
SAFEPRINTF3(str,"%sqnet/%s.out/%s",cfg.data_dir,hubid_lower,dirent->d_name);
if(isdir(str))
continue;
SAFEPRINTF2(tmp2,"%s%s",cfg.temp_dir,dirent->d_name);
eprintf(LOG_INFO,remove_ctrl_a(text[RetrievingFile],tmp),str);
if(!mv(str,tmp2,/* copy: */TRUE))
netfiles++;
}
if(dir!=NULL)
closedir(dir);
if(netfiles)
CRLF;
if(!msgcnt && !netfiles && !packedmail) {
eprintf(LOG_INFO,remove_ctrl_a(text[QWKNoNewMessages],tmp));
return(true); // Changed from false Mar-11-2005 (needs to be true to save updated ptrs)
}
/*******************/
/* Compress Packet */
/*******************/
SAFEPRINTF2(str,"%s%s.REP",cfg.data_dir,hubid_upper);
SAFEPRINTF2(tmp2,"%s%s",cfg.temp_dir,ALLFILES);
i=external(cmdstr(cfg.qhub[hubnum]->pack,str,tmp2,NULL)
,EX_OFFLINE|EX_WILDCARD);
if(!fexistcase(str)) {
eprintf(LOG_WARNING,"%s",remove_ctrl_a(text[QWKCompressionFailed],tmp));
if(i)
errormsg(WHERE,ERR_EXEC,cmdstr(cfg.qhub[hubnum]->pack,str,tmp2,NULL),i);
else
lprintf(LOG_ERR, "Couldn't compress REP packet");
return(false);
}
SAFEPRINTF2(str,"%sqnet/%s.out/",cfg.data_dir,hubid_lower);
delfiles(str,ALLFILES);
if(packedmail) { /* Delete NetMail */
SAFEPRINTF(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(true);
}
mail=loadmail(&smb,&mailmsgs,0,MAIL_YOUR,0);
if((i=smb_locksmbhdr(&smb))!=0) { /* Lock the base, so nobody */
if(mailmsgs)
free(mail);
smb_close(&smb);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error); /* messes with the index */
return(true);
}
if((i=smb_getstatus(&smb))!=0) {
if(mailmsgs)
free(mail);
smb_close(&smb);
errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
return(true);
}
deleted=0;
/* Mark as READ and DELETE */
for(u=0;u<mailmsgs;u++) {
if(mail[u].number>qwkmail_last)
continue;
memset(&msg,0,sizeof(msg));
/* !IMPORTANT: search by number (do not initialize msg.idx.offset) */
if(!loadmsg(&msg,mail[u].number))
continue;
SAFEPRINTF(str,"%s/",cfg.qhub[hubnum]->id);
if(msg.to_net.type!=NET_QWK
|| (strcmp((char *)msg.to_net.addr,cfg.qhub[hubnum]->id)
&& strncmp((char *)msg.to_net.addr,str,strlen(str)))) {
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
continue;
}
msg.hdr.attr|=MSG_DELETE;
msg.idx.attr=msg.hdr.attr;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
else
deleted++;
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
}
if(deleted && cfg.sys_misc&SM_DELEMAIL)
delmail(0,MAIL_YOUR);
smb_close(&smb);
if(mailmsgs)
free(mail);
eprintf(LOG_INFO,"Deleted %d sent NetMail messages",deleted);
}
return(true);
}
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);
}
static int receive_files(char** fname_list, int fnames)
{
char str[MAX_PATH+1];
char fname[MAX_PATH+1];
int i;
int fnum=0;
uint errors;
uint total_files=0;
uint cps;
uint wr;
BOOL success=FALSE;
long fmode;
long serial_num=-1;
ulong file_bytes=0,file_bytes_left=0;
ulong total_bytes=0;
FILE* fp;
time_t t,startfile,ftime;
if(fnames>1)
lprintf(LOG_INFO,"Receiving %u files",fnames);
outbuf.highwater_mark=0; /* don't delay ACK/NAK transmits */
/* Purge input buffer */
while(is_connected(NULL) && (i=recv_byte(NULL,0))!=NOINP)
lprintf(LOG_WARNING,"Throwing out received: %s",chr((uchar)i));
while(is_connected(NULL)) {
if(mode&XMODEM) {
SAFECOPY(str,fname_list[0]); /* we'll have at least one fname */
file_bytes=file_bytes_left=0x7fffffff;
}
else {
if(mode&YMODEM) {
lprintf(LOG_INFO,"Fetching Ymodem header block");
for(errors=0;errors<=xm.max_errors && !xm.cancelled;errors++) {
if(errors>(xm.max_errors/2) && mode&CRC && !(mode&GMODE))
mode&=~CRC;
xmodem_put_nak(&xm, /* expected_block: */ 0);
if(xmodem_get_block(&xm, block, /* expected_block: */ 0) == 0) {
send_byte(NULL,ACK,10);
break;
}
}
if(errors>=xm.max_errors || xm.cancelled) {
lprintf(LOG_ERR,"Error fetching Ymodem header block");
xmodem_cancel(&xm);
return(1);
}
if(!block[0]) {
lprintf(LOG_INFO,"Received Ymodem termination block");
return(0);
}
file_bytes=ftime=total_files=total_bytes=0;
i=sscanf(block+strlen(block)+1,"%ld %lo %lo %lo %d %ld"
,&file_bytes /* file size (decimal) */
,&ftime /* file time (octal unix format) */
,&fmode /* file mode (not used) */
,&serial_num /* program serial number */
,&total_files /* remaining files to be sent */
,&total_bytes /* remaining bytes to be sent */
);
lprintf(LOG_DEBUG,"Ymodem header (%u fields): %s", i, block+strlen(block)+1);
SAFECOPY(fname,block);
} else { /* Zmodem */
lprintf(LOG_INFO,"Waiting for Zmodem sender...");
i=zmodem_recv_init(&zm);
if(zm.cancelled)
return(1);
if(i<0)
return(-1);
switch(i) {
case ZFILE:
SAFECOPY(fname,zm.current_file_name);
file_bytes = zm.current_file_size;
ftime = zm.current_file_time;
total_files = zm.files_remaining;
total_bytes = zm.bytes_remaining;
break;
case ZFIN:
case ZCOMPL:
return(!success);
default:
return(-1);
}
}
if(!file_bytes)
file_bytes=0x7fffffff;
file_bytes_left=file_bytes;
if(!total_files)
total_files=fnames-fnum;
if(!total_files)
total_files=1;
if(total_bytes<file_bytes)
total_bytes=file_bytes;
lprintf(LOG_DEBUG,"Incoming filename: %.64s ",fname);
if(mode&RECVDIR)
sprintf(str,"%s%s",fname_list[0],getfname(fname));
else {
SAFECOPY(str,getfname(fname));
for(i=0;i<fnames;i++) {
if(!fname_list[i][0]) /* name blank or already used */
continue;
if(!stricmp(getfname(fname_list[i]),str)) {
SAFECOPY(str,fname_list[i]);
fname_list[i][0]=0;
break;
}
}
if(i==fnames) { /* Not found in list */
if(fnames)
fprintf(statfp," - Not in receive list!");
if(!fnames || fnum>=fnames || !fname_list[fnum][0])
SAFECOPY(str,getfname(fname)); /* worst case */
else {
SAFECOPY(str,fname_list[fnum]);
fname_list[fnum][0]=0;
}
}
}
fprintf(statfp,"File size: %lu bytes\n", file_bytes);
if(total_files>1)
fprintf(statfp,"Remaining: %lu bytes in %u files\n", total_bytes, total_files);
}
lprintf(LOG_DEBUG,"Receiving: %.64s ",str);
fnum++;
if(!(mode&RECVDIR) && fnames && fnum>fnames) {
lprintf(LOG_WARNING,"Attempt to send more files than specified");
xmodem_cancel(&xm);
break;
}
if(fexistcase(str) && !(mode&OVERWRITE)) {
lprintf(LOG_WARNING,"%s already exists",str);
if(mode&ZMODEM) {
zmodem_send_zskip(&zm);
continue;
}
xmodem_cancel(&xm);
return(1);
}
if((fp=fnopen(NULL,str,O_WRONLY|O_CREAT|O_TRUNC|O_BINARY))==NULL
&& (fp=fopen(str,"wb"))==NULL) {
lprintf(LOG_ERR,"Error %d creating %s",errno,str);
if(mode&ZMODEM) {
zmodem_send_zskip(&zm);
continue;
}
xmodem_cancel(&xm);
return(1);
}
if(mode&XMODEM)
lprintf(LOG_INFO,"Receiving %s via Xmodem %s"
,str
,mode&CRC ? "CRC-16":"Checksum");
else
lprintf(LOG_INFO,"Receiving %s (%lu KB) via %s %s"
,str
,file_bytes/1024
,mode&YMODEM ? mode&GMODE ? "Ymodem-G" : "Ymodem" :"Zmodem"
,mode&ZMODEM ? "" : (mode&CRC ? "CRC-16" : "Checksum"));
startfile=time(NULL);
success=FALSE;
if(mode&ZMODEM) {
errors=zmodem_recv_file_data(&zm,fp,0);
/*
* wait for the eof header
*/
for(;errors<=zm.max_errors && !success && !zm.cancelled; errors++) {
if(zmodem_recv_header_and_check(&zm))
success=TRUE;
}
} else {
errors=0;
block_num=1;
xmodem_put_nak(&xm, block_num);
while(is_connected(NULL)) {
xmodem_progress(NULL,block_num,ftell(fp),file_bytes,startfile);
i=xmodem_get_block(&xm, block, block_num);
if(i!=0) {
if(i==EOT) { /* end of transfer */
success=TRUE;
xmodem_put_ack(&xm);
break;
}
if(i==CAN) { /* Cancel */
xm.cancelled=TRUE;
break;
}
if(mode&GMODE)
return(-1);
if(++errors>=xm.max_errors) {
lprintf(LOG_ERR,"Too many errors (%u)",errors);
xmodem_cancel(&xm);
break;
}
if(block_num==1 && errors>(xm.max_errors/2) && mode&CRC && !(mode&GMODE))
mode&=~CRC;
xmodem_put_nak(&xm, block_num);
continue;
}
if(!(mode&GMODE))
send_byte(NULL,ACK,10);
if(file_bytes_left<=0L) { /* No more bytes to send */
lprintf(LOG_WARNING,"Attempt to send more byte specified in header");
break;
}
wr=xm.block_size;
if(wr>file_bytes_left)
wr=file_bytes_left;
if(fwrite(block,1,wr,fp)!=wr) {
lprintf(LOG_ERR,"Error writing %u bytes to file at offset %lu"
,wr,ftell(fp));
xmodem_cancel(&xm);
return(1);
}
file_bytes_left-=wr;
block_num++;
}
}
/* Use correct file size */
fflush(fp);
if(file_bytes < (ulong)filelength(fileno(fp))) {
lprintf(LOG_INFO,"Truncating file to %lu bytes", file_bytes);
chsize(fileno(fp),file_bytes);
} else
file_bytes = filelength(fileno(fp));
fclose(fp);
t=time(NULL)-startfile;
if(!t) t=1;
if(success)
lprintf(LOG_INFO,"Successful - Time: %lu:%02lu CPS: %lu"
,t/60,t%60,file_bytes/t);
else
lprintf(LOG_ERR,"File Transfer %s", aborted ? "Aborted":"Failure");
if(!(mode&XMODEM) && ftime)
setfdate(str,ftime);
if(logfp) {
lprintf(LOG_DEBUG,"Updating DSZLOG: %s", dszlog);
fprintf(logfp,"%c %6lu %5u bps %4lu cps %3u errors %5u %4u "
"%s %d\n"
,success ? (mode&ZMODEM ? 'Z' : 'R') : 'E'
,file_bytes
,115200 /* baud */
,file_bytes/t
,errors
,flows
,mode&ZMODEM ? zm.block_size : xm.block_size
,dszlog_filename(str)
,serial_num);
fflush(logfp);
}
if(aborted) {
lprintf(LOG_DEBUG,"Locally aborted, sending cancel to remote");
if(mode&ZMODEM)
zmodem_abort_receive(&zm);
xm.cancelled=FALSE;
xmodem_cancel(&xm);
break;
}
if(mode&XMODEM) /* maximum of one file */
break;
if((cps=file_bytes/t)==0)
cps=1;
total_files--;
total_bytes-=file_bytes;
if(total_files>1 && total_bytes)
lprintf(LOG_INFO,"Remaining - Time: %lu:%02lu Files: %u KBytes: %lu"
,(total_bytes/cps)/60
,(total_bytes/cps)%60
,total_files
,total_bytes/1024
);
}
return(!success); /* 0=success */
}
int sbbs_t::exec(csi_t *csi)
{
char str[256],*path;
char tmp[512];
uchar buf[1025],ch;
int i,j,file;
long l;
FILE *stream;
if(usrgrps)
cursubnum=usrsub[curgrp][cursub[curgrp]]; /* Used for ARS */
else
cursubnum=INVALID_SUB;
if(usrlibs) {
curdirnum=usrdir[curlib][curdir[curlib]]; /* Used for ARS */
path=cfg.dir[usrdir[curlib][curdir[curlib]]]->path;
}
else {
curdirnum=INVALID_DIR;
path=nulstr;
}
now=time(NULL);
if(csi->ip>=csi->cs+csi->length)
return(1);
if(*csi->ip>=CS_FUNCTIONS)
return(exec_function(csi));
/**********************************************/
/* Miscellaneous variable length instructions */
/**********************************************/
if(*csi->ip>=CS_MISC)
return(exec_misc(csi,path));
/********************************/
/* ASCIIZ argument instructions */
/********************************/
if(*csi->ip>=CS_ASCIIZ) {
switch(*(csi->ip++)) {
case CS_STR_FUNCTION:
switch(*(csi->ip++)) {
case CS_LOGIN:
csi->logic=login(csi->str,(char*)csi->ip);
break;
case CS_LOAD_TEXT:
csi->logic=LOGIC_FALSE;
for(i=0;i<TOTAL_TEXT;i++)
if(text[i]!=text_sav[i]) {
if(text[i]!=nulstr)
free(text[i]);
text[i]=text_sav[i];
}
SAFEPRINTF2(str,"%s%s.dat"
,cfg.ctrl_dir,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
break;
}
for(i=0;i<TOTAL_TEXT && !feof(stream);i++) {
if((text[i]=readtext((long *)NULL,stream,i))==NULL) {
i--;
continue;
}
if(!strcmp(text[i],text_sav[i])) { /* If identical */
free(text[i]); /* Don't alloc */
text[i]=text_sav[i];
}
else if(text[i][0]==0) {
free(text[i]);
text[i]=nulstr;
}
}
if(i<TOTAL_TEXT) {
fclose(stream);
errormsg(WHERE,ERR_READ,str,TOTAL_TEXT);
break;
}
fclose(stream);
csi->logic=LOGIC_TRUE;
break;
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
break;
}
while(*(csi->ip++)); /* Find NULL */
return(0);
case CS_LOG:
log(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_GETCMD:
csi->cmd=(uchar)getkeys((char*)csi->ip,0);
if((char)csi->cmd==-1)
csi->cmd=3;
break;
case CS_CMDSTR:
if(stricmp(csi->str,(char*)csi->ip)) {
while(*(csi->ip++)); /* Find NULL */
skipto(csi,CS_END_CMD);
csi->ip++;
return(0);
}
break;
case CS_CMDKEYS:
for(i=0;csi->ip[i];i++)
if(csi->cmd==csi->ip[i])
break;
if(!csi->ip[i]) {
while(*(csi->ip++)); /* Find NULL */
skipto(csi,CS_END_CMD);
csi->ip++;
return(0);
}
break;
case CS_GET_TEMPLATE:
gettmplt(csi->str,(char*)csi->ip,K_LINE);
if(sys_status&SS_ABORT)
csi->str[0]=0;
csi->cmd=csi->str[0];
break;
case CS_TRASHCAN:
csi->logic=!trashcan(csi->str,(char*)csi->ip);
break;
case CS_CREATE_SIF:
create_sif_dat((char*)csi->ip,csi->str);
break;
case CS_READ_SIF:
read_sif_dat((char*)csi->ip,csi->str);
break;
case CS_MNEMONICS:
mnemonics((char*)csi->ip);
break;
case CS_PRINT:
putmsg(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR|P_NOABORT);
break;
case CS_PRINT_LOCAL:
if(online==ON_LOCAL)
eprintf(LOG_INFO,"%s",cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
else
lputs(LOG_INFO,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_PRINT_REMOTE:
putcom(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_PRINTFILE:
printfile(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR);
break;
case CS_PRINTFILE_REMOTE:
if(online!=ON_REMOTE || !(console&CON_R_ECHO))
break;
console&=~CON_L_ECHO;
printfile(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR);
console|=CON_L_ECHO;
break;
case CS_PRINTFILE_LOCAL:
if(!(console&CON_L_ECHO))
break;
console&=~CON_R_ECHO;
printfile(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR);
console|=CON_R_ECHO;
break;
case CS_CHKFILE:
csi->logic=!fexistcase(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_EXEC:
external(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),0);
break;
case CS_EXEC_INT:
external(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),EX_STDIO);
break;
case CS_EXEC_XTRN:
for(i=0;i<cfg.total_xtrns;i++)
if(!stricmp(cfg.xtrn[i]->code,(char*)csi->ip))
break;
if(i<cfg.total_xtrns)
exec_xtrn(i);
break;
case CS_EXEC_BIN:
exec_bin(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),csi,/* startup_dir: */NULL);
break;
case CS_YES_NO:
csi->logic=!yesno(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_NO_YES:
csi->logic=!noyes(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_MENU:
menu(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_SETSTR:
strcpy(csi->str,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_SET_MENU_DIR:
cmdstr((char*)csi->ip,path,csi->str,menu_dir);
break;
case CS_SET_MENU_FILE:
cmdstr((char*)csi->ip,path,csi->str,menu_file);
break;
case CS_COMPARE_STR:
csi->logic=stricmp(csi->str,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_COMPARE_KEYS:
for(i=0;csi->ip[i];i++)
if(csi->cmd==csi->ip[i])
break;
if(csi->ip[i])
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
break;
case CS_COMPARE_WORD:
csi->logic=strnicmp(csi->str,(char*)csi->ip,strlen((char*)csi->ip));
break;
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
break;
}
while(*(csi->ip++)); /* Find NULL */
return(0);
}
if(*csi->ip>=CS_THREE_BYTE) {
switch(*(csi->ip++)) {
case CS_THREE_MORE_BYTES:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
case CS_GOTO:
csi->ip=csi->cs+*((ushort *)(csi->ip));
return(0);
case CS_CALL:
if(csi->rets<MAX_RETS) {
csi->ret[csi->rets++]=csi->ip+2;
csi->ip=csi->cs+*((ushort *)(csi->ip));
}
return(0);
case CS_MSWAIT:
mswait(*(ushort *)csi->ip);
csi->ip+=2;
return(0);
case CS_TOGGLE_NODE_MISC:
if(getnodedat(cfg.node_num,&thisnode,true)==0) {
thisnode.misc^=*(ushort *)csi->ip;
putnodedat(cfg.node_num,&thisnode);
}
csi->ip+=2;
return(0);
case CS_COMPARE_NODE_MISC:
getnodedat(cfg.node_num,&thisnode,0);
if((thisnode.misc&*(ushort *)csi->ip)==*(ushort *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=2;
return(0);
case CS_ADJUST_USER_CREDITS:
i=*(short *)csi->ip;
l=i*1024L;
if(l<0)
subtract_cdt(&cfg,&useron,-l);
else
useron.cdt=adjustuserrec(&cfg,useron.number,U_CDT,10,l);
csi->ip+=2;
return(0);
case CS_ADJUST_USER_MINUTES:
i=*(short *)csi->ip;
useron.min=adjustuserrec(&cfg,useron.number,U_MIN,10,i);
csi->ip+=2;
return(0);
case CS_GETNUM:
i=*(short *)csi->ip;
csi->ip+=2;
l=getnum(i);
if(l<=0) {
csi->str[0]=0;
csi->logic=LOGIC_FALSE;
}
else {
sprintf(csi->str,"%lu",l);
csi->logic=LOGIC_TRUE;
}
return(0);
case CS_TOGGLE_USER_FLAG:
i=*(csi->ip++);
ch=*(csi->ip++);
switch(i) {
case '1':
useron.flags1^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS1,8
,ultoa(useron.flags1,tmp,16));
break;
case '2':
useron.flags2^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS2,8
,ultoa(useron.flags2,tmp,16));
break;
case '3':
useron.flags3^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS3,8
,ultoa(useron.flags3,tmp,16));
break;
case '4':
useron.flags4^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS4,8
,ultoa(useron.flags4,tmp,16));
break;
case 'R':
useron.rest^=FLAG(ch);
putuserrec(&cfg,useron.number,U_REST,8
,ultoa(useron.rest,tmp,16));
break;
case 'E':
useron.exempt^=FLAG(ch);
putuserrec(&cfg,useron.number,U_EXEMPT,8
,ultoa(useron.exempt,tmp,16));
break;
default:
errormsg(WHERE,ERR_CHK,"user flag type",*(csi->ip-2));
return(0);
}
return(0);
case CS_REVERT_TEXT:
i=*(ushort *)csi->ip;
csi->ip+=2;
if((ushort)i==0xffff) {
for(i=0;i<TOTAL_TEXT;i++) {
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
text[i]=text_sav[i];
}
return(0);
}
i--;
if(i>=TOTAL_TEXT) {
errormsg(WHERE,ERR_CHK,"revert text #",i);
return(0);
}
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
text[i]=text_sav[i];
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
}
}
if(*csi->ip>=CS_TWO_BYTE) {
switch(*(csi->ip++)) {
case CS_TWO_MORE_BYTES:
switch(*(csi->ip++)) {
case CS_USER_EVENT:
user_event((user_event_t)*(csi->ip++));
return(0);
}
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
case CS_SETLOGIC:
csi->logic=*csi->ip++;
return(0);
case CS_CMDKEY:
if( ((*csi->ip)==CS_DIGIT && isdigit(csi->cmd))
|| ((*csi->ip)==CS_EDIGIT && csi->cmd&0x80
&& isdigit(csi->cmd&0x7f))) {
csi->ip++;
return(0);
}
if(csi->cmd!=*csi->ip) {
csi->ip++;
skipto(csi,CS_END_CMD); /* skip code */
}
csi->ip++; /* skip key */
return(0);
case CS_CMDCHAR:
if(csi->cmd!=*csi->ip) {
csi->ip++;
skipto(csi,CS_END_CMD); /* skip code */
}
csi->ip++; /* skip key */
return(0);
case CS_NODE_ACTION:
action=*csi->ip++;
return(0);
case CS_NODE_STATUS:
if(getnodedat(cfg.node_num,&thisnode,true)==0) {
thisnode.status=*csi->ip++;
putnodedat(cfg.node_num,&thisnode);
} else
csi->ip++;
return(0);
case CS_MULTINODE_CHAT:
multinodechat(*csi->ip++);
return(0);
case CS_GETSTR:
csi->logic=LOGIC_TRUE;
getstr(csi->str,*csi->ip++,0);
if(sys_status&SS_ABORT) {
csi->str[0]=0;
csi->logic=LOGIC_FALSE;
}
if(csi->str[0]=='/' && csi->str[1])
csi->cmd=csi->str[1]|0x80;
else
csi->cmd=csi->str[0];
return(0);
case CS_GETLINE:
getstr(csi->str,*csi->ip++,K_LINE);
if(sys_status&SS_ABORT)
csi->str[0]=0;
if(csi->str[0]=='/' && csi->str[1])
csi->cmd=csi->str[1]|0x80;
else
csi->cmd=csi->str[0];
return(0);
case CS_GETSTRUPR:
getstr(csi->str,*csi->ip++,K_UPPER);
if(sys_status&SS_ABORT)
csi->str[0]=0;
if(csi->str[0]=='/' && csi->str[1])
csi->cmd=csi->str[1]|0x80;
else
csi->cmd=csi->str[0];
return(0);
case CS_GETNAME:
getstr(csi->str,*csi->ip++,K_UPRLWR);
if(sys_status&SS_ABORT)
csi->str[0]=0;
return(0);
case CS_SHIFT_STR:
i=*(csi->ip++);
j=strlen(csi->str);
if(i>j)
i=j;
if(i)
memmove(csi->str,csi->str+i,j+1);
return(0);
case CS_COMPARE_KEY:
if( ((*csi->ip)==CS_DIGIT && isdigit(csi->cmd))
|| ((*csi->ip)==CS_EDIGIT && csi->cmd&0x80
&& isdigit(csi->cmd&0x7f))) {
csi->ip++;
csi->logic=LOGIC_TRUE;
}
else {
if(csi->cmd==*(csi->ip++))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
}
return(0);
case CS_COMPARE_CHAR:
if(csi->cmd==*(csi->ip++))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_SET_USER_LEVEL:
useron.level=*(csi->ip++);
putuserrec(&cfg,useron.number,U_LEVEL,2,ultoa(useron.level,tmp,10));
return(0);
case CS_SET_USER_STRING:
csi->logic=LOGIC_FALSE;
if(!csi->str[0]) {
csi->ip++;
return(0);
}
switch(*(csi->ip++)) {
case USER_STRING_ALIAS:
if(!isalpha(csi->str[0]) || trashcan(csi->str,"name"))
break;
i=matchuser(&cfg,csi->str,TRUE /*sysop_alias*/);
if(i && i!=useron.number)
break;
sprintf(useron.alias,"%.*s",LEN_ALIAS,csi->str);
putuserrec(&cfg,useron.number,U_ALIAS,LEN_ALIAS,useron.alias);
putusername(&cfg,useron.number,useron.alias);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_REALNAME:
if(trashcan(csi->str,"name"))
break;
if(cfg.uq&UQ_DUPREAL
&& userdatdupe(useron.number,U_NAME,LEN_NAME,csi->str))
break;
sprintf(useron.name,"%.*s",LEN_NAME,csi->str);
putuserrec(&cfg,useron.number,U_NAME,LEN_NAME
,useron.name);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_HANDLE:
if(trashcan(csi->str,"name"))
break;
if(cfg.uq&UQ_DUPHAND
&& userdatdupe(useron.number,U_HANDLE,LEN_HANDLE,csi->str))
break;
sprintf(useron.handle,"%.*s",LEN_HANDLE,csi->str);
putuserrec(&cfg,useron.number,U_HANDLE,LEN_HANDLE
,useron.handle);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_COMPUTER:
sprintf(useron.comp,"%.*s",LEN_COMP,csi->str);
putuserrec(&cfg,useron.number,U_COMP,LEN_COMP
,useron.comp);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_NOTE:
sprintf(useron.note,"%.*s",LEN_NOTE,csi->str);
putuserrec(&cfg,useron.number,U_NOTE,LEN_NOTE
,useron.note);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_ADDRESS:
sprintf(useron.address,"%.*s",LEN_ADDRESS,csi->str);
putuserrec(&cfg,useron.number,U_ADDRESS,LEN_ADDRESS
,useron.address);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_LOCATION:
sprintf(useron.location,"%.*s",LEN_LOCATION,csi->str);
putuserrec(&cfg,useron.number,U_LOCATION,LEN_LOCATION
,useron.location);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_ZIPCODE:
sprintf(useron.zipcode,"%.*s",LEN_ZIPCODE,csi->str);
putuserrec(&cfg,useron.number,U_ZIPCODE,LEN_ZIPCODE
,useron.zipcode);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_PASSWORD:
sprintf(useron.pass,"%.*s",LEN_PASS,csi->str);
putuserrec(&cfg,useron.number,U_PASS,LEN_PASS
,useron.pass);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_BIRTHDAY:
if(!getage(&cfg,csi->str))
break;
sprintf(useron.birth,"%.*s",LEN_BIRTH,csi->str);
putuserrec(&cfg,useron.number,U_BIRTH,LEN_BIRTH
,useron.birth);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_PHONE:
if(trashcan(csi->str,"phone"))
break;
sprintf(useron.phone,"%.*s",LEN_PHONE,csi->str);
putuserrec(&cfg,useron.number,U_PHONE,LEN_PHONE
,useron.phone);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_MODEM:
sprintf(useron.modem,"%.*s",LEN_MODEM,csi->str);
putuserrec(&cfg,useron.number,U_MODEM,LEN_MODEM
,useron.phone);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_COMMENT:
sprintf(useron.comment,"%.*s",LEN_COMMENT,csi->str);
putuserrec(&cfg,useron.number,U_COMMENT,LEN_COMMENT
,useron.comment);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_NETMAIL:
sprintf(useron.netmail,"%.*s",LEN_NETMAIL,csi->str);
putuserrec(&cfg,useron.number,U_NETMAIL,LEN_NETMAIL
,useron.netmail);
csi->logic=LOGIC_TRUE;
break;
default:
errormsg(WHERE,ERR_CHK,"user string type",*(csi->ip-1));
return(0);
}
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
}
}
/*********************************/
/* Single Byte Instrcutions ONLY */
/*********************************/
switch(*(csi->ip++)) {
case CS_ONE_MORE_BYTE: /* Just one MORE byte */
switch(*(csi->ip++)) {
case CS_OFFLINE:
csi->misc|=CS_OFFLINE_EXEC;
return(0);
case CS_ONLINE:
csi->misc&=~CS_OFFLINE_EXEC;
return(0);
case CS_NEWUSER:
if(newuser())
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_LOGON:
if(logon())
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_LOGOUT:
logout();
return(0);
case CS_EXIT:
return(1);
case CS_LOOP_BEGIN:
if(csi->loops<MAX_LOOPDEPTH)
csi->loop_home[csi->loops++]=(csi->ip-1);
return(0);
case CS_BREAK_LOOP:
if(csi->loops) {
skipto(csi,CS_END_LOOP);
csi->ip+=2;
csi->loops--;
}
return(0);
case CS_END_LOOP:
case CS_CONTINUE_LOOP:
if(csi->loops)
csi->ip=csi->loop_home[csi->loops-1];
return(0);
default:
errormsg(WHERE,ERR_CHK,"one byte extended function"
,*(csi->ip-1));
return(0);
}
case CS_CRLF:
CRLF;
return(0);
case CS_CLS:
CLS;
return(0);
case CS_PAUSE:
pause();
return(0);
case CS_PAUSE_RESET:
lncntr=0;
return(0);
case CS_GETLINES:
ansi_getlines();
return(0);
case CS_HANGUP:
hangup();
return(0);
case CS_LOGKEY:
logch(csi->cmd,0);
return(0);
case CS_LOGKEY_COMMA:
logch(csi->cmd,1);
return(0);
case CS_LOGSTR:
log(csi->str);
return(0);
case CS_CHKSYSPASS:
csi->logic=!chksyspass();
return(0);
case CS_PUT_NODE:
if(getnodedat(cfg.node_num,&thisnode,true)==0)
putnodedat(cfg.node_num,&thisnode);
return(0);
case CS_SYNC:
SYNC;
return(0);
case CS_ASYNC:
ASYNC;
return(0);
case CS_GETTIMELEFT:
gettimeleft();
return(0);
case CS_RETURN:
if(!csi->rets)
return(1);
csi->ip=csi->ret[--csi->rets];
return(0);
case CS_GETKEY:
csi->cmd=getkey(K_UPPER);
return(0);
case CS_GETCHAR:
csi->cmd=getkey(0);
return(0);
case CS_INKEY:
csi->cmd=toupper(inkey(K_NONE,1));
if(csi->cmd)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_INCHAR:
csi->cmd=inkey(K_NONE,1);
if(csi->cmd)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_GETKEYE:
csi->cmd=getkey(K_UPPER);
if(csi->cmd=='/') {
outchar('/');
csi->cmd=getkey(K_UPPER);
csi->cmd|=0x80;
}
return(0);
case CS_GETFILESPEC:
if(getfilespec(csi->str))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_SAVELINE:
SAVELINE;
return(0);
case CS_RESTORELINE:
RESTORELINE;
return(0);
case CS_SELECT_SHELL:
csi->logic=select_shell() ? LOGIC_TRUE:LOGIC_FALSE;
return(0);
case CS_SET_SHELL:
csi->logic=LOGIC_TRUE;
for(i=0;i<cfg.total_shells;i++)
if(!stricmp(csi->str,cfg.shell[i]->code)
&& chk_ar(cfg.shell[i]->ar,&useron,&client))
break;
if(i<cfg.total_shells) {
useron.shell=i;
putuserrec(&cfg,useron.number,U_SHELL,8,cfg.shell[i]->code);
}
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_SELECT_EDITOR:
csi->logic=select_editor() ? LOGIC_TRUE:LOGIC_FALSE;
return(0);
case CS_SET_EDITOR:
csi->logic=LOGIC_TRUE;
for(i=0;i<cfg.total_xedits;i++)
if(!stricmp(csi->str,cfg.xedit[i]->code)
&& chk_ar(cfg.xedit[i]->ar,&useron,&client))
break;
if(i<cfg.total_xedits) {
useron.xedit=i+1;
putuserrec(&cfg,useron.number,U_XEDIT,8,cfg.xedit[i]->code);
}
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_CLEAR_ABORT:
sys_status&=~SS_ABORT;
return(0);
case CS_FINDUSER:
i=finduser(csi->str);
if(i) {
csi->logic=LOGIC_TRUE;
username(&cfg,i,csi->str);
}
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_UNGETKEY:
ungetkey(csi->cmd&0x7f);
return(0);
case CS_UNGETSTR:
j=strlen(csi->str);
for(i=0;i<j;i++)
ungetkey(csi->str[i]);
return(0);
case CS_PRINTKEY:
if((csi->cmd&0x7f)>=' ')
outchar(csi->cmd&0x7f);
return(0);
case CS_PRINTSTR:
putmsg(csi->str,P_SAVEATR|P_NOABORT|P_NOATCODES);
return(0);
case CS_CMD_HOME:
if(csi->cmdrets<MAX_CMDRETS)
csi->cmdret[csi->cmdrets++]=(csi->ip-1);
return(0);
case CS_END_CMD:
if(csi->cmdrets)
csi->ip=csi->cmdret[--csi->cmdrets];
return(0);
case CS_CMD_POP:
if(csi->cmdrets)
csi->cmdrets--;
return(0);
case CS_IF_TRUE:
if(csi->logic!=LOGIC_TRUE) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_GREATER:
if(csi->logic!=LOGIC_GREATER) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_GREATER_OR_EQUAL:
if(csi->logic!=LOGIC_GREATER && csi->logic!=LOGIC_EQUAL) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_LESS:
if(csi->logic!=LOGIC_LESS) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_LESS_OR_EQUAL:
if(csi->logic!=LOGIC_LESS && csi->logic!=LOGIC_EQUAL) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_FALSE:
if(csi->logic==LOGIC_TRUE) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_ELSE:
skipto(csi,CS_ENDIF);
csi->ip++;
return(0);
case CS_END_CASE:
skipto(csi,CS_END_SWITCH);
csi->misc&=~CS_IN_SWITCH;
csi->ip++;
return(0);
case CS_DEFAULT:
case CS_END_SWITCH:
csi->misc&=~CS_IN_SWITCH;
return(0);
case CS_ENDIF:
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
}
}
BOOL read_chat_cfg(scfg_t* cfg, char* error)
{
char str[MAX_PATH+1],fname[13];
short i,j,n;
long offset=0;
FILE *instream;
strcpy(fname,"chat.cnf");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d (%s) opening %s",errno,STRERROR(errno),str);
return(FALSE);
}
/*********/
/* Gurus */
/*********/
get_int(cfg->total_gurus,instream);
if(cfg->total_gurus) {
if((cfg->guru=(guru_t **)malloc(sizeof(guru_t *)*cfg->total_gurus))==NULL)
return allocerr(instream,error,offset,fname,sizeof(guru_t *)*cfg->total_gurus);
} else
cfg->guru=NULL;
for(i=0;i<cfg->total_gurus;i++) {
if(feof(instream)) break;
if((cfg->guru[i]=(guru_t *)malloc(sizeof(guru_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(guru_t));
memset(cfg->guru[i],0,sizeof(guru_t));
get_str(cfg->guru[i]->name,instream);
get_str(cfg->guru[i]->code,instream);
get_str(cfg->guru[i]->arstr,instream);
cfg->guru[i]->ar=ARSTR(cfg->guru[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_chans=i;
/********************/
/* Chat Action Sets */
/********************/
get_int(cfg->total_actsets,instream);
if(cfg->total_actsets) {
if((cfg->actset=(actset_t **)malloc(sizeof(actset_t *)*cfg->total_actsets))==NULL)
return allocerr(instream,error,offset,fname,sizeof(actset_t *)*cfg->total_actsets);
} else
cfg->actset=NULL;
for(i=0;i<cfg->total_actsets;i++) {
if(feof(instream)) break;
if((cfg->actset[i]=(actset_t *)malloc(sizeof(actset_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(actset_t));
get_str(cfg->actset[i]->name,instream);
}
cfg->total_actsets=i;
/****************/
/* Chat Actions */
/****************/
get_int(cfg->total_chatacts,instream);
if(cfg->total_chatacts) {
if((cfg->chatact=(chatact_t **)malloc(sizeof(chatact_t *)*cfg->total_chatacts))
==NULL)
return allocerr(instream,error,offset,fname,sizeof(chatact_t *)*cfg->total_chatacts);
} else
cfg->chatact=NULL;
for(i=0;i<cfg->total_chatacts;i++) {
if(feof(instream)) break;
if((cfg->chatact[i]=(chatact_t *)malloc(sizeof(chatact_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(chatact_t));
memset(cfg->chatact[i],0,sizeof(chatact_t));
get_int(cfg->chatact[i]->actset,instream);
get_str(cfg->chatact[i]->cmd,instream);
get_str(cfg->chatact[i]->out,instream);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_chatacts=i;
/***************************/
/* Multinode Chat Channels */
/***************************/
get_int(cfg->total_chans,instream);
if(cfg->total_chans) {
if((cfg->chan=(chan_t **)malloc(sizeof(chan_t *)*cfg->total_chans))==NULL)
return allocerr(instream,error,offset,fname,sizeof(chan_t *)*cfg->total_chans);
} else
cfg->chan=NULL;
for(i=0;i<cfg->total_chans;i++) {
if(feof(instream)) break;
if((cfg->chan[i]=(chan_t *)malloc(sizeof(chan_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(chan_t));
memset(cfg->chan[i],0,sizeof(chan_t));
get_int(cfg->chan[i]->actset,instream);
get_str(cfg->chan[i]->name,instream);
get_str(cfg->chan[i]->code,instream);
get_str(cfg->chan[i]->arstr,instream);
cfg->chan[i]->ar=ARSTR(cfg->chan[i]->arstr,cfg);
get_int(cfg->chan[i]->cost,instream);
get_int(cfg->chan[i]->guru,instream);
get_int(cfg->chan[i]->misc,instream);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_chans=i;
/**************/
/* Chat Pages */
/**************/
get_int(cfg->total_pages,instream);
if(cfg->total_pages) {
if((cfg->page=(page_t **)malloc(sizeof(page_t *)*cfg->total_pages))==NULL)
return allocerr(instream,error,offset,fname,sizeof(page_t *)*cfg->total_pages);
} else
cfg->page=NULL;
for(i=0;i<cfg->total_pages;i++) {
if(feof(instream)) break;
if((cfg->page[i]=(page_t *)malloc(sizeof(page_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(page_t));
memset(cfg->page[i],0,sizeof(page_t));
get_str(cfg->page[i]->cmd,instream);
get_str(cfg->page[i]->arstr,instream);
cfg->page[i]->ar=ARSTR(cfg->page[i]->arstr,cfg);
get_int(cfg->page[i]->misc,instream);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_pages=i;
fclose(instream);
return(TRUE);
}
static int send_files(char** fname, uint fnames)
{
char path[MAX_PATH+1];
int i;
uint errors;
uint fnum;
uint cps;
glob_t g;
int gi;
BOOL success=TRUE;
long fsize;
ulong sent_bytes;
ulong total_bytes=0;
time_t t,startfile;
time_t startall;
FILE* fp;
startall=time(NULL);
/****************************************************/
/* Search through all to find total files and bytes */
/****************************************************/
for(fnum=0;fnum<fnames;fnum++) {
if(glob(fname[fnum],0,NULL,&g)) {
lprintf(LOG_WARNING,"%s not found",fname[fnum]);
continue;
}
for(i=0;i<(int)g.gl_pathc;i++) {
if(isdir(g.gl_pathv[i]))
continue;
xm.total_files++;
xm.total_bytes+=flength(g.gl_pathv[i]);
}
globfree(&g);
}
if(xm.total_files<1) {
lprintf(LOG_ERR,"No files to send");
return(-1);
}
if(xm.total_files>1)
lprintf(LOG_INFO,"Sending %u files (%lu KB total)"
,xm.total_files,xm.total_bytes/1024);
zm.files_remaining = xm.total_files;
zm.bytes_remaining = xm.total_bytes;
/***********************************************/
/* Send every file matching names or filespecs */
/***********************************************/
for(fnum=0;fnum<fnames;fnum++) {
if(glob(fname[fnum],0,NULL,&g)) {
lprintf(LOG_WARNING,"%s not found",fname[fnum]);
continue;
}
for(gi=0;gi<(int)g.gl_pathc;gi++) {
SAFECOPY(path,g.gl_pathv[gi]);
if(isdir(path))
continue;
if((fp=fnopen(NULL,path,O_RDONLY|O_BINARY))==NULL
&& (fp=fopen(path,"rb"))==NULL) {
lprintf(LOG_ERR,"Error %d opening %s for read",errno,path);
continue;
}
setvbuf(fp,NULL,_IOFBF,0x10000);
fsize=filelength(fileno(fp));
errors=0;
success=FALSE;
startfile=time(NULL);
lprintf(LOG_INFO,"Sending %s (%lu KB) via %s"
,path,fsize/1024
,mode&XMODEM ? "Xmodem" : mode&YMODEM ? "Ymodem" : "Zmodem");
if(mode&ZMODEM)
success=zmodem_send_file(&zm, path, fp, /* ZRQINIT? */fnum==0, &startfile, &sent_bytes);
else /* X/Ymodem */
success=xmodem_send_file(&xm, path, fp, &startfile, &sent_bytes);
fclose(fp);
if((t=time(NULL)-startfile)<=0)
t=1;
if((cps=sent_bytes/t)==0)
cps=1;
if(success) {
xm.sent_files++;
xm.sent_bytes+=fsize;
lprintf(LOG_INFO,"Successful - Time: %lu:%02lu CPS: %lu"
,t/60,t%60,cps);
if(xm.total_files-xm.sent_files)
lprintf(LOG_INFO,"Remaining - Time: %lu:%02lu Files: %u KBytes: %lu"
,((xm.total_bytes-xm.sent_bytes)/cps)/60
,((xm.total_bytes-xm.sent_bytes)/cps)%60
,xm.total_files-xm.sent_files
,(xm.total_bytes-xm.sent_bytes)/1024
);
} else
lprintf(LOG_WARNING,"File Transfer %s", aborted ? "Aborted" : "Failure");
/* DSZLOG entry */
if(logfp) {
lprintf(LOG_DEBUG,"Updating DSZLOG: %s", dszlog);
fprintf(logfp,"%c %7lu %5u bps %6lu cps %3u errors %5u %4u "
"%s -1\n"
,success ? (mode&ZMODEM ? 'z':'S')
: (mode&ZMODEM && zm.file_skipped) ? 's'
: 'E'
,sent_bytes
,115200 /* baud */
,cps
,mode&ZMODEM ? zm.errors : xm.errors
,flows
,mode&ZMODEM ? zm.block_size : xm.block_size
,dszlog_filename(path));
fflush(logfp);
}
total_bytes += sent_bytes;
if(aborted) {
xm.cancelled=FALSE;
xmodem_cancel(&xm);
break;
}
if(xm.cancelled || zm.cancelled)
break;
} /* while(gi<(int)g.gl_pathc) */
if(gi<(int)g.gl_pathc)/* error occurred */
break;
}
if(mode&ZMODEM && !zm.cancelled && is_connected(NULL))
zmodem_get_zfin(&zm);
if(fnum<fnames) /* error occurred */
return(-1);
if(!success)
return(-1);
if(mode&XMODEM)
return(0);
if(mode&YMODEM) {
if(xmodem_get_mode(&xm)) {
lprintf(LOG_INFO,"Sending Ymodem termination block");
memset(block,0,128); /* send short block for terminator */
xmodem_put_block(&xm, block, 128 /* block_size */, 0 /* block_num */);
if(!xmodem_get_ack(&xm,6,0)) {
lprintf(LOG_WARNING,"Failed to receive ACK after terminating block");
}
}
}
if(xm.total_files>1) {
t=time(NULL)-startall;
if(!t) t=1;
lprintf(LOG_INFO,"Overall - Time %02lu:%02lu KBytes: %lu CPS: %lu"
,t/60,t%60,total_bytes/1024,total_bytes/t);
}
return(0); /* success */
}
BOOL read_xtrn_cfg(scfg_t* cfg, char* error)
{
char str[MAX_PATH+1],fname[13],c;
short i,j,n;
long offset=0;
FILE *instream;
strcpy(fname,"xtrn.cnf");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d (%s) opening %s",errno,STRERROR(errno),str);
return(FALSE);
}
/*************/
/* Swap list */
/*************/
get_int(cfg->total_swaps,instream);
if(cfg->total_swaps) {
if((cfg->swap=(swap_t **)malloc(sizeof(swap_t *)*cfg->total_swaps))==NULL)
return allocerr(instream,error,offset,fname,sizeof(swap_t *)*cfg->total_swaps);
} else
cfg->swap=NULL;
for(i=0;i<cfg->total_swaps;i++) {
if(feof(instream)) break;
if((cfg->swap[i]=(swap_t *)malloc(sizeof(swap_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(swap_t));
get_str(cfg->swap[i]->cmd,instream);
}
cfg->total_swaps=i;
/********************/
/* External Editors */
/********************/
get_int(cfg->total_xedits,instream);
if(cfg->total_xedits) {
if((cfg->xedit=(xedit_t **)malloc(sizeof(xedit_t *)*cfg->total_xedits))==NULL)
return allocerr(instream,error,offset,fname,sizeof(xedit_t *)*cfg->total_xedits);
} else
cfg->xedit=NULL;
for(i=0;i<cfg->total_xedits;i++) {
if(feof(instream)) break;
if((cfg->xedit[i]=(xedit_t *)malloc(sizeof(xedit_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(xedit_t));
memset(cfg->xedit[i],0,sizeof(xedit_t));
get_str(cfg->xedit[i]->name,instream);
get_str(cfg->xedit[i]->code,instream);
get_str(cfg->xedit[i]->lcmd,instream);
get_str(cfg->xedit[i]->rcmd,instream);
get_int(cfg->xedit[i]->misc,instream);
get_str(cfg->xedit[i]->arstr,instream);
cfg->xedit[i]->ar=ARSTR(cfg->xedit[i]->arstr,cfg);
get_int(cfg->xedit[i]->type,instream);
get_int(c,instream);
for(j=0;j<7;j++)
get_int(n,instream);
}
cfg->total_xedits=i;
/*****************************/
/* External Program Sections */
/*****************************/
get_int(cfg->total_xtrnsecs,instream);
if(cfg->total_xtrnsecs) {
if((cfg->xtrnsec=(xtrnsec_t **)malloc(sizeof(xtrnsec_t *)*cfg->total_xtrnsecs))
==NULL)
return allocerr(instream,error,offset,fname,sizeof(xtrnsec_t *)*cfg->total_xtrnsecs);
} else
cfg->xtrnsec=NULL;
for(i=0;i<cfg->total_xtrnsecs;i++) {
if(feof(instream)) break;
if((cfg->xtrnsec[i]=(xtrnsec_t *)malloc(sizeof(xtrnsec_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(xtrnsec_t));
memset(cfg->xtrnsec[i],0,sizeof(xtrnsec_t));
get_str(cfg->xtrnsec[i]->name,instream);
get_str(cfg->xtrnsec[i]->code,instream);
get_str(cfg->xtrnsec[i]->arstr,instream);
cfg->xtrnsec[i]->ar=ARSTR(cfg->xtrnsec[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_xtrnsecs=i;
/*********************/
/* External Programs */
/*********************/
get_int(cfg->total_xtrns,instream);
if(cfg->total_xtrns) {
if((cfg->xtrn=(xtrn_t **)malloc(sizeof(xtrn_t *)*cfg->total_xtrns))==NULL)
return allocerr(instream,error,offset,fname,sizeof(xtrn_t *)*cfg->total_xtrns);
} else
cfg->xtrn=NULL;
for(i=0;i<cfg->total_xtrns;i++) {
if(feof(instream)) break;
if((cfg->xtrn[i]=(xtrn_t *)malloc(sizeof(xtrn_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(xtrn_t));
memset(cfg->xtrn[i],0,sizeof(xtrn_t));
get_int(cfg->xtrn[i]->sec,instream);
get_str(cfg->xtrn[i]->name,instream);
get_str(cfg->xtrn[i]->code,instream);
get_str(cfg->xtrn[i]->arstr,instream);
get_str(cfg->xtrn[i]->run_arstr,instream);
cfg->xtrn[i]->ar=ARSTR(cfg->xtrn[i]->arstr,cfg);
cfg->xtrn[i]->run_ar=ARSTR(cfg->xtrn[i]->run_arstr,cfg);
get_int(cfg->xtrn[i]->type,instream);
get_int(cfg->xtrn[i]->misc,instream);
get_int(cfg->xtrn[i]->event,instream);
get_int(cfg->xtrn[i]->cost,instream);
get_str(cfg->xtrn[i]->cmd,instream);
get_str(cfg->xtrn[i]->clean,instream);
get_str(cfg->xtrn[i]->path,instream);
get_int(cfg->xtrn[i]->textra,instream);
get_int(cfg->xtrn[i]->maxtime,instream);
for(j=0;j<7;j++)
get_int(n,instream);
}
cfg->total_xtrns=i;
/****************/
/* Timed Events */
/****************/
get_int(cfg->total_events,instream);
if(cfg->total_events) {
if((cfg->event=(event_t **)malloc(sizeof(event_t *)*cfg->total_events))==NULL)
return allocerr(instream,error,offset,fname,sizeof(event_t *)*cfg->total_events);
} else
cfg->event=NULL;
for(i=0;i<cfg->total_events;i++) {
if(feof(instream)) break;
if((cfg->event[i]=(event_t *)malloc(sizeof(event_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(event_t));
memset(cfg->event[i],0,sizeof(event_t));
get_str(cfg->event[i]->code,instream);
get_str(cfg->event[i]->cmd,instream);
get_int(cfg->event[i]->days,instream);
get_int(cfg->event[i]->time,instream);
get_int(cfg->event[i]->node,instream);
get_int(cfg->event[i]->misc,instream);
get_str(cfg->event[i]->dir,instream);
get_int(cfg->event[i]->freq,instream);
get_int(cfg->event[i]->mdays,instream);
for(j=0;j<5;j++)
get_int(n,instream);
}
cfg->total_events=i;
/********************************/
/* Native (32-bit) Program list */
/********************************/
get_int(cfg->total_natvpgms,instream);
if(cfg->total_natvpgms) {
if((cfg->natvpgm=(natvpgm_t **)malloc(sizeof(natvpgm_t *)*cfg->total_natvpgms))==NULL)
return allocerr(instream,error,offset,fname,sizeof(natvpgm_t *)*cfg->total_natvpgms);
} else
cfg->natvpgm=NULL;
for(i=0;i<cfg->total_natvpgms;i++) {
if(feof(instream)) break;
if((cfg->natvpgm[i]=(natvpgm_t *)malloc(sizeof(natvpgm_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(natvpgm_t));
get_str(cfg->natvpgm[i]->name,instream);
cfg->natvpgm[i]->misc=0;
}
cfg->total_natvpgms=i;
for(i=0;i<cfg->total_natvpgms;i++) {
if(feof(instream)) break;
get_int(cfg->natvpgm[i]->misc,instream);
}
/*******************/
/* Global Hot Keys */
/*******************/
get_int(cfg->total_hotkeys,instream);
if(cfg->total_hotkeys) {
if((cfg->hotkey=(hotkey_t **)malloc(sizeof(hotkey_t *)*cfg->total_hotkeys))==NULL)
return allocerr(instream,error,offset,fname,sizeof(hotkey_t *)*cfg->total_hotkeys);
} else
cfg->hotkey=NULL;
for(i=0;i<cfg->total_hotkeys;i++) {
if(feof(instream)) break;
if((cfg->hotkey[i]=(hotkey_t *)malloc(sizeof(hotkey_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(hotkey_t));
memset(cfg->hotkey[i],0,sizeof(hotkey_t));
get_int(cfg->hotkey[i]->key,instream);
get_str(cfg->hotkey[i]->cmd,instream);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_hotkeys=i;
/************************************/
/* External Program-related Toggles */
/************************************/
get_int(cfg->xtrn_misc,instream);
fclose(instream);
return(TRUE);
}
BOOL read_file_cfg(scfg_t* cfg, char* error)
{
char str[MAX_PATH+1],fname[13],c,cmd[LEN_CMD+1];
short i,j,n;
long offset=0,t;
FILE *instream;
strcpy(fname,"file.cnf");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d (%s) opening %s",errno,STRERROR(errno),str);
return(FALSE);
}
get_int(cfg->min_dspace,instream);
get_int(cfg->max_batup,instream);
get_int(cfg->max_batdn,instream);
get_int(cfg->max_userxfer,instream);
get_int(t,instream); /* unused - was cdt_byte_value */
get_int(cfg->cdt_up_pct,instream);
get_int(cfg->cdt_dn_pct,instream);
get_int(t,instream); /* unused - was temp_ext */
get_str(cmd,instream); /* unused - was temp_cmd */
get_int(cfg->leech_pct,instream);
get_int(cfg->leech_sec,instream);
get_int(cfg->file_misc,instream);
for(i=0;i<30;i++)
get_int(n,instream);
/**************************/
/* Extractable File Types */
/**************************/
get_int(cfg->total_fextrs,instream);
if(cfg->total_fextrs) {
if((cfg->fextr=(fextr_t **)malloc(sizeof(fextr_t *)*cfg->total_fextrs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(fextr_t*)*cfg->total_fextrs);
} else
cfg->fextr=NULL;
for(i=0; i<cfg->total_fextrs; i++) {
if(feof(instream))
break;
if((cfg->fextr[i]=(fextr_t *)malloc(sizeof(fextr_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(fextr_t));
memset(cfg->fextr[i],0,sizeof(fextr_t));
get_str(cfg->fextr[i]->ext,instream);
get_str(cfg->fextr[i]->cmd,instream);
get_str(cfg->fextr[i]->arstr,instream);
cfg->fextr[i]->ar=ARSTR(cfg->fextr[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_fextrs=i;
/***************************/
/* Compressable File Types */
/***************************/
get_int(cfg->total_fcomps,instream);
if(cfg->total_fcomps) {
if((cfg->fcomp=(fcomp_t **)malloc(sizeof(fcomp_t *)*cfg->total_fcomps))==NULL)
return allocerr(instream,error,offset,fname,sizeof(fcomp_t*)*cfg->total_fcomps);
} else
cfg->fcomp=NULL;
for(i=0; i<cfg->total_fcomps; i++) {
if(feof(instream))
break;
if((cfg->fcomp[i]=(fcomp_t *)malloc(sizeof(fcomp_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(fcomp_t));
memset(cfg->fcomp[i],0,sizeof(fcomp_t));
get_str(cfg->fcomp[i]->ext,instream);
get_str(cfg->fcomp[i]->cmd,instream);
get_str(cfg->fcomp[i]->arstr,instream);
cfg->fcomp[i]->ar=ARSTR(cfg->fcomp[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_fcomps=i;
/***********************/
/* Viewable File Types */
/***********************/
get_int(cfg->total_fviews,instream);
if(cfg->total_fviews) {
if((cfg->fview=(fview_t **)malloc(sizeof(fview_t *)*cfg->total_fviews))==NULL)
return allocerr(instream,error,offset,fname,sizeof(fview_t*)*cfg->total_fviews);
} else
cfg->fview=NULL;
for(i=0; i<cfg->total_fviews; i++) {
if(feof(instream)) break;
if((cfg->fview[i]=(fview_t *)malloc(sizeof(fview_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(fview_t));
memset(cfg->fview[i],0,sizeof(fview_t));
get_str(cfg->fview[i]->ext,instream);
get_str(cfg->fview[i]->cmd,instream);
get_str(cfg->fview[i]->arstr,instream);
cfg->fview[i]->ar=ARSTR(cfg->fview[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_fviews=i;
/***********************/
/* Testable File Types */
/***********************/
get_int(cfg->total_ftests,instream);
if(cfg->total_ftests) {
if((cfg->ftest=(ftest_t **)malloc(sizeof(ftest_t *)*cfg->total_ftests))==NULL)
return allocerr(instream,error,offset,fname,sizeof(ftest_t*)*cfg->total_ftests);
} else
cfg->ftest=NULL;
for(i=0; i<cfg->total_ftests; i++) {
if(feof(instream)) break;
if((cfg->ftest[i]=(ftest_t *)malloc(sizeof(ftest_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(ftest_t));
memset(cfg->ftest[i],0,sizeof(ftest_t));
get_str(cfg->ftest[i]->ext,instream);
get_str(cfg->ftest[i]->cmd,instream);
get_str(cfg->ftest[i]->workstr,instream);
get_str(cfg->ftest[i]->arstr,instream);
cfg->ftest[i]->ar=ARSTR(cfg->ftest[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_ftests=i;
/*******************/
/* Download events */
/*******************/
get_int(cfg->total_dlevents,instream);
if(cfg->total_dlevents) {
if((cfg->dlevent=(dlevent_t **)malloc(sizeof(dlevent_t *)*cfg->total_dlevents))
==NULL)
return allocerr(instream,error,offset,fname,sizeof(dlevent_t*)*cfg->total_dlevents);
} else
cfg->dlevent=NULL;
for(i=0; i<cfg->total_dlevents; i++) {
if(feof(instream)) break;
if((cfg->dlevent[i]=(dlevent_t *)malloc(sizeof(dlevent_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(dlevent_t));
memset(cfg->dlevent[i],0,sizeof(dlevent_t));
get_str(cfg->dlevent[i]->ext,instream);
get_str(cfg->dlevent[i]->cmd,instream);
get_str(cfg->dlevent[i]->workstr,instream);
get_str(cfg->dlevent[i]->arstr,instream);
cfg->dlevent[i]->ar=ARSTR(cfg->dlevent[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_dlevents=i;
/***************************/
/* File Transfer Protocols */
/***************************/
get_int(cfg->total_prots,instream);
if(cfg->total_prots) {
if((cfg->prot=(prot_t **)malloc(sizeof(prot_t *)*cfg->total_prots))==NULL)
return allocerr(instream,error,offset,fname,sizeof(prot_t*)*cfg->total_prots);
} else
cfg->prot=NULL;
for(i=0;i<cfg->total_prots;i++) {
if(feof(instream)) break;
if((cfg->prot[i]=(prot_t *)malloc(sizeof(prot_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(prot_t));
memset(cfg->prot[i],0,sizeof(prot_t));
get_int(cfg->prot[i]->mnemonic,instream);
get_str(cfg->prot[i]->name,instream);
get_str(cfg->prot[i]->ulcmd,instream);
get_str(cfg->prot[i]->dlcmd,instream);
get_str(cfg->prot[i]->batulcmd,instream);
get_str(cfg->prot[i]->batdlcmd,instream);
get_str(cfg->prot[i]->blindcmd,instream);
get_str(cfg->prot[i]->bicmd,instream);
get_int(cfg->prot[i]->misc,instream);
get_str(cfg->prot[i]->arstr,instream);
cfg->prot[i]->ar=ARSTR(cfg->prot[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_prots=i;
/************************/
/* Alternate File Paths */
/************************/
get_int(cfg->altpaths,instream);
if(cfg->altpaths) {
if((cfg->altpath=(char **)malloc(sizeof(char *)*cfg->altpaths))==NULL)
return allocerr(instream,error,offset,fname,sizeof(char *)*cfg->altpaths);
} else
cfg->altpath=NULL;
for(i=0;i<cfg->altpaths;i++) {
if(feof(instream)) break;
fread(str,LEN_DIR+1,1,instream);
offset+=LEN_DIR+1;
backslash(str);
j=LEN_DIR+1;
if((cfg->altpath[i]=(char *)malloc(j))==NULL)
return allocerr(instream,error,offset,fname,j);
memset(cfg->altpath[i],0,j);
strcpy(cfg->altpath[i],str);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->altpaths=i;
/******************/
/* File Libraries */
/******************/
get_int(cfg->total_libs,instream);
if(cfg->total_libs) {
if((cfg->lib=(lib_t **)malloc(sizeof(lib_t *)*cfg->total_libs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(lib_t *)*cfg->total_libs);
} else
cfg->lib=NULL;
for(i=0;i<cfg->total_libs;i++) {
if(feof(instream)) break;
if((cfg->lib[i]=(lib_t *)malloc(sizeof(lib_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(lib_t));
memset(cfg->lib[i],0,sizeof(lib_t));
cfg->lib[i]->offline_dir=INVALID_DIR;
get_str(cfg->lib[i]->lname,instream);
get_str(cfg->lib[i]->sname,instream);
get_str(cfg->lib[i]->arstr,instream);
cfg->lib[i]->ar=ARSTR(cfg->lib[i]->arstr,cfg);
get_str(cfg->lib[i]->parent_path,instream);
get_str(cfg->lib[i]->code_prefix,instream);
get_int(c,instream);
for(j=0;j<3;j++)
get_int(n,instream); /* 0x0000 */
for(j=0;j<16;j++)
get_int(n,instream); /* 0xffff */
}
cfg->total_libs=i;
/********************/
/* File Directories */
/********************/
cfg->sysop_dir=cfg->user_dir=cfg->upload_dir=INVALID_DIR;
get_int(cfg->total_dirs,instream);
if(cfg->total_dirs) {
if((cfg->dir=(dir_t **)malloc(sizeof(dir_t *)*(cfg->total_dirs+1)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(dir_t *)*(cfg->total_dirs+1));
} else
cfg->dir=NULL;
for(i=0;i<cfg->total_dirs;i++) {
if(feof(instream)) break;
if((cfg->dir[i]=(dir_t *)malloc(sizeof(dir_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(dir_t));
memset(cfg->dir[i],0,sizeof(dir_t));
get_int(cfg->dir[i]->lib,instream);
get_str(cfg->dir[i]->lname,instream);
get_str(cfg->dir[i]->sname,instream);
if(!stricmp(cfg->dir[i]->sname,"SYSOP")) /* Sysop upload directory */
cfg->sysop_dir=i;
else if(!stricmp(cfg->dir[i]->sname,"USER")) /* User to User xfer dir */
cfg->user_dir=i;
else if(!stricmp(cfg->dir[i]->sname,"UPLOADS")) /* Upload directory */
cfg->upload_dir=i;
else if(!stricmp(cfg->dir[i]->sname,"OFFLINE")) /* Offline files dir */
cfg->lib[cfg->dir[i]->lib]->offline_dir=i;
get_str(cfg->dir[i]->code_suffix,instream);
get_str(cfg->dir[i]->data_dir,instream);
get_str(cfg->dir[i]->arstr,instream);
get_str(cfg->dir[i]->ul_arstr,instream);
get_str(cfg->dir[i]->dl_arstr,instream);
get_str(cfg->dir[i]->op_arstr,instream);
cfg->dir[i]->ar=ARSTR(cfg->dir[i]->arstr,cfg);
cfg->dir[i]->ul_ar=ARSTR(cfg->dir[i]->ul_arstr,cfg);
cfg->dir[i]->dl_ar=ARSTR(cfg->dir[i]->dl_arstr,cfg);
cfg->dir[i]->op_ar=ARSTR(cfg->dir[i]->op_arstr,cfg);
get_str(cfg->dir[i]->path,instream);
get_str(cfg->dir[i]->upload_sem,instream);
get_int(cfg->dir[i]->maxfiles,instream);
if(cfg->dir[i]->maxfiles>MAX_FILES)
cfg->dir[i]->maxfiles=MAX_FILES;
get_str(cfg->dir[i]->exts,instream);
get_int(cfg->dir[i]->misc,instream);
get_int(cfg->dir[i]->seqdev,instream);
get_int(cfg->dir[i]->sort,instream);
get_str(cfg->dir[i]->ex_arstr,instream);
cfg->dir[i]->ex_ar=ARSTR(cfg->dir[i]->ex_arstr,cfg);
get_int(cfg->dir[i]->maxage,instream);
get_int(cfg->dir[i]->up_pct,instream);
get_int(cfg->dir[i]->dn_pct,instream);
get_int(c,instream);
for(j=0;j<24;j++)
get_int(n,instream);
}
cfg->total_dirs=i;
/**********************/
/* Text File Sections */
/**********************/
get_int(cfg->total_txtsecs,instream);
if(cfg->total_txtsecs) {
if((cfg->txtsec=(txtsec_t **)malloc(sizeof(txtsec_t *)*cfg->total_txtsecs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(txtsec_t *)*cfg->total_txtsecs);
} else
cfg->txtsec=NULL;
for(i=0;i<cfg->total_txtsecs;i++) {
if(feof(instream)) break;
if((cfg->txtsec[i]=(txtsec_t *)malloc(sizeof(txtsec_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(txtsec_t));
memset(cfg->txtsec[i],0,sizeof(txtsec_t));
get_str(cfg->txtsec[i]->name,instream);
get_str(cfg->txtsec[i]->code,instream);
get_str(cfg->txtsec[i]->arstr,instream);
cfg->txtsec[i]->ar=ARSTR(cfg->txtsec[i]->arstr,cfg);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_txtsecs=i;
fclose(instream);
return(TRUE);
}
uint sbbs_t::finduser(char *instr)
{
int file,i;
char str[128],str2[256],str3[256],ynq[25],c,pass=1;
long l,length;
FILE *stream;
i=atoi(instr);
if(i>0) {
username(&cfg, i,str2);
if(str2[0] && strcmp(str2,"DELETED USER"))
return(i);
}
strcpy(str,instr);
strupr(str);
SAFEPRINTF(str3,"%suser/name.dat",cfg.data_dir);
if(flength(str3)<1L)
return(0);
if((stream=fnopen(&file,str3,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str3,O_RDONLY);
return(0);
}
SAFEPRINTF(ynq,"%.2s",text[YN]);
ynq[2]='Q';
ynq[3]=0;
length=(long)filelength(file);
while(pass<3) {
fseek(stream,0L,SEEK_SET); /* seek to beginning for each pass */
for(l=0;l<length;l+=LEN_ALIAS+2) {
if(!online) break;
fread(str2,LEN_ALIAS+2,1,stream);
for(c=0;c<LEN_ALIAS;c++)
if(str2[c]==ETX) break;
str2[c]=0;
if(!c) /* deleted user */
continue;
strcpy(str3,str2);
strupr(str2);
if(pass==1 && !strcmp(str,str2)) {
fclose(stream);
return((l/(LEN_ALIAS+2))+1);
}
if(pass==2 && strstr(str2,str)) {
bprintf(text[DoYouMeanThisUserQ],str3
,(uint)(l/(LEN_ALIAS+2))+1);
c=(char)getkeys(ynq,0);
if(sys_status&SS_ABORT) {
fclose(stream);
return(0);
}
if(c==text[YN][0]) {
fclose(stream);
return((l/(LEN_ALIAS+2))+1);
}
if(c=='Q') {
fclose(stream);
return(0);
}
}
}
pass++;
}
bputs(text[UnknownUser]);
fclose(stream);
return(0);
}
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);
}
int sbbs_t::text_sec()
{
char str[256],usemenu
,*file[MAX_TXTFILES],addpath[83],addstr[83],*buf,ch;
char tmp[512];
long i,j,usrsec[MAX_TXTSECS],usrsecs,cursec;
long l,length;
FILE *stream;
for(i=j=0;i<cfg.total_txtsecs;i++) {
if(!chk_ar(cfg.txtsec[i]->ar,&useron,&client))
continue;
usrsec[j++]=i;
}
usrsecs=j;
if(!usrsecs) {
bputs(text[NoTextSections]);
return(1);
}
action=NODE_RTXT;
while(online) {
sprintf(str,"%smenu/text_sec.*",cfg.text_dir);
if(fexist(str))
menu("text_sec");
else {
bputs(text[TextSectionLstHdr]);
for(i=0;i<usrsecs && !msgabort();i++) {
sprintf(str,text[TextSectionLstFmt],i+1,cfg.txtsec[usrsec[i]]->name);
if(i<9) outchar(' ');
bputs(str);
}
}
ASYNC;
mnemonics(text[WhichTextSection]);
if((cursec=getnum(usrsecs))<1)
break;
cursec--;
while(online) {
sprintf(str,"%smenu/text%lu.*",cfg.text_dir,cursec+1);
if(fexist(str)) {
sprintf(str,"text%lu",cursec+1);
menu(str);
usemenu=1;
}
else {
bprintf(text[TextFilesLstHdr],cfg.txtsec[usrsec[cursec]]->name);
usemenu=0;
}
sprintf(str,"%stext/%s.ixt",cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
j=0;
if(fexist(str)) {
if((stream=fnopen((int *)&i,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(0);
}
while(!ferror(stream) && !msgabort()) { /* file open too long */
if(!fgets(str,81,stream))
break;
str[strlen(str)-2]=0; /* chop off CRLF */
if((file[j]=(char *)malloc(strlen(str)+1))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,strlen(str)+1);
continue;
}
strcpy(file[j],str);
fgets(str,81,stream);
if(!usemenu) bprintf(text[TextFilesLstFmt],j+1,str);
j++;
}
fclose(stream);
}
ASYNC;
if(SYSOP) {
strcpy(str,"QARE?");
mnemonics(text[WhichTextFileSysop]);
}
else {
strcpy(str,"Q?");
mnemonics(text[WhichTextFile]);
}
i=getkeys(str,j);
if(!(i&0x80000000L)) { /* no file number */
for(l=0;l<j;l++)
free(file[l]);
if((i=='E' || i=='R') && !j)
continue;
}
if(i=='Q' || !i)
break;
if(i==-1) { /* ctrl-c */
for(i=0;i<j;i++)
free(file[i]);
return(0);
}
if(i=='?') /* ? means re-list */
continue;
if(i=='A') { /* Add text file */
if(j) {
bputs(text[AddTextFileBeforeWhich]);
i=getnum(j+1);
if(i<1)
continue;
i--; /* number of file entries to skip */ }
else
i=0;
bprintf(text[AddTextFilePath]
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
if(!getstr(addpath,80,0))
continue;
strcat(addpath,crlf);
bputs(text[AddTextFileDesc]);
if(!getstr(addstr,74,0))
continue;
strcat(addstr,crlf);
sprintf(str,"%stext/%s.ixt"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
if(i==j) { /* just add to end */
if((i=nopen(str,O_WRONLY|O_APPEND|O_CREAT))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_APPEND|O_CREAT);
return(0);
}
write(i,addpath,strlen(addpath));
write(i,addstr,strlen(addstr));
close(i);
continue;
}
j=i; /* inserting in middle of file */
if((stream=fnopen((int *)&i,str,O_RDWR))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDWR);
return(0);
}
length=(long)filelength(i);
for(i=0;i<j;i++) { /* skip two lines for each entry */
fgets(tmp,81,stream);
fgets(tmp,81,stream);
}
l=(long)ftell(stream);
if((buf=(char *)malloc(length-l))==NULL) {
fclose(stream);
errormsg(WHERE,ERR_ALLOC,str,length-l);
return(0);
}
fread(buf,1,length-l,stream);
fseek(stream,l,SEEK_SET); /* go back to where we need to insert */
fputs(addpath,stream);
fputs(addstr,stream);
fwrite(buf,1,length-l,stream);
fclose(stream);
free(buf);
continue;
}
if(i=='R' || i=='E') { /* Remove or Edit text file */
ch=(char)i;
if(ch=='R')
bputs(text[RemoveWhichTextFile]);
else
bputs(text[EditWhichTextFile]);
i=getnum(j);
if(i<1)
continue;
sprintf(str,"%stext/%s.ixt"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
j=i-1;
if((stream=fnopen(NULL,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(0);
}
for(i=0;i<j;i++) { /* skip two lines for each entry */
fgets(tmp,81,stream);
fgets(tmp,81,stream);
}
fgets(addpath,81,stream);
truncsp(addpath);
fclose(stream);
if(!strchr(addpath,'\\') && !strchr(addpath,'/'))
sprintf(tmp,"%stext/%s/%s"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code,addpath);
else
strcpy(tmp,addpath);
if(ch=='R') { /* Remove */
if(fexist(tmp)) {
sprintf(str,text[DeleteTextFileQ],tmp);
if(!noyes(str))
if(remove(tmp)) errormsg(WHERE,ERR_REMOVE,tmp,0);
}
sprintf(str,"%stext/%s.ixt"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
removeline(str,addpath,2,0);
}
else { /* Edit */
strcpy(str,tmp);
editfile(str);
}
continue;
}
i=(i&~0x80000000L)-1;
if(!strchr(file[i],'\\') && !strchr(file[i],'/'))
sprintf(str,"%stext/%s/%s"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code,file[i]);
else
strcpy(str,file[i]);
fexistcase(str);
attr(LIGHTGRAY);
printfile(str,0);
sprintf(str,"%s read text file: %s"
,useron.alias,file[i]);
logline("T-",str);
pause();
sys_status&=~SS_ABORT;
for(i=0;i<j;i++)
free(file[i]);
}
}
return(0);
}
BOOL read_node_cfg(scfg_t* cfg, char* error)
{
char c,str[MAX_PATH+1],fname[13];
int i;
int16_t n;
long offset=0;
FILE *instream;
strcpy(fname,"node.cnf");
sprintf(str,"%s%s",cfg->node_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d (%s) opening %s",errno,STRERROR(errno),str);
return(FALSE);
}
get_int(cfg->node_num,instream);
if(!cfg->node_num) {
sprintf(error,"offset %ld in %s, Node number must be non-zero"
,offset,fname);
fclose(instream);
return(FALSE);
}
get_str(cfg->node_name,instream);
get_str(cfg->node_phone,instream);
get_str(cfg->node_comspec,instream);
#ifdef __OS2__
if(!cfg->node_comspec[0])
strcpy(cfg->node_comspec,"C:\\OS2\\MDOS\\COMMAND.COM");
#endif
get_int(cfg->node_misc,instream);
get_int(cfg->node_ivt,instream);
get_int(cfg->node_swap,instream);
get_str(cfg->node_swapdir,instream);
get_int(cfg->node_valuser,instream);
get_int(cfg->node_minbps,instream);
get_str(cfg->node_arstr,instream);
cfg->node_ar=ARSTR(cfg->node_arstr, cfg);
get_int(cfg->node_dollars_per_call,instream);
get_str(cfg->node_editor,instream);
get_str(cfg->node_viewer,instream);
get_str(cfg->node_daily,instream);
get_int(c,instream);
if(c) cfg->node_scrnlen=c;
get_int(cfg->node_scrnblank,instream);
get_str(cfg->text_dir,instream); /* ctrl directory */
get_str(cfg->text_dir,instream); /* text directory */
get_str(cfg->temp_dir,instream); /* temp directory */
#if 0 /* removed Sep-9-2003, always use nodex/temp (rrs) */
if(!cfg->temp_dir[0])
#endif
strcpy(cfg->temp_dir,"temp");
for(i=0;i<10;i++) /* WFC 0-9 DOS commands */
get_str(cfg->wfc_cmd[i],instream);
for(i=0;i<12;i++) /* WFC F1-F12 shrinking DOS cmds */
get_str(cfg->wfc_scmd[i],instream);
get_str(cfg->mdm_hang,instream);
get_int(cfg->node_sem_check,instream);
if(!cfg->node_sem_check) cfg->node_sem_check=60;
get_int(cfg->node_stat_check,instream);
if(!cfg->node_stat_check) cfg->node_stat_check=10;
get_str(cfg->scfg_cmd,instream);
if(!cfg->scfg_cmd[0])
strcpy(cfg->scfg_cmd,"%!scfg %k");
get_int(cfg->sec_warn,instream);
if(!cfg->sec_warn)
cfg->sec_warn=180;
get_int(cfg->sec_hangup,instream);
if(!cfg->sec_hangup)
cfg->sec_hangup=300;
for(i=0;i<188;i++) { /* Unused - initialized to NULL */
fread(&n,1,2,instream);
offset+=2; }
for(i=0;i<256;i++) { /* Unused - initialized to 0xff */
fread(&n,1,2,instream);
offset+=2; }
/***************/
/* Modem Stuff */
/***************/
get_int(cfg->com_port,instream);
get_int(cfg->com_irq,instream);
get_int(cfg->com_base,instream);
get_int(cfg->com_rate,instream);
get_int(cfg->mdm_misc,instream);
get_str(cfg->mdm_init,instream);
get_str(cfg->mdm_spec,instream);
get_str(cfg->mdm_term,instream);
get_str(cfg->mdm_dial,instream);
get_str(cfg->mdm_offh,instream);
get_str(cfg->mdm_answ,instream);
get_int(cfg->mdm_reinit,instream);
get_int(cfg->mdm_ansdelay,instream);
get_int(cfg->mdm_rings,instream);
get_int(cfg->mdm_results,instream);
if(cfg->mdm_results) {
if((cfg->mdm_result=(mdm_result_t *)malloc(sizeof(mdm_result_t)*cfg->mdm_results))
==NULL)
return allocerr(instream,error,offset,fname,sizeof(mdm_result_t *)*cfg->mdm_results);
} else
cfg->mdm_result=NULL;
for(i=0;i<cfg->mdm_results;i++) {
if(feof(instream)) break;
get_int(cfg->mdm_result[i].code,instream);
get_int(cfg->mdm_result[i].rate,instream);
get_int(cfg->mdm_result[i].cps,instream);
get_str(cfg->mdm_result[i].str,instream);
}
cfg->mdm_results=i;
fclose(instream);
return(TRUE);
}
BOOL read_msgs_cfg(scfg_t* cfg, char* error)
{
char str[MAX_PATH+1],fname[13],c;
short i,j;
int16_t n,k;
long offset=0;
FILE *instream;
strcpy(fname,"msgs.cnf");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d (%s) opening %s",errno,STRERROR(errno),str);
return(FALSE);
}
/*************************/
/* General Message Stuff */
/*************************/
get_int(cfg->max_qwkmsgs,instream);
get_int(cfg->mail_maxcrcs,instream);
get_int(cfg->mail_maxage,instream);
get_str(cfg->preqwk_arstr,instream);
cfg->preqwk_ar=ARSTR(cfg->preqwk_arstr,cfg);
get_int(cfg->smb_retry_time,instream); /* odd byte */
if(!cfg->smb_retry_time)
cfg->smb_retry_time=30;
get_int(cfg->max_qwkmsgage, instream);
for(i=0;i<233;i++) /* NULL */
get_int(n,instream);
get_int(cfg->msg_misc,instream);
for(i=0;i<255;i++) /* 0xff */
get_int(n,instream);
/******************/
/* Message Groups */
/******************/
get_int(cfg->total_grps,instream);
if(cfg->total_grps) {
if((cfg->grp=(grp_t **)malloc(sizeof(grp_t *)*cfg->total_grps))==NULL)
return allocerr(instream,error,offset,fname,sizeof(grp_t *)*cfg->total_grps);
} else
cfg->grp=NULL;
for(i=0;i<cfg->total_grps;i++) {
if(feof(instream)) break;
if((cfg->grp[i]=(grp_t *)malloc(sizeof(grp_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(grp_t));
memset(cfg->grp[i],0,sizeof(grp_t));
get_str(cfg->grp[i]->lname,instream);
get_str(cfg->grp[i]->sname,instream);
get_str(cfg->grp[i]->arstr,instream);
cfg->grp[i]->ar=ARSTR(cfg->grp[i]->arstr,cfg);
get_str(cfg->grp[i]->code_prefix,instream);
get_int(c,instream);
for(j=0;j<43;j++)
get_int(n,instream);
}
cfg->total_grps=i;
/**********************/
/* Message Sub-boards */
/**********************/
get_int(cfg->total_subs,instream);
if(cfg->total_subs) {
if((cfg->sub=(sub_t **)malloc(sizeof(sub_t *)*cfg->total_subs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(sub_t *)*cfg->total_subs);
} else
cfg->sub=NULL;
for(i=0;i<cfg->total_subs;i++) {
if(feof(instream)) break;
if((cfg->sub[i]=(sub_t *)malloc(sizeof(sub_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(sub_t));
memset(cfg->sub[i],0,sizeof(sub_t));
get_int(cfg->sub[i]->grp,instream);
get_str(cfg->sub[i]->lname,instream);
get_str(cfg->sub[i]->sname,instream);
get_str(cfg->sub[i]->qwkname,instream);
get_str(cfg->sub[i]->code_suffix,instream);
get_str(cfg->sub[i]->data_dir,instream);
#ifdef SBBS
if(cfg->sub[i]->grp >= cfg->total_grps) {
sprintf(error,"offset %ld in %s: invalid group number (%u) for sub-board: %s"
,offset,fname
,cfg->sub[i]->grp
,cfg->sub[i]->code_suffix);
fclose(instream);
return(FALSE);
}
#endif
get_str(cfg->sub[i]->arstr,instream);
get_str(cfg->sub[i]->read_arstr,instream);
get_str(cfg->sub[i]->post_arstr,instream);
get_str(cfg->sub[i]->op_arstr,instream);
cfg->sub[i]->ar=ARSTR(cfg->sub[i]->arstr,cfg);
cfg->sub[i]->read_ar=ARSTR(cfg->sub[i]->read_arstr,cfg);
cfg->sub[i]->post_ar=ARSTR(cfg->sub[i]->post_arstr,cfg);
cfg->sub[i]->op_ar=ARSTR(cfg->sub[i]->op_arstr,cfg);
get_int(cfg->sub[i]->misc,instream);
get_str(cfg->sub[i]->tagline,instream);
get_str(cfg->sub[i]->origline,instream);
get_str(cfg->sub[i]->post_sem,instream);
#if 0
fread(str,1,LEN_DIR+1,instream); /* skip EchoMail path */
offset+=LEN_DIR+1;
#else
get_str(cfg->sub[i]->newsgroup,instream);
#endif
get_int(cfg->sub[i]->faddr,instream); /* FidoNet address */
get_int(cfg->sub[i]->maxmsgs,instream);
get_int(cfg->sub[i]->maxcrcs,instream);
get_int(cfg->sub[i]->maxage,instream);
get_int(cfg->sub[i]->ptridx,instream);
#ifdef SBBS
for(j=0;j<i;j++)
if(cfg->sub[i]->ptridx==cfg->sub[j]->ptridx) {
sprintf(error,"offset %ld in %s: Duplicate pointer index for subs %s and %s"
,offset,fname
,cfg->sub[i]->code_suffix,cfg->sub[j]->code_suffix);
fclose(instream);
return(FALSE);
}
#endif
get_str(cfg->sub[i]->mod_arstr,instream);
cfg->sub[i]->mod_ar=ARSTR(cfg->sub[i]->mod_arstr,cfg);
get_int(cfg->sub[i]->qwkconf,instream);
get_int(c,instream);
for(j=0;j<26;j++)
get_int(n,instream);
}
cfg->total_subs=i;
/***********/
/* FidoNet */
/***********/
get_int(cfg->total_faddrs,instream);
if(cfg->total_faddrs) {
if((cfg->faddr=(faddr_t *)malloc(sizeof(faddr_t)*cfg->total_faddrs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(faddr_t)*cfg->total_faddrs);
} else
cfg->faddr=NULL;
for(i=0;i<cfg->total_faddrs;i++)
get_int(cfg->faddr[i],instream);
get_str(cfg->origline,instream);
get_str(cfg->netmail_sem,instream);
get_str(cfg->echomail_sem,instream);
get_str(cfg->netmail_dir,instream);
get_str(cfg->echomail_dir,instream);
get_str(cfg->fidofile_dir,instream);
get_int(cfg->netmail_misc,instream);
get_int(cfg->netmail_cost,instream);
get_int(cfg->dflt_faddr,instream);
for(i=0;i<28;i++)
get_int(n,instream);
/**********/
/* QWKnet */
/**********/
get_str(cfg->qnet_tagline,instream);
get_int(cfg->total_qhubs,instream);
if(cfg->total_qhubs) {
if((cfg->qhub=(qhub_t **)malloc(sizeof(qhub_t *)*cfg->total_qhubs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(qhub_t*)*cfg->total_qhubs);
} else
cfg->qhub=NULL;
for(i=0;i<cfg->total_qhubs;i++) {
if(feof(instream)) break;
if((cfg->qhub[i]=(qhub_t *)malloc(sizeof(qhub_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(qhub_t));
memset(cfg->qhub[i],0,sizeof(qhub_t));
get_str(cfg->qhub[i]->id,instream);
get_int(cfg->qhub[i]->time,instream);
get_int(cfg->qhub[i]->freq,instream);
get_int(cfg->qhub[i]->days,instream);
get_int(cfg->qhub[i]->node,instream);
get_str(cfg->qhub[i]->call,instream);
get_str(cfg->qhub[i]->pack,instream);
get_str(cfg->qhub[i]->unpack,instream);
get_int(k,instream);
if(k) {
if((cfg->qhub[i]->sub=(ulong *)malloc(sizeof(ulong)*k))==NULL)
return allocerr(instream,error,offset,fname,sizeof(ulong)*k);
if((cfg->qhub[i]->conf=(ushort *)malloc(sizeof(ushort)*k))==NULL)
return allocerr(instream,error,offset,fname,sizeof(ushort)*k);
if((cfg->qhub[i]->mode=(char *)malloc(sizeof(char)*k))==NULL)
return allocerr(instream,error,offset,fname,sizeof(uchar)*k);
}
for(j=0;j<k;j++) {
uint16_t subnum;
if(feof(instream)) break;
get_int(cfg->qhub[i]->conf[cfg->qhub[i]->subs],instream);
get_int(subnum,instream);
cfg->qhub[i]->sub[cfg->qhub[i]->subs]=subnum;
get_int(cfg->qhub[i]->mode[cfg->qhub[i]->subs],instream);
if(cfg->qhub[i]->sub[cfg->qhub[i]->subs]<cfg->total_subs)
cfg->sub[cfg->qhub[i]->sub[cfg->qhub[i]->subs]]->misc|=SUB_QNET;
else
continue;
if(cfg->qhub[i]->sub[cfg->qhub[i]->subs]!=INVALID_SUB)
cfg->qhub[i]->subs++; }
for(j=0;j<32;j++)
get_int(n,instream);
}
cfg->total_qhubs=i;
for(j=0;j<32;j++)
get_int(n,instream);
/************/
/* PostLink */
/************/
fread(str,11,1,instream); /* Unused - used to be Site Name */
offset+=11;
get_int(cfg->sys_psnum,instream); /* Site Number */
get_int(cfg->total_phubs,instream);
if(cfg->total_phubs) {
if((cfg->phub=(phub_t **)malloc(sizeof(phub_t *)*cfg->total_phubs))==NULL)
return allocerr(instream,error,offset,fname,sizeof(phub_t*)*cfg->total_phubs);
} else
cfg->phub=NULL;
for(i=0;i<cfg->total_phubs;i++) {
if(feof(instream)) break;
if((cfg->phub[i]=(phub_t *)malloc(sizeof(phub_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(phub_t));
memset(cfg->phub[i],0,sizeof(phub_t));
get_str(cfg->phub[i]->name,instream);
get_int(cfg->phub[i]->time,instream);
get_int(cfg->phub[i]->freq,instream);
get_int(cfg->phub[i]->days,instream);
get_int(cfg->phub[i]->node,instream);
get_str(cfg->phub[i]->call,instream);
for(j=0;j<32;j++)
get_int(n,instream);
}
cfg->total_phubs=i;
get_str(cfg->sys_psname,instream); /* Site Name */
for(j=0;j<32;j++)
get_int(n,instream);
/************/
/* Internet */
/************/
get_str(cfg->sys_inetaddr,instream); /* Internet address */
get_str(cfg->inetmail_sem,instream);
get_int(cfg->inetmail_misc,instream);
get_int(cfg->inetmail_cost,instream);
get_str(cfg->smtpmail_sem,instream);
fclose(instream);
return(TRUE);
}
BOOL read_main_cfg(scfg_t* cfg, char* error)
{
char str[MAX_PATH+1],fname[13],c;
short i,j;
int16_t n;
long offset=0;
FILE *instream;
strcpy(fname,"main.cnf");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d (%s) opening %s",errno,STRERROR(errno),str);
return(FALSE);
}
get_str(cfg->sys_name,instream);
get_str(cfg->sys_id,instream);
get_str(cfg->sys_location,instream);
get_str(cfg->sys_phonefmt,instream);
get_str(cfg->sys_op,instream);
get_str(cfg->sys_guru,instream);
get_str(cfg->sys_pass,instream);
get_int(cfg->sys_nodes,instream);
#if 0 /* removed Jan-10-2003: cfg->node_num may be old or uninitialized */
if(!cfg->sys_nodes || cfg->sys_nodes<cfg->node_num || cfg->sys_nodes>MAX_NODES) {
if(!cfg->sys_nodes)
sprintf(error,"Total nodes on system must be non-zero.");
else if(cfg->sys_nodes>MAX_NODES)
sprintf(error,"Total nodes exceeds %u.",MAX_NODES);
else
sprintf(error,"Total nodes (%u) < node number in NODE.CNF (%u)"
,cfg->sys_nodes,cfg->node_num);
fclose(instream);
return(FALSE);
}
#endif
for(i=0;i<cfg->sys_nodes;i++) {
get_str(cfg->node_path[i],instream);
#if defined(__unix__)
strlwr(cfg->node_path[i]);
#endif
}
get_str(cfg->data_dir,instream); /* data directory */
get_str(cfg->exec_dir,instream); /* exec directory */
get_str(cfg->sys_logon,instream);
get_str(cfg->sys_logout,instream);
get_str(cfg->sys_daily,instream);
get_int(cfg->sys_timezone,instream);
get_int(cfg->sys_misc,instream);
get_int(cfg->sys_lastnode,instream);
get_int(cfg->sys_autonode,instream);
get_int(cfg->uq,instream);
get_int(cfg->sys_pwdays,instream);
get_int(cfg->sys_deldays,instream);
get_int(cfg->sys_exp_warn,instream); /* Days left till expiration warning */
get_int(cfg->sys_autodel,instream);
get_int(cfg->sys_def_stat,instream); /* default status line */
get_str(cfg->sys_chat_arstr,instream);
cfg->sys_chat_ar=ARSTR(cfg->sys_chat_arstr,cfg);
get_int(cfg->cdt_min_value,instream);
get_int(cfg->max_minutes,instream);
get_int(cfg->cdt_per_dollar,instream);
get_str(cfg->new_pass,instream);
get_str(cfg->new_magic,instream);
get_str(cfg->new_sif,instream);
get_str(cfg->new_sof,instream);
if(!cfg->new_sof[0]) /* if output not specified, use input file */
strcpy(cfg->new_sof,cfg->new_sif);
/*********************/
/* New User Settings */
/*********************/
get_int(cfg->new_level,instream);
get_int(cfg->new_flags1,instream);
get_int(cfg->new_flags2,instream);
get_int(cfg->new_flags3,instream);
get_int(cfg->new_flags4,instream);
get_int(cfg->new_exempt,instream);
get_int(cfg->new_rest,instream);
get_int(cfg->new_cdt,instream);
get_int(cfg->new_min,instream);
get_str(cfg->new_xedit,instream);
get_int(cfg->new_expire,instream);
get_int(cfg->new_shell,instream);
get_int(cfg->new_misc,instream);
get_int(cfg->new_prot,instream);
if(cfg->new_prot<' ')
cfg->new_prot=' ';
get_int(cfg->new_install,instream);
for(i=0;i<7;i++)
get_int(n,instream);
/*************************/
/* Expired User Settings */
/*************************/
get_int(cfg->expired_level,instream);
get_int(cfg->expired_flags1,instream);
get_int(cfg->expired_flags2,instream);
get_int(cfg->expired_flags3,instream);
get_int(cfg->expired_flags4,instream);
get_int(cfg->expired_exempt,instream);
get_int(cfg->expired_rest,instream);
get_str(cfg->logon_mod,instream);
get_str(cfg->logoff_mod,instream);
get_str(cfg->newuser_mod,instream);
get_str(cfg->login_mod,instream);
if(!cfg->login_mod[0]) SAFECOPY(cfg->login_mod,"login");
get_str(cfg->logout_mod,instream);
get_str(cfg->sync_mod,instream);
get_str(cfg->expire_mod,instream);
get_int(cfg->ctrlkey_passthru,instream);
get_str(cfg->mods_dir,instream);
get_str(cfg->logs_dir,instream);
if(!cfg->logs_dir[0]) SAFECOPY(cfg->logs_dir,cfg->data_dir);
get_int(c,instream);
for(i=0;i<158;i++) /* unused - initialized to NULL */
get_int(n,instream);
for(i=0;i<254;i++) /* unused - initialized to 0xff */
get_int(n,instream);
get_int(cfg->user_backup_level,instream);
if(cfg->user_backup_level==0xffff)
cfg->user_backup_level=5;
get_int(cfg->mail_backup_level,instream);
if(cfg->mail_backup_level==0xffff)
cfg->mail_backup_level=5;
/*******************/
/* Validation Sets */
/*******************/
for(i=0;i<10 && !feof(instream);i++) {
get_int(cfg->val_level[i],instream);
get_int(cfg->val_expire[i],instream);
get_int(cfg->val_flags1[i],instream);
get_int(cfg->val_flags2[i],instream);
get_int(cfg->val_flags3[i],instream);
get_int(cfg->val_flags4[i],instream);
get_int(cfg->val_cdt[i],instream);
get_int(cfg->val_exempt[i],instream);
get_int(cfg->val_rest[i],instream);
for(j=0;j<8;j++)
get_int(n,instream);
}
/***************************/
/* Security Level Settings */
/***************************/
for(i=0;i<100 && !feof(instream);i++) {
get_int(cfg->level_timeperday[i],instream);
#if 0 /* removed May 06, 2002 */
if(cfg->level_timeperday[i]>500)
cfg->level_timeperday[i]=500;
#endif
get_int(cfg->level_timepercall[i],instream);
#if 0 /* removed May 06, 2002 */
if(cfg->level_timepercall[i]>500)
cfg->level_timepercall[i]=500;
#endif
get_int(cfg->level_callsperday[i],instream);
get_int(cfg->level_freecdtperday[i],instream);
get_int(cfg->level_linespermsg[i],instream);
get_int(cfg->level_postsperday[i],instream);
get_int(cfg->level_emailperday[i],instream);
get_int(cfg->level_misc[i],instream);
get_int(cfg->level_expireto[i],instream);
get_int(c,instream);
for(j=0;j<5;j++)
get_int(n,instream);
}
if(i!=100) {
sprintf(error,"Insufficient User Level Information: "
"%d user levels read, 100 needed.",i);
fclose(instream);
return(FALSE);
}
get_int(cfg->total_shells,instream);
#ifdef SBBS
if(!cfg->total_shells) {
sprintf(error,"At least one command shell must be configured.");
fclose(instream);
return(FALSE);
}
#endif
if(cfg->total_shells) {
if((cfg->shell=(shell_t **)malloc(sizeof(shell_t *)*cfg->total_shells))==NULL)
return allocerr(instream,error,offset,fname,sizeof(shell_t *)*cfg->total_shells);
} else
cfg->shell=NULL;
for(i=0;i<cfg->total_shells;i++) {
if(feof(instream)) break;
if((cfg->shell[i]=(shell_t *)malloc(sizeof(shell_t)))==NULL)
return allocerr(instream,error,offset,fname,sizeof(shell_t));
memset(cfg->shell[i],0,sizeof(shell_t));
get_str(cfg->shell[i]->name,instream);
get_str(cfg->shell[i]->code,instream);
get_str(cfg->shell[i]->arstr,instream);
cfg->shell[i]->ar=ARSTR(cfg->shell[i]->arstr,cfg);
get_int(cfg->shell[i]->misc,instream);
for(j=0;j<8;j++)
get_int(n,instream);
}
cfg->total_shells=i;
if(cfg->new_shell>=cfg->total_shells)
cfg->new_shell=0;
fclose(instream);
return(TRUE);
}
int sbbs_t::exec_misc(csi_t* csi, char *path)
{
char str[512],tmp[512],buf[1025],ch,op,*p,**pp,**pp1,**pp2;
ushort w;
uint i=0,j;
long l,*lp=NULL,*lp1=NULL,*lp2=NULL;
void *vp;
struct dirent *de;
struct tm tm;
switch(*(csi->ip++)) {
case CS_VAR_INSTRUCTION:
switch(*(csi->ip++)) { /* sub-op-code stored as next byte */
case PRINT_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp || !*pp) {
lp=getintvar(csi,*(long *)csi->ip);
if(lp)
bprintf("%ld",*lp); }
else
putmsg(cmdstr(*pp,path,csi->str,buf)
,P_SAVEATR|P_NOABORT|P_NOATCODES);
csi->ip+=4;
return(0);
case VAR_PRINTF:
case VAR_PRINTF_LOCAL:
op=*(csi->ip-1);
p=format_string(this, csi);
if(op==VAR_PRINTF)
putmsg(cmdstr(p,path,csi->str,buf),P_SAVEATR|P_NOABORT|P_NOATCODES);
else {
if(online==ON_LOCAL)
eprintf(LOG_INFO,"%s",cmdstr(p,path,csi->str,buf));
else
lputs(LOG_INFO,cmdstr(p,path,csi->str,buf));
}
free(p);
return(0);
case SHOW_VARS:
bprintf("shell str=(%08lX) %s\r\n"
,csi->str,csi->str);
for(i=0;i<csi->str_vars;i++)
bprintf("local str[%d]=(%08lX) (%08lX) %s\r\n"
,i,csi->str_var_name[i]
,csi->str_var[i]
,csi->str_var[i]);
for(i=0;i<csi->int_vars;i++)
bprintf("local int[%d]=(%08lX) (%08lX) %ld\r\n"
,i,csi->int_var_name[i]
,csi->int_var[i]
,csi->int_var[i]);
for(i=0;i<global_str_vars;i++)
bprintf("global str[%d]=(%08lX) (%08lX) %s\r\n"
,i,global_str_var_name[i]
,global_str_var[i]
,global_str_var[i]);
for(i=0;i<global_int_vars;i++)
bprintf("global int[%d]=(%08lX) (%08lX) %ld\r\n"
,i,global_int_var_name[i]
,global_int_var[i]
,global_int_var[i]);
return(0);
case DEFINE_STR_VAR:
if(getstrvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
csi->str_vars++;
csi->str_var=(char **)realloc(csi->str_var
,sizeof(char *)*csi->str_vars);
csi->str_var_name=(long *)realloc(csi->str_var_name
,sizeof(long)*csi->str_vars);
if(csi->str_var==NULL
|| csi->str_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local str var"
,sizeof(char *)*csi->str_vars);
if(csi->str_var_name) {
free(csi->str_var_name);
csi->str_var_name=0; }
if(csi->str_var) {
free(csi->str_var);
csi->str_var=0; }
csi->str_vars=0; }
else {
csi->str_var_name[csi->str_vars-1]=*(long *)csi->ip;
csi->str_var[csi->str_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_INT_VAR:
if(getintvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
csi->int_vars++;
csi->int_var=(long *)realloc(csi->int_var
,sizeof(char *)*csi->int_vars);
csi->int_var_name=(long *)realloc(csi->int_var_name
,sizeof(long)*csi->int_vars);
if(csi->int_var==NULL
|| csi->int_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local int var"
,sizeof(char *)*csi->int_vars);
if(csi->int_var_name) {
free(csi->int_var_name);
csi->int_var_name=0; }
if(csi->int_var) {
free(csi->int_var);
csi->int_var=0; }
csi->int_vars=0; }
else {
csi->int_var_name[csi->int_vars-1]=*(long *)csi->ip;
csi->int_var[csi->int_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_GLOBAL_STR_VAR:
if(getstrvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
global_str_vars++;
global_str_var=(char **)realloc(global_str_var
,sizeof(char *)*global_str_vars);
global_str_var_name=(long *)realloc(global_str_var_name
,sizeof(long)*global_str_vars);
if(global_str_var==NULL
|| global_str_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"global str var"
,sizeof(char *)*global_str_vars);
if(global_str_var_name) {
free(global_str_var_name);
global_str_var_name=0; }
if(global_str_var) {
free(global_str_var);
global_str_var=0; }
global_str_vars=0; }
else {
global_str_var_name[global_str_vars-1]=
*(long *)csi->ip;
global_str_var[global_str_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_GLOBAL_INT_VAR:
if(getintvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
global_int_vars++;
global_int_var=(long *)realloc(global_int_var
,sizeof(char *)*global_int_vars);
global_int_var_name=(long *)realloc(global_int_var_name
,sizeof(long)*global_int_vars);
if(global_int_var==NULL
|| global_int_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local int var"
,sizeof(char *)*global_int_vars);
if(global_int_var_name) {
free(global_int_var_name);
global_int_var_name=0; }
if(global_int_var) {
free(global_int_var);
global_int_var=0; }
global_int_vars=0; }
else {
global_int_var_name[global_int_vars-1]
=*(long *)csi->ip;
global_int_var[global_int_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case SET_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp)
*pp=copystrvar(csi,*pp
,cmdstr((char *)csi->ip,path,csi->str,buf));
while(*(csi->ip++)); /* Find NULL */
return(0);
case SET_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(lp)
*lp=*(long *)csi->ip;
csi->ip+=4; /* Skip value */
return(0);
case COMPARE_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp)
csi->logic=stricmp(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf));
else { /* Uninitialized str var */
if(*(csi->ip)==0) /* Blank static str */
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE; }
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRSTR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp && strstr(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf)))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRNCMP_VAR:
i=*csi->ip++;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp)
csi->logic=strnicmp(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf),i);
else
csi->logic=LOGIC_FALSE;
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRNCMP_VARS:
i=*csi->ip++;
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2)
csi->logic=strnicmp(*pp1,*pp2,i);
else
csi->logic=LOGIC_FALSE;
return(0);
case STRSTR_VARS:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2 && strstr(*pp1,*pp2))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case COMPARE_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
l=*(long *)csi->ip;
csi->ip+=4; /* Skip static value */
if(!lp) { /* Unknown variable */
csi->logic=LOGIC_FALSE;
return(0); }
if(*lp>l)
csi->logic=LOGIC_GREATER;
else if(*lp<l)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0);
case COMPARE_VARS:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(((!pp1 || !*pp1) && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
if(pp1 && pp2) /* Both unitialized or blank */
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0); }
if(pp1) { /* ASCII */
if(!pp2) {
ultoa(*lp2,tmp,10);
csi->logic=stricmp(*pp1,tmp); }
else
csi->logic=stricmp(*pp1,*pp2);
return(0); }
/* Binary */
if(!lp2) {
l=strtol(*pp2,0,0);
if(*lp1>l)
csi->logic=LOGIC_GREATER;
else if(*lp1<l)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0); }
if(*lp1>*lp2)
csi->logic=LOGIC_GREATER;
else if(*lp1<*lp2)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0);
case COPY_VAR:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if((!pp1 && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(pp1) { /* ASCII */
if(!pp2)
ultoa(*lp2,tmp,10);
else
strcpy(tmp,*pp2);
*pp1=copystrvar(csi,*pp1,tmp);
return(0); }
if(!lp2)
*lp1=strtol(*pp2,0,0);
else
*lp1=*lp2;
return(0);
case SWAP_VARS:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(((!pp1 || !*pp1) && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(pp1) { /* ASCII */
if(!pp2) {
if(!strnicmp(*pp2,"0x",2)) {
l=strtol((*pp1)+2,0,16);
ultoa(*lp2,tmp,16); }
else {
l=atol(*pp1);
ultoa(*lp2,tmp,10); }
*pp1=copystrvar(csi,*pp1,tmp);
*lp2=l; }
else {
p=*pp1;
*pp1=*pp2;
*pp2=p; }
return(0); }
/* Binary */
if(!lp2) {
if(!strnicmp(*pp2,"0x",2)) {
l=strtol((*pp2)+2,0,16);
ultoa(*lp1,tmp,16); }
else {
l=atol(*pp2);
ultoa(*lp1,tmp,10); }
*pp2=copystrvar(csi,*pp2,tmp);
*lp1=l; }
else {
l=*lp1;
*lp1=*lp2;
*lp2=l; }
return(0);
case CAT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
strcpy(tmp,(char *)csi->ip);
while(*(csi->ip++));
if(pp && *pp)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp==sysvar_p[i])
break;
if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
if(*pp)
*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
else
*pp=(char *)realloc(*pp,strlen(tmp)+1); }
if(pp && *pp)
strcat(*pp,tmp);
return(0);
case CAT_STR_VARS:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip dest variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip source variable name */
/* Concatenate an int var to a str var (as char) */
if(pp2==NULL) {
lp=getintvar(csi,*(long *)(csi->ip-4));
if(lp==NULL) {
csi->logic=LOGIC_FALSE;
return(0);
}
pp=pp1;
tmp[0]=(uchar)*lp;
tmp[1]=0;
if(pp && *pp)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp==sysvar_p[i])
break;
if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
if(*pp)
*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
else
*pp=(char *)realloc(*pp,strlen(tmp)+1); }
if(pp && *pp)
strcat(*pp,tmp);
return(0);
}
if(!pp1 || !pp2 || !*pp2) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(*pp1)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp1==sysvar_p[i])
break;
if(*pp1!=csi->str && (!*pp1 || i==MAX_SYSVARS)) {
if(*pp1)
*pp1=(char *)realloc(*pp1,strlen(*pp1)+strlen(*pp2)+1);
else
*pp1=(char *)realloc(*pp1,strlen(*pp2)+1); }
strcat(*pp1,*pp2);
return(0);
case FORMAT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
p=format_string(this, csi);
cmdstr(p,path,csi->str,str);
if(pp)
*pp=copystrvar(csi,*pp,str);
free(p);
return(0);
case FORMAT_TIME_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
strcpy(str,(char *)csi->ip);
while(*(csi->ip++)); /* Find NULL */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && lp) {
if(localtime_r((time_t *)lp,&tm)!=NULL) {
strftime(buf,128,str,&tm);
*pp=copystrvar(csi,*pp,buf);
}
}
return(0);
case TIME_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
strcpy(str,timestr((time_t *)lp));
*pp=copystrvar(csi,*pp,str); }
return(0);
case DATE_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
unixtodstr(&cfg,*lp,str);
*pp=copystrvar(csi,*pp,str); }
return(0);
case SECOND_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
sectostr(*lp,str);
*pp=copystrvar(csi,*pp,str); }
return(0);
case STRUPR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strupr(*pp);
return(0);
case STRLWR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strlwr(*pp);
return(0);
case TRUNCSP_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
truncsp(*pp);
return(0);
case STRIP_CTRL_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strip_ctrl(*pp);
return(0);
case ADD_INT_VAR:
case SUB_INT_VAR:
case MUL_INT_VAR:
case DIV_INT_VAR:
case MOD_INT_VAR:
case AND_INT_VAR:
case OR_INT_VAR:
case NOT_INT_VAR:
case XOR_INT_VAR:
i=*(csi->ip-1);
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
if(!lp)
return(0);
switch(i) {
case ADD_INT_VAR:
*lp+=l;
break;
case SUB_INT_VAR:
*lp-=l;
break;
case MUL_INT_VAR:
*lp*=l;
break;
case DIV_INT_VAR:
*lp/=l;
break;
case MOD_INT_VAR:
*lp%=l;
break;
case AND_INT_VAR:
*lp&=l;
break;
case OR_INT_VAR:
*lp|=l;
break;
case NOT_INT_VAR:
*lp&=~l;
break;
case XOR_INT_VAR:
*lp^=l;
break; }
return(0);
case COMPARE_ANY_BITS:
case COMPARE_ALL_BITS:
i=*(csi->ip-1);
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(!lp)
return(0);
if(i==COMPARE_ANY_BITS) {
if(((*lp)&l)!=0)
csi->logic=LOGIC_TRUE;
} else {
if(((*lp)&l)==l)
csi->logic=LOGIC_TRUE;
}
return(0);
case ADD_INT_VARS:
case SUB_INT_VARS:
case MUL_INT_VARS:
case DIV_INT_VARS:
case MOD_INT_VARS:
case AND_INT_VARS:
case OR_INT_VARS:
case NOT_INT_VARS:
case XOR_INT_VARS:
i=*(csi->ip-1);
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
if(!lp2) {
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp || !*pp)
return(0);
l=strtol(*pp,0,0); }
else
l=*lp2;
csi->ip+=4;
if(!lp1)
return(0);
switch(i) {
case ADD_INT_VARS:
*lp1+=l;
break;
case SUB_INT_VARS:
*lp1-=l;
break;
case MUL_INT_VARS:
*lp1*=l;
break;
case DIV_INT_VARS:
*lp1/=l;
break;
case MOD_INT_VARS:
*lp1%=l;
break;
case AND_INT_VARS:
*lp1&=l;
break;
case OR_INT_VARS:
*lp1|=l;
break;
case NOT_INT_VARS:
*lp1&=~l;
break;
case XOR_INT_VARS:
*lp1^=l;
break; }
return(0);
case RANDOM_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
if(lp)
*lp=sbbs_random(l);
return(0);
case TIME_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp)
*lp=time(NULL);
return(0);
case DATE_STR_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && pp && *pp)
*lp=dstrtounix(&cfg,*pp);
return(0);
case STRLEN_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=strlen(*pp);
else
*lp=0; }
return(0);
case CRC16_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=crc16(*pp,0);
else
*lp=0; }
return(0);
case CRC32_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=crc32(*pp,0);
else
*lp=0; }
return(0);
case CHKSUM_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
*lp=0;
if(pp && *pp) {
i=0;
while(*((*pp)+i))
*lp+=(uchar)*((*pp)+(i++)); } }
return(0);
case FLENGTH_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=flength(*pp);
else
*lp=0; }
return(0);
case FTIME_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=fdate(*pp);
else
*lp=0; }
return(0);
case CHARVAL_TO_INT:
case COPY_FIRST_CHAR: // duplicate functionality - doh!
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=**pp;
else
*lp=0; }
return(0);
case GETSTR_VAR:
case GETLINE_VAR:
case GETNAME_VAR:
case GETSTRUPR_VAR:
case GETSTR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(csi->ip++);
csi->logic=LOGIC_FALSE;
switch(*(csi->ip-6)) {
case GETNAME_VAR:
getstr(buf,i,K_UPRLWR);
break;
case GETSTRUPR_VAR:
getstr(buf,i,K_UPPER);
break;
case GETLINE_VAR:
getstr(buf,i,K_LINE);
break;
case GETSTR_MODE:
l=*(long *)csi->ip;
csi->ip+=4;
if(l&K_EDIT) {
if(pp && *pp)
strcpy(buf,*pp);
else
buf[0]=0; }
getstr(buf,i,l);
break;
default:
getstr(buf,i,0); }
if(sys_status&SS_ABORT)
return(0);
if(pp) {
*pp=copystrvar(csi,*pp,buf);
csi->logic=LOGIC_TRUE; }
return(0);
case GETNUM_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)csi->ip;
csi->ip+=2;
csi->logic=LOGIC_FALSE;
l=getnum(i);
if(!pp && !lp)
return(0);
if(pp) {
if(l<=0)
str[0]=0;
else
ultoa(l,str,10);
*pp=copystrvar(csi,*pp,str);
csi->logic=LOGIC_TRUE;
return(0); }
if(lp) {
*lp=l;
csi->logic=LOGIC_TRUE; }
return(0);
case SHIFT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(csi->ip++);
if(!pp || !*pp)
return(0);
if(strlen(*pp)>=i)
memmove(*pp,*pp+i,strlen(*pp)+1);
return(0);
case SHIFT_TO_FIRST_CHAR:
case SHIFT_TO_LAST_CHAR:
i=*(csi->ip-1);
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
ch=*(csi->ip++);
csi->logic=LOGIC_FALSE;
if(!pp || !*pp)
return(0);
if(i==SHIFT_TO_FIRST_CHAR)
p=strchr(*pp,ch);
else /* _TO_LAST_CHAR */
p=strrchr(*pp,ch);
if(p==NULL)
return(0);
csi->logic=LOGIC_TRUE;
i=p-*pp;
if(i>0)
memmove(*pp,*pp+i,strlen(p)+1);
return(0);
case CHKFILE_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && fexistcase(cmdstr(*pp,path,csi->str,buf)))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case PRINTFILE_VAR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)(csi->ip);
csi->ip+=2;
if(pp && *pp)
printfile(*pp,i);
return(0);
case PRINTTAIL_VAR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)(csi->ip);
csi->ip+=2;
j=*csi->ip;
csi->ip++;
if(pp && *pp)
printtail(*pp,j,i);
return(0);
case TELNET_GATE_VAR:
l=*(ulong *)(csi->ip); // Mode
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
telnet_gate(*pp,l);
return(0);
case TELNET_GATE_STR:
l=*(ulong *)(csi->ip); // Mode
csi->ip+=4;
strcpy(str,(char *)csi->ip);
while(*(csi->ip++)); /* Find NULL */
telnet_gate(str,l);
return(0);
case COPY_CHAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(pp==NULL)
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp==NULL && lp!=NULL)
*lp=csi->cmd;
else if(pp!=NULL) {
sprintf(tmp,"%c",csi->cmd);
*pp=copystrvar(csi,*pp,tmp);
}
return(0);
case COMPARE_FIRST_CHAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
ch=*(csi->ip++); /* char const */
if(pp==NULL || *pp==NULL)
csi->logic=LOGIC_FALSE;
else {
if(**pp==ch)
csi->logic=LOGIC_EQUAL;
else if(**pp>ch)
csi->logic=LOGIC_GREATER;
else
csi->logic=LOGIC_LESS;
}
return(0);
case SEND_FILE_VIA:
case RECEIVE_FILE_VIA:
j=*(csi->ip-1);
ch=*(csi->ip++); /* Protocol */
cmdstr((char *)csi->ip,csi->str,csi->str,str);
while(*(csi->ip++)); /* Find NULL */
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
break;
csi->logic=LOGIC_FALSE;
if(i<cfg.total_prots)
if(protocol(cfg.prot[i],j==SEND_FILE_VIA ? XFER_DOWNLOAD : XFER_UPLOAD
,str,str,true)==0)
csi->logic=LOGIC_TRUE;
return(0);
case SEND_FILE_VIA_VAR:
case RECEIVE_FILE_VIA_VAR:
j=*(csi->ip-1);
ch=*(csi->ip++); /* Protocol */
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
break;
csi->logic=LOGIC_FALSE;
if(!pp || !(*pp))
return(0);
if(i<cfg.total_prots)
if(protocol(cfg.prot[i]
,j==SEND_FILE_VIA_VAR ? XFER_DOWNLOAD : XFER_UPLOAD
,*pp,*pp,true)==0)
csi->logic=LOGIC_TRUE;
return(0);
case MATCHUSER:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=matchuser(&cfg, *pp, TRUE /*sysop_alias*/);
else
*lp=0;
}
return(0);
default:
errormsg(WHERE,ERR_CHK,"var sub-instruction",*(csi->ip-1));
return(0); }
case CS_FIO_FUNCTION:
switch(*(csi->ip++)) { /* sub-op-code stored as next byte */
case FIO_OPEN:
case FIO_OPEN_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
w=*(ushort *)csi->ip;
csi->ip+=2;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-7)==FIO_OPEN) {
cmdstr((char *)csi->ip,path,csi->str,str);
while(*(csi->ip++)); } /* skip filename */
else {
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!pp || !*pp)
return(0);
strcpy(str,*pp); }
if(csi->files>=MAX_FOPENS)
return(0);
if(lp) {
/* Access flags are not cross-platform, so convert */
i=0;
if(w&0x001) i|=O_RDONLY;
if(w&0x002) i|=O_WRONLY;
if(w&0x004) i|=O_RDWR;
if(w&0x040) i|=O_DENYNONE;
if(w&0x100) i|=O_CREAT;
if(w&0x200) i|=O_TRUNC;
if(w&0x400) i|=O_EXCL;
if(w&0x800) i|=O_APPEND;
*lp=(long)fnopen((int *)&j,str,i);
if(*lp) {
for(i=0;i<csi->files;i++)
if(!csi->file[i])
break;
csi->file[i]=(FILE *)*lp;
if(i==csi->files)
csi->files++;
csi->logic=LOGIC_TRUE; } }
return(0);
case FIO_CLOSE:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && *lp) {
csi->logic=fclose((FILE *)*lp);
for(i=0;i<csi->files;i++)
if(csi->file[i]==(FILE *)*lp)
csi->file[i]=0;
*lp=0;
}
else
csi->logic=LOGIC_FALSE;
return(0);
case FIO_FLUSH:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && *lp)
csi->logic=fflush((FILE *)*lp);
else
csi->logic=LOGIC_FALSE;
return(0);
case FIO_READ:
case FIO_READ_VAR:
lp1=getintvar(csi,*(long *)csi->ip); /* Handle */
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-9)==FIO_READ) {
i=*(short *)csi->ip;
csi->ip+=2; /* Length */ }
else { /* FIO_READ_VAR */
vp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!vp)
return(0);
i=*(short *)vp; }
if(i>sizeof(buf)-1)
i=sizeof(buf)-1;
if(!lp1 || !(*lp1) || (!pp && !lp2))
return(0);
if(pp) {
if(i<1) {
if(*pp && **pp)
i=strlen(*pp);
else
i=128; }
if((j=fread(buf,1,i,(FILE *)*lp1))==i)
csi->logic=LOGIC_TRUE;
buf[j]=0;
if(csi->etx) {
p=strchr(buf,csi->etx);
if(p) *p=0; }
*pp=copystrvar(csi,*pp,buf); }
else {
*lp2=0;
if(i>4 || i<1) i=4;
if(fread(lp2,1,i,(FILE *)*lp1)==i)
csi->logic=LOGIC_TRUE; }
return(0);
case FIO_READ_LINE:
lp1=getintvar(csi,*(long *)csi->ip); /* Handle */
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(!lp1 || !(*lp1) || feof((FILE *)*lp1) || (!pp && !lp2))
return(0);
csi->logic=LOGIC_TRUE;
for(i=0;i<sizeof(buf)-1;i++) {
if(!fread(buf+i,1,1,(FILE *)*lp1))
break;
if(*(buf+i)==LF) {
i++;
break; } }
buf[i]=0;
if(csi->etx) {
p=strchr(buf,csi->etx);
if(p) *p=0; }
if(pp)
*pp=copystrvar(csi,*pp,buf);
else
*lp2=strtol(buf,0,0);
return(0);
case FIO_WRITE:
case FIO_WRITE_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-9)==FIO_WRITE) {
i=*(short *)csi->ip;
csi->ip+=2; /* Length */ }
else { /* FIO_WRITE_VAR */
vp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!vp)
return(0);
i=*(short *)vp; }
if(i>sizeof(buf)-1)
i=sizeof(buf)-1;
if(!lp1 || !(*lp1) || (!pp && !lp2) || (pp && !*pp))
return(0);
if(pp) {
j=strlen(*pp);
if(i<1) i=j;
if(j>i) j=i;
if(fwrite(*pp,1,j,(FILE *)*lp1)!=j)
csi->logic=LOGIC_FALSE;
else {
if(j<i) {
memset(buf,csi->etx,i-j);
fwrite(buf,1,i-j,(FILE *)*lp1);
}
csi->logic=LOGIC_TRUE;
}
} else {
if(i<1 || i>4) i=4;
if(fwrite(lp2,1,i,(FILE *)*lp1)==i)
csi->logic=LOGIC_TRUE; }
return(0);
case FIO_GET_LENGTH:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=filelength(fileno((FILE *)*lp1));
return(0);
case FIO_GET_TIME:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=filetime(fileno((FILE *)*lp1));
return(0);
case FIO_SET_TIME:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
#if 0 /* ftime */
if(lp1 && *lp1 && lp2) {
ft=unixtoftime(*lp2);
setftime(fileno((FILE *)*lp1),&ft); }
#endif
return(0);
case FIO_EOF:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(lp && *lp)
if(ftell((FILE *)*lp)>=filelength(fileno((FILE *)*lp)))
csi->logic=LOGIC_TRUE;
return(0);
case FIO_GET_POS:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=ftell((FILE *)*lp1);
return(0);
case FIO_SEEK:
case FIO_SEEK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_SEEK) {
l=*(long *)csi->ip;
csi->ip+=4; }
else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2) {
csi->ip+=2;
return(0); }
l=*lp2; }
i=*(short *)csi->ip;
csi->ip+=2;
if(lp1 && *lp1)
if(fseek((FILE *)*lp1,l,i)!=-1)
csi->logic=LOGIC_TRUE;
return(0);
case FIO_LOCK:
case FIO_LOCK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_LOCK) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2;
}
if(lp1 && *lp1) {
fflush((FILE *)*lp1);
csi->logic=!lock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l);
}
return(0);
case FIO_UNLOCK:
case FIO_UNLOCK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_UNLOCK) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2;
}
if(lp1 && *lp1) {
fflush((FILE *)*lp1);
csi->logic=!unlock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l);
}
return(0);
case FIO_SET_LENGTH:
case FIO_SET_LENGTH_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_SET_LENGTH) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2; }
if(lp1 && *lp1)
csi->logic=chsize(fileno((FILE *)*lp1),l);
return(0);
case FIO_PRINTF:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
p=format_string(this, csi);
if(lp1 && *lp1) {
cmdstr(p,path,csi->str,str);
fwrite(str,1,strlen(str),(FILE *)*lp1);
}
free(p);
return(0);
case FIO_SET_ETX:
csi->etx=*(csi->ip++);
return(0);
case REMOVE_FILE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && remove(*pp)==0)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case RENAME_FILE:
case COPY_FILE:
case MOVE_FILE:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2)
switch(*(csi->ip-9)) {
case RENAME_FILE:
csi->logic=rename(*pp1,*pp2);
break;
case COPY_FILE:
csi->logic=mv(*pp1,*pp2,1);
break;
case MOVE_FILE:
csi->logic=mv(*pp1,*pp2,0);
break; }
else
csi->logic=LOGIC_FALSE;
return(0);
case GET_FILE_ATTRIB:
case SET_FILE_ATTRIB:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && lp) {
if(*(csi->ip-9)==GET_FILE_ATTRIB)
*lp=getfattr(*pp);
else
*lp=CHMOD(*pp,(int)*lp);
}
return(0);
case MAKE_DIR:
case REMOVE_DIR:
case CHANGE_DIR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
switch(*(csi->ip-5)) {
case MAKE_DIR:
csi->logic=MKDIR(*pp);
break;
case REMOVE_DIR:
csi->logic=rmdir(*pp);
break;
case CHANGE_DIR:
csi->logic=chdir(*pp);
break; }
else
csi->logic=LOGIC_FALSE;
return(0);
case OPEN_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(pp && *pp && lp) {
*lp=(long)opendir((char *)*pp);
if(*lp)
csi->logic=LOGIC_TRUE; }
return(0);
case READ_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(pp && lp) {
de=readdir((DIR *)(*lp));
if(de!=NULL) {
csi->logic=LOGIC_TRUE;
*pp=copystrvar(csi,*pp,de->d_name); } }
return(0);
case REWIND_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
rewinddir((DIR *)(*lp));
csi->logic=LOGIC_TRUE; }
else
csi->logic=LOGIC_FALSE;
return(0);
case CLOSE_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && closedir((DIR *)(*lp))==0)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
default:
errormsg(WHERE,ERR_CHK,"fio sub-instruction",*(csi->ip-1));
return(0); }
case CS_NET_FUNCTION:
return(exec_net(csi));
case CS_SWITCH:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp) {
skipto(csi,CS_END_SWITCH);
csi->ip++; }
else {
csi->misc|=CS_IN_SWITCH;
csi->switch_val=*lp; }
return(0);
case CS_CASE:
l=*(long *)csi->ip;
csi->ip+=4;
if(csi->misc&CS_IN_SWITCH && csi->switch_val!=l)
skipto(csi,CS_NEXTCASE);
else
csi->misc&=~CS_IN_SWITCH;
return(0);
case CS_COMPARE_ARS:
i=*(csi->ip++); /* Length of ARS stored as byte before ARS */
csi->logic=!chk_ar(csi->ip,&useron);
csi->ip+=i;
return(0);
case CS_TOGGLE_USER_MISC:
useron.misc^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_MISC,8,ultoa(useron.misc,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_MISC:
if((useron.misc&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_TOGGLE_USER_CHAT:
useron.chat^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_CHAT,8,ultoa(useron.chat,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_CHAT:
if((useron.chat&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_TOGGLE_USER_QWK:
useron.qwk^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_QWK,8,ultoa(useron.qwk,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_QWK:
if((useron.qwk&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_REPLACE_TEXT:
i=*(ushort *)csi->ip;
csi->ip+=2;
i--;
if(i>=TOTAL_TEXT) {
errormsg(WHERE,ERR_CHK,"replace text #",i);
while(*(csi->ip++)); /* Find NULL */
return(0); }
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
j=strlen(cmdstr((char *)csi->ip,path,csi->str,buf));
if(!j)
text[i]=nulstr;
else
text[i]=(char *)malloc(j+1);
if(!text[i]) {
errormsg(WHERE,ERR_ALLOC,"replacement text",j);
while(*(csi->ip++)); /* Find NULL */
text[i]=text_sav[i];
return(0); }
if(j)
strcpy(text[i],buf);
while(*(csi->ip++)); /* Find NULL */
return(0);
case CS_USE_INT_VAR: // Self-modifying code!
pp=getstrvar(csi,*(long *)csi->ip);
if(pp && *pp)
l=strtol(*pp,0,0);
else {
lp=getintvar(csi,*(long *)csi->ip);
if(lp)
l=*lp;
else
l=0; }
csi->ip+=4; // Variable
i=*(csi->ip++); // Offset
if(i<1 || csi->ip+1+i>=csi->cs+csi->length) {
errormsg(WHERE,ERR_CHK,"offset",i);
csi->ip++;
return(0); }
switch(*(csi->ip++)) { // Length
case sizeof(char):
*(csi->ip+i)=(char)l;
break;
case sizeof(short):
*((short *)(csi->ip+i))=(short)l;
break;
case sizeof(long):
*((long *)(csi->ip+i))=l;
break;
default:
errormsg(WHERE,ERR_CHK,"length",*(csi->ip-1));
break; }
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0); }
}
BOOL DLLCALL load_cfg(scfg_t* cfg, char* text[], BOOL prep, char* error)
{
int i;
#ifdef SBBS
long line=0L;
FILE *instream;
char str[256],fname[13];
#endif
if(cfg->size!=sizeof(scfg_t)) {
sprintf(error,"cfg->size (%"PRIu32") != sizeof(scfg_t) (%d)"
,cfg->size,sizeof(scfg_t));
return(FALSE);
}
free_cfg(cfg); /* free allocated config parameters */
cfg->prepped=FALSE; /* reset prepped flag */
if(cfg->node_num<1)
cfg->node_num=1;
backslash(cfg->ctrl_dir);
if(read_main_cfg(cfg, error)==FALSE)
return(FALSE);
if(prep)
for(i=0;i<cfg->sys_nodes;i++)
prep_dir(cfg->ctrl_dir, cfg->node_path[i], sizeof(cfg->node_path[i]));
SAFECOPY(cfg->node_dir,cfg->node_path[cfg->node_num-1]);
prep_dir(cfg->ctrl_dir, cfg->node_dir, sizeof(cfg->node_dir));
if(read_node_cfg(cfg, error)==FALSE)
return(FALSE);
if(read_msgs_cfg(cfg, error)==FALSE)
return(FALSE);
if(read_file_cfg(cfg, error)==FALSE)
return(FALSE);
if(read_xtrn_cfg(cfg, error)==FALSE)
return(FALSE);
if(read_chat_cfg(cfg, error)==FALSE)
return(FALSE);
if(read_attr_cfg(cfg, error)==FALSE)
return(FALSE);
#ifdef SBBS
if(text!=NULL) {
/* Free existing text if allocated */
free_text(text);
strcpy(fname,"text.dat");
sprintf(str,"%s%s",cfg->ctrl_dir,fname);
if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {
sprintf(error,"%d opening %s",errno,str);
return(FALSE);
}
for(i=0;i<TOTAL_TEXT;i++)
if((text[i]=readtext(&line,instream,i))==NULL) {
i--;
break;
}
fclose(instream);
if(i<TOTAL_TEXT) {
sprintf(error,"line %d in %s: Less than TOTAL_TEXT (%u) strings defined in %s."
,i,fname
,TOTAL_TEXT,fname);
return(FALSE);
}
}
#endif
/* Override com-port settings */
cfg->com_base=0xf; /* All nodes use FOSSIL */
cfg->com_port=1; /* All nodes use "COM1" */
if(prep)
prep_cfg(cfg);
/* Auto-toggle daylight savings time in US time-zones */
sys_timezone(cfg);
return(TRUE);
}
void msgs_cfg()
{
static int dflt,msgs_dflt,bar;
char str[256],str2[256],done=0;
char* p;
char* tp;
char tmp[128];
char tmp_code[32];
int j,k,q,s;
int i,file,ptridx,n;
unsigned total_subs;
long ported;
sub_t tmpsub;
static grp_t savgrp;
FILE* stream;
while(1) {
for(i=0;i<cfg.total_grps && i<MAX_OPTS;i++)
sprintf(opt[i],"%-25s",cfg.grp[i]->lname);
opt[i][0]=0;
j=WIN_ORG|WIN_ACT|WIN_CHE;
if(cfg.total_grps)
j|=WIN_DEL|WIN_DELACT|WIN_GET;
if(cfg.total_grps<MAX_OPTS)
j|=WIN_INS|WIN_INSACT|WIN_XTR;
if(savgrp.sname[0])
j|=WIN_PUT;
uifc.helpbuf=
"`Message Groups:`\n"
"\n"
"This is a listing of message groups for your BBS. Message groups are\n"
"used to logically separate your message `sub-boards` into groups. Every\n"
"sub-board belongs to a message group. You must have at least one message\n"
"group and one sub-board configured.\n"
"\n"
"One popular use for message groups is to separate local sub-boards and\n"
"networked sub-boards. One might have a `Local` message group that contains\n"
"non-networked sub-boards of various topics and also have a `FidoNet`\n"
"message group that contains sub-boards that are echoed across FidoNet.\n"
"Some sysops separate sub-boards into more specific areas such as `Main`,\n"
"`Technical`, or `Adult`. If you have many sub-boards that have a common\n"
"subject denominator, you may want to have a separate message group for\n"
"those sub-boards for a more organized message structure.\n"
;
i=uifc.list(j,0,0,45,&msgs_dflt,&bar,"Message Groups",opt);
if(i==-1) {
j=save_changes(WIN_MID);
if(j==-1)
continue;
if(!j) {
write_msgs_cfg(&cfg,backup_level);
refresh_cfg(&cfg);
}
return;
}
if((i&MSK_ON)==MSK_INS) {
i&=MSK_OFF;
uifc.helpbuf=
"`Group Long Name:`\n"
"\n"
"This is a description of the message group which is displayed when a\n"
"user of the system uses the `/*` command from the main menu.\n"
;
strcpy(str,"Main");
if(uifc.input(WIN_MID|WIN_SAV,0,0,"Group Long Name",str,LEN_GLNAME
,K_EDIT)<1)
continue;
uifc.helpbuf=
"`Group Short Name:`\n"
"\n"
"This is a short description of the message group which is used for the\n"
"main menu and reading message prompts.\n"
;
sprintf(str2,"%.*s",LEN_GSNAME,str);
if(uifc.input(WIN_MID,0,0,"Group Short Name",str2,LEN_GSNAME,K_EDIT)<1)
continue;
if((cfg.grp=(grp_t **)realloc(cfg.grp,sizeof(grp_t *)*(cfg.total_grps+1)))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,cfg.total_grps+1);
cfg.total_grps=0;
bail(1);
continue;
}
if(cfg.total_grps) { /* was cfg.total_subs (?) */
for(j=cfg.total_grps;j>i;j--) /* insert above */
cfg.grp[j]=cfg.grp[j-1];
for(j=0;j<cfg.total_subs;j++) /* move sub group numbers */
if(cfg.sub[j]->grp>=i)
cfg.sub[j]->grp++;
}
if((cfg.grp[i]=(grp_t *)malloc(sizeof(grp_t)))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,sizeof(grp_t));
continue;
}
memset((grp_t *)cfg.grp[i],0,sizeof(grp_t));
strcpy(cfg.grp[i]->lname,str);
strcpy(cfg.grp[i]->sname,str2);
cfg.total_grps++;
uifc.changes=1;
continue;
}
if((i&MSK_ON)==MSK_DEL) {
i&=MSK_OFF;
uifc.helpbuf=
"`Delete All Data in Group:`\n"
"\n"
"If you wish to delete the messages in all the sub-boards in this group,\n"
"select `Yes`.\n"
;
j=1;
strcpy(opt[0],"Yes");
strcpy(opt[1],"No");
opt[2][0]=0;
j=uifc.list(WIN_MID|WIN_SAV,0,0,0,&j,0,"Delete All Data in Group",opt);
if(j==-1)
continue;
if(j==0)
for(j=0;j<cfg.total_subs;j++)
if(cfg.sub[j]->grp==i) {
sprintf(str,"%s%s.s*"
,cfg.grp[cfg.sub[j]->grp]->code_prefix
,cfg.sub[j]->code_suffix);
strlwr(str);
if(!cfg.sub[j]->data_dir[0])
sprintf(tmp,"%ssubs/",cfg.data_dir);
else
strcpy(tmp,cfg.sub[j]->data_dir);
delfiles(tmp,str);
clearptrs(j);
}
free(cfg.grp[i]);
for(j=0;j<cfg.total_subs;) {
if(cfg.sub[j]->grp==i) { /* delete subs of this group */
free(cfg.sub[j]);
cfg.total_subs--;
k=j;
while(k<cfg.total_subs) { /* move all subs down */
cfg.sub[k]=cfg.sub[k+1];
for(q=0;q<cfg.total_qhubs;q++)
for(s=0;s<cfg.qhub[q]->subs;s++)
if(cfg.qhub[q]->sub[s]==k)
cfg.qhub[q]->sub[s]--;
k++;
}
}
else j++;
}
for(j=0;j<cfg.total_subs;j++) /* move sub group numbers down */
if(cfg.sub[j]->grp>i)
cfg.sub[j]->grp--;
cfg.total_grps--;
while(i<cfg.total_grps) {
cfg.grp[i]=cfg.grp[i+1];
i++;
}
uifc.changes=1;
continue;
}
if((i&MSK_ON)==MSK_GET) {
i&=MSK_OFF;
savgrp=*cfg.grp[i];
continue;
}
if((i&MSK_ON)==MSK_PUT) {
i&=MSK_OFF;
*cfg.grp[i]=savgrp;
uifc.changes=1;
continue;
}
done=0;
while(!done) {
j=0;
sprintf(opt[j++],"%-27.27s%s","Long Name",cfg.grp[i]->lname);
sprintf(opt[j++],"%-27.27s%s","Short Name",cfg.grp[i]->sname);
sprintf(opt[j++],"%-27.27s%s","Internal Code Prefix",cfg.grp[i]->code_prefix);
sprintf(opt[j++],"%-27.27s%.40s","Access Requirements"
,cfg.grp[i]->arstr);
strcpy(opt[j++],"Clone Options");
strcpy(opt[j++],"Export Areas...");
strcpy(opt[j++],"Import Areas...");
strcpy(opt[j++],"Message Sub-boards...");
opt[j][0]=0;
sprintf(str,"%s Group",cfg.grp[i]->sname);
uifc.helpbuf=
"`Message Group Configuration:`\n"
"\n"
"This menu allows you to configure the security requirements for access\n"
"to this message group. You can also add, delete, and configure the\n"
"sub-boards of this group by selecting the `Messages Sub-boards...` option.\n"
;
switch(uifc.list(WIN_ACT,6,4,60,&dflt,0,str,opt)) {
case -1:
done=1;
break;
case 0:
uifc.helpbuf=
"`Group Long Name:`\n"
"\n"
"This is a description of the message group which is displayed when a\n"
"user of the system uses the `/*` command from the main menu.\n"
;
strcpy(str,cfg.grp[i]->lname); /* save incase setting to null */
if(!uifc.input(WIN_MID|WIN_SAV,0,17,"Name to use for Listings"
,cfg.grp[i]->lname,LEN_GLNAME,K_EDIT))
strcpy(cfg.grp[i]->lname,str);
break;
case 1:
uifc.helpbuf=
"`Group Short Name:`\n"
"\n"
"This is a short description of the message group which is used for\n"
"main menu and reading messages prompts.\n"
;
uifc.input(WIN_MID|WIN_SAV,0,17,"Name to use for Prompts"
,cfg.grp[i]->sname,LEN_GSNAME,K_EDIT);
break;
case 2:
uifc.helpbuf=
"`Internal Code Prefix:`\n"
"\n"
"This is an `optional` code prefix used to help generate unique internal\n"
"codes for the sub-boards in this message group. If this option\n"
"is used, sub-board internal codes will be constructed from this prefix\n"
"and the specified code suffix for each sub-board.\n"
;
uifc.input(WIN_MID|WIN_SAV,0,17,"Internal Code Prefix"
,cfg.grp[i]->code_prefix,LEN_CODE,K_EDIT|K_UPPER);
break;
case 3:
sprintf(str,"%s Group",cfg.grp[i]->sname);
getar(str,cfg.grp[i]->arstr);
break;
case 4: /* Clone Options */
j=0;
strcpy(opt[0],"Yes");
strcpy(opt[1],"No");
opt[2][0]=0;
uifc.helpbuf=
"`Clone Sub-board Options:`\n"
"\n"
"If you want to clone the options of the first sub-board of this group\n"
"into all sub-boards of this group, select `Yes`.\n"
"\n"
"The options cloned are posting requirements, reading requirements,\n"
"operator requirments, moderated user requirments, toggle options,\n"
"network options (including EchoMail origin line, EchoMail address,\n"
"and QWK Network tagline), maximum number of messages, maximum number\n"
"of CRCs, maximum age of messages, storage method, and data directory.\n"
;
j=uifc.list(WIN_MID|WIN_SAV,0,0,0,&j,0
,"Clone Options of First Sub-board into All of Group",opt);
if(j==0) {
k=-1;
for(j=0;j<cfg.total_subs;j++)
if(cfg.sub[j]->grp==i) {
if(k==-1)
k=j;
else {
uifc.changes=1;
cfg.sub[j]->misc=(cfg.sub[k]->misc|SUB_HDRMOD);
strcpy(cfg.sub[j]->post_arstr,cfg.sub[k]->post_arstr);
strcpy(cfg.sub[j]->read_arstr,cfg.sub[k]->read_arstr);
strcpy(cfg.sub[j]->op_arstr,cfg.sub[k]->op_arstr);
strcpy(cfg.sub[j]->mod_arstr,cfg.sub[k]->mod_arstr);
strcpy(cfg.sub[j]->origline,cfg.sub[k]->origline);
strcpy(cfg.sub[j]->tagline,cfg.sub[k]->tagline);
strcpy(cfg.sub[j]->data_dir,cfg.sub[k]->data_dir);
strcpy(cfg.sub[j]->post_sem,cfg.sub[k]->post_sem);
cfg.sub[j]->maxmsgs=cfg.sub[k]->maxmsgs;
cfg.sub[j]->maxcrcs=cfg.sub[k]->maxcrcs;
cfg.sub[j]->maxage=cfg.sub[k]->maxage;
cfg.sub[j]->faddr=cfg.sub[k]->faddr;
}
}
}
break;
case 5:
k=0;
ported=0;
q=uifc.changes;
strcpy(opt[k++],"SUBS.TXT (Synchronet)");
strcpy(opt[k++],"AREAS.BBS (MSG)");
strcpy(opt[k++],"AREAS.BBS (SBBSecho)");
strcpy(opt[k++],"FIDONET.NA (Fido)");
opt[k][0]=0;
uifc.helpbuf=
"`Export Area File Format:`\n"
"\n"
"This menu allows you to choose the format of the area file you wish to\n"
"export the current message group into.\n"
;
k=0;
k=uifc.list(WIN_MID|WIN_SAV,0,0,0,&k,0
,"Export Area File Format",opt);
if(k==-1)
break;
if(k==0)
sprintf(str,"%sSUBS.TXT",cfg.ctrl_dir);
else if(k==1)
sprintf(str,"AREAS.BBS");
else if(k==2)
sprintf(str,"%sAREAS.BBS",cfg.data_dir);
else if(k==3)
sprintf(str,"FIDONET.NA");
if(k && k<3)
if(uifc.input(WIN_MID|WIN_SAV,0,0,"Uplinks"
,str2,sizeof(str2)-1,0)<=0) {
uifc.changes=q;
break;
}
if(uifc.input(WIN_MID|WIN_SAV,0,0,"Filename"
,str,sizeof(str)-1,K_EDIT)<=0) {
uifc.changes=q;
break;
}
if(fexist(str)) {
strcpy(opt[0],"Overwrite");
strcpy(opt[1],"Append");
opt[2][0]=0;
j=0;
j=uifc.list(WIN_MID|WIN_SAV,0,0,0,&j,0
,"File Exists",opt);
if(j==-1)
break;
if(j==0) j=O_WRONLY|O_TRUNC;
else j=O_WRONLY|O_APPEND;
}
else
j=O_WRONLY|O_CREAT;
if((stream=fnopen(&file,str,j))==NULL) {
sprintf(str,"Open Failure: %d (%s)"
,errno,strerror(errno));
uifc.msg(str);
uifc.changes=q;
break;
}
uifc.pop("Exporting Areas...");
for(j=0;j<cfg.total_subs;j++) {
if(cfg.sub[j]->grp!=i)
continue;
ported++;
if(k==1) { /* AREAS.BBS *.MSG */
sprintf(str,"%s%s%s/"
,cfg.echomail_dir
,cfg.grp[cfg.sub[j]->grp]->code_prefix
,cfg.sub[j]->code_suffix);
fprintf(stream,"%-30s %-20s %s\r\n"
,str,stou(cfg.sub[j]->sname),str2);
continue;
}
if(k==2) { /* AREAS.BBS SBBSecho */
fprintf(stream,"%s%-30s %-20s %s\r\n"
,cfg.grp[cfg.sub[j]->grp]->code_prefix
,cfg.sub[j]->code_suffix
,stou(cfg.sub[j]->sname)
,str2);
continue;
}
if(k==3) { /* FIDONET.NA */
fprintf(stream,"%-20s %s\r\n"
,stou(cfg.sub[j]->sname),cfg.sub[j]->lname);
continue;
}
fprintf(stream,"%s\r\n%s\r\n%s\r\n%s\r\n%s\r\n%s\r\n"
"%s\r\n%s\r\n%s\r\n"
,cfg.sub[j]->lname
,cfg.sub[j]->sname
,cfg.sub[j]->qwkname
,cfg.sub[j]->code_suffix
,cfg.sub[j]->data_dir
,cfg.sub[j]->arstr
,cfg.sub[j]->read_arstr
,cfg.sub[j]->post_arstr
,cfg.sub[j]->op_arstr
);
fprintf(stream,"%"PRIX32"\r\n%s\r\n%s\r\n%s\r\n%s\r\n%s\r\n"
,cfg.sub[j]->misc
,cfg.sub[j]->tagline
,cfg.sub[j]->origline
,cfg.sub[j]->post_sem
,cfg.sub[j]->newsgroup
,smb_faddrtoa(&cfg.sub[j]->faddr,tmp)
);
fprintf(stream,"%"PRIu32"\r\n%"PRIu32"\r\n%u\r\n%u\r\n%s\r\n"
,cfg.sub[j]->maxmsgs
,cfg.sub[j]->maxcrcs
,cfg.sub[j]->maxage
,cfg.sub[j]->ptridx
,cfg.sub[j]->mod_arstr
);
fprintf(stream,"***END-OF-SUB***\r\n\r\n");
}
fclose(stream);
uifc.pop(0);
sprintf(str,"%lu Message Areas Exported Successfully",ported);
uifc.msg(str);
uifc.changes=q;
break;
case 6:
ported=0;
k=0;
strcpy(opt[k++],"SUBS.TXT (Synchronet)");
strcpy(opt[k++],"AREAS.BBS (Generic)");
strcpy(opt[k++],"AREAS.BBS (SBBSecho)");
strcpy(opt[k++],"FIDONET.NA (Fido)");
opt[k][0]=0;
uifc.helpbuf=
"`Import Area File Format:`\n"
"\n"
"This menu allows you to choose the format of the area file you wish to\n"
"import into the current message group.\n"
;
k=0;
k=uifc.list(WIN_MID|WIN_SAV,0,0,0,&k,0
,"Import Area File Format",opt);
if(k==-1)
break;
if(k==0)
sprintf(str,"%sSUBS.TXT",cfg.ctrl_dir);
else if(k==1)
sprintf(str,"AREAS.BBS");
else if(k==2)
sprintf(str,"%sAREAS.BBS",cfg.data_dir);
else if(k==3)
sprintf(str,"FIDONET.NA");
if(uifc.input(WIN_MID|WIN_SAV,0,0,"Filename"
,str,sizeof(str)-1,K_EDIT)<=0)
break;
if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
uifc.msg("Open Failure");
break;
}
uifc.pop("Importing Areas...");
total_subs = cfg.total_subs; /* Save original number of subs */
ptridx = 0;
while(!feof(stream)) {
if(!fgets(str,sizeof(str),stream)) break;
truncsp(str);
if(!str[0])
continue;
if(k) {
p=str;
while(*p && *p<=' ') p++;
if(!*p || *p==';')
continue;
memset(&tmpsub,0,sizeof(sub_t));
tmpsub.misc|=
(SUB_FIDO|SUB_NAME|SUB_TOUSER|SUB_QUOTE|SUB_HYPER);
if(k==1) { /* AREAS.BBS Generic/*.MSG */
p=str;
SKIP_WHITESPACE(p); /* Find path */
FIND_WHITESPACE(p); /* Skip path */
SKIP_WHITESPACE(p); /* Find tag */
truncstr(p," \t"); /* Truncate tag */
SAFECOPY(tmp_code,p); /* Copy tag to internal code */
SAFECOPY(tmpsub.lname,utos(p));
SAFECOPY(tmpsub.sname,tmpsub.lname);
SAFECOPY(tmpsub.qwkname,tmpsub.qwkname);
}
else if(k==2) { /* AREAS.BBS SBBSecho */
p=str;
SKIP_WHITESPACE(p); /* Find internal code */
tp=p;
FIND_WHITESPACE(tp);
*tp=0; /* Truncate internal code */
SAFECOPY(tmp_code,p); /* Copy internal code suffix */
p=tp+1;
SKIP_WHITESPACE(p); /* Find echo tag */
truncstr(p," \t"); /* Truncate tag */
SAFECOPY(tmpsub.lname,utos(p));
SAFECOPY(tmpsub.sname,tmpsub.lname);
SAFECOPY(tmpsub.qwkname,tmpsub.sname);
}
else if(k==3) { /* FIDONET.NA */
p=str;
SKIP_WHITESPACE(p); /* Find echo tag */
tp=p;
FIND_WHITESPACE(tp); /* Find end of tag */
*tp=0; /* Truncate echo tag */
SAFECOPY(tmp_code,p); /* Copy tag to internal code suffix */
SAFECOPY(tmpsub.sname,utos(p)); /* ... to short name, converting underscores to spaces */
SAFECOPY(tmpsub.qwkname,tmpsub.sname); /* ... to QWK name .... */
p=tp+1;
SKIP_WHITESPACE(p); /* Find description */
SAFECOPY(tmpsub.lname,p); /* Copy description to long name */
}
}
else {
memset(&tmpsub,0,sizeof(sub_t));
tmpsub.grp=i;
sprintf(tmpsub.lname,"%.*s",LEN_SLNAME,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.sname,"%.*s",LEN_SSNAME,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.qwkname,"%.*s",10,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
SAFECOPY(tmp_code,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.data_dir,"%.*s",LEN_DIR,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.arstr,"%.*s",LEN_ARSTR,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.read_arstr,"%.*s",LEN_ARSTR,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.post_arstr,"%.*s",LEN_ARSTR,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.op_arstr,"%.*s",LEN_ARSTR,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
tmpsub.misc=ahtoul(str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.tagline,"%.*s",80,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.origline,"%.*s",50,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.post_sem,"%.*s",LEN_DIR,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
SAFECOPY(tmpsub.newsgroup,str);
if(!fgets(str,128,stream)) break;
truncsp(str);
tmpsub.faddr=atofaddr(str);
if(!fgets(str,128,stream)) break;
truncsp(str);
tmpsub.maxmsgs=atol(str);
if(!fgets(str,128,stream)) break;
truncsp(str);
tmpsub.maxcrcs=atol(str);
if(!fgets(str,128,stream)) break;
truncsp(str);
tmpsub.maxage=atoi(str);
if(!fgets(str,128,stream)) break;
truncsp(str);
tmpsub.ptridx=atoi(str);
if(!fgets(str,128,stream)) break;
truncsp(str);
sprintf(tmpsub.mod_arstr,"%.*s",LEN_ARSTR,str);
while(!feof(stream)
&& strcmp(str,"***END-OF-SUB***")) {
if(!fgets(str,128,stream)) break;
truncsp(str);
}
}
SAFECOPY(tmpsub.code_suffix, prep_code(tmp_code,cfg.grp[i]->code_prefix));
truncsp(tmpsub.sname);
truncsp(tmpsub.lname);
truncsp(tmpsub.qwkname);
if(tmpsub.code_suffix[0]==0
|| tmpsub.sname[0]==0
|| tmpsub.lname[0]==0
|| tmpsub.qwkname[0]==0)
continue;
for(j=0;j<total_subs;j++) {
if(cfg.sub[j]->grp!=i)
continue;
if(!stricmp(cfg.sub[j]->code_suffix,tmpsub.code_suffix))
break;
}
if(j==total_subs) {
j=cfg.total_subs;
if((cfg.sub=(sub_t **)realloc(cfg.sub
,sizeof(sub_t *)*(cfg.total_subs+1)))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,cfg.total_subs+1);
cfg.total_subs=0;
bail(1);
break;
}
if((cfg.sub[j]=(sub_t *)malloc(sizeof(sub_t)))
==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,sizeof(sub_t));
break;
}
memset(cfg.sub[j],0,sizeof(sub_t));
}
if(!k) {
n=cfg.sub[j]->ptridx; /* save original ptridx */
memcpy(cfg.sub[j],&tmpsub,sizeof(sub_t));
cfg.sub[j]->ptridx=n; /* restore original ptridx */
} else {
cfg.sub[j]->grp=i;
if(cfg.total_faddrs)
cfg.sub[j]->faddr=cfg.faddr[0];
strcpy(cfg.sub[j]->code_suffix,tmpsub.code_suffix);
strcpy(cfg.sub[j]->sname,tmpsub.sname);
strcpy(cfg.sub[j]->lname,tmpsub.lname);
strcpy(cfg.sub[j]->qwkname,tmpsub.qwkname);
strcpy(cfg.sub[j]->data_dir,tmpsub.data_dir);
if(j==cfg.total_subs)
cfg.sub[j]->maxmsgs=1000;
}
if(j==cfg.total_subs) { /* adding new sub-board */
for(;ptridx<USHRT_MAX;ptridx++) {
for(n=0;n<total_subs;n++)
if(cfg.sub[n]->ptridx==ptridx)
break;
if(n==total_subs)
break;
}
cfg.sub[j]->ptridx=ptridx; /* use new ptridx */
cfg.sub[j]->misc=tmpsub.misc;
cfg.total_subs++;
ptridx++; /* don't use the same ptridx for next sub */
}
uifc.changes=1;
ported++;
}
fclose(stream);
uifc.pop(0);
sprintf(str,"%lu Message Areas Imported Successfully",ported);
uifc.msg(str);
break;
case 7:
sub_cfg(i);
break;
}
}
}
}
