Line data Source code
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 :
25 0 : static WERROR cmd_clusapi_open_cluster(struct rpc_pipe_client *cli,
26 : TALLOC_CTX *mem_ctx,
27 : int argc,
28 : const char **argv)
29 : {
30 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
31 : NTSTATUS status;
32 : WERROR error;
33 : struct policy_handle Cluster;
34 :
35 0 : status = dcerpc_clusapi_OpenCluster(b, mem_ctx,
36 : &error,
37 : &Cluster);
38 0 : if (!NT_STATUS_IS_OK(status)) {
39 0 : return ntstatus_to_werror(status);
40 : }
41 :
42 0 : if (!W_ERROR_IS_OK(error)) {
43 0 : printf("error: %s\n", win_errstr(error));
44 0 : return error;
45 : }
46 :
47 0 : printf("successfully opened cluster\n");
48 :
49 0 : status = dcerpc_clusapi_CloseCluster(b, mem_ctx,
50 : &Cluster,
51 : &error);
52 0 : if (!NT_STATUS_IS_OK(status)) {
53 0 : return ntstatus_to_werror(status);
54 : }
55 :
56 0 : if (!W_ERROR_IS_OK(error)) {
57 0 : printf("error: %s\n", win_errstr(error));
58 0 : return error;
59 : }
60 :
61 0 : printf("successfully closed cluster\n");
62 :
63 0 : return WERR_OK;
64 : }
65 :
66 0 : static 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 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
72 : NTSTATUS status;
73 : WERROR error;
74 : const char *ClusterName;
75 : const char *NodeName;
76 :
77 0 : status = dcerpc_clusapi_GetClusterName(b, mem_ctx,
78 : &ClusterName,
79 : &NodeName,
80 : &error);
81 0 : if (!NT_STATUS_IS_OK(status)) {
82 0 : return ntstatus_to_werror(status);
83 : }
84 :
85 0 : if (!W_ERROR_IS_OK(error)) {
86 0 : printf("error: %s\n", win_errstr(error));
87 0 : return error;
88 : }
89 :
90 0 : printf("ClusterName: %s\n", ClusterName);
91 0 : printf("NodeName: %s\n", NodeName);
92 :
93 0 : return WERR_OK;
94 : }
95 :
96 0 : static 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 0 : 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 0 : status = dcerpc_clusapi_GetClusterVersion(b, mem_ctx,
111 : &lpwMajorVersion,
112 : &lpwMinorVersion,
113 : &lpwBuildNumber,
114 : &lpszVendorId,
115 : &lpszCSDVersion,
116 : &error);
117 0 : if (!NT_STATUS_IS_OK(status)) {
118 0 : return ntstatus_to_werror(status);
119 : }
120 :
121 0 : if (!W_ERROR_IS_OK(error)) {
122 0 : printf("error: %s\n", win_errstr(error));
123 0 : return error;
124 : }
125 :
126 0 : printf("lpwMajorVersion: %d\n", lpwMajorVersion);
127 0 : printf("lpwMinorVersion: %d\n", lpwMinorVersion);
128 0 : printf("lpwBuildNumber: %d\n", lpwBuildNumber);
129 0 : printf("lpszVendorId: %s\n", lpszVendorId);
130 0 : printf("lpszCSDVersion: %s\n", lpszCSDVersion);
131 :
132 0 : return WERR_OK;
133 : }
134 :
135 0 : static 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 0 : 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 0 : status = dcerpc_clusapi_GetQuorumResource(b, mem_ctx,
149 : &lpszResourceName,
150 : &lpszDeviceName,
151 : &pdwMaxQuorumLogSize,
152 : &rpc_status,
153 : &error);
154 0 : if (!NT_STATUS_IS_OK(status)) {
155 0 : return ntstatus_to_werror(status);
156 : }
157 :
158 0 : if (!W_ERROR_IS_OK(error)) {
159 0 : printf("error: %s\n", win_errstr(error));
160 0 : return error;
161 : }
162 :
163 0 : printf("lpszResourceName: %s\n", lpszResourceName);
164 0 : printf("lpszDeviceName: %s\n", lpszDeviceName);
165 0 : printf("pdwMaxQuorumLogSize: %d\n", pdwMaxQuorumLogSize);
166 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
167 :
168 0 : return WERR_OK;
169 : }
170 :
171 0 : static WERROR cmd_clusapi_create_enum(struct rpc_pipe_client *cli,
172 : TALLOC_CTX *mem_ctx,
173 : int argc,
174 : const char **argv)
175 : {
176 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
177 : NTSTATUS status;
178 : WERROR error;
179 0 : uint32_t dwType = 1;
180 : struct ENUM_LIST *ReturnEnum;
181 : WERROR rpc_status;
182 :
183 0 : if (argc >= 2) {
184 0 : sscanf(argv[1],"%x",&dwType);
185 : }
186 :
187 0 : status = dcerpc_clusapi_CreateEnum(b, mem_ctx,
188 : dwType,
189 : &ReturnEnum,
190 : &rpc_status,
191 : &error);
192 0 : if (!NT_STATUS_IS_OK(status)) {
193 0 : return ntstatus_to_werror(status);
194 : }
195 :
196 0 : if (!W_ERROR_IS_OK(error)) {
197 0 : printf("error: %s\n", win_errstr(error));
198 0 : return error;
199 : }
200 :
201 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
202 :
203 0 : return WERR_OK;
204 : }
205 :
206 0 : static WERROR cmd_clusapi_create_enumex(struct rpc_pipe_client *cli,
207 : TALLOC_CTX *mem_ctx,
208 : int argc,
209 : const char **argv)
210 : {
211 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
212 : NTSTATUS status;
213 : WERROR error;
214 0 : 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 0 : status = dcerpc_clusapi_OpenCluster(b, mem_ctx,
221 : &error,
222 : &Cluster);
223 0 : if (!NT_STATUS_IS_OK(status)) {
224 0 : return ntstatus_to_werror(status);
225 : }
226 :
227 0 : if (!W_ERROR_IS_OK(error)) {
228 0 : printf("error: %s\n", win_errstr(error));
229 0 : return error;
230 : }
231 :
232 0 : if (argc >= 2) {
233 0 : sscanf(argv[1],"%x",&dwType);
234 : }
235 :
236 0 : status = dcerpc_clusapi_CreateEnumEx(b, mem_ctx,
237 : Cluster,
238 : dwType,
239 : 0,
240 : &ReturnIdEnum,
241 : &ReturnNameEnum,
242 : &rpc_status,
243 : &error);
244 0 : dcerpc_clusapi_CloseCluster(b, mem_ctx,
245 : &Cluster,
246 : &ignore);
247 :
248 0 : if (!NT_STATUS_IS_OK(status)) {
249 0 : return ntstatus_to_werror(status);
250 : }
251 :
252 0 : if (!W_ERROR_IS_OK(error)) {
253 0 : printf("error: %s\n", win_errstr(error));
254 0 : return error;
255 : }
256 :
257 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
258 :
259 0 : return WERR_OK;
260 : }
261 :
262 :
263 0 : static WERROR cmd_clusapi_open_resource(struct rpc_pipe_client *cli,
264 : TALLOC_CTX *mem_ctx,
265 : int argc,
266 : const char **argv)
267 : {
268 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
269 : NTSTATUS status;
270 0 : const char *lpszResourceName = "Cluster Name";
271 : WERROR Status;
272 : struct policy_handle hResource;
273 : WERROR rpc_status, ignore;
274 :
275 0 : if (argc >= 2) {
276 0 : lpszResourceName = argv[1];
277 : }
278 :
279 0 : status = dcerpc_clusapi_OpenResource(b, mem_ctx,
280 : lpszResourceName,
281 : &Status,
282 : &rpc_status,
283 : &hResource);
284 0 : if (!NT_STATUS_IS_OK(status)) {
285 0 : return ntstatus_to_werror(status);
286 : }
287 :
288 0 : if (!W_ERROR_IS_OK(Status)) {
289 0 : printf("Status: %s\n", win_errstr(Status));
290 0 : return Status;
291 : }
292 :
293 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
294 :
295 0 : dcerpc_clusapi_CloseResource(b, mem_ctx,
296 : &hResource,
297 : &ignore);
298 :
299 0 : return WERR_OK;
300 : }
301 :
302 0 : static WERROR cmd_clusapi_online_resource(struct rpc_pipe_client *cli,
303 : TALLOC_CTX *mem_ctx,
304 : int argc,
305 : const char **argv)
306 : {
307 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
308 : NTSTATUS status;
309 0 : const char *lpszResourceName = "Cluster Name";
310 : WERROR Status;
311 : struct policy_handle hResource;
312 : WERROR rpc_status, ignore;
313 :
314 0 : if (argc >= 2) {
315 0 : lpszResourceName = argv[1];
316 : }
317 :
318 0 : status = dcerpc_clusapi_OpenResource(b, mem_ctx,
319 : lpszResourceName,
320 : &Status,
321 : &rpc_status,
322 : &hResource);
323 0 : if (!NT_STATUS_IS_OK(status)) {
324 0 : return ntstatus_to_werror(status);
325 : }
326 :
327 0 : if (!W_ERROR_IS_OK(Status)) {
328 0 : printf("Status: %s\n", win_errstr(Status));
329 0 : return Status;
330 : }
331 :
332 0 : status = dcerpc_clusapi_OnlineResource(b, mem_ctx,
333 : hResource,
334 : &Status,
335 : &rpc_status);
336 0 : dcerpc_clusapi_CloseResource(b, mem_ctx,
337 : &hResource,
338 : &ignore);
339 :
340 0 : if (!NT_STATUS_IS_OK(status)) {
341 0 : return ntstatus_to_werror(status);
342 : }
343 :
344 0 : if (!W_ERROR_IS_OK(Status)) {
345 0 : printf("Status: %s\n", win_errstr(Status));
346 0 : return Status;
347 : }
348 :
349 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
350 :
351 0 : return WERR_OK;
352 : }
353 :
354 0 : static WERROR cmd_clusapi_offline_resource(struct rpc_pipe_client *cli,
355 : TALLOC_CTX *mem_ctx,
356 : int argc,
357 : const char **argv)
358 : {
359 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
360 : NTSTATUS status;
361 0 : const char *lpszResourceName = "Cluster Name";
362 : WERROR Status;
363 : struct policy_handle hResource;
364 : WERROR rpc_status, ignore;
365 :
366 0 : if (argc >= 2) {
367 0 : lpszResourceName = argv[1];
368 : }
369 :
370 0 : status = dcerpc_clusapi_OpenResource(b, mem_ctx,
371 : lpszResourceName,
372 : &Status,
373 : &rpc_status,
374 : &hResource);
375 0 : if (!NT_STATUS_IS_OK(status)) {
376 0 : return ntstatus_to_werror(status);
377 : }
378 :
379 0 : if (!W_ERROR_IS_OK(Status)) {
380 0 : printf("Status: %s\n", win_errstr(Status));
381 0 : return Status;
382 : }
383 :
384 0 : status = dcerpc_clusapi_OfflineResource(b, mem_ctx,
385 : hResource,
386 : &Status,
387 : &rpc_status);
388 0 : dcerpc_clusapi_CloseResource(b, mem_ctx,
389 : &hResource,
390 : &ignore);
391 :
392 0 : if (!NT_STATUS_IS_OK(status)) {
393 0 : return ntstatus_to_werror(status);
394 : }
395 :
396 0 : if (!W_ERROR_IS_OK(Status)) {
397 0 : printf("Status: %s\n", win_errstr(Status));
398 0 : return Status;
399 : }
400 :
401 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
402 :
403 0 : return WERR_OK;
404 : }
405 :
406 0 : static 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 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
412 : NTSTATUS status;
413 0 : 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 0 : if (argc >= 2) {
423 0 : lpszResourceName = argv[1];
424 : }
425 :
426 0 : status = dcerpc_clusapi_OpenResource(b, mem_ctx,
427 : lpszResourceName,
428 : &Status,
429 : &rpc_status,
430 : &hResource);
431 0 : if (!NT_STATUS_IS_OK(status)) {
432 0 : return ntstatus_to_werror(status);
433 : }
434 :
435 0 : if (!W_ERROR_IS_OK(Status)) {
436 0 : printf("Status: %s\n", win_errstr(Status));
437 0 : return Status;
438 : }
439 :
440 0 : status = dcerpc_clusapi_GetResourceState(b, mem_ctx,
441 : hResource,
442 : &State,
443 : &NodeName,
444 : &GroupName,
445 : &rpc_status,
446 : &result);
447 0 : dcerpc_clusapi_CloseResource(b, mem_ctx,
448 : &hResource,
449 : &ignore);
450 :
451 0 : if (!NT_STATUS_IS_OK(status)) {
452 0 : return ntstatus_to_werror(status);
453 : }
454 :
455 0 : if (!W_ERROR_IS_OK(Status)) {
456 0 : printf("Status: %s\n", win_errstr(Status));
457 0 : return Status;
458 : }
459 :
460 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
461 :
462 0 : return WERR_OK;
463 : }
464 :
465 0 : static 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 0 : 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 0 : 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 0 : if (!NT_STATUS_IS_OK(status)) {
491 0 : return ntstatus_to_werror(status);
492 : }
493 :
494 0 : if (!W_ERROR_IS_OK(result)) {
495 0 : printf("result: %s\n", win_errstr(result));
496 0 : return result;
497 : }
498 :
499 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
500 :
501 0 : return WERR_OK;
502 : }
503 :
504 0 : static WERROR cmd_clusapi_pause_node(struct rpc_pipe_client *cli,
505 : TALLOC_CTX *mem_ctx,
506 : int argc,
507 : const char **argv)
508 : {
509 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
510 : NTSTATUS status;
511 0 : const char *lpszNodeName = "CTDB_NODE_0";
512 : WERROR Status;
513 : struct policy_handle hNode;
514 : WERROR rpc_status;
515 : WERROR result, ignore;
516 :
517 0 : if (argc >= 2) {
518 0 : lpszNodeName = argv[1];
519 : }
520 :
521 0 : status = dcerpc_clusapi_OpenNode(b, mem_ctx,
522 : lpszNodeName,
523 : &Status,
524 : &rpc_status,
525 : &hNode);
526 0 : if (!NT_STATUS_IS_OK(status)) {
527 0 : return ntstatus_to_werror(status);
528 : }
529 :
530 0 : if (!W_ERROR_IS_OK(Status)) {
531 0 : printf("Failed to open node %s\n", lpszNodeName);
532 0 : printf("Status: %s\n", win_errstr(Status));
533 0 : return Status;
534 : }
535 :
536 0 : status = dcerpc_clusapi_PauseNode(b, mem_ctx,
537 : hNode,
538 : &rpc_status,
539 : &result);
540 0 : if (!NT_STATUS_IS_OK(status)) {
541 0 : return ntstatus_to_werror(status);
542 : }
543 0 : if (!W_ERROR_IS_OK(result)) {
544 0 : printf("Failed to pause node %s\n", lpszNodeName);
545 0 : printf("Status: %s\n", win_errstr(result));
546 0 : return result;
547 : }
548 :
549 0 : dcerpc_clusapi_CloseNode(b, mem_ctx,
550 : &hNode,
551 : &ignore);
552 :
553 0 : printf("Cluster node %s has been paused\n", lpszNodeName);
554 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
555 :
556 0 : return WERR_OK;
557 : }
558 :
559 0 : static WERROR cmd_clusapi_resume_node(struct rpc_pipe_client *cli,
560 : TALLOC_CTX *mem_ctx,
561 : int argc,
562 : const char **argv)
563 : {
564 0 : struct dcerpc_binding_handle *b = cli->binding_handle;
565 : NTSTATUS status;
566 0 : const char *lpszNodeName = "CTDB_NODE_0";
567 : WERROR Status;
568 : struct policy_handle hNode;
569 : WERROR rpc_status;
570 : WERROR result, ignore;
571 :
572 0 : if (argc >= 2) {
573 0 : lpszNodeName = argv[1];
574 : }
575 :
576 0 : status = dcerpc_clusapi_OpenNode(b, mem_ctx,
577 : lpszNodeName,
578 : &Status,
579 : &rpc_status,
580 : &hNode);
581 0 : if (!NT_STATUS_IS_OK(status)) {
582 0 : return ntstatus_to_werror(status);
583 : }
584 :
585 0 : if (!W_ERROR_IS_OK(Status)) {
586 0 : printf("Failed to open node %s\n", lpszNodeName);
587 0 : printf("Status: %s\n", win_errstr(Status));
588 0 : return Status;
589 : }
590 :
591 0 : status = dcerpc_clusapi_ResumeNode(b, mem_ctx,
592 : hNode,
593 : &rpc_status,
594 : &result);
595 0 : if (!NT_STATUS_IS_OK(status)) {
596 0 : return ntstatus_to_werror(status);
597 : }
598 0 : if (!W_ERROR_IS_OK(result)) {
599 0 : printf("Failed to resume node %s\n", lpszNodeName);
600 0 : printf("Status: %s\n", win_errstr(result));
601 0 : return result;
602 : }
603 :
604 0 : dcerpc_clusapi_CloseNode(b, mem_ctx,
605 : &hNode,
606 : &ignore);
607 :
608 0 : printf("Cluster node %s has been resumed\n", lpszNodeName);
609 0 : printf("rpc_status: %s\n", win_errstr(rpc_status));
610 :
611 0 : return WERR_OK;
612 : }
613 :
614 :
615 : struct cmd_set clusapi_commands[] = {
616 :
617 : {
618 : .name = "CLUSAPI",
619 : },
620 : {
621 : .name = "clusapi_open_cluster",
622 : .returntype = RPC_RTYPE_WERROR,
623 : .ntfn = NULL,
624 : .wfn = cmd_clusapi_open_cluster,
625 : .table = &ndr_table_clusapi,
626 : .rpc_pipe = NULL,
627 : .description = "Open cluster",
628 : .usage = "",
629 : },
630 : {
631 : .name = "clusapi_get_cluster_name",
632 : .returntype = RPC_RTYPE_WERROR,
633 : .ntfn = NULL,
634 : .wfn = cmd_clusapi_get_cluster_name,
635 : .table = &ndr_table_clusapi,
636 : .rpc_pipe = NULL,
637 : .description = "Get cluster name",
638 : .usage = "",
639 : },
640 : {
641 : .name = "clusapi_get_cluster_version",
642 : .returntype = RPC_RTYPE_WERROR,
643 : .ntfn = NULL,
644 : .wfn = cmd_clusapi_get_cluster_version,
645 : .table = &ndr_table_clusapi,
646 : .rpc_pipe = NULL,
647 : .description = "Get cluster version",
648 : .usage = "",
649 : },
650 : {
651 : .name = "clusapi_get_quorum_resource",
652 : .returntype = RPC_RTYPE_WERROR,
653 : .ntfn = NULL,
654 : .wfn = cmd_clusapi_get_quorum_resource,
655 : .table = &ndr_table_clusapi,
656 : .rpc_pipe = NULL,
657 : .description = "Get quorum resource",
658 : .usage = "",
659 : },
660 : {
661 : .name = "clusapi_create_enum",
662 : .returntype = RPC_RTYPE_WERROR,
663 : .ntfn = NULL,
664 : .wfn = cmd_clusapi_create_enum,
665 : .table = &ndr_table_clusapi,
666 : .rpc_pipe = NULL,
667 : .description = "Create enum query",
668 : .usage = "",
669 : },
670 : {
671 : .name = "clusapi_create_enumex",
672 : .returntype = RPC_RTYPE_WERROR,
673 : .ntfn = NULL,
674 : .wfn = cmd_clusapi_create_enumex,
675 : .table = &ndr_table_clusapi,
676 : .rpc_pipe = NULL,
677 : .description = "Create enumex query",
678 : .usage = "",
679 : },
680 : {
681 : .name = "clusapi_open_resource",
682 : .returntype = RPC_RTYPE_WERROR,
683 : .ntfn = NULL,
684 : .wfn = cmd_clusapi_open_resource,
685 : .table = &ndr_table_clusapi,
686 : .rpc_pipe = NULL,
687 : .description = "Open cluster resource",
688 : .usage = "",
689 : },
690 : {
691 : .name = "clusapi_online_resource",
692 : .returntype = RPC_RTYPE_WERROR,
693 : .ntfn = NULL,
694 : .wfn = cmd_clusapi_online_resource,
695 : .table = &ndr_table_clusapi,
696 : .rpc_pipe = NULL,
697 : .description = "Set cluster resource online",
698 : .usage = "",
699 : },
700 : {
701 : .name = "clusapi_offline_resource",
702 : .returntype = RPC_RTYPE_WERROR,
703 : .ntfn = NULL,
704 : .wfn = cmd_clusapi_offline_resource,
705 : .table = &ndr_table_clusapi,
706 : .rpc_pipe = NULL,
707 : .description = "Set cluster resource offline",
708 : .usage = "",
709 : },
710 : {
711 : .name = "clusapi_get_resource_state",
712 : .returntype = RPC_RTYPE_WERROR,
713 : .ntfn = NULL,
714 : .wfn = cmd_clusapi_get_resource_state,
715 : .table = &ndr_table_clusapi,
716 : .rpc_pipe = NULL,
717 : .description = "Get cluster resource state",
718 : .usage = "",
719 : },
720 : {
721 : .name = "clusapi_get_cluster_version2",
722 : .returntype = RPC_RTYPE_WERROR,
723 : .ntfn = NULL,
724 : .wfn = cmd_clusapi_get_cluster_version2,
725 : .table = &ndr_table_clusapi,
726 : .rpc_pipe = NULL,
727 : .description = "Get cluster version2",
728 : .usage = "",
729 : },
730 : {
731 : .name = "clusapi_pause_node",
732 : .returntype = RPC_RTYPE_WERROR,
733 : .ntfn = NULL,
734 : .wfn = cmd_clusapi_pause_node,
735 : .table = &ndr_table_clusapi,
736 : .rpc_pipe = NULL,
737 : .description = "Pause cluster node",
738 : .usage = "",
739 : },
740 : {
741 : .name = "clusapi_resume_node",
742 : .returntype = RPC_RTYPE_WERROR,
743 : .ntfn = NULL,
744 : .wfn = cmd_clusapi_resume_node,
745 : .table = &ndr_table_clusapi,
746 : .rpc_pipe = NULL,
747 : .description = "Resume cluster node",
748 : .usage = "",
749 : },
750 : {
751 : .name = NULL,
752 : },
753 : };
|
