git.m6w6.name Git - m6w6/ext-pq/blob - src/php_pq_misc.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: pq                                                         |
   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) 2013, Michael Wallner <mike@php.net>                 |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #       include "config.h"
  15 #endif
  16
  17 #include <php.h>
  18 #include <ext/date/php_date.h>
  19 #include <ext/standard/php_string.h>
  20 #if defined(HAVE_JSON) && !defined(COMPILE_DL_JSON)
  21 #       include <ext/json/php_json.h>
  22 #endif
  23
  24 #include <Zend/zend_interfaces.h>
  25
  26 #include <libpq/libpq-fs.h>
  27
  28 #include "php_pq.h"
  29 #include "php_pq_misc.h"
  30
  31 char *rtrim(char *e)
  32 {
  33         size_t l = strlen(e);
  34
  35         while (l-- > 0 && e[l] == '\n') {
  36                 e[l] = '\0';
  37         }
  38         return e;
  39 }
  40
  41 const char *strmode(long mode)
  42 {
  43         switch (mode & (INV_READ|INV_WRITE)) {
  44         case INV_READ|INV_WRITE:
  45                 return "rw";
  46         case INV_READ:
  47                 return "r";
  48         case INV_WRITE:
  49                 return "w";
  50         default:
  51                 return "-";
  52         }
  53 }
  54
  55 int compare_index(const void *lptr, const void *rptr TSRMLS_DC)
  56 {
  57         const Bucket *l = *(const Bucket **) lptr;
  58         const Bucket *r = *(const Bucket **) rptr;
  59
  60         if (l->h < r->h) {
  61                 return -1;
  62         }
  63         if (l->h > r->h) {
  64                 return 1;
  65         }
  66         return 0;
  67 }
  68
  69 static int apply_to_oid(void *p, void *arg TSRMLS_DC)
  70 {
  71         Oid **types = arg;
  72         zval **ztype = p;
  73
  74         if (Z_TYPE_PP(ztype) != IS_LONG) {
  75                 convert_to_long_ex(ztype);
  76         }
  77
  78         **types = Z_LVAL_PP(ztype);
  79         ++*types;
  80
  81         if (*ztype != *(zval **)p) {
  82                 zval_ptr_dtor(ztype);
  83         }
  84         return ZEND_HASH_APPLY_KEEP;
  85 }
  86
  87 static int apply_to_param(void *p TSRMLS_DC, int argc, va_list argv, zend_hash_key *key)
  88 {
  89         char ***params;
  90         HashTable *zdtor;
  91         zval **zparam = p;
  92
  93         params = (char ***) va_arg(argv, char ***);
  94         zdtor = (HashTable *) va_arg(argv, HashTable *);
  95
  96         switch (Z_TYPE_PP(zparam)) {
  97         case IS_NULL:
  98                 **params = NULL;
  99                 ++*params;
 100                 break;
 101
 102         case IS_BOOL:
 103                 **params = Z_BVAL_PP(zparam) ? "t" : "f";
 104                 ++*params;
 105                 break;
 106
 107         case IS_DOUBLE:
 108                 SEPARATE_ZVAL(zparam);
 109                 Z_TYPE_PP(zparam) = IS_STRING;
 110                 Z_STRLEN_PP(zparam) = spprintf(&Z_STRVAL_PP(zparam), 0, "%F", Z_DVAL_PP((zval **)p));
 111                 /* no break */
 112
 113         default:
 114                 convert_to_string_ex(zparam);
 115                 /* no break */
 116
 117         case IS_STRING:
 118                 **params = Z_STRVAL_PP(zparam);
 119                 ++*params;
 120
 121                 if (*zparam != *(zval **)p) {
 122                         zend_hash_next_index_insert(zdtor, zparam, sizeof(zval *), NULL);
 123                 }
 124                 break;
 125         }
 126
 127         return ZEND_HASH_APPLY_KEEP;
 128 }
 129
 130 int php_pq_types_to_array(HashTable *ht, Oid **types TSRMLS_DC)
 131 {
 132         int count = zend_hash_num_elements(ht);
 133
 134         *types = NULL;
 135
 136         if (count) {
 137                 Oid *tmp;
 138
 139                 /* +1 for when less types than params are specified */
 140                 *types = tmp = ecalloc(count + 1, sizeof(**types));
 141                 zend_hash_apply_with_argument(ht, apply_to_oid, &tmp TSRMLS_CC);
 142         }
 143
 144         return count;
 145 }
 146
 147 int php_pq_params_to_array(HashTable *ht, char ***params, HashTable *zdtor TSRMLS_DC)
 148 {
 149         int count = zend_hash_num_elements(ht);
 150
 151         *params = NULL;
 152
 153         if (count) {
 154                 char **tmp;
 155
 156                 *params = tmp = ecalloc(count, sizeof(char *));
 157                 zend_hash_apply_with_arguments(ht TSRMLS_CC, apply_to_param, 2, &tmp, zdtor);
 158         }
 159
 160         return count;
 161 }
 162
 163 /*
 164 Oid *php_pq_ntypes_to_array(zend_bool fill, int argc, ...)
 165 {
 166         int i;
 167         Oid *oids = ecalloc(argc + 1, sizeof(*oids));
 168         va_list argv;
 169
 170         va_start(argv, argc);
 171         for (i = 0; i < argc; ++i) {
 172                 if (!fill || !i) {
 173                         oids[i] = va_arg(argv, Oid);
 174                 } else {
 175                         oids[i] = oids[0];
 176                 }
 177         }
 178         va_end(argv);
 179
 180         return oids;
 181 }
 182 */
 183
 184 zend_class_entry *php_pqdt_class_entry;
 185
 186 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_to_string, 0, 0, 0)
 187 ZEND_END_ARG_INFO();
 188 static PHP_METHOD(pqdt, __toString)
 189 {
 190         zval *rv;
 191
 192         zend_call_method_with_1_params(&getThis(), php_pqdt_class_entry, NULL, "format", &rv,
 193                         zend_read_property(php_pqdt_class_entry, getThis(), ZEND_STRL("format"), 0 TSRMLS_CC));
 194         RETVAL_ZVAL(rv, 1, 1);
 195 }
 196
 197 static zend_function_entry php_pqdt_methods[] = {
 198         PHP_ME(pqdt, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 199         PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 200         {0}
 201 };
 202
 203 zval *php_pqdt_from_string(char *dt_str, size_t dt_len, char *fmt, zval *zv TSRMLS_DC)
 204 {
 205         php_date_obj *dobj;
 206
 207         if (!zv) {
 208                 MAKE_STD_ZVAL(zv);
 209         }
 210
 211         php_date_instantiate(php_pqdt_class_entry, zv TSRMLS_CC);
 212         dobj = zend_object_store_get_object(zv TSRMLS_CC);
 213         if (!php_date_initialize(dobj, dt_str, dt_len, NULL, NULL, 1 TSRMLS_CC)) {
 214                 zval_dtor(zv);
 215                 ZVAL_NULL(zv);
 216         } else if (fmt) {
 217                 zend_update_property_string(php_pqdt_class_entry, zv, ZEND_STRL("format"), fmt TSRMLS_CC);
 218         }
 219
 220         return zv;
 221 }
 222
 223 PHP_MINIT_FUNCTION(pq_misc)
 224 {
 225         zend_class_entry **json, ce = {0};
 226
 227         INIT_NS_CLASS_ENTRY(ce ,"pq", "DateTime", php_pqdt_methods);
 228         php_pqdt_class_entry = zend_register_internal_class_ex(&ce, php_date_get_date_ce(), "DateTime" TSRMLS_CC);
 229
 230         zend_declare_property_stringl(php_pqdt_class_entry, ZEND_STRL("format"), ZEND_STRL("Y-m-d H:i:s.u"), ZEND_ACC_PUBLIC TSRMLS_CC);
 231
 232         /* stop reading this file right here! */
 233         if (SUCCESS == zend_hash_find(CG(class_table), ZEND_STRS("jsonserializable"), (void *) &json)) {
 234                 zend_class_implements(php_pqdt_class_entry TSRMLS_CC, 1, *json);
 235         }
 236
 237         return SUCCESS;
 238 }
 239
 240 typedef struct _HashTableList {
 241         HashTable ht;
 242         struct _HashTableList *parent;
 243 } HashTableList;
 244
 245 typedef struct _ArrayParserState {
 246         const char *ptr, *end;
 247         HashTableList *list;
 248 #ifdef ZTS
 249         void ***ts;
 250 #endif
 251         Oid typ;
 252         unsigned quotes:1;
 253         unsigned escaped:1;
 254 } ArrayParserState;
 255
 256 static char caa(ArrayParserState *a, const char *any, unsigned advance)
 257 {
 258         const char *p = any;
 259         TSRMLS_FETCH_FROM_CTX(a->ts);
 260
 261         do {
 262                 if (*p == *a->ptr) {
 263                         a->ptr += advance;
 264                         return *p;
 265                 }
 266         } while (*++p);
 267
 268         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse array: expected one of '%s', got '%c'", any, *a->ptr); \
 269         return 0;
 270 }
 271
 272 static STATUS add_element(ArrayParserState *a, const char *start)
 273 {
 274         zval *zelem;
 275         size_t el_len = a->ptr - start;
 276         char *el_str = estrndup(start, el_len);
 277         TSRMLS_FETCH_FROM_CTX(a->ts);
 278
 279         if (a->quotes) {
 280                 int tmp_len;
 281
 282                 php_stripslashes(el_str, &tmp_len TSRMLS_CC);
 283                 el_len = tmp_len;
 284         } else if ((a->ptr - start == 4) && !strncmp(start, "NULL", 4)) {
 285                 efree(el_str);
 286                 el_str = NULL;
 287                 el_len = 0;
 288         }
 289
 290         if (!el_str) {
 291                 MAKE_STD_ZVAL(zelem);
 292                 ZVAL_NULL(zelem);
 293         } else {
 294                 zelem = php_pq_typed_zval(el_str, el_len, a->typ TSRMLS_CC);
 295
 296                 efree(el_str);
 297         }
 298
 299         return zend_hash_next_index_insert(&a->list->ht, &zelem, sizeof(zval *), NULL);
 300 }
 301
 302 static STATUS parse_array(ArrayParserState *a);
 303
 304 static STATUS parse_element(ArrayParserState *a)
 305 {
 306         const char *el;
 307         TSRMLS_FETCH_FROM_CTX(a->ts);
 308
 309         switch (*a->ptr) {
 310         case '{':
 311                 return parse_array(a);
 312
 313         case '"':
 314                 a->quotes = 1;
 315                 ++a->ptr;
 316                 break;
 317         }
 318
 319         for (el = a->ptr; a->ptr < a->end; ++a->ptr) {
 320                 switch (*a->ptr) {
 321                 case '"':
 322                         if (a->escaped) {
 323                                 a->escaped = 0;
 324                         } else if (a->quotes) {
 325                                 if (SUCCESS != add_element(a, el)) {
 326                                         return FAILURE;
 327                                 }
 328                                 a->quotes = 0;
 329                                 ++a->ptr;
 330                                 return SUCCESS;
 331                         } else {
 332                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, unexpected quote: '%.*s'", (int) (a->ptr - el), el);
 333                                 return FAILURE;
 334                         }
 335                         break;
 336
 337                 case ',':
 338                 case '}':
 339                         if (!a->quotes) {
 340                                 return add_element(a, el);
 341                         }
 342                         break;
 343
 344                 case '\\':
 345                         a->escaped = !a->escaped;
 346                         break;
 347
 348                 default:
 349                         a->escaped = 0;
 350                         break;
 351                 }
 352         }
 353
 354         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, reached end of input");
 355         return FAILURE;
 356 }
 357
 358 static STATUS parse_elements(ArrayParserState *a)
 359 {
 360         TSRMLS_FETCH_FROM_CTX(a->ts);
 361
 362         while (SUCCESS == parse_element(a)) {
 363                 switch (caa(a, ",}", 0)) {
 364                 case 0:
 365                         return FAILURE;
 366
 367                 case '}':
 368                         return SUCCESS;
 369
 370                 default:
 371                         if (!*++a->ptr) {
 372                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse elements, reached end of input");
 373                                 return FAILURE;
 374                         }
 375                         break;
 376                 }
 377         }
 378
 379         return FAILURE;
 380 }
 381
 382 static STATUS parse_array(ArrayParserState *a)
 383 {
 384         HashTableList *list;
 385
 386         if (!caa(a, "{", 1)) {
 387                 return FAILURE;
 388         }
 389
 390         list = ecalloc(1, sizeof(*list));
 391         ZEND_INIT_SYMTABLE(&list->ht);
 392
 393         if (a->list) {
 394                 zval *zcur;
 395
 396                 MAKE_STD_ZVAL(zcur);
 397                 Z_TYPE_P(zcur) = IS_ARRAY;
 398                 Z_ARRVAL_P(zcur) = &list->ht;
 399
 400                 zend_hash_next_index_insert(&a->list->ht, &zcur, sizeof(zval *), NULL);
 401
 402                 list->parent = a->list;
 403         }
 404         a->list = list;
 405
 406         if (SUCCESS != parse_elements(a)) {
 407                 return FAILURE;
 408         }
 409
 410         if (!caa(a, "}", 1)) {
 411                 return FAILURE;
 412         }
 413
 414         if (a->list->parent) {
 415                 a->list = a->list->parent;
 416         }
 417
 418         return SUCCESS;
 419 }
 420
 421 HashTable *php_pq_parse_array(const char *val_str, size_t val_len, Oid typ TSRMLS_DC)
 422 {
 423         HashTable *ht = NULL;
 424         ArrayParserState a = {0};
 425         TSRMLS_SET_CTX(a.ts);
 426
 427         a.typ = typ;
 428         a.ptr = val_str;
 429         a.end = val_str + val_len;
 430
 431         if (SUCCESS != parse_array(&a)) {
 432                 while (a.list) {
 433                         HashTableList *l = a.list->parent;
 434
 435                         zend_hash_destroy(&a.list->ht);
 436                         efree(a.list);
 437                         a.list = l;
 438                 }
 439                 return ht;
 440         }
 441
 442         if (*a.ptr) {
 443                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Trailing input: '%s'", a.ptr);
 444         }
 445
 446         do {
 447                 ht = &a.list->ht;
 448         } while ((a.list = a.list->parent));
 449
 450         return ht;
 451 }
 452
 453 zval *php_pq_typed_zval(char *val, size_t len, Oid typ TSRMLS_DC)
 454 {
 455         zval *zv;
 456
 457         MAKE_STD_ZVAL(zv);
 458
 459         switch (typ) {
 460 #ifdef HAVE_PHP_PQ_TYPE_H
 461 #       undef PHP_PQ_TYPE
 462 #       include "php_pq_type.h"
 463         case PHP_PQ_OID_BOOL:
 464                 ZVAL_BOOL(zv, *val == 't');
 465                 break;
 466 #if SIZEOF_LONG >= 8
 467         case PHP_PQ_OID_INT8:
 468         case PHP_PQ_OID_TID:
 469 #endif
 470         case PHP_PQ_OID_INT4:
 471         case PHP_PQ_OID_INT2:
 472         case PHP_PQ_OID_XID:
 473         case PHP_PQ_OID_OID:
 474                 ZVAL_LONG(zv, zend_atol(val, len));
 475                 break;
 476
 477         case PHP_PQ_OID_FLOAT4:
 478         case PHP_PQ_OID_FLOAT8:
 479                 ZVAL_DOUBLE(zv, zend_strtod(val, NULL));
 480                 break;
 481
 482         case PHP_PQ_OID_DATE:
 483                 php_pqdt_from_string(val, len, "Y-m-d", zv TSRMLS_CC);
 484                 break;
 485
 486         case PHP_PQ_OID_ABSTIME:
 487                 php_pqdt_from_string(val, len, "Y-m-d H:i:s", zv TSRMLS_CC);
 488                 break;
 489
 490         case PHP_PQ_OID_TIMESTAMP:
 491                 php_pqdt_from_string(val, len, "Y-m-d H:i:s.u", zv TSRMLS_CC);
 492                 break;
 493
 494         case PHP_PQ_OID_TIMESTAMPTZ:
 495                 php_pqdt_from_string(val, len, "Y-m-d H:i:s.uO", zv TSRMLS_CC);
 496                 break;
 497
 498         default:
 499                 if (PHP_PQ_TYPE_IS_ARRAY(typ) && (Z_ARRVAL_P(zv) = php_pq_parse_array(val, len, PHP_PQ_TYPE_OF_ARRAY(typ) TSRMLS_CC))) {
 500                         Z_TYPE_P(zv) = IS_ARRAY;
 501                 } else {
 502                         ZVAL_STRINGL(zv, val, len, 1);
 503                 }
 504                 break;
 505         }
 506 #else
 507         case 16: /* BOOL */
 508                 ZVAL_BOOL(zv, *val == 't');
 509                 break;
 510
 511         default:
 512                 ZVAL_STRINGL(zv, val, len, 1);
 513 #endif
 514
 515         return zv;
 516 }
 517
 518 /*
 519  * Local variables:
 520  * tab-width: 4
 521  * c-basic-offset: 4
 522  * End:
 523  * vim600: noet sw=4 ts=4 fdm=marker
 524  * vim<600: noet sw=4 ts=4
 525  */