From d7f11ecb06688186d4c68b5933fb1437279ce03d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 8 Apr 2009 16:50:57 +0200
Subject: Make it work in batches of statements.

Currently, all statements to be executed are stored on the same
structure. When the batch size is reached, all statements are executed
in a single transaction, and then committed.

There are many corner cases in which an error may happen and the batch
may be left in an inconsistent state, perhaps leaking memory or
crashing. They will be fixed.
---
 plugins/omoracle/omoracle.c | 71 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 60 insertions(+), 11 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index ea910d3a..9b1ec42d 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -15,7 +15,8 @@
     $OmoracleDBPassword: password to log in on the database.
     $OmoracleDB: connection string (an Oracle easy connect or a db
     name as specified by tnsnames.ora)
-    
+    $OmoracleBatchSize: Number of elements to send to the DB.
+
     All fields are mandatory. The dbstring can be an Oracle easystring
     or a DB name, as present in the tnsnames.ora file.
 
@@ -50,6 +51,18 @@ MODULE_TYPE_OUTPUT
 DEF_OMOD_STATIC_DATA
 DEFobjCurrIf(errmsg)
 
+/**  */
+struct oracle_batch
+{
+	/* Batch size */
+	int size;
+	/* Last element inserted in the buffer. The batch will be
+	 * executed when n == size */
+	int n;
+	/* Statements to run on this transaction */
+	char** statements;
+};
+
 typedef struct _instanceData {
 	/* Environment handler, the base for any OCI work. */
 	OCIEnv* environment;
@@ -67,6 +80,8 @@ typedef struct _instanceData {
 	OCIBind* binding;
 	/* Connection string, kept here for possible retries. */
 	char* connection;
+	/* Batch */
+	struct oracle_batch batch;
 } instanceData;
 
 /** Database name, to be filled by the $OmoracleDB directive */
@@ -76,6 +91,8 @@ static char* db_name;
 static char* db_user;
 /** Database password, to be filled by the $OmoracleDBPassword */
 static char* db_password;
+/** Batch size. */
+static int batch_size;
 
 /** Generic function for handling errors from OCI.
 
@@ -148,6 +165,12 @@ CODESTARTcreateInstance
 		 OCIHandleAlloc(pData->environment, (void*) &(pData->statement),
 				OCI_HTYPE_STMT, 0, NULL));
 
+	pData->batch.n = 0;
+	pData->batch.size = batch_size;
+	pData->batch.statements = calloc(pData->batch.size,
+					 sizeof *pData->batch.statements);
+	CHKmalloc(pData->batch.statements);
+
 finalize_it:
 ENDcreateInstance
 
@@ -163,6 +186,9 @@ CODESTARTfreeInstance
 	OCIHandleFree(pData->authinfo, OCI_HTYPE_AUTHINFO);
 	OCIHandleFree(pData->statement, OCI_HTYPE_STMT);
 	free(pData->connection);
+	while (pData->batch.size--) 
+		free(pData->batch.statements[pData->batch.size]);
+	free(pData->batch.statements);
 	dbgprintf ("omoracle freed all its resources\n");
 	RETiRet;
 
@@ -263,21 +289,41 @@ CODE_STD_FINALIZERparseSelectorAct
 ENDparseSelectorAct
 
 BEGINdoAction
+	int i;
+	int n;
 CODESTARTdoAction
 	dbgprintf("omoracle attempting to execute statement %s\n", *ppString);
-	CHECKERR(pData->error,
-		 OCIStmtPrepare(pData->statement, pData->error, *ppString,
-				strlen(*ppString), OCI_NTV_SYNTAX,
-				OCI_DEFAULT));
-	CHECKERR(pData->error,
-		 OCIStmtExecute(pData->service, pData->statement, pData->error,
-				1, 0, NULL, NULL, OCI_DEFAULT));
-	CHECKERR(pData->error,
-		 OCITransCommit(pData->service, pData->error, 0));
+
+	if (pData->batch.n == pData->batch.size) {
+		dbgprintf("omoracle batch size limit hit, sending into DB\n");
+		for (i = 0; i < pData->batch.n; i++) {
+			if (pData->batch.statements[i] == NULL)
+				continue;
+			n = strlen(pData->batch.statements[i]);
+			CHECKERR(pData->error,
+				 OCIStmtPrepare(pData->statement,
+						pData->error,
+						pData->batch.statements[i], n,
+						OCI_NTV_SYNTAX, OCI_DEFAULT));
+			CHECKERR(pData->error,
+				 OCIStmtExecute(pData->service,
+						pData->statement,
+						pData->error,
+						1, 0, NULL, NULL, OCI_DEFAULT));
+			free(pData->batch.statements[i]);
+			pData->batch.statements[i] = NULL;
+		}
+		CHECKERR(pData->error,
+			 OCITransCommit(pData->service, pData->error, 0));
+		pData->batch.n = 0;
+	}
+	pData->batch.statements[pData->batch.n] = strdup(*ppString);
+	CHKmalloc(pData->batch.statements[pData->batch.n]);
+	pData->batch.n++;
+
 finalize_it:
 	dbgprintf ("omoracle %s at executing statement %s\n",
 		   iRet?"did not succeed":"succeeded", *ppString);
-/* Clean credentials to avoid leakage in case of core dump. */
 ENDdoAction
 
 BEGINmodExit
@@ -331,4 +377,7 @@ CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoracledb", 0,
 				   eCmdHdlrGetWord, NULL, &db_name,
 				   STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclebatchsize", 0,
+				   eCmdHdlrInt, NULL, &batch_size,
+				   STD_LOADABLE_MODULE_ID));
 ENDmodInit
-- 
cgit v1.2.3


From 9bbd5dfd25f3e2a7a6839ff0e7b4076186efbcf4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 8 Apr 2009 16:50:58 +0200
Subject: Solve a memory leak when freeing Oracle instances.

---
 plugins/omoracle/omoracle.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 9b1ec42d..df06a8b6 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -190,7 +190,6 @@ CODESTARTfreeInstance
 		free(pData->batch.statements[pData->batch.size]);
 	free(pData->batch.statements);
 	dbgprintf ("omoracle freed all its resources\n");
-	RETiRet;
 
 ENDfreeInstance
 
-- 
cgit v1.2.3


From 1ebbd3a2df09ed9e706be7762307cd17c4a5cad0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 8 Apr 2009 16:50:59 +0200
Subject: Stop omoracle losing messages on rsyslog shutdown.

When rsyslog shuts down, we must send and commit any pending messages
or information will be lost. It will make rsyslog's shut down slower,
but also more reliable.
---
 plugins/omoracle/omoracle.c | 65 +++++++++++++++++++++++++++++----------------
 1 file changed, 42 insertions(+), 23 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index df06a8b6..f6679953 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -12,13 +12,17 @@
     namely:
 
     $OmoracleDBUser: user name to log in on the database.
+
     $OmoracleDBPassword: password to log in on the database.
+
     $OmoracleDB: connection string (an Oracle easy connect or a db
     name as specified by tnsnames.ora)
-    $OmoracleBatchSize: Number of elements to send to the DB.
 
-    All fields are mandatory. The dbstring can be an Oracle easystring
-    or a DB name, as present in the tnsnames.ora file.
+    $OmoracleBatchSize: Number of elements to send to the DB on each
+    transaction.
+
+    All these directives are mandatory. The dbstring can be an Oracle
+    easystring or a DB name, as present in the tnsnames.ora file.
 
     Author: Luis Fernando Muñoz Mejías
     <Luis.Fernando.Munoz.Mejias@cern.ch>
@@ -174,11 +178,45 @@ CODESTARTcreateInstance
 finalize_it:
 ENDcreateInstance
 
+/* Inserts all stored statements into the database, releasing any
+ * allocated memory. */
+static int insert_to_db(instanceData* pData)
+{
+	DEFiRet;
+	int i, n;
+
+	for (i = 0; i < pData->batch.n; i++) {
+		if (pData->batch.statements[i] == NULL)
+			continue;
+		n = strlen(pData->batch.statements[i]);
+		CHECKERR(pData->error,
+			 OCIStmtPrepare(pData->statement,
+					pData->error,
+					pData->batch.statements[i], n,
+					OCI_NTV_SYNTAX, OCI_DEFAULT));
+		CHECKERR(pData->error,
+			 OCIStmtExecute(pData->service,
+					pData->statement,
+					pData->error,
+					1, 0, NULL, NULL, OCI_DEFAULT));
+		free(pData->batch.statements[i]);
+		pData->batch.statements[i] = NULL;
+	}
+	CHECKERR(pData->error,
+		 OCITransCommit(pData->service, pData->error, 0));
+	pData->batch.n = 0;
+finalize_it:
+	RETiRet;
+}
+
 /** Close the session and free anything allocated by
     createInstance. */
 BEGINfreeInstance
 CODESTARTfreeInstance
 
+/* Before actually releasing our resources, let's try to commit
+ * anything pending so that we don't lose any messages. */
+	insert_to_db(pData);
 	OCISessionRelease(pData->service, pData->error, NULL, 0, OCI_DEFAULT);
 	OCIHandleFree(pData->environment, OCI_HTYPE_ENV);
 	OCIHandleFree(pData->error, OCI_HTYPE_ERROR);
@@ -295,26 +333,7 @@ CODESTARTdoAction
 
 	if (pData->batch.n == pData->batch.size) {
 		dbgprintf("omoracle batch size limit hit, sending into DB\n");
-		for (i = 0; i < pData->batch.n; i++) {
-			if (pData->batch.statements[i] == NULL)
-				continue;
-			n = strlen(pData->batch.statements[i]);
-			CHECKERR(pData->error,
-				 OCIStmtPrepare(pData->statement,
-						pData->error,
-						pData->batch.statements[i], n,
-						OCI_NTV_SYNTAX, OCI_DEFAULT));
-			CHECKERR(pData->error,
-				 OCIStmtExecute(pData->service,
-						pData->statement,
-						pData->error,
-						1, 0, NULL, NULL, OCI_DEFAULT));
-			free(pData->batch.statements[i]);
-			pData->batch.statements[i] = NULL;
-		}
-		CHECKERR(pData->error,
-			 OCITransCommit(pData->service, pData->error, 0));
-		pData->batch.n = 0;
+		CHKiRet(insert_to_db(pData));
 	}
 	pData->batch.statements[pData->batch.n] = strdup(*ppString);
 	CHKmalloc(pData->batch.statements[pData->batch.n]);
-- 
cgit v1.2.3


From 65a85de3d97ab6bc427ea005b75e4b416013de3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 15 Apr 2009 16:53:16 +0200
Subject: Convert to the array-based interface.

We'll receive a single statement to be prepared and a batch
size. Then, doAction will execute the statement only once per batch
hit, making the process much more efficient.

This will reduce network and DB server overhead. The downside is that
this version cannot be used with rsyslog v3 anymore. If anyone is
interested on backporting the module, they should choose all patches
up to this one.

Better documentation may follow.
---
 plugins/omoracle/omoracle.c | 203 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 162 insertions(+), 41 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index f6679953..02f83551 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -21,9 +21,28 @@
     $OmoracleBatchSize: Number of elements to send to the DB on each
     transaction.
 
+    $OmoracleStatement: Statement to be prepared and executed in
+    batches. Please note that Oracle's prepared statements have their
+    placeholders as ':identifier', and this module uses the colon to
+    guess how many placeholders there will be.
+
     All these directives are mandatory. The dbstring can be an Oracle
     easystring or a DB name, as present in the tnsnames.ora file.
 
+    The form of the template is just a list of strings you want
+    inserted to the DB, for instance:
+
+    $template TestStmt,"%hostname%%msg%"
+
+    Will provide the arguments to a statement like
+
+    $OmoracleStatement \
+        insert into foo(hostname,message)values(:host,:message)
+
+    Also note that identifiers to placeholders are arbitrarry. You
+    need to define the properties on the template in the correct order
+    you want them passed to the statement!
+
     Author: Luis Fernando Muñoz Mejías
     <Luis.Fernando.Munoz.Mejias@cern.ch>
 
@@ -40,6 +59,7 @@
 #include <signal.h>
 #include <time.h>
 #include <assert.h>
+#include <ctype.h>
 #include "dirty.h"
 #include "syslogd-types.h"
 #include "srUtils.h"
@@ -63,8 +83,12 @@ struct oracle_batch
 	/* Last element inserted in the buffer. The batch will be
 	 * executed when n == size */
 	int n;
