740 lines
19 KiB
C++
740 lines
19 KiB
C++
// This may look like C code, but it is really -*- C++ -*-
|
|
|
|
// ------------------------------------------------------------------
|
|
// The Goldware Library
|
|
// Copyright (C) 1990-1999 Odinn Sorensen
|
|
// Copyright (C) 1999-2000 Alexander 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$
|
|
// ------------------------------------------------------------------
|
|
// FrontDoor Nodelist Indexing.
|
|
// Based on code kindly provided by Scott Dudley.
|
|
// ------------------------------------------------------------------
|
|
|
|
#include <gfilutil.h>
|
|
#include <gstrall.h>
|
|
#include <gftnnlfd.h>
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline const _FDUdx& ftn_frontdoor_nodelist_index::namerec() const {
|
|
|
|
return block.node.name[node-1];
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline const _FDFdx& ftn_frontdoor_nodelist_index::addrrec() const {
|
|
|
|
return block.node.addr[node-1];
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline const _FDGdx& ftn_frontdoor_nodelist_index::noderec() const {
|
|
|
|
return namebrowse ? *((_FDGdx*)&block.node.name[node-1]) : *((_FDGdx*)&block.node.addr[node-1]);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
int ftn_frontdoor_nodelist_index::namecmp() const {
|
|
|
|
#ifdef DEBUG
|
|
printf("[%s] [%-15.15s] ", searchname, namerec().name);
|
|
#endif
|
|
|
|
const char* a = searchname;
|
|
const char* b = namerec().name;
|
|
int n = 1;
|
|
while(n <= 15) {
|
|
int d = (int)((byte)*a) - (int)((byte)*b);
|
|
if(d != 0)
|
|
return d > 0 ? n : -n;
|
|
a++;
|
|
b++;
|
|
n++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::getaddr(ftn_addr& addr) const {
|
|
|
|
if(namebrowse) {
|
|
addr.zone = (word)((namerec().zone_hi << 8) | namerec().zone_lo);
|
|
addr.net = (word)((namerec().net_hi << 8) | namerec().net_lo);
|
|
addr.node = (word)((namerec().node_hi << 8) | namerec().node_lo);
|
|
addr.point = (word)((namerec().point_hi << 8) | namerec().point_lo);
|
|
}
|
|
else {
|
|
addr.zone = (word)((addrrec().zone_hi << 8) | addrrec().zone_lo);
|
|
addr.net = (word)((addrrec().net_hi << 8) | addrrec().net_lo);
|
|
addr.node = (word)((addrrec().node_hi << 8) | addrrec().node_lo);
|
|
addr.point = (word)((addrrec().point_hi << 8) | addrrec().point_lo);
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
int ftn_frontdoor_nodelist_index::addrcmp() const {
|
|
|
|
ftn_addr currentaddr;
|
|
getaddr(currentaddr);
|
|
|
|
#ifdef DEBUG
|
|
printf("[%d:%d/%d.%d] [%d:%d/%d.%d] ",
|
|
searchaddr.zone, searchaddr.net, searchaddr.node, searchaddr.point,
|
|
currentaddr.zone, currentaddr.net, currentaddr.node, currentaddr.point
|
|
);
|
|
#endif
|
|
|
|
return searchaddr.compare(currentaddr);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::getstatus(char* _status, int type) const {
|
|
|
|
switch(type) {
|
|
case ISZC: strcpy(_status, "Zone"); break;
|
|
case ISRC: strcpy(_status, "Region"); break;
|
|
case ISNC: strcpy(_status, "Host"); break;
|
|
case ISHUB: strcpy(_status, "Hub"); break;
|
|
case ISPVT: strcpy(_status, "Pvt"); break;
|
|
case ISHOLD: strcpy(_status, "Hold"); break;
|
|
case ISDOWN: strcpy(_status, "Down"); break;
|
|
case ISPOINT: strcpy(_status, "Point"); break;
|
|
default: *_status = NUL;
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::fetchdata() {
|
|
|
|
bool infdpvt = !!(noderec().nlofs & IN_FDNET);
|
|
bool infdpoint = !!(noderec().nlofs & IN_FDPOINT);
|
|
bool infdnode = !!(noderec().nlofs & IN_FDNODE);
|
|
|
|
if(infdnode) {
|
|
|
|
int fd = ::sopen(AddPath(nlpath, "FDNODE.FDA"), O_RDONLY|O_BINARY, SH_DENYNO, S_STDRD);
|
|
if(fd != -1) {
|
|
_FDFdn fda;
|
|
while(read(fd, &fda, sizeof(_FDFdn)) == sizeof(_FDFdn)) {
|
|
if(not fda.erased) {
|
|
if((fda.zone == data.addr.zone) and (fda.net == data.addr.net) and (fda.node == data.addr.node) and (fda.point == data.addr.point)) {
|
|
strnp2cc(data.name, fda.user, 36);
|
|
strnp2cc(data.system, fda.name, 30);
|
|
strnp2cc(data.phone, fda.telephone, 40);
|
|
strnp2cc(data.location, fda.location, 40);
|
|
switch(fda.maxbaud) {
|
|
case ISBAUD300 : strcpy(data.baud, "300"); break;
|
|
case ISBAUD1200 : strcpy(data.baud, "1200"); break;
|
|
case ISBAUD2400 : strcpy(data.baud, "2400"); break;
|
|
case ISBAUD4800 : strcpy(data.baud, "4800"); break;
|
|
case ISBAUD7200 : strcpy(data.baud, "7200"); break;
|
|
case ISBAUD9600 : strcpy(data.baud, "9600"); break;
|
|
case ISBAUD12000 : strcpy(data.baud, "12000"); break;
|
|
case ISBAUD14400 : strcpy(data.baud, "14400"); break;
|
|
case ISBAUD16800 : strcpy(data.baud, "16800"); break;
|
|
case ISBAUD19200 : strcpy(data.baud, "19200"); break;
|
|
case ISBAUD38400 : strcpy(data.baud, "38400"); break;
|
|
case ISBAUD57600 : strcpy(data.baud, "57600"); break;
|
|
case ISBAUD64000 : strcpy(data.baud, "64000"); break;
|
|
case ISBAUD76800 : strcpy(data.baud, "76800"); break;
|
|
case ISBAUD115200: strcpy(data.baud, "115200"); break;
|
|
default: *data.baud = NUL;
|
|
}
|
|
getstatus(data.status, fda.status);
|
|
*data.flags = NUL;
|
|
long c = fda.capability;
|
|
char* f = data.flags;
|
|
if(c & CMflag) strcat(f, "CM,");
|
|
if(c & MOflag) strcat(f, "MO,");
|
|
if(c & LOflag) strcat(f, "LO,");
|
|
if(c & V32flag) strcat(f, "V32,");
|
|
if(c & V32bflag) strcat(f, "V32B,");
|
|
if(c & V33flag) strcat(f, "V33,");
|
|
if(c & V34flag) strcat(f, "V34,");
|
|
if(c & V42flag) strcat(f, "V42,");
|
|
if(c & V42bflag) strcat(f, "V42B,");
|
|
if(c & MNPflag) strcat(f, "MNP,");
|
|
if(c & H96flag) strcat(f, "H96,");
|
|
if(c & HSTflag) strcat(f, "HST,");
|
|
if(c & HST14flag) strcat(f, "H14,");
|
|
if(c & HST16flag) strcat(f, "H16,");
|
|
if(c & MAXflag) strcat(f, "MAX,");
|
|
if(c & PEPflag) strcat(f, "PEP,");
|
|
if(c & ZYXflag) strcat(f, "ZYX,");
|
|
if(c & XAflag) strcat(f, "XA,");
|
|
if(c & XBflag) strcat(f, "XB,");
|
|
if(c & XCflag) strcat(f, "XC,");
|
|
if(c & XPflag) strcat(f, "XP,");
|
|
if(c & XRflag) strcat(f, "XR,");
|
|
if(c & XWflag) strcat(f, "XW,");
|
|
if(c & XXflag) strcat(f, "XX,");
|
|
if(c & FAXflag) strcat(f, "FAX,");
|
|
if(c & UISDNAflag) strcat(f, "V110L,");
|
|
if(c & UISDNBflag) strcat(f, "V110H,");
|
|
if(c & UISDNCflag) strcat(f, "X75,");
|
|
if(*f) f[strlen(f)-1] = NUL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
::close(fd);
|
|
}
|
|
}
|
|
else {
|
|
|
|
int fd = infdpvt ? pfd : (infdpoint ? ppfd : nfd);
|
|
long offset = noderec().nlofs & ~(IN_FDNET|IN_FDPOINT);
|
|
|
|
char buf[256];
|
|
buf[255] = NUL;
|
|
|
|
lseek(fd, offset, SEEK_SET);
|
|
read(fd, buf, 255);
|
|
if(*buf != ';') {
|
|
|
|
char* end = strchr(buf, '\r');
|
|
if(end)
|
|
*end = NUL;
|
|
|
|
strchg(strtrim(buf), '_', ' ');
|
|
|
|
*data.name = NUL;
|
|
*data.system = NUL;
|
|
*data.location = NUL;
|
|
*data.phone = NUL;
|
|
*data.flags = NUL;
|
|
*data.baud = NUL;
|
|
|
|
char* q = buf;
|
|
char* p = strchr(buf, ',');
|
|
if(p) {
|
|
*p++ = NUL;
|
|
strxcpy(data.system, q, sizeof(data.system));
|
|
p = strchr((q=p), ',');
|
|
if(p) {
|
|
*p++ = NUL;
|
|
strxcpy(data.location, q, sizeof(data.location));
|
|
p = strchr((q=p), ',');
|
|
if(p) {
|
|
*p++ = NUL;
|
|
strxcpy(data.name, q, sizeof(data.name));
|
|
p = strchr((q=p), ',');
|
|
if(p) {
|
|
*p++ = NUL;
|
|
strxcpy(data.phone, q, sizeof(data.phone));
|
|
p = strchr((q=p), ',');
|
|
sprintf(data.baud, "%lu", atol(q));
|
|
if(p)
|
|
strxcpy(data.flags, p+1, sizeof(data.flags));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
getstatus(data.status, namebrowse ? namerec().type : addrrec().type);
|
|
}
|
|
|
|
data.addr.make_string(data.address);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
#ifdef DEBUG
|
|
void ftn_frontdoor_nodelist_index::printnode() const {
|
|
|
|
printf("<%05d.%05d.%05d.%d> <%02d:%02d> ",
|
|
blockno,
|
|
block.info.index,
|
|
noderec().block_num,
|
|
depth,
|
|
block.info.nodes,
|
|
node
|
|
);
|
|
}
|
|
#endif
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::getnodedata() {
|
|
|
|
#ifdef DEBUG
|
|
printnode();
|
|
#endif
|
|
getaddr(data.addr);
|
|
fetchdata();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::getblock() {
|
|
|
|
lseek(xfd, (long)blockno*(long)blocksize, SEEK_SET);
|
|
read(xfd, &block, blocksize);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::push() {
|
|
|
|
stack[depth].blockno = blockno;
|
|
stack[depth].block_num = noderec().block_num;
|
|
stack[depth].maxnodes = block.info.nodes;
|
|
stack[depth].node = node;
|
|
depth++;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::pop() {
|
|
|
|
depth--;
|
|
node = stack[depth].node;
|
|
blockno = stack[depth].blockno;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::search() {
|
|
|
|
xfd = namebrowse ? ufd : fdfd;
|
|
blocksize = namebrowse ? sizeof(_FDUdb) : sizeof(_FDFdb);
|
|
|
|
// Read beginning control block
|
|
lseek(xfd, 0L, SEEK_SET);
|
|
read(xfd, &ctl, sizeof(_FDCtl));
|
|
|
|
// Now trace down the tree, starting at the master index
|
|
exactmatch = false;
|
|
int diff = 0;
|
|
int prevdiff = 0;
|
|
blockno = ctl.hdr.master_idx;
|
|
maxblockno = (uint)(lseek(xfd, 0L, SEEK_END)/blocksize);
|
|
depth = 0;
|
|
node = 1;
|
|
push();
|
|
|
|
// Do one block at a time...
|
|
while((not exactmatch) and (blockno < maxblockno)) {
|
|
|
|
// Get one block
|
|
node = 0;
|
|
getblock();
|
|
|
|
// Scan all nodes in this block to find a match
|
|
lastblockno = block.info.index;
|
|
do {
|
|
node++;
|
|
if(namebrowse) {
|
|
#ifdef DEBUG
|
|
printnode();
|
|
#endif
|
|
prevdiff = diff;
|
|
diff = namecmp();
|
|
#ifdef DEBUG
|
|
printf("{%d}\n", diff);
|
|
#endif
|
|
if(diff <= 0) {
|
|
if(diff == 0) {
|
|
exactmatch = true;
|
|
}
|
|
break;
|
|
}
|
|
lastblockno = namerec().block_num;
|
|
}
|
|
else {
|
|
#ifdef DEBUG
|
|
printnode();
|
|
#endif
|
|
prevdiff = diff;
|
|
diff = addrcmp();
|
|
#ifdef DEBUG
|
|
printf("{%d}\n", diff);
|
|
#endif
|
|
if(diff <= 0) {
|
|
if(diff == 0) {
|
|
exactmatch = true;
|
|
}
|
|
break;
|
|
}
|
|
lastblockno = addrrec().block_num;
|
|
}
|
|
} while(node < block.info.nodes);
|
|
|
|
if(not exactmatch) {
|
|
if(lastblockno) {
|
|
push();
|
|
blockno = lastblockno;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(diff == 0) {
|
|
#ifdef DEBUG
|
|
printf("Gotcha!\n");
|
|
#endif
|
|
while(previous()) {
|
|
if(not exactmatch) {
|
|
next();
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else if((prevdiff > 0) and (diff < 0)) {
|
|
if(absolute(prevdiff) > absolute(diff)) {
|
|
#ifdef DEBUG
|
|
printf("Begin lookup at previous blockno.\n");
|
|
#endif
|
|
prevnode();
|
|
}
|
|
}
|
|
else {
|
|
#ifdef DEBUG
|
|
printf("Begin lookup at current blockno.\n");
|
|
#endif
|
|
}
|
|
|
|
getnodedata();
|
|
|
|
return exactmatch;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::prevnode() {
|
|
|
|
if(node == 1) {
|
|
if(blockno == 1)
|
|
return false;
|
|
if(depth > 0) {
|
|
pop();
|
|
getblock();
|
|
node--;
|
|
if(node <= 0) {
|
|
blockno = block.info.index;
|
|
getblock();
|
|
node = block.info.nodes;
|
|
}
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
node--;
|
|
if(noderec().block_num) {
|
|
node++;
|
|
push();
|
|
node--;
|
|
blockno = noderec().block_num;
|
|
getblock();
|
|
node = block.info.nodes;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::nextnode() {
|
|
|
|
if(noderec().block_num) {
|
|
// Current node has a block. Go to it.
|
|
node++;
|
|
push();
|
|
node--;
|
|
blockno = noderec().block_num;
|
|
node = 1;
|
|
getblock();
|
|
}
|
|
else if(node >= block.info.nodes) {
|
|
// Reached end of nodes in current block.
|
|
if(depth > 0) {
|
|
if((stack[depth-1].node == stack[depth-1].maxnodes) and (stack[depth-1].block_num == blockno))
|
|
return false;
|
|
// Go back to previous block
|
|
pop();
|
|
getblock();
|
|
}
|
|
else {
|
|
// Reached final leaf
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
node++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
ftn_frontdoor_nodelist_index::ftn_frontdoor_nodelist_index() {
|
|
|
|
fdfd = nfd = pfd = ppfd = ufd = -1;
|
|
is_intermail = false;
|
|
isopen = false;
|
|
blocksize = 0;
|
|
depth = 0;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
ftn_frontdoor_nodelist_index::~ftn_frontdoor_nodelist_index() {
|
|
|
|
if(isopen)
|
|
close();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::open() {
|
|
|
|
if(isopen)
|
|
close();
|
|
|
|
if(fexist(AddPath(nlpath, "IMNODE.CTL")))
|
|
is_intermail = true;
|
|
|
|
// Open the nodelist binary file first
|
|
fdfd = ::sopen(AddPath(nlpath, "NODELIST.FDX"), O_RDONLY|O_BINARY, SH_DENYNO, S_STDRD);
|
|
if(fdfd == -1) {
|
|
close();
|
|
return false;
|
|
}
|
|
|
|
// Read the control block up front
|
|
read(fdfd, &ctl, sizeof(_FDCtl));
|
|
|
|
// Now use that info to open the primary nodelist
|
|
Path primary;
|
|
sprintf(nodelist, "NODELIST.%3.3s", ctl.nl_ext);
|
|
sprintf(primary, "%s%s", nlpath, nodelist);
|
|
nfd = ::sopen(primary, O_RDONLY | O_BINARY, SH_DENYNO, S_STDRD);
|
|
// Don't check for failure, since there may not be a primary nodelist!
|
|
|
|
// Open the userlist file
|
|
ufd = ::sopen(AddPath(nlpath, "USERLIST.FDX"), O_RDONLY|O_BINARY, SH_DENYNO, S_STDRD);
|
|
if(ufd == -1) {
|
|
close();
|
|
return false;
|
|
}
|
|
|
|
// Failing to open the private nodelist is not an error, since there may not be one!
|
|
pfd = ::sopen(AddPath(nlpath, is_intermail ? "IMNET.PVT" : "FDNET.PVT"), O_RDONLY|O_BINARY, SH_DENYNO, S_STDRD);
|
|
|
|
// Failing to open the point nodelist is not an error, since there may not be one!
|
|
ppfd = ::sopen(AddPath(nlpath, is_intermail ? "IMPOINT.PVT" : "FDPOINT.PVT"), O_RDONLY|O_BINARY, SH_DENYNO, S_STDRD);
|
|
|
|
isopen = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::close() {
|
|
|
|
if(fdfd != -1) ::close(fdfd); fdfd = -1;
|
|
if(nfd != -1) ::close(nfd); nfd = -1;
|
|
if(pfd != -1) ::close(pfd); pfd = -1;
|
|
if(ppfd != -1) ::close(ppfd); ppfd = -1;
|
|
if(ufd != -1) ::close(ufd); ufd = -1;
|
|
|
|
isopen = false;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::find(const char* lookup_name) {
|
|
|
|
char buf[80], tmp[80];
|
|
|
|
strcpy(tmp, lookup_name);
|
|
namebrowse = true;
|
|
char* ptr = strrchr(tmp, ' ');
|
|
if(ptr) {
|
|
if(ptr == (tmp+strlen(tmp)-1)) {
|
|
while((*ptr == ' ') and (ptr > tmp))
|
|
ptr--;
|
|
ptr++;
|
|
}
|
|
*ptr = NUL;
|
|
sprintf(buf, "%s %s", ptr+1, tmp);
|
|
*ptr = ' ';
|
|
}
|
|
else {
|
|
strcpy(buf, tmp);
|
|
}
|
|
strupr(strtrim(buf));
|
|
sprintf(searchname, "%-15.15s", buf);
|
|
|
|
return search();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::find(const ftn_addr& addr) {
|
|
|
|
namebrowse = false;
|
|
searchaddr = addr;
|
|
return search();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::previous() {
|
|
|
|
bool moved = prevnode();
|
|
if(moved) {
|
|
getnodedata();
|
|
compare();
|
|
}
|
|
return moved;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
bool ftn_frontdoor_nodelist_index::next() {
|
|
|
|
bool moved = nextnode();
|
|
if(moved) {
|
|
getnodedata();
|
|
compare();
|
|
}
|
|
return moved;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::first() {
|
|
|
|
if(namebrowse) {
|
|
memset(searchname, ' ', sizeof(searchname)-1);
|
|
searchname[sizeof(searchname)-1] = NUL;
|
|
}
|
|
else {
|
|
searchaddr.reset();
|
|
}
|
|
search();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::last() {
|
|
|
|
if(namebrowse) {
|
|
memset(searchname, 0xFF, sizeof(searchname)-1);
|
|
searchname[sizeof(searchname)-1] = NUL;
|
|
}
|
|
else {
|
|
searchaddr.set_all(0xFFFF);
|
|
}
|
|
search();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::push_state() {
|
|
|
|
state.node = node;
|
|
state.depth = depth;
|
|
state.blockno = blockno;
|
|
memcpy(state.stack, stack, sizeof(stack));
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void ftn_frontdoor_nodelist_index::pop_state() {
|
|
|
|
memcpy(stack, state.stack, sizeof(stack));
|
|
blockno = state.blockno;
|
|
depth = state.depth;
|
|
node = state.node;
|
|
getblock();
|
|
getnodedata();
|
|
compare();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
const char* ftn_frontdoor_nodelist_index::index_name() const {
|
|
|
|
return namebrowse ? "USERLIST.FDX" : "NODELIST.FDX";
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
const char* ftn_frontdoor_nodelist_index::nodelist_name() const {
|
|
|
|
if(noderec().nlofs & IN_FDNODE)
|
|
return "FDNODE.FDA";
|
|
else if(noderec().nlofs & IN_FDNET)
|
|
return is_intermail ? "IMNET.PVT" : "FDNET.PVT";
|
|
else if(noderec().nlofs & IN_FDPOINT)
|
|
return is_intermail ? "IMPOINT.PVT" : "FDPOINT.PVT";
|
|
return nodelist;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|