func download(con *ssh.Client, buf bytes.Buffer, path string,) ([]byte,error) {
	//https://chuacw.ath.cx/development/b/chuacw/archive/2019/02/04/how-the-scp-protocol-works.aspx
	session, err := con.NewSession()
	if err != nil {
		return nil,err
	}
	buf.WriteString("sudo scp -f " + path + "\n")
	stdin, err := session.StdinPipe()
	if err != nil {
		return nil,err
	}
	go func() {
		defer stdin.Close()
		fmt.Fprint(stdin, "C0660 "+strconv.Itoa(len(content))+" file\n")
		stdin.Write(content)
		fmt.Fprint(stdin, "\x00")
	}()
	output, err := session.CombinedOutput("sudo scp -f " + path)
	buf.Write(output)
	if err != nil {
		return nil,&DeployError{
			Err:    err,
			Output: buf.String(),
		}
	}
	session.Close()
	session, err = con.NewSession()
	if err != nil {
		return nil,err
	}
	defer session.Close()
	return output,nil
}

func download(con *ssh.Client, path string) ([]byte, error) {
	//https://chuacw.ath.cx/development/b/chuacw/archive/2019/02/04/how-the-scp-protocol-works.aspx
	session, err := con.NewSession()
	if err != nil {
		return nil, err
	}
	defer session.Close()
	// Local -> remote
	stdin, err := session.StdinPipe()
	if err != nil {
		return nil, err
	}
	defer stdin.Close()
	// Request a file, note that directories will require different handling
	_, err = stdin.Write([]byte("sudo scp -f " + path + "\n"))
	if err != nil {
		return nil, err
	}
	// Remote -> local
	stdout, err := session.StdoutPipe()
	if err != nil {
		return nil, err
	}
	// Make a buffer for the protocol messages
	const megabyte = 1 << 20
	b := make([]byte, megabyte)
	// Offset into the buffer
	off := 0
	var filesize int64
	// SCP may send multiple protocol messages, so keep reading
	for {
		n, err := stdout.Read(b[off:])
		if err != nil {
			return nil, err
		}
		nl := bytes.Index(b[:off+n], []byte("\n"))
		// If there is no newline in the buffer, we need to read more
		if nl == -1 {
			off = off + n
			continue
		}
		// We read a full message, reset the offset
		off = 0
		// if we did get a new line. We have the full protocol message
		msg := string(b[:nl])
		// Send back 0, which means OK, the SCP source will not send the next message otherwise
		_, err = stdin.Write([]byte("0\n"))
		if err != nil {
			return nil, err
		}
		// First char is the mode (C=file, D=dir, E=End of dir, T=Time metadata)
		mode := msg[0]
		if mode != 'C' {
			// Ignore other messags for now.
			continue
		}
		// File message = Cmmmm <length> <filename>
		msgParts := strings.Split(msg, " ")
		if len(msgParts) > 1 {
			// Parse the second part <length> as an base 10 integer
			filesize, err = strconv.ParseInt(msgParts[1], 10, 64)
			if err != nil {
				return nil, err
			}
		}
		// The file message will be followed with binary data containing the file
		break
	}
	// Wrap the stdout reader in a limit reader so we will not read more than the filesize
	fileReader := io.LimitReader(stdout, filesize)
	// Seed the bytes buffer with the existing byte slice, saves additional allocation if file <= 1mb
	buf := bytes.NewBuffer(b)
	// Copy the file into the bytes buffer
	_, err = io.Copy(buf, fileReader)
	return buf.Bytes(), err
}