int command_silc_connect(void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) {
char *servername;
struct t_gui_buffer *server_buffer;
SilcPluginServerList server;
if (argc < 3) {
weechat_printf(buffer, "you need to specify a servername to connect to");
return WEECHAT_RC_ERROR;
}
servername = argv[2];
// create a new buffer for this connection but merge it into the main window
server_buffer = weechat_buffer_new(servername, NULL, NULL, NULL, NULL);
weechat_printf(server_buffer, "SILC: trying to connect to %s", servername);
weechat_buffer_merge(server_buffer, weechat_buffer_search_main());
if (!silc_client_connect_to_server(silc_plugin->client, NULL, silc_plugin->public_key, silc_plugin->private_key,
servername, 706, silc_plugin_connected, server_buffer)) {
weechat_printf(server_buffer, "%sSILC: connection to server failed", weechat_prefix("error"));
weechat_buffer_close(server_buffer);
}
server = add_server(servername, NULL, NULL, server_buffer);
return WEECHAT_RC_OK;
}
struct t_gui_buffer *
exec_buffer_new (const char *name, int switch_to_buffer)
{
struct t_gui_buffer *new_buffer;
new_buffer = weechat_buffer_search (EXEC_PLUGIN_NAME, name);
if (new_buffer)
goto end;
new_buffer = weechat_buffer_new (name,
&exec_buffer_input_cb, NULL,
&exec_buffer_close_cb, NULL);
/* failed to create buffer ? then return */
if (!new_buffer)
return NULL;
weechat_buffer_set (new_buffer, "title", _("Executed commands"));
weechat_buffer_set (new_buffer, "localvar_set_type", "exec");
weechat_buffer_set (new_buffer, "localvar_set_no_log", "1");
weechat_buffer_set (new_buffer, "time_for_each_line", "0");
weechat_buffer_set (new_buffer, "input_get_unknown_commands", "0");
end:
if (switch_to_buffer)
weechat_buffer_set (new_buffer, "display", "1");
return new_buffer;
}
void
xfer_chat_open_buffer (struct t_xfer *xfer)
{
char *name;
int length, buffer_created;
buffer_created = 0;
length = strlen (xfer->plugin_name) + 8 + strlen (xfer->plugin_id) + 1
+ strlen (xfer->remote_nick) + 1;
name = malloc (length);
if (name)
{
snprintf (name, length, "%s_dcc.%s.%s",
xfer->plugin_name, xfer->plugin_id, xfer->remote_nick);
xfer->buffer = weechat_buffer_search (XFER_PLUGIN_NAME, name);
if (!xfer->buffer)
{
xfer->buffer = weechat_buffer_new (name,
&xfer_chat_buffer_input_cb, NULL,
&xfer_chat_buffer_close_cb, NULL);
buffer_created = 1;
/* failed to create buffer ? then return */
if (!xfer->buffer)
return;
}
if (buffer_created)
{
weechat_buffer_set (xfer->buffer, "title", _("xfer chat"));
if (!weechat_buffer_get_integer (xfer->buffer, "short_name_is_set"))
{
weechat_buffer_set (xfer->buffer, "short_name",
xfer->remote_nick);
}
weechat_buffer_set (xfer->buffer, "localvar_set_type", "private");
weechat_buffer_set (xfer->buffer, "localvar_set_nick", xfer->local_nick);
weechat_buffer_set (xfer->buffer, "localvar_set_channel", xfer->remote_nick);
weechat_buffer_set (xfer->buffer, "highlight_words_add", "$nick");
}
weechat_printf (xfer->buffer,
_("%s%s: connected to %s (%s) via xfer chat"),
weechat_prefix ("network"),
XFER_PLUGIN_NAME,
xfer->remote_nick,
xfer->remote_address_str);
free (name);
}
}
void
irc_raw_open (int switch_to_buffer)
{
struct t_irc_raw_message *ptr_raw_message;
if (!irc_raw_buffer)
{
irc_raw_buffer = weechat_buffer_search (IRC_PLUGIN_NAME,
IRC_RAW_BUFFER_NAME);
if (!irc_raw_buffer)
{
irc_raw_buffer = weechat_buffer_new (IRC_RAW_BUFFER_NAME,
NULL, NULL,
&irc_buffer_close_cb, NULL);
/* failed to create buffer ? then return */
if (!irc_raw_buffer)
return;
weechat_buffer_set (irc_raw_buffer,
"title", _("IRC raw messages"));
weechat_buffer_set (irc_raw_buffer, "short_name", IRC_RAW_BUFFER_NAME);
weechat_buffer_set (irc_raw_buffer, "localvar_set_type", "debug");
weechat_buffer_set (irc_raw_buffer, "localvar_set_server", IRC_RAW_BUFFER_NAME);
weechat_buffer_set (irc_raw_buffer, "localvar_set_channel", IRC_RAW_BUFFER_NAME);
weechat_buffer_set (irc_raw_buffer, "localvar_set_no_log", "1");
/* disable all highlights on this debug buffer */
weechat_buffer_set (irc_raw_buffer, "highlight_words", "-");
if (switch_to_buffer)
weechat_buffer_set (irc_raw_buffer, "display", "1");
/* print messages in list */
for (ptr_raw_message = irc_raw_messages; ptr_raw_message;
ptr_raw_message = ptr_raw_message->next_message)
{
irc_raw_message_print (ptr_raw_message);
}
}
}
else
{
if (switch_to_buffer)
weechat_buffer_set (irc_raw_buffer, "display", "1");
}
}
struct t_gui_buffer *
exec_buffer_new (const char *name, int free_content, int clear_buffer,
int switch_to_buffer)
{
struct t_gui_buffer *new_buffer;
int buffer_type;
new_buffer = weechat_buffer_search (EXEC_PLUGIN_NAME, name);
if (new_buffer)
{
buffer_type = weechat_buffer_get_integer (new_buffer, "type");
if (((buffer_type == 0) && free_content)
|| ((buffer_type == 1) && !free_content))
{
/* change the type of buffer */
weechat_buffer_set (new_buffer,
"type",
(free_content) ? "free" : "formatted");
}
goto end;
}
new_buffer = weechat_buffer_new (name,
&exec_buffer_input_cb, NULL, NULL,
&exec_buffer_close_cb, NULL, NULL);
/* failed to create buffer ? then return */
if (!new_buffer)
return NULL;
if (free_content)
weechat_buffer_set (new_buffer, "type", "free");
weechat_buffer_set (new_buffer, "clear", "1");
weechat_buffer_set (new_buffer, "title", _("Executed commands"));
weechat_buffer_set (new_buffer, "localvar_set_type", "exec");
weechat_buffer_set (new_buffer, "localvar_set_no_log", "1");
weechat_buffer_set (new_buffer, "time_for_each_line", "0");
weechat_buffer_set (new_buffer, "input_get_unknown_commands", "0");
end:
if (clear_buffer)
weechat_buffer_clear (new_buffer);
if (switch_to_buffer)
weechat_buffer_set (new_buffer, "display", "1");
return new_buffer;
}
void
relay_raw_open (int switch_to_buffer)
{
struct t_relay_raw_message *ptr_raw_message;
if (!relay_raw_buffer)
{
relay_raw_buffer = weechat_buffer_search (RELAY_PLUGIN_NAME,
RELAY_RAW_BUFFER_NAME);
if (!relay_raw_buffer)
{
relay_raw_buffer = weechat_buffer_new (RELAY_RAW_BUFFER_NAME,
&relay_buffer_input_cb, NULL,
&relay_buffer_close_cb, NULL);
/* failed to create buffer ? then return */
if (!relay_raw_buffer)
return;
weechat_buffer_set (relay_raw_buffer,
"title", _("Relay raw messages"));
if (!weechat_buffer_get_integer (relay_raw_buffer, "short_name_is_set"))
{
weechat_buffer_set (relay_raw_buffer, "short_name",
RELAY_RAW_BUFFER_NAME);
}
weechat_buffer_set (relay_raw_buffer, "localvar_set_type", "debug");
weechat_buffer_set (relay_raw_buffer, "localvar_set_server", RELAY_RAW_BUFFER_NAME);
weechat_buffer_set (relay_raw_buffer, "localvar_set_channel", RELAY_RAW_BUFFER_NAME);
weechat_buffer_set (relay_raw_buffer, "localvar_set_no_log", "1");
/* disable all highlights on this buffer */
weechat_buffer_set (relay_raw_buffer, "highlight_words", "-");
/* print messages in list */
for (ptr_raw_message = relay_raw_messages; ptr_raw_message;
ptr_raw_message = ptr_raw_message->next_message)
{
relay_raw_message_print (ptr_raw_message);
}
}
}
if (relay_raw_buffer && switch_to_buffer)
weechat_buffer_set (relay_raw_buffer, "display", "1");
}
void silc_private_message(SilcClient client, SilcClientConnection conn, SilcClientEntry sender,
SilcMessagePayload payload, SilcMessageFlags flags, const unsigned char *message, SilcUInt32 message_len) {
struct SilcClientContext *clientCtx;
struct t_gui_buffer *query_buffer = sender->context;
if (query_buffer == NULL) {
clientCtx = malloc(sizeof(struct SilcClientContext));
query_buffer = weechat_buffer_new(sender->nickname, &silc_plugin_query_input, clientCtx, NULL, NULL);
clientCtx->query_buffer = query_buffer;
clientCtx->client_entry = sender;
clientCtx->connection = conn;
sender->context = query_buffer;
}
weechat_printf(query_buffer, "%s\t%s", sender->nickname, message);
weechat_buffer_set(query_buffer, "hotlist", WEECHAT_HOTLIST_HIGHLIGHT);
}
void
relay_buffer_open ()
{
if (!relay_buffer)
{
relay_buffer = weechat_buffer_new (RELAY_BUFFER_NAME,
&relay_buffer_input_cb, NULL, NULL,
&relay_buffer_close_cb, NULL, NULL);
/* failed to create buffer ? then exit */
if (!relay_buffer)
return;
weechat_buffer_set (relay_buffer, "type", "free");
weechat_buffer_set (relay_buffer, "title", _("List of clients for relay"));
weechat_buffer_set (relay_buffer, "key_bind_meta2-A", "/relay up");
weechat_buffer_set (relay_buffer, "key_bind_meta2-B", "/relay down");
weechat_buffer_set (relay_buffer, "localvar_set_type", "relay");
}
}
void
xfer_buffer_open ()
{
if (!xfer_buffer)
{
xfer_buffer = weechat_buffer_new (XFER_BUFFER_NAME,
&xfer_buffer_input_cb, NULL, NULL,
&xfer_buffer_close_cb, NULL, NULL);
/* failed to create buffer ? then exit */
if (!xfer_buffer)
return;
weechat_buffer_set (xfer_buffer, "type", "free");
weechat_buffer_set (xfer_buffer, "title", _("Xfer list"));
weechat_buffer_set (xfer_buffer, "key_bind_meta2-A", "/xfer up");
weechat_buffer_set (xfer_buffer, "key_bind_meta2-B", "/xfer down");
weechat_buffer_set (xfer_buffer, "localvar_set_type", "xfer");
}
}
void
script_buffer_open ()
{
if (!script_buffer)
{
script_buffer = weechat_buffer_new (SCRIPT_BUFFER_NAME,
&script_buffer_input_cb, NULL,
&script_buffer_close_cb, NULL);
/* failed to create buffer ? then exit */
if (!script_buffer)
return;
weechat_buffer_set (script_buffer, "type", "free");
weechat_buffer_set (script_buffer, "title", _("Scripts"));
script_buffer_set_keys ();
weechat_buffer_set (script_buffer, "localvar_set_type", "script");
script_buffer_selected_line = 0;
script_buffer_detail_script = NULL;
}
}
int command_silc_msg(void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) {
char *nickname;
char *msg;
struct t_gui_buffer *query_buffer;
struct SilcClientContext *clientCtx;
SilcClientEntry client_entry;
SilcDList list;
SilcPluginServerList server = find_server_for_buffer(buffer);
if (argc < 3) {
weechat_printf(buffer, "you need to specify a recipient");
return WEECHAT_RC_ERROR;
}
nickname = argv[2];
list = silc_client_get_clients_local(silc_plugin->client, server->connection, nickname, FALSE);
if (list == NULL) {
weechat_printf(buffer, "no such nick: %s", nickname);
return WEECHAT_RC_OK;
}
silc_dlist_start(list);
client_entry = silc_dlist_get(list);
silc_client_list_free(silc_plugin->client, server->connection, list);
clientCtx = client_entry->context;
if (clientCtx == NULL) {
clientCtx = malloc(sizeof(struct SilcClientContext));
query_buffer = weechat_buffer_new(client_entry->nickname, &silc_plugin_query_input, clientCtx, NULL, NULL);
clientCtx->query_buffer = query_buffer;
clientCtx->client_entry = client_entry;
clientCtx->connection = server->connection;
}
if (argc > 3) {
msg = argv_eol[3];
silc_plugin_query_input(clientCtx, clientCtx->query_buffer, msg);
}
return WEECHAT_RC_OK;
}
void silc_command_reply(SilcClient client, SilcClientConnection conn, SilcCommand command, SilcStatus status, SilcStatus error, va_list ap) {
// "infrastructure"
struct t_gui_buffer *channelbuffer, *serverbuffer;
SilcConnectionContext ctx = conn->context;
//SilcPluginChannelList channel;
struct SilcChannelContext *chanCtx;
// possible args
char *str, *topic, *cipher, *hmac;
SilcChannelEntry channel_entry;
SilcUInt32 mode, userlimit;
SilcHashTableList *userlist;
SilcPublicKey key;
SilcDList pubkeys;
size_t strsize;
// needed for the nicklist
SilcClientEntry user_client;
SilcChannelUser user;
struct t_gui_nick *nick = NULL;
switch (command) {
case SILC_COMMAND_JOIN:
str = va_arg(ap, char *);
channel_entry = va_arg(ap, SilcChannelEntry);
mode = va_arg(ap, SilcUInt32);
userlist = va_arg(ap, SilcHashTableList *);
topic = va_arg(ap, char *);
cipher = va_arg(ap, char *);
hmac = va_arg(ap, char *);
key = va_arg(ap, SilcPublicKey);
pubkeys = va_arg(ap, SilcDList);
userlimit = va_arg(ap, SilcUInt32);
chanCtx = malloc(sizeof(struct SilcChannelContext));
chanCtx->channel_name = str;
chanCtx->channel_entry = channel_entry;
chanCtx->connection = conn;
strsize = strlen(channel_entry->channel_name) + strlen(channel_entry->server) + 1;
str = malloc(strsize+1);
snprintf(str, strsize, "%s.%s", channel_entry->channel_name, channel_entry->server);
// create a regular chat buffer and set some senible values
channelbuffer = weechat_buffer_new(str, &silc_plugin_channel_input, chanCtx, NULL, NULL);
weechat_buffer_set(channelbuffer, "name", str);
weechat_buffer_set(channelbuffer, "short_name", channel_entry->channel_name);
weechat_buffer_set(channelbuffer, "title", topic);
weechat_buffer_set(channelbuffer, "hotlist", WEECHAT_HOTLIST_LOW);
weechat_buffer_set(channelbuffer, "nicklist", "1");
chanCtx->channel_buffer = channelbuffer;
channel_entry->context = channelbuffer;
serverbuffer = ctx->server_buffer;
add_channel(channel_entry->channel_name, find_server_for_buffer(serverbuffer), channel_entry, NULL, channelbuffer);
// fill the nicklist with users currently on the channel
while (silc_hash_table_get(userlist, (void **)&user_client, (void **)&user)) {
nick = silc_nicklist_add(user);
}
break;
default:
weechat_log_printf("unhandled command reply for %d", command);
break;
}
}
