~ubuntu-branches/ubuntu/wily/wpasupplicant/wily

« back to all changes in this revision

Viewing changes to src/crypto/tls_nss.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2010-11-22 09:43:43 UTC
  • mfrom: (1.1.16 upstream)
  • Revision ID: james.westby@ubuntu.com-20101122094343-qgsxaojvmswfri77
Tags: 0.7.3-0ubuntu1
* Get wpasupplicant 0.7.3 from Debian's SVN. Leaving 0.7.3-1 as unreleased
  for now.
* Build-Depend on debhelper 8, since the packaging from Debian uses compat 8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * SSL/TLS interface functions for NSS
 
3
 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License version 2 as
 
7
 * published by the Free Software Foundation.
 
8
 *
 
9
 * Alternatively, this software may be distributed under the terms of BSD
 
10
 * license.
 
11
 *
 
12
 * See README and COPYING for more details.
 
13
 */
 
14
 
 
15
#include "includes.h"
 
16
#include <nspr/prtypes.h>
 
17
#include <nspr/plarenas.h>
 
18
#include <nspr/plhash.h>
 
19
#include <nspr/prio.h>
 
20
#include <nspr/prclist.h>
 
21
#include <nspr/prlock.h>
 
22
#include <nspr/prinit.h>
 
23
#include <nspr/prerror.h>
 
24
#include <nspr/prmem.h>
 
25
#include <nss/nss.h>
 
26
#include <nss/nssilckt.h>
 
27
#include <nss/ssl.h>
 
28
#include <nss/pk11func.h>
 
29
#include <nss/secerr.h>
 
30
 
 
31
#include "common.h"
 
32
#include "tls.h"
 
33
 
 
34
static int tls_nss_ref_count = 0;
 
35
 
 
36
static PRDescIdentity nss_layer_id;
 
37
 
 
38
 
 
39
struct tls_connection {
 
40
        PRFileDesc *fd;
 
41
 
 
42
        int established;
 
43
        int verify_peer;
 
44
        u8 *push_buf, *pull_buf, *pull_buf_offset;
 
45
        size_t push_buf_len, pull_buf_len;
 
46
};
 
47
 
 
48
 
 
49
static PRStatus nss_io_close(PRFileDesc *fd)
 
50
{
 
51
        wpa_printf(MSG_DEBUG, "NSS: I/O close");
 
52
        return PR_SUCCESS;
 
53
}
 
54
 
 
55
 
 
56
static PRInt32 nss_io_read(PRFileDesc *fd, void *buf, PRInt32 amount)
 
57
{
 
58
        wpa_printf(MSG_DEBUG, "NSS: I/O read(%d)", amount);
 
59
        return PR_FAILURE;
 
60
}
 
61
 
 
62
 
 
63
static PRInt32 nss_io_write(PRFileDesc *fd, const void *buf, PRInt32 amount)
 
64
{
 
65
        wpa_printf(MSG_DEBUG, "NSS: I/O write(%d)", amount);
 
66
        return PR_FAILURE;
 
67
}
 
68
 
 
69
 
 
70
static PRInt32 nss_io_writev(PRFileDesc *fd, const PRIOVec *iov,
 
71
                             PRInt32 iov_size, PRIntervalTime timeout)
 
72
{
 
73
        wpa_printf(MSG_DEBUG, "NSS: I/O writev(%d)", iov_size);
 
74
        return PR_FAILURE;
 
75
}
 
76
 
 
77
 
 
78
static PRInt32 nss_io_recv(PRFileDesc *fd, void *buf, PRInt32 amount,
 
79
                           PRIntn flags, PRIntervalTime timeout)
 
