[catagits/fcgi2.git] / perl / FCGI.XL

use Config;

open OUT, ">FCGI.xs";

print "Generating FCGI.xs for Perl version $]\n";
#unless (exists $Config{apiversion} && $Config{apiversion} >= 5.005) 
unless ($] >= 5.005) {
    for (qw(sv_undef diehook warnhook in_eval)) {
	print OUT "#define PL_$_ $_\n" 
    }
}
print OUT while <DATA>;
close OUT;
__END__
/* $Id: FCGI.XL,v 1.1 2000/12/31 21:46:58 skimo Exp $ */

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "fcgi_config.h"
#include "fcgiapp.h"
#include "fastcgi.h"

#ifndef FALSE
#define FALSE (0)
#endif

#ifndef TRUE
#define TRUE  (1)
#endif

#ifndef dTHX
#define dTHX
#endif

#ifdef USE_SFIO
typedef struct
{
    Sfdisc_t	disc;
    FCGX_Stream	*stream;
} FCGI_Disc;

static ssize_t
sffcgiread(f, buf, n, disc)
Sfio_t*		f;      /* stream involved */
Void_t*		buf;    /* buffer to read into */
size_t		n;      /* number of bytes to read */
Sfdisc_t*	disc;   /* discipline */
{
    return FCGX_GetStr(buf, n, ((FCGI_Disc *)disc)->stream);
}

static ssize_t
sffcgiwrite(f, buf, n, disc)
Sfio_t*		f;      /* stream involved */
const Void_t*	buf;    /* buffer to read into */
size_t		n;      /* number of bytes to read */
Sfdisc_t*	disc;   /* discipline */
{
    n = FCGX_PutStr(buf, n, ((FCGI_Disc *)disc)->stream);
    FCGX_FFlush(((FCGI_Disc *)disc)->stream);
    return n;
}

Sfdisc_t *
sfdcnewfcgi(stream)
	FCGX_Stream *stream;
{
    FCGI_Disc*	disc;

    New(1000,disc,1,FCGI_Disc);
    if (!disc) return (Sfdisc_t *)disc;

    disc->disc.exceptf = (Sfexcept_f)NULL;
    disc->disc.seekf = (Sfseek_f)NULL;
    disc->disc.readf = sffcgiread;
    disc->disc.writef = sffcgiwrite;
    disc->stream = stream;
    return (Sfdisc_t *)disc;
}

Sfdisc_t *
sfdcdelfcgi(disc)
    Sfdisc_t*	disc;
{
    Safefree(disc);
    return 0;
}
#endif

#if defined(USE_LOCKING) && defined(USE_THREADS)
static perl_mutex   accept_mutex;
#endif

typedef struct FCGP_Request {
    int		    accepted;
    int		    bound;
    SV*		    svin;
    SV*		    svout;
    SV*		    sverr;
    GV*		    gv[3];
    HV*		    hvEnv;
    FCGX_Request*   requestPtr;
#ifdef USE_SFIO
    int		    sfcreated[3];
    IO*		    io[3];
#endif
} FCGP_Request;

static void FCGI_Finish(FCGP_Request* request);

static int 
FCGI_Flush(FCGP_Request* request)
{
    dTHX;

    if(!request->bound) {
	return;
    }
#ifdef USE_SFIO
    sfsync(IoOFP(GvIOp(request->gv[1])));
    sfsync(IoOFP(GvIOp(request->gv[2])));
#else
    FCGX_FFlush((FCGX_Stream *) SvIV((SV*) SvRV(request->svout)));
    FCGX_FFlush((FCGX_Stream *) SvIV((SV*) SvRV(request->sverr)));
#endif
}

static void
FCGI_UndoBinding(FCGP_Request* request)
{
    dTHX;

#ifdef USE_SFIO
    sfdcdelfcgi(sfdisc(IoIFP(request->io[0]), SF_POPDISC));
    sfdcdelfcgi(sfdisc(IoOFP(request->io[1]), SF_POPDISC));
    sfdcdelfcgi(sfdisc(IoOFP(request->io[2]), SF_POPDISC));
#else
    sv_unmagic((SV *)request->gv[0], 'q');
    sv_unmagic((SV *)request->gv[1], 'q');
    sv_unmagic((SV *)request->gv[2], 'q');
#endif
    request->bound = FALSE;
}

