goldlib/gmb3/gmohuds2.cpp

//  This may look like C code, but it is really -*- C++ -*-

//  ------------------------------------------------------------------
//  The Goldware Library
//  Copyright (C) 1990-1999 Odinn Sorensen
//  Copyright (C) 1999-2000 Alex. S. Aganichev
//  ------------------------------------------------------------------
//  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: gmohuds2.cpp,v 1.6 2011/12/17 21:46:02 stas_degteff Exp $
//  ------------------------------------------------------------------
//  Hudson / Goldbase msgbase handling
//  ------------------------------------------------------------------


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::raw_close()
{
  GFTRK("HudsRawClose");

  fhtxt.Close();
  fhhdr.Close();
  fhidx.Close();
  fhinf.Close();
  fhlrd.Close();
  fhtoi.Close();
  fhusr.Close();

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::test_open(gfile &__file, const char* __fname, int __oaccess)
{
  GFTRK("HudsTestOpen");

  long _tries = 0;
  __oaccess |= O_RDWR|O_BINARY;

  do
  {
    Path _testfn;
    strcpy(_testfn, AddPath(path, __fname));
    int _omode = (__oaccess & O_CREAT) ? S_STDRW : S_STDRD;

    __file.Open(_testfn, __oaccess, WideSharemode, _omode);
    if (!__file.isopen())
    {
      if (errno == ENOENT)
      {
        if (_tries == 0)
        {
          __oaccess |= O_CREAT;
          _tries++;
          continue;
        }
      }

      // Request the other program to unlock
      if (errno != ENOENT)
        TouchFile(AddPath(path, "mbunlock.now"));

      // Tell the world
      if (PopupLocked(++_tries, false, _testfn) == false)
      {
        // User requested to exit
        WideLog->ErrOpen();
        raw_close();
        WideLog->printf("! A %s msgbase file could not be opened.", __HUDSON ? HUDS_NAME : GOLD_NAME);
        WideLog->printf(": %s.", _testfn);
        WideLog->ErrOSInfo();
        OpenErrorExit();
      }
    }
  }
  while (!__file.isopen());

  // Remove the popup window
  if (_tries)
    PopupLocked(0, 0, NULL);

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::raw_open(int __oaccess, int __all) {

  GFTRK("HudsRawOpen");

  test_open(fhidx, __HUDSON ? "msgidx" HUDS_EXT : "msgidx" GOLD_EXT, __oaccess);
  test_open(fhinf, __HUDSON ? "msginfo" HUDS_EXT : "msginfo" GOLD_EXT, __oaccess);
  test_open(fhlrd, __HUDSON ? "lastread" HUDS_EXT : "lastread" GOLD_EXT, __oaccess);
  test_open(fhtoi, __HUDSON ? "msgtoidx" HUDS_EXT : "msgtoidx" GOLD_EXT, __oaccess);
  if (__all)
  {
    test_open(fhhdr, __HUDSON ? "msghdr" HUDS_EXT : "msghdr" GOLD_EXT, __oaccess);
    test_open(fhtxt, __HUDSON ? "msgtxt" HUDS_EXT : "msgtxt" GOLD_EXT, __oaccess);
    test_open(fhusr, __HUDSON ? "users" HUDS_EXT : "users" GOLD_EXT, __oaccess);
  }

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::raw_open_scan() {

  GFTRK("HudsRawOpenScan");

  raw_open(0, false);

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::refresh() {

  GFTRK("HudsRefresh");

  // (Re)Allocate memory to hold the complete MSGIDX.BBS/DAT
  msgidxsize = fhidx.FileLength();
  msgidxptr = (HudsIdx*)throw_realloc(msgidxptr, (uint)(msgidxsize+sizeof(HudsIdx)));

  // Load MSGIDX.BBS/DAT
  fhidx.LseekSet(0);
  fhidx.Read(msgidxptr, (uint)msgidxsize);

  // Load MSGINFO.BBS/DAT
  fhinf.LseekSet(0);
  fhinf.Read(&msginfo, sizeof(HudsInfo));

  // Load LASTREAD.BBS/DAT
  fhlrd.LseekSet(userno*sizeof(HudsLast));
  fhlrd.Read(lastrec, sizeof(HudsLast));

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::open() {

  GFTRK("HudsWideOpen");

  isopen = 1;
  iswideopen = true;
  ispmscanned = false;
  iswidescanned = false;
  raw_open_scan();
  lock();

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::close() {

  GFTRK("HudsWideClose");

  unlock();
  raw_close();
  throw_release(msgidxptr);
  throw_release(pmscan);
  throw_release(scn);
  iswideopen = false;
  isopen = 0;

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::lock() {

  GFTRK("HudsLock");

  if(not islocked and WideCanLock) {

    long _tries = 0;

    // Try to get the lock
    while (fhinf.Lock(sizeof(HudsInfo)+1, 1) == -1)
    {
      // Tell the world
      if(PopupLocked(++_tries, true, AddPath(path, __HUDSON ? "msginfo" HUDS_EXT : "msginfo" GOLD_EXT)) == false) {

        // User requested to exit
        WideLog->ErrLock();
        raw_close();
        WideLog->printf("! A %s msgbase file could not be locked.", __HUDSON ? HUDS_NAME : GOLD_NAME);
        WideLog->printf(": %smsginfo%s.", path, __HUDSON ? HUDS_EXT : GOLD_EXT);
        WideLog->ErrOSInfo();
        LockErrorExit();
      }

      // Request the other program to unlock
      TouchFile(AddPath(path, "mbunlock.now"));
    }

    // Remove the popup window
    if(_tries)
      PopupLocked(0, 0, NULL);

    // We got the lock
    islocked = true;
  }

  // Refresh msgbase data
  refresh();

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::unlock() {

  GFTRK("HudsUnlock");

  if (islocked and WideCanLock)
  {
    fhinf.Unlock(sizeof(HudsInfo)+1, 1);
    islocked = false;
  }

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsArea<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::lock() {

  wide->lock();
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsArea<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::unlock() {

  wide->unlock();
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::scan() {

  GFTRK("HudsWideScan");

  iswidescanned = true;

  // Alloc scan array
  throw_free(scn);
  scn = (HudsScan*)throw_calloc((__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD), sizeof(HudsScan));

  // Board and scan array pointer
  register int _board;
  register HudsScan* _scan = scn;

  // Init wide scan array
  _board = 0;
  while(_board < (__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD)) {
    _scan->active = msginfo.active[_board];
    _scan->lastread = lastrec[_board];
    _board++;
    _scan++;
  }

  // Setup MSGIDX pointer and counters
  register HudsIdx* _msgidx_ptr = msgidxptr;
  register uint    _msgidx_count = 0;
  register uint    _msgidx_total = (uint)(msgidxsize/sizeof(HudsIdx));
  int         _invalidboards = 0;

  // Scan the index
  while(_msgidx_count < _msgidx_total) {

    // Is the msg not deleted?
    if(_msgidx_ptr->msgno != (__HUDSON ? HUDS_DELETEDMSGNO : GOLD_DELETEDMSGNO)) {

      register int _idxboard = _msgidx_ptr->board;
      if(_idxboard and (_idxboard <= (__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD))) {

        _scan = scn + (_idxboard - 1);

        // Get message number
        _scan->lastmsgno = _msgidx_ptr->msgno;
        _scan->count++;

        // Set first message number
        if(not _scan->firstmsgno)
          _scan->firstmsgno = _scan->lastmsgno;

        // Set lastread pointer
        if((_scan->lastmsgno >= _scan->lastread) and (_scan->lastreadreln == 0)) {
          _scan->lastreadfound = _scan->lastmsgno;
          _scan->lastreadreln = _scan->count - (_scan->lastmsgno != _scan->lastread ? 1 : 0);
        }
      }
      else {
        _invalidboards++;
      }
    }

    // Go to next record
    _msgidx_count++;
    _msgidx_ptr++;
  }

  if(_invalidboards) {
    WideLog->printf("! Found %u msgs with an invalid board number (0 or >%u).", _invalidboards, (__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD));
    WideLog->printf("! In the %s msgbase at %s.", __HUDSON ? HUDS_NAME : GOLD_NAME, path);
    WideLog->printf(": Info: Your msgbase may be partially corrupted.");
    WideLog->printf("+ Advice: Run a msgbase index rebuild/recover utility.");
  }

  // Check/fix boards
  _board = 0;
  _scan = scn;
  while(_board < (__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD)) {

    // Check/fix lastreads
    if(_scan->count and (_scan->lastreadfound != _scan->lastread)) {
      if(_scan->lastread > _scan->lastmsgno)
        _scan->lastreadreln = _scan->count;
      else if(_scan->lastread < _scan->firstmsgno)
        _scan->lastreadreln = 0;
    }

    if(WideDebug) {
      WideLog->printf("- b:%u: t:%u, l:%u, fm:%u, hm:%u, lr:%u, u:%u",
        _board,
        _scan->count,
        _scan->lastreadreln,
        _scan->firstmsgno,
        _scan->lastmsgno,
        _scan->lastread,
        userno
      );
    }

    // Check active message count and log it if different
    if(_scan->active != _scan->count) {
      WideLog->printf("! Counted %u active msgs in %s board %u.", _scan->count, __HUDSON ? HUDS_NAME : GOLD_NAME, _board+1);
      WideLog->printf("! According to msginfo%s there should be %u active msgs.", __HUDSON ? HUDS_EXT : GOLD_EXT, _scan->active);
      WideLog->printf(": Info: A program did not update msginfo%s correctly.", __HUDSON ? HUDS_EXT : GOLD_EXT);
      WideLog->printf("+ Advice: Run a msgbase index rebuild utility.");
    }

    _board++;
    _scan++;
  }

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsArea<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::raw_scan(int __keep_index) {

  GFTRK("HudsRawScan");

  if(!wide)
    wide = (HudsWide*) (__HUDSON ? (void *)hudsonwide : (void *)goldbasewide);

  if(wide->iswideopen and not wide->iswidescanned)
    wide->scan();

  // Get wide scan data if any
  if(wide->scn) {

    // Update area data
    register HudsScan* _scan = wide->scn + (board() - 1);
    Msgn->SetCount(_scan->count);
    lastread = _scan->lastreadreln;
    lastreadentry = _scan->lastreadfound;
  }
  else {

    // Open the msgbase if it wasn't already
    int _was_open = wide->isopen;
    if(not _was_open)
      wide->open();

    // Get the number of active msgs in the area
    register board_t _board = (board_t)board();
    register uint _active = wide->msginfo.active[_board-1];
    register msgn_t _lastread = wide->lastrec[_board-1];

    // Setup pointers and counts
    register uint    _msg_count = 0;
    register HudsIdx* _msgidx_ptr = wide->msgidxptr;
    register uint    _msgidx_count = 0;
    register uint    _msgidx_total = (uint)(wide->msgidxsize/sizeof(HudsIdx));
    register uint    _lastread_reln = 0;

    // (Re)Allocate index
    if(__keep_index)
      Msgn->Resize(_active);

    // Index pointers
    uint32_t* _msgno_ptr = Msgn->tag;

    // Fill index
    uint _firstmsgno = 0;
    uint _lastmsgno = 0;
    uint _lastreadfound = 0;
    while(_msgidx_count < _msgidx_total) {

      // Is it our board and is the msg not deleted?
      if((_msgidx_ptr->board == _board) and (_msgidx_ptr->msgno != (__HUDSON ? HUDS_DELETEDMSGNO : GOLD_DELETEDMSGNO))) {

        // Get message number
        _lastmsgno = _msgidx_ptr->msgno;
        _msg_count++;

        // Set first message number
        if(not _firstmsgno)
          _firstmsgno = _lastmsgno;

        // Transfer data to the index
        if(__keep_index)
          *_msgno_ptr++ = _lastmsgno;

        // Set lastread pointer
        if((_lastmsgno >= _lastread) and (_lastread_reln == 0)) {
          _lastreadfound = _lastmsgno;
          _lastread_reln = _msg_count - (_lastmsgno != _lastread ? 1 : 0);
        }

        // Break loop as soon as we have all we need
        if(_msg_count == _active)
          break;
      }

      // Go to next record
      _msgidx_count++;
      _msgidx_ptr++;
    }

    // If the exact lastread was not found
    if(_msg_count and (_lastreadfound != _lastread)) {

      // Higher than highest or lower than lowest?
      if(_lastread > _lastmsgno)
        _lastread_reln = _msg_count;
      else if(_lastread < _firstmsgno)
        _lastread_reln = 0;
    }

    // Check active message count and log it if different
    if(_active != _msg_count) {
      WideLog->printf("! Counted %u active msgs in %s board %u (%s).", _msg_count, __HUDSON ? HUDS_NAME : GOLD_NAME, board(), echoid());
      WideLog->printf("! According to msginfo%s there should be %u active msgs.", __HUDSON ? HUDS_EXT : GOLD_EXT, _active);
      WideLog->printf(": Info: A program did not update msginfo%s correctly.", __HUDSON ? HUDS_EXT : GOLD_EXT);
      WideLog->printf("+ Advice: Run a msgbase index rebuild utility.");
    }

    // Update area data
    Msgn->SetCount(_msg_count);
    lastread = _lastread_reln;
    lastreadentry = _lastreadfound;

    if(WideDebug) {
      WideLog->printf("- b:%u: t:%u, l:%u, fm:%u, hm:%u, lr:%u, u:%u",
        board(),
        Msgn->Count(),
        lastread,
        _firstmsgno,
        _lastmsgno,
        _lastread,
        wide->userno
      );
    }

    // Close the msgbase again if we opened it in here
    if(not _was_open)
      wide->close();
  }

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsArea<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::scan() {

  GFTRK("HudsScan");

  raw_scan(true);

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsArea<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::scan_area() {

  GFTRK("HudsScanArea");

  raw_scan(false);

  GFTRK(0);
}


//  ------------------------------------------------------------------

#define HudsIdxCmp(a,b) ((a.board-b.board != 0) ? a.board-b.board : ((int)(a.msgno-b.msgno)))


//  ------------------------------------------------------------------

#define TOIDXBUFSZ 100u
#define PMSCANBUFSZ 50u

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::realloc_pm_scan() {

  pmscan = (HudsIdx*)throw_realloc(pmscan, (pmscantotal+PMSCANBUFSZ)*sizeof(HudsIdx));
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsWide<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::scan_pm() {

  GFTRK("HudsWideScanPM");

  if(not iswidescanned)
    scan();

  ispmscanned = true;

  HudsToIdx* toidxbuf = (HudsToIdx*)throw_calloc(TOIDXBUFSZ, sizeof(HudsToIdx));
  uint totrecs = (uint)(fhtoi.FileLength() / sizeof(HudsToIdx));
  HudsIdx* idxptr = msgidxptr;
  throw_release(pmscan);
  pmscantotal = 0;
  int invalidboards = 0;
  int gotpm, idxboard, umax, u;
  uint getrecs, rec;
  HudsToIdx* toidx;

  do {

    rec = 0;
    gotpm = false;
    getrecs = MinV(TOIDXBUFSZ, totrecs);
    fhtoi.Read(toidxbuf, getrecs*sizeof(HudsToIdx));

    for(toidx=toidxbuf; rec<getrecs; idxptr++,toidx++,rec++) {

      // Skip deleted msgs
      if(idxptr->msgno == (__HUDSON ? HUDS_DELETEDMSGNO : GOLD_DELETEDMSGNO))
        continue;

      // Skip msgs in invalid boards
      idxboard = idxptr->board;
      if(not (idxboard and (idxboard <= (__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD)))) {
        invalidboards++;
        continue;
      }

      // If after lastread
      if(idxptr->msgno <= scn[idxboard-1].lastreadfound)
        continue;

      // Convert name string
      strnp2c(toidx->name, sizeof(HudsToIdx)-1);

      // Is it a PM?
      umax = (WidePersonalmail & PM_ALLNAMES) ? WideUsernames : 1;
      for(u=0; u<umax; u++) {
        if(strieql(toidx->name, WideUsername[u])) {
          gotpm = true;
          break;
        }
      }

      if(gotpm) {
        if((pmscantotal % PMSCANBUFSZ) == 0)
          realloc_pm_scan();
        pmscan[pmscantotal++] = *idxptr;
        scn[idxboard-1].pmcount++;
        gotpm = false;
      }
    }
    totrecs -= getrecs;
  } while(totrecs);

  throw_free(toidxbuf);
  pmscan = (HudsIdx*)throw_realloc(pmscan, (pmscantotal+1)*sizeof(HudsIdx));

  // Sort all pm records in board/msgno order
  for(uint k=pmscantotal >> 1; k; k >>= 1)
    for(uint i=k; i < pmscantotal; i++)
      for(uint j=i-k; (j >= 0) and HudsIdxCmp(pmscan[j], pmscan[j+k]) > 0; j-=k) {
        HudsIdx e = pmscan[j];
        pmscan[j] = pmscan[j+k];
        pmscan[j+k] = e;
      }

  if(invalidboards) {
    WideLog->printf("! Found %u msgs with an invalid board number (0 or >%u).", invalidboards, (__HUDSON ? HUDS_MAXBOARD : GOLD_MAXBOARD));
    WideLog->printf("! In the %s msgbase at %s.", __HUDSON ? HUDS_NAME : GOLD_NAME, path);
    WideLog->printf(": Info: Your msgbase may be partially corrupted.");
    WideLog->printf("+ Advice: Run a msgbase index rebuild/recover utility.");
  }

  GFTRK(0);
}


//  ------------------------------------------------------------------

template <class msgn_t, class rec_t, class attr_t, class board_t, class last_t, bool __HUDSON>
void _HudsArea<msgn_t, rec_t, attr_t, board_t, last_t, __HUDSON>::scan_area_pm() {

  GFTRK("HudsScanAreaPM");

  PMrk->ResetAll();

  if(!wide)
    wide = (HudsWide*) (__HUDSON ? (void *)hudsonwide : (void *)goldbasewide);

  if(wide->iswideopen and not wide->ispmscanned)
    wide->scan_pm();

  // Get wide scan data if any
  if(wide->scn) {

    register board_t _board = (board_t)board();
    register HudsScan* _scan = wide->scn + (_board - 1);

    if(wide->pmscan) {
      if(_scan->pmcount) {

        register HudsIdx* pmscanptr = wide->pmscan;
        while(pmscanptr->board != _board)
          pmscanptr++;

        register uint n = 0;
        register uint cnt = _scan->pmcount;
        while(n < cnt) {
          PMrk->Append(pmscanptr->msgno);
          pmscanptr++;
          n++;
        }
      }
    }

    // Update area data
    Msgn->SetCount(_scan->count);
    lastread = _scan->lastreadreln;
    lastreadentry = _scan->lastreadfound;

    if(WideDebug) {
      WideLog->printf("- b:%u: t:%u, l:%u, fm:%u, hm:%u, lr:%u, u:%u, pm:%i",
        _board,
        _scan->count,
        _scan->lastreadreln,
        _scan->firstmsgno,
        _scan->lastmsgno,
        _scan->lastread,
        wide->userno,
        PMrk->Count()
      );
    }

  }
  else {
    if(WideDebug)
      WideLog->printf("- Oops!  Fell into empty bracket.");
  }

  GFTRK(0);
}


//  ------------------------------------------------------------------