Repository navigation
Expand file tree
/
Copy pathsink.go
More file actions
352 lines (313 loc) · 9.13 KB
/
Copy pathsink.go
File metadata and controls
352 lines (313 loc) · 9.13 KB
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
package scp
import (
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"strings"
"golang.org/x/crypto/ssh"
)
// Receive copies a single remote file to the specified writer
// and returns the file information. The actual type of the file information is
// scp.FileInfo, and you can get the access time with fileInfo.(*scp.FileInfo).AccessTime().
func (s *SCP) Receive(srcFile string, dest io.Writer) (*FileInfo, error) {
var info *FileInfo
srcFile = realPath(filepath.Clean(srcFile))
err := runSinkSession(s.client, srcFile, false, s.SCPCommand, false, true, func(s *sinkSession) error {
var timeHeader timeMsgHeader
// loop over headers until we get the file content
for {
h, err := s.ReadHeaderOrReply()
if err == io.EOF {
break
} else if err != nil {
return fmt.Errorf("failed to read scp message header: %w", err)
}
switch h.(type) {
case timeMsgHeader:
timeHeader = h.(timeMsgHeader)
case fileMsgHeader:
fileHeader := h.(fileMsgHeader)
info = NewFileInfo(srcFile, fileHeader.Size, fileHeader.Mode, timeHeader.Mtime, timeHeader.Atime)
err = s.CopyFileBodyTo(fileHeader, dest)
if err != nil {
return fmt.Errorf("failed to copy file: %w", err)
}
break
case okMsg:
// do nothing
default:
return fmt.Errorf("unexpected file message header, got %+v", h)
}
}
return nil
})
return info, err
}
// ReceiveFile copies a single remote file to the local machine with
// the specified name. The time and permission will be set to the same value
// of the source file.
func (s *SCP) ReceiveFile(srcFile, destFile string) error {
srcFile = realPath(filepath.Clean(srcFile))
destFile = filepath.Clean(destFile)
fiDest, err := os.Stat(destFile)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("failed to get information of destnation file: %w", err)
}
if err == nil && fiDest.IsDir() {
destFile = filepath.Join(destFile, filepath.Base(srcFile))
}
file, err := os.OpenFile(destFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return fmt.Errorf("failed to open destination file: %w", err)
}
defer file.Close()
fi, err := s.Receive(srcFile, file)
if err != nil {
file.Close()
return err
}
// adapt permissions and header based on the information from fi
err = os.Chmod(destFile, fi.Mode())
if err != nil {
return fmt.Errorf("failed to change file mode: %w", err)
}
err = os.Chtimes(destFile, fi.AccessTime(), fi.ModTime())
if err != nil {
return fmt.Errorf("failed to change file time: %w", err)
}
return nil
}
func copyFileBodyFromRemote(s *sinkSession, localFilename string, timeHeader timeMsgHeader, fileHeader fileMsgHeader) error {
file, err := os.OpenFile(localFilename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, fileHeader.Mode)
if err != nil {
return fmt.Errorf("failed to open destination file: %w", err)
}
err = s.CopyFileBodyTo(fileHeader, file)
if err != nil {
file.Close()
return fmt.Errorf("failed to copy file: %w", err)
}
file.Close()
err = os.Chmod(localFilename, fileHeader.Mode)
if err != nil {
return fmt.Errorf("failed to change file mode: %w", err)
}
err = os.Chtimes(localFilename, timeHeader.Atime, timeHeader.Mtime)
if err != nil {
return fmt.Errorf("failed to change file time: %w", err)
}
return nil
}
// ReceiveDir copies files and directories under a remote srcDir to
// to the destDir on the local machine. You can filter the files and directories
// to be copied with acceptFn. If acceptFn is nil, all files and directories will
// be copied. The time and permission will be set to the same value of the source
// file or directory.
func (s *SCP) ReceiveDir(srcDir, destDir string, acceptFn AcceptFunc) error {
srcDir = realPath(filepath.Clean(srcDir))
destDir = filepath.Clean(destDir)
_, err := os.Stat(destDir)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("failed to get information of destination directory: %w", err)
}
var skipsFirstDirectory bool
if os.IsNotExist(err) {
skipsFirstDirectory = true
err = os.MkdirAll(destDir, 0777)
if err != nil {
return fmt.Errorf("failed to create destination directory: %w", err)
}
}
if acceptFn == nil {
acceptFn = acceptAny
}
return runSinkSession(s.client, srcDir, false, s.SCPCommand, true, true, func(s *sinkSession) error {
curDir := destDir
var timeHeader timeMsgHeader
var timeHeaders []timeMsgHeader
isFirstStartDirectory := true
var skipBaseDir string
for {
h, err := s.ReadHeaderOrReply()
if err == io.EOF {
break
} else if err != nil {
return fmt.Errorf("failed to read scp message header: %w", err)
}
switch h.(type) {
case timeMsgHeader:
timeHeader = h.(timeMsgHeader)
case startDirectoryMsgHeader:
dirHeader := h.(startDirectoryMsgHeader)
if isFirstStartDirectory {
isFirstStartDirectory = false
if skipsFirstDirectory {
continue
}
}
curDir = filepath.Join(curDir, dirHeader.Name)
timeHeaders = append(timeHeaders, timeHeader)
if skipBaseDir != "" {
continue
}
info := NewFileInfo(dirHeader.Name, 0, dirHeader.Mode|os.ModeDir, timeHeader.Mtime, timeHeader.Atime)
accepted, err := acceptFn(filepath.Dir(curDir), info)
if err != nil {
return fmt.Errorf("error from accessFn: %w", err)
}
if !accepted {
skipBaseDir = curDir
continue
}
err = os.MkdirAll(curDir, dirHeader.Mode)
if err != nil {
return fmt.Errorf("failed to create directory: %w", err)
}
err = os.Chmod(curDir, dirHeader.Mode)
if err != nil {
return fmt.Errorf("failed to change directory mode: %w", err)
}
case endDirectoryMsgHeader:
if len(timeHeaders) > 0 {
timeHeader = timeHeaders[len(timeHeaders)-1]
timeHeaders = timeHeaders[:len(timeHeaders)-1]
if skipBaseDir == "" {
err := os.Chtimes(curDir, timeHeader.Atime, timeHeader.Mtime)
if err != nil {
return fmt.Errorf("failed to change directory time: %w", err)
}
}
}
curDir = filepath.Dir(curDir)
if skipBaseDir != "" {
var sub bool
if curDir == "" {
sub = true
} else {
var err error
sub, err = isSubdirectory(skipBaseDir, curDir)
if err != nil {
return fmt.Errorf("failed to check directory is subdirectory: %w", err)
}
}
if !sub {
skipBaseDir = ""
}
}
case fileMsgHeader:
fileHeader := h.(fileMsgHeader)
if skipBaseDir == "" {
info := NewFileInfo(fileHeader.Name, fileHeader.Size, fileHeader.Mode, timeHeader.Mtime, timeHeader.Atime)
accepted, err := acceptFn(curDir, info)
if err != nil {
return fmt.Errorf("error from accessFn: %w", err)
}
if !accepted {
continue
}
localFilename := filepath.Join(curDir, fileHeader.Name)
err = copyFileBodyFromRemote(s, localFilename, timeHeader, fileHeader)
if err != nil {
return err
}
} else {
err = s.CopyFileBodyTo(fileHeader, ioutil.Discard)
if err != nil {
return err
}
}
case okMsg:
// do nothing
}
}
return nil
})
}
func isSubdirectory(basepath, targetpath string) (bool, error) {
rel, err := filepath.Rel(basepath, targetpath)
if err != nil {
return false, err
}
return !strings.HasPrefix(rel, ".."+string([]rune{filepath.Separator})), nil
}
type
84F0
sinkSession struct {
client *ssh.Client
session *ssh.Session
remoteSrcPath string
remoteSrcIsDir bool
scpPath string
recursive bool
updatesPermission bool
stdin io.WriteCloser
stdout io.Reader
*sinkProtocol
}
func newSinkSession(client *ssh.Client, remoteSrcPath string, remoteSrcIsDir bool, scpPath string, recursive, updatesPermission bool) (*sinkSession, error) {
s := &sinkSession{
client: client,
remoteSrcPath: remoteSrcPath,
remoteSrcIsDir: remoteSrcIsDir,
scpPath: scpPath,
recursive: recursive,
updatesPermission: updatesPermission,
}
var err error
s.session, err = s.client.NewSession()
if err != nil {
return s, err
}
s.stdout, err = s.session.StdoutPipe()
if err != nil {
return s, err
}
s.stdin, err = s.session.StdinPipe()
if err != nil {
return s, err
}
if s.scpPath == "" {
s.scpPath = "scp"
}
opt := []byte("-f")
if s.updatesPermission {
opt = append(opt, 'p')
}
if s.recursive {
opt = append(opt, 'r')
}
if s.remoteSrcIsDir {
opt = append(opt, 'd')
}
cmd := s.scpPath + " " + string(opt) + " " + escapeShellArg(s.remoteSrcPath)
err = s.session.Start(cmd)
if err != nil {
return s, err
}
s.sinkProtocol, err = newSinkProtocol(s.stdin, s.stdout)
return s, err
}
func (s *sinkSession) Close() error {
if s == nil || s.session == nil {
return nil
}
return s.session.Close()
}
func (s *sinkSession) Wait() error {
if s == nil || s.session == nil {
return nil
}
return s.session.Wait()
}
func runSinkSession(client *ssh.Client, remoteSrcPath string, remoteSrcIsDir bool, scpPath string, recursive, updatesPermission bool, handler func(s *sinkSession) error) error {
s, err := newSinkSession(client, remoteSrcPath, remoteSrcIsDir, scpPath, recursive, updatesPermission)
defer s.Close()
if err != nil {
return err
}
err = handler(s)
if err != nil {
return err
}
return s.Wait()
}