// receives and prints discovery announcements func recv(bc beacon.Interface) { seen := make(map[string]bool) for { data, src := bc.Recv() var ann discover.Announce ann.UnmarshalXDR(data) if bytes.Equal(ann.This.ID, myID) { // This is one of our own fake packets, don't print it. continue } // Print announcement details for the first packet from a given // device ID and source address, or if -all was given. key := string(ann.This.ID) + src.String() if all || !seen[key] { log.Printf("Announcement from %v\n", src) log.Printf(" %v at %s\n", protocol.DeviceIDFromBytes(ann.This.ID), strings.Join(addrStrs(ann.This), ", ")) for _, dev := range ann.Extra { log.Printf(" %v at %s\n", protocol.DeviceIDFromBytes(dev.ID), strings.Join(addrStrs(dev), ", ")) } seen[key] = true } } }
// ldbRemoveFromGlobal removes the device from the global version list for the // given file. If the version list is empty after this, the file entry is // removed entirely. func ldbRemoveFromGlobal(db dbReader, batch dbWriter, folder, device, file []byte) { l.Debugf("remove from global; folder=%q device=%v file=%q", folder, protocol.DeviceIDFromBytes(device), file) gk := globalKey(folder, file) svl, err := db.Get(gk, nil) if err != nil { // We might be called to "remove" a global version that doesn't exist // if the first update for the file is already marked invalid. return } var fl versionList err = fl.UnmarshalXDR(svl) if err != nil { panic(err) } for i := range fl.versions { if bytes.Compare(fl.versions[i].device, device) == 0 { fl.versions = append(fl.versions[:i], fl.versions[i+1:]...) break } } if len(fl.versions) == 0 { l.Debugf("batch.Delete %p %x", batch, gk) batch.Delete(gk) } else { l.Debugf("batch.Put %p %x", batch, gk) l.Debugf("new global after remove: %v", fl) batch.Put(gk, fl.MustMarshalXDR()) } }
func (c *localClient) recvAnnouncements(b beacon.Interface) { for { buf, addr := b.Recv() var pkt Announce err := pkt.UnmarshalXDR(buf) if err != nil && err != io.EOF { l.Debugf("discover: Failed to unmarshal local announcement from %s:\n%s", addr, hex.Dump(buf)) continue } if pkt.Magic != AnnouncementMagic { l.Debugf("discover: Incorrect magic from %s: %s != %s", addr, pkt.Magic, AnnouncementMagic) continue } l.Debugf("discover: Received local announcement from %s for %s", addr, protocol.DeviceIDFromBytes(pkt.This.ID)) var newDevice bool if !bytes.Equal(pkt.This.ID, c.myID[:]) { newDevice = c.registerDevice(addr, pkt.This) } if newDevice { // Force a transmit to announce ourselves, if we are ready to do // so right away. select { case c.forcedBcastTick <- time.Now(): default: } } } }
func (t readWriteTransaction) insertFile(folder, device []byte, file protocol.FileInfo) { l.Debugf("insert; folder=%q device=%v %v", folder, protocol.DeviceIDFromBytes(device), file) name := []byte(file.Name) nk := t.db.deviceKey(folder, device, name) t.Put(nk, mustMarshal(&file)) }
func ldbAvailability(db *leveldb.DB, folder, file []byte) []protocol.DeviceID { k := globalKey(folder, file) bs, err := db.Get(k, nil) if err == leveldb.ErrNotFound { return nil } if err != nil { panic(err) } var vl versionList err = vl.UnmarshalXDR(bs) if err != nil { panic(err) } var devices []protocol.DeviceID for _, v := range vl.versions { if !v.version.Equal(vl.versions[0].version) { break } n := protocol.DeviceIDFromBytes(v.device) devices = append(devices, n) } return devices }
func (c *localClient) recvAnnouncements(b beacon.Interface) { for { buf, addr := b.Recv() var pkt Announce err := pkt.UnmarshalXDR(buf) if err != nil && err != io.EOF { l.Debugf("discover: Failed to unmarshal local announcement from %s:\n%s", addr, hex.Dump(buf)) continue } l.Debugf("discover: Received local announcement from %s for %s", addr, protocol.DeviceIDFromBytes(pkt.This.ID)) var newDevice bool if bytes.Compare(pkt.This.ID, c.myID[:]) != 0 { newDevice = c.registerDevice(addr, pkt.This) } if newDevice { select { case c.forcedBcastTick <- time.Now(): } } } }
func dump(ldb *db.Instance) { it := ldb.NewIterator(nil, nil) for it.Next() { key := it.Key() switch key[0] { case db.KeyTypeDevice: folder := binary.BigEndian.Uint32(key[1:]) device := binary.BigEndian.Uint32(key[1+4:]) name := nulString(key[1+4+4:]) fmt.Printf("[device] F:%d D:%d N:%q", folder, device, name) var f protocol.FileInfo err := f.Unmarshal(it.Value()) if err != nil { log.Fatal(err) } fmt.Printf(" V:%v\n", f) case db.KeyTypeGlobal: folder := binary.BigEndian.Uint32(key[1:]) name := nulString(key[1+4:]) var flv db.VersionList flv.Unmarshal(it.Value()) fmt.Printf("[global] F:%d N:%q V:%s\n", folder, name, flv) case db.KeyTypeBlock: folder := binary.BigEndian.Uint32(key[1:]) hash := key[1+4 : 1+4+32] name := nulString(key[1+4+32:]) fmt.Printf("[block] F:%d H:%x N:%q I:%d\n", folder, hash, name, binary.BigEndian.Uint32(it.Value())) case db.KeyTypeDeviceStatistic: fmt.Printf("[dstat] K:%x V:%x\n", it.Key(), it.Value()) case db.KeyTypeFolderStatistic: fmt.Printf("[fstat] K:%x V:%x\n", it.Key(), it.Value()) case db.KeyTypeVirtualMtime: fmt.Printf("[mtime] K:%x V:%x\n", it.Key(), it.Value()) case db.KeyTypeFolderIdx: key := binary.BigEndian.Uint32(it.Key()[1:]) fmt.Printf("[folderidx] K:%d V:%q\n", key, it.Value()) case db.KeyTypeDeviceIdx: key := binary.BigEndian.Uint32(it.Key()[1:]) val := it.Value() if len(val) == 0 { fmt.Printf("[deviceidx] K:%d V:<nil>\n", key) } else { dev := protocol.DeviceIDFromBytes(val) fmt.Printf("[deviceidx] K:%d V:%s\n", key, dev) } default: fmt.Printf("[???]\n %x\n %x\n", it.Key(), it.Value()) } } }
func (db *Instance) replace(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) { db.genericReplace(folder, device, fs, localSize, globalSize, func(t readWriteTransaction, folder, device, name []byte, dbi iterator.Iterator) { // Database has a file that we are missing. Remove it. l.Debugf("delete; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name) t.removeFromGlobal(folder, device, name, globalSize) t.Delete(dbi.Key()) }) }
func ldbReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) int64 { // TODO: Return the remaining maxLocalVer? return ldbGenericReplace(db, folder, device, fs, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) int64 { // Database has a file that we are missing. Remove it. l.Debugf("delete; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name) ldbRemoveFromGlobal(db, batch, folder, device, name) l.Debugf("batch.Delete %p %x", batch, dbi.Key()) batch.Delete(dbi.Key()) return 0 }) }
func (t readWriteTransaction) insertFile(folder, device []byte, file protocol.FileInfo) int64 { l.Debugf("insert; folder=%q device=%v %v", folder, protocol.DeviceIDFromBytes(device), file) if file.LocalVersion == 0 { file.LocalVersion = clock(0) } name := []byte(file.Name) nk := deviceKey(folder, device, name) t.Put(nk, file.MustMarshalXDR()) return file.LocalVersion }
func (c *localClient) recvAnnouncements(b beacon.Interface) { warnedAbout := make(map[string]bool) for { buf, addr := b.Recv() if len(buf) < 4 { l.Debugf("discover: short packet from %s") continue } magic := binary.BigEndian.Uint32(buf) switch magic { case Magic: // All good case v13Magic: // Old version if !warnedAbout[addr.String()] { l.Warnf("Incompatible (v0.13) local discovery packet from %v - upgrade that device to connect", addr) warnedAbout[addr.String()] = true } continue default: l.Debugf("discover: Incorrect magic %x from %s", magic, addr) continue } var pkt Announce err := pkt.Unmarshal(buf[4:]) if err != nil && err != io.EOF { l.Debugf("discover: Failed to unmarshal local announcement from %s:\n%s", addr, hex.Dump(buf)) continue } l.Debugf("discover: Received local announcement from %s for %s", addr, protocol.DeviceIDFromBytes(pkt.ID)) var newDevice bool if !bytes.Equal(pkt.ID, c.myID[:]) { newDevice = c.registerDevice(addr, pkt) } if newDevice { // Force a transmit to announce ourselves, if we are ready to do // so right away. select { case c.forcedBcastTick <- time.Now(): default: } } } }
func ldbInsert(batch dbWriter, folder, device []byte, file protocol.FileInfo) int64 { l.Debugf("insert; folder=%q device=%v %v", folder, protocol.DeviceIDFromBytes(device), file) if file.LocalVersion == 0 { file.LocalVersion = clock(0) } name := []byte(file.Name) nk := deviceKey(folder, device, name) l.Debugf("batch.Put %p %x", batch, nk) batch.Put(nk, file.MustMarshalXDR()) return file.LocalVersion }
// ldbRemoveFromGlobal removes the device from the global version list for the // given file. If the version list is empty after this, the file entry is // removed entirely. func ldbRemoveFromGlobal(db dbReader, batch dbWriter, folder, device, file []byte, globalSize *sizeTracker) { l.Debugf("remove from global; folder=%q device=%v file=%q", folder, protocol.DeviceIDFromBytes(device), file) gk := globalKey(folder, file) svl, err := db.Get(gk, nil) if err != nil { // We might be called to "remove" a global version that doesn't exist // if the first update for the file is already marked invalid. return } var fl versionList err = fl.UnmarshalXDR(svl) if err != nil { panic(err) } removed := false for i := range fl.versions { if bytes.Compare(fl.versions[i].device, device) == 0 { if i == 0 && globalSize != nil { f, ok := ldbGet(db, folder, device, file) if !ok { panic("removing nonexistent file") } globalSize.removeFile(f) removed = true } fl.versions = append(fl.versions[:i], fl.versions[i+1:]...) break } } if len(fl.versions) == 0 { l.Debugf("batch.Delete %p %x", batch, gk) batch.Delete(gk) } else { l.Debugf("batch.Put %p %x", batch, gk) l.Debugf("new global after remove: %v", fl) batch.Put(gk, fl.MustMarshalXDR()) if removed { f, ok := ldbGet(db, folder, fl.versions[0].device, file) if !ok { panic("new global is nonexistent file") } globalSize.addFile(f) } } }
func main() { flag.BoolVar(&all, "all", all, "Print all received announcements (not only first)") flag.BoolVar(&fake, "fake", fake, "Send fake announcements") flag.StringVar(&mc, "mc", mc, "IPv6 multicast address") flag.IntVar(&bc, "bc", bc, "IPv4 broadcast port number") flag.Parse() if fake { log.Println("My ID:", protocol.DeviceIDFromBytes(myID)) } runbeacon(beacon.NewMulticast(mc), fake) runbeacon(beacon.NewBroadcast(bc), fake) select {} }
// removeFromGlobal removes the device from the global version list for the // given file. If the version list is empty after this, the file entry is // removed entirely. func (t readWriteTransaction) removeFromGlobal(folder, device, file []byte, globalSize *sizeTracker) { l.Debugf("remove from global; folder=%q device=%v file=%q", folder, protocol.DeviceIDFromBytes(device), file) gk := t.db.globalKey(folder, file) svl, err := t.Get(gk, nil) if err != nil { // We might be called to "remove" a global version that doesn't exist // if the first update for the file is already marked invalid. return } var fl VersionList err = fl.Unmarshal(svl) if err != nil { panic(err) } removed := false for i := range fl.Versions { if bytes.Equal(fl.Versions[i].Device, device) { if i == 0 && globalSize != nil { f, ok := t.getFile(folder, device, file) if !ok { panic("removing nonexistent file") } globalSize.removeFile(f) removed = true } fl.Versions = append(fl.Versions[:i], fl.Versions[i+1:]...) break } } if len(fl.Versions) == 0 { t.Delete(gk) } else { l.Debugf("new global after remove: %v", fl) t.Put(gk, mustMarshal(&fl)) if removed { f, ok := t.getFile(folder, fl.Versions[0].Device, file) if !ok { panic("new global is nonexistent file") } globalSize.addFile(f) } } }
func ldbWithNeed(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterator) { runtime.GC() start := globalKey(folder, nil) limit := globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff}) snap, err := db.GetSnapshot() if err != nil { panic(err) } if debugDB { l.Debugf("created snapshot %p", snap) } defer func() { if debugDB { l.Debugf("close snapshot %p", snap) } snap.Release() }() dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil) defer dbi.Release() var fk []byte nextFile: for dbi.Next() { var vl versionList err := vl.UnmarshalXDR(dbi.Value()) if err != nil { panic(err) } if len(vl.versions) == 0 { l.Debugln(dbi.Key()) panic("no versions?") } have := false // If we have the file, any version need := false // If we have a lower version of the file var haveVersion protocol.Vector for _, v := range vl.versions { if bytes.Compare(v.device, device) == 0 { have = true haveVersion = v.version // XXX: This marks Concurrent (i.e. conflicting) changes as // needs. Maybe we should do that, but it needs special // handling in the puller. need = !v.version.GreaterEqual(vl.versions[0].version) break } } if need || !have { name := globalKeyName(dbi.Key()) needVersion := vl.versions[0].version nextVersion: for i := range vl.versions { if !vl.versions[i].version.Equal(needVersion) { // We haven't found a valid copy of the file with the needed version. continue nextFile } fk = deviceKeyInto(fk[:cap(fk)], folder, vl.versions[i].device, name) if debugDB { l.Debugf("snap.Get %p %x", snap, fk) } bs, err := snap.Get(fk, nil) if err != nil { var id protocol.DeviceID copy(id[:], device) l.Debugf("device: %v", id) l.Debugf("need: %v, have: %v", need, have) l.Debugf("key: %q (%x)", dbi.Key(), dbi.Key()) l.Debugf("vl: %v", vl) l.Debugf("i: %v", i) l.Debugf("fk: %q (%x)", fk, fk) l.Debugf("name: %q (%x)", name, name) panic(err) } gf, err := unmarshalTrunc(bs, truncate) if err != nil { panic(err) } if gf.IsInvalid() { // The file is marked invalid for whatever reason, don't use it. continue nextVersion } if gf.IsDeleted() && !have { // We don't need deleted files that we don't have continue nextFile } if debugDB { l.Debugf("need folder=%q device=%v name=%q need=%v have=%v haveV=%d globalV=%d", folder, protocol.DeviceIDFromBytes(device), name, need, have, haveVersion, vl.versions[0].version) } if cont := fn(gf); !cont { return } // This file is handled, no need to look further in the version list continue nextFile } } } }
// ldbUpdateGlobal adds this device+version to the version list for the given // file. If the device is already present in the list, the version is updated. // If the file does not have an entry in the global list, it is created. func ldbUpdateGlobal(db dbReader, batch dbWriter, folder, device []byte, file protocol.FileInfo) bool { if debugDB { l.Debugf("update global; folder=%q device=%v file=%q version=%d", folder, protocol.DeviceIDFromBytes(device), file.Name, file.Version) } name := []byte(file.Name) gk := globalKey(folder, name) svl, err := db.Get(gk, nil) if err != nil && err != leveldb.ErrNotFound { panic(err) } var fl versionList // Remove the device from the current version list if svl != nil { err = fl.UnmarshalXDR(svl) if err != nil { panic(err) } for i := range fl.versions { if bytes.Compare(fl.versions[i].device, device) == 0 { if fl.versions[i].version.Equal(file.Version) { // No need to do anything return false } fl.versions = append(fl.versions[:i], fl.versions[i+1:]...) break } } } nv := fileVersion{ device: device, version: file.Version, } // Find a position in the list to insert this file. The file at the front // of the list is the newer, the "global". for i := range fl.versions { switch fl.versions[i].version.Compare(file.Version) { case protocol.Equal, protocol.Lesser: // The version at this point in the list is equal to or lesser // ("older") than us. We insert ourselves in front of it. fl.versions = insertVersion(fl.versions, i, nv) goto done case protocol.ConcurrentLesser, protocol.ConcurrentGreater: // The version at this point is in conflict with us. We must pull // the actual file metadata to determine who wins. If we win, we // insert ourselves in front of the loser here. (The "Lesser" and // "Greater" in the condition above is just based on the device // IDs in the version vector, which is not the only thing we use // to determine the winner.) of, ok := ldbGet(db, folder, fl.versions[i].device, name) if !ok { panic("file referenced in version list does not exist") } if file.WinsConflict(of) { fl.versions = insertVersion(fl.versions, i, nv) goto done } } } // We didn't find a position for an insert above, so append to the end. fl.versions = append(fl.versions, nv) done: if debugDB { l.Debugf("batch.Put %p %x", batch, gk) l.Debugf("new global after update: %v", fl) } batch.Put(gk, fl.MustMarshalXDR()) return true }
func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, deleteFn deletionHandler) int64 { runtime.GC() sort.Sort(fileList(fs)) // sort list on name, same as in the database start := deviceKey(folder, device, nil) // before all folder/device files limit := deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files batch := new(leveldb.Batch) if debugDB { l.Debugf("new batch %p", batch) } snap, err := db.GetSnapshot() if err != nil { panic(err) } if debugDB { l.Debugf("created snapshot %p", snap) } defer func() { if debugDB { l.Debugf("close snapshot %p", snap) } snap.Release() }() dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil) defer dbi.Release() moreDb := dbi.Next() fsi := 0 var maxLocalVer int64 for { var newName, oldName []byte moreFs := fsi < len(fs) if !moreDb && !moreFs { break } if moreFs { newName = []byte(fs[fsi].Name) } if moreDb { oldName = deviceKeyName(dbi.Key()) } cmp := bytes.Compare(newName, oldName) if debugDB { l.Debugf("generic replace; folder=%q device=%v moreFs=%v moreDb=%v cmp=%d newName=%q oldName=%q", folder, protocol.DeviceIDFromBytes(device), moreFs, moreDb, cmp, newName, oldName) } switch { case moreFs && (!moreDb || cmp == -1): if debugDB { l.Debugln("generic replace; missing - insert") } // Database is missing this file. Insert it. if lv := ldbInsert(batch, folder, device, fs[fsi]); lv > maxLocalVer { maxLocalVer = lv } if fs[fsi].IsInvalid() { ldbRemoveFromGlobal(snap, batch, folder, device, newName) } else { ldbUpdateGlobal(snap, batch, folder, device, fs[fsi]) } fsi++ case moreFs && moreDb && cmp == 0: // File exists on both sides - compare versions. We might get an // update with the same version and different flags if a device has // marked a file as invalid, so handle that too. if debugDB { l.Debugln("generic replace; exists - compare") } var ef FileInfoTruncated ef.UnmarshalXDR(dbi.Value()) if !fs[fsi].Version.Equal(ef.Version) || fs[fsi].Flags != ef.Flags { if debugDB { l.Debugln("generic replace; differs - insert") } if lv := ldbInsert(batch, folder, device, fs[fsi]); lv > maxLocalVer { maxLocalVer = lv } if fs[fsi].IsInvalid() { ldbRemoveFromGlobal(snap, batch, folder, device, newName) } else { ldbUpdateGlobal(snap, batch, folder, device, fs[fsi]) } } else if debugDB { l.Debugln("generic replace; equal - ignore") } fsi++ moreDb = dbi.Next() case moreDb && (!moreFs || cmp == 1): if debugDB { l.Debugln("generic replace; exists - remove") } if lv := deleteFn(snap, batch, folder, device, oldName, dbi); lv > maxLocalVer { maxLocalVer = lv } moreDb = dbi.Next() } // Write out and reuse the batch every few records, to avoid the batch // growing too large and thus allocating unnecessarily much memory. if batch.Len() > batchFlushSize { if debugDB { l.Debugf("db.Write %p", batch) } err = db.Write(batch, nil) if err != nil { panic(err) } batch.Reset() } } if debugDB { l.Debugf("db.Write %p", batch) } err = db.Write(batch, nil) if err != nil { panic(err) } return maxLocalVer }
func (db *Instance) withNeed(folder, device []byte, truncate bool, fn Iterator) { t := db.newReadOnlyTransaction() defer t.close() dbi := t.NewIterator(util.BytesPrefix(db.globalKey(folder, nil)[:keyPrefixLen+keyFolderLen]), nil) defer dbi.Release() var fk []byte nextFile: for dbi.Next() { var vl VersionList err := vl.UnmarshalXDR(dbi.Value()) if err != nil { panic(err) } if len(vl.versions) == 0 { l.Debugln(dbi.Key()) panic("no versions?") } have := false // If we have the file, any version need := false // If we have a lower version of the file var haveVersion protocol.Vector for _, v := range vl.versions { if bytes.Equal(v.device, device) { have = true haveVersion = v.version // XXX: This marks Concurrent (i.e. conflicting) changes as // needs. Maybe we should do that, but it needs special // handling in the puller. need = !v.version.GreaterEqual(vl.versions[0].version) break } } if need || !have { name := db.globalKeyName(dbi.Key()) needVersion := vl.versions[0].version nextVersion: for i := range vl.versions { if !vl.versions[i].version.Equal(needVersion) { // We haven't found a valid copy of the file with the needed version. continue nextFile } fk = db.deviceKeyInto(fk[:cap(fk)], folder, vl.versions[i].device, name) bs, err := t.Get(fk, nil) if err != nil { var id protocol.DeviceID copy(id[:], device) l.Debugf("device: %v", id) l.Debugf("need: %v, have: %v", need, have) l.Debugf("key: %q (%x)", dbi.Key(), dbi.Key()) l.Debugf("vl: %v", vl) l.Debugf("i: %v", i) l.Debugf("fk: %q (%x)", fk, fk) l.Debugf("name: %q (%x)", name, name) panic(err) } gf, err := unmarshalTrunc(bs, truncate) if err != nil { panic(err) } if gf.IsInvalid() { // The file is marked invalid for whatever reason, don't use it. continue nextVersion } if gf.IsDeleted() && !have { // We don't need deleted files that we don't have continue nextFile } l.Debugf("need folder=%q device=%v name=%q need=%v have=%v haveV=%d globalV=%d", folder, protocol.DeviceIDFromBytes(device), name, need, have, haveVersion, vl.versions[0].version) if cont := fn(gf); !cont { return } // This file is handled, no need to look further in the version list continue nextFile } } } }
func (db *Instance) genericReplace(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker, deleteFn deletionHandler) int64 { sort.Sort(fileList(fs)) // sort list on name, same as in the database t := db.newReadWriteTransaction() defer t.close() dbi := t.NewIterator(util.BytesPrefix(db.deviceKey(folder, device, nil)[:keyPrefixLen+keyFolderLen+keyDeviceLen]), nil) defer dbi.Release() moreDb := dbi.Next() fsi := 0 var maxLocalVer int64 isLocalDevice := bytes.Equal(device, protocol.LocalDeviceID[:]) for { var newName, oldName []byte moreFs := fsi < len(fs) if !moreDb && !moreFs { break } if moreFs { newName = []byte(fs[fsi].Name) } if moreDb { oldName = db.deviceKeyName(dbi.Key()) } cmp := bytes.Compare(newName, oldName) l.Debugf("generic replace; folder=%q device=%v moreFs=%v moreDb=%v cmp=%d newName=%q oldName=%q", folder, protocol.DeviceIDFromBytes(device), moreFs, moreDb, cmp, newName, oldName) switch { case moreFs && (!moreDb || cmp == -1): l.Debugln("generic replace; missing - insert") // Database is missing this file. Insert it. if lv := t.insertFile(folder, device, fs[fsi]); lv > maxLocalVer { maxLocalVer = lv } if isLocalDevice { localSize.addFile(fs[fsi]) } if fs[fsi].IsInvalid() { t.removeFromGlobal(folder, device, newName, globalSize) } else { t.updateGlobal(folder, device, fs[fsi], globalSize) } fsi++ case moreFs && moreDb && cmp == 0: // File exists on both sides - compare versions. We might get an // update with the same version and different flags if a device has // marked a file as invalid, so handle that too. l.Debugln("generic replace; exists - compare") var ef FileInfoTruncated ef.UnmarshalXDR(dbi.Value()) if !fs[fsi].Version.Equal(ef.Version) || fs[fsi].Flags != ef.Flags { l.Debugln("generic replace; differs - insert") if lv := t.insertFile(folder, device, fs[fsi]); lv > maxLocalVer { maxLocalVer = lv } if isLocalDevice { localSize.removeFile(ef) localSize.addFile(fs[fsi]) } if fs[fsi].IsInvalid() { t.removeFromGlobal(folder, device, newName, globalSize) } else { t.updateGlobal(folder, device, fs[fsi], globalSize) } } else { l.Debugln("generic replace; equal - ignore") } fsi++ moreDb = dbi.Next() case moreDb && (!moreFs || cmp == 1): l.Debugln("generic replace; exists - remove") if lv := deleteFn(t, folder, device, oldName, dbi); lv > maxLocalVer { maxLocalVer = lv } moreDb = dbi.Next() } // Write out and reuse the batch every few records, to avoid the batch // growing too large and thus allocating unnecessarily much memory. t.checkFlush() } return maxLocalVer }
// updateGlobal adds this device+version to the version list for the given // file. If the device is already present in the list, the version is updated. // If the file does not have an entry in the global list, it is created. func (t readWriteTransaction) updateGlobal(folder, device []byte, file protocol.FileInfo, globalSize *sizeTracker) bool { l.Debugf("update global; folder=%q device=%v file=%q version=%d", folder, protocol.DeviceIDFromBytes(device), file.Name, file.Version) name := []byte(file.Name) gk := globalKey(folder, name) svl, err := t.Get(gk, nil) if err != nil && err != leveldb.ErrNotFound { panic(err) } var fl versionList var oldFile protocol.FileInfo var hasOldFile bool // Remove the device from the current version list if svl != nil { err = fl.UnmarshalXDR(svl) if err != nil { panic(err) } for i := range fl.versions { if bytes.Compare(fl.versions[i].device, device) == 0 { if fl.versions[i].version.Equal(file.Version) { // No need to do anything return false } if i == 0 { // Keep the current newest file around so we can subtract it from // the globalSize if we replace it. oldFile, hasOldFile = t.getFile(folder, fl.versions[0].device, name) } fl.versions = append(fl.versions[:i], fl.versions[i+1:]...) break } } } nv := fileVersion{ device: device, version: file.Version, } insertedAt := -1 // Find a position in the list to insert this file. The file at the front // of the list is the newer, the "global". for i := range fl.versions { switch fl.versions[i].version.Compare(file.Version) { case protocol.Equal, protocol.Lesser: // The version at this point in the list is equal to or lesser // ("older") than us. We insert ourselves in front of it. fl.versions = insertVersion(fl.versions, i, nv) insertedAt = i goto done case protocol.ConcurrentLesser, protocol.ConcurrentGreater: // The version at this point is in conflict with us. We must pull // the actual file metadata to determine who wins. If we win, we // insert ourselves in front of the loser here. (The "Lesser" and // "Greater" in the condition above is just based on the device // IDs in the version vector, which is not the only thing we use // to determine the winner.) of, ok := t.getFile(folder, fl.versions[i].device, name) if !ok { panic("file referenced in version list does not exist") } if file.WinsConflict(of) { fl.versions = insertVersion(fl.versions, i, nv) insertedAt = i goto done } } } // We didn't find a position for an insert above, so append to the end. fl.versions = append(fl.versions, nv) insertedAt = len(fl.versions) - 1 done: if insertedAt == 0 { // We just inserted a new newest version. Fixup the global size // calculation. if !file.Version.Equal(oldFile.Version) { globalSize.addFile(file) if hasOldFile { // We have the old file that was removed at the head of the list. globalSize.removeFile(oldFile) } else if len(fl.versions) > 1 { // The previous newest version is now at index 1, grab it from there. oldFile, ok := t.getFile(folder, fl.versions[1].device, name) if !ok { panic("file referenced in version list does not exist") } globalSize.removeFile(oldFile) } } } l.Debugf("new global after update: %v", fl) t.Put(gk, fl.MustMarshalXDR()) return true }
func (i SessionInvitation) String() string { return fmt.Sprintf("%s@%s", syncthingprotocol.DeviceIDFromBytes(i.From), i.AddressString()) }
func protocolConnectionHandler(tcpConn net.Conn, config *tls.Config) { conn := tls.Server(tcpConn, config) err := conn.Handshake() if err != nil { if debug { log.Println("Protocol connection TLS handshake:", conn.RemoteAddr(), err) } conn.Close() return } state := conn.ConnectionState() if (!state.NegotiatedProtocolIsMutual || state.NegotiatedProtocol != protocol.ProtocolName) && debug { log.Println("Protocol negotiation error") } certs := state.PeerCertificates if len(certs) != 1 { if debug { log.Println("Certificate list error") } conn.Close() return } id := syncthingprotocol.NewDeviceID(certs[0].Raw) messages := make(chan interface{}) errors := make(chan error, 1) outbox := make(chan interface{}) // Read messages from the connection and send them on the messages // channel. When there is an error, send it on the error channel and // return. Applies also when the connection gets closed, so the pattern // below is to close the connection on error, then wait for the error // signal from messageReader to exit. go messageReader(conn, messages, errors) pingTicker := time.NewTicker(pingInterval) timeoutTicker := time.NewTimer(networkTimeout) joined := false for { select { case message := <-messages: timeoutTicker.Reset(networkTimeout) if debug { log.Printf("Message %T from %s", message, id) } switch msg := message.(type) { case protocol.JoinRelayRequest: if atomic.LoadInt32(&overLimit) > 0 { protocol.WriteMessage(conn, protocol.RelayFull{}) if debug { log.Println("Refusing join request from", id, "due to being over limits") } conn.Close() limitCheckTimer.Reset(time.Second) continue } outboxesMut.RLock() _, ok := outboxes[id] outboxesMut.RUnlock() if ok { protocol.WriteMessage(conn, protocol.ResponseAlreadyConnected) if debug { log.Println("Already have a peer with the same ID", id, conn.RemoteAddr()) } conn.Close() continue } outboxesMut.Lock() outboxes[id] = outbox outboxesMut.Unlock() joined = true protocol.WriteMessage(conn, protocol.ResponseSuccess) case protocol.ConnectRequest: requestedPeer := syncthingprotocol.DeviceIDFromBytes(msg.ID) outboxesMut.RLock() peerOutbox, ok := outboxes[requestedPeer] outboxesMut.RUnlock() if !ok { if debug { log.Println(id, "is looking for", requestedPeer, "which does not exist") } protocol.WriteMessage(conn, protocol.ResponseNotFound) conn.Close() continue } // requestedPeer is the server, id is the client ses := newSession(requestedPeer, id, sessionLimiter, globalLimiter) go ses.Serve() clientInvitation := ses.GetClientInvitationMessage() serverInvitation := ses.GetServerInvitationMessage() if err := protocol.WriteMessage(conn, clientInvitation); err != nil { if debug { log.Printf("Error sending invitation from %s to client: %s", id, err) } conn.Close() continue } peerOutbox <- serverInvitation if debug { log.Println("Sent invitation from", id, "to", requestedPeer) } conn.Close() case protocol.Ping: if err := protocol.WriteMessage(conn, protocol.Pong{}); err != nil { if debug { log.Println("Error writing pong:", err) } conn.Close() continue } case protocol.Pong: // Nothing default: if debug { log.Printf("Unknown message %s: %T", id, message) } protocol.WriteMessage(conn, protocol.ResponseUnexpectedMessage) conn.Close() } case err := <-errors: if debug { log.Printf("Closing connection %s: %s", id, err) } close(outbox) // Potentially closing a second time. conn.Close() if joined { // Only delete the outbox if the client is joined, as it might be // a lookup request coming from the same client. outboxesMut.Lock() delete(outboxes, id) outboxesMut.Unlock() // Also, kill all sessions related to this node, as it probably // went offline. This is for the other end to realize the client // is no longer there faster. This also helps resolve // 'already connected' errors when one of the sides is // restarting, and connecting to the other peer before the other // peer even realised that the node has gone away. dropSessions(id) } return case <-pingTicker.C: if !joined { if debug { log.Println(id, "didn't join within", pingInterval) } conn.Close() continue } if err := protocol.WriteMessage(conn, protocol.Ping{}); err != nil { if debug { log.Println(id, err) } conn.Close() } if atomic.LoadInt32(&overLimit) > 0 && !hasSessions(id) { if debug { log.Println("Dropping", id, "as it has no sessions and we are over our limits") } protocol.WriteMessage(conn, protocol.RelayFull{}) conn.Close() limitCheckTimer.Reset(time.Second) } case <-timeoutTicker.C: // We should receive a error from the reader loop, which will cause // us to quit this loop. if debug { log.Printf("%s timed out", id) } conn.Close() case msg := <-outbox: if msg == nil { conn.Close() return } if debug { log.Printf("Sending message %T to %s", msg, id) } if err := protocol.WriteMessage(conn, msg); err != nil { if debug { log.Println(id, err) } conn.Close() } } } }