dlodbc.cpp

用于处理证书请求,生成证书的CA服务器源码,

/*
 * Date         : Jan 31, 2001
 * Copyright    : Diginfo Technology Co.
 * Author       : Junhui Yang
 * File         : DLodbc.cpp
 * Description  : Class for DTCLink in DTCLink server
 */

#include "DLodbc.h"

static SQLHENV environment = NULL; //  The environment handle.

int IniEven() {
	if (environment == NULL) {
		SQLRETURN re;
		re = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&environment);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
		    // Set environment odbc version;
	     	SQLPOINTER ver = (void*)SQL_OV_ODBC3;
	      	re = SQLSetEnvAttr(environment,SQL_ATTR_ODBC_VERSION,ver,0);
		    if (re != SQL_SUCCESS && re != SQL_SUCCESS_WITH_INFO) {
				environment = NULL;
				return -1;
			}
		} else {
			environment = NULL;
			return -1;
		}
	}
	return 1;
}
SQLHDBC ConnectDB(unsigned char* DBname,int len1,unsigned char* Username,int len2,unsigned char* Password,int len3) {
    int n = IniEven();
    if (n == -1) return NULL;

	SQLHDBC hdbc;
    SQLRETURN retcode = SQLAllocHandle(SQL_HANDLE_DBC, environment, &hdbc); 
    if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
        retcode = SQLConnect(hdbc, (SQLCHAR*) DBname, len1,
                  (SQLCHAR*) Username, len2,
                  (SQLCHAR*) Password, len3);


         if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO){
			 return NULL;
		 }
	} else {
		return NULL;
	}

	return hdbc;
}

SQLHSTMT CreateStatement(SQLHDBC connection,long rs_type,long rs_concur) {

		SQLHSTMT statement;
		SQLRETURN re=0;

		try {
	    	re = SQLAllocHandle(SQL_HANDLE_STMT,connection,&statement);

			/*
	    	// Set statement parameter;
	    	if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
		        SQLPOINTER	 curscr,cursen,concur;
	    	    switch (rs_type) {
			        case 1003L: curscr = (void*)SQL_NONSCROLLABLE;
	                            cursen = (void*)SQL_UNSPECIFIED;
				                break;
			        case 1004L: curscr = (void*)SQL_SCROLLABLE;
				                cursen = (void*)SQL_INSENSITIVE;
				                break;
			        case 1005L: curscr = (void*)SQL_SCROLLABLE;
				                cursen = (void*)SQL_SENSITIVE;
				                break;
			        default:    break;
				}

	        	switch (rs_concur) {
		    	    case 1007L:	concur = (void*)SQL_CONCUR_READ_ONLY;
				                break;
			        case 1008L: concur = (void*)SQL_CONCUR_VALUES;
				                break;
		        	default:    break;
				}

	        	re=SQLSetStmtAttr (statement,SQL_ATTR_CURSOR_SCROLLABLE,curscr,0);
                if (re != SQL_SUCCESS && re != SQL_SUCCESS_WITH_INFO) {
                    SQLCHAR sql[255];
                    SQLINTEGER err;
                    SQLCHAR mes[255];
			        memset (mes, '\0', 10);
			        memset (sql, '\0', 10);
			        SQLSMALLINT len;
			        SQLGetDiagRec(SQL_HANDLE_STMT, statement, 1, sql, &err, mes, 255, &len);

			    
					return NULL;
				}

	        	re=SQLSetStmtAttr (statement,SQL_ATTR_CURSOR_SENSITIVITY,cursen,0);
                if (re != SQL_SUCCESS && re != SQL_SUCCESS_WITH_INFO) {
                    SQLCHAR sql[255];
                    SQLINTEGER err;
                    SQLCHAR mes[255];
			        memset (mes, '\0', 10);
			        memset (sql, '\0', 10);
			        SQLSMALLINT len;
			        SQLGetDiagRec(SQL_HANDLE_STMT, statement, 1, sql, &err, mes, 255, &len);


					return NULL;
				}

	        	re=SQLSetStmtAttr (statement,SQL_ATTR_CONCURRENCY,concur,0);
                if (re != SQL_SUCCESS && re != SQL_SUCCESS_WITH_INFO) {
                    SQLCHAR sql[255];
                    SQLINTEGER err;
                    SQLCHAR mes[255];
			        memset (mes, '\0', 10);
			        memset (sql, '\0', 10);
			        SQLSMALLINT len;
			        SQLGetDiagRec(SQL_HANDLE_STMT, statement, 1, sql, &err, mes, 255, &len);


					return NULL;
				}

			} else {
		    	return NULL;
				
			}
			*/
		} catch (...) {
			printf ("Handle Error!!!");
			return NULL;
		}

		return statement;

	}

