src/midgard.c

/* $Id: midgard.c,v 1.137 2006/10/12 11:07:07 piotras Exp $
 *
 * midgard-lib: database access for Midgard clients
 *
 * Copyright (C) 1999 Jukka Zitting <jukka.zitting@iki.fi>
 * Copyright (C) 2000 The Midgard Project ry
 * Copyright (C) 2003 David Schmitter, Dataflow Solutions GmbH <schmitt@dataflow.ch>
 * Copyright (C) 2003-2004 Alexander Bokovoy <ab@altlinux.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this library; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <config.h>
#include "midgard/midgard_connection.h"
#include "midgard/authfailure.h"
#include "defaults.h"
#include "fmt_russian.h"
#include "midgard/midgard_quota.h"
#if HAVE_CRYPT_H
# include <crypt.h>
#else
# define _XOPEN_SOURCE
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#ifdef WIN32
# include <windows.h>
#endif
#include <glib.h>
#include <ctype.h>
#ifndef WIN32
# include <unistd.h>
#endif
#include <signal.h>

#ifdef WIN32
# include <process.h>
# include "win32/flock.h"
# include "win32/win95nt.h"
#else
# include <sys/utsname.h>
# include <sys/file.h>
# include <sys/wait.h>
# include <netdb.h>
#endif

#include <sys/stat.h>

#if HAVE_MIDGARD_VC
# include <sys/time.h>
#endif

#ifndef MAXHOSTNAMELEN
# define MAXHOSTNAMELEN 255
#endif

#ifndef G_LOG_DOMAIN
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN="midgard-core"
#endif

#include "midgard_mysql.h"
#include "midgard/midgard_legacy.h"

static FILE *_log_file = NULL;

void mgd_log_debug_none(const gchar *domain, GLogLevelFlags level,
      const gchar *msg, gpointer userdata)
{
}

void mgd_log_debug_default(const gchar *domain, GLogLevelFlags level,
      const gchar *msg, gpointer userdata)
{
   int fno;
   guint mlevel = (guint) userdata;
   gchar *level_ad = NULL;

   switch (level) {
      case G_LOG_FLAG_RECURSION:
         level_ad =  "RECURSION"; 
         break;

      case G_LOG_FLAG_FATAL:
         level_ad = "FATAL! ";
         break;

      case G_LOG_LEVEL_ERROR:
         level_ad =  "ERROR";
         break;

      case G_LOG_LEVEL_CRITICAL:
         level_ad = "CRITICAL ";
         break;

      case G_LOG_LEVEL_WARNING:
         level_ad =  "WARNING";
         break;

      case G_LOG_LEVEL_MESSAGE:
         level_ad = "m";
         break;

      case G_LOG_LEVEL_INFO:
         level_ad = "info";
         break;

      case G_LOG_LEVEL_DEBUG:
         level_ad = "debug";
         break;

      default:
         /* Should never happen , default log level should be set 
          * in midgard_config_init when unknown defined */
         level_ad =  "Unknown level";
         break;
   }

   if (mlevel >= level) {
       
       if (_log_file == NULL) _log_file = stderr;
       fno = fileno(_log_file);

       if (fno != 2) flock(fno, LOCK_EX);

       fprintf(_log_file, "%s ", domain != NULL ? domain : "midgard-core");
       /* I am not sure if we need pid */
       fprintf(_log_file, "(pid:%ld):", (unsigned long)getpid()); 
   
       fprintf(_log_file, "(%s):", level_ad);
       fprintf(_log_file, "  %s\n", msg);
       
       fflush(_log_file);
       if (fno != 2) flock(fno, LOCK_UN);
   }
}

void mgd_init()
{
   mgd_init_ex(0, NULL);
}

guint mgd_parse_log_levels(const char *levels)
{
   const char *c;
   guint mask = 0;
   int level = 0;

   for (c = levels; *c != '\0'; ) {
      /* skip over non-text */
      if (!isalpha(*c)) { c++; continue; }

      /* first char determines log level */
      switch (tolower(*c)) {
         /*[eeh]  I don't think we're supposed to offer these as log
          * level flags
            case 'r': level = G_LOG_FLAG_RECURSION; break;
            case 'f': level = G_LOG_FLAG_FATAL; break;
         */
         case 'e': level = G_LOG_LEVEL_ERROR; break;
         case 'c': level = G_LOG_LEVEL_CRITICAL; break;
         case 'w': level = G_LOG_LEVEL_WARNING; break;
         case 'm': level = G_LOG_LEVEL_MESSAGE; break;
         case 'i': level = G_LOG_LEVEL_INFO; break;
         case 'd': level = G_LOG_LEVEL_DEBUG; break;
         default: level = 4; break;
      }

      /* skip over rest of 'word' */
      for (c++; *c != '\0' && isalpha(*c); c++) {}

      /* last word was garbage, ignore, maybe we should log this */
      if (level == 0) continue;

      /* select single log level */
      if (*c == '+') {
         mask |= level;
         continue;
      }

      /* select loglevel and all higher loglevels */
      for (; level && level > G_LOG_FLAG_FATAL; level >>= 1) {
         mask |= level;
      }
      
   }

   return mask;
}

