source: protocols/account.c @ c1d9c95

Last change on this file since c1d9c95 was 6ee51a9, checked in by Wilmer van der Gaast <wilmer@…>, at 2012-08-19T14:07:48Z

Allow "set -del password". #984

  • Property mode set to 100644
File size: 10.5 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2010 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* Account management functions                                         */
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
26#define BITLBEE_CORE
27#include "bitlbee.h"
28#include "account.h"
29
30static char *set_eval_nick_source( set_t *set, char *value );
31
32account_t *account_add( bee_t *bee, struct prpl *prpl, char *user, char *pass )
33{
34        account_t *a;
35        set_t *s;
36        char tag[strlen(prpl->name)+10];
37       
38        if( bee->accounts )
39        {
40                for( a = bee->accounts; a->next; a = a->next );
41                a = a->next = g_new0( account_t, 1 );
42        }
43        else
44        {
45                bee->accounts = a = g_new0 ( account_t, 1 );
46        }
47       
48        a->prpl = prpl;
49        a->user = g_strdup( user );
50        a->pass = g_strdup( pass );
51        a->auto_connect = 1;
52        a->bee = bee;
53       
54        s = set_add( &a->set, "auto_connect", "true", set_eval_account, a );
55        s->flags |= ACC_SET_NOSAVE;
56       
57        s = set_add( &a->set, "auto_reconnect", "true", set_eval_bool, a );
58       
59        s = set_add( &a->set, "nick_format", NULL, NULL, a );
60        s->flags |= SET_NULL_OK;
61       
62        s = set_add( &a->set, "nick_source", "handle", set_eval_nick_source, a );
63        s->flags |= ACC_SET_NOSAVE; /* Just for bw compatibility! */
64       
65        s = set_add( &a->set, "password", NULL, set_eval_account, a );
66        s->flags |= ACC_SET_NOSAVE | SET_NULL_OK | SET_PASSWORD;
67       
68        s = set_add( &a->set, "tag", NULL, set_eval_account, a );
69        s->flags |= ACC_SET_NOSAVE;
70       
71        s = set_add( &a->set, "username", NULL, set_eval_account, a );
72        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
73        set_setstr( &a->set, "username", user );
74       
75        /* Hardcode some more clever tag guesses. */
76        strcpy( tag, prpl->name );
77        if( strcmp( prpl->name, "oscar" ) == 0 )
78        {
79                if( isdigit( a->user[0] ) )
80                        strcpy( tag, "icq" );
81                else
82                        strcpy( tag, "aim" );
83        }
84        else if( strcmp( prpl->name, "jabber" ) == 0 )
85        {
86                if( strstr( a->user, "@gmail.com" ) ||
87                    strstr( a->user, "@googlemail.com" ) )
88                        strcpy( tag, "gtalk" );
89                else if( strstr( a->user, "@chat.facebook.com" ) )
90                        strcpy( tag, "fb" );
91        }
92       
93        if( account_by_tag( bee, tag ) )
94        {
95                char *numpos = tag + strlen( tag );
96                int i;
97
98                for( i = 2; i < 10000; i ++ )
99                {
100                        sprintf( numpos, "%d", i );
101                        if( !account_by_tag( bee, tag ) )
102                                break;
103                }
104        }
105        set_setstr( &a->set, "tag", tag );
106       
107        a->nicks = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free );
108       
109        /* This function adds some more settings (and might want to do more
110           things that have to be done now, although I can't think of anything. */
111        if( prpl->init )
112                prpl->init( a );
113       
114        s = set_add( &a->set, "away", NULL, set_eval_account, a );
115        s->flags |= SET_NULL_OK;
116       
117        if( a->flags & ACC_FLAG_STATUS_MESSAGE )
118        {
119                s = set_add( &a->set, "status", NULL, set_eval_account, a );
120                s->flags |= SET_NULL_OK;
121        }
122       
123        return a;
124}
125
126char *set_eval_account( set_t *set, char *value )
127{
128        account_t *acc = set->data;
129       
130        /* Double-check: We refuse to edit on-line accounts. */
131        if( set->flags & ACC_SET_OFFLINE_ONLY && acc->ic )
132                return SET_INVALID;
133       
134        if( strcmp( set->key, "server" ) == 0 )
135        {
136                g_free( acc->server );
137                if( value && *value )
138                {
139                        acc->server = g_strdup( value );
140                        return value;
141                }
142                else
143                {
144                        acc->server = g_strdup( set->def );
145                        return g_strdup( set->def );
146                }
147        }
148        else if( strcmp( set->key, "username" ) == 0 )
149        {
150                g_free( acc->user );
151                acc->user = g_strdup( value );
152                return value;
153        }
154        else if( strcmp( set->key, "password" ) == 0 )
155        {
156                /* set -del should be allowed now, but I don't want to have any
157                   NULL pointers to have to deal with. */
158                if( !value )
159                        value = "";
160               
161                g_free( acc->pass );
162                acc->pass = g_strdup( value );
163                return NULL;    /* password shouldn't be visible in plaintext! */
164        }
165        else if( strcmp( set->key, "tag" ) == 0 )
166        {
167                account_t *oa;
168               
169                /* Enforce uniqueness. */
170                if( ( oa = account_by_tag( acc->bee, value ) ) && oa != acc )
171                        return SET_INVALID;
172               
173                g_free( acc->tag );
174                acc->tag = g_strdup( value );
175                return value;
176        }
177        else if( strcmp( set->key, "auto_connect" ) == 0 )
178        {
179                if( !is_bool( value ) )
180                        return SET_INVALID;
181               
182                acc->auto_connect = bool2int( value );
183                return value;
184        }
185        else if( strcmp( set->key, "away" ) == 0 ||
186                 strcmp( set->key, "status" ) == 0 )
187        {
188                if( acc->ic && acc->ic->flags & OPT_LOGGED_IN )
189                {
190                        /* If we're currently on-line, set the var now already
191                           (bit of a hack) and send an update. */
192                        g_free( set->value );
193                        set->value = g_strdup( value );
194                       
195                        imc_away_send_update( acc->ic );
196                }
197               
198                return value;
199        }
200       
201        return SET_INVALID;
202}
203
204/* For bw compatibility, have this write-only setting. */
205static char *set_eval_nick_source( set_t *set, char *value )
206{
207        account_t *a = set->data;
208       
209        if( strcmp( value, "full_name" ) == 0 )
210                set_setstr( &a->set, "nick_format", "%full_name" );
211        else if( strcmp( value, "first_name" ) == 0 )
212                set_setstr( &a->set, "nick_format", "%first_name" );
213        else
214                set_setstr( &a->set, "nick_format", "%-@nick" );
215       
216        return value;
217}
218
219account_t *account_get( bee_t *bee, const char *id )
220{
221        account_t *a, *ret = NULL;
222        char *handle, *s;
223        int nr;
224       
225        /* Tags get priority above anything else. */
226        if( ( a = account_by_tag( bee, id ) ) )
227                return a;
228       
229        /* This checks if the id string ends with (...) */
230        if( ( handle = strchr( id, '(' ) ) && ( s = strchr( handle, ')' ) ) && s[1] == 0 )
231        {
232                struct prpl *proto;
233               
234                *s = *handle = 0;
235                handle ++;
236               
237                if( ( proto = find_protocol( id ) ) )
238                {
239                        for( a = bee->accounts; a; a = a->next )
240                                if( a->prpl == proto &&
241                                    a->prpl->handle_cmp( handle, a->user ) == 0 )
242                                        ret = a;
243                }
244               
245                /* Restore the string. */
246                handle --;
247                *handle = '(';
248                *s = ')';
249               
250                if( ret )
251                        return ret;
252        }
253       
254        if( sscanf( id, "%d", &nr ) == 1 && nr < 1000 )
255        {
256                for( a = bee->accounts; a; a = a->next )
257                        if( ( nr-- ) == 0 )
258                                return( a );
259               
260                return( NULL );
261        }
262       
263        for( a = bee->accounts; a; a = a->next )
264        {
265                if( g_strcasecmp( id, a->prpl->name ) == 0 )
266                {
267                        if( !ret )
268                                ret = a;
269                        else
270                                return( NULL ); /* We don't want to match more than one... */
271                }
272                else if( strstr( a->user, id ) )
273                {
274                        if( !ret )
275                                ret = a;
276                        else
277                                return( NULL );
278                }
279        }
280       
281        return( ret );
282}
283
284account_t *account_by_tag( bee_t *bee, const char *tag )
285{
286        account_t *a;
287       
288        for( a = bee->accounts; a; a = a->next )
289                if( a->tag && g_strcasecmp( tag, a->tag ) == 0 )
290                        return a;
291       
292        return NULL;
293}
294
295void account_del( bee_t *bee, account_t *acc )
296{
297        account_t *a, *l = NULL;
298       
299        if( acc->ic )
300                /* Caller should have checked, accounts still in use can't be deleted. */
301                return;
302       
303        for( a = bee->accounts; a; a = (l=a)->next )
304                if( a == acc )
305                {
306                        if( l )
307                                l->next = a->next;
308                        else
309                                bee->accounts = a->next;
310                       
311                        /** FIXME
312                        for( c = bee->chatrooms; c; c = nc )
313                        {
314                                nc = c->next;
315                                if( acc == c->acc )
316                                        chat_del( bee, c );
317                        }
318                        */
319                       
320                        while( a->set )
321                                set_del( &a->set, a->set->key );
322                       
323                        g_hash_table_destroy( a->nicks );
324                       
325                        g_free( a->tag );
326                        g_free( a->user );
327                        g_free( a->pass );
328                        g_free( a->server );
329                        if( a->reconnect )      /* This prevents any reconnect still queued to happen */
330                                cancel_auto_reconnect( a );
331                        g_free( a );
332                       
333                        break;
334                }
335}
336
337static gboolean account_on_timeout( gpointer d, gint fd, b_input_condition cond );
338
339void account_on( bee_t *bee, account_t *a )
340{
341        if( a->ic )
342        {
343                /* Trying to enable an already-enabled account */
344                return;
345        }
346       
347        cancel_auto_reconnect( a );
348       
349        a->reconnect = 0;
350        a->prpl->login( a );
351       
352        if( a->ic && !( a->ic->flags & OPT_SLOW_LOGIN ) )
353                a->ic->keepalive = b_timeout_add( 120000, account_on_timeout, a->ic );
354}
355
356void account_off( bee_t *bee, account_t *a )
357{
358        imc_logout( a->ic, FALSE );
359        a->ic = NULL;
360        if( a->reconnect )
361        {
362                /* Shouldn't happen */
363                cancel_auto_reconnect( a );
364        }
365}
366
367static gboolean account_on_timeout( gpointer d, gint fd, b_input_condition cond )
368{
369        struct im_connection *ic = d;
370       
371        imcb_error( ic, "Connection timeout" );
372        imc_logout( ic, TRUE );
373       
374        return FALSE;
375}
376
377struct account_reconnect_delay
378{
379        int start;
380        char op;
381        int step;
382        int max;
383};
384
385int account_reconnect_delay_parse( char *value, struct account_reconnect_delay *p )
386{
387        memset( p, 0, sizeof( *p ) );
388        /* A whole day seems like a sane "maximum maximum". */
389        p->max = 86400;
390       
391        /* Format: /[0-9]+([*+][0-9]+(<[0-9+])?)?/ */
392        while( *value && isdigit( *value ) )
393                p->start = p->start * 10 + *value++ - '0';
394       
395        /* Sure, call me evil for implementing my own fscanf here, but it's
396           dead simple and I immediately know where to continue parsing. */
397       
398        if( *value == 0 )
399                /* If the string ends now, the delay is constant. */
400                return 1;
401        else if( *value != '+' && *value != '*' )
402                /* Otherwise allow either a + or a * */
403                return 0;
404       
405        p->op = *value++;
406       
407        /* + or * the delay by this number every time. */
408        while( *value && isdigit( *value ) )
409                p->step = p->step * 10 + *value++ - '0';
410       
411        if( *value == 0 )
412                /* Use the default maximum (one day). */
413                return 1;
414        else if( *value != '<' )
415                return 0;
416       
417        p->max = 0;
418        value ++;
419        while( *value && isdigit( *value ) )
420                p->max = p->max * 10 + *value++ - '0';
421       
422        return p->max > 0;
423}
424
425char *set_eval_account_reconnect_delay( set_t *set, char *value )
426{
427        struct account_reconnect_delay p;
428       
429        return account_reconnect_delay_parse( value, &p ) ? value : SET_INVALID;
430}
431
432int account_reconnect_delay( account_t *a )
433{
434        char *setting = set_getstr( &a->bee->set, "auto_reconnect_delay" );
435        struct account_reconnect_delay p;
436       
437        if( account_reconnect_delay_parse( setting, &p ) )
438        {
439                if( a->auto_reconnect_delay == 0 )
440                        a->auto_reconnect_delay = p.start;
441                else if( p.op == '+' )
442                        a->auto_reconnect_delay += p.step;
443                else if( p.op == '*' )
444                        a->auto_reconnect_delay *= p.step;
445               
446                if( a->auto_reconnect_delay > p.max )
447                        a->auto_reconnect_delay = p.max;
448        }
449        else
450        {
451                a->auto_reconnect_delay = 0;
452        }
453       
454        return a->auto_reconnect_delay;
455}
Note: See TracBrowser for help on using the repository browser.