1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | http://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Authors: |
14 | Israel Ekpo <iekpo@php.net> |
15 | Omar Shaban <omars@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 #include "php_solr.h"
20
solr_init_params(solr_params_t * solr_params,long int index)21 PHP_SOLR_API int solr_init_params(solr_params_t *solr_params, long int index)
22 {
23 uint32_t nSize = SOLR_INITIAL_HASH_TABLE_SIZE;
24 solr_params = (solr_params_t *)pemalloc( sizeof(solr_params_t), SOLR_PARAMS_PERSISTENT);
25
26 memset(solr_params, 0, sizeof(solr_params_t));
27
28 if ((solr_params = zend_hash_index_update_ptr(SOLR_GLOBAL(params), index, (void *) solr_params)) == NULL) {
29
30 php_error_docref(NULL, E_ERROR, "Error while registering query parameters in HashTable");
31
32 return FAILURE;
33 }
34
35 solr_params->params_index = index;
36 solr_params->params_count = 0U;
37
38 /* Allocated memory for the parameters HashTable using fast cache for HashTables */
39 ALLOC_HASHTABLE(solr_params->params);
40
41 zend_hash_init(solr_params->params, nSize, NULL, (dtor_func_t) solr_destory_param_ht_dtor, SOLR_PARAMS_PERSISTENT);
42 return SUCCESS;
43 }
44
45 /* {{{ PHP_SOLR_API void solr_destroy_params(zval *solr_params) */
solr_destroy_params(zval * solr_params)46 PHP_SOLR_API void solr_destroy_params(zval *solr_params)
47 {
48 solr_params_t *params = (solr_params_t *) Z_PTR_P(solr_params);
49
50 zend_hash_destroy(params->params);
51
52 pefree(params->params, SOLR_PARAMS_PERSISTENT);
53 pefree(params, SOLR_PARAMS_PERSISTENT);
54 }
55 /* }}} */
56
57 /* {{{ PHP_SOLR_API void solr_destroy_param(solr_param_t **param) */
solr_destroy_param(solr_param_t ** param)58 PHP_SOLR_API void solr_destroy_param(solr_param_t **param)
59 {
60 solr_param_value_t *temp_ptr = NULL;
61
62 solr_param_value_t *current_ptr = (*param)->head;
63
64 while(current_ptr != NULL) {
65
66 temp_ptr = current_ptr->next;
67
68 (*param)->value_free_func(current_ptr);
69
70 current_ptr = temp_ptr;
71 }
72
73 (*param)->head = NULL;
74 (*param)->last = NULL;
75
76 pefree((*param)->param_name, SOLR_PARAMS_PERSISTENT);
77
78 (*param)->param_name = NULL;
79
80 pefree((*param), SOLR_PARAMS_PERSISTENT);
81
82 (*param) = NULL;
83 }
84 /* }}} */
85
solr_destory_param_ht_dtor(zval * param_zv)86 PHP_SOLR_API void solr_destory_param_ht_dtor(zval *param_zv)
87 {
88 solr_param_t *param = (solr_param_t *) Z_PTR_P(param_zv);
89 solr_destroy_param(¶m);
90 }
91
92 /* {{{ PHP_SOLR_API int solr_params_delete_param_value(solr_param_t *param, const solr_param_value_t *target_value) */
solr_params_delete_param_value(solr_param_t * param,const solr_param_value_t * target_value)93 PHP_SOLR_API int solr_params_delete_param_value(solr_param_t *param, const solr_param_value_t *target_value)
94 {
95 solr_param_value_t *curr_value = param->head;
96 int match_found = 0;
97
98 if (!target_value)
99 {
100 php_error_docref(NULL, E_NOTICE, "Invalid pointer. Submitted target cannot be used for the delete search\n");
101
102 return FAILURE;
103 }
104
105 while(!match_found && curr_value != NULL)
106 {
107 match_found = param->value_equal_func(curr_value, target_value);
108
109 /* If the target was found */
110 if (match_found)
111 {
112 /* If the target is not the head */
113 if (curr_value->prev)
114 {
115 curr_value->prev->next = curr_value->next;
116
117 } else {
118
119 param->head = curr_value->next;
120 }
121
122 /* If the target is not the tail */
123 if (curr_value->next)
124 {
125 curr_value->next->prev = curr_value->prev;
126
127 } else {
128
129 param->last = curr_value->prev;
130 }
131
132 /* Destroy target value */
133 param->value_free_func(curr_value);
134
135 goto dpv_end;
136 }
137
138 curr_value = curr_value->next;
139 }
140
141 dpv_end :
142
143 if (!match_found)
144 {
145 php_error_docref(NULL, E_NOTICE, "Target parameter value could not be found in '%s'. No value was deleted ", param->param_name);
146
147 return FAILURE;
148 }
149
150 param->count--; /* Reduce the value count by one */
151
152 return SUCCESS;
153 }
154 /* }}} */
155
156 /* {{{ PHP_SOLR_API int solr_params_insert_param_value(solr_param_t *param, solr_param_value_t *param_value) */
solr_params_insert_param_value(solr_param_t * param,solr_param_value_t * param_value)157 PHP_SOLR_API int solr_params_insert_param_value(solr_param_t *param, solr_param_value_t *param_value)
158 {
159 if (!param_value)
160 {
161 return FAILURE;
162 }
163
164 param_value->next = param_value->prev = NULL;
165
166 if (!param->allow_multiple)
167 {
168 param->value_free_func(param->head);
169 param->head = param_value;
170 param->last = param_value;
171 param->count = 1U;
172 return SUCCESS;
173 }
174
175 if (param->head == NULL) {
176 param->head = param_value;
177 param->last = param_value;
178 } else {
179 param_value->prev = param->last;
180 param->last->next = param_value;
181 param->last = param_value;
182 }
183
184 param->count++;
185
186 return SUCCESS;
187 }
188 /* }}} */
189
190 /* {{{ PHP_SOLR_API solr_param_t *solr_create_new_param(const solr_char_t *param_name, size_t param_name_len, solr_param_type_t param_type, solr_bool allow_multiple, solr_param_value_equal_func_t value_equal_func, solr_param_fetch_func_t param_fetch_func, solr_param_value_free_func_t value_free_func, solr_char_t delimiter, solr_char_t arg_separator) */
solr_create_new_param(const solr_char_t * param_name,size_t param_name_len,solr_param_type_t param_type,solr_bool allow_multiple,solr_param_value_equal_func_t value_equal_func,solr_param_fetch_func_t param_fetch_func,solr_param_value_free_func_t value_free_func,solr_char_t delimiter,solr_char_t arg_separator)191 PHP_SOLR_API solr_param_t *solr_create_new_param(const solr_char_t *param_name, size_t param_name_len, solr_param_type_t param_type, solr_bool allow_multiple, solr_param_value_equal_func_t value_equal_func, solr_param_fetch_func_t param_fetch_func, solr_param_value_free_func_t value_free_func, solr_char_t delimiter, solr_char_t arg_separator)
192 {
193 solr_param_t *query_param = (solr_param_t *) pemalloc(sizeof(solr_param_t), SOLR_PARAMS_PERSISTENT);
194
195 /* Always initialize linked list containers to NULL. */
196 /* Member pointers may contain unallocated addresses */
197 /* This notice applies to all solr_param_t member pointers here */
198 memset(query_param, 0, sizeof(solr_param_t));
199
200 query_param->type = param_type;
201
202 query_param->count = 0L;
203
204 query_param->param_name = solr_strndup(param_name, param_name_len);
205
206 query_param->param_name_length = param_name_len;
207
208 query_param->allow_multiple = allow_multiple;
209
210 query_param->head = query_param->last = NULL;
211
212 query_param->value_equal_func = value_equal_func;
213
214 query_param->fetch_func = param_fetch_func;
215
216 query_param->value_free_func = value_free_func;
217
218 query_param->delimiter = delimiter;
219
220 query_param->arg_separator = arg_separator;
221
222 return query_param;
223 }
224 /* }}} */
225
226 /* {{{ PHP_SOLR_API int solr_add_or_set_normal_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length, zend_bool allow_multiple)
227 parameter value addition functions */
solr_add_or_set_normal_param(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length,zend_bool allow_multiple)228 PHP_SOLR_API int solr_add_or_set_normal_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length, zend_bool allow_multiple)
229 {
230 solr_params_t *solr_params = NULL;
231 HashTable *params = NULL;
232 solr_param_type_t param_type = SOLR_PARAM_TYPE_NORMAL;
233 solr_param_t *param = NULL;
234 solr_param_value_t *parameter_value = NULL;
235
236
237 if (!pname_length)
238 {
239 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter name");
240 /* php_error_docref(NULL, E_ERROR, "Invalid parameter name"); */
241
242 return FAILURE;
243 }
244
245 if (!pvalue_length)
246 {
247 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter value");
248 /* php_error_docref(NULL, E_ERROR, "Invalid parameter value"); */
249
250 return FAILURE;
251 }
252
253 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
254
255 php_error_docref(NULL, E_WARNING, "SolrParams instance could not be retrieved from HashTable");
256
257 return FAILURE;
258 }
259
260 params = solr_params->params;
261
262 if ((param = zend_hash_str_find_ptr(params, (char *) pname, pname_length)) != NULL)
263 {
264 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
265
266 memset(parameter_value, 0, sizeof(solr_param_value_t));
267
268 solr_string_appends(&(parameter_value->contents.normal), pvalue, pvalue_length);
269
270 solr_params_insert_param_value(param, parameter_value);
271
272 return SUCCESS;
273 }
274
275 param = solr_create_new_param(pname, pname_length, param_type, allow_multiple, solr_normal_param_value_equal, (solr_param_fetch_func_t) solr_normal_param_value_fetch, solr_normal_param_value_free, '&', 0);
276 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
277
278 memset(parameter_value, 0, sizeof(solr_param_value_t));
279
280 solr_string_appends(&(parameter_value->contents.normal), pvalue, pvalue_length);
281 solr_params_insert_param_value(param, parameter_value);
282
283 if (zend_hash_str_add_ptr(params, pname, pname_length, (void *) param) == NULL) {
284 php_error_docref(NULL, E_ERROR, "Error from %s %s=%s", __func__, (char *) pname, pvalue);
285 return FAILURE;
286 }
287
288 return SUCCESS;
289 }
290 /* }}} */
291
292
293 /* {{{ PHP_SOLR_API int solr_add_simple_list_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length) */
solr_add_simple_list_param(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length)294 PHP_SOLR_API int solr_add_simple_list_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length)
295 {
296 zend_bool allow_multiple = 1; /* This value type by definition allows multiple. add parameters can be added more than once */
297 solr_params_t *solr_params = NULL;
298 HashTable *params = NULL;
299 solr_param_type_t param_type = SOLR_PARAM_TYPE_SIMPLE_LIST;
300 solr_param_t *param = NULL;
301 solr_param_value_t *parameter_value = NULL;
302
303 if (!pname_length)
304 {
305 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter name");
306 return FAILURE;
307 }
308
309 if (!pvalue_length)
310 {
311 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter value");
312 return FAILURE;
313 }
314
315 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
316 php_error_docref(NULL, E_ERROR, "SolrParams instance could not be retrieved from HashTable");
317 return FAILURE;
318 }
319
320 params = solr_params->params;
321
322 if ((param = zend_hash_str_find_ptr(params, pname, pname_length)) != NULL)
323 {
324 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
325 memset(parameter_value, 0, sizeof(solr_param_value_t));
326 solr_string_appends(&(parameter_value->contents.simple_list), pvalue, pvalue_length);
327 solr_params_insert_param_value(param, parameter_value);
328 return SUCCESS;
329 }
330
331 param = solr_create_new_param(pname, pname_length, param_type, allow_multiple, solr_simple_list_param_value_equal, (solr_param_fetch_func_t) solr_simple_list_param_value_fetch, solr_simple_list_param_value_free, ',', 0);
332 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
333
334 memset(parameter_value, 0, sizeof(solr_param_value_t));
335
336 solr_string_appends(&(parameter_value->contents.simple_list), pvalue, pvalue_length);
337 solr_params_insert_param_value(param, parameter_value);
338
339 if (zend_hash_str_add_ptr(params, pname, pname_length, (void *) param) == NULL) {
340 php_error_docref(NULL, E_ERROR, "Error from %s %s=%s", __func__, (char *) pname, pvalue);
341 return FAILURE;
342 }
343
344 return SUCCESS;
345 }
346 /* }}} */
347
348 /* {{{ PHP_SOLR_API int solr_add_simple_list_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length) */
solr_add_simple_list_param_ex(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length,solr_char_t * separator)349 PHP_SOLR_API int solr_add_simple_list_param_ex(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length,solr_char_t *separator)
350 {
351 zend_bool allow_multiple = 1; /* This value type by definition allows multiple. add parameters can be added more than once */
352 solr_params_t *solr_params = NULL;
353 HashTable *params = NULL;
354 solr_param_type_t param_type = SOLR_PARAM_TYPE_SIMPLE_LIST;
355 solr_param_t *param = NULL;
356 solr_param_value_t *parameter_value = NULL;
357
358 if (!pname_length)
359 {
360 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter name");
361 return FAILURE;
362 }
363
364 if (!pvalue_length)
365 {
366 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter value");
367 return FAILURE;
368 }
369
370 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
371 php_error_docref(NULL, E_ERROR, "SolrParams instance could not be retrieved from HashTable");
372 return FAILURE;
373 }
374
375 params = solr_params->params;
376
377 if ((param = zend_hash_str_find_ptr(params, pname, pname_length)) != NULL)
378 {
379 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
380
381 memset(parameter_value, 0, sizeof(solr_param_value_t));
382
383 solr_string_appends(&(parameter_value->contents.simple_list), pvalue, pvalue_length);
384
385 solr_params_insert_param_value(param, parameter_value);
386
387 return SUCCESS;
388 }
389
390 param = solr_create_new_param(pname, pname_length, param_type, allow_multiple, solr_simple_list_param_value_equal, (solr_param_fetch_func_t) solr_simple_list_param_value_fetch, solr_simple_list_param_value_free, *separator, 0);
391 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
392
393 memset(parameter_value, 0, sizeof(solr_param_value_t));
394
395 solr_string_appends(&(parameter_value->contents.simple_list), pvalue, pvalue_length);
396 solr_params_insert_param_value(param, parameter_value);
397
398 if (zend_hash_str_add_ptr(params, pname, pname_length, (void *) param) == NULL) {
399
400 php_error_docref(NULL, E_ERROR, "Error from %s %s=%s", __func__, (char *) pname, pvalue);
401
402 return FAILURE;
403 }
404
405 return SUCCESS;
406 }
407 /* }}} */
408
409
410 /* {{{ PHP_SOLR_API int solr_add_arg_list_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length, solr_char_t *avalue, int avalue_length, solr_char_t delimiter, solr_char_t arg_separator) */
solr_add_arg_list_param(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length,solr_char_t * avalue,int avalue_length,solr_char_t delimiter,solr_char_t arg_separator)411 PHP_SOLR_API int solr_add_arg_list_param(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length, solr_char_t *avalue, int avalue_length, solr_char_t delimiter, solr_char_t arg_separator)
412 {
413 zend_bool allow_multiple = 1; /* This value type by definition allows multiple */
414 solr_params_t *solr_params = NULL;
415 solr_param_type_t param_type = SOLR_PARAM_TYPE_ARG_LIST;
416 solr_param_t *param = NULL; /* holds a pointer to the param structure e.g. sort */
417 solr_param_value_t *parameter_value = NULL;
418 HashTable *params = NULL;
419
420 if (!pname_length)
421 {
422 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter name");
423 return FAILURE;
424 }
425
426 if (!pvalue_length)
427 {
428 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter value");
429
430 return FAILURE;
431 }
432
433 /*
434 if (!avalue_length)
435 {
436 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid argument value");
437
438 return FAILURE;
439 }
440 */
441
442 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
443
444 php_error_docref(NULL, E_WARNING, "SolrParams instance could not be retrieved from HashTable");
445
446 return FAILURE;
447 }
448
449 params = solr_params->params;
450 /* if parameter exists add the new value argument(param_value) */
451 if ((param = zend_hash_str_find_ptr(params, pname, pname_length)) != NULL)
452 {
453 parameter_value = create_parameter_value_arg_list(pvalue, pvalue_length, avalue, avalue_length, "", 0);
454
455 solr_params_insert_param_value(param, parameter_value);
456
457 return SUCCESS;
458 }
459
460 param = solr_create_new_param(pname, pname_length, param_type, allow_multiple, solr_arg_list_param_value_equal, (solr_param_fetch_func_t) solr_arg_list_param_value_fetch, solr_arg_list_param_value_free, delimiter, arg_separator);
461 parameter_value = create_parameter_value_arg_list(pvalue, pvalue_length, avalue, avalue_length, (solr_char_t*)"", 0);
462 solr_params_insert_param_value(param, parameter_value);
463
464 if (zend_hash_str_add_ptr(params, pname, pname_length, (void *) param) == NULL) {
465
466 php_error_docref(NULL, E_ERROR, "Error from %s %s=%s", __func__, (char *) pname, pvalue);
467
468 return FAILURE;
469 }
470
471 return SUCCESS;
472 }
473 /* }}} */
474
create_parameter_value_arg_list(solr_char_t * pvalue,int pvalue_length,solr_char_t * avalue,int avalue_length,solr_char_t * delimiter_override,solr_bool delimiter_overriden)475 PHP_SOLR_API solr_param_value_t* create_parameter_value_arg_list(solr_char_t *pvalue, int pvalue_length, solr_char_t *avalue, int avalue_length, solr_char_t *delimiter_override, solr_bool delimiter_overriden)
476 {
477 solr_param_value_t *parameter_value = NULL;
478
479 parameter_value = (solr_param_value_t *) pemalloc(sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
480
481 memset(parameter_value, 0, sizeof(solr_param_value_t));
482 solr_string_appends(&(parameter_value->contents.arg_list.value), pvalue, pvalue_length);
483
484 solr_string_appends(&(parameter_value->contents.arg_list.arg), avalue, avalue_length);
485
486 if(delimiter_overriden){
487 parameter_value->contents.arg_list.delimiter_override = solr_strndup(delimiter_override, sizeof(delimiter_override));
488 parameter_value->contents.arg_list.delimiter_overriden = delimiter_overriden;
489 }
490
491 return parameter_value;
492 }
493
494
solr_add_arg_list_param_ex(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length,solr_char_t * avalue,int avalue_length,solr_char_t delimiter,solr_char_t arg_separator,solr_char_t delimiter_override)495 PHP_SOLR_API int solr_add_arg_list_param_ex(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length, solr_char_t *avalue, int avalue_length, solr_char_t delimiter, solr_char_t arg_separator, solr_char_t delimiter_override) {
496 zend_bool allow_multiple = 1; /* This value type by definition allows multiple */
497 solr_params_t *solr_params = NULL;
498 solr_param_type_t param_type = SOLR_PARAM_TYPE_ARG_LIST;
499 solr_param_t *param = NULL; /* holds a pointer to the param structure e.g. sort */
500 solr_param_value_t *parameter_value = NULL;
501 HashTable *params = NULL;
502
503 if (!pname_length)
504 {
505 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter name");
506
507 return FAILURE;
508 }
509
510 if (!pvalue_length)
511 {
512 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid parameter value");
513
514 return FAILURE;
515 }
516 /*
517 * commented for the favor of having empty value
518 if (!avalue_length)
519 {
520 solr_throw_exception_ex(solr_ce_SolrIllegalArgumentException, SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC, "Invalid argument value");
521
522 return FAILURE;
523 }
524 */
525
526 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
527
528 php_error_docref(NULL, E_WARNING, "SolrParams instance could not be retrieved from HashTable");
529
530 return FAILURE;
531 }
532
533 params = solr_params->params;
534 /* if parameter exists add the new value argument(param_value) */
535 if ((param = zend_hash_str_find_ptr(params, pname, pname_length)) != NULL)
536 {
537 parameter_value = create_parameter_value_arg_list(pvalue, pvalue_length, avalue, avalue_length, &delimiter_override, 1);
538
539 solr_params_insert_param_value(param, parameter_value);
540
541 return SUCCESS;
542 }
543
544 param = solr_create_new_param(pname, pname_length, param_type, allow_multiple, solr_arg_list_param_value_equal, (solr_param_fetch_func_t) solr_arg_list_param_value_fetch, solr_arg_list_param_value_free, delimiter, arg_separator);
545 parameter_value = create_parameter_value_arg_list(pvalue, pvalue_length, avalue, avalue_length, &delimiter_override, 1);
546 solr_params_insert_param_value(param, parameter_value);
547
548 if (zend_hash_str_add_ptr(params, pname, pname_length, (void *) param) == NULL) {
549
550 php_error_docref(NULL, E_ERROR, "Error from %s %s=%s", __func__, (char *) pname, pvalue);
551
552 return FAILURE;
553 }
554
555 return SUCCESS;
556 }
557
558 /* {{{ Parameter value EQUALITY FUNCTIONS */
559
560 /* {{{ PHP_SOLR_API int solr_normal_param_value_equal(const solr_param_value_t *a, const solr_param_value_t *b) */
solr_normal_param_value_equal(const solr_param_value_t * a,const solr_param_value_t * b)561 PHP_SOLR_API int solr_normal_param_value_equal(const solr_param_value_t *a, const solr_param_value_t *b)
562 {
563 return solr_string_equal(&(a->contents.normal), &(b->contents.normal));
564 }
565 /* }}} */
566
567 /* {{{ PHP_SOLR_API int solr_simple_list_param_value_equal(const solr_param_value_t *a, const solr_param_value_t *b) */
solr_simple_list_param_value_equal(const solr_param_value_t * a,const solr_param_value_t * b)568 PHP_SOLR_API int solr_simple_list_param_value_equal(const solr_param_value_t *a, const solr_param_value_t *b)
569 {
570 return solr_string_equal(&(a->contents.simple_list), &(b->contents.simple_list));
571 }
572 /* }}} */
573
574 /* {{{ PHP_SOLR_API int solr_arg_list_param_value_equal(const solr_param_value_t *a, const solr_param_value_t *b) */
solr_arg_list_param_value_equal(const solr_param_value_t * a,const solr_param_value_t * b)575 PHP_SOLR_API int solr_arg_list_param_value_equal(const solr_param_value_t *a, const solr_param_value_t *b)
576 {
577 return solr_string_equal(&(a->contents.arg_list.value), &(b->contents.arg_list.value));
578 }
579 /* }}} */
580
581 /* }}} */
582
583 /* {{{ Parameter values retrieval functions */
584
585 /* {{{ PHP_SOLR_API void solr_normal_param_value_fetch(solr_param_t *solr_param, solr_string_t *buffer) */
solr_normal_param_value_fetch(solr_param_t * solr_param,solr_string_t * buffer)586 PHP_SOLR_API void solr_normal_param_value_fetch(solr_param_t *solr_param, solr_string_t *buffer)
587 {
588 zend_string *url_encoded_param_value;
589 solr_param_value_t *current_ptr = solr_param->head;
590 solr_char_t glue = '&';
591
592 if (!solr_param->allow_multiple)
593 {
594 url_encoded_param_value = php_raw_url_encode((char *) current_ptr->contents.normal.str, current_ptr->contents.normal.len);
595
596 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
597
598 solr_string_appendc(buffer, '=');
599
600 solr_string_appends(buffer, url_encoded_param_value->val, url_encoded_param_value->len);
601
602 zend_string_free(url_encoded_param_value);
603
604 } else {
605
606 zend_ulong n_loops = solr_param->count - 1;
607
608 while(n_loops)
609 {
610 url_encoded_param_value = NULL;
611
612 url_encoded_param_value = php_raw_url_encode(current_ptr->contents.normal.str, current_ptr->contents.normal.len);
613
614 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
615
616 solr_string_appendc(buffer, '=');
617
618 solr_string_appends(buffer, url_encoded_param_value->val, url_encoded_param_value->len);
619
620 zend_string_release(url_encoded_param_value);
621
622 solr_string_appendc(buffer, glue);
623
624 n_loops--;
625
626 current_ptr = current_ptr->next;
627 }
628
629 url_encoded_param_value = NULL;
630
631 url_encoded_param_value = php_raw_url_encode(current_ptr->contents.normal.str, current_ptr->contents.normal.len);
632
633 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
634 solr_string_appendc(buffer, '=');
635 solr_string_appends(buffer, url_encoded_param_value->val, url_encoded_param_value->len);
636
637 zend_string_free(url_encoded_param_value);
638 }
639 }
640 /* }}} */
641
642 /* {{{ PHP_SOLR_API void solr_simple_list_param_value_fetch(solr_param_t *solr_param, solr_string_t *buffer) */
solr_simple_list_param_value_fetch(solr_param_t * solr_param,solr_string_t * buffer)643 PHP_SOLR_API void solr_simple_list_param_value_fetch(solr_param_t *solr_param, solr_string_t *buffer)
644 {
645 solr_param_value_t *current_ptr = solr_param->head;
646 solr_char_t list_delimiter = ','; /* Comma 0x2C */
647 zend_ulong n_loops = solr_param->count - 1;
648 auto solr_string_t tmp_buffer;
649 zend_string *url_encoded_list = NULL;
650
651 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
652 solr_string_appendc(buffer, '=');
653
654 memset(&tmp_buffer, 0, sizeof(solr_string_t));
655
656 while(n_loops)
657 {
658 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.simple_list));
659
660 solr_string_appendc(&tmp_buffer, list_delimiter);
661
662 n_loops--;
663
664 current_ptr = current_ptr->next;
665 }
666
667 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.simple_list));
668
669 url_encoded_list = php_raw_url_encode(tmp_buffer.str, tmp_buffer.len);
670
671 solr_string_appends(buffer, url_encoded_list->val, url_encoded_list->len);
672
673 zend_string_release(url_encoded_list);
674
675 url_encoded_list = NULL;
676
677 solr_string_free(&tmp_buffer);
678 }
679 /* }}} */
680
681 /* {{{ PHP_SOLR_API void solr_arg_list_param_value_fetch(solr_param_t *solr_param, solr_string_t *buffer) */
solr_arg_list_param_value_fetch(solr_param_t * solr_param,solr_string_t * buffer)682 PHP_SOLR_API void solr_arg_list_param_value_fetch(solr_param_t *solr_param, solr_string_t *buffer)
683 {
684 solr_param_value_t *current_ptr = solr_param->head;
685 solr_char_t list_delimiter = solr_param->delimiter;
686 solr_char_t separator = solr_param->arg_separator;
687 zend_ulong n_loops = solr_param->count - 1;
688 solr_string_t tmp_buffer;
689 zend_string *url_encoded_list = NULL;
690
691
692 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
693 solr_string_appendc(buffer, '=');
694
695 memset(&tmp_buffer, 0, sizeof(solr_string_t));
696
697 while(n_loops)
698 {
699 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.value));
700
701 if (current_ptr->contents.arg_list.delimiter_override && *current_ptr->contents.arg_list.delimiter_override) {
702 solr_string_appendc(&tmp_buffer, *current_ptr->contents.arg_list.delimiter_override);
703 } else {
704 solr_string_appendc(&tmp_buffer, separator);
705 }
706
707 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.arg));
708
709 solr_string_appendc(&tmp_buffer, list_delimiter);
710
711 n_loops--;
712
713 current_ptr = current_ptr->next;
714 }
715
716 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.value));
717
718 if (current_ptr->contents.arg_list.delimiter_override && *current_ptr->contents.arg_list.delimiter_override) {
719 solr_string_appendc(&tmp_buffer, *current_ptr->contents.arg_list.delimiter_override);
720 } else {
721 solr_string_appendc(&tmp_buffer, separator);
722 }
723
724 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.arg));
725
726 url_encoded_list = php_raw_url_encode(tmp_buffer.str, tmp_buffer.len);
727
728 solr_string_appends(buffer, url_encoded_list->val, url_encoded_list->len);
729
730 zend_string_release(url_encoded_list);
731
732 url_encoded_list = NULL;
733
734 solr_string_free(&tmp_buffer);
735 }
736 /* }}} */
737
738 /* }}} */
739
740 /* {{{ Parameter retrieval functions. Only used for display. */
741
742 /* {{{ PHP_SOLR_API void solr_normal_param_value_display_string(solr_param_t *solr_param, zval *param_value) */
solr_normal_param_value_display_string(solr_param_t * solr_param,zval * param_value)743 PHP_SOLR_API void solr_normal_param_value_display_string(solr_param_t *solr_param, zval *param_value)
744 {
745 solr_param_value_t *current_ptr = solr_param->head;
746
747 ZVAL_STRINGL(param_value, current_ptr->contents.normal.str, current_ptr->contents.normal.len);
748 }
749 /* }}} */
750
751 /* {{{ PHP_SOLR_API void solr_normal_param_value_display_integer(solr_param_t *solr_param, zval *param_value) */
solr_normal_param_value_display_integer(solr_param_t * solr_param,zval * param_value)752 PHP_SOLR_API void solr_normal_param_value_display_integer(solr_param_t *solr_param, zval *param_value)
753 {
754 solr_param_value_t *current_ptr = solr_param->head;
755
756 long int return_value = atol(current_ptr->contents.normal.str);
757
758 ZVAL_LONG(param_value, return_value);
759 }
760 /* }}} */
761
762 /* {{{ PHP_SOLR_API void solr_normal_param_value_display_double(solr_param_t *solr_param, zval *param_value) */
solr_normal_param_value_display_double(solr_param_t * solr_param,zval * param_value)763 PHP_SOLR_API void solr_normal_param_value_display_double(solr_param_t *solr_param, zval *param_value)
764 {
765 solr_param_value_t *current_ptr = solr_param->head;
766
767 double return_value = zend_strtod(current_ptr->contents.normal.str, (const char **) NULL);
768
769 ZVAL_DOUBLE(param_value, return_value);
770 }
771 /* }}} */
772
773 /* Checks if current_ptr->contents.normal.str matches str_const */
774 #define solr_npvdb_strcmp(str_const) (0 == strcmp(str_const, current_ptr->contents.normal.str))
775
776 /* {{{ PHP_SOLR_API void solr_normal_param_value_display_boolean(solr_param_t *solr_param, zval *param_value) */
solr_normal_param_value_display_boolean(solr_param_t * solr_param,zval * param_value)777 PHP_SOLR_API void solr_normal_param_value_display_boolean(solr_param_t *solr_param, zval *param_value)
778 {
779 solr_param_value_t *current_ptr = solr_param->head;
780
781 zend_bool return_value = (zend_bool) (solr_npvdb_strcmp("true") || solr_npvdb_strcmp("on") );
782
783 ZVAL_BOOL(param_value, return_value);
784 }
785 /* }}} */
786
787 /* {{{ PHP_SOLR_API void solr_normal_param_value_display_sort_type(solr_param_t *solr_param, zval *param_value) */
solr_normal_param_value_display_sort_type(solr_param_t * solr_param,zval * param_value)788 PHP_SOLR_API void solr_normal_param_value_display_sort_type(solr_param_t *solr_param, zval *param_value)
789 {
790 solr_param_value_t *current_ptr = solr_param->head;
791
792 long int return_value = (long int) (solr_npvdb_strcmp("count"));
793
794 ZVAL_LONG(param_value, return_value);
795 }
796 /* }}} */
797
798 /* {{{ PHP_SOLR_API void solr_normal_param_value_display(solr_param_t *solr_param, zval *param_value_array) */
solr_normal_param_value_display(solr_param_t * solr_param,zval * param_value_array)799 PHP_SOLR_API void solr_normal_param_value_display(solr_param_t *solr_param, zval *param_value_array)
800 {
801 solr_param_value_t *current_ptr = solr_param->head;
802
803 while (current_ptr != NULL)
804 {
805 add_next_index_stringl(param_value_array, current_ptr->contents.normal.str, current_ptr->contents.normal.len);
806
807 current_ptr = current_ptr->next;
808 }
809 }
810 /* }}} */
811
812 /* {{{ PHP_SOLR_API void solr_simple_list_param_value_display(solr_param_t *solr_param, zval *param_value_array) */
solr_simple_list_param_value_display(solr_param_t * solr_param,zval * param_value_array)813 PHP_SOLR_API void solr_simple_list_param_value_display(solr_param_t *solr_param, zval *param_value_array)
814 {
815 solr_param_value_t *current_ptr = solr_param->head;
816
817 while (current_ptr != NULL)
818 {
819 add_next_index_stringl(param_value_array, current_ptr->contents.simple_list.str, current_ptr->contents.simple_list.len);
820
821 current_ptr = current_ptr->next;
822 }
823 }
824 /* }}} */
825
826 /* {{{ PHP_SOLR_API void solr_arg_list_param_value_display(solr_param_t *solr_param, zval *param_value_array) */
solr_arg_list_param_value_display(solr_param_t * solr_param,zval * param_value_array)827 PHP_SOLR_API void solr_arg_list_param_value_display(solr_param_t *solr_param, zval *param_value_array)
828 {
829 solr_param_value_t *current_ptr = solr_param->head;
830
831 while (current_ptr != NULL)
832 {
833 solr_string_t tmp_buffer;
834
835 memset(&tmp_buffer, 0, sizeof(solr_string_t));
836
837 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.value));
838
839 solr_string_appendc(&tmp_buffer, solr_param->arg_separator);
840
841 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.arg));
842
843 add_next_index_stringl(param_value_array, tmp_buffer.str, tmp_buffer.len);
844
845 solr_string_free(&tmp_buffer);
846
847 current_ptr = current_ptr->next;
848 }
849 }
850 /* }}} */
851
852 /* }}} */
853
854 /* {{{ Parameter retrieval functions. Only used for toString() */
855
856 /* {{{ PHP_SOLR_API void solr_normal_param_value_tostring(solr_param_t *solr_param, solr_string_t *buffer, zend_bool url_encode) */
solr_normal_param_value_tostring(solr_param_t * solr_param,solr_string_t * buffer,zend_bool url_encode)857 PHP_SOLR_API void solr_normal_param_value_tostring(solr_param_t *solr_param, solr_string_t *buffer, zend_bool url_encode)
858 {
859 solr_param_value_t *current_ptr = solr_param->head;
860
861 solr_char_t glue = '&';
862
863 if (!solr_param->allow_multiple)
864 {
865 zend_string *url_encoded_param_value = NULL;
866
867 if (url_encode)
868 {
869 url_encoded_param_value = php_raw_url_encode((char *) current_ptr->contents.normal.str, current_ptr->contents.normal.len);
870 } else {
871 url_encoded_param_value = zend_string_init(current_ptr->contents.normal.str, current_ptr->contents.normal.len, 0);
872 }
873
874 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
875
876 solr_string_appendc(buffer, '=');
877
878 solr_string_appends(buffer, url_encoded_param_value->val, url_encoded_param_value->len);
879
880 zend_string_release(url_encoded_param_value);
881
882 } else {
883
884 zend_ulong n_loops = solr_param->count - 1;
885 zend_string *url_encoded_param_value = NULL;
886
887 while(n_loops)
888 {
889 if (url_encode)
890 {
891 url_encoded_param_value = php_raw_url_encode(current_ptr->contents.normal.str, current_ptr->contents.normal.len);
892 } else {
893 url_encoded_param_value = zend_string_init(current_ptr->contents.normal.str, current_ptr->contents.normal.len, 0);
894 }
895
896 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
897
898 solr_string_appendc(buffer, '=');
899
900 solr_string_appends(buffer, url_encoded_param_value->val, url_encoded_param_value->len);
901
902 zend_string_free(url_encoded_param_value);
903
904 url_encoded_param_value = NULL;
905
906 solr_string_appendc(buffer, glue);
907
908 n_loops--;
909
910 current_ptr = current_ptr->next;
911 }
912
913 if (url_encode)
914 {
915 url_encoded_param_value = php_raw_url_encode(current_ptr->contents.normal.str, current_ptr->contents.normal.len);
916
917 } else {
918 url_encoded_param_value = zend_string_init(current_ptr->contents.normal.str, current_ptr->contents.normal.len, 0);
919 }
920
921 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
922 solr_string_appendc(buffer, '=');
923 solr_string_appends(buffer, url_encoded_param_value->val, url_encoded_param_value->len);
924
925 zend_string_free(url_encoded_param_value);
926
927 url_encoded_param_value = NULL;
928 }
929 }
930 /* }}} */
931
932 /* {{{ PHP_SOLR_API void solr_simple_list_param_value_tostring(solr_param_t *solr_param, solr_string_t *buffer, zend_bool url_encode) */
solr_simple_list_param_value_tostring(solr_param_t * solr_param,solr_string_t * buffer,zend_bool url_encode)933 PHP_SOLR_API void solr_simple_list_param_value_tostring(solr_param_t *solr_param, solr_string_t *buffer, zend_bool url_encode)
934 {
935 solr_param_value_t *current_ptr = solr_param->head;
936 solr_char_t list_delimiter = solr_param->delimiter; /* Comma 0x2C */
937 zend_ulong n_loops = solr_param->count - 1;
938 auto solr_string_t tmp_buffer;
939 zend_string *url_encoded_list = NULL;
940
941 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
942 solr_string_appendc(buffer, '=');
943
944 memset(&tmp_buffer, 0, sizeof(solr_string_t));
945
946 while(n_loops)
947 {
948 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.simple_list));
949
950 solr_string_appendc(&tmp_buffer, list_delimiter);
951
952 n_loops--;
953
954 current_ptr = current_ptr->next;
955 }
956
957 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.simple_list));
958
959 if (url_encode)
960 {
961 url_encoded_list = php_raw_url_encode(tmp_buffer.str, tmp_buffer.len);
962 } else {
963 url_encoded_list = zend_string_init(tmp_buffer.str, tmp_buffer.len, 0);
964 }
965
966 solr_string_appends(buffer, url_encoded_list->val, url_encoded_list->len);
967
968 zend_string_free(url_encoded_list);
969
970 url_encoded_list = NULL;
971
972 solr_string_free(&tmp_buffer);
973 }
974 /* }}} */
975
976 /* {{{ PHP_SOLR_API void solr_arg_list_param_value_tostring(solr_param_t *solr_param, solr_string_t *buffer, zend_bool url_encode) */
solr_arg_list_param_value_tostring(solr_param_t * solr_param,solr_string_t * buffer,zend_bool url_encode)977 PHP_SOLR_API void solr_arg_list_param_value_tostring(solr_param_t *solr_param, solr_string_t *buffer, zend_bool url_encode)
978 {
979 solr_param_value_t *current_ptr = solr_param->head;
980 solr_char_t list_delimiter = solr_param->delimiter;
981 solr_char_t separator = solr_param->arg_separator;
982 zend_ulong n_loops = solr_param->count - 1;
983 solr_string_t tmp_buffer;
984 zend_string *url_encoded_list = NULL;
985
986 solr_string_appends(buffer, solr_param->param_name, solr_param->param_name_length);
987 solr_string_appendc(buffer, '=');
988
989 memset(&tmp_buffer, 0, sizeof(solr_string_t));
990
991 while(n_loops)
992 {
993 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.value));
994
995 if(current_ptr->contents.arg_list.delimiter_overriden)
996 {
997 if(strlen(current_ptr->contents.arg_list.delimiter_override) > 0)
998 {
999 solr_string_appendc(&tmp_buffer, (*current_ptr->contents.arg_list.delimiter_override));
1000 }
1001 }else{
1002 solr_string_appendc(&tmp_buffer, separator);
1003 }
1004
1005 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.arg));
1006
1007 solr_string_appendc(&tmp_buffer, list_delimiter);
1008
1009 n_loops--;
1010
1011 current_ptr = current_ptr->next;
1012 }
1013 /* process last parameter value */
1014 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.value));
1015 /* check for separator override */
1016 if(current_ptr->contents.arg_list.delimiter_overriden)
1017 {
1018 if(strlen(current_ptr->contents.arg_list.delimiter_override) > 0)
1019 {
1020 solr_string_appendc(&tmp_buffer, (*current_ptr->contents.arg_list.delimiter_override));
1021 }
1022 }else{
1023 solr_string_appendc(&tmp_buffer, separator);
1024 }
1025
1026 solr_string_append_solr_string(&tmp_buffer, &(current_ptr->contents.arg_list.arg));
1027
1028 if (url_encode)
1029 {
1030 url_encoded_list = php_raw_url_encode(tmp_buffer.str, tmp_buffer.len);
1031 } else {
1032 url_encoded_list = zend_string_init(tmp_buffer.str, tmp_buffer.len, 0);
1033 }
1034
1035 solr_string_appends(buffer, url_encoded_list->val, url_encoded_list->len);
1036
1037 zend_string_free(url_encoded_list);
1038
1039 url_encoded_list = NULL;
1040
1041 solr_string_free(&tmp_buffer);
1042 }
1043 /* }}} */
1044
1045 /* }}} */
1046
1047 /* {{{ Memory deallocation functions for parameter values */
1048
1049 /* {{{ PHP_SOLR_API void solr_normal_param_value_free(solr_param_value_t *param_value) */
solr_normal_param_value_free(solr_param_value_t * param_value)1050 PHP_SOLR_API void solr_normal_param_value_free(solr_param_value_t *param_value)
1051 {
1052 if (param_value)
1053 {
1054 solr_string_free(&(param_value->contents.normal));
1055
1056 pefree(param_value, SOLR_PARAMS_PERSISTENT);
1057
1058 param_value = NULL;
1059 }
1060 }
1061 /* }}} */
1062
1063 /* {{{ PHP_SOLR_API void solr_simple_list_param_value_free(solr_param_value_t *param_value) */
solr_simple_list_param_value_free(solr_param_value_t * param_value)1064 PHP_SOLR_API void solr_simple_list_param_value_free(solr_param_value_t *param_value)
1065 {
1066 if (param_value)
1067 {
1068 solr_string_free(&(param_value->contents.simple_list));
1069
1070 pefree(param_value, SOLR_PARAMS_PERSISTENT);
1071
1072 param_value = NULL;
1073 }
1074 }
1075 /* }}} */
1076
1077 /* {{{ PHP_SOLR_API void solr_arg_list_param_value_free(solr_param_value_t *param_value) */
solr_arg_list_param_value_free(solr_param_value_t * param_value)1078 PHP_SOLR_API void solr_arg_list_param_value_free(solr_param_value_t *param_value)
1079 {
1080 if (param_value)
1081 {
1082 solr_string_free(&(param_value->contents.arg_list.value));
1083
1084 solr_string_free(&(param_value->contents.arg_list.arg));
1085
1086 if(param_value->contents.arg_list.delimiter_override != NULL){
1087 efree(param_value->contents.arg_list.delimiter_override);
1088 }
1089
1090 pefree(param_value, SOLR_PARAMS_PERSISTENT);
1091
1092 param_value = NULL;
1093 }
1094 }
1095 /* }}} */
1096
1097 /* {{{ PHP_SOLR_API void solr_set_return_solr_params_object(zval *return_value_ptr, zval *current_objptr) */
solr_set_return_solr_params_object(zval * return_value_ptr,zval * current_objptr)1098 PHP_SOLR_API void solr_set_return_solr_params_object(zval *return_value_ptr, zval *current_objptr)
1099 {
1100 #ifdef PHP_7
1101 ZVAL_COPY(return_value_ptr, current_objptr);
1102 #else
1103 zval_ptr_dtor(return_value_ptr);
1104 ZVAL_MAKE_REF(current_objptr);
1105 Z_ADDREF_P(current_objptr);
1106 return_value_ptr = current_objptr;
1107 #endif
1108 }
1109 /* }}} */
1110
1111 /* {{{ PHP_SOLR_API int solr_delete_solr_parameter(zval *objptr, solr_char_t *name, int name_length) */
solr_delete_solr_parameter(zval * objptr,solr_char_t * name,int name_length)1112 PHP_SOLR_API int solr_delete_solr_parameter(zval *objptr, solr_char_t *name, int name_length)
1113 {
1114 solr_params_t *solr_params = NULL;
1115 HashTable *params_ht = NULL;
1116
1117 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
1118
1119 php_error_docref(NULL, E_ERROR, "SolrParams instance could not be retrieved from HashTable");
1120
1121 return FAILURE;
1122 }
1123
1124 params_ht = solr_params->params;
1125
1126 if (zend_hash_str_del(params_ht, name, name_length) == FAILURE)
1127 {
1128 php_error_docref(NULL, E_NOTICE, "parameter '%s' was not set. Attempting to remove an undefined parameter.", name);
1129
1130 return FAILURE;
1131 }
1132
1133 return SUCCESS;
1134 }
1135 /* }}} */
1136
1137 /* {{{ PHP_SOLR_API int solr_delete_normal_param_value(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length) */
solr_delete_normal_param_value(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length)1138 PHP_SOLR_API int solr_delete_normal_param_value(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length)
1139 {
1140 solr_params_t *solr_params = NULL;
1141 HashTable *params_ht = NULL;
1142 solr_param_t *param_ptr = NULL;
1143 solr_param_value_t *target_value = NULL;
1144
1145 if (!pname_length)
1146 {
1147 php_error_docref(NULL, E_ERROR, "Invalid parameter name");
1148
1149 return FAILURE;
1150 }
1151
1152 if (!pvalue_length)
1153 {
1154 php_error_docref(NULL, E_ERROR, "Invalid parameter value");
1155
1156 return FAILURE;
1157 }
1158
1159 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
1160
1161 php_error_docref(NULL, E_ERROR, "SolrParams instance could not be retrieved from HashTable");
1162
1163 return FAILURE;
1164 }
1165
1166 params_ht = solr_params->params;
1167
1168 if ((param_ptr = zend_hash_str_find_ptr(params_ht, pname, pname_length)) == NULL)
1169 {
1170 php_error_docref(NULL, E_WARNING, "parameter could not be retrieved from HashTable");
1171
1172 return FAILURE;
1173 }
1174
1175 target_value = (solr_param_value_t *) pecalloc(1, sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
1176
1177 solr_string_appends(&(target_value->contents.normal), pvalue, pvalue_length);
1178
1179 solr_params_delete_param_value(param_ptr, target_value);
1180
1181 /* We are done with target_value. */
1182 param_ptr->value_free_func(target_value);
1183
1184 if (param_ptr->count < 1U)
1185 {
1186 zend_hash_str_del(params_ht, pname, pname_length);
1187
1188 #if SOLR_DEBUG
1189 php_error_docref(NULL, E_NOTICE, "Deleted last value from parameter. Removing parameter '%s' from object instance.", pname);
1190 #endif
1191
1192 }
1193
1194 return SUCCESS;
1195 }
1196 /* }}} */
1197
1198 /* {{{ PHP_SOLR_API int solr_delete_simple_list_param_value(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length) */
solr_delete_simple_list_param_value(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length)1199 PHP_SOLR_API int solr_delete_simple_list_param_value(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length)
1200 {
1201 solr_params_t *solr_params = NULL;
1202 solr_param_t *param_ptr = NULL;
1203 HashTable *params_ht = NULL;
1204 solr_param_value_t *target_value = NULL;
1205
1206 if (!pname_length)
1207 {
1208 php_error_docref(NULL, E_ERROR, "Invalid parameter name");
1209
1210 return FAILURE;
1211 }
1212
1213 if (!pvalue_length)
1214 {
1215 php_error_docref(NULL, E_ERROR, "Invalid parameter value");
1216
1217 return FAILURE;
1218 }
1219
1220 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
1221
1222 php_error_docref(NULL, E_ERROR, "SolrParams instance could not be retrieved from HashTable");
1223
1224 return FAILURE;
1225 }
1226
1227 params_ht = solr_params->params;
1228
1229 if ((param_ptr = zend_hash_str_find_ptr(params_ht, pname, pname_length)) == NULL)
1230 {
1231 php_error_docref(NULL, E_WARNING, "parameter could not be retrieved from HashTable");
1232
1233 return FAILURE;
1234 }
1235
1236 target_value = (solr_param_value_t *) pecalloc(1, sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
1237
1238 solr_string_appends(&(target_value->contents.simple_list), pvalue, pvalue_length);
1239
1240 solr_params_delete_param_value(param_ptr, target_value);
1241
1242 /* We are done with target_value. */
1243 param_ptr->value_free_func(target_value);
1244
1245 if (param_ptr->count < 1U)
1246 {
1247 zend_hash_str_del(params_ht, pname, pname_length);
1248
1249 #if SOLR_DEBUG
1250 php_error_docref(NULL, E_NOTICE, "Deleted last value from parameter. Removing parameter '%s' from object instance.", pname);
1251 #endif
1252
1253 }
1254
1255 return SUCCESS;
1256 }
1257 /* }}} */
1258
1259 /* {{{ PHP_SOLR_API int solr_delete_arg_list_param_value(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length) */
solr_delete_arg_list_param_value(zval * objptr,solr_char_t * pname,int pname_length,solr_char_t * pvalue,int pvalue_length)1260 PHP_SOLR_API int solr_delete_arg_list_param_value(zval *objptr, solr_char_t *pname, int pname_length, solr_char_t *pvalue, int pvalue_length)
1261 {
1262 solr_params_t *solr_params = NULL;
1263 HashTable *params_ht = NULL;
1264 solr_param_t *param_ptr = NULL;
1265 solr_param_value_t *target_value = NULL;
1266
1267 if (!pname_length)
1268 {
1269 php_error_docref(NULL, E_ERROR, "Invalid parameter name");
1270
1271 return FAILURE;
1272 }
1273
1274 if (!pvalue_length)
1275 {
1276 php_error_docref(NULL, E_ERROR, "Invalid parameter value");
1277
1278 return FAILURE;
1279 }
1280
1281 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
1282
1283 php_error_docref(NULL, E_WARNING, "SolrParams instance could not be retrieved from HashTable");
1284
1285 return FAILURE;
1286 }
1287
1288 params_ht = solr_params->params;
1289
1290 if ((param_ptr = zend_hash_str_find_ptr(params_ht, pname, pname_length)) == NULL)
1291 {
1292 php_error_docref(NULL, E_WARNING, "parameter could not be retrieved from HashTable");
1293
1294 return FAILURE;
1295 }
1296
1297 target_value = (solr_param_value_t *) pecalloc(1, sizeof(solr_param_value_t), SOLR_PARAMS_PERSISTENT);
1298
1299 solr_string_appends(&(target_value->contents.arg_list.value), pvalue, pvalue_length);
1300
1301 solr_params_delete_param_value(param_ptr, target_value);
1302
1303 /* We are done with target_value. */
1304 param_ptr->value_free_func(target_value);
1305
1306 if (param_ptr->count < 1U)
1307 {
1308 zend_hash_str_del(params_ht, pname, pname_length);
1309
1310 #if SOLR_DEBUG
1311 php_error_docref(NULL, E_NOTICE, "Deleted last value from parameter. Removing parameter '%s' from object instance.", pname);
1312 #endif
1313
1314 }
1315
1316 return SUCCESS;
1317 }
1318 /* }}} */
1319
1320 /* }}} */
1321
1322 /* {{{ PHP_SOLR_API int solr_param_find(zval *objptr, solr_char_t *pname, int pname_length, solr_param_t **solr_param) */
solr_param_find(zval * objptr,solr_char_t * pname,int pname_length,solr_param_t ** solr_param)1323 PHP_SOLR_API int solr_param_find(zval *objptr, solr_char_t *pname, int pname_length, solr_param_t **solr_param)
1324 {
1325 solr_params_t *solr_params = NULL;
1326 HashTable *params_ht = NULL;
1327
1328 solr_param_t *solr_param_tmp = NULL;
1329
1330 if (!pname_length) {
1331
1332 php_error_docref(NULL, E_ERROR, "Invalid parameter name");
1333
1334 return FAILURE;
1335 }
1336
1337 if (solr_fetch_params_entry(objptr, &solr_params) == FAILURE) {
1338
1339 php_error_docref(NULL, E_ERROR, "SolrParams instance could not be retrieved from HashTable");
1340
1341 return FAILURE;
1342 }
1343
1344 params_ht = solr_params->params;
1345
1346 if ((solr_param_tmp = zend_hash_str_find_ptr(params_ht, pname, pname_length)) == NULL) {
1347
1348 return FAILURE;
1349 }
1350
1351 (*solr_param) = solr_param_tmp;
1352
1353 return SUCCESS;
1354 }
1355
1356 /* }}} */
1357
solr_params_to_string(solr_params_t * solr_params,zend_bool url_encode)1358 PHP_SOLR_API solr_string_t solr_params_to_string(solr_params_t * solr_params, zend_bool url_encode)
1359 {
1360 HashTable *params = solr_params->params;
1361
1362 solr_string_t tmp_buffer;
1363
1364 memset(&tmp_buffer, 0, sizeof(solr_string_t));
1365
1366 SOLR_HASHTABLE_FOR_LOOP(params)
1367 {
1368 solr_param_t *solr_param_ptr = NULL;
1369 solr_param_tostring_func_t tostring_func = NULL;
1370
1371 solr_param_ptr = zend_hash_get_current_data_ptr(params);
1372
1373 switch(solr_param_ptr->type)
1374 {
1375 case SOLR_PARAM_TYPE_NORMAL :
1376 tostring_func = solr_normal_param_value_tostring;
1377 break;
1378
1379 case SOLR_PARAM_TYPE_SIMPLE_LIST :
1380 tostring_func = solr_simple_list_param_value_tostring;
1381 break;
1382
1383 case SOLR_PARAM_TYPE_ARG_LIST :
1384 tostring_func = solr_arg_list_param_value_tostring;
1385 break;
1386
1387 default :
1388 php_error_docref(NULL, E_WARNING, "Invalid parameter type");
1389 }
1390
1391 tostring_func(solr_param_ptr, &(tmp_buffer), url_encode);
1392
1393 solr_string_appendc(&(tmp_buffer), '&');
1394 }
1395
1396 if (tmp_buffer.str && tmp_buffer.len)
1397 {
1398 solr_string_remove_last_char(&(tmp_buffer));
1399 }
1400
1401 return tmp_buffer;
1402 }
1403
1404 /*
1405 * Local variables:
1406 * tab-width: 4
1407 * c-basic-offset: 4
1408 * indent-tabs-mode: t
1409 * End:
1410 * vim600: fdm=marker
1411 * vim: noet sw=4 ts=4
1412 */
1413