xml

Documentation

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

Types

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"`
}