static void
FCGI_Bind(FCGP_Request* request)
{
    dTHX;

#ifdef USE_SFIO
    sfdisc(IoIFP(request->io[0]), sfdcnewfcgi(request->requestPtr->in));
    sfdisc(IoOFP(request->io[1]), sfdcnewfcgi(request->requestPtr->out));
    sfdisc(IoOFP(request->io[2]), sfdcnewfcgi(request->requestPtr->err));
#else
    sv_magic((SV *)request->gv[1], request->svout, 'q', Nullch, 0);
    sv_magic((SV *)request->gv[2], request->sverr, 'q', Nullch, 0);
    sv_magic((SV *)request->gv[0], request->svin, 'q', Nullch, 0);
#endif
    request->bound = TRUE;
}

static void
populate_env(envp, hv)
char **envp;
HV *hv;
{
    int i;
    char *p, *p1;
    SV   *sv;
    dTHX;

    hv_clear(hv);
    for(i = 0; ; i++) {
	if((p = envp[i]) == NULL) {
	    break;
	}
	p1 = strchr(p, '=');
	assert(p1 != NULL);
	sv = newSVpv(p1 + 1, 0);
	/* call magic for this value ourselves */
	hv_store(hv, p, p1 - p, sv, 0);
	SvSETMAGIC(sv);
    }
}

static int
FCGI_IsFastCGI(FCGP_Request* request)
{
    static int isCGI = -1; /* -1: not checked; 0: FCGI; 1: CGI */

    if (request->requestPtr->listen_sock == FCGI_LISTENSOCK_FILENO) {
	if (isCGI == -1)
	    isCGI = FCGX_IsCGI();
	return !isCGI;
    }

    /* A explicit socket is being used -> assume FastCGI */
    return 1;
}

static int 
FCGI_Accept(FCGP_Request* request)
{
    dTHX;

    if (!FCGI_IsFastCGI(request)) {
	static int been_here = 0;

        /*
         * Not first call to FCGI_Accept and running as CGI means
         * application is done.
         */
	if (been_here)
	    return EOF;

	been_here = 1;
    } else {
#ifdef USE_SFIO
	int i;
#endif
	FCGX_Request *fcgx_req = request->requestPtr;
        int acceptResult;

	FCGI_Finish(request);
#if defined(USE_LOCKING) && defined(USE_THREADS)
	MUTEX_LOCK(&accept_mutex);
#endif
	acceptResult = FCGX_Accept_r(fcgx_req);
#if defined(USE_LOCKING) && defined(USE_THREADS)
	MUTEX_UNLOCK(&accept_mutex);
#endif
        if(acceptResult < 0) {
            return acceptResult;
        }

	populate_env(fcgx_req->envp, request->hvEnv);

#ifdef USE_SFIO
	for (i = 0; i < 3; ++i) {
	    request->io[i] = GvIOn(request->gv[i]);
	    if (!(i == 0 ? IoIFP(request->io[i]) 
			 : IoOFP(request->io[i]))) {
		IoIFP(request->io[i]) = sftmp(0);
		/*IoIFP(request->io[i]) = sfnew(NULL, NULL, SF_UNBOUND, 0, 
				     SF_STRING | (i ? SF_WRITE : SF_READ));*/
		if (i != 0) 
		    IoOFP(request->io[i]) = IoIFP(request->io[i]);
		request->sfcreated[i] = TRUE;
	    }
	}
#else
	if (!request->svout) {
	    newSVrv(request->svout = newSV(0), "FCGI::Stream");
	    newSVrv(request->sverr = newSV(0), "FCGI::Stream");
	    newSVrv(request->svin = newSV(0), "FCGI::Stream");
	}
	sv_setiv(SvRV(request->svout), (IV) fcgx_req->out);
	sv_setiv(SvRV(request->sverr), (IV) fcgx_req->err);
	sv_setiv(SvRV(request->svin), (IV) fcgx_req->in);
#endif
	FCGI_Bind(request);
	request->accepted = TRUE;
    }
    return 0;
}

