source3/rpcclient/cmd_srvsvc.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NT Domain Authentication SMB / MSRPC client
   5    Copyright (C) Andrew Tridgell 1994-1999
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1999
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24
  25 #ifdef SYSLOG
  26 #undef SYSLOG
  27 #endif
  28
  29 #include "includes.h"
  30 #include "nterr.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34 #define DEBUG_TESTING
  35
  36 extern struct cli_state *smb_cli;
  37
  38 extern FILE* out_hnd;
  39
  40
  41 /****************************************************************************
  42 server get info query
  43 ****************************************************************************/
  44 BOOL net_srv_get_info(struct client_info *info,
  45                 uint32 info_level,
  46                 SRV_INFO_CTR *ctr)
  47 {
  48         uint16 fnum;
  49         fstring dest_srv;
  50
  51         BOOL res = True;
  52
  53         fstrcpy(dest_srv, "\\\\");
  54         fstrcat(dest_srv, info->dest_host);
  55         strupper(dest_srv);
  56
  57         DEBUG(4,("net_srv_get_info: server:%s info level: %d\n",
  58                                 dest_srv, (int)info_level));
  59
  60         /* open LSARPC session. */
  61         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
  62
  63         /* send info level: receive requested info.  hopefully. */
  64         res = res ? do_srv_net_srv_get_info(smb_cli, fnum,
  65                                 dest_srv, info_level, ctr) : False;
  66
  67         /* close the session */
  68         cli_nt_session_close(smb_cli, fnum);
  69
  70         return res;
  71 }
  72
  73 /****************************************************************************
  74 server get info query
  75 ****************************************************************************/
  76 void cmd_srv_query_info(struct client_info *info, int argc, char *argv[])
  77 {
  78         uint32 info_level = 101;
  79         SRV_INFO_CTR ctr;
  80
  81         bzero(&ctr, sizeof(ctr));
  82
  83         if (argc > 1)
  84         {
  85                 info_level = (uint32)strtol(argv[1], (char**)NULL, 10);
  86         }
  87
  88         DEBUG(5, ("cmd_srv_query_info: smb_cli->fd:%d\n", smb_cli->fd));
  89
  90         if (net_srv_get_info(info, info_level, &ctr))
  91         {
  92                 DEBUG(5,("cmd_srv_query_info: query succeeded\n"));
  93
  94                 display_srv_info_ctr(out_hnd, ACTION_HEADER   , &ctr);
  95                 display_srv_info_ctr(out_hnd, ACTION_ENUMERATE, &ctr);
  96                 display_srv_info_ctr(out_hnd, ACTION_FOOTER   , &ctr);
  97         }
  98         else
  99         {
 100                 DEBUG(5,("cmd_srv_query_info: query failed\n"));
 101         }
 102 }
 103
 104 /****************************************************************************
 105 server enum transports
 106 ****************************************************************************/
 107 BOOL msrpc_srv_enum_tprt(struct cli_state *cli,
 108                                 const char* dest_srv,
 109                                 uint32 info_level,
 110                                 SRV_TPRT_INFO_CTR *ctr,
 111                                 TPRT_INFO_FN(tprt_fn))
 112 {
 113         uint16 fnum;
 114
 115         BOOL res = True;
 116         BOOL res1 = True;
 117
 118         ENUM_HND hnd;
 119
 120         hnd.ptr_hnd = 1;
 121         hnd.handle = 0;
 122
 123         /* open srvsvc session. */
 124         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
 125
 126         /* enumerate transports on server */
 127         res1 = res ? do_srv_net_srv_tprt_enum(smb_cli, fnum,
 128                                 dest_srv,
 129                     info_level, ctr, 0xffffffff, &hnd) : False;
 130
 131         /* close the session */
 132         cli_nt_session_close(smb_cli, fnum);
 133
 134         tprt_fn(ctr);
 135
 136         free_srv_tprt_ctr(ctr);
 137
 138         return res1;
 139 }
 140
 141 static void srv_display_tprt_ctr(const SRV_TPRT_INFO_CTR *ctr)
 142 {
 143         display_srv_tprt_info_ctr(out_hnd, ACTION_HEADER   , ctr);
 144         display_srv_tprt_info_ctr(out_hnd, ACTION_ENUMERATE, ctr);
 145         display_srv_tprt_info_ctr(out_hnd, ACTION_FOOTER   , ctr);
 146 }
 147
 148 /****************************************************************************
 149 server enum transports
 150 ****************************************************************************/
 151 void cmd_srv_enum_tprt(struct client_info *info, int argc, char *argv[])
 152 {
 153         fstring dest_srv;
 154         SRV_TPRT_INFO_CTR ctr;
 155         uint32 info_level = 0;
 156
 157         bzero(&ctr, sizeof(ctr));
 158
 159         fstrcpy(dest_srv, "\\\\");
 160         fstrcat(dest_srv, info->dest_host);
 161         strupper(dest_srv);
 162
 163         if (argc > 1)
 164         {
 165                 info_level = (uint32)strtol(argv[1], (char**)NULL, 10);
 166         }
 167
 168         DEBUG(4,("cmd_srv_enum_tprt: server:%s info level: %d\n",
 169                                 dest_srv, (int)info_level));
 170
 171         DEBUG(5, ("cmd_srv_enum_tprt: smb_cli->fd:%d\n", smb_cli->fd));
 172
 173         /* enumerate transports on server */
 174         msrpc_srv_enum_tprt(smb_cli, dest_srv,
 175                     info_level, &ctr,
 176                     srv_display_tprt_ctr);
 177 }
 178
 179 /****************************************************************************
 180 server enum connections
 181 ****************************************************************************/
 182 void cmd_srv_enum_conn(struct client_info *info, int argc, char *argv[])
 183 {
 184         uint16 fnum;
 185         fstring dest_srv;
 186         fstring qual_srv;
 187         SRV_CONN_INFO_CTR ctr;
 188         ENUM_HND hnd;
 189         uint32 info_level = 0;
 190
 191         BOOL res = True;
 192
 193         bzero(&ctr, sizeof(ctr));
 194
 195         fstrcpy(qual_srv, "\\\\");
 196         fstrcat(qual_srv, info->myhostname);
 197         strupper(qual_srv);
 198
 199         fstrcpy(dest_srv, "\\\\");
 200         fstrcat(dest_srv, info->dest_host);
 201         strupper(dest_srv);
 202
 203         if (argc > 1)
 204         {
 205                 info_level = (uint32)strtol(argv[1], (char**)NULL, 10);
 206         }
 207
 208         DEBUG(4,("cmd_srv_enum_conn: server:%s info level: %d\n",
 209                                 dest_srv, (int)info_level));
 210
 211         DEBUG(5, ("cmd_srv_enum_conn: smb_cli->fd:%d\n", smb_cli->fd));
 212
 213         /* open srvsvc session. */
 214         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
 215
 216         hnd.ptr_hnd = 1;
 217         hnd.handle = 0;
 218
 219         /* enumerate connections on server */
 220         res = res ? do_srv_net_srv_conn_enum(smb_cli, fnum,
 221                                 dest_srv, qual_srv,
 222                     info_level, &ctr, 0xffffffff, &hnd) : False;
 223
 224         if (res)
 225         {
 226                 display_srv_conn_info_ctr(out_hnd, ACTION_HEADER   , &ctr);
 227                 display_srv_conn_info_ctr(out_hnd, ACTION_ENUMERATE, &ctr);
 228                 display_srv_conn_info_ctr(out_hnd, ACTION_FOOTER   , &ctr);
 229         }
 230
 231         /* close the session */
 232         cli_nt_session_close(smb_cli, fnum);
 233
 234         if (res)
 235         {
 236                 DEBUG(5,("cmd_srv_enum_conn: query succeeded\n"));
 237         }
 238         else
 239         {
 240                 DEBUG(5,("cmd_srv_enum_conn: query failed\n"));
 241         }
 242 }
 243
 244 /****************************************************************************
 245 server enum shares
 246 ****************************************************************************/
 247 void cmd_srv_enum_shares(struct client_info *info, int argc, char *argv[])
 248 {
 249         uint16 fnum;
 250         fstring dest_srv;
 251         SRV_SHARE_INFO_CTR ctr;
 252         ENUM_HND hnd;
 253         uint32 info_level = 1;
 254
 255         BOOL res = True;
 256
 257         bzero(&ctr, sizeof(ctr));
 258
 259         fstrcpy(dest_srv, "\\\\");
 260         fstrcat(dest_srv, info->dest_host);
 261         strupper(dest_srv);
 262
 263         if (argc > 1)
 264         {
 265                 info_level = (uint32)strtol(argv[1], (char**)NULL, 10);
 266         }
 267
 268         DEBUG(4,("cmd_srv_enum_shares: server:%s info level: %d\n",
 269                                 dest_srv, (int)info_level));
 270
 271         DEBUG(5, ("cmd_srv_enum_shares: smb_cli->fd:%d\n", smb_cli->fd));
 272
 273         /* open srvsvc session. */
 274         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
 275
 276         hnd.ptr_hnd = 0;
 277         hnd.handle = 0;
 278
 279         /* enumerate shares_files on server */
 280         res = res ? do_srv_net_srv_share_enum(smb_cli, fnum,
 281                                 dest_srv,
 282                     info_level, &ctr, 0xffffffff, &hnd) : False;
 283
 284         if (res)
 285         {
 286                 display_srv_share_info_ctr(out_hnd, ACTION_HEADER   , &ctr);
 287                 display_srv_share_info_ctr(out_hnd, ACTION_ENUMERATE, &ctr);
 288                 display_srv_share_info_ctr(out_hnd, ACTION_FOOTER   , &ctr);
 289         }
 290
 291         /* close the session */
 292         cli_nt_session_close(smb_cli, fnum);
 293
 294         if (res)
 295         {
 296                 DEBUG(5,("cmd_srv_enum_shares: query succeeded\n"));
 297         }
 298         else
 299         {
 300                 DEBUG(5,("cmd_srv_enum_shares: query failed\n"));
 301         }
 302 }
 303
 304 /****************************************************************************
 305 server enum sessions
 306 ****************************************************************************/
 307 void cmd_srv_enum_sess(struct client_info *info, int argc, char *argv[])
 308 {
 309         uint16 fnum;
 310         fstring dest_srv;
 311         SRV_SESS_INFO_CTR ctr;
 312         ENUM_HND hnd;
 313         uint32 info_level = 0;
 314
 315         BOOL res = True;
 316
 317         bzero(&ctr, sizeof(ctr));
 318
 319         fstrcpy(dest_srv, "\\\\");
 320         fstrcat(dest_srv, info->dest_host);
 321         strupper(dest_srv);
 322
 323         if (argc > 1)
 324         {
 325                 info_level = (uint32)strtol(argv[1], (char**)NULL, 10);
 326         }
 327
 328         DEBUG(4,("cmd_srv_enum_sess: server:%s info level: %d\n",
 329                                 dest_srv, (int)info_level));
 330
 331         DEBUG(5, ("cmd_srv_enum_sess: smb_cli->fd:%d\n", smb_cli->fd));
 332
 333         /* open srvsvc session. */
 334         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
 335
 336         hnd.ptr_hnd = 1;
 337         hnd.handle = 0;
 338
 339         /* enumerate sessions on server */
 340         res = res ? do_srv_net_srv_sess_enum(smb_cli, fnum,
 341                                 dest_srv, NULL, NULL, info_level, &ctr, 0x1000, &hnd) : False;
 342
 343         if (res)
 344         {
 345                 display_srv_sess_info_ctr(out_hnd, ACTION_HEADER   , &ctr);
 346                 display_srv_sess_info_ctr(out_hnd, ACTION_ENUMERATE, &ctr);
 347                 display_srv_sess_info_ctr(out_hnd, ACTION_FOOTER   , &ctr);
 348         }
 349
 350         /* close the session */
 351         cli_nt_session_close(smb_cli, fnum);
 352
 353         if (res)
 354         {
 355                 DEBUG(5,("cmd_srv_enum_sess: query succeeded\n"));
 356         }
 357         else
 358         {
 359                 DEBUG(5,("cmd_srv_enum_sess: query failed\n"));
 360         }
 361 }
 362
 363 /****************************************************************************
 364 server enum files
 365 ****************************************************************************/
 366 void cmd_srv_enum_files(struct client_info *info, int argc, char *argv[])
 367 {
 368         uint16 fnum;
 369         fstring dest_srv;
 370         SRV_FILE_INFO_CTR ctr;
 371         ENUM_HND hnd;
 372         uint32 info_level = 3;
 373
 374         BOOL res = True;
 375
 376         bzero(&ctr, sizeof(ctr));
 377
 378         fstrcpy(dest_srv, "\\\\");
 379         fstrcat(dest_srv, info->dest_host);
 380         strupper(dest_srv);
 381
 382         if (argc > 1)
 383         {
 384                 info_level = (uint32)strtol(argv[1], (char**)NULL, 10);
 385         }
 386
 387         DEBUG(4,("cmd_srv_enum_files: server:%s info level: %d\n",
 388                                 dest_srv, (int)info_level));
 389
 390         DEBUG(5, ("cmd_srv_enum_files: smb_cli->fd:%d\n", smb_cli->fd));
 391
 392         /* open srvsvc session. */
 393         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
 394
 395         hnd.ptr_hnd = 1;
 396         hnd.handle = 0;
 397
 398         /* enumerate files on server */
 399         res = res ? do_srv_net_srv_file_enum(smb_cli, fnum,
 400                                 dest_srv, NULL, 0, info_level, &ctr, 0x1000, &hnd) : False;
 401
 402         if (res)
 403         {
 404                 display_srv_file_info_ctr(out_hnd, ACTION_HEADER   , &ctr);
 405                 display_srv_file_info_ctr(out_hnd, ACTION_ENUMERATE, &ctr);
 406                 display_srv_file_info_ctr(out_hnd, ACTION_FOOTER   , &ctr);
 407         }
 408
 409         /* close the session */
 410         cli_nt_session_close(smb_cli, fnum);
 411
 412         if (res)
 413         {
 414                 DEBUG(5,("cmd_srv_enum_files: query succeeded\n"));
 415         }
 416         else
 417         {
 418                 DEBUG(5,("cmd_srv_enum_files: query failed\n"));
 419         }
 420 }
 421
 422 /****************************************************************************
 423 display remote time
 424 ****************************************************************************/
 425 void cmd_time(struct client_info *info, int argc, char *argv[])
 426 {
 427         uint16 fnum;
 428         fstring dest_srv;
 429         TIME_OF_DAY_INFO tod;
 430         BOOL res = True;
 431
 432         fstrcpy(dest_srv, "\\\\");
 433         fstrcat(dest_srv, info->dest_host);
 434         strupper(dest_srv);
 435
 436         DEBUG(4,("cmd_time: server:%s\n", dest_srv));
 437
 438         /* open srvsvc session. */
 439         res = res ? cli_nt_session_open(smb_cli, PIPE_SRVSVC, &fnum) : False;
 440
 441         /* enumerate files on server */
 442         res = res ? do_srv_net_remote_tod(smb_cli, fnum,
 443                                           dest_srv, &tod) : False;
 444
 445         if (res)
 446         {
 447                 fprintf(out_hnd, "\tRemote Time:\t%s\n\n",
 448                         http_timestring(tod.elapsedt));
 449         }
 450
 451         /* Close the session */
 452         cli_nt_session_close(smb_cli, fnum);
 453
 454         if (res)
 455         {
 456                 DEBUG(5,("cmd_srv_enum_files: query succeeded\n"));
 457         }
 458         else
 459         {
 460                 DEBUG(5,("cmd_srv_enum_files: query failed\n"));
 461         }
 462 }