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.
deb-goldedplus/goldlib/gmb3/gmopcbd2.cpp
2002-05-12 13:07:37 +00:00

402 lines
9.7 KiB
C++

// This may look like C code, but it is really -*- C++ -*-
// ------------------------------------------------------------------
// The Goldware Library
// Copyright (C) 1990-1999 Odinn Sorensen
// ------------------------------------------------------------------
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library 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
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this program; if not, write to the Free
// Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
// MA 02111-1307, USA
// ------------------------------------------------------------------
// $Id$
// ------------------------------------------------------------------
// PCBoard msgbase handling.
// ------------------------------------------------------------------
#include <gdbgerr.h>
#include <gmemdbg.h>
#include <gdbgtrk.h>
#include <gstrall.h>
#include <gutlmisc.h>
#include <gmoprot.h>
#include <gmopcbd.h>
// ------------------------------------------------------------------
void PcbArea::data_open() {
wide = pcbwide;
data = pcbdata + (pcbdatano++);
data->fhmsg = data->fhidx = -1;
memset(&data->base, 0x20, sizeof(PcbBase));
data->base.highmsgno = 0;
data->base.lowmsgno = 0;
data->base.active = 0;
}
// ------------------------------------------------------------------
void PcbArea::data_close() {
pcbdatano--;
}
// ------------------------------------------------------------------
int PcbWideTestOpen(char* __file) {
GFTRK("PcbWideTestOpen");
int _fh;
long _tries = 0;
do {
_fh = ::sopen(__file, O_RDWR|O_BINARY|O_CREAT, WideSharemode, S_STDRW);
if(_fh == -1) {
// Tell the world
if(PopupLocked(++_tries, false, __file) == false) {
WideLog->ErrOpen();
PcbWideClose();
WideLog->printf("! A PCBoard msgbase file could not be opened.");
WideLog->printf(": %s.", __file);
WideLog->ErrOSInfo();
OpenErrorExit();
}
}
} while(_fh == -1);
// Remove the popup window
if(_tries)
PopupLocked(0, 0, NULL);
GFTRK(NULL);
return _fh;
}
// ------------------------------------------------------------------
void PcbWideOpen() {
GFTRK("PcbWideOpen");
if(not pcbwide->isopen) {
pcbwide->fhusr = PcbWideTestOpen(pcbwide->users);
pcbwide->fhinf = PcbWideTestOpen(pcbwide->usersinf);
pcbwide->user->fh = pcbwide->fhusr;
pcbwide->user->fhinf = pcbwide->fhinf;
// Read lastreads from USERS file
lseekset(pcbwide->fhusr, (long)pcbwide->userno*(long)sizeof(PcbUsers));
read(pcbwide->fhusr, &pcbwide->usersrec, sizeof(PcbUsers));
int _maxlr = MinV(pcbwide->numareas, 40);
for(int n=0; n<_maxlr; n++)
pcbwide->lastread[n] = B2L(pcbwide->usersrec.lastmsgread[n]);
// Read lastreads from USERS.INF file
if(pcbwide->extconflen) {
long _offset = (pcbwide->usersrec.usersinfrec-1)*pcbwide->usershdr.totalrecsize;
_offset += pcbwide->usershdrsize;
_offset += pcbwide->usershdr.sizeofrec;
_offset += 2 * pcbwide->confbytelen;
_offset += 3 * pcbwide->extconflen;
lseekset(pcbwide->fhinf, _offset);
read(pcbwide->fhinf, pcbwide->lastread+40, (pcbwide->numareas-40)*sizeof(long));
}
pcbwide->isopen = true;
}
GFTRK(NULL);
}
// ------------------------------------------------------------------
void PcbWideClose() {
GFTRK("PcbWideClose");
if(pcbwide->isopen) {
if(pcbwide->fhinf != -1) ::close(pcbwide->fhinf); pcbwide->fhinf = -1;
if(pcbwide->fhusr != -1) ::close(pcbwide->fhusr); pcbwide->fhusr = -1;
pcbwide->isopen = false;
}
GFTRK(NULL);
}
// ------------------------------------------------------------------
void PcbArea::raw_close() {
GFTRK("PcbRawClose");
if(data->fhidx != -1) ::close(data->fhidx); data->fhidx = -1;
if(data->fhmsg != -1) ::close(data->fhmsg); data->fhmsg = -1;
GFTRK(NULL);
}
// ------------------------------------------------------------------
int PcbArea::test_open(const char* __file) {
GFTRK("PcbArea::test_open");
int _fh;
long _tries = 0;
do {
_fh = ::sopen(__file, O_RDWR|O_BINARY|O_CREAT, WideSharemode, S_STDRW);
if(_fh == -1) {
// Tell the world
if(PopupLocked(++_tries, false, __file) == false) {
WideLog->ErrOpen();
raw_close();
PcbWideClose();
WideLog->printf("! A PCBoard msgbase file could not be opened.");
WideLog->printf(": %s.", __file);
WideLog->ErrOSInfo();
OpenErrorExit();
}
}
} while(_fh == -1);
// Remove the popup window
if(_tries)
PopupLocked(0, 0, NULL);
GFTRK(NULL);
return _fh;
}
// ------------------------------------------------------------------
void PcbArea::raw_open() {
GFTRK("PcbRawOpen");
if(not just_scanning)
data->fhmsg = test_open(real_path());
data->fhidx = test_open(AddPath(real_path(), ".idx"));
GFTRK(NULL);
}
// ------------------------------------------------------------------
void PcbArea::raw_scan(int __keep_index, int __scanpm) {
GFTRK("PcbRawScan");
// Open the msgbase if it wasn't already
int _was_open = isopen;
if(not _was_open) {
if(not __keep_index)
just_scanning = true;
if(ispacked()) {
const char* newpath = Unpack(path());
if(newpath == NULL)
packed(false);
set_real_path(newpath ? newpath : path());
}
isopen++;
data_open();
raw_open();
just_scanning = false;
}
int _was_wideopen = wide->isopen;
if(not _was_wideopen)
PcbWideOpen();
// Load the base header
if(__keep_index) {
lseekset(data->fhmsg, 0);
read(data->fhmsg, &data->base, sizeof(PcbBase));
data->base.highmsgno = B2L(data->base.highmsgno);
data->base.lowmsgno = B2L(data->base.lowmsgno);
data->base.active = B2L(data->base.active);
}
// Get some sizes
long _idxlen = filelength(data->fhidx);
uint _idxsize = (uint)_idxlen;
uint _idxtotal = _idxsize / sizeof(PcbIdx);
// (Re)Allocate message index
if(__keep_index)
Msgn->Resize(_idxtotal);
// Allocate buffer to hold .IDX data
PcbIdx* _idxbuf = (PcbIdx*)throw_malloc(_idxsize+1);
// Read the entire .IDX file into memory
lseekset(data->fhidx, 0);
read(data->fhidx, _idxbuf, _idxsize);
// Variables for the loop
register uint _active = 0;
register ulong _firstmsgno = 0;
register ulong _lastmsgno = 0;
register ulong _lastreadfound = 0;
register ulong _totalmsgs = _idxtotal;
register ulong _lastread = wide->lastread[board()];
register uint _lastread_reln = 0;
register ulong* _msgndxptr = Msgn->tag;
register PcbIdx* _idxptr = _idxbuf;
// Fill message index
register uint n = 0;
while((n++) < _totalmsgs) {
if(_idxptr->offset > 0) {
_active++;
_lastmsgno = _idxptr->num;
if(not _firstmsgno)
_firstmsgno = _lastmsgno;
if(__keep_index)
*_msgndxptr++ = _lastmsgno;
if((_lastmsgno >= _lastread) and (_lastread_reln == 0)) {
_lastreadfound = _lastmsgno;
_lastread_reln = (uint)(_active - (_lastmsgno != _lastread ? 1 : 0));
}
}
_idxptr++;
}
// If the exact lastread was not found
if(_active and (_lastreadfound != _lastread)) {
// Higher than highest or lower than lowest?
if(_lastread > _lastmsgno)
_lastread_reln = _active;
else if(_lastread < _firstmsgno)
_lastread_reln = 0;
}
// Update area data
Msgn->SetCount(_active);
lastread = _lastread_reln;
lastreadentry = _lastreadfound;
// Scan for personal mail
if(__scanpm) {
int umax = (WidePersonalmail & PM_ALLNAMES) ? WideUsernames : 1;
PcbName* uname = (PcbName*)throw_calloc(umax, sizeof(PcbName));
for(int un=0; un<umax; un++)
strsetsz(strxcpy(uname[un], WideUsername[un], sizeof(PcbName)), 25);
PMrk->ResetAll();
register uint n = lastread + 1;
register uint cnt = Msgn->Count();
register int gotpm = false;
while(n <= cnt) {
PcbIdx* idx = _idxbuf + (uint)(Msgn->at(n-1) - data->base.lowmsgno);
for(int u=0; u<umax; u++) {
if(strnieql(idx->to, uname[u], 25)) {
gotpm = true;
break;
}
}
if(gotpm) {
switch(idx->status) {
case '+':
case '-':
case '`':
case '^':
case '#':
break;
default:
PMrk->Append(idx->num);
}
gotpm = false;
}
n++;
}
throw_free(uname);
}
// Free the .IDX buffer
throw_free(_idxbuf);
if(not _was_wideopen)
PcbWideClose();
// Close the msgbase again if we opened it in here
if(not _was_open) {
raw_close();
data_close();
if(ispacked()) {
CleanUnpacked(real_path());
}
isopen--;
}
GFTRK(NULL);
}
// ------------------------------------------------------------------
void PcbArea::scan() {
GFTRK("PcbScan");
raw_scan(true);
GFTRK(NULL);
}
// ------------------------------------------------------------------
void PcbArea::scan_area() {
GFTRK("PcbScanArea");
raw_scan(false);
GFTRK(NULL);
}
// ------------------------------------------------------------------
void PcbArea::scan_area_pm() {
GFTRK("PcbScanArea*M");
raw_scan(true, true);
Msgn->Reset();
GFTRK(NULL);
}
// ------------------------------------------------------------------