trunk2/openisis/lio.h

/*
        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 */
#ifndef LIO_H

/*
        $Id: lio.h,v 1.22 2003/05/29 18:02:54 kripke Exp $
        I/O support for the openisis library.
        Provides non-blocking, look-ahead network streams and other nice stuff.
*/

#include "luti.h"
#include "lll.h"


/* ************************************************************
        time
*/

/* struct wrapper just for struct Tm *Time */ 
typedef struct Tm {
        lll   millis;
}       Tm;

/**
        set Tm to current time, return difference in millis
*/
extern int timeUpd ( Tm * );
/**
        print generalized time yyyyMMddHHmmss + 0 byte to buffer
        if Tm is 0, current time is used
        if Tm.millis is 0, Tm is updated
        return buffer, which must have 15 bytes
*/
extern char *timeGtf ( char *buf, Tm * );
/**
        like timeAsc, but with additional 3 digits millis
        return buffer, which must have 18 bytes
*/
extern char *timeGtfm ( char *buf, Tm * );
/**
        nanosl
*/
extern void timeSleep ( Tm * );


/* ************************************************************
        system files
*/

/**
        system file is a non-negative 32bit int including status bits.
        main status bits are LIO_IN and LIO_OUT,
        which are set by open and cleared by close.

        negative values are reserved for use by non-system based streams.
*/
#define LIO_WANT  0xfff00000 /* what we want: open flags */
#define LIO_FD    0x0000ffff /* what we get: system fd */
#define LIO_STAT  0x000f0000 /* how it's going: it's status */

/* status flags */
#define LIO_IN    0x00010000 /* support input */
#define LIO_OUT   0x00020000 /* support output */
#define LIO_INOUT 0x00030000 /* support both */
#define LIO_ISOPEN( file ) (LIO_INOUT & (file))

/* common requirements that are also used by non-system streams. */
#define LIO_RD    0x00100000 /* shall be opened for input */
#define LIO_WR    0x00200000 /* shall be opened for output */
#define LIO_RDWR  0x00300000 /* shall be opened for both */
#define LIO_SYNC  0x00400000 /* with WR: syncing output */
#define LIO_NBLK  0x00800000 /* non blocking IO (not used) */

/* system files only. */
#define LIO_CREAT 0x01000000 /* with WR: shall be created */
#define LIO_TRY   0x01000000 /* w/o  WR: do not complain if open fails */
#define LIO_TRUNC 0x02000000 /* with WR: shall be truncated */
#define LIO_SEEK  0x04000000 /* random access (with WR: else append mode) */
#define LIO_SOCK  0x08000000 /* is a socket (support shutdown) */

/* locking */
#define LIO_TLOCK 0x10000000 /* try locking (EX with WR) */
#define LIO_WLOCK 0x20000000 /* lock waiting (EX with WR) */
#define LIO_FLOCK 0x30000000 /* any locking is set */


/** create a new fid based on name and flags.
        name may be &i to use fd i, esp. for i=0,1 or 2.
        @return non-negative file or some error code
*/
extern int lio_open ( const char *name, int flags );
extern int lio_close ( int *file, int flags );
extern int lio_size ( int file );
extern unsigned lio_time ( int file ); /* mtime sec */

extern int lio_in;
extern int lio_out;
extern int lio_err;


/*
        Like the syscalls, this returns the number of bytes on success.
        Unlike the syscalls, it returns 0 rather than an error
        when no bytes are available after interrupt (EINTR)
        or on non-blocking IO (EAGAIN); i.e. you may try later.
        On error, a negative value is returned.
        On errors that render the file unusable,
        it is closed for input or output, resp.
        These are most errors but EFAULT (bad buf)
        and ESPIPE (which clears the SEEK bit).
        For files that do not have the SEEK bit set,
        EOF is considered such an error and -LERR_EOF is returned.
        If you want to stream a disk file like 'tail -f', set the SEEK bit.
*/
extern int lio_read ( int *file, void *buf, unsigned count );
extern int lio_write ( int *file, const void *buf, unsigned count );
extern int lio_pread ( int *file, void *buf, unsigned count, int offset );
extern int lio_pwrite ( int *file, const void *buf, unsigned count, int offset );
extern int lio_seek ( int *file, int offset );
extern int lio_trunc ( int *file, int offset );
/**
        open, sync or close a memory mapping

        @param file pointer to open file handle to map.
                if file is NULL, *map is unmapped (and set to NULL)
                else if *map is NULL, length bytes are mapped
                else *map is synced (flushed)
        @param length number of bytes to map; if 0, size will be used
        @return mapped length; if <= 0, *map is set to 0, else to memory region
*/
extern int lio_mmap ( int *file, void **map, int length );