void mgd_init_ex(guint log_levels, char *logname)
{
        if (mgd_parser_list())
                return;
        /* MySQL expects utf8 instead of utf-8. 
         * latin1 instead of iso-8859-1.
         */     
        (void) mgd_parser_create("latin1", "latin1", 1);
        (void) mgd_parser_init_raw("russian", "KOI8-R");
        (void) mgd_parser_init_raw("utf-8", "UTF-8");

        if (logname == NULL) {
                _log_file = stderr;
        } else {
                _log_file = fopen(logname, "a");
                if (_log_file == NULL) {
                        _log_file = stderr;
                        g_log("midgard-core", G_LOG_LEVEL_WARNING,
                                        "Could not open logfile '%s', using stderr", logname);
                }
        }
}

void mgd_done()
{
        mgd_parser_free_all();
}

const char *mgd_version()
{
        return MIDGARD_LIB_VERSION;
}

midgard *mgd_setup()
{
        midgard *mgd;
        /* create midgard handle */
        mgd = g_new(midgard, 1);
        if (!mgd)
                return NULL;

        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->current_user = &mgd->user_at_pagestart;
        
        mgd->user_at_pagestart.id = 0;
        mgd->setuid_user.id = 0;
        mgd->user_at_pagestart.is_admin = 0;
        mgd->setuid_user.is_admin = 0;
        mgd->user_at_pagestart.is_root = 0;
        mgd->setuid_user.is_root = 0;
        mgd->user_at_pagestart.sitegroup = 0;
        mgd->setuid_user.sitegroup = 0;
        mgd->user_at_pagestart.member_of = NULL;
        mgd->setuid_user.member_of = NULL;

        mgd->username = NULL;

        mgd->parser = mgd_parser_list(); 

        mgd->msql = g_new(midgard_mysql, 1);
        mgd->msql->mysql = NULL;
        mgd->blobdir = NULL;

        mgd->ah_prefix = NULL;
        mgd->auth_type = MGD_AUTHTYPE_NORMAL;

#if HAVE_MIDGARD_MULTILANG
        mgd->lang = 0;
        mgd->default_lang = 0;
        mgd->a_lang = 0;
        mgd->p_lang = 0;
#endif /* HAVE_MIDGARD_MULTILANG */

#if HAVE_MIDGARD_VC
        mgd->cvs_script = NULL;
#endif /* HAVE_MIDGARD_VC */

#if HAVE_MIDGARD_QUOTA
        mgd->quota = 0;
        mgd->quota_err = 0;
        mgd->qlimits = g_hash_table_new(g_str_hash, g_str_equal);
#endif /* HAVE_MIDGARD_QUOTA */

        mgd->loglevel = mgd_parse_log_levels("warn");
        mgd->logfile = NULL;
        mgd->loghandler = 0;
        mgd->person = NULL;
        mgd->schema = NULL;
        mgd->err = NULL;
        /* UGLY WORKAROUND TO AVOID LEGACY API USAGE */
        mgd->_mgd = midgard_connection_new();
        mgd->_mgd->mgd = mgd;   
        mgd->pamfile = "midgard";
        
        return mgd;
}

void mgd_set_authtype(midgard *mgd, midgard_auth_type authtype)
{
        mgd->auth_type = authtype;
}

void mgd_easy_connect(midgard *mgd, const char *host, const char *database,
      const char *user, const char *password)
{
        int connected;

        /* create mysql connection handle */
        mgd->msql->mysql = mysql_init(NULL);

        /* Set the correct character encoding, UTF-8 by default. Note */
        /* that Midgard uses "utf-8" where MySQL uses "utf8".         */
        if (mgd->msql->mysql != NULL) 
                mysql_options(mgd->msql->mysql, MYSQL_SET_CHARSET_NAME, "utf8");
        

   /* connect to the database */
   connected = mgd->msql->mysql &&
      mysql_real_connect(mgd->msql->mysql, host,
         user, password, database, 0, NULL, 0);

        if (!mgd->msql->mysql || !connected) {
      /* EEH/TODO: I know this is ugly but we need this info.
         There will be proper logging at some point
      */
      g_warning(" %s@%s://%s connection failed: %s",
            user, host, database,
            mgd->msql->mysql ? mysql_error(mgd->msql->mysql) : "<mysql server not found?>");

                if (mgd->msql->mysql) mysql_close(mgd->msql->mysql);
      mgd->msql->mysql = NULL;
   }
}