-	/* Statements to run on this transaction */
-	char** statements;
+	/* Number of arguments the statement takes */
+	int arguments;
+	/* Parameters to pass to the statement on this transaction */
+	char*** parameters;
+	/* Binding parameters */
+	OCIBind** bindings;
 };
 
 typedef struct _instanceData {
@@ -80,10 +104,10 @@ typedef struct _instanceData {
 	OCISvcCtx* service;
 	/* Credentials object for the connection. */
 	OCIAuthInfo* authinfo;
-	/* Binding parameters, currently unused */
-	OCIBind* binding;
 	/* Connection string, kept here for possible retries. */
 	char* connection;
+	/* Statement to be prepared. */
+	char* txt_statement;
 	/* Batch */
 	struct oracle_batch batch;
 } instanceData;
@@ -97,6 +121,12 @@ static char* db_user;
 static char* db_password;
 /** Batch size. */
 static int batch_size;
+/** Statement to prepare and execute */
+static char* db_statement;
+/** Whether or not the core supports the newer array interface. The
+ * module is able to work in both modes, but the newer is the
+ * recommended one for performance reasons. */
+static int array_passing;
 
 /** Generic function for handling errors from OCI.
 
@@ -149,9 +179,49 @@ static int oci_errors(void* handle, ub4 htype, sword status)
 	return OCI_ERROR;
 }
 
+/** Returns the number of bind parameters for the statement given as
+ * an argument. */
+static int count_bind_parameters(char* p)
+{
+	int n = 0;
+
+	for (; *p; p++)
+		if (*p == BIND_MARK)
+			n++;
+	dbgprintf ("omoracle statement has %d parameters\n", n);
+	return n;
+}
+
+/** Prepares the statement, binding all its positional parameters */
+static int prepare_statement(instanceData* pData)
+{
+	int i;
+	DEFiRet;
+
+	CHECKERR(pData->error,
+		 OCIStmtPrepare(pData->statement,
+				pData->error,
+				pData->txt_statement,
+				strlen(pData->txt_statement),
+				OCI_NTV_SYNTAX, OCI_DEFAULT));
+	for (i = 0; i < pData->batch.arguments; i++)
+		CHECKERR(pData->error,
+			 OCIBindByPos(pData->statement,
+				      pData->batch.bindings+i,
+				      pData->error,
+				      i+1,
+				      pData->batch.parameters[i],
+				      sizeof (OCILobLocator*),
+				      SQLT_STR, NULL, NULL, NULL,
+				      0, 0,  OCI_DEFAULT));
+finalize_it:
+	RETiRet;
+}
+
 
 /* Resource allocation */
 BEGINcreateInstance
+	int i;
 CODESTARTcreateInstance
 
 	ASSERT(pData != NULL);
@@ -168,12 +238,29 @@ CODESTARTcreateInstance
 	CHECKENV(pData->environment,
 		 OCIHandleAlloc(pData->environment, (void*) &(pData->statement),
 				OCI_HTYPE_STMT, 0, NULL));
+	pData->txt_statement = strdup(db_statement);
+	CHKmalloc(pData->txt_statement);
+	dbgprintf("omoracle will run stored statement: %s\n",
+		  pData->txt_statement);
 
 	pData->batch.n = 0;
 	pData->batch.size = batch_size;
-	pData->batch.statements = calloc(pData->batch.size,
-					 sizeof *pData->batch.statements);
-	CHKmalloc(pData->batch.statements);
+	pData->batch.arguments = count_bind_parameters(pData->txt_statement);
+
+	/* I know, this can be done with a single malloc() call but this is
+	 * easier to read. :) */
+	pData->batch.parameters = malloc(pData->batch.arguments *
+					 sizeof *pData->batch.parameters);
+	CHKmalloc(pData->batch.parameters);
+	for (i = 0; i < pData->batch.arguments; i++) {
+		pData->batch.parameters[i] = calloc(pData->batch.size,
+						    sizeof **pData->batch.parameters);
+		CHKmalloc(pData->batch.parameters[i]);
+	}
+
+	pData->batch.bindings = calloc(pData->batch.arguments,
+				       sizeof *pData->batch.bindings);
+	CHKmalloc(pData->batch.bindings);
 
 finalize_it:
 ENDcreateInstance
@@ -183,35 +270,34 @@ ENDcreateInstance
 static int insert_to_db(instanceData* pData)
 {
 	DEFiRet;
-	int i, n;
+	int i, j, n;
+
+	CHECKERR(pData->error,
+		 OCIStmtExecute(pData->service,
+				pData->statement,
+				pData->error,
+				pData->batch.n, 0, NULL, NULL, OCI_DEFAULT));
 
-	for (i = 0; i < pData->batch.n; i++) {
-		if (pData->batch.statements[i] == NULL)
-			continue;
-		n = strlen(pData->batch.statements[i]);
-		CHECKERR(pData->error,
-			 OCIStmtPrepare(pData->statement,
-					pData->error,
-					pData->batch.statements[i], n,
-					OCI_NTV_SYNTAX, OCI_DEFAULT));
-		CHECKERR(pData->error,
-			 OCIStmtExecute(pData->service,
-					pData->statement,
-					pData->error,
-					1, 0, NULL, NULL, OCI_DEFAULT));
-		free(pData->batch.statements[i]);
-		pData->batch.statements[i] = NULL;
-	}
 	CHECKERR(pData->error,
 		 OCITransCommit(pData->service, pData->error, 0));
+
+	for (i = 0; i < pData->batch.arguments; i++)
+		for (j = 0; j < pData->batch.n; j++) {
+			free(pData->batch.parameters[i][j]);
+			pData->batch.parameters[i][j] = NULL;
+		}
+
 	pData->batch.n = 0;
 finalize_it:
+	dbgprintf ("omoracle insertion to DB %s\n", iRet == RS_RET_OK ?
+		   "succeeded" : "did not succeed");
 	RETiRet;
 }
 
 /** Close the session and free anything allocated by
     createInstance. */
 BEGINfreeInstance
+	int i, j;
 CODESTARTfreeInstance
 
 /* Before actually releasing our resources, let's try to commit
@@ -224,9 +310,13 @@ CODESTARTfreeInstance
 	OCIHandleFree(pData->authinfo, OCI_HTYPE_AUTHINFO);
 	OCIHandleFree(pData->statement, OCI_HTYPE_STMT);
 	free(pData->connection);
-	while (pData->batch.size--) 
-		free(pData->batch.statements[pData->batch.size]);
-	free(pData->batch.statements);
+	for (i = 0; i < pData->batch.arguments; i++) {
+		for (j = 0; j < pData->batch.size; j++)
+			free(pData->batch.parameters[i][j]);
+		free(pData->batch.parameters[i]);
+	}
+	free(pData->batch.parameters);
+	free(pData->batch.bindings);
 	dbgprintf ("omoracle freed all its resources\n");
 
 ENDfreeInstance
@@ -253,7 +343,7 @@ CODESTARTtryResume
 	 * ... of course I don't know why Oracle might need a full restart...
 	 * rgerhards, 2009-03-26
 	 */
-	dbgprintf("Attempting to reconnect to DB server\n");
+	dbgprintf("omoracle attempting to reconnect to DB server\n");
 	OCISessionRelease(pData->service, pData->error, NULL, 0, OCI_DEFAULT);
 	OCIHandleFree(pData->service, OCI_HTYPE_SVCCTX);
 	CHECKERR(pData->error, OCISessionGet(pData->environment, pData->error,
@@ -261,6 +351,7 @@ CODESTARTtryResume
 					     pData->connection,
 					     strlen(pData->connection), NULL, 0,
 					     NULL, NULL, NULL, OCI_DEFAULT));
+	CHKiRet(prepare_statement(pData));
 
 finalize_it:
 ENDtryResume
@@ -296,7 +387,6 @@ CODESTARTisCompatibleWithFeature
 ENDisCompatibleWithFeature
 
 BEGINparseSelectorAct
-
 CODESTARTparseSelectorAct
 CODE_STD_STRING_REQUESTparseSelectorAct(1);
 
@@ -314,11 +404,12 @@ CODE_STD_STRING_REQUESTparseSelectorAct(1);
 	}
 
 	CHKiRet(cflineParseTemplateName(&p, *ppOMSR, 0,
-					OMSR_RQD_TPL_OPT_SQL, " StdFmt"));
+					OMSR_TPL_AS_ARRAY, " StdFmt"));
 	CHKiRet(createInstance(&pData));
 	CHKmalloc(pData->connection = strdup(db_name));
 	CHKiRet(startSession(pData, db_name, db_user, db_password));
