static int
f_unl_com (alist *a, int lock)
#endif
{
unit *ftnunit = find_luno(a->aunit);
if (ftnunit == NULL)
err (a->aerr, 101, "unlock");
while (lock && test_and_set( &ftnunit->lock_unit, 1L ))
;
if (ftnunit->uconn > 0) {
if (ftnunit->uacc != KEYED)
errret(a->aerr, 163, "unlock");
if (isrelease (ftnunit->isfd) < SUCCESS)
ierrret(a->aerr, iserrno, "unlock");
}
else
err (a->aerr, 101, "delete");
if (lock) ftnunit->lock_unit = 0;
return 0;
}
int
isstart (const int ihandle, struct keydesc *pskeydesc, int ilength, char *pcrow, int imode)
{
struct VBKEY *pskey;
struct DICTINFO *psvbptr;
int ikeynumber, iresult;
unsigned char ckeyvalue[VB_MAX_KEYLEN];
unsigned char ckeyvalue2[VB_MAX_KEYLEN];
if (ivbenter (ihandle, 0, 0)) {
return -1;
}
psvbptr = psvbfile[ihandle];
ikeynumber = ivbcheckkey (ihandle, pskeydesc, 2, 0, 0);
iresult = -1;
if (ikeynumber == -1 && pskeydesc->k_nparts) {
goto startexit;
}
if (ilength < 1 || ilength > psvbptr->pskeydesc[ikeynumber]->k_len) {
ilength = pskeydesc->k_len;
}
psvbptr->iactivekey = ikeynumber;
if (!(imode & ISKEEPLOCK)) {
isrelease (ihandle);
}
imode &= BYTEMASK;
if (!pskeydesc->k_nparts) {
iresult = istartrownumber (ihandle, imode, 0);
if (iresult && iserrno == ENOREC && imode <= ISLAST) {
iresult = 0;
iserrno = 0;
}
goto startexit;
}
iserrno = 0;
switch (imode) {
case ISFIRST: /* ckeyvalue is just a placeholder for 1st/last */
psvbptr->iisdisjoint = 1;
iresult = ivbkeysearch (ihandle, ISFIRST, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iresult < 0) {
break;
}
iresult = 0;
break;
case ISLAST: /* ckeyvalue is just a placeholder for 1st/last */
psvbptr->iisdisjoint = 0;
iresult = ivbkeysearch (ihandle, ISLAST, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iresult < 0 || iresult > 2) {
iresult = -1;
break;
}
iserrno = ivbkeyload (ihandle, ikeynumber, ISPREV, 1, &pskey);
if (iserrno) {
iresult = -1;
}
break;
case ISEQUAL:
psvbptr->iisdisjoint = 1;
vvbmakekey (psvbptr->pskeydesc[ikeynumber], pcrow, ckeyvalue2);
memset (ckeyvalue, 0, sizeof (ckeyvalue));
memcpy (ckeyvalue, ckeyvalue2, (size_t)ilength);
if (ilength < pskeydesc->k_len) {
iresult = ivbkeysearch (ihandle, ISGTEQ, ikeynumber, 0, ckeyvalue, (off_t)0);
} else {
iresult = ivbkeysearch (ihandle, ISEQUAL, ikeynumber, ilength, ckeyvalue, (off_t)0);
}
iserrno = EBADFILE;
if (iresult == -1) { /* Error */
break;
}
/* Map EQUAL onto OK and LESS THAN onto OK if the basekey is == */
if (iresult == 1) {
iresult = 0;
} else if (iresult == 0
&& memcmp (ckeyvalue,
psvbptr->pskeycurr[psvbptr->iactivekey]->ckey,
(size_t)ilength)) {
iserrno = ENOREC;
iresult = -1;
}
break;
case ISGREAT:
case ISGTEQ:
psvbptr->iisdisjoint = 1;
vvbmakekey (psvbptr->pskeydesc[ikeynumber], pcrow, ckeyvalue2);
if (ilength < pskeydesc->k_len && imode == ISGREAT) {
memset (ckeyvalue, 255, sizeof (ckeyvalue));
} else {
memset (ckeyvalue, 0, sizeof (ckeyvalue));
}
memcpy (ckeyvalue, ckeyvalue2, (size_t)ilength);
iresult = ivbkeysearch (ihandle, imode, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iserrno == EENDFILE) {
iserrno = ENOREC;
iresult = -1;
break;
}
if (iresult < 0) { /* Error is always error */
break;
}
if (iresult < 2) {
iresult = 0;
break;
}
iserrno = EENDFILE;
iresult = -1;
break;
default:
iserrno = EBADARG;
iresult = -1;
}
if (!iresult) {
iserrno = 0;
isrecnum = psvbptr->pskeycurr[ikeynumber]->trownode;
psvbptr->trowstart = isrecnum;
} else {
psvbptr->trowstart = 0;
iresult = -1;
}
startexit:
psvbptr->iisdictlocked |= 0x04;
ivbexit (ihandle);
return iresult;
}
int
isread (const int ihandle, char *pcrow, int imode)
{
struct VBKEY *pskey;
struct DICTINFO *psvbptr;
int ideleted = 0, ikeynumber, ilockresult = 0;
int ireadmode, iresult = -1;
unsigned char ckeyvalue[VB_MAX_KEYLEN];
if (ivbenter (ihandle, 0, 0)) {
return -1;
}
iserrno = EBADKEY;
psvbptr = psvbfile[ihandle];
ikeynumber = psvbptr->iactivekey;
if (psvbptr->iopenmode & ISAUTOLOCK) {
isrelease (ihandle);
}
ireadmode = imode & BYTEMASK;
if (ikeynumber == -1 || !psvbptr->pskeydesc[ikeynumber]->k_nparts) {
/*
* This code relies on the fact that istartrownumber will
* populate the global VBISAM pcrowbuffer with the fixed-length
* portion of the row on success.
*/
iresult = istartrownumber (ihandle, ireadmode, 1);
if (!iresult) {
memcpy (pcrow, psvbptr->ppcrowbuffer, (size_t)psvbptr->iminrowlength);
psvbptr->iisdisjoint = 0;
}
goto read_exit;
}
iserrno = 0;
isrecnum = 0;
switch (ireadmode) {
case ISFIRST:
/* ckeyvalue is just a placeholder for ISFIRST */
iresult = ivbkeysearch (ihandle, ISFIRST, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iresult < 0) {
break;
}
if (iresult == 2) {
iserrno = EENDFILE;
} else {
iresult = 0;
}
break;
case ISLAST:
/*
* ckeyvalue is just a placeholder for ISLAST
* Note that the KeySearch (ISLAST) will position the pointer onto the
* LAST key of the LAST tree which, by definition, is a DUMMY key
*/
iresult = ivbkeysearch (ihandle, ISLAST, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iresult < 0) {
break;
}
if (iresult == 2) {
iserrno = EENDFILE;
} else {
iresult = 0;
iserrno = ivbkeyload (ihandle, ikeynumber, ISPREV, 1, &pskey);
if (iserrno) {
iresult = -1;
}
}
break;
case ISEQUAL:
vvbmakekey (psvbptr->pskeydesc[ikeynumber], pcrow, ckeyvalue);
iresult = ivbkeysearch (ihandle, ISGTEQ, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iresult == -1) { /* Error */
break;
}
if (iresult == 1) { /* Found it! */
iresult = 0;
} else {
if (psvbptr->pskeycurr[ikeynumber]->iisdummy) {
iresult = ivbkeyload (ihandle, ikeynumber, ISNEXT, 1, &pskey);
if (iresult == EENDFILE) {
iresult = -1;
iserrno = ENOREC;
break;
}
iserrno = 0;
}
if (memcmp (ckeyvalue, psvbptr->pskeycurr[ikeynumber]->ckey,
(size_t)psvbptr->pskeydesc[ikeynumber]->k_len)) {
iresult = -1;
iserrno = ENOREC;
} else {
iresult = 0;
}
}
break;
case ISGREAT:
case ISGTEQ:
vvbmakekey (psvbptr->pskeydesc[ikeynumber], pcrow, ckeyvalue);
iresult = ivbkeysearch (ihandle, ireadmode, ikeynumber, 0, ckeyvalue, (off_t)0);
if (iresult < 0) { /* Error is always error */
break;
}
if (iresult == 2) {
iserrno = EENDFILE;
break;
}
if (iresult == 1) {
iresult = 0;
} else {
iresult = 0;
if (psvbptr->pskeycurr[ikeynumber]->iisdummy) {
iserrno = EENDFILE;
iresult = -1;
}
}
break;
case ISPREV:
if (psvbptr->trowstart) {
iresult = ivbkeylocaterow (ihandle, ikeynumber,
psvbptr->trowstart);
} else if (psvbptr->trownumber) {
iresult = ivbkeylocaterow (ihandle, ikeynumber,
psvbptr->trownumber);
} else {
iserrno = ENOCURR;
iresult = -1;
break;
}
if (iresult) {
iserrno = ENOCURR;
} else {
iresult = 0;
iserrno = ivbkeyload (ihandle, ikeynumber, ISPREV, 1, &pskey);
if (iserrno) {
iresult = -1;
}
}
break;
case ISNEXT: /* Might fall thru to ISCURR */
if (!psvbptr->iisdisjoint) {
if (psvbptr->trowstart) {
iresult = ivbkeylocaterow (ihandle, ikeynumber,
psvbptr->trowstart);
} else if (psvbptr->trownumber) {
iresult = ivbkeylocaterow (ihandle, ikeynumber,
psvbptr->trownumber);
} else {
iserrno = ENOCURR;
iresult = -1;
break;
}
if (iresult) {
iserrno = EENDFILE;
} else {
iresult = 0;
iserrno = ivbkeyload (ihandle, ikeynumber, ISNEXT, 1, &pskey);
if (iserrno) {
iresult = -1;
}
}
break; /* Exit the switch case */
}
case ISCURR:
if (psvbptr->trowstart) {
iresult = ivbkeylocaterow (ihandle, ikeynumber, psvbptr->trowstart);
} else if (psvbptr->trownumber) {
iresult = ivbkeylocaterow (ihandle, ikeynumber,
psvbptr->trownumber);
} else {
iserrno = ENOCURR;
iresult = -1;
break;
}
if (iresult) {
iserrno = ENOCURR;
}
break;
default:
iserrno = EBADARG;
iresult = -1;
}
/* By the time we get here, we're done with index positioning... */
/* If iresult == 0 then we have a valid row to read in */
if (!iresult) {
psvbptr->trowstart = 0;
if (imode & ISLOCK || psvbptr->iopenmode & ISAUTOLOCK) {
if (ivbdatalock
(ihandle, imode & ISWAIT ? VBWRLCKW : VBWRLOCK,
psvbptr->pskeycurr[ikeynumber]->trownode)) {
iresult = -1;
iserrno = ilockresult = ELOCKED;
}
}
if (!ilockresult) {
iresult = ivbdataread (ihandle, pcrow, &ideleted,
psvbptr->pskeycurr[ikeynumber]->trownode);
}
if (!iresult && (!ilockresult || (imode & ISSKIPLOCK && iserrno == ELOCKED))) {
isrecnum = psvbptr->pskeycurr[ikeynumber]->trownode;
psvbptr->trownumber = isrecnum;
psvbptr->iisdisjoint = 0;
}
}
read_exit:
psvbptr->iisdictlocked |= 0x04;
ivbexit (ihandle);
return iresult;
}
