trunk2/openisis/lstb.c

/*
        openisis - an open implementation of the CDS/ISIS database
        Version 0.8.x (patchlevel see file Version)
        Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 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
        Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public
        License along with this library; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

        see README for more information
EOH */

/*
        $Id: lstb.c,v 1.41 2003/06/15 15:57:43 mawag Exp $
        implementation of client side session and communication functions.
*/

#include <errno.h>
#include <limits.h> /* PATH_MAX */
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include "openisis.h"
#include "loi.h"
#include "lcli.h"
#include "ldb.h"
#include "ldsp.h"
#include "lfdt.h"
#include "luti.h"

#ifdef WIN32
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#endif

#define LSTB_STHOSTLEN   32

#define LSTB_MAXDBS      255  /* according to OPENISIS_DBIDMSK */
#define LSTB_MAXSTUBS    255  /* according to OPENISIS_SCIDMSK */

#define LSTB_INCRDB      8
#define LSTB_INCRSTUB    8

/* ************************************************************
 * meta
*/

/* stub id 0      has idx -1 */
/* stub id 0x0100 has idx  0 */

#define SC_X2I(s)  ( ( (1 + (s)) << 8 ) & OPENISIS_SCIDMSK )

#define SC_I2X(s)  ( ( ((s) & OPENISIS_SCIDMSK) >> 8 ) - 1 )

#define DB_X2I(d,s)  ( ((s) & OPENISIS_SCIDMSK) | ((d) & OPENISIS_DBIDMSK) )

#define DB_I2X(d)    ( (d) & OPENISIS_DBIDMSK )

#define DB_IDX_OK(st,idx)   \
        (0 <= (idx) && (st)->head.ndbs > (idx) && * (st)->head.dbs[idx]->name)

/* ************************************************************
 * client view of db
*/

typedef struct {
        Db head;
} CDb;

static void cdbCtor (CDb *that,
        const char *name, int dbid, int tms, Fdt *fdt, Rec *cfg
) {
        strncpy (that->head.name, name, DBNLEN - 1) [DBNLEN - 1] = 0;
        that->head.dbid = dbid;
        that->head.tms  = tms;
        that->head.fdt  = fdt;
        that->head.cfg  = cfg;
}

static void cdbDtor (CDb *that) {
        if (that->head.fdt) {
                fFree (that->head.fdt);
        }
        if (that->head.cfg) {
                mFree (that->head.cfg);
        }
        memset (that, 0, sizeof (CDb));
}

/* ************************************************************
 * client session
*/

typedef struct OpenIsisStb {
        Schema    head;
        char      host[LSTB_STHOSTLEN];
        int       port;
        int       srq;   /* rqs serial no */
        Rec      *rqs;   /* last request */
        Rec      *rsp;   /* last response */
        Db       *rdb;   /* db of embedded rsp recs */
        CDb      *dbase; /* db array of non-local schema */
        LutiLT    hsh;
        CliChnl   chn;
        OpenIsisStbRqsProc  *rqsp;
        OpenIsisStbDelProc  *delp;
        void     *cld;   /* client_data of rqsp */
        /*MMM deprecated*/
        OpenIsisRspCb       *actcb;
        void                *actcld;
        OpenIsisStubCbData   cbdta;
} OpenIsisStb;

Stub stub0 = 0;

static Stub  RmtStubs = 0;
static int   NumStubs = 0;

static LutiLT StubLT = 0;

#define STBSIZE  (sizeof(Stb))

static int stbLocalRqs (Stub that, Rec *rqs);
static int stbSyncRqs (Stub that, Rec *rqs);

static void stbClear (Stub that) {
        memset (that, 0, STBSIZE);
        that->chn.sd = -1;
}