midgard *mgd_connect(const char *hostname, const char *database,
             const char *username, const char *password)
{
midgard *mgd = mgd_setup();

if (mgd == NULL)
        return NULL;

/* use default values if none specified */
if (!hostname)
        hostname = MGD_MYSQL_HOST;
if (!username)
        username = MGD_MYSQL_USERNAME;
if (!password)
        password = MGD_MYSQL_PASSWORD;
if (!database)
        database = MGD_MYSQL_DATABASE;

/* create mysql connection handle */
mgd_easy_connect(mgd, hostname, database, username, password);

if (!mgd->msql->mysql) {
        mgd_free_pool(mgd->tmp);
        mgd_free_pool(mgd->pool);
        free(mgd);
        return NULL;
}

return mgd;
}



void mgd_close(midgard * mgd)
{
assert(mgd);
mgd_clear(mgd, MGD_CLEAR_ALL);

if (mgd->msql->mysql) {
        mysql_close(mgd->msql->mysql);
mgd->msql->mysql = NULL;
}

if (mgd->user_at_pagestart.member_of != NULL)
free(mgd->user_at_pagestart.member_of);
if (mgd->setuid_user.member_of != NULL)
free(mgd->setuid_user.member_of);

mgd_free_pool(mgd->tmp);
mgd_free_pool(mgd->pool);
free(mgd);
}


int mgd_select_db(midgard * mgd, const char *database)
{
int errcode;

assert(mgd);
assert(database);

if ((errcode = mysql_select_db(mgd->msql->mysql, database)) == 0) return 1;

g_log("midgard-lib", G_LOG_LEVEL_ERROR,
 "Midgard: mgd_select_db(%s) failed: %s (%d)\n",
              database, mysql_error(mgd->msql->mysql), errcode);
return 0;
}

int mgd_assert_db_connection(midgard *mgd, const char *hostname, const char *database,
const char* username, const char *pass)
{
void (*handler) (int);

handler=signal(SIGPIPE, SIG_IGN);

/* EEH: ensure that the link did not die, from PHPs mysql connector */
#if defined(CR_SERVER_GONE_ERROR)
mysql_stat(mgd->msql->mysql);
if (mysql_errno(mgd->msql->mysql) == CR_SERVER_GONE_ERROR) {
#else
if (!strcasecmp(mysql_stat(mgd->msql->mysql), "mysql server has gone away")) {
#endif
        mysql_close(mgd->msql->mysql);
sleep(1);
mgd_easy_connect(mgd, hostname, database, username, pass);
}

signal(SIGPIPE, handler);
return (mgd->msql->mysql != NULL);
}

#ifdef HAVE_LIBPAM

#ifdef HAVE_SECURITY_PAM_APPL_H
#include <security/pam_appl.h>
#endif
/* Mac OS X puts PAM headers into /usr/include/pam, not /usr/include/security */
#ifdef HAVE_PAM_PAM_APPL_H
#include <pam/pam_appl.h>
#endif

typedef struct {
char *username;
char *password;
} _midgard_pam_appdata;

static int _midgard_pam_conv(int num_msg, const struct pam_message **msg, 
                struct pam_response **resp, void *appdata_ptr)
{
        _midgard_pam_appdata *appdata = (_midgard_pam_appdata*) appdata_ptr;
        int i = 0, j = 0;

        if (num_msg && msg && *msg && resp && appdata_ptr) {
                *resp = malloc(sizeof(struct pam_response)*num_msg);
                if (*resp) {
                        /* Process conversation and fill in results */
                        for(; i < num_msg; i++) {
                                (*resp)[i].resp_retcode = 0;
                                (*resp)[i].resp = NULL;
                                switch((*msg)[i].msg_style) {
                                        
                                        case PAM_PROMPT_ECHO_ON: /* username */
                                                (*resp)[i].resp = strdup(appdata->username);
                                                break;
                                        
                                        case PAM_PROMPT_ECHO_OFF: /* password */
                                                (*resp)[i].resp = strdup(appdata->password);
                                                break;
                                }

                                /* If there was an error during strdup(), 
                                 * clean up already allocated  structures and return PAM_CONV_ERR */
                                if (!(*resp)[i].resp) {
                                        for(j = i; j >= 0 ; j--) {
                                                if ((*resp)[j].resp)
                                                        free((*resp)[j].resp);
                                        }
                                        free(*resp);
                                        *resp = NULL;
                                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, 
                                                        "Return PAM_CONV_ERROR due to strdup() failure");
                                        return PAM_CONV_ERR;
                                }
                        }
                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Return PAM_SUCCESS");
                        return PAM_SUCCESS;
                }
        }
        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Return PAM_CONV_ERROR");
        return PAM_CONV_ERR;
}
#endif

