Yattm - unified GTK instant-messaging client
[Generated for version 0.2-17 - Mon Jan 6 19:01:23 GMT+1 2003]

Home - - - - -

util.c

Go to the documentation of this file.

/*
 * Yattm 
 *
 * Copyright (C) 1999, Torrey Searle <tsearle@uci.edu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*
 * util.c
 * just some handy functions to have around
 *
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "intl.h"
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#ifdef __MINGW32__
#include <winsock2.h>
#else
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif
#include <ctype.h>
#include <sys/stat.h>
#include <assert.h>
#include "util.h"
#include "status.h"
#include "globals.h"
#include "chat_window.h"
#include "value_pair.h"
#include "plugin.h"

#ifndef NAME_MAX
#define NAME_MAX 4096
#endif

gint clean_pid(void * dummy)
{
    int status;
    pid_t pid;

#ifndef __MINGW32__
    pid = waitpid(-1, &status, WNOHANG);
#endif

    if (pid == 0)
        return TRUE;

    return FALSE;
}

char * get_local_addresses()
{
    static char addresses[1024];
    char buff[1024];
    char gateway[16];
    char  * c;
    struct hostent * hn;
    int i;
        FILE * f;
        //system("getip.pl > myip");
        f = popen("netstat -nr", "r");
        if((int)f < 1)
                goto IP_TEST_2;
        while( fgets(buff, sizeof(buff), f)  != NULL )
        {
                c = strtok( buff, " " );
                if( (strstr(c, "default") || strstr(c,"0.0.0.0") ) &&
                                !strstr(c, "127.0.0" ) )
                        break;
        }
        c = strtok( NULL, " " );
        pclose(f);

        strncpy(gateway,c, 16);

        
        
        for(i = strlen(gateway); gateway[i] != '.'; i-- )
        {
            gateway[i] = 0;
        }

        gateway[i] = 0;

        for(i = strlen(gateway); gateway[i] != '.'; i-- )
        {
            gateway[i] = 0;
        }

        //g_snprintf(buff, 1024, "/sbin/ifconfig -a|grep inet|grep %s", gateway );
        f = popen("/sbin/ifconfig -a", "r");
        if((int)f < 1)
                goto IP_TEST_2;
        
        while( fgets(buff, sizeof(buff), f) != NULL )
        {
                if( strstr(buff, "inet") && strstr(buff,gateway) )
                        break;
        }
        pclose(f);
        
        c = strtok( buff, " " );
        c = strtok( NULL, " " );

        strncpy ( addresses, c, sizeof(addresses) );
        c = strtok(addresses, ":" );
        strncpy ( buff, c, sizeof(buff) );
        if((c=strtok(NULL, ":")))
        {
            strncpy( buff, c, sizeof(buff) );
        }

        
        strncpy(addresses, buff, sizeof(addresses));

        return addresses;
        
        
IP_TEST_2:

        gethostname(buff,sizeof(buff));
        
        hn = gethostbyname(buff);
        if(hn)
                strncpy(addresses, inet_ntoa( *((struct in_addr*)hn->h_addr)), sizeof(addresses) );
        else
                addresses[0] = 0;
        return addresses;
}


/* a valid domain name is one that contains only alphanumeric, - and . 
 * if it has anything else, then it can't be a domain name
 */

gint is_valid_domain( gchar * name )
{
    int i;
    int dot_count = 0;
    if( name[0] == '-' || name[0] == '.' )
    {
        return FALSE;
    }
    for( i = 0; name[i] && name[i] != '/' && name[i] != ':'; i++ )
    {
        if( !isalnum(name[i]) && name[i] != '.' && name[i] != '-' )
        {
            return FALSE;
        }
        if( name[i] == '.' )
        {
            if( name[i-1] == '.' ||
                name[i-1] == '-' ||
                name[i+1] == '.' ||
                name[i+1] == '-' )
            {
                return FALSE;
            }
            dot_count++;
        }

    }
    if( name[i] == ':' )
    {
        for( i = i+1; name[i] && name[i] != '/'; i++ )
        {
            if(!isdigit(name[i]))
            {
                return FALSE;
            }
        }
    }
    return dot_count > 0;
}