/** slurp in a whole file at once.
        @param buf points to buffer of size sz.
                lio_slurp will allocate one, if *buf is NULL
        @param sz maximum number of bytes to read
        @param name of file to slurp
        @param opt if != 0, do not complain on failure
        @return number of bytes read or negative on error
*/
extern int lio_slurp ( char **buf, int sz, const char *name, int opt );


/* ************************************************************
        streams
*/

/** an I/O buffered stream similar to stdio's FILE.
        Unlike FILE with it's stupid ungetc,
        it supports efficient scanning of the whole input buffer without
        actually consuming it.
        Also unlike at least Linux' glibc's stdio, access is not interlocked.
        The buffer is typically used for input OR output.
        However, for internal pipes, the same buffer is used from both ends.

        High level access functions like printf operate directly on the buffer
        and call the stream function on buffer underflow or overflow
        (or explicit flush).
*/
typedef int lio_sfunc ( struct Ios *s, int op );

enum {
        LIO_BUFSIZ = 8192
};

typedef struct Buf {
        /* struct Buf     *nxt; chain -- not used */
        short           fill; /* total #bytes in the buffer */
        short           done; /* #bytes done */
        unsigned char   c[LIO_BUFSIZ]; /* actual buffer may be longer */
} Buf;
/* fill - done is the number of available bytes */
#define LIO_BAVAIL( b )  ((b)->fill - (b)->done)
#define LIO_BINIT( b ) do { \
        /*(b)->nxt = 0;*/ (b)->fill = 0; (b)->done = 0; \
        } while (0)
#define LIO_BINITIALIZER { 0,0,"" }

typedef struct Ios {
        lio_sfunc  *func;
        const char *name; /* stream's name */
        int         file; /* file "id" and flags as above */
        int         pos;  /* logical position of buffer start within stream */
        Buf         b;
}       Ios;

#define LIO_SISOPEN( s ) LIO_ISOPEN( (s)->file )
#define LIO_SAVAIL( s )  LIO_BAVAIL( &(s)->b )
#define LIO_SINIT( s, fun, nam, fil ) do { \
        (s)->func = fun; (s)->name = nam; (s)->file = fil; \
        (s)->pos = 0; \
        LIO_BINIT( &(s)->b ); \
        } while (0)
#define LIO_STDINIT( s, nam, fil ) LIO_SINIT( s, lio_stdio, nam, fil )
#define LIO_SINITIALIZER( fun, nam, fil ) { fun, nam, fil, 0, LIO_BINITIALIZER }
#define LIO_STDINITIALIZER( nam, fil ) LIO_SINITIALIZER( lio_stdio, nam, fil )
        

/** stream operations.
*/
enum {
        LIO_SSIZE,  /* tell the size of the stream structure */
        LIO_SOPEN,  /* initialize the structure */
        LIO_SCLOSE, /* close */
        LIO_SPURGE, /* kill the done bytes. return fill buffer size */
        LIO_SFILL,  /* try to refill the buffer (poll input). return # new bytes */
        LIO_SFLUSH, /* try to flush the buffer. return # bytes written */
        LIO_SPUSH   /* push input stream: munge prefilled input */
};

/**
        "abstract" base implementation of stream.
        not very useful in itself, but used by derived impl.
*/
extern int ioStream ( Ios *s, int op );

/**
        stream func based on system file to mimic stdio.
        on LIO_SOPEN, the fid is set by lio_open based on name.
        other ops used the correponding lio system call.
*/
extern int ioStdio ( Ios *s, int op );

#define LIO_OPEN( s )  (s)->func( (s), LIO_SOPEN )
#define LIO_CLOSE( s ) (s)->func( (s), LIO_SCLOSE )
#define LIO_FILL( s )  (s)->func( (s), LIO_SFILL )
#define LIO_FLUSH( s ) (s)->func( (s), LIO_SFLUSH )


/* ************************************************************
        inter process communication
*/

extern CLockFunc *lio_lock;
#define LIO_LOCK() (NULL != lio_lock && lio_lock(OPENISIS_LOCK))
#define LIO_RELE() (NULL != lio_lock && lio_lock(OPENISIS_RELE))
#define LIO_WAIT( c ) (NULL != lio_lock && lio_lock(OPENISIS_WAIT \
        | (OPENISIS_COND & (c))))
#define LIO_WAKE( c ) (NULL != lio_lock && lio_lock(OPENISIS_WAKE \
        | (OPENISIS_COND & (c))))