void free_connect_handle(SQLHDBC handle) {
	try {
		SQLRETURN re;

		re = SQLDisconnect(handle);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
            SQLFreeHandle(SQL_HANDLE_ENV, handle);
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, handle, 1, sql, &err, mes, 255, &len);


		}
	} catch (...) {
	}
}

void getCatalog(SQLHDBC handle, char cata[], SQLINTEGER slen, SQLINTEGER &len) {
	try {
		SQLINTEGER attr = SQL_ATTR_CURRENT_CATALOG;
		SQLRETURN re;

		re = SQLGetConnectAttr(handle,attr,cata,slen,&len);
		if (re != SQL_SUCCESS && re != SQL_SUCCESS_WITH_INFO) {
            memset(cata, '\0', slen);

            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, handle, 1, sql, &err, mes, 255, &len);


		}        
	} catch (...) {
        memset(cata, '\0', slen);
	}
}

SQLUINTEGER geTsolation(SQLHDBC connection) {
	SQLRETURN re;	
	SQLINTEGER attr = SQL_ATTR_TXN_ISOLATION;
	SQLINTEGER strlen;
	SQLUINTEGER value = 0;
	try {
		re = SQLGetConnectAttr(connection,attr,(void*)(&value),0,&strlen);
		if (re != SQL_SUCCESS && re != SQL_SUCCESS_WITH_INFO) {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, connection, 1, sql, &err, mes, 255, &len);


			return 0;
		}
	} catch (...) {
		value = 0;
	}
	return value;
}


int isReadOnly(SQLHDBC connect) {

	SQLINTEGER attr = SQL_ATTR_ACCESS_MODE;
	SQLINTEGER strlen;
	SQLUINTEGER value = 0;
	SQLRETURN re;

	try {
		re = SQLGetConnectAttr(connect,attr,(void*)(&value),0,&strlen);
        if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
            return value;
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, connect, 1, sql, &err, mes, 255, &len);


		}
	} catch (...) {
	}
	return 0;
}

int setCatalog(SQLHDBC connection, char name[], int len) {
	try {
		SQLINTEGER attr = SQL_ATTR_CURRENT_CATALOG;
		SQLRETURN re;
		re = SQLSetConnectAttr(connection,attr,name,len);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
	    	return 0;  
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, connection, 1, sql, &err, mes, 255, &len);

		}
	} catch (...) {
	}
	return -1;
}

int setReadOnly(SQLHDBC connect, char r) {

	SQLINTEGER attr = SQL_ATTR_ACCESS_MODE;
	SQLRETURN re;
	try {
		if (r == 0) re = SQLSetConnectAttr(connect,attr,(void*)SQL_AUTOCOMMIT_OFF,0);
    		else re = SQLSetConnectAttr(connect,attr,(void*)SQL_AUTOCOMMIT_ON,0);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
	    	return 0;  
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, connect, 1, sql, &err, mes, 255, &len);


		}
	} catch (...) {
	}
	return -1;
}

int seTsolation(SQLHDBC connection, SQLUINTEGER value) {

	SQLRETURN re;	
	SQLINTEGER attr = SQL_ATTR_TXN_ISOLATION;
	try {
		re = SQLSetConnectAttr(connection,attr,(void*)(value),0);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
	    	return 0;  
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, connection, 1, sql, &err, mes, 255, &len);


		}
	} catch (...) {
	}
	return -1;
}

int GetBatchSupported(SQLHDBC connection) {

	SQLRETURN re;
	SQLUSMALLINT type = SQL_BATCH_SUPPORT;
	SQLUINTEGER value = -1;
	SQLSMALLINT str_len;
	try{
		re = SQLGetInfo(connection,type,(void*)(&value),0,&str_len);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
	    	return value;  
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, connection, 1, sql, &err, mes, 255, &len);

		}
	} catch (...) {
	}
	return -1;
}

int FreeStatement(SQLHSTMT statement) {

	SQLRETURN re;
	try{
		re = SQLFreeHandle(SQL_HANDLE_STMT,statement);
		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO) {
			//printf("ok");
	    	return 1;  
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);
			SQLSMALLINT len;
			SQLGetDiagRec(SQL_HANDLE_STMT, statement, 1, sql, &err, mes, 255, &len);


		}
	} catch (...) {
	}
	return -1;
}

int ExecSQL(SQLHSTMT statement,SQLCHAR sql[],SQLINTEGER len) {

	SQLRETURN re;
	try {
		re = SQLExecDirect(statement,sql,len);

		if (re == SQL_SUCCESS || re == SQL_SUCCESS_WITH_INFO || re == SQL_NO_DATA
			|| re == SQL_STILL_EXECUTING) {
	    	return 1;  
		} else {
            SQLCHAR sql[255];
            SQLINTEGER err;
            SQLCHAR mes[255];
			memset (mes, '\0', 10);
			memset (sql, '\0', 10);