source/libsmb/cli_srvsvc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    NT Domain Authentication SMB / MSRPC client
   4    Copyright (C) Andrew Tridgell 1994-2000
   5    Copyright (C) Luke Kenneth Casson Leighton 1996-2000
   6    Copyright (C) Tim Potter 2001
   7    Copyright (C) Jim McDonough 2002
   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 NTSTATUS cli_srvsvc_net_srv_get_info(struct cli_state *cli,
  27                                      TALLOC_CTX *mem_ctx,
  28                                      uint32 switch_value, SRV_INFO_CTR *ctr)
  29 {
  30         prs_struct qbuf, rbuf;
  31         SRV_Q_NET_SRV_GET_INFO q;
  32         SRV_R_NET_SRV_GET_INFO r;
  33         NTSTATUS result;
  34
  35         ZERO_STRUCT(q);
  36         ZERO_STRUCT(r);
  37
  38         /* Initialise parse structures */
  39
  40         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  41         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  42
  43         /* Initialise input parameters */
  44
  45         init_srv_q_net_srv_get_info(&q, cli->srv_name_slash, switch_value);
  46
  47         /* Marshall data and send request */
  48
  49         if (!srv_io_q_net_srv_get_info("", &q, &qbuf, 0) ||
  50             !rpc_api_pipe_req(cli, SRV_NET_SRV_GET_INFO, &qbuf, &rbuf)) {
  51                 result = NT_STATUS_UNSUCCESSFUL;
  52                 goto done;
  53         }
  54
  55         /* Unmarshall response */
  56
  57         r.ctr = ctr;
  58
  59         if (!srv_io_r_net_srv_get_info("", &r, &rbuf, 0)) {
  60                 result = NT_STATUS_UNSUCCESSFUL;
  61                 goto done;
  62         }
  63
  64         result = werror_to_ntstatus(r.status);
  65
  66  done:
  67         prs_mem_free(&qbuf);
  68         prs_mem_free(&rbuf);
  69
  70         return result;
  71 }
  72
  73 WERROR cli_srvsvc_net_share_enum(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  74                                  uint32 info_level, SRV_SHARE_INFO_CTR *ctr,
  75                                  int preferred_len, ENUM_HND *hnd)
  76 {
  77         prs_struct qbuf, rbuf;
  78         SRV_Q_NET_SHARE_ENUM q;
  79         SRV_R_NET_SHARE_ENUM r;
  80         WERROR result = W_ERROR(ERRgeneral);
  81         int i;
  82
  83         ZERO_STRUCT(q);
  84         ZERO_STRUCT(r);
  85
  86         /* Initialise parse structures */
  87
  88         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  89         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  90
  91         /* Initialise input parameters */
  92
  93         init_srv_q_net_share_enum(
  94                 &q, cli->srv_name_slash, info_level, preferred_len, hnd);
  95
  96         /* Marshall data and send request */
  97
  98         if (!srv_io_q_net_share_enum("", &q, &qbuf, 0) ||
  99             !rpc_api_pipe_req(cli, SRV_NET_SHARE_ENUM_ALL, &qbuf, &rbuf))
 100                 goto done;
 101
 102         /* Unmarshall response */
 103
 104         if (!srv_io_r_net_share_enum("", &r, &rbuf, 0))
 105                 goto done;
 106
 107         result = r.status;
 108
 109         if (!W_ERROR_IS_OK(result))
 110                 goto done;
 111
 112         /* Oh yuck yuck yuck - we have to copy all the info out of the
 113            SRV_SHARE_INFO_CTR in the SRV_R_NET_SHARE_ENUM as when we do a
 114            prs_mem_free() it will all be invalidated.  The various share
 115            info structures suck badly too.  This really is gross. */
 116
 117         ZERO_STRUCTP(ctr);
 118
 119         ctr->info_level = info_level;
 120         ctr->num_entries = r.ctr.num_entries;
 121
 122         switch(info_level) {
 123         case 1:
 124                 ctr->share.info1 = (SRV_SHARE_INFO_1 *)talloc(
 125                         mem_ctx, sizeof(SRV_SHARE_INFO_1) * ctr->num_entries);
 126
 127                 memset(ctr->share.info1, 0, sizeof(SRV_SHARE_INFO_1));
 128
 129                 for (i = 0; i < ctr->num_entries; i++) {
 130                         SRV_SHARE_INFO_1 *info1 = &ctr->share.info1[i];
 131                         char *s;
 132
 133                         /* Copy pointer crap */
 134
 135                         memcpy(&info1->info_1, &r.ctr.share.info1[i].info_1,
 136                                sizeof(SH_INFO_1));
 137
 138                         /* Duplicate strings */
 139
 140                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_netname);
 141                         if (s)
 142                                 init_unistr2(&info1->info_1_str.uni_netname, s, strlen(s) + 1);
 143
 144                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_remark);
 145                         if (s)
 146                                 init_unistr2(&info1->info_1_str.uni_remark, s, strlen(s) + 1);
 147
 148                 }
 149
 150                 break;
 151         case 2:
 152                 ctr->share.info2 = (SRV_SHARE_INFO_2 *)talloc(
 153                         mem_ctx, sizeof(SRV_SHARE_INFO_2) * ctr->num_entries);
 154
 155                 memset(ctr->share.info2, 0, sizeof(SRV_SHARE_INFO_2));
 156
 157                 for (i = 0; i < ctr->num_entries; i++) {
 158                         SRV_SHARE_INFO_2 *info2 = &ctr->share.info2[i];
 159                         char *s;
 160
 161                         /* Copy pointer crap */
 162
 163                         memcpy(&info2->info_2, &r.ctr.share.info2[i].info_2,
 164                                sizeof(SH_INFO_2));
 165
 166                         /* Duplicate strings */
 167
 168                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_netname);
 169                         if (s)
 170                                 init_unistr2(&info2->info_2_str.uni_netname, s, strlen(s) + 1);
 171
 172                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_remark);
 173                         if (s)
 174                                 init_unistr2(&info2->info_2_str.uni_remark, s, strlen(s) + 1);
 175
 176                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_path);
 177                         if (s)
 178                                 init_unistr2(&info2->info_2_str.uni_path, s, strlen(s) + 1);
 179
 180                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_passwd);
 181                         if (s)
 182                                 init_unistr2(&info2->info_2_str.uni_passwd, s, strlen(s) + 1);
 183                 }
 184                 break;
 185         }
 186  done:
 187         prs_mem_free(&qbuf);
 188         prs_mem_free(&rbuf);
 189
 190         return result;
 191 }
 192
 193 WERROR cli_srvsvc_net_share_del(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 194                                 const char *sharename)
 195 {
 196         prs_struct qbuf, rbuf;
 197         SRV_Q_NET_SHARE_DEL q;
 198         SRV_R_NET_SHARE_DEL r;
 199         WERROR result = W_ERROR(ERRgeneral);
 200
 201         ZERO_STRUCT(q);
 202         ZERO_STRUCT(r);
 203
 204         /* Initialise parse structures */
 205
 206         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 207         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 208
 209         /* Initialise input parameters */
 210
 211         init_srv_q_net_share_del(&q, cli->srv_name_slash, sharename);
 212
 213         /* Marshall data and send request */
 214
 215         if (!srv_io_q_net_share_del("", &q, &qbuf, 0) ||
 216             !rpc_api_pipe_req(cli, SRV_NET_SHARE_DEL, &qbuf, &rbuf))
 217                 goto done;
 218
 219         /* Unmarshall response */
 220
 221         if (!srv_io_r_net_share_del("", &r, &rbuf, 0))
 222                 goto done;
 223
 224         result = r.status;
 225
 226  done:
 227         prs_mem_free(&qbuf);
 228         prs_mem_free(&rbuf);
 229
 230         return result;
 231 }
 232
 233 WERROR cli_srvsvc_net_share_add(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 234                                 char *netname, uint32 type, char *remark,
 235                                 uint32 perms, uint32 max_uses, uint32 num_uses,
 236                                 char *path, char *passwd)
 237 {
 238         prs_struct qbuf, rbuf;
 239         SRV_Q_NET_SHARE_ADD q;
 240         SRV_R_NET_SHARE_ADD r;
 241         WERROR result = W_ERROR(ERRgeneral);
 242
 243         ZERO_STRUCT(q);
 244         ZERO_STRUCT(r);
 245
 246         /* Initialise parse structures */
 247
 248         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 249         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 250
 251         init_srv_q_net_share_add(&q,cli->srv_name_slash, netname, type, remark,
 252                                  perms, max_uses, num_uses, path, passwd);
 253
 254         /* Marshall data and send request */
 255
 256         if (!srv_io_q_net_share_add("", &q, &qbuf, 0) ||
 257             !rpc_api_pipe_req(cli, SRV_NET_SHARE_ADD, &qbuf, &rbuf))
 258                 goto done;
 259
 260         /* Unmarshall response */
 261
 262         if (!srv_io_r_net_share_add("", &r, &rbuf, 0))
 263                 goto done;
 264
 265         result = r.status;
 266
 267  done:
 268         prs_mem_free(&qbuf);
 269         prs_mem_free(&rbuf);
 270
 271         return result;
 272 }
 273
 274 WERROR cli_srvsvc_net_remote_tod(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 275                                  char *server, TIME_OF_DAY_INFO *tod)
 276 {
 277         prs_struct qbuf, rbuf;
 278         SRV_Q_NET_REMOTE_TOD q;
 279         SRV_R_NET_REMOTE_TOD r;
 280         WERROR result = W_ERROR(ERRgeneral);
 281
 282         ZERO_STRUCT(q);
 283         ZERO_STRUCT(r);
 284
 285         /* Initialise parse structures */
 286
 287         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 288         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 289
 290         /* Initialise input parameters */
 291
 292         init_srv_q_net_remote_tod(&q, cli->srv_name_slash);
 293
 294         /* Marshall data and send request */
 295
 296         if (!srv_io_q_net_remote_tod("", &q, &qbuf, 0) ||
 297             !rpc_api_pipe_req(cli, SRV_NET_REMOTE_TOD, &qbuf, &rbuf))
 298                 goto done;
 299
 300         /* Unmarshall response */
 301
 302         r.tod = tod;
 303
 304         if (!srv_io_r_net_remote_tod("", &r, &rbuf, 0))
 305                 goto done;
 306
 307         result = r.status;
 308
 309         if (!W_ERROR_IS_OK(result))
 310                 goto done;
 311
 312  done:
 313         prs_mem_free(&qbuf);
 314         prs_mem_free(&rbuf);
 315
 316         return result;
 317 }
 318
 319 WERROR cli_srvsvc_net_file_enum(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 320                                 uint32 file_level, const char *user_name,
 321                                 SRV_FILE_INFO_CTR *ctr, int preferred_len,
 322                                 ENUM_HND *hnd)
 323 {
 324         prs_struct qbuf, rbuf;
 325         SRV_Q_NET_FILE_ENUM q;
 326         SRV_R_NET_FILE_ENUM r;
 327         WERROR result = W_ERROR(ERRgeneral);
 328         int i;
 329
 330         ZERO_STRUCT(q);
 331         ZERO_STRUCT(r);
 332
 333         /* Initialise parse structures */
 334
 335         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 336         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 337
 338         /* Initialise input parameters */
 339
 340         init_srv_q_net_file_enum(&q, cli->srv_name_slash, NULL, user_name,
 341                                  file_level, ctr, preferred_len, hnd);
 342
 343         /* Marshall data and send request */
 344
 345         if (!srv_io_q_net_file_enum("", &q, &qbuf, 0) ||
 346             !rpc_api_pipe_req(cli, SRV_NET_FILE_ENUM, &qbuf, &rbuf))
 347                 goto done;
 348
 349         /* Unmarshall response */
 350
 351         if (!srv_io_r_net_file_enum("", &r, &rbuf, 0))
 352                 goto done;
 353
 354         result = r.status;
 355
 356         if (!W_ERROR_IS_OK(result))
 357                 goto done;
 358
 359         /* copy the data over to the ctr */
 360
 361         ZERO_STRUCTP(ctr);
 362
 363         ctr->switch_value = file_level;
 364
 365         ctr->num_entries = ctr->num_entries2 = r.ctr.num_entries;
 366
 367         switch(file_level) {
 368         case 3:
 369                 ctr->file.info3 = (SRV_FILE_INFO_3 *)talloc(
 370                         mem_ctx, sizeof(SRV_FILE_INFO_3) * ctr->num_entries);
 371
 372                 memset(ctr->file.info3, 0,
 373                        sizeof(SRV_FILE_INFO_3) * ctr->num_entries);
 374
 375                 for (i = 0; i < r.ctr.num_entries; i++) {
 376                         SRV_FILE_INFO_3 *info3 = &ctr->file.info3[i];
 377                         char *s;
 378
 379                         /* Copy pointer crap */
 380
 381                         memcpy(&info3->info_3, &r.ctr.file.info3[i].info_3,
 382                                sizeof(FILE_INFO_3));
 383
 384                         /* Duplicate strings */
 385
 386                         s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_path_name);
 387                         if (s)
 388                                 init_unistr2(&info3->info_3_str.uni_path_name, s, strlen(s) + 1);
 389
 390                         s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_user_name);
 391                         if (s)
 392                                 init_unistr2(&info3->info_3_str.uni_user_name, s, strlen(s) + 1);
 393
 394                 }
 395
 396                 break;
 397         }
 398
 399  done:
 400         prs_mem_free(&qbuf);
 401         prs_mem_free(&rbuf);
 402
 403         return result;
 404 }
 405
 406 WERROR cli_srvsvc_net_file_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 407                                  uint32 file_id)
 408 {
 409         prs_struct qbuf, rbuf;
 410         SRV_Q_NET_FILE_CLOSE q;
 411         SRV_R_NET_FILE_CLOSE r;
 412         WERROR result = W_ERROR(ERRgeneral);
 413
 414         ZERO_STRUCT(q);
 415         ZERO_STRUCT(r);
 416
 417         /* Initialise parse structures */
 418
 419         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 420         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 421
 422         /* Initialise input parameters */
 423
 424         init_srv_q_net_file_close(&q, cli->srv_name_slash, file_id);
 425
 426         /* Marshall data and send request */
 427
 428         if (!srv_io_q_net_file_close("", &q, &qbuf, 0) ||
 429             !rpc_api_pipe_req(cli, SRV_NET_FILE_CLOSE, &qbuf, &rbuf))
 430                 goto done;
 431
 432         /* Unmarshall response */
 433
 434         if (!srv_io_r_net_file_close("", &r, &rbuf, 0))
 435                 goto done;
 436
 437         result = r.status;
 438  done:
 439         prs_mem_free(&qbuf);
 440         prs_mem_free(&rbuf);
 441         return result;
 442 }