80
{
 
81
        struct tls_connection *conn = (struct tls_connection *) fd->secret;
 
82
        u8 *end;
 
83
 
 
84
        wpa_printf(MSG_DEBUG, "NSS: I/O recv(%d)", amount);
 
85
 
 
86
        if (conn->pull_buf == NULL) {
 
87
                wpa_printf(MSG_DEBUG, "NSS: No data available to be read yet");
 
88
                return PR_FAILURE;
 
89
        }
 
90
 
 
91
        end = conn->pull_buf + conn->pull_buf_len;
 
92
        if (end - conn->pull_buf_offset < amount)
 
93
                amount = end - conn->pull_buf_offset;
 
94
        os_memcpy(buf, conn->pull_buf_offset, amount);
 
95
        conn->pull_buf_offset += amount;
 
96
        if (conn->pull_buf_offset == end) {
 
97
                wpa_printf(MSG_DEBUG, "%s - pull_buf consumed", __func__);
 
98
                os_free(conn->pull_buf);
 
99
                conn->pull_buf = conn->pull_buf_offset = NULL;
 
100
                conn->pull_buf_len = 0;
 
101
        } else {
 
102
                wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in pull_buf",
 
103
                           __func__,
 
104
                           (unsigned long) (end - conn->pull_buf_offset));
 
105
        }
 
106
        return amount;
 
107
}
 
108
 
 
109
 
 
110
static PRInt32 nss_io_send(PRFileDesc *fd, const void *buf, PRInt32 amount,
 
111
                           PRIntn flags, PRIntervalTime timeout)
 
112
{
 
113
        struct tls_connection *conn = (struct tls_connection *) fd->secret;
 
114
        u8 *nbuf;
 
115
 
 
116
        wpa_printf(MSG_DEBUG, "NSS: I/O %s", __func__);
 
117
        wpa_hexdump(MSG_MSGDUMP, "NSS: I/O send data", buf, amount);
 
118
 
 
119
        nbuf = os_realloc(conn->push_buf, conn->push_buf_len + amount);
 
120
        if (nbuf == NULL) {
 
121
                wpa_printf(MSG_ERROR, "NSS: Failed to allocate memory for the "
 
122
                           "data to be sent");
 
123
                return PR_FAILURE;
 
124
        }
 
125
        os_memcpy(nbuf + conn->push_buf_len, buf, amount);
 
126
        conn->push_buf = nbuf;
 
127
        conn->push_buf_len += amount;
 
128
 
 
129
        return amount;
 
130
}
 
131
 
 
132
 
 
133
static PRInt32 nss_io_recvfrom(PRFileDesc *fd, void *buf, PRInt32 amount,
 
134
                               PRIntn flags, PRNetAddr *addr,
 
135
                               PRIntervalTime timeout)
 
136
{
 
137
        wpa_printf(MSG_DEBUG, "NSS: I/O %s", __func__);
 
138
        return PR_FAILURE;
 
139
}
 
140
 
 
141
 
 
142
static PRInt32 nss_io_sendto(PRFileDesc *fd, const void *buf, PRInt32 amount,
 
143
                             PRIntn flags, const PRNetAddr *addr,
 
144
                             PRIntervalTime timeout)
 
145
{
 
146
        wpa_printf(MSG_DEBUG, "NSS: I/O %s", __func__);
 
147
        return PR_FAILURE;
 
148
}
 
149
 
 
150
 
 
151
static PRStatus nss_io_getpeername(PRFileDesc *fd, PRNetAddr *addr)
 
152
{
 
153
        wpa_printf(MSG_DEBUG, "NSS: I/O getpeername");
 
154
 
 
155
        /*
 
156
         * It Looks like NSS only supports IPv4 and IPv6 TCP sockets. Provide a
 
157
         * fake IPv4 address to work around this even though we are not really
 
158
         * using TCP.
 
159
         */
 
160
        os_memset(addr, 0, sizeof(*addr));
 
161
        addr->inet.family = PR_AF_INET;
 
162
 
 
163
        return PR_SUCCESS;
 
164
}
 
165
 
 
166
 
 
167
static PRStatus nss_io_getsocketoption(PRFileDesc *fd,
 
168
                                       PRSocketOptionData *data)
 
169
{
 
170
        switch (data->option) {
 
171
        case PR_SockOpt_Nonblocking:
 
172
                wpa_printf(MSG_DEBUG, "NSS: I/O getsocketoption(Nonblocking)");
 
173
                data->value.non_blocking = PR_TRUE;
 
174
                return PR_SUCCESS;
 
175
        default:
 
176
                wpa_printf(MSG_DEBUG, "NSS: I/O getsocketoption(%d)",
 
177
                           data->option);
 
178
                return PR_FAILURE;
 
179
        }
 
180
}
 
