source3/rpc_client/cli_srvsvc.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25
  26 #ifdef SYSLOG
  27 #undef SYSLOG
  28 #endif
  29
  30 #include "includes.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34 /****************************************************************************
  35 do a server net tprt enum
  36 ****************************************************************************/
  37 BOOL do_srv_net_srv_tprt_enum(struct cli_state *cli, uint16 fnum,
  38                         char *server_name,
  39                         uint32 switch_value, SRV_TPRT_INFO_CTR *ctr,
  40                         uint32 preferred_len,
  41                         ENUM_HND *hnd)
  42 {
  43         prs_struct data;
  44         prs_struct rdata;
  45         SRV_Q_NET_TPRT_ENUM q_o;
  46     BOOL valid_enum = False;
  47
  48         if (server_name == NULL || ctr == NULL || preferred_len == 0) return False;
  49
  50         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
  51         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
  52
  53         /* create and send a MSRPC command with api SRV_NETTPRTENUM */
  54
  55         DEBUG(4,("SRV Net Server Transport Enum(%s), level %d, enum:%8x\n",
  56                                 server_name, switch_value, get_enum_hnd(hnd)));
  57
  58         ctr->switch_value = switch_value;
  59         ctr->ptr_tprt_ctr = 1;
  60         ctr->tprt.info0.num_entries_read = 0;
  61         ctr->tprt.info0.ptr_tprt_info    = 1;
  62
  63         /* store the parameters */
  64         make_srv_q_net_tprt_enum(&q_o, server_name,
  65                                  switch_value, ctr,
  66                                  preferred_len,
  67                                  hnd);
  68
  69         /* turn parameters into data stream */
  70         srv_io_q_net_tprt_enum("", &q_o, &data, 0);
  71
  72         /* send the data on \PIPE\ */
  73         if (rpc_api_pipe_req(cli, fnum, SRV_NETTRANSPORTENUM, &data, &rdata))
  74         {
  75                 SRV_R_NET_TPRT_ENUM r_o;
  76                 BOOL p;
  77
  78                 r_o.ctr = ctr;
  79
  80                 srv_io_r_net_tprt_enum("", &r_o, &rdata, 0);
  81                 p = rdata.offset != 0;
  82
  83                 if (p && r_o.status != 0)
  84                 {
  85                         /* report error code */
  86                         DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
  87                         p = 0;
  88                 }
  89
  90                 if (p && r_o.ctr->switch_value != switch_value)
  91                 {
  92                         /* different switch levels.  oops. */
  93                         DEBUG(0,("SRV_R_NET_SRV_TPRT_ENUM: info class %d does not match request %d\n",
  94                                 r_o.ctr->switch_value, switch_value));
  95                         p = 0;
  96                 }
  97
  98                 if (p)
  99                 {
 100                         /* ok, at last: we're happy. */
 101                         valid_enum = True;
 102                 }
 103         }
 104
 105         prs_mem_free(&data   );
 106         prs_mem_free(&rdata  );
 107
 108         return valid_enum;
 109 }
 110
 111 /****************************************************************************
 112 do a server net conn enum
 113 ****************************************************************************/
 114 BOOL do_srv_net_srv_conn_enum(struct cli_state *cli, uint16 fnum,
 115                         char *server_name, char *qual_name,
 116                         uint32 switch_value, SRV_CONN_INFO_CTR *ctr,
 117                         uint32 preferred_len,
 118                         ENUM_HND *hnd)
 119 {
 120         prs_struct data;
 121         prs_struct rdata;
 122         SRV_Q_NET_CONN_ENUM q_o;
 123     BOOL valid_enum = False;
 124
 125         if (server_name == NULL || ctr == NULL || preferred_len == 0) return False;
 126
 127         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 128         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 129
 130         /* create and send a MSRPC command with api SRV_NETCONNENUM */
 131
 132         DEBUG(4,("SRV Net Server Connection Enum(%s, %s), level %d, enum:%8x\n",
 133                                 server_name, qual_name, switch_value, get_enum_hnd(hnd)));
 134
 135         ctr->switch_value = switch_value;
 136         ctr->ptr_conn_ctr = 1;
 137         ctr->conn.info0.num_entries_read = 0;
 138         ctr->conn.info0.ptr_conn_info    = 1;
 139
 140         /* store the parameters */
 141         make_srv_q_net_conn_enum(&q_o, server_name, qual_name,
 142                                  switch_value, ctr,
 143                                  preferred_len,
 144                                  hnd);
 145
 146         /* turn parameters into data stream */
 147         srv_io_q_net_conn_enum("", &q_o, &data, 0);
 148
 149         /* send the data on \PIPE\ */
 150         if (rpc_api_pipe_req(cli, fnum, SRV_NETCONNENUM, &data, &rdata))
 151         {
 152                 SRV_R_NET_CONN_ENUM r_o;
 153                 BOOL p;
 154
 155                 r_o.ctr = ctr;
 156
 157                 srv_io_r_net_conn_enum("", &r_o, &rdata, 0);
 158                 p = rdata.offset != 0;
 159
 160                 if (p && r_o.status != 0)
 161                 {
 162                         /* report error code */
 163                         DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
 164                         p = 0;
 165                 }
 166
 167                 if (p && r_o.ctr->switch_value != switch_value)
 168                 {
 169                         /* different switch levels.  oops. */
 170                         DEBUG(0,("SRV_R_NET_SRV_CONN_ENUM: info class %d does not match request %d\n",
 171                                 r_o.ctr->switch_value, switch_value));
 172                         p = 0;
 173                 }
 174
 175                 if (p)
 176                 {
 177                         /* ok, at last: we're happy. */
 178                         valid_enum = True;
 179                 }
 180         }
 181
 182         prs_mem_free(&data   );
 183         prs_mem_free(&rdata  );
 184
 185         return valid_enum;
 186 }
 187
 188 /****************************************************************************
 189 do a server net sess enum
 190 ****************************************************************************/
 191 BOOL do_srv_net_srv_sess_enum(struct cli_state *cli, uint16 fnum,
 192                         char *server_name, char *qual_name, char *user_name,
 193                         uint32 switch_value, SRV_SESS_INFO_CTR *ctr,
 194                         uint32 preferred_len,
 195                         ENUM_HND *hnd)
 196 {
 197         prs_struct data;
 198         prs_struct rdata;
 199         SRV_Q_NET_SESS_ENUM q_o;
 200     BOOL valid_enum = False;
 201
 202         if (server_name == NULL || ctr == NULL || preferred_len == 0) return False;
 203
 204         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 205         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 206
 207         /* create and send a MSRPC command with api SRV_NETSESSENUM */
 208
 209         DEBUG(4,("SRV Net Session Enum (%s), level %d, enum:%8x\n",
 210                                 server_name, switch_value, get_enum_hnd(hnd)));
 211
 212         ctr->switch_value = switch_value;
 213         ctr->ptr_sess_ctr = 1;
 214         ctr->sess.info0.num_entries_read = 0;
 215         ctr->sess.info0.ptr_sess_info    = 1;
 216
 217         /* store the parameters */
 218         make_srv_q_net_sess_enum(&q_o, server_name, qual_name, user_name,
 219                                  switch_value, ctr,
 220                                  preferred_len,
 221                                  hnd);
 222
 223         /* turn parameters into data stream */
 224         srv_io_q_net_sess_enum("", &q_o, &data, 0);
 225
 226         /* send the data on \PIPE\ */
 227         if (rpc_api_pipe_req(cli, fnum, SRV_NETSESSENUM, &data, &rdata))
 228         {
 229                 SRV_R_NET_SESS_ENUM r_o;
 230                 BOOL p;
 231
 232                 r_o.ctr = ctr;
 233
 234                 srv_io_r_net_sess_enum("", &r_o, &rdata, 0);
 235                 p = rdata.offset != 0;
 236
 237                 if (p && r_o.status != 0)
 238                 {
 239                         /* report error code */
 240                         DEBUG(0,("SRV_R_NET_SRV_SESS_ENUM: %s\n", get_nt_error_msg(r_o.status)));
 241                         p = 0;
 242                 }
 243
 244                 if (p && r_o.ctr->switch_value != switch_value)
 245                 {
 246                         /* different switch levels.  oops. */
 247                         DEBUG(0,("SRV_R_NET_SRV_SESS_ENUM: info class %d does not match request %d\n",
 248                                 r_o.ctr->switch_value, switch_value));
 249                         p = 0;
 250                 }
 251
 252                 if (p)
 253                 {
 254                         /* ok, at last: we're happy. */
 255                         valid_enum = True;
 256                 }
 257         }
 258
 259         prs_mem_free(&data   );
 260         prs_mem_free(&rdata  );
 261
 262         return valid_enum;
 263 }
 264
 265 /****************************************************************************
 266 do a server net share enum
 267 ****************************************************************************/
 268 BOOL do_srv_net_srv_share_enum(struct cli_state *cli, uint16 fnum,
 269                         char *server_name,
 270                         uint32 switch_value, SRV_SHARE_INFO_CTR *ctr,
 271                         uint32 preferred_len,
 272                         ENUM_HND *hnd)
 273 {
 274         prs_struct data;
 275         prs_struct rdata;
 276         SRV_Q_NET_SHARE_ENUM q_o;
 277     BOOL valid_enum = False;
 278
 279         if (server_name == NULL || ctr == NULL || preferred_len == 0) return False;
 280
 281         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 282         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 283
 284         /* create and send a MSRPC command with api SRV_NETSHAREENUM */
 285
 286         DEBUG(4,("SRV Get Share Info (%s), level %d, enum:%8x\n",
 287                                 server_name, switch_value, get_enum_hnd(hnd)));
 288
 289         q_o.share_level = switch_value;
 290
 291         ctr->switch_value = switch_value;
 292         ctr->ptr_share_ctr = 1;
 293         ctr->share.info1.num_entries_read = 0;
 294         ctr->share.info1.ptr_share_info    = 1;
 295
 296         /* store the parameters */
 297         make_srv_q_net_share_enum(&q_o, server_name,
 298                                  switch_value, ctr,
 299                                  preferred_len,
 300                                  hnd);
 301
 302         /* turn parameters into data stream */
 303         srv_io_q_net_share_enum("", &q_o, &data, 0);
 304
 305         /* send the data on \PIPE\ */
 306         if (rpc_api_pipe_req(cli, fnum, SRV_NETSHAREENUM, &data, &rdata))
 307         {
 308                 SRV_R_NET_SHARE_ENUM r_o;
 309                 BOOL p;
 310
 311                 r_o.ctr = ctr;
 312
 313                 srv_io_r_net_share_enum("", &r_o, &rdata, 0);
 314                 p = rdata.offset != 0;
 315
 316                 if (p && r_o.status != 0)
 317                 {
 318                         /* report error code */
 319                         DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
 320                         p = 0;
 321                 }
 322
 323                 if (p && r_o.ctr->switch_value != switch_value)
 324                 {
 325                         /* different switch levels.  oops. */
 326                         DEBUG(0,("SRV_R_NET_SRV_SHARE_ENUM: info class %d does not match request %d\n",
 327                                 r_o.ctr->switch_value, switch_value));
 328                         p = 0;
 329                 }
 330
 331                 if (p)
 332                 {
 333                         /* ok, at last: we're happy. */
 334                         valid_enum = True;
 335                 }
 336         }
 337
 338         prs_mem_free(&data   );
 339         prs_mem_free(&rdata  );
 340
 341         return valid_enum;
 342 }
 343
 344 /****************************************************************************
 345 do a server net file enum
 346 ****************************************************************************/
 347 BOOL do_srv_net_srv_file_enum(struct cli_state *cli, uint16 fnum,
 348                         char *server_name, char *qual_name, uint32 file_id,
 349                         uint32 switch_value, SRV_FILE_INFO_CTR *ctr,
 350                         uint32 preferred_len,
 351                         ENUM_HND *hnd)
 352 {
 353         prs_struct data;
 354         prs_struct rdata;
 355         SRV_Q_NET_FILE_ENUM q_o;
 356     BOOL valid_enum = False;
 357
 358         if (server_name == NULL || ctr == NULL || preferred_len == 0) return False;
 359
 360         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 361         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 362
 363         /* create and send a MSRPC command with api SRV_NETFILEENUM */
 364
 365         DEBUG(4,("SRV Get File Info (%s), level %d, enum:%8x\n",
 366                                 server_name, switch_value, get_enum_hnd(hnd)));
 367
 368         q_o.file_level = switch_value;
 369
 370         ctr->switch_value = switch_value;
 371         ctr->ptr_file_ctr = 1;
 372         ctr->file.info3.num_entries_read = 0;
 373         ctr->file.info3.ptr_file_info    = 1;
 374
 375         /* store the parameters */
 376         make_srv_q_net_file_enum(&q_o, server_name, qual_name, file_id,
 377                                  switch_value, ctr,
 378                                  preferred_len,
 379                                  hnd);
 380
 381         /* turn parameters into data stream */
 382         srv_io_q_net_file_enum("", &q_o, &data, 0);
 383
 384         /* send the data on \PIPE\ */
 385         if (rpc_api_pipe_req(cli, fnum, SRV_NETFILEENUM, &data, &rdata))
 386         {
 387                 SRV_R_NET_FILE_ENUM r_o;
 388                 BOOL p;
 389
 390                 r_o.ctr = ctr;
 391
 392                 srv_io_r_net_file_enum("", &r_o, &rdata, 0);
 393                 p = rdata.offset != 0;
 394
 395                 if (p && r_o.status != 0)
 396                 {
 397                         /* report error code */
 398                         DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
 399                         p = 0;
 400                 }
 401
 402                 if (p && r_o.ctr->switch_value != switch_value)
 403                 {
 404                         /* different switch levels.  oops. */
 405                         DEBUG(0,("SRV_R_NET_SRV_FILE_ENUM: info class %d does not match request %d\n",
 406                                 r_o.ctr->switch_value, switch_value));
 407                         p = 0;
 408                 }
 409
 410                 if (p)
 411                 {
 412                         /* ok, at last: we're happy. */
 413                         valid_enum = True;
 414                 }
 415         }
 416
 417         prs_mem_free(&data   );
 418         prs_mem_free(&rdata  );
 419
 420         return valid_enum;
 421 }
 422
 423 /****************************************************************************
 424 do a server get info
 425 ****************************************************************************/
 426 BOOL do_srv_net_srv_get_info(struct cli_state *cli, uint16 fnum,
 427                         char *server_name, uint32 switch_value, SRV_INFO_CTR *ctr)
 428 {
 429         prs_struct data;
 430         prs_struct rdata;
 431         SRV_Q_NET_SRV_GET_INFO q_o;
 432     BOOL valid_info = False;
 433
 434         if (server_name == NULL || switch_value == 0 || ctr == NULL) return False;
 435
 436         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 437         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 438
 439         /* create and send a MSRPC command with api SRV_NET_SRV_GET_INFO */
 440
 441         DEBUG(4,("SRV Get Server Info (%s), level %d\n", server_name, switch_value));
 442
 443         /* store the parameters */
 444         make_srv_q_net_srv_get_info(&q_o, server_name, switch_value);
 445
 446         /* turn parameters into data stream */
 447         srv_io_q_net_srv_get_info("", &q_o, &data, 0);
 448
 449         /* send the data on \PIPE\ */
 450         if (rpc_api_pipe_req(cli, fnum, SRV_NET_SRV_GET_INFO, &data, &rdata))
 451         {
 452                 SRV_R_NET_SRV_GET_INFO r_o;
 453                 BOOL p;
 454
 455                 r_o.ctr = ctr;
 456
 457                 srv_io_r_net_srv_get_info("", &r_o, &rdata, 0);
 458                 p = rdata.offset != 0;
 459                 p = rdata.offset != 0;
 460
 461                 if (p && r_o.status != 0)
 462                 {
 463                         /* report error code */
 464                         DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
 465                         p = 0;
 466                 }
 467
 468                 if (p && r_o.ctr->switch_value != q_o.switch_value)
 469                 {
 470                         /* different switch levels.  oops. */
 471                         DEBUG(0,("SRV_R_NET_SRV_GET_INFO: info class %d does not match request %d\n",
 472                                 r_o.ctr->switch_value, q_o.switch_value));
 473                         p = 0;
 474                 }
 475
 476                 if (p)
 477                 {
 478                         /* ok, at last: we're happy. */
 479                         valid_info = True;
 480                 }
 481         }
 482
 483         prs_mem_free(&data   );
 484         prs_mem_free(&rdata  );
 485
 486         return valid_info;
 487 }
 488
 489 /****************************************************************************
 490 get server time
 491 ****************************************************************************/
 492 BOOL do_srv_net_remote_tod(struct cli_state *cli, uint16 fnum,
 493                            char *server_name, TIME_OF_DAY_INFO *tod)
 494 {
 495         prs_struct data;
 496         prs_struct rdata;
 497         SRV_Q_NET_REMOTE_TOD q_t;
 498         BOOL valid_info = False;
 499
 500         if (server_name == NULL || tod == NULL) return False;
 501
 502         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 503         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 504
 505         /* create and send a MSRPC command with api SRV_NET_REMOTE_TOD */
 506
 507         DEBUG(4,("SRV Remote TOD (%s)\n", server_name));
 508
 509         /* store the parameters */
 510         make_srv_q_net_remote_tod(&q_t, server_name);
 511
 512         /* turn parameters into data stream */
 513         srv_io_q_net_remote_tod("", &q_t, &data, 0);
 514
 515         /* send the data on \PIPE\ */
 516         if (rpc_api_pipe_req(cli, fnum, SRV_NET_REMOTE_TOD, &data, &rdata))
 517         {
 518                 SRV_R_NET_REMOTE_TOD r_t;
 519                 BOOL p;
 520
 521                 r_t.tod = tod;
 522
 523                 srv_io_r_net_remote_tod("", &r_t, &rdata, 0);
 524                 p = rdata.offset != 0;
 525                 p = rdata.offset != 0;
 526
 527                 if (p && r_t.status != 0)
 528                 {
 529                         /* report error code */
 530                         DEBUG(0,("SRV_R_NET_REMOTE_TOD: %s\n", get_nt_error_msg(r_t.status)));
 531                         p = False;
 532                 }
 533
 534                 if (p)
 535                 {
 536                         valid_info = True;
 537                 }
 538         }
 539
 540         prs_mem_free(&data   );
 541         prs_mem_free(&rdata  );
 542
 543         return valid_info;
 544 }