2013-12-15 11:10:32 -05:00
/*
2016-05-22 19:06:01 -04:00
* cmd_funcs . c
2013-12-15 11:10:32 -05:00
*
2019-01-22 05:31:45 -05:00
* Copyright ( C ) 2012 - 2019 James Booth < boothj5 @ gmail . com >
2019-08-02 04:23:13 -04:00
* Copyright ( C ) 2019 Michael Vetter < jubalh @ iodoru . org >
2013-12-15 11:10:32 -05:00
*
* This file is part of Profanity .
*
* Profanity 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 3 of the License , or
* ( at your option ) any later version .
*
* Profanity 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
2016-07-23 20:14:49 -04:00
* along with Profanity . If not , see < https : //www.gnu.org/licenses/>.
2013-12-15 11:10:32 -05:00
*
2014-08-24 15:57:39 -04:00
* In addition , as a special exception , the copyright holders give permission to
* link the code of portions of this program with the OpenSSL library under
* certain conditions as described in each individual source file , and
* distribute linked combinations including the two .
*
* You must obey the GNU General Public License in all respects for all of the
* code used other than OpenSSL . If you modify file ( s ) with this exception , you
* may extend this exception to your version of the file ( s ) , but you are not
* obligated to do so . If you do not wish to do so , delete this exception
* statement from your version . If you delete this exception statement from all
* source files in the program , then also delete it here .
*
2013-12-15 11:10:32 -05:00
*/
2016-04-11 14:13:18 -04:00
# define _GNU_SOURCE 1
2016-03-31 16:05:02 -04:00
# include "config.h"
2014-05-19 16:25:21 -04:00
2013-12-15 11:10:32 -05:00
# include <string.h>
# include <stdlib.h>
2016-04-11 14:13:18 -04:00
# include <stdio.h>
2013-12-15 11:10:32 -05:00
# include <errno.h>
2014-12-21 19:01:43 -05:00
# include <assert.h>
2013-12-15 11:10:32 -05:00
# include <glib.h>
2015-11-23 21:09:51 -05:00
# include <sys/stat.h>
# include <sys/types.h>
# include <fcntl.h>
# include <unistd.h>
2015-12-19 18:32:58 -05:00
# include <langinfo.h>
2016-01-06 19:38:17 -05:00
# include <ctype.h>
2013-12-15 11:10:32 -05:00
2016-07-24 10:43:51 -04:00
# include "profanity.h"
# include "log.h"
# include "common.h"
2016-05-22 18:59:52 -04:00
# include "command/cmd_funcs.h"
# include "command/cmd_defs.h"
# include "command/cmd_ac.h"
2013-12-15 11:10:32 -05:00
# include "config/accounts.h"
2014-01-22 17:22:01 -05:00
# include "config/account.h"
2013-12-15 11:10:32 -05:00
# include "config/preferences.h"
# include "config/theme.h"
2015-09-23 19:43:41 -04:00
# include "config/tlscerts.h"
2015-10-15 18:57:52 -04:00
# include "config/scripts.h"
2016-07-24 10:43:51 -04:00
# include "event/client_events.h"
# include "tools/http_upload.h"
# include "tools/autocomplete.h"
# include "tools/parser.h"
# include "tools/tinyurl.h"
# include "plugins/plugins.h"
# include "ui/ui.h"
# include "ui/window_list.h"
# include "xmpp/xmpp.h"
2018-09-05 08:37:26 -04:00
# include "xmpp/connection.h"
2016-07-24 09:55:32 -04:00
# include "xmpp/contact.h"
2016-07-24 10:08:47 -04:00
# include "xmpp/roster_list.h"
2016-07-24 09:59:28 -04:00
# include "xmpp/jid.h"
2016-07-24 10:02:43 -04:00
# include "xmpp/muc.h"
2016-07-24 10:43:51 -04:00
# include "xmpp/chat_session.h"
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBOTR
2014-02-12 17:19:21 -05:00
# include "otr/otr.h"
2014-05-19 15:41:19 -04:00
# endif
2016-07-24 10:43:51 -04:00
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBGPGME
2015-03-21 20:12:14 -04:00
# include "pgp/gpg.h"
# endif
2016-07-24 10:43:51 -04:00
2019-02-19 13:23:50 -05:00
# ifdef HAVE_OMEMO
2019-02-18 23:44:47 -05:00
# include "omemo/omemo.h"
2019-04-01 07:14:46 -04:00
# include "xmpp/omemo.h"
2019-02-18 23:44:47 -05:00
# endif
2016-04-16 10:29:32 -04:00
# ifdef HAVE_GTK
2016-07-24 10:10:58 -04:00
# include "ui/tray.h"
2016-04-16 10:29:32 -04:00
# endif
2016-07-24 10:43:51 -04:00
2016-07-23 21:12:56 -04:00
# ifdef HAVE_PYTHON
# include "plugins/python_plugins.h"
# endif
2013-12-15 11:10:32 -05:00
static void _update_presence ( const resource_presence_t presence ,
2015-10-24 19:31:42 -04:00
const char * const show , gchar * * args ) ;
2016-04-17 18:46:29 -04:00
static void _cmd_set_boolean_preference ( gchar * arg , const char * const command ,
2015-10-24 19:31:42 -04:00
const char * const display , preference_t pref ) ;
static void _who_room ( ProfWin * window , const char * const command , gchar * * args ) ;
static void _who_roster ( ProfWin * window , const char * const command , gchar * * args ) ;
2016-05-22 19:31:00 -04:00
static gboolean _cmd_execute ( ProfWin * window , const char * const command , const char * const inp ) ;
2016-05-22 19:39:36 -04:00
static gboolean _cmd_execute_default ( ProfWin * window , const char * inp ) ;
2016-05-22 19:31:00 -04:00
static gboolean _cmd_execute_alias ( ProfWin * window , const char * const inp , gboolean * ran ) ;
2013-12-15 11:10:32 -05:00
2016-05-22 19:31:00 -04:00
/*
* Take a line of input and process it , return TRUE if profanity is to
* continue , FALSE otherwise
*/
gboolean
cmd_process_input ( ProfWin * window , char * inp )
{
log_debug ( " Input received: %s " , inp ) ;
gboolean result = FALSE ;
g_strchomp ( inp ) ;
// just carry on if no input
if ( strlen ( inp ) = = 0 ) {
result = TRUE ;
// handle command if input starts with a '/'
} else if ( inp [ 0 ] = = ' / ' ) {
char * inp_cpy = strdup ( inp ) ;
char * command = strtok ( inp_cpy , " " ) ;
char * question_mark = strchr ( command , ' ? ' ) ;
if ( question_mark ) {
* question_mark = ' \0 ' ;
char * fakeinp ;
if ( asprintf ( & fakeinp , " /help %s " , command + 1 ) ) {
result = _cmd_execute ( window , " /help " , fakeinp ) ;
free ( fakeinp ) ;
}
} else {
result = _cmd_execute ( window , command , inp ) ;
}
free ( inp_cpy ) ;
// call a default handler if input didn't start with '/'
} else {
2016-05-22 19:39:36 -04:00
result = _cmd_execute_default ( window , inp ) ;
2016-05-22 19:31:00 -04:00
}
return result ;
}
// Command execution
void
cmd_execute_connect ( ProfWin * window , const char * const account )
{
GString * command = g_string_new ( " /connect " ) ;
g_string_append ( command , account ) ;
cmd_process_input ( window , command - > str ) ;
g_string_free ( command , TRUE ) ;
}
2015-09-22 16:42:05 -04:00
gboolean
2016-04-26 15:29:45 -04:00
cmd_tls_certpath ( ProfWin * window , const char * const command , gchar * * args )
2015-09-22 16:42:05 -04:00
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBMESODE
2016-04-26 15:29:45 -04:00
if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 ) {
if ( args [ 2 ] = = NULL ) {
2015-09-23 15:37:41 -04:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-04-26 15:29:45 -04:00
if ( g_file_test ( args [ 2 ] , G_FILE_TEST_IS_DIR ) ) {
prefs_set_string ( PREF_TLS_CERTPATH , args [ 2 ] ) ;
cons_show ( " Certificate path set to: %s " , args [ 2 ] ) ;
} else {
cons_show ( " Directory %s does not exist. " , args [ 2 ] ) ;
}
2015-11-10 18:26:19 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " clear " ) = = 0 ) {
2016-10-17 18:48:03 -04:00
prefs_set_string ( PREF_TLS_CERTPATH , " none " ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " Certificate path cleared " ) ;
return TRUE ;
2016-10-17 18:48:03 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " default " ) = = 0 ) {
prefs_set_string ( PREF_TLS_CERTPATH , NULL ) ;
cons_show ( " Certificate path defaulted to finding system certpath. " ) ;
return TRUE ;
2016-04-26 15:29:45 -04:00
} else if ( args [ 1 ] = = NULL ) {
2016-10-17 18:48:03 -04:00
char * path = prefs_get_tls_certpath ( ) ;
2016-04-26 15:29:45 -04:00
if ( path ) {
cons_show ( " Trusted certificate path: %s " , path ) ;
2016-10-17 18:48:03 -04:00
free ( path ) ;
2016-04-26 15:29:45 -04:00
} else {
cons_show ( " No trusted certificate path set. " ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
# else
cons_show ( " Certificate path setting only supported when built with libmesode. " ) ;
return TRUE ;
2015-11-10 18:26:19 -05:00
# endif
2016-04-26 15:29:45 -04:00
}
gboolean
cmd_tls_trust ( ProfWin * window , const char * const command , gchar * * args )
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBMESODE
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-04-26 15:29:45 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
2018-09-05 05:40:37 -04:00
cons_show ( " You are currently not connected. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2016-05-05 21:18:31 -04:00
if ( ! connection_is_secured ( ) ) {
2016-04-26 15:29:45 -04:00
cons_show ( " No TLS connection established " ) ;
return TRUE ;
}
2016-05-05 20:47:19 -04:00
TLSCertificate * cert = connection_get_tls_peer_cert ( ) ;
2016-04-26 15:29:45 -04:00
if ( ! cert ) {
cons_show ( " Error getting TLS certificate. " ) ;
return TRUE ;
}
if ( tlscerts_exists ( cert - > fingerprint ) ) {
cons_show ( " Certificate %s already trusted. " , cert - > fingerprint ) ;
2015-11-10 19:57:38 -05:00
tlscerts_free ( cert ) ;
2015-11-10 18:26:19 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
cons_show ( " Adding %s to trusted certificates. " , cert - > fingerprint ) ;
tlscerts_add ( cert ) ;
tlscerts_free ( cert ) ;
return TRUE ;
2015-11-10 18:26:19 -05:00
# else
2016-04-26 15:29:45 -04:00
cons_show ( " Manual certificate trust only supported when built with libmesode. " ) ;
return TRUE ;
2015-11-09 18:31:21 -05:00
# endif
2016-04-26 15:29:45 -04:00
}
gboolean
cmd_tls_trusted ( ProfWin * window , const char * const command , gchar * * args )
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBMESODE
2016-04-26 15:29:45 -04:00
GList * certs = tlscerts_list ( ) ;
GList * curr = certs ;
2015-09-23 19:43:41 -04:00
2016-04-26 15:29:45 -04:00
if ( curr ) {
cons_show ( " Trusted certificates: " ) ;
cons_show ( " " ) ;
} else {
cons_show ( " No trusted certificates found. " ) ;
}
while ( curr ) {
TLSCertificate * cert = curr - > data ;
cons_show_tlscert_summary ( cert ) ;
cons_show ( " " ) ;
curr = g_list_next ( curr ) ;
}
g_list_free_full ( certs , ( GDestroyNotify ) tlscerts_free ) ;
return TRUE ;
2015-11-09 18:31:21 -05:00
# else
2016-04-26 15:29:45 -04:00
cons_show ( " Manual certificate trust only supported when built with libmesode. " ) ;
return TRUE ;
2015-11-09 18:31:21 -05:00
# endif
2016-04-26 15:29:45 -04:00
}
gboolean
cmd_tls_revoke ( ProfWin * window , const char * const command , gchar * * args )
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBMESODE
2016-04-26 15:29:45 -04:00
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
} else {
gboolean res = tlscerts_revoke ( args [ 1 ] ) ;
if ( res ) {
cons_show ( " Trusted certificate revoked: %s " , args [ 1 ] ) ;
2015-09-23 20:06:53 -04:00
} else {
2016-10-05 19:45:55 -04:00
cons_show ( " Could not find certificate: %s " , args [ 1 ] ) ;
2015-09-23 20:06:53 -04:00
}
2016-04-26 15:29:45 -04:00
}
return TRUE ;
2015-11-09 18:31:21 -05:00
# else
2016-04-26 15:29:45 -04:00
cons_show ( " Manual certificate trust only supported when built with libmesode. " ) ;
return TRUE ;
2015-11-09 18:31:21 -05:00
# endif
2016-04-26 15:29:45 -04:00
}
gboolean
cmd_tls_show ( ProfWin * window , const char * const command , gchar * * args )
{
_cmd_set_boolean_preference ( args [ 1 ] , command , " TLS titlebar indicator " , PREF_TLS_SHOW ) ;
return TRUE ;
}
gboolean
cmd_tls_cert ( ProfWin * window , const char * const command , gchar * * args )
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBMESODE
2016-04-26 15:29:45 -04:00
if ( args [ 1 ] ) {
TLSCertificate * cert = tlscerts_get_trusted ( args [ 1 ] ) ;
if ( ! cert ) {
cons_show ( " No such certificate. " ) ;
2015-11-22 14:53:41 -05:00
} else {
cons_show_tlscert ( cert ) ;
tlscerts_free ( cert ) ;
2015-11-09 18:31:21 -05:00
}
return TRUE ;
2015-09-23 15:37:41 -04:00
} else {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-04-26 15:29:45 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2016-05-05 21:18:31 -04:00
if ( ! connection_is_secured ( ) ) {
2016-04-26 15:29:45 -04:00
cons_show ( " No TLS connection established " ) ;
return TRUE ;
}
2016-05-05 20:47:19 -04:00
TLSCertificate * cert = connection_get_tls_peer_cert ( ) ;
2016-04-26 15:29:45 -04:00
if ( ! cert ) {
cons_show ( " Error getting TLS certificate. " ) ;
return TRUE ;
}
cons_show_tlscert ( cert ) ;
cons_show ( " " ) ;
tlscerts_free ( cert ) ;
2015-09-23 15:37:41 -04:00
return TRUE ;
}
2016-04-26 15:29:45 -04:00
# else
cons_show ( " Certificate fetching not supported. " ) ;
return TRUE ;
# endif
2015-09-22 16:42:05 -04:00
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_connect ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-05-10 18:18:11 -04:00
if ( conn_status ! = JABBER_DISCONNECTED ) {
2014-04-12 10:20:19 -04:00
cons_show ( " You are either connected already, or a login is in process. " ) ;
2015-04-21 19:29:37 -04:00
return TRUE ;
}
2014-04-14 18:15:39 -04:00
2015-10-17 22:06:23 -04:00
gchar * opt_keys [ ] = { " server " , " port " , " tls " , NULL } ;
2015-04-21 19:29:37 -04:00
gboolean parsed ;
2014-04-14 18:15:39 -04:00
2015-04-21 19:29:37 -04:00
GHashTable * options = parse_options ( & args [ args [ 0 ] ? 1 : 0 ] , opt_keys , & parsed ) ;
if ( ! parsed ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-04-21 19:29:37 -04:00
cons_show ( " " ) ;
2019-10-06 11:19:17 -04:00
options_destroy ( options ) ;
2015-04-21 19:29:37 -04:00
return TRUE ;
}
2013-12-15 11:10:32 -05:00
2015-04-21 19:29:37 -04:00
char * altdomain = g_hash_table_lookup ( options , " server " ) ;
2014-01-17 20:45:05 -05:00
2015-10-17 22:06:23 -04:00
char * tls_policy = g_hash_table_lookup ( options , " tls " ) ;
if ( tls_policy & &
( g_strcmp0 ( tls_policy , " force " ) ! = 0 ) & &
( g_strcmp0 ( tls_policy , " allow " ) ! = 0 ) & &
2018-11-06 07:01:27 -05:00
( g_strcmp0 ( tls_policy , " trust " ) ! = 0 ) & &
2017-06-24 14:33:30 -04:00
( g_strcmp0 ( tls_policy , " disable " ) ! = 0 ) & &
( g_strcmp0 ( tls_policy , " legacy " ) ! = 0 ) ) {
2015-10-17 22:06:23 -04:00
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
2019-10-06 11:19:17 -04:00
options_destroy ( options ) ;
2015-10-17 22:06:23 -04:00
return TRUE ;
}
2015-04-21 19:29:37 -04:00
int port = 0 ;
if ( g_hash_table_contains ( options , " port " ) ) {
char * port_str = g_hash_table_lookup ( options , " port " ) ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( port_str , & port , 1 , 65535 , & err_msg ) ;
if ( ! res ) {
cons_show ( err_msg ) ;
cons_show ( " " ) ;
free ( err_msg ) ;
port = 0 ;
2019-10-06 11:19:17 -04:00
options_destroy ( options ) ;
2015-04-21 19:29:37 -04:00
return TRUE ;
2014-11-27 14:18:54 -05:00
}
2015-04-21 19:29:37 -04:00
}
2015-01-13 00:00:03 -05:00
2015-04-21 19:29:37 -04:00
char * user = args [ 0 ] ;
char * def = prefs_get_string ( PREF_DEFAULT_ACCOUNT ) ;
if ( ! user ) {
if ( def ) {
user = def ;
cons_show ( " Using default account %s. " , user ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-04-21 19:29:37 -04:00
cons_show ( " No default account. " ) ;
g_free ( def ) ;
2019-10-06 11:19:17 -04:00
options_destroy ( options ) ;
2015-04-21 19:29:37 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2015-04-21 19:29:37 -04:00
}
2013-12-15 11:10:32 -05:00
2015-04-21 19:29:37 -04:00
char * jid ;
2019-04-08 05:20:12 -04:00
user = strdup ( user ) ;
2015-04-21 19:29:37 -04:00
g_free ( def ) ;
2014-12-21 21:09:55 -05:00
2015-04-23 16:56:48 -04:00
// connect with account
2019-02-22 05:07:19 -05:00
ProfAccount * account = accounts_get_account ( user ) ;
2015-04-21 19:29:37 -04:00
if ( account ) {
2018-11-07 07:56:43 -05:00
// override account options with connect options
if ( altdomain ! = NULL )
account_set_server ( account , altdomain ) ;
if ( port ! = 0 )
account_set_port ( account , port ) ;
if ( tls_policy ! = NULL )
account_set_tls_policy ( account , tls_policy ) ;
2015-04-23 16:56:48 -04:00
// use password if set
if ( account - > password ) {
2015-04-28 18:38:56 -04:00
conn_status = cl_ev_connect_account ( account ) ;
2015-04-23 16:56:48 -04:00
// use eval_password if set
} else if ( account - > eval_password ) {
gboolean res = account_eval_password ( account ) ;
if ( res ) {
2015-04-28 18:38:56 -04:00
conn_status = cl_ev_connect_account ( account ) ;
2015-04-23 16:56:48 -04:00
free ( account - > password ) ;
account - > password = NULL ;
} else {
cons_show ( " Error evaluating password, see logs for details. " ) ;
2015-06-24 15:53:04 -04:00
account_free ( account ) ;
2019-07-22 09:12:02 -04:00
free ( user ) ;
2019-10-06 11:19:17 -04:00
options_destroy ( options ) ;
2015-04-23 16:56:48 -04:00
return TRUE ;
}
// no account password setting, prompt
} else {
account - > password = ui_ask_password ( ) ;
2015-04-28 18:38:56 -04:00
conn_status = cl_ev_connect_account ( account ) ;
2015-04-23 16:56:48 -04:00
free ( account - > password ) ;
account - > password = NULL ;
2015-04-21 19:29:37 -04:00
}
2015-04-23 16:56:48 -04:00
2016-11-21 19:39:52 -05:00
jid = account_create_connect_jid ( account ) ;
2015-06-24 15:24:39 -04:00
account_free ( account ) ;
2015-04-23 16:56:48 -04:00
// connect with JID
2015-04-21 19:29:37 -04:00
} else {
2019-02-22 05:07:19 -05:00
jid = g_utf8_strdown ( user , - 1 ) ;
2015-04-23 16:56:48 -04:00
char * passwd = ui_ask_password ( ) ;
2015-10-17 22:06:23 -04:00
conn_status = cl_ev_connect_jid ( jid , passwd , altdomain , port , tls_policy ) ;
2015-04-23 16:56:48 -04:00
free ( passwd ) ;
2015-04-21 19:29:37 -04:00
}
2013-12-15 11:10:32 -05:00
2015-04-21 19:29:37 -04:00
if ( conn_status = = JABBER_DISCONNECTED ) {
cons_show_error ( " Connection attempt for %s failed. " , jid ) ;
log_info ( " Connection attempt for %s failed " , jid ) ;
2013-12-15 11:10:32 -05:00
}
2015-04-21 19:29:37 -04:00
options_destroy ( options ) ;
free ( jid ) ;
2019-04-08 05:20:12 -04:00
free ( user ) ;
2015-04-21 19:29:37 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2016-04-26 15:29:45 -04:00
cmd_account_list ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-26 15:29:45 -04:00
gchar * * accounts = accounts_get_list ( ) ;
cons_show_account_list ( accounts ) ;
g_strfreev ( accounts ) ;
2013-12-15 11:10:32 -05:00
2016-04-26 15:29:45 -04:00
return TRUE ;
}
gboolean
cmd_account_show ( ProfWin * window , const char * const command , gchar * * args )
{
char * account_name = args [ 1 ] ;
if ( account_name = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
ProfAccount * account = accounts_get_account ( account_name ) ;
if ( account = = NULL ) {
cons_show ( " No such account. " ) ;
cons_show ( " " ) ;
} else {
cons_show_account ( account ) ;
account_free ( account ) ;
}
return TRUE ;
}
gboolean
cmd_account_add ( ProfWin * window , const char * const command , gchar * * args )
{
char * account_name = args [ 1 ] ;
if ( account_name = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
accounts_add ( account_name , NULL , 0 , NULL ) ;
cons_show ( " Account created. " ) ;
cons_show ( " " ) ;
return TRUE ;
}
gboolean
cmd_account_remove ( ProfWin * window , const char * const command , gchar * * args )
{
char * account_name = args [ 1 ] ;
if ( ! account_name ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * def = prefs_get_string ( PREF_DEFAULT_ACCOUNT ) ;
if ( accounts_remove ( account_name ) ) {
cons_show ( " Account %s removed. " , account_name ) ;
if ( def & & strcmp ( def , account_name ) = = 0 ) {
prefs_set_string ( PREF_DEFAULT_ACCOUNT , NULL ) ;
cons_show ( " Default account removed because the corresponding account was removed. " ) ;
}
} else {
cons_show ( " Failed to remove account %s. " , account_name ) ;
cons_show ( " Either the account does not exist, or an unknown error occurred. " ) ;
}
cons_show ( " " ) ;
g_free ( def ) ;
return TRUE ;
}
gboolean
cmd_account_enable ( ProfWin * window , const char * const command , gchar * * args )
{
char * account_name = args [ 1 ] ;
if ( account_name = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( accounts_enable ( account_name ) ) {
cons_show ( " Account enabled. " ) ;
cons_show ( " " ) ;
} else {
cons_show ( " No such account: %s " , account_name ) ;
cons_show ( " " ) ;
}
return TRUE ;
}
gboolean
cmd_account_disable ( ProfWin * window , const char * const command , gchar * * args )
{
char * account_name = args [ 1 ] ;
if ( account_name = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( accounts_disable ( account_name ) ) {
cons_show ( " Account disabled. " ) ;
cons_show ( " " ) ;
} else {
cons_show ( " No such account: %s " , account_name ) ;
cons_show ( " " ) ;
}
return TRUE ;
}
gboolean
cmd_account_rename ( ProfWin * window , const char * const command , gchar * * args )
{
if ( g_strv_length ( args ) ! = 3 ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * account_name = args [ 1 ] ;
char * new_name = args [ 2 ] ;
if ( accounts_rename ( account_name , new_name ) ) {
cons_show ( " Account renamed. " ) ;
cons_show ( " " ) ;
} else {
cons_show ( " Either account %s doesn't exist, or account %s already exists. " , account_name , new_name ) ;
cons_show ( " " ) ;
}
return TRUE ;
}
gboolean
cmd_account_default ( ProfWin * window , const char * const command , gchar * * args )
{
if ( g_strv_length ( args ) = = 1 ) {
char * def = prefs_get_string ( PREF_DEFAULT_ACCOUNT ) ;
if ( def ) {
cons_show ( " The default account is %s. " , def ) ;
free ( def ) ;
2013-12-15 11:10:32 -05:00
} else {
2016-04-26 15:29:45 -04:00
cons_show ( " No default account. " ) ;
2013-12-15 11:10:32 -05:00
}
2016-04-26 15:29:45 -04:00
} else if ( g_strv_length ( args ) = = 2 ) {
if ( strcmp ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_DEFAULT_ACCOUNT , NULL ) ;
cons_show ( " Removed default account. " ) ;
2013-12-15 11:10:32 -05:00
} else {
2016-04-26 15:29:45 -04:00
cons_bad_cmd_usage ( command ) ;
}
} else if ( g_strv_length ( args ) = = 3 ) {
if ( strcmp ( args [ 1 ] , " set " ) = = 0 ) {
2016-07-25 17:38:23 -04:00
ProfAccount * account_p = accounts_get_account ( args [ 2 ] ) ;
if ( account_p ) {
2016-04-26 15:29:45 -04:00
prefs_set_string ( PREF_DEFAULT_ACCOUNT , args [ 2 ] ) ;
cons_show ( " Default account set to %s. " , args [ 2 ] ) ;
2016-07-25 17:38:23 -04:00
account_free ( account_p ) ;
2013-12-15 11:10:32 -05:00
} else {
2016-04-26 15:29:45 -04:00
cons_show ( " Account %s does not exist. " , args [ 2 ] ) ;
2013-12-15 11:10:32 -05:00
}
} else {
2016-04-26 15:29:45 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
2016-04-26 15:29:45 -04:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
}
gboolean
2016-04-27 20:13:42 -04:00
_account_set_jid ( char * account_name , char * jid )
2016-04-26 15:29:45 -04:00
{
2016-04-27 20:13:42 -04:00
Jid * jidp = jid_create ( jid ) ;
if ( jidp = = NULL ) {
cons_show ( " Malformed jid: %s " , jid ) ;
} else {
accounts_set_jid ( account_name , jidp - > barejid ) ;
cons_show ( " Updated jid for account %s: %s " , account_name , jidp - > barejid ) ;
if ( jidp - > resourcepart ) {
accounts_set_resource ( account_name , jidp - > resourcepart ) ;
cons_show ( " Updated resource for account %s: %s " , account_name , jidp - > resourcepart ) ;
}
cons_show ( " " ) ;
2016-04-26 15:29:45 -04:00
}
2016-04-27 20:13:42 -04:00
jid_destroy ( jidp ) ;
2016-04-26 15:29:45 -04:00
2016-04-27 20:13:42 -04:00
return TRUE ;
}
2016-04-26 15:29:45 -04:00
2016-04-27 20:13:42 -04:00
gboolean
_account_set_server ( char * account_name , char * server )
{
accounts_set_server ( account_name , server ) ;
cons_show ( " Updated server for account %s: %s " , account_name , server ) ;
cons_show ( " " ) ;
return TRUE ;
}
2016-04-26 15:29:45 -04:00
2016-04-27 20:13:42 -04:00
gboolean
_account_set_port ( char * account_name , char * port )
{
int porti ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( port , & porti , 1 , 65535 , & err_msg ) ;
if ( ! res ) {
cons_show ( err_msg ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " " ) ;
2016-04-27 20:13:42 -04:00
free ( err_msg ) ;
} else {
accounts_set_port ( account_name , porti ) ;
cons_show ( " Updated port for account %s: %s " , account_name , port ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " " ) ;
2016-04-27 20:13:42 -04:00
}
return TRUE ;
}
gboolean
_account_set_resource ( char * account_name , char * resource )
{
accounts_set_resource ( account_name , resource ) ;
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) = = JABBER_CONNECTED ) {
2016-04-27 20:13:42 -04:00
cons_show ( " Updated resource for account %s: %s, reconnect to pick up the change. " , account_name , resource ) ;
} else {
cons_show ( " Updated resource for account %s: %s " , account_name , resource ) ;
}
cons_show ( " " ) ;
return TRUE ;
}
gboolean
_account_set_password ( char * account_name , char * password )
{
ProfAccount * account = accounts_get_account ( account_name ) ;
if ( account - > eval_password ) {
cons_show ( " Cannot set password when eval_password is set. " ) ;
} else {
accounts_set_password ( account_name , password ) ;
cons_show ( " Updated password for account %s " , account_name ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " " ) ;
2016-04-27 20:13:42 -04:00
}
account_free ( account ) ;
return TRUE ;
}
gboolean
_account_set_eval_password ( char * account_name , char * eval_password )
{
ProfAccount * account = accounts_get_account ( account_name ) ;
if ( account - > password ) {
cons_show ( " Cannot set eval_password when password is set. " ) ;
} else {
accounts_set_eval_password ( account_name , eval_password ) ;
cons_show ( " Updated eval_password for account %s " , account_name ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " " ) ;
2016-04-27 20:13:42 -04:00
}
account_free ( account ) ;
return TRUE ;
}
gboolean
_account_set_muc ( char * account_name , char * muc )
{
accounts_set_muc_service ( account_name , muc ) ;
cons_show ( " Updated muc service for account %s: %s " , account_name , muc ) ;
cons_show ( " " ) ;
return TRUE ;
}
gboolean
_account_set_nick ( char * account_name , char * nick )
{
accounts_set_muc_nick ( account_name , nick ) ;
cons_show ( " Updated muc nick for account %s: %s " , account_name , nick ) ;
cons_show ( " " ) ;
return TRUE ;
}
gboolean
_account_set_otr ( char * account_name , char * policy )
{
if ( ( g_strcmp0 ( policy , " manual " ) ! = 0 )
& & ( g_strcmp0 ( policy , " opportunistic " ) ! = 0 )
& & ( g_strcmp0 ( policy , " always " ) ! = 0 ) ) {
cons_show ( " OTR policy must be one of: manual, opportunistic or always. " ) ;
} else {
accounts_set_otr_policy ( account_name , policy ) ;
cons_show ( " Updated OTR policy for account %s: %s " , account_name , policy ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " " ) ;
2016-04-27 20:13:42 -04:00
}
return TRUE ;
}
gboolean
_account_set_status ( char * account_name , char * status )
{
if ( ! valid_resource_presence_string ( status ) & & ( strcmp ( status , " last " ) ! = 0 ) ) {
cons_show ( " Invalid status: %s " , status ) ;
} else {
accounts_set_login_presence ( account_name , status ) ;
cons_show ( " Updated login status for account %s: %s " , account_name , status ) ;
}
cons_show ( " " ) ;
return TRUE ;
}
gboolean
_account_set_pgpkeyid ( char * account_name , char * pgpkeyid )
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBGPGME
2016-04-27 20:13:42 -04:00
char * err_str = NULL ;
if ( ! p_gpg_valid_key ( pgpkeyid , & err_str ) ) {
cons_show ( " Invalid PGP key ID specified: %s, see /pgp keys " , err_str ) ;
} else {
accounts_set_pgp_keyid ( account_name , pgpkeyid ) ;
cons_show ( " Updated PGP key ID for account %s: %s " , account_name , pgpkeyid ) ;
}
free ( err_str ) ;
2015-08-25 15:35:45 -04:00
# else
2016-04-27 20:13:42 -04:00
cons_show ( " PGP support is not included in this build. " ) ;
2015-08-25 15:35:45 -04:00
# endif
2016-04-27 20:13:42 -04:00
cons_show ( " " ) ;
return TRUE ;
}
2013-12-15 11:10:32 -05:00
2016-04-27 20:13:42 -04:00
gboolean
_account_set_startscript ( char * account_name , char * script )
{
accounts_set_script_start ( account_name , script ) ;
cons_show ( " Updated start script for account %s: %s " , account_name , script ) ;
return TRUE ;
}
gboolean
_account_set_theme ( char * account_name , char * theme )
{
if ( ! theme_exists ( theme ) ) {
cons_show ( " Theme does not exist: %s " , theme ) ;
return TRUE ;
}
accounts_set_theme ( account_name , theme ) ;
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) = = JABBER_CONNECTED ) {
2016-05-05 19:53:03 -04:00
ProfAccount * account = accounts_get_account ( session_get_account_name ( ) ) ;
2016-04-27 20:13:42 -04:00
if ( account ) {
if ( g_strcmp0 ( account - > name , account_name ) = = 0 ) {
theme_load ( theme ) ;
ui_load_colours ( ) ;
if ( prefs_get_boolean ( PREF_ROSTER ) ) {
ui_show_roster ( ) ;
} else {
ui_hide_roster ( ) ;
2013-12-15 11:10:32 -05:00
}
2016-04-27 20:13:42 -04:00
if ( prefs_get_boolean ( PREF_OCCUPANTS ) ) {
ui_show_all_room_rosters ( ) ;
} else {
ui_hide_all_room_rosters ( ) ;
}
ui_redraw ( ) ;
2013-12-15 11:10:32 -05:00
}
2016-04-27 20:13:42 -04:00
account_free ( account ) ;
2013-12-15 11:10:32 -05:00
}
2016-04-27 20:13:42 -04:00
}
cons_show ( " Updated theme for account %s: %s " , account_name , theme ) ;
return TRUE ;
}
gboolean
_account_set_tls ( char * account_name , char * policy )
{
if ( ( g_strcmp0 ( policy , " force " ) ! = 0 )
& & ( g_strcmp0 ( policy , " allow " ) ! = 0 )
2018-11-06 07:01:27 -05:00
& & ( g_strcmp0 ( policy , " trust " ) ! = 0 )
2017-06-24 14:33:30 -04:00
& & ( g_strcmp0 ( policy , " disable " ) ! = 0 )
& & ( g_strcmp0 ( policy , " legacy " ) ! = 0 ) ) {
cons_show ( " TLS policy must be one of: force, allow, legacy or disable. " ) ;
2013-12-15 11:10:32 -05:00
} else {
2016-04-27 20:13:42 -04:00
accounts_set_tls_policy ( account_name , policy ) ;
cons_show ( " Updated TLS policy for account %s: %s " , account_name , policy ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " " ) ;
}
2016-04-27 20:13:42 -04:00
return TRUE ;
}
gboolean
_account_set_presence_priority ( char * account_name , char * presence , char * priority )
{
int intval ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( priority , & intval , - 128 , 127 , & err_msg ) ;
if ( ! res ) {
cons_show ( err_msg ) ;
free ( err_msg ) ;
return TRUE ;
}
resource_presence_t presence_type = resource_presence_from_string ( presence ) ;
switch ( presence_type )
{
case ( RESOURCE_ONLINE ) :
accounts_set_priority_online ( account_name , intval ) ;
break ;
case ( RESOURCE_CHAT ) :
accounts_set_priority_chat ( account_name , intval ) ;
break ;
case ( RESOURCE_AWAY ) :
accounts_set_priority_away ( account_name , intval ) ;
break ;
case ( RESOURCE_XA ) :
accounts_set_priority_xa ( account_name , intval ) ;
break ;
case ( RESOURCE_DND ) :
accounts_set_priority_dnd ( account_name , intval ) ;
break ;
}
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-04-27 20:13:42 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
2016-05-05 19:53:03 -04:00
char * connected_account = session_get_account_name ( ) ;
2016-04-27 20:13:42 -04:00
resource_presence_t last_presence = accounts_get_last_presence ( connected_account ) ;
if ( presence_type = = last_presence ) {
2017-01-15 18:59:31 -05:00
cl_ev_presence_send ( last_presence , 0 ) ;
2016-04-27 20:13:42 -04:00
}
}
cons_show ( " Updated %s priority for account %s: %s " , presence , account_name , priority ) ;
cons_show ( " " ) ;
return TRUE ;
}
gboolean
cmd_account_set ( ProfWin * window , const char * const command , gchar * * args )
{
if ( g_strv_length ( args ) ! = 4 ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * account_name = args [ 1 ] ;
if ( ! accounts_account_exists ( account_name ) ) {
cons_show ( " Account %s doesn't exist " , account_name ) ;
cons_show ( " " ) ;
return TRUE ;
}
char * property = args [ 2 ] ;
char * value = args [ 3 ] ;
if ( strcmp ( property , " jid " ) = = 0 ) return _account_set_jid ( account_name , value ) ;
if ( strcmp ( property , " server " ) = = 0 ) return _account_set_server ( account_name , value ) ;
if ( strcmp ( property , " port " ) = = 0 ) return _account_set_port ( account_name , value ) ;
if ( strcmp ( property , " resource " ) = = 0 ) return _account_set_resource ( account_name , value ) ;
if ( strcmp ( property , " password " ) = = 0 ) return _account_set_password ( account_name , value ) ;
if ( strcmp ( property , " eval_password " ) = = 0 ) return _account_set_eval_password ( account_name , value ) ;
if ( strcmp ( property , " muc " ) = = 0 ) return _account_set_muc ( account_name , value ) ;
if ( strcmp ( property , " nick " ) = = 0 ) return _account_set_nick ( account_name , value ) ;
if ( strcmp ( property , " otr " ) = = 0 ) return _account_set_otr ( account_name , value ) ;
if ( strcmp ( property , " status " ) = = 0 ) return _account_set_status ( account_name , value ) ;
if ( strcmp ( property , " pgpkeyid " ) = = 0 ) return _account_set_pgpkeyid ( account_name , value ) ;
if ( strcmp ( property , " startscript " ) = = 0 ) return _account_set_startscript ( account_name , value ) ;
if ( strcmp ( property , " theme " ) = = 0 ) return _account_set_theme ( account_name , value ) ;
if ( strcmp ( property , " tls " ) = = 0 ) return _account_set_tls ( account_name , value ) ;
if ( valid_resource_presence_string ( property ) ) {
return _account_set_presence_priority ( account_name , property , value ) ;
}
cons_show ( " Invalid property: %s " , property ) ;
cons_show ( " " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
gboolean
cmd_account_clear ( ProfWin * window , const char * const command , gchar * * args )
{
if ( g_strv_length ( args ) ! = 3 ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * account_name = args [ 1 ] ;
if ( ! accounts_account_exists ( account_name ) ) {
cons_show ( " Account %s doesn't exist " , account_name ) ;
cons_show ( " " ) ;
return TRUE ;
}
char * property = args [ 2 ] ;
if ( strcmp ( property , " password " ) = = 0 ) {
accounts_clear_password ( account_name ) ;
cons_show ( " Removed password for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " eval_password " ) = = 0 ) {
accounts_clear_eval_password ( account_name ) ;
cons_show ( " Removed eval password for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " server " ) = = 0 ) {
accounts_clear_server ( account_name ) ;
cons_show ( " Removed server for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " port " ) = = 0 ) {
accounts_clear_port ( account_name ) ;
cons_show ( " Removed port for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " otr " ) = = 0 ) {
accounts_clear_otr ( account_name ) ;
cons_show ( " OTR policy removed for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " pgpkeyid " ) = = 0 ) {
accounts_clear_pgp_keyid ( account_name ) ;
cons_show ( " Removed PGP key ID for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " startscript " ) = = 0 ) {
accounts_clear_script_start ( account_name ) ;
cons_show ( " Removed start script for account %s " , account_name ) ;
cons_show ( " " ) ;
} else if ( strcmp ( property , " theme " ) = = 0 ) {
accounts_clear_theme ( account_name ) ;
cons_show ( " Removed theme for account %s " , account_name ) ;
cons_show ( " " ) ;
2016-11-19 21:09:34 -05:00
} else if ( strcmp ( property , " muc " ) = = 0 ) {
accounts_clear_muc ( account_name ) ;
cons_show ( " Removed MUC service for account %s " , account_name ) ;
cons_show ( " " ) ;
2016-11-21 19:39:52 -05:00
} else if ( strcmp ( property , " resource " ) = = 0 ) {
accounts_clear_resource ( account_name ) ;
cons_show ( " Removed resource for account %s " , account_name ) ;
cons_show ( " " ) ;
2016-04-26 15:29:45 -04:00
} else {
cons_show ( " Invalid property: %s " , property ) ;
cons_show ( " " ) ;
}
return TRUE ;
}
gboolean
cmd_account ( ProfWin * window , const char * const command , gchar * * args )
{
if ( args [ 0 ] ! = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
cons_show ( " " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2016-05-05 19:53:03 -04:00
ProfAccount * account = accounts_get_account ( session_get_account_name ( ) ) ;
2016-04-26 15:29:45 -04:00
cons_show_account ( account ) ;
account_free ( account ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
2015-10-15 18:57:52 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_script ( ProfWin * window , const char * const command , gchar * * args )
2015-10-15 18:57:52 -04:00
{
if ( ( g_strcmp0 ( args [ 0 ] , " run " ) = = 0 ) & & args [ 1 ] ) {
gboolean res = scripts_exec ( args [ 1 ] ) ;
if ( ! res ) {
cons_show ( " Could not find script %s " , args [ 1 ] ) ;
}
2015-10-17 17:30:01 -04:00
} else if ( g_strcmp0 ( args [ 0 ] , " list " ) = = 0 ) {
GSList * scripts = scripts_list ( ) ;
cons_show_scripts ( scripts ) ;
g_slist_free_full ( scripts , g_free ) ;
2015-10-17 17:58:45 -04:00
} else if ( ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 ) & & args [ 1 ] ) {
GSList * commands = scripts_read ( args [ 1 ] ) ;
cons_show_script ( args [ 1 ] , commands ) ;
g_slist_free_full ( commands , g_free ) ;
2015-10-15 18:57:52 -04:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
}
2015-11-23 21:25:55 -05:00
/* escape a string into csv and write it to the file descriptor */
2015-11-23 22:02:23 -05:00
static int
2015-11-24 18:59:28 -05:00
_writecsv ( int fd , const char * const str )
{
2015-11-24 19:24:48 -05:00
if ( ! str ) return 0 ;
2015-11-23 21:25:55 -05:00
size_t len = strlen ( str ) ;
2015-11-23 21:30:48 -05:00
char * s = malloc ( 2 * len * sizeof ( char ) ) ;
2015-11-23 21:25:55 -05:00
char * c = s ;
2015-11-23 21:43:42 -05:00
int i = 0 ;
2015-11-24 19:24:48 -05:00
for ( ; i < strlen ( str ) ; i + + ) {
2015-11-24 19:41:37 -05:00
if ( str [ i ] ! = ' " ' ) * c + + = str [ i ] ;
2015-11-23 21:25:55 -05:00
else { * c + + = ' " ' ; * c + + = ' " ' ; len + + ; }
2015-11-23 21:09:51 -05:00
}
2015-11-24 19:24:48 -05:00
if ( - 1 = = write ( fd , s , len ) ) {
2015-11-23 22:02:23 -05:00
cons_show ( " error: failed to write '%s' to the requested file: %s " , s , strerror ( errno ) ) ;
return - 1 ;
}
2015-11-23 21:25:55 -05:00
free ( s ) ;
2015-11-23 22:02:23 -05:00
return 0 ;
2015-11-23 21:09:51 -05:00
}
gboolean
cmd_export ( ProfWin * window , const char * const command , gchar * * args )
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-11-24 19:02:48 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
cons_show ( " " ) ;
return TRUE ;
2015-11-24 19:15:35 -05:00
} else {
2015-11-24 19:12:41 -05:00
GString * fname = g_string_new ( " " ) ;
2015-11-23 21:25:55 -05:00
GSList * list = NULL ;
2015-11-24 19:12:41 -05:00
int fd ;
/* deal with the ~ convention for $HOME */
2015-11-24 19:24:48 -05:00
if ( args [ 0 ] [ 0 ] = = ' ~ ' ) {
2015-11-24 19:12:41 -05:00
fname = g_string_append ( fname , getenv ( " HOME " ) ) ;
fname = g_string_append ( fname , args [ 0 ] + 1 ) ;
} else {
fname = g_string_append ( fname , args [ 0 ] ) ;
}
fd = open ( fname - > str , O_WRONLY | O_CREAT , 00600 ) ;
2015-11-24 19:19:02 -05:00
g_string_free ( fname , TRUE ) ;
2015-11-23 21:25:55 -05:00
2015-11-24 19:24:48 -05:00
if ( - 1 = = fd ) {
2015-11-23 21:25:55 -05:00
cons_show ( " error: cannot open %s: %s " , args [ 0 ] , strerror ( errno ) ) ;
cons_show ( " " ) ;
return TRUE ;
}
2015-11-23 21:09:51 -05:00
2015-11-24 19:24:48 -05:00
if ( - 1 = = write ( fd , " jid,name \n " , strlen ( " jid,name \n " ) ) ) goto write_error ;
2015-11-23 22:02:23 -05:00
2016-01-30 21:33:44 -05:00
list = roster_get_contacts ( ROSTER_ORD_NAME ) ;
2015-11-24 19:24:48 -05:00
if ( list ) {
2015-11-23 21:09:51 -05:00
GSList * curr = list ;
2015-11-24 19:24:48 -05:00
while ( curr ) {
2015-11-23 21:09:51 -05:00
PContact contact = curr - > data ;
const char * jid = p_contact_barejid ( contact ) ;
const char * name = p_contact_name ( contact ) ;
/* write the data to the file */
2015-11-24 19:24:48 -05:00
if ( - 1 = = write ( fd , " \" " , 1 ) ) goto write_error ;
if ( - 1 = = _writecsv ( fd , jid ) ) goto write_error ;
if ( - 1 = = write ( fd , " \" , \" " , 3 ) ) goto write_error ;
if ( - 1 = = _writecsv ( fd , name ) ) goto write_error ;
if ( - 1 = = write ( fd , " \" \n " , 2 ) ) goto write_error ;
2015-11-23 21:09:51 -05:00
/* loop */
curr = g_slist_next ( curr ) ;
}
2015-11-23 21:25:55 -05:00
cons_show ( " Contacts exported successfully " ) ;
cons_show ( " " ) ;
2015-11-23 21:09:51 -05:00
} else {
cons_show ( " No contacts in roster. " ) ;
2015-11-23 21:25:55 -05:00
cons_show ( " " ) ;
2015-11-23 21:09:51 -05:00
}
2015-11-23 22:02:23 -05:00
g_slist_free ( list ) ;
close ( fd ) ;
return TRUE ;
write_error :
cons_show ( " error: write failed: %s " , strerror ( errno ) ) ;
cons_show ( " " ) ;
2015-11-23 21:09:51 -05:00
g_slist_free ( list ) ;
close ( fd ) ;
return TRUE ;
}
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_sub ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are currently not connected. " ) ;
return TRUE ;
}
char * subcmd , * jid ;
subcmd = args [ 0 ] ;
jid = args [ 1 ] ;
if ( subcmd = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
if ( strcmp ( subcmd , " sent " ) = = 0 ) {
cons_show_sent_subs ( ) ;
return TRUE ;
}
if ( strcmp ( subcmd , " received " ) = = 0 ) {
cons_show_received_subs ( ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( ( window - > type ! = WIN_CHAT ) & & ( jid = = NULL ) ) {
2013-12-15 11:10:32 -05:00
cons_show ( " You must specify a contact. " ) ;
return TRUE ;
}
if ( jid = = NULL ) {
2015-06-17 14:49:55 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
jid = chatwin - > barejid ;
2013-12-15 11:10:32 -05:00
}
Jid * jidp = jid_create ( jid ) ;
if ( strcmp ( subcmd , " allow " ) = = 0 ) {
presence_subscription ( jidp - > barejid , PRESENCE_SUBSCRIBED ) ;
cons_show ( " Accepted subscription for %s " , jidp - > barejid ) ;
log_info ( " Accepted subscription for %s " , jidp - > barejid ) ;
} else if ( strcmp ( subcmd , " deny " ) = = 0 ) {
presence_subscription ( jidp - > barejid , PRESENCE_UNSUBSCRIBED ) ;
cons_show ( " Deleted/denied subscription for %s " , jidp - > barejid ) ;
log_info ( " Deleted/denied subscription for %s " , jidp - > barejid ) ;
} else if ( strcmp ( subcmd , " request " ) = = 0 ) {
presence_subscription ( jidp - > barejid , PRESENCE_SUBSCRIBE ) ;
cons_show ( " Sent subscription request to %s. " , jidp - > barejid ) ;
log_info ( " Sent subscription request to %s. " , jidp - > barejid ) ;
} else if ( strcmp ( subcmd , " show " ) = = 0 ) {
PContact contact = roster_get_contact ( jidp - > barejid ) ;
if ( ( contact = = NULL ) | | ( p_contact_subscription ( contact ) = = NULL ) ) {
2015-06-16 19:15:28 -04:00
if ( window - > type = = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " No subscription information for %s. " , jidp - > barejid ) ;
2013-12-15 11:10:32 -05:00
} else {
cons_show ( " No subscription information for %s. " , jidp - > barejid ) ;
}
} else {
2015-06-16 19:15:28 -04:00
if ( window - > type = = WIN_CHAT ) {
2013-12-15 11:10:32 -05:00
if ( p_contact_pending_out ( contact ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " %s subscription status: %s, request pending. " ,
2013-12-15 11:10:32 -05:00
jidp - > barejid , p_contact_subscription ( contact ) ) ;
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " %s subscription status: %s. " , jidp - > barejid ,
2013-12-15 11:10:32 -05:00
p_contact_subscription ( contact ) ) ;
}
} else {
if ( p_contact_pending_out ( contact ) ) {
cons_show ( " %s subscription status: %s, request pending. " ,
jidp - > barejid , p_contact_subscription ( contact ) ) ;
} else {
cons_show ( " %s subscription status: %s. " , jidp - > barejid ,
p_contact_subscription ( contact ) ) ;
}
}
}
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
jid_destroy ( jidp ) ;
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_disconnect ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2013-12-15 11:10:32 -05:00
cons_show ( " You are not currently connected. " ) ;
2016-01-03 12:23:36 -05:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2016-01-03 12:23:36 -05:00
cl_ev_disconnect ( ) ;
2016-01-21 20:06:28 -05:00
char * theme = prefs_get_string ( PREF_THEME ) ;
if ( theme ) {
gboolean res = theme_load ( theme ) ;
prefs_free_string ( theme ) ;
if ( ! res ) {
theme_load ( " default " ) ;
}
} else {
theme_load ( " default " ) ;
}
ui_load_colours ( ) ;
if ( prefs_get_boolean ( PREF_ROSTER ) ) {
ui_show_roster ( ) ;
} else {
ui_hide_roster ( ) ;
}
if ( prefs_get_boolean ( PREF_OCCUPANTS ) ) {
ui_show_all_room_rosters ( ) ;
} else {
ui_hide_all_room_rosters ( ) ;
}
ui_redraw ( ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_quit ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
log_info ( " Profanity is shutting down... " ) ;
exit ( 0 ) ;
return FALSE ;
}
gboolean
2016-04-26 15:29:45 -04:00
cmd_wins_unread ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-26 15:29:45 -04:00
cons_show_wins ( TRUE ) ;
return TRUE ;
}
gboolean
cmd_wins_prune ( ProfWin * window , const char * const command , gchar * * args )
{
ui_prune_wins ( ) ;
return TRUE ;
}
gboolean
cmd_wins_swap ( ProfWin * window , const char * const command , gchar * * args )
{
if ( ( args [ 1 ] = = NULL ) | | ( args [ 2 ] = = NULL ) ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
int source_win = atoi ( args [ 1 ] ) ;
int target_win = atoi ( args [ 2 ] ) ;
2018-03-09 17:59:38 -05:00
2016-04-26 15:29:45 -04:00
if ( ( source_win = = 1 ) | | ( target_win = = 1 ) ) {
cons_show ( " Cannot move console window. " ) ;
2018-03-09 17:59:38 -05:00
return TRUE ;
}
if ( source_win = = 10 | | target_win = = 10 ) {
2016-04-26 15:29:45 -04:00
cons_show ( " Window 10 does not exist " ) ;
2018-03-09 17:59:38 -05:00
return TRUE ;
}
if ( source_win = = target_win ) {
2016-04-26 15:29:45 -04:00
cons_show ( " Same source and target window supplied. " ) ;
2018-03-09 17:59:38 -05:00
return TRUE ;
}
if ( wins_get_by_num ( source_win ) = = NULL ) {
cons_show ( " Window %d does not exist " , source_win ) ;
return TRUE ;
}
if ( wins_get_by_num ( target_win ) = = NULL ) {
cons_show ( " Window %d does not exist " , target_win ) ;
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2018-03-09 17:59:38 -05:00
wins_swap ( source_win , target_win ) ;
cons_show ( " Swapped windows %d <-> %d " , source_win , target_win ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
gboolean
cmd_wins ( ProfWin * window , const char * const command , gchar * * args )
{
if ( args [ 0 ] ! = NULL ) {
2015-07-25 21:09:01 -04:00
cons_bad_cmd_usage ( command ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2014-04-24 16:50:59 -04:00
2016-04-26 15:29:45 -04:00
cons_show_wins ( FALSE ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
2016-01-13 18:19:11 -05:00
gboolean
cmd_close ( ProfWin * window , const char * const command , gchar * * args )
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-01-13 18:19:11 -05:00
if ( g_strcmp0 ( args [ 0 ] , " all " ) = = 0 ) {
int count = ui_close_all_wins ( ) ;
if ( count = = 0 ) {
cons_show ( " No windows to close. " ) ;
} else if ( count = = 1 ) {
cons_show ( " Closed 1 window. " ) ;
} else {
cons_show ( " Closed %d windows. " , count ) ;
}
2016-01-14 17:54:50 -05:00
rosterwin_roster ( ) ;
2016-01-13 18:19:11 -05:00
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " read " ) = = 0 ) {
int count = ui_close_read_wins ( ) ;
if ( count = = 0 ) {
cons_show ( " No windows to close. " ) ;
} else if ( count = = 1 ) {
cons_show ( " Closed 1 window. " ) ;
} else {
cons_show ( " Closed %d windows. " , count ) ;
}
2016-01-14 17:54:50 -05:00
rosterwin_roster ( ) ;
2016-01-13 18:19:11 -05:00
return TRUE ;
}
gboolean is_num = TRUE ;
int index = 0 ;
if ( args [ 0 ] ! = NULL ) {
int i = 0 ;
for ( i = 0 ; i < strlen ( args [ 0 ] ) ; i + + ) {
2016-01-13 19:05:12 -05:00
if ( ! isdigit ( ( int ) args [ 0 ] [ i ] ) ) {
2016-01-13 18:19:11 -05:00
is_num = FALSE ;
break ;
}
}
if ( is_num ) {
index = atoi ( args [ 0 ] ) ;
}
} else {
index = wins_get_current_num ( ) ;
}
if ( is_num ) {
if ( index < 0 | | index = = 10 ) {
cons_show ( " No such window exists. " ) ;
return TRUE ;
}
if ( index = = 1 ) {
cons_show ( " Cannot close console window. " ) ;
return TRUE ;
}
ProfWin * toclose = wins_get_by_num ( index ) ;
if ( ! toclose ) {
cons_show ( " Window is not open. " ) ;
return TRUE ;
}
// check for unsaved form
if ( ui_win_has_unsaved_form ( index ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You have unsaved changes, use /form submit or /form cancel " ) ;
2016-01-13 18:19:11 -05:00
return TRUE ;
}
// handle leaving rooms, or chat
if ( conn_status = = JABBER_CONNECTED ) {
ui_close_connected_win ( index ) ;
}
// close the window
ui_close_win ( index ) ;
cons_show ( " Closed window %d " , index ) ;
2018-03-09 17:42:20 -05:00
wins_tidy ( ) ;
2016-01-13 18:19:11 -05:00
2016-01-14 17:54:50 -05:00
rosterwin_roster ( ) ;
2016-01-13 18:19:11 -05:00
return TRUE ;
} else {
if ( g_strcmp0 ( args [ 0 ] , " console " ) = = 0 ) {
cons_show ( " Cannot close console window. " ) ;
return TRUE ;
}
ProfWin * toclose = wins_get_by_string ( args [ 0 ] ) ;
if ( ! toclose ) {
cons_show ( " Window \" %s \" does not exist. " , args [ 0 ] ) ;
return TRUE ;
}
index = wins_get_num ( toclose ) ;
// check for unsaved form
if ( ui_win_has_unsaved_form ( index ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You have unsaved changes, use /form submit or /form cancel " ) ;
2016-01-13 18:19:11 -05:00
return TRUE ;
}
// handle leaving rooms, or chat
if ( conn_status = = JABBER_CONNECTED ) {
ui_close_connected_win ( index ) ;
}
// close the window
ui_close_win ( index ) ;
cons_show ( " Closed window %s " , args [ 0 ] ) ;
2018-03-09 17:42:20 -05:00
wins_tidy ( ) ;
2016-01-13 18:19:11 -05:00
2016-01-14 17:54:50 -05:00
rosterwin_roster ( ) ;
2016-01-13 18:19:11 -05:00
return TRUE ;
}
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_win ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-01-06 19:38:17 -05:00
gboolean is_num = TRUE ;
int i = 0 ;
for ( i = 0 ; i < strlen ( args [ 0 ] ) ; i + + ) {
2016-01-13 19:05:12 -05:00
if ( ! isdigit ( ( int ) args [ 0 ] [ i ] ) ) {
2016-01-06 19:38:17 -05:00
is_num = FALSE ;
break ;
}
}
if ( is_num ) {
int num = atoi ( args [ 0 ] ) ;
2015-04-30 17:09:39 -04:00
2016-01-06 19:38:17 -05:00
ProfWin * focuswin = wins_get_by_num ( num ) ;
if ( ! focuswin ) {
cons_show ( " Window %d does not exist. " , num ) ;
} else {
ui_focus_win ( focuswin ) ;
}
2015-04-30 17:09:39 -04:00
} else {
2016-01-06 19:38:17 -05:00
ProfWin * focuswin = wins_get_by_string ( args [ 0 ] ) ;
if ( ! focuswin ) {
cons_show ( " Window \" %s \" does not exist. " , args [ 0 ] ) ;
} else {
ui_focus_win ( focuswin ) ;
}
2013-12-15 11:10:32 -05:00
}
2015-04-30 17:09:39 -04:00
2013-12-15 11:10:32 -05:00
return TRUE ;
}
2017-04-06 18:36:50 -04:00
static void
_cmd_list_commands ( GList * commands ) {
int maxlen = 0 ;
GList * curr = commands ;
while ( curr ) {
gchar * cmd = curr - > data ;
int len = strlen ( cmd ) ;
if ( len > maxlen ) maxlen = len ;
curr = g_list_next ( curr ) ;
}
GString * cmds = g_string_new ( " " ) ;
curr = commands ;
int count = 0 ;
while ( curr ) {
gchar * cmd = curr - > data ;
if ( count = = 5 ) {
cons_show ( cmds - > str ) ;
g_string_free ( cmds , TRUE ) ;
cmds = g_string_new ( " " ) ;
count = 0 ;
}
g_string_append_printf ( cmds , " %-*s " , maxlen + 1 , cmd ) ;
curr = g_list_next ( curr ) ;
count + + ;
}
cons_show ( cmds - > str ) ;
g_string_free ( cmds , TRUE ) ;
g_list_free ( curr ) ;
cons_show ( " " ) ;
cons_show ( " Use /help [command] without the leading slash, for help on a specific command " ) ;
cons_show ( " " ) ;
}
2015-07-27 19:10:18 -04:00
static void
2015-10-24 19:31:42 -04:00
_cmd_help_cmd_list ( const char * const tag )
2015-07-27 19:10:18 -04:00
{
cons_show ( " " ) ;
ProfWin * console = wins_get_console ( ) ;
if ( tag ) {
2016-10-29 11:27:32 -04:00
win_println ( console , THEME_HELP_HEADER , ' - ' , " %s commands " , tag ) ;
2015-07-27 19:10:18 -04:00
} else {
2016-10-29 11:27:32 -04:00
win_println ( console , THEME_HELP_HEADER , ' - ' , " All commands " ) ;
2015-07-27 19:10:18 -04:00
}
GList * ordered_commands = NULL ;
2016-02-18 16:53:20 -05:00
if ( g_strcmp0 ( tag , " plugins " ) = = 0 ) {
GList * plugins_cmds = plugins_get_command_names ( ) ;
GList * curr = plugins_cmds ;
while ( curr ) {
ordered_commands = g_list_insert_sorted ( ordered_commands , curr - > data , ( GCompareFunc ) g_strcmp0 ) ;
curr = g_list_next ( curr ) ;
}
g_list_free ( plugins_cmds ) ;
} else {
2016-05-22 19:31:00 -04:00
ordered_commands = cmd_get_ordered ( tag ) ;
2016-02-18 16:53:20 -05:00
// add plugins if showing all commands
if ( ! tag ) {
GList * plugins_cmds = plugins_get_command_names ( ) ;
GList * curr = plugins_cmds ;
while ( curr ) {
ordered_commands = g_list_insert_sorted ( ordered_commands , curr - > data , ( GCompareFunc ) g_strcmp0 ) ;
curr = g_list_next ( curr ) ;
}
g_list_free ( plugins_cmds ) ;
2015-07-27 19:10:18 -04:00
}
}
2017-04-06 18:36:50 -04:00
_cmd_list_commands ( ordered_commands ) ;
2015-07-27 19:10:18 -04:00
g_list_free ( ordered_commands ) ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_help ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
int num_args = g_strv_length ( args ) ;
if ( num_args = = 0 ) {
cons_help ( ) ;
2017-04-06 19:51:29 -04:00
} else if ( strcmp ( args [ 0 ] , " search_all " ) = = 0 ) {
2017-04-06 18:36:50 -04:00
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
} else {
2017-04-06 19:51:29 -04:00
GList * cmds = cmd_search_index_all ( args [ 1 ] ) ;
if ( cmds = = NULL ) {
cons_show ( " No commands found. " ) ;
} else {
GList * curr = cmds ;
GList * results = NULL ;
while ( curr ) {
results = g_list_insert_sorted ( results , curr - > data , ( GCompareFunc ) g_strcmp0 ) ;
curr = g_list_next ( curr ) ;
}
cons_show ( " Search results: " ) ;
_cmd_list_commands ( results ) ;
g_list_free ( results ) ;
}
g_list_free ( cmds ) ;
}
} else if ( strcmp ( args [ 0 ] , " search_any " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
} else {
GList * cmds = cmd_search_index_any ( args [ 1 ] ) ;
2017-04-06 18:36:50 -04:00
if ( cmds = = NULL ) {
cons_show ( " No commands found. " ) ;
} else {
GList * curr = cmds ;
GList * results = NULL ;
while ( curr ) {
results = g_list_insert_sorted ( results , curr - > data , ( GCompareFunc ) g_strcmp0 ) ;
curr = g_list_next ( curr ) ;
}
cons_show ( " Search results: " ) ;
_cmd_list_commands ( results ) ;
g_list_free ( results ) ;
}
g_list_free ( cmds ) ;
}
2013-12-15 11:10:32 -05:00
} else if ( strcmp ( args [ 0 ] , " commands " ) = = 0 ) {
2015-07-27 18:55:04 -04:00
if ( args [ 1 ] ) {
if ( ! cmd_valid_tag ( args [ 1 ] ) ) {
cons_bad_cmd_usage ( command ) ;
2015-07-27 19:10:18 -04:00
} else {
_cmd_help_cmd_list ( args [ 1 ] ) ;
2015-07-27 18:55:04 -04:00
}
} else {
2015-07-27 19:10:18 -04:00
_cmd_help_cmd_list ( NULL ) ;
2015-07-27 18:55:04 -04:00
}
2013-12-15 11:10:32 -05:00
} else if ( strcmp ( args [ 0 ] , " navigation " ) = = 0 ) {
cons_navigation_help ( ) ;
} else {
char * cmd = args [ 0 ] ;
char cmd_with_slash [ 1 + strlen ( cmd ) + 1 ] ;
sprintf ( cmd_with_slash , " /%s " , cmd ) ;
2016-05-22 19:31:00 -04:00
Command * command = cmd_get ( cmd_with_slash ) ;
2015-05-04 17:23:59 -04:00
if ( command ) {
2016-02-18 15:52:52 -05:00
cons_show_help ( cmd_with_slash , & command - > help ) ;
2013-12-15 11:10:32 -05:00
} else {
2016-02-17 20:20:17 -05:00
CommandHelp * commandHelp = plugins_get_help ( cmd_with_slash ) ;
if ( commandHelp ) {
2016-02-18 15:52:52 -05:00
cons_show_help ( cmd_with_slash , commandHelp ) ;
2016-02-17 20:20:17 -05:00
} else {
cons_show ( " No such command. " ) ;
}
2013-12-15 11:10:32 -05:00
}
cons_show ( " " ) ;
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_about ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2015-10-26 16:37:50 -04:00
cons_show ( " " ) ;
cons_about ( ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_prefs ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
if ( args [ 0 ] = = NULL ) {
cons_prefs ( ) ;
cons_show ( " Use the /account command for preferences for individual accounts. " ) ;
} else if ( strcmp ( args [ 0 ] , " ui " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_ui_prefs ( ) ;
cons_show ( " " ) ;
} else if ( strcmp ( args [ 0 ] , " desktop " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_desktop_prefs ( ) ;
cons_show ( " " ) ;
} else if ( strcmp ( args [ 0 ] , " chat " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_chat_prefs ( ) ;
cons_show ( " " ) ;
} else if ( strcmp ( args [ 0 ] , " log " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_log_prefs ( ) ;
cons_show ( " " ) ;
} else if ( strcmp ( args [ 0 ] , " conn " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_connection_prefs ( ) ;
cons_show ( " " ) ;
} else if ( strcmp ( args [ 0 ] , " presence " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_presence_prefs ( ) ;
cons_show ( " " ) ;
2014-05-11 08:32:59 -04:00
} else if ( strcmp ( args [ 0 ] , " otr " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_otr_prefs ( ) ;
cons_show ( " " ) ;
2015-06-22 16:09:14 -04:00
} else if ( strcmp ( args [ 0 ] , " pgp " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_pgp_prefs ( ) ;
cons_show ( " " ) ;
2019-04-01 07:53:29 -04:00
} else if ( strcmp ( args [ 0 ] , " omemo " ) = = 0 ) {
cons_show ( " " ) ;
cons_show_omemo_prefs ( ) ;
cons_show ( " " ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_theme ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
// list themes
2014-11-17 16:10:08 -05:00
if ( g_strcmp0 ( args [ 0 ] , " list " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
GSList * themes = theme_list ( ) ;
cons_show_themes ( themes ) ;
g_slist_free_full ( themes , g_free ) ;
// load a theme
2015-02-25 19:49:21 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " load " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
if ( args [ 1 ] = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
} else if ( theme_load ( args [ 1 ] ) ) {
ui_load_colours ( ) ;
prefs_set_string ( PREF_THEME , args [ 1 ] ) ;
2014-11-19 18:58:55 -05:00
if ( prefs_get_boolean ( PREF_ROSTER ) ) {
ui_show_roster ( ) ;
} else {
ui_hide_roster ( ) ;
}
if ( prefs_get_boolean ( PREF_OCCUPANTS ) ) {
ui_show_all_room_rosters ( ) ;
} else {
ui_hide_all_room_rosters ( ) ;
}
2016-09-19 18:40:45 -04:00
ui_resize ( ) ;
2013-12-15 11:10:32 -05:00
cons_show ( " Loaded theme: %s " , args [ 1 ] ) ;
} else {
cons_show ( " Couldn't find theme: %s " , args [ 1 ] ) ;
}
2014-11-17 16:10:08 -05:00
// show colours
} else if ( g_strcmp0 ( args [ 0 ] , " colours " ) = = 0 ) {
cons_theme_colours ( ) ;
2016-01-20 19:50:55 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " properties " ) = = 0 ) {
cons_theme_properties ( ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
2014-07-22 18:22:50 -04:00
static void
2015-10-24 19:31:42 -04:00
_who_room ( ProfWin * window , const char * const command , gchar * * args )
2014-07-22 18:22:50 -04:00
{
2015-05-04 17:23:59 -04:00
if ( ( g_strv_length ( args ) = = 2 ) & & args [ 1 ] ) {
2014-10-04 16:53:04 -04:00
cons_show ( " Argument group is not applicable to chat rooms. " ) ;
return ;
}
// bad arg
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] & &
2014-10-04 17:43:22 -04:00
( g_strcmp0 ( args [ 0 ] , " online " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " available " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " unavailable " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " away " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " chat " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " xa " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " dnd " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " any " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " moderator " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " participant " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " visitor " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " owner " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " admin " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " member " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " outcast " ) ! = 0 ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-04 16:53:04 -04:00
return ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-07-22 18:22:50 -04:00
2014-10-04 17:43:22 -04:00
// presence filter
if ( args [ 0 ] = = NULL | |
( g_strcmp0 ( args [ 0 ] , " online " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " available " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " unavailable " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " away " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " chat " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " xa " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " dnd " ) = = 0 ) | |
( g_strcmp0 ( args [ 0 ] , " any " ) = = 0 ) ) {
char * presence = args [ 0 ] ;
2014-12-18 18:57:19 -05:00
GList * occupants = muc_roster ( mucwin - > roomjid ) ;
2014-10-04 17:43:22 -04:00
// no arg, show all contacts
if ( ( presence = = NULL ) | | ( g_strcmp0 ( presence , " any " ) = = 0 ) ) {
2015-11-01 18:41:45 -05:00
mucwin_roster ( mucwin , occupants , NULL ) ;
2014-10-04 17:43:22 -04:00
// available
} else if ( strcmp ( " available " , presence ) = = 0 ) {
GList * filtered = NULL ;
2015-05-04 17:23:59 -04:00
while ( occupants ) {
2014-11-03 16:27:41 -05:00
Occupant * occupant = occupants - > data ;
2014-10-04 17:43:22 -04:00
if ( muc_occupant_available ( occupant ) ) {
filtered = g_list_append ( filtered , occupant ) ;
}
2014-11-03 16:27:41 -05:00
occupants = g_list_next ( occupants ) ;
2014-10-04 17:43:22 -04:00
}
2014-07-22 18:22:50 -04:00
2015-11-01 18:41:45 -05:00
mucwin_roster ( mucwin , filtered , " available " ) ;
2014-07-22 18:22:50 -04:00
2014-10-04 17:43:22 -04:00
// unavailable
} else if ( strcmp ( " unavailable " , presence ) = = 0 ) {
GList * filtered = NULL ;
2015-05-04 17:23:59 -04:00
while ( occupants ) {
2014-11-03 16:27:41 -05:00
Occupant * occupant = occupants - > data ;
2014-10-04 17:43:22 -04:00
if ( ! muc_occupant_available ( occupant ) ) {
filtered = g_list_append ( filtered , occupant ) ;
}
2014-11-03 16:27:41 -05:00
occupants = g_list_next ( occupants ) ;
2014-07-22 18:22:50 -04:00
}
2015-11-01 18:41:45 -05:00
mucwin_roster ( mucwin , filtered , " unavailable " ) ;
2014-07-22 18:22:50 -04:00
2014-10-04 17:43:22 -04:00
// show specific status
} else {
GList * filtered = NULL ;
2014-07-22 18:22:50 -04:00
2015-05-04 17:23:59 -04:00
while ( occupants ) {
2014-11-03 16:27:41 -05:00
Occupant * occupant = occupants - > data ;
2014-10-04 17:43:22 -04:00
const char * presence_str = string_from_resource_presence ( occupant - > presence ) ;
if ( strcmp ( presence_str , presence ) = = 0 ) {
filtered = g_list_append ( filtered , occupant ) ;
}
2014-11-03 16:27:41 -05:00
occupants = g_list_next ( occupants ) ;
2014-07-22 18:22:50 -04:00
}
2015-11-01 18:41:45 -05:00
mucwin_roster ( mucwin , filtered , presence ) ;
2014-10-04 17:43:22 -04:00
}
2014-07-22 18:22:50 -04:00
2014-11-03 16:27:41 -05:00
g_list_free ( occupants ) ;
2014-10-04 17:43:22 -04:00
// role or affiliation filter
2014-07-22 18:22:50 -04:00
} else {
2014-10-04 17:43:22 -04:00
if ( g_strcmp0 ( args [ 0 ] , " moderator " ) = = 0 ) {
2015-11-01 16:51:24 -05:00
mucwin_show_role_list ( mucwin , MUC_ROLE_MODERATOR ) ;
2014-10-04 17:43:22 -04:00
return ;
}
if ( g_strcmp0 ( args [ 0 ] , " participant " ) = = 0 ) {
2015-11-01 16:51:24 -05:00
mucwin_show_role_list ( mucwin , MUC_ROLE_PARTICIPANT ) ;
2014-10-04 17:43:22 -04:00
return ;
}
if ( g_strcmp0 ( args [ 0 ] , " visitor " ) = = 0 ) {
2015-11-01 16:51:24 -05:00
mucwin_show_role_list ( mucwin , MUC_ROLE_VISITOR ) ;
2014-10-04 17:43:22 -04:00
return ;
2014-07-22 18:22:50 -04:00
}
2014-10-04 17:43:22 -04:00
if ( g_strcmp0 ( args [ 0 ] , " owner " ) = = 0 ) {
2015-11-01 16:46:57 -05:00
mucwin_show_affiliation_list ( mucwin , MUC_AFFILIATION_OWNER ) ;
2014-10-04 17:43:22 -04:00
return ;
}
if ( g_strcmp0 ( args [ 0 ] , " admin " ) = = 0 ) {
2015-11-01 16:46:57 -05:00
mucwin_show_affiliation_list ( mucwin , MUC_AFFILIATION_ADMIN ) ;
2014-10-04 17:43:22 -04:00
return ;
}
if ( g_strcmp0 ( args [ 0 ] , " member " ) = = 0 ) {
2015-11-01 16:46:57 -05:00
mucwin_show_affiliation_list ( mucwin , MUC_AFFILIATION_MEMBER ) ;
2014-10-04 17:43:22 -04:00
return ;
}
if ( g_strcmp0 ( args [ 0 ] , " outcast " ) = = 0 ) {
2015-11-01 16:46:57 -05:00
mucwin_show_affiliation_list ( mucwin , MUC_AFFILIATION_OUTCAST ) ;
2014-10-04 17:43:22 -04:00
return ;
}
2014-07-22 18:22:50 -04:00
}
}
2014-07-22 18:27:36 -04:00
static void
2015-10-24 19:31:42 -04:00
_who_roster ( ProfWin * window , const char * const command , gchar * * args )
2014-07-22 18:27:36 -04:00
{
2014-10-04 16:53:04 -04:00
char * presence = args [ 0 ] ;
// bad arg
2015-05-04 17:23:59 -04:00
if ( presence
2014-10-04 16:53:04 -04:00
& & ( strcmp ( presence , " online " ) ! = 0 )
& & ( strcmp ( presence , " available " ) ! = 0 )
& & ( strcmp ( presence , " unavailable " ) ! = 0 )
& & ( strcmp ( presence , " offline " ) ! = 0 )
& & ( strcmp ( presence , " away " ) ! = 0 )
& & ( strcmp ( presence , " chat " ) ! = 0 )
& & ( strcmp ( presence , " xa " ) ! = 0 )
& & ( strcmp ( presence , " dnd " ) ! = 0 )
& & ( strcmp ( presence , " any " ) ! = 0 ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-04 16:53:04 -04:00
return ;
}
char * group = NULL ;
2015-05-04 17:23:59 -04:00
if ( ( g_strv_length ( args ) = = 2 ) & & args [ 1 ] ) {
2014-10-04 16:53:04 -04:00
group = args [ 1 ] ;
}
2014-07-22 18:27:36 -04:00
cons_show ( " " ) ;
GSList * list = NULL ;
2015-05-04 17:23:59 -04:00
if ( group ) {
2016-01-30 21:33:44 -05:00
list = roster_get_group ( group , ROSTER_ORD_NAME ) ;
2014-07-22 18:31:14 -04:00
if ( list = = NULL ) {
cons_show ( " No such group: %s. " , group ) ;
return ;
}
2014-07-22 18:27:36 -04:00
} else {
2016-01-30 21:33:44 -05:00
list = roster_get_contacts ( ROSTER_ORD_NAME ) ;
2014-07-22 18:31:14 -04:00
if ( list = = NULL ) {
cons_show ( " No contacts in roster. " ) ;
return ;
}
2014-07-22 18:27:36 -04:00
}
// no arg, show all contacts
if ( ( presence = = NULL ) | | ( g_strcmp0 ( presence , " any " ) = = 0 ) ) {
2015-05-04 17:23:59 -04:00
if ( group ) {
2014-07-22 18:27:36 -04:00
if ( list = = NULL ) {
cons_show ( " No contacts in group %s. " , group ) ;
} else {
cons_show ( " %s: " , group ) ;
cons_show_contacts ( list ) ;
}
} else {
if ( list = = NULL ) {
cons_show ( " You have no contacts. " ) ;
} else {
cons_show ( " All contacts: " ) ;
cons_show_contacts ( list ) ;
}
}
// available
} else if ( strcmp ( " available " , presence ) = = 0 ) {
GSList * filtered = NULL ;
2015-02-10 15:30:50 -05:00
GSList * curr = list ;
2015-05-04 17:23:59 -04:00
while ( curr ) {
2015-02-10 15:30:50 -05:00
PContact contact = curr - > data ;
2014-07-22 18:27:36 -04:00
if ( p_contact_is_available ( contact ) ) {
filtered = g_slist_append ( filtered , contact ) ;
}
2015-02-10 15:30:50 -05:00
curr = g_slist_next ( curr ) ;
2014-07-22 18:27:36 -04:00
}
2015-05-04 17:23:59 -04:00
if ( group ) {
2014-07-22 18:27:36 -04:00
if ( filtered = = NULL ) {
cons_show ( " No contacts in group %s are %s. " , group , presence ) ;
} else {
cons_show ( " %s (%s): " , group , presence ) ;
cons_show_contacts ( filtered ) ;
}
} else {
if ( filtered = = NULL ) {
cons_show ( " No contacts are %s. " , presence ) ;
} else {
cons_show ( " Contacts (%s): " , presence ) ;
cons_show_contacts ( filtered ) ;
}
}
2015-02-09 17:03:17 -05:00
g_slist_free ( filtered ) ;
2014-07-22 18:27:36 -04:00
// unavailable
} else if ( strcmp ( " unavailable " , presence ) = = 0 ) {
GSList * filtered = NULL ;
2015-02-10 15:30:50 -05:00
GSList * curr = list ;
2015-05-04 17:23:59 -04:00
while ( curr ) {
2015-02-10 15:30:50 -05:00
PContact contact = curr - > data ;
2014-07-22 18:27:36 -04:00
if ( ! p_contact_is_available ( contact ) ) {
filtered = g_slist_append ( filtered , contact ) ;
}
2015-02-10 15:30:50 -05:00
curr = g_slist_next ( curr ) ;
2014-07-22 18:27:36 -04:00
}
2015-05-04 17:23:59 -04:00
if ( group ) {
2014-07-22 18:27:36 -04:00
if ( filtered = = NULL ) {
cons_show ( " No contacts in group %s are %s. " , group , presence ) ;
} else {
cons_show ( " %s (%s): " , group , presence ) ;
cons_show_contacts ( filtered ) ;
}
} else {
if ( filtered = = NULL ) {
cons_show ( " No contacts are %s. " , presence ) ;
} else {
cons_show ( " Contacts (%s): " , presence ) ;
cons_show_contacts ( filtered ) ;
}
}
2015-02-09 17:03:17 -05:00
g_slist_free ( filtered ) ;
2014-07-22 18:27:36 -04:00
// online, available resources
} else if ( strcmp ( " online " , presence ) = = 0 ) {
GSList * filtered = NULL ;
2015-02-10 15:30:50 -05:00
GSList * curr = list ;
2015-05-04 17:23:59 -04:00
while ( curr ) {
2015-02-10 15:30:50 -05:00
PContact contact = curr - > data ;
2014-07-22 18:27:36 -04:00
if ( p_contact_has_available_resource ( contact ) ) {
filtered = g_slist_append ( filtered , contact ) ;
}
2015-02-10 15:30:50 -05:00
curr = g_slist_next ( curr ) ;
2014-07-22 18:27:36 -04:00
}
2015-05-04 17:23:59 -04:00
if ( group ) {
2014-07-22 18:27:36 -04:00
if ( filtered = = NULL ) {
cons_show ( " No contacts in group %s are %s. " , group , presence ) ;
} else {
cons_show ( " %s (%s): " , group , presence ) ;
cons_show_contacts ( filtered ) ;
}
} else {
if ( filtered = = NULL ) {
cons_show ( " No contacts are %s. " , presence ) ;
} else {
cons_show ( " Contacts (%s): " , presence ) ;
cons_show_contacts ( filtered ) ;
}
}
2015-02-09 17:03:17 -05:00
g_slist_free ( filtered ) ;
2014-07-22 18:27:36 -04:00
// offline, no available resources
} else if ( strcmp ( " offline " , presence ) = = 0 ) {
GSList * filtered = NULL ;
2015-02-10 15:30:50 -05:00
GSList * curr = list ;
2015-05-04 17:23:59 -04:00
while ( curr ) {
2015-02-10 15:30:50 -05:00
PContact contact = curr - > data ;
2014-07-22 18:27:36 -04:00
if ( ! p_contact_has_available_resource ( contact ) ) {
filtered = g_slist_append ( filtered , contact ) ;
}
2015-02-10 15:30:50 -05:00
curr = g_slist_next ( curr ) ;
2014-07-22 18:27:36 -04:00
}
2015-05-04 17:23:59 -04:00
if ( group ) {
2014-07-22 18:27:36 -04:00
if ( filtered = = NULL ) {
cons_show ( " No contacts in group %s are %s. " , group , presence ) ;
} else {
cons_show ( " %s (%s): " , group , presence ) ;
cons_show_contacts ( filtered ) ;
}
} else {
if ( filtered = = NULL ) {
cons_show ( " No contacts are %s. " , presence ) ;
} else {
cons_show ( " Contacts (%s): " , presence ) ;
cons_show_contacts ( filtered ) ;
}
}
2015-02-09 17:03:17 -05:00
g_slist_free ( filtered ) ;
2014-07-22 18:27:36 -04:00
// show specific status
} else {
GSList * filtered = NULL ;
2015-02-10 15:30:50 -05:00
GSList * curr = list ;
2015-05-04 17:23:59 -04:00
while ( curr ) {
2015-02-10 15:30:50 -05:00
PContact contact = curr - > data ;
2014-07-22 18:27:36 -04:00
if ( strcmp ( p_contact_presence ( contact ) , presence ) = = 0 ) {
filtered = g_slist_append ( filtered , contact ) ;
}
2015-02-10 15:30:50 -05:00
curr = g_slist_next ( curr ) ;
2014-07-22 18:27:36 -04:00
}
2015-05-04 17:23:59 -04:00
if ( group ) {
2014-07-22 18:27:36 -04:00
if ( filtered = = NULL ) {
cons_show ( " No contacts in group %s are %s. " , group , presence ) ;
} else {
cons_show ( " %s (%s): " , group , presence ) ;
cons_show_contacts ( filtered ) ;
}
} else {
if ( filtered = = NULL ) {
cons_show ( " No contacts are %s. " , presence ) ;
} else {
cons_show ( " Contacts (%s): " , presence ) ;
cons_show_contacts ( filtered ) ;
}
}
2015-02-09 17:03:17 -05:00
g_slist_free ( filtered ) ;
2014-07-22 18:27:36 -04:00
}
2014-11-23 19:32:30 -05:00
g_slist_free ( list ) ;
2014-07-22 18:27:36 -04:00
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_who ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
2015-06-16 19:15:28 -04:00
} else if ( window - > type = = WIN_MUC ) {
2015-07-25 21:28:45 -04:00
_who_room ( window , command , args ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:28:45 -04:00
_who_roster ( window , command , args ) ;
2013-12-15 11:10:32 -05:00
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_CONSOLE & & window - > type ! = WIN_MUC ) {
2018-03-09 16:11:59 -05:00
status_bar_new ( 1 , WIN_CONSOLE , " console " ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_msg ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * usr = args [ 0 ] ;
char * msg = args [ 1 ] ;
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-04-21 16:57:39 -04:00
// send private message when in MUC room
2015-06-16 19:15:28 -04:00
if ( window - > type = = WIN_MUC ) {
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2015-03-15 19:31:39 -04:00
if ( muc_roster_contains_nick ( mucwin - > roomjid , usr ) ) {
GString * full_jid = g_string_new ( mucwin - > roomjid ) ;
g_string_append ( full_jid , " / " ) ;
g_string_append ( full_jid , usr ) ;
2013-12-15 11:10:32 -05:00
2015-05-03 20:31:27 -04:00
ProfPrivateWin * privwin = wins_get_private ( full_jid - > str ) ;
if ( ! privwin ) {
2015-11-05 18:28:21 -05:00
privwin = ( ProfPrivateWin * ) wins_new_private ( full_jid - > str ) ;
2015-05-03 20:31:27 -04:00
}
2015-11-02 15:59:36 -05:00
ui_focus_win ( ( ProfWin * ) privwin ) ;
2015-05-03 20:31:27 -04:00
2015-04-21 16:57:39 -04:00
if ( msg ) {
2016-04-11 14:13:18 -04:00
cl_ev_send_priv_msg ( privwin , msg , NULL ) ;
2015-03-15 19:18:50 -04:00
}
2013-12-15 11:10:32 -05:00
2015-03-15 19:31:39 -04:00
g_string_free ( full_jid , TRUE ) ;
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " No such participant \" %s \" in room. " , usr ) ;
2013-12-15 11:10:32 -05:00
}
2014-12-21 19:01:43 -05:00
2015-03-15 19:31:39 -04:00
return TRUE ;
2014-04-22 18:53:15 -04:00
2015-04-21 16:57:39 -04:00
// send chat message
2015-03-15 19:31:39 -04:00
} else {
char * barejid = roster_barejid_from_name ( usr ) ;
if ( barejid = = NULL ) {
barejid = usr ;
}
2014-12-26 19:52:34 -05:00
2015-04-29 17:59:44 -04:00
ProfChatWin * chatwin = wins_get_chat ( barejid ) ;
if ( ! chatwin ) {
2015-10-27 19:15:28 -04:00
chatwin = chatwin_new ( barejid ) ;
2015-04-29 17:59:44 -04:00
}
2015-11-02 15:59:36 -05:00
ui_focus_win ( ( ProfWin * ) chatwin ) ;
2015-04-29 17:59:44 -04:00
2019-04-09 01:02:35 -04:00
# ifdef HAVE_OMEMO
# ifndef HAVE_LIBOTR
2019-04-15 16:09:47 -04:00
if ( omemo_automatic_start ( barejid ) ) {
2019-04-09 01:02:35 -04:00
omemo_start_session ( barejid ) ;
chatwin - > is_omemo = TRUE ;
}
if ( msg ) {
cl_ev_send_msg ( chatwin , msg , NULL ) ;
}
return TRUE ;
# endif
# endif
# ifdef HAVE_OMEMO
# ifdef HAVE_LIBOTR
2019-04-15 16:09:47 -04:00
if ( omemo_automatic_start ( barejid ) & & otr_is_secure ( barejid ) ) {
2019-04-09 01:02:35 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Chat could be either OMEMO or OTR encrypted. Use '/omemo start %s' or '/otr start %s' to start a session. " , usr , usr ) ;
return TRUE ;
2019-04-15 16:09:47 -04:00
} else if ( omemo_automatic_start ( barejid ) ) {
2019-04-09 01:02:35 -04:00
omemo_start_session ( barejid ) ;
chatwin - > is_omemo = TRUE ;
}
2015-03-16 17:59:11 -04:00
if ( msg ) {
2016-04-11 14:13:18 -04:00
cl_ev_send_msg ( chatwin , msg , NULL ) ;
2015-03-16 17:59:11 -04:00
} else {
2019-04-09 01:02:35 -04:00
if ( otr_is_secure ( barejid ) ) {
chatwin_otr_secured ( chatwin , otr_is_trusted ( barejid ) ) ;
}
}
return TRUE ;
# endif
# endif
# ifndef HAVE_OMEMO
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBOTR
2019-04-09 01:02:35 -04:00
if ( msg ) {
cl_ev_send_msg ( chatwin , msg , NULL ) ;
} else {
2015-03-15 19:31:39 -04:00
if ( otr_is_secure ( barejid ) ) {
2015-10-27 17:23:56 -04:00
chatwin_otr_secured ( chatwin , otr_is_trusted ( barejid ) ) ;
2015-03-15 19:18:50 -04:00
}
2019-04-09 01:02:35 -04:00
}
return TRUE ;
# endif
2015-03-15 19:31:39 -04:00
# endif
2019-04-09 01:02:35 -04:00
# ifndef HAVE_OMEMO
# ifndef HAVE_LIBOTR
if ( msg ) {
cl_ev_send_msg ( chatwin , msg , NULL ) ;
2013-12-15 11:10:32 -05:00
}
2015-04-29 17:59:44 -04:00
return TRUE ;
2019-04-09 01:02:35 -04:00
# endif
# endif
2013-12-15 11:10:32 -05:00
}
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_group ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
// list all groups
if ( args [ 0 ] = = NULL ) {
2017-03-31 19:27:11 -04:00
GList * groups = roster_get_groups ( ) ;
GList * curr = groups ;
2015-05-04 17:23:59 -04:00
if ( curr ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Groups: " ) ;
2015-05-04 17:23:59 -04:00
while ( curr ) {
2013-12-15 11:10:32 -05:00
cons_show ( " %s " , curr - > data ) ;
2017-03-31 19:27:11 -04:00
curr = g_list_next ( curr ) ;
2013-12-15 11:10:32 -05:00
}
2017-03-31 19:27:11 -04:00
g_list_free_full ( groups , g_free ) ;
2013-12-15 11:10:32 -05:00
} else {
cons_show ( " No groups. " ) ;
}
return TRUE ;
}
// show contacts in group
if ( strcmp ( args [ 0 ] , " show " ) = = 0 ) {
char * group = args [ 1 ] ;
if ( group = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
2016-01-30 21:33:44 -05:00
GSList * list = roster_get_group ( group , ROSTER_ORD_NAME ) ;
2013-12-15 11:10:32 -05:00
cons_show_roster_group ( group , list ) ;
return TRUE ;
}
// add contact to group
if ( strcmp ( args [ 0 ] , " add " ) = = 0 ) {
char * group = args [ 1 ] ;
char * contact = args [ 2 ] ;
if ( ( group = = NULL ) | | ( contact = = NULL ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
char * barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
PContact pcontact = roster_get_contact ( barejid ) ;
if ( pcontact = = NULL ) {
cons_show ( " Contact not found in roster: %s " , barejid ) ;
return TRUE ;
}
2014-01-05 18:24:48 -05:00
if ( p_contact_in_group ( pcontact , group ) ) {
const char * display_name = p_contact_name_or_jid ( pcontact ) ;
ui_contact_already_in_group ( display_name , group ) ;
} else {
roster_send_add_to_group ( group , pcontact ) ;
}
2013-12-15 11:10:32 -05:00
return TRUE ;
}
// remove contact from group
if ( strcmp ( args [ 0 ] , " remove " ) = = 0 ) {
char * group = args [ 1 ] ;
char * contact = args [ 2 ] ;
if ( ( group = = NULL ) | | ( contact = = NULL ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
char * barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
PContact pcontact = roster_get_contact ( barejid ) ;
if ( pcontact = = NULL ) {
cons_show ( " Contact not found in roster: %s " , barejid ) ;
return TRUE ;
}
2014-01-05 18:24:48 -05:00
if ( ! p_contact_in_group ( pcontact , group ) ) {
const char * display_name = p_contact_name_or_jid ( pcontact ) ;
ui_contact_not_in_group ( display_name , group ) ;
} else {
roster_send_remove_from_group ( group , pcontact ) ;
}
2013-12-15 11:10:32 -05:00
return TRUE ;
}
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_roster ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
// show roster
if ( args [ 0 ] = = NULL ) {
2015-06-13 18:59:33 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2016-01-30 21:33:44 -05:00
GSList * list = roster_get_contacts ( ROSTER_ORD_NAME ) ;
2013-12-15 11:10:32 -05:00
cons_show_roster ( list ) ;
2014-11-23 19:54:51 -05:00
g_slist_free ( list ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
2014-11-23 19:54:51 -05:00
// show roster, only online contacts
} else if ( g_strcmp0 ( args [ 0 ] , " online " ) = = 0 ) {
2015-06-13 18:59:33 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2014-11-23 19:54:51 -05:00
GSList * list = roster_get_contacts_online ( ) ;
2014-11-23 02:34:09 -05:00
cons_show_roster ( list ) ;
2014-11-23 19:54:51 -05:00
g_slist_free ( list ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
2014-11-15 18:47:27 -05:00
// set roster size
} else if ( g_strcmp0 ( args [ 0 ] , " size " ) = = 0 ) {
if ( ! args [ 1 ] ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-11-15 18:47:27 -05:00
return TRUE ;
2015-03-15 21:03:20 -04:00
}
int intval = 0 ;
char * err_msg = NULL ;
2015-03-15 21:06:40 -04:00
gboolean res = strtoi_range ( args [ 1 ] , & intval , 1 , 99 , & err_msg ) ;
2015-03-15 21:03:20 -04:00
if ( res ) {
2014-11-15 18:47:27 -05:00
prefs_set_roster_size ( intval ) ;
cons_show ( " Roster screen size set to: %d%% " , intval ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED & & prefs_get_boolean ( PREF_ROSTER ) ) {
2014-11-15 18:47:27 -05:00
wins_resize_all ( ) ;
}
return TRUE ;
} else {
2015-03-15 21:03:20 -04:00
cons_show ( err_msg ) ;
free ( err_msg ) ;
2014-11-15 18:47:27 -05:00
return TRUE ;
}
2015-11-21 20:39:20 -05:00
// set line wrapping
} else if ( g_strcmp0 ( args [ 0 ] , " wrap " ) = = 0 ) {
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
} else {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 1 ] , command , " Roster panel line wrap " , PREF_ROSTER_WRAP ) ;
2015-11-21 20:39:20 -05:00
rosterwin_roster ( ) ;
2016-04-17 18:46:29 -04:00
return TRUE ;
2015-11-21 20:39:20 -05:00
}
2015-11-22 12:45:38 -05:00
// header settings
} else if ( g_strcmp0 ( args [ 0 ] , " header " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " char " ) = = 0 ) {
2015-11-19 18:21:51 -05:00
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
prefs_clear_roster_header_char ( ) ;
cons_show ( " Roster header char removed. " ) ;
rosterwin_roster ( ) ;
} else {
prefs_set_roster_header_char ( args [ 2 ] [ 0 ] ) ;
cons_show ( " Roster header char set to %c. " , args [ 2 ] [ 0 ] ) ;
rosterwin_roster ( ) ;
}
2015-11-22 12:45:38 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
// contact settings
} else if ( g_strcmp0 ( args [ 0 ] , " contact " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " char " ) = = 0 ) {
2015-11-19 19:06:46 -05:00
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
prefs_clear_roster_contact_char ( ) ;
cons_show ( " Roster contact char removed. " ) ;
rosterwin_roster ( ) ;
} else {
prefs_set_roster_contact_char ( args [ 2 ] [ 0 ] ) ;
cons_show ( " Roster contact char set to %c. " , args [ 2 ] [ 0 ] ) ;
rosterwin_roster ( ) ;
}
2015-11-22 12:45:38 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " indent " ) = = 0 ) {
2015-11-21 16:03:53 -05:00
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else {
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( args [ 2 ] , & intval , 0 , 10 , & err_msg ) ;
if ( res ) {
prefs_set_roster_contact_indent ( intval ) ;
cons_show ( " Roster contact indent set to: %d " , intval ) ;
rosterwin_roster ( ) ;
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
}
2015-11-22 12:45:38 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
// resource settings
} else if ( g_strcmp0 ( args [ 0 ] , " resource " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " char " ) = = 0 ) {
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
prefs_clear_roster_resource_char ( ) ;
cons_show ( " Roster resource char removed. " ) ;
rosterwin_roster ( ) ;
} else {
prefs_set_roster_resource_char ( args [ 2 ] [ 0 ] ) ;
cons_show ( " Roster resource char set to %c. " , args [ 2 ] [ 0 ] ) ;
rosterwin_roster ( ) ;
}
} else if ( g_strcmp0 ( args [ 1 ] , " indent " ) = = 0 ) {
2015-11-21 16:49:12 -05:00
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else {
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( args [ 2 ] , & intval , 0 , 10 , & err_msg ) ;
if ( res ) {
prefs_set_roster_resource_indent ( intval ) ;
cons_show ( " Roster resource indent set to: %d " , intval ) ;
rosterwin_roster ( ) ;
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
}
2015-11-22 12:45:38 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " join " ) = = 0 ) {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 2 ] , command , " Roster join " , PREF_ROSTER_RESOURCE_JOIN ) ;
2015-11-22 12:45:38 -05:00
rosterwin_roster ( ) ;
2016-04-17 18:46:29 -04:00
return TRUE ;
2015-11-22 12:45:38 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
// presence settings
} else if ( g_strcmp0 ( args [ 0 ] , " presence " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " indent " ) = = 0 ) {
2015-11-21 17:03:43 -05:00
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else {
int intval = 0 ;
char * err_msg = NULL ;
2015-11-21 19:30:42 -05:00
gboolean res = strtoi_range ( args [ 2 ] , & intval , - 1 , 10 , & err_msg ) ;
2015-11-21 17:03:43 -05:00
if ( res ) {
prefs_set_roster_presence_indent ( intval ) ;
cons_show ( " Roster presence indent set to: %d " , intval ) ;
rosterwin_roster ( ) ;
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
}
2015-11-21 16:03:53 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
2014-11-10 18:23:02 -05:00
// show/hide roster
} else if ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 ) {
2014-11-10 18:51:13 -05:00
if ( args [ 1 ] = = NULL ) {
cons_show ( " Roster enabled. " ) ;
prefs_set_boolean ( PREF_ROSTER , TRUE ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
ui_show_roster ( ) ;
}
2014-11-10 18:51:13 -05:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " offline " ) = = 0 ) {
cons_show ( " Roster offline enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_OFFLINE , TRUE ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2014-11-10 18:51:13 -05:00
return TRUE ;
2014-11-10 19:00:10 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " resource " ) = = 0 ) {
cons_show ( " Roster resource enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_RESOURCE , TRUE ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2014-11-10 19:00:10 -05:00
return TRUE ;
2015-11-15 16:33:48 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " presence " ) = = 0 ) {
cons_show ( " Roster presence enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_PRESENCE , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " status " ) = = 0 ) {
cons_show ( " Roster status enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_STATUS , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2015-07-08 07:11:56 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " empty " ) = = 0 ) {
cons_show ( " Roster empty enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_EMPTY , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2015-11-17 21:14:11 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " priority " ) = = 0 ) {
cons_show ( " Roster priority enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_PRIORITY , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2016-01-19 20:48:41 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " contacts " ) = = 0 ) {
cons_show ( " Roster contacts enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_CONTACTS , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2016-01-01 20:37:03 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " rooms " ) = = 0 ) {
cons_show ( " Roster rooms enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_ROOMS , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2016-02-06 19:49:48 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " unsubscribed " ) = = 0 ) {
cons_show ( " Roster unsubscribed enabled " ) ;
prefs_set_boolean ( PREF_ROSTER_UNSUBSCRIBED , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2014-11-10 18:51:13 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-11-10 18:51:13 -05:00
return TRUE ;
}
2014-11-10 18:23:02 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " hide " ) = = 0 ) {
2014-11-10 18:51:13 -05:00
if ( args [ 1 ] = = NULL ) {
cons_show ( " Roster disabled. " ) ;
prefs_set_boolean ( PREF_ROSTER , FALSE ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
ui_hide_roster ( ) ;
}
2014-11-10 18:51:13 -05:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " offline " ) = = 0 ) {
cons_show ( " Roster offline disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_OFFLINE , FALSE ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2014-11-10 18:51:13 -05:00
return TRUE ;
2014-11-10 19:00:10 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " resource " ) = = 0 ) {
cons_show ( " Roster resource disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_RESOURCE , FALSE ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2014-11-10 19:00:10 -05:00
return TRUE ;
2015-11-15 16:33:48 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " presence " ) = = 0 ) {
cons_show ( " Roster presence disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_PRESENCE , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " status " ) = = 0 ) {
cons_show ( " Roster status disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_STATUS , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2015-07-08 07:11:56 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " empty " ) = = 0 ) {
cons_show ( " Roster empty disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_EMPTY , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2015-11-17 21:14:11 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " priority " ) = = 0 ) {
cons_show ( " Roster priority disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_PRIORITY , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
2016-01-19 20:48:41 -05:00
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " contacts " ) = = 0 ) {
cons_show ( " Roster contacts disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_CONTACTS , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
2015-11-17 21:14:11 -05:00
}
return TRUE ;
2016-01-01 20:37:03 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " rooms " ) = = 0 ) {
cons_show ( " Roster rooms disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_ROOMS , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2016-02-06 19:49:48 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " unsubscribed " ) = = 0 ) {
cons_show ( " Roster unsubscribed disabled " ) ;
prefs_set_boolean ( PREF_ROSTER_UNSUBSCRIBED , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
2014-11-10 18:51:13 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-11-10 18:51:13 -05:00
return TRUE ;
}
2015-11-22 12:45:38 -05:00
2014-11-10 19:30:29 -05:00
// roster grouping
} else if ( g_strcmp0 ( args [ 0 ] , " by " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " group " ) = = 0 ) {
cons_show ( " Grouping roster by roster group " ) ;
prefs_set_string ( PREF_ROSTER_BY , " group " ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2014-11-10 19:30:29 -05:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " presence " ) = = 0 ) {
cons_show ( " Grouping roster by presence " ) ;
prefs_set_string ( PREF_ROSTER_BY , " presence " ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2014-11-10 19:30:29 -05:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " none " ) = = 0 ) {
cons_show ( " Roster grouping disabled " ) ;
prefs_set_string ( PREF_ROSTER_BY , " none " ) ;
2015-06-13 18:59:33 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
2015-11-17 18:37:33 -05:00
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2015-11-22 12:45:38 -05:00
2015-11-17 18:37:33 -05:00
// roster item order
} else if ( g_strcmp0 ( args [ 0 ] , " order " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " name " ) = = 0 ) {
cons_show ( " Ordering roster by name " ) ;
prefs_set_string ( PREF_ROSTER_ORDER , " name " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " presence " ) = = 0 ) {
cons_show ( " Ordering roster by presence " ) ;
prefs_set_string ( PREF_ROSTER_ORDER , " presence " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
2015-06-13 18:59:33 -04:00
}
2014-11-10 19:30:29 -05:00
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2016-01-27 18:02:28 -05:00
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " count " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " zero " ) = = 0 ) {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 2 ] , command , " Roster header zero count " , PREF_ROSTER_COUNT_ZERO ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
2016-01-27 18:02:28 -05:00
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2016-01-27 18:02:28 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " unread " ) = = 0 ) {
cons_show ( " Roster header count set to unread " ) ;
prefs_set_string ( PREF_ROSTER_COUNT , " unread " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " items " ) = = 0 ) {
cons_show ( " Roster header count set to items " ) ;
prefs_set_string ( PREF_ROSTER_COUNT , " items " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
cons_show ( " Disabling roster header count " ) ;
prefs_set_string ( PREF_ROSTER_COUNT , " off " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
2014-11-10 19:30:29 -05:00
return TRUE ;
}
2015-11-22 12:45:38 -05:00
2016-01-16 21:17:12 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " unread " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " before " ) = = 0 ) {
cons_show ( " Roster unread message count: before " ) ;
prefs_set_string ( PREF_ROSTER_UNREAD , " before " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " after " ) = = 0 ) {
cons_show ( " Roster unread message count: after " ) ;
prefs_set_string ( PREF_ROSTER_UNREAD , " after " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
cons_show ( " Roster unread message count: off " ) ;
prefs_set_string ( PREF_ROSTER_UNREAD , " off " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
2016-01-23 20:04:21 -05:00
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " private " ) = = 0 ) {
2016-01-23 21:28:22 -05:00
if ( g_strcmp0 ( args [ 1 ] , " char " ) = = 0 ) {
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
prefs_clear_roster_private_char ( ) ;
cons_show ( " Roster private room chat char removed. " ) ;
rosterwin_roster ( ) ;
} else {
prefs_set_roster_private_char ( args [ 2 ] [ 0 ] ) ;
cons_show ( " Roster private room chat char set to %c. " , args [ 2 ] [ 0 ] ) ;
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " room " ) = = 0 ) {
2016-01-23 20:04:21 -05:00
cons_show ( " Showing room private chats under room. " ) ;
prefs_set_string ( PREF_ROSTER_PRIVATE , " room " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " group " ) = = 0 ) {
cons_show ( " Showing room private chats as roster group. " ) ;
prefs_set_string ( PREF_ROSTER_PRIVATE , " group " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
cons_show ( " Hiding room private chats in roster. " ) ;
prefs_set_string ( PREF_ROSTER_PRIVATE , " off " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
2016-01-16 21:17:12 -05:00
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-01-09 17:21:09 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " room " ) = = 0 ) {
2016-01-23 21:28:22 -05:00
if ( g_strcmp0 ( args [ 1 ] , " char " ) = = 0 ) {
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
prefs_clear_roster_room_char ( ) ;
cons_show ( " Roster room char removed. " ) ;
rosterwin_roster ( ) ;
} else {
prefs_set_roster_room_char ( args [ 2 ] [ 0 ] ) ;
cons_show ( " Roster room char set to %c. " , args [ 2 ] [ 0 ] ) ;
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " position " ) = = 0 ) {
2016-01-19 17:38:00 -05:00
if ( g_strcmp0 ( args [ 2 ] , " first " ) = = 0 ) {
cons_show ( " Showing rooms first in roster. " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_POS , " first " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 2 ] , " last " ) = = 0 ) {
cons_show ( " Showing rooms last in roster. " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_POS , " last " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 1 ] , " order " ) = = 0 ) {
2016-01-09 17:21:09 -05:00
if ( g_strcmp0 ( args [ 2 ] , " name " ) = = 0 ) {
cons_show ( " Ordering roster rooms by name " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_ORDER , " name " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 2 ] , " unread " ) = = 0 ) {
cons_show ( " Ordering roster rooms by unread messages " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_ORDER , " unread " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-01-16 20:49:16 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " unread " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " before " ) = = 0 ) {
cons_show ( " Roster rooms unread message count: before " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_UNREAD , " before " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 2 ] , " after " ) = = 0 ) {
cons_show ( " Roster rooms unread message count: after " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_UNREAD , " after " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
cons_show ( " Roster rooms unread message count: off " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_UNREAD , " off " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-01-31 15:17:20 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " private " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " char " ) = = 0 ) {
if ( ! args [ 3 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 3 ] , " none " ) = = 0 ) {
prefs_clear_roster_room_private_char ( ) ;
cons_show ( " Roster room private char removed. " ) ;
rosterwin_roster ( ) ;
} else {
prefs_set_roster_room_private_char ( args [ 3 ] [ 0 ] ) ;
cons_show ( " Roster room private char set to %c. " , args [ 3 ] [ 0 ] ) ;
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-01-31 20:11:01 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " by " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " service " ) = = 0 ) {
cons_show ( " Grouping rooms by service " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_BY , " service " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
cons_show ( " Roster room grouping disabled " ) ;
prefs_set_string ( PREF_ROSTER_ROOMS_BY , " none " ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2018-01-21 13:49:07 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " show " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " server " ) = = 0 ) {
cons_show ( " Roster room server enabled. " ) ;
prefs_set_boolean ( PREF_ROSTER_ROOMS_SERVER , TRUE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2018-02-05 15:01:54 -05:00
return TRUE ;
2018-01-21 13:49:07 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 1 ] , " hide " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " server " ) = = 0 ) {
cons_show ( " Roster room server disabled. " ) ;
prefs_set_boolean ( PREF_ROSTER_ROOMS_SERVER , FALSE ) ;
if ( conn_status = = JABBER_CONNECTED ) {
rosterwin_roster ( ) ;
}
2018-02-05 15:01:54 -05:00
return TRUE ;
2018-01-21 13:49:07 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-01-09 17:21:09 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2013-12-15 11:10:32 -05:00
// add contact
2014-03-16 13:53:41 -04:00
} else if ( strcmp ( args [ 0 ] , " add " ) = = 0 ) {
2015-06-13 18:59:33 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2014-03-16 13:53:41 -04:00
char * jid = args [ 1 ] ;
if ( jid = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-03-16 13:53:41 -04:00
} else {
char * name = args [ 2 ] ;
roster_send_add_new ( jid , name ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
// remove contact
2014-03-16 13:53:41 -04:00
} else if ( strcmp ( args [ 0 ] , " remove " ) = = 0 ) {
2015-06-13 18:59:33 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2014-03-16 13:53:41 -04:00
char * jid = args [ 1 ] ;
if ( jid = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-03-16 13:53:41 -04:00
} else {
roster_send_remove ( jid ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
2015-07-08 15:51:39 -04:00
} else if ( strcmp ( args [ 0 ] , " remove_all " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " contacts " ) ! = 0 ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-07-08 15:51:39 -04:00
return TRUE ;
}
2015-06-19 19:38:28 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2016-01-30 21:33:44 -05:00
GSList * all = roster_get_contacts ( ROSTER_ORD_NAME ) ;
2015-06-19 19:38:28 -04:00
GSList * curr = all ;
while ( curr ) {
PContact contact = curr - > data ;
roster_send_remove ( p_contact_barejid ( contact ) ) ;
curr = g_slist_next ( curr ) ;
}
g_slist_free ( all ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
// change nickname
2014-03-16 13:53:41 -04:00
} else if ( strcmp ( args [ 0 ] , " nick " ) = = 0 ) {
2015-06-13 18:59:33 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2014-03-16 13:53:41 -04:00
char * jid = args [ 1 ] ;
if ( jid = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
char * name = args [ 2 ] ;
2014-03-16 13:53:41 -04:00
if ( name = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-03-16 13:53:41 -04:00
return TRUE ;
}
2013-12-15 11:10:32 -05:00
// contact does not exist
PContact contact = roster_get_contact ( jid ) ;
if ( contact = = NULL ) {
cons_show ( " Contact not found in roster: %s " , jid ) ;
return TRUE ;
}
2014-01-05 17:55:04 -05:00
const char * barejid = p_contact_barejid ( contact ) ;
2016-02-03 17:19:29 -05:00
// TODO wait for result stanza before updating
const char * oldnick = p_contact_name ( contact ) ;
wins_change_nick ( barejid , oldnick , name ) ;
2014-01-05 17:55:04 -05:00
roster_change_name ( contact , name ) ;
GSList * groups = p_contact_groups ( contact ) ;
roster_send_name_change ( barejid , name , groups ) ;
2013-12-15 11:10:32 -05:00
2016-02-03 17:19:29 -05:00
2014-03-16 13:53:41 -04:00
cons_show ( " Nickname for %s set to: %s. " , jid , name ) ;
return TRUE ;
// remove nickname
} else if ( strcmp ( args [ 0 ] , " clearnick " ) = = 0 ) {
2015-06-13 18:59:33 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2014-03-16 13:53:41 -04:00
char * jid = args [ 1 ] ;
if ( jid = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-03-16 13:53:41 -04:00
return TRUE ;
}
// contact does not exist
PContact contact = roster_get_contact ( jid ) ;
if ( contact = = NULL ) {
cons_show ( " Contact not found in roster: %s " , jid ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2014-03-16 13:53:41 -04:00
const char * barejid = p_contact_barejid ( contact ) ;
2016-02-03 17:19:29 -05:00
// TODO wait for result stanza before updating
const char * oldnick = p_contact_name ( contact ) ;
wins_remove_nick ( barejid , oldnick ) ;
2014-03-16 13:53:41 -04:00
roster_change_name ( contact , NULL ) ;
GSList * groups = p_contact_groups ( contact ) ;
roster_send_name_change ( barejid , NULL , groups ) ;
cons_show ( " Nickname for %s removed. " , jid ) ;
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
}
2016-05-01 14:39:39 -04:00
gboolean
cmd_blocked ( ProfWin * window , const char * const command , gchar * * args )
{
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-05-01 14:39:39 -04:00
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2016-05-07 18:28:16 -04:00
if ( ! connection_supports ( XMPP_FEATURE_BLOCKING ) ) {
2016-05-01 14:39:39 -04:00
cons_show ( " Blocking not supported by server. " ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " add " ) = = 0 ) {
2016-05-01 15:06:34 -04:00
char * jid = args [ 1 ] ;
if ( jid = = NULL & & ( window - > type = = WIN_CHAT ) ) {
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
jid = chatwin - > barejid ;
}
if ( jid = = NULL ) {
2016-05-01 14:39:39 -04:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-05-01 15:06:34 -04:00
gboolean res = blocked_add ( jid ) ;
2016-05-01 14:39:39 -04:00
if ( ! res ) {
2016-05-01 15:06:34 -04:00
cons_show ( " User %s already blocked. " , jid ) ;
2016-05-01 14:39:39 -04:00
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " remove " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
gboolean res = blocked_remove ( args [ 1 ] ) ;
if ( ! res ) {
cons_show ( " User %s is not currently blocked. " , args [ 1 ] ) ;
}
return TRUE ;
}
GList * blocked = blocked_list ( ) ;
GList * curr = blocked ;
if ( curr ) {
cons_show ( " Blocked users: " ) ;
while ( curr ) {
cons_show ( " %s " , curr - > data ) ;
curr = g_list_next ( curr ) ;
}
} else {
cons_show ( " No blocked users. " ) ;
}
return TRUE ;
}
2014-12-02 15:50:21 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_resource ( ProfWin * window , const char * const command , gchar * * args )
2014-12-02 15:50:21 -05:00
{
2015-01-10 14:10:10 -05:00
char * cmd = args [ 0 ] ;
char * setting = NULL ;
if ( g_strcmp0 ( cmd , " message " ) = = 0 ) {
setting = args [ 1 ] ;
if ( ! setting ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-01-10 14:10:10 -05:00
return TRUE ;
} else {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( setting , command , " Message resource " , PREF_RESOURCE_MESSAGE ) ;
return TRUE ;
2015-01-10 14:10:10 -05:00
}
} else if ( g_strcmp0 ( cmd , " title " ) = = 0 ) {
setting = args [ 1 ] ;
if ( ! setting ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-01-10 14:10:10 -05:00
return TRUE ;
} else {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( setting , command , " Title resource " , PREF_RESOURCE_TITLE ) ;
return TRUE ;
2015-01-10 14:10:10 -05:00
}
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_CHAT ) {
2015-01-10 14:10:10 -05:00
cons_show ( " Resource can only be changed in chat windows. " ) ;
2014-12-02 15:50:21 -05:00
return TRUE ;
}
2016-01-04 19:06:50 -05:00
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-01-04 19:06:50 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
2014-12-15 20:39:47 -05:00
2014-12-02 15:50:21 -05:00
if ( g_strcmp0 ( cmd , " set " ) = = 0 ) {
char * resource = args [ 1 ] ;
if ( ! resource ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-12-02 15:50:21 -05:00
return TRUE ;
}
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBOTR
2014-12-18 18:57:19 -05:00
if ( otr_is_secure ( chatwin - > barejid ) ) {
2014-12-03 18:36:39 -05:00
cons_show ( " Cannot choose resource during an OTR session. " ) ;
return TRUE ;
}
# endif
2014-12-18 18:57:19 -05:00
PContact contact = roster_get_contact ( chatwin - > barejid ) ;
2014-12-02 15:50:21 -05:00
if ( ! contact ) {
cons_show ( " Cannot choose resource for contact not in roster. " ) ;
return TRUE ;
}
if ( ! p_contact_get_resource ( contact , resource ) ) {
cons_show ( " No such resource %s. " , resource ) ;
return TRUE ;
}
2015-01-10 13:17:10 -05:00
chatwin - > resource_override = strdup ( resource ) ;
2015-01-11 18:04:22 -05:00
chat_state_free ( chatwin - > state ) ;
chatwin - > state = chat_state_new ( ) ;
2015-01-10 16:07:40 -05:00
chat_session_resource_override ( chatwin - > barejid , resource ) ;
2014-12-02 15:50:21 -05:00
return TRUE ;
} else if ( g_strcmp0 ( cmd , " off " ) = = 0 ) {
2015-01-10 13:17:10 -05:00
FREE_SET_NULL ( chatwin - > resource_override ) ;
2015-01-11 18:04:22 -05:00
chat_state_free ( chatwin - > state ) ;
chatwin - > state = chat_state_new ( ) ;
2015-01-10 16:07:40 -05:00
chat_session_remove ( chatwin - > barejid ) ;
2014-12-02 15:50:21 -05:00
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-12-02 15:50:21 -05:00
return TRUE ;
}
}
2019-09-29 09:07:08 -04:00
static void
_cmd_status_show_status ( char * usr )
{
char * usr_jid = roster_barejid_from_name ( usr ) ;
if ( usr_jid = = NULL ) {
usr_jid = usr ;
}
cons_show_status ( usr_jid ) ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_status ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * usr = args [ 0 ] ;
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
switch ( window - > type )
2013-12-15 11:10:32 -05:00
{
case WIN_MUC :
2015-05-04 17:23:59 -04:00
if ( usr ) {
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-12-19 19:52:35 -05:00
Occupant * occupant = muc_roster_item ( mucwin - > roomjid , usr ) ;
2014-12-18 18:57:19 -05:00
if ( occupant ) {
2014-12-21 14:40:15 -05:00
win_show_occupant ( window , occupant ) ;
2014-12-18 18:57:19 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " No such participant \" %s \" in room. " , usr ) ;
2014-12-18 18:57:19 -05:00
}
2013-12-15 11:10:32 -05:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must specify a nickname. " ) ;
2013-12-15 11:10:32 -05:00
}
break ;
case WIN_CHAT :
2015-05-04 17:23:59 -04:00
if ( usr ) {
2019-09-29 09:07:08 -04:00
_cmd_status_show_status ( usr ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-06-17 14:49:55 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
PContact pcontact = roster_get_contact ( chatwin - > barejid ) ;
2015-05-04 17:23:59 -04:00
if ( pcontact ) {
2014-12-21 14:40:15 -05:00
win_show_contact ( window , pcontact ) ;
2014-12-18 18:57:19 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Error getting contact info. " ) ;
2014-12-18 18:57:19 -05:00
}
2013-12-15 11:10:32 -05:00
}
break ;
case WIN_PRIVATE :
2015-05-04 17:23:59 -04:00
if ( usr ) {
2019-09-29 09:07:08 -04:00
_cmd_status_show_status ( usr ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-06-17 14:49:55 -04:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
Jid * jid = jid_create ( privatewin - > fulljid ) ;
Occupant * occupant = muc_roster_item ( jid - > barejid , jid - > resourcepart ) ;
if ( occupant ) {
2014-12-21 14:40:15 -05:00
win_show_occupant ( window , occupant ) ;
2014-12-18 18:57:19 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Error getting contact info. " ) ;
2014-12-18 18:57:19 -05:00
}
jid_destroy ( jid ) ;
2013-12-15 11:10:32 -05:00
}
break ;
case WIN_CONSOLE :
2015-05-04 17:23:59 -04:00
if ( usr ) {
2019-09-29 09:07:08 -04:00
_cmd_status_show_status ( usr ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
break ;
default :
break ;
}
return TRUE ;
}
2019-09-29 09:04:19 -04:00
static void
2019-09-29 09:07:32 -04:00
_cmd_info_show_contact ( char * usr )
2019-09-29 09:04:19 -04:00
{
char * usr_jid = roster_barejid_from_name ( usr ) ;
if ( usr_jid = = NULL ) {
usr_jid = usr ;
}
PContact pcontact = roster_get_contact ( usr_jid ) ;
if ( pcontact ) {
cons_show_info ( pcontact ) ;
} else {
cons_show ( " No such contact \" %s \" in roster. " , usr ) ;
}
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_info ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * usr = args [ 0 ] ;
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
switch ( window - > type )
2013-12-15 11:10:32 -05:00
{
case WIN_MUC :
2014-09-29 19:16:01 -04:00
if ( usr ) {
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
Occupant * occupant = muc_roster_item ( mucwin - > roomjid , usr ) ;
2014-09-29 19:16:01 -04:00
if ( occupant ) {
2015-06-16 19:15:28 -04:00
win_show_occupant_info ( window , mucwin - > roomjid , occupant ) ;
2014-09-29 19:16:01 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " No such occupant \" %s \" in room. " , usr ) ;
2014-09-29 19:16:01 -04:00
}
2013-12-15 11:10:32 -05:00
} else {
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2015-03-28 20:55:33 -04:00
iq_room_info_request ( mucwin - > roomjid , TRUE ) ;
2015-11-01 16:54:31 -05:00
mucwin_info ( mucwin ) ;
2014-10-11 18:37:04 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
break ;
case WIN_CHAT :
2014-09-29 19:16:01 -04:00
if ( usr ) {
2019-09-29 09:07:32 -04:00
_cmd_info_show_contact ( usr ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-06-17 14:49:55 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
PContact pcontact = roster_get_contact ( chatwin - > barejid ) ;
2015-05-04 17:23:59 -04:00
if ( pcontact ) {
2014-12-21 14:40:15 -05:00
win_show_info ( window , pcontact ) ;
2014-12-18 18:57:19 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Error getting contact info. " ) ;
2014-12-18 18:57:19 -05:00
}
2013-12-15 11:10:32 -05:00
}
break ;
case WIN_PRIVATE :
2014-09-29 19:16:01 -04:00
if ( usr ) {
2019-09-29 09:07:32 -04:00
_cmd_info_show_contact ( usr ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-06-17 14:49:55 -04:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
Jid * jid = jid_create ( privatewin - > fulljid ) ;
Occupant * occupant = muc_roster_item ( jid - > barejid , jid - > resourcepart ) ;
if ( occupant ) {
2014-12-21 14:40:15 -05:00
win_show_occupant_info ( window , jid - > barejid , occupant ) ;
2014-12-18 18:57:19 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Error getting contact info. " ) ;
2014-12-18 18:57:19 -05:00
}
jid_destroy ( jid ) ;
2013-12-15 11:10:32 -05:00
}
break ;
case WIN_CONSOLE :
2014-09-29 19:16:01 -04:00
if ( usr ) {
2019-09-29 09:07:32 -04:00
_cmd_info_show_contact ( usr ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
break ;
default :
break ;
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_caps ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-09-29 19:16:01 -04:00
Occupant * occupant = NULL ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
switch ( window - > type )
2013-12-15 11:10:32 -05:00
{
case WIN_MUC :
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] ) {
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
occupant = muc_roster_item ( mucwin - > roomjid , args [ 0 ] ) ;
2014-09-29 19:16:01 -04:00
if ( occupant ) {
2014-12-18 18:57:19 -05:00
Jid * jidp = jid_create_from_bare_and_resource ( mucwin - > roomjid , args [ 0 ] ) ;
2014-09-29 19:16:01 -04:00
cons_show_caps ( jidp - > fulljid , occupant - > presence ) ;
2014-09-21 18:05:27 -04:00
jid_destroy ( jidp ) ;
2013-12-15 11:10:32 -05:00
} else {
cons_show ( " No such participant \" %s \" in room. " , args [ 0 ] ) ;
}
} else {
cons_show ( " No nickname supplied to /caps in chat room. " ) ;
}
break ;
case WIN_CHAT :
case WIN_CONSOLE :
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] ) {
2013-12-15 11:10:32 -05:00
Jid * jid = jid_create ( args [ 0 ] ) ;
if ( jid - > fulljid = = NULL ) {
cons_show ( " You must provide a full jid to the /caps command. " ) ;
} else {
2015-10-09 04:34:58 -04:00
PContact pcontact = roster_get_contact ( jid - > barejid ) ;
2013-12-15 11:10:32 -05:00
if ( pcontact = = NULL ) {
cons_show ( " Contact not found in roster: %s " , jid - > barejid ) ;
} else {
Resource * resource = p_contact_get_resource ( pcontact , jid - > resourcepart ) ;
if ( resource = = NULL ) {
cons_show ( " Could not find resource %s, for contact %s " , jid - > barejid , jid - > resourcepart ) ;
} else {
2014-09-29 19:16:01 -04:00
cons_show_caps ( jid - > fulljid , resource - > presence ) ;
2013-12-15 11:10:32 -05:00
}
}
}
2014-09-20 21:21:52 -04:00
jid_destroy ( jid ) ;
2013-12-15 11:10:32 -05:00
} else {
cons_show ( " You must provide a jid to the /caps command. " ) ;
}
break ;
case WIN_PRIVATE :
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] ) {
2013-12-15 11:10:32 -05:00
cons_show ( " No parameter needed to /caps when in private chat. " ) ;
} else {
2015-06-17 14:49:55 -04:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
Jid * jid = jid_create ( privatewin - > fulljid ) ;
2013-12-15 11:10:32 -05:00
if ( jid ) {
2014-09-29 19:16:01 -04:00
occupant = muc_roster_item ( jid - > barejid , jid - > resourcepart ) ;
cons_show_caps ( jid - > resourcepart , occupant - > presence ) ;
2013-12-15 11:10:32 -05:00
jid_destroy ( jid ) ;
}
}
break ;
default :
break ;
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_software ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
switch ( window - > type )
2013-12-15 11:10:32 -05:00
{
case WIN_MUC :
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] ) {
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2015-10-09 04:34:58 -04:00
Occupant * occupant = muc_roster_item ( mucwin - > roomjid , args [ 0 ] ) ;
2014-09-29 19:16:01 -04:00
if ( occupant ) {
2014-12-18 18:57:19 -05:00
Jid * jid = jid_create_from_bare_and_resource ( mucwin - > roomjid , args [ 0 ] ) ;
2013-12-15 11:10:32 -05:00
iq_send_software_version ( jid - > fulljid ) ;
jid_destroy ( jid ) ;
} else {
cons_show ( " No such participant \" %s \" in room. " , args [ 0 ] ) ;
}
} else {
cons_show ( " No nickname supplied to /software in chat room. " ) ;
}
break ;
case WIN_CHAT :
2015-08-05 20:56:52 -04:00
if ( args [ 0 ] ) {
cons_show ( " No parameter needed to /software when in chat. " ) ;
} else {
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
char * resource = NULL ;
ChatSession * session = chat_session_get ( chatwin - > barejid ) ;
if ( chatwin - > resource_override ) {
resource = chatwin - > resource_override ;
} else if ( session & & session - > resource ) {
resource = session - > resource ;
}
if ( resource ) {
GString * fulljid = g_string_new ( chatwin - > barejid ) ;
g_string_append_printf ( fulljid , " /%s " , resource ) ;
iq_send_software_version ( fulljid - > str ) ;
g_string_free ( fulljid , TRUE ) ;
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Unknown resource for /software command. " ) ;
2015-08-05 20:56:52 -04:00
}
}
break ;
2013-12-15 11:10:32 -05:00
case WIN_CONSOLE :
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] ) {
2016-05-05 20:12:54 -04:00
Jid * myJid = jid_create ( connection_get_fulljid ( ) ) ;
2013-12-15 11:10:32 -05:00
Jid * jid = jid_create ( args [ 0 ] ) ;
if ( jid = = NULL | | jid - > fulljid = = NULL ) {
cons_show ( " You must provide a full jid to the /software command. " ) ;
2015-07-08 16:05:20 -04:00
} else if ( g_strcmp0 ( jid - > barejid , myJid - > barejid ) = = 0 ) {
cons_show ( " Cannot request software version for yourself. " ) ;
2013-12-15 11:10:32 -05:00
} else {
iq_send_software_version ( jid - > fulljid ) ;
}
2015-07-08 16:05:20 -04:00
jid_destroy ( myJid ) ;
2013-12-15 11:10:32 -05:00
jid_destroy ( jid ) ;
} else {
cons_show ( " You must provide a jid to the /software command. " ) ;
}
break ;
case WIN_PRIVATE :
2015-05-04 17:23:59 -04:00
if ( args [ 0 ] ) {
2013-12-15 11:10:32 -05:00
cons_show ( " No parameter needed to /software when in private chat. " ) ;
} else {
2015-06-17 14:49:55 -04:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
iq_send_software_version ( privatewin - > fulljid ) ;
2013-12-15 11:10:32 -05:00
}
break ;
default :
break ;
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_join ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2014-03-07 19:19:21 -05:00
if ( args [ 0 ] = = NULL ) {
2016-05-05 19:53:03 -04:00
char * account_name = session_get_account_name ( ) ;
2015-04-11 18:37:52 -04:00
ProfAccount * account = accounts_get_account ( account_name ) ;
2016-11-19 21:09:34 -05:00
if ( account - > muc_service ) {
GString * room_str = g_string_new ( " " ) ;
char * uuid = connection_create_uuid ( ) ;
g_string_append_printf ( room_str , " private-chat-%s@%s " , uuid , account - > muc_service ) ;
connection_free_uuid ( uuid ) ;
2015-04-11 18:37:52 -04:00
2016-11-19 21:09:34 -05:00
presence_join_room ( room_str - > str , account - > muc_nick , NULL ) ;
muc_join ( room_str - > str , account - > muc_nick , NULL , FALSE ) ;
2015-04-11 18:37:52 -04:00
2016-11-19 21:09:34 -05:00
g_string_free ( room_str , TRUE ) ;
account_free ( account ) ;
} else {
cons_show ( " Account MUC service property not found. " ) ;
}
2015-04-11 18:37:52 -04:00
2014-03-07 19:19:21 -05:00
return TRUE ;
}
2013-12-15 11:10:32 -05:00
Jid * room_arg = jid_create ( args [ 0 ] ) ;
if ( room_arg = = NULL ) {
2014-03-07 19:23:52 -05:00
cons_show_error ( " Specified room has incorrect format. " ) ;
cons_show ( " " ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
char * room = NULL ;
char * nick = NULL ;
2014-02-27 00:31:10 -05:00
char * passwd = NULL ;
2016-05-05 19:53:03 -04:00
char * account_name = session_get_account_name ( ) ;
2014-03-07 19:19:21 -05:00
ProfAccount * account = accounts_get_account ( account_name ) ;
2013-12-15 11:10:32 -05:00
// full room jid supplied (room@server)
2015-05-04 17:23:59 -04:00
if ( room_arg - > localpart ) {
2013-12-15 11:10:32 -05:00
room = args [ 0 ] ;
// server not supplied (room), use account preference
2016-11-19 21:09:34 -05:00
} else if ( account - > muc_service ) {
GString * room_str = g_string_new ( " " ) ;
2013-12-15 11:10:32 -05:00
g_string_append ( room_str , args [ 0 ] ) ;
g_string_append ( room_str , " @ " ) ;
g_string_append ( room_str , account - > muc_service ) ;
room = room_str - > str ;
2016-11-19 21:09:34 -05:00
g_string_free ( room_str , FALSE ) ;
// no account preference
} else {
cons_show ( " Account MUC service property not found. " ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2014-03-05 12:13:42 -05:00
// Additional args supplied
2014-04-14 19:13:32 -04:00
gchar * opt_keys [ ] = { " nick " , " password " , NULL } ;
2014-04-14 18:36:00 -04:00
gboolean parsed ;
2014-04-14 19:27:55 -04:00
GHashTable * options = parse_options ( & args [ 1 ] , opt_keys , & parsed ) ;
2014-04-14 18:36:00 -04:00
if ( ! parsed ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-04-14 18:36:00 -04:00
cons_show ( " " ) ;
2015-06-24 15:53:04 -04:00
jid_destroy ( room_arg ) ;
2014-04-14 18:36:00 -04:00
return TRUE ;
2014-03-05 14:55:02 -05:00
}
2014-03-05 12:39:44 -05:00
2014-04-14 18:36:00 -04:00
nick = g_hash_table_lookup ( options , " nick " ) ;
passwd = g_hash_table_lookup ( options , " password " ) ;
options_destroy ( options ) ;
2014-03-05 14:55:02 -05:00
// In the case that a nick wasn't provided by the optional args...
2015-03-28 22:16:41 -04:00
if ( ! nick ) {
2013-12-15 11:10:32 -05:00
nick = account - > muc_nick ;
}
2015-03-28 22:16:41 -04:00
// When no password, check for invite with password
if ( ! passwd ) {
passwd = muc_invite_password ( room ) ;
}
2014-09-28 17:09:20 -04:00
if ( ! muc_active ( room ) ) {
2014-03-08 16:10:23 -05:00
presence_join_room ( room , nick , passwd ) ;
2014-09-28 17:09:20 -04:00
muc_join ( room , nick , passwd , FALSE ) ;
} else if ( muc_roster_complete ( room ) ) {
2014-10-17 19:40:44 -04:00
ui_switch_to_room ( room ) ;
2013-12-15 11:10:32 -05:00
}
jid_destroy ( room_arg ) ;
2014-01-22 17:22:01 -05:00
account_free ( account ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_invite ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * contact = args [ 0 ] ;
char * reason = args [ 1 ] ;
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2013-12-15 11:10:32 -05:00
cons_show ( " You must be in a chat room to send an invite. " ) ;
return TRUE ;
}
char * usr_jid = roster_barejid_from_name ( contact ) ;
if ( usr_jid = = NULL ) {
usr_jid = contact ;
}
2014-12-18 18:57:19 -05:00
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
message_send_invite ( mucwin - > roomjid , usr_jid , reason ) ;
2015-05-04 17:23:59 -04:00
if ( reason ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Room invite sent, contact: %s, room: %s, reason: \" %s \" . " ,
2014-12-18 18:57:19 -05:00
contact , mucwin - > roomjid , reason ) ;
2013-12-15 11:10:32 -05:00
} else {
cons_show ( " Room invite sent, contact: %s, room: %s. " ,
2014-12-18 18:57:19 -05:00
contact , mucwin - > roomjid ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_invites ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2017-03-31 19:27:11 -04:00
GList * invites = muc_invites ( ) ;
2013-12-15 11:10:32 -05:00
cons_show_room_invites ( invites ) ;
2017-03-31 19:27:11 -04:00
g_list_free_full ( invites , g_free ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_decline ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2014-09-28 17:09:20 -04:00
if ( ! muc_invites_contain ( args [ 0 ] ) ) {
2013-12-15 11:10:32 -05:00
cons_show ( " No such invite exists. " ) ;
} else {
2014-09-28 17:09:20 -04:00
muc_invites_remove ( args [ 0 ] ) ;
2013-12-15 11:10:32 -05:00
cons_show ( " Declined invite to %s. " , args [ 0 ] ) ;
}
return TRUE ;
}
2014-10-18 22:27:34 -04:00
gboolean
2015-06-16 19:15:28 -04:00
cmd_form_field ( ProfWin * window , char * tag , gchar * * args )
2014-10-18 22:27:34 -04:00
{
2018-04-11 12:57:50 -04:00
if ( window - > type ! = WIN_CONFIG ) {
2014-12-09 20:14:11 -05:00
return TRUE ;
}
2018-04-11 12:57:50 -04:00
ProfConfWin * confwin = ( ProfConfWin * ) window ;
2014-12-15 20:39:47 -05:00
DataForm * form = confwin - > form ;
2014-10-18 22:27:34 -04:00
if ( form ) {
if ( ! form_tag_exists ( form , tag ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Form does not contain a field with tag %s " , tag ) ;
2014-10-18 22:27:34 -04:00
return TRUE ;
}
form_field_type_t field_type = form_get_field_type ( form , tag ) ;
char * cmd = NULL ;
char * value = NULL ;
gboolean valid = FALSE ;
gboolean added = FALSE ;
gboolean removed = FALSE ;
switch ( field_type ) {
case FIELD_BOOLEAN :
value = args [ 0 ] ;
if ( g_strcmp0 ( value , " on " ) = = 0 ) {
form_set_value ( form , tag , " 1 " ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else if ( g_strcmp0 ( value , " off " ) = = 0 ) {
form_set_value ( form , tag , " 0 " ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
}
break ;
case FIELD_TEXT_PRIVATE :
case FIELD_TEXT_SINGLE :
case FIELD_JID_SINGLE :
value = args [ 0 ] ;
if ( value = = NULL ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
} else {
form_set_value ( form , tag , value ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
}
break ;
case FIELD_LIST_SINGLE :
value = args [ 0 ] ;
if ( ( value = = NULL ) | | ! form_field_contains_option ( form , tag , value ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
} else {
form_set_value ( form , tag , value ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
}
break ;
case FIELD_TEXT_MULTI :
cmd = args [ 0 ] ;
if ( cmd ) {
value = args [ 1 ] ;
}
if ( ( g_strcmp0 ( cmd , " add " ) ! = 0 ) & & ( g_strcmp0 ( cmd , " remove " ) ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( value = = NULL ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( g_strcmp0 ( cmd , " add " ) = = 0 ) {
form_add_value ( form , tag , value ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( g_strcmp0 ( args [ 0 ] , " remove " ) = = 0 ) {
if ( ! g_str_has_prefix ( value , " val " ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( strlen ( value ) < 4 ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
int index = strtol ( & value [ 3 ] , NULL , 10 ) ;
if ( ( index < 1 ) | | ( index > form_get_value_count ( form , tag ) ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
removed = form_remove_text_multi_value ( form , tag , index ) ;
if ( removed ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Could not remove %s from %s " , value , tag ) ;
2014-10-18 22:27:34 -04:00
}
}
break ;
case FIELD_LIST_MULTI :
cmd = args [ 0 ] ;
if ( cmd ) {
value = args [ 1 ] ;
}
if ( ( g_strcmp0 ( cmd , " add " ) ! = 0 ) & & ( g_strcmp0 ( cmd , " remove " ) ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( value = = NULL ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( g_strcmp0 ( args [ 0 ] , " add " ) = = 0 ) {
valid = form_field_contains_option ( form , tag , value ) ;
if ( valid ) {
added = form_add_unique_value ( form , tag , value ) ;
if ( added ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Value %s already selected for %s " , value , tag ) ;
2014-10-18 22:27:34 -04:00
}
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
}
break ;
}
if ( g_strcmp0 ( args [ 0 ] , " remove " ) = = 0 ) {
valid = form_field_contains_option ( form , tag , value ) ;
if ( valid = = TRUE ) {
removed = form_remove_value ( form , tag , value ) ;
if ( removed ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Value %s is not currently set for %s " , value , tag ) ;
2014-10-18 22:27:34 -04:00
}
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
}
}
break ;
case FIELD_JID_MULTI :
cmd = args [ 0 ] ;
if ( cmd ) {
value = args [ 1 ] ;
}
if ( ( g_strcmp0 ( cmd , " add " ) ! = 0 ) & & ( g_strcmp0 ( cmd , " remove " ) ) ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( value = = NULL ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Invalid command, usage: " ) ;
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-10-18 22:27:34 -04:00
break ;
}
if ( g_strcmp0 ( args [ 0 ] , " add " ) = = 0 ) {
added = form_add_unique_value ( form , tag , value ) ;
if ( added ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " JID %s already exists in %s " , value , tag ) ;
2014-10-18 22:27:34 -04:00
}
break ;
}
if ( g_strcmp0 ( args [ 0 ] , " remove " ) = = 0 ) {
2014-12-09 20:14:11 -05:00
removed = form_remove_value ( form , tag , value ) ;
2014-10-18 22:27:34 -04:00
if ( removed ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field updated... " ) ;
2018-04-11 12:57:50 -04:00
confwin_show_form_field ( confwin , form , tag ) ;
2014-10-18 22:27:34 -04:00
} else {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " Field %s does not contain %s " , tag , value ) ;
2014-10-18 22:27:34 -04:00
}
}
break ;
default :
break ;
}
}
return TRUE ;
}
2014-09-02 19:36:42 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_form ( ProfWin * window , const char * const command , gchar * * args )
2014-09-02 19:36:42 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-09-02 19:36:42 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2018-04-11 12:57:50 -04:00
if ( window - > type ! = WIN_CONFIG ) {
2014-09-15 16:33:25 -04:00
cons_show ( " Command '/form' does not apply to this window. " ) ;
2014-09-03 17:56:33 -04:00
return TRUE ;
}
2014-09-02 19:58:20 -04:00
2014-09-15 16:33:25 -04:00
if ( ( g_strcmp0 ( args [ 0 ] , " submit " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " cancel " ) ! = 0 ) & &
2014-09-15 17:51:53 -04:00
( g_strcmp0 ( args [ 0 ] , " show " ) ! = 0 ) & &
2014-10-18 22:27:34 -04:00
( g_strcmp0 ( args [ 0 ] , " help " ) ! = 0 ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-09-03 17:56:33 -04:00
return TRUE ;
}
2014-09-02 19:58:20 -04:00
2018-04-11 12:57:50 -04:00
ProfConfWin * confwin = ( ProfConfWin * ) window ;
2015-06-17 14:49:55 -04:00
assert ( confwin - > memcheck = = PROFCONFWIN_MEMCHECK ) ;
2014-09-10 19:01:44 -04:00
2014-09-15 17:51:53 -04:00
if ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 ) {
2018-04-11 12:57:50 -04:00
confwin_show_form ( confwin ) ;
2014-09-15 17:51:53 -04:00
return TRUE ;
}
2014-09-16 15:52:38 -04:00
if ( g_strcmp0 ( args [ 0 ] , " help " ) = = 0 ) {
char * tag = args [ 1 ] ;
2015-05-04 17:23:59 -04:00
if ( tag ) {
2018-04-11 12:57:50 -04:00
confwin_field_help ( confwin , tag ) ;
2014-09-16 15:52:38 -04:00
} else {
2018-04-11 12:57:50 -04:00
confwin_form_help ( confwin ) ;
2014-09-16 15:52:38 -04:00
2016-07-03 19:41:29 -04:00
gchar * * help_text = NULL ;
2016-05-22 19:31:00 -04:00
Command * command = cmd_get ( " /form " ) ;
2014-09-16 15:52:38 -04:00
2015-05-04 17:23:59 -04:00
if ( command ) {
2015-07-25 21:05:53 -04:00
help_text = command - > help . synopsis ;
2014-09-16 15:52:38 -04:00
}
2014-12-21 14:40:15 -05:00
ui_show_lines ( ( ProfWin * ) confwin , help_text ) ;
2014-09-16 15:52:38 -04:00
}
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " " ) ;
2014-09-16 15:52:38 -04:00
return TRUE ;
}
2018-09-10 06:28:28 -04:00
if ( g_strcmp0 ( args [ 0 ] , " submit " ) = = 0 & & confwin - > submit ! = NULL ) {
2018-05-30 13:25:06 -04:00
confwin - > submit ( confwin ) ;
2014-09-15 16:33:25 -04:00
}
2014-10-31 21:48:36 -04:00
2018-09-10 06:28:28 -04:00
if ( g_strcmp0 ( args [ 0 ] , " cancel " ) = = 0 & & confwin - > cancel ! = NULL ) {
2018-05-30 13:25:06 -04:00
confwin - > cancel ( confwin ) ;
2014-09-15 16:33:25 -04:00
}
2014-10-31 21:48:36 -04:00
if ( ( g_strcmp0 ( args [ 0 ] , " submit " ) = = 0 ) | | ( g_strcmp0 ( args [ 0 ] , " cancel " ) = = 0 ) ) {
2014-12-15 20:39:47 -05:00
if ( confwin - > form ) {
2016-05-19 19:19:03 -04:00
cmd_ac_remove_form_fields ( confwin - > form ) ;
2014-10-18 18:56:10 -04:00
}
2015-10-13 15:46:59 -04:00
int num = wins_get_num ( window ) ;
2015-04-30 17:09:39 -04:00
ProfWin * new_current = ( ProfWin * ) wins_get_muc ( confwin - > roomjid ) ;
if ( ! new_current ) {
new_current = wins_get_console ( ) ;
2014-09-15 16:33:25 -04:00
}
2015-11-02 15:59:36 -05:00
ui_focus_win ( new_current ) ;
2015-10-13 15:46:59 -04:00
wins_close_by_num ( num ) ;
2018-03-09 20:48:43 -05:00
wins_tidy ( ) ;
2014-09-15 16:33:25 -04:00
}
return TRUE ;
}
2014-10-10 08:35:50 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_kick ( ProfWin * window , const char * const command , gchar * * args )
2014-10-10 08:35:50 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-10-10 08:35:50 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2014-10-10 08:35:50 -04:00
cons_show ( " Command '/kick' only applies in chat rooms. " ) ;
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-10-10 08:35:50 -04:00
char * nick = args [ 0 ] ;
if ( nick ) {
2014-12-18 18:57:19 -05:00
if ( muc_roster_contains_nick ( mucwin - > roomjid , nick ) ) {
2014-10-10 08:35:50 -04:00
char * reason = args [ 1 ] ;
2014-12-18 18:57:19 -05:00
iq_room_kick_occupant ( mucwin - > roomjid , nick , reason ) ;
2014-10-10 08:35:50 -04:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Occupant does not exist: %s " , nick ) ;
2014-10-10 08:35:50 -04:00
}
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-10 08:35:50 -04:00
}
return TRUE ;
}
2014-10-11 17:43:54 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_ban ( ProfWin * window , const char * const command , gchar * * args )
2014-10-11 17:43:54 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-10-11 17:43:54 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2014-10-18 15:35:23 -04:00
cons_show ( " Command '/ban' only applies in chat rooms. " ) ;
2014-10-11 17:43:54 -04:00
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-10-11 17:43:54 -04:00
char * jid = args [ 0 ] ;
if ( jid ) {
char * reason = args [ 1 ] ;
2014-12-18 18:57:19 -05:00
iq_room_affiliation_set ( mucwin - > roomjid , jid , " outcast " , reason ) ;
2014-10-11 17:43:54 -04:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 17:43:54 -04:00
}
return TRUE ;
}
2014-10-11 18:13:48 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_subject ( ProfWin * window , const char * const command , gchar * * args )
2014-10-11 18:13:48 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-10-11 18:13:48 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2014-10-11 18:13:48 -04:00
cons_show ( " Command '/room' does not apply to this window. " ) ;
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-10-11 18:13:48 -04:00
if ( args [ 0 ] = = NULL ) {
2014-12-18 18:57:19 -05:00
char * subject = muc_subject ( mucwin - > roomjid ) ;
2014-10-11 18:13:48 -04:00
if ( subject ) {
2016-10-15 13:29:02 -04:00
win_print ( window , THEME_ROOMINFO , ' ! ' , " Room subject: " ) ;
2016-10-15 14:19:44 -04:00
win_appendln ( window , THEME_DEFAULT , " %s " , subject ) ;
2014-10-11 18:13:48 -04:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_ROOMINFO , ' ! ' , " Room has no subject " ) ;
2014-10-11 18:13:48 -04:00
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " set " ) = = 0 ) {
if ( args [ 1 ] ) {
2014-12-18 18:57:19 -05:00
message_send_groupchat_subject ( mucwin - > roomjid , args [ 1 ] ) ;
2014-10-11 18:13:48 -04:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-10-29 16:55:37 -04:00
}
return TRUE ;
}
2015-10-29 17:21:41 -04:00
if ( g_strcmp0 ( args [ 0 ] , " edit " ) = = 0 ) {
if ( args [ 1 ] ) {
message_send_groupchat_subject ( mucwin - > roomjid , args [ 1 ] ) ;
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
}
2015-10-29 17:02:46 -04:00
if ( g_strcmp0 ( args [ 0 ] , " prepend " ) = = 0 ) {
if ( args [ 1 ] ) {
char * old_subject = muc_subject ( mucwin - > roomjid ) ;
if ( old_subject ) {
GString * new_subject = g_string_new ( args [ 1 ] ) ;
g_string_append ( new_subject , old_subject ) ;
message_send_groupchat_subject ( mucwin - > roomjid , new_subject - > str ) ;
g_string_free ( new_subject , TRUE ) ;
} else {
2016-10-15 13:29:02 -04:00
win_print ( window , THEME_ROOMINFO , ' ! ' , " Room does not have a subject, use /subject set <subject> " ) ;
2015-10-29 17:02:46 -04:00
}
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
}
2015-10-29 16:55:37 -04:00
if ( g_strcmp0 ( args [ 0 ] , " append " ) = = 0 ) {
if ( args [ 1 ] ) {
char * old_subject = muc_subject ( mucwin - > roomjid ) ;
if ( old_subject ) {
GString * new_subject = g_string_new ( old_subject ) ;
g_string_append ( new_subject , args [ 1 ] ) ;
message_send_groupchat_subject ( mucwin - > roomjid , new_subject - > str ) ;
g_string_free ( new_subject , TRUE ) ;
} else {
2016-10-15 13:29:02 -04:00
win_print ( window , THEME_ROOMINFO , ' ! ' , " Room does not have a subject, use /subject set <subject> " ) ;
2015-10-29 16:55:37 -04:00
}
} else {
cons_bad_cmd_usage ( command ) ;
2014-10-11 18:13:48 -04:00
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " clear " ) = = 0 ) {
2014-12-18 18:57:19 -05:00
message_send_groupchat_subject ( mucwin - > roomjid , NULL ) ;
2014-10-11 18:13:48 -04:00
return TRUE ;
}
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 18:13:48 -04:00
return TRUE ;
}
2014-09-15 16:33:25 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_affiliation ( ProfWin * window , const char * const command , gchar * * args )
2014-09-15 16:33:25 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-09-15 16:33:25 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2014-10-11 19:43:58 -04:00
cons_show ( " Command '/affiliation' does not apply to this window. " ) ;
2014-09-15 16:33:25 -04:00
return TRUE ;
}
2014-10-11 19:43:58 -04:00
char * cmd = args [ 0 ] ;
if ( cmd = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 19:43:58 -04:00
return TRUE ;
}
char * affiliation = args [ 1 ] ;
2015-05-04 17:23:59 -04:00
if ( affiliation & &
2014-10-11 20:32:15 -04:00
( g_strcmp0 ( affiliation , " owner " ) ! = 0 ) & &
2014-10-11 19:43:58 -04:00
( g_strcmp0 ( affiliation , " admin " ) ! = 0 ) & &
( g_strcmp0 ( affiliation , " member " ) ! = 0 ) & &
( g_strcmp0 ( affiliation , " none " ) ! = 0 ) & &
( g_strcmp0 ( affiliation , " outcast " ) ! = 0 ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-09-15 16:33:25 -04:00
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-09-15 16:33:25 -04:00
2014-10-11 19:43:58 -04:00
if ( g_strcmp0 ( cmd , " list " ) = = 0 ) {
2014-10-11 20:32:15 -04:00
if ( ! affiliation ) {
2014-12-18 18:57:19 -05:00
iq_room_affiliation_list ( mucwin - > roomjid , " owner " ) ;
iq_room_affiliation_list ( mucwin - > roomjid , " admin " ) ;
iq_room_affiliation_list ( mucwin - > roomjid , " member " ) ;
2014-12-19 19:52:35 -05:00
iq_room_affiliation_list ( mucwin - > roomjid , " outcast " ) ;
2014-10-11 20:32:15 -04:00
} else if ( g_strcmp0 ( affiliation , " none " ) = = 0 ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Cannot list users with no affiliation. " ) ;
2014-10-11 19:43:58 -04:00
} else {
2014-12-18 18:57:19 -05:00
iq_room_affiliation_list ( mucwin - > roomjid , affiliation ) ;
2014-10-11 19:43:58 -04:00
}
return TRUE ;
2014-09-15 16:33:25 -04:00
}
2014-10-11 19:43:58 -04:00
if ( g_strcmp0 ( cmd , " set " ) = = 0 ) {
2014-10-11 20:32:15 -04:00
if ( ! affiliation ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 20:32:15 -04:00
return TRUE ;
}
2014-10-11 19:43:58 -04:00
char * jid = args [ 2 ] ;
if ( jid = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-04 18:40:36 -04:00
return TRUE ;
2014-10-11 19:43:58 -04:00
} else {
char * reason = args [ 3 ] ;
2014-12-18 18:57:19 -05:00
iq_room_affiliation_set ( mucwin - > roomjid , jid , affiliation , reason ) ;
2014-10-04 18:40:36 -04:00
return TRUE ;
}
2014-10-11 19:43:58 -04:00
}
2014-10-04 18:40:36 -04:00
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 19:43:58 -04:00
return TRUE ;
}
2014-10-04 18:40:36 -04:00
2014-10-11 19:43:58 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_role ( ProfWin * window , const char * const command , gchar * * args )
2014-10-11 19:43:58 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-10-04 18:40:36 -04:00
2014-10-11 19:43:58 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
2014-10-04 18:40:36 -04:00
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2014-10-11 19:43:58 -04:00
cons_show ( " Command '/role' does not apply to this window. " ) ;
return TRUE ;
}
char * cmd = args [ 0 ] ;
if ( cmd = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 19:43:58 -04:00
return TRUE ;
}
char * role = args [ 1 ] ;
2015-05-04 17:23:59 -04:00
if ( role & &
2014-10-11 20:32:15 -04:00
( g_strcmp0 ( role , " visitor " ) ! = 0 ) & &
2014-10-11 19:43:58 -04:00
( g_strcmp0 ( role , " participant " ) ! = 0 ) & &
( g_strcmp0 ( role , " moderator " ) ! = 0 ) & &
( g_strcmp0 ( role , " none " ) ! = 0 ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 19:43:58 -04:00
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-10-11 19:43:58 -04:00
if ( g_strcmp0 ( cmd , " list " ) = = 0 ) {
2014-10-11 20:32:15 -04:00
if ( ! role ) {
2014-12-18 18:57:19 -05:00
iq_room_role_list ( mucwin - > roomjid , " moderator " ) ;
iq_room_role_list ( mucwin - > roomjid , " participant " ) ;
iq_room_role_list ( mucwin - > roomjid , " visitor " ) ;
2014-10-11 20:32:15 -04:00
} else if ( g_strcmp0 ( role , " none " ) = = 0 ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Cannot list users with no role. " ) ;
2014-10-11 19:43:58 -04:00
} else {
2014-12-18 18:57:19 -05:00
iq_room_role_list ( mucwin - > roomjid , role ) ;
2014-10-06 16:42:09 -04:00
}
2014-10-11 19:43:58 -04:00
return TRUE ;
}
2014-10-06 16:42:09 -04:00
2014-10-11 19:43:58 -04:00
if ( g_strcmp0 ( cmd , " set " ) = = 0 ) {
2014-10-11 20:32:15 -04:00
if ( ! role ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 20:32:15 -04:00
return TRUE ;
}
2014-10-11 19:43:58 -04:00
char * nick = args [ 2 ] ;
if ( nick = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-06 16:42:09 -04:00
return TRUE ;
2014-10-11 19:43:58 -04:00
} else {
char * reason = args [ 3 ] ;
2014-12-18 18:57:19 -05:00
iq_room_role_set ( mucwin - > roomjid , nick , role , reason ) ;
2014-10-06 16:42:09 -04:00
return TRUE ;
}
2014-10-11 19:43:58 -04:00
}
2014-10-06 16:42:09 -04:00
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 19:43:58 -04:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_room ( ProfWin * window , const char * const command , gchar * * args )
2014-10-11 19:43:58 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-10-06 16:42:09 -04:00
2014-10-11 19:43:58 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
2014-09-30 19:46:58 -04:00
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2014-10-11 19:43:58 -04:00
cons_show ( " Command '/room' does not apply to this window. " ) ;
return TRUE ;
}
if ( ( g_strcmp0 ( args [ 0 ] , " accept " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " destroy " ) ! = 0 ) & &
( g_strcmp0 ( args [ 0 ] , " config " ) ! = 0 ) ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-11 19:43:58 -04:00
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-10-11 19:43:58 -04:00
2014-09-15 16:33:25 -04:00
if ( g_strcmp0 ( args [ 0 ] , " accept " ) = = 0 ) {
2014-12-18 18:57:19 -05:00
gboolean requires_config = muc_requires_config ( mucwin - > roomjid ) ;
2014-09-15 16:33:25 -04:00
if ( ! requires_config ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_ROOMINFO , ' ! ' , " Current room does not require configuration. " ) ;
2014-09-15 16:33:25 -04:00
return TRUE ;
} else {
2014-12-18 18:57:19 -05:00
iq_confirm_instant_room ( mucwin - > roomjid ) ;
muc_set_requires_config ( mucwin - > roomjid , FALSE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_ROOMINFO , ' ! ' , " Room unlocked. " ) ;
2014-09-15 16:33:25 -04:00
return TRUE ;
2014-09-10 19:17:42 -04:00
}
2014-09-15 16:33:25 -04:00
}
2014-09-10 19:17:42 -04:00
2014-09-15 16:33:25 -04:00
if ( g_strcmp0 ( args [ 0 ] , " destroy " ) = = 0 ) {
2014-12-18 18:57:19 -05:00
iq_destroy_room ( mucwin - > roomjid ) ;
2014-09-15 16:33:25 -04:00
return TRUE ;
}
2014-09-10 19:17:42 -04:00
2014-09-15 16:33:25 -04:00
if ( g_strcmp0 ( args [ 0 ] , " config " ) = = 0 ) {
2018-04-11 12:57:50 -04:00
ProfConfWin * confwin = wins_get_conf ( mucwin - > roomjid ) ;
2014-12-18 18:57:19 -05:00
2015-04-30 17:09:39 -04:00
if ( confwin ) {
2015-11-02 15:59:36 -05:00
ui_focus_win ( ( ProfWin * ) confwin ) ;
2014-09-15 16:33:25 -04:00
} else {
2014-12-18 18:57:19 -05:00
iq_request_room_config_form ( mucwin - > roomjid ) ;
2014-09-15 16:33:25 -04:00
}
2014-09-10 19:17:42 -04:00
return TRUE ;
2014-09-02 19:58:20 -04:00
}
2014-09-03 17:56:33 -04:00
2014-09-02 19:36:42 -04:00
return TRUE ;
}
2014-10-09 08:16:36 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_occupants ( ProfWin * window , const char * const command , gchar * * args )
2014-10-09 08:16:36 -04:00
{
2014-11-15 18:47:27 -05:00
if ( g_strcmp0 ( args [ 0 ] , " size " ) = = 0 ) {
if ( ! args [ 1 ] ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-11-15 18:47:27 -05:00
return TRUE ;
2015-03-15 21:03:20 -04:00
} else {
int intval = 0 ;
char * err_msg = NULL ;
2015-03-15 21:06:40 -04:00
gboolean res = strtoi_range ( args [ 1 ] , & intval , 1 , 99 , & err_msg ) ;
2015-03-15 21:03:20 -04:00
if ( res ) {
prefs_set_occupants_size ( intval ) ;
cons_show ( " Occupants screen size set to: %d%% " , intval ) ;
wins_resize_all ( ) ;
return TRUE ;
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
return TRUE ;
}
2014-11-15 18:47:27 -05:00
}
}
2019-04-18 14:56:51 -04:00
if ( g_strcmp0 ( args [ 0 ] , " indent " ) = = 0 ) {
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
} else {
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( args [ 1 ] , & intval , 0 , 10 , & err_msg ) ;
if ( res ) {
prefs_set_occupants_indent ( intval ) ;
cons_show ( " Occupants indent set to: %d " , intval ) ;
2019-04-23 08:10:18 -04:00
occupantswin_occupants_all ( ) ;
2019-04-18 14:56:51 -04:00
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
return TRUE ;
}
}
2019-04-23 10:54:40 -04:00
if ( g_strcmp0 ( args [ 0 ] , " wrap " ) = = 0 ) {
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
} else {
_cmd_set_boolean_preference ( args [ 1 ] , command , " Occupants panel line wrap " , PREF_OCCUPANTS_WRAP ) ;
occupantswin_occupants_all ( ) ;
return TRUE ;
}
}
2019-05-02 11:01:55 -04:00
if ( g_strcmp0 ( args [ 0 ] , " char " ) = = 0 ) {
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 1 ] , " none " ) = = 0 ) {
prefs_clear_occupants_char ( ) ;
cons_show ( " Occupants char removed. " ) ;
occupantswin_occupants_all ( ) ;
} else {
prefs_set_occupants_char ( args [ 1 ] [ 0 ] ) ;
cons_show ( " Occupants char set to %c. " , args [ 1 ] [ 0 ] ) ;
occupantswin_occupants_all ( ) ;
}
return TRUE ;
}
2014-10-09 17:39:57 -04:00
if ( g_strcmp0 ( args [ 0 ] , " default " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " show " ) = = 0 ) {
2015-04-11 21:14:37 -04:00
if ( g_strcmp0 ( args [ 2 ] , " jid " ) = = 0 ) {
cons_show ( " Occupant jids enabled. " ) ;
prefs_set_boolean ( PREF_OCCUPANTS_JID , TRUE ) ;
} else {
cons_show ( " Occupant list enabled. " ) ;
prefs_set_boolean ( PREF_OCCUPANTS , TRUE ) ;
}
2014-10-09 17:39:57 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " hide " ) = = 0 ) {
2015-04-11 21:14:37 -04:00
if ( g_strcmp0 ( args [ 2 ] , " jid " ) = = 0 ) {
cons_show ( " Occupant jids disabled. " ) ;
prefs_set_boolean ( PREF_OCCUPANTS_JID , FALSE ) ;
} else {
cons_show ( " Occupant list disabled. " ) ;
prefs_set_boolean ( PREF_OCCUPANTS , FALSE ) ;
}
2014-10-09 17:39:57 -04:00
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-09 17:39:57 -04:00
return TRUE ;
}
}
2019-04-23 07:50:58 -04:00
// header settings
if ( g_strcmp0 ( args [ 0 ] , " header " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " char " ) = = 0 ) {
if ( ! args [ 2 ] ) {
cons_bad_cmd_usage ( command ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " none " ) = = 0 ) {
prefs_clear_occupants_header_char ( ) ;
cons_show ( " Occupants header char removed. " ) ;
2019-04-23 08:10:18 -04:00
occupantswin_occupants_all ( ) ;
2019-04-23 07:50:58 -04:00
} else {
prefs_set_occupants_header_char ( args [ 2 ] [ 0 ] ) ;
cons_show ( " Occupants header char set to %c. " , args [ 2 ] [ 0 ] ) ;
2019-04-23 08:10:18 -04:00
occupantswin_occupants_all ( ) ;
2019-04-23 07:50:58 -04:00
}
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
}
2016-09-25 19:46:09 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2015-04-11 21:14:37 -04:00
cons_show ( " Cannot apply setting when not in chat room. " ) ;
2014-10-09 08:16:36 -04:00
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-10-09 08:16:36 -04:00
if ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 ) {
2015-04-11 21:14:37 -04:00
if ( g_strcmp0 ( args [ 1 ] , " jid " ) = = 0 ) {
mucwin - > showjid = TRUE ;
2015-11-01 19:57:13 -05:00
mucwin_update_occupants ( mucwin ) ;
2015-04-11 21:14:37 -04:00
} else {
2015-11-01 19:59:27 -05:00
mucwin_show_occupants ( mucwin ) ;
2015-04-11 21:14:37 -04:00
}
2014-10-09 08:16:36 -04:00
} else if ( g_strcmp0 ( args [ 0 ] , " hide " ) = = 0 ) {
2015-04-11 21:14:37 -04:00
if ( g_strcmp0 ( args [ 1 ] , " jid " ) = = 0 ) {
mucwin - > showjid = FALSE ;
2015-11-01 19:57:13 -05:00
mucwin_update_occupants ( mucwin ) ;
2015-04-11 21:14:37 -04:00
} else {
2015-11-01 20:01:37 -05:00
mucwin_hide_occupants ( mucwin ) ;
2015-04-11 21:14:37 -04:00
}
2014-10-09 08:16:36 -04:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-10-09 08:16:36 -04:00
}
return TRUE ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_rooms ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2018-01-27 18:51:03 -05:00
gchar * service = NULL ;
gchar * filter = NULL ;
2018-01-27 17:42:31 -05:00
if ( args [ 0 ] ! = NULL ) {
if ( g_strcmp0 ( args [ 0 ] , " service " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
return TRUE ;
}
service = g_strdup ( args [ 1 ] ) ;
2018-01-27 18:51:03 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " filter " ) = = 0 ) {
2018-01-27 17:42:31 -05:00
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
return TRUE ;
}
2018-01-27 18:51:03 -05:00
filter = g_strdup ( args [ 1 ] ) ;
2018-02-05 15:01:54 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " cache " ) = = 0 ) {
if ( g_strv_length ( args ) ! = 2 ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
prefs_set_boolean ( PREF_ROOM_LIST_CACHE , TRUE ) ;
cons_show ( " Rooms list cache enabled. " ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_boolean ( PREF_ROOM_LIST_CACHE , FALSE ) ;
cons_show ( " Rooms list cache disabled. " ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " clear " ) = = 0 ) {
iq_rooms_cache_clear ( ) ;
cons_show ( " Rooms list cache cleared. " ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
return TRUE ;
}
2018-01-27 17:42:31 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
return TRUE ;
}
}
if ( g_strv_length ( args ) > = 3 ) {
if ( g_strcmp0 ( args [ 2 ] , " service " ) = = 0 ) {
if ( args [ 3 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
g_free ( service ) ;
2018-01-27 18:51:03 -05:00
g_free ( filter ) ;
2018-01-27 17:42:31 -05:00
return TRUE ;
}
g_free ( service ) ;
service = g_strdup ( args [ 3 ] ) ;
2018-01-27 18:51:03 -05:00
} else if ( g_strcmp0 ( args [ 2 ] , " filter " ) = = 0 ) {
2018-01-27 17:42:31 -05:00
if ( args [ 3 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
g_free ( service ) ;
2018-01-27 18:51:03 -05:00
g_free ( filter ) ;
2018-01-27 17:42:31 -05:00
return TRUE ;
}
2018-01-27 18:51:03 -05:00
g_free ( filter ) ;
filter = g_strdup ( args [ 3 ] ) ;
2018-01-27 17:42:31 -05:00
} else {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
return TRUE ;
}
2016-11-19 21:09:34 -05:00
}
2018-01-27 17:42:31 -05:00
if ( service = = NULL ) {
ProfAccount * account = accounts_get_account ( session_get_account_name ( ) ) ;
if ( account - > muc_service ) {
service = g_strdup ( account - > muc_service ) ;
account_free ( account ) ;
} else {
cons_show ( " Account MUC service property not found. " ) ;
account_free ( account ) ;
g_free ( service ) ;
2018-01-27 18:51:03 -05:00
g_free ( filter ) ;
2018-01-27 17:42:31 -05:00
return TRUE ;
}
}
2018-02-04 16:59:33 -05:00
cons_show ( " " ) ;
if ( filter ) {
cons_show ( " Room list request sent: %s, filter: '%s' " , service , filter ) ;
} else {
cons_show ( " Room list request sent: %s " , service ) ;
}
2018-01-27 18:51:03 -05:00
iq_room_list_request ( service , filter ) ;
2018-01-27 17:42:31 -05:00
g_free ( service ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_bookmark ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
2014-02-01 11:24:51 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2014-02-01 11:16:56 -05:00
return TRUE ;
}
2018-03-03 19:35:53 -05:00
int num_args = g_strv_length ( args ) ;
2014-12-14 14:57:29 -05:00
gchar * cmd = args [ 0 ] ;
2018-03-03 19:35:53 -05:00
if ( window - > type = = WIN_MUC
& & num_args < 2
& & ( cmd = = NULL | | g_strcmp0 ( cmd , " add " ) = = 0 ) ) {
2014-08-19 17:51:00 -04:00
// default to current nickname, password, and autojoin "on"
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2014-12-18 18:57:19 -05:00
char * nick = muc_nick ( mucwin - > roomjid ) ;
char * password = muc_password ( mucwin - > roomjid ) ;
gboolean added = bookmark_add ( mucwin - > roomjid , nick , password , " on " ) ;
2014-12-14 14:57:29 -05:00
if ( added ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Bookmark added for %s. " , mucwin - > roomjid ) ;
2014-08-19 17:51:00 -04:00
} else {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Bookmark already exists for %s. " , mucwin - > roomjid ) ;
2013-12-15 11:10:32 -05:00
}
2014-12-14 14:57:29 -05:00
return TRUE ;
2016-10-04 19:52:57 -04:00
}
2013-12-15 11:10:32 -05:00
2018-03-03 19:35:53 -05:00
if ( window - > type = = WIN_MUC
& & num_args < 2
& & g_strcmp0 ( cmd , " remove " ) = = 0 ) {
2016-10-04 19:52:57 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
gboolean removed = bookmark_remove ( mucwin - > roomjid ) ;
if ( removed ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Bookmark removed for %s. " , mucwin - > roomjid ) ;
2016-10-04 19:52:57 -04:00
} else {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Bookmark does not exist for %s. " , mucwin - > roomjid ) ;
2016-10-04 19:52:57 -04:00
}
return TRUE ;
}
if ( cmd = = NULL ) {
cons_bad_cmd_usage ( command ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
if ( strcmp ( cmd , " invites " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
prefs_set_boolean ( PREF_BOOKMARK_INVITE , TRUE ) ;
cons_show ( " Auto bookmarking accepted invites enabled. " ) ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_boolean ( PREF_BOOKMARK_INVITE , FALSE ) ;
cons_show ( " Auto bookmarking accepted invites disabled. " ) ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2016-10-04 19:52:57 -04:00
cons_show ( " " ) ;
2014-05-09 19:50:43 -04:00
}
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
2014-05-09 19:50:43 -04:00
2016-10-04 19:52:57 -04:00
if ( strcmp ( cmd , " list " ) = = 0 ) {
GList * bookmarks = bookmark_get_list ( ) ;
cons_show_bookmarks ( bookmarks ) ;
g_list_free ( bookmarks ) ;
return TRUE ;
}
char * jid = args [ 1 ] ;
if ( jid = = NULL ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
if ( strchr ( jid , ' @ ' ) = = NULL ) {
cons_show ( " Invalid room, must be of the form room@domain.tld " ) ;
cons_show ( " " ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
if ( strcmp ( cmd , " remove " ) = = 0 ) {
gboolean removed = bookmark_remove ( jid ) ;
if ( removed ) {
cons_show ( " Bookmark removed for %s. " , jid ) ;
2014-08-19 17:51:00 -04:00
} else {
2016-10-04 19:52:57 -04:00
cons_show ( " No bookmark exists for %s. " , jid ) ;
}
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
2013-12-15 11:10:32 -05:00
2016-10-04 19:52:57 -04:00
if ( strcmp ( cmd , " join " ) = = 0 ) {
gboolean joined = bookmark_join ( jid ) ;
if ( ! joined ) {
cons_show ( " No bookmark exists for %s. " , jid ) ;
}
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
2014-08-19 17:51:00 -04:00
2016-10-04 19:52:57 -04:00
gchar * opt_keys [ ] = { " autojoin " , " nick " , " password " , NULL } ;
gboolean parsed ;
2014-08-19 17:51:00 -04:00
2016-10-04 19:52:57 -04:00
GHashTable * options = parse_options ( & args [ 2 ] , opt_keys , & parsed ) ;
if ( ! parsed ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
2014-08-19 17:51:00 -04:00
2016-10-04 19:52:57 -04:00
char * autojoin = g_hash_table_lookup ( options , " autojoin " ) ;
2014-08-19 17:51:00 -04:00
2016-10-04 19:52:57 -04:00
if ( autojoin & & ( ( strcmp ( autojoin , " on " ) ! = 0 ) & & ( strcmp ( autojoin , " off " ) ! = 0 ) ) ) {
cons_bad_cmd_usage ( command ) ;
cons_show ( " " ) ;
options_destroy ( options ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
2014-08-19 17:51:00 -04:00
2016-10-04 19:52:57 -04:00
char * nick = g_hash_table_lookup ( options , " nick " ) ;
char * password = g_hash_table_lookup ( options , " password " ) ;
2014-08-19 17:51:00 -04:00
2016-10-04 19:52:57 -04:00
if ( strcmp ( cmd , " add " ) = = 0 ) {
gboolean added = bookmark_add ( jid , nick , password , autojoin ) ;
if ( added ) {
cons_show ( " Bookmark added for %s. " , jid ) ;
} else {
cons_show ( " Bookmark already exists, use /bookmark update to edit. " ) ;
}
options_destroy ( options ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
}
2014-05-09 19:50:43 -04:00
2016-10-04 19:52:57 -04:00
if ( strcmp ( cmd , " update " ) = = 0 ) {
gboolean updated = bookmark_update ( jid , nick , password , autojoin ) ;
if ( updated ) {
cons_show ( " Bookmark updated. " ) ;
} else {
cons_show ( " No bookmark exists for %s. " , jid ) ;
2014-08-19 17:51:00 -04:00
}
2016-10-04 19:52:57 -04:00
options_destroy ( options ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2016-10-04 19:52:57 -04:00
cons_bad_cmd_usage ( command ) ;
options_destroy ( options ) ;
2018-03-04 16:15:24 -05:00
cons_alert ( ) ;
2016-10-04 19:52:57 -04:00
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_disco ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
2015-11-27 06:42:55 -05:00
cons_show ( " You are not currently connected. " ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
GString * jid = g_string_new ( " " ) ;
2015-05-04 17:23:59 -04:00
if ( args [ 1 ] ) {
2013-12-15 11:10:32 -05:00
jid = g_string_append ( jid , args [ 1 ] ) ;
} else {
2016-05-05 20:12:54 -04:00
Jid * jidp = jid_create ( connection_get_fulljid ( ) ) ;
2013-12-15 11:10:32 -05:00
jid = g_string_append ( jid , jidp - > domainpart ) ;
jid_destroy ( jidp ) ;
}
if ( g_strcmp0 ( args [ 0 ] , " info " ) = = 0 ) {
iq_disco_info_request ( jid - > str ) ;
} else {
iq_disco_items_request ( jid - > str ) ;
}
g_string_free ( jid , TRUE ) ;
return TRUE ;
}
2016-04-11 14:13:18 -04:00
gboolean
cmd_sendfile ( ProfWin * window , const char * const command , gchar * * args )
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2016-04-11 14:13:18 -04:00
char * filename = args [ 0 ] ;
// expand ~ to $HOME
if ( filename [ 0 ] = = ' ~ ' & & filename [ 1 ] = = ' / ' ) {
if ( asprintf ( & filename , " %s/%s " , getenv ( " HOME " ) , filename + 2 ) = = - 1 ) {
return TRUE ;
}
} else {
filename = strdup ( filename ) ;
}
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
free ( filename ) ;
return TRUE ;
}
if ( window - > type ! = WIN_CHAT & & window - > type ! = WIN_PRIVATE & & window - > type ! = WIN_MUC ) {
cons_show_error ( " Unsupported window for file transmission. " ) ;
free ( filename ) ;
return TRUE ;
}
if ( access ( filename , R_OK ) ! = 0 ) {
cons_show_error ( " Uploading '%s' failed: File not found! " , filename ) ;
free ( filename ) ;
return TRUE ;
}
if ( ! is_regular_file ( filename ) ) {
cons_show_error ( " Uploading '%s' failed: Not a file! " , filename ) ;
free ( filename ) ;
return TRUE ;
}
HTTPUpload * upload = malloc ( sizeof ( HTTPUpload ) ) ;
upload - > window = window ;
upload - > filename = filename ;
upload - > filesize = file_size ( filename ) ;
upload - > mime_type = file_mime_type ( filename ) ;
iq_http_upload_request ( upload ) ;
return TRUE ;
}
2015-09-28 19:01:38 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_lastactivity ( ProfWin * window , const char * const command , gchar * * args )
2015-09-28 19:01:38 -04:00
{
2015-10-15 18:32:47 -04:00
if ( ( g_strcmp0 ( args [ 0 ] , " on " ) = = 0 ) | | ( g_strcmp0 ( args [ 0 ] , " off " ) = = 0 ) ) {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Last activity " , PREF_LASTACTIVITY ) ;
2016-08-17 19:29:33 -04:00
if ( g_strcmp0 ( args [ 0 ] , " on " ) = = 0 ) {
caps_add_feature ( XMPP_FEATURE_LASTACTIVITY ) ;
}
if ( g_strcmp0 ( args [ 0 ] , " off " ) = = 0 ) {
caps_remove_feature ( XMPP_FEATURE_LASTACTIVITY ) ;
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2015-10-15 18:32:47 -04:00
}
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-09-28 19:01:38 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2015-09-28 19:01:38 -04:00
return TRUE ;
}
if ( args [ 0 ] = = NULL ) {
2016-05-05 20:12:54 -04:00
Jid * jidp = jid_create ( connection_get_fulljid ( ) ) ;
2015-09-28 19:01:38 -04:00
GString * jid = g_string_new ( jidp - > domainpart ) ;
iq_last_activity_request ( jid - > str ) ;
g_string_free ( jid , TRUE ) ;
jid_destroy ( jidp ) ;
2015-10-14 17:09:18 -04:00
return TRUE ;
2015-09-28 19:01:38 -04:00
} else {
iq_last_activity_request ( args [ 0 ] ) ;
2015-10-14 17:09:18 -04:00
return TRUE ;
2015-09-28 19:01:38 -04:00
}
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_nick ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_MUC ) {
2013-12-15 11:10:32 -05:00
cons_show ( " You can only change your nickname in a chat room window. " ) ;
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2013-12-15 11:10:32 -05:00
char * nick = args [ 0 ] ;
2014-12-18 18:57:19 -05:00
presence_change_room_nick ( mucwin - > roomjid , nick ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
2014-01-23 14:56:33 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_alias ( ProfWin * window , const char * const command , gchar * * args )
2014-01-23 14:56:33 -05:00
{
2014-01-23 17:29:53 -05:00
char * subcmd = args [ 0 ] ;
if ( strcmp ( subcmd , " add " ) = = 0 ) {
char * alias = args [ 1 ] ;
if ( alias = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-01-23 17:29:53 -05:00
return TRUE ;
} else {
2014-11-30 18:34:54 -05:00
char * alias_p = alias ;
GString * ac_value = g_string_new ( " " ) ;
if ( alias [ 0 ] = = ' / ' ) {
g_string_append ( ac_value , alias ) ;
alias_p = & alias [ 1 ] ;
} else {
g_string_append ( ac_value , " / " ) ;
g_string_append ( ac_value , alias ) ;
}
2014-01-24 20:39:12 -05:00
2014-01-23 17:29:53 -05:00
char * value = args [ 2 ] ;
if ( value = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-01-24 20:39:12 -05:00
g_string_free ( ac_value , TRUE ) ;
return TRUE ;
2016-05-19 19:19:03 -04:00
} else if ( cmd_ac_exists ( ac_value - > str ) ) {
2014-02-15 16:17:31 -05:00
cons_show ( " Command or alias '%s' already exists. " , ac_value - > str ) ;
2014-01-24 20:39:12 -05:00
g_string_free ( ac_value , TRUE ) ;
2014-01-23 17:29:53 -05:00
return TRUE ;
} else {
2014-11-30 18:34:54 -05:00
prefs_add_alias ( alias_p , value ) ;
2016-05-19 19:19:03 -04:00
cmd_ac_add ( ac_value - > str ) ;
cmd_ac_add_alias_value ( alias_p ) ;
2014-11-30 18:34:54 -05:00
cons_show ( " Command alias added %s -> %s " , ac_value - > str , value ) ;
2014-01-24 20:39:12 -05:00
g_string_free ( ac_value , TRUE ) ;
2014-01-23 17:29:53 -05:00
return TRUE ;
}
}
} else if ( strcmp ( subcmd , " remove " ) = = 0 ) {
char * alias = args [ 1 ] ;
if ( alias = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-01-23 17:29:53 -05:00
return TRUE ;
} else {
2014-11-30 18:34:54 -05:00
if ( alias [ 0 ] = = ' / ' ) {
alias = & alias [ 1 ] ;
}
2014-01-23 17:29:53 -05:00
gboolean removed = prefs_remove_alias ( alias ) ;
if ( ! removed ) {
cons_show ( " No such command alias /%s " , alias ) ;
} else {
2014-01-23 18:53:20 -05:00
GString * ac_value = g_string_new ( " / " ) ;
g_string_append ( ac_value , alias ) ;
2016-05-19 19:19:03 -04:00
cmd_ac_remove ( ac_value - > str ) ;
cmd_ac_remove_alias_value ( alias ) ;
2014-01-23 18:53:20 -05:00
g_string_free ( ac_value , TRUE ) ;
2014-01-23 17:29:53 -05:00
cons_show ( " Command alias removed -> /%s " , alias ) ;
}
return TRUE ;
}
} else if ( strcmp ( subcmd , " list " ) = = 0 ) {
GList * aliases = prefs_get_aliases ( ) ;
cons_show_aliases ( aliases ) ;
prefs_free_aliases ( aliases ) ;
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-01-23 17:29:53 -05:00
return TRUE ;
}
2014-01-23 14:56:33 -05:00
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_tiny ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * url = args [ 0 ] ;
2015-03-16 19:03:31 -04:00
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_CHAT & & window - > type ! = WIN_MUC & & window - > type ! = WIN_PRIVATE ) {
2015-03-16 19:03:31 -04:00
cons_show ( " /tiny can only be used in chat windows " ) ;
return TRUE ;
}
2013-12-15 11:10:32 -05:00
if ( ! tinyurl_valid ( url ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_ERROR , ' - ' , " /tiny, badly formed URL: %s " , url ) ;
2015-03-16 19:03:31 -04:00
return TRUE ;
}
2013-12-15 11:10:32 -05:00
2015-03-16 19:03:31 -04:00
char * tiny = tinyurl_get ( url ) ;
if ( ! tiny ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_ERROR , ' - ' , " Couldn't create tinyurl. " ) ;
2015-03-16 19:03:31 -04:00
return TRUE ;
}
2015-06-16 19:15:28 -04:00
switch ( window - > type ) {
2015-03-16 19:03:31 -04:00
case WIN_CHAT :
{
2015-06-17 14:49:55 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2016-04-11 14:13:18 -04:00
cl_ev_send_msg ( chatwin , tiny , NULL ) ;
2015-03-16 19:03:31 -04:00
break ;
2013-12-15 11:10:32 -05:00
}
2015-03-16 19:03:31 -04:00
case WIN_PRIVATE :
{
2015-06-17 14:49:55 -04:00
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
2016-04-11 14:13:18 -04:00
cl_ev_send_priv_msg ( privatewin , tiny , NULL ) ;
2015-03-16 19:03:31 -04:00
break ;
}
case WIN_MUC :
{
2015-06-17 14:49:55 -04:00
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2016-04-11 14:13:18 -04:00
cl_ev_send_muc_msg ( mucwin , tiny , NULL ) ;
2015-03-16 19:03:31 -04:00
break ;
}
default :
break ;
}
free ( tiny ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_clear ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2019-10-05 10:19:53 -04:00
if ( args [ 0 ] = = NULL ) {
win_clear ( window ) ;
return TRUE ;
} else {
if ( ( g_strcmp0 ( args [ 0 ] , " persist_history " ) = = 0 ) ) {
if ( args [ 1 ] ! = NULL ) {
if ( ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) | | ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) ) {
_cmd_set_boolean_preference ( args [ 1 ] , command , " Persistant history " , PREF_CLEAR_PERSIST_HISTORY ) ;
return TRUE ;
}
} else {
if ( prefs_get_boolean ( PREF_CLEAR_PERSIST_HISTORY ) ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " Persistantly clear screen : ON " ) ;
} else {
win_println ( window , THEME_DEFAULT , ' ! ' , " Persistantly clear screen : OFF " ) ;
}
return TRUE ;
}
}
}
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_leave ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2017-03-21 17:10:38 -04:00
if ( window - > type ! = WIN_MUC & & window - > type ! = WIN_CHAT & & window - > type ! = WIN_PRIVATE ) {
cons_show ( " The /leave command is only valid in chat, or chat room windows. " ) ;
2013-12-15 11:10:32 -05:00
cons_alert ( ) ;
return TRUE ;
}
2017-03-21 17:10:38 -04:00
// use /close behaviour
return cmd_close ( window , " /leave " , args ) ;
2013-12-15 11:10:32 -05:00
}
2014-10-18 15:22:34 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_privileges ( ProfWin * window , const char * const command , gchar * * args )
2014-10-18 15:22:34 -04:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " MUC privileges " , PREF_MUC_PRIVILEGES ) ;
2014-10-18 15:22:34 -04:00
ui_redraw_all_room_rosters ( ) ;
2016-04-17 18:46:29 -04:00
return TRUE ;
2014-10-18 15:22:34 -04:00
}
2015-12-19 18:32:58 -05:00
gboolean
cmd_charset ( ProfWin * window , const char * const command , gchar * * args )
{
char * codeset = nl_langinfo ( CODESET ) ;
char * lang = getenv ( " LANG " ) ;
cons_show ( " Charset information: " ) ;
if ( lang ) {
cons_show ( " LANG: %s " , lang ) ;
}
if ( codeset ) {
cons_show ( " CODESET: %s " , codeset ) ;
}
cons_show ( " MB_CUR_MAX: %d " , MB_CUR_MAX ) ;
cons_show ( " MB_LEN_MAX: %d " , MB_LEN_MAX ) ;
return TRUE ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_beep ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Sound " , PREF_BEEP ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2015-12-29 18:32:32 -05:00
gboolean
cmd_console ( ProfWin * window , const char * const command , gchar * * args )
{
2016-02-03 18:39:20 -05:00
if ( ( g_strcmp0 ( args [ 0 ] , " chat " ) ! = 0 ) & & ( g_strcmp0 ( args [ 0 ] , " muc " ) ! = 0 ) & & ( g_strcmp0 ( args [ 0 ] , " private " ) ! = 0 ) ) {
2015-12-29 18:32:32 -05:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * setting = args [ 1 ] ;
if ( ( g_strcmp0 ( setting , " all " ) ! = 0 ) & & ( g_strcmp0 ( setting , " first " ) ! = 0 ) & & ( g_strcmp0 ( setting , " none " ) ! = 0 ) ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-02-03 18:02:52 -05:00
if ( g_strcmp0 ( args [ 0 ] , " chat " ) = = 0 ) {
prefs_set_string ( PREF_CONSOLE_CHAT , setting ) ;
cons_show ( " Console chat messages set: %s " , setting ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " muc " ) = = 0 ) {
prefs_set_string ( PREF_CONSOLE_MUC , setting ) ;
cons_show ( " Console MUC messages set: %s " , setting ) ;
return TRUE ;
}
2015-12-29 18:32:32 -05:00
2016-02-03 18:39:20 -05:00
if ( g_strcmp0 ( args [ 0 ] , " private " ) = = 0 ) {
prefs_set_string ( PREF_CONSOLE_PRIVATE , setting ) ;
cons_show ( " Console private room messages set: %s " , setting ) ;
return TRUE ;
}
2015-12-29 18:32:32 -05:00
return TRUE ;
}
2014-11-07 17:38:34 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_presence ( ProfWin * window , const char * const command , gchar * * args )
2014-11-07 17:38:34 -05:00
{
2016-05-31 18:21:19 -04:00
if ( strcmp ( args [ 0 ] , " console " ) ! = 0 & &
strcmp ( args [ 0 ] , " chat " ) ! = 0 & &
strcmp ( args [ 0 ] , " room " ) ! = 0 & &
strcmp ( args [ 0 ] , " titlebar " ) ! = 0 ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( strcmp ( args [ 0 ] , " titlebar " ) = = 0 ) {
_cmd_set_boolean_preference ( args [ 1 ] , command , " Contact presence " , PREF_PRESENCE ) ;
return TRUE ;
}
if ( strcmp ( args [ 1 ] , " all " ) ! = 0 & &
strcmp ( args [ 1 ] , " online " ) ! = 0 & &
strcmp ( args [ 1 ] , " none " ) ! = 0 ) {
2016-05-31 17:46:03 -04:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-05-31 18:21:19 -04:00
if ( strcmp ( args [ 0 ] , " console " ) = = 0 ) {
prefs_set_string ( PREF_STATUSES_CONSOLE , args [ 1 ] ) ;
if ( strcmp ( args [ 1 ] , " all " ) = = 0 ) {
cons_show ( " All presence updates will appear in the console. " ) ;
} else if ( strcmp ( args [ 1 ] , " online " ) = = 0 ) {
cons_show ( " Only online/offline presence updates will appear in the console. " ) ;
} else {
cons_show ( " Presence updates will not appear in the console. " ) ;
}
}
if ( strcmp ( args [ 0 ] , " chat " ) = = 0 ) {
prefs_set_string ( PREF_STATUSES_CHAT , args [ 1 ] ) ;
if ( strcmp ( args [ 1 ] , " all " ) = = 0 ) {
cons_show ( " All presence updates will appear in chat windows. " ) ;
} else if ( strcmp ( args [ 1 ] , " online " ) = = 0 ) {
cons_show ( " Only online/offline presence updates will appear in chat windows. " ) ;
} else {
cons_show ( " Presence updates will not appear in chat windows. " ) ;
}
}
if ( strcmp ( args [ 0 ] , " room " ) = = 0 ) {
prefs_set_string ( PREF_STATUSES_MUC , args [ 1 ] ) ;
if ( strcmp ( args [ 1 ] , " all " ) = = 0 ) {
cons_show ( " All presence updates will appear in chat room windows. " ) ;
} else if ( strcmp ( args [ 1 ] , " online " ) = = 0 ) {
cons_show ( " Only join/leave presence updates will appear in chat room windows. " ) ;
} else {
cons_show ( " Presence updates will not appear in chat room windows. " ) ;
}
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2014-11-07 17:38:34 -05:00
}
2014-11-09 18:29:25 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_wrap ( ProfWin * window , const char * const command , gchar * * args )
2014-11-09 18:29:25 -05:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Word wrap " , PREF_WRAP ) ;
2014-11-09 18:29:25 -05:00
wins_resize_all ( ) ;
2016-04-17 18:46:29 -04:00
return TRUE ;
2014-11-09 18:29:25 -05:00
}
2014-11-15 19:40:54 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_time ( ProfWin * window , const char * const command , gchar * * args )
2014-11-15 19:40:54 -05:00
{
2015-09-29 18:30:23 -04:00
if ( g_strcmp0 ( args [ 0 ] , " lastactivity " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_LASTACTIVITY ) ;
cons_show ( " Last activity time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-09-29 18:30:23 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_LASTACTIVITY , args [ 2 ] ) ;
cons_show ( " Last activity time format set to '%s'. " , args [ 2 ] ) ;
ui_redraw ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
cons_show ( " Last activity time cannot be disabled. " ) ;
ui_redraw ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " statusbar " ) = = 0 ) {
2015-05-29 20:53:37 -04:00
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_STATUSBAR ) ;
cons_show ( " Status bar time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-03-10 19:35:08 -04:00
return TRUE ;
2015-05-29 20:53:37 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_STATUSBAR , args [ 2 ] ) ;
cons_show ( " Status bar time format set to '%s'. " , args [ 2 ] ) ;
2015-03-10 19:35:08 -04:00
ui_redraw ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2015-09-30 17:34:27 -04:00
prefs_set_string ( PREF_TIME_STATUSBAR , " off " ) ;
2015-03-10 19:35:08 -04:00
cons_show ( " Status bar time display disabled. " ) ;
ui_redraw ( ) ;
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-03-10 19:35:08 -04:00
return TRUE ;
}
2015-09-30 17:34:27 -04:00
} else if ( g_strcmp0 ( args [ 0 ] , " console " ) = = 0 ) {
2015-05-29 20:53:37 -04:00
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_CONSOLE ) ;
cons_show ( " Console time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-03-10 19:35:08 -04:00
return TRUE ;
2015-05-29 20:53:37 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
2015-09-30 17:34:27 -04:00
prefs_set_string ( PREF_TIME_CONSOLE , args [ 2 ] ) ;
cons_show ( " Console time format set to '%s'. " , args [ 2 ] ) ;
2015-03-10 19:35:08 -04:00
wins_resize_all ( ) ;
return TRUE ;
2015-05-29 20:53:37 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2015-09-30 17:34:27 -04:00
prefs_set_string ( PREF_TIME_CONSOLE , " off " ) ;
cons_show ( " Console time display disabled. " ) ;
wins_resize_all ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " chat " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_CHAT ) ;
cons_show ( " Chat time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-09-30 17:34:27 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_CHAT , args [ 2 ] ) ;
cons_show ( " Chat time format set to '%s'. " , args [ 2 ] ) ;
wins_resize_all ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_TIME_CHAT , " off " ) ;
cons_show ( " Chat time display disabled. " ) ;
wins_resize_all ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " muc " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_MUC ) ;
cons_show ( " MUC time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-09-30 17:34:27 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_MUC , args [ 2 ] ) ;
cons_show ( " MUC time format set to '%s'. " , args [ 2 ] ) ;
wins_resize_all ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_TIME_MUC , " off " ) ;
cons_show ( " MUC time display disabled. " ) ;
wins_resize_all ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2018-04-11 12:57:50 -04:00
} else if ( g_strcmp0 ( args [ 0 ] , " config " ) = = 0 ) {
2015-09-30 17:34:27 -04:00
if ( args [ 1 ] = = NULL ) {
2018-04-11 12:57:50 -04:00
char * format = prefs_get_string ( PREF_TIME_CONFIG ) ;
cons_show ( " config time format: '%s'. " , format ) ;
2015-11-21 16:19:28 -05:00
prefs_free_string ( format ) ;
2015-09-30 17:34:27 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
2018-04-11 12:57:50 -04:00
prefs_set_string ( PREF_TIME_CONFIG , args [ 2 ] ) ;
cons_show ( " config time format set to '%s'. " , args [ 2 ] ) ;
2015-09-30 17:34:27 -04:00
wins_resize_all ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2018-04-11 12:57:50 -04:00
prefs_set_string ( PREF_TIME_CONFIG , " off " ) ;
cons_show ( " config time display disabled. " ) ;
2015-09-30 17:34:27 -04:00
wins_resize_all ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " private " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_PRIVATE ) ;
cons_show ( " Private chat time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-09-30 17:34:27 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_PRIVATE , args [ 2 ] ) ;
cons_show ( " Private chat time format set to '%s'. " , args [ 2 ] ) ;
wins_resize_all ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_TIME_PRIVATE , " off " ) ;
cons_show ( " Private chat time display disabled. " ) ;
wins_resize_all ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
} else if ( g_strcmp0 ( args [ 0 ] , " xml " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
2015-11-21 16:19:28 -05:00
char * format = prefs_get_string ( PREF_TIME_XMLCONSOLE ) ;
cons_show ( " XML Console time format: '%s'. " , format ) ;
prefs_free_string ( format ) ;
2015-09-30 17:34:27 -04:00
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_XMLCONSOLE , args [ 2 ] ) ;
cons_show ( " XML Console time format set to '%s'. " , args [ 2 ] ) ;
wins_resize_all ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_TIME_XMLCONSOLE , " off " ) ;
cons_show ( " XML Console time display disabled. " ) ;
2015-03-10 19:35:08 -04:00
wins_resize_all ( ) ;
return TRUE ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-03-10 19:35:08 -04:00
return TRUE ;
}
2019-06-17 08:23:33 -04:00
} else if ( g_strcmp0 ( args [ 0 ] , " all " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_time_setting ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 & & args [ 2 ] ! = NULL ) {
prefs_set_string ( PREF_TIME_CONSOLE , args [ 2 ] ) ;
cons_show ( " Console time format set to '%s'. " , args [ 2 ] ) ;
prefs_set_string ( PREF_TIME_CHAT , args [ 2 ] ) ;
cons_show ( " Chat time format set to '%s'. " , args [ 2 ] ) ;
prefs_set_string ( PREF_TIME_MUC , args [ 2 ] ) ;
cons_show ( " MUC time format set to '%s'. " , args [ 2 ] ) ;
prefs_set_string ( PREF_TIME_CONFIG , args [ 2 ] ) ;
cons_show ( " config time format set to '%s'. " , args [ 2 ] ) ;
prefs_set_string ( PREF_TIME_PRIVATE , args [ 2 ] ) ;
cons_show ( " Private chat time format set to '%s'. " , args [ 2 ] ) ;
prefs_set_string ( PREF_TIME_XMLCONSOLE , args [ 2 ] ) ;
cons_show ( " XML Console time format set to '%s'. " , args [ 2 ] ) ;
wins_resize_all ( ) ;
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_TIME_CONSOLE , " off " ) ;
cons_show ( " Console time display disabled. " ) ;
prefs_set_string ( PREF_TIME_CHAT , " off " ) ;
cons_show ( " Chat time display disabled. " ) ;
prefs_set_string ( PREF_TIME_MUC , " off " ) ;
cons_show ( " MUC time display disabled. " ) ;
prefs_set_string ( PREF_TIME_CONFIG , " off " ) ;
cons_show ( " config time display disabled. " ) ;
prefs_set_string ( PREF_TIME_PRIVATE , " off " ) ;
cons_show ( " config time display disabled. " ) ;
prefs_set_string ( PREF_TIME_XMLCONSOLE , " off " ) ;
cons_show ( " XML Console time display disabled. " ) ;
ui_redraw ( ) ;
return TRUE ;
} else {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2015-05-29 20:53:37 -04:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-05-29 20:53:37 -04:00
return TRUE ;
2014-11-15 19:40:54 -05:00
}
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_states ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2019-07-22 07:47:52 -04:00
if ( args [ 0 ] = = NULL ) {
return FALSE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Sending chat states " , PREF_STATES ) ;
2013-12-15 11:10:32 -05:00
// if disabled, disable outtype and gone
2016-04-17 18:46:29 -04:00
if ( strcmp ( args [ 0 ] , " off " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
prefs_set_boolean ( PREF_OUTTYPE , FALSE ) ;
prefs_set_gone ( 0 ) ;
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2016-09-22 16:42:00 -04:00
cmd_wintitle ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2015-01-11 20:12:42 -05:00
if ( g_strcmp0 ( args [ 0 ] , " show " ) ! = 0 & & g_strcmp0 ( args [ 0 ] , " goodbye " ) ! = 0 ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-01-11 19:43:42 -05:00
return TRUE ;
}
2015-01-11 20:12:42 -05:00
if ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 & & g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2014-04-03 16:46:43 -04:00
ui_clear_win_title ( ) ;
2013-12-15 11:10:32 -05:00
}
2015-01-11 20:12:42 -05:00
if ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 ) {
2016-09-22 16:42:00 -04:00
_cmd_set_boolean_preference ( args [ 1 ] , command , " Window title show " , PREF_WINTITLE_SHOW ) ;
2015-01-11 20:12:42 -05:00
} else {
2016-09-22 16:42:00 -04:00
_cmd_set_boolean_preference ( args [ 1 ] , command , " Window title goodbye " , PREF_WINTITLE_GOODBYE ) ;
2015-01-11 20:12:42 -05:00
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_outtype ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2019-07-22 07:47:52 -04:00
if ( args [ 0 ] = = NULL ) {
return FALSE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Sending typing notifications " , PREF_OUTTYPE ) ;
2013-12-15 11:10:32 -05:00
// if enabled, enable states
2016-04-17 18:46:29 -04:00
if ( strcmp ( args [ 0 ] , " on " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
prefs_set_boolean ( PREF_STATES , TRUE ) ;
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_gone ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * value = args [ 0 ] ;
gint period = atoi ( value ) ;
prefs_set_gone ( period ) ;
if ( period = = 0 ) {
cons_show ( " Automatic leaving conversations after period disabled. " ) ;
} else if ( period = = 1 ) {
cons_show ( " Leaving conversations after 1 minute of inactivity. " ) ;
} else {
cons_show ( " Leaving conversations after %d minutes of inactivity. " , period ) ;
}
// if enabled, enable states
if ( period > 0 ) {
prefs_set_boolean ( PREF_STATES , TRUE ) ;
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_notify ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2015-11-27 19:15:53 -05:00
if ( ! args [ 0 ] ) {
ProfWin * current = wins_get_current ( ) ;
if ( current - > type = = WIN_MUC ) {
2016-10-15 13:29:02 -04:00
win_println ( current , THEME_DEFAULT , ' - ' , " " ) ;
2015-11-27 19:15:53 -05:00
ProfMucWin * mucwin = ( ProfMucWin * ) current ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Notification settings for %s: " , mucwin - > roomjid ) ;
2015-11-28 19:34:53 -05:00
if ( prefs_has_room_notify ( mucwin - > roomjid ) ) {
if ( prefs_get_room_notify ( mucwin - > roomjid ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Message : ON " ) ;
2015-11-28 19:34:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Message : OFF " ) ;
2015-11-28 19:34:53 -05:00
}
2015-11-27 19:15:53 -05:00
} else {
2015-11-28 19:34:53 -05:00
if ( prefs_get_boolean ( PREF_NOTIFY_ROOM ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Message : ON (global setting) " ) ;
2015-11-28 19:34:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Message : OFF (global setting) " ) ;
2015-11-27 19:15:53 -05:00
}
2015-11-28 19:34:53 -05:00
}
if ( prefs_has_room_notify_mention ( mucwin - > roomjid ) ) {
if ( prefs_get_room_notify_mention ( mucwin - > roomjid ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Mention : ON " ) ;
2015-11-28 19:34:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Mention : OFF " ) ;
2015-11-27 19:15:53 -05:00
}
2015-11-28 19:34:53 -05:00
} else {
if ( prefs_get_boolean ( PREF_NOTIFY_ROOM_MENTION ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Mention : ON (global setting) " ) ;
2015-11-28 19:34:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Mention : OFF (global setting) " ) ;
2015-11-28 19:34:53 -05:00
}
}
if ( prefs_has_room_notify_trigger ( mucwin - > roomjid ) ) {
if ( prefs_get_room_notify_trigger ( mucwin - > roomjid ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Triggers : ON " ) ;
2015-11-28 19:34:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Triggers : OFF " ) ;
2015-11-28 19:34:53 -05:00
}
} else {
if ( prefs_get_boolean ( PREF_NOTIFY_ROOM_TRIGGER ) ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Triggers : ON (global setting) " ) ;
2015-11-28 19:34:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Triggers : OFF (global setting) " ) ;
2015-11-27 19:15:53 -05:00
}
}
2016-10-15 13:29:02 -04:00
win_println ( current , THEME_DEFAULT , ' - ' , " " ) ;
2015-11-27 19:15:53 -05:00
} else {
2015-11-28 19:34:53 -05:00
cons_show ( " " ) ;
2015-11-27 19:15:53 -05:00
cons_notify_setting ( ) ;
2015-11-28 19:34:53 -05:00
cons_bad_cmd_usage ( command ) ;
2015-11-27 19:15:53 -05:00
}
return TRUE ;
}
2013-12-15 11:10:32 -05:00
2015-11-28 19:08:49 -05:00
// chat settings
2015-11-28 19:34:53 -05:00
if ( g_strcmp0 ( args [ 0 ] , " chat " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
2015-11-28 19:08:49 -05:00
cons_show ( " Chat notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_CHAT , TRUE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2015-11-28 19:08:49 -05:00
cons_show ( " Chat notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_CHAT , FALSE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " current " ) = = 0 ) {
2014-05-24 15:46:03 -04:00
if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
2015-11-28 19:08:49 -05:00
cons_show ( " Current window chat notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_CHAT_CURRENT , TRUE ) ;
2014-05-24 15:46:03 -04:00
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
2015-11-28 19:08:49 -05:00
cons_show ( " Current window chat notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_CHAT_CURRENT , FALSE ) ;
2014-05-24 15:46:03 -04:00
} else {
2015-11-28 19:08:49 -05:00
cons_show ( " Usage: /notify chat current on|off " ) ;
2014-05-24 15:46:03 -04:00
}
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " text " ) = = 0 ) {
2014-05-24 17:14:26 -04:00
if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
2015-11-28 19:08:49 -05:00
cons_show ( " Showing text in chat notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_CHAT_TEXT , TRUE ) ;
2014-05-24 17:14:26 -04:00
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
2015-11-28 19:08:49 -05:00
cons_show ( " Showing text in chat notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_CHAT_TEXT , FALSE ) ;
2014-05-24 17:14:26 -04:00
} else {
2015-11-28 19:08:49 -05:00
cons_show ( " Usage: /notify chat text on|off " ) ;
2014-05-24 17:14:26 -04:00
}
2013-12-15 11:10:32 -05:00
}
2015-11-27 19:15:53 -05:00
// chat room settings
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " room " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
2015-11-25 16:24:21 -05:00
cons_show ( " Room notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_ROOM , TRUE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2015-11-25 16:24:21 -05:00
cons_show ( " Room notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_ROOM , FALSE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " mention " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
2015-11-25 16:24:21 -05:00
cons_show ( " Room notifications with mention enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_ROOM_MENTION , TRUE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
2015-11-25 16:24:21 -05:00
cons_show ( " Room notifications with mention disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_ROOM_MENTION , FALSE ) ;
2016-04-06 20:01:27 -04:00
} else if ( g_strcmp0 ( args [ 2 ] , " case_sensitive " ) = = 0 ) {
cons_show ( " Room mention matching set to case sensitive. " ) ;
prefs_set_boolean ( PREF_NOTIFY_MENTION_CASE_SENSITIVE , TRUE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " case_insensitive " ) = = 0 ) {
cons_show ( " Room mention matching set to case insensitive. " ) ;
prefs_set_boolean ( PREF_NOTIFY_MENTION_CASE_SENSITIVE , FALSE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " word_whole " ) = = 0 ) {
cons_show ( " Room mention matching set to whole word. " ) ;
prefs_set_boolean ( PREF_NOTIFY_MENTION_WHOLE_WORD , TRUE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " word_part " ) = = 0 ) {
cons_show ( " Room mention matching set to partial word. " ) ;
prefs_set_boolean ( PREF_NOTIFY_MENTION_WHOLE_WORD , FALSE ) ;
2015-11-25 16:24:21 -05:00
} else {
cons_show ( " Usage: /notify room mention on|off " ) ;
}
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " current " ) = = 0 ) {
2014-05-24 15:46:03 -04:00
if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
2014-05-24 16:13:33 -04:00
cons_show ( " Current window chat room message notifications enabled. " ) ;
2014-05-24 15:46:03 -04:00
prefs_set_boolean ( PREF_NOTIFY_ROOM_CURRENT , TRUE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
2014-05-24 16:13:33 -04:00
cons_show ( " Current window chat room message notifications disabled. " ) ;
2014-05-24 15:46:03 -04:00
prefs_set_boolean ( PREF_NOTIFY_ROOM_CURRENT , FALSE ) ;
} else {
cons_show ( " Usage: /notify room current on|off " ) ;
}
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " text " ) = = 0 ) {
2014-05-24 17:14:26 -04:00
if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
cons_show ( " Showing text in chat room message notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_ROOM_TEXT , TRUE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
cons_show ( " Showing text in chat room message notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_ROOM_TEXT , FALSE ) ;
} else {
cons_show ( " Usage: /notify room text on|off " ) ;
}
2015-11-23 18:43:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " trigger " ) = = 0 ) {
if ( g_strcmp0 ( args [ 2 ] , " add " ) = = 0 ) {
if ( ! args [ 3 ] ) {
cons_bad_cmd_usage ( command ) ;
} else {
2015-11-23 19:38:33 -05:00
gboolean res = prefs_add_room_notify_trigger ( args [ 3 ] ) ;
if ( res ) {
cons_show ( " Adding room notification trigger: %s " , args [ 3 ] ) ;
} else {
cons_show ( " Room notification trigger already exists: %s " , args [ 3 ] ) ;
}
2015-11-23 18:43:53 -05:00
}
} else if ( g_strcmp0 ( args [ 2 ] , " remove " ) = = 0 ) {
if ( ! args [ 3 ] ) {
cons_bad_cmd_usage ( command ) ;
} else {
2015-11-23 19:38:33 -05:00
gboolean res = prefs_remove_room_notify_trigger ( args [ 3 ] ) ;
if ( res ) {
cons_show ( " Removing room notification trigger: %s " , args [ 3 ] ) ;
} else {
cons_show ( " Room notification trigger does not exist: %s " , args [ 3 ] ) ;
}
2015-11-23 18:43:53 -05:00
}
} else if ( g_strcmp0 ( args [ 2 ] , " list " ) = = 0 ) {
2015-11-23 19:38:33 -05:00
GList * triggers = prefs_get_room_notify_triggers ( ) ;
GList * curr = triggers ;
if ( curr ) {
cons_show ( " Room notification triggers: " ) ;
} else {
cons_show ( " No room notification triggers " ) ;
}
while ( curr ) {
cons_show ( " %s " , curr - > data ) ;
curr = g_list_next ( curr ) ;
}
g_list_free_full ( triggers , free ) ;
2015-11-23 18:43:53 -05:00
} else if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
2015-11-23 19:38:33 -05:00
cons_show ( " Enabling room notification triggers " ) ;
2015-11-23 18:43:53 -05:00
prefs_set_boolean ( PREF_NOTIFY_ROOM_TRIGGER , TRUE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
2015-11-23 19:38:33 -05:00
cons_show ( " Disabling room notification triggers " ) ;
2015-11-23 18:43:53 -05:00
prefs_set_boolean ( PREF_NOTIFY_ROOM_TRIGGER , FALSE ) ;
} else {
cons_bad_cmd_usage ( command ) ;
}
2014-05-24 10:54:10 -04:00
} else {
2014-05-24 11:46:05 -04:00
cons_show ( " Usage: /notify room on|off|mention " ) ;
2014-05-24 10:54:10 -04:00
}
2015-11-27 19:15:53 -05:00
// typing settings
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " typing " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Typing notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_TYPING , TRUE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Typing notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_TYPING , FALSE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " current " ) = = 0 ) {
2014-05-24 16:13:33 -04:00
if ( g_strcmp0 ( args [ 2 ] , " on " ) = = 0 ) {
cons_show ( " Current window typing notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_TYPING_CURRENT , TRUE ) ;
} else if ( g_strcmp0 ( args [ 2 ] , " off " ) = = 0 ) {
cons_show ( " Current window typing notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_TYPING_CURRENT , FALSE ) ;
} else {
cons_show ( " Usage: /notify typing current on|off " ) ;
}
2013-12-15 11:10:32 -05:00
} else {
cons_show ( " Usage: /notify typing on|off " ) ;
}
2015-11-27 19:15:53 -05:00
// invite settings
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " invite " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Chat room invite notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_INVITE , TRUE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Chat room invite notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_INVITE , FALSE ) ;
} else {
cons_show ( " Usage: /notify invite on|off " ) ;
}
2015-11-27 19:15:53 -05:00
// subscription settings
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " sub " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Subscription notifications enabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_SUB , TRUE ) ;
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Subscription notifications disabled. " ) ;
prefs_set_boolean ( PREF_NOTIFY_SUB , FALSE ) ;
} else {
cons_show ( " Usage: /notify sub on|off " ) ;
}
2015-11-27 19:15:53 -05:00
// remind settings
2015-11-28 19:34:53 -05:00
} else if ( g_strcmp0 ( args [ 0 ] , " remind " ) = = 0 ) {
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
} else {
2015-11-28 19:34:53 -05:00
gint period = atoi ( args [ 1 ] ) ;
prefs_set_notify_remind ( period ) ;
if ( period = = 0 ) {
cons_show ( " Message reminders disabled. " ) ;
} else if ( period = = 1 ) {
cons_show ( " Message reminder period set to 1 second. " ) ;
} else {
cons_show ( " Message reminder period set to %d seconds. " , period ) ;
}
2013-12-15 11:10:32 -05:00
}
2015-11-27 19:15:53 -05:00
// current chat room settings
} else if ( g_strcmp0 ( args [ 0 ] , " on " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-11-27 19:15:53 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2015-11-27 19:15:53 -05:00
} else {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat room. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
prefs_set_room_notify ( mucwin - > roomjid , TRUE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Notifications enabled for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
}
} else if ( g_strcmp0 ( args [ 0 ] , " off " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-11-27 19:15:53 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2015-11-27 19:15:53 -05:00
} else {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat room. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
prefs_set_room_notify ( mucwin - > roomjid , FALSE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Notifications disabled for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
}
} else if ( g_strcmp0 ( args [ 0 ] , " mention " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-11-27 19:15:53 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2015-11-27 19:15:53 -05:00
} else {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat room. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
prefs_set_room_notify_mention ( mucwin - > roomjid , TRUE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Mention notifications enabled for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat rooms. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
prefs_set_room_notify_mention ( mucwin - > roomjid , FALSE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Mention notifications disabled for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
} else {
cons_bad_cmd_usage ( command ) ;
}
}
} else if ( g_strcmp0 ( args [ 0 ] , " trigger " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-11-27 19:15:53 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2015-11-27 19:15:53 -05:00
} else {
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat room. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
prefs_set_room_notify_trigger ( mucwin - > roomjid , TRUE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Custom trigger notifications enabled for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat rooms. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
prefs_set_room_notify_trigger ( mucwin - > roomjid , FALSE ) ;
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Custom trigger notifications disabled for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
} else {
cons_bad_cmd_usage ( command ) ;
}
}
} else if ( g_strcmp0 ( args [ 0 ] , " reset " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-11-27 19:15:53 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2015-11-27 19:15:53 -05:00
} else {
ProfWin * window = wins_get_current ( ) ;
if ( window - > type ! = WIN_MUC ) {
cons_show ( " You must be in a chat room. " ) ;
} else {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
gboolean res = prefs_reset_room_notify ( mucwin - > roomjid ) ;
if ( res ) {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Notification settings set to global defaults for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
} else {
2016-10-15 13:29:02 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " No custom notification settings for %s " , mucwin - > roomjid ) ;
2015-11-27 19:15:53 -05:00
}
}
}
2013-12-15 11:10:32 -05:00
} else {
2015-11-27 19:15:53 -05:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
2014-12-21 13:15:29 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_inpblock ( ProfWin * window , const char * const command , gchar * * args )
2014-12-21 13:15:29 -05:00
{
2015-01-12 05:32:32 -05:00
char * subcmd = args [ 0 ] ;
char * value = args [ 1 ] ;
2015-01-12 18:41:15 -05:00
if ( g_strcmp0 ( subcmd , " timeout " ) = = 0 ) {
2015-01-12 05:32:32 -05:00
if ( value = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-01-12 05:32:32 -05:00
return TRUE ;
}
2015-03-15 21:03:20 -04:00
int intval = 0 ;
char * err_msg = NULL ;
2015-03-15 21:06:40 -04:00
gboolean res = strtoi_range ( value , & intval , 1 , 1000 , & err_msg ) ;
2015-03-15 21:03:20 -04:00
if ( res ) {
2015-01-12 05:32:32 -05:00
cons_show ( " Input blocking set to %d milliseconds. " , intval ) ;
prefs_set_inpblock ( intval ) ;
2015-11-01 13:56:34 -05:00
inp_nonblocking ( FALSE ) ;
2015-03-15 21:03:20 -04:00
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
2015-01-12 05:32:32 -05:00
}
return TRUE ;
2014-12-21 13:15:29 -05:00
}
2015-01-12 05:32:32 -05:00
2015-01-12 18:41:15 -05:00
if ( g_strcmp0 ( subcmd , " dynamic " ) = = 0 ) {
2015-01-12 05:32:32 -05:00
if ( value = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-01-12 05:32:32 -05:00
return TRUE ;
}
2015-01-12 18:41:15 -05:00
if ( g_strcmp0 ( value , " on " ) ! = 0 & & g_strcmp0 ( value , " off " ) ! = 0 ) {
2015-01-12 05:32:32 -05:00
cons_show ( " Dynamic must be one of 'on' or 'off' " ) ;
return TRUE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( value , command , " Dynamic input blocking " , PREF_INPBLOCK_DYNAMIC ) ;
return TRUE ;
2014-12-21 13:15:29 -05:00
}
2015-01-12 05:32:32 -05:00
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-01-12 05:32:32 -05:00
2016-09-19 18:40:45 -04:00
return TRUE ;
}
2016-09-22 19:56:53 -04:00
gboolean
cmd_titlebar ( ProfWin * window , const char * const command , gchar * * args )
{
if ( g_strcmp0 ( args [ 0 ] , " up " ) = = 0 ) {
gboolean result = prefs_titlebar_pos_up ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Title bar moved up. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move title bar up. " ) ;
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " down " ) = = 0 ) {
gboolean result = prefs_titlebar_pos_down ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Title bar moved down. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move title bar down. " ) ;
}
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
gboolean
cmd_mainwin ( ProfWin * window , const char * const command , gchar * * args )
{
if ( g_strcmp0 ( args [ 0 ] , " up " ) = = 0 ) {
gboolean result = prefs_mainwin_pos_up ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Main window moved up. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move main window up. " ) ;
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " down " ) = = 0 ) {
gboolean result = prefs_mainwin_pos_down ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Main window moved down. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move main window down. " ) ;
}
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
gboolean
cmd_statusbar ( ProfWin * window , const char * const command , gchar * * args )
{
2018-03-08 17:27:49 -05:00
if ( g_strcmp0 ( args [ 0 ] , " show " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " name " ) = = 0 ) {
prefs_set_boolean ( PREF_STATUSBAR_SHOW_NAME , TRUE ) ;
cons_show ( " Enabled showing tab names. " ) ;
ui_resize ( ) ;
return TRUE ;
}
2018-03-09 18:44:28 -05:00
if ( g_strcmp0 ( args [ 1 ] , " number " ) = = 0 ) {
prefs_set_boolean ( PREF_STATUSBAR_SHOW_NUMBER , TRUE ) ;
cons_show ( " Enabled showing tab numbers. " ) ;
ui_resize ( ) ;
return TRUE ;
}
2018-03-08 17:27:49 -05:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " hide " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " name " ) = = 0 ) {
2018-03-09 18:44:28 -05:00
if ( prefs_get_boolean ( PREF_STATUSBAR_SHOW_NUMBER ) = = FALSE ) {
cons_show ( " Cannot disable both names and numbers in statusbar. " ) ;
cons_show ( " Use '/statusbar maxtabs 0' to hide tabs. " ) ;
return TRUE ;
}
2018-03-08 17:27:49 -05:00
prefs_set_boolean ( PREF_STATUSBAR_SHOW_NAME , FALSE ) ;
cons_show ( " Disabled showing tab names. " ) ;
ui_resize ( ) ;
return TRUE ;
}
2018-03-09 18:44:28 -05:00
if ( g_strcmp0 ( args [ 1 ] , " number " ) = = 0 ) {
if ( prefs_get_boolean ( PREF_STATUSBAR_SHOW_NAME ) = = FALSE ) {
cons_show ( " Cannot disable both names and numbers in statusbar. " ) ;
cons_show ( " Use '/statusbar maxtabs 0' to hide tabs. " ) ;
return TRUE ;
}
prefs_set_boolean ( PREF_STATUSBAR_SHOW_NUMBER , FALSE ) ;
cons_show ( " Disabled showing tab numbers. " ) ;
ui_resize ( ) ;
return TRUE ;
}
2018-03-08 17:27:49 -05:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " maxtabs " ) = = 0 ) {
2018-03-08 18:11:49 -05:00
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * value = args [ 1 ] ;
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( value , & intval , 0 , INT_MAX , & err_msg ) ;
if ( res ) {
if ( intval < 0 | | intval > 10 ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2018-03-08 17:27:49 -05:00
2018-03-08 18:11:49 -05:00
prefs_set_statusbartabs ( intval ) ;
if ( intval = = 0 ) {
cons_show ( " Status bar tabs disabled. " ) ;
} else {
cons_show ( " Status bar tabs set to %d. " , intval ) ;
2018-03-10 20:18:46 -05:00
}
ui_resize ( ) ;
return TRUE ;
} else {
cons_show ( err_msg ) ;
cons_bad_cmd_usage ( command ) ;
free ( err_msg ) ;
return TRUE ;
}
}
if ( g_strcmp0 ( args [ 0 ] , " tablen " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
char * value = args [ 1 ] ;
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( value , & intval , 0 , INT_MAX , & err_msg ) ;
if ( res ) {
if ( intval < 0 ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
prefs_set_statusbartablen ( intval ) ;
if ( intval = = 0 ) {
cons_show ( " Maximum tab length disabled. " ) ;
} else {
cons_show ( " Maximum tab length set to %d. " , intval ) ;
2018-03-08 18:11:49 -05:00
}
2018-03-09 16:11:59 -05:00
ui_resize ( ) ;
2018-03-08 18:11:49 -05:00
return TRUE ;
} else {
cons_show ( err_msg ) ;
cons_bad_cmd_usage ( command ) ;
free ( err_msg ) ;
return TRUE ;
}
2018-03-08 17:27:49 -05:00
}
2018-03-10 17:16:52 -05:00
if ( g_strcmp0 ( args [ 0 ] , " self " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " barejid " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_SELF , " barejid " ) ;
cons_show ( " Using barejid for statusbar title. " ) ;
ui_resize ( ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 1 ] , " fulljid " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_SELF , " fulljid " ) ;
cons_show ( " Using fulljid for statusbar title. " ) ;
ui_resize ( ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 1 ] , " user " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_SELF , " user " ) ;
cons_show ( " Using user for statusbar title. " ) ;
ui_resize ( ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_SELF , " off " ) ;
cons_show ( " Disabling statusbar title. " ) ;
ui_resize ( ) ;
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2018-03-09 16:11:59 -05:00
if ( g_strcmp0 ( args [ 0 ] , " chat " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " jid " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_CHAT , " jid " ) ;
cons_show ( " Using jid for chat tabs. " ) ;
ui_resize ( ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 1 ] , " user " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_CHAT , " user " ) ;
cons_show ( " Using user for chat tabs. " ) ;
ui_resize ( ) ;
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " room " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " jid " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_ROOM , " jid " ) ;
cons_show ( " Using jid for room tabs. " ) ;
ui_resize ( ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 1 ] , " room " ) = = 0 ) {
prefs_set_string ( PREF_STATUSBAR_ROOM , " room " ) ;
cons_show ( " Using room name for room tabs. " ) ;
ui_resize ( ) ;
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-09-22 19:56:53 -04:00
if ( g_strcmp0 ( args [ 0 ] , " up " ) = = 0 ) {
gboolean result = prefs_statusbar_pos_up ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Status bar moved up " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move status bar up. " ) ;
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " down " ) = = 0 ) {
gboolean result = prefs_statusbar_pos_down ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Status bar moved down. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move status bar down. " ) ;
}
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-09-19 18:40:45 -04:00
gboolean
cmd_inputwin ( ProfWin * window , const char * const command , gchar * * args )
{
2016-09-22 19:56:53 -04:00
if ( g_strcmp0 ( args [ 0 ] , " up " ) = = 0 ) {
gboolean result = prefs_inputwin_pos_up ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Input window moved up. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move input window up. " ) ;
}
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " down " ) = = 0 ) {
gboolean result = prefs_inputwin_pos_down ( ) ;
if ( result ) {
ui_resize ( ) ;
2016-09-25 16:47:00 -04:00
cons_show ( " Input window moved down. " ) ;
2016-09-22 19:56:53 -04:00
} else {
cons_show ( " Could not move input window down. " ) ;
}
return TRUE ;
2016-09-19 18:40:45 -04:00
}
2016-09-22 19:56:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-12-21 13:15:29 -05:00
return TRUE ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_log ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * subcmd = args [ 0 ] ;
char * value = args [ 1 ] ;
if ( strcmp ( subcmd , " maxsize " ) = = 0 ) {
2014-04-13 17:20:15 -04:00
if ( value = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-04-13 17:20:15 -04:00
return TRUE ;
}
2015-03-15 21:03:20 -04:00
int intval = 0 ;
char * err_msg = NULL ;
2015-03-15 21:06:40 -04:00
gboolean res = strtoi_range ( value , & intval , PREFS_MIN_LOG_SIZE , INT_MAX , & err_msg ) ;
2015-03-15 21:03:20 -04:00
if ( res ) {
2013-12-15 11:10:32 -05:00
prefs_set_max_log_size ( intval ) ;
2016-03-07 08:06:10 -05:00
cons_show ( " Log maximum size set to %d bytes " , intval ) ;
2015-03-15 21:03:20 -04:00
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
2013-12-15 11:10:32 -05:00
}
2014-04-13 15:41:11 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2014-04-13 15:41:11 -04:00
if ( strcmp ( subcmd , " rotate " ) = = 0 ) {
if ( value = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-04-13 15:41:11 -04:00
return TRUE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( value , command , " Log rotate " , PREF_LOG_ROTATE ) ;
return TRUE ;
2014-04-13 15:41:11 -04:00
}
2014-04-13 16:56:35 -04:00
if ( strcmp ( subcmd , " shared " ) = = 0 ) {
if ( value = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-04-13 16:56:35 -04:00
return TRUE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( value , command , " Shared log " , PREF_LOG_SHARED ) ;
2014-04-13 17:20:15 -04:00
log_reinit ( ) ;
2016-04-17 18:46:29 -04:00
return TRUE ;
2014-04-13 17:20:15 -04:00
}
if ( strcmp ( subcmd , " where " ) = = 0 ) {
char * logfile = get_log_file_location ( ) ;
cons_show ( " Log file: %s " , logfile ) ;
return TRUE ;
2014-04-13 16:56:35 -04:00
}
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-04-13 15:41:11 -04:00
2013-12-15 11:10:32 -05:00
/* TODO: make 'level' subcommand for debug level */
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_reconnect ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * value = args [ 0 ] ;
2015-03-15 21:03:20 -04:00
int intval = 0 ;
char * err_msg = NULL ;
2015-03-15 21:06:40 -04:00
gboolean res = strtoi_range ( value , & intval , 0 , INT_MAX , & err_msg ) ;
2015-03-15 21:03:20 -04:00
if ( res ) {
2013-12-15 11:10:32 -05:00
prefs_set_reconnect ( intval ) ;
if ( intval = = 0 ) {
cons_show ( " Reconnect disabled. " , intval ) ;
} else {
cons_show ( " Reconnect interval set to %d seconds. " , intval ) ;
}
} else {
2015-03-15 21:03:20 -04:00
cons_show ( err_msg ) ;
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-03-15 21:03:20 -04:00
free ( err_msg ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_autoping ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-01-01 14:50:13 -05:00
char * cmd = args [ 0 ] ;
char * value = args [ 1 ] ;
2013-12-15 11:10:32 -05:00
2016-01-01 14:50:13 -05:00
if ( g_strcmp0 ( cmd , " set " ) = = 0 ) {
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( value , & intval , 0 , INT_MAX , & err_msg ) ;
if ( res ) {
prefs_set_autoping ( intval ) ;
iq_set_autoping ( intval ) ;
if ( intval = = 0 ) {
cons_show ( " Autoping disabled. " ) ;
} else {
cons_show ( " Autoping interval set to %d seconds. " , intval ) ;
}
2013-12-15 11:10:32 -05:00
} else {
2016-01-01 14:50:13 -05:00
cons_show ( err_msg ) ;
cons_bad_cmd_usage ( command ) ;
free ( err_msg ) ;
2013-12-15 11:10:32 -05:00
}
2016-01-01 14:50:13 -05:00
} else if ( g_strcmp0 ( cmd , " timeout " ) = = 0 ) {
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( value , & intval , 0 , INT_MAX , & err_msg ) ;
if ( res ) {
prefs_set_autoping_timeout ( intval ) ;
if ( intval = = 0 ) {
cons_show ( " Autoping timeout disabled. " ) ;
} else {
cons_show ( " Autoping timeout set to %d seconds. " , intval ) ;
}
} else {
cons_show ( err_msg ) ;
cons_bad_cmd_usage ( command ) ;
free ( err_msg ) ;
}
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
2014-09-03 20:08:10 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_ping ( ProfWin * window , const char * const command , gchar * * args )
2014-09-03 20:08:10 -04:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2014-09-03 20:08:10 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
2016-04-09 15:19:50 -04:00
cons_show ( " You are not currently connected. " ) ;
2014-09-03 20:08:10 -04:00
return TRUE ;
}
2017-06-15 18:27:30 -04:00
if ( args [ 0 ] = = NULL & & connection_supports ( XMPP_FEATURE_PING ) = = FALSE ) {
cons_show ( " Server does not support ping requests. " ) ;
return TRUE ;
}
2017-06-15 19:59:21 -04:00
if ( args [ 0 ] ! = NULL & & caps_jid_has_feature ( args [ 0 ] , XMPP_FEATURE_PING ) = = FALSE ) {
cons_show ( " %s does not support ping requests. " , args [ 0 ] ) ;
return TRUE ;
}
2014-09-03 20:08:10 -04:00
iq_send_ping ( args [ 0 ] ) ;
if ( args [ 0 ] = = NULL ) {
cons_show ( " Pinged server... " ) ;
} else {
cons_show ( " Pinged %s... " , args [ 0 ] ) ;
}
return TRUE ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_autoaway ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2015-09-27 18:08:30 -04:00
if ( ( strcmp ( args [ 0 ] , " mode " ) ! = 0 ) & & ( strcmp ( args [ 0 ] , " time " ) ! = 0 ) & &
( strcmp ( args [ 0 ] , " message " ) ! = 0 ) & & ( strcmp ( args [ 0 ] , " check " ) ! = 0 ) ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Setting must be one of 'mode', 'time', 'message' or 'check' " ) ;
return TRUE ;
}
2015-09-27 18:08:30 -04:00
if ( strcmp ( args [ 0 ] , " mode " ) = = 0 ) {
if ( ( strcmp ( args [ 1 ] , " idle " ) ! = 0 ) & & ( strcmp ( args [ 1 ] , " away " ) ! = 0 ) & &
( strcmp ( args [ 1 ] , " off " ) ! = 0 ) ) {
2013-12-15 11:10:32 -05:00
cons_show ( " Mode must be one of 'idle', 'away' or 'off' " ) ;
} else {
2015-09-27 18:08:30 -04:00
prefs_set_string ( PREF_AUTOAWAY_MODE , args [ 1 ] ) ;
cons_show ( " Auto away mode set to: %s. " , args [ 1 ] ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
2015-09-27 18:08:30 -04:00
if ( strcmp ( args [ 0 ] , " time " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " away " ) = = 0 ) {
int minutesval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( args [ 2 ] , & minutesval , 1 , INT_MAX , & err_msg ) ;
if ( res ) {
prefs_set_autoaway_time ( minutesval ) ;
if ( minutesval = = 1 ) {
cons_show ( " Auto away time set to: 1 minute. " ) ;
} else {
cons_show ( " Auto away time set to: %d minutes. " , minutesval ) ;
}
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " xa " ) = = 0 ) {
int minutesval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( args [ 2 ] , & minutesval , 0 , INT_MAX , & err_msg ) ;
if ( res ) {
int away_time = prefs_get_autoaway_time ( ) ;
if ( minutesval ! = 0 & & minutesval < = away_time ) {
cons_show ( " Auto xa time must be larger than auto away time. " ) ;
} else {
prefs_set_autoxa_time ( minutesval ) ;
if ( minutesval = = 0 ) {
cons_show ( " Auto xa time disabled. " ) ;
} else if ( minutesval = = 1 ) {
cons_show ( " Auto xa time set to: 1 minute. " ) ;
} else {
cons_show ( " Auto xa time set to: %d minutes. " , minutesval ) ;
}
}
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
return TRUE ;
2015-03-15 21:03:20 -04:00
} else {
2015-09-27 18:08:30 -04:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
}
2015-09-27 18:08:30 -04:00
if ( strcmp ( args [ 0 ] , " message " ) = = 0 ) {
if ( g_strcmp0 ( args [ 1 ] , " away " ) = = 0 ) {
if ( strcmp ( args [ 2 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_AUTOAWAY_MESSAGE , NULL ) ;
cons_show ( " Auto away message cleared. " ) ;
} else {
prefs_set_string ( PREF_AUTOAWAY_MESSAGE , args [ 2 ] ) ;
cons_show ( " Auto away message set to: \" %s \" . " , args [ 2 ] ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 1 ] , " xa " ) = = 0 ) {
if ( strcmp ( args [ 2 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_AUTOXA_MESSAGE , NULL ) ;
cons_show ( " Auto xa message cleared. " ) ;
} else {
prefs_set_string ( PREF_AUTOXA_MESSAGE , args [ 2 ] ) ;
cons_show ( " Auto xa message set to: \" %s \" . " , args [ 2 ] ) ;
}
return TRUE ;
2013-12-15 11:10:32 -05:00
} else {
2015-09-27 18:08:30 -04:00
cons_bad_cmd_usage ( command ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
}
2015-09-27 18:08:30 -04:00
if ( strcmp ( args [ 0 ] , " check " ) = = 0 ) {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 1 ] , command , " Online check " , PREF_AUTOAWAY_CHECK ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_priority ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
char * value = args [ 0 ] ;
2015-03-15 21:03:20 -04:00
int intval = 0 ;
char * err_msg = NULL ;
2015-03-15 21:06:40 -04:00
gboolean res = strtoi_range ( value , & intval , - 128 , 127 , & err_msg ) ;
2015-03-15 21:03:20 -04:00
if ( res ) {
2016-05-05 19:53:03 -04:00
accounts_set_priority_all ( session_get_account_name ( ) , intval ) ;
resource_presence_t last_presence = accounts_get_last_presence ( session_get_account_name ( ) ) ;
2017-01-15 18:59:31 -05:00
cl_ev_presence_send ( last_presence , 0 ) ;
2013-12-15 11:10:32 -05:00
cons_show ( " Priority set to %d. " , intval ) ;
2015-03-15 21:03:20 -04:00
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
2013-12-15 11:10:32 -05:00
}
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_vercheck ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
int num_args = g_strv_length ( args ) ;
if ( num_args = = 0 ) {
cons_check_version ( TRUE ) ;
return TRUE ;
} else {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Version checking " , PREF_VERCHECK ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
}
2014-04-15 08:16:32 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_xmlconsole ( ProfWin * window , const char * const command , gchar * * args )
2014-04-15 08:16:32 -04:00
{
2015-11-01 14:26:31 -05:00
ProfXMLWin * xmlwin = wins_get_xmlconsole ( ) ;
if ( xmlwin ) {
2015-11-02 15:59:36 -05:00
ui_focus_win ( ( ProfWin * ) xmlwin ) ;
2015-11-01 14:26:31 -05:00
} else {
2015-11-01 14:29:59 -05:00
ProfWin * window = wins_new_xmlconsole ( ) ;
2015-11-02 15:59:36 -05:00
ui_focus_win ( window ) ;
2014-04-15 08:16:32 -04:00
}
return TRUE ;
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_flash ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Screen flash " , PREF_FLASH ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2016-04-16 10:29:32 -04:00
gboolean
cmd_tray ( ProfWin * window , const char * const command , gchar * * args )
{
2016-04-17 18:17:43 -04:00
# ifdef HAVE_GTK
2016-05-14 20:41:34 -04:00
if ( g_strcmp0 ( args [ 0 ] , " timer " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2016-05-14 19:55:19 -04:00
if ( prefs_get_boolean ( PREF_TRAY ) = = FALSE ) {
2016-05-14 20:41:34 -04:00
cons_show ( " Tray icon not currently enabled, see /help tray " ) ;
return TRUE ;
}
int intval = 0 ;
char * err_msg = NULL ;
gboolean res = strtoi_range ( args [ 1 ] , & intval , 1 , 10 , & err_msg ) ;
if ( res ) {
2016-05-14 21:15:45 -04:00
if ( intval = = 1 ) {
cons_show ( " Tray timer set to 1 second. " ) ;
} else {
cons_show ( " Tray timer set to %d seconds. " , intval ) ;
}
2016-05-14 20:41:34 -04:00
prefs_set_tray_timer ( intval ) ;
if ( prefs_get_boolean ( PREF_TRAY ) ) {
tray_set_timer ( intval ) ;
}
} else {
cons_show ( err_msg ) ;
free ( err_msg ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 0 ] , " read " ) = = 0 ) {
if ( prefs_get_boolean ( PREF_TRAY ) = = FALSE ) {
cons_show ( " Tray icon not currently enabled, see /help tray " ) ;
2016-05-14 19:55:19 -04:00
} else if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
prefs_set_boolean ( PREF_TRAY_READ , TRUE ) ;
cons_show ( " Tray icon enabled when no unread messages. " ) ;
} else if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
prefs_set_boolean ( PREF_TRAY_READ , FALSE ) ;
cons_show ( " Tray icon disabled when no unread messages. " ) ;
2016-04-16 10:29:32 -04:00
} else {
2016-05-14 19:55:19 -04:00
cons_bad_cmd_usage ( command ) ;
}
2016-05-14 20:41:34 -04:00
return TRUE ;
2016-05-14 19:55:19 -04:00
} else {
gboolean old = prefs_get_boolean ( PREF_TRAY ) ;
_cmd_set_boolean_preference ( args [ 0 ] , command , " Tray icon " , PREF_TRAY ) ;
gboolean new = prefs_get_boolean ( PREF_TRAY ) ;
if ( old ! = new ) {
if ( new ) {
tray_enable ( ) ;
} else {
tray_disable ( ) ;
}
2016-04-16 10:29:32 -04:00
}
2016-05-14 20:41:34 -04:00
return TRUE ;
2016-04-16 10:29:32 -04:00
}
2016-04-17 18:17:43 -04:00
# else
cons_show ( " This version of Profanity has not been built with GTK Tray Icon support enabled " ) ;
return TRUE ;
2016-04-16 10:29:32 -04:00
# endif
2016-04-17 18:17:43 -04:00
}
2016-04-16 10:29:32 -04:00
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_intype ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Show contact typing " , PREF_INTYPE ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_splash ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Splash screen " , PREF_SPLASH ) ;
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_autoconnect ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
if ( strcmp ( args [ 0 ] , " off " ) = = 0 ) {
prefs_set_string ( PREF_CONNECT_ACCOUNT , NULL ) ;
cons_show ( " Autoconnect account disabled. " ) ;
} else if ( strcmp ( args [ 0 ] , " set " ) = = 0 ) {
2019-06-05 08:41:09 -04:00
if ( args [ 1 ] = = NULL | | strlen ( args [ 1 ] ) = = 0 ) {
cons_bad_cmd_usage ( command ) ;
2019-06-05 08:19:41 -04:00
} else {
2019-06-05 08:41:09 -04:00
if ( accounts_account_exists ( args [ 1 ] ) ) {
prefs_set_string ( PREF_CONNECT_ACCOUNT , args [ 1 ] ) ;
cons_show ( " Autoconnect account set to: %s. " , args [ 1 ] ) ;
} else {
cons_show_error ( " Account '%s' does not exist. " , args [ 1 ] ) ;
}
2019-06-05 08:19:41 -04:00
}
2013-12-15 11:10:32 -05:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
2019-06-05 08:19:41 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_chlog ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2019-07-22 07:47:52 -04:00
if ( args [ 0 ] = = NULL ) {
return FALSE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Chat logging " , PREF_CHLOG ) ;
2013-12-15 11:10:32 -05:00
// if set to off, disable history
2016-04-17 18:46:29 -04:00
if ( strcmp ( args [ 0 ] , " off " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
prefs_set_boolean ( PREF_HISTORY , FALSE ) ;
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_grlog ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Groupchat logging " , PREF_GRLOG ) ;
2013-12-15 11:10:32 -05:00
2016-04-17 18:46:29 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_history ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
2019-07-22 07:47:52 -04:00
if ( args [ 0 ] = = NULL ) {
return FALSE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Chat history " , PREF_HISTORY ) ;
2013-12-15 11:10:32 -05:00
// if set to on, set chlog
2016-04-17 18:46:29 -04:00
if ( strcmp ( args [ 0 ] , " on " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
prefs_set_boolean ( PREF_CHLOG , TRUE ) ;
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2013-12-15 11:10:32 -05:00
}
2015-02-02 05:10:05 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_carbons ( ProfWin * window , const char * const command , gchar * * args )
2015-02-02 05:10:05 -05:00
{
2019-07-22 07:47:52 -04:00
if ( args [ 0 ] = = NULL ) {
return FALSE ;
}
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Message carbons preference " , PREF_CARBONS ) ;
2015-02-02 05:10:05 -05:00
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-05-17 07:29:08 -04:00
if ( conn_status = = JABBER_CONNECTED ) {
// enable carbons
if ( strcmp ( args [ 0 ] , " on " ) = = 0 ) {
iq_enable_carbons ( ) ;
}
else if ( strcmp ( args [ 0 ] , " off " ) = = 0 ) {
iq_disable_carbons ( ) ;
}
2015-02-02 05:10:05 -05:00
}
2015-05-17 07:29:08 -04:00
2016-04-17 18:46:29 -04:00
return TRUE ;
2015-02-02 05:10:05 -05:00
}
2015-03-15 15:48:19 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_receipts ( ProfWin * window , const char * const command , gchar * * args )
2015-03-15 15:48:19 -04:00
{
2015-03-19 18:57:51 -04:00
if ( g_strcmp0 ( args [ 0 ] , " send " ) = = 0 ) {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 1 ] , command , " Send delivery receipts " , PREF_RECEIPTS_SEND ) ;
2016-08-17 19:10:15 -04:00
if ( g_strcmp0 ( args [ 1 ] , " on " ) = = 0 ) {
caps_add_feature ( XMPP_FEATURE_RECEIPTS ) ;
}
if ( g_strcmp0 ( args [ 1 ] , " off " ) = = 0 ) {
caps_remove_feature ( XMPP_FEATURE_RECEIPTS ) ;
}
2015-03-19 18:57:51 -04:00
} else if ( g_strcmp0 ( args [ 0 ] , " request " ) = = 0 ) {
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 1 ] , command , " Request delivery receipts " , PREF_RECEIPTS_REQUEST ) ;
2015-03-19 18:57:51 -04:00
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-03-19 18:57:51 -04:00
}
2016-04-17 18:46:29 -04:00
return TRUE ;
2015-03-15 15:48:19 -04:00
}
2013-12-15 11:10:32 -05:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_away ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
_update_presence ( RESOURCE_AWAY , " away " , args ) ;
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_online ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
_update_presence ( RESOURCE_ONLINE , " online " , args ) ;
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_dnd ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
_update_presence ( RESOURCE_DND , " dnd " , args ) ;
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_chat ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
_update_presence ( RESOURCE_CHAT , " chat " , args ) ;
return TRUE ;
}
gboolean
2015-10-24 19:31:42 -04:00
cmd_xa ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 11:10:32 -05:00
{
_update_presence ( RESOURCE_XA , " xa " , args ) ;
return TRUE ;
}
2016-02-14 17:28:55 -05:00
gboolean
2017-02-05 17:37:48 -05:00
cmd_plugins_sourcepath ( ProfWin * window , const char * const command , gchar * * args )
2016-02-14 17:28:55 -05:00
{
2017-02-05 17:37:48 -05:00
if ( args [ 1 ] = = NULL ) {
char * sourcepath = prefs_get_string ( PREF_PLUGINS_SOURCEPATH ) ;
if ( sourcepath ) {
cons_show ( " Current plugins sourcepath: %s " , sourcepath ) ;
prefs_free_string ( sourcepath ) ;
} else {
cons_show ( " Plugins sourcepath not currently set. " ) ;
}
2017-02-05 13:54:33 -05:00
return TRUE ;
}
2016-07-12 18:50:21 -04:00
2017-02-05 17:37:48 -05:00
if ( g_strcmp0 ( args [ 1 ] , " clear " ) = = 0 ) {
prefs_set_string ( PREF_PLUGINS_SOURCEPATH , NULL ) ;
cons_show ( " Plugins sourcepath cleared. " ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 1 ] , " set " ) = = 0 ) {
char * path = args [ 2 ] ;
if ( path = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
// expand ~ to $HOME
if ( path [ 0 ] = = ' ~ ' & & path [ 1 ] = = ' / ' ) {
if ( asprintf ( & path , " %s/%s " , getenv ( " HOME " ) , path + 2 ) = = - 1 ) {
return TRUE ;
}
} else {
path = strdup ( path ) ;
}
if ( ! is_dir ( path ) ) {
cons_show ( " Plugins sourcepath must be a directory. " ) ;
2019-07-22 09:12:02 -04:00
free ( path ) ;
2017-02-05 17:37:48 -05:00
return TRUE ;
}
cons_show ( " Setting plugins sourcepath: %s " , path ) ;
prefs_set_string ( PREF_PLUGINS_SOURCEPATH , path ) ;
2019-07-22 09:12:02 -04:00
free ( path ) ;
2017-02-05 17:37:48 -05:00
return TRUE ;
}
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
gboolean
cmd_plugins_install ( ProfWin * window , const char * const command , gchar * * args )
{
char * path = args [ 1 ] ;
if ( path = = NULL ) {
char * sourcepath = prefs_get_string ( PREF_PLUGINS_SOURCEPATH ) ;
if ( sourcepath ) {
path = strdup ( sourcepath ) ;
prefs_free_string ( sourcepath ) ;
} else {
cons_show ( " Either a path must be provided or the sourcepath property must be set, see /help plugins " ) ;
return TRUE ;
}
} else if ( path [ 0 ] = = ' ~ ' & & path [ 1 ] = = ' / ' ) {
2017-02-05 16:09:03 -05:00
if ( asprintf ( & path , " %s/%s " , getenv ( " HOME " ) , path + 2 ) = = - 1 ) {
2016-07-12 18:50:21 -04:00
return TRUE ;
}
2017-02-05 13:54:33 -05:00
} else {
2017-02-05 16:09:03 -05:00
path = strdup ( path ) ;
2017-02-05 13:54:33 -05:00
}
2016-07-12 18:50:21 -04:00
2017-02-05 16:09:03 -05:00
if ( is_regular_file ( path ) ) {
if ( ! g_str_has_suffix ( path , " .py " ) & & ! g_str_has_suffix ( path , " .so " ) ) {
cons_show ( " Plugins must have one of the following extensions: '.py' '.so' " ) ;
free ( path ) ;
return TRUE ;
}
2016-02-14 17:28:55 -05:00
2018-05-07 12:27:01 -04:00
GString * error_message = g_string_new ( NULL ) ;
2017-02-05 16:09:03 -05:00
gchar * plugin_name = g_path_get_basename ( path ) ;
2018-05-07 12:27:01 -04:00
gboolean result = plugins_install ( plugin_name , path , error_message ) ;
2017-02-05 16:09:03 -05:00
if ( result ) {
cons_show ( " Plugin installed: %s " , plugin_name ) ;
} else {
2018-05-07 12:27:01 -04:00
cons_show ( " Failed to install plugin: %s. %s " , plugin_name , error_message - > str ) ;
2017-02-05 16:09:03 -05:00
}
g_free ( plugin_name ) ;
2018-08-02 01:51:13 -04:00
g_string_free ( error_message , TRUE ) ;
2017-02-05 16:09:03 -05:00
free ( path ) ;
2016-06-30 18:14:05 -04:00
return TRUE ;
2019-02-26 08:17:59 -05:00
} else if ( is_dir ( path ) ) {
2017-02-05 16:09:03 -05:00
PluginsInstallResult * result = plugins_install_all ( path ) ;
if ( result - > installed | | result - > failed ) {
if ( result - > installed ) {
cons_show ( " " ) ;
cons_show ( " Installed plugins: " ) ;
GSList * curr = result - > installed ;
while ( curr ) {
cons_show ( " %s " , curr - > data ) ;
curr = g_slist_next ( curr ) ;
}
}
if ( result - > failed ) {
cons_show ( " " ) ;
cons_show ( " Failed installs: " ) ;
GSList * curr = result - > failed ;
while ( curr ) {
cons_show ( " %s " , curr - > data ) ;
curr = g_slist_next ( curr ) ;
}
}
} else {
cons_show ( " No plugins found in: %s " , path ) ;
}
free ( path ) ;
plugins_free_install_result ( result ) ;
return TRUE ;
2019-02-26 08:17:59 -05:00
} else {
cons_show ( " Argument must be a file or directory. " ) ;
2017-02-05 13:54:33 -05:00
}
2016-06-30 18:14:05 -04:00
2019-07-22 09:12:02 -04:00
free ( path ) ;
2017-02-05 13:54:33 -05:00
return TRUE ;
}
2018-05-07 14:29:34 -04:00
gboolean
2018-05-07 14:57:32 -04:00
cmd_plugins_update ( ProfWin * window , const char * const command , gchar * * args )
{
char * path = args [ 1 ] ;
if ( path = = NULL ) {
char * sourcepath = prefs_get_string ( PREF_PLUGINS_SOURCEPATH ) ;
if ( sourcepath ) {
path = strdup ( sourcepath ) ;
prefs_free_string ( sourcepath ) ;
} else {
cons_show ( " Either a path must be provided or the sourcepath property must be set, see /help plugins " ) ;
return TRUE ;
}
} else if ( path [ 0 ] = = ' ~ ' & & path [ 1 ] = = ' / ' ) {
if ( asprintf ( & path , " %s/%s " , getenv ( " HOME " ) , path + 2 ) = = - 1 ) {
return TRUE ;
}
} else {
path = strdup ( path ) ;
}
if ( access ( path , R_OK ) ! = 0 ) {
cons_show ( " File not found: %s " , path ) ;
free ( path ) ;
return TRUE ;
}
if ( is_regular_file ( path ) ) {
if ( ! g_str_has_suffix ( path , " .py " ) & & ! g_str_has_suffix ( path , " .so " ) ) {
cons_show ( " Plugins must have one of the following extensions: '.py' '.so' " ) ;
free ( path ) ;
return TRUE ;
}
GString * error_message = g_string_new ( NULL ) ;
gchar * plugin_name = g_path_get_basename ( path ) ;
2018-08-02 01:51:13 -04:00
if ( plugins_unload ( plugin_name ) ) {
if ( plugins_uninstall ( plugin_name ) ) {
if ( plugins_install ( plugin_name , path , error_message ) ) {
cons_show ( " Plugin installed: %s " , plugin_name ) ;
} else {
cons_show ( " Failed to install plugin: %s. %s " , plugin_name , error_message - > str ) ;
}
} else {
cons_show ( " Failed to uninstall plugin: %s. " , plugin_name ) ;
}
2018-05-07 14:57:32 -04:00
} else {
2018-08-02 01:51:13 -04:00
cons_show ( " Failed to unload plugin: %s. " , plugin_name ) ;
2018-05-07 14:57:32 -04:00
}
g_free ( plugin_name ) ;
2018-08-02 01:51:13 -04:00
g_string_free ( error_message , TRUE ) ;
2018-05-07 14:57:32 -04:00
free ( path ) ;
return TRUE ;
}
if ( is_dir ( path ) ) {
2018-08-02 01:51:13 -04:00
free ( path ) ;
2018-05-07 14:57:32 -04:00
return FALSE ;
}
2018-08-02 01:51:13 -04:00
free ( path ) ;
2018-05-07 14:57:32 -04:00
cons_show ( " Argument must be a file or directory. " ) ;
return TRUE ;
}
gboolean
2018-05-07 14:29:34 -04:00
cmd_plugins_uninstall ( ProfWin * window , const char * const command , gchar * * args )
{
if ( args [ 1 ] = = NULL ) {
return FALSE ;
}
gboolean res = plugins_uninstall ( args [ 1 ] ) ;
if ( res ) {
cons_show ( " Uninstalled plugin: %s " , args [ 1 ] ) ;
} else {
cons_show ( " Failed to uninstall plugin: %s " , args [ 1 ] ) ;
}
return TRUE ;
}
2017-02-05 13:54:33 -05:00
gboolean
cmd_plugins_load ( ProfWin * window , const char * const command , gchar * * args )
{
if ( args [ 1 ] = = NULL ) {
2017-02-05 14:16:14 -05:00
GSList * loaded = plugins_load_all ( ) ;
if ( loaded ) {
cons_show ( " Loaded plugins: " ) ;
GSList * curr = loaded ;
while ( curr ) {
cons_show ( " %s " , curr - > data ) ;
curr = g_slist_next ( curr ) ;
}
g_slist_free_full ( loaded , g_free ) ;
} else {
cons_show ( " No plugins loaded. " ) ;
}
2016-07-09 20:07:41 -04:00
return TRUE ;
2017-02-05 13:54:33 -05:00
}
2017-02-05 14:16:14 -05:00
2019-06-07 05:30:46 -04:00
GString * error_message = g_string_new ( NULL ) ;
gboolean res = plugins_load ( args [ 1 ] , error_message ) ;
2017-02-05 13:54:33 -05:00
if ( res ) {
cons_show ( " Loaded plugin: %s " , args [ 1 ] ) ;
} else {
2019-06-07 05:30:46 -04:00
cons_show ( " Failed to load plugin: %s. %s " , args [ 1 ] , error_message - > str ) ;
2017-02-05 13:54:33 -05:00
}
2019-06-07 05:30:46 -04:00
g_string_free ( error_message , TRUE ) ;
2016-07-09 20:07:41 -04:00
2017-02-05 13:54:33 -05:00
return TRUE ;
}
gboolean
cmd_plugins_unload ( ProfWin * window , const char * const command , gchar * * args )
{
if ( args [ 1 ] = = NULL ) {
2017-02-05 14:16:14 -05:00
gboolean res = plugins_unload_all ( ) ;
if ( res ) {
cons_show ( " Unloaded all plugins. " ) ;
} else {
cons_show ( " No plugins unloaded. " ) ;
}
2016-04-09 20:15:11 -04:00
return TRUE ;
2017-02-05 13:54:33 -05:00
}
gboolean res = plugins_unload ( args [ 1 ] ) ;
if ( res ) {
cons_show ( " Unloaded plugin: %s " , args [ 1 ] ) ;
} else {
cons_show ( " Failed to unload plugin: %s " , args [ 1 ] ) ;
}
return TRUE ;
}
gboolean
cmd_plugins_reload ( ProfWin * window , const char * const command , gchar * * args )
{
if ( args [ 1 ] = = NULL ) {
plugins_reload_all ( ) ;
cons_show ( " Reloaded all plugins " ) ;
2016-07-23 21:12:56 -04:00
return TRUE ;
2017-02-05 13:54:33 -05:00
}
2016-07-23 21:12:56 -04:00
2019-06-07 05:30:46 -04:00
GString * error_message = g_string_new ( NULL ) ;
gboolean res = plugins_reload ( args [ 1 ] , error_message ) ;
2017-02-05 13:54:33 -05:00
if ( res ) {
cons_show ( " Reloaded plugin: %s " , args [ 1 ] ) ;
2016-02-14 17:28:55 -05:00
} else {
2019-06-07 05:30:46 -04:00
cons_show ( " Failed to reload plugin: %s, %s " , args [ 1 ] , error_message ) ;
2017-02-05 13:54:33 -05:00
}
2019-06-07 05:30:46 -04:00
g_string_free ( error_message , TRUE ) ;
2016-06-30 18:58:04 -04:00
2017-02-05 13:54:33 -05:00
return TRUE ;
}
2016-04-09 20:15:11 -04:00
2017-02-05 13:54:33 -05:00
gboolean
cmd_plugins_python_version ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_PYTHON
2017-08-10 17:17:05 -04:00
const char * version = python_get_version_string ( ) ;
2017-02-05 13:54:33 -05:00
cons_show ( " Python version: " ) ;
cons_show ( " %s " , version ) ;
# else
2017-07-31 09:06:23 -04:00
cons_show ( " This build does not support python plugins. " ) ;
2017-02-05 13:54:33 -05:00
# endif
return TRUE ;
}
gboolean
cmd_plugins ( ProfWin * window , const char * const command , gchar * * args )
{
GList * plugins = plugins_loaded_list ( ) ;
if ( plugins = = NULL ) {
cons_show ( " No plugins installed. " ) ;
2016-04-09 20:15:11 -04:00
return TRUE ;
2016-02-14 17:28:55 -05:00
}
2017-02-05 13:54:33 -05:00
GList * curr = plugins ;
cons_show ( " Installed plugins: " ) ;
while ( curr ) {
cons_show ( " %s " , curr - > data ) ;
curr = g_list_next ( curr ) ;
}
g_list_free ( plugins ) ;
return TRUE ;
2016-02-14 17:28:55 -05:00
}
2015-03-21 20:12:14 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_pgp ( ProfWin * window , const char * const command , gchar * * args )
2015-03-21 20:12:14 -04:00
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBGPGME
2015-06-17 19:12:01 -04:00
if ( args [ 0 ] = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-06-17 19:12:01 -04:00
return TRUE ;
2015-06-20 18:49:24 -04:00
}
2015-08-25 20:24:53 -04:00
if ( strcmp ( args [ 0 ] , " char " ) = = 0 ) {
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
} else if ( strlen ( args [ 1 ] ) ! = 1 ) {
cons_bad_cmd_usage ( command ) ;
} else {
prefs_set_pgp_char ( args [ 1 ] [ 0 ] ) ;
cons_show ( " PGP char set to %c. " , args [ 1 ] [ 0 ] ) ;
}
return TRUE ;
} else if ( g_strcmp0 ( args [ 0 ] , " log " ) = = 0 ) {
2015-06-21 16:42:58 -04:00
char * choice = args [ 1 ] ;
if ( g_strcmp0 ( choice , " on " ) = = 0 ) {
prefs_set_string ( PREF_PGP_LOG , " on " ) ;
cons_show ( " PGP messages will be logged as plaintext. " ) ;
if ( ! prefs_get_boolean ( PREF_CHLOG ) ) {
cons_show ( " Chat logging is currently disabled, use '/chlog on' to enable. " ) ;
}
} else if ( g_strcmp0 ( choice , " off " ) = = 0 ) {
prefs_set_string ( PREF_PGP_LOG , " off " ) ;
cons_show ( " PGP message logging disabled. " ) ;
} else if ( g_strcmp0 ( choice , " redact " ) = = 0 ) {
prefs_set_string ( PREF_PGP_LOG , " redact " ) ;
cons_show ( " PGP messages will be logged as '[redacted]'. " ) ;
if ( ! prefs_get_boolean ( PREF_CHLOG ) ) {
cons_show ( " Chat logging is currently disabled, use '/chlog on' to enable. " ) ;
}
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-06-21 16:42:58 -04:00
}
return TRUE ;
}
2015-06-20 18:49:24 -04:00
if ( g_strcmp0 ( args [ 0 ] , " keys " ) = = 0 ) {
2015-08-24 19:21:49 -04:00
GHashTable * keys = p_gpg_list_keys ( ) ;
if ( ! keys | | g_hash_table_size ( keys ) = = 0 ) {
2015-03-21 21:03:06 -04:00
cons_show ( " No keys found " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
cons_show ( " PGP keys: " ) ;
2015-08-24 19:21:49 -04:00
GList * keylist = g_hash_table_get_keys ( keys ) ;
GList * curr = keylist ;
2015-06-20 18:49:24 -04:00
while ( curr ) {
2015-08-24 19:21:49 -04:00
ProfPGPKey * key = g_hash_table_lookup ( keys , curr - > data ) ;
2015-06-20 18:49:24 -04:00
cons_show ( " %s " , key - > name ) ;
cons_show ( " ID : %s " , key - > id ) ;
2015-08-29 21:12:05 -04:00
char * format_fp = p_gpg_format_fp_str ( key - > fp ) ;
cons_show ( " Fingerprint : %s " , format_fp ) ;
free ( format_fp ) ;
2015-08-24 19:21:49 -04:00
if ( key - > secret ) {
cons_show ( " Type : PUBLIC, PRIVATE " ) ;
} else {
cons_show ( " Type : PUBLIC " ) ;
}
curr = g_list_next ( curr ) ;
2015-03-21 20:12:14 -04:00
}
2015-08-24 19:21:49 -04:00
g_list_free ( keylist ) ;
p_gpg_free_keys ( keys ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
2015-06-23 18:29:10 -04:00
if ( g_strcmp0 ( args [ 0 ] , " setkey " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-06-23 18:29:10 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
char * jid = args [ 1 ] ;
if ( ! args [ 1 ] ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-06-23 18:29:10 -04:00
return TRUE ;
}
char * keyid = args [ 2 ] ;
if ( ! args [ 2 ] ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-06-23 18:29:10 -04:00
return TRUE ;
}
gboolean res = p_gpg_addkey ( jid , keyid ) ;
if ( ! res ) {
cons_show ( " Key ID not found. " ) ;
} else {
cons_show ( " Key %s set for %s. " , keyid , jid ) ;
}
return TRUE ;
}
2015-08-25 17:45:51 -04:00
if ( g_strcmp0 ( args [ 0 ] , " contacts " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-06-12 20:19:56 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
2015-08-25 17:45:51 -04:00
GHashTable * pubkeys = p_gpg_pubkeys ( ) ;
GList * jids = g_hash_table_get_keys ( pubkeys ) ;
2015-06-20 18:49:24 -04:00
if ( ! jids ) {
2015-08-25 17:45:51 -04:00
cons_show ( " No contacts found with PGP public keys assigned. " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
2015-08-25 17:45:51 -04:00
cons_show ( " Assigned PGP public keys: " ) ;
2015-06-20 18:49:24 -04:00
GList * curr = jids ;
while ( curr ) {
char * jid = curr - > data ;
2015-08-25 18:04:21 -04:00
ProfPGPPubKeyId * pubkeyid = g_hash_table_lookup ( pubkeys , jid ) ;
if ( pubkeyid - > received ) {
cons_show ( " %s: %s (received) " , jid , pubkeyid - > id ) ;
} else {
cons_show ( " %s: %s (stored) " , jid , pubkeyid - > id ) ;
}
2015-06-20 18:49:24 -04:00
curr = g_list_next ( curr ) ;
2015-03-23 20:47:13 -04:00
}
2015-06-20 18:49:24 -04:00
g_list_free ( jids ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " libver " ) = = 0 ) {
2015-03-21 20:29:57 -04:00
const char * libver = p_gpg_libver ( ) ;
2015-06-20 18:49:24 -04:00
if ( ! libver ) {
2015-03-21 20:29:57 -04:00
cons_show ( " Could not get libgpgme version " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
2015-03-21 20:29:57 -04:00
}
2015-06-20 18:49:24 -04:00
GString * fullstr = g_string_new ( " Using libgpgme version " ) ;
g_string_append ( fullstr , libver ) ;
cons_show ( " %s " , fullstr - > str ) ;
g_string_free ( fullstr , TRUE ) ;
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " start " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-06-17 20:34:27 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected to start PGP encrpytion. " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
if ( window - > type ! = WIN_CHAT & & args [ 1 ] = = NULL ) {
2015-06-17 20:34:27 -04:00
cons_show ( " You must be in a regular chat window to start PGP encrpytion. " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
ProfChatWin * chatwin = NULL ;
if ( args [ 1 ] ) {
char * contact = args [ 1 ] ;
char * barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
chatwin = wins_get_chat ( barejid ) ;
if ( ! chatwin ) {
2015-10-27 19:15:28 -04:00
chatwin = chatwin_new ( barejid ) ;
2015-06-20 18:49:24 -04:00
}
2015-11-02 15:59:36 -05:00
ui_focus_win ( ( ProfWin * ) chatwin ) ;
2015-06-20 18:49:24 -04:00
} else {
chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
}
2015-08-29 20:32:13 -04:00
if ( chatwin - > is_otr ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You must end the OTR session to start PGP encryption. " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
2015-08-29 20:32:13 -04:00
if ( chatwin - > pgp_send ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You have already started PGP encryption. " ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
2015-06-17 20:34:27 -04:00
}
2015-06-20 18:49:24 -04:00
2016-05-05 19:53:03 -04:00
ProfAccount * account = accounts_get_account ( session_get_account_name ( ) ) ;
2015-12-14 19:38:16 -05:00
char * err_str = NULL ;
if ( ! p_gpg_valid_key ( account - > pgp_keyid , & err_str ) ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Invalid PGP key ID %s: %s, cannot start PGP encryption. " , account - > pgp_keyid , err_str ) ;
2015-12-14 19:38:16 -05:00
free ( err_str ) ;
2015-06-20 18:49:24 -04:00
account_free ( account ) ;
return TRUE ;
}
2015-12-14 19:38:16 -05:00
free ( err_str ) ;
2015-06-20 18:49:24 -04:00
account_free ( account ) ;
if ( ! p_gpg_available ( chatwin - > barejid ) ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " No PGP key found for %s. " , chatwin - > barejid ) ;
2015-06-20 18:49:24 -04:00
return TRUE ;
}
2015-08-29 20:32:13 -04:00
chatwin - > pgp_send = TRUE ;
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " PGP encryption enabled. " ) ;
2015-06-21 15:20:28 -04:00
return TRUE ;
}
if ( g_strcmp0 ( args [ 0 ] , " end " ) = = 0 ) {
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2015-06-21 15:20:28 -04:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
if ( window - > type ! = WIN_CHAT ) {
cons_show ( " You must be in a regular chat window to end PGP encrpytion. " ) ;
return TRUE ;
}
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
2015-08-29 20:32:13 -04:00
if ( chatwin - > pgp_send = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " PGP encryption is not currently enabled. " ) ;
2015-06-21 15:20:28 -04:00
return TRUE ;
}
2015-08-29 20:32:13 -04:00
chatwin - > pgp_send = FALSE ;
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " PGP encryption disabled. " ) ;
2015-06-21 15:20:28 -04:00
return TRUE ;
2015-03-21 20:12:14 -04:00
}
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2015-03-21 20:12:14 -04:00
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with PGP support enabled " ) ;
return TRUE ;
# endif
}
2013-12-15 12:19:01 -05:00
gboolean
2016-04-26 15:29:45 -04:00
cmd_otr_char ( ProfWin * window , const char * const command , gchar * * args )
2013-12-15 12:19:01 -05:00
{
2016-03-31 16:05:02 -04:00
# ifdef HAVE_LIBOTR
2016-04-26 15:29:45 -04:00
if ( args [ 1 ] = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2016-04-26 15:29:45 -04:00
} else if ( strlen ( args [ 1 ] ) ! = 1 ) {
cons_bad_cmd_usage ( command ) ;
} else {
prefs_set_otr_char ( args [ 1 ] [ 0 ] ) ;
cons_show ( " OTR char set to %c. " , args [ 1 ] [ 0 ] ) ;
2014-02-15 19:04:53 -05:00
}
2016-04-26 15:29:45 -04:00
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2014-02-15 19:04:53 -05:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_log ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
char * choice = args [ 1 ] ;
if ( g_strcmp0 ( choice , " on " ) = = 0 ) {
prefs_set_string ( PREF_OTR_LOG , " on " ) ;
cons_show ( " OTR messages will be logged as plaintext. " ) ;
if ( ! prefs_get_boolean ( PREF_CHLOG ) ) {
cons_show ( " Chat logging is currently disabled, use '/chlog on' to enable. " ) ;
}
} else if ( g_strcmp0 ( choice , " off " ) = = 0 ) {
prefs_set_string ( PREF_OTR_LOG , " off " ) ;
cons_show ( " OTR message logging disabled. " ) ;
} else if ( g_strcmp0 ( choice , " redact " ) = = 0 ) {
prefs_set_string ( PREF_OTR_LOG , " redact " ) ;
cons_show ( " OTR messages will be logged as '[redacted]'. " ) ;
if ( ! prefs_get_boolean ( PREF_CHLOG ) ) {
cons_show ( " Chat logging is currently disabled, use '/chlog on' to enable. " ) ;
2014-01-13 15:17:45 -05:00
}
2016-04-26 15:29:45 -04:00
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
gboolean
cmd_otr_libver ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
char * version = otr_libotr_version ( ) ;
cons_show ( " Using libotr version %s " , version ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
gboolean
cmd_otr_policy ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
if ( args [ 1 ] = = NULL ) {
char * policy = prefs_get_string ( PREF_OTR_POLICY ) ;
cons_show ( " OTR policy is now set to: %s " , policy ) ;
prefs_free_string ( policy ) ;
2014-01-13 15:17:45 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
char * choice = args [ 1 ] ;
if ( ( g_strcmp0 ( choice , " manual " ) ! = 0 ) & &
( g_strcmp0 ( choice , " opportunistic " ) ! = 0 ) & &
( g_strcmp0 ( choice , " always " ) ! = 0 ) ) {
cons_show ( " OTR policy can be set to: manual, opportunistic or always. " ) ;
2014-02-11 18:19:09 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
char * contact = args [ 2 ] ;
if ( contact = = NULL ) {
prefs_set_string ( PREF_OTR_POLICY , choice ) ;
cons_show ( " OTR policy is now set to: %s " , choice ) ;
return TRUE ;
}
2014-04-22 18:53:15 -04:00
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected to set the OTR policy for a contact. " ) ;
return TRUE ;
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
char * contact_jid = roster_barejid_from_name ( contact ) ;
if ( contact_jid = = NULL ) {
contact_jid = contact ;
2014-01-13 15:17:45 -05:00
}
2016-05-05 19:53:03 -04:00
accounts_add_otr_policy ( session_get_account_name ( ) , contact_jid , choice ) ;
2016-04-26 15:29:45 -04:00
cons_show ( " OTR policy for %s set to: %s " , contact_jid , choice ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2014-01-13 15:17:45 -05:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_gen ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2014-01-10 15:20:38 -05:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
return TRUE ;
}
2016-05-05 19:53:03 -04:00
ProfAccount * account = accounts_get_account ( session_get_account_name ( ) ) ;
2016-04-26 15:29:45 -04:00
otr_keygen ( account ) ;
account_free ( account ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_myfp ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
2014-01-11 14:10:00 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
if ( ! otr_key_loaded ( ) ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a private key, use '/otr gen' " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
char * fingerprint = otr_get_my_fingerprint ( ) ;
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Your OTR fingerprint: %s " , fingerprint ) ;
2016-04-26 15:29:45 -04:00
free ( fingerprint ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_theirfp ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
2014-01-10 15:20:38 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to view a recipient's fingerprint. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2014-01-11 12:03:01 -05:00
2016-04-26 15:29:45 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2014-01-13 14:16:46 -05:00
2016-04-26 15:29:45 -04:00
char * fingerprint = otr_get_their_fingerprint ( chatwin - > barejid ) ;
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " %s's OTR fingerprint: %s " , chatwin - > barejid , fingerprint ) ;
2016-04-26 15:29:45 -04:00
free ( fingerprint ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2015-06-21 15:13:28 -04:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_start ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
// recipient supplied
if ( args [ 1 ] ) {
char * contact = args [ 1 ] ;
char * barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
ProfChatWin * chatwin = wins_get_chat ( barejid ) ;
if ( ! chatwin ) {
chatwin = chatwin_new ( barejid ) ;
}
ui_focus_win ( ( ProfWin * ) chatwin ) ;
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
if ( chatwin - > pgp_send ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You must disable PGP encryption before starting an OTR session. " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2015-06-15 18:16:22 -04:00
2019-02-22 13:16:12 -05:00
if ( chatwin - > is_omemo ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You must disable OMEMO before starting an OTR session. " ) ;
return TRUE ;
}
2016-04-26 15:29:45 -04:00
if ( chatwin - > is_otr ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are already in an OTR session. " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
2014-01-11 12:03:01 -05:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
if ( ! otr_key_loaded ( ) ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a private key, use '/otr gen' " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
}
2016-04-26 15:29:45 -04:00
if ( ! otr_is_secure ( barejid ) ) {
char * otr_query_message = otr_start_query ( ) ;
2016-08-18 17:51:06 -04:00
char * id = message_send_chat_otr ( barejid , otr_query_message , FALSE ) ;
2016-04-26 15:29:45 -04:00
free ( id ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
2014-01-11 18:59:20 -05:00
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
chatwin_otr_secured ( chatwin , otr_is_trusted ( barejid ) ) ;
2014-01-11 18:59:20 -05:00
return TRUE ;
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
// no recipient, use current chat
} else {
2015-06-16 19:15:28 -04:00
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to start an OTR session. " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
}
2015-06-17 14:49:55 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
2016-04-26 15:29:45 -04:00
if ( chatwin - > pgp_send ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You must disable PGP encryption before starting an OTR session. " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
2014-01-11 20:20:22 -05:00
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
if ( chatwin - > is_otr ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are already in an OTR session. " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
}
2016-04-26 15:29:45 -04:00
if ( ! otr_key_loaded ( ) ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a private key, use '/otr gen' " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
2014-01-11 20:20:22 -05:00
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
char * otr_query_message = otr_start_query ( ) ;
2016-08-18 17:51:06 -04:00
char * id = message_send_chat_otr ( chatwin - > barejid , otr_query_message , FALSE ) ;
2016-04-26 15:29:45 -04:00
free ( id ) ;
2014-01-11 20:20:22 -05:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_end ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to use OTR. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
chatwin_otr_unsecured ( chatwin ) ;
otr_end_session ( chatwin - > barejid ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_trust ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
2014-04-26 17:08:53 -04:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in an OTR session to trust a recipient. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
chatwin_otr_trust ( chatwin ) ;
otr_trust ( chatwin - > barejid ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
gboolean
cmd_otr_untrust ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
2015-06-15 18:16:22 -04:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in an OTR session to untrust a recipient. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
chatwin_otr_untrust ( chatwin ) ;
otr_untrust ( chatwin - > barejid ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
gboolean
cmd_otr_secret ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
return TRUE ;
}
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in an OTR session to trust a recipient. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
2015-06-15 18:16:22 -04:00
2016-04-26 15:29:45 -04:00
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2014-04-30 18:59:40 -04:00
return TRUE ;
2016-04-26 15:29:45 -04:00
}
2014-05-11 13:13:04 -04:00
2016-04-26 15:29:45 -04:00
char * secret = args [ 1 ] ;
if ( secret = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 12:19:01 -05:00
return TRUE ;
}
2016-04-26 15:29:45 -04:00
otr_smp_secret ( chatwin - > barejid , secret ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
gboolean
cmd_otr_question ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
return TRUE ;
}
char * question = args [ 1 ] ;
char * answer = args [ 2 ] ;
if ( question = = NULL | | answer = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in an OTR session to trust a recipient. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
otr_smp_question ( chatwin - > barejid , question , answer ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
return TRUE ;
# endif
}
gboolean
cmd_otr_answer ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_LIBOTR
2016-05-05 18:51:49 -04:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2016-04-26 15:29:45 -04:00
cons_show ( " You must be connected with an account to load OTR information. " ) ;
return TRUE ;
}
if ( window - > type ! = WIN_CHAT ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in an OTR session to trust a recipient. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( chatwin - > is_otr = = FALSE ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OTR session. " ) ;
2016-04-26 15:29:45 -04:00
return TRUE ;
}
char * answer = args [ 1 ] ;
if ( answer = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
otr_smp_answer ( chatwin - > barejid , answer ) ;
return TRUE ;
2013-12-15 12:19:01 -05:00
# else
2014-01-11 21:15:16 -05:00
cons_show ( " This version of Profanity has not been built with OTR support enabled " ) ;
2013-12-15 12:19:01 -05:00
return TRUE ;
# endif
}
2015-06-21 16:07:57 -04:00
gboolean
2015-10-24 19:31:42 -04:00
cmd_encwarn ( ProfWin * window , const char * const command , gchar * * args )
2015-06-21 16:07:57 -04:00
{
2016-04-17 18:46:29 -04:00
_cmd_set_boolean_preference ( args [ 0 ] , command , " Encryption warning message " , PREF_ENC_WARN ) ;
return TRUE ;
2015-06-21 16:07:57 -04:00
}
2018-03-21 13:00:11 -04:00
gboolean
2018-03-21 22:27:52 -04:00
cmd_command_list ( ProfWin * window , const char * const command , gchar * * args )
2018-03-21 13:00:11 -04:00
{
jabber_conn_status_t conn_status = connection_get_status ( ) ;
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
2018-03-21 22:27:52 -04:00
if ( connection_supports ( XMPP_FEATURE_COMMANDS ) = = FALSE ) {
2018-03-21 13:00:11 -04:00
cons_show ( " Server does not support ad hoc commands. " ) ;
return TRUE ;
}
2018-07-02 00:50:01 -04:00
char * jid = args [ 1 ] ;
if ( jid = = NULL ) {
2018-09-05 06:23:57 -04:00
switch ( window - > type ) {
case WIN_MUC :
{
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
jid = mucwin - > roomjid ;
break ;
}
case WIN_CHAT :
{
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
jid = chatwin - > barejid ;
break ;
}
case WIN_PRIVATE :
{
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
jid = privatewin - > fulljid ;
break ;
}
2018-09-05 08:37:26 -04:00
case WIN_CONSOLE :
{
jid = connection_get_domain ( ) ;
break ;
}
2018-09-05 06:23:57 -04:00
default :
cons_show ( " Cannot send ad hoc commands. " ) ;
return TRUE ;
}
2018-07-02 00:50:01 -04:00
}
2018-09-05 06:23:57 -04:00
2018-07-02 00:50:01 -04:00
iq_command_list ( jid ) ;
2018-03-21 22:27:52 -04:00
cons_show ( " List available ad hoc commands " ) ;
return TRUE ;
}
gboolean
cmd_command_exec ( ProfWin * window , const char * const command , gchar * * args )
{
jabber_conn_status_t conn_status = connection_get_status ( ) ;
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
return TRUE ;
}
if ( connection_supports ( XMPP_FEATURE_COMMANDS ) = = FALSE ) {
cons_show ( " Server does not support ad hoc commands. " ) ;
return TRUE ;
}
2019-07-12 04:36:17 -04:00
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
2018-07-02 00:50:01 -04:00
char * jid = args [ 2 ] ;
if ( jid = = NULL ) {
2018-09-05 06:23:57 -04:00
switch ( window - > type ) {
case WIN_MUC :
{
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
jid = mucwin - > roomjid ;
break ;
}
case WIN_CHAT :
{
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
jid = chatwin - > barejid ;
break ;
}
case WIN_PRIVATE :
{
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
jid = privatewin - > fulljid ;
break ;
}
2018-09-05 08:37:26 -04:00
case WIN_CONSOLE :
{
jid = connection_get_domain ( ) ;
break ;
}
2018-09-05 06:23:57 -04:00
default :
cons_show ( " Cannot send ad hoc commands. " ) ;
return TRUE ;
}
2018-07-02 00:50:01 -04:00
}
2018-03-21 22:27:52 -04:00
2018-07-02 00:50:01 -04:00
iq_command_exec ( jid , args [ 1 ] ) ;
2018-03-21 13:00:11 -04:00
2018-03-22 16:01:15 -04:00
cons_show ( " Execute %s... " , args [ 1 ] ) ;
2018-03-21 13:00:11 -04:00
return TRUE ;
}
2016-05-22 19:39:36 -04:00
static gboolean
_cmd_execute ( ProfWin * window , const char * const command , const char * const inp )
{
2018-04-11 12:57:50 -04:00
if ( g_str_has_prefix ( command , " /field " ) & & window - > type = = WIN_CONFIG ) {
2016-05-22 19:39:36 -04:00
gboolean result = FALSE ;
gchar * * args = parse_args_with_freetext ( inp , 1 , 2 , & result ) ;
if ( ! result ) {
2016-10-16 17:13:49 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " Invalid command, see /form help " ) ;
2016-05-22 19:39:36 -04:00
result = TRUE ;
} else {
gchar * * tokens = g_strsplit ( inp , " " , 2 ) ;
char * field = tokens [ 0 ] + 1 ;
result = cmd_form_field ( window , field , args ) ;
g_strfreev ( tokens ) ;
}
g_strfreev ( args ) ;
return result ;
}
Command * cmd = cmd_get ( command ) ;
gboolean result = FALSE ;
if ( cmd ) {
gchar * * args = cmd - > parser ( inp , cmd - > min_args , cmd - > max_args , & result ) ;
if ( result = = FALSE ) {
ui_invalid_command_usage ( cmd - > cmd , cmd - > setting_func ) ;
return TRUE ;
}
if ( args [ 0 ] & & cmd - > sub_funcs [ 0 ] [ 0 ] ) {
int i = 0 ;
while ( cmd - > sub_funcs [ i ] [ 0 ] ) {
if ( g_strcmp0 ( args [ 0 ] , ( char * ) cmd - > sub_funcs [ i ] [ 0 ] ) = = 0 ) {
gboolean ( * func ) ( ProfWin * window , const char * const command , gchar * * args ) = cmd - > sub_funcs [ i ] [ 1 ] ;
gboolean result = func ( window , command , args ) ;
g_strfreev ( args ) ;
return result ;
}
i + + ;
}
}
if ( ! cmd - > func ) {
ui_invalid_command_usage ( cmd - > cmd , cmd - > setting_func ) ;
return TRUE ;
}
gboolean result = cmd - > func ( window , command , args ) ;
g_strfreev ( args ) ;
return result ;
} else if ( plugins_run_command ( inp ) ) {
return TRUE ;
} else {
gboolean ran_alias = FALSE ;
gboolean alias_result = _cmd_execute_alias ( window , inp , & ran_alias ) ;
if ( ! ran_alias ) {
return _cmd_execute_default ( window , inp ) ;
} else {
return alias_result ;
}
}
}
static gboolean
_cmd_execute_default ( ProfWin * window , const char * inp )
{
// handle escaped commands - treat as normal message
if ( g_str_has_prefix ( inp , " // " ) ) {
inp + + ;
// handle unknown commands
} else if ( ( inp [ 0 ] = = ' / ' ) & & ( ! g_str_has_prefix ( inp , " /me " ) ) ) {
cons_show ( " Unknown command: %s " , inp ) ;
cons_alert ( ) ;
return TRUE ;
}
// handle non commands in non chat or plugin windows
if ( window - > type ! = WIN_CHAT & & window - > type ! = WIN_MUC & & window - > type ! = WIN_PRIVATE & & window - > type ! = WIN_PLUGIN & & window - > type ! = WIN_XML ) {
cons_show ( " Unknown command: %s " , inp ) ;
return TRUE ;
}
// handle plugin window
if ( window - > type = = WIN_PLUGIN ) {
ProfPluginWin * pluginwin = ( ProfPluginWin * ) window ;
plugins_win_process_line ( pluginwin - > tag , inp ) ;
return TRUE ;
}
jabber_conn_status_t status = connection_get_status ( ) ;
if ( status ! = JABBER_CONNECTED ) {
2016-10-16 16:45:48 -04:00
win_println ( window , THEME_DEFAULT , ' - ' , " You are not currently connected. " ) ;
2016-05-22 19:39:36 -04:00
return TRUE ;
}
switch ( window - > type ) {
case WIN_CHAT :
{
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
cl_ev_send_msg ( chatwin , inp , NULL ) ;
break ;
}
case WIN_PRIVATE :
{
ProfPrivateWin * privatewin = ( ProfPrivateWin * ) window ;
assert ( privatewin - > memcheck = = PROFPRIVATEWIN_MEMCHECK ) ;
cl_ev_send_priv_msg ( privatewin , inp , NULL ) ;
break ;
}
case WIN_MUC :
{
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
cl_ev_send_muc_msg ( mucwin , inp , NULL ) ;
break ;
}
case WIN_XML :
{
connection_send_stanza ( inp ) ;
break ;
}
default :
break ;
}
return TRUE ;
}
static gboolean
_cmd_execute_alias ( ProfWin * window , const char * const inp , gboolean * ran )
{
if ( inp [ 0 ] ! = ' / ' ) {
ran = FALSE ;
return TRUE ;
}
char * alias = strdup ( inp + 1 ) ;
char * value = prefs_get_alias ( alias ) ;
free ( alias ) ;
if ( value ) {
* ran = TRUE ;
gboolean result = cmd_process_input ( window , value ) ;
prefs_free_string ( value ) ;
return result ;
}
* ran = FALSE ;
return TRUE ;
}
2013-12-15 11:10:32 -05:00
// helper function for status change commands
static void
_update_presence ( const resource_presence_t resource_presence ,
2015-10-24 19:31:42 -04:00
const char * const show , gchar * * args )
2013-12-15 11:10:32 -05:00
{
char * msg = NULL ;
int num_args = g_strv_length ( args ) ;
if ( num_args = = 1 ) {
msg = args [ 0 ] ;
}
2016-05-05 18:51:49 -04:00
jabber_conn_status_t conn_status = connection_get_status ( ) ;
2013-12-15 11:10:32 -05:00
if ( conn_status ! = JABBER_CONNECTED ) {
cons_show ( " You are not currently connected. " ) ;
} else {
2017-01-15 18:59:31 -05:00
connection_set_presence_msg ( msg ) ;
cl_ev_presence_send ( resource_presence , 0 ) ;
2014-04-07 15:41:06 -04:00
ui_update_presence ( resource_presence , msg , show ) ;
2013-12-15 11:10:32 -05:00
}
}
// helper function for boolean preference commands
2016-04-17 18:46:29 -04:00
static void
2015-10-24 19:31:42 -04:00
_cmd_set_boolean_preference ( gchar * arg , const char * const command ,
const char * const display , preference_t pref )
2013-12-15 11:10:32 -05:00
{
GString * enabled = g_string_new ( display ) ;
g_string_append ( enabled , " enabled. " ) ;
GString * disabled = g_string_new ( display ) ;
g_string_append ( disabled , " disabled. " ) ;
2014-01-16 17:44:23 -05:00
if ( arg = = NULL ) {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2014-01-16 17:44:23 -05:00
} else if ( strcmp ( arg , " on " ) = = 0 ) {
2013-12-15 11:10:32 -05:00
cons_show ( enabled - > str ) ;
prefs_set_boolean ( pref , TRUE ) ;
} else if ( strcmp ( arg , " off " ) = = 0 ) {
cons_show ( disabled - > str ) ;
prefs_set_boolean ( pref , FALSE ) ;
} else {
2015-07-25 21:05:53 -04:00
cons_bad_cmd_usage ( command ) ;
2013-12-15 11:10:32 -05:00
}
g_string_free ( enabled , TRUE ) ;
g_string_free ( disabled , TRUE ) ;
}
2019-02-18 23:44:47 -05:00
gboolean
2019-02-19 13:23:50 -05:00
cmd_omemo_gen ( ProfWin * window , const char * const command , gchar * * args )
2019-02-18 23:44:47 -05:00
{
2019-02-19 13:23:50 -05:00
# ifdef HAVE_OMEMO
2019-02-18 23:44:47 -05:00
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
2019-02-22 13:16:26 -05:00
cons_show ( " You must be connected with an account to initialize OMEMO. " ) ;
return TRUE ;
}
if ( omemo_loaded ( ) ) {
cons_show ( " OMEMO crytographic materials have already been generated. " ) ;
2019-02-18 23:44:47 -05:00
return TRUE ;
}
2019-04-17 03:55:11 -04:00
cons_show ( " Generating OMEMO crytographic materials, it may take a while... " ) ;
2019-05-21 16:32:06 -04:00
ui_update ( ) ;
2019-02-18 23:44:47 -05:00
ProfAccount * account = accounts_get_account ( session_get_account_name ( ) ) ;
2019-02-19 13:23:50 -05:00
omemo_generate_crypto_materials ( account ) ;
2019-03-13 15:26:33 -04:00
cons_show ( " OMEMO crytographic materials generated. " ) ;
2019-02-18 23:44:47 -05:00
return TRUE ;
# else
2019-02-19 13:23:50 -05:00
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
2019-02-18 23:44:47 -05:00
return TRUE ;
# endif
}
2019-02-25 11:27:11 -05:00
gboolean
cmd_omemo_start ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected with an account to load OMEMO information. " ) ;
return TRUE ;
}
2019-03-13 14:10:43 -04:00
if ( ! omemo_loaded ( ) ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a cryptographic materials, use '/omemo gen' " ) ;
return TRUE ;
}
2019-06-07 15:11:11 -04:00
ProfChatWin * chatwin = NULL ;
2019-02-25 11:27:11 -05:00
// recipient supplied
if ( args [ 1 ] ) {
char * contact = args [ 1 ] ;
char * barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
2019-06-07 15:11:11 -04:00
chatwin = wins_get_chat ( barejid ) ;
2019-02-25 11:27:11 -05:00
if ( ! chatwin ) {
chatwin = chatwin_new ( barejid ) ;
}
ui_focus_win ( ( ProfWin * ) chatwin ) ;
2019-06-07 15:11:11 -04:00
} else {
if ( window - > type = = WIN_CHAT ) {
chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
}
}
2019-02-25 11:27:11 -05:00
2019-06-07 15:11:11 -04:00
if ( chatwin ) {
2019-02-25 11:27:11 -05:00
if ( chatwin - > pgp_send ) {
2019-06-07 14:37:12 -04:00
win_println ( ( ProfWin * ) chatwin , THEME_DEFAULT , ' ! ' , " You must disable PGP encryption before starting an OMEMO session. " ) ;
2019-02-25 11:27:11 -05:00
return TRUE ;
}
if ( chatwin - > is_otr ) {
2019-06-07 14:37:12 -04:00
win_println ( ( ProfWin * ) chatwin , THEME_DEFAULT , ' ! ' , " You must disable OTR encryption before starting an OMEMO session. " ) ;
2019-02-25 11:27:11 -05:00
return TRUE ;
}
if ( chatwin - > is_omemo ) {
2019-06-07 15:11:11 -04:00
win_println ( ( ProfWin * ) chatwin , THEME_DEFAULT , ' ! ' , " You are already in an OMEMO session. " ) ;
2019-02-25 11:27:11 -05:00
return TRUE ;
}
2019-06-07 15:11:11 -04:00
accounts_add_omemo_state ( session_get_account_name ( ) , chatwin - > barejid , TRUE ) ;
omemo_start_session ( chatwin - > barejid ) ;
2019-02-26 13:53:06 -05:00
chatwin - > is_omemo = TRUE ;
2019-06-07 15:11:11 -04:00
} else if ( window - > type = = WIN_MUC ) {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
2019-03-15 13:52:28 -04:00
2019-06-07 15:11:11 -04:00
if ( muc_anonymity_type ( mucwin - > roomjid ) = = MUC_ANONYMITY_TYPE_NONANONYMOUS ) {
accounts_add_omemo_state ( session_get_account_name ( ) , mucwin - > roomjid , TRUE ) ;
omemo_start_muc_sessions ( mucwin - > roomjid ) ;
mucwin - > is_omemo = TRUE ;
2019-03-15 01:48:21 -04:00
} else {
2019-06-07 15:11:11 -04:00
win_println ( window , THEME_DEFAULT , ' ! ' , " MUC must be non-anonymous (i.e. be configured to present real jid to anyone) in order to support OMEMO. " ) ;
2019-03-06 12:42:46 -05:00
}
2019-06-07 15:11:11 -04:00
} else {
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to start an OMEMO session. " ) ;
2019-02-25 11:27:11 -05:00
}
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-04-09 23:29:20 -04:00
gboolean
cmd_omemo_char ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( args [ 1 ] = = NULL ) {
cons_bad_cmd_usage ( command ) ;
} else if ( strlen ( args [ 1 ] ) ! = 1 ) {
cons_bad_cmd_usage ( command ) ;
} else {
prefs_set_omemo_char ( args [ 1 ] [ 0 ] ) ;
cons_show ( " OMEMO char set to %c. " , args [ 1 ] [ 0 ] ) ;
}
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-03-07 12:24:33 -05:00
2019-03-22 13:40:23 -04:00
gboolean
cmd_omemo_log ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
char * choice = args [ 1 ] ;
if ( g_strcmp0 ( choice , " on " ) = = 0 ) {
prefs_set_string ( PREF_OMEMO_LOG , " on " ) ;
cons_show ( " OMEMO messages will be logged as plaintext. " ) ;
if ( ! prefs_get_boolean ( PREF_CHLOG ) ) {
cons_show ( " Chat logging is currently disabled, use '/chlog on' to enable. " ) ;
}
} else if ( g_strcmp0 ( choice , " off " ) = = 0 ) {
prefs_set_string ( PREF_OMEMO_LOG , " off " ) ;
cons_show ( " OMEMO message logging disabled. " ) ;
} else if ( g_strcmp0 ( choice , " redact " ) = = 0 ) {
prefs_set_string ( PREF_OMEMO_LOG , " redact " ) ;
cons_show ( " OMEMO messages will be logged as '[redacted]'. " ) ;
if ( ! prefs_get_boolean ( PREF_CHLOG ) ) {
cons_show ( " Chat logging is currently disabled, use '/chlog on' to enable. " ) ;
}
} else {
cons_bad_cmd_usage ( command ) ;
}
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-03-19 12:10:20 -04:00
gboolean
cmd_omemo_end ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected with an account to load OMEMO information. " ) ;
return TRUE ;
}
if ( window - > type = = WIN_CHAT ) {
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
if ( ! chatwin - > is_omemo ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OMEMO session. " ) ;
return TRUE ;
}
chatwin - > is_omemo = FALSE ;
2019-04-15 16:09:47 -04:00
accounts_add_omemo_state ( session_get_account_name ( ) , chatwin - > barejid , FALSE ) ;
2019-03-19 12:10:20 -04:00
} else if ( window - > type = = WIN_MUC ) {
ProfMucWin * mucwin = ( ProfMucWin * ) window ;
assert ( mucwin - > memcheck = = PROFMUCWIN_MEMCHECK ) ;
if ( ! mucwin - > is_omemo ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You are not currently in an OMEMO session. " ) ;
return TRUE ;
}
mucwin - > is_omemo = FALSE ;
2019-04-15 16:09:47 -04:00
accounts_add_omemo_state ( session_get_account_name ( ) , mucwin - > roomjid , FALSE ) ;
2019-03-19 12:10:20 -04:00
} else {
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to start an OMEMO session. " ) ;
return TRUE ;
}
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-03-07 12:24:33 -05:00
gboolean
cmd_omemo_fingerprint ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected with an account to load OMEMO information. " ) ;
return TRUE ;
}
if ( ! omemo_loaded ( ) ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a cryptographic materials, use '/omemo gen' " ) ;
return TRUE ;
}
2019-03-25 12:50:46 -04:00
Jid * jid ;
if ( ! args [ 1 ] ) {
if ( window - > type = = WIN_CONSOLE ) {
char * fingerprint = omemo_own_fingerprint ( TRUE ) ;
cons_show ( " Your OMEMO fingerprint: %s " , fingerprint ) ;
free ( fingerprint ) ;
2019-03-26 17:24:26 -04:00
jid = jid_create ( connection_get_fulljid ( ) ) ;
2019-03-25 12:50:46 -04:00
} else if ( window - > type = = WIN_CHAT ) {
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
jid = jid_create ( chatwin - > barejid ) ;
} else {
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to print fingerprint without providing the contact. " ) ;
return TRUE ;
}
} else {
2019-04-10 11:43:12 -04:00
char * barejid = roster_barejid_from_name ( args [ 1 ] ) ;
if ( barejid ) {
jid = jid_create ( barejid ) ;
} else {
jid = jid_create ( args [ 1 ] ) ;
if ( ! jid ) {
cons_show ( " %s is not a valid jid " , args [ 1 ] ) ;
return TRUE ;
}
2019-03-25 12:50:46 -04:00
}
}
GList * fingerprints = omemo_known_device_identities ( jid - > barejid ) ;
GList * fingerprint ;
if ( ! fingerprints ) {
win_println ( window , THEME_DEFAULT , ' - ' , " There is no known fingerprints for %s " , jid - > barejid ) ;
return TRUE ;
}
for ( fingerprint = fingerprints ; fingerprint ! = NULL ; fingerprint = fingerprint - > next ) {
char * formatted_fingerprint = omemo_format_fingerprint ( fingerprint - > data ) ;
gboolean trusted = omemo_is_trusted_identity ( jid - > barejid , fingerprint - > data ) ;
win_println ( window , THEME_DEFAULT , ' - ' , " %s's OMEMO fingerprint: %s%s " , jid - > barejid , formatted_fingerprint , trusted ? " (trusted) " : " " ) ;
free ( formatted_fingerprint ) ;
}
g_list_free ( fingerprints ) ;
win_println ( window , THEME_DEFAULT , ' - ' , " You can trust it with '/omemo trust <fingerprint>' " ) ;
win_println ( window , THEME_DEFAULT , ' - ' , " You can untrust it with '/omemo untrust <fingerprint>' " ) ;
2019-03-07 13:05:11 -05:00
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
gboolean
cmd_omemo_trust ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected with an account to load OMEMO information. " ) ;
return TRUE ;
}
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( ! omemo_loaded ( ) ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a cryptographic materials, use '/omemo gen' " ) ;
return TRUE ;
}
char * fingerprint ;
char * barejid ;
/* Contact not provided */
if ( ! args [ 2 ] ) {
fingerprint = args [ 1 ] ;
if ( window - > type ! = WIN_CHAT ) {
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to trust a device without providing the contact. " ) ;
return TRUE ;
}
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
barejid = chatwin - > barejid ;
} else {
2019-03-13 12:24:45 -04:00
fingerprint = args [ 2 ] ;
char * contact = args [ 1 ] ;
2019-03-07 13:05:11 -05:00
barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
}
omemo_trust ( barejid , fingerprint ) ;
2019-03-07 12:24:33 -05:00
2019-03-26 12:10:46 -04:00
char * unformatted_fingerprint = malloc ( strlen ( fingerprint ) ) ;
int i ;
int j ;
for ( i = 0 , j = 0 ; fingerprint [ i ] ! = ' \0 ' ; i + + ) {
if ( ! g_ascii_isxdigit ( fingerprint [ i ] ) ) {
continue ;
}
unformatted_fingerprint [ j + + ] = fingerprint [ i ] ;
}
unformatted_fingerprint [ j ] = ' \0 ' ;
gboolean trusted = omemo_is_trusted_identity ( barejid , unformatted_fingerprint ) ;
win_println ( window , THEME_DEFAULT , ' - ' , " %s's OMEMO fingerprint: %s%s " , barejid , fingerprint , trusted ? " (trusted) " : " " ) ;
free ( unformatted_fingerprint ) ;
2019-03-07 12:24:33 -05:00
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-03-13 14:03:07 -04:00
gboolean
cmd_omemo_untrust ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected with an account to load OMEMO information. " ) ;
return TRUE ;
}
if ( ! args [ 1 ] ) {
cons_bad_cmd_usage ( command ) ;
return TRUE ;
}
if ( ! omemo_loaded ( ) ) {
win_println ( window , THEME_DEFAULT , ' ! ' , " You have not generated or loaded a cryptographic materials, use '/omemo gen' " ) ;
return TRUE ;
}
char * fingerprint ;
char * barejid ;
/* Contact not provided */
if ( ! args [ 2 ] ) {
fingerprint = args [ 1 ] ;
if ( window - > type ! = WIN_CHAT ) {
win_println ( window , THEME_DEFAULT , ' - ' , " You must be in a regular chat window to trust a device without providing the contact. " ) ;
return TRUE ;
}
ProfChatWin * chatwin = ( ProfChatWin * ) window ;
assert ( chatwin - > memcheck = = PROFCHATWIN_MEMCHECK ) ;
barejid = chatwin - > barejid ;
} else {
fingerprint = args [ 2 ] ;
char * contact = args [ 1 ] ;
barejid = roster_barejid_from_name ( contact ) ;
if ( barejid = = NULL ) {
barejid = contact ;
}
}
omemo_untrust ( barejid , fingerprint ) ;
2019-03-26 12:10:46 -04:00
char * unformatted_fingerprint = malloc ( strlen ( fingerprint ) ) ;
int i ;
int j ;
for ( i = 0 , j = 0 ; fingerprint [ i ] ! = ' \0 ' ; i + + ) {
if ( ! g_ascii_isxdigit ( fingerprint [ i ] ) ) {
continue ;
}
unformatted_fingerprint [ j + + ] = fingerprint [ i ] ;
}
unformatted_fingerprint [ j ] = ' \0 ' ;
gboolean trusted = omemo_is_trusted_identity ( barejid , unformatted_fingerprint ) ;
win_println ( window , THEME_DEFAULT , ' - ' , " %s's OMEMO fingerprint: %s%s " , barejid , fingerprint , trusted ? " (trusted) " : " " ) ;
free ( unformatted_fingerprint ) ;
2019-03-13 14:03:07 -04:00
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-04-01 07:14:46 -04:00
gboolean
cmd_omemo_clear_device_list ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( connection_get_status ( ) ! = JABBER_CONNECTED ) {
cons_show ( " You must be connected with an account to initialize OMEMO. " ) ;
return TRUE ;
}
omemo_devicelist_publish ( NULL ) ;
cons_show ( " Cleared OMEMO device list " ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-04-15 16:09:47 -04:00
gboolean
cmd_omemo_policy ( ProfWin * window , const char * const command , gchar * * args )
{
# ifdef HAVE_OMEMO
if ( args [ 1 ] = = NULL ) {
char * policy = prefs_get_string ( PREF_OMEMO_POLICY ) ;
cons_show ( " OMEMO policy is now set to: %s " , policy ) ;
prefs_free_string ( policy ) ;
return TRUE ;
}
char * choice = args [ 1 ] ;
if ( ( g_strcmp0 ( choice , " manual " ) ! = 0 ) & &
( g_strcmp0 ( choice , " automatic " ) ! = 0 ) & &
( g_strcmp0 ( choice , " always " ) ! = 0 ) ) {
cons_show ( " OMEMO policy can be set to: manual, automatic or always. " ) ;
return TRUE ;
}
prefs_set_string ( PREF_OMEMO_POLICY , choice ) ;
cons_show ( " OMEMO policy is now set to: %s " , choice ) ;
return TRUE ;
# else
cons_show ( " This version of Profanity has not been built with OMEMO support enabled " ) ;
return TRUE ;
# endif
}
2019-08-02 04:23:13 -04:00
gboolean
cmd_save ( ProfWin * window , const char * const command , gchar * * args )
{
log_info ( " Saving preferences to configuration file " ) ;
cons_show ( " Saving preferences. " ) ;
prefs_save ( ) ;
return TRUE ;
}
2019-10-04 08:06:25 -04:00
gboolean
cmd_reload ( ProfWin * window , const char * const command , gchar * * args )
{
log_info ( " Reloading preferences " ) ;
cons_show ( " Reloading preferences. " ) ;
prefs_reload ( ) ;
return TRUE ;
}