/[webpac]/trunk2/openisis/ldb.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /trunk2/openisis/ldb.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 237 - (hide annotations)
Mon Mar 8 17:43:12 2004 UTC (15 years, 11 months ago) by dpavlin
Original Path: openisis/current/ldb.c
File MIME type: text/plain
File size: 80336 byte(s)
initial import of openisis 0.9.0 vendor drop

1 dpavlin 237 /*
2     openisis - an open implementation of the CDS/ISIS database
3     Version 0.8.x (patchlevel see file Version)
4     Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org
5    
6     This library is free software; you can redistribute it and/or
7     modify it under the terms of the GNU Lesser General Public
8     License as published by the Free Software Foundation; either
9     version 2.1 of the License, or (at your option) any later version.
10    
11     This library is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14     Lesser General Public License for more details.
15    
16     You should have received a copy of the GNU Lesser General Public
17     License along with this library; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19    
20     see README for more information
21     EOH */
22    
23     /*
24     $Id: ldb.c,v 1.95 2003/06/10 11:00:34 kripke Exp $
25     implementation of general db access functions.
26     */
27    
28     #include <stdlib.h>
29     #include <string.h>
30     #include <limits.h> /* PATH_MAX */
31     #include <errno.h>
32    
33    
34     /* special */
35     #if defined( __GNUC__ ) && defined ( alloca )
36     #include <alloca.h>
37     #endif
38    
39     /* gcc defines always a cpu type - this we use for byteorder checking */
40     #if defined( sparc ) || defined( __ppc__ )
41     # define LDB_BIG_ENDIAN
42     /* TODO: figure out fastest "htonl" on those boxes that usually don't swap */
43     static int rvi ( int i ) {
44     int r;
45     ((char*)&r)[0] = ((char*)&i)[3];
46     ((char*)&r)[1] = ((char*)&i)[2];
47     ((char*)&r)[2] = ((char*)&i)[1];
48     ((char*)&r)[3] = ((char*)&i)[0];
49     return r;
50     }
51     static short rvs ( short i ) {
52     short r;
53     ((char*)&r)[0] = ((char*)&i)[1];
54     ((char*)&r)[1] = ((char*)&i)[0];
55     return r;
56     }
57     #define SWI( i ) i = rvi( i )
58     #define SWS( s ) s = rvs( s )
59     #else
60     # define rvi(i) i
61     # define rvs(s) s
62     #define SWI( i )
63     #define SWS( s )
64     #endif
65     #if defined( sparc )
66     # define LDB_NEEDALIGN
67     #endif
68     #if defined( LDB_NEEDALIGN )
69     static unsigned GETINT ( const void *m )
70     {
71     unsigned l;
72     memcpy( &l, m, 4 );
73     return l;
74     }
75     static unsigned short GETSHORT ( const void *m )
76     {
77     unsigned short s;
78     memcpy( &s, m, 2 );
79     return s;
80     }
81     #else
82     #define GETINT( m ) (*(unsigned*)(m))
83     #define GETSHORT( m ) (*(unsigned short*)(m))
84     #endif
85    
86     #include "lstr.h"
87     #include "lio.h"
88     #include "lbt.h"
89     #include "lcs.h"
90     #include "ldb.h"
91     #include "lfdt.h"
92     #include "luti.h"
93    
94     #ifdef WIN32
95     #define IsAbsPath(p) \
96     ((p) && *(p) && ( \
97     '/' == *(p) || '\\' == *(p) || ( \
98     ':' == (p)[1] && ( \
99     '/' == (p)[2] || '\\' == (p)[2] \
100     ))))
101     #else
102     #define IsAbsPath(p) \
103     ((p) && '/' == *(p))
104     #endif
105    
106    
107     #define LF 10 /* LineFeed a.k.a. newline - '\n' isn't really well defined */
108     #define TAB 9 /* horizontal, that is */
109     #define VT 11 /* vertical, used as newline replacement */
110    
111     /* ************************************************************
112     private types
113     */
114    
115     /** extension of master file proper. */
116     static const char EXT_MST_MST[] = ".mst";
117     /** extension of master file xref. */
118     static const char EXT_MST_XRF[] = ".xrf";
119    
120     typedef enum {
121     MST_MST,
122     MST_XRF,
123     MST_FILES
124     } mst_file;
125    
126     static const char * const EXT_MST[MST_FILES] = {
127     EXT_MST_MST,
128     EXT_MST_XRF
129     };
130    
131     /** extension of inverted file short term nodes. */
132     static const char EXT_INV_N01[] = ".n01";
133     /** extension of inverted file short term leaves. */
134     static const char EXT_INV_L01[] = ".l01";
135     /** extension of inverted file long term nodes. */
136     static const char EXT_INV_N02[] = ".n02";
137     /** extension of inverted file long term leaves. */
138     static const char EXT_INV_L02[] = ".l02";
139     /** extension of inverted file control records. */
140     static const char EXT_INV_CNT[] = ".cnt";
141     /** extension of inverted file postings. */
142     static const char EXT_INV_IFP[] = ".ifp";
143    
144     typedef enum {
145     INV_N01,
146     INV_L01,
147     INV_N02,
148     INV_L02,
149     INV_CNT,
150     INV_IFP,
151     INV_FILES
152     } inv_file;
153    
154     static const char * const EXT_INV[INV_FILES] = {
155     EXT_INV_N01,
156     EXT_INV_L01,
157     EXT_INV_N02,
158     EXT_INV_L02,
159     EXT_INV_CNT,
160     EXT_INV_IFP
161     };
162    
163     /** extension of lbt B-Link-Tree.
164     It's named oxi because that is nicer than oix for OpenIsis indeX.
165     however, see http://www.oxicenter.com.br/
166     */
167     static const char EXT_LBT_OXI[] = ".oxi";
168     static const char * const EXT_LBT[] = {
169     EXT_LBT_OXI
170     };
171    
172    
173     /** plaintext master file
174     */
175     static const char EXT_TXT_TXT[] = ".txt";
176     static const char EXT_TXT_PTR[] = ".ptr";
177     static const char EXT_TXT_OPT[] = ".opt";
178     typedef enum {
179     TXT_TXT,
180     TXT_PTR,
181     TXT_FILES
182     } txt_file;
183     static const char * const EXT_TXT[] = {
184     EXT_TXT_TXT,
185     EXT_TXT_PTR
186     };
187    
188     static const char ISIX[] = "ISIX"; /* ptr magic */
189    
190    
191     /** extension of supporting file alpha character table. */
192     static const char EXT_SUP_ACT[] = ".act";
193     /** extension of supporting file uppercase table. */
194     static const char EXT_SUP_UCT[] = ".uct";
195    
196     typedef enum {
197     SUP_ACT,
198     SUP_UCT,
199     SUP_FILES
200     } sup_file;
201    
202     static const char * const EXT_SUP[SUP_FILES] = {
203     EXT_SUP_ACT,
204     EXT_SUP_UCT
205     };
206    
207    
208     typedef int lblk[128];
209    
210    
211     typedef struct {
212     Db head;
213     int flags;
214     const char *path;
215     int mst[MST_FILES]; /* master file */
216     int inv[INV_FILES]; /* primary inverted file */
217     int mfc[LMFC__FL]; /* master file control record */
218     unsigned mflen; /* master file length */
219     int xrf[129]; /* last used xrf block : THREAD THREAT */
220     int xrlen; /* length of xrf (in blocks) */
221     unsigned short ptr; /* type of pointer file (new style xrf) */
222     unsigned short ptrl; /* pointer bytes, 512 for old xrf */
223     char *mmap; /* memory map of xrf/ptr */
224     int mmlen; /* length of map (in ptrl) */
225     int cnt[LDB_INDEXES][LCNT__FL]; /* two cnt records */
226     short tlen[LDB_INDEXES]; /* max term length for each index */
227     LcsTab ctab[LCS__TABS];
228     Idx oxi;
229     } LDb;
230    
231    
232     typedef union {
233     lll bar;
234     char r[16];
235     } Ptr;
236    
237    
238     /* db flags */
239     #define DB_OPEN 0x010000
240     #define DB_INVOPEN 0x020000
241     #define DB_LBTOPEN 0x040000
242     #define DB_TXTOPEN 0x080000
243     #define DB_WRITABLE 0x100000
244     #define DB_MODIFIED 0x200000
245    
246     #define DB_TXTMODE 0x20
247     #define DB_MMAP 0x10
248     #define DB_VARI 0xf /* mask for variant */
249    
250    
251     /* get xstr for record rec in set */
252     #define DB_XSTR( db, set, rec ) \
253     lstrlib[ set ].desc[ DB_VARI & (db)->flags ][ rec ]
254     /* get record names for record rec in set */
255     #define DB_RNAM( db, set, rec ) \
256     lstrlib[ set ].name[ rec ]
257    
258    
259     /** packed little endian masterfile control structure.
260     */
261     typedef struct Mfc {
262     int ctlm;
263     int nmfn;
264     int nmfb;
265     short nmfp;
266     short type;
267     int rcnt;
268     int mfx1;
269     int mfx2;
270     int mfx3;
271     } Mfc;
272    
273    
274     /** packed little endian masterfile record.
275     */
276     typedef struct Dict {
277     short tag;
278     short pos;
279     short len;
280     } Dict;
281    
282     /** packed little endian masterfile record.
283     */
284     typedef struct Mfr {
285     int mfn;
286     short recl; /* a.k.a. mfrl */
287     short bwbl; /* low part of int */
288     short bwbh; /* high part of int */
289     short bwp;
290     /* it is believed, that this first five fields up to here (12 bytes packed)
291     are to be in one 512-byte block; the manual mentiones even 14 bytes ... ???
292     */
293     short base;
294     short nvf;
295     short stat;
296     Dict dict[1];
297     } Mfr;
298    
299    
300    
301     /* ************************************************************
302     private data
303     */
304    
305     static LDb defdbspace[32];
306     /* array of open dbs. should expand dynamically. */
307     static LDb *dbs = defdbspace;
308     static int dbs_len = sizeof(defdbspace)/sizeof(defdbspace[0]);
309    
310     static int init;
311    
312    
313     /* ************************************************************
314     private functions
315     */
316     static LDb *getDb ( int id )
317     {
318     if ( 0 <= id && id < dbs_len && dbs[id].flags ) {
319     return &dbs[id];
320     }
321     log_msg( LOG_ERROR, "attempt to access bad db id %d", id );
322     return 0;
323     } /* getDb */
324    
325    
326     /* ************************************************************
327     start of io section
328     */
329     enum {
330     /* additional flags in the LIO_FD range */
331     OPEN_TRY = 1, /* try writable, open readonly else */
332     OPEN_UC = 2, /* use uppercase ext */
333     /* commonly used combinations */
334     /* 1) open as is, do not complain about any failure, do not create */
335     OPEN_ASIS = LIO_SEEK|LIO_RDWR|OPEN_TRY,
336     /* 2) open readonly, do not complain about any failure, do not create */
337     OPEN_RDIF = LIO_SEEK|LIO_RD|LIO_TRY,
338     /* 3) open readonly, complain about any failure */
339     OPEN_RD = LIO_SEEK|LIO_RD,
340     /* 4) open or create writable, complain on failure */
341     OPEN_NEW = LIO_SEEK|LIO_RDWR|LIO_CREAT,
342     OPEN_BLANK = LIO_SEEK|LIO_RDWR|LIO_CREAT|LIO_TRUNC
343     };
344    
345     /* figure out wether to use uppercase extension on path.
346     if last path component (everything after the last / and \)
347     does contain an uppercase ascii and does not contain a lowercase ascii,
348     return OPEN_UC, else 0.
349     */
350     static int autocase ( const char *path )
351     {
352     int ret = 0;
353     const char *e = path + strlen( path );
354     while ( e-- > path )
355     if ( 'A'<=*e && *e<= 'Z' )
356     ret = OPEN_UC;
357     else if ( 'a'<=*e && *e<= 'z' )
358     return 0;
359     else if ( '/'==*e || '\\' == *e )
360     break;
361     return ret;
362     }
363    
364     /* set extension. fname MUST already end with .xxx.
365     if how has OPEN_UC set, use uppercase extension
366     */
367     static char *setext ( char *fname, const char *ext, int how )
368     {
369     int l = strlen( fname ) - 4;
370     memcpy( fname+l, ext, 4 );
371     if ( OPEN_UC & how ) {
372     char *p = fname+l;
373     for ( ;*p; p++ ) /* use uppercase extensions */
374     if ( 'a' <= *p && *p <= 'z' )
375     *p -= 'a'-'A';
376     }
377     return fname;
378     }
379    
380     /**
381     try to open all files according to how.
382     ldb is only interested in seekable readable true files.
383     @return
384     1 if all files could be opened writable
385     0 if all files could be opened readonly,
386     and that was requested by a RD mode or try write
387     something negative else
388     */
389     static int openfiles ( int *fid, char *path,
390     const char * const *ext, int nfiles, int how )
391     {
392     int i;
393     int wr = LIO_WR&how ? 1 : 0, mode = LIO_WANT & how;
394    
395     for ( i=0; i<nfiles; i++ ) {
396     setext( path, ext[i], how );
397     fid[i] = lio_open( path, mode & LIO_WANT );
398     log_msg( LOG_INFO, "opening file '%s' %c 0x%x",
399     path, wr ? 'w' : 'r', fid[i] );
400     if ( 0 < fid[i] ) { /* ok */
401     mode &= ~LIO_FLOCK; /* lock only leading file */
402     continue;
403     }
404     fid[i] = 0;
405     while ( i-- ) /* close others */
406     lio_close( &fid[i], LIO_INOUT );
407     if ( OPEN_TRY & how )
408     return openfiles( fid, path, ext, nfiles,
409     (how & ~(OPEN_TRY|LIO_WR)) | LIO_TRY );
410     return LIO_TRY&how ? -ERR_BADF /* silent */
411     : log_msg( LOG_SYSERR, "could not open file '%s' for %sing",
412     path, wr ? "writ" : "read" );
413     }
414     return wr; /* good */
415     } /* openfiles */
416    
417    
418     static int closefiles ( int *fid, int nfiles )
419     {
420     int ret = 0, i;
421     for ( i=0; i<nfiles; i++ )
422     if ( 0 < fid[i] && LIO_INOUT & fid[i] )
423     lio_close( &fid[i], LIO_INOUT );
424     return ret;
425     } /* closefiles */
426    
427    
428     static int readblk ( void *dst, int siz, int fid, int where )
429     {
430     int got;
431     got = lio_pread( &fid, dst, siz, where );
432     if ( 0 > got )
433     return got;
434     #ifndef NDEBUG
435     if ( LOG_DO( LOG_ALL ) )
436     LOG_HEX( dst, got );
437     #endif
438     if ( siz == (int)got )
439     return 0;
440     log_msg( LOG_WARN, "got %u bytes wanted %d at %d in 0x%x",
441     got, siz, where, fid );
442     return 1+(int)got;
443     } /* readblk */
444    
445    
446     /* ************************************************************
447     end of io section
448     */
449    
450     static int *nrec ( int *xstr )
451     {
452     int *dst = (int*)mAlloc( xstr[LSTR_ILEN] );
453     if ( dst )
454     *dst = *xstr;
455     return dst;
456     } /* nrec */
457    
458    
459    
460     typedef struct b8 { char x[8]; } b8;
461     typedef struct b4 { char x[4]; } b4;
462     typedef struct b2 { char x[2]; } b2;
463    
464    
465     static int convert ( int *dst, char *src, int *xstr )
466     {
467     static int pow2[] = { 1, 2, 4, 8 };
468     int occ = -1;
469     int *xmbrs = xstr+LSTR_XMBR;
470     int nmbrs = LSTRFIX(*xstr);
471     int *mbr;
472     char *buf, *part = src, *srcend = src + xstr[LSTR_XLEN];
473    
474     if ( ! dst )
475     return log_msg( ERR_NOMEM, "out of memory (no dst) in convert" );
476     if ( LSTRLEN(*xstr) > xstr[LSTR_ILEN] )
477     return log_msg( ERR_INVAL, "bad ilen %d need %d",
478     xstr[LSTR_ILEN], (int)LSTRLEN(*xstr) );
479     if ( *dst != *xstr )
480     return log_msg( ERR_INVAL, "bad *dst 0x%08x need 0x%08x", *dst, *xstr );
481     /* clean and re-init */
482     memset( dst, 0, xstr[LSTR_ILEN] );
483     *dst = *xstr;
484     mbr = dst+1;
485     buf = ((char*)dst) + LSTRLEN(*dst);
486    
487     /* cvt the fixed part (occ==-1) and each occurrence of repeated part. */
488     for ( ;/* occ < LSTROCC(*dst) */; ) { /* cvt one part */
489     int i;
490     for ( i=0; i<nmbrs; i++, mbr++ ) { /* assign one xmbr */
491     int xmbr = xmbrs[i];
492     char *s = part + LONG2OFF(xmbr);
493     int sbytes = srcend - s;
494     int len,j;
495     union {
496     char buf[8];
497     b8 x8;
498     b4 x4;
499     b2 x2;
500     short s;
501     int i;
502     lll ll;
503     } num;
504     if ( LMBRISNUM( xmbr ) ) {
505     /* numeric data */
506     #ifdef LDB_BIG_ENDIAN
507     # define NEEDSWAP(xmbr) ( ! ( LMBR_FHIE & (xmbr) ) )
508     #else
509     # define NEEDSWAP(xmbr) (LMBR_FHIE & (xmbr))
510     #endif
511     int ld = LMBRLD(xmbr);
512     #ifndef LDB_NEEDALIGN
513     if ( ! NEEDSWAP( xmbr ) ) {
514     /* much faster this way ... */
515     /* TODO: len and bit checks; actually not needed yet ... */
516     switch ( ld ) {
517     case 3: *mbr = *(lll*)s; break;
518     case 2: *mbr = *(int*)s; break;
519     case 1: *mbr = *(short*)s; break;
520     case 0: *mbr = *s; break;
521     }
522     continue;
523     }
524     #endif
525     len = pow2[ LMBRLD(xmbr) ];
526     if ( len > sbytes )
527     return log_msg( ERR_INVAL,
528     "srcbuf too short %d have %d need %d occ %d mbr %d",
529     xstr[LSTR_XLEN], sbytes, len, occ, i );
530     if ( !NEEDSWAP( xmbr ) )
531     /* for ( j = len; j--; ) num.buf[j] = s[j]; */
532     switch ( ld ) {
533     case 3: num.x8 = *(b8*)s; break;
534     case 2: num.x4 = *(b4*)s; break;
535     case 1: num.x2 = *(b2*)s; break;
536     case 0: num.buf[0] = *s; break;
537     }
538     else /* swap bytes */
539     for ( j = len; j--; )
540     num.buf[j] = s[len - 1 - j];
541     switch ( len ) {
542     case 8: *mbr = num.ll; break;
543     /* TODO: defines for 16 and 64 bit compilers */
544     case 4: *mbr = num.i; break;
545     case 2: *mbr = num.s; break;
546     case 1: *mbr = num.buf[0]; break;
547     }
548     if ( LMBRISBITS( xmbr ) ) { /* apply bit shift and mask */
549     *mbr >>= LMBRBITOFF( xmbr );
550     *mbr &= ~(-1L << LMBRBITLEN( xmbr ));
551     }
552     continue;
553     }
554     /* else raw data -- that's easy :) */
555     {
556     int offset = buf - (char*)dst;
557     int need;
558     len = LONG2LEN(xmbr);
559     need = offset + len;
560     if ( need > xstr[LSTR_ILEN] )
561     return log_msg( ERR_INVAL,
562     "bad buflen %d need %d+%d in occ %d mbr %d",
563     xstr[LSTR_ILEN], offset, len, occ, i );
564     if ( len > sbytes )
565     return log_msg( ERR_INVAL,
566     "srcbuf too short %d have %d need %d occ %d mbr %d",
567     xstr[LSTR_XLEN], sbytes, len, occ, i );
568     memcpy( buf, s, len );
569     *mbr = buf - (char*)dst;
570     buf += len;
571     }
572     } /* for mbrs */
573    
574     if ( ++occ >= LSTROCC(*dst) )
575     break;
576     if ( occ )
577     part += (short)xstr[LSTR_XRLO]; /* adv. rep. part len */
578     else { /* was the fixed part, setup for repeated */
579     nmbrs = LSTRREP(*xstr);
580     part += (short)(xstr[LSTR_XRLO]>>16); /* adv. rep. part off */
581     xmbrs += i;
582     }
583     }
584     return 0;
585     } /* convert */
586    
587    
588     static int readrec ( int *dst, int fid, int where, int *xstr )
589     {
590     char *buf = (char *)
591     #ifdef alloca
592     alloca( xstr[LSTR_XLEN] )
593     #else
594     mAlloc( xstr[LSTR_XLEN] )
595     #endif
596     ;
597     int got = 0;
598     int ret = 0;
599    
600     if ( ! buf )
601     return -ERR_NOMEM;
602     if ( 0 > where )
603     where = -where * xstr[LSTR_XLEN];
604     got = readblk( buf, xstr[LSTR_XLEN], fid, where );
605     ret = got ? got : convert( dst, buf, xstr );
606     #ifndef alloca
607     mFree( buf );
608     #endif
609    
610     return ret;
611     } /* readrec */
612    
613    
614     /* read and log */
615     static int readlog ( int *dst, int fid, int where, LDb *db, int set, int rec )
616     {
617     int ret = readrec( dst, fid, where, DB_XSTR( db, set, rec ) );
618     if ( !ret && LOG_DO( LOG_TRACE ) )
619     LOG_STR( dst, lstrlib[ set ].name[ rec ] );
620     return ret;
621     } /* readlog */
622    
623    
624    
625     /* ************************************************************
626     access functions for the record types
627     */
628    
629     static int getOff ( LDb *db, int rowid, int xr )
630     {
631     int rowix = rowid - 1; /* mfns count from 1 */
632     int xrf_block = rowix / 127;
633     int blkix = xrf_block + 1; /* ... so do xrf blocks */
634     int off;
635     if ( xrf_block < db->mmlen ) {
636     if ( xr )
637     ((lblk*)db->mmap)[xrf_block][1+(int)(rowix % 127)] = rvi( xr );
638     else
639     xr = rvi( ((lblk*)db->mmap)[xrf_block][1+(int)(rowix % 127)] );
640     } else {
641     int err = 0;
642     /* if ( LIO_LOCK() ) return -3; */
643     if ( xr ) { /* write */
644     if ( blkix <= db->xrlen ) {
645     SWI( xr );
646     if ( 4 != lio_pwrite( &db->mst[MST_XRF], &xr, 4,
647     xrf_block*512 + 4*(1 + (rowix % 127))) )
648     return 0;
649     } else { /* extent */
650     lblk extend;
651     memset( extend, 0, sizeof(extend) );
652     while ( db->xrlen < blkix ) { /* extend */
653     extend[0] = db->xrlen + 1; /* set blk id */
654     if ( blkix == extend[0] )
655     extend[1+(int)(rowix % 127)] = rvi( xr );
656     SWI( extend[0] );
657     if ( 512 != lio_pwrite( &db->mst[MST_XRF], extend, 512,
658     db->xrlen*512) )
659     return 0;
660     db->xrlen++;
661     }
662     }
663     if ( blkix == db->xrf[LXRF_XPOS] )
664     db->xrf[ LXRF_XREC + (int)(rowix % 127) ] = xr;
665     /* and go on read it back, just to check ... */
666     }
667     if ( blkix != db->xrf[LXRF_XPOS] ) {
668     int ret;
669     LOG_DBG( LOG_VERBOSE, "fetching xrf block %d had %d",
670     blkix, ! db->xrf ? -1 : db->xrf[LXRF_XPOS] );
671     ret = readlog( db->xrf, db->mst[MST_XRF],
672     -xrf_block, db, LSET_MST, LSTR_XRF );
673     if ( ret ) {
674     log_msg( LOG_ERROR, "\twhen fetching xrf block %d", blkix );
675     err = -1;
676     } else if ( blkix == -db->xrf[LXRF_XPOS] ) {
677     LOG_DBG( LOG_DEBUG, "hmmm ... negative" );
678     db->xrf[LXRF_XPOS] = blkix;
679     } else if ( blkix != db->xrf[LXRF_XPOS] ) {
680     log_msg( LOG_WARN, "bad xrf %d wanted %d",
681     db->xrf[LXRF_XPOS], blkix );
682     err = -2;
683     }
684     }
685     xr = db->xrf[ LXRF_XREC + (int)(rowix % 127) ];
686     /* LIO_RELE(); */
687     if ( err )
688     return err;
689     }
690     /*
691     21 bits (<<11) signed for the (512 byte) block ("xrmfb")
692     1 for the first block (offset 0)
693     0 means, never had such a record
694     -1 and xrmfp=0: record removed from MST
695     (there is no record at pos 0 in 1st block,
696     since there resides the MST header)
697     other negative value -x or pos!=0:
698     record logically deleted, was at +x
699     1 bit (1<<10): this record is new and not yet inverted
700     1 bit (1<<9): this record is changed and not yet re-inverted
701     9 bits for the block-relative position ("xrmfp")
702     */
703     off = (((xr & 0xfffff800) >> 2) - 0x200) | (0x1ff & xr);
704     if ( 0 < (xr & ~0x600) ) {
705     LOG_DBG( LOG_DEBUG,
706     "offset for rowid %d is %d (blk %d pos %d) flg 0x%08x at %d[%d]",
707     rowid, off, (xr>>11)&0xfffff, xr&0x1ff, xr&0x80000600, blkix, rowix%127 );
708     return off;
709     }
710     /* deleted */
711     log_msg( LOG_INFO,
712     "offset for rowid %d is %d (blk %d pos %d) flg 0x%08x at %d[%d]",
713     rowid, off, (xr>>11)&0xfffff, xr&0x1ff, xr&0x80000600, blkix, rowix%127 );
714     return 0;
715     } /* getOff */
716    
717    
718     static int* getMfr ( LDb *db, int off, int *nxtoff )
719     {
720     struct mfcxstr {
721     int xstr[LSTR_LONGS(7+3)];
722     } my = *(struct mfcxstr *)DB_XSTR( db, LSET_MST, LSTR_MFR );
723     int head[1+7+3];
724     int len = 0, base;
725     int *rec = 0;
726     char *buf = 0;
727     #ifdef alloca
728     int notalloca = 0;
729     #endif
730    
731     LOG_DBG( LOG_VERBOSE, "getting MFR at off %d", off );
732     if ( 498 < off % 512 )
733     log_msg( LOG_WARN, "blk pos > 498 in offset 0x%08x", off );
734     *head = *my.xstr;
735     if ( readrec( head, db->mst[MST_MST], off, my.xstr ) ) {
736     log_msg( LOG_ERROR, "\twhen reading MFR head at %d", off );
737     return 0;
738     }
739     /* log_str( LOG_VERBOSE, head, lstrlib[LSET_MST].name[LSTR_MFR] ); */
740     len = head[LMFR_RECL];
741     LOG_DBG( LOG_VERBOSE, "got MFR %d reclen %d", head[LMFR_MFN], len );
742     if ( nxtoff ) {
743     *nxtoff = off + (0 < len ? len : -len); /* an odditiy */
744     if ( 1 & *nxtoff ) /* an odditiy */
745     (*nxtoff)++; /* round up to even */
746     if ( 498 < *nxtoff % 512 ) {
747     *nxtoff += 512;
748     *nxtoff &= ~0x1ff;
749     }
750     if ( *nxtoff > db->mfc[LMFC_NMFB]*512 + db->mfc[LMFC_NMFP] ) {
751     LOG_DBG( LOG_VERBOSE, "at end of db: %d > %d*512+%hd",
752     *nxtoff, db->mfc[LMFC_NMFB], db->mfc[LMFC_NMFP] );
753     *nxtoff = -1;
754     }
755     }
756     if ( len < 0 ) {
757     log_msg( LOG_INFO, "found deleted rec len %hd at offset %d", len, off );
758     return 0;
759     }
760    
761     /* check external base length */
762     base = LONG2OFF(my.xstr[LSTR_XRLO])
763     + head[LMFR_NVF]*LONG2LEN(my.xstr[LSTR_XRLO]);
764     if ( 0 > head[LMFR_BASE] || 0 > head[LMFR_NVF]
765     || 0x8fff < head[LMFR_NVF]
766     || len < head[LMFR_BASE] || len < base
767     || (head[LMFR_NVF] && head[LMFR_BASE] < base)
768     ) {
769     log_msg( LOG_ERROR,
770     "bad len %d base %d nvf %d need base %d at offset %d",
771     len, head[LMFR_BASE], head[LMFR_NVF], base, off );
772     /* check alignment problem */
773     base = LONG2OFF(my.xstr[LSTR_XRLO])
774     + head[LMFR_STAT]*LONG2LEN(my.xstr[LSTR_XRLO]);
775     if ( 0 > head[LMFR_NVF] || 0 > head[LMFR_STAT]
776     || 0x8fff < head[LMFR_STAT]
777     || len < head[LMFR_NVF] || len < base
778     || (head[LMFR_STAT] && head[LMFR_NVF] < base)
779     )
780     ;
781     else
782     log_msg( LOG_ERROR, "probably alignment problem, try -format aligned" );
783     goto cleanup;
784     }
785    
786     /* set up external structure for this rec */
787     my.xstr[LSTR_SIZE] |= head[LMFR_NVF] << 16; /* occ of rep. part */
788     my.xstr[LSTR_XLEN] = len;
789     /* internal base length */
790     base = LSTRLEN( *my.xstr );
791     /* internal len adjusted for the slightly longer base */
792     my.xstr[LSTR_ILEN] = len + base - head[LMFR_BASE]; /* the buffer */
793    
794     rec = nrec( my.xstr );
795     if ( ! rec ) {
796     log_msg( LOG_SYSERR, "could not alloc MFR of len %hd", my.xstr[LSTR_ILEN] );
797     goto cleanup;
798     }
799     buf = (char *)
800     #ifdef alloca
801     alloca( len );
802     /* first try faster alloca, but stack may be too limited for large records */
803     notalloca = ! buf;
804     if ( notalloca )
805     buf =
806     #endif
807     mAlloc( len );
808    
809     if ( ! buf ) {
810     log_msg( LOG_SYSERR, "could not alloc MFR of len %hd", len );
811     goto cleanup;
812     }
813     if ( readblk( buf, len, db->mst[MST_MST], off ) ) {
814     log_msg( LOG_ERROR, "\twhen reading MFR" );
815     goto cleanup;
816     }
817     #ifndef LDB_BIG_ENDIAN
818     if ( LVAR_PAC != (DB_VARI & db->flags) ) {
819     #endif
820     if ( convert( rec, buf, my.xstr ) ) {
821     log_msg( LOG_ERROR, "\twhen converting MFR" );
822     goto cleanup;
823     }
824     #ifndef LDB_BIG_ENDIAN
825     } else { /* 10% faster */
826     Mfr *mfr = (Mfr*)buf;
827     short *s = &mfr->dict->tag;
828     int *f = rec + LMFR__FL;
829     int *e = f + 3*head[LMFR_NVF];
830     rec[LMFR_MFN] = mfr->mfn;
831     rec[LMFR_RECL] = mfr->recl;
832     /*
833     rec[LMFR_BWB] = mfr->bwbh<<16 | mfr->bwbl;
834     rec[LMFR_BWP] = mfr->bwp;
835     */
836     rec[LMFR_BASE] = mfr->base;
837     rec[LMFR_NVF] = mfr->nvf;
838     rec[LMFR_STAT] = mfr->stat;
839     while ( f < e ) {
840     *f++ = *s++;
841     *f++ = *s++;
842     *f++ = *s++;
843     }
844     }
845     #endif
846    
847     if ( rec[LMFR_STAT] ) {
848     log_msg( LOG_WARN, "found status %hd", rec[LMFR_STAT] );
849     goto cleanok;
850     }
851    
852     /* do a consistency check */
853     if ( rec[LMFR_NVF] < 0 || rec[LMFR_BASE] < 0 ) {
854     log_msg( LOG_ERROR, "found neg. field nvf %hd base %hd",
855     rec[LMFR_NVF], rec[LMFR_BASE] );
856     goto cleanup;
857     }
858    
859     /* now care for the field values */
860     {
861     char *valsrc = buf+rec[LMFR_BASE];
862     char *recsta = ((char*)rec);
863     char *valdst = recsta + base;
864     int xbufl = rec[LMFR_RECL] - rec[LMFR_BASE];
865     int sumlens = 0;
866     int i;
867     for ( i=0; i < rec[LMFR_NVF]; i++ ) {
868     int *d = &rec[LMFR__FL + i*LMFR__RL];
869     if ( d[LMFR_POS] < 0 || d[LMFR_LEN] < 0 ) {
870     log_msg( LOG_ERROR,
871     "bad field %d at off %d: negativ pos %hd or len %hd",
872     i, off, d[LMFR_POS], d[LMFR_LEN] );
873     goto cleanup;
874     }
875     if ( d[LMFR_POS] + d[LMFR_LEN] > xbufl ) {
876     log_msg( LOG_ERROR,
877     "bad field %d at off %d: pos %hd + len %hd > buf %d",
878     i, off, d[LMFR_POS], d[LMFR_LEN], xbufl );
879     goto cleanup;
880     }
881     sumlens += d[LMFR_LEN];
882     if ( sumlens > xbufl ) {
883     log_msg( LOG_ERROR,
884     "bad fields at off %d: sum of lengths %d > buf %d",
885     off, sumlens, xbufl );
886     goto cleanup;
887     }
888     memcpy( valdst, valsrc+d[LMFR_POS], d[LMFR_LEN] );
889     d[LMFR_POS] = valdst - recsta;
890     valdst += d[LMFR_LEN];
891     }
892     } /* consistency check */
893     rec[LMFR_BWB] = /* "used" bytes */
894     rec[LMFR_RECL] = my.xstr[LSTR_ILEN];
895     rec[LMFR_BWP] = rec[LMFR_NVF]; /* avail fields = used fields */
896     rec[LMFR_BASE] = base;
897    
898     if ( LOG_TRACE <= log_lev )
899     LOG_STR( rec, lstrlib[LSET_MST].name[LSTR_MFR] );
900     goto done;
901    
902     cleanup:
903     if ( nxtoff )
904     *nxtoff = -1;
905     cleanok:
906     if ( rec ) {
907     mFree( rec );
908     rec = 0;
909     }
910     done:
911     if ( buf
912     #ifdef alloca
913     && notalloca
914     #endif
915     )
916     mFree( buf );
917     if ( rec )
918     *rec = db->head.dbid;
919     return rec;
920     } /* getMfr */
921    
922    
923     /** write the record.
924     If it doesn't yet have a mfn, assign one.
925     NOTE: on a BIG_ENDIAN, anything but the mfn and recl will be frobbed
926     after this call
927     */
928     static int putMfr ( LDb *db, Mfr *mfr )
929     {
930     int oldpos, newpos;
931     int ret;
932    
933     if ( !(db->flags & DB_WRITABLE) ) {
934     log_msg( LOG_ERROR, "db is not writable" );
935     return -1;
936     }
937     /* minimalist sanity check */
938     if ( mfr->nvf < 0
939     || mfr->base != 18 + 6*mfr->nvf
940     || mfr->base > mfr->recl
941     ) {
942     log_msg( LOG_ERROR, "bad nvf/base/recl %d/%d/%d ",
943     mfr->nvf, mfr->base, mfr->recl );
944     return -2;
945     }
946     db->flags |= DB_MODIFIED;
947     if ( mfr->mfn ) {
948     int block;
949     if ( db->mfc[LMFC_NMFN] > mfr->mfn )
950     oldpos = getOff( db, mfr->mfn, 0 );
951     else {
952     db->mfc[LMFC_NMFN] = mfr->mfn+1;
953     oldpos = 0;
954     }
955     mfr->bwp = 511 & oldpos;
956     block = 1 + (oldpos >> 9); /* blockno counting from 1 */
957     mfr->bwbl = 0xffff & block;
958     mfr->bwbh = block >> 16;
959     if ( db->mfc[LMFC_NMFN] <= mfr->mfn )
960     db->mfc[LMFC_NMFN] = mfr->mfn+1;
961     } else {
962     mfr->mfn = db->mfc[LMFC_NMFN]++; /* assign new mfn */
963     oldpos = 0;
964     mfr->bwbl = mfr->bwbh = mfr->bwp = 0;
965     }
966     mfr->stat = 0;
967     newpos = db->mflen;
968     if ( 498 < (newpos & 511) ) /* round up to next block boundary */
969     newpos = ~511 & (newpos + 14);
970     if ( 1 & newpos )
971     newpos++;
972     db->mflen = newpos + mfr->recl;
973     #ifdef LDB_BIG_ENDIAN
974     { /* swap swap swap */
975     Dict *d = mfr->dict;
976     short nvf = mfr->nvf;
977     SWI( mfr->mfn ); SWS( mfr->recl ); SWS( mfr->bwbl ); SWS( mfr->bwbh );
978     SWS( mfr->bwp ); SWS( mfr->base ); SWS( mfr->nvf ); SWS( mfr->stat );
979     for ( ; nvf--; d++ ) {
980     SWS( d->tag );
981     SWS( d->pos );
982     SWS( d->len );
983     }
984     }
985     #endif
986     ret = lio_pwrite( &db->mst[MST_MST], (char*)mfr, rvs(mfr->recl), newpos );
987     #ifdef LDB_BIG_ENDIAN
988     /* restore mnf, recl */
989     SWI( mfr->mfn );
990     SWS( mfr->recl );
991     #endif
992     if ( ret != mfr->recl )
993     return log_msg( ERR_TRASH, "could not write Mfr %d bytes got %d",
994     mfr->recl, ret );
995     getOff( db, mfr->mfn, (1 << (oldpos ? 9 : 10))
996     | (((newpos & 0xfffffe00) + 0x200) << 2) | (0x1ff & newpos) );
997    
998     return 0;
999     } /* putMfr */
1000    
1001    
1002     static int putRec ( LDb *db, Rec *rec )
1003     {
1004     int ret = 0, i;
1005     Mfr *mfr = 0;
1006     int buflen = 0;
1007     int reclen = 0;
1008     int contig = 1;
1009     #ifdef alloca
1010     int notalloca = 0;
1011     #endif
1012     const char *rbase = ((char *)rec) + rec->base;
1013     Dict *d;
1014     Field *f = rec->field;
1015     /* TODO: if not rec->len, delete ? */
1016     for ( i = rec->len; i--; f++ ) {
1017     if ( ! f->len )
1018     continue;
1019     if ( ! f->val )
1020     LOG_OTO( cleanup, ( ERR_FAULT, "bad rec NULL val" ) );
1021     contig = contig && (f->val == rbase + buflen);
1022     buflen += f->len;
1023     }
1024     reclen = 18 + 6*rec->len + buflen;
1025     if ( 1 & reclen )
1026     reclen++;
1027     mfr = (Mfr*)
1028     #ifdef alloca
1029     alloca( reclen );
1030     notalloca = ! mfr;
1031     if ( notalloca )
1032     mfr = (Mfr*)
1033     #endif
1034     mAlloc( reclen );
1035     if ( ! mfr )
1036     LOG_OTO( cleanup,
1037     ( ERR_NOMEM, "could not alloc MFR of len %hd", reclen ) );
1038     mfr->mfn = rec->rowid;
1039     mfr->recl = reclen;
1040     mfr->bwbl = mfr->bwbh = mfr->bwp = 0;
1041     mfr->base = 18 + 6*rec->len;
1042     mfr->nvf = rec->len;
1043     mfr->stat = 0;
1044     d = mfr->dict;
1045     f = rec->field;
1046     buflen = 0;
1047     for ( i = rec->len; i--; d++, f++ ) {
1048     d->tag = f->tag;
1049     d->pos = buflen;
1050     buflen += (d->len = f->len);
1051     }
1052     if ( contig )
1053     memcpy( ((char*)mfr)+mfr->base, rbase, buflen );
1054     else {
1055     char *mbase = ((char*)mfr)+mfr->base;
1056     d = mfr->dict;
1057     f = rec->field;
1058     for ( i = rec->len; i--; d++, f++ )
1059     if ( d->len )
1060     memcpy( mbase + d->pos, f->val, d->len );
1061     }
1062     ret = putMfr( db, mfr );
1063     if ( !ret && !rec->rowid )
1064     rec->rowid = mfr->mfn;
1065    
1066     cleanup:
1067     if ( mfr
1068     #ifdef alloca
1069     && notalloca
1070     #endif
1071     )
1072     mFree( mfr );
1073     return ret;
1074     } /* putRec */
1075    
1076    
1077    
1078     /* ************************************************************
1079     access functions for plaintext db
1080     */
1081    
1082     /*
1083     create a pointer from the least significant bytes of pos, len, fld
1084     buf must have db->ptrl bytes (up to 16 = 8+4+4)
1085     and the most strict alignment (i.e. 4 or 8) possible for db->ptrl
1086     returns buf
1087     */
1088     static char *mkptr ( char *buf, LDb *db,
1089     unsigned pos, unsigned len, unsigned fld )
1090     {
1091     switch ( db->ptr ) {
1092     case 0x0134: /* '4' */
1093     ((unsigned*)buf)[0] = pos;
1094     if ( ~0xff & fld ) fld = 0;
1095     #ifdef LDB_BIG_ENDIAN /* the first = high order 3 bytes are len */
1096     ((unsigned*)buf)[1] = (0xff&fld) | len<<8;
1097     #else /* the first = low order 3 bytes are len */
1098     ((unsigned*)buf)[1] = (0xffffff&len) | fld<<24;
1099     #endif
1100     return buf;
1101     case 0x0044: /* 'D' */
1102     ((unsigned*)buf)[0] = pos;
1103     ((unsigned*)buf)[1] = len;
1104     return buf;
1105     case 0x0035: /* '5' */
1106     #ifdef LDB_BIG_ENDIAN /* the first = high order 5 bytes are pos */
1107     *(lll*)buf = (0xffffff&len) | ((lll)pos)<<24;
1108     #else /* the first = low order 5 bytes are pos */
1109     *(lll*)buf = pos | ((lll)len)<<40;
1110     #endif
1111     return buf;
1112     }
1113     /* TODO */
1114     (void)fld;
1115     assert( 0 );
1116     return 0;
1117     }
1118    
1119    
1120     /*
1121     read pointer, return len
1122     if 0x0f00 & db->ptr, fld must not be 0, else *fld is untouched
1123     */
1124     static unsigned rdptr ( unsigned *pos, unsigned *fld, LDb *db, char *buf )
1125     {
1126     switch ( db->ptr ) {
1127     case 0x0134:
1128     *pos = *(unsigned*)buf;
1129     *fld = ((unsigned char *)buf)[7];
1130     #ifdef LDB_BIG_ENDIAN
1131     return ((unsigned*)buf)[1] >> 8;
1132     #else
1133     return 0xffffff & ((unsigned*)buf)[1];
1134     #endif
1135     case 0x0044:
1136     *pos = *(unsigned*)buf;
1137     return ((unsigned*)buf)[1];
1138     case 0x0035:
1139     #ifdef LDB_BIG_ENDIAN
1140     /* *pos = (*(unsigned*)(buf+1)); would bus error on sparc */
1141     *pos = (unsigned) (*(lll*)buf >> 24);
1142     return 0xffffff & (unsigned)*(lll*)buf; /* last 3 bytes */
1143     #else /* guess there is no little endian that needs alignment ? */
1144     *pos = *(unsigned*)buf; /* use low order = first 4 of first 5 bytes */
1145     return 0xffffff & (*(unsigned*)(buf+5));
1146     #endif
1147     }
1148     /* TODO */
1149     (void)fld;
1150     assert( 0 );
1151     return 0;
1152     }
1153    
1154    
1155     static void setPtr ( LDb *db, int mfn,
1156     unsigned pos, unsigned len, unsigned fld )
1157     {
1158     Ptr pt;
1159     if ( mfn < db->mmlen ) {
1160     mkptr( db->mmap + mfn*db->ptrl, db, pos, len, fld );
1161     return;
1162     }
1163     lio_pwrite( &db->mst[MST_XRF],
1164     mkptr( pt.r, db, pos, len, fld), db->ptrl, mfn*db->ptrl );
1165     } /* setPtr */
1166    
1167    
1168     static unsigned getPtr ( unsigned *pos, unsigned *fld, LDb *db, int mfn )
1169     {
1170     Ptr pt;
1171     return mfn < db->mmlen
1172     ? rdptr( pos, fld, db, db->mmap + mfn*db->ptrl )
1173     : db->ptrl == lio_pread( &db->mst[MST_XRF],
1174     pt.r, db->ptrl, mfn*db->ptrl )
1175     ? rdptr( pos, fld, db, pt.r )
1176     : 0;
1177     } /* getPtr */
1178    
1179    
1180     #if 0
1181     static int putPlain ( LDb *db, Rec *rec )
1182     {
1183     return 0;
1184     } /* putPlain */
1185     #endif
1186    
1187     /**
1188     get text
1189     the original text is read contigously at base.
1190     the record is then cooked as requested:
1191     0 well done: do full fixup,
1192     apply conversions and create fields.
1193     1 english: do not create fields (rec->fields is 0), apply no conversions,
1194     but set rec->len to actual number of fields (counting if necessary).
1195     2 raw:
1196     set len only if it's known from the pointer
1197     */
1198     static Rec *dText ( LDb *db, int mfn, int raw )
1199     {
1200     unsigned base, sz, pos, len, fld; /* #fields actually used */
1201     unsigned n = 0; /* known #fields */
1202     Rec *r, *x;
1203     Field *f, *fe;
1204     char *p, *q, *e;
1205    
1206     len = getPtr( &pos, &n, db, mfn );
1207     LOG_DBG( LOG_TRACE, "dText %d pos %d len %d fld %d", mfn, pos, len, n );
1208     if ( !len )
1209     return 0;
1210     if ( raw )
1211     fld = 0;
1212     else if ( !(fld = n) ) {
1213     fld = len / 36; /* assume one (costing 12 bytes) per 36 bytes data */
1214     if ( fld < 8 ) /* small record is likely to have some short fields */
1215     fld = 8;
1216     }
1217     base = BASESZ(fld);
1218     sz = base + len;
1219     r = (Rec*)mAlloc( sz );
1220     p = ((char*)r) + base;
1221     if ( (int)len != lio_pread( &db->mst[MST_MST], p, len, pos ) ) {
1222     mFree( r );
1223     return 0;
1224     }
1225     LOG_DBG( LOG_TRACE, "'%.*s'", len, p );
1226     r->dbid = db->head.dbid;
1227     r->rowid = mfn;
1228     r->used = r->bytes = sz;
1229     r->fields = fld;
1230     r->base = base;
1231     r->len = n;
1232     if ( raw && (n || 1 != raw) )
1233     return r;
1234     e = p + len;
1235     f = r->field; /* next field to assign */
1236     fe = f + fld; /* end of assignable fields */
1237     /*
1238     loop through buffer lines to count a/o assign
1239     count them in n
1240     while f < fe, also fix and assign them
1241     */
1242     for ( n=0;;) { /* possibly 2 passes needed */
1243     for ( ;p < e; p = q+1 ) {
1244     if ( !(q = memchr( p, LF, e-p )) )
1245     q = e; /* > p */
1246     if ( TAB != *p || !n ) {
1247     if ( f < fe ) {
1248     p += a2il( p, q-p, &f->tag );
1249     if ( p < q && TAB == *p )
1250     p++;
1251     f->len = q - (f->val = p);
1252     f++; /* f == r->field+n, as long as we don't hit fe */
1253     }
1254     n++;
1255     continue;
1256     }
1257     /* continuation line */
1258     if ( f != r->field+n )
1259     continue;
1260     /* we ARE assigning & didn't loose sync at fe */
1261     /* append to previous */ {
1262     char *dest = (char*)f[-1].val + f[-1].len;
1263     int dist = p - dest, l = q-p;
1264     *p = LF;
1265     memmove( dest, p, l );
1266     memset( q-dist, ' ', dist ); /* cleanup */
1267     f[-1].len += l;
1268     }
1269     }
1270     /* now n != 0, since initially p < e, since len != 0 */
1271     if ( r->len && r->len != (int)n ) {
1272     log_msg( LOG_WARN, "rec %d len %d != ptr %d", mfn, n, r->len );
1273     break;
1274     }
1275     if ( raw || (int)n <= r->fields ) /* all counted/assigned */
1276     break;
1277     /* extend the record to n fields */
1278     log_msg( LOG_INFO, "extending rec %d %d -> %d fields", mfn, fld, n );
1279     fld = n;
1280     base = BASESZ(fld);
1281     sz = base + len;
1282     x = (Rec*)mAlloc( sz );
1283     x->dbid = db->head.dbid;
1284     x->rowid = mfn;
1285     x->used = x->bytes = sz;
1286     x->fields = fld;
1287     x->base = base;
1288     x->len = n;
1289     p = ((char*)x) + base;
1290     e = p + len;
1291     q = ((char*)r) + r->base;
1292     memcpy( p, q, len );
1293     memcpy( x->field, r->field, r->fields*sizeof(Field) );
1294     for ( f=x->field, n=r->fields; n--; )
1295     (f++)->val += p-q;
1296     n = r->fields;
1297     mFree( r );
1298     r = x;
1299     f = r->field + n;
1300     fe = r->field + fld;
1301     p = (char*)f[-1].val + f[-1].len;
1302     /* seek behind the LF that delimited the last field */
1303     while (LF != *p++)
1304     ;
1305     }
1306     r->len = n;
1307     if ( !raw && (DB_TXTMODE & db->flags) )
1308     for ( f = r->field, fe = r->field + r->fields; f < fe; f++ )
1309     for ( p = (char*)f->val, e = p+f->len; (p = memchr(p,VT,e-p)); )
1310     *p++ = LF;
1311     return r;
1312     } /* dText */
1313    
1314    
1315     static int pText ( LDb *db, Rec *r, const char *mark )
1316     {
1317     char buf[128 + 65536];
1318     unsigned pos = 0, len = 0, fld, off;
1319     char *p, *b;
1320     int ret;
1321    
1322     if ( !(db->flags & DB_WRITABLE) ) {
1323     log_msg( LOG_ERROR, "db is not writable" );
1324     return -1;
1325     }
1326     if ( ! r->rowid )
1327     r->rowid = db->mfc[LMFC_NMFN]++; /* assign new mfn */
1328     else if ( db->mfc[LMFC_NMFN] <= r->rowid )
1329     db->mfc[LMFC_NMFN] = r->rowid + 1;
1330     else {
1331     fld = 0;
1332     len = getPtr( &pos, &fld, db, r->rowid );
1333     }
1334     p = b = 32768 >= r->used ? buf : mAlloc(128+2*r->used);
1335     *p++ = 'W';
1336     *p++ = TAB;
1337     p += u2a( p, r->rowid );
1338     *p++ = TAB;
1339     if ( pos ) {
1340     p += u2a( p, pos );
1341     *p++ = '.';
1342     p += u2a( p, len );
1343     if ( fld ) {
1344     *p++ = '.';
1345     p += u2a( p, fld );
1346     }
1347     }
1348     *p++ = TAB;
1349     if ( mark ) {
1350     int l = strlen(mark);
1351     if ( l > 31 ) {
1352     log_msg( LOG_WARN, "mark '%.48s'%s has length %d",
1353     mark, l<48 ? "" : "...", l );
1354     l = 31;
1355     }
1356     memcpy( p, mark, l );
1357     p += l;
1358     } else {
1359     timeGtfm( p, 0 );
1360     p += 17;
1361     }
1362     *p++ = LF;
1363     off = p - b;
1364     p += len = rSerB( p, r );
1365     if ( len > 1 ) /* don't count 2 trailing LFs */
1366     len -= 2;
1367     db->flags |= DB_MODIFIED;
1368     pos = db->mflen;
1369     db->mflen += p - b;
1370     ret = lio_pwrite( &db->mst[MST_MST], b, p - b, pos );
1371     if ( ret == p - b ) {
1372     setPtr( db, r->rowid, pos+off, len, r->len );
1373     ret = 0;
1374     }
1375     if ( buf != b )
1376     mFree( b );
1377     return ret;
1378     } /* pText */
1379    
1380    
1381     /* ************************************************************
1382     utilities
1383     */
1384    
1385     static int search ( LDb *db, const char *key, LdbPost *post,
1386     Rec *rec, DXLoop *lp )
1387     {
1388     int i, j, prefix, idx, ret, ock;
1389     int pos;
1390     int *leaf, *entry;
1391     char *term;
1392     int *xstr;
1393     struct { /* terms cursor */
1394     char key[LDB_MAX_KEYLEN+1]; /* key or key prefix */
1395     short klen; /* key length to compare */
1396     char imin; /* minimum index to search */
1397     char imax; /* maximum index to search */
1398     int leaf[LDB_INDEXES][LDB_TERMBUF]; /* one leaf buffer per index */
1399     short lpos[LDB_INDEXES]; /* next position in leaf, -1 if done */
1400     } crs;
1401     short klen; /* length for initial locate */
1402     int block[128]; /* buffer to read one block */
1403     int blockpos = 0;
1404     LdbP *p = 0;
1405    
1406     if ( ! key )
1407     key = "$";
1408     /* prepare cursor struct */
1409     memset( &crs, 0, sizeof(crs) ); /* tabula rasa */
1410     crs.klen = strlen( key );
1411     /* check for prefix match */
1412     if ( post )
1413     prefix = LDB_PFX & post->mode;
1414     else if ( (prefix = crs.klen && '$' == key[crs.klen - 1]) )
1415     crs.klen--;
1416     /* check out minimum index to search */
1417     for ( crs.imin=0; crs.klen > db->tlen[(int)crs.imin]; )
1418     if ( LDB_INDEXES == ++(crs.imin) )
1419     return log_msg( ERR_INVAL, "bad keylen %d key '%.64s'", crs.klen, key );
1420     /* prepare key */
1421     memset( crs.key, ' ', sizeof(crs.key)-1 );
1422     {
1423     unsigned char *uc = (unsigned char*)crs.key;
1424     unsigned char *uk = (unsigned char*)key;
1425     for ( i=crs.klen; i--; )
1426     uc[i] = db->ctab[LCS_UCASE].c[ uk[i] ];
1427     }
1428     if ( prefix )
1429     crs.imax = LDB_INDEXES-1;
1430     else {
1431     crs.imax = crs.imin;
1432     crs.klen = db->tlen[(int)crs.imin];
1433     }
1434     log_msg( LOG_INFO, "search for '%.*s'%c", crs.klen, crs.key, prefix?'$':' ' );
1435     key = crs.key;
1436     klen = crs.klen;
1437     if ( rec && rec->len ) {
1438     /* use last key from record to locate starting position */
1439     key = rec->field[rec->len-1].val;
1440     klen = rec->field[rec->len-1].len;
1441     rec->len = 0;
1442     }
1443    
1444     for ( i=crs.imin; i<=crs.imax; i++ ) { /* find leaf positions */
1445     int nFile = INV_N01 + 2*i; /* node file index */
1446     int nStr = LSTR_N01 + 2*i; /* node struct index */
1447     int *nstr = DB_XSTR( db, LSET_INV, nStr );
1448     int lvl;
1449     short cmplen = klen <= db->tlen[i] ? klen : db->tlen[i];
1450     pos = db->cnt[i][LCNT_POSR]; /* pos of root record */
1451     j = 0;
1452     for ( lvl = 0; 0<pos; lvl++ ) { /* traverse node levels */
1453     int node[102];
1454     LOG_DBG( LOG_DEBUG, "node %d at %d lvl %d", pos, j, lvl );
1455     assert( (int)sizeof(node) >= nstr[LSTR_ILEN] );
1456     *node = *nstr;
1457     ret = readlog( node, db->inv[nFile], 1-pos, db, LSET_INV, nStr );
1458     if ( pos != node[LN0X_POS] /* wrong address */
1459     || i+1 != node[LN0X_TYPE] /* wrong type */
1460     || node[LN0X_OCK] < 1 /* no keys */
1461     || 2*db->cnt[i][LCNT_ORDN] < node[LN0X_OCK] /* too many keys */
1462     )
1463     return log_msg( ERR_TRASH, "bad node pos %d type %d keys %d",
1464     node[LN0X_POS], node[LN0X_TYPE], node[LN0X_OCK]
1465     );
1466     ock = node[LN0X_OCK];
1467     for ( j=1;
1468     j<ock && 0 < (ret = memcmp( key,
1469     ((char*)node)+node[j*LN0X__RL+LN0X__FL+LN0X_KEY], cmplen ));
1470     j++ )
1471     ;
1472     /* now j is at end or on next index not less */
1473     if ( j==ock /* end */
1474     || ret /* index is greater than key */
1475     || prefix /* backtrack even on exact match */
1476     )
1477     j--; /* step into last ock with lower key */
1478     pos = node[LN0X__FL + j*LN0X__RL + LN0X_REF];
1479     } /* for lvl */
1480     /* got some negative ref to leaf; set leaf pos */
1481     crs.leaf[i][LL0X_PS] = -pos;
1482     /*
1483     since the lpos and LL0X_OCK are both 0 by the memset above,
1484     we will initially load the leaves
1485     */
1486     } /* for indexes */
1487     /* done preparing cursor */
1488    
1489     if ( post ) /* prepare for postings */
1490     p = post->p;
1491     xstr = DB_XSTR( db, LSET_INV, LSTR_IFP );
1492    
1493     for (;;) { /* loop terms in prefix mode */
1494     /* vars for postings: */
1495     int infb, infp; /* block and pos where to read postings */
1496     int added; /* postings added or marked per term */
1497     int blkno; /* postings block number */
1498     int remain = 0; /* postings to fetch from next block of segment */
1499     int ifp[LIFP__FL]; /* postings header */
1500    
1501     idx = -1; /* index to use */
1502     /* compare index terms, load leafes if needed */
1503     for ( i = crs.imin; i <= crs.imax; i++ ) {
1504     short cmplen = klen <= db->tlen[i] ? klen : db->tlen[i];
1505     leaf = crs.leaf[i];
1506     if ( leaf[LL0X_OCK] <= crs.lpos[i] ) { /* load */
1507     int lFile = INV_L01 + 2*i; /* leaf file index */
1508     int lStr = LSTR_L01 + 2*i; /* leaf struct index */
1509     int *lstr = DB_XSTR( db, LSET_INV, lStr );
1510    
1511     crs.lpos[i] = -1;
1512     reread:
1513     if ( ! (pos = leaf[LL0X_PS]) )
1514     continue;
1515     LOG_DBG( LOG_DEBUG, "leaf %d", pos );
1516     assert( (int)sizeof(crs.leaf[i]) >= lstr[LSTR_ILEN] );
1517     *leaf = *lstr;
1518     ret = readlog( leaf, db->inv[lFile], 1-pos, db, LSET_INV, lStr );
1519     if ( pos != leaf[LL0X_POS] /* wrong address */
1520     || i+1 != leaf[LL0X_TYPE] /* wrong type */
1521     || leaf[LL0X_OCK] < 1 /* no keys */
1522     || 2*db->cnt[i][LCNT_ORDN] < leaf[LL0X_OCK] /* too many keys */
1523     )
1524     return log_msg( ERR_TRASH, "bad leaf pos %d type %d keys %d",
1525     leaf[LL0X_POS], leaf[LL0X_TYPE], leaf[LL0X_OCK] );
1526     ock = leaf[LL0X_OCK];
1527     /* advance to first term which is not too small
1528     (should be needed only for first leaf of an index)
1529     */
1530     for ( j=0;
1531     j<ock && (0 < (ret = memcmp( key,
1532     ((char*)leaf)+leaf[LL0X__FL + j*LL0X__RL + LL0X_KEY], cmplen ))
1533     || (!ret && key!=crs.key) ); /* skip exact while locating */
1534     j++ )
1535     ;
1536     if ( ock == j )
1537     goto reread; /* start over w/ next leaf of same index */
1538     if ( 0 <= ret
1539     || (key!=crs.key && !memcmp( crs.key,
1540     ((char*)leaf)+leaf[LL0X__FL + j*LL0X__RL + LL0X_KEY], crs.klen ))
1541     )
1542     crs.lpos[i] = j;
1543     /* else let -1 */
1544     } /* if reload */
1545     if ( 0 > crs.lpos[i] )
1546     continue;
1547     if ( 0 > idx ) {
1548     idx = i;
1549     continue;
1550     }
1551     /* compare this index next term to that of index idx */
1552     /* assume that index w/ lower number has shorter keys */
1553     ret = memcmp(
1554     ((char*)leaf)+leaf[LL0X__FL + crs.lpos[i]*LL0X__RL + LL0X_KEY],
1555     ((char*)crs.leaf[idx])+
1556     crs.leaf[idx][LL0X__FL + crs.lpos[idx]*LL0X__RL + LL0X_KEY],
1557     db->tlen[idx] );
1558     if ( 0 > ret )
1559     idx = i;
1560     }
1561     if ( 0 > idx )
1562     goto done;
1563     j = crs.lpos[idx];
1564     leaf = crs.leaf[idx];
1565     entry = leaf + LL0X__FL + j*LL0X__RL;
1566     term = ((char*)leaf) + entry[LL0X_KEY];
1567     if ( memcmp( crs.key, term, crs.klen ) )
1568     goto done;
1569     crs.lpos[idx]++;
1570    
1571     if ( rec ) { /* record the term */
1572     /* field to assign */
1573     Field *f = rec->field + rec->len;
1574     short tlen = db->tlen[idx];
1575     /* end of available buffer */
1576     char *b = rec->len
1577     ? (char*)f[-1].val /* before previously assigned field */
1578     : ((char*)rec + rec->bytes); /* end of record */
1579     while ( tlen && ' ' == term[tlen-1] )
1580     tlen--;
1581     b -= tlen;
1582     if ( b < (char*)(f+1) ) /* no space left on device */
1583     goto done;
1584     /* probably we're nuking the locator now: */
1585     memcpy( b, term, tlen );
1586     f->tag = 0;
1587     f->val = b;
1588     f->len = tlen;
1589     rec->len++;
1590     /* reset key from locator to prefix */
1591     key = crs.key;
1592     klen = crs.klen;
1593     }
1594    
1595     if ( ! post && ! lp )
1596     continue;
1597     /* collect postings */
1598     infb = entry[LL0X_INFB];
1599     infp = entry[LL0X_INFP];
1600     /* the IFP file is organized in blocks of 128 longs.
1601     1st int is block number followed by 127 data.
1602     postings are organized in chained segments so that each segment
1603     fits within one such block. a segment has five longs header,
1604     giving number of postings and pointer to next segment.
1605     */
1606     added = 0;
1607     for ( blkno=0; infb; blkno++ ) { /* segments */
1608     LdbP merge[127/2]; /* buffer to collect new postings */
1609     int *base; /* start of data */
1610     int *b; /* start of postings */
1611     int n; /* max postings in this seg's 1st block */
1612     int xlen; /* external length to read */
1613     int f = post ? post->fil - 1 : 0; /* highest pos to consider in given postings */
1614     int m = 0; /* fill merge buffer */
1615     int k; /* loop segment */
1616    
1617     if ( infp > 127-2-5 ) {
1618     return log_msg( ERR_TRASH, "found bad IFP pos %d blk %d for %.*s",
1619     infp, blkno, klen, key );
1620     }
1621     if ( remain ) { /* consecutive block of same segment */
1622     n = remain;
1623     if ( n > 127/2 )
1624     n = 127/2;
1625     xlen = 8*n;
1626     } else {
1627     n = (127 - 5 - infp)/2;
1628     xlen = 20 + 8*n;
1629     }
1630     pos = (infb - 1) * 512 + (infp + 1) * 4;
1631     if ( blockpos
1632     && !((pos-blockpos) >> 9) /* 0 <= (pos-blockpos) < 512 */
1633     && pos+xlen <= blockpos+ 1 + (0x1ff & ~blockpos)
1634     )
1635     base = block + (pos - blockpos)/sizeof(int);
1636     else {
1637     int blklen = 1 + (0x1ff & ~pos);
1638     assert( xlen <= blklen );
1639     assert( blklen <= (int)sizeof(block) );
1640     assert( 0 == (0x1ff & (pos + blklen)) );
1641     ret = readblk( block, blklen, db->inv[INV_IFP], pos );
1642     if ( ret )
1643     return log_msg( ERR_IO, "\twhen reading IFP" );
1644     blockpos = pos;
1645     base = block;
1646     }
1647     if ( remain ) { /* no header to convert */
1648     remain -= n;
1649     b = base; /* no header */
1650     } else {
1651     assert( (int)sizeof(ifp) >= xstr[LSTR_ILEN] );
1652     *ifp = *xstr;
1653     ret = convert( ifp, (char *)base, xstr );
1654     if ( ret )
1655     return log_msg( ERR_TRASH, "\twhen converting IFP header" );
1656     if ( n > ifp[LIFP_SEGP] )
1657     n = ifp[LIFP_SEGP];
1658     remain = ifp[LIFP_SEGP] - n;
1659     b = base+5; /* after header */
1660     }
1661     LOG_DBG( LOG_VERBOSE,
1662     "key %d.%d '%.*s' blk %d post %d/%d r %d xlen %d at b/p %d.%d=%d",
1663     leaf[LL0X_PS], j, db->tlen[idx], term, blkno,
1664     n, ifp[LIFP_TOTP], remain, xlen, infb, infp, pos );
1665     if ( LOG_DO( LOG_TRACE ) )
1666     LOG_STR( ifp, lstrlib[ LSET_INV ].name[ LSTR_IFP ] );
1667     assert( (size_t)n <= sizeof(merge)/sizeof(merge[0]) );
1668     if ( lp ) {
1669     Key kbf;
1670     Hit hit;
1671     unsigned char tlen = (unsigned char) db->tlen[idx];
1672     while ( tlen && ' ' == term[tlen-1] )
1673     tlen--;
1674     memcpy( kbf.byt, term, kbf.len = tlen );
1675     for ( k=0; k<n; k++ ) { /* callback needs 'em sorted */
1676     int ppos;
1677     unsigned char *c = (unsigned char *)&b[k*2];
1678     LdbP e; /* the entry */
1679     #ifdef LDB_BIG_ENDIAN
1680     memcpy(e.bytes,c,8);
1681     #else
1682     e.bytes[0] = c[7]; e.bytes[1] = c[6];
1683     e.bytes[2] = c[5]; e.bytes[3] = c[4];
1684     e.bytes[4] = c[3]; e.bytes[5] = c[2];
1685     e.bytes[6] = c[1]; e.bytes[7] = c[0];
1686     #endif
1687     ppos = LDBP_POS( &e );
1688     hit.mfn = (unsigned)LDBP_ROW( &e );
1689     hit.tag = (unsigned short)LDBP_TAG( &e );
1690     hit.occ = (unsigned short)(ppos >> 16);
1691     hit.pos = (unsigned short)ppos;
1692     if ( lp->cb( lp->me, &kbf, &hit ) )
1693     goto done;
1694     }
1695     }
1696     if ( post ) for ( k=n; k--; ) {
1697     /* loop backwards (for the fun of it) postings in segment */
1698     int prow, ptag, ppos;
1699     unsigned char *c = (unsigned char *)&b[k*2];
1700     LdbP e; /* the entry */
1701     LdbP samerow; /* highest possible entry w/ same row as e */
1702     #ifdef LDB_BIG_ENDIAN
1703     /* the 8 bytes of a posting are BIG ENDIAN ! */
1704     memcpy(e.bytes,c,8);
1705     #else
1706     e.bytes[0] = c[7]; e.bytes[1] = c[6];
1707     e.bytes[2] = c[5]; e.bytes[3] = c[4];
1708     e.bytes[4] = c[3]; e.bytes[5] = c[2];
1709     e.bytes[6] = c[1]; e.bytes[7] = c[0];
1710     #endif
1711     prow = LDBP_ROW( &e );
1712     ptag = LDBP_TAG( &e );
1713     ppos = LDBP_POS( &e );
1714     LOG_DBG( LOG_VERBOSE, "post %d.%hd pos %06x key '%.*s'",
1715     prow, ptag, ppos, db->tlen[idx], term );
1716     if ( 0 >= ptag /* bad tag */
1717     || !prow || prow >= db->mfc[LMFC_NMFN] /* bad mfn */
1718     )
1719     continue;
1720     if ( ! post
1721     || (post->cut && prow >= post->cut)
1722     || (post->tag && post->tag != ptag)
1723     )
1724     continue;
1725     if ( prow < post->skp ) /* quickly bail out on skip condition */
1726     break;
1727     LDBP_SETROWTOP( &samerow, &e ); /* for mfn comparison */
1728     /* sweep down to postings for the same row as e ... */
1729     while ( f >= 0 && LDBP_GT( p+f, &samerow ) )
1730     f--;
1731     if ( LDB_AND & post->mode ) {
1732     int l;
1733     /* loop postings for same row, mark all (that are near enough) */
1734     LDBP_SETROWBOT( &samerow, &e ); /* for mfn comparison */
1735     /* NOTE: postings for row are GT than bottom even if marked */
1736     for ( l = f; l>=0 && LDBP_GT( p+l, &samerow ); l-- ) {
1737     if ( post->near ) {
1738     int dist;
1739     if ( ptag != LDBP_TAG( p+l ) ) continue;
1740     if ( LDB_NEAR_G != post->near ) {
1741     dist = LDBP_POS( p+l ) - LDBP_POS( &e );
1742     if ( dist < 0 ) dist = -dist;
1743     if ( 0 < post->near
1744     ? post->near < dist
1745     : -post->near != dist /* exact $$$$ */
1746     ) continue;
1747     }
1748     }
1749     LDBP_SETMARK( p+l );
1750     added++;
1751     }
1752     } else { /* OR mode */
1753     int add;
1754     if ( ! post->near ) /* add if row not found: ignore details */
1755     add = 0 > f || prow > LDBP_ROW( p+f );
1756     else { /* add if no exact match */
1757     int l;
1758     /* NOTE: we don't use mark bit in OR mode, do we ? */
1759     for ( l = f; l>=0 && LDBP_GT( p+l, &e ); l-- )
1760     ;
1761     add = 0 > l || LDBP_GT( &e, p+l );
1762     }
1763     if ( add )
1764     merge[ m++ ] = e;
1765     }
1766     } /* for postings in segment */
1767     if ( m ) { /* merge in the merge buffer */
1768     LdbP *mm = merge;
1769     added += m;
1770     for ( k = post->fil += m; m && k--; ) {
1771     LdbP src;
1772     if ( k < m || LDBP_GT( mm, &p[k-m] ) ) {
1773     src = *mm++;
1774     m--;
1775     LOG_DBG( LOG_DEBUG, "merging %d at %d", LDBP_ROW(&src), k );
1776     } else
1777     src = p[k-m];
1778     if ( k < post->len )
1779     p[k] = src;
1780     else { /* set cut */
1781     int row = LDBP_ROW( &src );
1782     if ( row < post->cut || !post->cut )
1783     post->cut = row;
1784     }
1785     }
1786     if ( post->fil > post->len )
1787     post->fil = post->len;
1788     if ( post->cut ) /* postings for cut row are unreliable */
1789     while ( post->fil && post->cut <= LDBP_ROW(p+post->fil-1) )
1790     post->fil--;
1791     }
1792     if ( remain ) { /* advance to start of next block */
1793     infb++;
1794     infp = 0;
1795     } else {
1796     infb = ifp[LIFP_NXTB];
1797     infp = ifp[LIFP_NXTP];
1798     }
1799     } /* for segments */
1800     LOG_DBG( LOG_VERBOSE, "added %d postings for key '%.*s'",
1801     added, db->tlen[idx], term );
1802     } /* for terms in prefix/postings mode */
1803     done:
1804     if ( post /* fixup */
1805     && LDB_AND & post->mode && !(LDB_KEEPMARKS & post->mode)
1806     ) {
1807     int mark = LDB_NOT & post->mode ? 0 : 0x8000;
1808     j=0;
1809     for ( i=0; i<post->fil; i++ )
1810     if ( mark == LDBP_MARK(p+i) ) {
1811     LDBP_CLRMARK(p+i);
1812     p[j++] = p[i];
1813     }
1814     post->fil = j;
1815     }
1816     return ! rec ? 0 : rec->len;
1817     } /* search */
1818    
1819    
1820     static int ldb_last_path_sep (const char *path) {
1821     char *p2;
1822     int i2;
1823     #ifdef WIN32
1824     char *p3;
1825     int i3;
1826     #endif
1827     if (! path) {
1828     return -1;
1829     }
1830     p2 = strrchr (path, '/');
1831     i2 = p2 ? p2 - path : -1;
1832     #ifdef WIN32
1833     p3 = strrchr (path, '\\');
1834     i3 = p3 ? p3 - path : -1;
1835     if (i3 > i2) {
1836     i2 = i3;
1837     }
1838     #endif
1839     return i2;
1840     } /* ldb_last_path_sep */
1841    
1842    
1843     static int ldb_open (const char *dbname, Rec *dbpar, Rec *syspar, Fdt *fdt)
1844     {
1845     LDb ndb, *db;
1846     int i, plen, sz, dbid, lck = LIO_TLOCK; /* WLOCK only on special demand */
1847     int ret = 0, invret = -1, lbtret = 0, autoformat = 1, writable = -1;
1848     int uc = -1, gotopt = 0, txtfd = 0, copyidx = 0;
1849     char *autoenc = 0;
1850     char *p, *q;
1851     char buf[65536+1]; /* need 64K buf for copying DO NOT SHRINK !!! */
1852     char path[ PATH_MAX ];
1853    
1854     memset( &ndb, 0, sizeof(ndb) );
1855     /* these should be 0 by memsetting to 0 anyway ... */
1856     ndb.path = 0; ndb.mmap = 0;
1857     ndb.flags |= DB_MMAP; /* it mean's: we'll try */
1858    
1859     /* loglevel */
1860     if ( 0 <= (i = rInt2(dbpar, syspar, OPENISIS_SLOGV, -1)) )
1861     cLog( i, 0 );
1862    
1863     /* prepare name ... */
1864     if (! dbname) {
1865     if (! dbpar)
1866     return log_msg( ERR_FAULT, "ldb_open: dbname not given");
1867     dbname = rString (dbpar, OPENISIS_DNAME, 0, buf, sizeof(buf));
1868     if (! dbname)
1869     return log_msg( ERR_FAULT, "ldb_open: no dbname parameter");
1870     }
1871     plen = strlen (dbname);
1872     if (0 >= plen)
1873     return log_msg( ERR_FAULT, "ldb_open: empty dbname");
1874     if ( 4 < plen ) {
1875     if ( !memcmp( ".mst", dbname+plen-4, 4 ) ) {
1876     uc = 0;
1877     plen -= 4;
1878     } else if ( !memcmp( ".MST", dbname+plen-4, 4 ) ) {
1879     uc = OPEN_UC;
1880     plen -= 4;
1881     }
1882     }
1883     if ( sizeof(buf) <= (unsigned)plen
1884     || sizeof(path) <= (unsigned)(plen + 4 + 1)
1885     )
1886     return log_msg( ERR_FAULT, "ldb_open: dbname too long '%s'", dbname);
1887     if ('/' == dbname[plen - 1]
1888     #ifdef WIN32
1889     || '\\' == dbname[plen - 1]
1890     #endif
1891     )
1892     return log_msg( ERR_FAULT,
1893     "ldb_open: must not specify directory as dbname '%s'", dbname);
1894     if (DBNLEN > plen)
1895     strcpy(ndb.head.name, dbname);
1896     else {
1897     int i1 = 1 + plen - DBNLEN ;
1898     int i2 = ldb_last_path_sep (dbname);
1899     if (0 <= i2 && plen > ++i2 && i2 > i1) {
1900     i1 = i2;
1901     }
1902     strncpy(ndb.head.name, dbname + i1, DBNLEN - 1) [DBNLEN - 1] = 0;
1903     log_msg( LOG_WARN, "ldb_open: truncating dbname '%s' to '%s'",
1904     dbname, ndb.head.name);
1905     }
1906     /* ... and path */
1907     strcpy(path, dbname);
1908     if (! IsAbsPath (path)) {
1909     int plen2;
1910     if ( (dbpar || syspar)
1911     && (p = rString2 (dbpar, syspar, OPENISIS_DPATH, buf, sizeof(buf)))
1912     ) {
1913     plen2 = strlen (p);
1914     if (sizeof(path) <= (unsigned)(plen + plen2 + 4 + 1 + 1))
1915     return log_msg( ERR_FAULT,
1916     "ldb_open: dbname or dbpath too long: %d %d '%s'",
1917     plen, plen2, path);
1918     memmove (path + 1 + plen2, path, 1 + plen);
1919     path[plen2] = '/';
1920     memcpy (path, p, plen2);
1921     plen += 1 + plen2;
1922     }
1923     if ( !IsAbsPath(path)
1924     && syspar
1925     && (p = rString(syspar, OPENISIS_SPATH, 0, buf, sizeof(buf)))
1926     ) {
1927     plen2 = strlen(p);
1928     if (sizeof(path) <= (unsigned)(plen + plen2 + 4 + 1 + 1))
1929     return log_msg( ERR_FAULT,
1930     "ldb_open: dbname or syspath too long: %d %d '%s'",
1931     plen, plen2, path);
1932     memmove(path + 1 + plen2, path, 1 + plen);
1933     path[plen2] = '/';
1934     memcpy(path, p, plen2);
1935     plen += 1 + plen2;
1936     }
1937     } /* name and path */
1938    
1939     /* more init AFTER honoring verbosity */
1940     if ( ! init ) {
1941     lstr_auto(0);
1942     init = !0;
1943     }
1944    
1945     for ( dbid=0; dbid<dbs_len; dbid++ ) {
1946     if ( dbs[dbid].flags &&
1947     !strcmp( ndb.head.name, dbs[dbid].head.name ) ) {
1948     log_msg( LOG_INFO, "reopening %d '%s'", dbid, ndb.head.name );
1949     return dbid;
1950     }
1951     }
1952     /* go for slot */
1953     if ( dbid == dbs_len )
1954     for ( dbid=0; dbid<dbs_len && dbs[dbid].flags; dbid++ )
1955     ;
1956     if ( dbid == dbs_len )
1957     return -1;
1958     db = &dbs[dbid];
1959     /* got slot */
1960     *db = ndb;
1961     db->head.dbid = dbid;
1962    
1963     /* preset record sizes */
1964     db->mfc[0] = *DB_XSTR( db, LSET_MST, LSTR_MFC );
1965     db->xrf[0] = *DB_XSTR( db, LSET_MST, LSTR_XRF );
1966     db->cnt[0][0] =
1967     db->cnt[1][0] = *DB_XSTR( db, LSET_INV, LSTR_CNT );
1968     /* isis-1 index term lengths */
1969     db->tlen[0] = 10;
1970     db->tlen[1] = 30;
1971    
1972     /* only the packed little endian ("DOS") format is writable
1973     test later ...
1974     if ( LVAR_PAC != (DB_VARI & db->flags) )
1975     writable = 0;
1976     */
1977    
1978     db->path = mDup( path, plen+1 ); /* save path */
1979     memcpy( path+plen, ".???", 5 );
1980    
1981     if ( dbpar )
1982     dbpar = rDup(dbpar, 0, 0);
1983     /* check options file and extension case */
1984     if ( 0 <= uc ) /* use case from dbname */
1985     i = lio_open( setext(path,EXT_TXT_OPT,uc), OPEN_RDIF );
1986     else if ( 0 > (i = lio_open( setext(path,EXT_TXT_OPT,uc=0), OPEN_RDIF ))
1987     && 0 > (i = lio_open( setext(path,EXT_TXT_OPT,uc=OPEN_UC), OPEN_RDIF ))
1988     )
1989     uc = autocase( db->path );
1990     if ( 0 < i ) {
1991     if ( 0 < (sz = lio_size(i)) ) {
1992     p = sz < (int)sizeof(buf) ? buf : mAlloc(sz);
1993     if ( (gotopt = (sz == lio_read( &i, p, sz ))) )
1994     rDeser( &dbpar, p, sz, 0 );
1995     log_msg( LOG_INFO, "reading %d bytes options from '%s' %s",
1996     sz, path, gotopt ? "ok" : "nok" );
1997     if ( buf != p )
1998     mFree( p );
1999     }
2000     lio_close( &i, LIO_INOUT );
2001     }
2002     lck |= uc;
2003    
2004     if ( (dbpar || syspar) && 0 <= (i = rInt2(dbpar, syspar, OPENISIS_DRO, -1)))
2005     writable = !i; /* explicit 0/1 */
2006    
2007     /* open files */
2008     /* trad. index is never openend writable. */
2009     invret = openfiles( db->inv, path, EXT_INV, INV_FILES, uc|OPEN_RDIF );
2010     if (dbpar || syspar) {
2011     char fmtstr[32];
2012     if (rString2 (dbpar, syspar, OPENISIS_DTYPE, fmtstr, sizeof(fmtstr))) {
2013     if (! strcmp ("aligned", fmtstr)) {
2014     db->flags |= LVAR_ALI;
2015     autoformat = 0;
2016     } else if (! strcmp ("naligned", fmtstr))
2017     autoformat = 0;
2018     }
2019     }
2020     if ( autoformat ) {
2021     if ( invret )
2022     log_msg( LOG_WARN, "cannot guess format -- no inverted file" );
2023     else {
2024     unsigned len = lio_size( db->inv[INV_CNT] );
2025     if ( 56L == len ) {
2026     db->flags |= LVAR_ALI;
2027     autoenc = "iso8859-1";
2028     /* writable = 0; we do not write aligned format */
2029     } else if ( 52L == len )
2030     autoenc = "cp850";
2031     else
2032     log_msg( LOG_WARN, "cannot guess format -- bad .cnt len %d", len );
2033     log_msg( LOG_INFO, "using autoformat %saligned for .cnt len %d",
2034     (db->flags & LVAR_ALI) ? "":"un", len );
2035     }
2036     }
2037    
2038     /* data */
2039     #ifdef NOTXTDB
2040     if ( !(ret = openfiles( db->mst, path, EXT_MST, MST_FILES,
2041     lck|OPEN_ASIS|LIO_CREAT ))
2042     )
2043     writable = 0;
2044     else if (0 > ret)
2045     #else
2046     if ( 0 <= (ret = openfiles( &txtfd, path, EXT_TXT, 1,
2047     lck|LIO_SYNC|(writable?OPEN_ASIS:OPEN_RDIF) ))
2048     ) { /* .txt exists: use it */
2049     if ( ret )
2050     writable = 1;
2051     else if (1 == writable) {
2052     log_msg( LOG_ERROR, "file '%s' is readonly", path );
2053     goto cleanup;
2054     } else
2055     writable = 0;
2056     } else if (
2057     0 <= (ret = openfiles( db->mst, path, EXT_MST, MST_FILES,
2058     lck|((writable && !(db->flags & LVAR_ALI))?OPEN_ASIS:OPEN_RDIF) ))
2059     && (ret || 1!=writable)
2060     ) { /* trad. files are ok */
2061     if ( !ret )
2062     writable = 0;
2063     } else if ( 1 != (ret = openfiles( &txtfd, path, EXT_TXT, 1,
2064     lck|(ret ? LIO_SYNC : 0)|OPEN_NEW )) ) /* don't sync on autoconv */
2065     #endif
2066     goto cleanup;
2067    
2068     /* MW: creation mode? KR: ugo+rw & ~umask */
2069     if ( 1 == (lbtret = openfiles( &db->oxi.fd, path, EXT_LBT, 1,
2070     lck|(writable?OPEN_ASIS:OPEN_RDIF) ))
2071     )
2072     lbtret = 0;
2073     else if ( !writable )
2074     ;/* no problem */
2075     else if ( !lbtret ) { /* exists ro */
2076     log_msg( LOG_ERROR, "file '%s' is readonly", path );
2077     goto cleanup;
2078     } else { /* create and copy to oxi */
2079     if ( 1 != openfiles( &db->oxi.fd, path, EXT_LBT, 1, lck|OPEN_NEW ) )
2080     goto cleanup;
2081     lbtret = 0;
2082     copyidx = 1;
2083     }
2084    
2085     if ( db->mst[MST_MST] ) { /* care for the traditionals */
2086     if ( (ret = readlog(
2087     db->mfc, db->mst[MST_MST], 0, db, LSET_MST, LSTR_MFC ))
2088     ) {
2089     /* NEW goto cleanup; */
2090     memset( db->mfc, 0, sizeof(db->mfc) );
2091     db->mfc[LMFC_NMFN] = 1;
2092     db->mfc[LMFC_NMFB] = 1;
2093     db->mfc[LMFC_NMFP] = 64;
2094     db->mflen = 64;
2095     } else {
2096     /*
2097     int lastblock = (db->mflen = lio_size( db->mst[MST_MST] ))/512;
2098     if ( 511 & db->mflen ) lastblock++;
2099     counting from 1
2100     the next record's block should be either the last one we have
2101     or the next one to follow
2102     if ( db->mfc[LMFC_NMFB] != lastblock
2103     && db->mfc[LMFC_NMFB] != lastblock+1
2104     )
2105     log_msg( LOG_VERBOSE, "NMFB mismatch: NMFB %d ~ %d",
2106     db->mfc[LMFC_NMFB], lastblock );
2107     */
2108     /* set LOGICAL mf length */
2109     db->mflen = (db->mfc[LMFC_NMFB]-1)*512 + db->mfc[LMFC_NMFP];
2110     }
2111     db->ptrl = 512;
2112     db->xrlen = lio_size( db->mst[MST_XRF] ) / 512;
2113     if ( (DB_MMAP & db->flags)
2114     && db->xrlen
2115     && db->xrlen*512
2116     == lio_mmap( &db->mst[MST_XRF], (void**)&db->mmap, db->xrlen*512 )
2117     )
2118     db->mmlen = db->xrlen;
2119     }
2120    
2121     if ( txtfd ) {
2122     int remake = 0;
2123     /* TODO: make on-demand preparation even faster using buffered IO */
2124     if ( !lio_size(txtfd) ) {
2125     const char newline = LF;
2126     if ( gotopt
2127     && 0 < (i = lio_open( setext(path,EXT_TXT_OPT,uc), LIO_RD ))
2128     ) { /* copy the options file */
2129     log_msg( LOG_INFO, "copying %d bytes options", lio_size(i) );
2130     while ( 0 < (sz = lio_read( &i, buf, sizeof(buf)-1 )) )
2131     lio_write( &txtfd, buf, sz );
2132     if ( LIO_INOUT & i ) { /* is supposed to autoclose */
2133     log_msg( LOG_WARN, "tss tss tss ..." );
2134     lio_close( &i, LIO_INOUT );
2135     }
2136     }
2137     lio_write( &txtfd, &newline, 1 );
2138     }
2139    
2140     if ( db->mst[MST_MST] ) { /* copy to new empty txt */
2141     int end = db->mfc[LMFC_NMFN];
2142     /*
2143     max recsize for traditionals is 32K.
2144     field values may double, if consisting entirely of newlines.
2145     rec->used may be more than 32K, since we 12 bytes per field.
2146     However, we know there are only sign+5digits+tab+newline used per tag,
2147     fitting within 2* the original 6 bytes per field.
2148     */
2149    
2150     log_msg( LOG_INFO, "copying traditional data" );
2151     db->flags |= DB_OPEN; /* pretend */
2152     for ( i=1; i<end; i++ ) {
2153     Rec *r = dRead( dbid, i );
2154     if ( !r )
2155     sz = 1;
2156     else if ( (int)sizeof(buf) <= (sz = rSerB( buf, r )) ) {
2157     log_msg( ERR_IDIOT, "serialized %d bytes" );
2158     exit(42);
2159     }
2160     lio_write( &txtfd, buf, sz );
2161     }
2162     db->flags &= ~DB_OPEN; /* pret end */
2163     remake = 1;
2164     if ( db->mmap )
2165     lio_mmap( 0, (void**)&db->mmap, db->mmlen*512 );
2166     db->mmlen = 0;
2167     closefiles( db->mst, MST_FILES );
2168     } /* copying */
2169     db->mst[MST_MST] = txtfd;
2170     db->mflen = lio_size( db->mst[MST_MST] );
2171    
2172     db->ptr = 0x0134; /* should be config opt */
2173     if ( !remake ) { /* other reasons why we should remake */
2174     unsigned short ptr;
2175     unsigned isix = GETINT(ISIX);
2176     unsigned magic;
2177    
2178     remake = 1;
2179     if ( 0 > (db->mst[MST_XRF] = lio_open( setext(path,EXT_TXT_PTR,uc),
2180     LIO_SEEK|(writable?LIO_RDWR:LIO_RD) ))
2181     )
2182     log_msg( LOG_INFO, "'%s' not found", path );
2183     else if ( 6 != lio_read(&db->mst[MST_XRF],buf,6) )
2184     log_msg( LOG_WARN, "'%s' too short", path );
2185     else if ( isix != (magic = GETINT(buf)) ) /* FOO! */
2186     log_msg( LOG_WARN, "'%s' has black magic 0x%08x", path, magic );
2187     /* TODO: save that foo if it doesn't read ISIX ? */
2188     else if ( 0xf000 & (ptr = GETSHORT(buf+4)) ) /* bad endianess */
2189     log_msg( LOG_WARN, "'%s' has bad endianess type 0x%04x", path, ptr );
2190     else if ( (db->ptr && db->ptr != ptr) ) /* other type configured */
2191     log_msg( LOG_WARN, "'%s' type 0x%04x != cfg 0x%04x", path, ptr, db->ptr );
2192     else if ( lio_time(db->mst[MST_XRF]) < lio_time(db->mst[MST_MST]) )
2193     log_msg( LOG_WARN, "'%s' older than data", path );
2194     else {
2195     db->ptr = ptr;
2196     remake = 0;
2197     }
2198     }
2199     if ( ! db->ptr ) {
2200     db->ptr = 0x0134; /* m*256 + l*16 + k, doc/Serialized */
2201     /* BTW: 0x34 is ASCII digit '4', so it's ISIX4^A on little endian */
2202     db->ptrl = 8;
2203     } else { /* fix unsupported type */
2204     unsigned m = 0xf&(db->ptr>>8);
2205     unsigned l = 0xf&(db->ptr>>4);
2206     unsigned k = 0xf&db->ptr;
2207     int mod = 0;
2208     if ( m > 4 ) { m = 4; mod = 1; }
2209     if ( l > 4 ) { l = 4; mod = 1; }
2210     if ( k > 4 ) { k = 4; mod = 1; } /* TODO: allow 8 with large files */
2211     /* total ptr bytes = sum(nibbles) <= 45, but won't use more than 8+4+4 */
2212     if ( mod ) {
2213     log_msg( LOG_WARN, "fixing unsupported ptr type 0x%04x", db->ptr );
2214     db->ptr = (unsigned short)(m<<8 | l<<4 | k);
2215     remake = 1;
2216     }
2217     db->ptrl = k+l+m;
2218     }
2219     if ( remake ) {
2220     Ptr pt;
2221     unsigned base = 0; /* of current block */
2222     unsigned pos = 0; /* of last record */
2223     unsigned fld = 0; /* of last record */
2224     unsigned nmfn = 0; /* next mfn = maxmfn+1 */
2225     unsigned xmfn = 0; /* explicitly given */
2226     char op = 0;
2227     int more; /* buf not empty flag */
2228     char *last; /* of current block */
2229    
2230     lio_close( &db->mst[MST_XRF], LIO_INOUT );
2231     if ( 0 > (db->mst[MST_XRF] = lio_open(
2232     setext(path,EXT_TXT_PTR,uc), OPEN_BLANK ))
2233     )
2234     goto cleanup;
2235     /* write signature */
2236     memcpy( pt.r, "ISIX", 4 );
2237     memcpy( pt.r+4, &db->ptr, 2 );
2238     memcpy( pt.r+6, ":)", 2 );
2239     if ( 8 < db->ptrl )
2240     memset( pt.r+8, ')', db->ptrl - 8 );
2241     lio_pwrite( &db->mst[MST_XRF], pt.r, db->ptrl, 0 );
2242     /* loop the masterfile */
2243     lio_seek( &db->mst[MST_MST], 0 );
2244     last = (p = buf) + lio_read( &db->mst[MST_MST], buf, 8192 ) - 1;
2245     more = last > buf; /* one byte is no byte ;) */
2246     if ( more && LF == *p ) { /* no options: no \n\n */
2247     nmfn = pos = 1;
2248     p++;
2249     }
2250     for (;;) { /* records */
2251     unsigned len, mfn;
2252     for (;;) { /* lines and stuff to end of record */
2253     if ( p < last ) { /* have one lookahead */
2254     if ( LF != *p++ )
2255     continue; /* the tight loop ... or use memchr ? */
2256     if ( LF != *p ) { /* now p <= last */
2257     if ( fld || !(0xc0 & *p) ) { /* < '@', 'A', ... */
2258     if ( TAB != *p ) /* no continuation */
2259     fld++;
2260     continue;
2261     }
2262     fld++; /* count field, unless we really recognize a opline */
2263     if ( 'Z' < *p )
2264     continue;
2265     /* now we have '@'...'Z' at start of 1st line */
2266     sz = last - p; /* avail after p */
2267     if ( sz && TAB != p[1] ) /* no opline */
2268     continue;
2269     switch (*p) {
2270     case 'D':
2271     case 'I':
2272     case 'W':
2273     break; /* give it a try */
2274     default:
2275     log_msg( LOG_WARN, "unknown opline %c at mfn %d", *p, nmfn );
2276     continue;
2277     }
2278     if ( sz > 127 ) /* longer -> no opline */
2279     sz = 127;
2280     if ( ! sz || ! (q = memchr(p+1, LF, sz)) ) {
2281     if ( sz >= 127 || ! more )
2282     continue; /* too long or undelimited last */
2283     p--; /* back to \n, so we come here again */
2284     goto gimmemore;
2285     }
2286     if ( q < p+3 || p[2] < '0' || '9' < p[2] )
2287     continue;
2288     /* TODO:
2289     take a closer look at whether the whole line makes sense
2290     */
2291     if ( op ) { /* yeah, two metas in sequence! weird stuff! */
2292     p--; /* step back to newline */
2293     pos = base+(p-buf); /* fake pos as if we had no line at all */
2294     break; /* go handle the PREVIOUS opline */
2295     }
2296     op = *p;
2297     xmfn = a2i( p+2, q-p-2 );
2298     fld--; /* uncount this line */
2299     pos = base + (q-buf) + 1; /* start after q */
2300     continue;
2301     }
2302     break;
2303     }
2304     gimmemore:
2305     LOG_DBG( LOG_DEBUG, "MORE %d at pos %d base %d p +%d last +%d",
2306     more, pos, base, p-buf, last-buf );
2307     if ( !more )
2308     goto schicht; /* german: done */
2309     base += p - buf; /* shift out bytes before p */
2310     len = last-p; /* bytes to keep after p; < 128 */
2311     if ( len ) /* we're probing for more lookahead */
2312     memmove( buf, p, 1+last-p );
2313     else /* typically */
2314     *buf = *p; /* but save the last dance */
2315     p = buf;
2316     last = buf + len;
2317     /* reload */
2318     if ( 0 < (sz = lio_read( &db->mst[MST_MST], buf+1+len, 8192 )) ) {
2319     last += sz;
2320     continue;
2321     }
2322     more = 0; /* but yet, finish this up */
2323     /* since *buf = *last was the files last character,
2324     we'd expect a newline
2325     */
2326     if ( last == p )
2327     p = buf+(LF==*buf ? 1 : 2); /* pretend buf started \n */
2328     if ( ! len )
2329     break;
2330     /* else try again opline */
2331     } /* lines and stuff */
2332     /* now p is on a delimiting blank lines \n -- or such ... */
2333     len = base + (p-buf) - pos; /* >= 0 */
2334     mfn = xmfn ? xmfn : nmfn;
2335     log_msg( LOG_INFO, "ptr %c %d(%d/%d) pos %d len %d",
2336     op?op:'>', mfn, xmfn, nmfn, pos, len );
2337     if ( base + (p-buf) < pos ) /* FOO !!! */
2338     len = 0;
2339     if ( len ) /* could have been completely empty */
2340     len--; /* mute last \n */
2341     if ( 'D' == op && len ) /* FOO !!! */
2342     len = 0;
2343     if ( mfn && (len || op) )
2344     lio_pwrite( &db->mst[MST_XRF],
2345     mkptr( pt.r, db, pos, len, fld), db->ptrl, mfn*db->ptrl );
2346     pos = base + (p-buf) + 1; /* next starts after p */
2347     if ( 'D' != op ) { /* 'D'elete does not lead to implicit reuse */
2348     if ( op && nmfn < xmfn )
2349     nmfn = xmfn;
2350     nmfn++; /* continue after this */
2351     }
2352     xmfn = fld = op = 0;
2353     }
2354     schicht: ;
2355     } /* remake */
2356     db->mfc[LMFC_NMFN] =
2357     db->xrlen = lio_size( db->mst[MST_XRF] ) / db->ptrl;
2358     if ( (DB_MMAP & db->flags)
2359     && db->xrlen
2360     && db->xrlen*db->ptrl
2361     == lio_mmap( &db->mst[MST_XRF], (void**)&db->mmap, db->xrlen*db->ptrl )
2362     )
2363     db->mmlen = db->xrlen;
2364     log_msg( LOG_INFO, "mapped %d*%d = %d",
2365     db->xrlen, db->ptrl, db->xrlen*db->ptrl );
2366     db->flags |= DB_TXTOPEN;
2367     db->flags &= ~DB_VARI; /* clear alignment and such */
2368     } /* if ( txtfd ) */
2369    
2370     /* supporting files, ctables */
2371     p = buf;
2372     if ( 0 >= (sz = lio_slurp( &p, sizeof(buf), setext(path,EXT_SUP_ACT,uc), 1 ))
2373     || lcs_mktab( db->ctab+LCS_CTYPE, p, sz, LCS_A )
2374     )
2375     memcpy( db->ctab+LCS_CTYPE, lcs_latin1_ct, sizeof(db->ctab[0]) );
2376     if ( 0 >= (sz = lio_slurp( &p, sizeof(buf), setext(path,EXT_SUP_UCT,uc), 1 ))
2377     || lcs_mktab( db->ctab+LCS_UCASE, p, sz, 0 )
2378     )
2379     memcpy( db->ctab+LCS_UCASE, lcs_latin1_uc, sizeof(db->ctab[0]) );
2380     /* fill header */
2381    
2382     if (! fdt) {
2383     if ( (p = rString (dbpar, OPENISIS_DFDT, 0, buf, sizeof(buf))) ) {
2384     Rec *recfdt = 0;
2385     Db *dbfdt = nDbByName (openisis_stub0, p);
2386     if ( dbfdt)
2387     recfdt = dRead (dbfdt->dbid, 1);
2388     else {
2389     int idfdt = ldb_open (p, 0, syspar, 0);
2390     if (0 <= idfdt) {
2391     recfdt = dRead (idfdt, 1); /*MMM*/
2392     cDClose (idfdt);
2393     }
2394     }
2395     if (recfdt)
2396     fdt = fRec2Fdt (recfdt);
2397     } else if ( gotopt )
2398     fdt = fRec2Fdt(dbpar);
2399     if (! fdt)
2400     fdt = fFromFile (path);
2401     }
2402     db->head.fdt = fdt;
2403     if (fdt)
2404     log_msg( LOG_INFO, "have %d fdt entries for %s",
2405     fdt->len, db->head.name);
2406     else
2407     log_msg( LOG_INFO, "have no fdt for %s", db->head.name);
2408    
2409     db->head.tms = timeUpd(0); /* what watch? */
2410     log_msg( LOG_INFO, "tms %d for %s", db->head.tms, db->head.name);
2411    
2412    
2413     /* set path and name */
2414     if (0 <= (i = ldb_last_path_sep (db->path))) {
2415     if (i)
2416     strncpy(path, db->path, i)[i] = 0;
2417     else
2418     strcpy (path, "/");
2419     dbpar = rSet (dbpar, RCHG | RDIS, OPENISIS_DPATH, path, 0);
2420     }
2421     dbpar = rSet (dbpar, RCHG | RDIS, OPENISIS_DNAME, db->head.name, 0);
2422    
2423     /* set encoding */
2424     if (!(p = rString (dbpar, OPENISIS_DENC, 0, buf, sizeof(buf))))
2425     if ( (syspar
2426     && (p = rString (syspar, OPENISIS_DENC, 0, buf, sizeof(buf))))
2427     || (p = autoenc)
2428     )
2429     dbpar = rSet(dbpar, RDIS, OPENISIS_DENC, p, 0);
2430     if ( p )
2431     log_msg( LOG_INFO, "using encoding %s for %s", p, db->head.name);
2432    
2433     db->head.cfg = dbpar;
2434    
2435     /* done */
2436     db->flags |= DB_OPEN;
2437    
2438     if ( writable && LVAR_PAC == (DB_VARI & db->flags) )
2439     db->flags |= DB_WRITABLE;
2440    
2441     /*
2442     if ( (dbpar || syspar) && 0 < rInt2(dbpar, syspar, OPENISIS_DDUMP, -1) ) {
2443     int off = 0;
2444     int *r;
2445     do {
2446     if ( (r = ldb_readRecAtOff(dbid,off,&off)) )
2447     mFree( r );
2448     } while ( 0 < off );
2449     exit(0);
2450     }
2451     */
2452    
2453     /* init oxi */
2454     if ( writable )
2455     db->oxi.flg |= LBT_WRITE;
2456     if ( (p = getenv("OXITYP")) && 0 < (i = atoi(p)) && 4 > i )
2457     db->oxi.typ = i << 4;
2458     if ( !lbtret && !lbt_init( &db->oxi ) )
2459     db->flags |= DB_LBTOPEN;
2460    
2461     if ( ! invret
2462     && ! (ret = readlog( db->cnt[0], db->inv[INV_CNT],
2463     0, db, LSET_INV, LSTR_CNT ))
2464     && ! (ret = readlog( db->cnt[1], db->inv[INV_CNT],
2465     -1, db, LSET_INV, LSTR_CNT ))
2466     ) {
2467     if ( lbtret )
2468     db->flags |= DB_INVOPEN;
2469     else {
2470     if ( copyidx ) {
2471     DXLoop l;
2472     log_msg( LOG_INFO, "copying traditional index" );
2473     lbtret = 0;
2474     memset( &l, 0, sizeof(l) );
2475     l.me = & db->oxi;
2476     l.cb = (DXCb*)cXAdd;
2477     lbt_batch( & db->oxi, 5 );
2478     search( db, 0, 0, 0, &l );
2479     cXAdd( & db->oxi, 0, 0 );
2480     }
2481     closefiles( db->inv, INV_FILES );
2482     }
2483     }
2484    
2485     return dbid;
2486    
2487     cleanup:
2488     /* cleanup ... */
2489     db->flags = 0;
2490     closefiles( &db->oxi.fd, 1 );
2491     closefiles( &txtfd, 1 );
2492     closefiles( db->inv, INV_FILES );
2493     closefiles( db->mst, MST_FILES );
2494     return 0 > ret ? ret : ret ? -ret : -1;
2495     } /* ldb_open */
2496    
2497    
2498     /* ************************************************************
2499     package data
2500     */
2501    
2502    
2503    
2504     /* ************************************************************
2505     package functions
2506     */
2507    
2508     int *ldb_readRecAtOff ( int dbid, lxref off, int *nxtoff )
2509     {
2510     int *rec;
2511     LDb *db = getDb( dbid );
2512     if ( ! db ) {
2513     log_msg( LOG_ERROR, "\tat ldb_readRecAtOff" );
2514     return 0;
2515     }
2516     if ( 0 == off )
2517     off = 64;
2518     rec = getMfr( db, off, nxtoff );
2519     if ( ! rec )
2520     return 0;
2521     LOG_DBG( LOG_VERBOSE, "db %d off %d: got %hd bytes",
2522     dbid, off, !rec ? -1 : rec[LMFR_RECL] );
2523     return rec;
2524     } /* ldb_readRecAtOff */
2525    
2526    
2527    
2528     int ldb_search ( int dbid, const char *key, LdbPost *post, Rec *rec )
2529     {
2530     LDb *db = getDb( dbid );
2531     Key k;
2532    
2533     if ( ! db )
2534     return -ERR_BADF;
2535     if ( post ) { /* prepare for postings */
2536     if ( ! post->len )
2537     post->len = sizeof(post->p)/sizeof(post->p[0]); /* standard length */
2538     if ( LDB_NOT & post->mode )
2539     post->mode |= LDB_AND;
2540     }
2541     if ( DB_INVOPEN & db->flags )
2542     return search( db, key, post, rec, 0 );
2543     if ( !(DB_LBTOPEN & db->flags) )
2544     return -ERR_BADF;
2545     if ( db->oxi.bat )
2546     return -ERR_BUSY;
2547     memset( &k, 0, sizeof(k) );
2548     if ( ! key ) {
2549     k.byt[0] = '$';
2550     k.len = 1;
2551     } else {
2552     unsigned char *uk = (unsigned char*)key;
2553     int l = strlen( key );
2554     if ( l > 255 )
2555     l = 255;
2556     k.len = (unsigned char)l;
2557     while ( l-- )
2558     k.byt[l] = db->ctab[LCS_UCASE].c[ uk[l] ];
2559     }
2560     return lbt_search( &db->oxi, &k, post, rec );
2561     } /* ldb_search */
2562    
2563    
2564     int ldb_p2s ( Set *set, LdbPost *post )
2565     {
2566     int *s = set->id;
2567     int last=0, max = set->len;
2568     int i;
2569     set->len = 0;
2570     if ( ! max )
2571     max = OPENISIS_SETLEN;
2572     max--;
2573     if ( !post->fil )
2574     return 0L;
2575     s[0] = LDBP_ROW(post->p);
2576     for ( i=1; i<post->fil && last < max; i++ ) {
2577     int row = LDBP_ROW(post->p+i);
2578     if ( s[last] != row )
2579     s[++last] = row;
2580     }
2581     return set->len = last+1;
2582     } /* ldb_p2s */
2583    
2584    
2585     #if 0
2586     LcsTab *ldb_tabs( int dbid )
2587     {
2588     LDb *db = getDb( dbid );
2589     return ! db ? 0 : db->ctab;
2590     } /* ldb_tabs */
2591     #endif
2592    
2593    
2594     Db *ldb_getdb (int dbid) {
2595     LDb *db = getDb (dbid);
2596     return db ? &db->head : 0;
2597     }
2598    
2599     /* ************************************************************
2600     public functions
2601     */
2602     int dMaxId ( int dbid )
2603     {
2604     LDb *db = getDb( dbid );
2605     if ( ! db )
2606     return -ERR_BADF;
2607     return db->mfc[LMFC_NMFN] - 1;
2608     } /* dMaxId */
2609    
2610    
2611     Raw *dRaw ( int dbid, int rowid )
2612     {
2613     int off;
2614     int *rec = 0;
2615     LDb *db;
2616    
2617     if ( LIO_LOCK() ) return 0;
2618     db = getDb( dbid );
2619     if ( ! db ) {
2620     log_msg( LOG_ERROR, "\tat openIsisReadRaw %d", rowid );
2621     goto done;
2622     }
2623     off = getOff( db, rowid, 0 );
2624     log_msg( LOG_INFO, "found xref 0x%08x for %d", off, rowid );
2625     if ( 0 >= off ) {
2626     log_msg( LOG_INFO, "found deleted xref 0x%08x for %d", off, rowid );
2627     goto done;
2628     }
2629     rec = getMfr( db, off, 0 );
2630     if ( ! rec ) {
2631     log_msg( LOG_WARN, "\tno record at %d rowid %d", off, rowid );
2632     goto done;
2633     }
2634     LOG_DBG( LOG_VERBOSE, "db %d row %d: got %hd bytes",
2635     dbid, rowid, !rec ? -1 : rec[LMFR_RECL] );
2636     if ( rec[LMFR_MFN] != rowid ) {
2637     log_msg( LOG_ERROR, "got mfn %d expected %d", rec[LMFR_MFN], rowid );
2638     mFree( rec );
2639     rec = 0;
2640     goto done;
2641     }
2642     done:
2643     (void)LIO_RELE();
2644     return (Raw*)rec;
2645     } /* dRaw */
2646    
2647    
2648     Rec *dRead ( int dbid, int rowid )
2649     {
2650     LDb *db = getDb( dbid );
2651     Rec *r;
2652     if ( DB_TXTOPEN & db->flags )
2653     return dText( db, rowid, 0 );
2654     if ( (r = (Rec *) dRaw( dbid, rowid )) ) {
2655     char * base = (char*)r;
2656     Field *f = r->field;
2657     int i = r->len;
2658     for ( ; i--; f++ )
2659     f->val = base + (int)f->val;
2660     assert( RECOK( r ) );
2661     }
2662     return r;
2663     } /* dRead */
2664    
2665    
2666     int dWritex ( int dbid, Rec *rec, Rec *idx )
2667     {
2668     LDb *db = getDb( dbid );
2669     int ret = 0;
2670    
2671     if ( ! db )
2672     return -ERR_BADF;
2673     if ( !(DB_WRITABLE & db->flags) )
2674     return log_msg( ERR_INVAL, "db %d not writable", dbid );
2675     if ( rec && (ret =
2676     DB_TXTOPEN & db->flags ? pText( db, rec, 0 ) : putRec( db, rec )
2677     ) )
2678     return ret;
2679     if ( idx ) {
2680     const unsigned char *const uc = db->ctab[LCS_UCASE].c;
2681     int delmode = 0;
2682     int tag = -1;
2683     int mode = 'f'; /* 'w', 's' */
2684     int occ = 0;
2685     int pos = 0;
2686     int cut = 30;
2687     int mfn = rec ? rec->rowid : 0;
2688     Hit h;
2689     Key k;
2690     Field *f = idx->field, *last = f + idx->len - 1;
2691    
2692     for ( ; f <= last; f++ ) {
2693     const char *val = f->val;
2694     int len = f->len;
2695     int del = delmode;
2696    
2697     k.val.len = 0;
2698     switch ( f->tag ) {
2699     case XCTL: { /* index cmd [opt] */
2700     const char *cmd = val, *e = val + len;
2701     int cmdlen, opt = 0, haveopt;
2702     while ( val < e && 64 < *val ) /* eat ASCII letters */
2703     val++;
2704     cmdlen = val - cmd;
2705     if ( val < e && (TAB == *val || ' ' == *val) )
2706     val++;
2707     haveopt = val < e && a2il( val, e-val, &opt );
2708     if ( ! cmdlen ) {
2709     cut = haveopt ? opt : 30;
2710     continue;
2711     }
2712     switch (*cmd) {
2713     case 'f': /* fields */
2714     mode = 'f';
2715     occ = opt;
2716     pos = 0;
2717     continue;
2718     case 'w': /* words */
2719     mode = 'w';
2720     pos = opt;
2721     continue;
2722     case 's': /* split */
2723     mode = 's';
2724     pos = opt;
2725     continue;
2726     case 'a': /* add */
2727     delmode = 0;
2728     occ = pos = 0;
2729     continue;
2730     case 'd': /* del */
2731     delmode = 1;
2732     occ = pos = 0;
2733     continue;
2734     case 'm': /* mfn */
2735     mfn = opt;
2736     occ = pos = 0;
2737     continue;
2738     }
2739     return log_msg( ERR_INVAL, "bad index control '%.*s'", cmdlen, cmd );
2740     }
2741     case XHIT: {
2742     int i = 0, v[5], *pv = v;
2743     const char *e = val + len;
2744     if ( len )
2745     switch (*val) {
2746     case '+': del = 0; val++; break;
2747     case '-': del = 1; val++; break;
2748     }
2749     for ( ; val < e && i<5; i++ ) {
2750     int dig = a2il( val, e-val, v+i );
2751     val += dig;
2752     if ( val >= e || TAB == *val )
2753     break;
2754     if ( '.' != *val )
2755     return log_msg( ERR_INVAL,
2756     "bad HIT '%.*s' after %d", e-val, val, v[i] );
2757     val++;
2758     }
2759     h.dbn = 0;
2760     h.mfn = mfn;
2761     h.pos = pos;
2762     h.occ = occ;
2763     h.tag = tag;
2764     switch ( i ) {
2765     case 5: h.dbn = (unsigned short)*pv++;
2766     case 4: h.mfn = (unsigned)*pv++;
2767     case 3: h.pos = (unsigned short)pv[2];
2768     case 2: h.occ = (unsigned short)pv[1];
2769     case 1: h.tag = (unsigned short)pv[0];
2770     /* case 0: ! f->len */
2771     }
2772     if ( val < e && TAB == *val )
2773     val++;
2774     len = e - val;
2775     } break; /* case XHIT */
2776     case XFST:
2777     return log_msg( ERR_IDIOT, "sorry, XFST not implemented" );
2778     #if 0
2779     case XADD: /* binary key */
2780     /* if ( f->len < db->oxi.vsz )
2781     memset( k.val.byt, 0, db->oxi.vsz - f->len );
2782     */
2783     memcpy( k.val.byt
2784     + (f->len < (int)db->oxi.vsz ? (int)db->oxi.vsz - f->len : 0),
2785     f->val, f->len > (int)db->oxi.vsz ? (int)db->oxi.vsz : f->len );
2786     k.val.len = db->oxi.vsz;
2787     break;
2788     #endif
2789     default:
2790     if ( 0 > f->tag )
2791     return log_msg( ERR_INVAL, "bad index control tag %d", f->tag );
2792     switch ( mode ) { /* check for tag change */
2793     case 'f':
2794     if ( tag == f->tag )
2795     occ++;
2796     else
2797     occ = 0;
2798     break;
2799     case 'w':
2800     if ( tag == f->tag )
2801     pos++;
2802     else
2803     pos = 0;
2804     break;
2805     }
2806     tag = f->tag;
2807     h.dbn = 0;
2808     h.mfn = mfn;
2809     h.pos = pos;
2810     h.occ = occ;
2811     h.tag = f->tag;
2812     }
2813     if ( ! k.val.len ) { /* not ADD/DEL: use hit, val */
2814     unsigned char *dst = k.byt;
2815     const unsigned char *src = (const unsigned char *)val;
2816     if ( cut < len )
2817     len = cut;
2818     k.len = (unsigned char)len;
2819     while ( len-- )
2820     *dst++ = uc[ *src++ ];
2821     cXMkVal( &db->oxi, &k.val, &h );
2822     LOG_DBG( LOG_DEBUG, "#%d %c key '%.*s' hit %d.%d.%d.%d.%d",
2823     f - idx->field, del ? '-' : '+', k.len, k.byt,
2824     h.dbn, h.mfn, h.tag, h.occ, h.pos );
2825     }
2826     ret = del ? lbt_del( &db->oxi, &k ) : lbt_add( &db->oxi, &k );
2827     }
2828     }
2829     return ret;
2830     } /* dWritex */
2831    
2832    
2833     int dWrite ( int dbid, Rec *rec )
2834     {
2835     /* TODO: use FST lines as idx */
2836     return dWritex( dbid, rec, 0 );
2837     } /* dWrite */
2838    
2839    
2840     Rec* dTerm ( Rec *rec, int dbid, const char *key )
2841     {
2842     return 0 > ldb_search( dbid, key, 0, rec ) ? 0 : rec;
2843     } /* dTerm */
2844    
2845    
2846     int dXLoop ( int dbid, DXLoop *l )
2847     {
2848     LDb *db = getDb( dbid );
2849    
2850     if ( !db )
2851     return -ERR_BADF;
2852     if ( OPENISIS_IDXTRAD & l->flg ) {
2853     if ( !(db->flags & DB_INVOPEN) )
2854     return -ERR_BUSY;
2855     return search( db, 0, 0, 0, l );
2856     }
2857     if ( !(db->flags & DB_LBTOPEN) || db->oxi.bat )
2858     return -ERR_BUSY;
2859     return lbt_loop( & db->oxi, l );
2860     } /* dXLoop */
2861    
2862    
2863    
2864     int cInit ( int argc, const char **argv, CLockFunc lockfunc )
2865     {
2866     (void)argc; (void)argv;
2867     cOpen( 0 );
2868     if ( lockfunc )
2869     lio_lock = lockfunc;
2870     return 0;
2871     }
2872    
2873    
2874     Db* cDOpen (const char *dbname, Rec *dbpar, Rec *syspar, Fdt *fdt) {
2875     int dbid;
2876     if ( ! init )
2877     cOpen( 0 );
2878     dbid = ldb_open (dbname, dbpar, syspar, fdt);
2879     if (0 <= dbid) {
2880     return &dbs[dbid].head;
2881     }
2882     return 0;
2883     }
2884    
2885     int cDOpenv ( const char *dbname, const char **argv, int argc )
2886     {
2887     Rec *dbpar = 0;
2888     int rt;
2889     if ( ! init )
2890     cOpen( 0 );
2891     if (argc) {
2892     dbpar = rSet (0, RARGV | RFDT | RNOC | RIGN | argc,
2893     openIsisFdtDbpar, argv);
2894     }
2895     rt = ldb_open (dbname, dbpar, 0, 0);
2896     if (dbpar) {
2897     mFree (dbpar);
2898     }
2899     return rt;
2900     }
2901    
2902    
2903     int cDClose ( int dbid )
2904     {
2905     LDb *db = getDb( dbid );
2906     if ( ! db )
2907     return -ERR_BADF;
2908     if ( LIO_LOCK() ) return -ERR_BUSY;
2909     if ( DB_MODIFIED == ((DB_MODIFIED|DB_TXTOPEN) & db->flags) ) {
2910     /* write back the MF control */
2911     Mfc mfc;
2912     /* if ( 498 < (db->mflen & 511) ) db->mflen = ~511 & (db->mflen + 14); */
2913     mfc.ctlm = rvi( db->mfc[LMFC_CTLM] );
2914     mfc.nmfn = rvi( db->mfc[LMFC_NMFN] );
2915     mfc.nmfb = rvi( 1 + (db->mflen >> 9) );
2916     mfc.nmfp = rvs( 511 & db->mflen );
2917     mfc.type = rvs( db->mfc[LMFC_TYPE] );
2918     mfc.rcnt = rvi( db->mfc[LMFC_RCNT] );
2919     mfc.mfx1 = rvi( db->mfc[LMFC_MFX1] );
2920     mfc.mfx2 = rvi( db->mfc[LMFC_MFX2] );
2921     mfc.mfx3 = rvi( db->mfc[LMFC_MFX3] );
2922     if ( sizeof(mfc) != lio_pwrite( &db->mst[MST_MST], &mfc, sizeof(mfc), 0) )
2923     log_msg( ERR_TRASH, "could not write MST header" );
2924     }
2925     if ( db->mmap ) {
2926     if ( (DB_MODIFIED|DB_TXTOPEN) == ((DB_MODIFIED|DB_TXTOPEN) & db->flags) )
2927     memcpy( db->mmap, ISIX, 4 ); /* force newer mtime on proper close */
2928     lio_mmap( 0, (void**)&db->mmap, db->mmlen*db->ptrl );
2929     }
2930     db->mmlen = 0;
2931     closefiles( db->mst, MST_FILES );
2932     if ( DB_INVOPEN & db->flags )
2933     closefiles( db->inv, INV_FILES );
2934     if ( DB_LBTOPEN & db->flags )
2935     lbt_close( &db->oxi );
2936     db->flags = 0L;
2937     if ( db->path ) mFree( (char*)db->path );
2938     if (db->head.cfg) mFree (db->head.cfg);
2939     if (db->head.fdt) fFree (db->head.fdt);
2940     memset( db, 0, sizeof(db) );
2941     (void)LIO_RELE();
2942     return 0;
2943     } /* cDClose */
2944    
2945    
2946     int cDCheck ( int dbid, int flags )
2947     {
2948     static char dot = '.';
2949     int *r;
2950     LDb *db = getDb( dbid );
2951     int nxtoff = 64, off;
2952    
2953     if ( ! db )
2954     return -ERR_BADF;
2955     (void)flags;
2956     do {
2957     lio_write( &lio_out, &dot, 1 );
2958     if ( (r = ldb_readRecAtOff(dbid,off=nxtoff,&nxtoff)) ) {
2959     int o = getOff( db, r[LMFR_MFN], 0 );
2960     if ( o != off ) {
2961     log_msg( LOG_WARN, "mfn %d xrf %d != real %d\n",
2962     r[LMFR_MFN], o, off );
2963     }
2964     mFree( r );
2965     }
2966     } while ( 0 < nxtoff );
2967     return 0;
2968     } /* cDCheck */
2969    
2970    
2971     OpenIsisIdx *cXOpen ( int dbid, int mode )
2972     {
2973     LDb *db = getDb( dbid );
2974     if ( !db
2975     || !(db->flags & DB_LBTOPEN)
2976     || !(db->oxi.flg & LBT_WRITE) /* may be writable if db is not */
2977     || db->oxi.bat
2978     /*
2979     preliminary undocumented feature:
2980     mode -1 gives direct access in non-batch mode
2981     */
2982     || (0 <= mode && lbt_batch( & db->oxi, (unsigned char)mode ))
2983     )
2984     return 0;
2985     return & db->oxi;
2986     } /* cXOpen */

  ViewVC Help
Powered by ViewVC 1.1.26