static int pdo_sqlite_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /* {{{ */ { pdo_sqlite_db_handle *H; int i, ret = 0; zend_long timeout = 60, flags; char *filename; H = pecalloc(1, sizeof(pdo_sqlite_db_handle), dbh->is_persistent); H->einfo.errcode = 0; H->einfo.errmsg = NULL; dbh->driver_data = H; filename = make_filename_safe(dbh->data_source); if (!filename) { zend_throw_exception_ex(php_pdo_get_exception(), 0, "open_basedir prohibits opening %s", dbh->data_source); goto cleanup; } flags = pdo_attr_lval(driver_options, PDO_SQLITE_ATTR_OPEN_FLAGS, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); #if SQLITE_VERSION_NUMBER >= 3005000 i = sqlite3_open_v2(filename, &H->db, flags, NULL); #else i = sqlite3_open(filename, &H->db); #endif efree(filename); if (i != SQLITE_OK) { pdo_sqlite_error(dbh); goto cleanup; } if (PG(open_basedir) && *PG(open_basedir)) { sqlite3_set_authorizer(H->db, authorizer, NULL); } if (driver_options) { timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, timeout); } sqlite3_busy_timeout(H->db, timeout * 1000); dbh->alloc_own_columns = 1; dbh->max_escaped_char_length = 2; ret = 1; cleanup: dbh->methods = &sqlite_methods; return ret; }
static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, size_t sql_len, pdo_stmt_t *stmt, zval *driver_options) { pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data; pdo_sqlite_stmt *S = ecalloc(1, sizeof(pdo_sqlite_stmt)); int i; const char *tail; S->H = H; stmt->driver_data = S; stmt->methods = &sqlite_stmt_methods; stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL|PDO_PLACEHOLDER_NAMED; if (PDO_CURSOR_FWDONLY != pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY)) { H->einfo.errcode = SQLITE_ERROR; pdo_sqlite_error(dbh); return 0; } i = sqlite3_prepare(H->db, sql, sql_len, &S->stmt, &tail); if (i == SQLITE_OK) { return 1; } pdo_sqlite_error(dbh); return 0; }
bool PDOPgSqlStatement::create(const String& sql, const Array &options){ supports_placeholders = PDO_PLACEHOLDER_NAMED; bool scrollable = pdo_attr_lval( options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY ) == PDO_CURSOR_SCROLL; if(scrollable){ m_cursorName = ( boost::format("pdo_crsr_%08x") % ++m_cursorNameCounter ).str(); // Disable prepared statements supports_placeholders = PDO_PLACEHOLDER_NONE; } else if ( m_conn->m_emulate_prepare || (!options.empty() && pdo_attr_lval(options, PDO_ATTR_EMULATE_PREPARES, 0)) ) { supports_placeholders = PDO_PLACEHOLDER_NONE; } if( supports_placeholders != PDO_PLACEHOLDER_NONE && m_server->protocolVersion() > 2 ) { named_rewrite_template = "$%d"; String nsql; int ret = pdo_parse_params(sp_PDOStatement(this), sql, nsql); if(ret == 1){ // Query was rewritten } else if (ret == -1){ // Query didn't parse - exception should have been thrown at this point strncpy(m_conn->error_code, error_code, 6); m_conn->error_code[5] = '\0'; return false; } else { // Original is great nsql = sql; } m_stmtName = (boost::format("pdo_stmt_%08x") % ++m_stmtNameCounter).str(); m_resolvedQuery = (std::string)nsql; } return true; }
bool PDOPgSqlConnection::create(const Array &options){ long connect_timeout = pdo_attr_lval(options, PDO_ATTR_TIMEOUT, 30); struct pdo_data_src_parser vars[] = { { "host", "localhost", 0 }, { "port", "5432", 0 }, { "dbname", "", 0 }, { "user", nullptr, 0 }, { "password", nullptr, 0 } }; parseDataSource(data_source.data(), data_source.size(), vars, 5, "; "); std::stringstream conninfo; conninfo << "host='"; std::string host(vars[0].optval); ReplaceStringInPlace(host, "\\", "\\\\"); ReplaceStringInPlace(host, "'", "\\'"); conninfo << host << "' port='"; std::string port(vars[1].optval); ReplaceStringInPlace(port, "\\", "\\\\"); ReplaceStringInPlace(port, "'", "\\'"); conninfo << port << "' dbname='"; std::string dbname(vars[2].optval); ReplaceStringInPlace(dbname, "\\", "\\\\"); ReplaceStringInPlace(dbname, "'", "\\'"); conninfo << dbname << "' password='******'", "\\'"); conninfo << password << "' user='******'", "\\'"); conninfo << username << "'"; conninfo << " connect_timeout=" << connect_timeout; m_server = new PQ::Connection(conninfo.str()); if(m_server->status() == CONNECTION_OK){ return true; } else { handleError( nullptr, PHP_PDO_PGSQL_CONNECTION_FAILURE_SQLSTATE, m_server->errorMessage() ); return false; } }
static int pdo_odbc_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /* {{{ */ { pdo_odbc_db_handle *H; RETCODE rc; int use_direct = 0; zend_ulong cursor_lib; H = pecalloc(1, sizeof(*H), dbh->is_persistent); dbh->driver_data = H; SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &H->env); rc = SQLSetEnvAttr(H->env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { pdo_odbc_drv_error("SQLSetEnvAttr: ODBC3"); goto fail; } #ifdef SQL_ATTR_CONNECTION_POOLING if (pdo_odbc_pool_on != SQL_CP_OFF) { rc = SQLSetEnvAttr(H->env, SQL_ATTR_CP_MATCH, (void*)pdo_odbc_pool_mode, 0); if (rc != SQL_SUCCESS) { pdo_odbc_drv_error("SQLSetEnvAttr: SQL_ATTR_CP_MATCH"); goto fail; } } #endif rc = SQLAllocHandle(SQL_HANDLE_DBC, H->env, &H->dbc); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { pdo_odbc_drv_error("SQLAllocHandle (DBC)"); goto fail; } rc = SQLSetConnectAttr(H->dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)(dbh->auto_commit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF), SQL_IS_INTEGER); if (rc != SQL_SUCCESS) { pdo_odbc_drv_error("SQLSetConnectAttr AUTOCOMMIT"); goto fail; } /* set up the cursor library, if needed, or if configured explicitly */ cursor_lib = pdo_attr_lval(driver_options, PDO_ODBC_ATTR_USE_CURSOR_LIBRARY, SQL_CUR_USE_IF_NEEDED); rc = SQLSetConnectAttr(H->dbc, SQL_ODBC_CURSORS, (void*)cursor_lib, SQL_IS_INTEGER); if (rc != SQL_SUCCESS && cursor_lib != SQL_CUR_USE_IF_NEEDED) { pdo_odbc_drv_error("SQLSetConnectAttr SQL_ODBC_CURSORS"); goto fail; } if (strchr(dbh->data_source, ';')) { char dsnbuf[1024]; SQLSMALLINT dsnbuflen; use_direct = 1; /* Force UID and PWD to be set in the DSN */ if (dbh->username && *dbh->username && !strstr(dbh->data_source, "uid") && !strstr(dbh->data_source, "UID")) { char *dsn; spprintf(&dsn, 0, "%s;UID=%s;PWD=%s", dbh->data_source, dbh->username, dbh->password); pefree((char*)dbh->data_source, dbh->is_persistent); dbh->data_source = dsn; } rc = SQLDriverConnect(H->dbc, NULL, (char*)dbh->data_source, strlen(dbh->data_source), dsnbuf, sizeof(dsnbuf)-1, &dsnbuflen, SQL_DRIVER_NOPROMPT); } if (!use_direct) { rc = SQLConnect(H->dbc, (char*)dbh->data_source, SQL_NTS, dbh->username, SQL_NTS, dbh->password, SQL_NTS); } if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { pdo_odbc_drv_error(use_direct ? "SQLDriverConnect" : "SQLConnect"); goto fail; } /* TODO: if we want to play nicely, we should check to see if the driver really supports ODBC v3 or not */ dbh->methods = &odbc_methods; dbh->alloc_own_columns = 1; return 1; fail: dbh->methods = &odbc_methods; return 0; }
static int odbc_handle_preparer(pdo_dbh_t *dbh, const char *sql, size_t sql_len, pdo_stmt_t *stmt, zval *driver_options) { RETCODE rc; pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data; pdo_odbc_stmt *S = ecalloc(1, sizeof(*S)); enum pdo_cursor_type cursor_type = PDO_CURSOR_FWDONLY; int ret; char *nsql = NULL; size_t nsql_len = 0; S->H = H; S->assume_utf8 = H->assume_utf8; /* before we prepare, we need to peek at the query; if it uses named parameters, * we want PDO to rewrite them for us */ stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL; ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len); if (ret == 1) { /* query was re-written */ sql = nsql; } else if (ret == -1) { /* couldn't grok it */ strcpy(dbh->error_code, stmt->error_code); efree(S); return 0; } rc = SQLAllocHandle(SQL_HANDLE_STMT, H->dbc, &S->stmt); if (rc == SQL_INVALID_HANDLE || rc == SQL_ERROR) { efree(S); if (nsql) { efree(nsql); } pdo_odbc_drv_error("SQLAllocStmt"); return 0; } cursor_type = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY); if (cursor_type != PDO_CURSOR_FWDONLY) { rc = SQLSetStmtAttr(S->stmt, SQL_ATTR_CURSOR_SCROLLABLE, (void*)SQL_SCROLLABLE, 0); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { pdo_odbc_stmt_error("SQLSetStmtAttr: SQL_ATTR_CURSOR_SCROLLABLE"); SQLFreeHandle(SQL_HANDLE_STMT, S->stmt); if (nsql) { efree(nsql); } return 0; } } rc = SQLPrepare(S->stmt, (char*)sql, SQL_NTS); if (nsql) { efree(nsql); } stmt->driver_data = S; stmt->methods = &odbc_stmt_methods; if (rc != SQL_SUCCESS) { pdo_odbc_stmt_error("SQLPrepare"); if (rc != SQL_SUCCESS_WITH_INFO) { /* clone error information into the db handle */ strcpy(H->einfo.last_err_msg, S->einfo.last_err_msg); H->einfo.file = S->einfo.file; H->einfo.line = S->einfo.line; H->einfo.what = S->einfo.what; strcpy(dbh->error_code, stmt->error_code); } } if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { return 0; } return 1; }
static int pgsql_handle_preparer(pdo_dbh_t *dbh, const char *sql, zend_long sql_len, pdo_stmt_t *stmt, zval *driver_options) { pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data; pdo_pgsql_stmt *S = ecalloc(1, sizeof(pdo_pgsql_stmt)); int scrollable; int ret; char *nsql = NULL; int nsql_len = 0; int emulate = 0; int execute_only = 0; S->H = H; stmt->driver_data = S; stmt->methods = &pgsql_stmt_methods; scrollable = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY) == PDO_CURSOR_SCROLL; if (scrollable) { if (S->cursor_name) { efree(S->cursor_name); } spprintf(&S->cursor_name, 0, "pdo_crsr_%08x", ++H->stmt_counter); emulate = 1; } else if (driver_options) { if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT, H->disable_native_prepares) == 1) { php_error_docref(NULL, E_DEPRECATED, "PDO::PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT is deprecated, use PDO::ATTR_EMULATE_PREPARES instead"); emulate = 1; } if (pdo_attr_lval(driver_options, PDO_ATTR_EMULATE_PREPARES, H->emulate_prepares) == 1) { emulate = 1; } if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_PREPARES, H->disable_prepares) == 1) { execute_only = 1; } } else { emulate = H->disable_native_prepares || H->emulate_prepares; execute_only = H->disable_prepares; } if (!emulate && PQprotocolVersion(H->server) > 2) { stmt->supports_placeholders = PDO_PLACEHOLDER_NAMED; stmt->named_rewrite_template = "$%d"; ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len); if (ret == 1) { /* query was re-written */ sql = nsql; } else if (ret == -1) { /* couldn't grok it */ strcpy(dbh->error_code, stmt->error_code); return 0; } if (!execute_only) { /* prepared query: set the query name and defer the actual prepare until the first execute call */ spprintf(&S->stmt_name, 0, "pdo_stmt_%08x", ++H->stmt_counter); } if (nsql) { S->query = nsql; } else { S->query = estrdup(sql); } return 1; } stmt->supports_placeholders = PDO_PLACEHOLDER_NONE; return 1; }
static int pdo_dblib_handle_factory(pdo_dbh_t *dbh, zval *driver_options) { pdo_dblib_db_handle *H; int i, nvars, nvers, ret = 0; const pdo_dblib_keyval tdsver[] = { {"4.2",DBVERSION_42} ,{"4.6",DBVERSION_46} ,{"5.0",DBVERSION_70} /* FIXME: This does not work with Sybase, but environ will */ ,{"6.0",DBVERSION_70} ,{"7.0",DBVERSION_70} #ifdef DBVERSION_71 ,{"7.1",DBVERSION_71} #endif #ifdef DBVERSION_72 ,{"7.2",DBVERSION_72} ,{"8.0",DBVERSION_72} #endif #ifdef DBVERSION_73 ,{"7.3",DBVERSION_73} #endif #ifdef DBVERSION_74 ,{"7.4",DBVERSION_74} #endif ,{"10.0",DBVERSION_100} ,{"auto",0} /* Only works with FreeTDS. Other drivers will bork */ }; struct pdo_data_src_parser vars[] = { { "charset", NULL, 0 } ,{ "appname", "PHP " PDO_DBLIB_FLAVOUR, 0 } ,{ "host", "127.0.0.1", 0 } ,{ "dbname", NULL, 0 } ,{ "secure", NULL, 0 } /* DBSETLSECURE */ ,{ "version", NULL, 0 } /* DBSETLVERSION */ }; nvars = sizeof(vars)/sizeof(vars[0]); nvers = sizeof(tdsver)/sizeof(tdsver[0]); php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, nvars); H = pecalloc(1, sizeof(*H), dbh->is_persistent); H->login = dblogin(); H->err.sqlstate = dbh->error_code; H->stringify_uniqueidentifier = 0; if (!H->login) { goto cleanup; } if (driver_options) { int connect_timeout = pdo_attr_lval(driver_options, PDO_DBLIB_ATTR_CONNECTION_TIMEOUT, -1); int query_timeout = pdo_attr_lval(driver_options, PDO_DBLIB_ATTR_QUERY_TIMEOUT, -1); int timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, 30); if (connect_timeout == -1) { connect_timeout = timeout; } if (query_timeout == -1) { query_timeout = timeout; } dbsetlogintime(connect_timeout); /* Connection/Login Timeout */ dbsettime(query_timeout); /* Statement Timeout */ H->stringify_uniqueidentifier = pdo_attr_lval(driver_options, PDO_DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER, 0); } DBERRHANDLE(H->login, (EHANDLEFUNC) pdo_dblib_error_handler); DBMSGHANDLE(H->login, (MHANDLEFUNC) pdo_dblib_msg_handler); if(vars[5].optval) { for(i=0;i<nvers;i++) { if(strcmp(vars[5].optval,tdsver[i].key) == 0) { if(FAIL==dbsetlversion(H->login, tdsver[i].value)) { pdo_raise_impl_error(dbh, NULL, "HY000", "PDO_DBLIB: Failed to set version specified in connection string."); goto cleanup; } break; } } if (i==nvers) { printf("Invalid version '%s'\n", vars[5].optval); pdo_raise_impl_error(dbh, NULL, "HY000", "PDO_DBLIB: Invalid version specified in connection string."); goto cleanup; /* unknown version specified */ } } if (dbh->username) { if(FAIL == DBSETLUSER(H->login, dbh->username)) { goto cleanup; } } if (dbh->password) { if(FAIL == DBSETLPWD(H->login, dbh->password)) { goto cleanup; } } #if !PHP_DBLIB_IS_MSSQL if (vars[0].optval) { DBSETLCHARSET(H->login, vars[0].optval); } #endif DBSETLAPP(H->login, vars[1].optval); /* DBSETLDBNAME is only available in FreeTDS 0.92 or above */ #ifdef DBSETLDBNAME if (vars[3].optval) { if(FAIL == DBSETLDBNAME(H->login, vars[3].optval)) goto cleanup; } #endif H->link = dbopen(H->login, vars[2].optval); if (!H->link) { goto cleanup; } /* * FreeTDS < 0.92 does not support the DBSETLDBNAME option * Send use database here after login (Will not work with SQL Azure) */ #ifndef DBSETLDBNAME if (vars[3].optval) { if(FAIL == dbuse(H->link, vars[3].optval)) goto cleanup; } #endif #if PHP_DBLIB_IS_MSSQL /* dblib do not return more than this length from text/image */ DBSETOPT(H->link, DBTEXTLIMIT, "2147483647"); #endif /* limit text/image from network */ DBSETOPT(H->link, DBTEXTSIZE, "2147483647"); /* allow double quoted indentifiers */ DBSETOPT(H->link, DBQUOTEDIDENT, "1"); ret = 1; dbh->max_escaped_char_length = 2; dbh->alloc_own_columns = 1; cleanup: for (i = 0; i < nvars; i++) { if (vars[i].freeme) { efree(vars[i].optval); } } dbh->methods = &dblib_methods; dbh->driver_data = H; if (!ret) { zend_throw_exception_ex(php_pdo_get_exception(), DBLIB_G(err).dberr, "SQLSTATE[%s] %s (severity %d)", DBLIB_G(err).sqlstate, DBLIB_G(err).dberrstr, DBLIB_G(err).severity); } return ret; }
/* {{{ pdo_mysql_handle_factory */ static int pdo_mysql_handle_factory(pdo_dbh_t *dbh, zval *driver_options) { pdo_mysql_db_handle *H; size_t i; int ret = 0; char *host = NULL, *unix_socket = NULL; unsigned int port = 3306; char *dbname; struct pdo_data_src_parser vars[] = { { "charset", NULL, 0 }, { "dbname", "", 0 }, { "host", "localhost", 0 }, { "port", "3306", 0 }, { "unix_socket", PDO_DEFAULT_MYSQL_UNIX_ADDR, 0 }, }; int connect_opts = 0 #ifdef CLIENT_MULTI_RESULTS |CLIENT_MULTI_RESULTS #endif ; #if defined(PDO_USE_MYSQLND) size_t dbname_len = 0; size_t password_len = 0; #endif #ifdef CLIENT_MULTI_STATEMENTS if (!driver_options) { connect_opts |= CLIENT_MULTI_STATEMENTS; } else if (pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_MULTI_STATEMENTS, 1)) { connect_opts |= CLIENT_MULTI_STATEMENTS; } #endif PDO_DBG_ENTER("pdo_mysql_handle_factory"); PDO_DBG_INF_FMT("dbh=%p", dbh); #ifdef CLIENT_MULTI_RESULTS PDO_DBG_INF("multi results"); #endif php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, 5); H = pecalloc(1, sizeof(pdo_mysql_db_handle), dbh->is_persistent); H->einfo.errcode = 0; H->einfo.errmsg = NULL; /* allocate an environment */ /* handle for the server */ if (!(H->server = pdo_mysql_init(dbh->is_persistent))) { pdo_mysql_error(dbh); goto cleanup; } #if defined(PDO_USE_MYSQLND) if (dbh->is_persistent) { mysqlnd_restart_psession(H->server); } #endif dbh->driver_data = H; #ifndef PDO_USE_MYSQLND H->max_buffer_size = 1024*1024; #endif H->assume_national_character_set_strings = 0; H->buffered = H->emulate_prepare = 1; /* handle MySQL options */ if (driver_options) { zend_long connect_timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, 30); zend_long local_infile = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_LOCAL_INFILE, 0); zend_string *init_cmd = NULL; #ifndef PDO_USE_MYSQLND zend_string *default_file = NULL, *default_group = NULL; #endif zend_long compress = 0; zend_string *ssl_key = NULL, *ssl_cert = NULL, *ssl_ca = NULL, *ssl_capath = NULL, *ssl_cipher = NULL; H->buffered = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_USE_BUFFERED_QUERY, 1); H->emulate_prepare = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_DIRECT_QUERY, H->emulate_prepare); H->emulate_prepare = pdo_attr_lval(driver_options, PDO_ATTR_EMULATE_PREPARES, H->emulate_prepare); H->assume_national_character_set_strings = pdo_attr_lval(driver_options, PDO_ATTR_DEFAULT_STR_PARAM, 0) == PDO_PARAM_STR_NATL; #ifndef PDO_USE_MYSQLND H->max_buffer_size = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_MAX_BUFFER_SIZE, H->max_buffer_size); #endif if (pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_FOUND_ROWS, 0)) { connect_opts |= CLIENT_FOUND_ROWS; } if (pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_IGNORE_SPACE, 0)) { connect_opts |= CLIENT_IGNORE_SPACE; } if (mysql_options(H->server, MYSQL_OPT_CONNECT_TIMEOUT, (const char *)&connect_timeout)) { pdo_mysql_error(dbh); goto cleanup; } #ifndef PDO_USE_MYSQLND if (PG(open_basedir) && PG(open_basedir)[0] != '\0') { local_infile = 0; } #endif #if defined(MYSQL_OPT_LOCAL_INFILE) || defined(PDO_USE_MYSQLND) if (mysql_options(H->server, MYSQL_OPT_LOCAL_INFILE, (const char *)&local_infile)) { pdo_mysql_error(dbh); goto cleanup; } #endif #ifdef MYSQL_OPT_RECONNECT /* since 5.0.3, the default for this option is 0 if not specified. * we want the old behaviour * mysqlnd doesn't support reconnect, thus we don't have "|| defined(PDO_USE_MYSQLND)" */ { zend_long reconnect = 1; mysql_options(H->server, MYSQL_OPT_RECONNECT, (const char*)&reconnect); } #endif init_cmd = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_INIT_COMMAND, NULL); if (init_cmd) { if (mysql_options(H->server, MYSQL_INIT_COMMAND, (const char *)ZSTR_VAL(init_cmd))) { zend_string_release_ex(init_cmd, 0); pdo_mysql_error(dbh); goto cleanup; } zend_string_release_ex(init_cmd, 0); } #ifndef PDO_USE_MYSQLND default_file = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_READ_DEFAULT_FILE, NULL); if (default_file) { if (mysql_options(H->server, MYSQL_READ_DEFAULT_FILE, (const char *)ZSTR_VAL(default_file))) { zend_string_release_ex(default_file, 0); pdo_mysql_error(dbh); goto cleanup; } zend_string_release_ex(default_file, 0); } default_group = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_READ_DEFAULT_GROUP, NULL); if (default_group) { if (mysql_options(H->server, MYSQL_READ_DEFAULT_GROUP, (const char *)ZSTR_VAL(default_group))) { zend_string_release_ex(default_group, 0); pdo_mysql_error(dbh); goto cleanup; } zend_string_release_ex(default_group, 0); } #endif compress = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_COMPRESS, 0); if (compress) { if (mysql_options(H->server, MYSQL_OPT_COMPRESS, 0)) { pdo_mysql_error(dbh); goto cleanup; } } ssl_key = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_KEY, NULL); ssl_cert = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CERT, NULL); ssl_ca = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CA, NULL); ssl_capath = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CAPATH, NULL); ssl_cipher = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CIPHER, NULL); if (ssl_key || ssl_cert || ssl_ca || ssl_capath || ssl_cipher) { mysql_ssl_set(H->server, ssl_key? ZSTR_VAL(ssl_key) : NULL, ssl_cert? ZSTR_VAL(ssl_cert) : NULL, ssl_ca? ZSTR_VAL(ssl_ca) : NULL, ssl_capath? ZSTR_VAL(ssl_capath) : NULL, ssl_cipher? ZSTR_VAL(ssl_cipher) : NULL); if (ssl_key) { zend_string_release_ex(ssl_key, 0); } if (ssl_cert) { zend_string_release_ex(ssl_cert, 0); } if (ssl_ca) { zend_string_release_ex(ssl_ca, 0); } if (ssl_capath) { zend_string_release_ex(ssl_capath, 0); } if (ssl_cipher) { zend_string_release_ex(ssl_cipher, 0); } } #if MYSQL_VERSION_ID > 50605 || defined(PDO_USE_MYSQLND) { zend_string *public_key = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SERVER_PUBLIC_KEY, NULL); if (public_key) { if (mysql_options(H->server, MYSQL_SERVER_PUBLIC_KEY, ZSTR_VAL(public_key))) { pdo_mysql_error(dbh); zend_string_release_ex(public_key, 0); goto cleanup; } zend_string_release_ex(public_key, 0); } } #endif #ifdef PDO_USE_MYSQLND { zend_long ssl_verify_cert = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_SSL_VERIFY_SERVER_CERT, -1); if (ssl_verify_cert != -1) { connect_opts |= ssl_verify_cert ? CLIENT_SSL_VERIFY_SERVER_CERT: CLIENT_SSL_DONT_VERIFY_SERVER_CERT; } } #endif } #ifdef PDO_MYSQL_HAS_CHARSET if (vars[0].optval && mysql_options(H->server, MYSQL_SET_CHARSET_NAME, vars[0].optval)) { pdo_mysql_error(dbh); goto cleanup; } #endif dbname = vars[1].optval; host = vars[2].optval; if(vars[3].optval) { port = atoi(vars[3].optval); } #ifdef PHP_WIN32 if (vars[2].optval && !strcmp(".", vars[2].optval)) { #else if (vars[2].optval && !strcmp("localhost", vars[2].optval)) { #endif unix_socket = vars[4].optval; } /* TODO: - Check zval cache + ZTS */ #ifdef PDO_USE_MYSQLND if (dbname) { dbname_len = strlen(dbname); } if (dbh->password) { password_len = strlen(dbh->password); } if (mysqlnd_connect(H->server, host, dbh->username, dbh->password, password_len, dbname, dbname_len, port, unix_socket, connect_opts, MYSQLND_CLIENT_NO_FLAG) == NULL) { #else if (mysql_real_connect(H->server, host, dbh->username, dbh->password, dbname, port, unix_socket, connect_opts) == NULL) { #endif pdo_mysql_error(dbh); goto cleanup; } if (!dbh->auto_commit) { mysql_handle_autocommit(dbh); } H->attached = 1; dbh->alloc_own_columns = 1; dbh->max_escaped_char_length = 2; dbh->methods = &mysql_methods; ret = 1; cleanup: for (i = 0; i < sizeof(vars)/sizeof(vars[0]); i++) { if (vars[i].freeme) { efree(vars[i].optval); } } dbh->methods = &mysql_methods; PDO_DBG_RETURN(ret); } /* }}} */ const pdo_driver_t pdo_mysql_driver = { PDO_DRIVER_HEADER(mysql), pdo_mysql_handle_factory };
/* {{{ mysql_handle_preparer */ static int mysql_handle_preparer(pdo_dbh_t *dbh, const char *sql, size_t sql_len, pdo_stmt_t *stmt, zval *driver_options) { pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data; pdo_mysql_stmt *S = ecalloc(1, sizeof(pdo_mysql_stmt)); char *nsql = NULL; size_t nsql_len = 0; int ret; int server_version; PDO_DBG_ENTER("mysql_handle_preparer"); PDO_DBG_INF_FMT("dbh=%p", dbh); PDO_DBG_INF_FMT("sql=%.*s", (int)sql_len, sql); S->H = H; stmt->driver_data = S; stmt->methods = &mysql_stmt_methods; if (H->emulate_prepare) { goto end; } server_version = mysql_get_server_version(H->server); if (server_version < 40100) { goto fallback; } stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL; ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len); if (ret == 1) { /* query was rewritten */ sql = nsql; sql_len = nsql_len; } else if (ret == -1) { /* failed to parse */ strcpy(dbh->error_code, stmt->error_code); PDO_DBG_RETURN(0); } if (!(S->stmt = mysql_stmt_init(H->server))) { pdo_mysql_error(dbh); if (nsql) { efree(nsql); } PDO_DBG_RETURN(0); } if (mysql_stmt_prepare(S->stmt, sql, sql_len)) { /* TODO: might need to pull statement specific info here? */ /* if the query isn't supported by the protocol, fallback to emulation */ if (mysql_errno(H->server) == 1295) { if (nsql) { efree(nsql); } goto fallback; } pdo_mysql_error(dbh); if (nsql) { efree(nsql); } PDO_DBG_RETURN(0); } if (nsql) { efree(nsql); } S->num_params = mysql_stmt_param_count(S->stmt); if (S->num_params) { S->params_given = 0; #if defined(PDO_USE_MYSQLND) S->params = NULL; #else S->params = ecalloc(S->num_params, sizeof(MYSQL_BIND)); S->in_null = ecalloc(S->num_params, sizeof(my_bool)); S->in_length = ecalloc(S->num_params, sizeof(zend_ulong)); #endif } dbh->alloc_own_columns = 1; S->max_length = pdo_attr_lval(driver_options, PDO_ATTR_MAX_COLUMN_LEN, 0); PDO_DBG_RETURN(1); fallback: end: stmt->supports_placeholders = PDO_PLACEHOLDER_NONE; PDO_DBG_RETURN(1); }