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/cpp/private/net_address_private.h"
6 
7 #include "ppapi/c/pp_bool.h"
8 #include "ppapi/cpp/module.h"
9 #include "ppapi/cpp/module_impl.h"
10 #include "ppapi/cpp/var.h"
11 
12 namespace pp {
13 
14 namespace {
15 
interface_name()16 template <> const char* interface_name<PPB_NetAddress_Private_1_1>() {
17   return PPB_NETADDRESS_PRIVATE_INTERFACE_1_1;
18 }
19 
interface_name()20 template <> const char* interface_name<PPB_NetAddress_Private_1_0>() {
21   return PPB_NETADDRESS_PRIVATE_INTERFACE_1_0;
22 }
23 
interface_name()24 template <> const char* interface_name<PPB_NetAddress_Private_0_1>() {
25   return PPB_NETADDRESS_PRIVATE_INTERFACE_0_1;
26 }
27 
28 }  // namespace
29 
30 // static
IsAvailable()31 bool NetAddressPrivate::IsAvailable() {
32   return has_interface<PPB_NetAddress_Private_1_1>() ||
33       has_interface<PPB_NetAddress_Private_1_0>() ||
34       has_interface<PPB_NetAddress_Private_0_1>();
35 }
36 
37 // static
AreEqual(const PP_NetAddress_Private & addr1,const PP_NetAddress_Private & addr2)38 bool NetAddressPrivate::AreEqual(const PP_NetAddress_Private& addr1,
39                                  const PP_NetAddress_Private& addr2) {
40   if (has_interface<PPB_NetAddress_Private_1_1>()) {
41     return !!get_interface<PPB_NetAddress_Private_1_1>()->AreEqual(&addr1,
42                                                                    &addr2);
43   }
44   if (has_interface<PPB_NetAddress_Private_1_0>()) {
45     return !!get_interface<PPB_NetAddress_Private_1_0>()->AreEqual(&addr1,
46                                                                    &addr2);
47   }
48   if (has_interface<PPB_NetAddress_Private_0_1>()) {
49     return !!get_interface<PPB_NetAddress_Private_0_1>()->AreEqual(&addr1,
50                                                                    &addr2);
51   }
52   return false;
53 }
54 
55 // static
AreHostsEqual(const PP_NetAddress_Private & addr1,const PP_NetAddress_Private & addr2)56 bool NetAddressPrivate::AreHostsEqual(const PP_NetAddress_Private& addr1,
57                                       const PP_NetAddress_Private& addr2) {
58   if (has_interface<PPB_NetAddress_Private_1_1>()) {
59     return !!get_interface<PPB_NetAddress_Private_1_1>()->AreHostsEqual(&addr1,
60                                                                         &addr2);
61   }
62   if (has_interface<PPB_NetAddress_Private_1_0>()) {
63     return !!get_interface<PPB_NetAddress_Private_1_0>()->AreHostsEqual(&addr1,
64                                                                         &addr2);
65   }
66   if (has_interface<PPB_NetAddress_Private_0_1>()) {
67     return !!get_interface<PPB_NetAddress_Private_0_1>()->AreHostsEqual(&addr1,
68                                                                         &addr2);
69   }
70   return false;
71 }
72 
73 // static
Describe(const PP_NetAddress_Private & addr,bool include_port)74 std::string NetAddressPrivate::Describe(const PP_NetAddress_Private& addr,
75                                         bool include_port) {
76   Module* module = Module::Get();
77   if (!module)
78     return std::string();
79 
80   PP_Var result_pp_var = PP_MakeUndefined();
81   if (has_interface<PPB_NetAddress_Private_1_1>()) {
82     result_pp_var = get_interface<PPB_NetAddress_Private_1_1>()->Describe(
83         module->pp_module(),
84         &addr,
85         PP_FromBool(include_port));
86   } else if (has_interface<PPB_NetAddress_Private_1_0>()) {
87     result_pp_var = get_interface<PPB_NetAddress_Private_1_0>()->Describe(
88         module->pp_module(),
89         &addr,
90         PP_FromBool(include_port));
91   } else if (has_interface<PPB_NetAddress_Private_0_1>()) {
92     result_pp_var = get_interface<PPB_NetAddress_Private_0_1>()->Describe(
93         module->pp_module(),
94         &addr,
95         PP_FromBool(include_port));
96   }
97 
98   Var result(PASS_REF, result_pp_var);
99   return result.is_string() ? result.AsString() : std::string();
100 }
101 
102 // static
ReplacePort(const PP_NetAddress_Private & addr_in,uint16_t port,PP_NetAddress_Private * addr_out)103 bool NetAddressPrivate::ReplacePort(const PP_NetAddress_Private& addr_in,
104                                     uint16_t port,
105                                     PP_NetAddress_Private* addr_out) {
106   if (has_interface<PPB_NetAddress_Private_1_1>()) {
107     return !!get_interface<PPB_NetAddress_Private_1_1>()->ReplacePort(&addr_in,
108                                                                       port,
109                                                                       addr_out);
110   }
111   if (has_interface<PPB_NetAddress_Private_1_0>()) {
112     return !!get_interface<PPB_NetAddress_Private_1_0>()->ReplacePort(&addr_in,
113                                                                       port,
114                                                                       addr_out);
115   }
116   if (has_interface<PPB_NetAddress_Private_0_1>()) {
117     return !!get_interface<PPB_NetAddress_Private_0_1>()->ReplacePort(&addr_in,
118                                                                       port,
119                                                                       addr_out);
120   }
121   return false;
122 }
123 
124 // static
GetAnyAddress(bool is_ipv6,PP_NetAddress_Private * addr)125 bool NetAddressPrivate::GetAnyAddress(bool is_ipv6,
126                                       PP_NetAddress_Private* addr) {
127   if (has_interface<PPB_NetAddress_Private_1_1>()) {
128     get_interface<PPB_NetAddress_Private_1_1>()->GetAnyAddress(
129         PP_FromBool(is_ipv6),
130         addr);
131     return true;
132   } else if (has_interface<PPB_NetAddress_Private_1_0>()) {
133     get_interface<PPB_NetAddress_Private_1_0>()->GetAnyAddress(
134         PP_FromBool(is_ipv6),
135         addr);
136     return true;
137   } else if (has_interface<PPB_NetAddress_Private_0_1>()) {
138     get_interface<PPB_NetAddress_Private_0_1>()->GetAnyAddress(
139         PP_FromBool(is_ipv6),
140         addr);
141     return true;
142   }
143   return false;
144 }
145 
146 // static
GetFamily(const PP_NetAddress_Private & addr)147 PP_NetAddressFamily_Private NetAddressPrivate::GetFamily(
148     const PP_NetAddress_Private& addr) {
149   if (has_interface<PPB_NetAddress_Private_1_1>())
150     return get_interface<PPB_NetAddress_Private_1_1>()->GetFamily(&addr);
151   if (has_interface<PPB_NetAddress_Private_1_0>())
152     return get_interface<PPB_NetAddress_Private_1_0>()->GetFamily(&addr);
153   return PP_NETADDRESSFAMILY_PRIVATE_UNSPECIFIED;
154 }
155 
156 // static
GetPort(const PP_NetAddress_Private & addr)157 uint16_t NetAddressPrivate::GetPort(const PP_NetAddress_Private& addr) {
158   if (has_interface<PPB_NetAddress_Private_1_1>())
159     return get_interface<PPB_NetAddress_Private_1_1>()->GetPort(&addr);
160   if (has_interface<PPB_NetAddress_Private_1_0>())
161     return get_interface<PPB_NetAddress_Private_1_0>()->GetPort(&addr);
162   return 0;
163 }
164 
165 // static
GetAddress(const PP_NetAddress_Private & addr,void * address,uint16_t address_size)166 bool NetAddressPrivate::GetAddress(const PP_NetAddress_Private& addr,
167                                    void* address,
168                                    uint16_t address_size) {
169   if (has_interface<PPB_NetAddress_Private_1_1>()) {
170     return PP_ToBool(get_interface<PPB_NetAddress_Private_1_1>()->GetAddress(
171         &addr,
172         address,
173         address_size));
174   }
175   if (has_interface<PPB_NetAddress_Private_1_0>()) {
176     return PP_ToBool(get_interface<PPB_NetAddress_Private_1_0>()->GetAddress(
177         &addr,
178         address,
179         address_size));
180   }
181   return false;
182 }
183 
184 // static
GetScopeID(const PP_NetAddress_Private & addr)185 uint32_t NetAddressPrivate::GetScopeID(const PP_NetAddress_Private& addr) {
186   if (has_interface<PPB_NetAddress_Private_1_1>())
187     return get_interface<PPB_NetAddress_Private_1_1>()->GetScopeID(&addr);
188   return 0;
189 }
190 
191 // static
CreateFromIPv4Address(const uint8_t ip[4],uint16_t port,struct PP_NetAddress_Private * addr_out)192 bool NetAddressPrivate::CreateFromIPv4Address(
193     const uint8_t ip[4],
194     uint16_t port,
195     struct PP_NetAddress_Private* addr_out) {
196   if (has_interface<PPB_NetAddress_Private_1_1>()) {
197     get_interface<PPB_NetAddress_Private_1_1>()->CreateFromIPv4Address(
198         ip, port, addr_out);
199     return true;
200   }
201   return false;
202 }
203 
204 // static
CreateFromIPv6Address(const uint8_t ip[16],uint32_t scope_id,uint16_t port,struct PP_NetAddress_Private * addr_out)205 bool NetAddressPrivate::CreateFromIPv6Address(
206     const uint8_t ip[16],
207     uint32_t scope_id,
208     uint16_t port,
209     struct PP_NetAddress_Private* addr_out) {
210   if (has_interface<PPB_NetAddress_Private_1_1>()) {
211     get_interface<PPB_NetAddress_Private_1_1>()->CreateFromIPv6Address(
212         ip, scope_id, port, addr_out);
213     return true;
214   }
215   return false;
216 }
217 
218 }  // namespace pp
219