char * escape_string(char * input)
{
    GString * temp_result = g_string_sized_new(2048);
    gchar * result;
    int ipos = 0;
    for(ipos=0;input[ipos];ipos++)
    {
        if(input[ipos] == '\n')
        {
            g_string_append(temp_result, "\\n");
        }
        else if(input[ipos] == '\r')
        {
            g_string_append(temp_result, "\\r");
        }
        else if(input[ipos] == '\\')
        {
            g_string_append(temp_result, "\\\\");
        }
        else if(input[ipos] == '"')
        {
            g_string_append(temp_result, "\\\"");
        }
        else
        {
            g_string_append_c(temp_result, input[ipos]);
        }
    }

    result = temp_result->str;
    g_string_free(temp_result, FALSE);
    return result;
}
char * unescape_string(char * input)
{
    gchar * result = g_malloc0(strlen(input)+1);
    int ipos=0, opos=0; 
    while(input[ipos])
    {
        char c = input[ipos++];
        if(c == '\\')
        {
            c = input[ipos++];
            switch(c)
            {
                case 'n':
                    result[opos++] = '\n';
                    break;
                case 'r':   
                    result[opos++] = '\r';
                    break;
                case '\\':  
                    result[opos++] = '\\';
                    break;
                case '\"':  
                    result[opos++] = '\"';
                    break;
            }
        }
        else
        {
            result[opos++] = c;
        }
    }
    result[opos] = '\0';

    return result;

}
/* this function will be used to determine if a given token is a link */

gint is_link( gchar * token )
{
    int i;
    int len = strlen(token);
    
    if( token[0] == '<' )
    {
        return TOKEN_NORMAL;
    }
    if(!strncasecmp( token, "http://", 7 ) )
    {
        if(is_valid_domain(token+7))
        {
            return TOKEN_HTTP;
        }
        else
        {
            return TOKEN_NORMAL;
        }
    }
    if(!strncasecmp( token, "ftp://", 6))
    {
        return TOKEN_FTP;
    }
    if(!strncasecmp( token, "mailto:", 7))
    {
        return TOKEN_EMAIL;
    }
    if(!strncasecmp( token, "www.", 4) && is_valid_domain(token))
    {
        return TOKEN_HTTP;
    }
    if(!strncasecmp( token, "ftp.", 4) && is_valid_domain(token))
    {
        return TOKEN_FTP;
    }
    if(strstr(token, "://") && !ispunct(token[0]) && !ispunct(token[strlen(token)]) )
    {
        return TOKEN_CUSTOM;
    }

    for(i = 0; i < len; i++ )
    {
        if(token[i] == '@' )
        {
            if( !ispunct(token[0]) && !ispunct(token[len-1]) )
            {
                if(is_valid_domain(token+i+1))
                {
                        return TOKEN_EMAIL;
                }
                break;
            }
        }
    }
    
    for(i=len; i >= 0; i-- )
    {
        if( token[i] == '.' )
        {
            if(!strcasecmp(token+i, ".edu") && is_valid_domain(token))
            {
                return TOKEN_HTTP;
            }
            if(!strcasecmp(token+i, ".com") && is_valid_domain(token))
            {
                return TOKEN_HTTP;
            }
            if(!strcasecmp(token+i, ".net") && is_valid_domain(token))
            {
                return TOKEN_HTTP;
            }
            if(!strcasecmp(token+i, ".org") && is_valid_domain(token))
            {
                return TOKEN_HTTP;
            }
            if(!strcasecmp(token+i, ".gov") && is_valid_domain(token))
            {
                return TOKEN_HTTP;
            }
            break;
        }
    }
    return TOKEN_NORMAL;
}

GString * get_next_token(char * input)
{
    int i = 0;
    int len = strlen(input);
    GString * string = g_string_sized_new(20);

    if(!strncasecmp(input, "<A", 2))
    {
        g_string_assign(string, "<A");
        for( i = 2; i < len; i++ )
        {
            g_string_append_c(string, input[i]);
            if( input[i] != '<' )
            {
                continue;
            }
            g_string_append_c(string, input[++i]);
            if( input[i] != '/' )
            {
                continue;
            }
            g_string_append_c(string, input[++i]);
            if( tolower(input[i]) != 'a' )
            {
                continue;
            }
            g_string_append_c(string, input[++i]);
            break;
        }
        return string;
    }
    if(input[0] == '<')
    {
        for(i=0; i < len; i++)
        {
            g_string_append_c(string, input[i]);
            if(input[i] == '>')
            {
                break;
            }
        }
        return string;
    }

    if( ispunct(input[0]) )
    {
        for( i=0; i < len; i++ )
        {
            if( ispunct(input[i]) && input[i] != '<' )
            {
                g_string_append_c(string, input[i]);
            }
            else
            {
                break;
            }
        }
        return string;
    }

    /*
     * now that we have covered prior html
     * we can do an (almost) simple word tokenization
     */

    for( i = 0; i < len; i++ )
    {
        if(!isspace(input[i]) && input[i] != '<' )
        {
            if(!ispunct(input[i]) || input[i] == '/' )
            {
                g_string_append_c(string, input[i]);
            }
            else
            {
                int j;
#if 0
                if( (i < len - 1 && !isspace(input[i+1])) || i==0 )
                {
                    g_string_append_c(string, input[i]);
                }
                else
                {
                    return string;
                }
#endif
                for(j = i+1; j < len; j++ )
                {
                    if( isspace(input[j] ) )
                    {
                        return string;
                    }
                    if( isalpha( input[j] ) || isdigit(input[j] ) ) 
                    {
                        break;
                    }
                }
                if( j == len )
                {
                    return string;
                }
                else
                {
                    g_string_append_c(string, input[i]);
                }
                            
                            
            }
        }
        else
        {
            return string;
        }
    }
    return string;
}
            
