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