-
Rob Swindell authoreduncrustify nl_split_if_one_liner setting
Rob Swindell authoreduncrustify nl_split_if_one_liner setting
getmsg.cpp 22.62 KiB
/* Synchronet message retrieval functions */
/****************************************************************************
* @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. *
****************************************************************************/
/***********************************************************************/
/* Functions that do i/o with messages (posts/mail/auto) or their data */
/***********************************************************************/
#include "sbbs.h"
#include "utf8.h"
/****************************************************************************/
/* Loads an SMB message from the open msg base the fastest way possible */
/* first by offset, and if that's the wrong message, then by number. */
/* Returns >=0 if the message was loaded and left locked, otherwise < 0. */
/* !WARNING!: If you're going to write the msg index back to disk, you must */
/* Call this function with a msg->idx.offset of 0 (so msg->offset will be */
/* initialized correctly) */
/****************************************************************************/
int sbbs_t::loadmsg(smbmsg_t *msg, uint number)
{
char str[128];
int i;
if (msg->idx.offset) { /* Load by offset if specified */
if ((i = smb_lockmsghdr(&smb, msg)) != SMB_SUCCESS) {
errormsg(WHERE, ERR_LOCK, smb.file, i, smb.last_error);
return i;
}
i = smb_getmsghdr(&smb, msg);
if (i == SMB_SUCCESS) {
if (msg->hdr.number == number)
return msg->total_hfields;
/* Wrong offset */
smb_freemsgmem(msg);
}
smb_unlockmsghdr(&smb, msg);
}
msg->hdr.number = number;
if ((i = smb_getmsgidx(&smb, msg)) != SMB_SUCCESS) /* Message is deleted */
return i;
if ((i = smb_lockmsghdr(&smb, msg)) != SMB_SUCCESS) {
errormsg(WHERE, ERR_LOCK, smb.file, i, smb.last_error);
return i;
}
if ((i = smb_getmsghdr(&smb, msg)) != SMB_SUCCESS) {
SAFEPRINTF4(str, "(%06" PRIX32 ") #%" PRIu32 "/%u %s", msg->idx.offset, msg->idx.number
, number, smb.file);
smb_unlockmsghdr(&smb, msg); errormsg(WHERE, ERR_READ, str, i, smb.last_error);
return i;
}
return msg->total_hfields;
}
/* Synchronized with atcode()! */
void sbbs_t::show_msgattr(const smbmsg_t* msg)
{
uint16_t attr = msg->hdr.attr;
uint16_t poll = attr & MSG_POLL_VOTE_MASK;
uint32_t auxattr = msg->hdr.auxattr;
uint32_t netattr = msg->hdr.netattr;
char attr_str[64];
safe_snprintf(attr_str, sizeof(attr_str), "%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
, attr & MSG_PRIVATE ? "Private " :nulstr
, attr & MSG_SPAM ? "SPAM " :nulstr
, attr & MSG_READ ? "Read " :nulstr
, attr & MSG_DELETE ? "Deleted " :nulstr
, attr & MSG_KILLREAD ? "Kill " :nulstr
, attr & MSG_ANONYMOUS ? "Anonymous " :nulstr
, attr & MSG_LOCKED ? "Locked " :nulstr
, attr & MSG_PERMANENT ? "Permanent " :nulstr
, attr & MSG_MODERATED ? "Moderated " :nulstr
, attr & MSG_VALIDATED ? "Validated " :nulstr
, attr & MSG_REPLIED ? "Replied " :nulstr
, attr & MSG_NOREPLY ? "NoReply " :nulstr
, poll == MSG_POLL ? "Poll " :nulstr
, poll == MSG_POLL && auxattr & POLL_CLOSED ? "(Closed) " :nulstr
);
char auxattr_str[64];
safe_snprintf(auxattr_str, sizeof(auxattr_str), "%s%s%s%s%s%s%s"
, auxattr & MSG_FILEREQUEST? "FileRequest " :nulstr
, auxattr & MSG_FILEATTACH ? "FileAttach " :nulstr
, auxattr & MSG_MIMEATTACH ? "MimeAttach " :nulstr
, auxattr & MSG_KILLFILE ? "KillFile " :nulstr
, auxattr & MSG_RECEIPTREQ ? "ReceiptReq " :nulstr
, auxattr & MSG_CONFIRMREQ ? "ConfirmReq " :nulstr
, auxattr & MSG_NODISP ? "DontDisplay " :nulstr
);
char netattr_str[64];
safe_snprintf(netattr_str, sizeof(netattr_str), "%s%s%s%s%s%s%s%s"
, netattr & NETMSG_LOCAL ? "Local " :nulstr
, netattr & NETMSG_INTRANSIT ? "InTransit " :nulstr
, netattr & NETMSG_SENT ? "Sent " :nulstr
, netattr & NETMSG_KILLSENT ? "KillSent " :nulstr
, netattr & NETMSG_HOLD ? "Hold " :nulstr
, netattr & NETMSG_CRASH ? "Crash " :nulstr
, netattr & NETMSG_IMMEDIATE ? "Immediate " :nulstr
, netattr & NETMSG_DIRECT ? "Direct " :nulstr
);
bprintf(text[MsgAttr], attr_str, auxattr_str, netattr_str
, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr
, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr
, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr, nulstr);
}
/* Returns a CP437 text.dat string converted to UTF-8, when appropriate */
const char* sbbs_t::msghdr_text(const smbmsg_t* msg, uint index)
{
if (msg == NULL || !(msg->hdr.auxattr & MSG_HFIELDS_UTF8))
return text[index];
if (cp437_to_utf8_str(text[index], msghdr_utf8_text, sizeof(msghdr_utf8_text), /* min-char-val: */ '\x80') < 1)
return text[index];
return msghdr_utf8_text;
}
// Returns a CP437 version of a message header field or UTF-8 if can_utf8 is true
// Doesn't do CP437->UTF-8 conversion
const char* sbbs_t::msghdr_field(const smbmsg_t* msg, const char* str, char* buf, bool can_utf8)
{
if (msg == NULL || !(msg->hdr.auxattr & MSG_HFIELDS_UTF8))
return str;
if (can_utf8)
return str;
if (buf == NULL)
buf = msgghdr_field_cp437_str;
strncpy(buf, str, sizeof(msgghdr_field_cp437_str) - 1);
utf8_to_cp437_inplace(buf);
return buf;
}
/****************************************************************************/
/* Displays a message header to the screen */
/****************************************************************************/
void sbbs_t::show_msghdr(smb_t* smb, const smbmsg_t* msg, const char* subject, const char* from, const char* to)
{
char str[MAX_PATH + 1];
char age[64];
char *sender = NULL;
int i;
smb_t saved_smb = this->smb;
int pmode = 0;
if (smb != NULL)
this->smb = *smb; // Needed for @-codes and JS bbs.smb_* properties
current_msg = msg; // Needed for @-codes and JS bbs.msg_* properties
current_msg_subj = msg->subj;
current_msg_from = msg->from;
current_msg_to = msg->to;
if (msg->hdr.auxattr & MSG_HFIELDS_UTF8)
pmode |= P_UTF8;
if (subject != NULL)
current_msg_subj = subject;
if (from != NULL)
current_msg_from = from;
if (to != NULL)
current_msg_to = to;
attr(LIGHTGRAY);
if (row != 0) {
if (useron.misc & CLRSCRN)
outchar(FF);
else
CRLF;
}
msghdr_tos = (row == 0);
if (!menu("msghdr", P_NOERROR)) {
bprintf(pmode, msghdr_text(msg, MsgSubj), current_msg_subj);
if (msg->tags && *msg->tags)
bprintf(text[MsgTags], msg->tags);
if (msg->hdr.attr || msg->hdr.netattr || (msg->hdr.auxattr & ~MSG_HFIELDS_UTF8))
show_msgattr(msg);
if (current_msg_to != NULL && *current_msg_to != 0) {
bprintf(pmode, msghdr_text(msg, MsgTo), current_msg_to);
if (msg->to_net.addr != NULL)
bprintf(text[MsgToNet], smb_netaddrstr(&msg->to_net, str));
if (msg->to_ext)
bprintf(text[MsgToExt], msg->to_ext); }
if (msg->cc_list != NULL)
bprintf(text[MsgCarbonCopyList], msg->cc_list);
if (current_msg_from != NULL && (!(msg->hdr.attr & MSG_ANONYMOUS) || SYSOP)) {
bprintf(pmode, msghdr_text(msg, MsgFrom), current_msg_from);
if (msg->from_ext)
bprintf(text[MsgFromExt], msg->from_ext);
if (msg->from_net.addr != NULL)
bprintf(text[MsgFromNet], smb_netaddrstr(&msg->from_net, str));
}
if (!(msg->hdr.attr & MSG_POLL) && (msg->upvotes || msg->downvotes))
bprintf(text[MsgVotes]
, msg->upvotes, msg->user_voted == 1 ? text[PollAnswerChecked] : nulstr
, msg->downvotes, msg->user_voted == 2 ? text[PollAnswerChecked] : nulstr
, msg->upvotes - msg->downvotes);
time_t t = smb_time(msg->hdr.when_written);
bprintf(text[MsgDate]
, timestr(t)
, smb_zonestr(msg->hdr.when_written.zone, NULL)
, age_of_posted_item(age, sizeof(age), t - (smb_tzutc(msg->hdr.when_written.zone) * 60)));
bputs(text[MsgHdrBodySeparator]);
}
for (i = 0; i < msg->total_hfields; i++) {
if (msg->hfield[i].type == SENDER)
sender = (char *)msg->hfield_dat[i];
if (msg->hfield[i].type == FORWARDED && sender)
bprintf(text[ForwardedFrom], sender
, timestr(*(time32_t *)msg->hfield_dat[i]));
}
this->smb = saved_smb;
current_msg_subj = NULL;
current_msg_from = NULL;
current_msg_to = NULL;
}
/****************************************************************************/
/* Displays message header and text (if not deleted) */
/****************************************************************************/
bool sbbs_t::show_msg(smb_t* smb, smbmsg_t* msg, int p_mode, post_t* post)
{
char* txt;
BOOL is_sub = subnum_is_valid(smb->subnum);
if (is_sub) {
if ((msg->hdr.type == SMB_MSG_TYPE_NORMAL && post != NULL && (post->upvotes || post->downvotes))
|| msg->hdr.type == SMB_MSG_TYPE_POLL)
msg->user_voted = smb_voted_already(smb, msg->hdr.number
, cfg.sub[smb->subnum]->misc & SUB_NAME ? useron.name : useron.alias, NET_NONE, NULL);
}
show_msghdr(smb, msg);
int comments = 0;
for (int i = 0; i < msg->total_hfields; i++)
if (msg->hfield[i].type == SMB_COMMENT) {
bprintf("%s\r\n", (char*)msg->hfield_dat[i]);
comments++;
}
if (comments)
CRLF;
if (msg->hdr.type == SMB_MSG_TYPE_POLL && post != NULL && is_sub) {
char* answer;
int longest_answer = 0;
for (int i = 0; i < msg->total_hfields; i++) {
if (msg->hfield[i].type != SMB_POLL_ANSWER)
continue;
answer = (char*)msg->hfield_dat[i];
int len = strlen(answer);
if (len > longest_answer) longest_answer = len;
}
unsigned answers = 0;
for (int i = 0; i < msg->total_hfields; i++) {
if (msg->hfield[i].type != SMB_POLL_ANSWER)
continue;
answer = (char*)msg->hfield_dat[i];
float pct = post->total_votes ? ((float)post->votes[answers] / post->total_votes) * 100.0F : 0.0F;
char str[128];
int width = longest_answer;
if (width < cols / 3)
width = cols / 3;
else if (width > cols - 20)
width = cols - 20;
bprintf(text[PollAnswerNumber], answers + 1);
bool results_visible = false;
if ((msg->hdr.auxattr & POLL_RESULTS_MASK) == POLL_RESULTS_OPEN)
results_visible = true;
else if ((msg->from_net.type == NET_NONE && sub_op(smb->subnum))
|| smb_msg_is_from(msg, cfg.sub[smb->subnum]->misc & SUB_NAME ? useron.name : useron.alias, NET_NONE, NULL))
results_visible = true;
else if ((msg->hdr.auxattr & POLL_RESULTS_MASK) == POLL_RESULTS_CLOSED)
results_visible = (msg->hdr.auxattr & POLL_CLOSED) ? true : false;
else if ((msg->hdr.auxattr & POLL_RESULTS_MASK) != POLL_RESULTS_SECRET)
results_visible = msg->user_voted ? true : false;
if (results_visible) {
safe_snprintf(str, sizeof(str), text[PollAnswerFmt]
, width, width, answer, post->votes[answers], pct);
backfill(str, pct, cfg.color[clr_votes_full], cfg.color[clr_votes_empty]);
if (msg->user_voted & (1 << answers))
bputs(text[PollAnswerChecked]);
} else {
attr(cfg.color[clr_votes_empty]);
bputs(answer);
}
CRLF;
answers++;
}
if (!msg->user_voted && !(useron.misc & EXPERT) && !(msg->hdr.auxattr & POLL_CLOSED) && !(useron.rest & FLAG('V')))
mnemonics(text[VoteInThisPollNow]);
return true;
}
if ((txt = smb_getmsgtxt(smb, msg, GETMSGTXT_BODY_ONLY)) == NULL)
return false;
char* p = txt;
if (!(console & CON_RAW_IN)) {
if (strstr(txt, "\x1b[") == NULL) // Don't word-wrap raw ANSI text
p_mode |= P_WORDWRAP;
p = smb_getplaintext(msg, txt);
if (p == NULL)
p = txt;
else if (*p != '\0')
bprintf(text[MIMEDecodedPlainTextFmt]
, msg->text_charset == NULL ? "unspecified (US-ASCII)" : msg->text_charset
, msg->text_subtype == NULL ? "plain" : msg->text_subtype);
}
truncsp(p);
SKIP_CRLF(p);
if (smb_msg_is_utf8(msg)) {
if (!term_supports(UTF8))
utf8_normalize_str(txt);
p_mode |= P_UTF8;
}
if (is_sub) {
p_mode |= cfg.sub[smb->subnum]->pmode;
p_mode &= ~cfg.sub[smb->subnum]->n_pmode;
}
if (console & CON_RAW_IN)
p_mode = P_NOATCODES;
putmsg(p, p_mode, msg->columns); smb_freemsgtxt(txt);
if (column)
CRLF;
if ((txt = smb_getmsgtxt(smb, msg, GETMSGTXT_TAIL_ONLY)) == NULL)
return false;
putmsg(txt, p_mode & (~P_WORDWRAP));
smb_freemsgtxt(txt);
return true;
}
void sbbs_t::download_msg_attachments(smb_t* smb, smbmsg_t* msg, bool del, bool use_default_prot)
{
char str[256];
char keys[128];
char fpath[MAX_PATH + 1];
char* txt;
int attachment_index = 0;
bool found = true;
while (found && (txt = smb_getmsgtxt(smb, msg, 0)) != NULL) {
char filename[MAX_PATH + 1] = {0};
uint32_t filelen = 0;
uint8_t* filedata;
if ((filedata = smb_getattachment(msg, txt, filename, sizeof(filename), &filelen, attachment_index++)) != NULL
&& filename[0] != 0 && filelen > 0) {
char tmp[32];
SAFEPRINTF2(str, text[DownloadAttachedFileQ], filename, ultoac(filelen, tmp));
if (!noyes(str)) {
SAFEPRINTF2(fpath, "%s%s", cfg.temp_dir, filename);
FILE* fp = fopen(fpath, "wb");
if (fp == NULL)
errormsg(WHERE, ERR_OPEN, fpath, 0);
else {
int result = fwrite(filedata, filelen, 1, fp);
fclose(fp);
if (!result)
errormsg(WHERE, ERR_WRITE, fpath, filelen);
else
sendfile(fpath, use_default_prot ? useron.prot : 0, "attachment");
}
}
} else
found = false;
smb_freemsgtxt(txt);
}
if (msg->hdr.auxattr & MSG_FILEATTACH) { /* Attached file */
char subj[FIDO_SUBJ_LEN];
int result = smb_getmsgidx(smb, msg);
if (result != SMB_SUCCESS) {
errormsg(WHERE, ERR_READ, "index", result, smb->last_error);
return;
}
SAFECOPY(subj, msg->subj); /* filenames (multiple?) in title */
char *p, *tp, ch;
tp = subj;
while (online) {
p = strchr(tp, ' ');
if (p)
*p = 0;
tp = getfname(tp);
if (strcspn(tp, ILLEGAL_FILENAME_CHARS) == strlen(tp)) {
SAFEPRINTF3(fpath, "%sfile/%04u.in/%s" /* path is path/fname */
, cfg.data_dir, msg->idx.to, tp);
if (!fexistcase(fpath) && msg->idx.from)
SAFEPRINTF3(fpath, "%sfile/%04u.out/%s" /* path is path/fname */
, cfg.data_dir, msg->idx.from, tp);
off_t length = flength(fpath);
if (length < 1)
bprintf(text[FileDoesNotExist], tp); else if (!(useron.exempt & FLAG('T')) && cur_cps && !SYSOP
&& (ulong)(length / cur_cps) > timeleft)
bputs(text[NotEnoughTimeToDl]);
else {
char tmp[512];
int i;
SAFEPRINTF2(str, text[DownloadAttachedFileQ]
, getfname(fpath), u64toac(length, tmp));
if (length > 0L && text[DownloadAttachedFileQ][0] && yesno(str)) {
{ /* Remote User */
xfer_prot_menu(XFER_DOWNLOAD, &useron, keys, sizeof keys);
SAFECAT(keys, quit_key(str));
mnemonics(text[ProtocolOrQuit]);
ch = (char)getkeys(keys, 0);
i = protnum(ch, XFER_DOWNLOAD);
if (i < cfg.total_prots) {
time_t elapsed = 0;
int error = protocol(cfg.prot[i], XFER_DOWNLOAD, fpath, nulstr, /* cid: */ false, /* autohang: */ true, &elapsed);
if (checkprotresult(cfg.prot[i], error, fpath)) {
if (del)
(void)remove(fpath);
logon_dlb += length; /* Update stats */
logon_dls++;
useron.dls = (ushort)adjustuserval(&cfg, useron.number
, USER_DLS, 1);
useron.dlb = adjustuserval(&cfg, useron.number
, USER_DLB, length);
downloadedbytes(length, elapsed);
bprintf(text[FileNBytesSent]
, getfname(fpath), u64toac(length, tmp));
SAFEPRINTF(str
, "downloaded attached file: %s"
, getfname(fpath));
logline("D-", str);
}
autohangup();
}
}
}
}
}
if (!p)
break;
tp = p + 1;
while (*tp == ' ') tp++;
}
// Remove the *.in directory, only if its empty
SAFEPRINTF2(fpath, "%sfile/%04u.in", cfg.data_dir, msg->idx.to);
rmdir(fpath);
}
}
/****************************************************************************/
/* Writes message header and text data to a text file */
/****************************************************************************/
bool sbbs_t::msgtotxt(smb_t* smb, smbmsg_t* msg, const char *fname, bool header, uint gettxt_mode)
{
char *buf;
char tmp[128];
int i;
FILE *out;
if ((out = fnopen(&i, fname, O_WRONLY | O_CREAT | O_APPEND)) == NULL) {
errormsg(WHERE, ERR_OPEN, fname, 0);
return false;
}
if (header) {
fprintf(out, "\r\n");
fprintf(out, "Subj : %s\r\n", msg->subj);
fprintf(out, "To : %s", msg->to); if (msg->to_net.addr)
fprintf(out, " (%s)", smb_netaddrstr(&msg->to_net, tmp));
if (msg->to_ext)
fprintf(out, " #%s", msg->to_ext);
fprintf(out, "\r\nFrom : %s", msg->from);
if (msg->from_ext && !(msg->hdr.attr & MSG_ANONYMOUS))
fprintf(out, " #%s", msg->from_ext);
if (msg->from_net.addr)
fprintf(out, " (%s)", smb_netaddrstr(&msg->from_net, tmp));
fprintf(out, "\r\nDate : %.24s %s"
, timestr(smb_time(msg->hdr.when_written))
, smb_zonestr(msg->hdr.when_written.zone, NULL));
fprintf(out, "\r\n\r\n");
}
bool result = false;
buf = smb_getmsgtxt(smb, msg, gettxt_mode);
if (buf != NULL) {
strip_invalid_attr(buf);
fputs(buf, out);
smb_freemsgtxt(buf);
result = true;
} else if (smb_getmsgdatlen(msg) > 2)
errormsg(WHERE, ERR_READ, smb->file, smb_getmsgdatlen(msg));
fclose(out);
return result;
}
/****************************************************************************/
/* Returns message number posted at or after time */
/****************************************************************************/
int sbbs_t::getmsgnum(int subnum, time_t t)
{
int i;
smb_t smb;
idxrec_t idx;
if (!t)
return 0;
ZERO_VAR(smb);
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_index(&smb)) != SMB_SUCCESS) {
errormsg(WHERE, ERR_OPEN, smb.file, i, smb.last_error);
return 0;
}
int result = smb_getmsgidx_by_time(&smb, &idx, t);
smb_close(&smb);
if (result >= SMB_SUCCESS)
return idx.number - 1;
return ~0;
}
/****************************************************************************/
/* Returns the time of the message number pointed to by 'ptr' */
/****************************************************************************/
time_t sbbs_t::getmsgtime(int subnum, uint ptr)
{
int i;
smb_t smb;
smbmsg_t msg;
idxrec_t lastidx;
ZERO_VAR(smb);
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);
return 0;
}
if (!filelength(fileno(smb.sid_fp))) { /* Empty base */
smb_close(&smb);
return 0;
}
msg.idx_offset = 0;
msg.hdr.number = 0;
if (smb_getmsgidx(&smb, &msg)) { /* Get first message index */
smb_close(&smb);
return 0;
}
if (!ptr || msg.idx.number >= ptr) { /* ptr is before first message */
smb_close(&smb);
return msg.idx.time; /* so return time of first msg */
}
if (smb_getlastidx(&smb, &lastidx)) { /* Get last message index */
smb_close(&smb);
return 0;
}
if (lastidx.number < ptr) { /* ptr is after last message */
smb_close(&smb);
return lastidx.time; /* so return time of last msg */
}
msg.idx.time = 0;
msg.hdr.number = ptr;
if (!smb_getmsgidx(&smb, &msg)) {
smb_close(&smb);
return msg.idx.time;
}
if (ptr - msg.idx.number < lastidx.number - ptr) {
msg.idx_offset = 0;
msg.idx.number = 0;
while (msg.idx.number < ptr) {
msg.hdr.number = 0;
if (smb_getmsgidx(&smb, &msg) || msg.idx.number >= ptr)
break;
msg.idx_offset++;
}
smb_close(&smb);
return msg.idx.time;
}
ptr--;
while (ptr) {
msg.hdr.number = ptr;
if (!smb_getmsgidx(&smb, &msg))
break;
ptr--;
}
smb_close(&smb);
return msg.idx.time;
}
/****************************************************************************/
/* Returns the total number of msgs in the sub-board and sets 'ptr' to the */
/* number of the last message in the sub (0) if no messages. */
/****************************************************************************/
uint sbbs_t::getlastmsg(int subnum, uint32_t *ptr, time_t *t)
{
int i;
uint total;
smb_t smb;
idxrec_t idx;
if (ptr)
(*ptr) = 0;
if (t)
(*t) = 0;
if (!subnum_is_valid(subnum))
return 0;
ZERO_VAR(smb);
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);
return 0;
}
if (!filelength(fileno(smb.sid_fp))) { /* Empty base */
smb_close(&smb);
return 0;
}
if ((i = smb_locksmbhdr(&smb)) != 0) {
smb_close(&smb);
errormsg(WHERE, ERR_LOCK, smb.file, i, smb.last_error);
return 0;
}
if ((i = smb_getlastidx(&smb, &idx)) != 0) {
smb_close(&smb);
errormsg(WHERE, ERR_READ, smb.file, i, smb.last_error);
return 0;
}
if (cfg.sub[subnum]->misc & SUB_NOVOTING)
total = (int)filelength(fileno(smb.sid_fp)) / sizeof(idxrec_t);
else
total = smb_msg_count(&smb, (1 << SMB_MSG_TYPE_NORMAL) | (1 << SMB_MSG_TYPE_POLL));
smb_unlocksmbhdr(&smb);
smb_close(&smb);
if (ptr)
(*ptr) = idx.number;
if (t)
(*t) = idx.time;
return total;
}