1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_ASH_COMPONENTS_SMBFS_SMBFS_MOUNTER_H_
#define CHROMEOS_ASH_COMPONENTS_SMBFS_SMBFS_MOUNTER_H_
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "base/component_export.h"
#include "base/files/scoped_file.h"
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "base/unguessable_token.h"
#include "chromeos/ash/components/disks/disk_mount_manager.h"
#include "chromeos/ash/components/disks/mount_point.h"
#include "chromeos/ash/components/smbfs/mojom/smbfs.mojom.h"
#include "chromeos/ash/components/smbfs/smbfs_host.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/system/invitation.h"
#include "net/base/ip_address.h"
namespace smbfs {
// SmbFsMounter is a helper class that is used to mount an instance of smbfs. It
// performs all the actions necessary to start smbfs and initiate a connection
// to the SMB server.
class COMPONENT_EXPORT(CHROMEOS_ASH_COMPONENTS_SMBFS) SmbFsMounter {
public:
using DoneCallback =
base::OnceCallback<void(mojom::MountError, std::unique_ptr<SmbFsHost>)>;
struct KerberosOptions {
using Source = mojom::KerberosConfig::Source;
KerberosOptions(Source source, const std::string& identity);
~KerberosOptions();
// Don't allow an invalid options struct to be created.
KerberosOptions() = delete;
Source source;
std::string identity;
};
struct MountOptions {
MountOptions();
MountOptions(const MountOptions&);
~MountOptions();
// Resolved IP address for share's hostname.
net::IPAddress resolved_host;
// Authentication options.
std::string username;
std::string workgroup;
std::string password;
std::optional<KerberosOptions> kerberos_options;
// Allow NTLM authentication to be used.
bool allow_ntlm = false;
// Skip attempting to connect to the share.
bool skip_connect = false;
// Run /usr/sbin/smbfs with a chattier log-level.
bool enable_verbose_logging = false;
// Have smbfs save/restore the share's password.
bool save_restore_password = false;
std::string account_hash;
std::vector<uint8_t> password_salt;
};
SmbFsMounter(const std::string& share_path,
const std::string& mount_dir_name,
const MountOptions& options,
SmbFsHost::Delegate* delegate,
ash::disks::DiskMountManager* disk_mount_manager);
SmbFsMounter(const SmbFsMounter&) = delete;
SmbFsMounter& operator=(const SmbFsMounter&) = delete;
virtual ~SmbFsMounter();
// Initiate the filesystem mount request, and run |callback| when completed.
// |callback| is guaranteed not to run after |this| is destroyed.
// Must only be called once. Virtual for testing.
virtual void Mount(DoneCallback callback);
protected:
// Additional constructors for tests.
SmbFsMounter();
SmbFsMounter(const std::string& share_path,
const std::string& mount_dir_name,
const MountOptions& options,
SmbFsHost::Delegate* delegate,
ash::disks::DiskMountManager* disk_mount_manager,
mojo::Remote<mojom::SmbFsBootstrap> bootstrap);
private:
// Callback for MountPoint::Mount().
void OnMountDone(ash::MountError error_code,
std::unique_ptr<ash::disks::MountPoint> mount_point);
// Callback for receiving a Mojo bootstrap channel.
void OnIpcChannel(base::ScopedFD mojo_fd);
// Callback for bootstrap Mojo MountShare() method.
void OnMountShare(
mojo::PendingReceiver<mojom::SmbFsDelegate> delegate_receiver,
mojom::MountError mount_error,
mojo::PendingRemote<mojom::SmbFs> smbfs);
// Mojo disconnection handler.
void OnMojoDisconnect();
// Mount timeout handler.
void OnMountTimeout();
// Perform cleanup and run |callback_| with |mount_error|.
void ProcessMountError(mojom::MountError mount_error);
const std::string share_path_;
const std::string mount_dir_name_;
const MountOptions options_;
const raw_ptr<SmbFsHost::Delegate> delegate_;
const raw_ptr<ash::disks::DiskMountManager> disk_mount_manager_;
const base::UnguessableToken token_;
const std::string mount_url_;
bool mojo_fd_pending_ = false;
base::OneShotTimer mount_timer_;
DoneCallback callback_;
std::unique_ptr<ash::disks::MountPoint> mount_point_;
mojo::OutgoingInvitation bootstrap_invitation_;
mojo::Remote<mojom::SmbFsBootstrap> bootstrap_;
base::WeakPtrFactory<SmbFsMounter> weak_factory_{this};
};
} // namespace smbfs
#endif // CHROMEOS_ASH_COMPONENTS_SMBFS_SMBFS_MOUNTER_H_
|