void linkify_token( GString * token )
{
    GString * g;
    GString * g2;
    int type = is_link(token->str);

    if(type == TOKEN_NORMAL)
        return;

    g = g_string_sized_new(token->len);
    g2 = g_string_sized_new(token->len);

    g_string_assign(g, token->str);
    g_string_assign(g2, token->str);
    

        
    if(type == TOKEN_HTTP && strncasecmp(token->str, "http://", 7))
    {
        g_string_prepend(g2, "http://");
    }
    else if( type == TOKEN_FTP && strncasecmp(token->str, "ftp://", 6))
    {
        g_string_prepend(g2, "ftp://");
    }
    else if( type == TOKEN_EMAIL && strncasecmp(token->str, "mailto:", 7))
    {
        g_string_prepend(g2, "mailto:");
    }

    eb_debug(DBG_HTML, "TOKEN: %s\n", token->str);
    g_string_sprintf(token, "<A HREF=\"%s\">%s</A>", g2->str, g->str);

    g_string_free(g,TRUE);
    g_string_free(g2,TRUE);
}

gchar * linkify( gchar * input )
{
    int i = 0;
    int len = strlen(input);
    gchar * result;
    GString * temp_result;
    GString * temp = NULL;

    temp_result = g_string_sized_new(2048);

    while( i < len )
    {
        if( isspace(input[i]) )
        {
            g_string_append_c(temp_result, input[i]);
            i++;
        }
        else
        {
            temp = get_next_token(input+i);
            eb_debug(DBG_HTML, "%s\t%s\t%d\t%d\n", input, input+i, i, temp->len);
            i += temp->len;
            linkify_token(temp);
            g_string_append(temp_result, temp->str);
            g_string_free(temp, TRUE);
        }
    }

    result = temp_result->str;
    g_string_free(temp_result, FALSE);
    return result;
}

gchar * convert_eol (gchar * text) 
{
    gchar * temp;
    gchar **data=NULL;
    int i;
    
    if (strstr (text, "\r\n") != NULL)
        return text;
    
    data = g_strsplit(text,"\n",64);
    temp = g_strdup(data[0]);
    for(i=1; data[i] != NULL; i++) {
        temp = g_strdup_printf("%s\r\n%s",temp,data[i]);
    }
    g_strfreev(data);
    return temp;
}

/* Parameters:
    remote - the account to find a local account for
    online - whether the local account needs to be online
*/
eb_local_account * find_local_account_for_remote( eb_account *remote, gboolean online )
{
    static GList * node = NULL;
    static eb_account *last_remote=NULL;

    /* If this is a normal call, start at the top and give the first, otherwise continue where we left off */
    if(remote) {
        node = accounts;
        last_remote=remote;
    }
    else {
        remote = last_remote;
        if(node)
            node=node->next;
    }
    for( ; node; node = node->next )
    {
        eb_local_account * ela = (eb_local_account *)(node->data);
        
        if (remote->service_id == ela->service_id)
        {
            if (eb_services[ela->service_id].sc->is_suitable != NULL)
            {
                if (eb_services[ela->service_id].sc->is_suitable(ela, remote) == TRUE)
                {
                    if (online && (! ela->connected)) {}
                    else
                    {
                        return (ela);
                    }
                }
            }
            else
            {
                if (online && (! ela->connected)) {}
                else
                {
                    return (ela);
                }
            }
        }
    }
    
    /*We can't find anything, let's bail*/
    return NULL;
}

eb_local_account * find_suitable_local_account( eb_local_account * first,
                                                gint second )
{
    GList * node;
    GList * states;
    
    /*The last state in the list of states will be the OFFLINE state*
     *The first state in the list will be the ONLINE states         *
     *The rest of the states are the various AWAY states            */
    
    states = eb_services[second].sc->get_states();
    
    g_list_free(states);
    
    if( first && first->connected )
    {
        /* hurrah, we got our first choice */
        return first;
    }
            
    /*dang, we are out of luck with our first choice, do we have something
      else that uses the same service? */

    for( node = accounts; node; node = node->next )
    {
        eb_local_account * ela = (eb_local_account *)(node->data);
            eb_debug(DBG_CORE, "%s %s\n", eb_services[ela->service_id].name, ela->handle);
        
        if( ela->service_id == second && ela->connected )
        {
            return ela;
        }
        else if( !ela->connected )
        {
            eb_debug(DBG_CORE, "%s is offline!\n", ela->handle );
        }
            
    }
    
    /*We can't find anything, let's bail*/
    return NULL;
}

