Splitted plugin/eurephiadb_session.[ch] into two parts

One part is a generic session handling part
(common/eurephiadb_session_common.[ch]) and the other part
is left in the old plugin/eurephiadb_session.[ch].

This splitting should make it easiser to reuse some of the session
handling functions for the admin utils.

1 files changed, 128 insertions, 0 deletions

diff --git a/common/eurephiadb_session_common.c b/common/eurephiadb_session_common.c
new file mode 100644
index 0000000..8fdcbc1
--- /dev/null
+++ b/common/eurephiadb_session_common.c
@@ -0,0 +1,128 @@
+/* eurephiadb_session_common.c  --  Common function for handling sessions
+ *
+ *  GPLv2 - Copyright (C) 2008  David Sommerseth <dazo@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; version 2
+ *  of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <openssl/rand.h>
+
+#include <eurephia_nullsafe.h>
+#include <eurephia_context.h>
+#include <eurephia_log.h>
+#include <eurephia_values.h>
+#include <eurephiadb_session_struct.h>
+#include <eurephiadb_session_common.h>
+
+
+// Functions needed to be found in the database driver
+extern int eDBstore_session_value(eurephiaCTX *ctx, eurephiaSESSION *session, int mode,
+                                  const char *key, const char *val);
+
+
+// Adds or updates a key in the eurephiaVALUES stack.  Database is updated before the stack is updated.
+// If database fails, the stack is not updated.
+int eDBset_session_value(eurephiaCTX *ctx, eurephiaSESSION *session, const char *key, const char *val) {
+        eurephiaVALUES *svals = NULL;
+
+        if( (session == NULL) || (key == NULL) ) {
+                return 0;
+        }
+
+        DEBUG(ctx, 30, "Function call: eDBset_session_value(ctx, '%s','%s','%s')",
+              session->sessionkey, key, val);
+
+        // Create a new session value buffer if it does not exist
+        if( session->sessvals == NULL ) {
+                session->sessvals = eCreate_value_space(ctx, 10);
+                if( session->sessvals == NULL ) {
+                        eurephia_log(ctx, LOG_PANIC, 0, "Could not allocate memory for session values");
+                        return 0;
+                }
+        }
+
+        // Check if the session value exists already.  If it does update it, or else add it
+        svals = eGet_valuestruct(session->sessvals, key);
+        if( (svals == NULL) && (val != NULL) ) {
+                DEBUG(ctx, 32, "eDBset_session_value ... New session value: %s = '%s'", key, val);
+                // Add a new session value
+                if( eDBstore_session_value(ctx, session, SESSVAL_NEW, key, val) ) {
+                        DEBUG(ctx, 32, "eDBset_session_value ... Adding value to value stack: %s = '%s'",
+                              key, val);
+                        // Add value to the stack
+                        eAdd_value(ctx, session->sessvals, key, val);
+
+                        DEBUG(ctx, 32, "Registered session variable to session '%s': %s = %s",
+                              session->sessionkey, key, val);
+                }
+        } else if( svals != NULL ) {
+                if( (val != NULL) && (strcmp(svals->val, val) == 0) ) {
+                        DEBUG(ctx, 32, "Session value not changed('%s','%s','%s)",
+                              session->sessionkey, key, val);
+                        return 1;
+                }
+                // Update the value in the stack if database is updated without errors
+                if( eDBstore_session_value(ctx, session,(val != NULL ? SESSVAL_UPDATE : SESSVAL_DELETE), key,val)){
+                        free_nullsafe(svals->val);
+                        svals->val = strdup_nullsafe(val);
+                        DEBUG(ctx, 32, "Session variable updated in session '%s': %s = %s",
+                              session->sessionkey, key, val);
+                }
+        } else if( (svals == NULL) && (val == NULL ) ) {
+                DEBUG(ctx, 32, "Ignoring saving new session value '%s' == NULL", key);
+        }
+        return 1;
+}
+
+
+// Generate some random data and return a string.
+static int rand_init = 0;
+int eDBsessionGetRandString(eurephiaCTX *ctx, char *rndstr, int len) {
+        int attempts = 0;
+        do {
+                if( !rand_init ) {
+                        if( !RAND_load_file("/dev/urandom", 64) ) {
+                                eurephia_log(ctx, LOG_FATAL, 0, "Could not load random data from /dev/urandom");
+                                return 0;
+                        }
+                        rand_init = 1;
+                }
+
+                if( RAND_pseudo_bytes((unsigned char *) rndstr, len) ) {
+                        return 1;
+                }
+                sleep(1);
+                rand_init = 0;
+        } while( attempts++ < 11 );
+        eurephia_log(ctx, LOG_FATAL, 0, "RAND_pseudo_bytes() could not generate enough random data");
+        return 0;
+}
+
+
+// Free up the memory used by a session structure
+void eDBfree_session_func(eurephiaCTX *ctx, eurephiaSESSION *session) {
+        if( session == NULL ) {
+                return;
+        }
+        DEBUG(ctx, 12, "Function call: eDBfree_session(ctx, '%s')", session->sessionkey);
+        eFree_values(ctx, session->sessvals);
+        free_nullsafe(session->sessionkey);
+        free_nullsafe(session);
+}