release/src/router/samba/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, 4, MARSHALL);
  53         prs_init(&rdata, 0, 4, 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, 4, MARSHALL);
 133         prs_init(&rdata, 0, 4, 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, 4, MARSHALL);
 210         prs_init(&rdata, 0, 4, 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                 free_srv_r_net_share_enum(r_o);
 247                 return False;
 248         }
 249
 250         if (r_o->ctr.switch_value != switch_value) {
 251                 /* different switch levels.  oops. */
 252                 DEBUG(0,("SRV_R_NET_SHARE_ENUM: info class %d does not match request %d\n",
 253                         r_o->ctr.switch_value, switch_value));
 254                 prs_mem_free(&rdata);
 255                 free_srv_r_net_share_enum(r_o);
 256                 return False;
 257         }
 258
 259         prs_mem_free(&rdata);
 260
 261         return True;
 262 }
 263
 264 /****************************************************************************
 265 do a server net file enum
 266 ****************************************************************************/
 267
 268 BOOL do_srv_net_srv_file_enum(struct cli_state *cli,
 269                         char *server_name, char *qual_name,
 270                         uint32 switch_value, SRV_FILE_INFO_CTR *ctr,
 271                         uint32 preferred_len,
 272                         ENUM_HND *hnd)
 273 {
 274         prs_struct data;
 275         prs_struct rdata;
 276         SRV_Q_NET_FILE_ENUM q_o;
 277         SRV_R_NET_FILE_ENUM r_o;
 278
 279         if (server_name == NULL || ctr == NULL || preferred_len == 0)
 280                 return False;
 281
 282         prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 283         prs_init(&rdata, 0, 4, UNMARSHALL);
 284
 285         /* create and send a MSRPC command with api SRV_NETFILEENUM */
 286
 287         DEBUG(4,("SRV Get File Info (%s), level %d, enum:%8x\n",
 288                                 server_name, switch_value, get_enum_hnd(hnd)));
 289
 290         q_o.file_level = switch_value;
 291
 292         ctr->switch_value = switch_value;
 293         ctr->ptr_file_ctr = 1;
 294         ctr->file.info3.num_entries_read = 0;
 295         ctr->file.info3.ptr_file_info    = 1;
 296
 297         /* store the parameters */
 298         init_srv_q_net_file_enum(&q_o, server_name, qual_name,
 299                                  switch_value, ctr,
 300                                  preferred_len,
 301                                  hnd);
 302
 303         /* turn parameters into data stream */
 304         if(!srv_io_q_net_file_enum("", &q_o, &data, 0)) {
 305                 prs_mem_free(&data);
 306                 prs_mem_free(&rdata);
 307                 return False;
 308         }
 309
 310         /* send the data on \PIPE\ */
 311         if (!rpc_api_pipe_req(cli, SRV_NETFILEENUM, &data, &rdata)) {
 312                 prs_mem_free(&data);
 313                 prs_mem_free(&rdata);
 314                 return False;
 315         }
 316
 317         prs_mem_free(&data);
 318
 319         r_o.ctr = ctr;
 320
 321         if(!srv_io_r_net_file_enum("", &r_o, &rdata, 0)) {
 322                 prs_mem_free(&rdata);
 323                 return False;
 324         }
 325
 326         if (r_o.status != 0) {
 327                 /* report error code */
 328                 DEBUG(0,("SRV_R_NET_FILE_ENUM: %s\n", get_nt_error_msg(r_o.status)));
 329                 prs_mem_free(&rdata);
 330                 return False;
 331         }
 332
 333         if (r_o.ctr->switch_value != switch_value) {
 334                 /* different switch levels.  oops. */
 335                 DEBUG(0,("SRV_R_NET_FILE_ENUM: info class %d does not match request %d\n",
 336                         r_o.ctr->switch_value, switch_value));
 337                 prs_mem_free(&rdata);
 338                 return False;
 339         }
 340
 341         prs_mem_free(&rdata);
 342
 343         return True;
 344 }
 345
 346 /****************************************************************************
 347 do a server get info
 348 ****************************************************************************/
 349 BOOL do_srv_net_srv_get_info(struct cli_state *cli,
 350                         char *server_name, uint32 switch_value, SRV_INFO_CTR *ctr)
 351 {
 352         prs_struct data;
 353         prs_struct rdata;
 354         SRV_Q_NET_SRV_GET_INFO q_o;
 355         SRV_R_NET_SRV_GET_INFO r_o;
 356
 357         if (server_name == NULL || switch_value == 0 || ctr == NULL)
 358                 return False;
 359
 360         prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 361         prs_init(&rdata, 0, 4, UNMARSHALL);
 362
 363         /* create and send a MSRPC command with api SRV_NET_SRV_GET_INFO */
 364
 365         DEBUG(4,("SRV Get Server Info (%s), level %d\n", server_name, switch_value));
 366
 367         /* store the parameters */
 368         init_srv_q_net_srv_get_info(&q_o, server_name, switch_value);
 369
 370         /* turn parameters into data stream */
 371         if(!srv_io_q_net_srv_get_info("", &q_o, &data, 0)) {
 372                 prs_mem_free(&data);
 373                 prs_mem_free(&rdata);
 374                 return False;
 375         }
 376
 377         /* send the data on \PIPE\ */
 378         if (!rpc_api_pipe_req(cli, SRV_NET_SRV_GET_INFO, &data, &rdata)) {
 379                 prs_mem_free(&data);
 380                 prs_mem_free(&rdata);
 381                 return False;
 382         }
 383
 384         prs_mem_free(&data);
 385
 386         r_o.ctr = ctr;
 387
 388         if(!srv_io_r_net_srv_get_info("", &r_o, &rdata, 0)) {
 389                 prs_mem_free(&rdata);
 390                 return False;
 391         }
 392
 393         if (r_o.status != 0) {
 394                 /* report error code */
 395                 DEBUG(0,("SRV_R_NET_SRV_GET_INFO: %s\n", get_nt_error_msg(r_o.status)));
 396                 prs_mem_free(&rdata);
 397                 return False;
 398         }
 399
 400         if (r_o.ctr->switch_value != q_o.switch_value) {
 401                 /* different switch levels.  oops. */
 402                 DEBUG(0,("SRV_R_NET_SRV_GET_INFO: info class %d does not match request %d\n",
 403                         r_o.ctr->switch_value, q_o.switch_value));
 404                 prs_mem_free(&rdata);
 405                 return False;
 406         }
 407
 408         prs_mem_free(&rdata);
 409
 410         return True;
 411 }