#!/usr/bin/python

################################################################################

#

# SOAP.py 0.9.7 - Cayce Ullman    (cayce@actzero.com)

#                 Brian Matthews  (blm@actzero.com)

#

# INCLUDED:

# - General SOAP Parser based on sax.xml (requires Python 2.0)

# - General SOAP Builder

# - SOAP Proxy for RPC client code

# - SOAP Server framework for RPC server code

#

# FEATURES:

# - Handles all of the types in the BDG

# - Handles faults

# - Allows namespace specification

# - Allows SOAPAction specification

# - Homogeneous typed arrays

# - Supports multiple schemas

# - Header support (mustUnderstand and actor)

# - XML attribute support

# - Multi-referencing support (Parser/Builder)

# - Understands SOAP-ENC:root attribute

# - Good interop, passes all client tests for Frontier, SOAP::LITE, SOAPRMI

# - Encodings

# - SSL clients (with OpenSSL configured in to Python)

# - SSL servers (with OpenSSL configured in to Python and M2Crypto installed)

#

# TODO:

# - Timeout on method calls - MCU

# - Arrays (sparse, multidimensional and partial) - BLM

# - Clean up data types - BLM

# - Type coercion system (Builder) - MCU

# - Early WSDL Support - MCU

# - Attachments - BLM

# - setup.py - MCU

# - mod_python example - MCU

# - medusa example - MCU

# - Documentation - JAG

# - Look at performance

#

################################################################################

#

# Copyright (c) 2001, Cayce Ullman.

# Copyright (c) 2001, Brian Matthews.

#

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

# Redistributions of source code must retain the above copyright notice, this

# list of conditions and the following disclaimer.

#

# Redistributions in binary form must reproduce the above copyright notice,

# this list of conditions and the following disclaimer in the documentation

# and/or other materials provided with the distribution.

#

# Neither the name of actzero, inc. nor the names of its contributors may

# be used to endorse or promote products derived from this software without

# specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR

# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#

################################################################################

#

# Additional changes:

# 0.9.7.3 - 4/18/2002 - Mark Pilgrim (f8dy@diveintomark.org)

#   added dump_dict as alias for dump_dictionary for Python 2.2 compatibility

# 0.9.7.2 - 4/12/2002 - Mark Pilgrim (f8dy@diveintomark.org)

#   fixed logic to unmarshal the value of "null" attributes ("true" or "1"

#   means true, others false)

# 0.9.7.1 - 4/11/2002 - Mark Pilgrim (f8dy@diveintomark.org)

#   added "dump_str" as alias for "dump_string" for Python 2.2 compatibility

#   Between 2.1 and 2.2, type("").__name__ changed from "string" to "str"

################################################################################

import xml.sax

import UserList

import base64

import cgi

import urllib

import exceptions

import copy

import re

import socket

import string

import sys

import time

import SocketServer

from types import *

try: from M2Crypto import SSL

except: pass

ident = '$Id: SOAP.py,v 1.1.1.1 2005/09/29 21:38:51 mikem Exp $'

__version__ = "0.9.7.3"

# Platform hackery

# Check float support

try:

    float("NaN")

    float("INF")

    float("-INF")

    good_float = 1

except:

    good_float = 0

################################################################################

# Exceptions

################################################################################

class Error(exceptions.Exception):

    def __init__(self, msg):

        self.msg = msg

    def __str__(self):

        return "<Error : %s>" % self.msg

    __repr__ = __str__

class RecursionError(Error):

    pass

class UnknownTypeError(Error):

    pass

class HTTPError(Error):

    # indicates an HTTP protocol error

    def __init__(self, code, msg):

        self.code = code

        self.msg  = msg

    def __str__(self):

        return "<HTTPError %s %s>" % (self.code, self.msg)

    __repr__ = __str__

##############################################################################

# Namespace Class

################################################################################

def invertDict(dict):

    d = {}

    for k, v in dict.items():

        d[v] = k

    return d