static void 
FCGI_Finish(FCGP_Request* request)
{
#ifdef USE_SFIO
    int i;
#endif
    int was_bound;
    dTHX;

    if(!request->accepted) {
	return;
    }

    if (was_bound = request->bound) {
	FCGI_UndoBinding(request);
    }
#ifdef USE_SFIO
    for (i = 0; i < 3; ++i) {
	if (request->sfcreated[i]) {
	    sfclose(IoIFP(request->io[i]));
	    IoIFP(request->io[i]) = IoOFP(request->io[i]) = Nullfp;
	    request->sfcreated[i] = FALSE;
	}
    }
#endif
    if (was_bound)
	FCGX_Finish_r(request->requestPtr);
    else
	FCGX_Free(request->requestPtr);
    request->accepted = FALSE;
}

static int 
FCGI_StartFilterData(FCGP_Request* request)
{
    return request->requestPtr->in ? 
	    FCGX_StartFilterData(request->requestPtr->in) : -1;
}

static FCGP_Request *
FCGI_Request(in, out, err, env, socket, flags)
    GV*	    in;
    GV*	    out;
    GV*	    err;
    HV*	    env;
    int	    socket;
    int	    flags;
{
    FCGX_Request* fcgx_req;
    FCGP_Request* req;

    Newz(551, fcgx_req, 1, FCGX_Request);
    FCGX_InitRequest(fcgx_req, socket, flags);
    Newz(551, req, 1, FCGP_Request);
    req->requestPtr = fcgx_req;
    req->gv[0] = in;
    req->gv[1] = out;
    req->gv[2] = err;
    req->hvEnv = env;

    return req;
}

static void
FCGI_Release_Request(FCGP_Request *req)
{
    FCGI_Finish(req);
    Safefree(req->requestPtr);
    Safefree(req);
}

static void
FCGI_Init()
{
#if defined(USE_LOCKING) && defined(USE_THREADS)
    dTHX;

    MUTEX_INIT(&accept_mutex);
#endif

    FCGX_Init();
}

typedef FCGX_Stream *	FCGI__Stream;
typedef FCGP_Request *	FCGI;
typedef	GV*		GLOBREF;
typedef	HV*		HASHREF;

MODULE = FCGI		PACKAGE = FCGI	    PREFIX = FCGI_

BOOT:
    FCGI_Init();

SV *
RequestX(in, out, err, env, socket, flags)
    GLOBREF in;
    GLOBREF out;
    GLOBREF err;
    HASHREF env;
    int	    socket;
    int	    flags;

    PROTOTYPE: ***$$$
    CODE:
    RETVAL = sv_setref_pv(newSV(0), "FCGI", 
		FCGI_Request(in, out, err, env, socket, flags));

    OUTPUT:
    RETVAL

int
OpenSocket(path, backlog)
    char* path;
    int backlog;

    PROTOTYPE: $$
    CODE:
    RETVAL = FCGX_OpenSocket(path, backlog);
    OUTPUT:
    RETVAL

void
CloseSocket(socket)
    int socket;

    PROTOTYPE: $
    CODE:
    close(socket);

int
FCGI_Accept(request)

    FCGI    request;

    PROTOTYPE: $

void
FCGI_Finish(request)
    FCGI    request;

    PROTOTYPE: $

void
FCGI_Flush(request)
    FCGI    request;

    PROTOTYPE: $

HV *
GetEnvironment(request)
    FCGI    request;

    PROTOTYPE: $

    CODE:
    RETVAL = request->hvEnv;

    OUTPUT: 
    RETVAL

void
GetHandles(request)
    FCGI    request;

    PROTOTYPE: $

    PREINIT:
    int	    i;

    PPCODE:
    EXTEND(sp,3);
    for (i = 0; i < 3; ++i)
	PUSHs(sv_2mortal(newRV((SV *) request->gv[i])));

int
FCGI_IsFastCGI(request)
    FCGI    request;

    PROTOTYPE: $

