source: nick.c @ eabe6d4

Last change on this file since eabe6d4 was 6b13103, checked in by dequis <dx@…>, at 2015-01-16T19:50:23Z

Replace isdigit/isalpha/.../tolower/toupper with glib variants

This fixes warnings about passing signed chars to them (apparently they
are implemented as macros that do array lookups without checks in some
platforms, yay)

Specifically:

functions=isalnum|isalpha|isdigit|isspace|isxdigit|tolower|toupper
sed -ir "s/$functions/g_ascii_&/g" /*.c

  • Property mode set to 100644
File size: 10.3 KB
RevLine 
[b7d3cc34]1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
[0e788f5]4  * Copyright 2002-2012 Wilmer van der Gaast and others                *
[b7d3cc34]5  \********************************************************************/
6
7/* Some stuff to fetch, save and handle nicknames for your buddies      */
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;
[6f10697]22  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
23  Fifth Floor, Boston, MA  02110-1301  USA
[b7d3cc34]24*/
25
26#define BITLBEE_CORE
27#include "bitlbee.h"
28
[2e0eaac]29/* Character maps, _lc_[x] == _uc_[x] (but uppercase), according to the RFC's.
30   With one difference, we allow dashes. These are used to do uc/lc conversions
31   and strip invalid chars. */
32static char *nick_lc_chars = "0123456789abcdefghijklmnopqrstuvwxyz{}^`-_|";
33static char *nick_uc_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ[]~`-_\\";
34
[5b52a48]35/* Store handles in lower case and strip spaces, because AIM is braindead. */
36static char *clean_handle( const char *orig )
[b7d3cc34]37{
[5b52a48]38        char *new = g_malloc( strlen( orig ) + 1 );
39        int i = 0;
[b7d3cc34]40       
[5b52a48]41        do {
42                if (*orig != ' ')
[6b13103]43                        new[i++] = g_ascii_tolower( *orig );
[b7d3cc34]44        }
[5b52a48]45        while (*(orig++));
[b7d3cc34]46       
[5b52a48]47        return new;
48}
49
[b1f818b]50void nick_set_raw( account_t *acc, const char *handle, const char *nick )
[5b52a48]51{
52        char *store_handle, *store_nick = g_malloc( MAX_NICK_LENGTH + 1 );
[e277e80]53        irc_t *irc = (irc_t *) acc->bee->ui_data;
[b7d3cc34]54       
[5b52a48]55        store_handle = clean_handle( handle );
[b1f818b]56        store_nick[MAX_NICK_LENGTH] = '\0';
[5b52a48]57        strncpy( store_nick, nick, MAX_NICK_LENGTH );
[e277e80]58        nick_strip( irc, store_nick );
[b7d3cc34]59       
[5b52a48]60        g_hash_table_replace( acc->nicks, store_handle, store_nick );
[b7d3cc34]61}
62
[b1f818b]63void nick_set( bee_user_t *bu, const char *nick )
64{
65        nick_set_raw( bu->ic->acc, bu->handle, nick );
66}
67
68char *nick_get( bee_user_t *bu )
[b7d3cc34]69{
70        static char nick[MAX_NICK_LENGTH+1];
[5b52a48]71        char *store_handle, *found_nick;
[e277e80]72        irc_t *irc = (irc_t *) bu->bee->ui_data;
[b7d3cc34]73       
74        memset( nick, 0, MAX_NICK_LENGTH + 1 );
75       
[b1f818b]76        store_handle = clean_handle( bu->handle );
[5b52a48]77        /* Find out if we stored a nick for this person already. If not, try
78           to generate a sane nick automatically. */
[b1f818b]79        if( ( found_nick = g_hash_table_lookup( bu->ic->acc->nicks, store_handle ) ) )
[5b52a48]80        {
81                strncpy( nick, found_nick, MAX_NICK_LENGTH );
82        }
[2e0eaac]83        else if( ( found_nick = nick_gen( bu ) ) )
84        {
85                strncpy( nick, found_nick, MAX_NICK_LENGTH );
86                g_free( found_nick );
87        }
[5b52a48]88        else
[b7d3cc34]89        {
[2e0eaac]90                /* Keep this fallback since nick_gen() can return NULL in some cases. */
[b7d3cc34]91                char *s;
92               
[b1f818b]93                g_snprintf( nick, MAX_NICK_LENGTH, "%s", bu->handle );
[b7d3cc34]94                if( ( s = strchr( nick, '@' ) ) )
95                        while( *s )
96                                *(s++) = 0;
97               
[e277e80]98                nick_strip( irc, nick );
[b1f818b]99                if( set_getbool( &bu->bee->set, "lcnicks" ) )
[e277e80]100                        nick_lc( irc, nick );
[b7d3cc34]101        }
[5b52a48]102        g_free( store_handle );
[b7d3cc34]103       
[d06eabf]104        /* Make sure the nick doesn't collide with an existing one by adding
105           underscores and that kind of stuff, if necessary. */
[b1f818b]106        nick_dedupe( bu, nick );
[d06eabf]107       
108        return nick;
109}
110
[b1f818b]111char *nick_gen( bee_user_t *bu )
[d06eabf]112{
[2e0eaac]113        gboolean ok = FALSE; /* Set to true once the nick contains something unique. */
[c608891]114        GString *ret = g_string_sized_new( MAX_NICK_LENGTH + 1 );
115        char *rets;
116        irc_t *irc = (irc_t *) bu->bee->ui_data;
[2e0eaac]117        char *fmt = set_getstr( &bu->ic->acc->set, "nick_format" ) ? :
118                    set_getstr( &bu->bee->set, "nick_format" );
119       
120        while( fmt && *fmt && ret->len < MAX_NICK_LENGTH )
121        {
[7e84168]122                char *part = NULL, chop = '\0', *asc = NULL, *s;
123                int len = INT_MAX;
[2e0eaac]124               
125                if( *fmt != '%' )
126                {
127                        g_string_append_c( ret, *fmt );
128                        fmt ++;
129                        continue;
130                }
131               
132                fmt ++;
133                while( *fmt )
134                {
135                        /* -char means chop off everything from char */
136                        if( *fmt == '-' )
137                        {
138                                chop = fmt[1];
139                                if( chop == '\0' )
[9ed0081]140                                {
141                                        g_string_free( ret, TRUE );
[2e0eaac]142                                        return NULL;
[9ed0081]143                                }
[2e0eaac]144                                fmt += 2;
145                        }
[6b13103]146                        else if( g_ascii_isdigit( *fmt ) )
[7e84168]147                        {
148                                len = 0;
149                                /* Grab a number. */
[6b13103]150                                while( g_ascii_isdigit( *fmt ) )
[7e84168]151                                        len = len * 10 + ( *(fmt++) - '0' );
152                        }
[09dfb68]153                        else if( g_strncasecmp( fmt, "nick", 4 ) == 0 )
154                        {
155                                part = bu->nick ? : bu->handle;
156                                fmt += 4;
157                                ok |= TRUE;
158                                break;
159                        }
[2e0eaac]160                        else if( g_strncasecmp( fmt, "handle", 6 ) == 0 )
161                        {
162                                part = bu->handle;
163                                fmt += 6;
164                                ok |= TRUE;
165                                break;
166                        }
167                        else if( g_strncasecmp( fmt, "full_name", 9 ) == 0 )
168                        {
169                                part = bu->fullname;
170                                fmt += 9;
171                                ok |= part && *part;
172                                break;
173                        }
174                        else if( g_strncasecmp( fmt, "first_name", 10 ) == 0 )
175                        {
176                                part = bu->fullname;
177                                fmt += 10;
178                                ok |= part && *part;
179                                chop = ' ';
180                                break;
181                        }
[09dfb68]182                        else if( g_strncasecmp( fmt, "group", 5 ) == 0 )
183                        {
184                                part = bu->group ? bu->group->name : NULL;
185                                fmt += 5;
186                                break;
187                        }
[3b3c50d9]188                        else if( g_strncasecmp( fmt, "account", 7 ) == 0 )
189                        {
190                                part = bu->ic->acc->tag;
191                                fmt += 7;
192                                break;
193                        }
[2e0eaac]194                        else
195                        {
[9ed0081]196                                g_string_free( ret, TRUE );
[2e0eaac]197                                return NULL;
198                        }
199                }
200               
[c608891]201                if( !part )
202                        continue;
203               
[badd148]204                /* Credits to Josay_ in #bitlbee for this idea. //TRANSLIT
205                   should do lossy/approximate conversions, so letters with
206                   accents don't just get stripped. Note that it depends on
207                   LC_CTYPE being set to something other than C/POSIX. */
[c608891]208                if( !( irc && irc->status & IRC_UTF8_NICKS ) )
[560129a]209                        part = asc = g_convert_with_fallback( part, -1, "ASCII//TRANSLIT",
210                                                              "UTF-8", "", NULL, NULL, NULL );
[badd148]211               
[cce1b63]212                if( part && chop && ( s = strchr( part, chop ) ) )
[7e84168]213                        len = MIN( len, s - part );
214               
[c608891]215                if( part )
[7e84168]216                {
217                        if( len < INT_MAX )
218                                g_string_append_len( ret, part, len );
219                        else
220                                g_string_append( ret, part );
221                }
[badd148]222                g_free( asc );
[2e0eaac]223        }
224       
[c608891]225        rets = g_string_free( ret, FALSE );
226        if( ok && rets && *rets )
227        {
228                nick_strip( irc, rets );
229                rets[MAX_NICK_LENGTH] = '\0';
230                return rets;
231        }
232        g_free( rets );
233        return NULL;
[b1f818b]234}
235
236void nick_dedupe( bee_user_t *bu, char nick[MAX_NICK_LENGTH+1] )
237{
238        irc_t *irc = (irc_t*) bu->bee->ui_data;
[d06eabf]239        int inf_protection = 256;
[badd148]240        irc_user_t *iu;
[d06eabf]241       
[5b52a48]242        /* Now, find out if the nick is already in use at the moment, and make
243           subtle changes to make it unique. */
[e277e80]244        while( !nick_ok( irc, nick ) ||
[badd148]245               ( ( iu = irc_user_by_name( irc, nick ) ) && iu->bu != bu ) )
[b7d3cc34]246        {
247                if( strlen( nick ) < ( MAX_NICK_LENGTH - 1 ) )
248                {
249                        nick[strlen(nick)+1] = 0;
250                        nick[strlen(nick)] = '_';
251                }
252                else
253                {
254                        nick[0] ++;
255                }
256               
257                if( inf_protection-- == 0 )
258                {
259                        g_snprintf( nick, MAX_NICK_LENGTH + 1, "xx%x", rand() );
260                       
[c608891]261                        irc_rootmsg( irc, "Warning: Something went wrong while trying "
262                                          "to generate a nickname for contact %s on %s.",
263                                          bu->handle, bu->ic->acc->tag );
264                        irc_rootmsg( irc, "This might be a bug in BitlBee, or the result "
265                                          "of a faulty nick_format setting. Will use %s "
266                                          "instead.", nick );
267                       
[b7d3cc34]268                        break;
269                }
270        }
271}
272
[d323394c]273/* Just check if there is a nickname set for this buddy or if we'd have to
274   generate one. */
[b1f818b]275int nick_saved( bee_user_t *bu )
[d323394c]276{
277        char *store_handle, *found;
278       
[b1f818b]279        store_handle = clean_handle( bu->handle );
280        found = g_hash_table_lookup( bu->ic->acc->nicks, store_handle );
[d323394c]281        g_free( store_handle );
282       
283        return found != NULL;
284}
285
[b1f818b]286void nick_del( bee_user_t *bu )
[b7d3cc34]287{
[b1f818b]288        g_hash_table_remove( bu->ic->acc->nicks, bu->handle );
[b7d3cc34]289}
290
291
[e277e80]292void nick_strip( irc_t *irc, char *nick )
[b7d3cc34]293{
[c608891]294        int len = 0;
[b7d3cc34]295       
[c608891]296        if( irc && ( irc->status & IRC_UTF8_NICKS ) )
[b7d3cc34]297        {
[c608891]298                gunichar c;
299                char *p = nick, *n, tmp[strlen(nick)+1];
300               
301                while( p && *p )
[b7d3cc34]302                {
[c608891]303                        c = g_utf8_get_char_validated( p, -1 );
304                        n = g_utf8_find_next_char( p, NULL );
305                       
306                        if( ( c < 0x7f && !( strchr( nick_lc_chars, c ) ||
307                                             strchr( nick_uc_chars, c ) ) ) ||
308                            !g_unichar_isgraph( c ) )
309                        {
310                                strcpy( tmp, n );
311                                strcpy( p, tmp );
312                        }
313                        else
314                                p = n;
315                }
316                if( p )
317                        len = p - nick;
318        }
319        else
320        {
321                int i;
322               
323                for( i = len = 0; nick[i] && len < MAX_NICK_LENGTH; i++ )
324                {
325                        if( strchr( nick_lc_chars, nick[i] ) || 
326                            strchr( nick_uc_chars, nick[i] ) )
327                        {
328                                nick[len] = nick[i];
329                                len++;
330                        }
[b7d3cc34]331                }
332        }
[6b13103]333        if( g_ascii_isdigit( nick[0] ) )
[0f47613]334        {
335                char *orig;
336               
[c608891]337                /* First character of a nick can't be a digit, so insert an
338                   underscore if necessary. */
[0f47613]339                orig = g_strdup( nick );
340                g_snprintf( nick, MAX_NICK_LENGTH, "_%s", orig );
341                g_free( orig );
[c608891]342                len ++;
[0f47613]343        }
[c608891]344        while( len <= MAX_NICK_LENGTH )
345                nick[len++] = '\0';
[b7d3cc34]346}
347
[c608891]348gboolean nick_ok( irc_t *irc, const char *nick )
[b7d3cc34]349{
[1eddf6b]350        const char *s;
[b7d3cc34]351       
[0f47613]352        /* Empty/long nicks are not allowed, nor numbers at [0] */
[6b13103]353        if( !*nick || g_ascii_isdigit( nick[0] ) || strlen( nick ) > MAX_NICK_LENGTH )
[c608891]354                return 0;
[b7d3cc34]355       
[c608891]356        if( irc && ( irc->status & IRC_UTF8_NICKS ) )
357        {
358                gunichar c;
359                const char *p = nick, *n;
360               
361                while( p && *p )
362                {
363                        c = g_utf8_get_char_validated( p, -1 );
364                        n = g_utf8_find_next_char( p, NULL );
365                       
366                        if( ( c < 0x7f && !( strchr( nick_lc_chars, c ) ||
367                                             strchr( nick_uc_chars, c ) ) ) ||
368                            !g_unichar_isgraph( c ) )
369                        {
370                                return FALSE;
371                        }
372                        p = n;
373                }
374        }
375        else
376        {
377                for( s = nick; *s; s ++ )
378                        if( !strchr( nick_lc_chars, *s ) && !strchr( nick_uc_chars, *s ) )
379                                return FALSE;
380        }
[b7d3cc34]381       
[c608891]382        return TRUE;
[b7d3cc34]383}
384
[e277e80]385int nick_lc( irc_t *irc, char *nick )
[b7d3cc34]386{
[d323394c]387        static char tab[128] = { 0 };
[b7d3cc34]388        int i;
389       
390        if( tab['A'] == 0 )
391                for( i = 0; nick_lc_chars[i]; i ++ )
392                {
393                        tab[(int)nick_uc_chars[i]] = nick_lc_chars[i];
394                        tab[(int)nick_lc_chars[i]] = nick_lc_chars[i];
395                }
396       
[c608891]397        if( irc && ( irc->status & IRC_UTF8_NICKS ) )
[b7d3cc34]398        {
[c608891]399                gchar *down = g_utf8_strdown( nick, -1 );
400                if( strlen( down ) > strlen( nick ) )
[b7d3cc34]401                {
[c608891]402                        /* Well crap. Corrupt it if we have to. */
403                        down[strlen(nick)] = '\0';
[b7d3cc34]404                }
[c608891]405                strcpy( nick, down );
406                g_free( down );
407        }
[b7d3cc34]408       
409        for( i = 0; nick[i]; i ++ )
[46511b3]410                if( ((guchar)nick[i]) < 0x7f )
411                        nick[i] = tab[(guchar)nick[i]];
[b7d3cc34]412       
[c608891]413        return nick_ok( irc, nick );
[b7d3cc34]414}
415
[e277e80]416int nick_cmp( irc_t *irc, const char *a, const char *b )
[b7d3cc34]417{
418        char aa[1024] = "", bb[1024] = "";
419       
420        strncpy( aa, a, sizeof( aa ) - 1 );
421        strncpy( bb, b, sizeof( bb ) - 1 );
[e277e80]422        if( nick_lc( irc, aa ) && nick_lc( irc, bb ) )
[b7d3cc34]423        {
424                return( strcmp( aa, bb ) );
425        }
426        else
427        {
428                return( -1 );   /* Hmm... Not a clear answer.. :-/ */
429        }
430}
Note: See TracBrowser for help on using the repository browser.