// serializeWithoutHeaders marshals the PublicKey to w in the form of an
// OpenPGP public key packet, not including the packet header.
func (pk *PublicKeyV3) serializeWithoutHeaders(w io.Writer) (err error) {
var buf [8]byte
// Version 3
buf[0] = 3
// Creation time
t := uint32(pk.CreationTime.Unix())
buf[1] = byte(t >> 24)
buf[2] = byte(t >> 16)
buf[3] = byte(t >> 8)
buf[4] = byte(t)
// Days to expire
buf[5] = byte(pk.DaysToExpire >> 8)
buf[6] = byte(pk.DaysToExpire)
// Public key algorithm
buf[7] = byte(pk.PubKeyAlgo)
if _, err = w.Write(buf[:]); err != nil {
return
}
switch pk.PubKeyAlgo {
case PubKeyAlgoRSA, PubKeyAlgoRSAEncryptOnly, PubKeyAlgoRSASignOnly:
return writeMPIs(w, pk.n, pk.e)
}
return errors.InvalidArgumentError("bad public-key algorithm")
}
func UploadFromFileToUrl(url, fileName string, w io.Writer) (http.Header, error) {
if url == "" {
return http.Header{}, fmt.Errorf("To upload from a file to a url, I need a URL.")
}
w.Write([]byte("Uploading =>\t\t\t" + fileName + ":" + url + "\n"))
input, err := os.Open(fileName)
if err != nil {
return http.Header{}, err
}
defer input.Close()
request, err := http.NewRequest("POST", url, input)
if err != nil {
return http.Header{}, err
}
request.Header.Set("Content-Type", "application/json")
client := &http.Client{}
response, err := client.Do(request)
if err != nil {
return http.Header{}, err
}
defer response.Body.Close()
return response.Header, nil
}
func (server *SocksServer) handleSocks4(reader io.Reader, writer io.Writer, auth protocol.Socks4AuthenticationRequest) error {
result := protocol.Socks4RequestGranted
if auth.Command == protocol.CmdBind {
result = protocol.Socks4RequestRejected
}
socks4Response := protocol.NewSocks4AuthenticationResponse(result, auth.Port, auth.IP[:])
responseBuffer := alloc.NewSmallBuffer().Clear()
socks4Response.Write(responseBuffer)
writer.Write(responseBuffer.Value)
responseBuffer.Release()
if result == protocol.Socks4RequestRejected {
log.Warning("Unsupported socks 4 command %d", auth.Command)
return UnsupportedSocksCommand
}
dest := v2net.NewTCPDestination(v2net.IPAddress(auth.IP[:], auth.Port))
data, err := v2net.ReadFrom(reader, nil)
if err != nil {
return err
}
packet := v2net.NewPacket(dest, data, true)
server.transport(reader, writer, packet)
return nil
}
func debugFailf(out io.Writer, body bool, s string, v ...interface{}) func(*http.Response) os.Error {
return func(in *http.Response) os.Error {
ob, _ := http.DumpResponse(in, body)
out.Write(ob)
return os.NewError(fmt.Sprintf(s, v...))
}
}
// EncodeToStream serializes the provided object to the given writer. Overrides is ignored.
func (s *Serializer) EncodeToStream(obj runtime.Object, w io.Writer, overrides ...unversioned.GroupVersion) error {
if s.yaml {
json, err := json.Marshal(obj)
if err != nil {
return err
}
data, err := yaml.JSONToYAML(json)
if err != nil {
return err
}
_, err = w.Write(data)
return err
}
if s.pretty {
data, err := json.MarshalIndent(obj, "", " ")
if err != nil {
return err
}
_, err = w.Write(data)
return err
}
encoder := json.NewEncoder(w)
return encoder.Encode(obj)
}
// emitCDATA writes to w the CDATA-wrapped plain text data s.
// It escapes CDATA directives nested in s.
func emitCDATA(w io.Writer, s []byte) error {
if len(s) == 0 {
return nil
}
if _, err := w.Write(cdataStart); err != nil {
return err
}
for {
i := bytes.Index(s, cdataEnd)
if i >= 0 && i+len(cdataEnd) <= len(s) {
// Found a nested CDATA directive end.
if _, err := w.Write(s[:i]); err != nil {
return err
}
if _, err := w.Write(cdataEscape); err != nil {
return err
}
i += len(cdataEnd)
} else {
if _, err := w.Write(s); err != nil {
return err
}
break
}
s = s[i:]
}
if _, err := w.Write(cdataEnd); err != nil {
return err
}
return nil
}
func (par field) WriteValue(out io.Writer, valueOf reflect.Value) error {
if (par.Flags & (fieldNotAny | fieldFollowedBy)) != 0 {
return nil
}
if par.Index < 0 { // We can not out this value in all cases but if it was literal we can do it
// TODO: Check if it is string and output only in case it is literal
p := par.Parse
v := valueOf
for {
switch tp := p.(type) {
case *ptrParser:
p = tp.Parser
if v.IsNil() {
if tp.Optional {
return nil
}
return errors.New("Ptr value is nil")
}
v = v.Elem()
break
case *literalParser:
_, err := out.Write([]byte(tp.Literal))
return err
default:
return errors.New("Could not out anonymous field if it is not literal")
}
}
} else {
f := valueOf.Field(par.Index)
return par.Parse.WriteValue(out, f)
}
}
func (c *ClickWindow) write(ww io.Writer) (err error) {
var tmp [2]byte
tmp[0] = byte(c.ID >> 0)
if _, err = ww.Write(tmp[:1]); err != nil {
return
}
tmp[0] = byte(c.Slot >> 8)
tmp[1] = byte(c.Slot >> 0)
if _, err = ww.Write(tmp[:2]); err != nil {
return
}
tmp[0] = byte(c.Button >> 0)
if _, err = ww.Write(tmp[:1]); err != nil {
return
}
tmp[0] = byte(c.ActionNumber >> 8)
tmp[1] = byte(c.ActionNumber >> 0)
if _, err = ww.Write(tmp[:2]); err != nil {
return
}
tmp[0] = byte(c.Mode >> 0)
if _, err = ww.Write(tmp[:1]); err != nil {
return
}
if err = c.ClickedItem.Serialize(ww); err != nil {
return
}
return
}
func (s *SetSign) write(ww io.Writer) (err error) {
var tmp [8]byte
tmp[0] = byte(s.Location >> 56)
tmp[1] = byte(s.Location >> 48)
tmp[2] = byte(s.Location >> 40)
tmp[3] = byte(s.Location >> 32)
tmp[4] = byte(s.Location >> 24)
tmp[5] = byte(s.Location >> 16)
tmp[6] = byte(s.Location >> 8)
tmp[7] = byte(s.Location >> 0)
if _, err = ww.Write(tmp[:8]); err != nil {
return
}
if err = WriteString(ww, s.Line1); err != nil {
return
}
if err = WriteString(ww, s.Line2); err != nil {
return
}
if err = WriteString(ww, s.Line3); err != nil {
return
}
if err = WriteString(ww, s.Line4); err != nil {
return
}
return
}
func (vs *Vertexes) Print(w io.Writer, xPos, zPos int) (count int) {
var buf = make([]byte, 64)
copy(buf[0:2], "v ")
count = 0
for i := 0; i < len(*vs); i += 129 {
var x, z = (i / 129) / 17, (i / 129) % 17
var column = (*vs)[i : i+129]
for y, offset := range column {
if offset != -1 {
count++
var (
xa = x + xPos*16
ya = y - 64
za = z + zPos*16
)
buf = buf[:2]
buf = appendCoord(buf, xa)
buf = append(buf, ' ')
buf = appendCoord(buf, ya)
buf = append(buf, ' ')
buf = appendCoord(buf, za)
buf = append(buf, '\n')
w.Write(buf)
}
}
}
return
}
// writeTxIn encodes ti to the bitcoin protocol encoding for a transaction
// input (TxIn) to w.
func writeTxIn(w io.Writer, pver uint32, version uint32, ti *TxIn) error {
err := writeOutPoint(w, pver, version, &ti.PreviousOutpoint)
if err != nil {
return err
}
slen := uint64(len(ti.SignatureScript))
err = writeVarInt(w, pver, slen)
if err != nil {
return err
}
b := []byte(ti.SignatureScript)
_, err = w.Write(b)
if err != nil {
return err
}
err = writeElement(w, &ti.Sequence)
if err != nil {
return err
}
return nil
}
func pipe(r io.Reader, w io.Writer) {
var err error
defer func() {
if err != nil && err != io.EOF {
log.Print(err)
}
}()
firstChunk := true
buf := make([]byte, cmdline.bufsize)
for {
var n int
n, err = r.Read(buf)
if n <= 0 {
return
}
if firstChunk {
firstChunk = false
} else if cmdline.maxPostDelay > 0 {
delay(cmdline.minPostDelay, cmdline.maxPostDelay)
}
_, err = w.Write(buf[:n])
if err != nil {
return
}
}
}
// Write text to w; optionally html-escaped.
func writeText(w io.Writer, text []byte, html bool) {
if html {
template.HTMLEscape(w, text)
return
}
w.Write(text)
}
// writeMPI serializes a big integer to w.
func writeMPI(w io.Writer, bitLength uint16, mpiBytes []byte) (err error) {
_, err = w.Write([]byte{byte(bitLength >> 8), byte(bitLength)})
if err == nil {
_, err = w.Write(mpiBytes)
}
return
}
// serializeHeader writes an OpenPGP packet header to w. See RFC 4880, section
// 4.2.
func serializeHeader(w io.Writer, ptype packetType, length int) (err error) {
var buf [6]byte
var n int
buf[0] = 0x80 | 0x40 | byte(ptype)
if length < 192 {
buf[1] = byte(length)
n = 2
} else if length < 8384 {
length -= 192
buf[1] = 192 + byte(length>>8)
buf[2] = byte(length)
n = 3
} else {
buf[1] = 255
buf[2] = byte(length >> 24)
buf[3] = byte(length >> 16)
buf[4] = byte(length >> 8)
buf[5] = byte(length)
n = 6
}
_, err = w.Write(buf[:n])
return
}
func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.StreamFormatter) (string, error) {
out = utils.NewWriteFlusher(out)
img, err := srv.runtime.repositories.LookupImage(name)
if err != nil {
return "", err
}
file, err := utils.Download(url, out)
if err != nil {
return "", err
}
defer file.Body.Close()
config, _, _, err := ParseRun([]string{img.ID, "echo", "insert", url, path}, srv.runtime.capabilities)
if err != nil {
return "", err
}
b := NewBuilder(srv.runtime)
c, err := b.Create(config)
if err != nil {
return "", err
}
if err := c.Inject(utils.ProgressReader(file.Body, int(file.ContentLength), out, sf.FormatProgress("Downloading", "%v/%v (%v)"), sf), path); err != nil {
return "", err
}
// FIXME: Handle custom repo, tag comment, author
img, err = b.Commit(c, "", "", img.Comment, img.Author, nil)
if err != nil {
return "", err
}
out.Write(sf.FormatStatus(img.ID))
return img.ShortID(), nil
}
func renderElement(element interface{}, contextChain []interface{}, buf io.Writer) error {
switch elem := element.(type) {
case *textElement:
buf.Write(elem.text)
case *varElement:
defer func() {
if r := recover(); r != nil {
fmt.Printf("Panic while looking up %q: %s\n", elem.name, r)
}
}()
val, err := lookup(contextChain, elem.name, AllowMissingVariables)
if err != nil {
return err
}
if val.IsValid() {
if elem.raw {
fmt.Fprint(buf, val.Interface())
} else {
s := fmt.Sprint(val.Interface())
template.HTMLEscape(buf, []byte(s))
}
}
case *sectionElement:
if err := renderSection(elem, contextChain, buf); err != nil {
return err
}
case *Template:
if err := elem.renderTemplate(contextChain, buf); err != nil {
return err
}
}
return nil
}
// copyNRandomly copies n bytes from src to dst. It uses a variable, and random,
// buffer size to exercise more code paths.
func copyNRandomly(title string, dst io.Writer, src io.Reader, n int) (int, error) {
var (
buf = make([]byte, 32*1024)
written int
remaining = n
)
for remaining > 0 {
l := rand.Intn(1 << 15)
if remaining < l {
l = remaining
}
nr, er := src.Read(buf[:l])
nw, ew := dst.Write(buf[:nr])
remaining -= nw
written += nw
if ew != nil {
return written, ew
}
if nr != nw {
return written, io.ErrShortWrite
}
if er != nil && er != io.EOF {
return written, er
}
}
return written, nil
}
func WriteStatus(requestedTag string, out io.Writer, sf *utils.StreamFormatter, layers_downloaded bool) {
if layers_downloaded {
out.Write(sf.FormatStatus("", "Status: Downloaded newer image for %s", requestedTag))
} else {
out.Write(sf.FormatStatus("", "Status: Image is up to date for %s", requestedTag))
}
}
// Encode returns a WriteCloser which will encode the data written to it in
// OpenPGP armor.
func Encode(out io.Writer, blockType string, headers map[string]string) (w io.WriteCloser, err error) {
bType := []byte(blockType)
err = writeSlices(out, armorStart, bType, armorEndOfLineOut)
if err != nil {
return
}
for k, v := range headers {
err = writeSlices(out, []byte(k), armorHeaderSep, []byte(v), newline)
if err != nil {
return
}
}
_, err = out.Write(newline)
if err != nil {
return
}
e := &encoding{
out: out,
breaker: newLineBreaker(out, 64),
crc: crc24Init,
blockType: bType,
}
e.b64 = base64.NewEncoder(base64.StdEncoding, e.breaker)
return e, nil
}
func (c *Copier) Copy(dst io.Writer, src io.Reader) (wr int64, err error) {
buf := c.getBuffer()
defer c.putBuffer(buf)
for {
nr, er := src.Read(buf)
if nr > 0 {
nw, ew := dst.Write(buf[0:nr])
if nw > 0 {
wr += int64(nw)
}
if ew != nil {
err = ew
break
}
if nr != nw {
err = io.ErrShortWrite
break
}
}
if er == io.EOF {
break
}
if er != nil {
err = er
break
}
}
return wr, err
}
// Fprintf formats according to a format specifier and writes to w.
// It returns the number of bytes written and any write error encountered.
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
p := newPrinter()
p.doPrintf(format, a)
n, err = w.Write(p.buf)
p.free()
return
}
func (k *KnownHosts) AppendHost(hostname string, key ssh.PublicKey, out io.Writer) error {
hostname, port, err := net.SplitHostPort(hostname)
if err != nil {
return err
}
l := &Line{
PublicKey: key,
}
h := &Host{
Addr: hostname,
Port: port,
line: l,
}
l.Hosts = []*Host{h}
*k = append(*k, l)
if out != nil {
data, err := l.Marshal()
if err != nil {
return err
}
if _, err := out.Write(data); err != nil {
return err
}
}
return nil
}
// Fprintln formats using the default formats for its operands and writes to w.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
p := newPrinter()
p.doPrint(a, true, true)
n, err = w.Write(p.buf)
p.free()
return
}
func (ic *Iconv) convert(input []byte, out io.Writer, outBuf []byte) (bytesConverted int, err error) {
inputLen := len(input)
if inputLen == 0 {
return
}
outputLen := len(outBuf)
if outputLen == 0 {
outputLen = inputLen
outBuf = make([]byte, outputLen)
}
outputPtr := &outBuf[0]
outputPtrPtr := (**C.char)(unsafe.Pointer(&outputPtr))
outputBytesLeft := C.size_t(outputLen)
inputPtr := &input[0]
inputPtrPtr := (**C.char)(unsafe.Pointer(&inputPtr))
inputBytesLeft := C.size_t(inputLen)
_, err = C.iconv(ic.pIconv, inputPtrPtr, &inputBytesLeft, outputPtrPtr, &outputBytesLeft)
bytesConverted = inputLen - int(inputBytesLeft)
if int(outputBytesLeft) < outputLen {
out.Write(outBuf[:outputLen-int(outputBytesLeft)])
}
return
}
func (srv *Server) pullImage(r *registry.Registry, out io.Writer, imgId, endpoint string, token []string, sf *utils.StreamFormatter) error {
history, err := r.GetRemoteHistory(imgId, endpoint, token)
if err != nil {
return err
}
// FIXME: Try to stream the images?
// FIXME: Launch the getRemoteImage() in goroutines
for _, id := range history {
if !srv.runtime.graph.Exists(id) {
out.Write(sf.FormatStatus("Pulling %s metadata", id))
imgJSON, imgSize, err := r.GetRemoteImageJSON(id, endpoint, token)
if err != nil {
// FIXME: Keep goging in case of error?
return err
}
img, err := NewImgJSON(imgJSON)
if err != nil {
return fmt.Errorf("Failed to parse json: %s", err)
}
// Get the layer
out.Write(sf.FormatStatus("Pulling %s fs layer", id))
layer, err := r.GetRemoteImageLayer(img.ID, endpoint, token)
if err != nil {
return err
}
defer layer.Close()
if err := srv.runtime.graph.Register(utils.ProgressReader(layer, imgSize, out, sf.FormatProgress("Downloading", "%v/%v (%v)"), sf), false, img); err != nil {
return err
}
}
}
return nil
}
// Encodes the SnapshotRecoveryRequest to a buffer. Returns the number of bytes
// written and any error that may have occurred.
func (req *SnapshotRecoveryRequest) Encode(w io.Writer) (int, error) {
protoPeers := make([]*protobuf.SnapshotRecoveryRequest_Peer, len(req.Peers))
for i, peer := range req.Peers {
protoPeers[i] = &protobuf.SnapshotRecoveryRequest_Peer{
Name: proto.String(peer.Name),
ConnectionString: proto.String(peer.ConnectionString),
}
}
pb := &protobuf.SnapshotRecoveryRequest{
LeaderName: proto.String(req.LeaderName),
LastIndex: proto.Uint64(req.LastIndex),
LastTerm: proto.Uint64(req.LastTerm),
Peers: protoPeers,
State: req.State,
}
p, err := proto.Marshal(pb)
if err != nil {
return -1, err
}
return w.Write(p)
}
// FIXME: Allow to interupt current push when new push of same image is done.
func (srv *Server) ImagePush(name, endpoint string, out io.Writer, sf *utils.StreamFormatter, authConfig *auth.AuthConfig) error {
if err := srv.poolAdd("push", name); err != nil {
return err
}
defer srv.poolRemove("push", name)
out = utils.NewWriteFlusher(out)
img, err := srv.runtime.graph.Get(name)
r, err2 := registry.NewRegistry(srv.runtime.root, authConfig)
if err2 != nil {
return err2
}
if err != nil {
out.Write(sf.FormatStatus("The push refers to a repository [%s] (len: %d)", name, len(srv.runtime.repositories.Repositories[name])))
// If it fails, try to get the repository
if localRepo, exists := srv.runtime.repositories.Repositories[name]; exists {
if err := srv.pushRepository(r, out, name, endpoint, localRepo, sf); err != nil {
return err
}
return nil
}
return err
}
out.Write(sf.FormatStatus("The push refers to an image: [%s]", name))
if err := srv.pushImage(r, out, name, img.ID, endpoint, nil, sf); err != nil {
return err
}
return nil
}
// StringFormatter formats into the default string representation.
// It is stored under the name "str" and is the default formatter.
// You can override the default formatter by storing your default
// under the name "" in your custom formatter map.
func StringFormatter(w io.Writer, value interface{}, format string) {
if b, ok := value.([]byte); ok {
w.Write(b)
return
}
fmt.Fprint(w, value)
}
func SendToIPFS(fileName, gateway string, w io.Writer) (string, error) {
url := IPFSBaseGatewayUrl(gateway)
w.Write([]byte("POSTing file to IPFS. File =>\t" + fileName + "\n"))
var head http.Header
var err error
passed := false
for i := 0; i < 9; i++ {
head, err = UploadFromFileToUrl(url, fileName, w)
if err != nil {
time.Sleep(2 * time.Second)
continue
} else {
passed = true
break
}
}
if !passed {
head, err = UploadFromFileToUrl(url, fileName, w)
if err != nil {
return "", err
}
}
hash, ok := head["Ipfs-Hash"]
if !ok || hash[0] == "" {
return "", fmt.Errorf("No hash returned")
}
return hash[0], nil
}