void
Detach(request)

    FCGI    request;

    PROTOTYPE: $

    CODE:
    if (request->accepted && request->bound)
	FCGI_UndoBinding(request);

void
Attach(request)

    FCGI    request;

    PROTOTYPE: $

    CODE:
    if (request->accepted && !request->bound)
	FCGI_Bind(request);


int
FCGI_StartFilterData(request)

    FCGI    request;

    PROTOTYPE: $

void
DESTROY(request)
    FCGI    request;

    CODE:
    FCGI_Release_Request(request);


MODULE = FCGI		PACKAGE = FCGI::Stream

#ifndef USE_SFIO

void
PRINT(stream, ...)
	FCGI::Stream	stream;

	PREINIT:
	int	n;

	CODE:
	for (n = 1; n < items; ++n) {
            STRLEN len;
            register char *tmps = (char *)SvPV(ST(n),len);
            FCGX_PutStr(tmps, len, stream);
	}
	if (SvTRUEx(perl_get_sv("|", FALSE))) 
	    FCGX_FFlush(stream);

int
WRITE(stream, bufsv, len, ...)
	FCGI::Stream	stream;
	SV *	bufsv;
	int	len;

	PREINIT:
	int	offset;
	char *	buf;
	STRLEN	blen;
	int	n;

	CODE:
	offset = (items == 4) ? (int)SvIV(ST(3)) : 0;
	buf = SvPV(bufsv, blen);
	if (offset < 0) offset += blen;
	if (len > blen - offset)
	    len = blen - offset;
	if (offset < 0 || offset >= blen ||
		(n = FCGX_PutStr(buf+offset, len, stream)) < 0) 
	    ST(0) = &PL_sv_undef;
	else {
	    ST(0) = sv_newmortal();
	    sv_setpvf(ST(0), "%c", n);
	}

int
READ(stream, bufsv, len, ...)
	FCGI::Stream	stream;
	SV *	bufsv;
	int	len;

	PREINIT:
	int	offset;
	char *	buf;

	CODE:
	offset = (items == 4) ? (int)SvIV(ST(3)) : 0;
	if (! SvOK(bufsv))
	    sv_setpvn(bufsv, "", 0);
	buf = SvGROW(bufsv, len+offset+1);
	len = FCGX_GetStr(buf+offset, len, stream);
	SvCUR_set(bufsv, len+offset);
	*SvEND(bufsv) = '\0';
	(void)SvPOK_only(bufsv);
	SvSETMAGIC(bufsv);
	RETVAL = len;

	OUTPUT:
	RETVAL

SV *
GETC(stream)
	FCGI::Stream	stream;

	PREINIT:
	int	retval;

	CODE:
	if ((retval = FCGX_GetChar(stream)) != -1) {
	    ST(0) = sv_newmortal();
	    sv_setpvf(ST(0), "%c", retval);
	} else ST(0) = &PL_sv_undef;

bool
CLOSE(stream)
	FCGI::Stream	stream;

#	ALIAS:
#	DESTROY = 1

	CODE:
	RETVAL = FCGX_FClose(stream) != -1;

	OUTPUT:
	RETVAL

