← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/irssi/oneiric

« back to all changes in this revision

Viewing changes to src/fe-common/irc/fe-events.c

  • Committer: Bazaar Package Importer
  • Author(s): Andres Rodriguez
  • Date: 2009-05-05 15:50:50 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20090505155050-aoqlnpes7che9rtd
Tags: 0.8.13-1ubuntu1
https://launchpad.net/bugs/372411
* Merge from debian unstable (LP: #372411), remaining changes:
  - debian/patches: 03firsttimer_text
    + Adapt it so it tells you about connecting to irc.ubuntu.com and
      joining #ubuntu instead of irc.debian.org and #debian.
  - debian/patches: 90irc-ubuntu-com
* Fixed debian/patches/90irc-ubuntu-com for new irssi.conf.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/fe-common/irc/fe-events.c
30
30
#include "servers-reconnect.h"
31
31
#include "queries.h"
32
32
#include "ignore.h"
 
33
#include "recode.h"
33
34
 
34
35
#include "irc-servers.h"
35
36
#include "irc-channels.h"
44
45
static void event_privmsg(IRC_SERVER_REC *server, const char *data,
45
46
                          const char *nick, const char *addr)
46
47
{
47
 
        char *params, *target, *msg;
 
48
        char *params, *target, *msg, *recoded;
48
49
 
49
50
        g_return_if_fail(data != NULL);
50
51
 
53
54
        if (addr == NULL) addr = "";
54
55
        if (*target == '@' && ischannel(target[1])) {
55
56
                /* Hybrid 6 feature, send msg to all ops in channel */
 
57
                recoded = recode_in(SERVER(server), msg, target+1);
56
58
                signal_emit("message irc op_public", 5,
57
 
                            server, msg, nick, addr,
 
59
                            server, recoded, nick, addr,
58
60
                            get_visible_target(server, target+1));
59
61
        } else {
 
62
                recoded = recode_in(SERVER(server), msg, ischannel(*target) ? target : nick);
60
63
                signal_emit(ischannel(*target) ?
61
64
                            "message public" : "message private", 5,
62
 
                            server, msg, nick, addr,
 
65
                            server, recoded, nick, addr,
63
66
                            get_visible_target(server, target));
64
67
        }
65
68
 
66
69
        g_free(params);
 
70
        g_free(recoded);
67
71
}
68
72
 
69
73
static void ctcp_action(IRC_SERVER_REC *server, const char *data,
70
74
                        const char *nick, const char *addr,
71
75
                        const char *target)
72
76
{
 
77
        char *recoded;
 
78
 
73
79
        g_return_if_fail(data != NULL);
 
80
        recoded = recode_in(SERVER(server), data, target);
74
81
        signal_emit("message irc action", 5,
75
 
                    server, data, nick, addr,
 
82
                    server, recoded, nick, addr,
76
83
                    get_visible_target(server, target));
 
84
        g_free(recoded);
77
85
}
78
86
 
79
87
static void event_notice(IRC_SERVER_REC *server, const char *data,
80
88
                         const char *nick, const char *addr)
81
89
{
82
 
        char *params, *target, *msg;
 
90
        char *params, *target, *msg, *recoded;
83
91
 
84
92
        g_return_if_fail(data != NULL);
85
93
 
86
94
        params = event_get_params(data, 2 | PARAM_FLAG_GETREST, &target, &msg);
 
95
        recoded = recode_in(SERVER(server), msg, target);
87
96
        if (nick == NULL) {
88
97
                nick = server->real_address == NULL ?
89
98
                        server->connrec->address :
90
99
                        server->real_address;
91
100
        }
92
101
 
93
 
        signal_emit("message irc notice", 5, server, msg, nick, addr,
 
102
        signal_emit("message irc notice", 5, server, recoded, nick, addr,
94
103
                    get_visible_target(server, target));
95
104
        g_free(params);
 
105
        g_free(recoded);
96
106
}
97
107
 
98
108
static void event_join(IRC_SERVER_REC *server, const char *data,
114
124
static void event_part(IRC_SERVER_REC *server, const char *data,
115
125
                       const char *nick, const char *addr)
116
126
{
117
 
        char *params, *channel, *reason;
 
127
        char *params, *channel, *reason, *recoded;
118
128
 
119
129
        g_return_if_fail(data != NULL);
120
130
 
121
131
        params = event_get_params(data, 2 | PARAM_FLAG_GETREST,
122
132
                                  &channel, &reason);
 
133
        recoded = recode_in(SERVER(server), reason, channel);
123
134
        signal_emit("message part", 5, server,
124
 
                    get_visible_target(server, channel), nick, addr, reason);
 
135
                    get_visible_target(server, channel), nick, addr, recoded);
125
136
        g_free(params);
 
137
        g_free(recoded);
126
138
}
127
139
 
128
140
static void event_quit(IRC_SERVER_REC *server, const char *data,
129
141
                       const char *nick, const char *addr)
130
142
{
 
143
        char *recoded;
 
144
 
131
145
        g_return_if_fail(data != NULL);
132
146
 
133
147
        if (*data == ':') data++; /* quit message */
134
 
        signal_emit("message quit", 4, server, nick, addr, data);
 
148
        recoded = recode_in(SERVER(server), data, nick);
 
149
        signal_emit("message quit", 4, server, nick, addr, recoded);
 
150
        g_free(recoded);
135
151
}
136
152
 
137
153
static void event_kick(IRC_SERVER_REC *server, const char *data,
138
154
                       const char *kicker, const char *addr)
139
155
{
140
 
        char *params, *channel, *nick, *reason;
 
156
        char *params, *channel, *nick, *reason, *recoded;
141
157
 
142
158
        g_return_if_fail(data != NULL);
143
159
 
144
160
        params = event_get_params(data, 3 | PARAM_FLAG_GETREST,
145
161
                                  &channel, &nick, &reason);
 
162
        recoded = recode_in(SERVER(server), reason, channel);
146
163
        signal_emit("message kick", 6,
147
164
                    server, get_visible_target(server, channel),
148
 
                    nick, kicker, addr, reason);
 
165
                    nick, kicker, addr, recoded);
149
166
        g_free(params);
 
167
        g_free(recoded);
150
168
}
151
169
 
152
170
static void event_kill(IRC_SERVER_REC *server, const char *data,
242
260
static void event_topic(IRC_SERVER_REC *server, const char *data,
243
261
                        const char *nick, const char *addr)
244
262
{
245
 
        char *params, *channel, *topic;
 
263
        char *params, *channel, *topic, *recoded;
246
264
 
247
265
        g_return_if_fail(data != NULL);
248
266
 
249
267
        params = event_get_params(data, 2 | PARAM_FLAG_GETREST,
250
268
                                  &channel, &topic);
 
269
        recoded = recode_in(SERVER(server), topic, channel);
251
270
        signal_emit("message topic", 5, server,
252
 
                    get_visible_target(server, channel), topic, nick, addr);
 
271
                    get_visible_target(server, channel), recoded, nick, addr);
253
272
        g_free(params);
 
273
        g_free(recoded);
254
274
}
255
275
 
256
276
static void event_error(IRC_SERVER_REC *server, const char *data)
269
289
        if (ignore_check(SERVER(server), nick, addr, NULL, data, MSGLEVEL_WALLOPS))
270
290
                return;
271
291
 
272
 
        if (g_strncasecmp(data, "\001ACTION ", 8) != 0)
 
292
        if (g_ascii_strncasecmp(data, "\001ACTION ", 8) != 0)
273
293
                printformat(server, NULL, MSGLEVEL_WALLOPS, IRCTXT_WALLOPS, nick, data);
274
294
        else {
275
295
                /* Action in WALLOP */