isopen.c File Reference

#include "isinternal.h"

Include dependency graph for isopen.c:

Go to the source code of this file.

Functions
int	ivbforceexit (const int ihandle)
int	ivbclose2 (const int ihandle)
void	ivbclose3 (const int ihandle)
int	iscleanup (void)
int	isclose (const int ihandle)
int	isfullclose (const int ihandle)
int	isindexinfo (const int ihandle, void *pskeydesc, const int ikeynumber)
int	isopen (const char *pcfilename, int imode)
int	issetcollate (const int ihandle, const unsigned char *collating_sequence)

Function Documentation

int iscleanup

(

void

)

Definition at line 152 of file isopen.c.

References DICTINFO::iisopen, isclose(), iserrno, islogclose(), ivbclose2(), ivbclose3(), ivblogfilehandle, ivbmaxusedhandle, and psvbfile.

Referenced by cob_exit_fileio().

{
    int iloop, iresult, iresult2 = 0;

    for (iloop = 0; iloop <= ivbmaxusedhandle; iloop++)
        if (psvbfile[iloop]) {
            if (psvbfile[iloop]->iisopen == 0) {
                iresult = isclose (iloop);
                if (iresult) {
                    iresult2 = iserrno;
                }
            }
            if (psvbfile[iloop]->iisopen == 1) {
                iresult = ivbclose2 (iloop);
                if (iresult) {
                    iresult2 = iserrno;
                }
            }
            ivbclose3 (iloop);
        }
    if (ivblogfilehandle >= 0) {
        iresult = islogclose ();
        if (iresult) {
            iresult2 = iserrno;
        }
    }
    return iresult2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isclose

(

const int

ihandle

)

Definition at line 182 of file isopen.c.

References DICTINFO::iindexchanged, DICTINFO::iisopen, DICTINFO::iopenmode, iserrno, ivbclose2(), ivbforceexit(), ivbintrans, ivbmaxusedhandle, psvbfile, unlikely, VBBEGIN, VBNEEDFLUSH, and VBRECOVER.

Referenced by ircvbuild(), ircvfileclose(), isbuild(), iscleanup(), iserase(), isfullclose(), ivbrollmeback(), ivbrollmeforward(), and vcloseall().

{
    struct DICTINFO *psvbptr;

    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        iserrno = EBADARG;
        return -1;
    }
    psvbptr = psvbfile[ihandle];
    if (!psvbptr || psvbptr->iisopen) {
        iserrno = ENOTOPEN;
        return -1;
    }
    if (psvbptr->iopenmode & ISEXCLLOCK) {
        ivbforceexit (ihandle); /* BUG retval */
    }
    psvbptr->iindexchanged = 0;
    psvbptr->iisopen = 1;
    if (!(ivbintrans == VBBEGIN || ivbintrans == VBNEEDFLUSH || ivbintrans == VBRECOVER)) {
        if (ivbclose2 (ihandle)) {
            return -1;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isfullclose

(

const int

ihandle

)

Definition at line 209 of file isopen.c.

References isclose(), iserrno, ivbclose3(), ivbmaxusedhandle, and unlikely.

Referenced by indexed_close(), indexed_open(), and ischeck().

{
    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        iserrno = EBADARG;
        return -1;
    }
    isclose (ihandle);
    ivbclose3 (ihandle);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isindexinfo	(	const int	ihandle,
		void *	pskeydesc,
		const int	ikeynumber
	)

Definition at line 221 of file isopen.c.

References DICTINFO::iisopen, DICTINFO::imaxrowlength, DICTINFO::iminrowlength, DICTINFO::inkeys, DICTINFO::inodesize, DICTINFO::iopenmode, iserrno, isreclen, ivbenter(), ivbexit(), ivbmaxusedhandle, DICTINFO::pskeydesc, psvbfile, and unlikely.

Referenced by indexed_open().

{
    char        *pctemp;
    struct DICTINFO *psvbptr;
    struct dictinfo sdict;

    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        iserrno = EBADARG;
        return -1;
    }
    psvbptr = psvbfile[ihandle];
    if (!psvbptr || psvbptr->iisopen) {
        iserrno = ENOTOPEN;
        return -1;
    }
    iserrno = EBADKEY;
    if (ikeynumber < 0 || ikeynumber > psvbptr->inkeys) {
        return -1;
    }
    iserrno = 0;
    if (ikeynumber) {
        memcpy (pskeydesc, psvbptr->pskeydesc[ikeynumber - 1],
            sizeof (struct keydesc));
        return 0;
    }

    if (ivbenter (ihandle, 1, 0)) {
        return -1;
    }

    sdict.di_nkeys = psvbptr->inkeys;
    if (psvbptr->iopenmode & ISVARLEN) {
        pctemp = (char *)&sdict.di_nkeys;
        *pctemp |= 0x80;
    }
    sdict.di_recsize = psvbptr->imaxrowlength;
    sdict.di_idxsize = psvbptr->inodesize;
/* RXW
    sdict.di_nrecords = tcountrows (ihandle);
*/
    sdict.di_nrecords = 0;
    isreclen = psvbptr->iminrowlength;
    memcpy (pskeydesc, &sdict, sizeof (struct dictinfo));

    ivbexit (ihandle);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isopen	(	const char *	pcfilename,
		int	imode
	)

Definition at line 270 of file isopen.c.

References DICTINFO::cfilename, DICTNODE::cindexcount, DICTNODE::cmaxrowlength, DICTNODE::cminrowlength, DICTNODE::cnodekeydesc, DICTNODE::cnodesize, DICTNODE::cvalidation, cvbnodetmp, DICTINFO::idatahandle, DICTINFO::iindexhandle, DICTINFO::iisopen, DICTINFO::imaxrowlength, DICTINFO::iminrowlength, DICTINFO::inkeys, inl_ldint(), inl_ldquad(), DICTINFO::inodesize, DICTINFO::iopenmode, iserrno, isstart(), DICTINFO::itransyet, ivbblockread(), ivbclose(), ivbenter(), ivbexit(), ivbfileopenlock(), ivbintrans, ivblogfilehandle, ivbmaxusedhandle, ivbopen(), ivbtransopen(), MAX_NODE_LENGTH, MAX_RESERVED_LENGTH, MAXSUBS, NULL, O_BINARY, DICTINFO::ppcrowbuffer, DICTINFO::pskeydesc, psvbfile, pvvbmalloc(), QUADSIZE, DICTINFO::sdictnode, VB_MAX_FILES, VB_NODE_MAX, VBNOTRANS, and vvbfree().

Referenced by indexed_open(), ircvfileopen(), isbuild(), ischeck(), ivbrollmeback(), and ivbrollmeforward().

{
    struct DICTINFO *psvbptr;
    char        *pctemp;
    struct keydesc  *pkptr;
    off_t       tnodenumber;
    int     iflags;
    int     ihandle, iindexnumber = 0, iindexpart;
    int     ikeydesclength, ilengthused, iloop, iresult;
    struct stat sstat;
    char        tmpfname[1024];
    char        cvbnodetmp[VB_NODE_MAX];

    if ((imode & ISTRANS) && ivblogfilehandle < 0) {
        iserrno = EBADARG;  /* I'd have expected ENOLOG or ENOTRANS! */
        return -1;
    }
    iflags = imode & 0x03;
    if (iflags == 3) {
        /* Cannot be BOTH ISOUTPUT and ISINOUT */
        iserrno = EBADARG;
        return -1;
    }
    if (strlen (pcfilename) > sizeof(tmpfname) - 5) {
        iserrno = EFNAME;
        return -1;
    }
    /*
     * The following for loop deals with the concept of re-opening a file
     * that was closed within the SAME transaction.  Since we were not
     * allowed to perform the FULL close during the transaction because we
     * needed to retain all the transactional locks, we can tremendously
     * simplify the re-opening process.
     */
    for (ihandle = 0; ihandle <= ivbmaxusedhandle; ihandle++) {
        psvbptr = psvbfile[ihandle];
        if (psvbptr && psvbptr->iisopen != 0) {
            if (!strcmp (psvbptr->cfilename, pcfilename)) {
                if (psvbptr->iisopen == 2) {
                    sprintf (tmpfname, "%s.idx", pcfilename);
                    psvbptr->iindexhandle =
                        ivbopen (tmpfname, O_RDWR | O_BINARY, 0);
                    sprintf (tmpfname, "%s.dat", pcfilename);
                    psvbptr->idatahandle =
                        ivbopen (tmpfname, O_RDWR | O_BINARY, 0);
                    if (imode & ISEXCLLOCK) {
                        iresult = ivbfileopenlock (ihandle, 2);
                    } else {
                        iresult = ivbfileopenlock (ihandle, 1);
                    }
                    if (iresult) {
                        errno = EFLOCKED;
                        goto open_err;
                    }
                }
                psvbptr->iisopen = 0;
                psvbptr->iopenmode = imode;
                return ihandle;
            }
        }
    }
    for (ihandle = 0; ; ihandle++) {
        if (ihandle > ivbmaxusedhandle) {
            if (ivbmaxusedhandle >= VB_MAX_FILES) {
                iserrno = ETOOMANY;
                return -1;
            }
            ivbmaxusedhandle = ihandle;
            break;
        }
        if (psvbfile[ihandle] == NULL) {
            break;
        }
    }
    psvbfile[ihandle] = pvvbmalloc (sizeof (struct DICTINFO));
    if (psvbfile[ihandle] == NULL) {
        errno = EBADMEM;
        goto open_err;
    }
    psvbptr = psvbfile[ihandle];
    psvbptr->cfilename = strdup (pcfilename);
    if (psvbptr->cfilename == NULL) {
        errno = EBADMEM;
        goto open_err;
    }
    psvbptr->ppcrowbuffer = pvvbmalloc (MAX_RESERVED_LENGTH);
    if (psvbptr->ppcrowbuffer == NULL) {
        errno = EBADMEM;
        goto open_err;
    }
    psvbptr->idatahandle = -1;
    psvbptr->iindexhandle = -1;
    sprintf (tmpfname, "%s.dat", pcfilename);
    if (stat (tmpfname, &sstat)) {
        errno = ENOENT;
        goto open_err;
    }
    sprintf (tmpfname, "%s.idx", pcfilename);
    if (stat (tmpfname, &sstat)) {
        errno = ENOENT;
        goto open_err;
    }
    psvbptr->iindexhandle = ivbopen (tmpfname, O_RDWR | O_BINARY, 0);
    if (psvbptr->iindexhandle < 0) {
        goto open_err;
    }
    sprintf (tmpfname, "%s.dat", pcfilename);
    psvbptr->idatahandle = ivbopen (tmpfname, O_RDWR | O_BINARY, 0);
    if (psvbptr->idatahandle < 0) {
        goto open_err;
    }
    psvbptr->iisopen = 0;

    psvbptr->inodesize = MAX_NODE_LENGTH;
    /* Get dictionary node and set node size */
    if (ivbenter (ihandle, 1, 1)) {
        errno = iserrno;
        goto open_err;
    }
    errno = EBADFILE;
#if ISAMMODE == 1
    if (psvbptr->sdictnode.cvalidation[0] != 0x56
        || psvbptr->sdictnode.cvalidation[1] != 0x42) {
        goto open_err;
    }
#else
    if (psvbptr->sdictnode.cvalidation[0] != -2
        || psvbptr->sdictnode.cvalidation[1] != 0x53) {
        goto open_err;
    }
#endif
    psvbptr->inodesize = inl_ldint (psvbptr->sdictnode.cnodesize) + 1;
    psvbptr->inkeys = inl_ldint (psvbptr->sdictnode.cindexcount);
    psvbptr->iminrowlength = inl_ldint (psvbptr->sdictnode.cminrowlength);
    if (imode & ISVARLEN) {
        psvbptr->imaxrowlength = inl_ldint (psvbptr->sdictnode.cmaxrowlength);
    } else {
        psvbptr->imaxrowlength = psvbptr->iminrowlength;
    }

    errno = EROWSIZE;
    if (psvbptr->imaxrowlength && psvbptr->imaxrowlength != psvbptr->iminrowlength) {
        if (!(imode & ISVARLEN)) {
            goto open_err;
        }
    } else {
        if (imode & ISVARLEN) {
            goto open_err;
        }
    }
    psvbptr->iopenmode = imode;
    tnodenumber = inl_ldquad (psvbptr->sdictnode.cnodekeydesc);

    /* Fill in the keydesc stuff */
    while (tnodenumber) {
        iresult = ivbblockread (ihandle, 1, tnodenumber, cvbnodetmp);
        errno = EBADFILE;
        if (iresult) {
            goto open_err;
        }
        pctemp = cvbnodetmp;
        if (*(cvbnodetmp + psvbptr->inodesize - 3) != -1
            || *(cvbnodetmp + psvbptr->inodesize - 2) != 0x7e) {
            goto open_err;
        }
        ilengthused = inl_ldint (pctemp);
        pctemp += INTSIZE;
        tnodenumber = inl_ldquad (pctemp);
        pctemp += QUADSIZE;
        ilengthused -= (INTSIZE + QUADSIZE);
        while (ilengthused > 0) {
            errno = EBADFILE;
            if (iindexnumber >= MAXSUBS) {
                goto open_err;
            }
            ikeydesclength = inl_ldint (pctemp);
            ilengthused -= ikeydesclength;
            pctemp += INTSIZE;
            psvbptr->pskeydesc[iindexnumber] = pvvbmalloc (sizeof (struct keydesc));
            pkptr = psvbptr->pskeydesc[iindexnumber];
            if (pkptr == NULL) {
                errno = EBADMEM;
                goto open_err;
            }
            pkptr->k_nparts = 0;
            pkptr->k_len = 0;
            pkptr->k_rootnode = inl_ldquad (pctemp);
/* RXW
            memcpy (&(pkptr->k_rootnode), pctemp, QUADSIZE);
*/
            pctemp += QUADSIZE;
            pkptr->k_flags = (*pctemp) * 2;
            pctemp++;
            ikeydesclength -= (QUADSIZE + INTSIZE + 1);
            iindexpart = 0;
            if (*pctemp & 0x80) {
                pkptr->k_flags |= ISDUPS;
            }
            *pctemp &= ~0x80;
            while (ikeydesclength > 0) {
                pkptr->k_nparts++;
                pkptr->k_part[iindexpart].kp_leng = inl_ldint (pctemp);
                pkptr->k_len += pkptr->k_part[iindexpart].kp_leng;
                pctemp += INTSIZE;
                pkptr->k_part[iindexpart].kp_start = inl_ldint (pctemp);
                pctemp += INTSIZE;
                pkptr->k_part[iindexpart].kp_type = *pctemp;
                pctemp++;
                ikeydesclength -= ((INTSIZE * 2) + 1);
                errno = EBADFILE;
                if (ikeydesclength < 0) {
                    goto open_err;
                }
                iindexpart++;
            }
            iindexnumber++;
        }
        if (ilengthused < 0) {
            goto open_err;
        }
    }
    if (imode & ISEXCLLOCK) {
        iresult = ivbfileopenlock (ihandle, 2);
    } else {
        iresult = ivbfileopenlock (ihandle, 1);
    }
    if (iresult) {
        errno = EFLOCKED;
        goto open_err;
    }
    ivbexit (ihandle);
    iresult = isstart (ihandle, psvbptr->pskeydesc[0], 0, NULL, ISFIRST);
    if (iresult) {
        errno = iserrno;
        goto open_err;
    }

    if (ivbintrans == VBNOTRANS) {
        ivbtransopen (ihandle, pcfilename);
        psvbptr->itransyet = 1;
    }
    return ihandle;
open_err:
    ivbexit (ihandle);
    psvbptr = psvbfile[ihandle];
    if (psvbptr != NULL) {
        for (iloop = 0; iloop < MAXSUBS; iloop++) {
            if (psvbptr->pskeydesc[iloop]) {
                vvbfree (psvbptr->pskeydesc[iloop]);
            }
        }
        if (psvbptr->idatahandle != -1) {
            ivbclose (psvbptr->idatahandle);
        }
        if (psvbptr->idatahandle != -1) {
            ivbclose (psvbptr->iindexhandle);
        }
        if (psvbptr->cfilename) {
            free (psvbptr->cfilename);
        }
        if (psvbptr->ppcrowbuffer) {
            free (psvbptr->ppcrowbuffer);
        }
        vvbfree (psvbptr);
    }
    psvbfile[ihandle] = NULL;
    iserrno = errno;
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int issetcollate	(	const int	ihandle,
		const unsigned char *	collating_sequence
	)

Definition at line 540 of file isopen.c.

References DICTINFO::collating_sequence, DICTINFO::iisopen, iserrno, ivbmaxusedhandle, psvbfile, and unlikely.

{
    struct DICTINFO *psvbptr;

    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        iserrno = EBADARG;
        return -1;
    }
    psvbptr = psvbfile[ihandle];
    if (!psvbptr || psvbptr->iisopen) {
        iserrno = ENOTOPEN;
        return -1;
    }
    psvbptr->collating_sequence = collating_sequence;
    return 0;
}

int ivbclose2

(

const int

ihandle

)

Definition at line 83 of file isopen.c.

References DICTINFO::cfilename, DICTINFO::idatahandle, DICTINFO::iindexhandle, DICTINFO::iisopen, iserrno, isrelease(), DICTINFO::itransyet, ivbclose(), ivbtransclose(), MAXSUBS, NULL, DICTINFO::pskeycurr, VBFILE::pslockhead, VBFILE::pslocktail, VBLOCK::psnext, psvbfile, svbfile, DICTINFO::tdupnumber, DICTINFO::trownumber, and vvblockfree().

Referenced by iscleanup(), isclose(), iscommit(), and isrollback().

{
    struct VBLOCK   *psrowlock;
    struct DICTINFO *psvbptr;
    int     iloop;
    int     iindexhandle;

    psvbptr = psvbfile[ihandle];
    psvbptr->iisopen = 0;   /* It's a LIE, but so what! */
    isrelease (ihandle);
    iserrno = ivbtransclose (ihandle, psvbptr->cfilename);
    if (ivbclose (psvbptr->idatahandle)) {
        iserrno = errno;
    }
    psvbptr->idatahandle = -1;
    if (ivbclose (psvbptr->iindexhandle)) {
        iserrno = errno;
    }
    iindexhandle = psvbptr->iindexhandle;
    while (svbfile[iindexhandle].pslockhead) {
        psrowlock = svbfile[iindexhandle].pslockhead->psnext;
        vvblockfree (svbfile[iindexhandle].pslockhead);
        svbfile[iindexhandle].pslockhead = psrowlock;
    }
    svbfile[iindexhandle].pslocktail = NULL;
    psvbptr->iindexhandle = -1;
/* RXW
    psvbptr->trownumber = -1;
    psvbptr->tdupnumber = -1;
*/
    psvbptr->trownumber = 0;
    psvbptr->tdupnumber = 0;
    psvbptr->iisopen = 2;   /* Only buffers remain! */
    psvbptr->itransyet = 0;
    for (iloop = 0; iloop < MAXSUBS; iloop++) {
        psvbptr->pskeycurr[iloop] = NULL;
    }

    return (iserrno ? -1 : 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ivbclose3

(

const int

ihandle

)

Definition at line 125 of file isopen.c.

References DICTINFO::cfilename, MAXSUBS, NULL, DICTINFO::ppcrowbuffer, DICTINFO::pskeydesc, DICTINFO::pstree, psvbfile, vvbfree(), vvbkeyunmalloc(), and vvbtreeallfree().

Referenced by isbuild(), iscleanup(), iserase(), and isfullclose().

{
    struct DICTINFO *psvbptr;
    int     iloop;

    psvbptr = psvbfile[ihandle];
    if (!psvbptr) {
        return;
    }
    for (iloop = 0; iloop < MAXSUBS; iloop++) {
        vvbtreeallfree (ihandle, iloop, psvbptr->pstree[iloop]);
        if (psvbptr->pskeydesc[iloop]) {
            vvbkeyunmalloc (ihandle, iloop);
            vvbfree (psvbptr->pskeydesc[iloop]);
        }
    }
    if (psvbptr->cfilename) {
        free (psvbptr->cfilename);
    }
    if (psvbptr->ppcrowbuffer) {
        free (psvbptr->ppcrowbuffer);
    }
    vvbfree (psvbptr);
    psvbfile[ihandle] = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbforceexit

(

const int

ihandle

)

Definition at line 50 of file isopen.c.

References cvbnodetmp, DICTINFO::iisdictlocked, iserrno, ivbblockwrite(), psvbfile, DICTINFO::sdictnode, and VB_NODE_MAX.

Referenced by isclose().

{
    struct DICTINFO *psvbptr;
    int     iresult = 0;
    char        cvbnodetmp[VB_NODE_MAX];

    psvbptr = psvbfile[ihandle];
    if (psvbptr->iisdictlocked & 0x02) {
        memset (cvbnodetmp, 0, VB_NODE_MAX);
        memcpy ((void *)cvbnodetmp, (void *)&psvbptr->sdictnode,
            sizeof (struct DICTNODE));
        iresult = ivbblockwrite (ihandle, 1, (off_t) 1, cvbnodetmp);
        if (iresult) {
            iserrno = EBADFILE;
        } else {
            iserrno = 0;
        }
    }
    psvbptr->iisdictlocked = 0;
    if (iresult) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: