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