[prev in list] [next in list] [prev in thread] [next in thread]
List: midgard-dev
Subject: [midgard-dev] cvs: /midgard/lib midgard.c
From: hukka <midgard-dev () greywolves ! org>
Date: 1999-10-26 7:43:07
[Download RAW message or body]
hukka Tue Oct 26 10:43:07 1999 EDT
Modified files:
/midgard/lib midgard.c
Log:
Added Emiles fix for noexistant crypt.h
Index: midgard/lib/midgard.c
diff -u midgard/lib/midgard.c:1.13 midgard/lib/midgard.c:1.14
--- midgard/lib/midgard.c:1.13 Mon Aug 23 11:45:33 1999
+++ midgard/lib/midgard.c Thu Sep 16 13:12:31 1999
@@ -1,4 +1,4 @@
-/* $Id: midgard.c,v 1.13 1999/08/23 08:45:33 hukka Exp $
+/* $Id: midgard.c,v 1.14 1999/09/16 10:12:31 hukka Exp $
*
* midgard-lib: database access for Midgard clients
*
@@ -28,55 +28,55 @@
#define __USE_XOPEN /* to get crypt */
#include <unistd.h>
-const char *mgd_version()
+const char *midgard_version()
{
return VERSION;
}
/* ODBC support functions */
-int _midgard_execute_statement(midgard *mgd, const char *sql)
+int _midgard_execute_statement(Midgard *midgard, const char *sql)
{
SQLRETURN rv;
- SQLSMALLINT cols;
- long id;
- assert(mgd);
+ g_assert (midgard);
- rv = SQLExecDirect(mgd->statement, (char *) sql, SQL_NTS);
+ rv = SQLExecDirect(midgard->statement, (char *) sql, SQL_NTS);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return 0;
return 1;
}
-int _midgard_fetch(midgard *mgd)
+int _midgard_fetch(Midgard *midgard)
{
SQLRETURN rv;
- assert(mgd);
+ g_assert (midgard);
+ g_return_val_if_fail (midgard->statement, 0);
- rv = SQLFetch(mgd->statement);
+ rv = SQLFetch(midgard->statement);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return 0;
return 1;
}
-void _midgard_clear_statement(midgard *mgd)
+void _midgard_clear_statement(Midgard *midgard)
{
- assert(mgd);
+ g_assert (midgard);
+ g_return_if_fail (midgard->statement);
- SQLFreeStmt(mgd->statement, SQL_CLOSE);
- SQLFreeStmt(mgd->statement, SQL_RESET_PARAMS);
- SQLFreeStmt(mgd->statement, SQL_UNBIND);
+ SQLFreeStmt(midgard->statement, SQL_CLOSE);
+ SQLFreeStmt(midgard->statement, SQL_RESET_PARAMS);
+ SQLFreeStmt(midgard->statement, SQL_UNBIND);
}
-int _midgard_result_columns(midgard *mgd)
+int _midgard_result_columns(Midgard *midgard)
{
SQLRETURN rv;
SQLSMALLINT count;
- assert(mgd);
+ g_assert (midgard);
- rv = SQLNumResultCols(mgd->statement, &count);
+ rv = SQLNumResultCols(midgard->statement, &count);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return 0;
@@ -86,14 +86,14 @@
#define DATALEN 4096
static char databuf[DATALEN];
-const char *_midgard_column_name(midgard *mgd, int pos)
+const char *_midgard_column_name(Midgard *midgard, int pos)
{
SQLSMALLINT ind, a, c, d;
SQLUINTEGER b;
SQLCHAR *val;
SQLRETURN rv;
- rv = SQLDescribeCol(mgd->statement, pos,
+ rv = SQLDescribeCol(midgard->statement, pos,
databuf, DATALEN, &ind, &a, &b, &c, &d);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return NULL;
@@ -107,7 +107,7 @@
return val;
}
-const char *_midgard_column_value(midgard *mgd, int pos)
+const char *_midgard_column_value(Midgard *midgard, int pos)
{
SQLINTEGER ind;
char *val = NULL;
@@ -115,7 +115,7 @@
SQLRETURN rv;
do {
- rv = SQLGetData(mgd->statement, pos, SQL_C_CHAR,
+ rv = SQLGetData(midgard->statement, pos, SQL_C_CHAR,
databuf, DATALEN, &ind);
if ((rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
|| ind == SQL_NULL_DATA) {
@@ -144,12 +144,12 @@
return val;
}
-int _midgard_bind_parameter_int(midgard *mgd, int pos, int *val)
+int _midgard_bind_parameter_int(Midgard *midgard, int pos, int *val)
{
SQLRETURN rv;
- assert(mgd);
+ g_assert (midgard);
- rv = SQLBindParameter(mgd->statement, pos, SQL_PARAM_INPUT,
+ rv = SQLBindParameter(midgard->statement, pos, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, val, 0, NULL);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return 0;
@@ -157,13 +157,13 @@
return 1;
}
-int _midgard_bind_parameter_str(midgard *mgd, int pos, const char *str)
+int _midgard_bind_parameter_str(Midgard *midgard, int pos, const char *str)
{
SQLRETURN rv;
int len = strlen(str);
- assert(mgd);
+ g_assert (midgard);
- rv = SQLBindParameter(mgd->statement, pos, SQL_PARAM_INPUT,
+ rv = SQLBindParameter(midgard->statement, pos, SQL_PARAM_INPUT,
SQL_C_CHAR, SQL_CHAR, len, 0,
(SQLCHAR *) str, len, NULL);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
@@ -172,126 +172,165 @@
return 1;
}
-int _midgard_bind_column_long(midgard *mgd, int pos, long *val)
+int _midgard_bind_column_long(Midgard *midgard, int pos, long *val)
{
SQLRETURN rv;
- assert(mgd);
+ g_assert (midgard);
- rv = SQLBindCol(mgd->statement, pos, SQL_C_SLONG, val, 0, NULL);
+ rv = SQLBindCol(midgard->statement, pos, SQL_C_SLONG, val, 0, NULL);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return 0;
return 1;
}
-int _midgard_bind_column_str(midgard *mgd, int pos, char *str, int len)
+int _midgard_bind_column_str(Midgard *midgard, int pos, char *str, int len)
{
SQLRETURN rv;
- assert(mgd);
+ g_assert (midgard);
- rv = SQLBindCol(mgd->statement, pos, SQL_C_CHAR, str, len, NULL);
+ rv = SQLBindCol(midgard->statement, pos, SQL_C_CHAR, str, len, NULL);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO)
return 0;
return 1;
}
+
+Midgard *
+midgard_handle_new ()
+{
+ Midgard *midgard = (Midgard *) g_malloc0 (sizeof(Midgard));
+ if (!midgard) return NULL;
+
+ midgard->env = SQL_NULL_HENV;
+ midgard->dbc = SQL_NULL_HDBC;
+ midgard->statement = SQL_NULL_HSTMT;
+
+ return midgard;
+}
+
+gboolean
+midgard_handle_free (Midgard *midgard)
+{
+ g_return_val_if_fail (midgard, FALSE);
+ midgard_close (midgard);
+ g_free (midgard);
+ return TRUE;
+}
-midgard *mgd_connect(const char *database,
- const char *username, const char *password)
+gboolean
+midgard_connected (Midgard *midgard)
{
- midgard *mgd;
+ g_return_val_if_fail (midgard, FALSE);
+ return (midgard->env != SQL_NULL_HENV
+ && midgard->dbc != SQL_NULL_HDBC
+ && midgard->statement != SQL_NULL_HSTMT);
+}
+
+gboolean
+midgard_connect (Midgard *midgard, const char *database,
+ const char *username, const char *password)
+{
int rv;
+ g_return_val_if_fail (midgard, FALSE);
- /* create midgard handle */
- mgd = (midgard *) malloc(sizeof(struct midgard));
- if (!mgd) return NULL;
-
- mgd->env = SQL_NULL_HENV;
- mgd->dbc = SQL_NULL_HDBC;
- mgd->statement = SQL_NULL_HSTMT;
- mgd->res = NULL;
- mgd->pool = mgd_alloc_pool();
- if (!mgd->pool) { free(mgd); return NULL; }
- mgd->tmp = mgd_alloc_pool();
- if (!mgd->tmp) { mgd_free_pool(mgd->pool); free(mgd); return NULL; }
-
- mgd->user = mgd->admin = 0;
- mgd->member = NULL;
- mgd->username = mgd->name = NULL;
-
+ /* Make sure the connection is closed before opening a new one */
+ midgard_close (midgard);
+
/* create ODBC environment handle */
- rv = SQLAllocEnv(&mgd->env);
+ rv = SQLAllocEnv (&midgard->env);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO) {
- free(mgd);
- return NULL;
+ midgard->env = SQL_NULL_HENV;
+ return FALSE;
}
/* create ODBC connection handle */
- rv = SQLAllocConnect(mgd->env, &mgd->dbc);
+ rv = SQLAllocConnect (midgard->env, &midgard->dbc);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO) {
- SQLFreeEnv(mgd->env);
- free(mgd);
- return NULL;
+ SQLFreeEnv (midgard->env);
+ midgard->env = SQL_NULL_HENV;
+ midgard->dbc = SQL_NULL_HDBC;
+ return FALSE;
}
/* connect to the Midgard database */
- if (!database || !*database) database = MIDGARD_DATABASE;
- if (!username || !*username) username = MIDGARD_USERNAME;
- if (!password || !*password) password = MIDGARD_PASSWORD;
- rv = SQLConnect(mgd->dbc,
- (SQLCHAR *) database, SQL_NTS,
- (SQLCHAR *) username, SQL_NTS,
- (SQLCHAR *) password, SQL_NTS);
+ if (!database) database = MIDGARD_DATABASE;
+ if (!username) username = MIDGARD_USERNAME;
+ if (!password) password = MIDGARD_PASSWORD;
+ rv = SQLConnect (midgard->dbc,
+ (SQLCHAR *) database, SQL_NTS,
+ (SQLCHAR *) username, SQL_NTS,
+ (SQLCHAR *) password, SQL_NTS);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO) {
- SQLFreeConnect(mgd->dbc);
- SQLFreeEnv(mgd->env);
- free(mgd);
- return NULL;
+ SQLFreeConnect (midgard->dbc);
+ SQLFreeEnv (midgard->env);
+ midgard->env = SQL_NULL_HENV;
+ midgard->dbc = SQL_NULL_HDBC;
+ return FALSE;
}
/* create ODBC statement handle */
- rv = SQLAllocStmt(mgd->dbc, &mgd->statement);
+ rv = SQLAllocStmt (midgard->dbc, &midgard->statement);
if (rv != SQL_SUCCESS && rv != SQL_SUCCESS_WITH_INFO) {
- SQLDisconnect(mgd->dbc);
- SQLFreeConnect(mgd->dbc);
- SQLFreeEnv(mgd->env);
- free(mgd);
- return NULL;
+ SQLDisconnect (midgard->dbc);
+ SQLFreeConnect (midgard->dbc);
+ SQLFreeEnv (midgard->env);
+ midgard->env = SQL_NULL_HENV;
+ midgard->dbc = SQL_NULL_HDBC;
+ midgard->statement = SQL_NULL_HSTMT;
+ return FALSE;
}
- return mgd;
+ return TRUE;
}
-void mgd_close(midgard *mgd)
+gboolean midgard_close(Midgard *midgard)
{
- assert(mgd);
- mgd_clear(mgd);
- SQLFreeStmt(mgd->dbc, SQL_DROP);
- SQLDisconnect(mgd->dbc);
- SQLFreeConnect(mgd->dbc);
- SQLFreeEnv(mgd->env);
- mgd_free_pool(mgd->tmp);
- mgd_free_pool(mgd->pool);
- free(mgd);
+ g_return_val_if_fail (midgard, FALSE);
+
+ /* Clear caches and authentication information */
+ midgard_clear(midgard);
+
+ /* Disconnect and free ODBC handles */
+
+ if (midgard->statement != SQL_NULL_HSTMT) {
+ SQLFreeStmt (midgard->statement, SQL_DROP);
+ midgard->statement = SQL_NULL_HSTMT;
+ }
+
+ if (midgard->dbc != SQL_NULL_HDBC) {
+ SQLDisconnect (midgard->dbc);
+ SQLFreeConnect (midgard->dbc);
+ midgard->dbc = SQL_NULL_HDBC;
+ }
+
+ if (midgard->env != SQL_NULL_HENV) {
+ SQLFreeEnv (midgard->env);
+ midgard->env = SQL_NULL_HENV;
+ }
+
+ return TRUE;
}
#define FINDUSER "SELECT id,password FROM person WHERE username=?"
#define FINDGRPS "SELECT gid FROM member WHERE uid=?"
-int mgd_auth(midgard *mgd, const char *username, const char *password)
+gboolean
+midgard_auth (Midgard *midgard, const char *username, const char *password)
{
int i, n;
long id;
char *cipher;
char pwd[16];
- assert(mgd);
+ g_assert (midgard);
+ g_return_val_if_fail (midgard_connected (midgard), FALSE);
- /* Clear user information and release resources */
- mgd_clear(mgd);
+ /* Clear caches and authentication information */
+ midgard_clear (midgard);
/* Authenticate and get user information */
/* TODO: Should this be moved to the card module? */
- if (!username || !*username) return 0; /* anonymous */
+ if (!username || !*username) return TRUE; /* anonymous */
/* PART 1: Find the user with the given username and password.
* We search for a person record whose username field matches
@@ -299,516 +338,126 @@
* password or the password field is of the form '**XXXX' where
* 'XXXX' is the given password in plain text.
*/
- if (!_midgard_bind_parameter_str(mgd, 1, username)
- || !_midgard_bind_column_long(mgd, 1, &id)
- || !_midgard_bind_column_str(mgd, 2, pwd, sizeof(pwd))
- || !_midgard_execute_statement(mgd, FINDUSER)) {
- _midgard_clear_statement(mgd);
+ if (!_midgard_bind_parameter_str(midgard, 1, username)
+ || !_midgard_bind_column_long(midgard, 1, &id)
+ || !_midgard_bind_column_str(midgard, 2, pwd, sizeof(pwd))
+ || !_midgard_execute_statement(midgard, FINDUSER)) {
+ _midgard_clear_statement(midgard);
return 0;
}
- while (!mgd->user && _midgard_fetch(mgd)) {
+ while (!midgard->user && _midgard_fetch(midgard)) {
cipher = crypt(password, pwd);
if (!strcmp(cipher, pwd)
|| (!strncmp(pwd, "**", 2) && !strcmp(password, pwd+2)))
- mgd->user = id;
+ midgard->user = id;
}
- _midgard_clear_statement(mgd);
+ _midgard_clear_statement(midgard);
/* PART 2: List the groups the user belongs to.
* If a member record with the gid field containing zero is found,
* then the user is administrator.
*/
- if (!_midgard_bind_parameter_int(mgd, 1, &mgd->user)
- || !_midgard_bind_column_long(mgd, 1, &id)
- || !_midgard_execute_statement(mgd, FINDGRPS)) {
- _midgard_clear_statement(mgd);
- mgd->user = 0;
+ if (!_midgard_bind_parameter_int(midgard, 1, &midgard->user)
+ || !_midgard_bind_column_long(midgard, 1, &id)
+ || !_midgard_execute_statement(midgard, FINDGRPS)) {
+ _midgard_clear_statement(midgard);
+ midgard->user = 0;
return 0;
}
n = 16; i = 0;
- mgd->member = (int *) malloc(sizeof(int) * n);
- if (!mgd->member) {
- _midgard_clear_statement(mgd);
- mgd->user = 0;
+ midgard->member = (int *) malloc(sizeof(int) * n);
+ if (!midgard->member) {
+ _midgard_clear_statement(midgard);
+ midgard->user = 0;
return 0;
}
- while (_midgard_fetch(mgd))
+ while (_midgard_fetch(midgard))
if (id == 0)
- mgd->admin = 1;
+ midgard->admin = 1;
else {
- mgd->member[i++] = id;
+ midgard->member[i++] = id;
if (i == n) {
n *= 2;
- mgd->member = (int *)
- realloc(mgd->member, sizeof(int) * n);
- if (!mgd->member) {
- _midgard_clear_statement(mgd);
- mgd->user = 0;
+ midgard->member = (int *)
+ realloc(midgard->member, sizeof(int) * n);
+ if (!midgard->member) {
+ _midgard_clear_statement(midgard);
+ midgard->user = 0;
return 0;
}
}
}
- _midgard_clear_statement(mgd);
-
- return mgd->user;
-}
-
-void mgd_clear(midgard *mgd)
-{
- assert(mgd);
-
- /* clear user information */
- mgd->user = mgd->admin = 0;
- mgd->username = NULL;
- mgd->name = NULL;
- mgd->member = NULL;
-
- /* clear resources reserved */
- while (mgd->res)
- mgd_release(mgd->res);
-
- mgd_clear_pool(mgd->pool);
-}
+ _midgard_clear_statement(midgard);
-const char *mgd_error(midgard *mgd)
-{
- assert(mgd);
- return "";
-}
-
-int mgd_user(midgard *mgd)
-{
- assert(mgd);
- return mgd->user;
-}
-
-int mgd_isauser(midgard *mgd)
-{
- assert(mgd);
- return mgd->user != 0;
-}
-
-int mgd_isadmin(midgard *mgd)
-{
- assert(mgd);
- return mgd->admin != 0;
-}
-
-int mgd_isuser(midgard *mgd, int user)
-{
- assert(mgd);
- return mgd->user == user;
-}
-
-int mgd_ismember(midgard *mgd, int group)
-{
- int i;
- assert(mgd);
- if (!mgd->member) return 0;
- for (i = 0; mgd->member[i]; i++)
- if (mgd->member[i] == group) return 1;
- return 0;
-}
-
-int *mgd_groups(midgard *mgd)
-{
- return mgd->member;
+ return midgard->user;
}
-midgard_res *mgd_query(midgard *mgd, const char *query, ...)
+gboolean
+midgard_clear (Midgard *midgard)
{
- midgard_res *res;
- va_list args;
- va_start(args, query);
- res = mgd_vquery(mgd, query, args);
- va_end(args);
- return res;
-}
-
-midgard_res *mgd_vquery(midgard *mgd, const char *query, va_list args)
-{
- midgard_res *res;
- midgard_row *row;
- midgard_pool *pool;
- int i;
- const char *fquery;
- assert(mgd);
-
- /* format and send query */
- pool = mgd_alloc_pool();
- if (!pool) return NULL;
- fquery = mgd_vformat(pool, query, args);
- if (!fquery) { mgd_free_pool(pool); return NULL; }
- if (!_midgard_execute_statement(mgd, fquery)) {
- _midgard_clear_statement(mgd);
- mgd_free_pool(pool);
- return NULL;
- }
- mgd_free_pool(pool);
-
- /* create result handle */
- res = (midgard_res *) malloc(sizeof(struct midgard_res));
- if (!res) { _midgard_clear_statement(mgd); return NULL; }
- res->pool = mgd_alloc_pool();
- if (!res->pool) { free(res); _midgard_clear_statement(mgd); return NULL; }
- res->mgd = mgd;
- res->row = NULL;
- res->rown = 0;
- res->rows = 0;
- res->cols = _midgard_result_columns(mgd);
-
- res->res.next = NULL;
- res->res.cols = (const char **) malloc(sizeof(char *) * res->cols);
- if (!res->res.cols) {
- mgd_free_pool(res->pool);
- free(res);
- _midgard_clear_statement(mgd);
- return NULL;
- }
-
- /* insert into result chain */
- if (mgd->res) mgd->res->prev = res;
- res->prev = NULL;
- res->next = mgd->res;
- mgd->res = res;
-
- for (i = 1; i <= res->cols; i++) {
- res->res.cols[i-1] = _midgard_column_name(mgd, i);
- if (!res->res.cols[i-1]) {
- for (i--; i > 0; i--)
- free((char *) res->res.cols[i-1]);
- mgd_free_pool(res->pool);
- free(res);
- _midgard_clear_statement(mgd);
- return NULL;
- }
- }
-
- while (_midgard_fetch(mgd)) {
- row = (midgard_row *) malloc(sizeof(midgard_row));
- row->next = NULL;
- row->cols = (const char **) malloc(sizeof(char *) * res->cols);
- for (i = 1; i <= res->cols; i++) {
- row->cols[i-1] = _midgard_column_value(mgd, i);
- }
- res->rows++;
- if (!res->res.next)
- res->res.next = row;
- else
- res->row->next = row;
- res->row = row;
- }
- res->row = NULL;
- _midgard_clear_statement(mgd);
-
- return res;
-}
-
-midgard_res *mgd_select(midgard *mgd,
- const char *fields, const char *from,
- const char *where, const char *sort, ...)
-{
- midgard_res *res;
- va_list args;
- va_start(args, sort);
- res = mgd_vselect(mgd, fields, from, where, sort, args);
- va_end(args);
- return res;
-}
-
-midgard_res *mgd_vselect(midgard *mgd,
- const char *fields, const char *from,
- const char *where, const char *sort, va_list args)
-{
- midgard_res *res;
- const char *query;
- assert(fields && from);
-
- /* format query */
- if (where)
- if (sort)
- query = mgd_format(mgd->tmp,
- "SELECT $s FROM $s WHERE $s ORDER BY $s",
- fields, from, where, sort);
- else
- query = mgd_format(mgd->tmp, "SELECT $s FROM $s WHERE $s",
- fields, from, where);
- else
- if (sort)
- query = mgd_format(mgd->tmp, "SELECT $s FROM $s ORDER BY $s",
- fields, from, sort);
- else
- query = mgd_format(mgd->tmp, "SELECT $s FROM $s",
- fields, from);
- if (!query) return NULL;
-
- /* execute query */
- res = mgd_vquery(mgd, query, args);
-
- mgd_clear_pool(mgd->tmp);
- return res;
-}
-
-midgard_res *mgd_record(midgard *mgd,
- const char *fields, const char *table, int id)
-{
- midgard_res *res;
- const char *query;
-
- /* format query */
- query = mgd_format(mgd->tmp, "SELECT $s FROM $s WHERE id=$i",
- fields, table, id);
- if (!query) return NULL;
-
- /* execute query */
- res = mgd_query(mgd, query);
-
- mgd_clear_pool(mgd->tmp);
- return res;
-}
-
-int mgd_idfield(midgard *mgd, const char *field, const char *table, int id)
-{
- midgard_res *res;
- int rv;
-
- /* get record field */
- res = mgd_record(mgd, field, table, id);
- if (!res) return 0;
-
- /* get id value */
- if (mgd_fetch(res))
- rv = mgd_sql2id(res, 0);
- else
- rv = 0;
- mgd_release(res);
-
- return rv;
-}
-
-int mgd_exists(midgard *mgd, const char *from, const char *where, ...)
-{
- midgard_res *res;
- const char *query;
- va_list args;
- int id;
-
- /* format query */
- query = mgd_format(mgd->tmp, "SELECT id FROM $s WHERE $s", from, where);
- if (!query) return 0;
-
- /* execute query */
- va_start(args, where);
- res = mgd_vquery(mgd, query, args);
- va_end(args);
-
- mgd_clear_pool(mgd->tmp);
- if (!res) return 0;
-
- id = mgd_fetch(res) ? atoi(mgd_colvalue(res, 0)) : 0;
-
- mgd_release(res);
-
- return id;
-}
-
-int mgd_fetch(midgard_res *res)
-{
- assert(res);
- if (res->row) res->rown++;
- res->row = res->row ? res->row->next : res->res.next;
- if (!res->row) return 0;
- return 1;
-}
-
-void mgd_release(midgard_res *res)
-{
- int i;
- midgard_row *row;
- assert(res);
+ g_return_val_if_fail (midgard, FALSE);
- for (i = 0; i < res->cols; i++)
- if (res->res.cols[i])
- free((char *) res->res.cols[i]);
-
- while (res->res.next) {
- row = res->res.next;
- res->res.next = row->next;
- for (i = 0; i < res->cols; i++)
- if (row->cols[i])
- free((char *) row->cols[i]);
- free(row);
- }
-
- mgd_free_pool(res->pool);
- if (res->next)
- res->next->prev = res->prev;
- if (res->prev)
- res->prev->next = res->next;
- else
- res->mgd->res = res->next;
-
- free(res);
-}
-
-int mgd_rows(midgard_res *res)
-{
- assert(res);
- return res->rows;
-}
+ /* clear user information */
+ midgard->user = midgard->admin = 0;
+ midgard->username = NULL;
+ midgard->name = NULL;
+ midgard->member = NULL;
-int mgd_cols(midgard_res *res)
-{
- assert(res);
- return res->cols;
+ return TRUE;
}
-const char *mgd_colname(midgard_res *res, int i)
+const char *
+midgard_error(Midgard *midgard)
{
- assert(res);
- if (0 <= i && i < res->cols)
- return res->res.cols[i];
- else
- return NULL;
+ g_assert (midgard);
+ return "";
}
-const char *mgd_colvalue(midgard_res *res, int i)
+MidgardID
+midgard_user (Midgard *midgard)
{
- assert(res && res->row);
- if (0 <= i && i < res->cols)
- return res->row->cols[i];
- else
- return NULL;
+ g_return_val_if_fail (midgard, FALSE);
+ return midgard->user;
}
-const char *mgd_column(midgard_res *res, const char *name)
+gboolean
+midgard_isauser (Midgard *midgard)
{
- int i;
- for (i = 0; i < mgd_cols(res); i++)
- if (strcmp(mgd_colname(res, i), name) == 0)
- return mgd_colvalue(res, i);
- return NULL;
+ g_return_val_if_fail (midgard, FALSE);
+ return midgard->user != 0;
}
-int mgd_exec(midgard *mgd, const char *command, ...)
+gboolean
+midgard_isadmin (Midgard *midgard)
{
- int rv;
- va_list args;
- va_start(args, command);
- rv = mgd_vexec(mgd, command, args);
- va_end(args);
- return rv;
+ g_return_val_if_fail (midgard, FALSE);
+ return midgard->admin != 0;
}
-int mgd_vexec(midgard *mgd, const char *command, va_list args)
+gboolean
+midgard_isuser (Midgard *midgard, MidgardID user)
{
- int rv;
- char *fcommand;
- assert(mgd);
- assert(command);
-
- /* format and send command */
- fcommand = mgd_vformat(mgd->tmp, command, args);
- if (!fcommand) return 0;
- rv = _midgard_execute_statement(mgd, fcommand);
- _midgard_clear_statement(mgd);
-
- mgd_clear_pool(mgd->tmp);
- return rv;
+ g_return_val_if_fail (midgard, FALSE);
+ return midgard->user == user;
}
-
-int mgd_create(midgard *mgd, const char *table,
- const char *fields, const char *values, ...)
+gboolean
+midgard_ismember(Midgard *midgard, MidgardID group)
{
- int id;
- va_list args;
- va_start(args, values);
- id = mgd_vcreate(mgd, table, fields, values, args);
- va_end(args);
- return id;
-}
-
-int mgd_vcreate(midgard *mgd, const char *table,
- const char *fields, const char *values, va_list args)
-{
- const char *command;
- int rv;
- long id;
-
- /* format command */
- command = mgd_format(mgd->tmp,
- "INSERT INTO $s ($s) VALUES ($s)",
- table, fields, values);
- if (!command) return 0;
-
- /* execute command */
- rv = mgd_vexec(mgd, command, args);
- if (!rv) return 0;
-
- if (!_midgard_bind_column_long(mgd, 1, &id)
- || !_midgard_execute_statement(mgd, "SELECT last_insert_id()")) {
- _midgard_clear_statement(mgd);
- return 0;
- }
- if (!_midgard_fetch(mgd))
- id = 0;
- _midgard_clear_statement(mgd);
-
- mgd_clear_pool(mgd->tmp);
- return id;
-}
-
-int mgd_update(midgard *mgd, const char *table, int id,
- const char *fields, ...)
-{
- int rv;
- va_list args;
- va_start(args, fields);
- rv = mgd_vupdate(mgd, table, id, fields, args);
- va_end(args);
- return id;
-}
-
-int mgd_vupdate(midgard *mgd, const char *table, int id,
- const char *fields, va_list args)
-{
- const char *command;
- int rv;
-
- /* format command */
- command = mgd_format(mgd->tmp,
- "UPDATE $s SET $s WHERE id=$d",
- table, fields, id);
- if (!command) return 0;
-
- /* execute command */
- rv = mgd_vexec(mgd, command, args);
-
- mgd_clear_pool(mgd->tmp);
- return rv;
-}
-
-int mgd_delete(midgard *mgd, const char *table, int id)
-{
- const char *command;
- int rv;
-
- /* format command */
- command = mgd_format(mgd->tmp, "DELETE FROM $s WHERE id=$d", table, id);
- if (!command) return 0;
-
- /* execute command */
- rv = mgd_exec(mgd, command);
-
- mgd_clear_pool(mgd->tmp);
- return rv;
+ int i;
+ g_return_val_if_fail (midgard, FALSE);
+ if (!midgard->member) return FALSE;
+ for (i = 0; midgard->member[i]; i++)
+ if (midgard->member[i] == group) return TRUE;
+ return FALSE;
}
-int mgd_translate(const char *host, int port, const char *uri)
+int *
+midgard_groups (Midgard *midgard)
{
- return 0;
+ g_return_val_if_fail (midgard, NULL);
+ return midgard->member;
}
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic