Check for out of memory when allocating sqlca.

Patch by Michael Paquier

Conflicts:
	src/interfaces/ecpg/ecpglib/connect.c

diff --git a/src/interfaces/ecpg/compatlib/informix.c b/src/interfaces/ecpg/compatlib/informix.c
index 730c7913cd1c9ae8cd70f88d8e0f9d464c13ea9b..3176178441a1a722070c86dd17297cdd9e77c1cf 100644 (file)
--- a/src/interfaces/ecpg/compatlib/informix.c
+++ b/src/interfaces/ecpg/compatlib/informix.c
@@ -1024,6 +1024,8 @@ void
 ECPG_informix_reset_sqlca(void)
 {
        struct sqlca_t *sqlca = ECPGget_sqlca();
+       if (sqlca == NULL)
+               return;
 
        memcpy((char *) sqlca, (char *) &sqlca_init, sizeof(struct sqlca_t));
 }

diff --git a/src/interfaces/ecpg/ecpglib/connect.c b/src/interfaces/ecpg/ecpglib/connect.c
index f008bbd4fe4225568c9a3a9f59bd8b8f1f31548b..760db3421c1dd158ae6eff591408431227f59f08 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/connect.c
+++ b/src/interfaces/ecpg/ecpglib/connect.c
@@ -219,6 +219,14 @@ ECPGnoticeReceiver(void *arg, const PGresult *result)
 
        int                     sqlcode;
 
+       if (sqlca == NULL)
+       {
+               ecpg_log("out of memory");
+               return;
+       }
+
+       (void) arg;                                     /* keep the compiler quiet */
+       
        if (sqlstate == NULL)
                sqlstate = ECPG_SQLSTATE_ECPG_INTERNAL_ERROR;
 
