← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_net_ssl.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_net_ssl.cpp
 
1
// Copyright 2013 Dolphin Emulator Project
 
2
// Licensed under GPLv2
 
3
// Refer to the license.txt file included.
 
4
 
 
5
#include "FileUtil.h"
 
6
#include "WII_IPC_HLE_Device_net_ssl.h"
 
7
#include "WII_Socket.h"
 
8
 
 
9
WII_SSL CWII_IPC_HLE_Device_net_ssl::_SSL[NET_SSL_MAXINSTANCES];
 
10
 
 
11
CWII_IPC_HLE_Device_net_ssl::CWII_IPC_HLE_Device_net_ssl(u32 _DeviceID, const std::string& _rDeviceName)
 
12
        : IWII_IPC_HLE_Device(_DeviceID, _rDeviceName)
 
13
{
 
14
        for (int i = 0; i < NET_SSL_MAXINSTANCES; ++i)
 
15
        {
 
16
                memset(&_SSL[i], 0, sizeof(WII_SSL));
 
17
        }
 
18
}
 
19
 
 
20
CWII_IPC_HLE_Device_net_ssl::~CWII_IPC_HLE_Device_net_ssl()
 
21
{
 
22
        // Cleanup sessions
 
23
        for (int i = 0; i < NET_SSL_MAXINSTANCES; i++)
 
24
        {
 
25
                if (_SSL[i].active)
 
26
                {
 
27
                        ssl_close_notify(&_SSL[i].ctx);
 
28
                        ssl_session_free(&_SSL[i].session);
 
29
                        ssl_free(&_SSL[i].ctx);
 
30
 
 
31
                        x509_free(&_SSL[i].cacert);
 
32
                        x509_free(&_SSL[i].clicert);
 
33
 
 
34
                        memset(&_SSL[i].ctx, 0, sizeof(ssl_context));
 
35
                        memset(&_SSL[i].session, 0, sizeof(ssl_session));
 
36
                        memset(&_SSL[i].hs, 0, sizeof(havege_state));
 
37
                        memset(_SSL[i].hostname, 0, NET_SSL_MAX_HOSTNAME_LEN);
 
38
 
 
39
                        _SSL[i].active = false;
 
40
                }
 
41
        }
 
42
}
 
43
 
 
44
int CWII_IPC_HLE_Device_net_ssl::getSSLFreeID()
 
45
{
 
46
        for (int i = 0; i < NET_SSL_MAXINSTANCES; i++)
 
47
        {
 
48
                if (!_SSL[i].active)
 
49
                {
 
50
                        return i + 1;
 
51
                }
 
52
        }
 
53
        return 0;
 
54
}
 
55
 
 
56
bool CWII_IPC_HLE_Device_net_ssl::Open(u32 _CommandAddress, u32 _Mode)
 
57
{
 
58
        Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
 
59
        m_Active = true;
 
60
        return true;
 
61
}
 
62
 
 
63
bool CWII_IPC_HLE_Device_net_ssl::Close(u32 _CommandAddress, bool _bForce)
 
64
{
 
65
        if (!_bForce)
 
66
        {
 
67
                Memory::Write_U32(0, _CommandAddress + 4);
 
68
        }
 
69
        m_Active = false;
 
70
        return true;
 
71
}
 
72
 
 
73
bool CWII_IPC_HLE_Device_net_ssl::IOCtl(u32 _CommandAddress)
 
74
{
 
75
        u32 BufferIn            = Memory::Read_U32(_CommandAddress + 0x10);
 
76
        u32 BufferInSize        = Memory::Read_U32(_CommandAddress + 0x14);
 
77
        u32 BufferOut           = Memory::Read_U32(_CommandAddress + 0x18);
 
78
        u32 BufferOutSize       = Memory::Read_U32(_CommandAddress + 0x1C);
 
79
        u32 Command                     = Memory::Read_U32(_CommandAddress + 0x0C);
 
80
        
 
81
        INFO_LOG(WII_IPC_SSL, "%s unknown %i "
 
82
        "(BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
 
83
                         GetDeviceName().c_str(), Command,
 
84
                         BufferIn, BufferInSize, BufferOut, BufferOutSize);
 
85
        Memory::Write_U32(0, _CommandAddress + 0x4);
 
86
        return true;
 
87
}
 
