about summary refs log tree commit diff stats
path: root/src/otr/otrlibv4.c
blob: d735eb746f184bd7b5e125bdf1bf4cfbf029547c (plain) (blame)
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
/*
 * otrlibv4.c
 * vim: expandtab:ts=4:sts=4:sw=4
 *
 * Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
 *
 * 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
 * along with Profanity.  If not, see <https://www.gnu.org/licenses/>.
 *
 * 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.
 *
 */

#include "config.h"

#include <libotr/proto.h>
#include <libotr/privkey.h>
#include <libotr/message.h>

#include "log.h"
#include "otr/otr.h"
#include "otr/otrlib.h"
#include "ui/ui.h"
#include "ui/window_list.h"

static GTimer* timer;
static unsigned int current_interval;

OtrlPolicy
otrlib_policy(void)
{
    return OTRL_POLICY_ALLOW_V1 | OTRL_POLICY_ALLOW_V2;
}

void
otrlib_init_timer(void)
{
    OtrlUserState user_state = otr_userstate();
    timer = g_timer_new();
    current_interval = otrl_message_poll_get_default_interval(user_state);
}

void
otrlib_poll(void)
{
    gdouble elapsed = g_timer_elapsed(timer, NULL);

    if (current_interval != 0 && elapsed > current_interval) {
        OtrlUserState user_state = otr_userstate();
        OtrlMessageAppOps* ops = otr_messageops();
        otrl_message_poll(user_state, ops, NULL);
        g_timer_start(timer);
    }
}

char*
otrlib_start_query(void)
{
    return "?OTR?v2? This user has requested an Off-the-Record private conversation. However, you do not have a plugin to support that. See http://otr.cypherpunks.ca/ for more information.";
}

static const char*
cb_otr_error_message(void* opdata, ConnContext* context, OtrlErrorCode err_code)
{
    switch (err_code) {
    case OTRL_ERRCODE_ENCRYPTION_ERROR:
        return strdup("OTR Error: occurred while encrypting a message");
    case OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:
        return strdup("OTR Error: Sent encrypted message to somebody who is not in a mutual OTR session");
    case OTRL_ERRCODE_MSG_UNREADABLE:
        return strdup("OTR Error: sent an unreadable encrypted message");
    case OTRL_ERRCODE_MSG_MALFORMED:
        return strdup("OTR Error: message sent is malformed");
    default:
        return strdup("OTR Error: unknown");
    }
}

static void
cb_otr_error_message_free(void* opdata, const char* err_msg)
{
    free((char*)err_msg);
}

static void
cb_timer_control(void* opdata, unsigned int interval)
{
    current_interval = interval;
}

static void
cb_handle_msg_event(void* opdata, OtrlMessageEvent msg_event,
                    ConnContext* context, const char* message,
                    gcry_error_t err)
{
    GString* err_msg;
    switch (msg_event) {
    case OTRL_MSGEVENT_ENCRYPTION_REQUIRED:
        ui_handle_otr_error(context->username, "OTR: Policy requires encryption, but attempting to send an unencrypted message.");
        break;
    case OTRL_MSGEVENT_ENCRYPTION_ERROR:
        ui_handle_otr_error(context->username, "OTR: Error occurred while encrypting a message, message not sent.");
        break;
    case OTRL_MSGEVENT_CONNECTION_ENDED:
        ui_handle_otr_error(context->username, "OTR: Message not sent because contact has ended the private conversation.");
        break;
    case OTRL_MSGEVENT_SETUP_ERROR:
        ui_handle_otr_error(context->username, "OTR: A private conversation could not be set up.");
        break;
    case OTRL_MSGEVENT_MSG_REFLECTED:
        ui_handle_otr_error(context->username, "OTR: Received our own OTR message.");
        break;
    case OTRL_MSGEVENT_MSG_RESENT:
        ui_handle_otr_error(context->username, "OTR: The previous message was resent.");
        break;
    case OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:
        ui_handle_otr_error(context->username, "OTR: Received an encrypted message but no private connection established.");
        break;
    case OTRL_MSGEVENT_RCVDMSG_UNREADABLE:
        ui_handle_otr_error(context->username, "OTR: Cannot read the received message.");
        break;
    case OTRL_MSGEVENT_RCVDMSG_MALFORMED:
        ui_handle_otr_error(context->username, "OTR: The message received contains malformed data.");
        break;
    case OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:
        err_msg = g_string_new("OTR: Received error: ");
        g_string_append(err_msg, message);
        g_string_append(err_msg, ".");
        ui_handle_otr_error(context->username, err_msg->str);
        g_string_free(err_msg, TRUE);
        break;
    case OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED:
        err_msg = g_string_new("OTR: Received an unencrypted message: ");
        g_string_append(err_msg, message);
        ui_handle_otr_error(context->username, err_msg->str);
        g_string_free(err_msg, TRUE);
        break;
    case OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED:
        ui_handle_otr_error(context->username, "OTR: Cannot recognize the type of message received.");
        break;
    case OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE:
        ui_handle_otr_error(context->username, "OTR: Received and discarded a message intended for another instance.");
        break;
    default:
        break;
    }
}