#define MGD_USERNAME_MAXLEN 80

static int mgd_auth_su(midgard * mgd, const char *username,
                       const char *password, int su, int setuid, int trusted)
{
        midgard_res *res;
        int i;
        const char *cipher, *passwd;
        int host_sitegroup, req_sitegroup, admingroup;
        char *sitegroup;
        int rootuser = 0;
        char delim = '+';
        int grant;
        char *reauth = NULL;    

        assert(mgd);

        if (mgd->msql->mysql == NULL)
                return MGD_AUTH_NOT_CONNECTED;

        host_sitegroup = mgd->current_user->sitegroup;
        mgd_clear(mgd, MGD_CLEAR_BASE);

        if (setuid) {
                mgd->current_user = &mgd->setuid_user;
                mgd_clear(mgd, MGD_CLEAR_BASE);
                mgd->current_user->sitegroup = host_sitegroup;
        }

        /* anonymous */
        if (!username || !*username) {
                return MGD_AUTH_ANONYMOUS;
        }

        if (strlen(username) > MGD_USERNAME_MAXLEN)
                return MGD_AUTH_INVALID_NAME;

#define MIDGARD_LOGIN_SG_ROOT_SEP "*!$"

#define MIDGARD_LOGIN_SG_ROOT_ROOT      '*'
#define MIDGARD_LOGIN_SG_ROOT_ADMIN     '!'
#define MIDGARD_LOGIN_SG_ROOT_USER      '$'
#define MIDGARD_LOGIN_SG_ADMIN_USER     ';'
#define MIDGARD_LOGIN_SG_USER_USER      '+'
#define MIDGARD_LOGIN_SG_REAUTH         '='

        gchar *uname = g_strdup(username);
        
        sitegroup = strpbrk(uname, MIDGARD_LOGIN_SG_SEPARATOR);

        if (sitegroup) {
                delim = *sitegroup;
                *sitegroup = '\0';
                sitegroup++;
                rootuser = (strchr(MIDGARD_LOGIN_SG_ROOT_SEP, delim) != NULL);

                if (rootuser && !*sitegroup) return MGD_AUTH_SG_NOTFOUND;
        
        } else if (host_sitegroup == 0) {
                delim = MIDGARD_LOGIN_SG_ROOT_ROOT;
                rootuser = 1;
        } else {
                delim = MIDGARD_LOGIN_SG_USER_USER;
                rootuser = 0;
        }

        reauth = strchr(uname, MIDGARD_LOGIN_SG_REAUTH);
        if (reauth) {
                *reauth = '\0';
                reauth++;
        }

        if ((su == 1) && (sitegroup || reauth)) {
                g_free(uname);
                return MGD_AUTH_REAUTH;
        }

        if (sitegroup && *sitegroup) {
                res =
                   mgd_ungrouped_select(mgd, "id,admingroup", "sitegroup",
                                        "name=$q", NULL, sitegroup);

                /* sitegroup must be found */
                if (!res || !mgd_fetch(res)) {
                        if (res)
                                mgd_release(res);
                        g_free(uname);
                        return MGD_AUTH_SG_NOTFOUND;
                }

                req_sitegroup = mgd_sql2id(res, 0);
                admingroup = mgd_sql2id(res, 1);
                mgd_release(res);
        }
        else {
                req_sitegroup = host_sitegroup;
                admingroup = 0;

                res =
                   mgd_ungrouped_select(mgd, "admingroup", "sitegroup",
                                        "id=$d", NULL, host_sitegroup);

                if (res) {
                        if (mgd_fetch(res))
                                admingroup = mgd_sql2id(res, 0);
                        mgd_release(res);
                }
        }

        if (rootuser) {
                res = mgd_ungrouped_select(mgd, "person.id,person.password",
                                           "person,member",
                                           "person.username=$q AND person.sitegroup=0"
                                           " AND member.uid = person.id AND member.gid=0",
                                           NULL, uname);
        }
        else {
                res = mgd_ungrouped_select(mgd, "id,password", "person",
                                           "username=$q AND sitegroup=$d",
                                           NULL, uname, req_sitegroup);
        }

        /* username not found */
        if (!res) {
                g_free(uname);
                return MGD_AUTH_NOTFOUND;
        }

        /* only one user may match */
        if (mgd_rows(res) != 1) {
      mgd_release(res);
                return MGD_AUTH_DUPLICATE;
        }

        /* username not found */
        if (!res) {
                g_free(uname);
                return MGD_AUTH_NOTFOUND;
        }

        while (mgd->current_user->id == 0 && mgd_fetch(res)) {
                
                switch(mgd->auth_type) {
                case MGD_AUTHTYPE_NORMAL:
                
                        /* Ugly workaround for compiler warning message.
                         * 'fallback' label is available in function scope , so 
                         * no warning should be thrown. */
                        if( 0 > 1)
                                goto fallback;

                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, 
                                        "Authentication type: NORMAL");
                        fallback:
                        passwd = mgd_colvalue(res, 1);

                        if (passwd[0] == '*' && passwd[1] == '*') {
                                passwd += 2;
                                cipher = password;
                        }
                        else
#ifdef WIN32
                                g_warning("crypt not supported on Win32");
#else
                        /* Conditional jump or move depends on uninitialised value(s) */        
                        cipher = (const char *)crypt(password, passwd);
#endif

                        if (
                                su || trusted ||
                                !strcmp(cipher, passwd))
                                mgd->current_user->id = mgd_sql2id(res, 0);
                        break;
#ifdef HAVE_LIBPAM
                case MGD_AUTHTYPE_PAM:
                        /* Authenticate against PAM source. We use predefined PAM service 'midgard' as auth source */
                        {
                                _midgard_pam_appdata appdata = {
                                        (char*) uname, 
                                        (char*) password
                                };
                                
                                struct pam_conv pconv = {
                                        _midgard_pam_conv,
                                        &appdata
                                };

                                pam_handle_t *phandle = NULL;
                                
                                int result = pam_start(mgd->pamfile, uname, &pconv, &phandle);
                                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, 
                                                "PAM start result: %d", result);
                                
                                if (result == PAM_SUCCESS) 
                                        result = pam_authenticate(phandle, 0);
                                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, 
                                                "PAM authenticate result: %d", result);
                                if (su || (result == PAM_SUCCESS)) {
                                        mgd->current_user->id = mgd_sql2id(res, 0);
                                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO,
                                                        "PAM auth was successful, new user id: %d", mgd->current_user->id);
                                }
                                result = pam_end(phandle, su ? PAM_SUCCESS : result);
                                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO,
                                                "PAM end result: %d", result);
                                if (mgd->current_user->id == 0) {
                                        /* Fallback to normal authentication */
                                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, 
                                                        "PAM auth was unsuccessful, going to normal auth");
                                        goto fallback;
                          }
                        }
                break;