88
 
 
89
bool CWII_IPC_HLE_Device_net_ssl::IOCtlV(u32 _CommandAddress)
 
90
{
 
91
        SIOCtlVBuffer CommandBuffer(_CommandAddress);
 
92
 
 
93
        u32 _BufferIn = 0, _BufferIn2 = 0, _BufferIn3 = 0;
 
94
        u32 BufferInSize = 0, BufferInSize2 = 0, BufferInSize3 = 0;
 
95
 
 
96
        u32 BufferOut = 0, BufferOut2 = 0, BufferOut3 = 0;
 
97
        u32 BufferOutSize = 0, BufferOutSize2 = 0, BufferOutSize3 = 0;
 
98
 
 
99
        if (CommandBuffer.InBuffer.size() > 0)
 
100
        {
 
101
                _BufferIn = CommandBuffer.InBuffer.at(0).m_Address;
 
102
                BufferInSize = CommandBuffer.InBuffer.at(0).m_Size;
 
103
        }
 
104
        if (CommandBuffer.InBuffer.size() > 1)
 
105
        {
 
106
                _BufferIn2 = CommandBuffer.InBuffer.at(1).m_Address;
 
107
                BufferInSize2 = CommandBuffer.InBuffer.at(1).m_Size;
 
108
        }
 
109
        if (CommandBuffer.InBuffer.size() > 2)
 
110
        {
 
111
                _BufferIn3 = CommandBuffer.InBuffer.at(2).m_Address;
 
112
                BufferInSize3 = CommandBuffer.InBuffer.at(2).m_Size;
 
113
        }
 
114
 
 
115
        if (CommandBuffer.PayloadBuffer.size() > 0)
 
116
        {
 
117
                BufferOut = CommandBuffer.PayloadBuffer.at(0).m_Address;
 
118
                BufferOutSize = CommandBuffer.PayloadBuffer.at(0).m_Size;
 
119
        }
 
120
        if (CommandBuffer.PayloadBuffer.size() > 1)
 
121
        {
 
122
                BufferOut2 = CommandBuffer.PayloadBuffer.at(1).m_Address;
 
123
                BufferOutSize2 = CommandBuffer.PayloadBuffer.at(1).m_Size;
 
124
        }
 
125
        if (CommandBuffer.PayloadBuffer.size() > 2)
 
126
        {
 
127
                BufferOut3 = CommandBuffer.PayloadBuffer.at(2).m_Address;
 
128
                BufferOutSize3 = CommandBuffer.PayloadBuffer.at(2).m_Size;
 
129
        }
 
130
 
 
131
        switch (CommandBuffer.Parameter)
 
132
        {
 
133
        case IOCTLV_NET_SSL_NEW:
 
134
        {
 
135
                int verifyOption = Memory::Read_U32(BufferOut);
 
136
                const char * hostname = (const char*) Memory::GetPointer(BufferOut2);
 
137
 
 
138
                int freeSSL = this->getSSLFreeID();
 
139
                if (freeSSL)
 
140
                {
 
141
                        int sslID = freeSSL - 1;
 
142
                        int ret = ssl_init(&_SSL[sslID].ctx);
 
143
                        if (ret)
 
144
                        {
 
145
                                // Cleanup possibly dirty ctx
 
146
                                memset(&_SSL[sslID].ctx, 0, sizeof(ssl_context));
 
147
                                goto _SSL_NEW_ERROR;
 
148
                        }
 
149
 
 
150
                        havege_init(&_SSL[sslID].hs);
 
151
                        ssl_set_rng(&_SSL[sslID].ctx, havege_random, &_SSL[sslID].hs);
 
152
 
 
153
                        // For some reason we can't use TLSv1.2, v1.1 and below are fine!
 
154
                        ssl_set_max_version(&_SSL[sslID].ctx, SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_2);
 
155
 
 
156
                        ssl_set_ciphersuites(&_SSL[sslID].ctx, ssl_default_ciphersuites);
 
157
                        ssl_set_session(&_SSL[sslID].ctx, &_SSL[sslID].session);
 
158
 
 
159
                        ssl_set_endpoint(&_SSL[sslID].ctx, SSL_IS_CLIENT);
 
160
                        ssl_set_authmode(&_SSL[sslID].ctx, SSL_VERIFY_NONE);
 
161
                        ssl_set_renegotiation(&_SSL[sslID].ctx, SSL_RENEGOTIATION_ENABLED);
 
162
 
 
163
                        memcpy(_SSL[sslID].hostname, hostname, min((int)BufferOutSize2, NET_SSL_MAX_HOSTNAME_LEN));
 
164
                        _SSL[sslID].hostname[NET_SSL_MAX_HOSTNAME_LEN-1] = '\0';
 
165
                        ssl_set_hostname(&_SSL[sslID].ctx, _SSL[sslID].hostname);
 
166
 
 
167
                        _SSL[sslID].active = true;
 
168
                        Memory::Write_U32(freeSSL, _BufferIn);
 
169
                }
 
170
                else
 
171
                {
 
172
_SSL_NEW_ERROR:
 
173
                        Memory::Write_U32(SSL_ERR_FAILED, _BufferIn);
 
174
                }
 
175
 
 
176
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_NEW (%d, %s) "
 
177
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
178
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
179
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
180
                        verifyOption, hostname,
 
181
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
182
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
183
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
184
                break;
 
185
        }
 
186
        case IOCTLV_NET_SSL_SHUTDOWN:
 
187
        {
 
188
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
189
                if (SSLID_VALID(sslID))
 
190
                {
 
191
                        ssl_close_notify(&_SSL[sslID].ctx);
 
192
                        ssl_session_free(&_SSL[sslID].session);
 
193
                        ssl_free(&_SSL[sslID].ctx);
 
194
 
 
195
                        x509_free(&_SSL[sslID].cacert);
 
196
                        x509_free(&_SSL[sslID].clicert);
 
197
 
 
198
                        memset(&_SSL[sslID].ctx, 0, sizeof(ssl_context));
 
199
                        memset(&_SSL[sslID].session, 0, sizeof(ssl_session));
 
200
                        memset(&_SSL[sslID].hs, 0, sizeof(havege_state));
 
201
                        memset(_SSL[sslID].hostname, 0, NET_SSL_MAX_HOSTNAME_LEN);
 
202
 
 
203
                        _SSL[sslID].active = false;
 
204
 
 
205
                        Memory::Write_U32(SSL_OK, _BufferIn);
 
206
                }
 
207
                else
 
208
                {
 
209
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
210
                }
 
211
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SHUTDOWN "
 
212
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
213
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
214
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
215
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
216
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
217
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
218
                break;
 
219
        }
 
220
        case IOCTLV_NET_SSL_SETROOTCA:
 
221
        {
 
222
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETROOTCA "
 
223
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
224
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
225
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
226
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
227
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
228
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
229
 
 
230
 
 
231
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
232
                if (SSLID_VALID(sslID))
 
233
                {
 
234
                        int ret = x509parse_crt_der(
 
235
                                &_SSL[sslID].cacert,
 
236
                                Memory::GetPointer(BufferOut2),
 
237
                                BufferOutSize2);
 
238
 
 
239
                        if (ret)
 
240
                        {
 
241
                                Memory::Write_U32(SSL_ERR_FAILED, _BufferIn);
 
242
                        }
 
243
                        else
 
244
                        {
 
245
                                ssl_set_ca_chain(&_SSL[sslID].ctx, &_SSL[sslID].cacert, NULL, _SSL[sslID].hostname);
 
246
                                Memory::Write_U32(SSL_OK, _BufferIn);
 
247
                        }
 
248
 
 
249
                        INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETROOTCA = %d", ret);
 
250
                }
 
251
                else
 
252
                {
 
253
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
254
                }
 
255
                break;
 
256
        }
 
257
        case IOCTLV_NET_SSL_SETBUILTINCLIENTCERT:
 
258
        {
 
259
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT "
 
260
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
261
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
262
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
263
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
264
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
265
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
266
 
 
267
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
268
                if (SSLID_VALID(sslID))
 
269
                {
 
270
                        std::string cert_base_path(File::GetUserPath(D_WIIUSER_IDX));
 
271
                        int ret = x509parse_crtfile(&_SSL[sslID].clicert, (cert_base_path + "clientca.pem").c_str());
 
272
                        int rsa_ret = x509parse_keyfile(&_SSL[sslID].rsa, (cert_base_path + "clientcakey.pem").c_str(), NULL);
 
273
                        if (ret || rsa_ret)
 
274
                        {
 
275
                                x509_free(&_SSL[sslID].clicert);
 
276
                                rsa_free(&_SSL[sslID].rsa);
 
277
                                memset(&_SSL[sslID].clicert, 0, sizeof(x509_cert));
 
278
                                memset(&_SSL[sslID].rsa, 0, sizeof(rsa_context));
 
279
                                Memory::Write_U32(SSL_ERR_FAILED, _BufferIn);
 
280
                        }
 
281
                        else
 
282
                        {
 
283
                                ssl_set_own_cert(&_SSL[sslID].ctx, &_SSL[sslID].clicert, &_SSL[sslID].rsa);
 
284
                                Memory::Write_U32(SSL_OK, _BufferIn);
 
285
                        }
 
286
 
 
287
                        INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT = (%d, %d)", ret, rsa_ret);
 
288
                }
 
289
                else
 
290
                {
 
291
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
292
                        INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT invalid sslID = %d", sslID);
 
293
                }
 
294
                break;
 
295
        }
 
296
        case IOCTLV_NET_SSL_REMOVECLIENTCERT:
 
297
        {
 
298
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_REMOVECLIENTCERT "
 
299
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
300
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
301
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
302
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
303
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
304
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
305
 
 
306
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
307
                if (SSLID_VALID(sslID))
 
308
                {
 
309
                        x509_free(&_SSL[sslID].clicert);
 
310
                        rsa_free(&_SSL[sslID].rsa);
 
311
                        memset(&_SSL[sslID].clicert, 0, sizeof(x509_cert));
 
312
                        memset(&_SSL[sslID].rsa, 0, sizeof(rsa_context));
 
313
 
 
314
                        ssl_set_own_cert(&_SSL[sslID].ctx, NULL, NULL);
 
315
                        Memory::Write_U32(SSL_OK, _BufferIn);
 
316
                }
 
317
                else
 
318
                {
 
319
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
320
                        INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT invalid sslID = %d", sslID);
 
321
                }
 
322
                break;
 
323
        }
 
324
        case IOCTLV_NET_SSL_SETBUILTINROOTCA:
 
325
        {
 
326
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
327
                if (SSLID_VALID(sslID))
 
328
                {
 
329
                        std::string cert_base_path(File::GetUserPath(D_WIIUSER_IDX));
 
330
 
 
331
                        int ret = x509parse_crtfile(&_SSL[sslID].cacert, (cert_base_path + "rootca.pem").c_str());
 
332
                        if (ret)
 
333
                        {
 
334
                                x509_free(&_SSL[sslID].clicert);
 
335
                                Memory::Write_U32(SSL_ERR_FAILED, _BufferIn);
 
336
                        }
 
337
                        else
 
338
                        {
 
339
                                ssl_set_ca_chain(&_SSL[sslID].ctx, &_SSL[sslID].cacert, NULL, _SSL[sslID].hostname);
 
340
                                Memory::Write_U32(SSL_OK, _BufferIn);
 
341
                        }
 
342
                        INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA = %d", ret);
 
343
                }
 
344
                else
 
345
                {
 
346
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
347
                }
 
348
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA "
 
349
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
350
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
351
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
352
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
353
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
354
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
355
                break;
 
356
        }
 
357
        case IOCTLV_NET_SSL_CONNECT:
 
358
        {
 
359
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
360
                if (SSLID_VALID(sslID))
 
361
                {
 
362
                        _SSL[sslID].sockfd = Memory::Read_U32(BufferOut2);
 
363
                        INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_CONNECT socket = %d", _SSL[sslID].sockfd);
 
364
                        ssl_set_bio(&_SSL[sslID].ctx, net_recv, &_SSL[sslID].sockfd, net_send, &_SSL[sslID].sockfd);
 
365
                        Memory::Write_U32(SSL_OK, _BufferIn);
 
366
                }
 
367
                else
 
368
                {
 
369
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
370
                }
 
371
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_CONNECT "
 
372
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
373
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
374
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
375
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
376
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
377
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
378
                break;
 
379
        }
 
380
        case IOCTLV_NET_SSL_DOHANDSHAKE:
 
381
        {
 
382
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
383
                if (SSLID_VALID(sslID))
 
384
                {
 
385
                        WiiSockMan &sm = WiiSockMan::getInstance();
 
386
                        sm.doSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_DOHANDSHAKE);
 
387
                        return false;
 
388
                }
 
389
                else
 
390
                {
 
391
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
392
                }
 
393
                break;
 
394
        }
 
395
        case IOCTLV_NET_SSL_WRITE:
 
396
        {
 
397
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
398
                if (SSLID_VALID(sslID))
 
399
                {
 
400
                        WiiSockMan &sm = WiiSockMan::getInstance();
 
401
                        sm.doSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_WRITE);
 
402
                        return false;
 
403
                }
 
404
                else
 
405
                {
 
406
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
407
                }
 
408
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_WRITE "
 
409
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
410
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
411
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
412
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
413
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
414
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
415
                INFO_LOG(WII_IPC_SSL, "%s", Memory::GetPointer(BufferOut2));
 
416
                break;
 
417
        }
 