static int stbCtor (Stub that,
        const char *name, int scid, Rec *cfg,
        OpenIsisStbRqsProc *rqsp, OpenIsisStbDelProc *delp, void *cld,
        OpenIsisStubCbData *cbd
) {
        strncpy (that->head.name, name, SCNLEN - 1) [SCNLEN - 1] = 0;
        that->head.scid = scid;
        if (scid) {
                if (! rString (cfg, OPENISIS_SC_HOST, 0, that->host, LSTB_STHOSTLEN)) {
                        return 0;
                }
                that->port = rInt (cfg, OPENISIS_SC_PORT, 0, 0);
                if (0 >= that->port) {
                        return 0;
                }
                if (rqsp) {
                        that->rqsp = rqsp;
                }
                else {
                        that->rqsp = &stbSyncRqs;
                }
        }
        else {
                that->rqsp = &stbLocalRqs;
        }
        that->head.cfg =
                rSet (cfg, RCHG | RDIS, OPENISIS_SC_NAME, that->head.name, 0);
        that->delp = delp;
        that->cld  = cld;
        that->hsh  = luti_ltnew ();
        if (cbd) {
                memcpy (&that->cbdta, cbd, sizeof (OpenIsisStubCbData));
        }
        luti_ltadd (StubLT, that->head.name, scid);
        return !0;
}

/* return idx or -err */
static int cdbNewIdx (Stub that) {
        int     ndb = that->head.ndbs;
        int     rt, j;
        for (j = 0; ndb > j; ++j) {
                if (! * that->dbase[j].head.name) {
                        return j;
                }
        }
        rt = luti_ptrincr (&that->dbase, &ndb,
                LSTB_INCRDB, sizeof (CDb), LSTB_MAXDBS);
        if (0 > rt) {
                return sMsg (ERR_NOMEM, "%s: cdbNewIdx: out of memory",
                        that->head.name);
        }
        rt = luti_ptrincr (&that->head.dbs, &that->head.ndbs,
                LSTB_INCRDB, sizeof (CDb*), LSTB_MAXDBS);
        if (0 > rt) {
                return sMsg (ERR_NOMEM, "%s: cdbNewIdx: out of memory",
                        that->head.name);
        }
        for (j = that->head.ndbs; 0 <= --j; ) {
                that->head.dbs[j] = (Db*) (that->dbase + j);
        }
        return rt;
}

/* return bool newly allocated or -err */
static int cdbNewIdx0 (Stub that, int dbid) {
        int  rt;
        if (dbid < that->head.ndbs) {
                if (that->head.dbs[dbid]) {
                        return 0;
                }
                return 1;
        }
        rt = luti_ptrincr (&that->head.dbs, &that->head.ndbs,
                1 + dbid - that->head.ndbs, sizeof (CDb*), -1);
        if (0 > rt) {
                return sMsg (ERR_NOMEM, "%s: cdbNewIdx0(%d): out of memory",
                        that->head.name, dbid);
        }
        return 1;
}

static int stbNewIdx () {
        int   j;
        for (j = 0; NumStubs > j; ++j) {
                if (! * RmtStubs[j].head.name) {
                        return j;
                }
        }
        j = luti_ptrincr (&RmtStubs, &NumStubs,
                LSTB_INCRSTUB, STBSIZE, LSTB_MAXSTUBS);
        /* stbClear (RmtStubs + j) done in nOpen */
        return j;
}

static Stub stbById (int sid) {
        int idx;
        if (0 > sid || ! stub0) {
                return 0;
        }
        if (0 == sid) {
                return stub0;
        }
        idx = SC_I2X (sid);
        if (0 > idx) {
                log_msg (LOG_ERROR, "stbById: illegal id %x", sid);
                return 0;
        }
        if (NumStubs <= idx) {
                return 0;
        }
        if (! * RmtStubs[idx].head.name) {
                return 0;
        }
        return RmtStubs + idx;
}

