trunk/openisis/lses.c

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

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 of the License, or (at your option) any later version.

        This library is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        Lesser General Public License for more details.

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

        see README for more information
EOH */

/*
        $Id: lses.c,v 1.18 2003/05/26 10:55:10 kripke Exp $
        implementation of general db access functions.
*/

#include <stdlib.h>
#include <string.h> /* memset */

#ifdef _REENTRANT
#ifdef WIN32
#       define WIN32_LEAN_AND_MEAN
#       define NONAMELESSUNION
#       include <windows.h>
/* they call it "thread local storage" */
#       define pthread_key_t int
# define pthread_key_create( pkey, func ) *(pkey) = TlsAlloc()
# define pthread_setspecific( key, val ) TlsSetValue( key, val )
# define pthread_getspecific( key ) TlsGetValue( key )
#else
#       include <pthread.h>
#endif
#endif

#include "lses.h"


/* ************************************************************
        private types
*/
typedef struct {
        Ses h;
        /* int          brk; */
} SesI;

enum {
        LSES_MAX = 0x1000,
        LSES_MSK = 0x0fff
};

/* ************************************************************
        package data
*/

/* ************************************************************
        private data
*/
static Ios stdio[3] = {
        LIO_STDINITIALIZER( "&0", LIO_IN ),
        LIO_STDINITIALIZER( "&1", LIO_OUT|1 ),
        LIO_STDINITIALIZER( "&2", LIO_OUT|2 )
};
static SesI cses = { /* the default session */
{
        0,
        "",
        { stdio, stdio+1, stdio+2 },
        -1,
        0, 0, /* nxt, accnt */
        {0},{0},{0}, /* times */
        0,0,0,0 /* state */
}
};

static SesI *tab[ LSES_MAX ] = {
        &cses
};
static Ses *htab[ LSES_MAX ];
static int maxid;
static const char oops[] = "out of memory\n";

#ifndef _REENTRANT
Session ses = &cses.h;
#else
int openisis_threaded = 42;
static pthread_key_t seskey;
#endif

/* ************************************************************
        private functions
*/

static void *memordie ( int size )
{
        void *p = malloc( size );
        if ( p )
                return p;
        /* TODO: ask btree to release some cache */
        lio_write( &lio_err, oops, sizeof(oops)-1 );
        exit( 71/*EX_OSERR*/ ); /* exit handlers MUST NOT alloc memory */
        return 0;
}


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

void lses_init () /* called from openIsisInit */
{
#ifdef _REENTRANT
        pthread_key_create( &seskey, 0 ); /* TODO: use ses destr func */
        pthread_setspecific( seskey, &cses.h );
#endif
}       /* lses_init */


void lses_fini () /* called from openIsisFini */
{
        int i, s = LSES_MAX;
        /* lio_write( &lio_out, "fini time\n", 9 ); */
        while ( s-- )
                if ( tab[s] )
                        for ( i=0; i<3; i++ )
                                if ( tab[s]->h.io[i] )
                                        LIO_CLOSE( tab[s]->h.io[i] );
}       /* lses_fini */


int lses_open ( Session s, const char *name, int flags, SFunc *type )
{
        int fd = 0;
        const char *p = name;
        lio_sfunc *func = type ? (lio_sfunc*)type : lio_stdio;

        /* check for i<> */
        while ( '0' <= *p && *p <= '9' )
                fd = 10*fd + *p++ - '0';
        if ( '<' != *p && '>' != *p )
                p = name; /* forget it */
        else {
                if ( name == p && '>' == *p ) /* no fd given, > defaults to 1 */
                        fd = 1;
                flags |= '<' == *p ? LIO_RD : LIO_WR;
                p++;
        }
        if ( p == name ) { /* no fd given, find one */
                for ( fd=0; s->io[fd]; )
                        if ( LSES_FILE_MAX == ++fd )
                                return -ERR_NOMEM;
        } else if ( s->io[fd] ) { /* close existing */
                func( s->io[fd], LIO_SCLOSE );
                /* don't kill the statics :) */
                if ( s->io[fd] < stdio || s->io[fd] > stdio+2 )
                        mFree( s->io[fd] );
        }
        s->io[fd] = (Ios*)mAlloc( func( 0, LIO_SSIZE ) );
        if ( ! s->io[fd] )
                return -ERR_NOMEM;
        s->io[fd]->func = func;
        s->io[fd]->name = mDup( p, -1 );
        s->io[fd]->file = flags;
        return func( s->io[fd], LIO_SOPEN );
}       /* lses_open */


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

