source: set.c @ 3f81999

Last change on this file since 3f81999 was 673a54c, checked in by Sven Moritz Hallberg <pesco@…>, at 2009-03-12T19:33:28Z

pretty blind try at merging in the latest trunk
  • Property mode set to 100644
File size: 8.7 KB
Line 
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. */
29char *SET_INVALID = "nee";
30
31set_t *set_add( set_t **head, char *key, 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
65set_t *set_find( set_t **head, char *key )
66{
67        set_t *s = *head;
68       
69        while( s )
70        {
71                if( g_strcasecmp( s->key, key ) == 0 )
72                        break;
73                s = s->next;
74        }
75       
76        return s;
77}
78
79char *set_getstr( set_t **head, char *key )
80{
81        set_t *s = set_find( head, key );
82       
83        if( !s || ( !s->value && !s->def ) )
84                return NULL;
85       
86        return s->value ? s->value : s->def;
87}
88
89int set_getint( set_t **head, char *key )
90{
91        char *s = set_getstr( head, key );
92        int i = 0;
93       
94        if( !s )
95                return 0;
96       
97        if( sscanf( s, "%d", &i ) != 1 )
98                return 0;
99       
100        return i;
101}
102
103int set_getbool( set_t **head, char *key )
104{
105        char *s = set_getstr( head, key );
106       
107        if( !s )
108                return 0;
109       
110        return bool2int( s );
111}
112
113int set_setstr( set_t **head, char *key, char *value )
114{
115        set_t *s = set_find( head, key );
116        char *nv = value;
117       
118        if( !s )
119                /*
120                Used to do this, but it never really made sense.
121                s = set_add( head, key, NULL, NULL, NULL );
122                */
123                return 0;
124       
125        if( value == NULL && ( s->flags & SET_NULL_OK ) == 0 )
126                return 0;
127       
128        /* Call the evaluator. For invalid values, evaluators should now
129           return SET_INVALID, but previously this was NULL. Try to handle
130           that too if NULL is not an allowed value for this setting. */
131        if( s->eval && ( ( nv = s->eval( s, value ) ) == SET_INVALID ||
132                         ( ( s->flags & SET_NULL_OK ) == 0 && nv == NULL ) ) )
133                return 0;
134       
135        if( s->value )
136        {
137                g_free( s->value );
138                s->value = NULL;
139        }
140       
141        /* If there's a default setting and it's equal to what we're trying to
142           set, stick with s->value = NULL. Otherwise, remember the setting. */
143        if( !s->def || ( strcmp( nv, s->def ) != 0 ) )
144                s->value = g_strdup( nv );
145       
146        if( nv != value )
147                g_free( nv );
148       
149        return 1;
150}
151
152int set_setint( set_t **head, char *key, int value )
153{
154        char s[24];     /* Not quite 128-bit clean eh? ;-) */
155       
156        g_snprintf( s, sizeof( s ), "%d", value );
157        return set_setstr( head, key, s );
158}
159
160void set_del( set_t **head, char *key )
161{
162        set_t *s = *head, *t = NULL;
163       
164        while( s )
165        {
166                if( g_strcasecmp( s->key, key ) == 0 )
167                        break;
168                s = (t=s)->next;
169        }
170        if( s )
171        {
172                if( t )
173                        t->next = s->next;
174                else
175                        *head = s->next;
176               
177                g_free( s->key );
178                if( s->value ) g_free( s->value );
179                if( s->def ) g_free( s->def );
180                g_free( s );
181        }
182}
183
184int set_reset( set_t **head, char *key )
185{
186        set_t *s;
187       
188        s = set_find( head, key );
189        if( s )
190                return set_setstr( head, key, s->def );
191       
192        return 0;
193}
194
195char *set_eval_int( set_t *set, char *value )
196{
197        char *s = value;
198       
199        /* Allow a minus at the first position. */
200        if( *s == '-' )
201                s ++;
202       
203        for( ; *s; s ++ )
204                if( !isdigit( *s ) )
205                        return SET_INVALID;
206       
207        return value;
208}
209
210char *set_eval_bool( set_t *set, char *value )
211{
212        return is_bool( value ) ? value : SET_INVALID;
213}
214
215char *set_eval_to_char( set_t *set, char *value )
216{
217        char *s = g_new( char, 3 );
218       
219        if( *value == ' ' )
220                strcpy( s, " " );
221        else
222                sprintf( s, "%c ", *value );
223       
224        return s;
225}
226
227char* set_eval_op_root( set_t *set, char* value )
228{
229        irc_t *irc = set->data;
230        char* ret = set_eval_bool(set, value);
231        int b = bool2int(ret);
232
233        irc_write( irc, ":%s!%s@%s MODE %s %s %s", irc->mynick, irc->mynick, irc->myhost,
234                                               irc->channel, b?"+o":"-o", irc->mynick);
235
236        return ret;
237}
238
239char* set_eval_op_user( set_t *set, char* value )
240{
241        irc_t *irc = set->data;
242        char* ret = set_eval_bool(set, value);
243        int b = bool2int(ret);
244
245        irc_write( irc, ":%s!%s@%s MODE %s %s %s", irc->mynick, irc->mynick, irc->myhost,
246                                               irc->channel, b?"+o":"-o", irc->nick);
247
248        return ret;
249}
250
251/* generalized version of set_eval_op/voice_buddies */
252char *set_eval_mode_buddies( set_t *set, char *value, char modeflag )
253{
254        irc_t *irc = set->data;
255        char op[64], deop[64];
256        int nop=0, ndeop=0;
257        user_t *u;
258        int mode;
259       
260        if(!strcmp(value, "false"))
261                mode=0;
262        else if(!strcmp(value, "encrypted"))
263                mode=1;
264        else if(!strcmp(value, "trusted"))
265                mode=2;
266        else if(!strcmp(value, "notaway"))
267                mode=3;
268        else
269                return SET_INVALID;
270
271        /* sorry for calling them op/deop - too lazy for search+replace :P */
272        op[0]='\0';
273        deop[0]='\0';
274        for(u=irc->users; u; u=u->next) {
275                /* we're only concerned with online buddies */
276                if(!u->ic || !u->online)
277                        continue;
278
279                /* just in case... */
280                if(strlen(u->nick) >= 64)
281                        continue;
282               
283                /* dump out ops/deops when the corresponding name list fills up */
284                if(strlen(op)+strlen(u->nick)+2 > 64) {
285                        char *flags = g_strnfill(nop, modeflag);
286                        irc_write( irc, ":%s!%s@%s MODE %s +%s%s", irc->mynick, irc->mynick, irc->myhost,
287                                                               irc->channel, flags, op );
288                    op[0]='\0';
289            nop=0;
290                    g_free(flags);
291                }
292                if(strlen(deop)+strlen(u->nick)+2 > 64) {
293                        char *flags = g_strnfill(ndeop, modeflag);
294                        irc_write( irc, ":%s!%s@%s MODE %s -%s%s", irc->mynick, irc->mynick, irc->myhost,
295                                                               irc->channel, flags, deop );
296                    deop[0]='\0';
297            ndeop=0;
298                    g_free(flags);
299                }
300               
301                switch(mode) {
302                /* "false" */
303                case 0:
304                        g_strlcat(deop, " ", 64);
305                        g_strlcat(deop, u->nick, 64);
306                        ndeop++;
307                        break;
308                /* "encrypted" */
309                case 1:
310                        if(u->encrypted) {
311                                g_strlcat(op, " ", 64);
312                                g_strlcat(op, u->nick, 64);
313                                nop++;
314                        } else {
315                                g_strlcat(deop, " ", 64);
316                                g_strlcat(deop, u->nick, 64);
317                                ndeop++;
318                        }
319                        break;
320                /* "trusted" */
321                case 2:
322                        if(u->encrypted > 1) {
323                                g_strlcat(op, " ", 64);
324                                g_strlcat(op, u->nick, 64);
325                                nop++;
326                        } else {
327                                g_strlcat(deop, " ", 64);
328                                g_strlcat(deop, u->nick, 64);
329                                ndeop++;
330                        }
331                        break;
332                /* "notaway" */
333                case 3:
334                        if(u->away) {
335                                g_strlcat(deop, " ", 64);
336                                g_strlcat(deop, u->nick, 64);
337                                ndeop++;
338                        } else {
339                                g_strlcat(op, " ", 64);
340                                g_strlcat(op, u->nick, 64);
341                                nop++;
342                        }
343                }
344        }
345        /* dump anything left in op/deop lists */
346        if(*op) {
347                char *flags = g_strnfill(nop, modeflag);
348                irc_write( irc, ":%s!%s@%s MODE %s +%s%s", irc->mynick, irc->mynick, irc->myhost,
349                                                               irc->channel, flags, op );
350                g_free(flags);
351        }
352        if(*deop) {
353                char *flags = g_strnfill(ndeop, modeflag);
354                irc_write( irc, ":%s!%s@%s MODE %s -%s%s", irc->mynick, irc->mynick, irc->myhost,
355                                                   irc->channel, flags, deop );
356        g_free(flags);
357    }
358
359        return value;
360}
361
362char *set_eval_op_buddies( set_t *set, char *value )
363{
364        return set_eval_mode_buddies(set, value, 'o');
365}
366
367char *set_eval_halfop_buddies( set_t *set, char *value )
368{
369        return set_eval_mode_buddies(set, value, 'h');
370}
371
372char *set_eval_voice_buddies( set_t *set, char *value )
373{
374        return set_eval_mode_buddies(set, value, 'v');
375}
376
377/* possible values: never, opportunistic, manual, always */
378char *set_eval_otr_policy( set_t *set, char *value )
379{
380        if ( !strcmp(value, "never") )
381                return value;
382        if ( !strcmp(value, "opportunistic") )
383                return value;
384        if ( !strcmp(value, "manual") )
385                return value;
386        if ( !strcmp(value, "always") )
387                return value;
388        return NULL;
389}
390
Note: See TracBrowser for help on using the repository browser.