-	
+	CHKiRet(prepare_statement(pData));
+
 	dbgprintf ("omoracle module got all its resources allocated "
 		   "and connected to the DB\n");
 	
@@ -327,21 +418,23 @@ ENDparseSelectorAct
 
 BEGINdoAction
 	int i;
-	int n;
+	int n = pData->batch.n;
+	char **params = (char**) ppString[0];
 CODESTARTdoAction
-	dbgprintf("omoracle attempting to execute statement %s\n", *ppString);
 
-	if (pData->batch.n == pData->batch.size) {
+	if (n == pData->batch.size) {
 		dbgprintf("omoracle batch size limit hit, sending into DB\n");
 		CHKiRet(insert_to_db(pData));
 	}
-	pData->batch.statements[pData->batch.n] = strdup(*ppString);
-	CHKmalloc(pData->batch.statements[pData->batch.n]);
+
+	for (i = 0; i < pData->batch.arguments && params[i]; i++) {
+		dbgprintf ("omoracle argument on batch[%d][%d]: %s\n", i, n, params[i]);
+		pData->batch.parameters[i][n] = strdup(params[i]);
+		CHKmalloc(pData->batch.parameters[i][n]);
+	}
 	pData->batch.n++;
 
 finalize_it:
-	dbgprintf ("omoracle %s at executing statement %s\n",
-		   iRet?"did not succeed":"succeeded", *ppString);
 ENDdoAction
 
 BEGINmodExit
@@ -373,16 +466,35 @@ resetConfigVariables(uchar __attribute__((unused)) *pp,
 		memset(db_password, 0, n);
 		free(db_password);
 	}
-	db_name = db_user = db_password = NULL;
+	if (db_statement != NULL)
+		free(db_statement);
+	db_name = db_user = db_password = db_statement = NULL;
+	RETiRet;
+}
+
+/** As I don't find any handler that reads an entire line, I write my
+ * own. */
+static int get_db_statement(char** line, char** stmt)
+{
+	DEFiRet;
+
+	while (isspace(**line))
+		(*line)++;
+	dbgprintf ("Config line: %s\n", *line);
+	*stmt = strdup(*line);
+	CHKmalloc(*stmt);
+	dbgprintf ("Statement: %s\n", *stmt);
+finalize_it:
 	RETiRet;
 }
 
 BEGINmodInit()
+	rsRetVal (*supported_options)(unsigned long *pOpts);
+	unsigned long opts;
 CODESTARTmodInit
 	*ipIFVersProvided = CURR_MOD_IF_VERSION;
 CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(objUse(errmsg, CORE_COMPONENT));
-	/* CHKiRet(omsdRegCFSLineHdlr((uchar*)"actionomoracle",  */
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "resetconfigvariables", 1,
 				   eCmdHdlrCustomHandler, resetConfigVariables,
 				   NULL, STD_LOADABLE_MODULE_ID));
@@ -398,4 +510,13 @@ CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclebatchsize", 0,
 				   eCmdHdlrInt, NULL, &batch_size,
 				   STD_LOADABLE_MODULE_ID));
+	CHKiRet(pHostQueryEtryPt((uchar*)"OMSRgetSupportedTplOpts", &supported_options));
+	CHKiRet((*supported_options)(&opts));
+	if (!(array_passing = opts & OMSR_TPL_AS_ARRAY))
+		ABORT_FINALIZE(RS_RET_ERR);
+
+	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclestatement", 0,
+				   eCmdHdlrCustomHandler, get_db_statement,
+				   &db_statement, STD_LOADABLE_MODULE_ID));
+
 ENDmodInit
-- 
cgit v1.2.3


From 24fcd96203c9b8b84a8414cea19dcb3ba989c9ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 15 Apr 2009 16:53:17 +0200
Subject: Fixed a mem leak

---
 plugins/omoracle/omoracle.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 02f83551..12efd61c 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -310,6 +310,7 @@ CODESTARTfreeInstance
 	OCIHandleFree(pData->authinfo, OCI_HTYPE_AUTHINFO);
 	OCIHandleFree(pData->statement, OCI_HTYPE_STMT);
 	free(pData->connection);
