1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | http://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Author: Wez Furlong <wez@php.net> |
14 | Frank M. Kromann <frank@kromann.info> |
15 +----------------------------------------------------------------------+
16 */
17
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
21
22 #include "php.h"
23 #include "php_ini.h"
24 #include "ext/standard/php_string.h"
25 #include "ext/standard/info.h"
26 #include "pdo/php_pdo.h"
27 #include "pdo/php_pdo_driver.h"
28 #include "php_pdo_dblib.h"
29 #include "php_pdo_dblib_int.h"
30 #include "zend_exceptions.h"
31
32
33 /* {{{ pdo_dblib_get_field_name
34 *
35 * Return the data type name for a given TDS number
36 *
37 */
pdo_dblib_get_field_name(int type)38 static char *pdo_dblib_get_field_name(int type)
39 {
40 /*
41 * I don't return dbprtype(type) because it does not fully describe the type
42 * (example: varchar is reported as char by dbprtype)
43 *
44 * FIX ME: Cache datatypes from server systypes table in pdo_dblib_handle_factory()
45 * to make this future proof.
46 */
47
48 switch (type) {
49 case 31: return "nvarchar";
50 case 34: return "image";
51 case 35: return "text";
52 case 36: return "uniqueidentifier";
53 case 37: return "varbinary"; /* & timestamp - Sybase AS12 */
54 case 38: return "bigint"; /* & bigintn - Sybase AS12 */
55 case 39: return "varchar"; /* & sysname & nvarchar - Sybase AS12 */
56 case 40: return "date";
57 case 41: return "time";
58 case 42: return "datetime2";
59 case 43: return "datetimeoffset";
60 case 45: return "binary"; /* Sybase AS12 */
61 case 47: return "char"; /* & nchar & uniqueidentifierstr Sybase AS12 */
62 case 48: return "tinyint";
63 case 50: return "bit"; /* Sybase AS12 */
64 case 52: return "smallint";
65 case 55: return "decimal"; /* Sybase AS12 */
66 case 56: return "int";
67 case 58: return "smalldatetime";
68 case 59: return "real";
69 case 60: return "money";
70 case 61: return "datetime";
71 case 62: return "float";
72 case 63: return "numeric"; /* or uint, ubigint, usmallint Sybase AS12 */
73 case 98: return "sql_variant";
74 case 99: return "ntext";
75 case 104: return "bit";
76 case 106: return "decimal"; /* decimal n on sybase */
77 case 108: return "numeric"; /* numeric n on sybase */
78 case 122: return "smallmoney";
79 case 127: return "bigint";
80 case 165: return "varbinary";
81 case 167: return "varchar";
82 case 173: return "binary";
83 case 175: return "char";
84 case 189: return "timestamp";
85 case 231: return "nvarchar";
86 case 239: return "nchar";
87 case 240: return "geometry";
88 case 241: return "xml";
89 default: return "unknown";
90 }
91 }
92 /* }}} */
93
pdo_dblib_stmt_cursor_closer(pdo_stmt_t * stmt)94 static int pdo_dblib_stmt_cursor_closer(pdo_stmt_t *stmt)
95 {
96 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
97 pdo_dblib_db_handle *H = S->H;
98
99 /* Cancel any pending results */
100 dbcancel(H->link);
101
102 pdo_dblib_err_dtor(&H->err);
103
104 return 1;
105 }
106
pdo_dblib_stmt_dtor(pdo_stmt_t * stmt)107 static int pdo_dblib_stmt_dtor(pdo_stmt_t *stmt)
108 {
109 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
110
111 pdo_dblib_err_dtor(&S->err);
112
113 efree(S);
114
115 return 1;
116 }
117
pdo_dblib_stmt_next_rowset_no_cancel(pdo_stmt_t * stmt)118 static int pdo_dblib_stmt_next_rowset_no_cancel(pdo_stmt_t *stmt)
119 {
120 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
121 pdo_dblib_db_handle *H = S->H;
122 RETCODE ret;
123 int num_fields;
124
125 do {
126 ret = dbresults(H->link);
127 num_fields = dbnumcols(H->link);
128 } while (H->skip_empty_rowsets && num_fields <= 0 && ret == SUCCEED);
129
130
131 if (FAIL == ret) {
132 pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbresults() returned FAIL");
133 return 0;
134 }
135
136 if (NO_MORE_RESULTS == ret) {
137 return 0;
138 }
139
140 if (H->skip_empty_rowsets && num_fields <= 0) {
141 return 0;
142 }
143
144 stmt->row_count = DBCOUNT(H->link);
145 stmt->column_count = num_fields;
146
147 return 1;
148 }
149
pdo_dblib_stmt_next_rowset(pdo_stmt_t * stmt)150 static int pdo_dblib_stmt_next_rowset(pdo_stmt_t *stmt)
151 {
152 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
153 pdo_dblib_db_handle *H = S->H;
154 RETCODE ret = SUCCESS;
155
156 /* Ideally use dbcanquery here, but there is a bug in FreeTDS's implementation of dbcanquery
157 * It has been resolved but is currently only available in nightly builds
158 */
159 while (NO_MORE_ROWS != ret) {
160 ret = dbnextrow(H->link);
161
162 if (FAIL == ret) {
163 pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbnextrow() returned FAIL");
164 return 0;
165 }
166 }
167
168 return pdo_dblib_stmt_next_rowset_no_cancel(stmt);
169 }
170
pdo_dblib_stmt_execute(pdo_stmt_t * stmt)171 static int pdo_dblib_stmt_execute(pdo_stmt_t *stmt)
172 {
173 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
174 pdo_dblib_db_handle *H = S->H;
175
176 dbsetuserdata(H->link, (BYTE*) &S->err);
177
178 pdo_dblib_stmt_cursor_closer(stmt);
179
180 if (FAIL == dbcmd(H->link, stmt->active_query_string)) {
181 return 0;
182 }
183
184 if (FAIL == dbsqlexec(H->link)) {
185 return 0;
186 }
187
188 pdo_dblib_stmt_next_rowset_no_cancel(stmt);
189
190 stmt->row_count = DBCOUNT(H->link);
191 stmt->column_count = dbnumcols(H->link);
192
193 return 1;
194 }
195
pdo_dblib_stmt_fetch(pdo_stmt_t * stmt,enum pdo_fetch_orientation ori,zend_long offset)196 static int pdo_dblib_stmt_fetch(pdo_stmt_t *stmt,
197 enum pdo_fetch_orientation ori, zend_long offset)
198 {
199
200 RETCODE ret;
201
202 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
203 pdo_dblib_db_handle *H = S->H;
204
205 ret = dbnextrow(H->link);
206
207 if (FAIL == ret) {
208 pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbnextrow() returned FAIL");
209 return 0;
210 }
211
212 if(NO_MORE_ROWS == ret) {
213 return 0;
214 }
215
216 return 1;
217 }
218
pdo_dblib_stmt_describe(pdo_stmt_t * stmt,int colno)219 static int pdo_dblib_stmt_describe(pdo_stmt_t *stmt, int colno)
220 {
221 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
222 pdo_dblib_db_handle *H = S->H;
223 struct pdo_column_data *col;
224 char *fname;
225
226 if(colno >= stmt->column_count || colno < 0) {
227 return FAILURE;
228 }
229
230 if (colno == 0) {
231 S->computed_column_name_count = 0;
232 }
233
234 col = &stmt->columns[colno];
235 fname = (char*)dbcolname(H->link, colno+1);
236
237 if (fname && *fname) {
238 col->name = zend_string_init(fname, strlen(fname), 0);
239 } else {
240 if (S->computed_column_name_count > 0) {
241 char buf[16];
242 int len;
243
244 len = snprintf(buf, sizeof(buf), "computed%d", S->computed_column_name_count);
245 col->name = zend_string_init(buf, len, 0);
246 } else {
247 col->name = zend_string_init("computed", strlen("computed"), 0);
248 }
249
250 S->computed_column_name_count++;
251 }
252
253 col->maxlen = dbcollen(H->link, colno+1);
254 col->param_type = PDO_PARAM_ZVAL;
255
256 return 1;
257 }
258
pdo_dblib_stmt_should_stringify_col(pdo_stmt_t * stmt,int coltype)259 static int pdo_dblib_stmt_should_stringify_col(pdo_stmt_t *stmt, int coltype)
260 {
261 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
262 pdo_dblib_db_handle *H = S->H;
263
264 switch (coltype) {
265 case SQLDECIMAL:
266 case SQLNUMERIC:
267 case SQLMONEY:
268 case SQLMONEY4:
269 case SQLMONEYN:
270 case SQLFLT4:
271 case SQLFLT8:
272 case SQLINT4:
273 case SQLINT2:
274 case SQLINT1:
275 case SQLBIT:
276 if (stmt->dbh->stringify) {
277 return 1;
278 }
279 break;
280
281 case SQLINT8:
282 if (stmt->dbh->stringify) {
283 return 1;
284 }
285
286 /* force stringify if DBBIGINT won't fit in zend_long */
287 /* this should only be an issue for 32-bit machines */
288 if (sizeof(zend_long) < sizeof(DBBIGINT)) {
289 return 1;
290 }
291 break;
292
293 #ifdef SQLMSDATETIME2
294 case SQLMSDATETIME2:
295 #endif
296 case SQLDATETIME:
297 case SQLDATETIM4:
298 if (H->datetime_convert) {
299 return 1;
300 }
301 break;
302 }
303
304 return 0;
305 }
306
pdo_dblib_stmt_stringify_col(int coltype,LPBYTE data,DBINT data_len,zval ** ptr)307 static void pdo_dblib_stmt_stringify_col(int coltype, LPBYTE data, DBINT data_len, zval **ptr)
308 {
309 DBCHAR *tmp_data;
310 DBINT tmp_data_len;
311 zval *zv;
312
313 /* FIXME: We allocate more than we need here */
314 tmp_data_len = 32 + (2 * (data_len));
315
316 switch (coltype) {
317 case SQLDATETIME:
318 case SQLDATETIM4: {
319 if (tmp_data_len < DATETIME_MAX_LEN) {
320 tmp_data_len = DATETIME_MAX_LEN;
321 }
322 break;
323 }
324 }
325
326 tmp_data = emalloc(tmp_data_len);
327 data_len = dbconvert(NULL, coltype, data, data_len, SQLCHAR, (LPBYTE) tmp_data, tmp_data_len);
328
329 zv = emalloc(sizeof(zval));
330 if (data_len > 0) {
331 /* to prevent overflows, tmp_data_len is provided as a dest len for dbconvert()
332 * this code previously passed a dest len of -1
333 * the FreeTDS impl of dbconvert() does an rtrim with that value, so replicate that behavior
334 */
335 while (data_len > 0 && tmp_data[data_len - 1] == ' ') {
336 data_len--;
337 }
338
339 ZVAL_STRINGL(zv, tmp_data, data_len);
340 } else {
341 ZVAL_EMPTY_STRING(zv);
342 }
343
344 efree(tmp_data);
345
346 *ptr = zv;
347 }
348
pdo_dblib_stmt_get_col(pdo_stmt_t * stmt,int colno,char ** ptr,zend_ulong * len,int * caller_frees)349 static int pdo_dblib_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr,
350 zend_ulong *len, int *caller_frees)
351 {
352
353 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
354 pdo_dblib_db_handle *H = S->H;
355
356 int coltype;
357 LPBYTE data;
358 DBCHAR *tmp_data;
359 DBINT data_len, tmp_data_len;
360 zval *zv = NULL;
361
362 coltype = dbcoltype(H->link, colno+1);
363 data = dbdata(H->link, colno+1);
364 data_len = dbdatlen(H->link, colno+1);
365
366 if (data_len != 0 || data != NULL) {
367 if (pdo_dblib_stmt_should_stringify_col(stmt, coltype) && dbwillconvert(coltype, SQLCHAR)) {
368 pdo_dblib_stmt_stringify_col(coltype, data, data_len, &zv);
369 }
370
371 if (!zv) {
372 switch (coltype) {
373 case SQLCHAR:
374 case SQLVARCHAR:
375 case SQLTEXT: {
376 #ifdef ilia_0
377 while (data_len>0 && data[data_len-1] == ' ') { /* nuke trailing whitespace */
378 data_len--;
379 }
380 #endif
381 }
382 case SQLVARBINARY:
383 case SQLBINARY:
384 case SQLIMAGE: {
385 zv = emalloc(sizeof(zval));
386 ZVAL_STRINGL(zv, (DBCHAR *) data, data_len);
387
388 break;
389 }
390 #ifdef SQLMSDATETIME2
391 case SQLMSDATETIME2:
392 #endif
393 case SQLDATETIME:
394 case SQLDATETIM4: {
395 size_t dl;
396 DBDATEREC di;
397 DBDATEREC dt;
398
399 dbconvert(H->link, coltype, data, -1, SQLDATETIME, (LPBYTE) &dt, -1);
400 dbdatecrack(H->link, &di, (DBDATETIME *) &dt);
401
402 dl = spprintf(&tmp_data, 20, "%04d-%02d-%02d %02d:%02d:%02d",
403 #if defined(PHP_DBLIB_IS_MSSQL) || defined(MSDBLIB)
404 di.year, di.month, di.day, di.hour, di.minute, di.second
405 #else
406 di.dateyear, di.datemonth+1, di.datedmonth, di.datehour, di.dateminute, di.datesecond
407 #endif
408 );
409
410 zv = emalloc(sizeof(zval));
411 ZVAL_STRINGL(zv, tmp_data, dl);
412
413 efree(tmp_data);
414
415 break;
416 }
417 case SQLFLT4: {
418 zv = emalloc(sizeof(zval));
419 ZVAL_DOUBLE(zv, *(DBFLT4 *) data);
420
421 break;
422 }
423 case SQLFLT8: {
424 zv = emalloc(sizeof(zval));
425 ZVAL_DOUBLE(zv, *(DBFLT8 *) data);
426
427 break;
428 }
429 case SQLINT8: {
430 zv = emalloc(sizeof(zval));
431 ZVAL_LONG(zv, *(DBBIGINT *) data);
432
433 break;
434 }
435 case SQLINT4: {
436 zv = emalloc(sizeof(zval));
437 ZVAL_LONG(zv, *(DBINT *) data);
438
439 break;
440 }
441 case SQLINT2: {
442 zv = emalloc(sizeof(zval));
443 ZVAL_LONG(zv, *(DBSMALLINT *) data);
444
445 break;
446 }
447 case SQLINT1:
448 case SQLBIT: {
449 zv = emalloc(sizeof(zval));
450 ZVAL_LONG(zv, *(DBTINYINT *) data);
451
452 break;
453 }
454 case SQLDECIMAL:
455 case SQLNUMERIC:
456 case SQLMONEY:
457 case SQLMONEY4:
458 case SQLMONEYN: {
459 DBFLT8 float_value;
460 dbconvert(NULL, coltype, data, 8, SQLFLT8, (LPBYTE) &float_value, -1);
461
462 zv = emalloc(sizeof(zval));
463 ZVAL_DOUBLE(zv, float_value);
464
465 break;
466 }
467
468 case SQLUNIQUE: {
469 if (H->stringify_uniqueidentifier) {
470 /* 36-char hex string representation */
471 tmp_data_len = 36;
472 tmp_data = safe_emalloc(tmp_data_len, sizeof(char), 1);
473 data_len = dbconvert(NULL, SQLUNIQUE, data, data_len, SQLCHAR, (LPBYTE) tmp_data, tmp_data_len);
474 php_strtoupper(tmp_data, data_len);
475 zv = emalloc(sizeof(zval));
476 ZVAL_STRINGL(zv, tmp_data, data_len);
477 efree(tmp_data);
478 } else {
479 /* 16-byte binary representation */
480 zv = emalloc(sizeof(zval));
481 ZVAL_STRINGL(zv, (DBCHAR *) data, 16);
482 }
483 break;
484 }
485
486 default: {
487 if (dbwillconvert(coltype, SQLCHAR)) {
488 pdo_dblib_stmt_stringify_col(coltype, data, data_len, &zv);
489 }
490
491 break;
492 }
493 }
494 }
495 }
496
497 if (zv != NULL) {
498 *ptr = (char*)zv;
499 *len = sizeof(zval);
500 } else {
501 *ptr = NULL;
502 *len = 0;
503 }
504
505 *caller_frees = 1;
506
507 return 1;
508 }
509
pdo_dblib_stmt_get_column_meta(pdo_stmt_t * stmt,zend_long colno,zval * return_value)510 static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value)
511 {
512 pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
513 pdo_dblib_db_handle *H = S->H;
514 DBTYPEINFO* dbtypeinfo;
515 int coltype;
516
517 if(colno >= stmt->column_count || colno < 0) {
518 return FAILURE;
519 }
520
521 array_init(return_value);
522
523 dbtypeinfo = dbcoltypeinfo(H->link, colno+1);
524
525 if(!dbtypeinfo) return FAILURE;
526
527 coltype = dbcoltype(H->link, colno+1);
528
529 add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) );
530 add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision );
531 add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale );
532 add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1));
533 add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(coltype));
534 add_assoc_long(return_value, "native_type_id", coltype);
535 add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1));
536
537 switch (coltype) {
538 case SQLBIT:
539 case SQLINT1:
540 case SQLINT2:
541 case SQLINT4:
542 add_assoc_long(return_value, "pdo_type", PDO_PARAM_INT);
543 break;
544 default:
545 add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR);
546 break;
547 }
548
549 return 1;
550 }
551
552
553 const struct pdo_stmt_methods dblib_stmt_methods = {
554 pdo_dblib_stmt_dtor,
555 pdo_dblib_stmt_execute,
556 pdo_dblib_stmt_fetch,
557 pdo_dblib_stmt_describe,
558 pdo_dblib_stmt_get_col,
559 NULL, /* param hook */
560 NULL, /* set attr */
561 NULL, /* get attr */
562 pdo_dblib_stmt_get_column_meta, /* meta */
563 pdo_dblib_stmt_next_rowset, /* nextrow */
564 pdo_dblib_stmt_cursor_closer
565 };
566
