1 MODULE = APR::Request     PACKAGE = APR::Request
2 
3 SV*
4 encode(in)
5     SV *in
6   PREINIT:
7     STRLEN len;
8     char *src;
9   CODE:
10     src = SvPV(in, len);
11     RETVAL = newSV(3 * len + 1);
12     SvCUR_set(RETVAL, apreq_encode(SvPVX(RETVAL), src, len));
13     SvPOK_on(RETVAL);
14 
15   OUTPUT:
16     RETVAL
17 
18 SV*
19 decode(in)
20     SV *in
21   PREINIT:
22     STRLEN len;
23     apr_size_t dlen;
24     char *src;
25   CODE:
26     src = SvPV(in, len);
27     RETVAL = newSV(len + 1);
28     apreq_decode(SvPVX(RETVAL), &dlen, src, len); /*XXX needs error-handling */
29     SvCUR_set(RETVAL, dlen);
30     SvPOK_on(RETVAL);
31   OUTPUT:
32     RETVAL
33 
34 SV*
35 read_limit(req, val=NULL)
36     APR::Request req
37     SV *val
38   PREINIT:
39     /* nada */
40   CODE:
41     if (items == 1) {
42         apr_status_t s;
43         apr_uint64_t bytes;
44         s = apreq_read_limit_get(req, &bytes);
45         if (s != APR_SUCCESS) {
46             if (!sv_derived_from(ST(0), ERROR_CLASS)) {
47                 SV *obj = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
48                 apreq_xs_croak(aTHX_ newHV(), obj, s,
49                                "APR::Request::read_limit", ERROR_CLASS);
50             }
51             else
52                 RETVAL = &PL_sv_undef;
53         }
54         else {
55             RETVAL = newSVuv(bytes);
56         }
57     }
58     else {
59         apr_status_t s = apreq_read_limit_set(req, SvUV(val));
60         if (s != APR_SUCCESS) {
61             if (GIMME_V == G_VOID && !sv_derived_from(ST(0), ERROR_CLASS)) {
62                 SV *obj = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
63                 apreq_xs_croak(aTHX_ newHV(), obj, s,
64                                "APR::Request::read_limit", ERROR_CLASS);
65             }
66             else
67                 RETVAL = &PL_sv_no;
68         }
69         else {
70             RETVAL = &PL_sv_yes;
71         }
72     }
73 
74   OUTPUT:
75     RETVAL
76 
77 SV*
78 brigade_limit(req, val=NULL)
79     APR::Request req
80     SV *val
81   PREINIT:
82     /* nada */
83   CODE:
84     if (items == 1) {
85         apr_status_t s;
86         apr_size_t bytes;
87         s = apreq_brigade_limit_get(req, &bytes);
88         if (s != APR_SUCCESS) {
89             if (!sv_derived_from(ST(0), ERROR_CLASS)) {
90                 SV *obj = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
91                 apreq_xs_croak(aTHX_ newHV(), obj, s,
92                                "APR::Request::brigade_limit", ERROR_CLASS);
93             }
94             else
95                 RETVAL = &PL_sv_undef;
96         }
97         else {
98             RETVAL = newSVuv(bytes);
99         }
100     }
101     else {
102         apr_status_t s = apreq_brigade_limit_set(req, SvUV(val));
103         if (s != APR_SUCCESS) {
104             if (GIMME_V == G_VOID && !sv_derived_from(ST(0), ERROR_CLASS)) {
105                 SV *obj = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
106                 apreq_xs_croak(aTHX_ newHV(), obj, s,
107                                "APR::Request::brigade_limit", ERROR_CLASS);
108             }
109             else
110                 RETVAL = &PL_sv_no;
111         }
112         else {
113             RETVAL = &PL_sv_yes;
114         }
115     }
116 
117   OUTPUT:
118     RETVAL
119 
120 
121 SV*
122 temp_dir(req, val=NULL)
123     APR::Request req
124     SV *val
125   PREINIT:
126     /* nada */
127   CODE:
128     if (items == 1) {
129         apr_status_t s;
130         const char *path;
131         s = apreq_temp_dir_get(req, &path);
132         if (s != APR_SUCCESS) {
133             if (!sv_derived_from(ST(0), ERROR_CLASS)) {
134                 SV *obj = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
135                 apreq_xs_croak(aTHX_ newHV(), obj, s,
136                                "APR::Request::temp_dir", ERROR_CLASS);
137             }
138             else
139                 RETVAL = &PL_sv_undef;
140         }
141         else {
142             RETVAL = (path == NULL) ? &PL_sv_undef : newSVpv(path, 0);
143         }
144     }
145     else {
146         apr_status_t s = apreq_temp_dir_set(req, SvPV_nolen(val));
147         if (s != APR_SUCCESS) {
148             if (GIMME_V == G_VOID && !sv_derived_from(ST(0), ERROR_CLASS)) {
149                 SV *obj = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
150                 apreq_xs_croak(aTHX_ newHV(), obj, s,
151                                "APR::Request::temp_dir", ERROR_CLASS);
152             }
153             else
154                 RETVAL = &PL_sv_no;
155         }
156         else {
157             RETVAL = &PL_sv_yes;
158         }
159     }
160 
161   OUTPUT:
162     RETVAL
163 
164 SV*
165 jar_status(req)
166     APR::Request req
167   PREINIT:
168     const apr_table_t *t;
169 
170   CODE:
171     RETVAL = apreq_xs_error2sv(aTHX_ apreq_jar(req, &t));
172 
173   OUTPUT:
174     RETVAL
175 
176 SV*
177 args_status(req)
178     APR::Request req
179   PREINIT:
180     const apr_table_t *t;
181 
182   CODE:
183     RETVAL = apreq_xs_error2sv(aTHX_ apreq_args(req, &t));
184 
185   OUTPUT:
186     RETVAL
187 
188 SV*
189 body_status(req)
190     APR::Request req
191   PREINIT:
192     const apr_table_t *t;
193 
194   CODE:
195     RETVAL = apreq_xs_error2sv(aTHX_ apreq_body(req, &t));
196 
197   OUTPUT:
198     RETVAL
199 
200 SV*
201 disable_uploads(req)
202     APR::Request req
203   PREINIT:
204     apreq_hook_t *h;
205     apr_status_t s;
206   CODE:
207     h = apreq_hook_make(req->pool, apreq_hook_disable_uploads, NULL, NULL);
208     s = apreq_hook_add(req, h);
209     RETVAL = apreq_xs_error2sv(aTHX_ s);
210 
211   OUTPUT:
212     RETVAL
213 
214 void
215 upload_hook(obj, sub)
216     SV *obj
217     SV *sub
218   PREINIT:
219     struct hook_ctx *ctx;
220     IV iv;
221     apreq_handle_t *req;
222   CODE:
223     obj = apreq_xs_sv2object(aTHX_ obj, "APR::Request", 'r');
224     iv = SvIVX(obj);
225     req = INT2PTR(apreq_handle_t *, iv);
226     ctx = apr_palloc(req->pool, sizeof *ctx);
227     ctx->hook = newSVsv(sub);
228     ctx->bucket_data = newSV(8000);
229     ctx->parent = SvREFCNT_inc(obj);
230     SvTAINTED_on(ctx->bucket_data);
231 #ifdef USE_ITHREADS
232     ctx->perl = aTHX;
233 #endif
234 
235     apreq_hook_add(req, apreq_hook_make(req->pool, apreq_xs_upload_hook, NULL, ctx));
236     apr_pool_cleanup_register(req->pool, ctx, upload_hook_cleanup, NULL);
237 
238 
239 APR::Pool
240 pool(req)
241     APR::Request req
242   CODE:
243     RETVAL = req->pool;
244    OUTPUT:
245     RETVAL
246 
247 
248 APR::BucketAlloc
249 bucket_alloc(req)
250     APR::Request req
251   CODE:
252     RETVAL = req->bucket_alloc;
253   OUTPUT:
254     RETVAL
255 
256 MODULE = APR::Request::Param    PACKAGE = APR::Request::Param::Table
257 
258 SV *
259 uploads(t, pool)
260     APR::Request::Param::Table t
261     APR::Pool pool
262   PREINIT:
263     SV *obj = apreq_xs_sv2object(aTHX_ ST(0), PARAM_TABLE_CLASS, 't');
264     SV *parent = apreq_xs_sv2object(aTHX_ ST(0), HANDLE_CLASS, 'r');
265     MAGIC *mg = mg_find(obj, PERL_MAGIC_ext);
266   CODE:
267     RETVAL = apreq_xs_param_table2sv(aTHX_ apreq_uploads(t, pool),
268                                      HvNAME(SvSTASH(obj)),
269                                      parent, mg->mg_ptr, mg->mg_len);
270   OUTPUT:
271     RETVAL
272 
273 
274 MODULE = APR::Request::Param PACKAGE = APR::Request::Param::Table
275 
276 SV *
277 param_class(t, subclass=&PL_sv_undef)
278     APR::Request::Param::Table t
279     SV *subclass
280 
281   PREINIT:
282     SV *obj = apreq_xs_sv2object(aTHX_ ST(0), PARAM_TABLE_CLASS, 't');
283     MAGIC *mg = mg_find(obj, PERL_MAGIC_ext);
284     char *curclass = mg->mg_ptr;
285 
286   CODE:
287 
288     if (items == 2) {
289         if (!SvOK(subclass)) {
290             mg->mg_ptr = NULL;
291             mg->mg_len = 0;
292         }
293         else if (!sv_derived_from(subclass, PARAM_CLASS)) {
294             Perl_croak(aTHX_ "Usage: "
295                               PARAM_TABLE_CLASS "::param_class($table, $class): "
296                              "class %s is not derived from " PARAM_CLASS,
297                               SvPV_nolen(subclass));
298         }
299         else {
300             STRLEN len;
301             mg->mg_ptr = savepv(SvPV(subclass, len));
302             mg->mg_len = len;
303 
304         }
305         if (curclass != NULL)
306             Safefree(curclass);
307 
308         XSRETURN(1);
309     }
310 
311     RETVAL = (curclass == NULL) ? &PL_sv_undef : newSVpv(curclass, 0);
312 
313   OUTPUT:
314     RETVAL
315 
316 
317 MODULE = APR::Request::Cookie PACKAGE = APR::Request::Cookie::Table
318 
319 SV *
320 cookie_class(t, subclass=&PL_sv_undef)
321     APR::Request::Cookie::Table t
322     SV *subclass
323 
324   PREINIT:
325     SV *obj = apreq_xs_sv2object(aTHX_ ST(0), COOKIE_TABLE_CLASS, 't');
326     MAGIC *mg = mg_find(obj, PERL_MAGIC_ext);
327     char *curclass = mg->mg_ptr;
328 
329   CODE:
330 
331     if (items == 2) {
332         if (!SvOK(subclass)) {
333             mg->mg_ptr = NULL;
334             mg->mg_len = 0;
335         }
336         else if (!sv_derived_from(subclass, COOKIE_CLASS)) {
337             Perl_croak(aTHX_ "Usage: "
338                              COOKIE_TABLE_CLASS "::cookie_class($table, $class): "
339                              "class %s is not derived from " COOKIE_CLASS,
340                              SvPV_nolen(subclass));
341         }
342         else {
343             STRLEN len;
344             mg->mg_ptr = savepv(SvPV(subclass, len));
345             mg->mg_len = len;
346         }
347         if (curclass != NULL)
348             Safefree(curclass);
349 
350         XSRETURN(1);
351     }
352 
353     RETVAL = (curclass == NULL) ? &PL_sv_undef : newSVpv(curclass, 0);
354 
355   OUTPUT:
356     RETVAL
357 
358 
359 MODULE = APR::Request  PACKAGE = APR::Request::Custom
360 
361 APR::Request
362 handle(class, pool, query_string, cookie, parser, read_limit, in)
363     apreq_xs_subclass_t class
364     APR::Pool pool
365     char *query_string
366     char *cookie
367     APR::Request::Parser parser
368     UV read_limit
369     APR::Brigade in
370   PREINIT:
371     SV *parent = SvRV(ST(1));
372   CODE:
373     RETVAL = apreq_handle_custom(pool, query_string, cookie,
374                                  parser, read_limit, in);
375   OUTPUT:
376     RETVAL
377 
378 
379 BOOT:
380     {
381         apr_version_t version;
382         apr_version(&version);
383         if (version.major != APR_MAJOR_VERSION)
384             Perl_croak(aTHX_ "Can't load module APR::Request : "
385                              "wrong libapr major version "
386                              "(expected %d, saw %d)",
387                               APR_MAJOR_VERSION, version.major);
388     }
389