xref: /PHP-5.4/ext/pdo_odbc/odbc_stmt.c (revision c0d060f5)
1 /*
2   +----------------------------------------------------------------------+
3   | PHP Version 5                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2014 The PHP Group                                |
6   +----------------------------------------------------------------------+
7   | This source file is subject to version 3.0 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_0.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   | Author: Wez Furlong <wez@php.net>                                    |
16   +----------------------------------------------------------------------+
17 */
18 
19 /* $Id$ */
20 
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24 
25 #include "php.h"
26 #include "php_ini.h"
27 #include "ext/standard/info.h"
28 #include "pdo/php_pdo.h"
29 #include "pdo/php_pdo_driver.h"
30 #include "php_pdo_odbc.h"
31 #include "php_pdo_odbc_int.h"
32 
33 enum pdo_odbc_conv_result {
34 	PDO_ODBC_CONV_NOT_REQUIRED,
35 	PDO_ODBC_CONV_OK,
36 	PDO_ODBC_CONV_FAIL
37 };
38 
pdo_odbc_sqltype_is_unicode(pdo_odbc_stmt * S,SWORD sqltype)39 static int pdo_odbc_sqltype_is_unicode(pdo_odbc_stmt *S, SWORD sqltype)
40 {
41 	if (!S->assume_utf8) return 0;
42 	switch (sqltype) {
43 #ifdef SQL_WCHAR
44 		case SQL_WCHAR:
45 			return 1;
46 #endif
47 #ifdef SQL_WLONGVARCHAR
48 		case SQL_WLONGVARCHAR:
49 			return 1;
50 #endif
51 #ifdef SQL_WVARCHAR
52 		case SQL_WVARCHAR:
53 			return 1;
54 #endif
55 		default:
56 			return 0;
57 	}
58 }
59 
pdo_odbc_utf82ucs2(pdo_stmt_t * stmt,int is_unicode,const char * buf,unsigned long buflen,unsigned long * outlen)60 static int pdo_odbc_utf82ucs2(pdo_stmt_t *stmt, int is_unicode, const char *buf,
61 	unsigned long buflen, unsigned long *outlen)
62 {
63 #ifdef PHP_WIN32
64 	if (is_unicode && buflen) {
65 		pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
66 		DWORD ret;
67 
68 		ret = MultiByteToWideChar(CP_UTF8, 0, buf, buflen, NULL, 0);
69 		if (ret == 0) {
70 			/*printf("%s:%d %d [%d] %.*s\n", __FILE__, __LINE__, GetLastError(), buflen, buflen, buf);*/
71 			return PDO_ODBC_CONV_FAIL;
72 		}
73 
74 		ret *= sizeof(WCHAR);
75 
76 		if (S->convbufsize <= ret) {
77 			S->convbufsize = ret + sizeof(WCHAR);
78 			S->convbuf = erealloc(S->convbuf, S->convbufsize);
79 		}
80 
81 		ret = MultiByteToWideChar(CP_UTF8, 0, buf, buflen, (LPWSTR)S->convbuf, S->convbufsize / sizeof(WCHAR));
82 		if (ret == 0) {
83 			/*printf("%s:%d %d [%d] %.*s\n", __FILE__, __LINE__, GetLastError(), buflen, buflen, buf);*/
84 			return PDO_ODBC_CONV_FAIL;
85 		}
86 
87 		ret *= sizeof(WCHAR);
88 		*outlen = ret;
89 		return PDO_ODBC_CONV_OK;
90 	}
91 #endif
92 	return PDO_ODBC_CONV_NOT_REQUIRED;
93 }
94 
pdo_odbc_ucs22utf8(pdo_stmt_t * stmt,int is_unicode,const char * buf,unsigned long buflen,unsigned long * outlen)95 static int pdo_odbc_ucs22utf8(pdo_stmt_t *stmt, int is_unicode, const char *buf,
96 	unsigned long buflen, unsigned long *outlen)
97 {
98 #ifdef PHP_WIN32
99 	if (is_unicode && buflen) {
100 		pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
101 		DWORD ret;
102 
103 		ret = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)buf, buflen/sizeof(WCHAR), NULL, 0, NULL, NULL);
104 		if (ret == 0) {
105 			return PDO_ODBC_CONV_FAIL;
106 		}
107 
108 		if (S->convbufsize <= ret) {
109 			S->convbufsize = ret + 1;
110 			S->convbuf = erealloc(S->convbuf, S->convbufsize);
111 		}
112 
113 		ret = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)buf, buflen/sizeof(WCHAR), S->convbuf, S->convbufsize, NULL, NULL);
114 		if (ret == 0) {
115 			return PDO_ODBC_CONV_FAIL;
116 		}
117 
118 		*outlen = ret;
119 		S->convbuf[*outlen] = '\0';
120 		return PDO_ODBC_CONV_OK;
121 	}
122 #endif
123 	return PDO_ODBC_CONV_NOT_REQUIRED;
124 }
125 
free_cols(pdo_stmt_t * stmt,pdo_odbc_stmt * S TSRMLS_DC)126 static void free_cols(pdo_stmt_t *stmt, pdo_odbc_stmt *S TSRMLS_DC)
127 {
128 	if (S->cols) {
129 		int i;
130 
131 		for (i = 0; i < stmt->column_count; i++) {
132 			if (S->cols[i].data) {
133 				efree(S->cols[i].data);
134 			}
135 		}
136 		efree(S->cols);
137 		S->cols = NULL;
138 	}
139 }
140 
odbc_stmt_dtor(pdo_stmt_t * stmt TSRMLS_DC)141 static int odbc_stmt_dtor(pdo_stmt_t *stmt TSRMLS_DC)
142 {
143 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
144 
145 	if (S->stmt != SQL_NULL_HANDLE) {
146 		if (stmt->executed) {
147 			SQLCloseCursor(S->stmt);
148 		}
149 		SQLFreeHandle(SQL_HANDLE_STMT, S->stmt);
150 		S->stmt = SQL_NULL_HANDLE;
151 	}
152 
153 	free_cols(stmt, S TSRMLS_CC);
154 	if (S->convbuf) {
155 		efree(S->convbuf);
156 	}
157 	efree(S);
158 
159 	return 1;
160 }
161 
odbc_stmt_execute(pdo_stmt_t * stmt TSRMLS_DC)162 static int odbc_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC)
163 {
164 	RETCODE rc;
165 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
166 	char *buf = NULL;
167 	SQLLEN row_count = -1;
168 
169 	if (stmt->executed) {
170 		SQLCloseCursor(S->stmt);
171 	}
172 
173 	rc = SQLExecute(S->stmt);
174 
175 	while (rc == SQL_NEED_DATA) {
176 		struct pdo_bound_param_data *param;
177 
178 		rc = SQLParamData(S->stmt, (SQLPOINTER*)&param);
179 		if (rc == SQL_NEED_DATA) {
180 			php_stream *stm;
181 			int len;
182 			pdo_odbc_param *P;
183 
184 			P = (pdo_odbc_param*)param->driver_data;
185 			if (Z_TYPE_P(param->parameter) != IS_RESOURCE) {
186 				/* they passed in a string */
187 				unsigned long ulen;
188 				convert_to_string(param->parameter);
189 
190 				switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode,
191 							Z_STRVAL_P(param->parameter),
192 							Z_STRLEN_P(param->parameter),
193 							&ulen)) {
194 					case PDO_ODBC_CONV_NOT_REQUIRED:
195 						SQLPutData(S->stmt, Z_STRVAL_P(param->parameter),
196 							Z_STRLEN_P(param->parameter));
197 						break;
198 					case PDO_ODBC_CONV_OK:
199 						SQLPutData(S->stmt, S->convbuf, ulen);
200 						break;
201 					case PDO_ODBC_CONV_FAIL:
202 						pdo_odbc_stmt_error("error converting input string");
203 						SQLCloseCursor(S->stmt);
204 						if (buf) {
205 							efree(buf);
206 						}
207 						return 0;
208 				}
209 				continue;
210 			}
211 
212 			/* we assume that LOBs are binary and don't need charset
213 			 * conversion */
214 
215 			php_stream_from_zval_no_verify(stm, &param->parameter);
216 			if (!stm) {
217 				/* shouldn't happen either */
218 				pdo_odbc_stmt_error("input LOB is no longer a stream");
219 				SQLCloseCursor(S->stmt);
220 				if (buf) {
221 					efree(buf);
222 				}
223 				return 0;
224 			}
225 
226 			/* now suck data from the stream and stick it into the database */
227 			if (buf == NULL) {
228 				buf = emalloc(8192);
229 			}
230 
231 			do {
232 				len = php_stream_read(stm, buf, 8192);
233 				if (len == 0) {
234 					break;
235 				}
236 				SQLPutData(S->stmt, buf, len);
237 			} while (1);
238 		}
239 	}
240 
241 	if (buf) {
242 		efree(buf);
243 	}
244 
245 	switch (rc) {
246 		case SQL_SUCCESS:
247 			break;
248 		case SQL_NO_DATA_FOUND:
249 		case SQL_SUCCESS_WITH_INFO:
250 			pdo_odbc_stmt_error("SQLExecute");
251 			break;
252 
253 		default:
254 			pdo_odbc_stmt_error("SQLExecute");
255 			return 0;
256 	}
257 
258 	SQLRowCount(S->stmt, &row_count);
259 	stmt->row_count = row_count;
260 
261 	if (!stmt->executed) {
262 		/* do first-time-only definition of bind/mapping stuff */
263 		SQLSMALLINT colcount;
264 
265 		/* how many columns do we have ? */
266 		SQLNumResultCols(S->stmt, &colcount);
267 
268 		stmt->column_count = (int)colcount;
269 		S->cols = ecalloc(colcount, sizeof(pdo_odbc_column));
270 		S->going_long = 0;
271 	}
272 
273 	return 1;
274 }
275 
odbc_stmt_param_hook(pdo_stmt_t * stmt,struct pdo_bound_param_data * param,enum pdo_param_event event_type TSRMLS_DC)276 static int odbc_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,
277 		enum pdo_param_event event_type TSRMLS_DC)
278 {
279 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
280 	RETCODE rc;
281 	SWORD sqltype = 0, ctype = 0, scale = 0, nullable = 0;
282 	UDWORD precision = 0;
283 	pdo_odbc_param *P;
284 
285 	/* we're only interested in parameters for prepared SQL right now */
286 	if (param->is_param) {
287 
288 		switch (event_type) {
289 			case PDO_PARAM_EVT_FETCH_PRE:
290 			case PDO_PARAM_EVT_FETCH_POST:
291 			case PDO_PARAM_EVT_NORMALIZE:
292 				/* Do nothing */
293 				break;
294 
295 			case PDO_PARAM_EVT_FREE:
296 				P = param->driver_data;
297 				if (P) {
298 					efree(P);
299 				}
300 				break;
301 
302 			case PDO_PARAM_EVT_ALLOC:
303 			{
304 				/* figure out what we're doing */
305 				switch (PDO_PARAM_TYPE(param->param_type)) {
306 					case PDO_PARAM_LOB:
307 						break;
308 
309 					case PDO_PARAM_STMT:
310 						return 0;
311 
312 					default:
313 						break;
314 				}
315 
316 				rc = SQLDescribeParam(S->stmt, (SQLUSMALLINT) param->paramno+1, &sqltype, &precision, &scale, &nullable);
317 				if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
318 					/* MS Access, for instance, doesn't support SQLDescribeParam,
319 					 * so we need to guess */
320 					sqltype = PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB ?
321 									SQL_LONGVARBINARY :
322 									SQL_LONGVARCHAR;
323 					precision = 4000;
324 					scale = 5;
325 					nullable = 1;
326 
327 					if (param->max_value_len > 0) {
328 						precision = param->max_value_len;
329 					}
330 				}
331 				if (sqltype == SQL_BINARY || sqltype == SQL_VARBINARY || sqltype == SQL_LONGVARBINARY) {
332 					ctype = SQL_C_BINARY;
333 				} else {
334 					ctype = SQL_C_CHAR;
335 				}
336 
337 				P = emalloc(sizeof(*P));
338 				param->driver_data = P;
339 
340 				P->len = 0; /* is re-populated each EXEC_PRE */
341 				P->outbuf = NULL;
342 
343 				P->is_unicode = pdo_odbc_sqltype_is_unicode(S, sqltype);
344 				if (P->is_unicode) {
345 					/* avoid driver auto-translation: we'll do it ourselves */
346 					ctype = SQL_C_BINARY;
347 				}
348 
349 				if ((param->param_type & PDO_PARAM_INPUT_OUTPUT) == PDO_PARAM_INPUT_OUTPUT) {
350 					P->paramtype = SQL_PARAM_INPUT_OUTPUT;
351 				} else if (param->max_value_len <= 0) {
352 					P->paramtype = SQL_PARAM_INPUT;
353 				} else {
354 					P->paramtype = SQL_PARAM_OUTPUT;
355 				}
356 
357 				if (P->paramtype != SQL_PARAM_INPUT) {
358 					if (PDO_PARAM_TYPE(param->param_type) != PDO_PARAM_NULL) {
359 						/* need an explicit buffer to hold result */
360 						P->len = param->max_value_len > 0 ? param->max_value_len : precision;
361 						if (P->is_unicode) {
362 							P->len *= 2;
363 						}
364 						P->outbuf = emalloc(P->len + (P->is_unicode ? 2:1));
365 					}
366 				}
367 
368 				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB && P->paramtype != SQL_PARAM_INPUT) {
369 					pdo_odbc_stmt_error("Can't bind a lob for output");
370 					return 0;
371 				}
372 
373 				rc = SQLBindParameter(S->stmt, (SQLUSMALLINT) param->paramno+1,
374 						P->paramtype, ctype, sqltype, precision, scale,
375 						P->paramtype == SQL_PARAM_INPUT ?
376 							(SQLPOINTER)param :
377 							P->outbuf,
378 						P->len,
379 						&P->len
380 						);
381 
382 				if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
383 					return 1;
384 				}
385 				pdo_odbc_stmt_error("SQLBindParameter");
386 				return 0;
387 			}
388 
389 			case PDO_PARAM_EVT_EXEC_PRE:
390 				P = param->driver_data;
391 				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
392 					if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
393 						php_stream *stm;
394 						php_stream_statbuf sb;
395 
396 						php_stream_from_zval_no_verify(stm, &param->parameter);
397 
398 						if (!stm) {
399 							return 0;
400 						}
401 
402 						if (0 == php_stream_stat(stm, &sb)) {
403 							if (P->outbuf) {
404 								int len, amount;
405 								char *ptr = P->outbuf;
406 								char *end = P->outbuf + P->len;
407 
408 								P->len = 0;
409 								do {
410 									amount = end - ptr;
411 									if (amount == 0) {
412 										break;
413 									}
414 									if (amount > 8192)
415 										amount = 8192;
416 									len = php_stream_read(stm, ptr, amount);
417 									if (len == 0) {
418 										break;
419 									}
420 									ptr += len;
421 									P->len += len;
422 								} while (1);
423 
424 							} else {
425 								P->len = SQL_LEN_DATA_AT_EXEC(sb.sb.st_size);
426 							}
427 						} else {
428 							if (P->outbuf) {
429 								P->len = 0;
430 							} else {
431 								P->len = SQL_LEN_DATA_AT_EXEC(0);
432 							}
433 						}
434 					} else {
435 						convert_to_string(param->parameter);
436 						if (P->outbuf) {
437 							P->len = Z_STRLEN_P(param->parameter);
438 							memcpy(P->outbuf, Z_STRVAL_P(param->parameter), P->len);
439 						} else {
440 							P->len = SQL_LEN_DATA_AT_EXEC(Z_STRLEN_P(param->parameter));
441 						}
442 					}
443 				} else if (Z_TYPE_P(param->parameter) == IS_NULL || PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL) {
444 					P->len = SQL_NULL_DATA;
445 				} else {
446 					convert_to_string(param->parameter);
447 					if (P->outbuf) {
448 						unsigned long ulen;
449 						switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode,
450 								Z_STRVAL_P(param->parameter),
451 								Z_STRLEN_P(param->parameter),
452 								&ulen)) {
453 							case PDO_ODBC_CONV_FAIL:
454 							case PDO_ODBC_CONV_NOT_REQUIRED:
455 								P->len = Z_STRLEN_P(param->parameter);
456 								memcpy(P->outbuf, Z_STRVAL_P(param->parameter), P->len);
457 								break;
458 							case PDO_ODBC_CONV_OK:
459 								P->len = ulen;
460 								memcpy(P->outbuf, S->convbuf, P->len);
461 								break;
462 						}
463 					} else {
464 						P->len = SQL_LEN_DATA_AT_EXEC(Z_STRLEN_P(param->parameter));
465 					}
466 				}
467 				return 1;
468 
469 			case PDO_PARAM_EVT_EXEC_POST:
470 				P = param->driver_data;
471 				if (P->outbuf) {
472 					if (P->outbuf) {
473 						unsigned long ulen;
474 						char *srcbuf;
475 						unsigned long srclen = 0;
476 
477 						switch (P->len) {
478 							case SQL_NULL_DATA:
479 								zval_dtor(param->parameter);
480 								ZVAL_NULL(param->parameter);
481 								break;
482 							default:
483 								convert_to_string(param->parameter);
484 								switch (pdo_odbc_ucs22utf8(stmt, P->is_unicode, P->outbuf, P->len, &ulen)) {
485 									case PDO_ODBC_CONV_FAIL:
486 										/* something fishy, but allow it to come back as binary */
487 									case PDO_ODBC_CONV_NOT_REQUIRED:
488 										srcbuf = P->outbuf;
489 										srclen = P->len;
490 										break;
491 									case PDO_ODBC_CONV_OK:
492 										srcbuf = S->convbuf;
493 										srclen = ulen;
494 										break;
495 								}
496 
497 								Z_STRVAL_P(param->parameter) = erealloc(Z_STRVAL_P(param->parameter), srclen+1);
498 								memcpy(Z_STRVAL_P(param->parameter), srcbuf, srclen);
499 								Z_STRLEN_P(param->parameter) = srclen;
500 								Z_STRVAL_P(param->parameter)[srclen] = '\0';
501 						}
502 					}
503 				}
504 				return 1;
505 		}
506 	}
507 	return 1;
508 }
509 
odbc_stmt_fetch(pdo_stmt_t * stmt,enum pdo_fetch_orientation ori,long offset TSRMLS_DC)510 static int odbc_stmt_fetch(pdo_stmt_t *stmt,
511 	enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
512 {
513 	RETCODE rc;
514 	SQLSMALLINT odbcori;
515 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
516 
517 	switch (ori) {
518 		case PDO_FETCH_ORI_NEXT:	odbcori = SQL_FETCH_NEXT; break;
519 		case PDO_FETCH_ORI_PRIOR:	odbcori = SQL_FETCH_PRIOR; break;
520 		case PDO_FETCH_ORI_FIRST:	odbcori = SQL_FETCH_FIRST; break;
521 		case PDO_FETCH_ORI_LAST:	odbcori = SQL_FETCH_LAST; break;
522 		case PDO_FETCH_ORI_ABS:		odbcori = SQL_FETCH_ABSOLUTE; break;
523 		case PDO_FETCH_ORI_REL:		odbcori = SQL_FETCH_RELATIVE; break;
524 		default:
525 			strcpy(stmt->error_code, "HY106");
526 			return 0;
527 	}
528 	rc = SQLFetchScroll(S->stmt, odbcori, offset);
529 
530 	if (rc == SQL_SUCCESS) {
531 		return 1;
532 	}
533 	if (rc == SQL_SUCCESS_WITH_INFO) {
534 		pdo_odbc_stmt_error("SQLFetchScroll");
535 		return 1;
536 	}
537 
538 	if (rc == SQL_NO_DATA) {
539 		/* pdo_odbc_stmt_error("SQLFetchScroll"); */
540 		return 0;
541 	}
542 
543 	pdo_odbc_stmt_error("SQLFetchScroll");
544 
545 	return 0;
546 }
547 
odbc_stmt_describe(pdo_stmt_t * stmt,int colno TSRMLS_DC)548 static int odbc_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
549 {
550 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
551 	struct pdo_column_data *col = &stmt->columns[colno];
552 	RETCODE rc;
553 	SWORD	colnamelen;
554 	SDWORD	colsize;
555 	SQLLEN displaysize;
556 
557 	rc = SQLDescribeCol(S->stmt, colno+1, S->cols[colno].colname,
558 			sizeof(S->cols[colno].colname)-1, &colnamelen,
559 			&S->cols[colno].coltype, &colsize, NULL, NULL);
560 
561 	if (rc != SQL_SUCCESS) {
562 		pdo_odbc_stmt_error("SQLDescribeCol");
563 		if (rc != SQL_SUCCESS_WITH_INFO) {
564 			return 0;
565 		}
566 	}
567 
568 	rc = SQLColAttribute(S->stmt, colno+1,
569 			SQL_DESC_DISPLAY_SIZE,
570 			NULL, 0, NULL, &displaysize);
571 
572 	if (rc != SQL_SUCCESS) {
573 		pdo_odbc_stmt_error("SQLColAttribute");
574 		if (rc != SQL_SUCCESS_WITH_INFO) {
575 			return 0;
576 		}
577 	}
578 	colsize = displaysize;
579 
580 	col->maxlen = S->cols[colno].datalen = colsize;
581 	col->namelen = colnamelen;
582 	col->name = estrdup(S->cols[colno].colname);
583 	S->cols[colno].is_unicode = pdo_odbc_sqltype_is_unicode(S, S->cols[colno].coltype);
584 
585 	/* returning data as a string */
586 	col->param_type = PDO_PARAM_STR;
587 
588 	/* tell ODBC to put it straight into our buffer, but only if it
589 	 * isn't "long" data, and only if we haven't already bound a long
590 	 * column. */
591 	if (colsize < 256 && !S->going_long) {
592 		S->cols[colno].data = emalloc(colsize+1);
593 		S->cols[colno].is_long = 0;
594 
595 		rc = SQLBindCol(S->stmt, colno+1,
596 			S->cols[colno].is_unicode ? SQL_C_BINARY : SQL_C_CHAR,
597 			S->cols[colno].data,
598  			S->cols[colno].datalen+1, &S->cols[colno].fetched_len);
599 
600 		if (rc != SQL_SUCCESS) {
601 			pdo_odbc_stmt_error("SQLBindCol");
602 			return 0;
603 		}
604 	} else {
605 		/* allocate a smaller buffer to keep around for smaller
606 		 * "long" columns */
607 		S->cols[colno].data = emalloc(256);
608 		S->going_long = 1;
609 		S->cols[colno].is_long = 1;
610 	}
611 
612 	return 1;
613 }
614 
odbc_stmt_get_col(pdo_stmt_t * stmt,int colno,char ** ptr,unsigned long * len,int * caller_frees TSRMLS_DC)615 static int odbc_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC)
616 {
617 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
618 	pdo_odbc_column *C = &S->cols[colno];
619 	unsigned long ulen;
620 
621 	/* if it is a column containing "long" data, perform late binding now */
622 	if (C->is_long) {
623 		unsigned long used = 0;
624 		char *buf;
625 		RETCODE rc;
626 
627 		/* fetch it into C->data, which is allocated with a length
628 		 * of 256 bytes; if there is more to be had, we then allocate
629 		 * bigger buffer for the caller to free */
630 
631 		rc = SQLGetData(S->stmt, colno+1, C->is_unicode ? SQL_C_BINARY : SQL_C_CHAR, C->data,
632  			256, &C->fetched_len);
633 
634 		if (rc == SQL_SUCCESS) {
635 			/* all the data fit into our little buffer;
636 			 * jump down to the generic bound data case */
637 			goto in_data;
638 		}
639 
640 		if (rc == SQL_SUCCESS_WITH_INFO) {
641 			/* this is a 'long column'
642 
643 			 read the column in 255 byte blocks until the end of the column is reached, reassembling those blocks
644 			 in order into the output buffer
645 
646 			 this loop has to work whether or not SQLGetData() provides the total column length.
647 			 calling SQLDescribeCol() or other, specifically to get the column length, then doing a single read
648 			 for that size would be slower except maybe for extremely long columns.*/
649 			char *buf2;
650 
651 			buf2 = emalloc(256);
652 			buf = estrndup(C->data, 256);
653 			used = 255; /* not 256; the driver NUL terminated the buffer */
654 
655 			do {
656 				C->fetched_len = 0;
657 				/* read block. 256 bytes => 255 bytes are actually read, the last 1 is NULL */
658 				rc = SQLGetData(S->stmt, colno+1, SQL_C_CHAR, buf2, 256, &C->fetched_len);
659 
660 				/* resize output buffer and reassemble block */
661 				if (rc==SQL_SUCCESS_WITH_INFO) {
662 					/* point 5, in section "Retrieving Data with SQLGetData" in http://msdn.microsoft.com/en-us/library/windows/desktop/ms715441(v=vs.85).aspx
663 					 states that if SQL_SUCCESS_WITH_INFO, fetched_len will be > 255 (greater than buf2's size)
664 					 (if a driver fails to follow that and wrote less than 255 bytes to buf2, this will AV or read garbage into buf) */
665 					buf = erealloc(buf, used + 255+1);
666 					memcpy(buf + used, buf2, 255);
667 					used = used + 255;
668 				} else if (rc==SQL_SUCCESS) {
669 					buf = erealloc(buf, used + C->fetched_len+1);
670 					memcpy(buf + used, buf2, C->fetched_len);
671 					used = used + C->fetched_len;
672 				} else {
673 					/* includes SQL_NO_DATA */
674 					break;
675 				}
676 
677 			} while (1);
678 
679 			efree(buf2);
680 
681 			/* NULL terminate the buffer once, when finished, for use with the rest of PHP */
682 			buf[used] = '\0';
683 
684 			*ptr = buf;
685 			*caller_frees = 1;
686 			*len = used;
687 			if (C->is_unicode) {
688 				goto unicode_conv;
689 			}
690 			return 1;
691 		}
692 
693 		/* something went caca */
694 		*ptr = NULL;
695 		*len = 0;
696 		return 1;
697 	}
698 
699 in_data:
700 	/* check the indicator to ensure that the data is intact */
701 	if (C->fetched_len == SQL_NULL_DATA) {
702 		/* A NULL value */
703 		*ptr = NULL;
704 		*len = 0;
705 		return 1;
706 	} else if (C->fetched_len >= 0) {
707 		/* it was stored perfectly */
708 		*ptr = C->data;
709 		*len = C->fetched_len;
710 		if (C->is_unicode) {
711 			goto unicode_conv;
712 		}
713 		return 1;
714 	} else {
715 		/* no data? */
716 		*ptr = NULL;
717 		*len = 0;
718 		return 1;
719 	}
720 
721 	unicode_conv:
722 	switch (pdo_odbc_ucs22utf8(stmt, C->is_unicode, *ptr, *len, &ulen)) {
723 		case PDO_ODBC_CONV_FAIL:
724 			/* oh well.  They can have the binary version of it */
725 		case PDO_ODBC_CONV_NOT_REQUIRED:
726 			/* shouldn't happen... */
727 			return 1;
728 
729 		case PDO_ODBC_CONV_OK:
730 			if (*caller_frees) {
731 				efree(*ptr);
732 			}
733 			*ptr = emalloc(ulen + 1);
734 			*len = ulen;
735 			memcpy(*ptr, S->convbuf, ulen+1);
736 			*caller_frees = 1;
737 			return 1;
738 	}
739 	return 1;
740 }
741 
odbc_stmt_set_param(pdo_stmt_t * stmt,long attr,zval * val TSRMLS_DC)742 static int odbc_stmt_set_param(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
743 {
744 	SQLRETURN rc;
745 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
746 
747 	switch (attr) {
748 		case PDO_ATTR_CURSOR_NAME:
749 			convert_to_string(val);
750 			rc = SQLSetCursorName(S->stmt, Z_STRVAL_P(val), Z_STRLEN_P(val));
751 
752 			if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
753 				return 1;
754 			}
755 			pdo_odbc_stmt_error("SQLSetCursorName");
756 			return 0;
757 
758 		case PDO_ODBC_ATTR_ASSUME_UTF8:
759 			S->assume_utf8 = zval_is_true(val);
760 			return 0;
761 		default:
762 			strcpy(S->einfo.last_err_msg, "Unknown Attribute");
763 			S->einfo.what = "setAttribute";
764 			strcpy(S->einfo.last_state, "IM001");
765 			return -1;
766 	}
767 }
768 
odbc_stmt_get_attr(pdo_stmt_t * stmt,long attr,zval * val TSRMLS_DC)769 static int odbc_stmt_get_attr(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
770 {
771 	SQLRETURN rc;
772 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
773 
774 	switch (attr) {
775 		case PDO_ATTR_CURSOR_NAME:
776 		{
777 			char buf[256];
778 			SQLSMALLINT len = 0;
779 			rc = SQLGetCursorName(S->stmt, buf, sizeof(buf), &len);
780 
781 			if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
782 				ZVAL_STRINGL(val, buf, len, 1);
783 				return 1;
784 			}
785 			pdo_odbc_stmt_error("SQLGetCursorName");
786 			return 0;
787 		}
788 
789 		case PDO_ODBC_ATTR_ASSUME_UTF8:
790 			ZVAL_BOOL(val, S->assume_utf8 ? 1 : 0);
791 			return 0;
792 
793 		default:
794 			strcpy(S->einfo.last_err_msg, "Unknown Attribute");
795 			S->einfo.what = "getAttribute";
796 			strcpy(S->einfo.last_state, "IM001");
797 			return -1;
798 	}
799 }
800 
odbc_stmt_next_rowset(pdo_stmt_t * stmt TSRMLS_DC)801 static int odbc_stmt_next_rowset(pdo_stmt_t *stmt TSRMLS_DC)
802 {
803 	SQLRETURN rc;
804 	SQLSMALLINT colcount;
805 	pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
806 
807 	/* NOTE: can't guarantee that output or input/output parameters
808 	 * are set until this fella returns SQL_NO_DATA, according to
809 	 * MSDN ODBC docs */
810 	rc = SQLMoreResults(S->stmt);
811 
812 	if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
813 		return 0;
814 	}
815 
816 	free_cols(stmt, S TSRMLS_CC);
817 	/* how many columns do we have ? */
818 	SQLNumResultCols(S->stmt, &colcount);
819 	stmt->column_count = (int)colcount;
820 	S->cols = ecalloc(colcount, sizeof(pdo_odbc_column));
821 	S->going_long = 0;
822 
823 	return 1;
824 }
825 
826 struct pdo_stmt_methods odbc_stmt_methods = {
827 	odbc_stmt_dtor,
828 	odbc_stmt_execute,
829 	odbc_stmt_fetch,
830 	odbc_stmt_describe,
831 	odbc_stmt_get_col,
832 	odbc_stmt_param_hook,
833 	odbc_stmt_set_param,
834 	odbc_stmt_get_attr, /* get attr */
835 	NULL, /* get column meta */
836 	odbc_stmt_next_rowset
837 };
838 
839 /*
840  * Local variables:
841  * tab-width: 4
842  * c-basic-offset: 4
843  * End:
844  * vim600: noet sw=4 ts=4 fdm=marker
845  * vim<600: noet sw=4 ts=4
846  */
847