static void stbDtor (Stub that) {
        luti_ltrmv (StubLT, that->head.name);
        if (that->cbdta.delcb) {
                if (that->actcld) {
                        (*that->cbdta.delcb) (
                                that->cbdta.delcld, that, that->actcld);
                }
                if (that->cbdta.dfltcld) {
                        (*that->cbdta.delcb) (
                                that->cbdta.delcld, that, that->cbdta.dfltcld);
                }
                (*that->cbdta.delcb) (that->cbdta.delcld, that, 0);
        }
        if (that->dbase) {
                int j;
                for (j = that->head.ndbs; 0 <= --j;  ) {
                        if (* that->dbase[j].head.name) {
                                cdbDtor (that->dbase + j);
                        }
                }
                mFree (that->dbase);
        }
        if (that->head.dbs) {
                mFree (that->head.dbs);
        }
        if (that->head.cfg) {
                mFree (that->head.cfg);
        }
        luti_ltdel (that->hsh);
        nClean (that);
        stbClear (that);
}

static int stbDbidFromName (Stub that, const char *dbn) {
        int id;
        if (! dbn) {
                return -1;
        }
        id = luti_ltget (that->hsh, dbn);
        return id;
}

static int stbDbIdxFromName (Stub that, const char *dbn) {
        int idx = stbDbidFromName (that, dbn);
        if (0 > idx) {
                return -1;
        }
        idx = DB_I2X (idx);
        if (! DB_IDX_OK (that, idx)) {
                return -1;
        }
        return idx;
}

static int stbOpenDb (Stub that) {
        char  dbn[DBNLEN];
        Fdt  *fdt;
        Rec  *cfg;
        int   idx, dbid, tms;
        int   newdb = 0;

        if (! rString (that->rsp, OPENISIS_COM_DBN, 0, dbn, DBNLEN)) {
                return sMsg (ERR_IDIOT, "%s: stbOpenDb: missing db name in rsp",
                        that->head.name);
        }
        idx = stbDbIdxFromName (that, dbn);

        if (0 > idx) {
                idx = cdbNewIdx (that);
                if (0 > idx) {
                        return idx;
                }
                newdb = !0;
        }
        else {
                cdbDtor (that->dbase + idx);
        }

        fdt = fRec2Fdt (that->rsp);
        cfg = luti_unwrap (that->rsp, 0, OPENISIS_COM_CFG, -1);
        tms = rInt (that->rsp, OPENISIS_COM_TMS, 0, 0);
        dbid = DB_X2I (idx, that->head.scid);

        cdbCtor (that->dbase + idx, dbn, dbid, tms, fdt, cfg);

        if (newdb) {
                luti_ltadd (that->hsh, dbn, dbid);
        }
        return 0;
}

static int stbOpenDb0 (Stub that) {
        Db  *dbh;
        int  newdb = 0;
        int  dbid  = rInt (that->rsp, OPENISIS_RSP_DBID, -1, 0);
        if (0 > dbid) {
                return sMsg (ERR_IDIOT, "stbOpenDb0: missing dbid in rsp");
        }

        newdb = cdbNewIdx0 (that, dbid);
        if (0 > newdb) {
                return newdb;
        }

        dbh = ldb_getdb (dbid);
        if (! dbh) {
                return sMsg (ERR_TRASH, "stbOpenDb0: no such db %d", dbid);
        }
        log_msg (LOG_INFO, "stbOpenDb0 %d %s", dbid, dbh->name);

        that->head.dbs[dbid] = dbh;
        if (newdb) {
                luti_ltadd (that->hsh, dbh->name, dbid);
        }
        return 0;
}

static int stbCloseDb (Stub that) {
        char  dbn[DBNLEN];
        CDb  *db;
        int   dbid;
        if (! rString (that->rsp, OPENISIS_COM_DBN, 0, dbn, sizeof (dbn))) {
                return sMsg (ERR_IDIOT, "%s: stbCloseDb: missing db name in rsp",
                        that->head.name);
        }
        dbid = stbDbIdxFromName (that, dbn);
        if (0 > dbid) {
                return sMsg (ERR_TRASH, "%s: stbCloseDb: illegal db name <%s> in rsp",
                        that->head.name, dbn);
        }
        db = that->dbase + dbid;
        luti_ltrmv (that->hsh, db->head.name);
        cdbDtor (db);
        return 0;
}

