1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
package winrm
import (
"bytes"
"crypto/tls"
"crypto/x509"
"fmt"
"io"
"net/http"
"github.com/masterzen/winrm/soap"
)
type Client struct {
Parameters
username string
password string
useHTTPS bool
url string
http HttpPost
transport http.RoundTripper
}
// NewClient will create a new remote client on url, connecting with user and password
// This function doesn't connect (connection happens only when CreateShell is called)
func NewClient(endpoint *Endpoint, user, password string) (client *Client, err error) {
params := DefaultParameters()
client, err = NewClientWithParameters(endpoint, user, password, params)
return
}
// NewClient will create a new remote client on url, connecting with user and password
// This function doesn't connect (connection happens only when CreateShell is called)
func NewClientWithParameters(endpoint *Endpoint, user, password string, params *Parameters) (client *Client, err error) {
transport, err := newTransport(endpoint)
client = &Client{
Parameters: *params,
username: user,
password: password,
url: endpoint.url(),
http: Http_post,
useHTTPS: endpoint.HTTPS,
transport: transport,
}
if params.TransportDecorator != nil {
client.transport = params.TransportDecorator(transport)
}
return
}
// newTransport will create a new HTTP Transport, with options specified within the endpoint configuration
func newTransport(endpoint *Endpoint) (*http.Transport, error) {
transport := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: endpoint.Insecure,
},
}
if endpoint.CACert != nil && len(*endpoint.CACert) > 0 {
certPool, err := readCACerts(endpoint.CACert)
if err != nil {
return nil, err
}
transport.TLSClientConfig.RootCAs = certPool
}
return transport, nil
}
func readCACerts(certs *[]byte) (*x509.CertPool, error) {
certPool := x509.NewCertPool()
if !certPool.AppendCertsFromPEM(*certs) {
return nil, fmt.Errorf("Unable to read certificates")
}
return certPool, nil
}
// CreateShell will create a WinRM Shell, which is the prealable for running
// commands.
func (client *Client) CreateShell() (shell *Shell, err error) {
request := NewOpenShellRequest(client.url, &client.Parameters)
defer request.Free()
response, err := client.sendRequest(request)
if err == nil {
var shellId string
if shellId, err = ParseOpenShellResponse(response); err == nil {
shell = &Shell{client: client, ShellId: shellId}
}
}
return
}
// NewShell will create a new WinRM Shell for the given shellID
func (client *Client) NewShell(shellID string) *Shell {
return &Shell{client: client, ShellId: shellID}
}
func (client *Client) sendRequest(request *soap.SoapMessage) (response string, err error) {
return client.http(client, request)
}
// Run will run command on the the remote host, writing the process stdout and stderr to
// the given writers. Note with this method it isn't possible to inject stdin.
func (client *Client) Run(command string, stdout io.Writer, stderr io.Writer) (exitCode int, err error) {
shell, err := client.CreateShell()
if err != nil {
return 0, err
}
var cmd *Command
cmd, err = shell.Execute(command)
if err != nil {
return 0, err
}
go io.Copy(stdout, cmd.Stdout)
go io.Copy(stderr, cmd.Stderr)
cmd.Wait()
shell.Close()
return cmd.ExitCode(), cmd.err
}
// Run will run command on the the remote host, returning the process stdout and stderr
// as strings, and using the input stdin string as the process input
func (client *Client) RunWithString(command string, stdin string) (stdout string, stderr string, exitCode int, err error) {
shell, err := client.CreateShell()
if err != nil {
return "", "", 0, err
}
defer shell.Close()
var cmd *Command
cmd, err = shell.Execute(command)
if err != nil {
return "", "", 0, err
}
if len(stdin) > 0 {
cmd.Stdin.Write([]byte(stdin))
}
var outWriter, errWriter bytes.Buffer
go io.Copy(&outWriter, cmd.Stdout)
go io.Copy(&errWriter, cmd.Stderr)
cmd.Wait()
return outWriter.String(), errWriter.String(), cmd.ExitCode(), cmd.err
}
// Run will run command on the the remote host, writing the process stdout and stderr to
// the given writers, and injecting the process stdin with the stdin reader.
// Warning stdin (not stdout/stderr) are bufferized, which means reading only one byte in stdin will
// send a winrm http packet to the remote host. If stdin is a pipe, it might be better for
// performance reasons to buffer it.
func (client *Client) RunWithInput(command string, stdout io.Writer, stderr io.Writer, stdin io.Reader) (exitCode int, err error) {
shell, err := client.CreateShell()
if err != nil {
return 0, err
}
defer shell.Close()
var cmd *Command
cmd, err = shell.Execute(command)
if err != nil {
return 0, err
}
go io.Copy(cmd.Stdin, stdin)
go io.Copy(stdout, cmd.Stdout)
go io.Copy(stderr, cmd.Stderr)
cmd.Wait()
return cmd.ExitCode(), cmd.err
}
|