static void
cb_handle_smp_event(void* opdata, OtrlSMPEvent smp_event,
                    ConnContext* context, unsigned short progress_percent,
                    char* question)
{
    NextExpectedSMP nextMsg = context->smstate->nextExpected;
    OtrlUserState user_state = otr_userstate();
    OtrlMessageAppOps* ops = otr_messageops();
    GHashTable* smp_initiators = otr_smpinitators();

    ProfChatWin* chatwin = wins_get_chat(context->username);

    switch (smp_event) {
    case OTRL_SMPEVENT_ASK_FOR_SECRET:
        if (chatwin) {
            chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_INIT, NULL);
        }
        g_hash_table_insert(smp_initiators, strdup(context->username), strdup(context->username));
        break;

    case OTRL_SMPEVENT_ASK_FOR_ANSWER:
        if (chatwin) {
            chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_INIT_Q, question);
        }
        break;

    case OTRL_SMPEVENT_SUCCESS:
        if (chatwin) {
            if (context->smstate->received_question == 0) {
                chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_SUCCESS, NULL);
                chatwin_otr_trust(chatwin);
            } else {
                chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_SUCCESS_Q, NULL);
            }
        }
        break;

    case OTRL_SMPEVENT_FAILURE:
        if (chatwin) {
            if (context->smstate->received_question == 0) {
                if (nextMsg == OTRL_SMP_EXPECT3) {
                    chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_SENDER_FAIL, NULL);
                } else if (nextMsg == OTRL_SMP_EXPECT4) {
                    chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_RECEIVER_FAIL, NULL);
                }
                chatwin_otr_untrust(chatwin);
            } else {
                chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_FAIL_Q, NULL);
            }
        }
        break;

    case OTRL_SMPEVENT_ERROR:
        otrl_message_abort_smp(user_state, ops, NULL, context);
        break;

    case OTRL_SMPEVENT_CHEATED:
        otrl_message_abort_smp(user_state, ops, NULL, context);
        break;

    case OTRL_SMPEVENT_ABORT:
        if (chatwin) {
            chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_ABORT, NULL);
            chatwin_otr_untrust(chatwin);
        }
        break;

    case OTRL_SMPEVENT_IN_PROGRESS:
        break;

    default:
        break;
    }
}

void
otrlib_init_ops(OtrlMessageAppOps* ops)
{
    ops->otr_error_message = cb_otr_error_message;
    ops->otr_error_message_free = cb_otr_error_message_free;
    ops->handle_msg_event = cb_handle_msg_event;
    ops->handle_smp_event = cb_handle_smp_event;
    ops->timer_control = cb_timer_control;
}

ConnContext*
otrlib_context_find(OtrlUserState user_state, const char* const recipient, char* jid)
{
    return otrl_context_find(user_state, recipient, jid, "xmpp", OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);
}

void
otrlib_end_session(OtrlUserState user_state, const char* const recipient, char* jid, OtrlMessageAppOps* ops)
{
    ConnContext* context = otrl_context_find(user_state, recipient, jid, "xmpp",
                                             OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);

    if (context) {
        otrl_message_disconnect(user_state, ops, NULL, jid, "xmpp", recipient, 0);
    }
}

gcry_error_t
otrlib_encrypt_message(OtrlUserState user_state, OtrlMessageAppOps* ops, char* jid, const char* const to,
                       const char* const message, char** newmessage)
{
    gcry_error_t err;

    err = otrl_message_sending(
        user_state,
        ops,
        NULL,
        jid,
        "xmpp",
        to,
        OTRL_INSTAG_MASTER,
        message,
        0,
        newmessage,
        OTRL_FRAGMENT_SEND_SKIP,
        NULL,
        NULL,
        NULL);

    return err;
}

int
otrlib_decrypt_message(OtrlUserState user_state, OtrlMessageAppOps* ops, char* jid, const char* const from,
                       const char* const message, char** decrypted, OtrlTLV** tlvs)
{
    return otrl_message_receiving(
        user_state,
        ops,
        NULL,
        jid,
        "xmpp",
        from,
        message,
        decrypted,
        tlvs,
        NULL,
        NULL,
        NULL);
}

void
otrlib_handle_tlvs(OtrlUserState user_state, OtrlMessageAppOps* ops, ConnContext* context, OtrlTLV* tlvs, GHashTable* smp_initiators)
{
}