/* if contact can offline message, return the account,
   otherwise, return null 
*/

eb_account * can_offline_message( struct contact * con )
{
    GList * node;
    for(node = con->accounts; node; node=node->next)
    {
        eb_account * ea = (eb_account*)node->data;
        
        if( eb_services[ea->service_id].offline_messaging )
            return ea;
    }
    return 0;
}   
    
eb_account * find_suitable_remote_account( eb_account * first, 
                                           struct contact * rest )
{
    GList * node;
    eb_account * possibility = NULL;

    if( first && eb_services[first->service_id].sc->query_connected(first) )
    {
        return first;
    }
    
    for(node = rest->accounts; node; node=node->next)
    {
        eb_account * ea = (eb_account*)node->data;
        
        if( eb_services[ea->service_id].sc->query_connected(ea) )
        {
            if(ea->service_id == rest->default_chatb )
            {
                return ea;
            }
            else
            {
                possibility = ea;
            }
        }
    }
    return possibility;
}
    
eb_account * find_suitable_file_transfer_account( eb_account * first, 
                           struct contact * rest )
{
    GList * node;
    eb_account * possibility = NULL;

    if ( first == NULL )
        return NULL;

    if( first && eb_services[first->service_id].sc->query_connected(first)
            && eb_services[first->service_id].file_transfer )
    {
        return first;
    }
    
    for(node = rest->accounts; node; node=node->next)
    {
        eb_account * ea = (eb_account*)node->data;
        
        if( eb_services[ea->service_id].sc->query_connected(ea)
                && eb_services[first->service_id].file_transfer )
        {
            if(ea->service_id == rest->default_chatb )
            {
                return ea;
            }
            else
            {
                possibility = ea;
            }
        }
    }
    return possibility;
}
    
eb_chat_room * find_chat_room_by_id( gchar * id )
{
    GList * node = chat_rooms;
    for( node= chat_rooms; node; node=node->next)
    {
        eb_chat_room * ecr = node->data;
        eb_debug(DBG_CORE, "Comparing %s to %s\n", id, ecr->id );
        if(!strcmp(id, ecr->id))
            return ecr;
    }
    return NULL;

}

eb_chat_room * find_chat_room_by_name( gchar * name, gint service_id )
{
    GList * node = chat_rooms;
    for( node= chat_rooms; node; node=node->next)
    {
        eb_chat_room * ecr = node->data;
        if(!strcmp(name, ecr->room_name)  && (ecr->chat_room_account->service_id == service_id) )
            return ecr;
    }
    return NULL;

}

grouplist * find_grouplist_by_name(gchar * name)
{
    GList * l1;

    if (name == NULL) {
    return NULL;
    }
    for(l1 = groups; l1; l1=l1->next )
    {
        if(!g_strncasecmp(((grouplist *)l1->data)->name, name, strlen(name)+1))
        {
             return (grouplist*)l1->data;
        }
    }
    return NULL;
}

grouplist * find_grouplist_by_nick(gchar * nick)
{
    GList * l1;
    GList * l2;

    if (nick == NULL) {
    return NULL;
    }
    for(l1 = groups; l1; l1=l1->next )
    {
        for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next )
        {
            if(!strcmp(((struct contact*)l2->data)->nick, nick))
            {
                    return (grouplist*)l1->data;
            }
        }
    }
    return NULL;
}

struct contact * find_contact_by_handle( gchar * handle )
{
    GList * l1;
    GList * l2;
    GList * l3;

    if (handle == NULL) {
    return NULL;
    }
    for(l1 = groups; l1; l1=l1->next )
    {
        for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next )
        {
            for(l3 = ((struct contact*)l2->data)->accounts; l3; l3=l3->next)
            {
                eb_account * account = (eb_account*)l3->data;
                if(!strcmp(account->handle, handle))
                    return (struct contact*)l2->data;
            }
        }
    }
    return NULL;
}

struct contact * find_contact_by_nick( gchar * nick )
{
    GList * l1;
    GList * l2;

    if (nick == NULL){
    return NULL;
    }
    for(l1 = groups; l1; l1=l1->next )
    {
        for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next )
        {
            if(!g_strncasecmp(((struct contact*)l2->data)->nick, nick, strlen(nick)+1))
            {
                return (struct contact*)l2->data;
            }
        }
    }
    return NULL;
}

