Annotation of embedaddon/php/ext/mysqlnd/mysqlnd.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:
! 21: /* $Id: mysqlnd.c 321634 2012-01-01 13:15:04Z felipe $ */
! 22: #include "php.h"
! 23: #include "mysqlnd.h"
! 24: #include "mysqlnd_wireprotocol.h"
! 25: #include "mysqlnd_priv.h"
! 26: #include "mysqlnd_result.h"
! 27: #include "mysqlnd_statistics.h"
! 28: #include "mysqlnd_charset.h"
! 29: #include "mysqlnd_debug.h"
! 30: /* for php_get_current_user() */
! 31: #include "ext/standard/basic_functions.h"
! 32:
! 33: /*
! 34: TODO :
! 35: - Don't bind so tightly the metadata with the result set. This means
! 36: that the metadata reading should not expect a MYSQLND_RES pointer, it
! 37: does not need it, but return a pointer to the metadata (MYSQLND_FIELD *).
! 38: For normal statements we will then just assign it to a member of
! 39: MYSQLND_RES. For PS statements, it will stay as part of the statement
! 40: (MYSQLND_STMT) between prepare and execute. At execute the new metadata
! 41: will be sent by the server, so we will discard the old one and then
! 42: finally attach it to the result set. This will make the code more clean,
! 43: as a prepared statement won't have anymore stmt->result != NULL, as it
! 44: is now, just to have where to store the metadata.
! 45:
! 46: - Change mysqlnd_simple_command to accept a heap dynamic array of MYSQLND_STRING
! 47: terminated by a string with ptr being NULL. Thus, multi-part messages can be
! 48: sent to the network like writev() and this can save at least for
! 49: mysqlnd_stmt_send_long_data() new malloc. This change will probably make the
! 50: code in few other places cleaner.
! 51: */
! 52:
! 53: extern MYSQLND_CHARSET *mysqlnd_charsets;
! 54:
! 55:
! 56:
! 57: PHPAPI const char * const mysqlnd_old_passwd = "mysqlnd cannot connect to MySQL 4.1+ using the old insecure authentication. "
! 58: "Please use an administration tool to reset your password with the command SET PASSWORD = PASSWORD('your_existing_password'). This will "
! 59: "store a new, and more secure, hash value in mysql.user. If this user is used in other scripts executed by PHP 5.2 or earlier you might need to remove the old-passwords "
! 60: "flag from your my.cnf file";
! 61:
! 62: PHPAPI const char * const mysqlnd_server_gone = "MySQL server has gone away";
! 63: PHPAPI const char * const mysqlnd_out_of_sync = "Commands out of sync; you can't run this command now";
! 64: PHPAPI const char * const mysqlnd_out_of_memory = "Out of memory";
! 65:
! 66: PHPAPI MYSQLND_STATS *mysqlnd_global_stats = NULL;
! 67: static zend_bool mysqlnd_library_initted = FALSE;
! 68:
! 69: static struct st_mysqlnd_conn_methods *mysqlnd_conn_methods;
! 70:
! 71: /* {{{ mysqlnd_library_end */
! 72: PHPAPI void mysqlnd_library_end(TSRMLS_D)
! 73: {
! 74: if (mysqlnd_library_initted == TRUE) {
! 75: mysqlnd_stats_end(mysqlnd_global_stats);
! 76: mysqlnd_global_stats = NULL;
! 77: mysqlnd_library_initted = FALSE;
! 78: }
! 79: }
! 80: /* }}} */
! 81:
! 82:
! 83: /* {{{ mysqlnd_conn::free_options */
! 84: static void
! 85: MYSQLND_METHOD(mysqlnd_conn, free_options)(MYSQLND * conn TSRMLS_DC)
! 86: {
! 87: zend_bool pers = conn->persistent;
! 88:
! 89: if (conn->options.charset_name) {
! 90: mnd_pefree(conn->options.charset_name, pers);
! 91: conn->options.charset_name = NULL;
! 92: }
! 93: if (conn->options.num_commands) {
! 94: unsigned int i;
! 95: for (i = 0; i < conn->options.num_commands; i++) {
! 96: /* allocated with pestrdup */
! 97: mnd_pefree(conn->options.init_commands[i], pers);
! 98: }
! 99: mnd_pefree(conn->options.init_commands, pers);
! 100: conn->options.init_commands = NULL;
! 101: }
! 102: if (conn->options.cfg_file) {
! 103: mnd_pefree(conn->options.cfg_file, pers);
! 104: conn->options.cfg_file = NULL;
! 105: }
! 106: if (conn->options.cfg_section) {
! 107: mnd_pefree(conn->options.cfg_section, pers);
! 108: conn->options.cfg_section = NULL;
! 109: }
! 110: }
! 111: /* }}} */
! 112:
! 113:
! 114: /* {{{ mysqlnd_conn::free_contents */
! 115: static void
! 116: MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND * conn TSRMLS_DC)
! 117: {
! 118: zend_bool pers = conn->persistent;
! 119:
! 120: DBG_ENTER("mysqlnd_conn::free_contents");
! 121:
! 122: mysqlnd_local_infile_default(conn);
! 123: if (conn->current_result) {
! 124: conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC);
! 125: conn->current_result = NULL;
! 126: }
! 127:
! 128: if (conn->net) {
! 129: conn->net->m.free_contents(conn->net TSRMLS_CC);
! 130: }
! 131:
! 132: DBG_INF("Freeing memory of members");
! 133:
! 134: if (conn->host) {
! 135: DBG_INF("Freeing host");
! 136: mnd_pefree(conn->host, pers);
! 137: conn->host = NULL;
! 138: }
! 139: if (conn->user) {
! 140: DBG_INF("Freeing user");
! 141: mnd_pefree(conn->user, pers);
! 142: conn->user = NULL;
! 143: }
! 144: if (conn->passwd) {
! 145: DBG_INF("Freeing passwd");
! 146: mnd_pefree(conn->passwd, pers);
! 147: conn->passwd = NULL;
! 148: }
! 149: if (conn->connect_or_select_db) {
! 150: DBG_INF("Freeing connect_or_select_db");
! 151: mnd_pefree(conn->connect_or_select_db, pers);
! 152: conn->connect_or_select_db = NULL;
! 153: }
! 154: if (conn->unix_socket) {
! 155: DBG_INF("Freeing unix_socket");
! 156: mnd_pefree(conn->unix_socket, pers);
! 157: conn->unix_socket = NULL;
! 158: }
! 159: DBG_INF_FMT("scheme=%s", conn->scheme);
! 160: if (conn->scheme) {
! 161: DBG_INF("Freeing scheme");
! 162: mnd_pefree(conn->scheme, pers);
! 163: conn->scheme = NULL;
! 164: }
! 165: if (conn->server_version) {
! 166: DBG_INF("Freeing server_version");
! 167: mnd_pefree(conn->server_version, pers);
! 168: conn->server_version = NULL;
! 169: }
! 170: if (conn->host_info) {
! 171: DBG_INF("Freeing host_info");
! 172: mnd_pefree(conn->host_info, pers);
! 173: conn->host_info = NULL;
! 174: }
! 175: if (conn->scramble) {
! 176: DBG_INF("Freeing scramble");
! 177: mnd_pefree(conn->scramble, pers);
! 178: conn->scramble = NULL;
! 179: }
! 180: if (conn->last_message) {
! 181: mnd_pefree(conn->last_message, pers);
! 182: conn->last_message = NULL;
! 183: }
! 184: conn->charset = NULL;
! 185: conn->greet_charset = NULL;
! 186:
! 187: DBG_VOID_RETURN;
! 188: }
! 189: /* }}} */
! 190:
! 191:
! 192: /* {{{ mysqlnd_conn::dtor */
! 193: static void
! 194: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND * conn TSRMLS_DC)
! 195: {
! 196: DBG_ENTER("mysqlnd_conn::dtor");
! 197: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 198:
! 199: conn->m->free_contents(conn TSRMLS_CC);
! 200: conn->m->free_options(conn TSRMLS_CC);
! 201:
! 202: if (conn->net) {
! 203: DBG_INF("Freeing net");
! 204: mysqlnd_net_free(conn->net TSRMLS_CC);
! 205: conn->net = NULL;
! 206: }
! 207:
! 208: if (conn->protocol) {
! 209: DBG_INF("Freeing protocol");
! 210: mysqlnd_protocol_free(conn->protocol TSRMLS_CC);
! 211: conn->protocol = NULL;
! 212: }
! 213:
! 214: if (conn->stats) {
! 215: mysqlnd_stats_end(conn->stats);
! 216: }
! 217:
! 218: mnd_pefree(conn, conn->persistent);
! 219:
! 220: DBG_VOID_RETURN;
! 221: }
! 222: /* }}} */
! 223:
! 224:
! 225: /* {{{ mysqlnd_conn::simple_command_handle_response */
! 226: static enum_func_status
! 227: MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enum mysqlnd_packet_type ok_packet,
! 228: zend_bool silent, enum php_mysqlnd_server_command command,
! 229: zend_bool ignore_upsert_status TSRMLS_DC)
! 230: {
! 231: enum_func_status ret = FAIL;
! 232:
! 233: DBG_ENTER("mysqlnd_conn::simple_command_handle_response");
! 234: DBG_INF_FMT("silent=%u packet=%u command=%s", silent, ok_packet, mysqlnd_command_to_text[command]);
! 235:
! 236: switch (ok_packet) {
! 237: case PROT_OK_PACKET:{
! 238: MYSQLND_PACKET_OK * ok_response = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC);
! 239: if (!ok_response) {
! 240: SET_OOM_ERROR(conn->error_info);
! 241: break;
! 242: }
! 243: if (FAIL == (ret = PACKET_READ(ok_response, conn))) {
! 244: if (!silent) {
! 245: DBG_ERR_FMT("Error while reading %s's OK packet", mysqlnd_command_to_text[command]);
! 246: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's OK packet. PID=%u",
! 247: mysqlnd_command_to_text[command], getpid());
! 248: }
! 249: } else {
! 250: DBG_INF_FMT("OK from server");
! 251: if (0xFF == ok_response->field_count) {
! 252: /* The server signalled error. Set the error */
! 253: SET_CLIENT_ERROR(conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error);
! 254: ret = FAIL;
! 255: /*
! 256: Cover a protocol design error: error packet does not
! 257: contain the server status. Therefore, the client has no way
! 258: to find out whether there are more result sets of
! 259: a multiple-result-set statement pending. Luckily, in 5.0 an
! 260: error always aborts execution of a statement, wherever it is
! 261: a multi-statement or a stored procedure, so it should be
! 262: safe to unconditionally turn off the flag here.
! 263: */
! 264: conn->upsert_status.server_status &= ~SERVER_MORE_RESULTS_EXISTS;
! 265: SET_ERROR_AFF_ROWS(conn);
! 266: } else {
! 267: SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
! 268: ok_response->message, ok_response->message_len,
! 269: conn->persistent);
! 270:
! 271: if (!ignore_upsert_status) {
! 272: conn->upsert_status.warning_count = ok_response->warning_count;
! 273: conn->upsert_status.server_status = ok_response->server_status;
! 274: conn->upsert_status.affected_rows = ok_response->affected_rows;
! 275: conn->upsert_status.last_insert_id = ok_response->last_insert_id;
! 276: }
! 277: }
! 278: }
! 279: PACKET_FREE(ok_response);
! 280: break;
! 281: }
! 282: case PROT_EOF_PACKET:{
! 283: MYSQLND_PACKET_EOF * ok_response = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC);
! 284: if (!ok_response) {
! 285: SET_OOM_ERROR(conn->error_info);
! 286: break;
! 287: }
! 288: if (FAIL == (ret = PACKET_READ(ok_response, conn))) {
! 289: SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE,
! 290: "Malformed packet");
! 291: if (!silent) {
! 292: DBG_ERR_FMT("Error while reading %s's EOF packet", mysqlnd_command_to_text[command]);
! 293: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's EOF packet. PID=%d",
! 294: mysqlnd_command_to_text[command], getpid());
! 295: }
! 296: } else if (0xFF == ok_response->field_count) {
! 297: /* The server signalled error. Set the error */
! 298: SET_CLIENT_ERROR(conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error);
! 299: SET_ERROR_AFF_ROWS(conn);
! 300: } else if (0xFE != ok_response->field_count) {
! 301: SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet");
! 302: if (!silent) {
! 303: DBG_ERR_FMT("EOF packet expected, field count wasn't 0xFE but 0x%2X", ok_response->field_count);
! 304: php_error_docref(NULL TSRMLS_CC, E_WARNING, "EOF packet expected, field count wasn't 0xFE but 0x%2X",
! 305: ok_response->field_count);
! 306: }
! 307: } else {
! 308: DBG_INF_FMT("OK from server");
! 309: }
! 310: PACKET_FREE(ok_response);
! 311: break;
! 312: }
! 313: default:
! 314: SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet");
! 315: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong response packet %u passed to the function", ok_packet);
! 316: break;
! 317: }
! 318: DBG_INF(ret == PASS ? "PASS":"FAIL");
! 319: DBG_RETURN(ret);
! 320: }
! 321: /* }}} */
! 322:
! 323:
! 324: /* {{{ mysqlnd_conn::simple_command */
! 325: static enum_func_status
! 326: MYSQLND_METHOD(mysqlnd_conn, simple_command)(MYSQLND * conn, enum php_mysqlnd_server_command command,
! 327: const char * const arg, size_t arg_len, enum mysqlnd_packet_type ok_packet, zend_bool silent,
! 328: zend_bool ignore_upsert_status TSRMLS_DC)
! 329: {
! 330: enum_func_status ret = PASS;
! 331: MYSQLND_PACKET_COMMAND * cmd_packet;
! 332:
! 333: DBG_ENTER("mysqlnd_conn::simple_command");
! 334: DBG_INF_FMT("command=%s ok_packet=%u silent=%u", mysqlnd_command_to_text[command], ok_packet, silent);
! 335:
! 336: switch (CONN_GET_STATE(conn)) {
! 337: case CONN_READY:
! 338: break;
! 339: case CONN_QUIT_SENT:
! 340: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
! 341: DBG_ERR("Server is gone");
! 342: DBG_RETURN(FAIL);
! 343: default:
! 344: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
! 345: DBG_ERR_FMT("Command out of sync. State=%u", CONN_GET_STATE(conn));
! 346: DBG_RETURN(FAIL);
! 347: }
! 348:
! 349: /* clean UPSERT info */
! 350: if (!ignore_upsert_status) {
! 351: memset(&conn->upsert_status, 0, sizeof(conn->upsert_status));
! 352: }
! 353: SET_ERROR_AFF_ROWS(conn);
! 354: SET_EMPTY_ERROR(conn->error_info);
! 355:
! 356: cmd_packet = conn->protocol->m.get_command_packet(conn->protocol, FALSE TSRMLS_CC);
! 357: if (!cmd_packet) {
! 358: SET_OOM_ERROR(conn->error_info);
! 359: DBG_RETURN(FAIL);
! 360: }
! 361:
! 362: cmd_packet->command = command;
! 363: if (arg && arg_len) {
! 364: cmd_packet->argument = arg;
! 365: cmd_packet->arg_len = arg_len;
! 366: }
! 367:
! 368: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_COM_QUIT + command - 1 /* because of COM_SLEEP */ );
! 369:
! 370: if (! PACKET_WRITE(cmd_packet, conn)) {
! 371: if (!silent) {
! 372: DBG_ERR_FMT("Error while sending %s packet", mysqlnd_command_to_text[command]);
! 373: php_error(E_WARNING, "Error while sending %s packet. PID=%d", mysqlnd_command_to_text[command], getpid());
! 374: }
! 375: DBG_ERR("Server is gone");
! 376: ret = FAIL;
! 377: } else if (ok_packet != PROT_LAST) {
! 378: ret = conn->m->simple_command_handle_response(conn, ok_packet, silent, command, ignore_upsert_status TSRMLS_CC);
! 379: }
! 380:
! 381: PACKET_FREE(cmd_packet);
! 382: DBG_INF(ret == PASS ? "PASS":"FAIL");
! 383: DBG_RETURN(ret);
! 384: }
! 385: /* }}} */
! 386:
! 387:
! 388: /* {{{ mysqlnd_conn::set_server_option */
! 389: static enum_func_status
! 390: MYSQLND_METHOD(mysqlnd_conn, set_server_option)(MYSQLND * const conn, enum_mysqlnd_server_option option TSRMLS_DC)
! 391: {
! 392: enum_func_status ret;
! 393: char buffer[2];
! 394: DBG_ENTER("mysqlnd_conn::set_server_option");
! 395:
! 396: int2store(buffer, (unsigned int) option);
! 397: ret = conn->m->simple_command(conn, COM_SET_OPTION, buffer, sizeof(buffer), PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC);
! 398: DBG_RETURN(ret);
! 399: }
! 400: /* }}} */
! 401:
! 402:
! 403: /* {{{ mysqlnd_conn::restart_psession */
! 404: static enum_func_status
! 405: MYSQLND_METHOD(mysqlnd_conn, restart_psession)(MYSQLND * conn TSRMLS_DC)
! 406: {
! 407: DBG_ENTER("mysqlnd_conn::restart_psession");
! 408: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_REUSED);
! 409: /* Free here what should not be seen by the next script */
! 410: if (conn->last_message) {
! 411: mnd_pefree(conn->last_message, conn->persistent);
! 412: conn->last_message = NULL;
! 413: }
! 414: DBG_RETURN(PASS);
! 415: }
! 416: /* }}} */
! 417:
! 418:
! 419: /* {{{ mysqlnd_conn::end_psession */
! 420: static enum_func_status
! 421: MYSQLND_METHOD(mysqlnd_conn, end_psession)(MYSQLND * conn TSRMLS_DC)
! 422: {
! 423: DBG_ENTER("mysqlnd_conn::end_psession");
! 424: DBG_RETURN(PASS);
! 425: }
! 426: /* }}} */
! 427:
! 428:
! 429: #define MYSQLND_ASSEBLED_PACKET_MAX_SIZE 3UL*1024UL*1024UL*1024UL
! 430: /* {{{ mysqlnd_connect_run_authentication */
! 431: static enum_func_status
! 432: mysqlnd_connect_run_authentication(
! 433: MYSQLND * conn,
! 434: const char * const user,
! 435: const char * const passwd,
! 436: const char * const db,
! 437: size_t db_len,
! 438: const MYSQLND_PACKET_GREET * const greet_packet,
! 439: const MYSQLND_OPTIONS * const options,
! 440: unsigned long mysql_flags
! 441: TSRMLS_DC)
! 442: {
! 443: const MYSQLND_CHARSET * charset = NULL;
! 444: enum_func_status ret = FAIL;
! 445: MYSQLND_PACKET_AUTH * auth_packet = conn->protocol->m.get_auth_packet(conn->protocol, FALSE TSRMLS_CC);
! 446: MYSQLND_PACKET_OK * ok_packet = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC);
! 447:
! 448: DBG_ENTER("mysqlnd_connect_run_authentication");
! 449:
! 450: if (!auth_packet || !ok_packet) {
! 451: SET_OOM_ERROR(conn->error_info);
! 452: goto err;
! 453: }
! 454:
! 455: #ifdef MYSQLND_SSL_SUPPORTED
! 456: if ((greet_packet->server_capabilities & CLIENT_SSL) && (mysql_flags & CLIENT_SSL)) {
! 457: auth_packet->send_half_packet = TRUE;
! 458: }
! 459: #endif
! 460: auth_packet->user = user;
! 461: auth_packet->password = passwd;
! 462:
! 463: if (options->charset_name && (charset = mysqlnd_find_charset_name(options->charset_name))) {
! 464: auth_packet->charset_no = charset->nr;
! 465: } else {
! 466: #if MYSQLND_UNICODE
! 467: auth_packet->charset_no = 200;/* utf8 - swedish collation, check mysqlnd_charset.c */
! 468: #else
! 469: auth_packet->charset_no = greet_packet->charset_no;
! 470: #endif
! 471: }
! 472: auth_packet->db = db;
! 473: auth_packet->db_len = db_len;
! 474: auth_packet->max_packet_size= MYSQLND_ASSEBLED_PACKET_MAX_SIZE;
! 475: auth_packet->client_flags= mysql_flags;
! 476:
! 477: conn->scramble = auth_packet->server_scramble_buf = mnd_pemalloc(SCRAMBLE_LENGTH, conn->persistent);
! 478: if (!conn->scramble) {
! 479: SET_OOM_ERROR(conn->error_info);
! 480: goto err;
! 481: }
! 482: memcpy(auth_packet->server_scramble_buf, greet_packet->scramble_buf, SCRAMBLE_LENGTH);
! 483:
! 484: if (!PACKET_WRITE(auth_packet, conn)) {
! 485: CONN_SET_STATE(conn, CONN_QUIT_SENT);
! 486: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
! 487: goto err;
! 488: }
! 489:
! 490: #ifdef MYSQLND_SSL_SUPPORTED
! 491: if (auth_packet->send_half_packet) {
! 492: zend_bool verify = mysql_flags & CLIENT_SSL_VERIFY_SERVER_CERT? TRUE:FALSE;
! 493: DBG_INF("Switching to SSL");
! 494:
! 495: conn->net->m.set_client_option(conn->net, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, (const char *) &verify TSRMLS_CC);
! 496:
! 497: if (FAIL == conn->net->m.enable_ssl(conn->net TSRMLS_CC)) {
! 498: goto err;
! 499: }
! 500:
! 501: auth_packet->send_half_packet = FALSE;
! 502: if (!PACKET_WRITE(auth_packet, conn)) {
! 503: CONN_SET_STATE(conn, CONN_QUIT_SENT);
! 504: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
! 505: goto err;
! 506: }
! 507: }
! 508: #endif
! 509:
! 510:
! 511: if (FAIL == PACKET_READ(ok_packet, conn) || ok_packet->field_count >= 0xFE) {
! 512: if (ok_packet->field_count == 0xFE) {
! 513: /* old authentication with new server !*/
! 514: DBG_ERR(mysqlnd_old_passwd);
! 515: SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd);
! 516: } else if (ok_packet->field_count == 0xFF) {
! 517: if (ok_packet->sqlstate[0]) {
! 518: strlcpy(conn->error_info.sqlstate, ok_packet->sqlstate, sizeof(conn->error_info.sqlstate));
! 519: DBG_ERR_FMT("ERROR:%u [SQLSTATE:%s] %s", ok_packet->error_no, ok_packet->sqlstate, ok_packet->error);
! 520: }
! 521: conn->error_info.error_no = ok_packet->error_no;
! 522: strlcpy(conn->error_info.error, ok_packet->error, sizeof(conn->error_info.error));
! 523: }
! 524: goto err;
! 525: }
! 526:
! 527: SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
! 528: ok_packet->message, ok_packet->message_len,
! 529: conn->persistent);
! 530: conn->charset = mysqlnd_find_charset_nr(auth_packet->charset_no);
! 531: ret = PASS;
! 532: err:
! 533: PACKET_FREE(auth_packet);
! 534: PACKET_FREE(ok_packet);
! 535: DBG_RETURN(ret);
! 536: }
! 537: /* }}} */
! 538:
! 539:
! 540: #define MYSQLND_CAPABILITIES (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | \
! 541: CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION | \
! 542: CLIENT_MULTI_RESULTS)
! 543:
! 544:
! 545:
! 546: /* {{{ mysqlnd_conn::connect */
! 547: static enum_func_status
! 548: MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn,
! 549: const char *host, const char *user,
! 550: const char *passwd, unsigned int passwd_len,
! 551: const char *db, unsigned int db_len,
! 552: unsigned int port,
! 553: const char * socket_or_pipe,
! 554: unsigned int mysql_flags
! 555: TSRMLS_DC)
! 556: {
! 557: char *errstr = NULL;
! 558: int errcode = 0, host_len;
! 559: zend_bool unix_socket = FALSE;
! 560: zend_bool reconnect = FALSE;
! 561: zend_bool saved_compression = FALSE;
! 562:
! 563: MYSQLND_PACKET_GREET * greet_packet = NULL;
! 564:
! 565: DBG_ENTER("mysqlnd_conn::connect");
! 566:
! 567: DBG_INF_FMT("host=%s user=%s db=%s port=%u flags=%u persistent=%u state=%u",
! 568: host?host:"", user?user:"", db?db:"", port, mysql_flags,
! 569: conn? conn->persistent:0, conn? CONN_GET_STATE(conn):-1);
! 570:
! 571: if (conn && CONN_GET_STATE(conn) > CONN_ALLOCED && CONN_GET_STATE(conn) ) {
! 572: DBG_INF("Connecting on a connected handle.");
! 573:
! 574: if (CONN_GET_STATE(conn) < CONN_QUIT_SENT) {
! 575: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CLOSE_IMPLICIT);
! 576: reconnect = TRUE;
! 577: conn->m->send_close(conn TSRMLS_CC);
! 578: }
! 579:
! 580: conn->m->free_contents(conn TSRMLS_CC);
! 581: MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS);
! 582: if (conn->persistent) {
! 583: MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
! 584: }
! 585: /* Now reconnect using the same handle */
! 586: if (conn->net->compressed) {
! 587: /*
! 588: we need to save the state. As we will re-connect, net->compressed should be off, or
! 589: we will look for a compression header as part of the greet message, but there will
! 590: be none.
! 591: */
! 592: saved_compression = TRUE;
! 593: conn->net->compressed = FALSE;
! 594: }
! 595: }
! 596:
! 597: if (!host || !host[0]) {
! 598: host = "localhost";
! 599: }
! 600: if (!user) {
! 601: DBG_INF_FMT("no user given, using empty string");
! 602: user = "";
! 603: }
! 604: if (!passwd) {
! 605: DBG_INF_FMT("no password given, using empty string");
! 606: passwd = "";
! 607: passwd_len = 0;
! 608: }
! 609: if (!db) {
! 610: DBG_INF_FMT("no db given, using empty string");
! 611: db = "";
! 612: db_len = 0;
! 613: }
! 614:
! 615: host_len = strlen(host);
! 616: {
! 617: char * transport = NULL;
! 618: int transport_len;
! 619: #ifndef PHP_WIN32
! 620: if (host_len == sizeof("localhost") - 1 && !strncasecmp(host, "localhost", host_len)) {
! 621: DBG_INF_FMT("socket=%s", socket_or_pipe? socket_or_pipe:"n/a");
! 622: if (!socket_or_pipe) {
! 623: socket_or_pipe = "/tmp/mysql.sock";
! 624: }
! 625: transport_len = spprintf(&transport, 0, "unix://%s", socket_or_pipe);
! 626: unix_socket = TRUE;
! 627: } else
! 628: #endif
! 629: {
! 630: if (!port) {
! 631: port = 3306;
! 632: }
! 633: transport_len = spprintf(&transport, 0, "tcp://%s:%u", host, port);
! 634: }
! 635: if (!transport) {
! 636: SET_OOM_ERROR(conn->error_info);
! 637: goto err; /* OOM */
! 638: }
! 639: DBG_INF_FMT("transport=%s conn->scheme=%s", transport, conn->scheme);
! 640: conn->scheme = mnd_pestrndup(transport, transport_len, conn->persistent);
! 641: conn->scheme_len = transport_len;
! 642: efree(transport); /* allocated by spprintf */
! 643: transport = NULL;
! 644: if (!conn->scheme) {
! 645: goto err; /* OOM */
! 646: }
! 647: }
! 648:
! 649: greet_packet = conn->protocol->m.get_greet_packet(conn->protocol, FALSE TSRMLS_CC);
! 650: if (!greet_packet) {
! 651: SET_OOM_ERROR(conn->error_info);
! 652: goto err; /* OOM */
! 653: }
! 654:
! 655: if (FAIL == conn->net->m.connect(conn->net, conn->scheme, conn->scheme_len, conn->persistent, &errstr, &errcode TSRMLS_CC)) {
! 656: goto err;
! 657: }
! 658:
! 659: DBG_INF_FMT("stream=%p", conn->net->stream);
! 660:
! 661: if (FAIL == PACKET_READ(greet_packet, conn)) {
! 662: DBG_ERR("Error while reading greeting packet");
! 663: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading greeting packet. PID=%d", getpid());
! 664: goto err;
! 665: } else if (greet_packet->error_no) {
! 666: DBG_ERR_FMT("errorno=%u error=%s", greet_packet->error_no, greet_packet->error);
! 667: SET_CLIENT_ERROR(conn->error_info, greet_packet->error_no, greet_packet->sqlstate, greet_packet->error);
! 668: goto err;
! 669: } else if (greet_packet->pre41) {
! 670: DBG_ERR_FMT("Connecting to 3.22, 3.23 & 4.0 is not supported. Server is %-.32s", greet_packet->server_version);
! 671: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connecting to 3.22, 3.23 & 4.0 "
! 672: " is not supported. Server is %-.32s", greet_packet->server_version);
! 673: SET_CLIENT_ERROR(conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE,
! 674: "Connecting to 3.22, 3.23 & 4.0 servers is not supported");
! 675: goto err;
! 676: }
! 677:
! 678: conn->thread_id = greet_packet->thread_id;
! 679: conn->protocol_version = greet_packet->protocol_version;
! 680: conn->server_version = mnd_pestrdup(greet_packet->server_version, conn->persistent);
! 681:
! 682: conn->greet_charset = mysqlnd_find_charset_nr(greet_packet->charset_no);
! 683: /* we allow load data local infile by default */
! 684: mysql_flags |= CLIENT_LOCAL_FILES | CLIENT_PS_MULTI_RESULTS;
! 685: mysql_flags |= MYSQLND_CAPABILITIES;
! 686:
! 687: if (db) {
! 688: mysql_flags |= CLIENT_CONNECT_WITH_DB;
! 689: }
! 690:
! 691: if (PG(open_basedir) && strlen(PG(open_basedir))) {
! 692: mysql_flags ^= CLIENT_LOCAL_FILES;
! 693: }
! 694:
! 695: #ifndef MYSQLND_COMPRESSION_ENABLED
! 696: if (mysql_flags & CLIENT_COMPRESS) {
! 697: mysql_flags &= ~CLIENT_COMPRESS;
! 698: }
! 699: #else
! 700: if (conn->net->options.flags & MYSQLND_NET_FLAG_USE_COMPRESSION) {
! 701: mysql_flags |= CLIENT_COMPRESS;
! 702: }
! 703: #endif
! 704: #ifndef MYSQLND_SSL_SUPPORTED
! 705: if (mysql_flags & CLIENT_SSL) {
! 706: mysql_flags &= ~CLIENT_SSL;
! 707: }
! 708: #else
! 709: if (conn->net->options.ssl_key || conn->net->options.ssl_cert ||
! 710: conn->net->options.ssl_ca || conn->net->options.ssl_capath || conn->net->options.ssl_cipher)
! 711: {
! 712: mysql_flags |= CLIENT_SSL;
! 713: }
! 714: #endif
! 715:
! 716: if (FAIL == mysqlnd_connect_run_authentication(conn, user, passwd, db, db_len, greet_packet, &conn->options, mysql_flags TSRMLS_CC)) {
! 717: goto err;
! 718: }
! 719:
! 720: {
! 721: CONN_SET_STATE(conn, CONN_READY);
! 722:
! 723: if (saved_compression) {
! 724: conn->net->compressed = TRUE;
! 725: }
! 726: /*
! 727: If a connect on a existing handle is performed and mysql_flags is
! 728: passed which doesn't CLIENT_COMPRESS, then we need to overwrite the value
! 729: which we set based on saved_compression.
! 730: */
! 731: conn->net->compressed = mysql_flags & CLIENT_COMPRESS? TRUE:FALSE;
! 732:
! 733: conn->user = mnd_pestrdup(user, conn->persistent);
! 734: conn->user_len = strlen(conn->user);
! 735: conn->passwd = mnd_pestrndup(passwd, passwd_len, conn->persistent);
! 736: conn->passwd_len = passwd_len;
! 737: conn->port = port;
! 738: conn->connect_or_select_db = mnd_pestrndup(db, db_len, conn->persistent);
! 739: conn->connect_or_select_db_len = db_len;
! 740:
! 741: if (!conn->user || !conn->passwd || !conn->connect_or_select_db) {
! 742: SET_OOM_ERROR(conn->error_info);
! 743: goto err; /* OOM */
! 744: }
! 745:
! 746: if (!unix_socket) {
! 747: conn->host = mnd_pestrdup(host, conn->persistent);
! 748: if (!conn->host) {
! 749: SET_OOM_ERROR(conn->error_info);
! 750: goto err; /* OOM */
! 751: }
! 752: conn->host_len = strlen(conn->host);
! 753: {
! 754: char *p;
! 755: spprintf(&p, 0, "%s via TCP/IP", conn->host);
! 756: if (!p) {
! 757: SET_OOM_ERROR(conn->error_info);
! 758: goto err; /* OOM */
! 759: }
! 760: conn->host_info = mnd_pestrdup(p, conn->persistent);
! 761: efree(p); /* allocated by spprintf */
! 762: if (!conn->host_info) {
! 763: SET_OOM_ERROR(conn->error_info);
! 764: goto err; /* OOM */
! 765: }
! 766: }
! 767: } else {
! 768: conn->unix_socket = mnd_pestrdup(socket_or_pipe, conn->persistent);
! 769: conn->host_info = mnd_pestrdup("Localhost via UNIX socket", conn->persistent);
! 770: if (!conn->unix_socket || !conn->host_info) {
! 771: SET_OOM_ERROR(conn->error_info);
! 772: goto err; /* OOM */
! 773: }
! 774: conn->unix_socket_len = strlen(conn->unix_socket);
! 775: }
! 776: conn->client_flag = mysql_flags;
! 777: conn->max_packet_size = MYSQLND_ASSEBLED_PACKET_MAX_SIZE;
! 778: /* todo: check if charset is available */
! 779: conn->server_capabilities = greet_packet->server_capabilities;
! 780: conn->upsert_status.warning_count = 0;
! 781: conn->upsert_status.server_status = greet_packet->server_status;
! 782: conn->upsert_status.affected_rows = 0;
! 783:
! 784: SET_EMPTY_ERROR(conn->error_info);
! 785:
! 786: mysqlnd_local_infile_default(conn);
! 787:
! 788: #if MYSQLND_UNICODE
! 789: {
! 790: unsigned int as_unicode = 1;
! 791: conn->m->set_client_option(conn, MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE, (char *)&as_unicode TSRMLS_CC);
! 792: DBG_INF("unicode set");
! 793: }
! 794: #endif
! 795: if (conn->options.init_commands) {
! 796: unsigned int current_command = 0;
! 797: for (; current_command < conn->options.num_commands; ++current_command) {
! 798: const char * const command = conn->options.init_commands[current_command];
! 799: if (command) {
! 800: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_INIT_COMMAND_EXECUTED_COUNT);
! 801: if (PASS != conn->m->query(conn, command, strlen(command) TSRMLS_CC)) {
! 802: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_INIT_COMMAND_FAILED_COUNT);
! 803: goto err;
! 804: }
! 805: if (conn->last_query_type == QUERY_SELECT) {
! 806: MYSQLND_RES * result = conn->m->use_result(conn TSRMLS_CC);
! 807: if (result) {
! 808: result->m.free_result(result, TRUE TSRMLS_CC);
! 809: }
! 810: }
! 811: }
! 812: }
! 813: }
! 814:
! 815:
! 816: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_CONNECT_SUCCESS, 1, STAT_OPENED_CONNECTIONS, 1);
! 817: if (reconnect) {
! 818: MYSQLND_INC_GLOBAL_STATISTIC(STAT_RECONNECT);
! 819: }
! 820: if (conn->persistent) {
! 821: MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_PCONNECT_SUCCESS, 1, STAT_OPENED_PERSISTENT_CONNECTIONS, 1);
! 822: }
! 823:
! 824: DBG_INF_FMT("connection_id=%llu", conn->thread_id);
! 825:
! 826: PACKET_FREE(greet_packet);
! 827:
! 828: DBG_RETURN(PASS);
! 829: }
! 830: err:
! 831: PACKET_FREE(greet_packet);
! 832:
! 833: if (errstr) {
! 834: DBG_ERR_FMT("[%u] %.128s (trying to connect via %s)", errcode, errstr, conn->scheme);
! 835: SET_CLIENT_ERROR(conn->error_info, errcode? errcode:CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, errstr);
! 836: php_error_docref(NULL TSRMLS_CC, E_WARNING, "[%u] %.128s (trying to connect via %s)", errcode, errstr, conn->scheme);
! 837: /* no mnd_ since we don't allocate it */
! 838: efree(errstr);
! 839: }
! 840: conn->m->free_contents(conn TSRMLS_CC);
! 841: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_FAILURE);
! 842:
! 843: DBG_RETURN(FAIL);
! 844: }
! 845: /* }}} */
! 846:
! 847:
! 848: /* {{{ mysqlnd_connect */
! 849: PHPAPI MYSQLND * mysqlnd_connect(MYSQLND * conn,
! 850: const char *host, const char *user,
! 851: const char *passwd, unsigned int passwd_len,
! 852: const char *db, unsigned int db_len,
! 853: unsigned int port,
! 854: const char *socket_or_pipe,
! 855: unsigned int mysql_flags
! 856: TSRMLS_DC)
! 857: {
! 858: enum_func_status ret = FAIL;
! 859: zend_bool self_alloced = FALSE;
! 860:
! 861: DBG_ENTER("mysqlnd_connect");
! 862: DBG_INF_FMT("host=%s user=%s db=%s port=%u flags=%u", host?host:"", user?user:"", db?db:"", port, mysql_flags);
! 863:
! 864: if (!conn) {
! 865: self_alloced = TRUE;
! 866: if (!(conn = mysqlnd_init(FALSE))) {
! 867: /* OOM */
! 868: DBG_RETURN(NULL);
! 869: }
! 870: }
! 871:
! 872: ret = conn->m->connect(conn, host, user, passwd, passwd_len, db, db_len, port, socket_or_pipe, mysql_flags TSRMLS_CC);
! 873:
! 874: if (ret == FAIL) {
! 875: if (self_alloced) {
! 876: /*
! 877: We have alloced, thus there are no references to this
! 878: object - we are free to kill it!
! 879: */
! 880: conn->m->dtor(conn TSRMLS_CC);
! 881: }
! 882: DBG_RETURN(NULL);
! 883: }
! 884: DBG_RETURN(conn);
! 885: }
! 886: /* }}} */
! 887:
! 888:
! 889: /* {{{ mysqlnd_conn::change_user */
! 890: static enum_func_status
! 891: MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn,
! 892: const char *user,
! 893: const char *passwd,
! 894: const char *db,
! 895: zend_bool silent TSRMLS_DC)
! 896: {
! 897: size_t user_len;
! 898: enum_func_status ret = FAIL;
! 899: MYSQLND_PACKET_CHG_USER_RESPONSE * chg_user_resp;
! 900: char buffer[MYSQLND_MAX_ALLOWED_USER_LEN + 1 + 1 + SCRAMBLE_LENGTH + MYSQLND_MAX_ALLOWED_DB_LEN + 1 + 2 /* charset*/ + 2];
! 901: char *p = buffer;
! 902: const MYSQLND_CHARSET * old_cs = conn->charset;
! 903:
! 904: DBG_ENTER("mysqlnd_conn::change_user");
! 905: DBG_INF_FMT("conn=%llu user=%s passwd=%s db=%s silent=%u",
! 906: conn->thread_id, user?user:"", passwd?"***":"null", db?db:"", (silent == TRUE)?1:0 );
! 907:
! 908: SET_ERROR_AFF_ROWS(conn);
! 909:
! 910: if (!user) {
! 911: user = "";
! 912: }
! 913: if (!passwd) {
! 914: passwd = "";
! 915: }
! 916: if (!db) {
! 917: db = "";
! 918: }
! 919:
! 920: /* 1. user ASCIIZ */
! 921: user_len = MIN(strlen(user), MYSQLND_MAX_ALLOWED_USER_LEN);
! 922: memcpy(p, user, user_len);
! 923: p += user_len;
! 924: *p++ = '\0';
! 925:
! 926: /* 2. password SCRAMBLE_LENGTH followed by the scramble or \0 */
! 927: if (passwd[0]) {
! 928: *p++ = SCRAMBLE_LENGTH;
! 929: php_mysqlnd_scramble((unsigned char *)p, conn->scramble, (unsigned char *)passwd);
! 930: p += SCRAMBLE_LENGTH;
! 931: } else {
! 932: *p++ = '\0';
! 933: }
! 934:
! 935: /* 3. db ASCIIZ */
! 936: if (db[0]) {
! 937: size_t db_len = MIN(strlen(db), MYSQLND_MAX_ALLOWED_DB_LEN);
! 938: memcpy(p, db, db_len);
! 939: p += db_len;
! 940: }
! 941: *p++ = '\0';
! 942:
! 943: /*
! 944: 4. request the current charset, or it will be reset to the system one.
! 945: 5.0 doesn't support it. Support added in 5.1.23 by fixing the following bug :
! 946: Bug #30472 libmysql doesn't reset charset, insert_id after succ. mysql_change_user() call
! 947: */
! 948: if (mysqlnd_get_server_version(conn) >= 50123) {
! 949: int2store(p, conn->charset->nr);
! 950: p+=2;
! 951: }
! 952:
! 953: if (PASS != conn->m->simple_command(conn, COM_CHANGE_USER, buffer, p - buffer,
! 954: PROT_LAST /* we will handle the OK packet*/,
! 955: silent, TRUE TSRMLS_CC)) {
! 956: DBG_RETURN(FAIL);
! 957: }
! 958:
! 959: chg_user_resp = conn->protocol->m.get_change_user_response_packet(conn->protocol, FALSE TSRMLS_CC);
! 960: if (!chg_user_resp) {
! 961: SET_OOM_ERROR(conn->error_info);
! 962: goto end;
! 963: }
! 964: ret = PACKET_READ(chg_user_resp, conn);
! 965: conn->error_info = chg_user_resp->error_info;
! 966:
! 967: if (conn->error_info.error_no) {
! 968: ret = FAIL;
! 969: /*
! 970: COM_CHANGE_USER is broken in 5.1. At least in 5.1.15 and 5.1.14, 5.1.11 is immune.
! 971: bug#25371 mysql_change_user() triggers "packets out of sync"
! 972: When it gets fixed, there should be one more check here
! 973: */
! 974: if (mysqlnd_get_server_version(conn) > 50113L && mysqlnd_get_server_version(conn) < 50118L) {
! 975: MYSQLND_PACKET_OK * redundant_error_packet = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC);
! 976: if (redundant_error_packet) {
! 977: PACKET_READ(redundant_error_packet, conn);
! 978: PACKET_FREE(redundant_error_packet);
! 979: DBG_INF_FMT("Server is %u, buggy, sends two ERR messages", mysqlnd_get_server_version(conn));
! 980: } else {
! 981: SET_OOM_ERROR(conn->error_info);
! 982: }
! 983: }
! 984: }
! 985: if (ret == PASS) {
! 986: char * tmp = NULL;
! 987: /* if we get conn->user as parameter and then we first free it, then estrndup it, we will crash */
! 988: tmp = mnd_pestrndup(user, user_len, conn->persistent);
! 989: if (conn->user) {
! 990: mnd_pefree(conn->user, conn->persistent);
! 991: }
! 992: conn->user = tmp;
! 993:
! 994: tmp = mnd_pestrdup(passwd, conn->persistent);
! 995: if (conn->passwd) {
! 996: mnd_pefree(conn->passwd, conn->persistent);
! 997: }
! 998: conn->passwd = tmp;
! 999:
! 1000: if (conn->last_message) {
! 1001: mnd_pefree(conn->last_message, conn->persistent);
! 1002: conn->last_message = NULL;
! 1003: }
! 1004: memset(&conn->upsert_status, 0, sizeof(conn->upsert_status));
! 1005: /* set charset for old servers */
! 1006: if (mysqlnd_get_server_version(conn) < 50123) {
! 1007: ret = conn->m->set_charset(conn, old_cs->name TSRMLS_CC);
! 1008: }
! 1009: } else if (ret == FAIL && chg_user_resp->server_asked_323_auth == TRUE) {
! 1010: /* old authentication with new server !*/
! 1011: DBG_ERR(mysqlnd_old_passwd);
! 1012: SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd);
! 1013: }
! 1014: end:
! 1015: PACKET_FREE(chg_user_resp);
! 1016:
! 1017: /*
! 1018: Here we should close all statements. Unbuffered queries should not be a
! 1019: problem as we won't allow sending COM_CHANGE_USER.
! 1020: */
! 1021: DBG_INF(ret == PASS? "PASS":"FAIL");
! 1022: DBG_RETURN(ret);
! 1023: }
! 1024: /* }}} */
! 1025:
! 1026:
! 1027: /* {{{ mysqlnd_conn::query */
! 1028: /*
! 1029: If conn->error_info.error_no is not zero, then we had an error.
! 1030: Still the result from the query is PASS
! 1031: */
! 1032: static enum_func_status
! 1033: MYSQLND_METHOD(mysqlnd_conn, query)(MYSQLND * conn, const char * query, unsigned int query_len TSRMLS_DC)
! 1034: {
! 1035: enum_func_status ret = FAIL;
! 1036: DBG_ENTER("mysqlnd_conn::query");
! 1037: DBG_INF_FMT("conn=%llu query=%s", conn->thread_id, query);
! 1038:
! 1039: if (PASS == conn->m->send_query(conn, query, query_len TSRMLS_CC) &&
! 1040: PASS == conn->m->reap_query(conn TSRMLS_CC))
! 1041: {
! 1042: ret = PASS;
! 1043: if (conn->last_query_type == QUERY_UPSERT && conn->upsert_status.affected_rows) {
! 1044: MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status.affected_rows);
! 1045: }
! 1046: }
! 1047: DBG_RETURN(ret);
! 1048: }
! 1049: /* }}} */
! 1050:
! 1051:
! 1052: /* {{{ mysqlnd_conn::send_query */
! 1053: static enum_func_status
! 1054: MYSQLND_METHOD(mysqlnd_conn, send_query)(MYSQLND * conn, const char * query, unsigned int query_len TSRMLS_DC)
! 1055: {
! 1056: enum_func_status ret;
! 1057: DBG_ENTER("mysqlnd_conn::send_query");
! 1058: DBG_INF_FMT("conn=%llu query=%s", conn->thread_id, query);
! 1059:
! 1060: ret = conn->m->simple_command(conn, COM_QUERY, query, query_len,
! 1061: PROT_LAST /* we will handle the OK packet*/,
! 1062: FALSE, FALSE TSRMLS_CC);
! 1063: if (PASS == ret) {
! 1064: CONN_SET_STATE(conn, CONN_QUERY_SENT);
! 1065: }
! 1066: DBG_RETURN(ret);
! 1067: }
! 1068: /* }}} */
! 1069:
! 1070:
! 1071: /* {{{ mysqlnd_conn::reap_query */
! 1072: static enum_func_status
! 1073: MYSQLND_METHOD(mysqlnd_conn, reap_query)(MYSQLND * conn TSRMLS_DC)
! 1074: {
! 1075: enum_mysqlnd_connection_state state = CONN_GET_STATE(conn);
! 1076: DBG_ENTER("mysqlnd_conn::reap_query");
! 1077: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1078:
! 1079: if (state <= CONN_READY || state == CONN_QUIT_SENT) {
! 1080: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not opened, clear or has been closed");
! 1081: DBG_ERR_FMT("Connection not opened, clear or has been closed. State=%u", state);
! 1082: DBG_RETURN(FAIL);
! 1083: }
! 1084: /*
! 1085: Here read the result set. We don't do it in simple_command because it need
! 1086: information from the ok packet. We will fetch it ourselves.
! 1087: */
! 1088: DBG_RETURN(conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC));
! 1089: }
! 1090: /* }}} */
! 1091:
! 1092:
! 1093: #include "php_network.h"
! 1094:
! 1095: MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array TSRMLS_DC)
! 1096: {
! 1097: int cnt = 0;
! 1098: MYSQLND **p = conn_array, **p_p;
! 1099: MYSQLND **ret = NULL;
! 1100:
! 1101: while (*p) {
! 1102: if (CONN_GET_STATE(*p) <= CONN_READY || CONN_GET_STATE(*p) == CONN_QUIT_SENT) {
! 1103: cnt++;
! 1104: }
! 1105: p++;
! 1106: }
! 1107: if (cnt) {
! 1108: MYSQLND **ret_p = ret = ecalloc(cnt + 1, sizeof(MYSQLND *));
! 1109: p_p = p = conn_array;
! 1110: while (*p) {
! 1111: if (CONN_GET_STATE(*p) <= CONN_READY || CONN_GET_STATE(*p) == CONN_QUIT_SENT) {
! 1112: *ret_p = *p;
! 1113: *p = NULL;
! 1114: ret_p++;
! 1115: } else {
! 1116: *p_p = *p;
! 1117: p_p++;
! 1118: }
! 1119: p++;
! 1120: }
! 1121: *ret_p = NULL;
! 1122: }
! 1123: return ret;
! 1124: }
! 1125:
! 1126:
! 1127: /* {{{ stream_select mysqlnd_stream_array_to_fd_set functions */
! 1128: static int mysqlnd_stream_array_to_fd_set(MYSQLND **conn_array, fd_set *fds, php_socket_t *max_fd TSRMLS_DC)
! 1129: {
! 1130: php_socket_t this_fd;
! 1131: int cnt = 0;
! 1132: MYSQLND **p = conn_array;
! 1133:
! 1134: while (*p) {
! 1135: /* get the fd.
! 1136: * NB: Most other code will NOT use the PHP_STREAM_CAST_INTERNAL flag
! 1137: * when casting. It is only used here so that the buffered data warning
! 1138: * is not displayed.
! 1139: * */
! 1140: if (SUCCESS == php_stream_cast((*p)->net->stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL,
! 1141: (void*)&this_fd, 1) && this_fd >= 0) {
! 1142:
! 1143: PHP_SAFE_FD_SET(this_fd, fds);
! 1144:
! 1145: if (this_fd > *max_fd) {
! 1146: *max_fd = this_fd;
! 1147: }
! 1148: cnt++;
! 1149: }
! 1150: p++;
! 1151: }
! 1152: return cnt ? 1 : 0;
! 1153: }
! 1154:
! 1155: static int mysqlnd_stream_array_from_fd_set(MYSQLND **conn_array, fd_set *fds TSRMLS_DC)
! 1156: {
! 1157: php_socket_t this_fd;
! 1158: int ret = 0;
! 1159: zend_bool disproportion = FALSE;
! 1160:
! 1161:
! 1162: MYSQLND **fwd = conn_array, **bckwd = conn_array;
! 1163:
! 1164: while (*fwd) {
! 1165: if (SUCCESS == php_stream_cast((*fwd)->net->stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL,
! 1166: (void*)&this_fd, 1) && this_fd >= 0) {
! 1167: if (PHP_SAFE_FD_ISSET(this_fd, fds)) {
! 1168: if (disproportion) {
! 1169: *bckwd = *fwd;
! 1170: }
! 1171: bckwd++;
! 1172: fwd++;
! 1173: ret++;
! 1174: continue;
! 1175: }
! 1176: }
! 1177: disproportion = TRUE;
! 1178: fwd++;
! 1179: }
! 1180: *bckwd = NULL;/* NULL-terminate the list */
! 1181:
! 1182: return ret;
! 1183: }
! 1184: /* }}} */
! 1185:
! 1186: #ifndef PHP_WIN32
! 1187: #define php_select(m, r, w, e, t) select(m, r, w, e, t)
! 1188: #else
! 1189: #include "win32/select.h"
! 1190: #endif
! 1191:
! 1192: /* {{{ _mysqlnd_poll */
! 1193: PHPAPI enum_func_status
! 1194: _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQLND ***dont_poll, long sec, long usec, uint * desc_num TSRMLS_DC)
! 1195: {
! 1196:
! 1197: struct timeval tv;
! 1198: struct timeval *tv_p = NULL;
! 1199: fd_set rfds, wfds, efds;
! 1200: php_socket_t max_fd = 0;
! 1201: int retval, sets = 0;
! 1202: int set_count, max_set_count = 0;
! 1203: DBG_ENTER("mysqlnd_poll");
! 1204:
! 1205: if (sec < 0 || usec < 0) {
! 1206: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Negative values passed for sec and/or usec");
! 1207: DBG_RETURN(FAIL);
! 1208: }
! 1209:
! 1210: *dont_poll = mysqlnd_stream_array_check_for_readiness(r_array TSRMLS_CC);
! 1211:
! 1212: FD_ZERO(&rfds);
! 1213: FD_ZERO(&wfds);
! 1214: FD_ZERO(&efds);
! 1215:
! 1216: if (r_array != NULL) {
! 1217: set_count = mysqlnd_stream_array_to_fd_set(r_array, &rfds, &max_fd TSRMLS_CC);
! 1218: if (set_count > max_set_count) {
! 1219: max_set_count = set_count;
! 1220: }
! 1221: sets += set_count;
! 1222: }
! 1223:
! 1224: if (e_array != NULL) {
! 1225: set_count = mysqlnd_stream_array_to_fd_set(e_array, &efds, &max_fd TSRMLS_CC);
! 1226: if (set_count > max_set_count) {
! 1227: max_set_count = set_count;
! 1228: }
! 1229: sets += set_count;
! 1230: }
! 1231:
! 1232: if (!sets) {
! 1233: php_error_docref(NULL TSRMLS_CC, E_WARNING, *dont_poll ? "All arrays passed are clear":"No stream arrays were passed");
! 1234: DBG_ERR_FMT(*dont_poll ? "All arrays passed are clear":"No stream arrays were passed");
! 1235: DBG_RETURN(FAIL);
! 1236: }
! 1237:
! 1238: PHP_SAFE_MAX_FD(max_fd, max_set_count);
! 1239:
! 1240: /* Solaris + BSD do not like microsecond values which are >= 1 sec */
! 1241: if (usec > 999999) {
! 1242: tv.tv_sec = sec + (usec / 1000000);
! 1243: tv.tv_usec = usec % 1000000;
! 1244: } else {
! 1245: tv.tv_sec = sec;
! 1246: tv.tv_usec = usec;
! 1247: }
! 1248:
! 1249: tv_p = &tv;
! 1250:
! 1251: retval = php_select(max_fd + 1, &rfds, &wfds, &efds, tv_p);
! 1252:
! 1253: if (retval == -1) {
! 1254: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to select [%d]: %s (max_fd=%d)",
! 1255: errno, strerror(errno), max_fd);
! 1256: DBG_RETURN(FAIL);
! 1257: }
! 1258:
! 1259: if (r_array != NULL) {
! 1260: mysqlnd_stream_array_from_fd_set(r_array, &rfds TSRMLS_CC);
! 1261: }
! 1262: if (e_array != NULL) {
! 1263: mysqlnd_stream_array_from_fd_set(e_array, &efds TSRMLS_CC);
! 1264: }
! 1265:
! 1266: *desc_num = retval;
! 1267:
! 1268: DBG_RETURN(PASS);
! 1269: }
! 1270: /* }}} */
! 1271:
! 1272:
! 1273: /*
! 1274: COM_FIELD_LIST is special, different from a SHOW FIELDS FROM :
! 1275: - There is no result set header - status from the command, which
! 1276: impacts us to allocate big chunk of memory for reading the metadata.
! 1277: - The EOF packet is consumed by the metadata packet reader.
! 1278: */
! 1279:
! 1280: /* {{{ mysqlnd_conn::list_fields */
! 1281: MYSQLND_RES *
! 1282: MYSQLND_METHOD(mysqlnd_conn, list_fields)(MYSQLND * conn, const char *table, const char *achtung_wild TSRMLS_DC)
! 1283: {
! 1284: /* db + \0 + wild + \0 (for wild) */
! 1285: char buff[MYSQLND_MAX_ALLOWED_DB_LEN * 2 + 1 + 1], *p;
! 1286: size_t table_len, wild_len;
! 1287: MYSQLND_RES *result = NULL;
! 1288: DBG_ENTER("mysqlnd_conn::list_fields");
! 1289: DBG_INF_FMT("conn=%llu table=%s wild=%s", conn->thread_id, table? table:"",achtung_wild? achtung_wild:"");
! 1290:
! 1291: p = buff;
! 1292: if (table && (table_len = strlen(table))) {
! 1293: size_t to_copy = MIN(table_len, MYSQLND_MAX_ALLOWED_DB_LEN);
! 1294: memcpy(p, table, to_copy);
! 1295: p += to_copy;
! 1296: *p++ = '\0';
! 1297: }
! 1298:
! 1299: if (achtung_wild && (wild_len = strlen(achtung_wild))) {
! 1300: size_t to_copy = MIN(wild_len, MYSQLND_MAX_ALLOWED_DB_LEN);
! 1301: memcpy(p, achtung_wild, to_copy);
! 1302: p += to_copy;
! 1303: *p++ = '\0';
! 1304: }
! 1305:
! 1306: if (PASS != conn->m->simple_command(conn, COM_FIELD_LIST, buff, p - buff,
! 1307: PROT_LAST /* we will handle the OK packet*/,
! 1308: FALSE, TRUE TSRMLS_CC)) {
! 1309: DBG_RETURN(NULL);
! 1310: }
! 1311:
! 1312: /*
! 1313: Prepare for the worst case.
! 1314: MyISAM goes to 2500 BIT columns, double it for safety.
! 1315: */
! 1316: result = conn->m->result_init(5000, conn->persistent TSRMLS_CC);
! 1317: if (!result) {
! 1318: DBG_RETURN(NULL);
! 1319: }
! 1320:
! 1321: if (FAIL == result->m.read_result_metadata(result, conn TSRMLS_CC)) {
! 1322: DBG_ERR("Error ocurred while reading metadata");
! 1323: result->m.free_result(result, TRUE TSRMLS_CC);
! 1324: DBG_RETURN(NULL);
! 1325: }
! 1326:
! 1327: result->type = MYSQLND_RES_NORMAL;
! 1328: result->m.fetch_row = result->m.fetch_row_normal_unbuffered;
! 1329: result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED));
! 1330: if (!result->unbuf) {
! 1331: /* OOM */
! 1332: SET_OOM_ERROR(conn->error_info);
! 1333: result->m.free_result(result, TRUE TSRMLS_CC);
! 1334: DBG_RETURN(NULL);
! 1335: }
! 1336: result->unbuf->eof_reached = TRUE;
! 1337:
! 1338: DBG_RETURN(result);
! 1339: }
! 1340: /* }}} */
! 1341:
! 1342:
! 1343: /* {{{ mysqlnd_conn::list_method */
! 1344: MYSQLND_RES *
! 1345: MYSQLND_METHOD(mysqlnd_conn, list_method)(MYSQLND * conn, const char * query, const char *achtung_wild, char *par1 TSRMLS_DC)
! 1346: {
! 1347: char *show_query = NULL;
! 1348: size_t show_query_len;
! 1349: MYSQLND_RES *result = NULL;
! 1350:
! 1351: DBG_ENTER("mysqlnd_conn::list_method");
! 1352: DBG_INF_FMT("conn=%llu query=%s wild=%u", conn->thread_id, query, achtung_wild);
! 1353:
! 1354: if (par1) {
! 1355: if (achtung_wild) {
! 1356: show_query_len = spprintf(&show_query, 0, query, par1, achtung_wild);
! 1357: } else {
! 1358: show_query_len = spprintf(&show_query, 0, query, par1);
! 1359: }
! 1360: } else {
! 1361: if (achtung_wild) {
! 1362: show_query_len = spprintf(&show_query, 0, query, achtung_wild);
! 1363: } else {
! 1364: show_query_len = strlen(show_query = (char *)query);
! 1365: }
! 1366: }
! 1367:
! 1368: if (PASS == conn->m->query(conn, show_query, show_query_len TSRMLS_CC)) {
! 1369: result = conn->m->store_result(conn TSRMLS_CC);
! 1370: }
! 1371: if (show_query != query) {
! 1372: efree(show_query); /* allocated by spprintf */
! 1373: }
! 1374: DBG_RETURN(result);
! 1375: }
! 1376: /* }}} */
! 1377:
! 1378:
! 1379: /* {{{ mysqlnd_conn::errno */
! 1380: static unsigned int
! 1381: MYSQLND_METHOD(mysqlnd_conn, errno)(const MYSQLND * const conn TSRMLS_DC)
! 1382: {
! 1383: return conn->error_info.error_no;
! 1384: }
! 1385: /* }}} */
! 1386:
! 1387:
! 1388: /* {{{ mysqlnd_conn::error */
! 1389: static const char *
! 1390: MYSQLND_METHOD(mysqlnd_conn, error)(const MYSQLND * const conn TSRMLS_DC)
! 1391: {
! 1392: return conn->error_info.error;
! 1393: }
! 1394: /* }}} */
! 1395:
! 1396:
! 1397: /* {{{ mysqlnd_conn::sqlstate */
! 1398: static const char *
! 1399: MYSQLND_METHOD(mysqlnd_conn, sqlstate)(const MYSQLND * const conn TSRMLS_DC)
! 1400: {
! 1401: return conn->error_info.sqlstate[0] ? conn->error_info.sqlstate:MYSQLND_SQLSTATE_NULL;
! 1402: }
! 1403: /* }}} */
! 1404:
! 1405:
! 1406: /* {{{ mysqlnd_old_escape_string */
! 1407: PHPAPI ulong mysqlnd_old_escape_string(char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC)
! 1408: {
! 1409: DBG_ENTER("mysqlnd_old_escape_string");
! 1410: DBG_RETURN(mysqlnd_cset_escape_slashes(mysqlnd_find_charset_name("latin1"), newstr, escapestr, escapestr_len TSRMLS_CC));
! 1411: }
! 1412: /* }}} */
! 1413:
! 1414: /* {{{ mysqlnd_conn::ssl_set */
! 1415: static enum_func_status
! 1416: MYSQLND_METHOD(mysqlnd_conn, ssl_set)(MYSQLND * const conn, const char * key, const char * const cert, const char * const ca, const char * const capath, const char * const cipher TSRMLS_DC)
! 1417: {
! 1418: return (PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_KEY, key TSRMLS_CC) &&
! 1419: PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CERT, cert TSRMLS_CC) &&
! 1420: PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CA, ca TSRMLS_CC) &&
! 1421: PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CAPATH, capath TSRMLS_CC) &&
! 1422: PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CIPHER, cipher TSRMLS_CC)) ? PASS : FAIL;
! 1423: }
! 1424: /* }}} */
! 1425:
! 1426:
! 1427: /* {{{ mysqlnd_conn::escape_string */
! 1428: static ulong
! 1429: MYSQLND_METHOD(mysqlnd_conn, escape_string)(MYSQLND * const conn, char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC)
! 1430: {
! 1431: DBG_ENTER("mysqlnd_conn::escape_string");
! 1432: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1433: if (conn->upsert_status.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES) {
! 1434: DBG_RETURN(mysqlnd_cset_escape_quotes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC));
! 1435: }
! 1436: DBG_RETURN(mysqlnd_cset_escape_slashes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC));
! 1437: }
! 1438: /* }}} */
! 1439:
! 1440:
! 1441: /* {{{ mysqlnd_conn::dump_debug_info */
! 1442: static enum_func_status
! 1443: MYSQLND_METHOD(mysqlnd_conn, dump_debug_info)(MYSQLND * const conn TSRMLS_DC)
! 1444: {
! 1445: DBG_ENTER("mysqlnd_conn::dump_debug_info");
! 1446: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1447: DBG_RETURN(conn->m->simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC));
! 1448: }
! 1449: /* }}} */
! 1450:
! 1451:
! 1452: /* {{{ mysqlnd_conn::select_db */
! 1453: static enum_func_status
! 1454: MYSQLND_METHOD(mysqlnd_conn, select_db)(MYSQLND * const conn, const char * const db, unsigned int db_len TSRMLS_DC)
! 1455: {
! 1456: enum_func_status ret;
! 1457:
! 1458: DBG_ENTER("mysqlnd_conn::select_db");
! 1459: DBG_INF_FMT("conn=%llu db=%s", conn->thread_id, db);
! 1460:
! 1461: ret = conn->m->simple_command(conn, COM_INIT_DB, db, db_len, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC);
! 1462: /*
! 1463: The server sends 0 but libmysql doesn't read it and has established
! 1464: a protocol of giving back -1. Thus we have to follow it :(
! 1465: */
! 1466: SET_ERROR_AFF_ROWS(conn);
! 1467: if (ret == PASS) {
! 1468: if (conn->connect_or_select_db) {
! 1469: mnd_pefree(conn->connect_or_select_db, conn->persistent);
! 1470: }
! 1471: conn->connect_or_select_db = mnd_pestrndup(db, db_len, conn->persistent);
! 1472: conn->connect_or_select_db_len = db_len;
! 1473: if (!conn->connect_or_select_db) {
! 1474: /* OOM */
! 1475: SET_OOM_ERROR(conn->error_info);
! 1476: ret = FAIL;
! 1477: }
! 1478: }
! 1479: DBG_RETURN(ret);
! 1480: }
! 1481: /* }}} */
! 1482:
! 1483:
! 1484: /* {{{ mysqlnd_conn::ping */
! 1485: static enum_func_status
! 1486: MYSQLND_METHOD(mysqlnd_conn, ping)(MYSQLND * const conn TSRMLS_DC)
! 1487: {
! 1488: enum_func_status ret;
! 1489:
! 1490: DBG_ENTER("mysqlnd_conn::ping");
! 1491: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1492:
! 1493: ret = conn->m->simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, TRUE, TRUE TSRMLS_CC);
! 1494: /*
! 1495: The server sends 0 but libmysql doesn't read it and has established
! 1496: a protocol of giving back -1. Thus we have to follow it :(
! 1497: */
! 1498: SET_ERROR_AFF_ROWS(conn);
! 1499:
! 1500: DBG_INF_FMT("ret=%u", ret);
! 1501: DBG_RETURN(ret);
! 1502: }
! 1503: /* }}} */
! 1504:
! 1505:
! 1506: /* {{{ mysqlnd_conn::statistic */
! 1507: static enum_func_status
! 1508: MYSQLND_METHOD(mysqlnd_conn, statistic)(MYSQLND * conn, char **message, unsigned int * message_len TSRMLS_DC)
! 1509: {
! 1510: enum_func_status ret;
! 1511: MYSQLND_PACKET_STATS * stats_header;
! 1512:
! 1513: DBG_ENTER("mysqlnd_conn::statistic");
! 1514: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1515:
! 1516: ret = conn->m->simple_command(conn, COM_STATISTICS, NULL, 0, PROT_LAST, FALSE, TRUE TSRMLS_CC);
! 1517: if (FAIL == ret) {
! 1518: DBG_RETURN(FAIL);
! 1519: }
! 1520: stats_header = conn->protocol->m.get_stats_packet(conn->protocol, FALSE TSRMLS_CC);
! 1521: if (!stats_header) {
! 1522: SET_OOM_ERROR(conn->error_info);
! 1523: DBG_RETURN(FAIL);
! 1524: }
! 1525:
! 1526: if (FAIL == (ret = PACKET_READ(stats_header, conn))) {
! 1527: DBG_RETURN(FAIL);
! 1528: }
! 1529: /* will be freed by Zend, thus don't use the mnd_ allocator */
! 1530: *message = estrndup(stats_header->message, stats_header->message_len);
! 1531: *message_len = stats_header->message_len;
! 1532: PACKET_FREE(stats_header);
! 1533:
! 1534: DBG_INF(*message);
! 1535: DBG_RETURN(PASS);
! 1536: }
! 1537: /* }}} */
! 1538:
! 1539:
! 1540: /* {{{ mysqlnd_conn::kill */
! 1541: static enum_func_status
! 1542: MYSQLND_METHOD(mysqlnd_conn, kill)(MYSQLND * conn, unsigned int pid TSRMLS_DC)
! 1543: {
! 1544: enum_func_status ret;
! 1545: char buff[4];
! 1546:
! 1547: DBG_ENTER("mysqlnd_conn::kill");
! 1548: DBG_INF_FMT("conn=%llu pid=%u", conn->thread_id, pid);
! 1549:
! 1550: int4store(buff, pid);
! 1551:
! 1552: /* If we kill ourselves don't expect OK packet, PROT_LAST will skip it */
! 1553: if (pid != conn->thread_id) {
! 1554: ret = conn->m->simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC);
! 1555: /*
! 1556: The server sends 0 but libmysql doesn't read it and has established
! 1557: a protocol of giving back -1. Thus we have to follow it :(
! 1558: */
! 1559: SET_ERROR_AFF_ROWS(conn);
! 1560: } else if (PASS == (ret = conn->m->simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_LAST, FALSE, TRUE TSRMLS_CC))) {
! 1561: CONN_SET_STATE(conn, CONN_QUIT_SENT);
! 1562: }
! 1563: DBG_RETURN(ret);
! 1564: }
! 1565: /* }}} */
! 1566:
! 1567:
! 1568: /* {{{ mysqlnd_conn::set_charset */
! 1569: static enum_func_status
! 1570: MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * const csname TSRMLS_DC)
! 1571: {
! 1572: enum_func_status ret = PASS;
! 1573: char * query;
! 1574: size_t query_len;
! 1575: const MYSQLND_CHARSET * const charset = mysqlnd_find_charset_name(csname);
! 1576:
! 1577: DBG_ENTER("mysqlnd_conn::set_charset");
! 1578: DBG_INF_FMT("conn=%llu cs=%s", conn->thread_id, csname);
! 1579:
! 1580: if (!charset) {
! 1581: SET_CLIENT_ERROR(conn->error_info, CR_CANT_FIND_CHARSET, UNKNOWN_SQLSTATE,
! 1582: "Invalid characterset or character set not supported");
! 1583: DBG_RETURN(FAIL);
! 1584: }
! 1585:
! 1586: query_len = spprintf(&query, 0, "SET NAMES %s", csname);
! 1587:
! 1588: if (FAIL == conn->m->query(conn, query, query_len TSRMLS_CC)) {
! 1589: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error executing query");
! 1590: } else if (conn->error_info.error_no) {
! 1591: ret = FAIL;
! 1592: } else {
! 1593: conn->charset = charset;
! 1594: }
! 1595: efree(query); /* allocated by spprintf */
! 1596:
! 1597: DBG_INF(ret == PASS? "PASS":"FAIL");
! 1598: DBG_RETURN(ret);
! 1599: }
! 1600: /* }}} */
! 1601:
! 1602:
! 1603: /* {{{ mysqlnd_conn::refresh */
! 1604: static enum_func_status
! 1605: MYSQLND_METHOD(mysqlnd_conn, refresh)(MYSQLND * const conn, uint8_t options TSRMLS_DC)
! 1606: {
! 1607: zend_uchar bits[1];
! 1608: DBG_ENTER("mysqlnd_conn::refresh");
! 1609: DBG_INF_FMT("conn=%llu options=%lu", conn->thread_id, options);
! 1610:
! 1611: int1store(bits, options);
! 1612:
! 1613: DBG_RETURN(conn->m->simple_command(conn, COM_REFRESH, (char *)bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC));
! 1614: }
! 1615: /* }}} */
! 1616:
! 1617:
! 1618: /* {{{ mysqlnd_conn::shutdown */
! 1619: static enum_func_status
! 1620: MYSQLND_METHOD(mysqlnd_conn, shutdown)(MYSQLND * const conn, uint8_t level TSRMLS_DC)
! 1621: {
! 1622: zend_uchar bits[1];
! 1623: DBG_ENTER("mysqlnd_conn::shutdown");
! 1624: DBG_INF_FMT("conn=%llu level=%lu", conn->thread_id, level);
! 1625:
! 1626: int1store(bits, level);
! 1627:
! 1628: DBG_RETURN(conn->m->simple_command(conn, COM_SHUTDOWN, (char *)bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC));
! 1629: }
! 1630: /* }}} */
! 1631:
! 1632:
! 1633: /* {{{ mysqlnd_send_close */
! 1634: static enum_func_status
! 1635: MYSQLND_METHOD(mysqlnd_conn, send_close)(MYSQLND * const conn TSRMLS_DC)
! 1636: {
! 1637: enum_func_status ret = PASS;
! 1638:
! 1639: DBG_ENTER("mysqlnd_send_close");
! 1640: DBG_INF_FMT("conn=%llu conn->net->stream->abstract=%p",
! 1641: conn->thread_id, conn->net->stream? conn->net->stream->abstract:NULL);
! 1642:
! 1643: switch (CONN_GET_STATE(conn)) {
! 1644: case CONN_READY:
! 1645: DBG_INF("Connection clean, sending COM_QUIT");
! 1646: if (conn->net->stream) {
! 1647: ret = conn->m->simple_command(conn, COM_QUIT, NULL, 0, PROT_LAST, TRUE, TRUE TSRMLS_CC);
! 1648: }
! 1649: /* Do nothing */
! 1650: break;
! 1651: case CONN_SENDING_LOAD_DATA:
! 1652: /*
! 1653: Don't send COM_QUIT if we are in a middle of a LOAD DATA or we
! 1654: will crash (assert) a debug server.
! 1655: */
! 1656: case CONN_NEXT_RESULT_PENDING:
! 1657: case CONN_QUERY_SENT:
! 1658: case CONN_FETCHING_DATA:
! 1659: MYSQLND_INC_GLOBAL_STATISTIC(STAT_CLOSE_IN_MIDDLE);
! 1660: DBG_ERR_FMT("Brutally closing connection [%p][%s]", conn, conn->scheme);
! 1661: /*
! 1662: Do nothing, the connection will be brutally closed
! 1663: and the server will catch it and free close from its side.
! 1664: */
! 1665: case CONN_ALLOCED:
! 1666: /*
! 1667: Allocated but not connected or there was failure when trying
! 1668: to connect with pre-allocated connect.
! 1669:
! 1670: Fall-through
! 1671: */
! 1672: case CONN_QUIT_SENT:
! 1673: /* The user has killed its own connection */
! 1674: break;
! 1675: }
! 1676: /*
! 1677: We hold one reference, and every other object which needs the
! 1678: connection does increase it by 1.
! 1679: */
! 1680: CONN_SET_STATE(conn, CONN_QUIT_SENT);
! 1681:
! 1682: DBG_RETURN(ret);
! 1683: }
! 1684: /* }}} */
! 1685:
! 1686:
! 1687: /* {{{ mysqlnd_conn::close */
! 1688: static enum_func_status
! 1689: MYSQLND_METHOD(mysqlnd_conn, close)(MYSQLND * conn, enum_connection_close_type close_type TSRMLS_DC)
! 1690: {
! 1691: enum_func_status ret = PASS;
! 1692: static enum_mysqlnd_collected_stats
! 1693: close_type_to_stat_map[MYSQLND_CLOSE_LAST] = {
! 1694: STAT_CLOSE_EXPLICIT,
! 1695: STAT_CLOSE_IMPLICIT,
! 1696: STAT_CLOSE_DISCONNECT
! 1697: };
! 1698: enum_mysqlnd_collected_stats statistic = close_type_to_stat_map[close_type];
! 1699:
! 1700: DBG_ENTER("mysqlnd_conn::close");
! 1701: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1702:
! 1703: if (conn->state >= CONN_READY) {
! 1704: MYSQLND_INC_CONN_STATISTIC(conn->stats, statistic);
! 1705: MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS);
! 1706: if (conn->persistent) {
! 1707: MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
! 1708: }
! 1709: }
! 1710:
! 1711: /*
! 1712: Close now, free_reference will try,
! 1713: if we are last, but that's not a problem.
! 1714: */
! 1715: ret = conn->m->send_close(conn TSRMLS_CC);
! 1716:
! 1717: ret = conn->m->free_reference(conn TSRMLS_CC);
! 1718:
! 1719: DBG_RETURN(ret);
! 1720: }
! 1721: /* }}} */
! 1722:
! 1723:
! 1724: /* {{{ mysqlnd_conn::get_reference */
! 1725: static MYSQLND *
! 1726: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_reference)(MYSQLND * const conn TSRMLS_DC)
! 1727: {
! 1728: DBG_ENTER("mysqlnd_conn::get_reference");
! 1729: ++conn->refcount;
! 1730: DBG_INF_FMT("conn=%llu new_refcount=%u", conn->thread_id, conn->refcount);
! 1731: DBG_RETURN(conn);
! 1732: }
! 1733: /* }}} */
! 1734:
! 1735:
! 1736: /* {{{ mysqlnd_conn::free_reference */
! 1737: static enum_func_status
! 1738: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference)(MYSQLND * const conn TSRMLS_DC)
! 1739: {
! 1740: enum_func_status ret = PASS;
! 1741: DBG_ENTER("mysqlnd_conn::free_reference");
! 1742: DBG_INF_FMT("conn=%llu old_refcount=%u", conn->thread_id, conn->refcount);
! 1743: if (!(--conn->refcount)) {
! 1744: /*
! 1745: No multithreading issues as we don't share the connection :)
! 1746: This will free the object too, of course because references has
! 1747: reached zero.
! 1748: */
! 1749: ret = conn->m->send_close(conn TSRMLS_CC);
! 1750: conn->m->dtor(conn TSRMLS_CC);
! 1751: }
! 1752: DBG_RETURN(ret);
! 1753: }
! 1754: /* }}} */
! 1755:
! 1756:
! 1757: /* {{{ mysqlnd_conn::get_state */
! 1758: static enum mysqlnd_connection_state
! 1759: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_state)(MYSQLND * const conn TSRMLS_DC)
! 1760: {
! 1761: DBG_ENTER("mysqlnd_conn::get_state");
! 1762: DBG_RETURN(conn->state);
! 1763: }
! 1764: /* }}} */
! 1765:
! 1766:
! 1767: /* {{{ mysqlnd_conn::set_state */
! 1768: static void
! 1769: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state)(MYSQLND * const conn, enum mysqlnd_connection_state new_state TSRMLS_DC)
! 1770: {
! 1771: DBG_ENTER("mysqlnd_conn::set_state");
! 1772: DBG_INF_FMT("New state=%u", new_state);
! 1773: conn->state = new_state;
! 1774: DBG_VOID_RETURN;
! 1775: }
! 1776: /* }}} */
! 1777:
! 1778:
! 1779: /* {{{ mysqlnd_conn::field_count */
! 1780: static unsigned int
! 1781: MYSQLND_METHOD(mysqlnd_conn, field_count)(const MYSQLND * const conn TSRMLS_DC)
! 1782: {
! 1783: return conn->field_count;
! 1784: }
! 1785: /* }}} */
! 1786:
! 1787:
! 1788: /* {{{ mysqlnd_conn::insert_id */
! 1789: static uint64_t
! 1790: MYSQLND_METHOD(mysqlnd_conn, insert_id)(const MYSQLND * const conn TSRMLS_DC)
! 1791: {
! 1792: return conn->upsert_status.last_insert_id;
! 1793: }
! 1794: /* }}} */
! 1795:
! 1796:
! 1797: /* {{{ mysqlnd_conn::affected_rows */
! 1798: static uint64_t
! 1799: MYSQLND_METHOD(mysqlnd_conn, affected_rows)(const MYSQLND * const conn TSRMLS_DC)
! 1800: {
! 1801: return conn->upsert_status.affected_rows;
! 1802: }
! 1803: /* }}} */
! 1804:
! 1805:
! 1806: /* {{{ mysqlnd_conn::warning_count */
! 1807: static unsigned int
! 1808: MYSQLND_METHOD(mysqlnd_conn, warning_count)(const MYSQLND * const conn TSRMLS_DC)
! 1809: {
! 1810: return conn->upsert_status.warning_count;
! 1811: }
! 1812: /* }}} */
! 1813:
! 1814:
! 1815: /* {{{ mysqlnd_conn::info */
! 1816: static const char *
! 1817: MYSQLND_METHOD(mysqlnd_conn, info)(const MYSQLND * const conn TSRMLS_DC)
! 1818: {
! 1819: return conn->last_message;
! 1820: }
! 1821: /* }}} */
! 1822:
! 1823: #if !defined(MYSQLND_USE_OPTIMISATIONS) || MYSQLND_USE_OPTIMISATIONS == 0
! 1824: /* {{{ mysqlnd_get_client_info */
! 1825: PHPAPI const char * mysqlnd_get_client_info()
! 1826: {
! 1827: return MYSQLND_VERSION;
! 1828: }
! 1829: /* }}} */
! 1830:
! 1831:
! 1832: /* {{{ mysqlnd_get_client_version */
! 1833: PHPAPI unsigned int mysqlnd_get_client_version()
! 1834: {
! 1835: return MYSQLND_VERSION_ID;
! 1836: }
! 1837: /* }}} */
! 1838: #endif
! 1839:
! 1840: /* {{{ mysqlnd_conn::get_server_info */
! 1841: static const char *
! 1842: MYSQLND_METHOD(mysqlnd_conn, get_server_info)(const MYSQLND * const conn TSRMLS_DC)
! 1843: {
! 1844: return conn->server_version;
! 1845: }
! 1846: /* }}} */
! 1847:
! 1848:
! 1849: /* {{{ mysqlnd_conn::get_host_info */
! 1850: static const char *
! 1851: MYSQLND_METHOD(mysqlnd_conn, get_host_info)(const MYSQLND * const conn TSRMLS_DC)
! 1852: {
! 1853: return conn->host_info;
! 1854: }
! 1855: /* }}} */
! 1856:
! 1857:
! 1858: /* {{{ mysqlnd_conn::get_proto_info */
! 1859: static unsigned int
! 1860: MYSQLND_METHOD(mysqlnd_conn, get_proto_info)(const MYSQLND *const conn TSRMLS_DC)
! 1861: {
! 1862: return conn->protocol_version;
! 1863: }
! 1864: /* }}} */
! 1865:
! 1866:
! 1867: /* {{{ mysqlnd_conn::charset_name */
! 1868: static const char *
! 1869: MYSQLND_METHOD(mysqlnd_conn, charset_name)(const MYSQLND * const conn TSRMLS_DC)
! 1870: {
! 1871: return conn->charset->name;
! 1872: }
! 1873: /* }}} */
! 1874:
! 1875:
! 1876: /* {{{ mysqlnd_conn::thread_id */
! 1877: static uint64_t
! 1878: MYSQLND_METHOD(mysqlnd_conn, thread_id)(const MYSQLND * const conn TSRMLS_DC)
! 1879: {
! 1880: return conn->thread_id;
! 1881: }
! 1882: /* }}} */
! 1883:
! 1884:
! 1885: /* {{{ mysqlnd_conn::get_server_version */
! 1886: static unsigned long
! 1887: MYSQLND_METHOD(mysqlnd_conn, get_server_version)(const MYSQLND * const conn TSRMLS_DC)
! 1888: {
! 1889: long major, minor, patch;
! 1890: char *p;
! 1891:
! 1892: if (!(p = conn->server_version)) {
! 1893: return 0;
! 1894: }
! 1895:
! 1896: major = strtol(p, &p, 10);
! 1897: p += 1; /* consume the dot */
! 1898: minor = strtol(p, &p, 10);
! 1899: p += 1; /* consume the dot */
! 1900: patch = strtol(p, &p, 10);
! 1901:
! 1902: return (unsigned long)(major * 10000L + (unsigned long)(minor * 100L + patch));
! 1903: }
! 1904: /* }}} */
! 1905:
! 1906:
! 1907: /* {{{ mysqlnd_conn::more_results */
! 1908: static zend_bool
! 1909: MYSQLND_METHOD(mysqlnd_conn, more_results)(const MYSQLND * const conn TSRMLS_DC)
! 1910: {
! 1911: DBG_ENTER("mysqlnd_conn::more_results");
! 1912: /* (conn->state == CONN_NEXT_RESULT_PENDING) too */
! 1913: DBG_RETURN(conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS? TRUE:FALSE);
! 1914: }
! 1915: /* }}} */
! 1916:
! 1917:
! 1918: /* {{{ mysqlnd_conn::next_result */
! 1919: static enum_func_status
! 1920: MYSQLND_METHOD(mysqlnd_conn, next_result)(MYSQLND * const conn TSRMLS_DC)
! 1921: {
! 1922: enum_func_status ret;
! 1923:
! 1924: DBG_ENTER("mysqlnd_conn::next_result");
! 1925: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 1926:
! 1927: if (CONN_GET_STATE(conn) != CONN_NEXT_RESULT_PENDING) {
! 1928: DBG_RETURN(FAIL);
! 1929: }
! 1930:
! 1931: SET_EMPTY_ERROR(conn->error_info);
! 1932: SET_ERROR_AFF_ROWS(conn);
! 1933: /*
! 1934: We are sure that there is a result set, since conn->state is set accordingly
! 1935: in mysqlnd_store_result() or mysqlnd_fetch_row_unbuffered()
! 1936: */
! 1937: if (FAIL == (ret = conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC))) {
! 1938: /*
! 1939: There can be an error in the middle of a multi-statement, which will cancel the multi-statement.
! 1940: So there are no more results and we should just return FALSE, error_no has been set
! 1941: */
! 1942: if (!conn->error_info.error_no) {
! 1943: DBG_ERR_FMT("Serious error. %s::%u", __FILE__, __LINE__);
! 1944: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error. PID=%d", getpid());
! 1945: CONN_SET_STATE(conn, CONN_QUIT_SENT);
! 1946: } else {
! 1947: DBG_INF_FMT("Error from the server : (%u) %s", conn->error_info.error_no, conn->error_info.error);
! 1948: }
! 1949: }
! 1950: if (ret == PASS && conn->last_query_type == QUERY_UPSERT && conn->upsert_status.affected_rows) {
! 1951: MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status.affected_rows);
! 1952: }
! 1953:
! 1954: DBG_RETURN(ret);
! 1955: }
! 1956: /* }}} */
! 1957:
! 1958:
! 1959: /* {{{ mysqlnd_field_type_name */
! 1960: PHPAPI const char *mysqlnd_field_type_name(enum mysqlnd_field_types field_type)
! 1961: {
! 1962: switch(field_type) {
! 1963: case FIELD_TYPE_STRING:
! 1964: case FIELD_TYPE_VAR_STRING:
! 1965: return "string";
! 1966: case FIELD_TYPE_TINY:
! 1967: case FIELD_TYPE_SHORT:
! 1968: case FIELD_TYPE_LONG:
! 1969: case FIELD_TYPE_LONGLONG:
! 1970: case FIELD_TYPE_INT24:
! 1971: return "int";
! 1972: case FIELD_TYPE_FLOAT:
! 1973: case FIELD_TYPE_DOUBLE:
! 1974: case FIELD_TYPE_DECIMAL:
! 1975: case FIELD_TYPE_NEWDECIMAL:
! 1976: return "real";
! 1977: case FIELD_TYPE_TIMESTAMP:
! 1978: return "timestamp";
! 1979: case FIELD_TYPE_YEAR:
! 1980: return "year";
! 1981: case FIELD_TYPE_DATE:
! 1982: case FIELD_TYPE_NEWDATE:
! 1983: return "date";
! 1984: case FIELD_TYPE_TIME:
! 1985: return "time";
! 1986: case FIELD_TYPE_SET:
! 1987: return "set";
! 1988: case FIELD_TYPE_ENUM:
! 1989: return "enum";
! 1990: case FIELD_TYPE_GEOMETRY:
! 1991: return "geometry";
! 1992: case FIELD_TYPE_DATETIME:
! 1993: return "datetime";
! 1994: case FIELD_TYPE_TINY_BLOB:
! 1995: case FIELD_TYPE_MEDIUM_BLOB:
! 1996: case FIELD_TYPE_LONG_BLOB:
! 1997: case FIELD_TYPE_BLOB:
! 1998: return "blob";
! 1999: case FIELD_TYPE_NULL:
! 2000: return "null";
! 2001: case FIELD_TYPE_BIT:
! 2002: return "bit";
! 2003: default:
! 2004: return "unknown";
! 2005: }
! 2006: }
! 2007: /* }}} */
! 2008:
! 2009:
! 2010: /* {{{ mysqlnd_conn::set_client_option */
! 2011: static enum_func_status
! 2012: MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn,
! 2013: enum mysqlnd_option option,
! 2014: const char * const value
! 2015: TSRMLS_DC)
! 2016: {
! 2017: enum_func_status ret = PASS;
! 2018: DBG_ENTER("mysqlnd_conn::set_client_option");
! 2019: DBG_INF_FMT("conn=%llu option=%u", conn->thread_id, option);
! 2020: switch (option) {
! 2021: case MYSQL_OPT_COMPRESS:
! 2022: #ifdef WHEN_SUPPORTED_BY_MYSQLI
! 2023: case MYSQL_OPT_READ_TIMEOUT:
! 2024: case MYSQL_OPT_WRITE_TIMEOUT:
! 2025: #endif
! 2026: case MYSQLND_OPT_SSL_KEY:
! 2027: case MYSQLND_OPT_SSL_CERT:
! 2028: case MYSQLND_OPT_SSL_CA:
! 2029: case MYSQLND_OPT_SSL_CAPATH:
! 2030: case MYSQLND_OPT_SSL_CIPHER:
! 2031: case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:
! 2032: case MYSQL_OPT_CONNECT_TIMEOUT:
! 2033: case MYSQLND_OPT_NET_CMD_BUFFER_SIZE:
! 2034: case MYSQLND_OPT_NET_READ_BUFFER_SIZE:
! 2035: ret = conn->net->m.set_client_option(conn->net, option, value TSRMLS_CC);
! 2036: break;
! 2037: #if MYSQLND_UNICODE
! 2038: case MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE:
! 2039: conn->options.numeric_and_datetime_as_unicode = *(unsigned int*) value;
! 2040: break;
! 2041: #endif
! 2042: #ifdef MYSQLND_STRING_TO_INT_CONVERSION
! 2043: case MYSQLND_OPT_INT_AND_FLOAT_NATIVE:
! 2044: DBG_INF("MYSQLND_OPT_INT_AND_FLOAT_NATIVE");
! 2045: conn->options.int_and_float_native = *(unsigned int*) value;
! 2046: break;
! 2047: #endif
! 2048: case MYSQL_OPT_LOCAL_INFILE:
! 2049: DBG_INF("MYSQL_OPT_LOCAL_INFILE");
! 2050: if (!value || (*(unsigned int*) value) ? 1 : 0) {
! 2051: conn->options.flags |= CLIENT_LOCAL_FILES;
! 2052: } else {
! 2053: conn->options.flags &= ~CLIENT_LOCAL_FILES;
! 2054: }
! 2055: break;
! 2056: case MYSQL_INIT_COMMAND:
! 2057: {
! 2058: char ** new_init_commands;
! 2059: char * new_command;
! 2060: DBG_INF("MYSQL_INIT_COMMAND");
! 2061: DBG_INF_FMT("command=%s", value);
! 2062: /* when num_commands is 0, then realloc will be effectively a malloc call, internally */
! 2063: /* Don't assign to conn->options.init_commands because in case of OOM we will lose the pointer and leak */
! 2064: new_init_commands = mnd_perealloc(conn->options.init_commands, sizeof(char *) * (conn->options.num_commands + 1), conn->persistent);
! 2065: if (!new_init_commands) {
! 2066: goto oom;
! 2067: }
! 2068: conn->options.init_commands = new_init_commands;
! 2069: new_command = mnd_pestrdup(value, conn->persistent);
! 2070: if (!new_command) {
! 2071: goto oom;
! 2072: }
! 2073: conn->options.init_commands[conn->options.num_commands] = new_command;
! 2074: ++conn->options.num_commands;
! 2075: break;
! 2076: }
! 2077: case MYSQL_READ_DEFAULT_FILE:
! 2078: case MYSQL_READ_DEFAULT_GROUP:
! 2079: #ifdef WHEN_SUPPORTED_BY_MYSQLI
! 2080: case MYSQL_SET_CLIENT_IP:
! 2081: case MYSQL_REPORT_DATA_TRUNCATION:
! 2082: #endif
! 2083: /* currently not supported. Todo!! */
! 2084: break;
! 2085: case MYSQL_SET_CHARSET_NAME:
! 2086: {
! 2087: char * new_charset_name = mnd_pestrdup(value, conn->persistent);
! 2088: DBG_INF("MYSQL_SET_CHARSET_NAME");
! 2089: if (!new_charset_name) {
! 2090: goto oom;
! 2091: }
! 2092: if (conn->options.charset_name) {
! 2093: mnd_pefree(conn->options.charset_name, conn->persistent);
! 2094: }
! 2095: conn->options.charset_name = new_charset_name;
! 2096: DBG_INF_FMT("charset=%s", conn->options.charset_name);
! 2097: break;
! 2098: }
! 2099: case MYSQL_OPT_NAMED_PIPE:
! 2100: conn->options.protocol = MYSQL_PROTOCOL_PIPE;
! 2101: break;
! 2102: case MYSQL_OPT_PROTOCOL:
! 2103: if (*(unsigned int*) value < MYSQL_PROTOCOL_LAST) {
! 2104: conn->options.protocol = *(unsigned int*) value;
! 2105: }
! 2106: break;
! 2107: #ifdef WHEN_SUPPORTED_BY_MYSQLI
! 2108: case MYSQL_SET_CHARSET_DIR:
! 2109: case MYSQL_OPT_RECONNECT:
! 2110: /* we don't need external character sets, all character sets are
! 2111: compiled in. For compatibility we just ignore this setting.
! 2112: Same for protocol, we don't support old protocol */
! 2113: case MYSQL_OPT_USE_REMOTE_CONNECTION:
! 2114: case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
! 2115: case MYSQL_OPT_GUESS_CONNECTION:
! 2116: /* todo: throw an error, we don't support embedded */
! 2117: break;
! 2118: #endif
! 2119:
! 2120: #ifdef WHEN_SUPPORTED_BY_MYSQLI
! 2121: case MYSQL_SHARED_MEMORY_BASE_NAME:
! 2122: case MYSQL_OPT_USE_RESULT:
! 2123: case MYSQL_SECURE_AUTH:
! 2124: /* not sure, todo ? */
! 2125: #endif
! 2126: default:
! 2127: ret = FAIL;
! 2128: }
! 2129: DBG_RETURN(ret);
! 2130: oom:
! 2131: SET_OOM_ERROR(conn->error_info);
! 2132: DBG_RETURN(FAIL);
! 2133: }
! 2134: /* }}} */
! 2135:
! 2136:
! 2137: /* {{{ mysqlnd_conn::use_result */
! 2138: static MYSQLND_RES *
! 2139: MYSQLND_METHOD(mysqlnd_conn, use_result)(MYSQLND * const conn TSRMLS_DC)
! 2140: {
! 2141: MYSQLND_RES * result;
! 2142:
! 2143: DBG_ENTER("mysqlnd_conn::use_result");
! 2144: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 2145:
! 2146: if (!conn->current_result) {
! 2147: DBG_RETURN(NULL);
! 2148: }
! 2149:
! 2150: /* Nothing to store for UPSERT/LOAD DATA */
! 2151: if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) {
! 2152: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE,
! 2153: mysqlnd_out_of_sync);
! 2154: DBG_ERR("Command out of sync");
! 2155: DBG_RETURN(NULL);
! 2156: }
! 2157:
! 2158: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_UNBUFFERED_SETS);
! 2159:
! 2160: conn->current_result->conn = conn->m->get_reference(conn TSRMLS_CC);
! 2161: result = conn->current_result->m.use_result(conn->current_result, FALSE TSRMLS_CC);
! 2162:
! 2163: if (!result) {
! 2164: conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC);
! 2165: }
! 2166: conn->current_result = NULL;
! 2167:
! 2168: DBG_RETURN(result);
! 2169: }
! 2170: /* }}} */
! 2171:
! 2172:
! 2173: /* {{{ mysqlnd_conn::store_result */
! 2174: static MYSQLND_RES *
! 2175: MYSQLND_METHOD(mysqlnd_conn, store_result)(MYSQLND * const conn TSRMLS_DC)
! 2176: {
! 2177: MYSQLND_RES *result;
! 2178:
! 2179: DBG_ENTER("mysqlnd_conn::store_result");
! 2180: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 2181:
! 2182: if (!conn->current_result) {
! 2183: DBG_RETURN(NULL);
! 2184: }
! 2185:
! 2186: /* Nothing to store for UPSERT/LOAD DATA*/
! 2187: if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) {
! 2188: SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE,
! 2189: mysqlnd_out_of_sync);
! 2190: DBG_ERR("Command out of sync");
! 2191: DBG_RETURN(NULL);
! 2192: }
! 2193:
! 2194: MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS);
! 2195:
! 2196: result = conn->current_result->m.store_result(conn->current_result, conn, FALSE TSRMLS_CC);
! 2197: if (!result) {
! 2198: conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC);
! 2199: }
! 2200: conn->current_result = NULL;
! 2201: DBG_RETURN(result);
! 2202: }
! 2203: /* }}} */
! 2204:
! 2205:
! 2206: /* {{{ mysqlnd_conn::get_connection_stats */
! 2207: static void
! 2208: MYSQLND_METHOD(mysqlnd_conn, get_connection_stats)(const MYSQLND * const conn,
! 2209: zval *return_value
! 2210: TSRMLS_DC ZEND_FILE_LINE_DC)
! 2211: {
! 2212: DBG_ENTER("mysqlnd_conn::get_connection_stats");
! 2213: DBG_INF_FMT("conn=%llu", conn->thread_id);
! 2214: mysqlnd_fill_stats_hash(conn->stats, mysqlnd_stats_values_names, return_value TSRMLS_CC ZEND_FILE_LINE_CC);
! 2215: DBG_VOID_RETURN;
! 2216: }
! 2217: /* }}} */
! 2218:
! 2219:
! 2220: /* {{{ mysqlnd_conn::set_autocommit */
! 2221: static enum_func_status
! 2222: MYSQLND_METHOD(mysqlnd_conn, set_autocommit)(MYSQLND * conn, unsigned int mode TSRMLS_DC)
! 2223: {
! 2224: enum_func_status ret;
! 2225: DBG_ENTER("mysqlnd_conn::set_autocommit");
! 2226: ret = conn->m->query(conn, (mode) ? "SET AUTOCOMMIT=1":"SET AUTOCOMMIT=0", sizeof("SET AUTOCOMMIT=1") - 1 TSRMLS_CC);
! 2227: DBG_RETURN(ret);
! 2228: }
! 2229: /* }}} */
! 2230:
! 2231:
! 2232: /* {{{ mysqlnd_conn::tx_commit */
! 2233: static enum_func_status
! 2234: MYSQLND_METHOD(mysqlnd_conn, tx_commit)(MYSQLND * conn TSRMLS_DC)
! 2235: {
! 2236: enum_func_status ret;
! 2237: DBG_ENTER("mysqlnd_conn::tx_commit");
! 2238: ret = conn->m->query(conn, "COMMIT", sizeof("COMMIT") - 1 TSRMLS_CC);
! 2239: DBG_RETURN(ret);
! 2240: }
! 2241: /* }}} */
! 2242:
! 2243:
! 2244: /* {{{ mysqlnd_conn::tx_rollback */
! 2245: static enum_func_status
! 2246: MYSQLND_METHOD(mysqlnd_conn, tx_rollback)(MYSQLND * conn TSRMLS_DC)
! 2247: {
! 2248: enum_func_status ret;
! 2249: DBG_ENTER("mysqlnd_conn::tx_rollback");
! 2250: ret = conn->m->query(conn, "ROLLBACK", sizeof("ROLLBACK") - 1 TSRMLS_CC);
! 2251: DBG_RETURN(ret);
! 2252: }
! 2253: /* }}} */
! 2254:
! 2255:
! 2256:
! 2257: MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC);
! 2258: static enum_func_status MYSQLND_METHOD(mysqlnd_conn, init)(MYSQLND * conn TSRMLS_DC);
! 2259:
! 2260: static
! 2261: MYSQLND_CLASS_METHODS_START(mysqlnd_conn)
! 2262: MYSQLND_METHOD(mysqlnd_conn, init),
! 2263: MYSQLND_METHOD(mysqlnd_conn, connect),
! 2264:
! 2265: MYSQLND_METHOD(mysqlnd_conn, escape_string),
! 2266: MYSQLND_METHOD(mysqlnd_conn, set_charset),
! 2267: MYSQLND_METHOD(mysqlnd_conn, query),
! 2268: MYSQLND_METHOD(mysqlnd_conn, send_query),
! 2269: MYSQLND_METHOD(mysqlnd_conn, reap_query),
! 2270: MYSQLND_METHOD(mysqlnd_conn, use_result),
! 2271: MYSQLND_METHOD(mysqlnd_conn, store_result),
! 2272: MYSQLND_METHOD(mysqlnd_conn, next_result),
! 2273: MYSQLND_METHOD(mysqlnd_conn, more_results),
! 2274:
! 2275: _mysqlnd_stmt_init,
! 2276:
! 2277: MYSQLND_METHOD(mysqlnd_conn, shutdown),
! 2278: MYSQLND_METHOD(mysqlnd_conn, refresh),
! 2279:
! 2280: MYSQLND_METHOD(mysqlnd_conn, ping),
! 2281: MYSQLND_METHOD(mysqlnd_conn, kill),
! 2282: MYSQLND_METHOD(mysqlnd_conn, select_db),
! 2283: MYSQLND_METHOD(mysqlnd_conn, dump_debug_info),
! 2284: MYSQLND_METHOD(mysqlnd_conn, change_user),
! 2285:
! 2286: MYSQLND_METHOD(mysqlnd_conn, errno),
! 2287: MYSQLND_METHOD(mysqlnd_conn, error),
! 2288: MYSQLND_METHOD(mysqlnd_conn, sqlstate),
! 2289: MYSQLND_METHOD(mysqlnd_conn, thread_id),
! 2290:
! 2291: MYSQLND_METHOD(mysqlnd_conn, get_connection_stats),
! 2292:
! 2293: MYSQLND_METHOD(mysqlnd_conn, get_server_version),
! 2294: MYSQLND_METHOD(mysqlnd_conn, get_server_info),
! 2295: MYSQLND_METHOD(mysqlnd_conn, statistic),
! 2296: MYSQLND_METHOD(mysqlnd_conn, get_host_info),
! 2297: MYSQLND_METHOD(mysqlnd_conn, get_proto_info),
! 2298: MYSQLND_METHOD(mysqlnd_conn, info),
! 2299: MYSQLND_METHOD(mysqlnd_conn, charset_name),
! 2300: MYSQLND_METHOD(mysqlnd_conn, list_fields),
! 2301: MYSQLND_METHOD(mysqlnd_conn, list_method),
! 2302:
! 2303: MYSQLND_METHOD(mysqlnd_conn, insert_id),
! 2304: MYSQLND_METHOD(mysqlnd_conn, affected_rows),
! 2305: MYSQLND_METHOD(mysqlnd_conn, warning_count),
! 2306: MYSQLND_METHOD(mysqlnd_conn, field_count),
! 2307:
! 2308: MYSQLND_METHOD(mysqlnd_conn, set_server_option),
! 2309: MYSQLND_METHOD(mysqlnd_conn, set_client_option),
! 2310: MYSQLND_METHOD(mysqlnd_conn, free_contents),
! 2311: MYSQLND_METHOD(mysqlnd_conn, free_options),
! 2312: MYSQLND_METHOD(mysqlnd_conn, close),
! 2313:
! 2314: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor),
! 2315:
! 2316: mysqlnd_query_read_result_set_header,
! 2317:
! 2318: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_reference),
! 2319: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference),
! 2320: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_state),
! 2321: MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state),
! 2322:
! 2323: MYSQLND_METHOD(mysqlnd_conn, simple_command),
! 2324: MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response),
! 2325: MYSQLND_METHOD(mysqlnd_conn, restart_psession),
! 2326: MYSQLND_METHOD(mysqlnd_conn, end_psession),
! 2327: MYSQLND_METHOD(mysqlnd_conn, send_close),
! 2328:
! 2329: MYSQLND_METHOD(mysqlnd_conn, ssl_set),
! 2330: mysqlnd_result_init
! 2331: #ifdef AUTOCOMMIT_TX_COMMIT_ROLLBACK
! 2332: ,MYSQLND_METHOD(mysqlnd_conn, set_autocommit),
! 2333: MYSQLND_METHOD(mysqlnd_conn, tx_commit),
! 2334: MYSQLND_METHOD(mysqlnd_conn, tx_rollback)
! 2335: #endif
! 2336: MYSQLND_CLASS_METHODS_END;
! 2337:
! 2338:
! 2339: /* {{{ mysqlnd_conn::init */
! 2340: static enum_func_status
! 2341: MYSQLND_METHOD(mysqlnd_conn, init)(MYSQLND * conn TSRMLS_DC)
! 2342: {
! 2343: DBG_ENTER("mysqlnd_conn::init");
! 2344: mysqlnd_stats_init(&conn->stats, STAT_LAST);
! 2345: SET_ERROR_AFF_ROWS(conn);
! 2346:
! 2347: conn->net = mysqlnd_net_init(conn->persistent TSRMLS_CC);
! 2348: conn->protocol = mysqlnd_protocol_init(conn->persistent TSRMLS_CC);
! 2349:
! 2350: DBG_RETURN(conn->net && conn->protocol? PASS:FAIL);
! 2351: }
! 2352: /* }}} */
! 2353:
! 2354:
! 2355: /* {{{ mysqlnd_init */
! 2356: PHPAPI MYSQLND * _mysqlnd_init(zend_bool persistent TSRMLS_DC)
! 2357: {
! 2358: size_t alloc_size = sizeof(MYSQLND) + mysqlnd_plugin_count() * sizeof(void *);
! 2359: MYSQLND *ret;
! 2360:
! 2361: DBG_ENTER("mysqlnd_init");
! 2362: DBG_INF_FMT("persistent=%u", persistent);
! 2363: ret = mnd_pecalloc(1, alloc_size, persistent);
! 2364: if (!ret) {
! 2365: DBG_RETURN(NULL);
! 2366: }
! 2367:
! 2368: ret->persistent = persistent;
! 2369: ret->m = mysqlnd_conn_methods;
! 2370: CONN_SET_STATE(ret, CONN_ALLOCED);
! 2371: ret->m->get_reference(ret TSRMLS_CC);
! 2372:
! 2373: if (PASS != ret->m->init(ret TSRMLS_CC)) {
! 2374: ret->m->dtor(ret TSRMLS_CC);
! 2375: ret = NULL;
! 2376: }
! 2377:
! 2378: DBG_RETURN(ret);
! 2379: }
! 2380: /* }}} */
! 2381:
! 2382:
! 2383: /* {{{ mysqlnd_library_init */
! 2384: PHPAPI void mysqlnd_library_init(TSRMLS_D)
! 2385: {
! 2386: if (mysqlnd_library_initted == FALSE) {
! 2387: mysqlnd_library_initted = TRUE;
! 2388: mysqlnd_conn_methods = &MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_conn);
! 2389: _mysqlnd_init_ps_subsystem();
! 2390: /* Should be calloc, as mnd_calloc will reference LOCK_access*/
! 2391: mysqlnd_stats_init(&mysqlnd_global_stats, STAT_LAST);
! 2392: }
! 2393: }
! 2394: /* }}} */
! 2395:
! 2396: /* {{{ mysqlnd_conn_get_methods */
! 2397: PHPAPI struct st_mysqlnd_conn_methods * mysqlnd_conn_get_methods()
! 2398: {
! 2399: return mysqlnd_conn_methods;
! 2400: }
! 2401: /* }}} */
! 2402:
! 2403: /* {{{ mysqlnd_conn_set_methods */
! 2404: PHPAPI void mysqlnd_conn_set_methods(struct st_mysqlnd_conn_methods *methods)
! 2405: {
! 2406: mysqlnd_conn_methods = methods;
! 2407: }
! 2408: /* }}} */
! 2409:
! 2410:
! 2411: static unsigned int mysqlnd_plugins_counter = 0;
! 2412:
! 2413: /* {{{ mysqlnd_plugin_register */
! 2414: PHPAPI unsigned int mysqlnd_plugin_register()
! 2415: {
! 2416: return mysqlnd_plugins_counter++;
! 2417: }
! 2418: /* }}} */
! 2419:
! 2420:
! 2421: /* {{{ mysqlnd_plugin_count */
! 2422: PHPAPI unsigned int mysqlnd_plugin_count()
! 2423: {
! 2424: return mysqlnd_plugins_counter;
! 2425: }
! 2426: /* }}} */
! 2427:
! 2428:
! 2429: /* {{{ _mysqlnd_plugin_get_plugin_connection_data */
! 2430: PHPAPI void ** _mysqlnd_plugin_get_plugin_connection_data(const MYSQLND * conn, unsigned int plugin_id TSRMLS_DC)
! 2431: {
! 2432: DBG_ENTER("_mysqlnd_plugin_get_plugin_connection_data");
! 2433: DBG_INF_FMT("plugin_id=%u", plugin_id);
! 2434: if (!conn || plugin_id >= mysqlnd_plugin_count()) {
! 2435: return NULL;
! 2436: }
! 2437: DBG_RETURN((void *)((char *)conn + sizeof(MYSQLND) + plugin_id * sizeof(void *)));
! 2438: }
! 2439: /* }}} */
! 2440:
! 2441: /*
! 2442: * Local variables:
! 2443: * tab-width: 4
! 2444: * c-basic-offset: 4
! 2445: * End:
! 2446: * vim600: noet sw=4 ts=4 fdm=marker
! 2447: * vim<600: noet sw=4 ts=4
! 2448: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mysqlnd.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