0.9.9e/pw/pw.c

/*
        The Malete project - the Z39.2/Z39.50 database framework of OpenIsis.
        Version 0.9.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: pw.c,v 1.7 2004/03/29 09:35:20 kripke Exp $
        Malete patchwork functions
*/

#include "../pw/pw.h"


Ses *ses;


/* ************************************************************
        object
*/

int OPT_STDCALL mPipe ( Obj *self, Msg msg )
{
#if 1
        (void)self; (void)msg; return ERR_INVAL;
#else
        int rv = ERR_INVAL, eflg = env.flg;
        const char *p, *q, *e;
        Sink l1, l2, *pin, *pout, *eout = env.out;
        lInit( pout = &l1, 0 );
        lInit( pin = &l2, 0 );
        lCpy( pin, msg, 0 );
        LADD( pout, -1, msg->val, msg->len );
        env.out = pout;
        env.flg |= ENV_BUFFER;
        for ( p = msg->val, q = 0, e = msg->val + msg->len; e > p; ) {
                if ( ( TAB == *p++ && ( '|' == *p || msg->val == p-2 ) ) || e == p ) {
                        if ( q ) {
                                char *s = pin->fld->val;
                                pin->fld->val += q - msg->val;
                                pin->fld->len = ( p - q );
                                if ( e > p )
                                        --pin->fld->len;
                                if ( ( rv = self->snd( self, pin->fld ) ) )
                                        goto cleanup;
                                pin->fld->val = s;
                                pin->fld->len = msg->len;
                                lReset( pin );
                                env.out = pin;
                                pin = pout;
                                pout = env.out;
                        }
                        q = '|' == *p ? p+1 : p;
                }
        }
        LCPY( eout, pin );
cleanup:
        env.out = eout;
        env.flg = eflg;
        lClr( pin );
        lClr( pout );
        return rv;
#endif
}       /* mPipe */


int OPT_STDCALL mComp ( Obj *self, Msg msg )
{
        const char *e = msg->val + msg->len;
        char *q, *p;
        int rv = ERR_INVAL;
        for ( q = 0, p = msg->val, e = msg->val + msg->len; e > p; ) {
                if ( ( TAB == *p++ && ( ';' == *p || msg->val == p-2 ) ) || e == p ) {
                        if ( q ) {
                                msg->val = q;
                                msg->len = (p - q);
                                if ( e > p )
                                        --msg->len;
                                if ( 0 > (rv = self->snd(self, msg)) )
                                        return rv;
                        }
                        q = ';' == *p ? p+1 : p;
                }
        }
        return rv;
}       /* mComp */


int OPT_STDCALL mComm ( Obj *self, Msg msg )
{
        EADDF(msg);
        if ( -1 <= msg->tag )
                return 0;
        if ( msg[1].tag > msg->tag+1 ) /* not properly embedded */
                msg[1].tag = msg->tag+1;
        return self->snd(self, msg+1);
}       /* mComm */


int OPT_STDCALL oObj ( Obj *self, Msg msg )
{
        eRr(LOG_VERBOSE, "oObj '%.*s'", msg->len, msg->val);
        if ( msg->len )
                switch (*msg->val) {
                case '|': return mPipe(self, msg);
                case ';': return mComp(self, msg);
                case '#': return mComm(self, msg);
                case '=': return 0;
                case '.': return dispatch(msg);
                }
        else
                return eOut(0, "#\t0");
        return eRr(ERR_INVAL, "unrecognized message '%.*s'", msg->len, msg->val); 
}       /* oObj */


/* ************************************************************
        struct
*/
int OPT_STDCALL oStruct ( Struct *self, Msg msg )
{
        HEntry *he;
        int nlen;
        char *p = msg->val, *e = p + msg->len;
        if ( !msg->len || CT_A != lat1ct[(unsigned char)*p] )
                return oObj((Obj*)self, msg);
        eRr(LOG_VERBOSE, "oStruct '%.*s'", msg->len, msg->val);
        /* must address child */
        for ( ;p < e; p++ )
                switch (*p) {
                case TAB:
                        break;
                case '.':
                        goto dot;
                }
        return eRr(ERR_INVAL, "bad struct msg '%.*s'", p-msg->val, msg->val);
dot:
        nlen = p++ - msg->val;
        if ( !self->reg || !(he = hGet(self->reg, msg->val, nlen)) ) {
                Obj *cld;
                if ( !self->fac || !(cld = self->fac(self, msg->val, nlen)) )
                        return ERR_INVAL;
                if ( !self->reg ) {
                        self->reg = (HTable *) mAlloc( sizeof(HTable) );
                        hInit(self->reg, "reg");
                }
                he = hSet(self->reg, msg->val, nlen, cld);
        }
        if ( he && he->obj ) { 
                msg->len -= nlen + 1;
                msg->val = p; 
                return  ((Obj *) he->obj)->snd( (Obj *) he->obj, msg ); 
        } 
        return eRr(ERR_INVAL, "no such child '%.*s'", nlen, msg->val);
} /* oStruct */


