add vendoring with go dep

vendor/github.com/vmware/govmomi/vim25/client.go

@@ -0,0 +1,123 @@
+/*
+Copyright (c) 2015-2016 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package vim25
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Client is a tiny wrapper around the vim25/soap Client that stores session
+// specific state (i.e. state that only needs to be retrieved once after the
+// client has been created). This means the client can be reused after
+// serialization without performing additional requests for initialization.
+type Client struct {
+	*soap.Client
+
+	ServiceContent types.ServiceContent
+
+	// RoundTripper is a separate field such that the client's implementation of
+	// the RoundTripper interface can be wrapped by separate implementations for
+	// extra functionality (for example, reauthentication on session timeout).
+	RoundTripper soap.RoundTripper
+}
+
+// NewClient creates and returns a new client wirh the ServiceContent field
+// filled in.
+func NewClient(ctx context.Context, rt soap.RoundTripper) (*Client, error) {
+	serviceContent, err := methods.GetServiceContent(ctx, rt)
+	if err != nil {
+		return nil, err
+	}
+
+	c := Client{
+		ServiceContent: serviceContent,
+		RoundTripper:   rt,
+	}
+
+	// Set client if it happens to be a soap.Client
+	if sc, ok := rt.(*soap.Client); ok {
+		c.Client = sc
+	}
+
+	return &c, nil
+}
+
+// RoundTrip dispatches to the RoundTripper field.
+func (c *Client) RoundTrip(ctx context.Context, req, res soap.HasFault) error {
+	return c.RoundTripper.RoundTrip(ctx, req, res)
+}
+
+type marshaledClient struct {
+	SoapClient     *soap.Client
+	ServiceContent types.ServiceContent
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	m := marshaledClient{
+		SoapClient:     c.Client,
+		ServiceContent: c.ServiceContent,
+	}
+
+	return json.Marshal(m)
+}
+
+func (c *Client) UnmarshalJSON(b []byte) error {
+	var m marshaledClient
+
+	err := json.Unmarshal(b, &m)
+	if err != nil {
+		return err
+	}
+
+	*c = Client{
+		Client:         m.SoapClient,
+		ServiceContent: m.ServiceContent,
+		RoundTripper:   m.SoapClient,
+	}
+
+	return nil
+}
+
+// Valid returns whether or not the client is valid and ready for use.
+// This should be called after unmarshalling the client.
+func (c *Client) Valid() bool {
+	if c == nil {
+		return false
+	}
+
+	if c.Client == nil {
+		return false
+	}
+
+	// Use arbitrary pointer field in the service content.
+	// Doesn't matter which one, as long as it is populated by default.
+	if c.ServiceContent.SessionManager == nil {
+		return false
+	}
+
+	return true
+}
+
+// IsVC returns true if we are connected to a vCenter
+func (c *Client) IsVC() bool {
+	return c.ServiceContent.About.ApiType == "VirtualCenter"
+}

vendor/github.com/vmware/govmomi/vim25/client_test.go

@@ -0,0 +1,97 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package vim25
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"os"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Duplicated to prevent cyclic dependency...
+func testURL(t *testing.T) *url.URL {
+	s := os.Getenv("GOVMOMI_TEST_URL")
+	if s == "" {
+		t.SkipNow()
+	}
+	u, err := soap.ParseURL(s)
+	if err != nil {
+		panic(err)
+	}
+	return u
+}
+
+func sessionLogin(t *testing.T, c *Client) {
+	req := types.Login{
+		This: *c.ServiceContent.SessionManager,
+	}
+
+	u := testURL(t).User
+	req.UserName = u.Username()
+	if pw, ok := u.Password(); ok {
+		req.Password = pw
+	}
+
+	_, err := methods.Login(context.Background(), c, &req)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func sessionCheck(t *testing.T, c *Client) {
+	var mgr mo.SessionManager
+
+	err := mo.RetrieveProperties(context.Background(), c, c.ServiceContent.PropertyCollector, *c.ServiceContent.SessionManager, &mgr)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClientSerialization(t *testing.T) {
+	var c1, c2 *Client
+
+	soapClient := soap.NewClient(testURL(t), true)
+	c1, err := NewClient(context.Background(), soapClient)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Login
+	sessionLogin(t, c1)
+	sessionCheck(t, c1)
+
+	// Serialize/deserialize
+	b, err := json.Marshal(c1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c2 = &Client{}
+	err = json.Unmarshal(b, c2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check the session is still valid
+	sessionCheck(t, c2)
+}

vendor/github.com/vmware/govmomi/vim25/debug/debug.go

@@ -0,0 +1,81 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package debug
+
+import (
+	"io"
+	"os"
+	"path"
+)
+
+// Provider specified the interface types must implement to be used as a
+// debugging sink. Having multiple such sink implementations allows it to be
+// changed externally (for example when running tests).
+type Provider interface {
+	NewFile(s string) io.WriteCloser
+	Flush()
+}
+
+var currentProvider Provider = nil
+
+func SetProvider(p Provider) {
+	if currentProvider != nil {
+		currentProvider.Flush()
+	}
+	currentProvider = p
+}
+
+// Enabled returns whether debugging is enabled or not.
+func Enabled() bool {
+	return currentProvider != nil
+}
+
+// NewFile dispatches to the current provider's NewFile function.
+func NewFile(s string) io.WriteCloser {
+	return currentProvider.NewFile(s)
+}
+
+// Flush dispatches to the current provider's Flush function.
+func Flush() {
+	currentProvider.Flush()
+}
+
+// FileProvider implements a debugging provider that creates a real file for
+// every call to NewFile. It maintains a list of all files that it creates,
+// such that it can close them when its Flush function is called.
+type FileProvider struct {
+	Path string
+
+	files []*os.File
+}
+
+func (fp *FileProvider) NewFile(p string) io.WriteCloser {
+	f, err := os.Create(path.Join(fp.Path, p))
+	if err != nil {
+		panic(err)
+	}
+
+	fp.files = append(fp.files, f)
+
+	return f
+}
+
+func (fp *FileProvider) Flush() {
+	for _, f := range fp.files {
+		f.Close()
+	}
+}

vendor/github.com/vmware/govmomi/vim25/doc.go

@@ -0,0 +1,29 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Package vim25 provides a minimal client implementation to use with other
+packages in the vim25 tree. The code in this package intentionally does not
+take any dependendies outside the vim25 tree.
+
+The client implementation in this package embeds the soap.Client structure.
+Additionally, it stores the value of the session's ServiceContent object. This
+object stores references to a variety of subsystems, such as the root property
+collector, the session manager, and the search index. The client is fully
+functional after serialization and deserialization, without the need for
+additional requests for initialization.
+*/
+package vim25

vendor/github.com/vmware/govmomi/vim25/methods/fault_test.go

@@ -0,0 +1,62 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package methods
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+var invalidLoginFault = `
+<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
+ xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+ xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<soapenv:Body>
+<soapenv:Fault><faultcode>ServerFaultCode</faultcode><faultstring>Cannot complete login due to an incorrect user name or password.</faultstring><detail><InvalidLoginFault xmlns="urn:vim25" xsi:type="InvalidLogin"></InvalidLoginFault></detail></soapenv:Fault>
+</soapenv:Body>
+</soapenv:Envelope>`
+
+type TestBody struct {
+	Fault *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
+}
+
+func TestFaultDetail(t *testing.T) {
+	body := TestBody{}
+	env := soap.Envelope{Body: &body}
+
+	dec := xml.NewDecoder(bytes.NewReader([]byte(invalidLoginFault)))
+	dec.TypeFunc = types.TypeFunc()
+
+	err := dec.Decode(&env)
+	if err != nil {
+		t.Fatalf("Decode: %s", err)
+	}
+
+	if body.Fault == nil {
+		t.Fatal("Expected fault")
+	}
+
+	if _, ok := body.Fault.Detail.Fault.(types.InvalidLogin); !ok {
+		t.Fatalf("Expected InvalidLogin, got: %#v", body.Fault.Detail.Fault)
+	}
+}

vendor/github.com/vmware/govmomi/vim25/methods/internal.go

@@ -0,0 +1,124 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package methods
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type RetrieveDynamicTypeManagerBody struct {
+	Req    *types.RetrieveDynamicTypeManager         `xml:"urn:vim25 RetrieveDynamicTypeManager"`
+	Res    *types.RetrieveDynamicTypeManagerResponse `xml:"urn:vim25 RetrieveDynamicTypeManagerResponse"`
+	Fault_ *soap.Fault
+}
+
+func (b *RetrieveDynamicTypeManagerBody) Fault() *soap.Fault { return b.Fault_ }
+
+func RetrieveDynamicTypeManager(ctx context.Context, r soap.RoundTripper, req *types.RetrieveDynamicTypeManager) (*types.RetrieveDynamicTypeManagerResponse, error) {
+	var reqBody, resBody RetrieveDynamicTypeManagerBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	return resBody.Res, nil
+}
+
+type RetrieveManagedMethodExecuterBody struct {
+	Req    *types.RetrieveManagedMethodExecuter         `xml:"urn:vim25 RetrieveManagedMethodExecuter"`
+	Res    *types.RetrieveManagedMethodExecuterResponse `xml:"urn:vim25 RetrieveManagedMethodExecuterResponse"`
+	Fault_ *soap.Fault
+}
+
+func (b *RetrieveManagedMethodExecuterBody) Fault() *soap.Fault { return b.Fault_ }
+
+func RetrieveManagedMethodExecuter(ctx context.Context, r soap.RoundTripper, req *types.RetrieveManagedMethodExecuter) (*types.RetrieveManagedMethodExecuterResponse, error) {
+	var reqBody, resBody RetrieveManagedMethodExecuterBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	return resBody.Res, nil
+}
+
+type DynamicTypeMgrQueryMoInstancesBody struct {
+	Req    *types.DynamicTypeMgrQueryMoInstances         `xml:"urn:vim25 DynamicTypeMgrQueryMoInstances"`
+	Res    *types.DynamicTypeMgrQueryMoInstancesResponse `xml:"urn:vim25 DynamicTypeMgrQueryMoInstancesResponse"`
+	Fault_ *soap.Fault
+}
+
+func (b *DynamicTypeMgrQueryMoInstancesBody) Fault() *soap.Fault { return b.Fault_ }
+
+func DynamicTypeMgrQueryMoInstances(ctx context.Context, r soap.RoundTripper, req *types.DynamicTypeMgrQueryMoInstances) (*types.DynamicTypeMgrQueryMoInstancesResponse, error) {
+	var reqBody, resBody DynamicTypeMgrQueryMoInstancesBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	return resBody.Res, nil
+}
+
+type DynamicTypeMgrQueryTypeInfoBody struct {
+	Req    *types.DynamicTypeMgrQueryTypeInfo         `xml:"urn:vim25 DynamicTypeMgrQueryTypeInfo"`
+	Res    *types.DynamicTypeMgrQueryTypeInfoResponse `xml:"urn:vim25 DynamicTypeMgrQueryTypeInfoResponse"`
+	Fault_ *soap.Fault
+}
+
+func (b *DynamicTypeMgrQueryTypeInfoBody) Fault() *soap.Fault { return b.Fault_ }
+
+func DynamicTypeMgrQueryTypeInfo(ctx context.Context, r soap.RoundTripper, req *types.DynamicTypeMgrQueryTypeInfo) (*types.DynamicTypeMgrQueryTypeInfoResponse, error) {
+	var reqBody, resBody DynamicTypeMgrQueryTypeInfoBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	return resBody.Res, nil
+}
+
+type ExecuteSoapBody struct {
+	Req    *types.ExecuteSoap         `xml:"urn:vim25 ExecuteSoap"`
+	Res    *types.ExecuteSoapResponse `xml:"urn:vim25 ExecuteSoapResponse"`
+	Fault_ *soap.Fault
+}
+
+func (b *ExecuteSoapBody) Fault() *soap.Fault { return b.Fault_ }
+
+func ExecuteSoap(ctx context.Context, r soap.RoundTripper, req *types.ExecuteSoap) (*types.ExecuteSoapResponse, error) {
+	var reqBody, resBody ExecuteSoapBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	return resBody.Res, nil
+}

vendor/github.com/vmware/govmomi/vim25/methods/service_content.go