181
 
 
182
 
 
183
static const PRIOMethods nss_io = {
 
184
        PR_DESC_LAYERED,
 
185
        nss_io_close,
 
186
        nss_io_read,
 
187
        nss_io_write,
 
188
        NULL /* available */,
 
189
        NULL /* available64 */,
 
190
        NULL /* fsync */,
 
191
        NULL /* fseek */,
 
192
        NULL /* fseek64 */,
 
193
        NULL /* fileinfo */,
 
194
        NULL /* fileinfo64 */,
 
195
        nss_io_writev,
 
196
        NULL /* connect */,
 
197
        NULL /* accept */,
 
198
        NULL /* bind */,
 
199
        NULL /* listen */,
 
200
        NULL /* shutdown */,
 
201
        nss_io_recv,
 
202
        nss_io_send,
 
203
        nss_io_recvfrom,
 
204
        nss_io_sendto,
 
205
        NULL /* poll */,
 
206
        NULL /* acceptread */,
 
207
        NULL /* transmitfile */,
 
208
        NULL /* getsockname */,
 
209
        nss_io_getpeername,
 
210
        NULL /* reserved_fn_6 */,
 
211
        NULL /* reserved_fn_5 */,
 
212
        nss_io_getsocketoption,
 
213
        NULL /* setsocketoption */,
 
214
        NULL /* sendfile */,
 
215
        NULL /* connectcontinue */,
 
216
        NULL /* reserved_fn_3 */,
 
217
        NULL /* reserved_fn_2 */,
 
218
        NULL /* reserved_fn_1 */,
 
219
        NULL /* reserved_fn_0 */
 
220
};
 
221
 
 
222
 
 
223
static char * nss_password_cb(PK11SlotInfo *slot, PRBool retry, void *arg)
 
224
{
 
225
        wpa_printf(MSG_ERROR, "NSS: TODO - %s", __func__);
 
226
        return NULL;
 
227
}
 
228
 
 
229
 
 
230
void * tls_init(const struct tls_config *conf)
 
231
{
 
232
        char *dir;
 
233
 
 
234
        tls_nss_ref_count++;
 
235
        if (tls_nss_ref_count > 1)
 
236
                return (void *) 1;
 
237
 
 
238
        PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
 
239
 
 
240
        nss_layer_id = PR_GetUniqueIdentity("wpa_supplicant");
 
241
 
 
242
        PK11_SetPasswordFunc(nss_password_cb);
 
243
 
 
244
        dir = getenv("SSL_DIR");
 
245
        if (dir) {
 
246
                if (NSS_Init(dir) != SECSuccess) {
 
247
                        wpa_printf(MSG_ERROR, "NSS: NSS_Init(cert_dir=%s) "
 
248
                                   "failed", dir);
 
249
                        return NULL;
 
250
                }
 
251
        } else {
 
252
                if (NSS_NoDB_Init(NULL) != SECSuccess) {
 
253
                        wpa_printf(MSG_ERROR, "NSS: NSS_NoDB_Init(NULL) "
 
254
                                   "failed");
 
255
                        return NULL;
 
256
                }
 
257
        }
 
258
 
 
259
        if (SSL_OptionSetDefault(SSL_V2_COMPATIBLE_HELLO, PR_FALSE) !=
 
260
            SECSuccess ||
 
261
            SSL_OptionSetDefault(SSL_ENABLE_SSL3, PR_FALSE) != SECSuccess ||
 
262
            SSL_OptionSetDefault(SSL_ENABLE_SSL2, PR_FALSE) != SECSuccess ||
 
263
            SSL_OptionSetDefault(SSL_ENABLE_TLS, PR_TRUE) != SECSuccess) {
 
264
                wpa_printf(MSG_ERROR, "NSS: SSL_OptionSetDefault failed");
 
265
                return NULL;
 
266
        }
 
267
 
 
268
        if (NSS_SetDomesticPolicy() != SECSuccess) {
 
269
                wpa_printf(MSG_ERROR, "NSS: NSS_SetDomesticPolicy() failed");
 
270
                return NULL;
 
271
        }
 
272
 
 
273
        return (void *) 1;
 
274
}
 
