forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-22 20:56:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Multiple bug fixes

Browse source
This commit is contained in:
Daniel A. Nagy 2015-02-11 16:53:36 +01:00
parent cfe9304b5c
commit abeebb0e2d
1 changed files with 27 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
bzz/httpaccess.go
View file

@ -10,6 +10,7 @@ import (
"io" "io"
"net/http" "net/http"
"regexp" "regexp"
"sync"
"time" "time"
) )
@ -28,6 +29,7 @@ type sequentialReader struct {
reader io.Reader reader io.Reader
pos int64 pos int64
ahead map[int64](chan bool) ahead map[int64](chan bool)
lock sync.Mutex
} }
type manifestEntry struct { type manifestEntry struct {
@ -38,17 +40,26 @@ type manifestEntry struct {
} }
func (self *sequentialReader) ReadAt(target []byte, off int64) (n int, err error) { func (self *sequentialReader) ReadAt(target []byte, off int64) (n int, err error) {
self.lock.Lock()
// assert self.pos <= off
if self.pos > off {
dpaLogger.Errorf("Swarm: non-sequential read attempted from sequentialReader; %d > %d",
self.pos, off)
panic("Non-sequential read attempt")
}
if self.pos != off { if self.pos != off {
dpaLogger.Debugf("Swarm: deferred read in POST at position %d, offset %d.", dpaLogger.Debugf("Swarm: deferred read in POST at position %d, offset %d.",
self.pos, off) self.pos, off)
wait := make(chan bool) wait := make(chan bool)
self.ahead[off] = wait self.ahead[off] = wait
self.lock.Unlock()
if <-wait { if <-wait {
// failed read behind // failed read behind
n = 0 n = 0
err = io.ErrUnexpectedEOF err = io.ErrUnexpectedEOF
return return
} }
self.lock.Lock()
} }
localPos := 0 localPos := 0
for localPos < len(target) { for localPos < len(target) {
@ -60,9 +71,10 @@ func (self *sequentialReader) ReadAt(target []byte, off int64) (n int, err error
dpaLogger.Debugf("Swarm: POST stream's reading terminated with %v.", err) dpaLogger.Debugf("Swarm: POST stream's reading terminated with %v.", err)
for i := range self.ahead { for i := range self.ahead {
self.ahead[i] <- true self.ahead[i] <- true
self.ahead[i] = nil delete(self.ahead, i)
} }
return self.lock.Unlock()
return localPos, err
} }
self.pos += int64(n) self.pos += int64(n)
} }
@ -70,10 +82,11 @@ func (self *sequentialReader) ReadAt(target []byte, off int64) (n int, err error
if wait != nil { if wait != nil {
dpaLogger.Debugf("Swarm: deferred read in POST at position %d triggered.", dpaLogger.Debugf("Swarm: deferred read in POST at position %d triggered.",
self.pos) self.pos)
self.ahead[self.pos] = nil delete(self.ahead, self.pos)
close(wait) close(wait)
} }
return self.lock.Unlock()
return localPos, err
} }
func handler(w http.ResponseWriter, r *http.Request, dpa *DPA) { func handler(w http.ResponseWriter, r *http.Request, dpa *DPA) {
@ -108,19 +121,20 @@ func handler(w http.ResponseWriter, r *http.Request, dpa *DPA) {
dpaLogger.Debugf("Swarm: Structured GET request %s received.", uri) dpaLogger.Debugf("Swarm: Structured GET request %s received.", uri)
name := uri[1:65] name := uri[1:65]
path := uri[65:] // typically begins with a / path := uri[65:] // typically begins with a /
dpaLogger.Debugf("Swarm: path \"%s\" requested.", path)
key := ethutil.Hex2Bytes(name) key := ethutil.Hex2Bytes(name)
MANIFEST_RESOLUTION: MANIFEST_RESOLUTION:
for { for {
manifestReader := dpa.Retrieve(key) manifestReader := dpa.Retrieve(key)
// TODO check size for oversized manifests // TODO check size for oversized manifests
manifest := make([]byte, manifestReader.Size()) manifest := make([]byte, manifestReader.Size())
_, err := manifestReader.Read(manifest) size, err := manifestReader.Read(manifest)
if err != nil { if int64(size) < manifestReader.Size() {
dpaLogger.Debugf("Swarm: Manifest %s not found.", name) dpaLogger.Debugf("Swarm: Manifest %s not found.", name)
http.Error(w, err.Error(), http.StatusNotFound) http.Error(w, err.Error(), http.StatusNotFound)
return return
} }
dpaLogger.Debugf("Swarm: Manifest %s retrieved.") dpaLogger.Debugf("Swarm: Manifest %s retrieved.", name)
manifestEntries := make([]manifestEntry, 0) manifestEntries := make([]manifestEntry, 0)
err = json.Unmarshal(manifest, &manifestEntries) err = json.Unmarshal(manifest, &manifestEntries)
if err != nil { if err != nil {
@ -149,9 +163,10 @@ func handler(w http.ResponseWriter, r *http.Request, dpa *DPA) {
entry.Status = 200 entry.Status = 200
} }
pathLen := len(entry.Path) pathLen := len(entry.Path)
if len(path) >= pathLen && path[:pathLen] == entry.Path && prefix < pathLen { if len(path) >= pathLen && path[:pathLen] == entry.Path && prefix <= pathLen {
prefix = pathLen prefix = pathLen
key = ethutil.Hex2Bytes(entry.Hash) key = ethutil.Hex2Bytes(entry.Hash)
dpaLogger.Debugf("Swarm: Payload hash %064x", key)
mimeType = entry.Content_type mimeType = entry.Content_type
status = entry.Status status = entry.Status
} }
@ -161,8 +176,11 @@ func handler(w http.ResponseWriter, r *http.Request, dpa *DPA) {
break MANIFEST_RESOLUTION break MANIFEST_RESOLUTION
} else if mimeType != manifest_type { } else if mimeType != manifest_type {
w.Header().Set("Content-Type", mimeType) w.Header().Set("Content-Type", mimeType)
dpaLogger.Debugf("Swarm: HTTP Status %d", status)
w.WriteHeader(int(status)) w.WriteHeader(int(status))
http.ServeContent(w, r, "", time.Unix(0, 0), dpa.Retrieve(key)) reader := dpa.Retrieve(key)
dpaLogger.Debugf("Swarm: Reading %d bytes.", reader.Size())
http.ServeContent(w, r, name, time.Unix(0, 0), reader)
dpaLogger.Debugf("Swarm: Served %s as %s.", mimeType, uri) dpaLogger.Debugf("Swarm: Served %s as %s.", mimeType, uri)
break MANIFEST_RESOLUTION break MANIFEST_RESOLUTION
} else { } else {