Esempio n. 1
0
// Inflate utility that decompresses a string using the flate algo
func Inflate(deflated []byte) []byte {
	var b bytes.Buffer
	r := flate.NewReader(bytes.NewReader(deflated))
	b.ReadFrom(r)
	r.Close()
	return b.Bytes()
}
Esempio n. 2
0
func (db *Database) Load(filename string) {
	var rows, columns uint32
	f, _ := os.Open(filename)
	c := flate.NewReader(f)
	r := bufio.NewReader(c)
	binary.Read(r, binary.LittleEndian, &rows)
	binary.Read(r, binary.LittleEndian, &columns)
	ids := make(map[string]int)
	db.ids = ids
	keys := make([]string, rows)
	db.keys = keys
	for i := 0; i < int(rows); i++ {
		b, _ := r.ReadBytes('\x00')
		key := string(b[:len(b)-1])
		keys[i] = key
		ids[key] = i
	}
	db.columns = make(map[string]*Column)
	for i := 0; i < int(columns); i++ {
		var id, count uint32
		name, _ := r.ReadBytes('\x00')
		binary.Read(r, binary.LittleEndian, &count)
		column := db.getColumn(string(name[:len(name)-1]))
		for j := 0; j < int(count); j++ {
			binary.Read(r, binary.LittleEndian, &id)
			column.Set(int(id), true)
		}
	}
	c.Close()
	f.Close()
}
Esempio n. 3
0
func (parser *redirectRequestParser) Parse(request *http.Request) (loginReq *AuthnRequest,
	relayState string, err error) {
	err = request.ParseForm()
	if err != nil {
		return
	}
	relayState = request.Form.Get("RelayState")
	if len(relayState) > 80 {
		err = errors.New("RelayState cannot be longer than 80 characters.")
		return
	}
	samlReq := request.Form.Get("SAMLRequest")
	// URL decoding is already performed
	// remove base64 encoding
	reqBytes, err := base64.StdEncoding.DecodeString(samlReq)
	if err != nil {
		return
	}
	// Remove deflate
	req := flate.NewReader(bytes.NewReader(reqBytes))
	// Read the XML
	decoder := xml.NewDecoder(req)
	loginReq = &AuthnRequest{}
	err = decoder.Decode(loginReq)
	return
}
Esempio n. 4
0
func NewConnection(nodeID string, reader io.Reader, writer io.Writer, receiver Model) Connection {
	cr := &countingReader{Reader: reader}
	cw := &countingWriter{Writer: writer}

	flrd := flate.NewReader(cr)
	flwr, err := flate.NewWriter(cw, flate.BestSpeed)
	if err != nil {
		panic(err)
	}
	wb := bufio.NewWriter(flwr)

	c := rawConnection{
		id:        nodeID,
		receiver:  nativeModel{receiver},
		reader:    flrd,
		cr:        cr,
		xr:        xdr.NewReader(flrd),
		writer:    flwr,
		cw:        cw,
		wb:        wb,
		xw:        xdr.NewWriter(wb),
		awaiting:  make([]chan asyncResult, 0x1000),
		indexSent: make(map[string]map[string][2]int64),
		outbox:    make(chan []encodable),
		nextID:    make(chan int),
		closed:    make(chan struct{}),
	}

	go c.readerLoop()
	go c.writerLoop()
	go c.pingerLoop()
	go c.idGenerator()

	return wireFormatConnection{&c}
}
Esempio n. 5
0
// NewReaderDict is like NewReader but uses a preset dictionary.
// NewReaderDict ignores the dictionary if the compressed data does not refer to it.
func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, os.Error) {
	z := new(reader)
	if fr, ok := r.(flate.Reader); ok {
		z.r = fr
	} else {
		z.r = bufio.NewReader(r)
	}
	_, err := io.ReadFull(z.r, z.scratch[0:2])
	if err != nil {
		return nil, err
	}
	h := uint(z.scratch[0])<<8 | uint(z.scratch[1])
	if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) {
		return nil, HeaderError
	}
	if z.scratch[1]&0x20 != 0 {
		_, err = io.ReadFull(z.r, z.scratch[0:4])
		if err != nil {
			return nil, err
		}
		checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
		if checksum != adler32.Checksum(dict) {
			return nil, DictionaryError
		}
		z.decompressor = flate.NewReaderDict(z.r, dict)
	} else {
		z.decompressor = flate.NewReader(z.r)
	}
	z.digest = adler32.New()
	return z, nil
}
Esempio n. 6
0
func Decrypt(key string, publickey PublicKey, rin io.Reader) (r io.Reader, length int64, sequence int64, e os.Error) {
	c, e := simpleCipher(key)
	if e != nil {
		e = os.NewError("Trouble reading the symmetric key: " + e.String())
		return
	}
	pub, e := readPublicKey(publickey)
	if e != nil {
		e = os.NewError("Trouble reading the public key: " + e.String())
		return
	}
	iv := make([]byte, c.BlockSize())
	_, e = io.ReadFull(rin, iv) // read the iv first (it's not encrypted)
	if e != nil {
		e = os.NewError("Trouble reading the iv: " + e.String())
		return
	}
	decrypter := cipher.NewCFBDecrypter(c, iv)
	rdec := flate.NewReader(cipher.StreamReader{decrypter, rin})
	e = binary.Read(rdec, binary.LittleEndian, &length)
	if e != nil {
		e = os.NewError("Trouble reading the file length: " + e.String())
		return
	}
	e = binary.Read(rdec, binary.LittleEndian, &sequence)
	if e != nil {
		e = os.NewError("Trouble reading the serial number: " + e.String())
		return
	}
	return &hashReader{rdec, sha256.New(), pub, length}, length, sequence, nil
}
Esempio n. 7
0
func (dz *reader) get(start, size int64) ([]byte, error) {

	if size == 0 {
		return []byte{}, nil
	}

	if start < 0 || size < 0 {
		return nil, fmt.Errorf("Negative start or size")
	}

	if int(start/dz.blocksize) >= len(dz.offsets) {
		return nil, fmt.Errorf("Start passed end of archive")
	}

	start1 := dz.blocksize * (start / dz.blocksize)
	size1 := size + (start - start1)

	dz.lock.Lock()
	defer dz.lock.Unlock()

	_, err := dz.fp.Seek(dz.offsets[start/dz.blocksize], 0)
	if err != nil {
		return nil, err
	}
	rd := flate.NewReader(dz.fp)

	data := make([]byte, size1)
	_, err = io.ReadFull(rd, data)
	if err != nil {
		return nil, err
	}

	return data[start-start1:], nil
}
Esempio n. 8
0
func ExampleDecode() {
	// In this example, we read a PBM (black and white) "file" (really a
	// hard-wired string to make the example self-contained) into a PPM
	// (color) image.  Because netpbm.Decode returns a netpbm.Image, not a
	// generic image.Image we can query its Netpbm format and maximum
	// value.  We also output an arbitrary white pixel to show how B&W can
	// be promoted to color.

	const pbmRaw = "\n0\xe1RVp\x0eru\f\xf1\x0f\xb2Rp\xf7\xf4\rP\b\xf0\xf3Up\xcb\xcc)I-R\bK-*\xce\xcc\xcfS0\xd43\xe423Q02\xe1\xfa\x0f\x02\xff\xfe\xff\x06\xd3\x1f\xec\x1b\xc1\xf4a{\x060\xddo\xc3\x01\xa6\xe5l*\xc0\xca\xea,~\x80\xe8?\u007f\n\u007f\x82\xe8\x9f\xff\x1eC\xe8\xff\xcf?\x02\xa9\v\xc6\xff\xfa?\xff\xff\xdf\xc0\xfd|A\xff\xe3\xff\x17\xe2\xff\x1fc\x90?\xfe\x83\xf5\xff\x97\xbeB\xfb\xe3M\xff\xff2\xcc\u007fd/\xbf\xff/\x03\xb7\xfc\xa1:\xf9\xff\f\xfc\xff\xed\xfbj\xec\xff\x89\xff\a\xd2\x15\xf5 \xe3\xed\xe4\x12\xc0\xd6\xd8\xd81\x82i\x81\u007f\xec`\x9a\xf1\u007f?\xd8\x19`\x1e\x1a\x00\x04\x00\x00\xff\xff"
	r := flate.NewReader(bytes.NewBufferString(pbmRaw))
	img, err := netpbm.Decode(r, &netpbm.DecodeOptions{
		Target:      netpbm.PPM, // Want to wind up with color
		Exact:       false,      // Can accept grayscale or B&W too
		PBMMaxValue: 42,         // B&W white --> (42, 42, 42)
	})
	if err != nil {
		panic(err)
	}
	r.Close()
	fmt.Printf("Image is of type %s.\n", img.Format())
	fmt.Printf("Maximum channel value is %d.\n", img.MaxValue())
	fmt.Printf("Color at (32, 20) is %#v.\n", img.At(32, 20))
	// Output:
	// Image is of type PPM.
	// Maximum channel value is 42.
	// Color at (32, 20) is npcolor.RGBM{R:0x2a, G:0x2a, B:0x2a, M:0x2a}.
}
Esempio n. 9
0
func Decompress(in []byte) []byte {
	buf := new(bytes.Buffer)
	decompressor := flate.NewReader(bytes.NewReader(in))
	io.Copy(buf, decompressor)
	decompressor.Close()
	return buf.Bytes()
}
Esempio n. 10
0
func main() {
	var file *os.File
	var err error

	if file, err = os.Open("output/sample.tar.flate"); err != nil {
		log.Fatalln(err)
	}
	defer file.Close()

	tr := tar.NewReader(flate.NewReader(file))

	var header *tar.Header
	for {
		header, err = tr.Next()
		if err == io.EOF {
			// ファイルの最後
			break
		}
		if err != nil {
			log.Fatalln(err)
		}

		buf := new(bytes.Buffer)
		if _, err = io.Copy(buf, tr); err != nil {
			log.Fatalln(err)
		}

		if err = ioutil.WriteFile("output/"+header.Name, buf.Bytes(), 0755); err != nil {
			log.Fatal(err)
		}
	}

}
Esempio n. 11
0
func (r *ZipScannerImpl) Reader() (io.Reader, error) {
	switch r.fh.Method {
	case zip.Deflate:
		if r.Debug {
			fmt.Println("inflating...")
		}

		r.fr = flate.NewReader(r.reader)

	case zip.Store:
		if r.Debug {
			fmt.Println("reading...")
		}

		if r.fh.UncompressedSize > 0 {
			r.fr = io.LimitReader(r.reader, int64(r.fh.UncompressedSize))
		} else if r.fh.UncompressedSize == 0 && (r.fh.Flags&hasDataDescriptor) == 0 {
			// file of 0 bytes or directory ?
			r.fr = io.LimitReader(r.reader, 0)
		} else {
			return r.readError(NoUncompressedSize)
		}

	default:
		return r.readError(UnsupportedCompression)
	}

	r.err = nil
	return r.fr, r.err
}
Esempio n. 12
0
func DecompressString(in string) string {
	buf := new(bytes.Buffer)
	decompressor := flate.NewReader(strings.NewReader(in))
	io.Copy(buf, decompressor)
	decompressor.Close()
	return buf.String()
}
Esempio n. 13
0
// BodyReader returns an io.ReadCloser that reads the HTTP request or response
// body. If mv.skipBody was set the reader will immediately return io.EOF.
//
// If the Decode option is passed the body will be unchunked if
// Transfer-Encoding is set to "chunked", and will decode the following
// Content-Encodings: gzip, deflate.
func (mv *MessageView) BodyReader(opts ...Option) (io.ReadCloser, error) {
	var r io.Reader

	conf := &config{}
	for _, o := range opts {
		o(conf)
	}

	br := bytes.NewReader(mv.message)
	r = io.NewSectionReader(br, mv.bodyoffset, mv.traileroffset-mv.bodyoffset)

	if !conf.decode {
		return ioutil.NopCloser(r), nil
	}

	if mv.chunked {
		r = httputil.NewChunkedReader(r)
	}
	switch mv.compress {
	case "gzip":
		gr, err := gzip.NewReader(r)
		if err != nil {
			return nil, err
		}
		return gr, nil
	case "deflate":
		return flate.NewReader(r), nil
	default:
		return ioutil.NopCloser(r), nil
	}
}
Esempio n. 14
0
//Read returns a channel which logentries are appended to
//in sequential order
func (l *Logger) Read() <-chan model.LogEntry {
	c := make(chan model.LogEntry)

	go func(c chan<- model.LogEntry) {
		defer close(c)
		rFile, err := os.OpenFile(l.wFile.Name(), os.O_RDONLY, 0644)
		if err != nil {
			log.Fatal(err)
		}
		defer rFile.Close()

		reader := flate.NewReader(rFile)
		defer reader.Close()

		scanner := bufio.NewScanner(reader)
		scanner.Split(ScanPayloadSplitFunc)
		for scanner.Scan() {
			entry := model.LogEntry(scanner.Bytes())
			c <- entry
		}
		err = scanner.Err()
		if err != nil && err != io.ErrUnexpectedEOF {
			log.Fatal(err)
		}
	}(c)
	return c
}
Esempio n. 15
0
func NewCompressedReadWriteCloser(rwc io.ReadWriteCloser) io.ReadWriteCloser {
	w, _ := flate.NewWriter(rwc, 1)
	return &compressedRWC{
		flate.NewReader(rwc),
		w,
	}
}
Esempio n. 16
0
func (self *Surf) Download(req Request) (resp *http.Response, err error) {
	param, err := NewParam(req)
	if err != nil {
		return nil, err
	}
	param.client = self.buildClient(param)
	resp, err = self.httpRequest(param)

	if err == nil {
		switch resp.Header.Get("Content-Encoding") {
		case "gzip":
			var gzipReader *gzip.Reader
			gzipReader, err = gzip.NewReader(resp.Body)
			if err == nil {
				resp.Body = gzipReader
			}

		case "deflate":
			resp.Body = flate.NewReader(resp.Body)

		case "zlib":
			var readCloser io.ReadCloser
			readCloser, err = zlib.NewReader(resp.Body)
			if err == nil {
				resp.Body = readCloser
			}
		}
	}

	resp = param.writeback(resp)

	return
}
Esempio n. 17
0
func (a *Article) Website() io.ReadCloser {
	if a.WebsiteRaw != nil {
		return flate.NewReader(bytes.NewReader(a.WebsiteRaw))
	}

	return nil
}
Esempio n. 18
0
func main() {

	input, e := ioutil.ReadAll(os.Stdin)
	if e != nil {
		log.Fatal(e)
	}

	if isHttpPostBinding(input) {
		decoded, e := base64.StdEncoding.DecodeString(string(input))
		if e != nil {
			log.Fatal(e)
		}

		fmt.Print(string(decoded))

	} else {
		unescaped, e := url.QueryUnescape(string(input))
		if e != nil {
			log.Fatal(e)
		}

		decoded, e := base64.StdEncoding.DecodeString(unescaped)
		if e != nil {
			log.Fatal(e)
		}

		inflater := flate.NewReader(bytes.NewBuffer(decoded))

		io.Copy(os.Stdout, inflater)

		inflater.Close()
	}
}
Esempio n. 19
0
func readBody(resp *http.Response) ([]byte, error) {
	buffer := bytes.NewBuffer(make([]byte, 0, 1024))
	var rd io.ReadCloser
	var err error
	switch resp.Header.Get("Content-Encoding") {
	case "gzip":
		rd, _ = gzip.NewReader(resp.Body)
		defer rd.Close()
	case "deflate":
		rd = flate.NewReader(resp.Body)
		defer rd.Close()
	default:
		rd = resp.Body
	}
	defer func() {
		e := recover()
		if e == nil {
			return
		}
		if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
			err = panicErr
		} else {
			panic(e)
		}
	}()
	_, err = buffer.ReadFrom(rd)
	return buffer.Bytes(), err
}
Esempio n. 20
0
func (data *Data) Decompress() error {
	if !data.IsCompressed() {
		return nil
	}
	input := bytes.NewBuffer(data.Content)
	var reader io.Reader
	if data.ContentEncoding == ceDeflate {
		reader = flate.NewReader(input)
	} else if data.ContentEncoding == ceGzip {
		var err error
		if reader, err = gzip.NewReader(input); err != nil {
			return err
		}
	} else {
		return log.Error("unknown content-encoding",
			log.WithValue("content-encoding", data.ContentEncoding))
	}
	writer := bytes.Buffer{}
	_, err := io.Copy(&writer, reader)
	if err != nil {
		return err
	}
	data.Content = writer.Bytes()
	data.ContentEncoding = ""
	data.UncompressedLength = len(data.Content)
	return nil
}
Esempio n. 21
0
// NewIdpAuthnRequest returns a new IdpAuthnRequest for the given HTTP request to the authorization
// service.
func NewIdpAuthnRequest(idp *IdentityProvider, r *http.Request) (*IdpAuthnRequest, error) {
	req := &IdpAuthnRequest{
		IDP:         idp,
		HTTPRequest: r,
	}

	switch r.Method {
	case "GET":
		compressedRequest, err := base64.StdEncoding.DecodeString(r.URL.Query().Get("SAMLRequest"))
		if err != nil {
			return nil, fmt.Errorf("cannot decode request: %s", err)
		}
		req.RequestBuffer, err = ioutil.ReadAll(flate.NewReader(bytes.NewReader(compressedRequest)))
		if err != nil {
			return nil, fmt.Errorf("cannot decompress request: %s", err)
		}
		req.RelayState = r.URL.Query().Get("RelayState")
	case "POST":
		if err := r.ParseForm(); err != nil {
			return nil, err
		}
		var err error
		req.RequestBuffer, err = base64.StdEncoding.DecodeString(r.PostForm.Get("SAMLRequest"))
		if err != nil {
			return nil, err
		}
		req.RelayState = r.PostForm.Get("RelayState")
	default:
		return nil, fmt.Errorf("method not allowed")
	}
	return req, nil
}
Esempio n. 22
0
func (f *FetchServer) decodeResponse(resp *http.Response) (resp1 *http.Response, err error) {
	if resp.StatusCode != 200 {
		return resp, nil
	}

	var hdrLen uint16
	if err = binary.Read(resp.Body, binary.BigEndian, &hdrLen); err != nil {
		return
	}

	hdrBuf := make([]byte, hdrLen)
	if _, err = io.ReadFull(resp.Body, hdrBuf); err != nil {
		return
	}

	resp1, err = http.ReadResponse(bufio.NewReader(flate.NewReader(bytes.NewReader(hdrBuf))), resp.Request)
	if err != nil {
		return
	}

	data, _ := ioutil.ReadAll(resp.Body)

	resp1.Body = httpproxy.NewMultiReadCloser(bytes.NewReader(data), resp.Body)

	return
}
Esempio n. 23
0
// Open returns a ReadCloser that provides access to the File's contents.
func (f *File) Open() (rc io.ReadCloser, err os.Error) {
	off := int64(f.headerOffset)
	size := int64(f.CompressedSize)
	if f.bodyOffset == 0 {
		r := io.NewSectionReader(f.zipr, off, f.zipsize-off)
		if err = readFileHeader(f, r); err != nil {
			return
		}
		if f.bodyOffset, err = r.Seek(0, os.SEEK_CUR); err != nil {
			return
		}
		if size == 0 {
			size = int64(f.CompressedSize)
		}
	}
	if f.hasDataDescriptor() && size == 0 {
		// permit SectionReader to see the rest of the file
		size = f.zipsize - (off + f.bodyOffset)
	}
	r := io.NewSectionReader(f.zipr, off+f.bodyOffset, size)
	switch f.Method {
	case Store: // (no compression)
		rc = ioutil.NopCloser(r)
	case Deflate:
		rc = flate.NewReader(r)
	default:
		err = UnsupportedMethod
	}
	if rc != nil {
		rc = &checksumReader{rc, crc32.NewIEEE(), f, r}
	}
	return
}
Esempio n. 24
0
func (f *FetchServer) decodeResponse(resp *http.Response) (resp1 *http.Response, err error) {
	if resp.StatusCode != 200 {
		return resp, nil
	}

	var hdrLen uint16
	if err = binary.Read(resp.Body, binary.BigEndian, &hdrLen); err != nil {
		return
	}

	hdrBuf := make([]byte, hdrLen)
	if _, err = io.ReadFull(resp.Body, hdrBuf); err != nil {
		return
	}

	resp1, err = http.ReadResponse(bufio.NewReader(flate.NewReader(bytes.NewReader(hdrBuf))), resp.Request)
	if err != nil {
		return
	}

	const cookieKey string = "Set-Cookie"
	if cookie := resp1.Header.Get(cookieKey); cookie != "" {
		parts := strings.Split(cookie, ", ")

		parts1 := make([]string, 0)
		for i := 0; i < len(parts); i++ {
			c := parts[i]
			if i == 0 || strings.Contains(strings.Split(c, ";")[0], "=") {
				parts1 = append(parts1, c)
			} else {
				parts1[len(parts1)-1] = parts1[len(parts1)-1] + ", " + c
			}
		}

		resp1.Header.Del(cookieKey)
		for i := 0; i < len(parts1); i++ {
			resp1.Header.Add(cookieKey, parts1[i])
		}
	}

	if resp1.StatusCode >= 400 {
		switch {
		case resp.Body == nil:
			break
		case resp1.Body == nil:
			resp1.Body = resp.Body
		default:
			b, _ := ioutil.ReadAll(resp1.Body)
			if b != nil && len(b) > 0 {
				resp1.Body = httpproxy.NewMultiReadCloser(bytes.NewReader(b), resp.Body)
			} else {
				resp1.Body = resp.Body
			}
		}
	} else {
		resp1.Body = resp.Body
	}

	return
}
Esempio n. 25
0
func (c *Conn) parseXzver() (result []MessageOverview, err error) {
	// XZVER is a yenc stream…
	yencStream := &yencReader{r: c.r}
	defer yencStream.Close()

	// containing a DEFLATE stream…
	flateStream := flate.NewReader(yencStream)
	defer flateStream.Close()

	// containing an overview stream…
	result, err = parseOverview(bufio.NewReader(flateStream))

	if err == nil {
		// …with a dot at the end
		flateStream.Close()
		yencStream.Close()

		var line string
		line, err = c.r.ReadString('\n')
		if err == nil && strings.TrimRight(line, "\r\n") != "." {
			return nil, fmt.Errorf("unexpected data after XZVER: %q", line)
		}
	}

	return
}
Esempio n. 26
0
// 识别输入(文件名/网址)并提供弹幕数据
func identify(par string) (r io.ReadCloser, name string, err error) {
	if biliz.MatchString(par) {
		err := func() error {
			resp, err := http.Get(par)
			if err != nil {
				return err
			}
			defer resp.Body.Close()
			data, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				return err
			}
			matched := addrs.FindSubmatch(data)
			if len(matched) == 0 {
				return errNoXML
			}
			par = string(matched[1]) + `.xml`
			matched = title.FindSubmatch(data)
			if len(matched) == 0 {
				return errNoTitle
			}
			name = string(matched[1]) + `.ass`
			resp, err = http.Get(`http://comment.bilibili.com/` + par)
			if err != nil {
				return err
			}
			defer resp.Body.Close()
			if resp.Header.Get("Content-Encoding") == "deflate" {
				resp.Body = flate.NewReader(resp.Body)
				defer resp.Body.Close()
			}
			file, err := os.Create(par)
			if err != nil {
				return err
			}
			defer file.Close()
			xml, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				return err
			}
			file.Write(xml)
			return nil
		}()
		if err != nil {
			return nil, "", err
		}
	} else {
		if n := strings.LastIndex(par, "."); n < 0 {
			name = par + ".ass"
		} else {
			name = par[:n] + ".ass"
		}
	}
	file, err := os.Open(par)
	if err != nil {
		return nil, "", err
	}
	return file, name, nil
}
Esempio n. 27
0
func DeCompress(src []byte, length int) []byte {
	realSrc := src[:length]
	b := bytes.NewReader(realSrc)
	var out bytes.Buffer
	r := flate.NewReader(b)
	io.Copy(&out, r)
	return out.Bytes()
}
Esempio n. 28
0
func Uncompress(stream []byte) ([]byte, error) {
	stream = append(Dictionary, stream...)
	uncompressed, err := ioutil.ReadAll(flate.NewReader(bytes.NewBuffer(stream)))
	if err != nil {
		return nil, err
	}
	return uncompressed, nil
}
Esempio n. 29
0
func (alg *Deflate) Decompress(compressedText []byte) []byte {

	enflated, _ := ioutil.ReadAll(
		flate.NewReader(
			bytes.NewReader(compressedText)))

	return enflated
}
Esempio n. 30
0
func inflate(src []byte) []byte {
	r := bytes.NewReader(src)
	b, err := ioutil.ReadAll(flate.NewReader(r))
	if err != nil {
		panic(err)
	}
	return b
}