projects / m6w6 / ext-http / blob
? search:


16352ee6c2d7c5e9d17e8ea1fe0cfce99071d77b
[m6w6/ext-http] / php_http_request_factory.c
1
2 #include "php_http.h"
3
4 #include <ext/standard/php_string.h>
5 #include <ext/spl/spl_observer.h>
6 #include <Zend/zend_interfaces.h>
7
8 /*
9 * array of name => php_http_request_factory_driver_t*
10 */
11 static HashTable php_http_request_factory_drivers;
12
13 PHP_HTTP_API STATUS php_http_request_factory_add_driver(const char *name_str, size_t name_len, php_http_request_factory_driver_t *driver)
14 {
15 return zend_hash_add(&php_http_request_factory_drivers, name_str, name_len + 1, (void *) driver, sizeof(php_http_request_factory_driver_t), NULL);
16 }
17
18 PHP_HTTP_API STATUS php_http_request_factory_get_driver(const char *name_str, size_t name_len, php_http_request_factory_driver_t *driver)
19 {
20 php_http_request_factory_driver_t *tmp;
21
22 if (SUCCESS == zend_hash_find(&php_http_request_factory_drivers, name_str, name_len + 1, (void *) &tmp)) {
23 *driver = *tmp;
24 return SUCCESS;
25 }
26 return FAILURE;
27 }
28
29 static zend_class_entry *php_http_request_factory_get_class_entry(zval *this_ptr, const char *for_str, size_t for_len TSRMLS_DC)
30 {
31 /* stupid non-const api */
32 char *sc = estrndup(for_str, for_len);
33 zval *cn = zend_read_property(Z_OBJCE_P(getThis()), getThis(), sc, for_len, 0 TSRMLS_CC);
34
35 efree(sc);
36 if (Z_TYPE_P(cn) == IS_STRING && Z_STRLEN_P(cn)) {
37 return zend_fetch_class(Z_STRVAL_P(cn), Z_STRLEN_P(cn), 0 TSRMLS_CC);
38 }
39
40 return NULL;
41 }
42
43 #define PHP_HTTP_BEGIN_ARGS(method, req_args) PHP_HTTP_BEGIN_ARGS_EX(HttpRequestFactory, method, 0, req_args)
44 #define PHP_HTTP_EMPTY_ARGS(method) PHP_HTTP_EMPTY_ARGS_EX(HttpRequestFactory, method, 0)
45 #define PHP_HTTP_REQUEST_FACTORY_ME(method, visibility) PHP_ME(HttpRequestFactory, method, PHP_HTTP_ARGS(HttpRequestFactory, method), visibility)
46 #define PHP_HTTP_REQUEST_FACTORY_ALIAS(method, func) PHP_HTTP_STATIC_ME_ALIAS(method, func, PHP_HTTP_ARGS(HttpRequestFactory, method))
47 #define PHP_HTTP_REQUEST_FACTORY_MALIAS(me, al, vis) ZEND_FENTRY(me, ZEND_MN(HttpRequestFactory_##al), PHP_HTTP_ARGS(HttpRequestFactory, al), vis)
48
49 PHP_HTTP_BEGIN_ARGS(__construct, 1)
50 PHP_HTTP_ARG_VAL(driver, 0)
51 PHP_HTTP_ARG_VAL(options, 0)
52 PHP_HTTP_END_ARGS;
53 PHP_HTTP_BEGIN_ARGS(createRequest, 0)
54 PHP_HTTP_ARG_VAL(persistentHandle, 0)
55 PHP_HTTP_END_ARGS;
56 PHP_HTTP_BEGIN_ARGS(createPool, 0)
57 PHP_HTTP_ARG_VAL(persistentHandle, 0)
58 PHP_HTTP_END_ARGS;
59 PHP_HTTP_BEGIN_ARGS(createDataShare, 0)
60 PHP_HTTP_ARG_VAL(persistentHandle, 0)
61 PHP_HTTP_END_ARGS;
62 PHP_HTTP_EMPTY_ARGS(getGlobalDataShareInstance);
63 PHP_HTTP_EMPTY_ARGS(getDriver);
64 PHP_HTTP_EMPTY_ARGS(getAvailableDrivers);
65
66 zend_class_entry *php_http_request_factory_class_entry;
67 zend_function_entry php_http_request_factory_method_entry[] = {
68 PHP_HTTP_REQUEST_FACTORY_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
69 PHP_HTTP_REQUEST_FACTORY_ME(createRequest, ZEND_ACC_PUBLIC)
70 PHP_HTTP_REQUEST_FACTORY_ME(createPool, ZEND_ACC_PUBLIC)
71 PHP_HTTP_REQUEST_FACTORY_ME(createDataShare, ZEND_ACC_PUBLIC)
72 PHP_HTTP_REQUEST_FACTORY_ME(getGlobalDataShareInstance, ZEND_ACC_PUBLIC)
73 PHP_HTTP_REQUEST_FACTORY_ME(getDriver, ZEND_ACC_PUBLIC)
74 PHP_HTTP_REQUEST_FACTORY_ME(getAvailableDrivers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
75
76 EMPTY_FUNCTION_ENTRY
77 };
78
79 PHP_METHOD(HttpRequestFactory, __construct)
80 {
81 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
82 char *driver_str;
83 int driver_len;
84 HashTable *options = NULL;
85
86 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|h", &driver_str, &driver_len, &options)) {
87 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(request_factory)) {
88 char *lower_str = php_strtolower(estrdup(driver_str), driver_len);
89
90 if (zend_hash_exists(&php_http_request_factory_drivers, lower_str, driver_len + 1)) {
91 zend_update_property_stringl(php_http_request_factory_class_entry, getThis(), ZEND_STRL("driver"), lower_str, driver_len TSRMLS_CC);
92
93 if (options) {
94 zval **val;
95 HashPosition pos;
96 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
97
98 FOREACH_HASH_KEYVAL(pos, options, key, val) {
99 if (key.type == HASH_KEY_IS_STRING) {
100 zend_update_property(php_http_request_factory_class_entry, getThis(), key.str, key.len - 1, *val);
101 }
102 }
103 }
104 } else {
105 php_http_error(HE_THROW, PHP_HTTP_E_REQUEST_FACTORY, "unknown request driver: '%s'", driver_str);
106 }
107 efree(lower_str);
108 } end_error_handling();
109 }
110 } end_error_handling();
111 }
112
113 PHP_METHOD(HttpRequestFactory, createRequest)
114 {
115 char *url_str = NULL;
116 int url_len;
117 long meth = -1;
118 zval *options = NULL;
119
120 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
121 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!la!", &url_str, &url_len, &meth, &options)) {
122 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(request_factory)) {
123 zval *zdriver, *os;
124 zend_object_value ov;
125 zend_class_entry *class_entry = NULL;
126 php_http_request_t *req = NULL;
127 php_http_request_factory_driver_t driver;
128
129 if (!(class_entry = php_http_request_factory_get_class_entry(getThis(), ZEND_STRL("requestClass") TSRMLS_CC))) {
130 class_entry = php_http_request_class_entry;
131 }
132
133 if ((zdriver = zend_read_property(php_http_request_factory_class_entry, getThis(), ZEND_STRL("driver"), 0 TSRMLS_CC))
134 && (IS_STRING == Z_TYPE_P(zdriver))
135 && (SUCCESS == php_http_request_factory_get_driver(Z_STRVAL_P(zdriver), Z_STRLEN_P(zdriver), &driver))
136 && (driver.request_ops)
137 && (req = php_http_request_init(NULL, driver.request_ops, NULL TSRMLS_CC))
138 && (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_request_object_new_ex, php_http_request_class_entry, req, NULL TSRMLS_CC))
139 ) {
140 ZVAL_OBJVAL(return_value, ov, 0);
141
142 MAKE_STD_ZVAL(os);
143 object_init_ex(os, spl_ce_SplObjectStorage);
144 zend_update_property(php_http_request_class_entry, return_value, ZEND_STRL("observers"), os TSRMLS_CC);
145 zval_ptr_dtor(&os);
146
147 if (url_str) {
148 zend_update_property_stringl(php_http_request_class_entry, return_value, ZEND_STRL("url"), url_str, url_len TSRMLS_CC);
149 }
150 if (meth > 0) {
151 zend_update_property_long(php_http_request_class_entry, return_value, ZEND_STRL("method"), meth TSRMLS_CC);
152 }
153 if (options) {
154 zend_call_method_with_1_params(&return_value, Z_OBJCE_P(return_value), NULL, "setoptions", NULL, options);
155 }
156 } else {
157 if (req) {
158 php_http_request_free(&req);
159 } else {
160 php_http_error(HE_WARNING, PHP_HTTP_E_REQUEST_FACTORY, "requests are not supported by this driver");
161 }
162 }
163 } end_error_handling();
164 }
165 } end_error_handling();
166 }
167
168 PHP_METHOD(HttpRequestFactory, createPool)
169 {
170 int argc = 0;
171 zval ***argv;
172
173 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
174 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|*", &argv, &argc)) {
175 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(request_factory)) {
176 int i;
177 zval *zdriver;
178 zend_object_value ov;
179 zend_class_entry *class_entry = NULL;
180 php_http_request_pool_t *pool = NULL;
181 php_http_request_pool_object_t *obj;
182 php_http_request_factory_driver_t driver;
183
184 if (!(class_entry = php_http_request_factory_get_class_entry(getThis(), ZEND_STRL("requestPoolClass") TSRMLS_CC))) {
185 class_entry = php_http_request_pool_class_entry;
186 }
187
188 if ((zdriver = zend_read_property(php_http_request_factory_class_entry, getThis(), ZEND_STRL("driver"), 0 TSRMLS_CC))
189 && (IS_STRING == Z_TYPE_P(zdriver))
190 && (SUCCESS == php_http_request_factory_get_driver(Z_STRVAL_P(zdriver), Z_STRLEN_P(zdriver), &driver))
191 && (driver.request_pool_ops)
192 && (pool = php_http_request_pool_init(NULL, driver.request_pool_ops, NULL TSRMLS_CC))
193 && (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_request_pool_object_new_ex, php_http_request_pool_class_entry, pool, (void *) &obj TSRMLS_CC))
194 ) {
195 ZVAL_OBJVAL(return_value, ov, 0);
196
197 for (i = 0; i < argc; ++i) {
198 if (Z_TYPE_PP(argv[i]) == IS_OBJECT && instanceof_function(Z_OBJCE_PP(argv[i]), php_http_request_class_entry TSRMLS_CC)) {
199 php_http_request_pool_attach(obj->pool, *(argv[i]));
200 }
201 }
202 } else {
203 if (pool) {
204 php_http_request_pool_free(&pool);
205 } else {
206 php_http_error(HE_WARNING, PHP_HTTP_E_REQUEST_FACTORY, "pools are not supported by this driver");
207 }
208 }
209 } end_error_handling();
210 }
211 } end_error_handling();
212 }
213
214 PHP_METHOD(HttpRequestFactory, createDataShare)
215 {
216 int argc = 0;
217 zval ***argv;
218
219 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
220 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|*", &argv, &argc)) {
221 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(request_factory)) {
222 int i;
223 zval *zdriver;
224 zend_object_value ov;
225 zend_class_entry *class_entry;
226 php_http_request_datashare_t *share = NULL;
227 php_http_request_datashare_object_t *obj;
228 php_http_request_factory_driver_t driver;
229
230 if (!(class_entry = php_http_request_factory_get_class_entry(getThis(), ZEND_STRL("requestDataShareClass") TSRMLS_CC))) {
231 class_entry = php_http_request_datashare_class_entry;
232 }
233
234 if ((zdriver = zend_read_property(php_http_request_factory_class_entry, getThis(), ZEND_STRL("driver"), 0 TSRMLS_CC))
235 && (IS_STRING == Z_TYPE_P(zdriver))
236 && (SUCCESS == php_http_request_factory_get_driver(Z_STRVAL_P(zdriver), Z_STRLEN_P(zdriver), &driver))
237 && (driver.request_datashare_ops)
238 && (share = php_http_request_datashare_init(NULL, driver.request_datashare_ops, NULL, 0 TSRMLS_CC))
239 && (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_request_datashare_object_new_ex, php_http_request_datashare_class_entry, share, (void *) &obj TSRMLS_CC))
240 ) {
241 ZVAL_OBJVAL(return_value, ov, 0);
242
243 for (i = 0; i < argc; ++i) {
244 if (Z_TYPE_PP(argv[i]) == IS_OBJECT && instanceof_function(Z_OBJCE_PP(argv[i]), php_http_request_class_entry TSRMLS_CC)) {
245 php_http_request_datashare_attach(obj->share, *(argv[i]));
246 }
247 }
248 } else {
249 if (share) {
250 php_http_request_datashare_free(&share);
251 } else {
252 php_http_error(HE_WARNING, PHP_HTTP_E_REQUEST_FACTORY, "datashares are not supported by this driver");
253 }
254 }
255 } end_error_handling();
256 }
257 } end_error_handling();
258 }
259
260 PHP_METHOD(HttpRequestFactory, getGlobalDataShareInstance)
261 {
262 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
263 if (SUCCESS == zend_parse_parameters_none()) {
264 with_error_handling(EH_THROW, PHP_HTTP_EX_CE(request_datashare)) {
265 zval *instance = *zend_std_get_static_property(php_http_request_datashare_class_entry, ZEND_STRL("instance"), 0, NULL TSRMLS_CC);
266
267 if (Z_TYPE_P(instance) != IS_OBJECT) {
268 zval *zdriver;
269 zend_object_value ov;
270 zend_class_entry *class_entry;
271 php_http_request_datashare_t *share;
272
273 if (!(class_entry = php_http_request_factory_get_class_entry(getThis(), ZEND_STRL("requestDataShareClass") TSRMLS_CC))) {
274 class_entry = php_http_request_datashare_class_entry;
275 }
276
277 if ((zdriver = zend_read_property(php_http_request_factory_class_entry, getThis(), ZEND_STRL("driver"), 0 TSRMLS_CC))
278 && (IS_STRING == Z_TYPE_P(zdriver))
279 && (share = php_http_request_datashare_global_get(Z_STRVAL_P(zdriver), Z_STRLEN_P(zdriver) TSRMLS_CC))
280 && (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_request_datashare_object_new_ex, php_http_request_datashare_class_entry, share, NULL TSRMLS_CC))
281 ) {
282 MAKE_STD_ZVAL(instance);
283 ZVAL_OBJVAL(instance, ov, 0);
284 zend_update_static_property(php_http_request_datashare_class_entry, ZEND_STRL("instance"), instance TSRMLS_CC);
285
286 if (PHP_HTTP_G->request_datashare.cookie) {
287 zend_update_property_bool(php_http_request_datashare_class_entry, instance, ZEND_STRL("cookie"), PHP_HTTP_G->request_datashare.cookie TSRMLS_CC);
288 }
289 if (PHP_HTTP_G->request_datashare.dns) {
290 zend_update_property_bool(php_http_request_datashare_class_entry, instance, ZEND_STRL("dns"), PHP_HTTP_G->request_datashare.dns TSRMLS_CC);
291 }
292 }
293 }
294
295 RETVAL_ZVAL(instance, 1, 0);
296 } end_error_handling();
297 }
298 } end_error_handling();
299 }
300
301
302 PHP_METHOD(HttpRequestFactory, getDriver)
303 {
304 if (SUCCESS == zend_parse_parameters_none()) {
305 RETURN_PROP(php_http_request_factory_class_entry, "driver");
306 }
307 RETURN_FALSE;
308 }
309
310 PHP_METHOD(HttpRequestFactory, getAvailableDrivers)
311 {
312 if (SUCCESS == zend_parse_parameters_none()) {
313 HashPosition pos;
314 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
315
316 array_init(return_value);
317 FOREACH_HASH_KEY(pos, &php_http_request_factory_drivers, key) {
318 add_next_index_stringl(return_value, key.str, key.len - 1, 1);
319 }
320 return;
321 }
322 RETURN_FALSE;
323 }
324
325 PHP_MINIT_FUNCTION(http_request_factory)
326 {
327 zend_hash_init(&php_http_request_factory_drivers, 0, NULL, NULL, 1);
328
329 PHP_HTTP_REGISTER_CLASS(http\\request, Factory, http_request_factory, php_http_object_class_entry, 0);
330 zend_declare_property_null(php_http_request_factory_class_entry, ZEND_STRL("driver"), ZEND_ACC_PRIVATE TSRMLS_CC);
331 zend_declare_property_null(php_http_request_factory_class_entry, ZEND_STRL("requestClass"), ZEND_ACC_PUBLIC TSRMLS_CC);
332 zend_declare_property_null(php_http_request_factory_class_entry, ZEND_STRL("requestPoolClass"), ZEND_ACC_PUBLIC TSRMLS_CC);
333 zend_declare_property_null(php_http_request_factory_class_entry, ZEND_STRL("requestDataShareClass"), ZEND_ACC_PUBLIC TSRMLS_CC);
334
335 return SUCCESS;
336 }
337
338 PHP_MSHUTDOWN_FUNCTION(http_request_factory)
339 {
340 zend_hash_destroy(&php_http_request_factory_drivers);
341
342 return SUCCESS;
343 }
344
Extended HTTP Support