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