Split messages line by line before sending it to syslog() fix #3325

[bacula/bacula] / bacula / src / cats / sqlite.c

diff --git a/bacula/src/cats/sqlite.c b/bacula/src/cats/sqlite.c
index cd64546d9b4c6c11d50f3b5f4612293b094c1263..a859777ff755c028125a695b54feea19a698366a 100644 (file)
--- a/bacula/src/cats/sqlite.c
+++ b/bacula/src/cats/sqlite.c
@@ -225,9 +225,9 @@ void B_DB_SQLITE::db_close_database(JCR *jcr)
 {
    db_end_transaction(jcr);
    P(mutex);
-   sql_free_result();
    m_ref_count--;
    if (m_ref_count == 0) {
+      sql_free_result();
       db_list->remove(this);
       if (m_connected && m_db_handle) {
          sqlite3_close(m_db_handle);
@@ -302,28 +302,14 @@ void B_DB_SQLITE::db_escape_string(JCR *jcr, char *snew, char *old, int len)
  */
 char *B_DB_SQLITE::db_escape_object(JCR *jcr, char *old, int len)
 {
-   char *n, *o;
+   int l;
+   int max = len*2;           /* TODO: too big, should be *4/3 */
+
+   esc_obj = check_pool_memory_size(esc_obj, max);
+   l = bin_to_base64(esc_obj, max, old, len, true);
+   esc_obj[l] = 0;
+   ASSERT(l < max);    /* TODO: add check for l */
 
-   n = esc_obj = check_pool_memory_size(esc_obj, len*2+1);
-   o = old;
-   while (len--) {
-      switch (*o) {
-      case '\'':
-         *n++ = '\'';
-         *n++ = '\'';
-         o++;
-         break;
-      case 0:
-         *n++ = '\\';
-         *n++ = 0;
-         o++;
-         break;
-      default:
-         *n++ = *o++;
-         break;
-      }
-   }
-   *n = 0;
    return esc_obj;
 }
 
@@ -332,6 +318,7 @@ char *B_DB_SQLITE::db_escape_object(JCR *jcr, char *old, int len)
  *
  * TODO: need to be implemented (escape \0)
  */
+
 void B_DB_SQLITE::db_unescape_object(JCR *jcr, char *from, int32_t expected_len,
                                      POOLMEM **dest, int32_t *dest_len)
 {
@@ -341,8 +328,8 @@ void B_DB_SQLITE::db_unescape_object(JCR *jcr, char *from, int32_t expected_len,
       return;
    }
    *dest = check_pool_memory_size(*dest, expected_len+1);
+   base64_to_bin(*dest, expected_len+1, from, strlen(from));
    *dest_len = expected_len;
-   memcpy(*dest, from, expected_len);
    (*dest)[expected_len]=0;
 }
 
@@ -404,20 +391,30 @@ void B_DB_SQLITE::db_end_transaction(JCR *jcr)
 }
 
 struct rh_data {
+   B_DB_SQLITE *mdb;
    DB_RESULT_HANDLER *result_handler;
    void *ctx;
+   bool initialized;
 };
 
 /*
  * Convert SQLite's callback into Bacula DB callback
  */
-static int sqlite_sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
+static int sqlite_result_handler(void *arh_data, int num_fields, char **rows, char **col_names)
 {
    struct rh_data *rh_data = (struct rh_data *)arh_data;
 
+   /* The db_sql_query doesn't have access to m_results, so if we wan't to get
+    * fields information, we need to use col_names
+    */
+   if (!rh_data->initialized) {
+      rh_data->mdb->set_column_names(col_names, num_fields);
+      rh_data->initialized = true;
+   }
    if (rh_data->result_handler) {
       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
    }
+   
    return 0;
 }
 
@@ -438,15 +435,23 @@ bool B_DB_SQLITE::db_sql_query(const char *query, DB_RESULT_HANDLER *result_hand
       sqlite3_free(m_sqlite_errmsg);
       m_sqlite_errmsg = NULL;
    }
-   rh_data.result_handler = result_handler;
+   sql_free_result();
+
    rh_data.ctx = ctx;
-   stat = sqlite3_exec(m_db_handle, query, sqlite_sqlite_result, (void *)&rh_data, &m_sqlite_errmsg);
+   rh_data.mdb = this;
+   rh_data.initialized = false;
+   rh_data.result_handler = result_handler;
+
+   stat = sqlite3_exec(m_db_handle, query, sqlite_result_handler,
+                       (void *)&rh_data, &m_sqlite_errmsg);
+   
    if (stat != SQLITE_OK) {
       Mmsg(errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror());
       Dmsg0(500, "db_sql_query finished\n");
       goto bail_out;
    }
    Dmsg0(500, "db_sql_query finished\n");
+   sql_free_result();
    retval = true;
 
 bail_out:
@@ -464,9 +469,7 @@ bool B_DB_SQLITE::sql_query(const char *query, int flags)
 
    Dmsg1(500, "sql_query starts with '%s'\n", query);
 
-   if (m_result) {
-      sql_free_result();
-   }
+   sql_free_result();
    if (m_sqlite_errmsg) {
       sqlite3_free(m_sqlite_errmsg);
       m_sqlite_errmsg = NULL;
@@ -497,6 +500,7 @@ void B_DB_SQLITE::sql_free_result(void)
       sqlite3_free_table(m_result);
       m_result = NULL;
    }
+   m_col_names = NULL;
    m_num_rows = m_num_fields = 0;
    db_unlock(this);
 }
@@ -554,6 +558,26 @@ SQL_FIELD *B_DB_SQLITE::sql_fetch_field(void)
 {
    int i, j, len;
 
+   /* We are in the middle of a db_sql_query and we want to get fields info */
+   if (m_col_names != NULL) {
+      if (m_num_fields > m_field_number) {
+         m_sql_field.name = m_col_names[m_field_number];
+         /* We don't have the maximum field length, so we can use 80 as
+          * estimation.
+          */
+         len = MAX(cstrlen(m_sql_field.name), 80/m_num_fields);
+         m_sql_field.max_length = len;
+
+         m_field_number++;
+         m_sql_field.type = 0;  /* not numeric */
+         m_sql_field.flags = 1; /* not null */
+         return &m_sql_field;
+      } else {                  /* too much fetch_field() */
+         return NULL;
+      }
+   }
+
+   /* We are after a sql_query() that stores the result in m_results */
    if (!m_fields || m_fields_size < m_num_fields) {
       if (m_fields) {
          free(m_fields);
@@ -627,7 +651,7 @@ bool B_DB_SQLITE::sql_batch_start(JCR *jcr)
                               "Name blob,"
                               "LStat tinyblob,"
                               "MD5 tinyblob,"
-                              "MarkId integer)");
+                              "DeltaSeq integer)");
    db_unlock(this);
 
    return retval;