readmsgs.cpp

/* Synchronet public message reading function */

/****************************************************************************
 * @format.tab-size 4		(Plain Text/Source Code File Header)			*
 * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
 *																			*
 * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
 *																			*
 * This program is free software; you can redistribute it and/or			*
 * modify it under the terms of the GNU General Public License				*
 * as published by the Free Software Foundation; either version 2			*
 * of the License, or (at your option) any later version.					*
 * See the GNU General Public License for more details: gpl.txt or			*
 * http://www.fsf.org/copyleft/gpl.html										*
 *																			*
 * For Synchronet coding style and modification guidelines, see				*
 * http://www.synchro.net/source.html										*
 *																			*
 * Note: If this box doesn't appear square, then you need to fix your tabs.	*
 ****************************************************************************/

#include "sbbs.h"

int sbbs_t::sub_op(uint subnum)
{
	return(is_user_subop(&cfg, subnum, &useron, &client));
}

uchar sbbs_t::msg_listing_flag(uint subnum, smbmsg_t* msg, post_t* post)
{
	if(msg->hdr.attr&MSG_DELETE)						return '-';
	if((stricmp(msg->to,useron.alias)==0 || stricmp(msg->to,useron.name)==0)
		&& !(msg->hdr.attr&MSG_READ))					return '!';
	if(msg->hdr.attr&MSG_PERMANENT)						return 'p';
	if(msg->hdr.attr&MSG_LOCKED)						return 'L';
	if(msg->hdr.attr&MSG_KILLREAD)						return 'K';
	if(msg->hdr.attr&MSG_NOREPLY)						return '#';
	if(msg->hdr.number > subscan[subnum].ptr)			return '*';
	if(msg->hdr.attr&MSG_PRIVATE)						return 'P';
	if(msg->hdr.attr&MSG_POLL)							return '?'; 
	if(post->upvotes > post->downvotes)					return 251;
	if(post->upvotes || post->downvotes)				return 'v';
	if(msg->hdr.attr&MSG_REPLIED)						return 'R';
	if(sub_op(subnum) && msg->hdr.attr&MSG_ANONYMOUS)	return 'A';
	return ' ';
}

long sbbs_t::listmsgs(uint subnum, long mode, post_t *post, long start, long posts, bool reading)
{
	smbmsg_t msg;
	long listed=0;

	for(long i = start; i<posts && !msgabort(); i++) {
		if(mode&SCAN_NEW && post[i].idx.number<=subscan[subnum].ptr)
			continue;
		msg.idx.offset=post[i].idx.offset;
		if(loadmsg(&msg,post[i].idx.number) < 0)
			break;
		smb_unlockmsghdr(&smb,&msg);
		if(listed==0)
			bputs(text[MailOnSystemLstHdr]);
		bprintf(P_TRUNCATE|(msg.hdr.auxattr&MSG_HFIELDS_UTF8)
			,msghdr_text(&msg, SubMsgLstFmt), reading ? (i+1) : post[i].num
			,msg.hdr.attr&MSG_ANONYMOUS && !sub_op(subnum)
			? text[Anonymous] : msg.from
			,msg.to
			,msg_listing_flag(subnum, &msg, &post[i])
			,msg.subj);
		smb_freemsgmem(&msg);
		msg.total_hfields=0;
		listed++;
	}

	return(listed);
}

void sbbs_t::dump_msghdr(smbmsg_t* msg)
{
	newline();
	str_list_t list = smb_msghdr_str_list(msg);
	if(list != NULL) {
		for(int i = 0; list[i] != NULL && !msgabort(); i++) {
			bprintf("%s\r\n", list[i]);
		}
		strListFree(&list);
	}
}

