bbs/deb-mbse
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2024-04-08. You can view files and clone it, but cannot push or open issues or pull requests.
9b545491ca
deb-mbse/lib/jammsg.c
Michiel Broek 9b545491ca Use both CRC and User ID to search lastread record
2007-09-02 15:04:35 +00:00

1486 lines
42 KiB
C
Raw Blame History

/*****************************************************************************
*
* $Id$
* Purpose ...............: JAM message base functions
*
*****************************************************************************
*
* Original written in C++ by Marco Maccaferri for LoraBBS and was
* distributed under GNU GPL. This version is modified for use with
* MBSE BBS and utilities.
*
*****************************************************************************
* Copyright (C) 1997-2007
*
* Michiel Broek FIDO: 2:280/2802
* Beekmansbos 10
* 1971 BV IJmuiden
* the Netherlands
*
* This file is part of MBSE BBS.
*
* This BBS 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, or (at your option) any
* later version.
*
* MBSE BBS is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with MBSE BBS; see the file COPYING. If not, write to the Free
* Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*****************************************************************************/
#include "../config.h"
#include "mbselib.h"
#include "msgtext.h"
#include "msg.h"
#include "jam.h"
#include "jammsg.h"
#include "users.h"
#define MAX_TEXT 2048
int fdHdr = -1;
int fdJdt = -1;
int fdJdx = -1;
int fdJlr = -1;
unsigned char *pSubfield;
char BaseName[PATH_MAX];
char *pLine, *pBuff;
char szBuff[MAX_LINE_LENGTH + 1];
char szLine[MAX_LINE_LENGTH + 1];
JAMHDRINFO jamHdrInfo;
JAMHDR jamHdr;
unsigned int LastReadRec;
unsigned int AddSubfield(unsigned int, char *);
unsigned int AddSubfield(unsigned int JamSFld, char *SubStr)
{
JAMSUBFIELD jamSubfield;
unsigned int Len;
jamSubfield.HiID = 0;
jamSubfield.LoID = JamSFld;
jamSubfield.DatLen = strlen(SubStr); /* + 1; */
Len = jamSubfield.DatLen + sizeof(JAMBINSUBFIELD);
write(fdHdr, &jamSubfield, sizeof(JAMBINSUBFIELD));
write(fdHdr, SubStr, strlen(SubStr)); /* + 1); */
return Len;
}
void JAMset_flags(void);
void JAMset_flags()
{
jamHdr.Attribute |= (Msg.Local) ? MSG_LOCAL : 0;
jamHdr.Attribute |= (Msg.Intransit) ? MSG_INTRANSIT : 0;
jamHdr.Attribute |= (Msg.Private) ? MSG_PRIVATE : 0;
jamHdr.Attribute |= (Msg.Received) ? MSG_READ : 0;
jamHdr.Attribute |= (Msg.Sent) ? MSG_SENT : 0;
jamHdr.Attribute |= (Msg.KillSent) ? MSG_KILLSENT : 0;
jamHdr.Attribute |= (Msg.ArchiveSent) ? MSG_ARCHIVESENT : 0;
jamHdr.Attribute |= (Msg.Hold) ? MSG_HOLD : 0;
jamHdr.Attribute |= (Msg.Crash) ? MSG_CRASH : 0;
jamHdr.Attribute |= (Msg.Immediate) ? MSG_IMMEDIATE : 0;
jamHdr.Attribute |= (Msg.Direct) ? MSG_DIRECT : 0;
jamHdr.Attribute |= (Msg.Gate) ? MSG_GATE : 0;
jamHdr.Attribute |= (Msg.FileRequest) ? MSG_FILEREQUEST : 0;
jamHdr.Attribute |= (Msg.FileAttach) ? MSG_FILEATTACH : 0;
jamHdr.Attribute |= (Msg.TruncFile) ? MSG_TRUNCFILE : 0;
jamHdr.Attribute |= (Msg.KillFile) ? MSG_KILLFILE : 0;
jamHdr.Attribute |= (Msg.ReceiptRequest) ? MSG_RECEIPTREQ : 0;
jamHdr.Attribute |= (Msg.ConfirmRequest) ? MSG_CONFIRMREQ : 0;
jamHdr.Attribute |= (Msg.Orphan) ? MSG_ORPHAN : 0;
jamHdr.Attribute |= (Msg.Encrypt) ? MSG_ENCRYPT : 0;
jamHdr.Attribute |= (Msg.Compressed) ? MSG_COMPRESS : 0;
jamHdr.Attribute |= (Msg.Escaped) ? MSG_ESCAPED : 0;
jamHdr.Attribute |= (Msg.ForcePU) ? MSG_FPU : 0;
jamHdr.Attribute |= (Msg.Localmail) ? MSG_TYPELOCAL : 0;
jamHdr.Attribute |= (Msg.Echomail) ? MSG_TYPEECHO : 0;
jamHdr.Attribute |= (Msg.Netmail) ? MSG_TYPENET : 0;
jamHdr.Attribute |= (Msg.Nodisplay) ? MSG_NODISP : 0;
jamHdr.Attribute |= (Msg.Locked) ? MSG_LOCKED : 0;
jamHdr.Attribute |= (Msg.Deleted) ? MSG_DELETED : 0;
jamHdr.ReplyTo = Msg.Original;
jamHdr.ReplyNext = Msg.Reply;
jamHdr.DateReceived = Msg.Read;
jamHdr.MsgIdCRC = Msg.MsgIdCRC;
jamHdr.ReplyCRC = Msg.ReplyCRC;
}
int JAM_SearchUser(unsigned int crcval)
{
char *temp;
FILE *fp;
struct userhdr usrhdr;
struct userrec usr;
unsigned int mycrc;
int rc = 0;
if (crcval == 0)
return -1;
temp = calloc(PATH_MAX, sizeof(char));
snprintf(temp, PATH_MAX -1, "%s/etc/users.data", getenv("MBSE_ROOT"));
if ((fp = fopen(temp, "r")) == NULL) {
free(temp);
return -1;
}
free(temp);
fread(&usrhdr, sizeof(usrhdr), 1, fp);
while (fread(&usr, usrhdr.recsize, 1, fp) == 1) {
mycrc = StringCRC32(tl(usr.sUserName));
if (mycrc == crcval) {
fclose(fp);
return rc;
}
rc++;
}
/*
* Nothing found
*/
fclose(fp);
return -1;
}
/*
* Add a message, the structure msg must contain all needed
* information.
*/
int JAM_AddMsg()
{
int i, RetVal = TRUE;
unsigned int ulMsg = JAM_Highest() + 1L;
char *pszText, *Sign= (char *)HEADERSIGNATURE;
JAMIDXREC jamIdx;
int Oke;
memset(&jamHdr, 0, sizeof(JAMHDR));
jamHdr.Signature[0] = Sign[0];
jamHdr.Signature[1] = Sign[1];
jamHdr.Signature[2] = Sign[2];
jamHdr.Signature[3] = Sign[3];
jamHdr.Revision = CURRENTREVLEV;
jamHdr.MsgNum = ulMsg;
jamHdr.DateWritten = Msg.Written;
jamHdr.DateProcessed = Msg.Arrived;
JAMset_flags();
lseek(fdHdr, 0L, SEEK_END);
jamIdx.UserCRC = 0;
jamIdx.HdrOffset = tell(fdHdr);
lseek(fdJdx, 0L, SEEK_END);
write(fdJdx, &jamIdx, sizeof(JAMIDXREC));
write(fdHdr, &jamHdr, sizeof(JAMHDR));
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_SENDERNAME, Msg.From);
if (Msg.To[0])
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_RECVRNAME, Msg.To);
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_SUBJECT, Msg.Subject);
if (Msg.FromAddress[0] != '\0')
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_OADDRESS, Msg.FromAddress);
if (Msg.ToAddress[0] != '\0')
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_DADDRESS, Msg.ToAddress);
Msg.Id = jamHdr.MsgNum;
lseek(fdJdt, 0L, SEEK_END);
jamHdr.TxtOffset = tell(fdJdt);
jamHdr.TxtLen = 0;
/*
* Read message text from memory, this also contains kludges.
* Extract those that are defined by the JAMmb specs, except
* the AREA: kludge. This one is only present in bad and dupe
* echomail areas and is present for tossbad and tossdupe.
*/
if ((pszText = (char *)MsgText_First ()) != NULL)
do {
if ((pszText[0] == '\001') || (!strncmp(pszText, "SEEN-BY:", 8))) {
Oke = FALSE;
if (!strncmp(pszText, "\001PID: ", 6)) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_PID, pszText + 6);
Oke = TRUE;
}
if (!strncmp(pszText, "\001MSGID: ", 8)) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_MSGID, pszText + 8);
Oke = TRUE;
}
if (!strncmp(pszText, "\001REPLY: ", 8)) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_REPLYID, pszText + 8);
Oke = TRUE;
}
if (!strncmp(pszText, "\001PATH: ", 7)) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_PATH2D, pszText + 7);
Oke = TRUE;
}
if (!strncmp(pszText, "\001Via", 4)) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_TRACE, pszText + 5);
Oke = TRUE;
}
if (!strncmp(pszText, "SEEN-BY: ", 9)) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_SEENBY2D, pszText + 9);
Oke = TRUE;
}
/*
* Other non-JAM kludges
*/
if ((!Oke) && (pszText[0] == '\001')) {
jamHdr.SubfieldLen += AddSubfield(JAMSFLD_FTSKLUDGE, pszText + 1);
Oke = TRUE;
}
if (!Oke) {
for (i = 0; i < strlen(pszText); i++) {
if (pszText[i] < 32)
printf("<%x>", pszText[i]);
else
printf("%c", pszText[i]);
}
}
} else {
write(fdJdt, pszText, strlen (pszText));
jamHdr.TxtLen += strlen (pszText);
write(fdJdt, "\r", 1);
jamHdr.TxtLen += 1;
}
} while ((pszText = (char *)MsgText_Next ()) != NULL);
/*
* Write final message header
*/
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
write(fdHdr, &jamHdr, sizeof (JAMHDR));
/*
* Update area information
*/
lseek(fdHdr, 0L, SEEK_SET);
read(fdHdr, &jamHdrInfo, sizeof (JAMHDRINFO));
jamHdrInfo.ActiveMsgs++;
jamHdrInfo.ModCounter++;
lseek(fdHdr, 0L, SEEK_SET);
write(fdHdr, &jamHdrInfo, sizeof (JAMHDRINFO));
return RetVal;
}
/*
* Close current message base
*/
void JAM_Close(void)
{
if (fdJdx != -1)
close(fdJdx);
if (fdJdt != -1)
close(fdJdt);
if (fdHdr != -1)
close(fdHdr);
if (fdJlr != -1)
close(fdJlr);
if (pSubfield != NULL)
free(pSubfield);
fdHdr = fdJdt = fdJdx = fdJlr = -1;
pSubfield = NULL;
Msg.Id = 0L;
}
/*
* Delete message number
*/
int JAM_Delete(unsigned int ulMsg)
{
int RetVal = FALSE;
JAMIDXREC jamIdx;
if (JAM_ReadHeader(ulMsg) == TRUE) {
jamHdr.Attribute |= MSG_DELETED;
lseek(fdJdx, tell(fdJdx) - sizeof(jamIdx), SEEK_SET);
if (read(fdJdx, &jamIdx, sizeof(jamIdx)) == sizeof(jamIdx)) {
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
write(fdHdr, &jamHdr, sizeof(JAMHDR));
lseek(fdHdr, 0L, SEEK_SET);
read(fdHdr, &jamHdrInfo, sizeof (JAMHDRINFO));
jamHdrInfo.ActiveMsgs--;
lseek(fdHdr, 0L, SEEK_SET);
write(fdHdr, &jamHdrInfo, sizeof (JAMHDRINFO));
RetVal = TRUE;
}
}
return RetVal;
}
/*
* Delete JAM area files
*/
void JAM_DeleteJAM(char *Base)
{
char *temp;
temp = calloc(PATH_MAX, sizeof(char));
snprintf(temp, PATH_MAX -1, "%s%s", Base, EXT_HDRFILE);
unlink(temp);
snprintf(temp, PATH_MAX -1, "%s%s", Base, EXT_IDXFILE);
unlink(temp);
snprintf(temp, PATH_MAX -1, "%s%s", Base, EXT_TXTFILE);
unlink(temp);
snprintf(temp, PATH_MAX -1, "%s%s", Base, EXT_LRDFILE);
unlink(temp);
free(temp);
Syslog('+', "JAM deleted %s", Base);
}
/*
* Search for requested LastRead record.
*/
int JAM_GetLastRead(lastread *LR)
{
lastread lr;
LastReadRec = 0L;
lseek(fdJlr, 0, SEEK_SET);
while (read(fdJlr, &lr, sizeof(lastread)) == sizeof(lastread)) {
if (lr.UserID == LR->UserID) {
LR->LastReadMsg = lr.LastReadMsg;
LR->HighReadMsg = lr.HighReadMsg;
return TRUE;
}
LastReadRec++;
}
return FALSE;
}
/*
* Get highest message number
*/
unsigned int JAM_Highest(void)
{
unsigned int RetVal = 0L;
JAMIDXREC jamIdx;
if (jamHdrInfo.ActiveMsgs > 0L) {
lseek(fdJdx, filelength(fdJdx) - sizeof(jamIdx), SEEK_SET);
if (read(fdJdx, &jamIdx, sizeof(jamIdx)) == sizeof(jamIdx)) {
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
read(fdHdr, &jamHdr, sizeof(JAMHDR));
RetVal = jamHdr.MsgNum;
}
}
Msg.Id = RetVal;
return RetVal;
}
int JAM_Lock(unsigned int ulTimeout)
{
int rc, Tries = 0;
struct flock fl;
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
fl.l_start = 0L;
fl.l_len = 1L; /* GoldED locks 1 byte as well */
fl.l_pid = getpid();
while ((rc = fcntl(fdHdr, F_SETLK, &fl)) && ((errno == EACCES) || (errno == EAGAIN))) {
if (++Tries >= (ulTimeout * 4)) {
fcntl(fdHdr, F_GETLK, &fl);
WriteError("JAM messagebase is locked by pid %d", fl.l_pid);
return FALSE;
}
msleep(250);
Syslog('m', "JAM messagebase lock attempt %d", Tries);
}
if (rc) {
WriteError("$%s lock error", BaseName);
return FALSE;
}
return TRUE;
}
/*
* Get lowest message number
*/
unsigned int JAM_Lowest(void)
{
unsigned int RetVal = 0L;
JAMIDXREC jamIdx;
if (jamHdrInfo.ActiveMsgs > 0L) {
lseek(fdJdx, 0L, SEEK_SET);
if (read(fdJdx, &jamIdx, sizeof(jamIdx)) == sizeof(jamIdx)) {
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
read(fdHdr, &jamHdr, sizeof(JAMHDR));
RetVal = jamHdr.MsgNum;
}
}
Msg.Id = RetVal;
return RetVal;
}
void JAM_New(void)
{
memset(&Msg, 0, sizeof(Msg));
MsgText_Clear();
}
int JAM_NewLastRead(lastread LR)
{
lseek(fdJlr, 0, SEEK_END);
return (write(fdJlr, &LR, sizeof(lastread)) == sizeof(lastread));
}
int JAM_Next(unsigned int * ulMsg)
{
int RetVal = FALSE, MayBeNext = FALSE;
JAMIDXREC jamIdx;
unsigned int _Msg;
_Msg = *ulMsg;
if (jamHdrInfo.ActiveMsgs > 0L) {
// --------------------------------------------------------------------
// The first attempt to retrive the next message number suppose that
// the file pointers are located after the current message number.
// Usually this is the 99% of the situations because the messages are
// often readed sequentially.
// --------------------------------------------------------------------
if (tell(fdJdx) >= sizeof (jamIdx))
lseek(fdJdx, tell(fdJdx) - sizeof(jamIdx), SEEK_SET);
do {
if (read(fdJdx, &jamIdx, sizeof(jamIdx)) == sizeof(jamIdx)) {
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
read(fdHdr, &jamHdr, sizeof (JAMHDR));
if (MayBeNext == TRUE) {
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum > _Msg) {
_Msg = jamHdr.MsgNum;
RetVal = TRUE;
}
}
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == _Msg)
MayBeNext = TRUE;
}
} while (RetVal == FALSE && tell(fdJdx) < filelength(fdJdx));
if (RetVal == FALSE && MayBeNext == FALSE) {
// --------------------------------------------------------------------
// It seems that the file pointers are not located where they should be
// so our next attempt is to scan the database from the beginning to
// find the next message number.
// --------------------------------------------------------------------
lseek(fdJdx, 0L, SEEK_SET);
do {
if (read(fdJdx, &jamIdx, sizeof(jamIdx)) == sizeof(jamIdx)) {
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
read(fdHdr, &jamHdr, sizeof (JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum > _Msg) {
_Msg = jamHdr.MsgNum;
RetVal = TRUE;
}
}
} while (RetVal == FALSE && tell(fdJdx) < filelength(fdJdx));
}
Msg.Id = 0L;
if (RetVal == TRUE)
Msg.Id = _Msg;
}
memcpy(ulMsg, &_Msg, sizeof(unsigned int));
return RetVal;
}
/*
* Return number of messages
*/
unsigned int JAM_Number(void)
{
return jamHdrInfo.ActiveMsgs;
}
/*
* Open specified JAM message base
*/
int JAM_Open(char *Msgbase)
{
int RetVal = FALSE;
char *File;
char *Signature = (char *)HEADERSIGNATURE;
fdJdt = fdJdx = fdJlr = -1;
pSubfield = NULL;
File = calloc(PATH_MAX, sizeof(char));
snprintf(File, PATH_MAX -1, "%s%s", Msgbase, EXT_HDRFILE);
if ((fdHdr = open(File, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)) != -1) {
if (read(fdHdr, &jamHdrInfo, sizeof(JAMHDRINFO)) != sizeof(JAMHDRINFO)) {
memset(&jamHdrInfo, 0, sizeof(JAMHDRINFO));
jamHdrInfo.Signature[0] = Signature[0];
jamHdrInfo.Signature[1] = Signature[1];
jamHdrInfo.Signature[2] = Signature[2];
jamHdrInfo.Signature[3] = Signature[3];
jamHdrInfo.DateCreated = time(NULL);
jamHdrInfo.BaseMsgNum = 1;
lseek(fdHdr, 0, SEEK_SET);
write(fdHdr, &jamHdrInfo, sizeof(JAMHDRINFO));
Syslog('+', "JAM created %s", Msgbase);
}
if (jamHdrInfo.Signature[0] == Signature[0] &&
jamHdrInfo.Signature[1] == Signature[1] &&
jamHdrInfo.Signature[2] == Signature[2] &&
jamHdrInfo.Signature[3] == Signature[3]) {
snprintf(File, PATH_MAX -1, "%s%s", Msgbase, EXT_TXTFILE);
fdJdt = open(File, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
snprintf(File, PATH_MAX -1, "%s%s", Msgbase, EXT_IDXFILE);
fdJdx = open(File, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
snprintf(File, PATH_MAX -1, "%s%s", Msgbase, EXT_LRDFILE);
fdJlr = open(File, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
RetVal = TRUE;
strcpy(BaseName, Msgbase);
} else {
close(fdHdr);
fdHdr = -1;
}
} else
memset(&jamHdrInfo, 0, sizeof(JAMHDRINFO));
Msg.Id = 0L;
free(File);
if (!RetVal)
WriteError("JAM error open %s", Msgbase);
return RetVal;
}
/*
* Pack deleted messages from the message base. The messages are
* renumbered on the fly and the LastRead pointers are updated.
*/
void JAM_Pack(void)
{
int fdnHdr, fdnJdx, fdnJdt, fdnJlr;
int ToRead, Readed, i, count;
char *File, *New, *Subfield, *Temp;
JAMIDXREC jamIdx;
unsigned int NewNumber = 0, RefNumber = 0, Written = 0, mycrc;
lastread LR;
FILE *usrF;
struct userhdr usrhdr;
struct userrec usr;
File = calloc(PATH_MAX, sizeof(char));
New = calloc(PATH_MAX, sizeof(char));
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dr");
fdnHdr = open(File, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dt");
fdnJdt = open(File, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dx");
fdnJdx = open(File, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$lr");
fdnJlr = open(File, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
/*
* Get the number of LastRead records, this number is needed to prevent
* that FreeBSD makes garbage of the LastRead pointers for some reason.
*/
count = lseek(fdJlr, 0, SEEK_END) / sizeof(lastread);
if (fdnHdr != -1 && fdnJdt != -1 && fdnJdx != -1 && fdnJlr != -1) {
lseek(fdHdr, 0L, SEEK_SET);
if (read(fdHdr, &jamHdrInfo, sizeof(JAMHDRINFO)) == sizeof(JAMHDRINFO)) {
write(fdnHdr, &jamHdrInfo, sizeof(JAMHDRINFO));
while (read(fdHdr, &jamHdr, sizeof(JAMHDR)) == sizeof(JAMHDR)) {
RefNumber++;
if (strncmp(jamHdr.Signature, "JAM", 3)) {
WriteError("jamPack: %s headerfile corrupt", BaseName);
lseek(fdJdx, (RefNumber -1) * sizeof(JAMIDXREC), SEEK_SET);
read(fdJdx, &jamIdx, sizeof(JAMIDXREC));
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
read(fdHdr, &jamHdr, sizeof(JAMHDR));
if ((strncmp(jamHdr.Signature, "JAM", 3) == 0) && (jamHdr.MsgNum == RefNumber))
WriteError("jamPack: corrected the problem");
else {
WriteError("jamPack: PANIC, problem cannot be solved, skipping this area");
Written = 0;
break;
}
}
if (jamHdr.Attribute & MSG_DELETED) {
if (jamHdr.SubfieldLen > 0L)
lseek (fdHdr, jamHdr.SubfieldLen, SEEK_CUR);
} else {
jamIdx.UserCRC = 0;
jamIdx.HdrOffset = tell(fdnHdr);
write(fdnJdx, &jamIdx, sizeof(JAMIDXREC));
lseek(fdJdt, jamHdr.TxtOffset, SEEK_SET);
jamHdr.TxtOffset = tell(fdnJdt);
NewNumber++;
Written++;
lseek(fdJlr, 0, SEEK_SET);
for (i = 0; i < count; i++) {
if ((read(fdJlr, &LR, sizeof(lastread)) == sizeof(lastread))) {
/*
* Test if one of the lastread pointer is the current
* old message number and is different then the new number.
*/
if (((LR.LastReadMsg == jamHdr.MsgNum) || (LR.HighReadMsg == jamHdr.MsgNum)) &&
(jamHdr.MsgNum != NewNumber)) {
/*
* Adjust the matching numbers
*/
if (LR.LastReadMsg == jamHdr.MsgNum) {
Syslog('m', "JAM_Pack %s recno %d user %d LastRead %u -> %u",
BaseName, i, LR.UserID, jamHdr.MsgNum, NewNumber);
LR.LastReadMsg = NewNumber;
}
if (LR.HighReadMsg == jamHdr.MsgNum) {
Syslog('m', "JAM_Pack %s recno %d user %d HighRead %u -> %u",
BaseName, i, LR.UserID, jamHdr.MsgNum, NewNumber);
LR.HighReadMsg = NewNumber;
}
lseek(fdJlr, - sizeof(lastread), SEEK_CUR);
write(fdJlr, &LR, sizeof(lastread));
}
}
}
jamHdr.MsgNum = NewNumber;
write(fdnHdr, &jamHdr, sizeof(JAMHDR));
if (jamHdr.SubfieldLen > 0L) {
if ((Subfield = (char *)malloc ((size_t)(jamHdr.SubfieldLen + 1))) != NULL) {
read (fdHdr, Subfield, (size_t)jamHdr.SubfieldLen);
write (fdnHdr, Subfield, (size_t)jamHdr.SubfieldLen);
free(Subfield);
}
}
if ((Temp = (char *)malloc (MAX_TEXT)) != NULL) {
do {
if ((ToRead = MAX_TEXT) > jamHdr.TxtLen)
ToRead = (int)jamHdr.TxtLen;
Readed = (int)read (fdJdt, Temp, ToRead);
write (fdnJdt, Temp, Readed);
jamHdr.TxtLen -= Readed;
} while (jamHdr.TxtLen > 0);
free(Temp);
}
}
}
}
/*
* Correct any errors in the header
*/
if (Written) {
lseek(fdnHdr, 0, SEEK_SET);
if (read(fdnHdr, &jamHdrInfo, sizeof(JAMHDRINFO)) == sizeof(JAMHDRINFO)) {
if (jamHdrInfo.ActiveMsgs != Written) {
WriteError("jamPack: repair msgs %lu to %lu area %s", jamHdrInfo.ActiveMsgs, Written, BaseName);
jamHdrInfo.ActiveMsgs = Written;
lseek(fdnHdr, 0, SEEK_SET);
write(fdnHdr, &jamHdrInfo, sizeof(JAMHDRINFO));
}
}
}
/*
* Now copy the lastread file, reset LastRead pointers if area is empty.
* Check for deleted users.
*/
snprintf(File, PATH_MAX -1, "%s/etc/users.data", getenv("MBSE_ROOT"));
if ((usrF = fopen(File, "r"))) {
fread(&usrhdr, sizeof(usrhdr), 1, usrF);
}
lseek(fdJlr, 0, SEEK_SET);
for (i = 0; i < count; i++) {
if (read(fdJlr, &LR, sizeof(lastread)) == sizeof(lastread)) {
if (jamHdrInfo.ActiveMsgs == 0 && (LR.LastReadMsg || LR.HighReadMsg)) {
LR.LastReadMsg = 0;
LR.HighReadMsg = 0;
Syslog('m', "JAM_Pack %s recno %d user %d LastRead and HighRead are reset", BaseName, i, LR.UserID);
}
if (jamHdrInfo.ActiveMsgs && (LR.LastReadMsg > jamHdrInfo.ActiveMsgs)) {
LR.LastReadMsg = jamHdrInfo.ActiveMsgs;
Syslog('m', "JAM_Pack %s recno %d user %d LastRead is reset to %d", BaseName, i, LR.UserID, LR.LastReadMsg);
}
if (jamHdrInfo.ActiveMsgs && (LR.HighReadMsg > jamHdrInfo.ActiveMsgs)) {
LR.HighReadMsg = jamHdrInfo.ActiveMsgs;
Syslog('m', "JAM_Pack %s recno %d user %d HighRead is reset to %d", BaseName, i, LR.UserID, LR.HighReadMsg);
}
if (usrF) {
/*
* Search user record for LR pointer. If the record is valid and the
* user still exists then copy the LR record, else we drop it.
*/
fseek(usrF, usrhdr.hdrsize + (usrhdr.recsize * LR.UserID), SEEK_SET);
memset(&usr, 0, sizeof(usr));
if (fread(&usr, usrhdr.recsize, 1, usrF) == 1) {
mycrc = StringCRC32(tl(usr.sUserName));
if (mycrc == LR.UserCRC) {
write(fdnJlr, &LR, sizeof(lastread));
} else {
Syslog('-', "JAM_Pack %s purged LR record %d", BaseName, i);
}
} else {
Syslog('-', "JAM_Pack %s purged LR record %d", BaseName, i);
}
} else {
/*
* Should not be possible, but simply write LR records
* if no user data is available.
*/
write(fdnJlr, &LR, sizeof(lastread));
}
}
}
if (usrF)
fclose(usrF);
/*
* Close all files
*/
close(fdnHdr);
close(fdnJdt);
close(fdnJdx);
close(fdnJlr);
fdnHdr = fdnJdt = fdnJdx = fdnJlr = -1;
close(fdHdr);
close(fdJdt);
close(fdJdx);
close(fdJlr);
fdHdr = fdJdt = fdJdx = fdJlr = -1;
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dr");
snprintf(New, PATH_MAX -1, "%s%s", BaseName, EXT_HDRFILE);
unlink(New);
rename(File, New);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dt");
snprintf(New, PATH_MAX -1, "%s%s", BaseName, EXT_TXTFILE);
unlink(New);
rename(File, New);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dx");
snprintf(New, PATH_MAX -1, "%s%s", BaseName, EXT_IDXFILE);
unlink(New);
rename(File, New);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$lr");
snprintf(New, PATH_MAX -1, "%s%s", BaseName, EXT_LRDFILE);
unlink(New);
rename(File, New);
snprintf(File, PATH_MAX -1, "%s", BaseName);
JAM_Open(File);
}
if (fdnHdr != -1)
close(fdnHdr);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dr");
unlink(File);
if (fdnJdt != -1)
close(fdnJdt);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dt");
unlink(File);
if (fdnJdx != -1)
close(fdnJdx);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$dx");
unlink(File);
if (fdnJlr != -1)
close(fdnJlr);
snprintf(File, PATH_MAX -1, "%s%s", BaseName, ".$lr");
unlink(File);
free(File);
free(New);
}
int JAM_Previous (unsigned int *ulMsg)
{
int RetVal = FALSE, MayBeNext = FALSE;
int Pos;
JAMIDXREC jamIdx;
unsigned int _Msg;
_Msg = *ulMsg;
if (jamHdrInfo.ActiveMsgs > 0L) {
// --------------------------------------------------------------------
// The first attempt to retrive the next message number suppose that
// the file pointers are located after the current message number.
// Usually this is the 99% of the situations because the messages are
// often readed sequentially.
// --------------------------------------------------------------------
if (tell (fdJdx) >= sizeof (jamIdx)) {
Pos = tell (fdJdx) - sizeof (jamIdx);
do {
lseek (fdJdx, Pos, SEEK_SET);
if (read (fdJdx, &jamIdx, sizeof (jamIdx)) == sizeof (jamIdx)) {
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (MayBeNext == TRUE) {
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum < _Msg) {
_Msg = jamHdr.MsgNum;
RetVal = TRUE;
}
}
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == _Msg)
MayBeNext = TRUE;
}
Pos -= sizeof (jamIdx);
} while (RetVal == FALSE && Pos >= 0L);
}
if (RetVal == FALSE && MayBeNext == FALSE) {
// --------------------------------------------------------------------
// It seems that the file pointers are not located where they should be
// so our next attempt is to scan the database from the end to find
// the next message number.
// --------------------------------------------------------------------
Pos = filelength (fdJdx) - sizeof (jamIdx);
do {
lseek (fdJdx, Pos, SEEK_SET);
if (read (fdJdx, &jamIdx, sizeof (jamIdx)) == sizeof (jamIdx)) {
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum < _Msg) {
_Msg = jamHdr.MsgNum;
RetVal = TRUE;
}
}
Pos -= sizeof (jamIdx);
} while (RetVal == FALSE && Pos >= 0L);
}
Msg.Id = 0L;
if (RetVal == TRUE)
Msg.Id = _Msg;
}
memcpy(ulMsg, &_Msg, sizeof(unsigned int));
return (RetVal);
}
int JAM_ReadHeader (unsigned int ulMsg)
{
int i, RetVal = FALSE;
unsigned char *pPos;
unsigned int ulSubfieldLen, tmp;
JAMIDXREC jamIdx;
JAMBINSUBFIELD *jamSubField;
tmp = Msg.Id;
JAM_New ();
Msg.Id = tmp;
if (Msg.Id == ulMsg) {
// --------------------------------------------------------------------
// The user is requesting the header of the last message retrived
// so our first attempt is to read the last index from the file and
// check if this is the correct one.
// --------------------------------------------------------------------
lseek (fdJdx, tell (fdJdx) - sizeof (jamIdx), SEEK_SET);
if (read (fdJdx, &jamIdx, sizeof (jamIdx)) == sizeof (jamIdx)) {
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == ulMsg)
RetVal = TRUE;
}
}
if (((Msg.Id + 1) == ulMsg) && (RetVal == FALSE)) {
//---------------------------------------------------------------------
// If the user is requesting the header of the next message we attempt
// to read the next header and check if this is the correct one.
// This is EXPERIMENTAL
//---------------------------------------------------------------------
if (read(fdJdx, &jamIdx, sizeof(jamIdx)) == sizeof(jamIdx)) {
lseek(fdHdr, jamIdx.HdrOffset, SEEK_SET);
read(fdHdr, &jamHdr, sizeof(JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == ulMsg)
RetVal = TRUE;
}
}
if (RetVal == FALSE) {
// --------------------------------------------------------------------
// The message request is not the last retrived or the file pointers
// are not positioned where they should be, so now we attempt to
// retrieve the message header scanning the database from the beginning.
// --------------------------------------------------------------------
Msg.Id = 0L;
lseek (fdJdx, 0L, SEEK_SET);
do {
if (read (fdJdx, &jamIdx, sizeof (jamIdx)) == sizeof (jamIdx)) {
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == ulMsg)
RetVal = TRUE;
}
} while (RetVal == FALSE && tell (fdJdx) < filelength (fdJdx));
}
if (RetVal == TRUE) {
Msg.Current = Msg.Id = ulMsg;
Msg.Local = (unsigned char)((jamHdr.Attribute & MSG_LOCAL) ? TRUE : FALSE);
Msg.Intransit = (unsigned char)((jamHdr.Attribute & MSG_INTRANSIT) ? TRUE : FALSE);
Msg.Private = (unsigned char)((jamHdr.Attribute & MSG_PRIVATE) ? TRUE : FALSE);
Msg.Received = (unsigned char)((jamHdr.Attribute & MSG_READ) ? TRUE : FALSE);
Msg.Sent = (unsigned char)((jamHdr.Attribute & MSG_SENT) ? TRUE : FALSE);
Msg.KillSent = (unsigned char)((jamHdr.Attribute & MSG_KILLSENT) ? TRUE : FALSE);
Msg.ArchiveSent = (unsigned char)((jamHdr.Attribute & MSG_ARCHIVESENT) ? TRUE : FALSE);
Msg.Hold = (unsigned char)((jamHdr.Attribute & MSG_HOLD) ? TRUE : FALSE);
Msg.Crash = (unsigned char)((jamHdr.Attribute & MSG_CRASH) ? TRUE : FALSE);
Msg.Immediate = (unsigned char)((jamHdr.Attribute & MSG_IMMEDIATE) ? TRUE : FALSE);
Msg.Direct = (unsigned char)((jamHdr.Attribute & MSG_DIRECT) ? TRUE : FALSE);
Msg.Gate = (unsigned char)((jamHdr.Attribute & MSG_GATE) ? TRUE : FALSE);
Msg.FileRequest = (unsigned char)((jamHdr.Attribute & MSG_FILEREQUEST) ? TRUE : FALSE);
Msg.FileAttach = (unsigned char)((jamHdr.Attribute & MSG_FILEATTACH) ? TRUE : FALSE);
Msg.TruncFile = (unsigned char)((jamHdr.Attribute & MSG_TRUNCFILE) ? TRUE : FALSE);
Msg.KillFile = (unsigned char)((jamHdr.Attribute & MSG_KILLFILE) ? TRUE : FALSE);
Msg.ReceiptRequest = (unsigned char)((jamHdr.Attribute & MSG_RECEIPTREQ) ? TRUE : FALSE);
Msg.ConfirmRequest = (unsigned char)((jamHdr.Attribute & MSG_CONFIRMREQ) ? TRUE : FALSE);
Msg.Orphan = (unsigned char)((jamHdr.Attribute & MSG_ORPHAN) ? TRUE : FALSE);
Msg.Encrypt = (unsigned char)((jamHdr.Attribute & MSG_ENCRYPT) ? TRUE : FALSE);
Msg.Compressed = (unsigned char)((jamHdr.Attribute & MSG_COMPRESS) ? TRUE : FALSE);
Msg.Escaped = (unsigned char)((jamHdr.Attribute & MSG_ESCAPED) ? TRUE : FALSE);
Msg.ForcePU = (unsigned char)((jamHdr.Attribute & MSG_FPU) ? TRUE : FALSE);
Msg.Localmail = (unsigned char)((jamHdr.Attribute & MSG_TYPELOCAL) ? TRUE : FALSE);
Msg.Echomail = (unsigned char)((jamHdr.Attribute & MSG_TYPEECHO) ? TRUE : FALSE);
Msg.Netmail = (unsigned char)((jamHdr.Attribute & MSG_TYPENET) ? TRUE : FALSE);
Msg.Nodisplay = (unsigned char)((jamHdr.Attribute & MSG_NODISP) ? TRUE : FALSE);
Msg.Locked = (unsigned char)((jamHdr.Attribute & MSG_LOCKED) ? TRUE : FALSE);
Msg.Deleted = (unsigned char)((jamHdr.Attribute & MSG_DELETED) ? TRUE : FALSE);
Msg.Written = jamHdr.DateWritten;
Msg.Arrived = jamHdr.DateProcessed;
Msg.Read = jamHdr.DateReceived;
Msg.Original = jamHdr.ReplyTo;
Msg.Reply = jamHdr.ReplyNext;
if (pSubfield != NULL)
free (pSubfield);
pSubfield = NULL;
if (jamHdr.SubfieldLen > 0L) {
ulSubfieldLen = jamHdr.SubfieldLen;
pPos = pSubfield = (unsigned char *)malloc ((size_t)(ulSubfieldLen + 1));
if (pSubfield == NULL)
return (FALSE);
read (fdHdr, pSubfield, (size_t)jamHdr.SubfieldLen);
while (ulSubfieldLen > 0L) {
jamSubField = (JAMBINSUBFIELD *)pPos;
pPos += sizeof (JAMBINSUBFIELD);
/*
* The next check is to prevent a segmentation
* fault by corrupted subfields.
*/
if ((jamSubField->DatLen < 0) || (jamSubField->DatLen > jamHdr.SubfieldLen))
return FALSE;
switch (jamSubField->LoID) {
case JAMSFLD_SENDERNAME:
if (jamSubField->DatLen > 100) {
memcpy (Msg.From, pPos, 100);
Msg.From[100] = '\0';
} else {
memcpy (Msg.From, pPos, (int)jamSubField->DatLen);
Msg.From[(int)jamSubField->DatLen] = '\0';
}
break;
case JAMSFLD_RECVRNAME:
if (jamSubField->DatLen > 100) {
memcpy (Msg.To, pPos, 100);
Msg.To[100] = '\0';
} else {
memcpy (Msg.To, pPos, (int)jamSubField->DatLen);
Msg.To[(int)jamSubField->DatLen] = '\0';
}
break;
case JAMSFLD_SUBJECT:
if (jamSubField->DatLen > 100) {
memcpy (Msg.Subject, pPos, 100);
Msg.Subject[100] = '\0';
} else {
memcpy (Msg.Subject, pPos, (int)jamSubField->DatLen);
Msg.Subject[(int)jamSubField->DatLen] = '\0';
}
break;
case JAMSFLD_OADDRESS:
if (jamSubField->DatLen > 100) {
memcpy (Msg.FromAddress, pPos, 100);
Msg.FromAddress[100] = '\0';
} else {
memcpy (Msg.FromAddress, pPos, (int)jamSubField->DatLen);
Msg.FromAddress[(int)jamSubField->DatLen] = '\0';
}
break;
case JAMSFLD_DADDRESS:
if (jamSubField->DatLen > 100) {
memcpy(Msg.ToAddress, pPos, 100);
Msg.ToAddress[100] = '\0';
} else {
memcpy (Msg.ToAddress, pPos, (int)jamSubField->DatLen);
Msg.ToAddress[(int)jamSubField->DatLen] = '\0';
}
break;
case JAMSFLD_MSGID:
memcpy (Msg.Msgid, pPos, (int)jamSubField->DatLen);
Msg.Msgid[(int)jamSubField->DatLen] = '\0';
break;
case JAMSFLD_REPLYID:
memcpy (Msg.Replyid, pPos, (int)jamSubField->DatLen);
Msg.Replyid[(int)jamSubField->DatLen] = '\0';
break;
default:
break;
}
ulSubfieldLen -= sizeof (JAMBINSUBFIELD) + jamSubField->DatLen;
if (ulSubfieldLen > 0)
pPos += (int)jamSubField->DatLen;
}
}
/*
* In the original BBS we found that GEcho was not
* setting the FromAddress. We take it from the MSGID
* if there is one.
*/
if ((!strlen(Msg.FromAddress)) && (strlen(Msg.Msgid))) {
for (i = 0; i < strlen(Msg.Msgid); i++) {
if ((Msg.Msgid[i] == '@') || (Msg.Msgid[i] == ' '))
break;
Msg.FromAddress[i] = Msg.Msgid[i];
}
}
}
return (RetVal);
}
/*
* Read message
*/
int JAM_Read(unsigned int ulMsg, int nWidth)
{
int RetVal = FALSE, SkipNext;
int i, nReaded, nCol, nRead;
unsigned char *pPos;
unsigned int ulTxtLen, ulSubfieldLen;
JAMIDXREC jamIdx;
JAMBINSUBFIELD *jamSubField;
LDATA *Bottom = NULL, *New;
MsgText_Clear();
if ((RetVal = JAM_ReadHeader(ulMsg)) == TRUE) {
lseek (fdJdx, tell (fdJdx) - sizeof (jamIdx), SEEK_SET);
read (fdJdx, &jamIdx, sizeof (jamIdx));
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (pSubfield != NULL)
free (pSubfield);
pSubfield = NULL;
if (jamHdr.SubfieldLen > 0L) {
ulSubfieldLen = jamHdr.SubfieldLen;
pPos = pSubfield = (unsigned char *)malloc ((size_t)(ulSubfieldLen + 1));
if (pSubfield == NULL)
return (FALSE);
read (fdHdr, pSubfield, (size_t)jamHdr.SubfieldLen);
while (ulSubfieldLen > 0L) {
jamSubField = (JAMBINSUBFIELD *)pPos;
pPos += sizeof (JAMBINSUBFIELD);
/*
* Check for corrupted subfields
*/
if ((jamSubField->DatLen < 0) || (jamSubField->DatLen > jamHdr.SubfieldLen))
return FALSE;
switch (jamSubField->LoID) {
case JAMSFLD_MSGID:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
memset(&Msg.Msgid, 0, sizeof(Msg.Msgid));
snprintf(Msg.Msgid, 80, "%s", szBuff);
snprintf(szLine, MAX_LINE_LENGTH, "\001MSGID: %s", szBuff);
MsgText_Add2(szLine);
break;
case JAMSFLD_REPLYID:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf(szLine, MAX_LINE_LENGTH, "\001REPLY: %s", szBuff);
MsgText_Add2(szLine);
break;
case JAMSFLD_PID:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf(szLine, MAX_LINE_LENGTH, "\001PID: %s", szBuff);
MsgText_Add2(szLine);
break;
case JAMSFLD_TRACE:
memcpy(szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf(szLine, MAX_LINE_LENGTH, "\001Via %s", szBuff);
MsgText_Add2(szLine);
break;
case JAMSFLD_FTSKLUDGE:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
if (!strncmp(szBuff, "AREA:", 5))
snprintf(szLine, MAX_LINE_LENGTH, "%s", szBuff);
else {
snprintf(szLine, MAX_LINE_LENGTH, "\001%s", szBuff);
if (strncmp(szLine, "\001REPLYADDR:", 11) == 0) {
snprintf(Msg.ReplyAddr, 80, "%s", szLine+12);
}
if (strncmp(szLine, "\001REPLYTO:", 9) == 0) {
snprintf(Msg.ReplyTo, 80, "%s", szLine+10);
}
if (strncmp(szLine, "\001REPLYADDR", 10) == 0) {
snprintf(Msg.ReplyAddr, 80, "%s", szLine+11);
}
if (strncmp(szLine, "\001REPLYTO", 8) == 0) {
snprintf(Msg.ReplyTo, 80, "%s", szLine+9);
}
}
MsgText_Add2(szLine);
break;
case JAMSFLD_SEENBY2D:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf (szLine, MAX_LINE_LENGTH, "SEEN-BY: %s", szBuff);
if ((New = (LDATA *)malloc(sizeof(LDATA))) != NULL) {
memset(New, 0, sizeof(LDATA));
New->Value = strdup(szLine);
if (Bottom != NULL) {
while (Bottom->Next != NULL)
Bottom = Bottom->Next;
New->Previous = Bottom;
New->Next = Bottom->Next;
if (New->Next != NULL)
New->Next->Previous = New;
Bottom->Next = New;
}
Bottom = New;
}
break;
case JAMSFLD_PATH2D:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf(szLine, MAX_LINE_LENGTH, "\001PATH: %s", szBuff);
if ((New = (LDATA *)malloc(sizeof(LDATA))) != NULL) {
memset(New, 0, sizeof(LDATA));
New->Value = strdup(szLine);
if (Bottom != NULL) {
while (Bottom->Next != NULL)
Bottom = Bottom->Next;
New->Previous = Bottom;
New->Next = Bottom->Next;
if (New->Next != NULL)
New->Next->Previous = New;
Bottom->Next = New;
}
Bottom = New;
}
break;
case JAMSFLD_FLAGS:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf(szLine, MAX_LINE_LENGTH, "\001FLAGS %s", szLine);
MsgText_Add2(szLine);
break;
case JAMSFLD_TZUTCINFO:
memcpy (szBuff, pPos, (int)jamSubField->DatLen);
szBuff[(int)jamSubField->DatLen] = '\0';
snprintf(szBuff, MAX_LINE_LENGTH, "\001TZUTC %s", szLine);
MsgText_Add2(szLine);
break;
default:
break;
}
ulSubfieldLen -= sizeof (JAMBINSUBFIELD) + jamSubField->DatLen;
if (ulSubfieldLen > 0)
pPos += (int)jamSubField->DatLen;
}
}
lseek (fdJdt, jamHdr.TxtOffset, SEEK_SET);
ulTxtLen = jamHdr.TxtLen;
pLine = szLine;
nCol = 0;
SkipNext = FALSE;
do {
if ((unsigned int)(nRead = sizeof (szBuff)) > ulTxtLen)
nRead = (int)ulTxtLen;
nReaded = (int)read (fdJdt, szBuff, nRead);
for (i = 0, pBuff = szBuff; i < nReaded; i++, pBuff++) {
if (*pBuff == '\r') {
*pLine = '\0';
if (pLine > szLine && SkipNext == TRUE) {
pLine--;
while (pLine > szLine && *pLine == ' ')
*pLine-- = '\0';
if (pLine > szLine)
MsgText_Add3(szLine, (int)(strlen (szLine) + 1));
} else
if (SkipNext == FALSE)
MsgText_Add2(szLine);
SkipNext = FALSE;
pLine = szLine;
nCol = 0;
} else
if (*pBuff != '\n') {
*pLine++ = *pBuff;
nCol++;
if (nCol >= nWidth) {
*pLine = '\0';
if (strchr (szLine, ' ') != NULL) {
while (nCol > 1 && *pLine != ' ') {
nCol--;
pLine--;
}
if (nCol > 0) {
while (*pLine == ' ')
pLine++;
strcpy (szWrp, pLine);
}
*pLine = '\0';
} else
szWrp[0] = '\0';
MsgText_Add2(szLine);
strcpy (szLine, szWrp);
pLine = strchr (szLine, '\0');
nCol = (int)strlen (szLine);
SkipNext = TRUE;
}
}
}
ulTxtLen -= nRead;
} while (ulTxtLen > 0);
if (Bottom != NULL) {
while (Bottom->Previous != NULL)
Bottom = Bottom->Previous;
MsgText_Add2(Bottom->Value);
while (Bottom->Next != NULL) {
Bottom = Bottom->Next;
MsgText_Add2(Bottom->Value);
}
while (Bottom != NULL) {
if (Bottom->Previous != NULL)
Bottom->Previous->Next = Bottom->Next;
if (Bottom->Next != NULL)
Bottom->Next->Previous = Bottom->Previous;
New = Bottom;
if (Bottom->Next != NULL)
Bottom = Bottom->Next;
else if (Bottom->Previous != NULL)
Bottom = Bottom->Previous;
else
Bottom = NULL;
free(New->Value);
free(New);
}
}
}
return (RetVal);
}
int JAM_SetLastRead(lastread LR)
{
if (lseek(fdJlr, LastReadRec * sizeof(lastread), SEEK_SET) != -1)
if (write(fdJlr, &LR, sizeof(lastread)) == sizeof(lastread))
return TRUE;
return FALSE;
}
/*
* Unlock the message base
*/
void JAM_UnLock(void)
{
struct flock fl;
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fl.l_start = 0L;
fl.l_len = 1L; /* GoldED locks 1 byte as well */
fl.l_pid = getpid();
if (fcntl(fdHdr, F_SETLK, &fl)) {
WriteError("$Can't unlock JAM message base %s", BaseName);
}
}
/*
* Write message header
*/
int JAM_WriteHeader (unsigned int ulMsg)
{
int RetVal = FALSE;
JAMIDXREC jamIdx;
if (Msg.Id == ulMsg) {
// --------------------------------------------------------------------
// The user is requesting to write the header of the last message
// retrived so our first attempt is to read the last index from the
// file and check if this is the correct one.
// --------------------------------------------------------------------
lseek (fdJdx, tell (fdJdx) - sizeof (jamIdx), SEEK_SET);
if (read (fdJdx, &jamIdx, sizeof (jamIdx)) == sizeof (jamIdx)) {
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == ulMsg)
RetVal = TRUE;
}
}
if (RetVal == FALSE) {
// --------------------------------------------------------------------
// The message requested is not the last retrived or the file pointers
// are not positioned where they should be, so now we attempt to
// retrive the message header scanning the database from the beginning.
// --------------------------------------------------------------------
Msg.Id = 0L;
lseek (fdJdx, 0L, SEEK_SET);
do {
if (read (fdJdx, &jamIdx, sizeof (jamIdx)) == sizeof (jamIdx)) {
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
read (fdHdr, &jamHdr, sizeof (JAMHDR));
if (!(jamHdr.Attribute & MSG_DELETED) && jamHdr.MsgNum == ulMsg)
RetVal = TRUE;
}
} while (RetVal == FALSE && tell (fdJdx) < filelength (fdJdx));
}
if (RetVal == TRUE) {
Msg.Id = jamHdr.MsgNum;
jamHdr.Attribute &= MSG_DELETED;
JAMset_flags();
lseek (fdHdr, jamIdx.HdrOffset, SEEK_SET);
write (fdHdr, &jamHdr, sizeof (JAMHDR));
}
return RetVal;
}
Reference in New Issue View Git Blame Copy Permalink