1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ppapi/c/pp_completion_callback.h"
6#include "ppapi/c/pp_errors.h"
7#include "ppapi/c/private/ppb_tcp_socket_private.h"
8#include "ppapi/shared_impl/tracked_callback.h"
9#include "ppapi/thunk/enter.h"
10#include "ppapi/thunk/thunk.h"
11#include "ppapi/thunk/ppb_tcp_socket_private_api.h"
12#include "ppapi/thunk/resource_creation_api.h"
13
14namespace ppapi {
15namespace thunk {
16
17namespace {
18
19typedef EnterResource<PPB_TCPSocket_Private_API> EnterTCP;
20
21PP_Resource Create(PP_Instance instance) {
22  EnterResourceCreation enter(instance);
23  if (enter.failed())
24    return 0;
25  return enter.functions()->CreateTCPSocketPrivate(instance);
26}
27
28PP_Bool IsTCPSocket(PP_Resource resource) {
29  EnterTCP enter(resource, false);
30  return PP_FromBool(enter.succeeded());
31}
32
33int32_t Connect(PP_Resource tcp_socket,
34                const char* host,
35                uint16_t port,
36                PP_CompletionCallback callback) {
37  EnterTCP enter(tcp_socket, callback, true);
38  if (enter.failed())
39    return enter.retval();
40  return enter.SetResult(enter.object()->Connect(host, port, enter.callback()));
41}
42
43int32_t ConnectWithNetAddress(PP_Resource tcp_socket,
44                              const PP_NetAddress_Private* addr,
45                              PP_CompletionCallback callback) {
46  EnterTCP enter(tcp_socket, callback, true);
47  if (enter.failed())
48    return enter.retval();
49  return enter.SetResult(
50      enter.object()->ConnectWithNetAddress(addr, enter.callback()));
51}
52
53PP_Bool GetLocalAddress(PP_Resource tcp_socket,
54                        PP_NetAddress_Private* local_addr) {
55  EnterTCP enter(tcp_socket, true);
56  if (enter.failed())
57    return PP_FALSE;
58  return enter.object()->GetLocalAddress(local_addr);
59}
60
61PP_Bool GetRemoteAddress(PP_Resource tcp_socket,
62                         PP_NetAddress_Private* remote_addr) {
63  EnterTCP enter(tcp_socket, true);
64  if (enter.failed())
65    return PP_FALSE;
66  return enter.object()->GetRemoteAddress(remote_addr);
67}
68
69int32_t SSLHandshake(PP_Resource tcp_socket,
70                     const char* server_name,
71                     uint16_t server_port,
72                     PP_CompletionCallback callback) {
73  EnterTCP enter(tcp_socket, callback, true);
74  if (enter.failed())
75    return enter.retval();
76  return enter.SetResult(enter.object()->SSLHandshake(server_name, server_port,
77                                                      enter.callback()));
78}
79
80PP_Resource GetServerCertificate(PP_Resource tcp_socket) {
81  EnterTCP enter(tcp_socket, true);
82  if (enter.failed())
83    return 0;
84  return enter.object()->GetServerCertificate();
85}
86
87PP_Bool AddChainBuildingCertificate(PP_Resource tcp_socket,
88                                    PP_Resource certificate,
89                                    PP_Bool trusted) {
90  EnterTCP enter(tcp_socket, true);
91  if (enter.failed())
92    return PP_FALSE;
93  return enter.object()->AddChainBuildingCertificate(certificate, trusted);
94}
95
96int32_t Read(PP_Resource tcp_socket,
97             char* buffer,
98             int32_t bytes_to_read,
99             PP_CompletionCallback callback) {
100  EnterTCP enter(tcp_socket, callback, true);
101  if (enter.failed())
102    return enter.retval();
103  return enter.SetResult(enter.object()->Read(buffer, bytes_to_read,
104                                              enter.callback()));
105}
106
107int32_t Write(PP_Resource tcp_socket,
108              const char* buffer,
109              int32_t bytes_to_write,
110              PP_CompletionCallback callback) {
111  EnterTCP enter(tcp_socket, callback, true);
112  if (enter.failed())
113    return enter.retval();
114  return enter.SetResult(enter.object()->Write(buffer, bytes_to_write,
115                                               enter.callback()));
116}
117
118void Disconnect(PP_Resource tcp_socket) {
119  EnterTCP enter(tcp_socket, true);
120  if (enter.succeeded())
121    enter.object()->Disconnect();
122}
123
124int32_t SetOption(PP_Resource tcp_socket,
125                  PP_TCPSocketOption_Private name,
126                  PP_Var value,
127                  PP_CompletionCallback callback) {
128  EnterTCP enter(tcp_socket, callback, true);
129  if (enter.failed())
130    return enter.retval();
131  return enter.SetResult(
132      enter.object()->SetOption(name, value, enter.callback()));
133}
134
135const PPB_TCPSocket_Private_0_3 g_ppb_tcp_socket_thunk_0_3 = {
136  &Create,
137  &IsTCPSocket,
138  &Connect,
139  &ConnectWithNetAddress,
140  &GetLocalAddress,
141  &GetRemoteAddress,
142  &SSLHandshake,
143  &Read,
144  &Write,
145  &Disconnect
146};
147
148const PPB_TCPSocket_Private_0_4 g_ppb_tcp_socket_thunk_0_4 = {
149  &Create,
150  &IsTCPSocket,
151  &Connect,
152  &ConnectWithNetAddress,
153  &GetLocalAddress,
154  &GetRemoteAddress,
155  &SSLHandshake,
156  &GetServerCertificate,
157  &AddChainBuildingCertificate,
158  &Read,
159  &Write,
160  &Disconnect
161};
162
163const PPB_TCPSocket_Private_0_5 g_ppb_tcp_socket_thunk_0_5 = {
164  &Create,
165  &IsTCPSocket,
166  &Connect,
167  &ConnectWithNetAddress,
168  &GetLocalAddress,
169  &GetRemoteAddress,
170  &SSLHandshake,
171  &GetServerCertificate,
172  &AddChainBuildingCertificate,
173  &Read,
174  &Write,
175  &Disconnect,
176  &SetOption
177};
178
179}  // namespace
180
181const PPB_TCPSocket_Private_0_3* GetPPB_TCPSocket_Private_0_3_Thunk() {
182  return &g_ppb_tcp_socket_thunk_0_3;
183}
184
185const PPB_TCPSocket_Private_0_4* GetPPB_TCPSocket_Private_0_4_Thunk() {
186  return &g_ppb_tcp_socket_thunk_0_4;
187}
188
189const PPB_TCPSocket_Private_0_5* GetPPB_TCPSocket_Private_0_5_Thunk() {
190  return &g_ppb_tcp_socket_thunk_0_5;
191}
192
193}  // namespace thunk
194}  // namespace ppapi
195