static int stbCloseDb0 (Stub that) {
        char   dbn[DBNLEN];
        int    dbid = rInt (that->rsp, OPENISIS_RSP_DBID, -1, 0);
        if (0 > dbid) {
                return sMsg (ERR_IDIOT, "stbCloseDb0: missing dbid in rsp");
        }
        if (that->head.ndbs <= dbid) {
                return sMsg (ERR_TRASH, "stbCloseDb0: illegal dbid %d(%d) in rsp",
                        dbid, that->head.ndbs);
        }
        if (! rString (that->rsp, OPENISIS_COM_DBN, 0, dbn, DBNLEN)) {
                return sMsg (ERR_IDIOT, "stbCloseDb0: missing db name in rsp\n");
        }
        log_msg (LOG_INFO, "stbCloseDb0 %d %s", dbid, dbn);
        luti_ltrmv (that->hsh, dbn);
        that->head.dbs[dbid] = 0;
        return 0;
}

/*      (local) response callback
*/
static int stbRspCb (Rec **rsp, void *cld) {
        Stub      that;
        Rec      *rsp2;
        int       sid, ser, err, err2, err3;

        (void)cld;
        sid = rInt (*rsp, OPENISIS_COM_SID, -1, 0);
        ser = rInt (*rsp, OPENISIS_COM_SER, -1, 0);
        err = rInt (*rsp, OPENISIS_RSP_ERR, -1, 0);

        that = stbById (sid);
        if (! that) {
                return sMsg (ERR_TRASH, "illegal stub id %d in stbRspCb\n", sid);
        }
        if (ser != that->srq) {
                return sMsg (ERR_TRASH, "%s: rqs serial mismatch %d != %d",
                        that->head.name, ser, that->srq);
        }
        if (! that->rqs) {
                return sMsg (ERR_TRASH, "%s/%d: response without request",
                        that->head.name, sid);
        }
        if (that->rsp) {
                sMsg (ERR_TRASH, "%s: multiple responses",
                        that->head.name);
                mFree (that->rsp);
        }
        that->rdb = 0;
        that->rsp = *rsp;
        *rsp = 0;

        err2 = err3 = 0;

        if (0 == err) {
                int rtyp = rInt (that->rqs, OPENISIS_RQS_TYPE, -1, 0);
                switch (rtyp) {

                case OPENISIS_RQST_LSDB:
                case OPENISIS_RQST_EVAL:
                        break;

                case OPENISIS_RQST_CLOS:
                        if (sid) {
                                err2 = sMsg (ERR_IDIOT, "%s: db close on remote stub",
                                        that->head.name);
                        }
                        else {
                                err2 = stbCloseDb0 (that);
                        }
                        break;
                
                case OPENISIS_RQST_OPEN:
                        if (sid) {
                                err2 = sMsg (ERR_IDIOT, "%s: db open on remote stub",
                                        that->head.name);
                                break;
                        }
                        err2 = stbOpenDb0 (that);
                        goto setdb;
                
                case OPENISIS_RQST_MNT:
                        if (0 == sid) {
                                err2 = sMsg (ERR_IDIOT, "db mount on local stub");
                                break;
                        }
                        err2 = stbOpenDb (that);
                        goto setdb;

                default:
                setdb: {
                        char dbn[DBNLEN];
                        int rdid, rx;
                        if (! rString (that->rsp, OPENISIS_COM_DBN, 0, dbn, sizeof(dbn))) {
                                if (sid) {
                                        err2 = sMsg (ERR_IDIOT,
                                                "%s: stbRspCb: missing db name in rsp",
                                                that->head.name);
                                }
                                else {
                                        err2 = sMsg (ERR_IDIOT,
                                                "stbRspCb: missing db name in rsp");
                                }
                        }
                        else {
                                rdid = stbDbidFromName (that, dbn);
                                if (0 > rdid) {
                                        if (sid) {
                                                err2 = sMsg (ERR_TRASH,
                                                        "%s: stbRspCb: illegal db name <%s> in rsp",
                                                        that->head.name, dbn);
                                        }
                                        else {
                                                err2 = sMsg (ERR_TRASH,
                                                        "stbRspCb: illegal db name <%s> in rsp", dbn);
                                        }
                                }
                                else {
                                        /* see nDbById */
                                        rx = DB_I2X (rdid);
                                        if (! DB_IDX_OK (that, rx)) {
                                                if (sid) {
                                                        err2 = sMsg (ERR_TRASH,
                                                                "%s: stbRspCb: illegal db id %d %d <%s>",
                                                                that->head.name, rdid, rx, dbn);
                                                }
                                                else {
                                                        err2 = sMsg (ERR_TRASH,
                                                                "stbRspCb: illegal db id %d %d <%s>",
                                                                rdid, rx, dbn);
                                                }
                                        }
                                        else {
                                                that->rdb = that->head.dbs[rx];
                                        }
                                }
                        }
                }
                } /* switch */
        }
        else { /* err */
                int tms;
                tms = rInt (that->rsp, OPENISIS_COM_TMS, 0, 0);
                if (tms && sid) { /* remounted */
                        err2 = stbCloseDb (that);
                }
        }

        rsp2 = rAddI (that->rsp, OPENISIS_RSP_CERR, err2, !0);
        if (rsp2) {
                that->rsp = rsp2;
        }

        if (that->actcb) {
                err3 = (*that->actcb) (that->actcld,
                        that, that->rsp, that->rdb);
                if (that->actcld && that->cbdta.delcb) {
                        (*that->cbdta.delcb) (
                                that->cbdta.delcld, that, that->actcld);
                }
                that->actcb = 0;
                that->actcld = 0;
        }
        else if (that->cbdta.dfltcb) {
                err3 = (*that->cbdta.dfltcb) (that->cbdta.dfltcld,
                        that, that->rsp, that->rdb);
        }

        sMsg (LOG_VERBOSE, "stbRspCb(%s): %d/%d err = %x,%x,%x",
                that->head.name, sid, ser, err, err2, err3);

        return err3;
}

