Example #1
0
    def _rfc2231_and_continuation_params(cls, params):  # TODO: complexity
        count = set()
        continuations = dict()
        for key, value, quoted in params:
            if key in count:
                raise InvalidHeader(_(u'Parameter given twice: %r'),
                                    key.decode('ISO8859-1'))
            count.add(key)
            if '*' in key:
                if key.endswith('*') and not quoted:
                    charset, language, value_ = decode_rfc2231(
                        value.encode('ISO8859-1'))
                    if not charset:
                        yield key, value
                        continue
                    encoding = sanitize_encoding(charset)
                    if encoding is None:
                        raise InvalidHeader(_(u'Unknown encoding: %r'),
                                            charset)
                    try:
                        key, value = key[:-1], Percent.unquote(value_).decode(
                            encoding)
                    except UnicodeDecodeError as exc:
                        raise InvalidHeader(_(u'%s') % (exc, ))
                key_, asterisk, num = key.rpartition('*')
                if asterisk:
                    try:
                        if num != '0' and num.startswith('0'):
                            raise ValueError
                        num = int(num)
                    except ValueError:
                        yield key, value
                        continue
                    continuations.setdefault(key_, {})[num] = value
                    continue
            yield key, value

        for key, lines in iteritems(continuations):
            value = b''
            for i in xrange(len(lines)):
                try:
                    value += lines.pop(i)
                except KeyError:
                    break
            if not key:
                raise InvalidHeader(_(u'...'))
            if value:
                yield key, value
            for k, v in iteritems(lines):
                yield '%s*%d' % (key, k), v
Example #2
0
	def compose(self):
		def _encode(v):
			try:
				return v.encode('ISO8859-1')
			except UnicodeEncodeError:
				return v.encode('ISO8859-1', 'replace')  # FIXME: if value contains UTF-8 chars encode them in MIME; =?UTF-8?B?…?= (RFC 2047); seealso quopri
		return b'%s\r\n' % b''.join(b'%s: %s\r\n' % (k, _encode(v)) for k, v in iteritems(self))
Example #3
0
	def from_environ(self, environ=None):
		environ = os.environ if environ is None else environ
		environ = environ.copy()

		for name, value in iteritems(environ):
			if name.startswith('HTTP_'):
				self.request.headers[name[5:].replace('_', '-')] = value

		self.request.body = environ['REQUEST_METHOD']
		self.request.uri.path = environ['PATH_INFO']
		self.request.uri.query_string = environ['QUERY_STRING']
		self.request.headers['Content-Type'] = environ.get('CONTENT_TYPE')
		self.request.headers['Content-Length'] = environ.get('Content-Length')
		self.server_name = environ.get('SERVER_NAME')
		self.server_port = environ.get('SERVER_PORT')
		self.request.protocol = environ['SERVER_PROTOCOL']
		self.wsgi_version = environ['wsgi.version']
		self.request.uri.scheme = environ['wsgi.url_scheme']
		self.request.body = environ['wsgi.input']
		self.errors = environ['wsgi.errors']
		self.multithread = environ['wsgi.multithread']
		self.multiprocess = environ['wsgi.multiprocess']
		self.run_once = environ['wsgi.run_once']

		self.environ = environ
Example #4
0
	def get_environ(self):
		environ = {}
		environ.update(dict(self.environ.items()))
		environ.update(dict([
			('HTTP_%s' % name.upper().replace('-', '_'), value)
			for name, value in iteritems(self.request.headers)
			if name.lower() not in ('content-type', 'content-length')
		]))
		environ.update({
			'REQUEST_METHOD': bytes(self.request.method),
			'SCRIPT_NAME': b'',
			'REQUEST_URI': self.request.uri.path.encode('ISO8859-1'),
			'PATH_INFO': self.path_info or self.request.uri.path.encode('ISO8859-1'),
			'QUERY_STRING': self.request.uri.query_string.encode('ISO8859-1'),
			'CONTENT_TYPE': self.request.headers.get('Content-Type', b''),
			'CONTENT_LENGTH': self.request.headers.get('Content-Length', b''),
			'SERVER_NAME': self.server_name,
			'SERVER_PORT': self.server_port,
			'SERVER_PROTOCOL': bytes(self.request.protocol),
			'wsgi.version': self.wsgi_version,
			'wsgi.url_scheme': self.request.uri.scheme.encode('ascii'),
			'wsgi.input': self.request.body,
			'wsgi.errors': self.errors,
			'wsgi.multithread': self.multithread,
			'wsgi.multiprocess': self.multiprocess,
			'wsgi.run_once': self.run_once,
		})
		return environ