extern Ses *sGet ()
{
#ifdef _REENTRANT
        Ses *ses;
        if ( ! (ses = (Ses*)pthread_getspecific( seskey )) )
                pthread_setspecific( seskey, ses = cSession( 0 ) );
#endif
        return ses;
}

extern void sSet ( Ses *s )
{
#ifndef _REENTRANT
        ses = s;
#else
        pthread_setspecific( seskey, s );
#endif
}


Ses *cOpen ( Rec *args )
{
        extern void linit();

        linit();
        if ( args ) { /* add args */
                /* TODO: merge args */
                cses.h.prop = rDup( args, -1, 0 );
        }
        return &cses.h;
}       /* cOpen */


Ses *cSession ( Rec *args )
{
        SesI *sesi = 0;
        Ses *s = 0;
        int id = 1;
        /** XXX unless we actually free sessions,
                we should start checking with maxid
                or check for expiry
        */
        while ( tab[id] )
                if ( LSES_MAX == ++id )
                        return 0;
        if ( maxid < id )
                maxid = id;
        sesi = tab[id] = (SesI*)malloc( sizeof(SesI) );
        memset( sesi, 0, sizeof(SesI) );
        s = &sesi->h;
        s->id = id;
        s->hash = -1; /* not hashed (hash is non-negative) */
        s->prop = args ? rDup( args, -1, 0 ) : 0;
        /* check props */
        /* open files */
        lses_open( s, "2>&2", 0, lio_stdio );
        return s;
}       /* cSession */


void *mAlloc ( int size )
{
        void *p = memordie( size );
        memset(p, 0, size);
        return p;
}       /* mAlloc */


void  mFree ( void *mem )
{
        if ( mem )
                free( mem );
}       /* mFree */


void *mDup ( const void *str, int sz )
{
        void *m = memordie( 0<=sz ? sz : (sz = strlen( str ) + 1) );
        memcpy( m, str, sz );
        return m;
}       /* mDup */


int sOpen ( const char *name, int flags, SFunc *type )
{
        SESDECL
        return lses_open( ses, name, flags, type );
}       /* sOpen */


Ses *openIsisId2Session (int sid) {
        if (0 > sid || LSES_MAX <= sid || 0 == tab[sid]) {
                return (Ses*)0;
        }
        return &(tab[sid]->h);
}       /* openIsisId2Session */


int openIsisSession2Id (Ses *s) {
        if (0 == s) {
                return -1;
        }
        return s->id;
}       /* openIsisSession2Id */