#endif
                default:
                        g_error("Unsupported midgard authentication type %d", mgd->auth_type);
                }
        }

        mgd_release(res);

        if (mgd->current_user->id == 0) {
                g_free(uname);
                return MGD_AUTH_INVALID_PWD;
        }

        /* Get group information */
        res = mgd_ungrouped_select(mgd, "gid", "member",
                                   "uid=$i AND sitegroup in (0, $i)",
                                   "gid DESC", mgd->current_user->id, req_sitegroup);

        if (res) { 
                mgd->current_user->member_of = 
                        (int *) realloc(mgd->current_user->member_of,
                                        sizeof (int) * (mgd_rows(res) + 1));
                i = 0;
                while (mgd_fetch(res)) {
                        if ((mgd->current_user->member_of[i] = mgd_sql2id(res, 0)) != 0) {
                                if (mgd->current_user->member_of[i] == admingroup)
                                        mgd->current_user->is_admin = 1;
                                i++;
                        } else {
                                mgd->current_user->is_admin = 1;
                                mgd->current_user->is_root = 1;
                        }
                }

                mgd->current_user->member_of[i] = 0;
                mgd_release(res);
        }

        grant = (rootuser && mgd->current_user->is_root);
        if (!grant && !rootuser && !mgd->current_user->is_root) {
                if (host_sitegroup != 0 && req_sitegroup == host_sitegroup)
                        grant = 1;
                if (host_sitegroup == 0 && req_sitegroup != 0)
                        grant = 1;
        }

        if (!grant) {
                mgd_clear(mgd, MGD_CLEAR_BASE);
        }
        else {
                /* Change current sitegroup */
                mgd->current_user->sitegroup = req_sitegroup;
        }

        switch (delim) {
        case MIDGARD_LOGIN_SG_ROOT_USER:
        case MIDGARD_LOGIN_SG_ADMIN_USER:
                mgd->current_user->is_admin = 0;
        case MIDGARD_LOGIN_SG_ROOT_ADMIN:
                mgd->current_user->is_root = 0;
        }

        if (su == 1) {
                if (!grant || mgd->current_user->sitegroup == 0
            || !mgd->current_user->is_admin || !reauth) {
                        mgd_clear(mgd, MGD_CLEAR_BASE);
                }
                else {
                        /* this depends on mgd->sitegroup already being set */
                        mgd_auth_su(mgd, reauth, "", 1, 0, FALSE);
                }
        }

        /* schema and midgard_person check is done for repligard workaround
         * which doesn't use new configuration file */  
        if (mgd->schema != NULL ) {
                if(g_type_from_name("midgard_person") > 0){                     
                        MgdObject *pobject = midgard_object_new_by_id(mgd,
                                        "midgard_person",
                                        (gchar *) mgd->current_user->id);               
                        mgd->person = pobject;                  
                }
        }
        g_free(uname);
        return mgd->current_user->id;
}