struct contact * find_contact_in_group_by_nick( gchar * nick , grouplist *gl )
{
    GList * l;

    if (nick == NULL || gl == NULL){
    return NULL;
    }

    for(l = gl->members; l; l=l->next )
    {
        if(!g_strncasecmp(((struct contact*)l->data)->nick, nick, strlen(nick)+1))
        {
            return (struct contact*)l->data;
        }
    }

    return NULL;
}

// FIXME: Do we really need to use aim_normalize?  I copied it from the libtoc/libtoc.c to facilitate making modules
char *aim_normalize(char *s)
{
    static char buf[255];
        char *t, *u;
        int x=0;

        u = t = g_malloc(strlen(s) + 1);

        strncpy(t, s, strlen(s)+1);
        g_strdown(t);

    while(*t) {
        if (*t != ' ') {
            buf[x] = *t;
            x++;
        }
        t++;
    }
        buf[x]='\0';
        g_free(u);
    return buf;
}

void refresh_service_contacts(gint type)
{
    GList * l1;
    GList * l2;
    GList * l3;
    GList * config=NULL;
    struct contact *con=NULL;

    eb_debug(DBG_CORE, ">Refreshing contacts for %i\n", type);
    for(l1 = groups; l1; l1=l1->next )
    {
        for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next )
        {
        con=(struct contact *)l2->data;
        if(con->chatwindow && con->chatwindow->perfered && (con->chatwindow->perfered->service_id==type))
        {
        eb_debug(DBG_MOD, "Setting the perfered service to NULL for %s\n", con->nick);
        con->chatwindow->perfered=NULL;
        }
            for(l3 = con->accounts; l3; l3=l3->next)
            {
                eb_account * account = (eb_account*)l3->data;
                if(account->service_id == type) {
               eb_debug(DBG_CORE, "Refreshing %s - %i\n", account->handle, type);
               config = value_pair_add(NULL, "NAME", account->handle);
               g_free(account->protocol_account_data);
               g_free(account);
               account = eb_services[type].sc->read_account_config(config, (struct contact*)l2->data);
               /* Is this a nomodule account?  Make it the right service number */
               if(account->service_id==-1)
                   account->service_id=type;
               value_pair_free(config);
               config=NULL;
               l3->data=account;
        }
            }
        }
    }
    eb_debug(DBG_CORE, "<Leaving\n");
    return;
}

eb_account * find_account_by_handle( gchar * handle, gint type )
{
    GList * l1;
    GList * l2;
    GList * l3;

    if (handle == NULL) {
    return NULL;
    }
    for(l1 = groups; l1; l1=l1->next )
    {
        for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next )
        {
            for(l3 = ((struct contact*)l2->data)->accounts; l3; l3=l3->next)
            {
                eb_account * account = (eb_account*)l3->data;
        char string1[255];
        char string2[255];
        strcpy(string1, aim_normalize(account->handle));
        strcpy(string2, aim_normalize(handle));
                if(!g_strncasecmp(string1, string2,strlen(string1)+1)
                        && account->service_id == type )
                    return account;
            }
        }
    }
    return NULL;
}

eb_account * find_account_by_handle_normalized( gchar * handle, gint type )
{
    GList * l1;
    GList * l2;
    GList * l3;
 
    if (handle == NULL) {
        return NULL;
    }
    for(l1 = groups; l1; l1=l1->next )
    {
        for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next )
        {
            for(l3 = ((struct contact*)l2->data)->accounts; l3; l3=l3->next)
            {
                eb_account * account = (eb_account*)l3->data;
                if(!g_strncasecmp(aim_normalize(account->handle), handle,strlen(handle)+1)
                                                && account->service_id == type )
                    return account;
            }
        }
    }
    return NULL;
}

eb_local_account * find_local_account_by_handle( gchar * handle, gint type)
{
    GList * l1;

    for(l1 = accounts; l1; l1=l1->next )
    {
         eb_local_account * account = (eb_local_account*)l1->data;
         if(account->service_id == type && !g_strncasecmp(account->handle, handle, strlen(handle)+1))
              return account;
    }
    return NULL;
}