static int stbLocalRqs (Stub that, Rec *rqs) {
        (void)that;
        return ldspProcess (rqs, 0, &stbRspCb, 0);
}

static int stbSyncRqs (Stub that, Rec *rqs) {
        Rec *rsp;
        int  rt;
        if (0 > that->chn.sd) {
                rt = cliConnect (&that->chn, that->host, that->port);
                if (0 > rt) {
                        return rt;
                }
        }
        rt = cliWrite (&that->chn, rqs);
        if (0 > rt) {
                return rt;
        }
        rsp = cliRead (&that->chn);
        if (! rsp) {
                return sMsg (ERR_IO, "stbSyncRqs: read error %d - %s", 
                        that->chn.err, strerror (that->chn.err));
        }
        rt = stbRspCb (&rsp, 0);
        if (rsp) {
                mFree (rsp);
        }
        return rt;
}

/* ************************************************************
        package functions
*/

/* ************************************************************
        public functions
*/

Stub nInit (
        int argc, const char **argv, OpenIsisStubCbData *dta
) {
        Rec *cfg = 0;

        if (stub0) {
                return stub0;
        }

        StubLT = luti_ltnew ();
        stub0 = mAlloc (STBSIZE);
        stbClear (stub0);

        if (0 < argc) {
                char  buf[PATH_MAX];
                char *logn;
                int   logl;

                cfg = rSet (0, RFDT | RARGV | RIGN | argc, openIsisFdtSyspar, argv);

                logn = rString (cfg, OPENISIS_SLOGF, 0, buf, sizeof(buf));
                logl = rInt (cfg, OPENISIS_SLOGV, -1, 0);
                if (logn || 0 <= logl) {
                        cLog (logl, logn);
                }
        }

        stbCtor (stub0, "", 0, cfg, 0, 0, 0, dta);
        return stub0;
}