Example #5
0
	def _rfc2231_and_continuation_params(cls, params):  # TODO: complexity
		count = set()
		continuations = dict()
		for key, value, quoted in params:
			if key in count:
				raise InvalidHeader(_(u'Parameter given twice: %r'), key.decode('ISO8859-1'))
			count.add(key)
			if '*' in key:
				if key.endswith('*') and not quoted:
					charset, language, value_ = decode_rfc2231(value.encode('ISO8859-1'))
					if not charset:
						yield key, value
						continue
					encoding = sanitize_encoding(charset)
					if encoding is None:
						raise InvalidHeader(_(u'Unknown encoding: %r'), charset)
					try:
						key, value = key[:-1], Percent.unquote(value_).decode(encoding)
					except UnicodeDecodeError as exc:
						raise InvalidHeader(_(u'%s') % (exc,))
				key_, asterisk, num = key.rpartition('*')
				if asterisk:
					try:
						if num != '0' and num.startswith('0'):
							raise ValueError
						num = int(num)
					except ValueError:
						yield key, value
						continue
					continuations.setdefault(key_, {})[num] = value
					continue
			yield key, value

		for key, lines in iteritems(continuations):
			value = b''
			for i in xrange(len(lines)):
				try:
					value += lines.pop(i)
				except KeyError:
					break
			if not key:
				raise InvalidHeader(_(u'...'))
			if value:
				yield key, value
			for k, v in iteritems(lines):
				yield '%s*%d' % (key, k), v
Example #6
0
	def __encoded_items(self):
		for key, values in iteritems(self):
			Element = HEADER.get(key, HeaderElement)
			if Element is not HeaderElement:
				key = Element.__name__
			if Element.list_element:
				for value in Element.split(values):
					yield key, Element.encode(value)
			else:
				yield key, Element.encode(values)
Example #7
0
	def __encoded_items(self):
		for key, values in iteritems(self):
			Element = HEADER.get(key, HeaderElement)
			if Element is not HeaderElement:
				key = Element.__name__
			if Element.list_element:
				for value in Element.split(values):
					yield key, Element.encode(value)
			else:
				yield key, Element.encode(values)
Example #8
0
	def _rfc2231_and_continuation_params(cls, params):
		count = set()
		continuations = dict()
		for key, (value, quoted) in params:
			if key in count:
				raise InvalidHeader('Parameter given twice: %r' % (key.decode('ISO8859-1'),))
			count.add(key)
			if '*' in key:
				if key.endswith('*') and not quoted:
					encoding, language, value_ = decode_rfc2231(value.encode('ISO8859-1'))
					if not encoding:
						yield key, value
						continue
					key, value = key[:-1], Percent.decode(value_, encoding)
				key_, asterisk, num = key.rpartition('*')
				if asterisk:
					try:
						if num != '0' and num.startswith('0'):
							raise ValueError
						num = int(num)
					except ValueError:
						yield key, value
						continue
					continuations.setdefault(key_, {})[num] = value
					continue
			yield key, value

		for key, lines in iteritems(continuations):
			value = b''
			for i in xrange(len(lines)):
				try:
					value += lines.pop(i)
				except KeyError:
					break
			if not key:
				raise InvalidHeader('...')
			if value:
				yield key, value
			for k, v in iteritems(lines):
				yield '%s*%d' % (key, k), v