275
 
 
276
void tls_deinit(void *ssl_ctx)
 
277
{
 
278
        tls_nss_ref_count--;
 
279
        if (tls_nss_ref_count == 0) {
 
280
                if (NSS_Shutdown() != SECSuccess)
 
281
                        wpa_printf(MSG_ERROR, "NSS: NSS_Shutdown() failed");
 
282
        }
 
283
}
 
284
 
 
285
 
 
286
int tls_get_errors(void *tls_ctx)
 
287
{
 
288
        return 0;
 
289
}
 
290
 
 
291
 
 
292
static SECStatus nss_bad_cert_cb(void *arg, PRFileDesc *fd)
 
293
{
 
294
        struct tls_connection *conn = arg;
 
295
        SECStatus res = SECSuccess;
 
296
        PRErrorCode err;
 
297
        CERTCertificate *cert;
 
298
        char *subject, *issuer;
 
299
 
 
300
        err = PR_GetError();
 
301
        if (IS_SEC_ERROR(err))
 
302
                wpa_printf(MSG_DEBUG, "NSS: Bad Server Certificate (sec err "
 
303
                           "%d)", err - SEC_ERROR_BASE);
 
304
        else
 
305
                wpa_printf(MSG_DEBUG, "NSS: Bad Server Certificate (err %d)",
 
306
                           err);
 
307
        cert = SSL_PeerCertificate(fd);
 
308
        subject = CERT_NameToAscii(&cert->subject);
 
309
        issuer = CERT_NameToAscii(&cert->issuer);
 
310
        wpa_printf(MSG_DEBUG, "NSS: Peer certificate subject='%s' issuer='%s'",
 
311
                   subject, issuer);
 
312
        CERT_DestroyCertificate(cert);
 
313
        PR_Free(subject);
 
314
        PR_Free(issuer);
 
315
        if (conn->verify_peer)
 
316
                res = SECFailure;
 
317
 
 
318
        return res;
 
319
}
 
320
 
 
321
 
 
322
static void nss_handshake_cb(PRFileDesc *fd, void *client_data)
 
323
{
 
324
        struct tls_connection *conn = client_data;
 
325
        wpa_printf(MSG_DEBUG, "NSS: Handshake completed");
 
326
        conn->established = 1;
 
327
}
 
328
 
 
329
 
 
330
struct tls_connection * tls_connection_init(void *tls_ctx)
 
331
{
 
332
        struct tls_connection *conn;
 
333
 
 
334
        conn = os_zalloc(sizeof(*conn));
 
335
        if (conn == NULL)
 
336
                return NULL;
 
337
 
 
338
        conn->fd = PR_CreateIOLayerStub(nss_layer_id, &nss_io);
 
339
        if (conn->fd == NULL) {
 
340
                os_free(conn);
 
341
                return NULL;
 
342
        }
 
343
        conn->fd->secret = (void *) conn;
 
344
 
 
345
        conn->fd = SSL_ImportFD(NULL, conn->fd);
 
346
        if (conn->fd == NULL) {
 
347
                os_free(conn);
 
348
                return NULL;
 
349
        }
 
350
 
 
351
        if (SSL_OptionSet(conn->fd, SSL_SECURITY, PR_TRUE) != SECSuccess ||
 
352
            SSL_OptionSet(conn->fd, SSL_HANDSHAKE_AS_CLIENT, PR_TRUE) !=
 
353
            SECSuccess ||
 
354
            SSL_OptionSet(conn->fd, SSL_HANDSHAKE_AS_SERVER, PR_FALSE) !=
 
355
            SECSuccess ||
 
356
            SSL_OptionSet(conn->fd, SSL_ENABLE_TLS, PR_TRUE) != SECSuccess ||
 
357
            SSL_BadCertHook(conn->fd, nss_bad_cert_cb, conn) != SECSuccess ||
 
358
            SSL_HandshakeCallback(conn->fd, nss_handshake_cb, conn) !=
 
359
            SECSuccess) {
 
360
                wpa_printf(MSG_ERROR, "NSS: Failed to set options");
 
361
                PR_Close(conn->fd);
 
362
                os_free(conn);
 
363
                return NULL;
 
364
        }
 
365
 
 
366
        SSL_ResetHandshake(conn->fd, PR_FALSE);
 
367
 
 
368
        return conn;
 
369
}
 
