2011-02-24 06:14:30 +03:00
/* X-Chat
* Copyright ( C ) 1998 Peter Zelezny .
*
* 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
*/
# define _GNU_SOURCE /* for memrchr */
# include <string.h>
# include <stdlib.h>
# include <stdio.h>
# include <ctype.h>
# include <limits.h>
# include <errno.h>
# define WANTSOCKET
# define WANTARPA
# include "inet.h"
# ifndef WIN32
# include <sys/wait.h>
2011-12-11 20:34:02 +04:00
# include <unistd.h>
2011-02-24 06:14:30 +03:00
# endif
# include <time.h>
# include <signal.h>
# include <sys/stat.h>
# include <fcntl.h>
# include "xchat.h"
# include "plugin.h"
# include "ignore.h"
# include "util.h"
# include "fe.h"
# include "cfgfiles.h" /* xchat_fopen_file() */
# include "network.h" /* net_ip() */
# include "modes.h"
# include "notify.h"
# include "inbound.h"
# include "text.h"
# include "xchatc.h"
# include "servlist.h"
# include "server.h"
# include "tree.h"
# include "outbound.h"
2012-07-21 16:26:19 +04:00
# include "chanopt.h"
2011-02-24 06:14:30 +03:00
# ifdef USE_DEBUG
extern int current_mem_usage ;
# endif
# define TBUFSIZE 4096
static void help ( session * sess , char * tbuf , char * helpcmd , int quiet ) ;
static int cmd_server ( session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] ) ;
static void handle_say ( session * sess , char * text , int check_spch ) ;
static void
notj_msg ( struct session * sess )
{
PrintText ( sess , _ ( " No channel joined. Try /join #<channel> \n " ) ) ;
}
void
notc_msg ( struct session * sess )
{
PrintText ( sess , _ ( " Not connected. Try /server <host> [<port>] \n " ) ) ;
}
static char *
random_line ( char * file_name )
{
FILE * fh ;
char buf [ 512 ] ;
int lines , ran ;
if ( ! file_name [ 0 ] )
goto nofile ;
fh = xchat_fopen_file ( file_name , " r " , 0 ) ;
if ( ! fh )
{
nofile :
/* reason is not a file, an actual reason! */
return strdup ( file_name ) ;
}
/* count number of lines in file */
lines = 0 ;
while ( fgets ( buf , sizeof ( buf ) , fh ) )
lines + + ;
if ( lines < 1 )
goto nofile ;
/* go down a random number */
rewind ( fh ) ;
ran = RAND_INT ( lines ) ;
do
{
fgets ( buf , sizeof ( buf ) , fh ) ;
lines - - ;
}
while ( lines > ran ) ;
fclose ( fh ) ;
buf [ strlen ( buf ) - 1 ] = 0 ; /* remove the trailing '\n' */
return strdup ( buf ) ;
}
void
server_sendpart ( server * serv , char * channel , char * reason )
{
if ( ! reason )
{
reason = random_line ( prefs . partreason ) ;
serv - > p_part ( serv , channel , reason ) ;
free ( reason ) ;
} else
{
/* reason set by /quit, /close argument */
serv - > p_part ( serv , channel , reason ) ;
}
}
void
server_sendquit ( session * sess )
{
char * rea , * colrea ;
if ( ! sess - > quitreason )
{
colrea = strdup ( prefs . quitreason ) ;
check_special_chars ( colrea , FALSE ) ;
rea = random_line ( colrea ) ;
free ( colrea ) ;
sess - > server - > p_quit ( sess - > server , rea ) ;
free ( rea ) ;
} else
{
/* reason set by /quit, /close argument */
sess - > server - > p_quit ( sess - > server , sess - > quitreason ) ;
}
}
void
process_data_init ( char * buf , char * cmd , char * word [ ] ,
char * word_eol [ ] , gboolean handle_quotes ,
gboolean allow_escape_quotes )
{
int wordcount = 2 ;
int space = FALSE ;
int quote = FALSE ;
int j = 0 ;
int len ;
word [ 0 ] = " \000 \000 " ;
word_eol [ 0 ] = " \000 \000 " ;
word [ 1 ] = ( char * ) buf ;
word_eol [ 1 ] = ( char * ) cmd ;
while ( 1 )
{
switch ( * cmd )
{
case 0 :
buf [ j ] = 0 ;
for ( j = wordcount ; j < PDIWORDS ; j + + )
{
word [ j ] = " \000 \000 " ;
word_eol [ j ] = " \000 \000 " ;
}
return ;
case ' \042 ' :
if ( ! handle_quotes )
goto def ;
/* two quotes turn into 1 */
if ( allow_escape_quotes & & cmd [ 1 ] = = ' \042 ' )
{
cmd + + ;
goto def ;
}
if ( quote )
{
quote = FALSE ;
space = FALSE ;
} else
quote = TRUE ;
cmd + + ;
break ;
case ' ' :
if ( ! quote )
{
if ( ! space )
{
buf [ j ] = 0 ;
j + + ;
if ( wordcount < PDIWORDS )
{
word [ wordcount ] = & buf [ j ] ;
word_eol [ wordcount ] = cmd + 1 ;
wordcount + + ;
}
space = TRUE ;
}
cmd + + ;
break ;
}
default :
def :
space = FALSE ;
len = g_utf8_skip [ ( ( unsigned char * ) cmd ) [ 0 ] ] ;
if ( len = = 1 )
{
buf [ j ] = * cmd ;
j + + ;
cmd + + ;
} else
{
/* skip past a multi-byte utf8 char */
memcpy ( buf + j , cmd , len ) ;
j + = len ;
cmd + = len ;
}
}
}
}
static int
cmd_addbutton ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
if ( * word [ 2 ] & & * word_eol [ 3 ] )
{
if ( sess - > type = = SESS_DIALOG )
{
list_addentry ( & dlgbutton_list , word_eol [ 3 ] , word [ 2 ] ) ;
fe_dlgbuttons_update ( sess ) ;
} else
{
list_addentry ( & button_list , word_eol [ 3 ] , word [ 2 ] ) ;
fe_buttons_update ( sess ) ;
}
return TRUE ;
}
return FALSE ;
}
static int
cmd_allchannels ( session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
GSList * list = sess_list ;
if ( ! * word_eol [ 2 ] )
return FALSE ;
while ( list )
{
sess = list - > data ;
if ( sess - > type = = SESS_CHANNEL & & sess - > channel [ 0 ] & & sess - > server - > connected )
{
handle_command ( sess , word_eol [ 2 ] , FALSE ) ;
}
list = list - > next ;
}
return TRUE ;
}
static int
cmd_allchannelslocal ( session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
GSList * list = sess_list ;
server * serv = sess - > server ;
if ( ! * word_eol [ 2 ] )
return FALSE ;
while ( list )
{
sess = list - > data ;
if ( sess - > type = = SESS_CHANNEL & & sess - > channel [ 0 ] & &
sess - > server - > connected & & sess - > server = = serv )
{
handle_command ( sess , word_eol [ 2 ] , FALSE ) ;
}
list = list - > next ;
}
return TRUE ;
}
static int
cmd_allservers ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
GSList * list ;
server * serv ;
if ( ! * word_eol [ 2 ] )
return FALSE ;
list = serv_list ;
while ( list )
{
serv = list - > data ;
if ( serv - > connected )
handle_command ( serv - > front_session , word_eol [ 2 ] , FALSE ) ;
list = list - > next ;
}
return TRUE ;
}
static int
cmd_away ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
GSList * list ;
char * reason = word_eol [ 2 ] ;
if ( ! ( * reason ) )
{
if ( sess - > server - > is_away )
{
if ( sess - > server - > last_away_reason )
PrintTextf ( sess , _ ( " Already marked away: %s \n " ) , sess - > server - > last_away_reason ) ;
return FALSE ;
}
if ( sess - > server - > reconnect_away )
reason = sess - > server - > last_away_reason ;
else
/* must manage memory pointed to by random_line() */
reason = random_line ( prefs . awayreason ) ;
}
sess - > server - > p_set_away ( sess - > server , reason ) ;
if ( prefs . show_away_message )
{
snprintf ( tbuf , TBUFSIZE , " me is away: %s " , reason ) ;
for ( list = sess_list ; list ; list = list - > next )
{
/* am I the right server and not a dialog box */
if ( ( ( struct session * ) list - > data ) - > server = = sess - > server
& & ( ( struct session * ) list - > data ) - > type = = SESS_CHANNEL
& & ( ( struct session * ) list - > data ) - > channel [ 0 ] )
{
handle_command ( ( session * ) list - > data , tbuf , TRUE ) ;
}
}
}
if ( sess - > server - > last_away_reason ! = reason )
{
if ( sess - > server - > last_away_reason )
free ( sess - > server - > last_away_reason ) ;
if ( reason = = word_eol [ 2 ] )
sess - > server - > last_away_reason = strdup ( reason ) ;
else
sess - > server - > last_away_reason = reason ;
}
if ( ! sess - > server - > connected )
sess - > server - > reconnect_away = 1 ;
return TRUE ;
}
static int
cmd_back ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
GSList * list ;
unsigned int gone ;
if ( sess - > server - > is_away )
{
sess - > server - > p_set_back ( sess - > server ) ;
if ( prefs . show_away_message )
{
gone = time ( NULL ) - sess - > server - > away_time ;
sprintf ( tbuf , " me is back (gone %.2d:%.2d:%.2d) " , gone / 3600 ,
( gone / 60 ) % 60 , gone % 60 ) ;
for ( list = sess_list ; list ; list = list - > next )
{
/* am I the right server and not a dialog box */
if ( ( ( struct session * ) list - > data ) - > server = = sess - > server
& & ( ( struct session * ) list - > data ) - > type = = SESS_CHANNEL
& & ( ( struct session * ) list - > data ) - > channel [ 0 ] )
{
handle_command ( ( session * ) list - > data , tbuf , TRUE ) ;
}
}
}
}
else
{
PrintText ( sess , _ ( " Already marked back. \n " ) ) ;
}
if ( sess - > server - > last_away_reason )
free ( sess - > server - > last_away_reason ) ;
sess - > server - > last_away_reason = NULL ;
return TRUE ;
}
static void
ban ( session * sess , char * tbuf , char * mask , char * bantypestr , int deop )
{
int bantype ;
struct User * user ;
char * at , * dot , * lastdot ;
char username [ 64 ] , fullhost [ 128 ] , domain [ 128 ] , * mode , * p2 ;
server * serv = sess - > server ;
user = userlist_find ( sess , mask ) ;
if ( user & & user - > hostname ) /* it's a nickname, let's find a proper ban mask */
{
if ( deop )
{
mode = " -o+b " ;
p2 = user - > nick ;
} else
{
mode = " +b " ;
p2 = " " ;
}
mask = user - > hostname ;
at = strchr ( mask , ' @ ' ) ; /* FIXME: utf8 */
if ( ! at )
return ; /* can't happen? */
* at = 0 ;
if ( mask [ 0 ] = = ' ~ ' | | mask [ 0 ] = = ' + ' | |
mask [ 0 ] = = ' = ' | | mask [ 0 ] = = ' ^ ' | | mask [ 0 ] = = ' - ' )
{
/* the ident is prefixed with something, we replace that sign with an * */
safe_strcpy ( username + 1 , mask + 1 , sizeof ( username ) - 1 ) ;
username [ 0 ] = ' * ' ;
} else if ( at - mask < USERNAMELEN )
{
/* we just add an * in the begining of the ident */
safe_strcpy ( username + 1 , mask , sizeof ( username ) - 1 ) ;
username [ 0 ] = ' * ' ;
} else
{
/* ident might be too long, we just ban what it gives and add an * in the end */
safe_strcpy ( username , mask , sizeof ( username ) ) ;
}
* at = ' @ ' ;
safe_strcpy ( fullhost , at + 1 , sizeof ( fullhost ) ) ;
dot = strchr ( fullhost , ' . ' ) ;
if ( dot )
{
safe_strcpy ( domain , dot , sizeof ( domain ) ) ;
} else
{
safe_strcpy ( domain , fullhost , sizeof ( domain ) ) ;
}
if ( * bantypestr )
bantype = atoi ( bantypestr ) ;
else
bantype = prefs . bantype ;
tbuf [ 0 ] = 0 ;
if ( inet_addr ( fullhost ) ! = - 1 ) /* "fullhost" is really a IP number */
{
lastdot = strrchr ( fullhost , ' . ' ) ;
if ( ! lastdot )
return ; /* can't happen? */
* lastdot = 0 ;
strcpy ( domain , fullhost ) ;
* lastdot = ' . ' ;
switch ( bantype )
{
case 0 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!*@%s.* " , mode , p2 , domain ) ;
break ;
case 1 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!*@%s " , mode , p2 , fullhost ) ;
break ;
case 2 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!%s@%s.* " , mode , p2 , username , domain ) ;
break ;
case 3 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!%s@%s " , mode , p2 , username , fullhost ) ;
break ;
}
} else
{
switch ( bantype )
{
case 0 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!*@*%s " , mode , p2 , domain ) ;
break ;
case 1 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!*@%s " , mode , p2 , fullhost ) ;
break ;
case 2 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!%s@*%s " , mode , p2 , username , domain ) ;
break ;
case 3 :
snprintf ( tbuf , TBUFSIZE , " %s%s *!%s@%s " , mode , p2 , username , fullhost ) ;
break ;
}
}
} else
{
snprintf ( tbuf , TBUFSIZE , " +b %s " , mask ) ;
}
serv - > p_mode ( serv , sess - > channel , tbuf ) ;
}
static int
cmd_ban ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * mask = word [ 2 ] ;
if ( * mask )
{
ban ( sess , tbuf , mask , word [ 3 ] , 0 ) ;
} else
{
sess - > server - > p_mode ( sess - > server , sess - > channel , " +b " ) ; /* banlist */
}
return TRUE ;
}
static int
cmd_unban ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
/* Allow more than one mask in /unban -- tvk */
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' - ' , ' b ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
static int
cmd_chanopt ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
/* chanopt.c */
return chanopt_command ( sess , tbuf , word , word_eol ) ;
}
static int
cmd_charset ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
server * serv = sess - > server ;
const char * locale = NULL ;
int offset = 0 ;
if ( strcmp ( word [ 2 ] , " -quiet " ) = = 0 )
offset + + ;
if ( ! word [ 2 + offset ] [ 0 ] )
{
g_get_charset ( & locale ) ;
PrintTextf ( sess , " Current charset: %s \n " ,
serv - > encoding ? serv - > encoding : locale ) ;
return TRUE ;
}
if ( servlist_check_encoding ( word [ 2 + offset ] ) )
{
server_set_encoding ( serv , word [ 2 + offset ] ) ;
if ( offset < 1 )
PrintTextf ( sess , " Charset changed to: %s \n " , word [ 2 + offset ] ) ;
} else
{
PrintTextf ( sess , " \003 4Unknown charset: \017 %s \n " , word [ 2 + offset ] ) ;
}
return TRUE ;
}
static int
cmd_clear ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
GSList * list = sess_list ;
char * reason = word_eol [ 2 ] ;
2012-06-16 15:01:47 +04:00
if ( g_ascii_strcasecmp ( reason , " HISTORY " ) = = 0 )
2011-02-24 06:14:30 +03:00
{
history_free ( & sess - > history ) ;
return TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( g_ascii_strncasecmp ( reason , " all " , 3 ) = = 0 )
2011-02-24 06:14:30 +03:00
{
while ( list )
{
sess = list - > data ;
if ( ! sess - > nick_said )
fe_text_clear ( list - > data , 0 ) ;
list = list - > next ;
}
return TRUE ;
}
if ( reason [ 0 ] ! = ' - ' & & ! isdigit ( reason [ 0 ] ) & & reason [ 0 ] ! = 0 )
return FALSE ;
fe_text_clear ( sess , atoi ( reason ) ) ;
return TRUE ;
}
static int
cmd_close ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
GSList * list ;
if ( strcmp ( word [ 2 ] , " -m " ) = = 0 )
{
list = sess_list ;
while ( list )
{
sess = list - > data ;
list = list - > next ;
if ( sess - > type = = SESS_DIALOG )
fe_close_window ( sess ) ;
}
} else
{
if ( * word_eol [ 2 ] )
sess - > quitreason = word_eol [ 2 ] ;
fe_close_window ( sess ) ;
}
return TRUE ;
}
static int
cmd_ctcp ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int mbl ;
char * to = word [ 2 ] ;
if ( * to )
{
char * msg = word_eol [ 3 ] ;
if ( * msg )
{
unsigned char * cmd = ( unsigned char * ) msg ;
/* make the first word upper case (as per RFC) */
while ( 1 )
{
if ( * cmd = = ' ' | | * cmd = = 0 )
break ;
mbl = g_utf8_skip [ * cmd ] ;
if ( mbl = = 1 )
* cmd = toupper ( * cmd ) ;
cmd + = mbl ;
}
sess - > server - > p_ctcp ( sess - > server , to , msg ) ;
EMIT_SIGNAL ( XP_TE_CTCPSEND , sess , to , msg , NULL , NULL , 0 ) ;
return TRUE ;
}
}
return FALSE ;
}
static int
cmd_country ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * code = word [ 2 ] ;
if ( * code )
{
/* search? */
if ( strcmp ( code , " -s " ) = = 0 )
{
country_search ( word [ 3 ] , sess , ( void * ) PrintTextf ) ;
return TRUE ;
}
/* search, but forgot the -s */
if ( strchr ( code , ' * ' ) )
{
country_search ( code , sess , ( void * ) PrintTextf ) ;
return TRUE ;
}
sprintf ( tbuf , " %s = %s \n " , code , country ( code ) ) ;
PrintText ( sess , tbuf ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_cycle ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * key = sess - > channelkey ;
char * chan = word [ 2 ] ;
if ( ! * chan )
chan = sess - > channel ;
if ( * chan & & sess - > type = = SESS_CHANNEL )
{
sess - > server - > p_cycle ( sess - > server , chan , key ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_dcc ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int goodtype ;
struct DCC * dcc = 0 ;
char * type = word [ 2 ] ;
if ( * type )
{
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( type , " HELP " ) )
2011-02-24 06:14:30 +03:00
return FALSE ;
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( type , " CLOSE " ) )
2011-02-24 06:14:30 +03:00
{
if ( * word [ 3 ] & & * word [ 4 ] )
{
goodtype = 0 ;
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ 3 ] , " SEND " ) )
2011-02-24 06:14:30 +03:00
{
dcc = find_dcc ( word [ 4 ] , word [ 5 ] , TYPE_SEND ) ;
dcc_abort ( sess , dcc ) ;
goodtype = TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ 3 ] , " GET " ) )
2011-02-24 06:14:30 +03:00
{
dcc = find_dcc ( word [ 4 ] , word [ 5 ] , TYPE_RECV ) ;
dcc_abort ( sess , dcc ) ;
goodtype = TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ 3 ] , " CHAT " ) )
2011-02-24 06:14:30 +03:00
{
dcc = find_dcc ( word [ 4 ] , " " , TYPE_CHATRECV ) ;
if ( ! dcc )
dcc = find_dcc ( word [ 4 ] , " " , TYPE_CHATSEND ) ;
dcc_abort ( sess , dcc ) ;
goodtype = TRUE ;
}
if ( ! goodtype )
return FALSE ;
if ( ! dcc )
EMIT_SIGNAL ( XP_TE_NODCC , sess , NULL , NULL , NULL , NULL , 0 ) ;
return TRUE ;
}
return FALSE ;
}
2012-06-16 15:01:47 +04:00
if ( ( ! g_ascii_strcasecmp ( type , " CHAT " ) ) | | ( ! g_ascii_strcasecmp ( type , " PCHAT " ) ) )
2011-02-24 06:14:30 +03:00
{
char * nick = word [ 3 ] ;
2012-06-16 15:01:47 +04:00
int passive = ( ! g_ascii_strcasecmp ( type , " PCHAT " ) ) ? 1 : 0 ;
2011-02-24 06:14:30 +03:00
if ( * nick )
dcc_chat ( sess , nick , passive ) ;
return TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( type , " LIST " ) )
2011-02-24 06:14:30 +03:00
{
dcc_show_list ( sess ) ;
return TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( type , " GET " ) )
2011-02-24 06:14:30 +03:00
{
char * nick = word [ 3 ] ;
char * file = word [ 4 ] ;
if ( ! * file )
{
if ( * nick )
dcc_get_nick ( sess , nick ) ;
} else
{
dcc = find_dcc ( nick , file , TYPE_RECV ) ;
if ( dcc )
dcc_get ( dcc ) ;
else
EMIT_SIGNAL ( XP_TE_NODCC , sess , NULL , NULL , NULL , NULL , 0 ) ;
}
return TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ( ! g_ascii_strcasecmp ( type , " SEND " ) ) | | ( ! g_ascii_strcasecmp ( type , " PSEND " ) ) )
2011-02-24 06:14:30 +03:00
{
int i = 3 , maxcps ;
char * nick , * file ;
2012-06-16 15:01:47 +04:00
int passive = ( ! g_ascii_strcasecmp ( type , " PSEND " ) ) ? 1 : 0 ;
2011-02-24 06:14:30 +03:00
nick = word [ i ] ;
if ( ! * nick )
return FALSE ;
maxcps = prefs . dcc_max_send_cps ;
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strncasecmp ( nick , " -maxcps= " , 8 ) )
2011-02-24 06:14:30 +03:00
{
maxcps = atoi ( nick + 8 ) ;
i + + ;
nick = word [ i ] ;
if ( ! * nick )
return FALSE ;
}
i + + ;
file = word [ i ] ;
if ( ! * file )
{
fe_dcc_send_filereq ( sess , nick , maxcps , passive ) ;
return TRUE ;
}
do
{
dcc_send ( sess , nick , file , maxcps , passive ) ;
i + + ;
file = word [ i ] ;
}
while ( * file ) ;
return TRUE ;
}
return FALSE ;
}
dcc_show_list ( sess ) ;
return TRUE ;
}
static int
cmd_debug ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
struct session * s ;
struct server * v ;
GSList * list = sess_list ;
PrintText ( sess , " Session T Channel WaitChan WillChan Server \n " ) ;
while ( list )
{
s = ( struct session * ) list - > data ;
sprintf ( tbuf , " %p %1x %-10.10s %-10.10s %-10.10s %p \n " ,
s , s - > type , s - > channel , s - > waitchannel ,
s - > willjoinchannel , s - > server ) ;
PrintText ( sess , tbuf ) ;
list = list - > next ;
}
list = serv_list ;
PrintText ( sess , " Server Sock Name \n " ) ;
while ( list )
{
v = ( struct server * ) list - > data ;
sprintf ( tbuf , " %p %-5d %s \n " ,
v , v - > sok , v - > servername ) ;
PrintText ( sess , tbuf ) ;
list = list - > next ;
}
sprintf ( tbuf ,
" \n front_session: %p \n "
" current_tab: %p \n \n " ,
sess - > server - > front_session , current_tab ) ;
PrintText ( sess , tbuf ) ;
# ifdef USE_DEBUG
sprintf ( tbuf , " current mem: %d \n \n " , current_mem_usage ) ;
PrintText ( sess , tbuf ) ;
# endif /* !MEMORY_DEBUG */
return TRUE ;
}
static int
cmd_delbutton ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
if ( * word [ 2 ] )
{
if ( sess - > type = = SESS_DIALOG )
{
if ( list_delentry ( & dlgbutton_list , word [ 2 ] ) )
fe_dlgbuttons_update ( sess ) ;
} else
{
if ( list_delentry ( & button_list , word [ 2 ] ) )
fe_buttons_update ( sess ) ;
}
return TRUE ;
}
return FALSE ;
}
static int
cmd_dehop ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' - ' , ' h ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
static int
cmd_deop ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' - ' , ' o ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
typedef struct
{
char * * nicks ;
int i ;
session * sess ;
char * reason ;
char * tbuf ;
} multidata ;
static int
mdehop_cb ( struct User * user , multidata * data )
{
if ( user - > hop & & ! user - > me )
{
data - > nicks [ data - > i ] = user - > nick ;
data - > i + + ;
}
return TRUE ;
}
static int
cmd_mdehop ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * * nicks = malloc ( sizeof ( char * ) * sess - > hops ) ;
multidata data ;
data . nicks = nicks ;
data . i = 0 ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) mdehop_cb , & data ) ;
send_channel_modes ( sess , tbuf , nicks , 0 , data . i , ' - ' , ' h ' , 0 ) ;
free ( nicks ) ;
return TRUE ;
}
static int
mdeop_cb ( struct User * user , multidata * data )
{
if ( user - > op & & ! user - > me )
{
data - > nicks [ data - > i ] = user - > nick ;
data - > i + + ;
}
return TRUE ;
}
static int
cmd_mdeop ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * * nicks = malloc ( sizeof ( char * ) * sess - > ops ) ;
multidata data ;
data . nicks = nicks ;
data . i = 0 ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) mdeop_cb , & data ) ;
send_channel_modes ( sess , tbuf , nicks , 0 , data . i , ' - ' , ' o ' , 0 ) ;
free ( nicks ) ;
return TRUE ;
}
GSList * menu_list = NULL ;
static void
menu_free ( menu_entry * me )
{
free ( me - > path ) ;
if ( me - > label )
free ( me - > label ) ;
if ( me - > cmd )
free ( me - > cmd ) ;
if ( me - > ucmd )
free ( me - > ucmd ) ;
if ( me - > group )
free ( me - > group ) ;
if ( me - > icon )
free ( me - > icon ) ;
free ( me ) ;
}
/* strings equal? but ignore underscores */
int
menu_streq ( const char * s1 , const char * s2 , int def )
{
/* for separators */
if ( s1 = = NULL & & s2 = = NULL )
return 0 ;
if ( s1 = = NULL | | s2 = = NULL )
return 1 ;
while ( * s1 )
{
if ( * s1 = = ' _ ' )
s1 + + ;
if ( * s2 = = ' _ ' )
s2 + + ;
if ( * s1 ! = * s2 )
return 1 ;
s1 + + ;
s2 + + ;
}
if ( ! * s2 )
return 0 ;
return def ;
}
static menu_entry *
menu_entry_find ( char * path , char * label )
{
GSList * list ;
menu_entry * me ;
list = menu_list ;
while ( list )
{
me = list - > data ;
if ( ! strcmp ( path , me - > path ) )
{
if ( me - > label & & label & & ! strcmp ( label , me - > label ) )
return me ;
}
list = list - > next ;
}
return NULL ;
}
static void
menu_del_children ( char * path , char * label )
{
GSList * list , * next ;
menu_entry * me ;
char buf [ 512 ] ;
if ( ! label )
label = " " ;
if ( path [ 0 ] )
snprintf ( buf , sizeof ( buf ) , " %s/%s " , path , label ) ;
else
snprintf ( buf , sizeof ( buf ) , " %s " , label ) ;
list = menu_list ;
while ( list )
{
me = list - > data ;
next = list - > next ;
if ( ! menu_streq ( buf , me - > path , 0 ) )
{
menu_list = g_slist_remove ( menu_list , me ) ;
menu_free ( me ) ;
}
list = next ;
}
}
static int
menu_del ( char * path , char * label )
{
GSList * list ;
menu_entry * me ;
list = menu_list ;
while ( list )
{
me = list - > data ;
if ( ! menu_streq ( me - > label , label , 1 ) & & ! menu_streq ( me - > path , path , 1 ) )
{
menu_list = g_slist_remove ( menu_list , me ) ;
fe_menu_del ( me ) ;
menu_free ( me ) ;
/* delete this item's children, if any */
menu_del_children ( path , label ) ;
return 1 ;
}
list = list - > next ;
}
return 0 ;
}
static char
menu_is_mainmenu_root ( char * path , gint16 * offset )
{
static const char * menus [ ] = { " \ x4$TAB " , " \ x5$TRAY " , " \ x4$URL " , " \ x5$NICK " , " \ x5$CHAN " } ;
int i ;
for ( i = 0 ; i < 5 ; i + + )
{
if ( ! strncmp ( path , menus [ i ] + 1 , menus [ i ] [ 0 ] ) )
{
* offset = menus [ i ] [ 0 ] + 1 ; /* number of bytes to offset the root */
return 0 ; /* is not main menu */
}
}
* offset = 0 ;
return 1 ; /* is main menu */
}
static void
menu_add ( char * path , char * label , char * cmd , char * ucmd , int pos , int state , int markup , int enable , int mod , int key , char * group , char * icon )
{
menu_entry * me ;
/* already exists? */
me = menu_entry_find ( path , label ) ;
if ( me )
{
/* update only */
me - > state = state ;
me - > enable = enable ;
fe_menu_update ( me ) ;
return ;
}
me = malloc ( sizeof ( menu_entry ) ) ;
me - > pos = pos ;
me - > modifier = mod ;
me - > is_main = menu_is_mainmenu_root ( path , & me - > root_offset ) ;
me - > state = state ;
me - > markup = markup ;
me - > enable = enable ;
me - > key = key ;
me - > path = strdup ( path ) ;
me - > label = NULL ;
me - > cmd = NULL ;
me - > ucmd = NULL ;
me - > group = NULL ;
me - > icon = NULL ;
if ( label )
me - > label = strdup ( label ) ;
if ( cmd )
me - > cmd = strdup ( cmd ) ;
if ( ucmd )
me - > ucmd = strdup ( ucmd ) ;
if ( group )
me - > group = strdup ( group ) ;
if ( icon )
me - > icon = strdup ( icon ) ;
menu_list = g_slist_append ( menu_list , me ) ;
label = fe_menu_add ( me ) ;
if ( label )
{
/* FE has given us a stripped label */
free ( me - > label ) ;
me - > label = strdup ( label ) ;
g_free ( label ) ; /* this is from pango */
}
}
static int
cmd_menu ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int idx = 2 ;
int len ;
int pos = 0xffff ;
int state ;
int toggle = FALSE ;
int enable = TRUE ;
int markup = FALSE ;
int key = 0 ;
int mod = 0 ;
char * label ;
char * group = NULL ;
char * icon = NULL ;
if ( ! word [ 2 ] [ 0 ] | | ! word [ 3 ] [ 0 ] )
return FALSE ;
/* -eX enabled or not? */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' e ' )
{
enable = atoi ( word [ idx ] + 2 ) ;
idx + + ;
}
/* -i<ICONFILE> */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' i ' )
{
icon = word [ idx ] + 2 ;
idx + + ;
}
/* -k<mod>,<key> key binding */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' k ' )
{
char * comma = strchr ( word [ idx ] , ' , ' ) ;
if ( ! comma )
return FALSE ;
mod = atoi ( word [ idx ] + 2 ) ;
key = atoi ( comma + 1 ) ;
idx + + ;
}
/* -m to specify PangoMarkup language */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' m ' )
{
markup = TRUE ;
idx + + ;
}
/* -pX to specify menu position */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' p ' )
{
pos = atoi ( word [ idx ] + 2 ) ;
idx + + ;
}
/* -rSTATE,GROUP to specify a radio item */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' r ' )
{
state = atoi ( word [ idx ] + 2 ) ;
group = word [ idx ] + 4 ;
idx + + ;
}
/* -tX to specify toggle item with default state */
if ( word [ idx ] [ 0 ] = = ' - ' & & word [ idx ] [ 1 ] = = ' t ' )
{
state = atoi ( word [ idx ] + 2 ) ;
idx + + ;
toggle = TRUE ;
}
if ( word [ idx + 1 ] [ 0 ] = = 0 )
return FALSE ;
/* the path */
path_part ( word [ idx + 1 ] , tbuf , 512 ) ;
len = strlen ( tbuf ) ;
if ( len )
tbuf [ len - 1 ] = 0 ;
/* the name of the item */
label = file_part ( word [ idx + 1 ] ) ;
if ( label [ 0 ] = = ' - ' & & label [ 1 ] = = 0 )
label = NULL ; /* separator */
if ( markup )
{
char * p ; /* to force pango closing tags through */
for ( p = label ; * p ; p + + )
if ( * p = = 3 )
* p = ' / ' ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ idx ] , " ADD " ) )
2011-02-24 06:14:30 +03:00
{
if ( toggle )
{
menu_add ( tbuf , label , word [ idx + 2 ] , word [ idx + 3 ] , pos , state , markup , enable , mod , key , NULL , NULL ) ;
} else
{
if ( word [ idx + 2 ] [ 0 ] )
menu_add ( tbuf , label , word [ idx + 2 ] , NULL , pos , state , markup , enable , mod , key , group , icon ) ;
else
menu_add ( tbuf , label , NULL , NULL , pos , state , markup , enable , mod , key , group , icon ) ;
}
return TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ idx ] , " DEL " ) )
2011-02-24 06:14:30 +03:00
{
menu_del ( tbuf , label ) ;
return TRUE ;
}
return FALSE ;
}
static int
mkick_cb ( struct User * user , multidata * data )
{
if ( ! user - > op & & ! user - > me )
data - > sess - > server - > p_kick ( data - > sess - > server , data - > sess - > channel , user - > nick , data - > reason ) ;
return TRUE ;
}
static int
mkickops_cb ( struct User * user , multidata * data )
{
if ( user - > op & & ! user - > me )
data - > sess - > server - > p_kick ( data - > sess - > server , data - > sess - > channel , user - > nick , data - > reason ) ;
return TRUE ;
}
static int
cmd_mkick ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
multidata data ;
data . sess = sess ;
data . reason = word_eol [ 2 ] ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) mkickops_cb , & data ) ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) mkick_cb , & data ) ;
return TRUE ;
}
static int
cmd_devoice ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' - ' , ' v ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
static int
cmd_discon ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
sess - > server - > disconnect ( sess , TRUE , - 1 ) ;
return TRUE ;
}
static int
cmd_dns ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
# ifdef WIN32
PrintText ( sess , " DNS is not implemented in Windows. \n " ) ;
return TRUE ;
# else
char * nick = word [ 2 ] ;
struct User * user ;
if ( * nick )
{
if ( strchr ( nick , ' . ' ) = = NULL )
{
user = userlist_find ( sess , nick ) ;
if ( user & & user - > hostname )
{
do_dns ( sess , user - > nick , user - > hostname ) ;
} else
{
sess - > server - > p_get_ip ( sess - > server , nick ) ;
sess - > server - > doing_dns = TRUE ;
}
} else
{
snprintf ( tbuf , TBUFSIZE , " exec -d %s %s " , prefs . dnsprogram , nick ) ;
handle_command ( sess , tbuf , FALSE ) ;
}
return TRUE ;
}
return FALSE ;
# endif
}
static int
cmd_echo ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
PrintText ( sess , word_eol [ 2 ] ) ;
return TRUE ;
}
# ifndef WIN32
static void
exec_check_process ( struct session * sess )
{
int val ;
if ( sess - > running_exec = = NULL )
return ;
val = waitpid ( sess - > running_exec - > childpid , NULL , WNOHANG ) ;
if ( val = = - 1 | | val > 0 )
{
close ( sess - > running_exec - > myfd ) ;
fe_input_remove ( sess - > running_exec - > iotag ) ;
free ( sess - > running_exec ) ;
sess - > running_exec = NULL ;
}
}
# ifndef __EMX__
static int
cmd_execs ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int r ;
exec_check_process ( sess ) ;
if ( sess - > running_exec = = NULL )
{
EMIT_SIGNAL ( XP_TE_NOCHILD , sess , NULL , NULL , NULL , NULL , 0 ) ;
return FALSE ;
}
r = kill ( sess - > running_exec - > childpid , SIGSTOP ) ;
if ( r = = - 1 )
PrintText ( sess , " Error in kill(2) \n " ) ;
return TRUE ;
}
static int
cmd_execc ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int r ;
exec_check_process ( sess ) ;
if ( sess - > running_exec = = NULL )
{
EMIT_SIGNAL ( XP_TE_NOCHILD , sess , NULL , NULL , NULL , NULL , 0 ) ;
return FALSE ;
}
r = kill ( sess - > running_exec - > childpid , SIGCONT ) ;
if ( r = = - 1 )
PrintText ( sess , " Error in kill(2) \n " ) ;
return TRUE ;
}
static int
cmd_execk ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int r ;
exec_check_process ( sess ) ;
if ( sess - > running_exec = = NULL )
{
EMIT_SIGNAL ( XP_TE_NOCHILD , sess , NULL , NULL , NULL , NULL , 0 ) ;
return FALSE ;
}
if ( strcmp ( word [ 2 ] , " -9 " ) = = 0 )
r = kill ( sess - > running_exec - > childpid , SIGKILL ) ;
else
r = kill ( sess - > running_exec - > childpid , SIGTERM ) ;
if ( r = = - 1 )
PrintText ( sess , " Error in kill(2) \n " ) ;
return TRUE ;
}
/* OS/2 Can't have the /EXECW command because it uses pipe(2) not socketpair
and thus it is simplex - - AGL */
static int
cmd_execw ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int len ;
char * temp ;
exec_check_process ( sess ) ;
if ( sess - > running_exec = = NULL )
{
EMIT_SIGNAL ( XP_TE_NOCHILD , sess , NULL , NULL , NULL , NULL , 0 ) ;
return FALSE ;
}
len = strlen ( word_eol [ 2 ] ) ;
temp = malloc ( len + 2 ) ;
sprintf ( temp , " %s \n " , word_eol [ 2 ] ) ;
PrintText ( sess , temp ) ;
write ( sess - > running_exec - > myfd , temp , len + 1 ) ;
free ( temp ) ;
return TRUE ;
}
# endif /* !__EMX__ */
/* convert ANSI escape color codes to mIRC codes */
static short escconv [ ] =
/* 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 */
{ 1 , 4 , 3 , 5 , 2 , 10 , 6 , 1 , 1 , 7 , 9 , 8 , 12 , 11 , 13 , 1 } ;
static void
exec_handle_colors ( char * buf , int len )
{
char numb [ 16 ] ;
char * nbuf ;
int i = 0 , j = 0 , k = 0 , firstn = 0 , col , colf = 0 , colb = 0 ;
int esc = FALSE , backc = FALSE , bold = FALSE ;
/* any escape codes in this text? */
if ( strchr ( buf , 27 ) = = 0 )
return ;
nbuf = malloc ( len + 1 ) ;
while ( i < len )
{
switch ( buf [ i ] )
{
case ' \r ' :
break ;
case 27 :
esc = TRUE ;
break ;
case ' ; ' :
if ( ! esc )
goto norm ;
backc = TRUE ;
numb [ k ] = 0 ;
firstn = atoi ( numb ) ;
k = 0 ;
break ;
case ' [ ' :
if ( ! esc )
goto norm ;
break ;
default :
if ( esc )
{
if ( buf [ i ] > = ' A ' & & buf [ i ] < = ' z ' )
{
if ( buf [ i ] = = ' m ' )
{
/* ^[[0m */
if ( k = = 0 | | ( numb [ 0 ] = = ' 0 ' & & k = = 1 ) )
{
nbuf [ j ] = ' \017 ' ;
j + + ;
bold = FALSE ;
goto cont ;
}
numb [ k ] = 0 ;
col = atoi ( numb ) ;
backc = FALSE ;
if ( firstn = = 1 )
bold = TRUE ;
if ( firstn > = 30 & & firstn < = 37 )
colf = firstn - 30 ;
if ( col > = 40 )
{
colb = col - 40 ;
backc = TRUE ;
}
if ( col > = 30 & & col < = 37 )
colf = col - 30 ;
if ( bold )
colf + = 8 ;
if ( backc )
{
colb = escconv [ colb % 14 ] ;
colf = escconv [ colf % 14 ] ;
j + = sprintf ( & nbuf [ j ] , " \003 %d,%02d " , colf , colb ) ;
} else
{
colf = escconv [ colf % 14 ] ;
j + = sprintf ( & nbuf [ j ] , " \003 %02d " , colf ) ;
}
}
cont : esc = FALSE ;
backc = FALSE ;
k = 0 ;
} else
{
if ( isdigit ( ( unsigned char ) buf [ i ] ) & & k < ( sizeof ( numb ) - 1 ) )
{
numb [ k ] = buf [ i ] ;
k + + ;
}
}
} else
{
norm : nbuf [ j ] = buf [ i ] ;
j + + ;
}
}
i + + ;
}
nbuf [ j ] = 0 ;
memcpy ( buf , nbuf , j + 1 ) ;
free ( nbuf ) ;
}
# ifndef HAVE_MEMRCHR
static void *
memrchr ( const void * block , int c , size_t size )
{
unsigned char * p ;
for ( p = ( unsigned char * ) block + size ; p ! = block ; p - - )
if ( * p = = c )
return p ;
return 0 ;
}
# endif
static gboolean
exec_data ( GIOChannel * source , GIOCondition condition , struct nbexec * s )
{
char * buf , * readpos , * rest ;
int rd , len ;
int sok = s - > myfd ;
len = s - > buffill ;
if ( len ) {
/* append new data to buffered incomplete line */
buf = malloc ( len + 2050 ) ;
memcpy ( buf , s - > linebuf , len ) ;
readpos = buf + len ;
free ( s - > linebuf ) ;
s - > linebuf = NULL ;
}
else
readpos = buf = malloc ( 2050 ) ;
rd = read ( sok , readpos , 2048 ) ;
if ( rd < 1 )
{
/* The process has died */
kill ( s - > childpid , SIGKILL ) ;
if ( len ) {
buf [ len ] = ' \0 ' ;
exec_handle_colors ( buf , len ) ;
if ( s - > tochannel )
{
/* must turn off auto-completion temporarily */
unsigned int old = prefs . nickcompletion ;
prefs . nickcompletion = 0 ;
handle_multiline ( s - > sess , buf , FALSE , TRUE ) ;
prefs . nickcompletion = old ;
}
else
PrintText ( s - > sess , buf ) ;
}
free ( buf ) ;
waitpid ( s - > childpid , NULL , 0 ) ;
s - > sess - > running_exec = NULL ;
fe_input_remove ( s - > iotag ) ;
close ( sok ) ;
free ( s ) ;
return TRUE ;
}
len + = rd ;
buf [ len ] = ' \0 ' ;
rest = memrchr ( buf , ' \n ' , len ) ;
if ( rest )
rest + + ;
else
rest = buf ;
if ( * rest ) {
s - > buffill = len - ( rest - buf ) ; /* = strlen(rest) */
2012-01-09 02:48:46 +04:00
s - > linebuf = malloc ( s - > buffill + 1 ) ;
2011-02-24 06:14:30 +03:00
memcpy ( s - > linebuf , rest , s - > buffill ) ;
* rest = ' \0 ' ;
len - = s - > buffill ; /* possibly 0 */
}
else
s - > buffill = 0 ;
if ( len ) {
exec_handle_colors ( buf , len ) ;
if ( s - > tochannel )
handle_multiline ( s - > sess , buf , FALSE , TRUE ) ;
else
PrintText ( s - > sess , buf ) ;
}
free ( buf ) ;
return TRUE ;
}
static int
cmd_exec ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int tochannel = FALSE ;
char * cmd = word_eol [ 2 ] ;
int fds [ 2 ] , pid = 0 ;
struct nbexec * s ;
int shell = TRUE ;
int fd ;
if ( * cmd )
{
exec_check_process ( sess ) ;
if ( sess - > running_exec ! = NULL )
{
EMIT_SIGNAL ( XP_TE_ALREADYPROCESS , sess , NULL , NULL , NULL , NULL , 0 ) ;
return TRUE ;
}
if ( ! strcmp ( word [ 2 ] , " -d " ) )
{
if ( ! * word [ 3 ] )
return FALSE ;
cmd = word_eol [ 3 ] ;
shell = FALSE ;
}
else if ( ! strcmp ( word [ 2 ] , " -o " ) )
{
if ( ! * word [ 3 ] )
return FALSE ;
cmd = word_eol [ 3 ] ;
tochannel = TRUE ;
}
if ( shell )
{
if ( access ( " /bin/sh " , X_OK ) ! = 0 )
{
fe_message ( _ ( " I need /bin/sh to run! \n " ) , FE_MSG_ERROR ) ;
return TRUE ;
}
}
# ifdef __EMX__ /* if os/2 */
if ( pipe ( fds ) < 0 )
{
PrintText ( sess , " Pipe create error \n " ) ;
return FALSE ;
}
setmode ( fds [ 0 ] , O_BINARY ) ;
setmode ( fds [ 1 ] , O_BINARY ) ;
# else
if ( socketpair ( PF_UNIX , SOCK_STREAM , 0 , fds ) = = - 1 )
{
PrintText ( sess , " socketpair(2) failed \n " ) ;
return FALSE ;
}
# endif
s = ( struct nbexec * ) malloc ( sizeof ( struct nbexec ) ) ;
memset ( s , 0 , sizeof ( * s ) ) ;
s - > myfd = fds [ 0 ] ;
s - > tochannel = tochannel ;
s - > sess = sess ;
pid = fork ( ) ;
if ( pid = = 0 )
{
/* This is the child's context */
close ( 0 ) ;
close ( 1 ) ;
close ( 2 ) ;
/* Close parent's end of pipe */
close ( s - > myfd ) ;
/* Copy the child end of the pipe to stdout and stderr */
dup2 ( fds [ 1 ] , 1 ) ;
dup2 ( fds [ 1 ] , 2 ) ;
/* Also copy it to stdin so we can write to it */
dup2 ( fds [ 1 ] , 0 ) ;
/* Now close all open file descriptors except stdin, stdout and stderr */
for ( fd = 3 ; fd < 1024 ; fd + + ) close ( fd ) ;
/* Now we call /bin/sh to run our cmd ; made it more friendly -DC1 */
if ( shell )
{
execl ( " /bin/sh " , " sh " , " -c " , cmd , NULL ) ;
} else
{
char * * argv ;
int argc ;
my_poptParseArgvString ( cmd , & argc , & argv ) ;
execvp ( argv [ 0 ] , argv ) ;
}
/* not reached unless error */
/*printf("exec error\n");*/
fflush ( stdout ) ;
fflush ( stdin ) ;
_exit ( 0 ) ;
}
if ( pid = = - 1 )
{
/* Parent context, fork() failed */
PrintText ( sess , " Error in fork(2) \n " ) ;
close ( fds [ 0 ] ) ;
close ( fds [ 1 ] ) ;
} else
{
/* Parent path */
close ( fds [ 1 ] ) ;
s - > childpid = pid ;
s - > iotag = fe_input_add ( s - > myfd , FIA_READ | FIA_EX , exec_data , s ) ;
sess - > running_exec = s ;
return TRUE ;
}
}
return FALSE ;
}
# endif
static int
cmd_flushq ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
sprintf ( tbuf , " Flushing server send queue, %d bytes. \n " , sess - > server - > sendq_len ) ;
PrintText ( sess , tbuf ) ;
sess - > server - > flush_queue ( sess - > server ) ;
return TRUE ;
}
static int
cmd_quit ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word_eol [ 2 ] )
sess - > quitreason = word_eol [ 2 ] ;
sess - > server - > disconnect ( sess , TRUE , - 1 ) ;
sess - > quitreason = NULL ;
return 2 ;
}
static int
cmd_gate ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * server_name = word [ 2 ] ;
server * serv = sess - > server ;
if ( * server_name )
{
char * port = word [ 3 ] ;
# ifdef USE_OPENSSL
serv - > use_ssl = FALSE ;
# endif
server_fill_her_up ( serv ) ;
if ( * port )
serv - > connect ( serv , server_name , atoi ( port ) , TRUE ) ;
else
serv - > connect ( serv , server_name , 23 , TRUE ) ;
return TRUE ;
}
return FALSE ;
}
typedef struct
{
char * cmd ;
session * sess ;
} getvalinfo ;
static void
get_int_cb ( int cancel , int val , getvalinfo * info )
{
char buf [ 512 ] ;
if ( ! cancel )
{
snprintf ( buf , sizeof ( buf ) , " %s %d " , info - > cmd , val ) ;
if ( is_session ( info - > sess ) )
handle_command ( info - > sess , buf , FALSE ) ;
}
free ( info - > cmd ) ;
free ( info ) ;
}
static int
cmd_getint ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
getvalinfo * info ;
if ( ! word [ 4 ] [ 0 ] )
return FALSE ;
info = malloc ( sizeof ( * info ) ) ;
info - > cmd = strdup ( word [ 3 ] ) ;
info - > sess = sess ;
fe_get_int ( word [ 4 ] , atoi ( word [ 2 ] ) , get_int_cb , info ) ;
return TRUE ;
}
static void
get_file_cb ( char * cmd , char * file )
{
char buf [ 1024 + 128 ] ;
/* execute the command once per file, then once more with
no args */
if ( file )
{
snprintf ( buf , sizeof ( buf ) , " %s %s " , cmd , file ) ;
handle_command ( current_sess , buf , FALSE ) ;
}
else
{
handle_command ( current_sess , cmd , FALSE ) ;
free ( cmd ) ;
}
}
static int
cmd_getfile ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int idx = 2 ;
int flags = 0 ;
if ( ! word [ 3 ] [ 0 ] )
return FALSE ;
if ( ! strcmp ( word [ 2 ] , " -folder " ) )
{
flags | = FRF_CHOOSEFOLDER ;
idx + + ;
}
if ( ! strcmp ( word [ idx ] , " -multi " ) )
{
flags | = FRF_MULTIPLE ;
idx + + ;
}
if ( ! strcmp ( word [ idx ] , " -save " ) )
{
flags | = FRF_WRITE ;
idx + + ;
}
fe_get_file ( word [ idx + 1 ] , word [ idx + 2 ] , ( void * ) get_file_cb , strdup ( word [ idx ] ) , flags ) ;
return TRUE ;
}
static void
get_str_cb ( int cancel , char * val , getvalinfo * info )
{
char buf [ 512 ] ;
if ( ! cancel )
{
snprintf ( buf , sizeof ( buf ) , " %s %s " , info - > cmd , val ) ;
if ( is_session ( info - > sess ) )
handle_command ( info - > sess , buf , FALSE ) ;
}
free ( info - > cmd ) ;
free ( info ) ;
}
static int
cmd_getstr ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
getvalinfo * info ;
if ( ! word [ 4 ] [ 0 ] )
return FALSE ;
info = malloc ( sizeof ( * info ) ) ;
info - > cmd = strdup ( word [ 3 ] ) ;
info - > sess = sess ;
fe_get_str ( word [ 4 ] , word [ 2 ] , get_str_cb , info ) ;
return TRUE ;
}
static int
cmd_ghost ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( ! word [ 2 ] [ 0 ] )
return FALSE ;
sess - > server - > p_ns_ghost ( sess - > server , word [ 2 ] , word [ 3 ] ) ;
return TRUE ;
}
static int
cmd_gui ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
switch ( str_ihash ( word [ 2 ] ) )
{
case 0x058b836e : fe_ctrl_gui ( sess , 8 , 0 ) ; break ; /* APPLY */
case 0xac1eee45 : fe_ctrl_gui ( sess , 7 , 2 ) ; break ; /* ATTACH */
case 0x05a72f63 : fe_ctrl_gui ( sess , 4 , atoi ( word [ 3 ] ) ) ; break ; /* COLOR */
case 0xb06a1793 : fe_ctrl_gui ( sess , 7 , 1 ) ; break ; /* DETACH */
case 0x05cfeff0 : fe_ctrl_gui ( sess , 3 , 0 ) ; break ; /* FLASH */
case 0x05d154d8 : fe_ctrl_gui ( sess , 2 , 0 ) ; break ; /* FOCUS */
case 0x0030dd42 : fe_ctrl_gui ( sess , 0 , 0 ) ; break ; /* HIDE */
case 0x61addbe3 : fe_ctrl_gui ( sess , 5 , 0 ) ; break ; /* ICONIFY */
case 0xc0851aaa : fe_message ( word [ 3 ] , FE_MSG_INFO | FE_MSG_MARKUP ) ; break ; /* MSGBOX */
case 0x0035dafd : fe_ctrl_gui ( sess , 1 , 0 ) ; break ; /* SHOW */
case 0x0033155f : /* MENU */
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ 3 ] , " TOGGLE " ) )
2011-02-24 06:14:30 +03:00
fe_ctrl_gui ( sess , 6 , 0 ) ;
else
return FALSE ;
break ;
default :
return FALSE ;
}
return TRUE ;
}
typedef struct
{
int longfmt ;
int i , t ;
char * buf ;
} help_list ;
static void
show_help_line ( session * sess , help_list * hl , char * name , char * usage )
{
int j , len , max ;
char * p ;
if ( name [ 0 ] = = ' . ' ) /* hidden command? */
return ;
if ( hl - > longfmt ) /* long format for /HELP -l */
{
if ( ! usage | | usage [ 0 ] = = 0 )
PrintTextf ( sess , " \003 4%s \003 : \n " , name ) ;
else
PrintTextf ( sess , " \003 4%s \003 : %s \n " , name , _ ( usage ) ) ;
return ;
}
/* append the name into buffer, but convert to uppercase */
len = strlen ( hl - > buf ) ;
p = name ;
while ( * p )
{
hl - > buf [ len ] = toupper ( ( unsigned char ) * p ) ;
len + + ;
p + + ;
}
hl - > buf [ len ] = 0 ;
hl - > t + + ;
if ( hl - > t = = 5 )
{
hl - > t = 0 ;
strcat ( hl - > buf , " \n " ) ;
PrintText ( sess , hl - > buf ) ;
hl - > buf [ 0 ] = ' ' ;
hl - > buf [ 1 ] = ' ' ;
hl - > buf [ 2 ] = 0 ;
} else
{
/* append some spaces after the command name */
max = strlen ( name ) ;
if ( max < 10 )
{
max = 10 - max ;
for ( j = 0 ; j < max ; j + + )
{
hl - > buf [ len ] = ' ' ;
len + + ;
hl - > buf [ len ] = 0 ;
}
}
}
}
static int
cmd_help ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 0 , longfmt = 0 ;
char * helpcmd = " " ;
GSList * list ;
if ( tbuf )
helpcmd = word [ 2 ] ;
if ( * helpcmd & & strcmp ( helpcmd , " -l " ) = = 0 )
longfmt = 1 ;
if ( * helpcmd & & ! longfmt )
{
help ( sess , tbuf , helpcmd , FALSE ) ;
} else
{
struct popup * pop ;
char * buf = malloc ( 4096 ) ;
help_list hl ;
hl . longfmt = longfmt ;
hl . buf = buf ;
PrintTextf ( sess , " \n %s \n \n " , _ ( " Commands Available: " ) ) ;
buf [ 0 ] = ' ' ;
buf [ 1 ] = ' ' ;
buf [ 2 ] = 0 ;
hl . t = 0 ;
hl . i = 0 ;
while ( xc_cmds [ i ] . name )
{
show_help_line ( sess , & hl , xc_cmds [ i ] . name , xc_cmds [ i ] . help ) ;
i + + ;
}
strcat ( buf , " \n " ) ;
PrintText ( sess , buf ) ;
PrintTextf ( sess , " \n %s \n \n " , _ ( " User defined commands: " ) ) ;
buf [ 0 ] = ' ' ;
buf [ 1 ] = ' ' ;
buf [ 2 ] = 0 ;
hl . t = 0 ;
hl . i = 0 ;
list = command_list ;
while ( list )
{
pop = list - > data ;
show_help_line ( sess , & hl , pop - > name , pop - > cmd ) ;
list = list - > next ;
}
strcat ( buf , " \n " ) ;
PrintText ( sess , buf ) ;
PrintTextf ( sess , " \n %s \n \n " , _ ( " Plugin defined commands: " ) ) ;
buf [ 0 ] = ' ' ;
buf [ 1 ] = ' ' ;
buf [ 2 ] = 0 ;
hl . t = 0 ;
hl . i = 0 ;
plugin_command_foreach ( sess , & hl , ( void * ) show_help_line ) ;
strcat ( buf , " \n " ) ;
PrintText ( sess , buf ) ;
free ( buf ) ;
PrintTextf ( sess , " \n %s \n \n " , _ ( " Type /HELP <command> for more information, or /HELP -l " ) ) ;
}
return TRUE ;
}
static int
cmd_id ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( word [ 2 ] [ 0 ] )
{
sess - > server - > p_ns_identify ( sess - > server , word [ 2 ] ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_ignore ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i ;
int type = 0 ;
int quiet = 0 ;
char * mask ;
if ( ! * word [ 2 ] )
{
ignore_showlist ( sess ) ;
return TRUE ;
}
if ( ! * word [ 3 ] )
return FALSE ;
i = 3 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( type = = 0 )
return FALSE ;
mask = word [ 2 ] ;
if ( strchr ( mask , ' ? ' ) = = NULL & &
2012-07-13 22:18:53 +04:00
strchr ( mask , ' * ' ) = = NULL )
2011-02-24 06:14:30 +03:00
{
mask = tbuf ;
snprintf ( tbuf , TBUFSIZE , " %s!*@* " , word [ 2 ] ) ;
}
i = ignore_add ( mask , type ) ;
if ( quiet )
return TRUE ;
switch ( i )
{
case 1 :
EMIT_SIGNAL ( XP_TE_IGNOREADD , sess , mask , NULL , NULL , NULL , 0 ) ;
break ;
case 2 : /* old ignore changed */
EMIT_SIGNAL ( XP_TE_IGNORECHANGE , sess , mask , NULL , NULL , NULL , 0 ) ;
}
return TRUE ;
}
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ i ] , " UNIGNORE " ) )
2011-02-24 06:14:30 +03:00
type | = IG_UNIG ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " ALL " ) )
2011-02-24 06:14:30 +03:00
type | = IG_PRIV | IG_NOTI | IG_CHAN | IG_CTCP | IG_INVI | IG_DCC ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " PRIV " ) )
2011-02-24 06:14:30 +03:00
type | = IG_PRIV ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " NOTI " ) )
2011-02-24 06:14:30 +03:00
type | = IG_NOTI ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " CHAN " ) )
2011-02-24 06:14:30 +03:00
type | = IG_CHAN ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " CTCP " ) )
2011-02-24 06:14:30 +03:00
type | = IG_CTCP ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " INVI " ) )
2011-02-24 06:14:30 +03:00
type | = IG_INVI ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " QUIET " ) )
2011-02-24 06:14:30 +03:00
quiet = 1 ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " NOSAVE " ) )
2011-02-24 06:14:30 +03:00
type | = IG_NOSAVE ;
2012-06-16 15:01:47 +04:00
else if ( ! g_ascii_strcasecmp ( word [ i ] , " DCC " ) )
2011-02-24 06:14:30 +03:00
type | = IG_DCC ;
else
{
sprintf ( tbuf , _ ( " Unknown arg '%s' ignored. " ) , word [ i ] ) ;
PrintText ( sess , tbuf ) ;
}
i + + ;
}
}
static int
cmd_invite ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( ! * word [ 2 ] )
return FALSE ;
if ( * word [ 3 ] )
sess - > server - > p_invite ( sess - > server , word [ 3 ] , word [ 2 ] ) ;
else
sess - > server - > p_invite ( sess - > server , sess - > channel , word [ 2 ] ) ;
return TRUE ;
}
static int
cmd_join ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * chan = word [ 2 ] ;
if ( * chan )
{
char * po , * pass = word [ 3 ] ;
sess - > server - > p_join ( sess - > server , chan , pass ) ;
if ( sess - > channel [ 0 ] = = 0 & & sess - > waitchannel [ 0 ] )
{
po = strchr ( chan , ' , ' ) ;
if ( po )
* po = 0 ;
safe_strcpy ( sess - > waitchannel , chan , CHANLEN ) ;
}
return TRUE ;
}
return FALSE ;
}
static int
cmd_kick ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * nick = word [ 2 ] ;
char * reason = word_eol [ 3 ] ;
if ( * nick )
{
sess - > server - > p_kick ( sess - > server , sess - > channel , nick , reason ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_kickban ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * nick = word [ 2 ] ;
char * reason = word_eol [ 3 ] ;
struct User * user ;
if ( * nick )
{
/* if the reason is a 1 digit number, treat it as a bantype */
user = userlist_find ( sess , nick ) ;
if ( isdigit ( ( unsigned char ) reason [ 0 ] ) & & reason [ 1 ] = = 0 )
{
ban ( sess , tbuf , nick , reason , ( user & & user - > op ) ) ;
reason [ 0 ] = 0 ;
} else
ban ( sess , tbuf , nick , " " , ( user & & user - > op ) ) ;
sess - > server - > p_kick ( sess - > server , sess - > channel , nick , reason ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_killall ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
xchat_exit ( ) ;
return 2 ;
}
static int
cmd_lagcheck ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
lag_check ( ) ;
return TRUE ;
}
static void
lastlog ( session * sess , char * search , gboolean regexp )
{
session * lastlog_sess ;
if ( ! is_session ( sess ) )
return ;
lastlog_sess = find_dialog ( sess - > server , " (lastlog) " ) ;
if ( ! lastlog_sess )
lastlog_sess = new_ircwindow ( sess - > server , " (lastlog) " , SESS_DIALOG , 0 ) ;
lastlog_sess - > lastlog_sess = sess ;
lastlog_sess - > lastlog_regexp = regexp ; /* remember the search type */
fe_text_clear ( lastlog_sess , 0 ) ;
fe_lastlog ( sess , lastlog_sess , search , regexp ) ;
}
static int
cmd_lastlog ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word_eol [ 2 ] )
{
if ( ! strcmp ( word [ 2 ] , " -r " ) )
2012-07-22 04:23:30 +04:00
# ifdef WIN32
lastlog ( sess , word_eol [ 3 ] , FALSE ) ;
# else
2011-02-24 06:14:30 +03:00
lastlog ( sess , word_eol [ 3 ] , TRUE ) ;
2012-07-22 04:23:30 +04:00
# endif
2011-02-24 06:14:30 +03:00
else
lastlog ( sess , word_eol [ 2 ] , FALSE ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_list ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
sess - > server - > p_list_channels ( sess - > server , word_eol [ 2 ] , 1 ) ;
return TRUE ;
}
gboolean
load_perform_file ( session * sess , char * file )
{
char tbuf [ 1024 + 4 ] ;
char * nl ;
FILE * fp ;
fp = xchat_fopen_file ( file , " r " , XOF_FULLPATH ) ;
if ( ! fp )
return FALSE ;
tbuf [ 1024 ] = 0 ;
while ( fgets ( tbuf , 1024 , fp ) )
{
nl = strchr ( tbuf , ' \n ' ) ;
if ( nl = = tbuf ) /* skip empty commands */
continue ;
if ( nl )
* nl = 0 ;
if ( tbuf [ 0 ] = = prefs . cmdchar [ 0 ] )
handle_command ( sess , tbuf + 1 , TRUE ) ;
else
handle_command ( sess , tbuf , TRUE ) ;
}
fclose ( fp ) ;
return TRUE ;
}
static int
cmd_load ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * error , * arg , * file ;
int len ;
if ( ! word [ 2 ] [ 0 ] )
return FALSE ;
if ( strcmp ( word [ 2 ] , " -e " ) = = 0 )
{
file = expand_homedir ( word [ 3 ] ) ;
if ( ! load_perform_file ( sess , file ) )
{
PrintTextf ( sess , _ ( " Cannot access %s \n " ) , file ) ;
PrintText ( sess , errorstring ( errno ) ) ;
}
free ( file ) ;
return TRUE ;
}
# ifdef USE_PLUGIN
len = strlen ( word [ 2 ] ) ;
# ifdef WIN32
2012-06-16 15:01:47 +04:00
if ( len > 4 & & g_ascii_strcasecmp ( " .dll " , word [ 2 ] + len - 4 ) = = 0 )
2011-02-24 06:14:30 +03:00
# else
# if defined(__hpux)
2012-06-16 15:01:47 +04:00
if ( len > 3 & & g_ascii_strcasecmp ( " .sl " , word [ 2 ] + len - 3 ) = = 0 )
2011-02-24 06:14:30 +03:00
# else
2012-06-16 15:01:47 +04:00
if ( len > 3 & & g_ascii_strcasecmp ( " .so " , word [ 2 ] + len - 3 ) = = 0 )
2011-02-24 06:14:30 +03:00
# endif
# endif
{
arg = NULL ;
if ( word_eol [ 3 ] [ 0 ] )
arg = word_eol [ 3 ] ;
file = expand_homedir ( word [ 2 ] ) ;
error = plugin_load ( sess , file , arg ) ;
free ( file ) ;
if ( error )
PrintText ( sess , error ) ;
return TRUE ;
}
# endif
sprintf ( tbuf , " Unknown file type %s. Maybe you need to install the Perl or Python plugin? \n " , word [ 2 ] ) ;
PrintText ( sess , tbuf ) ;
return FALSE ;
}
static int
cmd_me ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * act = word_eol [ 2 ] ;
if ( ! ( * act ) )
return FALSE ;
if ( sess - > type = = SESS_SERVER )
{
notj_msg ( sess ) ;
return TRUE ;
}
snprintf ( tbuf , TBUFSIZE , " \001 ACTION %s \001 \r " , act ) ;
/* first try through DCC CHAT */
if ( dcc_write_chat ( sess - > channel , tbuf ) )
{
/* print it to screen */
inbound_action ( sess , sess - > channel , sess - > server - > nick , " " , act , TRUE , FALSE ) ;
} else
{
/* DCC CHAT failed, try through server */
if ( sess - > server - > connected )
{
sess - > server - > p_action ( sess - > server , sess - > channel , act ) ;
/* print it to screen */
inbound_action ( sess , sess - > channel , sess - > server - > nick , " " , act , TRUE , FALSE ) ;
} else
{
notc_msg ( sess ) ;
}
}
return TRUE ;
}
static int
cmd_mode ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
/* +channel channels are dying, let those servers whine about modes.
* return info about current channel if available and no info is given */
if ( ( * word [ 2 ] = = ' + ' ) | | ( * word [ 2 ] = = 0 ) | | ( ! is_channel ( sess - > server , word [ 2 ] ) & &
! ( rfc_casecmp ( sess - > server - > nick , word [ 2 ] ) = = 0 ) ) )
{
if ( sess - > channel [ 0 ] = = 0 )
return FALSE ;
sess - > server - > p_mode ( sess - > server , sess - > channel , word_eol [ 2 ] ) ;
}
else
sess - > server - > p_mode ( sess - > server , word [ 2 ] , word_eol [ 3 ] ) ;
return TRUE ;
}
static int
mop_cb ( struct User * user , multidata * data )
{
if ( ! user - > op )
{
data - > nicks [ data - > i ] = user - > nick ;
data - > i + + ;
}
return TRUE ;
}
static int
cmd_mop ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * * nicks = malloc ( sizeof ( char * ) * ( sess - > total - sess - > ops ) ) ;
multidata data ;
data . nicks = nicks ;
data . i = 0 ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) mop_cb , & data ) ;
send_channel_modes ( sess , tbuf , nicks , 0 , data . i , ' + ' , ' o ' , 0 ) ;
free ( nicks ) ;
return TRUE ;
}
static int
cmd_msg ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * nick = word [ 2 ] ;
char * msg = word_eol [ 3 ] ;
struct session * newsess ;
if ( * nick )
{
if ( * msg )
{
if ( strcmp ( nick , " . " ) = = 0 )
{ /* /msg the last nick /msg'ed */
if ( sess - > lastnick [ 0 ] )
nick = sess - > lastnick ;
} else
{
safe_strcpy ( sess - > lastnick , nick , NICKLEN ) ; /* prime the last nick memory */
}
if ( * nick = = ' = ' )
{
nick + + ;
if ( ! dcc_write_chat ( nick , msg ) )
{
EMIT_SIGNAL ( XP_TE_NODCC , sess , NULL , NULL , NULL , NULL , 0 ) ;
return TRUE ;
}
} else
{
if ( ! sess - > server - > connected )
{
notc_msg ( sess ) ;
return TRUE ;
}
sess - > server - > p_message ( sess - > server , nick , msg ) ;
}
newsess = find_dialog ( sess - > server , nick ) ;
if ( ! newsess )
newsess = find_channel ( sess - > server , nick ) ;
if ( newsess )
inbound_chanmsg ( newsess - > server , NULL , newsess - > channel ,
newsess - > server - > nick , msg , TRUE , FALSE ) ;
else
{
/* mask out passwords */
2012-06-16 15:01:47 +04:00
if ( g_ascii_strcasecmp ( nick , " nickserv " ) = = 0 & &
g_ascii_strncasecmp ( msg , " identify " , 9 ) = = 0 )
2011-02-24 06:14:30 +03:00
msg = " identify **** " ;
EMIT_SIGNAL ( XP_TE_MSGSEND , sess , nick , msg , NULL , NULL , 0 ) ;
}
return TRUE ;
}
}
return FALSE ;
}
static int
cmd_names ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word [ 2 ] )
sess - > server - > p_names ( sess - > server , word [ 2 ] ) ;
else
sess - > server - > p_names ( sess - > server , sess - > channel ) ;
return TRUE ;
}
static int
cmd_nctcp ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word_eol [ 3 ] )
{
sess - > server - > p_nctcp ( sess - > server , word [ 2 ] , word_eol [ 3 ] ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_newserver ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
if ( strcmp ( word [ 2 ] , " -noconnect " ) = = 0 )
{
new_ircwindow ( NULL , word [ 3 ] , SESS_SERVER , 0 ) ;
return TRUE ;
}
sess = new_ircwindow ( NULL , NULL , SESS_SERVER , 0 ) ;
cmd_server ( sess , tbuf , word , word_eol ) ;
return TRUE ;
}
static int
cmd_nick ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * nick = word [ 2 ] ;
if ( * nick )
{
if ( sess - > server - > connected )
sess - > server - > p_change_nick ( sess - > server , nick ) ;
else
inbound_newnick ( sess - > server , sess - > server - > nick , nick , TRUE ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_notice ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word [ 2 ] & & * word_eol [ 3 ] )
{
sess - > server - > p_notice ( sess - > server , word [ 2 ] , word_eol [ 3 ] ) ;
EMIT_SIGNAL ( XP_TE_NOTICESEND , sess , word [ 2 ] , word_eol [ 3 ] , NULL , NULL , 0 ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_notify ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 1 ;
char * net = NULL ;
if ( * word [ 2 ] )
{
if ( strcmp ( word [ 2 ] , " -n " ) = = 0 ) /* comma sep network list */
{
net = word [ 3 ] ;
i + = 2 ;
}
while ( 1 )
{
i + + ;
if ( ! * word [ i ] )
break ;
if ( notify_deluser ( word [ i ] ) )
{
EMIT_SIGNAL ( XP_TE_DELNOTIFY , sess , word [ i ] , NULL , NULL , NULL , 0 ) ;
return TRUE ;
}
if ( net & & strcmp ( net , " ASK " ) = = 0 )
fe_notify_ask ( word [ i ] , NULL ) ;
else
{
notify_adduser ( word [ i ] , net ) ;
EMIT_SIGNAL ( XP_TE_ADDNOTIFY , sess , word [ i ] , NULL , NULL , NULL , 0 ) ;
}
}
} else
notify_showlist ( sess ) ;
return TRUE ;
}
static int
cmd_op ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' + ' , ' o ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
static int
cmd_part ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * chan = word [ 2 ] ;
char * reason = word_eol [ 3 ] ;
if ( ! * chan )
chan = sess - > channel ;
if ( ( * chan ) & & is_channel ( sess - > server , chan ) )
{
if ( reason [ 0 ] = = 0 )
reason = NULL ;
server_sendpart ( sess - > server , chan , reason ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_ping ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char timestring [ 64 ] ;
unsigned long tim ;
char * to = word [ 2 ] ;
tim = make_ping_time ( ) ;
snprintf ( timestring , sizeof ( timestring ) , " %lu " , tim ) ;
sess - > server - > p_ping ( sess - > server , to , timestring ) ;
return TRUE ;
}
void
open_query ( server * serv , char * nick , gboolean focus_existing )
{
session * sess ;
sess = find_dialog ( serv , nick ) ;
if ( ! sess )
new_ircwindow ( serv , nick , SESS_DIALOG , 1 ) ;
else if ( focus_existing )
fe_ctrl_gui ( sess , 2 , 0 ) ; /* bring-to-front */
}
static int
cmd_query ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * nick = word [ 2 ] ;
gboolean focus = TRUE ;
if ( strcmp ( word [ 2 ] , " -nofocus " ) = = 0 )
{
nick = word [ 3 ] ;
focus = FALSE ;
}
if ( * nick & & ! is_channel ( sess - > server , nick ) )
{
open_query ( sess - > server , nick , focus ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_quote ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * raw = word_eol [ 2 ] ;
return sess - > server - > p_raw ( sess - > server , raw ) ;
}
static int
cmd_reconnect ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int tmp = prefs . recon_delay ;
GSList * list ;
server * serv = sess - > server ;
prefs . recon_delay = 0 ;
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( word [ 2 ] , " ALL " ) )
2011-02-24 06:14:30 +03:00
{
list = serv_list ;
while ( list )
{
serv = list - > data ;
if ( serv - > connected )
serv - > auto_reconnect ( serv , TRUE , - 1 ) ;
list = list - > next ;
}
}
/* If it isn't "ALL" and there is something
there it * should * be a server they are trying to connect to */
else if ( * word [ 2 ] )
{
int offset = 0 ;
# ifdef USE_OPENSSL
int use_ssl = FALSE ;
if ( strcmp ( word [ 2 ] , " -ssl " ) = = 0 )
{
use_ssl = TRUE ;
offset + + ; /* args move up by 1 word */
}
serv - > use_ssl = use_ssl ;
serv - > accept_invalid_cert = TRUE ;
# endif
if ( * word [ 4 + offset ] )
safe_strcpy ( serv - > password , word [ 4 + offset ] , sizeof ( serv - > password ) ) ;
if ( * word [ 3 + offset ] )
serv - > port = atoi ( word [ 3 + offset ] ) ;
safe_strcpy ( serv - > hostname , word [ 2 + offset ] , sizeof ( serv - > hostname ) ) ;
serv - > auto_reconnect ( serv , TRUE , - 1 ) ;
}
else
{
serv - > auto_reconnect ( serv , TRUE , - 1 ) ;
}
prefs . recon_delay = tmp ;
return TRUE ;
}
static int
cmd_recv ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word_eol [ 2 ] )
{
sess - > server - > p_inline ( sess - > server , word_eol [ 2 ] , strlen ( word_eol [ 2 ] ) ) ;
return TRUE ;
}
return FALSE ;
}
2011-12-11 20:34:02 +04:00
#if 0 /* manual command for flushing prefs to disk, but we use an autosave-upon-set approach instead */
2011-09-08 00:08:24 +04:00
static int
cmd_saveconf ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
2011-11-23 14:51:19 +04:00
if ( save_config ( ) )
{
2011-11-23 16:25:16 +04:00
PrintText ( sess , " Settings have been saved successfully. \n " ) ;
2011-11-23 14:51:19 +04:00
}
else
{
2011-11-23 16:25:16 +04:00
PrintText ( sess , " Error saving settings. \n " ) ;
2011-11-23 14:51:19 +04:00
}
2011-09-08 00:08:24 +04:00
return TRUE ;
}
2011-12-11 20:34:02 +04:00
# endif
2011-09-08 00:08:24 +04:00
2011-02-24 06:14:30 +03:00
static int
cmd_say ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
char * speech = word_eol [ 2 ] ;
if ( * speech )
{
handle_say ( sess , speech , FALSE ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_send ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
guint32 addr ;
socklen_t len ;
struct sockaddr_in SAddr ;
if ( ! word [ 2 ] [ 0 ] )
return FALSE ;
addr = dcc_get_my_address ( ) ;
if ( addr = = 0 )
{
/* use the one from our connected server socket */
memset ( & SAddr , 0 , sizeof ( struct sockaddr_in ) ) ;
len = sizeof ( SAddr ) ;
getsockname ( sess - > server - > sok , ( struct sockaddr * ) & SAddr , & len ) ;
addr = SAddr . sin_addr . s_addr ;
}
addr = ntohl ( addr ) ;
if ( ( addr & 0xffff0000 ) = = 0xc0a80000 | | /* 192.168.x.x */
( addr & 0xff000000 ) = = 0x0a000000 ) /* 10.x.x.x */
/* we got a private net address, let's PSEND or it'll fail */
snprintf ( tbuf , 512 , " DCC PSEND %s " , word_eol [ 2 ] ) ;
else
snprintf ( tbuf , 512 , " DCC SEND %s " , word_eol [ 2 ] ) ;
handle_command ( sess , tbuf , FALSE ) ;
return TRUE ;
}
static int
cmd_setcursor ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int delta = FALSE ;
if ( * word [ 2 ] )
{
if ( word [ 2 ] [ 0 ] = = ' - ' | | word [ 2 ] [ 0 ] = = ' + ' )
delta = TRUE ;
fe_set_inputbox_cursor ( sess , delta , atoi ( word [ 2 ] ) ) ;
return TRUE ;
}
return FALSE ;
}
static int
cmd_settab ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word_eol [ 2 ] )
{
strcpy ( tbuf , sess - > channel ) ;
safe_strcpy ( sess - > channel , word_eol [ 2 ] , CHANLEN ) ;
fe_set_channel ( sess ) ;
strcpy ( sess - > channel , tbuf ) ;
}
return TRUE ;
}
static int
cmd_settext ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
fe_set_inputbox_contents ( sess , word_eol [ 2 ] ) ;
return TRUE ;
}
static int
cmd_splay ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( * word [ 2 ] )
{
sound_play ( word [ 2 ] , FALSE ) ;
return TRUE ;
}
return FALSE ;
}
static int
parse_irc_url ( char * url , char * server_name [ ] , char * port [ ] , char * channel [ ] , int * use_ssl )
{
char * co ;
# ifdef USE_OPENSSL
2012-06-16 15:01:47 +04:00
if ( g_ascii_strncasecmp ( " ircs:// " , url , 7 ) = = 0 )
2011-02-24 06:14:30 +03:00
{
* use_ssl = TRUE ;
* server_name = url + 7 ;
goto urlserv ;
}
# endif
2012-06-16 15:01:47 +04:00
if ( g_ascii_strncasecmp ( " irc:// " , url , 6 ) = = 0 )
2011-02-24 06:14:30 +03:00
{
* server_name = url + 6 ;
# ifdef USE_OPENSSL
urlserv :
# endif
/* check for port */
co = strchr ( * server_name , ' : ' ) ;
if ( co )
{
* port = co + 1 ;
* co = 0 ;
} else
co = * server_name ;
/* check for channel - mirc style */
co = strchr ( co + 1 , ' / ' ) ;
if ( co )
{
* co = 0 ;
co + + ;
if ( * co = = ' # ' )
* channel = co + 1 ;
else
* channel = co ;
}
return TRUE ;
}
return FALSE ;
}
static int
cmd_server ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int offset = 0 ;
char * server_name = NULL ;
char * port = NULL ;
char * pass = NULL ;
char * channel = NULL ;
int use_ssl = FALSE ;
int is_url = TRUE ;
server * serv = sess - > server ;
# ifdef USE_OPENSSL
/* BitchX uses -ssl, mIRC uses -e, let's support both */
if ( strcmp ( word [ 2 ] , " -ssl " ) = = 0 | | strcmp ( word [ 2 ] , " -e " ) = = 0 )
{
use_ssl = TRUE ;
offset + + ; /* args move up by 1 word */
}
# endif
if ( ! parse_irc_url ( word [ 2 + offset ] , & server_name , & port , & channel , & use_ssl ) )
{
is_url = FALSE ;
server_name = word [ 2 + offset ] ;
}
if ( port )
pass = word [ 3 + offset ] ;
else
{
port = word [ 3 + offset ] ;
pass = word [ 4 + offset ] ;
}
if ( ! ( * server_name ) )
return FALSE ;
sess - > server - > network = NULL ;
/* dont clear it for /servchan */
2012-06-16 15:01:47 +04:00
if ( g_ascii_strncasecmp ( word_eol [ 1 ] , " SERVCHAN " , 9 ) )
2011-02-24 06:14:30 +03:00
sess - > willjoinchannel [ 0 ] = 0 ;
if ( channel )
{
sess - > willjoinchannel [ 0 ] = ' # ' ;
safe_strcpy ( ( sess - > willjoinchannel + 1 ) , channel , ( CHANLEN - 1 ) ) ;
}
/* support +7000 style ports like mIRC */
if ( port [ 0 ] = = ' + ' )
{
port + + ;
# ifdef USE_OPENSSL
use_ssl = TRUE ;
# endif
}
if ( * pass )
{
safe_strcpy ( serv - > password , pass , sizeof ( serv - > password ) ) ;
}
# ifdef USE_OPENSSL
serv - > use_ssl = use_ssl ;
serv - > accept_invalid_cert = TRUE ;
# endif
/* try to connect by Network name */
if ( servlist_connect_by_netname ( sess , server_name , ! is_url ) )
return TRUE ;
if ( * port )
{
serv - > connect ( serv , server_name , atoi ( port ) , FALSE ) ;
} else
{
/* -1 for default port */
serv - > connect ( serv , server_name , - 1 , FALSE ) ;
}
/* try to associate this connection with a listed network */
if ( ! serv - > network )
/* search for this hostname in the entire server list */
serv - > network = servlist_net_find_from_server ( server_name ) ;
/* may return NULL, but that's OK */
return TRUE ;
}
static int
cmd_servchan ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
int offset = 0 ;
# ifdef USE_OPENSSL
if ( strcmp ( word [ 2 ] , " -ssl " ) = = 0 )
offset + + ;
# endif
if ( * word [ 4 + offset ] )
{
safe_strcpy ( sess - > willjoinchannel , word [ 4 + offset ] , CHANLEN ) ;
return cmd_server ( sess , tbuf , word , word_eol ) ;
}
return FALSE ;
}
static int
cmd_topic ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( word [ 2 ] [ 0 ] & & is_channel ( sess - > server , word [ 2 ] ) )
sess - > server - > p_topic ( sess - > server , word [ 2 ] , word_eol [ 3 ] ) ;
else
sess - > server - > p_topic ( sess - > server , sess - > channel , word_eol [ 2 ] ) ;
return TRUE ;
}
static int
cmd_tray ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( strcmp ( word [ 2 ] , " -b " ) = = 0 )
{
fe_tray_set_balloon ( word [ 3 ] , word [ 4 ] [ 0 ] ? word [ 4 ] : NULL ) ;
return TRUE ;
}
if ( strcmp ( word [ 2 ] , " -t " ) = = 0 )
{
fe_tray_set_tooltip ( word [ 3 ] [ 0 ] ? word [ 3 ] : NULL ) ;
return TRUE ;
}
if ( strcmp ( word [ 2 ] , " -i " ) = = 0 )
{
fe_tray_set_icon ( atoi ( word [ 3 ] ) ) ;
return TRUE ;
}
if ( strcmp ( word [ 2 ] , " -f " ) ! = 0 )
return FALSE ;
if ( ! word [ 3 ] [ 0 ] )
{
fe_tray_set_file ( NULL ) ; /* default xchat icon */
return TRUE ;
}
if ( ! word [ 4 ] [ 0 ] )
{
fe_tray_set_file ( word [ 3 ] ) ; /* fixed custom icon */
return TRUE ;
}
/* flash between 2 icons */
fe_tray_set_flash ( word [ 4 ] , word [ 5 ] [ 0 ] ? word [ 5 ] : NULL , atoi ( word [ 3 ] ) ) ;
return TRUE ;
}
static int
cmd_unignore ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
char * mask = word [ 2 ] ;
char * arg = word [ 3 ] ;
if ( * mask )
{
if ( ignore_del ( mask , NULL ) )
{
2012-06-16 15:01:47 +04:00
if ( g_ascii_strcasecmp ( arg , " QUIET " ) )
2011-02-24 06:14:30 +03:00
EMIT_SIGNAL ( XP_TE_IGNOREREMOVE , sess , mask , NULL , NULL , NULL , 0 ) ;
}
return TRUE ;
}
return FALSE ;
}
static int
cmd_unload ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
# ifdef USE_PLUGIN
int len , by_file = FALSE ;
len = strlen ( word [ 2 ] ) ;
# ifdef WIN32
2012-06-16 15:01:47 +04:00
if ( len > 4 & & g_ascii_strcasecmp ( word [ 2 ] + len - 4 , " .dll " ) = = 0 )
2011-02-24 06:14:30 +03:00
# else
# if defined(__hpux)
2012-06-16 15:01:47 +04:00
if ( len > 3 & & g_ascii_strcasecmp ( word [ 2 ] + len - 3 , " .sl " ) = = 0 )
2011-02-24 06:14:30 +03:00
# else
2012-06-16 15:01:47 +04:00
if ( len > 3 & & g_ascii_strcasecmp ( word [ 2 ] + len - 3 , " .so " ) = = 0 )
2011-02-24 06:14:30 +03:00
# endif
# endif
by_file = TRUE ;
switch ( plugin_kill ( word [ 2 ] , by_file ) )
{
case 0 :
PrintText ( sess , _ ( " No such plugin found. \n " ) ) ;
break ;
case 1 :
return TRUE ;
case 2 :
PrintText ( sess , _ ( " That plugin is refusing to unload. \n " ) ) ;
break ;
}
# endif
return FALSE ;
}
static server *
find_server_from_hostname ( char * hostname )
{
GSList * list = serv_list ;
server * serv ;
while ( list )
{
serv = list - > data ;
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( hostname , serv - > hostname ) & & serv - > connected )
2011-02-24 06:14:30 +03:00
return serv ;
list = list - > next ;
}
return NULL ;
}
static server *
find_server_from_net ( void * net )
{
GSList * list = serv_list ;
server * serv ;
while ( list )
{
serv = list - > data ;
if ( serv - > network = = net & & serv - > connected )
return serv ;
list = list - > next ;
}
return NULL ;
}
static void
url_join_only ( server * serv , char * tbuf , char * channel )
{
/* already connected, JOIN only. FIXME: support keys? */
tbuf [ 0 ] = ' # ' ;
/* tbuf is 4kb */
safe_strcpy ( ( tbuf + 1 ) , channel , 256 ) ;
serv - > p_join ( serv , tbuf , " " ) ;
}
static int
cmd_url ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
if ( word [ 2 ] [ 0 ] )
{
char * server_name = NULL ;
char * port = NULL ;
char * channel = NULL ;
char * url = g_strdup ( word [ 2 ] ) ;
int use_ssl = FALSE ;
void * net ;
server * serv ;
if ( parse_irc_url ( url , & server_name , & port , & channel , & use_ssl ) )
{
/* maybe we're already connected to this net */
/* check for "FreeNode" */
2012-06-16 15:01:47 +04:00
net = servlist_net_find ( server_name , NULL , g_ascii_strcasecmp ) ;
2011-02-24 06:14:30 +03:00
/* check for "irc.eu.freenode.net" */
if ( ! net )
net = servlist_net_find_from_server ( server_name ) ;
if ( net )
{
/* found the network, but are we connected? */
serv = find_server_from_net ( net ) ;
if ( serv )
{
url_join_only ( serv , tbuf , channel ) ;
g_free ( url ) ;
return TRUE ;
}
}
else
{
/* an un-listed connection */
serv = find_server_from_hostname ( server_name ) ;
if ( serv )
{
url_join_only ( serv , tbuf , channel ) ;
g_free ( url ) ;
return TRUE ;
}
}
/* not connected to this net, open new window */
cmd_newserver ( sess , tbuf , word , word_eol ) ;
} else
fe_open_url ( word [ 2 ] ) ;
g_free ( url ) ;
return TRUE ;
}
return FALSE ;
}
static int
userlist_cb ( struct User * user , session * sess )
{
time_t lt ;
if ( ! user - > lasttalk )
lt = 0 ;
else
lt = time ( 0 ) - user - > lasttalk ;
PrintTextf ( sess ,
" \003 06%s \t \003 14[ \003 10%-38s \003 14] \017 ov \003 3= \017 %d%d away=%u lt \003 3= \017 %d \n " ,
user - > nick , user - > hostname , user - > op , user - > voice , user - > away , lt ) ;
return TRUE ;
}
static int
cmd_uselect ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int idx = 2 ;
int clear = TRUE ;
int scroll = FALSE ;
if ( strcmp ( word [ 2 ] , " -a " ) = = 0 ) /* ADD (don't clear selections) */
{
clear = FALSE ;
idx + + ;
}
if ( strcmp ( word [ idx ] , " -s " ) = = 0 ) /* SCROLL TO */
{
scroll = TRUE ;
idx + + ;
}
/* always valid, no args means clear the selection list */
fe_uselect ( sess , word + idx , clear , scroll ) ;
return TRUE ;
}
static int
cmd_userlist ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) userlist_cb , sess ) ;
return TRUE ;
}
static int
wallchop_cb ( struct User * user , multidata * data )
{
if ( user - > op )
{
if ( data - > i )
strcat ( data - > tbuf , " , " ) ;
strcat ( data - > tbuf , user - > nick ) ;
data - > i + + ;
}
if ( data - > i = = 5 )
{
data - > i = 0 ;
sprintf ( data - > tbuf + strlen ( data - > tbuf ) ,
" :[@%s] %s " , data - > sess - > channel , data - > reason ) ;
data - > sess - > server - > p_raw ( data - > sess - > server , data - > tbuf ) ;
strcpy ( data - > tbuf , " NOTICE " ) ;
}
return TRUE ;
}
static int
cmd_wallchop ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
multidata data ;
if ( ! ( * word_eol [ 2 ] ) )
return FALSE ;
strcpy ( tbuf , " NOTICE " ) ;
data . reason = word_eol [ 2 ] ;
data . tbuf = tbuf ;
data . i = 0 ;
data . sess = sess ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) wallchop_cb , & data ) ;
if ( data . i )
{
sprintf ( tbuf + strlen ( tbuf ) ,
" :[@%s] %s " , sess - > channel , word_eol [ 2 ] ) ;
sess - > server - > p_raw ( sess - > server , tbuf ) ;
}
return TRUE ;
}
static int
cmd_wallchan ( struct session * sess , char * tbuf , char * word [ ] ,
char * word_eol [ ] )
{
GSList * list ;
if ( * word_eol [ 2 ] )
{
list = sess_list ;
while ( list )
{
sess = list - > data ;
if ( sess - > type = = SESS_CHANNEL )
{
inbound_chanmsg ( sess - > server , NULL , sess - > channel ,
sess - > server - > nick , word_eol [ 2 ] , TRUE , FALSE ) ;
sess - > server - > p_message ( sess - > server , sess - > channel , word_eol [ 2 ] ) ;
}
list = list - > next ;
}
return TRUE ;
}
return FALSE ;
}
static int
cmd_hop ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' + ' , ' h ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
static int
cmd_voice ( struct session * sess , char * tbuf , char * word [ ] , char * word_eol [ ] )
{
int i = 2 ;
while ( 1 )
{
if ( ! * word [ i ] )
{
if ( i = = 2 )
return FALSE ;
send_channel_modes ( sess , tbuf , word , 2 , i , ' + ' , ' v ' , 0 ) ;
return TRUE ;
}
i + + ;
}
}
/* *MUST* be kept perfectly sorted for the bsearch to work */
const struct commands xc_cmds [ ] = {
{ " ADDBUTTON " , cmd_addbutton , 0 , 0 , 1 ,
N_ ( " ADDBUTTON <name> <action>, adds a button under the user-list " ) } ,
{ " ALLCHAN " , cmd_allchannels , 0 , 0 , 1 ,
N_ ( " ALLCHAN <cmd>, sends a command to all channels you're in " ) } ,
{ " ALLCHANL " , cmd_allchannelslocal , 0 , 0 , 1 ,
2012-05-13 16:33:30 +04:00
N_ ( " ALLCHANL <cmd>, sends a command to all channels on the current server " ) } ,
2011-02-24 06:14:30 +03:00
{ " ALLSERV " , cmd_allservers , 0 , 0 , 1 ,
N_ ( " ALLSERV <cmd>, sends a command to all servers you're in " ) } ,
{ " AWAY " , cmd_away , 1 , 0 , 1 , N_ ( " AWAY [<reason>], sets you away " ) } ,
{ " BACK " , cmd_back , 1 , 0 , 1 , N_ ( " BACK, sets you back (not away) " ) } ,
{ " BAN " , cmd_ban , 1 , 1 , 1 ,
N_ ( " BAN <mask> [<bantype>], bans everyone matching the mask from the current channel. If they are already on the channel this doesn't kick them (needs chanop) " ) } ,
{ " CHANOPT " , cmd_chanopt , 0 , 0 , 1 , N_ ( " CHANOPT [-quiet] <variable> [<value>] " ) } ,
2012-05-13 16:33:30 +04:00
{ " CHARSET " , cmd_charset , 0 , 0 , 1 , N_ ( " CHARSET [<encoding>], get or set the encoding used for the current connection " ) } ,
2011-02-24 06:14:30 +03:00
{ " CLEAR " , cmd_clear , 0 , 0 , 1 , N_ ( " CLEAR [ALL|HISTORY], Clears the current text window or command history " ) } ,
{ " CLOSE " , cmd_close , 0 , 0 , 1 , N_ ( " CLOSE, Closes the current window/tab " ) } ,
{ " COUNTRY " , cmd_country , 0 , 0 , 1 ,
N_ ( " COUNTRY [-s] <code|wildcard>, finds a country code, eg: au = australia " ) } ,
{ " CTCP " , cmd_ctcp , 1 , 0 , 1 ,
N_ ( " CTCP <nick> <message>, send the CTCP message to nick, common messages are VERSION and USERINFO " ) } ,
{ " CYCLE " , cmd_cycle , 1 , 1 , 1 ,
N_ ( " CYCLE [<channel>], parts the current or given channel and immediately rejoins " ) } ,
{ " DCC " , cmd_dcc , 0 , 0 , 1 ,
N_ ( " \n "
" DCC GET <nick> - accept an offered file \n "
" DCC SEND [-maxcps=#] <nick> [file] - send a file to someone \n "
" DCC PSEND [-maxcps=#] <nick> [file] - send a file using passive mode \n "
" DCC LIST - show DCC list \n "
" DCC CHAT <nick> - offer DCC CHAT to someone \n "
" DCC PCHAT <nick> - offer DCC CHAT using passive mode \n "
" DCC CLOSE <type> <nick> <file> example: \n "
" /dcc close send johnsmith file.tar.gz " ) } ,
{ " DEBUG " , cmd_debug , 0 , 0 , 1 , 0 } ,
{ " DEHOP " , cmd_dehop , 1 , 1 , 1 ,
N_ ( " DEHOP <nick>, removes chanhalf-op status from the nick on the current channel (needs chanop) " ) } ,
{ " DELBUTTON " , cmd_delbutton , 0 , 0 , 1 ,
N_ ( " DELBUTTON <name>, deletes a button from under the user-list " ) } ,
{ " DEOP " , cmd_deop , 1 , 1 , 1 ,
N_ ( " DEOP <nick>, removes chanop status from the nick on the current channel (needs chanop) " ) } ,
{ " DEVOICE " , cmd_devoice , 1 , 1 , 1 ,
N_ ( " DEVOICE <nick>, removes voice status from the nick on the current channel (needs chanop) " ) } ,
{ " DISCON " , cmd_discon , 0 , 0 , 1 , N_ ( " DISCON, Disconnects from server " ) } ,
{ " DNS " , cmd_dns , 0 , 0 , 1 , N_ ( " DNS <nick|host|ip>, Finds a users IP number " ) } ,
{ " ECHO " , cmd_echo , 0 , 0 , 1 , N_ ( " ECHO <text>, Prints text locally " ) } ,
# ifndef WIN32
{ " EXEC " , cmd_exec , 0 , 0 , 1 ,
N_ ( " EXEC [-o] <command>, runs the command. If -o flag is used then output is sent to current channel, else is printed to current text box " ) } ,
# ifndef __EMX__
{ " EXECCONT " , cmd_execc , 0 , 0 , 1 , N_ ( " EXECCONT, sends the process SIGCONT " ) } ,
# endif
{ " EXECKILL " , cmd_execk , 0 , 0 , 1 ,
N_ ( " EXECKILL [-9], kills a running exec in the current session. If -9 is given the process is SIGKILL'ed " ) } ,
# ifndef __EMX__
{ " EXECSTOP " , cmd_execs , 0 , 0 , 1 , N_ ( " EXECSTOP, sends the process SIGSTOP " ) } ,
{ " EXECWRITE " , cmd_execw , 0 , 0 , 1 , N_ ( " EXECWRITE, sends data to the processes stdin " ) } ,
# endif
# endif
{ " FLUSHQ " , cmd_flushq , 0 , 0 , 1 ,
N_ ( " FLUSHQ, flushes the current server's send queue " ) } ,
{ " GATE " , cmd_gate , 0 , 0 , 1 ,
N_ ( " GATE <host> [<port>], proxies through a host, port defaults to 23 " ) } ,
{ " GETFILE " , cmd_getfile , 0 , 0 , 1 , " GETFILE [-folder] [-multi] [-save] <command> <title> [<initial>] " } ,
{ " GETINT " , cmd_getint , 0 , 0 , 1 , " GETINT <default> <command> <prompt> " } ,
{ " GETSTR " , cmd_getstr , 0 , 0 , 1 , " GETSTR <default> <command> <prompt> " } ,
{ " GHOST " , cmd_ghost , 1 , 0 , 1 , N_ ( " GHOST <nick> [password], Kills a ghosted nickname " ) } ,
{ " GUI " , cmd_gui , 0 , 0 , 1 , " GUI [APPLY|ATTACH|DETACH|SHOW|HIDE|FOCUS|FLASH|ICONIFY|COLOR <n>] \n "
" GUI [MSGBOX <text>|MENU TOGGLE] " } ,
{ " HELP " , cmd_help , 0 , 0 , 1 , 0 } ,
{ " HOP " , cmd_hop , 1 , 1 , 1 ,
N_ ( " HOP <nick>, gives chanhalf-op status to the nick (needs chanop) " ) } ,
{ " ID " , cmd_id , 1 , 0 , 1 , N_ ( " ID <password>, identifies yourself to nickserv " ) } ,
{ " IGNORE " , cmd_ignore , 0 , 0 , 1 ,
N_ ( " IGNORE <mask> <types..> <options..> \n "
" mask - host mask to ignore, eg: *!*@*.aol.com \n "
" types - types of data to ignore, one or all of: \n "
" PRIV, CHAN, NOTI, CTCP, DCC, INVI, ALL \n "
" options - NOSAVE, QUIET " ) } ,
{ " INVITE " , cmd_invite , 1 , 0 , 1 ,
N_ ( " INVITE <nick> [<channel>], invites someone to a channel, by default the current channel (needs chanop) " ) } ,
{ " JOIN " , cmd_join , 1 , 0 , 0 , N_ ( " JOIN <channel>, joins the channel " ) } ,
{ " KICK " , cmd_kick , 1 , 1 , 1 ,
N_ ( " KICK <nick>, kicks the nick from the current channel (needs chanop) " ) } ,
{ " KICKBAN " , cmd_kickban , 1 , 1 , 1 ,
N_ ( " KICKBAN <nick>, bans then kicks the nick from the current channel (needs chanop) " ) } ,
{ " KILLALL " , cmd_killall , 0 , 0 , 1 , " KILLALL, immediately exit " } ,
{ " LAGCHECK " , cmd_lagcheck , 0 , 0 , 1 ,
N_ ( " LAGCHECK, forces a new lag check " ) } ,
{ " LASTLOG " , cmd_lastlog , 0 , 0 , 1 ,
2012-07-22 04:13:36 +04:00
N_ ( " LASTLOG [-r] <string>, searches for a string in the buffer " ) } ,
2011-02-24 06:14:30 +03:00
{ " LIST " , cmd_list , 1 , 0 , 1 , 0 } ,
{ " LOAD " , cmd_load , 0 , 0 , 1 , N_ ( " LOAD [-e] <file>, loads a plugin or script " ) } ,
{ " MDEHOP " , cmd_mdehop , 1 , 1 , 1 ,
N_ ( " MDEHOP, Mass deop's all chanhalf-ops in the current channel (needs chanop) " ) } ,
{ " MDEOP " , cmd_mdeop , 1 , 1 , 1 ,
N_ ( " MDEOP, Mass deop's all chanops in the current channel (needs chanop) " ) } ,
{ " ME " , cmd_me , 0 , 0 , 1 ,
N_ ( " ME <action>, sends the action to the current channel (actions are written in the 3rd person, like /me jumps) " ) } ,
{ " MENU " , cmd_menu , 0 , 0 , 1 , " MENU [-eX] [-i<ICONFILE>] [-k<mod>,<key>] [-m] [-pX] [-r<X,group>] [-tX] {ADD|DEL} <path> [command] [unselect command] \n "
" See http://xchat.org/docs/menu/ for more details. " } ,
{ " MKICK " , cmd_mkick , 1 , 1 , 1 ,
N_ ( " MKICK, Mass kicks everyone except you in the current channel (needs chanop) " ) } ,
{ " MODE " , cmd_mode , 1 , 0 , 1 , 0 } ,
{ " MOP " , cmd_mop , 1 , 1 , 1 ,
N_ ( " MOP, Mass op's all users in the current channel (needs chanop) " ) } ,
{ " MSG " , cmd_msg , 0 , 0 , 1 , N_ ( " MSG <nick> <message>, sends a private message " ) } ,
{ " NAMES " , cmd_names , 1 , 0 , 1 ,
N_ ( " NAMES, Lists the nicks on the current channel " ) } ,
{ " NCTCP " , cmd_nctcp , 1 , 0 , 1 ,
N_ ( " NCTCP <nick> <message>, Sends a CTCP notice " ) } ,
{ " NEWSERVER " , cmd_newserver , 0 , 0 , 1 , N_ ( " NEWSERVER [-noconnect] <hostname> [<port>] " ) } ,
{ " NICK " , cmd_nick , 0 , 0 , 1 , N_ ( " NICK <nickname>, sets your nick " ) } ,
{ " NOTICE " , cmd_notice , 1 , 0 , 1 ,
N_ ( " NOTICE <nick/channel> <message>, sends a notice. Notices are a type of message that should be auto reacted to " ) } ,
{ " NOTIFY " , cmd_notify , 0 , 0 , 1 ,
N_ ( " NOTIFY [-n network1[,network2,...]] [<nick>], displays your notify list or adds someone to it " ) } ,
{ " OP " , cmd_op , 1 , 1 , 1 ,
N_ ( " OP <nick>, gives chanop status to the nick (needs chanop) " ) } ,
{ " PART " , cmd_part , 1 , 1 , 0 ,
N_ ( " PART [<channel>] [<reason>], leaves the channel, by default the current one " ) } ,
{ " PING " , cmd_ping , 1 , 0 , 1 ,
N_ ( " PING <nick | channel>, CTCP pings nick or channel " ) } ,
{ " QUERY " , cmd_query , 0 , 0 , 1 ,
N_ ( " QUERY [-nofocus] <nick>, opens up a new privmsg window to someone " ) } ,
{ " QUIT " , cmd_quit , 0 , 0 , 1 ,
N_ ( " QUIT [<reason>], disconnects from the current server " ) } ,
{ " QUOTE " , cmd_quote , 1 , 0 , 1 ,
N_ ( " QUOTE <text>, sends the text in raw form to the server " ) } ,
# ifdef USE_OPENSSL
{ " RECONNECT " , cmd_reconnect , 0 , 0 , 1 ,
N_ ( " RECONNECT [-ssl] [<host>] [<port>] [<password>], Can be called just as /RECONNECT to reconnect to the current server or with /RECONNECT ALL to reconnect to all the open servers " ) } ,
# else
{ " RECONNECT " , cmd_reconnect , 0 , 0 , 1 ,
N_ ( " RECONNECT [<host>] [<port>] [<password>], Can be called just as /RECONNECT to reconnect to the current server or with /RECONNECT ALL to reconnect to all the open servers " ) } ,
# endif
{ " RECV " , cmd_recv , 1 , 0 , 1 , N_ ( " RECV <text>, send raw data to xchat, as if it was received from the irc server " ) } ,
2011-12-11 20:34:02 +04:00
#if 0
{ " SAVECONF " , cmd_saveconf , 0 , 0 , 1 , N_ ( " SAVECONF, saves the current settings to disk " ) } ,
# endif
2011-02-24 06:14:30 +03:00
{ " SAY " , cmd_say , 0 , 0 , 1 ,
N_ ( " SAY <text>, sends the text to the object in the current window " ) } ,
{ " SEND " , cmd_send , 0 , 0 , 1 , N_ ( " SEND <nick> [<file>] " ) } ,
# ifdef USE_OPENSSL
{ " SERVCHAN " , cmd_servchan , 0 , 0 , 1 ,
N_ ( " SERVCHAN [-ssl] <host> <port> <channel>, connects and joins a channel " ) } ,
# else
{ " SERVCHAN " , cmd_servchan , 0 , 0 , 1 ,
N_ ( " SERVCHAN <host> <port> <channel>, connects and joins a channel " ) } ,
# endif
# ifdef USE_OPENSSL
{ " SERVER " , cmd_server , 0 , 0 , 1 ,
N_ ( " SERVER [-ssl] <host> [<port>] [<password>], connects to a server, the default port is 6667 for normal connections, and 9999 for ssl connections " ) } ,
# else
{ " SERVER " , cmd_server , 0 , 0 , 1 ,
N_ ( " SERVER <host> [<port>] [<password>], connects to a server, the default port is 6667 " ) } ,
# endif
{ " SET " , cmd_set , 0 , 0 , 1 , N_ ( " SET [-e] [-off|-on] [-quiet] <variable> [<value>] " ) } ,
2012-05-13 16:33:30 +04:00
{ " SETCURSOR " , cmd_setcursor , 0 , 0 , 1 , N_ ( " SETCURSOR [-|+]<position>, reposition the cursor in the inputbox " ) } ,
{ " SETTAB " , cmd_settab , 0 , 0 , 1 , N_ ( " SETTAB <new name>, change a tab's name, tab_trunc limit still applies " ) } ,
{ " SETTEXT " , cmd_settext , 0 , 0 , 1 , N_ ( " SETTEXT <new text>, replace the text in the input box " ) } ,
2011-02-24 06:14:30 +03:00
{ " SPLAY " , cmd_splay , 0 , 0 , 1 , " SPLAY <soundfile> " } ,
{ " TOPIC " , cmd_topic , 1 , 1 , 1 ,
N_ ( " TOPIC [<topic>], sets the topic if one is given, else shows the current topic " ) } ,
{ " TRAY " , cmd_tray , 0 , 0 , 1 ,
N_ ( " \n TRAY -f <timeout> <file1> [<file2>] Blink tray between two icons. \n "
" TRAY -f <filename> Set tray to a fixed icon. \n "
" TRAY -i <number> Blink tray with an internal icon. \n "
" TRAY -t <text> Set the tray tooltip. \n "
" TRAY -b <title> <text> Set the tray balloon. "
) } ,
{ " UNBAN " , cmd_unban , 1 , 1 , 1 ,
N_ ( " UNBAN <mask> [<mask>...], unbans the specified masks. " ) } ,
{ " UNIGNORE " , cmd_unignore , 0 , 0 , 1 , N_ ( " UNIGNORE <mask> [QUIET] " ) } ,
{ " UNLOAD " , cmd_unload , 0 , 0 , 1 , N_ ( " UNLOAD <name>, unloads a plugin or script " ) } ,
{ " URL " , cmd_url , 0 , 0 , 1 , N_ ( " URL <url>, opens a URL in your browser " ) } ,
{ " USELECT " , cmd_uselect , 0 , 1 , 0 ,
N_ ( " USELECT [-a] [-s] <nick1> <nick2> etc, highlights nick(s) in channel userlist " ) } ,
{ " USERLIST " , cmd_userlist , 1 , 1 , 1 , 0 } ,
{ " VOICE " , cmd_voice , 1 , 1 , 1 ,
N_ ( " VOICE <nick>, gives voice status to someone (needs chanop) " ) } ,
{ " WALLCHAN " , cmd_wallchan , 1 , 1 , 1 ,
N_ ( " WALLCHAN <message>, writes the message to all channels " ) } ,
{ " WALLCHOP " , cmd_wallchop , 1 , 1 , 1 ,
N_ ( " WALLCHOP <message>, sends the message to all chanops on the current channel " ) } ,
{ 0 , 0 , 0 , 0 , 0 , 0 }
} ;
static int
command_compare ( const void * a , const void * b )
{
2012-06-16 15:01:47 +04:00
return g_ascii_strcasecmp ( a , ( ( struct commands * ) b ) - > name ) ;
2011-02-24 06:14:30 +03:00
}
static struct commands *
find_internal_command ( char * name )
{
/* the "-1" is to skip the NULL terminator */
return bsearch ( name , xc_cmds , ( sizeof ( xc_cmds ) /
sizeof ( xc_cmds [ 0 ] ) ) - 1 , sizeof ( xc_cmds [ 0 ] ) , command_compare ) ;
}
static void
help ( session * sess , char * tbuf , char * helpcmd , int quiet )
{
struct commands * cmd ;
if ( plugin_show_help ( sess , helpcmd ) )
return ;
cmd = find_internal_command ( helpcmd ) ;
if ( cmd )
{
if ( cmd - > help )
{
snprintf ( tbuf , TBUFSIZE , _ ( " Usage: %s \n " ) , _ ( cmd - > help ) ) ;
PrintText ( sess , tbuf ) ;
} else
{
if ( ! quiet )
PrintText ( sess , _ ( " \n No help available on that command. \n " ) ) ;
}
return ;
}
if ( ! quiet )
PrintText ( sess , _ ( " No such command. \n " ) ) ;
}
/* inserts %a, %c, %d etc into buffer. Also handles &x %x for word/word_eol. *
* returns 2 on buffer overflow
* returns 1 on success *
* returns 0 on bad - args - for - user - command *
* - word / word_eol args might be NULL *
* - this beast is used for UserCommands , UserlistButtons and CTCP replies */
int
auto_insert ( char * dest , int destlen , unsigned char * src , char * word [ ] ,
char * word_eol [ ] , char * a , char * c , char * d , char * e , char * h ,
char * n , char * s )
{
int num ;
char buf [ 32 ] ;
time_t now ;
struct tm * tm_ptr ;
char * utf ;
gsize utf_len ;
char * orig = dest ;
destlen - - ;
while ( src [ 0 ] )
{
if ( src [ 0 ] = = ' % ' | | src [ 0 ] = = ' & ' )
{
if ( isdigit ( ( unsigned char ) src [ 1 ] ) )
{
if ( isdigit ( ( unsigned char ) src [ 2 ] ) & & isdigit ( ( unsigned char ) src [ 3 ] ) )
{
buf [ 0 ] = src [ 1 ] ;
buf [ 1 ] = src [ 2 ] ;
buf [ 2 ] = src [ 3 ] ;
buf [ 3 ] = 0 ;
dest [ 0 ] = atoi ( buf ) ;
utf = g_locale_to_utf8 ( dest , 1 , 0 , & utf_len , 0 ) ;
if ( utf )
{
if ( ( dest - orig ) + utf_len > = destlen )
{
g_free ( utf ) ;
return 2 ;
}
memcpy ( dest , utf , utf_len ) ;
g_free ( utf ) ;
dest + = utf_len ;
}
src + = 3 ;
} else
{
if ( word )
{
src + + ;
num = src [ 0 ] - ' 0 ' ; /* ascii to decimal */
if ( * word [ num ] = = 0 )
return 0 ;
if ( src [ - 1 ] = = ' % ' )
utf = word [ num ] ;
else
utf = word_eol [ num ] ;
/* avoid recusive usercommand overflow */
if ( ( dest - orig ) + strlen ( utf ) > = destlen )
return 2 ;
strcpy ( dest , utf ) ;
dest + = strlen ( dest ) ;
}
}
} else
{
if ( src [ 0 ] = = ' & ' )
goto lamecode ;
src + + ;
utf = NULL ;
switch ( src [ 0 ] )
{
case ' % ' :
if ( ( dest - orig ) + 2 > = destlen )
return 2 ;
dest [ 0 ] = ' % ' ;
dest [ 1 ] = 0 ;
dest + + ;
break ;
case ' a ' :
utf = a ; break ;
case ' c ' :
utf = c ; break ;
case ' d ' :
utf = d ; break ;
case ' e ' :
utf = e ; break ;
case ' h ' :
utf = h ; break ;
case ' m ' :
utf = get_cpu_str ( ) ; break ;
case ' n ' :
utf = n ; break ;
case ' s ' :
utf = s ; break ;
case ' t ' :
now = time ( 0 ) ;
utf = ctime ( & now ) ;
utf [ 19 ] = 0 ;
break ;
case ' v ' :
utf = PACKAGE_VERSION ; break ;
break ;
case ' y ' :
now = time ( 0 ) ;
tm_ptr = localtime ( & now ) ;
snprintf ( buf , sizeof ( buf ) , " %4d%02d%02d " , 1900 +
tm_ptr - > tm_year , 1 + tm_ptr - > tm_mon , tm_ptr - > tm_mday ) ;
utf = buf ;
break ;
default :
src - - ;
goto lamecode ;
}
if ( utf )
{
if ( ( dest - orig ) + strlen ( utf ) > = destlen )
return 2 ;
strcpy ( dest , utf ) ;
dest + = strlen ( dest ) ;
}
}
src + + ;
} else
{
utf_len = g_utf8_skip [ src [ 0 ] ] ;
if ( ( dest - orig ) + utf_len > = destlen )
return 2 ;
if ( utf_len = = 1 )
{
lamecode :
dest [ 0 ] = src [ 0 ] ;
dest + + ;
src + + ;
} else
{
memcpy ( dest , src , utf_len ) ;
dest + = utf_len ;
src + = utf_len ;
}
}
}
dest [ 0 ] = 0 ;
return 1 ;
}
void
check_special_chars ( char * cmd , int do_ascii ) /* check for %X */
{
int occur = 0 ;
int len = strlen ( cmd ) ;
char * buf , * utf ;
char tbuf [ 4 ] ;
int i = 0 , j = 0 ;
gsize utf_len ;
if ( ! len )
return ;
buf = malloc ( len + 1 ) ;
if ( buf )
{
while ( cmd [ j ] )
{
switch ( cmd [ j ] )
{
case ' % ' :
occur + + ;
if ( do_ascii & &
j + 3 < len & &
( isdigit ( ( unsigned char ) cmd [ j + 1 ] ) & & isdigit ( ( unsigned char ) cmd [ j + 2 ] ) & &
isdigit ( ( unsigned char ) cmd [ j + 3 ] ) ) )
{
tbuf [ 0 ] = cmd [ j + 1 ] ;
tbuf [ 1 ] = cmd [ j + 2 ] ;
tbuf [ 2 ] = cmd [ j + 3 ] ;
tbuf [ 3 ] = 0 ;
buf [ i ] = atoi ( tbuf ) ;
utf = g_locale_to_utf8 ( buf + i , 1 , 0 , & utf_len , 0 ) ;
if ( utf )
{
memcpy ( buf + i , utf , utf_len ) ;
g_free ( utf ) ;
i + = ( utf_len - 1 ) ;
}
j + = 3 ;
} else
{
switch ( cmd [ j + 1 ] )
{
case ' R ' :
buf [ i ] = ' \026 ' ;
break ;
case ' U ' :
buf [ i ] = ' \037 ' ;
break ;
case ' B ' :
buf [ i ] = ' \002 ' ;
break ;
case ' C ' :
buf [ i ] = ' \003 ' ;
break ;
case ' O ' :
buf [ i ] = ' \017 ' ;
break ;
case ' H ' : /* CL: invisible text code */
buf [ i ] = HIDDEN_CHAR ;
break ;
case ' % ' :
buf [ i ] = ' % ' ;
break ;
default :
buf [ i ] = ' % ' ;
j - - ;
break ;
}
j + + ;
break ;
default :
buf [ i ] = cmd [ j ] ;
}
}
j + + ;
i + + ;
}
buf [ i ] = 0 ;
if ( occur )
strcpy ( cmd , buf ) ;
free ( buf ) ;
}
}
typedef struct
{
char * nick ;
int len ;
struct User * best ;
int bestlen ;
char * space ;
char * tbuf ;
} nickdata ;
static int
nick_comp_cb ( struct User * user , nickdata * data )
{
int lenu ;
if ( ! rfc_ncasecmp ( user - > nick , data - > nick , data - > len ) )
{
lenu = strlen ( user - > nick ) ;
if ( lenu = = data - > len )
{
snprintf ( data - > tbuf , TBUFSIZE , " %s%s " , user - > nick , data - > space ) ;
data - > len = - 1 ;
return FALSE ;
} else if ( lenu < data - > bestlen )
{
data - > bestlen = lenu ;
data - > best = user ;
}
}
return TRUE ;
}
static void
perform_nick_completion ( struct session * sess , char * cmd , char * tbuf )
{
int len ;
char * space = strchr ( cmd , ' ' ) ;
if ( space & & space ! = cmd )
{
if ( space [ - 1 ] = = prefs . nick_suffix [ 0 ] & & space - 1 ! = cmd )
{
len = space - cmd - 1 ;
if ( len < NICKLEN )
{
char nick [ NICKLEN ] ;
nickdata data ;
memcpy ( nick , cmd , len ) ;
nick [ len ] = 0 ;
data . nick = nick ;
data . len = len ;
data . bestlen = INT_MAX ;
data . best = NULL ;
data . tbuf = tbuf ;
data . space = space - 1 ;
tree_foreach ( sess - > usertree , ( tree_traverse_func * ) nick_comp_cb , & data ) ;
if ( data . len = = - 1 )
return ;
if ( data . best )
{
snprintf ( tbuf , TBUFSIZE , " %s%s " , data . best - > nick , space - 1 ) ;
return ;
}
}
}
}
strcpy ( tbuf , cmd ) ;
}
static void
user_command ( session * sess , char * tbuf , char * cmd , char * word [ ] ,
char * word_eol [ ] )
{
if ( ! auto_insert ( tbuf , 2048 , cmd , word , word_eol , " " , sess - > channel , " " ,
server_get_network ( sess - > server , TRUE ) , " " ,
sess - > server - > nick , " " ) )
{
PrintText ( sess , _ ( " Bad arguments for user command. \n " ) ) ;
return ;
}
handle_command ( sess , tbuf , TRUE ) ;
}
/* handle text entered without a CMDchar prefix */
static void
handle_say ( session * sess , char * text , int check_spch )
{
struct DCC * dcc ;
char * word [ PDIWORDS + 1 ] ;
char * word_eol [ PDIWORDS + 1 ] ;
char pdibuf_static [ 1024 ] ;
char newcmd_static [ 1024 ] ;
char * pdibuf = pdibuf_static ;
char * newcmd = newcmd_static ;
int len ;
int newcmdlen = sizeof newcmd_static ;
if ( strcmp ( sess - > channel , " (lastlog) " ) = = 0 )
{
lastlog ( sess - > lastlog_sess , text , sess - > lastlog_regexp ) ;
return ;
}
len = strlen ( text ) ;
if ( len > = sizeof pdibuf_static )
pdibuf = malloc ( len + 1 ) ;
if ( len + NICKLEN > = newcmdlen )
newcmd = malloc ( newcmdlen = len + NICKLEN + 1 ) ;
if ( check_spch & & prefs . perc_color )
check_special_chars ( text , prefs . perc_ascii ) ;
/* Python relies on this */
word [ PDIWORDS ] = NULL ;
word_eol [ PDIWORDS ] = NULL ;
/* split the text into words and word_eol */
process_data_init ( pdibuf , text , word , word_eol , TRUE , FALSE ) ;
/* a command of "" can be hooked for non-commands */
if ( plugin_emit_command ( sess , " " , word , word_eol ) )
goto xit ;
/* incase a plugin did /close */
if ( ! is_session ( sess ) )
goto xit ;
if ( ! sess - > channel [ 0 ] | | sess - > type = = SESS_SERVER | | sess - > type = = SESS_NOTICES | | sess - > type = = SESS_SNOTICES )
{
notj_msg ( sess ) ;
goto xit ;
}
if ( prefs . nickcompletion )
perform_nick_completion ( sess , text , newcmd ) ;
else
safe_strcpy ( newcmd , text , newcmdlen ) ;
text = newcmd ;
if ( sess - > type = = SESS_DIALOG )
{
/* try it via dcc, if possible */
dcc = dcc_write_chat ( sess - > channel , text ) ;
if ( dcc )
{
inbound_chanmsg ( sess - > server , NULL , sess - > channel ,
sess - > server - > nick , text , TRUE , FALSE ) ;
set_topic ( sess , net_ip ( dcc - > addr ) , net_ip ( dcc - > addr ) ) ;
goto xit ;
}
}
if ( sess - > server - > connected )
{
unsigned int max ;
unsigned char t = 0 ;
/* maximum allowed message text */
/* :nickname!username@host.com PRIVMSG #channel :text\r\n */
max = 512 ;
max - = 16 ; /* :, !, @, " PRIVMSG ", " ", :, \r, \n */
max - = strlen ( sess - > server - > nick ) ;
max - = strlen ( sess - > channel ) ;
if ( sess - > me & & sess - > me - > hostname )
max - = strlen ( sess - > me - > hostname ) ;
else
{
max - = 9 ; /* username */
max - = 65 ; /* max possible hostname and '@' */
}
if ( strlen ( text ) > max )
{
int i = 0 , size ;
/* traverse the utf8 string and find the nearest cut point that
doesn ' t split 1 char in half */
while ( 1 )
{
size = g_utf8_skip [ ( ( unsigned char * ) text ) [ i ] ] ;
if ( ( i + size ) > = max )
break ;
i + = size ;
}
max = i ;
t = text [ max ] ;
text [ max ] = 0 ; /* insert a NULL terminator to shorten it */
}
inbound_chanmsg ( sess - > server , sess , sess - > channel , sess - > server - > nick ,
text , TRUE , FALSE ) ;
sess - > server - > p_message ( sess - > server , sess - > channel , text ) ;
if ( t )
{
text [ max ] = t ;
handle_say ( sess , text + max , FALSE ) ;
}
} else
{
notc_msg ( sess ) ;
}
xit :
if ( pdibuf ! = pdibuf_static )
free ( pdibuf ) ;
if ( newcmd ! = newcmd_static )
free ( newcmd ) ;
}
/* handle a command, without the '/' prefix */
int
handle_command ( session * sess , char * cmd , int check_spch )
{
struct popup * pop ;
int user_cmd = FALSE ;
GSList * list ;
char * word [ PDIWORDS + 1 ] ;
char * word_eol [ PDIWORDS + 1 ] ;
static int command_level = 0 ;
struct commands * int_cmd ;
char pdibuf_static [ 1024 ] ;
char tbuf_static [ TBUFSIZE ] ;
char * pdibuf ;
char * tbuf ;
int len ;
int ret = TRUE ;
if ( command_level > 99 )
{
fe_message ( _ ( " Too many recursive usercommands, aborting. " ) , FE_MSG_ERROR ) ;
return TRUE ;
}
command_level + + ;
/* anything below MUST DEC command_level before returning */
len = strlen ( cmd ) ;
if ( len > = sizeof ( pdibuf_static ) )
pdibuf = malloc ( len + 1 ) ;
else
pdibuf = pdibuf_static ;
if ( ( len * 2 ) > = sizeof ( tbuf_static ) )
tbuf = malloc ( ( len * 2 ) + 1 ) ;
else
tbuf = tbuf_static ;
/* split the text into words and word_eol */
process_data_init ( pdibuf , cmd , word , word_eol , TRUE , TRUE ) ;
/* ensure an empty string at index 32 for cmd_deop etc */
/* (internal use only, plugins can still only read 1-31). */
word [ PDIWORDS ] = " \000 \000 " ;
word_eol [ PDIWORDS ] = " \000 \000 " ;
int_cmd = find_internal_command ( word [ 1 ] ) ;
/* redo it without quotes processing, for some commands like /JOIN */
if ( int_cmd & & ! int_cmd - > handle_quotes )
process_data_init ( pdibuf , cmd , word , word_eol , FALSE , FALSE ) ;
if ( check_spch & & prefs . perc_color )
check_special_chars ( cmd , prefs . perc_ascii ) ;
if ( plugin_emit_command ( sess , word [ 1 ] , word , word_eol ) )
goto xit ;
/* incase a plugin did /close */
if ( ! is_session ( sess ) )
goto xit ;
/* first see if it's a userCommand */
list = command_list ;
while ( list )
{
pop = ( struct popup * ) list - > data ;
2012-06-16 15:01:47 +04:00
if ( ! g_ascii_strcasecmp ( pop - > name , word [ 1 ] ) )
2011-02-24 06:14:30 +03:00
{
user_command ( sess , tbuf , pop - > cmd , word , word_eol ) ;
user_cmd = TRUE ;
}
list = list - > next ;
}
if ( user_cmd )
goto xit ;
/* now check internal commands */
int_cmd = find_internal_command ( word [ 1 ] ) ;
if ( int_cmd )
{
if ( int_cmd - > needserver & & ! sess - > server - > connected )
{
notc_msg ( sess ) ;
} else if ( int_cmd - > needchannel & & ! sess - > channel [ 0 ] )
{
notj_msg ( sess ) ;
} else
{
switch ( int_cmd - > callback ( sess , tbuf , word , word_eol ) )
{
case FALSE :
help ( sess , tbuf , int_cmd - > name , TRUE ) ;
break ;
case 2 :
ret = FALSE ;
goto xit ;
}
}
} else
{
/* unknown command, just send it to the server and hope */
if ( ! sess - > server - > connected )
PrintText ( sess , _ ( " Unknown Command. Try /help \n " ) ) ;
else
sess - > server - > p_raw ( sess - > server , cmd ) ;
}
xit :
command_level - - ;
if ( pdibuf ! = pdibuf_static )
free ( pdibuf ) ;
if ( tbuf ! = tbuf_static )
free ( tbuf ) ;
return ret ;
}
/* handle one line entered into the input box */
static int
handle_user_input ( session * sess , char * text , int history , int nocommand )
{
if ( * text = = ' \0 ' )
return 1 ;
if ( history )
history_add ( & sess - > history , text ) ;
/* is it NOT a command, just text? */
if ( nocommand | | text [ 0 ] ! = prefs . cmdchar [ 0 ] )
{
handle_say ( sess , text , TRUE ) ;
return 1 ;
}
/* check for // */
if ( text [ 0 ] = = prefs . cmdchar [ 0 ] & & text [ 1 ] = = prefs . cmdchar [ 0 ] )
{
handle_say ( sess , text + 1 , TRUE ) ;
return 1 ;
}
if ( prefs . cmdchar [ 0 ] = = ' / ' )
{
int i ;
const char * unix_dirs [ ] = {
" /bin/ " , " /boot/ " , " /dev/ " ,
" /etc/ " , " /home/ " , " /lib/ " ,
" /lost+found/ " , " /mnt/ " , " /opt/ " ,
" /proc/ " , " /root/ " , " /sbin/ " ,
" /tmp/ " , " /usr/ " , " /var/ " ,
" /gnome/ " , NULL } ;
for ( i = 0 ; unix_dirs [ i ] ! = NULL ; i + + )
if ( strncmp ( text , unix_dirs [ i ] , strlen ( unix_dirs [ i ] ) ) = = 0 )
{
handle_say ( sess , text , TRUE ) ;
return 1 ;
}
}
return handle_command ( sess , text + 1 , TRUE ) ;
}
/* changed by Steve Green. Macs sometimes paste with imbedded \r */
void
handle_multiline ( session * sess , char * cmd , int history , int nocommand )
{
while ( * cmd )
{
char * cr = cmd + strcspn ( cmd , " \n \r " ) ;
int end_of_string = * cr = = 0 ;
* cr = 0 ;
if ( ! handle_user_input ( sess , cmd , history , nocommand ) )
return ;
if ( end_of_string )
break ;
cmd = cr + 1 ;
}
}
/*void
handle_multiline ( session * sess , char * cmd , int history , int nocommand )
{
char * cr ;
cr = strchr ( cmd , ' \n ' ) ;
if ( cr )
{
while ( 1 )
{
if ( cr )
* cr = 0 ;
if ( ! handle_user_input ( sess , cmd , history , nocommand ) )
return ;
if ( ! cr )
break ;
cmd = cr + 1 ;
if ( * cmd = = 0 )
break ;
cr = strchr ( cmd , ' \n ' ) ;
}
} else
{
handle_user_input ( sess , cmd , history , nocommand ) ;
}
} */