Example #9
0
	def append(self, _name, _value, **params):
		if params:
			parts = [_value or b'']
			for k, v in iteritems(params):
				k = k.replace('_', '-')  # TODO: find out why this is done
				if v is None:
					parts.append(k)
				else:
					parts.append(Headers._formatparam(k, v))
			_value = "; ".join(parts)

		if not _name in self or not self[_name]:
			self[_name] = _value
		else:
			self[_name] = ", ".join([self[_name], _value])
Example #10
0
	def append(self, _name, _value, **params):
		if params:
			Element = HEADER.get(_name, HeaderElement)
			parts = [_value or u'']
			for k, v in iteritems(params):
				if v is None:
					parts.append(k)
				else:
					parts.append(Element.formatparam(k, v))
			_value = u'; '.join(parts)

		if _name not in self or not self[_name]:
			self[_name] = _value
		else:
			Element = HEADER.get(_name, HeaderElement)
			self[_name] = Element.join([self[_name], _value])
Example #11
0
	def append(self, _name, _value, **params):
		if params:
			Element = HEADER.get(_name, HeaderElement)
			parts = [_value or b'']
			for k, v in iteritems(params):
				k = k.replace('_', '-')  # TODO: find out why this is done
				if v is None:
					parts.append(k)
				else:
					parts.append(Element.formatparam(k, v))
			_value = "; ".join(parts)

		if _name not in self or not self[_name]:
			self[_name] = _value
		else:
			Element = HEADER.get(_name, HeaderElement)
			self[_name] = Element.join([self[_name], _value])
Example #12
0
	def append(self, _name, _value, **params):
		if params:
			Element = HEADER.get(_name, HeaderElement)
			parts = [_value or b'']
			for k, v in iteritems(params):
				k = k.replace('_', '-')  # TODO: find out why this is done
				if v is None:
					parts.append(k)
				else:
					parts.append(Element.formatparam(k, v))
			_value = "; ".join(parts)

		if _name not in self or not self[_name]:
			self[_name] = _value
		else:
			Element = HEADER.get(_name, HeaderElement)
			self[_name] = Element.join([self[_name], _value])
Example #13
0
	def _get_environ(self):
		environ = {}
		environ.update(dict(self.environ.items()))
		environ.update(dict([('HTTP_%s' % name.upper().replace('-', '_'), value)
			for name, value in iteritems(self.request.headers)]))
		environ.update({
			'REQUEST_METHOD': bytes(self.request.method),
			'SCRIPT_NAME': b'',
			'PATH_INFO': bytes(self.request.uri.path),
			'QUERY_STRING': bytes(self.request.uri.query_string),
			'CONTENT_TYPE': self.request.headers.get('Content-Type'),
			'CONTENT_LENGTH': self.request.headers.get('Content-Length'),
			'SERVER_NAME': self.server_name,
			'SERVER_PORT': self.server_port,
			'SERVER_PROTOCOL': bytes(self.request.protocol),
			'wsgi.version': self.wsgi_version,
			'wsgi.url_scheme': bytes(self.request.uri.scheme),
			'wsgi.input': self.request.body,
			'wsgi.errors': self.errors,
			'wsgi.multithread': self.multithread,
			'wsgi.multiprocess': self.multiprocess,
			'wsgi.run_once': self.run_once,
		})
		return environ
Example #14
0
 def compose(self):
     params = [
         b'; %s' % self.formatparam(k, v) for k, v in iteritems(self.params)
     ]
     return b'%s%s' % (self.value, ''.join(params))
Example #15
0
	def compose(self):
		params = [b'; %s' % self.formatparam(k, v) for k, v in iteritems(self.params)]
		return b'%s%s' % (self.value, ''.join(params))
Example #16
0
	def compose(self):
		# TODO: if value contains UTF-8 chars encode them in MIME
		return b'%s\r\n' % b''.join(b'%s: %s\r\n' % (k, v.encode('ISO8859-1', 'replace')) for k, v in iteritems(self))