void sbbs_t::change_user(void)
{
uint i;
char str[256];
char tmp[128];
if(!chksyspass())
return;
bputs(text[ChUserPrompt]);
if(!getstr(str,LEN_ALIAS,K_UPPER))
return;
if((i=finduser(str))==0)
return;
if(online==ON_REMOTE) {
getuserrec(&cfg,i,U_LEVEL,2,str);
if(atoi(str)>logon_ml) {
getuserrec(&cfg,i,U_PASS,8,tmp);
bputs(text[ChUserPwPrompt]);
console|=CON_R_ECHOX;
getstr(str,8,K_UPPER);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
if(strcmp(str,tmp))
return;
}
}
putmsgptrs();
putuserrec(&cfg,useron.number,U_CURSUB,0
,cfg.sub[usrsub[curgrp][cursub[curgrp]]]->code);
putuserrec(&cfg,useron.number,U_CURDIR,0
,cfg.dir[usrdir[curlib][curdir[curlib]]]->code);
useron.number=i;
getuserdat(&cfg,&useron);
getnodedat(cfg.node_num,&thisnode,1);
thisnode.useron=useron.number;
putnodedat(cfg.node_num,&thisnode);
getmsgptrs();
if(REALSYSOP) sys_status&=~SS_TMPSYSOP;
else sys_status|=SS_TMPSYSOP;
sprintf(str,"Changed into %s #%u",useron.alias,useron.number);
logline("S+",str);
}
bool sbbs_t::select_shell(void)
{
int i;
for(i=0;i<cfg.total_shells;i++)
uselect(1,i,text[CommandShellHeading],cfg.shell[i]->name,cfg.shell[i]->ar);
if((i=uselect(0,useron.shell,0,0,0))>=0) {
useron.shell=i;
putuserrec(&cfg,useron.number,U_SHELL,8,cfg.shell[i]->code);
return(true);
}
return(false);
}
bool sbbs_t::select_editor(void)
{
int i;
for(i=0;i<cfg.total_xedits;i++)
uselect(1,i,text[ExternalEditorHeading],cfg.xedit[i]->name,cfg.xedit[i]->ar);
if(useron.xedit) useron.xedit--;
if((i=uselect(0,useron.xedit,0,0,0))>=0) {
useron.xedit=i+1;
putuserrec(&cfg,useron.number,U_XEDIT,8,cfg.xedit[i]->code);
return(true);
}
return(false);
}
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 sbbs_t::newuser()
{
char c,str[512];
char tmp[512];
uint i;
long kmode;
bool usa;
bputs(text[StartingNewUserRegistration]);
getnodedat(cfg.node_num,&thisnode,0);
if(thisnode.misc&NODE_LOCK) {
bputs(text[NodeLocked]);
logline(LOG_WARNING,"N!","New user locked node logon attempt");
hangup();
return(FALSE);
}
if(cfg.sys_misc&SM_CLOSED) {
bputs(text[NoNewUsers]);
hangup();
return(FALSE);
}
getnodedat(cfg.node_num,&thisnode,1);
thisnode.status=NODE_NEWUSER;
thisnode.connection=node_connection;
putnodedat(cfg.node_num,&thisnode);
memset(&useron,0,sizeof(user_t)); /* Initialize user info to null */
if(cfg.new_pass[0] && online==ON_REMOTE) {
c=0;
while(++c<4) {
bputs(text[NewUserPasswordPrompt]);
getstr(str,40,K_UPPER);
if(!strcmp(str,cfg.new_pass))
break;
SAFEPRINTF(tmp,"NUP Attempted: '%s'",str);
logline(LOG_NOTICE,"N!",tmp);
}
if(c==4) {
SAFEPRINTF(str,"%snupguess.msg",cfg.text_dir);
if(fexist(str))
printfile(str,P_NOABORT);
hangup();
return(FALSE);
}
}
/* Sets defaults per sysop config */
useron.misc|=(cfg.new_misc&~(DELETED|INACTIVE|QUIET|NETMAIL));
useron.qwk=QWK_DEFAULT;
useron.firston=useron.laston=useron.pwmod=time32(NULL);
if(cfg.new_expire) {
now=time(NULL);
useron.expire=(time32_t)(now+((long)cfg.new_expire*24L*60L*60L));
} else
useron.expire=0;
useron.sex=' ';
useron.prot=cfg.new_prot;
SAFECOPY(useron.comp,client_name); /* hostname or CID name */
SAFECOPY(useron.note,cid); /* IP address or CID number */
if((i=userdatdupe(0,U_NOTE,LEN_NOTE,cid, /* del */true))!=0) { /* Duplicate IP address */
SAFEPRINTF2(useron.comment,"Warning: same IP address as user #%d %s"
,i,username(&cfg,i,str));
logline(LOG_NOTICE,"N!",useron.comment);
}
SAFECOPY(useron.alias,"New"); /* just for status line */
SAFECOPY(useron.modem,connection);
if(!lastuser(&cfg)) { /* Automatic sysop access for first user */
bprintf("Creating sysop account... System password required.\r\n");
if(!chksyspass())
return(FALSE);
useron.level=99;
useron.exempt=useron.flags1=useron.flags2=0xffffffffUL;
useron.flags3=useron.flags4=0xffffffffUL;
useron.rest=0L;
} else {
useron.level=cfg.new_level;
useron.flags1=cfg.new_flags1;
useron.flags2=cfg.new_flags2;
useron.flags3=cfg.new_flags3;
useron.flags4=cfg.new_flags4;
useron.rest=cfg.new_rest;
useron.exempt=cfg.new_exempt;
}
useron.cdt=cfg.new_cdt;
useron.min=cfg.new_min;
useron.freecdt=cfg.level_freecdtperday[useron.level];
if(cfg.total_fcomps)
SAFECOPY(useron.tmpext,cfg.fcomp[0]->ext);
else
SAFECOPY(useron.tmpext,"ZIP");
useron.shell=cfg.new_shell;
useron.alias[0]=0;
kmode=(cfg.uq&UQ_NOEXASC)|K_EDIT|K_AUTODEL;
if(!(cfg.uq&UQ_NOUPRLWR))
kmode|=K_UPRLWR;
while(online) {
if(autoterm || (text[AutoTerminalQ][0] && yesno(text[AutoTerminalQ]))) {
useron.misc|=AUTOTERM;
useron.misc|=autoterm;
} else
useron.misc&=~AUTOTERM;
if(!(useron.misc&AUTOTERM)) {
if(text[AnsiTerminalQ][0] && yesno(text[AnsiTerminalQ]))
useron.misc|=ANSI;
else
useron.misc&=~ANSI;
}
if(useron.misc&ANSI) {
useron.rows=0; /* Auto-rows */
if(!(cfg.uq&UQ_COLORTERM) || useron.misc&(RIP|WIP|HTML) || text[ColorTerminalQ][0]==0 || yesno(text[ColorTerminalQ]))
useron.misc|=COLOR;
else
useron.misc&=~COLOR;
}
else
useron.rows=24;
if(text[ExAsciiTerminalQ][0] && !yesno(text[ExAsciiTerminalQ]))
useron.misc|=NO_EXASCII;
else
useron.misc&=~NO_EXASCII;
if(rlogin_name[0])
SAFECOPY(useron.alias,rlogin_name);
while(online) {
if(cfg.uq&UQ_ALIASES)
bputs(text[EnterYourAlias]);
else
bputs(text[EnterYourRealName]);
getstr(useron.alias,LEN_ALIAS,kmode);
truncsp(useron.alias);
if (!check_name(&cfg,useron.alias)
|| (!(cfg.uq&UQ_ALIASES) && !strchr(useron.alias,' '))) {
bputs(text[YouCantUseThatName]);
if(text[ContinueQ][0] && !yesno(text[ContinueQ]))
return(FALSE);
continue;
}
break;
}
if(!online) return(FALSE);
if((cfg.uq&UQ_ALIASES) && (cfg.uq&UQ_REALNAME)) {
while(online) {
bputs(text[EnterYourRealName]);
getstr(useron.name,LEN_NAME,kmode);
if (!check_name(&cfg,useron.name)
|| !strchr(useron.name,' ')
|| ((cfg.uq&UQ_DUPREAL)
&& userdatdupe(useron.number,U_NAME,LEN_NAME,useron.name)))
bputs(text[YouCantUseThatName]);
else
break;
if(text[ContinueQ][0] && !yesno(text[ContinueQ]))
return(FALSE);
}
}
else if(cfg.uq&UQ_COMPANY) {
bputs(text[EnterYourCompany]);
getstr(useron.name,LEN_NAME,(cfg.uq&UQ_NOEXASC)|K_EDIT|K_AUTODEL);
}
if(!useron.name[0])
SAFECOPY(useron.name,useron.alias);
if(!online) return(FALSE);
if(!useron.handle[0])
SAFECOPY(useron.handle,useron.alias);
while((cfg.uq&UQ_HANDLE) && online) {
bputs(text[EnterYourHandle]);
if(!getstr(useron.handle,LEN_HANDLE
,K_LINE|K_EDIT|K_AUTODEL|(cfg.uq&UQ_NOEXASC))
|| strchr(useron.handle,0xff)
|| ((cfg.uq&UQ_DUPHAND)
&& userdatdupe(0,U_HANDLE,LEN_HANDLE,useron.handle))
|| trashcan(useron.handle,"name"))
bputs(text[YouCantUseThatName]);
else
break;
if(text[ContinueQ][0] && !yesno(text[ContinueQ]))
return(FALSE);
}
if(!online) return(FALSE);
if(cfg.uq&UQ_ADDRESS)
while(online) { /* Get address and zip code */
bputs(text[EnterYourAddress]);
if(getstr(useron.address,LEN_ADDRESS,kmode))
break;
}
if(!online) return(FALSE);
while((cfg.uq&UQ_LOCATION) && online) {
bputs(text[EnterYourCityState]);
if(getstr(useron.location,LEN_LOCATION,kmode)
&& ((cfg.uq&UQ_NOCOMMAS) || strchr(useron.location,',')))
break;
bputs(text[CommaInLocationRequired]);
useron.location[0]=0;
}
if(cfg.uq&UQ_ADDRESS)
while(online) {
bputs(text[EnterYourZipCode]);
if(getstr(useron.zipcode,LEN_ZIPCODE
,K_UPPER|(cfg.uq&UQ_NOEXASC)|K_EDIT|K_AUTODEL))
break;
}
if(!online) return(FALSE);
if(cfg.uq&UQ_PHONE) {
if(text[CallingFromNorthAmericaQ][0])
usa=yesno(text[CallingFromNorthAmericaQ]);
else
usa=false;
while(online && text[EnterYourPhoneNumber][0]) {
bputs(text[EnterYourPhoneNumber]);
if(!usa) {
if(getstr(useron.phone,LEN_PHONE
,K_UPPER|K_LINE|(cfg.uq&UQ_NOEXASC)|K_EDIT|K_AUTODEL)<5)
continue;
}
else {
if(gettmplt(useron.phone,cfg.sys_phonefmt
,K_LINE|(cfg.uq&UQ_NOEXASC)|K_EDIT)<strlen(cfg.sys_phonefmt))
continue;
}
if(!trashcan(useron.phone,"phone"))
break;
}
}
if(!online) return(FALSE);
if(cfg.uq&UQ_SEX) {
bputs(text[EnterYourSex]);
useron.sex=(char)getkeys("MF",0);
}
while((cfg.uq&UQ_BIRTH) && online) {
bprintf(text[EnterYourBirthday]
,cfg.sys_misc&SM_EURODATE ? "DD/MM/YY" : "MM/DD/YY");
if(gettmplt(useron.birth,"nn/nn/nn",K_EDIT)==8 && getage(&cfg,useron.birth))
break;
}
if(!online) return(FALSE);
while(!(cfg.uq&UQ_NONETMAIL) && online) {
bputs(text[EnterNetMailAddress]);
if(getstr(useron.netmail,LEN_NETMAIL,K_EDIT|K_AUTODEL|K_LINE)
&& !trashcan(useron.netmail,"email"))
break;
}
if(useron.netmail[0] && cfg.sys_misc&SM_FWDTONET && text[ForwardMailQ][0] && yesno(text[ForwardMailQ]))
useron.misc|=NETMAIL;
else
useron.misc&=~NETMAIL;
if(text[UserInfoCorrectQ][0]==0 || yesno(text[UserInfoCorrectQ]))
break;
}
if(!online) return(FALSE);
SAFEPRINTF(str,"New user: %s",useron.alias);
logline("N",str);
if(!online) return(FALSE);
CLS;
SAFEPRINTF(str,"%ssbbs.msg",cfg.text_dir);
printfile(str,P_NOABORT);
if(lncntr)
pause();
CLS;
SAFEPRINTF(str,"%ssystem.msg",cfg.text_dir);
printfile(str,P_NOABORT);
if(lncntr)
pause();
CLS;
SAFEPRINTF(str,"%snewuser.msg",cfg.text_dir);
printfile(str,P_NOABORT);
if(lncntr)
pause();
CLS;
answertime=time(NULL); /* could take 10 minutes to get this far */
/* Default editor (moved here, after terminal type setup Jan-2003) */
for(i=0;i<cfg.total_xedits;i++)
if(!stricmp(cfg.xedit[i]->code,cfg.new_xedit) && chk_ar(cfg.xedit[i]->ar,&useron,&client))
break;
if(i<cfg.total_xedits)
useron.xedit=i+1;
if(cfg.total_xedits && (cfg.uq&UQ_XEDIT) && text[UseExternalEditorQ][0]) {
if(yesno(text[UseExternalEditorQ])) {
for(i=0;i<cfg.total_xedits;i++)
uselect(1,i,text[ExternalEditorHeading],cfg.xedit[i]->name,cfg.xedit[i]->ar);
if((int)(i=uselect(0,useron.xedit ? useron.xedit-1 : 0,0,0,0))>=0)
useron.xedit=i+1;
} else
useron.xedit=0;
}
if(cfg.total_shells>1 && (cfg.uq&UQ_CMDSHELL)) {
for(i=0;i<cfg.total_shells;i++)
uselect(1,i,text[CommandShellHeading],cfg.shell[i]->name,cfg.shell[i]->ar);
if((int)(i=uselect(0,useron.shell,0,0,0))>=0)
useron.shell=i;
}
if(rlogin_pass[0] && chkpass(rlogin_pass,&useron,true)) {
CRLF;
SAFECOPY(useron.pass, rlogin_pass);
strupr(useron.pass); /* passwords are case insensitive, but assumed (in some places) to be uppercase in the user database */
}
else {
c=0;
while(c<LEN_PASS) { /* Create random password */
useron.pass[c]=sbbs_random(43)+'0';
if(isalnum(useron.pass[c]))
c++;
}
useron.pass[c]=0;
bprintf(text[YourPasswordIs],useron.pass);
if(cfg.sys_misc&SM_PWEDIT && text[NewPasswordQ][0] && yesno(text[NewPasswordQ]))
while(online) {
bputs(text[NewPassword]);
getstr(str,LEN_PASS,K_UPPER|K_LINE);
truncsp(str);
if(chkpass(str,&useron,true)) {
SAFECOPY(useron.pass,str);
CRLF;
bprintf(text[YourPasswordIs],useron.pass);
break;
}
CRLF;
}
c=0;
while(online) {
bprintf(text[NewUserPasswordVerify]);
console|=CON_R_ECHOX;
str[0]=0;
getstr(str,LEN_PASS*2,K_UPPER);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
if(!strcmp(str,useron.pass)) break;
if(cfg.sys_misc&SM_ECHO_PW)
SAFEPRINTF3(tmp,"%s FAILED Password verification: '%s' instead of '%s'"
,useron.alias
,str
,useron.pass);
else
SAFEPRINTF(tmp,"%s FAILED Password verification"
,useron.alias);
logline(LOG_NOTICE,nulstr,tmp);
if(++c==4) {
logline(LOG_NOTICE,"N!","Couldn't figure out password.");
hangup();
}
bputs(text[IncorrectPassword]);
bprintf(text[YourPasswordIs],useron.pass);
}
}
if(!online) return(FALSE);
if(cfg.new_magic[0]) {
bputs(text[MagicWordPrompt]);
str[0]=0;
getstr(str,50,K_UPPER);
if(strcmp(str,cfg.new_magic)) {
bputs(text[FailedMagicWord]);
SAFEPRINTF2(tmp,"%s failed magic word: '%s'",useron.alias,str);
logline("N!",tmp);
hangup();
}
if(!online) return(FALSE);
}
bputs(text[CheckingSlots]);
if((i=newuserdat(&cfg,&useron))!=0) {
SAFEPRINTF(str,"user record #%u",useron.number);
errormsg(WHERE,ERR_CREATE,str,i);
hangup();
return(FALSE);
}
SAFEPRINTF2(str,"Created user record #%u: %s",useron.number,useron.alias);
logline(nulstr,str);
if(cfg.new_sif[0]) {
SAFEPRINTF2(str,"%suser/%4.4u.dat",cfg.data_dir,useron.number);
create_sif_dat(cfg.new_sif,str);
}
if(!(cfg.uq&UQ_NODEF))
maindflts(&useron);
delallmail(useron.number, MAIL_ANY);
if(useron.number!=1 && cfg.node_valuser) {
SAFEPRINTF(str,"%sfeedback.msg",cfg.text_dir);
CLS;
printfile(str,P_NOABORT);
safe_snprintf(str,sizeof(str),text[NewUserFeedbackHdr]
,nulstr,getage(&cfg,useron.birth),useron.sex,useron.birth
,useron.name,useron.phone,useron.comp,useron.modem);
email(cfg.node_valuser,str,"New User Validation",WM_EMAIL|WM_SUBJ_RO|WM_FORCEFWD);
if(!useron.fbacks && !useron.emails) {
if(online) { /* didn't hang up */
bprintf(text[NoFeedbackWarning],username(&cfg,cfg.node_valuser,tmp));
email(cfg.node_valuser,str,"New User Validation",WM_EMAIL|WM_SUBJ_RO|WM_FORCEFWD);
} /* give 'em a 2nd try */
if(!useron.fbacks && !useron.emails) {
bprintf(text[NoFeedbackWarning],username(&cfg,cfg.node_valuser,tmp));
logline(LOG_NOTICE,"N!","Aborted feedback");
hangup();
putuserrec(&cfg,useron.number,U_COMMENT,60,"Didn't leave feedback");
putuserrec(&cfg,useron.number,U_MISC,8
,ultoa(useron.misc|DELETED,tmp,16));
putusername(&cfg,useron.number,nulstr);
return(FALSE);
}
}
}
answertime=starttime=time(NULL); /* set answertime to now */
#ifdef JAVASCRIPT
js_create_user_objects();
#endif
if(cfg.newuser_mod[0])
exec_bin(cfg.newuser_mod,&main_csi);
user_event(EVENT_NEWUSER);
getuserdat(&cfg,&useron); // In case event(s) modified user data
logline("N+","Successful new user logon");
sys_status|=SS_NEWUSER;
return(TRUE);
}
bool sbbs_t::inetmail(char *into, char *subj, long mode)
{
char str[256],str2[256],msgpath[256],title[256],name[256],ch
,buf[SDT_BLOCK_LEN],*p,addr[256];
char tmp[512];
char your_addr[128];
ushort xlat=XLAT_NONE,net=NET_INTERNET;
int i,j,x,file;
long l;
ulong length,offset;
FILE *instream;
smbmsg_t msg;
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP) {
bputs(text[TooManyEmailsToday]);
return(false);
}
strcpy(name,into);
strcpy(addr,into);
strcpy(title,subj);
if((!SYSOP && !(cfg.inetmail_misc&NMAIL_ALLOW)) || useron.rest&FLAG('M')) {
bputs(text[NoNetMailAllowed]);
return(false); }
if(cfg.inetmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.inetmail_cost) {
bputs(text[NotEnoughCredits]);
return(false); }
sprintf(str,text[NetMailCostContinueQ],cfg.inetmail_cost);
if(noyes(str))
return(false); }
/* Get destination user name */
p=strrchr(name,'@');
if(!p)
p=strrchr(name,'!');
if(p) {
*p=0;
truncsp(name); }
/* Get this user's internet mailing address */
usermailaddr(&cfg,your_addr
,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
bprintf(text[InternetMailing],addr,your_addr);
action=NODE_SMAL;
nodesync();
sprintf(msgpath,"%snetmail.msg",cfg.node_dir);
if(!writemsg(msgpath,nulstr,title,mode,INVALID_SUB,into)) {
bputs(text[Aborted]);
return(false); }
if(mode&WM_FILE) {
sprintf(str2,"%sfile/%04u.out",cfg.data_dir,useron.number);
MKDIR(str2);
sprintf(str2,"%sfile/%04u.out/%s",cfg.data_dir,useron.number,title);
if(fexistcase(str2)) {
bputs(text[FileAlreadyThere]);
remove(msgpath);
return(false); }
#if 0 /* no such thing as local logon */
if(online==ON_LOCAL) { /* Local upload */
bputs(text[EnterPath]);
if(!getstr(str,60,K_LINE|K_UPPER)) {
bputs(text[Aborted]);
remove(msgpath);
return(false); }
backslash(str);
strcat(str,title);
mv(str,str2,1); }
else
#endif
{ /* 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)) {
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))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,str2,nulstr,true);
}
sprintf(tmp,"%s%s",cfg.temp_dir,title);
if(!fexistcase(str2) && fexistcase(tmp))
mv(tmp,str2,0);
l=flength(str2);
if(l>0)
bprintf(text[FileNBytesReceived],title,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],title);
remove(msgpath);
return(false); } }
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=SMB_SUCCESS) {
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))!=SMB_SUCCESS) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false); }
if(filelength(fileno(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))!=SMB_SUCCESS) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i);
return(false); } }
if((i=smb_locksmbhdr(&smb))!=SMB_SUCCESS) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i);
return(false); }
length=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))!=SMB_SUCCESS) {
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((file=open(msgpath,O_RDONLY|O_BINARY))==-1
|| (instream=fdopen(file,"rb"))==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);
fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
fwrite(&xlat,2,1,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;
fwrite(buf,j,1,smb.sdt_fp);
x=SDT_BLOCK_LEN; }
fflush(smb.sdt_fp);
fclose(instream);
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
msg.hdr.offset=offset;
net=NET_INTERNET;
smb_hfield_str(&msg,RECIPIENT,name);
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
smb_hfield_str(&msg,RECIPIENTNETADDR,addr);
strcpy(str,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
/*
smb_hfield(&msg,SENDERNETTYPE,sizeof(net),&net);
smb_hfield(&msg,SENDERNETADDR,strlen(sys_inetaddr),sys_inetaddr);
*/
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SUBJECT,title);
strcpy(str,title);
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) {
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
smb_freemsgdat(&smb,offset,length,1);
return(false);
}
if(mode&WM_FILE && online==ON_REMOTE)
autohangup();
if(cfg.inetmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.inetmail_sem,nulstr,nulstr,NULL));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.inetmail_cost);
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));
sprintf(str,"%s sent Internet Mail to %s (%s)"
,useron.alias
,name,addr);
logline("EN",str);
return(true);
}
bool sbbs_t::logon()
{
char str[256],c;
char tmp[512];
int file;
uint i,j,mailw;
long kmode;
ulong totallogons;
node_t node;
struct tm tm;
now=time(NULL);
if(localtime_r(&now,&tm)==NULL)
return(false);
if(!useron.number)
return(false);
client.user=useron.alias;
client_on(client_socket,&client,TRUE /* update */);
#ifdef JAVASCRIPT
js_create_user_objects();
#endif
if(useron.rest&FLAG('Q'))
qwklogon=1;
if(SYSOP && !(cfg.sys_misc&SM_R_SYSOP))
return(false);
if(useron.rest&FLAG('G')) { /* Guest account */
useron.misc=(cfg.new_misc&(~ASK_NSCAN));
useron.rows=0;
useron.misc&=~(ANSI|RIP|WIP|NO_EXASCII|COLOR|HTML);
useron.misc|=autoterm;
if(!(useron.misc&ANSI) && text[AnsiTerminalQ][0] && yesno(text[AnsiTerminalQ]))
useron.misc|=ANSI;
if(useron.misc&(RIP|WIP|HTML)
|| (useron.misc&ANSI && text[ColorTerminalQ][0] && yesno(text[ColorTerminalQ])))
useron.misc|=COLOR;
if(text[ExAsciiTerminalQ][0] && !yesno(text[ExAsciiTerminalQ]))
useron.misc|=NO_EXASCII;
for(i=0;i<cfg.total_xedits;i++)
if(!stricmp(cfg.xedit[i]->code,cfg.new_xedit)
&& chk_ar(cfg.xedit[i]->ar,&useron,&client))
break;
if(i<cfg.total_xedits)
useron.xedit=i+1;
else
useron.xedit=0;
useron.prot=cfg.new_prot;
useron.shell=cfg.new_shell;
}
if(!chk_ar(cfg.node_ar,&useron,&client)) {
bputs(text[NoNodeAccess]);
sprintf(str,"(%04u) %-25s Insufficient node access"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
return(false);
}
getnodedat(cfg.node_num,&thisnode,1);
if(thisnode.misc&NODE_LOCK) {
putnodedat(cfg.node_num,&thisnode); /* must unlock! */
if(!SYSOP && !(useron.exempt&FLAG('N'))) {
bputs(text[NodeLocked]);
sprintf(str,"(%04u) %-25s Locked node logon attempt"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
return(false);
}
if(yesno(text[RemoveNodeLockQ])) {
getnodedat(cfg.node_num,&thisnode,1);
logline("S-","Removed Node Lock");
thisnode.misc&=~NODE_LOCK;
}
else
getnodedat(cfg.node_num,&thisnode,1);
}
if(useron.exempt&FLAG('H'))
console|=CON_NO_INACT;
if((useron.exempt&FLAG('Q') && useron.misc&QUIET))
thisnode.status=NODE_QUIET;
else
thisnode.status=NODE_INUSE;
action=thisnode.action=NODE_LOGN;
thisnode.connection=node_connection;
thisnode.misc&=~(NODE_ANON|NODE_INTR|NODE_MSGW|NODE_POFF|NODE_AOFF);
if(useron.chat&CHAT_NOACT)
thisnode.misc|=NODE_AOFF;
if(useron.chat&CHAT_NOPAGE)
thisnode.misc|=NODE_POFF;
thisnode.useron=useron.number;
putnodedat(cfg.node_num,&thisnode);
getusrsubs();
getusrdirs();
if(useron.misc&CURSUB && !(useron.rest&FLAG('G'))) {
for(i=0;i<usrgrps;i++) {
for(j=0;j<usrsubs[i];j++) {
if(!strcmp(cfg.sub[usrsub[i][j]]->code,useron.cursub))
break;
}
if(j<usrsubs[i]) {
curgrp=i;
cursub[i]=j;
break;
}
}
for(i=0;i<usrlibs;i++) {
for(j=0;j<usrdirs[i];j++)
if(!strcmp(cfg.dir[usrdir[i][j]]->code,useron.curdir))
break;
if(j<usrdirs[i]) {
curlib=i;
curdir[i]=j;
break;
}
}
}
if(useron.misc&AUTOTERM) {
useron.misc&=~(ANSI|RIP|WIP|HTML);
useron.misc|=autoterm;
}
if(!chk_ar(cfg.shell[useron.shell]->ar,&useron,&client)) {
useron.shell=cfg.new_shell;
if(!chk_ar(cfg.shell[useron.shell]->ar,&useron,&client)) {
for(i=0;i<cfg.total_shells;i++)
if(chk_ar(cfg.shell[i]->ar,&useron,&client))
break;
if(i==cfg.total_shells)
useron.shell=0;
}
}
logon_ml=useron.level;
logontime=time(NULL);
starttime=logontime;
useron.logontime=(time32_t)logontime;
last_ns_time=ns_time=useron.ns_time;
// ns_time-=(useron.tlast*60); /* file newscan time == last logon time */
delfiles(cfg.temp_dir,ALLFILES);
sprintf(str,"%smsgs/n%3.3u.msg",cfg.data_dir,cfg.node_num);
remove(str); /* remove any pending node messages */
sprintf(str,"%smsgs/n%3.3u.ixb",cfg.data_dir,cfg.node_num);
remove(str); /* remove any pending node message indices */
if(!SYSOP && online==ON_REMOTE && !qwklogon) {
rioctl(IOCM|ABORT); /* users can't abort anything */
rioctl(IOCS|ABORT);
}
CLS;
if(useron.rows)
rows=useron.rows;
unixtodstr(&cfg,(time32_t)logontime,str);
if(!strncmp(str,useron.birth,5) && !(useron.rest&FLAG('Q'))) {
bputs(text[HappyBirthday]);
pause();
CLS;
user_event(EVENT_BIRTHDAY);
}
useron.ltoday++;
gettimeleft();
sprintf(str,"%sfile/%04u.dwn",cfg.data_dir,useron.number);
batch_add_list(str);
if(!qwklogon) { /* QWK Nodes don't go through this */
if(cfg.sys_pwdays
&& (ulong)logontime>(useron.pwmod+((ulong)cfg.sys_pwdays*24UL*60UL*60UL))) {
bprintf(text[TimeToChangePw],cfg.sys_pwdays);
c=0;
while(c<LEN_PASS) { /* Create random password */
str[c]=sbbs_random(43)+'0';
if(isalnum(str[c]))
c++;
}
str[c]=0;
bprintf(text[YourPasswordIs],str);
if(cfg.sys_misc&SM_PWEDIT && yesno(text[NewPasswordQ]))
while(online) {
bputs(text[NewPassword]);
getstr(str,LEN_PASS,K_UPPER|K_LINE);
truncsp(str);
if(chkpass(str,&useron,true))
break;
CRLF;
}
while(online) {
if(cfg.sys_misc&SM_PWEDIT) {
CRLF;
bputs(text[VerifyPassword]);
}
else
bputs(text[NewUserPasswordVerify]);
console|=CON_R_ECHOX;
getstr(tmp,LEN_PASS*2,K_UPPER);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
if(strcmp(str,tmp)) {
bputs(text[Wrong]);
continue;
}
break;
}
strcpy(useron.pass,str);
useron.pwmod=time32(NULL);
putuserrec(&cfg,useron.number,U_PWMOD,8,ultoa((ulong)useron.pwmod,str,16));
bputs(text[PasswordChanged]);
pause();
}
if(useron.ltoday>cfg.level_callsperday[useron.level]
&& !(useron.exempt&FLAG('L'))) {
bputs(text[NoMoreLogons]);
sprintf(str,"(%04u) %-25s Out of logons"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
hangup();
return(false);
}
if(useron.rest&FLAG('L') && useron.ltoday>1) {
bputs(text[R_Logons]);
sprintf(str,"(%04u) %-25s Out of logons"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
hangup();
return(false);
}
kmode=(cfg.uq&UQ_NOEXASC);
if(!(cfg.uq&UQ_NOUPRLWR))
kmode|=K_UPRLWR;
if(!(useron.rest&FLAG('G'))) {
if(!useron.name[0] && ((cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME)
|| cfg.uq&UQ_COMPANY))
while(online) {
if(cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME)
bputs(text[EnterYourRealName]);
else
bputs(text[EnterYourCompany]);
getstr(useron.name,LEN_NAME,kmode);
if(cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME) {
if(trashcan(useron.name,"name") || !useron.name[0]
|| !strchr(useron.name,' ')
|| strchr(useron.name,0xff)
|| (cfg.uq&UQ_DUPREAL
&& userdatdupe(useron.number,U_NAME,LEN_NAME
,useron.name,0,0)))
bputs(text[YouCantUseThatName]);
else
break;
}
else
break;
}
if(cfg.uq&UQ_HANDLE && !useron.handle[0]) {
sprintf(useron.handle,"%.*s",LEN_HANDLE,useron.alias);
while(online) {
bputs(text[EnterYourHandle]);
if(!getstr(useron.handle,LEN_HANDLE
,K_LINE|K_EDIT|K_AUTODEL|(cfg.uq&UQ_NOEXASC))
|| strchr(useron.handle,0xff)
|| (cfg.uq&UQ_DUPHAND
&& userdatdupe(useron.number,U_HANDLE,LEN_HANDLE
,useron.handle,0,0))
|| trashcan(useron.handle,"name"))
bputs(text[YouCantUseThatName]);
else
break;
}
}
if(cfg.uq&UQ_LOCATION && !useron.location[0])
while(online) {
bputs(text[EnterYourCityState]);
if(getstr(useron.location,LEN_LOCATION,kmode))
break;
}
if(cfg.uq&UQ_ADDRESS && !useron.address[0])
while(online) {
bputs(text[EnterYourAddress]);
if(getstr(useron.address,LEN_ADDRESS,kmode))
break;
}
if(cfg.uq&UQ_ADDRESS && !useron.zipcode[0])
while(online) {
bputs(text[EnterYourZipCode]);
if(getstr(useron.zipcode,LEN_ZIPCODE,K_UPPER|(cfg.uq&UQ_NOEXASC)))
break;
}
if(cfg.uq&UQ_PHONE && !useron.phone[0]) {
if(text[CallingFromNorthAmericaQ][0])
i=yesno(text[CallingFromNorthAmericaQ]);
else
i=0;
while(online) {
bputs(text[EnterYourPhoneNumber]);
if(i) {
if(gettmplt(useron.phone,cfg.sys_phonefmt
,K_LINE|(cfg.uq&UQ_NOEXASC))<strlen(cfg.sys_phonefmt))
continue;
} else {
if(getstr(useron.phone,LEN_PHONE
,K_UPPER|(cfg.uq&UQ_NOEXASC))<5)
continue;
}
if(!trashcan(useron.phone,"phone"))
break;
}
}
if(!(cfg.uq&UQ_NONETMAIL) && !useron.netmail[0]) {
while(online) {
bputs(text[EnterNetMailAddress]);
if(getstr(useron.netmail,LEN_NETMAIL,K_EDIT|K_AUTODEL|K_LINE)
&& !trashcan(useron.netmail,"email"))
break;
}
if(useron.netmail[0] && cfg.sys_misc&SM_FWDTONET && !noyes(text[ForwardMailQ]))
useron.misc|=NETMAIL;
else
useron.misc&=~NETMAIL;
}
if(cfg.new_sif[0]) {
sprintf(str,"%suser/%4.4u.dat",cfg.data_dir,useron.number);
if(flength(str)<1L)
create_sif_dat(cfg.new_sif,str);
}
}
}
if(!online) {
sprintf(str,"(%04u) %-25s Unsuccessful logon"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
return(false);
}
SAFECOPY(useron.modem,connection);
useron.logons++;
putuserdat(&cfg,&useron);
getmsgptrs();
sys_status|=SS_USERON; /* moved from further down */
if(useron.rest&FLAG('Q')) {
sprintf(str,"(%04u) %-25s QWK Network Connection"
,useron.number,useron.alias);
logline("++",str);
return(true);
}
/********************/
/* SUCCESSFUL LOGON */
/********************/
totallogons=logonstats();
sprintf(str,"(%04u) %-25s Logon %lu - %u"
,useron.number,useron.alias,totallogons,useron.ltoday);
logline("++",str);
if(!qwklogon && cfg.logon_mod[0])
exec_bin(cfg.logon_mod,&main_csi);
if(thisnode.status!=NODE_QUIET && (!REALSYSOP || cfg.sys_misc&SM_SYSSTAT)) {
sprintf(str,"%slogon.lst",cfg.data_dir);
if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_CREAT|O_APPEND);
return(false);
}
getuserrec(&cfg,useron.number,U_NOTE,LEN_NOTE,useron.note);
getuserrec(&cfg,useron.number,U_LOCATION,LEN_LOCATION,useron.location);
sprintf(str,text[LastFewCallersFmt],cfg.node_num
,totallogons,useron.alias
,cfg.sys_misc&SM_LISTLOC ? useron.location : useron.note
,tm.tm_hour,tm.tm_min
,connection,useron.ltoday > 999 ? 999 : useron.ltoday);
write(file,str,strlen(str));
close(file);
}
if(cfg.sys_logon[0]) /* execute system logon event */
external(cmdstr(cfg.sys_logon,nulstr,nulstr,NULL),EX_STDOUT); /* EX_SH */
if(qwklogon)
return(true);
sys_status|=SS_PAUSEON; /* always force pause on during this section */
mailw=getmail(&cfg,useron.number,0);
if(!(cfg.sys_misc&SM_NOSYSINFO)) {
bprintf(text[SiSysName],cfg.sys_name);
//bprintf(text[SiNodeNumberName],cfg.node_num,cfg.node_name);
bprintf(text[LiUserNumberName],useron.number,useron.alias);
bprintf(text[LiLogonsToday],useron.ltoday
,cfg.level_callsperday[useron.level]);
bprintf(text[LiTimeonToday],useron.ttoday
,cfg.level_timeperday[useron.level]+useron.min);
bprintf(text[LiMailWaiting],mailw);
strcpy(str,text[LiSysopIs]);
if(startup->options&BBS_OPT_SYSOP_AVAILABLE
|| (cfg.sys_chat_ar[0] && chk_ar(cfg.sys_chat_ar,&useron,&client)))
strcat(str,text[LiSysopAvailable]);
else
strcat(str,text[LiSysopNotAvailable]);
bprintf("%s\r\n\r\n",str);
}
if(sys_status&SS_EVENT)
bprintf(text[ReducedTime],timestr(event_time));
getnodedat(cfg.node_num,&thisnode,1);
thisnode.misc&=~(NODE_AOFF|NODE_POFF);
if(useron.chat&CHAT_NOACT)
thisnode.misc|=NODE_AOFF;
if(useron.chat&CHAT_NOPAGE)
thisnode.misc|=NODE_POFF;
putnodedat(cfg.node_num,&thisnode);
getsmsg(useron.number); /* Moved from further down */
SYNC;
c=0;
for(i=1;i<=cfg.sys_nodes;i++)
if(i!=cfg.node_num) {
getnodedat(i,&node,0);
if(!(cfg.sys_misc&SM_NONODELIST)
&& (node.status==NODE_INUSE
|| ((node.status==NODE_QUIET || node.errors) && SYSOP))) {
if(!c)
bputs(text[NodeLstHdr]);
printnodedat(i,&node);
c=1;
}
if(node.status==NODE_INUSE && i!=cfg.node_num && node.useron==useron.number
&& !SYSOP && !(useron.exempt&FLAG('G'))) {
SAFEPRINTF2(str,"(%04u) %-25s On two nodes at the same time"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",str);
bputs(text[UserOnTwoNodes]);
hangup();
return(false);
}
if(thisnode.status!=NODE_QUIET
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)
&& !(node.misc&NODE_AOFF) && node.useron!=useron.number) {
sprintf(str,text[NodeLoggedOnAtNbps]
,cfg.node_num
,thisnode.misc&NODE_ANON ? text[UNKNOWN_USER] : useron.alias
,connection);
putnmsg(&cfg,i,str);
}
}
if(cfg.sys_exp_warn && useron.expire && useron.expire>now /* Warn user of coming */
&& (useron.expire-now)/(1440L*60L)<=cfg.sys_exp_warn) /* expiration */
bprintf(text[AccountWillExpireInNDays],(useron.expire-now)/(1440L*60L));
if(criterrs && SYSOP)
bprintf(text[CriticalErrors],criterrs);
if((i=getuserxfers(0,useron.number,0))!=0)
bprintf(text[UserXferForYou],i,i>1 ? "s" : nulstr);
if((i=getuserxfers(useron.number,0,0))!=0)
bprintf(text[UnreceivedUserXfer],i,i>1 ? "s" : nulstr);
SYNC;
sys_status&=~SS_PAUSEON; /* Turn off the pause override flag */
if(online==ON_REMOTE)
rioctl(IOSM|ABORT); /* Turn abort ability on */
if(text[ReadYourMailNowQ][0] && mailw) {
if(yesno(text[ReadYourMailNowQ]))
readmail(useron.number,MAIL_YOUR);
}
if(usrgrps && useron.misc&ASK_NSCAN && text[NScanAllGrpsQ][0] && yesno(text[NScanAllGrpsQ]))
scanallsubs(SCAN_NEW);
if(usrgrps && useron.misc&ASK_SSCAN && text[SScanAllGrpsQ][0] && yesno(text[SScanAllGrpsQ]))
scanallsubs(SCAN_TOYOU);
return(true);
}
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);
}
ulong sbbs_t::gettimeleft(bool handle_out_of_time)
{
char str[128];
char tmp[512];
event_t nextevent;
now=time(NULL);
timeleft = (ulong)::gettimeleft(&cfg, &useron, starttime);
/* Timed event time reduction handler */
event_time=getnextevent(&cfg, &nextevent);
if(event_time)
event_code=nextevent.code;
if(event_time && now+(time_t)timeleft>event_time) { /* less time, set flag */
if(event_time<now)
timeleft=0;
else
timeleft=(ulong)(event_time-now);
if(!(sys_status&SS_EVENT)) {
lprintf(LOG_NOTICE,"Node %d Time reduced (to %s) due to upcoming event (%s) on %s"
,cfg.node_num,sectostr(timeleft,tmp),event_code,timestr(event_time));
sys_status|=SS_EVENT;
}
}
if((long)timeleft<0) /* timeleft can't go negative */
timeleft=0;
if(thisnode.status==NODE_NEWUSER) {
timeleft=cfg.level_timepercall[cfg.new_level];
if(timeleft<10*60L)
timeleft=10*60L;
}
if(handle_out_of_time && !gettimeleft_inside) /* The following code is not recursive */
{
gettimeleft_inside=1;
if(!timeleft && !SYSOP && !(sys_status&SS_LCHAT)) {
logline(LOG_NOTICE,nulstr,"Ran out of time");
SAVELINE;
if(sys_status&SS_EVENT)
bprintf(text[ReducedTime],timestr(event_time));
bputs(text[TimesUp]);
if(!(sys_status&(SS_EVENT|SS_USERON)) && useron.cdt>=100L*1024L
&& !(cfg.sys_misc&SM_NOCDTCVT)) {
SAFEPRINTF(tmp,text[Convert100ktoNminQ],cfg.cdt_min_value);
if(yesno(tmp)) {
logline(" ","Credit to Minute Conversion");
useron.min=adjustuserrec(&cfg,useron.number,U_MIN,10,cfg.cdt_min_value);
useron.cdt=adjustuserrec(&cfg,useron.number,U_CDT,10,-(102400L));
SAFEPRINTF(str,"Credit Adjustment: %ld",-(102400L));
logline("$-",str);
SAFEPRINTF(str,"Minute Adjustment: %u",cfg.cdt_min_value);
logline("*+",str);
RESTORELINE;
gettimeleft();
gettimeleft_inside=0;
return timeleft;
}
}
if(cfg.sys_misc&SM_TIME_EXP && !(sys_status&SS_EVENT)
&& !(useron.exempt&FLAG('E'))) {
/* set to expired values */
bputs(text[AccountHasExpired]);
SAFEPRINTF(str,"%s Expired",useron.alias);
logentry("!%",str);
if(cfg.level_misc[useron.level]&LEVEL_EXPTOVAL
&& cfg.level_expireto[useron.level]<10) {
useron.flags1=cfg.val_flags1[cfg.level_expireto[useron.level]];
useron.flags2=cfg.val_flags2[cfg.level_expireto[useron.level]];
useron.flags3=cfg.val_flags3[cfg.level_expireto[useron.level]];
useron.flags4=cfg.val_flags4[cfg.level_expireto[useron.level]];
useron.exempt=cfg.val_exempt[cfg.level_expireto[useron.level]];
useron.rest=cfg.val_rest[cfg.level_expireto[useron.level]];
if(cfg.val_expire[cfg.level_expireto[useron.level]])
useron.expire=(time32_t)now
+(cfg.val_expire[cfg.level_expireto[useron.level]]*24*60*60);
else
useron.expire=0;
useron.level=cfg.val_level[cfg.level_expireto[useron.level]];
}
else {
if(cfg.level_misc[useron.level]&LEVEL_EXPTOLVL)
useron.level=cfg.level_expireto[useron.level];
else
useron.level=cfg.expired_level;
useron.flags1&=~cfg.expired_flags1; /* expired status */
useron.flags2&=~cfg.expired_flags2; /* expired status */
useron.flags3&=~cfg.expired_flags3; /* expired status */
useron.flags4&=~cfg.expired_flags4; /* expired status */
useron.exempt&=~cfg.expired_exempt;
useron.rest|=cfg.expired_rest;
useron.expire=0;
}
putuserrec(&cfg,useron.number,U_LEVEL,2,ultoa(useron.level,str,10));
putuserrec(&cfg,useron.number,U_FLAGS1,8,ultoa(useron.flags1,str,16));
putuserrec(&cfg,useron.number,U_FLAGS2,8,ultoa(useron.flags2,str,16));
putuserrec(&cfg,useron.number,U_FLAGS3,8,ultoa(useron.flags3,str,16));
putuserrec(&cfg,useron.number,U_FLAGS4,8,ultoa(useron.flags4,str,16));
putuserrec(&cfg,useron.number,U_EXPIRE,8,ultoa((ulong)useron.expire,str,16));
putuserrec(&cfg,useron.number,U_EXEMPT,8,ultoa(useron.exempt,str,16));
putuserrec(&cfg,useron.number,U_REST,8,ultoa(useron.rest,str,16));
if(cfg.expire_mod[0])
exec_bin(cfg.expire_mod,&main_csi);
RESTORELINE;
gettimeleft();
gettimeleft_inside=0;
return timeleft;
}
SYNC;
hangup();
}
gettimeleft_inside=0;
}
return timeleft;
}
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); }
}
void sbbs_t::logout()
{
char str[256];
char tmp[512];
int i,j;
ushort ttoday;
node_t node;
struct tm tm;
now=time(NULL);
if(localtime_r(&now,&tm)==NULL)
return;
if(!useron.number) { /* Not logged in, so do nothing */
if(!online) {
sprintf(str,"%s T:%3u sec\r\n"
,hhmmtostr(&cfg,&tm,tmp)
,(uint)(now-answertime));
logline("@-",str);
}
return;
}
strcpy(lastuseron,useron.alias); /* for use with WFC status display */
if(useron.rest&FLAG('G')) { /* Reset guest's msg scan cfg */
putuserrec(&cfg,useron.number,U_NAME,LEN_NAME,nulstr);
batdn_total=0;
}
batch_create_list();
if(sys_status&SS_USERON && thisnode.status!=NODE_QUIET && !(useron.rest&FLAG('Q')))
for(i=1;i<=cfg.sys_nodes;i++)
if(i!=cfg.node_num) {
getnodedat(i,&node,0);
if((node.status==NODE_INUSE || node.status==NODE_QUIET)
&& !(node.misc&NODE_AOFF) && node.useron!=useron.number) {
sprintf(str,text[NodeLoggedOff],cfg.node_num
,thisnode.misc&NODE_ANON
? text[UNKNOWN_USER] : useron.alias);
putnmsg(&cfg,i,str); }
}
if(!online) { /* NOT re-login */
#if 0 /* too soon, handled in node_thread */
getnodedat(cfg.node_num,&thisnode,1);
thisnode.status=NODE_WFC;
thisnode.misc&=~(NODE_INTR|NODE_MSGW|NODE_NMSG
|NODE_UDAT|NODE_POFF|NODE_AOFF|NODE_EXT);
putnodedat(cfg.node_num,&thisnode);
#endif
#if 0 /* beep? */
if(sys_status&SS_SYSALERT) {
mswait(500);
offhook();
CLS;
lputs("\r\n\r\nAlerting Sysop...");
while(!lkbrd(1)) {
sbbs_beep(1000,200);
nosound();
mswait(200);
}
lkbrd(0);
}
#endif
sys_status&=~SS_SYSALERT;
if(cfg.sys_logout[0]) /* execute system logout event */
external(cmdstr(cfg.sys_logout,nulstr,nulstr,NULL),EX_OUTL|EX_OFFLINE);
}
if(cfg.logout_mod[0])
exec_bin(cfg.logout_mod,&main_csi);
backout();
sprintf(str,"%smsgs/%4.4u.msg",cfg.data_dir,useron.number);
if(!flength(str)) /* remove any 0 byte message files */
remove(str);
delfiles(cfg.temp_dir,ALLFILES);
putmsgptrs();
if(!REALSYSOP)
logofflist();
useron.laston=(time32_t)now;
ttoday=useron.ttoday-useron.textra; /* billable time used prev calls */
if(ttoday>=cfg.level_timeperday[useron.level])
i=0;
else
i=cfg.level_timeperday[useron.level]-ttoday;
if(i>cfg.level_timepercall[useron.level]) /* i=amount of time without min */
i=cfg.level_timepercall[useron.level];
j=(int)(now-starttime)/60; /* j=billable time online in min */
if(i<0) i=0;
if(j<0) j=0;
if(useron.min && j>i) {
j-=i; /* j=time to deduct from min */
sprintf(str,"Minute Adjustment: %d",-j);
logline(">>",str);
if(useron.min>(ulong)j)
useron.min-=j;
else
useron.min=0L;
putuserrec(&cfg,useron.number,U_MIN,10,ultoa(useron.min,str,10));
}
if(timeleft>0 && starttime-logontime>0) /* extra time */
useron.textra+=(ushort)((starttime-logontime)/60);
putuserrec(&cfg,useron.number,U_TEXTRA,5,ultoa(useron.textra,str,10));
putuserrec(&cfg,useron.number,U_NS_TIME,8,ultoa((ulong)last_ns_time,str,16));
logoutuserdat(&cfg, &useron, now, logontime);
getusrsubs();
getusrdirs();
if(usrgrps>0)
putuserrec(&cfg,useron.number,U_CURSUB,0,cfg.sub[usrsub[curgrp][cursub[curgrp]]]->code);
if(usrlibs>0)
putuserrec(&cfg,useron.number,U_CURDIR,0,cfg.dir[usrdir[curlib][curdir[curlib]]]->code);
hhmmtostr(&cfg,&tm,str);
strcat(str," ");
if(sys_status&SS_USERON)
sprintf(tmp,"T:%3u R:%3lu P:%3lu E:%3lu F:%3lu "
"U:%3luk %lu D:%3luk %lu"
,(uint)(now-logontime)/60,posts_read,logon_posts
,logon_emails,logon_fbacks,logon_ulb/1024UL,logon_uls
,logon_dlb/1024UL,logon_dls);
else
sprintf(tmp,"T:%3u sec",(uint)(now-answertime));
strcat(str,tmp);
strcat(str,"\r\n");
logline("@-",str);
sys_status&=~SS_USERON;
answertime=now; // Incase we're relogging on
}
void sbbs_t::qwktonetmail(FILE *rep, char *block, char *into, uchar fromhub)
{
char *qwkbuf,to[129],name[129],sender[129],senderaddr[129]
,str[256],*p,*cp,*addr,fulladdr[129],ch;
char tmp[512];
int i,fido,inet=0,qnet=0;
ushort net;
uint16_t xlat;
long l,offset,length,m,n;
faddr_t fidoaddr;
fmsghdr_t hdr;
smbmsg_t msg;
struct tm tm;
if(useron.rest&FLAG('M')) {
bputs(text[NoNetMailAllowed]);
return;
}
to[0]=0;
name[0]=0;
sender[0]=0;
senderaddr[0]=0;
fulladdr[0]=0;
sprintf(str,"%.6s",block+116);
n=atol(str); /* i = number of 128 byte records */
if(n<2L || n>999999L) {
errormsg(WHERE,ERR_CHK,"QWK blocks",n);
return;
}
if((qwkbuf=(char *)malloc(n*QWK_BLOCK_LEN))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,n*QWK_BLOCK_LEN);
return;
}
memcpy((char *)qwkbuf,block,QWK_BLOCK_LEN);
fread(qwkbuf+QWK_BLOCK_LEN,n-1,QWK_BLOCK_LEN,rep);
if(into==NULL)
sprintf(to,"%-128.128s",(char *)qwkbuf+QWK_BLOCK_LEN); /* To user on first line */
else
SAFECOPY(to,into);
p=strchr(to,QWK_NEWLINE); /* chop off at first CR */
if(p) *p=0;
SAFECOPY(name,to);
p=strchr(name,'@');
if(p) *p=0;
truncsp(name);
p=strrchr(to,'@'); /* Find '@' in name@addr */
if(p && !isdigit(*(p+1)) && !strchr(p,'.') && !strchr(p,':')) { /* QWKnet */
qnet=1;
*p=0;
}
else if(p==NULL || !isdigit(*(p+1)) || !cfg.total_faddrs) {
if(p==NULL && cfg.dflt_faddr.zone)
fidoaddr=cfg.dflt_faddr;
else if(cfg.inetmail_misc&NMAIL_ALLOW) { /* Internet */
inet=1;
}
else if(cfg.dflt_faddr.zone)
fidoaddr=cfg.dflt_faddr;
else {
bputs(text[InvalidNetMailAddr]);
free(qwkbuf);
return;
}
}
else {
fidoaddr=atofaddr(&cfg,p+1); /* Get fido address */
*p=0; /* Chop off address */
}
if(!inet && !qnet && /* FidoNet */
((!SYSOP && !(cfg.netmail_misc&NMAIL_ALLOW)) || !cfg.total_faddrs)) {
bputs(text[NoNetMailAllowed]);
free(qwkbuf);
return;
}
truncsp(to); /* Truncate off space */
if(!stricmp(to,"SBBS") && !SYSOP && qnet) {
free(qwkbuf);
return;
}
l=QWK_BLOCK_LEN; /* Start of message text */
if(qnet || inet) {
if(into==NULL) { /* If name@addr on first line, skip first line */
while(l<(n*QWK_BLOCK_LEN) && qwkbuf[l]!=QWK_NEWLINE) l++;
l++;
}
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
msg.hdr.when_imported.time=time32(NULL);
msg.hdr.when_imported.zone=sys_timezone(&cfg);
if(fromhub || useron.rest&FLAG('Q')) {
net=NET_QWK;
smb_hfield(&msg,SENDERNETTYPE,sizeof(net),&net);
if(!strncmp(qwkbuf+l,"@VIA:",5)) {
sprintf(str,"%.128s",qwkbuf+l+5);
cp=strchr(str,QWK_NEWLINE);
if(cp) *cp=0;
l+=strlen(str)+1;
cp=str;
while(*cp && *cp<=' ') cp++;
sprintf(senderaddr,"%s/%s"
,fromhub ? cfg.qhub[fromhub-1]->id : useron.alias,cp);
strupr(senderaddr);
smb_hfield(&msg,SENDERNETADDR,strlen(senderaddr),senderaddr);
}
else {
if(fromhub)
SAFECOPY(senderaddr, cfg.qhub[fromhub-1]->id);
else
SAFECOPY(senderaddr, useron.alias);
strupr(senderaddr);
smb_hfield(&msg,SENDERNETADDR,strlen(senderaddr),senderaddr);
}
sprintf(sender,"%.25s",block+46); /* From name */
}
else { /* Not Networked */
msg.hdr.when_written.zone=sys_timezone(&cfg);
sprintf(str,"%u",useron.number);
smb_hfield(&msg,SENDEREXT,strlen(str),str);
SAFECOPY(sender,(qnet || cfg.inetmail_misc&NMAIL_ALIAS)
? useron.alias : useron.name);
}
truncsp(sender);
smb_hfield(&msg,SENDER,strlen(sender),sender);
if(fromhub)
msg.idx.from=0;
else
msg.idx.from=useron.number;
if(!strncmp(qwkbuf+l,"@TZ:",4)) {
sprintf(str,"%.128s",qwkbuf+l);
cp=strchr(str,QWK_NEWLINE);
if(cp) *cp=0;
l+=strlen(str)+1;
cp=str+4;
while(*cp && *cp<=' ') cp++;
msg.hdr.when_written.zone=(short)ahtoul(cp);
}
else
msg.hdr.when_written.zone=sys_timezone(&cfg);
memset(&tm,0,sizeof(tm));
tm.tm_mon=((qwkbuf[8]&0xf)*10)+(qwkbuf[9]&0xf);
if(tm.tm_mon) tm.tm_mon--; /* 0 based */
tm.tm_mday=((qwkbuf[11]&0xf)*10)+(qwkbuf[12]&0xf);
tm.tm_year=((qwkbuf[14]&0xf)*10)+(qwkbuf[15]&0xf);
if(tm.tm_year<Y2K_2DIGIT_WINDOW)
tm.tm_year+=100;
tm.tm_hour=((qwkbuf[16]&0xf)*10)+(qwkbuf[17]&0xf);
tm.tm_min=((qwkbuf[19]&0xf)*10)+(qwkbuf[20]&0xf); /* From QWK time */
tm.tm_sec=0;
tm.tm_isdst=-1; /* Do not adjust for DST */
msg.hdr.when_written.time=mktime32(&tm);
sprintf(str,"%.25s",block+71); /* Title */
smb_hfield(&msg,SUBJECT,strlen(str),str);
}
if(qnet) {
p++;
addr=p;
msg.idx.to=qwk_route(addr,fulladdr);
if(!fulladdr[0]) { /* Invalid address, so BOUNCE it */
/**
errormsg(WHERE,ERR_CHK,addr,0);
free(qwkbuf);
smb_freemsgmem(msg);
return;
**/
smb_hfield(&msg,SENDER,strlen(cfg.sys_id),cfg.sys_id);
msg.idx.from=0;
msg.idx.to=useron.number;
SAFECOPY(to,sender);
SAFECOPY(fulladdr,senderaddr);
SAFEPRINTF(str,"BADADDR: %s",addr);
smb_hfield(&msg,SUBJECT,strlen(str),str);
net=NET_NONE;
smb_hfield(&msg,SENDERNETTYPE,sizeof(net),&net);
}
/* This is required for fixsmb to be able to rebuild the index */
SAFEPRINTF(str,"%u",msg.idx.to);
smb_hfield_str(&msg,RECIPIENTEXT,str);
smb_hfield(&msg,RECIPIENT,strlen(name),name);
net=NET_QWK;
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
truncsp(fulladdr);
if(fulladdr[0])
smb_hfield(&msg,RECIPIENTNETADDR,strlen(fulladdr),fulladdr);
bprintf(text[NetMailing],to,fulladdr,sender,cfg.sys_id);
}
if(inet) { /* Internet E-mail */
if(cfg.inetmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.inetmail_cost) {
bputs(text[NotEnoughCredits]);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
sprintf(str,text[NetMailCostContinueQ],cfg.inetmail_cost);
if(noyes(str)) {
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
}
net=NET_INTERNET;
smb_hfield(&msg,RECIPIENT,strlen(name),name);
msg.idx.to=0; /* Out-bound NetMail set to 0 */
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
smb_hfield(&msg,RECIPIENTNETADDR,strlen(to),to);
bprintf(text[NetMailing],name,to
,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name
,cfg.sys_inetaddr);
}
if(qnet || inet) {
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
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);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
if(smb_fgetlength(smb.shd_fp)<1L) { /* Create it if it doesn't exist */
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((i=smb_create(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i,smb.last_error);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
}
length=n*256L; // Extra big for CRLF xlat, was (n-1L)*256L (03/16/96)
if(length&0xfff00000UL || !length) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
sprintf(str,"REP msg (%ld)",n);
errormsg(WHERE,ERR_LEN,str,length);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
if((i=smb_open_da(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
smb_fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
smb_fwrite(&smb,&xlat,2,smb.sdt_fp);
m=2;
for(;l<n*QWK_BLOCK_LEN && m<length;l++) {
if(qwkbuf[l]==0 || qwkbuf[l]==LF)
continue;
if(qwkbuf[l]==QWK_NEWLINE) {
smb_fwrite(&smb,crlf,2,smb.sdt_fp);
m+=2;
continue;
}
smb_fputc(qwkbuf[l],smb.sdt_fp);
m++;
}
for(ch=0;m<length;m++) /* Pad out with NULLs */
smb_fputc(ch,smb.sdt_fp);
smb_fflush(smb.sdt_fp);
msg.hdr.offset=offset;
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
smb_freemsgdat(&smb,offset,length,1);
}
else { /* Successful */
if(inet) {
if(cfg.inetmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.inetmail_sem,nulstr,nulstr,NULL));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.inetmail_cost);
}
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));
sprintf(str,"%s sent %s NetMail to %s (%s) via QWK"
,useron.alias
,qnet ? "QWK":"Internet",name,qnet ? fulladdr : to);
logline("EN",str);
}
free((char *)qwkbuf);
return;
}
/****************************** FidoNet **********************************/
if(!fidoaddr.zone || !cfg.netmail_dir[0]) { // No fido netmail allowed
bputs(text[InvalidNetMailAddr]);
free(qwkbuf);
return;
}
memset(&hdr,0,sizeof(hdr)); /* Initialize header to null */
if(fromhub || useron.rest&FLAG('Q')) {
sprintf(str,"%.25s",block+46); /* From */
truncsp(str);
sprintf(tmp,"@%s",fromhub ? cfg.qhub[fromhub-1]->id : useron.alias);
strupr(tmp);
strcat(str,tmp);
}
else
SAFECOPY(str,cfg.netmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
SAFECOPY(hdr.from,str);
SAFECOPY(hdr.to,to);
/* Look-up in nodelist? */
if(cfg.netmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.netmail_cost) {
bputs(text[NotEnoughCredits]);
free(qwkbuf);
return;
}
sprintf(str,text[NetMailCostContinueQ],cfg.netmail_cost);
if(noyes(str)) {
free(qwkbuf);
return;
}
}
hdr.destzone =fidoaddr.zone;
hdr.destnet =fidoaddr.net;
hdr.destnode =fidoaddr.node;
hdr.destpoint =fidoaddr.point;
for(i=0;i<cfg.total_faddrs;i++)
if(fidoaddr.zone==cfg.faddr[i].zone && fidoaddr.net==cfg.faddr[i].net)
break;
if(i==cfg.total_faddrs) {
for(i=0;i<cfg.total_faddrs;i++)
if(fidoaddr.zone==cfg.faddr[i].zone)
break;
}
if(i==cfg.total_faddrs)
i=0;
hdr.origzone =cfg.faddr[i].zone;
hdr.orignet =cfg.faddr[i].net;
hdr.orignode =cfg.faddr[i].node;
hdr.origpoint =cfg.faddr[i].point;
smb_faddrtoa(&cfg.faddr[i],str);
bprintf(text[NetMailing],hdr.to,smb_faddrtoa(&fidoaddr,tmp),hdr.from,str);
tm.tm_mon=((qwkbuf[8]&0xf)*10)+(qwkbuf[9]&0xf);
if (tm.tm_mon) tm.tm_mon--;
tm.tm_mday=((qwkbuf[11]&0xf)*10)+(qwkbuf[12]&0xf);
tm.tm_year=((qwkbuf[14]&0xf)*10)+(qwkbuf[15]&0xf)+1900;
tm.tm_hour=((qwkbuf[16]&0xf)*10)+(qwkbuf[17]&0xf);
tm.tm_min=((qwkbuf[19]&0xf)*10)+(qwkbuf[20]&0xf); /* From QWK time */
tm.tm_sec=0;
sprintf(hdr.time,"%02u %3.3s %02u %02u:%02u:%02u" /* To FidoNet */
,tm.tm_mday,mon[tm.tm_mon],TM_YEAR(tm.tm_year)
,tm.tm_hour,tm.tm_min,tm.tm_sec);
hdr.attr=(FIDO_LOCAL|FIDO_PRIVATE);
if(cfg.netmail_misc&NMAIL_CRASH) hdr.attr|=FIDO_CRASH;
if(cfg.netmail_misc&NMAIL_HOLD) hdr.attr|=FIDO_HOLD;
if(cfg.netmail_misc&NMAIL_KILL) hdr.attr|=FIDO_KILLSENT;
sprintf(str,"%.25s",block+71); /* Title */
truncsp(str);
p=str;
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"CR:",3)) { /* Crash over-ride by sysop */
p+=3; /* skip CR: */
if(*p==' ') p++; /* skip extra space if it exists */
hdr.attr|=FIDO_CRASH;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FR:",3)) { /* File request */
p+=3; /* skip FR: */
if(*p==' ') p++;
hdr.attr|=FIDO_FREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"RR:",3)) { /* Return receipt request */
p+=3; /* skip RR: */
if(*p==' ') p++;
hdr.attr|=FIDO_RRREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FA:",3)) { /* File attachment */
p+=3; /* skip FA: */
if(*p==' ') p++;
hdr.attr|=FIDO_FILE;
}
SAFECOPY(hdr.subj,p);
md(cfg.netmail_dir);
for(i=1;i;i++) {
sprintf(str,"%s%u.msg", cfg.netmail_dir,i);
if(!fexistcase(str))
break;
}
if(!i) {
bputs(text[TooManyEmailsToday]);
return;
}
if((fido=nopen(str,O_WRONLY|O_CREAT|O_EXCL))==-1) {
free(qwkbuf);
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_EXCL);
return;
}
write(fido,&hdr,sizeof(hdr));
pt_zone_kludge(hdr,fido);
if(cfg.netmail_misc&NMAIL_DIRECT) {
sprintf(str,"\1FLAGS DIR\r\n");
write(fido,str,strlen(str));
}
l=QWK_BLOCK_LEN;
if(into==NULL) { /* If name@addr on first line, skip first line */
while(l<n*QWK_BLOCK_LEN && qwkbuf[l]!=QWK_NEWLINE) l++;
l++;
}
length=n*QWK_BLOCK_LEN;
while(l<length) {
if(qwkbuf[l]==CTRL_A) { /* Ctrl-A, so skip it and the next char */
l++;
if(l>=length || toupper(qwkbuf[l])=='Z') /* EOF */
break;
if((ch=ctrl_a_to_ascii_char(qwkbuf[l])) != 0)
write(fido,&ch,1);
}
else if(qwkbuf[l]!=LF) {
if(qwkbuf[l]==QWK_NEWLINE) /* QWK cr/lf char converted to hard CR */
qwkbuf[l]=CR;
write(fido,(char *)qwkbuf+l,1);
}
l++;
}
l=0;
write(fido,&l,1); /* Null terminator */
close(fido);
free((char *)qwkbuf);
if(cfg.netmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.netmail_sem,nulstr,nulstr,NULL));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.netmail_cost);
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));
sprintf(str,"%s sent NetMail to %s @%s via QWK"
,useron.alias
,hdr.to,smb_faddrtoa(&fidoaddr,tmp));
logline("EN",str);
}
bool sbbs_t::netmail(const char *into, const char *title, long mode)
{
char str[256],subj[128],to[256],fname[128],*buf,*p,ch;
char tmp[512];
int file,fido,x,cc_found,cc_sent;
uint i;
long length,l;
faddr_t addr;
fmsghdr_t hdr;
struct tm tm;
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP && !(useron.exempt&FLAG('M'))) {
bputs(text[TooManyEmailsToday]);
return(false);
}
SAFECOPY(subj,title);
strcpy(to,into);
lookup_netuser(to);
p=strrchr(to,'@'); /* Find '@' in name@addr */
if(p && !isdigit(*(p+1)) && !strchr(p,'.') && !strchr(p,':')) {
mode&=~WM_FILE;
qnetmail(to,title,mode|WM_NETMAIL);
return(false);
}
if(!cfg.total_faddrs || p==NULL || !strchr(p+1,'/')) {
if(!p && cfg.dflt_faddr.zone)
addr=cfg.dflt_faddr;
else if(cfg.inetmail_misc&NMAIL_ALLOW) {
if(mode&WM_FILE && !SYSOP && !(cfg.inetmail_misc&NMAIL_FILE))
mode&=~WM_FILE;
return(inetmail(into,title,mode|WM_NETMAIL));
}
else if(cfg.dflt_faddr.zone)
addr=cfg.dflt_faddr;
else {
bputs(text[InvalidNetMailAddr]);
return(false);
}
} else {
addr=atofaddr(&cfg,p+1); /* Get fido address */
*p=0; /* Chop off address */
}
if(mode&WM_FILE && !SYSOP && !(cfg.netmail_misc&NMAIL_FILE))
mode&=~WM_FILE;
if((!SYSOP && !(cfg.netmail_misc&NMAIL_ALLOW)) || useron.rest&FLAG('M')
|| !cfg.total_faddrs) {
bputs(text[NoNetMailAllowed]);
return(false);
}
truncsp(to); /* Truncate off space */
memset(&hdr,0,sizeof(hdr)); /* Initialize header to null */
strcpy(hdr.from,cfg.netmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
SAFECOPY(hdr.to,to);
/* Look-up in nodelist? */
if(cfg.netmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.netmail_cost) {
bputs(text[NotEnoughCredits]);
return(false);
}
sprintf(str,text[NetMailCostContinueQ],cfg.netmail_cost);
if(noyes(str))
return(false);
}
now=time(NULL);
if(localtime_r(&now,&tm)!=NULL)
sprintf(hdr.time,"%02u %3.3s %02u %02u:%02u:%02u"
,tm.tm_mday,mon[tm.tm_mon],TM_YEAR(tm.tm_year)
,tm.tm_hour,tm.tm_min,tm.tm_sec);
hdr.destzone =addr.zone;
hdr.destnet =addr.net;
hdr.destnode =addr.node;
hdr.destpoint =addr.point;
for(i=0;i<cfg.total_faddrs;i++)
if(addr.zone==cfg.faddr[i].zone && addr.net==cfg.faddr[i].net)
break;
if(i==cfg.total_faddrs) {
for(i=0;i<cfg.total_faddrs;i++)
if(addr.zone==cfg.faddr[i].zone)
break;
}
if(i==cfg.total_faddrs)
i=0;
hdr.origzone =cfg.faddr[i].zone;
hdr.orignet =cfg.faddr[i].net;
hdr.orignode =cfg.faddr[i].node;
hdr.origpoint =cfg.faddr[i].point;
smb_faddrtoa(&cfg.faddr[i],str);
bprintf(text[NetMailing],hdr.to,smb_faddrtoa(&addr,tmp),hdr.from,str);
hdr.attr=(FIDO_LOCAL|FIDO_PRIVATE);
if(cfg.netmail_misc&NMAIL_CRASH) hdr.attr|=FIDO_CRASH;
if(cfg.netmail_misc&NMAIL_HOLD) hdr.attr|=FIDO_HOLD;
if(cfg.netmail_misc&NMAIL_KILL) hdr.attr|=FIDO_KILLSENT;
if(mode&WM_FILE) hdr.attr|=FIDO_FILE;
sprintf(str,"%sNETMAIL.MSG", cfg.node_dir);
remove(str); /* Just incase it's already there */
// mode&=~WM_FILE;
if(!writemsg(str,nulstr,subj,WM_NETMAIL|mode,INVALID_SUB,into)) {
bputs(text[Aborted]);
return(false);
}
if(mode&WM_FILE) {
strcpy(fname,subj);
sprintf(str,"%sfile/%04u.out", cfg.data_dir, useron.number);
MKDIR(str);
strcpy(tmp, cfg.data_dir);
if(tmp[0]=='.') /* Relative path */
sprintf(tmp,"%s%s", cfg.node_dir, cfg.data_dir);
sprintf(str,"%sfile/%04u.out/%s",tmp,useron.number,fname);
strcpy(subj,str);
if(fexistcase(str)) {
bputs(text[FileAlreadyThere]);
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]);
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,subj,nulstr,true);
}
sprintf(tmp,"%s%s",cfg.temp_dir,title);
if(!fexistcase(subj) && fexistcase(tmp))
mv(tmp,subj,0);
l=(long)flength(subj);
if(l>0)
bprintf(text[FileNBytesReceived],fname,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],fname);
return(false);
}
}
p=subj;
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"CR:",3)) { /* Crash over-ride by sysop */
p+=3; /* skip CR: */
if(*p==' ') p++; /* skip extra space if it exists */
hdr.attr|=FIDO_CRASH;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FR:",3)) { /* File request */
p+=3; /* skip FR: */
if(*p==' ') p++;
hdr.attr|=FIDO_FREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"RR:",3)) { /* Return receipt request */
p+=3; /* skip RR: */
if(*p==' ') p++;
hdr.attr|=FIDO_RRREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FA:",3)) { /* File Attachment */
p+=3; /* skip FA: */
if(*p==' ') p++;
hdr.attr|=FIDO_FILE;
}
SAFECOPY(hdr.subj,p);
sprintf(str,"%sNETMAIL.MSG", cfg.node_dir);
if((file=nopen(str,O_RDONLY))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(false);
}
length=(long)filelength(file);
if((buf=(char *)malloc(length))==NULL) {
close(file);
errormsg(WHERE,ERR_ALLOC,str,length);
return(false);
}
read(file,buf,length);
close(file);
md(cfg.netmail_dir);
cc_sent=0;
while(1) {
for(i=1;i;i++) {
sprintf(str,"%s%u.msg", cfg.netmail_dir,i);
if(!fexistcase(str))
break;
}
if(!i) {
bputs(text[TooManyEmailsToday]);
return(false);
}
if((fido=nopen(str,O_WRONLY|O_CREAT|O_EXCL))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_EXCL);
return(false);
}
write(fido,&hdr,sizeof(hdr));
pt_zone_kludge(hdr,fido);
if(cfg.netmail_misc&NMAIL_DIRECT) {
SAFECOPY(str,"\1FLAGS DIR\r\n");
write(fido,str,strlen(str));
}
if(mode&WM_FILE) {
SAFECOPY(str,"\1FLAGS KFS\r\n");
write(fido,str,strlen(str));
}
if(cc_sent) {
SAFEPRINTF(str,"* Originally to: %s\r\n\r\n",into);
write(fido,str,strlen(str));
}
l=0L;
while(l<length) {
if(buf[l]==CTRL_A) { /* Ctrl-A, so skip it and the next char */
l++;
if(l>=length || toupper(buf[l])=='Z') /* EOF */
break;
if((ch=ctrl_a_to_ascii_char(buf[l])) != 0)
write(fido,&ch,1);
}
else if(buf[l]!=LF) {
if((uchar)buf[l]==0x8d) /* r0dent i converted to normal i */
buf[l]='i';
write(fido,buf+l,1);
}
l++;
}
l=0;
write(fido,&l,1); /* Null terminator */
close(fido);
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));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.netmail_cost);
if(mode&WM_FILE)
sprintf(str,"%s sent NetMail file attachment to %s (%s)"
,useron.alias
,hdr.to,smb_faddrtoa(&addr,tmp));
else
sprintf(str,"%s sent NetMail to %s (%s)"
,useron.alias
,hdr.to,smb_faddrtoa(&addr,tmp));
logline("EN",str);
cc_found=0;
for(l=0;l<length && cc_found<=cc_sent;l++)
if(l+3<length && !strnicmp(buf+l,"CC:",3)) {
cc_found++;
l+=2;
}
else {
while(l<length && *(buf+l)!=LF)
l++;
}
if(!cc_found)
break;
while(l<length && *(buf+l)==' ') l++;
for(i=0;l<length && *(buf+l)!=LF && i<128;i++,l++)
str[i]=buf[l];
if(!i)
break;
str[i]=0;
p=strrchr(str,'@');
if(p) {
addr=atofaddr(&cfg,p+1);
*p=0;
SAFECOPY(hdr.to,str);
}
else {
atofaddr(&cfg,str);
strcpy(hdr.to,"Sysop");
}
hdr.destzone =addr.zone;
hdr.destnet =addr.net;
hdr.destnode =addr.node;
hdr.destpoint =addr.point;
cc_sent++;
}
if(cfg.netmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.netmail_sem,nulstr,nulstr,NULL));
free(buf);
return(true);
}
bool sbbs_t::answer()
{
char str[MAX_PATH+1],str2[MAX_PATH+1],c;
char tmp[(MAX_PATH > CRYPT_MAX_TEXTSIZE ? MAX_PATH:CRYPT_MAX_TEXTSIZE)+1];
char tmpname[CRYPT_MAX_TEXTSIZE+1];
char path[MAX_PATH+1];
int i,l,in;
struct tm tm;
useron.number=0;
answertime=logontime=starttime=now=time(NULL);
/* Caller ID is IP address */
SAFECOPY(cid,client_ipaddr);
memset(&tm,0,sizeof(tm));
localtime_r(&now,&tm);
safe_snprintf(str,sizeof(str),"%s %s %s %02d %u Node %3u"
,hhmmtostr(&cfg,&tm,str2)
,wday[tm.tm_wday]
,mon[tm.tm_mon],tm.tm_mday,tm.tm_year+1900,cfg.node_num);
logline("@ ",str);
safe_snprintf(str,sizeof(str),"%s %s [%s]", connection, client_name, cid);
logline("@+:",str);
if(client_ident[0]) {
safe_snprintf(str,sizeof(str),"Identity: %s",client_ident);
logline("@*",str);
}
online=ON_REMOTE;
if(sys_status&SS_RLOGIN) {
if(incom(1000)==0) {
for(i=0;i<(int)sizeof(str)-1;i++) {
in=incom(1000);
if(in==0 || in==NOINP)
break;
str[i]=in;
}
str[i]=0;
for(i=0;i<(int)sizeof(str2)-1;i++) {
in=incom(1000);
if(in==0 || in==NOINP)
break;
str2[i]=in;
}
str2[i]=0;
for(i=0;i<(int)sizeof(terminal)-1;i++) {
in=incom(1000);
if(in==0 || in==NOINP)
break;
terminal[i]=in;
}
terminal[i]=0;
lprintf(LOG_DEBUG,"Node %d RLogin: '******' / '%.*s' / '%s'"
,cfg.node_num
,LEN_ALIAS*2,str
,LEN_ALIAS*2,str2
,terminal);
SAFECOPY(rlogin_term, terminal);
SAFECOPY(rlogin_name, str2);
SAFECOPY(rlogin_pass, str);
/* Truncate terminal speed (e.g. "/57600") from terminal-type string
(but keep full terminal type/speed string in rlogin_term): */
truncstr(terminal,"/");
useron.number=userdatdupe(0, U_ALIAS, LEN_ALIAS, rlogin_name);
if(useron.number) {
getuserdat(&cfg,&useron);
useron.misc&=~TERM_FLAGS;
SAFEPRINTF(path,"%srlogin.cfg",cfg.ctrl_dir);
if(!findstr(client.addr,path)) {
SAFECOPY(tmp, rlogin_pass);
for(i=0;i<3;i++) {
if(stricmp(tmp,useron.pass)) {
badlogin(useron.alias, tmp);
rioctl(IOFI); /* flush input buffer */
bputs(text[InvalidLogon]);
if(cfg.sys_misc&SM_ECHO_PW)
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt: '%s'"
,0,useron.alias,tmp);
else
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt"
,0,useron.alias);
logline(LOG_NOTICE,"+!",str);
bputs(text[PasswordPrompt]);
console|=CON_R_ECHOX;
getstr(tmp,LEN_PASS*2,K_UPPER|K_LOWPRIO|K_TAB);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
}
else {
if(REALSYSOP) {
rioctl(IOFI); /* flush input buffer */
if(!chksyspass())
bputs(text[InvalidLogon]);
else {
i=0;
break;
}
}
else
break;
}
}
if(i) {
if(stricmp(tmp,useron.pass)) {
badlogin(useron.alias, tmp);
bputs(text[InvalidLogon]);
if(cfg.sys_misc&SM_ECHO_PW)
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt: '%s'"
,0,useron.alias,tmp);
else
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt"
,0,useron.alias);
logline(LOG_NOTICE,"+!",str);
}
lprintf(LOG_WARNING,"Node %d !CLIENT IP NOT LISTED in %s"
,cfg.node_num,path);
useron.number=0;
hangup();
}
}
}
else
lprintf(LOG_INFO,"Node %d RLogin: Unknown user: %s",cfg.node_num,rlogin_name);
}
if(rlogin_name[0]==0) {
lprintf(LOG_NOTICE,"Node %d !RLogin: No user name received",cfg.node_num);
sys_status&=~SS_RLOGIN;
}
}
if(!(telnet_mode&TELNET_MODE_OFF)) {
/* Disable Telnet Terminal Echo */
request_telnet_opt(TELNET_WILL,TELNET_ECHO);
/* Will suppress Go Ahead */
request_telnet_opt(TELNET_WILL,TELNET_SUP_GA);
/* Retrieve terminal type and speed from telnet client --RS */
request_telnet_opt(TELNET_DO,TELNET_TERM_TYPE);
request_telnet_opt(TELNET_DO,TELNET_TERM_SPEED);
request_telnet_opt(TELNET_DO,TELNET_SEND_LOCATION);
request_telnet_opt(TELNET_DO,TELNET_NEGOTIATE_WINDOW_SIZE);
request_telnet_opt(TELNET_DO,TELNET_NEW_ENVIRON);
}
#ifdef USE_CRYPTLIB
if(sys_status&SS_SSH) {
pthread_mutex_lock(&ssh_mutex);
cryptGetAttributeString(ssh_session, CRYPT_SESSINFO_USERNAME, tmpname, &i);
tmpname[i]=0;
SAFECOPY(rlogin_name, tmpname);
cryptGetAttributeString(ssh_session, CRYPT_SESSINFO_PASSWORD, tmp, &i);
tmp[i]=0;
SAFECOPY(rlogin_pass, tmp);
pthread_mutex_unlock(&ssh_mutex);
lprintf(LOG_DEBUG,"Node %d SSH login: '******'"
,cfg.node_num, tmpname);
useron.number=userdatdupe(0, U_ALIAS, LEN_ALIAS, tmpname);
if(useron.number) {
getuserdat(&cfg,&useron);
useron.misc&=~TERM_FLAGS;
for(i=0;i<3;i++) {
if(stricmp(tmp,useron.pass)) {
badlogin(useron.alias, tmp);
rioctl(IOFI); /* flush input buffer */
bputs(text[InvalidLogon]);
if(cfg.sys_misc&SM_ECHO_PW)
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt: '%s'"
,0,useron.alias,tmp);
else
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt"
,0,useron.alias);
/* crash here Sept-12-2010
str 0x06b3fc4c "(0000) Guest FAILED Password attempt: '*****@*****.**'"
and Oct-6-2010
str 0x070ffc4c "(0000) Woot903 FAILED Password attempt: 'p67890pppsdsjhsdfhhfhnhnfhfhfdhjksdjkfdskw3902391=`'" char [261]
*/
logline(LOG_NOTICE,"+!",str);
bputs(text[PasswordPrompt]);
console|=CON_R_ECHOX;
getstr(tmp,LEN_PASS*2,K_UPPER|K_LOWPRIO|K_TAB);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
}
else {
if(REALSYSOP) {
rioctl(IOFI); /* flush input buffer */
if(!chksyspass())
bputs(text[InvalidLogon]);
else {
i=0;
break;
}
}
else
break;
}
}
if(i) {
if(stricmp(tmp,useron.pass)) {
badlogin(useron.alias, tmp);
bputs(text[InvalidLogon]);
if(cfg.sys_misc&SM_ECHO_PW)
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt: '%s'"
,0,useron.alias,tmp);
else
safe_snprintf(str,sizeof(str),"(%04u) %-25s FAILED Password attempt"
,0,useron.alias);
logline(LOG_NOTICE,"+!",str);
}
useron.number=0;
hangup();
}
}
else
lprintf(LOG_INFO,"Node %d SSH: Unknown user: %s",cfg.node_num,rlogin_name);
}
#endif
/* Detect terminal type */
mswait(200);
rioctl(IOFI); /* flush input buffer */
putcom( "\r\n" /* locate cursor at column 1 */
"\x1b[s" /* save cursor position (necessary for HyperTerm auto-ANSI) */
"\x1b[255B" /* locate cursor as far down as possible */
"\x1b[255C" /* locate cursor as far right as possible */
"\b_" /* need a printable at this location to actually move cursor */
"\x1b[6n" /* Get cursor position */
"\x1b[u" /* restore cursor position */
"\x1b[!_" /* RIP? */
"\x1b[30;40m\xc2\x9f""Zuul.connection.write('\\x1b""Are you the gatekeeper?')\xc2\x9c" /* ZuulTerm? */
"\x1b[0m_" /* "Normal" colors */
"\x1b[2J" /* clear screen */
"\x1b[H" /* home cursor */
"\xC" /* clear screen (in case not ANSI) */
"\r" /* Move cursor left (in case previous char printed) */
);
i=l=0;
tos=1;
lncntr=0;
safe_snprintf(str, sizeof(str), "%s %s", VERSION_NOTICE, COPYRIGHT_NOTICE);
strip_ctrl(str, str);
center(str);
while(i++<50 && l<(int)sizeof(str)-1) { /* wait up to 5 seconds for response */
c=incom(100)&0x7f;
if(c==0)
continue;
i=0;
if(l==0 && c!=ESC) // response must begin with escape char
continue;
str[l++]=c;
if(c=='R') { /* break immediately if ANSI response */
mswait(500);
break;
}
}
while((c=(incom(100)&0x7f))!=0 && l<(int)sizeof(str)-1)
str[l++]=c;
str[l]=0;
if(l) {
c_escape_str(str,tmp,sizeof(tmp),TRUE);
lprintf(LOG_DEBUG,"Node %d received terminal auto-detection response: '%s'"
,cfg.node_num,tmp);
if(str[0]==ESC && str[1]=='[' && str[l-1]=='R') {
int x,y;
if(terminal[0]==0)
SAFECOPY(terminal,"ANSI");
autoterm|=(ANSI|COLOR);
if(sscanf(str+2,"%u;%u",&y,&x)==2) {
lprintf(LOG_DEBUG,"Node %d received ANSI cursor position report: %ux%u"
,cfg.node_num, x, y);
/* Sanity check the coordinates in the response: */
if(x>=40 && x<=255) cols=x;
if(y>=10 && y<=255) rows=y;
}
}
truncsp(str);
if(strstr(str,"RIPSCRIP")) {
if(terminal[0]==0)
SAFECOPY(terminal,"RIP");
logline("@R",strstr(str,"RIPSCRIP"));
autoterm|=(RIP|COLOR|ANSI); }
else if(strstr(str,"Are you the gatekeeper?")) {
if(terminal[0]==0)
SAFECOPY(terminal,"HTML");
logline("@H",strstr(str,"Are you the gatekeeper?"));
autoterm|=HTML;
}
}
else if(terminal[0]==0)
SAFECOPY(terminal,"DUMB");
rioctl(IOFI); /* flush left-over or late response chars */
if(!autoterm && str[0]) {
c_escape_str(str,tmp,sizeof(tmp),TRUE);
lprintf(LOG_NOTICE,"Node %d terminal auto-detection failed, response: '%s'"
,cfg.node_num, tmp);
}
/* AutoLogon via IP or Caller ID here */
if(!useron.number && !(sys_status&SS_RLOGIN)
&& (startup->options&BBS_OPT_AUTO_LOGON) && cid[0]) {
useron.number=userdatdupe(0, U_NOTE, LEN_NOTE, cid);
if(useron.number) {
getuserdat(&cfg, &useron);
if(!(useron.misc&AUTOLOGON) || !(useron.exempt&FLAG('V')))
useron.number=0;
}
}
if(!online)
return(false);
if(stricmp(terminal,"sexpots")==0) { /* dial-up connection (via SexPOTS) */
SAFEPRINTF2(str,"%s connection detected at %lu bps", terminal, cur_rate);
logline("@S",str);
node_connection = (ushort)cur_rate;
SAFEPRINTF(connection,"%lu",cur_rate);
SAFECOPY(cid,"Unknown");
SAFECOPY(client_name,"Unknown");
if(telnet_location[0]) { /* Caller-ID info provided */
SAFEPRINTF(str, "CID: %s", telnet_location);
logline("@*",str);
SAFECOPY(cid,telnet_location);
truncstr(cid," "); /* Only include phone number in CID */
char* p=telnet_location;
FIND_WHITESPACE(p);
SKIP_WHITESPACE(p);
if(*p) {
SAFECOPY(client_name,p); /* CID name, if provided (maybe 'P' or 'O' if private or out-of-area) */
}
}
SAFECOPY(client.addr,cid);
SAFECOPY(client.host,client_name);
client_on(client_socket,&client,TRUE /* update */);
} else {
if(telnet_location[0]) { /* Telnet Location info provided */
SAFEPRINTF(str, "Telnet Location: %s", telnet_location);
logline("@*",str);
}
}
useron.misc&=~TERM_FLAGS;
useron.misc|=autoterm;
SAFECOPY(useron.comp,client_name);
if(!useron.number && rlogin_name[0]!=0 && !(cfg.sys_misc&SM_CLOSED) && !matchuser(&cfg, rlogin_name, /* Sysop alias: */FALSE)) {
lprintf(LOG_INFO,"Node %d UNKNOWN %s-specified USERNAME: %s, starting new user signup",cfg.node_num,client.protocol,rlogin_name);
bprintf("%s: %s\r\n", text[UNKNOWN_USER], rlogin_name);
newuser();
}
if(!useron.number) { /* manual/regular logon */
/* Display ANSWER screen */
rioctl(IOSM|PAUSE);
sys_status|=SS_PAUSEON;
SAFEPRINTF(str,"%sanswer",cfg.text_dir);
SAFEPRINTF(path,"%s.rip",str);
if((autoterm&RIP) && fexistcase(path))
printfile(path,P_NOABORT);
else {
SAFEPRINTF(path,"%s.html",str);
if((autoterm&HTML) && fexistcase(path))
printfile(path,P_NOABORT);
else {
SAFEPRINTF(path,"%s.ans",str);
if((autoterm&ANSI) && fexistcase(path))
printfile(path,P_NOABORT);
else {
SAFEPRINTF(path,"%s.asc",str);
if(fexistcase(path))
printfile(path, P_NOABORT);
}
}
}
sys_status&=~SS_PAUSEON;
exec_bin(cfg.login_mod,&main_csi);
} else /* auto logon here */
if(logon()==false)
return(false);
if(!useron.number)
hangup();
/* Save the IP to the user's note */
if(cid[0]) {
SAFECOPY(useron.note,cid);
putuserrec(&cfg,useron.number,U_NOTE,LEN_NOTE,useron.note);
}
/* Save host name to the user's computer description */
if(client_name[0]) {
SAFECOPY(useron.comp,client_name);
putuserrec(&cfg,useron.number,U_COMP,LEN_COMP,useron.comp);
}
if(!online)
return(false);
if(!(sys_status&SS_USERON)) {
errormsg(WHERE,ERR_CHK,"User not logged on",0);
hangup();
return(false);
}
if(useron.pass[0])
loginSuccess(startup->login_attempt_list, &client_addr);
return(true);
}
bool sbbs_t::qnetmail(char *into, char *subj, long mode)
{
char str[256],msgpath[128],title[128],to[128],fulladdr[128]
,buf[SDT_BLOCK_LEN],*addr;
char tmp[512];
ushort xlat=XLAT_NONE,net=NET_QWK,touser;
int i,j,x,file;
ulong length,offset;
FILE *instream;
smbmsg_t msg;
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP) {
bputs(text[TooManyEmailsToday]);
return(false);
}
strcpy(to,into);
strcpy(title,subj);
if(useron.rest&FLAG('M')) {
bputs(text[NoNetMailAllowed]);
return(false); }
addr=strrchr(to,'@');
if(!addr) {
bputs(text[InvalidNetMailAddr]);
return(false);
}
*addr=0;
addr++;
strupr(addr);
truncsp(addr);
touser=qwk_route(addr,fulladdr);
if(!fulladdr[0]) {
bputs(text[InvalidNetMailAddr]);
return(false);
}
truncsp(to);
if(!stricmp(to,"SBBS") && !SYSOP) {
bputs(text[InvalidNetMailAddr]);
return(false);
}
bprintf(text[NetMailing],to,fulladdr
,useron.alias,cfg.sys_id);
action=NODE_SMAL;
nodesync();
sprintf(msgpath,"%snetmail.msg",cfg.node_dir);
if(!writemsg(msgpath,nulstr,title,mode|WM_QWKNET,INVALID_SUB,to)) {
bputs(text[Aborted]);
return(false); }
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=SMB_SUCCESS) {
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))!=SMB_SUCCESS) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false); }
if(filelength(fileno(smb.shd_fp))<1) { /* Create it if it doesn't exist */
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((i=smb_create(&smb))!=SMB_SUCCESS) {
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))!=SMB_SUCCESS) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(false); }
length=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))!=SMB_SUCCESS) {
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((file=open(msgpath,O_RDONLY|O_BINARY))==-1
|| (instream=fdopen(file,"rb"))==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);
fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
fwrite(&xlat,2,1,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;
fwrite(buf,j,1,smb.sdt_fp);
x=SDT_BLOCK_LEN; }
fflush(smb.sdt_fp);
fclose(instream);
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
msg.hdr.offset=offset;
net=NET_QWK;
smb_hfield_str(&msg,RECIPIENT,to);
sprintf(str,"%u",touser);
smb_hfield_str(&msg,RECIPIENTEXT,str);
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
smb_hfield_str(&msg,RECIPIENTNETADDR,fulladdr);
smb_hfield_str(&msg,SENDER,useron.alias);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SUBJECT,title);
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) {
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
smb_freemsgdat(&smb,offset,length,1);
return(false);
}
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));
sprintf(str,"%s sent QWK NetMail to %s (%s)"
,useron.alias
,to,fulladdr);
logline("EN",str);
return(true);
}
bool sbbs_t::bulkmail(uchar *ar)
{
char str[256],title[LEN_TITLE+1];
char msgpath[MAX_PATH+1];
char* msgbuf;
char* editor=NULL;
char tmp[512];
int i,j,x;
long msgs=0;
long length;
FILE* fp;
smb_t smb;
smbmsg_t msg;
user_t user;
memset(&msg,0,sizeof(msg));
title[0]=0;
action=NODE_SMAL;
nodesync();
if(cfg.sys_misc&SM_ANON_EM && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ]))
msg.hdr.attr|=MSG_ANONYMOUS;
msg_tmp_fname(useron.xedit, msgpath, sizeof(msgpath));
if(!writemsg(msgpath,nulstr,title,WM_EMAIL,INVALID_SUB,"Bulk Mailing",&editor)) {
bputs(text[Aborted]);
return(false);
}
if((fp=fopen(msgpath,"r"))==NULL) {
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY);
return(false);
}
if((length=(long)filelength(fileno(fp)))<=0) {
fclose(fp);
return(false);
}
bputs(text[WritingIndx]);
CRLF;
if((msgbuf=(char*)malloc(length+1))==NULL) {
errormsg(WHERE,ERR_ALLOC,msgpath,length+1);
return(false);
}
length=fread(msgbuf,sizeof(char),length,fp);
fclose(fp);
if(length<0) {
free(msgbuf);
errormsg(WHERE,ERR_READ,msgpath,length);
return(false);
}
msgbuf[length]=0; /* ASCIIZ */
smb_hfield_str(&msg,SENDER,useron.alias);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
smb_hfield_str(&msg,SUBJECT,title);
msg.hdr.when_written.time=time32(NULL);
msg.hdr.when_written.zone=sys_timezone(&cfg);
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
memset(&smb,0,sizeof(smb));
smb.subnum=INVALID_SUB; /* mail database */
i=savemsg(&cfg, &smb, &msg, &client, startup->host_name, msgbuf);
free(msgbuf);
if(i!=0) {
smb_close(&smb);
smb_freemsgmem(&msg);
return(false);
}
j=lastuser(&cfg);
if(*ar)
for(i=1;i<=j;i++) {
user.number=i;
if(getuserdat(&cfg, &user)!=0)
continue;
if(user.misc&(DELETED|INACTIVE))
continue;
if(chk_ar(ar,&user,/* client: */NULL)) {
if((x=bulkmailhdr(&smb, &msg, i))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,x);
break;
}
msgs++;
}
}
else
while(online) {
bputs(text[EnterAfterLastDestUser]);
if(!getstr(str,LEN_ALIAS,cfg.uq&UQ_NOUPRLWR ? K_NONE:K_UPRLWR))
break;
if((i=finduser(str))!=0) {
if((x=bulkmailhdr(&smb, &msg, i))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,x);
break;
}
msgs++;
}
}
if((i=smb_open_da(&smb))==SMB_SUCCESS) {
if(!msgs)
smb_freemsg_dfields(&smb,&msg,SMB_ALL_REFS);
else if(msgs>1)
smb_incmsg_dfields(&smb,&msg,(ushort)msgs-1);
smb_close_da(&smb);
}
smb_close(&smb);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10));
putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
return(true);
}
static JSBool js_user_set(JSContext *cx, JSObject *obj, jsid id, JSBool strict, jsval *vp)
{
jsval idval;
char* str;
char tmp[64];
jsint val;
ulong usermisc;
jsint tiny;
private_t* p;
int32 usernumber;
jsrefcount rc;
scfg_t* scfg;
scfg=JS_GetRuntimePrivate(JS_GetRuntime(cx));
if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL)
return(JS_TRUE);
JSVALUE_TO_MSTRING(cx, *vp, str, NULL);
HANDLE_PENDING(cx);
if(str==NULL)
return(JS_FALSE);
JS_IdToValue(cx, id, &idval);
tiny = JSVAL_TO_INT(idval);
rc=JS_SUSPENDREQUEST(cx);
switch(tiny) {
case USER_PROP_NUMBER:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx, *vp, &usernumber)) {
free(str);
return JS_FALSE;
}
rc=JS_SUSPENDREQUEST(cx);
if(usernumber!=p->user->number) {
p->user->number=(ushort)usernumber;
p->cached=FALSE;
}
break;
case USER_PROP_ALIAS:
SAFECOPY(p->user->alias,str);
/* update USER.DAT */
putuserrec(scfg,p->user->number,U_ALIAS,LEN_ALIAS,str);
/* update NAME.DAT */
getuserrec(scfg,p->user->number,U_MISC,8,tmp);
usermisc=ahtoul(tmp);
if(!(usermisc&DELETED))
putusername(scfg,p->user->number,str);
break;
case USER_PROP_NAME:
SAFECOPY(p->user->name,str);
putuserrec(scfg,p->user->number,U_NAME,LEN_NAME,str);
break;
case USER_PROP_HANDLE:
SAFECOPY(p->user->handle,str);
putuserrec(scfg,p->user->number,U_HANDLE,LEN_HANDLE,str);
break;
case USER_PROP_NOTE:
SAFECOPY(p->user->note,str);
putuserrec(scfg,p->user->number,U_NOTE,LEN_NOTE,str);
break;
case USER_PROP_COMP:
SAFECOPY(p->user->comp,str);
putuserrec(scfg,p->user->number,U_COMP,LEN_COMP,str);
break;
case USER_PROP_COMMENT:
SAFECOPY(p->user->comment,str);
putuserrec(scfg,p->user->number,U_COMMENT,LEN_COMMENT,str);
break;
case USER_PROP_NETMAIL:
SAFECOPY(p->user->netmail,str);
putuserrec(scfg,p->user->number,U_NETMAIL,LEN_NETMAIL,str);
break;
case USER_PROP_ADDRESS:
SAFECOPY(p->user->address,str);
putuserrec(scfg,p->user->number,U_ADDRESS,LEN_ADDRESS,str);
break;
case USER_PROP_LOCATION:
SAFECOPY(p->user->location,str);
putuserrec(scfg,p->user->number,U_LOCATION,LEN_LOCATION,str);
break;
case USER_PROP_ZIPCODE:
SAFECOPY(p->user->zipcode,str);
putuserrec(scfg,p->user->number,U_ZIPCODE,LEN_ZIPCODE,str);
break;
case USER_PROP_PHONE:
SAFECOPY(p->user->phone,str);
putuserrec(scfg,p->user->number,U_PHONE,LEN_PHONE,str);
break;
case USER_PROP_BIRTH:
SAFECOPY(p->user->birth,str);
putuserrec(scfg,p->user->number,U_BIRTH,LEN_BIRTH,str);
break;
case USER_PROP_MODEM:
SAFECOPY(p->user->modem,str);
putuserrec(scfg,p->user->number,U_MODEM,LEN_MODEM,str);
break;
case USER_PROP_ROWS:
p->user->rows=atoi(str);
putuserrec(scfg,p->user->number,U_ROWS,0,str); /* base 10 */
break;
case USER_PROP_SEX:
p->user->sex=toupper(str[0]);
putuserrec(scfg,p->user->number,U_SEX,0,strupr(str)); /* single char */
break;
case USER_PROP_CURSUB:
SAFECOPY(p->user->cursub,str);
putuserrec(scfg,p->user->number,U_CURSUB,0,str);
break;
case USER_PROP_CURDIR:
SAFECOPY(p->user->curdir,str);
putuserrec(scfg,p->user->number,U_CURDIR,0,str);
break;
case USER_PROP_CURXTRN:
SAFECOPY(p->user->curxtrn,str);
putuserrec(scfg,p->user->number,U_CURXTRN,0,str);
break;
case USER_PROP_XEDIT:
putuserrec(scfg,p->user->number,U_XEDIT,0,str);
break;
case USER_PROP_SHELL:
putuserrec(scfg,p->user->number,U_SHELL,0,str);
break;
case USER_PROP_MISC:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_MISC,0,ultoa(p->user->misc=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_QWK:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_QWK,0,ultoa(p->user->qwk=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_CHAT:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_CHAT,0,ultoa(p->user->chat=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_TMPEXT:
SAFECOPY(p->user->tmpext,str);
putuserrec(scfg,p->user->number,U_TMPEXT,0,str);
break;
case USER_PROP_NS_TIME:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_NS_TIME,0,ultoa((ulong)(p->user->ns_time=val),tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_PROT:
p->user->prot=toupper(str[0]);
putuserrec(scfg,p->user->number,U_PROT,0,strupr(str)); /* single char */
break;
case USER_PROP_LOGONTIME:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_LOGONTIME,0,ultoa(p->user->logontime=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
/* security properties*/
case USER_PROP_PASS:
SAFECOPY(p->user->pass,str);
putuserrec(scfg,p->user->number,U_PASS,LEN_PASS,strupr(str));
break;
case USER_PROP_PWMOD:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_PWMOD,0,ultoa(p->user->pwmod=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_LEVEL:
p->user->level=atoi(str);
putuserrec(scfg,p->user->number,U_LEVEL,0,str);
break;
case USER_PROP_FLAGS1:
JS_RESUMEREQUEST(cx, rc);
if(JSVAL_IS_STRING(*vp)) {
val=str_to_bits(p->user->flags1, str);
}
else {
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
}
putuserrec(scfg,p->user->number,U_FLAGS1,0,ultoa(p->user->flags1=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_FLAGS2:
JS_RESUMEREQUEST(cx, rc);
if(JSVAL_IS_STRING(*vp)) {
val=str_to_bits(p->user->flags1, str);
}
else {
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
}
putuserrec(scfg,p->user->number,U_FLAGS2,0,ultoa(p->user->flags2=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_FLAGS3:
JS_RESUMEREQUEST(cx, rc);
if(JSVAL_IS_STRING(*vp)) {
val=str_to_bits(p->user->flags1, str);
}
else {
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
}
putuserrec(scfg,p->user->number,U_FLAGS3,0,ultoa(p->user->flags3=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_FLAGS4:
JS_RESUMEREQUEST(cx, rc);
if(JSVAL_IS_STRING(*vp)) {
val=str_to_bits(p->user->flags1, str);
}
else {
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
}
putuserrec(scfg,p->user->number,U_FLAGS4,0,ultoa(p->user->flags4=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_EXEMPT:
JS_RESUMEREQUEST(cx, rc);
if(JSVAL_IS_STRING(*vp)) {
val=str_to_bits(p->user->flags1, str);
}
else {
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
}
putuserrec(scfg,p->user->number,U_EXEMPT,0,ultoa(p->user->exempt=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_REST:
JS_RESUMEREQUEST(cx, rc);
if(JSVAL_IS_STRING(*vp)) {
val=str_to_bits(p->user->flags1, str);
}
else {
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
}
putuserrec(scfg,p->user->number,U_REST,0,ultoa(p->user->rest=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_CDT:
p->user->cdt=strtoul(str,NULL,0);
putuserrec(scfg,p->user->number,U_CDT,0,str);
break;
case USER_PROP_FREECDT:
p->user->freecdt=strtoul(str,NULL,0);
putuserrec(scfg,p->user->number,U_FREECDT,0,str);
break;
case USER_PROP_MIN:
p->user->min=strtoul(str,NULL,0);
putuserrec(scfg,p->user->number,U_MIN,0,str);
break;
case USER_PROP_TEXTRA:
p->user->textra=(ushort)strtoul(str,NULL,0);
putuserrec(scfg,p->user->number,U_TEXTRA,0,str);
break;
case USER_PROP_EXPIRE:
JS_RESUMEREQUEST(cx, rc);
if(!JS_ValueToInt32(cx,*vp,&val)) {
free(str);
return JS_FALSE;
}
putuserrec(scfg,p->user->number,U_EXPIRE,0,ultoa(p->user->expire=val,tmp,16));
rc=JS_SUSPENDREQUEST(cx);
break;
case USER_PROP_CACHED:
JS_ValueToBoolean(cx, *vp, &p->cached);
JS_RESUMEREQUEST(cx, rc);
free(str);
return(JS_TRUE); /* intentional early return */
}
free(str);
if(!(p->user->rest&FLAG('G')))
p->cached=FALSE;
JS_RESUMEREQUEST(cx, rc);
return(JS_TRUE);
}