Stub nOpen (
        const char *name, int argc, const char *argv[], OpenIsisStubCbData *dta
) {
        OpenIsisStb buf;
        Stub  that;
        Rec  *cfg   =  0;
        int   idx, sid;

        if (! stub0 || ! name || ! *name) {
                return 0;
        }

        idx = luti_ltget (StubLT, name);
        if (0 <= idx) {
                idx = SC_I2X (idx);
                if (0 > idx || NumStubs <= idx || ! * RmtStubs[idx].head.name) {
                        log_msg (LOG_ERROR, "nOpen: illegal idx %d(%d) for %s",
                                idx, NumStubs, name);
                        return 0;
                }
                return RmtStubs + idx;
        }

        idx = stbNewIdx ();
        if (0 > idx) {
                return 0;
        }
        if (0 < argc) {
                cfg = rSet (0, RFDT | RARGV | RIGN | argc, openIsisFdtScheme, argv);
        }
        sid = SC_X2I (idx);
        stbClear (&buf);
        if (! stbCtor (&buf, name, sid, cfg, 0, 0, 0, dta)) {
                if (cfg) {
                        mFree (cfg);
                }
                return 0;
        }

        that = RmtStubs + idx;
        memcpy (that, &buf, STBSIZE);
        return that;
}

void nClose (Stub that) {
        if (that && *that->head.name) {
                stbDtor (that);
        }
}

void nDeinit () {
        if (stub0) {
                int j;
                if (RmtStubs) {
                        for (j = NumStubs; 0 <= --j;  ) {
                                if (* RmtStubs[j].head.name) {
                                        stbDtor (RmtStubs + j);
                                }
                        }
                        mFree (RmtStubs);
                        RmtStubs = 0;
                        NumStubs = 0;
                }
                for (j = stub0->head.ndbs; 0 <= --j;  ) {
                        if (stub0->head.dbs[j]) {
                                cDClose (stub0->head.dbs[j]->dbid);
                        }
                }
                stbDtor (stub0);
                mFree (stub0);
                stub0 = 0;
                luti_ltdel (StubLT);
                StubLT = 0;
        }
}

Schema* nSchema (Stub that) {
        int idx;
        if (that && ( stub0 == that || ( *that->head.name &&
                0 <= (idx = SC_I2X (that->head.scid)) && NumStubs > idx
        ))) {
                return &that->head;
        }
        return 0;
}

void nClean (Stub that) {
        if (that->rqs) {
                mFree (that->rqs);
                that->rqs = 0;
        }
        if (that->rsp) {
                mFree (that->rsp);
                that->rsp = 0;
        }
        that->rdb = 0;
}

