Annotation of embedaddon/php/ext/mysqlnd/mysqlnd_wireprotocol.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 2006-2012 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: Georg Richter <georg@mysql.com> |
16: | Andrey Hristov <andrey@mysql.com> |
17: | Ulf Wendel <uwendel@mysql.com> |
18: +----------------------------------------------------------------------+
19: */
20: #include "php.h"
21: #include "php_globals.h"
22: #include "mysqlnd.h"
23: #include "mysqlnd_priv.h"
24: #include "mysqlnd_wireprotocol.h"
25: #include "mysqlnd_statistics.h"
26: #include "mysqlnd_debug.h"
27: #include "ext/standard/sha1.h"
28: #include "zend_ini.h"
29:
30: #define MYSQLND_SILENT 1
31:
32: #define MYSQLND_DUMP_HEADER_N_BODY
33:
34: #define PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_size, packet_type_as_text, packet_type) \
35: { \
36: DBG_INF_FMT("buf=%p size=%u", (buf), (buf_size)); \
37: if (FAIL == mysqlnd_read_header((conn), &((packet)->header) TSRMLS_CC)) {\
38: CONN_SET_STATE(conn, CONN_QUIT_SENT); \
39: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);\
40: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", mysqlnd_server_gone); \
41: DBG_ERR_FMT("Can't read %s's header", (packet_type_as_text)); \
42: DBG_RETURN(FAIL);\
43: }\
44: if ((buf_size) < (packet)->header.size) { \
45: DBG_ERR_FMT("Packet buffer %u wasn't big enough %u, %u bytes will be unread", \
46: (buf_size), (packet)->header.size, (packet)->header.size - (buf_size)); \
47: DBG_RETURN(FAIL); \
48: }\
49: if (FAIL == conn->net->m.receive((conn), (buf), (packet)->header.size TSRMLS_CC)) { \
50: CONN_SET_STATE(conn, CONN_QUIT_SENT); \
51: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);\
52: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", mysqlnd_server_gone); \
53: DBG_ERR_FMT("Empty '%s' packet body", (packet_type_as_text)); \
54: DBG_RETURN(FAIL);\
55: } \
56: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, packet_type_to_statistic_byte_count[packet_type], \
57: MYSQLND_HEADER_SIZE + (packet)->header.size, \
58: packet_type_to_statistic_packet_count[packet_type], \
59: 1); \
60: }
61:
62:
63: #define BAIL_IF_NO_MORE_DATA \
64: if ((size_t)(p - begin) > packet->header.size) { \
65: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Premature end of data (mysqlnd_wireprotocol.c:%u)", __LINE__); \
66: goto premature_end; \
67: } \
68:
69:
70: static const char *unknown_sqlstate= "HY000";
71:
72: const char * const mysqlnd_empty_string = "";
73:
74: /* Used in mysqlnd_debug.c */
75: const char mysqlnd_read_header_name[] = "mysqlnd_read_header";
76: const char mysqlnd_read_body_name[] = "mysqlnd_read_body";
77:
78:
79: #define ERROR_MARKER 0xFF
80: #define EODATA_MARKER 0xFE
81:
82: /* {{{ mysqlnd_command_to_text
83: */
84: const char * const mysqlnd_command_to_text[COM_END] =
85: {
86: "SLEEP", "QUIT", "INIT_DB", "QUERY", "FIELD_LIST",
87: "CREATE_DB", "DROP_DB", "REFRESH", "SHUTDOWN", "STATISTICS",
88: "PROCESS_INFO", "CONNECT", "PROCESS_KILL", "DEBUG", "PING",
89: "TIME", "DELAYED_INSERT", "CHANGE_USER", "BINLOG_DUMP",
90: "TABLE_DUMP", "CONNECT_OUT", "REGISTER_SLAVE",
91: "STMT_PREPARE", "STMT_EXECUTE", "STMT_SEND_LONG_DATA", "STMT_CLOSE",
92: "STMT_RESET", "SET_OPTION", "STMT_FETCH", "DAEMON"
93: };
94: /* }}} */
95:
96:
97:
98: static enum_mysqlnd_collected_stats packet_type_to_statistic_byte_count[PROT_LAST] =
99: {
100: STAT_LAST,
101: STAT_LAST,
102: STAT_BYTES_RECEIVED_OK,
103: STAT_BYTES_RECEIVED_EOF,
104: STAT_LAST,
105: STAT_BYTES_RECEIVED_RSET_HEADER,
106: STAT_BYTES_RECEIVED_RSET_FIELD_META,
107: STAT_BYTES_RECEIVED_RSET_ROW,
108: STAT_BYTES_RECEIVED_PREPARE_RESPONSE,
109: STAT_BYTES_RECEIVED_CHANGE_USER,
110: };
111:
112: static enum_mysqlnd_collected_stats packet_type_to_statistic_packet_count[PROT_LAST] =
113: {
114: STAT_LAST,
115: STAT_LAST,
116: STAT_PACKETS_RECEIVED_OK,
117: STAT_PACKETS_RECEIVED_EOF,
118: STAT_LAST,
119: STAT_PACKETS_RECEIVED_RSET_HEADER,
120: STAT_PACKETS_RECEIVED_RSET_FIELD_META,
121: STAT_PACKETS_RECEIVED_RSET_ROW,
122: STAT_PACKETS_RECEIVED_PREPARE_RESPONSE,
123: STAT_PACKETS_RECEIVED_CHANGE_USER,
124: };
125:
126:
127: /* {{{ php_mysqlnd_net_field_length
128: Get next field's length */
129: unsigned long
130: php_mysqlnd_net_field_length(zend_uchar **packet)
131: {
132: register zend_uchar *p= (zend_uchar *)*packet;
133:
134: if (*p < 251) {
135: (*packet)++;
136: return (unsigned long) *p;
137: }
138:
139: switch (*p) {
140: case 251:
141: (*packet)++;
142: return MYSQLND_NULL_LENGTH;
143: case 252:
144: (*packet) += 3;
145: return (unsigned long) uint2korr(p+1);
146: case 253:
147: (*packet) += 4;
148: return (unsigned long) uint3korr(p+1);
149: default:
150: (*packet) += 9;
151: return (unsigned long) uint4korr(p+1);
152: }
153: }
154: /* }}} */
155:
156:
157: /* {{{ php_mysqlnd_net_field_length_ll
158: Get next field's length */
159: uint64_t
160: php_mysqlnd_net_field_length_ll(zend_uchar **packet)
161: {
162: register zend_uchar *p= (zend_uchar *)*packet;
163:
164: if (*p < 251) {
165: (*packet)++;
166: return (uint64_t) *p;
167: }
168:
169: switch (*p) {
170: case 251:
171: (*packet)++;
172: return (uint64_t) MYSQLND_NULL_LENGTH;
173: case 252:
174: (*packet) += 3;
175: return (uint64_t) uint2korr(p + 1);
176: case 253:
177: (*packet) += 4;
178: return (uint64_t) uint3korr(p + 1);
179: default:
180: (*packet) += 9;
181: return (uint64_t) uint8korr(p + 1);
182: }
183: }
184: /* }}} */
185:
186:
187: /* {{{ php_mysqlnd_net_store_length */
188: zend_uchar *
189: php_mysqlnd_net_store_length(zend_uchar *packet, uint64_t length)
190: {
191: if (length < (uint64_t) L64(251)) {
192: *packet = (zend_uchar) length;
193: return packet + 1;
194: }
195:
196: if (length < (uint64_t) L64(65536)) {
197: *packet++ = 252;
198: int2store(packet,(unsigned int) length);
199: return packet + 2;
200: }
201:
202: if (length < (uint64_t) L64(16777216)) {
203: *packet++ = 253;
204: int3store(packet,(ulong) length);
205: return packet + 3;
206: }
207: *packet++ = 254;
208: int8store(packet, length);
209: return packet + 8;
210: }
211: /* }}} */
212:
213:
214: /* {{{ php_mysqlnd_read_error_from_line */
215: static enum_func_status
216: php_mysqlnd_read_error_from_line(zend_uchar *buf, size_t buf_len,
217: char *error, int error_buf_len,
218: unsigned int *error_no, char *sqlstate TSRMLS_DC)
219: {
220: zend_uchar *p = buf;
221: int error_msg_len= 0;
222:
223: DBG_ENTER("php_mysqlnd_read_error_from_line");
224:
225: *error_no = CR_UNKNOWN_ERROR;
226: memcpy(sqlstate, unknown_sqlstate, MYSQLND_SQLSTATE_LENGTH);
227:
228: if (buf_len > 2) {
229: *error_no = uint2korr(p);
230: p+= 2;
231: /*
232: sqlstate is following. No need to check for buf_left_len as we checked > 2 above,
233: if it was >=2 then we would need a check
234: */
235: if (*p == '#') {
236: ++p;
237: if ((buf_len - (p - buf)) >= MYSQLND_SQLSTATE_LENGTH) {
238: memcpy(sqlstate, p, MYSQLND_SQLSTATE_LENGTH);
239: p+= MYSQLND_SQLSTATE_LENGTH;
240: } else {
241: goto end;
242: }
243: }
244: if ((buf_len - (p - buf)) > 0) {
245: error_msg_len = MIN((int)((buf_len - (p - buf))), (int) (error_buf_len - 1));
246: memcpy(error, p, error_msg_len);
247: }
248: }
249: end:
250: sqlstate[MYSQLND_SQLSTATE_LENGTH] = '\0';
251: error[error_msg_len]= '\0';
252:
253: DBG_RETURN(FAIL);
254: }
255: /* }}} */
256:
257:
258: /* {{{ mysqlnd_read_header */
259: static enum_func_status
260: mysqlnd_read_header(MYSQLND * conn, MYSQLND_PACKET_HEADER * header TSRMLS_DC)
261: {
262: MYSQLND_NET * net = conn->net;
263: zend_uchar buffer[MYSQLND_HEADER_SIZE];
264:
265: DBG_ENTER("mysqlnd_read_header_name");
266: DBG_INF_FMT("compressed=%u conn_id=%u", net->compressed, conn->thread_id);
267: if (FAIL == net->m.receive(conn, buffer, MYSQLND_HEADER_SIZE TSRMLS_CC)) {
268: DBG_RETURN(FAIL);
269: }
270:
271: header->size = uint3korr(buffer);
272: header->packet_no = uint1korr(buffer + 3);
273:
274: #ifdef MYSQLND_DUMP_HEADER_N_BODY
275: DBG_INF_FMT("HEADER: prot_packet_no=%u size=%3u", header->packet_no, header->size);
276: #endif
277: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats,
278: STAT_PROTOCOL_OVERHEAD_IN, MYSQLND_HEADER_SIZE,
279: STAT_PACKETS_RECEIVED, 1);
280:
281: if (net->compressed || net->packet_no == header->packet_no) {
282: /*
283: Have to increase the number, so we can send correct number back. It will
284: round at 255 as this is unsigned char. The server needs this for simple
285: flow control checking.
286: */
287: net->packet_no++;
288: DBG_RETURN(PASS);
289: }
290:
291: DBG_ERR_FMT("Logical link: packets out of order. Expected %u received %u. Packet size="MYSQLND_SZ_T_SPEC,
292: net->packet_no, header->packet_no, header->size);
293:
294: php_error(E_WARNING, "Packets out of order. Expected %u received %u. Packet size="MYSQLND_SZ_T_SPEC,
295: net->packet_no, header->packet_no, header->size);
296: DBG_RETURN(FAIL);
297: }
298: /* }}} */
299:
300:
301: /* {{{ php_mysqlnd_greet_read */
302: static enum_func_status
303: php_mysqlnd_greet_read(void *_packet, MYSQLND *conn TSRMLS_DC)
304: {
305: zend_uchar buf[2048];
306: zend_uchar *p = buf;
307: zend_uchar *begin = buf;
308: MYSQLND_PACKET_GREET *packet= (MYSQLND_PACKET_GREET *) _packet;
309:
310: DBG_ENTER("php_mysqlnd_greet_read");
311:
312: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, sizeof(buf), "greeting", PROT_GREET_PACKET);
313: BAIL_IF_NO_MORE_DATA;
314:
315: packet->protocol_version = uint1korr(p);
316: p++;
317: BAIL_IF_NO_MORE_DATA;
318:
319: if (ERROR_MARKER == packet->protocol_version) {
320: php_mysqlnd_read_error_from_line(p, packet->header.size - 1,
321: packet->error, sizeof(packet->error),
322: &packet->error_no, packet->sqlstate
323: TSRMLS_CC);
324: /*
325: The server doesn't send sqlstate in the greet packet.
326: It's a bug#26426 , so we have to set it correctly ourselves.
327: It's probably "Too many connections, which has SQL state 08004".
328: */
329: if (packet->error_no == 1040) {
330: memcpy(packet->sqlstate, "08004", MYSQLND_SQLSTATE_LENGTH);
331: }
332: DBG_RETURN(PASS);
333: }
334:
335: packet->server_version = estrdup((char *)p);
336: p+= strlen(packet->server_version) + 1; /* eat the '\0' */
337: BAIL_IF_NO_MORE_DATA;
338:
339: packet->thread_id = uint4korr(p);
340: p+=4;
341: BAIL_IF_NO_MORE_DATA;
342:
343: memcpy(packet->scramble_buf, p, SCRAMBLE_LENGTH_323);
344: p+= 8;
345: BAIL_IF_NO_MORE_DATA;
346:
347: /* pad1 */
348: p++;
349: BAIL_IF_NO_MORE_DATA;
350:
351: packet->server_capabilities = uint2korr(p);
352: p+= 2;
353: BAIL_IF_NO_MORE_DATA;
354:
355: packet->charset_no = uint1korr(p);
356: p++;
357: BAIL_IF_NO_MORE_DATA;
358:
359: packet->server_status = uint2korr(p);
360: p+= 2;
361: BAIL_IF_NO_MORE_DATA;
362:
363: /* pad2 */
364: p+= 13;
365: BAIL_IF_NO_MORE_DATA;
366:
367: if ((size_t) (p - buf) < packet->header.size) {
368: /* scramble_buf is split into two parts */
369: memcpy(packet->scramble_buf + SCRAMBLE_LENGTH_323,
370: p, SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
371: } else {
372: packet->pre41 = TRUE;
373: }
374:
375: DBG_INF_FMT("proto=%u server=%s thread_id=%u",
376: packet->protocol_version, packet->server_version, packet->thread_id);
377:
378: DBG_INF_FMT("server_capabilities=%u charset_no=%u server_status=%i",
379: packet->server_capabilities, packet->charset_no, packet->server_status);
380:
381: DBG_RETURN(PASS);
382: premature_end:
383: DBG_ERR_FMT("GREET packet %d bytes shorter than expected", p - begin - packet->header.size);
384: php_error_docref(NULL TSRMLS_CC, E_WARNING, "GREET packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
385: p - begin - packet->header.size);
386: DBG_RETURN(FAIL);
387: }
388: /* }}} */
389:
390:
391: /* {{{ php_mysqlnd_greet_free_mem */
392: static
393: void php_mysqlnd_greet_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
394: {
395: MYSQLND_PACKET_GREET *p= (MYSQLND_PACKET_GREET *) _packet;
396: if (p->server_version) {
397: efree(p->server_version);
398: p->server_version = NULL;
399: }
400: if (!stack_allocation) {
401: mnd_pefree(p, p->header.persistent);
402: }
403: }
404: /* }}} */
405:
406:
407: /* {{{ php_mysqlnd_crypt */
408: static void
409: php_mysqlnd_crypt(zend_uchar *buffer, const zend_uchar *s1, const zend_uchar *s2, size_t len)
410: {
411: const zend_uchar *s1_end = s1 + len;
412: while (s1 < s1_end) {
413: *buffer++= *s1++ ^ *s2++;
414: }
415: }
416: /* }}} */
417:
418:
419: /* {{{ php_mysqlnd_scramble */
420: void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const scramble, const zend_uchar * const password)
421: {
422: PHP_SHA1_CTX context;
423: zend_uchar sha1[SHA1_MAX_LENGTH];
424: zend_uchar sha2[SHA1_MAX_LENGTH];
425:
426:
427: /* Phase 1: hash password */
428: PHP_SHA1Init(&context);
429: PHP_SHA1Update(&context, password, strlen((char *)password));
430: PHP_SHA1Final(sha1, &context);
431:
432: /* Phase 2: hash sha1 */
433: PHP_SHA1Init(&context);
434: PHP_SHA1Update(&context, (zend_uchar*)sha1, SHA1_MAX_LENGTH);
435: PHP_SHA1Final(sha2, &context);
436:
437: /* Phase 3: hash scramble + sha2 */
438: PHP_SHA1Init(&context);
439: PHP_SHA1Update(&context, scramble, SCRAMBLE_LENGTH);
440: PHP_SHA1Update(&context, (zend_uchar*)sha2, SHA1_MAX_LENGTH);
441: PHP_SHA1Final(buffer, &context);
442:
443: /* let's crypt buffer now */
444: php_mysqlnd_crypt(buffer, (const zend_uchar *)buffer, (const zend_uchar *)sha1, SHA1_MAX_LENGTH);
445: }
446: /* }}} */
447:
448:
449: #define AUTH_WRITE_BUFFER_LEN (MYSQLND_HEADER_SIZE + MYSQLND_MAX_ALLOWED_USER_LEN + SHA1_MAX_LENGTH + MYSQLND_MAX_ALLOWED_DB_LEN + 1 + 128)
450:
451: /* {{{ php_mysqlnd_auth_write */
452: static
453: size_t php_mysqlnd_auth_write(void *_packet, MYSQLND * conn TSRMLS_DC)
454: {
455: char buffer[AUTH_WRITE_BUFFER_LEN];
456: register char *p= buffer + MYSQLND_HEADER_SIZE; /* start after the header */
457: int len;
458: register MYSQLND_PACKET_AUTH *packet= (MYSQLND_PACKET_AUTH *) _packet;
459:
460: DBG_ENTER("php_mysqlnd_auth_write");
461:
462: int4store(p, packet->client_flags);
463: p+= 4;
464:
465: int4store(p, packet->max_packet_size);
466: p+= 4;
467:
468: int1store(p, packet->charset_no);
469: p++;
470:
471: memset(p, 0, 23); /* filler */
472: p+= 23;
473:
474: if (!packet->send_half_packet) {
475: len = MIN(strlen(packet->user), MYSQLND_MAX_ALLOWED_USER_LEN);
476: memcpy(p, packet->user, len);
477: p+= len;
478: *p++ = '\0';
479:
480: /* copy scrambled pass*/
481: if (packet->password && packet->password[0]) {
482: /* In 4.1 we use CLIENT_SECURE_CONNECTION and thus the len of the buf should be passed */
483: int1store(p, SHA1_MAX_LENGTH);
484: p++;
485: php_mysqlnd_scramble((zend_uchar*)p, packet->server_scramble_buf, (zend_uchar*)packet->password);
486: p+= SHA1_MAX_LENGTH;
487: } else {
488: /* Zero length */
489: int1store(p, 0);
490: p++;
491: }
492:
493: if (packet->db) {
494: size_t real_db_len = MIN(MYSQLND_MAX_ALLOWED_DB_LEN, packet->db_len);
495: memcpy(p, packet->db, real_db_len);
496: p+= real_db_len;
497: *p++= '\0';
498: }
499: /* Handle CLIENT_CONNECT_WITH_DB */
500: /* no \0 for no DB */
501: }
502:
503: DBG_RETURN(conn->net->m.send(conn, buffer, p - buffer - MYSQLND_HEADER_SIZE TSRMLS_CC));
504: }
505: /* }}} */
506:
507:
508: /* {{{ php_mysqlnd_auth_free_mem */
509: static
510: void php_mysqlnd_auth_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
511: {
512: if (!stack_allocation) {
513: MYSQLND_PACKET_AUTH * p = (MYSQLND_PACKET_AUTH *) _packet;
514: mnd_pefree(p, p->header.persistent);
515: }
516: }
517: /* }}} */
518:
519:
520: #define OK_BUFFER_SIZE 2048
521:
522: /* {{{ php_mysqlnd_ok_read */
523: static enum_func_status
524: php_mysqlnd_ok_read(void *_packet, MYSQLND *conn TSRMLS_DC)
525: {
526: zend_uchar local_buf[OK_BUFFER_SIZE];
527: size_t buf_len = conn->net->cmd_buffer.buffer? conn->net->cmd_buffer.length : OK_BUFFER_SIZE;
528: zend_uchar *buf = conn->net->cmd_buffer.buffer? (zend_uchar *) conn->net->cmd_buffer.buffer : local_buf;
529: zend_uchar *p = buf;
530: zend_uchar *begin = buf;
531: unsigned long i;
532: register MYSQLND_PACKET_OK *packet= (MYSQLND_PACKET_OK *) _packet;
533:
534: DBG_ENTER("php_mysqlnd_ok_read");
535:
536: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "OK", PROT_OK_PACKET);
537: BAIL_IF_NO_MORE_DATA;
538:
539: /* Should be always 0x0 or ERROR_MARKER for error */
540: packet->field_count = uint1korr(p);
541: p++;
542: BAIL_IF_NO_MORE_DATA;
543:
544: if (ERROR_MARKER == packet->field_count) {
545: php_mysqlnd_read_error_from_line(p, packet->header.size - 1,
546: packet->error, sizeof(packet->error),
547: &packet->error_no, packet->sqlstate
548: TSRMLS_CC);
549: DBG_RETURN(PASS);
550: }
551: /* Everything was fine! */
552: packet->affected_rows = php_mysqlnd_net_field_length_ll(&p);
553: BAIL_IF_NO_MORE_DATA;
554:
555: packet->last_insert_id = php_mysqlnd_net_field_length_ll(&p);
556: BAIL_IF_NO_MORE_DATA;
557:
558: packet->server_status = uint2korr(p);
559: p+= 2;
560: BAIL_IF_NO_MORE_DATA;
561:
562: packet->warning_count = uint2korr(p);
563: p+= 2;
564: BAIL_IF_NO_MORE_DATA;
565:
566: /* There is a message */
567: if (packet->header.size > (size_t) (p - buf) && (i = php_mysqlnd_net_field_length(&p))) {
568: packet->message_len = MIN(i, buf_len - (p - begin));
569: packet->message = mnd_pestrndup((char *)p, packet->message_len, FALSE);
570: } else {
571: packet->message = NULL;
572: packet->message_len = 0;
573: }
574:
575: DBG_INF_FMT("OK packet: aff_rows=%lld last_ins_id=%ld server_status=%u warnings=%u",
576: packet->affected_rows, packet->last_insert_id, packet->server_status,
577: packet->warning_count);
578:
579: BAIL_IF_NO_MORE_DATA;
580:
581: DBG_RETURN(PASS);
582: premature_end:
583: DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size);
584: php_error_docref(NULL TSRMLS_CC, E_WARNING, "OK packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
585: p - begin - packet->header.size);
586: DBG_RETURN(FAIL);
587: }
588: /* }}} */
589:
590:
591: /* {{{ php_mysqlnd_ok_free_mem */
592: static void
593: php_mysqlnd_ok_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
594: {
595: MYSQLND_PACKET_OK *p= (MYSQLND_PACKET_OK *) _packet;
596: if (p->message) {
597: mnd_efree(p->message);
598: p->message = NULL;
599: }
600: if (!stack_allocation) {
601: mnd_pefree(p, p->header.persistent);
602: }
603: }
604: /* }}} */
605:
606:
607: /* {{{ php_mysqlnd_eof_read */
608: static enum_func_status
609: php_mysqlnd_eof_read(void *_packet, MYSQLND *conn TSRMLS_DC)
610: {
611: /*
612: EOF packet is since 4.1 five bytes long,
613: but we can get also an error, make it bigger.
614:
615: Error : error_code + '#' + sqlstate + MYSQLND_ERRMSG_SIZE
616: */
617: MYSQLND_PACKET_EOF *packet= (MYSQLND_PACKET_EOF *) _packet;
618: size_t buf_len = conn->net->cmd_buffer.length;
619: zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
620: zend_uchar *p = buf;
621: zend_uchar *begin = buf;
622:
623: DBG_ENTER("php_mysqlnd_eof_read");
624:
625: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "EOF", PROT_EOF_PACKET);
626: BAIL_IF_NO_MORE_DATA;
627:
628: /* Should be always EODATA_MARKER */
629: packet->field_count = uint1korr(p);
630: p++;
631: BAIL_IF_NO_MORE_DATA;
632:
633: if (ERROR_MARKER == packet->field_count) {
634: php_mysqlnd_read_error_from_line(p, packet->header.size - 1,
635: packet->error, sizeof(packet->error),
636: &packet->error_no, packet->sqlstate
637: TSRMLS_CC);
638: DBG_RETURN(PASS);
639: }
640:
641: /*
642: 4.1 sends 1 byte EOF packet after metadata of
643: PREPARE/EXECUTE but 5 bytes after the result. This is not
644: according to the Docs@Forge!!!
645: */
646: if (packet->header.size > 1) {
647: packet->warning_count = uint2korr(p);
648: p+= 2;
649: BAIL_IF_NO_MORE_DATA;
650:
651: packet->server_status = uint2korr(p);
652: p+= 2;
653: BAIL_IF_NO_MORE_DATA;
654: } else {
655: packet->warning_count = 0;
656: packet->server_status = 0;
657: }
658:
659: BAIL_IF_NO_MORE_DATA;
660:
661: DBG_INF_FMT("EOF packet: fields=%u status=%u warnings=%u",
662: packet->field_count, packet->server_status, packet->warning_count);
663:
664: DBG_RETURN(PASS);
665: premature_end:
666: DBG_ERR_FMT("EOF packet %d bytes shorter than expected", p - begin - packet->header.size);
667: php_error_docref(NULL TSRMLS_CC, E_WARNING, "EOF packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
668: p - begin - packet->header.size);
669: DBG_RETURN(FAIL);
670: }
671: /* }}} */
672:
673:
674: /* {{{ php_mysqlnd_eof_free_mem */
675: static
676: void php_mysqlnd_eof_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
677: {
678: if (!stack_allocation) {
679: mnd_pefree(_packet, ((MYSQLND_PACKET_EOF *)_packet)->header.persistent);
680: }
681: }
682: /* }}} */
683:
684:
685: /* {{{ php_mysqlnd_cmd_write */
686: size_t php_mysqlnd_cmd_write(void *_packet, MYSQLND *conn TSRMLS_DC)
687: {
688: /* Let's have some space, which we can use, if not enough, we will allocate new buffer */
689: MYSQLND_PACKET_COMMAND *packet= (MYSQLND_PACKET_COMMAND *) _packet;
690: MYSQLND_NET *net = conn->net;
691: unsigned int error_reporting = EG(error_reporting);
692: size_t written = 0;
693:
694: DBG_ENTER("php_mysqlnd_cmd_write");
695: /*
696: Reset packet_no, or we will get bad handshake!
697: Every command starts a new TX and packet numbers are reset to 0.
698: */
699: net->packet_no = 0;
700: net->compressed_envelope_packet_no = 0; /* this is for the response */
701:
702: if (error_reporting) {
703: EG(error_reporting) = 0;
704: }
705:
706: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_PACKETS_SENT_CMD);
707:
708: #ifdef MYSQLND_DO_WIRE_CHECK_BEFORE_COMMAND
709: net->m.consume_uneaten_data(net, packet->command TSRMLS_CC);
710: #endif
711:
712: if (!packet->argument || !packet->arg_len) {
713: char buffer[MYSQLND_HEADER_SIZE + 1];
714:
715: int1store(buffer + MYSQLND_HEADER_SIZE, packet->command);
716: written = conn->net->m.send(conn, buffer, 1 TSRMLS_CC);
717: } else {
718: size_t tmp_len = packet->arg_len + 1 + MYSQLND_HEADER_SIZE, ret;
719: zend_uchar *tmp, *p;
720: tmp = (tmp_len > net->cmd_buffer.length)? mnd_emalloc(tmp_len):net->cmd_buffer.buffer;
721: if (!tmp) {
722: goto end;
723: }
724: p = tmp + MYSQLND_HEADER_SIZE; /* skip the header */
725:
726: int1store(p, packet->command);
727: p++;
728:
729: memcpy(p, packet->argument, packet->arg_len);
730:
731: ret = conn->net->m.send(conn, (char *)tmp, tmp_len - MYSQLND_HEADER_SIZE TSRMLS_CC);
732: if (tmp != net->cmd_buffer.buffer) {
733: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CMD_BUFFER_TOO_SMALL);
734: mnd_efree(tmp);
735: }
736: written = ret;
737: }
738: end:
739: if (error_reporting) {
740: /* restore error reporting */
741: EG(error_reporting) = error_reporting;
742: }
743: DBG_RETURN(written);
744: }
745: /* }}} */
746:
747:
748: /* {{{ php_mysqlnd_cmd_free_mem */
749: static
750: void php_mysqlnd_cmd_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
751: {
752: if (!stack_allocation) {
753: MYSQLND_PACKET_COMMAND * p = (MYSQLND_PACKET_COMMAND *) _packet;
754: mnd_pefree(p, p->header.persistent);
755: }
756: }
757: /* }}} */
758:
759:
760: /* {{{ php_mysqlnd_rset_header_read */
761: static enum_func_status
762: php_mysqlnd_rset_header_read(void *_packet, MYSQLND *conn TSRMLS_DC)
763: {
764: enum_func_status ret = PASS;
765: size_t buf_len = conn->net->cmd_buffer.length;
766: zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
767: zend_uchar *p = buf;
768: zend_uchar *begin = buf;
769: size_t len;
770: MYSQLND_PACKET_RSET_HEADER *packet= (MYSQLND_PACKET_RSET_HEADER *) _packet;
771:
772: DBG_ENTER("php_mysqlnd_rset_header_read");
773:
774: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "resultset header", PROT_RSET_HEADER_PACKET);
775: BAIL_IF_NO_MORE_DATA;
776:
777: /*
778: Don't increment. First byte is ERROR_MARKER on error, but otherwise is starting byte
779: of encoded sequence for length.
780: */
781: if (ERROR_MARKER == *p) {
782: /* Error */
783: p++;
784: BAIL_IF_NO_MORE_DATA;
785: php_mysqlnd_read_error_from_line(p, packet->header.size - 1,
786: packet->error_info.error, sizeof(packet->error_info.error),
787: &packet->error_info.error_no, packet->error_info.sqlstate
788: TSRMLS_CC);
789: DBG_RETURN(PASS);
790: }
791:
792: packet->field_count = php_mysqlnd_net_field_length(&p);
793: BAIL_IF_NO_MORE_DATA;
794:
795: switch (packet->field_count) {
796: case MYSQLND_NULL_LENGTH:
797: DBG_INF("LOAD LOCAL");
798: /*
799: First byte in the packet is the field count.
800: Thus, the name is size - 1. And we add 1 for a trailing \0.
801: Because we have BAIL_IF_NO_MORE_DATA before the switch, we are guaranteed
802: that packet->header.size is > 0. Which means that len can't underflow, that
803: would lead to 0 byte allocation but 2^32 or 2^64 bytes copied.
804: */
805: len = packet->header.size - 1;
806: packet->info_or_local_file = mnd_emalloc(len + 1);
807: if (packet->info_or_local_file) {
808: memcpy(packet->info_or_local_file, p, len);
809: packet->info_or_local_file[len] = '\0';
810: packet->info_or_local_file_len = len;
811: } else {
812: SET_OOM_ERROR(conn->error_info);
813: ret = FAIL;
814: }
815: break;
816: case 0x00:
817: DBG_INF("UPSERT");
818: packet->affected_rows = php_mysqlnd_net_field_length_ll(&p);
819: BAIL_IF_NO_MORE_DATA;
820:
821: packet->last_insert_id = php_mysqlnd_net_field_length_ll(&p);
822: BAIL_IF_NO_MORE_DATA;
823:
824: packet->server_status = uint2korr(p);
825: p+=2;
826: BAIL_IF_NO_MORE_DATA;
827:
828: packet->warning_count = uint2korr(p);
829: p+=2;
830: BAIL_IF_NO_MORE_DATA;
831: /* Check for additional textual data */
832: if (packet->header.size > (size_t) (p - buf) && (len = php_mysqlnd_net_field_length(&p))) {
833: packet->info_or_local_file = mnd_emalloc(len + 1);
834: if (packet->info_or_local_file) {
835: memcpy(packet->info_or_local_file, p, len);
836: packet->info_or_local_file[len] = '\0';
837: packet->info_or_local_file_len = len;
838: } else {
839: SET_OOM_ERROR(conn->error_info);
840: ret = FAIL;
841: }
842: }
843: DBG_INF_FMT("affected_rows=%llu last_insert_id=%llu server_status=%u warning_count=%u",
844: packet->affected_rows, packet->last_insert_id,
845: packet->server_status, packet->warning_count);
846: break;
847: default:
848: DBG_INF("SELECT");
849: /* Result set */
850: break;
851: }
852: BAIL_IF_NO_MORE_DATA;
853:
854: DBG_RETURN(ret);
855: premature_end:
856: DBG_ERR_FMT("RSET_HEADER packet %d bytes shorter than expected", p - begin - packet->header.size);
857: php_error_docref(NULL TSRMLS_CC, E_WARNING, "RSET_HEADER packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
858: p - begin - packet->header.size);
859: DBG_RETURN(FAIL);
860: }
861: /* }}} */
862:
863:
864: /* {{{ php_mysqlnd_rset_header_free_mem */
865: static
866: void php_mysqlnd_rset_header_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
867: {
868: MYSQLND_PACKET_RSET_HEADER *p= (MYSQLND_PACKET_RSET_HEADER *) _packet;
869: DBG_ENTER("php_mysqlnd_rset_header_free_mem");
870: if (p->info_or_local_file) {
871: mnd_efree(p->info_or_local_file);
872: p->info_or_local_file = NULL;
873: }
874: if (!stack_allocation) {
875: mnd_pefree(p, p->header.persistent);
876: }
877: DBG_VOID_RETURN;
878: }
879: /* }}} */
880:
881: static size_t rset_field_offsets[] =
882: {
883: STRUCT_OFFSET(MYSQLND_FIELD, catalog),
884: STRUCT_OFFSET(MYSQLND_FIELD, catalog_length),
885: STRUCT_OFFSET(MYSQLND_FIELD, db),
886: STRUCT_OFFSET(MYSQLND_FIELD, db_length),
887: STRUCT_OFFSET(MYSQLND_FIELD, table),
888: STRUCT_OFFSET(MYSQLND_FIELD, table_length),
889: STRUCT_OFFSET(MYSQLND_FIELD, org_table),
890: STRUCT_OFFSET(MYSQLND_FIELD, org_table_length),
891: STRUCT_OFFSET(MYSQLND_FIELD, name),
892: STRUCT_OFFSET(MYSQLND_FIELD, name_length),
893: STRUCT_OFFSET(MYSQLND_FIELD, org_name),
894: STRUCT_OFFSET(MYSQLND_FIELD, org_name_length)
895: };
896:
897:
898: /* {{{ php_mysqlnd_rset_field_read */
899: static enum_func_status
900: php_mysqlnd_rset_field_read(void *_packet, MYSQLND *conn TSRMLS_DC)
901: {
902: /* Should be enough for the metadata of a single row */
903: MYSQLND_PACKET_RES_FIELD *packet= (MYSQLND_PACKET_RES_FIELD *) _packet;
904: size_t buf_len = conn->net->cmd_buffer.length, total_len = 0;
905: zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
906: zend_uchar *p = buf;
907: zend_uchar *begin = buf;
908: char *root_ptr;
909: unsigned long len;
910: MYSQLND_FIELD *meta;
911: unsigned int i, field_count = sizeof(rset_field_offsets)/sizeof(size_t);
912:
913: DBG_ENTER("php_mysqlnd_rset_field_read");
914:
915: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "field", PROT_RSET_FLD_PACKET);
916:
917: if (packet->skip_parsing) {
918: DBG_RETURN(PASS);
919: }
920:
921: BAIL_IF_NO_MORE_DATA;
922: if (ERROR_MARKER == *p) {
923: /* Error */
924: p++;
925: BAIL_IF_NO_MORE_DATA;
926: php_mysqlnd_read_error_from_line(p, packet->header.size - 1,
927: packet->error_info.error, sizeof(packet->error_info.error),
928: &packet->error_info.error_no, packet->error_info.sqlstate
929: TSRMLS_CC);
930: DBG_ERR_FMT("Server error : (%u) %s", packet->error_info.error_no, packet->error_info.error);
931: DBG_RETURN(PASS);
932: } else if (EODATA_MARKER == *p && packet->header.size < 8) {
933: /* Premature EOF. That should be COM_FIELD_LIST */
934: DBG_INF("Premature EOF. That should be COM_FIELD_LIST");
935: packet->stupid_list_fields_eof = TRUE;
936: DBG_RETURN(PASS);
937: }
938:
939: meta = packet->metadata;
940:
941: for (i = 0; i < field_count; i += 2) {
942: len = php_mysqlnd_net_field_length(&p);
943: BAIL_IF_NO_MORE_DATA;
944: switch ((len)) {
945: case 0:
946: *(const char **)(((char*)meta) + rset_field_offsets[i]) = mysqlnd_empty_string;
947: *(unsigned int *)(((char*)meta) + rset_field_offsets[i+1]) = 0;
948: break;
949: case MYSQLND_NULL_LENGTH:
950: goto faulty_or_fake;
951: default:
952: *(const char **)(((char *)meta) + rset_field_offsets[i]) = (const char *)p;
953: *(unsigned int *)(((char*)meta) + rset_field_offsets[i+1]) = len;
954: p += len;
955: total_len += len + 1;
956: break;
957: }
958: BAIL_IF_NO_MORE_DATA;
959: }
960:
961: /* 1 byte filler */
962: p++;
963: BAIL_IF_NO_MORE_DATA;
964:
965: meta->charsetnr = uint2korr(p);
966: p += 2;
967: BAIL_IF_NO_MORE_DATA;
968:
969: meta->length = uint4korr(p);
970: p += 4;
971: BAIL_IF_NO_MORE_DATA;
972:
973: meta->type = uint1korr(p);
974: p += 1;
975: BAIL_IF_NO_MORE_DATA;
976:
977: meta->flags = uint2korr(p);
978: p += 2;
979: BAIL_IF_NO_MORE_DATA;
980:
981: meta->decimals = uint2korr(p);
982: p += 1;
983: BAIL_IF_NO_MORE_DATA;
984:
985: /* 2 byte filler */
986: p +=2;
987: BAIL_IF_NO_MORE_DATA;
988:
989: /* Should we set NUM_FLAG (libmysql does it) ? */
990: if (
991: (meta->type <= MYSQL_TYPE_INT24 &&
992: (meta->type != MYSQL_TYPE_TIMESTAMP || meta->length == 14 || meta->length == 8)
993: ) || meta->type == MYSQL_TYPE_YEAR)
994: {
995: meta->flags |= NUM_FLAG;
996: }
997:
998:
999: /*
1000: def could be empty, thus don't allocate on the root.
1001: NULL_LENGTH (0xFB) comes from COM_FIELD_LIST when the default value is NULL.
1002: Otherwise the string is length encoded.
1003: */
1004: if (packet->header.size > (size_t) (p - buf) &&
1005: (len = php_mysqlnd_net_field_length(&p)) &&
1006: len != MYSQLND_NULL_LENGTH)
1007: {
1008: BAIL_IF_NO_MORE_DATA;
1009: DBG_INF_FMT("Def found, length %lu, persistent=%u", len, packet->persistent_alloc);
1010: meta->def = mnd_pemalloc(len + 1, packet->persistent_alloc);
1011: if (!meta->def) {
1012: SET_OOM_ERROR(conn->error_info);
1013: DBG_RETURN(FAIL);
1014: }
1015: memcpy(meta->def, p, len);
1016: meta->def[len] = '\0';
1017: meta->def_length = len;
1018: p += len;
1019: }
1020:
1021: DBG_INF_FMT("allocing root. persistent=%u", packet->persistent_alloc);
1022: root_ptr = meta->root = mnd_pemalloc(total_len, packet->persistent_alloc);
1023: if (!root_ptr) {
1024: SET_OOM_ERROR(conn->error_info);
1025: DBG_RETURN(FAIL);
1026: }
1027:
1028: meta->root_len = total_len;
1029: /* Now do allocs */
1030: if (meta->catalog && meta->catalog != mysqlnd_empty_string) {
1031: len = meta->catalog_length;
1032: meta->catalog = memcpy(root_ptr, meta->catalog, len);
1033: *(root_ptr +=len) = '\0';
1034: root_ptr++;
1035: }
1036:
1037: if (meta->db && meta->db != mysqlnd_empty_string) {
1038: len = meta->db_length;
1039: meta->db = memcpy(root_ptr, meta->db, len);
1040: *(root_ptr +=len) = '\0';
1041: root_ptr++;
1042: }
1043:
1044: if (meta->table && meta->table != mysqlnd_empty_string) {
1045: len = meta->table_length;
1046: meta->table = memcpy(root_ptr, meta->table, len);
1047: *(root_ptr +=len) = '\0';
1048: root_ptr++;
1049: }
1050:
1051: if (meta->org_table && meta->org_table != mysqlnd_empty_string) {
1052: len = meta->org_table_length;
1053: meta->org_table = memcpy(root_ptr, meta->org_table, len);
1054: *(root_ptr +=len) = '\0';
1055: root_ptr++;
1056: }
1057:
1058: if (meta->name && meta->name != mysqlnd_empty_string) {
1059: len = meta->name_length;
1060: meta->name = memcpy(root_ptr, meta->name, len);
1061: *(root_ptr +=len) = '\0';
1062: root_ptr++;
1063: }
1064:
1065: if (meta->org_name && meta->org_name != mysqlnd_empty_string) {
1066: len = meta->org_name_length;
1067: meta->org_name = memcpy(root_ptr, meta->org_name, len);
1068: *(root_ptr +=len) = '\0';
1069: root_ptr++;
1070: }
1071:
1072: DBG_INF_FMT("FIELD=[%s.%s.%s]", meta->db? meta->db:"*NA*", meta->table? meta->table:"*NA*",
1073: meta->name? meta->name:"*NA*");
1074:
1075: DBG_RETURN(PASS);
1076:
1077: faulty_or_fake:
1078: DBG_ERR_FMT("Protocol error. Server sent NULL_LENGTH. The server is faulty");
1079: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Protocol error. Server sent NULL_LENGTH."
1080: " The server is faulty");
1081: DBG_RETURN(FAIL);
1082: premature_end:
1083: DBG_ERR_FMT("RSET field packet %d bytes shorter than expected", p - begin - packet->header.size);
1084: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Result set field packet "MYSQLND_SZ_T_SPEC" bytes "
1085: "shorter than expected", p - begin - packet->header.size);
1086: DBG_RETURN(FAIL);
1087: }
1088: /* }}} */
1089:
1090:
1091: /* {{{ php_mysqlnd_rset_field_free_mem */
1092: static
1093: void php_mysqlnd_rset_field_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
1094: {
1095: MYSQLND_PACKET_RES_FIELD *p= (MYSQLND_PACKET_RES_FIELD *) _packet;
1096: /* p->metadata was passed to us as temporal buffer */
1097: if (!stack_allocation) {
1098: mnd_pefree(p, p->header.persistent);
1099: }
1100: }
1101: /* }}} */
1102:
1103:
1104: /* {{{ php_mysqlnd_read_row_ex */
1105: static enum_func_status
1106: php_mysqlnd_read_row_ex(MYSQLND * conn, MYSQLND_MEMORY_POOL * result_set_memory_pool,
1107: MYSQLND_MEMORY_POOL_CHUNK **buffer,
1108: size_t *data_size, zend_bool persistent_alloc,
1109: unsigned int prealloc_more_bytes TSRMLS_DC)
1110: {
1111: enum_func_status ret = PASS;
1112: MYSQLND_PACKET_HEADER header;
1113: zend_uchar *p = NULL;
1114: zend_bool first_iteration = TRUE;
1115:
1116: DBG_ENTER("php_mysqlnd_read_row_ex");
1117:
1118: /*
1119: To ease the process the server splits everything in packets up to 2^24 - 1.
1120: Even in the case the payload is evenly divisible by this value, the last
1121: packet will be empty, namely 0 bytes. Thus, we can read every packet and ask
1122: for next one if they have 2^24 - 1 sizes. But just read the header of a
1123: zero-length byte, don't read the body, there is no such.
1124: */
1125:
1126: *data_size = prealloc_more_bytes;
1127: while (1) {
1128: if (FAIL == mysqlnd_read_header(conn , &header TSRMLS_CC)) {
1129: ret = FAIL;
1130: break;
1131: }
1132:
1133: *data_size += header.size;
1134:
1135: if (first_iteration) {
1136: first_iteration = FALSE;
1137: /*
1138: We need a trailing \0 for the last string, in case of text-mode,
1139: to be able to implement read-only variables. Thus, we add + 1.
1140: */
1141: *buffer = result_set_memory_pool->get_chunk(result_set_memory_pool, *data_size + 1 TSRMLS_CC);
1142: if (!*buffer) {
1143: ret = FAIL;
1144: break;
1145: }
1146: p = (*buffer)->ptr;
1147: } else if (!first_iteration) {
1148: /* Empty packet after MYSQLND_MAX_PACKET_SIZE packet. That's ok, break */
1149: if (!header.size) {
1150: break;
1151: }
1152:
1153: /*
1154: We have to realloc the buffer.
1155:
1156: We need a trailing \0 for the last string, in case of text-mode,
1157: to be able to implement read-only variables.
1158: */
1159: if (FAIL == (*buffer)->resize_chunk((*buffer), *data_size + 1 TSRMLS_CC)) {
1160: SET_OOM_ERROR(conn->error_info);
1161: ret = FAIL;
1162: break;
1163: }
1164: /* The position could have changed, recalculate */
1165: p = (*buffer)->ptr + (*data_size - header.size);
1166: }
1167:
1168: if (PASS != (ret = conn->net->m.receive(conn, p, header.size TSRMLS_CC))) {
1169: DBG_ERR("Empty row packet body");
1170: php_error(E_WARNING, "Empty row packet body");
1171: break;
1172: }
1173:
1174: if (header.size < MYSQLND_MAX_PACKET_SIZE) {
1175: break;
1176: }
1177: }
1178: if (ret == FAIL && *buffer) {
1179: (*buffer)->free_chunk((*buffer) TSRMLS_CC);
1180: *buffer = NULL;
1181: }
1182: *data_size -= prealloc_more_bytes;
1183: DBG_RETURN(ret);
1184: }
1185: /* }}} */
1186:
1187:
1188: /* {{{ php_mysqlnd_rowp_read_binary_protocol */
1189: enum_func_status
1190: php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
1191: unsigned int field_count, MYSQLND_FIELD *fields_metadata,
1192: zend_bool persistent,
1193: zend_bool as_unicode, zend_bool as_int_or_float,
1194: MYSQLND_STATS * stats TSRMLS_DC)
1195: {
1196: unsigned int i;
1197: zend_uchar *p = row_buffer->ptr;
1198: zend_uchar *null_ptr, bit;
1199: zval **current_field, **end_field, **start_field;
1200:
1201: DBG_ENTER("php_mysqlnd_rowp_read_binary_protocol");
1202:
1203: if (!fields) {
1204: DBG_RETURN(FAIL);
1205: }
1206:
1207: end_field = (start_field = fields) + field_count;
1208:
1209: /* skip the first byte, not EODATA_MARKER -> 0x0, status */
1210: p++;
1211: null_ptr= p;
1212: p += (field_count + 9)/8; /* skip null bits */
1213: bit = 4; /* first 2 bits are reserved */
1214:
1215: for (i = 0, current_field = start_field; current_field < end_field; current_field++, i++) {
1216: DBG_INF("Directly creating zval");
1217: MAKE_STD_ZVAL(*current_field);
1218: if (!*current_field) {
1219: DBG_RETURN(FAIL);
1220: }
1221: }
1222:
1223: for (i = 0, current_field = start_field; current_field < end_field; current_field++, i++) {
1224: enum_mysqlnd_collected_stats statistic;
1225: zend_uchar * orig_p = p;
1226:
1227: DBG_INF_FMT("Into zval=%p decoding column %u [%s.%s.%s] type=%u field->flags&unsigned=%u flags=%u is_bit=%u as_unicode=%u",
1228: *current_field, i,
1229: fields_metadata[i].db, fields_metadata[i].table, fields_metadata[i].name, fields_metadata[i].type,
1230: fields_metadata[i].flags & UNSIGNED_FLAG, fields_metadata[i].flags, fields_metadata[i].type == MYSQL_TYPE_BIT, as_unicode);
1231: if (*null_ptr & bit) {
1232: DBG_INF("It's null");
1233: ZVAL_NULL(*current_field);
1234: statistic = STAT_BINARY_TYPE_FETCHED_NULL;
1235: } else {
1236: enum_mysqlnd_field_types type = fields_metadata[i].type;
1237: mysqlnd_ps_fetch_functions[type].func(*current_field, &fields_metadata[i], 0, &p, as_unicode TSRMLS_CC);
1238:
1239: if (MYSQLND_G(collect_statistics)) {
1240: switch (fields_metadata[i].type) {
1241: case MYSQL_TYPE_DECIMAL: statistic = STAT_BINARY_TYPE_FETCHED_DECIMAL; break;
1242: case MYSQL_TYPE_TINY: statistic = STAT_BINARY_TYPE_FETCHED_INT8; break;
1243: case MYSQL_TYPE_SHORT: statistic = STAT_BINARY_TYPE_FETCHED_INT16; break;
1244: case MYSQL_TYPE_LONG: statistic = STAT_BINARY_TYPE_FETCHED_INT32; break;
1245: case MYSQL_TYPE_FLOAT: statistic = STAT_BINARY_TYPE_FETCHED_FLOAT; break;
1246: case MYSQL_TYPE_DOUBLE: statistic = STAT_BINARY_TYPE_FETCHED_DOUBLE; break;
1247: case MYSQL_TYPE_NULL: statistic = STAT_BINARY_TYPE_FETCHED_NULL; break;
1248: case MYSQL_TYPE_TIMESTAMP: statistic = STAT_BINARY_TYPE_FETCHED_TIMESTAMP; break;
1249: case MYSQL_TYPE_LONGLONG: statistic = STAT_BINARY_TYPE_FETCHED_INT64; break;
1250: case MYSQL_TYPE_INT24: statistic = STAT_BINARY_TYPE_FETCHED_INT24; break;
1251: case MYSQL_TYPE_DATE: statistic = STAT_BINARY_TYPE_FETCHED_DATE; break;
1252: case MYSQL_TYPE_TIME: statistic = STAT_BINARY_TYPE_FETCHED_TIME; break;
1253: case MYSQL_TYPE_DATETIME: statistic = STAT_BINARY_TYPE_FETCHED_DATETIME; break;
1254: case MYSQL_TYPE_YEAR: statistic = STAT_BINARY_TYPE_FETCHED_YEAR; break;
1255: case MYSQL_TYPE_NEWDATE: statistic = STAT_BINARY_TYPE_FETCHED_DATE; break;
1256: case MYSQL_TYPE_VARCHAR: statistic = STAT_BINARY_TYPE_FETCHED_STRING; break;
1257: case MYSQL_TYPE_BIT: statistic = STAT_BINARY_TYPE_FETCHED_BIT; break;
1258: case MYSQL_TYPE_NEWDECIMAL: statistic = STAT_BINARY_TYPE_FETCHED_DECIMAL; break;
1259: case MYSQL_TYPE_ENUM: statistic = STAT_BINARY_TYPE_FETCHED_ENUM; break;
1260: case MYSQL_TYPE_SET: statistic = STAT_BINARY_TYPE_FETCHED_SET; break;
1261: case MYSQL_TYPE_TINY_BLOB: statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
1262: case MYSQL_TYPE_MEDIUM_BLOB:statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
1263: case MYSQL_TYPE_LONG_BLOB: statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
1264: case MYSQL_TYPE_BLOB: statistic = STAT_BINARY_TYPE_FETCHED_BLOB; break;
1265: case MYSQL_TYPE_VAR_STRING: statistic = STAT_BINARY_TYPE_FETCHED_STRING; break;
1266: case MYSQL_TYPE_STRING: statistic = STAT_BINARY_TYPE_FETCHED_STRING; break;
1267: case MYSQL_TYPE_GEOMETRY: statistic = STAT_BINARY_TYPE_FETCHED_GEOMETRY; break;
1268: default: statistic = STAT_BINARY_TYPE_FETCHED_OTHER; break;
1269: }
1270: }
1271: }
1272: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(stats, statistic, 1,
1273: STAT_BYTES_RECEIVED_PURE_DATA_PS,
1274: (Z_TYPE_PP(current_field) == IS_STRING)?
1275: Z_STRLEN_PP(current_field) : (p - orig_p));
1276:
1277: if (!((bit<<=1) & 255)) {
1278: bit = 1; /* to the following byte */
1279: null_ptr++;
1280: }
1281: }
1282:
1283: DBG_RETURN(PASS);
1284: }
1285: /* }}} */
1286:
1287:
1288: /* {{{ php_mysqlnd_rowp_read_text_protocol */
1289: enum_func_status
1290: php_mysqlnd_rowp_read_text_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
1291: unsigned int field_count, MYSQLND_FIELD *fields_metadata,
1292: zend_bool persistent,
1293: zend_bool as_unicode, zend_bool as_int_or_float,
1294: MYSQLND_STATS * stats TSRMLS_DC)
1295: {
1296: unsigned int i;
1297: zend_bool last_field_was_string = FALSE;
1298: zval **current_field, **end_field, **start_field;
1299: zend_uchar *p = row_buffer->ptr;
1300: size_t data_size = row_buffer->app;
1301: zend_uchar *bit_area = (zend_uchar*) row_buffer->ptr + data_size + 1; /* we allocate from here */
1302:
1303: DBG_ENTER("php_mysqlnd_rowp_read_text_protocol");
1304:
1305: if (!fields) {
1306: DBG_RETURN(FAIL);
1307: }
1308:
1309: end_field = (start_field = fields) + field_count;
1310:
1311: for (i = 0, current_field = start_field; current_field < end_field; current_field++, i++) {
1312: DBG_INF("Directly creating zval");
1313: MAKE_STD_ZVAL(*current_field);
1314: if (!*current_field) {
1315: DBG_RETURN(FAIL);
1316: }
1317: }
1318:
1319: for (i = 0, current_field = start_field; current_field < end_field; current_field++, i++) {
1320: /* Don't reverse the order. It is significant!*/
1321: zend_uchar *this_field_len_pos = p;
1322: /* php_mysqlnd_net_field_length() call should be after *this_field_len_pos = p; */
1323: unsigned long len = php_mysqlnd_net_field_length(&p);
1324:
1325: if (current_field > start_field && last_field_was_string) {
1326: /*
1327: Normal queries:
1328: We have to put \0 now to the end of the previous field, if it was
1329: a string. IS_NULL doesn't matter. Because we have already read our
1330: length, then we can overwrite it in the row buffer.
1331: This statement terminates the previous field, not the current one.
1332:
1333: NULL_LENGTH is encoded in one byte, so we can stick a \0 there.
1334: Any string's length is encoded in at least one byte, so we can stick
1335: a \0 there.
1336: */
1337:
1338: *this_field_len_pos = '\0';
1339: }
1340:
1341: /* NULL or NOT NULL, this is the question! */
1342: if (len == MYSQLND_NULL_LENGTH) {
1343: ZVAL_NULL(*current_field);
1344: last_field_was_string = FALSE;
1345: } else {
1346: #if MYSQLND_UNICODE || defined(MYSQLND_STRING_TO_INT_CONVERSION)
1347: struct st_mysqlnd_perm_bind perm_bind =
1348: mysqlnd_ps_fetch_functions[fields_metadata[i].type];
1349: #endif
1350: if (MYSQLND_G(collect_statistics)) {
1351: enum_mysqlnd_collected_stats statistic;
1352: switch (fields_metadata[i].type) {
1353: case MYSQL_TYPE_DECIMAL: statistic = STAT_TEXT_TYPE_FETCHED_DECIMAL; break;
1354: case MYSQL_TYPE_TINY: statistic = STAT_TEXT_TYPE_FETCHED_INT8; break;
1355: case MYSQL_TYPE_SHORT: statistic = STAT_TEXT_TYPE_FETCHED_INT16; break;
1356: case MYSQL_TYPE_LONG: statistic = STAT_TEXT_TYPE_FETCHED_INT32; break;
1357: case MYSQL_TYPE_FLOAT: statistic = STAT_TEXT_TYPE_FETCHED_FLOAT; break;
1358: case MYSQL_TYPE_DOUBLE: statistic = STAT_TEXT_TYPE_FETCHED_DOUBLE; break;
1359: case MYSQL_TYPE_NULL: statistic = STAT_TEXT_TYPE_FETCHED_NULL; break;
1360: case MYSQL_TYPE_TIMESTAMP: statistic = STAT_TEXT_TYPE_FETCHED_TIMESTAMP; break;
1361: case MYSQL_TYPE_LONGLONG: statistic = STAT_TEXT_TYPE_FETCHED_INT64; break;
1362: case MYSQL_TYPE_INT24: statistic = STAT_TEXT_TYPE_FETCHED_INT24; break;
1363: case MYSQL_TYPE_DATE: statistic = STAT_TEXT_TYPE_FETCHED_DATE; break;
1364: case MYSQL_TYPE_TIME: statistic = STAT_TEXT_TYPE_FETCHED_TIME; break;
1365: case MYSQL_TYPE_DATETIME: statistic = STAT_TEXT_TYPE_FETCHED_DATETIME; break;
1366: case MYSQL_TYPE_YEAR: statistic = STAT_TEXT_TYPE_FETCHED_YEAR; break;
1367: case MYSQL_TYPE_NEWDATE: statistic = STAT_TEXT_TYPE_FETCHED_DATE; break;
1368: case MYSQL_TYPE_VARCHAR: statistic = STAT_TEXT_TYPE_FETCHED_STRING; break;
1369: case MYSQL_TYPE_BIT: statistic = STAT_TEXT_TYPE_FETCHED_BIT; break;
1370: case MYSQL_TYPE_NEWDECIMAL: statistic = STAT_TEXT_TYPE_FETCHED_DECIMAL; break;
1371: case MYSQL_TYPE_ENUM: statistic = STAT_TEXT_TYPE_FETCHED_ENUM; break;
1372: case MYSQL_TYPE_SET: statistic = STAT_TEXT_TYPE_FETCHED_SET; break;
1373: case MYSQL_TYPE_TINY_BLOB: statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
1374: case MYSQL_TYPE_MEDIUM_BLOB:statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
1375: case MYSQL_TYPE_LONG_BLOB: statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
1376: case MYSQL_TYPE_BLOB: statistic = STAT_TEXT_TYPE_FETCHED_BLOB; break;
1377: case MYSQL_TYPE_VAR_STRING: statistic = STAT_TEXT_TYPE_FETCHED_STRING; break;
1378: case MYSQL_TYPE_STRING: statistic = STAT_TEXT_TYPE_FETCHED_STRING; break;
1379: case MYSQL_TYPE_GEOMETRY: statistic = STAT_TEXT_TYPE_FETCHED_GEOMETRY; break;
1380: default: statistic = STAT_TEXT_TYPE_FETCHED_OTHER; break;
1381: }
1382: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(stats, statistic, 1, STAT_BYTES_RECEIVED_PURE_DATA_TEXT, len);
1383: }
1384: #ifdef MYSQLND_STRING_TO_INT_CONVERSION
1385: if (as_int_or_float && perm_bind.php_type == IS_LONG) {
1386: zend_uchar save = *(p + len);
1387: /* We have to make it ASCIIZ temporarily */
1388: *(p + len) = '\0';
1389: if (perm_bind.pack_len < SIZEOF_LONG) {
1390: /* direct conversion */
1391: int64_t v =
1392: #ifndef PHP_WIN32
1393: atoll((char *) p);
1394: #else
1395: _atoi64((char *) p);
1396: #endif
1397: ZVAL_LONG(*current_field, (long) v); /* the cast is safe */
1398: } else {
1399: uint64_t v =
1400: #ifndef PHP_WIN32
1401: (uint64_t) atoll((char *) p);
1402: #else
1403: (uint64_t) _atoi64((char *) p);
1404: #endif
1405: zend_bool uns = fields_metadata[i].flags & UNSIGNED_FLAG? TRUE:FALSE;
1406: /* We have to make it ASCIIZ temporarily */
1407: #if SIZEOF_LONG==8
1408: if (uns == TRUE && v > 9223372036854775807L)
1409: #elif SIZEOF_LONG==4
1410: if ((uns == TRUE && v > L64(2147483647)) ||
1411: (uns == FALSE && (( L64(2147483647) < (int64_t) v) ||
1412: (L64(-2147483648) > (int64_t) v))))
1413: #else
1414: #error Need fix for this architecture
1415: #endif /* SIZEOF */
1416: {
1417: ZVAL_STRINGL(*current_field, (char *)p, len, 0);
1418: } else {
1419: ZVAL_LONG(*current_field, (long) v); /* the cast is safe */
1420: }
1421: }
1422: *(p + len) = save;
1423: } else if (as_int_or_float && perm_bind.php_type == IS_DOUBLE) {
1424: zend_uchar save = *(p + len);
1425: /* We have to make it ASCIIZ temporarily */
1426: *(p + len) = '\0';
1427: ZVAL_DOUBLE(*current_field, atof((char *) p));
1428: *(p + len) = save;
1429: } else
1430: #endif /* MYSQLND_STRING_TO_INT_CONVERSION */
1431: if (fields_metadata[i].type == MYSQL_TYPE_BIT) {
1432: /*
1433: BIT fields are specially handled. As they come as bit mask, we have
1434: to convert it to human-readable representation. As the bits take
1435: less space in the protocol than the numbers they represent, we don't
1436: have enough space in the packet buffer to overwrite inside.
1437: Thus, a bit more space is pre-allocated at the end of the buffer,
1438: see php_mysqlnd_rowp_read(). And we add the strings at the end.
1439: Definitely not nice, _hackish_ :(, but works.
1440: */
1441: zend_uchar *start = bit_area;
1442: ps_fetch_from_1_to_8_bytes(*current_field, &(fields_metadata[i]), 0, &p, as_unicode, len TSRMLS_CC);
1443: /*
1444: We have advanced in ps_fetch_from_1_to_8_bytes. We should go back because
1445: later in this function there will be an advancement.
1446: */
1447: p -= len;
1448: if (Z_TYPE_PP(current_field) == IS_LONG) {
1449: bit_area += 1 + sprintf((char *)start, "%ld", Z_LVAL_PP(current_field));
1450: #if MYSQLND_UNICODE
1451: if (as_unicode) {
1452: ZVAL_UTF8_STRINGL(*current_field, start, bit_area - start - 1, 0);
1453: } else
1454: #endif
1455: {
1456: ZVAL_STRINGL(*current_field, (char *) start, bit_area - start - 1, 0);
1457: }
1458: } else if (Z_TYPE_PP(current_field) == IS_STRING){
1459: memcpy(bit_area, Z_STRVAL_PP(current_field), Z_STRLEN_PP(current_field));
1460: bit_area += Z_STRLEN_PP(current_field);
1461: *bit_area++ = '\0';
1462: zval_dtor(*current_field);
1463: #if MYSQLND_UNICODE
1464: if (as_unicode) {
1465: ZVAL_UTF8_STRINGL(*current_field, start, bit_area - start - 1, 0);
1466: } else
1467: #endif
1468: {
1469: ZVAL_STRINGL(*current_field, (char *) start, bit_area - start - 1, 0);
1470: }
1471: }
1472: /*
1473: IS_UNICODE should not be specially handled. In unicode mode
1474: the buffers are not referenced - everything is copied.
1475: */
1476: } else
1477: #if MYSQLND_UNICODE == 0
1478: {
1479: ZVAL_STRINGL(*current_field, (char *)p, len, 0);
1480: }
1481: #else
1482: /*
1483: Here we have to convert to UTF16, which means not reusing the buffer.
1484: Which in turn means that we can free the buffers once we have
1485: stored the result set, if we use store_result().
1486:
1487: Also the destruction of the zvals should not call zval_copy_ctor()
1488: because then we will leak.
1489:
1490: XXX: Keep in mind that up there there is an open `else` in
1491: #ifdef MYSQLND_STRING_TO_INT_CONVERSION
1492: which will make with this `if` an `else if`.
1493: */
1494: if ((perm_bind.is_possibly_blob == TRUE &&
1495: fields_metadata[i].charsetnr == MYSQLND_BINARY_CHARSET_NR) ||
1496: (!as_unicode && perm_bind.can_ret_as_str_in_uni == TRUE))
1497: {
1498: /* BLOB - no conversion please */
1499: ZVAL_STRINGL(*current_field, (char *)p, len, 0);
1500: } else {
1501: ZVAL_UTF8_STRINGL(*current_field, (char *)p, len, 0);
1502: }
1503: #endif
1504: p += len;
1505: last_field_was_string = TRUE;
1506: }
1507: }
1508: if (last_field_was_string) {
1509: /* Normal queries: The buffer has one more byte at the end, because we need it */
1510: row_buffer->ptr[data_size] = '\0';
1511: }
1512:
1513: DBG_RETURN(PASS);
1514: }
1515: /* }}} */
1516:
1517:
1518: /* {{{ php_mysqlnd_rowp_read */
1519: /*
1520: if normal statements => packet->fields is created by this function,
1521: if PS => packet->fields is passed from outside
1522: */
1523: static enum_func_status
1524: php_mysqlnd_rowp_read(void *_packet, MYSQLND *conn TSRMLS_DC)
1525: {
1526: MYSQLND_NET *net = conn->net;
1527: zend_uchar *p;
1528: enum_func_status ret = PASS;
1529: size_t old_chunk_size = net->stream->chunk_size;
1530: MYSQLND_PACKET_ROW *packet= (MYSQLND_PACKET_ROW *) _packet;
1531: size_t post_alloc_for_bit_fields = 0;
1532: size_t data_size = 0;
1533:
1534: DBG_ENTER("php_mysqlnd_rowp_read");
1535:
1536: if (!packet->binary_protocol && packet->bit_fields_count) {
1537: /* For every field we need terminating \0 */
1538: post_alloc_for_bit_fields = packet->bit_fields_total_len + packet->bit_fields_count;
1539: }
1540:
1541: ret = php_mysqlnd_read_row_ex(conn, packet->result_set_memory_pool, &packet->row_buffer, &data_size,
1542: packet->persistent_alloc, post_alloc_for_bit_fields
1543: TSRMLS_CC);
1544: if (FAIL == ret) {
1545: goto end;
1546: }
1547: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, packet_type_to_statistic_byte_count[PROT_ROW_PACKET],
1548: MYSQLND_HEADER_SIZE + packet->header.size,
1549: packet_type_to_statistic_packet_count[PROT_ROW_PACKET],
1550: 1);
1551:
1552: /* packet->row_buffer->ptr is of size 'data_size + 1' */
1553: packet->header.size = data_size;
1554: packet->row_buffer->app = data_size;
1555:
1556: if (ERROR_MARKER == (*(p = packet->row_buffer->ptr))) {
1557: /*
1558: Error message as part of the result set,
1559: not good but we should not hang. See:
1560: Bug #27876 : SF with cyrillic variable name fails during execution
1561: */
1562: ret = FAIL;
1563: php_mysqlnd_read_error_from_line(p + 1, data_size - 1,
1564: packet->error_info.error,
1565: sizeof(packet->error_info.error),
1566: &packet->error_info.error_no,
1567: packet->error_info.sqlstate
1568: TSRMLS_CC);
1569: } else if (EODATA_MARKER == *p && data_size < 8) { /* EOF */
1570: packet->eof = TRUE;
1571: p++;
1572: if (data_size > 1) {
1573: packet->warning_count = uint2korr(p);
1574: p += 2;
1575: packet->server_status = uint2korr(p);
1576: /* Seems we have 3 bytes reserved for future use */
1577: DBG_INF_FMT("server_status=%u warning_count=%u", packet->server_status, packet->warning_count);
1578: }
1579: } else {
1580: MYSQLND_INC_CONN_STATISTIC(conn->stats,
1581: packet->binary_protocol? STAT_ROWS_FETCHED_FROM_SERVER_PS:
1582: STAT_ROWS_FETCHED_FROM_SERVER_NORMAL);
1583:
1584: packet->eof = FALSE;
1585: /* packet->field_count is set by the user of the packet */
1586:
1587: if (!packet->skip_extraction) {
1588: if (!packet->fields) {
1589: DBG_INF("Allocating packet->fields");
1590: /*
1591: old-API will probably set packet->fields to NULL every time, though for
1592: unbuffered sets it makes not much sense as the zvals in this buffer matter,
1593: not the buffer. Constantly allocating and deallocating brings nothing.
1594:
1595: For PS - if stmt_store() is performed, thus we don't have a cursor, it will
1596: behave just like old-API buffered. Cursors will behave like a bit different,
1597: but mostly like old-API unbuffered and thus will populate this array with
1598: value.
1599: */
1600: packet->fields = (zval **) mnd_pecalloc(packet->field_count, sizeof(zval *),
1601: packet->persistent_alloc);
1602: }
1603: } else {
1604: MYSQLND_INC_CONN_STATISTIC(conn->stats,
1605: packet->binary_protocol? STAT_ROWS_SKIPPED_PS:
1606: STAT_ROWS_SKIPPED_NORMAL);
1607: }
1608: }
1609:
1610: end:
1611: net->stream->chunk_size = old_chunk_size;
1612: DBG_RETURN(ret);
1613: }
1614: /* }}} */
1615:
1616:
1617: /* {{{ php_mysqlnd_rowp_free_mem */
1618: static void
1619: php_mysqlnd_rowp_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
1620: {
1621: MYSQLND_PACKET_ROW *p;
1622:
1623: DBG_ENTER("php_mysqlnd_rowp_free_mem");
1624: p = (MYSQLND_PACKET_ROW *) _packet;
1625: if (p->row_buffer) {
1626: p->row_buffer->free_chunk(p->row_buffer TSRMLS_CC);
1627: p->row_buffer = NULL;
1628: }
1629: DBG_INF_FMT("stack_allocation=%u persistent=%u", (int)stack_allocation, (int)p->header.persistent);
1630: /*
1631: Don't free packet->fields :
1632: - normal queries -> store_result() | fetch_row_unbuffered() will transfer
1633: the ownership and NULL it.
1634: - PS will pass in it the bound variables, we have to use them! and of course
1635: not free the array. As it is passed to us, we should not clean it ourselves.
1636: */
1637: if (!stack_allocation) {
1638: mnd_pefree(p, p->header.persistent);
1639: }
1640: DBG_VOID_RETURN;
1641: }
1642: /* }}} */
1643:
1644:
1645: /* {{{ php_mysqlnd_stats_read */
1646: static enum_func_status
1647: php_mysqlnd_stats_read(void *_packet, MYSQLND *conn TSRMLS_DC)
1648: {
1649: MYSQLND_PACKET_STATS *packet= (MYSQLND_PACKET_STATS *) _packet;
1650: size_t buf_len = conn->net->cmd_buffer.length;
1651: zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
1652:
1653: DBG_ENTER("php_mysqlnd_stats_read");
1654:
1655: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "statistics", PROT_STATS_PACKET);
1656:
1657: packet->message = mnd_emalloc(packet->header.size + 1);
1658: memcpy(packet->message, buf, packet->header.size);
1659: packet->message[packet->header.size] = '\0';
1660: packet->message_len = packet->header.size;
1661:
1662: DBG_RETURN(PASS);
1663: }
1664: /* }}} */
1665:
1666:
1667: /* {{{ php_mysqlnd_stats_free_mem */
1668: static
1669: void php_mysqlnd_stats_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
1670: {
1671: MYSQLND_PACKET_STATS *p= (MYSQLND_PACKET_STATS *) _packet;
1672: if (p->message) {
1673: mnd_efree(p->message);
1674: p->message = NULL;
1675: }
1676: if (!stack_allocation) {
1677: mnd_pefree(p, p->header.persistent);
1678: }
1679: }
1680: /* }}} */
1681:
1682:
1683: /* 1 + 4 (id) + 2 (field_c) + 2 (param_c) + 1 (filler) + 2 (warnings ) */
1684: #define PREPARE_RESPONSE_SIZE_41 9
1685: #define PREPARE_RESPONSE_SIZE_50 12
1686:
1687: /* {{{ php_mysqlnd_prepare_read */
1688: static enum_func_status
1689: php_mysqlnd_prepare_read(void *_packet, MYSQLND *conn TSRMLS_DC)
1690: {
1691: /* In case of an error, we should have place to put it */
1692: size_t buf_len = conn->net->cmd_buffer.length;
1693: zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
1694: zend_uchar *p = buf;
1695: zend_uchar *begin = buf;
1696: unsigned int data_size;
1697: MYSQLND_PACKET_PREPARE_RESPONSE *packet= (MYSQLND_PACKET_PREPARE_RESPONSE *) _packet;
1698:
1699: DBG_ENTER("php_mysqlnd_prepare_read");
1700:
1701: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "prepare", PROT_PREPARE_RESP_PACKET);
1702: BAIL_IF_NO_MORE_DATA;
1703:
1704: data_size = packet->header.size;
1705: packet->error_code = uint1korr(p);
1706: p++;
1707: BAIL_IF_NO_MORE_DATA;
1708:
1709: if (ERROR_MARKER == packet->error_code) {
1710: php_mysqlnd_read_error_from_line(p, data_size - 1,
1711: packet->error_info.error,
1712: sizeof(packet->error_info.error),
1713: &packet->error_info.error_no,
1714: packet->error_info.sqlstate
1715: TSRMLS_CC);
1716: DBG_RETURN(PASS);
1717: }
1718:
1719: if (data_size != PREPARE_RESPONSE_SIZE_41 &&
1720: data_size != PREPARE_RESPONSE_SIZE_50 &&
1721: !(data_size > PREPARE_RESPONSE_SIZE_50)) {
1722: DBG_ERR_FMT("Wrong COM_STMT_PREPARE response size. Received %u", data_size);
1723: php_error(E_WARNING, "Wrong COM_STMT_PREPARE response size. Received %u", data_size);
1724: DBG_RETURN(FAIL);
1725: }
1726:
1727: packet->stmt_id = uint4korr(p);
1728: p += 4;
1729: BAIL_IF_NO_MORE_DATA;
1730:
1731: /* Number of columns in result set */
1732: packet->field_count = uint2korr(p);
1733: p += 2;
1734: BAIL_IF_NO_MORE_DATA;
1735:
1736: packet->param_count = uint2korr(p);
1737: p += 2;
1738: BAIL_IF_NO_MORE_DATA;
1739:
1740: if (data_size > 9) {
1741: /* 0x0 filler sent by the server for 5.0+ clients */
1742: p++;
1743: BAIL_IF_NO_MORE_DATA;
1744:
1745: packet->warning_count = uint2korr(p);
1746: }
1747:
1748: DBG_INF_FMT("Prepare packet read: stmt_id=%u fields=%u params=%u",
1749: packet->stmt_id, packet->field_count, packet->param_count);
1750:
1751: BAIL_IF_NO_MORE_DATA;
1752:
1753: DBG_RETURN(PASS);
1754: premature_end:
1755: DBG_ERR_FMT("PREPARE packet %d bytes shorter than expected", p - begin - packet->header.size);
1756: php_error_docref(NULL TSRMLS_CC, E_WARNING, "PREPARE packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
1757: p - begin - packet->header.size);
1758: DBG_RETURN(FAIL);
1759: }
1760: /* }}} */
1761:
1762:
1763: /* {{{ php_mysqlnd_prepare_free_mem */
1764: static void
1765: php_mysqlnd_prepare_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
1766: {
1767: MYSQLND_PACKET_PREPARE_RESPONSE *p= (MYSQLND_PACKET_PREPARE_RESPONSE *) _packet;
1768: if (!stack_allocation) {
1769: mnd_pefree(p, p->header.persistent);
1770: }
1771: }
1772: /* }}} */
1773:
1774:
1775: /* {{{ php_mysqlnd_chg_user_read */
1776: static enum_func_status
1777: php_mysqlnd_chg_user_read(void *_packet, MYSQLND *conn TSRMLS_DC)
1778: {
1779: /* There could be an error message */
1780: size_t buf_len = conn->net->cmd_buffer.length;
1781: zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
1782: zend_uchar *p = buf;
1783: zend_uchar *begin = buf;
1784: MYSQLND_PACKET_CHG_USER_RESPONSE *packet= (MYSQLND_PACKET_CHG_USER_RESPONSE *) _packet;
1785:
1786: DBG_ENTER("php_mysqlnd_chg_user_read");
1787:
1788: PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "change user response", PROT_CHG_USER_RESP_PACKET);
1789: BAIL_IF_NO_MORE_DATA;
1790:
1791: /*
1792: Don't increment. First byte is ERROR_MARKER on error, but otherwise is starting byte
1793: of encoded sequence for length.
1794: */
1795:
1796: /* Should be always 0x0 or ERROR_MARKER for error */
1797: packet->field_count= uint1korr(p);
1798: p++;
1799:
1800: if (packet->header.size == 1 && buf[0] == EODATA_MARKER && packet->server_capabilities & CLIENT_SECURE_CONNECTION) {
1801: /* We don't handle 3.23 authentication */
1802: packet->server_asked_323_auth = TRUE;
1803: DBG_RETURN(FAIL);
1804: }
1805:
1806: if (ERROR_MARKER == packet->field_count) {
1807: php_mysqlnd_read_error_from_line(p, packet->header.size - 1,
1808: packet->error_info.error,
1809: sizeof(packet->error_info.error),
1810: &packet->error_info.error_no,
1811: packet->error_info.sqlstate
1812: TSRMLS_CC);
1813: }
1814: BAIL_IF_NO_MORE_DATA;
1815:
1816: DBG_RETURN(PASS);
1817: premature_end:
1818: DBG_ERR_FMT("CHANGE_USER packet %d bytes shorter than expected", p - begin - packet->header.size);
1819: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CHANGE_USER packet "MYSQLND_SZ_T_SPEC" bytes shorter than expected",
1820: p - begin - packet->header.size);
1821: DBG_RETURN(FAIL);
1822: }
1823: /* }}} */
1824:
1825:
1826: /* {{{ php_mysqlnd_chg_user_free_mem */
1827: static void
1828: php_mysqlnd_chg_user_free_mem(void *_packet, zend_bool stack_allocation TSRMLS_DC)
1829: {
1830: if (!stack_allocation) {
1831: mnd_pefree(_packet, ((MYSQLND_PACKET_CHG_USER_RESPONSE *)_packet)->header.persistent);
1832: }
1833: }
1834: /* }}} */
1835:
1836:
1837: /* {{{ packet_methods */
1838: static
1839: mysqlnd_packet_methods packet_methods[PROT_LAST] =
1840: {
1841: {
1842: sizeof(MYSQLND_PACKET_GREET),
1843: php_mysqlnd_greet_read,
1844: NULL, /* write */
1845: php_mysqlnd_greet_free_mem,
1846: }, /* PROT_GREET_PACKET */
1847: {
1848: sizeof(MYSQLND_PACKET_AUTH),
1849: NULL, /* read */
1850: php_mysqlnd_auth_write,
1851: php_mysqlnd_auth_free_mem,
1852: }, /* PROT_AUTH_PACKET */
1853: {
1854: sizeof(MYSQLND_PACKET_OK),
1855: php_mysqlnd_ok_read, /* read */
1856: NULL, /* write */
1857: php_mysqlnd_ok_free_mem,
1858: }, /* PROT_OK_PACKET */
1859: {
1860: sizeof(MYSQLND_PACKET_EOF),
1861: php_mysqlnd_eof_read, /* read */
1862: NULL, /* write */
1863: php_mysqlnd_eof_free_mem,
1864: }, /* PROT_EOF_PACKET */
1865: {
1866: sizeof(MYSQLND_PACKET_COMMAND),
1867: NULL, /* read */
1868: php_mysqlnd_cmd_write, /* write */
1869: php_mysqlnd_cmd_free_mem,
1870: }, /* PROT_CMD_PACKET */
1871: {
1872: sizeof(MYSQLND_PACKET_RSET_HEADER),
1873: php_mysqlnd_rset_header_read, /* read */
1874: NULL, /* write */
1875: php_mysqlnd_rset_header_free_mem,
1876: }, /* PROT_RSET_HEADER_PACKET */
1877: {
1878: sizeof(MYSQLND_PACKET_RES_FIELD),
1879: php_mysqlnd_rset_field_read, /* read */
1880: NULL, /* write */
1881: php_mysqlnd_rset_field_free_mem,
1882: }, /* PROT_RSET_FLD_PACKET */
1883: {
1884: sizeof(MYSQLND_PACKET_ROW),
1885: php_mysqlnd_rowp_read, /* read */
1886: NULL, /* write */
1887: php_mysqlnd_rowp_free_mem,
1888: }, /* PROT_ROW_PACKET */
1889: {
1890: sizeof(MYSQLND_PACKET_STATS),
1891: php_mysqlnd_stats_read, /* read */
1892: NULL, /* write */
1893: php_mysqlnd_stats_free_mem,
1894: }, /* PROT_STATS_PACKET */
1895: {
1896: sizeof(MYSQLND_PACKET_PREPARE_RESPONSE),
1897: php_mysqlnd_prepare_read, /* read */
1898: NULL, /* write */
1899: php_mysqlnd_prepare_free_mem,
1900: }, /* PROT_PREPARE_RESP_PACKET */
1901: {
1902: sizeof(MYSQLND_PACKET_CHG_USER_RESPONSE),
1903: php_mysqlnd_chg_user_read, /* read */
1904: NULL, /* write */
1905: php_mysqlnd_chg_user_free_mem,
1906: } /* PROT_CHG_USER_RESP_PACKET */
1907: };
1908: /* }}} */
1909:
1910:
1911: /* {{{ mysqlnd_protocol::get_greet_packet */
1912: static struct st_mysqlnd_packet_greet *
1913: MYSQLND_METHOD(mysqlnd_protocol, get_greet_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
1914: {
1915: struct st_mysqlnd_packet_greet * packet = mnd_pecalloc(1, packet_methods[PROT_GREET_PACKET].struct_size, persistent);
1916: DBG_ENTER("mysqlnd_protocol::get_greet_packet");
1917: if (packet) {
1918: packet->header.m = &packet_methods[PROT_GREET_PACKET];
1919: packet->header.persistent = persistent;
1920: }
1921: DBG_RETURN(packet);
1922: }
1923: /* }}} */
1924:
1925:
1926: /* {{{ mysqlnd_protocol::get_auth_packet */
1927: static struct st_mysqlnd_packet_auth *
1928: MYSQLND_METHOD(mysqlnd_protocol, get_auth_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
1929: {
1930: struct st_mysqlnd_packet_auth * packet = mnd_pecalloc(1, packet_methods[PROT_AUTH_PACKET].struct_size, persistent);
1931: DBG_ENTER("mysqlnd_protocol::get_auth_packet");
1932: if (packet) {
1933: packet->header.m = &packet_methods[PROT_AUTH_PACKET];
1934: packet->header.persistent = persistent;
1935: }
1936: DBG_RETURN(packet);
1937: }
1938: /* }}} */
1939:
1940:
1941: /* {{{ mysqlnd_protocol::get_ok_packet */
1942: static struct st_mysqlnd_packet_ok *
1943: MYSQLND_METHOD(mysqlnd_protocol, get_ok_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
1944: {
1945: struct st_mysqlnd_packet_ok * packet = mnd_pecalloc(1, packet_methods[PROT_OK_PACKET].struct_size, persistent);
1946: DBG_ENTER("mysqlnd_protocol::get_ok_packet");
1947: if (packet) {
1948: packet->header.m = &packet_methods[PROT_OK_PACKET];
1949: packet->header.persistent = persistent;
1950: }
1951: DBG_RETURN(packet);
1952: }
1953: /* }}} */
1954:
1955:
1956: /* {{{ mysqlnd_protocol::get_eof_packet */
1957: static struct st_mysqlnd_packet_eof *
1958: MYSQLND_METHOD(mysqlnd_protocol, get_eof_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
1959: {
1960: struct st_mysqlnd_packet_eof * packet = mnd_pecalloc(1, packet_methods[PROT_EOF_PACKET].struct_size, persistent);
1961: DBG_ENTER("mysqlnd_protocol::get_eof_packet");
1962: if (packet) {
1963: packet->header.m = &packet_methods[PROT_EOF_PACKET];
1964: packet->header.persistent = persistent;
1965: }
1966: DBG_RETURN(packet);
1967: }
1968: /* }}} */
1969:
1970:
1971: /* {{{ mysqlnd_protocol::get_command_packet */
1972: static struct st_mysqlnd_packet_command *
1973: MYSQLND_METHOD(mysqlnd_protocol, get_command_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
1974: {
1975: struct st_mysqlnd_packet_command * packet = mnd_pecalloc(1, packet_methods[PROT_CMD_PACKET].struct_size, persistent);
1976: DBG_ENTER("mysqlnd_protocol::get_command_packet");
1977: if (packet) {
1978: packet->header.m = &packet_methods[PROT_CMD_PACKET];
1979: packet->header.persistent = persistent;
1980: }
1981: DBG_RETURN(packet);
1982: }
1983: /* }}} */
1984:
1985:
1986: /* {{{ mysqlnd_protocol::get_rset_packet */
1987: static struct st_mysqlnd_packet_rset_header *
1988: MYSQLND_METHOD(mysqlnd_protocol, get_rset_header_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
1989: {
1990: struct st_mysqlnd_packet_rset_header * packet = mnd_pecalloc(1, packet_methods[PROT_RSET_HEADER_PACKET].struct_size, persistent);
1991: DBG_ENTER("mysqlnd_protocol::get_rset_header_packet");
1992: if (packet) {
1993: packet->header.m = &packet_methods[PROT_RSET_HEADER_PACKET];
1994: packet->header.persistent = persistent;
1995: }
1996: DBG_RETURN(packet);
1997: }
1998: /* }}} */
1999:
2000:
2001: /* {{{ mysqlnd_protocol::get_result_field_packet */
2002: static struct st_mysqlnd_packet_res_field *
2003: MYSQLND_METHOD(mysqlnd_protocol, get_result_field_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
2004: {
2005: struct st_mysqlnd_packet_res_field * packet = mnd_pecalloc(1, packet_methods[PROT_RSET_FLD_PACKET].struct_size, persistent);
2006: DBG_ENTER("mysqlnd_protocol::get_result_field_packet");
2007: if (packet) {
2008: packet->header.m = &packet_methods[PROT_RSET_FLD_PACKET];
2009: packet->header.persistent = persistent;
2010: }
2011: DBG_RETURN(packet);
2012: }
2013: /* }}} */
2014:
2015:
2016: /* {{{ mysqlnd_protocol::get_row_packet */
2017: static struct st_mysqlnd_packet_row *
2018: MYSQLND_METHOD(mysqlnd_protocol, get_row_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
2019: {
2020: struct st_mysqlnd_packet_row * packet = mnd_pecalloc(1, packet_methods[PROT_ROW_PACKET].struct_size, persistent);
2021: DBG_ENTER("mysqlnd_protocol::get_row_packet");
2022: if (packet) {
2023: packet->header.m = &packet_methods[PROT_ROW_PACKET];
2024: packet->header.persistent = persistent;
2025: }
2026: DBG_RETURN(packet);
2027: }
2028: /* }}} */
2029:
2030:
2031: /* {{{ mysqlnd_protocol::get_stats_packet */
2032: static struct st_mysqlnd_packet_stats *
2033: MYSQLND_METHOD(mysqlnd_protocol, get_stats_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
2034: {
2035: struct st_mysqlnd_packet_stats * packet = mnd_pecalloc(1, packet_methods[PROT_STATS_PACKET].struct_size, persistent);
2036: DBG_ENTER("mysqlnd_protocol::get_stats_packet");
2037: if (packet) {
2038: packet->header.m = &packet_methods[PROT_STATS_PACKET];
2039: packet->header.persistent = persistent;
2040: }
2041: DBG_RETURN(packet);
2042: }
2043: /* }}} */
2044:
2045:
2046: /* {{{ mysqlnd_protocol::get_prepare_response_packet */
2047: static struct st_mysqlnd_packet_prepare_response *
2048: MYSQLND_METHOD(mysqlnd_protocol, get_prepare_response_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
2049: {
2050: struct st_mysqlnd_packet_prepare_response * packet = mnd_pecalloc(1, packet_methods[PROT_PREPARE_RESP_PACKET].struct_size, persistent);
2051: DBG_ENTER("mysqlnd_protocol::get_prepare_response_packet");
2052: if (packet) {
2053: packet->header.m = &packet_methods[PROT_PREPARE_RESP_PACKET];
2054: packet->header.persistent = persistent;
2055: }
2056: DBG_RETURN(packet);
2057: }
2058: /* }}} */
2059:
2060:
2061: /* {{{ mysqlnd_protocol::get_change_user_response_packet */
2062: static struct st_mysqlnd_packet_chg_user_resp*
2063: MYSQLND_METHOD(mysqlnd_protocol, get_change_user_response_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
2064: {
2065: struct st_mysqlnd_packet_chg_user_resp * packet = mnd_pecalloc(1, packet_methods[PROT_CHG_USER_RESP_PACKET].struct_size, persistent);
2066: DBG_ENTER("mysqlnd_protocol::get_change_user_response_packet");
2067: if (packet) {
2068: packet->header.m = &packet_methods[PROT_CHG_USER_RESP_PACKET];
2069: packet->header.persistent = persistent;
2070: }
2071: DBG_RETURN(packet);
2072: }
2073: /* }}} */
2074:
2075:
2076: static
2077: MYSQLND_CLASS_METHODS_START(mysqlnd_protocol)
2078: MYSQLND_METHOD(mysqlnd_protocol, get_greet_packet),
2079: MYSQLND_METHOD(mysqlnd_protocol, get_auth_packet),
2080: MYSQLND_METHOD(mysqlnd_protocol, get_ok_packet),
2081: MYSQLND_METHOD(mysqlnd_protocol, get_command_packet),
2082: MYSQLND_METHOD(mysqlnd_protocol, get_eof_packet),
2083: MYSQLND_METHOD(mysqlnd_protocol, get_rset_header_packet),
2084: MYSQLND_METHOD(mysqlnd_protocol, get_result_field_packet),
2085: MYSQLND_METHOD(mysqlnd_protocol, get_row_packet),
2086: MYSQLND_METHOD(mysqlnd_protocol, get_stats_packet),
2087: MYSQLND_METHOD(mysqlnd_protocol, get_prepare_response_packet),
2088: MYSQLND_METHOD(mysqlnd_protocol, get_change_user_response_packet)
2089: MYSQLND_CLASS_METHODS_END;
2090:
2091:
2092: /* {{{ mysqlnd_protocol_init */
2093: PHPAPI MYSQLND_PROTOCOL *
2094: mysqlnd_protocol_init(zend_bool persistent TSRMLS_DC)
2095: {
2096: size_t alloc_size = sizeof(MYSQLND_PROTOCOL) + mysqlnd_plugin_count() * sizeof(void *);
2097: MYSQLND_PROTOCOL *ret = mnd_pecalloc(1, alloc_size, persistent);
2098:
2099: DBG_ENTER("mysqlnd_protocol_init");
2100: DBG_INF_FMT("persistent=%u", persistent);
2101: if (ret) {
2102: ret->persistent = persistent;
2103: ret->m = mysqlnd_mysqlnd_protocol_methods;
2104: }
2105:
2106: DBG_RETURN(ret);
2107: }
2108: /* }}} */
2109:
2110:
2111: /* {{{ mysqlnd_protocol_free */
2112: PHPAPI void
2113: mysqlnd_protocol_free(MYSQLND_PROTOCOL * const protocol TSRMLS_DC)
2114: {
2115: DBG_ENTER("mysqlnd_protocol_free");
2116:
2117: if (protocol) {
2118: zend_bool pers = protocol->persistent;
2119: mnd_pefree(protocol, pers);
2120: }
2121: DBG_VOID_RETURN;
2122: }
2123: /* }}} */
2124:
2125:
2126: /* {{{ _mysqlnd_plugin_get_plugin_protocol_data */
2127: PHPAPI void **
2128: _mysqlnd_plugin_get_plugin_protocol_data(const MYSQLND_PROTOCOL * protocol, unsigned int plugin_id TSRMLS_DC)
2129: {
2130: DBG_ENTER("_mysqlnd_plugin_get_plugin_protocol_data");
2131: DBG_INF_FMT("plugin_id=%u", plugin_id);
2132: if (!protocol || plugin_id >= mysqlnd_plugin_count()) {
2133: return NULL;
2134: }
2135: DBG_RETURN((void *)((char *)protocol + sizeof(MYSQLND_PROTOCOL) + plugin_id * sizeof(void *)));
2136: }
2137: /* }}} */
2138:
2139:
2140: /* {{{ mysqlnd_protocol_get_methods */
2141: PHPAPI struct st_mysqlnd_protocol_methods *
2142: mysqlnd_protocol_get_methods()
2143: {
2144: return &mysqlnd_mysqlnd_protocol_methods;
2145: }
2146: /* }}} */
2147:
2148:
2149: /*
2150: * Local variables:
2151: * tab-width: 4
2152: * c-basic-offset: 4
2153: * End:
2154: * vim600: noet sw=4 ts=4 fdm=marker
2155: * vim<600: noet sw=4 ts=4
2156: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mysqlnd_wireprotocol.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mysqlnd