int mgd_auth(midgard * mgd,
      const char *username, const char *password, int setuid)
{
        return mgd_auth_su(mgd, username, password, 0, setuid, FALSE);
}

int mgd_auth_trusted(midgard *mgd, const char *username) {
        /* TODO: The mgd_auth_su() method needs to be refactored.    */
        /* Until that is done, we just add *another* special         */
        /* argument to overload the default behaviour. Not good. :-( */
        return mgd_auth_su(mgd, username, NULL, 0, FALSE, TRUE);
}

int mgd_auth_is_setuid(midgard * mgd)
{
   return (mgd->current_user == &mgd->setuid_user);
}

MGD_API int mgd_auth_unsetuid(midgard * mgd, long int rsg)
{
  if (mgd->current_user == &mgd->user_at_pagestart) return 0;
  mgd->current_user = &mgd->user_at_pagestart;
  mgd->current_user->sitegroup = rsg;
  g_log("midgard-lib", G_LOG_LEVEL_DEBUG, "Unset for SG: %d", (int) rsg);
  return 1;
}

void mgd_clear(midgard * mgd, int clearflags)
{
        assert(mgd);

        /* clear user information */
        mgd->current_user->id = 0;
        mgd->current_user->is_admin = 0;
        mgd->current_user->is_root = 0;
   if (clearflags & MGD_CLEAR_SITEGROUP) { mgd->current_user->sitegroup = 0; }
        mgd->username = NULL;

        if (mgd->current_user->member_of != NULL)
           free(mgd->current_user->member_of);
        mgd->current_user->member_of = NULL;

        /* we automaticaly select first parser to avoid confusion */
        if (clearflags & MGD_CLEAR_PARSER) { mgd->parser = mgd_parser_list(); }

        /* clear resources reserved */
        while (mgd->res) mgd_release(mgd->res);

        mgd_clear_pool(mgd->pool);
}

int mgd_errno(midgard * mgd)
{
        assert(mgd);
        return mysql_errno(mgd->msql->mysql);
}

const char *mgd_error(midgard * mgd)
{
        assert(mgd);
        return mysql_error(mgd->msql->mysql);
}

int mgd_select_parser(midgard * mgd, const char *name)
{
        return mgd_parser_activate(mgd, name);
}

const char *mgd_get_parser_name(midgard * mgd)
{
        if (mgd && mgd->parser)
                return mgd->parser->name;
        return NULL;
}

const char *mgd_get_encoding(midgard * mgd)
{
        if (mgd && mgd->parser)
                return mgd->parser->encoding;
        return NULL;
}

int mgd_mail_need_qp(midgard * mgd)
{
        if (mgd && mgd->parser)
                return mgd->parser->need_qp;
        return 0;
}

void mgd_set_sitegroup(midgard * mgd, int sitegroup)
{
        assert(mgd);
        mgd->current_user->sitegroup = sitegroup;
}
int mgd_sitegroup(midgard * mgd)
{
        assert(mgd);
        return mgd->current_user->sitegroup;
}

int mgd_user(midgard * mgd)
{
        assert(mgd);
        return mgd->current_user->id;
}

int mgd_isauser(midgard * mgd)
{
        assert(mgd);
        return (mgd->current_user->id != 0);
}

int mgd_isadmin(midgard * mgd)
{
        assert(mgd);
        return mgd->current_user->is_admin;
}

int mgd_isroot(midgard * mgd)
{
        assert(mgd);
        return mgd->current_user->is_root;
}

void mgd_force_root(midgard * mgd)
{
        assert(mgd);
        mgd->current_user->is_root = 1;
        mgd->current_user->is_admin = 1;
        mgd->current_user->id = 0;
}