+	free(pData->txt_statement);
 	for (i = 0; i < pData->batch.arguments; i++) {
 		for (j = 0; j < pData->batch.size; j++)
 			free(pData->batch.parameters[i][j]);
-- 
cgit v1.2.3


From f89b761c84270cde71e0a6275ea80bb20f60d2df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 15 Apr 2009 16:53:18 +0200
Subject: Make the counting of bind parameters aware of literals.

Literal strings passed in the statement may contain ':', let's not
count them.
---
 plugins/omoracle/omoracle.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 12efd61c..b598192f 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -180,14 +180,21 @@ static int oci_errors(void* handle, ub4 htype, sword status)
 }
 
 /** Returns the number of bind parameters for the statement given as
- * an argument. */
+ * an argument. It counts the number of appearances of ':', as in
+ *
+ * insert into foo(bar, baz) values(:bar, :baz)
+ *
+ * while taking in account that string literals must not be parsed. */
 static int count_bind_parameters(char* p)
 {
 	int n = 0;
+	int enable = 1;
 
 	for (; *p; p++)
-		if (*p == BIND_MARK)
+		if (enable && *p == BIND_MARK )
 			n++;
+		else if (*p == '\'')
+			enable ^= 1;
 	dbgprintf ("omoracle statement has %d parameters\n", n);
 	return n;
 }
@@ -429,7 +436,6 @@ CODESTARTdoAction
 	}
 
 	for (i = 0; i < pData->batch.arguments && params[i]; i++) {
-		dbgprintf ("omoracle argument on batch[%d][%d]: %s\n", i, n, params[i]);
 		pData->batch.parameters[i][n] = strdup(params[i]);
 		CHKmalloc(pData->batch.parameters[i][n]);
 	}
-- 
cgit v1.2.3


From 9a897329ec6f80c99ca039f12388961417e0a422 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 15 Apr 2009 16:53:19 +0200
Subject: Add some debugging output

---
 plugins/omoracle/omoracle.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index b598192f..7199f3e1 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -436,6 +436,7 @@ CODESTARTdoAction
 	}
 
 	for (i = 0; i < pData->batch.arguments && params[i]; i++) {
+		dbgprintf("batch[%d][%d]=%s\n", i, n, params[i]);
 		pData->batch.parameters[i][n] = strdup(params[i]);
 		CHKmalloc(pData->batch.parameters[i][n]);
 	}
-- 
cgit v1.2.3


From ca28204f7ba5c5c520b52180e26471e12af83560 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 15 Apr 2009 16:53:20 +0200
Subject: Add the callback for OCIBindDynamic.

Let's hope it works.
---
 plugins/omoracle/omoracle.c | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 7199f3e1..48b97b27 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -179,6 +179,34 @@ static int oci_errors(void* handle, ub4 htype, sword status)
 	return OCI_ERROR;
 }
 
+/** Callback for OCIBindDynamic.
+ *
+ * OCI doesn't insert an array of char* by itself (although it can
+ * handle arrays of int), so we must either run in batches of size one
+ * (no way) or bind all parameters with OCI_DATA_AT_EXEC instead of
+ * OCI_DEFAULT, and then give this function as an argument to
+ * OCIBindDynamic so that it is able to handle all strings in a single
+ * server trip.
+ *
+ * See the documentation of OCIBindDynamic
+ * (http://download.oracle.com/docs/cd/B28359_01/appdev.111/b28395/oci16rel003.htm#i444015)
+ * for more details.
+ */
+static int __attribute__((unused))
+bind_dynamic (char** in, OCIBind __attribute__((unused))* bind,
+			 int iter, int __attribute__((unused)) idx,
+			 char** out, int* buflen, char* piece,
+			 void** bd)
+{
+	dbgprintf ("Bound line: %s\n", in[iter]);
+	*out = in[iter];
+	*buflen = sizeof (OCILobLocator*);
+	*piece = OCI_ONE_PIECE;
+	*bd = NULL;
+	return OCI_CONTINUE;
+}
+
+
 /** Returns the number of bind parameters for the statement given as
  * an argument. It counts the number of appearances of ':', as in
  *
-- 
cgit v1.2.3


From 668f9a79fb7268f7935d93249cf283664662996d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Wed, 15 Apr 2009 16:53:21 +0200
Subject: Fixing the batch insertions.

Previous versions inserted garbage (the pointer was interpreted as the
string itself). It seems inserting arrays of strings is not that easy
with OCI.

This approach consumes 2KB per entry in the batch, so if you have
batches of size 1000 you'll be using 2MB for the batch. This size
doesn't change, anyways and the risk of leaking memory is gone. OCI
doesn't deal well with batches of strings. :(
---
 plugins/omoracle/omoracle.c | 63 ++++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 26 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 48b97b27..ddcb2ffa 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -192,15 +192,15 @@ static int oci_errors(void* handle, ub4 htype, sword status)
  * (http://download.oracle.com/docs/cd/B28359_01/appdev.111/b28395/oci16rel003.htm#i444015)
  * for more details.
  */
-static int __attribute__((unused))
-bind_dynamic (char** in, OCIBind __attribute__((unused))* bind,
-			 int iter, int __attribute__((unused)) idx,
-			 char** out, int* buflen, char* piece,
+static int bind_dynamic (char** in, OCIBind __attribute__((unused))* bind,
+			 int  iter, int __attribute__((unused))  idx,
+			 char** out, int* buflen, unsigned char* piece,
 			 void** bd)
 {
-	dbgprintf ("Bound line: %s\n", in[iter]);
 	*out = in[iter];
-	*buflen = sizeof (OCILobLocator*);
+	*buflen = strlen(*out) + 1;
+	dbgprintf ("omoracle bound line %d, length %d: %s\n", iter, *buflen,
+		   *out);
 	*piece = OCI_ONE_PIECE;
 	*bd = NULL;
 	return OCI_CONTINUE;
@@ -239,16 +239,22 @@ static int prepare_statement(instanceData* pData)
 				pData->txt_statement,
 				strlen(pData->txt_statement),
 				OCI_NTV_SYNTAX, OCI_DEFAULT));
