开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
connection.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：35k
源码类别：

数据库系统

开发平台：

Unix_Linux

connection.c：源码内容
  2. /* Module:          connection.c
  3.  *
  4.  * Description:     This module contains routines related to 
  5.  *                  connecting to and disconnecting from the Postgres DBMS.
  6.  *
  7.  * Classes:         ConnectionClass (Functions prefix: "CC_")
  8.  *
  9.  * API functions:   SQLAllocConnect, SQLConnect, SQLDisconnect, SQLFreeConnect,
  10.  *                  SQLBrowseConnect(NI)
  11.  *
  12.  * Comments:        See "notice.txt" for copyright and license information.
  13.  *
  14.  */
  16. #include "environ.h"
  17. #include "connection.h"
  18. #include "socket.h"
  19. #include "statement.h"
  20. #include "qresult.h"
  21. #include "lobj.h"
  22. #include "dlg_specific.h"
  23. #include <stdio.h>
  24. #include <string.h>
  26. #ifdef WIN32
  27. #include <odbcinst.h>
  28. #endif
  30. #define STMT_INCREMENT 16  /* how many statement holders to allocate at a time */
  32. extern GLOBAL_VALUES globals;
  35. RETCODE SQL_API SQLAllocConnect(
  36.                                 HENV     henv,
  37.                                 HDBC FAR *phdbc)
  38. {
  39. EnvironmentClass *env = (EnvironmentClass *)henv;
  40. ConnectionClass *conn;
  41. static char *func="SQLAllocConnect";
  43. mylog( "%s: entering...n", func);
  45. conn = CC_Constructor();
  46. mylog("**** %s: henv = %u, conn = %un", func, henv, conn);
  48.     if( ! conn) {
  49.         env->errormsg = "Couldn't allocate memory for Connection object.";
  50.         env->errornumber = ENV_ALLOC_ERROR;
  51. *phdbc = SQL_NULL_HDBC;
  52. EN_log_error(func, "", env);
  53.         return SQL_ERROR;
  54.     }
  56.     if ( ! EN_add_connection(env, conn)) {
  57.         env->errormsg = "Maximum number of connections exceeded.";
  58.         env->errornumber = ENV_ALLOC_ERROR;
  59.         CC_Destructor(conn);
  60. *phdbc = SQL_NULL_HDBC;
  61. EN_log_error(func, "", env);
  62.         return SQL_ERROR;
  63.     }
  65. *phdbc = (HDBC) conn;
  67.     return SQL_SUCCESS;
  68. }
  71. //      -       -       -       -       -       -       -       -       -
  73. RETCODE SQL_API SQLConnect(
  74.                            HDBC      hdbc,
  75.                            UCHAR FAR *szDSN,
  76.                            SWORD     cbDSN,
  77.                            UCHAR FAR *szUID,
  78.                            SWORD     cbUID,
  79.                            UCHAR FAR *szAuthStr,
  80.                            SWORD     cbAuthStr)
  81. {
  82. ConnectionClass *conn = (ConnectionClass *) hdbc;
  83. ConnInfo *ci;
  84. static char *func = "SQLConnect";
  86. mylog( "%s: entering...n", func);
  88. if ( ! conn) {
  89. CC_log_error(func, "", NULL);
  90. return SQL_INVALID_HANDLE;
  91. }
  93. ci = &conn->connInfo;
  95. make_string(szDSN, cbDSN, ci->dsn);
  97. /* get the values for the DSN from the registry */
  98. getDSNinfo(ci, CONN_OVERWRITE);
  100. /* override values from DSN info with UID and authStr(pwd) 
  101. This only occurs if the values are actually there.
  102. */
  103. make_string(szUID, cbUID, ci->username);
  104. make_string(szAuthStr, cbAuthStr, ci->password);
  106. /* fill in any defaults */
  107. getDSNdefaults(ci);
  109. qlog("conn = %u, %s(DSN='%s', UID='%s', PWD='%s')n", conn, func, ci->dsn, ci->username, ci->password);
  111. if ( CC_connect(conn, FALSE) <= 0) {
  112. // Error messages are filled in
  113. CC_log_error(func, "Error on CC_connect", conn);
  114. return SQL_ERROR;
  115. }
  117. mylog( "%s: returning...n", func);
  119. return SQL_SUCCESS;
  120. }
  122. //      -       -       -       -       -       -       -       -       -
  124. RETCODE SQL_API SQLBrowseConnect(
  125.         HDBC      hdbc,
  126.         UCHAR FAR *szConnStrIn,
  127.         SWORD     cbConnStrIn,
  128.         UCHAR FAR *szConnStrOut,
  129.         SWORD     cbConnStrOutMax,
  130.         SWORD FAR *pcbConnStrOut)
  131. {
  132. static char *func="SQLBrowseConnect";
  134. mylog( "%s: entering...n", func);
  136. return SQL_SUCCESS;
  137. }
  139. //      -       -       -       -       -       -       -       -       -
  141. /* Drop any hstmts open on hdbc and disconnect from database */
  142. RETCODE SQL_API SQLDisconnect(
  143.         HDBC      hdbc)
  144. {
  145. ConnectionClass *conn = (ConnectionClass *) hdbc;
  146. static char *func = "SQLDisconnect";
  149. mylog( "%s: entering...n", func);
  151. if ( ! conn) {
  152. CC_log_error(func, "", NULL);
  153. return SQL_INVALID_HANDLE;
  154. }
  156. qlog("conn=%u, %sn", conn, func);
  158. if (conn->status == CONN_EXECUTING) {
  159. conn->errornumber = CONN_IN_USE;
  160. conn->errormsg = "A transaction is currently being executed";
  161. CC_log_error(func, "", conn);
  162. return SQL_ERROR;
  163. }
  165. mylog("%s: about to CC_cleanupn", func);
  167. /*  Close the connection and free statements */
  168. CC_cleanup(conn);
  170. mylog("%s: done CC_cleanupn", func);
  171. mylog("%s: returning...n", func);
  173. return SQL_SUCCESS;
  174. }
  177. //      -       -       -       -       -       -       -       -       -
  179. RETCODE SQL_API SQLFreeConnect(
  180.         HDBC      hdbc)
  181. {
  182. ConnectionClass *conn = (ConnectionClass *) hdbc;
  183. static char *func = "SQLFreeConnect";
  185. mylog( "%s: entering...n", func);
  186. mylog("**** in %s: hdbc=%un", func, hdbc);
  188. if ( ! conn) {
  189. CC_log_error(func, "", NULL);
  190. return SQL_INVALID_HANDLE;
  191. }
  193. /*  Remove the connection from the environment */
  194. if ( ! EN_remove_connection(conn->henv, conn)) {
  195. conn->errornumber = CONN_IN_USE;
  196. conn->errormsg = "A transaction is currently being executed";
  197. CC_log_error(func, "", conn);
  198. return SQL_ERROR;
  199. }
  201. CC_Destructor(conn);
  203. mylog("%s: returning...n", func);
  205. return SQL_SUCCESS;
  206. }
  209. /*
  210. *
  211. *       IMPLEMENTATION CONNECTION CLASS
  212. *
  213. */
  215. ConnectionClass *CC_Constructor()
  216. {
  217. ConnectionClass *rv;
  219.     rv = (ConnectionClass *)malloc(sizeof(ConnectionClass));
  221.     if (rv != NULL) {
  223. rv->henv = NULL; /* not yet associated with an environment */
  225.         rv->errormsg = NULL;
  226.         rv->errornumber = 0;
  227. rv->errormsg_created = FALSE;
  229.         rv->status = CONN_NOT_CONNECTED;
  230.         rv->transact_status = CONN_IN_AUTOCOMMIT; // autocommit by default
  232. memset(&rv->connInfo, 0, sizeof(ConnInfo));
  234. rv->sock = SOCK_Constructor();
  235. if ( ! rv->sock)
  236. return NULL;
  238. rv->stmts = (StatementClass **) malloc( sizeof(StatementClass *) * STMT_INCREMENT);
  239. if ( ! rv->stmts)
  240. return NULL;
  241. memset(rv->stmts, 0, sizeof(StatementClass *) * STMT_INCREMENT);
  243. rv->num_stmts = STMT_INCREMENT;
  245. rv->lobj_type = PG_TYPE_LO;
  247. rv->ntables = 0;
  248. rv->col_info = NULL;
  250. rv->translation_option = 0;
  251. rv->translation_handle = NULL;
  252. rv->DataSourceToDriver = NULL;
  253. rv->DriverToDataSource = NULL;
  256. /* Initialize statement options to defaults */
  257. /* Statements under this conn will inherit these options */
  259. InitializeStatementOptions(&rv->stmtOptions);
  262.     } 
  263.     return rv;
  264. }
  267. char
  268. CC_Destructor(ConnectionClass *self)
  269. {
  271. mylog("enter CC_Destructor, self=%un", self);
  273. if (self->status == CONN_EXECUTING)
  274. return 0;
  276. CC_cleanup(self);   /* cleanup socket and statements */
  278. mylog("after CC_Cleanupn");
  280. /*  Free up statement holders */
  281. if (self->stmts) {
  282. free(self->stmts);
  283. self->stmts = NULL;
  284. }
  285. mylog("after free statement holdersn");
  287. /* Free cached table info */
  288. if (self->col_info) {
  289. int i;
  290. for (i = 0; i < self->ntables; i++) {
  291. if (self->col_info[i]->result) /* Free the SQLColumns result structure */
  292. QR_Destructor(self->col_info[i]->result);
  294. free(self->col_info[i]);
  295. }
  296. free(self->col_info);
  297. }
  300. free(self);
  302. mylog("exit CC_Destructorn");
  304. return 1;
  305. }
  307. /* Return how many cursors are opened on this connection */
  308. int
  309. CC_cursor_count(ConnectionClass *self)
  310. {
  311. StatementClass *stmt;
  312. int i, count = 0;
  314. mylog("CC_cursor_count: self=%u, num_stmts=%dn", self, self->num_stmts);
  316. for (i = 0; i < self->num_stmts; i++) {
  317. stmt = self->stmts[i];
  318. if (stmt && stmt->result && stmt->result->cursor)
  319. count++;
  320. }
  322. mylog("CC_cursor_count: returning %dn", count);
  324. return count;
  325. }
  327. void 
  328. CC_clear_error(ConnectionClass *self)
  329. {
  330. self->errornumber = 0; 
  331. self->errormsg = NULL; 
  332. self->errormsg_created = FALSE;
  333. }
  335. // Used to cancel a transaction
  336. // We are almost always in the middle of a transaction.
  337. char
  338. CC_abort(ConnectionClass *self)
  339. {
  340. QResultClass *res;
  342. if ( CC_is_in_trans(self)) {
  343. res = NULL;
  345. mylog("CC_abort:  sending ABORT!n");
  347. res = CC_send_query(self, "ABORT", NULL);
  348. CC_set_no_trans(self);
  350. if (res != NULL)
  351. QR_Destructor(res);
  352. else
  353. return FALSE;
  355. }
  357. return TRUE;
  358. }
  360. /* This is called by SQLDisconnect also */
  361. char
  362. CC_cleanup(ConnectionClass *self)
  363. {
  364. int i;
  365. StatementClass *stmt;
  367. if (self->status == CONN_EXECUTING)
  368. return FALSE;
  370. mylog("in CC_Cleanup, self=%un", self);
  372. // Cancel an ongoing transaction
  373. // We are always in the middle of a transaction,
  374. // even if we are in auto commit.
  375. if (self->sock)
  376. CC_abort(self);
  378. mylog("after CC_abortn");
  380. /*  This actually closes the connection to the dbase */
  381. if (self->sock) {
  382.     SOCK_Destructor(self->sock);
  383. self->sock = NULL;
  384. }
  386. mylog("after SOCK destructorn");
  388. /*  Free all the stmts on this connection */
  389. for (i = 0; i < self->num_stmts; i++) {
  390. stmt = self->stmts[i];
  391. if (stmt) {
  393. stmt->hdbc = NULL; /* prevent any more dbase interactions */
  395. SC_Destructor(stmt);
  397. self->stmts[i] = NULL;
  398. }
  399. }
  401. /* Check for translation dll */
  402. #ifdef WIN32
  403. if ( self->translation_handle) {
  404. FreeLibrary (self->translation_handle);
  405. self->translation_handle = NULL;
  406. }
  407. #endif
  409. mylog("exit CC_Cleanupn");
  410. return TRUE;
  411. }
  413. int
  414. CC_set_translation (ConnectionClass *self)
  415. {
  417. #ifdef WIN32
  419. if (self->translation_handle != NULL) {
  420. FreeLibrary (self->translation_handle);
  421. self->translation_handle = NULL;
  422. }
  424. if (self->connInfo.translation_dll[0] == 0)
  425. return TRUE;
  427. self->translation_option = atoi (self->connInfo.translation_option);
  428. self->translation_handle = LoadLibrary (self->connInfo.translation_dll);
  430. if (self->translation_handle == NULL) {
  431. self->errornumber = CONN_UNABLE_TO_LOAD_DLL;
  432. self->errormsg = "Could not load the translation DLL.";
  433. return FALSE;
  434. }
  436. self->DataSourceToDriver
  437.  = (DataSourceToDriverProc) GetProcAddress (self->translation_handle,
  438. "SQLDataSourceToDriver");
  440. self->DriverToDataSource
  441.  = (DriverToDataSourceProc) GetProcAddress (self->translation_handle,
  442. "SQLDriverToDataSource");
  444. if (self->DataSourceToDriver == NULL || self->DriverToDataSource == NULL) {
  445. self->errornumber = CONN_UNABLE_TO_LOAD_DLL;
  446. self->errormsg = "Could not find translation DLL functions.";
  447. return FALSE;
  448. }
  449. #endif
  450. return TRUE;
  451. }
  453. char 
  454. CC_connect(ConnectionClass *self, char do_password)
  455. {
  456. StartupPacket sp;
  457. StartupPacket6_2 sp62;
  458. QResultClass *res;
  459. SocketClass *sock;
  460. ConnInfo *ci = &(self->connInfo);
  461. int areq = -1;
  462. int beresp;
  463. char msgbuffer[ERROR_MSG_LENGTH]; 
  464. char salt[2];
  465. static char *func="CC_connect";
  467. mylog("%s: entering...n", func);
  469. if ( do_password)
  471. sock = self->sock; /* already connected, just authenticate */
  473. else {
  475. qlog("Global Options: Version='%s', fetch=%d, socket=%d, unknown_sizes=%d, max_varchar_size=%d, max_longvarchar_size=%dn",
  476. POSTGRESDRIVERVERSION,
  477. globals.fetch_max, 
  478. globals.socket_buffersize, 
  479. globals.unknown_sizes, 
  480. globals.max_varchar_size, 
  481. globals.max_longvarchar_size);
  482. qlog("                disable_optimizer=%d, ksqo=%d, unique_index=%d, use_declarefetch=%dn",
  483. globals.disable_optimizer,
  484. globals.ksqo,
  485. globals.unique_index,
  486. globals.use_declarefetch);
  487. qlog("                text_as_longvarchar=%d, unknowns_as_longvarchar=%d, bools_as_char=%dn",
  488. globals.text_as_longvarchar, 
  489. globals.unknowns_as_longvarchar, 
  490. globals.bools_as_char);
  491. qlog("                extra_systable_prefixes='%s', conn_settings='%s'n",
  492. globals.extra_systable_prefixes, 
  493. globals.conn_settings);
  495. if (self->status != CONN_NOT_CONNECTED) {
  496. self->errormsg = "Already connected.";
  497. self->errornumber = CONN_OPENDB_ERROR;
  498. return 0;
  499. }
  501. if ( ci->server[0] == '' || ci->port[0] == '' || ci->database[0] == '') {
  502. self->errornumber = CONN_INIREAD_ERROR;
  503. self->errormsg = "Missing server name, port, or database name in call to CC_connect.";
  504. return 0;
  505. }
  507. mylog("CC_connect(): DSN = '%s', server = '%s', port = '%s', database = '%s', username = '%s', password='%s'n", ci->dsn, ci->server, ci->port, ci->database, ci->username, ci->password);
  509. /* If the socket was closed for some reason (like a SQLDisconnect, but no SQLFreeConnect
  510. then create a socket now.
  511. */
  512. if ( ! self->sock) {
  513. self->sock = SOCK_Constructor();
  514. if ( ! self->sock) {
  515.  self->errornumber = CONNECTION_SERVER_NOT_REACHED;
  516.  self->errormsg = "Could not open a socket to the server";
  517.  return 0;
  518. }
  519. }
  521. sock = self->sock;
  523. mylog("connecting to the server socket...n");
  525. SOCK_connect_to(sock, (short) atoi(ci->port), ci->server);
  526. if (SOCK_get_errcode(sock) != 0) {
  527. mylog("connection to the server socket failed.n");
  528. self->errornumber = CONNECTION_SERVER_NOT_REACHED;
  529. self->errormsg = "Could not connect to the server";
  530. return 0;
  531. }
  532. mylog("connection to the server socket succeeded.n");
  534. if ( PROTOCOL_62(ci)) {
  535. sock->reverse = TRUE; /* make put_int and get_int work for 6.2 */
  537. memset(&sp62, 0, sizeof(StartupPacket6_2));
  538. SOCK_put_int(sock, htonl(4+sizeof(StartupPacket6_2)), 4);
  539. sp62.authtype = htonl(NO_AUTHENTICATION);
  540. strncpy(sp62.database, ci->database, PATH_SIZE);
  541. strncpy(sp62.user, ci->username, NAMEDATALEN);
  542. SOCK_put_n_char(sock, (char *) &sp62, sizeof(StartupPacket6_2));
  543. SOCK_flush_output(sock);
  544. }
  545. else {
  546. memset(&sp, 0, sizeof(StartupPacket));
  548. mylog("sizeof startup packet = %dn", sizeof(StartupPacket));
  550. // Send length of Authentication Block
  551. SOCK_put_int(sock, 4+sizeof(StartupPacket), 4); 
  553. if ( PROTOCOL_63(ci))
  554. sp.protoVersion = (ProtocolVersion) htonl(PG_PROTOCOL_63);
  555. else
  556. sp.protoVersion = (ProtocolVersion) htonl(PG_PROTOCOL_LATEST);
  558. strncpy(sp.database, ci->database, SM_DATABASE);
  559. strncpy(sp.user, ci->username, SM_USER);
  561. SOCK_put_n_char(sock, (char *) &sp, sizeof(StartupPacket));
  562. SOCK_flush_output(sock);
  563. }
  565. mylog("sent the authentication block.n");
  567. if (sock->errornumber != 0) {
  568. mylog("couldn't send the authentication block properly.n");
  569. self->errornumber = CONN_INVALID_AUTHENTICATION;
  570. self->errormsg = "Sending the authentication packet failed";
  571. return 0;
  572. }
  573. mylog("sent the authentication block successfully.n");
  574. }
  577. mylog("gonna do authenticationn");
  580. // ***************************************************
  581. // Now get the authentication request from backend
  582. // ***************************************************
  584. if ( ! PROTOCOL_62(ci)) do {
  586. if (do_password)
  587. beresp = 'R';
  588. else
  589. beresp = SOCK_get_char(sock);
  591. switch(beresp) {
  592. case 'E':
  593. mylog("auth got 'E'n");
  595. SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
  596. self->errornumber = CONN_INVALID_AUTHENTICATION;
  597. self->errormsg = msgbuffer;
  598. qlog("ERROR from backend during authentication: '%s'n", self->errormsg);
  599. return 0;
  600. case 'R':
  602. if (do_password) {
  603. mylog("in 'R' do_passwordn");
  604. areq = AUTH_REQ_PASSWORD;
  605. do_password = FALSE;
  606. }
  607. else {
  608. mylog("auth got 'R'n");
  610. areq = SOCK_get_int(sock, 4);
  611. if (areq == AUTH_REQ_CRYPT)
  612. SOCK_get_n_char(sock, salt, 2);
  614. mylog("areq = %dn", areq);
  615. }
  616. switch(areq) {
  617. case AUTH_REQ_OK:
  618. break;
  620. case AUTH_REQ_KRB4:
  621. self->errormsg = "Kerberos 4 authentication not supported";
  622. self->errornumber = CONN_AUTH_TYPE_UNSUPPORTED;
  623. return 0;
  625. case AUTH_REQ_KRB5:
  626. self->errormsg = "Kerberos 5 authentication not supported";
  627. self->errornumber = CONN_AUTH_TYPE_UNSUPPORTED;
  628. return 0;
  630. case AUTH_REQ_PASSWORD:
  631. mylog("in AUTH_REQ_PASSWORDn");
  633. if (ci->password[0] == '') {
  634. self->errornumber = CONNECTION_NEED_PASSWORD;
  635. self->errormsg = "A password is required for this connection.";
  636. return -1; /* need password */
  637. }
  639. mylog("past need passwordn");
  641. SOCK_put_int(sock, 4+strlen(ci->password)+1, 4);
  642. SOCK_put_n_char(sock, ci->password, strlen(ci->password) + 1);
  643. SOCK_flush_output(sock);
  645. mylog("past flushn");
  646. break;
  648. case AUTH_REQ_CRYPT:
  649. self->errormsg = "Password crypt authentication not supported";
  650. self->errornumber = CONN_AUTH_TYPE_UNSUPPORTED;
  651. return 0;
  653. default:
  654. self->errormsg = "Unknown authentication type";
  655. self->errornumber = CONN_AUTH_TYPE_UNSUPPORTED;
  656. return 0;
  657. }
  658. break;
  659. default:
  660. self->errormsg = "Unexpected protocol character during authentication";
  661. self->errornumber = CONN_INVALID_AUTHENTICATION;
  662. return 0;
  663. }
  665. } while (areq != AUTH_REQ_OK);
  668. CC_clear_error(self); /* clear any password error */
  670. /* send an empty query in order to find out whether the specified */
  671. /* database really exists on the server machine */
  672. mylog("sending an empty query...n");
  674. res = CC_send_query(self, " ", NULL);
  675. if ( res == NULL || QR_get_status(res) != PGRES_EMPTY_QUERY) {
  676. mylog("got no result from the empty query.  (probably database does not exist)n");
  677. self->errornumber = CONNECTION_NO_SUCH_DATABASE;
  678. self->errormsg = "The database does not exist on the servernor user authentication failed.";
  679. if (res != NULL)
  680. QR_Destructor(res);
  681. return 0;
  682. }
  683. if (res)
  684. QR_Destructor(res);
  686. mylog("empty query seems to be OK.n");
  688. CC_set_translation (self);
  690. /**********************************************/
  691. /*******   Send any initial settings  *********/
  692. /**********************************************/
  694. /* Since these functions allocate statements, and since the connection is not
  695. established yet, it would violate odbc state transition rules.  Therefore,
  696. these functions call the corresponding local function instead.
  697. */
  698. CC_send_settings(self);
  699. CC_lookup_lo(self); /* a hack to get the oid of our large object oid type */
  701. CC_clear_error(self); /* clear any initial command errors */
  702. self->status = CONN_CONNECTED;
  704. mylog("%s: returning...n", func);
  706. return 1;
  708. }
  710. char
  711. CC_add_statement(ConnectionClass *self, StatementClass *stmt)
  712. {
  713. int i;
  715. mylog("CC_add_statement: self=%u, stmt=%un", self, stmt);
  717. for (i = 0; i < self->num_stmts; i++) {
  718. if ( ! self->stmts[i]) {
  719. stmt->hdbc = self;
  720. self->stmts[i] = stmt;
  721. return TRUE;
  722. }
  723. }
  725. /* no more room -- allocate more memory */
  726. self->stmts = (StatementClass **) realloc( self->stmts, sizeof(StatementClass *) * (STMT_INCREMENT + self->num_stmts));
  727. if ( ! self->stmts)
  728. return FALSE;
  730. memset(&self->stmts[self->num_stmts], 0, sizeof(StatementClass *) * STMT_INCREMENT);
  732. stmt->hdbc = self;
  733. self->stmts[self->num_stmts] = stmt;
  735. self->num_stmts += STMT_INCREMENT;
  737. return TRUE;
  738. }
  740. char 
  741. CC_remove_statement(ConnectionClass *self, StatementClass *stmt)
  742. {
  743. int i;
  745. for (i = 0; i < self->num_stmts; i++) {
  746. if (self->stmts[i] == stmt && stmt->status != STMT_EXECUTING) {
  747. self->stmts[i] = NULL;
  748. return TRUE;
  749. }
  750. }
  752. return FALSE;
  753. }
  755. /* Create a more informative error message by concatenating the connection
  756. error message with its socket error message.
  757. */
  758. char *
  759. CC_create_errormsg(ConnectionClass *self)
  760. {
  761. SocketClass *sock = self->sock;
  762. int pos;
  763. static char msg[4096];
  765. mylog("enter CC_create_errormsgn");
  767. msg[0] = '';
  769. if (self->errormsg)
  770. strcpy(msg, self->errormsg);
  772. mylog("msg = '%s'n", msg);
  774. if (sock && sock->errormsg && sock->errormsg[0] != '') {
  775. pos = strlen(msg);
  776. sprintf(&msg[pos], ";n%s", sock->errormsg);
  777. }
  779. mylog("exit CC_create_errormsgn");
  780. return msg;
  781. }
  784. char 
  785. CC_get_error(ConnectionClass *self, int *number, char **message)
  786. {
  787. int rv;
  789. mylog("enter CC_get_errorn");
  791. // Create a very informative errormsg if it hasn't been done yet.
  792. if ( ! self->errormsg_created) {
  793. self->errormsg = CC_create_errormsg(self);
  794. self->errormsg_created = TRUE;
  795. }
  797. if (self->errornumber) {
  798. *number = self->errornumber;
  799. *message = self->errormsg;
  800. }
  801. rv = (self->errornumber != 0);
  803. self->errornumber = 0; // clear the error
  805. mylog("exit CC_get_errorn");
  807. return rv;
  808. }
  811. /* The "result_in" is only used by QR_next_tuple() to fetch another group of rows into
  812. the same existing QResultClass (this occurs when the tuple cache is depleted and
  813. needs to be re-filled).
  815. The "cursor" is used by SQLExecute to associate a statement handle as the cursor name
  816. (i.e., C3326857) for SQL select statements.  This cursor is then used in future 
  817. 'declare cursor C3326857 for ...' and 'fetch 100 in C3326857' statements.
  818. */
  819. QResultClass *
  820. CC_send_query(ConnectionClass *self, char *query, QueryInfo *qi)
  821. {
  822. QResultClass *result_in, *res = NULL;
  823. char id, swallow;
  824. SocketClass *sock = self->sock;
  825. static char msgbuffer[MAX_MESSAGE_LEN+1];
  826. char cmdbuffer[MAX_MESSAGE_LEN+1]; // QR_set_command() dups this string so dont need static
  829. mylog("send_query(): conn=%u, query='%s'n", self, query);
  830. qlog("conn=%u, query='%s'n", self, query);
  832. // Indicate that we are sending a query to the backend
  833. if(strlen(query) > MAX_MESSAGE_LEN-2) {
  834. self->errornumber = CONNECTION_MSG_TOO_LONG;
  835. self->errormsg = "Query string is too long";
  836. return NULL;
  837. }
  839. if ((NULL == query) || (query[0] == ''))
  840. return NULL;
  842. if (SOCK_get_errcode(sock) != 0) {
  843. self->errornumber = CONNECTION_COULD_NOT_SEND;
  844. self->errormsg = "Could not send Query to backend";
  845. CC_set_no_trans(self);
  846. return NULL;
  847. }
  849. SOCK_put_char(sock, 'Q');
  850. if (SOCK_get_errcode(sock) != 0) {
  851. self->errornumber = CONNECTION_COULD_NOT_SEND;
  852. self->errormsg = "Could not send Query to backend";
  853. CC_set_no_trans(self);
  854. return NULL;
  855. }
  857. SOCK_put_string(sock, query);
  858. SOCK_flush_output(sock);
  860. if (SOCK_get_errcode(sock) != 0) {
  861. self->errornumber = CONNECTION_COULD_NOT_SEND;
  862. self->errormsg = "Could not send Query to backend";
  863. CC_set_no_trans(self);
  864. return NULL;
  865. }
  867. mylog("send_query: done sending queryn");
  869. while(1) {
  870. /* what type of message is coming now ? */
  871. id = SOCK_get_char(sock);
  873. if ((SOCK_get_errcode(sock) != 0) || (id == EOF)) {
  874. self->errornumber = CONNECTION_NO_RESPONSE;
  875. self->errormsg = "No response from the backend";
  876. if (res)
  877. QR_Destructor(res);
  879. mylog("send_query: 'id' - %sn", self->errormsg);
  880. CC_set_no_trans(self);
  881. return NULL;
  882. }
  884. mylog("send_query: got id = '%c'n", id);
  886. switch (id) {
  887. case 'A' : /* Asynchronous Messages are ignored */
  888. (void)SOCK_get_int(sock, 4); /* id of notification */
  889. SOCK_get_string(sock, msgbuffer, MAX_MESSAGE_LEN);
  890. /* name of the relation the message comes from */
  891. break;
  892. case 'C' : /* portal query command, no tuples returned */
  893. /* read in the return message from the backend */
  894. SOCK_get_string(sock, cmdbuffer, MAX_MESSAGE_LEN);
  895. if (SOCK_get_errcode(sock) != 0) {
  896. self->errornumber = CONNECTION_NO_RESPONSE;
  897. self->errormsg = "No response from backend while receiving a portal query command";
  898. mylog("send_query: 'C' - %sn", self->errormsg);
  899. CC_set_no_trans(self);
  900. return NULL;
  901. } else {
  903. char clear = 0;
  905. mylog("send_query: ok - 'C' - %sn", cmdbuffer);
  907. if (res == NULL) /* allow for "show" style notices */
  908. res = QR_Constructor();
  910. mylog("send_query: setting cmdbuffer = '%s'n", cmdbuffer);
  912. /* Only save the first command */
  913. QR_set_status(res, PGRES_COMMAND_OK);
  914. QR_set_command(res, cmdbuffer);
  916. /* (Quotation from the original comments)
  917. since backend may produce more than one result for some commands
  918. we need to poll until clear
  919. so we send an empty query, and keep reading out of the pipe
  920. until an 'I' is received
  921. */
  924. SOCK_put_string(sock, "Q ");
  925. SOCK_flush_output(sock);
  927. while( ! clear) {
  928. id = SOCK_get_char(sock);
  929. switch(id) {
  930. case 'I':
  931. (void) SOCK_get_char(sock);
  932. clear = TRUE;
  933. break;
  934. case 'Z':
  935. break;
  936. case 'C':
  937. SOCK_get_string(sock, cmdbuffer, ERROR_MSG_LENGTH);
  938. qlog("Command response: '%s'n", cmdbuffer);
  939. break;
  940. case 'N':
  941. SOCK_get_string(sock, cmdbuffer, ERROR_MSG_LENGTH);
  942. qlog("NOTICE from backend during clear: '%s'n", cmdbuffer);
  943. break;
  944. case 'E':
  945. SOCK_get_string(sock, cmdbuffer, ERROR_MSG_LENGTH);
  946. qlog("ERROR from backend during clear: '%s'n", cmdbuffer);
  947. break;
  948. }
  949. }
  951. mylog("send_query: returning res = %un", res);
  952. return res;
  953. }
  954. case 'K': /* Secret key (6.4 protocol) */
  955. (void)SOCK_get_int(sock, 4); /* pid */
  956. (void)SOCK_get_int(sock, 4); /* key */
  958. break;
  959. case 'Z': /* Backend is ready for new query (6.4) */
  960. break;
  961. case 'N' : /* NOTICE: */
  962. SOCK_get_string(sock, cmdbuffer, ERROR_MSG_LENGTH);
  964. res = QR_Constructor();
  965. QR_set_status(res, PGRES_NONFATAL_ERROR);
  966. QR_set_notice(res, cmdbuffer); /* will dup this string */
  968. mylog("~~~ NOTICE: '%s'n", cmdbuffer);
  969. qlog("NOTICE from backend during send_query: '%s'n", cmdbuffer);
  971. continue; // dont return a result -- continue reading
  973. case 'I' : /* The server sends an empty query */
  974. /* There is a closing '' following the 'I', so we eat it */
  975. swallow = SOCK_get_char(sock);
  976. if ((swallow != '') || SOCK_get_errcode(sock) != 0) {
  977. self->errornumber = CONNECTION_BACKEND_CRAZY;
  978. self->errormsg = "Unexpected protocol character from backend (send_query - I)";
  979. res = QR_Constructor();
  980. QR_set_status(res, PGRES_FATAL_ERROR);
  981. return res;
  982. } else {
  983. /* We return the empty query */
  984. res = QR_Constructor();
  985. QR_set_status(res, PGRES_EMPTY_QUERY);
  986. return res;
  987. }
  988. break;
  989. case 'E' : 
  990. SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
  992. /* Remove a newline */
  993. if (msgbuffer[0] != '' && msgbuffer[strlen(msgbuffer)-1] == 'n')
  994. msgbuffer[strlen(msgbuffer)-1] = '';
  996. self->errormsg = msgbuffer;
  998. mylog("send_query: 'E' - %sn", self->errormsg);
  999. qlog("ERROR from backend during send_query: '%s'n", self->errormsg);
  1001. if ( ! strncmp(self->errormsg, "FATAL", 5)) {
  1002. self->errornumber = CONNECTION_SERVER_REPORTED_ERROR;
  1003. CC_set_no_trans(self);
  1004. }
  1005. else
  1006. self->errornumber = CONNECTION_SERVER_REPORTED_WARNING;
  1008. return NULL;
  1010. case 'P' : /* get the Portal name */
  1011. SOCK_get_string(sock, msgbuffer, MAX_MESSAGE_LEN);
  1012. break;
  1013. case 'T': /* Tuple results start here */
  1014. result_in = qi ? qi->result_in : NULL;
  1016. if ( result_in == NULL) {
  1017. result_in = QR_Constructor();
  1018. mylog("send_query: 'T' no result_in: res = %un", result_in);
  1019. if ( ! result_in) {
  1020. self->errornumber = CONNECTION_COULD_NOT_RECEIVE;
  1021. self->errormsg = "Could not create result info in send_query.";
  1022. return NULL;
  1023. }
  1025. if (qi)
  1026. QR_set_cache_size(result_in, qi->row_size);
  1028. if ( ! QR_fetch_tuples(result_in, self, qi ? qi->cursor : NULL)) {
  1029. self->errornumber = CONNECTION_COULD_NOT_RECEIVE;
  1030. self->errormsg = QR_get_message(result_in);
  1031. return NULL;
  1032. }
  1033. }
  1034. else {  // next fetch, so reuse an existing result
  1035. if ( ! QR_fetch_tuples(result_in, NULL, NULL)) {
  1036. self->errornumber = CONNECTION_COULD_NOT_RECEIVE;
  1037. self->errormsg = QR_get_message(result_in);
  1038. return NULL;
  1039. }
  1040. }
  1042. return result_in;
  1043. case 'D': /* Copy in command began successfully */
  1044. res = QR_Constructor();
  1045. QR_set_status(res, PGRES_COPY_IN);
  1046. return res;
  1047. case 'B': /* Copy out command began successfully */
  1048. res = QR_Constructor();
  1049. QR_set_status(res, PGRES_COPY_OUT);
  1050. return res;
  1051. default:
  1052. self->errornumber = CONNECTION_BACKEND_CRAZY;
  1053. self->errormsg = "Unexpected protocol character from backend (send_query)";
  1054. CC_set_no_trans(self);
  1056. mylog("send_query: error - %sn", self->errormsg);
  1057. return NULL;
  1058. }
  1059. }
  1060. }
  1062. int
  1063. CC_send_function(ConnectionClass *self, int fnid, void *result_buf, int *actual_result_len, int result_is_int, LO_ARG *args, int nargs)
  1064. {
  1065. char id, c, done;
  1066. SocketClass *sock = self->sock;
  1067. static char msgbuffer[MAX_MESSAGE_LEN+1];
  1068. int i;
  1070. mylog("send_function(): conn=%u, fnid=%d, result_is_int=%d, nargs=%dn", self, fnid, result_is_int, nargs);
  1072. if (SOCK_get_errcode(sock) != 0) {
  1073. self->errornumber = CONNECTION_COULD_NOT_SEND;
  1074. self->errormsg = "Could not send function to backend";
  1075. CC_set_no_trans(self);
  1076. return FALSE;
  1077. }
  1079. SOCK_put_string(sock, "F ");
  1080. if (SOCK_get_errcode(sock) != 0) {
  1081. self->errornumber = CONNECTION_COULD_NOT_SEND;
  1082. self->errormsg = "Could not send function to backend";
  1083. CC_set_no_trans(self);
  1084. return FALSE;
  1085. }
  1087. SOCK_put_int(sock, fnid, 4); 
  1088. SOCK_put_int(sock, nargs, 4); 
  1091. mylog("send_function: done sending functionn");
  1093. for (i = 0; i < nargs; ++i) {
  1095. mylog("  arg[%d]: len = %d, isint = %d, integer = %d, ptr = %un", i, args[i].len, args[i].isint, args[i].u.integer, args[i].u.ptr);
  1097. SOCK_put_int(sock, args[i].len, 4);
  1098. if (args[i].isint) 
  1099. SOCK_put_int(sock, args[i].u.integer, 4);
  1100. else
  1101. SOCK_put_n_char(sock, (char *) args[i].u.ptr, args[i].len);
  1104. }
  1106. mylog("    done sending argsn");
  1108. SOCK_flush_output(sock);
  1109. mylog("  after flush outputn");
  1111. done = FALSE;
  1112. while ( ! done) {
  1113. id = SOCK_get_char(sock);
  1114. mylog("   got id = %cn", id);
  1116. switch(id) {
  1117. case 'V':
  1118. done = TRUE;
  1119. break; /* ok */
  1121. case 'N':
  1122. SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
  1123. mylog("send_function(V): 'N' - %sn", msgbuffer);
  1124. /* continue reading */
  1125. break;
  1127. case 'E':
  1128. SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
  1129. self->errormsg = msgbuffer;
  1131. mylog("send_function(V): 'E' - %sn", self->errormsg);
  1132. qlog("ERROR from backend during send_function: '%s'n", self->errormsg);
  1134. return FALSE;
  1136. case 'Z':
  1137. break;
  1139. default:
  1140. self->errornumber = CONNECTION_BACKEND_CRAZY;
  1141. self->errormsg = "Unexpected protocol character from backend (send_function, args)";
  1142. CC_set_no_trans(self);
  1144. mylog("send_function: error - %sn", self->errormsg);
  1145. return FALSE;
  1146. }
  1147. }
  1149. id = SOCK_get_char(sock);
  1150. for (;;) {
  1151. switch (id) {
  1152. case 'G': /* function returned properly */
  1153. mylog("  got G!n");
  1155. *actual_result_len = SOCK_get_int(sock, 4);
  1156. mylog("  actual_result_len = %dn", *actual_result_len);
  1158. if (result_is_int)
  1159. *((int *) result_buf) = SOCK_get_int(sock, 4);
  1160. else
  1161. SOCK_get_n_char(sock, (char *) result_buf, *actual_result_len);
  1163. mylog("  after get resultn");
  1165. c = SOCK_get_char(sock); /* get the last '0' */
  1167. mylog("   after get 0n");
  1169. return TRUE;
  1171. case 'E':
  1172. SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
  1173. self->errormsg = msgbuffer;
  1175. mylog("send_function(G): 'E' - %sn", self->errormsg);
  1176. qlog("ERROR from backend during send_function: '%s'n", self->errormsg);
  1178. return FALSE;
  1180. case 'N':
  1181. SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
  1183. mylog("send_function(G): 'N' - %sn", msgbuffer);
  1184. qlog("NOTICE from backend during send_function: '%s'n", msgbuffer);
  1186. continue; // dont return a result -- continue reading
  1188. case '0': /* empty result */
  1189. return TRUE;
  1191. default:
  1192. self->errornumber = CONNECTION_BACKEND_CRAZY;
  1193. self->errormsg = "Unexpected protocol character from backend (send_function, result)";
  1194. CC_set_no_trans(self);
  1196. mylog("send_function: error - %sn", self->errormsg);
  1197. return FALSE;
  1198. }
  1199. }
  1200. }
  1203. char
  1204. CC_send_settings(ConnectionClass *self)
  1205. {
  1206. // char ini_query[MAX_MESSAGE_LEN];
  1207. ConnInfo *ci = &(self->connInfo);
  1208. // QResultClass *res;
  1209. HSTMT hstmt;
  1210. StatementClass *stmt;
  1211. RETCODE result;
  1212. char status = TRUE;
  1213. char *cs, *ptr;
  1214. static char *func="CC_send_settings";
  1217. mylog("%s: entering...n", func);
  1219. /* This function must use the local odbc API functions since the odbc state 
  1220. has not transitioned to "connected" yet.
  1221. */
  1223. result = SQLAllocStmt( self, &hstmt);
  1224. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1225. return FALSE;
  1226. }
  1227. stmt = (StatementClass *) hstmt;
  1229. stmt->internal = TRUE; /* ensure no BEGIN/COMMIT/ABORT stuff */
  1231. /* Set the Datestyle to the format the driver expects it to be in */
  1232. result = SQLExecDirect(hstmt, "set DateStyle to 'ISO'", SQL_NTS);
  1233. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
  1234. status = FALSE;
  1236. mylog("%s: result %d, status %d from set DateStylen", func, result, status);
  1238. /* Disable genetic optimizer based on global flag */
  1239. if (globals.disable_optimizer) {
  1240. result = SQLExecDirect(hstmt, "set geqo to 'OFF'", SQL_NTS);
  1241. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
  1242. status = FALSE;
  1244. mylog("%s: result %d, status %d from set geqon", func, result, status);
  1246. }
  1248. /* KSQO */
  1249. if (globals.ksqo) {
  1250. result = SQLExecDirect(hstmt, "set ksqo to 'ON'", SQL_NTS);
  1251. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
  1252. status = FALSE;
  1254. mylog("%s: result %d, status %d from set ksqon", func, result, status);
  1256. }
  1258. /* Global settings */
  1259. if (globals.conn_settings[0] != '') {
  1260. cs = strdup(globals.conn_settings);
  1261. ptr = strtok(cs, ";");
  1262. while (ptr) {
  1263. result = SQLExecDirect(hstmt, ptr, SQL_NTS);
  1264. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
  1265. status = FALSE;
  1267. mylog("%s: result %d, status %d from '%s'n", func, result, status, ptr);
  1269. ptr = strtok(NULL, ";");
  1270. }
  1272. free(cs);
  1273. }
  1275. /* Per Datasource settings */
  1276. if (ci->conn_settings[0] != '') {
  1277. cs = strdup(ci->conn_settings);
  1278. ptr = strtok(cs, ";");
  1279. while (ptr) {
  1280. result = SQLExecDirect(hstmt, ptr, SQL_NTS);
  1281. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
  1282. status = FALSE;
  1284. mylog("%s: result %d, status %d from '%s'n", func, result, status, ptr);
  1286. ptr = strtok(NULL, ";");
  1287. }
  1289. free(cs);
  1290. }
  1293. SQLFreeStmt(hstmt, SQL_DROP);
  1295. return status;
  1296. }
  1298. /* This function is just a hack to get the oid of our Large Object oid type.
  1299. If a real Large Object oid type is made part of Postgres, this function
  1300. will go away and the define 'PG_TYPE_LO' will be updated.
  1301. */
  1302. void
  1303. CC_lookup_lo(ConnectionClass *self) 
  1304. {
  1305. HSTMT hstmt;
  1306. StatementClass *stmt;
  1307. RETCODE result;
  1308. static char *func = "CC_lookup_lo";
  1310. mylog( "%s: entering...n", func);
  1312. /* This function must use the local odbc API functions since the odbc state 
  1313. has not transitioned to "connected" yet.
  1314. */
  1315. result = SQLAllocStmt( self, &hstmt);
  1316. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1317. return;
  1318. }
  1319. stmt = (StatementClass *) hstmt;
  1321. result = SQLExecDirect(hstmt, "select oid from pg_type where typname='" PG_TYPE_LO_NAME "'", SQL_NTS);
  1322. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1323. SQLFreeStmt(hstmt, SQL_DROP);
  1324. return;
  1325. }
  1327. result = SQLFetch(hstmt);
  1328. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1329. SQLFreeStmt(hstmt, SQL_DROP);
  1330. return;
  1331. }
  1333. result = SQLGetData(hstmt, 1, SQL_C_SLONG, &self->lobj_type, sizeof(self->lobj_type), NULL);
  1334. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1335. SQLFreeStmt(hstmt, SQL_DROP);
  1336. return;
  1337. }
  1339. mylog("Got the large object oid: %dn", self->lobj_type);
  1340. qlog("    [ Large Object oid = %d ]n", self->lobj_type);
  1342. result = SQLFreeStmt(hstmt, SQL_DROP);
  1343. }
  1345. void
  1346. CC_log_error(char *func, char *desc, ConnectionClass *self)
  1347. {
  1348. if (self) {
  1349. qlog("CONN ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'n", func, desc, self->errornumber, self->errormsg);
  1350. mylog("CONN ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'n", func, desc, self->errornumber, self->errormsg);
  1351. qlog("            ------------------------------------------------------------n");
  1352. qlog("            henv=%u, conn=%u, status=%u, num_stmts=%dn", self->henv, self, self->status, self->num_stmts);
  1353. qlog("            sock=%u, stmts=%u, lobj_type=%dn", self->sock, self->stmts, self->lobj_type);
  1355. qlog("            ---------------- Socket Info -------------------------------n");
  1356. if (self->sock) {
  1357. SocketClass *sock = self->sock;
  1358. qlog("            socket=%d, reverse=%d, errornumber=%d, errormsg='%s'n", sock->socket, sock->reverse, sock->errornumber, sock->errormsg);
  1359. qlog("            buffer_in=%u, buffer_out=%un", sock->buffer_in, sock->buffer_out);
  1360. qlog("            buffer_filled_in=%d, buffer_filled_out=%d, buffer_read_in=%dn", sock->buffer_filled_in, sock->buffer_filled_out, sock->buffer_read_in);
  1361. }
  1362. }
  1363. else
  1364. qlog("INVALID CONNECTION HANDLE ERROR: func=%s, desc='%s'n", func, desc);
  1365. }