telebit.js/build-all.go

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
	exe  string
}

// ReaderAtCloser is just what it sounds
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",
		"arm64":   "arm64",
		//"armv8":   "arm64",
	}

	pkgs := []pkg{
		pkg{os: "darwin", arch: "amd64", ext: "tar.gz"},
		pkg{os: "windows", arch: "amd64", ext: "zip", exe: ".exe"},
		pkg{os: "windows", arch: "386", ext: "zip", exe: ".exe"},
		pkg{os: "linux", arch: "amd64", ext: "tar.gz"},
		//pkg{os: "linux", arch: "armv8", ext: "tar.gz"},
		pkg{os: "linux", arch: "arm64", ext: "tar.gz"},
		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]

		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)

		// Create a fresh directory for this telebit release
		outdir := fmt.Sprintf("telebit-%s-%s-%s", release, pkg.os, pkg.arch)
		fmt.Printf("(clean) Release:%s\n", outdir)
		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
		nurl := fmt.Sprintf("https://nodejs.org/download/release/v%s/%s", nodev, nfile)
		err = download("node package", nurl, nfile)
		if nil != err {
			panic(err)
		}

		// 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)
			}
			strip := 1
			err = unzip(z, s.Size(), outdir, strip)
			if nil != err {
				panic(err)
			}
		case "tar.gz":
			tgz, err := os.Open(nfile)
			if nil != err {
				panic(err)
			}
			strip := 1
			err = untar(tgz, outdir, strip)
			if nil != err {
				panic(err)
			}
		default:
			panic(fmt.Errorf("%s", "Liar!!"))
		}

		// 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)
		}
		strip := 1
		if err := unzip(z, s.Size(), outdir, strip); nil != err {
			panic(err)
		}

		// 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
		err = download("pathman", pathmanURL, pathmanFile)
		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
		err = download("serviceman", servicemanURL, servicemanFile)
		if nil != err {
			panic(err)
		}
	}

	fmt.Printf("Done.\n")
}

func download(title string, nurl string, nfile string) error {
	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)
	nf, err := os.OpenFile(nfile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
	_, err = io.Copy(nf, resp.Body)
	if nil != err {
		return err
	}
	return nf.Sync()
}

func untar(tgz io.Reader, outdir string, strip int) error {
	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
		}

		fpath := stripPrefix(header.Name, strip)
		fpath = filepath.Join(outdir, fpath)
		switch header.Typeflag {
		case tar.TypeLink:
			// ignore hard links
		case tar.TypeSymlink:
			// 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
			}
		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
}

func unzip(z io.ReaderAt, size int64, outdir string, strip int) error {
	zr, err := zip.NewReader(z, size)
	if nil != err {
		return err
	}

	for i := range zr.File {
		f := zr.File[i]

		fpath := stripPrefix(f.Name, strip)
		fpath = filepath.Join(outdir, fpath)
		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
}

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, "/")
}

// 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))

	// foo/ foo => foo// foo/
	// foo/ foo/bar.md => foo// foo/bar.md/
	if !strings.HasPrefix(cleanpath+string(os.PathSeparator), cleandest+string(os.PathSeparator)) {
		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
}