source3/rpc_client/cli_srvsvc.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1997,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   7  *  Copyright (C) Paul Ashton                       1997.
   8  *  Copyright (C) Jeremy Allison                    1999.
   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 #ifdef SYSLOG
  26 #undef SYSLOG
  27 #endif
  28
  29 #include "includes.h"
  30
  31 /****************************************************************************
  32 do a server net conn enum
  33 ****************************************************************************/
  34 BOOL do_srv_net_srv_conn_enum(struct cli_state *cli,
  35                         char *server_name, char *qual_name,
  36                         uint32 switch_value, SRV_CONN_INFO_CTR *ctr,
  37                         uint32 preferred_len,
  38                         ENUM_HND *hnd)
  39 {
  40         prs_struct data;
  41         prs_struct rdata;
  42         SRV_Q_NET_CONN_ENUM q_o;
  43         SRV_R_NET_CONN_ENUM r_o;
  44
  45         if (server_name == NULL || ctr == NULL || preferred_len == 0)
  46                 return False;
  47
  48         prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
  49         prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
  50
  51         /* create and send a MSRPC command with api SRV_NETCONNENUM */
  52
  53         DEBUG(4,("SRV Net Server Connection Enum(%s, %s), level %d, enum:%8x\n",
  54                                 server_name, qual_name, switch_value, get_enum_hnd(hnd)));
  55
  56         ctr->switch_value = switch_value;
  57         ctr->ptr_conn_ctr = 1;
  58         ctr->conn.info0.num_entries_read = 0;
  59         ctr->conn.info0.ptr_conn_info    = 1;
  60
  61         /* store the parameters */
  62         init_srv_q_net_conn_enum(&q_o, server_name, qual_name,
  63                                  switch_value, ctr,
  64                                  preferred_len,
  65                                  hnd);
  66
  67         /* turn parameters into data stream */
  68         if(!srv_io_q_net_conn_enum("", &q_o, &data, 0)) {
  69                 prs_mem_free(&data);
  70                 prs_mem_free(&rdata);
  71                 return False;
  72         }
  73
  74         /* send the data on \PIPE\ */
  75         if(!rpc_api_pipe_req(cli, SRV_NETCONNENUM, &data, &rdata)) {
  76                 prs_mem_free(&data);
  77                 prs_mem_free(&rdata);
  78                 return False;
  79         }
  80
  81         prs_mem_free(&data);
  82
  83         r_o.ctr = ctr;
  84
  85         if(!srv_io_r_net_conn_enum("", &r_o, &rdata, 0)) {
  86                 prs_mem_free(&rdata);
  87                 return False;
  88         }
  89
  90         if (r_o.status != 0) {
  91                 /* report error code */
  92                 DEBUG(0,("SRV_R_NET_SRV_CONN_ENUM: %s\n", get_nt_error_msg(r_o.status)));
  93                 prs_mem_free(&rdata);
  94                 return False;
  95         }
  96
  97         if (r_o.ctr->switch_value != switch_value) {
  98                 /* different switch levels.  oops. */
  99                 DEBUG(0,("SRV_R_NET_SRV_CONN_ENUM: info class %d does not match request %d\n",
 100                         r_o.ctr->switch_value, switch_value));
 101                 prs_mem_free(&rdata);
 102                 return False;
 103         }
 104
 105         prs_mem_free(&rdata);
 106
 107         return True;
 108 }
 109
 110 /****************************************************************************
 111 do a server net sess enum
 112 ****************************************************************************/
 113
 114 BOOL do_srv_net_srv_sess_enum(struct cli_state *cli,
 115                         char *server_name, char *qual_name,
 116                         uint32 switch_value, SRV_SESS_INFO_CTR *ctr,
 117                         uint32 preferred_len,
 118                         ENUM_HND *hnd)
 119 {
 120         prs_struct data;
 121         prs_struct rdata;
 122         SRV_Q_NET_SESS_ENUM q_o;
 123         SRV_R_NET_SESS_ENUM r_o;
 124
 125         if (server_name == NULL || ctr == NULL || preferred_len == 0)
 126                 return False;
 127
 128         prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
 129         prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
 130
 131         /* create and send a MSRPC command with api SRV_NETSESSENUM */
 132
 133         DEBUG(4,("SRV Net Session Enum (%s), level %d, enum:%8x\n",
 134                                 server_name, switch_value, get_enum_hnd(hnd)));
 135
 136         ctr->switch_value = switch_value;
 137         ctr->ptr_sess_ctr = 1;
 138         ctr->sess.info0.num_entries_read = 0;
 139         ctr->sess.info0.ptr_sess_info    = 1;
 140
 141         /* store the parameters */
 142         init_srv_q_net_sess_enum(&q_o, server_name, qual_name,
 143                                  switch_value, ctr,
 144                                  preferred_len,
 145                                  hnd);
 146
 147         /* turn parameters into data stream */
 148         if(!srv_io_q_net_sess_enum("", &q_o, &data, 0)) {
 149                 prs_mem_free(&data);
 150                 prs_mem_free(&rdata);
 151                 return False;
 152         }
 153
 154         /* send the data on \PIPE\ */
 155         if (!rpc_api_pipe_req(cli, SRV_NETSESSENUM, &data, &rdata)) {
 156                 prs_mem_free(&data);
 157                 prs_mem_free(&rdata);
 158                 return False;
 159         }
 160
 161         prs_mem_free(&data);
 162
 163         r_o.ctr = ctr;
 164
 165         if(!srv_io_r_net_sess_enum("", &r_o, &rdata, 0)) {
 166                 prs_mem_free(&rdata);
 167                 return False;
 168         }
 169
 170         if (r_o.status != 0) {
 171                 /* report error code */
 172                 DEBUG(0,("SRV_R_NET_SRV_SESS_ENUM: %s\n", get_nt_error_msg(r_o.status)));
 173                 prs_mem_free(&rdata);
 174                 return False;
 175         }
 176
 177         if (r_o.ctr->switch_value != switch_value) {
 178                 /* different switch levels.  oops. */
 179                 DEBUG(0,("SRV_R_NET_SRV_SESS_ENUM: info class %d does not match request %d\n",
 180                         r_o.ctr->switch_value, switch_value));
 181                 prs_mem_free(&rdata);
 182                 return False;
 183         }
 184
 185         prs_mem_free(&rdata);
 186
 187         return True;
 188 }
 189
 190 /****************************************************************************
 191 do a server net share enum
 192 ****************************************************************************/
 193 BOOL do_srv_net_srv_share_enum(struct cli_state *cli,
 194                         char *server_name,
 195                         uint32 switch_value, SRV_R_NET_SHARE_ENUM *r_o,
 196                         uint32 preferred_len, ENUM_HND *hnd)
 197 {
 198         prs_struct data;
 199         prs_struct rdata;
 200         SRV_Q_NET_SHARE_ENUM q_o;
 201
 202         if (server_name == NULL || preferred_len == 0)
 203                 return False;
 204
 205         prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
 206         prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
 207
 208         /* create and send a MSRPC command with api SRV_NETSHAREENUM */
 209
 210         DEBUG(4,("SRV Get Share Info (%s), level %d, enum:%8x\n",
 211                                 server_name, switch_value, get_enum_hnd(hnd)));
 212
 213         /* store the parameters */
 214         init_srv_q_net_share_enum(&q_o, server_name, switch_value,
 215                                   preferred_len, hnd);
 216
 217         /* turn parameters into data stream */
 218         if(!srv_io_q_net_share_enum("", &q_o, &data, 0)) {
 219                 prs_mem_free(&data);
 220                 prs_mem_free(&rdata);
 221                 return False;
 222         }
 223
 224         /* send the data on \PIPE\ */
 225         if (!rpc_api_pipe_req(cli, SRV_NETSHAREENUM, &data, &rdata)) {
 226                 prs_mem_free(&data);
 227                 prs_mem_free(&rdata);
 228                 return False;
 229         }
 230
 231         prs_mem_free(&data);
 232
 233         if(!srv_io_r_net_share_enum("", r_o, &rdata, 0)) {
 234                 prs_mem_free(&rdata);
 235                 return False;
 236         }
 237
 238         if (r_o->status != 0) {
 239                 /* report error code */
 240                 DEBUG(0,("SRV_R_NET_SHARE_ENUM: %s\n", get_nt_error_msg(r_o->status)));
 241                 prs_mem_free(&rdata);
 242                 return False;
 243         }
 244
 245         if (r_o->ctr.switch_value != switch_value) {
 246                 /* different switch levels.  oops. */
 247                 DEBUG(0,("SRV_R_NET_SHARE_ENUM: info class %d does not match request %d\n",
 248                         r_o->ctr.switch_value, switch_value));
 249                 prs_mem_free(&rdata);
 250                 return False;
 251         }
 252
 253         prs_mem_free(&rdata);
 254
 255         return True;
 256 }
 257
 258 /****************************************************************************
 259 do a server net file enum
 260 ****************************************************************************/
 261
 262 BOOL do_srv_net_srv_file_enum(struct cli_state *cli,
 263                         char *server_name, char *qual_name,
 264                         uint32 switch_value, SRV_FILE_INFO_CTR *ctr,
 265                         uint32 preferred_len,
 266                         ENUM_HND *hnd)
 267 {
 268         prs_struct data;
 269         prs_struct rdata;
 270         SRV_Q_NET_FILE_ENUM q_o;
 271         SRV_R_NET_FILE_ENUM r_o;
 272
 273         if (server_name == NULL || ctr == NULL || preferred_len == 0)
 274                 return False;
 275
 276         prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
 277         prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
 278
 279         /* create and send a MSRPC command with api SRV_NETFILEENUM */
 280
 281         DEBUG(4,("SRV Get File Info (%s), level %d, enum:%8x\n",
 282                                 server_name, switch_value, get_enum_hnd(hnd)));
 283
 284         q_o.file_level = switch_value;
 285
 286         ctr->switch_value = switch_value;
 287         ctr->ptr_file_ctr = 1;
 288         ctr->file.info3.num_entries_read = 0;
 289         ctr->file.info3.ptr_file_info    = 1;
 290
 291         /* store the parameters */
 292         init_srv_q_net_file_enum(&q_o, server_name, qual_name,
 293                                  switch_value, ctr,
 294                                  preferred_len,
 295                                  hnd);
 296
 297         /* turn parameters into data stream */
 298         if(!srv_io_q_net_file_enum("", &q_o, &data, 0)) {
 299                 prs_mem_free(&data);
 300                 prs_mem_free(&rdata);
 301                 return False;
 302         }
 303
 304         /* send the data on \PIPE\ */
 305         if (!rpc_api_pipe_req(cli, SRV_NETFILEENUM, &data, &rdata)) {
 306                 prs_mem_free(&data);
 307                 prs_mem_free(&rdata);
 308                 return False;
 309         }
 310
 311         prs_mem_free(&data);
 312
 313         r_o.ctr = ctr;
 314
 315         if(!srv_io_r_net_file_enum("", &r_o, &rdata, 0)) {
 316                 prs_mem_free(&rdata);
 317                 return False;
 318         }
 319
 320         if (r_o.status != 0) {
 321                 /* report error code */
 322                 DEBUG(0,("SRV_R_NET_FILE_ENUM: %s\n", get_nt_error_msg(r_o.status)));
 323                 prs_mem_free(&rdata);
 324                 return False;
 325         }
 326
 327         if (r_o.ctr->switch_value != switch_value) {
 328                 /* different switch levels.  oops. */
 329                 DEBUG(0,("SRV_R_NET_FILE_ENUM: info class %d does not match request %d\n",
 330                         r_o.ctr->switch_value, switch_value));
 331                 prs_mem_free(&rdata);
 332                 return False;
 333         }
 334
 335         prs_mem_free(&rdata);
 336
 337         return True;
 338 }
 339
 340 /****************************************************************************
 341 do a server get info
 342 ****************************************************************************/
 343 BOOL do_srv_net_srv_get_info(struct cli_state *cli,
 344                         char *server_name, uint32 switch_value, SRV_INFO_CTR *ctr)
 345 {
 346         prs_struct data;
 347         prs_struct rdata;
 348         SRV_Q_NET_SRV_GET_INFO q_o;
 349         SRV_R_NET_SRV_GET_INFO r_o;
 350
 351         if (server_name == NULL || switch_value == 0 || ctr == NULL)
 352                 return False;
 353
 354         prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
 355         prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
 356
 357         /* create and send a MSRPC command with api SRV_NET_SRV_GET_INFO */
 358
 359         DEBUG(4,("SRV Get Server Info (%s), level %d\n", server_name, switch_value));
 360
 361         /* store the parameters */
 362         init_srv_q_net_srv_get_info(&q_o, server_name, switch_value);
 363
 364         /* turn parameters into data stream */
 365         if(!srv_io_q_net_srv_get_info("", &q_o, &data, 0)) {
 366                 prs_mem_free(&data);
 367                 prs_mem_free(&rdata);
 368                 return False;
 369         }
 370
 371         /* send the data on \PIPE\ */
 372         if (!rpc_api_pipe_req(cli, SRV_NET_SRV_GET_INFO, &data, &rdata)) {
 373                 prs_mem_free(&data);
 374                 prs_mem_free(&rdata);
 375                 return False;
 376         }
 377
 378         prs_mem_free(&data);
 379
 380         r_o.ctr = ctr;
 381
 382         if(!srv_io_r_net_srv_get_info("", &r_o, &rdata, 0)) {
 383                 prs_mem_free(&rdata);
 384                 return False;
 385         }
 386
 387         if (r_o.status != 0) {
 388                 /* report error code */
 389                 DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
 390                 prs_mem_free(&rdata);
 391                 return False;
 392         }
 393
 394         if (r_o.ctr->switch_value != q_o.switch_value) {
 395                 /* different switch levels.  oops. */
 396                 DEBUG(0,("SRV_R_NET_SRV_GET_INFO: info class %d does not match request %d\n",
 397                         r_o.ctr->switch_value, q_o.switch_value));
 398                 prs_mem_free(&rdata);
 399                 return False;
 400         }
 401
 402         prs_mem_free(&rdata);
 403
 404         return True;
 405 }