1 // Copyright 2013 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/chromeos/net/network_portal_detector.h"
11 #include "chrome/browser/chromeos/profiles/profile_helper.h"
12 #include "chrome/common/extensions/api/networking_private.h"
13 #include "chromeos/dbus/dbus_thread_manager.h"
14 #include "chromeos/dbus/shill_manager_client.h"
15 #include "chromeos/login/login_state.h"
16 #include "chromeos/network/managed_network_configuration_handler.h"
17 #include "chromeos/network/network_connection_handler.h"
18 #include "chromeos/network/network_device_handler.h"
19 #include "chromeos/network/network_event_log.h"
20 #include "chromeos/network/network_state.h"
21 #include "chromeos/network/network_state_handler.h"
22 #include "chromeos/network/network_util.h"
23 #include "chromeos/network/onc/onc_signature.h"
24 #include "chromeos/network/onc/onc_translator.h"
25 #include "chromeos/network/onc/onc_utils.h"
26 #include "components/onc/onc_constants.h"
27 #include "content/public/browser/browser_context.h"
28 #include "extensions/browser/extension_function_registry.h"
29
30 namespace api = extensions::api::networking_private;
31
32 using chromeos::DBusThreadManager;
33 using chromeos::ManagedNetworkConfigurationHandler;
34 using chromeos::NetworkHandler;
35 using chromeos::NetworkPortalDetector;
36 using chromeos::NetworkState;
37 using chromeos::NetworkStateHandler;
38 using chromeos::NetworkTypePattern;
39 using chromeos::ShillManagerClient;
40
41 namespace {
42
43 const int kDefaultNetworkListLimit = 1000;
44
45 // Helper function that converts between the two types of verification
46 // properties. They should always have the same fields, but we do this here to
47 // prevent ShillManagerClient from depending directly on the extension API.
ConvertVerificationProperties(const api::VerificationProperties & input)48 ShillManagerClient::VerificationProperties ConvertVerificationProperties(
49 const api::VerificationProperties& input) {
50 ShillManagerClient::VerificationProperties output;
51 COMPILE_ASSERT(sizeof(api::VerificationProperties) ==
52 sizeof(ShillManagerClient::VerificationProperties),
53 verification_properties_no_longer_match);
54
55 output.certificate = input.certificate;
56 output.public_key = input.public_key;
57 output.nonce = input.nonce;
58 output.signed_data = input.signed_data;
59 output.device_serial = input.device_serial;
60 output.device_ssid = input.device_ssid;
61 output.device_bssid = input.device_bssid;
62 return output;
63 }
64
GetUserIdHash(content::BrowserContext * browser_context,std::string * user_hash)65 bool GetUserIdHash(content::BrowserContext* browser_context,
66 std::string* user_hash) {
67 // Currently Chrome OS only configures networks for the primary user.
68 // Configuration attempts from other browser contexts should fail.
69 // TODO(stevenjb): use an ExtensionsBrowserClient method to access
70 // ProfileHelper when moving this to src/extensions.
71 std::string current_user_hash =
72 chromeos::ProfileHelper::GetUserIdHashFromProfile(
73 static_cast<Profile*>(browser_context));
74
75 if (current_user_hash != chromeos::LoginState::Get()->primary_user_hash())
76 return false;
77 *user_hash = current_user_hash;
78 return true;
79 }
80
GetServicePathFromGuid(const std::string & guid,std::string * service_path,std::string * error)81 bool GetServicePathFromGuid(const std::string& guid,
82 std::string* service_path,
83 std::string* error) {
84 const NetworkState* network =
85 NetworkHandler::Get()->network_state_handler()->GetNetworkStateFromGuid(
86 guid);
87 if (!network) {
88 *error = "Error.InvalidNetworkGuid";
89 return false;
90 }
91 *service_path = network->path();
92 return true;
93 }
94
95 } // namespace
96
97 ////////////////////////////////////////////////////////////////////////////////
98 // NetworkingPrivateGetPropertiesFunction
99
100 NetworkingPrivateGetPropertiesFunction::
~NetworkingPrivateGetPropertiesFunction()101 ~NetworkingPrivateGetPropertiesFunction() {
102 }
103
RunAsync()104 bool NetworkingPrivateGetPropertiesFunction::RunAsync() {
105 scoped_ptr<api::GetProperties::Params> params =
106 api::GetProperties::Params::Create(*args_);
107 EXTENSION_FUNCTION_VALIDATE(params);
108 std::string service_path;
109 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
110 return false;
111
112 NetworkHandler::Get()->managed_network_configuration_handler()->GetProperties(
113 service_path,
114 base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess,
115 this),
116 base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed,
117 this));
118 return true;
119 }
120
GetPropertiesSuccess(const std::string & service_path,const base::DictionaryValue & dictionary)121 void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess(
122 const std::string& service_path,
123 const base::DictionaryValue& dictionary) {
124 SetResult(dictionary.DeepCopy());
125 SendResponse(true);
126 }
127
GetPropertiesFailed(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)128 void NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed(
129 const std::string& error_name,
130 scoped_ptr<base::DictionaryValue> error_data) {
131 error_ = error_name;
132 SendResponse(false);
133 }
134
135 ////////////////////////////////////////////////////////////////////////////////
136 // NetworkingPrivateGetManagedPropertiesFunction
137
138 NetworkingPrivateGetManagedPropertiesFunction::
~NetworkingPrivateGetManagedPropertiesFunction()139 ~NetworkingPrivateGetManagedPropertiesFunction() {
140 }
141
RunAsync()142 bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() {
143 scoped_ptr<api::GetManagedProperties::Params> params =
144 api::GetManagedProperties::Params::Create(*args_);
145 EXTENSION_FUNCTION_VALIDATE(params);
146 std::string service_path;
147 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
148 return false;
149
150 std::string user_id_hash;
151 if (!GetUserIdHash(browser_context(), &user_id_hash)) {
152 // Disallow getManagedProperties from a non-primary user context to avoid
153 // complexites with the policy code.
154 NET_LOG_ERROR("getManagedProperties called from non primary user.",
155 browser_context()->GetPath().value());
156 error_ = "Error.NonPrimaryUser";
157 return false;
158 }
159
160 NetworkHandler::Get()->managed_network_configuration_handler()->
161 GetManagedProperties(
162 user_id_hash,
163 service_path,
164 base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success,
165 this),
166 base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
167 this));
168 return true;
169 }
170
Success(const std::string & service_path,const base::DictionaryValue & dictionary)171 void NetworkingPrivateGetManagedPropertiesFunction::Success(
172 const std::string& service_path,
173 const base::DictionaryValue& dictionary) {
174 SetResult(dictionary.DeepCopy());
175 SendResponse(true);
176 }
177
Failure(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)178 void NetworkingPrivateGetManagedPropertiesFunction::Failure(
179 const std::string& error_name,
180 scoped_ptr<base::DictionaryValue> error_data) {
181 error_ = error_name;
182 SendResponse(false);
183 }
184
185 ////////////////////////////////////////////////////////////////////////////////
186 // NetworkingPrivateGetStateFunction
187
188 NetworkingPrivateGetStateFunction::
~NetworkingPrivateGetStateFunction()189 ~NetworkingPrivateGetStateFunction() {
190 }
191
RunAsync()192 bool NetworkingPrivateGetStateFunction::RunAsync() {
193 scoped_ptr<api::GetState::Params> params =
194 api::GetState::Params::Create(*args_);
195 EXTENSION_FUNCTION_VALIDATE(params);
196 std::string service_path;
197 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
198 return false;
199
200 const NetworkState* network_state =
201 NetworkHandler::Get()
202 ->network_state_handler()
203 ->GetNetworkStateFromServicePath(service_path,
204 false /* configured_only */);
205 if (!network_state) {
206 error_ = "Error.NetworkUnavailable";
207 return false;
208 }
209
210 scoped_ptr<base::DictionaryValue> network_properties =
211 chromeos::network_util::TranslateNetworkStateToONC(network_state);
212
213 SetResult(network_properties.release());
214 SendResponse(true);
215
216 return true;
217 }
218
219 ////////////////////////////////////////////////////////////////////////////////
220 // NetworkingPrivateSetPropertiesFunction
221
222 NetworkingPrivateSetPropertiesFunction::
~NetworkingPrivateSetPropertiesFunction()223 ~NetworkingPrivateSetPropertiesFunction() {
224 }
225
RunAsync()226 bool NetworkingPrivateSetPropertiesFunction::RunAsync() {
227 scoped_ptr<api::SetProperties::Params> params =
228 api::SetProperties::Params::Create(*args_);
229 EXTENSION_FUNCTION_VALIDATE(params);
230 std::string service_path;
231 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
232 return false;
233
234 scoped_ptr<base::DictionaryValue> properties_dict(
235 params->properties.ToValue());
236
237 NetworkHandler::Get()->managed_network_configuration_handler()->SetProperties(
238 service_path,
239 *properties_dict,
240 base::Bind(&NetworkingPrivateSetPropertiesFunction::ResultCallback,
241 this),
242 base::Bind(&NetworkingPrivateSetPropertiesFunction::ErrorCallback,
243 this));
244 return true;
245 }
246
ErrorCallback(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)247 void NetworkingPrivateSetPropertiesFunction::ErrorCallback(
248 const std::string& error_name,
249 const scoped_ptr<base::DictionaryValue> error_data) {
250 error_ = error_name;
251 SendResponse(false);
252 }
253
ResultCallback()254 void NetworkingPrivateSetPropertiesFunction::ResultCallback() {
255 SendResponse(true);
256 }
257
258 ////////////////////////////////////////////////////////////////////////////////
259 // NetworkingPrivateCreateNetworkFunction
260
261 NetworkingPrivateCreateNetworkFunction::
~NetworkingPrivateCreateNetworkFunction()262 ~NetworkingPrivateCreateNetworkFunction() {
263 }
264
RunAsync()265 bool NetworkingPrivateCreateNetworkFunction::RunAsync() {
266 scoped_ptr<api::CreateNetwork::Params> params =
267 api::CreateNetwork::Params::Create(*args_);
268 EXTENSION_FUNCTION_VALIDATE(params);
269
270 std::string user_id_hash;
271 if (!params->shared &&
272 !GetUserIdHash(browser_context(), &user_id_hash)) {
273 // Do not allow configuring a non-shared network from a non-primary user
274 // context.
275 NET_LOG_ERROR("createNetwork called from non primary user.",
276 browser_context()->GetPath().value());
277 error_ = "Error.NonPrimaryUser";
278 return false;
279 }
280
281 scoped_ptr<base::DictionaryValue> properties_dict(
282 params->properties.ToValue());
283
284 NetworkHandler::Get()->managed_network_configuration_handler()->
285 CreateConfiguration(
286 user_id_hash,
287 *properties_dict,
288 base::Bind(&NetworkingPrivateCreateNetworkFunction::ResultCallback,
289 this),
290 base::Bind(&NetworkingPrivateCreateNetworkFunction::ErrorCallback,
291 this));
292 return true;
293 }
294
ErrorCallback(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)295 void NetworkingPrivateCreateNetworkFunction::ErrorCallback(
296 const std::string& error_name,
297 const scoped_ptr<base::DictionaryValue> error_data) {
298 error_ = error_name;
299 SendResponse(false);
300 }
301
ResultCallback(const std::string & guid)302 void NetworkingPrivateCreateNetworkFunction::ResultCallback(
303 const std::string& guid) {
304 results_ = api::CreateNetwork::Results::Create(guid);
305 SendResponse(true);
306 }
307
308 ////////////////////////////////////////////////////////////////////////////////
309 // NetworkingPrivateGetNetworksFunction
310
311 NetworkingPrivateGetNetworksFunction::
~NetworkingPrivateGetNetworksFunction()312 ~NetworkingPrivateGetNetworksFunction() {
313 }
314
RunAsync()315 bool NetworkingPrivateGetNetworksFunction::RunAsync() {
316 scoped_ptr<api::GetNetworks::Params> params =
317 api::GetNetworks::Params::Create(*args_);
318 EXTENSION_FUNCTION_VALIDATE(params);
319 NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType(
320 api::ToString(params->filter.network_type));
321 const bool configured_only =
322 params->filter.configured ? *params->filter.configured : false;
323 const bool visible_only =
324 params->filter.visible ? *params->filter.visible : false;
325 const int limit =
326 params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit;
327 scoped_ptr<base::ListValue> network_properties_list =
328 chromeos::network_util::TranslateNetworkListToONC(
329 pattern, configured_only, visible_only, limit, false /* debugging */);
330 SetResult(network_properties_list.release());
331 SendResponse(true);
332 return true;
333 }
334
335 ////////////////////////////////////////////////////////////////////////////////
336 // NetworkingPrivateGetVisibleNetworksFunction
337
338 NetworkingPrivateGetVisibleNetworksFunction::
~NetworkingPrivateGetVisibleNetworksFunction()339 ~NetworkingPrivateGetVisibleNetworksFunction() {
340 }
341
RunAsync()342 bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() {
343 scoped_ptr<api::GetVisibleNetworks::Params> params =
344 api::GetVisibleNetworks::Params::Create(*args_);
345 EXTENSION_FUNCTION_VALIDATE(params);
346 NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType(
347 api::ToString(params->network_type));
348 const bool configured_only = false;
349 const bool visible_only = true;
350 scoped_ptr<base::ListValue> network_properties_list =
351 chromeos::network_util::TranslateNetworkListToONC(
352 pattern, configured_only, visible_only, kDefaultNetworkListLimit,
353 false /* debugging */);
354 SetResult(network_properties_list.release());
355 SendResponse(true);
356 return true;
357 }
358
359 ////////////////////////////////////////////////////////////////////////////////
360 // NetworkingPrivateGetEnabledNetworkTypesFunction
361
362 NetworkingPrivateGetEnabledNetworkTypesFunction::
~NetworkingPrivateGetEnabledNetworkTypesFunction()363 ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
364 }
365
RunSync()366 bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
367 NetworkStateHandler* state_handler =
368 NetworkHandler::Get()->network_state_handler();
369
370 base::ListValue* network_list = new base::ListValue;
371
372 if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Ethernet()))
373 network_list->AppendString(api::ToString(api::NETWORK_TYPE_ETHERNET));
374 if (state_handler->IsTechnologyEnabled(NetworkTypePattern::WiFi()))
375 network_list->AppendString(api::ToString(api::NETWORK_TYPE_WIFI));
376 if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()))
377 network_list->AppendString(api::ToString(api::NETWORK_TYPE_WIMAX));
378 if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Cellular()))
379 network_list->AppendString(api::ToString(api::NETWORK_TYPE_CELLULAR));
380
381 SetResult(network_list);
382 return true;
383 }
384
385 ////////////////////////////////////////////////////////////////////////////////
386 // NetworkingPrivateEnableNetworkTypeFunction
387
388 NetworkingPrivateEnableNetworkTypeFunction::
~NetworkingPrivateEnableNetworkTypeFunction()389 ~NetworkingPrivateEnableNetworkTypeFunction() {
390 }
391
RunSync()392 bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
393 scoped_ptr<api::EnableNetworkType::Params> params =
394 api::EnableNetworkType::Params::Create(*args_);
395 EXTENSION_FUNCTION_VALIDATE(params);
396
397 NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType(
398 api::ToString(params->network_type));
399
400 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
401 pattern, true, chromeos::network_handler::ErrorCallback());
402
403 return true;
404 }
405
406 ////////////////////////////////////////////////////////////////////////////////
407 // NetworkingPrivateDisableNetworkTypeFunction
408
409 NetworkingPrivateDisableNetworkTypeFunction::
~NetworkingPrivateDisableNetworkTypeFunction()410 ~NetworkingPrivateDisableNetworkTypeFunction() {
411 }
412
RunSync()413 bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
414 scoped_ptr<api::DisableNetworkType::Params> params =
415 api::DisableNetworkType::Params::Create(*args_);
416
417 NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType(
418 api::ToString(params->network_type));
419
420 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
421 pattern, false, chromeos::network_handler::ErrorCallback());
422
423 return true;
424 }
425
426 ////////////////////////////////////////////////////////////////////////////////
427 // NetworkingPrivateRequestNetworkScanFunction
428
429 NetworkingPrivateRequestNetworkScanFunction::
~NetworkingPrivateRequestNetworkScanFunction()430 ~NetworkingPrivateRequestNetworkScanFunction() {
431 }
432
RunSync()433 bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
434 NetworkHandler::Get()->network_state_handler()->RequestScan();
435 return true;
436 }
437
438 ////////////////////////////////////////////////////////////////////////////////
439 // NetworkingPrivateStartConnectFunction
440
441 NetworkingPrivateStartConnectFunction::
~NetworkingPrivateStartConnectFunction()442 ~NetworkingPrivateStartConnectFunction() {
443 }
444
ConnectionStartSuccess()445 void NetworkingPrivateStartConnectFunction::ConnectionStartSuccess() {
446 SendResponse(true);
447 }
448
ConnectionStartFailed(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)449 void NetworkingPrivateStartConnectFunction::ConnectionStartFailed(
450 const std::string& error_name,
451 const scoped_ptr<base::DictionaryValue> error_data) {
452 error_ = error_name;
453 SendResponse(false);
454 }
455
RunAsync()456 bool NetworkingPrivateStartConnectFunction::RunAsync() {
457 scoped_ptr<api::StartConnect::Params> params =
458 api::StartConnect::Params::Create(*args_);
459 EXTENSION_FUNCTION_VALIDATE(params);
460 std::string service_path;
461 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
462 return false;
463
464 const bool check_error_state = false;
465 NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
466 service_path,
467 base::Bind(
468 &NetworkingPrivateStartConnectFunction::ConnectionStartSuccess,
469 this),
470 base::Bind(
471 &NetworkingPrivateStartConnectFunction::ConnectionStartFailed,
472 this),
473 check_error_state);
474 return true;
475 }
476
477 ////////////////////////////////////////////////////////////////////////////////
478 // NetworkingPrivateStartDisconnectFunction
479
480 NetworkingPrivateStartDisconnectFunction::
~NetworkingPrivateStartDisconnectFunction()481 ~NetworkingPrivateStartDisconnectFunction() {
482 }
483
DisconnectionStartSuccess()484 void NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess() {
485 SendResponse(true);
486 }
487
DisconnectionStartFailed(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)488 void NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed(
489 const std::string& error_name,
490 const scoped_ptr<base::DictionaryValue> error_data) {
491 error_ = error_name;
492 SendResponse(false);
493 }
494
RunAsync()495 bool NetworkingPrivateStartDisconnectFunction::RunAsync() {
496 scoped_ptr<api::StartDisconnect::Params> params =
497 api::StartDisconnect::Params::Create(*args_);
498 EXTENSION_FUNCTION_VALIDATE(params);
499 std::string service_path;
500 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
501 return false;
502
503 NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
504 service_path,
505 base::Bind(
506 &NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess,
507 this),
508 base::Bind(
509 &NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed,
510 this));
511 return true;
512 }
513
514 ////////////////////////////////////////////////////////////////////////////////
515 // NetworkingPrivateVerifyDestinationFunction
516
517 NetworkingPrivateVerifyDestinationFunction::
~NetworkingPrivateVerifyDestinationFunction()518 ~NetworkingPrivateVerifyDestinationFunction() {
519 }
520
RunAsync()521 bool NetworkingPrivateVerifyDestinationFunction::RunAsync() {
522 scoped_ptr<api::VerifyDestination::Params> params =
523 api::VerifyDestination::Params::Create(*args_);
524 EXTENSION_FUNCTION_VALIDATE(params);
525
526 ShillManagerClient::VerificationProperties verification_properties =
527 ConvertVerificationProperties(params->properties);
528
529 DBusThreadManager::Get()->GetShillManagerClient()->VerifyDestination(
530 verification_properties,
531 base::Bind(
532 &NetworkingPrivateVerifyDestinationFunction::ResultCallback,
533 this),
534 base::Bind(
535 &NetworkingPrivateVerifyDestinationFunction::ErrorCallback,
536 this));
537 return true;
538 }
539
ResultCallback(bool result)540 void NetworkingPrivateVerifyDestinationFunction::ResultCallback(
541 bool result) {
542 results_ = api::VerifyDestination::Results::Create(result);
543 SendResponse(true);
544 }
545
ErrorCallback(const std::string & error_name,const std::string & error)546 void NetworkingPrivateVerifyDestinationFunction::ErrorCallback(
547 const std::string& error_name, const std::string& error) {
548 error_ = error_name;
549 SendResponse(false);
550 }
551
552 ////////////////////////////////////////////////////////////////////////////////
553 // NetworkingPrivateVerifyAndEncryptCredentialsFunction
554
555 NetworkingPrivateVerifyAndEncryptCredentialsFunction::
~NetworkingPrivateVerifyAndEncryptCredentialsFunction()556 ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
557 }
558
RunAsync()559 bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() {
560 scoped_ptr<api::VerifyAndEncryptCredentials::Params> params =
561 api::VerifyAndEncryptCredentials::Params::Create(*args_);
562 EXTENSION_FUNCTION_VALIDATE(params);
563 std::string service_path;
564 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
565 return false;
566
567 ShillManagerClient::VerificationProperties verification_properties =
568 ConvertVerificationProperties(params->properties);
569
570 ShillManagerClient* shill_manager_client =
571 DBusThreadManager::Get()->GetShillManagerClient();
572 shill_manager_client->VerifyAndEncryptCredentials(
573 verification_properties,
574 service_path,
575 base::Bind(
576 &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback,
577 this),
578 base::Bind(
579 &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback,
580 this));
581 return true;
582 }
583
ResultCallback(const std::string & result)584 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback(
585 const std::string& result) {
586 results_ = api::VerifyAndEncryptCredentials::Results::Create(result);
587 SendResponse(true);
588 }
589
ErrorCallback(const std::string & error_name,const std::string & error)590 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback(
591 const std::string& error_name, const std::string& error) {
592 error_ = error_name;
593 SendResponse(false);
594 }
595
596 ////////////////////////////////////////////////////////////////////////////////
597 // NetworkingPrivateVerifyAndEncryptDataFunction
598
599 NetworkingPrivateVerifyAndEncryptDataFunction::
~NetworkingPrivateVerifyAndEncryptDataFunction()600 ~NetworkingPrivateVerifyAndEncryptDataFunction() {
601 }
602
RunAsync()603 bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() {
604 scoped_ptr<api::VerifyAndEncryptData::Params> params =
605 api::VerifyAndEncryptData::Params::Create(*args_);
606 EXTENSION_FUNCTION_VALIDATE(params);
607
608 ShillManagerClient::VerificationProperties verification_properties =
609 ConvertVerificationProperties(params->properties);
610
611 DBusThreadManager::Get()->GetShillManagerClient()->VerifyAndEncryptData(
612 verification_properties,
613 params->data,
614 base::Bind(
615 &NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback,
616 this),
617 base::Bind(
618 &NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback,
619 this));
620 return true;
621 }
622
ResultCallback(const std::string & result)623 void NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback(
624 const std::string& result) {
625 results_ = api::VerifyAndEncryptData::Results::Create(result);
626 SendResponse(true);
627 }
628
ErrorCallback(const std::string & error_name,const std::string & error)629 void NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback(
630 const std::string& error_name,
631 const std::string& error) {
632 error_ = error_name;
633 SendResponse(false);
634 }
635
636 ////////////////////////////////////////////////////////////////////////////////
637 // NetworkingPrivateSetWifiTDLSEnabledStateFunction
638
639 NetworkingPrivateSetWifiTDLSEnabledStateFunction::
~NetworkingPrivateSetWifiTDLSEnabledStateFunction()640 ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
641 }
642
RunAsync()643 bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() {
644 scoped_ptr<api::SetWifiTDLSEnabledState::Params> params =
645 api::SetWifiTDLSEnabledState::Params::Create(*args_);
646 EXTENSION_FUNCTION_VALIDATE(params);
647
648 std::string ip_or_mac_address = params->ip_or_mac_address;
649 bool enable = params->enabled;
650
651 NetworkHandler::Get()->network_device_handler()->
652 SetWifiTDLSEnabled(
653 ip_or_mac_address,
654 enable,
655 base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success,
656 this),
657 base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure,
658 this));
659
660 return true;
661 }
662
Success(const std::string & result)663 void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success(
664 const std::string& result) {
665 results_ = api::SetWifiTDLSEnabledState::Results::Create(result);
666 SendResponse(true);
667 }
668
Failure(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)669 void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure(
670 const std::string& error_name,
671 scoped_ptr<base::DictionaryValue> error_data) {
672 error_ = error_name;
673 SendResponse(false);
674 }
675
676 ////////////////////////////////////////////////////////////////////////////////
677 // NetworkingPrivateGetWifiTDLSStatusFunction
678
679 NetworkingPrivateGetWifiTDLSStatusFunction::
~NetworkingPrivateGetWifiTDLSStatusFunction()680 ~NetworkingPrivateGetWifiTDLSStatusFunction() {
681 }
682
RunAsync()683 bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() {
684 scoped_ptr<api::GetWifiTDLSStatus::Params> params =
685 api::GetWifiTDLSStatus::Params::Create(*args_);
686 EXTENSION_FUNCTION_VALIDATE(params);
687
688 std::string ip_or_mac_address = params->ip_or_mac_address;
689
690 NetworkHandler::Get()->network_device_handler()->
691 GetWifiTDLSStatus(
692 ip_or_mac_address,
693 base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Success,
694 this),
695 base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Failure,
696 this));
697
698 return true;
699 }
700
Success(const std::string & result)701 void NetworkingPrivateGetWifiTDLSStatusFunction::Success(
702 const std::string& result) {
703 results_ = api::GetWifiTDLSStatus::Results::Create(result);
704 SendResponse(true);
705 }
706
Failure(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)707 void NetworkingPrivateGetWifiTDLSStatusFunction::Failure(
708 const std::string& error_name,
709 scoped_ptr<base::DictionaryValue> error_data) {
710 error_ = error_name;
711 SendResponse(false);
712 }
713
714 ////////////////////////////////////////////////////////////////////////////////
715 // NetworkingPrivateGetCaptivePortalStatusFunction
716
717 NetworkingPrivateGetCaptivePortalStatusFunction::
~NetworkingPrivateGetCaptivePortalStatusFunction()718 ~NetworkingPrivateGetCaptivePortalStatusFunction() {}
719
RunAsync()720 bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() {
721 scoped_ptr<api::GetCaptivePortalStatus::Params> params =
722 api::GetCaptivePortalStatus::Params::Create(*args_);
723 EXTENSION_FUNCTION_VALIDATE(params);
724 std::string service_path;
725 if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_))
726 return false;
727
728 NetworkPortalDetector* detector = NetworkPortalDetector::Get();
729 if (!detector) {
730 error_ = "Error.NotReady";
731 return false;
732 }
733
734 NetworkPortalDetector::CaptivePortalState state =
735 detector->GetCaptivePortalState(service_path);
736
737 SetResult(new base::StringValue(
738 NetworkPortalDetector::CaptivePortalStatusString(state.status)));
739 SendResponse(true);
740 return true;
741 }
742