Ses *cSesByName ( char *name, int nlen, Tm *now, Tm *expire )
{
        char tbuf[20];
        int h,i;
        Ses *s;
        if ( nlen < 0 )
                nlen = strlen(name);
        if ( nlen > 63 )
                nlen = 63;
        for ( i=nlen; i--; )
                if ( !(0xe0 & name[i]) )
                        name[i] = '_';
        h = lhash( name, nlen );
        for ( s = htab[h & LSES_MSK]; s; s = s->nxt )
                if ( h == s->hash
                        && !memcmp( name, s->name, nlen )
                        && !s->name[nlen]
                ) {     /* match */
                        if ( !expire || s->atime.millis >= expire->millis )
                                goto gotit; /* valid */
                        if ( s->cur || s->que ) {
                                log_msg( LOG_WARN, "expired session %d %s still busy!",
                                        s->id, s->name );
                                goto gotit; /* valid anyway */
                        }
                        goto refresh;
                }
        /* didn't find by name */
        if ( ! expire ) /* bad thing -- we're going to run out of sessions ... */
                i = maxid+1;
        else /* check other expired */
                for ( i=1; i<=maxid; i++ ) {
                        s = &tab[i]->h; /* sind wir heute defensiv ... */
                        if ( s && s->atime.millis < expire->millis
                                && s->atime.millis && 0 <= s->hash /* else is none of our biz */
                                && !s->cur && !s->que /* else is busy !? */
                        )
                                break;
                }
        if ( i > maxid ) {
                s = cSession( 0 );
                if ( ! s )
                        return 0;
        } else /* got one */
                log_msg( LOG_INFO, "reusing session %d '%s' atime %s",
                        s->id, s->name, s->atime.millis ? timeGtf(tbuf,&s->atime) : "-" );
        if ( 0 <= s->hash ) { /* was hashed -- unlink */
                Ses **spp = &htab[s->hash & LSES_MSK];
                for ( ; *spp; spp = &(*spp)->nxt )
                        if ( s == *spp ) {
                                *spp = s->nxt;
                                break;
                        }
        }
        memset( s->name, 0, sizeof(s->name) );
        memcpy( s->name, name, nlen );
        s->hash = h;
        s->nxt = htab[h & LSES_MSK];
        htab[h & LSES_MSK] = s;
refresh:
        s->ctime.millis = s->mtime.millis = now ? now->millis : 0;
        s->accnt = 0;
        if ( s->prop )
                CLRREC( s->prop );
        if ( s->res )
                CLRREC( s->res );
gotit:
        s->atime.millis = now ? now->millis : 0;
        return s;
}       /* cSesByName */
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: lses.c,v 1.18 2003/05/26 10:55:10 kripke Exp $
25			implementation of general db access functions.
26			*/
27
28			#include <stdlib.h>
29			#include <string.h> /* memset */
30
31			#ifdef _REENTRANT
32			#ifdef WIN32
33			# define WIN32_LEAN_AND_MEAN
34			# define NONAMELESSUNION
35			# include <windows.h>
36			/* they call it "thread local storage" */
37			# define pthread_key_t int
38			# define pthread_key_create( pkey, func ) *(pkey) = TlsAlloc()
39			# define pthread_setspecific( key, val ) TlsSetValue( key, val )
40			# define pthread_getspecific( key ) TlsGetValue( key )
41			#else
42			# include <pthread.h>
43			#endif
44			#endif
45
46			#include "lses.h"
47
48
49			/* ************************************************************
50			private types
51			*/
52			typedef struct {
53			Ses h;
54			/* int brk; */
55			} SesI;
56
57			enum {
58			LSES_MAX = 0x1000,
59			LSES_MSK = 0x0fff
60			};
61
62			/* ************************************************************
63			package data
64			*/
65
66			/* ************************************************************
67			private data
68			*/
69			static Ios stdio[3] = {
70			LIO_STDINITIALIZER( "&0", LIO_IN ),
71			LIO_STDINITIALIZER( "&1", LIO_OUT\|1 ),
72			LIO_STDINITIALIZER( "&2", LIO_OUT\|2 )
73			};
74			static SesI cses = { /* the default session */
75			{
76			0,
77			"",
78			{ stdio, stdio+1, stdio+2 },
79			-1,
80			0, 0, /* nxt, accnt */
81			{0},{0},{0}, /* times */
82			0,0,0,0 /* state */
83			}
84			};
85
86			static SesI *tab[ LSES_MAX ] = {
87			&cses
88			};
89			static Ses *htab[ LSES_MAX ];
90			static int maxid;
91			static const char oops[] = "out of memory\n";
92
93			#ifndef _REENTRANT
94			Session ses = &cses.h;
95			#else
96			int openisis_threaded = 42;
97			static pthread_key_t seskey;
98			#endif
99
100			/* ************************************************************
101			private functions
102			*/
103
104			static void *memordie ( int size )
105			{
106			void *p = malloc( size );
107			if ( p )
108			return p;
109			/* TODO: ask btree to release some cache */
110			lio_write( &lio_err, oops, sizeof(oops)-1 );
111			exit( 71/EX_OSERR/ ); /* exit handlers MUST NOT alloc memory */
112			return 0;
113			}
114
115
116			/* ************************************************************
117			package functions
118			*/
119
120			void lses_init () /* called from openIsisInit */
121			{
122			#ifdef _REENTRANT
123			pthread_key_create( &seskey, 0 ); /* TODO: use ses destr func */
124			pthread_setspecific( seskey, &cses.h );
125			#endif
126			} /* lses_init */
127
128
129			void lses_fini () /* called from openIsisFini */
130			{
131			int i, s = LSES_MAX;
132			/* lio_write( &lio_out, "fini time\n", 9 ); */
133			while ( s-- )
134			if ( tab[s] )
135			for ( i=0; i<3; i++ )
136			if ( tab[s]->h.io[i] )
137			LIO_CLOSE( tab[s]->h.io[i] );
138			} /* lses_fini */
139
140
141			int lses_open ( Session s, const char name, int flags, SFunc type )
142			{
143			int fd = 0;
144			const char *p = name;
145			lio_sfunc func = type ? (lio_sfunc)type : lio_stdio;
146
147			/* check for i<> */
148			while ( '0' <= p && p <= '9' )
149			fd = 10fd + p++ - '0';
150			if ( '<' != p && '>' != p )
151			p = name; /* forget it */
152			else {
153			if ( name == p && '>' == p ) / no fd given, > defaults to 1 */
154			fd = 1;
155			flags \|= '<' == *p ? LIO_RD : LIO_WR;
156			p++;
157			}
158			if ( p == name ) { /* no fd given, find one */
159			for ( fd=0; s->io[fd]; )
160			if ( LSES_FILE_MAX == ++fd )
161			return -ERR_NOMEM;
162			} else if ( s->io[fd] ) { /* close existing */
163			func( s->io[fd], LIO_SCLOSE );
164			/* don't kill the statics :) */
165			if ( s->io[fd] < stdio \|\| s->io[fd] > stdio+2 )
166			mFree( s->io[fd] );
167			}
168			s->io[fd] = (Ios*)mAlloc( func( 0, LIO_SSIZE ) );
169			if ( ! s->io[fd] )
170			return -ERR_NOMEM;
171			s->io[fd]->func = func;
172			s->io[fd]->name = mDup( p, -1 );
173			s->io[fd]->file = flags;
174			return func( s->io[fd], LIO_SOPEN );
175			} /* lses_open */
176
177
178
179			/* ************************************************************
180			public functions
181			*/
182
183			extern Ses *sGet ()
184			{
185			#ifdef _REENTRANT
186			Ses *ses;
187			if ( ! (ses = (Ses*)pthread_getspecific( seskey )) )
188			pthread_setspecific( seskey, ses = cSession( 0 ) );
189			#endif
190			return ses;
191			}
192
193			extern void sSet ( Ses *s )
194			{
195			#ifndef _REENTRANT
196			ses = s;
197			#else
198			pthread_setspecific( seskey, s );
199			#endif
200			}
201
202
203			Ses cOpen ( Rec args )
204			{
205			extern void linit();
206
207			linit();
208			if ( args ) { /* add args */
209			/* TODO: merge args */
210			cses.h.prop = rDup( args, -1, 0 );
211			}
212			return &cses.h;
213			} /* cOpen */
214
215
216			Ses cSession ( Rec args )
217			{
218			SesI *sesi = 0;
219			Ses *s = 0;
220			int id = 1;
221			/** XXX unless we actually free sessions,
222			we should start checking with maxid
223			or check for expiry
224			*/
225			while ( tab[id] )
226			if ( LSES_MAX == ++id )
227			return 0;
228			if ( maxid < id )
229			maxid = id;
230			sesi = tab[id] = (SesI*)malloc( sizeof(SesI) );
231			memset( sesi, 0, sizeof(SesI) );
232			s = &sesi->h;
233			s->id = id;
234			s->hash = -1; /* not hashed (hash is non-negative) */
235			s->prop = args ? rDup( args, -1, 0 ) : 0;
236			/* check props */
237			/* open files */
238			lses_open( s, "2>&2", 0, lio_stdio );
239			return s;
240			} /* cSession */
241
242
243			void *mAlloc ( int size )
244			{
245			void *p = memordie( size );
246			memset(p, 0, size);
247			return p;
248			} /* mAlloc */
249
250
251			void mFree ( void *mem )
252			{
253			if ( mem )
254			free( mem );
255			} /* mFree */
256
257
258			void mDup ( const void str, int sz )
259			{
260			void *m = memordie( 0<=sz ? sz : (sz = strlen( str ) + 1) );
261			memcpy( m, str, sz );
262			return m;
263			} /* mDup */
264
265
266			int sOpen ( const char name, int flags, SFunc type )
267			{
268			SESDECL
269			return lses_open( ses, name, flags, type );
270			} /* sOpen */
271
272
273			Ses *openIsisId2Session (int sid) {
274			if (0 > sid \|\| LSES_MAX <= sid \|\| 0 == tab[sid]) {
275			return (Ses*)0;
276			}
277			return &(tab[sid]->h);
278			} /* openIsisId2Session */
279
280
281			int openIsisSession2Id (Ses *s) {
282			if (0 == s) {
283			return -1;
284			}
285			return s->id;
286			} /* openIsisSession2Id */
287
288
289			Ses cSesByName ( char name, int nlen, Tm now, Tm expire )
290			{
291			char tbuf[20];
292			int h,i;
293			Ses *s;
294			if ( nlen < 0 )
295			nlen = strlen(name);
296			if ( nlen > 63 )
297			nlen = 63;
298			for ( i=nlen; i--; )
299			if ( !(0xe0 & name[i]) )
300			name[i] = '_';
301			h = lhash( name, nlen );
302			for ( s = htab[h & LSES_MSK]; s; s = s->nxt )
303			if ( h == s->hash
304			&& !memcmp( name, s->name, nlen )
305			&& !s->name[nlen]
306			) { /* match */
307			if ( !expire \|\| s->atime.millis >= expire->millis )
308			goto gotit; /* valid */
309			if ( s->cur \|\| s->que ) {
310			log_msg( LOG_WARN, "expired session %d %s still busy!",
311			s->id, s->name );
312			goto gotit; /* valid anyway */
313			}
314			goto refresh;
315			}
316			/* didn't find by name */
317			if ( ! expire ) /* bad thing -- we're going to run out of sessions ... */
318			i = maxid+1;
319			else /* check other expired */
320			for ( i=1; i<=maxid; i++ ) {
321			s = &tab[i]->h; /* sind wir heute defensiv ... */
322			if ( s && s->atime.millis < expire->millis
323			&& s->atime.millis && 0 <= s->hash /* else is none of our biz */
324			&& !s->cur && !s->que /* else is busy !? */
325			)
326			break;
327			}
328			if ( i > maxid ) {
329			s = cSession( 0 );
330			if ( ! s )
331			return 0;
332			} else /* got one */
333			log_msg( LOG_INFO, "reusing session %d '%s' atime %s",
334			s->id, s->name, s->atime.millis ? timeGtf(tbuf,&s->atime) : "-" );
335			if ( 0 <= s->hash ) { /* was hashed -- unlink */
336			Ses **spp = &htab[s->hash & LSES_MSK];
337			for ( ; spp; spp = &(spp)->nxt )
338			if ( s == *spp ) {
339			*spp = s->nxt;
340			break;
341			}
342			}
343			memset( s->name, 0, sizeof(s->name) );
344			memcpy( s->name, name, nlen );
345			s->hash = h;
346			s->nxt = htab[h & LSES_MSK];
347			htab[h & LSES_MSK] = s;
348			refresh:
349			s->ctime.millis = s->mtime.millis = now ? now->millis : 0;
350			s->accnt = 0;
351			if ( s->prop )
352			CLRREC( s->prop );
353			if ( s->res )
354			CLRREC( s->res );
355			gotit:
356			s->atime.millis = now ? now->millis : 0;
357			return s;
358			} /* cSesByName */