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
  21 #include <Zend/zend_interfaces.h>
  22
  23 #include <libpq/libpq-fs.h>
  24
  25 #include "php_pq.h"
  26 #include "php_pqexc.h"
  27 #include "php_pq_misc.h"
  28 #include "php_pqconn_event.h"
  29 #undef PHP_PQ_TYPE
  30 #include "php_pq_type.h"
  31
  32
  33 /* clear result object associated with a result handle */
  34 void php_pqres_clear(PGresult *r) {
  35         php_pq_object_t *o = PQresultInstanceData(r, php_pqconn_event);
  36
  37         if (o) {
  38                 TSRMLS_FETCH();
  39                 php_pq_object_delref(o TSRMLS_CC);
  40         } else {
  41                 PQclear(r);
  42         }
  43 }
  44
  45 /* clear any asynchronous results */
  46 void php_pqconn_clear(PGconn *conn) {
  47         PGresult *r;
  48         php_pqconn_event_data_t *evdata = PQinstanceData(conn, php_pqconn_event);
  49
  50         while ((r = PQgetResult(conn))) {
  51                 php_pqres_clear(r);
  52         }
  53
  54         if (evdata && evdata->obj) {
  55                 if (php_pq_callback_is_enabled(&evdata->obj->intern->onevent)) {
  56                         TSRMLS_FETCH_FROM_CTX(evdata->ts);
  57
  58                         if (php_pq_callback_is_locked(&evdata->obj->intern->onevent TSRMLS_CC)) {
  59                                 php_pq_callback_disable(&evdata->obj->intern->onevent TSRMLS_CC);
  60                         } else {
  61                                 php_pq_callback_dtor(&evdata->obj->intern->onevent);
  62                         }
  63                 }
  64         }
  65 }
  66
  67 /* safe wrappers to clear any asynchronous wrappers before querying synchronously */
  68 PGresult *php_pq_exec(PGconn *conn, const char *query) {
  69         php_pqconn_clear(conn);
  70         return PQexec(conn, query);
  71 }
  72 PGresult *php_pq_exec_params(PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const * paramValues, const int *paramLengths, const int *paramFormats, int resultFormat) {
  73         php_pqconn_clear(conn);
  74         return PQexecParams(conn, command, nParams, paramTypes, paramValues, paramLengths, paramFormats, resultFormat);
  75 }
  76 PGresult *php_pq_prepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes) {
  77         php_pqconn_clear(conn);
  78         return PQprepare(conn, stmtName, query, nParams, paramTypes);
  79 }
  80 PGresult *php_pq_exec_prepared(PGconn *conn, const char *stmtName, int nParams, const char *const * paramValues, const int *paramLengths, const int *paramFormats, int resultFormat) {
  81         php_pqconn_clear(conn);
  82         return PQexecPrepared(conn, stmtName, nParams, paramValues, paramLengths, paramFormats, resultFormat);
  83 }
  84
  85 char *php_pq_rtrim(char *e)
  86 {
  87         size_t l = strlen(e);
  88
  89         while (l-- > 0 && e[l] == '\n') {
  90                 e[l] = '\0';
  91         }
  92         return e;
  93 }
  94
  95 const char *php_pq_strmode(long mode)
  96 {
  97         switch (mode & (INV_READ|INV_WRITE)) {
  98         case INV_READ|INV_WRITE:
  99                 return "rw";
 100         case INV_READ:
 101                 return "r";
 102         case INV_WRITE:
 103                 return "w";
 104         default:
 105                 return "-";
 106         }
 107 }
 108
 109 int php_pq_compare_index(const void *lptr, const void *rptr TSRMLS_DC)
 110 {
 111         const Bucket *l = *(const Bucket **) lptr;
 112         const Bucket *r = *(const Bucket **) rptr;
 113
 114         if (l->h < r->h) {
 115                 return -1;
 116         }
 117         if (l->h > r->h) {
 118                 return 1;
 119         }
 120         return 0;
 121 }
 122
 123 zend_class_entry *php_pqdt_class_entry;
 124
 125 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_to_string, 0, 0, 0)
 126 ZEND_END_ARG_INFO();
 127 static PHP_METHOD(pqdt, __toString)
 128 {
 129         zval *rv = NULL;
 130
 131         zend_call_method_with_1_params(&getThis(), php_pqdt_class_entry, NULL, "format", &rv,
 132                         zend_read_property(php_pqdt_class_entry, getThis(), ZEND_STRL("format"), 0 TSRMLS_CC));
 133         if (rv) {
 134                 RETVAL_ZVAL(rv, 1, 1);
 135         }
 136 }
 137
 138 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_create_from_format, 0, 0, 2)
 139         ZEND_ARG_INFO(0, format)
 140         ZEND_ARG_INFO(0, datetime)
 141         ZEND_ARG_INFO(0, timezone)
 142 ZEND_END_ARG_INFO();
 143 static PHP_METHOD(pqdt, createFromFormat)
 144 {
 145         zend_error_handling zeh;
 146         char *fmt_str, *dt_str;
 147         int fmt_len, dt_len;
 148         zval *ztz = NULL;
 149         ZEND_RESULT_CODE rv;
 150
 151         zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh TSRMLS_CC);
 152         rv = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|O", &fmt_str, &fmt_len, &dt_str, &dt_len, &ztz, php_date_get_timezone_ce());
 153         zend_restore_error_handling(&zeh TSRMLS_CC);
 154
 155         if (SUCCESS == rv) {
 156                 php_pqdt_from_string(return_value, fmt_str, dt_str, dt_len, "Y-m-d H:i:s.uO", ztz TSRMLS_CC);
 157         }
 158 }
 159
 160 static zend_function_entry php_pqdt_methods[] = {
 161         PHP_ME(pqdt, createFromFormat, ai_pqdt_create_from_format, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 162         PHP_ME(pqdt, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 163         PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 164         {0}
 165 };
 166
 167 zval *php_pqdt_from_string(zval *zv, char *input_fmt, char *dt_str, size_t dt_len, char *output_fmt, zval *ztimezone TSRMLS_DC)
 168 {
 169         php_date_obj *dobj;
 170
 171         if (!zv) {
 172                 MAKE_STD_ZVAL(zv);
 173         }
 174
 175         php_date_instantiate(php_pqdt_class_entry, zv TSRMLS_CC);
 176         dobj = zend_object_store_get_object(zv TSRMLS_CC);
 177         if (!php_date_initialize(dobj, dt_str, dt_len, input_fmt, ztimezone, 1 TSRMLS_CC)) {
 178                 zval_dtor(zv);
 179                 ZVAL_NULL(zv);
 180         } else if (output_fmt) {
 181                 zend_update_property_string(php_pqdt_class_entry, zv, ZEND_STRL("format"), output_fmt TSRMLS_CC);
 182         }
 183
 184         return zv;
 185 }
 186
 187 void php_pqdt_to_string(zval *zdt, const char *format, char **str_buf, size_t *str_len TSRMLS_DC)
 188 {
 189         zval rv;
 190
 191         INIT_PZVAL(&rv);
 192         ZVAL_NULL(&rv);
 193
 194         if (Z_OBJ_HT_P(zdt)->cast_object
 195         &&      SUCCESS == Z_OBJ_HT_P(zdt)->cast_object(zdt, &rv, IS_STRING TSRMLS_CC)
 196         ) {
 197                 *str_len = Z_STRLEN(rv);
 198                 *str_buf = Z_STRVAL(rv);
 199         } else if (instanceof_function(Z_OBJCE_P(zdt), php_date_get_date_ce() TSRMLS_CC)) {
 200                 zval *rv = NULL, *zfmt;
 201
 202                 MAKE_STD_ZVAL(zfmt);
 203                 ZVAL_STRING(zfmt, format, 1);
 204                 zend_call_method_with_1_params(&zdt, Z_OBJCE_P(zdt), NULL, "format", &rv, zfmt);
 205                 zval_ptr_dtor(&zfmt);
 206
 207                 if (rv) {
 208                         if (Z_TYPE_P(rv) == IS_STRING) {
 209                                 *str_len = Z_STRLEN_P(rv);
 210                                 *str_buf = estrndup(Z_STRVAL_P(rv), *str_len);
 211                         }
 212                         zval_ptr_dtor(&rv);
 213                 }
 214         }
 215 }
 216
 217 zend_class_entry *php_pqconv_class_entry;
 218
 219 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_types, 0, 0, 0)
 220 ZEND_END_ARG_INFO();
 221
 222 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_from_string, 0, 0, 2)
 223         ZEND_ARG_INFO(0, data)
 224         ZEND_ARG_INFO(0, type)
 225 ZEND_END_ARG_INFO();
 226
 227 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_to_string, 0, 0, 2)
 228         ZEND_ARG_INFO(0, data)
 229         ZEND_ARG_INFO(0, type)
 230 ZEND_END_ARG_INFO();
 231
 232 zend_function_entry php_pqconv_methods[] = {
 233         PHP_ABSTRACT_ME(pqconv, convertTypes, ai_pqconv_convert_types)
 234         PHP_ABSTRACT_ME(pqconv, convertFromString, ai_pqconv_convert_from_string)
 235         PHP_ABSTRACT_ME(pqconv, convertToString, ai_pqconv_convert_to_string)
 236         {0}
 237 };
 238
 239
 240 PHP_MINIT_FUNCTION(pq_misc)
 241 {
 242         zend_class_entry **json, ce = {0};
 243
 244         INIT_NS_CLASS_ENTRY(ce, "pq", "Converter", php_pqconv_methods);
 245         php_pqconv_class_entry = zend_register_internal_interface(&ce TSRMLS_CC);
 246
 247         memset(&ce, 0, sizeof(ce));
 248         INIT_NS_CLASS_ENTRY(ce ,"pq", "DateTime", php_pqdt_methods);
 249         php_pqdt_class_entry = zend_register_internal_class_ex(&ce, php_date_get_date_ce(), "DateTime" TSRMLS_CC);
 250
 251         zend_declare_property_stringl(php_pqdt_class_entry, ZEND_STRL("format"), ZEND_STRL("Y-m-d H:i:s.uO"), ZEND_ACC_PUBLIC TSRMLS_CC);
 252
 253         /* stop reading this file right here! */
 254         if (SUCCESS == zend_hash_find(CG(class_table), ZEND_STRS("jsonserializable"), (void *) &json)) {
 255                 zend_class_implements(php_pqdt_class_entry TSRMLS_CC, 1, *json);
 256         }
 257
 258         return SUCCESS;
 259 }
 260
 261 typedef struct _HashTableList {
 262         HashTable ht;
 263         struct _HashTableList *parent;
 264 } HashTableList;
 265
 266 typedef struct _ArrayParserState {
 267         const char *ptr, *end;
 268         HashTableList *list;
 269         php_pqres_t *res;
 270 #ifdef ZTS
 271         void ***ts;
 272 #endif
 273         Oid typ;
 274         unsigned quotes:1;
 275         unsigned escaped:1;
 276 } ArrayParserState;
 277
 278 static char caa(ArrayParserState *a, const char *any, unsigned advance)
 279 {
 280         const char *p = any;
 281         TSRMLS_FETCH_FROM_CTX(a->ts);
 282
 283         do {
 284                 if (*p == *a->ptr) {
 285                         a->ptr += advance;
 286                         return *p;
 287                 }
 288         } while (*++p);
 289
 290         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse array: expected one of '%s', got '%c'", any, *a->ptr); \
 291         return 0;
 292 }
 293
 294 static ZEND_RESULT_CODE add_element(ArrayParserState *a, const char *start)
 295 {
 296         zval *zelem;
 297         size_t el_len = a->ptr - start;
 298         char *el_str = estrndup(start, el_len);
 299         TSRMLS_FETCH_FROM_CTX(a->ts);
 300
 301         if (a->quotes) {
 302                 int tmp_len = el_len;
 303
 304                 php_stripslashes(el_str, &tmp_len TSRMLS_CC);
 305                 el_len = tmp_len;
 306         } else if ((a->ptr - start == 4) && !strncmp(start, "NULL", 4)) {
 307                 efree(el_str);
 308                 el_str = NULL;
 309                 el_len = 0;
 310         }
 311
 312         if (!el_str) {
 313                 MAKE_STD_ZVAL(zelem);
 314                 ZVAL_NULL(zelem);
 315         } else {
 316                 zelem = php_pqres_typed_zval(a->res, el_str, el_len, a->typ TSRMLS_CC);
 317
 318                 efree(el_str);
 319         }
 320
 321         return zend_hash_next_index_insert(&a->list->ht, &zelem, sizeof(zval *), NULL);
 322 }
 323
 324 static ZEND_RESULT_CODE parse_array(ArrayParserState *a);
 325
 326 static ZEND_RESULT_CODE parse_element(ArrayParserState *a, char delim)
 327 {
 328         const char *el;
 329         TSRMLS_FETCH_FROM_CTX(a->ts);
 330
 331         switch (*a->ptr) {
 332         case '{':
 333                 return parse_array(a);
 334
 335         case '"':
 336                 a->quotes = 1;
 337                 ++a->ptr;
 338                 break;
 339         }
 340
 341         for (el = a->ptr; a->ptr < a->end; ++a->ptr) {
 342                 switch (*a->ptr) {
 343                 case '\\':
 344                         a->escaped = !a->escaped;
 345                         break;
 346
 347                 case '"':
 348                         if (a->escaped) {
 349                                 a->escaped = 0;
 350                         } else if (a->quotes) {
 351                                 if (SUCCESS != add_element(a, el)) {
 352                                         return FAILURE;
 353                                 }
 354                                 a->quotes = 0;
 355                                 ++a->ptr;
 356                                 return SUCCESS;
 357                         } else {
 358                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, unexpected quote: '%.*s'", (int) (a->ptr - el), el);
 359                                 return FAILURE;
 360                         }
 361                         break;
 362
 363                 default:
 364                         if (delim != *a->ptr) {
 365                                 a->escaped = 0;
 366                                 break;
 367                         }
 368                         /* no break */
 369                 case '}':
 370                         if (!a->quotes) {
 371                                 return add_element(a, el);
 372                         }
 373                         break;
 374
 375                 }
 376         }
 377
 378         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, reached end of input");
 379         return FAILURE;
 380 }
 381
 382 static ZEND_RESULT_CODE parse_elements(ArrayParserState *a)
 383 {
 384         char delims[] = {'}', PHP_PQ_DELIM_OF_ARRAY(a->typ), 0};
 385         TSRMLS_FETCH_FROM_CTX(a->ts);
 386
 387         while (SUCCESS == parse_element(a, delims[1])) {
 388                 switch (caa(a, delims, 0)) {
 389                 case 0:
 390                         return FAILURE;
 391
 392                 case '}':
 393                         return SUCCESS;
 394
 395                 default:
 396                         if (!*++a->ptr) {
 397                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse elements, reached end of input");
 398                                 return FAILURE;
 399                         }
 400                         break;
 401                 }
 402         }
 403
 404         return FAILURE;
 405 }
 406
 407 static ZEND_RESULT_CODE parse_array(ArrayParserState *a)
 408 {
 409         HashTableList *list;
 410
 411         if (!caa(a, "{", 1)) {
 412                 return FAILURE;
 413         }
 414
 415         list = ecalloc(1, sizeof(*list));
 416         ZEND_INIT_SYMTABLE(&list->ht);
 417
 418         if (a->list) {
 419                 zval *zcur;
 420
 421                 MAKE_STD_ZVAL(zcur);
 422                 Z_TYPE_P(zcur) = IS_ARRAY;
 423                 Z_ARRVAL_P(zcur) = &list->ht;
 424
 425                 zend_hash_next_index_insert(&a->list->ht, &zcur, sizeof(zval *), NULL);
 426
 427                 list->parent = a->list;
 428         }
 429         a->list = list;
 430
 431         if (SUCCESS != parse_elements(a)) {
 432                 return FAILURE;
 433         }
 434
 435         if (!caa(a, "}", 1)) {
 436                 return FAILURE;
 437         }
 438
 439         if (a->list->parent) {
 440                 a->list = a->list->parent;
 441         }
 442
 443         return SUCCESS;
 444 }
 445
 446 HashTable *php_pq_parse_array(php_pqres_t *res, const char *val_str, size_t val_len, Oid typ TSRMLS_DC)
 447 {
 448         HashTable *ht = NULL;
 449         ArrayParserState a = {0};
 450         TSRMLS_SET_CTX(a.ts);
 451
 452         a.typ = typ;
 453         a.ptr = val_str;
 454         a.end = val_str + val_len;
 455         a.res = res;
 456
 457         if (SUCCESS != parse_array(&a)) {
 458                 while (a.list) {
 459                         HashTableList *l = a.list->parent;
 460
 461                         zend_hash_destroy(&a.list->ht);
 462                         efree(a.list);
 463                         a.list = l;
 464                 }
 465                 return ht;
 466         }
 467
 468         if (*a.ptr) {
 469                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Trailing input: '%s'", a.ptr);
 470         }
 471
 472         do {
 473                 ht = &a.list->ht;
 474         } while ((a.list = a.list->parent));
 475
 476         return ht;
 477 }
 478
 479
 480 /*
 481  * Local variables:
 482  * tab-width: 4
 483  * c-basic-offset: 4
 484  * End:
 485  * vim600: noet sw=4 ts=4 fdm=marker
 486  * vim<600: noet sw=4 ts=4
 487  */