LCOV - code coverage report
Current view: top level - source3/rpcclient - cmd_witness.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 228 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 10 0.0 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    RPC pipe client
       4             : 
       5             :    Copyright (C) Gregor Beck 2013-2014
       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_witness_c.h"
      24             : #include <popt.h>
      25             : 
      26             : /*
      27             :  * We have to use the same connection for each subcommand
      28             :  * for the context handles to be meaningful.
      29             :  */
      30             : static void use_only_one_rpc_pipe_hack(struct rpc_pipe_client *cli);
      31             : 
      32           0 : static WERROR cmd_witness_GetInterfaceList(struct rpc_pipe_client *cli,
      33             :                                            TALLOC_CTX *mem_ctx, int argc,
      34             :                                            const char **argv)
      35             : {
      36             :         NTSTATUS status;
      37             :         WERROR result;
      38           0 :         TALLOC_CTX *frame = talloc_stackframe();
      39           0 :         struct witness_interfaceList *interface_list = NULL;
      40             :         uint32_t num_interfaces, n;
      41             :         struct witness_interfaceInfo *interfaces;
      42             : 
      43           0 :         use_only_one_rpc_pipe_hack(cli);
      44             : 
      45           0 :         status = dcerpc_witness_GetInterfaceList(cli->binding_handle, frame,
      46             :                                                  &interface_list, &result);
      47           0 :         if (!NT_STATUS_IS_OK(status)) {
      48           0 :                 DEBUG(0, ("dcerpc_witness_GetInterfaceList failed, status: %s\n", nt_errstr(status)));
      49           0 :                 result = ntstatus_to_werror(status);
      50           0 :                 goto done;
      51             :         }
      52           0 :         if (!W_ERROR_IS_OK(result)) {
      53           0 :                 DEBUG(0, ("dcerpc_witness_GetInterfaceList failed, error: %s\n", win_errstr(result)));
      54           0 :                 goto done;
      55             :         }
      56             : 
      57           0 :         SMB_ASSERT(interface_list);
      58           0 :         interfaces = interface_list->interfaces;
      59           0 :         num_interfaces = interface_list->num_interfaces;
      60             : 
      61           0 :         for (n=0; n < num_interfaces; n++) {
      62           0 :                 char wif = (interfaces[n].flags & WITNESS_INFO_WITNESS_IF) ? '*' : ' ';
      63           0 :                 char state = 'X';
      64             : 
      65           0 :                 if (interfaces[n].state == WITNESS_STATE_AVAILABLE) {
      66           0 :                         state = '+';
      67           0 :                 } else if (interfaces[n].state == WITNESS_STATE_UNAVAILABLE) {
      68           0 :                         state = '-';
      69           0 :                 } else if (interfaces[n].state == WITNESS_STATE_UNKNOWN) {
      70           0 :                         state = '?';
      71             :                 }
      72             : 
      73           0 :                 d_printf("%c%c %s", wif, state, interfaces[n].group_name);
      74             : 
      75           0 :                 if (interfaces[n].flags & WITNESS_INFO_IPv4_VALID) {
      76           0 :                         d_printf(" %s", interfaces[n].ipv4);
      77             :                 }
      78             : 
      79           0 :                 if (interfaces[n].flags & WITNESS_INFO_IPv6_VALID) {
      80           0 :                         d_printf(" %s", interfaces[n].ipv6);
      81             :                 }
      82             : 
      83           0 :                 switch (interfaces[n].version) {
      84           0 :                 case WITNESS_V1:
      85           0 :                         d_printf(" V1");
      86           0 :                         break;
      87           0 :                 case WITNESS_V2:
      88           0 :                         d_printf(" V2");
      89           0 :                         break;
      90           0 :                 default:
      91           0 :                         d_printf(" Unsupported Version (0x%08x)", interfaces[n].version);
      92             :                 }
      93             : 
      94           0 :                 d_printf("\n");
      95             :         }
      96             : 
      97           0 : done:
      98           0 :         talloc_free(frame);
      99           0 :         return result;
     100             : }
     101             : 
     102           0 : static WERROR cmd_witness_Register(struct rpc_pipe_client *cli,
     103             :                                    TALLOC_CTX *mem_ctx, int argc,
     104             :                                    const char **argv)
     105             : {
     106             :         static char hostname[MAXHOSTNAMELEN] = {'\0'};
     107             :         NTSTATUS status;
     108           0 :         WERROR result = WERR_OK;
     109           0 :         TALLOC_CTX *frame = talloc_stackframe();
     110             :         struct policy_handle hnd;
     111           0 :         const char *net_name = NULL;
     112           0 :         const char *ip_addr = NULL;
     113           0 :         const char *client_name = hostname;
     114           0 :         long version = WITNESS_V1;
     115             :         int c;
     116             :         poptContext optCon;
     117           0 :         struct poptOption optionsTable[] = {
     118             :                 {
     119             :                         .longName   = "version",
     120             :                         .shortName  = 'v',
     121             :                         .argInfo    = POPT_ARG_LONG|POPT_ARGFLAG_SHOW_DEFAULT,
     122             :                         .arg        = &version,
     123             :                         .val        = WITNESS_V2,
     124             :                         .descrip    = "witness version",
     125             :                         .argDescrip = "version"
     126             :                 },
     127             :                 {
     128             :                         .longName   = "V1",
     129             :                         .shortName  = '1',
     130             :                         .argInfo    = POPT_ARG_LONG|POPT_ARG_VAL,
     131             :                         .arg        = &version,
     132             :                         .val        = WITNESS_V1,
     133             :                         .descrip    = "witness version 1",
     134             :                         .argDescrip = NULL
     135             :                 },
     136             :                 {
     137             :                         .longName   = "V2",
     138             :                         .shortName  = '2',
     139             :                         .argInfo    = POPT_ARG_LONG|POPT_ARG_VAL,
     140             :                         .arg        = &version,
     141             :                         .val        = WITNESS_V2,
     142             :                         .descrip    = "witness version 2",
     143             :                         .argDescrip = NULL
     144             :                 },
     145             :                 {
     146             :                         .longName   = "net",
     147             :                         .shortName  = 'n',
     148             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT,
     149             :                         .arg        = &net_name,
     150             :                         .val        = 0,
     151             :                         .descrip    = "net name",
     152             :                         .argDescrip = NULL
     153             :                 },
     154             :                 {
     155             :                         .longName   = "ip",
     156             :                         .shortName  =  'i',
     157             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT,
     158             :                         .arg        = &ip_addr,
     159             :                         .val        = 0,
     160             :                         .descrip    = "ip address",
     161             :                         .argDescrip = NULL
     162             :                 },
     163             :                 {
     164             :                         .longName   = "client",
     165             :                         .shortName  = 'c',
     166             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT|POPT_ARGFLAG_OPTIONAL,
     167             :                         .arg        = &client_name,
     168             :                         .val        = 0,
     169             :                         .descrip    = "client name",
     170             :                         .argDescrip = NULL
     171             :                 },
     172             :                 POPT_TABLEEND
     173             :         };
     174             : 
     175           0 :         use_only_one_rpc_pipe_hack(cli);
     176             : 
     177           0 :         if (hostname[0] == '\0') {
     178           0 :                 gethostname (hostname, sizeof(hostname));
     179             :         }
     180             : 
     181           0 :         optCon = poptGetContext(NULL, argc, argv, optionsTable, 0);
     182             : 
     183           0 :         while ((c = poptGetNextOpt(optCon)) >= 0) { }
     184             : 
     185           0 :         if (c < -1) {
     186             :              /* an error occurred during option processing */
     187           0 :                 d_fprintf(stderr, "%s: %s\n",
     188             :                           poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
     189             :                           poptStrerror(c));
     190           0 :              goto done;
     191             :         }
     192             : 
     193           0 :         if (argc < 2 || poptPeekArg(optCon) != NULL) {
     194           0 :                 poptPrintHelp(optCon, stderr, 0);
     195           0 :                 goto done;
     196             :         }
     197             : 
     198           0 :         status = dcerpc_witness_Register(cli->binding_handle, frame,
     199             :                                          &hnd,
     200             :                                          version,
     201             :                                          net_name, ip_addr, client_name,
     202             :                                          &result);
     203           0 :         if (!NT_STATUS_IS_OK(status)) {
     204           0 :                 DEBUG(0, ("dcerpc_witness_Register failed, status: %s\n", nt_errstr(status)));
     205           0 :                 result = ntstatus_to_werror(status);
     206           0 :                 goto done;
     207             :         }
     208           0 :         if (!W_ERROR_IS_OK(result)) {
     209           0 :                 DEBUG(0, ("dcerpc_witness_Register failed, error: %s\n", win_errstr(result)));
     210           0 :                 goto done;
     211             :         }
     212             : 
     213           0 :         d_printf("%x:%s\n", hnd.handle_type, GUID_string(frame, &hnd.uuid));
     214             : 
     215           0 : done:
     216           0 :         poptFreeContext(optCon);
     217           0 :         talloc_free(frame);
     218           0 :         return result;
     219             : }
     220             : 
     221           0 : static WERROR cmd_witness_RegisterEx(struct rpc_pipe_client *cli,
     222             :                                      TALLOC_CTX *mem_ctx, int argc,
     223             :                                      const char **argv)
     224             : {
     225             :         static char hostname[MAXHOSTNAMELEN] = {'\0'};
     226             :         NTSTATUS status;
     227           0 :         WERROR result = WERR_OK;
     228           0 :         TALLOC_CTX *frame = talloc_stackframe();
     229             :         struct policy_handle hnd;
     230           0 :         const char *net_name = NULL;
     231           0 :         const char *ip_addr = NULL;
     232           0 :         const char *share_name = NULL;
     233           0 :         const char *client_name = hostname;
     234           0 :         long version = WITNESS_V2;
     235           0 :         long flags = 0;
     236           0 :         long timeout = 0;
     237             :         int c;
     238             :         poptContext optCon;
     239           0 :         struct poptOption optionsTable[] = {
     240             :                 {
     241             :                         .longName   = "version",
     242             :                         .shortName  = 'v',
     243             :                         .argInfo    = POPT_ARG_LONG|POPT_ARGFLAG_SHOW_DEFAULT,
     244             :                         .arg        = &version,
     245             :                         .val        = WITNESS_V2,
     246             :                         .descrip    = "witness version",
     247             :                         .argDescrip = "version"
     248             :                 },
     249             :                 {
     250             :                         .longName   = "V1",
     251             :                         .shortName  = '1',
     252             :                         .argInfo    = POPT_ARG_LONG|POPT_ARG_VAL,
     253             :                         .arg        = &version,
     254             :                         .val        = WITNESS_V1,
     255             :                         .descrip    = "witness version 1",
     256             :                 },
     257             :                 {
     258             :                         .longName   = "V2",
     259             :                         .shortName  = '2',
     260             :                         .argInfo    = POPT_ARG_LONG|POPT_ARG_VAL,
     261             :                         .arg        = &version,
     262             :                         .val        = WITNESS_V2,
     263             :                         .descrip    = "witness version 2",
     264             :                 },
     265             :                 {
     266             :                         .longName   = "net",
     267             :                         .shortName  = 'n',
     268             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT,
     269             :                         .arg        = &net_name,
     270             :                         .val        = 0,
     271             :                         .descrip    = "net name",
     272             :                 },
     273             :                 {
     274             :                         .longName   = "ip",
     275             :                         .shortName  = 'i',
     276             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT,
     277             :                         .arg        = &ip_addr,
     278             :                         .val        = 0,
     279             :                         .descrip    = "ip address",
     280             :                 },
     281             :                 {
     282             :                         .longName   = "share",
     283             :                         .shortName  = 's',
     284             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT,
     285             :                         .arg        = &share_name,
     286             :                         .val        = 0,
     287             :                         .descrip    = "share name",
     288             :                 },
     289             :                 {
     290             :                         .longName   = "client",
     291             :                         .shortName  = 'c',
     292             :                         .argInfo    = POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT|POPT_ARGFLAG_OPTIONAL,
     293             :                         .arg        = &client_name,
     294             :                         .val        = 0,
     295             :                         .descrip    = "client name",
     296             :                 },
     297             :                 {
     298             :                         .longName   = "flags",
     299             :                         .shortName  = 'f',
     300             :                         .argInfo    = POPT_ARG_LONG|POPT_ARGFLAG_OR|POPT_ARGFLAG_SHOW_DEFAULT,
     301             :                         .arg        = &flags,
     302             :                         .val        = 0,
     303             :                         .descrip    = "flags",
     304             :                 },
     305             :                 {
     306             :                         .longName   = "timeout",
     307             :                         .shortName  = 't',
     308             :                         .argInfo    = POPT_ARG_LONG|POPT_ARGFLAG_SHOW_DEFAULT,
     309             :                         .arg        = &timeout,
     310             :                         .val        = 0,
     311             :                         .descrip    = "timeout",
     312             :                 },
     313             :                 POPT_TABLEEND
     314             :         };
     315             : 
     316           0 :         use_only_one_rpc_pipe_hack(cli);
     317             : 
     318           0 :         if (hostname[0] == '\0') {
     319           0 :                 gethostname (hostname, sizeof(hostname));
     320             :         }
     321             : 
     322           0 :         optCon = poptGetContext(NULL, argc, argv, optionsTable, 0);
     323             : 
     324           0 :         while ((c = poptGetNextOpt(optCon)) >= 0) { }
     325             : 
     326           0 :         if (c < -1) {
     327             :              /* an error occurred during option processing */
     328           0 :                 d_fprintf(stderr, "%s: %s\n",
     329             :                           poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
     330             :                           poptStrerror(c));
     331           0 :              goto done;
     332             :         }
     333             : 
     334           0 :         if (argc < 2 || poptPeekArg(optCon) != NULL) {
     335           0 :                 poptPrintHelp(optCon, stderr, 0);
     336           0 :                 goto done;
     337             :         }
     338             : 
     339           0 :         status = dcerpc_witness_RegisterEx(cli->binding_handle, frame,
     340             :                                            &hnd,
     341             :                                            version,
     342             :                                            net_name, share_name, ip_addr, client_name,
     343             :                                            flags, timeout,
     344             :                                            &result);
     345           0 :         if (!NT_STATUS_IS_OK(status)) {
     346           0 :                 DEBUG(0, ("dcerpc_witness_RegisterEx failed, status: %s\n", nt_errstr(status)));
     347           0 :                 result = ntstatus_to_werror(status);
     348           0 :                 goto done;
     349             :         }
     350           0 :         if (!W_ERROR_IS_OK(result)) {
     351           0 :                 DEBUG(0, ("dcerpc_witness_RegisterEx failed, error: %s\n", win_errstr(result)));
     352           0 :                 goto done;
     353             :         }
     354             : 
     355           0 :         d_printf("%x:%s\n", hnd.handle_type, GUID_string(frame, &hnd.uuid));
     356             : 
     357           0 : done:
     358           0 :         poptFreeContext(optCon);
     359           0 :         talloc_free(frame);
     360           0 :         return result;
     361             : }
     362             : 
     363             : static bool
     364           0 : read_context_handle(const char *str, struct policy_handle *hnd)
     365             : {
     366             :         NTSTATUS status;
     367             :         long type;
     368             :         char *pos;
     369             :         struct GUID guid;
     370             : 
     371           0 :         type = strtol(str, &pos, 16);
     372           0 :         if (*pos != ':') {
     373           0 :                 DEBUG(0, ("read_context_handle: failed to parse type\n"));
     374           0 :                 return false;
     375             :         }
     376           0 :         status = GUID_from_string(pos+1, &guid);
     377           0 :         if (!NT_STATUS_IS_OK(status)) {
     378           0 :                 DEBUG(0, ("read_context_handle: failed to parse guid %s\n", nt_errstr(status)));
     379           0 :                 return false;
     380             :         }
     381             : 
     382           0 :         hnd->handle_type = type;
     383           0 :         hnd->uuid = guid;
     384           0 :         return true;
     385             : }
     386             : 
     387           0 : static WERROR cmd_witness_UnRegister(struct rpc_pipe_client *cli,
     388             :                                      TALLOC_CTX *mem_ctx, int argc,
     389             :                                      const char **argv)
     390             : {
     391             :         NTSTATUS status;
     392           0 :         WERROR result = WERR_OK;
     393           0 :         TALLOC_CTX *frame = talloc_stackframe();
     394             :         struct policy_handle hnd;
     395             : 
     396           0 :         use_only_one_rpc_pipe_hack(cli);
     397             : 
     398           0 :         if (argc != 2) {
     399           0 :                 d_printf("%s <context_handle>\n", argv[0]);
     400           0 :                 goto done;
     401             :         }
     402             : 
     403           0 :         if (!read_context_handle(argv[1], &hnd)) {
     404           0 :                 result = WERR_INVALID_PARAMETER;
     405           0 :                 goto done;
     406             :         }
     407             : 
     408           0 :         status = dcerpc_witness_UnRegister(cli->binding_handle, frame,
     409             :                                            hnd, &result);
     410           0 :         if (!NT_STATUS_IS_OK(status)) {
     411           0 :                 DEBUG(0, ("dcerpc_witness_UnRegister failed, status: %s\n", nt_errstr(status)));
     412           0 :                 result = ntstatus_to_werror(status);
     413           0 :                 goto done;
     414             :         }
     415           0 :         if (!W_ERROR_IS_OK(result)) {
     416           0 :                 DEBUG(0, ("dcerpc_witness_UnRegister failed, error: %s\n", win_errstr(result)));
     417           0 :                 goto done;
     418             :         }
     419             : 
     420           0 : done:
     421           0 :         talloc_free(frame);
     422           0 :         return result;
     423             : }
     424             : 
     425           0 : static void print_notify_response_resource_change(struct witness_ResourceChange *r)
     426             : {
     427             :         const char *type_str;
     428             : 
     429           0 :         if (r->type == WITNESS_RESOURCE_STATE_UNKNOWN) {
     430           0 :                 type_str = "Unknown";
     431           0 :         } else if (r->type == WITNESS_RESOURCE_STATE_AVAILABLE) {
     432           0 :                 type_str = "Available\n";
     433           0 :         } else if (r->type == WITNESS_RESOURCE_STATE_UNAVAILABLE) {
     434           0 :                 type_str = "Unavailable";
     435             :         } else {
     436           0 :                 type_str = talloc_asprintf(r, "Invalid (%u)", r->type);
     437             :         }
     438           0 :         d_printf("%s -> %s\n", r->name, type_str);
     439           0 : }
     440             : 
     441           0 : static void print_notify_response_ip_addr_info_list(struct witness_IPaddrInfoList *r)
     442             : {
     443             :         int i;
     444             : 
     445           0 :         for (i=0; i < r->num; i++) {
     446           0 :                 uint32_t flags = r->addr[i].flags;
     447           0 :                 const char *str4 = r->addr[i].ipv4;
     448           0 :                 const char *str6 = r->addr[i].ipv6;
     449             : 
     450           0 :                 d_printf("Flags 0x%08x", flags);
     451           0 :                 if (flags & WITNESS_IPADDR_V4) {
     452           0 :                         d_printf(" %s", str4);
     453             :                 }
     454           0 :                 if (flags & WITNESS_IPADDR_V6) {
     455           0 :                         d_printf(" %s", str6);
     456             :                 }
     457           0 :                 if (flags & WITNESS_IPADDR_ONLINE) {
     458           0 :                         d_printf(" Online");
     459             :                 }
     460           0 :                 if (flags & WITNESS_IPADDR_ONLINE) {
     461           0 :                         d_printf(" Offline");
     462             :                 }
     463           0 :                 d_printf("\n");
     464             :         }
     465           0 : }
     466             : 
     467           0 : static void print_notify_response(union witness_notifyResponse_message *r,
     468             :                                   uint32_t type)
     469             : {
     470           0 :         switch (type) {
     471           0 :         case WITNESS_NOTIFY_RESOURCE_CHANGE:
     472           0 :                 print_notify_response_resource_change(&r->resource_change);
     473           0 :                 break;
     474           0 :         case WITNESS_NOTIFY_CLIENT_MOVE:
     475             :         case WITNESS_NOTIFY_SHARE_MOVE:
     476             :         case WITNESS_NOTIFY_IP_CHANGE:
     477           0 :                 print_notify_response_ip_addr_info_list(&r->client_move);
     478           0 :                 break;
     479           0 :         default:
     480           0 :                 break;
     481             :         }
     482           0 : }
     483             : 
     484           0 : static WERROR cmd_witness_AsyncNotify(struct rpc_pipe_client *cli,
     485             :                                       TALLOC_CTX *mem_ctx, int argc,
     486             :                                       const char **argv)
     487             : {
     488             :         NTSTATUS status;
     489           0 :         WERROR result = WERR_OK;
     490           0 :         TALLOC_CTX *frame = talloc_stackframe();
     491             :         struct policy_handle hnd;
     492           0 :         struct witness_notifyResponse *response = NULL;
     493             :         uint32_t timeout;
     494             :         int i;
     495             : 
     496           0 :         use_only_one_rpc_pipe_hack(cli);
     497             : 
     498           0 :         if (argc != 2) {
     499           0 :                 d_printf("%s <context_handle>\n", argv[0]);
     500           0 :                 goto done;
     501             :         }
     502             : 
     503           0 :         if (!read_context_handle(argv[1], &hnd)) {
     504           0 :                 result = WERR_INVALID_PARAMETER;
     505           0 :                 goto done;
     506             :         }
     507             : 
     508           0 :         timeout = dcerpc_binding_handle_set_timeout(cli->binding_handle, UINT32_MAX);
     509           0 :         status = dcerpc_witness_AsyncNotify(cli->binding_handle, frame, hnd,
     510             :                                             &response, &result);
     511           0 :         dcerpc_binding_handle_set_timeout(cli->binding_handle, timeout);
     512           0 :         if (!NT_STATUS_IS_OK(status)) {
     513           0 :                 DEBUG(0, ("dcerpc_witness_AsyncNotify failed, status: %s\n", nt_errstr(status)));
     514           0 :                 result = ntstatus_to_werror(status);
     515           0 :                 goto done;
     516             :         }
     517           0 :         if (!W_ERROR_IS_OK(result)) {
     518           0 :                 DEBUG(0, ("dcerpc_witness_AsyncNotify failed, error: %s\n", win_errstr(result)));
     519           0 :                 goto done;
     520             :         }
     521             : 
     522           0 :         if (response == NULL) {
     523           0 :                 d_printf("Got an empty response\n");
     524           0 :                 goto done;
     525             :         }
     526             : 
     527           0 :         switch(response->type) {
     528           0 :         case WITNESS_NOTIFY_RESOURCE_CHANGE:
     529           0 :                 d_printf("Resource change");
     530           0 :                 break;
     531           0 :         case WITNESS_NOTIFY_CLIENT_MOVE:
     532           0 :                 d_printf("Client move");
     533           0 :                 break;
     534           0 :         case WITNESS_NOTIFY_SHARE_MOVE:
     535           0 :                 d_printf("Share move");
     536           0 :                 break;
     537           0 :         case WITNESS_NOTIFY_IP_CHANGE:
     538           0 :                 d_printf("IP change");
     539           0 :                 break;
     540           0 :         default:
     541           0 :                 d_printf("Unknown (0x%x)", (int)response->type);
     542             :         }
     543           0 :         d_printf(" with %d messages\n", response->num);
     544             : 
     545           0 :         for (i=0; i < response->num; i++) {
     546           0 :                 print_notify_response(&response->messages[i], response->type);
     547             :         }
     548           0 : done:
     549           0 :         talloc_free(frame);
     550           0 :         return result;
     551             : }
     552             : 
     553             : struct cmd_set witness_commands[] = {
     554             :         {
     555             :                 .name = "WITNESS",
     556             :         },
     557             :         {
     558             :                 .name               = "GetInterfaceList",
     559             :                 .returntype         = RPC_RTYPE_WERROR,
     560             :                 .ntfn               = NULL,
     561             :                 .wfn                = &cmd_witness_GetInterfaceList,
     562             :                 .table              = &ndr_table_witness,
     563             :                 .rpc_pipe           = NULL,
     564             :                 .description        = "List the interfaces to which witness client connections can be made",
     565             :                 .usage              = "",
     566             :         },
     567             :         {
     568             :                 .name               = "Register",
     569             :                 .returntype         = RPC_RTYPE_WERROR,
     570             :                 .ntfn               = NULL,
     571             :                 .wfn                = &cmd_witness_Register,
     572             :                 .table              = &ndr_table_witness,
     573             :                 .rpc_pipe           = NULL,
     574             :                 .description        = "Register for resource state change notifications of a NetName and IPAddress",
     575             :                 .usage              = "",
     576             :         },
     577             :         {
     578             :                 .name               = "UnRegister",
     579             :                 .returntype         = RPC_RTYPE_WERROR,
     580             :                 .ntfn               = NULL,
     581             :                 .wfn                = &cmd_witness_UnRegister,
     582             :                 .table              = &ndr_table_witness,
     583             :                 .rpc_pipe           = NULL,
     584             :                 .description        = "Unregister for notifications from the server</para></listitem></varlistentry>",
     585             :                 .usage              = "",
     586             :         },
     587             :         {
     588             :                 .name               = "AsyncNotify",
     589             :                 .returntype         = RPC_RTYPE_WERROR,
     590             :                 .ntfn               = NULL,
     591             :                 .wfn                = &cmd_witness_AsyncNotify,
     592             :                 .table              = &ndr_table_witness,
     593             :                 .rpc_pipe           = NULL,
     594             :                 .description        = "Request notification of registered resource changes from the server",
     595             :                 .usage              = "",
     596             :         },
     597             :         {
     598             :                 .name               = "RegisterEx",
     599             :                 .returntype         = RPC_RTYPE_WERROR,
     600             :                 .ntfn               = NULL,
     601             :                 .wfn                = &cmd_witness_RegisterEx,
     602             :                 .table              = &ndr_table_witness,
     603             :                 .rpc_pipe           = NULL,
     604             :                 .description        = "Register for resource state change notifications of a NetName, ShareName and multiple IPAddresses",
     605             :                 .usage              = "",
     606             :         },
     607             :         {
     608             :                 .name = NULL,
     609             :         }
     610             : };
     611             : 
     612             : /*
     613             :  * We have to use the same connection for each subcommand
     614             :  * for the context handles to be meaningful.
     615             :  */
     616           0 : static void use_only_one_rpc_pipe_hack(struct rpc_pipe_client *cli)
     617             : {
     618             :         struct cmd_set *ptr;
     619             : 
     620           0 :         for (ptr = &witness_commands[0]; ptr->name; ptr++) {
     621           0 :                 ptr->rpc_pipe = cli;
     622             :         }
     623           0 : }

Generated by: LCOV version 1.13