You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
3.3 KiB
131 lines
3.3 KiB
// Copyright (c) 2020 Proton Technologies AG |
|
// |
|
// This file is part of ProtonMail Bridge. |
|
// |
|
// ProtonMail Bridge is free software: you can redistribute it and/or modify |
|
// it under the terms of the GNU General Public License as published by |
|
// the Free Software Foundation, either version 3 of the License, or |
|
// (at your option) any later version. |
|
// |
|
// ProtonMail Bridge is distributed in the hope that it will be useful, |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
// GNU General Public License for more details. |
|
// |
|
// You should have received a copy of the GNU General Public License |
|
// along with ProtonMail Bridge. If not, see <https://www.gnu.org/licenses/>. |
|
|
|
package updates |
|
|
|
import ( |
|
"errors" |
|
"io" |
|
"io/ioutil" |
|
"net/http" |
|
"os" |
|
"path/filepath" |
|
"strconv" |
|
|
|
"github.com/ProtonMail/proton-bridge/pkg/dialer" |
|
) |
|
|
|
func mkdirAllClear(path string) error { |
|
if err := os.RemoveAll(path); err != nil { |
|
return err |
|
} |
|
return os.MkdirAll(path, 0750) |
|
} |
|
|
|
func downloadToBytes(path string) (out []byte, err error) { |
|
var ( |
|
client *http.Client |
|
response *http.Response |
|
) |
|
client = dialer.DialTimeoutClient() |
|
log.WithField("path", path).Trace("Downloading") |
|
|
|
response, err = client.Get(path) |
|
if err != nil { |
|
return |
|
} |
|
out, err = ioutil.ReadAll(response.Body) |
|
_ = response.Body.Close() |
|
if response.StatusCode < http.StatusOK || http.StatusIMUsed < response.StatusCode { |
|
err = errors.New(path + " " + response.Status) |
|
} |
|
return |
|
} |
|
|
|
func downloadWithProgress(status *Progress, sourceURL, targetPath string) (err error) { |
|
targetFile, err := os.Create(targetPath) |
|
if err != nil { |
|
log.Warnf("Cannot create update file %s: %v", targetPath, err) |
|
return |
|
} |
|
defer targetFile.Close() //nolint[errcheck] |
|
|
|
var ( |
|
client *http.Client |
|
response *http.Response |
|
) |
|
client = dialer.DialTimeoutClient() |
|
response, err = client.Get(sourceURL) |
|
if err != nil { |
|
return |
|
} |
|
defer response.Body.Close() //nolint[errcheck] |
|
|
|
contentLength, _ := strconv.ParseUint(response.Header.Get("Content-Length"), 10, 64) |
|
|
|
wc := WriteCounter{ |
|
Status: status, |
|
Target: targetFile, |
|
Size: contentLength, |
|
} |
|
|
|
err = wc.ReadAll(response.Body) |
|
return |
|
} |
|
|
|
func downloadWithSignature(status *Progress, sourceURL, targetDir string) (localPath string, err error) { |
|
localPath = filepath.Join(targetDir, filepath.Base(sourceURL)) |
|
|
|
if err = downloadWithProgress(nil, sourceURL+sigExtension, localPath+sigExtension); err != nil { |
|
return |
|
} |
|
|
|
if err = downloadWithProgress(status, sourceURL, localPath); err != nil { |
|
return |
|
} |
|
return |
|
} |
|
|
|
type WriteCounter struct { |
|
Status *Progress |
|
Target io.Writer |
|
processed, Size, counter uint64 |
|
} |
|
|
|
func (s *WriteCounter) ReadAll(source io.Reader) (err error) { |
|
s.counter = uint64(0) |
|
if s.Target == nil { |
|
return errors.New("can not read all, target unset") |
|
} |
|
if source == nil { |
|
return errors.New("can not read all, source unset") |
|
} |
|
_, err = io.Copy(s.Target, io.TeeReader(source, s)) |
|
return |
|
} |
|
|
|
func (s *WriteCounter) Write(p []byte) (int, error) { |
|
if s.Status != nil && s.Size != 0 { |
|
s.processed += uint64(len(p)) |
|
fraction := float32(s.processed) / float32(s.Size) |
|
if s.counter%uint64(100) == 0 || fraction == 1. { |
|
s.Status.UpdateProcessed(fraction) |
|
} |
|
} |
|
s.counter++ |
|
return len(p), nil |
|
}
|
|
|