418
        case IOCTLV_NET_SSL_READ:
 
419
        {
 
420
 
 
421
                int ret = 0;
 
422
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
423
                if (SSLID_VALID(sslID))
 
424
                {
 
425
                        WiiSockMan &sm = WiiSockMan::getInstance();
 
426
                        sm.doSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_READ);
 
427
                        return false;
 
428
                }
 
429
                else
 
430
                {
 
431
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
432
                }
 
433
 
 
434
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_READ(%d)"
 
435
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
436
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
437
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
438
                        ret,
 
439
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
440
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
441
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
442
                break;
 
443
        }
 
444
        case IOCTLV_NET_SSL_SETROOTCADEFAULT:
 
445
        {
 
446
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
447
                if (SSLID_VALID(sslID))
 
448
                {
 
449
                        Memory::Write_U32(SSL_OK, _BufferIn);
 
450
                }
 
451
                else
 
452
                {
 
453
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
454
                }
 
455
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETROOTCADEFAULT "
 
456
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
457
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
458
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
459
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
460
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
461
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
462
                break;
 
463
        }
 
464
        case IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT:
 
465
        {
 
466
                INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT "
 
467
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
468
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
469
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
470
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
471
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
472
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
473
 
 
474
                int sslID = Memory::Read_U32(BufferOut) - 1;
 
475
                if (SSLID_VALID(sslID))
 
476
                {
 
477
                        Memory::Write_U32(SSL_OK, _BufferIn);
 
478
                }
 
479
                else
 
480
                {
 
481
                        Memory::Write_U32(SSL_ERR_ID, _BufferIn);
 
482
                }
 
483
                break;
 
484
        }
 
485
        default:
 
486
                ERROR_LOG(WII_IPC_SSL, "%i "
 
487
                        "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
 
488
                        "BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
 
489
                        "BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
 
490
                        CommandBuffer.Parameter,
 
491
                        _BufferIn, BufferInSize, _BufferIn2, BufferInSize2,
 
492
                        _BufferIn3, BufferInSize3, BufferOut, BufferOutSize,
 
493
                        BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
 
494
                break;
 
495
        }
 
496
        
 
497
        // SSL return codes are written to BufferIn
 
498
        Memory::Write_U32(0, _CommandAddress+4);
 
499
        
 
500
        return true;
 
501
}
 
502