1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 7 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Zeev Suraski <zeev@php.net> |
16 | Jouni Ahto <jouni.ahto@exdec.fi> |
17 | Yasuo Ohgaki <yohgaki@php.net> |
18 | Youichi Iwakiri <yiwakiri@st.rim.or.jp> (pg_copy_*) |
19 | Chris Kings-Lynne <chriskl@php.net> (v3 protocol) |
20 +----------------------------------------------------------------------+
21 */
22
23 #include <stdlib.h>
24
25 #define PHP_PGSQL_PRIVATE 1
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #define SMART_STR_PREALLOC 512
32
33 #include "php.h"
34 #include "php_ini.h"
35 #include "ext/standard/php_standard.h"
36 #include "zend_smart_str.h"
37 #include "ext/pcre/php_pcre.h"
38 #ifdef PHP_WIN32
39 # include "win32/time.h"
40 #endif
41 #include "php_pgsql.h"
42 #include "php_globals.h"
43 #include "zend_exceptions.h"
44
45 #if HAVE_PGSQL
46
47 #ifndef InvalidOid
48 #define InvalidOid ((Oid) 0)
49 #endif
50
51 #define PGSQL_ASSOC 1<<0
52 #define PGSQL_NUM 1<<1
53 #define PGSQL_BOTH (PGSQL_ASSOC|PGSQL_NUM)
54
55 #define PGSQL_NOTICE_LAST 1 /* Get the last notice */
56 #define PGSQL_NOTICE_ALL 2 /* Get all notices */
57 #define PGSQL_NOTICE_CLEAR 3 /* Remove notices */
58
59 #define PGSQL_STATUS_LONG 1
60 #define PGSQL_STATUS_STRING 2
61
62 #define PGSQL_MAX_LENGTH_OF_LONG 30
63 #define PGSQL_MAX_LENGTH_OF_DOUBLE 60
64
65 #if ZEND_LONG_MAX < UINT_MAX
66 #define PGSQL_RETURN_OID(oid) do { \
67 if (oid > ZEND_LONG_MAX) { \
68 smart_str s = {0}; \
69 smart_str_append_unsigned(&s, oid); \
70 smart_str_0(&s); \
71 RETURN_NEW_STR(s.s); \
72 } \
73 RETURN_LONG((zend_long)oid); \
74 } while(0)
75 #else
76 #define PGSQL_RETURN_OID(oid) RETURN_LONG((zend_long)oid)
77 #endif
78
79 #if HAVE_PQSETNONBLOCKING
80 #define PQ_SETNONBLOCKING(pg_link, flag) PQsetnonblocking(pg_link, flag)
81 #else
82 #define PQ_SETNONBLOCKING(pg_link, flag) 0
83 #endif
84
85 #define CHECK_DEFAULT_LINK(x) if ((x) == NULL) { php_error_docref(NULL, E_WARNING, "No PostgreSQL link opened yet"); RETURN_FALSE; }
86 #define FETCH_DEFAULT_LINK() PGG(default_link)
87
88 #ifndef HAVE_PQFREEMEM
89 #define PQfreemem free
90 #endif
91
92 ZEND_DECLARE_MODULE_GLOBALS(pgsql)
93 static PHP_GINIT_FUNCTION(pgsql);
94
95 /* {{{ arginfo */
96 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_connect, 0, 0, 1)
97 ZEND_ARG_INFO(0, connection_string)
98 ZEND_ARG_INFO(0, connect_type)
99 ZEND_ARG_INFO(0, host)
100 ZEND_ARG_INFO(0, port)
101 ZEND_ARG_INFO(0, options)
102 ZEND_ARG_INFO(0, tty)
103 ZEND_ARG_INFO(0, database)
104 ZEND_END_ARG_INFO()
105
106 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_pconnect, 0, 0, 1)
107 ZEND_ARG_INFO(0, connection_string)
108 ZEND_ARG_INFO(0, host)
109 ZEND_ARG_INFO(0, port)
110 ZEND_ARG_INFO(0, options)
111 ZEND_ARG_INFO(0, tty)
112 ZEND_ARG_INFO(0, database)
113 ZEND_END_ARG_INFO()
114
115 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_connect_poll, 0, 0, 0)
116 ZEND_ARG_INFO(0, connection)
117 ZEND_END_ARG_INFO()
118
119 #if HAVE_PQPARAMETERSTATUS
120 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_parameter_status, 0, 0, 1)
121 ZEND_ARG_INFO(0, connection)
122 ZEND_ARG_INFO(0, param_name)
123 ZEND_END_ARG_INFO()
124 #endif
125
126 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_close, 0, 0, 0)
127 ZEND_ARG_INFO(0, connection)
128 ZEND_END_ARG_INFO()
129
130 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_dbname, 0, 0, 0)
131 ZEND_ARG_INFO(0, connection)
132 ZEND_END_ARG_INFO()
133
134 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_last_error, 0, 0, 0)
135 ZEND_ARG_INFO(0, connection)
136 ZEND_END_ARG_INFO()
137
138 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_options, 0, 0, 0)
139 ZEND_ARG_INFO(0, connection)
140 ZEND_END_ARG_INFO()
141
142 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_port, 0, 0, 0)
143 ZEND_ARG_INFO(0, connection)
144 ZEND_END_ARG_INFO()
145
146 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_tty, 0, 0, 0)
147 ZEND_ARG_INFO(0, connection)
148 ZEND_END_ARG_INFO()
149
150 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_host, 0, 0, 0)
151 ZEND_ARG_INFO(0, connection)
152 ZEND_END_ARG_INFO()
153
154 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_version, 0, 0, 0)
155 ZEND_ARG_INFO(0, connection)
156 ZEND_END_ARG_INFO()
157
158 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_ping, 0, 0, 0)
159 ZEND_ARG_INFO(0, connection)
160 ZEND_END_ARG_INFO()
161
162 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_query, 0, 0, 0)
163 ZEND_ARG_INFO(0, connection)
164 ZEND_ARG_INFO(0, query)
165 ZEND_END_ARG_INFO()
166
167 #if HAVE_PQEXECPARAMS
168 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_query_params, 0, 0, 0)
169 ZEND_ARG_INFO(0, connection)
170 ZEND_ARG_INFO(0, query)
171 ZEND_ARG_INFO(0, params)
172 ZEND_END_ARG_INFO()
173 #endif
174
175 #if HAVE_PQPREPARE
176 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_prepare, 0, 0, 0)
177 ZEND_ARG_INFO(0, connection)
178 ZEND_ARG_INFO(0, stmtname)
179 ZEND_ARG_INFO(0, query)
180 ZEND_END_ARG_INFO()
181 #endif
182
183 #if HAVE_PQEXECPREPARED
184 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_execute, 0, 0, 0)
185 ZEND_ARG_INFO(0, connection)
186 ZEND_ARG_INFO(0, stmtname)
187 ZEND_ARG_INFO(0, params)
188 ZEND_END_ARG_INFO()
189 #endif
190
191 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_num_rows, 0, 0, 1)
192 ZEND_ARG_INFO(0, result)
193 ZEND_END_ARG_INFO()
194
195 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_num_fields, 0, 0, 1)
196 ZEND_ARG_INFO(0, result)
197 ZEND_END_ARG_INFO()
198
199 #if HAVE_PQCMDTUPLES
200 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_affected_rows, 0, 0, 1)
201 ZEND_ARG_INFO(0, result)
202 ZEND_END_ARG_INFO()
203 #endif
204
205 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_last_notice, 0, 0, 1)
206 ZEND_ARG_INFO(0, connection)
207 ZEND_ARG_INFO(0, option)
208 ZEND_END_ARG_INFO()
209
210 #ifdef HAVE_PQFTABLE
211 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_table, 0, 0, 2)
212 ZEND_ARG_INFO(0, result)
213 ZEND_ARG_INFO(0, field_number)
214 ZEND_ARG_INFO(0, oid_only)
215 ZEND_END_ARG_INFO()
216 #endif
217
218 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_name, 0, 0, 2)
219 ZEND_ARG_INFO(0, result)
220 ZEND_ARG_INFO(0, field_number)
221 ZEND_END_ARG_INFO()
222
223 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_size, 0, 0, 2)
224 ZEND_ARG_INFO(0, result)
225 ZEND_ARG_INFO(0, field_number)
226 ZEND_END_ARG_INFO()
227
228 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_type, 0, 0, 2)
229 ZEND_ARG_INFO(0, result)
230 ZEND_ARG_INFO(0, field_number)
231 ZEND_END_ARG_INFO()
232
233 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_type_oid, 0, 0, 2)
234 ZEND_ARG_INFO(0, result)
235 ZEND_ARG_INFO(0, field_number)
236 ZEND_END_ARG_INFO()
237
238 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_num, 0, 0, 2)
239 ZEND_ARG_INFO(0, result)
240 ZEND_ARG_INFO(0, field_name)
241 ZEND_END_ARG_INFO()
242
243 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_result, 0, 0, 1)
244 ZEND_ARG_INFO(0, result)
245 ZEND_ARG_INFO(0, row_number)
246 ZEND_ARG_INFO(0, field_name)
247 ZEND_END_ARG_INFO()
248
249 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_row, 0, 0, 1)
250 ZEND_ARG_INFO(0, result)
251 ZEND_ARG_INFO(0, row)
252 ZEND_ARG_INFO(0, result_type)
253 ZEND_END_ARG_INFO()
254
255 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_assoc, 0, 0, 1)
256 ZEND_ARG_INFO(0, result)
257 ZEND_ARG_INFO(0, row)
258 ZEND_END_ARG_INFO()
259
260 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_array, 0, 0, 1)
261 ZEND_ARG_INFO(0, result)
262 ZEND_ARG_INFO(0, row)
263 ZEND_ARG_INFO(0, result_type)
264 ZEND_END_ARG_INFO()
265
266 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_object, 0, 0, 1)
267 ZEND_ARG_INFO(0, result)
268 ZEND_ARG_INFO(0, row)
269 ZEND_ARG_INFO(0, class_name)
270 ZEND_ARG_INFO(0, l)
271 ZEND_ARG_INFO(0, ctor_params)
272 ZEND_END_ARG_INFO()
273
274 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_all, 0, 0, 1)
275 ZEND_ARG_INFO(0, result)
276 ZEND_ARG_INFO(0, result_type)
277 ZEND_END_ARG_INFO()
278
279 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_fetch_all_columns, 0, 0, 1)
280 ZEND_ARG_INFO(0, result)
281 ZEND_ARG_INFO(0, column_number)
282 ZEND_END_ARG_INFO()
283
284 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_result_seek, 0, 0, 2)
285 ZEND_ARG_INFO(0, result)
286 ZEND_ARG_INFO(0, offset)
287 ZEND_END_ARG_INFO()
288
289 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_prtlen, 0, 0, 1)
290 ZEND_ARG_INFO(0, result)
291 ZEND_ARG_INFO(0, row)
292 ZEND_ARG_INFO(0, field_name_or_number)
293 ZEND_END_ARG_INFO()
294
295 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_field_is_null, 0, 0, 1)
296 ZEND_ARG_INFO(0, result)
297 ZEND_ARG_INFO(0, row)
298 ZEND_ARG_INFO(0, field_name_or_number)
299 ZEND_END_ARG_INFO()
300
301 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_free_result, 0, 0, 1)
302 ZEND_ARG_INFO(0, result)
303 ZEND_END_ARG_INFO()
304
305 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_last_oid, 0, 0, 1)
306 ZEND_ARG_INFO(0, result)
307 ZEND_END_ARG_INFO()
308
309 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_trace, 0, 0, 1)
310 ZEND_ARG_INFO(0, filename)
311 ZEND_ARG_INFO(0, mode)
312 ZEND_ARG_INFO(0, connection)
313 ZEND_END_ARG_INFO()
314
315 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_untrace, 0, 0, 0)
316 ZEND_ARG_INFO(0, connection)
317 ZEND_END_ARG_INFO()
318
319 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_create, 0, 0, 0)
320 ZEND_ARG_INFO(0, connection)
321 ZEND_ARG_INFO(0, large_object_id)
322 ZEND_END_ARG_INFO()
323
324 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_unlink, 0, 0, 0)
325 ZEND_ARG_INFO(0, connection)
326 ZEND_ARG_INFO(0, large_object_oid)
327 ZEND_END_ARG_INFO()
328
329 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_open, 0, 0, 0)
330 ZEND_ARG_INFO(0, connection)
331 ZEND_ARG_INFO(0, large_object_oid)
332 ZEND_ARG_INFO(0, mode)
333 ZEND_END_ARG_INFO()
334
335 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_close, 0, 0, 1)
336 ZEND_ARG_INFO(0, large_object)
337 ZEND_END_ARG_INFO()
338
339 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_read, 0, 0, 1)
340 ZEND_ARG_INFO(0, large_object)
341 ZEND_ARG_INFO(0, len)
342 ZEND_END_ARG_INFO()
343
344 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_write, 0, 0, 2)
345 ZEND_ARG_INFO(0, large_object)
346 ZEND_ARG_INFO(0, buf)
347 ZEND_ARG_INFO(0, len)
348 ZEND_END_ARG_INFO()
349
350 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_read_all, 0, 0, 1)
351 ZEND_ARG_INFO(0, large_object)
352 ZEND_END_ARG_INFO()
353
354 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_import, 0, 0, 0)
355 ZEND_ARG_INFO(0, connection)
356 ZEND_ARG_INFO(0, filename)
357 ZEND_ARG_INFO(0, large_object_oid)
358 ZEND_END_ARG_INFO()
359
360 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_export, 0, 0, 0)
361 ZEND_ARG_INFO(0, connection)
362 ZEND_ARG_INFO(0, objoid)
363 ZEND_ARG_INFO(0, filename)
364 ZEND_END_ARG_INFO()
365
366 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_seek, 0, 0, 2)
367 ZEND_ARG_INFO(0, large_object)
368 ZEND_ARG_INFO(0, offset)
369 ZEND_ARG_INFO(0, whence)
370 ZEND_END_ARG_INFO()
371
372 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_tell, 0, 0, 1)
373 ZEND_ARG_INFO(0, large_object)
374 ZEND_END_ARG_INFO()
375
376 #if HAVE_PG_LO_TRUNCATE
377 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_lo_truncate, 0, 0, 1)
378 ZEND_ARG_INFO(0, large_object)
379 ZEND_ARG_INFO(0, size)
380 ZEND_END_ARG_INFO()
381 #endif
382
383 #if HAVE_PQSETERRORVERBOSITY
384 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_set_error_verbosity, 0, 0, 0)
385 ZEND_ARG_INFO(0, connection)
386 ZEND_ARG_INFO(0, verbosity)
387 ZEND_END_ARG_INFO()
388 #endif
389
390 #if HAVE_PQCLIENTENCODING
391 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_set_client_encoding, 0, 0, 0)
392 ZEND_ARG_INFO(0, connection)
393 ZEND_ARG_INFO(0, encoding)
394 ZEND_END_ARG_INFO()
395
396 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_client_encoding, 0, 0, 0)
397 ZEND_ARG_INFO(0, connection)
398 ZEND_END_ARG_INFO()
399 #endif
400
401 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_end_copy, 0, 0, 0)
402 ZEND_ARG_INFO(0, connection)
403 ZEND_END_ARG_INFO()
404
405 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_put_line, 0, 0, 0)
406 ZEND_ARG_INFO(0, connection)
407 ZEND_ARG_INFO(0, query)
408 ZEND_END_ARG_INFO()
409
410 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_copy_to, 0, 0, 2)
411 ZEND_ARG_INFO(0, connection)
412 ZEND_ARG_INFO(0, table_name)
413 ZEND_ARG_INFO(0, delimiter)
414 ZEND_ARG_INFO(0, null_as)
415 ZEND_END_ARG_INFO()
416
417 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_copy_from, 0, 0, 3)
418 ZEND_ARG_INFO(0, connection)
419 ZEND_ARG_INFO(0, table_name)
420 ZEND_ARG_INFO(0, rows)
421 ZEND_ARG_INFO(0, delimiter)
422 ZEND_ARG_INFO(0, null_as)
423 ZEND_END_ARG_INFO()
424
425 #if HAVE_PQESCAPE
426 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_escape_string, 0, 0, 0)
427 ZEND_ARG_INFO(0, connection)
428 ZEND_ARG_INFO(0, data)
429 ZEND_END_ARG_INFO()
430
431 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_escape_bytea, 0, 0, 0)
432 ZEND_ARG_INFO(0, connection)
433 ZEND_ARG_INFO(0, data)
434 ZEND_END_ARG_INFO()
435
436 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_unescape_bytea, 0, 0, 1)
437 ZEND_ARG_INFO(0, data)
438 ZEND_END_ARG_INFO()
439 #endif
440
441 #if HAVE_PQESCAPE
442 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_escape_literal, 0, 0, 0)
443 ZEND_ARG_INFO(0, connection)
444 ZEND_ARG_INFO(0, data)
445 ZEND_END_ARG_INFO()
446 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_escape_identifier, 0, 0, 0)
447 ZEND_ARG_INFO(0, connection)
448 ZEND_ARG_INFO(0, data)
449 ZEND_END_ARG_INFO()
450 #endif
451
452 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_result_error, 0, 0, 1)
453 ZEND_ARG_INFO(0, result)
454 ZEND_END_ARG_INFO()
455
456 #if HAVE_PQRESULTERRORFIELD
457 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_result_error_field, 0, 0, 2)
458 ZEND_ARG_INFO(0, result)
459 ZEND_ARG_INFO(0, fieldcode)
460 ZEND_END_ARG_INFO()
461 #endif
462
463 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_connection_status, 0, 0, 1)
464 ZEND_ARG_INFO(0, connection)
465 ZEND_END_ARG_INFO()
466
467 #if HAVE_PGTRANSACTIONSTATUS
468 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_transaction_status, 0, 0, 1)
469 ZEND_ARG_INFO(0, connection)
470 ZEND_END_ARG_INFO()
471 #endif
472
473 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_connection_reset, 0, 0, 1)
474 ZEND_ARG_INFO(0, connection)
475 ZEND_END_ARG_INFO()
476
477 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_cancel_query, 0, 0, 1)
478 ZEND_ARG_INFO(0, connection)
479 ZEND_END_ARG_INFO()
480
481 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_connection_busy, 0, 0, 1)
482 ZEND_ARG_INFO(0, connection)
483 ZEND_END_ARG_INFO()
484
485 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_send_query, 0, 0, 2)
486 ZEND_ARG_INFO(0, connection)
487 ZEND_ARG_INFO(0, query)
488 ZEND_END_ARG_INFO()
489
490 #if HAVE_PQSENDQUERYPARAMS
491 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_send_query_params, 0, 0, 3)
492 ZEND_ARG_INFO(0, connection)
493 ZEND_ARG_INFO(0, query)
494 ZEND_ARG_INFO(0, params)
495 ZEND_END_ARG_INFO()
496 #endif
497
498 #if HAVE_PQSENDPREPARE
499 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_send_prepare, 0, 0, 3)
500 ZEND_ARG_INFO(0, connection)
501 ZEND_ARG_INFO(0, stmtname)
502 ZEND_ARG_INFO(0, query)
503 ZEND_END_ARG_INFO()
504 #endif
505
506 #if HAVE_PQSENDQUERYPREPARED
507 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_send_execute, 0, 0, 3)
508 ZEND_ARG_INFO(0, connection)
509 ZEND_ARG_INFO(0, stmtname)
510 ZEND_ARG_INFO(0, params)
511 ZEND_END_ARG_INFO()
512 #endif
513
514 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_get_result, 0, 0, 1)
515 ZEND_ARG_INFO(0, connection)
516 ZEND_END_ARG_INFO()
517
518 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_result_status, 0, 0, 1)
519 ZEND_ARG_INFO(0, result)
520 ZEND_ARG_INFO(0, result_type)
521 ZEND_END_ARG_INFO()
522
523 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_get_notify, 0, 0, 0)
524 ZEND_ARG_INFO(0, connection)
525 ZEND_ARG_INFO(0, e)
526 ZEND_END_ARG_INFO()
527
528 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_get_pid, 0, 0, 0)
529 ZEND_ARG_INFO(0, connection)
530 ZEND_END_ARG_INFO()
531
532 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_socket, 0, 0, 1)
533 ZEND_ARG_INFO(0, connection)
534 ZEND_END_ARG_INFO()
535
536 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_consume_input, 0, 0, 1)
537 ZEND_ARG_INFO(0, connection)
538 ZEND_END_ARG_INFO()
539
540 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_flush, 0, 0, 1)
541 ZEND_ARG_INFO(0, connection)
542 ZEND_END_ARG_INFO()
543
544 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_meta_data, 0, 0, 2)
545 ZEND_ARG_INFO(0, db)
546 ZEND_ARG_INFO(0, table)
547 ZEND_END_ARG_INFO()
548
549 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_convert, 0, 0, 3)
550 ZEND_ARG_INFO(0, db)
551 ZEND_ARG_INFO(0, table)
552 ZEND_ARG_INFO(0, values)
553 ZEND_ARG_INFO(0, options)
554 ZEND_END_ARG_INFO()
555
556 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_insert, 0, 0, 3)
557 ZEND_ARG_INFO(0, db)
558 ZEND_ARG_INFO(0, table)
559 ZEND_ARG_INFO(0, values)
560 ZEND_ARG_INFO(0, options)
561 ZEND_END_ARG_INFO()
562
563 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_update, 0, 0, 4)
564 ZEND_ARG_INFO(0, db)
565 ZEND_ARG_INFO(0, table)
566 ZEND_ARG_INFO(0, fields)
567 ZEND_ARG_INFO(0, ids)
568 ZEND_ARG_INFO(0, options)
569 ZEND_END_ARG_INFO()
570
571 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_delete, 0, 0, 3)
572 ZEND_ARG_INFO(0, db)
573 ZEND_ARG_INFO(0, table)
574 ZEND_ARG_INFO(0, ids)
575 ZEND_ARG_INFO(0, options)
576 ZEND_END_ARG_INFO()
577
578 ZEND_BEGIN_ARG_INFO_EX(arginfo_pg_select, 0, 0, 3)
579 ZEND_ARG_INFO(0, db)
580 ZEND_ARG_INFO(0, table)
581 ZEND_ARG_INFO(0, ids)
582 ZEND_ARG_INFO(0, options)
583 ZEND_ARG_INFO(0, result_type)
584 ZEND_END_ARG_INFO()
585 /* }}} */
586
587 /* {{{ pgsql_functions[]
588 */
589 static const zend_function_entry pgsql_functions[] = {
590 /* connection functions */
591 PHP_FE(pg_connect, arginfo_pg_connect)
592 PHP_FE(pg_pconnect, arginfo_pg_pconnect)
593 PHP_FE(pg_connect_poll, arginfo_pg_connect_poll)
594 PHP_FE(pg_close, arginfo_pg_close)
595 PHP_FE(pg_connection_status, arginfo_pg_connection_status)
596 PHP_FE(pg_connection_busy, arginfo_pg_connection_busy)
597 PHP_FE(pg_connection_reset, arginfo_pg_connection_reset)
598 PHP_FE(pg_host, arginfo_pg_host)
599 PHP_FE(pg_dbname, arginfo_pg_dbname)
600 PHP_FE(pg_port, arginfo_pg_port)
601 PHP_FE(pg_tty, arginfo_pg_tty)
602 PHP_FE(pg_options, arginfo_pg_options)
603 PHP_FE(pg_version, arginfo_pg_version)
604 PHP_FE(pg_ping, arginfo_pg_ping)
605 #if HAVE_PQPARAMETERSTATUS
606 PHP_FE(pg_parameter_status, arginfo_pg_parameter_status)
607 #endif
608 #if HAVE_PGTRANSACTIONSTATUS
609 PHP_FE(pg_transaction_status, arginfo_pg_transaction_status)
610 #endif
611 /* query functions */
612 PHP_FE(pg_query, arginfo_pg_query)
613 #if HAVE_PQEXECPARAMS
614 PHP_FE(pg_query_params, arginfo_pg_query_params)
615 #endif
616 #if HAVE_PQPREPARE
617 PHP_FE(pg_prepare, arginfo_pg_prepare)
618 #endif
619 #if HAVE_PQEXECPREPARED
620 PHP_FE(pg_execute, arginfo_pg_execute)
621 #endif
622 PHP_FE(pg_send_query, arginfo_pg_send_query)
623 #if HAVE_PQSENDQUERYPARAMS
624 PHP_FE(pg_send_query_params, arginfo_pg_send_query_params)
625 #endif
626 #if HAVE_PQSENDPREPARE
627 PHP_FE(pg_send_prepare, arginfo_pg_send_prepare)
628 #endif
629 #if HAVE_PQSENDQUERYPREPARED
630 PHP_FE(pg_send_execute, arginfo_pg_send_execute)
631 #endif
632 PHP_FE(pg_cancel_query, arginfo_pg_cancel_query)
633 /* result functions */
634 PHP_FE(pg_fetch_result, arginfo_pg_fetch_result)
635 PHP_FE(pg_fetch_row, arginfo_pg_fetch_row)
636 PHP_FE(pg_fetch_assoc, arginfo_pg_fetch_assoc)
637 PHP_FE(pg_fetch_array, arginfo_pg_fetch_array)
638 PHP_FE(pg_fetch_object, arginfo_pg_fetch_object)
639 PHP_FE(pg_fetch_all, arginfo_pg_fetch_all)
640 PHP_FE(pg_fetch_all_columns, arginfo_pg_fetch_all_columns)
641 #if HAVE_PQCMDTUPLES
642 PHP_FE(pg_affected_rows,arginfo_pg_affected_rows)
643 #endif
644 PHP_FE(pg_get_result, arginfo_pg_get_result)
645 PHP_FE(pg_result_seek, arginfo_pg_result_seek)
646 PHP_FE(pg_result_status,arginfo_pg_result_status)
647 PHP_FE(pg_free_result, arginfo_pg_free_result)
648 PHP_FE(pg_last_oid, arginfo_pg_last_oid)
649 PHP_FE(pg_num_rows, arginfo_pg_num_rows)
650 PHP_FE(pg_num_fields, arginfo_pg_num_fields)
651 PHP_FE(pg_field_name, arginfo_pg_field_name)
652 PHP_FE(pg_field_num, arginfo_pg_field_num)
653 PHP_FE(pg_field_size, arginfo_pg_field_size)
654 PHP_FE(pg_field_type, arginfo_pg_field_type)
655 PHP_FE(pg_field_type_oid, arginfo_pg_field_type_oid)
656 PHP_FE(pg_field_prtlen, arginfo_pg_field_prtlen)
657 PHP_FE(pg_field_is_null,arginfo_pg_field_is_null)
658 #ifdef HAVE_PQFTABLE
659 PHP_FE(pg_field_table, arginfo_pg_field_table)
660 #endif
661 /* async message function */
662 PHP_FE(pg_get_notify, arginfo_pg_get_notify)
663 PHP_FE(pg_socket, arginfo_pg_socket)
664 PHP_FE(pg_consume_input,arginfo_pg_consume_input)
665 PHP_FE(pg_flush, arginfo_pg_flush)
666 PHP_FE(pg_get_pid, arginfo_pg_get_pid)
667 /* error message functions */
668 PHP_FE(pg_result_error, arginfo_pg_result_error)
669 #if HAVE_PQRESULTERRORFIELD
670 PHP_FE(pg_result_error_field, arginfo_pg_result_error_field)
671 #endif
672 PHP_FE(pg_last_error, arginfo_pg_last_error)
673 PHP_FE(pg_last_notice, arginfo_pg_last_notice)
674 /* copy functions */
675 PHP_FE(pg_put_line, arginfo_pg_put_line)
676 PHP_FE(pg_end_copy, arginfo_pg_end_copy)
677 PHP_FE(pg_copy_to, arginfo_pg_copy_to)
678 PHP_FE(pg_copy_from, arginfo_pg_copy_from)
679 /* debug functions */
680 PHP_FE(pg_trace, arginfo_pg_trace)
681 PHP_FE(pg_untrace, arginfo_pg_untrace)
682 /* large object functions */
683 PHP_FE(pg_lo_create, arginfo_pg_lo_create)
684 PHP_FE(pg_lo_unlink, arginfo_pg_lo_unlink)
685 PHP_FE(pg_lo_open, arginfo_pg_lo_open)
686 PHP_FE(pg_lo_close, arginfo_pg_lo_close)
687 PHP_FE(pg_lo_read, arginfo_pg_lo_read)
688 PHP_FE(pg_lo_write, arginfo_pg_lo_write)
689 PHP_FE(pg_lo_read_all, arginfo_pg_lo_read_all)
690 PHP_FE(pg_lo_import, arginfo_pg_lo_import)
691 PHP_FE(pg_lo_export, arginfo_pg_lo_export)
692 PHP_FE(pg_lo_seek, arginfo_pg_lo_seek)
693 PHP_FE(pg_lo_tell, arginfo_pg_lo_tell)
694 #if HAVE_PG_LO_TRUNCATE
695 PHP_FE(pg_lo_truncate, arginfo_pg_lo_truncate)
696 #endif
697 /* utility functions */
698 #if HAVE_PQESCAPE
699 PHP_FE(pg_escape_string, arginfo_pg_escape_string)
700 PHP_FE(pg_escape_bytea, arginfo_pg_escape_bytea)
701 PHP_FE(pg_unescape_bytea, arginfo_pg_unescape_bytea)
702 PHP_FE(pg_escape_literal, arginfo_pg_escape_literal)
703 PHP_FE(pg_escape_identifier, arginfo_pg_escape_identifier)
704 #endif
705 #if HAVE_PQSETERRORVERBOSITY
706 PHP_FE(pg_set_error_verbosity, arginfo_pg_set_error_verbosity)
707 #endif
708 #if HAVE_PQCLIENTENCODING
709 PHP_FE(pg_client_encoding, arginfo_pg_client_encoding)
710 PHP_FE(pg_set_client_encoding, arginfo_pg_set_client_encoding)
711 #endif
712 /* misc function */
713 PHP_FE(pg_meta_data, arginfo_pg_meta_data)
714 PHP_FE(pg_convert, arginfo_pg_convert)
715 PHP_FE(pg_insert, arginfo_pg_insert)
716 PHP_FE(pg_update, arginfo_pg_update)
717 PHP_FE(pg_delete, arginfo_pg_delete)
718 PHP_FE(pg_select, arginfo_pg_select)
719 /* aliases for downwards compatibility */
720 PHP_FALIAS(pg_exec, pg_query, arginfo_pg_query)
721 PHP_FALIAS(pg_getlastoid, pg_last_oid, arginfo_pg_last_oid)
722 #if HAVE_PQCMDTUPLES
723 PHP_FALIAS(pg_cmdtuples, pg_affected_rows, arginfo_pg_affected_rows)
724 #endif
725 PHP_FALIAS(pg_errormessage, pg_last_error, arginfo_pg_last_error)
726 PHP_FALIAS(pg_numrows, pg_num_rows, arginfo_pg_num_rows)
727 PHP_FALIAS(pg_numfields, pg_num_fields, arginfo_pg_num_fields)
728 PHP_FALIAS(pg_fieldname, pg_field_name, arginfo_pg_field_name)
729 PHP_FALIAS(pg_fieldsize, pg_field_size, arginfo_pg_field_size)
730 PHP_FALIAS(pg_fieldtype, pg_field_type, arginfo_pg_field_type)
731 PHP_FALIAS(pg_fieldnum, pg_field_num, arginfo_pg_field_num)
732 PHP_FALIAS(pg_fieldprtlen, pg_field_prtlen, arginfo_pg_field_prtlen)
733 PHP_FALIAS(pg_fieldisnull, pg_field_is_null, arginfo_pg_field_is_null)
734 PHP_FALIAS(pg_freeresult, pg_free_result, arginfo_pg_free_result)
735 PHP_FALIAS(pg_result, pg_fetch_result, arginfo_pg_get_result)
736 PHP_FALIAS(pg_loreadall, pg_lo_read_all, arginfo_pg_lo_read_all)
737 PHP_FALIAS(pg_locreate, pg_lo_create, arginfo_pg_lo_create)
738 PHP_FALIAS(pg_lounlink, pg_lo_unlink, arginfo_pg_lo_unlink)
739 PHP_FALIAS(pg_loopen, pg_lo_open, arginfo_pg_lo_open)
740 PHP_FALIAS(pg_loclose, pg_lo_close, arginfo_pg_lo_close)
741 PHP_FALIAS(pg_loread, pg_lo_read, arginfo_pg_lo_read)
742 PHP_FALIAS(pg_lowrite, pg_lo_write, arginfo_pg_lo_write)
743 PHP_FALIAS(pg_loimport, pg_lo_import, arginfo_pg_lo_import)
744 PHP_FALIAS(pg_loexport, pg_lo_export, arginfo_pg_lo_export)
745 #if HAVE_PQCLIENTENCODING
746 PHP_FALIAS(pg_clientencoding, pg_client_encoding, arginfo_pg_client_encoding)
747 PHP_FALIAS(pg_setclientencoding, pg_set_client_encoding, arginfo_pg_set_client_encoding)
748 #endif
749 PHP_FE_END
750 };
751 /* }}} */
752
753 /* {{{ pgsql_module_entry
754 */
755 zend_module_entry pgsql_module_entry = {
756 STANDARD_MODULE_HEADER,
757 "pgsql",
758 pgsql_functions,
759 PHP_MINIT(pgsql),
760 PHP_MSHUTDOWN(pgsql),
761 PHP_RINIT(pgsql),
762 PHP_RSHUTDOWN(pgsql),
763 PHP_MINFO(pgsql),
764 PHP_PGSQL_VERSION,
765 PHP_MODULE_GLOBALS(pgsql),
766 PHP_GINIT(pgsql),
767 NULL,
768 NULL,
769 STANDARD_MODULE_PROPERTIES_EX
770 };
771 /* }}} */
772
773 #ifdef COMPILE_DL_PGSQL
774 #ifdef ZTS
775 ZEND_TSRMLS_CACHE_DEFINE()
776 #endif
777 ZEND_GET_MODULE(pgsql)
778 #endif
779
780 static int le_link, le_plink, le_result, le_lofp, le_string;
781
782 /* Compatibility definitions */
783
784 #ifndef HAVE_PGSQL_WITH_MULTIBYTE_SUPPORT
785 #define pg_encoding_to_char(x) "SQL_ASCII"
786 #endif
787
788 #if !HAVE_PQESCAPE_CONN
789 #define PQescapeStringConn(conn, to, from, len, error) PQescapeString(to, from, len)
790 #endif
791
792 #if HAVE_PQESCAPELITERAL
793 #define PGSQLescapeLiteral(conn, str, len) PQescapeLiteral(conn, str, len)
794 #define PGSQLescapeIdentifier(conn, str, len) PQescapeIdentifier(conn, str, len)
795 #define PGSQLfree(a) PQfreemem(a)
796 #else
797 #define PGSQLescapeLiteral(conn, str, len) php_pgsql_PQescapeInternal(conn, str, len, 1, 0)
798 #define PGSQLescapeLiteral2(conn, str, len) php_pgsql_PQescapeInternal(conn, str, len, 1, 1)
799 #define PGSQLescapeIdentifier(conn, str, len) php_pgsql_PQescapeInternal(conn, str, len, 0, 0)
800 #define PGSQLfree(a) efree(a)
801
802 /* emulate libpq's PQescapeInternal() 9.0 or later */
php_pgsql_PQescapeInternal(PGconn * conn,const char * str,size_t len,int escape_literal,int safe)803 static char *php_pgsql_PQescapeInternal(PGconn *conn, const char *str, size_t len, int escape_literal, int safe) /* {{{ */
804 {
805 char *result, *rp, *s;
806
807 if (!conn) {
808 return NULL;
809 }
810
811 /* allocate enough memory */
812 rp = result = (char *)safe_emalloc(len, 2, 5); /* leading " E" needs extra 2 bytes + quote_chars on both end for 2 bytes + NULL */
813
814 if (escape_literal) {
815 if (safe) {
816 size_t new_len;
817 char *tmp = (char *)safe_emalloc(len, 2, 1);
818 *rp++ = '\'';
819 /* PQescapeString does not escape \, but it handles multibyte chars safely.
820 This escape is incompatible with PQescapeLiteral. */
821 new_len = PQescapeStringConn(conn, tmp, str, len, NULL);
822 strncpy(rp, tmp, new_len);
823 efree(tmp);
824 rp += new_len;
825 } else {
826 char *encoding;
827 size_t tmp_len;
828 /* This is compatible with PQescapeLiteral, but it cannot handle multbyte chars
829 such as SJIS, BIG5. Raise warning and return NULL by checking
830 client_encoding. */
831 encoding = (char *) pg_encoding_to_char(PQclientEncoding(conn));
832 if (!strncmp(encoding, "SJIS", sizeof("SJIS")-1) ||
833 !strncmp(encoding, "SHIFT_JIS_2004", sizeof("SHIFT_JIS_2004")-1) ||
834 !strncmp(encoding, "BIG5", sizeof("BIG5")-1) ||
835 !strncmp(encoding, "GB18030", sizeof("GB18030")-1) ||
836 !strncmp(encoding, "GBK", sizeof("GBK")-1) ||
837 !strncmp(encoding, "JOHAB", sizeof("JOHAB")-1) ||
838 !strncmp(encoding, "UHC", sizeof("UHC")-1) ) {
839
840 php_error_docref(NULL, E_WARNING, "Unsafe encoding is used. Do not use '%s' encoding or use PostgreSQL 9.0 or later libpq.", encoding);
841 }
842 /* check backslashes */
843 tmp_len = strspn(str, "\\");
844 if (tmp_len != len) {
845 /* add " E" for escaping slashes */
846 *rp++ = ' ';
847 *rp++ = 'E';
848 }
849 *rp++ = '\'';
850 for (s = (char *)str; s - str < len; ++s) {
851 if (*s == '\'' || *s == '\\') {
852 *rp++ = *s;
853 *rp++ = *s;
854 } else {
855 *rp++ = *s;
856 }
857 }
858 }
859 *rp++ = '\'';
860 } else {
861 /* Identifier escape. */
862 *rp++ = '"';
863 for (s = (char *)str; s - str < len; ++s) {
864 if (*s == '"') {
865 *rp++ = '"';
866 *rp++ = '"';
867 } else {
868 *rp++ = *s;
869 }
870 }
871 *rp++ = '"';
872 }
873 *rp = '\0';
874
875 return result;
876 }
877 /* }}} */
878 #endif
879
880 /* {{{ _php_pgsql_trim_message */
_php_pgsql_trim_message(const char * message,size_t * len)881 static char * _php_pgsql_trim_message(const char *message, size_t *len)
882 {
883 register size_t i = strlen(message);
884
885 if (i>2 && (message[i-2] == '\r' || message[i-2] == '\n') && message[i-1] == '.') {
886 --i;
887 }
888 while (i>1 && (message[i-1] == '\r' || message[i-1] == '\n')) {
889 --i;
890 }
891 if (len) {
892 *len = i;
893 }
894 return estrndup(message, i);
895 }
896 /* }}} */
897
898 /* {{{ _php_pgsql_trim_result */
_php_pgsql_trim_result(PGconn * pgsql,char ** buf)899 static inline char * _php_pgsql_trim_result(PGconn * pgsql, char **buf)
900 {
901 return *buf = _php_pgsql_trim_message(PQerrorMessage(pgsql), NULL);
902 }
903 /* }}} */
904
905 #define PQErrorMessageTrim(pgsql, buf) _php_pgsql_trim_result(pgsql, buf)
906
907 #define PHP_PQ_ERROR(text, pgsql) { \
908 char *msgbuf = _php_pgsql_trim_message(PQerrorMessage(pgsql), NULL); \
909 php_error_docref(NULL, E_WARNING, text, msgbuf); \
910 efree(msgbuf); \
911 } \
912
913 /* {{{ php_pgsql_set_default_link
914 */
php_pgsql_set_default_link(zend_resource * res)915 static void php_pgsql_set_default_link(zend_resource *res)
916 {
917 GC_ADDREF(res);
918
919 if (PGG(default_link) != NULL) {
920 zend_list_delete(PGG(default_link));
921 }
922
923 PGG(default_link) = res;
924 }
925 /* }}} */
926
927 /* {{{ _close_pgsql_link
928 */
_close_pgsql_link(zend_resource * rsrc)929 static void _close_pgsql_link(zend_resource *rsrc)
930 {
931 PGconn *link = (PGconn *)rsrc->ptr;
932 PGresult *res;
933 zval *hash;
934
935 while ((res = PQgetResult(link))) {
936 PQclear(res);
937 }
938 PQfinish(link);
939 PGG(num_links)--;
940
941 /* Remove connection hash for this link */
942 hash = zend_hash_index_find(&PGG(hashes), (uintptr_t) link);
943 if (hash) {
944 zend_hash_index_del(&PGG(hashes), (uintptr_t) link);
945 zend_hash_del(&EG(regular_list), Z_STR_P(hash));
946 }
947 }
948 /* }}} */
949
950 /* {{{ _close_pgsql_plink
951 */
_close_pgsql_plink(zend_resource * rsrc)952 static void _close_pgsql_plink(zend_resource *rsrc)
953 {
954 PGconn *link = (PGconn *)rsrc->ptr;
955 PGresult *res;
956
957 while ((res = PQgetResult(link))) {
958 PQclear(res);
959 }
960 PQfinish(link);
961 PGG(num_persistent)--;
962 PGG(num_links)--;
963 }
964 /* }}} */
965
966 /* {{{ _php_pgsql_notice_handler
967 */
_php_pgsql_notice_handler(void * resource_id,const char * message)968 static void _php_pgsql_notice_handler(void *resource_id, const char *message)
969 {
970 zval *notices;
971 zval tmp;
972 char *trimed_message;
973 size_t trimed_message_len;
974
975 if (! PGG(ignore_notices)) {
976 notices = zend_hash_index_find(&PGG(notices), (zend_ulong)resource_id);
977 if (!notices) {
978 array_init(&tmp);
979 notices = &tmp;
980 zend_hash_index_update(&PGG(notices), (zend_ulong)resource_id, notices);
981 }
982 trimed_message = _php_pgsql_trim_message(message, &trimed_message_len);
983 if (PGG(log_notices)) {
984 php_error_docref(NULL, E_NOTICE, "%s", trimed_message);
985 }
986 add_next_index_stringl(notices, trimed_message, trimed_message_len);
987 efree(trimed_message);
988 }
989 }
990 /* }}} */
991
992 /* {{{ _rollback_transactions
993 */
_rollback_transactions(zval * el)994 static int _rollback_transactions(zval *el)
995 {
996 PGconn *link;
997 PGresult *res;
998 zend_resource *rsrc = Z_RES_P(el);
999
1000 if (rsrc->type != le_plink)
1001 return 0;
1002
1003 link = (PGconn *) rsrc->ptr;
1004
1005 if (PQ_SETNONBLOCKING(link, 0)) {
1006 php_error_docref("ref.pgsql", E_NOTICE, "Cannot set connection to blocking mode");
1007 return -1;
1008 }
1009
1010 while ((res = PQgetResult(link))) {
1011 PQclear(res);
1012 }
1013 #if HAVE_PGTRANSACTIONSTATUS && HAVE_PQPROTOCOLVERSION
1014 if ((PQprotocolVersion(link) >= 3 && PQtransactionStatus(link) != PQTRANS_IDLE) || PQprotocolVersion(link) < 3)
1015 #endif
1016 {
1017 int orig = PGG(ignore_notices);
1018 PGG(ignore_notices) = 1;
1019 #if HAVE_PGTRANSACTIONSTATUS && HAVE_PQPROTOCOLVERSION
1020 res = PQexec(link,"ROLLBACK;");
1021 #else
1022 res = PQexec(link,"BEGIN;");
1023 PQclear(res);
1024 res = PQexec(link,"ROLLBACK;");
1025 #endif
1026 PQclear(res);
1027 PGG(ignore_notices) = orig;
1028 }
1029
1030 return 0;
1031 }
1032 /* }}} */
1033
1034 /* {{{ _free_ptr
1035 */
_free_ptr(zend_resource * rsrc)1036 static void _free_ptr(zend_resource *rsrc)
1037 {
1038 pgLofp *lofp = (pgLofp *)rsrc->ptr;
1039 efree(lofp);
1040 }
1041 /* }}} */
1042
1043 /* {{{ _free_result
1044 */
_free_result(zend_resource * rsrc)1045 static void _free_result(zend_resource *rsrc)
1046 {
1047 pgsql_result_handle *pg_result = (pgsql_result_handle *)rsrc->ptr;
1048
1049 PQclear(pg_result->result);
1050 efree(pg_result);
1051 }
1052 /* }}} */
1053
_php_pgsql_detect_identifier_escape(const char * identifier,size_t len)1054 static int _php_pgsql_detect_identifier_escape(const char *identifier, size_t len) /* {{{ */
1055 {
1056 /* Handle edge case. Cannot be a escaped string */
1057 if (len <= 2) {
1058 return FAILURE;
1059 }
1060 /* Detect double quotes */
1061 if (identifier[0] == '"' && identifier[len-1] == '"') {
1062 size_t i;
1063
1064 /* Detect wrong format of " inside of escaped string */
1065 for (i = 1; i < len-1; i++) {
1066 if (identifier[i] == '"' && (identifier[++i] != '"' || i == len-1)) {
1067 return FAILURE;
1068 }
1069 }
1070 } else {
1071 return FAILURE;
1072 }
1073 /* Escaped properly */
1074 return SUCCESS;
1075 }
1076 /* }}} */
1077
1078 /* {{{ PHP_INI
1079 */
1080 PHP_INI_BEGIN()
1081 STD_PHP_INI_BOOLEAN( "pgsql.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateBool, allow_persistent, zend_pgsql_globals, pgsql_globals)
1082 STD_PHP_INI_ENTRY_EX("pgsql.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_persistent, zend_pgsql_globals, pgsql_globals, display_link_numbers)
1083 STD_PHP_INI_ENTRY_EX("pgsql.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_links, zend_pgsql_globals, pgsql_globals, display_link_numbers)
1084 STD_PHP_INI_BOOLEAN( "pgsql.auto_reset_persistent", "0", PHP_INI_SYSTEM, OnUpdateBool, auto_reset_persistent, zend_pgsql_globals, pgsql_globals)
1085 STD_PHP_INI_BOOLEAN( "pgsql.ignore_notice", "0", PHP_INI_ALL, OnUpdateBool, ignore_notices, zend_pgsql_globals, pgsql_globals)
1086 STD_PHP_INI_BOOLEAN( "pgsql.log_notice", "0", PHP_INI_ALL, OnUpdateBool, log_notices, zend_pgsql_globals, pgsql_globals)
PHP_INI_END()1087 PHP_INI_END()
1088 /* }}} */
1089
1090 /* {{{ PHP_GINIT_FUNCTION
1091 */
1092 static PHP_GINIT_FUNCTION(pgsql)
1093 {
1094 #if defined(COMPILE_DL_PGSQL) && defined(ZTS)
1095 ZEND_TSRMLS_CACHE_UPDATE();
1096 #endif
1097 memset(pgsql_globals, 0, sizeof(zend_pgsql_globals));
1098 /* Initialize notice message hash at MINIT only */
1099 zend_hash_init_ex(&pgsql_globals->notices, 0, NULL, ZVAL_PTR_DTOR, 1, 0);
1100 zend_hash_init_ex(&pgsql_globals->hashes, 0, NULL, ZVAL_PTR_DTOR, 1, 0);
1101 }
1102 /* }}} */
1103
1104 /* {{{ PHP_MINIT_FUNCTION
1105 */
PHP_MINIT_FUNCTION(pgsql)1106 PHP_MINIT_FUNCTION(pgsql)
1107 {
1108 REGISTER_INI_ENTRIES();
1109
1110 le_link = zend_register_list_destructors_ex(_close_pgsql_link, NULL, "pgsql link", module_number);
1111 le_plink = zend_register_list_destructors_ex(NULL, _close_pgsql_plink, "pgsql link persistent", module_number);
1112 le_result = zend_register_list_destructors_ex(_free_result, NULL, "pgsql result", module_number);
1113 le_lofp = zend_register_list_destructors_ex(_free_ptr, NULL, "pgsql large object", module_number);
1114 le_string = zend_register_list_destructors_ex(_free_ptr, NULL, "pgsql string", module_number);
1115 #if HAVE_PG_CONFIG_H
1116 /* PG_VERSION - libpq version */
1117 REGISTER_STRING_CONSTANT("PGSQL_LIBPQ_VERSION", PG_VERSION, CONST_CS | CONST_PERSISTENT);
1118 REGISTER_STRING_CONSTANT("PGSQL_LIBPQ_VERSION_STR", PG_VERSION_STR, CONST_CS | CONST_PERSISTENT);
1119 #endif
1120 /* For connection option */
1121 REGISTER_LONG_CONSTANT("PGSQL_CONNECT_FORCE_NEW", PGSQL_CONNECT_FORCE_NEW, CONST_CS | CONST_PERSISTENT);
1122 REGISTER_LONG_CONSTANT("PGSQL_CONNECT_ASYNC", PGSQL_CONNECT_ASYNC, CONST_CS | CONST_PERSISTENT);
1123 /* For pg_fetch_array() */
1124 REGISTER_LONG_CONSTANT("PGSQL_ASSOC", PGSQL_ASSOC, CONST_CS | CONST_PERSISTENT);
1125 REGISTER_LONG_CONSTANT("PGSQL_NUM", PGSQL_NUM, CONST_CS | CONST_PERSISTENT);
1126 REGISTER_LONG_CONSTANT("PGSQL_BOTH", PGSQL_BOTH, CONST_CS | CONST_PERSISTENT);
1127 /* For pg_last_notice() */
1128 REGISTER_LONG_CONSTANT("PGSQL_NOTICE_LAST", PGSQL_NOTICE_LAST, CONST_CS | CONST_PERSISTENT);
1129 REGISTER_LONG_CONSTANT("PGSQL_NOTICE_ALL", PGSQL_NOTICE_ALL, CONST_CS | CONST_PERSISTENT);
1130 REGISTER_LONG_CONSTANT("PGSQL_NOTICE_CLEAR", PGSQL_NOTICE_CLEAR, CONST_CS | CONST_PERSISTENT);
1131 /* For pg_connection_status() */
1132 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_BAD", CONNECTION_BAD, CONST_CS | CONST_PERSISTENT);
1133 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_OK", CONNECTION_OK, CONST_CS | CONST_PERSISTENT);
1134 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_STARTED", CONNECTION_STARTED, CONST_CS | CONST_PERSISTENT);
1135 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_MADE", CONNECTION_MADE, CONST_CS | CONST_PERSISTENT);
1136 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_AWAITING_RESPONSE", CONNECTION_AWAITING_RESPONSE, CONST_CS | CONST_PERSISTENT);
1137 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_AUTH_OK", CONNECTION_AUTH_OK, CONST_CS | CONST_PERSISTENT);
1138 #ifdef CONNECTION_SSL_STARTUP
1139 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_SSL_STARTUP", CONNECTION_SSL_STARTUP, CONST_CS | CONST_PERSISTENT);
1140 #endif
1141 REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_SETENV", CONNECTION_SETENV, CONST_CS | CONST_PERSISTENT);
1142 /* For pg_connect_poll() */
1143 REGISTER_LONG_CONSTANT("PGSQL_POLLING_FAILED", PGRES_POLLING_FAILED, CONST_CS | CONST_PERSISTENT);
1144 REGISTER_LONG_CONSTANT("PGSQL_POLLING_READING", PGRES_POLLING_READING, CONST_CS | CONST_PERSISTENT);
1145 REGISTER_LONG_CONSTANT("PGSQL_POLLING_WRITING", PGRES_POLLING_WRITING, CONST_CS | CONST_PERSISTENT);
1146 REGISTER_LONG_CONSTANT("PGSQL_POLLING_OK", PGRES_POLLING_OK, CONST_CS | CONST_PERSISTENT);
1147 REGISTER_LONG_CONSTANT("PGSQL_POLLING_ACTIVE", PGRES_POLLING_ACTIVE, CONST_CS | CONST_PERSISTENT);
1148 #if HAVE_PGTRANSACTIONSTATUS
1149 /* For pg_transaction_status() */
1150 REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_IDLE", PQTRANS_IDLE, CONST_CS | CONST_PERSISTENT);
1151 REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_ACTIVE", PQTRANS_ACTIVE, CONST_CS | CONST_PERSISTENT);
1152 REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_INTRANS", PQTRANS_INTRANS, CONST_CS | CONST_PERSISTENT);
1153 REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_INERROR", PQTRANS_INERROR, CONST_CS | CONST_PERSISTENT);
1154 REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_UNKNOWN", PQTRANS_UNKNOWN, CONST_CS | CONST_PERSISTENT);
1155 #endif
1156 #if HAVE_PQSETERRORVERBOSITY
1157 /* For pg_set_error_verbosity() */
1158 REGISTER_LONG_CONSTANT("PGSQL_ERRORS_TERSE", PQERRORS_TERSE, CONST_CS | CONST_PERSISTENT);
1159 REGISTER_LONG_CONSTANT("PGSQL_ERRORS_DEFAULT", PQERRORS_DEFAULT, CONST_CS | CONST_PERSISTENT);
1160 REGISTER_LONG_CONSTANT("PGSQL_ERRORS_VERBOSE", PQERRORS_VERBOSE, CONST_CS | CONST_PERSISTENT);
1161 #endif
1162 /* For lo_seek() */
1163 REGISTER_LONG_CONSTANT("PGSQL_SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT);
1164 REGISTER_LONG_CONSTANT("PGSQL_SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT);
1165 REGISTER_LONG_CONSTANT("PGSQL_SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT);
1166 /* For pg_result_status() return value type */
1167 REGISTER_LONG_CONSTANT("PGSQL_STATUS_LONG", PGSQL_STATUS_LONG, CONST_CS | CONST_PERSISTENT);
1168 REGISTER_LONG_CONSTANT("PGSQL_STATUS_STRING", PGSQL_STATUS_STRING, CONST_CS | CONST_PERSISTENT);
1169 /* For pg_result_status() return value */
1170 REGISTER_LONG_CONSTANT("PGSQL_EMPTY_QUERY", PGRES_EMPTY_QUERY, CONST_CS | CONST_PERSISTENT);
1171 REGISTER_LONG_CONSTANT("PGSQL_COMMAND_OK", PGRES_COMMAND_OK, CONST_CS | CONST_PERSISTENT);
1172 REGISTER_LONG_CONSTANT("PGSQL_TUPLES_OK", PGRES_TUPLES_OK, CONST_CS | CONST_PERSISTENT);
1173 REGISTER_LONG_CONSTANT("PGSQL_COPY_OUT", PGRES_COPY_OUT, CONST_CS | CONST_PERSISTENT);
1174 REGISTER_LONG_CONSTANT("PGSQL_COPY_IN", PGRES_COPY_IN, CONST_CS | CONST_PERSISTENT);
1175 REGISTER_LONG_CONSTANT("PGSQL_BAD_RESPONSE", PGRES_BAD_RESPONSE, CONST_CS | CONST_PERSISTENT);
1176 REGISTER_LONG_CONSTANT("PGSQL_NONFATAL_ERROR", PGRES_NONFATAL_ERROR, CONST_CS | CONST_PERSISTENT);
1177 REGISTER_LONG_CONSTANT("PGSQL_FATAL_ERROR", PGRES_FATAL_ERROR, CONST_CS | CONST_PERSISTENT);
1178 #if HAVE_PQRESULTERRORFIELD
1179 /* For pg_result_error_field() field codes */
1180 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SEVERITY", PG_DIAG_SEVERITY, CONST_CS | CONST_PERSISTENT);
1181 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SQLSTATE", PG_DIAG_SQLSTATE, CONST_CS | CONST_PERSISTENT);
1182 REGISTER_LONG_CONSTANT("PGSQL_DIAG_MESSAGE_PRIMARY", PG_DIAG_MESSAGE_PRIMARY, CONST_CS | CONST_PERSISTENT);
1183 REGISTER_LONG_CONSTANT("PGSQL_DIAG_MESSAGE_DETAIL", PG_DIAG_MESSAGE_DETAIL, CONST_CS | CONST_PERSISTENT);
1184 REGISTER_LONG_CONSTANT("PGSQL_DIAG_MESSAGE_HINT", PG_DIAG_MESSAGE_HINT, CONST_CS | CONST_PERSISTENT);
1185 REGISTER_LONG_CONSTANT("PGSQL_DIAG_STATEMENT_POSITION", PG_DIAG_STATEMENT_POSITION, CONST_CS | CONST_PERSISTENT);
1186 #ifdef PG_DIAG_INTERNAL_POSITION
1187 REGISTER_LONG_CONSTANT("PGSQL_DIAG_INTERNAL_POSITION", PG_DIAG_INTERNAL_POSITION, CONST_CS | CONST_PERSISTENT);
1188 #endif
1189 #ifdef PG_DIAG_INTERNAL_QUERY
1190 REGISTER_LONG_CONSTANT("PGSQL_DIAG_INTERNAL_QUERY", PG_DIAG_INTERNAL_QUERY, CONST_CS | CONST_PERSISTENT);
1191 #endif
1192 REGISTER_LONG_CONSTANT("PGSQL_DIAG_CONTEXT", PG_DIAG_CONTEXT, CONST_CS | CONST_PERSISTENT);
1193 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SOURCE_FILE", PG_DIAG_SOURCE_FILE, CONST_CS | CONST_PERSISTENT);
1194 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SOURCE_LINE", PG_DIAG_SOURCE_LINE, CONST_CS | CONST_PERSISTENT);
1195 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SOURCE_FUNCTION", PG_DIAG_SOURCE_FUNCTION, CONST_CS | CONST_PERSISTENT);
1196 #ifdef PG_DIAG_SCHEMA_NAME
1197 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SCHEMA_NAME", PG_DIAG_SCHEMA_NAME, CONST_CS | CONST_PERSISTENT);
1198 #endif
1199 #ifdef PG_DIAG_TABLE_NAME
1200 REGISTER_LONG_CONSTANT("PGSQL_DIAG_TABLE_NAME", PG_DIAG_TABLE_NAME, CONST_CS | CONST_PERSISTENT);
1201 #endif
1202 #ifdef PG_DIAG_COLUMN_NAME
1203 REGISTER_LONG_CONSTANT("PGSQL_DIAG_COLUMN_NAME", PG_DIAG_COLUMN_NAME, CONST_CS | CONST_PERSISTENT);
1204 #endif
1205 #ifdef PG_DIAG_DATATYPE_NAME
1206 REGISTER_LONG_CONSTANT("PGSQL_DIAG_DATATYPE_NAME", PG_DIAG_DATATYPE_NAME, CONST_CS | CONST_PERSISTENT);
1207 #endif
1208 #ifdef PG_DIAG_CONSTRAINT_NAME
1209 REGISTER_LONG_CONSTANT("PGSQL_DIAG_CONSTRAINT_NAME", PG_DIAG_CONSTRAINT_NAME, CONST_CS | CONST_PERSISTENT);
1210 #endif
1211 #ifdef PG_DIAG_SEVERITY_NONLOCALIZED
1212 REGISTER_LONG_CONSTANT("PGSQL_DIAG_SEVERITY_NONLOCALIZED", PG_DIAG_SEVERITY_NONLOCALIZED, CONST_CS | CONST_PERSISTENT);
1213 #endif
1214 #endif
1215 /* pg_convert options */
1216 REGISTER_LONG_CONSTANT("PGSQL_CONV_IGNORE_DEFAULT", PGSQL_CONV_IGNORE_DEFAULT, CONST_CS | CONST_PERSISTENT);
1217 REGISTER_LONG_CONSTANT("PGSQL_CONV_FORCE_NULL", PGSQL_CONV_FORCE_NULL, CONST_CS | CONST_PERSISTENT);
1218 REGISTER_LONG_CONSTANT("PGSQL_CONV_IGNORE_NOT_NULL", PGSQL_CONV_IGNORE_NOT_NULL, CONST_CS | CONST_PERSISTENT);
1219 /* pg_insert/update/delete/select options */
1220 REGISTER_LONG_CONSTANT("PGSQL_DML_ESCAPE", PGSQL_DML_ESCAPE, CONST_CS | CONST_PERSISTENT);
1221 REGISTER_LONG_CONSTANT("PGSQL_DML_NO_CONV", PGSQL_DML_NO_CONV, CONST_CS | CONST_PERSISTENT);
1222 REGISTER_LONG_CONSTANT("PGSQL_DML_EXEC", PGSQL_DML_EXEC, CONST_CS | CONST_PERSISTENT);
1223 REGISTER_LONG_CONSTANT("PGSQL_DML_ASYNC", PGSQL_DML_ASYNC, CONST_CS | CONST_PERSISTENT);
1224 REGISTER_LONG_CONSTANT("PGSQL_DML_STRING", PGSQL_DML_STRING, CONST_CS | CONST_PERSISTENT);
1225 return SUCCESS;
1226 }
1227 /* }}} */
1228
1229 /* {{{ PHP_MSHUTDOWN_FUNCTION
1230 */
PHP_MSHUTDOWN_FUNCTION(pgsql)1231 PHP_MSHUTDOWN_FUNCTION(pgsql)
1232 {
1233 UNREGISTER_INI_ENTRIES();
1234 zend_hash_destroy(&PGG(notices));
1235 zend_hash_destroy(&PGG(hashes));
1236
1237 return SUCCESS;
1238 }
1239 /* }}} */
1240
1241 /* {{{ PHP_RINIT_FUNCTION
1242 */
PHP_RINIT_FUNCTION(pgsql)1243 PHP_RINIT_FUNCTION(pgsql)
1244 {
1245 PGG(default_link) = NULL;
1246 PGG(num_links) = PGG(num_persistent);
1247 return SUCCESS;
1248 }
1249 /* }}} */
1250
1251 /* {{{ PHP_RSHUTDOWN_FUNCTION
1252 */
PHP_RSHUTDOWN_FUNCTION(pgsql)1253 PHP_RSHUTDOWN_FUNCTION(pgsql)
1254 {
1255 /* clean up notice messages */
1256 zend_hash_clean(&PGG(notices));
1257 zend_hash_clean(&PGG(hashes));
1258 /* clean up persistent connection */
1259 zend_hash_apply(&EG(persistent_list), (apply_func_t) _rollback_transactions);
1260 return SUCCESS;
1261 }
1262 /* }}} */
1263
1264 /* {{{ PHP_MINFO_FUNCTION
1265 */
PHP_MINFO_FUNCTION(pgsql)1266 PHP_MINFO_FUNCTION(pgsql)
1267 {
1268 char buf[256];
1269
1270 php_info_print_table_start();
1271 php_info_print_table_header(2, "PostgreSQL Support", "enabled");
1272 #if HAVE_PG_CONFIG_H
1273 php_info_print_table_row(2, "PostgreSQL(libpq) Version", PG_VERSION);
1274 php_info_print_table_row(2, "PostgreSQL(libpq) ", PG_VERSION_STR);
1275 #ifdef HAVE_PGSQL_WITH_MULTIBYTE_SUPPORT
1276 php_info_print_table_row(2, "Multibyte character support", "enabled");
1277 #else
1278 php_info_print_table_row(2, "Multibyte character support", "disabled");
1279 #endif
1280 #if defined(USE_SSL) || defined(USE_OPENSSL)
1281 php_info_print_table_row(2, "SSL support", "enabled");
1282 #else
1283 php_info_print_table_row(2, "SSL support", "disabled");
1284 #endif
1285 #endif /* HAVE_PG_CONFIG_H */
1286 snprintf(buf, sizeof(buf), ZEND_LONG_FMT, PGG(num_persistent));
1287 php_info_print_table_row(2, "Active Persistent Links", buf);
1288 snprintf(buf, sizeof(buf), ZEND_LONG_FMT, PGG(num_links));
1289 php_info_print_table_row(2, "Active Links", buf);
1290 php_info_print_table_end();
1291
1292 DISPLAY_INI_ENTRIES();
1293 }
1294 /* }}} */
1295
1296 /* {{{ php_pgsql_do_connect
1297 */
php_pgsql_do_connect(INTERNAL_FUNCTION_PARAMETERS,int persistent)1298 static void php_pgsql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
1299 {
1300 char *host=NULL,*port=NULL,*options=NULL,*tty=NULL,*dbname=NULL,*connstring=NULL;
1301 PGconn *pgsql;
1302 smart_str str = {0};
1303 zval *args;
1304 uint32_t i;
1305 int connect_type = 0;
1306 PGresult *pg_result;
1307
1308 args = (zval *)safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval), 0);
1309 if (ZEND_NUM_ARGS() < 1 || ZEND_NUM_ARGS() > 5
1310 || zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
1311 efree(args);
1312 WRONG_PARAM_COUNT;
1313 }
1314
1315 smart_str_appends(&str, "pgsql");
1316
1317 for (i = 0; i < ZEND_NUM_ARGS(); i++) {
1318 /* make sure that the PGSQL_CONNECT_FORCE_NEW bit is not part of the hash so that subsequent connections
1319 * can re-use this connection. Bug #39979
1320 */
1321 if (i == 1 && ZEND_NUM_ARGS() == 2 && Z_TYPE(args[i]) == IS_LONG) {
1322 if (Z_LVAL(args[1]) == PGSQL_CONNECT_FORCE_NEW) {
1323 continue;
1324 } else if (Z_LVAL(args[1]) & PGSQL_CONNECT_FORCE_NEW) {
1325 smart_str_append_long(&str, Z_LVAL(args[1]) ^ PGSQL_CONNECT_FORCE_NEW);
1326 }
1327 }
1328 ZVAL_STR(&args[i], zval_get_string(&args[i]));
1329 smart_str_appendc(&str, '_');
1330 smart_str_appendl(&str, Z_STRVAL(args[i]), Z_STRLEN(args[i]));
1331 }
1332
1333 /* Exception thrown during a string conversion. */
1334 if (EG(exception)) {
1335 goto cleanup;
1336 }
1337
1338 smart_str_0(&str);
1339
1340 if (ZEND_NUM_ARGS() == 1) { /* new style, using connection string */
1341 connstring = Z_STRVAL(args[0]);
1342 } else if (ZEND_NUM_ARGS() == 2 ) { /* Safe to add conntype_option, since 2 args was illegal */
1343 connstring = Z_STRVAL(args[0]);
1344 connect_type = (int)zval_get_long(&args[1]);
1345 } else {
1346 host = Z_STRVAL(args[0]);
1347 port = Z_STRVAL(args[1]);
1348 dbname = Z_STRVAL(args[ZEND_NUM_ARGS()-1]);
1349
1350 switch (ZEND_NUM_ARGS()) {
1351 case 5:
1352 tty = Z_STRVAL(args[3]);
1353 /* fall through */
1354 case 4:
1355 options = Z_STRVAL(args[2]);
1356 break;
1357 }
1358 }
1359
1360 if (persistent && PGG(allow_persistent)) {
1361 zend_resource *le;
1362
1363 /* try to find if we already have this link in our persistent list */
1364 if ((le = zend_hash_find_ptr(&EG(persistent_list), str.s)) == NULL) { /* we don't */
1365 if (PGG(max_links) != -1 && PGG(num_links) >= PGG(max_links)) {
1366 php_error_docref(NULL, E_WARNING,
1367 "Cannot create new link. Too many open links (" ZEND_LONG_FMT ")", PGG(num_links));
1368 goto err;
1369 }
1370 if (PGG(max_persistent) != -1 && PGG(num_persistent) >= PGG(max_persistent)) {
1371 php_error_docref(NULL, E_WARNING,
1372 "Cannot create new link. Too many open persistent links (" ZEND_LONG_FMT ")", PGG(num_persistent));
1373 goto err;
1374 }
1375
1376 /* create the link */
1377 if (connstring) {
1378 pgsql = PQconnectdb(connstring);
1379 } else {
1380 pgsql = PQsetdb(host, port, options, tty, dbname);
1381 }
1382 if (pgsql == NULL || PQstatus(pgsql) == CONNECTION_BAD) {
1383 PHP_PQ_ERROR("Unable to connect to PostgreSQL server: %s", pgsql)
1384 if (pgsql) {
1385 PQfinish(pgsql);
1386 }
1387 goto err;
1388 }
1389
1390 /* hash it up */
1391 if (zend_register_persistent_resource(ZSTR_VAL(str.s), ZSTR_LEN(str.s), pgsql, le_plink) == NULL) {
1392 goto err;
1393 }
1394 PGG(num_links)++;
1395 PGG(num_persistent)++;
1396 } else { /* we do */
1397 if (le->type != le_plink) {
1398 goto err;
1399 }
1400 /* ensure that the link did not die */
1401 if (PGG(auto_reset_persistent) & 1) {
1402 /* need to send & get something from backend to
1403 make sure we catch CONNECTION_BAD every time */
1404 PGresult *pg_result;
1405 pg_result = PQexec(le->ptr, "select 1");
1406 PQclear(pg_result);
1407 }
1408 if (PQstatus(le->ptr) == CONNECTION_BAD) { /* the link died */
1409 if (le->ptr == NULL) {
1410 if (connstring) {
1411 le->ptr = PQconnectdb(connstring);
1412 } else {
1413 le->ptr = PQsetdb(host,port,options,tty,dbname);
1414 }
1415 }
1416 else {
1417 PQreset(le->ptr);
1418 }
1419 if (le->ptr == NULL || PQstatus(le->ptr) == CONNECTION_BAD) {
1420 php_error_docref(NULL, E_WARNING,"PostgreSQL link lost, unable to reconnect");
1421 zend_hash_del(&EG(persistent_list), str.s);
1422 goto err;
1423 }
1424 }
1425 pgsql = (PGconn *) le->ptr;
1426 #if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
1427 /* consider to use php_version_compare() here */
1428 if (PQprotocolVersion(pgsql) >= 3 && zend_strtod(PQparameterStatus(pgsql, "server_version"), NULL) >= 7.2) {
1429 #else
1430 if (zend_strtod(PG_VERSION, NULL) >= 7.2) {
1431 #endif
1432 pg_result = PQexec(pgsql, "RESET ALL;");
1433 PQclear(pg_result);
1434 }
1435 }
1436 RETVAL_RES(zend_register_resource(pgsql, le_plink));
1437 } else { /* Non persistent connection */
1438 zend_resource *index_ptr, new_index_ptr;
1439
1440 /* first we check the hash for the hashed_details key. if it exists,
1441 * it should point us to the right offset where the actual pgsql link sits.
1442 * if it doesn't, open a new pgsql link, add it to the resource list,
1443 * and add a pointer to it with hashed_details as the key.
1444 */
1445 if (!(connect_type & PGSQL_CONNECT_FORCE_NEW)
1446 && (index_ptr = zend_hash_find_ptr(&EG(regular_list), str.s)) != NULL) {
1447 zend_resource *link;
1448
1449 if (index_ptr->type != le_index_ptr) {
1450 goto err;
1451 }
1452
1453 link = (zend_resource *)index_ptr->ptr;
1454 ZEND_ASSERT(link->ptr && (link->type == le_link || link->type == le_plink));
1455 php_pgsql_set_default_link(link);
1456 GC_ADDREF(link);
1457 RETVAL_RES(link);
1458 goto cleanup;
1459 }
1460 if (PGG(max_links) != -1 && PGG(num_links) >= PGG(max_links)) {
1461 php_error_docref(NULL, E_WARNING, "Cannot create new link. Too many open links (" ZEND_LONG_FMT ")", PGG(num_links));
1462 goto err;
1463 }
1464
1465 /* Non-blocking connect */
1466 if (connect_type & PGSQL_CONNECT_ASYNC) {
1467 if (connstring) {
1468 pgsql = PQconnectStart(connstring);
1469 if (pgsql==NULL || PQstatus(pgsql)==CONNECTION_BAD) {
1470 PHP_PQ_ERROR("Unable to connect to PostgreSQL server: %s", pgsql);
1471 if (pgsql) {
1472 PQfinish(pgsql);
1473 }
1474 goto err;
1475 }
1476 } else {
1477 php_error_docref(NULL, E_WARNING, "Connection string required for async connections");
1478 goto err;
1479 }
1480 } else {
1481 if (connstring) {
1482 pgsql = PQconnectdb(connstring);
1483 } else {
1484 pgsql = PQsetdb(host,port,options,tty,dbname);
1485 }
1486 if (pgsql==NULL || PQstatus(pgsql)==CONNECTION_BAD) {
1487 PHP_PQ_ERROR("Unable to connect to PostgreSQL server: %s", pgsql);
1488 if (pgsql) {
1489 PQfinish(pgsql);
1490 }
1491 goto err;
1492 }
1493 }
1494
1495 /* add it to the list */
1496 RETVAL_RES(zend_register_resource(pgsql, le_link));
1497
1498 /* add it to the hash */
1499 new_index_ptr.ptr = (void *) Z_RES_P(return_value);
1500 new_index_ptr.type = le_index_ptr;
1501 zend_hash_update_mem(&EG(regular_list), str.s, (void *) &new_index_ptr, sizeof(zend_resource));
1502
1503 /* Keep track of link => hash mapping, so we can remove the hash entry from regular_list
1504 * when the connection is closed. This uses the address of the connection rather than the
1505 * zend_resource, because the resource destructor is passed a stack copy of the resource
1506 * structure. */
1507 {
1508 zval tmp;
1509 ZVAL_STR_COPY(&tmp, str.s);
1510 zend_hash_index_update(&PGG(hashes), (uintptr_t) pgsql, &tmp);
1511 }
1512 PGG(num_links)++;
1513 }
1514 /* set notice processor */
1515 if (! PGG(ignore_notices) && Z_TYPE_P(return_value) == IS_RESOURCE) {
1516 PQsetNoticeProcessor(pgsql, _php_pgsql_notice_handler, (void*)(zend_uintptr_t)Z_RES_HANDLE_P(return_value));
1517 }
1518 php_pgsql_set_default_link(Z_RES_P(return_value));
1519
1520 cleanup:
1521 for (i = 0; i < ZEND_NUM_ARGS(); i++) {
1522 zval_ptr_dtor(&args[i]);
1523 }
1524 efree(args);
1525 smart_str_free(&str);
1526 return;
1527
1528 err:
1529 for (i = 0; i < ZEND_NUM_ARGS(); i++) {
1530 zval_ptr_dtor(&args[i]);
1531 }
1532 efree(args);
1533 smart_str_free(&str);
1534 RETURN_FALSE;
1535 }
1536 /* }}} */
1537
1538 /* {{{ proto resource pg_connect(string connection_string[, int connect_type] | [string host, string port [, string options [, string tty,]]] string database)
1539 Open a PostgreSQL connection */
1540 PHP_FUNCTION(pg_connect)
1541 {
1542 php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);
1543 }
1544 /* }}} */
1545
1546 /* {{{ proto resource pg_connect_poll(resource connection)
1547 Poll the status of an in-progress async PostgreSQL connection attempt*/
1548 PHP_FUNCTION(pg_connect_poll)
1549 {
1550 zval *pgsql_link;
1551 PGconn *pgsql;
1552 int ret;
1553
1554 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_link) == FAILURE) {
1555 return;
1556 }
1557
1558 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
1559 RETURN_FALSE;
1560 }
1561
1562 ret = PQconnectPoll(pgsql);
1563
1564 RETURN_LONG(ret);
1565 }
1566 /* }}} */
1567
1568 /* {{{ proto resource pg_pconnect(string connection_string | [string host, string port [, string options [, string tty,]]] string database)
1569 Open a persistent PostgreSQL connection */
1570 PHP_FUNCTION(pg_pconnect)
1571 {
1572 php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);
1573 }
1574 /* }}} */
1575
1576 /* {{{ proto bool pg_close([resource connection])
1577 Close a PostgreSQL connection */
1578 PHP_FUNCTION(pg_close)
1579 {
1580 zval *pgsql_link = NULL;
1581 zend_resource *link;
1582
1583 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|r", &pgsql_link) == FAILURE) {
1584 return;
1585 }
1586
1587 if (!pgsql_link) {
1588 link = PGG(default_link);
1589 CHECK_DEFAULT_LINK(link);
1590 zend_list_delete(link);
1591 PGG(default_link) = NULL;
1592 RETURN_TRUE;
1593 }
1594
1595 link = Z_RES_P(pgsql_link);
1596 if (zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink) == NULL) {
1597 RETURN_FALSE;
1598 }
1599
1600 if (link == PGG(default_link)) {
1601 zend_list_delete(link);
1602 PGG(default_link) = NULL;
1603 }
1604 zend_list_close(link);
1605
1606 RETURN_TRUE;
1607 }
1608 /* }}} */
1609
1610 #define PHP_PG_DBNAME 1
1611 #define PHP_PG_ERROR_MESSAGE 2
1612 #define PHP_PG_OPTIONS 3
1613 #define PHP_PG_PORT 4
1614 #define PHP_PG_TTY 5
1615 #define PHP_PG_HOST 6
1616 #define PHP_PG_VERSION 7
1617
1618 /* {{{ php_pgsql_get_link_info
1619 */
1620 static void php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
1621 {
1622 zend_resource *link;
1623 zval *pgsql_link = NULL;
1624 int argc = ZEND_NUM_ARGS();
1625 PGconn *pgsql;
1626 char *msgbuf;
1627 char *result;
1628
1629 if (zend_parse_parameters(argc, "|r", &pgsql_link) == FAILURE) {
1630 return;
1631 }
1632
1633 if (argc == 0) {
1634 link = FETCH_DEFAULT_LINK();
1635 CHECK_DEFAULT_LINK(link);
1636 } else {
1637 link = Z_RES_P(pgsql_link);
1638 }
1639
1640 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
1641 RETURN_FALSE;
1642 }
1643
1644 switch(entry_type) {
1645 case PHP_PG_DBNAME:
1646 result = PQdb(pgsql);
1647 break;
1648 case PHP_PG_ERROR_MESSAGE:
1649 result = PQErrorMessageTrim(pgsql, &msgbuf);
1650 RETVAL_STRING(result);
1651 efree(result);
1652 return;
1653 case PHP_PG_OPTIONS:
1654 result = PQoptions(pgsql);
1655 break;
1656 case PHP_PG_PORT:
1657 result = PQport(pgsql);
1658 break;
1659 case PHP_PG_TTY:
1660 result = PQtty(pgsql);
1661 break;
1662 case PHP_PG_HOST:
1663 result = PQhost(pgsql);
1664 break;
1665 case PHP_PG_VERSION:
1666 array_init(return_value);
1667 add_assoc_string(return_value, "client", PG_VERSION);
1668 #if HAVE_PQPROTOCOLVERSION
1669 add_assoc_long(return_value, "protocol", PQprotocolVersion(pgsql));
1670 #if HAVE_PQPARAMETERSTATUS
1671 if (PQprotocolVersion(pgsql) >= 3) {
1672 /* 8.0 or grater supports protorol version 3 */
1673 char *tmp;
1674 add_assoc_string(return_value, "server", (char*)PQparameterStatus(pgsql, "server_version"));
1675
1676 #define PHP_PQ_COPY_PARAM(_x) tmp = (char*)PQparameterStatus(pgsql, _x); \
1677 if(tmp) add_assoc_string(return_value, _x, tmp); \
1678 else add_assoc_null(return_value, _x);
1679
1680 PHP_PQ_COPY_PARAM("server_encoding");
1681 PHP_PQ_COPY_PARAM("client_encoding");
1682 PHP_PQ_COPY_PARAM("is_superuser");
1683 PHP_PQ_COPY_PARAM("session_authorization");
1684 PHP_PQ_COPY_PARAM("DateStyle");
1685 PHP_PQ_COPY_PARAM("IntervalStyle");
1686 PHP_PQ_COPY_PARAM("TimeZone");
1687 PHP_PQ_COPY_PARAM("integer_datetimes");
1688 PHP_PQ_COPY_PARAM("standard_conforming_strings");
1689 PHP_PQ_COPY_PARAM("application_name");
1690 }
1691 #endif
1692 #endif
1693 return;
1694 default:
1695 RETURN_FALSE;
1696 }
1697 if (result) {
1698 RETURN_STRING(result);
1699 } else {
1700 RETURN_EMPTY_STRING();
1701 }
1702 }
1703 /* }}} */
1704
1705 /* {{{ proto string pg_dbname([resource connection])
1706 Get the database name */
1707 PHP_FUNCTION(pg_dbname)
1708 {
1709 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_DBNAME);
1710 }
1711 /* }}} */
1712
1713 /* {{{ proto string pg_last_error([resource connection])
1714 Get the error message string */
1715 PHP_FUNCTION(pg_last_error)
1716 {
1717 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_ERROR_MESSAGE);
1718 }
1719 /* }}} */
1720
1721 /* {{{ proto string pg_options([resource connection])
1722 Get the options associated with the connection */
1723 PHP_FUNCTION(pg_options)
1724 {
1725 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_OPTIONS);
1726 }
1727 /* }}} */
1728
1729 /* {{{ proto int pg_port([resource connection])
1730 Return the port number associated with the connection */
1731 PHP_FUNCTION(pg_port)
1732 {
1733 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_PORT);
1734 }
1735 /* }}} */
1736
1737 /* {{{ proto string pg_tty([resource connection])
1738 Return the tty name associated with the connection */
1739 PHP_FUNCTION(pg_tty)
1740 {
1741 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_TTY);
1742 }
1743 /* }}} */
1744
1745 /* {{{ proto string pg_host([resource connection])
1746 Returns the host name associated with the connection */
1747 PHP_FUNCTION(pg_host)
1748 {
1749 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_HOST);
1750 }
1751 /* }}} */
1752
1753 /* {{{ proto array pg_version([resource connection])
1754 Returns an array with client, protocol and server version (when available) */
1755 PHP_FUNCTION(pg_version)
1756 {
1757 php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_VERSION);
1758 }
1759 /* }}} */
1760
1761 #if HAVE_PQPARAMETERSTATUS
1762 /* {{{ proto string|false pg_parameter_status([resource connection,] string param_name)
1763 Returns the value of a server parameter */
1764 PHP_FUNCTION(pg_parameter_status)
1765 {
1766 zval *pgsql_link = NULL;
1767 zend_resource *link;
1768 PGconn *pgsql;
1769 char *param;
1770 size_t len;
1771
1772 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "rs", &pgsql_link, ¶m, &len) == FAILURE) {
1773 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m, &len) == SUCCESS) {
1774 link = FETCH_DEFAULT_LINK();
1775 CHECK_DEFAULT_LINK(link);
1776 } else {
1777 RETURN_FALSE;
1778 }
1779 } else {
1780 link = Z_RES_P(pgsql_link);
1781 }
1782
1783 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
1784 RETURN_FALSE;
1785 }
1786
1787 param = (char*)PQparameterStatus(pgsql, param);
1788 if (param) {
1789 RETURN_STRING(param);
1790 } else {
1791 RETURN_FALSE;
1792 }
1793 }
1794 /* }}} */
1795 #endif
1796
1797 /* {{{ proto bool pg_ping([resource connection])
1798 Ping database. If connection is bad, try to reconnect. */
1799 PHP_FUNCTION(pg_ping)
1800 {
1801 zval *pgsql_link;
1802 PGconn *pgsql;
1803 PGresult *res;
1804 zend_resource *link;
1805
1806 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r", &pgsql_link) == SUCCESS) {
1807 link = Z_RES_P(pgsql_link);
1808 } else {
1809 link = FETCH_DEFAULT_LINK();
1810 CHECK_DEFAULT_LINK(link);
1811 }
1812
1813 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
1814 RETURN_FALSE;
1815 }
1816
1817 /* ping connection */
1818 res = PQexec(pgsql, "SELECT 1;");
1819 PQclear(res);
1820
1821 /* check status. */
1822 if (PQstatus(pgsql) == CONNECTION_OK)
1823 RETURN_TRUE;
1824
1825 /* reset connection if it's broken */
1826 PQreset(pgsql);
1827 if (PQstatus(pgsql) == CONNECTION_OK) {
1828 RETURN_TRUE;
1829 }
1830 RETURN_FALSE;
1831 }
1832 /* }}} */
1833
1834 /* {{{ proto resource pg_query([resource connection,] string query)
1835 Execute a query */
1836 PHP_FUNCTION(pg_query)
1837 {
1838 zval *pgsql_link = NULL;
1839 char *query;
1840 int argc = ZEND_NUM_ARGS();
1841 size_t query_len;
1842 int leftover = 0;
1843 zend_resource *link;
1844 PGconn *pgsql;
1845 PGresult *pgsql_result;
1846 ExecStatusType status;
1847
1848 if (argc == 1) {
1849 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &query, &query_len) == FAILURE) {
1850 return;
1851 }
1852 link = FETCH_DEFAULT_LINK();
1853 CHECK_DEFAULT_LINK(link);
1854 } else {
1855 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &pgsql_link, &query, &query_len) == FAILURE) {
1856 return;
1857 }
1858 link = Z_RES_P(pgsql_link);
1859 }
1860
1861 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
1862 RETURN_FALSE;
1863 }
1864
1865 if (PQ_SETNONBLOCKING(pgsql, 0)) {
1866 php_error_docref(NULL, E_NOTICE,"Cannot set connection to blocking mode");
1867 RETURN_FALSE;
1868 }
1869 while ((pgsql_result = PQgetResult(pgsql))) {
1870 PQclear(pgsql_result);
1871 leftover = 1;
1872 }
1873 if (leftover) {
1874 php_error_docref(NULL, E_NOTICE, "Found results on this connection. Use pg_get_result() to get these results first");
1875 }
1876 pgsql_result = PQexec(pgsql, query);
1877 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
1878 PQclear(pgsql_result);
1879 PQreset(pgsql);
1880 pgsql_result = PQexec(pgsql, query);
1881 }
1882
1883 if (pgsql_result) {
1884 status = PQresultStatus(pgsql_result);
1885 } else {
1886 status = (ExecStatusType) PQstatus(pgsql);
1887 }
1888
1889 switch (status) {
1890 case PGRES_EMPTY_QUERY:
1891 case PGRES_BAD_RESPONSE:
1892 case PGRES_NONFATAL_ERROR:
1893 case PGRES_FATAL_ERROR:
1894 PHP_PQ_ERROR("Query failed: %s", pgsql);
1895 PQclear(pgsql_result);
1896 RETURN_FALSE;
1897 break;
1898 case PGRES_COMMAND_OK: /* successful command that did not return rows */
1899 default:
1900 if (pgsql_result) {
1901 pgsql_result_handle *pg_result = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
1902 pg_result->conn = pgsql;
1903 pg_result->result = pgsql_result;
1904 pg_result->row = 0;
1905 RETURN_RES(zend_register_resource(pg_result, le_result));
1906 } else {
1907 PQclear(pgsql_result);
1908 RETURN_FALSE;
1909 }
1910 break;
1911 }
1912 }
1913 /* }}} */
1914
1915 #if HAVE_PQEXECPARAMS || HAVE_PQEXECPREPARED || HAVE_PQSENDQUERYPARAMS || HAVE_PQSENDQUERYPREPARED
1916 /* {{{ _php_pgsql_free_params */
1917 static void _php_pgsql_free_params(char **params, int num_params)
1918 {
1919 if (num_params > 0) {
1920 int i;
1921 for (i = 0; i < num_params; i++) {
1922 if (params[i]) {
1923 efree(params[i]);
1924 }
1925 }
1926 efree(params);
1927 }
1928 }
1929 /* }}} */
1930 #endif
1931
1932 #if HAVE_PQEXECPARAMS
1933 /* {{{ proto resource pg_query_params([resource connection,] string query, array params)
1934 Execute a query */
1935 PHP_FUNCTION(pg_query_params)
1936 {
1937 zval *pgsql_link = NULL;
1938 zval *pv_param_arr, *tmp;
1939 char *query;
1940 size_t query_len;
1941 int argc = ZEND_NUM_ARGS();
1942 int leftover = 0;
1943 int num_params = 0;
1944 char **params = NULL;
1945 zend_resource *link;
1946 PGconn *pgsql;
1947 PGresult *pgsql_result;
1948 ExecStatusType status;
1949 pgsql_result_handle *pg_result;
1950
1951 if (argc == 2) {
1952 if (zend_parse_parameters(argc, "sa", &query, &query_len, &pv_param_arr) == FAILURE) {
1953 return;
1954 }
1955 link = FETCH_DEFAULT_LINK();
1956 CHECK_DEFAULT_LINK(link);
1957 } else {
1958 if (zend_parse_parameters(argc, "rsa", &pgsql_link, &query, &query_len, &pv_param_arr) == FAILURE) {
1959 return;
1960 }
1961 link = Z_RES_P(pgsql_link);
1962 }
1963
1964 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
1965 RETURN_FALSE;
1966 }
1967
1968 if (PQ_SETNONBLOCKING(pgsql, 0)) {
1969 php_error_docref(NULL, E_NOTICE,"Cannot set connection to blocking mode");
1970 RETURN_FALSE;
1971 }
1972 while ((pgsql_result = PQgetResult(pgsql))) {
1973 PQclear(pgsql_result);
1974 leftover = 1;
1975 }
1976 if (leftover) {
1977 php_error_docref(NULL, E_NOTICE, "Found results on this connection. Use pg_get_result() to get these results first");
1978 }
1979
1980 num_params = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr));
1981 if (num_params > 0) {
1982 int i = 0;
1983 params = (char **)safe_emalloc(sizeof(char *), num_params, 0);
1984
1985 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pv_param_arr), tmp) {
1986 ZVAL_DEREF(tmp);
1987 if (Z_TYPE_P(tmp) == IS_NULL) {
1988 params[i] = NULL;
1989 } else {
1990 zval tmp_val;
1991
1992 ZVAL_COPY(&tmp_val, tmp);
1993 convert_to_cstring(&tmp_val);
1994 if (Z_TYPE(tmp_val) != IS_STRING) {
1995 php_error_docref(NULL, E_WARNING,"Error converting parameter");
1996 zval_ptr_dtor(&tmp_val);
1997 _php_pgsql_free_params(params, i);
1998 RETURN_FALSE;
1999 }
2000 params[i] = estrndup(Z_STRVAL(tmp_val), Z_STRLEN(tmp_val));
2001 zval_ptr_dtor(&tmp_val);
2002 }
2003 i++;
2004 } ZEND_HASH_FOREACH_END();
2005 }
2006
2007 pgsql_result = PQexecParams(pgsql, query, num_params,
2008 NULL, (const char * const *)params, NULL, NULL, 0);
2009 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
2010 PQclear(pgsql_result);
2011 PQreset(pgsql);
2012 pgsql_result = PQexecParams(pgsql, query, num_params,
2013 NULL, (const char * const *)params, NULL, NULL, 0);
2014 }
2015
2016 if (pgsql_result) {
2017 status = PQresultStatus(pgsql_result);
2018 } else {
2019 status = (ExecStatusType) PQstatus(pgsql);
2020 }
2021
2022 _php_pgsql_free_params(params, num_params);
2023
2024 switch (status) {
2025 case PGRES_EMPTY_QUERY:
2026 case PGRES_BAD_RESPONSE:
2027 case PGRES_NONFATAL_ERROR:
2028 case PGRES_FATAL_ERROR:
2029 PHP_PQ_ERROR("Query failed: %s", pgsql);
2030 PQclear(pgsql_result);
2031 RETURN_FALSE;
2032 break;
2033 case PGRES_COMMAND_OK: /* successful command that did not return rows */
2034 default:
2035 if (pgsql_result) {
2036 pg_result = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
2037 pg_result->conn = pgsql;
2038 pg_result->result = pgsql_result;
2039 pg_result->row = 0;
2040 RETURN_RES(zend_register_resource(pg_result, le_result));
2041 } else {
2042 PQclear(pgsql_result);
2043 RETURN_FALSE;
2044 }
2045 break;
2046 }
2047 }
2048 /* }}} */
2049 #endif
2050
2051 #if HAVE_PQPREPARE
2052 /* {{{ proto resource pg_prepare([resource connection,] string stmtname, string query)
2053 Prepare a query for future execution */
2054 PHP_FUNCTION(pg_prepare)
2055 {
2056 zval *pgsql_link = NULL;
2057 char *query, *stmtname;
2058 size_t query_len, stmtname_len;
2059 int argc = ZEND_NUM_ARGS();
2060 int leftover = 0;
2061 PGconn *pgsql;
2062 zend_resource *link;
2063 PGresult *pgsql_result;
2064 ExecStatusType status;
2065 pgsql_result_handle *pg_result;
2066
2067 if (argc == 2) {
2068 if (zend_parse_parameters(argc, "ss", &stmtname, &stmtname_len, &query, &query_len) == FAILURE) {
2069 return;
2070 }
2071 link = FETCH_DEFAULT_LINK();
2072 CHECK_DEFAULT_LINK(link);
2073 } else {
2074 if (zend_parse_parameters(argc, "rss", &pgsql_link, &stmtname, &stmtname_len, &query, &query_len) == FAILURE) {
2075 return;
2076 }
2077 link = Z_RES_P(pgsql_link);
2078 }
2079
2080 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
2081 RETURN_FALSE;
2082 }
2083
2084 if (PQ_SETNONBLOCKING(pgsql, 0)) {
2085 php_error_docref(NULL, E_NOTICE,"Cannot set connection to blocking mode");
2086 RETURN_FALSE;
2087 }
2088 while ((pgsql_result = PQgetResult(pgsql))) {
2089 PQclear(pgsql_result);
2090 leftover = 1;
2091 }
2092 if (leftover) {
2093 php_error_docref(NULL, E_NOTICE, "Found results on this connection. Use pg_get_result() to get these results first");
2094 }
2095 pgsql_result = PQprepare(pgsql, stmtname, query, 0, NULL);
2096 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
2097 PQclear(pgsql_result);
2098 PQreset(pgsql);
2099 pgsql_result = PQprepare(pgsql, stmtname, query, 0, NULL);
2100 }
2101
2102 if (pgsql_result) {
2103 status = PQresultStatus(pgsql_result);
2104 } else {
2105 status = (ExecStatusType) PQstatus(pgsql);
2106 }
2107
2108 switch (status) {
2109 case PGRES_EMPTY_QUERY:
2110 case PGRES_BAD_RESPONSE:
2111 case PGRES_NONFATAL_ERROR:
2112 case PGRES_FATAL_ERROR:
2113 PHP_PQ_ERROR("Query failed: %s", pgsql);
2114 PQclear(pgsql_result);
2115 RETURN_FALSE;
2116 break;
2117 case PGRES_COMMAND_OK: /* successful command that did not return rows */
2118 default:
2119 if (pgsql_result) {
2120 pg_result = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
2121 pg_result->conn = pgsql;
2122 pg_result->result = pgsql_result;
2123 pg_result->row = 0;
2124 RETURN_RES(zend_register_resource(pg_result, le_result));
2125 } else {
2126 PQclear(pgsql_result);
2127 RETURN_FALSE;
2128 }
2129 break;
2130 }
2131 }
2132 /* }}} */
2133 #endif
2134
2135 #if HAVE_PQEXECPREPARED
2136 /* {{{ proto resource pg_execute([resource connection,] string stmtname, array params)
2137 Execute a prepared query */
2138 PHP_FUNCTION(pg_execute)
2139 {
2140 zval *pgsql_link = NULL;
2141 zval *pv_param_arr, *tmp;
2142 char *stmtname;
2143 size_t stmtname_len;
2144 int argc = ZEND_NUM_ARGS();
2145 int leftover = 0;
2146 int num_params = 0;
2147 char **params = NULL;
2148 PGconn *pgsql;
2149 zend_resource *link;
2150 PGresult *pgsql_result;
2151 ExecStatusType status;
2152 pgsql_result_handle *pg_result;
2153
2154 if (argc == 2) {
2155 if (zend_parse_parameters(argc, "sa", &stmtname, &stmtname_len, &pv_param_arr)==FAILURE) {
2156 return;
2157 }
2158 link = FETCH_DEFAULT_LINK();
2159 CHECK_DEFAULT_LINK(link);
2160 } else {
2161 if (zend_parse_parameters(argc, "rsa", &pgsql_link, &stmtname, &stmtname_len, &pv_param_arr) == FAILURE) {
2162 return;
2163 }
2164 link = Z_RES_P(pgsql_link);
2165 }
2166
2167 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
2168 RETURN_FALSE;
2169 }
2170
2171 if (PQ_SETNONBLOCKING(pgsql, 0)) {
2172 php_error_docref(NULL, E_NOTICE,"Cannot set connection to blocking mode");
2173 RETURN_FALSE;
2174 }
2175 while ((pgsql_result = PQgetResult(pgsql))) {
2176 PQclear(pgsql_result);
2177 leftover = 1;
2178 }
2179 if (leftover) {
2180 php_error_docref(NULL, E_NOTICE, "Found results on this connection. Use pg_get_result() to get these results first");
2181 }
2182
2183 num_params = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr));
2184 if (num_params > 0) {
2185 int i = 0;
2186 params = (char **)safe_emalloc(sizeof(char *), num_params, 0);
2187
2188 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pv_param_arr), tmp) {
2189
2190 if (Z_TYPE_P(tmp) == IS_NULL) {
2191 params[i] = NULL;
2192 } else {
2193 zend_string *tmp_str;
2194 zend_string *str = zval_get_tmp_string(tmp, &tmp_str);
2195
2196 params[i] = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
2197 zend_tmp_string_release(tmp_str);
2198 }
2199
2200 i++;
2201 } ZEND_HASH_FOREACH_END();
2202 }
2203
2204 pgsql_result = PQexecPrepared(pgsql, stmtname, num_params,
2205 (const char * const *)params, NULL, NULL, 0);
2206 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
2207 PQclear(pgsql_result);
2208 PQreset(pgsql);
2209 pgsql_result = PQexecPrepared(pgsql, stmtname, num_params,
2210 (const char * const *)params, NULL, NULL, 0);
2211 }
2212
2213 if (pgsql_result) {
2214 status = PQresultStatus(pgsql_result);
2215 } else {
2216 status = (ExecStatusType) PQstatus(pgsql);
2217 }
2218
2219 _php_pgsql_free_params(params, num_params);
2220
2221 switch (status) {
2222 case PGRES_EMPTY_QUERY:
2223 case PGRES_BAD_RESPONSE:
2224 case PGRES_NONFATAL_ERROR:
2225 case PGRES_FATAL_ERROR:
2226 PHP_PQ_ERROR("Query failed: %s", pgsql);
2227 PQclear(pgsql_result);
2228 RETURN_FALSE;
2229 break;
2230 case PGRES_COMMAND_OK: /* successful command that did not return rows */
2231 default:
2232 if (pgsql_result) {
2233 pg_result = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
2234 pg_result->conn = pgsql;
2235 pg_result->result = pgsql_result;
2236 pg_result->row = 0;
2237 RETURN_RES(zend_register_resource(pg_result, le_result));
2238 } else {
2239 PQclear(pgsql_result);
2240 RETURN_FALSE;
2241 }
2242 break;
2243 }
2244 }
2245 /* }}} */
2246 #endif
2247
2248 #define PHP_PG_NUM_ROWS 1
2249 #define PHP_PG_NUM_FIELDS 2
2250 #define PHP_PG_CMD_TUPLES 3
2251
2252 /* {{{ php_pgsql_get_result_info
2253 */
2254 static void php_pgsql_get_result_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
2255 {
2256 zval *result;
2257 PGresult *pgsql_result;
2258 pgsql_result_handle *pg_result;
2259
2260 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &result) == FAILURE) {
2261 return;
2262 }
2263
2264 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2265 RETURN_FALSE;
2266 }
2267
2268 pgsql_result = pg_result->result;
2269
2270 switch (entry_type) {
2271 case PHP_PG_NUM_ROWS:
2272 RETVAL_LONG(PQntuples(pgsql_result));
2273 break;
2274 case PHP_PG_NUM_FIELDS:
2275 RETVAL_LONG(PQnfields(pgsql_result));
2276 break;
2277 case PHP_PG_CMD_TUPLES:
2278 #if HAVE_PQCMDTUPLES
2279 RETVAL_LONG(atoi(PQcmdTuples(pgsql_result)));
2280 #else
2281 php_error_docref(NULL, E_WARNING, "Not supported under this build");
2282 RETVAL_LONG(0);
2283 #endif
2284 break;
2285 default:
2286 RETURN_FALSE;
2287 }
2288 }
2289 /* }}} */
2290
2291 /* {{{ proto int pg_num_rows(resource result)
2292 Return the number of rows in the result */
2293 PHP_FUNCTION(pg_num_rows)
2294 {
2295 php_pgsql_get_result_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_NUM_ROWS);
2296 }
2297 /* }}} */
2298
2299 /* {{{ proto int pg_num_fields(resource result)
2300 Return the number of fields in the result */
2301 PHP_FUNCTION(pg_num_fields)
2302 {
2303 php_pgsql_get_result_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_NUM_FIELDS);
2304 }
2305 /* }}} */
2306
2307 #if HAVE_PQCMDTUPLES
2308 /* {{{ proto int pg_affected_rows(resource result)
2309 Returns the number of affected tuples */
2310 PHP_FUNCTION(pg_affected_rows)
2311 {
2312 php_pgsql_get_result_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_CMD_TUPLES);
2313 }
2314 /* }}} */
2315 #endif
2316
2317 /* {{{ proto mixed pg_last_notice(resource connection [, int option])
2318 Returns the last notice set by the backend */
2319 PHP_FUNCTION(pg_last_notice)
2320 {
2321 zval *pgsql_link = NULL;
2322 zval *notice, *notices;
2323 PGconn *pg_link;
2324 zend_long option = PGSQL_NOTICE_LAST;
2325
2326 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &pgsql_link, &option) == FAILURE) {
2327 return;
2328 }
2329
2330 /* Just to check if user passed valid resoruce */
2331 if ((pg_link = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
2332 RETURN_FALSE;
2333 }
2334
2335 notices = zend_hash_index_find(&PGG(notices), (zend_ulong)Z_RES_HANDLE_P(pgsql_link));
2336 switch (option) {
2337 case PGSQL_NOTICE_LAST:
2338 if (notices) {
2339 zend_hash_internal_pointer_end(Z_ARRVAL_P(notices));
2340 if ((notice = zend_hash_get_current_data(Z_ARRVAL_P(notices))) == NULL) {
2341 RETURN_EMPTY_STRING();
2342 }
2343 RETURN_ZVAL(notice, 1, 0);
2344 } else {
2345 RETURN_EMPTY_STRING();
2346 }
2347 break;
2348 case PGSQL_NOTICE_ALL:
2349 if (notices) {
2350 RETURN_ZVAL(notices, 1, 0);
2351 } else {
2352 array_init(return_value);
2353 return;
2354 }
2355 break;
2356 case PGSQL_NOTICE_CLEAR:
2357 if (notices) {
2358 zend_hash_clean(&PGG(notices));
2359 }
2360 RETURN_TRUE;
2361 break;
2362 default:
2363 php_error_docref(NULL, E_WARNING,
2364 "Invalid option specified (" ZEND_LONG_FMT ")", option);
2365 }
2366 RETURN_FALSE;
2367 }
2368 /* }}} */
2369
2370 /* {{{ get_field_name
2371 */
2372 static char *get_field_name(PGconn *pgsql, Oid oid, HashTable *list)
2373 {
2374 smart_str str = {0};
2375 zend_resource *field_type;
2376 char *ret=NULL;
2377
2378 /* try to lookup the type in the resource list */
2379 smart_str_appends(&str, "pgsql_oid_");
2380 smart_str_append_unsigned(&str, oid);
2381 smart_str_0(&str);
2382
2383 if ((field_type = zend_hash_find_ptr(list, str.s)) != NULL) {
2384 ret = estrdup((char *)field_type->ptr);
2385 } else { /* hash all oid's */
2386 int i, num_rows;
2387 int oid_offset,name_offset;
2388 char *tmp_oid, *end_ptr, *tmp_name;
2389 zend_resource new_oid_entry;
2390 PGresult *result;
2391
2392 if ((result = PQexec(pgsql, "select oid,typname from pg_type")) == NULL || PQresultStatus(result) != PGRES_TUPLES_OK) {
2393 if (result) {
2394 PQclear(result);
2395 }
2396 smart_str_free(&str);
2397 return estrndup("", sizeof("") - 1);
2398 }
2399 num_rows = PQntuples(result);
2400 oid_offset = PQfnumber(result,"oid");
2401 name_offset = PQfnumber(result,"typname");
2402
2403 for (i=0; i<num_rows; i++) {
2404 if ((tmp_oid = PQgetvalue(result,i,oid_offset))==NULL) {
2405 continue;
2406 }
2407
2408 smart_str_free(&str);
2409 smart_str_appends(&str, "pgsql_oid_");
2410 smart_str_appends(&str, tmp_oid);
2411 smart_str_0(&str);
2412
2413 if ((tmp_name = PQgetvalue(result,i,name_offset))==NULL) {
2414 continue;
2415 }
2416 new_oid_entry.type = le_string;
2417 new_oid_entry.ptr = estrdup(tmp_name);
2418 zend_hash_update_mem(list, str.s, (void *) &new_oid_entry, sizeof(zend_resource));
2419 if (!ret && strtoul(tmp_oid, &end_ptr, 10)==oid) {
2420 ret = estrdup(tmp_name);
2421 }
2422 }
2423 PQclear(result);
2424 }
2425
2426 smart_str_free(&str);
2427 return ret;
2428 }
2429 /* }}} */
2430
2431 #ifdef HAVE_PQFTABLE
2432 /* {{{ proto mixed pg_field_table(resource result, int field_number[, bool oid_only])
2433 Returns the name of the table field belongs to, or table's oid if oid_only is true */
2434 PHP_FUNCTION(pg_field_table)
2435 {
2436 zval *result;
2437 pgsql_result_handle *pg_result;
2438 zend_long fnum = -1;
2439 zend_bool return_oid = 0;
2440 Oid oid;
2441 smart_str hash_key = {0};
2442 char *table_name;
2443 zend_resource *field_table;
2444
2445 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|b", &result, &fnum, &return_oid) == FAILURE) {
2446 return;
2447 }
2448
2449 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2450 RETURN_FALSE;
2451 }
2452
2453 if (fnum < 0 || fnum >= PQnfields(pg_result->result)) {
2454 php_error_docref(NULL, E_WARNING, "Bad field offset specified");
2455 RETURN_FALSE;
2456 }
2457
2458 oid = PQftable(pg_result->result, (int)fnum);
2459
2460 if (InvalidOid == oid) {
2461 RETURN_FALSE;
2462 }
2463
2464 if (return_oid) {
2465 #if UINT_MAX > ZEND_LONG_MAX /* Oid is unsigned int, we don't need this code, where LONG is wider */
2466 if (oid > ZEND_LONG_MAX) {
2467 smart_str oidstr = {0};
2468 smart_str_append_unsigned(&oidstr, oid);
2469 smart_str_0(&oidstr);
2470 RETURN_NEW_STR(oidstr.s);
2471 } else
2472 #endif
2473 RETURN_LONG((zend_long)oid);
2474 }
2475
2476 /* try to lookup the table name in the resource list */
2477 smart_str_appends(&hash_key, "pgsql_table_oid_");
2478 smart_str_append_unsigned(&hash_key, oid);
2479 smart_str_0(&hash_key);
2480
2481 if ((field_table = zend_hash_find_ptr(&EG(regular_list), hash_key.s)) != NULL) {
2482 smart_str_free(&hash_key);
2483 RETURN_STRING((char *)field_table->ptr);
2484 } else { /* Not found, lookup by querying PostgreSQL system tables */
2485 PGresult *tmp_res;
2486 smart_str querystr = {0};
2487 zend_resource new_field_table;
2488
2489 smart_str_appends(&querystr, "select relname from pg_class where oid=");
2490 smart_str_append_unsigned(&querystr, oid);
2491 smart_str_0(&querystr);
2492
2493 if ((tmp_res = PQexec(pg_result->conn, ZSTR_VAL(querystr.s))) == NULL || PQresultStatus(tmp_res) != PGRES_TUPLES_OK) {
2494 if (tmp_res) {
2495 PQclear(tmp_res);
2496 }
2497 smart_str_free(&querystr);
2498 smart_str_free(&hash_key);
2499 RETURN_FALSE;
2500 }
2501
2502 smart_str_free(&querystr);
2503
2504 if ((table_name = PQgetvalue(tmp_res, 0, 0)) == NULL) {
2505 PQclear(tmp_res);
2506 smart_str_free(&hash_key);
2507 RETURN_FALSE;
2508 }
2509
2510 new_field_table.type = le_string;
2511 new_field_table.ptr = estrdup(table_name);
2512 zend_hash_update_mem(&EG(regular_list), hash_key.s, (void *)&new_field_table, sizeof(zend_resource));
2513
2514 smart_str_free(&hash_key);
2515 PQclear(tmp_res);
2516 RETURN_STRING(table_name);
2517 }
2518
2519 }
2520 /* }}} */
2521 #endif
2522
2523 #define PHP_PG_FIELD_NAME 1
2524 #define PHP_PG_FIELD_SIZE 2
2525 #define PHP_PG_FIELD_TYPE 3
2526 #define PHP_PG_FIELD_TYPE_OID 4
2527
2528 /* {{{ php_pgsql_get_field_info
2529 */
2530 static void php_pgsql_get_field_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
2531 {
2532 zval *result;
2533 zend_long field;
2534 PGresult *pgsql_result;
2535 pgsql_result_handle *pg_result;
2536 Oid oid;
2537
2538 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &result, &field) == FAILURE) {
2539 return;
2540 }
2541
2542 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2543 RETURN_FALSE;
2544 }
2545
2546
2547 pgsql_result = pg_result->result;
2548
2549 if (field < 0 || field >= PQnfields(pgsql_result)) {
2550 php_error_docref(NULL, E_WARNING, "Bad field offset specified");
2551 RETURN_FALSE;
2552 }
2553
2554 switch (entry_type) {
2555 case PHP_PG_FIELD_NAME:
2556 RETURN_STRING(PQfname(pgsql_result, (int)field));
2557 break;
2558 case PHP_PG_FIELD_SIZE:
2559 RETURN_LONG(PQfsize(pgsql_result, (int)field));
2560 break;
2561 case PHP_PG_FIELD_TYPE: {
2562 char *name = get_field_name(pg_result->conn, PQftype(pgsql_result, (int)field), &EG(regular_list));
2563 RETVAL_STRING(name);
2564 efree(name);
2565 }
2566 break;
2567 case PHP_PG_FIELD_TYPE_OID:
2568
2569 oid = PQftype(pgsql_result, (int)field);
2570 #if UINT_MAX > ZEND_LONG_MAX
2571 if (oid > ZEND_LONG_MAX) {
2572 smart_str s = {0};
2573 smart_str_append_unsigned(&s, oid);
2574 smart_str_0(&s);
2575 RETURN_NEW_STR(s.s);
2576 } else
2577 #endif
2578 {
2579 RETURN_LONG((zend_long)oid);
2580 }
2581 break;
2582 default:
2583 RETURN_FALSE;
2584 }
2585 }
2586 /* }}} */
2587
2588 /* {{{ proto string pg_field_name(resource result, int field_number)
2589 Returns the name of the field */
2590 PHP_FUNCTION(pg_field_name)
2591 {
2592 php_pgsql_get_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_FIELD_NAME);
2593 }
2594 /* }}} */
2595
2596 /* {{{ proto int pg_field_size(resource result, int field_number)
2597 Returns the internal size of the field */
2598 PHP_FUNCTION(pg_field_size)
2599 {
2600 php_pgsql_get_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_FIELD_SIZE);
2601 }
2602 /* }}} */
2603
2604 /* {{{ proto string pg_field_type(resource result, int field_number)
2605 Returns the type name for the given field */
2606 PHP_FUNCTION(pg_field_type)
2607 {
2608 php_pgsql_get_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_FIELD_TYPE);
2609 }
2610 /* }}} */
2611
2612 /* {{{ proto string pg_field_type_oid(resource result, int field_number)
2613 Returns the type oid for the given field */
2614 PHP_FUNCTION(pg_field_type_oid)
2615 {
2616 php_pgsql_get_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_FIELD_TYPE_OID);
2617 }
2618 /* }}} */
2619
2620 /* {{{ proto int pg_field_num(resource result, string field_name)
2621 Returns the field number of the named field */
2622 PHP_FUNCTION(pg_field_num)
2623 {
2624 zval *result;
2625 char *field;
2626 size_t field_len;
2627 PGresult *pgsql_result;
2628 pgsql_result_handle *pg_result;
2629
2630 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &result, &field, &field_len) == FAILURE) {
2631 return;
2632 }
2633
2634 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2635 RETURN_FALSE;
2636 }
2637
2638 pgsql_result = pg_result->result;
2639
2640 RETURN_LONG(PQfnumber(pgsql_result, field));
2641 }
2642 /* }}} */
2643
2644 /* {{{ proto mixed pg_fetch_result(resource result, [int row_number,] mixed field_name)
2645 Returns values from a result identifier */
2646 PHP_FUNCTION(pg_fetch_result)
2647 {
2648 zval *result, *field=NULL;
2649 zend_long row;
2650 PGresult *pgsql_result;
2651 pgsql_result_handle *pg_result;
2652 int field_offset, pgsql_row, argc = ZEND_NUM_ARGS();
2653
2654 if (argc == 2) {
2655 if (zend_parse_parameters(argc, "rz", &result, &field) == FAILURE) {
2656 return;
2657 }
2658 } else {
2659 if (zend_parse_parameters(argc, "rlz", &result, &row, &field) == FAILURE) {
2660 return;
2661 }
2662 }
2663
2664 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2665 RETURN_FALSE;
2666 }
2667
2668 pgsql_result = pg_result->result;
2669 if (argc == 2) {
2670 if (pg_result->row < 0) {
2671 pg_result->row = 0;
2672 }
2673 pgsql_row = pg_result->row;
2674 if (pgsql_row >= PQntuples(pgsql_result)) {
2675 RETURN_FALSE;
2676 }
2677 pg_result->row++;
2678 } else {
2679 if (row < 0 || row >= PQntuples(pgsql_result)) {
2680 php_error_docref(NULL, E_WARNING, "Unable to jump to row " ZEND_LONG_FMT " on PostgreSQL result index " ZEND_LONG_FMT,
2681 row, Z_LVAL_P(result));
2682 RETURN_FALSE;
2683 }
2684 pgsql_row = (int)row;
2685 }
2686 switch (Z_TYPE_P(field)) {
2687 case IS_STRING:
2688 field_offset = PQfnumber(pgsql_result, Z_STRVAL_P(field));
2689 if (field_offset < 0 || field_offset >= PQnfields(pgsql_result)) {
2690 php_error_docref(NULL, E_WARNING, "Bad column offset specified");
2691 RETURN_FALSE;
2692 }
2693 break;
2694 default:
2695 convert_to_long_ex(field);
2696 if (Z_LVAL_P(field) < 0 || Z_LVAL_P(field) >= PQnfields(pgsql_result)) {
2697 php_error_docref(NULL, E_WARNING, "Bad column offset specified");
2698 RETURN_FALSE;
2699 }
2700 field_offset = (int)Z_LVAL_P(field);
2701 break;
2702 }
2703
2704 if (PQgetisnull(pgsql_result, pgsql_row, field_offset)) {
2705 RETVAL_NULL();
2706 } else {
2707 RETVAL_STRINGL(PQgetvalue(pgsql_result, pgsql_row, field_offset),
2708 PQgetlength(pgsql_result, pgsql_row, field_offset));
2709 }
2710 }
2711 /* }}} */
2712
2713 /* {{{ void php_pgsql_fetch_hash */
2714 static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_type, int into_object)
2715 {
2716 zval *result, *zrow = NULL;
2717 PGresult *pgsql_result;
2718 pgsql_result_handle *pg_result;
2719 int i, num_fields, pgsql_row, use_row;
2720 zend_long row = -1;
2721 char *field_name;
2722 zval *ctor_params = NULL;
2723 zend_class_entry *ce = NULL;
2724
2725 if (into_object) {
2726 zend_string *class_name = NULL;
2727
2728 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|z!Sz", &result, &zrow, &class_name, &ctor_params) == FAILURE) {
2729 return;
2730 }
2731 if (!class_name) {
2732 ce = zend_standard_class_def;
2733 } else {
2734 ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_AUTO);
2735 }
2736 if (!ce) {
2737 php_error_docref(NULL, E_WARNING, "Could not find class '%s'", ZSTR_VAL(class_name));
2738 return;
2739 }
2740 result_type = PGSQL_ASSOC;
2741 } else {
2742 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|z!l", &result, &zrow, &result_type) == FAILURE) {
2743 return;
2744 }
2745 }
2746 if (zrow == NULL) {
2747 row = -1;
2748 } else {
2749 convert_to_long(zrow);
2750 row = Z_LVAL_P(zrow);
2751 if (row < 0) {
2752 php_error_docref(NULL, E_WARNING, "The row parameter must be greater or equal to zero");
2753 RETURN_FALSE;
2754 }
2755 }
2756 use_row = ZEND_NUM_ARGS() > 1 && row != -1;
2757
2758 if (!(result_type & PGSQL_BOTH)) {
2759 php_error_docref(NULL, E_WARNING, "Invalid result type");
2760 RETURN_FALSE;
2761 }
2762
2763 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2764 RETURN_FALSE;
2765 }
2766
2767 pgsql_result = pg_result->result;
2768
2769 if (use_row) {
2770 if (row < 0 || row >= PQntuples(pgsql_result)) {
2771 php_error_docref(NULL, E_WARNING, "Unable to jump to row " ZEND_LONG_FMT " on PostgreSQL result index " ZEND_LONG_FMT,
2772 row, Z_LVAL_P(result));
2773 RETURN_FALSE;
2774 }
2775 pgsql_row = (int)row;
2776 pg_result->row = pgsql_row;
2777 } else {
2778 /* If 2nd param is NULL, use internal row counter to access next row */
2779 pgsql_row = pg_result->row;
2780 if (pgsql_row < 0 || pgsql_row >= PQntuples(pgsql_result)) {
2781 RETURN_FALSE;
2782 }
2783 pg_result->row++;
2784 }
2785
2786 array_init(return_value);
2787 for (i = 0, num_fields = PQnfields(pgsql_result); i < num_fields; i++) {
2788 if (PQgetisnull(pgsql_result, pgsql_row, i)) {
2789 if (result_type & PGSQL_NUM) {
2790 add_index_null(return_value, i);
2791 }
2792 if (result_type & PGSQL_ASSOC) {
2793 field_name = PQfname(pgsql_result, i);
2794 add_assoc_null(return_value, field_name);
2795 }
2796 } else {
2797 char *element = PQgetvalue(pgsql_result, pgsql_row, i);
2798 if (element) {
2799 const size_t element_len = strlen(element);
2800
2801 if (result_type & PGSQL_NUM) {
2802 add_index_stringl(return_value, i, element, element_len);
2803 }
2804
2805 if (result_type & PGSQL_ASSOC) {
2806 field_name = PQfname(pgsql_result, i);
2807 add_assoc_stringl(return_value, field_name, element, element_len);
2808 }
2809 }
2810 }
2811 }
2812
2813 if (into_object) {
2814 zval dataset;
2815 zend_fcall_info fci;
2816 zend_fcall_info_cache fcc;
2817 zval retval;
2818
2819 ZVAL_COPY_VALUE(&dataset, return_value);
2820 object_init_ex(return_value, ce);
2821 if (!ce->default_properties_count && !ce->__set) {
2822 Z_OBJ_P(return_value)->properties = Z_ARR(dataset);
2823 } else {
2824 zend_merge_properties(return_value, Z_ARRVAL(dataset));
2825 zval_ptr_dtor(&dataset);
2826 }
2827
2828 if (ce->constructor) {
2829 fci.size = sizeof(fci);
2830 ZVAL_UNDEF(&fci.function_name);
2831 fci.object = Z_OBJ_P(return_value);
2832 fci.retval = &retval;
2833 fci.params = NULL;
2834 fci.param_count = 0;
2835 fci.no_separation = 1;
2836
2837 if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) {
2838 if (zend_fcall_info_args(&fci, ctor_params) == FAILURE) {
2839 /* Two problems why we throw exceptions here: PHP is typeless
2840 * and hence passing one argument that's not an array could be
2841 * by mistake and the other way round is possible, too. The
2842 * single value is an array. Also we'd have to make that one
2843 * argument passed by reference.
2844 */
2845 zend_throw_exception(zend_ce_exception, "Parameter ctor_params must be an array", 0);
2846 return;
2847 }
2848 }
2849
2850 fcc.function_handler = ce->constructor;
2851 fcc.called_scope = Z_OBJCE_P(return_value);
2852 fcc.object = Z_OBJ_P(return_value);
2853
2854 if (zend_call_function(&fci, &fcc) == FAILURE) {
2855 zend_throw_exception_ex(zend_ce_exception, 0, "Could not execute %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name));
2856 } else {
2857 zval_ptr_dtor(&retval);
2858 }
2859 if (fci.params) {
2860 efree(fci.params);
2861 }
2862 } else if (ctor_params) {
2863 zend_throw_exception_ex(zend_ce_exception, 0, "Class %s does not have a constructor hence you cannot use ctor_params", ZSTR_VAL(ce->name));
2864 }
2865 }
2866 }
2867 /* }}} */
2868
2869 /* {{{ proto array pg_fetch_row(resource result [, int row [, int result_type]])
2870 Get a row as an enumerated array */
2871 PHP_FUNCTION(pg_fetch_row)
2872 {
2873 php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, PGSQL_NUM, 0);
2874 }
2875 /* }}} */
2876
2877 /* {{{ proto array pg_fetch_assoc(resource result [, int row])
2878 Fetch a row as an assoc array */
2879 PHP_FUNCTION(pg_fetch_assoc)
2880 {
2881 /* pg_fetch_assoc() is added from PHP 4.3.0. It should raise error, when
2882 there is 3rd parameter */
2883 if (ZEND_NUM_ARGS() > 2)
2884 WRONG_PARAM_COUNT;
2885 php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, PGSQL_ASSOC, 0);
2886 }
2887 /* }}} */
2888
2889 /* {{{ proto array pg_fetch_array(resource result [, int row [, int result_type]])
2890 Fetch a row as an array */
2891 PHP_FUNCTION(pg_fetch_array)
2892 {
2893 php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, PGSQL_BOTH, 0);
2894 }
2895 /* }}} */
2896
2897 /* {{{ proto object pg_fetch_object(resource result [, int row [, string class_name [, NULL|array ctor_params]]])
2898 Fetch a row as an object */
2899 PHP_FUNCTION(pg_fetch_object)
2900 {
2901 /* pg_fetch_object() allowed result_type used to be. 3rd parameter
2902 must be allowed for compatibility */
2903 php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, PGSQL_ASSOC, 1);
2904 }
2905 /* }}} */
2906
2907 /* {{{ proto array pg_fetch_all(resource result [, int result_type])
2908 Fetch all rows into array */
2909 PHP_FUNCTION(pg_fetch_all)
2910 {
2911 zval *result;
2912 long result_type = PGSQL_ASSOC;
2913 PGresult *pgsql_result;
2914 pgsql_result_handle *pg_result;
2915
2916 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &result, &result_type) == FAILURE) {
2917 return;
2918 }
2919
2920 if (!(result_type & PGSQL_BOTH)) {
2921 php_error_docref(NULL, E_WARNING, "Invalid result type");
2922 RETURN_FALSE;
2923 }
2924
2925 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2926 RETURN_FALSE;
2927 }
2928
2929 pgsql_result = pg_result->result;
2930 array_init(return_value);
2931 if (php_pgsql_result2array(pgsql_result, return_value, result_type) == FAILURE) {
2932 zend_array_destroy(Z_ARR_P(return_value));
2933 RETURN_FALSE;
2934 }
2935 }
2936 /* }}} */
2937
2938 /* {{{ proto array pg_fetch_all_columns(resource result [, int column_number])
2939 Fetch all rows into array */
2940 PHP_FUNCTION(pg_fetch_all_columns)
2941 {
2942 zval *result;
2943 PGresult *pgsql_result;
2944 pgsql_result_handle *pg_result;
2945 zend_long colno=0;
2946 int pg_numrows, pg_row;
2947 size_t num_fields;
2948
2949 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &result, &colno) == FAILURE) {
2950 RETURN_FALSE;
2951 }
2952
2953 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2954 RETURN_FALSE;
2955 }
2956
2957 pgsql_result = pg_result->result;
2958
2959 num_fields = PQnfields(pgsql_result);
2960 if (colno >= (zend_long)num_fields || colno < 0) {
2961 php_error_docref(NULL, E_WARNING, "Invalid column number '" ZEND_LONG_FMT "'", colno);
2962 RETURN_FALSE;
2963 }
2964
2965 array_init(return_value);
2966
2967 if ((pg_numrows = PQntuples(pgsql_result)) <= 0) {
2968 return;
2969 }
2970
2971 for (pg_row = 0; pg_row < pg_numrows; pg_row++) {
2972 if (PQgetisnull(pgsql_result, pg_row, (int)colno)) {
2973 add_next_index_null(return_value);
2974 } else {
2975 add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, (int)colno));
2976 }
2977 }
2978 }
2979 /* }}} */
2980
2981 /* {{{ proto bool pg_result_seek(resource result, int offset)
2982 Set internal row offset */
2983 PHP_FUNCTION(pg_result_seek)
2984 {
2985 zval *result;
2986 zend_long row;
2987 pgsql_result_handle *pg_result;
2988
2989 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &result, &row) == FAILURE) {
2990 return;
2991 }
2992
2993 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
2994 RETURN_FALSE;
2995 }
2996
2997 if (row < 0 || row >= PQntuples(pg_result->result)) {
2998 RETURN_FALSE;
2999 }
3000
3001 /* seek to offset */
3002 pg_result->row = (int)row;
3003 RETURN_TRUE;
3004 }
3005 /* }}} */
3006
3007 #define PHP_PG_DATA_LENGTH 1
3008 #define PHP_PG_DATA_ISNULL 2
3009
3010 /* {{{ php_pgsql_data_info
3011 */
3012 static void php_pgsql_data_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
3013 {
3014 zval *result, *field;
3015 zend_long row;
3016 PGresult *pgsql_result;
3017 pgsql_result_handle *pg_result;
3018 int field_offset, pgsql_row, argc = ZEND_NUM_ARGS();
3019
3020 if (argc == 2) {
3021 if (zend_parse_parameters(argc, "rz", &result, &field) == FAILURE) {
3022 return;
3023 }
3024 } else {
3025 if (zend_parse_parameters(argc, "rlz", &result, &row, &field) == FAILURE) {
3026 return;
3027 }
3028 }
3029
3030 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
3031 RETURN_FALSE;
3032 }
3033
3034 pgsql_result = pg_result->result;
3035 if (argc == 2) {
3036 if (pg_result->row < 0) {
3037 pg_result->row = 0;
3038 }
3039 pgsql_row = pg_result->row;
3040 if (pgsql_row < 0 || pgsql_row >= PQntuples(pgsql_result)) {
3041 RETURN_FALSE;
3042 }
3043 } else {
3044 if (row < 0 || row >= PQntuples(pgsql_result)) {
3045 php_error_docref(NULL, E_WARNING, "Unable to jump to row " ZEND_LONG_FMT " on PostgreSQL result index " ZEND_LONG_FMT,
3046 row, Z_LVAL_P(result));
3047 RETURN_FALSE;
3048 }
3049 pgsql_row = (int)row;
3050 }
3051
3052 switch (Z_TYPE_P(field)) {
3053 case IS_STRING:
3054 field_offset = PQfnumber(pgsql_result, Z_STRVAL_P(field));
3055 if (field_offset < 0 || field_offset >= PQnfields(pgsql_result)) {
3056 php_error_docref(NULL, E_WARNING, "Bad column offset specified");
3057 RETURN_FALSE;
3058 }
3059 break;
3060 default:
3061 convert_to_long_ex(field);
3062 if (Z_LVAL_P(field) < 0 || Z_LVAL_P(field) >= PQnfields(pgsql_result)) {
3063 php_error_docref(NULL, E_WARNING, "Bad column offset specified");
3064 RETURN_FALSE;
3065 }
3066 field_offset = (int)Z_LVAL_P(field);
3067 break;
3068 }
3069
3070 switch (entry_type) {
3071 case PHP_PG_DATA_LENGTH:
3072 RETVAL_LONG(PQgetlength(pgsql_result, pgsql_row, field_offset));
3073 break;
3074 case PHP_PG_DATA_ISNULL:
3075 RETVAL_LONG(PQgetisnull(pgsql_result, pgsql_row, field_offset));
3076 break;
3077 }
3078 }
3079 /* }}} */
3080
3081 /* {{{ proto int pg_field_prtlen(resource result, [int row,] mixed field_name_or_number)
3082 Returns the printed length */
3083 PHP_FUNCTION(pg_field_prtlen)
3084 {
3085 php_pgsql_data_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_PG_DATA_LENGTH);
3086 }
3087 /* }}} */
3088
3089 /* {{{ proto int pg_field_is_null(resource result, [int row,] mixed field_name_or_number)
3090 Test if a field is NULL */
3091 PHP_FUNCTION(pg_field_is_null)
3092 {
3093 php_pgsql_data_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_PG_DATA_ISNULL);
3094 }
3095 /* }}} */
3096
3097 /* {{{ proto bool pg_free_result(resource result)
3098 Free result memory */
3099 PHP_FUNCTION(pg_free_result)
3100 {
3101 zval *result;
3102 pgsql_result_handle *pg_result;
3103
3104 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &result) == FAILURE) {
3105 return;
3106 }
3107
3108 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
3109 RETURN_FALSE;
3110 }
3111
3112 zend_list_close(Z_RES_P(result));
3113 RETURN_TRUE;
3114 }
3115 /* }}} */
3116
3117 /* {{{ proto string pg_last_oid(resource result)
3118 Returns the last object identifier */
3119 PHP_FUNCTION(pg_last_oid)
3120 {
3121 zval *result;
3122 PGresult *pgsql_result;
3123 pgsql_result_handle *pg_result;
3124 #ifdef HAVE_PQOIDVALUE
3125 Oid oid;
3126 #endif
3127
3128 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &result) == FAILURE) {
3129 return;
3130 }
3131
3132 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
3133 RETURN_FALSE;
3134 }
3135
3136 pgsql_result = pg_result->result;
3137 #ifdef HAVE_PQOIDVALUE
3138 oid = PQoidValue(pgsql_result);
3139 if (oid == InvalidOid) {
3140 RETURN_FALSE;
3141 }
3142 PGSQL_RETURN_OID(oid);
3143 #else
3144 Z_STRVAL_P(return_value) = (char *) PQoidStatus(pgsql_result);
3145 if (Z_STRVAL_P(return_value)) {
3146 RETURN_STRING(Z_STRVAL_P(return_value));
3147 }
3148 RETURN_EMPTY_STRING();
3149 #endif
3150 }
3151 /* }}} */
3152
3153 /* {{{ proto bool pg_trace(string filename [, string mode [, resource connection]])
3154 Enable tracing a PostgreSQL connection */
3155 PHP_FUNCTION(pg_trace)
3156 {
3157 char *z_filename, *mode = "w";
3158 size_t z_filename_len, mode_len;
3159 zval *pgsql_link = NULL;
3160 int argc = ZEND_NUM_ARGS();
3161 PGconn *pgsql;
3162 FILE *fp = NULL;
3163 php_stream *stream;
3164 zend_resource *link;
3165
3166 if (zend_parse_parameters(argc, "p|sr", &z_filename, &z_filename_len, &mode, &mode_len, &pgsql_link) == FAILURE) {
3167 return;
3168 }
3169
3170 if (argc < 3) {
3171 link = FETCH_DEFAULT_LINK();
3172 CHECK_DEFAULT_LINK(link);
3173 } else {
3174 link = Z_RES_P(pgsql_link);
3175 }
3176
3177 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3178 RETURN_FALSE;
3179 }
3180
3181 stream = php_stream_open_wrapper(z_filename, mode, REPORT_ERRORS, NULL);
3182
3183 if (!stream) {
3184 RETURN_FALSE;
3185 }
3186
3187 if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_STDIO, (void**)&fp, REPORT_ERRORS)) {
3188 php_stream_close(stream);
3189 RETURN_FALSE;
3190 }
3191 php_stream_auto_cleanup(stream);
3192 PQtrace(pgsql, fp);
3193 RETURN_TRUE;
3194 }
3195 /* }}} */
3196
3197 /* {{{ proto bool pg_untrace([resource connection])
3198 Disable tracing of a PostgreSQL connection */
3199 PHP_FUNCTION(pg_untrace)
3200 {
3201 zval *pgsql_link = NULL;
3202 int argc = ZEND_NUM_ARGS();
3203 PGconn *pgsql;
3204 zend_resource *link;
3205
3206 if (zend_parse_parameters(argc, "|r", &pgsql_link) == FAILURE) {
3207 return;
3208 }
3209
3210 if (argc == 0) {
3211 link = FETCH_DEFAULT_LINK();
3212 CHECK_DEFAULT_LINK(link);
3213 } else {
3214 link = Z_RES_P(pgsql_link);
3215 }
3216
3217 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3218 RETURN_FALSE;
3219 }
3220
3221 PQuntrace(pgsql);
3222 RETURN_TRUE;
3223 }
3224 /* }}} */
3225
3226 /* {{{ proto mixed pg_lo_create([resource connection],[mixed large_object_oid])
3227 Create a large object */
3228 PHP_FUNCTION(pg_lo_create)
3229 {
3230 zval *pgsql_link = NULL, *oid = NULL;
3231 PGconn *pgsql;
3232 Oid pgsql_oid, wanted_oid = InvalidOid;
3233 int argc = ZEND_NUM_ARGS();
3234 zend_resource *link;
3235
3236 if (zend_parse_parameters(argc, "|zz", &pgsql_link, &oid) == FAILURE) {
3237 return;
3238 }
3239
3240 if ((argc == 1) && (Z_TYPE_P(pgsql_link) != IS_RESOURCE)) {
3241 oid = pgsql_link;
3242 pgsql_link = NULL;
3243 }
3244
3245 if (pgsql_link == NULL) {
3246 link = FETCH_DEFAULT_LINK();
3247 CHECK_DEFAULT_LINK(link);
3248 } else if ((Z_TYPE_P(pgsql_link) == IS_RESOURCE)) {
3249 link = Z_RES_P(pgsql_link);
3250 } else {
3251 link = NULL;
3252 }
3253
3254 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3255 RETURN_FALSE;
3256 }
3257
3258 if (oid) {
3259 #ifndef HAVE_PG_LO_CREATE
3260 php_error_docref(NULL, E_NOTICE, "Passing OID value is not supported. Upgrade your PostgreSQL");
3261 #else
3262 switch (Z_TYPE_P(oid)) {
3263 case IS_STRING:
3264 {
3265 char *end_ptr;
3266 wanted_oid = (Oid)strtoul(Z_STRVAL_P(oid), &end_ptr, 10);
3267 if ((Z_STRVAL_P(oid)+Z_STRLEN_P(oid)) != end_ptr) {
3268 /* wrong integer format */
3269 php_error_docref(NULL, E_NOTICE, "invalid OID value passed");
3270 RETURN_FALSE;
3271 }
3272 }
3273 break;
3274 case IS_LONG:
3275 if (Z_LVAL_P(oid) < (zend_long)InvalidOid) {
3276 php_error_docref(NULL, E_NOTICE, "invalid OID value passed");
3277 RETURN_FALSE;
3278 }
3279 wanted_oid = (Oid)Z_LVAL_P(oid);
3280 break;
3281 default:
3282 php_error_docref(NULL, E_NOTICE, "invalid OID value passed");
3283 RETURN_FALSE;
3284 }
3285 if ((pgsql_oid = lo_create(pgsql, wanted_oid)) == InvalidOid) {
3286 php_error_docref(NULL, E_WARNING, "Unable to create PostgreSQL large object");
3287 RETURN_FALSE;
3288 }
3289
3290 PGSQL_RETURN_OID(pgsql_oid);
3291 #endif
3292 }
3293
3294 if ((pgsql_oid = lo_creat(pgsql, INV_READ|INV_WRITE)) == InvalidOid) {
3295 php_error_docref(NULL, E_WARNING, "Unable to create PostgreSQL large object");
3296 RETURN_FALSE;
3297 }
3298
3299 PGSQL_RETURN_OID(pgsql_oid);
3300 }
3301 /* }}} */
3302
3303 /* {{{ proto bool pg_lo_unlink([resource connection,] string large_object_oid)
3304 Delete a large object */
3305 PHP_FUNCTION(pg_lo_unlink)
3306 {
3307 zval *pgsql_link = NULL;
3308 zend_long oid_long;
3309 char *oid_string, *end_ptr;
3310 size_t oid_strlen;
3311 PGconn *pgsql;
3312 Oid oid;
3313 zend_resource *link;
3314 int argc = ZEND_NUM_ARGS();
3315
3316 /* accept string type since Oid type is unsigned int */
3317 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3318 "rs", &pgsql_link, &oid_string, &oid_strlen) == SUCCESS) {
3319 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3320 if ((oid_string+oid_strlen) != end_ptr) {
3321 /* wrong integer format */
3322 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3323 RETURN_FALSE;
3324 }
3325 link = Z_RES_P(pgsql_link);
3326 }
3327 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3328 "rl", &pgsql_link, &oid_long) == SUCCESS) {
3329 if (oid_long <= (zend_long)InvalidOid) {
3330 php_error_docref(NULL, E_NOTICE, "Invalid OID specified");
3331 RETURN_FALSE;
3332 }
3333 oid = (Oid)oid_long;
3334 link = Z_RES_P(pgsql_link);
3335 }
3336 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3337 "s", &oid_string, &oid_strlen) == SUCCESS) {
3338 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3339 if ((oid_string+oid_strlen) != end_ptr) {
3340 /* wrong integer format */
3341 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3342 RETURN_FALSE;
3343 }
3344 link = FETCH_DEFAULT_LINK();
3345 CHECK_DEFAULT_LINK(link);
3346 }
3347 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3348 "l", &oid_long) == SUCCESS) {
3349 if (oid_long <= (zend_long)InvalidOid) {
3350 php_error_docref(NULL, E_NOTICE, "Invalid OID is specified");
3351 RETURN_FALSE;
3352 }
3353 oid = (Oid)oid_long;
3354 link = FETCH_DEFAULT_LINK();
3355 CHECK_DEFAULT_LINK(link);
3356 }
3357 else {
3358 php_error_docref(NULL, E_WARNING, "Requires 1 or 2 arguments");
3359 RETURN_FALSE;
3360 }
3361
3362 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3363 RETURN_FALSE;
3364 }
3365
3366 if (lo_unlink(pgsql, oid) == -1) {
3367 php_error_docref(NULL, E_WARNING, "Unable to delete PostgreSQL large object %u", oid);
3368 RETURN_FALSE;
3369 }
3370 RETURN_TRUE;
3371 }
3372 /* }}} */
3373
3374 /* {{{ proto resource pg_lo_open([resource connection,] int large_object_oid, string mode)
3375 Open a large object and return fd */
3376 PHP_FUNCTION(pg_lo_open)
3377 {
3378 zval *pgsql_link = NULL;
3379 zend_long oid_long;
3380 char *oid_string, *end_ptr, *mode_string;
3381 size_t oid_strlen, mode_strlen;
3382 PGconn *pgsql;
3383 Oid oid;
3384 int pgsql_mode=0, pgsql_lofd;
3385 int create = 0;
3386 pgLofp *pgsql_lofp;
3387 int argc = ZEND_NUM_ARGS();
3388 zend_resource *link;
3389
3390 /* accept string type since Oid is unsigned int */
3391 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3392 "rss", &pgsql_link, &oid_string, &oid_strlen, &mode_string, &mode_strlen) == SUCCESS) {
3393 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3394 if ((oid_string+oid_strlen) != end_ptr) {
3395 /* wrong integer format */
3396 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3397 RETURN_FALSE;
3398 }
3399 link = Z_RES_P(pgsql_link);
3400 }
3401 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3402 "rls", &pgsql_link, &oid_long, &mode_string, &mode_strlen) == SUCCESS) {
3403 if (oid_long <= (zend_long)InvalidOid) {
3404 php_error_docref(NULL, E_NOTICE, "Invalid OID specified");
3405 RETURN_FALSE;
3406 }
3407 oid = (Oid)oid_long;
3408 link = Z_RES_P(pgsql_link);
3409 }
3410 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3411 "ss", &oid_string, &oid_strlen, &mode_string, &mode_strlen) == SUCCESS) {
3412 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3413 if ((oid_string+oid_strlen) != end_ptr) {
3414 /* wrong integer format */
3415 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3416 RETURN_FALSE;
3417 }
3418 link = FETCH_DEFAULT_LINK();
3419 CHECK_DEFAULT_LINK(link);
3420 }
3421 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3422 "ls", &oid_long, &mode_string, &mode_strlen) == SUCCESS) {
3423 if (oid_long <= (zend_long)InvalidOid) {
3424 php_error_docref(NULL, E_NOTICE, "Invalid OID specified");
3425 RETURN_FALSE;
3426 }
3427 oid = (Oid)oid_long;
3428 link = FETCH_DEFAULT_LINK();
3429 CHECK_DEFAULT_LINK(link);
3430 }
3431 else {
3432 php_error_docref(NULL, E_WARNING, "Requires 1 or 2 arguments");
3433 RETURN_FALSE;
3434 }
3435
3436 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3437 RETURN_FALSE;
3438 }
3439
3440 /* r/w/+ is little bit more PHP-like than INV_READ/INV_WRITE and a lot of
3441 faster to type. Unfortunately, doesn't behave the same way as fopen()...
3442 (Jouni)
3443 */
3444
3445 if (strchr(mode_string, 'r') == mode_string) {
3446 pgsql_mode |= INV_READ;
3447 if (strchr(mode_string, '+') == mode_string+1) {
3448 pgsql_mode |= INV_WRITE;
3449 }
3450 }
3451 if (strchr(mode_string, 'w') == mode_string) {
3452 pgsql_mode |= INV_WRITE;
3453 create = 1;
3454 if (strchr(mode_string, '+') == mode_string+1) {
3455 pgsql_mode |= INV_READ;
3456 }
3457 }
3458
3459 pgsql_lofp = (pgLofp *) emalloc(sizeof(pgLofp));
3460
3461 if ((pgsql_lofd = lo_open(pgsql, oid, pgsql_mode)) == -1) {
3462 if (create) {
3463 if ((oid = lo_creat(pgsql, INV_READ|INV_WRITE)) == 0) {
3464 efree(pgsql_lofp);
3465 php_error_docref(NULL, E_WARNING, "Unable to create PostgreSQL large object");
3466 RETURN_FALSE;
3467 } else {
3468 if ((pgsql_lofd = lo_open(pgsql, oid, pgsql_mode)) == -1) {
3469 if (lo_unlink(pgsql, oid) == -1) {
3470 efree(pgsql_lofp);
3471 php_error_docref(NULL, E_WARNING, "Something is really messed up! Your database is badly corrupted in a way NOT related to PHP");
3472 RETURN_FALSE;
3473 }
3474 efree(pgsql_lofp);
3475 php_error_docref(NULL, E_WARNING, "Unable to open PostgreSQL large object");
3476 RETURN_FALSE;
3477 } else {
3478 pgsql_lofp->conn = pgsql;
3479 pgsql_lofp->lofd = pgsql_lofd;
3480 RETURN_RES(zend_register_resource(pgsql_lofp, le_lofp));
3481 }
3482 }
3483 } else {
3484 efree(pgsql_lofp);
3485 php_error_docref(NULL, E_WARNING, "Unable to open PostgreSQL large object");
3486 RETURN_FALSE;
3487 }
3488 } else {
3489 pgsql_lofp->conn = pgsql;
3490 pgsql_lofp->lofd = pgsql_lofd;
3491 RETURN_RES(zend_register_resource(pgsql_lofp, le_lofp));
3492 }
3493 }
3494 /* }}} */
3495
3496 /* {{{ proto bool pg_lo_close(resource large_object)
3497 Close a large object */
3498 PHP_FUNCTION(pg_lo_close)
3499 {
3500 zval *pgsql_lofp;
3501 pgLofp *pgsql;
3502
3503 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_lofp) == FAILURE) {
3504 return;
3505 }
3506
3507 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_lofp), "PostgreSQL large object", le_lofp)) == NULL) {
3508 RETURN_FALSE;
3509 }
3510
3511 if (lo_close((PGconn *)pgsql->conn, pgsql->lofd) < 0) {
3512 php_error_docref(NULL, E_WARNING, "Unable to close PostgreSQL large object descriptor %d", pgsql->lofd);
3513 RETVAL_FALSE;
3514 } else {
3515 RETVAL_TRUE;
3516 }
3517
3518 zend_list_close(Z_RES_P(pgsql_lofp));
3519 return;
3520 }
3521 /* }}} */
3522
3523 #define PGSQL_LO_READ_BUF_SIZE 8192
3524
3525 /* {{{ proto string pg_lo_read(resource large_object [, int len])
3526 Read a large object */
3527 PHP_FUNCTION(pg_lo_read)
3528 {
3529 zval *pgsql_id;
3530 zend_long len;
3531 size_t buf_len = PGSQL_LO_READ_BUF_SIZE;
3532 int nbytes, argc = ZEND_NUM_ARGS();
3533 zend_string *buf;
3534 pgLofp *pgsql;
3535
3536 if (zend_parse_parameters(argc, "r|l", &pgsql_id, &len) == FAILURE) {
3537 return;
3538 }
3539
3540 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_id), "PostgreSQL large object", le_lofp)) == NULL) {
3541 RETURN_FALSE;
3542 }
3543
3544 if (argc > 1) {
3545 buf_len = len < 0 ? 0 : len;
3546 }
3547
3548 buf = zend_string_alloc(buf_len, 0);
3549 if ((nbytes = lo_read((PGconn *)pgsql->conn, pgsql->lofd, ZSTR_VAL(buf), ZSTR_LEN(buf)))<0) {
3550 zend_string_efree(buf);
3551 RETURN_FALSE;
3552 }
3553
3554 ZSTR_LEN(buf) = nbytes;
3555 ZSTR_VAL(buf)[ZSTR_LEN(buf)] = '\0';
3556 RETURN_NEW_STR(buf);
3557 }
3558 /* }}} */
3559
3560 /* {{{ proto int pg_lo_write(resource large_object, string buf [, int len])
3561 Write a large object */
3562 PHP_FUNCTION(pg_lo_write)
3563 {
3564 zval *pgsql_id;
3565 char *str;
3566 zend_long z_len;
3567 size_t str_len, nbytes;
3568 size_t len;
3569 pgLofp *pgsql;
3570 int argc = ZEND_NUM_ARGS();
3571
3572 if (zend_parse_parameters(argc, "rs|l", &pgsql_id, &str, &str_len, &z_len) == FAILURE) {
3573 return;
3574 }
3575
3576 if (argc > 2) {
3577 if (z_len > (zend_long)str_len) {
3578 php_error_docref(NULL, E_WARNING, "Cannot write more than buffer size %zu. Tried to write " ZEND_LONG_FMT, str_len, z_len);
3579 RETURN_FALSE;
3580 }
3581 if (z_len < 0) {
3582 php_error_docref(NULL, E_WARNING, "Buffer size must be larger than 0, but " ZEND_LONG_FMT " was specified", z_len);
3583 RETURN_FALSE;
3584 }
3585 len = z_len;
3586 }
3587 else {
3588 len = str_len;
3589 }
3590
3591 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_id), "PostgreSQL large object", le_lofp)) == NULL) {
3592 RETURN_FALSE;
3593 }
3594
3595 if ((nbytes = lo_write((PGconn *)pgsql->conn, pgsql->lofd, str, len)) == (size_t)-1) {
3596 RETURN_FALSE;
3597 }
3598
3599 RETURN_LONG(nbytes);
3600 }
3601 /* }}} */
3602
3603 /* {{{ proto int pg_lo_read_all(resource large_object)
3604 Read a large object and send straight to browser */
3605 PHP_FUNCTION(pg_lo_read_all)
3606 {
3607 zval *pgsql_id;
3608 int tbytes;
3609 volatile int nbytes;
3610 char buf[PGSQL_LO_READ_BUF_SIZE];
3611 pgLofp *pgsql;
3612
3613 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_id) == FAILURE) {
3614 return;
3615 }
3616
3617 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_id), "PostgreSQL large object", le_lofp)) == NULL) {
3618 RETURN_FALSE;
3619 }
3620
3621 tbytes = 0;
3622 while ((nbytes = lo_read((PGconn *)pgsql->conn, pgsql->lofd, buf, PGSQL_LO_READ_BUF_SIZE))>0) {
3623 PHPWRITE(buf, nbytes);
3624 tbytes += nbytes;
3625 }
3626 RETURN_LONG(tbytes);
3627 }
3628 /* }}} */
3629
3630 /* {{{ proto int pg_lo_import([resource connection, ] string filename [, mixed oid])
3631 Import large object direct from filesystem */
3632 PHP_FUNCTION(pg_lo_import)
3633 {
3634 zval *pgsql_link = NULL, *oid = NULL;
3635 char *file_in;
3636 size_t name_len;
3637 int argc = ZEND_NUM_ARGS();
3638 PGconn *pgsql;
3639 Oid returned_oid;
3640 zend_resource *link;
3641
3642 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3643 "rp|z", &pgsql_link, &file_in, &name_len, &oid) == SUCCESS) {
3644 link = Z_RES_P(pgsql_link);
3645 }
3646 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3647 "p|z", &file_in, &name_len, &oid) == SUCCESS) {
3648 link = FETCH_DEFAULT_LINK();
3649 CHECK_DEFAULT_LINK(link);
3650 }
3651 /* old calling convention, deprecated since PHP 4.2 */
3652 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3653 "pr", &file_in, &name_len, &pgsql_link ) == SUCCESS) {
3654 php_error_docref(NULL, E_NOTICE, "Old API is used");
3655 link = Z_RES_P(pgsql_link);
3656 }
3657 else {
3658 WRONG_PARAM_COUNT;
3659 }
3660
3661 if (php_check_open_basedir(file_in)) {
3662 RETURN_FALSE;
3663 }
3664
3665 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3666 RETURN_FALSE;
3667 }
3668
3669 if (oid) {
3670 #ifndef HAVE_PG_LO_IMPORT_WITH_OID
3671 php_error_docref(NULL, E_NOTICE, "OID value passing not supported");
3672 #else
3673 Oid wanted_oid;
3674 switch (Z_TYPE_P(oid)) {
3675 case IS_STRING:
3676 {
3677 char *end_ptr;
3678 wanted_oid = (Oid)strtoul(Z_STRVAL_P(oid), &end_ptr, 10);
3679 if ((Z_STRVAL_P(oid)+Z_STRLEN_P(oid)) != end_ptr) {
3680 /* wrong integer format */
3681 php_error_docref(NULL, E_NOTICE, "invalid OID value passed");
3682 RETURN_FALSE;
3683 }
3684 }
3685 break;
3686 case IS_LONG:
3687 if (Z_LVAL_P(oid) < (zend_long)InvalidOid) {
3688 php_error_docref(NULL, E_NOTICE, "invalid OID value passed");
3689 RETURN_FALSE;
3690 }
3691 wanted_oid = (Oid)Z_LVAL_P(oid);
3692 break;
3693 default:
3694 php_error_docref(NULL, E_NOTICE, "invalid OID value passed");
3695 RETURN_FALSE;
3696 }
3697
3698 returned_oid = lo_import_with_oid(pgsql, file_in, wanted_oid);
3699
3700 if (returned_oid == InvalidOid) {
3701 RETURN_FALSE;
3702 }
3703
3704 PGSQL_RETURN_OID(returned_oid);
3705 #endif
3706 }
3707
3708 returned_oid = lo_import(pgsql, file_in);
3709
3710 if (returned_oid == InvalidOid) {
3711 RETURN_FALSE;
3712 }
3713 PGSQL_RETURN_OID(returned_oid);
3714 }
3715 /* }}} */
3716
3717 /* {{{ proto bool pg_lo_export([resource connection, ] int objoid, string filename)
3718 Export large object direct to filesystem */
3719 PHP_FUNCTION(pg_lo_export)
3720 {
3721 zval *pgsql_link = NULL;
3722 char *file_out, *oid_string, *end_ptr;
3723 size_t oid_strlen;
3724 size_t name_len;
3725 zend_long oid_long;
3726 Oid oid;
3727 PGconn *pgsql;
3728 int argc = ZEND_NUM_ARGS();
3729 zend_resource *link;
3730
3731 /* allow string to handle large OID value correctly */
3732 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3733 "rlp", &pgsql_link, &oid_long, &file_out, &name_len) == SUCCESS) {
3734 if (oid_long <= (zend_long)InvalidOid) {
3735 php_error_docref(NULL, E_NOTICE, "Invalid OID specified");
3736 RETURN_FALSE;
3737 }
3738 oid = (Oid)oid_long;
3739 link = Z_RES_P(pgsql_link);
3740 }
3741 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3742 "rss", &pgsql_link, &oid_string, &oid_strlen, &file_out, &name_len) == SUCCESS) {
3743 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3744 if ((oid_string+oid_strlen) != end_ptr) {
3745 /* wrong integer format */
3746 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3747 RETURN_FALSE;
3748 }
3749 link = Z_RES_P(pgsql_link);
3750 }
3751 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3752 "lp", &oid_long, &file_out, &name_len) == SUCCESS) {
3753 if (oid_long <= (zend_long)InvalidOid) {
3754 php_error_docref(NULL, E_NOTICE, "Invalid OID specified");
3755 RETURN_FALSE;
3756 }
3757 oid = (Oid)oid_long;
3758 link = FETCH_DEFAULT_LINK();
3759 CHECK_DEFAULT_LINK(link);
3760 }
3761 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3762 "sp", &oid_string, &oid_strlen, &file_out, &name_len) == SUCCESS) {
3763 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3764 if ((oid_string+oid_strlen) != end_ptr) {
3765 /* wrong integer format */
3766 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3767 RETURN_FALSE;
3768 }
3769 link = FETCH_DEFAULT_LINK();
3770 CHECK_DEFAULT_LINK(link);
3771 }
3772 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3773 "spr", &oid_string, &oid_strlen, &file_out, &name_len, &pgsql_link) == SUCCESS) {
3774 oid = (Oid)strtoul(oid_string, &end_ptr, 10);
3775 if ((oid_string+oid_strlen) != end_ptr) {
3776 /* wrong integer format */
3777 php_error_docref(NULL, E_NOTICE, "Wrong OID value passed");
3778 RETURN_FALSE;
3779 }
3780 link = Z_RES_P(pgsql_link);
3781 }
3782 else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc,
3783 "lpr", &oid_long, &file_out, &name_len, &pgsql_link) == SUCCESS) {
3784 php_error_docref(NULL, E_NOTICE, "Old API is used");
3785 if (oid_long <= (zend_long)InvalidOid) {
3786 php_error_docref(NULL, E_NOTICE, "Invalid OID specified");
3787 RETURN_FALSE;
3788 }
3789 oid = (Oid)oid_long;
3790 link = Z_RES_P(pgsql_link);
3791 }
3792 else {
3793 php_error_docref(NULL, E_WARNING, "Requires 2 or 3 arguments");
3794 RETURN_FALSE;
3795 }
3796
3797 if (php_check_open_basedir(file_out)) {
3798 RETURN_FALSE;
3799 }
3800
3801 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3802 RETURN_FALSE;
3803 }
3804
3805 if (lo_export(pgsql, oid, file_out) == -1) {
3806 RETURN_FALSE;
3807 }
3808 RETURN_TRUE;
3809 }
3810 /* }}} */
3811
3812 /* {{{ proto bool pg_lo_seek(resource large_object, int offset [, int whence])
3813 Seeks position of large object */
3814 PHP_FUNCTION(pg_lo_seek)
3815 {
3816 zval *pgsql_id = NULL;
3817 zend_long result, offset = 0, whence = SEEK_CUR;
3818 pgLofp *pgsql;
3819 int argc = ZEND_NUM_ARGS();
3820
3821 if (zend_parse_parameters(argc, "rl|l", &pgsql_id, &offset, &whence) == FAILURE) {
3822 return;
3823 }
3824 if (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END) {
3825 php_error_docref(NULL, E_WARNING, "Invalid whence parameter");
3826 return;
3827 }
3828
3829 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_id), "PostgreSQL large object", le_lofp)) == NULL) {
3830 RETURN_FALSE;
3831 }
3832
3833 #if HAVE_PG_LO64
3834 if (PQserverVersion((PGconn *)pgsql->conn) >= 90300) {
3835 result = lo_lseek64((PGconn *)pgsql->conn, pgsql->lofd, offset, (int)whence);
3836 } else {
3837 result = lo_lseek((PGconn *)pgsql->conn, pgsql->lofd, (int)offset, (int)whence);
3838 }
3839 #else
3840 result = lo_lseek((PGconn *)pgsql->conn, pgsql->lofd, offset, whence);
3841 #endif
3842 if (result > -1) {
3843 RETURN_TRUE;
3844 } else {
3845 RETURN_FALSE;
3846 }
3847 }
3848 /* }}} */
3849
3850 /* {{{ proto int pg_lo_tell(resource large_object)
3851 Returns current position of large object */
3852 PHP_FUNCTION(pg_lo_tell)
3853 {
3854 zval *pgsql_id = NULL;
3855 zend_long offset = 0;
3856 pgLofp *pgsql;
3857 int argc = ZEND_NUM_ARGS();
3858
3859 if (zend_parse_parameters(argc, "r", &pgsql_id) == FAILURE) {
3860 return;
3861 }
3862
3863 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_id), "PostgreSQL large object", le_lofp)) == NULL) {
3864 RETURN_FALSE;
3865 }
3866
3867 #if HAVE_PG_LO64
3868 if (PQserverVersion((PGconn *)pgsql->conn) >= 90300) {
3869 offset = lo_tell64((PGconn *)pgsql->conn, pgsql->lofd);
3870 } else {
3871 offset = lo_tell((PGconn *)pgsql->conn, pgsql->lofd);
3872 }
3873 #else
3874 offset = lo_tell((PGconn *)pgsql->conn, pgsql->lofd);
3875 #endif
3876 RETURN_LONG(offset);
3877 }
3878 /* }}} */
3879
3880 #if HAVE_PG_LO_TRUNCATE
3881 /* {{{ proto bool pg_lo_truncate(resource large_object, int size)
3882 Truncate large object to size */
3883 PHP_FUNCTION(pg_lo_truncate)
3884 {
3885 zval *pgsql_id = NULL;
3886 size_t size;
3887 pgLofp *pgsql;
3888 int argc = ZEND_NUM_ARGS();
3889 int result;
3890
3891 if (zend_parse_parameters(argc, "rl", &pgsql_id, &size) == FAILURE) {
3892 return;
3893 }
3894
3895 if ((pgsql = (pgLofp *)zend_fetch_resource(Z_RES_P(pgsql_id), "PostgreSQL large object", le_lofp)) == NULL) {
3896 RETURN_FALSE;
3897 }
3898
3899 #if HAVE_PG_LO64
3900 if (PQserverVersion((PGconn *)pgsql->conn) >= 90300) {
3901 result = lo_truncate64((PGconn *)pgsql->conn, pgsql->lofd, size);
3902 } else {
3903 result = lo_truncate((PGconn *)pgsql->conn, pgsql->lofd, size);
3904 }
3905 #else
3906 result = lo_truncate((PGconn *)pgsql->conn, pgsql->lofd, size);
3907 #endif
3908 if (!result) {
3909 RETURN_TRUE;
3910 } else {
3911 RETURN_FALSE;
3912 }
3913 }
3914 /* }}} */
3915 #endif
3916
3917 #if HAVE_PQSETERRORVERBOSITY
3918 /* {{{ proto int pg_set_error_verbosity([resource connection,] int verbosity)
3919 Set error verbosity */
3920 PHP_FUNCTION(pg_set_error_verbosity)
3921 {
3922 zval *pgsql_link = NULL;
3923 zend_long verbosity;
3924 int argc = ZEND_NUM_ARGS();
3925 PGconn *pgsql;
3926 zend_resource *link;
3927
3928 if (argc == 1) {
3929 if (zend_parse_parameters(argc, "l", &verbosity) == FAILURE) {
3930 return;
3931 }
3932 link = FETCH_DEFAULT_LINK();
3933 CHECK_DEFAULT_LINK(link);
3934 } else {
3935 if (zend_parse_parameters(argc, "rl", &pgsql_link, &verbosity) == FAILURE) {
3936 return;
3937 }
3938 link = Z_RES_P(pgsql_link);
3939 }
3940
3941 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3942 RETURN_FALSE;
3943 }
3944
3945 if (verbosity & (PQERRORS_TERSE|PQERRORS_DEFAULT|PQERRORS_VERBOSE)) {
3946 RETURN_LONG(PQsetErrorVerbosity(pgsql, verbosity));
3947 } else {
3948 RETURN_FALSE;
3949 }
3950 }
3951 /* }}} */
3952 #endif
3953
3954 #ifdef HAVE_PQCLIENTENCODING
3955 /* {{{ proto int pg_set_client_encoding([resource connection,] string encoding)
3956 Set client encoding */
3957 PHP_FUNCTION(pg_set_client_encoding)
3958 {
3959 char *encoding;
3960 size_t encoding_len;
3961 zval *pgsql_link = NULL;
3962 int argc = ZEND_NUM_ARGS();
3963 PGconn *pgsql;
3964 zend_resource *link;
3965
3966 if (argc == 1) {
3967 if (zend_parse_parameters(argc, "s", &encoding, &encoding_len) == FAILURE) {
3968 return;
3969 }
3970 link = FETCH_DEFAULT_LINK();
3971 CHECK_DEFAULT_LINK(link);
3972 } else {
3973 if (zend_parse_parameters(argc, "rs", &pgsql_link, &encoding, &encoding_len) == FAILURE) {
3974 return;
3975 }
3976 link = Z_RES_P(pgsql_link);
3977 }
3978
3979 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
3980 RETURN_FALSE;
3981 }
3982
3983 RETURN_LONG(PQsetClientEncoding(pgsql, encoding));
3984 }
3985 /* }}} */
3986
3987 /* {{{ proto string pg_client_encoding([resource connection])
3988 Get the current client encoding */
3989 PHP_FUNCTION(pg_client_encoding)
3990 {
3991 zval *pgsql_link = NULL;
3992 int argc = ZEND_NUM_ARGS();
3993 PGconn *pgsql;
3994 zend_resource *link;
3995
3996 if (zend_parse_parameters(argc, "|r", &pgsql_link) == FAILURE) {
3997 return;
3998 }
3999
4000 if (argc == 0) {
4001 link = FETCH_DEFAULT_LINK();
4002 CHECK_DEFAULT_LINK(link);
4003 } else {
4004 link = Z_RES_P(pgsql_link);
4005 }
4006
4007 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
4008 RETURN_FALSE;
4009 }
4010
4011 /* Just do the same as found in PostgreSQL sources... */
4012
4013 RETURN_STRING((char *) pg_encoding_to_char(PQclientEncoding(pgsql)));
4014 }
4015 /* }}} */
4016 #endif
4017
4018 #if !HAVE_PQGETCOPYDATA
4019 #define COPYBUFSIZ 8192
4020 #endif
4021
4022 /* {{{ proto bool pg_end_copy([resource connection])
4023 Sync with backend. Completes the Copy command */
4024 PHP_FUNCTION(pg_end_copy)
4025 {
4026 zval *pgsql_link = NULL;
4027 int argc = ZEND_NUM_ARGS();
4028 PGconn *pgsql;
4029 int result = 0;
4030 zend_resource *link;
4031
4032 if (zend_parse_parameters(argc, "|r", &pgsql_link) == FAILURE) {
4033 return;
4034 }
4035
4036 if (argc == 0) {
4037 link = FETCH_DEFAULT_LINK();
4038 CHECK_DEFAULT_LINK(link);
4039 } else {
4040 link = Z_RES_P(pgsql_link);
4041 }
4042
4043 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
4044 RETURN_FALSE;
4045 }
4046
4047 result = PQendcopy(pgsql);
4048
4049 if (result!=0) {
4050 PHP_PQ_ERROR("Query failed: %s", pgsql);
4051 RETURN_FALSE;
4052 }
4053 RETURN_TRUE;
4054 }
4055 /* }}} */
4056
4057 /* {{{ proto bool pg_put_line([resource connection,] string query)
4058 Send null-terminated string to backend server*/
4059 PHP_FUNCTION(pg_put_line)
4060 {
4061 char *query;
4062 zval *pgsql_link = NULL;
4063 size_t query_len;
4064 PGconn *pgsql;
4065 zend_resource *link;
4066 int result = 0, argc = ZEND_NUM_ARGS();
4067
4068 if (argc == 1) {
4069 if (zend_parse_parameters(argc, "s", &query, &query_len) == FAILURE) {
4070 return;
4071 }
4072 link = FETCH_DEFAULT_LINK();
4073 CHECK_DEFAULT_LINK(link);
4074 } else {
4075 if (zend_parse_parameters(argc, "rs", &pgsql_link, &query, &query_len) == FAILURE) {
4076 return;
4077 }
4078 link = Z_RES_P(pgsql_link);
4079 }
4080
4081 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
4082 RETURN_FALSE;
4083 }
4084
4085 result = PQputline(pgsql, query);
4086 if (result==EOF) {
4087 PHP_PQ_ERROR("Query failed: %s", pgsql);
4088 RETURN_FALSE;
4089 }
4090 RETURN_TRUE;
4091 }
4092 /* }}} */
4093
4094 /* {{{ proto array pg_copy_to(resource connection, string table_name [, string delimiter [, string null_as]])
4095 Copy table to array */
4096 PHP_FUNCTION(pg_copy_to)
4097 {
4098 zval *pgsql_link;
4099 char *table_name, *pg_delim = NULL, *pg_null_as = NULL;
4100 size_t table_name_len, pg_delim_len, pg_null_as_len, free_pg_null = 0;
4101 char *query;
4102 PGconn *pgsql;
4103 PGresult *pgsql_result;
4104 ExecStatusType status;
4105 char *csv = (char *)NULL;
4106 int argc = ZEND_NUM_ARGS();
4107
4108 if (zend_parse_parameters(argc, "rs|ss",
4109 &pgsql_link, &table_name, &table_name_len,
4110 &pg_delim, &pg_delim_len, &pg_null_as, &pg_null_as_len) == FAILURE) {
4111 return;
4112 }
4113
4114 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4115 RETURN_FALSE;
4116 }
4117
4118 if (!pg_delim) {
4119 pg_delim = "\t";
4120 }
4121 if (!pg_null_as) {
4122 pg_null_as = estrdup("\\\\N");
4123 free_pg_null = 1;
4124 }
4125
4126 spprintf(&query, 0, "COPY %s TO STDOUT DELIMITER E'%c' NULL AS E'%s'", table_name, *pg_delim, pg_null_as);
4127
4128 while ((pgsql_result = PQgetResult(pgsql))) {
4129 PQclear(pgsql_result);
4130 }
4131 pgsql_result = PQexec(pgsql, query);
4132 if (free_pg_null) {
4133 efree(pg_null_as);
4134 }
4135 efree(query);
4136
4137 if (pgsql_result) {
4138 status = PQresultStatus(pgsql_result);
4139 } else {
4140 status = (ExecStatusType) PQstatus(pgsql);
4141 }
4142
4143 switch (status) {
4144 case PGRES_COPY_OUT:
4145 if (pgsql_result) {
4146 int copydone = 0;
4147 #if !HAVE_PQGETCOPYDATA
4148 char copybuf[COPYBUFSIZ];
4149 #endif
4150
4151 PQclear(pgsql_result);
4152 array_init(return_value);
4153 #if HAVE_PQGETCOPYDATA
4154 while (!copydone)
4155 {
4156 int ret = PQgetCopyData(pgsql, &csv, 0);
4157 switch (ret) {
4158 case -1:
4159 copydone = 1;
4160 break;
4161 case 0:
4162 case -2:
4163 PHP_PQ_ERROR("getline failed: %s", pgsql);
4164 RETURN_FALSE;
4165 break;
4166 default:
4167 add_next_index_string(return_value, csv);
4168 PQfreemem(csv);
4169 break;
4170 }
4171 }
4172 #else
4173 while (!copydone)
4174 {
4175 if ((ret = PQgetline(pgsql, copybuf, COPYBUFSIZ))) {
4176 PHP_PQ_ERROR("getline failed: %s", pgsql);
4177 RETURN_FALSE;
4178 }
4179
4180 if (copybuf[0] == '\\' &&
4181 copybuf[1] == '.' &&
4182 copybuf[2] == '\0')
4183 {
4184 copydone = 1;
4185 }
4186 else
4187 {
4188 if (csv == (char *)NULL) {
4189 csv = estrdup(copybuf);
4190 } else {
4191 csv = (char *)erealloc(csv, strlen(csv) + sizeof(char)*(COPYBUFSIZ+1));
4192 strcat(csv, copybuf);
4193 }
4194
4195 switch (ret)
4196 {
4197 case EOF:
4198 copydone = 1;
4199 case 0:
4200 add_next_index_string(return_value, csv);
4201 efree(csv);
4202 csv = (char *)NULL;
4203 break;
4204 case 1:
4205 break;
4206 }
4207 }
4208 }
4209 if (PQendcopy(pgsql)) {
4210 PHP_PQ_ERROR("endcopy failed: %s", pgsql);
4211 RETURN_FALSE;
4212 }
4213 #endif
4214 while ((pgsql_result = PQgetResult(pgsql))) {
4215 PQclear(pgsql_result);
4216 }
4217 } else {
4218 PQclear(pgsql_result);
4219 RETURN_FALSE;
4220 }
4221 break;
4222 default:
4223 PQclear(pgsql_result);
4224 PHP_PQ_ERROR("Copy command failed: %s", pgsql);
4225 RETURN_FALSE;
4226 break;
4227 }
4228 }
4229 /* }}} */
4230
4231 /* {{{ proto bool pg_copy_from(resource connection, string table_name , array rows [, string delimiter [, string null_as]])
4232 Copy table from array */
4233 PHP_FUNCTION(pg_copy_from)
4234 {
4235 zval *pgsql_link = NULL, *pg_rows;
4236 zval *value;
4237 char *table_name, *pg_delim = NULL, *pg_null_as = NULL;
4238 size_t table_name_len, pg_delim_len, pg_null_as_len;
4239 int pg_null_as_free = 0;
4240 char *query;
4241 PGconn *pgsql;
4242 PGresult *pgsql_result;
4243 ExecStatusType status;
4244 int argc = ZEND_NUM_ARGS();
4245
4246 if (zend_parse_parameters(argc, "rsa|ss",
4247 &pgsql_link, &table_name, &table_name_len, &pg_rows,
4248 &pg_delim, &pg_delim_len, &pg_null_as, &pg_null_as_len) == FAILURE) {
4249 return;
4250 }
4251
4252 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4253 RETURN_FALSE;
4254 }
4255
4256 if (!pg_delim) {
4257 pg_delim = "\t";
4258 }
4259 if (!pg_null_as) {
4260 pg_null_as = estrdup("\\\\N");
4261 pg_null_as_free = 1;
4262 }
4263
4264 spprintf(&query, 0, "COPY %s FROM STDIN DELIMITER E'%c' NULL AS E'%s'", table_name, *pg_delim, pg_null_as);
4265 while ((pgsql_result = PQgetResult(pgsql))) {
4266 PQclear(pgsql_result);
4267 }
4268 pgsql_result = PQexec(pgsql, query);
4269
4270 if (pg_null_as_free) {
4271 efree(pg_null_as);
4272 }
4273 efree(query);
4274
4275 if (pgsql_result) {
4276 status = PQresultStatus(pgsql_result);
4277 } else {
4278 status = (ExecStatusType) PQstatus(pgsql);
4279 }
4280
4281 switch (status) {
4282 case PGRES_COPY_IN:
4283 if (pgsql_result) {
4284 int command_failed = 0;
4285 PQclear(pgsql_result);
4286 #if HAVE_PQPUTCOPYDATA
4287 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pg_rows), value) {
4288 zend_string *tmp = zval_try_get_string(value);
4289 if (UNEXPECTED(!tmp)) {
4290 return;
4291 }
4292 query = (char *)emalloc(ZSTR_LEN(tmp) + 2);
4293 strlcpy(query, ZSTR_VAL(tmp), ZSTR_LEN(tmp) + 2);
4294 if (ZSTR_LEN(tmp) > 0 && *(query + ZSTR_LEN(tmp) - 1) != '\n') {
4295 strlcat(query, "\n", ZSTR_LEN(tmp) + 2);
4296 }
4297 if (PQputCopyData(pgsql, query, (int)strlen(query)) != 1) {
4298 efree(query);
4299 zend_string_release(tmp);
4300 PHP_PQ_ERROR("copy failed: %s", pgsql);
4301 RETURN_FALSE;
4302 }
4303 efree(query);
4304 zend_string_release(tmp);
4305 } ZEND_HASH_FOREACH_END();
4306
4307 if (PQputCopyEnd(pgsql, NULL) != 1) {
4308 PHP_PQ_ERROR("putcopyend failed: %s", pgsql);
4309 RETURN_FALSE;
4310 }
4311 #else
4312 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pg_rows), value) {
4313 zend_string *tmp = zval_try_get_string(value);
4314 if (UNEXPECTED(!tmp)) {
4315 return;
4316 }
4317 query = (char *)emalloc(ZSTR_LEN(tmp) + 2);
4318 strlcpy(query, ZSTR_LVAL(tmp), ZSTR_LEN(tmp) + 2);
4319 if (ZSTR_LEN(tmp) > 0 && *(query + ZSTR_LEN(tmp) - 1) != '\n') {
4320 strlcat(query, "\n", ZSTR_LEN(tmp) + 2);
4321 }
4322 if (PQputline(pgsql, query)==EOF) {
4323 efree(query);
4324 zend_string_release(tmp);
4325 PHP_PQ_ERROR("copy failed: %s", pgsql);
4326 RETURN_FALSE;
4327 }
4328 efree(query);
4329 zend_string_release(tmp);
4330 } ZEND_HASH_FOREACH_END();
4331
4332 if (PQputline(pgsql, "\\.\n") == EOF) {
4333 PHP_PQ_ERROR("putline failed: %s", pgsql);
4334 RETURN_FALSE;
4335 }
4336 if (PQendcopy(pgsql)) {
4337 PHP_PQ_ERROR("endcopy failed: %s", pgsql);
4338 RETURN_FALSE;
4339 }
4340 #endif
4341 while ((pgsql_result = PQgetResult(pgsql))) {
4342 if (PGRES_COMMAND_OK != PQresultStatus(pgsql_result)) {
4343 PHP_PQ_ERROR("Copy command failed: %s", pgsql);
4344 command_failed = 1;
4345 }
4346 PQclear(pgsql_result);
4347 }
4348 if (command_failed) {
4349 RETURN_FALSE;
4350 }
4351 } else {
4352 PQclear(pgsql_result);
4353 RETURN_FALSE;
4354 }
4355 RETURN_TRUE;
4356 break;
4357 default:
4358 PQclear(pgsql_result);
4359 PHP_PQ_ERROR("Copy command failed: %s", pgsql);
4360 RETURN_FALSE;
4361 break;
4362 }
4363 }
4364 /* }}} */
4365
4366 #ifdef HAVE_PQESCAPE
4367 /* {{{ proto string pg_escape_string([resource connection,] string data)
4368 Escape string for text/char type */
4369 PHP_FUNCTION(pg_escape_string)
4370 {
4371 zend_string *from = NULL, *to = NULL;
4372 zval *pgsql_link;
4373 zend_resource *link;
4374 #ifdef HAVE_PQESCAPE_CONN
4375 PGconn *pgsql;
4376 #endif
4377
4378 switch (ZEND_NUM_ARGS()) {
4379 case 1:
4380 if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &from) == FAILURE) {
4381 return;
4382 }
4383 link = FETCH_DEFAULT_LINK();
4384 break;
4385 default:
4386 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rS", &pgsql_link, &from) == FAILURE) {
4387 return;
4388 }
4389 link = Z_RES_P(pgsql_link);
4390 break;
4391 }
4392
4393 to = zend_string_safe_alloc(ZSTR_LEN(from), 2, 0, 0);
4394 #ifdef HAVE_PQESCAPE_CONN
4395 if (link) {
4396 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
4397 RETURN_FALSE;
4398 }
4399 ZSTR_LEN(to) = PQescapeStringConn(pgsql, ZSTR_VAL(to), ZSTR_VAL(from), ZSTR_LEN(from), NULL);
4400 } else
4401 #endif
4402 {
4403 ZSTR_LEN(to) = PQescapeString(ZSTR_VAL(to), ZSTR_VAL(from), ZSTR_LEN(from));
4404 }
4405
4406 to = zend_string_truncate(to, ZSTR_LEN(to), 0);
4407 RETURN_NEW_STR(to);
4408 }
4409 /* }}} */
4410
4411 /* {{{ proto string pg_escape_bytea([resource connection,] string data)
4412 Escape binary for bytea type */
4413 PHP_FUNCTION(pg_escape_bytea)
4414 {
4415 char *from = NULL, *to = NULL;
4416 size_t to_len;
4417 size_t from_len;
4418 #ifdef HAVE_PQESCAPE_BYTEA_CONN
4419 PGconn *pgsql;
4420 #endif
4421 zval *pgsql_link;
4422 zend_resource *link;
4423
4424 switch (ZEND_NUM_ARGS()) {
4425 case 1:
4426 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &from, &from_len) == FAILURE) {
4427 return;
4428 }
4429 link = FETCH_DEFAULT_LINK();
4430 break;
4431 default:
4432 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &pgsql_link, &from, &from_len) == FAILURE) {
4433 return;
4434 }
4435 link = Z_RES_P(pgsql_link);
4436 break;
4437 }
4438
4439 #ifdef HAVE_PQESCAPE_BYTEA_CONN
4440 if (link) {
4441 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
4442 RETURN_FALSE;
4443 }
4444 to = (char *)PQescapeByteaConn(pgsql, (unsigned char *)from, (size_t)from_len, &to_len);
4445 } else
4446 #endif
4447 to = (char *)PQescapeBytea((unsigned char*)from, from_len, &to_len);
4448
4449 RETVAL_STRINGL(to, to_len-1); /* to_len includes additional '\0' */
4450 PQfreemem(to);
4451 }
4452 /* }}} */
4453
4454 #if !HAVE_PQUNESCAPEBYTEA
4455 /* PQunescapeBytea() from PostgreSQL 7.3 to provide bytea unescape feature to 7.2 users.
4456 Renamed to php_pgsql_unescape_bytea() */
4457 /*
4458 * PQunescapeBytea - converts the null terminated string representation
4459 * of a bytea, strtext, into binary, filling a buffer. It returns a
4460 * pointer to the buffer which is NULL on error, and the size of the
4461 * buffer in retbuflen. The pointer may subsequently be used as an
4462 * argument to the function free(3). It is the reverse of PQescapeBytea.
4463 *
4464 * The following transformations are reversed:
4465 * '\0' == ASCII 0 == \000
4466 * '\'' == ASCII 39 == \'
4467 * '\\' == ASCII 92 == \\
4468 *
4469 * States:
4470 * 0 normal 0->1->2->3->4
4471 * 1 \ 1->5
4472 * 2 \0 1->6
4473 * 3 \00
4474 * 4 \000
4475 * 5 \'
4476 * 6 \\
4477 */
4478 static unsigned char * php_pgsql_unescape_bytea(unsigned char *strtext, size_t *retbuflen) /* {{{ */
4479 {
4480 size_t buflen;
4481 unsigned char *buffer,
4482 *sp,
4483 *bp;
4484 unsigned int state = 0;
4485
4486 if (strtext == NULL)
4487 return NULL;
4488 buflen = strlen(strtext); /* will shrink, also we discover if
4489 * strtext */
4490 buffer = (unsigned char *) emalloc(buflen); /* isn't NULL terminated */
4491 for (bp = buffer, sp = strtext; *sp != '\0'; bp++, sp++)
4492 {
4493 switch (state)
4494 {
4495 case 0:
4496 if (*sp == '\\')
4497 state = 1;
4498 *bp = *sp;
4499 break;
4500 case 1:
4501 if (*sp == '\'') /* state=5 */
4502 { /* replace \' with 39 */
4503 bp--;
4504 *bp = '\'';
4505 buflen--;
4506 state = 0;
4507 }
4508 else if (*sp == '\\') /* state=6 */
4509 { /* replace \\ with 92 */
4510 bp--;
4511 *bp = '\\';
4512 buflen--;
4513 state = 0;
4514 }
4515 else
4516 {
4517 if (isdigit(*sp))
4518 state = 2;
4519 else
4520 state = 0;
4521 *bp = *sp;
4522 }
4523 break;
4524 case 2:
4525 if (isdigit(*sp))
4526 state = 3;
4527 else
4528 state = 0;
4529 *bp = *sp;
4530 break;
4531 case 3:
4532 if (isdigit(*sp)) /* state=4 */
4533 {
4534 unsigned char *start, *end, buf[4]; /* 000 + '\0' */
4535
4536 bp -= 3;
4537 memcpy(buf, sp-2, 3);
4538 buf[3] = '\0';
4539 start = buf;
4540 *bp = (unsigned char)strtoul(start, (char **)&end, 8);
4541 buflen -= 3;
4542 state = 0;
4543 }
4544 else
4545 {
4546 *bp = *sp;
4547 state = 0;
4548 }
4549 break;
4550 }
4551 }
4552 buffer = erealloc(buffer, buflen+1);
4553 buffer[buflen] = '\0';
4554
4555 *retbuflen = buflen;
4556 return buffer;
4557 }
4558 /* }}} */
4559 #endif
4560
4561 /* {{{ proto string pg_unescape_bytea(string data)
4562 Unescape binary for bytea type */
4563 PHP_FUNCTION(pg_unescape_bytea)
4564 {
4565 char *from = NULL, *to = NULL, *tmp = NULL;
4566 size_t to_len;
4567 size_t from_len;
4568 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
4569 &from, &from_len) == FAILURE) {
4570 return;
4571 }
4572
4573 #if HAVE_PQUNESCAPEBYTEA
4574 tmp = (char *)PQunescapeBytea((unsigned char*)from, &to_len);
4575 to = estrndup(tmp, to_len);
4576 PQfreemem(tmp);
4577 #else
4578 to = (char *)php_pgsql_unescape_bytea((unsigned char*)from, &to_len);
4579 #endif
4580 if (!to) {
4581 php_error_docref(NULL, E_WARNING,"Invalid parameter");
4582 RETURN_FALSE;
4583 }
4584 RETVAL_STRINGL(to, to_len);
4585 efree(to);
4586 }
4587 /* }}} */
4588 #endif
4589
4590 #ifdef HAVE_PQESCAPE
4591 static void php_pgsql_escape_internal(INTERNAL_FUNCTION_PARAMETERS, int escape_literal) /* {{{ */ {
4592 char *from = NULL;
4593 zval *pgsql_link = NULL;
4594 PGconn *pgsql;
4595 size_t from_len;
4596 char *tmp;
4597 zend_resource *link;
4598
4599 switch (ZEND_NUM_ARGS()) {
4600 case 1:
4601 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &from, &from_len) == FAILURE) {
4602 return;
4603 }
4604 link = FETCH_DEFAULT_LINK();
4605 CHECK_DEFAULT_LINK(link);
4606 break;
4607
4608 default:
4609 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &pgsql_link, &from, &from_len) == FAILURE) {
4610 return;
4611 }
4612 link = Z_RES_P(pgsql_link);
4613 break;
4614 }
4615
4616 if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {
4617 RETURN_FALSE;
4618 }
4619
4620 if (pgsql == NULL) {
4621 php_error_docref(NULL, E_WARNING,"Cannot get pgsql link");
4622 RETURN_FALSE;
4623 }
4624
4625 if (escape_literal) {
4626 tmp = PGSQLescapeLiteral(pgsql, from, (size_t)from_len);
4627 } else {
4628 tmp = PGSQLescapeIdentifier(pgsql, from, (size_t)from_len);
4629 }
4630 if (!tmp) {
4631 php_error_docref(NULL, E_WARNING,"Failed to escape");
4632 RETURN_FALSE;
4633 }
4634
4635 RETVAL_STRING(tmp);
4636 PGSQLfree(tmp);
4637 }
4638 /* }}} */
4639
4640 /* {{{ proto string pg_escape_literal([resource connection,] string data)
4641 Escape parameter as string literal (i.e. parameter) */
4642 PHP_FUNCTION(pg_escape_literal)
4643 {
4644 php_pgsql_escape_internal(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
4645 }
4646 /* }}} */
4647
4648 /* {{{ proto string pg_escape_identifier([resource connection,] string data)
4649 Escape identifier (i.e. table name, field name) */
4650 PHP_FUNCTION(pg_escape_identifier)
4651 {
4652 php_pgsql_escape_internal(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
4653 }
4654 /* }}} */
4655 #endif
4656
4657 /* {{{ proto string pg_result_error(resource result)
4658 Get error message associated with result */
4659 PHP_FUNCTION(pg_result_error)
4660 {
4661 zval *result;
4662 PGresult *pgsql_result;
4663 pgsql_result_handle *pg_result;
4664 char *err = NULL;
4665
4666 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r",
4667 &result) == FAILURE) {
4668 RETURN_FALSE;
4669 }
4670
4671 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
4672 RETURN_FALSE;
4673 }
4674
4675 pgsql_result = pg_result->result;
4676 if (!pgsql_result) {
4677 RETURN_FALSE;
4678 }
4679 err = (char *)PQresultErrorMessage(pgsql_result);
4680 RETURN_STRING(err);
4681 }
4682 /* }}} */
4683
4684 #if HAVE_PQRESULTERRORFIELD
4685 /* {{{ proto string pg_result_error_field(resource result, int fieldcode)
4686 Get error message field associated with result */
4687 PHP_FUNCTION(pg_result_error_field)
4688 {
4689 zval *result;
4690 zend_long fieldcode;
4691 PGresult *pgsql_result;
4692 pgsql_result_handle *pg_result;
4693 char *field = NULL;
4694
4695 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "rl",
4696 &result, &fieldcode) == FAILURE) {
4697 RETURN_FALSE;
4698 }
4699
4700 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
4701 RETURN_FALSE;
4702 }
4703
4704 pgsql_result = pg_result->result;
4705 if (!pgsql_result) {
4706 RETURN_FALSE;
4707 }
4708 if (fieldcode & (PG_DIAG_SEVERITY|PG_DIAG_SQLSTATE|PG_DIAG_MESSAGE_PRIMARY|PG_DIAG_MESSAGE_DETAIL
4709 |PG_DIAG_MESSAGE_HINT|PG_DIAG_STATEMENT_POSITION
4710 #if PG_DIAG_INTERNAL_POSITION
4711 |PG_DIAG_INTERNAL_POSITION
4712 #endif
4713 #if PG_DIAG_INTERNAL_QUERY
4714 |PG_DIAG_INTERNAL_QUERY
4715 #endif
4716 |PG_DIAG_CONTEXT|PG_DIAG_SOURCE_FILE|PG_DIAG_SOURCE_LINE
4717 |PG_DIAG_SOURCE_FUNCTION)) {
4718 field = (char *)PQresultErrorField(pgsql_result, (int)fieldcode);
4719 if (field == NULL) {
4720 RETURN_NULL();
4721 } else {
4722 RETURN_STRING(field);
4723 }
4724 } else {
4725 RETURN_FALSE;
4726 }
4727 }
4728 /* }}} */
4729 #endif
4730
4731 /* {{{ proto int pg_connection_status(resource connection)
4732 Get connection status */
4733 PHP_FUNCTION(pg_connection_status)
4734 {
4735 zval *pgsql_link = NULL;
4736 PGconn *pgsql;
4737
4738 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r",
4739 &pgsql_link) == FAILURE) {
4740 RETURN_FALSE;
4741 }
4742
4743 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4744 RETURN_FALSE;
4745 }
4746
4747 RETURN_LONG(PQstatus(pgsql));
4748 }
4749
4750 /* }}} */
4751
4752 #if HAVE_PGTRANSACTIONSTATUS
4753 /* {{{ proto int pg_transaction_status(resource connection)
4754 Get transaction status */
4755 PHP_FUNCTION(pg_transaction_status)
4756 {
4757 zval *pgsql_link = NULL;
4758 PGconn *pgsql;
4759
4760 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r",
4761 &pgsql_link) == FAILURE) {
4762 RETURN_FALSE;
4763 }
4764
4765 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4766 RETURN_FALSE;
4767 }
4768
4769 RETURN_LONG(PQtransactionStatus(pgsql));
4770 }
4771 #endif
4772
4773 /* }}} */
4774
4775 /* {{{ proto bool pg_connection_reset(resource connection)
4776 Reset connection (reconnect) */
4777 PHP_FUNCTION(pg_connection_reset)
4778 {
4779 zval *pgsql_link;
4780 PGconn *pgsql;
4781
4782 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r",
4783 &pgsql_link) == FAILURE) {
4784 RETURN_FALSE;
4785 }
4786
4787 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4788 RETURN_FALSE;
4789 }
4790
4791 PQreset(pgsql);
4792 if (PQstatus(pgsql) == CONNECTION_BAD) {
4793 RETURN_FALSE;
4794 }
4795 RETURN_TRUE;
4796 }
4797 /* }}} */
4798
4799 #define PHP_PG_ASYNC_IS_BUSY 1
4800 #define PHP_PG_ASYNC_REQUEST_CANCEL 2
4801
4802 /* {{{ php_pgsql_flush_query
4803 */
4804 static int php_pgsql_flush_query(PGconn *pgsql)
4805 {
4806 PGresult *res;
4807 int leftover = 0;
4808
4809 if (PQ_SETNONBLOCKING(pgsql, 1)) {
4810 php_error_docref(NULL, E_NOTICE,"Cannot set connection to nonblocking mode");
4811 return -1;
4812 }
4813 while ((res = PQgetResult(pgsql))) {
4814 PQclear(res);
4815 leftover++;
4816 }
4817 PQ_SETNONBLOCKING(pgsql, 0);
4818 return leftover;
4819 }
4820 /* }}} */
4821
4822 /* {{{ php_pgsql_do_async
4823 */
4824 static void php_pgsql_do_async(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
4825 {
4826 zval *pgsql_link;
4827 PGconn *pgsql;
4828 PGresult *pgsql_result;
4829
4830 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r",
4831 &pgsql_link) == FAILURE) {
4832 RETURN_FALSE;
4833 }
4834
4835 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4836 RETURN_FALSE;
4837 }
4838
4839 if (PQ_SETNONBLOCKING(pgsql, 1)) {
4840 php_error_docref(NULL, E_NOTICE, "Cannot set connection to nonblocking mode");
4841 RETURN_FALSE;
4842 }
4843 switch(entry_type) {
4844 case PHP_PG_ASYNC_IS_BUSY:
4845 PQconsumeInput(pgsql);
4846 RETVAL_LONG(PQisBusy(pgsql));
4847 break;
4848 case PHP_PG_ASYNC_REQUEST_CANCEL:
4849 RETVAL_LONG(PQrequestCancel(pgsql));
4850 while ((pgsql_result = PQgetResult(pgsql))) {
4851 PQclear(pgsql_result);
4852 }
4853 break;
4854 default:
4855 php_error_docref(NULL, E_ERROR, "PostgreSQL module error, please report this error");
4856 break;
4857 }
4858 if (PQ_SETNONBLOCKING(pgsql, 0)) {
4859 php_error_docref(NULL, E_NOTICE, "Cannot set connection to blocking mode");
4860 }
4861 convert_to_boolean_ex(return_value);
4862 }
4863 /* }}} */
4864
4865 /* {{{ proto bool pg_cancel_query(resource connection)
4866 Cancel request */
4867 PHP_FUNCTION(pg_cancel_query)
4868 {
4869 php_pgsql_do_async(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_PG_ASYNC_REQUEST_CANCEL);
4870 }
4871 /* }}} */
4872
4873 /* {{{ proto bool pg_connection_busy(resource connection)
4874 Get connection is busy or not */
4875 PHP_FUNCTION(pg_connection_busy)
4876 {
4877 php_pgsql_do_async(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_PG_ASYNC_IS_BUSY);
4878 }
4879 /* }}} */
4880
4881 static int _php_pgsql_link_has_results(PGconn *pgsql) /* {{{ */
4882 {
4883 PGresult *result;
4884 while ((result = PQgetResult(pgsql))) {
4885 PQclear(result);
4886 return 1;
4887 }
4888 return 0;
4889 }
4890 /* }}} */
4891
4892 /* {{{ proto bool pg_send_query(resource connection, string query)
4893 Send asynchronous query */
4894 PHP_FUNCTION(pg_send_query)
4895 {
4896 zval *pgsql_link;
4897 char *query;
4898 size_t len;
4899 PGconn *pgsql;
4900 int is_non_blocking;
4901 int ret;
4902
4903 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &pgsql_link, &query, &len) == FAILURE) {
4904 return;
4905 }
4906
4907 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4908 RETURN_FALSE;
4909 }
4910
4911 is_non_blocking = PQisnonblocking(pgsql);
4912
4913 if (is_non_blocking == 0 && PQ_SETNONBLOCKING(pgsql, 1) == -1) {
4914 php_error_docref(NULL, E_NOTICE, "Cannot set connection to nonblocking mode");
4915 RETURN_FALSE;
4916 }
4917
4918 if (_php_pgsql_link_has_results(pgsql)) {
4919 php_error_docref(NULL, E_NOTICE,
4920 "There are results on this connection. Call pg_get_result() until it returns FALSE");
4921 }
4922
4923 if (is_non_blocking) {
4924 if (!PQsendQuery(pgsql, query)) {
4925 RETURN_FALSE;
4926 }
4927 ret = PQflush(pgsql);
4928 } else {
4929 if (!PQsendQuery(pgsql, query)) {
4930 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
4931 PQreset(pgsql);
4932 }
4933 if (!PQsendQuery(pgsql, query)) {
4934 RETURN_FALSE;
4935 }
4936 }
4937
4938 /* Wait to finish sending buffer */
4939 while ((ret = PQflush(pgsql))) {
4940 if (ret == -1) {
4941 php_error_docref(NULL, E_NOTICE, "Could not empty PostgreSQL send buffer");
4942 break;
4943 }
4944 usleep(10000);
4945 }
4946
4947 if (PQ_SETNONBLOCKING(pgsql, 0)) {
4948 php_error_docref(NULL, E_NOTICE, "Cannot set connection to blocking mode");
4949 }
4950 }
4951
4952 if (ret == 0) {
4953 RETURN_TRUE;
4954 } else if (ret == -1) {
4955 RETURN_FALSE;
4956 } else {
4957 RETURN_LONG(0);
4958 }
4959 }
4960 /* }}} */
4961
4962 #if HAVE_PQSENDQUERYPARAMS
4963 /* {{{ proto bool pg_send_query_params(resource connection, string query, array params)
4964 Send asynchronous parameterized query */
4965 PHP_FUNCTION(pg_send_query_params)
4966 {
4967 zval *pgsql_link, *pv_param_arr, *tmp;
4968 int num_params = 0;
4969 char **params = NULL;
4970 char *query;
4971 size_t query_len;
4972 PGconn *pgsql;
4973 int is_non_blocking;
4974 int ret;
4975
4976 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsa", &pgsql_link, &query, &query_len, &pv_param_arr) == FAILURE) {
4977 return;
4978 }
4979
4980 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
4981 RETURN_FALSE;
4982 }
4983
4984 is_non_blocking = PQisnonblocking(pgsql);
4985
4986 if (is_non_blocking == 0 && PQ_SETNONBLOCKING(pgsql, 1) == -1) {
4987 php_error_docref(NULL, E_NOTICE, "Cannot set connection to nonblocking mode");
4988 RETURN_FALSE;
4989 }
4990
4991 if (_php_pgsql_link_has_results(pgsql)) {
4992 php_error_docref(NULL, E_NOTICE,
4993 "There are results on this connection. Call pg_get_result() until it returns FALSE");
4994 }
4995
4996 num_params = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr));
4997 if (num_params > 0) {
4998 int i = 0;
4999 params = (char **)safe_emalloc(sizeof(char *), num_params, 0);
5000
5001 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pv_param_arr), tmp) {
5002
5003 if (Z_TYPE_P(tmp) == IS_NULL) {
5004 params[i] = NULL;
5005 } else {
5006 zend_string *tmp_str;
5007 zend_string *str = zval_get_tmp_string(tmp, &tmp_str);
5008
5009 params[i] = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
5010 zend_tmp_string_release(tmp_str);
5011 }
5012
5013 i++;
5014 } ZEND_HASH_FOREACH_END();
5015 }
5016
5017 if (PQsendQueryParams(pgsql, query, num_params, NULL, (const char * const *)params, NULL, NULL, 0)) {
5018 _php_pgsql_free_params(params, num_params);
5019 } else if (is_non_blocking) {
5020 _php_pgsql_free_params(params, num_params);
5021 RETURN_FALSE;
5022 } else {
5023 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
5024 PQreset(pgsql);
5025 }
5026 if (!PQsendQueryParams(pgsql, query, num_params, NULL, (const char * const *)params, NULL, NULL, 0)) {
5027 _php_pgsql_free_params(params, num_params);
5028 RETURN_FALSE;
5029 }
5030 }
5031
5032 if (is_non_blocking) {
5033 ret = PQflush(pgsql);
5034 } else {
5035 /* Wait to finish sending buffer */
5036 while ((ret = PQflush(pgsql))) {
5037 if (ret == -1) {
5038 php_error_docref(NULL, E_NOTICE, "Could not empty PostgreSQL send buffer");
5039 break;
5040 }
5041 usleep(10000);
5042 }
5043
5044 if (PQ_SETNONBLOCKING(pgsql, 0) != 0) {
5045 php_error_docref(NULL, E_NOTICE, "Cannot set connection to blocking mode");
5046 }
5047 }
5048
5049 if (ret == 0) {
5050 RETURN_TRUE;
5051 } else if (ret == -1) {
5052 RETURN_FALSE;
5053 } else {
5054 RETURN_LONG(0);
5055 }
5056 }
5057 /* }}} */
5058 #endif
5059
5060 #if HAVE_PQSENDPREPARE
5061 /* {{{ proto bool pg_send_prepare(resource connection, string stmtname, string query)
5062 Asynchronously prepare a query for future execution */
5063 PHP_FUNCTION(pg_send_prepare)
5064 {
5065 zval *pgsql_link;
5066 char *query, *stmtname;
5067 size_t stmtname_len, query_len;
5068 PGconn *pgsql;
5069 int is_non_blocking;
5070 int ret;
5071
5072 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &pgsql_link, &stmtname, &stmtname_len, &query, &query_len) == FAILURE) {
5073 return;
5074 }
5075
5076 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5077 RETURN_FALSE;
5078 }
5079
5080 is_non_blocking = PQisnonblocking(pgsql);
5081
5082 if (is_non_blocking == 0 && PQ_SETNONBLOCKING(pgsql, 1) == -1) {
5083 php_error_docref(NULL, E_NOTICE, "Cannot set connection to nonblocking mode");
5084 RETURN_FALSE;
5085 }
5086
5087 if (_php_pgsql_link_has_results(pgsql)) {
5088 php_error_docref(NULL, E_NOTICE,
5089 "There are results on this connection. Call pg_get_result() until it returns FALSE");
5090 }
5091
5092 if (!PQsendPrepare(pgsql, stmtname, query, 0, NULL)) {
5093 if (is_non_blocking) {
5094 RETURN_FALSE;
5095 } else {
5096 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
5097 PQreset(pgsql);
5098 }
5099 if (!PQsendPrepare(pgsql, stmtname, query, 0, NULL)) {
5100 RETURN_FALSE;
5101 }
5102 }
5103 }
5104
5105 if (is_non_blocking) {
5106 ret = PQflush(pgsql);
5107 } else {
5108 /* Wait to finish sending buffer */
5109 while ((ret = PQflush(pgsql))) {
5110 if (ret == -1) {
5111 php_error_docref(NULL, E_NOTICE, "Could not empty PostgreSQL send buffer");
5112 break;
5113 }
5114 usleep(10000);
5115 }
5116 if (PQ_SETNONBLOCKING(pgsql, 0) != 0) {
5117 php_error_docref(NULL, E_NOTICE, "Cannot set connection to blocking mode");
5118 }
5119 }
5120
5121 if (ret == 0) {
5122 RETURN_TRUE;
5123 } else if (ret == -1) {
5124 RETURN_FALSE;
5125 } else {
5126 RETURN_LONG(0);
5127 }
5128 }
5129 /* }}} */
5130 #endif
5131
5132 #if HAVE_PQSENDQUERYPREPARED
5133 /* {{{ proto bool pg_send_execute(resource connection, string stmtname, array params)
5134 Executes prevriously prepared stmtname asynchronously */
5135 PHP_FUNCTION(pg_send_execute)
5136 {
5137 zval *pgsql_link;
5138 zval *pv_param_arr, *tmp;
5139 int num_params = 0;
5140 char **params = NULL;
5141 char *stmtname;
5142 size_t stmtname_len;
5143 PGconn *pgsql;
5144 int is_non_blocking;
5145 int ret;
5146
5147 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsa", &pgsql_link, &stmtname, &stmtname_len, &pv_param_arr) == FAILURE) {
5148 return;
5149 }
5150
5151 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5152 RETURN_FALSE;
5153 }
5154
5155 is_non_blocking = PQisnonblocking(pgsql);
5156
5157 if (is_non_blocking == 0 && PQ_SETNONBLOCKING(pgsql, 1) == -1) {
5158 php_error_docref(NULL, E_NOTICE, "Cannot set connection to nonblocking mode");
5159 RETURN_FALSE;
5160 }
5161
5162 if (_php_pgsql_link_has_results(pgsql)) {
5163 php_error_docref(NULL, E_NOTICE,
5164 "There are results on this connection. Call pg_get_result() until it returns FALSE");
5165 }
5166
5167 num_params = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr));
5168 if (num_params > 0) {
5169 int i = 0;
5170 params = (char **)safe_emalloc(sizeof(char *), num_params, 0);
5171
5172 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pv_param_arr), tmp) {
5173
5174 if (Z_TYPE_P(tmp) == IS_NULL) {
5175 params[i] = NULL;
5176 } else {
5177 zend_string *tmp_str = zval_try_get_string(tmp);
5178 if (UNEXPECTED(!tmp_str)) {
5179 _php_pgsql_free_params(params, i);
5180 return;
5181 }
5182 params[i] = estrndup(ZSTR_VAL(tmp_str), ZSTR_LEN(tmp_str));
5183 zend_string_release(tmp_str);
5184 }
5185
5186 i++;
5187 } ZEND_HASH_FOREACH_END();
5188 }
5189
5190 if (PQsendQueryPrepared(pgsql, stmtname, num_params, (const char * const *)params, NULL, NULL, 0)) {
5191 _php_pgsql_free_params(params, num_params);
5192 } else if (is_non_blocking) {
5193 _php_pgsql_free_params(params, num_params);
5194 RETURN_FALSE;
5195 } else {
5196 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
5197 PQreset(pgsql);
5198 }
5199 if (!PQsendQueryPrepared(pgsql, stmtname, num_params, (const char * const *)params, NULL, NULL, 0)) {
5200 _php_pgsql_free_params(params, num_params);
5201 RETURN_FALSE;
5202 }
5203 }
5204
5205 if (is_non_blocking) {
5206 ret = PQflush(pgsql);
5207 } else {
5208 /* Wait to finish sending buffer */
5209 while ((ret = PQflush(pgsql))) {
5210 if (ret == -1) {
5211 php_error_docref(NULL, E_NOTICE, "Could not empty PostgreSQL send buffer");
5212 break;
5213 }
5214 usleep(10000);
5215 }
5216 if (PQ_SETNONBLOCKING(pgsql, 0) != 0) {
5217 php_error_docref(NULL, E_NOTICE, "Cannot set connection to blocking mode");
5218 }
5219 }
5220
5221 if (ret == 0) {
5222 RETURN_TRUE;
5223 } else if (ret == -1) {
5224 RETURN_FALSE;
5225 } else {
5226 RETURN_LONG(0);
5227 }
5228 }
5229 /* }}} */
5230 #endif
5231
5232 /* {{{ proto resource pg_get_result(resource connection)
5233 Get asynchronous query result */
5234 PHP_FUNCTION(pg_get_result)
5235 {
5236 zval *pgsql_link;
5237 PGconn *pgsql;
5238 PGresult *pgsql_result;
5239 pgsql_result_handle *pg_result;
5240
5241 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r", &pgsql_link) == FAILURE) {
5242 RETURN_FALSE;
5243 }
5244
5245 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5246 RETURN_FALSE;
5247 }
5248
5249 pgsql_result = PQgetResult(pgsql);
5250 if (!pgsql_result) {
5251 /* no result */
5252 RETURN_FALSE;
5253 }
5254 pg_result = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
5255 pg_result->conn = pgsql;
5256 pg_result->result = pgsql_result;
5257 pg_result->row = 0;
5258 RETURN_RES(zend_register_resource(pg_result, le_result));
5259 }
5260 /* }}} */
5261
5262 /* {{{ proto mixed pg_result_status(resource result[, int result_type])
5263 Get status of query result */
5264 PHP_FUNCTION(pg_result_status)
5265 {
5266 zval *result;
5267 zend_long result_type = PGSQL_STATUS_LONG;
5268 ExecStatusType status;
5269 PGresult *pgsql_result;
5270 pgsql_result_handle *pg_result;
5271
5272 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r|l",
5273 &result, &result_type) == FAILURE) {
5274 RETURN_FALSE;
5275 }
5276
5277 if ((pg_result = (pgsql_result_handle *)zend_fetch_resource(Z_RES_P(result), "PostgreSQL result", le_result)) == NULL) {
5278 RETURN_FALSE;
5279 }
5280
5281 pgsql_result = pg_result->result;
5282 if (result_type == PGSQL_STATUS_LONG) {
5283 status = PQresultStatus(pgsql_result);
5284 RETURN_LONG((int)status);
5285 }
5286 else if (result_type == PGSQL_STATUS_STRING) {
5287 RETURN_STRING(PQcmdStatus(pgsql_result));
5288 }
5289 else {
5290 php_error_docref(NULL, E_WARNING, "Optional 2nd parameter should be PGSQL_STATUS_LONG or PGSQL_STATUS_STRING");
5291 RETURN_FALSE;
5292 }
5293 }
5294 /* }}} */
5295
5296 /* {{{ proto mixed pg_get_notify([resource connection[, int result_type]])
5297 Get asynchronous notification */
5298 PHP_FUNCTION(pg_get_notify)
5299 {
5300 zval *pgsql_link;
5301 zend_long result_type = PGSQL_ASSOC;
5302 PGconn *pgsql;
5303 PGnotify *pgsql_notify;
5304
5305 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r|l",
5306 &pgsql_link, &result_type) == FAILURE) {
5307 RETURN_FALSE;
5308 }
5309
5310 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5311 RETURN_FALSE;
5312 }
5313
5314 if (!(result_type & PGSQL_BOTH)) {
5315 php_error_docref(NULL, E_WARNING, "Invalid result type");
5316 RETURN_FALSE;
5317 }
5318
5319 PQconsumeInput(pgsql);
5320 pgsql_notify = PQnotifies(pgsql);
5321 if (!pgsql_notify) {
5322 /* no notify message */
5323 RETURN_FALSE;
5324 }
5325 array_init(return_value);
5326 if (result_type & PGSQL_NUM) {
5327 add_index_string(return_value, 0, pgsql_notify->relname);
5328 add_index_long(return_value, 1, pgsql_notify->be_pid);
5329 #if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
5330 /* consider to use php_version_compare() here */
5331 if (PQprotocolVersion(pgsql) >= 3 && zend_strtod(PQparameterStatus(pgsql, "server_version"), NULL) >= 9.0) {
5332 #else
5333 if (zend_strtod(PG_VERSION) >= 9.0, NULL) {
5334 #endif
5335 #if HAVE_PQPARAMETERSTATUS
5336 add_index_string(return_value, 2, pgsql_notify->extra);
5337 #endif
5338 }
5339 }
5340 if (result_type & PGSQL_ASSOC) {
5341 add_assoc_string(return_value, "message", pgsql_notify->relname);
5342 add_assoc_long(return_value, "pid", pgsql_notify->be_pid);
5343 #if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
5344 /* consider to use php_version_compare() here */
5345 if (PQprotocolVersion(pgsql) >= 3 && zend_strtod(PQparameterStatus(pgsql, "server_version"), NULL) >= 9.0) {
5346 #else
5347 if (zend_strtod(PG_VERSION, NULL) >= 9.0) {
5348 #endif
5349 #if HAVE_PQPARAMETERSTATUS
5350 add_assoc_string(return_value, "payload", pgsql_notify->extra);
5351 #endif
5352 }
5353 }
5354 PQfreemem(pgsql_notify);
5355 }
5356 /* }}} */
5357
5358 /* {{{ proto int pg_get_pid([resource connection)
5359 Get backend(server) pid */
5360 PHP_FUNCTION(pg_get_pid)
5361 {
5362 zval *pgsql_link;
5363 PGconn *pgsql;
5364
5365 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "r",
5366 &pgsql_link) == FAILURE) {
5367 RETURN_FALSE;
5368 }
5369
5370 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5371 RETURN_FALSE;
5372 }
5373
5374 RETURN_LONG(PQbackendPID(pgsql));
5375 }
5376 /* }}} */
5377
5378 static ssize_t php_pgsql_fd_write(php_stream *stream, const char *buf, size_t count) /* {{{ */
5379 {
5380 return -1;
5381 }
5382 /* }}} */
5383
5384 static ssize_t php_pgsql_fd_read(php_stream *stream, char *buf, size_t count) /* {{{ */
5385 {
5386 return -1;
5387 }
5388 /* }}} */
5389
5390 static int php_pgsql_fd_close(php_stream *stream, int close_handle) /* {{{ */
5391 {
5392 return EOF;
5393 }
5394 /* }}} */
5395
5396 static int php_pgsql_fd_flush(php_stream *stream) /* {{{ */
5397 {
5398 return FAILURE;
5399 }
5400 /* }}} */
5401
5402 static int php_pgsql_fd_set_option(php_stream *stream, int option, int value, void *ptrparam) /* {{{ */
5403 {
5404 PGconn *pgsql = (PGconn *) stream->abstract;
5405 switch (option) {
5406 case PHP_STREAM_OPTION_BLOCKING:
5407 return PQ_SETNONBLOCKING(pgsql, value);
5408 default:
5409 return FAILURE;
5410 }
5411 }
5412 /* }}} */
5413
5414 static int php_pgsql_fd_cast(php_stream *stream, int cast_as, void **ret) /* {{{ */
5415 {
5416 PGconn *pgsql = (PGconn *) stream->abstract;
5417
5418 switch (cast_as) {
5419 case PHP_STREAM_AS_FD_FOR_SELECT:
5420 case PHP_STREAM_AS_FD:
5421 case PHP_STREAM_AS_SOCKETD: {
5422 int fd_number = PQsocket(pgsql);
5423 if (fd_number == -1) {
5424 return FAILURE;
5425 }
5426
5427 if (ret) {
5428 *(php_socket_t *)ret = fd_number;
5429 }
5430 }
5431 return SUCCESS;
5432 default:
5433 return FAILURE;
5434 }
5435 }
5436 /* }}} */
5437
5438 /* {{{ proto resource pg_socket(resource connection)
5439 Get a read-only handle to the socket underlying the pgsql connection */
5440 PHP_FUNCTION(pg_socket)
5441 {
5442 zval *pgsql_link;
5443 php_stream *stream;
5444 PGconn *pgsql;
5445
5446 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_link) == FAILURE) {
5447 return;
5448 }
5449
5450 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5451 RETURN_FALSE;
5452 }
5453
5454 stream = php_stream_alloc(&php_stream_pgsql_fd_ops, pgsql, NULL, "r");
5455
5456 if (stream) {
5457 php_stream_to_zval(stream, return_value);
5458 return;
5459 }
5460
5461 RETURN_FALSE;
5462 }
5463 /* }}} */
5464
5465 /* {{{ proto bool pg_consume_input(resource connection)
5466 Reads input on the connection */
5467 PHP_FUNCTION(pg_consume_input)
5468 {
5469 zval *pgsql_link;
5470 PGconn *pgsql;
5471
5472 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_link) == FAILURE) {
5473 return;
5474 }
5475
5476 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5477 RETURN_FALSE;
5478 }
5479
5480 RETURN_BOOL(PQconsumeInput(pgsql));
5481 }
5482 /* }}} */
5483
5484 /* {{{ proto mixed pg_flush(resource connection)
5485 Flush outbound query data on the connection */
5486 PHP_FUNCTION(pg_flush)
5487 {
5488 zval *pgsql_link;
5489 PGconn *pgsql;
5490 int ret;
5491 int is_non_blocking;
5492
5493 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_link) == FAILURE) {
5494 return;
5495 }
5496
5497 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5498 RETURN_FALSE;
5499 }
5500
5501 is_non_blocking = PQisnonblocking(pgsql);
5502
5503 if (is_non_blocking == 0 && PQ_SETNONBLOCKING(pgsql, 1) == -1) {
5504 php_error_docref(NULL, E_NOTICE, "Cannot set connection to nonblocking mode");
5505 RETURN_FALSE;
5506 }
5507
5508 ret = PQflush(pgsql);
5509
5510 if (is_non_blocking == 0 && PQ_SETNONBLOCKING(pgsql, 0) == -1) {
5511 php_error_docref(NULL, E_NOTICE, "Failed resetting connection to blocking mode");
5512 }
5513
5514 switch (ret) {
5515 case 0: RETURN_TRUE; break;
5516 case 1: RETURN_LONG(0); break;
5517 default: RETURN_FALSE;
5518 }
5519 }
5520 /* }}} */
5521
5522 /* {{{ php_pgsql_meta_data
5523 * TODO: Add meta_data cache for better performance
5524 */
5525 PHP_PGSQL_API int php_pgsql_meta_data(PGconn *pg_link, const char *table_name, zval *meta, zend_bool extended)
5526 {
5527 PGresult *pg_result;
5528 char *src, *tmp_name, *tmp_name2 = NULL;
5529 char *escaped;
5530 smart_str querystr = {0};
5531 size_t new_len;
5532 int i, num_rows;
5533 zval elem;
5534
5535 if (!*table_name) {
5536 php_error_docref(NULL, E_WARNING, "The table name must be specified");
5537 return FAILURE;
5538 }
5539
5540 src = estrdup(table_name);
5541 tmp_name = php_strtok_r(src, ".", &tmp_name2);
5542 if (!tmp_name) {
5543 efree(src);
5544 php_error_docref(NULL, E_WARNING, "The table name must be specified");
5545 return FAILURE;
5546 }
5547 if (!tmp_name2 || !*tmp_name2) {
5548 /* Default schema */
5549 tmp_name2 = tmp_name;
5550 tmp_name = "public";
5551 }
5552
5553 if (extended) {
5554 smart_str_appends(&querystr,
5555 "SELECT a.attname, a.attnum, t.typname, a.attlen, a.attnotNULL, a.atthasdef, a.attndims, t.typtype, "
5556 "d.description "
5557 "FROM pg_class as c "
5558 " JOIN pg_attribute a ON (a.attrelid = c.oid) "
5559 " JOIN pg_type t ON (a.atttypid = t.oid) "
5560 " JOIN pg_namespace n ON (c.relnamespace = n.oid) "
5561 " LEFT JOIN pg_description d ON (d.objoid=a.attrelid AND d.objsubid=a.attnum AND c.oid=d.objoid) "
5562 "WHERE a.attnum > 0 AND c.relname = '");
5563 } else {
5564 smart_str_appends(&querystr,
5565 "SELECT a.attname, a.attnum, t.typname, a.attlen, a.attnotnull, a.atthasdef, a.attndims, t.typtype "
5566 "FROM pg_class as c "
5567 " JOIN pg_attribute a ON (a.attrelid = c.oid) "
5568 " JOIN pg_type t ON (a.atttypid = t.oid) "
5569 " JOIN pg_namespace n ON (c.relnamespace = n.oid) "
5570 "WHERE a.attnum > 0 AND c.relname = '");
5571 }
5572 escaped = (char *)safe_emalloc(strlen(tmp_name2), 2, 1);
5573 new_len = PQescapeStringConn(pg_link, escaped, tmp_name2, strlen(tmp_name2), NULL);
5574 if (new_len) {
5575 smart_str_appendl(&querystr, escaped, new_len);
5576 }
5577 efree(escaped);
5578
5579 smart_str_appends(&querystr, "' AND n.nspname = '");
5580 escaped = (char *)safe_emalloc(strlen(tmp_name), 2, 1);
5581 new_len = PQescapeStringConn(pg_link, escaped, tmp_name, strlen(tmp_name), NULL);
5582 if (new_len) {
5583 smart_str_appendl(&querystr, escaped, new_len);
5584 }
5585 efree(escaped);
5586
5587 smart_str_appends(&querystr, "' ORDER BY a.attnum;");
5588 smart_str_0(&querystr);
5589 efree(src);
5590
5591 pg_result = PQexec(pg_link, ZSTR_VAL(querystr.s));
5592 if (PQresultStatus(pg_result) != PGRES_TUPLES_OK || (num_rows = PQntuples(pg_result)) == 0) {
5593 php_error_docref(NULL, E_WARNING, "Table '%s' doesn't exists", table_name);
5594 smart_str_free(&querystr);
5595 PQclear(pg_result);
5596 return FAILURE;
5597 }
5598 smart_str_free(&querystr);
5599
5600 for (i = 0; i < num_rows; i++) {
5601 char *name;
5602 array_init(&elem);
5603 /* pg_attribute.attnum */
5604 add_assoc_long_ex(&elem, "num", sizeof("num") - 1, atoi(PQgetvalue(pg_result, i, 1)));
5605 /* pg_type.typname */
5606 add_assoc_string_ex(&elem, "type", sizeof("type") - 1, PQgetvalue(pg_result, i, 2));
5607 /* pg_attribute.attlen */
5608 add_assoc_long_ex(&elem, "len", sizeof("len") - 1, atoi(PQgetvalue(pg_result,i,3)));
5609 /* pg_attribute.attnonull */
5610 add_assoc_bool_ex(&elem, "not null", sizeof("not null") - 1, !strcmp(PQgetvalue(pg_result, i, 4), "t"));
5611 /* pg_attribute.atthasdef */
5612 add_assoc_bool_ex(&elem, "has default", sizeof("has default") - 1, !strcmp(PQgetvalue(pg_result,i,5), "t"));
5613 /* pg_attribute.attndims */
5614 add_assoc_long_ex(&elem, "array dims", sizeof("array dims") - 1, atoi(PQgetvalue(pg_result, i, 6)));
5615 /* pg_type.typtype */
5616 add_assoc_bool_ex(&elem, "is enum", sizeof("is enum") - 1, !strcmp(PQgetvalue(pg_result, i, 7), "e"));
5617 if (extended) {
5618 /* pg_type.typtype */
5619 add_assoc_bool_ex(&elem, "is base", sizeof("is base") - 1, !strcmp(PQgetvalue(pg_result, i, 7), "b"));
5620 add_assoc_bool_ex(&elem, "is composite", sizeof("is composite") - 1, !strcmp(PQgetvalue(pg_result, i, 7), "c"));
5621 add_assoc_bool_ex(&elem, "is pesudo", sizeof("is pesudo") - 1, !strcmp(PQgetvalue(pg_result, i, 7), "p"));
5622 /* pg_description.description */
5623 add_assoc_string_ex(&elem, "description", sizeof("description") - 1, PQgetvalue(pg_result, i, 8));
5624 }
5625 /* pg_attribute.attname */
5626 name = PQgetvalue(pg_result,i,0);
5627 add_assoc_zval(meta, name, &elem);
5628 }
5629 PQclear(pg_result);
5630
5631 return SUCCESS;
5632 }
5633
5634 /* }}} */
5635
5636 /* {{{ proto array pg_meta_data(resource db, string table [, bool extended])
5637 Get meta_data */
5638 PHP_FUNCTION(pg_meta_data)
5639 {
5640 zval *pgsql_link;
5641 char *table_name;
5642 size_t table_name_len;
5643 zend_bool extended=0;
5644 PGconn *pgsql;
5645
5646 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|b",
5647 &pgsql_link, &table_name, &table_name_len, &extended) == FAILURE) {
5648 return;
5649 }
5650
5651 if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
5652 RETURN_FALSE;
5653 }
5654
5655 array_init(return_value);
5656 if (php_pgsql_meta_data(pgsql, table_name, return_value, extended) == FAILURE) {
5657 zend_array_destroy(Z_ARR_P(return_value)); /* destroy array */
5658 RETURN_FALSE;
5659 }
5660 }
5661 /* }}} */
5662
5663 /* {{{ php_pgsql_get_data_type
5664 */
5665 static php_pgsql_data_type php_pgsql_get_data_type(const char *type_name, size_t len)
5666 {
5667 /* This is stupid way to do. I'll fix it when I decied how to support
5668 user defined types. (Yasuo) */
5669
5670 /* boolean */
5671 if (!strcmp(type_name, "bool")|| !strcmp(type_name, "boolean"))
5672 return PG_BOOL;
5673 /* object id */
5674 if (!strcmp(type_name, "oid"))
5675 return PG_OID;
5676 /* integer */
5677 if (!strcmp(type_name, "int2") || !strcmp(type_name, "smallint"))
5678 return PG_INT2;
5679 if (!strcmp(type_name, "int4") || !strcmp(type_name, "integer"))
5680 return PG_INT4;
5681 if (!strcmp(type_name, "int8") || !strcmp(type_name, "bigint"))
5682 return PG_INT8;
5683 /* real and other */
5684 if (!strcmp(type_name, "float4") || !strcmp(type_name, "real"))
5685 return PG_FLOAT4;
5686 if (!strcmp(type_name, "float8") || !strcmp(type_name, "double precision"))
5687 return PG_FLOAT8;
5688 if (!strcmp(type_name, "numeric"))
5689 return PG_NUMERIC;
5690 if (!strcmp(type_name, "money"))
5691 return PG_MONEY;
5692 /* character */
5693 if (!strcmp(type_name, "text"))
5694 return PG_TEXT;
5695 if (!strcmp(type_name, "bpchar") || !strcmp(type_name, "character"))
5696 return PG_CHAR;
5697 if (!strcmp(type_name, "varchar") || !strcmp(type_name, "character varying"))
5698 return PG_VARCHAR;
5699 /* time and interval */
5700 if (!strcmp(type_name, "abstime"))
5701 return PG_UNIX_TIME;
5702 if (!strcmp(type_name, "reltime"))
5703 return PG_UNIX_TIME_INTERVAL;
5704 if (!strcmp(type_name, "tinterval"))
5705 return PG_UNIX_TIME_INTERVAL;
5706 if (!strcmp(type_name, "date"))
5707 return PG_DATE;
5708 if (!strcmp(type_name, "time"))
5709 return PG_TIME;
5710 if (!strcmp(type_name, "time with time zone") || !strcmp(type_name, "timetz"))
5711 return PG_TIME_WITH_TIMEZONE;
5712 if (!strcmp(type_name, "timestamp without time zone") || !strcmp(type_name, "timestamp"))
5713 return PG_TIMESTAMP;
5714 if (!strcmp(type_name, "timestamp with time zone") || !strcmp(type_name, "timestamptz"))
5715 return PG_TIMESTAMP_WITH_TIMEZONE;
5716 if (!strcmp(type_name, "interval"))
5717 return PG_INTERVAL;
5718 /* binary */
5719 if (!strcmp(type_name, "bytea"))
5720 return PG_BYTEA;
5721 /* network */
5722 if (!strcmp(type_name, "cidr"))
5723 return PG_CIDR;
5724 if (!strcmp(type_name, "inet"))
5725 return PG_INET;
5726 if (!strcmp(type_name, "macaddr"))
5727 return PG_MACADDR;
5728 /* bit */
5729 if (!strcmp(type_name, "bit"))
5730 return PG_BIT;
5731 if (!strcmp(type_name, "bit varying"))
5732 return PG_VARBIT;
5733 /* geometric */
5734 if (!strcmp(type_name, "line"))
5735 return PG_LINE;
5736 if (!strcmp(type_name, "lseg"))
5737 return PG_LSEG;
5738 if (!strcmp(type_name, "box"))
5739 return PG_BOX;
5740 if (!strcmp(type_name, "path"))
5741 return PG_PATH;
5742 if (!strcmp(type_name, "point"))
5743 return PG_POINT;
5744 if (!strcmp(type_name, "polygon"))
5745 return PG_POLYGON;
5746 if (!strcmp(type_name, "circle"))
5747 return PG_CIRCLE;
5748
5749 return PG_UNKNOWN;
5750 }
5751 /* }}} */
5752
5753 /* {{{ php_pgsql_convert_match
5754 * test field value with regular expression specified.
5755 */
5756 static int php_pgsql_convert_match(const char *str, size_t str_len, const char *regex , size_t regex_len, int icase)
5757 {
5758 pcre2_code *re;
5759 PCRE2_SIZE err_offset;
5760 int res, errnumber;
5761 uint32_t options = PCRE2_NO_AUTO_CAPTURE;
5762 size_t i;
5763 pcre2_match_data *match_data;
5764
5765 /* Check invalid chars for POSIX regex */
5766 for (i = 0; i < str_len; i++) {
5767 if (str[i] == '\n' ||
5768 str[i] == '\r' ||
5769 str[i] == '\0' ) {
5770 return FAILURE;
5771 }
5772 }
5773
5774 if (icase) {
5775 options |= PCRE2_CASELESS;
5776 }
5777
5778 re = pcre2_compile((PCRE2_SPTR)regex, regex_len, options, &errnumber, &err_offset, php_pcre_cctx());
5779 if (NULL == re) {
5780 PCRE2_UCHAR err_msg[128];
5781 pcre2_get_error_message(errnumber, err_msg, sizeof(err_msg));
5782 php_error_docref(NULL, E_WARNING, "Cannot compile regex: '%s'", err_msg);
5783 return FAILURE;
5784 }
5785
5786 match_data = php_pcre_create_match_data(0, re);
5787 if (NULL == match_data) {
5788 pcre2_code_free(re);
5789 php_error_docref(NULL, E_WARNING, "Cannot allocate match data");
5790 return FAILURE;
5791 }
5792 res = pcre2_match(re, (PCRE2_SPTR)str, str_len, 0, 0, match_data, php_pcre_mctx());
5793 php_pcre_free_match_data(match_data);
5794 pcre2_code_free(re);
5795
5796 if (res == PCRE2_ERROR_NOMATCH) {
5797 return FAILURE;
5798 } else if (res < 0) {
5799 php_error_docref(NULL, E_WARNING, "Cannot exec regex");
5800 return FAILURE;
5801 }
5802 return SUCCESS;
5803 }
5804
5805 /* }}} */
5806
5807 /* {{{ php_pgsql_add_quote
5808 * add quotes around string.
5809 */
5810 static int php_pgsql_add_quotes(zval *src, zend_bool should_free)
5811 {
5812 smart_str str = {0};
5813
5814 assert(Z_TYPE_P(src) == IS_STRING);
5815 assert(should_free == 1 || should_free == 0);
5816
5817 smart_str_appendc(&str, 'E');
5818 smart_str_appendc(&str, '\'');
5819 smart_str_appendl(&str, Z_STRVAL_P(src), Z_STRLEN_P(src));
5820 smart_str_appendc(&str, '\'');
5821 smart_str_0(&str);
5822
5823 if (should_free) {
5824 zval_ptr_dtor(src);
5825 }
5826 ZVAL_NEW_STR(src, str.s);
5827
5828 return SUCCESS;
5829 }
5830 /* }}} */
5831
5832 #define PGSQL_CONV_CHECK_IGNORE() \
5833 if (!err && Z_TYPE(new_val) == IS_STRING && !strcmp(Z_STRVAL(new_val), "NULL")) { \
5834 /* if new_value is string "NULL" and field has default value, remove element to use default value */ \
5835 if (!(opt & PGSQL_CONV_IGNORE_DEFAULT) && Z_TYPE_P(has_default) == IS_TRUE) { \
5836 zval_ptr_dtor(&new_val); \
5837 skip_field = 1; \
5838 } \
5839 /* raise error if it's not null and cannot be ignored */ \
5840 else if (!(opt & PGSQL_CONV_IGNORE_NOT_NULL) && Z_TYPE_P(not_null) == IS_TRUE) { \
5841 php_error_docref(NULL, E_NOTICE, "Detected NULL for 'NOT NULL' field '%s'", ZSTR_VAL(field)); \
5842 err = 1; \
5843 } \
5844 }
5845
5846 /* {{{ php_pgsql_convert
5847 * check and convert array values (fieldname=>value pair) for sql
5848 */
5849 PHP_PGSQL_API int php_pgsql_convert(PGconn *pg_link, const char *table_name, const zval *values, zval *result, zend_ulong opt)
5850 {
5851 zend_string *field = NULL;
5852 zval meta, *def, *type, *not_null, *has_default, *is_enum, *val, new_val;
5853 int err = 0, skip_field;
5854 php_pgsql_data_type data_type;
5855
5856 assert(pg_link != NULL);
5857 assert(Z_TYPE_P(values) == IS_ARRAY);
5858 assert(Z_TYPE_P(result) == IS_ARRAY);
5859 assert(!(opt & ~PGSQL_CONV_OPTS));
5860
5861 if (!table_name) {
5862 return FAILURE;
5863 }
5864
5865 array_init(&meta);
5866 /* table_name is escaped by php_pgsql_meta_data */
5867 if (php_pgsql_meta_data(pg_link, table_name, &meta, 0) == FAILURE) {
5868 zval_ptr_dtor(&meta);
5869 return FAILURE;
5870 }
5871
5872 ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(values), field, val) {
5873 skip_field = 0;
5874 ZVAL_NULL(&new_val);
5875
5876 if (!err && field == NULL) {
5877 php_error_docref(NULL, E_WARNING, "Accepts only string key for values");
5878 err = 1;
5879 }
5880
5881 if (!err && (def = zend_hash_find(Z_ARRVAL(meta), field)) == NULL) {
5882 php_error_docref(NULL, E_NOTICE, "Invalid field name (%s) in values", ZSTR_VAL(field));
5883 err = 1;
5884 }
5885 if (!err && (type = zend_hash_str_find(Z_ARRVAL_P(def), "type", sizeof("type") - 1)) == NULL) {
5886 php_error_docref(NULL, E_NOTICE, "Detected broken meta data. Missing 'type'");
5887 err = 1;
5888 }
5889 if (!err && (not_null = zend_hash_str_find(Z_ARRVAL_P(def), "not null", sizeof("not null") - 1)) == NULL) {
5890 php_error_docref(NULL, E_NOTICE, "Detected broken meta data. Missing 'not null'");
5891 err = 1;
5892 }
5893 if (!err && (has_default = zend_hash_str_find(Z_ARRVAL_P(def), "has default", sizeof("has default") - 1)) == NULL) {
5894 php_error_docref(NULL, E_NOTICE, "Detected broken meta data. Missing 'has default'");
5895 err = 1;
5896 }
5897 if (!err && (is_enum = zend_hash_str_find(Z_ARRVAL_P(def), "is enum", sizeof("is enum") - 1)) == NULL) {
5898 php_error_docref(NULL, E_NOTICE, "Detected broken meta data. Missing 'is enum'");
5899 err = 1;
5900 }
5901 if (!err && (Z_TYPE_P(val) == IS_ARRAY || Z_TYPE_P(val) == IS_OBJECT)) {
5902 php_error_docref(NULL, E_NOTICE, "Expects scalar values as field values");
5903 err = 1;
5904 }
5905 if (err) {
5906 break; /* break out for() */
5907 }
5908
5909 convert_to_boolean(is_enum);
5910 if (Z_TYPE_P(is_enum) == IS_TRUE) {
5911 /* enums need to be treated like strings */
5912 data_type = PG_TEXT;
5913 } else {
5914 data_type = php_pgsql_get_data_type(Z_STRVAL_P(type), Z_STRLEN_P(type));
5915 }
5916
5917 switch(data_type)
5918 {
5919 case PG_BOOL:
5920 switch (Z_TYPE_P(val)) {
5921 case IS_STRING:
5922 if (Z_STRLEN_P(val) == 0) {
5923 ZVAL_STRING(&new_val, "NULL");
5924 }
5925 else {
5926 if (!strcmp(Z_STRVAL_P(val), "t") || !strcmp(Z_STRVAL_P(val), "T") ||
5927 !strcmp(Z_STRVAL_P(val), "y") || !strcmp(Z_STRVAL_P(val), "Y") ||
5928 !strcmp(Z_STRVAL_P(val), "true") || !strcmp(Z_STRVAL_P(val), "True") ||
5929 !strcmp(Z_STRVAL_P(val), "yes") || !strcmp(Z_STRVAL_P(val), "Yes") ||
5930 !strcmp(Z_STRVAL_P(val), "1")) {
5931 ZVAL_STRINGL(&new_val, "'t'", sizeof("'t'")-1);
5932 }
5933 else if (!strcmp(Z_STRVAL_P(val), "f") || !strcmp(Z_STRVAL_P(val), "F") ||
5934 !strcmp(Z_STRVAL_P(val), "n") || !strcmp(Z_STRVAL_P(val), "N") ||
5935 !strcmp(Z_STRVAL_P(val), "false") || !strcmp(Z_STRVAL_P(val), "False") ||
5936 !strcmp(Z_STRVAL_P(val), "no") || !strcmp(Z_STRVAL_P(val), "No") ||
5937 !strcmp(Z_STRVAL_P(val), "0")) {
5938 ZVAL_STRINGL(&new_val, "'f'", sizeof("'f'")-1);
5939 }
5940 else {
5941 php_error_docref(NULL, E_NOTICE, "Detected invalid value (%s) for PostgreSQL %s field (%s)", Z_STRVAL_P(val), Z_STRVAL_P(type), ZSTR_VAL(field));
5942 err = 1;
5943 }
5944 }
5945 break;
5946
5947 case IS_LONG:
5948 if (Z_LVAL_P(val)) {
5949 ZVAL_STRINGL(&new_val, "'t'", sizeof("'t'")-1);
5950 }
5951 else {
5952 ZVAL_STRINGL(&new_val, "'f'", sizeof("'f'")-1);
5953 }
5954 break;
5955
5956 case IS_TRUE:
5957 ZVAL_STRINGL(&new_val, "'t'", sizeof("'t'")-1);
5958 break;
5959
5960 case IS_FALSE:
5961 ZVAL_STRINGL(&new_val, "'f'", sizeof("'f'")-1);
5962 break;
5963
5964 case IS_NULL:
5965 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
5966 break;
5967
5968 default:
5969 err = 1;
5970 }
5971 PGSQL_CONV_CHECK_IGNORE();
5972 if (err) {
5973 php_error_docref(NULL, E_NOTICE, "Expects string, null, long or boolelan value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
5974 }
5975 break;
5976
5977 case PG_OID:
5978 case PG_INT2:
5979 case PG_INT4:
5980 case PG_INT8:
5981 switch (Z_TYPE_P(val)) {
5982 case IS_STRING:
5983 if (Z_STRLEN_P(val) == 0) {
5984 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
5985 }
5986 else {
5987 /* FIXME: better regex must be used */
5988 #define REGEX0 "^([+-]{0,1}[0-9]+)$"
5989 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 0) == FAILURE) {
5990 err = 1;
5991 }
5992 else {
5993 ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
5994 }
5995 #undef REGEX0
5996 }
5997 break;
5998
5999 case IS_DOUBLE:
6000 ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
6001 convert_to_long_ex(&new_val);
6002 break;
6003
6004 case IS_LONG:
6005 ZVAL_LONG(&new_val, Z_LVAL_P(val));
6006 break;
6007
6008 case IS_NULL:
6009 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6010 break;
6011
6012 default:
6013 err = 1;
6014 }
6015 PGSQL_CONV_CHECK_IGNORE();
6016 if (err) {
6017 php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for pgsql '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6018 }
6019 break;
6020
6021 case PG_NUMERIC:
6022 case PG_MONEY:
6023 case PG_FLOAT4:
6024 case PG_FLOAT8:
6025 switch (Z_TYPE_P(val)) {
6026 case IS_STRING:
6027 if (Z_STRLEN_P(val) == 0) {
6028 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6029 }
6030 else {
6031 #define REGEX0 "^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$"
6032 #define REGEX1 "^[+-]{0,1}(inf)(inity){0,1}$"
6033 /* better regex? */
6034 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 0) == FAILURE) {
6035 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX1, sizeof(REGEX1)-1, 1) == FAILURE) {
6036 err = 1;
6037 } else {
6038 ZVAL_STRING(&new_val, Z_STRVAL_P(val));
6039 php_pgsql_add_quotes(&new_val, 1);
6040 }
6041 }
6042 else {
6043 ZVAL_STRING(&new_val, Z_STRVAL_P(val));
6044 }
6045 #undef REGEX0
6046 #undef REGEX1
6047 }
6048 break;
6049
6050 case IS_LONG:
6051 ZVAL_LONG(&new_val, Z_LVAL_P(val));
6052 break;
6053
6054 case IS_DOUBLE:
6055 ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
6056 break;
6057
6058 case IS_NULL:
6059 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6060 break;
6061
6062 default:
6063 err = 1;
6064 }
6065 PGSQL_CONV_CHECK_IGNORE();
6066 if (err) {
6067 php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6068 }
6069 break;
6070
6071 /* Exotic types are handled as string also.
6072 Please feel free to add more valitions. Invalid query fails
6073 at execution anyway. */
6074 case PG_TEXT:
6075 case PG_CHAR:
6076 case PG_VARCHAR:
6077 /* bit */
6078 case PG_BIT:
6079 case PG_VARBIT:
6080 /* geometric */
6081 case PG_LINE:
6082 case PG_LSEG:
6083 case PG_POINT:
6084 case PG_BOX:
6085 case PG_PATH:
6086 case PG_POLYGON:
6087 case PG_CIRCLE:
6088 /* unknown. JSON, Array etc */
6089 case PG_UNKNOWN:
6090 switch (Z_TYPE_P(val)) {
6091 case IS_STRING:
6092 if (Z_STRLEN_P(val) == 0) {
6093 if (opt & PGSQL_CONV_FORCE_NULL) {
6094 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6095 } else {
6096 ZVAL_STRINGL(&new_val, "''", sizeof("''")-1);
6097 }
6098 }
6099 else {
6100 zend_string *str;
6101 /* PostgreSQL ignores \0 */
6102 str = zend_string_alloc(Z_STRLEN_P(val) * 2, 0);
6103 /* better to use PGSQLescapeLiteral since PGescapeStringConn does not handle special \ */
6104 ZSTR_LEN(str) = PQescapeStringConn(pg_link, ZSTR_VAL(str), Z_STRVAL_P(val), Z_STRLEN_P(val), NULL);
6105 str = zend_string_truncate(str, ZSTR_LEN(str), 0);
6106 ZVAL_NEW_STR(&new_val, str);
6107 php_pgsql_add_quotes(&new_val, 1);
6108 }
6109 break;
6110
6111 case IS_LONG:
6112 ZVAL_STR(&new_val, zend_long_to_str(Z_LVAL_P(val)));
6113 break;
6114
6115 case IS_DOUBLE:
6116 ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
6117 convert_to_string_ex(&new_val);
6118 break;
6119
6120 case IS_NULL:
6121 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6122 break;
6123
6124 default:
6125 err = 1;
6126 }
6127 PGSQL_CONV_CHECK_IGNORE();
6128 if (err) {
6129 php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6130 }
6131 break;
6132
6133 case PG_UNIX_TIME:
6134 case PG_UNIX_TIME_INTERVAL:
6135 /* these are the actallay a integer */
6136 switch (Z_TYPE_P(val)) {
6137 case IS_STRING:
6138 if (Z_STRLEN_P(val) == 0) {
6139 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6140 }
6141 else {
6142 /* better regex? */
6143 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^[0-9]+$", sizeof("^[0-9]+$")-1, 0) == FAILURE) {
6144 err = 1;
6145 }
6146 else {
6147 ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
6148 convert_to_long_ex(&new_val);
6149 }
6150 }
6151 break;
6152
6153 case IS_DOUBLE:
6154 ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
6155 convert_to_long_ex(&new_val);
6156 break;
6157
6158 case IS_LONG:
6159 ZVAL_LONG(&new_val, Z_LVAL_P(val));
6160 break;
6161
6162 case IS_NULL:
6163 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6164 break;
6165
6166 default:
6167 err = 1;
6168 }
6169 PGSQL_CONV_CHECK_IGNORE();
6170 if (err) {
6171 php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6172 }
6173 break;
6174
6175 case PG_CIDR:
6176 case PG_INET:
6177 switch (Z_TYPE_P(val)) {
6178 case IS_STRING:
6179 if (Z_STRLEN_P(val) == 0) {
6180 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6181 }
6182 else {
6183 #define REGEX0 "^((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])(\\/[0-9]{1,3})?$"
6184 #define REGEX1 "^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))(\\/[0-9]{1,3})?$"
6185 /* The inet type holds an IPv4 or IPv6 host address, and optionally its subnet, all in one field. See more in the doc.
6186 The regex might still be not perfect, but catches the most of IP variants. We might decide to remove the regex
6187 at all though and let the server side to handle it.*/
6188 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 0) == FAILURE
6189 && php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX1, sizeof(REGEX1)-1, 0) == FAILURE) {
6190 err = 1;
6191 }
6192 else {
6193 ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
6194 php_pgsql_add_quotes(&new_val, 1);
6195 }
6196 #undef REGEX0
6197 #undef REGEX1
6198 }
6199 break;
6200
6201 case IS_NULL:
6202 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6203 break;
6204
6205 default:
6206 err = 1;
6207 }
6208 PGSQL_CONV_CHECK_IGNORE();
6209 if (err) {
6210 php_error_docref(NULL, E_NOTICE, "Expects NULL or IPv4 or IPv6 address string for '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6211 }
6212 break;
6213
6214 case PG_TIME_WITH_TIMEZONE:
6215 case PG_TIMESTAMP:
6216 case PG_TIMESTAMP_WITH_TIMEZONE:
6217 switch(Z_TYPE_P(val)) {
6218 case IS_STRING:
6219 if (Z_STRLEN_P(val) == 0) {
6220 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6221 } else if (!strcasecmp(Z_STRVAL_P(val), "now()")) {
6222 ZVAL_STRINGL(&new_val, "NOW()", sizeof("NOW()")-1);
6223 } else {
6224 #define REGEX0 "^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})(([ \\t]+|T)(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}(\\.[0-9]+){0,1}([ \\t]*([+-][0-9]{1,4}(:[0-9]{1,2}){0,1}|[-a-zA-Z_/+]{1,50})){0,1})){0,1}$"
6225 /* better regex? */
6226 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 1) == FAILURE) {
6227 err = 1;
6228 } else {
6229 ZVAL_STRING(&new_val, Z_STRVAL_P(val));
6230 php_pgsql_add_quotes(&new_val, 1);
6231 }
6232 #undef REGEX0
6233 }
6234 break;
6235
6236 case IS_NULL:
6237 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6238 break;
6239
6240 default:
6241 err = 1;
6242 }
6243 PGSQL_CONV_CHECK_IGNORE();
6244 if (err) {
6245 php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6246 }
6247 break;
6248
6249 case PG_DATE:
6250 switch(Z_TYPE_P(val)) {
6251 case IS_STRING:
6252 if (Z_STRLEN_P(val) == 0) {
6253 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6254 }
6255 else {
6256 #define REGEX0 "^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})$"
6257 /* FIXME: better regex must be used */
6258 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 1) == FAILURE) {
6259 err = 1;
6260 }
6261 else {
6262 ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
6263 php_pgsql_add_quotes(&new_val, 1);
6264 }
6265 #undef REGEX0
6266 }
6267 break;
6268
6269 case IS_NULL:
6270 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6271 break;
6272
6273 default:
6274 err = 1;
6275 }
6276 PGSQL_CONV_CHECK_IGNORE();
6277 if (err) {
6278 php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6279 }
6280 break;
6281
6282 case PG_TIME:
6283 switch(Z_TYPE_P(val)) {
6284 case IS_STRING:
6285 if (Z_STRLEN_P(val) == 0) {
6286 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6287 }
6288 else {
6289 #define REGEX0 "^(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}){0,1}$"
6290 /* FIXME: better regex must be used */
6291 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 1) == FAILURE) {
6292 err = 1;
6293 }
6294 else {
6295 ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
6296 php_pgsql_add_quotes(&new_val, 1);
6297 }
6298 #undef REGEX0
6299 }
6300 break;
6301
6302 case IS_NULL:
6303 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6304 break;
6305
6306 default:
6307 err = 1;
6308 }
6309 PGSQL_CONV_CHECK_IGNORE();
6310 if (err) {
6311 php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6312 }
6313 break;
6314
6315 case PG_INTERVAL:
6316 switch(Z_TYPE_P(val)) {
6317 case IS_STRING:
6318 if (Z_STRLEN_P(val) == 0) {
6319 ZVAL_STRING(&new_val, "NULL");
6320 }
6321 else {
6322
6323 /* From the Postgres docs:
6324
6325 interval values can be written with the following syntax:
6326 [@] quantity unit [quantity unit...] [direction]
6327
6328 Where: quantity is a number (possibly signed); unit is second, minute, hour,
6329 day, week, month, year, decade, century, millennium, or abbreviations or
6330 plurals of these units [note not *all* abbreviations] ; direction can be
6331 ago or empty. The at sign (@) is optional noise.
6332
6333 ...
6334
6335 Quantities of days, hours, minutes, and seconds can be specified without explicit
6336 unit markings. For example, '1 12:59:10' is read the same as '1 day 12 hours 59 min 10
6337 sec'.
6338 */
6339 #define REGEX0 \
6340 "^(@?[ \\t]+)?(" \
6341 /* Textual time units and their abbreviations: */ \
6342 "(([-+]?[ \\t]+)?" \
6343 "[0-9]+(\\.[0-9]*)?[ \\t]*" \
6344 "(millenniums|millennia|millennium|mil|mils|" \
6345 "centuries|century|cent|c|" \
6346 "decades|decade|dec|decs|" \
6347 "years|year|y|" \
6348 "months|month|mon|" \
6349 "weeks|week|w|" \
6350 "days|day|d|" \
6351 "hours|hour|hr|hrs|h|" \
6352 "minutes|minute|mins|min|m|" \
6353 "seconds|second|secs|sec|s))+|" \
6354 /* Textual time units plus (dd)* hh[:mm[:ss]] */ \
6355 "((([-+]?[ \\t]+)?" \
6356 "[0-9]+(\\.[0-9]*)?[ \\t]*" \
6357 "(millenniums|millennia|millennium|mil|mils|" \
6358 "centuries|century|cent|c|" \
6359 "decades|decade|dec|decs|" \
6360 "years|year|y|" \
6361 "months|month|mon|" \
6362 "weeks|week|w|" \
6363 "days|day|d))+" \
6364 "([-+]?[ \\t]+" \
6365 "([0-9]+[ \\t]+)+" /* dd */ \
6366 "(([0-9]{1,2}:){0,2}[0-9]{0,2})" /* hh:[mm:[ss]] */ \
6367 ")?))" \
6368 "([ \\t]+ago)?$"
6369
6370 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 1) == FAILURE) {
6371 err = 1;
6372 }
6373 else {
6374 ZVAL_STRING(&new_val, Z_STRVAL_P(val));
6375 php_pgsql_add_quotes(&new_val, 1);
6376 }
6377 #undef REGEX0
6378 }
6379 break;
6380
6381 case IS_NULL:
6382 ZVAL_STRING(&new_val, "NULL");
6383 break;
6384
6385 default:
6386 err = 1;
6387 }
6388 PGSQL_CONV_CHECK_IGNORE();
6389 if (err) {
6390 php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6391 }
6392 break;
6393 #ifdef HAVE_PQESCAPE
6394 case PG_BYTEA:
6395 switch (Z_TYPE_P(val)) {
6396 case IS_STRING:
6397 if (Z_STRLEN_P(val) == 0) {
6398 ZVAL_STRING(&new_val, "NULL");
6399 }
6400 else {
6401 unsigned char *tmp;
6402 size_t to_len;
6403 smart_str s = {0};
6404 #ifdef HAVE_PQESCAPE_BYTEA_CONN
6405 tmp = PQescapeByteaConn(pg_link, (unsigned char *)Z_STRVAL_P(val), Z_STRLEN_P(val), &to_len);
6406 #else
6407 tmp = PQescapeBytea(Z_STRVAL_P(val), (unsigned char *)Z_STRLEN_P(val), &to_len);
6408 #endif
6409 ZVAL_STRINGL(&new_val, (char *)tmp, to_len - 1); /* PQescapeBytea's to_len includes additional '\0' */
6410 PQfreemem(tmp);
6411 php_pgsql_add_quotes(&new_val, 1);
6412 smart_str_appendl(&s, Z_STRVAL(new_val), Z_STRLEN(new_val));
6413 smart_str_0(&s);
6414 zval_ptr_dtor(&new_val);
6415 ZVAL_NEW_STR(&new_val, s.s);
6416 }
6417 break;
6418
6419 case IS_LONG:
6420 ZVAL_STR(&new_val, zend_long_to_str(Z_LVAL_P(val)));
6421 break;
6422
6423 case IS_DOUBLE:
6424 ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
6425 convert_to_string_ex(&new_val);
6426 break;
6427
6428 case IS_NULL:
6429 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6430 break;
6431
6432 default:
6433 err = 1;
6434 }
6435 PGSQL_CONV_CHECK_IGNORE();
6436 if (err) {
6437 php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6438 }
6439 break;
6440
6441 #endif
6442 case PG_MACADDR:
6443 switch(Z_TYPE_P(val)) {
6444 case IS_STRING:
6445 if (Z_STRLEN_P(val) == 0) {
6446 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6447 }
6448 else {
6449 #define REGEX0 "^([0-9a-f]{2,2}:){5,5}[0-9a-f]{2,2}$"
6450 if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), REGEX0, sizeof(REGEX0)-1, 1) == FAILURE) {
6451 err = 1;
6452 }
6453 else {
6454 ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
6455 php_pgsql_add_quotes(&new_val, 1);
6456 }
6457 #undef REGEX0
6458 }
6459 break;
6460
6461 case IS_NULL:
6462 ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1);
6463 break;
6464
6465 default:
6466 err = 1;
6467 }
6468 PGSQL_CONV_CHECK_IGNORE();
6469 if (err) {
6470 php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
6471 }
6472 break;
6473
6474 default:
6475 /* should not happen */
6476 php_error_docref(NULL, E_NOTICE, "Unknown or system data type '%s' for '%s'. Report error", Z_STRVAL_P(type), ZSTR_VAL(field));
6477 err = 1;
6478 break;
6479 } /* switch */
6480
6481 if (err) {
6482 zval_ptr_dtor(&new_val);
6483 break; /* break out for() */
6484 }
6485 /* If field is NULL and HAS DEFAULT, should be skipped */
6486 if (!skip_field) {
6487 if (_php_pgsql_detect_identifier_escape(ZSTR_VAL(field), ZSTR_LEN(field)) == SUCCESS) {
6488 zend_hash_update(Z_ARRVAL_P(result), field, &new_val);
6489 } else {
6490 char *escaped = PGSQLescapeIdentifier(pg_link, ZSTR_VAL(field), ZSTR_LEN(field));
6491 add_assoc_zval(result, escaped, &new_val);
6492 PGSQLfree(escaped);
6493 }
6494 }
6495 } ZEND_HASH_FOREACH_END(); /* for */
6496
6497 zval_ptr_dtor(&meta);
6498
6499 if (err) {
6500 /* shouldn't destroy & free zval here */
6501 return FAILURE;
6502 }
6503 return SUCCESS;
6504 }
6505 /* }}} */
6506
6507 /* {{{ proto array pg_convert(resource db, string table, array values[, int options])
6508 Check and convert values for PostgreSQL SQL statement */
6509 PHP_FUNCTION(pg_convert)
6510 {
6511 zval *pgsql_link, *values;
6512 char *table_name;
6513 size_t table_name_len;
6514 zend_ulong option = 0;
6515 PGconn *pg_link;
6516
6517 if (zend_parse_parameters(ZEND_NUM_ARGS(),
6518 "rsa|l", &pgsql_link, &table_name, &table_name_len, &values, &option) == FAILURE) {
6519 return;
6520 }
6521 if (option & ~PGSQL_CONV_OPTS) {
6522 php_error_docref(NULL, E_WARNING, "Invalid option is specified");
6523 RETURN_FALSE;
6524 }
6525 if (!table_name_len) {
6526 php_error_docref(NULL, E_NOTICE, "Table name is invalid");
6527 RETURN_FALSE;
6528 }
6529
6530 if ((pg_link = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
6531 RETURN_FALSE;
6532 }
6533
6534 if (php_pgsql_flush_query(pg_link)) {
6535 php_error_docref(NULL, E_NOTICE, "Detected unhandled result(s) in connection");
6536 }
6537 array_init(return_value);
6538 if (php_pgsql_convert(pg_link, table_name, values, return_value, option) == FAILURE) {
6539 zend_array_destroy(Z_ARR_P(return_value));
6540 RETURN_FALSE;
6541 }
6542 }
6543 /* }}} */
6544
6545 static int do_exec(smart_str *querystr, ExecStatusType expect, PGconn *pg_link, zend_ulong opt) /* {{{ */
6546 {
6547 if (opt & PGSQL_DML_ASYNC) {
6548 if (PQsendQuery(pg_link, ZSTR_VAL(querystr->s))) {
6549 return 0;
6550 }
6551 }
6552 else {
6553 PGresult *pg_result;
6554
6555 pg_result = PQexec(pg_link, ZSTR_VAL(querystr->s));
6556 if (PQresultStatus(pg_result) == expect) {
6557 PQclear(pg_result);
6558 return 0;
6559 } else {
6560 php_error_docref(NULL, E_WARNING, "%s", PQresultErrorMessage(pg_result));
6561 PQclear(pg_result);
6562 }
6563 }
6564
6565 return -1;
6566 }
6567 /* }}} */
6568
6569 static inline void build_tablename(smart_str *querystr, PGconn *pg_link, const char *table) /* {{{ */
6570 {
6571 size_t table_len = strlen(table);
6572
6573 /* schema.table should be "schema"."table" */
6574 const char *dot = memchr(table, '.', table_len);
6575 size_t len = dot ? dot - table : table_len;
6576 if (_php_pgsql_detect_identifier_escape(table, len) == SUCCESS) {
6577 smart_str_appendl(querystr, table, len);
6578 } else {
6579 char *escaped = PGSQLescapeIdentifier(pg_link, table, len);
6580 smart_str_appends(querystr, escaped);
6581 PGSQLfree(escaped);
6582 }
6583 if (dot) {
6584 const char *after_dot = dot + 1;
6585 len = table_len - len - 1;
6586 /* "schema"."table" format */
6587 if (_php_pgsql_detect_identifier_escape(after_dot, len) == SUCCESS) {
6588 smart_str_appendc(querystr, '.');
6589 smart_str_appendl(querystr, after_dot, len);
6590 } else {
6591 char *escaped = PGSQLescapeIdentifier(pg_link, after_dot, len);
6592 smart_str_appendc(querystr, '.');
6593 smart_str_appends(querystr, escaped);
6594 PGSQLfree(escaped);
6595 }
6596 }
6597 }
6598 /* }}} */
6599
6600 /* {{{ php_pgsql_insert
6601 */
6602 PHP_PGSQL_API int php_pgsql_insert(PGconn *pg_link, const char *table, zval *var_array, zend_ulong opt, zend_string **sql)
6603 {
6604 zval *val, converted;
6605 char buf[256];
6606 char *tmp;
6607 smart_str querystr = {0};
6608 int ret = FAILURE;
6609 zend_string *fld;
6610
6611 assert(pg_link != NULL);
6612 assert(table != NULL);
6613 assert(Z_TYPE_P(var_array) == IS_ARRAY);
6614
6615 ZVAL_UNDEF(&converted);
6616 if (zend_hash_num_elements(Z_ARRVAL_P(var_array)) == 0) {
6617 smart_str_appends(&querystr, "INSERT INTO ");
6618 build_tablename(&querystr, pg_link, table);
6619 smart_str_appends(&querystr, " DEFAULT VALUES");
6620
6621 goto no_values;
6622 }
6623
6624 /* convert input array if needed */
6625 if (!(opt & (PGSQL_DML_NO_CONV|PGSQL_DML_ESCAPE))) {
6626 array_init(&converted);
6627 if (php_pgsql_convert(pg_link, table, var_array, &converted, (opt & PGSQL_CONV_OPTS)) == FAILURE) {
6628 goto cleanup;
6629 }
6630 var_array = &converted;
6631 }
6632
6633 smart_str_appends(&querystr, "INSERT INTO ");
6634 build_tablename(&querystr, pg_link, table);
6635 smart_str_appends(&querystr, " (");
6636
6637 ZEND_HASH_FOREACH_STR_KEY(Z_ARRVAL_P(var_array), fld) {
6638 if (fld == NULL) {
6639 php_error_docref(NULL, E_NOTICE, "Expects associative array for values to be inserted");
6640 goto cleanup;
6641 }
6642 if (opt & PGSQL_DML_ESCAPE) {
6643 tmp = PGSQLescapeIdentifier(pg_link, ZSTR_VAL(fld), ZSTR_LEN(fld) + 1);
6644 smart_str_appends(&querystr, tmp);
6645 PGSQLfree(tmp);
6646 } else {
6647 smart_str_appendl(&querystr, ZSTR_VAL(fld), ZSTR_LEN(fld));
6648 }
6649 smart_str_appendc(&querystr, ',');
6650 } ZEND_HASH_FOREACH_END();
6651 ZSTR_LEN(querystr.s)--;
6652 smart_str_appends(&querystr, ") VALUES (");
6653
6654 /* make values string */
6655 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(var_array), val) {
6656 /* we can avoid the key_type check here, because we tested it in the other loop */
6657 switch (Z_TYPE_P(val)) {
6658 case IS_STRING:
6659 if (opt & PGSQL_DML_ESCAPE) {
6660 size_t new_len;
6661 char *tmp;
6662 tmp = (char *)safe_emalloc(Z_STRLEN_P(val), 2, 1);
6663 new_len = PQescapeStringConn(pg_link, tmp, Z_STRVAL_P(val), Z_STRLEN_P(val), NULL);
6664 smart_str_appendc(&querystr, '\'');
6665 smart_str_appendl(&querystr, tmp, new_len);
6666 smart_str_appendc(&querystr, '\'');
6667 efree(tmp);
6668 } else {
6669 smart_str_appendl(&querystr, Z_STRVAL_P(val), Z_STRLEN_P(val));
6670 }
6671 break;
6672 case IS_LONG:
6673 smart_str_append_long(&querystr, Z_LVAL_P(val));
6674 break;
6675 case IS_DOUBLE:
6676 smart_str_appendl(&querystr, buf, snprintf(buf, sizeof(buf), "%F", Z_DVAL_P(val)));
6677 break;
6678 case IS_NULL:
6679 smart_str_appendl(&querystr, "NULL", sizeof("NULL")-1);
6680 break;
6681 default:
6682 php_error_docref(NULL, E_WARNING, "Expects scaler values. type = %d", Z_TYPE_P(val));
6683 goto cleanup;
6684 break;
6685 }
6686 smart_str_appendc(&querystr, ',');
6687 } ZEND_HASH_FOREACH_END();
6688 /* Remove the trailing "," */
6689 ZSTR_LEN(querystr.s)--;
6690 smart_str_appends(&querystr, ");");
6691
6692 no_values:
6693
6694 smart_str_0(&querystr);
6695
6696 if ((opt & (PGSQL_DML_EXEC|PGSQL_DML_ASYNC)) &&
6697 do_exec(&querystr, PGRES_COMMAND_OK, pg_link, (opt & PGSQL_CONV_OPTS)) == 0) {
6698 ret = SUCCESS;
6699 }
6700 else if (opt & PGSQL_DML_STRING) {
6701 ret = SUCCESS;
6702 }
6703
6704 cleanup:
6705 zval_ptr_dtor(&converted);
6706 if (ret == SUCCESS && (opt & PGSQL_DML_STRING)) {
6707 *sql = querystr.s;
6708 }
6709 else {
6710 smart_str_free(&querystr);
6711 }
6712 return ret;
6713 }
6714 /* }}} */
6715
6716 /* {{{ proto mixed pg_insert(resource db, string table, array values[, int options])
6717 Insert values (filed=>value) to table */
6718 PHP_FUNCTION(pg_insert)
6719 {
6720 zval *pgsql_link, *values;
6721 char *table;
6722 size_t table_len;
6723 zend_ulong option = PGSQL_DML_EXEC, return_sql;
6724 PGconn *pg_link;
6725 PGresult *pg_result;
6726 ExecStatusType status;
6727 zend_string *sql = NULL;
6728 int argc = ZEND_NUM_ARGS();
6729
6730 if (zend_parse_parameters(argc, "rsa|l",
6731 &pgsql_link, &table, &table_len, &values, &option) == FAILURE) {
6732 return;
6733 }
6734 if (option & ~(PGSQL_CONV_OPTS|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_ASYNC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)) {
6735 php_error_docref(NULL, E_WARNING, "Invalid option is specified");
6736 RETURN_FALSE;
6737 }
6738
6739 if ((pg_link = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
6740 RETURN_FALSE;
6741 }
6742
6743 if (php_pgsql_flush_query(pg_link)) {
6744 php_error_docref(NULL, E_NOTICE, "Detected unhandled result(s) in connection");
6745 }
6746 return_sql = option & PGSQL_DML_STRING;
6747 if (option & PGSQL_DML_EXEC) {
6748 /* return resource when executed */
6749 option = option & ~PGSQL_DML_EXEC;
6750 if (php_pgsql_insert(pg_link, table, values, option|PGSQL_DML_STRING, &sql) == FAILURE) {
6751 RETURN_FALSE;
6752 }
6753 pg_result = PQexec(pg_link, ZSTR_VAL(sql));
6754 if ((PGG(auto_reset_persistent) & 2) && PQstatus(pg_link) != CONNECTION_OK) {
6755 PQclear(pg_result);
6756 PQreset(pg_link);
6757 pg_result = PQexec(pg_link, ZSTR_VAL(sql));
6758 }
6759 efree(sql);
6760
6761 if (pg_result) {
6762 status = PQresultStatus(pg_result);
6763 } else {
6764 status = (ExecStatusType) PQstatus(pg_link);
6765 }
6766
6767 switch (status) {
6768 case PGRES_EMPTY_QUERY:
6769 case PGRES_BAD_RESPONSE:
6770 case PGRES_NONFATAL_ERROR:
6771 case PGRES_FATAL_ERROR:
6772 PHP_PQ_ERROR("Query failed: %s", pg_link);
6773 PQclear(pg_result);
6774 RETURN_FALSE;
6775 break;
6776 case PGRES_COMMAND_OK: /* successful command that did not return rows */
6777 default:
6778 if (pg_result) {
6779 pgsql_result_handle *pgsql_handle = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
6780 pgsql_handle->conn = pg_link;
6781 pgsql_handle->result = pg_result;
6782 pgsql_handle->row = 0;
6783 RETURN_RES(zend_register_resource(pgsql_handle, le_result));
6784 } else {
6785 PQclear(pg_result);
6786 RETURN_FALSE;
6787 }
6788 break;
6789 }
6790 } else if (php_pgsql_insert(pg_link, table, values, option, &sql) == FAILURE) {
6791 RETURN_FALSE;
6792 }
6793 if (return_sql) {
6794 RETURN_STR(sql);
6795 return;
6796 }
6797 RETURN_TRUE;
6798 }
6799 /* }}} */
6800
6801 static inline int build_assignment_string(PGconn *pg_link, smart_str *querystr, HashTable *ht, int where_cond, const char *pad, int pad_len, zend_ulong opt) /* {{{ */
6802 {
6803 zend_string *fld;
6804 zval *val;
6805
6806 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, fld, val) {
6807 if (fld == NULL) {
6808 php_error_docref(NULL, E_NOTICE, "Expects associative array for values to be inserted");
6809 return -1;
6810 }
6811 if (opt & PGSQL_DML_ESCAPE) {
6812 char *tmp = PGSQLescapeIdentifier(pg_link, ZSTR_VAL(fld), ZSTR_LEN(fld) + 1);
6813 smart_str_appends(querystr, tmp);
6814 PGSQLfree(tmp);
6815 } else {
6816 smart_str_appendl(querystr, ZSTR_VAL(fld), ZSTR_LEN(fld));
6817 }
6818 if (where_cond && (Z_TYPE_P(val) == IS_TRUE || Z_TYPE_P(val) == IS_FALSE || (Z_TYPE_P(val) == IS_STRING && !strcmp(Z_STRVAL_P(val), "NULL")))) {
6819 smart_str_appends(querystr, " IS ");
6820 } else {
6821 smart_str_appendc(querystr, '=');
6822 }
6823
6824 switch (Z_TYPE_P(val)) {
6825 case IS_STRING:
6826 if (opt & PGSQL_DML_ESCAPE) {
6827 char *tmp = (char *)safe_emalloc(Z_STRLEN_P(val), 2, 1);
6828 size_t new_len = PQescapeStringConn(pg_link, tmp, Z_STRVAL_P(val), Z_STRLEN_P(val), NULL);
6829 smart_str_appendc(querystr, '\'');
6830 smart_str_appendl(querystr, tmp, new_len);
6831 smart_str_appendc(querystr, '\'');
6832 efree(tmp);
6833 } else {
6834 smart_str_appendl(querystr, Z_STRVAL_P(val), Z_STRLEN_P(val));
6835 }
6836 break;
6837 case IS_LONG:
6838 smart_str_append_long(querystr, Z_LVAL_P(val));
6839 break;
6840 case IS_DOUBLE: {
6841 char buf[256];
6842 smart_str_appendl(querystr, buf, MIN(snprintf(buf, sizeof(buf), "%F", Z_DVAL_P(val)), sizeof(buf) - 1));
6843 }
6844 break;
6845 case IS_NULL:
6846 smart_str_appendl(querystr, "NULL", sizeof("NULL")-1);
6847 break;
6848 default:
6849 php_error_docref(NULL, E_WARNING, "Expects scaler values. type=%d", Z_TYPE_P(val));
6850 return -1;
6851 }
6852 smart_str_appendl(querystr, pad, pad_len);
6853 } ZEND_HASH_FOREACH_END();
6854 if (querystr->s) {
6855 ZSTR_LEN(querystr->s) -= pad_len;
6856 }
6857
6858 return 0;
6859 }
6860 /* }}} */
6861
6862 /* {{{ php_pgsql_update
6863 */
6864 PHP_PGSQL_API int php_pgsql_update(PGconn *pg_link, const char *table, zval *var_array, zval *ids_array, zend_ulong opt, zend_string **sql)
6865 {
6866 zval var_converted, ids_converted;
6867 smart_str querystr = {0};
6868 int ret = FAILURE;
6869
6870 assert(pg_link != NULL);
6871 assert(table != NULL);
6872 assert(Z_TYPE_P(var_array) == IS_ARRAY);
6873 assert(Z_TYPE_P(ids_array) == IS_ARRAY);
6874 assert(!(opt & ~(PGSQL_CONV_OPTS|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)));
6875
6876 if (zend_hash_num_elements(Z_ARRVAL_P(var_array)) == 0
6877 || zend_hash_num_elements(Z_ARRVAL_P(ids_array)) == 0) {
6878 return FAILURE;
6879 }
6880
6881 ZVAL_UNDEF(&var_converted);
6882 ZVAL_UNDEF(&ids_converted);
6883 if (!(opt & (PGSQL_DML_NO_CONV|PGSQL_DML_ESCAPE))) {
6884 array_init(&var_converted);
6885 if (php_pgsql_convert(pg_link, table, var_array, &var_converted, (opt & PGSQL_CONV_OPTS)) == FAILURE) {
6886 goto cleanup;
6887 }
6888 var_array = &var_converted;
6889 array_init(&ids_converted);
6890 if (php_pgsql_convert(pg_link, table, ids_array, &ids_converted, (opt & PGSQL_CONV_OPTS)) == FAILURE) {
6891 goto cleanup;
6892 }
6893 ids_array = &ids_converted;
6894 }
6895
6896 smart_str_appends(&querystr, "UPDATE ");
6897 build_tablename(&querystr, pg_link, table);
6898 smart_str_appends(&querystr, " SET ");
6899
6900 if (build_assignment_string(pg_link, &querystr, Z_ARRVAL_P(var_array), 0, ",", 1, opt))
6901 goto cleanup;
6902
6903 smart_str_appends(&querystr, " WHERE ");
6904
6905 if (build_assignment_string(pg_link, &querystr, Z_ARRVAL_P(ids_array), 1, " AND ", sizeof(" AND ")-1, opt))
6906 goto cleanup;
6907
6908 smart_str_appendc(&querystr, ';');
6909 smart_str_0(&querystr);
6910
6911 if ((opt & PGSQL_DML_EXEC) && do_exec(&querystr, PGRES_COMMAND_OK, pg_link, opt) == 0) {
6912 ret = SUCCESS;
6913 } else if (opt & PGSQL_DML_STRING) {
6914 ret = SUCCESS;
6915 }
6916
6917 cleanup:
6918 zval_ptr_dtor(&var_converted);
6919 zval_ptr_dtor(&ids_converted);
6920 if (ret == SUCCESS && (opt & PGSQL_DML_STRING)) {
6921 *sql = querystr.s;
6922 }
6923 else {
6924 smart_str_free(&querystr);
6925 }
6926 return ret;
6927 }
6928 /* }}} */
6929
6930 /* {{{ proto mixed pg_update(resource db, string table, array fields, array ids[, int options])
6931 Update table using values (field=>value) and ids (id=>value) */
6932 PHP_FUNCTION(pg_update)
6933 {
6934 zval *pgsql_link, *values, *ids;
6935 char *table;
6936 size_t table_len;
6937 zend_ulong option = PGSQL_DML_EXEC;
6938 PGconn *pg_link;
6939 zend_string *sql = NULL;
6940 int argc = ZEND_NUM_ARGS();
6941
6942 if (zend_parse_parameters(argc, "rsaa|l",
6943 &pgsql_link, &table, &table_len, &values, &ids, &option) == FAILURE) {
6944 return;
6945 }
6946 if (option & ~(PGSQL_CONV_OPTS|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)) {
6947 php_error_docref(NULL, E_WARNING, "Invalid option is specified");
6948 RETURN_FALSE;
6949 }
6950
6951 if ((pg_link = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
6952 RETURN_FALSE;
6953 }
6954
6955 if (php_pgsql_flush_query(pg_link)) {
6956 php_error_docref(NULL, E_NOTICE, "Detected unhandled result(s) in connection");
6957 }
6958 if (php_pgsql_update(pg_link, table, values, ids, option, &sql) == FAILURE) {
6959 RETURN_FALSE;
6960 }
6961 if (option & PGSQL_DML_STRING) {
6962 RETURN_STR(sql);
6963 }
6964 RETURN_TRUE;
6965 }
6966 /* }}} */
6967
6968 /* {{{ php_pgsql_delete
6969 */
6970 PHP_PGSQL_API int php_pgsql_delete(PGconn *pg_link, const char *table, zval *ids_array, zend_ulong opt, zend_string **sql)
6971 {
6972 zval ids_converted;
6973 smart_str querystr = {0};
6974 int ret = FAILURE;
6975
6976 assert(pg_link != NULL);
6977 assert(table != NULL);
6978 assert(Z_TYPE_P(ids_array) == IS_ARRAY);
6979 assert(!(opt & ~(PGSQL_CONV_FORCE_NULL|PGSQL_DML_EXEC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)));
6980
6981 if (zend_hash_num_elements(Z_ARRVAL_P(ids_array)) == 0) {
6982 return FAILURE;
6983 }
6984
6985 ZVAL_UNDEF(&ids_converted);
6986 if (!(opt & (PGSQL_DML_NO_CONV|PGSQL_DML_ESCAPE))) {
6987 array_init(&ids_converted);
6988 if (php_pgsql_convert(pg_link, table, ids_array, &ids_converted, (opt & PGSQL_CONV_OPTS)) == FAILURE) {
6989 goto cleanup;
6990 }
6991 ids_array = &ids_converted;
6992 }
6993
6994 smart_str_appends(&querystr, "DELETE FROM ");
6995 build_tablename(&querystr, pg_link, table);
6996 smart_str_appends(&querystr, " WHERE ");
6997
6998 if (build_assignment_string(pg_link, &querystr, Z_ARRVAL_P(ids_array), 1, " AND ", sizeof(" AND ")-1, opt))
6999 goto cleanup;
7000
7001 smart_str_appendc(&querystr, ';');
7002 smart_str_0(&querystr);
7003
7004 if ((opt & PGSQL_DML_EXEC) && do_exec(&querystr, PGRES_COMMAND_OK, pg_link, opt) == 0) {
7005 ret = SUCCESS;
7006 } else if (opt & PGSQL_DML_STRING) {
7007 ret = SUCCESS;
7008 }
7009
7010 cleanup:
7011 zval_ptr_dtor(&ids_converted);
7012 if (ret == SUCCESS && (opt & PGSQL_DML_STRING)) {
7013 *sql = querystr.s;
7014 }
7015 else {
7016 smart_str_free(&querystr);
7017 }
7018 return ret;
7019 }
7020 /* }}} */
7021
7022 /* {{{ proto mixed pg_delete(resource db, string table, array ids[, int options])
7023 Delete records has ids (id=>value) */
7024 PHP_FUNCTION(pg_delete)
7025 {
7026 zval *pgsql_link, *ids;
7027 char *table;
7028 size_t table_len;
7029 zend_ulong option = PGSQL_DML_EXEC;
7030 PGconn *pg_link;
7031 zend_string *sql;
7032 int argc = ZEND_NUM_ARGS();
7033
7034 if (zend_parse_parameters(argc, "rsa|l",
7035 &pgsql_link, &table, &table_len, &ids, &option) == FAILURE) {
7036 return;
7037 }
7038 if (option & ~(PGSQL_CONV_FORCE_NULL|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)) {
7039 php_error_docref(NULL, E_WARNING, "Invalid option is specified");
7040 RETURN_FALSE;
7041 }
7042
7043 if ((pg_link = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
7044 RETURN_FALSE;
7045 }
7046
7047 if (php_pgsql_flush_query(pg_link)) {
7048 php_error_docref(NULL, E_NOTICE, "Detected unhandled result(s) in connection");
7049 }
7050 if (php_pgsql_delete(pg_link, table, ids, option, &sql) == FAILURE) {
7051 RETURN_FALSE;
7052 }
7053 if (option & PGSQL_DML_STRING) {
7054 RETURN_STR(sql);
7055 }
7056 RETURN_TRUE;
7057 }
7058 /* }}} */
7059
7060 /* {{{ php_pgsql_result2array
7061 */
7062 PHP_PGSQL_API int php_pgsql_result2array(PGresult *pg_result, zval *ret_array, long result_type)
7063 {
7064 zval row;
7065 char *field_name;
7066 size_t num_fields;
7067 int pg_numrows, pg_row;
7068 uint32_t i;
7069 assert(Z_TYPE_P(ret_array) == IS_ARRAY);
7070
7071 if ((pg_numrows = PQntuples(pg_result)) <= 0) {
7072 return FAILURE;
7073 }
7074 for (pg_row = 0; pg_row < pg_numrows; pg_row++) {
7075 array_init(&row);
7076 for (i = 0, num_fields = PQnfields(pg_result); i < num_fields; i++) {
7077 field_name = PQfname(pg_result, i);
7078 if (PQgetisnull(pg_result, pg_row, i)) {
7079 if (result_type & PGSQL_ASSOC) {
7080 add_assoc_null(&row, field_name);
7081 }
7082 if (result_type & PGSQL_NUM) {
7083 add_next_index_null(&row);
7084 }
7085 } else {
7086 char *element = PQgetvalue(pg_result, pg_row, i);
7087 if (element) {
7088 const size_t element_len = strlen(element);
7089 if (result_type & PGSQL_ASSOC) {
7090 add_assoc_stringl(&row, field_name, element, element_len);
7091 }
7092 if (result_type & PGSQL_NUM) {
7093 add_next_index_stringl(&row, element, element_len);
7094 }
7095 }
7096 }
7097 }
7098 add_index_zval(ret_array, pg_row, &row);
7099 }
7100 return SUCCESS;
7101 }
7102 /* }}} */
7103
7104 /* {{{ php_pgsql_select
7105 */
7106 PHP_PGSQL_API int php_pgsql_select(PGconn *pg_link, const char *table, zval *ids_array, zval *ret_array, zend_ulong opt, long result_type, zend_string **sql)
7107 {
7108 zval ids_converted;
7109 smart_str querystr = {0};
7110 int ret = FAILURE;
7111 PGresult *pg_result;
7112
7113 assert(pg_link != NULL);
7114 assert(table != NULL);
7115 assert(Z_TYPE_P(ids_array) == IS_ARRAY);
7116 assert(Z_TYPE_P(ret_array) == IS_ARRAY);
7117 assert(!(opt & ~(PGSQL_CONV_OPTS|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_ASYNC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)));
7118
7119 if (zend_hash_num_elements(Z_ARRVAL_P(ids_array)) == 0) {
7120 return FAILURE;
7121 }
7122
7123 ZVAL_UNDEF(&ids_converted);
7124 if (!(opt & (PGSQL_DML_NO_CONV|PGSQL_DML_ESCAPE))) {
7125 array_init(&ids_converted);
7126 if (php_pgsql_convert(pg_link, table, ids_array, &ids_converted, (opt & PGSQL_CONV_OPTS)) == FAILURE) {
7127 goto cleanup;
7128 }
7129 ids_array = &ids_converted;
7130 }
7131
7132 smart_str_appends(&querystr, "SELECT * FROM ");
7133 build_tablename(&querystr, pg_link, table);
7134 smart_str_appends(&querystr, " WHERE ");
7135
7136 if (build_assignment_string(pg_link, &querystr, Z_ARRVAL_P(ids_array), 1, " AND ", sizeof(" AND ")-1, opt))
7137 goto cleanup;
7138
7139 smart_str_appendc(&querystr, ';');
7140 smart_str_0(&querystr);
7141
7142 pg_result = PQexec(pg_link, ZSTR_VAL(querystr.s));
7143 if (PQresultStatus(pg_result) == PGRES_TUPLES_OK) {
7144 ret = php_pgsql_result2array(pg_result, ret_array, result_type);
7145 } else {
7146 php_error_docref(NULL, E_NOTICE, "Failed to execute '%s'", ZSTR_VAL(querystr.s));
7147 }
7148 PQclear(pg_result);
7149
7150 cleanup:
7151 zval_ptr_dtor(&ids_converted);
7152 if (ret == SUCCESS && (opt & PGSQL_DML_STRING)) {
7153 *sql = querystr.s;
7154 }
7155 else {
7156 smart_str_free(&querystr);
7157 }
7158 return ret;
7159 }
7160 /* }}} */
7161
7162 /* {{{ proto mixed pg_select(resource db, string table, array ids[, int options [, int result_type])
7163 Select records that has ids (id=>value) */
7164 PHP_FUNCTION(pg_select)
7165 {
7166 zval *pgsql_link, *ids;
7167 char *table;
7168 size_t table_len;
7169 zend_ulong option = PGSQL_DML_EXEC;
7170 long result_type = PGSQL_ASSOC;
7171 PGconn *pg_link;
7172 zend_string *sql = NULL;
7173 int argc = ZEND_NUM_ARGS();
7174
7175 if (zend_parse_parameters(argc, "rsa|l",
7176 &pgsql_link, &table, &table_len, &ids, &option, &result_type) == FAILURE) {
7177 return;
7178 }
7179 if (option & ~(PGSQL_CONV_FORCE_NULL|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_ASYNC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)) {
7180 php_error_docref(NULL, E_WARNING, "Invalid option is specified");
7181 RETURN_FALSE;
7182 }
7183 if (!(result_type & PGSQL_BOTH)) {
7184 php_error_docref(NULL, E_WARNING, "Invalid result type");
7185 RETURN_FALSE;
7186 }
7187
7188 if ((pg_link = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {
7189 RETURN_FALSE;
7190 }
7191
7192 if (php_pgsql_flush_query(pg_link)) {
7193 php_error_docref(NULL, E_NOTICE, "Detected unhandled result(s) in connection");
7194 }
7195 array_init(return_value);
7196 if (php_pgsql_select(pg_link, table, ids, return_value, option, result_type, &sql) == FAILURE) {
7197 zval_ptr_dtor(return_value);
7198 RETURN_FALSE;
7199 }
7200 if (option & PGSQL_DML_STRING) {
7201 zval_ptr_dtor(return_value);
7202 RETURN_STR(sql);
7203 }
7204 return;
7205 }
7206 /* }}} */
7207
7208 #endif
7209
