telebit.js/build-all.go

380 lines
8.5 KiB
Go
Raw Normal View History

2019-07-11 08:06:38 +00:00
package main
import (
"archive/tar"
"archive/zip"
"compress/gzip"
"fmt"
"io"
"log"
"net/http"
"os"
"path/filepath"
"strings"
)
type pkg struct {
os string
arch string
ext string
2019-08-01 07:44:19 +00:00
exe string
2019-07-11 08:06:38 +00:00
}
2019-08-01 07:44:19 +00:00
// ReaderAtCloser is just what it sounds
2019-07-11 08:06:38 +00:00
type ReaderAtCloser interface {
io.ReaderAt
io.Reader
io.Closer
}
func main() {
nodeArches := map[string]string{
"windows": "win",
"darwin": "darwin",
"linux": "linux",
"amd64": "x64",
"386": "x86",
"armv7": "armv7l",
"armv6": "armv6l",
2019-08-01 07:44:19 +00:00
"arm64": "arm64",
//"armv8": "arm64",
2019-07-11 08:06:38 +00:00
}
pkgs := []pkg{
pkg{os: "darwin", arch: "amd64", ext: "tar.gz"},
2019-08-01 07:44:19 +00:00
pkg{os: "windows", arch: "amd64", ext: "zip", exe: ".exe"},
pkg{os: "windows", arch: "386", ext: "zip", exe: ".exe"},
2019-07-11 08:06:38 +00:00
pkg{os: "linux", arch: "amd64", ext: "tar.gz"},
2019-08-01 07:44:19 +00:00
//pkg{os: "linux", arch: "armv8", ext: "tar.gz"},
pkg{os: "linux", arch: "arm64", ext: "tar.gz"},
2019-07-11 08:06:38 +00:00
pkg{os: "linux", arch: "armv7", ext: "tar.gz"},
pkg{os: "linux", arch: "armv6", ext: "tar.gz"},
}
nodev := "10.16.0"
release := "stable"
// temp file for the zip
// TODO use mktemp
f, err := os.OpenFile(fmt.Sprintf("telebit-%s.zip", release), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
if nil != err {
panic(err)
}
// get from trusted git source
turl := fmt.Sprintf("https://git.rootprojects.org/root/telebit.js/archive/%s.zip", release)
resp, err := http.Get(turl)
if nil != err {
panic(err)
}
defer resp.Body.Close()
if resp.StatusCode >= 300 || resp.StatusCode < 200 {
log.Fatal("Bad deal on telebit download:", resp.Status)
}
_, err = io.Copy(f, resp.Body)
if nil != err {
panic(err)
}
err = f.Sync()
if nil != err {
panic(err)
}
for i := range pkgs {
pkg := pkgs[i]
2019-08-01 07:44:19 +00:00
arch := pkg.arch
if "arm64" == arch {
// TODO switch the pathman and serviceman URLs
arch = "armv8"
}
fmt.Printf("\nOS: %s\nArch: %s\n", pkg.os, arch)
2019-07-11 08:06:38 +00:00
// Create a fresh directory for this telebit release
outdir := fmt.Sprintf("telebit-%s-%s-%s", release, pkg.os, pkg.arch)
2019-08-01 07:44:19 +00:00
fmt.Printf("(clean) Release:%s\n", outdir)
2019-07-11 08:06:38 +00:00
err := os.RemoveAll(outdir)
if nil != err {
panic(err)
}
nos := nodeArches[pkg.os]
narch := nodeArches[pkg.arch]
// Grab the node files
npath := fmt.Sprintf("node-v%s-%s-%s", nodev, nos, narch)
nfile := fmt.Sprintf("%s.%s", npath, pkg.ext)
// TODO check remote filesize anyway as a quick sanity check
2019-08-01 07:44:19 +00:00
nurl := fmt.Sprintf("https://nodejs.org/download/release/v%s/%s", nodev, nfile)
2019-08-01 07:47:59 +00:00
err = download("node package", nurl, nfile, false)
2019-08-01 07:44:19 +00:00
if nil != err {
panic(err)
2019-07-11 08:06:38 +00:00
}
// lay down the node directory first
fmt.Printf("Unpacking %s %s\n", nfile, pkg.ext)
switch pkg.ext {
case "zip":
z, err := os.Open(nfile)
if nil != err {
panic(err)
}
s, err := z.Stat()
if nil != err {
panic(err)
}
2019-07-12 07:47:12 +00:00
strip := 1
err = unzip(z, s.Size(), outdir, strip)
2019-07-11 08:06:38 +00:00
if nil != err {
panic(err)
}
case "tar.gz":
tgz, err := os.Open(nfile)
if nil != err {
panic(err)
}
2019-07-12 07:47:12 +00:00
strip := 1
err = untar(tgz, outdir, strip)
2019-07-11 08:06:38 +00:00
if nil != err {
panic(err)
}
default:
2019-08-01 07:44:19 +00:00
panic(fmt.Errorf("%s", "Liar!!"))
2019-07-11 08:06:38 +00:00
}
// TODO how to handle node modules?
// overlay our stuff on top of the node release package
z, err := os.Open(fmt.Sprintf("telebit-%s.zip", release))
fmt.Printf("Overlaying %s\n", outdir)
if nil != err {
panic(err)
}
defer z.Close()
s, err := z.Stat()
if nil != err {
panic(err)
}
2019-07-12 07:47:12 +00:00
strip := 1
if err := unzip(z, s.Size(), outdir, strip); nil != err {
2019-07-11 08:06:38 +00:00
panic(err)
}
2019-08-01 07:44:19 +00:00
// Get pathman for the platform
pathmanURL := fmt.Sprintf(
"https://rootprojects.org/pathman/dist/%s/%s/pathman"+pkg.exe,
pkg.os,
arch,
)
pathmanFile := filepath.Join(outdir, "bin", "pathman") + pkg.exe
2019-08-01 07:47:59 +00:00
err = download("pathman", pathmanURL, pathmanFile, true)
2019-08-01 07:44:19 +00:00
if nil != err {
panic(err)
}
// Get serviceman for the platform
servicemanURL := fmt.Sprintf(
"https://rootprojects.org/serviceman/dist/%s/%s/serviceman"+pkg.exe,
pkg.os,
arch,
)
servicemanFile := filepath.Join(outdir, "bin", "serviceman") + pkg.exe
2019-08-01 07:47:59 +00:00
err = download("serviceman", servicemanURL, servicemanFile, true)
2019-08-01 07:44:19 +00:00
if nil != err {
panic(err)
}
2019-07-11 08:06:38 +00:00
}
fmt.Printf("Done.\n")
}
2019-08-01 07:47:59 +00:00
func download(title string, nurl string, nfile string, exec bool) error {
2019-08-01 07:44:19 +00:00
if _, err := os.Stat(nfile); nil == err {
return nil
}
// doesn't exist, go grab it
fmt.Printf("Downloading %s to %s\n", nurl, nfile)
resp, err := http.Get(nurl)
if nil != err {
return err
}
if resp.StatusCode >= 300 || resp.StatusCode < 200 {
log.Fatal("Bad deal on download:", resp.Status)
}
defer resp.Body.Close()
// Stream it in locally
fmt.Printf("Streaming %s to %s\n", nurl, nfile)
2019-08-01 07:47:59 +00:00
fmode := os.FileMode(0644)
if exec {
fmode = os.FileMode(0755)
}
nf, err := os.OpenFile(nfile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, fmode)
2019-08-01 07:44:19 +00:00
_, err = io.Copy(nf, resp.Body)
if nil != err {
return err
}
return nf.Sync()
}
2019-07-12 07:47:12 +00:00
func untar(tgz io.Reader, outdir string, strip int) error {
2019-07-11 08:06:38 +00:00
t, err := gzip.NewReader(tgz)
if nil != err {
return err
}
defer t.Close()
tr := tar.NewReader(t)
for {
header, err := tr.Next()
if err == io.EOF {
break
}
if nil != err {
return err
}
2019-07-12 07:47:12 +00:00
fpath := stripPrefix(header.Name, strip)
fpath = filepath.Join(outdir, fpath)
2019-07-11 08:06:38 +00:00
switch header.Typeflag {
case tar.TypeLink:
// ignore hard links
case tar.TypeSymlink:
2019-07-12 07:47:12 +00:00
// Note: the link itself is always a file, even when it represents a directory
lpath := filepath.Join(filepath.Dir(fpath), header.Linkname)
if !strings.HasPrefix(lpath+string(os.PathSeparator), outdir+string(os.PathSeparator)) {
return fmt.Errorf("Malicious link path: %s", header.Linkname)
}
if err := os.Symlink(header.Linkname, fpath); nil != err {
return err
}
2019-07-11 08:06:38 +00:00
case tar.TypeDir:
// gonna use the same perms as were set previously here
// should be fine (i.e. we want 755 for execs on *nix)
_, err := safeOpen(header.FileInfo(), os.FileMode(header.Mode), fpath, outdir)
if nil != err {
return err
}
case tar.TypeReg:
// gonna use the same perms as were set previously here
// should be fine (i.e. we want 755 for execs on *nix)
out, err := safeOpen(header.FileInfo(), os.FileMode(header.Mode), fpath, outdir)
if nil != err {
return err
}
defer out.Close()
_, err = io.Copy(out, tr)
if nil != err {
return err
}
err = out.Close()
if nil != err {
return err
}
default:
fmt.Printf("[debug] odd type %s (%c)", fpath, header.Typeflag)
}
}
return nil
}
2019-07-12 07:47:12 +00:00
func unzip(z io.ReaderAt, size int64, outdir string, strip int) error {
2019-07-11 08:06:38 +00:00
zr, err := zip.NewReader(z, size)
if nil != err {
return err
}
for i := range zr.File {
f := zr.File[i]
2019-07-12 07:47:12 +00:00
fpath := stripPrefix(f.Name, strip)
fpath = filepath.Join(outdir, fpath)
2019-07-11 08:06:38 +00:00
out, err := safeOpen(f.FileInfo(), f.Mode(), fpath, outdir)
if nil != err {
return err
}
if f.FileInfo().IsDir() {
continue
}
// this is actually function scope (not loop scope)
defer out.Close()
zf, err := f.Open()
if nil != err {
return err
}
defer zf.Close()
_, err = io.Copy(out, zf)
if nil != err {
return err
}
// close explicitly within loop scope
err = out.Close()
if nil != err {
return err
}
err = zf.Close()
if nil != err {
return err
}
}
return nil
}
2019-07-12 07:47:12 +00:00
func stripPrefix(fpath string, strip int) string {
// /foo/bar/baz/ => foo/bar/baz
// strip 1 => bar/baz
fpath = strings.Trim(filepath.ToSlash(fpath), "/")
parts := []string{}
if "" != fpath {
parts = strings.Split(fpath, "/")
}
if strip > 0 {
n := len(parts)
if strip > n {
strip = n
}
if 0 != len(parts) {
parts = parts[strip:]
}
}
return strings.Join(parts, "/")
}
2019-07-11 08:06:38 +00:00
// given the path return a file, tell that it's a directory, or error out
func safeOpen(fi os.FileInfo, fm os.FileMode, fpath string, outdir string) (io.WriteCloser, error) {
// Keep it clean
// https://github.com/snyk/zip-slip-vulnerability
cleanpath, _ := filepath.Abs(filepath.Clean(fpath))
cleandest, _ := filepath.Abs(filepath.Clean(outdir))
2019-07-12 07:47:12 +00:00
// foo/ foo => foo// foo/
// foo/ foo/bar.md => foo// foo/bar.md/
if !strings.HasPrefix(cleanpath+string(os.PathSeparator), cleandest+string(os.PathSeparator)) {
2019-07-11 08:06:38 +00:00
return nil, fmt.Errorf("Malicious file path: %s", fpath)
}
fpath = cleanpath
if fi.IsDir() {
err := os.MkdirAll(fpath, fm)
if nil != err {
return nil, err
}
return nil, err
}
if err := os.MkdirAll(filepath.Dir(fpath), 0755); nil != err {
return nil, err
}
out, err := os.OpenFile(fpath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, fm)
if err != nil {
return nil, err
}
return out, nil
}