示例#1
0
文件: currency.go 项目: zzmjohn/Sia
// UnmarshalSia implements the encoding.SiaUnmarshaler interface.
func (c *Currency) UnmarshalSia(r io.Reader) error {
	b, err := encoding.ReadPrefix(r, 256)
	if err != nil {
		return err
	}
	c.i.SetBytes(b)
	return nil
}
示例#2
0
// ReadSignedObject reads a length-prefixed object prefixed by its signature,
// and verifies the signature.
func ReadSignedObject(r io.Reader, obj interface{}, maxLen uint64, pk PublicKey) error {
	// read the signature
	var sig Signature
	err := encoding.NewDecoder(r).Decode(&sig)
	if err != nil {
		return err
	}
	// read the encoded object
	encObj, err := encoding.ReadPrefix(r, maxLen)
	if err != nil {
		return err
	}
	// verify the signature
	if err := VerifyHash(HashBytes(encObj), pk, sig); err != nil {
		return err
	}
	// decode the object
	return encoding.Unmarshal(encObj, obj)
}
示例#3
0
文件: scan.go 项目: zzmjohn/Sia
// threadedProbeHost tries to fetch the settings of a host. If successful, the
// host is put in the set of active hosts. If unsuccessful, the host id deleted
// from the set of active hosts.
func (hdb *HostDB) threadedProbeHosts() {
	for hostEntry := range hdb.scanPool {
		// Request settings from the queued host entry.
		var settings modules.HostSettings
		err := func() error {
			conn, err := hdb.dialer.DialTimeout(hostEntry.NetAddress, hostRequestTimeout)
			if err != nil {
				return err
			}
			defer conn.Close()
			err = encoding.WriteObject(conn, modules.RPCSettings)
			if err != nil {
				return err
			}
			// COMPATv0.4.8 - If first decoding attempt fails, try decoding
			// into the old HostSettings type. Because we decode twice, we
			// must read the data into memory first.
			settingsBytes, err := encoding.ReadPrefix(conn, maxSettingsLen)
			if err != nil {
				return err
			}
			err = encoding.Unmarshal(settingsBytes, &settings)
			if err != nil {
				var oldSettings oldHostSettings
				err = encoding.Unmarshal(settingsBytes, &oldSettings)
				if err != nil {
					return err
				}
				// Convert the old type.
				settings = modules.HostSettings{
					NetAddress:   oldSettings.NetAddress,
					TotalStorage: oldSettings.TotalStorage,
					MinDuration:  oldSettings.MinDuration,
					MaxDuration:  oldSettings.MaxDuration,
					WindowSize:   oldSettings.WindowSize,
					Price:        oldSettings.Price,
					Collateral:   oldSettings.Collateral,
					UnlockHash:   oldSettings.UnlockHash,
				}
			}
			return nil
		}()

		// Now that network communication is done, lock the hostdb to modify the
		// host entry.
		func() {
			hdb.mu.Lock()
			defer hdb.mu.Unlock()

			// Regardless of whether the host responded, add it to allHosts.
			if _, exists := hdb.allHosts[hostEntry.NetAddress]; !exists {
				hdb.allHosts[hostEntry.NetAddress] = hostEntry
			}

			// If the scan was unsuccessful, decrement the host's reliability.
			if err != nil {
				hdb.decrementReliability(hostEntry.NetAddress, UnreachablePenalty)
				return
			}

			// Update the host settings, reliability, and weight. The old NetAddress
			// must be preserved.
			settings.NetAddress = hostEntry.HostSettings.NetAddress
			hostEntry.HostSettings = settings
			hostEntry.reliability = MaxReliability
			hostEntry.weight = calculateHostWeight(*hostEntry)
			hostEntry.online = true

			// If 'MaxActiveHosts' has not been reached, add the host to the
			// activeHosts tree.
			if _, exists := hdb.activeHosts[hostEntry.NetAddress]; !exists && len(hdb.activeHosts) < MaxActiveHosts {
				hdb.insertNode(hostEntry)
			}
		}()
	}
}