int nSend (Stub that,
        Rec *rqs, OpenIsisRspCb *actcb, void *actcld, int dup
) {
        char  buf[DBNLEN];
        char  sid[16];
        char  ser[16];
        char  tms[16];
        char *dbl, *dbn;
        int   dbid, rtyp, setn;

        if (!(that && rqs)) {
                return sMsg (ERR_IDIOT, "nSend: null pointer %x %x",
                        (int)that, (int)rqs);
        }
        if (stub0 != that && ! *that->head.name) {
                return sMsg (ERR_IDIOT, "nSend: invalid stub");
        }
        setn = !0;
        rtyp = rInt (rqs, OPENISIS_RQS_TYPE, -1, 0);
        switch (rtyp) {
        case -1:
                return sMsg (ERR_IDIOT, "nSend(%s): request without type",
                        that->head.name);
        case OPENISIS_RQST_LSDB:
        case OPENISIS_RQST_EVAL:
                setn = 0;
                break;
        case OPENISIS_RQST_OPEN:
        case OPENISIS_RQST_CLOS:
                if (stub0 != that) {
                        return sMsg (ERR_IDIOT, "nSend(%s): request %d denied",
                                that->head.name, rtyp);
                }
                break;
        case OPENISIS_RQST_MNT:
                if (stub0 == that) {
                        return sMsg (ERR_IDIOT, "nSend: local mount denied");
                }
                rqs = rSet (rqs, RFDT | RDIS | RCHG, openIsisFdtRqs,
                        OPENISIS_COM_TMS, "0", 0);
                if (! rqs) {
                        return sMsg (ERR_NOMEM, "nSend(%s): out of memory",
                                that->head.name);
                }
                break;
        }

        dbid = -1;
        dbn = 0;
        dbl = that->rdb ? that->rdb->name : 0;
        nClean (that);

        i2a (sid, that->head.scid);
        if (0 >= ++that->srq) {
                that->srq = 1;
                log_msg (LOG_INFO, "stub %s: srq loop over 0", that->head.name);
        }
        i2a (ser, that->srq);

        if (setn) {
                if ((dbn = rString (rqs, OPENISIS_COM_DBN, 0, buf, DBNLEN))) {
                        setn = 0;
                }
                else {
                        if (dbl) {
                                dbn = dbl;
                        }
                        else {
                                dbn = rString (that->head.cfg,
                                        OPENISIS_SC_DFLTDB, 0, buf, DBNLEN);
                        }
                }
                if (! dbn) {
                        return sMsg (ERR_IDIOT, "nSend(%s): request without db name",
                                that->head.name);
                }
                if (0 > rInt (rqs, OPENISIS_COM_TMS, -1, 0)) {
                        dbid = stbDbIdxFromName (that, dbn);
                        if (0 <= dbid) {
                                i2a (tms, that->head.dbs[dbid]->tms);
                        }
                }
        }

        if (dup) {
                rqs = rDup (rqs, 0, 0);
                if (! rqs) {
                        return -1;
                }
        }

        rqs = rSet (rqs, RFDT | RDIS | RCHG, openIsisFdtRqs,
                OPENISIS_COM_SID, sid, OPENISIS_COM_SER, ser,
                0 <= dbid ? OPENISIS_COM_TMS : 0, tms, 0);
        if (! rqs) {
                return sMsg (ERR_NOMEM, "nSend(%s): out of memory",
                        that->head.name);
        }
        if (setn) {
                rqs = rSet (rqs, RFDT | RDIS | RCHG, openIsisFdtRqs,
                        OPENISIS_COM_DBN, dbn, 0);
                if (! rqs) {
                        return sMsg (ERR_NOMEM, "nSend(%s): out of memory",
                                that->head.name);
                }
        }

        that->rqs = rqs;

        if (that->actcld && that->cbdta.delcb) {
                /* ooups */
                (*that->cbdta.delcb) (
                        that->cbdta.delcld, that, that->actcld);
        }
        if (actcb) {
                that->actcb = actcb;
                that->actcld = actcld;
        }
        else {
                that->actcb = 0;
                that->actcld = 0;
        }

        return (*that->rqsp) (that, that->rqs);
}

Rec* nRecv (Stub that, Db **db) {
        if (that && (
                stub0 == that || *that->head.name
        )) {
                if (db) {
                        *db = that->rdb;
                }
                return that->rsp;
        }
        return 0;
}

Db* nDbByName (Stub that, const char *dbname) {
        if (that && (
                stub0 == that || *that->head.name
        )) {
                int dbid = stbDbIdxFromName (that, dbname);
                if (0 <= dbid) {
                        return that->head.dbs[dbid];
                }
        }
        return 0;
}