void strip_html(gchar * text)
{
    int i, j;
    int visible = 1;
    
    for( i=0, j=0; text[i]; i++ )
    {
        if(text[i]=='<')
        {
            switch(text[i+1])
            {
                case 'a':
                case 'A':
                    if(isspace(text[i+2]) || text[i+2] == '>')
                    {
                        visible = 0;
                    }
                    break;

                case 'i':
                case 'I':
                case 'u':
                case 'U':
                case 'p':
                case 'P':
                    if(text[i+2] == '>')
                    {
                        visible = 0;
                    }
                    break;
                case 'b':
                case 'B':
                    if(text[i+2] == '>')
                    {
                        visible = 0;
                    }
                    else if(text[i+2] == 'O' || text[i+2] == 'o')
                    {
                        if(text[i+3] == 'D' || text[i+3] == 'd' )
                        {
                            if(text[i+4] == 'Y' || text[i+4] == 'y' )
                            {
                                if(isspace(text[i+5]) || text[i+5] == '>')
                                {
                                    visible = 0;
                                }
                            }
                        }
                    }
                    break;
                case 'h':
                case 'H':
                    if(text[i+2] == 'T' || text[i+2] == 't')
                    {
                        if(text[i+3] == 'M' || text[i+3] == 'm')
                        {
                            if(text[i+4] == 'L' || text[i+4] == 'l')
                            {
                                if(isspace(text[i+5]) || text[i+5] == '>')
                                {
                                    visible = 0;
                                }
                            }
                        }
                    }
                    break;
                                
                case 'F':
                case 'f':
                    if(text[i+2] == 'o' || text[i+2] == 'O')
                    {
                        if(text[i+3] == 'n' || text[i+3] == 'N')
                        {
                            if(text[i+4] == 't' || text[i+4] == 'T')
                            {
                                if(isspace(text[i+5]) || text[i+5] == '>')
                                {
                                    visible = 0;
                                }
                            }
                        }
                    }
                    break;
                case 's':
                    if (!strncmp(text+i+2,"miley", 5)) {
                        visible = 0;
                        text[j++]=' '; /*hack*/
                    }
                case '/':
                    visible = 0;
                    break;
            }
        }
        else if(text[i] == '>')
        {
            if(!visible)
            {
                visible = 1;
                continue;
            }
        }
        if(visible)
        {
            text[j++] = text[i];
        }
    }
    text[j] = '\0';
}


void remove_account( eb_account * a )
{
    struct contact * c = a->account_contact;
    buddy_logoff(a);
    remove_account_line(a);
    c->accounts = g_list_remove(c->accounts, a);
    RUN_SERVICE(a)->del_user(a);
    g_free(a);
}
void remove_contact( struct contact * c )
{
    grouplist * g = c->group;
    if(c->chatwindow)
        gtk_widget_destroy(c->chatwindow->window);
    while(c->accounts)
    {
        remove_account(c->accounts->data);
    }
    remove_contact_line(c);
    g->members = g_list_remove(g->members, c);
    g_free(c);

}
void remove_group( grouplist * g )
{
    while(g->members)
    {
        remove_contact(g->members->data);
    }
    remove_group_line(g);
    groups = g_list_remove(groups,g);
    g_free(g);
}

void add_group( gchar * name )
{
    grouplist g, *eg;
    strncpy(g.name, name,255);
    g.members = NULL;
    g.list_item = NULL;
   
    groups = g_list_append( groups, eg = g_memdup(&g, sizeof(grouplist)));
    add_group_line(eg);
}


static gint contact_cmp(gconstpointer a, gconstpointer b)
{
    const struct contact *ca=a, *cb=b;

    return strcasecmp(ca->nick, cb->nick);
}

struct contact * add_new_contact( gchar * group, gchar * con, gint type )
{
    grouplist * g = find_grouplist_by_name( group);
    struct contact * c = g_new0( struct contact, 1);
    c->online = 0;
    if (con != NULL) {      // don't copy from null pointers !!
        strncpy(c->nick, con, 255);
    }
    c->default_chatb = c->default_filetransb = type;
   
    if(g)
    {
        g->members = g_list_insert_sorted(g->members, c, contact_cmp);
        c->group = g;
    }
    return c;
}

void add_account_verbose( gchar * contact, eb_account * account, gboolean verbosity )
{
    struct contact * c = find_contact_by_nick( contact );
    eb_account * ea = find_account_by_handle(account->handle, account->service_id);
    if(ea)
    {
        if(!strcasecmp(ea->account_contact->nick, _("Unknown")))
        {
            struct contact * c2 = ea->account_contact;
            remove_account(ea);
            if(g_list_length(c2->accounts) == 0)
            {
                remove_contact(c2);
            }
        }
        else
        {
            char buff[2048];
            g_snprintf(buff, 2048, _("The account already exists on your\ncontact list at the following location\nGroup: %s\nContact: %s\nPlease delete this account before\nadding it elsewhere."), ea->account_contact->group->name, ea->account_contact->nick );

            if( c && g_list_length(c->accounts) == 0)
            {
                remove_contact(c);
            }
            if(verbosity)
                do_error_dialog(buff, _("Error: account exists"));
            return;
        }
    }
    if( c )
    {
        c->accounts = g_list_append( c->accounts, account );
        account->account_contact = c;
        RUN_SERVICE(account)->add_user(account);
    
    if(!strcmp(c->group->name, _("Ignore")) && 
            RUN_SERVICE(account)->ignore_user)
        RUN_SERVICE(account)->ignore_user(account);
    }
    else add_unknown(account);
}

