1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/* HexChat
* Copyright (C) 1998-2010 Peter Zelezny.
* Copyright (C) 2009-2013 Berke Viktor.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef HEXCHAT_COMMONPLUGIN_H
#define HEXCHAT_COMMONPLUGIN_H
#ifdef PLUGIN_C
struct _hexchat_plugin
{
/* Keep these in sync with hexchat-plugin.h */
/* !!don't change the order, to keep binary compat!! */
hexchat_hook *(*hexchat_hook_command) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[], void *user_data),
const char *help_text,
void *userdata);
hexchat_hook *(*hexchat_hook_server) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[], void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_print) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_timer) (hexchat_plugin *ph,
int timeout,
int (*callback) (void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_fd) (hexchat_plugin *ph,
int fd,
int flags,
int (*callback) (int fd, int flags, void *user_data),
void *userdata);
void *(*hexchat_unhook) (hexchat_plugin *ph,
hexchat_hook *hook);
void (*hexchat_print) (hexchat_plugin *ph,
const char *text);
void (*hexchat_printf) (hexchat_plugin *ph,
const char *format, ...);
void (*hexchat_command) (hexchat_plugin *ph,
const char *command);
void (*hexchat_commandf) (hexchat_plugin *ph,
const char *format, ...);
int (*hexchat_nickcmp) (hexchat_plugin *ph,
const char *s1,
const char *s2);
int (*hexchat_set_context) (hexchat_plugin *ph,
hexchat_context *ctx);
hexchat_context *(*hexchat_find_context) (hexchat_plugin *ph,
const char *servname,
const char *channel);
hexchat_context *(*hexchat_get_context) (hexchat_plugin *ph);
const char *(*hexchat_get_info) (hexchat_plugin *ph,
const char *id);
int (*hexchat_get_prefs) (hexchat_plugin *ph,
const char *name,
const char **string,
int *integer);
hexchat_list * (*hexchat_list_get) (hexchat_plugin *ph,
const char *name);
void (*hexchat_list_free) (hexchat_plugin *ph,
hexchat_list *xlist);
const char * const * (*hexchat_list_fields) (hexchat_plugin *ph,
const char *name);
int (*hexchat_list_next) (hexchat_plugin *ph,
hexchat_list *xlist);
const char * (*hexchat_list_str) (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
int (*hexchat_list_int) (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
void * (*hexchat_plugingui_add) (hexchat_plugin *ph,
const char *filename,
const char *name,
const char *desc,
const char *version,
char *reserved);
void (*hexchat_plugingui_remove) (hexchat_plugin *ph,
void *handle);
int (*hexchat_emit_print) (hexchat_plugin *ph,
const char *event_name, ...);
void *(*hexchat_read_fd) (hexchat_plugin *ph);
time_t (*hexchat_list_time) (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
char *(*hexchat_gettext) (hexchat_plugin *ph,
const char *msgid);
void (*hexchat_send_modes) (hexchat_plugin *ph,
const char **targets,
int ntargets,
int modes_per_line,
char sign,
char mode);
char *(*hexchat_strip) (hexchat_plugin *ph,
const char *str,
int len,
int flags);
void (*hexchat_free) (hexchat_plugin *ph,
void *ptr);
int (*hexchat_pluginpref_set_str) (hexchat_plugin *ph,
const char *var,
const char *value);
int (*hexchat_pluginpref_get_str) (hexchat_plugin *ph,
const char *var,
char *dest);
int (*hexchat_pluginpref_set_int) (hexchat_plugin *ph,
const char *var,
int value);
int (*hexchat_pluginpref_get_int) (hexchat_plugin *ph,
const char *var);
int (*hexchat_pluginpref_delete) (hexchat_plugin *ph,
const char *var);
int (*hexchat_pluginpref_list) (hexchat_plugin *ph,
char *dest);
hexchat_hook *(*hexchat_hook_server_attrs) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[],
hexchat_event_attrs *attrs, void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_print_attrs) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], hexchat_event_attrs *attrs,
void *user_data),
void *userdata);
int (*hexchat_emit_print_attrs) (hexchat_plugin *ph, hexchat_event_attrs *attrs,
const char *event_name, ...);
hexchat_event_attrs *(*hexchat_event_attrs_create) (hexchat_plugin *ph);
void (*hexchat_event_attrs_free) (hexchat_plugin *ph,
hexchat_event_attrs *attrs);
/* PRIVATE FIELDS! */
void *handle; /* from dlopen */
char *filename; /* loaded from */
char *name;
char *desc;
char *version;
session *context;
void *deinit_callback; /* pointer to hexchat_plugin_deinit */
unsigned int fake:1; /* fake plugin. Added by hexchat_plugingui_add() */
unsigned int free_strings:1; /* free name,desc,version? */
};
#endif
GModule *module_load (char *filename);
char *plugin_load (session *sess, char *filename, char *arg);
int plugin_reload (session *sess, char *name, int by_filename);
void plugin_add (session *sess, char *filename, void *handle, void *init_func, void *deinit_func, char *arg, int fake);
int plugin_kill (char *name, int by_filename);
void plugin_kill_all (void);
void plugin_auto_load (session *sess);
int plugin_emit_command (session *sess, char *name, char *word[], char *word_eol[]);
int plugin_emit_server (session *sess, char *name, char *word[], char *word_eol[],
time_t server_time);
int plugin_emit_print (session *sess, char *word[], time_t server_time);
int plugin_emit_dummy_print (session *sess, char *name);
int plugin_emit_keypress (session *sess, unsigned int state, unsigned int keyval, gunichar key);
GList* plugin_command_list(GList *tmp_list);
int plugin_show_help (session *sess, char *cmd);
void plugin_command_foreach (session *sess, void *userdata, void (*cb) (session *sess, void *userdata, char *name, char *usage));
session *plugin_find_context (const char *servname, const char *channel, server *current_server);
/* On macOS, G_MODULE_SUFFIX says "so" but meson uses "dylib"
* https://github.com/mesonbuild/meson/issues/1160 */
#if defined(__APPLE__)
# define PLUGIN_SUFFIX "dylib"
#else
# define PLUGIN_SUFFIX G_MODULE_SUFFIX
#endif
#endif
class="k">if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYOFFLINE, sess, nick, serv->servername,
server_get_network (serv, TRUE), NULL, 0,
tags_data->timestamp);
fe_notify_update (nick);
fe_notify_update (0);
}
static void
notify_announce_online (server * serv, struct notify_per_server *servnot,
char *nick, const message_tags_data *tags_data)
{
session *sess;
sess = serv->front_session;
servnot->lastseen = time (0);
if (servnot->ison)
return;
servnot->ison = TRUE;
servnot->laston = time (0);
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYONLINE, sess, nick, serv->servername,
server_get_network (serv, TRUE), NULL, 0,
tags_data->timestamp);
fe_notify_update (nick);
fe_notify_update (0);
if (prefs.hex_notify_whois_online)
{
/* Let's do whois with idle time (like in /quote WHOIS %s %s) */
char *wii_str = g_strdup_printf ("%s %s", nick, nick);
serv->p_whois (serv, wii_str);
g_free (wii_str);
}
}
/* handles numeric 601 */
void
notify_set_offline (server * serv, char *nick, int quiet,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
servnot = notify_find (serv, nick);
if (!servnot)
return;
notify_announce_offline (serv, servnot, nick, quiet, tags_data);
}
/* handles numeric 604 and 600 */
void
notify_set_online (server * serv, char *nick,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
servnot = notify_find (serv, nick);
if (!servnot)
return;
notify_announce_online (serv, servnot, nick, tags_data);
}
/* monitor can send lists for numeric 730/731 */
void
notify_set_offline_list (server * serv, char *users, int quiet,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
char nick[NICKLEN];
char *token, *chr;
token = strtok (users, ",");
while (token != NULL)
{
chr = strchr (token, '!');
if (chr != NULL)
*chr = '\0';
g_strlcpy (nick, token, sizeof(nick));
servnot = notify_find (serv, nick);
if (servnot)
notify_announce_offline (serv, servnot, nick, quiet, tags_data);
token = strtok (NULL, ",");
}
}
void
notify_set_online_list (server * serv, char *users,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
char nick[NICKLEN];
char *token, *chr;
token = strtok (users, ",");
while (token != NULL)
{
chr = strchr (token, '!');
if (chr != NULL)
*chr = '\0';
g_strlcpy (nick, token, sizeof(nick));
servnot = notify_find (serv, nick);
if (servnot)
notify_announce_online (serv, servnot, nick, tags_data);
token = strtok (NULL, ",");
}
}
static void
notify_watch (server * serv, char *nick, int add)
{
char tbuf[256];
char addchar = '+';
if (!add)
addchar = '-';
if (serv->supports_monitor)
g_snprintf (tbuf, sizeof (tbuf), "MONITOR %c %s", addchar, nick);
else if (serv->supports_watch)
g_snprintf (tbuf, sizeof (tbuf), "WATCH %c%s", addchar, nick);
else
return;
serv->p_raw (serv, tbuf);
}
static void
notify_watch_all (struct notify *notify, int add)
{
server *serv;
GSList *list = serv_list;
while (list)
{
serv = list->data;
if (serv->connected && serv->end_of_motd && notify_do_network (notify, serv))
notify_watch (serv, notify->name, add);
list = list->next;
}
}
static void
notify_flush_watches (server * serv, GSList *from, GSList *end)
{
char tbuf[512];
GSList *list;
struct notify *notify;
serv->supports_monitor ? strcpy (tbuf, "MONITOR + ") : strcpy (tbuf, "WATCH");
list = from;
while (list != end)
{
notify = list->data;
if (serv->supports_monitor)
g_strlcat (tbuf, ",", sizeof(tbuf));
else
g_strlcat (tbuf, " +", sizeof(tbuf));
g_strlcat (tbuf, notify->name, sizeof(tbuf));
list = list->next;
}
serv->p_raw (serv, tbuf);
}
/* called when logging in. e.g. when End of motd. */
void
notify_send_watches (server * serv)
{
struct notify *notify;
const int format_len = serv->supports_monitor ? 1 : 2; /* just , for monitor or + and space for watch */
GSList *list;
GSList *point;
GSList *send_list = NULL;
int len = 0;
/* Only get the list for this network */
list = notify_list;
while (list)
{
notify = list->data;
if (notify_do_network (notify, serv))
{
send_list = g_slist_append (send_list, notify);
}
list = list->next;
}
/* Now send that list in batches */
point = list = send_list;
while (list)
{
notify = list->data;
len += strlen (notify->name) + format_len;
if (len > 500)
{
/* Too long send existing list */
notify_flush_watches (serv, point, list);
len = strlen (notify->name) + format_len;
point = list; /* We left off here */
}
list = g_slist_next (list);
}
if (len) /* We had leftovers under 500, send them all */
{
notify_flush_watches (serv, point, NULL);
}
g_slist_free (send_list);
}
/* called when receiving a ISON 303 - should this func go? */
void
notify_markonline (server *serv, char *word[], const message_tags_data *tags_data)
{
struct notify *notify;
struct notify_per_server *servnot;
GSList *list = notify_list;
int i, seen;
while (list)
{
notify = (struct notify *) list->data;
servnot = notify_find_server_entry (notify, serv);
if (!servnot)
{
list = list->next;
continue;
}
i = 4;
seen = FALSE;
while (*word[i])
{
if (!serv->p_cmp (notify->name, word[i]))
{
seen = TRUE;
notify_announce_online (serv, servnot, notify->name, tags_data);
break;
}
i++;
/* FIXME: word[] is only a 32 element array, limits notify list to
about 27 people */
if (i > PDIWORDS - 5)
{
/*fprintf (stderr, _("*** HEXCHAT WARNING: notify list too large.\n"));*/
break;
}
}
if (!seen && servnot->ison)
{
notify_announce_offline (serv, servnot, notify->name, FALSE, tags_data);
}
list = list->next;
}
fe_notify_update (0);
}
/* yuck! Old routine for ISON notify */
static void
notify_checklist_for_server (server *serv)
{
char outbuf[512];
struct notify *notify;
GSList *list = notify_list;
int i = 0;
strcpy (outbuf, "ISON ");
while (list)
{
notify = list->data;
if (notify_do_network (notify, serv))
{
i++;
strcat (outbuf, notify->name);
strcat (outbuf, " ");
if (strlen (outbuf) > 460)
{
/* LAME: we can't send more than 512 bytes to the server, but *
* if we split it in two packets, our offline detection wouldn't *
work */
/*fprintf (stderr, _("*** HEXCHAT WARNING: notify list too large.\n"));*/
break;
}
}
list = list->next;
}
if (i)
serv->p_raw (serv, outbuf);
}
int
notify_checklist (void) /* check ISON list */
{
struct server *serv;
GSList *list = serv_list;
while (list)
{
serv = list->data;
if (serv->connected && serv->end_of_motd && !serv->supports_watch && !serv->supports_monitor)
{
notify_checklist_for_server (serv);
}
list = list->next;
}
return 1;
}
void
notify_showlist (struct session *sess, const message_tags_data *tags_data)
{
char outbuf[256];
struct notify *notify;
GSList *list = notify_list;
struct notify_per_server *servnot;
int i = 0;
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYHEAD, sess, NULL, NULL, NULL, NULL, 0,
tags_data->timestamp);
while (list)
{
i++;
notify = (struct notify *) list->data;
servnot = notify_find_server_entry (notify, sess->server);
if (servnot && servnot->ison)
g_snprintf (outbuf, sizeof (outbuf), _(" %-20s online\n"), notify->name);
else
g_snprintf (outbuf, sizeof (outbuf), _(" %-20s offline\n"), notify->name);
PrintTextTimeStamp (sess, outbuf, tags_data->timestamp);
list = list->next;
}
if (i)
{
sprintf (outbuf, "%d", i);
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYNUMBER, sess, outbuf, NULL, NULL, NULL,
0, tags_data->timestamp);
} else
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYEMPTY, sess, NULL, NULL, NULL, NULL, 0,
tags_data->timestamp);
}
int
notify_deluser (char *name)
{
struct notify *notify;
struct notify_per_server *servnot;
GSList *list = notify_list;
while (list)
{
notify = (struct notify *) list->data;
if (!rfc_casecmp (notify->name, name))
{
fe_notify_update (notify->name);
/* Remove the records for each server */
while (notify->server_list)
{
servnot = (struct notify_per_server *) notify->server_list->data;
notify->server_list =
g_slist_remove (notify->server_list, servnot);
g_free (servnot);
}
notify_list = g_slist_remove (notify_list, notify);
notify_watch_all (notify, FALSE);
g_free (notify->networks);
g_free (notify->name);
g_free (notify);
fe_notify_update (0);
return 1;
}
list = list->next;
}
return 0;
}
void
notify_adduser (char *name, char *networks)
{
struct notify *notify = g_new0 (struct notify, 1);
notify->name = g_strndup (name, NICKLEN - 1);
if (networks != NULL)
notify->networks = despacify_dup (networks);
notify->server_list = 0;
notify_list = g_slist_prepend (notify_list, notify);
notify_checklist ();
fe_notify_update (notify->name);
fe_notify_update (0);
notify_watch_all (notify, TRUE);
}
gboolean
notify_is_in_list (server *serv, char *name)
{
struct notify *notify;
GSList *list = notify_list;
while (list)
{
notify = (struct notify *) list->data;
if (!serv->p_cmp (notify->name, name))
return TRUE;
list = list->next;
}
return FALSE;
}
int
notify_isnotify (struct session *sess, char *name)
{
struct notify *notify;
struct notify_per_server *servnot;
GSList *list = notify_list;
while (list)
{
notify = (struct notify *) list->data;
if (!sess->server->p_cmp (notify->name, name))
{
servnot = notify_find_server_entry (notify, sess->server);
if (servnot && servnot->ison)
return TRUE;
}
list = list->next;
}
return FALSE;
}
void
notify_cleanup ()
{
GSList *list = notify_list;
GSList *nslist, *srvlist;
struct notify *notify;
struct notify_per_server *servnot;
struct server *serv;
int valid;
while (list)
{
/* Traverse the list of notify structures */
notify = (struct notify *) list->data;
nslist = notify->server_list;
while (nslist)
{
/* Look at each per-server structure */
servnot = (struct notify_per_server *) nslist->data;
/* Check the server is valid */
valid = FALSE;
srvlist = serv_list;
while (srvlist)
{
serv = (struct server *) srvlist->data;
if (servnot->server == serv)
{
valid = serv->connected; /* Only valid if server is too */
break;
}
srvlist = srvlist->next;
}
if (!valid)
{
notify->server_list =
g_slist_remove (notify->server_list, servnot);
g_free (servnot);
nslist = notify->server_list;
} else
{
nslist = nslist->next;
}
}
list = list->next;
}
fe_notify_update (0);
}
|