int OPT_STDCALL oSes ( Ses *self, Msg msg )
{
        self->req++;
        if ( msg->len && '.' == *msg->val ) { /* rooted */
                msg->val++;
                msg->len--;
        } else if (self->at) { /* prepend default */
                /* TODO */
        }
        return oStruct((Struct*)self, msg);
}       /* oSes */


Obj* OPT_STDCALL facMain ( Ses *self, const char *key, int len )
{
        char *name = mDupz(key, len);
        Obj *ret;

        eRr(LOG_VERBOSE, "facMain '%.*s'", len, key);
        (void)self; /* could be used for authorization etc. */
        /* we should scan env.opt for defined objects like remote servers
                however, db is the default anyway
        */
        ret = (Obj*)newDbo(name);
        mFree(name);
        return ret;
}       /* facMain */


void sInit (Ses *self)
{
        memset(self, 0, sizeof(Ses));
        self->snd = (disp*)oSes;
        self->fac = (factory*)facMain;
        self->out = env.out;
        self->err = env.err;
        /* TODO: check env opts for option settings */
        self->r = 20;
        self->q = 20;
        self->s = 10000;
}       /* sInit */
1	dpavlin	604	/*
2			The Malete project - the Z39.2/Z39.50 database framework of OpenIsis.
3			Version 0.9.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.
14			See the GNU 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: pw.c,v 1.7 2004/03/29 09:35:20 kripke Exp $
25			Malete patchwork functions
26			*/
27
28			#include "../pw/pw.h"
29
30
31			Ses *ses;
32
33
34			/* ************************************************************
35			object
36			*/
37
38			int OPT_STDCALL mPipe ( Obj *self, Msg msg )
39			{
40			#if 1
41			(void)self; (void)msg; return ERR_INVAL;
42			#else
43			int rv = ERR_INVAL, eflg = env.flg;
44			const char p, q, *e;
45			Sink l1, l2, pin, pout, *eout = env.out;
46			lInit( pout = &l1, 0 );
47			lInit( pin = &l2, 0 );
48			lCpy( pin, msg, 0 );
49			LADD( pout, -1, msg->val, msg->len );
50			env.out = pout;
51			env.flg \|= ENV_BUFFER;
52			for ( p = msg->val, q = 0, e = msg->val + msg->len; e > p; ) {
53			if ( ( TAB == p++ && ( '\|' == p \|\| msg->val == p-2 ) ) \|\| e == p ) {
54			if ( q ) {
55			char *s = pin->fld->val;
56			pin->fld->val += q - msg->val;
57			pin->fld->len = ( p - q );
58			if ( e > p )
59			--pin->fld->len;
60			if ( ( rv = self->snd( self, pin->fld ) ) )
61			goto cleanup;
62			pin->fld->val = s;
63			pin->fld->len = msg->len;
64			lReset( pin );
65			env.out = pin;
66			pin = pout;
67			pout = env.out;
68			}
69			q = '\|' == *p ? p+1 : p;
70			}
71			}
72			LCPY( eout, pin );
73			cleanup:
74			env.out = eout;
75			env.flg = eflg;
76			lClr( pin );
77			lClr( pout );
78			return rv;
79			#endif
80			} /* mPipe */
81
82
83			int OPT_STDCALL mComp ( Obj *self, Msg msg )
84			{
85			const char *e = msg->val + msg->len;
86			char q, p;
87			int rv = ERR_INVAL;
88			for ( q = 0, p = msg->val, e = msg->val + msg->len; e > p; ) {
89			if ( ( TAB == p++ && ( ';' == p \|\| msg->val == p-2 ) ) \|\| e == p ) {
90			if ( q ) {
91			msg->val = q;
92			msg->len = (p - q);
93			if ( e > p )
94			--msg->len;
95			if ( 0 > (rv = self->snd(self, msg)) )
96			return rv;
97			}
98			q = ';' == *p ? p+1 : p;
99			}
100			}
101			return rv;
102			} /* mComp */
103
104
105			int OPT_STDCALL mComm ( Obj *self, Msg msg )
106			{
107			EADDF(msg);
108			if ( -1 <= msg->tag )
109			return 0;
110			if ( msg[1].tag > msg->tag+1 ) /* not properly embedded */
111			msg[1].tag = msg->tag+1;
112			return self->snd(self, msg+1);
113			} /* mComm */
114
115
116			int OPT_STDCALL oObj ( Obj *self, Msg msg )
117			{
118			eRr(LOG_VERBOSE, "oObj '%.*s'", msg->len, msg->val);
119			if ( msg->len )
120			switch (*msg->val) {
121			case '\|': return mPipe(self, msg);
122			case ';': return mComp(self, msg);
123			case '#': return mComm(self, msg);
124			case '=': return 0;
125			case '.': return dispatch(msg);
126			}
127			else
128			return eOut(0, "#\t0");
129			return eRr(ERR_INVAL, "unrecognized message '%.*s'", msg->len, msg->val);
130			} /* oObj */
131
132
133
134			/* ************************************************************
135			struct
136			*/
137			int OPT_STDCALL oStruct ( Struct *self, Msg msg )
138			{
139			HEntry *he;
140			int nlen;
141			char p = msg->val, e = p + msg->len;
142			if ( !msg->len \|\| CT_A != lat1ct[(unsigned char)*p] )
143			return oObj((Obj*)self, msg);
144			eRr(LOG_VERBOSE, "oStruct '%.*s'", msg->len, msg->val);
145			/* must address child */
146			for ( ;p < e; p++ )
147			switch (*p) {
148			case TAB:
149			break;
150			case '.':
151			goto dot;
152			}
153			return eRr(ERR_INVAL, "bad struct msg '%.*s'", p-msg->val, msg->val);
154			dot:
155			nlen = p++ - msg->val;
156			if ( !self->reg \|\| !(he = hGet(self->reg, msg->val, nlen)) ) {
157			Obj *cld;
158			if ( !self->fac \|\| !(cld = self->fac(self, msg->val, nlen)) )
159			return ERR_INVAL;
160			if ( !self->reg ) {
161			self->reg = (HTable *) mAlloc( sizeof(HTable) );
162			hInit(self->reg, "reg");
163			}
164			he = hSet(self->reg, msg->val, nlen, cld);
165			}
166			if ( he && he->obj ) {
167			msg->len -= nlen + 1;
168			msg->val = p;
169			return ((Obj ) he->obj)->snd( (Obj ) he->obj, msg );
170			}
171			return eRr(ERR_INVAL, "no such child '%.*s'", nlen, msg->val);
172			} /* oStruct */
173
174
175			int OPT_STDCALL oSes ( Ses *self, Msg msg )
176			{
177			self->req++;
178			if ( msg->len && '.' == msg->val ) { / rooted */
179			msg->val++;
180			msg->len--;
181			} else if (self->at) { /* prepend default */
182			/* TODO */
183			}
184			return oStruct((Struct*)self, msg);
185			} /* oSes */
186
187
188			Obj* OPT_STDCALL facMain ( Ses self, const char key, int len )
189			{
190			char *name = mDupz(key, len);
191			Obj *ret;
192
193			eRr(LOG_VERBOSE, "facMain '%.*s'", len, key);
194			(void)self; /* could be used for authorization etc. */
195			/* we should scan env.opt for defined objects like remote servers
196			however, db is the default anyway
197			*/
198			ret = (Obj*)newDbo(name);
199			mFree(name);
200			return ret;
201			} /* facMain */
202
203
204			void sInit (Ses *self)
205			{
206			memset(self, 0, sizeof(Ses));
207			self->snd = (disp*)oSes;
208			self->fac = (factory*)facMain;
209			self->out = env.out;
210			self->err = env.err;
211			/* TODO: check env opts for option settings */
212			self->r = 20;
213			self->q = 20;
214			self->s = 10000;
215			} /* sInit */