xml package

import "41.neocities.org/playReady/xml"

Index ¶

• type AcquireLicense
• type Algorithm
• type Body
• type Bytes
  • func (b Bytes) MarshalText() ([]byte, error)
  • func (b *Bytes) UnmarshalText(data []byte) error
• type CertificateChains
• type Challenge
• type CipherData
• type ContentHeader
• type Data
  • func (d *Data) Marshal() ([]byte, error)
• type EncryptedData
• type EncryptedKey
• type EncryptedKeyInfo
• type Envelope
  • func (e *Envelope) Marshal() ([]byte, error)
• type EnvelopeResponse
  • func (e *EnvelopeResponse) Unmarshal(data []byte) error
• type Feature
• type Features
• type InnerChallenge
• type KeyInfo
• type La
  • func (l *La) Marshal() ([]byte, error)
• type ProtectInfo
• type Reference
• type Signature
• type SignedInfo
  • func (s *SignedInfo) Marshal() ([]byte, error)
• type WrmHeader
• type WrmHeaderData

type AcquireLicense ¶

type AcquireLicense struct {
	XmlNs string `xml:"xmlns,attr"`

	Challenge Challenge `xml:"challenge"`
}

type Algorithm ¶

type Algorithm struct {
	Algorithm string `xml:"Algorithm,attr"`
}

type Body ¶

type Body struct {
	AcquireLicense *AcquireLicense

	AcquireLicenseResponse *struct {
		AcquireLicenseResult struct {
			Response struct {
				LicenseResponse struct {
					Licenses struct {
						License Bytes
					}
				}
			}
		}
	}

	Fault *struct {
		Fault string `xml:"faultstring"`
	}
}

type Bytes ¶

type Bytes []byte

func (Bytes) MarshalText ¶

func (b Bytes) MarshalText() ([]byte, error)

func (*Bytes) UnmarshalText ¶

func (b *Bytes) UnmarshalText(data []byte) error

type CertificateChains ¶

type CertificateChains struct {
	CertificateChain Bytes
}

type Challenge ¶

type Challenge struct {
	Challenge InnerChallenge
}

type CipherData ¶

type CipherData struct {
	CipherValue Bytes
}

type ContentHeader ¶

type ContentHeader struct {
	WrmHeader WrmHeader `xml:"WRMHEADER"`
}

type Data ¶

type Data struct {
	CertificateChains CertificateChains

	Features Features
}

func (*Data) Marshal ¶

func (d *Data) Marshal() ([]byte, error)

type EncryptedData ¶

type EncryptedData struct {
	XmlNs string `xml:"xmlns,attr"`

	Type string `xml:"Type,attr"`

	EncryptionMethod Algorithm

	KeyInfo KeyInfo

	CipherData CipherData
}

type EncryptedKey ¶

type EncryptedKey struct {
	XmlNs string `xml:"xmlns,attr"`

	EncryptionMethod Algorithm

	CipherData CipherData

	KeyInfo EncryptedKeyInfo
}

type EncryptedKeyInfo ¶

type EncryptedKeyInfo struct {
	XmlNs string `xml:"xmlns,attr"`

	KeyName string
}

type Envelope ¶

type Envelope struct {
	XMLName xml.Name `xml:"soap:Envelope"`

	Soap string `xml:"xmlns:soap,attr"`

	Body Body `xml:"soap:Body"`
}

func (*Envelope) Marshal ¶

func (e *Envelope) Marshal() ([]byte, error)

type EnvelopeResponse ¶

type EnvelopeResponse struct {
	Body Body
}

func (*EnvelopeResponse) Unmarshal ¶

func (e *EnvelopeResponse) Unmarshal(data []byte) error

type Feature ¶

type Feature struct {
	Name string `xml:",attr"`
}

type Features ¶

type Features struct {
	Feature Feature
}

type InnerChallenge ¶

type InnerChallenge struct {
	XmlNs string `xml:"xmlns,attr"`

	La *La

	Signature Signature
}

type KeyInfo ¶

type KeyInfo struct {
	XmlNs string `xml:"xmlns,attr"`

	EncryptedKey EncryptedKey
}

type La ¶

type La struct {
	XMLName xml.Name `xml:"LA"`

	XmlNs string `xml:"xmlns,attr"`

	Id string `xml:"Id,attr"`

	Version string

	ContentHeader ContentHeader

	EncryptedData EncryptedData
}

func (*La) Marshal ¶

func (l *La) Marshal() ([]byte, error)

type ProtectInfo ¶

type ProtectInfo struct {
	KeyLen string `xml:"KEYLEN"`

	AlgId string `xml:"ALGID"`
}

type Reference ¶

type Reference struct {
	Uri string `xml:"URI,attr"`

	DigestValue Bytes
}

type Signature ¶

type Signature struct {
	SignedInfo SignedInfo

	SignatureValue Bytes
}

type SignedInfo ¶

type SignedInfo struct {
	XmlNs string `xml:"xmlns,attr"`

	Reference Reference
}

func (*SignedInfo) Marshal ¶

func (s *SignedInfo) Marshal() ([]byte, error)

type WrmHeader ¶

type WrmHeader struct {
	XmlNs string `xml:"xmlns,attr"`

	Version string `xml:"version,attr"`

	Data WrmHeaderData `xml:"DATA"`
}

type WrmHeaderData ¶

type WrmHeaderData struct {
	ProtectInfo ProtectInfo `xml:"PROTECTINFO"`

	Kid Bytes `xml:"KID"`
}

Source Files ¶

xml.go