set.c

   1   /********************************************************************\
   2   * BitlBee -- An IRC to other IM-networks gateway                     *
   3   *                                                                    *
   4   * Copyright 2002-2005 Wilmer van der Gaast and others                *
   5   \********************************************************************/
   6
   7 /* Some stuff to register, handle and save user preferences             */
   8
   9 /*
  10   This program is free software; you can redistribute it and/or modify
  11   it under the terms of the GNU General Public License as published by
  12   the Free Software Foundation; either version 2 of the License, or
  13   (at your option) any later version.
  14
  15   This program is distributed in the hope that it will be useful,
  16   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18   GNU General Public License for more details.
  19
  20   You should have received a copy of the GNU General Public License with
  21   the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
  22   if not, write to the Free Software Foundation, Inc., 59 Temple Place,
  23   Suite 330, Boston, MA  02111-1307  USA
  24 */
  25 #define BITLBEE_CORE
  26 #include "bitlbee.h"
  27
  28 /* Used to use NULL for this, but NULL is actually a "valid" value. */
  29 char *SET_INVALID = "nee";
  30
  31 set_t *set_add( set_t **head, const char *key, const char *def, set_eval eval, void *data )
  32 {
  33         set_t *s = set_find( head, key );
  34
  35         /* Possibly the setting already exists. If it doesn't exist yet,
  36            we create it. If it does, we'll just change the default. */
  37         if( !s )
  38         {
  39                 if( ( s = *head ) )
  40                 {
  41                         while( s->next ) s = s->next;
  42                         s->next = g_new0( set_t, 1 );
  43                         s = s->next;
  44                 }
  45                 else
  46                 {
  47                         s = *head = g_new0( set_t, 1 );
  48                 }
  49                 s->key = g_strdup( key );
  50         }
  51
  52         if( s->def )
  53         {
  54                 g_free( s->def );
  55                 s->def = NULL;
  56         }
  57         if( def ) s->def = g_strdup( def );
  58
  59         s->eval = eval;
  60         s->data = data;
  61
  62         return s;
  63 }
  64
  65 set_t *set_find( set_t **head, const char *key )
  66 {
  67         set_t *s = *head;
  68
  69         while( s )
  70         {
  71                 if( g_strcasecmp( s->key, key ) == 0 ||
  72                     ( s->old_key && g_strcasecmp( s->old_key, key ) == 0 ) )
  73                         break;
  74                 s = s->next;
  75         }
  76
  77         return s;
  78 }
  79
  80 char *set_getstr( set_t **head, const char *key )
  81 {
  82         set_t *s = set_find( head, key );
  83
  84         if( !s || ( !s->value && !s->def ) )
  85                 return NULL;
  86
  87         return set_value( s );
  88 }
  89
  90 int set_getint( set_t **head, const char *key )
  91 {
  92         char *s = set_getstr( head, key );
  93         int i = 0;
  94
  95         if( !s )
  96                 return 0;
  97
  98         if( sscanf( s, "%d", &i ) != 1 )
  99                 return 0;
 100
 101         return i;
 102 }
 103
 104 int set_getbool( set_t **head, const char *key )
 105 {
 106         char *s = set_getstr( head, key );
 107
 108         if( !s )
 109                 return 0;
 110
 111         return bool2int( s );
 112 }
 113
 114 int set_isvisible( set_t *set )
 115 {
 116         /* the default value is not stored in value, only in def */
 117         return !( ( set->flags & SET_HIDDEN ) ||
 118                   ( ( set->flags & SET_HIDDEN_DEFAULT ) &&
 119                     ( set->value == NULL ) ) );
 120 }
 121
 122 int set_setstr( set_t **head, const char *key, char *value )
 123 {
 124         set_t *s = set_find( head, key );
 125         char *nv = value;
 126
 127         if( !s )
 128                 /*
 129                 Used to do this, but it never really made sense.
 130                 s = set_add( head, key, NULL, NULL, NULL );
 131                 */
 132                 return 0;
 133
 134         if( value == NULL && ( s->flags & SET_NULL_OK ) == 0 )
 135                 return 0;
 136
 137         /* Call the evaluator. For invalid values, evaluators should now
 138            return SET_INVALID, but previously this was NULL. Try to handle
 139            that too if NULL is not an allowed value for this setting. */
 140         if( s->eval && ( ( nv = s->eval( s, value ) ) == SET_INVALID ||
 141                          ( ( s->flags & SET_NULL_OK ) == 0 && nv == NULL ) ) )
 142                 return 0;
 143
 144         if( s->value )
 145         {
 146                 g_free( s->value );
 147                 s->value = NULL;
 148         }
 149
 150         /* If there's a default setting and it's equal to what we're trying to
 151            set, stick with s->value = NULL. Otherwise, remember the setting. */
 152         if( !s->def || ( strcmp( nv, s->def ) != 0 ) )
 153                 s->value = g_strdup( nv );
 154
 155         if( nv != value )
 156                 g_free( nv );
 157
 158         return 1;
 159 }
 160
 161 int set_setint( set_t **head, const char *key, int value )
 162 {
 163         char s[24];     /* Not quite 128-bit clean eh? ;-) */
 164
 165         g_snprintf( s, sizeof( s ), "%d", value );
 166         return set_setstr( head, key, s );
 167 }
 168
 169 void set_del( set_t **head, const char *key )
 170 {
 171         set_t *s = *head, *t = NULL;
 172
 173         while( s )
 174         {
 175                 if( g_strcasecmp( s->key, key ) == 0 )
 176                         break;
 177                 s = (t=s)->next;
 178         }
 179         if( s )
 180         {
 181                 if( t )
 182                         t->next = s->next;
 183                 else
 184                         *head = s->next;
 185
 186                 g_free( s->key );
 187                 g_free( s->old_key );
 188                 g_free( s->value );
 189                 g_free( s->def );
 190                 g_free( s );
 191         }
 192 }
 193
 194 int set_reset( set_t **head, const char *key )
 195 {
 196         set_t *s;
 197
 198         s = set_find( head, key );
 199         if( s )
 200                 return set_setstr( head, key, s->def );
 201
 202         return 0;
 203 }
 204
 205 char *set_eval_int( set_t *set, char *value )
 206 {
 207         char *s = value;
 208
 209         /* Allow a minus at the first position. */
 210         if( *s == '-' )
 211                 s ++;
 212
 213         for( ; *s; s ++ )
 214                 if( !isdigit( *s ) )
 215                         return SET_INVALID;
 216
 217         return value;
 218 }
 219
 220 char *set_eval_bool( set_t *set, char *value )
 221 {
 222         return is_bool( value ) ? value : SET_INVALID;
 223 }
 224
 225 char *set_eval_list( set_t *set, char *value )
 226 {
 227         GSList *options = set->eval_data, *opt;
 228
 229         for( opt = options; opt; opt = opt->next )
 230                 if( strcmp( value, opt->data ) == 0 )
 231                         return value;
 232
 233         /* TODO: It'd be nice to show the user a list of allowed values,
 234                  but we don't have enough context here to do that. May
 235                  want to fix that. */
 236
 237         return NULL;
 238 }
 239
 240 char *set_eval_to_char( set_t *set, char *value )
 241 {
 242         char *s = g_new( char, 3 );
 243
 244         if( *value == ' ' )
 245                 strcpy( s, " " );
 246         else
 247                 sprintf( s, "%c ", *value );
 248
 249         return s;
 250 }
 251
 252 char *set_eval_oauth( set_t *set, char *value )
 253 {
 254         account_t *acc = set->data;
 255
 256         if( bool2int( value ) && strcmp( acc->pass, PASSWORD_PENDING ) == 0 )
 257                 *acc->pass = '\0';
 258
 259         return set_eval_bool( set, value );
 260 }