source3/rpc_client/cli_srvsvc.c

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