/***************************************************************************** * * $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)) { /* * Check for GoldED bug, the CRC == ID so the ID is invalid. * Test for a valid CRC to find the right record. */ if ((lr.UserID == lr.UserCRC) && (lr.UserCRC == LR->UserCRC)) { Syslog('m', "Found LR record for user %d using a workaround", LR->UserID); LR->LastReadMsg = lr.LastReadMsg; LR->HighReadMsg = lr.HighReadMsg; return TRUE; } /* * The way it should be. */ if ((lr.UserID != lr.UserCRC) && (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, myrec; 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) { if ((LR.UserID == LR.UserCRC) && LR.UserCRC) { /* * GoldED bug, try to fix it. This might leave double records, we * will deal with that later. TODO: write that code! */ fseek(usrF, usrhdr.hdrsize, SEEK_SET); myrec = 0; while (fread(&usr, usrhdr.recsize, 1, usrF) == 1) { mycrc = StringCRC32(tl(usr.sUserName)); if (LR.UserCRC == mycrc) { LR.UserID = myrec; Syslog('m', "JAM_Pack %s recno %d LastRead UserID set to %d", BaseName, i, myrec); } myrec++; write(fdnJlr, &LR, sizeof(lastread)); } } else { /* * 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; }