-	for (i = 0; i < pData->batch.arguments; i++)
+	for (i = 0; i < pData->batch.arguments; i++) {
 		CHECKERR(pData->error,
 			 OCIBindByPos(pData->statement,
 				      pData->batch.bindings+i,
-				      pData->error,
-				      i+1,
-				      pData->batch.parameters[i],
-				      sizeof (OCILobLocator*),
+				      pData->error, i+1, NULL,
+				      MAX_BUFSIZE *
+				      sizeof ***pData->batch.parameters,
 				      SQLT_STR, NULL, NULL, NULL,
-				      0, 0,  OCI_DEFAULT));
+				      0, 0,  OCI_DATA_AT_EXEC));
+		CHECKERR(pData->error,
+			 OCIBindDynamic(pData->batch.bindings[i],
+					pData->error,
+					pData->batch.parameters[i],
+					bind_dynamic, NULL, NULL));
+	}
+
 finalize_it:
 	RETiRet;
 }
@@ -256,7 +262,7 @@ finalize_it:
 
 /* Resource allocation */
 BEGINcreateInstance
-	int i;
+	int i, j;
 CODESTARTcreateInstance
 
 	ASSERT(pData != NULL);
@@ -284,13 +290,25 @@ CODESTARTcreateInstance
 
 	/* I know, this can be done with a single malloc() call but this is
 	 * easier to read. :) */