#define LIO_H
#endif /* LIO_H */
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			#ifndef LIO_H
23
24			/*
25			$Id: lio.h,v 1.22 2003/05/29 18:02:54 kripke Exp $
26			I/O support for the openisis library.
27			Provides non-blocking, look-ahead network streams and other nice stuff.
28			*/
29
30			#include "luti.h"
31			#include "lll.h"
32
33
34			/* ************************************************************
35			time
36			*/
37
38			/* struct wrapper just for struct Tm Time /
39			typedef struct Tm {
40			lll millis;
41			} Tm;
42
43			/**
44			set Tm to current time, return difference in millis
45			*/
46			extern int timeUpd ( Tm * );
47			/**
48			print generalized time yyyyMMddHHmmss + 0 byte to buffer
49			if Tm is 0, current time is used
50			if Tm.millis is 0, Tm is updated
51			return buffer, which must have 15 bytes
52			*/
53			extern char timeGtf ( char buf, Tm * );
54			/**
55			like timeAsc, but with additional 3 digits millis
56			return buffer, which must have 18 bytes
57			*/
58			extern char timeGtfm ( char buf, Tm * );
59			/**
60			nanosl
61			*/
62			extern void timeSleep ( Tm * );
63
64
65			/* ************************************************************
66			system files
67			*/
68
69			/**
70			system file is a non-negative 32bit int including status bits.
71			main status bits are LIO_IN and LIO_OUT,
72			which are set by open and cleared by close.
73
74			negative values are reserved for use by non-system based streams.
75			*/
76			#define LIO_WANT 0xfff00000 /* what we want: open flags */
77			#define LIO_FD 0x0000ffff /* what we get: system fd */
78			#define LIO_STAT 0x000f0000 /* how it's going: it's status */
79
80			/* status flags */
81			#define LIO_IN 0x00010000 /* support input */
82			#define LIO_OUT 0x00020000 /* support output */
83			#define LIO_INOUT 0x00030000 /* support both */
84			#define LIO_ISOPEN( file ) (LIO_INOUT & (file))
85
86			/* common requirements that are also used by non-system streams. */
87			#define LIO_RD 0x00100000 /* shall be opened for input */
88			#define LIO_WR 0x00200000 /* shall be opened for output */
89			#define LIO_RDWR 0x00300000 /* shall be opened for both */
90			#define LIO_SYNC 0x00400000 /* with WR: syncing output */
91			#define LIO_NBLK 0x00800000 /* non blocking IO (not used) */
92
93			/* system files only. */
94			#define LIO_CREAT 0x01000000 /* with WR: shall be created */
95			#define LIO_TRY 0x01000000 /* w/o WR: do not complain if open fails */
96			#define LIO_TRUNC 0x02000000 /* with WR: shall be truncated */
97			#define LIO_SEEK 0x04000000 /* random access (with WR: else append mode) */
98			#define LIO_SOCK 0x08000000 /* is a socket (support shutdown) */
99
100			/* locking */
101			#define LIO_TLOCK 0x10000000 /* try locking (EX with WR) */
102			#define LIO_WLOCK 0x20000000 /* lock waiting (EX with WR) */
103			#define LIO_FLOCK 0x30000000 /* any locking is set */
104
105
106			/** create a new fid based on name and flags.
107			name may be &i to use fd i, esp. for i=0,1 or 2.
108			@return non-negative file or some error code
109			*/
110			extern int lio_open ( const char *name, int flags );
111			extern int lio_close ( int *file, int flags );
112			extern int lio_size ( int file );
113			extern unsigned lio_time ( int file ); /* mtime sec */
114
115			extern int lio_in;
116			extern int lio_out;
117			extern int lio_err;
118
119
120			/*
121			Like the syscalls, this returns the number of bytes on success.
122			Unlike the syscalls, it returns 0 rather than an error
123			when no bytes are available after interrupt (EINTR)
124			or on non-blocking IO (EAGAIN); i.e. you may try later.
125			On error, a negative value is returned.
126			On errors that render the file unusable,
127			it is closed for input or output, resp.
128			These are most errors but EFAULT (bad buf)
129			and ESPIPE (which clears the SEEK bit).
130			For files that do not have the SEEK bit set,
131			EOF is considered such an error and -LERR_EOF is returned.
132			If you want to stream a disk file like 'tail -f', set the SEEK bit.
133			*/
134			extern int lio_read ( int file, void buf, unsigned count );
135			extern int lio_write ( int file, const void buf, unsigned count );
136			extern int lio_pread ( int file, void buf, unsigned count, int offset );
137			extern int lio_pwrite ( int file, const void buf, unsigned count, int offset );
138			extern int lio_seek ( int *file, int offset );
139			extern int lio_trunc ( int *file, int offset );
140			/**
141			open, sync or close a memory mapping
142
143			@param file pointer to open file handle to map.
144			if file is NULL, *map is unmapped (and set to NULL)
145			else if *map is NULL, length bytes are mapped
146			else *map is synced (flushed)
147			@param length number of bytes to map; if 0, size will be used
148			@return mapped length; if <= 0, *map is set to 0, else to memory region
149			*/
150			extern int lio_mmap ( int file, void *map, int length );
151
152
153			/** slurp in a whole file at once.
154			@param buf points to buffer of size sz.
155			lio_slurp will allocate one, if *buf is NULL
156			@param sz maximum number of bytes to read
157			@param name of file to slurp
158			@param opt if != 0, do not complain on failure
159			@return number of bytes read or negative on error
160			*/
161			extern int lio_slurp ( char *buf, int sz, const char name, int opt );
162
163
164
165			/* ************************************************************
166			streams
167			*/
168
169			/** an I/O buffered stream similar to stdio's FILE.
170			Unlike FILE with it's stupid ungetc,
171			it supports efficient scanning of the whole input buffer without
172			actually consuming it.
173			Also unlike at least Linux' glibc's stdio, access is not interlocked.
174			The buffer is typically used for input OR output.
175			However, for internal pipes, the same buffer is used from both ends.
176
177			High level access functions like printf operate directly on the buffer
178			and call the stream function on buffer underflow or overflow
179			(or explicit flush).
180			*/
181			typedef int lio_sfunc ( struct Ios *s, int op );
182
183			enum {
184			LIO_BUFSIZ = 8192
185			};
186
187			typedef struct Buf {
188			/* struct Buf nxt; chain -- not used /
189			short fill; /* total #bytes in the buffer */
190			short done; /* #bytes done */
191			unsigned char c[LIO_BUFSIZ]; /* actual buffer may be longer */
192			} Buf;
193			/* fill - done is the number of available bytes */
194			#define LIO_BAVAIL( b ) ((b)->fill - (b)->done)
195			#define LIO_BINIT( b ) do { \
196			/(b)->nxt = 0;/ (b)->fill = 0; (b)->done = 0; \
197			} while (0)
198			#define LIO_BINITIALIZER { 0,0,"" }
199
200			typedef struct Ios {
201			lio_sfunc *func;
202			const char name; / stream's name */
203			int file; /* file "id" and flags as above */
204			int pos; /* logical position of buffer start within stream */
205			Buf b;
206			} Ios;
207
208			#define LIO_SISOPEN( s ) LIO_ISOPEN( (s)->file )
209			#define LIO_SAVAIL( s ) LIO_BAVAIL( &(s)->b )
210			#define LIO_SINIT( s, fun, nam, fil ) do { \
211			(s)->func = fun; (s)->name = nam; (s)->file = fil; \
212			(s)->pos = 0; \
213			LIO_BINIT( &(s)->b ); \
214			} while (0)
215			#define LIO_STDINIT( s, nam, fil ) LIO_SINIT( s, lio_stdio, nam, fil )
216			#define LIO_SINITIALIZER( fun, nam, fil ) { fun, nam, fil, 0, LIO_BINITIALIZER }
217			#define LIO_STDINITIALIZER( nam, fil ) LIO_SINITIALIZER( lio_stdio, nam, fil )
218
219
220			/** stream operations.
221			*/
222			enum {
223			LIO_SSIZE, /* tell the size of the stream structure */
224			LIO_SOPEN, /* initialize the structure */
225			LIO_SCLOSE, /* close */
226			LIO_SPURGE, /* kill the done bytes. return fill buffer size */
227			LIO_SFILL, /* try to refill the buffer (poll input). return # new bytes */
228			LIO_SFLUSH, /* try to flush the buffer. return # bytes written */
229			LIO_SPUSH /* push input stream: munge prefilled input */
230			};
231
232			/**
233			"abstract" base implementation of stream.
234			not very useful in itself, but used by derived impl.
235			*/
236			extern int ioStream ( Ios *s, int op );
237
238			/**
239			stream func based on system file to mimic stdio.
240			on LIO_SOPEN, the fid is set by lio_open based on name.
241			other ops used the correponding lio system call.
242			*/
243			extern int ioStdio ( Ios *s, int op );
244
245			#define LIO_OPEN( s ) (s)->func( (s), LIO_SOPEN )
246			#define LIO_CLOSE( s ) (s)->func( (s), LIO_SCLOSE )
247			#define LIO_FILL( s ) (s)->func( (s), LIO_SFILL )
248			#define LIO_FLUSH( s ) (s)->func( (s), LIO_SFLUSH )
249
250
251
252
253			/* ************************************************************
254			inter process communication
255			*/
256
257			extern CLockFunc *lio_lock;
258			#define LIO_LOCK() (NULL != lio_lock && lio_lock(OPENISIS_LOCK))
259			#define LIO_RELE() (NULL != lio_lock && lio_lock(OPENISIS_RELE))
260			#define LIO_WAIT( c ) (NULL != lio_lock && lio_lock(OPENISIS_WAIT \
261			\| (OPENISIS_COND & (c))))
262			#define LIO_WAKE( c ) (NULL != lio_lock && lio_lock(OPENISIS_WAKE \
263			\| (OPENISIS_COND & (c))))
264
265			#define LIO_H
266			#endif /* LIO_H */