void mgd_force_admin(midgard * mgd)
{
        assert(mgd);
        mgd->current_user->is_admin = 1;
        mgd->current_user->id = 0;
}


#if HAVE_MIDGARD_MULTILANG
int mgd_lang(midgard * mgd)
{
        assert(mgd);
        return mgd->lang;
}

void mgd_set_default_lang(midgard *mgd, int lang)
{
        g_assert(mgd);
        mgd->default_lang = lang;
        mgd->lang = lang;
}

int mgd_get_default_lang(midgard *mgd)
{
        g_assert(mgd);
        return mgd->default_lang;
}

int mgd_parameters_defaultlang(midgard * mgd)
{
        assert(mgd);
        return mgd->p_lang;
}
int mgd_attachments_defaultlang(midgard * mgd)
{
        assert(mgd);
        return mgd->a_lang;
}

#endif /* HAVE_MIDGARD_MULTILANG */
int mgd_isuser(midgard * mgd, int user)
{
        assert(mgd);
        return (mgd->current_user->id == user);
}

int mgd_ismember(midgard * mgd, int group)
{
        int i;
   int *member_of;

        assert(mgd);

   member_of = mgd->current_user->member_of;

        if (member_of == NULL) return 0;

        for (i = 0; member_of[i]; i++) if (member_of[i] == group) return 1;

        return 0;
}

int *mgd_groups(midgard * mgd)
{
        return mgd->current_user->member_of;
}

midgard_res *mgd_query(midgard * mgd, const char *query, ...)
{
        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_pool *pool;
        MYSQL_RES *mres;
        int rv;
        char *fquery;
        assert(mgd);
        assert(query);
        
        if (mgd->msql->mysql == NULL)
                return NULL;

        /* format and send query */
        pool = mgd_alloc_pool();
        if (!pool)
                return NULL;
        fquery = mgd_vformat(mgd, pool, query, args);
        if (!fquery) {
                mgd_free_pool(pool);
                return NULL;
        }

        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", fquery);

        rv = mysql_query(mgd->msql->mysql, fquery);
        
        if (rv != 0) {
                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
                                "QUERY: \n"
                                "%s \n"
                                "FAILED: \n"
                                "%s", 
                                fquery, mysql_error(mgd->msql->mysql));
                return NULL;
        }

        g_free(fquery);
        mgd_free_pool(pool);
        
        /* get results */
        mres = mysql_store_result(mgd->msql->mysql);
        if (!mres)
                return NULL;
        if (mysql_num_rows(mres) == 0) {
                mysql_free_result(mres);
                return NULL;
        }
        /* create result handle */
        res = g_new(midgard_res, 1);
        if (!res) {
                mysql_free_result(mres);
                return NULL;
        }
        res->pool = mgd_alloc_pool();
        if (!res->pool) {
                free(res);
                mysql_free_result(mres);
                return NULL;
        }
        res->mgd = mgd;
        res->msql = g_new(midgard_mysql, 1);
        res->msql->res = mres;
        res->msql->row = NULL;
        res->rown = 0;
        res->rows = mysql_num_rows(mres);       
        res->cols = mysql_num_fields(mres);
        res->msql->fields = mysql_fetch_fields(mres);

        /* insert into result chain */
        if (mgd->res)
                mgd->res->prev = res;
        res->prev = NULL;
        res->next = mgd->res;
        mgd->res = res;

        return res;
}

midgard_res *mgd_ungrouped_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_ungrouped_vselect(mgd, fields, from, where, sort, args);
        va_end(args);
        return res;
}

midgard_res *mgd_sitegroup_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_sitegroup_vselect(mgd, fields, from, where, sort, args);
        va_end(args);
        return res;
}

midgard_res *mgd_ungrouped_vselect(midgard * mgd,
                                   const char *fields, const char *from,
                                   const char *where, const char *sort,
                                   va_list args)
{
        midgard_res *res;
        assert(fields && from);
        GString *query = g_string_new("SELECT ");
        
        /* format query */
        if (where)
                if (sort)
                        g_string_append_printf(query,
                                        "%s FROM %s WHERE %s ORDER BY %s",
                                        fields, from, where, sort);
                else
                        g_string_append_printf(query,
                                        "%s FROM %s WHERE %s",
                                        fields, from, where);
                
        else if (sort)
                g_string_append_printf(query,
                                "%s FROM %s ORDER BY %s",
                                fields, from, sort);
        else
                g_string_append_printf(query,
                                "%s FROM %s ",
                                fields, from);
                

        gchar *tmpstr = g_string_free(query, FALSE);
        /* execute query */
        res = mgd_vquery(mgd, tmpstr, args);
        g_free(tmpstr);

        return res;
}