/****************************************************************************/
/* posts is the actual number of posts returned in the allocated array		*/
/* visible is the number of visible posts to the user (not all included in	*/
/* returned array)															*/
/****************************************************************************/
post_t * sbbs_t::loadposts(uint32_t *posts, uint subnum, ulong ptr, long mode, ulong *unvalidated_num, uint32_t* visible)
{
	ushort aliascrc,namecrc,sysop;
	int i,skip;
	ulong l=0,total,alloc_len;
	uint32_t	curmsg=0;
	smbmsg_t	msg;
	idxrec_t	idx;
	post_t *	post;

	if(posts==NULL)
		return(NULL);

	(*posts)=0;

	if((i=smb_locksmbhdr(&smb))!=0) {				/* Be sure noone deletes or */
		errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);		/* adds while we're reading */
		return(NULL); 
	}

	total=(long)filelength(fileno(smb.sid_fp))/sizeof(idxrec_t); /* total msgs in sub */

	if(!total) {			/* empty */
		smb_unlocksmbhdr(&smb);
		return(NULL); 
	}

	namecrc=smb_name_crc(useron.name);
	aliascrc=smb_name_crc(useron.alias);
	sysop=crc16("sysop",0);

	rewind(smb.sid_fp);

	alloc_len=sizeof(post_t)*total;
	if((post=(post_t *)malloc(alloc_len))==NULL) {	/* alloc for max */
		smb_unlocksmbhdr(&smb);
		errormsg(WHERE,ERR_ALLOC,smb.file,alloc_len);
		return(NULL); 
	}
	memset(post, 0, alloc_len);

	if(unvalidated_num)
		*unvalidated_num=ULONG_MAX;

	while(!feof(smb.sid_fp)) {
		skip=0;
		if(smb_fread(&smb, &idx,sizeof(idx),smb.sid_fp) != sizeof(idx))
			break;

		if(idx.number==0)	/* invalid message number, ignore */
			continue;

		if(mode&LP_NOMSGS && (idx.attr&MSG_POLL_VOTE_MASK) == 0)
			continue;

		if(idx.attr&MSG_DELETE) {		/* Pre-flagged */
			if(mode&LP_REP) 			/* Don't include deleted msgs in REP pkt */
				continue;
			if(!(cfg.sys_misc&SM_SYSVDELM)) /* Noone can view deleted msgs */
				continue;
			if(!(cfg.sys_misc&SM_USRVDELM)	/* Users can't view deleted msgs */
				&& !sub_op(subnum)) 	/* not sub-op */
				continue;
			if(!sub_op(subnum)			/* not sub-op */
				&& idx.from!=namecrc && idx.from!=aliascrc) /* not for you */
				continue; 
		}

		if(idx.attr&MSG_MODERATED && !(idx.attr&MSG_VALIDATED)) {
			if(mode&LP_REP || !sub_op(subnum))
				break;
		}
		
		switch(idx.attr&MSG_POLL_VOTE_MASK) {
		case MSG_VOTE:
		case MSG_UPVOTE:
		case MSG_DOWNVOTE:
		{
			ulong u;
			for(u = 0; u < l; u++)
				if(post[u].idx.number == idx.remsg)
					break;
			if(u < l) {
				post[u].total_votes++;
				switch(idx.attr&MSG_VOTE) {
				case MSG_UPVOTE:
					post[u].upvotes++;
					break;
				case MSG_DOWNVOTE:
					post[u].downvotes++;
					break;
				default:
					for(int b=0; b < MSG_POLL_MAX_ANSWERS; b++) {
						if(idx.votes&(1<<b))
							post[u].votes[b]++;
					}
				}
			}
			if(!(mode&LP_VOTES))
				continue;
			break;
		}
		case MSG_POLL:
			if(!(mode&LP_POLLS))
				continue;
			break;
		case MSG_POLL_CLOSURE:
			if(!(mode&LP_VOTES))
				continue;
			break;
		}

		if(idx.attr&MSG_PRIVATE && !(mode&LP_PRIVATE)
			&& !sub_op(subnum) && !(useron.rest&FLAG('Q'))) {
			if(idx.to!=namecrc && idx.from!=namecrc
				&& idx.to!=aliascrc && idx.from!=aliascrc
				&& (useron.number!=1 || idx.to!=sysop))
				continue;
			msg.idx=idx;
			if(!smb_lockmsghdr(&smb,&msg)) {
				if(!smb_getmsghdr(&smb,&msg)) {
					if(stricmp(msg.to,useron.alias)
						&& stricmp(msg.from,useron.alias)
						&& stricmp(msg.to,useron.name)
						&& stricmp(msg.from,useron.name)
						&& (useron.number!=1 || stricmp(msg.to,"sysop")
						|| msg.from_net.type))
						skip=1;
					smb_freemsgmem(&msg); 
				}
				smb_unlockmsghdr(&smb,&msg); 
			}
			if(skip)
				continue; 
		}

		curmsg++;

		if(idx.number<=ptr)
			continue;

		if(idx.attr&MSG_READ && mode&LP_UNREAD) /* Skip read messages */
			continue;

		if(!(mode&LP_BYSELF) && (idx.from==namecrc || idx.from==aliascrc)) {
			msg.idx=idx;
			if(!smb_lockmsghdr(&smb,&msg)) {
				if(!smb_getmsghdr(&smb,&msg)) {
					if(!stricmp(msg.from,useron.alias)
						|| !stricmp(msg.from,useron.name))
						skip=1;
					smb_freemsgmem(&msg); 
				}
				smb_unlockmsghdr(&smb,&msg); 
			}
			if(skip)
				continue; 
		}

		if(!(mode&LP_OTHERS)) {
			if(idx.to!=namecrc && idx.to!=aliascrc
				&& (useron.number!=1 || idx.to!=sysop))
				continue;
			msg.idx=idx;
			if(!smb_lockmsghdr(&smb,&msg)) {
				if(!smb_getmsghdr(&smb,&msg)) {
					if(stricmp(msg.to,useron.alias) && stricmp(msg.to,useron.name)
						&& (useron.number!=1 || stricmp(msg.to,"sysop")
						|| msg.from_net.type))
						skip=1;
					smb_freemsgmem(&msg); 
				}
				smb_unlockmsghdr(&smb,&msg); 
			}
			if(skip)
				continue; 
		}

		if(idx.attr&MSG_MODERATED && !(idx.attr&MSG_VALIDATED)) {
			if(unvalidated_num && *unvalidated_num > l)
				*unvalidated_num=l;
		}

		memcpy(&post[l].idx,&idx,sizeof(idx));
		post[l].num = curmsg;
		l++;
	}
	smb_unlocksmbhdr(&smb);
	if(!l)
		FREE_AND_NULL(post);

	if(visible!=NULL)	/* Total number of currently visible/readable messages to the user */
		*visible=curmsg;
	(*posts)=l;
	return(post);
}

int64_t sbbs_t::get_start_msgnum(smb_t* smb, int next)
{
	uint32_t	j=smb->curmsg + next;
	int64_t		i;

	if(j<smb->msgs)
		j++;
	else
		j=1;
	bprintf(text[StartWithN],j);
	if((i = getnum(smb->msgs)) < 0)
		return(i);
	if(i==0)
		return(j-1);
	return(i-1);
}

static int score_post(post_t* post)
{
	if((post->idx.attr&MSG_POLL_VOTE_MASK) == MSG_POLL)
		return 0;
	return (post->upvotes*2) + ((post->idx.attr&MSG_REPLIED) ? 1:0) - (post->downvotes*2);
}

static int rank_post(const void* a1, const void* a2)
{
	post_t* p1 = (post_t*)a1;
	post_t* p2 = (post_t*)a2;
	int diff = score_post(p2) - score_post(p1);
	if(diff == 0)
		return p2->idx.time - p1->idx.time;
	return diff;
}

static int find_post(smb_t* smb, uint32_t msgnum, post_t* post)
{
	uint32_t i;

	/* ToDo: optimize search */
	for(i=0; i<smb->msgs; i++)
		if(post[i].idx.number == msgnum)
			return i;
	return -1;
}

void sbbs_t::show_thread(uint32_t msgnum, post_t* post, unsigned curmsg, int thread_depth, uint64_t reply_mask)
{
	char date[32];
	smbmsg_t msg;

	int i = find_post(&smb, msgnum, post);
	if(i < 0)
		return;

	memset(&msg, 0, sizeof(msg));
	msg.idx = post[i].idx;
	if(smb_getmsghdr(&smb, &msg) != SMB_SUCCESS)
		return;
	attr(LIGHTGRAY);
	if(thread_depth) {
		for(int j=0; j < thread_depth; j++)
			bprintf("%*s%c", j > 10 ? 0 : j > 5 ? 1 : 2, ""
			,j+1 == thread_depth ? msg.hdr.thread_next ? 195 : 192 : (reply_mask&(1LL<<j)) ? 179 : ' ');
	}
	if((unsigned)i == curmsg)
		attr(HIGH);
	bprintf("\1c%u\1g%c "
		,post[i].num
//		,msg.hdr.number
		,(unsigned)i == curmsg ? '>' : ':');
	bprintf("\1w%-*.*s\1g%c\1g%c \1w%s\r\n"
		,(int)(cols-column-12)
		,(int)(cols-column-12)
		,msg.hdr.attr&MSG_ANONYMOUS && !sub_op(smb.subnum)
			? text[Anonymous] : msghdr_field(&msg, msg.from)
		,(unsigned)i == curmsg ? '<' : ' '
		,msg_listing_flag(smb.subnum, &msg, &post[i])
		,unixtodstr(&cfg, msg.hdr.when_written.time, date));

	if(thread_depth) {
		if(msg.hdr.thread_first)
			reply_mask |= (1LL<<(thread_depth-1));
		else
			reply_mask &= ~(1LL<<(thread_depth-1));
	}
	if(thread_depth && !msg.hdr.thread_next)
		reply_mask &= ~(1LL<<(thread_depth-1));
	if(msg.hdr.thread_first)
		show_thread(msg.hdr.thread_first, post, curmsg, thread_depth+1, reply_mask);
	if(msg.hdr.thread_next)
		show_thread(msg.hdr.thread_next, post, curmsg, thread_depth, reply_mask);
	smb_freemsgmem(&msg);
}

