src/config.c

00001 /* Midgard config files routine functions 
00002  *    
00003  * Copyright (C) 2005,2006 Piotr Pokora <pp@infoglob.pl>
00004  *        
00005  * This program is free software; you can redistribute it and/or modify it
00006  * under the terms of the GNU Lesser General Public License as published
00007  * by the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018  */
00019 
00020 #include <config.h>
00021 #include <stdio.h>
00022 #include <string.h>
00023 #include <glib-object.h>
00024 #include "midgard/types.h"
00025 #include "midgard/midgard_config.h"
00026 #include "midgard/parser.h"
00027 #include "fmt_russian.h"
00028 #include "midgard/midgard_datatypes.h"
00029 #include "src/midgard_core_object.h"
00030 
00031 /* Properties */
00032 enum {
00033         MIDGARD_CONFIG_DBTYPE = 1,
00034         MIDGARD_CONFIG_DBNAME, /* remove me */
00035         MIDGARD_CONFIG_DBUSER, /* remove me */
00036         MIDGARD_CONFIG_DBPASS, /* remove me */
00037         MIDGARD_CONFIG_HOST,
00038         MIDGARD_CONFIG_BLOBDIR,
00039         MIDGARD_CONFIG_LOGFILENAME,
00040         MIDGARD_CONFIG_SCHEMA,
00041         MIDGARD_CONFIG_DEFAULT_LANG,
00042         MIDGARD_CONFIG_LOGLEVEL,
00043         MIDGARD_CONFIG_TABLECREATE,
00044         MIDGARD_CONFIG_TABLEUPDATE,
00045         MIDGARD_CONFIG_LOGFILE,
00046         MIDGARD_CONFIG_TESTUNIT,
00047         MIDGARD_CONFIG_LOGHANDLER,
00048         MIDGARD_CONFIG_MGDUSERNAME,
00049         MIDGARD_CONFIG_MGDPASSWORD,
00050         MIDGARD_CONFIG_AUTHTYPE,
00051         MIDGARD_CONFIG_PAMFILE
00052 };
00053 
00054 static void
00055 _midgard_config_set_property (GObject *object, guint property_id,
00056                         const GValue *value, GParamSpec *pspec){
00057         
00058         MidgardConfig *self = (MidgardConfig *) object;
00059 
00060         switch (property_id) {
00061 
00062                 case MIDGARD_CONFIG_DBTYPE:
00063                         self->private->dbtype = g_value_get_uint(value);
00064                         break;
00065 
00066                 case MIDGARD_CONFIG_DBNAME:
00067                         g_free(self->private->database);
00068                         self->private->database = g_value_dup_string(value);
00069                         break;
00070 
00071                 case MIDGARD_CONFIG_DBUSER: 
00072                         g_free(self->private->dbuser);
00073                         self->private->dbuser = g_value_dup_string(value);
00074                         break;
00075 
00076                 case MIDGARD_CONFIG_DBPASS:
00077                         g_free(self->private->dbpass);
00078                         self->private->dbpass = g_value_dup_string(value);
00079                         break;
00080 
00081                 case MIDGARD_CONFIG_HOST:
00082                         g_free(self->private->host);
00083                         self->private->host = g_value_dup_string(value);
00084                         break;
00085 
00086                 case MIDGARD_CONFIG_BLOBDIR:
00087                         g_free(self->private->blobdir);
00088                         self->private->blobdir = g_value_dup_string(value);
00089                         break;
00090 
00091                 case MIDGARD_CONFIG_LOGFILENAME:
00092                         g_free(self->private->logfilename);
00093                         self->private->logfilename = g_value_dup_string(value);
00094                         break;
00095 
00096                 case MIDGARD_CONFIG_SCHEMA:
00097                         g_free(self->private->schemafile);
00098                         self->private->schemafile = g_value_dup_string(value);
00099                         break;
00100 
00101                 case MIDGARD_CONFIG_DEFAULT_LANG:
00102                         g_free(self->private->default_lang);
00103                         self->private->default_lang = g_value_dup_string(value);
00104                         break;
00105 
00106                 case MIDGARD_CONFIG_LOGLEVEL:
00107                         g_free(self->private->loglevel);
00108                         self->private->loglevel = g_value_dup_string(value);
00109                         break;
00110 
00111                 case MIDGARD_CONFIG_TABLECREATE:
00112                         self->private->tablecreate = g_value_get_boolean(value);
00113                         break;
00114 
00115                 case MIDGARD_CONFIG_TABLEUPDATE:
00116                         self->private->tableupdate = g_value_get_boolean(value);
00117                         break;
00118 
00119                 case MIDGARD_CONFIG_TESTUNIT:
00120                         self->private->testunit = g_value_get_boolean(value);
00121                         break;
00122 
00123                 case MIDGARD_CONFIG_LOGHANDLER:
00124                         self->private->loghandler = g_value_get_boolean(value);
00125                         break;
00126                 
00127                 case MIDGARD_CONFIG_MGDUSERNAME:
00128                         g_free(self->private->mgdusername);
00129                         self->private->mgdusername = g_value_dup_string(value);
00130                         break;
00131                         
00132                 case MIDGARD_CONFIG_MGDPASSWORD:
00133                         g_free(self->private->mgdpassword);
00134                         self->private->mgdpassword = g_value_dup_string(value);
00135                         break;
00136 
00137                 case MIDGARD_CONFIG_AUTHTYPE:
00138                         self->private->authtype = g_value_get_uint(value);
00139                         break;
00140 
00141                 case MIDGARD_CONFIG_PAMFILE:
00142                         g_free(self->private->pamfile);
00143                         self->private->pamfile = g_value_dup_string(value);
00144                         break;
00145 
00146                 default:
00147                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
00148                         break;
00149         }       
00150 }
00151 
00152 static void
00153 _midgard_config_get_property (GObject *object, guint property_id,
00154                 GValue *value, GParamSpec *pspec){
00155 
00156         MidgardConfig *self = (MidgardConfig *) object;
00157         
00158         switch (property_id) {
00159                 
00160                 case MIDGARD_CONFIG_DBTYPE:
00161                         g_value_set_uint(value, self->private->dbtype);
00162                         break;
00163         
00164                 case MIDGARD_CONFIG_DBNAME: /* remove me */
00165                         g_value_set_string (value, self->private->database);
00166                         break;
00167 
00168                 case MIDGARD_CONFIG_DBUSER: /* remove me */
00169                         g_value_set_string (value, self->private->dbuser);
00170                         break;
00171 
00172                 case MIDGARD_CONFIG_DBPASS: /* remove me */
00173                         g_value_set_string (value, self->private->dbpass);
00174                         break;
00175 
00176                 case MIDGARD_CONFIG_HOST:
00177                         g_value_set_string (value, self->private->host);
00178                         break;
00179 
00180                 case MIDGARD_CONFIG_BLOBDIR:
00181                         g_value_set_string (value, self->private->blobdir);
00182                         break;
00183 
00184                 case MIDGARD_CONFIG_LOGFILENAME:
00185                         g_value_set_string (value, self->private->logfilename);
00186                         break;
00187 
00188                 case MIDGARD_CONFIG_SCHEMA:
00189                         g_value_set_string (value, self->private->schemafile);
00190                         break;
00191 
00192                 case MIDGARD_CONFIG_DEFAULT_LANG:
00193                         g_value_set_string (value, self->private->default_lang);
00194                         break;
00195 
00196                 case MIDGARD_CONFIG_LOGLEVEL:
00197                         g_value_set_string(value, self->private->loglevel);
00198                         break;
00199 
00200                 case MIDGARD_CONFIG_TABLECREATE:
00201                         g_value_set_boolean (value, self->private->tablecreate);
00202                         break;
00203         
00204                 case MIDGARD_CONFIG_TABLEUPDATE:
00205                         g_value_set_boolean (value, self->private->tableupdate);
00206                         break;
00207 
00208                 case MIDGARD_CONFIG_TESTUNIT:
00209                         g_value_set_boolean (value, self->private->testunit);
00210                         break;
00211                 
00212                 case MIDGARD_CONFIG_LOGHANDLER:
00213                         g_value_set_uint(value, self->private->loghandler);
00214                         break;
00215                         
00216                 case MIDGARD_CONFIG_MGDUSERNAME:
00217                         g_value_set_string(value, self->private->mgdusername);
00218                         break;
00219                 
00220                 case MIDGARD_CONFIG_MGDPASSWORD:
00221                         g_value_set_string(value, self->private->mgdpassword);
00222                         break;
00223 
00224                 case MIDGARD_CONFIG_AUTHTYPE:
00225                         g_value_set_uint(value, self->private->authtype);
00226                         break;
00227 
00228                 case MIDGARD_CONFIG_PAMFILE:
00229                         g_value_set_string(value, self->private->pamfile);
00230                         break;
00231                         
00232                 default:
00233                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
00234                         break;
00235         }
00236 }
00237 
00238 static void 
00239 _midgard_config_finalize(GObject *object)
00240 {
00241 
00242         g_assert(object != NULL);
00243         
00244         MidgardConfig *self = (MidgardConfig *) object;
00245 
00246         if(self->private->mgdusername)
00247                 g_free(self->private->mgdusername);
00248         if(self->private->mgdpassword)
00249                 g_free(self->private->mgdpassword);
00250         if(self->private->host)
00251                 g_free(self->private->host);
00252         if(self->private->database)
00253                 g_free(self->private->database);
00254         if(self->private->dbuser)
00255                 g_free(self->private->dbuser);
00256         if(self->private->dbpass)
00257                 g_free(self->private->dbpass);
00258         if(self->private->blobdir)
00259                 g_free(self->private->blobdir);
00260         if(self->private->logfilename)
00261                 g_free(self->private->logfilename);
00262         if(self->private->schemafile)
00263                 g_free(self->private->schemafile);
00264         if(self->private->default_lang)
00265                 g_free(self->private->default_lang);
00266         if(self->private->loglevel)
00267                 g_free(self->private->loglevel);
00268         if(self->private->pamfile)
00269                 g_free(self->private->pamfile);
00270         
00271         g_free(self->private);
00272 
00273 }
00274 
00275 static void _midgard_config_class_init(
00276                 gpointer g_class, gpointer g_class_data)
00277 {
00278         GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
00279         MidgardConfigClass *klass = MIDGARD_CONFIG_CLASS (g_class);
00280         GParamSpec *pspec;
00281         
00282         gobject_class->set_property = _midgard_config_set_property;
00283         gobject_class->get_property = _midgard_config_get_property;
00284         gobject_class->finalize = _midgard_config_finalize;
00285                 
00286         klass->read_config = midgard_config_read_file;
00287         /* klass->connect = mgd_connect; */
00288 
00289         /* Register properties */
00290         pspec = g_param_spec_uint ("dbtype",
00291                         "",
00292                         "Database type",
00293                         0, G_MAXUINT32, 1, G_PARAM_READABLE);
00294         g_object_class_install_property (gobject_class,
00295                         MIDGARD_CONFIG_DBTYPE,
00296                         pspec);
00297         
00298         pspec = g_param_spec_string ("host",
00299                         "",
00300                         "Host name or IP",
00301                         "",
00302                         G_PARAM_READABLE);
00303         g_object_class_install_property (gobject_class,
00304                         MIDGARD_CONFIG_HOST,
00305                         pspec);
00306         
00307         pspec = g_param_spec_string ("database",
00308                         "",
00309                         "Remove me",
00310                         "",
00311                         G_PARAM_READABLE);
00312         g_object_class_install_property (gobject_class,
00313                         MIDGARD_CONFIG_DBNAME,
00314                         pspec);
00315 
00316         pspec = g_param_spec_string ("dbuser",
00317                         "",
00318                         "Remove me",
00319                         "",
00320                         G_PARAM_READABLE);
00321         g_object_class_install_property (gobject_class,
00322                         MIDGARD_CONFIG_DBUSER,
00323                         pspec);
00324 
00325         pspec = g_param_spec_string ("dbpass",
00326                         "",
00327                         "Remove me",
00328                         "",
00329                         G_PARAM_READABLE);
00330         g_object_class_install_property (gobject_class,
00331                         MIDGARD_CONFIG_DBPASS,
00332                         pspec);
00333 
00334         pspec = g_param_spec_string ("blobdir",
00335                         "",
00336                         "Location of the blobs directory",
00337                         "",
00338                         G_PARAM_READABLE);
00339         g_object_class_install_property (gobject_class,
00340                         MIDGARD_CONFIG_BLOBDIR,
00341                         pspec);
00342         
00343         pspec = g_param_spec_string ("logfilename",
00344                         "",
00345                         "Location of the log file",
00346                         "",
00347                         G_PARAM_READABLE);    
00348         g_object_class_install_property (gobject_class,
00349                         MIDGARD_CONFIG_LOGFILENAME,
00350                         pspec);
00351 
00352         pspec = g_param_spec_string ("schema",
00353                         "",  
00354                         "Location of the schema file",
00355                         "",
00356                         G_PARAM_READABLE);
00357         g_object_class_install_property (gobject_class,
00358                         MIDGARD_CONFIG_SCHEMA,
00359                         pspec);
00360 
00361         pspec = g_param_spec_string ("defaultlang",
00362                         "",  
00363                         "Default language",
00364                         "",
00365                         G_PARAM_READABLE);
00366         g_object_class_install_property (gobject_class,
00367                         MIDGARD_CONFIG_DEFAULT_LANG,
00368                         pspec);
00369         
00370         pspec = g_param_spec_string ("loglevel",
00371                         "warn",
00372                         "Log level",
00373                         "",
00374                         G_PARAM_READABLE);
00375         g_object_class_install_property (gobject_class,
00376                         MIDGARD_CONFIG_LOGLEVEL,
00377                         pspec);
00378 
00379         pspec = g_param_spec_boolean("tablecreate",
00380                         "",
00381                         "Database creation switch",
00382                         FALSE, G_PARAM_READABLE);
00383         g_object_class_install_property (gobject_class,
00384                         MIDGARD_CONFIG_TABLECREATE,
00385                         pspec);
00386 
00387         pspec = g_param_spec_boolean("tableupdate",
00388                         "",
00389                         "Database update switch",
00390                         FALSE, G_PARAM_READABLE);
00391         g_object_class_install_property (gobject_class,
00392                         MIDGARD_CONFIG_TABLEUPDATE,
00393                         pspec);
00394 
00395         pspec = g_param_spec_boolean("testunit",
00396                         "",
00397                         "Database and objects testing switch",
00398                         FALSE, G_PARAM_READABLE);
00399         g_object_class_install_property (gobject_class,
00400                         MIDGARD_CONFIG_TESTUNIT,
00401                         pspec);
00402 
00403         pspec = g_param_spec_uint ("loghandler",
00404                         "",
00405                         "GLib log handler",
00406                         0, G_MAXUINT32, 0, G_PARAM_READABLE);
00407         g_object_class_install_property (gobject_class,
00408                         MIDGARD_CONFIG_LOGHANDLER,
00409                         pspec);   
00410         
00411         pspec = g_param_spec_string ("midgardusername",
00412                         "admin",
00413                         "Midgard sitegroup person's username",
00414                         "",
00415                         G_PARAM_READABLE);
00416         g_object_class_install_property (gobject_class,
00417                         MIDGARD_CONFIG_MGDUSERNAME,
00418                         pspec);
00419         
00420         pspec = g_param_spec_string ("midgardpassword",
00421                         "password",
00422                         "Midgard sitegroup person's password",
00423                         "",                                                                                                        G_PARAM_READABLE);   
00424         g_object_class_install_property (gobject_class,
00425                         MIDGARD_CONFIG_MGDPASSWORD,
00426                         pspec);
00427 
00428         pspec = g_param_spec_string ("pamfile",
00429                         "midgard",
00430                         "Name of the file used with PAM authentication type",
00431                         "",                                                                                                        G_PARAM_READABLE);
00432         g_object_class_install_property (gobject_class,
00433                         MIDGARD_CONFIG_PAMFILE,
00434                         pspec);
00435         
00436         pspec = g_param_spec_uint ("authtype",
00437                         "",
00438                         "Authentication type used with connection.",
00439                         0, G_MAXUINT32, 0, G_PARAM_READABLE);
00440         g_object_class_install_property (gobject_class,
00441                         MIDGARD_CONFIG_AUTHTYPE,
00442                         pspec);         
00443 }
00444 
00445 static void _midgard_config_instance_init(
00446                 GTypeInstance *instance, gpointer g_class) 
00447 {
00448         MidgardConfig *self = (MidgardConfig *) instance;
00449         self->private = g_new(MidgardConfigPrivate, 1); 
00450 
00451         self->private->mgdusername = NULL;
00452         self->private->mgdpassword = NULL;
00453         self->private->host = NULL;
00454         self->private->database = NULL;
00455         self->private->dbuser = NULL;
00456         self->private->dbpass = NULL;
00457         self->private->blobdir = NULL;
00458         self->private->logfilename = NULL;
00459         self->private->schemafile = NULL;
00460         self->private->default_lang = NULL;
00461         self->private->loglevel = NULL;
00462         self->private->pamfile = NULL;
00463 
00464 }
00465 
00466 /* Register MidgardConfig type */
00467 GType 
00468 midgard_config_get_type (void)
00469 {
00470         static GType type = 0;
00471         if (type == 0) {
00472                 static const GTypeInfo info = {
00473                         sizeof (MidgardConfigClass),
00474                         NULL,           /* base_init */
00475                         NULL,           /* base_finalize */
00476                         (GClassInitFunc) _midgard_config_class_init,
00477                         NULL,           /* class_finalize */
00478                         NULL,           /* class_data */
00479                         sizeof (MidgardConfig),
00480                         0,              /* n_preallocs */
00481                         (GInstanceInitFunc) _midgard_config_instance_init/* instance_init */
00482                 };
00483                 type = g_type_register_static (G_TYPE_OBJECT,
00484                                 "midgard_config",
00485                                 &info, 0);
00486         }       
00487         return type;
00488 }
00489 
00490 MidgardConfig *midgard_config_new(void)
00491 {
00492         MidgardConfig *self = 
00493                 g_object_new(MIDGARD_TYPE_CONFIG, NULL);
00494         return self;
00495 }
00496 
00497 /* Read config file  */
00498 typedef struct 
00499 {
00500   gchar *confdir;
00501   gchar *blobdir;
00502   gchar *sharedir;
00503 
00504 }mdirs;
00505 
00506 /* Get configuration directory path.
00507  * We define this directory according to MIDGARD_LIB_PREFIX */
00508 
00509 static mdirs *_get_config_dir()
00510 {
00511   mdirs *iconf;
00512   GDir *dir;
00513 
00514   iconf = g_new(mdirs,1);
00515   
00516   if (g_ascii_strcasecmp(MIDGARD_LIB_PREFIX, "/usr") == 0 ) {
00517     /* Set typical FSH directory */
00518     iconf->confdir = g_strdup("/etc/midgard/conf.d");
00519     iconf->blobdir = g_strdup("/var/lib/midgard/blobs");
00520   } else {
00521     /* Set any directory which follows midgard prefix */
00522     iconf->confdir = g_strconcat( MIDGARD_LIB_PREFIX, "/", "etc/midgard/conf.d", NULL);
00523     iconf->blobdir = g_strconcat( MIDGARD_LIB_PREFIX, "/", "var/lib/midgard/blobs", NULL);
00524   }
00525   
00526   /* Set blobdir to /var/local when /usr/local was set as prefix */
00527   if (g_ascii_strcasecmp(MIDGARD_LIB_PREFIX, "/usr/local") == 0 ) {
00528     iconf->blobdir = g_strdup("/var/local/lib/midgard/blobs");
00529   }
00530 
00531   iconf->sharedir = g_strconcat( MIDGARD_LIB_PREFIX, "/", "share/midgard", NULL);
00532   
00533   dir = g_dir_open(iconf->confdir, 0, NULL);
00534   if (dir == NULL ) {
00535     /* No idea at this moment how to create this directory and copy example file
00536      * when midgard-core is installed 
00537      */ 
00538     g_log("midgard-lib", G_LOG_LEVEL_CRITICAL, "Unable to open %s directory" , iconf->confdir);
00539     return NULL;
00540   } else {
00541     g_dir_close(dir);
00542     return iconf;
00543   }
00544   return NULL;
00545 }
00546 
00547 
00548 /* Use this function when glib >= 2.6 will be available in all distros */
00549 /* 
00550 static midgard *_set_config_from_file(const gchar *name)
00551 {
00552   mdirs *iconf;
00553   const gchar *fname = NULL;
00554   GKeyFile *cfile;
00555   gchar *dbtype, *host, *dbname, *username, *password, *encoding, *blobdir, *schemafile;
00556   midgard *mgd;
00557 
00558   if ((iconf = _get_config_dir()) == NULL)
00559     return NULL;
00560   
00561   fname = g_strconcat(iconf->confdir, "/", name, NULL);
00562 
00563   cfile = g_key_file_new(); 
00564   
00565   if ((g_key_file_load_from_file (cfile, fname, G_KEY_FILE_NONE, NULL)) == FALSE) {
00566     g_log("midgard-lib", G_LOG_LEVEL_CRITICAL, "Unable to open %s configuration file" , fname);
00567     return NULL;
00568   }
00569 
00570   //Get database type 
00571   if ((dbtype = g_key_file_get_string(cfile, "Database", "Type", NULL)) == NULL )
00572     dbtype = "MySQL";
00573  
00574   // Get database host 
00575   if ((host = g_key_file_get_string(cfile, "Database", "Host", NULL)) == NULL )
00576     host = "localhost";
00577     
00578   // Get database name 
00579   if ((dbname = g_key_file_get_string(cfile, "Database", "Name", NULL)) == NULL )
00580     dbname = "midgard";
00581     
00582   // Get database username 
00583   username = g_key_file_get_string(cfile, "Database", "Username", NULL);
00584 
00585   // Get database user's password 
00586   password = g_key_file_get_string(cfile, "Database", "Password", NULL);
00587 
00588   // Get encoding 
00589   if ((encoding = g_key_file_get_string(cfile, "Database", "Encoding", NULL)) != NULL)
00590     encoding = "utf-8";
00591 
00592 
00593   // Get blobdir 
00594   if ((blobdir = g_key_file_get_string(cfile, "Database", "Blobdir", NULL)) == NULL )
00595     blobdir = g_strconcat(iconf->blobdir, "/", dbname, NULL);
00596     
00597 
00598   // Get Schema file 
00599   if ((schemafile = g_key_file_get_string(cfile, "Database", "Schema", NULL)) == NULL )
00600     schemafile = g_strconcat(iconf->sharedir, "/", "MgdObjects.xml", NULL);
00601 
00602   mgd_init();
00603 
00604   if ((mgd = mgd_connect(host, dbname, username, password)) != NULL) {
00605 
00606     mgd->blobdir = blobdir;
00607     mgd->schemafile = schemafile;
00608    
00609     //mgd_select_parser (mgd, encoding);
00610     mgd_select_parser(mgd, "russian");
00611     return mgd;
00612 
00613   }
00614   g_free(dbtype);
00615   g_free(dbname);
00616   g_free(username);
00617   g_free(password);
00618   g_free(encoding);
00619   g_free(blobdir);
00620   g_free(schemafile);
00621 
00622   return NULL;
00623 }
00624 */
00625 
00626 /* Workaround for g_key_file_get_string , we set all keys and values in GHashTable */
00627 
00628 static GHashTable *__get_hash_from_config_file(const gchar *fname)
00629 {
00630         gchar *content, **flines = NULL, **kval = NULL;
00631         gint ic = 0;
00632         GHashTable *chash;
00633         GError *err = NULL;
00634         
00635         if (g_file_get_contents(fname,  &content, NULL, &err) == FALSE) {
00636                 g_warning("%s", err->message);
00637                 g_error_free (err);
00638                 return NULL;
00639         }
00640         
00641         /* get file content line by line */ 
00642         flines = g_strsplit(content, "\n", -1);
00643         chash = midgard_hash_strings_new();
00644         
00645         while (flines[ic]) {
00646                 
00647                 /* This is our key=value entry */
00648                 if (g_strstr_len(flines[ic], strlen(flines[ic]), "=") != NULL) {
00649                         kval = g_strsplit(flines[ic], "=", -1);
00650                         g_hash_table_insert(chash, g_strdup((gchar*)kval[0]),
00651                                         g_strdup((gchar*)kval[1]));    
00652                         g_strfreev(kval);
00653                 }
00654                 ic++;
00655         }
00656         g_free(content);   
00657         g_strfreev(flines);
00658         
00659         return chash; 
00660 }
00661 
00662 gboolean midgard_config_read_file(MidgardConfig *self, const gchar *filename)
00663 {
00664         mdirs *iconf;
00665         gchar *fname = NULL;
00666         gchar  *testunit, *tmpstr, *tablecreate, *tableupdate;
00667         GHashTable *chash;
00668 
00669         g_assert(self != NULL);
00670         
00671         if ((iconf = _get_config_dir()) == NULL)
00672                 return FALSE;
00673 
00674         /* We get user's config file first */
00675         fname = g_build_path (G_DIR_SEPARATOR_S, 
00676                         g_get_home_dir(), ".midgard/conf.d", filename, NULL);
00677                         
00678         /* If user file doesn't exist we try to read from /etc */
00679         if (!g_file_test (fname, G_FILE_TEST_EXISTS)){
00680                 g_free(fname);
00681                 fname = g_strconcat(iconf->confdir, "/", filename, NULL);
00682         }
00683 
00684         chash = __get_hash_from_config_file(fname);
00685         g_free((gchar *)fname);
00686 
00687         if (chash == NULL) 
00688                 return FALSE;
00689 
00690         /* Get database type */
00691         if ((tmpstr = g_hash_table_lookup(chash, "Type")) == NULL)
00692                 tmpstr = "MySQL";
00693         self->private->dbtype = 1 ; /* FIXME */
00694         
00695         /* Get host name or IP */
00696         if ((tmpstr = g_hash_table_lookup(chash, "Host")) == NULL)
00697                 tmpstr = "localhost";
00698         self->private->host = g_strdup(tmpstr);
00699                         
00700         /* Get database name */
00701         if ((tmpstr = g_hash_table_lookup(chash, "Name")) == NULL)
00702                 tmpstr = "midgard";
00703         self->private->database = g_strdup(tmpstr);
00704         
00705         /* Get database's username */
00706         if ((tmpstr = g_hash_table_lookup(chash, "Username")) == NULL)
00707                 tmpstr = "midgard";
00708         self->private->dbuser = g_strdup(tmpstr);
00709         
00710         /* Get password for database user */
00711         if ((tmpstr = g_hash_table_lookup(chash, "Password")) == NULL)
00712                 tmpstr = "midgard";
00713         self->private->dbpass = g_strdup(tmpstr);
00714         
00715         /* Get default language */
00716         if ((tmpstr = g_hash_table_lookup(chash, "DefaultLanguage")) == NULL) {
00717                 tmpstr = "";
00718                 self->private->default_lang = NULL;
00719         } else {
00720                 self->private->default_lang = g_strdup(tmpstr);
00721         }
00722         
00723         /* Get blobs' path */
00724         if ((tmpstr = g_hash_table_lookup(chash, "Blobdir")) == NULL) {
00725                 tmpstr = g_strconcat(iconf->blobdir, "/", self->private->database, NULL);
00726                 self->private->blobdir = g_strdup(tmpstr);     
00727                 g_free(tmpstr);
00728         } else {
00729                 self->private->blobdir = g_strdup(tmpstr);
00730         }
00731         
00732         /* Get schema file */
00733         if ((tmpstr = g_hash_table_lookup(chash, "Schema")) == NULL){
00734                 tmpstr = NULL;
00735         } else {
00736                 if(g_ascii_strcasecmp(tmpstr, "") == 0) {
00737                         g_warning("Schema directive used , but no file defined. Using default Schema." );
00738                         tmpstr = NULL;
00739                 }
00740         }
00741         self->private->schemafile = g_strdup(tmpstr);
00742         
00743         /* Get log filename */
00744         if ((tmpstr = g_hash_table_lookup(chash, "Logfile")) == NULL)
00745                 tmpstr = NULL;
00746         self->private->logfilename = g_strdup(tmpstr);
00747         
00748         /* Get log level */
00749         if ((tmpstr = g_hash_table_lookup(chash, "Loglevel")) == NULL)
00750                 tmpstr = "warn";
00751         self->private->loglevel = g_strdup(tmpstr);
00752         
00753         /* Get database creation mode */
00754         if ((tablecreate = g_hash_table_lookup(chash, "TableCreate")) == NULL)
00755                 tablecreate = "false";
00756 
00757         /* Get database update mode */
00758         if ((tableupdate = g_hash_table_lookup(chash, "TableUpdate")) == NULL)
00759                 tableupdate = "false";  
00760 
00761         /* Get SG admin username */
00762         if ((tmpstr = g_hash_table_lookup(chash, "MidgardUsername")) == NULL)
00763                 tmpstr = NULL;
00764         self->private->mgdusername = g_strdup(tmpstr);
00765 
00766         /* Get SG admin password */
00767         if ((tmpstr = g_hash_table_lookup(chash, "MidgardPassword")) == NULL)
00768                 tmpstr = NULL;
00769         self->private->mgdpassword = g_strdup(tmpstr);
00770         
00771         /* Get test mode */
00772         if ((testunit = g_hash_table_lookup(chash, "TestUnit")) == NULL)
00773                 testunit = "false";
00774 
00775         /* FIXME, add trusted auth type and trigger error if unknown type 
00776          * was defined */
00777         /* Get auth type */
00778         if ((tmpstr = g_hash_table_lookup(chash, "AuthType")) == NULL) {
00779                 self->private->authtype = MGD_AUTHTYPE_NORMAL; 
00780         } else {
00781                 if(g_str_equal(tmpstr, "PAM"))
00782                         self->private->authtype = MGD_AUTHTYPE_PAM;
00783         }
00784 
00785         /* Get Pam file */
00786         if ((tmpstr = g_hash_table_lookup(chash, "PamFile")) == NULL) 
00787                 tmpstr = "midgard";
00788         self->private->pamfile = g_strdup(tmpstr);
00789 
00790         /* Set boolean from dbcreate value string */
00791         self->private->tablecreate = FALSE; 
00792         tmpstr = g_ascii_strdown(tablecreate, -1);
00793         if(g_str_equal(tmpstr, "true"))
00794                 self->private->tablecreate = TRUE;
00795         g_free(tmpstr);
00796 
00797         /* Set boolean from testunit value string */
00798         self->private->testunit = FALSE;
00799         tmpstr = g_ascii_strdown(testunit, -1);
00800         if(g_str_equal(tmpstr, "true"))
00801                 self->private->testunit = TRUE;
00802         g_free(tmpstr);                  
00803 
00804         /* Set boolean from dbupdate value string */
00805         self->private->tableupdate = FALSE;
00806         tmpstr = g_ascii_strdown(tableupdate, -1);
00807         if(g_str_equal(tmpstr, "true"))
00808                 self->private->tableupdate = TRUE;
00809         g_free(tmpstr);
00810 
00811         guint logspec = mgd_parse_log_levels(self->private->loglevel);
00812         mgd_init_ex(logspec, self->private->logfilename);
00813 
00814         g_hash_table_destroy(chash);
00815         g_free(iconf->confdir);
00816         g_free(iconf->blobdir);
00817         g_free(iconf->sharedir);
00818         g_free(iconf);
00819         
00820         return TRUE; 
00821 }
00822 
00823 midgard *midgard_config_init(gchar *filename)
00824 {
00825         /* FIXME , unref this object when we 
00826          * switch to midgard_config and midgard objects */
00827         MidgardConfig *config = g_object_new(MIDGARD_TYPE_CONFIG, NULL);
00828         
00829         if(!midgard_config_read_file(config, filename))
00830                 return NULL;
00831 
00832         midgard *mgd = mgd_connect(
00833                         config->private->host,
00834                         config->private->database,
00835                         config->private->dbuser,
00836                         config->private->dbpass);
00837 
00838         if(mgd == NULL) 
00839                 return NULL;
00840 
00841         mgd->logfile = NULL;    
00842         mgd->loglevel = mgd_parse_log_levels(config->private->loglevel);
00843         mgd->schemafile = g_strdup(config->private->schemafile);
00844         mgd->blobdir = g_strdup(config->private->blobdir);
00845         mgd->loghandler = g_log_set_handler(G_LOG_DOMAIN, mgd->loglevel,
00846                         mgd_log_debug_default, (gpointer)mgd);
00847         mgd->auth_type = config->private->authtype;
00848         mgd->pamfile = config->private->pamfile;
00849 
00850         return mgd;
00851 }
Generated on Thu Feb 22 06:15:14 2007 for midgard-core by  doxygen 1.4.6