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 zend_class_entry *php_pqdt_class_entry;
  70
  71 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_to_string, 0, 0, 0)
  72 ZEND_END_ARG_INFO();
  73 static PHP_METHOD(pqdt, __toString)
  74 {
  75         zval *rv;
  76
  77         zend_call_method_with_1_params(&getThis(), php_pqdt_class_entry, NULL, "format", &rv,
  78                         zend_read_property(php_pqdt_class_entry, getThis(), ZEND_STRL("format"), 0 TSRMLS_CC));
  79         RETVAL_ZVAL(rv, 1, 1);
  80 }
  81
  82 static zend_function_entry php_pqdt_methods[] = {
  83         PHP_ME(pqdt, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
  84         PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
  85         {0}
  86 };
  87
  88 zval *php_pqdt_from_string(char *dt_str, size_t dt_len, char *fmt, zval *zv TSRMLS_DC)
  89 {
  90         php_date_obj *dobj;
  91
  92         if (!zv) {
  93                 MAKE_STD_ZVAL(zv);
  94         }
  95
  96         php_date_instantiate(php_pqdt_class_entry, zv TSRMLS_CC);
  97         dobj = zend_object_store_get_object(zv TSRMLS_CC);
  98         if (!php_date_initialize(dobj, dt_str, dt_len, NULL, NULL, 1 TSRMLS_CC)) {
  99                 zval_dtor(zv);
 100                 ZVAL_NULL(zv);
 101         } else if (fmt) {
 102                 zend_update_property_string(php_pqdt_class_entry, zv, ZEND_STRL("format"), fmt TSRMLS_CC);
 103         }
 104
 105         return zv;
 106 }
 107
 108 zend_class_entry *php_pqconv_class_entry;
 109
 110 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_types, 0, 0, 0)
 111 ZEND_END_ARG_INFO();
 112
 113 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_from_string, 0, 0, 1)
 114         ZEND_ARG_INFO(0, data)
 115 ZEND_END_ARG_INFO();
 116
 117 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_to_string, 0, 0, 1)
 118         ZEND_ARG_INFO(0, data)
 119 ZEND_END_ARG_INFO();
 120
 121 zend_function_entry php_pqconv_methods[] = {
 122         PHP_ABSTRACT_ME(pqconv, convertTypes, ai_pqconv_convert_types)
 123         PHP_ABSTRACT_ME(pqconv, convertFromString, ai_pqconv_convert_from_string)
 124         PHP_ABSTRACT_ME(pqconv, convertToString, ai_pqconv_convert_to_string)
 125         {0}
 126 };
 127
 128
 129 PHP_MINIT_FUNCTION(pq_misc)
 130 {
 131         zend_class_entry **json, ce = {0};
 132
 133         INIT_NS_CLASS_ENTRY(ce, "pq", "ConverterInterface", php_pqconv_methods);
 134         php_pqconv_class_entry = zend_register_internal_interface(&ce TSRMLS_CC);
 135
 136         memset(&ce, 0, sizeof(ce));
 137         INIT_NS_CLASS_ENTRY(ce ,"pq", "DateTime", php_pqdt_methods);
 138         php_pqdt_class_entry = zend_register_internal_class_ex(&ce, php_date_get_date_ce(), "DateTime" TSRMLS_CC);
 139
 140         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);
 141
 142         /* stop reading this file right here! */
 143         if (SUCCESS == zend_hash_find(CG(class_table), ZEND_STRS("jsonserializable"), (void *) &json)) {
 144                 zend_class_implements(php_pqdt_class_entry TSRMLS_CC, 1, *json);
 145         }
 146
 147         return SUCCESS;
 148 }
 149
 150 typedef struct _HashTableList {
 151         HashTable ht;
 152         struct _HashTableList *parent;
 153 } HashTableList;
 154
 155 typedef struct _ArrayParserState {
 156         const char *ptr, *end;
 157         HashTableList *list;
 158 #ifdef ZTS
 159         void ***ts;
 160 #endif
 161         Oid typ;
 162         unsigned quotes:1;
 163         unsigned escaped:1;
 164 } ArrayParserState;
 165
 166 static char caa(ArrayParserState *a, const char *any, unsigned advance)
 167 {
 168         const char *p = any;
 169         TSRMLS_FETCH_FROM_CTX(a->ts);
 170
 171         do {
 172                 if (*p == *a->ptr) {
 173                         a->ptr += advance;
 174                         return *p;
 175                 }
 176         } while (*++p);
 177
 178         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse array: expected one of '%s', got '%c'", any, *a->ptr); \
 179         return 0;
 180 }
 181
 182 static STATUS add_element(ArrayParserState *a, const char *start)
 183 {
 184         zval *zelem;
 185         size_t el_len = a->ptr - start;
 186         char *el_str = estrndup(start, el_len);
 187         TSRMLS_FETCH_FROM_CTX(a->ts);
 188
 189         if (a->quotes) {
 190                 int tmp_len = el_len;
 191
 192                 php_stripslashes(el_str, &tmp_len TSRMLS_CC);
 193                 el_len = tmp_len;
 194         } else if ((a->ptr - start == 4) && !strncmp(start, "NULL", 4)) {
 195                 efree(el_str);
 196                 el_str = NULL;
 197                 el_len = 0;
 198         }
 199
 200         if (!el_str) {
 201                 MAKE_STD_ZVAL(zelem);
 202                 ZVAL_NULL(zelem);
 203         } else {
 204                 zelem = php_pq_typed_zval(el_str, el_len, a->typ TSRMLS_CC);
 205
 206                 efree(el_str);
 207         }
 208
 209         return zend_hash_next_index_insert(&a->list->ht, &zelem, sizeof(zval *), NULL);
 210 }
 211
 212 static STATUS parse_array(ArrayParserState *a);
 213
 214 static STATUS parse_element(ArrayParserState *a)
 215 {
 216         const char *el;
 217         TSRMLS_FETCH_FROM_CTX(a->ts);
 218
 219         switch (*a->ptr) {
 220         case '{':
 221                 return parse_array(a);
 222
 223         case '"':
 224                 a->quotes = 1;
 225                 ++a->ptr;
 226                 break;
 227         }
 228
 229         for (el = a->ptr; a->ptr < a->end; ++a->ptr) {
 230                 switch (*a->ptr) {
 231                 case '"':
 232                         if (a->escaped) {
 233                                 a->escaped = 0;
 234                         } else if (a->quotes) {
 235                                 if (SUCCESS != add_element(a, el)) {
 236                                         return FAILURE;
 237                                 }
 238                                 a->quotes = 0;
 239                                 ++a->ptr;
 240                                 return SUCCESS;
 241                         } else {
 242                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, unexpected quote: '%.*s'", (int) (a->ptr - el), el);
 243                                 return FAILURE;
 244                         }
 245                         break;
 246
 247                 case ',':
 248                 case '}':
 249                         if (!a->quotes) {
 250                                 return add_element(a, el);
 251                         }
 252                         break;
 253
 254                 case '\\':
 255                         a->escaped = !a->escaped;
 256                         break;
 257
 258                 default:
 259                         a->escaped = 0;
 260                         break;
 261                 }
 262         }
 263
 264         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, reached end of input");
 265         return FAILURE;
 266 }
 267
 268 static STATUS parse_elements(ArrayParserState *a)
 269 {
 270         TSRMLS_FETCH_FROM_CTX(a->ts);
 271
 272         while (SUCCESS == parse_element(a)) {
 273                 switch (caa(a, ",}", 0)) {
 274                 case 0:
 275                         return FAILURE;
 276
 277                 case '}':
 278                         return SUCCESS;
 279
 280                 default:
 281                         if (!*++a->ptr) {
 282                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse elements, reached end of input");
 283                                 return FAILURE;
 284                         }
 285                         break;
 286                 }
 287         }
 288
 289         return FAILURE;
 290 }
 291
 292 static STATUS parse_array(ArrayParserState *a)
 293 {
 294         HashTableList *list;
 295
 296         if (!caa(a, "{", 1)) {
 297                 return FAILURE;
 298         }
 299
 300         list = ecalloc(1, sizeof(*list));
 301         ZEND_INIT_SYMTABLE(&list->ht);
 302
 303         if (a->list) {
 304                 zval *zcur;
 305
 306                 MAKE_STD_ZVAL(zcur);
 307                 Z_TYPE_P(zcur) = IS_ARRAY;
 308                 Z_ARRVAL_P(zcur) = &list->ht;
 309
 310                 zend_hash_next_index_insert(&a->list->ht, &zcur, sizeof(zval *), NULL);
 311
 312                 list->parent = a->list;
 313         }
 314         a->list = list;
 315
 316         if (SUCCESS != parse_elements(a)) {
 317                 return FAILURE;
 318         }
 319
 320         if (!caa(a, "}", 1)) {
 321                 return FAILURE;
 322         }
 323
 324         if (a->list->parent) {
 325                 a->list = a->list->parent;
 326         }
 327
 328         return SUCCESS;
 329 }
 330
 331 HashTable *php_pq_parse_array(const char *val_str, size_t val_len, Oid typ TSRMLS_DC)
 332 {
 333         HashTable *ht = NULL;
 334         ArrayParserState a = {0};
 335         TSRMLS_SET_CTX(a.ts);
 336
 337         a.typ = typ;
 338         a.ptr = val_str;
 339         a.end = val_str + val_len;
 340
 341         if (SUCCESS != parse_array(&a)) {
 342                 while (a.list) {
 343                         HashTableList *l = a.list->parent;
 344
 345                         zend_hash_destroy(&a.list->ht);
 346                         efree(a.list);
 347                         a.list = l;
 348                 }
 349                 return ht;
 350         }
 351
 352         if (*a.ptr) {
 353                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Trailing input: '%s'", a.ptr);
 354         }
 355
 356         do {
 357                 ht = &a.list->ht;
 358         } while ((a.list = a.list->parent));
 359
 360         return ht;
 361 }
 362
 363 zval *php_pq_typed_zval(char *val, size_t len, Oid typ TSRMLS_DC)
 364 {
 365         zval *zv;
 366
 367         MAKE_STD_ZVAL(zv);
 368
 369         switch (typ) {
 370 #ifdef HAVE_PHP_PQ_TYPE_H
 371 #       undef PHP_PQ_TYPE
 372 #       include "php_pq_type.h"
 373         case PHP_PQ_OID_BOOL:
 374                 ZVAL_BOOL(zv, *val == 't');
 375                 break;
 376 #if SIZEOF_LONG >= 8
 377         case PHP_PQ_OID_INT8:
 378         case PHP_PQ_OID_TID:
 379 #endif
 380         case PHP_PQ_OID_INT4:
 381         case PHP_PQ_OID_INT2:
 382         case PHP_PQ_OID_XID:
 383         case PHP_PQ_OID_OID:
 384                 ZVAL_LONG(zv, zend_atol(val, len));
 385                 break;
 386
 387         case PHP_PQ_OID_FLOAT4:
 388         case PHP_PQ_OID_FLOAT8:
 389                 ZVAL_DOUBLE(zv, zend_strtod(val, NULL));
 390                 break;
 391
 392         case PHP_PQ_OID_DATE:
 393                 php_pqdt_from_string(val, len, "Y-m-d", zv TSRMLS_CC);
 394                 break;
 395
 396         case PHP_PQ_OID_ABSTIME:
 397                 php_pqdt_from_string(val, len, "Y-m-d H:i:s", zv TSRMLS_CC);
 398                 break;
 399
 400         case PHP_PQ_OID_TIMESTAMP:
 401                 php_pqdt_from_string(val, len, "Y-m-d H:i:s.u", zv TSRMLS_CC);
 402                 break;
 403
 404         case PHP_PQ_OID_TIMESTAMPTZ:
 405                 php_pqdt_from_string(val, len, "Y-m-d H:i:s.uO", zv TSRMLS_CC);
 406                 break;
 407
 408         default:
 409                 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))) {
 410                         Z_TYPE_P(zv) = IS_ARRAY;
 411                 } else {
 412                         ZVAL_STRINGL(zv, val, len, 1);
 413                 }
 414                 break;
 415 #else
 416         case 16: /* BOOL */
 417                 ZVAL_BOOL(zv, *val == 't');
 418                 break;
 419
 420         default:
 421                 ZVAL_STRINGL(zv, val, len, 1);
 422 #endif
 423         }
 424
 425         return zv;
 426 }
 427
 428 /*
 429  * Local variables:
 430  * tab-width: 4
 431  * c-basic-offset: 4
 432  * End:
 433  * vim600: noet sw=4 ts=4 fdm=marker
 434  * vim<600: noet sw=4 ts=4
 435  */