int _pdo_pgsql_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, int errcode, const char *sqlstate, const char *file, int line TSRMLS_DC) /* {{{ */ { pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data; pdo_error_type *pdo_err = stmt ? &stmt->error_code : &dbh->error_code; pdo_pgsql_error_info *einfo = &H->einfo; char *errmsg = PQerrorMessage(H->server); einfo->errcode = errcode; einfo->file = file; einfo->line = line; if (einfo->errmsg) { pefree(einfo->errmsg, dbh->is_persistent); einfo->errmsg = NULL; } if (sqlstate == NULL) { strcpy(*pdo_err, "HY000"); } else { strcpy(*pdo_err, sqlstate); } if (errmsg) { einfo->errmsg = _pdo_pgsql_trim_message(errmsg, dbh->is_persistent); } if (!dbh->methods) { zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s", *pdo_err, einfo->errcode, einfo->errmsg); } return errcode; }
void nuodb_throw_zend_exception(const char *sql_state, int code, const char *msg) { TSRMLS_FETCH(); PDO_DBG_ENTER("nuodb_throw_zend_exception"); PDO_DBG_INF_FMT("Throwing exception: SQLSTATE[%s] [%d] %s", sql_state, code, msg); zend_throw_exception_ex(php_pdo_get_exception(), code TSRMLS_CC, "SQLSTATE[%s] [%d] %s", sql_state, code, msg); PDO_DBG_VOID_RETURN; }
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; }
int _pdo_sqlite_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line) /* {{{ */ { pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data; pdo_error_type *pdo_err = stmt ? &stmt->error_code : &dbh->error_code; pdo_sqlite_error_info *einfo = &H->einfo; einfo->errcode = sqlite3_errcode(H->db); einfo->file = file; einfo->line = line; if (einfo->errcode != SQLITE_OK) { if (einfo->errmsg) { pefree(einfo->errmsg, dbh->is_persistent); } einfo->errmsg = pestrdup((char*)sqlite3_errmsg(H->db), dbh->is_persistent); } else { /* no error */ strncpy(*pdo_err, PDO_ERR_NONE, sizeof(PDO_ERR_NONE)); return 0; } switch (einfo->errcode) { case SQLITE_NOTFOUND: strncpy(*pdo_err, "42S02", sizeof("42S02")); break; case SQLITE_INTERRUPT: strncpy(*pdo_err, "01002", sizeof("01002")); break; case SQLITE_NOLFS: strncpy(*pdo_err, "HYC00", sizeof("HYC00")); break; case SQLITE_TOOBIG: strncpy(*pdo_err, "22001", sizeof("22001")); break; case SQLITE_CONSTRAINT: strncpy(*pdo_err, "23000", sizeof("23000")); break; case SQLITE_ERROR: default: strncpy(*pdo_err, "HY000", sizeof("HY000")); break; } if (!dbh->methods) { zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode, "SQLSTATE[%s] [%d] %s", *pdo_err, einfo->errcode, einfo->errmsg); } return einfo->errcode; }
int _record_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line, const char *sql_state, int error_code, const char *error_message) { pdo_nuodb_db_handle *H = (pdo_nuodb_db_handle *)dbh->driver_data; pdo_error_type *pdo_err; pdo_nuodb_error_info *einfo; pdo_nuodb_stmt *S = NULL; PDO_DBG_ENTER("_record_error"); PDO_DBG_INF_FMT("file=%s line=%d", file, line); PDO_DBG_INF_FMT("sql_state=%s error_code=%d error_message=%s", sql_state, error_code, error_message); if (stmt) { S = (pdo_nuodb_stmt*)stmt->driver_data; PDO_DBG_INF_FMT("sql=%s", S->sql); pdo_err = &stmt->error_code; einfo = &S->einfo; } else { pdo_err = &dbh->error_code; einfo = &H->einfo; } einfo->errcode = error_code; einfo->file = file; einfo->line = line; if (einfo->errmsg) { pefree(einfo->errmsg, dbh->is_persistent); einfo->errmsg = NULL; } if (!einfo->errcode) { /* no error */ strcpy(*pdo_err, PDO_ERR_NONE); PDO_DBG_RETURN(0); } einfo->errmsg = pestrdup(error_message, dbh->is_persistent); strncpy(*pdo_err, sql_state, 6); if (!dbh->methods) { TSRMLS_FETCH(); PDO_DBG_INF("Throwing exception"); zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s", *pdo_err, einfo->errcode, einfo->errmsg); } PDO_DBG_RETURN(einfo->errcode); }
int _pdo_4d_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line TSRMLS_DC) /* {{{ */ { pdo_4d_db_handle *H = (pdo_4d_db_handle *)dbh->driver_data; pdo_error_type *pdo_err; pdo_4d_error_info *einfo; pdo_4d_stmt *S = NULL; if (stmt) { S = (pdo_4d_stmt*)stmt->driver_data; pdo_err = &stmt->error_code; einfo = &S->einfo; } else { pdo_err = &dbh->error_code; einfo = &H->einfo; } //pdo_err = &dbh->error_code; //einfo = &H->einfo; einfo->errcode = fourd_errno(H->server); einfo->file = file; einfo->line = line; /* free memory of last error message */ if (einfo->errmsg) { pefree(einfo->errmsg, dbh->is_persistent); einfo->errmsg = NULL; } strncpy(*pdo_err, fourd_sqlstate(H->server),5); *pdo_err[5]=0; /* if error_code is not null => get error message */ /* printf("einfo->errcode:%d\n",einfo->errcode); */ if (einfo->errcode) { /* printf("copy errmsg\n"); */ einfo->errmsg = pestrdup(fourd_error(H->server), dbh->is_persistent); } else { strcpy(*pdo_err, PDO_ERR_NONE); return 0; } if (!dbh->methods) { zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "SQLSTATE[%s] [%d] %s", *pdo_err, einfo->errcode, einfo->errmsg); } return einfo->errcode; }
void pdo_odbc_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, PDO_ODBC_HSTMT statement, char *what, const char *file, int line) /* {{{ */ { SQLRETURN rc; SQLSMALLINT errmsgsize = 0; SQLHANDLE eh; SQLSMALLINT htype, recno = 1; pdo_odbc_db_handle *H = (pdo_odbc_db_handle*)dbh->driver_data; pdo_odbc_errinfo *einfo = &H->einfo; pdo_odbc_stmt *S = NULL; pdo_error_type *pdo_err = &dbh->error_code; if (stmt) { S = (pdo_odbc_stmt*)stmt->driver_data; einfo = &S->einfo; pdo_err = &stmt->error_code; } if (statement == SQL_NULL_HSTMT && S) { statement = S->stmt; } if (statement) { htype = SQL_HANDLE_STMT; eh = statement; } else if (H->dbc) { htype = SQL_HANDLE_DBC; eh = H->dbc; } else { htype = SQL_HANDLE_ENV; eh = H->env; } rc = SQLGetDiagRec(htype, eh, recno++, einfo->last_state, &einfo->last_error, einfo->last_err_msg, sizeof(einfo->last_err_msg)-1, &errmsgsize); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { errmsgsize = 0; } einfo->last_err_msg[errmsgsize] = '\0'; einfo->file = file; einfo->line = line; einfo->what = what; strcpy(*pdo_err, einfo->last_state); /* printf("@@ SQLSTATE[%s] %s\n", *pdo_err, einfo->last_err_msg); */ if (!dbh->methods) { zend_throw_exception_ex(php_pdo_get_exception(), einfo->last_error, "SQLSTATE[%s] %s: %d %s", *pdo_err, what, einfo->last_error, einfo->last_err_msg); } /* just like a cursor, once you start pulling, you need to keep * going until the end; SQL Server (at least) will mess with the * actual cursor state if you don't finish retrieving all the * diagnostic records (which can be generated by PRINT statements * in the query, for instance). */ while (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) { char discard_state[6]; char discard_buf[1024]; SQLINTEGER code; rc = SQLGetDiagRec(htype, eh, recno++, discard_state, &code, discard_buf, sizeof(discard_buf)-1, &errmsgsize); } }
/* {{{ _pdo_mysql_error */ int _pdo_mysql_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line TSRMLS_DC) { pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data; pdo_error_type *pdo_err; pdo_mysql_error_info *einfo; pdo_mysql_stmt *S = NULL; PDO_DBG_ENTER("_pdo_mysql_error"); PDO_DBG_INF_FMT("file=%s line=%d", file, line); if (stmt) { S = (pdo_mysql_stmt*)stmt->driver_data; pdo_err = &stmt->error_code; einfo = &S->einfo; } else { pdo_err = &dbh->error_code; einfo = &H->einfo; } if (S && S->stmt) { einfo->errcode = mysql_stmt_errno(S->stmt); } else { einfo->errcode = mysql_errno(H->server); } einfo->file = file; einfo->line = line; if (einfo->errmsg) { pefree(einfo->errmsg, dbh->is_persistent); einfo->errmsg = NULL; } if (einfo->errcode) { if (einfo->errcode == 2014) { einfo->errmsg = pestrdup( "Cannot execute queries while other unbuffered queries are active. " "Consider using PDOStatement::fetchAll(). Alternatively, if your code " "is only ever going to run against mysql, you may enable query " "buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.", dbh->is_persistent); } else if (einfo->errcode == 2057) { einfo->errmsg = pestrdup( "A stored procedure returning result sets of different size was called. " "This is not supported by libmysql", dbh->is_persistent); } else { einfo->errmsg = pestrdup(mysql_error(H->server), dbh->is_persistent); } } else { /* no error */ strcpy(*pdo_err, PDO_ERR_NONE); PDO_DBG_RETURN(0); } if (S && S->stmt) { strcpy(*pdo_err, mysql_stmt_sqlstate(S->stmt)); } else { strcpy(*pdo_err, mysql_sqlstate(H->server)); } if (!dbh->methods) { PDO_DBG_INF("Throwing exception"); zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s", *pdo_err, einfo->errcode, einfo->errmsg); } PDO_DBG_RETURN(einfo->errcode); }
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; }