source: vendor/current/source3/rpcclient/cmd_clusapi.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 12.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) GÃŒnther Deschner 2015
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22#include "rpcclient.h"
23#include "../librpc/gen_ndr/ndr_clusapi_c.h"
24
25static WERROR cmd_clusapi_open_cluster(struct rpc_pipe_client *cli,
26 TALLOC_CTX *mem_ctx,
27 int argc,
28 const char **argv)
29{
30 struct dcerpc_binding_handle *b = cli->binding_handle;
31 NTSTATUS status;
32 WERROR error;
33 struct policy_handle Cluster;
34
35 status = dcerpc_clusapi_OpenCluster(b, mem_ctx,
36 &error,
37 &Cluster);
38 if (!NT_STATUS_IS_OK(status)) {
39 return ntstatus_to_werror(status);
40 }
41
42 if (!W_ERROR_IS_OK(error)) {
43 printf("error: %s\n", win_errstr(error));
44 return error;
45 }
46
47 printf("successfully opened cluster\n");
48
49 status = dcerpc_clusapi_CloseCluster(b, mem_ctx,
50 &Cluster,
51 &error);
52 if (!NT_STATUS_IS_OK(status)) {
53 return ntstatus_to_werror(status);
54 }
55
56 if (!W_ERROR_IS_OK(error)) {
57 printf("error: %s\n", win_errstr(error));
58 return error;
59 }
60
61 printf("successfully closed cluster\n");
62
63 return WERR_OK;
64}
65
66static WERROR cmd_clusapi_get_cluster_name(struct rpc_pipe_client *cli,
67 TALLOC_CTX *mem_ctx,
68 int argc,
69 const char **argv)
70{
71 struct dcerpc_binding_handle *b = cli->binding_handle;
72 NTSTATUS status;
73 WERROR error;
74 const char *ClusterName;
75 const char *NodeName;
76
77 status = dcerpc_clusapi_GetClusterName(b, mem_ctx,
78 &ClusterName,
79 &NodeName,
80 &error);
81 if (!NT_STATUS_IS_OK(status)) {
82 return ntstatus_to_werror(status);
83 }
84
85 if (!W_ERROR_IS_OK(error)) {
86 printf("error: %s\n", win_errstr(error));
87 return error;
88 }
89
90 printf("ClusterName: %s\n", ClusterName);
91 printf("NodeName: %s\n", NodeName);
92
93 return WERR_OK;
94}
95
96static WERROR cmd_clusapi_get_cluster_version(struct rpc_pipe_client *cli,
97 TALLOC_CTX *mem_ctx,
98 int argc,
99 const char **argv)
100{
101 struct dcerpc_binding_handle *b = cli->binding_handle;
102 NTSTATUS status;
103 WERROR error;
104 uint16_t lpwMajorVersion;
105 uint16_t lpwMinorVersion;
106 uint16_t lpwBuildNumber;
107 const char *lpszVendorId;
108 const char *lpszCSDVersion;
109
110 status = dcerpc_clusapi_GetClusterVersion(b, mem_ctx,
111 &lpwMajorVersion,
112 &lpwMinorVersion,
113 &lpwBuildNumber,
114 &lpszVendorId,
115 &lpszCSDVersion,
116 &error);
117 if (!NT_STATUS_IS_OK(status)) {
118 return ntstatus_to_werror(status);
119 }
120
121 if (!W_ERROR_IS_OK(error)) {
122 printf("error: %s\n", win_errstr(error));
123 return error;
124 }
125
126 printf("lpwMajorVersion: %d\n", lpwMajorVersion);
127 printf("lpwMinorVersion: %d\n", lpwMinorVersion);
128 printf("lpwBuildNumber: %d\n", lpwBuildNumber);
129 printf("lpszVendorId: %s\n", lpszVendorId);
130 printf("lpszCSDVersion: %s\n", lpszCSDVersion);
131
132 return WERR_OK;
133}
134
135static WERROR cmd_clusapi_get_quorum_resource(struct rpc_pipe_client *cli,
136 TALLOC_CTX *mem_ctx,
137 int argc,
138 const char **argv)
139{
140 struct dcerpc_binding_handle *b = cli->binding_handle;
141 NTSTATUS status;
142 WERROR error;
143 const char *lpszResourceName;
144 const char *lpszDeviceName;
145 uint32_t pdwMaxQuorumLogSize;
146 WERROR rpc_status;
147
148 status = dcerpc_clusapi_GetQuorumResource(b, mem_ctx,
149 &lpszResourceName,
150 &lpszDeviceName,
151 &pdwMaxQuorumLogSize,
152 &rpc_status,
153 &error);
154 if (!NT_STATUS_IS_OK(status)) {
155 return ntstatus_to_werror(status);
156 }
157
158 if (!W_ERROR_IS_OK(error)) {
159 printf("error: %s\n", win_errstr(error));
160 return error;
161 }
162
163 printf("lpszResourceName: %s\n", lpszResourceName);
164 printf("lpszDeviceName: %s\n", lpszDeviceName);
165 printf("pdwMaxQuorumLogSize: %d\n", pdwMaxQuorumLogSize);
166 printf("rpc_status: %s\n", win_errstr(rpc_status));
167
168 return WERR_OK;
169}
170
171static WERROR cmd_clusapi_create_enum(struct rpc_pipe_client *cli,
172 TALLOC_CTX *mem_ctx,
173 int argc,
174 const char **argv)
175{
176 struct dcerpc_binding_handle *b = cli->binding_handle;
177 NTSTATUS status;
178 WERROR error;
179 uint32_t dwType = 1;
180 struct ENUM_LIST *ReturnEnum;
181 WERROR rpc_status;
182
183 if (argc >= 2) {
184 sscanf(argv[1],"%x",&dwType);
185 }
186
187 status = dcerpc_clusapi_CreateEnum(b, mem_ctx,
188 dwType,
189 &ReturnEnum,
190 &rpc_status,
191 &error);
192 if (!NT_STATUS_IS_OK(status)) {
193 return ntstatus_to_werror(status);
194 }
195
196 if (!W_ERROR_IS_OK(error)) {
197 printf("error: %s\n", win_errstr(error));
198 return error;
199 }
200
201 printf("rpc_status: %s\n", win_errstr(rpc_status));
202
203 return WERR_OK;
204}
205
206static WERROR cmd_clusapi_create_enumex(struct rpc_pipe_client *cli,
207 TALLOC_CTX *mem_ctx,
208 int argc,
209 const char **argv)
210{
211 struct dcerpc_binding_handle *b = cli->binding_handle;
212 NTSTATUS status;
213 WERROR error;
214 uint32_t dwType = 1;
215 struct ENUM_LIST *ReturnIdEnum;
216 struct ENUM_LIST *ReturnNameEnum;
217 WERROR rpc_status, ignore;
218 struct policy_handle Cluster;
219
220 status = dcerpc_clusapi_OpenCluster(b, mem_ctx,
221 &error,
222 &Cluster);
223 if (!NT_STATUS_IS_OK(status)) {
224 return ntstatus_to_werror(status);
225 }
226
227 if (!W_ERROR_IS_OK(error)) {
228 printf("error: %s\n", win_errstr(error));
229 return error;
230 }
231
232 if (argc >= 2) {
233 sscanf(argv[1],"%x",&dwType);
234 }
235
236 status = dcerpc_clusapi_CreateEnumEx(b, mem_ctx,
237 Cluster,
238 dwType,
239 0,
240 &ReturnIdEnum,
241 &ReturnNameEnum,
242 &rpc_status,
243 &error);
244 dcerpc_clusapi_CloseCluster(b, mem_ctx,
245 &Cluster,
246 &ignore);
247
248 if (!NT_STATUS_IS_OK(status)) {
249 return ntstatus_to_werror(status);
250 }
251
252 if (!W_ERROR_IS_OK(error)) {
253 printf("error: %s\n", win_errstr(error));
254 return error;
255 }
256
257 printf("rpc_status: %s\n", win_errstr(rpc_status));
258
259 return WERR_OK;
260}
261
262
263static WERROR cmd_clusapi_open_resource(struct rpc_pipe_client *cli,
264 TALLOC_CTX *mem_ctx,
265 int argc,
266 const char **argv)
267{
268 struct dcerpc_binding_handle *b = cli->binding_handle;
269 NTSTATUS status;
270 const char *lpszResourceName = "Cluster Name";
271 WERROR Status;
272 struct policy_handle hResource;
273 WERROR rpc_status, ignore;
274
275 if (argc >= 2) {
276 lpszResourceName = argv[1];
277 }
278
279 status = dcerpc_clusapi_OpenResource(b, mem_ctx,
280 lpszResourceName,
281 &Status,
282 &rpc_status,
283 &hResource);
284 if (!NT_STATUS_IS_OK(status)) {
285 return ntstatus_to_werror(status);
286 }
287
288 if (!W_ERROR_IS_OK(Status)) {
289 printf("Status: %s\n", win_errstr(Status));
290 return Status;
291 }
292
293 printf("rpc_status: %s\n", win_errstr(rpc_status));
294
295 dcerpc_clusapi_CloseResource(b, mem_ctx,
296 &hResource,
297 &ignore);
298
299 return WERR_OK;
300}
301
302static WERROR cmd_clusapi_online_resource(struct rpc_pipe_client *cli,
303 TALLOC_CTX *mem_ctx,
304 int argc,
305 const char **argv)
306{
307 struct dcerpc_binding_handle *b = cli->binding_handle;
308 NTSTATUS status;
309 const char *lpszResourceName = "Cluster Name";
310 WERROR Status;
311 struct policy_handle hResource;
312 WERROR rpc_status, ignore;
313
314 if (argc >= 2) {
315 lpszResourceName = argv[1];
316 }
317
318 status = dcerpc_clusapi_OpenResource(b, mem_ctx,
319 lpszResourceName,
320 &Status,
321 &rpc_status,
322 &hResource);
323 if (!NT_STATUS_IS_OK(status)) {
324 return ntstatus_to_werror(status);
325 }
326
327 if (!W_ERROR_IS_OK(Status)) {
328 printf("Status: %s\n", win_errstr(Status));
329 return Status;
330 }
331
332 status = dcerpc_clusapi_OnlineResource(b, mem_ctx,
333 hResource,
334 &Status,
335 &rpc_status);
336 dcerpc_clusapi_CloseResource(b, mem_ctx,
337 &hResource,
338 &ignore);
339
340 if (!NT_STATUS_IS_OK(status)) {
341 return ntstatus_to_werror(status);
342 }
343
344 if (!W_ERROR_IS_OK(Status)) {
345 printf("Status: %s\n", win_errstr(Status));
346 return Status;
347 }
348
349 printf("rpc_status: %s\n", win_errstr(rpc_status));
350
351 return WERR_OK;
352}
353
354static WERROR cmd_clusapi_offline_resource(struct rpc_pipe_client *cli,
355 TALLOC_CTX *mem_ctx,
356 int argc,
357 const char **argv)
358{
359 struct dcerpc_binding_handle *b = cli->binding_handle;
360 NTSTATUS status;
361 const char *lpszResourceName = "Cluster Name";
362 WERROR Status;
363 struct policy_handle hResource;
364 WERROR rpc_status, ignore;
365
366 if (argc >= 2) {
367 lpszResourceName = argv[1];
368 }
369
370 status = dcerpc_clusapi_OpenResource(b, mem_ctx,
371 lpszResourceName,
372 &Status,
373 &rpc_status,
374 &hResource);
375 if (!NT_STATUS_IS_OK(status)) {
376 return ntstatus_to_werror(status);
377 }
378
379 if (!W_ERROR_IS_OK(Status)) {
380 printf("Status: %s\n", win_errstr(Status));
381 return Status;
382 }
383
384 status = dcerpc_clusapi_OfflineResource(b, mem_ctx,
385 hResource,
386 &Status,
387 &rpc_status);
388 dcerpc_clusapi_CloseResource(b, mem_ctx,
389 &hResource,
390 &ignore);
391
392 if (!NT_STATUS_IS_OK(status)) {
393 return ntstatus_to_werror(status);
394 }
395
396 if (!W_ERROR_IS_OK(Status)) {
397 printf("Status: %s\n", win_errstr(Status));
398 return Status;
399 }
400
401 printf("rpc_status: %s\n", win_errstr(rpc_status));
402
403 return WERR_OK;
404}
405
406static WERROR cmd_clusapi_get_resource_state(struct rpc_pipe_client *cli,
407 TALLOC_CTX *mem_ctx,
408 int argc,
409 const char **argv)
410{
411 struct dcerpc_binding_handle *b = cli->binding_handle;
412 NTSTATUS status;
413 const char *lpszResourceName = "Cluster Name";
414 WERROR Status;
415 struct policy_handle hResource;
416 WERROR rpc_status;
417 enum clusapi_ClusterResourceState State;
418 const char *NodeName;
419 const char *GroupName;
420 WERROR result, ignore;
421
422 if (argc >= 2) {
423 lpszResourceName = argv[1];
424 }
425
426 status = dcerpc_clusapi_OpenResource(b, mem_ctx,
427 lpszResourceName,
428 &Status,
429 &rpc_status,
430 &hResource);
431 if (!NT_STATUS_IS_OK(status)) {
432 return ntstatus_to_werror(status);
433 }
434
435 if (!W_ERROR_IS_OK(Status)) {
436 printf("Status: %s\n", win_errstr(Status));
437 return Status;
438 }
439
440 status = dcerpc_clusapi_GetResourceState(b, mem_ctx,
441 hResource,
442 &State,
443 &NodeName,
444 &GroupName,
445 &rpc_status,
446 &result);
447 dcerpc_clusapi_CloseResource(b, mem_ctx,
448 &hResource,
449 &ignore);
450
451 if (!NT_STATUS_IS_OK(status)) {
452 return ntstatus_to_werror(status);
453 }
454
455 if (!W_ERROR_IS_OK(Status)) {
456 printf("Status: %s\n", win_errstr(Status));
457 return Status;
458 }
459
460 printf("rpc_status: %s\n", win_errstr(rpc_status));
461
462 return WERR_OK;
463}
464
465static WERROR cmd_clusapi_get_cluster_version2(struct rpc_pipe_client *cli,
466 TALLOC_CTX *mem_ctx,
467 int argc,
468 const char **argv)
469{
470 struct dcerpc_binding_handle *b = cli->binding_handle;
471 NTSTATUS status;
472 uint16_t lpwMajorVersion;
473 uint16_t lpwMinorVersion;
474 uint16_t lpwBuildNumber;
475 const char *lpszVendorId;
476 const char *lpszCSDVersion;
477 struct CLUSTER_OPERATIONAL_VERSION_INFO *ppClusterOpVerInfo;
478 WERROR rpc_status;
479 WERROR result;
480
481 status = dcerpc_clusapi_GetClusterVersion2(b, mem_ctx,
482 &lpwMajorVersion,
483 &lpwMinorVersion,
484 &lpwBuildNumber,
485 &lpszVendorId,
486 &lpszCSDVersion,
487 &ppClusterOpVerInfo,
488 &rpc_status,
489 &result);
490 if (!NT_STATUS_IS_OK(status)) {
491 return ntstatus_to_werror(status);
492 }
493
494 if (!W_ERROR_IS_OK(result)) {
495 printf("result: %s\n", win_errstr(result));
496 return result;
497 }
498
499 printf("rpc_status: %s\n", win_errstr(rpc_status));
500
501 return WERR_OK;
502}
503
504
505struct cmd_set clusapi_commands[] = {
506
507 { "CLUSAPI" },
508 { "clusapi_open_cluster", RPC_RTYPE_WERROR, NULL, cmd_clusapi_open_cluster, &ndr_table_clusapi, NULL, "bla", "" },
509 { "clusapi_get_cluster_name", RPC_RTYPE_WERROR, NULL, cmd_clusapi_get_cluster_name, &ndr_table_clusapi, NULL, "bla", "" },
510 { "clusapi_get_cluster_version", RPC_RTYPE_WERROR, NULL, cmd_clusapi_get_cluster_version, &ndr_table_clusapi, NULL, "bla", "" },
511 { "clusapi_get_quorum_resource", RPC_RTYPE_WERROR, NULL, cmd_clusapi_get_quorum_resource, &ndr_table_clusapi, NULL, "bla", "" },
512 { "clusapi_create_enum", RPC_RTYPE_WERROR, NULL, cmd_clusapi_create_enum, &ndr_table_clusapi, NULL, "bla", "" },
513 { "clusapi_create_enumex", RPC_RTYPE_WERROR, NULL, cmd_clusapi_create_enumex, &ndr_table_clusapi, NULL, "bla", "" },
514 { "clusapi_open_resource", RPC_RTYPE_WERROR, NULL, cmd_clusapi_open_resource, &ndr_table_clusapi, NULL, "bla", "" },
515 { "clusapi_online_resource", RPC_RTYPE_WERROR, NULL, cmd_clusapi_online_resource, &ndr_table_clusapi, NULL, "bla", "" },
516 { "clusapi_offline_resource", RPC_RTYPE_WERROR, NULL, cmd_clusapi_offline_resource, &ndr_table_clusapi, NULL, "bla", "" },
517 { "clusapi_get_resource_state", RPC_RTYPE_WERROR, NULL, cmd_clusapi_get_resource_state, &ndr_table_clusapi, NULL, "bla", "" },
518 { "clusapi_get_cluster_version2", RPC_RTYPE_WERROR, NULL, cmd_clusapi_get_cluster_version2, &ndr_table_clusapi, NULL, "bla", "" },
519 { NULL }
520};
Note: See TracBrowser for help on using the repository browser.