@@ -0,0 +1,56 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package methods
+
+import (
+	"context"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+var ServiceInstance = types.ManagedObjectReference{
+	Type:  "ServiceInstance",
+	Value: "ServiceInstance",
+}
+
+func GetServiceContent(ctx context.Context, r soap.RoundTripper) (types.ServiceContent, error) {
+	req := types.RetrieveServiceContent{
+		This: ServiceInstance,
+	}
+
+	res, err := RetrieveServiceContent(ctx, r, &req)
+	if err != nil {
+		return types.ServiceContent{}, err
+	}
+
+	return res.Returnval, nil
+}
+
+func GetCurrentTime(ctx context.Context, r soap.RoundTripper) (*time.Time, error) {
+	req := types.CurrentTime{
+		This: ServiceInstance,
+	}
+
+	res, err := CurrentTime(ctx, r, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/vim25/mo/ancestors.go

@@ -0,0 +1,137 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Ancestors returns the entire ancestry tree of a specified managed object.
+// The return value includes the root node and the specified object itself.
+func Ancestors(ctx context.Context, rt soap.RoundTripper, pc, obj types.ManagedObjectReference) ([]ManagedEntity, error) {
+	ospec := types.ObjectSpec{
+		Obj: obj,
+		SelectSet: []types.BaseSelectionSpec{
+			&types.TraversalSpec{
+				SelectionSpec: types.SelectionSpec{Name: "traverseParent"},
+				Type:          "ManagedEntity",
+				Path:          "parent",
+				Skip:          types.NewBool(false),
+				SelectSet: []types.BaseSelectionSpec{
+					&types.SelectionSpec{Name: "traverseParent"},
+				},
+			},
+			&types.TraversalSpec{
+				SelectionSpec: types.SelectionSpec{},
+				Type:          "VirtualMachine",
+				Path:          "parentVApp",
+				Skip:          types.NewBool(false),
+				SelectSet: []types.BaseSelectionSpec{
+					&types.SelectionSpec{Name: "traverseParent"},
+				},
+			},
+		},
+		Skip: types.NewBool(false),
+	}
+
+	pspec := []types.PropertySpec{
+		{
+			Type:    "ManagedEntity",
+			PathSet: []string{"name", "parent"},
+		},
+		{
+			Type:    "VirtualMachine",
+			PathSet: []string{"parentVApp"},
+		},
+	}
+
+	req := types.RetrieveProperties{
+		This: pc,
+		SpecSet: []types.PropertyFilterSpec{
+			{
+				ObjectSet: []types.ObjectSpec{ospec},
+				PropSet:   pspec,
+			},
+		},
+	}
+
+	var ifaces []interface{}
+	err := RetrievePropertiesForRequest(ctx, rt, req, &ifaces)
+	if err != nil {
+		return nil, err
+	}
+
+	var out []ManagedEntity
+
+	// Build ancestry tree by iteratively finding a new child.
+	for len(out) < len(ifaces) {
+		var find types.ManagedObjectReference
+
+		if len(out) > 0 {
+			find = out[len(out)-1].Self
+		}
+
+		// Find entity we're looking for given the last entity in the current tree.
+		for _, iface := range ifaces {
+			me := iface.(IsManagedEntity).GetManagedEntity()
+
+			if me.Name == "" {
+				// The types below have their own 'Name' field, so ManagedEntity.Name (me.Name) is empty.
+				// We only hit this case when the 'obj' param is one of these types.
+				// In most cases, 'obj' is a Folder so Name isn't collected in this call.
+				switch x := iface.(type) {
+				case Network:
+					me.Name = x.Name
+				case DistributedVirtualSwitch:
+					me.Name = x.Name
+				case DistributedVirtualPortgroup:
+					me.Name = x.Name
+				case OpaqueNetwork:
+					me.Name = x.Name
+				default:
+					// ManagedEntity always has a Name, if we hit this point we missed a case above.
+					panic(fmt.Sprintf("%#v Name is empty", me.Reference()))
+				}
+			}
+
+			if me.Parent == nil {
+				// Special case for VirtualMachine within VirtualApp,
+				// unlikely to hit this other than via Finder.Element()
+				switch x := iface.(type) {
+				case VirtualMachine:
+					me.Parent = x.ParentVApp
+				}
+			}
+
+			if me.Parent == nil {
+				out = append(out, me)
+				break
+			}
+
+			if *me.Parent == find {
+				out = append(out, me)
+				break
+			}
+		}
+	}
+
+	return out, nil
+}

vendor/github.com/vmware/govmomi/vim25/mo/entity.go

@@ -0,0 +1,24 @@
+/*
+Copyright (c) 2016 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+// Entity is the interface that is implemented by all managed objects
+// that extend ManagedEntity.
+type Entity interface {
+	Reference
+	Entity() *ManagedEntity
+}

vendor/github.com/vmware/govmomi/vim25/mo/extra.go

@@ -0,0 +1,61 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+type IsManagedEntity interface {
+	GetManagedEntity() ManagedEntity
+}
+
+func (m ComputeResource) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m Datacenter) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m Datastore) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m DistributedVirtualSwitch) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m DistributedVirtualPortgroup) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m Folder) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m HostSystem) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m Network) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m ResourcePool) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}
+
+func (m VirtualMachine) GetManagedEntity() ManagedEntity {
+	return m.ManagedEntity
+}

vendor/github.com/vmware/govmomi/vim25/mo/fixtures/cluster_host_property.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+ <returnval>
+  <obj type="ClusterComputeResource">domain-c7</obj>
+  <propSet>
+   <name>host</name>
+   <val xsi:type="ArrayOfManagedObjectReference">
+    <ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-14</ManagedObjectReference>
+    <ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-17</ManagedObjectReference>
+    <ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-19</ManagedObjectReference>
+    <ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-52</ManagedObjectReference>
+   </val>
+  </propSet>
+ </returnval>
+</RetrievePropertiesResponse>

vendor/github.com/vmware/govmomi/vim25/mo/fixtures/hostsystem_list_name_property.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+ <returnval>
+  <obj type="HostSystem">host-10</obj>
+  <propSet>
+   <name>name</name>
+   <val xsi:type="xsd:string">host-01.example.com</val>
+  </propSet>
+ </returnval>
+ <returnval>
+  <obj type="HostSystem">host-30</obj>
+  <propSet>
+   <name>name</name>
+   <val xsi:type="xsd:string">host-02.example.com</val>
+  </propSet>
+ </returnval>
+</RetrievePropertiesResponse>

vendor/github.com/vmware/govmomi/vim25/mo/fixtures/nested_property.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <returnval>
+    <obj type="VirtualMachine">vm-411</obj>
+    <propSet>
+      <name>config.name</name>
+      <val xsi:type="xsd:string">kubernetes-master</val>
+    </propSet>
+    <propSet>
+      <name>config.uuid</name>
+      <val xsi:type="xsd:string">422ec880-ab06-06b4-23f3-beb7a052a4c9</val>
+    </propSet>
+  </returnval>
+</RetrievePropertiesResponse>

vendor/github.com/vmware/govmomi/vim25/mo/fixtures/not_authenticated_fault.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <returnval>
+    <obj type="SessionManager">SessionManager</obj>
+    <propSet>
+      <name>defaultLocale</name>
+      <val xsi:type="xsd:string">en</val>
+    </propSet>
+    <propSet>
+      <name>messageLocaleList</name>
+      <val xsi:type="ArrayOfString">
+        <string xsi:type="xsd:string">ja</string>
+        <string xsi:type="xsd:string">zh_CN</string>
+        <string xsi:type="xsd:string">en</string>
+        <string xsi:type="xsd:string">de</string>
+        <string xsi:type="xsd:string">zh_TW</string>
+        <string xsi:type="xsd:string">ko</string>
+        <string xsi:type="xsd:string">fr</string>
+      </val>
+    </propSet>
+    <missingSet>
+      <path>message</path>
+      <fault>
+        <fault xsi:type="NotAuthenticated">
+          <object type="Folder">group-d1</object>
+          <privilegeId>System.View</privilegeId>
+        </fault>
+        <localizedMessage/>
+      </fault>
+    </missingSet>
+    <missingSet>
+      <path>sessionList</path>
+      <fault>
+        <fault xsi:type="NotAuthenticated">
+          <object type="Folder">group-d1</object>
+          <privilegeId>Sessions.TerminateSession</privilegeId>
+        </fault>
+        <localizedMessage/>
+      </fault>
+    </missingSet>
+  </returnval>
+</RetrievePropertiesResponse>

vendor/github.com/vmware/govmomi/vim25/mo/fixtures/pointer_property.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <returnval>
+    <obj type="VirtualMachine">vm-411</obj>
+    <propSet>
+      <name>config.bootOptions</name>
+      <val xsi:type="VirtualMachineBootOptions">
+        <bootDelay>0</bootDelay>
+        <enterBIOSSetup>false</enterBIOSSetup>
+        <bootRetryEnabled>false</bootRetryEnabled>
+        <bootRetryDelay>10000</bootRetryDelay>
+      </val>
+    </propSet>
+  </returnval>
+</RetrievePropertiesResponse>

vendor/github.com/vmware/govmomi/vim25/mo/reference.go

@@ -0,0 +1,26 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import "github.com/vmware/govmomi/vim25/types"
+
+// Reference is the interface that is implemented by all the managed objects
+// defined in this package. It specifies that these managed objects have a
+// function that returns the managed object reference to themselves.
+type Reference interface {
+	Reference() types.ManagedObjectReference
+}

vendor/github.com/vmware/govmomi/vim25/mo/registry.go

@@ -0,0 +1,21 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import "reflect"
+
+var t = map[string]reflect.Type{}

vendor/github.com/vmware/govmomi/vim25/mo/retrieve.go

@@ -0,0 +1,174 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+func ignoreMissingProperty(ref types.ManagedObjectReference, p types.MissingProperty) bool {
+	switch ref.Type {
+	case "VirtualMachine":
+		switch p.Path {
+		case "environmentBrowser":
+			// See https://github.com/vmware/govmomi/pull/242
+			return true
+		case "alarmActionsEnabled":
+			// Seen with vApp child VM
+			return true
+		}
+	}
+
+	return false
+}
+
+// ObjectContentToType loads an ObjectContent value into the value it
+// represents. If the ObjectContent value has a non-empty 'MissingSet' field,
+// it returns the first fault it finds there as error. If the 'MissingSet'
+// field is empty, it returns a pointer to a reflect.Value. It handles contain
+// nested properties, such as 'guest.ipAddress' or 'config.hardware'.
+func ObjectContentToType(o types.ObjectContent) (interface{}, error) {
+	// Expect no properties in the missing set
+	for _, p := range o.MissingSet {
+		if ignoreMissingProperty(o.Obj, p) {
+			continue
+		}
+
+		return nil, soap.WrapVimFault(p.Fault.Fault)
+	}
+
+	ti := typeInfoForType(o.Obj.Type)
+	v, err := ti.LoadFromObjectContent(o)
+	if err != nil {
+		return nil, err
+	}
+
+	return v.Elem().Interface(), nil
+}
+
+// LoadRetrievePropertiesResponse converts the response of a call to
+// RetrieveProperties to one or more managed objects.
+func LoadRetrievePropertiesResponse(res *types.RetrievePropertiesResponse, dst interface{}) error {
+	rt := reflect.TypeOf(dst)
+	if rt == nil || rt.Kind() != reflect.Ptr {
+		panic("need pointer")
+	}
+
+	rv := reflect.ValueOf(dst).Elem()
+	if !rv.CanSet() {
+		panic("cannot set dst")
+	}
+
+	isSlice := false
+	switch rt.Elem().Kind() {
+	case reflect.Struct:
+	case reflect.Slice:
+		isSlice = true
+	default:
+		panic("unexpected type")
+	}
+
+	if isSlice {
+		for _, p := range res.Returnval {
+			v, err := ObjectContentToType(p)
+			if err != nil {
+				return err
+			}
+
+			vt := reflect.TypeOf(v)
+
+			if !rv.Type().AssignableTo(vt) {
+				// For example: dst is []ManagedEntity, res is []HostSystem
+				if field, ok := vt.FieldByName(rt.Elem().Elem().Name()); ok && field.Anonymous {
+					rv.Set(reflect.Append(rv, reflect.ValueOf(v).FieldByIndex(field.Index)))
+					continue
+				}
+			}
+
+			rv.Set(reflect.Append(rv, reflect.ValueOf(v)))
+		}
+	} else {
+		switch len(res.Returnval) {
+		case 0:
+		case 1:
+			v, err := ObjectContentToType(res.Returnval[0])
+			if err != nil {
+				return err
+			}
+
+			vt := reflect.TypeOf(v)
+
+			if !rv.Type().AssignableTo(vt) {
+				// For example: dst is ComputeResource, res is ClusterComputeResource
+				if field, ok := vt.FieldByName(rt.Elem().Name()); ok && field.Anonymous {
+					rv.Set(reflect.ValueOf(v).FieldByIndex(field.Index))
+					return nil
+				}
+			}
+
+			rv.Set(reflect.ValueOf(v))
+		default:
+			// If dst is not a slice, expect to receive 0 or 1 results
+			panic("more than 1 result")
+		}
+	}
+
+	return nil
+}
+
+// RetrievePropertiesForRequest calls the RetrieveProperties method with the
+// specified request and decodes the response struct into the value pointed to
+// by dst.
+func RetrievePropertiesForRequest(ctx context.Context, r soap.RoundTripper, req types.RetrieveProperties, dst interface{}) error {
+	res, err := methods.RetrieveProperties(ctx, r, &req)
+	if err != nil {
+		return err
+	}
+
+	return LoadRetrievePropertiesResponse(res, dst)
+}
+
+// RetrieveProperties retrieves the properties of the managed object specified
+// as obj and decodes the response struct into the value pointed to by dst.
+func RetrieveProperties(ctx context.Context, r soap.RoundTripper, pc, obj types.ManagedObjectReference, dst interface{}) error {
+	req := types.RetrieveProperties{
+		This: pc,
+		SpecSet: []types.PropertyFilterSpec{
+			{
+				ObjectSet: []types.ObjectSpec{
+					{
+						Obj:  obj,
+						Skip: types.NewBool(false),
+					},
+				},
+				PropSet: []types.PropertySpec{
+					{
+						All:  types.NewBool(true),
+						Type: obj.Type,
+					},
+				},
+			},
+		},
+	}
+
+	return RetrievePropertiesForRequest(ctx, r, req, dst)
+}

vendor/github.com/vmware/govmomi/vim25/mo/retrieve_test.go

@@ -0,0 +1,144 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import (
+	"os"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+func load(name string) *types.RetrievePropertiesResponse {
+	f, err := os.Open(name)
+	if err != nil {
+		panic(err)
+	}
+
+	defer f.Close()
+
+	var b types.RetrievePropertiesResponse
+
+	dec := xml.NewDecoder(f)
+	dec.TypeFunc = types.TypeFunc()
+	if err := dec.Decode(&b); err != nil {
+		panic(err)
+	}
+
+	return &b
+}
+
+func TestNotAuthenticatedFault(t *testing.T) {
+	var s SessionManager
+
+	err := LoadRetrievePropertiesResponse(load("fixtures/not_authenticated_fault.xml"), &s)
+	if !soap.IsVimFault(err) {
+		t.Errorf("Expected IsVimFault")
+	}
+
+	fault := soap.ToVimFault(err).(*types.NotAuthenticated)
+	if fault.PrivilegeId != "System.View" {
+		t.Errorf("Expected first fault to be returned")
+	}
+}
+
+func TestNestedProperty(t *testing.T) {
+	var vm VirtualMachine
+
+	err := LoadRetrievePropertiesResponse(load("fixtures/nested_property.xml"), &vm)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %s", err)
+	}
+
+	self := types.ManagedObjectReference{
+		Type:  "VirtualMachine",
+		Value: "vm-411",
+	}
+
+	if vm.Self != self {
+		t.Fatalf("Expected vm.Self to be set")
+	}
+
+	if vm.Config == nil {
+		t.Fatalf("Expected vm.Config to be set")
+	}
+
+	if vm.Config.Name != "kubernetes-master" {
+		t.Errorf("Got: %s", vm.Config.Name)
+	}
+
+	if vm.Config.Uuid != "422ec880-ab06-06b4-23f3-beb7a052a4c9" {
+		t.Errorf("Got: %s", vm.Config.Uuid)
+	}
+}
+
+func TestPointerProperty(t *testing.T) {
+	var vm VirtualMachine
+
+	err := LoadRetrievePropertiesResponse(load("fixtures/pointer_property.xml"), &vm)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %s", err)
+	}
+
+	if vm.Config == nil {
+		t.Fatalf("Expected vm.Config to be set")
+	}
+
+	if vm.Config.BootOptions == nil {
+		t.Fatalf("Expected vm.Config.BootOptions to be set")
+	}
+}
+
+func TestEmbeddedTypeProperty(t *testing.T) {
+	// Test that we avoid in this case:
+	// panic: reflect.Set: value of type mo.ClusterComputeResource is not assignable to type mo.ComputeResource
+	var cr ComputeResource
+
+	err := LoadRetrievePropertiesResponse(load("fixtures/cluster_host_property.xml"), &cr)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %s", err)
+	}
+
+	if len(cr.Host) != 4 {
+		t.Fatalf("Expected cr.Host to be set")
+	}
+}
+
+func TestEmbeddedTypePropertySlice(t *testing.T) {
+	var me []ManagedEntity
+
+	err := LoadRetrievePropertiesResponse(load("fixtures/hostsystem_list_name_property.xml"), &me)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %s", err)
+	}
+
+	if len(me) != 2 {
+		t.Fatalf("Expected 2 elements")
+	}
+
+	for _, m := range me {
+		if m.Name == "" {
+			t.Fatal("Expected Name field to be set")
+		}
+	}
+
+	if me[0].Name == me[1].Name {
+		t.Fatal("Name fields should not be the same")
+	}
+}

vendor/github.com/vmware/govmomi/vim25/mo/type_info.go

@@ -0,0 +1,247 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type typeInfo struct {
+	typ reflect.Type
+
+	// Field indices of "Self" field.
+	self []int
+
+	// Map property names to field indices.
+	props map[string][]int
+}
+
+var typeInfoLock sync.RWMutex
+var typeInfoMap = make(map[string]*typeInfo)
+
+func typeInfoForType(tname string) *typeInfo {
+	typeInfoLock.RLock()
+	ti, ok := typeInfoMap[tname]
+	typeInfoLock.RUnlock()
+
+	if ok {
+		return ti
+	}
+
+	// Create new typeInfo for type.
+	if typ, ok := t[tname]; !ok {
+		panic("unknown type: " + tname)
+	} else {
+		// Multiple routines may race to set it, but the result is the same.
+		typeInfoLock.Lock()
+		ti = newTypeInfo(typ)
+		typeInfoMap[tname] = ti
+		typeInfoLock.Unlock()
+	}
+
+	return ti
+}
+
+func newTypeInfo(typ reflect.Type) *typeInfo {
+	t := typeInfo{
+		typ:   typ,
+		props: make(map[string][]int),
+	}
+
+	t.build(typ, "", []int{})
+
+	return &t
+}
+
+var managedObjectRefType = reflect.TypeOf((*types.ManagedObjectReference)(nil)).Elem()
+
+func buildName(fn string, f reflect.StructField) string {
+	if fn != "" {
+		fn += "."
+	}
+
+	motag := f.Tag.Get("mo")
+	if motag != "" {
+		return fn + motag
+	}
+
+	xmltag := f.Tag.Get("xml")
+	if xmltag != "" {
+		tokens := strings.Split(xmltag, ",")
+		if tokens[0] != "" {
+			return fn + tokens[0]
+		}
+	}
+
+	return ""
+}
+
+func (t *typeInfo) build(typ reflect.Type, fn string, fi []int) {
+	if typ.Kind() == reflect.Ptr {
+		typ = typ.Elem()
+	}
+
+	if typ.Kind() != reflect.Struct {
+		panic("need struct")
+	}
+
+	for i := 0; i < typ.NumField(); i++ {
+		f := typ.Field(i)
+		ftyp := f.Type
+
+		// Copy field indices so they can be passed along.
+		fic := make([]int, len(fi)+1)
+		copy(fic, fi)
+		fic[len(fi)] = i
+
+		// Recurse into embedded field.
+		if f.Anonymous {
+			t.build(ftyp, fn, fic)
+			continue
+		}
+
+		// Top level type has a "Self" field.
+		if f.Name == "Self" && ftyp == managedObjectRefType {
+			t.self = fic
+			continue
+		}
+
+		fnc := buildName(fn, f)
+		if fnc == "" {
+			continue
+		}
+
+		t.props[fnc] = fic
+
+		// Dereference pointer.
+		if ftyp.Kind() == reflect.Ptr {
+			ftyp = ftyp.Elem()
+		}
+
+		// Slices are not addressable by `foo.bar.qux`.
+		if ftyp.Kind() == reflect.Slice {
+			continue
+		}
+
+		// Skip the managed reference type.
+		if ftyp == managedObjectRefType {
+			continue
+		}
+
+		// Recurse into structs.
+		if ftyp.Kind() == reflect.Struct {
+			t.build(ftyp, fnc, fic)
+		}
+	}
+}
+
+// assignValue assignes a value 'pv' to the struct pointed to by 'val', given a
+// slice of field indices. It recurses into the struct until it finds the field
+// specified by the indices. It creates new values for pointer types where
+// needed.
+func assignValue(val reflect.Value, fi []int, pv reflect.Value) {
+	// Create new value if necessary.
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			val.Set(reflect.New(val.Type().Elem()))
+		}
+
+		val = val.Elem()
+	}
+
+	rv := val.Field(fi[0])
+	fi = fi[1:]
+	if len(fi) == 0 {
+		rt := rv.Type()
+		pt := pv.Type()
+
+		// If type is a pointer, create new instance of type.
+		if rt.Kind() == reflect.Ptr {
+			rv.Set(reflect.New(rt.Elem()))
+			rv = rv.Elem()
+			rt = rv.Type()
+		}
+
+		// If type is an interface, check if pv implements it.
+		if rt.Kind() == reflect.Interface && !pt.Implements(rt) {
+			// Check if pointer to pv implements it.
+			if reflect.PtrTo(pt).Implements(rt) {
+				npv := reflect.New(pt)
+				npv.Elem().Set(pv)
+				pv = npv
+				pt = pv.Type()
+			} else {
+				panic(fmt.Sprintf("type %s doesn't implement %s", pt.Name(), rt.Name()))
+			}
+		}
+
+		if pt.AssignableTo(rt) {
+			rv.Set(pv)
+		} else if rt.ConvertibleTo(pt) {
+			rv.Set(pv.Convert(rt))
+		} else {
+			panic(fmt.Sprintf("cannot assign %s (%s) to %s (%s)", rt.Name(), rt.Kind(), pt.Name(), pt.Kind()))
+		}
+
+		return
+	}
+
+	assignValue(rv, fi, pv)
+}
+
+var arrayOfRegexp = regexp.MustCompile("ArrayOf(.*)$")
+
+func anyTypeToValue(t interface{}) reflect.Value {
+	rt := reflect.TypeOf(t)
+	rv := reflect.ValueOf(t)
+
+	// Dereference if ArrayOfXYZ type
+	m := arrayOfRegexp.FindStringSubmatch(rt.Name())
+	if len(m) > 0 {
+		// ArrayOfXYZ type has single field named XYZ
+		rv = rv.FieldByName(m[1])
+		if !rv.IsValid() {
+			panic(fmt.Sprintf("expected %s type to have field %s", m[0], m[1]))
+		}
+	}
+
+	return rv
+}
+
+// LoadObjectFromContent loads properties from the 'PropSet' field in the
+// specified ObjectContent value into the value it represents, which is
+// returned as a reflect.Value.
+func (t *typeInfo) LoadFromObjectContent(o types.ObjectContent) (reflect.Value, error) {
+	v := reflect.New(t.typ)
+	assignValue(v, t.self, reflect.ValueOf(o.Obj))
+
+	for _, p := range o.PropSet {
+		rv, ok := t.props[p.Name]
+		if !ok {
+			continue
+		}
+		assignValue(v, rv, anyTypeToValue(p.Val))
+	}
+
+	return v, nil
+}

vendor/github.com/vmware/govmomi/vim25/mo/type_info_test.go

@@ -0,0 +1,37 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mo
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestLoadAll(*testing.T) {
+	for _, typ := range t {
+		newTypeInfo(typ)
+	}
+}
+
+// The virtual machine managed object has about 500 nested properties.
+// It's likely to be indicative of the function's performance in general.
+func BenchmarkLoadVirtualMachine(b *testing.B) {
+	vmtyp := reflect.TypeOf((*VirtualMachine)(nil)).Elem()
+	for i := 0; i < b.N; i++ {
+		newTypeInfo(vmtyp)
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/aggregator.go

@@ -0,0 +1,73 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import "sync"
+
+type Aggregator struct {
+	downstream Sinker
+	upstream   chan (<-chan Report)
+
+	done chan struct{}
+	w    sync.WaitGroup
+}
+
+func NewAggregator(s Sinker) *Aggregator {
+	a := &Aggregator{
+		downstream: s,
+		upstream:   make(chan (<-chan Report)),
+
+		done: make(chan struct{}),
+	}
+
+	a.w.Add(1)
+	go a.loop()
+
+	return a
+}
+
+func (a *Aggregator) loop() {
+	defer a.w.Done()
+
+	dch := a.downstream.Sink()
+	defer close(dch)
+
+	for {
+		select {
+		case uch := <-a.upstream:
+			// Drain upstream channel
+			for e := range uch {
+				dch <- e
+			}
+		case <-a.done:
+			return
+		}
+	}
+}
+
+func (a *Aggregator) Sink() chan<- Report {
+	ch := make(chan Report)
+	a.upstream <- ch
+	return ch
+}
+
+// Done marks the aggregator as done. No more calls to Sink() may be made and
+// the downstream progress report channel will be closed when Done() returns.
+func (a *Aggregator) Done() {
+	close(a.done)
+	a.w.Wait()
+}

vendor/github.com/vmware/govmomi/vim25/progress/aggregator_test.go

@@ -0,0 +1,81 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import (
+	"testing"
+	"time"
+)
+
+func TestAggregatorNoSinks(t *testing.T) {
+	ch := make(chan Report)
+	a := NewAggregator(dummySinker{ch})
+	a.Done()
+
+	_, ok := <-ch
+	if ok {
+		t.Errorf("Expected channel to be closed")
+	}
+}
+
+func TestAggregatorMultipleSinks(t *testing.T) {
+	ch := make(chan Report)
+	a := NewAggregator(dummySinker{ch})
+
+	for i := 0; i < 5; i++ {
+		go func(ch chan<- Report) {
+			ch <- dummyReport{}
+			ch <- dummyReport{}
+			close(ch)
+		}(a.Sink())
+
+		<-ch
+		<-ch
+	}
+
+	a.Done()
+
+	_, ok := <-ch
+	if ok {
+		t.Errorf("Expected channel to be closed")
+	}
+}
+
+func TestAggregatorSinkInFlightOnDone(t *testing.T) {
+	ch := make(chan Report)
+	a := NewAggregator(dummySinker{ch})
+
+	// Simulate upstream
+	go func(ch chan<- Report) {
+		time.Sleep(1 * time.Millisecond)
+		ch <- dummyReport{}
+		close(ch)
+	}(a.Sink())
+
+	// Drain downstream
+	go func(ch <-chan Report) {
+		<-ch
+	}(ch)
+
+	// This should wait for upstream to complete
+	a.Done()
+
+	_, ok := <-ch
+	if ok {
+		t.Errorf("Expected channel to be closed")
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/common_test.go

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+type dummySinker struct {
+	ch chan Report
+}
+
+func (d dummySinker) Sink() chan<- Report {
+	return d.ch
+}
+
+type dummyReport struct {
+	p float32
+	d string
+	e error
+}
+
+func (p dummyReport) Percentage() float32 {
+	return p.p
+}
+
+func (p dummyReport) Detail() string {
+	return p.d
+}
+
+func (p dummyReport) Error() error {
+	return p.e
+}

vendor/github.com/vmware/govmomi/vim25/progress/doc.go

@@ -0,0 +1,32 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+/*
+The progress package contains functionality to deal with progress reporting.
+The functionality is built to serve progress reporting for infrastructure
+operations when talking the vSphere API, but is generic enough to be used
+elsewhere.
+
+At the core of this progress reporting API lies the Sinker interface. This
+interface is implemented by any object that can act as a sink for progress
+reports. Callers of the Sink() function receives a send-only channel for
+progress reports. They are responsible for closing the channel when done.
+This semantic makes it easy to keep track of multiple progress report channels;
+they are only created when Sink() is called and assumed closed when any
+function that receives a Sinker parameter returns.
+*/

vendor/github.com/vmware/govmomi/vim25/progress/prefix.go

@@ -0,0 +1,54 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import "fmt"
+
+type prefixedReport struct {
+	Report
+	prefix string
+}
+
+func (r prefixedReport) Detail() string {
+	if d := r.Report.Detail(); d != "" {
+		return fmt.Sprintf("%s: %s", r.prefix, d)
+	}
+
+	return r.prefix
+}
+
+func prefixLoop(upstream <-chan Report, downstream chan<- Report, prefix string) {
+	defer close(downstream)
+
+	for r := range upstream {
+		downstream <- prefixedReport{
+			Report: r,
+			prefix: prefix,
+		}
+	}
+}
+
+func Prefix(s Sinker, prefix string) Sinker {
+	fn := func() chan<- Report {
+		upstream := make(chan Report)
+		downstream := s.Sink()
+		go prefixLoop(upstream, downstream, prefix)
+		return upstream
+	}
+
+	return SinkFunc(fn)
+}

vendor/github.com/vmware/govmomi/vim25/progress/prefix_test.go

@@ -0,0 +1,40 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import "testing"
+
+func TestPrefix(t *testing.T) {
+	var r Report
+
+	ch := make(chan Report, 1)
+	s := Prefix(dummySinker{ch}, "prefix").Sink()
+
+	// No detail
+	s <- dummyReport{d: ""}
+	r = <-ch
+	if r.Detail() != "prefix" {
+		t.Errorf("Expected detail to be prefixed")
+	}
+
+	// With detail
+	s <- dummyReport{d: "something"}
+	r = <-ch
+	if r.Detail() != "prefix: something" {
+		t.Errorf("Expected detail to be prefixed")
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/reader.go

@@ -0,0 +1,177 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import (
+	"container/list"
+	"fmt"
+	"io"
+	"sync/atomic"
+	"time"
+)
+
+type readerReport struct {
+	t time.Time
+
+	pos  int64
+	size int64
+	bps  *uint64
+
+	err error
+}
+
+func (r readerReport) Percentage() float32 {
+	return 100.0 * float32(r.pos) / float32(r.size)
+}
+
+func (r readerReport) Detail() string {
+	const (
+		KiB = 1024
+		MiB = 1024 * KiB
+		GiB = 1024 * MiB
+	)
+
+	// Use the reader's bps field, so this report returns an up-to-date number.
+	//
+	// For example: if there hasn't been progress for the last 5 seconds, the
+	// most recent report should return "0B/s".
+	//
+	bps := atomic.LoadUint64(r.bps)
+
+	switch {
+	case bps >= GiB:
+		return fmt.Sprintf("%.1fGiB/s", float32(bps)/float32(GiB))
+	case bps >= MiB:
+		return fmt.Sprintf("%.1fMiB/s", float32(bps)/float32(MiB))
+	case bps >= KiB:
+		return fmt.Sprintf("%.1fKiB/s", float32(bps)/float32(KiB))
+	default:
+		return fmt.Sprintf("%dB/s", bps)
+	}
+}
+
+func (p readerReport) Error() error {
+	return p.err
+}
+
+// reader wraps an io.Reader and sends a progress report over a channel for
+// every read it handles.
+type reader struct {
+	r io.Reader
+
+	pos  int64
+	size int64
+
+	bps uint64
+
+	ch chan<- Report
+}
+
+func NewReader(s Sinker, r io.Reader, size int64) *reader {
+	pr := reader{
+		r: r,
+
+		size: size,
+	}
+
+	// Reports must be sent downstream and to the bps computation loop.
+	pr.ch = Tee(s, newBpsLoop(&pr.bps)).Sink()
+
+	return &pr
+}
+
+// Read calls the Read function on the underlying io.Reader. Additionally,
+// every read causes a progress report to be sent to the progress reader's
+// underlying channel.
+func (r *reader) Read(b []byte) (int, error) {
+	n, err := r.r.Read(b)
+	if err != nil {
+		return n, err
+	}
+
+	r.pos += int64(n)
+	q := readerReport{
+		t:    time.Now(),
+		pos:  r.pos,
+		size: r.size,
+		bps:  &r.bps,
+	}
+
+	r.ch <- q
+
+	return n, err
+}
+
+// Done marks the progress reader as done, optionally including an error in the
+// progress report. After sending it, the underlying channel is closed.
+func (r *reader) Done(err error) {
+	q := readerReport{
+		t:    time.Now(),
+		pos:  r.pos,
+		size: r.size,
+		bps:  &r.bps,
+		err:  err,
+	}
+
+	r.ch <- q
+	close(r.ch)
+}
+
+// newBpsLoop returns a sink that monitors and stores throughput.
+func newBpsLoop(dst *uint64) SinkFunc {
+	fn := func() chan<- Report {
+		sink := make(chan Report)
+		go bpsLoop(sink, dst)
+		return sink
+	}
+
+	return fn
+}
+
+func bpsLoop(ch <-chan Report, dst *uint64) {
+	l := list.New()
+
+	for {
+		var tch <-chan time.Time
+
+		// Setup timer for front of list to become stale.
+		if e := l.Front(); e != nil {
+			dt := time.Second - time.Now().Sub(e.Value.(readerReport).t)
+			tch = time.After(dt)
+		}
+
+		select {
+		case q, ok := <-ch:
+			if !ok {
+				return
+			}
+
+			l.PushBack(q)
+		case <-tch:
+			l.Remove(l.Front())
+		}
+
+		// Compute new bps
+		if l.Len() == 0 {
+			atomic.StoreUint64(dst, 0)
+		} else {
+			f := l.Front().Value.(readerReport)
+			b := l.Back().Value.(readerReport)
+			atomic.StoreUint64(dst, uint64(b.pos-f.pos))
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/reader_test.go

@@ -0,0 +1,90 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import (
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestReader(t *testing.T) {
+	s := "helloworld"
+	ch := make(chan Report, 1)
+	pr := NewReader(&dummySinker{ch}, strings.NewReader(s), int64(len(s)))
+
+	var buf [10]byte
+	var q Report
+	var n int
+	var err error
+
+	// Read first byte
+	n, err = pr.Read(buf[0:1])
+	if n != 1 {
+		t.Errorf("Expected n=1, but got: %d", n)
+	}
+
+	if err != nil {
+		t.Errorf("Error: %s", err)
+	}
+
+	q = <-ch
+	if q.Error() != nil {
+		t.Errorf("Error: %s", err)
+	}
+
+	if f := q.Percentage(); f != 10.0 {
+		t.Errorf("Expected percentage after 1 byte to be 10%%, but got: %.0f%%", f)
+	}
+
+	// Read remaining bytes
+	n, err = pr.Read(buf[:])
+	if n != 9 {
+		t.Errorf("Expected n=1, but got: %d", n)
+	}
+	if err != nil {
+		t.Errorf("Error: %s", err)
+	}
+
+	q = <-ch
+	if q.Error() != nil {
+		t.Errorf("Error: %s", err)
+	}
+
+	if f := q.Percentage(); f != 100.0 {
+		t.Errorf("Expected percentage after 10 bytes to be 100%%, but got: %.0f%%", f)
+	}
+
+	// Read EOF
+	_, err = pr.Read(buf[:])
+	if err != io.EOF {
+		t.Errorf("Expected io.EOF, but got: %s", err)
+	}
+
+	// Mark progress reader as done
+	pr.Done(io.EOF)
+	q = <-ch
+	if err != io.EOF {
+		t.Errorf("Expected io.EOF, but got: %s", err)
+	}
+
+	// Progress channel should be closed after progress reader is marked done
+	_, ok := <-ch
+	if ok {
+		t.Errorf("Expected channel to be closed")
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/report.go

@@ -0,0 +1,26 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+// Report defines the interface for types that can deliver progress reports.
+// Examples include uploads/downloads in the http client and the task info
+// field in the task managed object.
+type Report interface {
+	Percentage() float32
+	Detail() string
+	Error() error
+}

vendor/github.com/vmware/govmomi/vim25/progress/scale.go

@@ -0,0 +1,76 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+type scaledReport struct {
+	Report
+	n int
+	i int
+}
+
+func (r scaledReport) Percentage() float32 {
+	b := 100 * float32(r.i) / float32(r.n)
+	return b + (r.Report.Percentage() / float32(r.n))
+}
+
+type scaleOne struct {
+	s Sinker
+	n int
+	i int
+}
+
+func (s scaleOne) Sink() chan<- Report {
+	upstream := make(chan Report)
+	downstream := s.s.Sink()
+	go s.loop(upstream, downstream)
+	return upstream
+}
+
+func (s scaleOne) loop(upstream <-chan Report, downstream chan<- Report) {
+	defer close(downstream)
+
+	for r := range upstream {
+		downstream <- scaledReport{
+			Report: r,
+			n:      s.n,
+			i:      s.i,
+		}
+	}
+}
+
+type scaleMany struct {
+	s Sinker
+	n int
+	i int
+}
+
+func Scale(s Sinker, n int) Sinker {
+	return &scaleMany{
+		s: s,
+		n: n,
+	}
+}
+
+func (s *scaleMany) Sink() chan<- Report {
+	if s.i == s.n {
+		s.n++
+	}
+
+	ch := scaleOne{s: s.s, n: s.n, i: s.i}.Sink()
+	s.i++
+	return ch
+}

vendor/github.com/vmware/govmomi/vim25/progress/scale_test.go

@@ -0,0 +1,45 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import "testing"
+
+func TestScaleMany(t *testing.T) {
+	ch := make(chan Report)
+	a := NewAggregator(dummySinker{ch})
+	defer a.Done()
+
+	s := Scale(a, 5)
+
+	go func() {
+		for i := 0; i < 5; i++ {
+			go func(ch chan<- Report) {
+				ch <- dummyReport{p: 0.0}
+				ch <- dummyReport{p: 50.0}
+				close(ch)
+			}(s.Sink())
+		}
+	}()
+
+	// Expect percentages to be scaled across sinks
+	for p := float32(0.0); p < 100.0; p += 10.0 {
+		r := <-ch
+		if r.Percentage() != p {
+			t.Errorf("Expected percentage to be: %.0f%%", p)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/sinker.go

@@ -0,0 +1,33 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+// Sinker defines what is expected of a type that can act as a sink for
+// progress reports. The semantics are as follows. If you call Sink(), you are
+// responsible for closing the returned channel. Closing this channel means
+// that the related task is done, or resulted in error.
+type Sinker interface {
+	Sink() chan<- Report
+}
+
+// SinkFunc defines a function that returns a progress report channel.
+type SinkFunc func() chan<- Report
+
+// Sink makes the SinkFunc implement the Sinker interface.
+func (fn SinkFunc) Sink() chan<- Report {
+	return fn()
+}

vendor/github.com/vmware/govmomi/vim25/progress/tee.go

@@ -0,0 +1,41 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+// Tee works like Unix tee; it forwards all progress reports it receives to the
+// specified sinks
+func Tee(s1, s2 Sinker) Sinker {
+	fn := func() chan<- Report {
+		d1 := s1.Sink()
+		d2 := s2.Sink()
+		u := make(chan Report)
+		go tee(u, d1, d2)
+		return u
+	}
+
+	return SinkFunc(fn)
+}
+
+func tee(u <-chan Report, d1, d2 chan<- Report) {
+	defer close(d1)
+	defer close(d2)
+
+	for r := range u {
+		d1 <- r
+		d2 <- r
+	}
+}

vendor/github.com/vmware/govmomi/vim25/progress/tee_test.go

@@ -0,0 +1,46 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package progress
+
+import "testing"
+
+func TestTee(t *testing.T) {
+	var ok bool
+
+	ch1 := make(chan Report)
+	ch2 := make(chan Report)
+
+	s := Tee(&dummySinker{ch: ch1}, &dummySinker{ch: ch2})
+
+	in := s.Sink()
+	in <- dummyReport{}
+	close(in)
+
+	// Receive dummy on both sinks
+	<-ch1
+	<-ch2
+
+	_, ok = <-ch1
+	if ok {
+		t.Errorf("Expected channel to be closed")
+	}
+
+	_, ok = <-ch2
+	if ok {
+		t.Errorf("Expected channel to be closed")
+	}
+}

vendor/github.com/vmware/govmomi/vim25/retry.go

@@ -0,0 +1,105 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package vim25
+
+import (
+	"context"
+	"net"
+	"net/url"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type RetryFunc func(err error) (retry bool, delay time.Duration)
+
+// TemporaryNetworkError returns a RetryFunc that retries up to a maximum of n
+// times, only if the error returned by the RoundTrip function is a temporary
+// network error (for example: a connect timeout).
+func TemporaryNetworkError(n int) RetryFunc {
+	return func(err error) (retry bool, delay time.Duration) {
+		var nerr net.Error
+		var ok bool
+
+		// Never retry if this is not a network error.
+		switch rerr := err.(type) {
+		case *url.Error:
+			if nerr, ok = rerr.Err.(net.Error); !ok {
+				return false, 0
+			}
+		case net.Error:
+			nerr = rerr
+		default:
+			return false, 0
+		}
+
+		if !nerr.Temporary() {
+			return false, 0
+		}
+
+		// Don't retry if we're out of tries.
+		if n--; n <= 0 {
+			return false, 0
+		}
+
+		return true, 0
+	}
+}
+
+type retry struct {
+	roundTripper soap.RoundTripper
+
+	// fn is a custom function that is called when an error occurs.
+	// It returns whether or not to retry, and if so, how long to
+	// delay before retrying.
+	fn RetryFunc
+}
+
+// Retry wraps the specified soap.RoundTripper and invokes the
+// specified RetryFunc. The RetryFunc returns whether or not to
+// retry the call, and if so, how long to wait before retrying. If
+// the result of this function is to not retry, the original error
+// is returned from the RoundTrip function.
+func Retry(roundTripper soap.RoundTripper, fn RetryFunc) soap.RoundTripper {
+	r := &retry{
+		roundTripper: roundTripper,
+		fn:           fn,
+	}
+
+	return r
+}
+
+func (r *retry) RoundTrip(ctx context.Context, req, res soap.HasFault) error {
+	var err error
+
+	for {
+		err = r.roundTripper.RoundTrip(ctx, req, res)
+		if err == nil {
+			break
+		}
+
+		// Invoke retry function to see if another attempt should be made.
+		if retry, delay := r.fn(err); retry {
+			time.Sleep(delay)
+			continue
+		}
+
+		break
+	}
+
+	return err
+}

vendor/github.com/vmware/govmomi/vim25/retry_test.go

@@ -0,0 +1,86 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package vim25
+
+import (
+	"context"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type tempError struct{}
+
+func (tempError) Error() string   { return "tempError" }
+func (tempError) Timeout() bool   { return true }
+func (tempError) Temporary() bool { return true }
+
+type nonTempError struct{}
+
+func (nonTempError) Error() string   { return "nonTempError" }
+func (nonTempError) Timeout() bool   { return false }
+func (nonTempError) Temporary() bool { return false }
+
+type fakeRoundTripper struct {
+	errs []error
+}
+
+func (f *fakeRoundTripper) RoundTrip(ctx context.Context, req, res soap.HasFault) error {
+	err := f.errs[0]
+	f.errs = f.errs[1:]
+	return err
+}
+
+func TestRetry(t *testing.T) {
+	var tcs = []struct {
+		errs     []error
+		expected error
+	}{
+		{
+			errs:     []error{nil},
+			expected: nil,
+		},
+		{
+			errs:     []error{tempError{}, nil},
+			expected: nil,
+		},
+		{
+			errs:     []error{tempError{}, tempError{}},
+			expected: tempError{},
+		},
+		{
+			errs:     []error{nonTempError{}},
+			expected: nonTempError{},
+		},
+		{
+			errs:     []error{tempError{}, nonTempError{}},
+			expected: nonTempError{},
+		},
+	}
+
+	for _, tc := range tcs {
+		var rt soap.RoundTripper
+
+		rt = &fakeRoundTripper{errs: tc.errs}
+		rt = Retry(rt, TemporaryNetworkError(2))
+
+		err := rt.RoundTrip(nil, nil, nil)
+		if err != tc.expected {
+			t.Errorf("Expected: %s, got: %s", tc.expected, err)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/soap/client.go

@@ -0,0 +1,741 @@
+/*
+Copyright (c) 2014-2017 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package soap
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"crypto/sha1"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/progress"
+	"github.com/vmware/govmomi/vim25/types"
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+type HasFault interface {
+	Fault() *Fault
+}
+
+type RoundTripper interface {
+	RoundTrip(ctx context.Context, req, res HasFault) error
+}
+
+const (
+	DefaultVimNamespace  = "urn:vim25"
+	DefaultVimVersion    = "6.5"
+	DefaultMinVimVersion = "5.5"
+)
+
+type header struct {
+	Cookie string `xml:"vcSessionCookie,omitempty"`
+}
+
+type Client struct {
+	http.Client
+
+	u *url.URL
+	k bool // Named after curl's -k flag
+	d *debugContainer
+	t *http.Transport
+	p *url.URL
+
+	hostsMu sync.Mutex
+	hosts   map[string]string
+
+	Namespace string // Vim namespace
+	Version   string // Vim version
+	UserAgent string
+
+	header *header
+}
+
+var schemeMatch = regexp.MustCompile(`^\w+://`)
+
+// ParseURL is wrapper around url.Parse, where Scheme defaults to "https" and Path defaults to "/sdk"
+func ParseURL(s string) (*url.URL, error) {
+	var err error
+	var u *url.URL
+
+	if s != "" {
+		// Default the scheme to https
+		if !schemeMatch.MatchString(s) {
+			s = "https://" + s
+		}
+
+		u, err = url.Parse(s)
+		if err != nil {
+			return nil, err
+		}
+
+		// Default the path to /sdk
+		if u.Path == "" {
+			u.Path = "/sdk"
+		}
+
+		if u.User == nil {
+			u.User = url.UserPassword("", "")
+		}
+	}
+
+	return u, nil
+}
+
+func NewClient(u *url.URL, insecure bool) *Client {
+	c := Client{
+		u: u,
+		k: insecure,
+		d: newDebug(),
+	}
+
+	// Initialize http.RoundTripper on client, so we can customize it below
+	if t, ok := http.DefaultTransport.(*http.Transport); ok {
+		c.t = &http.Transport{
+			Proxy:                 t.Proxy,
+			DialContext:           t.DialContext,
+			MaxIdleConns:          t.MaxIdleConns,
+			IdleConnTimeout:       t.IdleConnTimeout,
+			TLSHandshakeTimeout:   t.TLSHandshakeTimeout,
+			ExpectContinueTimeout: t.ExpectContinueTimeout,
+		}
+	} else {
+		c.t = new(http.Transport)
+	}
+
+	c.hosts = make(map[string]string)
+	c.t.TLSClientConfig = &tls.Config{InsecureSkipVerify: c.k}
+	// Don't bother setting DialTLS if InsecureSkipVerify=true
+	if !c.k {
+		c.t.DialTLS = c.dialTLS
+	}
+
+	c.Client.Transport = c.t
+	c.Client.Jar, _ = cookiejar.New(nil)
+
+	// Remove user information from a copy of the URL
+	c.u = c.URL()
+	c.u.User = nil
+
+	c.Namespace = DefaultVimNamespace
+	c.Version = DefaultVimVersion
+
+	return &c
+}
+
+// NewServiceClient creates a NewClient with the given URL.Path and namespace.
+func (c *Client) NewServiceClient(path string, namespace string) *Client {
+	u := c.URL()
+	u.Path = path
+
+	client := NewClient(u, c.k)
+
+	client.Namespace = namespace
+
+	// Copy the cookies
+	client.Client.Jar.SetCookies(u, c.Client.Jar.Cookies(u))
+
+	// Set SOAP Header cookie
+	for _, cookie := range client.Jar.Cookies(u) {
+		if cookie.Name == "vmware_soap_session" {
+			client.header = &header{
+				Cookie: cookie.Value,
+			}
+
+			break
+		}
+	}
+
+	return client
+}
+
+// SetRootCAs defines the set of root certificate authorities
+// that clients use when verifying server certificates.
+// By default TLS uses the host's root CA set.
+//
+// See: http.Client.Transport.TLSClientConfig.RootCAs
+func (c *Client) SetRootCAs(file string) error {
+	pool := x509.NewCertPool()
+
+	for _, name := range filepath.SplitList(file) {
+		pem, err := ioutil.ReadFile(name)
+		if err != nil {
+			return err
+		}
+
+		pool.AppendCertsFromPEM(pem)
+	}
+
+	c.t.TLSClientConfig.RootCAs = pool
+
+	return nil
+}
+
+// Add default https port if missing
+func hostAddr(addr string) string {
+	_, port := splitHostPort(addr)
+	if port == "" {
+		return addr + ":443"
+	}
+	return addr
+}
+
+// SetThumbprint sets the known certificate thumbprint for the given host.
+// A custom DialTLS function is used to support thumbprint based verification.
+// We first try tls.Dial with the default tls.Config, only falling back to thumbprint verification
+// if it fails with an x509.UnknownAuthorityError or x509.HostnameError
+//
+// See: http.Client.Transport.DialTLS
+func (c *Client) SetThumbprint(host string, thumbprint string) {
+	host = hostAddr(host)
+
+	c.hostsMu.Lock()
+	if thumbprint == "" {
+		delete(c.hosts, host)
+	} else {
+		c.hosts[host] = thumbprint
+	}
+	c.hostsMu.Unlock()
+}
+
+// Thumbprint returns the certificate thumbprint for the given host if known to this client.
+func (c *Client) Thumbprint(host string) string {
+	host = hostAddr(host)
+	c.hostsMu.Lock()
+	defer c.hostsMu.Unlock()
+	return c.hosts[host]
+}
+
+// LoadThumbprints from file with the give name.
+// If name is empty or name does not exist this function will return nil.
+func (c *Client) LoadThumbprints(file string) error {
+	if file == "" {
+		return nil
+	}
+
+	for _, name := range filepath.SplitList(file) {
+		err := c.loadThumbprints(name)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Client) loadThumbprints(name string) error {
+	f, err := os.Open(name)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+
+	scanner := bufio.NewScanner(f)
+
+	for scanner.Scan() {
+		e := strings.SplitN(scanner.Text(), " ", 2)
+		if len(e) != 2 {
+			continue
+		}
+
+		c.SetThumbprint(e[0], e[1])
+	}
+
+	_ = f.Close()
+
+	return scanner.Err()
+}
+
+// ThumbprintSHA1 returns the thumbprint of the given cert in the same format used by the SDK and Client.SetThumbprint.
+//
+// See: SSLVerifyFault.Thumbprint, SessionManagerGenericServiceTicket.Thumbprint, HostConnectSpec.SslThumbprint
+func ThumbprintSHA1(cert *x509.Certificate) string {
+	sum := sha1.Sum(cert.Raw)
+	hex := make([]string, len(sum))
+	for i, b := range sum {
+		hex[i] = fmt.Sprintf("%02X", b)
+	}
+	return strings.Join(hex, ":")
+}
+
+func (c *Client) dialTLS(network string, addr string) (net.Conn, error) {
+	// Would be nice if there was a tls.Config.Verify func,
+	// see tls.clientHandshakeState.doFullHandshake
+
+	conn, err := tls.Dial(network, addr, c.t.TLSClientConfig)
+
+	if err == nil {
+		return conn, nil
+	}
+
+	switch err.(type) {
+	case x509.UnknownAuthorityError:
+	case x509.HostnameError:
+	default:
+		return nil, err
+	}
+
+	thumbprint := c.Thumbprint(addr)
+	if thumbprint == "" {
+		return nil, err
+	}
+
+	config := &tls.Config{InsecureSkipVerify: true}
+	conn, err = tls.Dial(network, addr, config)
+	if err != nil {
+		return nil, err
+	}
+
+	cert := conn.ConnectionState().PeerCertificates[0]
+	peer := ThumbprintSHA1(cert)
+	if thumbprint != peer {
+		_ = conn.Close()
+
+		return nil, fmt.Errorf("Host %q thumbprint does not match %q", addr, thumbprint)
+	}
+
+	return conn, nil
+}
+
+// splitHostPort is similar to net.SplitHostPort,
+// but rather than return error if there isn't a ':port',
+// return an empty string for the port.
+func splitHostPort(host string) (string, string) {
+	ix := strings.LastIndex(host, ":")
+
+	if ix <= strings.LastIndex(host, "]") {
+		return host, ""
+	}
+
+	name := host[:ix]
+	port := host[ix+1:]
+
+	return name, port
+}
+
+const sdkTunnel = "sdkTunnel:8089"
+
+func (c *Client) SetCertificate(cert tls.Certificate) {
+	t := c.Client.Transport.(*http.Transport)
+
+	// Extension certificate
+	t.TLSClientConfig.Certificates = []tls.Certificate{cert}
+
+	// Proxy to vCenter host on port 80
+	host, _ := splitHostPort(c.u.Host)
+
+	// Should be no reason to change the default port other than testing
+	key := "GOVMOMI_TUNNEL_PROXY_PORT"
+
+	port := c.URL().Query().Get(key)
+	if port == "" {
+		port = os.Getenv(key)
+	}
+
+	if port != "" {
+		host += ":" + port
+	}
+
+	c.p = &url.URL{
+		Scheme: "http",
+		Host:   host,
+	}
+	t.Proxy = func(r *http.Request) (*url.URL, error) {
+		// Only sdk requests should be proxied
+		if r.URL.Path == "/sdk" {
+			return c.p, nil
+		}
+		return http.ProxyFromEnvironment(r)
+	}
+
+	// Rewrite url Host to use the sdk tunnel, required for a certificate request.
+	c.u.Host = sdkTunnel
+}
+
+func (c *Client) URL() *url.URL {
+	urlCopy := *c.u
+	return &urlCopy
+}
+
+type marshaledClient struct {
+	Cookies  []*http.Cookie
+	URL      *url.URL
+	Insecure bool
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	m := marshaledClient{
+		Cookies:  c.Jar.Cookies(c.u),
+		URL:      c.u,
+		Insecure: c.k,
+	}
+
+	return json.Marshal(m)
+}
+
+func (c *Client) UnmarshalJSON(b []byte) error {
+	var m marshaledClient
+
+	err := json.Unmarshal(b, &m)
+	if err != nil {
+		return err
+	}
+
+	*c = *NewClient(m.URL, m.Insecure)
+	c.Jar.SetCookies(m.URL, m.Cookies)
+
+	return nil
+}
+
+func (c *Client) do(ctx context.Context, req *http.Request) (*http.Response, error) {
+	if nil == ctx || nil == ctx.Done() { // ctx.Done() is for ctx
+		return c.Client.Do(req)
+	}
+
+	return c.Client.Do(req.WithContext(ctx))
+}
+
+func (c *Client) RoundTrip(ctx context.Context, reqBody, resBody HasFault) error {
+	var err error
+
+	reqEnv := Envelope{Body: reqBody}
+	resEnv := Envelope{Body: resBody}
+
+	reqEnv.Header = c.header
+
+	// Create debugging context for this round trip
+	d := c.d.newRoundTrip()
+	if d.enabled() {
+		defer d.done()
+	}
+
+	b, err := xml.Marshal(reqEnv)
+	if err != nil {
+		panic(err)
+	}
+
+	rawReqBody := io.MultiReader(strings.NewReader(xml.Header), bytes.NewReader(b))
+	req, err := http.NewRequest("POST", c.u.String(), rawReqBody)
+	if err != nil {
+		panic(err)
+	}
+
+	req.Header.Set(`Content-Type`, `text/xml; charset="utf-8"`)
+	soapAction := fmt.Sprintf("%s/%s", c.Namespace, c.Version)
+	req.Header.Set(`SOAPAction`, soapAction)
+	if c.UserAgent != "" {
+		req.Header.Set(`User-Agent`, c.UserAgent)
+	}
+
+	if d.enabled() {
+		d.debugRequest(req)
+	}
+
+	tstart := time.Now()
+	res, err := c.do(ctx, req)
+	tstop := time.Now()
+
+	if d.enabled() {
+		d.logf("%6dms (%T)", tstop.Sub(tstart)/time.Millisecond, resBody)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if d.enabled() {
+		d.debugResponse(res)
+	}
+
+	// Close response regardless of what happens next
+	defer res.Body.Close()
+
+	switch res.StatusCode {
+	case http.StatusOK:
+		// OK
+	case http.StatusInternalServerError:
+		// Error, but typically includes a body explaining the error
+	default:
+		return errors.New(res.Status)
+	}
+
+	dec := xml.NewDecoder(res.Body)
+	dec.TypeFunc = types.TypeFunc()
+	err = dec.Decode(&resEnv)
+	if err != nil {
+		return err
+	}
+
+	if f := resBody.Fault(); f != nil {
+		return WrapSoapFault(f)
+	}
+
+	return err
+}
+
+func (c *Client) CloseIdleConnections() {
+	c.t.CloseIdleConnections()
+}
+
+// ParseURL wraps url.Parse to rewrite the URL.Host field
+// In the case of VM guest uploads or NFC lease URLs, a Host
+// field with a value of "*" is rewritten to the Client's URL.Host.
+func (c *Client) ParseURL(urlStr string) (*url.URL, error) {
+	u, err := url.Parse(urlStr)
+	if err != nil {
+		return nil, err
+	}
+
+	host, _ := splitHostPort(u.Host)
+	if host == "*" {
+		// Also use Client's port, to support port forwarding
+		u.Host = c.URL().Host
+	}
+
+	return u, nil
+}
+
+type Upload struct {
+	Type          string
+	Method        string
+	ContentLength int64
+	Headers       map[string]string
+	Ticket        *http.Cookie
+	Progress      progress.Sinker
+}
+
+var DefaultUpload = Upload{
+	Type:   "application/octet-stream",
+	Method: "PUT",
+}
+
+// Upload PUTs the local file to the given URL
+func (c *Client) Upload(f io.Reader, u *url.URL, param *Upload) error {
+	var err error
+
+	if param.Progress != nil {
+		pr := progress.NewReader(param.Progress, f, param.ContentLength)
+		f = pr
+
+		// Mark progress reader as done when returning from this function.
+		defer func() {
+			pr.Done(err)
+		}()
+	}
+
+	req, err := http.NewRequest(param.Method, u.String(), f)
+	if err != nil {
+		return err
+	}
+
+	req.ContentLength = param.ContentLength
+	req.Header.Set("Content-Type", param.Type)
+
+	for k, v := range param.Headers {
+		req.Header.Add(k, v)
+	}
+
+	if param.Ticket != nil {
+		req.AddCookie(param.Ticket)
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	switch res.StatusCode {
+	case http.StatusOK:
+	case http.StatusCreated:
+	default:
+		err = errors.New(res.Status)
+	}
+
+	return err
+}
+
+// UploadFile PUTs the local file to the given URL
+func (c *Client) UploadFile(file string, u *url.URL, param *Upload) error {
+	if param == nil {
+		p := DefaultUpload // Copy since we set ContentLength
+		param = &p
+	}
+
+	s, err := os.Stat(file)
+	if err != nil {
+		return err
+	}
+
+	f, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	param.ContentLength = s.Size()
+
+	return c.Upload(f, u, param)
+}
+
+type Download struct {
+	Method   string
+	Headers  map[string]string
+	Ticket   *http.Cookie
+	Progress progress.Sinker
+}
+
+var DefaultDownload = Download{
+	Method: "GET",
+}
+
+// DownloadRequest wraps http.Client.Do, returning the http.Response without checking its StatusCode
+func (c *Client) DownloadRequest(u *url.URL, param *Download) (*http.Response, error) {
+	req, err := http.NewRequest(param.Method, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range param.Headers {
+		req.Header.Add(k, v)
+	}
+
+	if param.Ticket != nil {
+		req.AddCookie(param.Ticket)
+	}
+
+	return c.Client.Do(req)
+}
+
+// directoryReader wraps an io.ReadCloser to support streaming download
+// of a guest directory, stops reading once it sees the stream trailer.
+// This is only useful when guest tools is the Go toolbox.
+// The trailer is required since TransferFromGuest requires a Content-Length,
+// which toolbox doesn't know ahead of time as the gzip'd tarball never touches the disk.
+// We opted to wrap this here for now rather than guest.FileManager so
+// DownloadFile can be also be used as-is to handle this use case.
+type directoryReader struct {
+	io.ReadCloser
+}
+
+var (
+	gzipHeader    = []byte{0x1f, 0x8b, 0x08} // rfc1952 {ID1, ID2, CM}
+	gzipHeaderLen = len(gzipHeader)
+)
+
+func (r *directoryReader) Read(buf []byte) (int, error) {
+	nr, err := r.ReadCloser.Read(buf)
+
+	// Stop reading if the last N bytes are the gzipTrailer
+	if nr >= gzipHeaderLen {
+		if bytes.Equal(buf[nr-gzipHeaderLen:nr], gzipHeader) {
+			nr -= gzipHeaderLen
+			err = io.EOF
+		}
+	}
+
+	return nr, err
+}
+
+// Download GETs the remote file from the given URL
+func (c *Client) Download(u *url.URL, param *Download) (io.ReadCloser, int64, error) {
+	res, err := c.DownloadRequest(u, param)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	switch res.StatusCode {
+	case http.StatusOK:
+	default:
+		err = errors.New(res.Status)
+	}
+
+	if err != nil {
+		return nil, 0, err
+	}
+
+	r := res.Body
+
+	if strings.HasSuffix(u.Path, "/") {
+		r = &directoryReader{ReadCloser: r}
+	}
+
+	return r, res.ContentLength, nil
+}
+
+// DownloadFile GETs the given URL to a local file
+func (c *Client) DownloadFile(file string, u *url.URL, param *Download) error {
+	var err error
+	if param == nil {
+		param = &DefaultDownload
+	}
+
+	rc, contentLength, err := c.Download(u, param)
+	if err != nil {
+		return err
+	}
+	defer rc.Close()
+
+	var r io.Reader = rc
+
+	fh, err := os.Create(file)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+
+	if param.Progress != nil {
+		pr := progress.NewReader(param.Progress, r, contentLength)
+		r = pr
+
+		// Mark progress reader as done when returning from this function.
+		defer func() {
+			pr.Done(err)
+		}()
+	}
+
+	_, err = io.Copy(fh, r)
+	if err != nil {
+		return err
+	}
+
+	// Assign error before returning so that it gets picked up by the deferred
+	// function marking the progress reader as done.
+	err = fh.Close()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/vim25/soap/client_test.go

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package soap
+
+import "testing"
+
+func TestSplitHostPort(t *testing.T) {
+	tests := []struct {
+		url  string
+		host string
+		port string
+	}{
+		{"127.0.0.1", "127.0.0.1", ""},
+		{"*:1234", "*", "1234"},
+		{"127.0.0.1:80", "127.0.0.1", "80"},
+		{"[::1]:6767", "[::1]", "6767"},
+		{"[::1]", "[::1]", ""},
+	}
+
+	for _, test := range tests {
+		host, port := splitHostPort(test.url)
+		if host != test.host {
+			t.Errorf("(%s) %s != %s", test.url, host, test.host)
+		}
+		if port != test.port {
+			t.Errorf("(%s) %s != %s", test.url, port, test.port)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/soap/debug.go

@@ -0,0 +1,149 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package soap
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httputil"
+	"sync/atomic"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/debug"
+)
+
+// teeReader wraps io.TeeReader and patches through the Close() function.
+type teeReader struct {
+	io.Reader
+	io.Closer
+}
+
+func newTeeReader(rc io.ReadCloser, w io.Writer) io.ReadCloser {
+	return teeReader{
+		Reader: io.TeeReader(rc, w),
+		Closer: rc,
+	}
+}
+
+// debugRoundTrip contains state and logic needed to debug a single round trip.
+type debugRoundTrip struct {
+	cn  uint64         // Client number
+	rn  uint64         // Request number
+	log io.WriteCloser // Request log
+	cs  []io.Closer    // Files that need closing when done
+}
+
+func (d *debugRoundTrip) logf(format string, a ...interface{}) {
+	now := time.Now().Format("2006-01-02T15-04-05.000000000")
+	fmt.Fprintf(d.log, "%s - %04d: ", now, d.rn)
+	fmt.Fprintf(d.log, format, a...)
+	fmt.Fprintf(d.log, "\n")
+}
+
+func (d *debugRoundTrip) enabled() bool {
+	return d != nil
+}
+
+func (d *debugRoundTrip) done() {
+	for _, c := range d.cs {
+		c.Close()
+	}
+}
+
+func (d *debugRoundTrip) newFile(suffix string) io.WriteCloser {
+	return debug.NewFile(fmt.Sprintf("%d-%04d.%s", d.cn, d.rn, suffix))
+}
+
+func (d *debugRoundTrip) debugRequest(req *http.Request) {
+	if d == nil {
+		return
+	}
+
+	var wc io.WriteCloser
+
+	// Capture headers
+	wc = d.newFile("req.headers")
+	b, _ := httputil.DumpRequest(req, false)
+	wc.Write(b)
+	wc.Close()
+
+	// Capture body
+	wc = d.newFile("req.xml")
+	req.Body = newTeeReader(req.Body, wc)
+
+	// Delay closing until marked done
+	d.cs = append(d.cs, wc)
+}
+
+func (d *debugRoundTrip) debugResponse(res *http.Response) {
+	if d == nil {
+		return
+	}
+
+	var wc io.WriteCloser
+
+	// Capture headers
+	wc = d.newFile("res.headers")
+	b, _ := httputil.DumpResponse(res, false)
+	wc.Write(b)
+	wc.Close()
+
+	// Capture body
+	wc = d.newFile("res.xml")
+	res.Body = newTeeReader(res.Body, wc)
+
+	// Delay closing until marked done
+	d.cs = append(d.cs, wc)
+}
+
+var cn uint64 // Client counter
+
+// debugContainer wraps the debugging state for a single client.
+type debugContainer struct {
+	cn  uint64         // Client number
+	rn  uint64         // Request counter
+	log io.WriteCloser // Request log
+}
+
+func newDebug() *debugContainer {
+	d := debugContainer{
+		cn: atomic.AddUint64(&cn, 1),
+		rn: 0,
+	}
+
+	if !debug.Enabled() {
+		return nil
+	}
+
+	d.log = debug.NewFile(fmt.Sprintf("%d-client.log", d.cn))
+	return &d
+}
+
+func (d *debugContainer) newRoundTrip() *debugRoundTrip {
+	if d == nil {
+		return nil
+	}
+
+	drt := debugRoundTrip{
+		cn:  d.cn,
+		rn:  atomic.AddUint64(&d.rn, 1),
+		log: d.log,
+	}
+
+	return &drt
+}

vendor/github.com/vmware/govmomi/vim25/soap/error.go

@@ -0,0 +1,115 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package soap
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type regularError struct {
+	err error
+}
+
+func (r regularError) Error() string {
+	return r.err.Error()
+}
+
+type soapFaultError struct {
+	fault *Fault
+}
+
+func (s soapFaultError) Error() string {
+	msg := s.fault.String
+
+	if msg == "" {
+		msg = reflect.TypeOf(s.fault.Detail.Fault).Name()
+	}
+
+	return fmt.Sprintf("%s: %s", s.fault.Code, msg)
+}
+
+type vimFaultError struct {
+	fault types.BaseMethodFault
+}
+
+func (v vimFaultError) Error() string {
+	typ := reflect.TypeOf(v.fault)
+	for typ.Kind() == reflect.Ptr {
+		typ = typ.Elem()
+	}
+
+	return typ.Name()
+}
+
+func (v vimFaultError) Fault() types.BaseMethodFault {
+	return v.fault
+}
+
+func Wrap(err error) error {
+	switch err.(type) {
+	case regularError:
+		return err
+	case soapFaultError:
+		return err
+	case vimFaultError:
+		return err
+	}
+
+	return WrapRegularError(err)
+}
+
+func WrapRegularError(err error) error {
+	return regularError{err}
+}
+
+func IsRegularError(err error) bool {
+	_, ok := err.(regularError)
+	return ok
+}
+
+func ToRegularError(err error) error {
+	return err.(regularError).err
+}
+
+func WrapSoapFault(f *Fault) error {
+	return soapFaultError{f}
+}
+
+func IsSoapFault(err error) bool {
+	_, ok := err.(soapFaultError)
+	return ok
+}
+
+func ToSoapFault(err error) *Fault {
+	return err.(soapFaultError).fault
+}
+
+func WrapVimFault(v types.BaseMethodFault) error {
+	return vimFaultError{v}
+}
+
+func IsVimFault(err error) bool {
+	_, ok := err.(vimFaultError)
+	return ok
+}
+
+func ToVimFault(err error) types.BaseMethodFault {
+	return err.(vimFaultError).fault
+}

vendor/github.com/vmware/govmomi/vim25/soap/soap.go

@@ -0,0 +1,41 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package soap
+
+import (
+	"github.com/vmware/govmomi/vim25/types"
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+type Envelope struct {
+	XMLName xml.Name    `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
+	Header  interface{} `xml:",omitempty"`
+	Body    interface{}
+}
+
+type Fault struct {
+	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault"`
+	Code    string   `xml:"faultcode"`
+	String  string   `xml:"faultstring"`
+	Detail  struct {
+		Fault types.AnyType `xml:",any,typeattr"`
+	} `xml:"detail"`
+}
+
+func (f *Fault) VimFault() types.AnyType {
+	return f.Detail.Fault
+}

vendor/github.com/vmware/govmomi/vim25/soap/soap_test.go

@@ -0,0 +1,59 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package soap
+
+import (
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+func TestEmptyEnvelope(t *testing.T) {
+	env := Envelope{}
+
+	b, err := xml.Marshal(env)
+	if err != nil {
+		t.Errorf("error: %s", err)
+		return
+	}
+
+	expected := `<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"></Envelope>`
+	actual := string(b)
+	if expected != actual {
+		t.Fatalf("expected: %s, actual: %s", expected, actual)
+	}
+}
+
+func TestNonEmptyHeader(t *testing.T) {
+	env := Envelope{
+		Header: struct {
+			Foo string
+		}{"bar"},
+	}
+
+	b, err := xml.Marshal(env)
+	if err != nil {
+		t.Errorf("error: %s", err)
+		return
+	}
+
+	env = Envelope{}
+	err = xml.Unmarshal(b, &env)
+	if err != nil {
+		t.Errorf("error: %s", err)
+	}
+}

vendor/github.com/vmware/govmomi/vim25/types/base.go

@@ -0,0 +1,19 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+type AnyType interface{}

vendor/github.com/vmware/govmomi/vim25/types/base_test.go

@@ -0,0 +1,65 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+func TestAnyType(t *testing.T) {
+	x := func(s string) []byte {
+		s = `<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">` + s
+		s += `</root>`
+		return []byte(s)
+	}
+
+	tests := []struct {
+		Input []byte
+		Value interface{}
+	}{
+		{
+			Input: x(`<name xsi:type="xsd:string">test</name>`),
+			Value: "test",
+		},
+		{
+			Input: x(`<name xsi:type="ArrayOfString"><string>AA</string><string>BB</string></name>`),
+			Value: ArrayOfString{String: []string{"AA", "BB"}},
+		},
+	}
+
+	for _, test := range tests {
+		var r struct {
+			A interface{} `xml:"name,typeattr"`
+		}
+
+		dec := xml.NewDecoder(bytes.NewReader(test.Input))
+		dec.TypeFunc = TypeFunc()
+
+		err := dec.Decode(&r)
+		if err != nil {
+			t.Fatalf("Decode: %s", err)
+		}
+
+		if !reflect.DeepEqual(r.A, test.Value) {
+			t.Errorf("Expected: %#v, actual: %#v", r.A, test.Value)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/types/fault.go

@@ -0,0 +1,32 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+type HasFault interface {
+	Fault() BaseMethodFault
+}
+
+func IsFileNotFound(err error) bool {
+	if f, ok := err.(HasFault); ok {
+		switch f.Fault().(type) {
+		case *FileNotFound:
+			return true
+		}
+	}
+
+	return false
+}

vendor/github.com/vmware/govmomi/vim25/types/helpers.go

@@ -0,0 +1,52 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+import "strings"
+
+func NewBool(v bool) *bool {
+	return &v
+}
+
+func NewReference(r ManagedObjectReference) *ManagedObjectReference {
+	return &r
+}
+
+func (r ManagedObjectReference) Reference() ManagedObjectReference {
+	return r
+}
+
+func (r ManagedObjectReference) String() string {
+	return strings.Join([]string{r.Type, r.Value}, ":")
+}
+
+func (r *ManagedObjectReference) FromString(o string) bool {
+	s := strings.SplitN(o, ":", 2)
+
+	if len(s) < 2 {
+		return false
+	}
+
+	r.Type = s[0]
+	r.Value = s[1]
+
+	return true
+}
+
+func (c *PerfCounterInfo) Name() string {
+	return c.GroupInfo.GetElementDescription().Key + "." + c.NameInfo.GetElementDescription().Key + "." + string(c.RollupType)
+}

vendor/github.com/vmware/govmomi/vim25/types/internal.go

@@ -0,0 +1,266 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+import "reflect"
+
+type DynamicTypeMgrQueryMoInstances struct {
+	This       ManagedObjectReference       `xml:"_this"`
+	FilterSpec BaseDynamicTypeMgrFilterSpec `xml:"filterSpec,omitempty,typeattr"`
+}
+
+type DynamicTypeMgrQueryMoInstancesResponse struct {
+	Returnval []DynamicTypeMgrMoInstance `xml:"urn:vim25 returnval"`
+}
+
+type DynamicTypeEnumTypeInfo struct {
+	DynamicData
+
+	Name       string                     `xml:"name"`
+	WsdlName   string                     `xml:"wsdlName"`
+	Version    string                     `xml:"version"`
+	Value      []string                   `xml:"value,omitempty"`
+	Annotation []DynamicTypeMgrAnnotation `xml:"annotation,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeEnumTypeInfo"] = reflect.TypeOf((*DynamicTypeEnumTypeInfo)(nil)).Elem()
+}
+
+type DynamicTypeMgrAllTypeInfo struct {
+	DynamicData
+
+	ManagedTypeInfo []DynamicTypeMgrManagedTypeInfo `xml:"managedTypeInfo,omitempty"`
+	EnumTypeInfo    []DynamicTypeEnumTypeInfo       `xml:"enumTypeInfo,omitempty"`
+	DataTypeInfo    []DynamicTypeMgrDataTypeInfo    `xml:"dataTypeInfo,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrAllTypeInfo"] = reflect.TypeOf((*DynamicTypeMgrAllTypeInfo)(nil)).Elem()
+}
+
+type DynamicTypeMgrAnnotation struct {
+	DynamicData
+
+	Name      string   `xml:"name"`
+	Parameter []string `xml:"parameter,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrAnnotation"] = reflect.TypeOf((*DynamicTypeMgrAnnotation)(nil)).Elem()
+}
+
+type DynamicTypeMgrDataTypeInfo struct {
+	DynamicData
+
+	Name       string                           `xml:"name"`
+	WsdlName   string                           `xml:"wsdlName"`
+	Version    string                           `xml:"version"`
+	Base       []string                         `xml:"base,omitempty"`
+	Property   []DynamicTypeMgrPropertyTypeInfo `xml:"property,omitempty"`
+	Annotation []DynamicTypeMgrAnnotation       `xml:"annotation,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrDataTypeInfo"] = reflect.TypeOf((*DynamicTypeMgrDataTypeInfo)(nil)).Elem()
+}
+
+func (b *DynamicTypeMgrFilterSpec) GetDynamicTypeMgrFilterSpec() *DynamicTypeMgrFilterSpec { return b }
+
+type BaseDynamicTypeMgrFilterSpec interface {
+	GetDynamicTypeMgrFilterSpec() *DynamicTypeMgrFilterSpec
+}
+
+type DynamicTypeMgrFilterSpec struct {
+	DynamicData
+}
+
+func init() {
+	t["DynamicTypeMgrFilterSpec"] = reflect.TypeOf((*DynamicTypeMgrFilterSpec)(nil)).Elem()
+}
+
+type DynamicTypeMgrManagedTypeInfo struct {
+	DynamicData
+
+	Name       string                           `xml:"name"`
+	WsdlName   string                           `xml:"wsdlName"`
+	Version    string                           `xml:"version"`
+	Base       []string                         `xml:"base,omitempty"`
+	Property   []DynamicTypeMgrPropertyTypeInfo `xml:"property,omitempty"`
+	Method     []DynamicTypeMgrMethodTypeInfo   `xml:"method,omitempty"`
+	Annotation []DynamicTypeMgrAnnotation       `xml:"annotation,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrManagedTypeInfo"] = reflect.TypeOf((*DynamicTypeMgrManagedTypeInfo)(nil)).Elem()
+}
+
+type DynamicTypeMgrMethodTypeInfo struct {
+	DynamicData
+
+	Name           string                        `xml:"name"`
+	WsdlName       string                        `xml:"wsdlName"`
+	Version        string                        `xml:"version"`
+	ParamTypeInfo  []DynamicTypeMgrParamTypeInfo `xml:"paramTypeInfo,omitempty"`
+	ReturnTypeInfo *DynamicTypeMgrParamTypeInfo  `xml:"returnTypeInfo,omitempty"`
+	Fault          []string                      `xml:"fault,omitempty"`
+	PrivId         string                        `xml:"privId,omitempty"`
+	Annotation     []DynamicTypeMgrAnnotation    `xml:"annotation,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrMethodTypeInfo"] = reflect.TypeOf((*DynamicTypeMgrMethodTypeInfo)(nil)).Elem()
+}
+
+type DynamicTypeMgrMoFilterSpec struct {
+	DynamicTypeMgrFilterSpec
+
+	Id         string `xml:"id,omitempty"`
+	TypeSubstr string `xml:"typeSubstr,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrMoFilterSpec"] = reflect.TypeOf((*DynamicTypeMgrMoFilterSpec)(nil)).Elem()
+}
+
+type DynamicTypeMgrMoInstance struct {
+	DynamicData
+
+	Id     string `xml:"id"`
+	MoType string `xml:"moType"`
+}
+
+func init() {
+	t["DynamicTypeMgrMoInstance"] = reflect.TypeOf((*DynamicTypeMgrMoInstance)(nil)).Elem()
+}
+
+type DynamicTypeMgrParamTypeInfo struct {
+	DynamicData
+
+	Name       string                     `xml:"name"`
+	Version    string                     `xml:"version"`
+	Type       string                     `xml:"type"`
+	PrivId     string                     `xml:"privId,omitempty"`
+	Annotation []DynamicTypeMgrAnnotation `xml:"annotation,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrParamTypeInfo"] = reflect.TypeOf((*DynamicTypeMgrParamTypeInfo)(nil)).Elem()
+}
+
+type DynamicTypeMgrPropertyTypeInfo struct {
+	DynamicData
+
+	Name        string                     `xml:"name"`
+	Version     string                     `xml:"version"`
+	Type        string                     `xml:"type"`
+	PrivId      string                     `xml:"privId,omitempty"`
+	MsgIdFormat string                     `xml:"msgIdFormat,omitempty"`
+	Annotation  []DynamicTypeMgrAnnotation `xml:"annotation,omitempty"`
+}
+
+type DynamicTypeMgrQueryTypeInfo struct {
+	This       ManagedObjectReference       `xml:"_this"`
+	FilterSpec BaseDynamicTypeMgrFilterSpec `xml:"filterSpec,omitempty,typeattr"`
+}
+
+type DynamicTypeMgrQueryTypeInfoResponse struct {
+	Returnval DynamicTypeMgrAllTypeInfo `xml:"urn:vim25 returnval"`
+}
+
+func init() {
+	t["DynamicTypeMgrPropertyTypeInfo"] = reflect.TypeOf((*DynamicTypeMgrPropertyTypeInfo)(nil)).Elem()
+}
+
+type DynamicTypeMgrTypeFilterSpec struct {
+	DynamicTypeMgrFilterSpec
+
+	TypeSubstr string `xml:"typeSubstr,omitempty"`
+}
+
+func init() {
+	t["DynamicTypeMgrTypeFilterSpec"] = reflect.TypeOf((*DynamicTypeMgrTypeFilterSpec)(nil)).Elem()
+}
+
+type ReflectManagedMethodExecuterSoapArgument struct {
+	DynamicData
+
+	Name string `xml:"name"`
+	Val  string `xml:"val"`
+}
+
+func init() {
+	t["ReflectManagedMethodExecuterSoapArgument"] = reflect.TypeOf((*ReflectManagedMethodExecuterSoapArgument)(nil)).Elem()
+}
+
+type ReflectManagedMethodExecuterSoapFault struct {
+	DynamicData
+
+	FaultMsg    string `xml:"faultMsg"`
+	FaultDetail string `xml:"faultDetail,omitempty"`
+}
+
+func init() {
+	t["ReflectManagedMethodExecuterSoapFault"] = reflect.TypeOf((*ReflectManagedMethodExecuterSoapFault)(nil)).Elem()
+}
+
+type ReflectManagedMethodExecuterSoapResult struct {
+	DynamicData
+
+	Response string                                 `xml:"response,omitempty"`
+	Fault    *ReflectManagedMethodExecuterSoapFault `xml:"fault,omitempty"`
+}
+
+type RetrieveDynamicTypeManager struct {
+	This ManagedObjectReference `xml:"_this"`
+}
+
+type RetrieveDynamicTypeManagerResponse struct {
+	Returnval *InternalDynamicTypeManager `xml:"urn:vim25 returnval"`
+}
+
+type RetrieveManagedMethodExecuter struct {
+	This ManagedObjectReference `xml:"_this"`
+}
+
+func init() {
+	t["RetrieveManagedMethodExecuter"] = reflect.TypeOf((*RetrieveManagedMethodExecuter)(nil)).Elem()
+}
+
+type RetrieveManagedMethodExecuterResponse struct {
+	Returnval *ReflectManagedMethodExecuter `xml:"urn:vim25 returnval"`
+}
+
+type InternalDynamicTypeManager struct {
+	ManagedObjectReference
+}
+
+type ReflectManagedMethodExecuter struct {
+	ManagedObjectReference
+}
+
+type ExecuteSoap struct {
+	This     ManagedObjectReference                     `xml:"_this"`
+	Moid     string                                     `xml:"moid"`
+	Version  string                                     `xml:"version"`
+	Method   string                                     `xml:"method"`
+	Argument []ReflectManagedMethodExecuterSoapArgument `xml:"argument,omitempty"`
+}
+
+type ExecuteSoapResponse struct {
+	Returnval *ReflectManagedMethodExecuterSoapResult `xml:"urn:vim25 returnval"`
+}

vendor/github.com/vmware/govmomi/vim25/types/registry.go

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+import (
+	"reflect"
+	"strings"
+)
+
+var t = map[string]reflect.Type{}
+
+func Add(name string, kind reflect.Type) {
+	t[name] = kind
+}
+
+type Func func(string) (reflect.Type, bool)
+
+func TypeFunc() Func {
+	return func(name string) (reflect.Type, bool) {
+		typ, ok := t[name]
+		if !ok {
+			// The /sdk endpoint does not prefix types with the namespace,
+			// but extension endpoints, such as /pbm/sdk do.
+			name = strings.TrimPrefix(name, "vim25:")
+			typ, ok = t[name]
+		}
+		return typ, ok
+	}
+}

vendor/github.com/vmware/govmomi/vim25/types/registry_test.go

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestTypeFunc(t *testing.T) {
+	var ok bool
+
+	fn := TypeFunc()
+
+	_, ok = fn("unknown")
+	if ok {
+		t.Errorf("Expected ok==false")
+	}
+
+	actual, ok := fn("UserProfile")
+	if !ok {
+		t.Errorf("Expected ok==true")
+	}
+
+	expected := reflect.TypeOf(UserProfile{})
+	if !reflect.DeepEqual(expected, actual) {
+		t.Errorf("Expected: %#v, actual: %#v", expected, actual)
+	}
+}

vendor/github.com/vmware/govmomi/vim25/types/types_test.go

@@ -0,0 +1,92 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package types
+
+import (
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+func TestVirtualMachineConfigSpec(t *testing.T) {
+	spec := VirtualMachineConfigSpec{
+		Name:     "vm-001",
+		GuestId:  "otherGuest",
+		Files:    &VirtualMachineFileInfo{VmPathName: "[datastore1]"},
+		NumCPUs:  1,
+		MemoryMB: 128,
+		DeviceChange: []BaseVirtualDeviceConfigSpec{
+			&VirtualDeviceConfigSpec{
+				Operation: VirtualDeviceConfigSpecOperationAdd,
+				Device: &VirtualLsiLogicController{VirtualSCSIController{
+					SharedBus: VirtualSCSISharingNoSharing,
+					VirtualController: VirtualController{
+						BusNumber: 0,
+						VirtualDevice: VirtualDevice{
+							Key: 1000,
+						},
+					},
+				}},
+			},
+			&VirtualDeviceConfigSpec{
+				Operation:     VirtualDeviceConfigSpecOperationAdd,
+				FileOperation: VirtualDeviceConfigSpecFileOperationCreate,
+				Device: &VirtualDisk{
+					VirtualDevice: VirtualDevice{
+						Key:           0,
+						ControllerKey: 1000,
+						UnitNumber:    new(int32), // zero default value
+						Backing: &VirtualDiskFlatVer2BackingInfo{
+							DiskMode:        string(VirtualDiskModePersistent),
+							ThinProvisioned: NewBool(true),
+							VirtualDeviceFileBackingInfo: VirtualDeviceFileBackingInfo{
+								FileName: "[datastore1]",
+							},
+						},
+					},
+					CapacityInKB: 4000000,
+				},
+			},
+			&VirtualDeviceConfigSpec{
+				Operation: VirtualDeviceConfigSpecOperationAdd,
+				Device: &VirtualE1000{VirtualEthernetCard{
+					VirtualDevice: VirtualDevice{
+						Key: 0,
+						DeviceInfo: &Description{
+							Label:   "Network Adapter 1",
+							Summary: "VM Network",
+						},
+						Backing: &VirtualEthernetCardNetworkBackingInfo{
+							VirtualDeviceDeviceBackingInfo: VirtualDeviceDeviceBackingInfo{
+								DeviceName: "VM Network",
+							},
+						},
+					},
+					AddressType: string(VirtualEthernetCardMacTypeGenerated),
+				}},
+			},
+		},
+		ExtraConfig: []BaseOptionValue{
+			&OptionValue{Key: "bios.bootOrder", Value: "ethernet0"},
+		},
+	}
+
+	_, err := xml.MarshalIndent(spec, "", " ")
+	if err != nil {
+		t.Fatal(err)
+	}
+}

vendor/github.com/vmware/govmomi/vim25/xml/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. 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 Google 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 COPYRIGHT
+OWNER 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.

vendor/github.com/vmware/govmomi/vim25/xml/atom_test.go

@@ -0,0 +1,56 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml
+
+import "time"
+
+var atomValue = &Feed{
+	XMLName: Name{"http://www.w3.org/2005/Atom", "feed"},
+	Title:   "Example Feed",
+	Link:    []Link{{Href: "http://example.org/"}},
+	Updated: ParseTime("2003-12-13T18:30:02Z"),
+	Author:  Person{Name: "John Doe"},
+	Id:      "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6",
+
+	Entry: []Entry{
+		{
+			Title:   "Atom-Powered Robots Run Amok",
+			Link:    []Link{{Href: "http://example.org/2003/12/13/atom03"}},
+			Id:      "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
+			Updated: ParseTime("2003-12-13T18:30:02Z"),
+			Summary: NewText("Some text."),
+		},
+	},
+}
+
+var atomXml = `` +
+	`<feed xmlns="http://www.w3.org/2005/Atom" updated="2003-12-13T18:30:02Z">` +
+	`<title>Example Feed</title>` +
+	`<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>` +
+	`<link href="http://example.org/"></link>` +
+	`<author><name>John Doe</name><uri></uri><email></email></author>` +
+	`<entry>` +
+	`<title>Atom-Powered Robots Run Amok</title>` +
+	`<id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>` +
+	`<link href="http://example.org/2003/12/13/atom03"></link>` +
+	`<updated>2003-12-13T18:30:02Z</updated>` +
+	`<author><name></name><uri></uri><email></email></author>` +
+	`<summary>Some text.</summary>` +
+	`</entry>` +
+	`</feed>`
+
+func ParseTime(str string) time.Time {
+	t, err := time.Parse(time.RFC3339, str)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+func NewText(text string) Text {
+	return Text{
+		Body: text,
+	}
+}

vendor/github.com/vmware/govmomi/vim25/xml/example_test.go

@@ -0,0 +1,151 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml_test
+
+import (
+	"encoding/xml"
+	"fmt"
+	"os"
+)
+
+func ExampleMarshalIndent() {
+	type Address struct {
+		City, State string
+	}
+	type Person struct {
+		XMLName   xml.Name `xml:"person"`
+		Id        int      `xml:"id,attr"`
+		FirstName string   `xml:"name>first"`
+		LastName  string   `xml:"name>last"`
+		Age       int      `xml:"age"`
+		Height    float32  `xml:"height,omitempty"`
+		Married   bool
+		Address
+		Comment string `xml:",comment"`
+	}
+
+	v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
+	v.Comment = " Need more details. "
+	v.Address = Address{"Hanga Roa", "Easter Island"}
+
+	output, err := xml.MarshalIndent(v, "  ", "    ")
+	if err != nil {
+		fmt.Printf("error: %v\n", err)
+	}
+
+	os.Stdout.Write(output)
+	// Output:
+	//   <person id="13">
+	//       <name>
+	//           <first>John</first>
+	//           <last>Doe</last>
+	//       </name>
+	//       <age>42</age>
+	//       <Married>false</Married>
+	//       <City>Hanga Roa</City>
+	//       <State>Easter Island</State>
+	//       <!-- Need more details. -->
+	//   </person>
+}
+
+func ExampleEncoder() {
+	type Address struct {
+		City, State string
+	}
+	type Person struct {
+		XMLName   xml.Name `xml:"person"`
+		Id        int      `xml:"id,attr"`
+		FirstName string   `xml:"name>first"`
+		LastName  string   `xml:"name>last"`
+		Age       int      `xml:"age"`
+		Height    float32  `xml:"height,omitempty"`
+		Married   bool
+		Address
+		Comment string `xml:",comment"`
+	}
+
+	v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
+	v.Comment = " Need more details. "
+	v.Address = Address{"Hanga Roa", "Easter Island"}
+
+	enc := xml.NewEncoder(os.Stdout)
+	enc.Indent("  ", "    ")
+	if err := enc.Encode(v); err != nil {
+		fmt.Printf("error: %v\n", err)
+	}
+
+	// Output:
+	//   <person id="13">
+	//       <name>
+	//           <first>John</first>
+	//           <last>Doe</last>
+	//       </name>
+	//       <age>42</age>
+	//       <Married>false</Married>
+	//       <City>Hanga Roa</City>
+	//       <State>Easter Island</State>
+	//       <!-- Need more details. -->
+	//   </person>
+}
+
+// This example demonstrates unmarshaling an XML excerpt into a value with
+// some preset fields. Note that the Phone field isn't modified and that
+// the XML <Company> element is ignored. Also, the Groups field is assigned
+// considering the element path provided in its tag.
+func ExampleUnmarshal() {
+	type Email struct {
+		Where string `xml:"where,attr"`
+		Addr  string
+	}
+	type Address struct {
+		City, State string
+	}
+	type Result struct {
+		XMLName xml.Name `xml:"Person"`
+		Name    string   `xml:"FullName"`
+		Phone   string
+		Email   []Email
+		Groups  []string `xml:"Group>Value"`
+		Address
+	}
+	v := Result{Name: "none", Phone: "none"}
+
+	data := `
+		<Person>
+			<FullName>Grace R. Emlin</FullName>
+			<Company>Example Inc.</Company>
+			<Email where="home">
+				<Addr>gre@example.com</Addr>
+			</Email>
+			<Email where='work'>
+				<Addr>gre@work.com</Addr>
+			</Email>
+			<Group>
+				<Value>Friends</Value>
+				<Value>Squash</Value>
+			</Group>
+			<City>Hanga Roa</City>
+			<State>Easter Island</State>
+		</Person>
+	`
+	err := xml.Unmarshal([]byte(data), &v)
+	if err != nil {
+		fmt.Printf("error: %v", err)
+		return
+	}
+	fmt.Printf("XMLName: %#v\n", v.XMLName)
+	fmt.Printf("Name: %q\n", v.Name)
+	fmt.Printf("Phone: %q\n", v.Phone)
+	fmt.Printf("Email: %v\n", v.Email)
+	fmt.Printf("Groups: %v\n", v.Groups)
+	fmt.Printf("Address: %v\n", v.Address)
+	// Output:
+	// XMLName: xml.Name{Space:"", Local:"Person"}
+	// Name: "Grace R. Emlin"
+	// Phone: "none"
+	// Email: [{home gre@example.com} {work gre@work.com}]
+	// Groups: [Friends Squash]
+	// Address: {Hanga Roa Easter Island}
+}

vendor/github.com/vmware/govmomi/vim25/xml/extras.go

@@ -0,0 +1,99 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package xml
+
+import (
+	"reflect"
+	"time"
+)
+
+var xmlSchemaInstance = Name{Space: "http://www.w3.org/2001/XMLSchema-instance", Local: "type"}
+
+var xsiType = Name{Space: "xsi", Local: "type"}
+
+var stringToTypeMap = map[string]reflect.Type{
+	"xsd:boolean":       reflect.TypeOf((*bool)(nil)).Elem(),
+	"xsd:byte":          reflect.TypeOf((*int8)(nil)).Elem(),
+	"xsd:short":         reflect.TypeOf((*int16)(nil)).Elem(),
+	"xsd:int":           reflect.TypeOf((*int32)(nil)).Elem(),
+	"xsd:long":          reflect.TypeOf((*int64)(nil)).Elem(),
+	"xsd:unsignedByte":  reflect.TypeOf((*uint8)(nil)).Elem(),
+	"xsd:unsignedShort": reflect.TypeOf((*uint16)(nil)).Elem(),
+	"xsd:unsignedInt":   reflect.TypeOf((*uint32)(nil)).Elem(),
+	"xsd:unsignedLong":  reflect.TypeOf((*uint64)(nil)).Elem(),
+	"xsd:float":         reflect.TypeOf((*float32)(nil)).Elem(),
+	"xsd:double":        reflect.TypeOf((*float64)(nil)).Elem(),
+	"xsd:string":        reflect.TypeOf((*string)(nil)).Elem(),
+	"xsd:dateTime":      reflect.TypeOf((*time.Time)(nil)).Elem(),
+	"xsd:base64Binary":  reflect.TypeOf((*[]byte)(nil)).Elem(),
+}
+
+// Return a reflect.Type for the specified type. Nil if unknown.
+func stringToType(s string) reflect.Type {
+	return stringToTypeMap[s]
+}
+
+// Return a string for the specified reflect.Type. Panic if unknown.
+func typeToString(typ reflect.Type) string {
+	switch typ.Kind() {
+	case reflect.Bool:
+		return "xsd:boolean"
+	case reflect.Int8:
+		return "xsd:byte"
+	case reflect.Int16:
+		return "xsd:short"
+	case reflect.Int32:
+		return "xsd:int"
+	case reflect.Int, reflect.Int64:
+		return "xsd:long"
+	case reflect.Uint8:
+		return "xsd:unsignedByte"
+	case reflect.Uint16:
+		return "xsd:unsignedShort"
+	case reflect.Uint32:
+		return "xsd:unsignedInt"
+	case reflect.Uint, reflect.Uint64:
+		return "xsd:unsignedLong"
+	case reflect.Float32:
+		return "xsd:float"
+	case reflect.Float64:
+		return "xsd:double"
+	case reflect.String:
+		name := typ.Name()
+		if name == "string" {
+			return "xsd:string"
+		}
+		return name
+	case reflect.Struct:
+		if typ == stringToTypeMap["xsd:dateTime"] {
+			return "xsd:dateTime"
+		}
+
+		// Expect any other struct to be handled...
+		return typ.Name()
+	case reflect.Slice:
+		if typ.Elem().Kind() == reflect.Uint8 {
+			return "xsd:base64Binary"
+		}
+	case reflect.Array:
+		if typ.Elem().Kind() == reflect.Uint8 {
+			return "xsd:base64Binary"
+		}
+	}
+
+	panic("don't know what to do for type: " + typ.String())
+}

vendor/github.com/vmware/govmomi/vim25/xml/extras_test.go

@@ -0,0 +1,222 @@
+/*
+Copyright (c) 2014 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package xml
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+	"time"
+)
+
+type MyType struct {
+	Value string
+}
+
+var myTypes = map[string]reflect.Type{
+	"MyType":      reflect.TypeOf(MyType{}),
+	"ValueType":   reflect.TypeOf(ValueType{}),
+	"PointerType": reflect.TypeOf(PointerType{}),
+}
+
+func MyTypes(name string) (reflect.Type, bool) {
+	t, ok := myTypes[name]
+	return t, ok
+}
+
+func TestMarshalWithEmptyInterface(t *testing.T) {
+	var r1, r2 struct {
+		XMLName Name          `xml:"root"`
+		Values  []interface{} `xml:"value,typeattr"`
+	}
+
+	var tests = []struct {
+		Value interface{}
+	}{
+		{Value: bool(true)},
+		{Value: int8(-8)},
+		{Value: int16(-16)},
+		{Value: int32(-32)},
+		{Value: int64(-64)},
+		{Value: uint8(8)},
+		{Value: uint16(16)},
+		{Value: uint32(32)},
+		{Value: uint64(64)},
+		{Value: float32(32.0)},
+		{Value: float64(64.0)},
+		{Value: string("string")},
+		{Value: time.Now()},
+		{Value: ParseTime("2009-10-04T01:35:58+00:00")},
+		{Value: []byte("bytes")},
+		{Value: MyType{Value: "v"}},
+	}
+
+	for _, test := range tests {
+		r1.XMLName.Local = "root"
+		r1.Values = []interface{}{test.Value}
+		r2.XMLName = Name{}
+		r2.Values = nil
+
+		b, err := Marshal(r1)
+		if err != nil {
+			t.Fatalf("Marshal: %s", err)
+		}
+
+		dec := NewDecoder(bytes.NewReader(b))
+		dec.TypeFunc = MyTypes
+		err = dec.Decode(&r2)
+		if err != nil {
+			t.Fatalf("Unmarshal: %s", err)
+		}
+
+		switch r1.Values[0].(type) {
+		case time.Time:
+			if !r1.Values[0].(time.Time).Equal(r2.Values[0].(time.Time)) {
+				t.Errorf("Expected: %#v, actual: %#v", r1, r2)
+			}
+		default:
+			if !reflect.DeepEqual(r1, r2) {
+				t.Errorf("Expected: %#v, actual: %#v", r1, r2)
+			}
+		}
+	}
+}
+
+type VIntf interface {
+	V() string
+}
+
+type ValueType struct {
+	Value string `xml:",chardata"`
+}
+
+type PointerType struct {
+	Value string `xml:",chardata"`
+}
+
+func (t ValueType) V() string {
+	return t.Value
+}
+
+func (t *PointerType) V() string {
+	return t.Value
+}
+
+func TestMarshalWithInterface(t *testing.T) {
+	var r1, r2 struct {
+		XMLName Name    `xml:"root"`
+		Values  []VIntf `xml:"value,typeattr"`
+	}
+
+	r1.XMLName.Local = "root"
+	r1.Values = []VIntf{
+		ValueType{"v1"},
+		&PointerType{"v2"},
+	}
+
+	b, err := Marshal(r1)
+	if err != nil {
+		t.Fatalf("Marshal: %s", err)
+	}
+
+	dec := NewDecoder(bytes.NewReader(b))
+	dec.TypeFunc = MyTypes
+	err = dec.Decode(&r2)
+	if err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+
+	if !reflect.DeepEqual(r1, r2) {
+		t.Errorf("expected: %#v, actual: %#v", r1, r2)
+	}
+}
+
+type test3iface interface {
+	Value() string
+}
+
+type test3a struct {
+	V string `xml:",chardata"`
+}
+
+func (t test3a) Value() string { return t.V }
+
+type test3b struct {
+	V string `xml:",chardata"`
+}
+
+func (t test3b) Value() string { return t.V }
+
+func TestUnmarshalInterfaceWithoutTypeAttr(t *testing.T) {
+	var r struct {
+		XMLName Name         `xml:"root"`
+		Values  []test3iface `xml:"value,typeattr"`
+	}
+
+	b := `
+	<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+	<value xsi:type="test3a">A</value>
+	<value>B</value>
+	</root>
+	`
+
+	fn := func(name string) (reflect.Type, bool) {
+		switch name {
+		case "test3a":
+			return reflect.TypeOf(test3a{}), true
+		case "test3iface":
+			return reflect.TypeOf(test3b{}), true
+		default:
+			return nil, false
+		}
+	}
+
+	dec := NewDecoder(bytes.NewReader([]byte(b)))
+	dec.TypeFunc = fn
+	err := dec.Decode(&r)
+	if err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+
+	if len(r.Values) != 2 {
+		t.Errorf("Expected 2 values")
+	}
+
+	exps := []struct {
+		Typ reflect.Type
+		Val string
+	}{
+		{
+			Typ: reflect.TypeOf(test3a{}),
+			Val: "A",
+		},
+		{
+			Typ: reflect.TypeOf(test3b{}),
+			Val: "B",
+		},
+	}
+
+	for i, e := range exps {
+		if val := r.Values[i].Value(); val != e.Val {
+			t.Errorf("Expected: %s, got: %s", e.Val, val)
+		}
+
+		if typ := reflect.TypeOf(r.Values[i]); typ.Name() != e.Typ.Name() {
+			t.Errorf("Expected: %s, got: %s", e.Typ.Name(), typ.Name())
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/xml/marshal.go

@@ -0,0 +1,949 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml
+
+import (
+	"bufio"
+	"bytes"
+	"encoding"
+	"fmt"
+	"io"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+const (
+	// A generic XML header suitable for use with the output of Marshal.
+	// This is not automatically added to any output of this package,
+	// it is provided as a convenience.
+	Header = `<?xml version="1.0" encoding="UTF-8"?>` + "\n"
+)
+
+// Marshal returns the XML encoding of v.
+//
+// Marshal handles an array or slice by marshalling each of the elements.
+// Marshal handles a pointer by marshalling the value it points at or, if the
+// pointer is nil, by writing nothing.  Marshal handles an interface value by
+// marshalling the value it contains or, if the interface value is nil, by
+// writing nothing.  Marshal handles all other data by writing one or more XML
+// elements containing the data.
+//
+// The name for the XML elements is taken from, in order of preference:
+//     - the tag on the XMLName field, if the data is a struct
+//     - the value of the XMLName field of type xml.Name
+//     - the tag of the struct field used to obtain the data
+//     - the name of the struct field used to obtain the data
+//     - the name of the marshalled type
+//
+// The XML element for a struct contains marshalled elements for each of the
+// exported fields of the struct, with these exceptions:
+//     - the XMLName field, described above, is omitted.
+//     - a field with tag "-" is omitted.
+//     - a field with tag "name,attr" becomes an attribute with
+//       the given name in the XML element.
+//     - a field with tag ",attr" becomes an attribute with the
+//       field name in the XML element.
+//     - a field with tag ",chardata" is written as character data,
+//       not as an XML element.
+//     - a field with tag ",innerxml" is written verbatim, not subject
+//       to the usual marshalling procedure.
+//     - a field with tag ",comment" is written as an XML comment, not
+//       subject to the usual marshalling procedure. It must not contain
+//       the "--" string within it.
+//     - a field with a tag including the "omitempty" option is omitted
+//       if the field value is empty. The empty values are false, 0, any
+//       nil pointer or interface value, and any array, slice, map, or
+//       string of length zero.
+//     - an anonymous struct field is handled as if the fields of its
+//       value were part of the outer struct.
+//
+// If a field uses a tag "a>b>c", then the element c will be nested inside
+// parent elements a and b.  Fields that appear next to each other that name
+// the same parent will be enclosed in one XML element.
+//
+// See MarshalIndent for an example.
+//
+// Marshal will return an error if asked to marshal a channel, function, or map.
+func Marshal(v interface{}) ([]byte, error) {
+	var b bytes.Buffer
+	if err := NewEncoder(&b).Encode(v); err != nil {
+		return nil, err
+	}
+	return b.Bytes(), nil
+}
+
+// Marshaler is the interface implemented by objects that can marshal
+// themselves into valid XML elements.
+//
+// MarshalXML encodes the receiver as zero or more XML elements.
+// By convention, arrays or slices are typically encoded as a sequence
+// of elements, one per entry.
+// Using start as the element tag is not required, but doing so
+// will enable Unmarshal to match the XML elements to the correct
+// struct field.
+// One common implementation strategy is to construct a separate
+// value with a layout corresponding to the desired XML and then
+// to encode it using e.EncodeElement.
+// Another common strategy is to use repeated calls to e.EncodeToken
+// to generate the XML output one token at a time.
+// The sequence of encoded tokens must make up zero or more valid
+// XML elements.
+type Marshaler interface {
+	MarshalXML(e *Encoder, start StartElement) error
+}
+
+// MarshalerAttr is the interface implemented by objects that can marshal
+// themselves into valid XML attributes.
+//
+// MarshalXMLAttr returns an XML attribute with the encoded value of the receiver.
+// Using name as the attribute name is not required, but doing so
+// will enable Unmarshal to match the attribute to the correct
+// struct field.
+// If MarshalXMLAttr returns the zero attribute Attr{}, no attribute
+// will be generated in the output.
+// MarshalXMLAttr is used only for struct fields with the
+// "attr" option in the field tag.
+type MarshalerAttr interface {
+	MarshalXMLAttr(name Name) (Attr, error)
+}
+
+// MarshalIndent works like Marshal, but each XML element begins on a new
+// indented line that starts with prefix and is followed by one or more
+// copies of indent according to the nesting depth.
+func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+	var b bytes.Buffer
+	enc := NewEncoder(&b)
+	enc.Indent(prefix, indent)
+	if err := enc.Encode(v); err != nil {
+		return nil, err
+	}
+	return b.Bytes(), nil
+}
+
+// An Encoder writes XML data to an output stream.
+type Encoder struct {
+	p printer
+}
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+	e := &Encoder{printer{Writer: bufio.NewWriter(w)}}
+	e.p.encoder = e
+	return e
+}
+
+// Indent sets the encoder to generate XML in which each element
+// begins on a new indented line that starts with prefix and is followed by
+// one or more copies of indent according to the nesting depth.
+func (enc *Encoder) Indent(prefix, indent string) {
+	enc.p.prefix = prefix
+	enc.p.indent = indent
+}
+
+// Encode writes the XML encoding of v to the stream.
+//
+// See the documentation for Marshal for details about the conversion
+// of Go values to XML.
+//
+// Encode calls Flush before returning.
+func (enc *Encoder) Encode(v interface{}) error {
+	err := enc.p.marshalValue(reflect.ValueOf(v), nil, nil)
+	if err != nil {
+		return err
+	}
+	return enc.p.Flush()
+}
+
+// EncodeElement writes the XML encoding of v to the stream,
+// using start as the outermost tag in the encoding.
+//
+// See the documentation for Marshal for details about the conversion
+// of Go values to XML.
+//
+// EncodeElement calls Flush before returning.
+func (enc *Encoder) EncodeElement(v interface{}, start StartElement) error {
+	err := enc.p.marshalValue(reflect.ValueOf(v), nil, &start)
+	if err != nil {
+		return err
+	}
+	return enc.p.Flush()
+}
+
+var (
+	endComment   = []byte("-->")
+	endProcInst  = []byte("?>")
+	endDirective = []byte(">")
+)
+
+// EncodeToken writes the given XML token to the stream.
+// It returns an error if StartElement and EndElement tokens are not properly matched.
+//
+// EncodeToken does not call Flush, because usually it is part of a larger operation
+// such as Encode or EncodeElement (or a custom Marshaler's MarshalXML invoked
+// during those), and those will call Flush when finished.
+// Callers that create an Encoder and then invoke EncodeToken directly, without
+// using Encode or EncodeElement, need to call Flush when finished to ensure
+// that the XML is written to the underlying writer.
+//
+// EncodeToken allows writing a ProcInst with Target set to "xml" only as the first token
+// in the stream.
+func (enc *Encoder) EncodeToken(t Token) error {
+	p := &enc.p
+	switch t := t.(type) {
+	case StartElement:
+		if err := p.writeStart(&t); err != nil {
+			return err
+		}
+	case EndElement:
+		if err := p.writeEnd(t.Name); err != nil {
+			return err
+		}
+	case CharData:
+		EscapeText(p, t)
+	case Comment:
+		if bytes.Contains(t, endComment) {
+			return fmt.Errorf("xml: EncodeToken of Comment containing --> marker")
+		}
+		p.WriteString("<!--")
+		p.Write(t)
+		p.WriteString("-->")
+		return p.cachedWriteError()
+	case ProcInst:
+		// First token to be encoded which is also a ProcInst with target of xml
+		// is the xml declaration.  The only ProcInst where target of xml is allowed.
+		if t.Target == "xml" && p.Buffered() != 0 {
+			return fmt.Errorf("xml: EncodeToken of ProcInst xml target only valid for xml declaration, first token encoded")
+		}
+		if !isNameString(t.Target) {
+			return fmt.Errorf("xml: EncodeToken of ProcInst with invalid Target")
+		}
+		if bytes.Contains(t.Inst, endProcInst) {
+			return fmt.Errorf("xml: EncodeToken of ProcInst containing ?> marker")
+		}
+		p.WriteString("<?")
+		p.WriteString(t.Target)
+		if len(t.Inst) > 0 {
+			p.WriteByte(' ')
+			p.Write(t.Inst)
+		}
+		p.WriteString("?>")
+	case Directive:
+		if bytes.Contains(t, endDirective) {
+			return fmt.Errorf("xml: EncodeToken of Directive containing > marker")
+		}
+		p.WriteString("<!")
+		p.Write(t)
+		p.WriteString(">")
+	}
+	return p.cachedWriteError()
+}
+
+// Flush flushes any buffered XML to the underlying writer.
+// See the EncodeToken documentation for details about when it is necessary.
+func (enc *Encoder) Flush() error {
+	return enc.p.Flush()
+}
+
+type printer struct {
+	*bufio.Writer
+	encoder    *Encoder
+	seq        int
+	indent     string
+	prefix     string
+	depth      int
+	indentedIn bool
+	putNewline bool
+	attrNS     map[string]string // map prefix -> name space
+	attrPrefix map[string]string // map name space -> prefix
+	prefixes   []string
+	tags       []Name
+}
+
+// createAttrPrefix finds the name space prefix attribute to use for the given name space,
+// defining a new prefix if necessary. It returns the prefix.
+func (p *printer) createAttrPrefix(url string) string {
+	if prefix := p.attrPrefix[url]; prefix != "" {
+		return prefix
+	}
+
+	// The "http://www.w3.org/XML/1998/namespace" name space is predefined as "xml"
+	// and must be referred to that way.
+	// (The "http://www.w3.org/2000/xmlns/" name space is also predefined as "xmlns",
+	// but users should not be trying to use that one directly - that's our job.)
+	if url == xmlURL {
+		return "xml"
+	}
+
+	// Need to define a new name space.
+	if p.attrPrefix == nil {
+		p.attrPrefix = make(map[string]string)
+		p.attrNS = make(map[string]string)
+	}
+
+	// Pick a name. We try to use the final element of the path
+	// but fall back to _.
+	prefix := strings.TrimRight(url, "/")
+	if i := strings.LastIndex(prefix, "/"); i >= 0 {
+		prefix = prefix[i+1:]
+	}
+	if prefix == "" || !isName([]byte(prefix)) || strings.Contains(prefix, ":") {
+		prefix = "_"
+	}
+	if strings.HasPrefix(prefix, "xml") {
+		// xmlanything is reserved.
+		prefix = "_" + prefix
+	}
+	if p.attrNS[prefix] != "" {
+		// Name is taken. Find a better one.
+		for p.seq++; ; p.seq++ {
+			if id := prefix + "_" + strconv.Itoa(p.seq); p.attrNS[id] == "" {
+				prefix = id
+				break
+			}
+		}
+	}
+
+	p.attrPrefix[url] = prefix
+	p.attrNS[prefix] = url
+
+	p.WriteString(`xmlns:`)
+	p.WriteString(prefix)
+	p.WriteString(`="`)
+	EscapeText(p, []byte(url))
+	p.WriteString(`" `)
+
+	p.prefixes = append(p.prefixes, prefix)
+
+	return prefix
+}
+
+// deleteAttrPrefix removes an attribute name space prefix.
+func (p *printer) deleteAttrPrefix(prefix string) {
+	delete(p.attrPrefix, p.attrNS[prefix])
+	delete(p.attrNS, prefix)
+}
+
+func (p *printer) markPrefix() {
+	p.prefixes = append(p.prefixes, "")
+}
+
+func (p *printer) popPrefix() {
+	for len(p.prefixes) > 0 {
+		prefix := p.prefixes[len(p.prefixes)-1]
+		p.prefixes = p.prefixes[:len(p.prefixes)-1]
+		if prefix == "" {
+			break
+		}
+		p.deleteAttrPrefix(prefix)
+	}
+}
+
+var (
+	marshalerType     = reflect.TypeOf((*Marshaler)(nil)).Elem()
+	marshalerAttrType = reflect.TypeOf((*MarshalerAttr)(nil)).Elem()
+	textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+)
+
+// marshalValue writes one or more XML elements representing val.
+// If val was obtained from a struct field, finfo must have its details.
+func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplate *StartElement) error {
+	if startTemplate != nil && startTemplate.Name.Local == "" {
+		return fmt.Errorf("xml: EncodeElement of StartElement with missing name")
+	}
+
+	if !val.IsValid() {
+		return nil
+	}
+	if finfo != nil && finfo.flags&fOmitEmpty != 0 && isEmptyValue(val) {
+		return nil
+	}
+
+	// Drill into interfaces and pointers.
+	// This can turn into an infinite loop given a cyclic chain,
+	// but it matches the Go 1 behavior.
+	for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			return nil
+		}
+		val = val.Elem()
+	}
+
+	kind := val.Kind()
+	typ := val.Type()
+
+	// Check for marshaler.
+	if val.CanInterface() && typ.Implements(marshalerType) {
+		return p.marshalInterface(val.Interface().(Marshaler), defaultStart(typ, finfo, startTemplate))
+	}
+	if val.CanAddr() {
+		pv := val.Addr()
+		if pv.CanInterface() && pv.Type().Implements(marshalerType) {
+			return p.marshalInterface(pv.Interface().(Marshaler), defaultStart(pv.Type(), finfo, startTemplate))
+		}
+	}
+
+	// Check for text marshaler.
+	if val.CanInterface() && typ.Implements(textMarshalerType) {
+		return p.marshalTextInterface(val.Interface().(encoding.TextMarshaler), defaultStart(typ, finfo, startTemplate))
+	}
+	if val.CanAddr() {
+		pv := val.Addr()
+		if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
+			return p.marshalTextInterface(pv.Interface().(encoding.TextMarshaler), defaultStart(pv.Type(), finfo, startTemplate))
+		}
+	}
+
+	// Slices and arrays iterate over the elements. They do not have an enclosing tag.
+	if (kind == reflect.Slice || kind == reflect.Array) && typ.Elem().Kind() != reflect.Uint8 {
+		for i, n := 0, val.Len(); i < n; i++ {
+			if err := p.marshalValue(val.Index(i), finfo, startTemplate); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	tinfo, err := getTypeInfo(typ)
+	if err != nil {
+		return err
+	}
+
+	// Create start element.
+	// Precedence for the XML element name is:
+	// 0. startTemplate
+	// 1. XMLName field in underlying struct;
+	// 2. field name/tag in the struct field; and
+	// 3. type name
+	var start StartElement
+
+	if startTemplate != nil {
+		start.Name = startTemplate.Name
+		start.Attr = append(start.Attr, startTemplate.Attr...)
+	} else if tinfo.xmlname != nil {
+		xmlname := tinfo.xmlname
+		if xmlname.name != "" {
+			start.Name.Space, start.Name.Local = xmlname.xmlns, xmlname.name
+		} else if v, ok := xmlname.value(val).Interface().(Name); ok && v.Local != "" {
+			start.Name = v
+		}
+	}
+	if start.Name.Local == "" && finfo != nil {
+		start.Name.Space, start.Name.Local = finfo.xmlns, finfo.name
+	}
+	if start.Name.Local == "" {
+		name := typ.Name()
+		if name == "" {
+			return &UnsupportedTypeError{typ}
+		}
+		start.Name.Local = name
+	}
+
+	// Add type attribute if necessary
+	if finfo != nil && finfo.flags&fTypeAttr != 0 {
+		start.Attr = append(start.Attr, Attr{xmlSchemaInstance, typeToString(typ)})
+	}
+
+	// Attributes
+	for i := range tinfo.fields {
+		finfo := &tinfo.fields[i]
+		if finfo.flags&fAttr == 0 {
+			continue
+		}
+		fv := finfo.value(val)
+		name := Name{Space: finfo.xmlns, Local: finfo.name}
+
+		if finfo.flags&fOmitEmpty != 0 && isEmptyValue(fv) {
+			continue
+		}
+
+		if fv.Kind() == reflect.Interface && fv.IsNil() {
+			continue
+		}
+
+		if fv.CanInterface() && fv.Type().Implements(marshalerAttrType) {
+			attr, err := fv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
+			if err != nil {
+				return err
+			}
+			if attr.Name.Local != "" {
+				start.Attr = append(start.Attr, attr)
+			}
+			continue
+		}
+
+		if fv.CanAddr() {
+			pv := fv.Addr()
+			if pv.CanInterface() && pv.Type().Implements(marshalerAttrType) {
+				attr, err := pv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
+				if err != nil {
+					return err
+				}
+				if attr.Name.Local != "" {
+					start.Attr = append(start.Attr, attr)
+				}
+				continue
+			}
+		}
+
+		if fv.CanInterface() && fv.Type().Implements(textMarshalerType) {
+			text, err := fv.Interface().(encoding.TextMarshaler).MarshalText()
+			if err != nil {
+				return err
+			}
+			start.Attr = append(start.Attr, Attr{name, string(text)})
+			continue
+		}
+
+		if fv.CanAddr() {
+			pv := fv.Addr()
+			if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
+				text, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
+				if err != nil {
+					return err
+				}
+				start.Attr = append(start.Attr, Attr{name, string(text)})
+				continue
+			}
+		}
+
+		// Dereference or skip nil pointer, interface values.
+		switch fv.Kind() {
+		case reflect.Ptr, reflect.Interface:
+			if fv.IsNil() {
+				continue
+			}
+			fv = fv.Elem()
+		}
+
+		s, b, err := p.marshalSimple(fv.Type(), fv)
+		if err != nil {
+			return err
+		}
+		if b != nil {
+			s = string(b)
+		}
+		start.Attr = append(start.Attr, Attr{name, s})
+	}
+
+	if err := p.writeStart(&start); err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Struct {
+		err = p.marshalStruct(tinfo, val)
+	} else {
+		s, b, err1 := p.marshalSimple(typ, val)
+		if err1 != nil {
+			err = err1
+		} else if b != nil {
+			EscapeText(p, b)
+		} else {
+			p.EscapeString(s)
+		}
+	}
+	if err != nil {
+		return err
+	}
+
+	if err := p.writeEnd(start.Name); err != nil {
+		return err
+	}
+
+	return p.cachedWriteError()
+}
+
+// defaultStart returns the default start element to use,
+// given the reflect type, field info, and start template.
+func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
+	var start StartElement
+	// Precedence for the XML element name is as above,
+	// except that we do not look inside structs for the first field.
+	if startTemplate != nil {
+		start.Name = startTemplate.Name
+		start.Attr = append(start.Attr, startTemplate.Attr...)
+	} else if finfo != nil && finfo.name != "" {
+		start.Name.Local = finfo.name
+		start.Name.Space = finfo.xmlns
+	} else if typ.Name() != "" {
+		start.Name.Local = typ.Name()
+	} else {
+		// Must be a pointer to a named type,
+		// since it has the Marshaler methods.
+		start.Name.Local = typ.Elem().Name()
+	}
+
+	// Add type attribute if necessary
+	if finfo != nil && finfo.flags&fTypeAttr != 0 {
+		start.Attr = append(start.Attr, Attr{xmlSchemaInstance, typeToString(typ)})
+	}
+
+	return start
+}
+
+// marshalInterface marshals a Marshaler interface value.
+func (p *printer) marshalInterface(val Marshaler, start StartElement) error {
+	// Push a marker onto the tag stack so that MarshalXML
+	// cannot close the XML tags that it did not open.
+	p.tags = append(p.tags, Name{})
+	n := len(p.tags)
+
+	err := val.MarshalXML(p.encoder, start)
+	if err != nil {
+		return err
+	}
+
+	// Make sure MarshalXML closed all its tags. p.tags[n-1] is the mark.
+	if len(p.tags) > n {
+		return fmt.Errorf("xml: %s.MarshalXML wrote invalid XML: <%s> not closed", receiverType(val), p.tags[len(p.tags)-1].Local)
+	}
+	p.tags = p.tags[:n-1]
+	return nil
+}
+
+// marshalTextInterface marshals a TextMarshaler interface value.
+func (p *printer) marshalTextInterface(val encoding.TextMarshaler, start StartElement) error {
+	if err := p.writeStart(&start); err != nil {
+		return err
+	}
+	text, err := val.MarshalText()
+	if err != nil {
+		return err
+	}
+	EscapeText(p, text)
+	return p.writeEnd(start.Name)
+}
+
+// writeStart writes the given start element.
+func (p *printer) writeStart(start *StartElement) error {
+	if start.Name.Local == "" {
+		return fmt.Errorf("xml: start tag with no name")
+	}
+
+	p.tags = append(p.tags, start.Name)
+	p.markPrefix()
+
+	p.writeIndent(1)
+	p.WriteByte('<')
+	p.WriteString(start.Name.Local)
+
+	if start.Name.Space != "" {
+		p.WriteString(` xmlns="`)
+		p.EscapeString(start.Name.Space)
+		p.WriteByte('"')
+	}
+
+	// Attributes
+	for _, attr := range start.Attr {
+		name := attr.Name
+		if name.Local == "" {
+			continue
+		}
+		p.WriteByte(' ')
+		if name.Space != "" {
+			p.WriteString(p.createAttrPrefix(name.Space))
+			p.WriteByte(':')
+		}
+		p.WriteString(name.Local)
+		p.WriteString(`="`)
+		p.EscapeString(attr.Value)
+		p.WriteByte('"')
+	}
+	p.WriteByte('>')
+	return nil
+}
+
+func (p *printer) writeEnd(name Name) error {
+	if name.Local == "" {
+		return fmt.Errorf("xml: end tag with no name")
+	}
+	if len(p.tags) == 0 || p.tags[len(p.tags)-1].Local == "" {
+		return fmt.Errorf("xml: end tag </%s> without start tag", name.Local)
+	}
+	if top := p.tags[len(p.tags)-1]; top != name {
+		if top.Local != name.Local {
+			return fmt.Errorf("xml: end tag </%s> does not match start tag <%s>", name.Local, top.Local)
+		}
+		return fmt.Errorf("xml: end tag </%s> in namespace %s does not match start tag <%s> in namespace %s", name.Local, name.Space, top.Local, top.Space)
+	}
+	p.tags = p.tags[:len(p.tags)-1]
+
+	p.writeIndent(-1)
+	p.WriteByte('<')
+	p.WriteByte('/')
+	p.WriteString(name.Local)
+	p.WriteByte('>')
+	p.popPrefix()
+	return nil
+}
+
+func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
+	switch val.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return strconv.FormatInt(val.Int(), 10), nil, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return strconv.FormatUint(val.Uint(), 10), nil, nil
+	case reflect.Float32, reflect.Float64:
+		return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil, nil
+	case reflect.String:
+		return val.String(), nil, nil
+	case reflect.Bool:
+		return strconv.FormatBool(val.Bool()), nil, nil
+	case reflect.Array:
+		if typ.Elem().Kind() != reflect.Uint8 {
+			break
+		}
+		// [...]byte
+		var bytes []byte
+		if val.CanAddr() {
+			bytes = val.Slice(0, val.Len()).Bytes()
+		} else {
+			bytes = make([]byte, val.Len())
+			reflect.Copy(reflect.ValueOf(bytes), val)
+		}
+		return "", bytes, nil
+	case reflect.Slice:
+		if typ.Elem().Kind() != reflect.Uint8 {
+			break
+		}
+		// []byte
+		return "", val.Bytes(), nil
+	}
+	return "", nil, &UnsupportedTypeError{typ}
+}
+
+var ddBytes = []byte("--")
+
+func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {
+	s := parentStack{p: p}
+	for i := range tinfo.fields {
+		finfo := &tinfo.fields[i]
+		if finfo.flags&fAttr != 0 {
+			continue
+		}
+		vf := finfo.value(val)
+
+		// Dereference or skip nil pointer, interface values.
+		switch vf.Kind() {
+		case reflect.Ptr, reflect.Interface:
+			if !vf.IsNil() {
+				vf = vf.Elem()
+			}
+		}
+
+		switch finfo.flags & fMode {
+		case fCharData:
+			if vf.CanInterface() && vf.Type().Implements(textMarshalerType) {
+				data, err := vf.Interface().(encoding.TextMarshaler).MarshalText()
+				if err != nil {
+					return err
+				}
+				Escape(p, data)
+				continue
+			}
+			if vf.CanAddr() {
+				pv := vf.Addr()
+				if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
+					data, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
+					if err != nil {
+						return err
+					}
+					Escape(p, data)
+					continue
+				}
+			}
+			var scratch [64]byte
+			switch vf.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				Escape(p, strconv.AppendInt(scratch[:0], vf.Int(), 10))
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+				Escape(p, strconv.AppendUint(scratch[:0], vf.Uint(), 10))
+			case reflect.Float32, reflect.Float64:
+				Escape(p, strconv.AppendFloat(scratch[:0], vf.Float(), 'g', -1, vf.Type().Bits()))
+			case reflect.Bool:
+				Escape(p, strconv.AppendBool(scratch[:0], vf.Bool()))
+			case reflect.String:
+				if err := EscapeText(p, []byte(vf.String())); err != nil {
+					return err
+				}
+			case reflect.Slice:
+				if elem, ok := vf.Interface().([]byte); ok {
+					if err := EscapeText(p, elem); err != nil {
+						return err
+					}
+				}
+			}
+			continue
+
+		case fComment:
+			k := vf.Kind()
+			if !(k == reflect.String || k == reflect.Slice && vf.Type().Elem().Kind() == reflect.Uint8) {
+				return fmt.Errorf("xml: bad type for comment field of %s", val.Type())
+			}
+			if vf.Len() == 0 {
+				continue
+			}
+			p.writeIndent(0)
+			p.WriteString("<!--")
+			dashDash := false
+			dashLast := false
+			switch k {
+			case reflect.String:
+				s := vf.String()
+				dashDash = strings.Index(s, "--") >= 0
+				dashLast = s[len(s)-1] == '-'
+				if !dashDash {
+					p.WriteString(s)
+				}
+			case reflect.Slice:
+				b := vf.Bytes()
+				dashDash = bytes.Index(b, ddBytes) >= 0
+				dashLast = b[len(b)-1] == '-'
+				if !dashDash {
+					p.Write(b)
+				}
+			default:
+				panic("can't happen")
+			}
+			if dashDash {
+				return fmt.Errorf(`xml: comments must not contain "--"`)
+			}
+			if dashLast {
+				// "--->" is invalid grammar. Make it "- -->"
+				p.WriteByte(' ')
+			}
+			p.WriteString("-->")
+			continue
+
+		case fInnerXml:
+			iface := vf.Interface()
+			switch raw := iface.(type) {
+			case []byte:
+				p.Write(raw)
+				continue
+			case string:
+				p.WriteString(raw)
+				continue
+			}
+
+		case fElement, fElement | fAny:
+			if err := s.trim(finfo.parents); err != nil {
+				return err
+			}
+			if len(finfo.parents) > len(s.stack) {
+				if vf.Kind() != reflect.Ptr && vf.Kind() != reflect.Interface || !vf.IsNil() {
+					if err := s.push(finfo.parents[len(s.stack):]); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		if err := p.marshalValue(vf, finfo, nil); err != nil {
+			return err
+		}
+	}
+	s.trim(nil)
+	return p.cachedWriteError()
+}
+
+// return the bufio Writer's cached write error
+func (p *printer) cachedWriteError() error {
+	_, err := p.Write(nil)
+	return err
+}
+
+func (p *printer) writeIndent(depthDelta int) {
+	if len(p.prefix) == 0 && len(p.indent) == 0 {
+		return
+	}
+	if depthDelta < 0 {
+		p.depth--
+		if p.indentedIn {
+			p.indentedIn = false
+			return
+		}
+		p.indentedIn = false
+	}
+	if p.putNewline {
+		p.WriteByte('\n')
+	} else {
+		p.putNewline = true
+	}
+	if len(p.prefix) > 0 {
+		p.WriteString(p.prefix)
+	}
+	if len(p.indent) > 0 {
+		for i := 0; i < p.depth; i++ {
+			p.WriteString(p.indent)
+		}
+	}
+	if depthDelta > 0 {
+		p.depth++
+		p.indentedIn = true
+	}
+}
+
+type parentStack struct {
+	p     *printer
+	stack []string
+}
+
+// trim updates the XML context to match the longest common prefix of the stack
+// and the given parents.  A closing tag will be written for every parent
+// popped.  Passing a zero slice or nil will close all the elements.
+func (s *parentStack) trim(parents []string) error {
+	split := 0
+	for ; split < len(parents) && split < len(s.stack); split++ {
+		if parents[split] != s.stack[split] {
+			break
+		}
+	}
+	for i := len(s.stack) - 1; i >= split; i-- {
+		if err := s.p.writeEnd(Name{Local: s.stack[i]}); err != nil {
+			return err
+		}
+	}
+	s.stack = parents[:split]
+	return nil
+}
+
+// push adds parent elements to the stack and writes open tags.
+func (s *parentStack) push(parents []string) error {
+	for i := 0; i < len(parents); i++ {
+		if err := s.p.writeStart(&StartElement{Name: Name{Local: parents[i]}}); err != nil {
+			return err
+		}
+	}
+	s.stack = append(s.stack, parents...)
+	return nil
+}
+
+// A MarshalXMLError is returned when Marshal encounters a type
+// that cannot be converted into XML.
+type UnsupportedTypeError struct {
+	Type reflect.Type
+}
+
+func (e *UnsupportedTypeError) Error() string {
+	return "xml: unsupported type: " + e.Type.String()
+}
+
+func isEmptyValue(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Interface, reflect.Ptr:
+		return v.IsNil()
+	}
+	return false
+}

vendor/github.com/vmware/govmomi/vim25/xml/read.go

@@ -0,0 +1,781 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml
+
+import (
+	"bytes"
+	"encoding"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// BUG(rsc): Mapping between XML elements and data structures is inherently flawed:
+// an XML element is an order-dependent collection of anonymous
+// values, while a data structure is an order-independent collection
+// of named values.
+// See package json for a textual representation more suitable
+// to data structures.
+
+// Unmarshal parses the XML-encoded data and stores the result in
+// the value pointed to by v, which must be an arbitrary struct,
+// slice, or string. Well-formed data that does not fit into v is
+// discarded.
+//
+// Because Unmarshal uses the reflect package, it can only assign
+// to exported (upper case) fields.  Unmarshal uses a case-sensitive
+// comparison to match XML element names to tag values and struct
+// field names.
+//
+// Unmarshal maps an XML element to a struct using the following rules.
+// In the rules, the tag of a field refers to the value associated with the
+// key 'xml' in the struct field's tag (see the example above).
+//
+//   * If the struct has a field of type []byte or string with tag
+//      ",innerxml", Unmarshal accumulates the raw XML nested inside the
+//      element in that field.  The rest of the rules still apply.
+//
+//   * If the struct has a field named XMLName of type xml.Name,
+//      Unmarshal records the element name in that field.
+//
+//   * If the XMLName field has an associated tag of the form
+//      "name" or "namespace-URL name", the XML element must have
+//      the given name (and, optionally, name space) or else Unmarshal
+//      returns an error.
+//
+//   * If the XML element has an attribute whose name matches a
+//      struct field name with an associated tag containing ",attr" or
+//      the explicit name in a struct field tag of the form "name,attr",
+//      Unmarshal records the attribute value in that field.
+//
+//   * If the XML element contains character data, that data is
+//      accumulated in the first struct field that has tag ",chardata".
+//      The struct field may have type []byte or string.
+//      If there is no such field, the character data is discarded.
+//
+//   * If the XML element contains comments, they are accumulated in
+//      the first struct field that has tag ",comment".  The struct
+//      field may have type []byte or string.  If there is no such
+//      field, the comments are discarded.
+//
+//   * If the XML element contains a sub-element whose name matches
+//      the prefix of a tag formatted as "a" or "a>b>c", unmarshal
+//      will descend into the XML structure looking for elements with the
+//      given names, and will map the innermost elements to that struct
+//      field. A tag starting with ">" is equivalent to one starting
+//      with the field name followed by ">".
+//
+//   * If the XML element contains a sub-element whose name matches
+//      a struct field's XMLName tag and the struct field has no
+//      explicit name tag as per the previous rule, unmarshal maps
+//      the sub-element to that struct field.
+//
+//   * If the XML element contains a sub-element whose name matches a
+//      field without any mode flags (",attr", ",chardata", etc), Unmarshal
+//      maps the sub-element to that struct field.
+//
+//   * If the XML element contains a sub-element that hasn't matched any
+//      of the above rules and the struct has a field with tag ",any",
+//      unmarshal maps the sub-element to that struct field.
+//
+//   * An anonymous struct field is handled as if the fields of its
+//      value were part of the outer struct.
+//
+//   * A struct field with tag "-" is never unmarshalled into.
+//
+// Unmarshal maps an XML element to a string or []byte by saving the
+// concatenation of that element's character data in the string or
+// []byte. The saved []byte is never nil.
+//
+// Unmarshal maps an attribute value to a string or []byte by saving
+// the value in the string or slice.
+//
+// Unmarshal maps an XML element to a slice by extending the length of
+// the slice and mapping the element to the newly created value.
+//
+// Unmarshal maps an XML element or attribute value to a bool by
+// setting it to the boolean value represented by the string.
+//
+// Unmarshal maps an XML element or attribute value to an integer or
+// floating-point field by setting the field to the result of
+// interpreting the string value in decimal.  There is no check for
+// overflow.
+//
+// Unmarshal maps an XML element to an xml.Name by recording the
+// element name.
+//
+// Unmarshal maps an XML element to a pointer by setting the pointer
+// to a freshly allocated value and then mapping the element to that value.
+//
+func Unmarshal(data []byte, v interface{}) error {
+	return NewDecoder(bytes.NewReader(data)).Decode(v)
+}
+
+// Decode works like xml.Unmarshal, except it reads the decoder
+// stream to find the start element.
+func (d *Decoder) Decode(v interface{}) error {
+	return d.DecodeElement(v, nil)
+}
+
+// DecodeElement works like xml.Unmarshal except that it takes
+// a pointer to the start XML element to decode into v.
+// It is useful when a client reads some raw XML tokens itself
+// but also wants to defer to Unmarshal for some elements.
+func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error {
+	val := reflect.ValueOf(v)
+	if val.Kind() != reflect.Ptr {
+		return errors.New("non-pointer passed to Unmarshal")
+	}
+	return d.unmarshal(val.Elem(), start)
+}
+
+// An UnmarshalError represents an error in the unmarshalling process.
+type UnmarshalError string
+
+func (e UnmarshalError) Error() string { return string(e) }
+
+// Unmarshaler is the interface implemented by objects that can unmarshal
+// an XML element description of themselves.
+//
+// UnmarshalXML decodes a single XML element
+// beginning with the given start element.
+// If it returns an error, the outer call to Unmarshal stops and
+// returns that error.
+// UnmarshalXML must consume exactly one XML element.
+// One common implementation strategy is to unmarshal into
+// a separate value with a layout matching the expected XML
+// using d.DecodeElement,  and then to copy the data from
+// that value into the receiver.
+// Another common strategy is to use d.Token to process the
+// XML object one token at a time.
+// UnmarshalXML may not use d.RawToken.
+type Unmarshaler interface {
+	UnmarshalXML(d *Decoder, start StartElement) error
+}
+
+// UnmarshalerAttr is the interface implemented by objects that can unmarshal
+// an XML attribute description of themselves.
+//
+// UnmarshalXMLAttr decodes a single XML attribute.
+// If it returns an error, the outer call to Unmarshal stops and
+// returns that error.
+// UnmarshalXMLAttr is used only for struct fields with the
+// "attr" option in the field tag.
+type UnmarshalerAttr interface {
+	UnmarshalXMLAttr(attr Attr) error
+}
+
+// receiverType returns the receiver type to use in an expression like "%s.MethodName".
+func receiverType(val interface{}) string {
+	t := reflect.TypeOf(val)
+	if t.Name() != "" {
+		return t.String()
+	}
+	return "(" + t.String() + ")"
+}
+
+// unmarshalInterface unmarshals a single XML element into val.
+// start is the opening tag of the element.
+func (p *Decoder) unmarshalInterface(val Unmarshaler, start *StartElement) error {
+	// Record that decoder must stop at end tag corresponding to start.
+	p.pushEOF()
+
+	p.unmarshalDepth++
+	err := val.UnmarshalXML(p, *start)
+	p.unmarshalDepth--
+	if err != nil {
+		p.popEOF()
+		return err
+	}
+
+	if !p.popEOF() {
+		return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local)
+	}
+
+	return nil
+}
+
+// unmarshalTextInterface unmarshals a single XML element into val.
+// The chardata contained in the element (but not its children)
+// is passed to the text unmarshaler.
+func (p *Decoder) unmarshalTextInterface(val encoding.TextUnmarshaler, start *StartElement) error {
+	var buf []byte
+	depth := 1
+	for depth > 0 {
+		t, err := p.Token()
+		if err != nil {
+			return err
+		}
+		switch t := t.(type) {
+		case CharData:
+			if depth == 1 {
+				buf = append(buf, t...)
+			}
+		case StartElement:
+			depth++
+		case EndElement:
+			depth--
+		}
+	}
+	return val.UnmarshalText(buf)
+}
+
+// unmarshalAttr unmarshals a single XML attribute into val.
+func (p *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error {
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			val.Set(reflect.New(val.Type().Elem()))
+		}
+		val = val.Elem()
+	}
+
+	if val.CanInterface() && val.Type().Implements(unmarshalerAttrType) {
+		// This is an unmarshaler with a non-pointer receiver,
+		// so it's likely to be incorrect, but we do what we're told.
+		return val.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
+	}
+	if val.CanAddr() {
+		pv := val.Addr()
+		if pv.CanInterface() && pv.Type().Implements(unmarshalerAttrType) {
+			return pv.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
+		}
+	}
+
+	// Not an UnmarshalerAttr; try encoding.TextUnmarshaler.
+	if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
+		// This is an unmarshaler with a non-pointer receiver,
+		// so it's likely to be incorrect, but we do what we're told.
+		return val.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
+	}
+	if val.CanAddr() {
+		pv := val.Addr()
+		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
+			return pv.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
+		}
+	}
+
+	copyValue(val, []byte(attr.Value))
+	return nil
+}
+
+var (
+	unmarshalerType     = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+	unmarshalerAttrType = reflect.TypeOf((*UnmarshalerAttr)(nil)).Elem()
+	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+)
+
+// Find reflect.Type for an element's type attribute.
+func (p *Decoder) typeForElement(val reflect.Value, start *StartElement) reflect.Type {
+	t := ""
+	for i, a := range start.Attr {
+		if a.Name == xmlSchemaInstance || a.Name == xsiType {
+			t = a.Value
+			// HACK: ensure xsi:type is last in the list to avoid using that value for
+			// a "type" attribute, such as ManagedObjectReference.Type for example.
+			// Note that xsi:type is already the last attribute in VC/ESX responses.
+			// This is only an issue with govmomi simulator generated responses.
+			// Proper fix will require finding a few needles in this xml package haystack.
+			// Note: govmomi uses xmlSchemaInstance, other clients (e.g. rbvmomi) use xsiType.
+			// They are the same thing to XML parsers, but not to this hack here.
+			x := len(start.Attr) - 1
+			if i != x {
+				start.Attr[i] = start.Attr[x]
+				start.Attr[x] = a
+			}
+			break
+		}
+	}
+
+	if t == "" {
+		// No type attribute; fall back to looking up type by interface name.
+		t = val.Type().Name()
+	}
+
+	// Maybe the type is a basic xsd:* type.
+	typ := stringToType(t)
+	if typ != nil {
+		return typ
+	}
+
+	// Maybe the type is a custom type.
+	if p.TypeFunc != nil {
+		if typ, ok := p.TypeFunc(t); ok {
+			return typ
+		}
+	}
+
+	return nil
+}
+
+// Unmarshal a single XML element into val.
+func (p *Decoder) unmarshal(val reflect.Value, start *StartElement) error {
+	// Find start element if we need it.
+	if start == nil {
+		for {
+			tok, err := p.Token()
+			if err != nil {
+				return err
+			}
+			if t, ok := tok.(StartElement); ok {
+				start = &t
+				break
+			}
+		}
+	}
+
+	// Try to figure out type for empty interface values.
+	if val.Kind() == reflect.Interface && val.IsNil() {
+		typ := p.typeForElement(val, start)
+		if typ != nil {
+			pval := reflect.New(typ).Elem()
+			err := p.unmarshal(pval, start)
+			if err != nil {
+				return err
+			}
+
+			for i := 0; i < 2; i++ {
+				if typ.Implements(val.Type()) {
+					val.Set(pval)
+					return nil
+				}
+
+				typ = reflect.PtrTo(typ)
+				pval = pval.Addr()
+			}
+
+			val.Set(pval)
+			return nil
+		}
+	}
+
+	// Load value from interface, but only if the result will be
+	// usefully addressable.
+	if val.Kind() == reflect.Interface && !val.IsNil() {
+		e := val.Elem()
+		if e.Kind() == reflect.Ptr && !e.IsNil() {
+			val = e
+		}
+	}
+
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			val.Set(reflect.New(val.Type().Elem()))
+		}
+		val = val.Elem()
+	}
+
+	if val.CanInterface() && val.Type().Implements(unmarshalerType) {
+		// This is an unmarshaler with a non-pointer receiver,
+		// so it's likely to be incorrect, but we do what we're told.
+		return p.unmarshalInterface(val.Interface().(Unmarshaler), start)
+	}
+
+	if val.CanAddr() {
+		pv := val.Addr()
+		if pv.CanInterface() && pv.Type().Implements(unmarshalerType) {
+			return p.unmarshalInterface(pv.Interface().(Unmarshaler), start)
+		}
+	}
+
+	if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
+		return p.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler), start)
+	}
+
+	if val.CanAddr() {
+		pv := val.Addr()
+		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
+			return p.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler), start)
+		}
+	}
+
+	var (
+		data         []byte
+		saveData     reflect.Value
+		comment      []byte
+		saveComment  reflect.Value
+		saveXML      reflect.Value
+		saveXMLIndex int
+		saveXMLData  []byte
+		saveAny      reflect.Value
+		sv           reflect.Value
+		tinfo        *typeInfo
+		err          error
+	)
+
+	switch v := val; v.Kind() {
+	default:
+		return errors.New("unknown type " + v.Type().String())
+
+	case reflect.Interface:
+		// TODO: For now, simply ignore the field. In the near
+		//       future we may choose to unmarshal the start
+		//       element on it, if not nil.
+		return p.Skip()
+
+	case reflect.Slice:
+		typ := v.Type()
+		if typ.Elem().Kind() == reflect.Uint8 {
+			// []byte
+			saveData = v
+			break
+		}
+
+		// Slice of element values.
+		// Grow slice.
+		n := v.Len()
+		if n >= v.Cap() {
+			ncap := 2 * n
+			if ncap < 4 {
+				ncap = 4
+			}
+			new := reflect.MakeSlice(typ, n, ncap)
+			reflect.Copy(new, v)
+			v.Set(new)
+		}
+		v.SetLen(n + 1)
+
+		// Recur to read element into slice.
+		if err := p.unmarshal(v.Index(n), start); err != nil {
+			v.SetLen(n)
+			return err
+		}
+		return nil
+
+	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.String:
+		saveData = v
+
+	case reflect.Struct:
+		typ := v.Type()
+		if typ == nameType {
+			v.Set(reflect.ValueOf(start.Name))
+			break
+		}
+
+		sv = v
+		tinfo, err = getTypeInfo(typ)
+		if err != nil {
+			return err
+		}
+
+		// Validate and assign element name.
+		if tinfo.xmlname != nil {
+			finfo := tinfo.xmlname
+			if finfo.name != "" && finfo.name != start.Name.Local {
+				return UnmarshalError("expected element type <" + finfo.name + "> but have <" + start.Name.Local + ">")
+			}
+			if finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
+				e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have "
+				if start.Name.Space == "" {
+					e += "no name space"
+				} else {
+					e += start.Name.Space
+				}
+				return UnmarshalError(e)
+			}
+			fv := finfo.value(sv)
+			if _, ok := fv.Interface().(Name); ok {
+				fv.Set(reflect.ValueOf(start.Name))
+			}
+		}
+
+		// Assign attributes.
+		// Also, determine whether we need to save character data or comments.
+		for i := range tinfo.fields {
+			finfo := &tinfo.fields[i]
+			switch finfo.flags & fMode {
+			case fAttr:
+				strv := finfo.value(sv)
+				// Look for attribute.
+				for _, a := range start.Attr {
+					if a.Name.Local == finfo.name && (finfo.xmlns == "" || finfo.xmlns == a.Name.Space) {
+						if err := p.unmarshalAttr(strv, a); err != nil {
+							return err
+						}
+						break
+					}
+				}
+
+			case fCharData:
+				if !saveData.IsValid() {
+					saveData = finfo.value(sv)
+				}
+
+			case fComment:
+				if !saveComment.IsValid() {
+					saveComment = finfo.value(sv)
+				}
+
+			case fAny, fAny | fElement:
+				if !saveAny.IsValid() {
+					saveAny = finfo.value(sv)
+				}
+
+			case fInnerXml:
+				if !saveXML.IsValid() {
+					saveXML = finfo.value(sv)
+					if p.saved == nil {
+						saveXMLIndex = 0
+						p.saved = new(bytes.Buffer)
+					} else {
+						saveXMLIndex = p.savedOffset()
+					}
+				}
+			}
+		}
+	}
+
+	// Find end element.
+	// Process sub-elements along the way.
+Loop:
+	for {
+		var savedOffset int
+		if saveXML.IsValid() {
+			savedOffset = p.savedOffset()
+		}
+		tok, err := p.Token()
+		if err != nil {
+			return err
+		}
+		switch t := tok.(type) {
+		case StartElement:
+			consumed := false
+			if sv.IsValid() {
+				consumed, err = p.unmarshalPath(tinfo, sv, nil, &t)
+				if err != nil {
+					return err
+				}
+				if !consumed && saveAny.IsValid() {
+					consumed = true
+					if err := p.unmarshal(saveAny, &t); err != nil {
+						return err
+					}
+				}
+			}
+			if !consumed {
+				if err := p.Skip(); err != nil {
+					return err
+				}
+			}
+
+		case EndElement:
+			if saveXML.IsValid() {
+				saveXMLData = p.saved.Bytes()[saveXMLIndex:savedOffset]
+				if saveXMLIndex == 0 {
+					p.saved = nil
+				}
+			}
+			break Loop
+
+		case CharData:
+			if saveData.IsValid() {
+				data = append(data, t...)
+			}
+
+		case Comment:
+			if saveComment.IsValid() {
+				comment = append(comment, t...)
+			}
+		}
+	}
+
+	if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) {
+		if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
+			return err
+		}
+		saveData = reflect.Value{}
+	}
+
+	if saveData.IsValid() && saveData.CanAddr() {
+		pv := saveData.Addr()
+		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
+			if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
+				return err
+			}
+			saveData = reflect.Value{}
+		}
+	}
+
+	if err := copyValue(saveData, data); err != nil {
+		return err
+	}
+
+	switch t := saveComment; t.Kind() {
+	case reflect.String:
+		t.SetString(string(comment))
+	case reflect.Slice:
+		t.Set(reflect.ValueOf(comment))
+	}
+
+	switch t := saveXML; t.Kind() {
+	case reflect.String:
+		t.SetString(string(saveXMLData))
+	case reflect.Slice:
+		t.Set(reflect.ValueOf(saveXMLData))
+	}
+
+	return nil
+}
+
+func copyValue(dst reflect.Value, src []byte) (err error) {
+	dst0 := dst
+
+	if dst.Kind() == reflect.Ptr {
+		if dst.IsNil() {
+			dst.Set(reflect.New(dst.Type().Elem()))
+		}
+		dst = dst.Elem()
+	}
+
+	// Save accumulated data.
+	switch dst.Kind() {
+	case reflect.Invalid:
+		// Probably a comment.
+	default:
+		return errors.New("cannot unmarshal into " + dst0.Type().String())
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		itmp, err := strconv.ParseInt(string(src), 10, dst.Type().Bits())
+		if err != nil {
+			return err
+		}
+		dst.SetInt(itmp)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		var utmp uint64
+		if len(src) > 0 && src[0] == '-' {
+			// Negative value for unsigned field.
+			// Assume it was serialized following two's complement.
+			itmp, err := strconv.ParseInt(string(src), 10, dst.Type().Bits())
+			if err != nil {
+				return err
+			}
+			// Reinterpret value based on type width.
+			switch dst.Type().Bits() {
+			case 8:
+				utmp = uint64(uint8(itmp))
+			case 16:
+				utmp = uint64(uint16(itmp))
+			case 32:
+				utmp = uint64(uint32(itmp))
+			case 64:
+				utmp = uint64(uint64(itmp))
+			}
+		} else {
+			utmp, err = strconv.ParseUint(string(src), 10, dst.Type().Bits())
+			if err != nil {
+				return err
+			}
+		}
+		dst.SetUint(utmp)
+	case reflect.Float32, reflect.Float64:
+		ftmp, err := strconv.ParseFloat(string(src), dst.Type().Bits())
+		if err != nil {
+			return err
+		}
+		dst.SetFloat(ftmp)
+	case reflect.Bool:
+		value, err := strconv.ParseBool(strings.TrimSpace(string(src)))
+		if err != nil {
+			return err
+		}
+		dst.SetBool(value)
+	case reflect.String:
+		dst.SetString(string(src))
+	case reflect.Slice:
+		if len(src) == 0 {
+			// non-nil to flag presence
+			src = []byte{}
+		}
+		dst.SetBytes(src)
+	}
+	return nil
+}
+
+// unmarshalPath walks down an XML structure looking for wanted
+// paths, and calls unmarshal on them.
+// The consumed result tells whether XML elements have been consumed
+// from the Decoder until start's matching end element, or if it's
+// still untouched because start is uninteresting for sv's fields.
+func (p *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
+	recurse := false
+Loop:
+	for i := range tinfo.fields {
+		finfo := &tinfo.fields[i]
+		if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
+			continue
+		}
+		for j := range parents {
+			if parents[j] != finfo.parents[j] {
+				continue Loop
+			}
+		}
+		if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
+			// It's a perfect match, unmarshal the field.
+			return true, p.unmarshal(finfo.value(sv), start)
+		}
+		if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
+			// It's a prefix for the field. Break and recurse
+			// since it's not ok for one field path to be itself
+			// the prefix for another field path.
+			recurse = true
+
+			// We can reuse the same slice as long as we
+			// don't try to append to it.
+			parents = finfo.parents[:len(parents)+1]
+			break
+		}
+	}
+	if !recurse {
+		// We have no business with this element.
+		return false, nil
+	}
+	// The element is not a perfect match for any field, but one
+	// or more fields have the path to this element as a parent
+	// prefix. Recurse and attempt to match these.
+	for {
+		var tok Token
+		tok, err = p.Token()
+		if err != nil {
+			return true, err
+		}
+		switch t := tok.(type) {
+		case StartElement:
+			consumed2, err := p.unmarshalPath(tinfo, sv, parents, &t)
+			if err != nil {
+				return true, err
+			}
+			if !consumed2 {
+				if err := p.Skip(); err != nil {
+					return true, err
+				}
+			}
+		case EndElement:
+			return true, nil
+		}
+	}
+}
+
+// Skip reads tokens until it has consumed the end element
+// matching the most recent start element already consumed.
+// It recurs if it encounters a start element, so it can be used to
+// skip nested structures.
+// It returns nil if it finds an end element matching the start
+// element; otherwise it returns an error describing the problem.
+func (d *Decoder) Skip() error {
+	for {
+		tok, err := d.Token()
+		if err != nil {
+			return err
+		}
+		switch tok.(type) {
+		case StartElement:
+			if err := d.Skip(); err != nil {
+				return err
+			}
+		case EndElement:
+			return nil
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/xml/read_test.go

@@ -0,0 +1,762 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml
+
+import (
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Stripped down Atom feed data structures.
+
+func TestUnmarshalFeed(t *testing.T) {
+	var f Feed
+	if err := Unmarshal([]byte(atomFeedString), &f); err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+	if !reflect.DeepEqual(f, atomFeed) {
+		t.Fatalf("have %#v\nwant %#v", f, atomFeed)
+	}
+}
+
+// hget http://codereview.appspot.com/rss/mine/rsc
+const atomFeedString = `
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en-us" updated="2009-10-04T01:35:58+00:00"><title>Code Review - My issues</title><link href="http://codereview.appspot.com/" rel="alternate"></link><link href="http://codereview.appspot.com/rss/mine/rsc" rel="self"></link><id>http://codereview.appspot.com/</id><author><name>rietveld&lt;&gt;</name></author><entry><title>rietveld: an attempt at pubsubhubbub
+</title><link href="http://codereview.appspot.com/126085" rel="alternate"></link><updated>2009-10-04T01:35:58+00:00</updated><author><name>email-address-removed</name></author><id>urn:md5:134d9179c41f806be79b3a5f7877d19a</id><summary type="html">
+  An attempt at adding pubsubhubbub support to Rietveld.
+http://code.google.com/p/pubsubhubbub
+http://code.google.com/p/rietveld/issues/detail?id=155
+
+The server side of the protocol is trivial:
+  1. add a &amp;lt;link rel=&amp;quot;hub&amp;quot; href=&amp;quot;hub-server&amp;quot;&amp;gt; tag to all
+     feeds that will be pubsubhubbubbed.
+  2. every time one of those feeds changes, tell the hub
+     with a simple POST request.
+
+I have tested this by adding debug prints to a local hub
+server and checking that the server got the right publish
+requests.
+
+I can&amp;#39;t quite get the server to work, but I think the bug
+is not in my code.  I think that the server expects to be
+able to grab the feed and see the feed&amp;#39;s actual URL in
+the link rel=&amp;quot;self&amp;quot;, but the default value for that drops
+the :port from the URL, and I cannot for the life of me
+figure out how to get the Atom generator deep inside
+django not to do that, or even where it is doing that,
+or even what code is running to generate the Atom feed.
+(I thought I knew but I added some assert False statements
+and it kept running!)
+
+Ignoring that particular problem, I would appreciate
+feedback on the right way to get the two values at
+the top of feeds.py marked NOTE(rsc).
+
+
+</summary></entry><entry><title>rietveld: correct tab handling
+</title><link href="http://codereview.appspot.com/124106" rel="alternate"></link><updated>2009-10-03T23:02:17+00:00</updated><author><name>email-address-removed</name></author><id>urn:md5:0a2a4f19bb815101f0ba2904aed7c35a</id><summary type="html">
+  This fixes the buggy tab rendering that can be seen at
+http://codereview.appspot.com/116075/diff/1/2
+
+The fundamental problem was that the tab code was
+not being told what column the text began in, so it
+didn&amp;#39;t know where to put the tab stops.  Another problem
+was that some of the code assumed that string byte
+offsets were the same as column offsets, which is only
+true if there are no tabs.
+
+In the process of fixing this, I cleaned up the arguments
+to Fold and ExpandTabs and renamed them Break and
+_ExpandTabs so that I could be sure that I found all the
+call sites.  I also wanted to verify that ExpandTabs was
+not being used from outside intra_region_diff.py.
+
+
+</summary></entry></feed> 	   `
+
+type Feed struct {
+	XMLName Name      `xml:"http://www.w3.org/2005/Atom feed"`
+	Title   string    `xml:"title"`
+	Id      string    `xml:"id"`
+	Link    []Link    `xml:"link"`
+	Updated time.Time `xml:"updated,attr"`
+	Author  Person    `xml:"author"`
+	Entry   []Entry   `xml:"entry"`
+}
+
+type Entry struct {
+	Title   string    `xml:"title"`
+	Id      string    `xml:"id"`
+	Link    []Link    `xml:"link"`
+	Updated time.Time `xml:"updated"`
+	Author  Person    `xml:"author"`
+	Summary Text      `xml:"summary"`
+}
+
+type Link struct {
+	Rel  string `xml:"rel,attr,omitempty"`
+	Href string `xml:"href,attr"`
+}
+
+type Person struct {
+	Name     string `xml:"name"`
+	URI      string `xml:"uri"`
+	Email    string `xml:"email"`
+	InnerXML string `xml:",innerxml"`
+}
+
+type Text struct {
+	Type string `xml:"type,attr,omitempty"`
+	Body string `xml:",chardata"`
+}
+
+var atomFeed = Feed{
+	XMLName: Name{"http://www.w3.org/2005/Atom", "feed"},
+	Title:   "Code Review - My issues",
+	Link: []Link{
+		{Rel: "alternate", Href: "http://codereview.appspot.com/"},
+		{Rel: "self", Href: "http://codereview.appspot.com/rss/mine/rsc"},
+	},
+	Id:      "http://codereview.appspot.com/",
+	Updated: ParseTime("2009-10-04T01:35:58+00:00"),
+	Author: Person{
+		Name:     "rietveld<>",
+		InnerXML: "<name>rietveld&lt;&gt;</name>",
+	},
+	Entry: []Entry{
+		{
+			Title: "rietveld: an attempt at pubsubhubbub\n",
+			Link: []Link{
+				{Rel: "alternate", Href: "http://codereview.appspot.com/126085"},
+			},
+			Updated: ParseTime("2009-10-04T01:35:58+00:00"),
+			Author: Person{
+				Name:     "email-address-removed",
+				InnerXML: "<name>email-address-removed</name>",
+			},
+			Id: "urn:md5:134d9179c41f806be79b3a5f7877d19a",
+			Summary: Text{
+				Type: "html",
+				Body: `
+  An attempt at adding pubsubhubbub support to Rietveld.
+http://code.google.com/p/pubsubhubbub
+http://code.google.com/p/rietveld/issues/detail?id=155
+
+The server side of the protocol is trivial:
+  1. add a &lt;link rel=&quot;hub&quot; href=&quot;hub-server&quot;&gt; tag to all
+     feeds that will be pubsubhubbubbed.
+  2. every time one of those feeds changes, tell the hub
+     with a simple POST request.
+
+I have tested this by adding debug prints to a local hub
+server and checking that the server got the right publish
+requests.
+
+I can&#39;t quite get the server to work, but I think the bug
+is not in my code.  I think that the server expects to be
+able to grab the feed and see the feed&#39;s actual URL in
+the link rel=&quot;self&quot;, but the default value for that drops
+the :port from the URL, and I cannot for the life of me
+figure out how to get the Atom generator deep inside
+django not to do that, or even where it is doing that,
+or even what code is running to generate the Atom feed.
+(I thought I knew but I added some assert False statements
+and it kept running!)
+
+Ignoring that particular problem, I would appreciate
+feedback on the right way to get the two values at
+the top of feeds.py marked NOTE(rsc).
+
+
+`,
+			},
+		},
+		{
+			Title: "rietveld: correct tab handling\n",
+			Link: []Link{
+				{Rel: "alternate", Href: "http://codereview.appspot.com/124106"},
+			},
+			Updated: ParseTime("2009-10-03T23:02:17+00:00"),
+			Author: Person{
+				Name:     "email-address-removed",
+				InnerXML: "<name>email-address-removed</name>",
+			},
+			Id: "urn:md5:0a2a4f19bb815101f0ba2904aed7c35a",
+			Summary: Text{
+				Type: "html",
+				Body: `
+  This fixes the buggy tab rendering that can be seen at
+http://codereview.appspot.com/116075/diff/1/2
+
+The fundamental problem was that the tab code was
+not being told what column the text began in, so it
+didn&#39;t know where to put the tab stops.  Another problem
+was that some of the code assumed that string byte
+offsets were the same as column offsets, which is only
+true if there are no tabs.
+
+In the process of fixing this, I cleaned up the arguments
+to Fold and ExpandTabs and renamed them Break and
+_ExpandTabs so that I could be sure that I found all the
+call sites.  I also wanted to verify that ExpandTabs was
+not being used from outside intra_region_diff.py.
+
+
+`,
+			},
+		},
+	},
+}
+
+const pathTestString = `
+<Result>
+    <Before>1</Before>
+    <Items>
+        <Item1>
+            <Value>A</Value>
+        </Item1>
+        <Item2>
+            <Value>B</Value>
+        </Item2>
+        <Item1>
+            <Value>C</Value>
+            <Value>D</Value>
+        </Item1>
+        <_>
+            <Value>E</Value>
+        </_>
+    </Items>
+    <After>2</After>
+</Result>
+`
+
+type PathTestItem struct {
+	Value string
+}
+
+type PathTestA struct {
+	Items         []PathTestItem `xml:">Item1"`
+	Before, After string
+}
+
+type PathTestB struct {
+	Other         []PathTestItem `xml:"Items>Item1"`
+	Before, After string
+}
+
+type PathTestC struct {
+	Values1       []string `xml:"Items>Item1>Value"`
+	Values2       []string `xml:"Items>Item2>Value"`
+	Before, After string
+}
+
+type PathTestSet struct {
+	Item1 []PathTestItem
+}
+
+type PathTestD struct {
+	Other         PathTestSet `xml:"Items"`
+	Before, After string
+}
+
+type PathTestE struct {
+	Underline     string `xml:"Items>_>Value"`
+	Before, After string
+}
+
+var pathTests = []interface{}{
+	&PathTestA{Items: []PathTestItem{{"A"}, {"D"}}, Before: "1", After: "2"},
+	&PathTestB{Other: []PathTestItem{{"A"}, {"D"}}, Before: "1", After: "2"},
+	&PathTestC{Values1: []string{"A", "C", "D"}, Values2: []string{"B"}, Before: "1", After: "2"},
+	&PathTestD{Other: PathTestSet{Item1: []PathTestItem{{"A"}, {"D"}}}, Before: "1", After: "2"},
+	&PathTestE{Underline: "E", Before: "1", After: "2"},
+}
+
+func TestUnmarshalPaths(t *testing.T) {
+	for _, pt := range pathTests {
+		v := reflect.New(reflect.TypeOf(pt).Elem()).Interface()
+		if err := Unmarshal([]byte(pathTestString), v); err != nil {
+			t.Fatalf("Unmarshal: %s", err)
+		}
+		if !reflect.DeepEqual(v, pt) {
+			t.Fatalf("have %#v\nwant %#v", v, pt)
+		}
+	}
+}
+
+type BadPathTestA struct {
+	First  string `xml:"items>item1"`
+	Other  string `xml:"items>item2"`
+	Second string `xml:"items"`
+}
+
+type BadPathTestB struct {
+	Other  string `xml:"items>item2>value"`
+	First  string `xml:"items>item1"`
+	Second string `xml:"items>item1>value"`
+}
+
+type BadPathTestC struct {
+	First  string
+	Second string `xml:"First"`
+}
+
+type BadPathTestD struct {
+	BadPathEmbeddedA
+	BadPathEmbeddedB
+}
+
+type BadPathEmbeddedA struct {
+	First string
+}
+
+type BadPathEmbeddedB struct {
+	Second string `xml:"First"`
+}
+
+var badPathTests = []struct {
+	v, e interface{}
+}{
+	{&BadPathTestA{}, &TagPathError{reflect.TypeOf(BadPathTestA{}), "First", "items>item1", "Second", "items"}},
+	{&BadPathTestB{}, &TagPathError{reflect.TypeOf(BadPathTestB{}), "First", "items>item1", "Second", "items>item1>value"}},
+	{&BadPathTestC{}, &TagPathError{reflect.TypeOf(BadPathTestC{}), "First", "", "Second", "First"}},
+	{&BadPathTestD{}, &TagPathError{reflect.TypeOf(BadPathTestD{}), "First", "", "Second", "First"}},
+}
+
+func TestUnmarshalBadPaths(t *testing.T) {
+	for _, tt := range badPathTests {
+		err := Unmarshal([]byte(pathTestString), tt.v)
+		if !reflect.DeepEqual(err, tt.e) {
+			t.Fatalf("Unmarshal with %#v didn't fail properly:\nhave %#v,\nwant %#v", tt.v, err, tt.e)
+		}
+	}
+}
+
+const OK = "OK"
+const withoutNameTypeData = `
+<?xml version="1.0" charset="utf-8"?>
+<Test3 Attr="OK" />`
+
+type TestThree struct {
+	XMLName Name   `xml:"Test3"`
+	Attr    string `xml:",attr"`
+}
+
+func TestUnmarshalWithoutNameType(t *testing.T) {
+	var x TestThree
+	if err := Unmarshal([]byte(withoutNameTypeData), &x); err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+	if x.Attr != OK {
+		t.Fatalf("have %v\nwant %v", x.Attr, OK)
+	}
+}
+
+func TestUnmarshalAttr(t *testing.T) {
+	type ParamVal struct {
+		Int int `xml:"int,attr"`
+	}
+
+	type ParamPtr struct {
+		Int *int `xml:"int,attr"`
+	}
+
+	type ParamStringPtr struct {
+		Int *string `xml:"int,attr"`
+	}
+
+	x := []byte(`<Param int="1" />`)
+
+	p1 := &ParamPtr{}
+	if err := Unmarshal(x, p1); err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+	if p1.Int == nil {
+		t.Fatalf("Unmarshal failed in to *int field")
+	} else if *p1.Int != 1 {
+		t.Fatalf("Unmarshal with %s failed:\nhave %#v,\n want %#v", x, p1.Int, 1)
+	}
+
+	p2 := &ParamVal{}
+	if err := Unmarshal(x, p2); err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+	if p2.Int != 1 {
+		t.Fatalf("Unmarshal with %s failed:\nhave %#v,\n want %#v", x, p2.Int, 1)
+	}
+
+	p3 := &ParamStringPtr{}
+	if err := Unmarshal(x, p3); err != nil {
+		t.Fatalf("Unmarshal: %s", err)
+	}
+	if p3.Int == nil {
+		t.Fatalf("Unmarshal failed in to *string field")
+	} else if *p3.Int != "1" {
+		t.Fatalf("Unmarshal with %s failed:\nhave %#v,\n want %#v", x, p3.Int, 1)
+	}
+}
+
+type Tables struct {
+	HTable string `xml:"http://www.w3.org/TR/html4/ table"`
+	FTable string `xml:"http://www.w3schools.com/furniture table"`
+}
+
+var tables = []struct {
+	xml string
+	tab Tables
+	ns  string
+}{
+	{
+		xml: `<Tables>` +
+			`<table xmlns="http://www.w3.org/TR/html4/">hello</table>` +
+			`<table xmlns="http://www.w3schools.com/furniture">world</table>` +
+			`</Tables>`,
+		tab: Tables{"hello", "world"},
+	},
+	{
+		xml: `<Tables>` +
+			`<table xmlns="http://www.w3schools.com/furniture">world</table>` +
+			`<table xmlns="http://www.w3.org/TR/html4/">hello</table>` +
+			`</Tables>`,
+		tab: Tables{"hello", "world"},
+	},
+	{
+		xml: `<Tables xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/">` +
+			`<f:table>world</f:table>` +
+			`<h:table>hello</h:table>` +
+			`</Tables>`,
+		tab: Tables{"hello", "world"},
+	},
+	{
+		xml: `<Tables>` +
+			`<table>bogus</table>` +
+			`</Tables>`,
+		tab: Tables{},
+	},
+	{
+		xml: `<Tables>` +
+			`<table>only</table>` +
+			`</Tables>`,
+		tab: Tables{HTable: "only"},
+		ns:  "http://www.w3.org/TR/html4/",
+	},
+	{
+		xml: `<Tables>` +
+			`<table>only</table>` +
+			`</Tables>`,
+		tab: Tables{FTable: "only"},
+		ns:  "http://www.w3schools.com/furniture",
+	},
+	{
+		xml: `<Tables>` +
+			`<table>only</table>` +
+			`</Tables>`,
+		tab: Tables{},
+		ns:  "something else entirely",
+	},
+}
+
+func TestUnmarshalNS(t *testing.T) {
+	for i, tt := range tables {
+		var dst Tables
+		var err error
+		if tt.ns != "" {
+			d := NewDecoder(strings.NewReader(tt.xml))
+			d.DefaultSpace = tt.ns
+			err = d.Decode(&dst)
+		} else {
+			err = Unmarshal([]byte(tt.xml), &dst)
+		}
+		if err != nil {
+			t.Errorf("#%d: Unmarshal: %v", i, err)
+			continue
+		}
+		want := tt.tab
+		if dst != want {
+			t.Errorf("#%d: dst=%+v, want %+v", i, dst, want)
+		}
+	}
+}
+
+func TestMarshalNS(t *testing.T) {
+	dst := Tables{"hello", "world"}
+	data, err := Marshal(&dst)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	want := `<Tables><table xmlns="http://www.w3.org/TR/html4/">hello</table><table xmlns="http://www.w3schools.com/furniture">world</table></Tables>`
+	str := string(data)
+	if str != want {
+		t.Errorf("have: %q\nwant: %q\n", str, want)
+	}
+}
+
+type TableAttrs struct {
+	TAttr TAttr
+}
+
+type TAttr struct {
+	HTable string `xml:"http://www.w3.org/TR/html4/ table,attr"`
+	FTable string `xml:"http://www.w3schools.com/furniture table,attr"`
+	Lang   string `xml:"http://www.w3.org/XML/1998/namespace lang,attr,omitempty"`
+	Other1 string `xml:"http://golang.org/xml/ other,attr,omitempty"`
+	Other2 string `xml:"http://golang.org/xmlfoo/ other,attr,omitempty"`
+	Other3 string `xml:"http://golang.org/json/ other,attr,omitempty"`
+	Other4 string `xml:"http://golang.org/2/json/ other,attr,omitempty"`
+}
+
+var tableAttrs = []struct {
+	xml string
+	tab TableAttrs
+	ns  string
+}{
+	{
+		xml: `<TableAttrs xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/"><TAttr ` +
+			`h:table="hello" f:table="world" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}},
+	},
+	{
+		xml: `<TableAttrs><TAttr xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/" ` +
+			`h:table="hello" f:table="world" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}},
+	},
+	{
+		xml: `<TableAttrs><TAttr ` +
+			`h:table="hello" f:table="world" xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}},
+	},
+	{
+		// Default space does not apply to attribute names.
+		xml: `<TableAttrs xmlns="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/"><TAttr ` +
+			`h:table="hello" table="world" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "hello", FTable: ""}},
+	},
+	{
+		// Default space does not apply to attribute names.
+		xml: `<TableAttrs xmlns:f="http://www.w3schools.com/furniture"><TAttr xmlns="http://www.w3.org/TR/html4/" ` +
+			`table="hello" f:table="world" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "", FTable: "world"}},
+	},
+	{
+		xml: `<TableAttrs><TAttr ` +
+			`table="bogus" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{},
+	},
+	{
+		// Default space does not apply to attribute names.
+		xml: `<TableAttrs xmlns:h="http://www.w3.org/TR/html4/"><TAttr ` +
+			`h:table="hello" table="world" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "hello", FTable: ""}},
+		ns:  "http://www.w3schools.com/furniture",
+	},
+	{
+		// Default space does not apply to attribute names.
+		xml: `<TableAttrs xmlns:f="http://www.w3schools.com/furniture"><TAttr ` +
+			`table="hello" f:table="world" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{TAttr{HTable: "", FTable: "world"}},
+		ns:  "http://www.w3.org/TR/html4/",
+	},
+	{
+		xml: `<TableAttrs><TAttr ` +
+			`table="bogus" ` +
+			`/></TableAttrs>`,
+		tab: TableAttrs{},
+		ns:  "something else entirely",
+	},
+}
+
+func TestUnmarshalNSAttr(t *testing.T) {
+	for i, tt := range tableAttrs {
+		var dst TableAttrs
+		var err error
+		if tt.ns != "" {
+			d := NewDecoder(strings.NewReader(tt.xml))
+			d.DefaultSpace = tt.ns
+			err = d.Decode(&dst)
+		} else {
+			err = Unmarshal([]byte(tt.xml), &dst)
+		}
+		if err != nil {
+			t.Errorf("#%d: Unmarshal: %v", i, err)
+			continue
+		}
+		want := tt.tab
+		if dst != want {
+			t.Errorf("#%d: dst=%+v, want %+v", i, dst, want)
+		}
+	}
+}
+
+func TestMarshalNSAttr(t *testing.T) {
+	src := TableAttrs{TAttr{"hello", "world", "en_US", "other1", "other2", "other3", "other4"}}
+	data, err := Marshal(&src)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	want := `<TableAttrs><TAttr xmlns:html4="http://www.w3.org/TR/html4/" html4:table="hello" xmlns:furniture="http://www.w3schools.com/furniture" furniture:table="world" xml:lang="en_US" xmlns:_xml="http://golang.org/xml/" _xml:other="other1" xmlns:_xmlfoo="http://golang.org/xmlfoo/" _xmlfoo:other="other2" xmlns:json="http://golang.org/json/" json:other="other3" xmlns:json_1="http://golang.org/2/json/" json_1:other="other4"></TAttr></TableAttrs>`
+	str := string(data)
+	if str != want {
+		t.Errorf("Marshal:\nhave: %#q\nwant: %#q\n", str, want)
+	}
+
+	var dst TableAttrs
+	if err := Unmarshal(data, &dst); err != nil {
+		t.Errorf("Unmarshal: %v", err)
+	}
+
+	if dst != src {
+		t.Errorf("Unmarshal = %q, want %q", dst, src)
+	}
+}
+
+type MyCharData struct {
+	body string
+}
+
+func (m *MyCharData) UnmarshalXML(d *Decoder, start StartElement) error {
+	for {
+		t, err := d.Token()
+		if err == io.EOF { // found end of element
+			break
+		}
+		if err != nil {
+			return err
+		}
+		if char, ok := t.(CharData); ok {
+			m.body += string(char)
+		}
+	}
+	return nil
+}
+
+var _ Unmarshaler = (*MyCharData)(nil)
+
+func (m *MyCharData) UnmarshalXMLAttr(attr Attr) error {
+	panic("must not call")
+}
+
+type MyAttr struct {
+	attr string
+}
+
+func (m *MyAttr) UnmarshalXMLAttr(attr Attr) error {
+	m.attr = attr.Value
+	return nil
+}
+
+var _ UnmarshalerAttr = (*MyAttr)(nil)
+
+type MyStruct struct {
+	Data *MyCharData
+	Attr *MyAttr `xml:",attr"`
+
+	Data2 MyCharData
+	Attr2 MyAttr `xml:",attr"`
+}
+
+func TestUnmarshaler(t *testing.T) {
+	xml := `<?xml version="1.0" encoding="utf-8"?>
+		<MyStruct Attr="attr1" Attr2="attr2">
+		<Data>hello <!-- comment -->world</Data>
+		<Data2>howdy <!-- comment -->world</Data2>
+		</MyStruct>
+	`
+
+	var m MyStruct
+	if err := Unmarshal([]byte(xml), &m); err != nil {
+		t.Fatal(err)
+	}
+
+	if m.Data == nil || m.Attr == nil || m.Data.body != "hello world" || m.Attr.attr != "attr1" || m.Data2.body != "howdy world" || m.Attr2.attr != "attr2" {
+		t.Errorf("m=%#+v\n", m)
+	}
+}
+
+type Pea struct {
+	Cotelydon string
+}
+
+type Pod struct {
+	Pea interface{} `xml:"Pea"`
+}
+
+// https://code.google.com/p/go/issues/detail?id=6836
+func TestUnmarshalIntoInterface(t *testing.T) {
+	pod := new(Pod)
+	pod.Pea = new(Pea)
+	xml := `<Pod><Pea><Cotelydon>Green stuff</Cotelydon></Pea></Pod>`
+	err := Unmarshal([]byte(xml), pod)
+	if err != nil {
+		t.Fatalf("failed to unmarshal %q: %v", xml, err)
+	}
+	pea, ok := pod.Pea.(*Pea)
+	if !ok {
+		t.Fatalf("unmarshalled into wrong type: have %T want *Pea", pod.Pea)
+	}
+	have, want := pea.Cotelydon, "Green stuff"
+	if have != want {
+		t.Errorf("failed to unmarshal into interface, have %q want %q", have, want)
+	}
+}
+
+// https://github.com/vmware/govmomi/issues/246
+func TestNegativeValuesUnsignedFields(t *testing.T) {
+	type T struct {
+		I   string
+		O   interface{}
+		U8  uint8  `xml:"u8"`
+		U16 uint16 `xml:"u16"`
+		U32 uint32 `xml:"u32"`
+		U64 uint64 `xml:"u64"`
+	}
+
+	var tests = []T{
+		{I: "<T><u8>-128</u8></T>", O: uint8(0x80)},
+		{I: "<T><u8>-1</u8></T>", O: uint8(0xff)},
+		{I: "<T><u16>-32768</u16></T>", O: uint16(0x8000)},
+		{I: "<T><u16>-1</u16></T>", O: uint16(0xffff)},
+		{I: "<T><u32>-2147483648</u32></T>", O: uint32(0x80000000)},
+		{I: "<T><u32>-1</u32></T>", O: uint32(0xffffffff)},
+		{I: "<T><u64>-9223372036854775808</u64></T>", O: uint64(0x8000000000000000)},
+		{I: "<T><u64>-1</u64></T>", O: uint64(0xffffffffffffffff)},
+	}
+
+	for _, test := range tests {
+		err := Unmarshal([]byte(test.I), &test)
+		if err != nil {
+			t.Errorf("Unmarshal error: %v", err)
+			continue
+		}
+
+		var expected = test.O
+		var actual interface{}
+		switch reflect.ValueOf(test.O).Type().Kind() {
+		case reflect.Uint8:
+			actual = test.U8
+		case reflect.Uint16:
+			actual = test.U16
+		case reflect.Uint32:
+			actual = test.U32
+		case reflect.Uint64:
+			actual = test.U64
+		}
+
+		if !reflect.DeepEqual(actual, expected) {
+			t.Errorf("Actual: %v, expected: %v", actual, expected)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/vim25/xml/typeinfo.go

@@ -0,0 +1,366 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+)
+
+// typeInfo holds details for the xml representation of a type.
+type typeInfo struct {
+	xmlname *fieldInfo
+	fields  []fieldInfo
+}
+
+// fieldInfo holds details for the xml representation of a single field.
+type fieldInfo struct {
+	idx     []int
+	name    string
+	xmlns   string
+	flags   fieldFlags
+	parents []string
+}
+
+type fieldFlags int
+
+const (
+	fElement fieldFlags = 1 << iota
+	fAttr
+	fCharData
+	fInnerXml
+	fComment
+	fAny
+
+	fOmitEmpty
+	fTypeAttr
+
+	fMode = fElement | fAttr | fCharData | fInnerXml | fComment | fAny
+)
+
+var tinfoMap = make(map[reflect.Type]*typeInfo)
+var tinfoLock sync.RWMutex
+
+var nameType = reflect.TypeOf(Name{})
+
+// getTypeInfo returns the typeInfo structure with details necessary
+// for marshalling and unmarshalling typ.
+func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
+	tinfoLock.RLock()
+	tinfo, ok := tinfoMap[typ]
+	tinfoLock.RUnlock()
+	if ok {
+		return tinfo, nil
+	}
+	tinfo = &typeInfo{}
+	if typ.Kind() == reflect.Struct && typ != nameType {
+		n := typ.NumField()
+		for i := 0; i < n; i++ {
+			f := typ.Field(i)
+			if f.PkgPath != "" || f.Tag.Get("xml") == "-" {
+				continue // Private field
+			}
+
+			// For embedded structs, embed its fields.
+			if f.Anonymous {
+				t := f.Type
+				if t.Kind() == reflect.Ptr {
+					t = t.Elem()
+				}
+				if t.Kind() == reflect.Struct {
+					inner, err := getTypeInfo(t)
+					if err != nil {
+						return nil, err
+					}
+					if tinfo.xmlname == nil {
+						tinfo.xmlname = inner.xmlname
+					}
+					for _, finfo := range inner.fields {
+						finfo.idx = append([]int{i}, finfo.idx...)
+						if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
+							return nil, err
+						}
+					}
+					continue
+				}
+			}
+
+			finfo, err := structFieldInfo(typ, &f)
+			if err != nil {
+				return nil, err
+			}
+
+			if f.Name == "XMLName" {
+				tinfo.xmlname = finfo
+				continue
+			}
+
+			// Add the field if it doesn't conflict with other fields.
+			if err := addFieldInfo(typ, tinfo, finfo); err != nil {
+				return nil, err
+			}
+		}
+	}
+	tinfoLock.Lock()
+	tinfoMap[typ] = tinfo
+	tinfoLock.Unlock()
+	return tinfo, nil
+}
+
+// structFieldInfo builds and returns a fieldInfo for f.
+func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) {
+	finfo := &fieldInfo{idx: f.Index}
+
+	// Split the tag from the xml namespace if necessary.
+	tag := f.Tag.Get("xml")
+	if i := strings.Index(tag, " "); i >= 0 {
+		finfo.xmlns, tag = tag[:i], tag[i+1:]
+	}
+
+	// Parse flags.
+	tokens := strings.Split(tag, ",")
+	if len(tokens) == 1 {
+		finfo.flags = fElement
+	} else {
+		tag = tokens[0]
+		for _, flag := range tokens[1:] {
+			switch flag {
+			case "attr":
+				finfo.flags |= fAttr
+			case "chardata":
+				finfo.flags |= fCharData
+			case "innerxml":
+				finfo.flags |= fInnerXml
+			case "comment":
+				finfo.flags |= fComment
+			case "any":
+				finfo.flags |= fAny
+			case "omitempty":
+				finfo.flags |= fOmitEmpty
+			case "typeattr":
+				finfo.flags |= fTypeAttr
+			}
+		}
+
+		// Validate the flags used.
+		valid := true
+		switch mode := finfo.flags & fMode; mode {
+		case 0:
+			finfo.flags |= fElement
+		case fAttr, fCharData, fInnerXml, fComment, fAny:
+			if f.Name == "XMLName" || tag != "" && mode != fAttr {
+				valid = false
+			}
+		default:
+			// This will also catch multiple modes in a single field.
+			valid = false
+		}
+		if finfo.flags&fMode == fAny {
+			finfo.flags |= fElement
+		}
+		if finfo.flags&fOmitEmpty != 0 && finfo.flags&(fElement|fAttr) == 0 {
+			valid = false
+		}
+		if !valid {
+			return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q",
+				f.Name, typ, f.Tag.Get("xml"))
+		}
+	}
+
+	// Use of xmlns without a name is not allowed.
+	if finfo.xmlns != "" && tag == "" {
+		return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q",
+			f.Name, typ, f.Tag.Get("xml"))
+	}
+
+	if f.Name == "XMLName" {
+		// The XMLName field records the XML element name. Don't
+		// process it as usual because its name should default to
+		// empty rather than to the field name.
+		finfo.name = tag
+		return finfo, nil
+	}
+
+	if tag == "" {
+		// If the name part of the tag is completely empty, get
+		// default from XMLName of underlying struct if feasible,
+		// or field name otherwise.
+		if xmlname := lookupXMLName(f.Type); xmlname != nil {
+			finfo.xmlns, finfo.name = xmlname.xmlns, xmlname.name
+		} else {
+			finfo.name = f.Name
+		}
+		return finfo, nil
+	}
+
+	// Prepare field name and parents.
+	parents := strings.Split(tag, ">")
+	if parents[0] == "" {
+		parents[0] = f.Name
+	}
+	if parents[len(parents)-1] == "" {
+		return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ)
+	}
+	finfo.name = parents[len(parents)-1]
+	if len(parents) > 1 {
+		if (finfo.flags & fElement) == 0 {
+			return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))
+		}
+		finfo.parents = parents[:len(parents)-1]
+	}
+
+	// If the field type has an XMLName field, the names must match
+	// so that the behavior of both marshalling and unmarshalling
+	// is straightforward and unambiguous.
+	if finfo.flags&fElement != 0 {
+		ftyp := f.Type
+		xmlname := lookupXMLName(ftyp)
+		if xmlname != nil && xmlname.name != finfo.name {
+			return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName",
+				finfo.name, typ, f.Name, xmlname.name, ftyp)
+		}
+	}
+	return finfo, nil
+}
+
+// lookupXMLName returns the fieldInfo for typ's XMLName field
+// in case it exists and has a valid xml field tag, otherwise
+// it returns nil.
+func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
+	for typ.Kind() == reflect.Ptr {
+		typ = typ.Elem()
+	}
+	if typ.Kind() != reflect.Struct {
+		return nil
+	}
+	for i, n := 0, typ.NumField(); i < n; i++ {
+		f := typ.Field(i)
+		if f.Name != "XMLName" {
+			continue
+		}
+		finfo, err := structFieldInfo(typ, &f)
+		if finfo.name != "" && err == nil {
+			return finfo
+		}
+		// Also consider errors as a non-existent field tag
+		// and let getTypeInfo itself report the error.
+		break
+	}
+	return nil
+}
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+// addFieldInfo adds finfo to tinfo.fields if there are no
+// conflicts, or if conflicts arise from previous fields that were
+// obtained from deeper embedded structures than finfo. In the latter
+// case, the conflicting entries are dropped.
+// A conflict occurs when the path (parent + name) to a field is
+// itself a prefix of another path, or when two paths match exactly.
+// It is okay for field paths to share a common, shorter prefix.
+func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
+	var conflicts []int
+Loop:
+	// First, figure all conflicts. Most working code will have none.
+	for i := range tinfo.fields {
+		oldf := &tinfo.fields[i]
+		if oldf.flags&fMode != newf.flags&fMode {
+			continue
+		}
+		if oldf.xmlns != "" && newf.xmlns != "" && oldf.xmlns != newf.xmlns {
+			continue
+		}
+		minl := min(len(newf.parents), len(oldf.parents))
+		for p := 0; p < minl; p++ {
+			if oldf.parents[p] != newf.parents[p] {
+				continue Loop
+			}
+		}
+		if len(oldf.parents) > len(newf.parents) {
+			if oldf.parents[len(newf.parents)] == newf.name {
+				conflicts = append(conflicts, i)
+			}
+		} else if len(oldf.parents) < len(newf.parents) {
+			if newf.parents[len(oldf.parents)] == oldf.name {
+				conflicts = append(conflicts, i)
+			}
+		} else {
+			if newf.name == oldf.name {
+				conflicts = append(conflicts, i)
+			}
+		}
+	}
+	// Without conflicts, add the new field and return.
+	if conflicts == nil {
+		tinfo.fields = append(tinfo.fields, *newf)
+		return nil
+	}
+
+	// If any conflict is shallower, ignore the new field.
+	// This matches the Go field resolution on embedding.
+	for _, i := range conflicts {
+		if len(tinfo.fields[i].idx) < len(newf.idx) {
+			return nil
+		}
+	}
+
+	// Otherwise, if any of them is at the same depth level, it's an error.
+	for _, i := range conflicts {
+		oldf := &tinfo.fields[i]
+		if len(oldf.idx) == len(newf.idx) {
+			f1 := typ.FieldByIndex(oldf.idx)
+			f2 := typ.FieldByIndex(newf.idx)
+			return &TagPathError{typ, f1.Name, f1.Tag.Get("xml"), f2.Name, f2.Tag.Get("xml")}
+		}
+	}
+
+	// Otherwise, the new field is shallower, and thus takes precedence,
+	// so drop the conflicting fields from tinfo and append the new one.
+	for c := len(conflicts) - 1; c >= 0; c-- {
+		i := conflicts[c]
+		copy(tinfo.fields[i:], tinfo.fields[i+1:])
+		tinfo.fields = tinfo.fields[:len(tinfo.fields)-1]
+	}
+	tinfo.fields = append(tinfo.fields, *newf)
+	return nil
+}
+
+// A TagPathError represents an error in the unmarshalling process
+// caused by the use of field tags with conflicting paths.
+type TagPathError struct {
+	Struct       reflect.Type
+	Field1, Tag1 string
+	Field2, Tag2 string
+}
+
+func (e *TagPathError) Error() string {
+	return fmt.Sprintf("%s field %q with tag %q conflicts with field %q with tag %q", e.Struct, e.Field1, e.Tag1, e.Field2, e.Tag2)
+}
+
+// value returns v's field value corresponding to finfo.
+// It's equivalent to v.FieldByIndex(finfo.idx), but initializes
+// and dereferences pointers as necessary.
+func (finfo *fieldInfo) value(v reflect.Value) reflect.Value {
+	for i, x := range finfo.idx {
+		if i > 0 {
+			t := v.Type()
+			if t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct {
+				if v.IsNil() {
+					v.Set(reflect.New(v.Type().Elem()))
+				}
+				v = v.Elem()
+			}
+		}
+		v = v.Field(x)
+	}
+	return v
+}

vendor/github.com/vmware/govmomi/vim25/xml/xml_test.go

@@ -0,0 +1,726 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xml
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+	"unicode/utf8"
+)
+
+const testInput = `
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" ` +
+	"\r\n\t" + `  >
+  <hello lang="en">World &lt;&gt;&apos;&quot; &#x767d;&#40300;翔</hello>
+  <query>&何; &is-it;</query>
+  <goodbye />
+  <outer foo:attr="value" xmlns:tag="ns4">
+    <inner/>
+  </outer>
+  <tag:name>
+    <![CDATA[Some text here.]]>
+  </tag:name>
+</body><!-- missing final newline -->`
+
+var testEntity = map[string]string{"何": "What", "is-it": "is it?"}
+
+var rawTokens = []Token{
+	CharData("\n"),
+	ProcInst{"xml", []byte(`version="1.0" encoding="UTF-8"`)},
+	CharData("\n"),
+	Directive(`DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"`),
+	CharData("\n"),
+	StartElement{Name{"", "body"}, []Attr{{Name{"xmlns", "foo"}, "ns1"}, {Name{"", "xmlns"}, "ns2"}, {Name{"xmlns", "tag"}, "ns3"}}},
+	CharData("\n  "),
+	StartElement{Name{"", "hello"}, []Attr{{Name{"", "lang"}, "en"}}},
+	CharData("World <>'\" 白鵬翔"),
+	EndElement{Name{"", "hello"}},
+	CharData("\n  "),
+	StartElement{Name{"", "query"}, []Attr{}},
+	CharData("What is it?"),
+	EndElement{Name{"", "query"}},
+	CharData("\n  "),
+	StartElement{Name{"", "goodbye"}, []Attr{}},
+	EndElement{Name{"", "goodbye"}},
+	CharData("\n  "),
+	StartElement{Name{"", "outer"}, []Attr{{Name{"foo", "attr"}, "value"}, {Name{"xmlns", "tag"}, "ns4"}}},
+	CharData("\n    "),
+	StartElement{Name{"", "inner"}, []Attr{}},
+	EndElement{Name{"", "inner"}},
+	CharData("\n  "),
+	EndElement{Name{"", "outer"}},
+	CharData("\n  "),
+	StartElement{Name{"tag", "name"}, []Attr{}},
+	CharData("\n    "),
+	CharData("Some text here."),
+	CharData("\n  "),
+	EndElement{Name{"tag", "name"}},
+	CharData("\n"),
+	EndElement{Name{"", "body"}},
+	Comment(" missing final newline "),
+}
+
+var cookedTokens = []Token{
+	CharData("\n"),
+	ProcInst{"xml", []byte(`version="1.0" encoding="UTF-8"`)},
+	CharData("\n"),
+	Directive(`DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"`),
+	CharData("\n"),
+	StartElement{Name{"ns2", "body"}, []Attr{{Name{"xmlns", "foo"}, "ns1"}, {Name{"", "xmlns"}, "ns2"}, {Name{"xmlns", "tag"}, "ns3"}}},
+	CharData("\n  "),
+	StartElement{Name{"ns2", "hello"}, []Attr{{Name{"", "lang"}, "en"}}},
+	CharData("World <>'\" 白鵬翔"),
+	EndElement{Name{"ns2", "hello"}},
+	CharData("\n  "),
+	StartElement{Name{"ns2", "query"}, []Attr{}},
+	CharData("What is it?"),
+	EndElement{Name{"ns2", "query"}},
+	CharData("\n  "),
+	StartElement{Name{"ns2", "goodbye"}, []Attr{}},
+	EndElement{Name{"ns2", "goodbye"}},
+	CharData("\n  "),
+	StartElement{Name{"ns2", "outer"}, []Attr{{Name{"ns1", "attr"}, "value"}, {Name{"xmlns", "tag"}, "ns4"}}},
+	CharData("\n    "),
+	StartElement{Name{"ns2", "inner"}, []Attr{}},
+	EndElement{Name{"ns2", "inner"}},
+	CharData("\n  "),
+	EndElement{Name{"ns2", "outer"}},
+	CharData("\n  "),
+	StartElement{Name{"ns3", "name"}, []Attr{}},
+	CharData("\n    "),
+	CharData("Some text here."),
+	CharData("\n  "),
+	EndElement{Name{"ns3", "name"}},
+	CharData("\n"),
+	EndElement{Name{"ns2", "body"}},
+	Comment(" missing final newline "),
+}
+
+const testInputAltEncoding = `
+<?xml version="1.0" encoding="x-testing-uppercase"?>
+<TAG>VALUE</TAG>`
+
+var rawTokensAltEncoding = []Token{
+	CharData("\n"),
+	ProcInst{"xml", []byte(`version="1.0" encoding="x-testing-uppercase"`)},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("value"),
+	EndElement{Name{"", "tag"}},
+}
+
+var xmlInput = []string{
+	// unexpected EOF cases
+	"<",
+	"<t",
+	"<t ",
+	"<t/",
+	"<!",
+	"<!-",
+	"<!--",
+	"<!--c-",
+	"<!--c--",
+	"<!d",
+	"<t></",
+	"<t></t",
+	"<?",
+	"<?p",
+	"<t a",
+	"<t a=",
+	"<t a='",
+	"<t a=''",
+	"<t/><![",
+	"<t/><![C",
+	"<t/><![CDATA[d",
+	"<t/><![CDATA[d]",
+	"<t/><![CDATA[d]]",
+
+	// other Syntax errors
+	"<>",
+	"<t/a",
+	"<0 />",
+	"<?0 >",
+	//	"<!0 >",	// let the Token() caller handle
+	"</0>",
+	"<t 0=''>",
+	"<t a='&'>",
+	"<t a='<'>",
+	"<t>&nbspc;</t>",
+	"<t a>",
+	"<t a=>",
+	"<t a=v>",
+	//	"<![CDATA[d]]>",	// let the Token() caller handle
+	"<t></e>",
+	"<t></>",
+	"<t></t!",
+	"<t>cdata]]></t>",
+}
+
+func TestRawToken(t *testing.T) {
+	d := NewDecoder(strings.NewReader(testInput))
+	d.Entity = testEntity
+	testRawToken(t, d, rawTokens)
+}
+
+const nonStrictInput = `
+<tag>non&entity</tag>
+<tag>&unknown;entity</tag>
+<tag>&#123</tag>
+<tag>&#zzz;</tag>
+<tag>&なまえ3;</tag>
+<tag>&lt-gt;</tag>
+<tag>&;</tag>
+<tag>&0a;</tag>
+`
+
+var nonStringEntity = map[string]string{"": "oops!", "0a": "oops!"}
+
+var nonStrictTokens = []Token{
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("non&entity"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&unknown;entity"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&#123"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&#zzz;"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&なまえ3;"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&lt-gt;"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&;"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+	StartElement{Name{"", "tag"}, []Attr{}},
+	CharData("&0a;"),
+	EndElement{Name{"", "tag"}},
+	CharData("\n"),
+}
+
+func TestNonStrictRawToken(t *testing.T) {
+	d := NewDecoder(strings.NewReader(nonStrictInput))
+	d.Strict = false
+	testRawToken(t, d, nonStrictTokens)
+}
+
+type downCaser struct {
+	t *testing.T
+	r io.ByteReader
+}
+
+func (d *downCaser) ReadByte() (c byte, err error) {
+	c, err = d.r.ReadByte()
+	if c >= 'A' && c <= 'Z' {
+		c += 'a' - 'A'
+	}
+	return
+}
+
+func (d *downCaser) Read(p []byte) (int, error) {
+	d.t.Fatalf("unexpected Read call on downCaser reader")
+	panic("unreachable")
+}
+
+func TestRawTokenAltEncoding(t *testing.T) {
+	d := NewDecoder(strings.NewReader(testInputAltEncoding))
+	d.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) {
+		if charset != "x-testing-uppercase" {
+			t.Fatalf("unexpected charset %q", charset)
+		}
+		return &downCaser{t, input.(io.ByteReader)}, nil
+	}
+	testRawToken(t, d, rawTokensAltEncoding)
+}
+
+func TestRawTokenAltEncodingNoConverter(t *testing.T) {
+	d := NewDecoder(strings.NewReader(testInputAltEncoding))
+	token, err := d.RawToken()
+	if token == nil {
+		t.Fatalf("expected a token on first RawToken call")
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	token, err = d.RawToken()
+	if token != nil {
+		t.Errorf("expected a nil token; got %#v", token)
+	}
+	if err == nil {
+		t.Fatalf("expected an error on second RawToken call")
+	}
+	const encoding = "x-testing-uppercase"
+	if !strings.Contains(err.Error(), encoding) {
+		t.Errorf("expected error to contain %q; got error: %v",
+			encoding, err)
+	}
+}
+
+func testRawToken(t *testing.T, d *Decoder, rawTokens []Token) {
+	for i, want := range rawTokens {
+		have, err := d.RawToken()
+		if err != nil {
+			t.Fatalf("token %d: unexpected error: %s", i, err)
+		}
+		if !reflect.DeepEqual(have, want) {
+			var shave, swant string
+			if _, ok := have.(CharData); ok {
+				shave = fmt.Sprintf("CharData(%q)", have)
+			} else {
+				shave = fmt.Sprintf("%#v", have)
+			}
+			if _, ok := want.(CharData); ok {
+				swant = fmt.Sprintf("CharData(%q)", want)
+			} else {
+				swant = fmt.Sprintf("%#v", want)
+			}
+			t.Errorf("token %d = %s, want %s", i, shave, swant)
+		}
+	}
+}
+
+// Ensure that directives (specifically !DOCTYPE) include the complete
+// text of any nested directives, noting that < and > do not change
+// nesting depth if they are in single or double quotes.
+
+var nestedDirectivesInput = `
+<!DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]>
+<!DOCTYPE [<!ENTITY xlt ">">]>
+<!DOCTYPE [<!ENTITY xlt "<">]>
+<!DOCTYPE [<!ENTITY xlt '>'>]>
+<!DOCTYPE [<!ENTITY xlt '<'>]>
+<!DOCTYPE [<!ENTITY xlt '">'>]>
+<!DOCTYPE [<!ENTITY xlt "'<">]>
+`
+
+var nestedDirectivesTokens = []Token{
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY xlt ">">]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY xlt "<">]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY xlt '>'>]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY xlt '<'>]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY xlt '">'>]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY xlt "'<">]`),
+	CharData("\n"),
+}
+
+func TestNestedDirectives(t *testing.T) {
+	d := NewDecoder(strings.NewReader(nestedDirectivesInput))
+
+	for i, want := range nestedDirectivesTokens {
+		have, err := d.Token()
+		if err != nil {
+			t.Fatalf("token %d: unexpected error: %s", i, err)
+		}
+		if !reflect.DeepEqual(have, want) {
+			t.Errorf("token %d = %#v want %#v", i, have, want)
+		}
+	}
+}
+
+func TestToken(t *testing.T) {
+	d := NewDecoder(strings.NewReader(testInput))
+	d.Entity = testEntity
+
+	for i, want := range cookedTokens {
+		have, err := d.Token()
+		if err != nil {
+			t.Fatalf("token %d: unexpected error: %s", i, err)
+		}
+		if !reflect.DeepEqual(have, want) {
+			t.Errorf("token %d = %#v want %#v", i, have, want)
+		}
+	}
+}
+
+func TestSyntax(t *testing.T) {
+	for i := range xmlInput {
+		d := NewDecoder(strings.NewReader(xmlInput[i]))
+		var err error
+		for _, err = d.Token(); err == nil; _, err = d.Token() {
+		}
+		if _, ok := err.(*SyntaxError); !ok {
+			t.Fatalf(`xmlInput "%s": expected SyntaxError not received`, xmlInput[i])
+		}
+	}
+}
+
+type allScalars struct {
+	True1     bool
+	True2     bool
+	False1    bool
+	False2    bool
+	Int       int
+	Int8      int8
+	Int16     int16
+	Int32     int32
+	Int64     int64
+	Uint      int
+	Uint8     uint8
+	Uint16    uint16
+	Uint32    uint32
+	Uint64    uint64
+	Uintptr   uintptr
+	Float32   float32
+	Float64   float64
+	String    string
+	PtrString *string
+}
+
+var all = allScalars{
+	True1:     true,
+	True2:     true,
+	False1:    false,
+	False2:    false,
+	Int:       1,
+	Int8:      -2,
+	Int16:     3,
+	Int32:     -4,
+	Int64:     5,
+	Uint:      6,
+	Uint8:     7,
+	Uint16:    8,
+	Uint32:    9,
+	Uint64:    10,
+	Uintptr:   11,
+	Float32:   13.0,
+	Float64:   14.0,
+	String:    "15",
+	PtrString: &sixteen,
+}
+
+var sixteen = "16"
+
+const testScalarsInput = `<allscalars>
+	<True1>true</True1>
+	<True2>1</True2>
+	<False1>false</False1>
+	<False2>0</False2>
+	<Int>1</Int>
+	<Int8>-2</Int8>
+	<Int16>3</Int16>
+	<Int32>-4</Int32>
+	<Int64>5</Int64>
+	<Uint>6</Uint>
+	<Uint8>7</Uint8>
+	<Uint16>8</Uint16>
+	<Uint32>9</Uint32>
+	<Uint64>10</Uint64>
+	<Uintptr>11</Uintptr>
+	<Float>12.0</Float>
+	<Float32>13.0</Float32>
+	<Float64>14.0</Float64>
+	<String>15</String>
+	<PtrString>16</PtrString>
+</allscalars>`
+
+func TestAllScalars(t *testing.T) {
+	var a allScalars
+	err := Unmarshal([]byte(testScalarsInput), &a)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(a, all) {
+		t.Errorf("have %+v want %+v", a, all)
+	}
+}
+
+type item struct {
+	Field_a string
+}
+
+func TestIssue569(t *testing.T) {
+	data := `<item><Field_a>abcd</Field_a></item>`
+	var i item
+	err := Unmarshal([]byte(data), &i)
+
+	if err != nil || i.Field_a != "abcd" {
+		t.Fatal("Expecting abcd")
+	}
+}
+
+func TestUnquotedAttrs(t *testing.T) {
+	data := "<tag attr=azAZ09:-_\t>"
+	d := NewDecoder(strings.NewReader(data))
+	d.Strict = false
+	token, err := d.Token()
+	if _, ok := err.(*SyntaxError); ok {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if token.(StartElement).Name.Local != "tag" {
+		t.Errorf("Unexpected tag name: %v", token.(StartElement).Name.Local)
+	}
+	attr := token.(StartElement).Attr[0]
+	if attr.Value != "azAZ09:-_" {
+		t.Errorf("Unexpected attribute value: %v", attr.Value)
+	}
+	if attr.Name.Local != "attr" {
+		t.Errorf("Unexpected attribute name: %v", attr.Name.Local)
+	}
+}
+
+func TestValuelessAttrs(t *testing.T) {
+	tests := [][3]string{
+		{"<p nowrap>", "p", "nowrap"},
+		{"<p nowrap >", "p", "nowrap"},
+		{"<input checked/>", "input", "checked"},
+		{"<input checked />", "input", "checked"},
+	}
+	for _, test := range tests {
+		d := NewDecoder(strings.NewReader(test[0]))
+		d.Strict = false
+		token, err := d.Token()
+		if _, ok := err.(*SyntaxError); ok {
+			t.Errorf("Unexpected error: %v", err)
+		}
+		if token.(StartElement).Name.Local != test[1] {
+			t.Errorf("Unexpected tag name: %v", token.(StartElement).Name.Local)
+		}
+		attr := token.(StartElement).Attr[0]
+		if attr.Value != test[2] {
+			t.Errorf("Unexpected attribute value: %v", attr.Value)
+		}
+		if attr.Name.Local != test[2] {
+			t.Errorf("Unexpected attribute name: %v", attr.Name.Local)
+		}
+	}
+}
+
+func TestCopyTokenCharData(t *testing.T) {
+	data := []byte("same data")
+	var tok1 Token = CharData(data)
+	tok2 := CopyToken(tok1)
+	if !reflect.DeepEqual(tok1, tok2) {
+		t.Error("CopyToken(CharData) != CharData")
+	}
+	data[1] = 'o'
+	if reflect.DeepEqual(tok1, tok2) {
+		t.Error("CopyToken(CharData) uses same buffer.")
+	}
+}
+
+func TestCopyTokenStartElement(t *testing.T) {
+	elt := StartElement{Name{"", "hello"}, []Attr{{Name{"", "lang"}, "en"}}}
+	var tok1 Token = elt
+	tok2 := CopyToken(tok1)
+	if tok1.(StartElement).Attr[0].Value != "en" {
+		t.Error("CopyToken overwrote Attr[0]")
+	}
+	if !reflect.DeepEqual(tok1, tok2) {
+		t.Error("CopyToken(StartElement) != StartElement")
+	}
+	tok1.(StartElement).Attr[0] = Attr{Name{"", "lang"}, "de"}
+	if reflect.DeepEqual(tok1, tok2) {
+		t.Error("CopyToken(CharData) uses same buffer.")
+	}
+}
+
+func TestSyntaxErrorLineNum(t *testing.T) {
+	testInput := "<P>Foo<P>\n\n<P>Bar</>\n"
+	d := NewDecoder(strings.NewReader(testInput))
+	var err error
+	for _, err = d.Token(); err == nil; _, err = d.Token() {
+	}
+	synerr, ok := err.(*SyntaxError)
+	if !ok {
+		t.Error("Expected SyntaxError.")
+	}
+	if synerr.Line != 3 {
+		t.Error("SyntaxError didn't have correct line number.")
+	}
+}
+
+func TestTrailingRawToken(t *testing.T) {
+	input := `<FOO></FOO>  `
+	d := NewDecoder(strings.NewReader(input))
+	var err error
+	for _, err = d.RawToken(); err == nil; _, err = d.RawToken() {
+	}
+	if err != io.EOF {
+		t.Fatalf("d.RawToken() = _, %v, want _, io.EOF", err)
+	}
+}
+
+func TestTrailingToken(t *testing.T) {
+	input := `<FOO></FOO>  `
+	d := NewDecoder(strings.NewReader(input))
+	var err error
+	for _, err = d.Token(); err == nil; _, err = d.Token() {
+	}
+	if err != io.EOF {
+		t.Fatalf("d.Token() = _, %v, want _, io.EOF", err)
+	}
+}
+
+func TestEntityInsideCDATA(t *testing.T) {
+	input := `<test><![CDATA[ &val=foo ]]></test>`
+	d := NewDecoder(strings.NewReader(input))
+	var err error
+	for _, err = d.Token(); err == nil; _, err = d.Token() {
+	}
+	if err != io.EOF {
+		t.Fatalf("d.Token() = _, %v, want _, io.EOF", err)
+	}
+}
+
+var characterTests = []struct {
+	in  string
+	err string
+}{
+	{"\x12<doc/>", "illegal character code U+0012"},
+	{"<?xml version=\"1.0\"?>\x0b<doc/>", "illegal character code U+000B"},
+	{"\xef\xbf\xbe<doc/>", "illegal character code U+FFFE"},
+	{"<?xml version=\"1.0\"?><doc>\r\n<hiya/>\x07<toots/></doc>", "illegal character code U+0007"},
+	{"<?xml version=\"1.0\"?><doc \x12='value'>what's up</doc>", "expected attribute name in element"},
+	{"<doc>&abc\x01;</doc>", "invalid character entity &abc (no semicolon)"},
+	{"<doc>&\x01;</doc>", "invalid character entity & (no semicolon)"},
+	{"<doc>&\xef\xbf\xbe;</doc>", "invalid character entity &\uFFFE;"},
+	{"<doc>&hello;</doc>", "invalid character entity &hello;"},
+}
+
+func TestDisallowedCharacters(t *testing.T) {
+
+	for i, tt := range characterTests {
+		d := NewDecoder(strings.NewReader(tt.in))
+		var err error
+
+		for err == nil {
+			_, err = d.Token()
+		}
+		synerr, ok := err.(*SyntaxError)
+		if !ok {
+			t.Fatalf("input %d d.Token() = _, %v, want _, *SyntaxError", i, err)
+		}
+		if synerr.Msg != tt.err {
+			t.Fatalf("input %d synerr.Msg wrong: want %q, got %q", i, tt.err, synerr.Msg)
+		}
+	}
+}
+
+type procInstEncodingTest struct {
+	expect, got string
+}
+
+var procInstTests = []struct {
+	input, expect string
+}{
+	{`version="1.0" encoding="utf-8"`, "utf-8"},
+	{`version="1.0" encoding='utf-8'`, "utf-8"},
+	{`version="1.0" encoding='utf-8' `, "utf-8"},
+	{`version="1.0" encoding=utf-8`, ""},
+	{`encoding="FOO" `, "FOO"},
+}
+
+func TestProcInstEncoding(t *testing.T) {
+	for _, test := range procInstTests {
+		got := procInstEncoding(test.input)
+		if got != test.expect {
+			t.Errorf("procInstEncoding(%q) = %q; want %q", test.input, got, test.expect)
+		}
+	}
+}
+
+// Ensure that directives with comments include the complete
+// text of any nested directives.
+
+var directivesWithCommentsInput = `
+<!DOCTYPE [<!-- a comment --><!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]>
+<!DOCTYPE [<!ENTITY go "Golang"><!-- a comment-->]>
+<!DOCTYPE <!-> <!> <!----> <!-->--> <!--->--> [<!ENTITY go "Golang"><!-- a comment-->]>
+`
+
+var directivesWithCommentsTokens = []Token{
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]`),
+	CharData("\n"),
+	Directive(`DOCTYPE [<!ENTITY go "Golang">]`),
+	CharData("\n"),
+	Directive(`DOCTYPE <!-> <!>    [<!ENTITY go "Golang">]`),
+	CharData("\n"),
+}
+
+func TestDirectivesWithComments(t *testing.T) {
+	d := NewDecoder(strings.NewReader(directivesWithCommentsInput))
+
+	for i, want := range directivesWithCommentsTokens {
+		have, err := d.Token()
+		if err != nil {
+			t.Fatalf("token %d: unexpected error: %s", i, err)
+		}
+		if !reflect.DeepEqual(have, want) {
+			t.Errorf("token %d = %#v want %#v", i, have, want)
+		}
+	}
+}
+
+// Writer whose Write method always returns an error.
+type errWriter struct{}
+
+func (errWriter) Write(p []byte) (n int, err error) { return 0, fmt.Errorf("unwritable") }
+
+func TestEscapeTextIOErrors(t *testing.T) {
+	expectErr := "unwritable"
+	err := EscapeText(errWriter{}, []byte{'A'})
+
+	if err == nil || err.Error() != expectErr {
+		t.Errorf("have %v, want %v", err, expectErr)
+	}
+}
+
+func TestEscapeTextInvalidChar(t *testing.T) {
+	input := []byte("A \x00 terminated string.")
+	expected := "A \uFFFD terminated string."
+
+	buff := new(bytes.Buffer)
+	if err := EscapeText(buff, input); err != nil {
+		t.Fatalf("have %v, want nil", err)
+	}
+	text := buff.String()
+
+	if text != expected {
+		t.Errorf("have %v, want %v", text, expected)
+	}
+}
+
+func TestIssue5880(t *testing.T) {
+	type T []byte
+	data, err := Marshal(T{192, 168, 0, 1})
+	if err != nil {
+		t.Errorf("Marshal error: %v", err)
+	}
+	if !utf8.Valid(data) {
+		t.Errorf("Marshal generated invalid UTF-8: %x", data)
+	}
+}