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;
}
Esempio n. 2
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);
  }
}
Esempio n. 3
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;
}
Esempio n. 4
0
/*
** 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;
	}
}
Esempio n. 7
0
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;
}
Esempio n. 8
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;
	}
Esempio n. 9
0
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;
}
Esempio n. 10
0
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;
}
Esempio n. 11
0
/*************************************************************************
 *
 *	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;
}
Esempio n. 12
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;
}
Esempio n. 13
0
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;
}
Esempio n. 14
0
// 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;
}
Esempio n. 15
0
//*************************************************************************
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;
}         
Esempio n. 16
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;
}
Esempio n. 17
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;
}
Esempio n. 18
0
/*************************************************************************
 *
 *	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;
}
Esempio n. 19
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;
}
Esempio n. 20
0
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
}
Esempio n. 22
0
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;
}
Esempio n. 23
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;
}
Esempio n. 24
0
File: odbc.c Progetto: liyvhg/gammu
/* 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;
}
Esempio n. 25
0
 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();
 }
Esempio n. 26
0
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;
}
Esempio n. 27
0
/* 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;
}
Esempio n. 28
0
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;
}
Esempio n. 29
0
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;
}
Esempio n. 30
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);
}