class NS:

    XML  = "http://www.w3.org/XML/1998/namespace"

    ENV  = "http://schemas.xmlsoap.org/soap/envelope/"

    ENC  = "http://schemas.xmlsoap.org/soap/encoding/"

    XSD  = "http://www.w3.org/1999/XMLSchema"

    XSD2 = "http://www.w3.org/2000/10/XMLSchema"

    XSD3 = "http://www.w3.org/2001/XMLSchema"

    XSD_L = [XSD, XSD2, XSD3]

    EXSD_L= [ENC, XSD, XSD2, XSD3]

    XSI   = "http://www.w3.org/1999/XMLSchema-instance"

    XSI2  = "http://www.w3.org/2000/10/XMLSchema-instance"

    XSI3  = "http://www.w3.org/2001/XMLSchema-instance"

    XSI_L = [XSI, XSI2, XSI3]

    URN   = "http://soapinterop.org/xsd"

    # For generated messages

    XML_T = "xml"

    ENV_T = "SOAP-ENV"

    ENC_T = "SOAP-ENC"

    XSD_T = "xsd"

    XSD2_T= "xsd2"

    XSD3_T= "xsd3"

    XSI_T = "xsi"

    XSI2_T= "xsi2"

    XSI3_T= "xsi3"

    URN_T = "urn"

    NSMAP       = {ENV_T: ENV, ENC_T: ENC, XSD_T: XSD, XSD2_T: XSD2,

                    XSD3_T: XSD3, XSI_T: XSI, XSI2_T: XSI2, XSI3_T: XSI3,

                    URN_T: URN}

    NSMAP_R     = invertDict(NSMAP)

    STMAP       = {'1999': (XSD_T, XSI_T), '2000': (XSD2_T, XSI2_T),

                    '2001': (XSD3_T, XSI3_T)}

    STMAP_R     = invertDict(STMAP)

    def __init__(self):

        raise Error, "Don't instantiate this"

################################################################################

# Configuration class

################################################################################

class SOAPConfig:

    __readonly = ('SSLserver', 'SSLclient')

    def __init__(self, config = None, **kw):

        d = self.__dict__

        if config:

            if not isinstance(config, SOAPConfig):

                raise AttributeError, \

                    "initializer must be SOAPConfig instance"

            s = config.__dict__

            for k, v in s.items():

                if k[0] != '_':

                    d[k] = v

        else:

            # Setting debug also sets returnFaultInfo, dumpFaultInfo,

            # dumpHeadersIn, dumpHeadersOut, dumpSOAPIn, and dumpSOAPOut

            self.debug = 0

            # Setting namespaceStyle sets typesNamespace, typesNamespaceURI,

            # schemaNamespace, and schemaNamespaceURI

            self.namespaceStyle = '1999'

            self.strictNamespaces = 0

            self.typed = 1

            self.buildWithNamespacePrefix = 1

            self.returnAllAttrs = 0

            try: SSL; d['SSLserver'] = 1

            except: d['SSLserver'] = 0

            try: socket.ssl; d['SSLclient'] = 1

            except: d['SSLclient'] = 0

        for k, v in kw.items():

            if k[0] != '_':

                setattr(self, k, v)

    def __setattr__(self, name, value):

        if name in self.__readonly:

            raise AttributeError, "readonly configuration setting"

        d = self.__dict__

        if name in ('typesNamespace', 'typesNamespaceURI',

            'schemaNamespace', 'schemaNamespaceURI'):

            if name[-3:] == 'URI':

                base, uri = name[:-3], 1

            else:

                base, uri = name, 0

            if type(value) == StringType:

                if NS.NSMAP.has_key(value):

                    n = (value, NS.NSMAP[value])

                elif NS.NSMAP_R.has_key(value):

                    n = (NS.NSMAP_R[value], value)

                else:

                    raise AttributeError, "unknown namespace"

            elif type(value) in (ListType, TupleType):

                if uri:

                    n = (value[1], value[0])

                else:

                    n = (value[0], value[1])

            else:

                raise AttributeError, "unknown namespace type"

            d[base], d[base + 'URI'] = n

            try:

                d['namespaceStyle'] = \

                    NS.STMAP_R[(d['typesNamespace'], d['schemaNamespace'])]

            except:

                d['namespaceStyle'] = ''

        elif name == 'namespaceStyle':

            value = str(value)

            if not NS.STMAP.has_key(value):

                raise AttributeError, "unknown namespace style"

            d[name] = value

            n = d['typesNamespace'] = NS.STMAP[value][0]

            d['typesNamespaceURI'] = NS.NSMAP[n]

            n = d['schemaNamespace'] = NS.STMAP[value][1]

            d['schemaNamespaceURI'] = NS.NSMAP[n]

        elif name == 'debug':

            d[name]                     = \

                d['returnFaultInfo']    = \

                d['dumpFaultInfo']      = \

                d['dumpHeadersIn']      = \

                d['dumpHeadersOut']     = \

                d['dumpSOAPIn']         = \

                d['dumpSOAPOut']        = value

        else:

            d[name] = value