-	pData->batch.parameters = malloc(pData->batch.arguments *
+	pData->batch.parameters = calloc(pData->batch.arguments,
 					 sizeof *pData->batch.parameters);
 	CHKmalloc(pData->batch.parameters);
 	for (i = 0; i < pData->batch.arguments; i++) {
 		pData->batch.parameters[i] = calloc(pData->batch.size,
 						    sizeof **pData->batch.parameters);
 		CHKmalloc(pData->batch.parameters[i]);
+		for (j = 0; j < pData->batch.size; j++) {
+			/* Each entry has at most MAX_BUFSIZE bytes
+			 * because OCI doesn't like null-terminated
+			 * strings when operating with batches, and
+			 * the maximum size of each entry must be
+			 * provided when binding
+			 * parameters. MAX_BUFSIZE is long enough for
+			 * usual entries. */
+			pData->batch.parameters[i][j] = calloc(MAX_BUFSIZE,
+							       sizeof ***pData->batch.parameters);
+			CHKmalloc(pData->batch.parameters[i][j]);
+		}
 	}
 
 	pData->batch.bindings = calloc(pData->batch.arguments,
@@ -305,7 +323,6 @@ ENDcreateInstance
 static int insert_to_db(instanceData* pData)
 {
 	DEFiRet;
-	int i, j, n;
 
 	CHECKERR(pData->error,
 		 OCIStmtExecute(pData->service,
@@ -316,12 +333,6 @@ static int insert_to_db(instanceData* pData)
 	CHECKERR(pData->error,
 		 OCITransCommit(pData->service, pData->error, 0));
 
-	for (i = 0; i < pData->batch.arguments; i++)
-		for (j = 0; j < pData->batch.n; j++) {
-			free(pData->batch.parameters[i][j]);
-			pData->batch.parameters[i][j] = NULL;
-		}
-
 	pData->batch.n = 0;
 finalize_it:
 	dbgprintf ("omoracle insertion to DB %s\n", iRet == RS_RET_OK ?
@@ -454,19 +465,19 @@ ENDparseSelectorAct
 
 BEGINdoAction
 	int i;
-	int n = pData->batch.n;
 	char **params = (char**) ppString[0];
 CODESTARTdoAction
 
-	if (n == pData->batch.size) {
+	if (pData->batch.n == pData->batch.size) {
 		dbgprintf("omoracle batch size limit hit, sending into DB\n");
 		CHKiRet(insert_to_db(pData));
 	}
 
 	for (i = 0; i < pData->batch.arguments && params[i]; i++) {
-		dbgprintf("batch[%d][%d]=%s\n", i, n, params[i]);
-		pData->batch.parameters[i][n] = strdup(params[i]);
-		CHKmalloc(pData->batch.parameters[i][n]);
+		dbgprintf("batch[%d][%d]=%s\n", i, pData->batch.n, params[i]);
+		strncpy(pData->batch.parameters[i][pData->batch.n], params[i],
+			MAX_BUFSIZE);
+		CHKmalloc(pData->batch.parameters[i][pData->batch.n]);
 	}
 	pData->batch.n++;
 
-- 
cgit v1.2.3


From 2d5e8ba7cd05a95f897506e51dcc5adb06dbcaa8 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Thu, 16 Apr 2009 17:26:07 +0200
Subject: added a new error code for too-old rsyslog core

which can be emittend when plugin can not load due to missing
core functionality.
---
 plugins/omoracle/omoracle.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index ddcb2ffa..71cc8e1f 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -560,7 +560,7 @@ CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(pHostQueryEtryPt((uchar*)"OMSRgetSupportedTplOpts", &supported_options));
 	CHKiRet((*supported_options)(&opts));
 	if (!(array_passing = opts & OMSR_TPL_AS_ARRAY))
-		ABORT_FINALIZE(RS_RET_ERR);
+		ABORT_FINALIZE(RS_RET_RSCORE_TOO_OLD);
 
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclestatement", 0,
 				   eCmdHdlrCustomHandler, get_db_statement,
-- 
cgit v1.2.3


From e65a30ddaaf027855b57355fe35b88b97053ac99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Tue, 28 Apr 2009 21:14:50 +0200
Subject: Add licensing information.

I'm not sure if GPLv3 contemplates the ability to link to proprietary
software, if it was previous work. I explicitly allow linking to OCI.
---
 plugins/omoracle/omoracle.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 71cc8e1f..3a1f141f 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -43,6 +43,10 @@
     need to define the properties on the template in the correct order
     you want them passed to the statement!
 
+    This file is licensed under the terms of the GPL version 3 or, at
+    your choice, any later version. Exceptionally (perhaps), you are
+    allowed to link to the Oracle Call Interface in your derived work
+
     Author: Luis Fernando Muñoz Mejías
     <Luis.Fernando.Munoz.Mejias@cern.ch>
 
-- 
cgit v1.2.3


From 65a69831e955fa32b23e8f25d3ba67b1e3058e1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Tue, 28 Apr 2009 21:14:51 +0200
Subject: Add the $OmoracleBatchItemSize directive

This directive controls the amount of memory needed for properties in
the batch. Users should specify the largest value they expect in the
statement. As per Rainer's comment:

on MAX_BUFSIZE: I'd tend to make this configurable, because with
RFC5424 messages can be much longer and RFC5425 now recommends a
minimum maximum size of 8K.

So we let users to choose. Maybe we need a sensible default value to
make users' lifes easier?

Also, the old non-vector based interface is not supported anymore. I
broke it already when moving to this stage.
---
 plugins/omoracle/omoracle.c | 46 ++++++++++++++++++++++++++++-----------------
 1 file changed, 29 insertions(+), 17 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 3a1f141f..d6349d89 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -21,6 +21,13 @@
     $OmoracleBatchSize: Number of elements to send to the DB on each
     transaction.
 
+    $OmoracleBatchItemSize: Number of characters each property may
+    have. Make it as big as the longest value you expect for *any*
+    property in the sentence. For instance, if you expect 5 arguments
+    to the statement, 4 have 10 bytes and the 5th may be up to 3KB,
+    then specify $OmoracleBatchItemSize 3072. Please, remember to
+    leave space to the trailing \0!!
+
     $OmoracleStatement: Statement to be prepared and executed in
     batches. Please note that Oracle's prepared statements have their
     placeholders as ':identifier', and this module uses the colon to
@@ -89,6 +96,8 @@ struct oracle_batch
 	int n;
 	/* Number of arguments the statement takes */
 	int arguments;
+	/** Maximum size of each parameter */
+	int param_size;
 	/* Parameters to pass to the statement on this transaction */
 	char*** parameters;
 	/* Binding parameters */
@@ -125,12 +134,10 @@ static char* db_user;
 static char* db_password;
 /** Batch size. */
 static int batch_size;
+/** Size of each element in the batch. */
+static int batch_item_size;
 /** Statement to prepare and execute */
 static char* db_statement;
-/** Whether or not the core supports the newer array interface. The
- * module is able to work in both modes, but the newer is the
- * recommended one for performance reasons. */
-static int array_passing;
 
 /** Generic function for handling errors from OCI.
 
@@ -248,8 +255,7 @@ static int prepare_statement(instanceData* pData)
 			 OCIBindByPos(pData->statement,
 				      pData->batch.bindings+i,
 				      pData->error, i+1, NULL,
-				      MAX_BUFSIZE *
-				      sizeof ***pData->batch.parameters,
+				      pData->batch.param_size,
 				      SQLT_STR, NULL, NULL, NULL,
 				      0, 0,  OCI_DATA_AT_EXEC));
 		CHECKERR(pData->error,
@@ -290,6 +296,7 @@ CODESTARTcreateInstance
 
 	pData->batch.n = 0;
 	pData->batch.size = batch_size;
+	pData->batch.param_size = batch_item_size * sizeof ***pData->batch.parameters;
 	pData->batch.arguments = count_bind_parameters(pData->txt_statement);
 
 	/* I know, this can be done with a single malloc() call but this is
@@ -302,15 +309,14 @@ CODESTARTcreateInstance
 						    sizeof **pData->batch.parameters);
 		CHKmalloc(pData->batch.parameters[i]);
 		for (j = 0; j < pData->batch.size; j++) {
-			/* Each entry has at most MAX_BUFSIZE bytes
-			 * because OCI doesn't like null-terminated
-			 * strings when operating with batches, and
-			 * the maximum size of each entry must be
-			 * provided when binding
-			 * parameters. MAX_BUFSIZE is long enough for
-			 * usual entries. */
-			pData->batch.parameters[i][j] = calloc(MAX_BUFSIZE,
-							       sizeof ***pData->batch.parameters);
+			/* Each entry has at most
+			 * pData->batch.param_size bytes because OCI
+			 * doesn't like null-terminated strings when
+			 * operating with batches, and the maximum
+			 * size of each entry must be provided when
+			 * binding parameters. pData->batch.param_size
+			 * is long enough for usual entries. */
+			pData->batch.parameters[i][j] = malloc(pData->batch.param_size);
 			CHKmalloc(pData->batch.parameters[i][j]);
 		}
 	}
@@ -480,7 +486,7 @@ CODESTARTdoAction
 	for (i = 0; i < pData->batch.arguments && params[i]; i++) {
 		dbgprintf("batch[%d][%d]=%s\n", i, pData->batch.n, params[i]);
 		strncpy(pData->batch.parameters[i][pData->batch.n], params[i],
-			MAX_BUFSIZE);
+			pData->batch.param_size);
 		CHKmalloc(pData->batch.parameters[i][pData->batch.n]);
 	}
 	pData->batch.n++;
@@ -520,6 +526,7 @@ resetConfigVariables(uchar __attribute__((unused)) *pp,
 	if (db_statement != NULL)
 		free(db_statement);
 	db_name = db_user = db_password = db_statement = NULL;
+	batch_size = batch_item_size = 0;
 	RETiRet;
 }
 
@@ -549,6 +556,7 @@ CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "resetconfigvariables", 1,
 				   eCmdHdlrCustomHandler, resetConfigVariables,
 				   NULL, STD_LOADABLE_MODULE_ID));
+
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoracledbuser", 0,
 				   eCmdHdlrGetWord, NULL, &db_user,
 				   STD_LOADABLE_MODULE_ID));
@@ -563,11 +571,15 @@ CODEmodInit_QueryRegCFSLineHdlr
 				   STD_LOADABLE_MODULE_ID));
 	CHKiRet(pHostQueryEtryPt((uchar*)"OMSRgetSupportedTplOpts", &supported_options));
 	CHKiRet((*supported_options)(&opts));
-	if (!(array_passing = opts & OMSR_TPL_AS_ARRAY))
+	if (!(opts & OMSR_TPL_AS_ARRAY))
 		ABORT_FINALIZE(RS_RET_RSCORE_TOO_OLD);
 
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclestatement", 0,
 				   eCmdHdlrCustomHandler, get_db_statement,
 				   &db_statement, STD_LOADABLE_MODULE_ID));
 
+	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclebatchitemsize", 0,
+				   eCmdHdlrInt, NULL,
+				   &batch_item_size, STD_LOADABLE_MODULE_ID));
+
 ENDmodInit
-- 
cgit v1.2.3