/* EmHe: add support for named tables at some point */
char *mgd_sitegroup_clause(midgard * mgd, midgard_pool * pool,
                           const char *tables)
{
        char *table , *tmptable;
        const char *sgclause;

        if (mgd->current_user->is_root) {
                return g_strdup("");
        }

        
        tmptable = g_strdup(tables);
        table = strtok((gchar *)tmptable, " ,");        

        while (table && !*table)
                table = strtok(NULL, " ,");

        if (!table) {   
                return g_strdup("AND 0=1");
        }                       /* EmHe: this is an error */

#if HAVE_MIDGARD_MULTILANG
        if (!strstr(table, "_i")) {
#endif /* HAVE_MIDGARD_MULTILANG */
        sgclause = mgd_format(mgd, pool, "AND ($s.sitegroup in (0,$d)",
                              table, mgd->current_user->sitegroup);
#if HAVE_MIDGARD_MULTILANG
        } else {
          sgclause = mgd_strdup(pool, "1=1");
        }
#endif /* HAVE_MIDGARD_MULTILANG */

        if (!sgclause) {
                return g_strdup("AND 0=2");
        }                       /* EmHe: this is an error */

        for (table = strtok(NULL, " ,"); table; table = strtok(NULL, " ,")) {
                if (!*table)
                        continue;

#if HAVE_MIDGARD_MULTILANG
                if (!strstr(table, "_i")) {
#endif /* HAVE_MIDGARD_MULTILANG */
                sgclause =
                   mgd_format(mgd, pool, "$s AND $s.sitegroup in (0, $d)",
                              sgclause, table, mgd->current_user->sitegroup);
#if HAVE_MIDGARD_MULTILANG
                }
#endif /* HAVE_MIDGARD_MULTILANG */

                if (!sgclause) {
                        return g_strdup("AND 0=3");
                }               /* EmHe: this is an error */
        }
        
        g_free(table);
        return mgd_format(mgd, pool, "$s)", sgclause);
}

midgard_res *mgd_sitegroup_vselect(midgard * mgd,
                                   const char *fields, const char *from,
                                   const char *where, const char *sort,
                                   va_list args)
{
        midgard_res *res;
        const char *query;
        midgard_pool *pool;
        const char *sgclause;
        assert(fields && from);
        pool = mgd_alloc_pool();
        if (!pool)
                return NULL;

        sgclause = mgd_sitegroup_clause(mgd, pool, from);

        if (sort)
                query = mgd_format(mgd, pool,
                                   "SELECT $s FROM $s WHERE ($s) $s"
                                   " ORDER BY $s",
                                   fields, from, where ? where : "1=1",
                                   sgclause, sort);
        else
                query = mgd_format(mgd, pool,
                                   "SELECT $s FROM $s WHERE ($s) $s",
                                   fields, from, where ? where : "1=1",
                                   sgclause);

        g_free((gchar *)sgclause);
        
        if (!query) {
                mgd_free_pool(pool);
                return NULL;
        }

        /* execute query */
        res = mgd_vquery(mgd, query, args);
        g_free((gchar *)query);

        mgd_free_pool(pool);
        return res;
}

midgard_res *mgd_ungrouped_record(midgard * mgd,
                                  const char *fields, const char *table, int id)
{
        midgard_res *res;
        const char *query;
        midgard_pool *pool;
        pool = mgd_alloc_pool();
        if (!pool)
                return NULL;

        /* format query */
#if ! HAVE_MIDGARD_MULTILANG
        query = mgd_format(mgd, pool, "SELECT $s FROM $s WHERE id=$i",
                           fields, table, id);
#else /* HAVE_MIDGARD_MULTILANG */
        query = mgd_format(mgd, pool, "SELECT $s FROM $s WHERE $s.id=$i",
                           fields, table, table, id);
#endif /* HAVE_MIDGARD_MULTILANG */
        if (!query) {
                mgd_free_pool(pool);
                return NULL;
        }

        /* execute query */
        res = mgd_query(mgd, query);
        g_free((gchar *)query);

        mgd_free_pool(pool);
        return res;
}

midgard_res *mgd_sitegroup_record(midgard * mgd,
                                  const char *fields, const char *table, int id)
{
        midgard_res *res;
        const char *query;
        midgard_pool *pool;

        pool = mgd_alloc_pool();
        if (!pool)
                return NULL;

        /* format query */
        query = mgd_format(mgd, pool,
                           "SELECT $s,sitegroup FROM $s WHERE id=$i AND (sitegroup in (0, $d) OR $d<>0)",
                           fields, table, id,
            mgd->current_user->sitegroup,
            mgd->current_user->