Config = SOAPConfig()

################################################################################

# Types and Wrappers

################################################################################

class anyType:

    _validURIs = (NS.XSD, NS.XSD2, NS.XSD3, NS.ENC)

    def __init__(self, data = None, name = None, typed = 1, attrs = None):

        if self.__class__ == anyType:

            raise Error, "anyType can't be instantiated directly"

        if type(name) in (ListType, TupleType):

            self._ns, self._name = name

        else:

            self._ns, self._name = self._validURIs[0], name

        self._typed = typed

        self._attrs = {}

        self._cache = None

        self._type = self._typeName()

        self._data = self._checkValueSpace(data)

        if attrs != None:

            self._setAttrs(attrs)

    def __str__(self):

        if self._name:

            return "<%s %s at %d>" % (self.__class__, self._name, id(self))

        return "<%s at %d>" % (self.__class__, id(self))

    __repr__ = __str__

    def _checkValueSpace(self, data):

        return data

    def _marshalData(self):

        return str(self._data)

    def _marshalAttrs(self, ns_map, builder):

        a = ''

        for attr, value in self._attrs.items():

            ns, n = builder.genns(ns_map, attr[0])

            a += n + ' %s%s="%s"' % \

                (ns, attr[1], cgi.escape(str(value), 1))

        return a

    def _fixAttr(self, attr):

        if type(attr) in (StringType, UnicodeType):

            attr = (None, attr)

        elif type(attr) == ListType:

            attr = tuple(attr)

        elif type(attr) != TupleType:

            raise AttributeError, "invalid attribute type"

        if len(attr) != 2:

            raise AttributeError, "invalid attribute length"

        if type(attr[0]) not in (NoneType, StringType, UnicodeType):

            raise AttributeError, "invalid attribute namespace URI type"

        return attr

    def _getAttr(self, attr):

        attr = self._fixAttr(attr)

        try:

            return self._attrs[attr]

        except:

            return None

    def _setAttr(self, attr, value):

        attr = self._fixAttr(attr)

        self._attrs[attr] = str(value)

    def _setAttrs(self, attrs):

        if type(attrs) in (ListType, TupleType):

            for i in range(0, len(attrs), 2):

                self._setAttr(attrs[i], attrs[i + 1])

            return

        if type(attrs) == DictType:

            d = attrs

        elif isinstance(attrs, anyType):

            d = attrs._attrs

        else:

            raise AttributeError, "invalid attribute type"

        for attr, value in d.items():

            self._setAttr(attr, value)

    def _setMustUnderstand(self, val):

        self._setAttr((NS.ENV, "mustUnderstand"), val)

    def _getMustUnderstand(self):

        return self._getAttr((NS.ENV, "mustUnderstand"))

    def _setActor(self, val):

        self._setAttr((NS.ENV, "actor"), val)

    def _getActor(self):

        return self._getAttr((NS.ENV, "actor"))

    def _typeName(self):

        return self.__class__.__name__[:-4]

    def _validNamespaceURI(self, URI, strict):

        if not self._typed:

            return None

        if URI in self._validURIs:

            return URI

        if not strict:

            return self._ns

        raise AttributeError, \

            "not a valid namespace for type %s" % self._type