void add_account_silent ( gchar * contact, eb_account * account )
{
    add_account_verbose(contact, account, FALSE);
}
void add_account( gchar * contact, eb_account * account )
{
    add_account_verbose(contact, account, TRUE);
}

void add_contact( gchar * group, struct contact * user )
{
    grouplist * grp = find_grouplist_by_name(group);

    if(!grp)
    {
        add_group(group);
    grp = find_grouplist_by_name(group);
    }
    if(!grp) {
        printf("Error adding group :(\n");
            return;
    }    
    grp->members = g_list_insert_sorted(grp->members, user, contact_cmp);
    user->group = grp;
}

void add_unknown( eb_account * ea )
{
    struct contact * con = g_new0(struct contact, 1);
    strncpy(con->nick, ea->handle, 255);
    con->accounts = g_list_append( con->accounts, ea );
    con->default_chatb = ea->service_id;
    con->default_filetransb = ea->service_id;
    ea->account_contact = con;
    add_contact(_("Unknown"), con);
    ea->icon_handler = -1;
    ea->status_handler = -1;
    RUN_SERVICE(ea)->add_user(ea);
    write_contact_list();
}

void add_unknown_with_name( eb_account * ea, gchar * name )
{
    struct contact * con = g_new0(struct contact, 1);

    /* Check that name is defined */
    if (name && strlen(name))
        strncpy(con->nick, name, 255);
    else
        strncpy(con->nick, ea->handle, 255);

    con->accounts = g_list_append( con->accounts, ea );
    con->default_chatb = ea->service_id;
    con->default_filetransb = ea->service_id;
    ea->account_contact = con;
    add_contact(_("Unknown"), con);
    ea->icon_handler = -1;
    ea->status_handler = -1;
    RUN_SERVICE(ea)->add_user(ea);
    write_contact_list();
}

static void handle_group_change(eb_account *ea, gchar *og, gchar *ng)
{
    /* if the groups are same, do nothing */
    if(!strcasecmp(ng, og))
        return;

    /* adding to ignore */
    if(!strcmp(ng, _("Ignore")) && RUN_SERVICE(ea)->ignore_user)
        RUN_SERVICE(ea)->ignore_user(ea);

    /* remove from ignore */
    else if(!strcmp(og, _("Ignore")) && RUN_SERVICE(ea)->unignore_user)
        RUN_SERVICE(ea)->unignore_user(ea, ng);
        
    /* just your regular group change */
    else if(RUN_SERVICE(ea)->change_group)
        RUN_SERVICE(ea)->change_group(ea, ng);

}

void move_account (struct contact * con, eb_account *ea)
{
    struct contact *c = ea->account_contact;
    gchar * new_group = con->group->name;
    gchar *old_group = c->group->name;
    
    handle_group_change(ea, old_group, new_group);

    c->accounts = g_list_remove(c->accounts, ea);

    remove_account_line(ea);
    if(g_list_length(c->accounts) == 0)
        remove_contact(c);
    else {
        GList *l;
        c->online = 0;
        for(l=c->accounts; l; l=l->next)
            if(((eb_account *)l->data)->online)
                c->online++;
        if(!c->online)
            remove_contact_line(c);
        else
            add_contact_and_accounts(c);
    }

    con->accounts = g_list_append(con->accounts, ea);

    ea->account_contact = con;
    if(ea->online)
        con->online++;

    add_contact_and_accounts(con);
}

void move_contact (gchar * group, struct contact * c)
{
    grouplist * g = c->group;
    struct contact *con;
    GList *l = c->accounts;
    
    g->members = g_list_remove(g->members, c);
    remove_contact_line(c);
    g = find_grouplist_by_name(group);
    
    if(!g)
    {
        add_group(group);
        g = find_grouplist_by_name(group);
    }
    add_group_line(g);

    for(; l; l=l->next)
    {
        eb_account *ea = l->data;
        handle_group_change(ea, c->group->name, group);
    }

    con = find_contact_by_nick(c->nick);
    if(con) 
    {
        l = c->accounts;
        while(l)
        {
            eb_account *ea = l->data;

                ea->account_contact = con;
            con->accounts = g_list_append(con->accounts, ea);
            l = l->next;
        }
        g_list_free(c->accounts);
        add_contact_and_accounts(con);
    } else {
        g->members = g_list_insert_sorted(g->members, c, contact_cmp);
        c->group = g;
        add_contact_and_accounts(c);
    }
}

typedef struct _invite_request
{
    eb_local_account * ela;
    void * id;
} invite_request;