/****************************************************************************/
/* Reads posts on subboard sub. 'mode' determines new-posts only, browse,   */
/* or continuous read.                                                      */
/* Returns 0 if normal completion, 1 if aborted.                            */
/* Called from function main_sec                                            */
/****************************************************************************/
int sbbs_t::scanposts(uint subnum, long mode, const char *find)
{
	char	str[256],str2[256],do_find=true,mismatches=0
			,done=0,domsg=1,*buf;
	char	find_buf[128];
	char	tmp[128];
	int		i;
	int64_t	i64;
	int		quit=0;
	uint 	usub,ugrp,reads=0;
	uint	lp = LP_BYSELF;
	long	org_mode=mode;
	ulong	msgs,l,unvalidated;
	uint32_t last;
	uint32_t u;
	post_t	*post;
	smbmsg_t	msg;
	bool	thread_mode = false;

	action=NODE_RMSG;
	cursubnum=subnum;	/* for ARS */
	if(cfg.scanposts_mod[0] && !scanposts_inside) {
		char cmdline[256];

		scanposts_inside = true;
		safe_snprintf(cmdline, sizeof(cmdline), "%s %s %ld %s", cfg.scanposts_mod, cfg.sub[subnum]->code, mode, find);
		i=exec_bin(cmdline, &main_csi);
		scanposts_inside = false;
		return i;
	}
	find_buf[0]=0;
	if(!chk_ar(cfg.sub[subnum]->read_ar,&useron,&client)) {
		bprintf(text[CantReadSub]
				,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->sname);
		return(0); 
	}
	ZERO_VAR(msg);				/* init to NULL, specify not-allocated */
	if(!(mode&SCAN_CONST))
		lncntr=0;
	if((msgs=getlastmsg(subnum,&last,0))==0) {
		if(mode&(SCAN_NEW|SCAN_TOYOU))
			bprintf(text[NScanStatusFmt]
				,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname,0L,0L);
		else if(!(mode&SCAN_POLLS))
			bprintf(text[NoMsgsOnSub]
				,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->sname);
		return(0); 
	}
	if(mode&SCAN_NEW && subscan[subnum].ptr>=last && !(mode&SCAN_BACK)) {
		if(subscan[subnum].ptr>last)
			subscan[subnum].ptr=last;
		if(subscan[subnum].last>last)
			subscan[subnum].last=last;
		bprintf(text[NScanStatusFmt]
			,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname,0L,msgs);
		return(0); 
	}

	if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
		errormsg(WHERE,ERR_OPEN,cfg.sub[subnum]->code,i);
		return(0); 
	}
	SAFEPRINTF2(smb.file,"%s%s",cfg.sub[subnum]->data_dir,cfg.sub[subnum]->code);
	smb.retry_time=cfg.smb_retry_time;
	smb.subnum=subnum;
	if((i=smb_open(&smb))!=0) {
		errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
		smb_stack(&smb,SMB_STACK_POP);
		return(0); 
	}
	usub = getusrsub(subnum);
	ugrp = getusrgrp(subnum);

	if(!(mode&SCAN_TOYOU)
		&& (!mode || mode&SCAN_FIND || !(subscan[subnum].cfg&SUB_CFG_YSCAN)))
		lp|=LP_OTHERS;
	if(mode&SCAN_TOYOU && mode&SCAN_UNREAD)
		lp|=LP_UNREAD;
	if(!(cfg.sub[subnum]->misc&SUB_NOVOTING))
		lp|=LP_POLLS;
	if(mode&SCAN_POLLS)
		lp|=LP_NOMSGS;
	post=loadposts(&smb.msgs,subnum,0,lp,&unvalidated);
	if(mode&SCAN_NEW) { 		  /* Scanning for new messages */
		for(smb.curmsg=0;smb.curmsg<smb.msgs;smb.curmsg++)
			if(subscan[subnum].ptr<post[smb.curmsg].idx.number)
				break;
		lncntr = 0;
		bprintf(text[NScanStatusFmt]
			,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname,smb.msgs-smb.curmsg,msgs);
		if(!smb.msgs) {		  /* no messages at all */
			smb_close(&smb);
			smb_stack(&smb,SMB_STACK_POP);
			return(0); 
		}
		if(smb.curmsg==smb.msgs) {  /* no new messages */
			if(!(mode&SCAN_BACK)) {
				if(post)
					free(post);
				smb_close(&smb);
				smb_stack(&smb,SMB_STACK_POP);
				return(0); 
			}
			smb.curmsg=smb.msgs-1; 
		} 
	}
	else {
		cleartoeol();
		lncntr = 0;
		if(mode&SCAN_TOYOU)
			bprintf(text[NScanStatusFmt]
			   ,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname,smb.msgs,msgs);
		if(!smb.msgs) {
			if(!(mode&(SCAN_TOYOU|SCAN_POLLS)))
				bprintf(text[NoMsgsOnSub]
					,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->sname);
			smb_close(&smb);
			smb_stack(&smb,SMB_STACK_POP);
			return(0); 
		}
		if(mode&SCAN_FIND) {
			bprintf(text[SearchSubFmt]
				,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->lname,smb.msgs);
			domsg=1;
			smb.curmsg=0; 
		}
		else if(mode&(SCAN_TOYOU|SCAN_POLLS))
			smb.curmsg=0;
		else {
			for(smb.curmsg=0;smb.curmsg<smb.msgs;smb.curmsg++)
				if(post[smb.curmsg].idx.number>=subscan[subnum].last)
					break;
			if(smb.curmsg==smb.msgs)
				smb.curmsg=smb.msgs-1;

			domsg=1; 
		} 
	}

	if(useron.misc&RIP)
		menu("msgscan");

	if((i=smb_locksmbhdr(&smb))!=0) {
		smb_close(&smb);
		errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
		smb_stack(&smb,SMB_STACK_POP);
		return(0); 
	}
	if((i=smb_getstatus(&smb))!=0) {
		smb_close(&smb);
		errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
		smb_stack(&smb,SMB_STACK_POP);
		return(0); 
	}
	smb_unlocksmbhdr(&smb);
	last=smb.status.last_msg;

	if(mode&SCAN_CONST) {   /* update action */
		getnodedat(cfg.node_num,&thisnode,1);
		thisnode.action=NODE_RMSG;
		putnodedat(cfg.node_num,&thisnode); 
	}
	current_msg=&msg;	/* For MSG_* @-codes and bbs.msg_* property values */
	while(online && !done) {

		action=NODE_RMSG;

		if(mode&(SCAN_CONST|SCAN_FIND) && sys_status&SS_ABORT)
			break;

		if(post==NULL)	/* Been unloaded */
			post=loadposts(&smb.msgs,subnum,0,lp,&unvalidated);   /* So re-load */

		if(!smb.msgs) {
			done=1;
			continue; 
		}

		while(smb.curmsg>=smb.msgs) smb.curmsg--;

		msg.idx=post[smb.curmsg].idx;

		if((i=smb_locksmbhdr(&smb))!=0) {
			errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
			break; 
		}
		if((i=smb_getstatus(&smb))!=0) {
			smb_unlocksmbhdr(&smb);
			errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
			break; 
		}
		smb_unlocksmbhdr(&smb);

		if(smb.status.last_msg!=last) { 	/* New messages */
			last=smb.status.last_msg;
			if(post) {
				free((void *)post); 
			}
			post=loadposts(&smb.msgs,subnum,0,lp,&unvalidated);   /* So re-load */
			if(!smb.msgs)
				break;
			for(smb.curmsg=0;smb.curmsg<smb.msgs;smb.curmsg++)
				if(post[smb.curmsg].idx.number==msg.idx.number)
					break;
			if(smb.curmsg>(smb.msgs-1))
				smb.curmsg=(smb.msgs-1);
			continue; 
		}

		if(msg.total_hfields)
			smb_freemsgmem(&msg);
		msg.total_hfields=0;

		if(loadmsg(&msg,post[smb.curmsg].idx.number) < 0) {
			if(mismatches>5) {	/* We can't do this too many times in a row */
				errormsg(WHERE,ERR_CHK,smb.file,post[smb.curmsg].idx.number);
				break; 
			}
			if(post)
				free(post);
			post=loadposts(&smb.msgs,subnum,0,lp,&unvalidated);
			if(!smb.msgs)
				break;
			if(smb.curmsg>(smb.msgs-1))
				smb.curmsg=(smb.msgs-1);
			mismatches++;
			continue; 
		}
		smb_unlockmsghdr(&smb,&msg);

		mismatches=0;

		if(thread_mode) {
			uint32_t first = smb_first_in_thread(&smb, &msg, NULL);
			if(first <= 0) {
				bputs(text[NoMessagesFound]);
				break;
			}
			bprintf("\1n\1l\1h\1bThread\1n\1b: \1h\1c");
			bprintf("%-.*s\r\n", (int)(cols-(column+1)), msghdr_field(&msg, msg.subj));
			show_thread(first, post, smb.curmsg);
			subscan[subnum].last = post[smb.curmsg].idx.number;
		}
		else if(domsg && !(sys_status&SS_ABORT)) {

			if(do_find && mode&SCAN_FIND) { 			/* Find text in messages */
				buf=smb_getmsgtxt(&smb,&msg,GETMSGTXT_ALL);
				if(!buf) {
					if(smb.curmsg<smb.msgs-1) 
						smb.curmsg++;
					else if(org_mode&SCAN_FIND)  
						done=1;
					else if(smb.curmsg>=smb.msgs-1)
							domsg=0;
					continue; 
				}
				if(strcasestr(buf,find) == NULL && strcasestr(msg.subj, find) == NULL
					&& (msg.tags == NULL || strcasestr(msg.tags, find) == NULL)) {
					free(buf);
					if(smb.curmsg<smb.msgs-1) 
						smb.curmsg++;
					else if(org_mode&SCAN_FIND) 
							done=1;
					else if(smb.curmsg>=smb.msgs-1)
							domsg=0;
					continue; 
				}
				free(buf); 
			}

			if(mode&SCAN_CONST)
				bprintf(text[ZScanPostHdr],ugrp,usub,smb.curmsg+1,smb.msgs);

			if(!reads && mode)
				CRLF;

			msg.upvotes = post[smb.curmsg].upvotes;
			msg.downvotes = post[smb.curmsg].downvotes;
			msg.total_votes = post[smb.curmsg].total_votes;
			show_msg(&smb, &msg
				,msg.from_ext && !strcmp(msg.from_ext,"1") && !msg.from_net.type
					? 0:P_NOATCODES
				,&post[smb.curmsg]);

			reads++;	/* number of messages actually read during this sub-scan */

			/* Message is to this user and hasn't been read, so flag as read */
			if((!stricmp(msg.to,useron.name) || !stricmp(msg.to,useron.alias)
				|| (useron.number==1 && !stricmp(msg.to,"sysop")
				&& !msg.from_net.type))
				&& !(msg.hdr.attr&MSG_READ)) {
				if(msg.total_hfields)
					smb_freemsgmem(&msg);
				msg.total_hfields=0;
				msg.idx.offset=0;
				if(!smb_locksmbhdr(&smb)) { 			  /* Lock the entire base */
					if(loadmsg(&msg,msg.idx.number) >= 0) {
						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.last_error);
						smb_unlockmsghdr(&smb,&msg); 
					}
					smb_unlocksmbhdr(&smb); 
				}
				if(!msg.total_hfields) {				/* unsuccessful reload */
					domsg=0;
					continue; 
				} 
			}

			subscan[subnum].last=post[smb.curmsg].idx.number;

			if(subscan[subnum].ptr<post[smb.curmsg].idx.number && !(mode&SCAN_TOYOU)) {
				posts_read++;
				subscan[subnum].ptr=post[smb.curmsg].idx.number; 
			} 

			if(sub_op(subnum) && (msg.hdr.attr&(MSG_MODERATED|MSG_VALIDATED)) == MSG_MODERATED) {
				uint16_t msg_attr = msg.hdr.attr;
				SAFEPRINTF2(str,text[ValidatePostQ],smb.curmsg+1,msghdr_field(&msg, msg.subj));
				if(!noyes(str))
					msg_attr|=MSG_VALIDATED;
				else {
					SAFEPRINTF2(str,text[DeletePostQ],smb.curmsg+1,msghdr_field(&msg, msg.subj));
					if(yesno(str))
						msg_attr|=MSG_DELETE;
				}
				if(msg_attr!=msg.hdr.attr) {
					if(msg.total_hfields)
						smb_freemsgmem(&msg);
					msg.total_hfields=0;
					msg.idx.offset=0;
					if(!smb_locksmbhdr(&smb)) { 			  /* Lock the entire base */
						if(loadmsg(&msg,msg.idx.number) >= 0) {
							msg.hdr.attr=msg.idx.attr=msg_attr;
							if((i=smb_putmsg(&smb,&msg))!=0)
								errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
							smb_unlockmsghdr(&smb,&msg); 
						}
						smb_unlocksmbhdr(&smb); 
					}
					if(msg_attr & MSG_DELETE) {
						if(cfg.sys_misc&SM_SYSVDELM)
							domsg=0;	// If you can view deleted messages, don't redisplay.
					}
					else {
						domsg=0;		// If you just validated, don't redisplay.
					}
					if(post)
						free(post);
					post=loadposts(&smb.msgs,subnum,0,lp,&unvalidated);
					if(!smb.msgs)
						break;
					if(smb.curmsg>(smb.msgs-1))
						smb.curmsg=(smb.msgs-1);
					mismatches++;
					continue; 
				}
			}
		}
		else domsg=1;
		if(mode&SCAN_CONST) {
			if(smb.curmsg<smb.msgs-1) smb.curmsg++;
				else done=1;
			continue; 
		}
		if(useron.misc&WIP)
			menu("msgscan");
		ASYNC;
		if(unvalidated < smb.curmsg)
			bprintf(text[UnvalidatedWarning],unvalidated+1);
		if(lncntr >= rows-2)
			lncntr--;
		bprintf(text[ReadingSub],ugrp,cfg.grp[cfg.sub[subnum]->grp]->sname
			,usub,cfg.sub[subnum]->sname,smb.curmsg+1,smb.msgs);
		sprintf(str,"ABCDEFHILMNPQRTUVY?*<>[]{}-+()\b%c%c%c%c"
			,TERM_KEY_LEFT
			,TERM_KEY_RIGHT
			,TERM_KEY_HOME
			,TERM_KEY_END
			);
		if(thread_mode)
			sprintf(str+strlen(str),"%c%c"
				,TERM_KEY_UP
				,TERM_KEY_DOWN);

		if(sub_op(subnum))
			strcat(str,"O");
		do_find=true;
		l=getkeys(str,smb.msgs);
		if(l&0x80000000L) {
			if((long)l==-1) { /* ctrl-c */
				quit=1;
				break; 
			}
			smb.curmsg=(l&~0x80000000L)-1;
			do_find = false;
			thread_mode = false;
			domsg = true;
			continue; 
		}
		if(thread_mode && (IS_ALPHA(l) || l=='?')) {
			thread_mode = false;
			domsg = true;
		}
		switch(l) {
			case '*':
				thread_mode = !thread_mode;
				if(!thread_mode)
					domsg = true;
				continue;
			case 'A':   
			case 'R':   
				if((char)l==(cfg.sys_misc&SM_RA_EMU ? 'A' : 'R')) { 
					do_find=false;	/* re-read last message */
					break;
				}
				/* Reply to last message */
				domsg=0;
				if(!chk_ar(cfg.sub[subnum]->post_ar,&useron,&client)) {
					bputs(text[CantPostOnSub]);
					break; 
				}
				if(msg.hdr.attr&MSG_NOREPLY && !sub_op(subnum)) {
					bputs(text[CantReplyToMsg]);
					break; 
				}
				FREE_AND_NULL(post);