/* callback to handle questions from libalpm transactions (yes/no) */
void cb_question(alpm_question_t *question)
{
if(config->print) {
if(question->type == ALPM_QUESTION_INSTALL_IGNOREPKG) {
question->any.answer = 1;
} else {
question->any.answer = 0;
}
return;
}
switch(question->type) {
case ALPM_QUESTION_INSTALL_IGNOREPKG:
{
alpm_question_install_ignorepkg_t *q = &question->install_ignorepkg;
if(!config->op_s_downloadonly) {
q->install = yesno(_("%s is in IgnorePkg/IgnoreGroup. Install anyway?"),
alpm_pkg_get_name(q->pkg));
} else {
q->install = 1;
}
}
break;
case ALPM_QUESTION_REPLACE_PKG:
{
alpm_question_replace_t *q = &question->replace;
q->replace = yesno(_("Replace %s with %s/%s?"),
alpm_pkg_get_name(q->oldpkg),
alpm_db_get_name(q->newdb),
alpm_pkg_get_name(q->newpkg));
}
break;
case ALPM_QUESTION_CONFLICT_PKG:
{
alpm_question_conflict_t *q = &question->conflict;
/* print conflict only if it contains new information */
if(strcmp(q->conflict->package1, q->conflict->reason->name) == 0
|| strcmp(q->conflict->package2, q->conflict->reason->name) == 0) {
q->remove = noyes(_("%s and %s are in conflict. Remove %s?"),
q->conflict->package1,
q->conflict->package2,
q->conflict->package2);
} else {
q->remove = noyes(_("%s and %s are in conflict (%s). Remove %s?"),
q->conflict->package1,
q->conflict->package2,
q->conflict->reason->name,
q->conflict->package2);
}
}
break;
case ALPM_QUESTION_REMOVE_PKGS:
{
alpm_question_remove_pkgs_t *q = &question->remove_pkgs;
alpm_list_t *namelist = NULL, *i;
size_t count = 0;
for(i = q->packages; i; i = i->next) {
namelist = alpm_list_add(namelist,
(char *)alpm_pkg_get_name(i->data));
count++;
}
colon_printf(_n(
"The following package cannot be upgraded due to unresolvable dependencies:\n",
"The following packages cannot be upgraded due to unresolvable dependencies:\n",
count));
list_display(" ", namelist, getcols());
printf("\n");
q->skip = noyes(_n(
"Do you want to skip the above package for this upgrade?",
"Do you want to skip the above packages for this upgrade?",
count));
alpm_list_free(namelist);
}
break;
case ALPM_QUESTION_SELECT_PROVIDER:
{
alpm_question_select_provider_t *q = &question->select_provider;
size_t count = alpm_list_count(q->providers);
char *depstring = alpm_dep_compute_string(q->depend);
colon_printf(_n("There is %zd provider available for %s\n",
"There are %zd providers available for %s:\n", count),
count, depstring);
free(depstring);
select_display(q->providers);
q->use_index = select_question(count);
}
break;
case ALPM_QUESTION_CORRUPTED_PKG:
{
alpm_question_corrupted_t *q = &question->corrupted;
q->remove = yesno(_("File %s is corrupted (%s).\n"
"Do you want to delete it?"),
q->filepath,
alpm_strerror(q->reason));
}
break;
case ALPM_QUESTION_IMPORT_KEY:
{
alpm_question_import_key_t *q = &question->import_key;
char created[12];
time_t time = (time_t)q->key->created;
strftime(created, 12, "%Y-%m-%d", localtime(&time));
if(q->key->revoked) {
q->import = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s (revoked)?"),
q->key->length, q->key->pubkey_algo, q->key->fingerprint, q->key->uid, created);
} else {
q->import = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s?"),
q->key->length, q->key->pubkey_algo, q->key->fingerprint, q->key->uid, created);
}
}
break;
}
if(config->noask) {
if(config->ask & question->type) {
/* inverse the default answer */
question->any.answer = !question->any.answer;
}
}
}
bool sbbs_t::postmsg(uint subnum, smbmsg_t *remsg, long wm_mode)
{
char str[256],title[LEN_TITLE+1],top[256];
char msg_id[256];
char touser[64];
char from[64];
char pid[128];
char* editor=NULL;
char* msgbuf=NULL;
uint16_t xlat;
ushort msgattr;
int i,storage;
long dupechk_hashes;
long length;
FILE* fp;
smbmsg_t msg;
uint reason;
if(remsg) {
sprintf(title,"%.*s",LEN_TITLE,remsg->subj);
if(remsg->hdr.attr&MSG_ANONYMOUS)
SAFECOPY(from,text[Anonymous]);
else
SAFECOPY(from,remsg->from);
// If user posted this message, reply to the original recipient again
if((remsg->from_ext!=NULL && atoi(remsg->from_ext)==useron.number)
|| stricmp(useron.alias,remsg->from)==0 || stricmp(useron.name,remsg->from)==0)
SAFECOPY(touser,remsg->to);
else
SAFECOPY(touser,from);
msgattr=(ushort)(remsg->hdr.attr&MSG_PRIVATE);
sprintf(top,text[RegardingByToOn],title,from,remsg->to
,timestr(remsg->hdr.when_written.time)
,smb_zonestr(remsg->hdr.when_written.zone,NULL));
} else {
title[0]=0;
touser[0]=0;
top[0]=0;
msgattr=0;
}
/* Security checks */
if(!can_user_post(&cfg,subnum,&useron,&client,&reason)) {
bputs(text[reason]);
return false;
}
bprintf(text[Posting],cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname);
action=NODE_PMSG;
nodesync();
if(!(msgattr&MSG_PRIVATE) && (cfg.sub[subnum]->misc&SUB_PONLY
|| (cfg.sub[subnum]->misc&SUB_PRIV && !noyes(text[PrivatePostQ]))))
msgattr|=MSG_PRIVATE;
if(sys_status&SS_ABORT)
return(false);
if(
#if 0 /* we *do* support internet posts to specific people July-11-2002 */
!(cfg.sub[subnum]->misc&SUB_INET) && // Prompt for TO: user
#endif
(cfg.sub[subnum]->misc&SUB_TOUSER || msgattr&MSG_PRIVATE || touser[0])) {
if(!touser[0] && !(msgattr&MSG_PRIVATE))
SAFECOPY(touser,"All");
bputs(text[PostTo]);
i=LEN_ALIAS;
if(cfg.sub[subnum]->misc&SUB_QNET)
i=25;
if(cfg.sub[subnum]->misc&SUB_FIDO)
i=FIDO_NAME_LEN-1;
if(cfg.sub[subnum]->misc&(SUB_PNET|SUB_INET))
i=60;
getstr(touser,i,K_UPRLWR|K_LINE|K_EDIT|K_AUTODEL);
if(stricmp(touser,"ALL")
&& !(cfg.sub[subnum]->misc&(SUB_PNET|SUB_FIDO|SUB_QNET|SUB_INET|SUB_ANON))) {
if(cfg.sub[subnum]->misc&SUB_NAME) {
if(!userdatdupe(useron.number,U_NAME,LEN_NAME,touser)) {
bputs(text[UnknownUser]);
return(false);
}
}
else {
if((i=finduser(touser))==0)
return(false);
username(&cfg,i,touser);
}
}
if(sys_status&SS_ABORT)
return(false);
}
if(!touser[0])
SAFECOPY(touser,"All"); // Default to ALL
if(!stricmp(touser,"SYSOP") && !SYSOP) // Change SYSOP to user #1
username(&cfg,1,touser);
if(msgattr&MSG_PRIVATE && !stricmp(touser,"ALL")) {
bputs(text[NoToUser]);
return(false);
}
if(msgattr&MSG_PRIVATE)
wm_mode|=WM_PRIVATE;
if(cfg.sub[subnum]->misc&SUB_AONLY
|| (cfg.sub[subnum]->misc&SUB_ANON && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ])))
msgattr|=MSG_ANONYMOUS;
if(cfg.sub[subnum]->mod_ar[0] && chk_ar(cfg.sub[subnum]->mod_ar,&useron,&client))
msgattr|=MSG_MODERATED;
if(cfg.sub[subnum]->misc&SUB_SYSPERM && sub_op(subnum))
msgattr|=MSG_PERMANENT;
if(msgattr&MSG_PRIVATE)
bputs(text[PostingPrivately]);
if(msgattr&MSG_ANONYMOUS)
bputs(text[PostingAnonymously]);
if(cfg.sub[subnum]->misc&SUB_NAME)
bputs(text[UsingRealName]);
msg_tmp_fname(useron.xedit, str, sizeof(str));
if(!writemsg(str,top,title,wm_mode,subnum,touser,&editor)
|| (length=(long)flength(str))<1) { /* Bugfix Aug-20-2003: Reject negative length */
bputs(text[Aborted]);
return(false);
}
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_OPEN,cfg.sub[subnum]->code,i,smb.last_error);
return(false);
}
smb.subnum=subnum;
if((i=msgbase_open(&cfg,&smb,&storage,&dupechk_hashes,&xlat))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
smb_stack(&smb,SMB_STACK_POP);
return(false);
}
if((i=smb_locksmbhdr(&smb))!=SMB_SUCCESS) {
smb_close(&smb);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
smb_stack(&smb,SMB_STACK_POP);
return(false);
}
if((i=smb_getstatus(&smb))!=SMB_SUCCESS) {
smb_close(&smb);
errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
smb_stack(&smb,SMB_STACK_POP);
return(false);
}
if((msgbuf=(char*)calloc(length+1,sizeof(char))) == NULL) {
smb_close(&smb);
errormsg(WHERE,ERR_ALLOC,"msgbuf",length+1);
smb_stack(&smb,SMB_STACK_POP);
return(false);
}
if((fp=fopen(str,"rb"))==NULL) {
free(msgbuf);
smb_close(&smb);
errormsg(WHERE,ERR_OPEN,str,O_RDONLY|O_BINARY);
smb_stack(&smb,SMB_STACK_POP);
return(false);
}
i=fread(msgbuf,1,length,fp);
fclose(fp);
if(i != length) {
free(msgbuf);
smb_close(&smb);
errormsg(WHERE,ERR_READ,str,length);
smb_stack(&smb,SMB_STACK_POP);
return(false);
}
truncsp(msgbuf);
/* ToDo: split body/tail */
memset(&msg,0,sizeof(msg));
msg.hdr.attr=msgattr;
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);
msg.hdr.number=smb.status.last_msg+1; /* this *should* be the new message number */
if(remsg) {
msg.hdr.thread_back=remsg->hdr.number; /* needed for threading backward */
if((msg.hdr.thread_id=remsg->hdr.thread_id) == 0)
msg.hdr.thread_id=remsg->hdr.number;
/* Add RFC-822 Reply-ID (generate if necessary) */
if(remsg->id!=NULL)
smb_hfield_str(&msg,RFC822REPLYID,remsg->id);
/* Add FidoNet Reply if original message has FidoNet MSGID */
if(remsg->ftn_msgid!=NULL)
smb_hfield_str(&msg,FIDOREPLYID,remsg->ftn_msgid);
if((i=smb_updatethread(&smb, remsg, smb.status.last_msg+1))!=SMB_SUCCESS)
errormsg(WHERE,"updating thread",smb.file,i,smb.last_error);
}
smb_hfield_str(&msg,RECIPIENT,touser);
SAFECOPY(str,cfg.sub[subnum]->misc&SUB_NAME ? useron.name : useron.alias);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SENDERSERVER,startup->host_name);
smb_hfield_str(&msg,SUBJECT,title);
/* Generate default (RFC822) message-id (always) */
get_msgid(&cfg,subnum,&msg,msg_id,sizeof(msg_id));
smb_hfield_str(&msg,RFC822MSGID,msg_id);
/* Generate FTN (FTS-9) MSGID */
if(cfg.sub[subnum]->misc&SUB_FIDO) {
ftn_msgid(cfg.sub[subnum],&msg,msg_id,sizeof(msg_id));
smb_hfield_str(&msg,FIDOMSGID,msg_id);
}
/* Generate FidoNet Program Identifier */
smb_hfield_str(&msg,FIDOPID,msg_program_id(pid));
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
i=smb_addmsg(&smb,&msg,storage,dupechk_hashes,xlat,(uchar*)msgbuf,NULL);
free(msgbuf);
if(i==SMB_DUPE_MSG) {
attr(cfg.color[clr_err]);
bprintf(text[CantPostMsg], smb.last_error);
} else if(i!=SMB_SUCCESS)
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS)
return(false);
logon_posts++;
user_posted_msg(&cfg, &useron, 1);
bprintf(text[Posted],cfg.grp[cfg.sub[subnum]->grp]->sname
,cfg.sub[subnum]->lname);
sprintf(str,"%s posted on %s %s"
,useron.alias,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname);
logline("P+",str);
signal_sub_sem(&cfg,subnum);
user_event(EVENT_POST);
return(true);
}
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);
}
}
void sbbs_t::readmail(uint usernumber, int which)
{
char str[256],str2[256],str3[256],done=0,domsg=1
,*p,*tp,*sp,ch;
char tmp[512];
int i,j;
int error;
int mismatches=0,act;
long length,l,lm_mode;
ulong last;
bool replied;
file_t fd;
mail_t *mail;
smbmsg_t msg;
if(which==MAIL_SENT && useron.rest&FLAG('K')) {
bputs(text[R_ReadSentMail]);
return;
}
msg.total_hfields=0; /* init to NULL, cause not allocated yet */
fd.dir=cfg.total_dirs+1; /* temp dir for file attachments */
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
return; }
sprintf(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return; }
if(cfg.sys_misc&SM_SYSVDELM && (SYSOP || cfg.sys_misc&SM_USRVDELM))
lm_mode=LM_INCDEL;
else
lm_mode=0;
mail=loadmail(&smb,&smb.msgs,usernumber,which,lm_mode);
if(!smb.msgs) {
if(which==MAIL_SENT)
bputs(text[NoMailSent]);
else if(which==MAIL_ALL)
bputs(text[NoMailOnSystem]);
else
bputs(text[NoMailWaiting]);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
return; }
last=smb.status.last_msg;
if(which==MAIL_SENT)
act=NODE_RSML;
else if(which==MAIL_ALL)
act=NODE_SYSP;
else
act=NODE_RMAL;
action=act;
if(smb.msgs>1 && which!=MAIL_ALL) {
if(which==MAIL_SENT)
bputs(text[MailSentLstHdr]);
else
bputs(text[MailWaitingLstHdr]);
for(smb.curmsg=0;smb.curmsg<smb.msgs && !msgabort();smb.curmsg++) {
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=mail[smb.curmsg].offset;
if(!loadmsg(&msg,mail[smb.curmsg].number))
continue;
smb_unlockmsghdr(&smb,&msg);
bprintf(text[MailWaitingLstFmt],smb.curmsg+1
,which==MAIL_SENT ? msg.to
: (msg.hdr.attr&MSG_ANONYMOUS) && !SYSOP ? text[Anonymous]
: msg.from
,msg.hdr.attr&MSG_DELETE ? '-' : msg.hdr.attr&MSG_REPLIED ? 'R'
: msg.hdr.attr&MSG_READ ? ' '
: msg.from_net.type || msg.to_net.type ? 'N':'*'
,msg.subj);
smb_freemsgmem(&msg);
msg.total_hfields=0; }
ASYNC;
if(!(sys_status&SS_ABORT)) {
bprintf(text[StartWithN],1L);
if((long)(smb.curmsg=getnum(smb.msgs))>0)
smb.curmsg--;
else if((long)smb.curmsg==-1) {
free(mail);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
return; } }
sys_status&=~SS_ABORT; }
else {
smb.curmsg=0;
if(which==MAIL_ALL)
domsg=0; }
if(which==MAIL_SENT) {
sprintf(str,"%s read sent mail",useron.alias);
logline("E",str);
} else if(which==MAIL_ALL) {
sprintf(str,"%s read all mail",useron.alias);
logline("S+",str);
} else {
sprintf(str,"%s read mail",useron.alias);
logline("E",str);
}
if(useron.misc&RIP) {
strcpy(str,which==MAIL_YOUR ? "mailread" : which==MAIL_ALL ?
"allmail" : "sentmail");
menu(str); }
while(online && !done) {
action=act;
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=mail[smb.curmsg].offset;
msg.idx.number=mail[smb.curmsg].number;
msg.idx.to=mail[smb.curmsg].to;
msg.idx.from=mail[smb.curmsg].from;
msg.idx.subj=mail[smb.curmsg].subj;
if((i=smb_locksmbhdr(&smb))!=0) {
errormsg(WHERE,ERR_LOCK,smb.file,i);
break; }
if((i=smb_getstatus(&smb))!=0) {
smb_unlocksmbhdr(&smb);
errormsg(WHERE,ERR_READ,smb.file,i);
break; }
smb_unlocksmbhdr(&smb);
if(smb.status.last_msg!=last) { /* New messages */
last=smb.status.last_msg;
free(mail);
mail=loadmail(&smb,&smb.msgs,usernumber,which,lm_mode); /* So re-load */
if(!smb.msgs)
break;
for(smb.curmsg=0;smb.curmsg<smb.msgs;smb.curmsg++)
if(mail[smb.curmsg].number==msg.idx.number)
break;
if(smb.curmsg>=smb.msgs)
smb.curmsg=(smb.msgs-1);
continue; }
if(!loadmsg(&msg,mail[smb.curmsg].number)) { /* Message header gone */
if(mismatches>5) { /* We can't do this too many times in a row */
errormsg(WHERE,ERR_CHK,"message number",mail[smb.curmsg].number);
break; }
free(mail);
mail=loadmail(&smb,&smb.msgs,usernumber,which,lm_mode);
if(!smb.msgs)
break;
if(smb.curmsg>(smb.msgs-1))
smb.curmsg=(smb.msgs-1);
mismatches++;
continue; }
smb_unlockmsghdr(&smb,&msg);
msg.idx.attr=msg.hdr.attr;
mismatches=0;
if(domsg && !(sys_status&SS_ABORT)) {
show_msg(&msg
,msg.from_ext && msg.idx.from==1 && !msg.from_net.type
? 0:P_NOATCODES);
if(msg.hdr.auxattr&MSG_FILEATTACH) { /* Attached file */
smb_getmsgidx(&smb,&msg);
strcpy(str,msg.subj); /* filenames in title */
// strupr(str);
tp=str;
while(online) {
p=strchr(tp,' ');
if(p) *p=0;
sp=strrchr(tp,'/'); /* sp is slash pointer */
if(!sp) sp=strrchr(tp,'\\');
if(sp) tp=sp+1;
padfname(tp,fd.name);
sprintf(str2,"%sfile/%04u.in/%s" /* str2 is path/fname */
,cfg.data_dir,msg.idx.to,tp);
length=flength(str2);
if(length<1)
bputs(text[FileNotFound]);
else if(!(useron.exempt&FLAG('T')) && cur_cps && !SYSOP
&& length/(long)cur_cps>(time_t)timeleft)
bputs(text[NotEnoughTimeToDl]);
else {
sprintf(str3,text[DownloadAttachedFileQ]
,tp,ultoac(length,tmp));
if(length>0L && yesno(str3)) {
#if 0 /* no such thing as local logon */
if(online==ON_LOCAL) {
bputs(text[EnterPath]);
if(getstr(str3,60,K_LINE)) {
backslashcolon(str3);
sprintf(tmp,"%s%s",str3,tp);
if(!mv(str2,tmp,which!=MAIL_YOUR)) {
logon_dlb+=length;
logon_dls++;
useron.dls=(ushort)adjustuserrec(&cfg,useron.number
,U_DLS,5,1);
useron.dlb=adjustuserrec(&cfg,useron.number
,U_DLB,10,length);
bprintf(text[FileNBytesSent]
,fd.name,ultoac(length,tmp)); } } }
else
#endif
{ /* Remote User */
xfer_prot_menu(XFER_DOWNLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str3,"Q");
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->dlcmd[0]
&& chk_ar(cfg.prot[i]->ar,&useron)) {
sprintf(tmp,"%c",cfg.prot[i]->mnemonic);
strcat(str3,tmp); }
ch=(char)getkeys(str3,0);
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->dlcmd[0] && ch==cfg.prot[i]->mnemonic
&& chk_ar(cfg.prot[i]->ar,&useron))
break;
if(i<cfg.total_prots) {
error=protocol(cfg.prot[i],XFER_DOWNLOAD,str2,nulstr,false);
if(checkprotresult(cfg.prot[i],error,&fd)) {
if(which==MAIL_YOUR)
remove(str2);
logon_dlb+=length; /* Update stats */
logon_dls++;
useron.dls=(ushort)adjustuserrec(&cfg,useron.number
,U_DLS,5,1);
useron.dlb=adjustuserrec(&cfg,useron.number
,U_DLB,10,length);
bprintf(text[FileNBytesSent]
,fd.name,ultoac(length,tmp));
sprintf(str3
,"%s downloaded attached file: %s"
,useron.alias
,fd.name);
logline("D-",str3);
}
autohangup();
}
}
}
}
if(!p)
break;
tp=p+1;
while(*tp==' ') tp++;
}
sprintf(str,"%sfile/%04u.in",cfg.data_dir,usernumber);
rmdir(str); }
if(which==MAIL_YOUR && !(msg.hdr.attr&MSG_READ)) {
mail[smb.curmsg].attr|=MSG_READ;
if(thisnode.status==NODE_INUSE)
telluser(&msg);
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=0; /* Search by number */
if(smb_locksmbhdr(&smb)==SMB_SUCCESS) { /* Lock the entire base */
if(loadmsg(&msg,msg.idx.number)) {
msg.hdr.attr|=MSG_READ;
msg.idx.attr=msg.hdr.attr;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i);
smb_unlockmsghdr(&smb,&msg); }
smb_unlocksmbhdr(&smb); }
if(!msg.total_hfields) { /* unsuccessful reload */
domsg=0;
continue; } }
}
else domsg=1;
if(useron.misc&WIP) {
strcpy(str,which==MAIL_YOUR ? "mailread" : which==MAIL_ALL ?
"allmail" : "sentmail");
menu(str); }
ASYNC;
if(which==MAIL_SENT)
bprintf(text[ReadingSentMail],smb.curmsg+1,smb.msgs);
else if(which==MAIL_ALL)
bprintf(text[ReadingAllMail],smb.curmsg+1,smb.msgs);
else
bprintf(text[ReadingMail],smb.curmsg+1,smb.msgs);
sprintf(str,"ADFLNQRT?<>[]{}-+");
if(SYSOP)
strcat(str,"CUSPH");
if(which!=MAIL_YOUR)
strcat(str,"E");
l=getkeys(str,smb.msgs);
if(l&0x80000000L) {
if(l==-1) /* ctrl-c */
break;
smb.curmsg=(l&~0x80000000L)-1;
continue; }
switch(l) {
case 'A': /* Auto-reply to last piece */
case 'R':
if(l==(cfg.sys_misc&SM_RA_EMU ? 'A' : 'R')) /* re-read last message */
break;
if(which==MAIL_SENT)
break;
if((msg.hdr.attr&MSG_ANONYMOUS) && !SYSOP) {
bputs(text[CantReplyToAnonMsg]);
break; }
quotemsg(&msg,1);
if(msg.from_net.addr==NULL)
SAFECOPY(str,msg.from);
else if(msg.from_net.type==NET_FIDO) /* FidoNet type */
SAFEPRINTF2(str,"%s@%s",msg.from
,smb_faddrtoa((faddr_t *)msg.from_net.addr,tmp));
else if(msg.from_net.type==NET_INTERNET) {
if(msg.replyto_net.type==NET_INTERNET)
SAFECOPY(str,(char *)msg.replyto_net.addr);
else
SAFECOPY(str,(char *)msg.from_net.addr);
} else
SAFEPRINTF2(str,"%s@%s",msg.from,(char*)msg.from_net.addr);
SAFECOPY(str2,str);
bputs(text[Email]);
if(!getstr(str,64,K_EDIT|K_AUTODEL))
break;
msg.hdr.number=msg.idx.number;
smb_getmsgidx(&smb,&msg);
if(!stricmp(str2,str)) /* Reply to sender */
sprintf(str2,text[Regarding],msg.subj);
else /* Reply to other */
sprintf(str2,text[RegardingByOn],msg.subj,msg.from
,timestr((time_t *)&msg.hdr.when_written.time));
p=strrchr(str,'@');
if(p) { /* name @addr */
replied=netmail(str,msg.subj,WM_QUOTE);
sprintf(str2,text[DeleteMailQ],msg.from); }
else {
if(!msg.from_net.type && !stricmp(str,msg.from))
replied=email(msg.idx.from,str2,msg.subj,WM_EMAIL|WM_QUOTE);
else if(!stricmp(str,"SYSOP"))
replied=email(1,str2,msg.subj,WM_EMAIL|WM_QUOTE);
else if((i=finduser(str))!=0)
replied=email(i,str2,msg.subj,WM_EMAIL|WM_QUOTE);
else
replied=false;
sprintf(str2,text[DeleteMailQ],msg.from); }
if(replied==true && !(msg.hdr.attr&MSG_REPLIED)) {
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=0;
if(smb_locksmbhdr(&smb)==SMB_SUCCESS) { /* Lock the entire base */
if(loadmsg(&msg,msg.idx.number)) {
msg.hdr.attr|=MSG_REPLIED;
msg.idx.attr=msg.hdr.attr;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i);
smb_unlockmsghdr(&smb,&msg);
}
smb_unlocksmbhdr(&smb);
}
}
if(msg.hdr.attr&MSG_DELETE || !yesno(str2)) {
if(smb.curmsg<smb.msgs-1) smb.curmsg++;
else done=1;
break; }
/* Case 'D': must follow! */
case 'D': /* Delete last piece (toggle) */
if(msg.hdr.attr&MSG_PERMANENT) {
bputs("\r\nPermanent message.\r\n");
domsg=0;
break; }
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=0;
if(smb_locksmbhdr(&smb)==SMB_SUCCESS) { /* Lock the entire base */
if(loadmsg(&msg,msg.idx.number)) {
msg.hdr.attr^=MSG_DELETE;
msg.idx.attr=msg.hdr.attr;
// mail[smb.curmsg].attr=msg.hdr.attr;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i);
smb_unlockmsghdr(&smb,&msg);
}
smb_unlocksmbhdr(&smb);
}
if(smb.curmsg<smb.msgs-1) smb.curmsg++;
else done=1;
break;
case 'F': /* Forward last piece */
domsg=0;
bputs(text[ForwardMailTo]);
if(!getstr(str,LEN_ALIAS,cfg.uq&UQ_NOUPRLWR ? K_NONE:K_UPRLWR))
break;
i=finduser(str);
if(!i)
break;
domsg=1;
if(smb.curmsg<smb.msgs-1) smb.curmsg++;
else done=1;
smb_getmsgidx(&smb,&msg);
forwardmail(&msg,i);
if(msg.hdr.attr&MSG_PERMANENT)
break;
sprintf(str2,text[DeleteMailQ],msg.from);
if(!yesno(str2))
break;
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=0;
if(smb_locksmbhdr(&smb)==SMB_SUCCESS) { /* Lock the entire base */
if(loadmsg(&msg,msg.idx.number)) {
msg.hdr.attr|=MSG_DELETE;
msg.idx.attr=msg.hdr.attr;
// mail[smb.curmsg].attr=msg.hdr.attr;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i);
smb_unlockmsghdr(&smb,&msg);
}
smb_unlocksmbhdr(&smb);
}
break;
case 'H':
domsg=0;
msghdr(&msg);
break;
case 'L': /* List mail */
domsg=0;
bprintf(text[StartWithN],(long)smb.curmsg+1);
if((i=getnum(smb.msgs))>0)
i--;
else if(i==-1)
break;
else
i=smb.curmsg;
if(which==MAIL_SENT)
bputs(text[MailSentLstHdr]);
else if(which==MAIL_ALL)
bputs(text[MailOnSystemLstHdr]);
else
bputs(text[MailWaitingLstHdr]);
for(;i<smb.msgs && !msgabort();i++) {
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=mail[i].offset;
if(!loadmsg(&msg,mail[i].number))
continue;
smb_unlockmsghdr(&smb,&msg);
if(which==MAIL_ALL)
bprintf(text[MailOnSystemLstFmt]
,i+1,msg.from,msg.to
,msg.hdr.attr&MSG_DELETE ? '-' : msg.hdr.attr&MSG_REPLIED ? 'R'
: msg.hdr.attr&MSG_READ ? ' '
: msg.from_net.type || msg.to_net.type ? 'N':'*'
,msg.subj);
else
bprintf(text[MailWaitingLstFmt],i+1
,which==MAIL_SENT ? msg.to
: (msg.hdr.attr&MSG_ANONYMOUS) && !SYSOP
? text[Anonymous] : msg.from
,msg.hdr.attr&MSG_DELETE ? '-' : msg.hdr.attr&MSG_REPLIED ? 'R'
: msg.hdr.attr&MSG_READ ? ' '
: msg.from_net.type || msg.to_net.type ? 'N':'*'
,msg.subj);
smb_freemsgmem(&msg);
msg.total_hfields=0; }
break;
case 'Q':
done=1;
break;
case 'C': /* Change attributes of last piece */
i=chmsgattr(msg.hdr.attr);
if(msg.hdr.attr==i)
break;
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=0;
if(smb_locksmbhdr(&smb)==SMB_SUCCESS) { /* Lock the entire base */
if(loadmsg(&msg,msg.idx.number)) {
msg.hdr.attr=msg.idx.attr=(ushort)i;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i);
smb_unlockmsghdr(&smb,&msg);
}
smb_unlocksmbhdr(&smb);
}
break;
case '>':
for(i=smb.curmsg+1;i<smb.msgs;i++)
if(mail[i].subj==msg.idx.subj)
break;
if(i<smb.msgs)
smb.curmsg=i;
else
domsg=0;
break;
case '<': /* Search Title backward */
for(i=smb.curmsg-1;i>-1;i--)
if(mail[i].subj==msg.idx.subj)
break;
if(i>-1)
smb.curmsg=i;
else
domsg=0;
break;
case '}': /* Search Author forward */
strcpy(str,msg.from);
for(i=smb.curmsg+1;i<smb.msgs;i++)
if(mail[i].from==msg.idx.from)
break;
if(i<smb.msgs)
smb.curmsg=i;
else
domsg=0;
break;
case 'N': /* Got to next un-read message */
for(i=smb.curmsg+1;i<smb.msgs;i++)
if(!(mail[i].attr&MSG_READ))
break;
if(i<smb.msgs)
smb.curmsg=i;
else
domsg=0;
break;
case '{': /* Search Author backward */
strcpy(str,msg.from);
for(i=smb.curmsg-1;i>-1;i--)
if(mail[i].from==msg.idx.from)
break;
if(i>-1)
smb.curmsg=i;
else
domsg=0;
break;
case ']': /* Search To User forward */
strcpy(str,msg.to);
for(i=smb.curmsg+1;i<smb.msgs;i++)
if(mail[i].to==msg.idx.to)
break;
if(i<smb.msgs)
smb.curmsg=i;
else
domsg=0;
break;
case '[': /* Search To User backward */
strcpy(str,msg.to);
for(i=smb.curmsg-1;i>-1;i--)
if(mail[i].to==msg.idx.to)
break;
if(i>-1)
smb.curmsg=i;
else
domsg=0;
break;
case 0:
case '+':
if(smb.curmsg<smb.msgs-1) smb.curmsg++;
else done=1;
break;
case '-':
if(smb.curmsg>0) smb.curmsg--;
break;
case 'S':
domsg=0;
/*
if(!yesno(text[SaveMsgToFile]))
break;
*/
bputs(text[FileToWriteTo]);
if(getstr(str,40,K_LINE))
msgtotxt(&msg,str,1,1);
break;
case 'E':
editmsg(&msg,INVALID_SUB);
break;
case 'T':
domsg=0;
i=smb.curmsg;
if(i) i++;
j=i+10;
if(j>smb.msgs)
j=smb.msgs;
if(which==MAIL_SENT)
bputs(text[MailSentLstHdr]);
else if(which==MAIL_ALL)
bputs(text[MailOnSystemLstHdr]);
else
bputs(text[MailWaitingLstHdr]);
for(;i<j;i++) {
if(msg.total_hfields)
smb_freemsgmem(&msg);
msg.total_hfields=0;
msg.idx.offset=mail[i].offset;
if(!loadmsg(&msg,mail[i].number))
continue;
smb_unlockmsghdr(&smb,&msg);
if(which==MAIL_ALL)
bprintf(text[MailOnSystemLstFmt]
,i+1,msg.from,msg.to
,msg.hdr.attr&MSG_DELETE ? '-' : msg.hdr.attr&MSG_REPLIED ? 'R'
: msg.hdr.attr&MSG_READ ? ' '
: msg.from_net.type || msg.to_net.type ? 'N':'*'
,msg.subj);
else
bprintf(text[MailWaitingLstFmt],i+1
,which==MAIL_SENT ? msg.to
: (msg.hdr.attr&MSG_ANONYMOUS) && !SYSOP
? text[Anonymous] : msg.from
,msg.hdr.attr&MSG_DELETE ? '-' : msg.hdr.attr&MSG_REPLIED ? 'R'
: msg.hdr.attr&MSG_READ ? ' '
: msg.from_net.type || msg.to_net.type ? 'N':'*'
,msg.subj);
smb_freemsgmem(&msg);
msg.total_hfields=0; }
smb.curmsg=(i-1);
break;
case 'U': /* user edit */
msg.hdr.number=msg.idx.number;
smb_getmsgidx(&smb,&msg);
useredit(which==MAIL_SENT ? msg.idx.to : msg.idx.from);
break;
case 'P': /* Purge author and all mail to/from */
if(noyes(text[AreYouSureQ]))
break;
msg.hdr.number=msg.idx.number;
smb_getmsgidx(&smb,&msg);
purgeuser(msg.idx.from);
if(smb.curmsg<smb.msgs-1) smb.curmsg++;
break;
case '?':
strcpy(str,which==MAIL_YOUR ? "mailread" : which==MAIL_ALL
? "allmail" : "sentmail");
menu(str);
if(SYSOP && which==MAIL_SENT)
menu("syssmail");
else if(SYSOP && which==MAIL_YOUR)
menu("sysmailr"); /* Sysop Mail Read */
domsg=0;
break;
} }
if(msg.total_hfields)
smb_freemsgmem(&msg);
if(smb.msgs)
free(mail);
/***************************************/
/* Delete messages marked for deletion */
/***************************************/
if(cfg.sys_misc&SM_DELEMAIL) {
if((i=smb_locksmbhdr(&smb))!=0) /* Lock the base, so nobody */
errormsg(WHERE,ERR_LOCK,smb.file,i); /* messes with the index */
else
delmail(usernumber,which); }
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
}
/* TODO this is one of the worst ever functions written. void *data ? wtf */
void cb_trans_conv(pmtransconv_t event, void *data1, void *data2,
void *data3, int *response)
{
switch(event) {
case PM_TRANS_CONV_INSTALL_IGNOREPKG:
if(!config->op_s_downloadonly) {
*response = yesno(_(":: %s is in IgnorePkg/IgnoreGroup. Install anyway?"),
alpm_pkg_get_name(data1));
} else {
*response = 1;
}
break;
case PM_TRANS_CONV_REPLACE_PKG:
*response = yesno(_(":: Replace %s with %s/%s?"),
alpm_pkg_get_name(data1),
(char *)data3,
alpm_pkg_get_name(data2));
break;
case PM_TRANS_CONV_CONFLICT_PKG:
/* data parameters: target package, local package, conflict (strings) */
/* print conflict only if it contains new information */
if(strcmp(data1, data3) == 0 || strcmp(data2, data3) == 0) {
*response = noyes(_(":: %s and %s are in conflict. Remove %s?"),
(char *)data1,
(char *)data2,
(char *)data2);
} else {
*response = noyes(_(":: %s and %s are in conflict (%s). Remove %s?"),
(char *)data1,
(char *)data2,
(char *)data3,
(char *)data2);
}
break;
case PM_TRANS_CONV_REMOVE_PKGS:
{
alpm_list_t *unresolved = (alpm_list_t *) data1;
alpm_list_t *namelist = NULL, *i;
size_t count = 0;
for (i = unresolved; i; i = i->next) {
namelist = alpm_list_add(namelist,
(char *)alpm_pkg_get_name(i->data));
count++;
}
printf(_n(
":: The following package cannot be upgraded due to unresolvable dependencies:\n",
":: The following packages cannot be upgraded due to unresolvable dependencies:\n",
count));
list_display(" ", namelist);
printf("\n");
*response = noyes(_n(
"Do you want to skip the above package for this upgrade?",
"Do you want to skip the above packages for this upgrade?",
count));
alpm_list_free(namelist);
}
break;
case PM_TRANS_CONV_SELECT_PROVIDER:
{
alpm_list_t *providers = (alpm_list_t *)data1;
int count = alpm_list_count(providers);
char *depstring = alpm_dep_compute_string((pmdepend_t *)data2);
printf(_(":: There are %d providers available for %s:\n"), count,
depstring);
free(depstring);
select_display(providers);
*response = select_question(count);
}
break;
case PM_TRANS_CONV_LOCAL_NEWER:
if(!config->op_s_downloadonly) {
*response = yesno(_(":: %s-%s: local version is newer. Upgrade anyway?"),
alpm_pkg_get_name(data1),
alpm_pkg_get_version(data1));
} else {
*response = 1;
}
break;
case PM_TRANS_CONV_CORRUPTED_PKG:
*response = yesno(_(":: File %s is corrupted. Do you want to delete it?"),
(char *)data1);
break;
}
if(config->noask) {
if(config->ask & event) {
/* inverse the default answer */
*response = !*response;
}
}
}
int sbbs_t::text_sec()
{
char str[256],usemenu
,*file[MAX_TXTFILES],addpath[83],addstr[83],*buf,ch;
char tmp[512];
long i,j,usrsec[MAX_TXTSECS],usrsecs,cursec;
long l,length;
FILE *stream;
for(i=j=0;i<cfg.total_txtsecs;i++) {
if(!chk_ar(cfg.txtsec[i]->ar,&useron,&client))
continue;
usrsec[j++]=i;
}
usrsecs=j;
if(!usrsecs) {
bputs(text[NoTextSections]);
return(1);
}
action=NODE_RTXT;
while(online) {
sprintf(str,"%smenu/text_sec.*",cfg.text_dir);
if(fexist(str))
menu("text_sec");
else {
bputs(text[TextSectionLstHdr]);
for(i=0;i<usrsecs && !msgabort();i++) {
sprintf(str,text[TextSectionLstFmt],i+1,cfg.txtsec[usrsec[i]]->name);
if(i<9) outchar(' ');
bputs(str);
}
}
ASYNC;
mnemonics(text[WhichTextSection]);
if((cursec=getnum(usrsecs))<1)
break;
cursec--;
while(online) {
sprintf(str,"%smenu/text%lu.*",cfg.text_dir,cursec+1);
if(fexist(str)) {
sprintf(str,"text%lu",cursec+1);
menu(str);
usemenu=1;
}
else {
bprintf(text[TextFilesLstHdr],cfg.txtsec[usrsec[cursec]]->name);
usemenu=0;
}
sprintf(str,"%stext/%s.ixt",cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
j=0;
if(fexist(str)) {
if((stream=fnopen((int *)&i,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(0);
}
while(!ferror(stream) && !msgabort()) { /* file open too long */
if(!fgets(str,81,stream))
break;
str[strlen(str)-2]=0; /* chop off CRLF */
if((file[j]=(char *)malloc(strlen(str)+1))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,strlen(str)+1);
continue;
}
strcpy(file[j],str);
fgets(str,81,stream);
if(!usemenu) bprintf(text[TextFilesLstFmt],j+1,str);
j++;
}
fclose(stream);
}
ASYNC;
if(SYSOP) {
strcpy(str,"QARE?");
mnemonics(text[WhichTextFileSysop]);
}
else {
strcpy(str,"Q?");
mnemonics(text[WhichTextFile]);
}
i=getkeys(str,j);
if(!(i&0x80000000L)) { /* no file number */
for(l=0;l<j;l++)
free(file[l]);
if((i=='E' || i=='R') && !j)
continue;
}
if(i=='Q' || !i)
break;
if(i==-1) { /* ctrl-c */
for(i=0;i<j;i++)
free(file[i]);
return(0);
}
if(i=='?') /* ? means re-list */
continue;
if(i=='A') { /* Add text file */
if(j) {
bputs(text[AddTextFileBeforeWhich]);
i=getnum(j+1);
if(i<1)
continue;
i--; /* number of file entries to skip */ }
else
i=0;
bprintf(text[AddTextFilePath]
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
if(!getstr(addpath,80,0))
continue;
strcat(addpath,crlf);
bputs(text[AddTextFileDesc]);
if(!getstr(addstr,74,0))
continue;
strcat(addstr,crlf);
sprintf(str,"%stext/%s.ixt"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
if(i==j) { /* just add to end */
if((i=nopen(str,O_WRONLY|O_APPEND|O_CREAT))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_APPEND|O_CREAT);
return(0);
}
write(i,addpath,strlen(addpath));
write(i,addstr,strlen(addstr));
close(i);
continue;
}
j=i; /* inserting in middle of file */
if((stream=fnopen((int *)&i,str,O_RDWR))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDWR);
return(0);
}
length=(long)filelength(i);
for(i=0;i<j;i++) { /* skip two lines for each entry */
fgets(tmp,81,stream);
fgets(tmp,81,stream);
}
l=(long)ftell(stream);
if((buf=(char *)malloc(length-l))==NULL) {
fclose(stream);
errormsg(WHERE,ERR_ALLOC,str,length-l);
return(0);
}
fread(buf,1,length-l,stream);
fseek(stream,l,SEEK_SET); /* go back to where we need to insert */
fputs(addpath,stream);
fputs(addstr,stream);
fwrite(buf,1,length-l,stream);
fclose(stream);
free(buf);
continue;
}
if(i=='R' || i=='E') { /* Remove or Edit text file */
ch=(char)i;
if(ch=='R')
bputs(text[RemoveWhichTextFile]);
else
bputs(text[EditWhichTextFile]);
i=getnum(j);
if(i<1)
continue;
sprintf(str,"%stext/%s.ixt"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
j=i-1;
if((stream=fnopen(NULL,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(0);
}
for(i=0;i<j;i++) { /* skip two lines for each entry */
fgets(tmp,81,stream);
fgets(tmp,81,stream);
}
fgets(addpath,81,stream);
truncsp(addpath);
fclose(stream);
if(!strchr(addpath,'\\') && !strchr(addpath,'/'))
sprintf(tmp,"%stext/%s/%s"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code,addpath);
else
strcpy(tmp,addpath);
if(ch=='R') { /* Remove */
if(fexist(tmp)) {
sprintf(str,text[DeleteTextFileQ],tmp);
if(!noyes(str))
if(remove(tmp)) errormsg(WHERE,ERR_REMOVE,tmp,0);
}
sprintf(str,"%stext/%s.ixt"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code);
removeline(str,addpath,2,0);
}
else { /* Edit */
strcpy(str,tmp);
editfile(str);
}
continue;
}
i=(i&~0x80000000L)-1;
if(!strchr(file[i],'\\') && !strchr(file[i],'/'))
sprintf(str,"%stext/%s/%s"
,cfg.data_dir,cfg.txtsec[usrsec[cursec]]->code,file[i]);
else
strcpy(str,file[i]);
fexistcase(str);
attr(LIGHTGRAY);
printfile(str,0);
sprintf(str,"%s read text file: %s"
,useron.alias,file[i]);
logline("T-",str);
pause();
sys_status&=~SS_ABORT;
for(i=0;i<j;i++)
free(file[i]);
}
}
return(0);
}
bool 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);
}
int sbbs_t::login(char *username, char *pw)
{
char str[128];
char tmp[512];
long useron_misc=useron.misc;
useron.number=0;
#if 0
if(cfg.node_dollars_per_call && noyes(text[AreYouSureQ]))
return(LOGIC_FALSE);
#endif
SAFECOPY(str,username);
if(str[0]=='*') {
memmove(str,str+1,strlen(str));
qwklogon=1;
}
else
qwklogon=0;
if(!(cfg.node_misc&NM_NO_NUM) && isdigit((uchar)str[0])) {
useron.number=atoi(str);
getuserdat(&cfg,&useron);
if(useron.number && useron.misc&(DELETED|INACTIVE))
useron.number=0;
}
if(!useron.number) {
useron.number=matchuser(&cfg,str,FALSE);
if(!useron.number && (uchar)str[0]<0x7f && str[1]
&& isalpha(str[0]) && strchr(str,' ') && cfg.node_misc&NM_LOGON_R)
useron.number=userdatdupe(0,U_NAME,LEN_NAME,str);
if(useron.number) {
getuserdat(&cfg,&useron);
if(useron.number && useron.misc&(DELETED|INACTIVE))
useron.number=0; }
}
if(!useron.number) {
if(cfg.node_misc&NM_LOGON_P) {
SAFECOPY(useron.alias,str);
bputs(pw);
console|=CON_R_ECHOX;
getstr(str,LEN_PASS*2,K_UPPER|K_LOWPRIO|K_TAB);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
badlogin(useron.alias, str);
bputs(text[InvalidLogon]); /* why does this always fail? */
if(cfg.sys_misc&SM_ECHO_PW)
sprintf(tmp,"(%04u) %-25s FAILED Password attempt: '%s'"
,0,useron.alias,str);
else
sprintf(tmp,"(%04u) %-25s FAILED Password attempt"
,0,useron.alias);
logline(LOG_NOTICE,"+!",tmp);
} else {
bputs(text[UnknownUser]);
sprintf(tmp,"Unknown User '%s'",str);
logline(LOG_NOTICE,"+!",tmp);
}
useron.misc=useron_misc;
return(LOGIC_FALSE);
}
if(!online) {
useron.number=0;
return(LOGIC_FALSE);
}
if(useron.pass[0] || REALSYSOP) {
bputs(pw);
console|=CON_R_ECHOX;
getstr(str,LEN_PASS*2,K_UPPER|K_LOWPRIO|K_TAB);
console&=~(CON_R_ECHOX|CON_L_ECHOX);
if(!online) {
useron.number=0;
return(LOGIC_FALSE);
}
if(stricmp(useron.pass,str)) {
badlogin(useron.alias, str);
bputs(text[InvalidLogon]);
if(cfg.sys_misc&SM_ECHO_PW)
sprintf(tmp,"(%04u) %-25s FAILED Password: '******' Attempt: '%s'"
,useron.number,useron.alias,useron.pass,str);
else
sprintf(tmp,"(%04u) %-25s FAILED Password attempt"
,useron.number,useron.alias);
logline(LOG_NOTICE,"+!",tmp);
useron.number=0;
useron.misc=useron_misc;
return(LOGIC_FALSE);
}
if(REALSYSOP && !chksyspass()) {
bputs(text[InvalidLogon]);
useron.number=0;
useron.misc=useron_misc;
return(LOGIC_FALSE);
}
}
return(LOGIC_TRUE);
}
/**
* @brief Remove a specified list of packages.
*
* @param targets a list of packages (as strings) to remove from the system
*
* @return 0 on success, 1 on failure
*/
int pacman_remove(alpm_list_t *targets)
{
int retval = 0;
alpm_list_t *i, *data = NULL;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Step 0: create a new transaction */
if(trans_init(config->flags, 0) == -1) {
return 1;
}
/* Step 1: add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *target = i->data;
if(strncmp(target, "local/", 6) == 0) {
target += 6;
}
if(remove_target(target) == -1) {
retval = 1;
}
}
if(retval == 1) {
goto cleanup;
}
/* Step 2: prepare the transaction based on its type, targets and flags */
if(alpm_trans_prepare(config->handle, &data) == -1) {
alpm_errno_t err = alpm_errno(config->handle);
pm_printf(ALPM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case ALPM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
alpm_depmissing_t *miss = i->data;
char *depstring = alpm_dep_compute_string(miss->depend);
colon_printf(_("%s: requires %s\n"), miss->target, depstring);
free(depstring);
alpm_depmissing_free(miss);
}
break;
default:
break;
}
alpm_list_free(data);
retval = 1;
goto cleanup;
}
/* Search for holdpkg in target list */
int holdpkg = 0;
for(i = alpm_trans_get_remove(config->handle); i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
if(alpm_list_find(config->holdpkg, alpm_pkg_get_name(pkg), fnmatch_cmp)) {
pm_printf(ALPM_LOG_WARNING, _("%s is designated as a HoldPkg.\n"),
alpm_pkg_get_name(pkg));
holdpkg = 1;
}
}
if(holdpkg && (noyes(_("HoldPkg was found in target list. Do you want to continue?")) == 0)) {
retval = 1;
goto cleanup;
}
/* Step 3: actually perform the removal */
alpm_list_t *pkglist = alpm_trans_get_remove(config->handle);
if(pkglist == NULL) {
printf(_(" there is nothing to do\n"));
goto cleanup; /* we are done */
}
if(config->print) {
print_packages(pkglist);
goto cleanup;
}
/* print targets and ask user confirmation */
display_targets();
printf("\n");
if(yesno(_("Do you want to remove these packages?")) == 0) {
retval = 1;
goto cleanup;
}
if(alpm_trans_commit(config->handle, &data) == -1) {
pm_printf(ALPM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
alpm_strerror(alpm_errno(config->handle)));
retval = 1;
}
FREELIST(data);
/* Step 4: release transaction resources */
cleanup:
if(trans_release() == -1) {
retval = 1;
}
return retval;
}
void sbbs_t::new_scan_cfg(ulong misc)
{
long s;
ulong i,j;
ulong t;
while(online) {
bputs(text[CfgGrpLstHdr]);
for(i=0;i<usrgrps && !msgabort();i++) {
checkline();
if(i<9) outchar(' ');
if(i<99) outchar(' ');
bprintf(text[CfgGrpLstFmt],i+1,cfg.grp[usrgrp[i]]->lname);
}
SYNC;
if(misc&SUB_CFG_NSCAN)
mnemonics(text[NScanCfgWhichGrp]);
else
mnemonics(text[SScanCfgWhichGrp]);
s=getnum(i);
if(s<1)
break;
i=s-1;
while(online) {
if(misc&SUB_CFG_NSCAN)
misc&=~SUB_CFG_YSCAN;
bprintf(text[CfgSubLstHdr],cfg.grp[usrgrp[i]]->lname);
for(j=0;j<usrsubs[i] && !msgabort();j++) {
checkline();
if(j<9) outchar(' ');
if(j<99) outchar(' ');
bprintf(text[CfgSubLstFmt],j+1
,cfg.sub[usrsub[i][j]]->lname
,subscan[usrsub[i][j]].cfg&misc ?
(misc&SUB_CFG_NSCAN && subscan[usrsub[i][j]].cfg&SUB_CFG_YSCAN) ?
"To You Only" : text[On] : text[Off]);
}
SYNC;
if(misc&SUB_CFG_NSCAN)
mnemonics(text[NScanCfgWhichSub]);
else
mnemonics(text[SScanCfgWhichSub]);
s=getkeys("AQ",usrsubs[i]);
if(sys_status&SS_ABORT) {
lncntr=0;
return;
}
if(!s || s==-1 || s=='Q')
break;
if(s=='A') {
t=subscan[usrsub[i][0]].cfg&misc;
if(misc&SUB_CFG_NSCAN && !t && !(useron.misc&FLAG('Q')))
if(!noyes("Messages to you only"))
misc|=SUB_CFG_YSCAN;
for(j=0;j<usrsubs[i] && online;j++) {
checkline();
if(t) subscan[usrsub[i][j]].cfg&=~misc;
else {
if(misc&SUB_CFG_NSCAN)
subscan[usrsub[i][j]].cfg&=~SUB_CFG_YSCAN;
subscan[usrsub[i][j]].cfg|=misc;
}
}
continue;
}
j=(s&~0x80000000L)-1;
if(misc&SUB_CFG_NSCAN && !(subscan[usrsub[i][j]].cfg&misc)) {
if(!(useron.rest&FLAG('Q')) && !noyes("Messages to you only"))
subscan[usrsub[i][j]].cfg|=SUB_CFG_YSCAN;
else
subscan[usrsub[i][j]].cfg&=~SUB_CFG_YSCAN;
}
subscan[usrsub[i][j]].cfg^=misc;
}
}
}
void ConfigUserMenuSet() {
if (session()->usernum != nSecondUserRecLoaded) {
if (!LoadMenuSetup(session()->usernum)) {
LoadMenuSetup(1);
}
}
nSecondUserRecLoaded = session()->usernum;
bout.cls();
bout.litebar("Configure Menus");
printfile(MENUWEL_NOEXT);
bool bDone = false;
while (!bDone && !hangup) {
bout.nl();
bout << "|#11|#9) Menuset :|#2 " << pSecondUserRec->szMenuSet << wwiv::endl;
bout << "|#12|#9) Use hot keys :|#2 " << (pSecondUserRec->cHotKeys == HOTKEYS_ON ? "Yes" : "No ")
<< wwiv::endl;
bout.nl();
bout << "|#9(|#2Q|#9=|#1Quit|#9) : ";
char chKey = onek("Q12?");
switch (chKey) {
case 'Q':
bDone = true;
break;
case '1': {
ListMenuDirs();
bout.nl(2);
bout << "|#9Enter the menu set to use : ";
string menuSetName;
inputl(&menuSetName, 8);
if (ValidateMenuSet(menuSetName.c_str())) {
wwiv::menus::MenuDescriptions descriptions(GetMenuDirectory());
bout.nl();
bout << "|#9Menu Set : |#2" << menuSetName.c_str() << " : |#1" << descriptions.description(menuSetName) << wwiv::endl;
bout << "|#5Use this menu set? ";
if (noyes()) {
strcpy(pSecondUserRec->szMenuSet, menuSetName.c_str());
break;
}
}
bout.nl();
bout << "|#6That menu set does not exists, resetting to the default menu set" << wwiv::endl;
pausescr();
if (pSecondUserRec->szMenuSet[0] == '\0') {
strcpy(pSecondUserRec->szMenuSet, "wwiv");
}
}
break;
case '2':
pSecondUserRec->cHotKeys = !pSecondUserRec->cHotKeys;
break;
case '3':
pSecondUserRec->cMenuType = !pSecondUserRec->cMenuType;
break;
case '?':
printfile(MENUWEL_NOEXT);
continue; // bypass the below cls()
}
bout.cls();
}
// If menu is invalid, it picks the first one it finds
if (!ValidateMenuSet(pSecondUserRec->szMenuSet)) {
if (session()->num_languages > 1 && session()->user()->GetLanguage() != 0) {
bout << "|#6No menus for " << languages[session()->user()->GetLanguage()].name
<< " language.";
input_language();
}
}
WriteMenuSetup(session()->usernum);
MenuSysopLog(StringPrintf("Menu in use : %s - %s - %s", pSecondUserRec->szMenuSet,
pSecondUserRec->cHotKeys == HOTKEYS_ON ? "Hot" : "Off", pSecondUserRec->cMenuType == MENUTYPE_REGULAR ? "REG" : "PD"));
bout.nl(2);
}
void sbbs_t::qwktonetmail(FILE *rep, char *block, char *into, uchar fromhub)
{
char *qwkbuf,to[129],name[129],sender[129],senderaddr[129]
,str[256],*p,*cp,*addr,fulladdr[129],ch;
char tmp[512];
int i,fido,inet=0,qnet=0;
ushort net;
uint16_t xlat;
long l,offset,length,m,n;
faddr_t fidoaddr;
fmsghdr_t hdr;
smbmsg_t msg;
struct tm tm;
if(useron.rest&FLAG('M')) {
bputs(text[NoNetMailAllowed]);
return;
}
to[0]=0;
name[0]=0;
sender[0]=0;
senderaddr[0]=0;
fulladdr[0]=0;
sprintf(str,"%.6s",block+116);
n=atol(str); /* i = number of 128 byte records */
if(n<2L || n>999999L) {
errormsg(WHERE,ERR_CHK,"QWK blocks",n);
return;
}
if((qwkbuf=(char *)malloc(n*QWK_BLOCK_LEN))==NULL) {
errormsg(WHERE,ERR_ALLOC,nulstr,n*QWK_BLOCK_LEN);
return;
}
memcpy((char *)qwkbuf,block,QWK_BLOCK_LEN);
fread(qwkbuf+QWK_BLOCK_LEN,n-1,QWK_BLOCK_LEN,rep);
if(into==NULL)
sprintf(to,"%-128.128s",(char *)qwkbuf+QWK_BLOCK_LEN); /* To user on first line */
else
SAFECOPY(to,into);
p=strchr(to,QWK_NEWLINE); /* chop off at first CR */
if(p) *p=0;
SAFECOPY(name,to);
p=strchr(name,'@');
if(p) *p=0;
truncsp(name);
p=strrchr(to,'@'); /* Find '@' in name@addr */
if(p && !isdigit(*(p+1)) && !strchr(p,'.') && !strchr(p,':')) { /* QWKnet */
qnet=1;
*p=0;
}
else if(p==NULL || !isdigit(*(p+1)) || !cfg.total_faddrs) {
if(p==NULL && cfg.dflt_faddr.zone)
fidoaddr=cfg.dflt_faddr;
else if(cfg.inetmail_misc&NMAIL_ALLOW) { /* Internet */
inet=1;
}
else if(cfg.dflt_faddr.zone)
fidoaddr=cfg.dflt_faddr;
else {
bputs(text[InvalidNetMailAddr]);
free(qwkbuf);
return;
}
}
else {
fidoaddr=atofaddr(&cfg,p+1); /* Get fido address */
*p=0; /* Chop off address */
}
if(!inet && !qnet && /* FidoNet */
((!SYSOP && !(cfg.netmail_misc&NMAIL_ALLOW)) || !cfg.total_faddrs)) {
bputs(text[NoNetMailAllowed]);
free(qwkbuf);
return;
}
truncsp(to); /* Truncate off space */
if(!stricmp(to,"SBBS") && !SYSOP && qnet) {
free(qwkbuf);
return;
}
l=QWK_BLOCK_LEN; /* Start of message text */
if(qnet || inet) {
if(into==NULL) { /* If name@addr on first line, skip first line */
while(l<(n*QWK_BLOCK_LEN) && qwkbuf[l]!=QWK_NEWLINE) l++;
l++;
}
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
msg.hdr.when_imported.time=time32(NULL);
msg.hdr.when_imported.zone=sys_timezone(&cfg);
if(fromhub || useron.rest&FLAG('Q')) {
net=NET_QWK;
smb_hfield(&msg,SENDERNETTYPE,sizeof(net),&net);
if(!strncmp(qwkbuf+l,"@VIA:",5)) {
sprintf(str,"%.128s",qwkbuf+l+5);
cp=strchr(str,QWK_NEWLINE);
if(cp) *cp=0;
l+=strlen(str)+1;
cp=str;
while(*cp && *cp<=' ') cp++;
sprintf(senderaddr,"%s/%s"
,fromhub ? cfg.qhub[fromhub-1]->id : useron.alias,cp);
strupr(senderaddr);
smb_hfield(&msg,SENDERNETADDR,strlen(senderaddr),senderaddr);
}
else {
if(fromhub)
SAFECOPY(senderaddr, cfg.qhub[fromhub-1]->id);
else
SAFECOPY(senderaddr, useron.alias);
strupr(senderaddr);
smb_hfield(&msg,SENDERNETADDR,strlen(senderaddr),senderaddr);
}
sprintf(sender,"%.25s",block+46); /* From name */
}
else { /* Not Networked */
msg.hdr.when_written.zone=sys_timezone(&cfg);
sprintf(str,"%u",useron.number);
smb_hfield(&msg,SENDEREXT,strlen(str),str);
SAFECOPY(sender,(qnet || cfg.inetmail_misc&NMAIL_ALIAS)
? useron.alias : useron.name);
}
truncsp(sender);
smb_hfield(&msg,SENDER,strlen(sender),sender);
if(fromhub)
msg.idx.from=0;
else
msg.idx.from=useron.number;
if(!strncmp(qwkbuf+l,"@TZ:",4)) {
sprintf(str,"%.128s",qwkbuf+l);
cp=strchr(str,QWK_NEWLINE);
if(cp) *cp=0;
l+=strlen(str)+1;
cp=str+4;
while(*cp && *cp<=' ') cp++;
msg.hdr.when_written.zone=(short)ahtoul(cp);
}
else
msg.hdr.when_written.zone=sys_timezone(&cfg);
memset(&tm,0,sizeof(tm));
tm.tm_mon=((qwkbuf[8]&0xf)*10)+(qwkbuf[9]&0xf);
if(tm.tm_mon) tm.tm_mon--; /* 0 based */
tm.tm_mday=((qwkbuf[11]&0xf)*10)+(qwkbuf[12]&0xf);
tm.tm_year=((qwkbuf[14]&0xf)*10)+(qwkbuf[15]&0xf);
if(tm.tm_year<Y2K_2DIGIT_WINDOW)
tm.tm_year+=100;
tm.tm_hour=((qwkbuf[16]&0xf)*10)+(qwkbuf[17]&0xf);
tm.tm_min=((qwkbuf[19]&0xf)*10)+(qwkbuf[20]&0xf); /* From QWK time */
tm.tm_sec=0;
tm.tm_isdst=-1; /* Do not adjust for DST */
msg.hdr.when_written.time=mktime32(&tm);
sprintf(str,"%.25s",block+71); /* Title */
smb_hfield(&msg,SUBJECT,strlen(str),str);
}
if(qnet) {
p++;
addr=p;
msg.idx.to=qwk_route(addr,fulladdr);
if(!fulladdr[0]) { /* Invalid address, so BOUNCE it */
/**
errormsg(WHERE,ERR_CHK,addr,0);
free(qwkbuf);
smb_freemsgmem(msg);
return;
**/
smb_hfield(&msg,SENDER,strlen(cfg.sys_id),cfg.sys_id);
msg.idx.from=0;
msg.idx.to=useron.number;
SAFECOPY(to,sender);
SAFECOPY(fulladdr,senderaddr);
SAFEPRINTF(str,"BADADDR: %s",addr);
smb_hfield(&msg,SUBJECT,strlen(str),str);
net=NET_NONE;
smb_hfield(&msg,SENDERNETTYPE,sizeof(net),&net);
}
/* This is required for fixsmb to be able to rebuild the index */
SAFEPRINTF(str,"%u",msg.idx.to);
smb_hfield_str(&msg,RECIPIENTEXT,str);
smb_hfield(&msg,RECIPIENT,strlen(name),name);
net=NET_QWK;
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
truncsp(fulladdr);
if(fulladdr[0])
smb_hfield(&msg,RECIPIENTNETADDR,strlen(fulladdr),fulladdr);
bprintf(text[NetMailing],to,fulladdr,sender,cfg.sys_id);
}
if(inet) { /* Internet E-mail */
if(cfg.inetmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.inetmail_cost) {
bputs(text[NotEnoughCredits]);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
sprintf(str,text[NetMailCostContinueQ],cfg.inetmail_cost);
if(noyes(str)) {
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
}
net=NET_INTERNET;
smb_hfield(&msg,RECIPIENT,strlen(name),name);
msg.idx.to=0; /* Out-bound NetMail set to 0 */
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
smb_hfield(&msg,RECIPIENTNETADDR,strlen(to),to);
bprintf(text[NetMailing],name,to
,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name
,cfg.sys_inetaddr);
}
if(qnet || inet) {
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
sprintf(smb.file,"%smail", cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
if(smb_fgetlength(smb.shd_fp)<1L) { /* Create it if it doesn't exist */
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_msgs=0;
smb.status.max_age=cfg.mail_maxage;
smb.status.attr=SMB_EMAIL;
if((i=smb_create(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i,smb.last_error);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
}
length=n*256L; // Extra big for CRLF xlat, was (n-1L)*256L (03/16/96)
if(length&0xfff00000UL || !length) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
sprintf(str,"REP msg (%ld)",n);
errormsg(WHERE,ERR_LEN,str,length);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
if((i=smb_open_da(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
free(qwkbuf);
smb_freemsgmem(&msg);
return;
}
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
smb_fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
smb_fwrite(&smb,&xlat,2,smb.sdt_fp);
m=2;
for(;l<n*QWK_BLOCK_LEN && m<length;l++) {
if(qwkbuf[l]==0 || qwkbuf[l]==LF)
continue;
if(qwkbuf[l]==QWK_NEWLINE) {
smb_fwrite(&smb,crlf,2,smb.sdt_fp);
m+=2;
continue;
}
smb_fputc(qwkbuf[l],smb.sdt_fp);
m++;
}
for(ch=0;m<length;m++) /* Pad out with NULLs */
smb_fputc(ch,smb.sdt_fp);
smb_fflush(smb.sdt_fp);
msg.hdr.offset=offset;
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
smb_freemsgdat(&smb,offset,length,1);
}
else { /* Successful */
if(inet) {
if(cfg.inetmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.inetmail_sem,nulstr,nulstr,NULL));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.inetmail_cost);
}
useron.emails++;
logon_emails++;
putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10));
useron.etoday++;
putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
sprintf(str,"%s sent %s NetMail to %s (%s) via QWK"
,useron.alias
,qnet ? "QWK":"Internet",name,qnet ? fulladdr : to);
logline("EN",str);
}
free((char *)qwkbuf);
return;
}
/****************************** FidoNet **********************************/
if(!fidoaddr.zone || !cfg.netmail_dir[0]) { // No fido netmail allowed
bputs(text[InvalidNetMailAddr]);
free(qwkbuf);
return;
}
memset(&hdr,0,sizeof(hdr)); /* Initialize header to null */
if(fromhub || useron.rest&FLAG('Q')) {
sprintf(str,"%.25s",block+46); /* From */
truncsp(str);
sprintf(tmp,"@%s",fromhub ? cfg.qhub[fromhub-1]->id : useron.alias);
strupr(tmp);
strcat(str,tmp);
}
else
SAFECOPY(str,cfg.netmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
SAFECOPY(hdr.from,str);
SAFECOPY(hdr.to,to);
/* Look-up in nodelist? */
if(cfg.netmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.netmail_cost) {
bputs(text[NotEnoughCredits]);
free(qwkbuf);
return;
}
sprintf(str,text[NetMailCostContinueQ],cfg.netmail_cost);
if(noyes(str)) {
free(qwkbuf);
return;
}
}
hdr.destzone =fidoaddr.zone;
hdr.destnet =fidoaddr.net;
hdr.destnode =fidoaddr.node;
hdr.destpoint =fidoaddr.point;
for(i=0;i<cfg.total_faddrs;i++)
if(fidoaddr.zone==cfg.faddr[i].zone && fidoaddr.net==cfg.faddr[i].net)
break;
if(i==cfg.total_faddrs) {
for(i=0;i<cfg.total_faddrs;i++)
if(fidoaddr.zone==cfg.faddr[i].zone)
break;
}
if(i==cfg.total_faddrs)
i=0;
hdr.origzone =cfg.faddr[i].zone;
hdr.orignet =cfg.faddr[i].net;
hdr.orignode =cfg.faddr[i].node;
hdr.origpoint =cfg.faddr[i].point;
smb_faddrtoa(&cfg.faddr[i],str);
bprintf(text[NetMailing],hdr.to,smb_faddrtoa(&fidoaddr,tmp),hdr.from,str);
tm.tm_mon=((qwkbuf[8]&0xf)*10)+(qwkbuf[9]&0xf);
if (tm.tm_mon) tm.tm_mon--;
tm.tm_mday=((qwkbuf[11]&0xf)*10)+(qwkbuf[12]&0xf);
tm.tm_year=((qwkbuf[14]&0xf)*10)+(qwkbuf[15]&0xf)+1900;
tm.tm_hour=((qwkbuf[16]&0xf)*10)+(qwkbuf[17]&0xf);
tm.tm_min=((qwkbuf[19]&0xf)*10)+(qwkbuf[20]&0xf); /* From QWK time */
tm.tm_sec=0;
sprintf(hdr.time,"%02u %3.3s %02u %02u:%02u:%02u" /* To FidoNet */
,tm.tm_mday,mon[tm.tm_mon],TM_YEAR(tm.tm_year)
,tm.tm_hour,tm.tm_min,tm.tm_sec);
hdr.attr=(FIDO_LOCAL|FIDO_PRIVATE);
if(cfg.netmail_misc&NMAIL_CRASH) hdr.attr|=FIDO_CRASH;
if(cfg.netmail_misc&NMAIL_HOLD) hdr.attr|=FIDO_HOLD;
if(cfg.netmail_misc&NMAIL_KILL) hdr.attr|=FIDO_KILLSENT;
sprintf(str,"%.25s",block+71); /* Title */
truncsp(str);
p=str;
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"CR:",3)) { /* Crash over-ride by sysop */
p+=3; /* skip CR: */
if(*p==' ') p++; /* skip extra space if it exists */
hdr.attr|=FIDO_CRASH;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FR:",3)) { /* File request */
p+=3; /* skip FR: */
if(*p==' ') p++;
hdr.attr|=FIDO_FREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"RR:",3)) { /* Return receipt request */
p+=3; /* skip RR: */
if(*p==' ') p++;
hdr.attr|=FIDO_RRREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FA:",3)) { /* File attachment */
p+=3; /* skip FA: */
if(*p==' ') p++;
hdr.attr|=FIDO_FILE;
}
SAFECOPY(hdr.subj,p);
md(cfg.netmail_dir);
for(i=1;i;i++) {
sprintf(str,"%s%u.msg", cfg.netmail_dir,i);
if(!fexistcase(str))
break;
}
if(!i) {
bputs(text[TooManyEmailsToday]);
return;
}
if((fido=nopen(str,O_WRONLY|O_CREAT|O_EXCL))==-1) {
free(qwkbuf);
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_EXCL);
return;
}
write(fido,&hdr,sizeof(hdr));
pt_zone_kludge(hdr,fido);
if(cfg.netmail_misc&NMAIL_DIRECT) {
sprintf(str,"\1FLAGS DIR\r\n");
write(fido,str,strlen(str));
}
l=QWK_BLOCK_LEN;
if(into==NULL) { /* If name@addr on first line, skip first line */
while(l<n*QWK_BLOCK_LEN && qwkbuf[l]!=QWK_NEWLINE) l++;
l++;
}
length=n*QWK_BLOCK_LEN;
while(l<length) {
if(qwkbuf[l]==CTRL_A) { /* Ctrl-A, so skip it and the next char */
l++;
if(l>=length || toupper(qwkbuf[l])=='Z') /* EOF */
break;
if((ch=ctrl_a_to_ascii_char(qwkbuf[l])) != 0)
write(fido,&ch,1);
}
else if(qwkbuf[l]!=LF) {
if(qwkbuf[l]==QWK_NEWLINE) /* QWK cr/lf char converted to hard CR */
qwkbuf[l]=CR;
write(fido,(char *)qwkbuf+l,1);
}
l++;
}
l=0;
write(fido,&l,1); /* Null terminator */
close(fido);
free((char *)qwkbuf);
if(cfg.netmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.netmail_sem,nulstr,nulstr,NULL));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.netmail_cost);
useron.emails++;
logon_emails++;
putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10));
useron.etoday++;
putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
sprintf(str,"%s sent NetMail to %s @%s via QWK"
,useron.alias
,hdr.to,smb_faddrtoa(&fidoaddr,tmp));
logline("EN",str);
}
bool sbbs_t::netmail(const char *into, const char *title, long mode)
{
char str[256],subj[128],to[256],fname[128],*buf,*p,ch;
char tmp[512];
int file,fido,x,cc_found,cc_sent;
uint i;
long length,l;
faddr_t addr;
fmsghdr_t hdr;
struct tm tm;
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP && !(useron.exempt&FLAG('M'))) {
bputs(text[TooManyEmailsToday]);
return(false);
}
SAFECOPY(subj,title);
strcpy(to,into);
lookup_netuser(to);
p=strrchr(to,'@'); /* Find '@' in name@addr */
if(p && !isdigit(*(p+1)) && !strchr(p,'.') && !strchr(p,':')) {
mode&=~WM_FILE;
qnetmail(to,title,mode|WM_NETMAIL);
return(false);
}
if(!cfg.total_faddrs || p==NULL || !strchr(p+1,'/')) {
if(!p && cfg.dflt_faddr.zone)
addr=cfg.dflt_faddr;
else if(cfg.inetmail_misc&NMAIL_ALLOW) {
if(mode&WM_FILE && !SYSOP && !(cfg.inetmail_misc&NMAIL_FILE))
mode&=~WM_FILE;
return(inetmail(into,title,mode|WM_NETMAIL));
}
else if(cfg.dflt_faddr.zone)
addr=cfg.dflt_faddr;
else {
bputs(text[InvalidNetMailAddr]);
return(false);
}
} else {
addr=atofaddr(&cfg,p+1); /* Get fido address */
*p=0; /* Chop off address */
}
if(mode&WM_FILE && !SYSOP && !(cfg.netmail_misc&NMAIL_FILE))
mode&=~WM_FILE;
if((!SYSOP && !(cfg.netmail_misc&NMAIL_ALLOW)) || useron.rest&FLAG('M')
|| !cfg.total_faddrs) {
bputs(text[NoNetMailAllowed]);
return(false);
}
truncsp(to); /* Truncate off space */
memset(&hdr,0,sizeof(hdr)); /* Initialize header to null */
strcpy(hdr.from,cfg.netmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
SAFECOPY(hdr.to,to);
/* Look-up in nodelist? */
if(cfg.netmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.netmail_cost) {
bputs(text[NotEnoughCredits]);
return(false);
}
sprintf(str,text[NetMailCostContinueQ],cfg.netmail_cost);
if(noyes(str))
return(false);
}
now=time(NULL);
if(localtime_r(&now,&tm)!=NULL)
sprintf(hdr.time,"%02u %3.3s %02u %02u:%02u:%02u"
,tm.tm_mday,mon[tm.tm_mon],TM_YEAR(tm.tm_year)
,tm.tm_hour,tm.tm_min,tm.tm_sec);
hdr.destzone =addr.zone;
hdr.destnet =addr.net;
hdr.destnode =addr.node;
hdr.destpoint =addr.point;
for(i=0;i<cfg.total_faddrs;i++)
if(addr.zone==cfg.faddr[i].zone && addr.net==cfg.faddr[i].net)
break;
if(i==cfg.total_faddrs) {
for(i=0;i<cfg.total_faddrs;i++)
if(addr.zone==cfg.faddr[i].zone)
break;
}
if(i==cfg.total_faddrs)
i=0;
hdr.origzone =cfg.faddr[i].zone;
hdr.orignet =cfg.faddr[i].net;
hdr.orignode =cfg.faddr[i].node;
hdr.origpoint =cfg.faddr[i].point;
smb_faddrtoa(&cfg.faddr[i],str);
bprintf(text[NetMailing],hdr.to,smb_faddrtoa(&addr,tmp),hdr.from,str);
hdr.attr=(FIDO_LOCAL|FIDO_PRIVATE);
if(cfg.netmail_misc&NMAIL_CRASH) hdr.attr|=FIDO_CRASH;
if(cfg.netmail_misc&NMAIL_HOLD) hdr.attr|=FIDO_HOLD;
if(cfg.netmail_misc&NMAIL_KILL) hdr.attr|=FIDO_KILLSENT;
if(mode&WM_FILE) hdr.attr|=FIDO_FILE;
sprintf(str,"%sNETMAIL.MSG", cfg.node_dir);
remove(str); /* Just incase it's already there */
// mode&=~WM_FILE;
if(!writemsg(str,nulstr,subj,WM_NETMAIL|mode,INVALID_SUB,into)) {
bputs(text[Aborted]);
return(false);
}
if(mode&WM_FILE) {
strcpy(fname,subj);
sprintf(str,"%sfile/%04u.out", cfg.data_dir, useron.number);
MKDIR(str);
strcpy(tmp, cfg.data_dir);
if(tmp[0]=='.') /* Relative path */
sprintf(tmp,"%s%s", cfg.node_dir, cfg.data_dir);
sprintf(str,"%sfile/%04u.out/%s",tmp,useron.number,fname);
strcpy(subj,str);
if(fexistcase(str)) {
bputs(text[FileAlreadyThere]);
return(false);
}
{ /* Remote */
xfer_prot_menu(XFER_UPLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str,"Q");
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && chk_ar(cfg.prot[x]->ar,&useron,&client)) {
sprintf(tmp,"%c",cfg.prot[x]->mnemonic);
strcat(str,tmp);
}
ch=(char)getkeys(str,0);
if(ch=='Q' || sys_status&SS_ABORT) {
bputs(text[Aborted]);
return(false);
}
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && cfg.prot[x]->mnemonic==ch
&& chk_ar(cfg.prot[x]->ar,&useron,&client))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,subj,nulstr,true);
}
sprintf(tmp,"%s%s",cfg.temp_dir,title);
if(!fexistcase(subj) && fexistcase(tmp))
mv(tmp,subj,0);
l=(long)flength(subj);
if(l>0)
bprintf(text[FileNBytesReceived],fname,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],fname);
return(false);
}
}
p=subj;
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"CR:",3)) { /* Crash over-ride by sysop */
p+=3; /* skip CR: */
if(*p==' ') p++; /* skip extra space if it exists */
hdr.attr|=FIDO_CRASH;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FR:",3)) { /* File request */
p+=3; /* skip FR: */
if(*p==' ') p++;
hdr.attr|=FIDO_FREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"RR:",3)) { /* Return receipt request */
p+=3; /* skip RR: */
if(*p==' ') p++;
hdr.attr|=FIDO_RRREQ;
}
if((SYSOP || useron.exempt&FLAG('F'))
&& !strnicmp(p,"FA:",3)) { /* File Attachment */
p+=3; /* skip FA: */
if(*p==' ') p++;
hdr.attr|=FIDO_FILE;
}
SAFECOPY(hdr.subj,p);
sprintf(str,"%sNETMAIL.MSG", cfg.node_dir);
if((file=nopen(str,O_RDONLY))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
return(false);
}
length=(long)filelength(file);
if((buf=(char *)malloc(length))==NULL) {
close(file);
errormsg(WHERE,ERR_ALLOC,str,length);
return(false);
}
read(file,buf,length);
close(file);
md(cfg.netmail_dir);
cc_sent=0;
while(1) {
for(i=1;i;i++) {
sprintf(str,"%s%u.msg", cfg.netmail_dir,i);
if(!fexistcase(str))
break;
}
if(!i) {
bputs(text[TooManyEmailsToday]);
return(false);
}
if((fido=nopen(str,O_WRONLY|O_CREAT|O_EXCL))==-1) {
errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_EXCL);
return(false);
}
write(fido,&hdr,sizeof(hdr));
pt_zone_kludge(hdr,fido);
if(cfg.netmail_misc&NMAIL_DIRECT) {
SAFECOPY(str,"\1FLAGS DIR\r\n");
write(fido,str,strlen(str));
}
if(mode&WM_FILE) {
SAFECOPY(str,"\1FLAGS KFS\r\n");
write(fido,str,strlen(str));
}
if(cc_sent) {
SAFEPRINTF(str,"* Originally to: %s\r\n\r\n",into);
write(fido,str,strlen(str));
}
l=0L;
while(l<length) {
if(buf[l]==CTRL_A) { /* Ctrl-A, so skip it and the next char */
l++;
if(l>=length || toupper(buf[l])=='Z') /* EOF */
break;
if((ch=ctrl_a_to_ascii_char(buf[l])) != 0)
write(fido,&ch,1);
}
else if(buf[l]!=LF) {
if((uchar)buf[l]==0x8d) /* r0dent i converted to normal i */
buf[l]='i';
write(fido,buf+l,1);
}
l++;
}
l=0;
write(fido,&l,1); /* Null terminator */
close(fido);
useron.emails++;
logon_emails++;
putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10));
useron.etoday++;
putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.netmail_cost);
if(mode&WM_FILE)
sprintf(str,"%s sent NetMail file attachment to %s (%s)"
,useron.alias
,hdr.to,smb_faddrtoa(&addr,tmp));
else
sprintf(str,"%s sent NetMail to %s (%s)"
,useron.alias
,hdr.to,smb_faddrtoa(&addr,tmp));
logline("EN",str);
cc_found=0;
for(l=0;l<length && cc_found<=cc_sent;l++)
if(l+3<length && !strnicmp(buf+l,"CC:",3)) {
cc_found++;
l+=2;
}
else {
while(l<length && *(buf+l)!=LF)
l++;
}
if(!cc_found)
break;
while(l<length && *(buf+l)==' ') l++;
for(i=0;l<length && *(buf+l)!=LF && i<128;i++,l++)
str[i]=buf[l];
if(!i)
break;
str[i]=0;
p=strrchr(str,'@');
if(p) {
addr=atofaddr(&cfg,p+1);
*p=0;
SAFECOPY(hdr.to,str);
}
else {
atofaddr(&cfg,str);
strcpy(hdr.to,"Sysop");
}
hdr.destzone =addr.zone;
hdr.destnet =addr.net;
hdr.destnode =addr.node;
hdr.destpoint =addr.point;
cc_sent++;
}
if(cfg.netmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.netmail_sem,nulstr,nulstr,NULL));
free(buf);
return(true);
}
bool sbbs_t::email(int usernumber, const char *top, const char *subj, long mode)
{
char str[256],str2[256],msgpath[256],title[LEN_TITLE+1],ch
,buf[SDT_BLOCK_LEN];
char tmp[512];
char pid[128];
char* editor=NULL;
ushort msgattr=0;
uint16_t xlat=XLAT_NONE;
ushort nettype;
int i,j,x,file;
long l;
long length;
ulong offset;
uint32_t crc=0xffffffffUL;
FILE* instream;
node_t node;
smbmsg_t msg;
SAFECOPY(title,subj);
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP && !(useron.exempt&FLAG('M'))) {
bputs(text[TooManyEmailsToday]);
return(false);
}
if(usernumber==1 && useron.rest&FLAG('S')
&& (cfg.node_valuser!=1 || useron.fbacks || useron.emails)) { /* ! val fback */
bprintf(text[R_Feedback],cfg.sys_op);
return(false);
}
if(usernumber!=1 && useron.rest&FLAG('E')
&& (cfg.node_valuser!=usernumber || useron.fbacks || useron.emails)) {
bputs(text[R_Email]);
return(false);
}
if(!usernumber) {
bputs(text[UnknownUser]);
return(false);
}
getuserrec(&cfg,usernumber,U_MISC,8,str);
l=ahtoul(str);
if(l&(DELETED|INACTIVE)) { /* Deleted or Inactive User */
bputs(text[UnknownUser]);
return(false);
}
if((l&NETMAIL) && (cfg.sys_misc&SM_FWDTONET)) {
getuserrec(&cfg,usernumber,U_NETMAIL,LEN_NETMAIL,str);
bprintf(text[UserNetMail],str);
if((mode & WM_FORCEFWD) || text[ForwardMailQ][0]==0 || yesno(text[ForwardMailQ])) /* Forward to netmail address */
return(netmail(str,subj,mode));
}
bprintf(text[Emailing],username(&cfg,usernumber,tmp),usernumber);
action=NODE_SMAL;
nodesync();
sprintf(str,"%sfeedback.*", cfg.exec_dir);
if(usernumber==cfg.node_valuser && useron.fbacks && fexist(str)) {
exec_bin("feedback",&main_csi);
if(main_csi.logic!=LOGIC_TRUE)
return(false);
}
if(cfg.sys_misc&SM_ANON_EM && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ]))
msgattr|=MSG_ANONYMOUS;
if(cfg.sys_misc&SM_DELREADM)
msgattr|=MSG_KILLREAD;
msg_tmp_fname(useron.xedit, msgpath, sizeof(msgpath));
username(&cfg,usernumber,str2);
if(!writemsg(msgpath,top,title,mode,INVALID_SUB,str2,&editor)) {
bputs(text[Aborted]);
return(false);
}
if(mode&WM_FILE && !SYSOP && !(cfg.sys_misc&SM_FILE_EM))
mode&=~WM_FILE;
if(mode&WM_FILE) {
sprintf(str2,"%sfile/%04u.in", cfg.data_dir,usernumber);
MKDIR(str2);
sprintf(str2,"%sfile/%04u.in/%s", cfg.data_dir,usernumber,title);
if(fexistcase(str2)) {
bputs(text[FileAlreadyThere]);
remove(msgpath);
return(false);
}
{ /* Remote */
xfer_prot_menu(XFER_UPLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str,"Q");
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && chk_ar(cfg.prot[x]->ar,&useron,&client)) {
sprintf(tmp,"%c",cfg.prot[x]->mnemonic);
strcat(str,tmp);
}
ch=(char)getkeys(str,0);
if(ch=='Q' || sys_status&SS_ABORT) {
bputs(text[Aborted]);
remove(msgpath);
return(false);
}
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && cfg.prot[x]->mnemonic==ch
&& chk_ar(cfg.prot[x]->ar,&useron,&client))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,str2,nulstr,true);
}
safe_snprintf(tmp,sizeof(tmp),"%s%s",cfg.temp_dir,title);
if(!fexistcase(str2) && fexistcase(tmp))
mv(tmp,str2,0);
l=(long)flength(str2);
if(l>0)
bprintf(text[FileNBytesReceived],title,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],title);
remove(msgpath);
return(false);
}
}
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
return(false);
}
sprintf(smb.file,"%smail", cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(smb_fgetlength(smb.shd_fp)<1) { /* Create it if it doesn't exist */
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_age=cfg.mail_maxage;
smb.status.max_msgs=0;
smb.status.attr=SMB_EMAIL;
if((i=smb_create(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i,smb.last_error);
return(false);
}
}
if((i=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(false);
}
length=(long)flength(msgpath)+2; /* +2 for translation string */
if(length&0xfff00000UL) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LEN,msgpath,length);
return(false);
}
if((i=smb_open_da(&smb))!=0) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
if((instream=fnopen(&file,msgpath,O_RDONLY|O_BINARY))==NULL) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY|O_BINARY);
return(false);
}
setvbuf(instream,NULL,_IOFBF,2*1024);
smb_fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
smb_fwrite(&smb,&xlat,2,smb.sdt_fp);
x=SDT_BLOCK_LEN-2; /* Don't read/write more than 255 */
while(!feof(instream)) {
memset(buf,0,x);
j=fread(buf,1,x,instream);
if(j<1)
break;
if(j>1 && (j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
buf[j-1]=buf[j-2]=0;
if(cfg.mail_maxcrcs) {
for(i=0;i<j;i++)
crc=ucrc32(buf[i],crc);
}
smb_fwrite(&smb,buf,j,smb.sdt_fp);
x=SDT_BLOCK_LEN;
}
smb_fflush(smb.sdt_fp);
fclose(instream);
crc=~crc;
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
msg.hdr.attr=msgattr;
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time32(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
if(cfg.mail_maxcrcs) {
i=smb_addcrc(&smb,crc);
if(i) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
attr(cfg.color[clr_err]);
bputs(text[CantPostMsg]);
return(false);
}
}
msg.hdr.offset=offset;
username(&cfg,usernumber,str);
smb_hfield_str(&msg,RECIPIENT,str);
sprintf(str,"%u",usernumber);
smb_hfield_str(&msg,RECIPIENTEXT,str);
SAFECOPY(str,useron.alias);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
if(useron.misc&NETMAIL) {
if(useron.rest&FLAG('G'))
smb_hfield_str(&msg,REPLYTO,useron.name);
nettype=smb_netaddr_type(useron.netmail);
if(nettype!=NET_NONE && nettype!=NET_UNKNOWN) {
smb_hfield(&msg,REPLYTONETTYPE,sizeof(nettype),&nettype);
smb_hfield_str(&msg,REPLYTONETADDR,useron.netmail);
}
}
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SENDERSERVER,startup->host_name);
smb_hfield_str(&msg,SUBJECT,title);
/* Generate FidoNet Program Identifier */
smb_hfield_str(&msg,FIDOPID,msg_program_id(pid));
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK); // calls smb_unlocksmbhdr()
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
smb_freemsgdat(&smb,offset,length,1);
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
return(false);
}
if(usernumber==1)
logon_fbacks++;
else
logon_emails++;
user_sent_email(&cfg, &useron, 1, usernumber==1);
bprintf(text[Emailed],username(&cfg,usernumber,tmp),usernumber);
safe_snprintf(str,sizeof(str),"%s sent e-mail to %s #%d"
,useron.alias,username(&cfg,usernumber,tmp),usernumber);
logline("E+",str);
if(mode&WM_FILE && online==ON_REMOTE)
autohangup();
if(msgattr&MSG_ANONYMOUS) /* Don't tell user if anonymous */
return(true);
for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
getnodedat(i,&node,0);
if(node.useron==usernumber && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
safe_snprintf(str,sizeof(str),text[EmailNodeMsg],cfg.node_num,useron.alias);
putnmsg(&cfg,i,str);
break;
}
}
if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
safe_snprintf(str,sizeof(str),text[UserSentYouMail],useron.alias);
putsmsg(&cfg,usernumber,str);
}
return(true);
}
bool sbbs_t::inetmail(char *into, char *subj, long mode)
{
char str[256],str2[256],msgpath[256],title[256],name[256],ch
,buf[SDT_BLOCK_LEN],*p,addr[256];
char tmp[512];
char your_addr[128];
ushort xlat=XLAT_NONE,net=NET_INTERNET;
int i,j,x,file;
long l;
ulong length,offset;
FILE *instream;
smbmsg_t msg;
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP) {
bputs(text[TooManyEmailsToday]);
return(false);
}
strcpy(name,into);
strcpy(addr,into);
strcpy(title,subj);
if((!SYSOP && !(cfg.inetmail_misc&NMAIL_ALLOW)) || useron.rest&FLAG('M')) {
bputs(text[NoNetMailAllowed]);
return(false); }
if(cfg.inetmail_cost && !(useron.exempt&FLAG('S'))) {
if(useron.cdt+useron.freecdt<cfg.inetmail_cost) {
bputs(text[NotEnoughCredits]);
return(false); }
sprintf(str,text[NetMailCostContinueQ],cfg.inetmail_cost);
if(noyes(str))
return(false); }
/* Get destination user name */
p=strrchr(name,'@');
if(!p)
p=strrchr(name,'!');
if(p) {
*p=0;
truncsp(name); }
/* Get this user's internet mailing address */
usermailaddr(&cfg,your_addr
,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
bprintf(text[InternetMailing],addr,your_addr);
action=NODE_SMAL;
nodesync();
sprintf(msgpath,"%snetmail.msg",cfg.node_dir);
if(!writemsg(msgpath,nulstr,title,mode,INVALID_SUB,into)) {
bputs(text[Aborted]);
return(false); }
if(mode&WM_FILE) {
sprintf(str2,"%sfile/%04u.out",cfg.data_dir,useron.number);
MKDIR(str2);
sprintf(str2,"%sfile/%04u.out/%s",cfg.data_dir,useron.number,title);
if(fexistcase(str2)) {
bputs(text[FileAlreadyThere]);
remove(msgpath);
return(false); }
#if 0 /* no such thing as local logon */
if(online==ON_LOCAL) { /* Local upload */
bputs(text[EnterPath]);
if(!getstr(str,60,K_LINE|K_UPPER)) {
bputs(text[Aborted]);
remove(msgpath);
return(false); }
backslash(str);
strcat(str,title);
mv(str,str2,1); }
else
#endif
{ /* Remote */
xfer_prot_menu(XFER_UPLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str,"Q");
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && chk_ar(cfg.prot[x]->ar,&useron)) {
sprintf(tmp,"%c",cfg.prot[x]->mnemonic);
strcat(str,tmp); }
ch=(char)getkeys(str,0);
if(ch=='Q' || sys_status&SS_ABORT) {
bputs(text[Aborted]);
remove(msgpath);
return(false); }
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && cfg.prot[x]->mnemonic==ch
&& chk_ar(cfg.prot[x]->ar,&useron))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,str2,nulstr,true);
}
sprintf(tmp,"%s%s",cfg.temp_dir,title);
if(!fexistcase(str2) && fexistcase(tmp))
mv(tmp,str2,0);
l=flength(str2);
if(l>0)
bprintf(text[FileNBytesReceived],title,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],title);
remove(msgpath);
return(false); } }
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
return(false); }
sprintf(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=SMB_SUCCESS) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false); }
if(filelength(fileno(smb.shd_fp))<1) { /* Create it if it doesn't exist */
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_age=cfg.mail_maxage;
smb.status.max_msgs=0;
smb.status.attr=SMB_EMAIL;
if((i=smb_create(&smb))!=SMB_SUCCESS) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i);
return(false); } }
if((i=smb_locksmbhdr(&smb))!=SMB_SUCCESS) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i);
return(false); }
length=flength(msgpath)+2; /* +2 for translation string */
if(length&0xfff00000UL) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LEN,msgpath,length);
return(false); }
if((i=smb_open_da(&smb))!=SMB_SUCCESS) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false); }
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
if((file=open(msgpath,O_RDONLY|O_BINARY))==-1
|| (instream=fdopen(file,"rb"))==NULL) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY|O_BINARY);
return(false); }
setvbuf(instream,NULL,_IOFBF,2*1024);
fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
fwrite(&xlat,2,1,smb.sdt_fp);
x=SDT_BLOCK_LEN-2; /* Don't read/write more than 255 */
while(!feof(instream)) {
memset(buf,0,x);
j=fread(buf,1,x,instream);
if(j<1)
break;
if(j>1 && (j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
buf[j-1]=buf[j-2]=0;
fwrite(buf,j,1,smb.sdt_fp);
x=SDT_BLOCK_LEN; }
fflush(smb.sdt_fp);
fclose(instream);
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
msg.hdr.offset=offset;
net=NET_INTERNET;
smb_hfield_str(&msg,RECIPIENT,name);
smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(net),&net);
smb_hfield_str(&msg,RECIPIENTNETADDR,addr);
strcpy(str,cfg.inetmail_misc&NMAIL_ALIAS ? useron.alias : useron.name);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
/*
smb_hfield(&msg,SENDERNETTYPE,sizeof(net),&net);
smb_hfield(&msg,SENDERNETADDR,strlen(sys_inetaddr),sys_inetaddr);
*/
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SUBJECT,title);
strcpy(str,title);
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK); // calls smb_unlocksmbhdr()
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
smb_freemsgdat(&smb,offset,length,1);
return(false);
}
if(mode&WM_FILE && online==ON_REMOTE)
autohangup();
if(cfg.inetmail_sem[0]) /* update semaphore file */
ftouch(cmdstr(cfg.inetmail_sem,nulstr,nulstr,NULL));
if(!(useron.exempt&FLAG('S')))
subtract_cdt(&cfg,&useron,cfg.inetmail_cost);
useron.emails++;
logon_emails++;
putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10));
useron.etoday++;
putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
sprintf(str,"%s sent Internet Mail to %s (%s)"
,useron.alias
,name,addr);
logline("EN",str);
return(true);
}
bool sbbs_t::bulkmail(uchar *ar)
{
char str[256],title[LEN_TITLE+1];
char msgpath[MAX_PATH+1];
char* msgbuf;
char* editor=NULL;
char tmp[512];
int i,j,x;
long msgs=0;
long length;
FILE* fp;
smb_t smb;
smbmsg_t msg;
user_t user;
memset(&msg,0,sizeof(msg));
title[0]=0;
action=NODE_SMAL;
nodesync();
if(cfg.sys_misc&SM_ANON_EM && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ]))
msg.hdr.attr|=MSG_ANONYMOUS;
msg_tmp_fname(useron.xedit, msgpath, sizeof(msgpath));
if(!writemsg(msgpath,nulstr,title,WM_EMAIL,INVALID_SUB,"Bulk Mailing",&editor)) {
bputs(text[Aborted]);
return(false);
}
if((fp=fopen(msgpath,"r"))==NULL) {
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY);
return(false);
}
if((length=(long)filelength(fileno(fp)))<=0) {
fclose(fp);
return(false);
}
bputs(text[WritingIndx]);
CRLF;
if((msgbuf=(char*)malloc(length+1))==NULL) {
errormsg(WHERE,ERR_ALLOC,msgpath,length+1);
return(false);
}
length=fread(msgbuf,sizeof(char),length,fp);
fclose(fp);
if(length<0) {
free(msgbuf);
errormsg(WHERE,ERR_READ,msgpath,length);
return(false);
}
msgbuf[length]=0; /* ASCIIZ */
smb_hfield_str(&msg,SENDER,useron.alias);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
smb_hfield_str(&msg,SUBJECT,title);
msg.hdr.when_written.time=time32(NULL);
msg.hdr.when_written.zone=sys_timezone(&cfg);
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
memset(&smb,0,sizeof(smb));
smb.subnum=INVALID_SUB; /* mail database */
i=savemsg(&cfg, &smb, &msg, &client, startup->host_name, msgbuf);
free(msgbuf);
if(i!=0) {
smb_close(&smb);
smb_freemsgmem(&msg);
return(false);
}
j=lastuser(&cfg);
if(*ar)
for(i=1;i<=j;i++) {
user.number=i;
if(getuserdat(&cfg, &user)!=0)
continue;
if(user.misc&(DELETED|INACTIVE))
continue;
if(chk_ar(ar,&user,/* client: */NULL)) {
if((x=bulkmailhdr(&smb, &msg, i))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,x);
break;
}
msgs++;
}
}
else
while(online) {
bputs(text[EnterAfterLastDestUser]);
if(!getstr(str,LEN_ALIAS,cfg.uq&UQ_NOUPRLWR ? K_NONE:K_UPRLWR))
break;
if((i=finduser(str))!=0) {
if((x=bulkmailhdr(&smb, &msg, i))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_WRITE,smb.file,x);
break;
}
msgs++;
}
}
if((i=smb_open_da(&smb))==SMB_SUCCESS) {
if(!msgs)
smb_freemsg_dfields(&smb,&msg,SMB_ALL_REFS);
else if(msgs>1)
smb_incmsg_dfields(&smb,&msg,(ushort)msgs-1);
smb_close_da(&smb);
}
smb_close(&smb);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10));
putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
return(true);
}
/* TODO this is one of the worst ever functions written. void *data ? wtf */
void cb_question(alpm_question_t event, void *data1, void *data2,
void *data3, int *response)
{
if(config->print) {
if(event == ALPM_QUESTION_INSTALL_IGNOREPKG) {
*response = 1;
} else {
*response = 0;
}
return;
}
switch(event) {
case ALPM_QUESTION_INSTALL_IGNOREPKG:
if(!config->op_s_downloadonly) {
*response = yesno(_("%s is in IgnorePkg/IgnoreGroup. Install anyway?"),
alpm_pkg_get_name(data1));
} else {
*response = 1;
}
break;
case ALPM_QUESTION_REPLACE_PKG:
*response = yesno(_("Replace %s with %s/%s?"),
alpm_pkg_get_name(data1),
(char *)data3,
alpm_pkg_get_name(data2));
break;
case ALPM_QUESTION_CONFLICT_PKG:
/* data parameters: target package, local package, conflict (strings) */
/* print conflict only if it contains new information */
if(strcmp(data1, data3) == 0 || strcmp(data2, data3) == 0) {
*response = noyes(_("%s and %s are in conflict. Remove %s?"),
(char *)data1,
(char *)data2,
(char *)data2);
} else {
*response = noyes(_("%s and %s are in conflict (%s). Remove %s?"),
(char *)data1,
(char *)data2,
(char *)data3,
(char *)data2);
}
break;
case ALPM_QUESTION_REMOVE_PKGS:
{
alpm_list_t *unresolved = data1;
alpm_list_t *namelist = NULL, *i;
size_t count = 0;
for(i = unresolved; i; i = i->next) {
namelist = alpm_list_add(namelist,
(char *)alpm_pkg_get_name(i->data));
count++;
}
colon_printf(_n(
"The following package cannot be upgraded due to unresolvable dependencies:\n",
"The following packages cannot be upgraded due to unresolvable dependencies:\n",
count));
list_display(" ", namelist, getcols(fileno(stdout)));
printf("\n");
*response = noyes(_n(
"Do you want to skip the above package for this upgrade?",
"Do you want to skip the above packages for this upgrade?",
count));
alpm_list_free(namelist);
}
break;
case ALPM_QUESTION_SELECT_PROVIDER:
{
alpm_list_t *providers = data1;
size_t count = alpm_list_count(providers);
char *depstring = alpm_dep_compute_string((alpm_depend_t *)data2);
colon_printf(_("There are %zd providers available for %s:\n"), count,
depstring);
free(depstring);
select_display(providers);
*response = select_question(count);
}
break;
case ALPM_QUESTION_CORRUPTED_PKG:
*response = yesno(_("File %s is corrupted (%s).\n"
"Do you want to delete it?"),
(char *)data1,
alpm_strerror(*(alpm_errno_t *)data2));
break;
case ALPM_QUESTION_IMPORT_KEY:
{
alpm_pgpkey_t *key = data1;
char created[12];
time_t time = (time_t)key->created;
strftime(created, 12, "%Y-%m-%d", localtime(&time));
if(key->revoked) {
*response = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s (revoked)?"),
key->length, key->pubkey_algo, key->fingerprint, key->uid, created);
} else {
*response = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s?"),
key->length, key->pubkey_algo, key->fingerprint, key->uid, created);
}
}
break;
}
if(config->noask) {
if(config->ask & event) {
/* inverse the default answer */
*response = !*response;
}
}
}