static void process_invite( GtkWidget * widget, gpointer data )
{
    invite_request * invite = data;
    int result = (int)gtk_object_get_user_data( GTK_OBJECT(widget));

    if( result )
    {
        RUN_SERVICE(invite->ela)->accept_invite( invite->ela, invite->id );
    }
    else
    {
        RUN_SERVICE(invite->ela)->decline_invite( invite->ela, invite->id);
    }

    g_free(invite);
}


void invite_dialog( eb_local_account * ela, char * user, char * chat_room,
                    void * id )
{
    char * message = g_strdup_printf(
            _("User %s wants to invite you to\n%s\nWould you like to accept?"),
            user, chat_room);
    invite_request * invite = g_new0( invite_request, 1 );

    invite->ela = ela;
    invite->id = id;
    do_dialog( message, _("Chat Invite"), process_invite, invite );
    g_free(message);
}
    
        


void make_safe_filename(gchar *buff, gchar *name)  {
    
    /* i'm pretty sure the only illegal character is '/', but maybe 
     * there are others i'm forgetting */
    char *bad_chars="/";
    char *p;
    char holder[NAME_MAX];

    strncpy(holder, name, NAME_MAX);

    for (p=holder; *p; p++) {
        if ( strchr(bad_chars, *p) )
            *p='_';
    }
    g_snprintf(buff, NAME_MAX, "%slogs/%s", 
                config_dir, holder);
}
                    

gint gtk_notebook_get_number_pages(GtkNotebook *notebook)
{
  gint i = 0;  

  for (i = 0; gtk_notebook_get_nth_page(notebook, i) != NULL; i++) {
  }

  return i;
}

/* looks for lockfile, if found, returns the pid in the file */
/* If not, creates the file, writes our pid, and returns -1 */
pid_t create_lock_file(gchar* fname)
{
  pid_t ourpid = -1;
  struct stat sbuff;
  FILE* f;

#ifndef __MINGW32__
  if (stat(fname, &sbuff) != 0) { 
    /* file doesn't exist, so we're gonna open it to write out pid to it */
    ourpid = getpid();
    if ((f = fopen(fname, "a")) != NULL) {
      fprintf(f, "%d\n", ourpid);
      fclose(f);
      ourpid = -1;
    } else {
      ourpid = 0;       /* I guess could be considered an error condition */
                /* in that we couldn't create the lock file */
    }           
  } else {
    /* this means that the file exists */
    if ((f = fopen(fname, "r")) != NULL) {
      char data[20];
      fscanf(f, "%d", &ourpid);
      fclose(f);
      sprintf(data, "/proc/%d", ourpid);
      if(stat(data, &sbuff) != 0) // we got a lock file but the process is gone
      {
          fprintf(stderr, _("deleting stale lock file\n"));
          unlink(fname); /*delete lock file and try again :) */
          return create_lock_file(fname);
      } else {
           FILE * fd = NULL;
           sprintf(data, "%s/cmdline", data);
       fd = fopen(data, "r");
       if(fd==NULL)
        perror("fopen");
       else {
            char cmd[1024];
        fgets(cmd, sizeof(cmd), fd);
        printf("registered PID is from %s\n",cmd);
        fclose(fd);
        if(cmd == NULL || strstr(cmd, "yattm") == NULL) {
          fprintf(stderr, _("deleting stale lock file\n"));
          unlink(fname); /*delete lock file and try again :) */
          return create_lock_file(fname);
        }
       }
      }
          
    } else {
      /* couldn't open it... bizarre... allow the program to run anyway... heh */
      ourpid = -1;
    }
  }
#endif

  return ourpid;
}

void delete_lock_file(gchar* fname) 
{
#ifndef __MINGW32__
  gchar cmd[1024];
  /* non-portable?  Yeah... I'll fix it at a later date... */
  g_snprintf(cmd, sizeof(cmd), "rm %s", fname);
  system(cmd);
#endif
}

void eb_generic_menu_function(GtkWidget *add_button, gpointer userdata)
{
    menu_item_data *mid=(menu_item_data *)userdata;
    ebmCallbackData *ecd=NULL;

    assert(userdata);
    ecd=mid->data;
    /* Check for valid data type */
    if(!ecd || !IS_ebmCallbackData(ecd)) {
        g_warning(_("Unexpected datatype passed to eb_generic_menu_function, ignoring call!"));
        return;
    }
    if(!mid->callback) {
        g_warning(_("No callback defined in call to eb_generic_menu_function, ignoring call!"));
        return;
    }
    eb_debug(DBG_CORE, "Calling callback\n");
    mid->callback(ecd);
}

---

Contact: Andy Maloney     [Documentation generated by doxygen]