void sbbs_t::telluser(smbmsg_t* msg)
{
char str[256];
uint usernumber,n;
node_t node;
if(msg->from_net.type)
return;
if(msg->from_ext)
usernumber=atoi(msg->from_ext);
else {
usernumber=matchuser(&cfg,msg->from,TRUE /*sysop_alias*/);
if(!usernumber)
return;
}
for(n=1;n<=cfg.sys_nodes;n++) { /* Tell user */
getnodedat(n,&node,0);
if(node.useron==usernumber
&& (node.status==NODE_INUSE
|| node.status==NODE_QUIET)) {
sprintf(str
,text[UserReadYourMailNodeMsg]
,cfg.node_num,useron.alias);
putnmsg(&cfg,n,str);
break;
}
}
if(n>cfg.sys_nodes) {
now=time(NULL);
sprintf(str,text[UserReadYourMail]
,useron.alias,timestr(now));
putsmsg(&cfg,usernumber,str);
}
}
void sbbs_t::pause()
{
char ch;
uchar tempattrs=curatr; /* was lclatr(-1) */
int i,j;
long l=K_UPPER;
if(sys_status&SS_ABORT)
return;
lncntr=0;
if(online==ON_REMOTE)
rioctl(IOFI);
bputs(text[Pause]);
j=bstrlen(text[Pause]);
if(sys_status&SS_USERON && !(useron.misc&(WIP|NOPAUSESPIN))
&& !(cfg.node_misc&NM_NOPAUSESPIN))
l|=K_SPIN;
ch=getkey(l);
if(ch==text[YN][1] || ch=='Q')
sys_status|=SS_ABORT;
else if(ch==LF) // down arrow == display one more line
lncntr=rows-2;
if(text[Pause][0]!='@')
for(i=0;i<j;i++)
backspace();
getnodedat(cfg.node_num,&thisnode,0);
nodesync();
attr(tempattrs);
}
void sbbs_t::errormsg(int line, const char *source, const char* action, const char *object
,ulong access, const char *extinfo)
{
const char* src;
char str[2048];
/* prevent recursion */
if(errormsg_inside)
return;
errormsg_inside=true;
/* Don't log path to source code */
src=getfname(source);
safe_snprintf(str,sizeof(str),"ERROR %d (%s) "
#ifdef _WIN32
"(WinError %u) "
#endif
"in %s line %u %s \"%s\" access=%ld %s%s"
,errno,STRERROR(errno)
#ifdef _WIN32
,GetLastError()
#endif
,src, line, action, object, access
,extinfo==NULL ? "":"info="
,extinfo==NULL ? "":extinfo);
if(online==ON_LOCAL)
eprintf(LOG_ERR,"%s",str);
else {
int savatr=curatr;
lprintf(LOG_ERR,"Node %d !%s",cfg.node_num, str);
attr(cfg.color[clr_err]);
bprintf("\7\r\n!ERROR %s %s\r\n", action, object); /* tell user about error */
bputs("\r\nThe sysop has been notified.\r\n");
pause();
attr(savatr);
CRLF;
}
safe_snprintf(str,sizeof(str),"ERROR %s %s", action, object);
if(cfg.node_num>0) {
getnodedat(cfg.node_num,&thisnode,1);
if(thisnode.errors<UCHAR_MAX)
thisnode.errors++;
criterrs=thisnode.errors;
putnodedat(cfg.node_num,&thisnode);
}
now=time(NULL);
if(logfile_fp!=NULL) {
if(logcol!=1)
fprintf(logfile_fp,"\r\n");
fprintf(logfile_fp,"!! %s\r\n",str);
logcol=1;
fflush(logfile_fp);
}
errormsg_inside=false;
}
int sbbs_t::bulkmailhdr(smb_t* smb, smbmsg_t* msg, uint usernum)
{
char str[256];
int i,j;
ushort nettype=NET_UNKNOWN;
node_t node;
user_t user;
smbmsg_t newmsg;
user.number=usernum;
if(getuserdat(&cfg, &user)!=0)
return(0);
if((i=smb_copymsgmem(NULL,&newmsg,msg))!=SMB_SUCCESS)
return(i);
SAFECOPY(str,user.alias);
smb_hfield_str(&newmsg,RECIPIENT,str);
if(cfg.sys_misc&SM_FWDTONET && user.misc&NETMAIL && user.netmail[0]) {
bprintf(text[UserNetMail],user.netmail);
smb_hfield_netaddr(&newmsg,RECIPIENTNETADDR,user.netmail,&nettype);
smb_hfield_bin(&newmsg,RECIPIENTNETTYPE,nettype);
} else {
sprintf(str,"%u",usernum);
smb_hfield_str(&newmsg,RECIPIENTEXT,str);
}
j=smb_addmsghdr(smb,&newmsg,SMB_SELFPACK);
smb_freemsgmem(&newmsg);
if(j!=SMB_SUCCESS)
return(j);
lncntr=0;
bprintf(text[Emailing],user.alias,usernum);
sprintf(str,"%s bulk-mailed %s #%d"
,useron.alias,user.alias,usernum);
logline("E+",str);
useron.emails++;
logon_emails++;
useron.etoday++;
for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
getnodedat(i,&node,0);
if(node.useron==usernum && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
sprintf(str,text[EmailNodeMsg],cfg.node_num,useron.alias);
putnmsg(&cfg,i,str);
break;
}
}
if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
sprintf(str,text[UserSentYouMail],useron.alias);
putsmsg(&cfg,usernum,str);
}
return(0);
}
void __fastcall TNodeForm::InterruptNodeButtonClick(TObject *Sender)
{
int i;
int file;
node_t node;
for(i=0;i<ListBox->Items->Count;i++)
if(ListBox->Selected[i]==true) {
if(getnodedat(i+1,&node,&file))
break;
node.misc^=NODE_INTR;
if(putnodedat(i+1,&node,file))
break;
}
TimerTick(Sender);
}
void __fastcall TNodeForm::ClearErrorButtonClick(TObject *Sender)
{
int i;
int file;
node_t node;
for(i=0;i<ListBox->Items->Count;i++)
if(ListBox->Selected[i]==true) {
if(getnodedat(i+1,&node,&file))
break;
node.errors=0;
if(putnodedat(i+1,&node,file))
break;
}
TimerTick(Sender);
}
// Checks for (and displays) any inter-node messages that are waiting.
// Under Synchronet, these include inter-node pages, user log-on/off notifications, new email notifications, etc.
bool checkNodeMsg()
{
bool bReturn = false;
static time_t ttLastChecked = 0, ttCurrent;
node_t node;
extern bool bPromptOnScreen;
extern short nPromptLength;
ttCurrent = time(NULL);
// Only check for new inter-node messages every 3 seconds.
if ( ttCurrent <= (ttLastChecked + 2) )
return false;
ttLastChecked = ttCurrent;
// Use XSDK calls to get the node messages...
if(!ctrl_dir[0])
return false;
getnodedat(node_num,&node,0);
if(node.misc&NODE_MSGW || node.misc&NODE_NMSG)
{
// Remove the user's prompt if it's on the screen and there's inter-node messages
if ( bPromptOnScreen )
{
backspace(nPromptLength);
bPromptOnScreen = false;
}
bReturn = true;
}
if(node.misc&NODE_MSGW)
getsmsg(user_number); /* getsmsg clears MSGW flag */
if(node.misc&NODE_NMSG) /* getnmsg clears NMSG flag */
getnmsg();
if(node.misc&NODE_INTR)
exit(0);
return bReturn;
}
G_MODULE_EXPORT void edituseron_node(GtkWidget *wiggy, gpointer data)
{
char str[MAX_PATH+1];
int i;
node_t node;
gtk_tree_selection_selected_foreach(sel
,get_lastselected_node
,&i);
if((i=getnodedat(&cfg,i,&node,NULL))) {
sprintf(str,"Error reading node data (%d)!",i);
display_message("Read Error",str,"gtk-dialog-error");
}
else {
sprintf(str,"gtkuseredit %d",node.useron);
run_external(cfg.exec_dir,str);
}
}
G_MODULE_EXPORT void do_clear_errors(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
int fd;
char *node_str;
int n,i;
node_t node;
char str[128];
gtk_tree_model_get(model, iter, 0, &node_str, -1);
n=atoi(node_str);
if((i=getnodedat(&cfg,n,&node,&fd))) {
sprintf(str,"Error reading node %d data (%d)!",n,i);
display_message("Read Error",str,"gtk-dialog-error");
}
else {
node.errors = 0;
putnodedat(&cfg, n, &node, fd);
}
}
int togglechat(scfg_t *cfg, int node_num, node_t *node, int on)
{
static int org_act;
int nodefile;
if(getnodedat(cfg,node_num,node,&nodefile)) {
return(FALSE);
}
if(on) {
org_act=node->action;
if(org_act==NODE_PCHT)
org_act=NODE_MAIN;
node->misc|=NODE_LCHAT;
} else {
node->action=org_act;
node->misc&=~NODE_LCHAT;
}
putnodedat(cfg,node_num,node,nodefile);
return(TRUE);
}
void __fastcall TNodeForm::UserEditButtonClick(TObject *Sender)
{
int i;
char str[128];
node_t node;
for(i=0;i<ListBox->Items->Count;i++)
if(ListBox->Selected[i]==true) {
if(getnodedat(i+1,&node,NULL))
break;
if(node.useron==0)
continue;
sprintf(str,"%sUSEREDIT %s %d"
,MainForm->cfg.exec_dir
,MainForm->cfg.data_dir
,node.useron);
WinExec(str,SW_SHOWNORMAL);
}
TimerTick(Sender);
}
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);
}
void __fastcall TNodeForm::DownButtonClick(TObject *Sender)
{
int i;
int file;
node_t node;
for(i=0;i<ListBox->Items->Count;i++)
if(ListBox->Selected[i]==true) {
if(getnodedat(i+1,&node,&file))
break;
if(node.status==NODE_WFC)
node.status=NODE_OFFLINE;
else if(node.status==NODE_OFFLINE)
node.status=NODE_WFC;
else
node.misc^=NODE_DOWN;
if(putnodedat(i+1,&node,file))
break;
}
TimerTick(Sender);
}
void __fastcall TNodeForm::UserMsgButtonClick(TObject *Sender)
{
int i;
node_t node;
Application->CreateForm(__classid(TUserMsgForm), &UserMsgForm);
UserMsgForm->Memo->Text="\1n\1y\1hMessage From Sysop:\1w ";
UserMsgForm->Memo->SelStart=UserMsgForm->Memo->Text.Length();
if(UserMsgForm->ShowModal()==mrOk) {
UserMsgForm->Memo->Lines->Add("");
for(i=0;i<ListBox->Items->Count;i++)
if(ListBox->Selected[i]==true) {
if(getnodedat(i+1,&node,NULL))
break;
if(node.useron==0)
continue;
putsmsg(&MainForm->cfg,node.useron
,UserMsgForm->Memo->Text.c_str());
}
}
delete UserMsgForm;
TimerTick(Sender);
}
G_MODULE_EXPORT void quickvalidate_useron_node(GtkWidget *wiggy, gpointer data)
{
char str[MAX_PATH+1];
int i;
int set;
node_t node;
set=gtk_combo_box_get_active(GTK_COMBO_BOX(wiggy))-1;
if(set>=0) {
gtk_tree_selection_selected_foreach(sel
,get_lastselected_node
,&i);
if((i=getnodedat(&cfg,i,&node,NULL))) {
sprintf(str,"Error reading node data (%d)!",i);
display_message("Read Error",str,"gtk-dialog-error");
}
else {
quick_validate(node.useron, set);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(wiggy), 0);
}
}
void __fastcall TNodeForm::ChatButtonClick(TObject *Sender)
{
char str[512];
char name[128];
int i;
node_t node;
for(i=0;i<ListBox->Items->Count;i++)
if(ListBox->Selected[i]==true) {
if(getnodedat(i+1,&node,NULL))
break;
if(node.status==NODE_WFC || node.status>NODE_QUIET)
continue;
sprintf(str,"%sCHAT %s %s %d %s"
,MainForm->cfg.exec_dir
,MainForm->cfg.ctrl_dir
,MainForm->cfg.node_path[i]
,i+1
,username(node.useron,name)
);
WinExec(str,SW_SHOWNORMAL);
}
TimerTick(Sender);
}
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::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);
}
void sbbs_t::telnet_gate(char* destaddr, ulong mode, char* client_user_name, char* server_user_name, char* term_type)
{
char* p;
uchar buf[512];
int i;
int rd;
uint attempts;
ulong l;
bool gotline;
ushort port;
ulong ip_addr;
ulong save_console;
SOCKET remote_socket;
SOCKADDR_IN addr;
if(mode&TG_RLOGIN)
port=513;
else
port=IPPORT_TELNET;
p=strchr(destaddr,':');
if(p!=NULL) {
*p=0;
port=atoi(p+1);
}
ip_addr=resolve_ip(destaddr);
if(ip_addr==INADDR_NONE) {
lprintf(LOG_NOTICE,"!TELGATE Failed to resolve address: %s",destaddr);
bprintf("!Failed to resolve address: %s\r\n",destaddr);
return;
}
if((remote_socket = open_socket(SOCK_STREAM, client.protocol)) == INVALID_SOCKET) {
errormsg(WHERE,ERR_OPEN,"socket",0);
return;
}
memset(&addr,0,sizeof(addr));
addr.sin_addr.s_addr = htonl(startup->telnet_interface);
addr.sin_family = AF_INET;
if((i=bind(remote_socket, (struct sockaddr *) &addr, sizeof (addr)))!=0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d (%d) binding to socket %d",i, ERROR_VALUE, remote_socket);
bprintf("!ERROR %d (%d) binding to socket\r\n",i, ERROR_VALUE);
close_socket(remote_socket);
return;
}
memset(&addr,0,sizeof(addr));
addr.sin_addr.s_addr = ip_addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
if((i=connect(remote_socket, (struct sockaddr *)&addr, sizeof(addr)))!=0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d (%d) connecting to server: %s"
,i,ERROR_VALUE, destaddr);
bprintf("!ERROR %d (%d) connecting to server: %s\r\n"
,i,ERROR_VALUE, destaddr);
close_socket(remote_socket);
return;
}
l=1;
if((i = ioctlsocket(remote_socket, FIONBIO, &l))!=0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d (%d) disabling socket blocking"
,i, ERROR_VALUE);
close_socket(remote_socket);
return;
}
lprintf(LOG_INFO,"Node %d %s gate to %s port %u on socket %d"
,cfg.node_num
,mode&TG_RLOGIN ? "RLogin" : "Telnet"
,destaddr,port,remote_socket);
if(!(mode&TG_CTRLKEYS))
console|=CON_RAW_IN;
if(mode&TG_RLOGIN) {
p=(char*)buf;
*(p++)=0;
p+=sprintf(p,"%s",client_user_name==NULL ? useron.alias : client_user_name);
p++; // Add NULL
p+=sprintf(p,"%s",server_user_name==NULL ? useron.name : server_user_name);
p++; // Add NULL
if(term_type!=NULL)
p+=sprintf(p,"%s",term_type);
else
p+=sprintf(p,"%s/%u",terminal, cur_rate);
p++; // Add NULL
l=p-(char*)buf;
sendsocket(remote_socket,(char*)buf,l);
mode|=TG_NOLF; /* Send LF (to remote host) when Telnet client sends CRLF (when not in binary mode) */
}
/* This is required for gating to Unix telnetd */
if(mode&TG_NOTERMTYPE)
request_telnet_opt(TELNET_DONT,TELNET_TERM_TYPE, 3000); // Re-negotiation of terminal type
/* Text/NVT mode by default */
request_telnet_opt(TELNET_DONT,TELNET_BINARY_TX, 3000);
if(!(telnet_mode&TELNET_MODE_OFF) && (mode&TG_PASSTHRU))
telnet_mode|=TELNET_MODE_GATE; // Pass-through telnet commands
while(online) {
if(!(mode&TG_NOCHKTIME))
gettimeleft();
rd=RingBufRead(&inbuf,buf,sizeof(buf));
if(rd) {
#if 0
if(memchr(buf,TELNET_IAC,rd)) {
char dump[2048];
dump[0];
p=dump;
for(int i=0;i<rd;i++)
p+=sprintf(p,"%u ",buf[i]);
lprintf(LOG_DEBUG,"Node %d Telnet cmd from client: %s", cfg.node_num, dump);
}
#endif
if(telnet_remote_option[TELNET_BINARY_TX]!=TELNET_WILL) {
if(*buf==0x1d) { // ^]
save_console=console;
console&=~CON_RAW_IN; // Allow Ctrl-U/Ctrl-P
CRLF;
while(online) {
SYNC;
mnemonics("\1n\r\n\1h\1bTelnet Gate: \1y~D\1wisconnect, "
"\1y~E\1wcho toggle, \1y~L\1wist Users, \1y~P\1wrivate message, "
"\1y~Q\1wuit: ");
switch(getkeys("DELPQ",0)) {
case 'D':
closesocket(remote_socket);
break;
case 'E':
mode^=TG_ECHO;
bprintf(text[EchoIsNow]
,mode&TG_ECHO
? text[ON]:text[OFF]);
continue;
case 'L':
whos_online(true);
continue;
case 'P':
nodemsg();
continue;
}
break;
}
attr(LIGHTGRAY);
console=save_console;
}
else if(*buf<' ' && (mode&TG_CTRLKEYS))
handle_ctrlkey(*buf, K_NONE);
gotline=false;
if((mode&TG_LINEMODE) && buf[0]!='\r') {
ungetkey(buf[0]);
l=K_CHAT;
if(!(mode&TG_ECHO))
l|=K_NOECHO;
rd=getstr((char*)buf,sizeof(buf)-1,l);
if(!rd)
continue;
strcat((char*)buf,crlf);
rd+=2;
gotline=true;
}
if((mode&TG_CRLF) && buf[rd-1]=='\r')
buf[rd++]='\n';
else if((mode&TG_NOLF) && buf[rd-1]=='\n')
rd--;
if(!gotline && (mode&TG_ECHO) && rd) {
RingBufWrite(&outbuf,buf,rd);
}
} /* Not Telnet Binary mode */
if(rd > 0) {
for(attempts=0;attempts<60 && online; attempts++) /* added retry loop here, Jan-20-2003 */
{
if((i=sendsocket(remote_socket,(char*)buf,rd))>=0)
break;
if(ERROR_VALUE!=EWOULDBLOCK)
break;
mswait(500);
}
if(i<0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d sending on socket %d",ERROR_VALUE,remote_socket);
break;
}
}
}
rd=recv(remote_socket,(char*)buf,sizeof(buf),0);
if(rd<0) {
if(ERROR_VALUE==EWOULDBLOCK) {
if(mode&TG_NODESYNC) {
SYNC;
} else {
// Check if the node has been interrupted
getnodedat(cfg.node_num,&thisnode,0);
if(thisnode.misc&NODE_INTR)
break;
}
YIELD();
continue;
}
lprintf(LOG_NOTICE,"!TELGATE ERROR %d receiving on socket %d",ERROR_VALUE,remote_socket);
break;
}
if(!rd) {
lprintf(LOG_INFO,"Node %d Telnet gate disconnected",cfg.node_num);
break;
}
#if 0
if(memchr(buf,TELNET_IAC,rd)) {
char dump[2048];
dump[0];
p=dump;
for(int i=0;i<rd;i++)
p+=sprintf(p,"%u ",buf[i]);
lprintf(LOG_DEBUG,"Node %d Telnet cmd from server: %s", cfg.node_num, dump);
}
#endif
RingBufWrite(&outbuf,buf,rd);
}
console&=~CON_RAW_IN;
telnet_mode&=~TELNET_MODE_GATE;
/* Disable Telnet Terminal Echo */
request_telnet_opt(TELNET_WILL,TELNET_ECHO);
close_socket(remote_socket);
lprintf(LOG_INFO,"Node %d Telnet gate to %s finished",cfg.node_num,destaddr);
}
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);
}
const char* sbbs_t::atcode(char* sp, char* str, size_t maxlen)
{
char* tp;
uint i;
uint ugrp;
uint usub;
long l;
stats_t stats;
node_t node;
struct tm tm;
str[0]=0;
if(!strcmp(sp,"VER"))
return(VERSION);
if(!strcmp(sp,"REV")) {
safe_snprintf(str,maxlen,"%c",REVISION);
return(str);
}
if(!strcmp(sp,"FULL_VER")) {
safe_snprintf(str,maxlen,"%s%c%s",VERSION,REVISION,beta_version);
truncsp(str);
#if defined(_DEBUG)
strcat(str," Debug");
#endif
return(str);
}
if(!strcmp(sp,"VER_NOTICE"))
return(VERSION_NOTICE);
if(!strcmp(sp,"OS_VER"))
return(os_version(str));
#ifdef JAVASCRIPT
if(!strcmp(sp,"JS_VER"))
return((char *)JS_GetImplementationVersion());
#endif
if(!strcmp(sp,"PLATFORM"))
return(PLATFORM_DESC);
if(!strcmp(sp,"COPYRIGHT"))
return(COPYRIGHT_NOTICE);
if(!strcmp(sp,"COMPILER")) {
DESCRIBE_COMPILER(str);
return(str);
}
if(!strcmp(sp,"UPTIME")) {
extern volatile time_t uptime;
time_t up=time(NULL)-uptime;
if(up<0)
up=0;
char days[64]="";
if((up/(24*60*60))>=2) {
sprintf(days,"%lu days ",(ulong)(up/(24L*60L*60L)));
up%=(24*60*60);
}
safe_snprintf(str,maxlen,"%s%lu:%02lu"
,days
,(ulong)(up/(60L*60L))
,(ulong)((up/60L)%60L)
);
return(str);
}
if(!strcmp(sp,"SERVED")) {
extern volatile ulong served;
safe_snprintf(str,maxlen,"%lu",served);
return(str);
}
if(!strcmp(sp,"SOCKET_LIB"))
return(socklib_version(str,SOCKLIB_DESC));
if(!strcmp(sp,"MSG_LIB")) {
safe_snprintf(str,maxlen,"SMBLIB %s",smb_lib_ver());
return(str);
}
if(!strcmp(sp,"BBS") || !strcmp(sp,"BOARDNAME"))
return(cfg.sys_name);
if(!strcmp(sp,"BAUD") || !strcmp(sp,"BPS")) {
safe_snprintf(str,maxlen,"%lu",cur_rate);
return(str);
}
if(!strcmp(sp,"CONN"))
return(connection);
if(!strcmp(sp,"SYSOP"))
return(cfg.sys_op);
if(!strcmp(sp,"LOCATION"))
return(cfg.sys_location);
if(!strcmp(sp,"NODE")) {
safe_snprintf(str,maxlen,"%u",cfg.node_num);
return(str);
}
if(!strcmp(sp,"TNODE")) {
safe_snprintf(str,maxlen,"%u",cfg.sys_nodes);
return(str);
}
if(!strcmp(sp,"INETADDR"))
return(cfg.sys_inetaddr);
if(!strcmp(sp,"HOSTNAME"))
return(startup->host_name);
if(!strcmp(sp,"FIDOADDR")) {
if(cfg.total_faddrs)
return(smb_faddrtoa(&cfg.faddr[0],str));
return(nulstr);
}
if(!strcmp(sp,"EMAILADDR"))
return(usermailaddr(&cfg, str
,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name));
if(!strcmp(sp,"QWKID"))
return(cfg.sys_id);
if(!strcmp(sp,"TIME") || !strcmp(sp,"SYSTIME")) {
now=time(NULL);
memset(&tm,0,sizeof(tm));
localtime_r(&now,&tm);
if(cfg.sys_misc&SM_MILITARY)
safe_snprintf(str,maxlen,"%02d:%02d:%02d"
,tm.tm_hour,tm.tm_min,tm.tm_sec);
else
safe_snprintf(str,maxlen,"%02d:%02d %s"
,tm.tm_hour==0 ? 12
: tm.tm_hour>12 ? tm.tm_hour-12
: tm.tm_hour, tm.tm_min, tm.tm_hour>11 ? "pm":"am");
return(str);
}
if(!strcmp(sp,"TIMEZONE"))
return(smb_zonestr(sys_timezone(&cfg),str));
if(!strcmp(sp,"DATE") || !strcmp(sp,"SYSDATE")) {
return(unixtodstr(&cfg,time32(NULL),str));
}
if(!strcmp(sp,"DATETIME"))
return(timestr(time(NULL)));
if(!strcmp(sp,"TMSG")) {
l=0;
for(i=0;i<cfg.total_subs;i++)
l+=getposts(&cfg,i); /* l=total posts */
safe_snprintf(str,maxlen,"%lu",l);
return(str);
}
if(!strcmp(sp,"TUSER")) {
safe_snprintf(str,maxlen,"%u",total_users(&cfg));
return(str);
}
if(!strcmp(sp,"TFILE")) {
l=0;
for(i=0;i<cfg.total_dirs;i++)
l+=getfiles(&cfg,i);
safe_snprintf(str,maxlen,"%lu",l);
return(str);
}
if(!strcmp(sp,"TCALLS") || !strcmp(sp,"NUMCALLS")) {
getstats(&cfg,0,&stats);
safe_snprintf(str,maxlen,"%lu",stats.logons);
return(str);
}
if(!strcmp(sp,"PREVON") || !strcmp(sp,"LASTCALLERNODE")
|| !strcmp(sp,"LASTCALLERSYSTEM"))
return(lastuseron);
if(!strcmp(sp,"CLS")) {
CLS;
return(nulstr);
}
if(!strcmp(sp,"PAUSE") || !strcmp(sp,"MORE")) {
pause();
return(nulstr);
}
if(!strcmp(sp,"RESETPAUSE")) {
lncntr=0;
return(nulstr);
}
if(!strcmp(sp,"NOPAUSE") || !strcmp(sp,"POFF")) {
sys_status^=SS_PAUSEOFF;
return(nulstr);
}
if(!strcmp(sp,"PON") || !strcmp(sp,"AUTOMORE")) {
sys_status^=SS_PAUSEON;
return(nulstr);
}
/* NOSTOP */
/* STOP */
if(!strcmp(sp,"BELL") || !strcmp(sp,"BEEP"))
return("\a");
if(!strcmp(sp,"EVENT")) {
if(event_time==0)
return("<none>");
return(timestr(event_time));
}
/* LASTCALL */
if(!strncmp(sp,"NODE",4)) {
i=atoi(sp+4);
if(i && i<=cfg.sys_nodes) {
getnodedat(i,&node,0);
printnodedat(i,&node);
}
return(nulstr);
}
if(!strcmp(sp,"WHO")) {
whos_online(true);
return(nulstr);
}
/* User Codes */
if(!strcmp(sp,"USER") || !strcmp(sp,"ALIAS") || !strcmp(sp,"NAME"))
return(useron.alias);
if(!strcmp(sp,"FIRST")) {
safe_snprintf(str,maxlen,"%s",useron.alias);
tp=strchr(str,' ');
if(tp) *tp=0;
return(str);
}
if(!strcmp(sp,"USERNUM")) {
safe_snprintf(str,maxlen,"%u",useron.number);
return(str);
}
if(!strcmp(sp,"PHONE") || !strcmp(sp,"HOMEPHONE")
|| !strcmp(sp,"DATAPHONE") || !strcmp(sp,"DATA"))
return(useron.phone);
if(!strcmp(sp,"ADDR1"))
return(useron.address);
if(!strcmp(sp,"FROM"))
return(useron.location);
if(!strcmp(sp,"CITY")) {
safe_snprintf(str,maxlen,"%s",useron.location);
char* p=strchr(str,',');
if(p) {
*p=0;
return(str);
}
return(nulstr);
}
if(!strcmp(sp,"STATE")) {
char* p=strchr(useron.location,',');
if(p) {
p++;
if(*p==' ')
p++;
return(p);
}
return(nulstr);
}
if(!strcmp(sp,"CPU"))
return(useron.comp);
if(!strcmp(sp,"HOST"))
return(client_name);
if(!strcmp(sp,"BDATE"))
return(useron.birth);
if(!strcmp(sp,"AGE")) {
safe_snprintf(str,maxlen,"%u",getage(&cfg,useron.birth));
return(str);
}
if(!strcmp(sp,"CALLS") || !strcmp(sp,"NUMTIMESON")) {
safe_snprintf(str,maxlen,"%u",useron.logons);
return(str);
}
if(!strcmp(sp,"MEMO"))
return(unixtodstr(&cfg,useron.pwmod,str));
if(!strcmp(sp,"SEC") || !strcmp(sp,"SECURITY")) {
safe_snprintf(str,maxlen,"%u",useron.level);
return(str);
}
if(!strcmp(sp,"SINCE"))
return(unixtodstr(&cfg,useron.firston,str));
if(!strcmp(sp,"TIMEON") || !strcmp(sp,"TIMEUSED")) {
now=time(NULL);
safe_snprintf(str,maxlen,"%lu",(ulong)(now-logontime)/60L);
return(str);
}
if(!strcmp(sp,"TUSED")) { /* Synchronet only */
now=time(NULL);
return(sectostr((uint)(now-logontime),str)+1);
}
if(!strcmp(sp,"TLEFT")) { /* Synchronet only */
gettimeleft();
return(sectostr(timeleft,str)+1);
}
if(!strcmp(sp,"TPERD")) /* Synchronet only */
return(sectostr(cfg.level_timeperday[useron.level],str)+1);
if(!strcmp(sp,"TPERC")) /* Synchronet only */
return(sectostr(cfg.level_timepercall[useron.level],str)+1);
if(!strcmp(sp,"TIMELIMIT")) {
safe_snprintf(str,maxlen,"%u",cfg.level_timepercall[useron.level]);
return(str);
}
if(!strcmp(sp,"MINLEFT") || !strcmp(sp,"LEFT") || !strcmp(sp,"TIMELEFT")) {
gettimeleft();
safe_snprintf(str,maxlen,"%lu",timeleft/60);
return(str);
}
if(!strcmp(sp,"LASTON"))
return(timestr(useron.laston));
if(!strcmp(sp,"LASTDATEON"))
return(unixtodstr(&cfg,useron.laston,str));
if(!strcmp(sp,"LASTTIMEON")) {
memset(&tm,0,sizeof(tm));
localtime32(&useron.laston,&tm);
if(cfg.sys_misc&SM_MILITARY)
safe_snprintf(str,maxlen,"%02d:%02d:%02d"
,tm.tm_hour, tm.tm_min, tm.tm_sec);
else
safe_snprintf(str,maxlen,"%02d:%02d %s"
,tm.tm_hour==0 ? 12
: tm.tm_hour>12 ? tm.tm_hour-12
: tm.tm_hour, tm.tm_min, tm.tm_hour>11 ? "pm":"am");
return(str);
}
if(!strcmp(sp,"MSGLEFT") || !strcmp(sp,"MSGSLEFT")) {
safe_snprintf(str,maxlen,"%u",useron.posts);
return(str);
}
if(!strcmp(sp,"MSGREAD")) {
safe_snprintf(str,maxlen,"%lu",posts_read);
return(str);
}
if(!strcmp(sp,"FREESPACE")) {
safe_snprintf(str,maxlen,"%lu",getfreediskspace(cfg.temp_dir,0));
return(str);
}
if(!strcmp(sp,"FREESPACEK")) {
safe_snprintf(str,maxlen,"%lu",getfreediskspace(cfg.temp_dir,1024));
return(str);
}
if(!strcmp(sp,"UPBYTES")) {
safe_snprintf(str,maxlen,"%lu",useron.ulb);
return(str);
}
if(!strcmp(sp,"UPK")) {
safe_snprintf(str,maxlen,"%lu",useron.ulb/1024L);
return(str);
}
if(!strcmp(sp,"UPS") || !strcmp(sp,"UPFILES")) {
safe_snprintf(str,maxlen,"%u",useron.uls);
return(str);
}
if(!strcmp(sp,"DLBYTES")) {
safe_snprintf(str,maxlen,"%lu",useron.dlb);
return(str);
}
if(!strcmp(sp,"DOWNK")) {
safe_snprintf(str,maxlen,"%lu",useron.dlb/1024L);
return(str);
}
if(!strcmp(sp,"DOWNS") || !strcmp(sp,"DLFILES")) {
safe_snprintf(str,maxlen,"%u",useron.dls);
return(str);
}
if(!strcmp(sp,"LASTNEW"))
return(unixtodstr(&cfg,(time32_t)ns_time,str));
if(!strcmp(sp,"NEWFILETIME"))
return(timestr(ns_time));
/* MAXDL */
if(!strcmp(sp,"MAXDK") || !strcmp(sp,"DLKLIMIT") || !strcmp(sp,"KBLIMIT")) {
safe_snprintf(str,maxlen,"%lu",cfg.level_freecdtperday[useron.level]/1024L);
return(str);
}
if(!strcmp(sp,"DAYBYTES")) { /* amt of free cdts used today */
safe_snprintf(str,maxlen,"%lu",cfg.level_freecdtperday[useron.level]-useron.freecdt);
return(str);
}
if(!strcmp(sp,"BYTELIMIT")) {
safe_snprintf(str,maxlen,"%lu",cfg.level_freecdtperday[useron.level]);
return(str);
}
if(!strcmp(sp,"KBLEFT")) {
safe_snprintf(str,maxlen,"%lu",(useron.cdt+useron.freecdt)/1024L);
return(str);
}
if(!strcmp(sp,"BYTESLEFT")) {
safe_snprintf(str,maxlen,"%lu",useron.cdt+useron.freecdt);
return(str);
}
if(!strcmp(sp,"CONF")) {
safe_snprintf(str,maxlen,"%s %s"
,usrgrps ? cfg.grp[usrgrp[curgrp]]->sname :nulstr
,usrgrps ? cfg.sub[usrsub[curgrp][cursub[curgrp]]]->sname : nulstr);
return(str);
}
if(!strcmp(sp,"CONFNUM")) {
safe_snprintf(str,maxlen,"%u %u",curgrp+1,cursub[curgrp]+1);
return(str);
}
if(!strcmp(sp,"NUMDIR")) {
safe_snprintf(str,maxlen,"%u %u",usrlibs ? curlib+1 : 0,usrlibs ? curdir[curlib]+1 : 0);
return(str);
}
if(!strcmp(sp,"EXDATE") || !strcmp(sp,"EXPDATE"))
return(unixtodstr(&cfg,useron.expire,str));
if(!strcmp(sp,"EXPDAYS")) {
now=time(NULL);
l=(long)(useron.expire-now);
if(l<0)
l=0;
safe_snprintf(str,maxlen,"%lu",l/(1440L*60L));
return(str);
}
if(!strcmp(sp,"MEMO1"))
return(useron.note);
if(!strcmp(sp,"MEMO2") || !strcmp(sp,"COMPANY"))
return(useron.name);
if(!strcmp(sp,"ZIP"))
return(useron.zipcode);
if(!strcmp(sp,"HANGUP")) {
hangup();
return(nulstr);
}
/* Synchronet Specific */
if(!strncmp(sp,"SETSTR:",7)) {
strcpy(main_csi.str,sp+7);
return(nulstr);
}
if(!strncmp(sp,"EXEC:",5)) {
exec_bin(sp+5,&main_csi);
return(nulstr);
}
if(!strncmp(sp,"EXEC_XTRN:",10)) {
for(i=0;i<cfg.total_xtrns;i++)
if(!stricmp(cfg.xtrn[i]->code,sp+10))
break;
if(i<cfg.total_xtrns)
exec_xtrn(i);
return(nulstr);
}
if(!strncmp(sp,"MENU:",5)) {
menu(sp+5);
return(nulstr);
}
if(!strncmp(sp,"TYPE:",5)) {
printfile(cmdstr(sp+5,nulstr,nulstr,str),0);
return(nulstr);
}
if(!strncmp(sp,"INCLUDE:",8)) {
printfile(cmdstr(sp+8,nulstr,nulstr,str),P_NOCRLF|P_SAVEATR);
return(nulstr);
}
if(!strcmp(sp,"QUESTION"))
return(question);
if(!strcmp(sp,"HANDLE"))
return(useron.handle);
if(!strcmp(sp,"CID") || !strcmp(sp,"IP"))
return(cid);
if(!strcmp(sp,"LOCAL-IP"))
return(local_addr);
if(!strcmp(sp,"CRLF"))
return("\r\n");
if(!strcmp(sp,"PUSHXY")) {
ansi_save();
return(nulstr);
}
if(!strcmp(sp,"POPXY")) {
ansi_restore();
return(nulstr);
}
if(!strncmp(sp,"UP:",3)) {
cursor_up(atoi(sp+3));
return(str);
}
if(!strncmp(sp,"DOWN:",5)) {
cursor_down(atoi(sp+5));
return(str);
}
if(!strncmp(sp,"LEFT:",5)) {
cursor_left(atoi(sp+5));
return(str);
}
if(!strncmp(sp,"RIGHT:",6)) {
cursor_right(atoi(sp+6));
return(str);
}
if(!strncmp(sp,"GOTOXY:",7)) {
tp=strchr(sp,',');
if(tp!=NULL) {
tp++;
ansi_gotoxy(atoi(sp+7),atoi(tp));
}
return(nulstr);
}
if(!strcmp(sp,"GRP")) {
if(SMB_IS_OPEN(&smb)) {
if(smb.subnum==INVALID_SUB)
return("Local");
if(smb.subnum<cfg.total_subs)
return(cfg.grp[cfg.sub[smb.subnum]->grp]->sname);
}
return(usrgrps ? cfg.grp[usrgrp[curgrp]]->sname : nulstr);
}
if(!strcmp(sp,"GRPL")) {
if(SMB_IS_OPEN(&smb)) {
if(smb.subnum==INVALID_SUB)
return("Local");
if(smb.subnum<cfg.total_subs)
return(cfg.grp[cfg.sub[smb.subnum]->grp]->lname);
}
return(usrgrps ? cfg.grp[usrgrp[curgrp]]->lname : nulstr);
}
if(!strcmp(sp,"GN")) {
if(SMB_IS_OPEN(&smb))
ugrp=getusrgrp(smb.subnum);
else
ugrp=usrgrps ? curgrp+1 : 0;
safe_snprintf(str,maxlen,"%u",ugrp);
return(str);
}
if(!strcmp(sp,"GL")) {
if(SMB_IS_OPEN(&smb))
ugrp=getusrgrp(smb.subnum);
else
ugrp=usrgrps ? curgrp+1 : 0;
safe_snprintf(str,maxlen,"%-4u",ugrp);
return(str);
}
if(!strcmp(sp,"GR")) {
if(SMB_IS_OPEN(&smb))
ugrp=getusrgrp(smb.subnum);
else
ugrp=usrgrps ? curgrp+1 : 0;
safe_snprintf(str,maxlen,"%4u",ugrp);
return(str);
}
if(!strcmp(sp,"SUB")) {
if(SMB_IS_OPEN(&smb)) {
if(smb.subnum==INVALID_SUB)
return("Mail");
else if(smb.subnum<cfg.total_subs)
return(cfg.sub[smb.subnum]->sname);
}
return(usrgrps ? cfg.sub[usrsub[curgrp][cursub[curgrp]]]->sname : nulstr);
}
if(!strcmp(sp,"SUBL")) {
if(SMB_IS_OPEN(&smb)) {
if(smb.subnum==INVALID_SUB)
return("Mail");
else if(smb.subnum<cfg.total_subs)
return(cfg.sub[smb.subnum]->lname);
}
return(usrgrps ? cfg.sub[usrsub[curgrp][cursub[curgrp]]]->lname : nulstr);
}
if(!strcmp(sp,"SN")) {
if(SMB_IS_OPEN(&smb))
usub=getusrsub(smb.subnum);
else
usub=usrgrps ? cursub[curgrp]+1 : 0;
safe_snprintf(str,maxlen,"%u",usub);
return(str);
}
if(!strcmp(sp,"SL")) {
if(SMB_IS_OPEN(&smb))
usub=getusrsub(smb.subnum);
else
usub=usrgrps ? cursub[curgrp]+1 : 0;
safe_snprintf(str,maxlen,"%-4u",usub);
return(str);
}
if(!strcmp(sp,"SR")) {
if(SMB_IS_OPEN(&smb))
usub=getusrsub(smb.subnum);
else
usub=usrgrps ? cursub[curgrp]+1 : 0;
safe_snprintf(str,maxlen,"%4u",usub);
return(str);
}
if(!strcmp(sp,"LIB"))
return(usrlibs ? cfg.lib[usrlib[curlib]]->sname : nulstr);
if(!strcmp(sp,"LIBL"))
return(usrlibs ? cfg.lib[usrlib[curlib]]->lname : nulstr);
if(!strcmp(sp,"LN")) {
safe_snprintf(str,maxlen,"%u",usrlibs ? curlib+1 : 0);
return(str);
}
if(!strcmp(sp,"LL")) {
safe_snprintf(str,maxlen,"%-4u",usrlibs ? curlib+1 : 0);
return(str);
}
if(!strcmp(sp,"LR")) {
safe_snprintf(str,maxlen,"%4u",usrlibs ? curlib+1 : 0);
return(str);
}
if(!strcmp(sp,"DIR"))
return(usrlibs ? cfg.dir[usrdir[curlib][curdir[curlib]]]->sname :nulstr);
if(!strcmp(sp,"DIRL"))
return(usrlibs ? cfg.dir[usrdir[curlib][curdir[curlib]]]->lname : nulstr);
if(!strcmp(sp,"DN")) {
safe_snprintf(str,maxlen,"%u",usrlibs ? curdir[curlib]+1 : 0);
return(str);
}
if(!strcmp(sp,"DL")) {
safe_snprintf(str,maxlen,"%-4u",usrlibs ? curdir[curlib]+1 : 0);
return(str);
}
if(!strcmp(sp,"DR")) {
safe_snprintf(str,maxlen,"%4u",usrlibs ? curdir[curlib]+1 : 0);
return(str);
}
if(!strcmp(sp,"NOACCESS")) {
if(noaccess_str==text[NoAccessTime])
safe_snprintf(str,maxlen,noaccess_str,noaccess_val/60,noaccess_val%60);
else if(noaccess_str==text[NoAccessDay])
safe_snprintf(str,maxlen,noaccess_str,wday[noaccess_val]);
else
safe_snprintf(str,maxlen,noaccess_str,noaccess_val);
return(str);
}
if(!strcmp(sp,"LAST")) {
tp=strrchr(useron.alias,' ');
if(tp) tp++;
else tp=useron.alias;
return(tp);
}
if(!strcmp(sp,"REAL") || !strcmp(sp,"FIRSTREAL")) {
safe_snprintf(str,maxlen,"%s",useron.name);
tp=strchr(str,' ');
if(tp) *tp=0;
return(str);
}
if(!strcmp(sp,"LASTREAL")) {
tp=strrchr(useron.name,' ');
if(tp) tp++;
else tp=useron.name;
return(tp);
}
if(!strcmp(sp,"MAILW")) {
safe_snprintf(str,maxlen,"%u",getmail(&cfg,useron.number,0));
return(str);
}
if(!strcmp(sp,"MAILP")) {
safe_snprintf(str,maxlen,"%u",getmail(&cfg,useron.number,1));
return(str);
}
if(!strncmp(sp,"MAILW:",6)) {
safe_snprintf(str,maxlen,"%u",getmail(&cfg,atoi(sp+6),0));
return(str);
}
if(!strncmp(sp,"MAILP:",6)) {
safe_snprintf(str,maxlen,"%u",getmail(&cfg,atoi(sp+6),1));
return(str);
}
if(!strcmp(sp,"MSGREPLY")) {
safe_snprintf(str,maxlen,"%c",cfg.sys_misc&SM_RA_EMU ? 'R' : 'A');
return(str);
}
if(!strcmp(sp,"MSGREREAD")) {
safe_snprintf(str,maxlen,"%c",cfg.sys_misc&SM_RA_EMU ? 'A' : 'R');
return(str);
}
if(!strncmp(sp,"STATS.",6)) {
getstats(&cfg,0,&stats);
sp+=6;
if(!strcmp(sp,"LOGONS"))
safe_snprintf(str,maxlen,"%lu",stats.logons);
else if(!strcmp(sp,"LTODAY"))
safe_snprintf(str,maxlen,"%lu",stats.ltoday);
else if(!strcmp(sp,"TIMEON"))
safe_snprintf(str,maxlen,"%lu",stats.timeon);
else if(!strcmp(sp,"TTODAY"))
safe_snprintf(str,maxlen,"%lu",stats.ttoday);
else if(!strcmp(sp,"ULS"))
safe_snprintf(str,maxlen,"%lu",stats.uls);
else if(!strcmp(sp,"ULB"))
safe_snprintf(str,maxlen,"%lu",stats.ulb);
else if(!strcmp(sp,"DLS"))
safe_snprintf(str,maxlen,"%lu",stats.dls);
else if(!strcmp(sp,"DLB"))
safe_snprintf(str,maxlen,"%lu",stats.dlb);
else if(!strcmp(sp,"PTODAY"))
safe_snprintf(str,maxlen,"%lu",stats.ptoday);
else if(!strcmp(sp,"ETODAY"))
safe_snprintf(str,maxlen,"%lu",stats.etoday);
else if(!strcmp(sp,"FTODAY"))
safe_snprintf(str,maxlen,"%lu",stats.ftoday);
else if(!strcmp(sp,"NUSERS"))
safe_snprintf(str,maxlen,"%u",stats.nusers);
return(str);
}
/* Message header codes */
if(!strcmp(sp,"MSG_TO") && current_msg!=NULL) {
if(current_msg->to==NULL)
return(nulstr);
if(current_msg->to_ext!=NULL)
safe_snprintf(str,maxlen,"%s #%s",current_msg->to,current_msg->to_ext);
else if(current_msg->to_net.type!=NET_NONE) {
char tmp[128];
safe_snprintf(str,maxlen,"%s (%s)",current_msg->to
,smb_netaddrstr(¤t_msg->to_net,tmp));
} else
return(current_msg->to);
return(str);
}
if(!strcmp(sp,"MSG_TO_NAME") && current_msg!=NULL)
return(current_msg->to==NULL ? nulstr : current_msg->to);
if(!strcmp(sp,"MSG_TO_EXT") && current_msg!=NULL) {
if(current_msg->to_ext==NULL)
return(nulstr);
return(current_msg->to_ext);
}
if(!strcmp(sp,"MSG_TO_NET") && current_msg!=NULL)
return(smb_netaddrstr(¤t_msg->to_net,str));
if(!strcmp(sp,"MSG_FROM") && current_msg!=NULL) {
if(current_msg->from==NULL)
return(nulstr);
if(current_msg->hdr.attr&MSG_ANONYMOUS && !SYSOP)
return(text[Anonymous]);
if(current_msg->from_ext!=NULL)
safe_snprintf(str,maxlen,"%s #%s",current_msg->from,current_msg->from_ext);
else if(current_msg->from_net.type!=NET_NONE) {
char tmp[128];
safe_snprintf(str,maxlen,"%s (%s)",current_msg->from
,smb_netaddrstr(¤t_msg->from_net,tmp));
} else
return(current_msg->from);
return(str);
}
if(!strcmp(sp,"MSG_FROM_NAME") && current_msg!=NULL) {
if(current_msg->from==NULL)
return(nulstr);
if(current_msg->hdr.attr&MSG_ANONYMOUS && !SYSOP)
return(text[Anonymous]);
return(current_msg->from);
}
if(!strcmp(sp,"MSG_FROM_EXT") && current_msg!=NULL) {
if(!(current_msg->hdr.attr&MSG_ANONYMOUS) || SYSOP)
if(current_msg->from_ext!=NULL)
return(current_msg->from_ext);
return(nulstr);
}
if(!strcmp(sp,"MSG_FROM_NET") && current_msg!=NULL) {
if(current_msg->from_net.type!=NET_NONE
&& (!(current_msg->hdr.attr&MSG_ANONYMOUS) || SYSOP))
return(smb_netaddrstr(¤t_msg->from_net,str));
return(nulstr);
}
if(!strcmp(sp,"MSG_SUBJECT") && current_msg!=NULL)
return(current_msg->subj==NULL ? nulstr : current_msg->subj);
if(!strcmp(sp,"MSG_DATE") && current_msg!=NULL)
return(timestr(current_msg->hdr.when_written.time));
if(!strcmp(sp,"MSG_TIMEZONE") && current_msg!=NULL)
return(smb_zonestr(current_msg->hdr.when_written.zone,NULL));
if(!strcmp(sp,"MSG_ATTR") && current_msg!=NULL) {
safe_snprintf(str,maxlen,"%s%s%s%s%s%s%s%s%s%s%s"
,current_msg->hdr.attr&MSG_PRIVATE ? "Private " :nulstr
,current_msg->hdr.attr&MSG_READ ? "Read " :nulstr
,current_msg->hdr.attr&MSG_DELETE ? "Deleted " :nulstr
,current_msg->hdr.attr&MSG_KILLREAD ? "Kill " :nulstr
,current_msg->hdr.attr&MSG_ANONYMOUS ? "Anonymous " :nulstr
,current_msg->hdr.attr&MSG_LOCKED ? "Locked " :nulstr
,current_msg->hdr.attr&MSG_PERMANENT ? "Permanent " :nulstr
,current_msg->hdr.attr&MSG_MODERATED ? "Moderated " :nulstr
,current_msg->hdr.attr&MSG_VALIDATED ? "Validated " :nulstr
,current_msg->hdr.attr&MSG_REPLIED ? "Replied " :nulstr
,current_msg->hdr.attr&MSG_NOREPLY ? "NoReply " :nulstr
);
return(str);
}
if(!strcmp(sp,"MSG_ID") && current_msg!=NULL)
return(current_msg->id==NULL ? nulstr : current_msg->id);
if(!strcmp(sp,"MSG_REPLY_ID") && current_msg!=NULL)
return(current_msg->reply_id==NULL ? nulstr : current_msg->reply_id);
if(!strcmp(sp,"MSG_NUM") && current_msg!=NULL) {
safe_snprintf(str,maxlen,"%lu",current_msg->hdr.number);
return(str);
}
if(!strcmp(sp,"SMB_AREA")) {
if(smb.subnum!=INVALID_SUB && smb.subnum<cfg.total_subs)
safe_snprintf(str,maxlen,"%s %s"
,cfg.grp[cfg.sub[smb.subnum]->grp]->sname
,cfg.sub[smb.subnum]->sname);
return(str);
}
if(!strcmp(sp,"SMB_AREA_DESC")) {
if(smb.subnum!=INVALID_SUB && smb.subnum<cfg.total_subs)
safe_snprintf(str,maxlen,"%s %s"
,cfg.grp[cfg.sub[smb.subnum]->grp]->lname
,cfg.sub[smb.subnum]->lname);
return(str);
}
if(!strcmp(sp,"SMB_GROUP")) {
if(smb.subnum!=INVALID_SUB && smb.subnum<cfg.total_subs)
return(cfg.grp[cfg.sub[smb.subnum]->grp]->sname);
return(nulstr);
}
if(!strcmp(sp,"SMB_GROUP_DESC")) {
if(smb.subnum!=INVALID_SUB && smb.subnum<cfg.total_subs)
return(cfg.grp[cfg.sub[smb.subnum]->grp]->lname);
return(nulstr);
}
if(!strcmp(sp,"SMB_GROUP_NUM")) {
if(smb.subnum!=INVALID_SUB && smb.subnum<cfg.total_subs)
safe_snprintf(str,maxlen,"%u",getusrgrp(smb.subnum));
return(str);
}
if(!strcmp(sp,"SMB_SUB")) {
if(smb.subnum==INVALID_SUB)
return("Mail");
else if(smb.subnum<cfg.total_subs)
return(cfg.sub[smb.subnum]->sname);
return(nulstr);
}
if(!strcmp(sp,"SMB_SUB_DESC")) {
if(smb.subnum==INVALID_SUB)
return("Mail");
else if(smb.subnum<cfg.total_subs)
return(cfg.sub[smb.subnum]->lname);
return(nulstr);
}
if(!strcmp(sp,"SMB_SUB_CODE")) {
if(smb.subnum==INVALID_SUB)
return("MAIL");
else if(smb.subnum<cfg.total_subs)
return(cfg.sub[smb.subnum]->code);
return(nulstr);
}
if(!strcmp(sp,"SMB_SUB_NUM")) {
if(smb.subnum!=INVALID_SUB && smb.subnum<cfg.total_subs)
safe_snprintf(str,maxlen,"%u",getusrsub(smb.subnum));
return(str);
}
if(!strcmp(sp,"SMB_MSGS")) {
safe_snprintf(str,maxlen,"%ld",smb.msgs);
return(str);
}
if(!strcmp(sp,"SMB_CURMSG")) {
safe_snprintf(str,maxlen,"%ld",smb.curmsg+1);
return(str);
}
if(!strcmp(sp,"SMB_LAST_MSG")) {
safe_snprintf(str,maxlen,"%lu",smb.status.last_msg);
return(str);
}
if(!strcmp(sp,"SMB_MAX_MSGS")) {
safe_snprintf(str,maxlen,"%lu",smb.status.max_msgs);
return(str);
}
if(!strcmp(sp,"SMB_MAX_CRCS")) {
safe_snprintf(str,maxlen,"%lu",smb.status.max_crcs);
return(str);
}
if(!strcmp(sp,"SMB_MAX_AGE")) {
safe_snprintf(str,maxlen,"%hu",smb.status.max_age);
return(str);
}
if(!strcmp(sp,"SMB_TOTAL_MSGS")) {
safe_snprintf(str,maxlen,"%lu",smb.status.total_msgs);
return(str);
}
return(NULL);
}
ulong sbbs_t::logonstats()
{
char str[MAX_PATH+1];
int dsts,csts;
uint i;
time32_t update32_t=0;
time_t update_t=0;
time32_t now32;
stats_t stats;
node_t node;
struct tm tm, update_tm;
sys_status&=~SS_DAILY;
memset(&stats,0,sizeof(stats));
sprintf(str,"%sdsts.dab",cfg.ctrl_dir);
if((dsts=nopen(str,O_RDWR))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_RDWR);
return(0L);
}
read(dsts,&update32_t,4); /* Last updated */
update_t=update32_t;
read(dsts,&stats.logons,4); /* Total number of logons on system */
close(dsts);
now=time(NULL);
now32=(time32_t)now;
if(update_t>now+(24L*60L*60L)) /* More than a day in the future? */
errormsg(WHERE,ERR_CHK,"Daily stats time stamp",(ulong)update_t);
if(localtime_r(&update_t,&update_tm)==NULL)
return(0);
if(localtime_r(&now,&tm)==NULL)
return(0);
if((tm.tm_mday>update_tm.tm_mday && tm.tm_mon==update_tm.tm_mon)
|| tm.tm_mon>update_tm.tm_mon || tm.tm_year>update_tm.tm_year) {
sprintf(str,"New Day - Prev: %s ",timestr(update_t));
logentry("!=",str);
sys_status|=SS_DAILY; /* New Day !!! */
sprintf(str,"%slogon.lst",cfg.data_dir); /* Truncate logon list */
if((dsts=nopen(str,O_TRUNC|O_CREAT|O_WRONLY))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_TRUNC|O_CREAT|O_WRONLY);
return(0L);
}
close(dsts);
for(i=0;i<=cfg.sys_nodes;i++) {
if(i) { /* updating a node */
getnodedat(i,&node,1);
node.misc|=NODE_EVENT;
putnodedat(i,&node);
}
sprintf(str,"%sdsts.dab",i ? cfg.node_path[i-1] : cfg.ctrl_dir);
if((dsts=nopen(str,O_RDWR))==-1) /* node doesn't have stats yet */
continue;
sprintf(str,"%scsts.dab",i ? cfg.node_path[i-1] : cfg.ctrl_dir);
if((csts=nopen(str,O_WRONLY|O_APPEND|O_CREAT))==-1) {
close(dsts);
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_APPEND|O_CREAT);
continue;
}
lseek(dsts,8L,SEEK_SET); /* Skip time and logons */
write(csts,&now32,4);
read(dsts,&stats.ltoday,4);
write(csts,&stats.ltoday,4);
lseek(dsts,4L,SEEK_CUR); /* Skip total time on */
read(dsts,&stats.ttoday,4);
write(csts,&stats.ttoday,4);
read(dsts,&stats.uls,4);
write(csts,&stats.uls,4);
read(dsts,&stats.ulb,4);
write(csts,&stats.ulb,4);
read(dsts,&stats.dls,4);
write(csts,&stats.dls,4);
read(dsts,&stats.dlb,4);
write(csts,&stats.dlb,4);
read(dsts,&stats.ptoday,4);
write(csts,&stats.ptoday,4);
read(dsts,&stats.etoday,4);
write(csts,&stats.etoday,4);
read(dsts,&stats.ftoday,4);
write(csts,&stats.ftoday,4);
close(csts);
lseek(dsts,0L,SEEK_SET); /* Go back to beginning */
write(dsts,&now32,4); /* Update time stamp */
lseek(dsts,4L,SEEK_CUR); /* Skip total logons */
stats.ltoday=0;
write(dsts,&stats.ltoday,4); /* Logons today to 0 */
lseek(dsts,4L,SEEK_CUR); /* Skip total time on */
stats.ttoday=0; /* Set all other today variables to 0 */
write(dsts,&stats.ttoday,4); /* Time on today to 0 */
write(dsts,&stats.ttoday,4); /* Uploads today to 0 */
write(dsts,&stats.ttoday,4); /* U/L Bytes today */
write(dsts,&stats.ttoday,4); /* Download today */
write(dsts,&stats.ttoday,4); /* Download bytes */
write(dsts,&stats.ttoday,4); /* Posts today */
write(dsts,&stats.ttoday,4); /* Emails today */
write(dsts,&stats.ttoday,4); /* Feedback today */
write(dsts,&stats.ttoday,2); /* New users Today */
close(dsts);
}
}
if(cfg.node_num==0) /* called from event_thread() */
return(0);
if(thisnode.status==NODE_QUIET) /* Quiet users aren't counted */
return(0);
if(REALSYSOP && !(cfg.sys_misc&SM_SYSSTAT))
return(0);
for(i=0;i<2;i++) {
sprintf(str,"%sdsts.dab",i ? cfg.ctrl_dir : cfg.node_dir);
if((dsts=nopen(str,O_RDWR))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_RDWR);
return(0L);
}
lseek(dsts,4L,SEEK_SET); /* Skip time stamp */
read(dsts,&stats.logons,4);
read(dsts,&stats.ltoday,4);
stats.logons++;
stats.ltoday++;
lseek(dsts,4L,SEEK_SET); /* Rewind back and overwrite */
write(dsts,&stats.logons,4);
write(dsts,&stats.ltoday,4);
close(dsts);
}
return(stats.logons);
}
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::email(int usernumber, const char *top, const char *subj, long mode)
{
char str[256],str2[256],msgpath[256],title[LEN_TITLE+1],ch
,buf[SDT_BLOCK_LEN];
char tmp[512];
char pid[128];
char* editor=NULL;
ushort msgattr=0;
uint16_t xlat=XLAT_NONE;
ushort nettype;
int i,j,x,file;
long l;
long length;
ulong offset;
uint32_t crc=0xffffffffUL;
FILE* instream;
node_t node;
smbmsg_t msg;
SAFECOPY(title,subj);
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP && !(useron.exempt&FLAG('M'))) {
bputs(text[TooManyEmailsToday]);
return(false);
}
if(usernumber==1 && useron.rest&FLAG('S')
&& (cfg.node_valuser!=1 || useron.fbacks || useron.emails)) { /* ! val fback */
bprintf(text[R_Feedback],cfg.sys_op);
return(false);
}
if(usernumber!=1 && useron.rest&FLAG('E')
&& (cfg.node_valuser!=usernumber || useron.fbacks || useron.emails)) {
bputs(text[R_Email]);
return(false);
}
if(!usernumber) {
bputs(text[UnknownUser]);
return(false);
}
getuserrec(&cfg,usernumber,U_MISC,8,str);
l=ahtoul(str);
if(l&(DELETED|INACTIVE)) { /* Deleted or Inactive User */
bputs(text[UnknownUser]);
return(false);
}
if((l&NETMAIL) && (cfg.sys_misc&SM_FWDTONET)) {
getuserrec(&cfg,usernumber,U_NETMAIL,LEN_NETMAIL,str);
bprintf(text[UserNetMail],str);
if((mode & WM_FORCEFWD) || text[ForwardMailQ][0]==0 || yesno(text[ForwardMailQ])) /* Forward to netmail address */
return(netmail(str,subj,mode));
}
bprintf(text[Emailing],username(&cfg,usernumber,tmp),usernumber);
action=NODE_SMAL;
nodesync();
sprintf(str,"%sfeedback.*", cfg.exec_dir);
if(usernumber==cfg.node_valuser && useron.fbacks && fexist(str)) {
exec_bin("feedback",&main_csi);
if(main_csi.logic!=LOGIC_TRUE)
return(false);
}
if(cfg.sys_misc&SM_ANON_EM && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ]))
msgattr|=MSG_ANONYMOUS;
if(cfg.sys_misc&SM_DELREADM)
msgattr|=MSG_KILLREAD;
msg_tmp_fname(useron.xedit, msgpath, sizeof(msgpath));
username(&cfg,usernumber,str2);
if(!writemsg(msgpath,top,title,mode,INVALID_SUB,str2,&editor)) {
bputs(text[Aborted]);
return(false);
}
if(mode&WM_FILE && !SYSOP && !(cfg.sys_misc&SM_FILE_EM))
mode&=~WM_FILE;
if(mode&WM_FILE) {
sprintf(str2,"%sfile/%04u.in", cfg.data_dir,usernumber);
MKDIR(str2);
sprintf(str2,"%sfile/%04u.in/%s", cfg.data_dir,usernumber,title);
if(fexistcase(str2)) {
bputs(text[FileAlreadyThere]);
remove(msgpath);
return(false);
}
{ /* Remote */
xfer_prot_menu(XFER_UPLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str,"Q");
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && chk_ar(cfg.prot[x]->ar,&useron,&client)) {
sprintf(tmp,"%c",cfg.prot[x]->mnemonic);
strcat(str,tmp);
}
ch=(char)getkeys(str,0);
if(ch=='Q' || sys_status&SS_ABORT) {
bputs(text[Aborted]);
remove(msgpath);
return(false);
}
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && cfg.prot[x]->mnemonic==ch
&& chk_ar(cfg.prot[x]->ar,&useron,&client))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,str2,nulstr,true);
}
safe_snprintf(tmp,sizeof(tmp),"%s%s",cfg.temp_dir,title);
if(!fexistcase(str2) && fexistcase(tmp))
mv(tmp,str2,0);
l=(long)flength(str2);
if(l>0)
bprintf(text[FileNBytesReceived],title,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],title);
remove(msgpath);
return(false);
}
}
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
return(false);
}
sprintf(smb.file,"%smail", cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(smb_fgetlength(smb.shd_fp)<1) { /* Create it if it doesn't exist */
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_age=cfg.mail_maxage;
smb.status.max_msgs=0;
smb.status.attr=SMB_EMAIL;
if((i=smb_create(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i,smb.last_error);
return(false);
}
}
if((i=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(false);
}
length=(long)flength(msgpath)+2; /* +2 for translation string */
if(length&0xfff00000UL) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LEN,msgpath,length);
return(false);
}
if((i=smb_open_da(&smb))!=0) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
if((instream=fnopen(&file,msgpath,O_RDONLY|O_BINARY))==NULL) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY|O_BINARY);
return(false);
}
setvbuf(instream,NULL,_IOFBF,2*1024);
smb_fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
smb_fwrite(&smb,&xlat,2,smb.sdt_fp);
x=SDT_BLOCK_LEN-2; /* Don't read/write more than 255 */
while(!feof(instream)) {
memset(buf,0,x);
j=fread(buf,1,x,instream);
if(j<1)
break;
if(j>1 && (j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
buf[j-1]=buf[j-2]=0;
if(cfg.mail_maxcrcs) {
for(i=0;i<j;i++)
crc=ucrc32(buf[i],crc);
}
smb_fwrite(&smb,buf,j,smb.sdt_fp);
x=SDT_BLOCK_LEN;
}
smb_fflush(smb.sdt_fp);
fclose(instream);
crc=~crc;
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
msg.hdr.attr=msgattr;
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time32(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
if(cfg.mail_maxcrcs) {
i=smb_addcrc(&smb,crc);
if(i) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
attr(cfg.color[clr_err]);
bputs(text[CantPostMsg]);
return(false);
}
}
msg.hdr.offset=offset;
username(&cfg,usernumber,str);
smb_hfield_str(&msg,RECIPIENT,str);
sprintf(str,"%u",usernumber);
smb_hfield_str(&msg,RECIPIENTEXT,str);
SAFECOPY(str,useron.alias);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
if(useron.misc&NETMAIL) {
if(useron.rest&FLAG('G'))
smb_hfield_str(&msg,REPLYTO,useron.name);
nettype=smb_netaddr_type(useron.netmail);
if(nettype!=NET_NONE && nettype!=NET_UNKNOWN) {
smb_hfield(&msg,REPLYTONETTYPE,sizeof(nettype),&nettype);
smb_hfield_str(&msg,REPLYTONETADDR,useron.netmail);
}
}
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SENDERSERVER,startup->host_name);
smb_hfield_str(&msg,SUBJECT,title);
/* Generate FidoNet Program Identifier */
smb_hfield_str(&msg,FIDOPID,msg_program_id(pid));
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK); // calls smb_unlocksmbhdr()
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
smb_freemsgdat(&smb,offset,length,1);
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
return(false);
}
if(usernumber==1)
logon_fbacks++;
else
logon_emails++;
user_sent_email(&cfg, &useron, 1, usernumber==1);
bprintf(text[Emailed],username(&cfg,usernumber,tmp),usernumber);
safe_snprintf(str,sizeof(str),"%s sent e-mail to %s #%d"
,useron.alias,username(&cfg,usernumber,tmp),usernumber);
logline("E+",str);
if(mode&WM_FILE && online==ON_REMOTE)
autohangup();
if(msgattr&MSG_ANONYMOUS) /* Don't tell user if anonymous */
return(true);
for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
getnodedat(i,&node,0);
if(node.useron==usernumber && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
safe_snprintf(str,sizeof(str),text[EmailNodeMsg],cfg.node_num,useron.alias);
putnmsg(&cfg,i,str);
break;
}
}
if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
safe_snprintf(str,sizeof(str),text[UserSentYouMail],useron.alias);
putsmsg(&cfg,usernumber,str);
}
return(true);
}
G_MODULE_EXPORT void sendmessageto_node(GtkWidget *wiggy, gpointer data)
{
char fn[MAX_PATH+1];
char str[MAX_PATH+1];
int i;
int tmp;
node_t node;
time_t edited;
struct utimbuf tb;
char *msg;
gtk_tree_selection_selected_foreach(sel
,get_lastselected_node
,&i);
if((i=getnodedat(&cfg,i,&node,NULL))) {
sprintf(str,"Error reading node data (%d)!",i);
display_message("Read Error",str,"gtk-dialog-error");
}
else {
strcpy(fn,"/tmp/gtkmonitor-msg-XXXXXXXX");
tmp=mkstemp(fn);
if(tmp!=-1) {
write(tmp,"\1n\1y\1hMessage From Sysop:\1w \n\n",30);
close(tmp);
/* Set modified time back one second so we can tell if the sysop
saved the file or not */
edited=fdate(fn);
edited--;
tb.actime=edited;
tb.modtime=edited;
utime(fn, &tb);
/* If utime() failed for some reason, sleep for a second */
if(fdate(fn)!=edited)
SLEEP(1000);
if(!run_cmd_mutex_initalized) {
pthread_mutex_init(&run_cmd_mutex, NULL);
run_cmd_mutex_initalized=1;
}
exec_cmdstr(gtkm_conf.edit_text_file, NULL, fn);
/* Spin on the lock waiting for the edit command to start */
while(!pthread_mutex_trylock(&run_cmd_mutex))
pthread_mutex_unlock(&run_cmd_mutex);
/* Now, spin on the lock waiting for it to *exit* */
while(pthread_mutex_trylock(&run_cmd_mutex)) {
/* Allow events to happen as normal */
while(gtk_events_pending()) {
if(gtk_main_iteration())
gtk_main_quit();
}
SLEEP(1);
}
pthread_mutex_unlock(&run_cmd_mutex);
/* Now, read the message back in and send to the user */
if(fdate(fn)!=edited) {
i=flength(fn);
if((msg=(char *)malloc(i))==NULL)
display_message("malloc() Error", "Cannot allocate enough memory for the message", "gtk-dialog-error");
else {
tmp=open(fn, O_RDONLY);
if(tmp==-1)
display_message("open() Error", "Cannot open temp message file", "gtk-dialog-error");
else {
if(read(tmp, msg, i)!=i)
display_message("read() Error", "Problem reading message file", "gtk-dialog-error");
else {
putsmsg(&cfg, node.useron, msg);
}
}
free(msg);
}
}
}
}
}
bool sbbs_t::pack_qwk(char *packet, ulong *msgcnt, bool prepack)
{
char str[MAX_PATH+1],ch,*p;
char tmp[MAX_PATH+1],tmp2[MAX_PATH+1];
char* fname;
char* fmode;
int mode;
uint i,j,k,conf;
long l,size,msgndx,posts,ex;
long mailmsgs=0;
ulong totalcdt,totaltime,lastmsg
,files,submsgs,msgs,netfiles=0,preqwk=0;
ulong subs_scanned=0;
float f; /* Sparky is responsible */
time_t start;
node_t node;
mail_t *mail;
post_t *post;
glob_t g;
FILE *stream,*qwk,*personal,*ndx;
DIR* dir;
DIRENT* dirent;
struct tm tm;
smbmsg_t msg;
ex=EX_OUTL|EX_OUTR; /* Need sh for wildcard expansion */
if(prepack)
ex|=EX_OFFLINE;
delfiles(cfg.temp_dir,ALLFILES);
sprintf(str,"%sfile/%04u.qwk",cfg.data_dir,useron.number);
if(fexistcase(str)) {
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;
p=cmdstr(cfg.fextr[k]->cmd,str,ALLFILES,NULL);
if((i=external(p,ex))==0)
preqwk=1;
else
errormsg(WHERE,ERR_EXEC,p,i);
}
if(useron.rest&FLAG('Q') && useron.qwk&QWK_RETCTLA)
useron.qwk|=(QWK_NOINDEX|QWK_NOCTRL|QWK_VIA|QWK_TZ|QWK_MSGID);
if(useron.qwk&QWK_EXPCTLA)
mode=A_EXPAND;
else if(useron.qwk&QWK_RETCTLA)
mode=A_LEAVE;
else mode=0;
if(useron.qwk&QWK_TZ)
mode|=QM_TZ;
if(useron.qwk&QWK_VIA)
mode|=QM_VIA;
if(useron.qwk&QWK_MSGID)
mode|=QM_MSGID;
(*msgcnt)=0L;
if(/* !prepack && */ !(useron.qwk&QWK_NOCTRL)) {
/***************************/
/* Create CONTROL.DAT file */
/***************************/
sprintf(str,"%sCONTROL.DAT",cfg.temp_dir);
if((stream=fopen(str,"wb"))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
now=time(NULL);
if(localtime_r(&now,&tm)==NULL)
return(false);
fprintf(stream,"%s\r\n%s\r\n%s\r\n%s, Sysop\r\n0000,%s\r\n"
"%02u-%02u-%u,%02u:%02u:%02u\r\n"
,cfg.sys_name
,cfg.sys_location
,cfg.node_phone
,cfg.sys_op
,cfg.sys_id
,tm.tm_mon+1,tm.tm_mday,tm.tm_year+1900
,tm.tm_hour,tm.tm_min,tm.tm_sec);
k=0;
for(i=0;i<usrgrps;i++)
for(j=0;j<usrsubs[i];j++)
k++; /* k is how many subs */
fprintf(stream,"%s\r\n\r\n0\r\n0\r\n%u\r\n",useron.alias,k);
fprintf(stream,"0\r\nE-mail\r\n"); /* first conference is e-mail */
char confname[256];
for(i=0;i<usrgrps;i++)
for(j=0;j<usrsubs[i];j++) {
if(useron.qwk&QWK_EXT) /* 255 char max */
sprintf(confname,"%s %s"
,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
,cfg.sub[usrsub[i][j]]->lname);
else /* 10 char max */
strcpy(confname,cfg.sub[usrsub[i][j]]->qwkname);
fprintf(stream,"%u\r\n%s\r\n"
,cfg.sub[usrsub[i][j]]->qwkconf ? cfg.sub[usrsub[i][j]]->qwkconf
: ((i+1)*1000)+j+1,confname);
}
fprintf(stream,"HELLO\r\nBBSNEWS\r\nGOODBYE\r\n");
fclose(stream);
/***********************/
/* Create DOOR.ID File */
/***********************/
sprintf(str,"%sDOOR.ID",cfg.temp_dir);
if((stream=fopen(str,"wb"))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
p="CONTROLTYPE = ";
fprintf(stream,"DOOR = %.10s\r\nVERSION = %s%c\r\n"
"SYSTEM = %s\r\n"
"CONTROLNAME = SBBS\r\n"
"%sADD\r\n"
"%sDROP\r\n"
"%sYOURS\r\n"
"%sRESET\r\n"
"%sRESETALL\r\n"
"%sFILES\r\n"
"%sATTACH\r\n"
"%sOWN\r\n"
"%smail\r\n"
"%sDELMAIL\r\n"
"%sCTRL-A\r\n"
"%sFREQ\r\n"
"%sNDX\r\n"
"%sTZ\r\n"
"%sVIA\r\n"
"%sCONTROL\r\n"
"MIXEDCASE = YES\r\n"
,VERSION_NOTICE
,VERSION,REVISION
,VERSION_NOTICE
,p,p,p,p
,p,p,p,p
,p,p,p,p
,p,p,p,p
);
fclose(stream);
if(useron.rest&FLAG('Q')) {
/***********************/
/* Create NETFLAGS.DAT */
/***********************/
sprintf(str,"%sNETFLAGS.DAT",cfg.temp_dir);
if((stream=fopen(str,"wb"))==NULL) {
errormsg(WHERE,ERR_CREATE,str,0);
return(false);
}
ch=1; /* Net enabled */
if(usrgrps)
for(i=0;i<(usrgrps*1000)+usrsubs[usrgrps-1];i++)
fputc(ch,stream);
fclose(stream);
}
}
/****************************************************/
/* Create MESSAGES.DAT, write header and leave open */
/****************************************************/
sprintf(str,"%sMESSAGES.DAT",cfg.temp_dir);
if(fexistcase(str))
fmode="r+b";
else
fmode="w+b";
if((qwk=fopen(str,fmode))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
l=filelength(fileno(qwk));
if(l<1) {
fprintf(qwk,"%-128.128s","Produced by " VERSION_NOTICE " " COPYRIGHT_NOTICE);
msgndx=1;
} else {
msgndx=l/QWK_BLOCK_LEN;
fseek(qwk,0,SEEK_END);
}
sprintf(str,"%sNEWFILES.DAT",cfg.temp_dir);
remove(str);
if(!(useron.rest&FLAG('T')) && useron.qwk&QWK_FILES)
files=create_filelist("NEWFILES.DAT",FL_ULTIME);
else
files=0;
start=time(NULL);
if(useron.rest&FLAG('Q'))
useron.qwk|=(QWK_EMAIL|QWK_ALLMAIL|QWK_DELMAIL);
if(!(useron.qwk&QWK_NOINDEX)) {
sprintf(str,"%sPERSONAL.NDX",cfg.temp_dir);
if((personal=fopen(str,"ab"))==NULL) {
fclose(qwk);
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
}
else
personal=NULL;
if(useron.qwk&(QWK_EMAIL|QWK_ALLMAIL) /* && !prepack */) {
sprintf(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
fclose(qwk);
if(personal)
fclose(personal);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
/***********************/
/* Pack E-mail, if any */
/***********************/
qwkmail_last=0;
mail=loadmail(&smb,&mailmsgs,useron.number,0,useron.qwk&QWK_ALLMAIL ? 0
: LM_UNREAD);
if(mailmsgs && !(sys_status&SS_ABORT)) {
bputs(text[QWKPackingEmail]);
if(!(useron.qwk&QWK_NOINDEX)) {
sprintf(str,"%s000.NDX",cfg.temp_dir);
if((ndx=fopen(str,"ab"))==NULL) {
fclose(qwk);
if(personal)
fclose(personal);
smb_close(&smb);
errormsg(WHERE,ERR_OPEN,str,0);
free(mail);
return(false);
}
}
else
ndx=NULL;
if(useron.rest&FLAG('Q'))
mode|=QM_TO_QNET;
else
mode&=~QM_TO_QNET;
for(l=0;l<mailmsgs;l++) {
bprintf("\b\b\b\b\b\b\b\b\b\b\b\b%4lu of %-4lu"
,l+1,mailmsgs);
memset(&msg,0,sizeof(msg));
msg.idx=mail[l];
if(msg.idx.number>qwkmail_last)
qwkmail_last=msg.idx.number;
if(!loadmsg(&msg,mail[l].number))
continue;
if(msg.hdr.auxattr&MSG_FILEATTACH && useron.qwk&QWK_ATTACH) {
sprintf(str,"%sfile/%04u.in/%s"
,cfg.data_dir,useron.number,msg.subj);
sprintf(tmp,"%s%s",cfg.temp_dir,msg.subj);
if(fexistcase(str) && !fexistcase(tmp))
mv(str,tmp,1);
}
size=msgtoqwk(&msg,qwk,mode,INVALID_SUB,0);
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
if(ndx) {
msgndx++;
f=ltomsbin(msgndx); /* Record number */
ch=0; /* Sub number, not used */
if(personal) {
fwrite(&f,4,1,personal);
fwrite(&ch,1,1,personal);
}
fwrite(&f,4,1,ndx);
fwrite(&ch,1,1,ndx);
msgndx+=size/QWK_BLOCK_LEN;
}
YIELD(); /* yield */
}
bprintf(text[QWKPackedEmail],mailmsgs);
if(ndx)
fclose(ndx);
}
smb_close(&smb); /* Close the e-mail */
if(mailmsgs)
free(mail);
}
/*********************/
/* Pack new messages */
/*********************/
for(i=0;i<usrgrps;i++) {
for(j=0;j<usrsubs[i] && !msgabort();j++) {
if(subscan[usrsub[i][j]].cfg&SUB_CFG_NSCAN
|| (!(useron.rest&FLAG('Q'))
&& cfg.sub[usrsub[i][j]]->misc&SUB_FORCED)) {
if(!chk_ar(cfg.sub[usrsub[i][j]]->read_ar,&useron))
continue;
lncntr=0; /* defeat pause */
if(useron.rest&FLAG('Q') && !(cfg.sub[usrsub[i][j]]->misc&SUB_QNET))
continue; /* QWK Net Node and not QWK networked, so skip */
subs_scanned++;
msgs=getlastmsg(usrsub[i][j],&lastmsg,0);
if(!msgs || lastmsg<=subscan[usrsub[i][j]].ptr) { /* no msgs */
if(subscan[usrsub[i][j]].ptr>lastmsg) { /* corrupted ptr */
outchar('*');
subscan[usrsub[i][j]].ptr=lastmsg; /* so fix automatically */
subscan[usrsub[i][j]].last=lastmsg;
}
bprintf(text[NScanStatusFmt]
,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
,cfg.sub[usrsub[i][j]]->lname,0L,msgs);
continue;
}
sprintf(smb.file,"%s%s"
,cfg.sub[usrsub[i][j]]->data_dir,cfg.sub[usrsub[i][j]]->code);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=usrsub[i][j];
if((k=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error);
continue;
}
k=0;
if(useron.qwk&QWK_BYSELF)
k|=LP_BYSELF;
if(useron.rest&FLAG('Q') || !(subscan[usrsub[i][j]].cfg&SUB_CFG_YSCAN))
k|=LP_OTHERS;
post=loadposts(&posts,usrsub[i][j],subscan[usrsub[i][j]].ptr,k);
bprintf(text[NScanStatusFmt]
,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
,cfg.sub[usrsub[i][j]]->lname,posts,msgs);
if(!posts) { /* no new messages */
smb_close(&smb);
continue;
}
bputs(text[QWKPackingSubboard]);
submsgs=0;
conf=cfg.sub[usrsub[i][j]]->qwkconf;
if(!conf)
conf=((i+1)*1000)+j+1;
if(!(useron.qwk&QWK_NOINDEX)) {
sprintf(str,"%s%u.NDX",cfg.temp_dir,conf);
if((ndx=fopen(str,"ab"))==NULL) {
fclose(qwk);
if(personal)
fclose(personal);
smb_close(&smb);
errormsg(WHERE,ERR_OPEN,str,0);
free(post);
return(false);
}
}
else
ndx=NULL;
for(l=0;l<posts && !msgabort();l++) {
bprintf("\b\b\b\b\b%-5lu",l+1);
subscan[usrsub[i][j]].ptr=post[l].number; /* set ptr */
subscan[usrsub[i][j]].last=post[l].number; /* set last read */
memset(&msg,0,sizeof(msg));
msg.idx=post[l];
if(!loadmsg(&msg,post[l].number))
continue;
if(useron.rest&FLAG('Q')) {
if(msg.from_net.type && msg.from_net.type!=NET_QWK &&
!(cfg.sub[usrsub[i][j]]->misc&SUB_GATE)) { /* From other */
smb_freemsgmem(&msg); /* net, don't gate */
smb_unlockmsghdr(&smb,&msg);
continue;
}
mode|=(QM_TO_QNET|QM_TAGLINE);
if(msg.from_net.type==NET_QWK) {
mode&=~QM_TAGLINE;
if(route_circ((char *)msg.from_net.addr,useron.alias)
|| !strnicmp(msg.subj,"NE:",3)) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
continue;
}
}
}
else
mode&=~(QM_TAGLINE|QM_TO_QNET);
size=msgtoqwk(&msg,qwk,mode,usrsub[i][j],conf);
smb_unlockmsghdr(&smb,&msg);
if(ndx) {
msgndx++;
f=ltomsbin(msgndx); /* Record number */
ch=0; /* Sub number, not used */
if(personal
&& (!stricmp(msg.to,useron.alias)
|| !stricmp(msg.to,useron.name))) {
fwrite(&f,4,1,personal);
fwrite(&ch,1,1,personal);
}
fwrite(&f,4,1,ndx);
fwrite(&ch,1,1,ndx);
msgndx+=size/QWK_BLOCK_LEN;
}
smb_freemsgmem(&msg);
(*msgcnt)++;
submsgs++;
if(cfg.max_qwkmsgs
&& !(useron.exempt&FLAG('O')) && (*msgcnt)>=cfg.max_qwkmsgs) {
bputs(text[QWKmsgLimitReached]);
break;
}
if(!(l%50))
YIELD(); /* yield */
}
if(!(sys_status&SS_ABORT))
bprintf(text[QWKPackedSubboard],submsgs,(*msgcnt));
if(ndx) {
fclose(ndx);
sprintf(str,"%s%u.NDX",cfg.temp_dir,conf);
if(!flength(str))
remove(str);
}
smb_close(&smb);
free(post);
if(l<posts)
break;
YIELD(); /* yield */
}
}
if(j<usrsubs[i]) /* if sub aborted, abort all */
break;
}
if(online==ON_LOCAL) /* event */
eprintf(LOG_INFO,"%s scanned %lu sub-boards for new messages"
,useron.alias,subs_scanned);
else
lprintf(LOG_INFO,"Node %d %s scanned %lu sub-boards for new messages"
,cfg.node_num,useron.alias,subs_scanned);
if((*msgcnt)+mailmsgs && time(NULL)-start) {
bprintf("\r\n\r\n\1n\1hPacked %lu messages (%lu bytes) in %lu seconds "
"(%lu messages/second)."
,(*msgcnt)+mailmsgs
,ftell(qwk)
,time(NULL)-start
,((*msgcnt)+mailmsgs)/(time(NULL)-start));
sprintf(str,"Packed %lu messages (%lu bytes) in %lu seconds (%lu msgs/sec)"
,(*msgcnt)+mailmsgs
,ftell(qwk)
,(ulong)(time(NULL)-start)
,((*msgcnt)+mailmsgs)/(time(NULL)-start));
if(online==ON_LOCAL) /* event */
eprintf(LOG_INFO,"%s",str);
else
lprintf(LOG_INFO,"%s",str);
}
fclose(qwk); /* close MESSAGE.DAT */
if(personal) {
fclose(personal); /* close PERSONAL.NDX */
sprintf(str,"%sPERSONAL.NDX",cfg.temp_dir);
if(!flength(str))
remove(str);
}
CRLF;
if(!prepack && (sys_status&SS_ABORT || !online))
return(false);
if(/*!prepack && */ useron.rest&FLAG('Q')) { /* If QWK Net node, check for files */
sprintf(str,"%sqnet/%s.out/",cfg.data_dir,useron.alias);
dir=opendir(str);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) { /* Move files into temp dir */
sprintf(str,"%sqnet/%s.out/%s",cfg.data_dir,useron.alias,dirent->d_name);
if(isdir(str))
continue;
sprintf(tmp2,"%s%s",cfg.temp_dir,dirent->d_name);
lncntr=0; /* Default pause */
if(online==ON_LOCAL)
eprintf(LOG_INFO,"Including %s in packet",str);
else
lprintf(LOG_INFO,"Including %s in packet",str);
bprintf(text[RetrievingFile],str);
if(!mv(str,tmp2,1))
netfiles++;
}
if(dir!=NULL)
closedir(dir);
if(netfiles)
CRLF;
}
if(batdn_total) {
for(i=0,totalcdt=0;i<batdn_total;i++)
if(!is_download_free(&cfg,batdn_dir[i],&useron))
totalcdt+=batdn_cdt[i];
if(totalcdt>useron.cdt+useron.freecdt) {
bprintf(text[YouOnlyHaveNCredits]
,ultoac(useron.cdt+useron.freecdt,tmp));
}
else {
for(i=0,totaltime=0;i<batdn_total;i++) {
if(!(cfg.dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
totaltime+=batdn_size[i]/(ulong)cur_cps;
}
if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft)
bputs(text[NotEnoughTimeToDl]);
else {
for(i=0;i<batdn_total;i++) {
lncntr=0;
unpadfname(batdn_name[i],tmp);
sprintf(tmp2,"%s%s",cfg.temp_dir,tmp);
if(!fexistcase(tmp2)) {
seqwait(cfg.dir[batdn_dir[i]]->seqdev);
bprintf(text[RetrievingFile],tmp);
sprintf(str,"%s%s"
,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
? cfg.altpath[batdn_alt[i]-1]
: cfg.dir[batdn_dir[i]]->path
,tmp);
mv(str,tmp2,1); /* copy the file to temp dir */
getnodedat(cfg.node_num,&thisnode,1);
thisnode.aux=0xfe;
putnodedat(cfg.node_num,&thisnode);
CRLF;
}
}
}
}
}
if(!(*msgcnt) && !mailmsgs && !files && !netfiles && !batdn_total
&& (prepack || !preqwk)) {
bputs(text[QWKNoNewMessages]);
return(false);
}
if(!(useron.rest&FLAG('Q'))) { /* Don't include in network */
/***********************/ /* packets */
/* Copy QWK Text files */
/***********************/
sprintf(str,"%sQWK/HELLO",cfg.text_dir);
if(fexistcase(str)) {
sprintf(tmp2,"%sHELLO",cfg.temp_dir);
mv(str,tmp2,1);
}
sprintf(str,"%sQWK/BBSNEWS",cfg.text_dir);
if(fexistcase(str)) {
sprintf(tmp2,"%sBBSNEWS",cfg.temp_dir);
mv(str,tmp2,1);
}
sprintf(str,"%sQWK/GOODBYE",cfg.text_dir);
if(fexistcase(str)) {
sprintf(tmp2,"%sGOODBYE",cfg.temp_dir);
mv(str,tmp2,1);
}
sprintf(str,"%sQWK/BLT-*",cfg.text_dir);
glob(str,0,NULL,&g);
for(i=0;i<(uint)g.gl_pathc;i++) { /* Copy BLT-*.* files */
fname=getfname(g.gl_pathv[i]);
padfname(fname,str);
if(isdigit(str[4]) && isdigit(str[9])) {
sprintf(str,"%sQWK/%s",cfg.text_dir,fname);
sprintf(tmp2,"%s%s",cfg.temp_dir,fname);
mv(str,tmp2,1);
}
}
globfree(&g);
}
if(prepack) {
for(i=1;i<=cfg.sys_nodes;i++) {
getnodedat(i,&node,0);
if((node.status==NODE_INUSE || node.status==NODE_QUIET
|| node.status==NODE_LOGON) && node.useron==useron.number)
break;
}
if(i<=cfg.sys_nodes) /* Don't pre-pack with user online */
return(false);
}
/*******************/
/* Compress Packet */
/*******************/
sprintf(tmp2,"%s%s",cfg.temp_dir,ALLFILES);
i=external(cmdstr(temp_cmd(),packet,tmp2,NULL)
,ex|EX_WILDCARD);
if(!fexist(packet)) {
bputs(text[QWKCompressionFailed]);
if(i)
errormsg(WHERE,ERR_EXEC,cmdstr(temp_cmd(),packet,tmp2,NULL),i);
else
errorlog("Couldn't compress QWK packet");
return(false);
}
if(prepack) /* Early return if pre-packing */
return(true);
l=flength(packet);
sprintf(str,"%s.qwk",cfg.sys_id);
bprintf(text[FiFilename],str);
bprintf(text[FiFileSize],ultoac(l,tmp));
if(l>0L && cur_cps)
i=l/(ulong)cur_cps;
else
i=0;
bprintf(text[FiTransferTime],sectostr(i,tmp));
CRLF;
if(!(useron.exempt&FLAG('T')) && i>timeleft) {
bputs(text[NotEnoughTimeToDl]);
return(false);
}
if(useron.rest&FLAG('Q')) {
sprintf(str,"%s.qwk",cfg.sys_id);
dir=opendir(cfg.temp_dir);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
if(!stricmp(str,dirent->d_name)) /* QWK packet */
continue;
sprintf(tmp,"%s%s",cfg.temp_dir,dirent->d_name);
if(!isdir(tmp))
remove(tmp);
}
if(dir!=NULL)
closedir(dir);
}
return(true);
}
int chat(scfg_t *cfg, int nodenum, node_t *node, box_t *boxch, void(*timecallback)(void)) {
int in,out;
char inpath[MAX_PATH];
char outpath[MAX_PATH];
char usrname[128];
char *p;
char ch;
time_t now;
time_t last_nodechk=0;
struct text_info ti;
char *buf;
gettextinfo(&ti);
if((buf=(char *)alloca(ti.screenwidth*ti.screenheight*2))==NULL) {
return(-1);
}
if(getnodedat(cfg,nodenum,node,NULL))
return(-1);
username(cfg,node->useron,usrname);
gettext(1,1,ti.screenwidth,ti.screenheight,buf);
drawchatwin(boxch,usrname,cfg->sys_op);
sprintf(outpath,"%slchat.dab",cfg->node_path[nodenum-1]);
if((out=sopen(outpath,O_RDWR|O_CREAT|O_BINARY,O_DENYNONE
,S_IREAD|S_IWRITE))==-1)
return(-1);
sprintf(inpath,"%schat.dab",cfg->node_path[nodenum-1]);
if((in=sopen(inpath,O_RDWR|O_CREAT|O_BINARY,O_DENYNONE
,S_IREAD|S_IWRITE))==-1) {
close(out);
return(-1);
}
if((p=(char *)alloca(PCHAT_LEN))==NULL) {
close(in);
close(out);
return(-1);
}
memset(p,0,PCHAT_LEN);
write(in,p,PCHAT_LEN);
write(out,p,PCHAT_LEN);
lseek(in,0,SEEK_SET);
lseek(out,0,SEEK_SET);
togglechat(cfg,nodenum,node,TRUE);
while(in != -1) {
now=time(NULL);
if(now!=last_nodechk) {
if(timecallback != NULL)
timecallback();
if(getnodedat(cfg,nodenum,node,NULL)!=0)
break;
last_nodechk=now;
}
if(node->misc&NODE_LCHAT) {
if(kbhit()) {
ch=getch();
if(ch==ESC || ch==3) {
close(in);
in=-1;
}
if(ch==0 || ch==-1) { /* Special keys... eat 'em. */
getch();
}
}
YIELD();
continue;
}
if(node->status==NODE_WFC || node->status>NODE_QUIET || node->action!=NODE_PCHT) {
close(in);
in=-1;
}
utime(inpath,NULL);
_setcursortype(_NORMALCURSOR);
while(1) {
switch(read(in,&ch,1)) {
case -1:
close(in);
in=-1;
break;
case 0:
lseek(in,0,SEEK_SET); /* Wrapped */
continue;
case 1:
lseek(in,-1L,SEEK_CUR);
if(ch) {
chatchar(&uwin,ch);
ch=0;
write(in,&ch,1);
continue;
}
break;
}
break;
}
if(kbhit()) {
ch=getch();
switch(ch) {
case 0: /* Special Chars */
case -1:
ch=0;
getch();
break;
case ESC:
case 3:
close(in);
in=-1;
continue;
default:
if(lseek(out,0,SEEK_CUR)>=PCHAT_LEN)
lseek(out,0,SEEK_SET);
chatchar(&swin,ch);
switch(write(out,&ch,1)) {
case -1:
close(in);
in=-1;
break;
}
break;
}
utime(outpath,NULL);
}
}
if(in != -1)
close(in);
if(out != -1)
close(out);
togglechat(cfg,nodenum,node,FALSE);
puttext(1,1,ti.screenwidth,ti.screenheight,buf);
window(ti.winleft,ti.wintop,ti.winright,ti.wintop);
gotoxy(ti.curx,ti.cury);
textattr(ti.attribute);
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
}