Db* nDbById (int id) {
        Stub that = stbById (id & OPENISIS_SCIDMSK);
        if (! that) {
                return 0;
        }
        id = DB_I2X (id);
        if (! DB_IDX_OK (that, id)) {
                return 0;
        }
        return that->head.dbs[id];
}

#define FREEPTR(p) if (p) { mFree (p); p = 0; }
#define FREEROW    if (rowids) { FREEPTR(*rowids) }

int nResult (
        Stub that, int **rowids, Rec ***recs, Db **db, int *tot
) {
        Field     *F;
        Rec      **R;
        int       *I;
        int        numt, numr, err, pos, j;

        if (rowids) {
                *rowids = 0;
        }
        if (recs) {
                *recs = 0;
        }
        if (db) {
                *db = 0;
        }
        if (tot) {
                *tot = 0;
        }
        if (! that) {
                return sMsg (ERR_IDIOT, "nGetResult: null pointer");
        }
        if (! that->rsp) {
                return sMsg (ERR_IDIOT, "nGetResult(%s): no response",
                        that->head.name);
        }
        err = rInt (that->rsp, OPENISIS_RSP_ERR, 0, 0);
        if (err) {
                return sMsg (ERR_IDIOT, "nGetResult(%s): response error %d",
                        that->head.name, err);
        }
        numr = rInt (that->rsp, OPENISIS_RSP_NUMR, -1, 0);
        numt = rInt (that->rsp, OPENISIS_RSP_NUMT, -1, 0);
        if (0 > numr || 0 > numt) {
                return sMsg (ERR_IDIOT, "nGetResult(%s): no record count in response",
                        that->head.name);
        }
        if (numr) {
                if (rowids) {
                        *rowids = (int*) mAlloc (numr * sizeof (int));
                        if (! *rowids) {
                                return sMsg (ERR_NOMEM, "nGetResult(%s): out of memory",
                                        that->head.name);
                        }
                        for (I = *rowids, j = pos = 0; numr > j; ++I, ++j) {
                                *I = rInt (that->rsp, OPENISIS_COM_ROW, -1, &pos);
                                if (0 > *I) {
                                        FREEROW;
                                        return sMsg (ERR_TRASH,
                                                "nGetResult(%s): missing rowid %d(%d)",
                                                that->head.name, j, numr);
                                }
                        }
                }

                if (recs) {
                        *recs = (Rec**) mAlloc (numr * sizeof (Rec*));
                        if (! *recs) {
                                FREEROW;
                                return sMsg (ERR_NOMEM, "nGetResult(%s): out of memory",
                                        that->head.name);
                        }
                        memset (*recs, 0, numr * sizeof (Rec*));
                        R = *recs;
                        I = rowids ? *rowids : 0;
                        j = pos = 0;
                        F = rGet (that->rsp, OPENISIS_COM_REC, &pos);
                        if (! F) {
                                sMsg (LOG_WARN,
                                        "nGetResult(%s): no records in response",
                                        that->head.name);
                                FREEPTR (*recs);
                        }
                        else {
                                --pos;
                                while (numr > j) {
                                        *R = luti_unwrap (that->rsp, &pos, OPENISIS_COM_REC,
                                                that->rdb ? that->rdb->dbid : -1);
                                        if (! *R) {
                                                FREEROW;
                                                luti_free ((void**)*recs, j);
                                                *recs = 0;
                                                return sMsg (ERR_NOMEM,
                                                        "nGetResult(%s): out of memory", that->head.name);
                                        }
                                        if (I) {
                                                (*R)->rowid = *I;
                                                ++I;
                                        }
                                        ++R;
                                        ++j;
                                }
                        }
                } /* recs */

        } /* numr */

        if (db) {
                *db = that->rdb;
        }
        if (tot) {
                *tot = numt;
        }

        return numr;
}