370
 
 
371
 
 
372
void tls_connection_deinit(void *tls_ctx, struct tls_connection *conn)
 
373
{
 
374
        PR_Close(conn->fd);
 
375
        os_free(conn->push_buf);
 
376
        os_free(conn->pull_buf);
 
377
        os_free(conn);
 
378
}
 
379
 
 
380
 
 
381
int tls_connection_established(void *tls_ctx, struct tls_connection *conn)
 
382
{
 
383
        return conn->established;
 
384
}
 
385
 
 
386
 
 
387
int tls_connection_shutdown(void *tls_ctx, struct tls_connection *conn)
 
388
{
 
389
        return -1;
 
390
}
 
391
 
 
392
 
 
393
int tls_connection_set_params(void *tls_ctx, struct tls_connection *conn,
 
394
                              const struct tls_connection_params *params)
 
395
{
 
396
        wpa_printf(MSG_ERROR, "NSS: TODO - %s", __func__);
 
397
        return 0;
 
398
}
 
399
 
 
400
 
 
401
int tls_global_set_params(void *tls_ctx,
 
402
                          const struct tls_connection_params *params)
 
403
{
 
404
        return -1;
 
405
}
 
406
 
 
407
 
 
408
int tls_global_set_verify(void *tls_ctx, int check_crl)
 
409
{
 
410
        return -1;
 
411
}
 
412
 
 
413
 
 
414
int tls_connection_set_verify(void *tls_ctx, struct tls_connection *conn,
 
415
                              int verify_peer)
 
416
{
 
417
        conn->verify_peer = verify_peer;
 
418
        return 0;
 
419
}
 
420
 
 
421
 
 
422
int tls_connection_set_ia(void *tls_ctx, struct tls_connection *conn,
 
423
                          int tls_ia)
 
424
{
 
425
        return -1;
 
426
}
 
427
 
 
428
 
 
429
int tls_connection_get_keys(void *tls_ctx, struct tls_connection *conn,
 
430
                            struct tls_keys *keys)
 
431
{
 
432
        /* NSS does not export master secret or client/server random. */
 
433
        return -1;
 
434
}
 
435
 
 
436
 
 
437
int tls_connection_prf(void *tls_ctx, struct tls_connection *conn,
 
438
                       const char *label, int server_random_first,
 
439
                       u8 *out, size_t out_len)
 
440
{
 
441
        if (conn == NULL || server_random_first) {
 
442
                wpa_printf(MSG_INFO, "NSS: Unsupported PRF request "
 
443
                           "(server_random_first=%d)",
 
444
                           server_random_first);
 
445
                return -1;
 
446
        }
 
447
 
 
448
        if (SSL_ExportKeyingMaterial(conn->fd, label, NULL, 0, out, out_len) !=
 
449
            SECSuccess) {
 
450
                wpa_printf(MSG_INFO, "NSS: Failed to use TLS extractor "
 
451
                           "(label='%s' out_len=%d", label, (int) out_len);
 
452
                return -1;
 
453
        }
 
454
 
 
455
        return 0;
 
456
}
 
457
 
 
458
 
 
459
struct wpabuf * tls_connection_handshake(void *tls_ctx,
 
460
                                         struct tls_connection *conn,
 
461
                                         const struct wpabuf *in_data,
 
462
                                         struct wpabuf **appl_data)
 