From c35ce31aed4d873ed9564332374fbf82d7ff187d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Tue, 28 Apr 2009 21:14:52 +0200
Subject: Replace get_db_statement by a template.

Instead of reading a complete line, we'll use a template and delegate
in the core to read such template. Then, all omoracle has to do is to
find that template and use it as the prepared statement.

I'm not sure if this is the correct approach, though. It has to dig
too much into rsyslog's structures...

txt_statement is stored in a private area, so that we don't mess too
much with rsyslog's internals (I still don't feel comfortable with
this much digging into template structures).
---
 plugins/omoracle/omoracle.c | 38 +++++++++++++-------------------------
 1 file changed, 13 insertions(+), 25 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index d6349d89..d1b3b955 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -28,10 +28,11 @@
     then specify $OmoracleBatchItemSize 3072. Please, remember to
     leave space to the trailing \0!!
 
-    $OmoracleStatement: Statement to be prepared and executed in
-    batches. Please note that Oracle's prepared statements have their
-    placeholders as ':identifier', and this module uses the colon to
-    guess how many placeholders there will be.
+    $OmoracleStatementTemplate: Name of the template containing the
+    statement to be prepared and executed in batches. Please note that
+    Oracle's prepared statements have their placeholders as
+    ':identifier', and this module uses the colon to guess how many
+    placeholders there will be.
 
     All these directives are mandatory. The dbstring can be an Oracle
     easystring or a DB name, as present in the tnsnames.ora file.
@@ -273,6 +274,7 @@ finalize_it:
 /* Resource allocation */
 BEGINcreateInstance
 	int i, j;
+	struct template* tpl;
 CODESTARTcreateInstance
 
 	ASSERT(pData != NULL);
@@ -289,14 +291,16 @@ CODESTARTcreateInstance
 	CHECKENV(pData->environment,
 		 OCIHandleAlloc(pData->environment, (void*) &(pData->statement),
 				OCI_HTYPE_STMT, 0, NULL));
-	pData->txt_statement = strdup(db_statement);
+	tpl = tplFind(db_statement, strlen(db_statement));
+	pData->txt_statement = strdup(tpl->pEntryRoot->data.constant.pConstant);
 	CHKmalloc(pData->txt_statement);
 	dbgprintf("omoracle will run stored statement: %s\n",
 		  pData->txt_statement);
 
 	pData->batch.n = 0;
 	pData->batch.size = batch_size;
-	pData->batch.param_size = batch_item_size * sizeof ***pData->batch.parameters;
+	pData->batch.param_size = batch_item_size *
+		sizeof ***pData->batch.parameters;
 	pData->batch.arguments = count_bind_parameters(pData->txt_statement);
 
 	/* I know, this can be done with a single malloc() call but this is
@@ -439,7 +443,6 @@ finalize_it:
 BEGINisCompatibleWithFeature
 CODESTARTisCompatibleWithFeature
 	/* Right now, this module is compatible with nothing. */
-	dbgprintf ("***** OMORACLE ***** At isCompatibleWithFeature\n");
 	iRet = RS_RET_INCOMPATIBLE;
 ENDisCompatibleWithFeature
 
@@ -465,6 +468,7 @@ CODE_STD_STRING_REQUESTparseSelectorAct(1);
 	CHKiRet(createInstance(&pData));
 	CHKmalloc(pData->connection = strdup(db_name));
 	CHKiRet(startSession(pData, db_name, db_user, db_password));
+
 	CHKiRet(prepare_statement(pData));
 
 	dbgprintf ("omoracle module got all its resources allocated "
@@ -530,22 +534,6 @@ resetConfigVariables(uchar __attribute__((unused)) *pp,
 	RETiRet;
 }
 
-/** As I don't find any handler that reads an entire line, I write my
- * own. */
-static int get_db_statement(char** line, char** stmt)
-{
-	DEFiRet;
-
-	while (isspace(**line))
-		(*line)++;
-	dbgprintf ("Config line: %s\n", *line);
-	*stmt = strdup(*line);
-	CHKmalloc(*stmt);
-	dbgprintf ("Statement: %s\n", *stmt);
-finalize_it:
-	RETiRet;
-}
-
 BEGINmodInit()
 	rsRetVal (*supported_options)(unsigned long *pOpts);
 	unsigned long opts;
@@ -574,8 +562,8 @@ CODEmodInit_QueryRegCFSLineHdlr
 	if (!(opts & OMSR_TPL_AS_ARRAY))
 		ABORT_FINALIZE(RS_RET_RSCORE_TOO_OLD);
 
-	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclestatement", 0,
-				   eCmdHdlrCustomHandler, get_db_statement,
+	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclestatementtemplate", 0,
+				   eCmdHdlrGetWord, NULL,
 				   &db_statement, STD_LOADABLE_MODULE_ID));
 
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclebatchitemsize", 0,
-- 
cgit v1.2.3


From 9823c73d1d07e50e6bec7f7c02c88d61d6955526 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luis=20Fernando=20Mu=C3=B1oz=20Mej=C3=ADas?=
 <Luis.Fernando.Munoz.Mejias@cern.ch>
Date: Tue, 28 Apr 2009 21:14:53 +0200
Subject: Make it recover from errors on insertions.

If the database rejected some entry, making the statement fail on it,
the batch was not cleaned and the same values were retried over and
over, causing a cascade of failures and a denial of service.

We use now OCI_BATCH_ERRORS so that everything valid in the batch is
inserted, and rejected values can be discarded.
---
 plugins/omoracle/omoracle.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'plugins/omoracle/omoracle.c')

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index d1b3b955..331b7dd4 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -342,13 +342,12 @@ static int insert_to_db(instanceData* pData)
 		 OCIStmtExecute(pData->service,
 				pData->statement,
 				pData->error,
-				pData->batch.n, 0, NULL, NULL, OCI_DEFAULT));
+				pData->batch.n, 0, NULL, NULL,
+				OCI_BATCH_ERRORS));
 
-	CHECKERR(pData->error,
-		 OCITransCommit(pData->service, pData->error, 0));
-
-	pData->batch.n = 0;
 finalize_it:
+	pData->batch.n = 0;
+	OCITransCommit(pData->service, pData->error, 0);
 	dbgprintf ("omoracle insertion to DB %s\n", iRet == RS_RET_OK ?
 		   "succeeded" : "did not succeed");
 	RETiRet;
-- 
cgit v1.2.3