1//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8//      http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16
17#ifndef SHILL_CELLULAR_CELLULAR_H_
18#define SHILL_CELLULAR_CELLULAR_H_
19
20#include <map>
21#include <memory>
22#include <string>
23#include <vector>
24
25#include <base/macros.h>
26#include <base/memory/weak_ptr.h>
27#include <gtest/gtest_prod.h>  // for FRIEND_TEST
28
29#include "shill/cellular/mobile_operator_info.h"
30#include "shill/cellular/modem_info.h"
31#include "shill/cellular/modem_proxy_interface.h"
32#include "shill/device.h"
33#include "shill/event_dispatcher.h"
34#include "shill/metrics.h"
35#include "shill/refptr_types.h"
36#include "shill/rpc_task.h"
37
38namespace shill {
39
40class CellularCapability;
41class Error;
42class ExternalTask;
43class MobileOperatorInfo;
44class PPPDeviceFactory;
45class ProcessManager;
46
47class Cellular : public Device, public RPCTaskDelegate {
48 public:
49  enum Type {
50    kTypeGSM,
51    kTypeCDMA,
52    kTypeUniversal,  // ModemManager1
53    kTypeUniversalCDMA,
54    kTypeInvalid,
55  };
56
57  // The device states progress linearly from Disabled to Linked.
58  enum State {
59    // This is the initial state of the modem and indicates that the modem radio
60    // is not turned on.
61    kStateDisabled,
62    // This state indicates that the modem radio is turned on, and it should be
63    // possible to measure signal strength.
64    kStateEnabled,
65    // The modem has registered with a network and has signal quality
66    // measurements. A cellular service object is created.
67    kStateRegistered,
68    // The modem has connected to a network.
69    kStateConnected,
70    // The network interface is UP.
71    kStateLinked,
72  };
73
74  // This enum must be kept in sync with ModemManager's MMModemState enum.
75  enum ModemState {
76    kModemStateFailed = -1,
77    kModemStateUnknown = 0,
78    kModemStateInitializing = 1,
79    kModemStateLocked = 2,
80    kModemStateDisabled = 3,
81    kModemStateDisabling = 4,
82    kModemStateEnabling = 5,
83    kModemStateEnabled = 6,
84    kModemStateSearching = 7,
85    kModemStateRegistered = 8,
86    kModemStateDisconnecting = 9,
87    kModemStateConnecting = 10,
88    kModemStateConnected = 11,
89  };
90
91  // |path| is the ModemManager.Modem DBus object path (e.g.,
92  // "/org/chromium/ModemManager/Gobi/0").
93  // |service| is the modem mananager service name (e.g.,
94  // /org/chromium/ModemManager or /org/freedesktop/ModemManager1).
95  Cellular(ModemInfo* modem_info,
96           const std::string& link_name,
97           const std::string& address,
98           int interface_index,
99           Type type,
100           const std::string& service,
101           const std::string& path);
102  ~Cellular() override;
103
104  // Load configuration for the device from |storage|.
105  bool Load(StoreInterface* storage) override;
106
107  // Save configuration for the device to |storage|.
108  bool Save(StoreInterface* storage) override;
109
110  // Asynchronously connects the modem to the network. Populates |error| on
111  // failure, leaves it unchanged otherwise.
112  virtual void Connect(Error* error);
113
114  // Asynchronously disconnects the modem from the network and populates
115  // |error| on failure, leaves it unchanged otherwise.
116  virtual void Disconnect(Error* error, const char* reason);
117
118  // Asynchronously activates the modem. Returns an error on failure.
119  void Activate(const std::string& carrier, Error* error,
120                const ResultCallback& callback);
121
122  // Performs the necessary steps to bring the service to the activated state,
123  // once an online payment has been done.
124  void CompleteActivation(Error* error);
125
126  const CellularServiceRefPtr& service() const { return service_; }
127  MobileOperatorInfo* home_provider_info() const {
128    return home_provider_info_.get();
129  }
130  MobileOperatorInfo* serving_operator_info() const {
131    return serving_operator_info_.get();
132  }
133
134  // Deregisters and destructs the current service and destroys the connection,
135  // if any. This also eliminates the circular references between this device
136  // and the associated service, allowing eventual device destruction.
137  virtual void DestroyService();
138
139  static std::string GetStateString(State state);
140  static std::string GetModemStateString(ModemState modem_state);
141
142  std::string CreateDefaultFriendlyServiceName();
143  bool IsDefaultFriendlyServiceName(const std::string& service_name) const;
144
145  // Update the home provider from the information in |operator_info|. This
146  // information may be from the SIM / received OTA.
147  void UpdateHomeProvider(const MobileOperatorInfo* operator_info);
148  // Update the serving operator using information in |operator_info|.
149  // Additionally, if |home_provider_info| is not nullptr, use it to come up
150  // with a better name.
151  void UpdateServingOperator(const MobileOperatorInfo* operator_info,
152                             const MobileOperatorInfo* home_provider_info);
153
154  State state() const { return state_; }
155
156  void set_modem_state(ModemState state) { modem_state_ = state; }
157  ModemState modem_state() const { return modem_state_; }
158  bool IsUnderlyingDeviceEnabled() const override;
159  bool IsModemRegistered() const;
160  static bool IsEnabledModemState(ModemState state);
161
162  void HandleNewSignalQuality(uint32_t strength);
163
164  // Processes a change in the modem registration state, possibly creating,
165  // destroying or updating the CellularService.
166  void HandleNewRegistrationState();
167
168  virtual void OnPropertiesChanged(
169      const std::string& interface,
170      const KeyValueStore& changed_properties,
171      const std::vector<std::string>& invalidated_properties);
172
173  // Inherited from Device.
174  void Start(Error* error,
175             const EnabledStateChangedCallback& callback) override;
176  void Stop(Error* error, const EnabledStateChangedCallback& callback) override;
177  void LinkEvent(unsigned int flags, unsigned int change) override;
178  void Scan(ScanType /*scan_type*/, Error* error,
179            const std::string& /*reason*/) override;
180  void RegisterOnNetwork(const std::string& network_id,
181                         Error* error,
182                         const ResultCallback& callback) override;
183  void RequirePIN(const std::string& pin, bool require,
184                  Error* error, const ResultCallback& callback) override;
185  void EnterPIN(const std::string& pin,
186                Error* error, const ResultCallback& callback) override;
187  void UnblockPIN(const std::string& unblock_code,
188                  const std::string& pin,
189                  Error* error, const ResultCallback& callback) override;
190  void ChangePIN(const std::string& old_pin,
191                 const std::string& new_pin,
192                 Error* error, const ResultCallback& callback) override;
193  void Reset(Error* error, const ResultCallback& callback) override;
194  void SetCarrier(const std::string& carrier,
195                  Error* error, const ResultCallback& callback) override;
196  bool IsIPv6Allowed() const override;
197  void DropConnection() override;
198  void SetServiceState(Service::ConnectState state) override;
199  void SetServiceFailure(Service::ConnectFailure failure_state) override;
200  void SetServiceFailureSilent(Service::ConnectFailure failure_state) override;
201  void OnBeforeSuspend(const ResultCallback& callback) override;
202  void OnAfterResume() override;
203
204  void StartModemCallback(const EnabledStateChangedCallback& callback,
205                          const Error& error);
206  void StopModemCallback(const EnabledStateChangedCallback& callback,
207                         const Error& error);
208  void OnDisabled();
209  void OnEnabled();
210  void OnConnecting();
211  void OnConnected() override;
212  void OnConnectFailed(const Error& error);
213  void OnDisconnected();
214  void OnDisconnectFailed();
215  std::string GetTechnologyFamily(Error* error);
216  void OnModemStateChanged(ModemState new_state);
217  void OnScanReply(const Stringmaps& found_networks, const Error& error);
218
219  // accessor to read the allow roaming property
220  bool allow_roaming_property() const { return allow_roaming_; }
221  // Is the underlying device in the process of activating?
222  bool IsActivating() const;
223
224  // Initiate PPP link. Called from capabilities.
225  virtual void StartPPP(const std::string& serial_device);
226  // Callback for |ppp_task_|.
227  virtual void OnPPPDied(pid_t pid, int exit);
228  // Implements RPCTaskDelegate, for |ppp_task_|.
229  void GetLogin(std::string* user, std::string* password) override;
230  void Notify(const std::string& reason,
231              const std::map<std::string, std::string>& dict) override;
232
233  // ///////////////////////////////////////////////////////////////////////////
234  // DBus Properties exposed by the Device interface of shill.
235  void RegisterProperties();
236
237  // getters
238  const std::string& dbus_service() const { return dbus_service_; }
239  const std::string& dbus_path() const { return dbus_path_; }
240  const Stringmap& home_provider() const { return home_provider_; }
241  const std::string& carrier() const { return carrier_; }
242  bool scanning_supported() const { return scanning_supported_; }
243  const std::string& esn() const { return esn_; }
244  const std::string& firmware_revision() const { return firmware_revision_; }
245  const std::string& hardware_revision() const { return hardware_revision_; }
246  const std::string& imei() const { return imei_; }
247  const std::string& imsi() const { return imsi_; }
248  const std::string& mdn() const { return mdn_; }
249  const std::string& meid() const { return meid_; }
250  const std::string& min() const { return min_; }
251  const std::string& manufacturer() const { return manufacturer_; }
252  const std::string& model_id() const { return model_id_; }
253  const std::string& mm_plugin() const { return mm_plugin_; }
254  bool scanning() const { return scanning_; }
255
256  const std::string& selected_network() const { return selected_network_; }
257  const Stringmaps& found_networks() const { return found_networks_; }
258  bool provider_requires_roaming() const { return provider_requires_roaming_; }
259  bool sim_present() const { return sim_present_; }
260  const Stringmaps& apn_list() const { return apn_list_; }
261  const std::string& sim_identifier() const { return sim_identifier_; }
262
263  const Strings& supported_carriers() const { return supported_carriers_; }
264  uint16_t prl_version() const { return prl_version_; }
265
266  // setters
267  void set_home_provider(const Stringmap& home_provider);
268  void set_carrier(const std::string& carrier);
269  void set_scanning_supported(bool scanning_supported);
270  void set_esn(const std::string& esn);
271  void set_firmware_revision(const std::string& firmware_revision);
272  void set_hardware_revision(const std::string& hardware_revision);
273  void set_imei(const std::string& imei);
274  void set_imsi(const std::string& imsi);
275  void set_mdn(const std::string& mdn);
276  void set_meid(const std::string& meid);
277  void set_min(const std::string& min);
278  void set_manufacturer(const std::string& manufacturer);
279  void set_model_id(const std::string& model_id);
280  void set_mm_plugin(const std::string& mm_plugin);
281  void set_scanning(bool scanning);
282
283  void set_selected_network(const std::string& selected_network);
284  void clear_found_networks();
285  void set_found_networks(const Stringmaps& found_networks);
286  void set_provider_requires_roaming(bool provider_requires_roaming);
287  void set_sim_present(bool sim_present);
288  void set_apn_list(const Stringmaps& apn_list);
289  void set_sim_identifier(const std::string& sim_identifier);
290
291  void set_supported_carriers(const Strings& supported_carriers);
292  void set_prl_version(uint16_t prl_version);
293
294  // Takes ownership.
295  void set_home_provider_info(MobileOperatorInfo* home_provider_info);
296  // Takes ownership.
297  void set_serving_operator_info(MobileOperatorInfo* serving_operator_info);
298
299 private:
300  friend class ActivePassiveOutOfCreditsDetectorTest;
301  friend class CellularTest;
302  friend class CellularCapabilityTest;
303  friend class CellularCapabilityCDMATest;
304  friend class CellularCapabilityGSMTest;
305  friend class CellularCapabilityUniversalTest;
306  friend class CellularCapabilityUniversalCDMATest;
307  friend class CellularServiceTest;
308  friend class ModemTest;
309  friend class SubscriptionStateOutOfCreditsDetectorTest;
310  FRIEND_TEST(CellularCapabilityCDMATest, GetRegistrationState);
311  FRIEND_TEST(CellularCapabilityGSMTest, AllowRoaming);
312  FRIEND_TEST(CellularCapabilityTest, AllowRoaming);
313  FRIEND_TEST(CellularCapabilityTest, EnableModemFail);
314  FRIEND_TEST(CellularCapabilityTest, EnableModemSucceed);
315  FRIEND_TEST(CellularCapabilityTest, FinishEnable);
316  FRIEND_TEST(CellularCapabilityTest, GetModemInfo);
317  FRIEND_TEST(CellularCapabilityTest, GetModemStatus);
318  FRIEND_TEST(CellularCapabilityUniversalCDMATest, OnCDMARegistrationChanged);
319  FRIEND_TEST(CellularCapabilityUniversalMainTest, AllowRoaming);
320  FRIEND_TEST(CellularCapabilityUniversalMainTest, Connect);
321  FRIEND_TEST(CellularCapabilityUniversalMainTest, IsServiceActivationRequired);
322  FRIEND_TEST(CellularCapabilityUniversalMainTest, StartModemAlreadyEnabled);
323  FRIEND_TEST(CellularCapabilityUniversalMainTest, StopModemConnected);
324  FRIEND_TEST(CellularCapabilityUniversalMainTest,
325              UpdatePendingActivationState);
326  FRIEND_TEST(CellularCapabilityUniversalMainTest,
327              UpdateRegistrationState);
328  FRIEND_TEST(CellularCapabilityUniversalMainTest,
329              UpdateRegistrationStateModemNotConnected);
330  FRIEND_TEST(CellularCapabilityUniversalMainTest, UpdateScanningProperty);
331  FRIEND_TEST(CellularCapabilityUniversalMainTest,
332              UpdateServiceActivationState);
333  FRIEND_TEST(CellularTest, ChangeServiceState);
334  FRIEND_TEST(CellularTest, ChangeServiceStatePPP);
335  FRIEND_TEST(CellularTest, CreateService);
336  FRIEND_TEST(CellularTest, Connect);
337  FRIEND_TEST(CellularTest, ConnectFailure);
338  FRIEND_TEST(CellularTest, ConnectFailureNoService);
339  FRIEND_TEST(CellularTest, ConnectSuccessNoService);
340  FRIEND_TEST(CellularTest, CustomSetterNoopChange);
341  FRIEND_TEST(CellularTest, DisableModem);
342  FRIEND_TEST(CellularTest, Disconnect);
343  FRIEND_TEST(CellularTest, DisconnectFailure);
344  FRIEND_TEST(CellularTest, DisconnectWithCallback);
345  FRIEND_TEST(CellularTest, DropConnection);
346  FRIEND_TEST(CellularTest, DropConnectionPPP);
347  FRIEND_TEST(CellularTest, EnableTrafficMonitor);
348  FRIEND_TEST(CellularTest, EstablishLinkDHCP);
349  FRIEND_TEST(CellularTest, EstablishLinkPPP);
350  FRIEND_TEST(CellularTest, EstablishLinkStatic);
351  FRIEND_TEST(CellularTest, FriendlyServiceName);
352  FRIEND_TEST(CellularTest,
353              HandleNewRegistrationStateForServiceRequiringActivation);
354  FRIEND_TEST(CellularTest, HomeProviderServingOperator);
355  FRIEND_TEST(CellularTest, LinkEventUpWithPPP);
356  FRIEND_TEST(CellularTest, LinkEventUpWithoutPPP);
357  FRIEND_TEST(CellularTest, LinkEventWontDestroyService);
358  FRIEND_TEST(CellularTest, ModemStateChangeDisable);
359  FRIEND_TEST(CellularTest, ModemStateChangeEnable);
360  FRIEND_TEST(CellularTest, ModemStateChangeStaleConnected);
361  FRIEND_TEST(CellularTest, ModemStateChangeValidConnected);
362  FRIEND_TEST(CellularTest, Notify);
363  FRIEND_TEST(CellularTest, OnAfterResumeDisableInProgressWantDisabled);
364  FRIEND_TEST(CellularTest, OnAfterResumeDisableQueuedWantEnabled);
365  FRIEND_TEST(CellularTest, OnAfterResumeDisabledWantDisabled);
366  FRIEND_TEST(CellularTest, OnAfterResumeDisabledWantEnabled);
367  FRIEND_TEST(CellularTest, OnAfterResumePowerDownInProgressWantEnabled);
368  FRIEND_TEST(CellularTest, OnConnectionHealthCheckerResult);
369  FRIEND_TEST(CellularTest, OnPPPDied);
370  FRIEND_TEST(CellularTest, PPPConnectionFailedAfterAuth);
371  FRIEND_TEST(CellularTest, PPPConnectionFailedBeforeAuth);
372  FRIEND_TEST(CellularTest, PPPConnectionFailedDuringAuth);
373  FRIEND_TEST(CellularTest, ScanAsynchronousFailure);
374  FRIEND_TEST(CellularTest, ScanImmediateFailure);
375  FRIEND_TEST(CellularTest, ScanSuccess);
376  FRIEND_TEST(CellularTest, SetAllowRoaming);
377  FRIEND_TEST(CellularTest, StartModemCallback);
378  FRIEND_TEST(CellularTest, StartModemCallbackFail);
379  FRIEND_TEST(CellularTest, StopModemCallback);
380  FRIEND_TEST(CellularTest, StopModemCallbackFail);
381  FRIEND_TEST(CellularTest, StopPPPOnDisconnect);
382  FRIEND_TEST(CellularTest, StopPPPOnTermination);
383  FRIEND_TEST(CellularTest, StorageIdentifier);
384  FRIEND_TEST(CellularTest, StartConnected);
385  FRIEND_TEST(CellularTest, StartCDMARegister);
386  FRIEND_TEST(CellularTest, StartGSMRegister);
387  FRIEND_TEST(CellularTest, StartLinked);
388  FRIEND_TEST(CellularTest, StartPPP);
389  FRIEND_TEST(CellularTest, StartPPPAfterEthernetUp);
390  FRIEND_TEST(CellularTest, StartPPPAlreadyStarted);
391  FRIEND_TEST(CellularTest, UpdateScanning);
392  FRIEND_TEST(Modem1Test, CreateDeviceMM1);
393
394  class MobileOperatorInfoObserver : public MobileOperatorInfo::Observer {
395   public:
396    // |cellular| must have lifespan longer than this object. In practice this
397    // is enforced because |cellular| owns this object.
398    explicit MobileOperatorInfoObserver(Cellular* cellular);
399    ~MobileOperatorInfoObserver() override;
400
401    void set_capability(CellularCapability* capability) {
402      capability_ = capability;
403    }
404
405    // Inherited from MobileOperatorInfo::Observer
406    void OnOperatorChanged() override;
407
408   private:
409    Cellular* const cellular_;
410    // Owned by |Cellular|.
411    CellularCapability* capability_;
412
413    DISALLOW_COPY_AND_ASSIGN(MobileOperatorInfoObserver);
414  };
415
416  // Names of properties in storage
417  static const char kAllowRoaming[];
418
419  // the |kScanningProperty| exposed by Cellular device is sticky false. Every
420  // time it is set to true, it must be reset to false after a time equal to
421  // this constant.
422  static const int64_t kDefaultScanningTimeoutMilliseconds;
423
424  // Generic service name prefix, shown when the correct carrier name is
425  // unknown.
426  static const char kGenericServiceNamePrefix[];
427  static unsigned int friendly_service_name_id_;
428
429  void SetState(State state);
430
431  // Invoked when the modem is connected to the cellular network to transition
432  // to the network-connected state and bring the network interface up.
433  void EstablishLink();
434
435  void InitCapability(Type type);
436
437  void CreateService();
438
439  // HelpRegisterDerived*: Expose a property over RPC, with the name |name|.
440  //
441  // Reads of the property will be handled by invoking |get|.
442  // Writes to the property will be handled by invoking |set|.
443  // Clearing the property will be handled by PropertyStore.
444  void HelpRegisterDerivedBool(
445      const std::string& name,
446      bool(Cellular::*get)(Error* error),
447      bool(Cellular::*set)(const bool& value, Error* error));
448  void HelpRegisterConstDerivedString(
449      const std::string& name,
450      std::string(Cellular::*get)(Error* error));
451
452  void OnConnectReply(const Error& error);
453  void OnDisconnectReply(const Error& error);
454
455  // DBUS accessors to read/modify the allow roaming property
456  bool GetAllowRoaming(Error* /*error*/) { return allow_roaming_; }
457  bool SetAllowRoaming(const bool& value, Error* error);
458
459  // When shill terminates or ChromeOS suspends, this function is called to
460  // disconnect from the cellular network.
461  void StartTermination();
462
463  // This method is invoked upon the completion of StartTermination().
464  void OnTerminationCompleted(const Error& error);
465
466  // This function does the final cleanup once a disconnect request terminates.
467  // Returns true, if the device state is successfully changed.
468  bool DisconnectCleanup();
469
470  // Executed after the asynchronous CellularCapability::StartModem
471  // call from OnAfterResume completes.
472  static void LogRestartModemResult(const Error& error);
473
474  // Terminate the pppd process associated with this Device, and remove the
475  // association between the PPPDevice and our CellularService. If this
476  // Device is not using PPP, the method has no effect.
477  void StopPPP();
478
479  // Handlers for PPP events. Dispatched from Notify().
480  void OnPPPAuthenticated();
481  void OnPPPAuthenticating();
482  void OnPPPConnected(const std::map<std::string, std::string>& params);
483  void OnPPPDisconnected();
484
485  void UpdateScanning();
486
487  base::WeakPtrFactory<Cellular> weak_ptr_factory_;
488
489  State state_;
490  ModemState modem_state_;
491
492  std::unique_ptr<CellularCapability> capability_;
493
494  // Operator info objects. These objects receive updates as we receive
495  // information about the network operators from the SIM or OTA. In turn, they
496  // send out updates through their observer interfaces whenever the identity of
497  // the network operator changes, or any other property of the operator
498  // changes.
499  std::unique_ptr<MobileOperatorInfo> home_provider_info_;
500  std::unique_ptr<MobileOperatorInfo> serving_operator_info_;
501  // Observer object to listen to updates from the operator info objects.
502  std::unique_ptr<MobileOperatorInfoObserver> mobile_operator_info_observer_;
503
504  // ///////////////////////////////////////////////////////////////////////////
505  // All DBus Properties exposed by the Cellular device.
506  // Properties common to GSM and CDMA modems.
507  const std::string dbus_service_;  // org.*.ModemManager*
508  const std::string dbus_path_;  // ModemManager.Modem
509  Stringmap home_provider_;
510
511  bool scanning_supported_;
512  std::string carrier_;
513  std::string esn_;
514  std::string firmware_revision_;
515  std::string hardware_revision_;
516  std::string imei_;
517  std::string imsi_;
518  std::string manufacturer_;
519  std::string mdn_;
520  std::string meid_;
521  std::string min_;
522  std::string model_id_;
523  std::string mm_plugin_;
524  bool scanning_;
525
526  // GSM only properties.
527  // They are always exposed but are non empty only for GSM technology modems.
528  std::string selected_network_;
529  Stringmaps found_networks_;
530  bool provider_requires_roaming_;
531  uint16_t scan_interval_;
532  bool sim_present_;
533  Stringmaps apn_list_;
534  std::string sim_identifier_;
535
536  // CDMA only properties.
537  uint16_t prl_version_;
538
539  // This property is specific to Gobi modems.
540  Strings supported_carriers_;
541  // End of DBus properties.
542  // ///////////////////////////////////////////////////////////////////////////
543
544  ModemInfo* modem_info_;
545  const Type type_;
546  PPPDeviceFactory* ppp_device_factory_;
547
548  ProcessManager* process_manager_;
549
550  CellularServiceRefPtr service_;
551
552  // User preference to allow or disallow roaming
553  bool allow_roaming_;
554
555  // Track whether a user initiated scan is in prgoress (initiated via ::Scan)
556  bool proposed_scan_in_progress_;
557
558  // Flag indicating that a disconnect has been explicitly requested.
559  bool explicit_disconnect_;
560
561  std::unique_ptr<ExternalTask> ppp_task_;
562  PPPDeviceRefPtr ppp_device_;
563  bool is_ppp_authenticating_;
564
565  // Sometimes modems may be stuck in the SEARCHING state during the lack of
566  // presence of a network. During this indefinite duration of time, keeping
567  // the Device.Scanning property as |true| causes a bad user experience.
568  // This callback sets it to |false| after a timeout period has passed.
569  base::CancelableClosure scanning_timeout_callback_;
570  int64_t scanning_timeout_milliseconds_;
571
572  DISALLOW_COPY_AND_ASSIGN(Cellular);
573};
574
575}  // namespace shill
576
577#endif  // SHILL_CELLULAR_CELLULAR_H_
578