3

�O[/3�@s�dd
lZddl
mZ
ddl
mZ
ddl
mZ
ddlmZ
ej	rPddl
mZmZ
nddl
mZmZ
ejd�
Zejd�
ZGd	d
�d
ej�ZGdd�de�Zd
S)
�N)
�names)
�NameType)
�named_tuples)
�_utils)�MutableMapping�IterableZrfc6680Zrfc6680_comp_oidcs�eZ
dZd
ZdZd)�f
dd�	Zd*dd�
Zd	d
�Zdd�Zd
d�Z	dd�Z
edd��
Zdd�Z
dd�Zdd�Zd+dd�
Zdd�Zdd�Zdd �Zd!d"�Zed#d$��
Zed%d&��
Zed'd(��
Z�ZS),�Namea�A GSSAPI Name

    This class represents a GSSAPI name which may be used with and/or returned
    by other GSSAPI methods.

    It inherits from the low-level GSSAPI :class:`~gssapi.raw.names.Name`
    class, and thus may used with both low-level and high-level API methods.

    This class may be pickled and unpickled, as well as copied.

    The :func:`str` and :func:`bytes` methods may be used to retrieve the
    text of the name.

    Note:
        Name strings will be automatically converted to and from unicode
        strings as appropriate.  If a method is listed as returning a
        :class:`str` object, it will return a unicode string.

        The encoding used will be python-gssapi's current encoding, which
        defaults to UTF-8.
    �	_attr_objNFcs�|dk	r||rltdkrt
d
�
�
tdk	r\tj|tj�}tj|dd�}|jtjkrjtj|tj	�}qztj|tj	�}q�tj|tj	�}n8t
|
tj�r�|
}n&t
|
tj
�r�|
jtj��
}
tj|
|�}tt|�j||�S)NzSYour GSSAPI implementation does not support RFC 6680 (the GSSAPI naming extensions)T)
�	name_type)�
rname_rfc6680�NotImplementedError�rname_rfc6680_comp_oid�rnameZimport_namerZcomposite_export�display_namer
�export�
isinstancer�six�	text_type�encoder�
_get_encoding�super�__new__)�cls�baser
�token�	compositeZ	base_nameZ
displ_name)
�	__class__��/usr/lib64/python3.6/names.pyr+s&










zName.__new__cCstd
k	rt
|�
|_nd
|_d
S)ag
        The constructor can be used to "import" a name from a human readable
        representation, or from a token, and can also be used to convert a
        low-level :class:`gssapi.raw.names.Name` object into a high-level
        object.

        If a :class:`~gssapi.raw.names.Name` object from the low-level API
        is passed as the `base` argument, it will be converted into a
        high-level object.

        If the `token` argument is used, the name will be imported using
        the token.  If the token was exported as a composite token,
        pass `composite=True`.

        Otherwise, a new name will be created, using the `base` argument as
        the human-readable string and the `name_type` argument to denote the
        name type.

        Raises:
            BadNameTypeError
            BadNameError
            BadMechanismError
        N)r�_NameAttributeMappingr	)�selfrr
rrrrr�__init__Os
z
Name.__init__c

Cs*tt
tj�rt|�
jtj��
S|j�SdS)
N)	�
issubclass�strrr�bytes�decoderr�	__bytes__)
r rrr�__str__ms
zName.__str__c

Cs|j�j
tj��
S)
N)r&r%rr)
r rrr�__unicode__uszName.__unicode__c

Cstj
|d
d�jS)NF)
r
)rr�name)
r rrrr&yszName.__bytes__cCs&td
krt
d�
�
tj||
�jtj��
S)aU
        Display this name as the given name type.

        This method attempts to display the current :class:`Name`
        using the syntax of the given :class:`NameType`, if possible.

        Warning:

            In MIT krb5 versions below 1.13.3, this method can segfault if
            the name was not *originally* created with a `name_type` that was
            not ``None`` (even in cases when a ``name_type``
            is later "added", such as via :meth:`canonicalize`).
            **Do not use this method unless you are sure the above
            conditions can never happen in your code.**

        Warning:

            In addition to the above warning, current versions of MIT krb5 do
            not actually fully implement this method, and it may return
            incorrect results in the case of canonicalized names.

        :requires-ext:`rfc6680`

        Args:
            name_type (OID): the :class:`NameType` to use to display the given
                name

        Returns:
            str: the displayed name

        Raises:
            OperationUnavailableError
        NzSYour GSSAPI implementation does not support RFC 6680 (the GSSAPI naming extensions))rrZdisplay_name_extr%rr)r r
rrr�
display_as}s#

zName.display_asc

Cstj
|d
d�jS)z"The :class:`NameType` of this nameT)
r
)rrr
)
r rrrr
�szName.name_typecCs t|
t
j�stSt
j||
�SdS)
N)rrr�NotImplementedZcompare_name)r �otherrrr�__eq__�s
zName.__eq__cCs|j|
�
S)
N)
r-)r r,rrr�__ne__�s
zName.__ne__c
Cs tj
|d
d�}
dj|
j|
jd�S)NT)
r
zName({name}, {name_type}))r)r
)rr�formatr)r
)r Zdisp_resrrr�__repr__�s


