Exemplo n.º 1
0
func newUploadHandler(fname string) (*UploadHandler, error) {
	var err error
	_, err = os.Stat(DownloadDir)
	if err != nil && os.IsNotExist(err) {
		os.Mkdir(DownloadDir, 0755)
	}
	h := UploadHandler{}
	h.file = fname
	f, err := os.Open(fname)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	h.hb, err = heartbeat.NewSwizzle(nil, 0, nil, 0)
	if err != nil {
		return nil, err
	}
	tag, err := h.hb.Encode(f, 0)
	if err != nil {
		return nil, err
	}
	h.fileSize, err = f.Seek(0, os.SEEK_CUR)
	logging.Println("file size:", h.fileSize)
	if err != nil {
		return nil, err
	}
	f.Seek(0, os.SEEK_SET)
	h.fileHash, err = farming.GetSHA256(f)
	if err != nil {
		return nil, err
	}
	logging.Println("file hash:", hex.EncodeToString(h.fileHash))

	f.Seek(0, os.SEEK_SET)
	tagFile, err := ioutil.TempFile("", "")
	defer tagFile.Close()
	if err != nil {
		return nil, err
	}
	h.tag = tagFile.Name()
	logging.Println("tag file:", h.tag)
	tag.Save(tagFile)
	h.tagSize, err = tagFile.Seek(0, os.SEEK_CUR)
	logging.Println("tag filesize:", h.tagSize)
	if err != nil {
		return nil, err
	}
	tagFile.Seek(0, os.SEEK_SET)
	h.tagHash, err = farming.GetSHA256(tagFile)
	if err != nil {
		return nil, err
	}
	logging.Println("tag hash:", hex.EncodeToString(h.tagHash))

	StoredFiles.SetStatus(h.fileHash, &h)

	return &h, nil
}
Exemplo n.º 2
0
//Init is called initlally when requesting farming.
func (h *UploadHandler) Init(msg []byte) ([]byte, storjtelehash.HandleMessage, error) {
	h.status = &Requesting
	logging.Println(h.status.Desc)
	f, err := os.Open(h.file)
	if err != nil {
		return nil, nil, err
	}
	defer f.Close()
	h.fileHash, err = farming.GetSHA256(f)
	f.Seek(0, os.SEEK_SET)

	rpacket := struct {
		FileHash string
		TagHash  string
		FileSize int64
		TagSize  int64
	}{
		hex.EncodeToString(h.fileHash),
		hex.EncodeToString(h.tagHash),
		h.fileSize,
		h.tagSize,
	}
	res, err := json.Marshal(rpacket)
	if err != nil {
		return nil, nil, err
	}
	logging.Println(string(res))

	return res, h.SendFile, nil
}
Exemplo n.º 3
0
func upload(w http.ResponseWriter, r *http.Request) {
	r.ParseMultipartForm(32 << 20)
	file, handler, err := r.FormFile("file")
	if err != nil {
		logging.Println("file not found")
		return
	}
	key, err := farming.GetSHA256(file)
	file.Seek(0, os.SEEK_SET)
	if err != nil {
		logging.Println(err.Error())
		return
	}
	s, err := farming.EncryptCTR(file, key)
	if err != nil {
		logging.Println(err.Error())
		return
	}
	tmp := os.TempDir() + "/" + handler.Filename
	f, err := os.Create(tmp)
	if err != nil {
		logging.Println(err.Error())
		return
	}

	buf := make([]byte, 65535)
	h := sha256.New()

	for n, err := s.Read(buf); n > 0; n, err = s.Read(buf) {
		if err != nil {
			logging.Println(err.Error())
			return
		}
		h.Write(buf)
		f.Write(buf)
	}
	hashOfEncrypted := h.Sum(nil)
	logging.Println("tmp file:" + tmp)
	f.Close()
	file.Close()

	loc := r.FormValue("address")
	logging.Println("address", loc)

	hl, err := newUploadHandler(tmp)
	if err != nil {
		logging.Println(err.Error())
		return
	}
	telehash.OpenChannel(loc, "farming", hl)

	res := map[string]string{
		"filehash": hex.EncodeToString(hashOfEncrypted),
		"key":      hex.EncodeToString(key),
	}
	j, err := json.Marshal(res)
	if err != nil {
		logging.Println(err.Error())
		return
	}
	w.Header().Set("Content-type", "application/json")

	w.Write(j)
}