463
{
 
464
        struct wpabuf *out_data;
 
465
 
 
466
        wpa_printf(MSG_DEBUG, "NSS: handshake: in_len=%u",
 
467
                   in_data ? (unsigned int) wpabuf_len(in_data) : 0);
 
468
 
 
469
        if (appl_data)
 
470
                *appl_data = NULL;
 
471
 
 
472
        if (in_data && wpabuf_len(in_data) > 0) {
 
473
                if (conn->pull_buf) {
 
474
                        wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in "
 
475
                                   "pull_buf", __func__,
 
476
                                   (unsigned long) conn->pull_buf_len);
 
477
                        os_free(conn->pull_buf);
 
478
                }
 
479
                conn->pull_buf = os_malloc(wpabuf_len(in_data));
 
480
                if (conn->pull_buf == NULL)
 
481
                        return NULL;
 
482
                os_memcpy(conn->pull_buf, wpabuf_head(in_data),
 
483
                          wpabuf_len(in_data));
 
484
                conn->pull_buf_offset = conn->pull_buf;
 
485
                conn->pull_buf_len = wpabuf_len(in_data);
 
486
        }
 
487
 
 
488
        SSL_ForceHandshake(conn->fd);
 
489
 
 
490
        if (conn->established && conn->push_buf == NULL) {
 
491
                /* Need to return something to get final TLS ACK. */
 
492
                conn->push_buf = os_malloc(1);
 
493
        }
 
494
 
 
495
        if (conn->push_buf == NULL)
 
496
                return NULL;
 
497
        out_data = wpabuf_alloc_ext_data(conn->push_buf, conn->push_buf_len);
 
498
        if (out_data == NULL)
 
499
                os_free(conn->push_buf);
 
500
        conn->push_buf = NULL;
 
501
        conn->push_buf_len = 0;
 
502
        return out_data;
 
503
}
 
504
 
 
505
 
 
506
struct wpabuf * tls_connection_server_handshake(void *tls_ctx,
 
507
                                                struct tls_connection *conn,
 
508
                                                const struct wpabuf *in_data,
 
509
                                                struct wpabuf **appl_data)
 
510
{
 
511
        return NULL;
 
512
}
 
513
 
 
514
 
 
515
struct wpabuf * tls_connection_encrypt(void *tls_ctx,
 
516
                                       struct tls_connection *conn,
 
517
                                       const struct wpabuf *in_data)
 
518
{
 
519
        PRInt32 res;
 
520
        struct wpabuf *buf;
 
521
 
 
522
        wpa_printf(MSG_DEBUG, "NSS: encrypt %d bytes",
 
523
                   (int) wpabuf_len(in_data));
 
524
        res = PR_Send(conn->fd, wpabuf_head(in_data), wpabuf_len(in_data), 0,
 
525
                      0);
 
526
        if (res < 0) {
 
527
                wpa_printf(MSG_ERROR, "NSS: Encryption failed");
 
528
                return NULL;
 
529
        }
 
530
        if (conn->push_buf == NULL)
 
531
                return NULL;
 
532
        buf = wpabuf_alloc_ext_data(conn->push_buf, conn->push_buf_len);
 
533
        if (buf == NULL)
 
534
                os_free(conn->push_buf);
 
535
        conn->push_buf = NULL;
 
536
        conn->push_buf_len = 0;
 
537
        return buf;
 
538
}
 
539
 
 
540
 
 
541
struct wpabuf * tls_connection_decrypt(void *tls_ctx,
 
542
                                       struct tls_connection *conn,
 
543
                                       const struct wpabuf *in_data)
 
544
{
 
545
        PRInt32 res;
 
546
        struct wpabuf *out;
 
547
 
 
548
        wpa_printf(MSG_DEBUG, "NSS: decrypt %d bytes",
 
549
                   (int) wpabuf_len(in_data));
 
550
        if (conn->pull_buf) {
 
551
                wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in "
 
552
                           "pull_buf", __func__,
 
553
                           (unsigned long) conn->pull_buf_len);
 
554
                os_free(conn->pull_buf);
 
555
        }
 
556
        conn->pull_buf = os_malloc(wpabuf_len(in_data));
 
557
        if (conn->pull_buf == NULL)
 
558
                return NULL;
 
559
        os_memcpy(conn->pull_buf, wpabuf_head(in_data), wpabuf_len(in_data));
 