z
Name.__repr__cCs,|
rtd
krt
d�
�
tj|�
Stj|�
Sd
S)a�
Export this name as a token.

        This method exports the name into a byte string which can then be
        imported by using the `token` argument of the constructor.

        Args:
            composite (bool): whether or not use to a composite token --
                :requires-ext:`rfc6680`

        Returns:
            bytes: the exported name in token form

        Raises:
            MechanismNameRequiredError
            BadNameTypeError
            BadNameError
        NzSYour GSSAPI implementation does not support RFC 6680 (the GSSAPI naming extensions))rrZexport_name_compositerZexport_name)r rrrrr�s



zName.exportcCst|�
t
j||
��
S)
a�
Canonicalize a name with respect to a mechanism.

        This method returns a new :class:`Name` that is canonicalized according
        to the given mechanism.

        Args:
            mech (OID): the :class:`MechType` to use

        Returns:
            Name: the canonicalized name

        Raises:
            BadMechanismError
            BadNameTypeError
            BadNameError
        )�typerZcanonicalize_name)r �mechrrr�canonicalize�szName.canonicalizec

Cst|�
t
j|�
�
S)
N)r1r�duplicate_name)
r rrr�__copy__�s
z
Name.__copy__cCst|�
t
j|�
�
S)
N)r1rr4)r �memorrr�__deepcopy__�s
zName.__deepcopy__c
KsFtd
krt
d�
�
|
sd}nd}|
jd|�}|
jd|�}tj|||d�S)a�Inspect this name for information.

        This method inspects the name for information.

        If no keyword arguments are passed, all available information
        is returned.  Otherwise, only the keyword arguments that
        are passed and set to `True` are returned.

        Args:
            mech_name (bool): get whether this is a mechanism name,
                and, if so, the associated mechanism
            attrs (bool): get the attributes names for this name

        Returns:
            InquireNameResult: the results of the inquiry, with unused
                fields set to None

        Raises:
            GSSError
        NzSYour GSSAPI implementation does not support RFC 6680 (the GSSAPI naming extensions)TF�attrs�	mech_name)r9r8)rr�getZinquire_name)r �kwargsZdefault_valr8r9rrr�_inquire�s



z
Name._inquirec

Cs|jd
d�
j
S)zWWhether or not this name is a mechanism name
        (:requires-ext:`rfc6680`)
        T)
r9)r<�is_mech_name)
r rrrr=
szName.is_mech_namec

Cs|jd
d�
j
S)zJThe mechanism associated with this name (:requires-ext:`rfc6680`)
        T)
r9)r<r2)
r rrrr2 
sz	Name.mechc

Cs|jd
krt
d�
�
|jS)a�The attributes of this name (:requires-ext:`rfc6680`)

        The attributes are presenting in the form of a
        :class:`~collections.MutableMapping` (a dict-like object).

        Retrieved values will always be in the form of :class:`frozensets`.

        When assigning values, if iterables are used, they be considered to be
        the set of values for the given attribute.  If a non-iterable is used,
        it will be considered a single value, and automatically wrapped in an
        iterable.

        Note:
            String types (includes :class:`bytes`) are not considered to
            be iterables in this case.
        NzSYour GSSAPI implementation does not support RFC 6680 (the GSSAPI naming extensions))r	r)
r rrr�
attributes&
s

zName.attributes)NNNF)NNNF)
F)�__name__�
__module__�__qualname__�__doc__�	__slots__rr!r'r(r&r*�propertyr
r-r.r0rr3r5r7r<r=r2r>�
__classcell__rr)
rrrs*
#
*
&rc@s@eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)rz6Provides dict-like access to RFC 6680 Name attributes.cCs
|
|_dS)
N)
�_name)r r)rrrr!C
s
z_NameAttributeMapping.__init__cCsHt|
t
j�r|
jtj��
}
tj|j|
�}t	j
t|j�
t|j
�
|j|j�S)
N)rrrrrrrZget_name_attributerF�tuples�GetNameAttributeResult�	frozenset�valuesZdisplay_valuesZ
authenticated�complete)r �key�resrrr�__getitem__F
s





z!_NameAttributeMapping.__getitem__cCs�t|
t
j�r|
jtj��
}
tj|j|
�
t|t	j
�rB|j}|j}n,t|t
�rjt|�
d
krj|d}|d}nd}t|t
jtf�s�t|t�r�|g
}tj|j|
||d�
dS)N��
r
F)
rK)rrrrrrr�delete_name_attributerFrGrHrKrJ�tuple�lenZstring_typesr$rZset_name_attribute)r rL�valuerKrrr�__setitem__P
s









z!_NameAttributeMapping.__setitem__cCs,t|
t
j�r|
jtj��
}
tj|j|
�
dS)
N)	rrrrrrrrQrF)r rLrrr�__delitem__h
s

z!_NameAttributeMapping.__delitem__c

Cst|j
jd
d�
j�
S)NT)
r8)�iterrFr<r8)
r rrr�__iter__n
s
z_NameAttributeMapping.__iter__c

Cst|j
jd
d�
j�
S)NT)
r8)rSrFr<r8)
r rrr�__len__q
s
z_NameAttributeMapping.__len__N)
r?r@rArBr!rNrUrVrXrYrrrrr@
s

r)rZ
gssapi.rawrrrrrGZgssapirZPY2�collectionsrr�collections.abcZimport_gssapi_extensionrr
rrrrrr�<module>
s






0