#endif
Commit	Line	Data
0833402a	1	use Config;
	2
	3	open OUT, ">FCGI.xs";
	4
	5	print "Generating FCGI.xs for Perl version $]\n";
	6	#unless (exists $Config{apiversion} && $Config{apiversion} >= 5.005)
	7	unless ($] >= 5.005) {
	8	for (qw(sv_undef diehook warnhook in_eval)) {
	9	print OUT "#define PL_$_ $_\n"
	10	}
	11	}
	12	print OUT while <DATA>;
	13	close OUT;
	14	__END__
	15	/* $Id: FCGI.XL,v 1.1 2000/12/31 21:46:58 skimo Exp $ */
	16
	17	#include "EXTERN.h"
	18	#include "perl.h"
	19	#include "XSUB.h"
	20
	21	#include "fcgi_config.h"
	22	#include "fcgiapp.h"
	23	#include "fastcgi.h"
	24
	25	#ifndef FALSE
	26	#define FALSE (0)
	27	#endif
	28
	29	#ifndef TRUE
	30	#define TRUE (1)
	31	#endif
	32
	33	#ifndef dTHX
	34	#define dTHX
	35	#endif
	36
	37	#ifdef USE_SFIO
	38	typedef struct
	39	{
	40	Sfdisc_t disc;
	41	FCGX_Stream *stream;
	42	} FCGI_Disc;
	43
	44	static ssize_t
	45	sffcgiread(f, buf, n, disc)
	46	Sfio_t* f; /* stream involved */
	47	Void_t* buf; /* buffer to read into */
	48	size_t n; /* number of bytes to read */
	49	Sfdisc_t* disc; /* discipline */
	50	{
	51	return FCGX_GetStr(buf, n, ((FCGI_Disc *)disc)->stream);
	52	}
	53
	54	static ssize_t
	55	sffcgiwrite(f, buf, n, disc)
	56	Sfio_t* f; /* stream involved */
	57	const Void_t* buf; /* buffer to read into */
	58	size_t n; /* number of bytes to read */
	59	Sfdisc_t* disc; /* discipline */
	60	{
	61	n = FCGX_PutStr(buf, n, ((FCGI_Disc *)disc)->stream);
	62	FCGX_FFlush(((FCGI_Disc *)disc)->stream);
	63	return n;
	64	}