@@ -279,6 +287,14 @@ ECPGconnect(int lineno, int c, const char *name, const char *user, const char *p
                           *options = NULL,
                           *connect_string = NULL;
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               ecpg_free(dbname);
+               return false;
+       }
+
        ecpg_init_sqlca(sqlca);
 
        /*
@@ -559,6 +575,13 @@ ECPGdisconnect(int lineno, const char *connection_name)
        struct sqlca_t *sqlca = ECPGget_sqlca();
        struct connection *con;
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return (false);
+       }
+
 #ifdef ENABLE_THREAD_SAFETY
        pthread_mutex_lock(&connections_mutex);
 #endif

diff --git a/src/interfaces/ecpg/ecpglib/data.c b/src/interfaces/ecpg/ecpglib/data.c
index 18a4e5b0962cae4d7b6609c25b3370c153988c19..2f4231db15d311bfc2c387cdcd90d32811393c7e 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/data.c
+++ b/src/interfaces/ecpg/ecpglib/data.c
@@ -132,6 +132,13 @@ ecpg_get_data(const PGresult *results, int act_tuple, int act_field, int lineno,
        int                     value_for_indicator = 0;
        long            log_offset;
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return (false);
+       }
+
        /*
         * If we are running in a regression test, do not log the offset variable,
         * it depends on the machine's alignment.

diff --git a/src/interfaces/ecpg/ecpglib/descriptor.c b/src/interfaces/ecpg/ecpglib/descriptor.c
index cebc8b67fa0c972b6f059359e30f73ab7d089822..542ca427328fcbd5e4c6cedf67f9f4970a72e81d 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/descriptor.c
+++ b/src/interfaces/ecpg/ecpglib/descriptor.c
@@ -93,6 +93,13 @@ ECPGget_desc_header(int lineno, const char *desc_name, int *count)
        PGresult   *ECPGresult;
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return false;
+       }
+
        ecpg_init_sqlca(sqlca);
        ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
        if (!ECPGresult)
@@ -244,6 +251,13 @@ ECPGget_desc(int lineno, const char *desc_name, int index,...)
        struct variable data_var;
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return false;
+       }
+
        va_start(args, index);
        ecpg_init_sqlca(sqlca);
        ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
@@ -649,6 +663,13 @@ ECPGdeallocate_desc(int line, const char *name)
        struct descriptor *prev;
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(line, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return false;
+       }
+
        ecpg_init_sqlca(sqlca);
        for (desc = get_descriptors(), prev = NULL; desc; prev = desc, desc = desc->next)
        {
@@ -688,6 +709,13 @@ ECPGallocate_desc(int line, const char *name)
        struct descriptor *new;
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(line, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return false;
+       }
+
        ecpg_init_sqlca(sqlca);
        new = (struct descriptor *) ecpg_alloc(sizeof(struct descriptor), line);
        if (!new)

diff --git a/src/interfaces/ecpg/ecpglib/error.c b/src/interfaces/ecpg/ecpglib/error.c
index a8f3b051ff5882b519bb60bec14965c71a8e2df0..8e4f2108ebfdd87b73a5f2f8918a1307cbd03d2c 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/error.c
+++ b/src/interfaces/ecpg/ecpglib/error.c
@@ -14,6 +14,13 @@ ecpg_raise(int line, int code, const char *sqlstate, const char *str)
 {
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_log("out of memory");
+               ECPGfree_auto_mem();
+               return;
+       }
+
        sqlca->sqlcode = code;
        strncpy(sqlca->sqlstate, sqlstate, sizeof(sqlca->sqlstate));
 
@@ -293,6 +300,13 @@ ecpg_raise_backend(int line, PGresult *result, PGconn *conn, int compat)
        char       *sqlstate;
        char       *message;
 
+       if (sqlca == NULL)
+       {
+               ecpg_log("out of memory");
+               ECPGfree_auto_mem();
+               return;
+       }
+
        if (result)
        {
                sqlstate = PQresultErrorField(result, PG_DIAG_SQLSTATE);
@@ -401,6 +415,12 @@ sqlprint(void)
 {
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_log("out of memory");
+               return;
+       }
+
        sqlca->sqlerrm.sqlerrmc[sqlca->sqlerrm.sqlerrml] = '\0';
        fprintf(stderr, ecpg_gettext("SQL error: %s\n"), sqlca->sqlerrm.sqlerrmc);
 }

diff --git a/src/interfaces/ecpg/ecpglib/execute.c b/src/interfaces/ecpg/ecpglib/execute.c
index 55969685351b43ed92e159b7fb3fa6e4edf344b4..9bdc09413b6ff13811e0e397e9b895e4eeea8a8c 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/execute.c
+++ b/src/interfaces/ecpg/ecpglib/execute.c
@@ -1441,6 +1441,13 @@ ecpg_execute(struct statement * stmt)
        if (!ecpg_check_PQresult(results, stmt->lineno, stmt->connection->connection, stmt->compat))
                return (false);
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(stmt->lineno, ECPG_OUT_OF_MEMORY,
+                                  ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+               return (false);
+       }
+
        var = stmt->outlist;
        switch (PQresultStatus(results))
        {

diff --git a/src/interfaces/ecpg/ecpglib/misc.c b/src/interfaces/ecpg/ecpglib/misc.c
index 77effbd3919f15d69b5602e97bf075b60ace1a79..8f6f2646a9ae60ea0e931dca12c95c70f65d85a2 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/misc.c
+++ b/src/interfaces/ecpg/ecpglib/misc.c
@@ -106,6 +106,13 @@ ecpg_init(const struct connection * con, const char *connection_name, const int
 {
        struct sqlca_t *sqlca = ECPGget_sqlca();
 
+       if (sqlca == NULL)
+       {
+               ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY,
+                                  NULL);
+               return (false);
+       }
+
        ecpg_init_sqlca(sqlca);
        if (con == NULL)
        {
@@ -143,6 +150,8 @@ ECPGget_sqlca(void)
        if (sqlca == NULL)
        {
                sqlca = malloc(sizeof(struct sqlca_t));
+               if (sqlca == NULL)
+                       return NULL;
                ecpg_init_sqlca(sqlca);
                pthread_setspecific(sqlca_key, sqlca);
        }
@@ -288,9 +297,11 @@ ecpg_log(const char *format,...)
        va_end(ap);
 
        /* dump out internal sqlca variables */
-       if (ecpg_internal_regression_mode)
+       if (ecpg_internal_regression_mode && sqlca != NULL)
+       {
                fprintf(debugstream, "[NO_PID]: sqlca: code: %ld, state: %s\n",
                                sqlca->sqlcode, sqlca->sqlstate);
+       }
 
        fflush(debugstream);
 
@@ -531,6 +542,13 @@ ECPGset_var(int number, void *pointer, int lineno)
        {
                struct sqlca_t *sqlca = ECPGget_sqlca();
 
+               if (sqlca == NULL)
+               {
+                       ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
+                                          ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
+                       return;
+               }
+
                sqlca->sqlcode = ECPG_OUT_OF_MEMORY;
                strncpy(sqlca->sqlstate, "YE001", sizeof(sqlca->sqlstate));
                snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc), "out of memory on line %d", lineno);