projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
silly mistake
[m6w6/ext-http] / http_request_object.c
1 /*
2 +--------------------------------------------------------------------+
3 | PECL :: http |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2004-2010, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 /* $Id$ */
14
15 #define HTTP_WANT_CURL
16 #include "php_http.h"
17
18 #if defined(ZEND_ENGINE_2) && defined(HTTP_HAVE_CURL)
19
20 #include "zend_interfaces.h"
21
22 #include "php_http_api.h"
23 #include "php_http_cookie_api.h"
24 #include "php_http_exception_object.h"
25 #include "php_http_message_api.h"
26 #include "php_http_message_object.h"
27 #include "php_http_request_api.h"
28 #include "php_http_request_object.h"
29 #include "php_http_request_pool_api.h"
30 #include "php_http_url_api.h"
31
32 #define HTTP_BEGIN_ARGS(method, req_args) HTTP_BEGIN_ARGS_EX(HttpRequest, method, 0, req_args)
33 #define HTTP_EMPTY_ARGS(method) HTTP_EMPTY_ARGS_EX(HttpRequest, method, 0)
34 #define HTTP_REQUEST_ME(method, visibility) PHP_ME(HttpRequest, method, HTTP_ARGS(HttpRequest, method), visibility)
35 #define HTTP_REQUEST_ALIAS(method, func) HTTP_STATIC_ME_ALIAS(method, func, HTTP_ARGS(HttpRequest, method))
36 #define HTTP_REQUEST_MALIAS(me, al, vis) ZEND_FENTRY(me, ZEND_MN(HttpRequest_##al), HTTP_ARGS(HttpRequest, al), vis)
37
38 HTTP_BEGIN_ARGS(__construct, 0)
39 HTTP_ARG_VAL(url, 0)
40 HTTP_ARG_VAL(method, 0)
41 HTTP_ARG_VAL(options, 0)
42 HTTP_END_ARGS;
43
44 HTTP_BEGIN_ARGS(factory, 0)
45 HTTP_ARG_VAL(url, 0)
46 HTTP_ARG_VAL(method, 0)
47 HTTP_ARG_VAL(options, 0)
48 HTTP_ARG_VAL(class_name, 0)
49 HTTP_END_ARGS;
50
51 HTTP_EMPTY_ARGS(getOptions);
52 HTTP_BEGIN_ARGS(setOptions, 0)
53 HTTP_ARG_VAL(options, 0)
54 HTTP_END_ARGS;
55
56 HTTP_EMPTY_ARGS(getSslOptions);
57 HTTP_BEGIN_ARGS(setSslOptions, 0)
58 HTTP_ARG_VAL(ssl_options, 0)
59 HTTP_END_ARGS;
60
61 HTTP_BEGIN_ARGS(addSslOptions, 0)
62 HTTP_ARG_VAL(ssl_optins, 0)
63 HTTP_END_ARGS;
64
65 HTTP_EMPTY_ARGS(getHeaders);
66 HTTP_BEGIN_ARGS(setHeaders, 0)
67 HTTP_ARG_VAL(headers, 0)
68 HTTP_END_ARGS;
69
70 HTTP_BEGIN_ARGS(addHeaders, 1)
71 HTTP_ARG_VAL(headers, 0)
72 HTTP_END_ARGS;
73
74 HTTP_EMPTY_ARGS(getCookies);
75 HTTP_BEGIN_ARGS(setCookies, 0)
76 HTTP_ARG_VAL(cookies, 0)
77 HTTP_END_ARGS;
78
79 HTTP_BEGIN_ARGS(addCookies, 1)
80 HTTP_ARG_VAL(cookies, 0)
81 HTTP_END_ARGS;
82
83 HTTP_EMPTY_ARGS(enableCookies);
84 HTTP_BEGIN_ARGS(resetCookies, 0)
85 HTTP_ARG_VAL(session_only, 0)
86 HTTP_END_ARGS;
87 HTTP_EMPTY_ARGS(flushCookies);
88
89 HTTP_EMPTY_ARGS(getUrl);
90 HTTP_BEGIN_ARGS(setUrl, 1)
91 HTTP_ARG_VAL(url, 0)
92 HTTP_END_ARGS;
93
94 HTTP_EMPTY_ARGS(getMethod);
95 HTTP_BEGIN_ARGS(setMethod, 1)
96 HTTP_ARG_VAL(request_method, 0)
97 HTTP_END_ARGS;
98
99 HTTP_EMPTY_ARGS(getContentType);
100 HTTP_BEGIN_ARGS(setContentType, 1)
101 HTTP_ARG_VAL(content_type, 0)
102 HTTP_END_ARGS;
103
104 HTTP_EMPTY_ARGS(getQueryData);
105 HTTP_BEGIN_ARGS(setQueryData, 0)
106 HTTP_ARG_VAL(query_data, 0)
107 HTTP_END_ARGS;
108
109 HTTP_BEGIN_ARGS(addQueryData, 1)
110 HTTP_ARG_VAL(query_data, 0)
111 HTTP_END_ARGS;
112
113 HTTP_EMPTY_ARGS(getPostFields);
114 HTTP_BEGIN_ARGS(setPostFields, 0)
115 HTTP_ARG_VAL(post_fields, 0)
116 HTTP_END_ARGS;
117
118 HTTP_BEGIN_ARGS(addPostFields, 1)
119 HTTP_ARG_VAL(post_fields, 0)
120 HTTP_END_ARGS;
121
122 HTTP_EMPTY_ARGS(getPostFiles);
123 HTTP_BEGIN_ARGS(setPostFiles, 0)
124 HTTP_ARG_VAL(post_files, 0)
125 HTTP_END_ARGS;
126
127 HTTP_BEGIN_ARGS(addPostFile, 2)
128 HTTP_ARG_VAL(formname, 0)
129 HTTP_ARG_VAL(filename, 0)
130 HTTP_ARG_VAL(content_type, 0)
131 HTTP_END_ARGS;
132
133 HTTP_EMPTY_ARGS(getBody);
134 HTTP_BEGIN_ARGS(setBody, 0)
135 HTTP_ARG_VAL(request_body_data, 0)
136 HTTP_END_ARGS;
137
138 HTTP_BEGIN_ARGS(addBody, 1)
139 HTTP_ARG_VAL(request_body_data, 0)
140 HTTP_END_ARGS;
141
142 HTTP_EMPTY_ARGS(getPutFile);
143 HTTP_BEGIN_ARGS(setPutFile, 0)
144 HTTP_ARG_VAL(filename, 0)
145 HTTP_END_ARGS;
146
147 HTTP_EMPTY_ARGS(getPutData);
148 HTTP_BEGIN_ARGS(setPutData, 0)
149 HTTP_ARG_VAL(put_data, 0)
150 HTTP_END_ARGS;
151
152 HTTP_BEGIN_ARGS(addPutData, 1)
153 HTTP_ARG_VAL(put_data, 0)
154 HTTP_END_ARGS;
155
156 HTTP_EMPTY_ARGS(getResponseData);
157 HTTP_BEGIN_ARGS(getResponseHeader, 0)
158 HTTP_ARG_VAL(name, 0)
159 HTTP_END_ARGS;
160
161 HTTP_BEGIN_ARGS(getResponseCookies, 0)
162 HTTP_ARG_VAL(flags, 0)
163 HTTP_ARG_VAL(allowed_extras, 0)
164 HTTP_END_ARGS;
165
166 HTTP_EMPTY_ARGS(getResponseBody);
167 HTTP_EMPTY_ARGS(getResponseCode);
168 HTTP_EMPTY_ARGS(getResponseStatus);
169 HTTP_BEGIN_ARGS(getResponseInfo, 0)
170 HTTP_ARG_VAL(name, 0)
171 HTTP_END_ARGS;
172
173 HTTP_EMPTY_ARGS(getMessageClass);
174 HTTP_BEGIN_ARGS(setMessageClass, 1)
175 HTTP_ARG_VAL(message_class_name, 0)
176 HTTP_END_ARGS;
177
178 HTTP_EMPTY_ARGS(getResponseMessage);
179 HTTP_EMPTY_ARGS(getRawResponseMessage);
180 HTTP_EMPTY_ARGS(getRequestMessage);
181 HTTP_EMPTY_ARGS(getRawRequestMessage);
182 HTTP_EMPTY_ARGS(getHistory);
183 HTTP_EMPTY_ARGS(clearHistory);
184 HTTP_EMPTY_ARGS(send);
185
186 HTTP_BEGIN_ARGS(get, 1)
187 HTTP_ARG_VAL(url, 0)
188 HTTP_ARG_VAL(options, 0)
189 HTTP_ARG_VAL(info, 1)
190 HTTP_END_ARGS;
191
192 HTTP_BEGIN_ARGS(head, 1)
193 HTTP_ARG_VAL(url, 0)
194 HTTP_ARG_VAL(options, 0)
195 HTTP_ARG_VAL(info, 1)
196 HTTP_END_ARGS;
197
198 HTTP_BEGIN_ARGS(postData, 2)
199 HTTP_ARG_VAL(url, 0)
200 HTTP_ARG_VAL(data, 0)
201 HTTP_ARG_VAL(options, 0)
202 HTTP_ARG_VAL(info, 1)
203 HTTP_END_ARGS;
204
205 HTTP_BEGIN_ARGS(postFields, 2)
206 HTTP_ARG_VAL(url, 0)
207 HTTP_ARG_VAL(data, 0)
208 HTTP_ARG_VAL(options, 0)
209 HTTP_ARG_VAL(info, 1)
210 HTTP_END_ARGS;
211
212 HTTP_BEGIN_ARGS(putData, 2)
213 HTTP_ARG_VAL(url, 0)
214 HTTP_ARG_VAL(data, 0)
215 HTTP_ARG_VAL(options, 0)
216 HTTP_ARG_VAL(info, 1)
217 HTTP_END_ARGS;
218
219 HTTP_BEGIN_ARGS(putFile, 2)
220 HTTP_ARG_VAL(url, 0)
221 HTTP_ARG_VAL(file, 0)
222 HTTP_ARG_VAL(options, 0)
223 HTTP_ARG_VAL(info, 1)
224 HTTP_END_ARGS;
225
226 HTTP_BEGIN_ARGS(putStream, 2)
227 HTTP_ARG_VAL(url, 0)
228 HTTP_ARG_VAL(stream, 0)
229 HTTP_ARG_VAL(options, 0)
230 HTTP_ARG_VAL(info, 1)
231 HTTP_END_ARGS;
232
233 HTTP_BEGIN_ARGS(methodRegister, 1)
234 HTTP_ARG_VAL(method_name, 0)
235 HTTP_END_ARGS;
236
237 HTTP_BEGIN_ARGS(methodUnregister, 1)
238 HTTP_ARG_VAL(method, 0)
239 HTTP_END_ARGS;
240
241 HTTP_BEGIN_ARGS(methodName, 1)
242 HTTP_ARG_VAL(method_id, 0)
243 HTTP_END_ARGS;
244
245 HTTP_BEGIN_ARGS(methodExists, 1)
246 HTTP_ARG_VAL(method, 0)
247 HTTP_END_ARGS;
248
249 #ifdef HAVE_CURL_FORMGET
250 HTTP_BEGIN_ARGS(encodeBody, 2)
251 HTTP_ARG_VAL(fields, 0)
252 HTTP_ARG_VAL(files, 0)
253 HTTP_END_ARGS;
254 #endif
255
256 #define THIS_CE http_request_object_ce
257 zend_class_entry *http_request_object_ce;
258 zend_function_entry http_request_object_fe[] = {
259 HTTP_REQUEST_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
260
261 HTTP_REQUEST_ME(setOptions, ZEND_ACC_PUBLIC)
262 HTTP_REQUEST_ME(getOptions, ZEND_ACC_PUBLIC)
263 HTTP_REQUEST_ME(setSslOptions, ZEND_ACC_PUBLIC)
264 HTTP_REQUEST_ME(getSslOptions, ZEND_ACC_PUBLIC)
265 HTTP_REQUEST_ME(addSslOptions, ZEND_ACC_PUBLIC)
266
267 HTTP_REQUEST_ME(addHeaders, ZEND_ACC_PUBLIC)
268 HTTP_REQUEST_ME(getHeaders, ZEND_ACC_PUBLIC)
269 HTTP_REQUEST_ME(setHeaders, ZEND_ACC_PUBLIC)
270
271 HTTP_REQUEST_ME(addCookies, ZEND_ACC_PUBLIC)
272 HTTP_REQUEST_ME(getCookies, ZEND_ACC_PUBLIC)
273 HTTP_REQUEST_ME(setCookies, ZEND_ACC_PUBLIC)
274
275 HTTP_REQUEST_ME(enableCookies, ZEND_ACC_PUBLIC)
276 HTTP_REQUEST_ME(resetCookies, ZEND_ACC_PUBLIC)
277 HTTP_REQUEST_ME(flushCookies, ZEND_ACC_PUBLIC)
278
279 HTTP_REQUEST_ME(setMethod, ZEND_ACC_PUBLIC)
280 HTTP_REQUEST_ME(getMethod, ZEND_ACC_PUBLIC)
281
282 HTTP_REQUEST_ME(setUrl, ZEND_ACC_PUBLIC)
283 HTTP_REQUEST_ME(getUrl, ZEND_ACC_PUBLIC)
284
285 HTTP_REQUEST_ME(setContentType, ZEND_ACC_PUBLIC)
286 HTTP_REQUEST_ME(getContentType, ZEND_ACC_PUBLIC)
287
288 HTTP_REQUEST_ME(setQueryData, ZEND_ACC_PUBLIC)
289 HTTP_REQUEST_ME(getQueryData, ZEND_ACC_PUBLIC)
290 HTTP_REQUEST_ME(addQueryData, ZEND_ACC_PUBLIC)
291
292 HTTP_REQUEST_ME(setPostFields, ZEND_ACC_PUBLIC)
293 HTTP_REQUEST_ME(getPostFields, ZEND_ACC_PUBLIC)
294 HTTP_REQUEST_ME(addPostFields, ZEND_ACC_PUBLIC)
295
296 HTTP_REQUEST_ME(setBody, ZEND_ACC_PUBLIC)
297 HTTP_REQUEST_ME(getBody, ZEND_ACC_PUBLIC)
298 HTTP_REQUEST_ME(addBody, ZEND_ACC_PUBLIC)
299 HTTP_REQUEST_MALIAS(setRawPostData, setBody, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
300 HTTP_REQUEST_MALIAS(getRawPostData, getBody, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
301 HTTP_REQUEST_MALIAS(addRawPostData, addBody, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
302
303 HTTP_REQUEST_ME(setPostFiles, ZEND_ACC_PUBLIC)
304 HTTP_REQUEST_ME(addPostFile, ZEND_ACC_PUBLIC)
305 HTTP_REQUEST_ME(getPostFiles, ZEND_ACC_PUBLIC)
306
307 HTTP_REQUEST_ME(setPutFile, ZEND_ACC_PUBLIC)
308 HTTP_REQUEST_ME(getPutFile, ZEND_ACC_PUBLIC)
309
310 HTTP_REQUEST_ME(setPutData, ZEND_ACC_PUBLIC)
311 HTTP_REQUEST_ME(getPutData, ZEND_ACC_PUBLIC)
312 HTTP_REQUEST_ME(addPutData, ZEND_ACC_PUBLIC)
313
314 HTTP_REQUEST_ME(send, ZEND_ACC_PUBLIC)
315
316 HTTP_REQUEST_ME(getResponseData, ZEND_ACC_PUBLIC)
317 HTTP_REQUEST_ME(getResponseHeader, ZEND_ACC_PUBLIC)
318 HTTP_REQUEST_ME(getResponseCookies, ZEND_ACC_PUBLIC)
319 HTTP_REQUEST_ME(getResponseCode, ZEND_ACC_PUBLIC)
320 HTTP_REQUEST_ME(getResponseStatus, ZEND_ACC_PUBLIC)
321 HTTP_REQUEST_ME(getResponseBody, ZEND_ACC_PUBLIC)
322 HTTP_REQUEST_ME(getResponseInfo, ZEND_ACC_PUBLIC)
323 HTTP_REQUEST_ME(getResponseMessage, ZEND_ACC_PUBLIC)
324 HTTP_REQUEST_ME(getRawResponseMessage, ZEND_ACC_PUBLIC)
325 HTTP_REQUEST_ME(getRequestMessage, ZEND_ACC_PUBLIC)
326 HTTP_REQUEST_ME(getRawRequestMessage, ZEND_ACC_PUBLIC)
327 HTTP_REQUEST_ME(getHistory, ZEND_ACC_PUBLIC)
328 HTTP_REQUEST_ME(clearHistory, ZEND_ACC_PUBLIC)
329
330 HTTP_REQUEST_ME(getMessageClass, ZEND_ACC_PUBLIC)
331 HTTP_REQUEST_ME(setMessageClass, ZEND_ACC_PUBLIC)
332
333 HTTP_REQUEST_ME(factory, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
334
335 HTTP_REQUEST_ALIAS(get, http_get)
336 HTTP_REQUEST_ALIAS(head, http_head)
337 HTTP_REQUEST_ALIAS(postData, http_post_data)
338 HTTP_REQUEST_ALIAS(postFields, http_post_fields)
339 HTTP_REQUEST_ALIAS(putData, http_put_data)
340 HTTP_REQUEST_ALIAS(putFile, http_put_file)
341 HTTP_REQUEST_ALIAS(putStream, http_put_stream)
342
343 HTTP_REQUEST_ALIAS(methodRegister, http_request_method_register)
344 HTTP_REQUEST_ALIAS(methodUnregister, http_request_method_unregister)
345 HTTP_REQUEST_ALIAS(methodName, http_request_method_name)
346 HTTP_REQUEST_ALIAS(methodExists, http_request_method_exists)
347 #ifdef HAVE_CURL_FORMGET
348 HTTP_REQUEST_ALIAS(encodeBody, http_request_body_encode)
349 #endif
350 EMPTY_FUNCTION_ENTRY
351 };
352 static zend_object_handlers http_request_object_handlers;
353
354 PHP_MINIT_FUNCTION(http_request_object)
355 {
356 HTTP_REGISTER_CLASS_EX(HttpRequest, http_request_object, NULL, 0);
357 http_request_object_handlers.clone_obj = _http_request_object_clone_obj;
358
359 zend_declare_property_null(THIS_CE, ZEND_STRS("options")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
360 zend_declare_property_null(THIS_CE, ZEND_STRS("postFields")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
361 zend_declare_property_null(THIS_CE, ZEND_STRS("postFiles")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
362 zend_declare_property_null(THIS_CE, ZEND_STRS("responseInfo")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
363 zend_declare_property_null(THIS_CE, ZEND_STRS("responseMessage")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
364 zend_declare_property_long(THIS_CE, ZEND_STRS("responseCode")-1, 0, ZEND_ACC_PRIVATE TSRMLS_CC);
365 zend_declare_property_string(THIS_CE, ZEND_STRS("responseStatus")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
366 zend_declare_property_long(THIS_CE, ZEND_STRS("method")-1, HTTP_GET, ZEND_ACC_PRIVATE TSRMLS_CC);
367 zend_declare_property_string(THIS_CE, ZEND_STRS("url")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
368 zend_declare_property_string(THIS_CE, ZEND_STRS("contentType")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
369 zend_declare_property_string(THIS_CE, ZEND_STRS("requestBody")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
370 zend_declare_property_string(THIS_CE, ZEND_STRS("queryData")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
371 zend_declare_property_string(THIS_CE, ZEND_STRS("putFile")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
372 zend_declare_property_string(THIS_CE, ZEND_STRS("putData")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
373 zend_declare_property_null(THIS_CE, ZEND_STRS("history")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
374 zend_declare_property_bool(THIS_CE, ZEND_STRS("recordHistory")-1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
375 zend_declare_property_string(THIS_CE, ZEND_STRS("messageClass")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
376
377 #ifndef WONKY
378 /*
379 * Request Method Constants
380 */
381 /* HTTP/1.1 */
382 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_GET")-1, HTTP_GET TSRMLS_CC);
383 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_HEAD")-1, HTTP_HEAD TSRMLS_CC);
384 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_POST")-1, HTTP_POST TSRMLS_CC);
385 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_PUT")-1, HTTP_PUT TSRMLS_CC);
386 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_DELETE")-1, HTTP_DELETE TSRMLS_CC);
387 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_OPTIONS")-1, HTTP_OPTIONS TSRMLS_CC);
388 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_TRACE")-1, HTTP_TRACE TSRMLS_CC);
389 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_CONNECT")-1, HTTP_CONNECT TSRMLS_CC);
390 /* WebDAV - RFC 2518 */
391 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_PROPFIND")-1, HTTP_PROPFIND TSRMLS_CC);
392 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_PROPPATCH")-1, HTTP_PROPPATCH TSRMLS_CC);
393 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MKCOL")-1, HTTP_MKCOL TSRMLS_CC);
394 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_COPY")-1, HTTP_COPY TSRMLS_CC);
395 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MOVE")-1, HTTP_MOVE TSRMLS_CC);
396 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_LOCK")-1, HTTP_LOCK TSRMLS_CC);
397 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_UNLOCK")-1, HTTP_UNLOCK TSRMLS_CC);
398 /* WebDAV Versioning - RFC 3253 */
399 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_VERSION_CONTROL")-1, HTTP_VERSION_CONTROL TSRMLS_CC);
400 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_REPORT")-1, HTTP_REPORT TSRMLS_CC);
401 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_CHECKOUT")-1, HTTP_CHECKOUT TSRMLS_CC);
402 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_CHECKIN")-1, HTTP_CHECKIN TSRMLS_CC);
403 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_UNCHECKOUT")-1, HTTP_UNCHECKOUT TSRMLS_CC);
404 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MKWORKSPACE")-1, HTTP_MKWORKSPACE TSRMLS_CC);
405 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_UPDATE")-1, HTTP_UPDATE TSRMLS_CC);
406 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_LABEL")-1, HTTP_LABEL TSRMLS_CC);
407 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MERGE")-1, HTTP_MERGE TSRMLS_CC);
408 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_BASELINE_CONTROL")-1, HTTP_BASELINE_CONTROL TSRMLS_CC);
409 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MKACTIVITY")-1, HTTP_MKACTIVITY TSRMLS_CC);
410 /* WebDAV Access Control - RFC 3744 */
411 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_ACL")-1, HTTP_ACL TSRMLS_CC);
412
413 /*
414 * HTTP Protocol Version Constants
415 */
416 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_1_0")-1, CURL_HTTP_VERSION_1_0 TSRMLS_CC);
417 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_1_1")-1, CURL_HTTP_VERSION_1_1 TSRMLS_CC);
418 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_NONE")-1, CURL_HTTP_VERSION_NONE TSRMLS_CC); /* to be removed */
419 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_ANY")-1, CURL_HTTP_VERSION_NONE TSRMLS_CC);
420
421 /*
422 * SSL Version Constants
423 */
424 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_TLSv1")-1, CURL_SSLVERSION_TLSv1 TSRMLS_CC);
425 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_SSLv2")-1, CURL_SSLVERSION_SSLv2 TSRMLS_CC);
426 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_SSLv3")-1, CURL_SSLVERSION_SSLv3 TSRMLS_CC);
427 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_ANY")-1, CURL_SSLVERSION_DEFAULT TSRMLS_CC);
428
429 /*
430 * DNS IPvX resolving
431 */
432 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("IPRESOLVE_V4")-1, CURL_IPRESOLVE_V4 TSRMLS_CC);
433 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("IPRESOLVE_V6")-1, CURL_IPRESOLVE_V6 TSRMLS_CC);
434 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("IPRESOLVE_ANY")-1, CURL_IPRESOLVE_WHATEVER TSRMLS_CC);
435
436 /*
437 * Auth Constants
438 */
439 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_BASIC")-1, CURLAUTH_BASIC TSRMLS_CC);
440 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_DIGEST")-1, CURLAUTH_DIGEST TSRMLS_CC);
441 #if HTTP_CURL_VERSION(7,19,3)
442 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_DIGEST_IE")-1, CURLAUTH_DIGEST_IE TSRMLS_CC);
443 #endif
444 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_NTLM")-1, CURLAUTH_NTLM TSRMLS_CC);
445 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_GSSNEG")-1, CURLAUTH_GSSNEGOTIATE TSRMLS_CC);
446 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_ANY")-1, CURLAUTH_ANY TSRMLS_CC);
447
448 /*
449 * Proxy Type Constants
450 */
451 # if HTTP_CURL_VERSION(7,15,2)
452 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS4")-1, CURLPROXY_SOCKS4 TSRMLS_CC);
453 # endif
454 #if HTTP_CURL_VERSION(7,18,0)
455 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS4A")-1, CURLPROXY_SOCKS5 TSRMLS_CC);
456 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS5_HOSTNAME")-1, CURLPROXY_SOCKS5 TSRMLS_CC);
457 #endif
458 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS5")-1, CURLPROXY_SOCKS5 TSRMLS_CC);
459 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_HTTP")-1, CURLPROXY_HTTP TSRMLS_CC);
460 # if HTTP_CURL_VERSION(7,19,4)
461 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_HTTP_1_0")-1, CURLPROXY_HTTP_1_0 TSRMLS_CC);
462 # endif
463 #endif /* WONKY */
464
465 /*
466 * Post Redirection Constants
467 */
468 #if HTTP_CURL_VERSION(7,19,1)
469 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("POSTREDIR_301")-1, CURL_REDIR_POST_301 TSRMLS_CC);
470 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("POSTREDIR_302")-1, CURL_REDIR_POST_302 TSRMLS_CC);
471 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("POSTREDIR_ALL")-1, CURL_REDIR_POST_ALL TSRMLS_CC);
472 #endif
473
474 return SUCCESS;
475 }
476
477 zend_object_value _http_request_object_new(zend_class_entry *ce TSRMLS_DC)
478 {
479 return http_request_object_new_ex(ce, NULL, NULL);
480 }
481
482 zend_object_value _http_request_object_new_ex(zend_class_entry *ce, CURL *ch, http_request_object **ptr TSRMLS_DC)
483 {
484 zend_object_value ov;
485 http_request_object *o;
486
487 o = ecalloc(1, sizeof(http_request_object));
488 o->zo.ce = ce;
489 o->request = http_request_init_ex(NULL, ch, 0, NULL);
490
491 if (ptr) {
492 *ptr = o;
493 }
494
495 ALLOC_HASHTABLE(OBJ_PROP(o));
496 zend_hash_init(OBJ_PROP(o), zend_hash_num_elements(&ce->default_properties), NULL, ZVAL_PTR_DTOR, 0);
497 zend_hash_copy(OBJ_PROP(o), &ce->default_properties, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
498
499 ov.handle = putObject(http_request_object, o);
500 ov.handlers = &http_request_object_handlers;
501
502 return ov;
503 }
504
505 zend_object_value _http_request_object_clone_obj(zval *this_ptr TSRMLS_DC)
506 {
507 zend_object_value new_ov;
508 http_request_object *new_obj;
509 getObject(http_request_object, old_obj);
510
511 new_ov = http_request_object_new_ex(old_obj->zo.ce, NULL, &new_obj);
512 if (old_obj->request->ch) {
513 http_curl_init_ex(http_curl_copy(old_obj->request->ch), new_obj->request);
514 }
515
516 zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
517 phpstr_append(&new_obj->request->conv.request, old_obj->request->conv.request.data, old_obj->request->conv.request.used);
518 phpstr_append(&new_obj->request->conv.response, old_obj->request->conv.response.data, old_obj->request->conv.response.used);
519
520 return new_ov;
521 }
522
523 void _http_request_object_free(zend_object *object TSRMLS_DC)
524 {
525 http_request_object *o = (http_request_object *) object;
526
527 http_request_free(&o->request);
528 freeObject(o);
529 }
530
531 #define http_request_object_check_request_content_type(t) _http_request_object_check_request_content_type((t) TSRMLS_CC)
532 static inline void _http_request_object_check_request_content_type(zval *this_ptr TSRMLS_DC)
533 {
534 zval *ctype = zend_read_property(THIS_CE, getThis(), ZEND_STRS("contentType")-1, 0 TSRMLS_CC);
535
536 if (Z_STRLEN_P(ctype)) {
537 zval **headers, *opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
538
539 if ( (Z_TYPE_P(opts) == IS_ARRAY) &&
540 (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "headers", sizeof("headers"), (void *) &headers)) &&
541 (Z_TYPE_PP(headers) == IS_ARRAY)) {
542 zval **ct_header;
543
544 /* only override if not already set */
545 if ((SUCCESS != zend_hash_find(Z_ARRVAL_PP(headers), "Content-Type", sizeof("Content-Type"), (void *) &ct_header))) {
546 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
547 } else
548 /* or not a string, zero length string or a string of spaces */
549 if ((Z_TYPE_PP(ct_header) != IS_STRING) || !Z_STRLEN_PP(ct_header)) {
550 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
551 } else {
552 int i, only_space = 1;
553
554 /* check for spaces only */
555 for (i = 0; i < Z_STRLEN_PP(ct_header); ++i) {
556 if (!HTTP_IS_CTYPE(space, Z_STRVAL_PP(ct_header)[i])) {
557 only_space = 0;
558 break;
559 }
560 }
561 if (only_space) {
562 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
563 }
564 }
565 } else {
566 zval *headers;
567
568 MAKE_STD_ZVAL(headers);
569 array_init(headers);
570 add_assoc_stringl(headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
571 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addheaders", NULL, headers);
572 zval_ptr_dtor(&headers);
573 }
574 }
575 }
576
577 #define http_request_object_message(zo, msg) _http_request_object_message((zo), (msg) TSRMLS_CC)
578 static inline zend_object_value _http_request_object_message(zval *this_ptr, http_message *msg TSRMLS_DC)
579 {
580 zend_object_value ov;
581 zval *zcn = zend_read_property(THIS_CE, getThis(), ZEND_STRS("messageClass")-1, 0 TSRMLS_CC);
582
583 if (Z_STRLEN_P(zcn) && (SUCCESS == http_object_new(&ov, Z_STRVAL_P(zcn), Z_STRLEN_P(zcn), _http_message_object_new_ex, http_message_object_ce, msg, NULL))) {
584 return ov;
585 } else {
586 return http_message_object_new_ex(http_message_object_ce, msg, NULL);
587 }
588 }
589
590 STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_ptr TSRMLS_DC)
591 {
592 STATUS status = SUCCESS;
593 char *url = http_absolute_url(Z_STRVAL_P(zend_read_property(THIS_CE, getThis(), ZEND_STRS("url")-1, 0 TSRMLS_CC)));
594
595 if (!url) {
596 return FAILURE;
597 }
598
599 http_request_reset(obj->request);
600 obj->request->url = url;
601 HTTP_CHECK_CURL_INIT(obj->request->ch, http_curl_init(obj->request), return FAILURE);
602
603 switch (obj->request->meth = Z_LVAL_P(zend_read_property(THIS_CE, getThis(), ZEND_STRS("method")-1, 0 TSRMLS_CC)))
604 {
605 case HTTP_GET:
606 case HTTP_HEAD:
607 break;
608
609 case HTTP_PUT:
610 {
611 zval *put_file = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putFile")-1, 0 TSRMLS_CC);
612
613 http_request_object_check_request_content_type(getThis());
614
615 if (Z_STRLEN_P(put_file)) {
616 php_stream_statbuf ssb;
617 php_stream *stream = php_stream_open_wrapper_ex(Z_STRVAL_P(put_file), "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL, HTTP_DEFAULT_STREAM_CONTEXT);
618
619 if (stream && SUCCESS == php_stream_stat(stream, &ssb)) {
620 obj->request->body = http_request_body_init_ex(obj->request->body, HTTP_REQUEST_BODY_UPLOADFILE, stream, ssb.sb.st_size, 1);
621 } else {
622 status = FAILURE;
623 }
624 } else {
625 zval *put_data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putData")-1, 0 TSRMLS_CC);
626 obj->request->body = http_request_body_init_ex(obj->request->body, HTTP_REQUEST_BODY_CSTRING,
627 estrndup(Z_STRVAL_P(put_data), Z_STRLEN_P(put_data)), Z_STRLEN_P(put_data), 1);
628 }
629 break;
630 }
631
632 case HTTP_POST:
633 default:
634 {
635 /* check for raw request body */
636 zval *raw_data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, 0 TSRMLS_CC);
637
638 if (Z_STRLEN_P(raw_data)) {
639 http_request_object_check_request_content_type(getThis());
640 obj->request->body = http_request_body_init_ex(obj->request->body, HTTP_REQUEST_BODY_CSTRING,
641 estrndup(Z_STRVAL_P(raw_data), Z_STRLEN_P(raw_data)), Z_STRLEN_P(raw_data), 1);
642 } else {
643 zval *zfields = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, 0 TSRMLS_CC), *zfiles = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, 0 TSRMLS_CC);
644 HashTable *fields;
645 HashTable *files;
646
647 fields = (Z_TYPE_P(zfields) == IS_ARRAY) ? Z_ARRVAL_P(zfields) : NULL;
648 files = (Z_TYPE_P(zfiles) == IS_ARRAY) ? Z_ARRVAL_P(zfiles) : NULL;
649
650 if ((fields && zend_hash_num_elements(fields)) || (files && zend_hash_num_elements(files))) {
651 if (!(obj->request->body = http_request_body_fill(obj->request->body, fields, files))) {
652 status = FAILURE;
653 }
654 }
655 }
656 break;
657 }
658 }
659
660 if (status == SUCCESS) {
661 zval *qdata = zend_read_property(THIS_CE, getThis(), ZEND_STRS("queryData")-1, 0 TSRMLS_CC);
662 zval *options = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
663
664 if (Z_STRLEN_P(qdata)) {
665 if (!strchr(obj->request->url, '?')) {
666 strlcat(obj->request->url, "?", HTTP_URL_MAXLEN);
667 } else {
668 strlcat(obj->request->url, "&", HTTP_URL_MAXLEN);
669 }
670 strlcat(obj->request->url, Z_STRVAL_P(qdata), HTTP_URL_MAXLEN);
671 }
672
673 http_request_prepare(obj->request, Z_ARRVAL_P(options));
674
675 /* check if there's a onProgress method and add it as progress callback if one isn't already set */
676 if (zend_hash_exists(&Z_OBJCE_P(getThis())->function_table, "onprogress", sizeof("onprogress"))) {
677 zval **entry, *pcb;
678
679 if ( (Z_TYPE_P(options) != IS_ARRAY)
680 || (SUCCESS != zend_hash_find(Z_ARRVAL_P(options), "onprogress", sizeof("onprogress"), (void *) &entry)
681 || (!IS_CALLABLE(*entry, 0, NULL)))) {
682 MAKE_STD_ZVAL(pcb);
683 array_init(pcb);
684 ZVAL_ADDREF(getThis());
685 add_next_index_zval(pcb, getThis());
686 add_next_index_stringl(pcb, "onprogress", lenof("onprogress"), 1);
687 http_request_set_progress_callback(obj->request, pcb);
688 zval_ptr_dtor(&pcb);
689 }
690 }
691 }
692
693 return status;
694 }
695
696 STATUS _http_request_object_responsehandler(http_request_object *obj, zval *this_ptr TSRMLS_DC)
697 {
698 STATUS ret;
699 zval *info;
700 http_message *msg;
701
702 /* always fetch info */
703 MAKE_STD_ZVAL(info);
704 array_init(info);
705 http_request_info(obj->request, Z_ARRVAL_P(info));
706 zend_update_property(THIS_CE, getThis(), ZEND_STRS("responseInfo")-1, info TSRMLS_CC);
707 zval_ptr_dtor(&info);
708
709 /* parse response message */
710 phpstr_fix(&obj->request->conv.request);
711 phpstr_fix(&obj->request->conv.response);
712
713 if ((msg = http_message_parse(PHPSTR_VAL(&obj->request->conv.response), PHPSTR_LEN(&obj->request->conv.response)))) {
714 zval *message;
715
716 if (i_zend_is_true(zend_read_property(THIS_CE, getThis(), ZEND_STRS("recordHistory")-1, 0 TSRMLS_CC))) {
717 zval *hist, *history = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
718 http_message *response = http_message_parse(PHPSTR_VAL(&obj->request->conv.response), PHPSTR_LEN(&obj->request->conv.response));
719 http_message *request = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request));
720
721 MAKE_STD_ZVAL(hist);
722 ZVAL_OBJVAL(hist, http_request_object_message(getThis(), http_message_interconnect(response, request)), 0);
723 if (Z_TYPE_P(history) == IS_OBJECT) {
724 http_message_object_prepend(hist, history);
725 }
726 zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
727 zval_ptr_dtor(&hist);
728 }
729
730 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("responseCode")-1, msg->http.info.response.code TSRMLS_CC);
731 zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("responseStatus")-1, STR_PTR(msg->http.info.response.status) TSRMLS_CC);
732
733 MAKE_STD_ZVAL(message);
734 ZVAL_OBJVAL(message, http_request_object_message(getThis(), msg), 0);
735 zend_update_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, message TSRMLS_CC);
736 zval_ptr_dtor(&message);
737
738 ret = SUCCESS;
739 } else {
740 /* update properties with empty values*/
741 zval *znull;
742
743 MAKE_STD_ZVAL(znull);
744 ZVAL_NULL(znull);
745 zend_update_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, znull TSRMLS_CC);
746 zval_ptr_dtor(&znull);
747
748 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("responseCode")-1, 0 TSRMLS_CC);
749 zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("responseStatus")-1, "" TSRMLS_CC);
750
751 /* append request message to history */
752 if (i_zend_is_true(zend_read_property(THIS_CE, getThis(), ZEND_STRS("recordHistory")-1, 0 TSRMLS_CC))) {
753 http_message *request;
754
755 if ((request = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request)))) {
756 zval *hist, *history = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
757
758 MAKE_STD_ZVAL(hist);
759 ZVAL_OBJVAL(hist, http_request_object_message(getThis(), request), 0);
760 if (Z_TYPE_P(history) == IS_OBJECT) {
761 http_message_object_prepend(hist, history);
762 }
763 zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
764 zval_ptr_dtor(&hist);
765 }
766 }
767
768 ret = FAILURE;
769 }
770
771 http_request_set_progress_callback(obj->request, NULL);
772
773 if (!EG(exception) && zend_hash_exists(&Z_OBJCE_P(getThis())->function_table, "onfinish", sizeof("onfinish"))) {
774 zval *param;
775
776 MAKE_STD_ZVAL(param);
777 ZVAL_BOOL(param, ret == SUCCESS);
778 with_error_handling(EH_NORMAL, NULL) {
779 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "onfinish", NULL, param);
780 } end_error_handling();
781 zval_ptr_dtor(&param);
782 }
783
784 return ret;
785 }
786
787 static int apply_pretty_key(void *pDest, int num_args, va_list args, zend_hash_key *hash_key)
788 {
789 if (hash_key->arKey && hash_key->nKeyLength > 1) {
790 hash_key->h = zend_hash_func(pretty_key(hash_key->arKey, hash_key->nKeyLength - 1, 1, 0), hash_key->nKeyLength);
791 }
792 return ZEND_HASH_APPLY_KEEP;
793 }
794
795 #define http_request_object_set_options_subr(key, ow, pk) \
796 _http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, (key), sizeof(key), (ow), (pk))
797 static inline void _http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAMETERS, char *key, size_t len, int overwrite, int prettify_keys)
798 {
799 zval *old_opts, *new_opts, *opts = NULL, **entry = NULL;
800
801 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a/!", &opts)) {
802 RETURN_FALSE;
803 }
804
805 MAKE_STD_ZVAL(new_opts);
806 array_init(new_opts);
807 old_opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
808 if (Z_TYPE_P(old_opts) == IS_ARRAY) {
809 array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL_P(new_opts));
810 }
811
812 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(new_opts), key, len, (void *) &entry)) {
813 if (overwrite) {
814 zend_hash_clean(Z_ARRVAL_PP(entry));
815 }
816 if (opts && zend_hash_num_elements(Z_ARRVAL_P(opts))) {
817 if (overwrite) {
818 array_copy(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry));
819 } else {
820 array_join(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry), 0, prettify_keys ? ARRAY_JOIN_PRETTIFY : 0);
821 }
822 }
823 } else if (opts) {
824 if (prettify_keys) {
825 zend_hash_apply_with_arguments(Z_ARRVAL_P(opts) HTTP_ZAPI_HASH_TSRMLS_CC, apply_pretty_key, 0, NULL);
826 }
827 ZVAL_ADDREF(opts);
828 add_assoc_zval_ex(new_opts, key, len, opts);
829 }
830 zend_update_property(THIS_CE, getThis(), ZEND_STRS("options")-1, new_opts TSRMLS_CC);
831 zval_ptr_dtor(&new_opts);
832
833 RETURN_TRUE;
834 }
835
836 #define http_request_object_get_options_subr(key) \
837 _http_request_get_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, (key), sizeof(key))
838 static inline void _http_request_get_options_subr(INTERNAL_FUNCTION_PARAMETERS, char *key, size_t len)
839 {
840 NO_ARGS;
841
842 if (return_value_used) {
843 zval *opts, **options;
844
845 opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
846 array_init(return_value);
847
848 if ( (Z_TYPE_P(opts) == IS_ARRAY) &&
849 (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), key, len, (void *) &options))) {
850 convert_to_array(*options);
851 array_copy(Z_ARRVAL_PP(options), Z_ARRVAL_P(return_value));
852 }
853 }
854 }
855
856
857 /* ### USERLAND ### */
858
859 /* {{{ proto void HttpRequest::__construct([string url[, int request_method = HTTP_METH_GET[, array options]]])
860 Create a new HttpRequest object instance. */
861 PHP_METHOD(HttpRequest, __construct)
862 {
863 char *URL = NULL;
864 int URL_len;
865 long meth = -1;
866 zval *options = NULL;
867
868 SET_EH_THROW_HTTP();
869 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sla!", &URL, &URL_len, &meth, &options)) {
870 if (URL) {
871 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("url")-1, URL, URL_len TSRMLS_CC);
872 }
873 if (meth > -1) {
874 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
875 }
876 if (options) {
877 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setoptions", NULL, options);
878 }
879 }
880 SET_EH_NORMAL();
881 }
882 /* }}} */
883
884 /* {{{ proto HttpRequest HttpRequest::factory([string url[, int request_method HTTP_METH_GET[, array options[, string class_name = "HttpRequest"]]]])
885 Create a new HttpRequest object instance. */
886 PHP_METHOD(HttpRequest, factory)
887 {
888 char *cn = NULL, *URL = NULL;
889 int cl = 0, URL_len = 0;
890 long meth = -1;
891 zval *options = NULL;
892 zend_object_value ov;
893
894 SET_EH_THROW_HTTP();
895 if ( SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sla!s", &URL, &URL_len, &meth, &options, &cn, &cl) &&
896 SUCCESS == http_object_new(&ov, cn, cl, _http_request_object_new_ex, http_request_object_ce, NULL, NULL)) {
897 RETVAL_OBJVAL(ov, 0);
898 getThis() = return_value;
899 if (URL) {
900 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("url")-1, URL, URL_len TSRMLS_CC);
901 }
902 if (meth > -1) {
903 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
904 }
905 if (options) {
906 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setoptions", NULL, options);
907 }
908 }
909 SET_EH_NORMAL();
910 }
911 /* }}} */
912
913 /* {{{ proto bool HttpRequest::setOptions([array options])
914 Set the request options to use. See http_get() for a full list of available options. */
915 PHP_METHOD(HttpRequest, setOptions)
916 {
917 HashKey key = initHashKey(0);
918 HashPosition pos;
919 zval *opts = NULL, *old_opts, *new_opts, *add_opts, **opt;
920
921 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts)) {
922 RETURN_FALSE;
923 }
924
925 MAKE_STD_ZVAL(new_opts);
926 array_init(new_opts);
927
928 if (!opts || !zend_hash_num_elements(Z_ARRVAL_P(opts))) {
929 zend_update_property(THIS_CE, getThis(), ZEND_STRS("options")-1, new_opts TSRMLS_CC);
930 zval_ptr_dtor(&new_opts);
931 RETURN_TRUE;
932 }
933
934 MAKE_STD_ZVAL(add_opts);
935 array_init(add_opts);
936 /* some options need extra attention -- thus cannot use array_merge() directly */
937 FOREACH_KEYVAL(pos, opts, key, opt) {
938 if (key.type == HASH_KEY_IS_STRING) {
939 #define KEYMATCH(k, s) ((sizeof(s)==k.len) && !strcasecmp(k.str, s))
940 if (KEYMATCH(key, "headers")) {
941 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addheaders", NULL, *opt);
942 } else if (KEYMATCH(key, "cookies")) {
943 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addcookies", NULL, *opt);
944 } else if (KEYMATCH(key, "ssl")) {
945 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addssloptions", NULL, *opt);
946 } else if (KEYMATCH(key, "url") || KEYMATCH(key, "uri")) {
947 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "seturl", NULL, *opt);
948 } else if (KEYMATCH(key, "method")) {
949 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setmethod", NULL, *opt);
950 } else if (KEYMATCH(key, "flushcookies")) {
951 getObject(http_request_object, obj);
952 if (i_zend_is_true(*opt)) {
953 http_request_flush_cookies(obj->request);
954 }
955 } else if (KEYMATCH(key, "resetcookies")) {
956 getObject(http_request_object, obj);
957 http_request_reset_cookies(obj->request, (zend_bool) i_zend_is_true(*opt));
958 } else if (KEYMATCH(key, "enablecookies")) {
959 getObject(http_request_object, obj);
960 http_request_enable_cookies(obj->request);
961 } else if (KEYMATCH(key, "recordHistory")) {
962 zend_update_property(THIS_CE, getThis(), ZEND_STRS("recordHistory")-1, *opt TSRMLS_CC);
963 } else if (KEYMATCH(key, "messageClass")) {
964 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setmessageclass", NULL, *opt);
965 } else if (Z_TYPE_PP(opt) == IS_NULL) {
966 old_opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
967 if (Z_TYPE_P(old_opts) == IS_ARRAY) {
968 zend_hash_del(Z_ARRVAL_P(old_opts), key.str, key.len);
969 }
970 } else {
971 ZVAL_ADDREF(*opt);
972 add_assoc_zval_ex(add_opts, key.str, key.len, *opt);
973 }
974 }
975 }
976
977 old_opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
978 if (Z_TYPE_P(old_opts) == IS_ARRAY) {
979 array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL_P(new_opts));
980 }
981 array_join(Z_ARRVAL_P(add_opts), Z_ARRVAL_P(new_opts), 0, 0);
982 zend_update_property(THIS_CE, getThis(), ZEND_STRS("options")-1, new_opts TSRMLS_CC);
983 zval_ptr_dtor(&new_opts);
984 zval_ptr_dtor(&add_opts);
985
986 RETURN_TRUE;
987 }
988 /* }}} */
989
990 /* {{{ proto array HttpRequest::getOptions()
991 Get currently set options. */
992 PHP_METHOD(HttpRequest, getOptions)
993 {
994 NO_ARGS;
995
996 if (return_value_used) {
997 RETURN_PROP(options);
998 }
999 }
1000 /* }}} */
1001
1002 /* {{{ proto bool HttpRequest::setSslOptions([array options])
1003 Set SSL options. */
1004 PHP_METHOD(HttpRequest, setSslOptions)
1005 {
1006 http_request_object_set_options_subr("ssl", 1, 0);
1007 }
1008 /* }}} */
1009
1010 /* {{{ proto bool HttpRequest::addSslOptions(array options)
1011 Set additional SSL options. */
1012 PHP_METHOD(HttpRequest, addSslOptions)
1013 {
1014 http_request_object_set_options_subr("ssl", 0, 0);
1015 }
1016 /* }}} */
1017
1018 /* {{{ proto array HttpRequest::getSslOtpions()
1019 Get previously set SSL options. */
1020 PHP_METHOD(HttpRequest, getSslOptions)
1021 {
1022 http_request_object_get_options_subr("ssl");
1023 }
1024 /* }}} */
1025
1026 /* {{{ proto bool HttpRequest::addHeaders(array headers)
1027 Add request header name/value pairs. */
1028 PHP_METHOD(HttpRequest, addHeaders)
1029 {
1030 http_request_object_set_options_subr("headers", 0, 1);
1031 }
1032
1033 /* {{{ proto bool HttpRequest::setHeaders([array headers])
1034 Set request header name/value pairs. */
1035 PHP_METHOD(HttpRequest, setHeaders)
1036 {
1037 http_request_object_set_options_subr("headers", 1, 1);
1038 }
1039 /* }}} */
1040
1041 /* {{{ proto array HttpRequest::getHeaders()
1042 Get previously set request headers. */
1043 PHP_METHOD(HttpRequest, getHeaders)
1044 {
1045 http_request_object_get_options_subr("headers");
1046 }
1047 /* }}} */
1048
1049 /* {{{ proto bool HttpRequest::setCookies([array cookies])
1050 Set cookies. */
1051 PHP_METHOD(HttpRequest, setCookies)
1052 {
1053 http_request_object_set_options_subr("cookies", 1, 0);
1054 }
1055 /* }}} */
1056
1057 /* {{{ proto bool HttpRequest::addCookies(array cookies)
1058 Add cookies. */
1059 PHP_METHOD(HttpRequest, addCookies)
1060 {
1061 http_request_object_set_options_subr("cookies", 0, 0);
1062 }
1063 /* }}} */
1064
1065 /* {{{ proto array HttpRequest::getCookies()
1066 Get previously set cookies. */
1067 PHP_METHOD(HttpRequest, getCookies)
1068 {
1069 http_request_object_get_options_subr("cookies");
1070 }
1071 /* }}} */
1072
1073 /* {{{ proto bool HttpRequest::enableCookies()
1074 Enable automatic sending of received cookies. Note that customly set cookies will be sent anyway. */
1075 PHP_METHOD(HttpRequest, enableCookies)
1076 {
1077 NO_ARGS {
1078 getObject(http_request_object, obj);
1079 RETURN_SUCCESS(http_request_enable_cookies(obj->request));
1080 }
1081
1082 }
1083 /* }}} */
1084
1085 /* {{{ proto bool HttpRequest::resetCookies([bool session_only = FALSE])
1086 Reset all automatically received/sent cookies. Note that customly set cookies are not affected. */
1087 PHP_METHOD(HttpRequest, resetCookies)
1088 {
1089 zend_bool session_only = 0;
1090 getObject(http_request_object, obj);
1091
1092 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &session_only)) {
1093 RETURN_FALSE;
1094 }
1095 RETURN_SUCCESS(http_request_reset_cookies(obj->request, session_only));
1096 }
1097 /* }}} */
1098
1099 /* {{{ proto bool HttpRequest::flushCookies()
1100 Flush internal cookies to the cookiestore file */
1101 PHP_METHOD(HttpRequest, flushCookies)
1102 {
1103 NO_ARGS {
1104 getObject(http_request_object, obj);
1105 RETURN_SUCCESS(http_request_flush_cookies(obj->request));
1106 }
1107 }
1108 /* }}} */
1109
1110 /* {{{ proto bool HttpRequest::setUrl(string url)
1111 Set the request URL. */
1112 PHP_METHOD(HttpRequest, setUrl)
1113 {
1114 char *URL = NULL;
1115 int URL_len;
1116
1117 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &URL, &URL_len)) {
1118 RETURN_FALSE;
1119 }
1120
1121 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("url")-1, URL, URL_len TSRMLS_CC);
1122 RETURN_TRUE;
1123 }
1124 /* }}} */
1125
1126 /* {{{ proto string HttpRequest::getUrl()
1127 Get the previously set request URL. */
1128 PHP_METHOD(HttpRequest, getUrl)
1129 {
1130 NO_ARGS;
1131
1132 if (return_value_used) {
1133 RETURN_PROP(url);
1134 }
1135 }
1136 /* }}} */
1137
1138 /* {{{ proto bool HttpRequest::setMethod(int request_method)
1139 Set the request method. */
1140 PHP_METHOD(HttpRequest, setMethod)
1141 {
1142 long meth;
1143
1144 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &meth)) {
1145 RETURN_FALSE;
1146 }
1147
1148 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
1149 RETURN_TRUE;
1150 }
1151 /* }}} */
1152
1153 /* {{{ proto int HttpRequest::getMethod()
1154 Get the previously set request method. */
1155 PHP_METHOD(HttpRequest, getMethod)
1156 {
1157 NO_ARGS;
1158
1159 if (return_value_used) {
1160 RETURN_PROP(method);
1161 }
1162 }
1163 /* }}} */
1164
1165 /* {{{ proto bool HttpRequest::setContentType(string content_type)
1166 Set the content type the post request should have. */
1167 PHP_METHOD(HttpRequest, setContentType)
1168 {
1169 char *ctype;
1170 int ct_len;
1171
1172 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ct_len)) {
1173 RETURN_FALSE;
1174 }
1175
1176 if (ct_len) {
1177 HTTP_CHECK_CONTENT_TYPE(ctype, RETURN_FALSE);
1178 }
1179 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("contentType")-1, ctype, ct_len TSRMLS_CC);
1180 RETURN_TRUE;
1181 }
1182 /* }}} */
1183
1184 /* {{{ proto string HttpRequest::getContentType()
1185 Get the previously content type. */
1186 PHP_METHOD(HttpRequest, getContentType)
1187 {
1188 NO_ARGS;
1189
1190 if (return_value_used) {
1191 RETURN_PROP(contentType);
1192 }
1193 }
1194 /* }}} */
1195
1196 /* {{{ proto bool HttpRequest::setQueryData([mixed query_data])
1197 Set the URL query parameters to use, overwriting previously set query parameters. */
1198 PHP_METHOD(HttpRequest, setQueryData)
1199 {
1200 zval *qdata = NULL;
1201
1202 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!", &qdata)) {
1203 RETURN_FALSE;
1204 }
1205
1206 if ((!qdata) || Z_TYPE_P(qdata) == IS_NULL) {
1207 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, "", 0 TSRMLS_CC);
1208 } else if ((Z_TYPE_P(qdata) == IS_ARRAY) || (Z_TYPE_P(qdata) == IS_OBJECT)) {
1209 char *query_data = NULL;
1210
1211 if (SUCCESS != http_urlencode_hash(HASH_OF(qdata), &query_data)) {
1212 RETURN_FALSE;
1213 }
1214
1215 zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("queryData")-1, query_data TSRMLS_CC);
1216 efree(query_data);
1217 } else {
1218 zval *data = http_zsep(IS_STRING, qdata);
1219
1220 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, Z_STRVAL_P(data), Z_STRLEN_P(data) TSRMLS_CC);
1221 zval_ptr_dtor(&data);
1222 }
1223 RETURN_TRUE;
1224 }
1225 /* }}} */
1226
1227 /* {{{ proto string HttpRequest::getQueryData()
1228 Get the current query data in form of an urlencoded query string. */
1229 PHP_METHOD(HttpRequest, getQueryData)
1230 {
1231 NO_ARGS;
1232
1233 if (return_value_used) {
1234 RETURN_PROP(queryData);
1235 }
1236 }
1237 /* }}} */
1238
1239 /* {{{ proto bool HttpRequest::addQueryData(array query_params)
1240 Add parameters to the query parameter list, leaving previously set unchanged. */
1241 PHP_METHOD(HttpRequest, addQueryData)
1242 {
1243 zval *qdata, *old_qdata;
1244 char *query_data = NULL;
1245 size_t query_data_len = 0;
1246
1247 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &qdata)) {
1248 RETURN_FALSE;
1249 }
1250
1251 old_qdata = zend_read_property(THIS_CE, getThis(), ZEND_STRS("queryData")-1, 0 TSRMLS_CC);
1252
1253 if (SUCCESS != http_urlencode_hash_ex(HASH_OF(qdata), 1, Z_STRVAL_P(old_qdata), Z_STRLEN_P(old_qdata), &query_data, &query_data_len)) {
1254 RETURN_FALSE;
1255 }
1256
1257 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, query_data, query_data_len TSRMLS_CC);
1258 efree(query_data);
1259
1260 RETURN_TRUE;
1261 }
1262 /* }}} */
1263
1264 /* {{{ proto bool HttpRequest::addPostFields(array post_data)
1265 Adds POST data entries, leaving previously set unchanged, unless a post entry with the same name already exists. */
1266 PHP_METHOD(HttpRequest, addPostFields)
1267 {
1268 zval *post_data, *old_post, *new_post;
1269
1270 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &post_data)) {
1271 RETURN_FALSE;
1272 }
1273
1274 if (zend_hash_num_elements(Z_ARRVAL_P(post_data))) {
1275 MAKE_STD_ZVAL(new_post);
1276 array_init(new_post);
1277 old_post = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, 0 TSRMLS_CC);
1278 if (Z_TYPE_P(old_post) == IS_ARRAY) {
1279 array_copy(Z_ARRVAL_P(old_post), Z_ARRVAL_P(new_post));
1280 }
1281 array_join(Z_ARRVAL_P(post_data), Z_ARRVAL_P(new_post), 0, 0);
1282 zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, new_post TSRMLS_CC);
1283 zval_ptr_dtor(&new_post);
1284 }
1285
1286 RETURN_TRUE;
1287 }
1288 /* }}} */
1289
1290 /* {{{ proto bool HttpRequest::setPostFields([array post_data])
1291 Set the POST data entries, overwriting previously set POST data. */
1292 PHP_METHOD(HttpRequest, setPostFields)
1293 {
1294 zval *post, *post_data = NULL;
1295
1296 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &post_data)) {
1297 RETURN_FALSE;
1298 }
1299
1300 MAKE_STD_ZVAL(post);
1301 array_init(post);
1302 if (post_data && zend_hash_num_elements(Z_ARRVAL_P(post_data))) {
1303 array_copy(Z_ARRVAL_P(post_data), Z_ARRVAL_P(post));
1304 }
1305 zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, post TSRMLS_CC);
1306 zval_ptr_dtor(&post);
1307
1308 RETURN_TRUE;
1309 }
1310 /* }}}*/
1311
1312 /* {{{ proto array HttpRequest::getPostFields()
1313 Get previously set POST data. */
1314 PHP_METHOD(HttpRequest, getPostFields)
1315 {
1316 NO_ARGS;
1317
1318 if (return_value_used) {
1319 RETURN_PROP(postFields);
1320 }
1321 }
1322 /* }}} */
1323
1324 /* {{{ proto bool HttpRequest::setBody([string request_body_data])
1325 Set request body to send, overwriting previously set request body. Don't forget to specify a content type. */
1326 PHP_METHOD(HttpRequest, setBody)
1327 {
1328 char *raw_data = NULL;
1329 int data_len = 0;
1330
1331 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &raw_data, &data_len)) {
1332 RETURN_FALSE;
1333 }
1334
1335 if (!raw_data) {
1336 raw_data = "";
1337 }
1338
1339 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, raw_data, data_len TSRMLS_CC);
1340 RETURN_TRUE;
1341 }
1342 /* }}} */
1343
1344 /* {{{ proto bool HttpRequest::addBody(string request_body_data)
1345 Add request body data, leaving previously set request body data unchanged. */
1346 PHP_METHOD(HttpRequest, addBody)
1347 {
1348 char *raw_data;
1349 int data_len;
1350
1351 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &raw_data, &data_len)) {
1352 RETURN_FALSE;
1353 }
1354
1355 if (data_len) {
1356 zval *data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, 0 TSRMLS_CC);
1357
1358 if (Z_STRLEN_P(data)) {
1359 Z_STRVAL_P(data) = erealloc(Z_STRVAL_P(data), (Z_STRLEN_P(data) += data_len) + 1);
1360 Z_STRVAL_P(data)[Z_STRLEN_P(data)] = '\0';
1361 memcpy(Z_STRVAL_P(data) + Z_STRLEN_P(data) - data_len, raw_data, data_len);
1362 } else {
1363 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, raw_data, data_len TSRMLS_CC);
1364 }
1365 }
1366
1367 RETURN_TRUE;
1368 }
1369 /* }}} */
1370
1371 /* {{{ proto string HttpRequest::getBody()
1372 Get previously set request body data. */
1373 PHP_METHOD(HttpRequest, getBody)
1374 {
1375 NO_ARGS;
1376
1377 if (return_value_used) {
1378 RETURN_PROP(requestBody);
1379 }
1380 }
1381 /* }}} */
1382
1383 /* {{{ proto bool HttpRequest::addPostFile(string name, string file[, string content_type = "application/x-octetstream"])
1384 Add a file to the POST request, leaving previously set files unchanged. */
1385 PHP_METHOD(HttpRequest, addPostFile)
1386 {
1387 zval *entry, *old_post, *new_post;
1388 char *name, *file, *type = NULL;
1389 int name_len, file_len, type_len = 0;
1390
1391 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &name, &name_len, &file, &file_len, &type, &type_len)) {
1392 RETURN_FALSE;
1393 }
1394
1395 if (type_len) {
1396 HTTP_CHECK_CONTENT_TYPE(type, RETURN_FALSE);
1397 } else {
1398 type = "application/x-octetstream";
1399 type_len = sizeof("application/x-octetstream") - 1;
1400 }
1401
1402 MAKE_STD_ZVAL(entry);
1403 array_init(entry);
1404
1405 add_assoc_stringl(entry, "name", name, name_len, 1);
1406 add_assoc_stringl(entry, "type", type, type_len, 1);
1407 add_assoc_stringl(entry, "file", file, file_len, 1);
1408
1409 MAKE_STD_ZVAL(new_post);
1410 array_init(new_post);
1411 old_post = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, 0 TSRMLS_CC);
1412 if (Z_TYPE_P(old_post) == IS_ARRAY) {
1413 array_copy(Z_ARRVAL_P(old_post), Z_ARRVAL_P(new_post));
1414 }
1415 add_next_index_zval(new_post, entry);
1416 zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, new_post TSRMLS_CC);
1417 zval_ptr_dtor(&new_post);
1418
1419 RETURN_TRUE;
1420 }
1421 /* }}} */
1422
1423 /* {{{ proto bool HttpRequest::setPostFiles([array post_files])
1424 Set files to post, overwriting previously set post files. */
1425 PHP_METHOD(HttpRequest, setPostFiles)
1426 {
1427 zval *files = NULL, *post;
1428
1429 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!/", &files)) {
1430 RETURN_FALSE;
1431 }
1432
1433 MAKE_STD_ZVAL(post);
1434 array_init(post);
1435 if (files && (Z_TYPE_P(files) == IS_ARRAY)) {
1436 array_copy(Z_ARRVAL_P(files), Z_ARRVAL_P(post));
1437 }
1438 zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, post TSRMLS_CC);
1439 zval_ptr_dtor(&post);
1440
1441 RETURN_TRUE;
1442 }
1443 /* }}} */
1444
1445 /* {{{ proto array HttpRequest::getPostFiles()
1446 Get all previously added POST files. */
1447 PHP_METHOD(HttpRequest, getPostFiles)
1448 {
1449 NO_ARGS;
1450
1451 if (return_value_used) {
1452 RETURN_PROP(postFiles);
1453 }
1454 }
1455 /* }}} */
1456
1457 /* {{{ proto bool HttpRequest::setPutFile([string file])
1458 Set file to put. Affects only PUT requests. */
1459 PHP_METHOD(HttpRequest, setPutFile)
1460 {
1461 char *file = "";
1462 int file_len = 0;
1463
1464 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &file, &file_len)) {
1465 RETURN_FALSE;
1466 }
1467
1468 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putFile")-1, file, file_len TSRMLS_CC);
1469 RETURN_TRUE;
1470 }
1471 /* }}} */
1472
1473 /* {{{ proto string HttpRequest::getPutFile()
1474 Get previously set put file. */
1475 PHP_METHOD(HttpRequest, getPutFile)
1476 {
1477 NO_ARGS;
1478
1479 if (return_value_used) {
1480 RETURN_PROP(putFile);
1481 }
1482 }
1483 /* }}} */
1484
1485 /* {{{ proto bool HttpRequest::setPutData([string put_data])
1486 Set PUT data to send, overwriting previously set PUT data. */
1487 PHP_METHOD(HttpRequest, setPutData)
1488 {
1489 char *put_data = NULL;
1490 int data_len = 0;
1491
1492 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &put_data, &data_len)) {
1493 RETURN_FALSE;
1494 }
1495
1496 if (!put_data) {
1497 put_data = "";
1498 }
1499
1500 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putData")-1, put_data, data_len TSRMLS_CC);
1501 RETURN_TRUE;
1502 }
1503 /* }}} */
1504
1505 /* {{{ proto bool HttpRequest::addPutData(string put_data)
1506 Add PUT data, leaving previously set PUT data unchanged. */
1507 PHP_METHOD(HttpRequest, addPutData)
1508 {
1509 char *put_data;
1510 int data_len;
1511
1512 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &put_data, &data_len)) {
1513 RETURN_FALSE;
1514 }
1515
1516 if (data_len) {
1517 zval *data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putData")-1, 0 TSRMLS_CC);
1518
1519 if (Z_STRLEN_P(data)) {
1520 Z_STRVAL_P(data) = erealloc(Z_STRVAL_P(data), (Z_STRLEN_P(data) += data_len) + 1);
1521 Z_STRVAL_P(data)[Z_STRLEN_P(data)] = '\0';
1522 memcpy(Z_STRVAL_P(data) + Z_STRLEN_P(data) - data_len, put_data, data_len);
1523 } else {
1524 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putData")-1, put_data, data_len TSRMLS_CC);
1525 }
1526 }
1527
1528 RETURN_TRUE;
1529 }
1530 /* }}} */
1531
1532 /* {{{ proto string HttpRequest::getPutData()
1533 Get previously set PUT data. */
1534 PHP_METHOD(HttpRequest, getPutData)
1535 {
1536 NO_ARGS;
1537
1538 if (return_value_used) {
1539 RETURN_PROP(putData);
1540 }
1541 }
1542 /* }}} */
1543
1544 /* {{{ proto array HttpRequest::getResponseData()
1545 Get all response data after the request has been sent. */
1546 PHP_METHOD(HttpRequest, getResponseData)
1547 {
1548 NO_ARGS;
1549
1550 if (return_value_used) {
1551 char *body;
1552 size_t body_len;
1553 zval *headers, *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1554
1555 if (Z_TYPE_P(message) == IS_OBJECT) {
1556 getObjectEx(http_message_object, msg, message);
1557
1558 array_init(return_value);
1559
1560 MAKE_STD_ZVAL(headers);
1561 array_init(headers);
1562 zend_hash_copy(Z_ARRVAL_P(headers), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1563 add_assoc_zval(return_value, "headers", headers);
1564
1565 phpstr_data(PHPSTR(msg->message), &body, &body_len);
1566 add_assoc_stringl(return_value, "body", body, body_len, 0);
1567 }
1568 }
1569 }
1570 /* }}} */
1571
1572 /* {{{ proto mixed HttpRequest::getResponseHeader([string name])
1573 Get response header(s) after the request has been sent. */
1574 PHP_METHOD(HttpRequest, getResponseHeader)
1575 {
1576 if (return_value_used) {
1577 zval *header;
1578 char *header_name = NULL;
1579 int header_len = 0;
1580
1581 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &header_name, &header_len)) {
1582 zval *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1583
1584 if (Z_TYPE_P(message) == IS_OBJECT) {
1585 getObjectEx(http_message_object, msg, message);
1586
1587 if (header_len) {
1588 if ((header = http_message_header_ex(msg->message, pretty_key(header_name, header_len, 1, 1), header_len + 1, 0))) {
1589 RETURN_ZVAL(header, 1, 1);
1590 }
1591 } else {
1592 array_init(return_value);
1593 zend_hash_copy(Z_ARRVAL_P(return_value), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1594 return;
1595 }
1596 }
1597 }
1598 RETURN_FALSE;
1599 }
1600 }
1601 /* }}} */
1602
1603 /* {{{ proto array HttpRequest::getResponseCookies([int flags[, array allowed_extras]])
1604 Get response cookie(s) after the request has been sent. */
1605 PHP_METHOD(HttpRequest, getResponseCookies)
1606 {
1607 if (return_value_used) {
1608 long flags = 0;
1609 zval *allowed_extras_array = NULL;
1610
1611 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|la!", &flags, &allowed_extras_array)) {
1612 int i = 0;
1613 HashKey key = initHashKey(0);
1614 char **allowed_extras = NULL;
1615 zval **header = NULL, **entry = NULL, *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1616 HashPosition pos, pos1, pos2;
1617
1618 if (Z_TYPE_P(message) == IS_OBJECT) {
1619 getObjectEx(http_message_object, msg, message);
1620
1621 array_init(return_value);
1622
1623 if (allowed_extras_array) {
1624 allowed_extras = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(allowed_extras_array)) + 1, sizeof(char *));
1625 FOREACH_VAL(pos, allowed_extras_array, entry) {
1626 zval *data = http_zsep(IS_STRING, *entry);
1627 allowed_extras[i++] = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
1628 zval_ptr_dtor(&data);
1629 }
1630 }
1631
1632 FOREACH_HASH_KEYVAL(pos1, &msg->message->hdrs, key, header) {
1633 if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "Set-Cookie")) {
1634 http_cookie_list list;
1635
1636 if (Z_TYPE_PP(header) == IS_ARRAY) {
1637 zval **single_header;
1638
1639 FOREACH_VAL(pos2, *header, single_header) {
1640 zval *data = http_zsep(IS_STRING, *single_header);
1641
1642 if (http_parse_cookie_ex(&list, Z_STRVAL_P(data), flags, allowed_extras)) {
1643 zval *cookie;
1644
1645 MAKE_STD_ZVAL(cookie);
1646 object_init(cookie);
1647 http_cookie_list_tostruct(&list, cookie);
1648 add_next_index_zval(return_value, cookie);
1649 http_cookie_list_dtor(&list);
1650 }
1651 zval_ptr_dtor(&data);
1652 }
1653 } else {
1654 zval *data = http_zsep(IS_STRING, *header);
1655 if (http_parse_cookie_ex(&list, Z_STRVAL_P(data), flags, allowed_extras)) {
1656 zval *cookie;
1657
1658 MAKE_STD_ZVAL(cookie);
1659 object_init(cookie);
1660 http_cookie_list_tostruct(&list, cookie);
1661 add_next_index_zval(return_value, cookie);
1662 http_cookie_list_dtor(&list);
1663 }
1664 zval_ptr_dtor(&data);
1665 }
1666 }
1667 }
1668
1669 if (allowed_extras) {
1670 for (i = 0; allowed_extras[i]; ++i) {
1671 efree(allowed_extras[i]);
1672 }
1673 efree(allowed_extras);
1674 }
1675
1676 return;
1677 }
1678 }
1679 RETURN_FALSE;
1680 }
1681 }
1682 /* }}} */
1683
1684 /* {{{ proto string HttpRequest::getResponseBody()
1685 Get the response body after the request has been sent. */
1686 PHP_METHOD(HttpRequest, getResponseBody)
1687 {
1688 NO_ARGS;
1689
1690 if (return_value_used) {
1691 zval *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1692
1693 if (Z_TYPE_P(message) == IS_OBJECT) {
1694 getObjectEx(http_message_object, msg, message);
1695 RETURN_PHPSTR_DUP(&msg->message->body);
1696 } else {
1697 RETURN_FALSE;
1698 }
1699 }
1700 }
1701 /* }}} */
1702
1703 /* {{{ proto int HttpRequest::getResponseCode()
1704 Get the response code after the request has been sent. */
1705 PHP_METHOD(HttpRequest, getResponseCode)
1706 {
1707 NO_ARGS;
1708
1709 if (return_value_used) {
1710 RETURN_PROP(responseCode);
1711 }
1712 }
1713 /* }}} */
1714
1715 /* {{{ proto string HttpRequest::getResponseStatus()
1716 Get the response status (i.e. the string after the response code) after the message has been sent. */
1717 PHP_METHOD(HttpRequest, getResponseStatus)
1718 {
1719 NO_ARGS;
1720
1721 if (return_value_used) {
1722 RETURN_PROP(responseStatus);
1723 }
1724 }
1725 /* }}} */
1726
1727 /* {{{ proto mixed HttpRequest::getResponseInfo([string name])
1728 Get response info after the request has been sent. */
1729 PHP_METHOD(HttpRequest, getResponseInfo)
1730 {
1731 if (return_value_used) {
1732 zval *info, **infop;
1733 char *info_name = NULL;
1734 int info_len = 0;
1735
1736 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &info_name, &info_len)) {
1737 RETURN_FALSE;
1738 }
1739
1740 info = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseInfo")-1, 0 TSRMLS_CC);
1741
1742 if (Z_TYPE_P(info) != IS_ARRAY) {
1743 RETURN_FALSE;
1744 }
1745
1746 if (info_len && info_name) {
1747 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(info), pretty_key(info_name, info_len, 0, 0), info_len + 1, (void *) &infop)) {
1748 RETURN_ZVAL(*infop, 1, 0);
1749 } else {
1750 http_error_ex(HE_NOTICE, HTTP_E_INVALID_PARAM, "Could not find response info named %s", info_name);
1751 RETURN_FALSE;
1752 }
1753 } else {
1754 RETURN_ZVAL(info, 1, 0);
1755 }
1756 }
1757 }
1758 /* }}}*/
1759
1760 /* {{{ proto HttpMessage HttpRequest::getResponseMessage()
1761 Get the full response as HttpMessage object after the request has been sent. */
1762 PHP_METHOD(HttpRequest, getResponseMessage)
1763 {
1764 NO_ARGS {
1765 zval *message;
1766
1767 SET_EH_THROW_HTTP();
1768 message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1769 if (Z_TYPE_P(message) == IS_OBJECT) {
1770 RETVAL_OBJECT(message, 1);
1771 } else {
1772 http_error(HE_WARNING, HTTP_E_RUNTIME, "HttpRequest does not contain a response message");
1773 }
1774 SET_EH_NORMAL();
1775 }
1776 }
1777 /* }}} */
1778
1779 /* {{{ proto HttpMessage HttpRequest::getRequestMessage()
1780 Get sent HTTP message. */
1781 PHP_METHOD(HttpRequest, getRequestMessage)
1782 {
1783 NO_ARGS;
1784
1785 if (return_value_used) {
1786 http_message *msg;
1787 getObject(http_request_object, obj);
1788
1789 SET_EH_THROW_HTTP();
1790 if ((msg = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request)))) {
1791 RETVAL_OBJVAL(http_request_object_message(getThis(), msg), 0);
1792 }
1793 SET_EH_NORMAL();
1794 }
1795 }
1796 /* }}} */
1797
1798 /* {{{ proto string HttpRequest::getRawRequestMessage()
1799 Get sent HTTP message. */
1800 PHP_METHOD(HttpRequest, getRawRequestMessage)
1801 {
1802 NO_ARGS;
1803
1804 if (return_value_used) {
1805 getObject(http_request_object, obj);
1806
1807 RETURN_PHPSTR_DUP(&obj->request->conv.request);
1808 }
1809 }
1810 /* }}} */
1811
1812 /* {{{ proto string HttpRequest::getRawResponseMessage()
1813 Get the entire HTTP response. */
1814 PHP_METHOD(HttpRequest, getRawResponseMessage)
1815 {
1816 NO_ARGS;
1817
1818 if (return_value_used) {
1819 getObject(http_request_object, obj);
1820
1821 RETURN_PHPSTR_DUP(&obj->request->conv.response);
1822 }
1823 }
1824 /* }}} */
1825
1826 /* {{{ proto HttpMessage HttpRequest::getHistory()
1827 Get all sent requests and received responses as an HttpMessage object. */
1828 PHP_METHOD(HttpRequest, getHistory)
1829 {
1830 NO_ARGS;
1831
1832 if (return_value_used) {
1833 zval *hist;
1834
1835 SET_EH_THROW_HTTP();
1836 hist = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
1837 if (Z_TYPE_P(hist) == IS_OBJECT) {
1838 RETVAL_OBJECT(hist, 1);
1839 } else {
1840 http_error(HE_WARNING, HTTP_E_RUNTIME, "The history is empty");
1841 }
1842 SET_EH_NORMAL();
1843 }
1844 }
1845 /* }}} */
1846
1847 /* {{{ proto void HttpRequest::clearHistory()
1848 Clear the history. */
1849 PHP_METHOD(HttpRequest, clearHistory)
1850 {
1851 NO_ARGS {
1852 zval *hist;
1853
1854 MAKE_STD_ZVAL(hist);
1855 ZVAL_NULL(hist);
1856 zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
1857 zval_ptr_dtor(&hist);
1858 }
1859 }
1860 /* }}} */
1861
1862 /* {{{ proto string HttpRequest::getMessageClass()
1863 Get the message class name. */
1864 PHP_METHOD(HttpRequest, getMessageClass)
1865 {
1866 NO_ARGS;
1867
1868 if (return_value_used) {
1869 RETURN_PROP("messageClass");
1870 }
1871 }
1872 /* }}} */
1873
1874 /* {{{ proto void setMessageClass(string class_name)
1875 Set the message class name. */
1876 PHP_METHOD(HttpRequest, setMessageClass)
1877 {
1878 char *cn;
1879 int cl;
1880
1881 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &cn, &cl)) {
1882 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("messageClass")-1, cn, cl TSRMLS_CC);
1883 }
1884 }
1885 /* }}} */
1886
1887 /* {{{ proto HttpMessage HttpRequest::send()
1888 Send the HTTP request. */
1889 PHP_METHOD(HttpRequest, send)
1890 {
1891 getObject(http_request_object, obj);
1892
1893 NO_ARGS;
1894
1895 SET_EH_THROW_HTTP();
1896
1897 RETVAL_FALSE;
1898
1899 if (obj->pool) {
1900 http_error(HE_WARNING, HTTP_E_RUNTIME, "Cannot perform HttpRequest::send() while attached to an HttpRequestPool");
1901 } else if (SUCCESS == http_request_object_requesthandler(obj, getThis())) {
1902 http_request_exec(obj->request);
1903 if (SUCCESS == http_request_object_responsehandler(obj, getThis())) {
1904 RETVAL_OBJECT(zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC), 1);
1905 }
1906 }
1907
1908 SET_EH_NORMAL();
1909 }
1910 /* }}} */
1911
1912 #endif /* ZEND_ENGINE_2 && HTTP_HAVE_CURL */
1913
1914 /*
1915 * Local variables:
1916 * tab-width: 4
1917 * c-basic-offset: 4
1918 * End:
1919 * vim600: noet sw=4 ts=4 fdm=marker
1920 * vim<600: noet sw=4 ts=4
1921 */
1922
Extended HTTP Support