void listmsgs(ulong start, ulong count)
{
int i;
ulong l=0;
smbmsg_t msg;
if(!start)
start=1;
if(!count)
count=~0;
fseek(smb.sid_fp,(start-1L)*sizeof(idxrec_t),SEEK_SET);
while(l<count) {
if(!fread(&msg.idx,1,sizeof(idxrec_t),smb.sid_fp))
break;
i=smb_lockmsghdr(&smb,&msg);
if(i) {
fprintf(errfp,"\n%s!smb_lockmsghdr returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
i=smb_getmsghdr(&smb,&msg);
smb_unlockmsghdr(&smb,&msg);
if(i) {
fprintf(errfp,"\n%s!smb_getmsghdr returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
printf("%4"PRIu32" %-25.25s %-25.25s %s\n"
,msg.hdr.number,msg.from,msg.to,msg.subj);
smb_freemsgmem(&msg);
l++;
}
}
int sbbs_t::loadmsg(smbmsg_t *msg, ulong number)
{
char str[128];
int i;
if(msg->idx.offset) { /* Load by offset if specified */
if((i=smb_lockmsghdr(&smb,msg))!=0) {
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(0);
}
i=smb_getmsghdr(&smb,msg);
if(i==SMB_SUCCESS) {
if(msg->hdr.number==number)
return(1);
/* 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(0);
if((i=smb_lockmsghdr(&smb,msg))!=SMB_SUCCESS) {
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(0);
}
if((i=smb_getmsghdr(&smb,msg))!=SMB_SUCCESS) {
sprintf(str,"(%06"PRIX32") #%"PRIu32"/%lu %s",msg->idx.offset,msg->idx.number
,number,smb.file);
smb_unlockmsghdr(&smb,msg);
errormsg(WHERE,ERR_READ,str,i,smb.last_error);
return(0);
}
return(msg->total_hfields);
}
int SMBCALL smb_getmsghdr_by_hash(smb_t* smb, smbmsg_t* msg, unsigned source
,unsigned flags, const void* data, size_t length)
{
int retval;
if((retval=smb_getmsgidx_by_hash(smb,msg,source,flags,data,length))!=SMB_SUCCESS)
return(retval);
if((retval=smb_lockmsghdr(smb,msg))!=SMB_SUCCESS)
return(retval);
retval=smb_getmsghdr(smb,msg);
smb_unlockmsghdr(smb,msg);
return(retval);
}
void viewmsgs(ulong start, ulong count)
{
int i;
ulong l=0;
smbmsg_t msg;
if(!start)
start=1;
if(!count)
count=~0;
fseek(smb.sid_fp,(start-1L)*sizeof(idxrec_t),SEEK_SET);
while(l<count) {
if(!fread(&msg.idx,1,sizeof(idxrec_t),smb.sid_fp))
break;
i=smb_lockmsghdr(&smb,&msg);
if(i) {
fprintf(errfp,"\n%s!smb_lockmsghdr returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
i=smb_getmsghdr(&smb,&msg);
smb_unlockmsghdr(&smb,&msg);
if(i) {
fprintf(errfp,"\n%s!smb_getmsghdr returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
printf("--------------------\n");
printf("%-20.20s %ld\n" ,"index record",ftell(smb.sid_fp)/sizeof(idxrec_t));
smb_dump_msghdr(stdout,&msg);
printf("\n");
smb_freemsgmem(&msg);
l++;
}
}
int fixsmb(char* sub)
{
char* p;
char* text;
char c;
int i,w;
ulong l,length,size,n;
smbmsg_t msg;
memset(&smb,0,sizeof(smb));
SAFECOPY(smb.file,sub);
if((p=getfext(smb.file))!=NULL && stricmp(p,".shd")==0)
*p=0; /* Chop off .shd extension, if supplied on command-line */
printf("Opening %s\n",smb.file);
if((i=smb_open(&smb))!=0) {
printf("smb_open returned %d: %s\n",i,smb.last_error);
exit(1);
}
if((i=smb_lock(&smb))!=0) {
printf("smb_lock returned %d: %s\n",i,smb.last_error);
exit(1);
}
if((i=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
printf("smb_locksmbhdr returned %d: %s\n",i,smb.last_error);
exit(1);
}
if((i=smb_getstatus(&smb))!=0) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
printf("smb_getstatus returned %d: %s\n",i,smb.last_error);
exit(1);
}
if(!(smb.status.attr&SMB_HYPERALLOC)) {
if((i=smb_open_ha(&smb))!=0) {
smb_close(&smb);
printf("smb_open_ha returned %d: %s\n",i,smb.last_error);
exit(1);
}
if((i=smb_open_da(&smb))!=0) {
smb_close(&smb);
printf("smb_open_da returned %d: %s\n",i,smb.last_error);
exit(1);
}
rewind(smb.sha_fp);
chsize(fileno(smb.sha_fp),0L); /* Truncate the header allocation file */
rewind(smb.sda_fp);
chsize(fileno(smb.sda_fp),0L); /* Truncate the data allocation file */
}
rewind(smb.sid_fp);
chsize(fileno(smb.sid_fp),0L); /* Truncate the index */
if(!(smb.status.attr&SMB_HYPERALLOC)) {
length=filelength(fileno(smb.sdt_fp));
w=0;
for(l=0;l<length;l+=SDT_BLOCK_LEN) /* Init .SDA file to NULL */
fwrite(&w,2,1,smb.sda_fp);
length=filelength(fileno(smb.shd_fp));
c=0;
for(l=0;l<length;l+=SHD_BLOCK_LEN) /* Init .SHD file to NULL */
fwrite(&c,1,1,smb.sha_fp);
} else
length=filelength(fileno(smb.shd_fp));
n=0; /* messsage offset */
for(l=smb.status.header_offset;l<length;l+=size) {
size=SHD_BLOCK_LEN;
printf("\r%2lu%% ",(long)(100.0/((float)length/l)));
msg.idx.offset=l;
if((i=smb_lockmsghdr(&smb,&msg))!=0) {
printf("\n(%06lX) smb_lockmsghdr returned %d:\n%s\n",l,i,smb.last_error);
continue;
}
i=smb_getmsghdr(&smb,&msg);
smb_unlockmsghdr(&smb,&msg);
if(i!=0) {
printf("\n(%06lX) smb_getmsghdr returned %d:\n%s\n",l,i,smb.last_error);
continue;
}
size=smb_hdrblocks(smb_getmsghdrlen(&msg))*SHD_BLOCK_LEN;
printf("#%-5lu (%06lX) %-25.25s ",msg.hdr.number,l,msg.from);
/* Create hash record */
if(msg.hdr.attr&MSG_DELETE)
text=NULL;
else
text=smb_getmsgtxt(&smb,&msg,GETMSGTXT_BODY_ONLY);
i=smb_hashmsg(&smb,&msg,text,TRUE /* update */);
if(i!=SMB_SUCCESS)
printf("!ERROR %d hashing message\n", i);
if(text!=NULL)
free(text);
/* Index the header */
if(msg.hdr.attr&MSG_DELETE)
printf("Not indexing deleted message\n");
else if(msg.hdr.number==0)
printf("Not indexing invalid message number (0)!\n");
else {
msg.offset=n;
if(renumber)
msg.hdr.number=n+1;
if(msg.hdr.netattr&MSG_INTRANSIT) {
printf("Removing 'in transit' attribute\n");
msg.hdr.netattr&=~MSG_INTRANSIT;
}
if((i=smb_putmsg(&smb,&msg))!=0) {
printf("\nsmb_putmsg returned %d: %s\n",i,smb.last_error);
continue;
}
n++;
}
if(!(smb.status.attr&SMB_HYPERALLOC)) {
/**************************/
/* Allocate header blocks */
/**************************/
fseek(smb.sha_fp,(l-smb.status.header_offset)/SHD_BLOCK_LEN,SEEK_SET);
if(msg.hdr.attr&MSG_DELETE) c=0; /* mark as free */
else c=1; /* or allocated */
for(i=0;i<(int)(size/SHD_BLOCK_LEN);i++)
fputc(c,smb.sha_fp);
/************************/
/* Allocate data blocks */
/************************/
if(!(msg.hdr.attr&MSG_DELETE))
smb_incmsg_dfields(&smb,&msg,1);
}
smb_freemsgmem(&msg);
}
printf("\r%79s\r100%%\n","");
smb.status.total_msgs=n;
if(renumber)
smb.status.last_msg=n;
else
sort_index(&smb);
printf("Saving message base status (%lu total messages).\n",n);
if((i=smb_putstatus(&smb))!=0)
printf("\nsmb_putstatus returned %d: %s\n",i,smb.last_error);
smb_unlocksmbhdr(&smb);
printf("Closing message base.\n");
smb_close(&smb);
unlock_msgbase();
printf("Done.\n");
return(0);
}
void maint(void)
{
int i;
ulong l,m,n,f,flagged=0;
time_t now;
smbmsg_t msg;
idxrec_t *idx;
printf("Maintaining %s\r\n",smb.file);
now=time(NULL);
i=smb_locksmbhdr(&smb);
if(i) {
fprintf(errfp,"\n%s!smb_locksmbhdr returned %d: %s\n"
,beep,i,smb.last_error);
return;
}
i=smb_getstatus(&smb);
if(i) {
smb_unlocksmbhdr(&smb);
fprintf(errfp,"\n%s!smb_getstatus returned %d: %s\n"
,beep,i,smb.last_error);
return;
}
if(smb_open_hash(&smb) == SMB_SUCCESS)
{
ulong max_hashes=0;
printf("Maintaining %s hash file\r\n", smb.file);
if((smb.status.attr&(SMB_EMAIL|SMB_NOHASH)) == 0) {
max_hashes = smb.status.max_msgs;
if(smb.status.max_crcs > max_hashes)
max_hashes = smb.status.max_crcs;
}
if(!max_hashes) {
CHSIZE_FP(smb.hash_fp,0);
} else if(filelength(fileno(smb.hash_fp)) > (long)(max_hashes * SMB_HASH_SOURCE_TYPES * sizeof(hash_t))) {
if(fseek(smb.hash_fp, -((long)(max_hashes * SMB_HASH_SOURCE_TYPES * sizeof(hash_t))), SEEK_END) == 0) {
hash_t* hashes = malloc(max_hashes * SMB_HASH_SOURCE_TYPES * sizeof(hash_t));
if(hashes != NULL) {
if(fread(hashes, sizeof(hash_t), max_hashes * SMB_HASH_SOURCE_TYPES, smb.hash_fp) == max_hashes * SMB_HASH_SOURCE_TYPES) {
CHSIZE_FP(smb.hash_fp,0);
rewind(smb.hash_fp);
fwrite(hashes, sizeof(hash_t), max_hashes * SMB_HASH_SOURCE_TYPES, smb.hash_fp);
}
free(hashes);
}
}
}
smb_close_hash(&smb);
}
if(!smb.status.total_msgs) {
smb_unlocksmbhdr(&smb);
printf("Empty\n");
return;
}
printf("Loading index...\n");
if((idx=(idxrec_t *)malloc(sizeof(idxrec_t)*smb.status.total_msgs))
==NULL) {
smb_unlocksmbhdr(&smb);
fprintf(errfp,"\n%s!Error allocating %u bytes of memory\n"
,beep,sizeof(idxrec_t)*smb.status.total_msgs);
return;
}
fseek(smb.sid_fp,0L,SEEK_SET);
for(l=0;l<smb.status.total_msgs;l++) {
printf("%lu of %"PRIu32"\r"
,l+1,smb.status.total_msgs);
if(!fread(&idx[l],1,sizeof(idxrec_t),smb.sid_fp))
break;
}
printf("\nDone.\n\n");
printf("Scanning for pre-flagged messages...\n");
for(m=0;m<l;m++) {
printf("\r%2lu%%",m ? (long)(100.0/((float)l/m)) : 0);
if(idx[m].attr&MSG_DELETE)
flagged++;
}
printf("\r100%% (%lu pre-flagged for deletion)\n",flagged);
if(smb.status.max_age) {
printf("Scanning for messages more than %u days old...\n"
,smb.status.max_age);
for(m=f=0;m<l;m++) {
printf("\r%2lu%%",m ? (long)(100.0/((float)l/m)) : 0);
if(idx[m].attr&(MSG_PERMANENT|MSG_DELETE))
continue;
if((ulong)now>idx[m].time && (now-idx[m].time)/(24L*60L*60L)
>smb.status.max_age) {
f++;
flagged++;
idx[m].attr|=MSG_DELETE;
}
} /* mark for deletion */
printf("\r100%% (%lu flagged for deletion due to age)\n",f);
}
printf("Scanning for read messages to be killed...\n");
for(m=f=0;m<l;m++) {
printf("\r%2lu%%",m ? (long)(100.0/((float)l/m)) : 0);
if(idx[m].attr&(MSG_PERMANENT|MSG_DELETE))
continue;
if((idx[m].attr&(MSG_READ|MSG_KILLREAD))==(MSG_READ|MSG_KILLREAD)) {
f++;
flagged++;
idx[m].attr|=MSG_DELETE;
}
}
printf("\r100%% (%lu flagged for deletion due to read status)\n",f);
if(smb.status.max_msgs && l-flagged>smb.status.max_msgs) {
printf("Flagging excess messages for deletion...\n");
for(m=n=0,f=flagged;l-flagged>smb.status.max_msgs && m<l;m++) {
if(idx[m].attr&(MSG_PERMANENT|MSG_DELETE))
continue;
printf("%lu of %lu\r",++n,(l-f)-smb.status.max_msgs);
flagged++;
idx[m].attr|=MSG_DELETE;
} /* mark for deletion */
printf("\nDone.\n\n");
}
if(!flagged) { /* No messages to delete */
free(idx);
smb_unlocksmbhdr(&smb);
return;
}
if(!(mode&NOANALYSIS)) {
printf("Freeing allocated header and data blocks for deleted messages...\n");
if(!(smb.status.attr&SMB_HYPERALLOC)) {
i=smb_open_da(&smb);
if(i) {
smb_unlocksmbhdr(&smb);
fprintf(errfp,"\n%s!smb_open_da returned %d: %s\n"
,beep,i,smb.last_error);
bail(1);
}
i=smb_open_ha(&smb);
if(i) {
smb_unlocksmbhdr(&smb);
fprintf(errfp,"\n%s!smb_open_ha returned %d: %s\n"
,beep,i,smb.last_error);
bail(1);
}
}
for(m=n=0;m<l;m++) {
if(idx[m].attr&MSG_DELETE) {
printf("%lu of %lu\r",++n,flagged);
msg.idx=idx[m];
msg.hdr.number=msg.idx.number;
if((i=smb_getmsgidx(&smb,&msg))!=0) {
fprintf(errfp,"\n%s!smb_getmsgidx returned %d: %s\n"
,beep,i,smb.last_error);
continue;
}
i=smb_lockmsghdr(&smb,&msg);
if(i) {
fprintf(errfp,"\n%s!smb_lockmsghdr returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
if((i=smb_getmsghdr(&smb,&msg))!=0) {
smb_unlockmsghdr(&smb,&msg);
fprintf(errfp,"\n%s!smb_getmsghdr returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
msg.hdr.attr|=MSG_DELETE; /* mark header as deleted */
if((i=smb_putmsg(&smb,&msg))!=0) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
fprintf(errfp,"\n%s!smb_putmsg returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
smb_unlockmsghdr(&smb,&msg);
if((i=smb_freemsg(&smb,&msg))!=0) {
smb_freemsgmem(&msg);
fprintf(errfp,"\n%s!smb_freemsg returned %d: %s\n"
,beep,i,smb.last_error);
break;
}
smb_freemsgmem(&msg);
}
}
if(!(smb.status.attr&SMB_HYPERALLOC)) {
smb_close_ha(&smb);
smb_close_da(&smb);
}
printf("\nDone.\n\n");
}
printf("Re-writing index...\n");
rewind(smb.sid_fp);
CHSIZE_FP(smb.sid_fp,0);
for(m=n=0;m<l;m++) {
if(idx[m].attr&MSG_DELETE)
continue;
printf("%lu of %lu\r",++n,l-flagged);
fwrite(&idx[m],sizeof(idxrec_t),1,smb.sid_fp);
}
printf("\nDone.\n\n");
fflush(smb.sid_fp);
free(idx);
smb.status.total_msgs-=flagged;
smb_putstatus(&smb);
smb_unlocksmbhdr(&smb);
}
int sbbs_t::delmail(uint usernumber, int which)
{
ulong i,l;
time_t now;
idxrec_t *idxbuf;
smbmsg_t msg;
now=time(NULL);
if((i=smb_getstatus(&smb))!=0) {
errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
return(2);
}
if(!smb.status.total_msgs)
return(0);
if((idxbuf=(idxrec_t *)malloc(smb.status.total_msgs*sizeof(idxrec_t)))==NULL) {
errormsg(WHERE,ERR_ALLOC,smb.file,smb.status.total_msgs*sizeof(idxrec_t));
return(-1);
}
if((i=smb_open_da(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
free(idxbuf);
return(i);
}
if((i=smb_open_ha(&smb))!=0) {
smb_close_da(&smb);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
free(idxbuf);
return(i);
}
smb_rewind(smb.sid_fp);
for(l=0;l<smb.status.total_msgs;) {
if(smb_fread(&smb,&msg.idx,sizeof(idxrec_t),smb.sid_fp)!=sizeof(idxrec_t))
break;
if(!(msg.idx.attr&MSG_PERMANENT)
&& ((which==MAIL_SENT && usernumber==msg.idx.from)
|| (which==MAIL_YOUR && usernumber==msg.idx.to)
|| (which==MAIL_ANY && (usernumber==msg.idx.to || usernumber==msg.idx.from))
|| which==MAIL_ALL)) {
if(smb.status.max_age && (now<0?0:(uintmax_t)now)>msg.idx.time
&& (now-msg.idx.time)/(24L*60L*60L)>smb.status.max_age)
msg.idx.attr|=MSG_DELETE;
else if(msg.idx.attr&MSG_KILLREAD && msg.idx.attr&MSG_READ)
msg.idx.attr|=MSG_DELETE;
if(msg.idx.attr&MSG_DELETE) {
/* Don't need to lock message because base is locked */
if((i=smb_getmsghdr(&smb,&msg))!=0)
errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
else {
if(msg.hdr.attr!=msg.idx.attr) {
msg.hdr.attr=msg.idx.attr;
if((i=smb_putmsghdr(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
}
if((i=smb_freemsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_REMOVE,smb.file,i,smb.last_error);
if(msg.hdr.auxattr&MSG_FILEATTACH)
delfattach(&cfg,&msg);
smb_freemsgmem(&msg);
}
continue;
}
}
idxbuf[l]=msg.idx;
l++;
}
smb_rewind(smb.sid_fp);
smb_fsetlength(smb.sid_fp,0);
for(i=0;i<l;i++)
smb_fwrite(&smb,&idxbuf[i],sizeof(idxrec_t),smb.sid_fp);
free(idxbuf);
smb.status.total_msgs=l;
smb_putstatus(&smb);
smb_fflush(smb.sid_fp);
smb_close_ha(&smb);
smb_close_da(&smb);
return(0);
}
