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_from_array(void *p TSRMLS_DC, int argc, va_list argv, zend_hash_key *key)
  88 {
  89         zval **zparam = p;
  90         unsigned j, *i = va_arg(argv, unsigned *);
  91         smart_str *s = va_arg(argv, smart_str *);
  92         char *tmp;
  93         size_t len;
  94         int tmp_len;
  95
  96         if ((*i)++) {
  97                 smart_str_appendc(s, ',');
  98         }
  99
 100         switch (Z_TYPE_PP(zparam)) {
 101         case IS_NULL:
 102                 smart_str_appends(s, "NULL");
 103                 break;
 104
 105         case IS_BOOL:
 106                 smart_str_appends(s, Z_BVAL_PP(zparam) ? "t" : "f");
 107                 break;
 108
 109         case IS_LONG:
 110                 smart_str_append_long(s, Z_LVAL_PP(zparam));
 111                 break;
 112
 113         case IS_DOUBLE:
 114                 len = spprintf(&tmp, 0, "%F", Z_DVAL_PP(zparam));
 115                 smart_str_appendl(s, tmp, len);
 116                 efree(tmp);
 117                 break;
 118
 119         case IS_ARRAY:
 120                 j = 0;
 121                 smart_str_appendc(s, '{');
 122                 zend_hash_apply_with_arguments(Z_ARRVAL_PP(zparam) TSRMLS_CC, apply_to_param_from_array, 2, &j, s);
 123                 smart_str_appendc(s, '}');
 124                 break;
 125
 126         default:
 127         {
 128                 SEPARATE_ZVAL(zparam);
 129                 if (Z_TYPE_PP(zparam) != IS_STRING) {
 130                         convert_to_string(*zparam);
 131                 }
 132
 133                 tmp = php_addslashes(Z_STRVAL_PP(zparam), Z_STRLEN_PP(zparam), &tmp_len, 0 TSRMLS_CC);
 134                 smart_str_appendc(s, '"');
 135                 smart_str_appendl(s, tmp, tmp_len);
 136                 smart_str_appendc(s, '"');
 137
 138                 if (*zparam != *((zval **) p)) {
 139                         zval_ptr_dtor(zparam);
 140                 }
 141                 break;
 142         }
 143         }
 144
 145         ++(*i);
 146         return ZEND_HASH_APPLY_KEEP;
 147 }
 148
 149 static void array_param_to_string(HashTable *ht, char **str, int *len TSRMLS_DC)
 150 {
 151         smart_str s = {0};
 152         unsigned i = 0;
 153
 154         smart_str_appendc(&s, '{');
 155         zend_hash_apply_with_arguments(ht TSRMLS_CC, apply_to_param_from_array, 2, &i, &s);
 156         smart_str_appendc(&s, '}');
 157
 158         smart_str_0(&s);
 159         *str = s.c;
 160         *len = s.len;
 161 }
 162
 163 static int apply_to_param(void *p TSRMLS_DC, int argc, va_list argv, zend_hash_key *key)
 164 {
 165         char ***params;
 166         HashTable *zdtor;
 167         zval **zparam = p;
 168
 169         params = (char ***) va_arg(argv, char ***);
 170         zdtor = (HashTable *) va_arg(argv, HashTable *);
 171
 172         switch (Z_TYPE_PP(zparam)) {
 173         case IS_NULL:
 174                 **params = NULL;
 175                 ++*params;
 176                 return ZEND_HASH_APPLY_KEEP;
 177
 178         case IS_BOOL:
 179                 **params = Z_BVAL_PP(zparam) ? "t" : "f";
 180                 ++*params;
 181                 return ZEND_HASH_APPLY_KEEP;
 182
 183         case IS_DOUBLE:
 184                 SEPARATE_ZVAL(zparam);
 185                 Z_TYPE_PP(zparam) = IS_STRING;
 186                 Z_STRLEN_PP(zparam) = spprintf(&Z_STRVAL_PP(zparam), 0, "%F", Z_DVAL_PP((zval **)p));
 187                 break;
 188
 189         case IS_ARRAY:
 190         {
 191                 zval *tmp;
 192                 MAKE_STD_ZVAL(tmp);
 193                 Z_TYPE_P(tmp) = IS_STRING;
 194                 array_param_to_string(Z_ARRVAL_PP(zparam), &Z_STRVAL_P(tmp), &Z_STRLEN_P(tmp) TSRMLS_CC);
 195                 zparam = &tmp;
 196                 break;
 197         }
 198
 199         default:
 200                 convert_to_string_ex(zparam);
 201                 break;
 202         }
 203
 204         **params = Z_STRVAL_PP(zparam);
 205         ++*params;
 206
 207         if (*zparam != *(zval **)p) {
 208                 zend_hash_next_index_insert(zdtor, zparam, sizeof(zval *), NULL);
 209         }
 210         return ZEND_HASH_APPLY_KEEP;
 211 }
 212
 213 int php_pq_types_to_array(HashTable *ht, Oid **types TSRMLS_DC)
 214 {
 215         int count = zend_hash_num_elements(ht);
 216
 217         *types = NULL;
 218
 219         if (count) {
 220                 Oid *tmp;
 221
 222                 /* +1 for when less types than params are specified */
 223                 *types = tmp = ecalloc(count + 1, sizeof(**types));
 224                 zend_hash_apply_with_argument(ht, apply_to_oid, &tmp TSRMLS_CC);
 225         }
 226
 227         return count;
 228 }
 229
 230 int php_pq_params_to_array(HashTable *ht, char ***params, HashTable *zdtor TSRMLS_DC)
 231 {
 232         int count = zend_hash_num_elements(ht);
 233
 234         *params = NULL;
 235
 236         if (count) {
 237                 char **tmp;
 238
 239                 *params = tmp = ecalloc(count, sizeof(char *));
 240                 zend_hash_apply_with_arguments(ht TSRMLS_CC, apply_to_param, 2, &tmp, zdtor);
 241         }
 242
 243         return count;
 244 }
 245
 246 /*
 247 Oid *php_pq_ntypes_to_array(zend_bool fill, int argc, ...)
 248 {
 249         int i;
 250         Oid *oids = ecalloc(argc + 1, sizeof(*oids));
 251         va_list argv;
 252
 253         va_start(argv, argc);
 254         for (i = 0; i < argc; ++i) {
 255                 if (!fill || !i) {
 256                         oids[i] = va_arg(argv, Oid);
 257                 } else {
 258                         oids[i] = oids[0];
 259                 }
 260         }
 261         va_end(argv);
 262
 263         return oids;
 264 }
 265 */
 266
 267 zend_class_entry *php_pqdt_class_entry;
 268
 269 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_to_string, 0, 0, 0)
 270 ZEND_END_ARG_INFO();
 271 static PHP_METHOD(pqdt, __toString)
 272 {
 273         zval *rv;
 274
 275         zend_call_method_with_1_params(&getThis(), php_pqdt_class_entry, NULL, "format", &rv,
 276                         zend_read_property(php_pqdt_class_entry, getThis(), ZEND_STRL("format"), 0 TSRMLS_CC));
 277         RETVAL_ZVAL(rv, 1, 1);
 278 }
 279
 280 static zend_function_entry php_pqdt_methods[] = {
 281         PHP_ME(pqdt, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 282         PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 283         {0}
 284 };
 285
 286 zval *php_pqdt_from_string(char *dt_str, size_t dt_len, char *fmt, zval *zv TSRMLS_DC)
 287 {
 288         php_date_obj *dobj;
 289
 290         if (!zv) {
 291                 MAKE_STD_ZVAL(zv);
 292         }
 293
 294         php_date_instantiate(php_pqdt_class_entry, zv TSRMLS_CC);
 295         dobj = zend_object_store_get_object(zv TSRMLS_CC);
 296         if (!php_date_initialize(dobj, dt_str, dt_len, NULL, NULL, 1 TSRMLS_CC)) {
 297                 zval_dtor(zv);
 298                 ZVAL_NULL(zv);
 299         } else if (fmt) {
 300                 zend_update_property_string(php_pqdt_class_entry, zv, ZEND_STRL("format"), fmt TSRMLS_CC);
 301         }
 302
 303         return zv;
 304 }
 305
 306 PHP_MINIT_FUNCTION(pq_misc)
 307 {
 308         zend_class_entry **json, ce = {0};
 309
 310         INIT_NS_CLASS_ENTRY(ce ,"pq", "DateTime", php_pqdt_methods);
 311         php_pqdt_class_entry = zend_register_internal_class_ex(&ce, php_date_get_date_ce(), "DateTime" TSRMLS_CC);
 312
 313         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);
 314
 315         /* stop reading this file right here! */
 316         if (SUCCESS == zend_hash_find(CG(class_table), ZEND_STRS("jsonserializable"), (void *) &json)) {
 317                 zend_class_implements(php_pqdt_class_entry TSRMLS_CC, 1, *json);
 318         }
 319
 320         return SUCCESS;
 321 }
 322
 323 typedef struct _HashTableList {
 324         HashTable ht;
 325         struct _HashTableList *parent;
 326 } HashTableList;
 327
 328 typedef struct _ArrayParserState {
 329         const char *ptr, *end;
 330         HashTableList *list;
 331 #ifdef ZTS
 332         void ***ts;
 333 #endif
 334         Oid typ;
 335         unsigned quotes:1;
 336         unsigned escaped:1;
 337 } ArrayParserState;
 338
 339 static char caa(ArrayParserState *a, const char *any, unsigned advance)
 340 {
 341         const char *p = any;
 342         TSRMLS_FETCH_FROM_CTX(a->ts);
 343
 344         do {
 345                 if (*p == *a->ptr) {
 346                         a->ptr += advance;
 347                         return *p;
 348                 }
 349         } while (*++p);
 350
 351         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse array: expected one of '%s', got '%c'", any, *a->ptr); \
 352         return 0;
 353 }
 354
 355 static STATUS add_element(ArrayParserState *a, const char *start)
 356 {
 357         zval *zelem;
 358         size_t el_len = a->ptr - start;
 359         char *el_str = estrndup(start, el_len);
 360         TSRMLS_FETCH_FROM_CTX(a->ts);
 361
 362         if (a->quotes) {
 363                 int tmp_len = el_len;
 364
 365                 php_stripslashes(el_str, &tmp_len TSRMLS_CC);
 366                 el_len = tmp_len;
 367         } else if ((a->ptr - start == 4) && !strncmp(start, "NULL", 4)) {
 368                 efree(el_str);
 369                 el_str = NULL;
 370                 el_len = 0;
 371         }
 372
 373         if (!el_str) {
 374                 MAKE_STD_ZVAL(zelem);
 375                 ZVAL_NULL(zelem);
 376         } else {
 377                 zelem = php_pq_typed_zval(el_str, el_len, a->typ TSRMLS_CC);
 378
 379                 efree(el_str);
 380         }
 381
 382         return zend_hash_next_index_insert(&a->list->ht, &zelem, sizeof(zval *), NULL);
 383 }
 384
 385 static STATUS parse_array(ArrayParserState *a);
 386
 387 static STATUS parse_element(ArrayParserState *a)
 388 {
 389         const char *el;
 390         TSRMLS_FETCH_FROM_CTX(a->ts);
 391
 392         switch (*a->ptr) {
 393         case '{':
 394                 return parse_array(a);
 395
 396         case '"':
 397                 a->quotes = 1;
 398                 ++a->ptr;
 399                 break;
 400         }
 401
 402         for (el = a->ptr; a->ptr < a->end; ++a->ptr) {
 403                 switch (*a->ptr) {
 404                 case '"':
 405                         if (a->escaped) {
 406                                 a->escaped = 0;
 407                         } else if (a->quotes) {
 408                                 if (SUCCESS != add_element(a, el)) {
 409                                         return FAILURE;
 410                                 }
 411                                 a->quotes = 0;
 412                                 ++a->ptr;
 413                                 return SUCCESS;
 414                         } else {
 415                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, unexpected quote: '%.*s'", (int) (a->ptr - el), el);
 416                                 return FAILURE;
 417                         }
 418                         break;
 419
 420                 case ',':
 421                 case '}':
 422                         if (!a->quotes) {
 423                                 return add_element(a, el);
 424                         }
 425                         break;
 426
 427                 case '\\':
 428                         a->escaped = !a->escaped;
 429                         break;
 430
 431                 default:
 432                         a->escaped = 0;
 433                         break;
 434                 }
 435         }
 436
 437         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, reached end of input");
 438         return FAILURE;
 439 }
 440
 441 static STATUS parse_elements(ArrayParserState *a)
 442 {
 443         TSRMLS_FETCH_FROM_CTX(a->ts);
 444
 445         while (SUCCESS == parse_element(a)) {
 446                 switch (caa(a, ",}", 0)) {
 447                 case 0:
 448                         return FAILURE;
 449
 450                 case '}':
 451                         return SUCCESS;
 452
 453                 default:
 454                         if (!*++a->ptr) {
 455                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse elements, reached end of input");
 456                                 return FAILURE;
 457                         }
 458                         break;
 459                 }
 460         }
 461
 462         return FAILURE;
 463 }
 464
 465 static STATUS parse_array(ArrayParserState *a)
 466 {
 467         HashTableList *list;
 468
 469         if (!caa(a, "{", 1)) {
 470                 return FAILURE;
 471         }
 472
 473         list = ecalloc(1, sizeof(*list));
 474         ZEND_INIT_SYMTABLE(&list->ht);
 475
 476         if (a->list) {
 477                 zval *zcur;
 478
 479                 MAKE_STD_ZVAL(zcur);
 480                 Z_TYPE_P(zcur) = IS_ARRAY;
 481                 Z_ARRVAL_P(zcur) = &list->ht;
 482
 483                 zend_hash_next_index_insert(&a->list->ht, &zcur, sizeof(zval *), NULL);
 484
 485                 list->parent = a->list;
 486         }
 487         a->list = list;
 488
 489         if (SUCCESS != parse_elements(a)) {
 490                 return FAILURE;
 491         }
 492
 493         if (!caa(a, "}", 1)) {
 494                 return FAILURE;
 495         }
 496
 497         if (a->list->parent) {
 498                 a->list = a->list->parent;
 499         }
 500
 501         return SUCCESS;
 502 }
 503
 504 HashTable *php_pq_parse_array(const char *val_str, size_t val_len, Oid typ TSRMLS_DC)
 505 {
 506         HashTable *ht = NULL;
 507         ArrayParserState a = {0};
 508         TSRMLS_SET_CTX(a.ts);
 509
 510         a.typ = typ;
 511         a.ptr = val_str;
 512         a.end = val_str + val_len;
 513
 514         if (SUCCESS != parse_array(&a)) {
 515                 while (a.list) {
 516                         HashTableList *l = a.list->parent;
 517
 518                         zend_hash_destroy(&a.list->ht);
 519                         efree(a.list);
 520                         a.list = l;
 521                 }
 522                 return ht;
 523         }
 524
 525         if (*a.ptr) {
 526                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Trailing input: '%s'", a.ptr);
 527         }
 528
 529         do {
 530                 ht = &a.list->ht;
 531         } while ((a.list = a.list->parent));
 532
 533         return ht;
 534 }
 535
 536 zval *php_pq_typed_zval(char *val, size_t len, Oid typ TSRMLS_DC)
 537 {
 538         zval *zv;
 539
 540         MAKE_STD_ZVAL(zv);
 541
 542         switch (typ) {
 543 #ifdef HAVE_PHP_PQ_TYPE_H
 544 #       undef PHP_PQ_TYPE
 545 #       include "php_pq_type.h"
 546         case PHP_PQ_OID_BOOL:
 547                 ZVAL_BOOL(zv, *val == 't');
 548                 break;
 549 #if SIZEOF_LONG >= 8
 550         case PHP_PQ_OID_INT8:
 551         case PHP_PQ_OID_TID:
 552 #endif
 553         case PHP_PQ_OID_INT4:
 554         case PHP_PQ_OID_INT2:
 555         case PHP_PQ_OID_XID:
 556         case PHP_PQ_OID_OID:
 557                 ZVAL_LONG(zv, zend_atol(val, len));
 558                 break;
 559
 560         case PHP_PQ_OID_FLOAT4:
 561         case PHP_PQ_OID_FLOAT8:
 562                 ZVAL_DOUBLE(zv, zend_strtod(val, NULL));
 563                 break;
 564
 565         case PHP_PQ_OID_DATE:
 566                 php_pqdt_from_string(val, len, "Y-m-d", zv TSRMLS_CC);
 567                 break;
 568
 569         case PHP_PQ_OID_ABSTIME:
 570                 php_pqdt_from_string(val, len, "Y-m-d H:i:s", zv TSRMLS_CC);
 571                 break;
 572
 573         case PHP_PQ_OID_TIMESTAMP:
 574                 php_pqdt_from_string(val, len, "Y-m-d H:i:s.u", zv TSRMLS_CC);
 575                 break;
 576
 577         case PHP_PQ_OID_TIMESTAMPTZ:
 578                 php_pqdt_from_string(val, len, "Y-m-d H:i:s.uO", zv TSRMLS_CC);
 579                 break;
 580
 581         default:
 582                 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))) {
 583                         Z_TYPE_P(zv) = IS_ARRAY;
 584                 } else {
 585                         ZVAL_STRINGL(zv, val, len, 1);
 586                 }
 587                 break;
 588 #else
 589         case 16: /* BOOL */
 590                 ZVAL_BOOL(zv, *val == 't');
 591                 break;
 592
 593         default:
 594                 ZVAL_STRINGL(zv, val, len, 1);
 595 #endif
 596         }
 597
 598         return zv;
 599 }
 600
 601 /*
 602  * Local variables:
 603  * tab-width: 4
 604  * c-basic-offset: 4
 605  * End:
 606  * vim600: noet sw=4 ts=4 fdm=marker
 607  * vim<600: noet sw=4 ts=4
 608  */