1// Copyright 2014 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 "chrome/browser/extensions/api/networking_private/networking_private_api.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/callback.h"
10#include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
11#include "chrome/common/extensions/api/networking_private.h"
12#include "components/onc/onc_constants.h"
13#include "extensions/browser/extension_function_registry.h"
14
15namespace {
16
17const int kDefaultNetworkListLimit = 1000;
18
19extensions::NetworkingPrivateDelegate* GetDelegate(
20    content::BrowserContext* browser_context) {
21  return extensions::NetworkingPrivateDelegate::GetForBrowserContext(
22      browser_context);
23}
24
25}  // namespace
26
27namespace private_api = extensions::api::networking_private;
28
29namespace extensions {
30
31namespace networking_private {
32
33// static
34const char kErrorInvalidNetworkGuid[] = "Error.InvalidNetworkGuid";
35const char kErrorNetworkUnavailable[] = "Error.NetworkUnavailable";
36const char kErrorEncryptionError[] = "Error.EncryptionError";
37const char kErrorNotReady[] = "Error.NotReady";
38const char kErrorNotSupported[] = "Error.NotSupported";
39
40}  // namespace networking_private
41
42////////////////////////////////////////////////////////////////////////////////
43// NetworkingPrivateGetPropertiesFunction
44
45NetworkingPrivateGetPropertiesFunction::
46    ~NetworkingPrivateGetPropertiesFunction() {
47}
48
49bool NetworkingPrivateGetPropertiesFunction::RunAsync() {
50  scoped_ptr<private_api::GetProperties::Params> params =
51      private_api::GetProperties::Params::Create(*args_);
52  EXTENSION_FUNCTION_VALIDATE(params);
53
54  GetDelegate(browser_context())->GetProperties(
55      params->network_guid,
56      base::Bind(&NetworkingPrivateGetPropertiesFunction::Success, this),
57      base::Bind(&NetworkingPrivateGetPropertiesFunction::Failure, this));
58  return true;
59}
60
61void NetworkingPrivateGetPropertiesFunction::Success(
62    scoped_ptr<base::DictionaryValue> result) {
63  SetResult(result.release());
64  SendResponse(true);
65}
66
67void NetworkingPrivateGetPropertiesFunction::Failure(const std::string& error) {
68  error_ = error;
69  SendResponse(false);
70}
71
72////////////////////////////////////////////////////////////////////////////////
73// NetworkingPrivateGetManagedPropertiesFunction
74
75NetworkingPrivateGetManagedPropertiesFunction::
76    ~NetworkingPrivateGetManagedPropertiesFunction() {
77}
78
79bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() {
80  scoped_ptr<private_api::GetManagedProperties::Params> params =
81      private_api::GetManagedProperties::Params::Create(*args_);
82  EXTENSION_FUNCTION_VALIDATE(params);
83
84  GetDelegate(browser_context())->GetManagedProperties(
85      params->network_guid,
86      base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success, this),
87      base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
88                 this));
89  return true;
90}
91
92void NetworkingPrivateGetManagedPropertiesFunction::Success(
93    scoped_ptr<base::DictionaryValue> result) {
94  SetResult(result.release());
95  SendResponse(true);
96}
97
98void NetworkingPrivateGetManagedPropertiesFunction::Failure(
99    const std::string& error) {
100  error_ = error;
101  SendResponse(false);
102}
103
104////////////////////////////////////////////////////////////////////////////////
105// NetworkingPrivateGetStateFunction
106
107NetworkingPrivateGetStateFunction::~NetworkingPrivateGetStateFunction() {
108}
109
110bool NetworkingPrivateGetStateFunction::RunAsync() {
111  scoped_ptr<private_api::GetState::Params> params =
112      private_api::GetState::Params::Create(*args_);
113  EXTENSION_FUNCTION_VALIDATE(params);
114
115  GetDelegate(browser_context())->GetState(
116      params->network_guid,
117      base::Bind(&NetworkingPrivateGetStateFunction::Success, this),
118      base::Bind(&NetworkingPrivateGetStateFunction::Failure, this));
119  return true;
120}
121
122void NetworkingPrivateGetStateFunction::Success(
123    scoped_ptr<base::DictionaryValue> result) {
124  SetResult(result.release());
125  SendResponse(true);
126}
127
128void NetworkingPrivateGetStateFunction::Failure(const std::string& error) {
129  error_ = error;
130  SendResponse(false);
131}
132
133////////////////////////////////////////////////////////////////////////////////
134// NetworkingPrivateSetPropertiesFunction
135
136NetworkingPrivateSetPropertiesFunction::
137    ~NetworkingPrivateSetPropertiesFunction() {
138}
139
140bool NetworkingPrivateSetPropertiesFunction::RunAsync() {
141  scoped_ptr<private_api::SetProperties::Params> params =
142      private_api::SetProperties::Params::Create(*args_);
143  EXTENSION_FUNCTION_VALIDATE(params);
144
145  scoped_ptr<base::DictionaryValue> properties_dict(
146      params->properties.ToValue());
147
148  GetDelegate(browser_context())->SetProperties(
149      params->network_guid,
150      properties_dict.Pass(),
151      base::Bind(&NetworkingPrivateSetPropertiesFunction::Success, this),
152      base::Bind(&NetworkingPrivateSetPropertiesFunction::Failure, this));
153  return true;
154}
155
156void NetworkingPrivateSetPropertiesFunction::Success() {
157  SendResponse(true);
158}
159
160void NetworkingPrivateSetPropertiesFunction::Failure(const std::string& error) {
161  error_ = error;
162  SendResponse(false);
163}
164
165////////////////////////////////////////////////////////////////////////////////
166// NetworkingPrivateCreateNetworkFunction
167
168NetworkingPrivateCreateNetworkFunction::
169    ~NetworkingPrivateCreateNetworkFunction() {
170}
171
172bool NetworkingPrivateCreateNetworkFunction::RunAsync() {
173  scoped_ptr<private_api::CreateNetwork::Params> params =
174      private_api::CreateNetwork::Params::Create(*args_);
175  EXTENSION_FUNCTION_VALIDATE(params);
176
177  scoped_ptr<base::DictionaryValue> properties_dict(
178      params->properties.ToValue());
179
180  GetDelegate(browser_context())->CreateNetwork(
181      params->shared,
182      properties_dict.Pass(),
183      base::Bind(&NetworkingPrivateCreateNetworkFunction::Success, this),
184      base::Bind(&NetworkingPrivateCreateNetworkFunction::Failure, this));
185  return true;
186}
187
188void NetworkingPrivateCreateNetworkFunction::Success(const std::string& guid) {
189  results_ = private_api::CreateNetwork::Results::Create(guid);
190  SendResponse(true);
191}
192
193void NetworkingPrivateCreateNetworkFunction::Failure(const std::string& error) {
194  error_ = error;
195  SendResponse(false);
196}
197
198////////////////////////////////////////////////////////////////////////////////
199// NetworkingPrivateGetNetworksFunction
200
201NetworkingPrivateGetNetworksFunction::~NetworkingPrivateGetNetworksFunction() {
202}
203
204bool NetworkingPrivateGetNetworksFunction::RunAsync() {
205  scoped_ptr<private_api::GetNetworks::Params> params =
206      private_api::GetNetworks::Params::Create(*args_);
207  EXTENSION_FUNCTION_VALIDATE(params);
208
209  std::string network_type = private_api::ToString(params->filter.network_type);
210  const bool configured_only =
211      params->filter.configured ? *params->filter.configured : false;
212  const bool visible_only =
213      params->filter.visible ? *params->filter.visible : false;
214  const int limit =
215      params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit;
216
217  GetDelegate(browser_context())->GetNetworks(
218      network_type,
219      configured_only,
220      visible_only,
221      limit,
222      base::Bind(&NetworkingPrivateGetNetworksFunction::Success, this),
223      base::Bind(&NetworkingPrivateGetNetworksFunction::Failure, this));
224  return true;
225}
226
227void NetworkingPrivateGetNetworksFunction::Success(
228    scoped_ptr<base::ListValue> network_list) {
229  SetResult(network_list.release());
230  SendResponse(true);
231}
232
233void NetworkingPrivateGetNetworksFunction::Failure(const std::string& error) {
234  error_ = error;
235  SendResponse(false);
236}
237
238////////////////////////////////////////////////////////////////////////////////
239// NetworkingPrivateGetVisibleNetworksFunction
240
241NetworkingPrivateGetVisibleNetworksFunction::
242    ~NetworkingPrivateGetVisibleNetworksFunction() {
243}
244
245bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() {
246  scoped_ptr<private_api::GetVisibleNetworks::Params> params =
247      private_api::GetVisibleNetworks::Params::Create(*args_);
248  EXTENSION_FUNCTION_VALIDATE(params);
249
250  std::string network_type = private_api::ToString(params->network_type);
251  const bool configured_only = false;
252  const bool visible_only = true;
253
254  GetDelegate(browser_context())->GetNetworks(
255      network_type,
256      configured_only,
257      visible_only,
258      kDefaultNetworkListLimit,
259      base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Success, this),
260      base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Failure, this));
261  return true;
262}
263
264void NetworkingPrivateGetVisibleNetworksFunction::Success(
265    scoped_ptr<base::ListValue> network_properties_list) {
266  SetResult(network_properties_list.release());
267  SendResponse(true);
268}
269
270void NetworkingPrivateGetVisibleNetworksFunction::Failure(
271    const std::string& error) {
272  error_ = error;
273  SendResponse(false);
274}
275
276////////////////////////////////////////////////////////////////////////////////
277// NetworkingPrivateGetEnabledNetworkTypesFunction
278
279NetworkingPrivateGetEnabledNetworkTypesFunction::
280    ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
281}
282
283bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
284  scoped_ptr<base::ListValue> enabled_networks_onc_types(
285      GetDelegate(browser_context())->GetEnabledNetworkTypes());
286  if (!enabled_networks_onc_types) {
287    error_ = networking_private::kErrorNotSupported;
288    return false;
289  }
290  scoped_ptr<base::ListValue> enabled_networks_list(new base::ListValue);
291  for (base::ListValue::iterator iter = enabled_networks_onc_types->begin();
292       iter != enabled_networks_onc_types->end(); ++iter) {
293    std::string type;
294    if (!(*iter)->GetAsString(&type))
295      NOTREACHED();
296    if (type == ::onc::network_type::kEthernet) {
297      enabled_networks_list->AppendString(api::networking_private::ToString(
298          api::networking_private::NETWORK_TYPE_ETHERNET));
299    } else if (type == ::onc::network_type::kWiFi) {
300      enabled_networks_list->AppendString(api::networking_private::ToString(
301          api::networking_private::NETWORK_TYPE_WIFI));
302    } else if (type == ::onc::network_type::kWimax) {
303      enabled_networks_list->AppendString(api::networking_private::ToString(
304          api::networking_private::NETWORK_TYPE_WIMAX));
305    } else if (type == ::onc::network_type::kCellular) {
306      enabled_networks_list->AppendString(api::networking_private::ToString(
307          api::networking_private::NETWORK_TYPE_CELLULAR));
308    } else {
309      LOG(ERROR) << "networkingPrivate: Unexpected type: " << type;
310    }
311  }
312  SetResult(enabled_networks_list.release());
313  return true;
314}
315
316////////////////////////////////////////////////////////////////////////////////
317// NetworkingPrivateEnableNetworkTypeFunction
318
319NetworkingPrivateEnableNetworkTypeFunction::
320    ~NetworkingPrivateEnableNetworkTypeFunction() {
321}
322
323bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
324  scoped_ptr<private_api::EnableNetworkType::Params> params =
325      private_api::EnableNetworkType::Params::Create(*args_);
326  EXTENSION_FUNCTION_VALIDATE(params);
327
328  return GetDelegate(browser_context())->EnableNetworkType(
329      private_api::ToString(params->network_type));
330}
331
332////////////////////////////////////////////////////////////////////////////////
333// NetworkingPrivateDisableNetworkTypeFunction
334
335NetworkingPrivateDisableNetworkTypeFunction::
336    ~NetworkingPrivateDisableNetworkTypeFunction() {
337}
338
339bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
340  scoped_ptr<private_api::DisableNetworkType::Params> params =
341      private_api::DisableNetworkType::Params::Create(*args_);
342
343  return GetDelegate(browser_context())->DisableNetworkType(
344      private_api::ToString(params->network_type));
345}
346
347////////////////////////////////////////////////////////////////////////////////
348// NetworkingPrivateRequestNetworkScanFunction
349
350NetworkingPrivateRequestNetworkScanFunction::
351    ~NetworkingPrivateRequestNetworkScanFunction() {
352}
353
354bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
355  return GetDelegate(browser_context())->RequestScan();
356}
357
358////////////////////////////////////////////////////////////////////////////////
359// NetworkingPrivateStartConnectFunction
360
361NetworkingPrivateStartConnectFunction::
362    ~NetworkingPrivateStartConnectFunction() {
363}
364
365bool NetworkingPrivateStartConnectFunction::RunAsync() {
366  scoped_ptr<private_api::StartConnect::Params> params =
367      private_api::StartConnect::Params::Create(*args_);
368  EXTENSION_FUNCTION_VALIDATE(params);
369
370  GetDelegate(browser_context())->StartConnect(
371      params->network_guid,
372      base::Bind(&NetworkingPrivateStartConnectFunction::Success, this),
373      base::Bind(&NetworkingPrivateStartConnectFunction::Failure, this));
374  return true;
375}
376
377void NetworkingPrivateStartConnectFunction::Success() {
378  SendResponse(true);
379}
380
381void NetworkingPrivateStartConnectFunction::Failure(const std::string& error) {
382  error_ = error;
383  SendResponse(false);
384}
385
386////////////////////////////////////////////////////////////////////////////////
387// NetworkingPrivateStartDisconnectFunction
388
389NetworkingPrivateStartDisconnectFunction::
390    ~NetworkingPrivateStartDisconnectFunction() {
391}
392
393bool NetworkingPrivateStartDisconnectFunction::RunAsync() {
394  scoped_ptr<private_api::StartDisconnect::Params> params =
395      private_api::StartDisconnect::Params::Create(*args_);
396  EXTENSION_FUNCTION_VALIDATE(params);
397
398  GetDelegate(browser_context())->StartDisconnect(
399      params->network_guid,
400      base::Bind(&NetworkingPrivateStartDisconnectFunction::Success, this),
401      base::Bind(&NetworkingPrivateStartDisconnectFunction::Failure, this));
402  return true;
403}
404
405void NetworkingPrivateStartDisconnectFunction::Success() {
406  SendResponse(true);
407}
408
409void NetworkingPrivateStartDisconnectFunction::Failure(
410    const std::string& error) {
411  error_ = error;
412  SendResponse(false);
413}
414
415////////////////////////////////////////////////////////////////////////////////
416// NetworkingPrivateVerifyDestinationFunction
417
418NetworkingPrivateVerifyDestinationFunction::
419    ~NetworkingPrivateVerifyDestinationFunction() {
420}
421
422bool NetworkingPrivateVerifyDestinationFunction::RunAsync() {
423  scoped_ptr<private_api::VerifyDestination::Params> params =
424      private_api::VerifyDestination::Params::Create(*args_);
425  EXTENSION_FUNCTION_VALIDATE(params);
426
427  GetDelegate(browser_context())->VerifyDestination(
428      params->properties,
429      base::Bind(&NetworkingPrivateVerifyDestinationFunction::Success, this),
430      base::Bind(&NetworkingPrivateVerifyDestinationFunction::Failure, this));
431  return true;
432}
433
434void NetworkingPrivateVerifyDestinationFunction::Success(bool result) {
435  results_ = private_api::VerifyDestination::Results::Create(result);
436  SendResponse(true);
437}
438
439void NetworkingPrivateVerifyDestinationFunction::Failure(
440    const std::string& error) {
441  error_ = error;
442  SendResponse(false);
443}
444
445////////////////////////////////////////////////////////////////////////////////
446// NetworkingPrivateVerifyAndEncryptCredentialsFunction
447
448NetworkingPrivateVerifyAndEncryptCredentialsFunction::
449    ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
450}
451
452bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() {
453  scoped_ptr<private_api::VerifyAndEncryptCredentials::Params> params =
454      private_api::VerifyAndEncryptCredentials::Params::Create(*args_);
455  EXTENSION_FUNCTION_VALIDATE(params);
456
457  GetDelegate(browser_context())->VerifyAndEncryptCredentials(
458      params->network_guid,
459      params->properties,
460      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
461                 this),
462      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
463                 this));
464  return true;
465}
466
467void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success(
468    const std::string& result) {
469  results_ = private_api::VerifyAndEncryptCredentials::Results::Create(result);
470  SendResponse(true);
471}
472
473void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure(
474    const std::string& error) {
475  error_ = error;
476  SendResponse(false);
477}
478
479////////////////////////////////////////////////////////////////////////////////
480// NetworkingPrivateVerifyAndEncryptDataFunction
481
482NetworkingPrivateVerifyAndEncryptDataFunction::
483    ~NetworkingPrivateVerifyAndEncryptDataFunction() {
484}
485
486bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() {
487  scoped_ptr<private_api::VerifyAndEncryptData::Params> params =
488      private_api::VerifyAndEncryptData::Params::Create(*args_);
489  EXTENSION_FUNCTION_VALIDATE(params);
490
491  GetDelegate(browser_context())->VerifyAndEncryptData(
492      params->properties,
493      params->data,
494      base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Success, this),
495      base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Failure,
496                 this));
497  return true;
498}
499
500void NetworkingPrivateVerifyAndEncryptDataFunction::Success(
501    const std::string& result) {
502  results_ = private_api::VerifyAndEncryptData::Results::Create(result);
503  SendResponse(true);
504}
505
506void NetworkingPrivateVerifyAndEncryptDataFunction::Failure(
507    const std::string& error) {
508  error_ = error;
509  SendResponse(false);
510}
511
512////////////////////////////////////////////////////////////////////////////////
513// NetworkingPrivateSetWifiTDLSEnabledStateFunction
514
515NetworkingPrivateSetWifiTDLSEnabledStateFunction::
516    ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
517}
518
519bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() {
520  scoped_ptr<private_api::SetWifiTDLSEnabledState::Params> params =
521      private_api::SetWifiTDLSEnabledState::Params::Create(*args_);
522  EXTENSION_FUNCTION_VALIDATE(params);
523
524  GetDelegate(browser_context())->SetWifiTDLSEnabledState(
525      params->ip_or_mac_address,
526      params->enabled,
527      base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success,
528                 this),
529      base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure,
530                 this));
531
532  return true;
533}
534
535void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success(
536    const std::string& result) {
537  results_ = private_api::SetWifiTDLSEnabledState::Results::Create(result);
538  SendResponse(true);
539}
540
541void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure(
542    const std::string& error) {
543  error_ = error;
544  SendResponse(false);
545}
546
547////////////////////////////////////////////////////////////////////////////////
548// NetworkingPrivateGetWifiTDLSStatusFunction
549
550NetworkingPrivateGetWifiTDLSStatusFunction::
551    ~NetworkingPrivateGetWifiTDLSStatusFunction() {
552}
553
554bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() {
555  scoped_ptr<private_api::GetWifiTDLSStatus::Params> params =
556      private_api::GetWifiTDLSStatus::Params::Create(*args_);
557  EXTENSION_FUNCTION_VALIDATE(params);
558
559  GetDelegate(browser_context())->GetWifiTDLSStatus(
560      params->ip_or_mac_address,
561      base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Success, this),
562      base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Failure, this));
563
564  return true;
565}
566
567void NetworkingPrivateGetWifiTDLSStatusFunction::Success(
568    const std::string& result) {
569  results_ = private_api::GetWifiTDLSStatus::Results::Create(result);
570  SendResponse(true);
571}
572
573void NetworkingPrivateGetWifiTDLSStatusFunction::Failure(
574    const std::string& error) {
575  error_ = error;
576  SendResponse(false);
577}
578
579////////////////////////////////////////////////////////////////////////////////
580// NetworkingPrivateGetCaptivePortalStatusFunction
581
582NetworkingPrivateGetCaptivePortalStatusFunction::
583    ~NetworkingPrivateGetCaptivePortalStatusFunction() {
584}
585
586bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() {
587  scoped_ptr<private_api::GetCaptivePortalStatus::Params> params =
588      private_api::GetCaptivePortalStatus::Params::Create(*args_);
589  EXTENSION_FUNCTION_VALIDATE(params);
590
591  GetDelegate(browser_context())->GetCaptivePortalStatus(
592      params->network_guid,
593      base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Success,
594                 this),
595      base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Failure,
596                 this));
597  return true;
598}
599
600void NetworkingPrivateGetCaptivePortalStatusFunction::Success(
601    const std::string& result) {
602  results_ = private_api::GetCaptivePortalStatus::Results::Create(
603      private_api::ParseCaptivePortalStatus(result));
604  SendResponse(true);
605}
606
607void NetworkingPrivateGetCaptivePortalStatusFunction::Failure(
608    const std::string& error) {
609  error_ = error;
610  SendResponse(false);
611}
612
613}  // namespace extensions
614