summaryrefslogtreecommitdiffstats
path: root/tests/var/certificate.crt
Commit message (Expand)AuthorAgeFilesLines
* Support for SSL in wsgi.ServiceDavanum Srinivas2013-01-291-0/+30
ef='#n12'>12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
#
# gzread.py - python gzip input wrapper
#
# Jakub Jelinek <jakub@redhat.com>
#
# Copyright 2001 Red Hat, Inc.
#
# This software may be freely redistributed under the terms of the GNU
# library public license.
#
# You should have received a copy of the GNU Library Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#

import string
import zlib
import __builtin__

# implements a python function that reads and writes a gzipped file
# the user of the file doesn't have to worry about the compression,
# but random access is not allowed

# based on Andrew Kuchling's minigzip.py distributed with the zlib module

FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT = 1, 2, 4, 8, 16

def read32(buf):
    v = ord(buf[0])
    v = v + (ord(buf[1]) << 8)
    v = v + (ord(buf[2]) << 16)
    v = v + (ord(buf[3]) << 24)
    return v

def open(filename, fileobj=None):
    return GzipFile(filename, fileobj)

class GzipFile:

    myfileobj = None

    def __init__(self, filename=None, fileobj=None):
	if fileobj is None:
	    fileobj = self.myfileobj = __builtin__.open(filename, 'r')
	self._init_read()
	self.decompress = zlib.decompressobj(-zlib.MAX_WBITS)
	self.fileobj = fileobj
	self.compressed = 1
	self._read_gzip_header()

    def _init_read(self):
	self.crc = zlib.crc32("")
	self.size = 0
	self.extrabuf = ""
	self.extrasize = 0
	self.lastbuf = ""

    def _read_gzip_header(self):
	magic = self.fileobj.read(2)
	if magic != '\037\213':
	    self._unread(magic)
	    self.compressed = 0
	    return
	method = ord( self.fileobj.read(1) )
	if method != 8:
	    raise RuntimeError, 'Unknown compression method'
	flag = ord( self.fileobj.read(1) )
	# modtime = self.fileobj.read(4)
	# extraflag = self.fileobj.read(1)
	# os = self.fileobj.read(1)
	self.fileobj.read(6)

	if flag & FEXTRA:
	    # Read & discard the extra field, if present
	    xlen=ord(self.fileobj.read(1))	      
	    xlen=xlen+256*ord(self.fileobj.read(1))
	    self.fileobj.read(xlen)
	if flag & FNAME:
	    # Read and discard a null-terminated string containing the filename
	    while (1):
		s=self.fileobj.read(1)
		if not s or s=='\000': break
	if flag & FCOMMENT:
	    # Read and discard a null-terminated string containing a comment
	    while (1):
		s=self.fileobj.read(1)
		if not s or s=='\000': break
	if flag & FHCRC:
	    self.fileobj.read(2)     # Read & discard the 16-bit header CRC

    def read(self,size=None):
	if self.extrasize <= 0 and self.fileobj is None:
	    return ''

	if not self.compressed:
	    chunk = ''
	    if size and self.extrasize >= size:
		chunk = self.extrabuf[:size]
		self.extrabuf = self.extrabuf[size:]
		self.extrasize = self.extrasize - size
		return chunk
	    if self.extrasize:
		chunk = self.extrabuf
		if size:
		    size = size - self.extrasize
		self.extrasize = 0
		self.extrabuf = ''
	    if not size:
		return chunk + self.fileobj.read()
	    else:
		return chunk + self.fileobj.read(size)

	readsize = 1024
	if not size:	# get the whole thing
	    try:
		while 1:
		    self._read(readsize)
		    readsize = readsize * 2
	    except EOFError:
		size = self.extrasize
	else:	       # just get some more of it
	    try:
		while size > self.extrasize:
		    self._read(readsize)
		    readsize = readsize * 2
	    except EOFError:
		pass
	
	chunk = self.extrabuf[:size]
	self.extrabuf = self.extrabuf[size:]
	self.extrasize = self.extrasize - size

	return chunk

    def _unread(self, buf):
	self.extrabuf = buf + self.extrabuf
	self.extrasize = len(buf) + self.extrasize

    def _read(self, size=1024):
	try:
	    buf = self.fileobj.read(size)
	except AttributeError:
	    raise EOFError, "Reached EOF"
	if buf == "":
	    uncompress = self.decompress.flush()
	    if uncompress == "":
		self._read_eof()
		self.fileobj = None
		raise EOFError, 'Reached EOF'
	else:
	    xlen = len(buf)
	    if xlen >= 8:
		xoff = 0
		boff = xlen - 8
	    else:
		xoff = 8 - xlen
		boff = 0
	    self.lastbuf = self.lastbuf[:xoff] + buf[boff:]
	    uncompress = self.decompress.decompress(buf)
	self.crc = zlib.crc32(uncompress, self.crc)
	self.extrabuf = self.extrabuf + uncompress
	self.extrasize = self.extrasize + len(uncompress)
	self.size = self.size + len(uncompress)

    def _read_eof(self):
	crc32 = read32(self.lastbuf[:4])
	isize = read32(self.lastbuf[4:8])
	if crc32 != self.crc:
	    raise IOError, 'CRC check failed'
	elif isize != self.size:
	    raise IOError, 'Incorrect length of data produced'

    def close(self):
	self.fileobj = None
	if self.myfileobj:
	    self.myfileobj.close()
	    self.myfileobj = None

    def flush(self):
	self.fileobj.flush()

    def seek(self):
	raise IOError, 'Random access not allowed in gzip files'

    def tell(self):
	raise IOError, 'I won\'t tell() you for gzip files'

    def isatty(self):
	return 0

    def readline(self):
	bufs = []
	readsize = 100
	while 1:
	    c = self.read(readsize)
	    i = string.find(c, '\n')
	    if i >= 0 or c == '':
		bufs.append(c[:i])
		self._unread(c[i+1:])
		return string.join(bufs, '')
	    bufs.append(c)
	    readsize = readsize * 2

    def readlines(self):
	buf = self.read()
	return string.split(buf, '\n')