// handleDir creates or updates the given directory func (p *Puller) handleDir(file protocol.FileInfo) { realName := filepath.Join(p.dir, file.Name) mode := os.FileMode(file.Flags & 0777) if p.ignorePerms { mode = 0755 } if debug { curFile := p.model.CurrentFolderFile(p.folder, file.Name) l.Debugf("need dir\n\t%v\n\t%v", file, curFile) } info, err := os.Lstat(realName) isLink, _ := symlinks.IsSymlink(realName) switch { // There is already something under that name, but it's a file/link. // Most likely a file/link is getting replaced with a directory. // Remove the file/link and fall through to directory creation. case isLink || (err == nil && !info.IsDir()): err = osutil.InWritableDir(os.Remove, realName) if err != nil { l.Infof("Puller (folder %q, dir %q): %v", p.folder, file.Name, err) return } fallthrough // The directory doesn't exist, so we create it with the right // mode bits from the start. case err != nil && os.IsNotExist(err): // We declare a function that acts on only the path name, so // we can pass it to InWritableDir. We use a regular Mkdir and // not MkdirAll because the parent should already exist. mkdir := func(path string) error { return os.Mkdir(path, mode) } if err = osutil.InWritableDir(mkdir, realName); err == nil { p.model.updateLocal(p.folder, file) } else { l.Infof("Puller (folder %q, dir %q): %v", p.folder, file.Name, err) } return // Weird error when stat()'ing the dir. Probably won't work to do // anything else with it if we can't even stat() it. case err != nil: l.Infof("Puller (folder %q, dir %q): %v", p.folder, file.Name, err) return } // The directory already exists, so we just correct the mode bits. (We // don't handle modification times on directories, because that sucks...) // It's OK to change mode bits on stuff within non-writable directories. if p.ignorePerms { p.model.updateLocal(p.folder, file) } else if err := os.Chmod(realName, mode); err == nil { p.model.updateLocal(p.folder, file) } else { l.Infof("Puller (folder %q, dir %q): %v", p.folder, file.Name, err) } }
func startWalker(dir string, res chan<- fileInfo, abort <-chan struct{}) { walker := func(path string, info os.FileInfo, err error) error { if err != nil { return err } rn, _ := filepath.Rel(dir, path) if rn == "." || rn == ".stfolder" { return nil } var f fileInfo if ok, err := symlinks.IsSymlink(path); err == nil && ok { f = fileInfo{ name: rn, mode: os.ModeSymlink, } tgt, _, err := symlinks.Read(path) if err != nil { return err } h := md5.New() h.Write([]byte(tgt)) hash := h.Sum(nil) copy(f.hash[:], hash) } else if info.IsDir() { f = fileInfo{ name: rn, mode: info.Mode(), // hash and modtime zero for directories } } else { f = fileInfo{ name: rn, mode: info.Mode(), mod: info.ModTime().Unix(), } sum, err := md5file(path) if err != nil { return err } f.hash = sum } select { case res <- f: return nil case <-abort: return errors.New("abort") } } go func() { filepath.Walk(dir, walker) close(res) }() }
func (p *Puller) performFinish(state *sharedPullerState) { // Verify the file against expected hashes fd, err := os.Open(state.tempName) if err != nil { l.Warnln("puller: final:", err) return } err = scanner.Verify(fd, protocol.BlockSize, state.file.Blocks) fd.Close() if err != nil { l.Infoln("puller:", state.file.Name, err, "(file changed during pull?)") return } // Set the correct permission bits on the new file if !p.ignorePerms { err = os.Chmod(state.tempName, os.FileMode(state.file.Flags&0777)) if err != nil { l.Warnln("puller: final:", err) return } } // Set the correct timestamp on the new file t := time.Unix(state.file.Modified, 0) err = os.Chtimes(state.tempName, t, t) if err != nil { if p.lenientMtimes { // We accept the failure with a warning here and allow the sync to // continue. We'll sync the new mtime back to the other devices later. // If they have the same problem & setting, we might never get in // sync. l.Infof("Puller (folder %q, file %q): final: %v (continuing anyway as requested)", p.folder, state.file.Name, err) } else { l.Warnln("puller: final:", err) return } } // If we should use versioning, let the versioner archive the old // file before we replace it. Archiving a non-existent file is not // an error. if p.versioner != nil { err = p.versioner.Archive(state.realName) if err != nil { l.Warnln("puller: final:", err) return } } // If the target path is a symlink or a directory, we cannot copy // over it, hence remove it before proceeding. stat, err := os.Lstat(state.realName) isLink, _ := symlinks.IsSymlink(state.realName) if isLink || (err == nil && stat.IsDir()) { osutil.InWritableDir(os.Remove, state.realName) } // Replace the original content with the new one err = osutil.Rename(state.tempName, state.realName) if err != nil { l.Warnln("puller: final:", err) return } // If it's a symlink, the target of the symlink is inside the file. if state.file.IsSymlink() { content, err := ioutil.ReadFile(state.realName) if err != nil { l.Warnln("puller: final: reading symlink:", err) return } // Remove the file, and replace it with a symlink. err = osutil.InWritableDir(func(path string) error { os.Remove(path) return symlinks.Create(path, string(content), state.file.Flags) }, state.realName) if err != nil { l.Warnln("puller: final: creating symlink:", err) return } } // Record the updated file in the index p.model.updateLocal(p.folder, state.file) }
func (w *Walker) walkAndHashFiles(fchan chan protocol.FileInfo) filepath.WalkFunc { return func(p string, info os.FileInfo, err error) error { if err != nil { if debug { l.Debugln("error:", p, info, err) } return nil } rn, err := filepath.Rel(w.Dir, p) if err != nil { if debug { l.Debugln("rel error:", p, err) } return nil } if rn == "." { return nil } if w.TempNamer != nil && w.TempNamer.IsTemporary(rn) { // A temporary file if debug { l.Debugln("temporary:", rn) } return nil } if sn := filepath.Base(rn); sn == ".stignore" || sn == ".stfolder" || strings.HasPrefix(rn, ".stversions") || (w.Matcher != nil && w.Matcher.Match(rn)) { // An ignored file if debug { l.Debugln("ignored:", rn) } if info.IsDir() { return filepath.SkipDir } return nil } if (runtime.GOOS == "linux" || runtime.GOOS == "windows") && !norm.NFC.IsNormalString(rn) { l.Warnf("File %q contains non-NFC UTF-8 sequences and cannot be synced. Consider renaming.", rn) return nil } // We must perform this check, as symlinks on Windows are always // .IsRegular or .IsDir unlike on Unix. // Index wise symlinks are always files, regardless of what the target // is, because symlinks carry their target path as their content. isSymlink, _ := symlinks.IsSymlink(p) if isSymlink { var rval error // If the target is a directory, do NOT descend down there. // This will cause files to get tracked, and removing the symlink // will as a result remove files in their real location. // But do not SkipDir if the target is not a directory, as it will // stop scanning the current directory. if info.IsDir() { rval = filepath.SkipDir } // We always rehash symlinks as they have no modtime or // permissions. // We check if they point to the old target by checking that // their existing blocks match with the blocks in the index. // If we don't have a filer or don't support symlinks, skip. if w.CurrentFiler == nil || !symlinks.Supported { return rval } target, flags, err := symlinks.Read(p) flags = flags & protocol.SymlinkTypeMask if err != nil { if debug { l.Debugln("readlink error:", p, err) } return rval } blocks, err := Blocks(strings.NewReader(target), w.BlockSize, 0) if err != nil { if debug { l.Debugln("hash link error:", p, err) } return rval } cf := w.CurrentFiler.CurrentFile(rn) if !cf.IsDeleted() && cf.IsSymlink() && SymlinkTypeEqual(flags, cf.Flags) && BlocksEqual(cf.Blocks, blocks) { return rval } f := protocol.FileInfo{ Name: rn, Version: lamport.Default.Tick(0), Flags: protocol.FlagSymlink | flags | protocol.FlagNoPermBits | 0666, Modified: 0, Blocks: blocks, } if debug { l.Debugln("symlink to hash:", p, f) } fchan <- f return rval } if info.Mode().IsDir() { if w.CurrentFiler != nil { cf := w.CurrentFiler.CurrentFile(rn) permUnchanged := w.IgnorePerms || !cf.HasPermissionBits() || PermsEqual(cf.Flags, uint32(info.Mode())) if !cf.IsDeleted() && cf.IsDirectory() && permUnchanged { return nil } } var flags uint32 = protocol.FlagDirectory if w.IgnorePerms { flags |= protocol.FlagNoPermBits | 0777 } else { flags |= uint32(info.Mode() & os.ModePerm) } f := protocol.FileInfo{ Name: rn, Version: lamport.Default.Tick(0), Flags: flags, Modified: info.ModTime().Unix(), } if debug { l.Debugln("dir:", p, f) } fchan <- f return nil } if info.Mode().IsRegular() { if w.CurrentFiler != nil { cf := w.CurrentFiler.CurrentFile(rn) permUnchanged := w.IgnorePerms || !cf.HasPermissionBits() || PermsEqual(cf.Flags, uint32(info.Mode())) if !cf.IsDeleted() && cf.Modified == info.ModTime().Unix() && permUnchanged { return nil } if debug { l.Debugln("rescan:", cf, info.ModTime().Unix(), info.Mode()&os.ModePerm) } } var flags = uint32(info.Mode() & os.ModePerm) if w.IgnorePerms { flags = protocol.FlagNoPermBits | 0666 } f := protocol.FileInfo{ Name: rn, Version: lamport.Default.Tick(0), Flags: flags, Modified: info.ModTime().Unix(), } if debug { l.Debugln("to hash:", p, f) } fchan <- f } return nil } }