vendor: github.com/hashicorp/terraform/...@v0.10.0

[github/fretlink/terraform-provider-statuscake.git] / vendor / golang.org / x / crypto / openpgp / packet / compressed.go

diff --git a/vendor/golang.org/x/crypto/openpgp/packet/compressed.go b/vendor/golang.org/x/crypto/openpgp/packet/compressed.go
new file mode 100644 (file)
index 0000000..e8f0b5c
--- /dev/null
+++ b/vendor/golang.org/x/crypto/openpgp/packet/compressed.go
@@ -0,0 +1,123 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packet
+
+import (
+       "compress/bzip2"
+       "compress/flate"
+       "compress/zlib"
+       "golang.org/x/crypto/openpgp/errors"
+       "io"
+       "strconv"
+)
+
+// Compressed represents a compressed OpenPGP packet. The decompressed contents
+// will contain more OpenPGP packets. See RFC 4880, section 5.6.
+type Compressed struct {
+       Body io.Reader
+}
+
+const (
+       NoCompression      = flate.NoCompression
+       BestSpeed          = flate.BestSpeed
+       BestCompression    = flate.BestCompression
+       DefaultCompression = flate.DefaultCompression
+)
+
+// CompressionConfig contains compressor configuration settings.
+type CompressionConfig struct {
+       // Level is the compression level to use. It must be set to
+       // between -1 and 9, with -1 causing the compressor to use the
+       // default compression level, 0 causing the compressor to use
+       // no compression and 1 to 9 representing increasing (better,
+       // slower) compression levels. If Level is less than -1 or
+       // more then 9, a non-nil error will be returned during
+       // encryption. See the constants above for convenient common
+       // settings for Level.
+       Level int
+}
+
+func (c *Compressed) parse(r io.Reader) error {
+       var buf [1]byte
+       _, err := readFull(r, buf[:])
+       if err != nil {
+               return err
+       }
+
+       switch buf[0] {
+       case 1:
+               c.Body = flate.NewReader(r)
+       case 2:
+               c.Body, err = zlib.NewReader(r)
+       case 3:
+               c.Body = bzip2.NewReader(r)
+       default:
+               err = errors.UnsupportedError("unknown compression algorithm: " + strconv.Itoa(int(buf[0])))
+       }
+
+       return err
+}
+
+// compressedWriterCloser represents the serialized compression stream
+// header and the compressor. Its Close() method ensures that both the
+// compressor and serialized stream header are closed. Its Write()
+// method writes to the compressor.
+type compressedWriteCloser struct {
+       sh io.Closer      // Stream Header
+       c  io.WriteCloser // Compressor
+}
+
+func (cwc compressedWriteCloser) Write(p []byte) (int, error) {
+       return cwc.c.Write(p)
+}
+
+func (cwc compressedWriteCloser) Close() (err error) {
+       err = cwc.c.Close()
+       if err != nil {
+               return err
+       }
+
+       return cwc.sh.Close()
+}
+
+// SerializeCompressed serializes a compressed data packet to w and
+// returns a WriteCloser to which the literal data packets themselves
+// can be written and which MUST be closed on completion. If cc is
+// nil, sensible defaults will be used to configure the compression
+// algorithm.
+func SerializeCompressed(w io.WriteCloser, algo CompressionAlgo, cc *CompressionConfig) (literaldata io.WriteCloser, err error) {
+       compressed, err := serializeStreamHeader(w, packetTypeCompressed)
+       if err != nil {
+               return
+       }
+
+       _, err = compressed.Write([]byte{uint8(algo)})
+       if err != nil {
+               return
+       }
+
+       level := DefaultCompression
+       if cc != nil {
+               level = cc.Level
+       }
+
+       var compressor io.WriteCloser
+       switch algo {
+       case CompressionZIP:
+               compressor, err = flate.NewWriter(compressed, level)
+       case CompressionZLIB:
+               compressor, err = zlib.NewWriterLevel(compressed, level)
+       default:
+               s := strconv.Itoa(int(algo))
+               err = errors.UnsupportedError("Unsupported compression algorithm: " + s)
+       }
+       if err != nil {
+               return
+       }
+
+       literaldata = compressedWriteCloser{compressed, compressor}
+
+       return
+}