Annotation of embedaddon/php/ext/mysqlnd/mysqlnd_net.c, revision 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 "php_network.h"
! 29: #include "zend_ini.h"
! 30: #ifdef MYSQLND_COMPRESSION_ENABLED
! 31: #include <zlib.h>
! 32: #endif
! 33:
! 34: #ifndef PHP_WIN32
! 35: #include <netinet/tcp.h>
! 36: #else
! 37: #include <winsock.h>
! 38: #endif
! 39:
! 40:
! 41: /* {{{ mysqlnd_set_sock_no_delay */
! 42: static int
! 43: mysqlnd_set_sock_no_delay(php_stream * stream TSRMLS_DC)
! 44: {
! 45:
! 46: int socketd = ((php_netstream_data_t*)stream->abstract)->socket;
! 47: int ret = SUCCESS;
! 48: int flag = 1;
! 49: int result = setsockopt(socketd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
! 50:
! 51: DBG_ENTER("mysqlnd_set_sock_no_delay");
! 52:
! 53: if (result == -1) {
! 54: ret = FAILURE;
! 55: }
! 56:
! 57: DBG_RETURN(ret);
! 58: }
! 59: /* }}} */
! 60:
! 61:
! 62: /* {{{ mysqlnd_net::network_read */
! 63: static enum_func_status
! 64: MYSQLND_METHOD(mysqlnd_net, network_read)(MYSQLND * conn, zend_uchar * buffer, size_t count TSRMLS_DC)
! 65: {
! 66: enum_func_status return_value = PASS;
! 67: size_t to_read = count, ret;
! 68: size_t old_chunk_size = conn->net->stream->chunk_size;
! 69: DBG_ENTER("mysqlnd_net::network_read");
! 70: DBG_INF_FMT("count=%u", count);
! 71: conn->net->stream->chunk_size = MIN(to_read, conn->net->options.net_read_buffer_size);
! 72: while (to_read) {
! 73: if (!(ret = php_stream_read(conn->net->stream, (char *) buffer, to_read))) {
! 74: DBG_ERR_FMT("Error while reading header from socket");
! 75: return_value = FAIL;
! 76: break;
! 77: }
! 78: buffer += ret;
! 79: to_read -= ret;
! 80: }
! 81: MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_BYTES_RECEIVED, count - to_read);
! 82: conn->net->stream->chunk_size = old_chunk_size;
! 83: DBG_RETURN(return_value);
! 84: }
! 85: /* }}} */
! 86:
! 87:
! 88: /* {{{ mysqlnd_net::network_write */
! 89: static size_t
! 90: MYSQLND_METHOD(mysqlnd_net, network_write)(MYSQLND * const conn, const zend_uchar * const buf, size_t count TSRMLS_DC)
! 91: {
! 92: size_t ret;
! 93: DBG_ENTER("mysqlnd_net::network_write");
! 94: ret = php_stream_write(conn->net->stream, (char *)buf, count);
! 95: DBG_RETURN(ret);
! 96: }
! 97: /* }}} */
! 98:
! 99:
! 100:
! 101: /* {{{ mysqlnd_net::connect */
! 102: static enum_func_status
! 103: MYSQLND_METHOD(mysqlnd_net, connect)(MYSQLND_NET * net, const char * const scheme, size_t scheme_len, zend_bool persistent, char **errstr, int * errcode TSRMLS_DC)
! 104: {
! 105: #if PHP_API_VERSION < 20100412
! 106: unsigned int streams_options = ENFORCE_SAFE_MODE;
! 107: #else
! 108: unsigned int streams_options = 0;
! 109: #endif
! 110: unsigned int streams_flags = STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT;
! 111: char * hashed_details = NULL;
! 112: int hashed_details_len = 0;
! 113: struct timeval tv;
! 114: DBG_ENTER("mysqlnd_net::connect");
! 115:
! 116: if (persistent) {
! 117: hashed_details_len = spprintf(&hashed_details, 0, "%p", net);
! 118: DBG_INF_FMT("hashed_details=%s", hashed_details);
! 119: }
! 120:
! 121: net->packet_no = net->compressed_envelope_packet_no = 0;
! 122:
! 123: if (net->stream) {
! 124: /* close before opening a new one */
! 125: DBG_INF_FMT("Freeing stream. abstract=%p", net->stream->abstract);
! 126: if (net->persistent) {
! 127: php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE_PERSISTENT | PHP_STREAM_FREE_RSRC_DTOR);
! 128: } else {
! 129: php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE);
! 130: }
! 131: net->stream = NULL;
! 132: }
! 133:
! 134: if (net->options.timeout_connect) {
! 135: tv.tv_sec = net->options.timeout_connect;
! 136: tv.tv_usec = 0;
! 137: }
! 138:
! 139: DBG_INF_FMT("calling php_stream_xport_create");
! 140: net->stream = php_stream_xport_create(scheme, scheme_len, streams_options, streams_flags,
! 141: hashed_details, (net->options.timeout_connect) ? &tv : NULL,
! 142: NULL /*ctx*/, errstr, errcode);
! 143:
! 144: if (*errstr || !net->stream) {
! 145: if (hashed_details) {
! 146: efree(hashed_details); /* allocated by spprintf */
! 147: }
! 148: *errcode = CR_CONNECTION_ERROR;
! 149: DBG_RETURN(FAIL);
! 150: }
! 151:
! 152: if (hashed_details) {
! 153: /*
! 154: If persistent, the streams register it in EG(persistent_list).
! 155: This is unwanted. ext/mysql or ext/mysqli are responsible to clean,
! 156: whatever they have to.
! 157: */
! 158: zend_rsrc_list_entry *le;
! 159:
! 160: if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_len + 1, (void*) &le) == SUCCESS) {
! 161: /*
! 162: in_free will let streams code skip destructing - big HACK,
! 163: but STREAMS suck big time regarding persistent streams.
! 164: Just not compatible for extensions that need persistency.
! 165: */
! 166: net->stream->in_free = 1;
! 167: zend_hash_del(&EG(persistent_list), hashed_details, hashed_details_len + 1);
! 168: net->stream->in_free = 0;
! 169: }
! 170: #if ZEND_DEBUG
! 171: /* Shut-up the streams, they don't know what they are doing */
! 172: net->stream->__exposed = 1;
! 173: #endif
! 174: efree(hashed_details);
! 175: }
! 176: /*
! 177: Streams are not meant for C extensions! Thus we need a hack. Every connected stream will
! 178: be registered as resource (in EG(regular_list). So far, so good. However, it won't be
! 179: unregistered till the script ends. So, we need to take care of that.
! 180: */
! 181: net->stream->in_free = 1;
! 182: zend_hash_index_del(&EG(regular_list), net->stream->rsrc_id);
! 183: net->stream->in_free = 0;
! 184:
! 185: if (!net->options.timeout_read) {
! 186: /* should always happen because read_timeout cannot be set via API */
! 187: net->options.timeout_read = (unsigned int) MYSQLND_G(net_read_timeout);
! 188: }
! 189: if (net->options.timeout_read) {
! 190: DBG_INF_FMT("setting %u as PHP_STREAM_OPTION_READ_TIMEOUT", net->options.timeout_read);
! 191: tv.tv_sec = net->options.timeout_read;
! 192: tv.tv_usec = 0;
! 193: php_stream_set_option(net->stream, PHP_STREAM_OPTION_READ_TIMEOUT, 0, &tv);
! 194: }
! 195:
! 196: if (!memcmp(scheme, "tcp://", sizeof("tcp://") - 1)) {
! 197: /* TCP -> Set TCP_NODELAY */
! 198: mysqlnd_set_sock_no_delay(net->stream TSRMLS_CC);
! 199: }
! 200:
! 201: {
! 202: unsigned int buf_size = MYSQLND_G(net_read_buffer_size); /* this is long, cast to unsigned int*/
! 203: net->m.set_client_option(net, MYSQLND_OPT_NET_READ_BUFFER_SIZE, (char *)&buf_size TSRMLS_CC);
! 204: }
! 205:
! 206:
! 207: DBG_RETURN(PASS);
! 208: }
! 209: /* }}} */
! 210:
! 211:
! 212: /* We assume that MYSQLND_HEADER_SIZE is 4 bytes !! */
! 213: #define COPY_HEADER(T,A) do { \
! 214: *(((char *)(T))) = *(((char *)(A)));\
! 215: *(((char *)(T))+1) = *(((char *)(A))+1);\
! 216: *(((char *)(T))+2) = *(((char *)(A))+2);\
! 217: *(((char *)(T))+3) = *(((char *)(A))+3); } while (0)
! 218: #define STORE_HEADER_SIZE(safe_storage, buffer) COPY_HEADER((safe_storage), (buffer))
! 219: #define RESTORE_HEADER_SIZE(buffer, safe_storage) STORE_HEADER_SIZE((safe_storage), (buffer))
! 220:
! 221: /* {{{ mysqlnd_net::send */
! 222: /*
! 223: IMPORTANT : It's expected that buf has place in the beginning for MYSQLND_HEADER_SIZE !!!!
! 224: This is done for performance reasons in the caller of this function.
! 225: Otherwise we will have to do send two TCP packets, or do new alloc and memcpy.
! 226: Neither are quick, thus the clients of this function are obligated to do
! 227: what they are asked for.
! 228:
! 229: `count` is actually the length of the payload data. Thus :
! 230: count + MYSQLND_HEADER_SIZE = sizeof(buf) (not the pointer but the actual buffer)
! 231: */
! 232: size_t
! 233: MYSQLND_METHOD(mysqlnd_net, send)(MYSQLND * const conn, char * const buf, size_t count TSRMLS_DC)
! 234: {
! 235: zend_uchar safe_buf[((MYSQLND_HEADER_SIZE) + (sizeof(zend_uchar)) - 1) / (sizeof(zend_uchar))];
! 236: zend_uchar *safe_storage = safe_buf;
! 237: MYSQLND_NET *net = conn->net;
! 238: size_t old_chunk_size = net->stream->chunk_size;
! 239: size_t ret, packets_sent = 1;
! 240: size_t left = count;
! 241: zend_uchar *p = (zend_uchar *) buf;
! 242: zend_uchar * compress_buf = NULL;
! 243: size_t to_be_sent;
! 244:
! 245: DBG_ENTER("mysqlnd_net::send");
! 246: DBG_INF_FMT("conn=%llu count=%lu compression=%u", conn->thread_id, count, net->compressed);
! 247:
! 248: net->stream->chunk_size = MYSQLND_MAX_PACKET_SIZE;
! 249:
! 250: if (net->compressed == TRUE) {
! 251: size_t comp_buf_size = MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE + MYSQLND_HEADER_SIZE + MIN(left, MYSQLND_MAX_PACKET_SIZE);
! 252: DBG_INF_FMT("compress_buf_size="MYSQLND_SZ_T_SPEC, comp_buf_size);
! 253: compress_buf = mnd_emalloc(comp_buf_size);
! 254: }
! 255:
! 256: do {
! 257: to_be_sent = MIN(left, MYSQLND_MAX_PACKET_SIZE);
! 258: #ifdef MYSQLND_COMPRESSION_ENABLED
! 259: if (net->compressed == TRUE) {
! 260: /* here we need to compress the data and then write it, first comes the compressed header */
! 261: size_t tmp_complen = to_be_sent;
! 262: size_t payload_size;
! 263: zend_uchar * uncompressed_payload = p; /* should include the header */
! 264:
! 265: STORE_HEADER_SIZE(safe_storage, uncompressed_payload);
! 266: int3store(uncompressed_payload, to_be_sent);
! 267: int1store(uncompressed_payload + 3, net->packet_no);
! 268: if (PASS == net->m.encode((compress_buf + COMPRESSED_HEADER_SIZE + MYSQLND_HEADER_SIZE), &tmp_complen,
! 269: uncompressed_payload, to_be_sent + MYSQLND_HEADER_SIZE TSRMLS_CC))
! 270: {
! 271: int3store(compress_buf + MYSQLND_HEADER_SIZE, to_be_sent + MYSQLND_HEADER_SIZE);
! 272: payload_size = tmp_complen;
! 273: } else {
! 274: int3store(compress_buf + MYSQLND_HEADER_SIZE, 0);
! 275: memcpy(compress_buf + MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE, uncompressed_payload, to_be_sent + MYSQLND_HEADER_SIZE);
! 276: payload_size = to_be_sent + MYSQLND_HEADER_SIZE;
! 277: }
! 278: RESTORE_HEADER_SIZE(uncompressed_payload, safe_storage);
! 279:
! 280: int3store(compress_buf, payload_size);
! 281: int1store(compress_buf + 3, net->packet_no);
! 282: DBG_INF_FMT("writing "MYSQLND_SZ_T_SPEC" bytes to the network", payload_size + MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE);
! 283: ret = conn->net->m.network_write(conn, compress_buf, payload_size + MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE TSRMLS_CC);
! 284: net->compressed_envelope_packet_no++;
! 285: #if WHEN_WE_NEED_TO_CHECK_WHETHER_COMPRESSION_WORKS_CORRECTLY
! 286: if (res == Z_OK) {
! 287: size_t decompressed_size = left + MYSQLND_HEADER_SIZE;
! 288: zend_uchar * decompressed_data = mnd_malloc(decompressed_size);
! 289: int error = net->m.decode(decompressed_data, decompressed_size,
! 290: compress_buf + MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE, payload_size);
! 291: if (error == Z_OK) {
! 292: int i;
! 293: DBG_INF("success decompressing");
! 294: for (i = 0 ; i < decompressed_size; i++) {
! 295: if (i && (i % 30 == 0)) {
! 296: printf("\n\t\t");
! 297: }
! 298: printf("%.2X ", (int)*((char*)&(decompressed_data[i])));
! 299: DBG_INF_FMT("%.2X ", (int)*((char*)&(decompressed_data[i])));
! 300: }
! 301: } else {
! 302: DBG_INF("error decompressing");
! 303: }
! 304: mnd_free(decompressed_data);
! 305: }
! 306: #endif /* WHEN_WE_NEED_TO_CHECK_WHETHER_COMPRESSION_WORKS_CORRECTLY */
! 307: } else
! 308: #endif /* MYSQLND_COMPRESSION_ENABLED */
! 309: {
! 310: DBG_INF("no compression");
! 311: STORE_HEADER_SIZE(safe_storage, p);
! 312: int3store(p, to_be_sent);
! 313: int1store(p + 3, net->packet_no);
! 314: ret = conn->net->m.network_write(conn, p, to_be_sent + MYSQLND_HEADER_SIZE TSRMLS_CC);
! 315: RESTORE_HEADER_SIZE(p, safe_storage);
! 316: net->compressed_envelope_packet_no++;
! 317: }
! 318: net->packet_no++;
! 319:
! 320: p += to_be_sent;
! 321: left -= to_be_sent;
! 322: packets_sent++;
! 323: /*
! 324: if left is 0 then there is nothing more to send, but if the last packet was exactly
! 325: with the size MYSQLND_MAX_PACKET_SIZE we need to send additional packet, which has
! 326: empty payload. Thus if left == 0 we check for to_be_sent being the max size. If it is
! 327: indeed it then loop once more, then to_be_sent will become 0, left will stay 0. Empty
! 328: packet will be sent and this loop will end.
! 329: */
! 330: } while (ret && (left > 0 || to_be_sent == MYSQLND_MAX_PACKET_SIZE));
! 331:
! 332: DBG_INF_FMT("packet_size="MYSQLND_SZ_T_SPEC" packet_no=%u", left, net->packet_no);
! 333: /* Even for zero size payload we have to send a packet */
! 334: if (!ret) {
! 335: DBG_ERR_FMT("Can't %u send bytes", count);
! 336: conn->state = CONN_QUIT_SENT;
! 337: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
! 338: }
! 339:
! 340: MYSQLND_INC_CONN_STATISTIC_W_VALUE3(conn->stats,
! 341: STAT_BYTES_SENT, count + packets_sent * MYSQLND_HEADER_SIZE,
! 342: STAT_PROTOCOL_OVERHEAD_OUT, packets_sent * MYSQLND_HEADER_SIZE,
! 343: STAT_PACKETS_SENT, packets_sent);
! 344:
! 345: net->stream->chunk_size = old_chunk_size;
! 346: if (compress_buf) {
! 347: mnd_efree(compress_buf);
! 348: }
! 349: DBG_RETURN(ret);
! 350: }
! 351: /* }}} */
! 352:
! 353:
! 354: #ifdef MYSQLND_COMPRESSION_ENABLED
! 355: /* {{{ php_mysqlnd_read_buffer_is_empty */
! 356: static zend_bool
! 357: php_mysqlnd_read_buffer_is_empty(MYSQLND_READ_BUFFER * buffer)
! 358: {
! 359: return buffer->len? FALSE:TRUE;
! 360: }
! 361: /* }}} */
! 362:
! 363:
! 364: /* {{{ php_mysqlnd_read_buffer_read */
! 365: static void
! 366: php_mysqlnd_read_buffer_read(MYSQLND_READ_BUFFER * buffer, size_t count, zend_uchar * dest)
! 367: {
! 368: if (buffer->len >= count) {
! 369: memcpy(dest, buffer->data + buffer->offset, count);
! 370: buffer->offset += count;
! 371: buffer->len -= count;
! 372: }
! 373: }
! 374: /* }}} */
! 375:
! 376:
! 377: /* {{{ php_mysqlnd_read_buffer_bytes_left */
! 378: static size_t
! 379: php_mysqlnd_read_buffer_bytes_left(MYSQLND_READ_BUFFER * buffer)
! 380: {
! 381: return buffer->len;
! 382: }
! 383: /* }}} */
! 384:
! 385:
! 386: /* {{{ php_mysqlnd_read_buffer_free */
! 387: static void
! 388: php_mysqlnd_read_buffer_free(MYSQLND_READ_BUFFER ** buffer TSRMLS_DC)
! 389: {
! 390: DBG_ENTER("php_mysqlnd_read_buffer_free");
! 391: if (*buffer) {
! 392: mnd_efree((*buffer)->data);
! 393: mnd_efree(*buffer);
! 394: *buffer = NULL;
! 395: }
! 396: DBG_VOID_RETURN;
! 397: }
! 398: /* }}} */
! 399:
! 400:
! 401: /* {{{ php_mysqlnd_create_read_buffer */
! 402: static MYSQLND_READ_BUFFER *
! 403: mysqlnd_create_read_buffer(size_t count TSRMLS_DC)
! 404: {
! 405: MYSQLND_READ_BUFFER * ret = mnd_emalloc(sizeof(MYSQLND_READ_BUFFER));
! 406: DBG_ENTER("mysqlnd_create_read_buffer");
! 407: ret->is_empty = php_mysqlnd_read_buffer_is_empty;
! 408: ret->read = php_mysqlnd_read_buffer_read;
! 409: ret->bytes_left = php_mysqlnd_read_buffer_bytes_left;
! 410: ret->free_buffer = php_mysqlnd_read_buffer_free;
! 411: ret->data = mnd_emalloc(count);
! 412: ret->size = ret->len = count;
! 413: ret->offset = 0;
! 414: DBG_RETURN(ret);
! 415: }
! 416: /* }}} */
! 417:
! 418:
! 419: /* {{{ mysqlnd_read_compressed_packet_from_stream_and_fill_read_buffer */
! 420: static enum_func_status
! 421: mysqlnd_read_compressed_packet_from_stream_and_fill_read_buffer(MYSQLND * conn, size_t net_payload_size TSRMLS_DC)
! 422: {
! 423: MYSQLND_NET * net = conn->net;
! 424: size_t decompressed_size;
! 425: enum_func_status ret = PASS;
! 426: zend_uchar * compressed_data = NULL;
! 427: zend_uchar comp_header[COMPRESSED_HEADER_SIZE];
! 428: DBG_ENTER("mysqlnd_read_compressed_packet_from_stream_and_fill_read_buffer");
! 429:
! 430: /* Read the compressed header */
! 431: if (FAIL == conn->net->m.network_read(conn, comp_header, COMPRESSED_HEADER_SIZE TSRMLS_CC)) {
! 432: DBG_RETURN(FAIL);
! 433: }
! 434: decompressed_size = uint3korr(comp_header);
! 435:
! 436: /* When decompressed_size is 0, then the data is not compressed, and we have wasted 3 bytes */
! 437: /* we need to decompress the data */
! 438:
! 439: if (decompressed_size) {
! 440: compressed_data = mnd_emalloc(net_payload_size);
! 441: if (FAIL == conn->net->m.network_read(conn, compressed_data, net_payload_size TSRMLS_CC)) {
! 442: ret = FAIL;
! 443: goto end;
! 444: }
! 445: net->uncompressed_data = mysqlnd_create_read_buffer(decompressed_size TSRMLS_CC);
! 446: ret = net->m.decode(net->uncompressed_data->data, decompressed_size, compressed_data, net_payload_size TSRMLS_CC);
! 447: if (ret == FAIL) {
! 448: goto end;
! 449: }
! 450: } else {
! 451: DBG_INF_FMT("The server decided not to compress the data. Our job is easy. Copying %u bytes", net_payload_size);
! 452: net->uncompressed_data = mysqlnd_create_read_buffer(net_payload_size TSRMLS_CC);
! 453: if (FAIL == conn->net->m.network_read(conn, net->uncompressed_data->data, net_payload_size TSRMLS_CC)) {
! 454: ret = FAIL;
! 455: goto end;
! 456: }
! 457: }
! 458: end:
! 459: if (compressed_data) {
! 460: mnd_efree(compressed_data);
! 461: }
! 462: DBG_RETURN(ret);
! 463: }
! 464: /* }}} */
! 465: #endif /* MYSQLND_COMPRESSION_ENABLED */
! 466:
! 467:
! 468: /* {{{ mysqlnd_net::decode */
! 469: static enum_func_status
! 470: MYSQLND_METHOD(mysqlnd_net, decode)(zend_uchar * uncompressed_data, size_t uncompressed_data_len,
! 471: const zend_uchar * const compressed_data, size_t compressed_data_len TSRMLS_DC)
! 472: {
! 473: #ifdef MYSQLND_COMPRESSION_ENABLED
! 474: int error;
! 475: uLongf tmp_complen = uncompressed_data_len;
! 476: DBG_ENTER("mysqlnd_net::decode");
! 477: error = uncompress(uncompressed_data, &tmp_complen, compressed_data, compressed_data_len);
! 478:
! 479: DBG_INF_FMT("compressed data: decomp_len=%lu compressed_size="MYSQLND_SZ_T_SPEC, tmp_complen, compressed_data_len);
! 480: if (error != Z_OK) {
! 481: DBG_INF_FMT("decompression NOT successful. error=%d Z_OK=%d Z_BUF_ERROR=%d Z_MEM_ERROR=%d", error, Z_OK, Z_BUF_ERROR, Z_MEM_ERROR);
! 482: }
! 483: DBG_RETURN(error == Z_OK? PASS:FAIL);
! 484: #else
! 485: DBG_ENTER("mysqlnd_net::decode");
! 486: DBG_RETURN(FAIL);
! 487: #endif
! 488: }
! 489: /* }}} */
! 490:
! 491:
! 492: /* {{{ mysqlnd_net::encode */
! 493: static enum_func_status
! 494: MYSQLND_METHOD(mysqlnd_net, encode)(zend_uchar * compress_buffer, size_t * compress_buffer_len,
! 495: const zend_uchar * const uncompressed_data, size_t uncompressed_data_len TSRMLS_DC)
! 496: {
! 497: #ifdef MYSQLND_COMPRESSION_ENABLED
! 498: int error;
! 499: uLongf tmp_complen = *compress_buffer_len;
! 500: DBG_ENTER("mysqlnd_net::encode");
! 501: error = compress(compress_buffer, &tmp_complen, uncompressed_data, uncompressed_data_len);
! 502:
! 503: if (error != Z_OK) {
! 504: DBG_INF_FMT("compression NOT successful. error=%d Z_OK=%d Z_BUF_ERROR=%d Z_MEM_ERROR=%d", error, Z_OK, Z_BUF_ERROR, Z_MEM_ERROR);
! 505: } else {
! 506: *compress_buffer_len = tmp_complen;
! 507: DBG_INF_FMT("compression successful. compressed size=%lu", tmp_complen);
! 508: }
! 509:
! 510: DBG_RETURN(error == Z_OK? PASS:FAIL);
! 511: #else
! 512: DBG_ENTER("mysqlnd_net::encode");
! 513: DBG_RETURN(FAIL);
! 514: #endif
! 515: }
! 516: /* }}} */
! 517:
! 518:
! 519: /* {{{ mysqlnd_net::receive */
! 520: static enum_func_status
! 521: MYSQLND_METHOD(mysqlnd_net, receive)(MYSQLND * conn, zend_uchar * buffer, size_t count TSRMLS_DC)
! 522: {
! 523: size_t to_read = count;
! 524: zend_uchar * p = buffer;
! 525: MYSQLND_NET * net = conn->net;
! 526:
! 527: DBG_ENTER("mysqlnd_net::receive");
! 528: #ifdef MYSQLND_COMPRESSION_ENABLED
! 529: if (net->compressed) {
! 530: if (net->uncompressed_data) {
! 531: size_t to_read_from_buffer = MIN(net->uncompressed_data->bytes_left(net->uncompressed_data), to_read);
! 532: DBG_INF_FMT("reading %u from uncompressed_data buffer", to_read_from_buffer);
! 533: if (to_read_from_buffer) {
! 534: net->uncompressed_data->read(net->uncompressed_data, to_read_from_buffer, (zend_uchar *) p);
! 535: p += to_read_from_buffer;
! 536: to_read -= to_read_from_buffer;
! 537: }
! 538: DBG_INF_FMT("left %u to read", to_read);
! 539: if (TRUE == net->uncompressed_data->is_empty(net->uncompressed_data)) {
! 540: /* Everything was consumed. This should never happen here, but for security */
! 541: net->uncompressed_data->free_buffer(&net->uncompressed_data TSRMLS_CC);
! 542: }
! 543: }
! 544: if (to_read) {
! 545: zend_uchar net_header[MYSQLND_HEADER_SIZE];
! 546: size_t net_payload_size;
! 547: zend_uchar packet_no;
! 548:
! 549: if (FAIL == net->m.network_read(conn, net_header, MYSQLND_HEADER_SIZE TSRMLS_CC)) {
! 550: DBG_RETURN(FAIL);
! 551: }
! 552: net_payload_size = uint3korr(net_header);
! 553: packet_no = uint1korr(net_header + 3);
! 554: if (net->compressed_envelope_packet_no != packet_no) {
! 555: DBG_ERR_FMT("Transport level: packets out of order. Expected %u received %u. Packet size="MYSQLND_SZ_T_SPEC,
! 556: net->compressed_envelope_packet_no, packet_no, net_payload_size);
! 557:
! 558: php_error(E_WARNING, "Packets out of order. Expected %u received %u. Packet size="MYSQLND_SZ_T_SPEC,
! 559: net->compressed_envelope_packet_no, packet_no, net_payload_size);
! 560: DBG_RETURN(FAIL);
! 561: }
! 562: net->compressed_envelope_packet_no++;
! 563: #ifdef MYSQLND_DUMP_HEADER_N_BODY
! 564: DBG_INF_FMT("HEADER: hwd_packet_no=%u size=%3u", packet_no, (unsigned long) net_payload_size);
! 565: #endif
! 566: /* Now let's read from the wire, decompress it and fill the read buffer */
! 567: mysqlnd_read_compressed_packet_from_stream_and_fill_read_buffer(conn, net_payload_size TSRMLS_CC);
! 568:
! 569: /*
! 570: Now a bit of recursion - read from the read buffer,
! 571: if the data which we have just read from the wire
! 572: is not enough, then the recursive call will try to
! 573: satisfy it until it is satisfied.
! 574: */
! 575: DBG_RETURN(net->m.receive(conn, p, to_read TSRMLS_CC));
! 576: }
! 577: DBG_RETURN(PASS);
! 578: }
! 579: #endif /* MYSQLND_COMPRESSION_ENABLED */
! 580: DBG_RETURN(net->m.network_read(conn, p, to_read TSRMLS_CC));
! 581: }
! 582: /* }}} */
! 583:
! 584:
! 585: /* {{{ mysqlnd_net::set_client_option */
! 586: static enum_func_status
! 587: MYSQLND_METHOD(mysqlnd_net, set_client_option)(MYSQLND_NET * const net, enum mysqlnd_option option, const char * const value TSRMLS_DC)
! 588: {
! 589: DBG_ENTER("mysqlnd_net::set_client_option");
! 590: DBG_INF_FMT("option=%u", option);
! 591: switch (option) {
! 592: case MYSQLND_OPT_NET_CMD_BUFFER_SIZE:
! 593: DBG_INF("MYSQLND_OPT_NET_CMD_BUFFER_SIZE");
! 594: if (*(unsigned int*) value < MYSQLND_NET_CMD_BUFFER_MIN_SIZE) {
! 595: DBG_RETURN(FAIL);
! 596: }
! 597: net->cmd_buffer.length = *(unsigned int*) value;
! 598: DBG_INF_FMT("new_length=%u", net->cmd_buffer.length);
! 599: if (!net->cmd_buffer.buffer) {
! 600: net->cmd_buffer.buffer = mnd_pemalloc(net->cmd_buffer.length, net->persistent);
! 601: } else {
! 602: net->cmd_buffer.buffer = mnd_perealloc(net->cmd_buffer.buffer, net->cmd_buffer.length, net->persistent);
! 603: }
! 604: break;
! 605: case MYSQLND_OPT_NET_READ_BUFFER_SIZE:
! 606: DBG_INF("MYSQLND_OPT_NET_READ_BUFFER_SIZE");
! 607: net->options.net_read_buffer_size = *(unsigned int*) value;
! 608: DBG_INF_FMT("new_length=%u", net->options.net_read_buffer_size);
! 609: break;
! 610: case MYSQL_OPT_CONNECT_TIMEOUT:
! 611: DBG_INF("MYSQL_OPT_CONNECT_TIMEOUT");
! 612: net->options.timeout_connect = *(unsigned int*) value;
! 613: break;
! 614: case MYSQLND_OPT_SSL_KEY:
! 615: {
! 616: zend_bool pers = net->persistent;
! 617: if (net->options.ssl_key) {
! 618: mnd_pefree(net->options.ssl_key, pers);
! 619: }
! 620: net->options.ssl_key = value? mnd_pestrdup(value, pers) : NULL;
! 621: break;
! 622: }
! 623: case MYSQLND_OPT_SSL_CERT:
! 624: {
! 625: zend_bool pers = net->persistent;
! 626: if (net->options.ssl_cert) {
! 627: mnd_pefree(net->options.ssl_cert, pers);
! 628: }
! 629: net->options.ssl_cert = value? mnd_pestrdup(value, pers) : NULL;
! 630: break;
! 631: }
! 632: case MYSQLND_OPT_SSL_CA:
! 633: {
! 634: zend_bool pers = net->persistent;
! 635: if (net->options.ssl_ca) {
! 636: mnd_pefree(net->options.ssl_ca, pers);
! 637: }
! 638: net->options.ssl_ca = value? mnd_pestrdup(value, pers) : NULL;
! 639: break;
! 640: }
! 641: case MYSQLND_OPT_SSL_CAPATH:
! 642: {
! 643: zend_bool pers = net->persistent;
! 644: if (net->options.ssl_capath) {
! 645: mnd_pefree(net->options.ssl_capath, pers);
! 646: }
! 647: net->options.ssl_capath = value? mnd_pestrdup(value, pers) : NULL;
! 648: break;
! 649: }
! 650: case MYSQLND_OPT_SSL_CIPHER:
! 651: {
! 652: zend_bool pers = net->persistent;
! 653: if (net->options.ssl_cipher) {
! 654: mnd_pefree(net->options.ssl_cipher, pers);
! 655: }
! 656: net->options.ssl_cipher = value? mnd_pestrdup(value, pers) : NULL;
! 657: break;
! 658: }
! 659: case MYSQLND_OPT_SSL_PASSPHRASE:
! 660: {
! 661: zend_bool pers = net->persistent;
! 662: if (net->options.ssl_passphrase) {
! 663: mnd_pefree(net->options.ssl_passphrase, pers);
! 664: }
! 665: net->options.ssl_passphrase = value? mnd_pestrdup(value, pers) : NULL;
! 666: break;
! 667: }
! 668: case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:
! 669: net->options.ssl_verify_peer = value? ((*(zend_bool *)value)? TRUE:FALSE): FALSE;
! 670: break;
! 671: #ifdef WHEN_SUPPORTED_BY_MYSQLI
! 672: case MYSQL_OPT_READ_TIMEOUT:
! 673: DBG_INF("MYSQL_OPT_READ_TIMEOUT");
! 674: net->options.timeout_read = *(unsigned int*) value;
! 675: break;
! 676: case MYSQL_OPT_WRITE_TIMEOUT:
! 677: DBG_INF("MYSQL_OPT_WRITE_TIMEOUT");
! 678: net->options.timeout_write = *(unsigned int*) value;
! 679: break;
! 680: #endif
! 681: case MYSQL_OPT_COMPRESS:
! 682: net->options.flags |= MYSQLND_NET_FLAG_USE_COMPRESSION;
! 683: break;
! 684: default:
! 685: DBG_RETURN(FAIL);
! 686: }
! 687: DBG_RETURN(PASS);
! 688: }
! 689: /* }}} */
! 690:
! 691: /* {{{ mysqlnd_net::consume_uneaten_data */
! 692: size_t
! 693: MYSQLND_METHOD(mysqlnd_net, consume_uneaten_data)(MYSQLND_NET * const net, enum php_mysqlnd_server_command cmd TSRMLS_DC)
! 694: {
! 695: #ifdef MYSQLND_DO_WIRE_CHECK_BEFORE_COMMAND
! 696: /*
! 697: Switch to non-blocking mode and try to consume something from
! 698: the line, if possible, then continue. This saves us from looking for
! 699: the actuall place where out-of-order packets have been sent.
! 700: If someone is completely sure that everything is fine, he can switch it
! 701: off.
! 702: */
! 703: char tmp_buf[256];
! 704: size_t skipped_bytes = 0;
! 705: int opt = PHP_STREAM_OPTION_BLOCKING;
! 706: int was_blocked = net->stream->ops->set_option(net->stream, opt, 0, NULL TSRMLS_CC);
! 707:
! 708: DBG_ENTER("mysqlnd_net::consume_uneaten_data");
! 709:
! 710: if (PHP_STREAM_OPTION_RETURN_ERR != was_blocked) {
! 711: /* Do a read of 1 byte */
! 712: int bytes_consumed;
! 713:
! 714: do {
! 715: skipped_bytes += (bytes_consumed = php_stream_read(net->stream, tmp_buf, sizeof(tmp_buf)));
! 716: } while (bytes_consumed == sizeof(tmp_buf));
! 717:
! 718: if (was_blocked) {
! 719: net->stream->ops->set_option(net->stream, opt, 1, NULL TSRMLS_CC);
! 720: }
! 721:
! 722: if (bytes_consumed) {
! 723: DBG_ERR_FMT("Skipped %u bytes. Last command %s hasn't consumed all the output from the server",
! 724: bytes_consumed, mysqlnd_command_to_text[net->last_command]);
! 725: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Skipped %u bytes. Last command %s hasn't "
! 726: "consumed all the output from the server",
! 727: bytes_consumed, mysqlnd_command_to_text[net->last_command]);
! 728: }
! 729: }
! 730: net->last_command = cmd;
! 731:
! 732: DBG_RETURN(skipped_bytes);
! 733: #else
! 734: return 0;
! 735: #endif
! 736: }
! 737: /* }}} */
! 738:
! 739: /*
! 740: in libmyusql, if cert and !key then key=cert
! 741: */
! 742: /* {{{ mysqlnd_net::enable_ssl */
! 743: static enum_func_status
! 744: MYSQLND_METHOD(mysqlnd_net, enable_ssl)(MYSQLND_NET * const net TSRMLS_DC)
! 745: {
! 746: #ifdef MYSQLND_SSL_SUPPORTED
! 747: php_stream_context *context = php_stream_context_alloc();
! 748: DBG_ENTER("mysqlnd_net::enable_ssl");
! 749: if (!context) {
! 750: DBG_RETURN(FAIL);
! 751: }
! 752:
! 753: if (net->options.ssl_key) {
! 754: zval key_zval;
! 755: ZVAL_STRING(&key_zval, net->options.ssl_key, 0);
! 756: DBG_INF("key");
! 757: php_stream_context_set_option(context, "ssl", "local_pk", &key_zval);
! 758: }
! 759: if (net->options.ssl_verify_peer) {
! 760: zval verify_peer_zval;
! 761: ZVAL_TRUE(&verify_peer_zval);
! 762: DBG_INF("verify peer");
! 763: php_stream_context_set_option(context, "ssl", "verify_peer", &verify_peer_zval);
! 764: }
! 765: if (net->options.ssl_cert) {
! 766: zval cert_zval;
! 767: ZVAL_STRING(&cert_zval, net->options.ssl_cert, 0);
! 768: DBG_INF_FMT("local_cert=%s", net->options.ssl_cert);
! 769: php_stream_context_set_option(context, "ssl", "local_cert", &cert_zval);
! 770: if (!net->options.ssl_key) {
! 771: php_stream_context_set_option(context, "ssl", "local_pk", &cert_zval);
! 772: }
! 773: }
! 774: if (net->options.ssl_ca) {
! 775: zval cafile_zval;
! 776: ZVAL_STRING(&cafile_zval, net->options.ssl_ca, 0);
! 777: DBG_INF_FMT("cafile=%s", net->options.ssl_ca);
! 778: php_stream_context_set_option(context, "ssl", "cafile", &cafile_zval);
! 779: }
! 780: if (net->options.ssl_capath) {
! 781: zval capath_zval;
! 782: ZVAL_STRING(&capath_zval, net->options.ssl_capath, 0);
! 783: DBG_INF_FMT("capath=%s", net->options.ssl_capath);
! 784: php_stream_context_set_option(context, "ssl", "cafile", &capath_zval);
! 785: }
! 786: if (net->options.ssl_passphrase) {
! 787: zval passphrase_zval;
! 788: ZVAL_STRING(&passphrase_zval, net->options.ssl_passphrase, 0);
! 789: php_stream_context_set_option(context, "ssl", "passphrase", &passphrase_zval);
! 790: }
! 791: if (net->options.ssl_cipher) {
! 792: zval cipher_zval;
! 793: ZVAL_STRING(&cipher_zval, net->options.ssl_cipher, 0);
! 794: DBG_INF_FMT("ciphers=%s", net->options.ssl_cipher);
! 795: php_stream_context_set_option(context, "ssl", "ciphers", &cipher_zval);
! 796: }
! 797: php_stream_context_set(net->stream, context);
! 798: if (php_stream_xport_crypto_setup(net->stream, STREAM_CRYPTO_METHOD_TLS_CLIENT, NULL TSRMLS_CC) < 0 ||
! 799: php_stream_xport_crypto_enable(net->stream, 1 TSRMLS_CC) < 0)
! 800: {
! 801: DBG_ERR("Cannot connect to MySQL by using SSL");
! 802: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot connect to MySQL by using SSL");
! 803: DBG_RETURN(FAIL);
! 804: }
! 805: /*
! 806: get rid of the context. we are persistent and if this is a real pconn used by mysql/mysqli,
! 807: then the context would not survive cleaning of EG(regular_list), where it is registered, as a
! 808: resource. What happens is that after this destruction any use of the network will mean usage
! 809: of the context, which means usage of already freed memory, bad. Actually we don't need this
! 810: context anymore after we have enabled SSL on the connection. Thus it is very simple, we remove it.
! 811: */
! 812: php_stream_context_set(net->stream, NULL);
! 813:
! 814: if (net->options.timeout_read) {
! 815: struct timeval tv;
! 816: DBG_INF_FMT("setting %u as PHP_STREAM_OPTION_READ_TIMEOUT", net->options.timeout_read);
! 817: tv.tv_sec = net->options.timeout_read;
! 818: tv.tv_usec = 0;
! 819: php_stream_set_option(net->stream, PHP_STREAM_OPTION_READ_TIMEOUT, 0, &tv);
! 820: }
! 821:
! 822: DBG_RETURN(PASS);
! 823: #else
! 824: DBG_ENTER("mysqlnd_net::enable_ssl");
! 825: DBG_RETURN(PASS);
! 826: #endif
! 827: }
! 828: /* }}} */
! 829:
! 830:
! 831: /* {{{ mysqlnd_net::disable_ssl */
! 832: static enum_func_status
! 833: MYSQLND_METHOD(mysqlnd_net, disable_ssl)(MYSQLND_NET * const net TSRMLS_DC)
! 834: {
! 835: DBG_ENTER("mysqlnd_net::disable_ssl");
! 836: DBG_RETURN(PASS);
! 837: }
! 838: /* }}} */
! 839:
! 840:
! 841: /* {{{ mysqlnd_net::set_client_option */
! 842: static void
! 843: MYSQLND_METHOD(mysqlnd_net, free_contents)(MYSQLND_NET * net TSRMLS_DC)
! 844: {
! 845: zend_bool pers = net->persistent;
! 846: DBG_ENTER("mysqlnd_net::free_contents");
! 847:
! 848: #ifdef MYSQLND_COMPRESSION_ENABLED
! 849: if (net->uncompressed_data) {
! 850: net->uncompressed_data->free_buffer(&net->uncompressed_data TSRMLS_CC);
! 851: }
! 852: #endif
! 853: if (net->options.ssl_key) {
! 854: mnd_pefree(net->options.ssl_key, pers);
! 855: net->options.ssl_key = NULL;
! 856: }
! 857: if (net->options.ssl_cert) {
! 858: mnd_pefree(net->options.ssl_cert, pers);
! 859: net->options.ssl_cert = NULL;
! 860: }
! 861: if (net->options.ssl_ca) {
! 862: mnd_pefree(net->options.ssl_ca, pers);
! 863: net->options.ssl_ca = NULL;
! 864: }
! 865: if (net->options.ssl_capath) {
! 866: mnd_pefree(net->options.ssl_capath, pers);
! 867: net->options.ssl_capath = NULL;
! 868: }
! 869: if (net->options.ssl_cipher) {
! 870: mnd_pefree(net->options.ssl_cipher, pers);
! 871: net->options.ssl_cipher = NULL;
! 872: }
! 873:
! 874: DBG_VOID_RETURN;
! 875: }
! 876: /* }}} */
! 877:
! 878: static
! 879: MYSQLND_CLASS_METHODS_START(mysqlnd_net)
! 880: MYSQLND_METHOD(mysqlnd_net, connect),
! 881: MYSQLND_METHOD(mysqlnd_net, send),
! 882: MYSQLND_METHOD(mysqlnd_net, receive),
! 883: MYSQLND_METHOD(mysqlnd_net, set_client_option),
! 884: MYSQLND_METHOD(mysqlnd_net, network_read),
! 885: MYSQLND_METHOD(mysqlnd_net, network_write),
! 886: MYSQLND_METHOD(mysqlnd_net, decode),
! 887: MYSQLND_METHOD(mysqlnd_net, encode),
! 888: MYSQLND_METHOD(mysqlnd_net, consume_uneaten_data),
! 889: MYSQLND_METHOD(mysqlnd_net, free_contents),
! 890: MYSQLND_METHOD(mysqlnd_net, enable_ssl),
! 891: MYSQLND_METHOD(mysqlnd_net, disable_ssl)
! 892: MYSQLND_CLASS_METHODS_END;
! 893:
! 894:
! 895: /* {{{ mysqlnd_net_init */
! 896: PHPAPI MYSQLND_NET *
! 897: mysqlnd_net_init(zend_bool persistent TSRMLS_DC)
! 898: {
! 899: size_t alloc_size = sizeof(MYSQLND_NET) + mysqlnd_plugin_count() * sizeof(void *);
! 900: MYSQLND_NET * net = mnd_pecalloc(1, alloc_size, persistent);
! 901:
! 902: DBG_ENTER("mysqlnd_net_init");
! 903: DBG_INF_FMT("persistent=%u", persistent);
! 904: if (net) {
! 905: net->persistent = persistent;
! 906: net->m = mysqlnd_mysqlnd_net_methods;
! 907:
! 908: {
! 909: unsigned int buf_size = MYSQLND_G(net_cmd_buffer_size); /* this is long, cast to unsigned int*/
! 910: net->m.set_client_option(net, MYSQLND_OPT_NET_CMD_BUFFER_SIZE, (char *) &buf_size TSRMLS_CC);
! 911: }
! 912: }
! 913: DBG_RETURN(net);
! 914: }
! 915: /* }}} */
! 916:
! 917:
! 918: /* {{{ mysqlnd_net_free */
! 919: PHPAPI void
! 920: mysqlnd_net_free(MYSQLND_NET * const net TSRMLS_DC)
! 921: {
! 922: DBG_ENTER("mysqlnd_net_free");
! 923:
! 924: if (net) {
! 925: zend_bool pers = net->persistent;
! 926:
! 927: net->m.free_contents(net TSRMLS_CC);
! 928: if (net->cmd_buffer.buffer) {
! 929: DBG_INF("Freeing cmd buffer");
! 930: mnd_pefree(net->cmd_buffer.buffer, pers);
! 931: net->cmd_buffer.buffer = NULL;
! 932: }
! 933: if (net->stream) {
! 934: DBG_INF_FMT("Freeing stream. abstract=%p", net->stream->abstract);
! 935: if (pers) {
! 936: php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE_PERSISTENT | PHP_STREAM_FREE_RSRC_DTOR);
! 937: } else {
! 938: php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE);
! 939: }
! 940: net->stream = NULL;
! 941: }
! 942: mnd_pefree(net, pers);
! 943: }
! 944: DBG_VOID_RETURN;
! 945: }
! 946: /* }}} */
! 947:
! 948:
! 949: /* {{{ _mysqlnd_plugin_get_plugin_net_data */
! 950: PHPAPI void ** _mysqlnd_plugin_get_plugin_net_data(const MYSQLND_NET * net, unsigned int plugin_id TSRMLS_DC)
! 951: {
! 952: DBG_ENTER("_mysqlnd_plugin_get_plugin_net_data");
! 953: DBG_INF_FMT("plugin_id=%u", plugin_id);
! 954: if (!net || plugin_id >= mysqlnd_plugin_count()) {
! 955: return NULL;
! 956: }
! 957: DBG_RETURN((void *)((char *)net + sizeof(MYSQLND_NET) + plugin_id * sizeof(void *)));
! 958: }
! 959: /* }}} */
! 960:
! 961:
! 962: /* {{{ mysqlnd_net_get_methods */
! 963: PHPAPI struct st_mysqlnd_net_methods *
! 964: mysqlnd_net_get_methods()
! 965: {
! 966: return &mysqlnd_mysqlnd_net_methods;
! 967: }
! 968: /* }}} */
! 969:
! 970:
! 971: /*
! 972: * Local variables:
! 973: * tab-width: 4
! 974: * c-basic-offset: 4
! 975: * End:
! 976: * vim600: noet sw=4 ts=4 fdm=marker
! 977: * vim<600: noet sw=4 ts=4
! 978: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mysqlnd_net.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