int dbaccess(char * server, char * user, char * cpw, RSA * rsa) { SQLHENV henv; SQLHDBC hdbc; char * pw; // Do something pw = base64_decode(cpw); SQLConnect(hdbc, (SQLCHAR *)server, strlen(server), user, strlen(user), pw, strlen(pw)); // @violation WEAK_ENCRYPTION.PASSWORD RSA_private_decrypt(strlen(cpw), cpw, pw, rsa, RSA_PKCS1_PADDING); SQLConnect(hdbc, (SQLCHAR *)server, strlen(server), user, strlen(user), pw, strlen(pw)); return 0; }
void sqlConnect(SQLHENV *henv, SQLHDBC *hdbc, SQLHSTMT *hstmt) { // sql vars SQLRETURN rc; // allocate environment handle rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, henv); if (!checkReturnCode("SQLAllocHandle [henv]", rc, *henv, SQL_HANDLE_ENV)){ freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT); exit(0); } rc = SQLSetEnvAttr(*henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0); if (!checkReturnCode("SQLSetEnvAttr [henv]", rc, henv, SQL_HANDLE_ENV)){ freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT); exit(0); } // allocate connection handle rc = SQLAllocHandle(SQL_HANDLE_DBC, *henv, hdbc); if (!checkReturnCode("SQLAllocHandle [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)){ freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT); exit(0); } // set login timeout to 5 seconds rc = SQLSetConnectAttr(*hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0); if (!checkReturnCode("SQLSetConnectAttr [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)){ freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT); exit(0); } // linux // connect to data source char* server = "MSSQLSERVER"; char* login = "******"; char* password = "******"; rc = SQLConnect(*hdbc, (SQLCHAR*) server, SQL_NTS, (SQLCHAR*) login, SQL_NTS, (SQLCHAR*) password, SQL_NTS); if (!checkReturnCode("SQLConnect [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)) { freeSQLHandles(henv, hdbc, hstmt); exit(0); } // windows // sql driver connect /*SQLCHAR retconstring[1024]; char* connStr = "DRIVER={SQL Server};SERVER=141.56.2.45, 1433;DATABASE=Verkauf;UID=stud01;PWD=stud01;"; rc = SQLDriverConnect(*hdbc, NULL, (SQLCHAR*)connStr, SQL_NTS, retconstring, 1024, NULL, SQL_DRIVER_NOPROMPT); if (!checkReturnCode("SQLDriverConnect [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)){ freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT); exit(0); }*/ // allocate statement handle rc = SQLAllocHandle(SQL_HANDLE_STMT, *hdbc, hstmt); if (!checkReturnCode("SQLAllocHandle [hstmt]", rc, *hstmt, SQL_HANDLE_STMT)) { freeSQLHandles(henv, hdbc, hstmt); exit(0); } }
/************************************************************************ * name: SQLConnectW * arguments: * returns/side-effects: * description: * NOTE: ************************************************************************/ ODBC_INTERFACE RETCODE SQL_API SQLConnectW (SQLHDBC hdbc, SQLWCHAR *dsn, SQLSMALLINT dsn_len, SQLWCHAR *user, SQLSMALLINT user_len, SQLWCHAR *auth, SQLSMALLINT auth_len) { SQLCHAR *cb_user, *cb_auth, *cb_dsn; int cb_user_len, cb_auth_len, cb_dsn_len; RETCODE ret; OutputDebugString ("SQLConnectW called\n"); wide_char_to_bytes (user, user_len, &cb_user, &cb_user_len, NULL); wide_char_to_bytes (auth, auth_len, &cb_auth, &cb_auth_len, NULL); wide_char_to_bytes (dsn, dsn_len, &cb_dsn, &cb_dsn_len, NULL); ret = SQLConnect (hdbc, cb_dsn, cb_dsn_len, cb_user, cb_user_len, cb_auth, cb_auth_len) ; UT_FREE (cb_user); UT_FREE (cb_auth); UT_FREE (cb_dsn); return ret; }
/* ** Creates and returns a connection object ** Lua Input: source [, user [, pass]] ** source: data source ** user, pass: data source authentication information ** Lua Returns: ** connection object if successfull ** nil and error message otherwise. */ static int env_connect (lua_State *L) { env_data *env = (env_data *) getenvironment (L); const char *sourcename = luaL_checkstring (L, 2); const char *username = luaL_optstring (L, 3, NULL); const char *password = luaL_optstring (L, 4, NULL); SQLHDBC hdbc; SQLRETURN ret; /* tries to allocate connection handle */ ret = SQLAllocHandle (hDBC, env->henv, &hdbc); if (error(ret)) return luasql_faildirect (L, "connection allocation error."); /* tries to connect handle */ ret = SQLConnect (hdbc, (char *) sourcename, SQL_NTS, (char *) username, SQL_NTS, (char *) password, SQL_NTS); if (error(ret)) { ret = fail(L, hDBC, hdbc); SQLFreeHandle(hDBC, hdbc); return ret; } /* success, return connection object */ return create_connection (L, 1, env, hdbc); }
void ODBCConnect(SQLHANDLE henv, SQLHANDLE *hdbc, char *username, char *password, char *dataSource) { SQLRETURN rc; rc = SQLAllocHandle(SQL_HANDLE_DBC, henv, hdbc); if (rc != SQL_SUCCESS) { printf ("Couldn't initialize ODBC connection.\n"); exit(255); } printf("===========================================================\n"); printf("Connecting to: %s\n", dataSource); printf(" User: %s\n", username); printf(" Password: %s\n", password); printf("\n"); rc = SQLConnect(*hdbc, (SQLCHAR *)dataSource, strlen(dataSource), (SQLCHAR *)username, strlen(username), (SQLCHAR *)password, strlen(password)); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { printf("Did not connect to %s\n", dataSource); displayError(SQL_HANDLE_DBC, *hdbc); exit(255); } else { printf("CONNECTED!\n", dataSource); } printf("===========================================================\n"); }
static SqlServer_T doConnect(URL_T url, char **error) { RETCODE retcode; SqlServer_T db = (SqlServer_T)malloc(sizeof(struct SqlServer_S)); /*retcode = SQLAllocHandle (SQL_HANDLE_ENV, NULL, &db->henv); retcode = SQLSetEnvAttr(db->henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER); */ retcode = SQLAllocEnv(&db->henv); //2.Á¬½Ó¾ä±ú retcode = SQLAllocConnect(db->henv, &db->hdbc); //retcode = SQLAllocHandle(SQL_HANDLE_DBC, db->henv, &db->hdbc); retcode = SQLConnect(db->hdbc, URL_getParameter(url, "db"), strlen( URL_getParameter(url, "db") ), URL_getUser(url), strlen(URL_getUser(url)), URL_getPassword(url), strlen(URL_getPassword(url))); if (SQLSERVERSUCCESS(retcode)) { return db; } else { SQLFreeHandle(SQL_HANDLE_DBC, db->hdbc); SQLFreeHandle(SQL_HANDLE_ENV, db->henv); free(db); return NULL; } }
int main (int ac, char *av[]) { SQLRETURN rc; if (ac < 3) { err_printf ("***FAILED: usage : %s dsn uid pwd\n", av[0]); return (-1); } dsn = av[1]; uid = av[2]; pwd = av[3]; rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, (SQLHANDLE *) & henv); if (rc != SQL_SUCCESS) { err_printf ("SQLAllocHandle() failed.\n"); return 1; } rc = SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER); if (rc != SQL_SUCCESS) { err_printf ("SQLSetEnvAttr() failed.\n"); return 1; } rc = SQLAllocHandle (SQL_HANDLE_DBC, (SQLHANDLE) henv, (SQLHANDLE *) & hdbc); if (rc != SQL_SUCCESS) { err_printf ("SQLAllocHandle() failed.\n"); return 1; } rc = SQLConnect (hdbc, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { err_printf ("SQLConnect() failed.\n"); error (SQL_HANDLE_DBC, (SQLHANDLE) hdbc); return 1; } rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, 0); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { err_printf ("autocommit off() failed.\n"); error (SQL_HANDLE_DBC, (SQLHANDLE) hdbc); return 1; } create_proc (); printf ("=====================================================\n"); printf ("starting test\n"); test (); printf ("test1 done\n"); printf ("=====================================================\n"); return 0; }
// open a connection with a data_source bool connection::connect(const _tstring & _dsn, const _tstring & _user, const _tstring & _pass, int _timeout, bool _autocommit) { cleanup(); // Allocate handles b_own_handle = true; __allocate_handle(env_h, conn_h); if (_timeout != -1) { // Set connection timeout SQLSetConnectAttr(conn_h, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)(size_t)_timeout, 0); } b_autocommit = _autocommit; if (!b_autocommit) { // Set manual commit mode SQLSetConnectAttr(conn_h, SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF, 0); } // Connect! SQLTCHAR_buf s_dsn = ybstring2sqltchar(_dsn, ""), s_user = ybstring2sqltchar(_user, ""), s_pass = ybstring2sqltchar(_pass, ""); RETCODE rc = SQLConnect(conn_h, s_dsn.data, SQL_NTS, s_user.data, SQL_NTS, s_pass.data, SQL_NTS); if (TIODBC_SUCCESS_CODE(rc)) { b_connected = true; } return b_connected; }
bool COdbcConnection::Open() { COdbcConnectionInformation *pCI = static_cast<COdbcConnectionInformation*>(GetConnectionInformation()); m_lasterror = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&m_hEnv); if(!SQL_SUCCEEDED(m_lasterror)) return false; m_lasterror = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0); if(!SQL_SUCCEEDED(m_lasterror)) return false; m_lasterror = SQLAllocHandle(SQL_HANDLE_DBC,m_hEnv,&m_hDbc); if(!SQL_SUCCEEDED(m_lasterror)) return false; m_lasterror = SQLConnect(m_hDbc,(SQLCHAR*)pCI->database.c_str(),SQL_NTS,(SQLCHAR*)pCI->username.c_str(),SQL_NTS,(SQLCHAR*)pCI->password.c_str(),SQL_NTS); if(!SQL_SUCCEEDED(m_lasterror)) return false; m_lasterror = SQLSetConnectAttr(m_hDbc,SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)SQL_AUTOCOMMIT_ON,0); if(!SQL_SUCCEEDED(m_lasterror)) return false; return true; }
SQLRETURN SQL_API SQLConnectW ( SQLHDBC hdbc, SQLWCHAR * wszDSN, SQLSMALLINT cbDSN, SQLWCHAR * wszUID, SQLSMALLINT cbUID, SQLWCHAR * wszPWD, SQLSMALLINT cbPWD) { long len; CON_CHARSET (hdbc); SQLRETURN rc; DEFINE_INPUT_NARROW (DSN); DEFINE_INPUT_NARROW (UID); DEFINE_INPUT_NARROW (PWD); MAKE_INPUT_NARROW_N (DSN); MAKE_INPUT_NARROW_N (UID); MAKE_INPUT_NARROW_N (PWD); rc = SQLConnect (hdbc, szDSN, SQL_NTS, szUID, SQL_NTS, szPWD, SQL_NTS); FREE_INPUT_NARROW (DSN); FREE_INPUT_NARROW (UID); FREE_INPUT_NARROW (PWD); return rc; }
/************************************************************************* * * Function: sql_create_socket * * Purpose: Establish connection to the db * *************************************************************************/ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { SQLRETURN retval; rlm_sql_db2_sock *sock; /* allocate socket */ if (!sqlsocket->conn) { sqlsocket->conn = (rlm_sql_db2_sock*)rad_malloc(sizeof(rlm_sql_db2_sock)); if (!sqlsocket->conn) { return -1; } } sock = sqlsocket->conn; memset(sock, 0, sizeof(*sock)); /* allocate handles */ SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(sock->henv)); SQLAllocHandle(SQL_HANDLE_DBC, sock->henv, &(sock->hdbc)); /* connect to database */ retval = SQLConnect(sock->hdbc, config->sql_server, SQL_NTS, config->sql_login, SQL_NTS, config->sql_password, SQL_NTS); if(retval != SQL_SUCCESS) { radlog(L_ERR, "could not connect to DB2 server %s\n", config->sql_server); SQLDisconnect(sock->hdbc); SQLFreeHandle(SQL_HANDLE_DBC, sock->hdbc); SQLFreeHandle(SQL_HANDLE_ENV, sock->henv); return -1; } return 0; }
static SQLRETURN init(char *dbalias, SQLHENV *henv, SQLHDBC *hdbc) { SQLHSTMT hstmt; /* statement handle */ SQLRETURN rc; *henv = 0; rc = SQLAllocEnv(henv); CHECK_HANDLE(SQL_HANDLE_ENV, *henv, rc, "SQLAllocEnv", (SQLCHAR *) ""); rc = SQLAllocConnect(*henv, hdbc); CHECK_HANDLE(SQL_HANDLE_DBC, *hdbc, rc, "SQLAllocConnect", (SQLCHAR *) ""); rc = SQLConnect(*hdbc, (SQLCHAR *) dbalias, SQL_NTS, NULL, SQL_NTS, NULL, SQL_NTS); CHECK_HANDLE(SQL_HANDLE_DBC, *hdbc, rc, "SQLConnect", (SQLCHAR *) ""); rc = SQLAllocHandle(SQL_HANDLE_STMT, *hdbc, &hstmt); CHECK_HANDLE(SQL_HANDLE_STMT, hstmt, rc, "SQLAllocHandle", (SQLCHAR *) ""); (void) SQLExecDirect(hstmt, CTSQL, SQL_NTS); /*CHECK_HANDLE(SQL_HANDLE_STMT, hstmt, rc, "SQLExecDirect", CTSQL);*/ (void) SQLFreeStmt(hstmt, SQL_DROP); return rc; }
int DBOP::open(WCHAR *DSN,WCHAR *UID,WCHAR *AuthStr){ retcode = SQLAllocHandle (SQL_HANDLE_ENV, NULL, &henv); retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION,(SQLPOINTER)SQL_OV_ODBC3,SQL_IS_INTEGER); retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc); //WCHAR* WDSN = new WCHAR[2*sizeof(DSN[0])]; //WCHAR* WUID = new WCHAR[2*sizeof(UID[0]) ]; //WCHAR* WAUTHSTR = new WCHAR[sizeof(AuthStr[0]) + 1]; //MultiByteToWideChar(CP_ACP, 0, DSN, strlen(DSN) + 1, WDSN, sizeof(WDSN[0])); //MultiByteToWideChar(CP_ACP, 0, UID, strlen(UID) + 1, WUID, sizeof(WUID[0])); //MultiByteToWideChar(CP_ACP, 0, AuthStr, strlen(AuthStr) + 1, WAUTHSTR, sizeof(WAUTHSTR[0])); retcode = SQLConnect(hdbc, (SQLWCHAR*)DSN, wcslen((SQLWCHAR*)DSN), (SQLWCHAR*)UID, wcslen((SQLWCHAR*)UID), (SQLWCHAR*)AuthStr, wcslen((SQLWCHAR*)AuthStr)); if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) { SQLDisconnect(hdbc); SQLFreeHandle(SQL_HANDLE_DBC, hdbc); SQLFreeHandle(SQL_HANDLE_ENV, henv); return 0; } retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); if((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO)){ return 0; } return 1; }
// Allocate environment handle, allocate connection handle, // connect to data source, and allocate statement handle. bool direxec::sqlconn(FILE* file) { logFile = file; unsigned int timeout = 10; // seconds SQLAllocEnv(&henv); SQLAllocConnect(henv,&hdbc); SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, &timeout, 0); rc=SQLConnect(hdbc,chr_ds_name,SQL_NTS,NULL,0,NULL,0); // Deallocate handles, display error message, and exit. if (!MYSQLSUCCESS(rc)) { SQLCHAR SqlState[6]; SQLINTEGER NativeError; SQLSMALLINT MsgLen; SQLGetDiagRec(SQL_HANDLE_DBC, hdbc, 1, SqlState, &NativeError, (unsigned char *) szData, 2048, &MsgLen); SQLFreeEnv(henv); SQLFreeConnect(hdbc); fprintf(logFile, "! Error while connecting to database: %s\n", szData); errorstate = TRUE; return FALSE; } rc=SQLAllocStmt(hdbc,&hstmt); errorstate = FALSE; return TRUE; }
//************************************************************************* int main() { SQLHENV env; SQLHDBC dbc; SQLHSTMT stmt; SQLRETURN ret; SQLCHAR outstr[1024]; SQLSMALLINT outstrlen; // Aloocate an environment handle ret=SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&env); checkrc(ret,__LINE__); //we need odbc3 support SQLSetEnvAttr(env,SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3,0); //ALLOCATE A Connection handle ret = SQLAllocHandle(SQL_HANDLE_DBC,env,&dbc); checkrc(ret,__LINE__); // connect to the DSN data source ret = SQLConnect (dbc, (SQLCHAR *) "DSN=mycsql;MODE=ADAPTER;SERVER=127.0.0.1;PORT=5678;", (SQLSMALLINT) strlen ("test"), (SQLCHAR *) "root", (SQLSMALLINT) strlen ("root"), (SQLCHAR *) "manager", (SQLSMALLINT) strlen ("")); //SERVER=192.168.1.114;PORT=5678 if(SQL_SUCCEEDED(ret)) { printf("\nConnected to the Data Source successfully..\n"); } else { printf("error in connection\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); return 2; } ret = SQLDisconnect(dbc); checkrc(ret,__LINE__); printf("Disconnected from the Datasource\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); return 0; }
/************************************************************************* * * Function: sql_init_socket * * Purpose: Establish connection to the db * *************************************************************************/ static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) { rlm_sql_unixodbc_sock *unixodbc_sock; long err_handle; if (!handle->conn) { handle->conn = (rlm_sql_unixodbc_sock *)rad_malloc(sizeof(rlm_sql_unixodbc_sock)); if (!handle->conn) { return -1; } } unixodbc_sock = handle->conn; memset(unixodbc_sock, 0, sizeof(*unixodbc_sock)); /* 1. Allocate environment handle and register version */ err_handle = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&unixodbc_sock->env_handle); if (sql_state(err_handle, handle, config)) { radlog(L_ERR, "rlm_sql_unixodbc: Can't allocate environment handle\n"); return -1; } err_handle = SQLSetEnvAttr(unixodbc_sock->env_handle, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (sql_state(err_handle, handle, config)) { radlog(L_ERR, "rlm_sql_unixodbc: Can't register ODBC version\n"); SQLFreeHandle(SQL_HANDLE_ENV, unixodbc_sock->env_handle); return -1; } /* 2. Allocate connection handle */ err_handle = SQLAllocHandle(SQL_HANDLE_DBC, unixodbc_sock->env_handle, &unixodbc_sock->dbc_handle); if (sql_state(err_handle, handle, config)) { radlog(L_ERR, "rlm_sql_unixodbc: Can't allocate connection handle\n"); SQLFreeHandle(SQL_HANDLE_ENV, unixodbc_sock->env_handle); return -1; } /* 3. Connect to the datasource */ err_handle = SQLConnect(unixodbc_sock->dbc_handle, (SQLCHAR*) config->sql_server, strlen(config->sql_server), (SQLCHAR*) config->sql_login, strlen(config->sql_login), (SQLCHAR*) config->sql_password, strlen(config->sql_password)); if (sql_state(err_handle, handle, config)) { radlog(L_ERR, "rlm_sql_unixodbc: Connection failed\n"); SQLFreeHandle(SQL_HANDLE_DBC, unixodbc_sock->dbc_handle); SQLFreeHandle(SQL_HANDLE_ENV, unixodbc_sock->env_handle); return -1; } /* 4. Allocate the statement */ err_handle = SQLAllocStmt(unixodbc_sock->dbc_handle, &unixodbc_sock->stmt_handle); if (sql_state(err_handle, handle, config)) { radlog(L_ERR, "rlm_sql_unixodbc: Can't allocate the statement\n"); return -1; } return 0; }
/** \brief Connect to a database. * * This function attempts to connect to a database. * * If it is possible that the connection fails, make sure that you * try/catch this function call. * * \param[in] dsn The virtual name of the database to connect to * \param[in] login The login name of the person connecting * \param[in] passwd The password of the person connecting * * \exception odbcpp_error * If the connection fails, or an invalid name is specified, this * function will throw an odbcpp_error exception. */ void connection::connect(const std::string& dsn, const std::string& login, const std::string& passwd) { check(SQLConnect(f_handle, (SQLCHAR *) dsn.c_str(), static_cast<SQLSMALLINT>(dsn.length()), (SQLCHAR *) login.c_str(), static_cast<SQLSMALLINT>(login.length()), (SQLCHAR *) passwd.c_str(), static_cast<SQLSMALLINT>(passwd.length()))); f_connected = true; }
/************************************************************************* * * Function: sql_socket_init * * Purpose: Establish connection to the db * *************************************************************************/ static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config) { rlm_sql_unixodbc_conn_t *conn; long err_handle; MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_unixodbc_conn_t)); talloc_set_destructor((void *) conn, sql_socket_destructor); /* 1. Allocate environment handle and register version */ err_handle = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&conn->env); if (sql_state(err_handle, handle, config)) { ERROR("rlm_sql_unixodbc: Can't allocate environment handle\n"); return -1; } err_handle = SQLSetEnvAttr(conn->env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (sql_state(err_handle, handle, config)) { ERROR("rlm_sql_unixodbc: Can't register ODBC version\n"); SQLFreeHandle(SQL_HANDLE_ENV, conn->env); return -1; } /* 2. Allocate connection handle */ err_handle = SQLAllocHandle(SQL_HANDLE_DBC, conn->env, &conn->dbc); if (sql_state(err_handle, handle, config)) { ERROR("rlm_sql_unixodbc: Can't allocate connection handle\n"); SQLFreeHandle(SQL_HANDLE_ENV, conn->env); return -1; } /* 3. Connect to the datasource */ { SQLCHAR *odbc_server, *odbc_login, *odbc_password; memcpy(&odbc_server, &config->sql_server, sizeof(odbc_server)); memcpy(&odbc_login, &config->sql_login, sizeof(odbc_login)); memcpy(&odbc_password, &config->sql_password, sizeof(odbc_password)); err_handle = SQLConnect(conn->dbc, odbc_server, strlen(config->sql_server), odbc_login, strlen(config->sql_login), odbc_password, strlen(config->sql_password)); } if (sql_state(err_handle, handle, config)) { ERROR("rlm_sql_unixodbc: Connection failed\n"); SQLFreeHandle(SQL_HANDLE_DBC, conn->dbc); SQLFreeHandle(SQL_HANDLE_ENV, conn->env); return -1; } /* 4. Allocate the statement */ err_handle = SQLAllocStmt(conn->dbc, &conn->statement); if (sql_state(err_handle, handle, config)) { ERROR("rlm_sql_unixodbc: Can't allocate the statement\n"); return -1; } return 0; }
// 연결 핸들을 할당하고 연결한 후 명령핸들까지 같이 할당한다. // Type=1:ConStr은 MDB 파일의 경로를 가진다. 경로 생략시 현재 디렉토리에서 MDB를 찾는다. // Type=2:ConStr은 SQL 서버의 연결 정보를 가지는 DSN 파일의 경로를 가진다. // 경로는 반드시 완전 경로로 지정해야 한다. // Type=3:SQLConnect 함수로 DSN에 직접 연결한다. // 연결 또는 명령 핸들 할당에 실패하면 FALSE를 리턴한다. BOOL CQuery::Connect(int Type, char *ConStr, char *UID, char *PWD) { SQLCHAR InCon[255]; SQLCHAR OutCon[255]; SQLSMALLINT cbOutCon; int ii=1; SQLRETURN Ret; SQLINTEGER NativeError; SQLCHAR SqlState[6], Msg[255]; SQLSMALLINT MsgLen; char str[256]; m_Type = Type; strcpy(m_szConnect, ConStr); strcpy(m_Id, UID); strcpy(m_Pass, PWD); // 연결 타입에 따라 MDB 또는 SQL 서버, 또는 DSN에 연결한다. SQLAllocHandle(SQL_HANDLE_DBC,hEnv,&hDbc); switch (Type) { case 1: wsprintf((char *)InCon,"DRIVER={Microsoft Access Driver (*.mdb)};DBQ=%s;",ConStr); ret=SQLDriverConnect(hDbc,NULL,(SQLCHAR *)InCon,sizeof(InCon),OutCon, sizeof(OutCon),&cbOutCon, SQL_DRIVER_NOPROMPT); break; case 2: wsprintf((char *)InCon, "FileDsn=%s",ConStr); ret=SQLDriverConnect(hDbc,NULL,(SQLCHAR *)InCon,sizeof(InCon),OutCon, sizeof(OutCon),&cbOutCon, SQL_DRIVER_NOPROMPT); break; case 3: ret=SQLConnect(hDbc,(SQLCHAR *)ConStr,SQL_NTS,(SQLCHAR *)UID,SQL_NTS, (SQLCHAR *)PWD,SQL_NTS); break; } // 접속 에러시 진단 정보를 보여준다. if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) { while (Ret=SQLGetDiagRec(SQL_HANDLE_DBC, hDbc, ii, SqlState, &NativeError, Msg, sizeof(Msg), &MsgLen)!=SQL_NO_DATA) { wsprintf(str, "(1) SQLSTATE:%s, Diagnosis:%s",(LPCTSTR)SqlState,(LPCTSTR)Msg); //::MessageBox(NULL,str,"진단 정보",0); gWindow.PrintLog(str); ii++; } return FALSE; } // 명령 핸들을 할당한다. ret=SQLAllocHandle(SQL_HANDLE_STMT,hDbc,&hStmt); if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) { hStmt=0; return FALSE; } return TRUE; }
DatabaseODBC::DatabaseODBC() { m_connected = false; char* dns = new char[SQL_MAX_DSN_LENGTH]; char* user = new char[32]; char* pass = new char[32]; strcpy((char*)dns, g_config.getString(ConfigManager::SQL_DB).c_str()); strcpy((char*)user, g_config.getString(ConfigManager::SQL_USER).c_str()); strcpy((char*)pass, g_config.getString(ConfigManager::SQL_PASS).c_str()); SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_env); if(!RETURN_SUCCESS(ret)){ std::cout << "Failed to allocate ODBC SQLHENV enviroment handle." << std::endl; m_env = NULL; return; } ret = SQLSetEnvAttr(m_env, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0); if(!RETURN_SUCCESS(ret)){ std::cout << "SQLSetEnvAttr(SQL_ATTR_ODBC_VERSION): Failed to switch to ODBC 3 version." << std::endl; SQLFreeHandle(SQL_HANDLE_ENV, m_env); m_env = NULL; } if(m_env == NULL){ std::cout << "ODBC SQLHENV enviroment not initialized." << std::endl; return; } ret = SQLAllocHandle(SQL_HANDLE_DBC, m_env, &m_handle); if(!RETURN_SUCCESS(ret)){ std::cout << "Failed to allocate ODBC SQLHDBC connection handle." << std::endl; m_handle = NULL; return; } ret = SQLSetConnectAttr(m_handle, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER*)5, 0); if(!RETURN_SUCCESS(ret)){ std::cout << "SQLSetConnectAttr(SQL_ATTR_CONNECTION_TIMEOUT): Failed to set connection timeout." << std::endl; SQLFreeHandle(SQL_HANDLE_DBC, m_handle); m_handle = NULL; return; } ret = SQLConnect(m_handle, (SQLCHAR*)dns, SQL_NTS, (SQLCHAR*)user, SQL_NTS, (SQLCHAR*)pass, SQL_NTS); if(!RETURN_SUCCESS(ret)){ std::cout << "Failed to connect to ODBC via DSN: " << dns << " (user " << user << ")" << std::endl; SQLFreeHandle(SQL_HANDLE_DBC, m_handle); m_handle = NULL; return; } m_connected = true; }
bool OdbcOutput::InitOutput() { #if defined(_WIN32) // Create the environment handle. SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_odbcEnv); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { return false; } // Set the ODBC version. We will hardcode it as 3 for now. /// @todo Read ODBC version from the config file. ret = SQLSetEnvAttr( this->m_odbcEnv, SQL_ATTR_ODBC_VERSION, (this->m_odbcVersion == 3 ? (void*)SQL_OV_ODBC3 : (void*)SQL_OV_ODBC2), 0 ); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { return this->FreeHandles(); } // Allocate the connection handle. ret = SQLAllocHandle( SQL_HANDLE_DBC, m_odbcEnv, &m_odbcHdbc ); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { return this->FreeHandles(); } // Set connection timeout attribute. Hardcode for 7 seconds. /// @todo Read connection timeout from config. ret = SQLSetConnectAttr(this->m_odbcHdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)this->m_connectTimeout, 0); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { return this->FreeHandles(); } /// @todo replace the DB name and user ID, & authorisation string? from config? ret = SQLConnect( this->m_odbcHdbc, (SQLTCHAR*)this->m_dsn.c_str(), this->m_dsn.length(), (SQLTCHAR*)this->m_user.c_str(), this->m_user.length(), (SQLTCHAR*)this->m_authorisation.c_str(), this->m_authorisation.length() ); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { return this->FreeHandles(); } return true; #else return false; #endif }
static int odbc_init(void) { long int ODBC_err; short int ODBC_mlen; int ODBC_res; char ODBC_msg[200], ODBC_stat[10]; if (ODBC_env == SQL_NULL_HANDLE || connected == 0) { ODBC_res = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &ODBC_env); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error AllocHandle\n"); connected = 0; return -1; } ODBC_res = SQLSetEnvAttr(ODBC_env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error SetEnv\n"); SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env); connected = 0; return -1; } ODBC_res = SQLAllocHandle(SQL_HANDLE_DBC, ODBC_env, &ODBC_con); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error AllocHDB %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env); connected = 0; return -1; } SQLSetConnectAttr(ODBC_con, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)10, 0); } ODBC_res = SQLConnect(ODBC_con, (SQLCHAR*)dsn, SQL_NTS, (SQLCHAR*)username, SQL_NTS, (SQLCHAR*)password, SQL_NTS); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error SQLConnect %d\n", ODBC_res); SQLGetDiagRec(SQL_HANDLE_DBC, ODBC_con, 1, ODBC_stat, &ODBC_err, ODBC_msg, 100, &ODBC_mlen); SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env); connected = 0; return -1; } else { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Connected to %s\n", dsn); connected = 1; } return 0; }
static int odbc_init(void) { int ODBC_res; if (ODBC_env == SQL_NULL_HANDLE || connected == 0) { ODBC_res = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &ODBC_env); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error AllocHandle\n"); connected = 0; return -1; } ODBC_res = SQLSetEnvAttr(ODBC_env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error SetEnv\n"); SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env); connected = 0; return -1; } ODBC_res = SQLAllocHandle(SQL_HANDLE_DBC, ODBC_env, &ODBC_con); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error AllocHDB %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env); connected = 0; return -1; } SQLSetConnectAttr(ODBC_con, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)10, 0); } /* Note that the username and password could be NULL here, but that is allowed in ODBC. In this case, the default username and password will be used from odbc.conf */ ODBC_res = SQLConnect(ODBC_con, (SQLCHAR*)dsn, SQL_NTS, (SQLCHAR*)username, SQL_NTS, (SQLCHAR*)password, SQL_NTS); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error SQLConnect %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_DBC, ODBC_con); SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env); connected = 0; return -1; } else { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Connected to %s\n", dsn); connected = 1; } return 0; }
/* Connects to database */ static GSM_Error SMSDODBC_Connect(GSM_SMSDConfig * Config) { SQLRETURN ret; int field; char driver_name[1000]; SQLSMALLINT len; for (field = 0; field < SMSD_ODBC_MAX_RETURN_STRINGS; field++) { Config->conn.odbc.retstr[field] = NULL; } ret = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &Config->conn.odbc.env); if (!SQL_SUCCEEDED(ret)) { SMSDODBC_LogError(Config, ret, SQL_HANDLE_ENV, Config->conn.odbc.env, "SQLAllocHandle(ENV) failed"); return ERR_DB_DRIVER; } ret = SQLSetEnvAttr (Config->conn.odbc.env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (!SQL_SUCCEEDED(ret)) { SMSDODBC_LogError(Config, ret, SQL_HANDLE_ENV, Config->conn.odbc.env, "SQLSetEnvAttr failed"); return ERR_DB_CONFIG; } ret = SQLAllocHandle (SQL_HANDLE_DBC, Config->conn.odbc.env, &Config->conn.odbc.dbc); if (!SQL_SUCCEEDED(ret)) { SMSDODBC_LogError(Config, ret, SQL_HANDLE_ENV, Config->conn.odbc.env, "SQLAllocHandle(DBC) failed"); return ERR_DB_CONFIG; } ret = SQLConnect(Config->conn.odbc.dbc, (SQLCHAR*)Config->host, SQL_NTS, (SQLCHAR*)Config->user, SQL_NTS, (SQLCHAR*)Config->password, SQL_NTS); if (!SQL_SUCCEEDED(ret)) { SMSDODBC_LogError(Config, ret, SQL_HANDLE_DBC, Config->conn.odbc.dbc, "SQLConnect failed"); return ERR_DB_CONNECT; } ret = SQLGetInfo(Config->conn.odbc.dbc, SQL_DRIVER_NAME, driver_name, sizeof(driver_name), &len); if (!SQL_SUCCEEDED(ret)) { SMSDODBC_LogError(Config, ret, SQL_HANDLE_DBC, Config->conn.odbc.dbc, "SQLGetInfo failed"); return ERR_DB_CONNECT; } else{ SMSD_Log(DEBUG_NOTICE, Config, "Connected to driver %s", driver_name); } return ERR_NONE; }
Connection::Connection(const std::string &dsn, const std::string &userName, const std::string &password) : Env(new Environment) , ConnHldr(0) { std::auto_ptr<ConnectionHolder> NewConnHldr(new ConnectionHolder(*Env.get())); SQLRETURN Ret = SQLConnect(NewConnHldr->GetHandle(), const_cast<SQLCHAR *>(reinterpret_cast<const SQLTCHAR *>(dsn.c_str())), SQL_NTS, !userName.empty() ? const_cast<SQLCHAR *>(reinterpret_cast<const SQLCHAR *>(userName.c_str())) : 0, SQL_NTS, !password.empty() ? const_cast<SQLCHAR *>(reinterpret_cast<const SQLCHAR *>(password.c_str())) : 0, SQL_NTS); if (Ret != SQL_SUCCESS) throw ConnectionException(GetLastDBError(SQL_HANDLE_DBC, NewConnHldr->GetHandle()), ceErrorConnect); ConnHldr = NewConnHldr.release(); }
TF EXPFUNC p_db_connect(ENGid eid) { HDBC hdbc; char szDataSource[80]; char szUserID[40]; char szPassword[40]; if (pVAR != lsGetParmType(eid, 1)) { lsErrRaise(eid, "db_connect instantiation error: arg 1 must be var"); return FALSE; } g_lsRC = lsGetParm(eid, 2, cSTR, szDataSource); if (g_lsRC != OK) goto LS_ERROR; g_lsRC = lsGetParm(eid, 3, cSTR, szUserID); if (g_lsRC != OK) goto LS_ERROR; g_lsRC = lsGetParm(eid, 4, cSTR, szPassword); if (g_lsRC != OK) goto LS_ERROR; g_RC = SQLAllocConnect(g_hEnv, &hdbc); /* set up error handler */ g_hDBC = hdbc; g_hSTMT = SQL_NULL_HSTMT; g_eid = eid; ERROR_CHK("SQLAllocConnect"); // Added this line to get around erroneous messages: // S1010:[Microsoft][ODBC SQL Server Driver]Function sequence error // Fix from MS Knowledge Article 179226 // SQL_PRESERVE_CURSORS - note new name in actual call // This only applies to SQL Server, so hopefully, nothing bad will // happen if it fails. g_RC = SQLSetConnectOption(hdbc, SQL_COPT_SS_PRESERVE_CURSORS, NULL); g_RC = SQLConnect(hdbc, (UCHAR*)szDataSource, SQL_NTS, (UCHAR*)szUserID, SQL_NTS, (UCHAR*)szPassword, SQL_NTS); ERROR_CHK("SQLConnect"); lsUnifyParm(eid, 1, cADDR, &hdbc); return TRUE; LS_ERROR: return(lserror()); ODBC_ERROR: return FALSE; }
/* Open an ODBC connection to the database. */ int _connect_to_db(struct db_context_t *odbcc) { SQLRETURN rc; /* Allocate connection handles. */ pthread_mutex_lock(&db_source_mutex); rc = SQLAllocHandle(SQL_HANDLE_DBC, henv, &odbcc->hdbc); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_DBC, odbcc->hdbc); SQLFreeHandle(SQL_HANDLE_DBC, odbcc->hdbc); return ERROR; } /* Open connection to the database. */ rc = SQLConnect(odbcc->hdbc, servername, SQL_NTS, username, SQL_NTS, authentication, SQL_NTS); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_DBC, odbcc->hdbc); SQLFreeHandle(SQL_HANDLE_DBC, odbcc->hdbc); return ERROR; } rc = SQLSetConnectAttr(odbcc->hdbc, SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF, 0); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return ERROR; } rc = SQLSetConnectAttr(odbcc->hdbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER *) SQL_TXN_REPEATABLE_READ, 0); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return ERROR; } /* allocate statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, odbcc->hdbc, &odbcc->hstmt); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return ERROR; } pthread_mutex_unlock(&db_source_mutex); return OK; }
bool CQuery::Connect( _In_ char* szDBName, _In_ char* szLogin, _In_ char* szDBPass ) { SQLAllocHandle( SQL_HANDLE_ENV,SQL_NULL_HANDLE, &m_hEnv ); SQLSetEnvAttr( m_hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3_80, SQL_IS_INTEGER ); SQLAllocHandle( SQL_HANDLE_DBC, m_hEnv, &m_hDbc ); SQLSetConnectAttr(m_hDbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0); if(!SQL_SUCCEEDED( SQLConnect( m_hDbc, (SQLCHAR*)szDBName, SQL_NTS, (SQLCHAR*)szLogin, SQL_NTS, (SQLCHAR*)szDBPass, SQL_NTS ) )) { Log( Error, "Can't connect to database!!" ); throw exception(); } SQLAllocHandle( SQL_HANDLE_STMT, m_hDbc, &m_hStmt ); return true; }
static int sql_odbc_init(const char *host, const char *port, const char *socket, const char *name, const char *user, const char *pass) { /* Create environment. */ if(odbc_Result(SQLAllocEnv(&env)) && odbc_Result(SQLAllocConnect(env, &con))) { eventlog(eventlog_level_debug, __FUNCTION__, "Created ODBC environment."); } else { eventlog(eventlog_level_error, __FUNCTION__, "Unable to allocate ODBC environment."); return odbc_Fail(); } if(odbc_Result(SQLConnect(con, (SQLCHAR*)name, SQL_NTS, (SQLCHAR*)user, SQL_NTS, (SQLCHAR*)pass, SQL_NTS))) { eventlog(eventlog_level_debug, __FUNCTION__, "Connected to ODBC datasource \"%s\".", name); } else { eventlog(eventlog_level_error, __FUNCTION__, "Unable to connect to ODBC datasource \"%s\".", name); odbc_Error(SQL_HANDLE_DBC, con, eventlog_level_error, __FUNCTION__); return odbc_Fail(); } return 0; }
RETCODE ODBC_connect( /* Perform Driver Connection */ HENV henv, /* ODBC Environment Handle */ HDBC hdbc, /* ODBC Connection Handle */ UCHAR *driver, /* Data Source Name */ UCHAR *uid, /* User ID */ UCHAR *pwd) /* User Password */ { RETCODE rc; int retries; #if defined(TRACING) rc = SQLSetConnectOption (hdbc, SQL_OPT_TRACE, 1); if ((rc != SQL_SUCCESS) && (rc != SQL_SUCCESS_WITH_INFO)) return (rc); #endif /* ** try connecting up to 3 times */ printf("\nPlease wait . . .\n"); printf("Establishing a connection to '%s' . . .\n", driver); for (retries = 1; retries <= 3; retries++) { printf("Attempt connecting %d of 3 . . .\n", retries ); rc = SQLConnect (hdbc, driver, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS); if ((rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO)) { printf("Successfully, connected to '%s'.\n", driver); return (rc); } else { printf("Unable to establish a connection to '%s'.\n", driver); ODBC_getErrorInfo (henv, hdbc, SQL_NULL_HSTMT); if(retries < 3) printf("Retrying connect . . .\n"); } } /* ** Attempt to obtain a meaningful error as to why connect failed. */ printf("No connection could be established.\n"); ODBC_getErrorInfo(henv, hdbc, SQL_NULL_HSTMT); return (SQL_INVALID_HANDLE); }