560
        conn->pull_buf_offset = conn->pull_buf;
 
561
        conn->pull_buf_len = wpabuf_len(in_data);
 
562
 
 
563
        /*
 
564
         * Even though we try to disable TLS compression, it is possible that
 
565
         * this cannot be done with all TLS libraries. Add extra buffer space
 
566
         * to handle the possibility of the decrypted data being longer than
 
567
         * input data.
 
568
         */
 
569
        out = wpabuf_alloc((wpabuf_len(in_data) + 500) * 3);
 
570
        if (out == NULL)
 
571
                return NULL;
 
572
 
 
573
        res = PR_Recv(conn->fd, wpabuf_mhead(out), wpabuf_size(out), 0, 0);
 
574
        wpa_printf(MSG_DEBUG, "NSS: PR_Recv: %d", res);
 
575
        if (res < 0) {
 
576
                wpabuf_free(out);
 
577
                return NULL;
 
578
        }
 
579
        wpabuf_put(out, res);
 
580
 
 
581
        return out;
 
582
}
 
583
 
 
584
 
 
585
int tls_connection_resumed(void *tls_ctx, struct tls_connection *conn)
 
586
{
 
587
        return 0;
 
588
}
 
589
 
 
590
 
 
591
int tls_connection_set_cipher_list(void *tls_ctx, struct tls_connection *conn,
 
592
                                   u8 *ciphers)
 
593
{
 
594
        return -1;
 
595
}
 
596
 
 
597
 
 
598
int tls_get_cipher(void *tls_ctx, struct tls_connection *conn,
 
599
                   char *buf, size_t buflen)
 
600
{
 
601
        return -1;
 
602
}
 
603
 
 
604
 
 
605
int tls_connection_enable_workaround(void *tls_ctx,
 
606
                                     struct tls_connection *conn)
 
607
{
 
608
        return -1;
 
609
}
 
610
 
 
611
 
 
612
int tls_connection_client_hello_ext(void *tls_ctx, struct tls_connection *conn,
 
613
                                    int ext_type, const u8 *data,
 
614
                                    size_t data_len)
 
615
{
 
616
        return -1;
 
617
}
 
618
 
 
619
 
 
620
int tls_connection_get_failed(void *tls_ctx, struct tls_connection *conn)
 
621
{
 
622
        return 0;
 
623
}
 
624
 
 
625
 
 
626
int tls_connection_get_read_alerts(void *tls_ctx, struct tls_connection *conn)
 
627
{
 
628
        return 0;
 
629
}
 
630
 
 
631
 
 
632
int tls_connection_get_write_alerts(void *tls_ctx,
 
633
                                    struct tls_connection *conn)
 
634
{
 
635
        return 0;
 
636
}
 
637
 
 
638
 
 
639
int tls_connection_get_keyblock_size(void *tls_ctx,
 
640
                                     struct tls_connection *conn)
 
641
{
 
642
        return -1;
 
643
}
 
644
 
 
645
 
 
646
unsigned int tls_capabilities(void *tls_ctx)
 
647
{
 
648
        return 0;
 
649
}
 
650
 
 
651
 
 
652
struct wpabuf * tls_connection_ia_send_phase_finished(
 
653
        void *tls_ctx, struct tls_connection *conn, int final)
 
654
{
 
655
        return NULL;
 
656
}
 
657
 
 
658
 
 
659
int tls_connection_ia_final_phase_finished(void *tls_ctx,
 
660
                                           struct tls_connection *conn)
 
661
{
 
662
        return -1;
 
663
}
 
664
 
 
665
 
 
666
int tls_connection_ia_permute_inner_secret(void *tls_ctx,
 
667
                                           struct tls_connection *conn,
 
668
                                           const u8 *key, size_t key_len)
 
669
{
 
670
        return -1;
 
671
}
 
672
 
 
673
 
 
674
int tls_connection_set_session_ticket_cb(void *tls_ctx,
 
675
                                         struct tls_connection *conn,
 
676
                                         tls_session_ticket_cb cb,
 
677
                                         void *ctx)
 
678
{
 
679
        return -1;
 
680
}