65
66	Sfdisc_t *
67	sfdcnewfcgi(stream)
68	FCGX_Stream *stream;
69	{
70	FCGI_Disc* disc;
71
72	New(1000,disc,1,FCGI_Disc);
73	if (!disc) return (Sfdisc_t *)disc;
74
75	disc->disc.exceptf = (Sfexcept_f)NULL;
76	disc->disc.seekf = (Sfseek_f)NULL;
77	disc->disc.readf = sffcgiread;
78	disc->disc.writef = sffcgiwrite;
79	disc->stream = stream;
80	return (Sfdisc_t *)disc;
81	}
82
83	Sfdisc_t *
84	sfdcdelfcgi(disc)
85	Sfdisc_t* disc;
86	{
87	Safefree(disc);
88	return 0;
89	}
90	#endif
91
92	#if defined(USE_LOCKING) && defined(USE_THREADS)
93	static perl_mutex accept_mutex;
94	#endif
95
96	typedef struct FCGP_Request {
97	int accepted;
98	int bound;
99	SV* svin;
100	SV* svout;
101	SV* sverr;
102	GV* gv[3];
103	HV* hvEnv;
104	FCGX_Request* requestPtr;
105	#ifdef USE_SFIO
106	int sfcreated[3];
107	IO* io[3];
108	#endif
109	} FCGP_Request;
110
111	static void FCGI_Finish(FCGP_Request* request);
112
113	static int
114	FCGI_Flush(FCGP_Request* request)
115	{
116	dTHX;
117
118	if(!request->bound) {
119	return;
120	}
121	#ifdef USE_SFIO
122	sfsync(IoOFP(GvIOp(request->gv[1])));
123	sfsync(IoOFP(GvIOp(request->gv[2])));
124	#else
125	FCGX_FFlush((FCGX_Stream ) SvIV((SV) SvRV(request->svout)));
126	FCGX_FFlush((FCGX_Stream ) SvIV((SV) SvRV(request->sverr)));
127	#endif
128	}
129
130	static void
131	FCGI_UndoBinding(FCGP_Request* request)
132	{
133	dTHX;
134
135	#ifdef USE_SFIO
136	sfdcdelfcgi(sfdisc(IoIFP(request->io[0]), SF_POPDISC));
137	sfdcdelfcgi(sfdisc(IoOFP(request->io[1]), SF_POPDISC));
138	sfdcdelfcgi(sfdisc(IoOFP(request->io[2]), SF_POPDISC));
139	#else
140	sv_unmagic((SV *)request->gv[0], 'q');
141	sv_unmagic((SV *)request->gv[1], 'q');
142	sv_unmagic((SV *)request->gv[2], 'q');
143	#endif
144	request->bound = FALSE;
145	}
146
147	static void
148	FCGI_Bind(FCGP_Request* request)
149	{
150	dTHX;
151
152	#ifdef USE_SFIO
153	sfdisc(IoIFP(request->io[0]), sfdcnewfcgi(request->requestPtr->in));
154	sfdisc(IoOFP(request->io[1]), sfdcnewfcgi(request->requestPtr->out));
155	sfdisc(IoOFP(request->io[2]), sfdcnewfcgi(request->requestPtr->err));
156	#else
157	sv_magic((SV *)request->gv[1], request->svout, 'q', Nullch, 0);
158	sv_magic((SV *)request->gv[2], request->sverr, 'q', Nullch, 0);
159	sv_magic((SV *)request->gv[0], request->svin, 'q', Nullch, 0);
160	#endif
161	request->bound = TRUE;
162	}
163
164	static void
165	populate_env(envp, hv)
166	char **envp;
167	HV *hv;
168	{
169	int i;
170	char p, p1;
171	SV *sv;
172	dTHX;
173
174	hv_clear(hv);
175	for(i = 0; ; i++) {
176	if((p = envp[i]) == NULL) {
177	break;
178	}
179	p1 = strchr(p, '=');
180	assert(p1 != NULL);
181	sv = newSVpv(p1 + 1, 0);
182	/* call magic for this value ourselves */
183	hv_store(hv, p, p1 - p, sv, 0);
184	SvSETMAGIC(sv);
185	}
186	}
187
188	static int
189	FCGI_IsFastCGI(FCGP_Request* request)
190	{
191	static int isCGI = -1; /* -1: not checked; 0: FCGI; 1: CGI */
192
193	if (request->requestPtr->listen_sock == FCGI_LISTENSOCK_FILENO) {
194	if (isCGI == -1)
195	isCGI = FCGX_IsCGI();
196	return !isCGI;
197	}
198
199	/* A explicit socket is being used -> assume FastCGI */
200	return 1;
201	}
202
203	static int
204	FCGI_Accept(FCGP_Request* request)
205	{
206	dTHX;
207
208	if (!FCGI_IsFastCGI(request)) {
209	static int been_here = 0;
210
211	/*
212	* Not first call to FCGI_Accept and running as CGI means
213	* application is done.
214	*/
215	if (been_here)
216	return EOF;
217
218	been_here = 1;
219	} else {
220	#ifdef USE_SFIO
221	int i;
222	#endif
223	FCGX_Request *fcgx_req = request->requestPtr;
224	int acceptResult;
225
226	FCGI_Finish(request);
227	#if defined(USE_LOCKING) && defined(USE_THREADS)
228	MUTEX_LOCK(&accept_mutex);
229	#endif
230	acceptResult = FCGX_Accept_r(fcgx_req);
231	#if defined(USE_LOCKING) && defined(USE_THREADS)
232	MUTEX_UNLOCK(&accept_mutex);
233	#endif
234	if(acceptResult < 0) {
235	return acceptResult;
236	}
237
238	populate_env(fcgx_req->envp, request->hvEnv);
239
240	#ifdef USE_SFIO
241	for (i = 0; i < 3; ++i) {
242	request->io[i] = GvIOn(request->gv[i]);
243	if (!(i == 0 ? IoIFP(request->io[i])
244	: IoOFP(request->io[i]))) {
245	IoIFP(request->io[i]) = sftmp(0);
246	/*IoIFP(request->io[i]) = sfnew(NULL, NULL, SF_UNBOUND, 0,
247	SF_STRING \| (i ? SF_WRITE : SF_READ));*/
248	if (i != 0)
249	IoOFP(request->io[i]) = IoIFP(request->io[i]);
250	request->sfcreated[i] = TRUE;
251	}
252	}
253	#else
254	if (!request->svout) {
255	newSVrv(request->svout = newSV(0), "FCGI::Stream");
256	newSVrv(request->sverr = newSV(0), "FCGI::Stream");
257	newSVrv(request->svin = newSV(0), "FCGI::Stream");
258	}
259	sv_setiv(SvRV(request->svout), (IV) fcgx_req->out);
260	sv_setiv(SvRV(request->sverr), (IV) fcgx_req->err);
261	sv_setiv(SvRV(request->svin), (IV) fcgx_req->in);
262	#endif
263	FCGI_Bind(request);
264	request->accepted = TRUE;
265	}
266	return 0;
267	}
268
269	static void
270	FCGI_Finish(FCGP_Request* request)
271	{
272	#ifdef USE_SFIO
273	int i;
274	#endif
275	int was_bound;
276	dTHX;
277
278	if(!request->accepted) {
279	return;
280	}
281
282	if (was_bound = request->bound) {
283	FCGI_UndoBinding(request);
284	}
285	#ifdef USE_SFIO
286	for (i = 0; i < 3; ++i) {
287	if (request->sfcreated[i]) {
288	sfclose(IoIFP(request->io[i]));
289	IoIFP(request->io[i]) = IoOFP(request->io[i]) = Nullfp;
290	request->sfcreated[i] = FALSE;
291	}
292	}
293	#endif
294	if (was_bound)
295	FCGX_Finish_r(request->requestPtr);
296	else
297	FCGX_Free(request->requestPtr);
298	request->accepted = FALSE;
299	}
300
301	static int
302	FCGI_StartFilterData(FCGP_Request* request)
303	{
304	return request->requestPtr->in ?
305	FCGX_StartFilterData(request->requestPtr->in) : -1;
306	}
307
308	static FCGP_Request *
309	FCGI_Request(in, out, err, env, socket, flags)
310	GV* in;
311	GV* out;
312	GV* err;
313	HV* env;
314	int socket;
315	int flags;
316	{
317	FCGX_Request* fcgx_req;
318	FCGP_Request* req;
319
320	Newz(551, fcgx_req, 1, FCGX_Request);
321	FCGX_InitRequest(fcgx_req, socket, flags);
322	Newz(551, req, 1, FCGP_Request);
323	req->requestPtr = fcgx_req;
324	req->gv[0] = in;
325	req->gv[1] = out;
326	req->gv[2] = err;
327	req->hvEnv = env;
328
329	return req;
330	}
331
332	static void
333	FCGI_Release_Request(FCGP_Request *req)
334	{
335	FCGI_Finish(req);
336	Safefree(req->requestPtr);
337	Safefree(req);
338	}
339
340	static void
341	FCGI_Init()
342	{
343	#if defined(USE_LOCKING) && defined(USE_THREADS)
344	dTHX;
345
346	MUTEX_INIT(&accept_mutex);
347	#endif
348
349	FCGX_Init();
350	}
351
352	typedef FCGX_Stream * FCGI__Stream;
353	typedef FCGP_Request * FCGI;
354	typedef GV* GLOBREF;
355	typedef HV* HASHREF;
356
357	MODULE = FCGI PACKAGE = FCGI PREFIX = FCGI_
358
359	BOOT:
360	FCGI_Init();
361
362	SV *
363	RequestX(in, out, err, env, socket, flags)
364	GLOBREF in;
365	GLOBREF out;
366	GLOBREF err;
367	HASHREF env;
368	int socket;
369	int flags;
370
371	PROTOTYPE: ***$$$
372	CODE:
373	RETVAL = sv_setref_pv(newSV(0), "FCGI",
374	FCGI_Request(in, out, err, env, socket, flags));
375
376	OUTPUT:
377	RETVAL
378
379	int
380	OpenSocket(path, backlog)
381	char* path;
382	int backlog;
383
384	PROTOTYPE: $$
385	CODE:
386	RETVAL = FCGX_OpenSocket(path, backlog);
387	OUTPUT:
388	RETVAL
389
390	void
391	CloseSocket(socket)
392	int socket;
393
394	PROTOTYPE: $
395	CODE:
396	close(socket);
397
398	int
399	FCGI_Accept(request)
400
401	FCGI request;
402
403	PROTOTYPE: $
404
405	void
406	FCGI_Finish(request)
407	FCGI request;
408
409	PROTOTYPE: $
410
411	void
412	FCGI_Flush(request)
413	FCGI request;
414
415	PROTOTYPE: $
416
417	HV *
418	GetEnvironment(request)
419	FCGI request;
420
421	PROTOTYPE: $
422
423	CODE:
424	RETVAL = request->hvEnv;
425
426	OUTPUT:
427	RETVAL
428
429	void
430	GetHandles(request)
431	FCGI request;
432
433	PROTOTYPE: $
434
435	PREINIT:
436	int i;
437
438	PPCODE:
439	EXTEND(sp,3);
440	for (i = 0; i < 3; ++i)
441	PUSHs(sv_2mortal(newRV((SV *) request->gv[i])));
442
443	int
444	FCGI_IsFastCGI(request)
445	FCGI request;
446
447	PROTOTYPE: $
448
449	void
450	Detach(request)
451
452	FCGI request;
453
454	PROTOTYPE: $
455
456	CODE:
457	if (request->accepted && request->bound)
458	FCGI_UndoBinding(request);
459
460	void
461	Attach(request)
462
463	FCGI request;
464
465	PROTOTYPE: $
466
467	CODE:
468	if (request->accepted && !request->bound)
469	FCGI_Bind(request);
470
471
472	int
473	FCGI_StartFilterData(request)
474
475	FCGI request;
476
477	PROTOTYPE: $
478
479	void
480	DESTROY(request)
481	FCGI request;
482
483	CODE:
484	FCGI_Release_Request(request);
485
486
487
488	MODULE = FCGI PACKAGE = FCGI::Stream
489
490	#ifndef USE_SFIO
491
492	void
493	PRINT(stream, ...)
494	FCGI::Stream stream;
495
496	PREINIT:
497	int n;
498
499	CODE:
500	for (n = 1; n < items; ++n) {
501	STRLEN len;
502	register char tmps = (char )SvPV(ST(n),len);
503	FCGX_PutStr(tmps, len, stream);
504	}
505	if (SvTRUEx(perl_get_sv("\|", FALSE)))
506	FCGX_FFlush(stream);
507
508	int
509	WRITE(stream, bufsv, len, ...)
510	FCGI::Stream stream;
511	SV * bufsv;
512	int len;
513
514	PREINIT:
515	int offset;
516	char * buf;
517	STRLEN blen;
518	int n;
519
520	CODE:
521	offset = (items == 4) ? (int)SvIV(ST(3)) : 0;
522	buf = SvPV(bufsv, blen);
523	if (offset < 0) offset += blen;
524	if (len > blen - offset)
525	len = blen - offset;
526	if (offset < 0 \|\| offset >= blen \|\|
527	(n = FCGX_PutStr(buf+offset, len, stream)) < 0)
528	ST(0) = &PL_sv_undef;
529	else {
530	ST(0) = sv_newmortal();
531	sv_setpvf(ST(0), "%c", n);
532	}
533
534	int
535	READ(stream, bufsv, len, ...)
536	FCGI::Stream stream;
537	SV * bufsv;
538	int len;
539
540	PREINIT:
541	int offset;
542	char * buf;
543
544	CODE:
545	offset = (items == 4) ? (int)SvIV(ST(3)) : 0;
546	if (! SvOK(bufsv))
547	sv_setpvn(bufsv, "", 0);
548	buf = SvGROW(bufsv, len+offset+1);
549	len = FCGX_GetStr(buf+offset, len, stream);
550	SvCUR_set(bufsv, len+offset);
551	*SvEND(bufsv) = '\0';
552	(void)SvPOK_only(bufsv);
553	SvSETMAGIC(bufsv);
554	RETVAL = len;
555
556	OUTPUT:
557	RETVAL
558
559	SV *
560	GETC(stream)
561	FCGI::Stream stream;
562
563	PREINIT:
564	int retval;
565
566	CODE:
567	if ((retval = FCGX_GetChar(stream)) != -1) {
568	ST(0) = sv_newmortal();
569	sv_setpvf(ST(0), "%c", retval);
570	} else ST(0) = &PL_sv_undef;
571
572	bool
573	CLOSE(stream)
574	FCGI::Stream stream;
575
576	# ALIAS:
577	# DESTROY = 1
578
579	CODE:
580	RETVAL = FCGX_FClose(stream) != -1;
581
582	OUTPUT:
583	RETVAL
584
585	#endif