source/rpc_client/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 <jmcd@us.ibm.com> 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 WERROR 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         WERROR result = W_ERROR(ERRgeneral);
  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, PI_SRVSVC, SRV_NET_SRV_GET_INFO, &qbuf, &rbuf))
  51                 goto done;
  52
  53         /* Unmarshall response */
  54
  55         r.ctr = ctr;
  56
  57         if (!srv_io_r_net_srv_get_info("", &r, &rbuf, 0))
  58                 goto done;
  59
  60         result = r.status;
  61
  62  done:
  63         prs_mem_free(&qbuf);
  64         prs_mem_free(&rbuf);
  65
  66         return result;
  67 }
  68
  69 WERROR cli_srvsvc_net_share_enum(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  70                                  uint32 info_level, SRV_SHARE_INFO_CTR *ctr,
  71                                  int preferred_len, ENUM_HND *hnd)
  72 {
  73         prs_struct qbuf, rbuf;
  74         SRV_Q_NET_SHARE_ENUM q;
  75         SRV_R_NET_SHARE_ENUM r;
  76         WERROR result = W_ERROR(ERRgeneral);
  77         int i;
  78
  79         ZERO_STRUCT(q);
  80         ZERO_STRUCT(r);
  81
  82         /* Initialise parse structures */
  83
  84         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  85         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  86
  87         /* Initialise input parameters */
  88
  89         init_srv_q_net_share_enum(
  90                 &q, cli->srv_name_slash, info_level, preferred_len, hnd);
  91
  92         /* Marshall data and send request */
  93
  94         if (!srv_io_q_net_share_enum("", &q, &qbuf, 0) ||
  95             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_SHARE_ENUM_ALL, &qbuf, &rbuf))
  96                 goto done;
  97
  98         /* Unmarshall response */
  99
 100         if (!srv_io_r_net_share_enum("", &r, &rbuf, 0))
 101                 goto done;
 102
 103         result = r.status;
 104
 105         if (!W_ERROR_IS_OK(result))
 106                 goto done;
 107
 108         /* Oh yuck yuck yuck - we have to copy all the info out of the
 109            SRV_SHARE_INFO_CTR in the SRV_R_NET_SHARE_ENUM as when we do a
 110            prs_mem_free() it will all be invalidated.  The various share
 111            info structures suck badly too.  This really is gross. */
 112
 113         ZERO_STRUCTP(ctr);
 114
 115         if (!r.ctr.num_entries)
 116                 goto done;
 117
 118         ctr->info_level = info_level;
 119         ctr->num_entries = r.ctr.num_entries;
 120
 121         switch(info_level) {
 122         case 1:
 123                 ctr->share.info1 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_1, ctr->num_entries);
 124
 125                 memset(ctr->share.info1, 0, sizeof(SRV_SHARE_INFO_1));
 126
 127                 for (i = 0; i < ctr->num_entries; i++) {
 128                         SRV_SHARE_INFO_1 *info1 = &ctr->share.info1[i];
 129                         char *s;
 130
 131                         /* Copy pointer crap */
 132
 133                         memcpy(&info1->info_1, &r.ctr.share.info1[i].info_1,
 134                                sizeof(SH_INFO_1));
 135
 136                         /* Duplicate strings */
 137
 138                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_netname);
 139                         if (s)
 140                                 init_unistr2(&info1->info_1_str.uni_netname, s, UNI_STR_TERMINATE);
 141
 142                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_remark);
 143                         if (s)
 144                                 init_unistr2(&info1->info_1_str.uni_remark, s, UNI_STR_TERMINATE);
 145
 146                 }
 147
 148                 break;
 149         case 2:
 150                 ctr->share.info2 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_2, ctr->num_entries);
 151
 152                 memset(ctr->share.info2, 0, sizeof(SRV_SHARE_INFO_2));
 153
 154                 for (i = 0; i < ctr->num_entries; i++) {
 155                         SRV_SHARE_INFO_2 *info2 = &ctr->share.info2[i];
 156                         char *s;
 157
 158                         /* Copy pointer crap */
 159
 160                         memcpy(&info2->info_2, &r.ctr.share.info2[i].info_2,
 161                                sizeof(SH_INFO_2));
 162
 163                         /* Duplicate strings */
 164
 165                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_netname);
 166                         if (s)
 167                                 init_unistr2(&info2->info_2_str.uni_netname, s, UNI_STR_TERMINATE);
 168
 169                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_remark);
 170                         if (s)
 171                                 init_unistr2(&info2->info_2_str.uni_remark, s, UNI_STR_TERMINATE);
 172
 173                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_path);
 174                         if (s)
 175                                 init_unistr2(&info2->info_2_str.uni_path, s, UNI_STR_TERMINATE);
 176
 177                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_passwd);
 178                         if (s)
 179                                 init_unistr2(&info2->info_2_str.uni_passwd, s, UNI_STR_TERMINATE);
 180                 }
 181                 break;
 182         /* adding info-level 502 here */
 183         case 502:
 184                 ctr->share.info502 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_502, ctr->num_entries);
 185
 186                 memset(ctr->share.info502, 0, sizeof(SRV_SHARE_INFO_502));
 187
 188                 for (i = 0; i < ctr->num_entries; i++) {
 189                         SRV_SHARE_INFO_502 *info502 = &ctr->share.info502[i];
 190                         char *s;
 191
 192                         /* Copy pointer crap */
 193                         memcpy(&info502->info_502, &r.ctr.share.info502[i].info_502,
 194                                sizeof(SH_INFO_502));
 195
 196                         /* Duplicate strings */
 197
 198                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_netname);
 199                         if (s)
 200                                 init_unistr2(&info502->info_502_str.uni_netname, s, UNI_STR_TERMINATE);
 201
 202                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_remark);
 203                         if (s)
 204                                 init_unistr2(&info502->info_502_str.uni_remark, s, UNI_STR_TERMINATE);
 205
 206                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_path);
 207                         if (s)
 208                                 init_unistr2(&info502->info_502_str.uni_path, s, UNI_STR_TERMINATE);
 209
 210                         s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_passwd);
 211                         if (s)
 212                                 init_unistr2(&info502->info_502_str.uni_passwd, s, UNI_STR_TERMINATE);
 213
 214                         info502->info_502_str.sd = dup_sec_desc(mem_ctx, r.ctr.share.info502[i].info_502_str.sd);
 215                 }
 216                 break;
 217         }
 218  done:
 219         prs_mem_free(&qbuf);
 220         prs_mem_free(&rbuf);
 221
 222         return result;
 223 }
 224
 225 WERROR cli_srvsvc_net_share_get_info(struct cli_state *cli,
 226                                      TALLOC_CTX *mem_ctx,
 227                                      const char *sharename,
 228                                      uint32 info_level,
 229                                      SRV_SHARE_INFO *info)
 230 {
 231         prs_struct qbuf, rbuf;
 232         SRV_Q_NET_SHARE_GET_INFO q;
 233         SRV_R_NET_SHARE_GET_INFO r;
 234         WERROR result = W_ERROR(ERRgeneral);
 235
 236         ZERO_STRUCT(q);
 237         ZERO_STRUCT(r);
 238
 239         /* Initialise parse structures */
 240
 241         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 242         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 243
 244         /* Initialise input parameters */
 245
 246         init_srv_q_net_share_get_info(&q, cli->srv_name_slash, sharename,
 247                                       info_level);
 248
 249         /* Marshall data and send request */
 250
 251         if (!srv_io_q_net_share_get_info("", &q, &qbuf, 0) ||
 252             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_SHARE_GET_INFO, &qbuf, &rbuf))
 253                 goto done;
 254
 255         /* Unmarshall response */
 256
 257         if (!srv_io_r_net_share_get_info("", &r, &rbuf, 0))
 258                 goto done;
 259
 260         result = r.status;
 261
 262         if (!W_ERROR_IS_OK(result))
 263                 goto done;
 264
 265         ZERO_STRUCTP(info);
 266
 267         info->switch_value = info_level;
 268
 269         switch(info_level) {
 270         case 502:
 271         {
 272                 SRV_SHARE_INFO_502 *info502 = &info->share.info502;
 273                 SH_INFO_502_STR *info502_str = &info502->info_502_str;
 274
 275                 char *s;
 276
 277                 info->share.info502 = r.info.share.info502;
 278
 279                 /* Duplicate strings */
 280
 281                 s = unistr2_tdup(mem_ctx, &info502_str->uni_netname);
 282                 if (s)
 283                         init_unistr2(&info502_str->uni_netname,
 284                                      s, UNI_STR_TERMINATE);
 285
 286                 s = unistr2_tdup(mem_ctx, &info502_str->uni_remark);
 287                 if (s)
 288                         init_unistr2(&info502_str->uni_remark,
 289                                      s, UNI_STR_TERMINATE);
 290
 291                 s = unistr2_tdup(mem_ctx, &info502_str->uni_path);
 292                 if (s)
 293                         init_unistr2(&info502_str->uni_path,
 294                                      s, UNI_STR_TERMINATE);
 295
 296                 s = unistr2_tdup(mem_ctx, &info502_str->uni_passwd);
 297                 if (s)
 298                         init_unistr2(&info502_str->uni_passwd,
 299                                      s, UNI_STR_TERMINATE);
 300
 301                 info502_str->sd = dup_sec_desc(mem_ctx, info502_str->sd);
 302                 break;
 303         }
 304         }
 305
 306  done:
 307         prs_mem_free(&qbuf);
 308         prs_mem_free(&rbuf);
 309
 310         return result;
 311 }
 312
 313 WERROR cli_srvsvc_net_share_del(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 314                                 const char *sharename)
 315 {
 316         prs_struct qbuf, rbuf;
 317         SRV_Q_NET_SHARE_DEL q;
 318         SRV_R_NET_SHARE_DEL r;
 319         WERROR result = W_ERROR(ERRgeneral);
 320
 321         ZERO_STRUCT(q);
 322         ZERO_STRUCT(r);
 323
 324         /* Initialise parse structures */
 325
 326         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 327         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 328
 329         /* Initialise input parameters */
 330
 331         init_srv_q_net_share_del(&q, cli->srv_name_slash, sharename);
 332
 333         /* Marshall data and send request */
 334
 335         if (!srv_io_q_net_share_del("", &q, &qbuf, 0) ||
 336             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_SHARE_DEL, &qbuf, &rbuf))
 337                 goto done;
 338
 339         /* Unmarshall response */
 340
 341         if (!srv_io_r_net_share_del("", &r, &rbuf, 0))
 342                 goto done;
 343
 344         result = r.status;
 345
 346  done:
 347         prs_mem_free(&qbuf);
 348         prs_mem_free(&rbuf);
 349
 350         return result;
 351 }
 352
 353 WERROR cli_srvsvc_net_share_add(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 354                                 const char *netname, uint32 type,
 355                                 const char *remark, uint32 perms,
 356                                 uint32 max_uses, uint32 num_uses,
 357                                 const char *path, const char *passwd,
 358                                 int level, SEC_DESC *sd)
 359 {
 360         prs_struct qbuf, rbuf;
 361         SRV_Q_NET_SHARE_ADD q;
 362         SRV_R_NET_SHARE_ADD r;
 363         WERROR result = W_ERROR(ERRgeneral);
 364
 365         ZERO_STRUCT(q);
 366         ZERO_STRUCT(r);
 367
 368         /* Initialise parse structures */
 369
 370         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 371         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 372
 373         init_srv_q_net_share_add(&q,cli->srv_name_slash, netname, type, remark,
 374                                  perms, max_uses, num_uses, path, passwd,
 375                                  level, sd);
 376
 377         /* Marshall data and send request */
 378
 379         if (!srv_io_q_net_share_add("", &q, &qbuf, 0) ||
 380             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_SHARE_ADD, &qbuf, &rbuf))
 381                 goto done;
 382
 383         /* Unmarshall response */
 384
 385         if (!srv_io_r_net_share_add("", &r, &rbuf, 0))
 386                 goto done;
 387
 388         result = r.status;
 389
 390  done:
 391         prs_mem_free(&qbuf);
 392         prs_mem_free(&rbuf);
 393
 394         return result;
 395 }
 396
 397 WERROR cli_srvsvc_net_remote_tod(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 398                                  char *server, TIME_OF_DAY_INFO *tod)
 399 {
 400         prs_struct qbuf, rbuf;
 401         SRV_Q_NET_REMOTE_TOD q;
 402         SRV_R_NET_REMOTE_TOD r;
 403         WERROR result = W_ERROR(ERRgeneral);
 404
 405         ZERO_STRUCT(q);
 406         ZERO_STRUCT(r);
 407
 408         /* Initialise parse structures */
 409
 410         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 411         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 412
 413         /* Initialise input parameters */
 414
 415         init_srv_q_net_remote_tod(&q, cli->srv_name_slash);
 416
 417         /* Marshall data and send request */
 418
 419         if (!srv_io_q_net_remote_tod("", &q, &qbuf, 0) ||
 420             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_REMOTE_TOD, &qbuf, &rbuf))
 421                 goto done;
 422
 423         /* Unmarshall response */
 424
 425         r.tod = tod;
 426
 427         if (!srv_io_r_net_remote_tod("", &r, &rbuf, 0))
 428                 goto done;
 429
 430         result = r.status;
 431
 432         if (!W_ERROR_IS_OK(result))
 433                 goto done;
 434
 435  done:
 436         prs_mem_free(&qbuf);
 437         prs_mem_free(&rbuf);
 438
 439         return result;
 440 }
 441
 442 WERROR cli_srvsvc_net_file_enum(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 443                                 uint32 file_level, const char *user_name,
 444                                 SRV_FILE_INFO_CTR *ctr, int preferred_len,
 445                                 ENUM_HND *hnd)
 446 {
 447         prs_struct qbuf, rbuf;
 448         SRV_Q_NET_FILE_ENUM q;
 449         SRV_R_NET_FILE_ENUM r;
 450         WERROR result = W_ERROR(ERRgeneral);
 451         int i;
 452
 453         ZERO_STRUCT(q);
 454         ZERO_STRUCT(r);
 455
 456         /* Initialise parse structures */
 457
 458         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 459         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 460
 461         /* Initialise input parameters */
 462
 463         init_srv_q_net_file_enum(&q, cli->srv_name_slash, NULL, user_name,
 464                                  file_level, ctr, preferred_len, hnd);
 465
 466         /* Marshall data and send request */
 467
 468         if (!srv_io_q_net_file_enum("", &q, &qbuf, 0) ||
 469             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_FILE_ENUM, &qbuf, &rbuf))
 470                 goto done;
 471
 472         /* Unmarshall response */
 473
 474         if (!srv_io_r_net_file_enum("", &r, &rbuf, 0))
 475                 goto done;
 476
 477         result = r.status;
 478
 479         if (!W_ERROR_IS_OK(result))
 480                 goto done;
 481
 482         /* copy the data over to the ctr */
 483
 484         ZERO_STRUCTP(ctr);
 485
 486         ctr->switch_value = file_level;
 487
 488         ctr->num_entries = ctr->num_entries2 = r.ctr.num_entries;
 489
 490         switch(file_level) {
 491         case 3:
 492                 ctr->file.info3 = TALLOC_ARRAY(mem_ctx, SRV_FILE_INFO_3, ctr->num_entries);
 493
 494                 memset(ctr->file.info3, 0,
 495                        sizeof(SRV_FILE_INFO_3) * ctr->num_entries);
 496
 497                 for (i = 0; i < r.ctr.num_entries; i++) {
 498                         SRV_FILE_INFO_3 *info3 = &ctr->file.info3[i];
 499                         char *s;
 500
 501                         /* Copy pointer crap */
 502
 503                         memcpy(&info3->info_3, &r.ctr.file.info3[i].info_3,
 504                                sizeof(FILE_INFO_3));
 505
 506                         /* Duplicate strings */
 507
 508                         s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_path_name);
 509                         if (s)
 510                                 init_unistr2(&info3->info_3_str.uni_path_name, s, UNI_STR_TERMINATE);
 511
 512                         s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_user_name);
 513                         if (s)
 514                                 init_unistr2(&info3->info_3_str.uni_user_name, s, UNI_STR_TERMINATE);
 515
 516                 }
 517
 518                 break;
 519         }
 520
 521  done:
 522         prs_mem_free(&qbuf);
 523         prs_mem_free(&rbuf);
 524
 525         return result;
 526 }
 527
 528 WERROR cli_srvsvc_net_file_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 529                                  uint32 file_id)
 530 {
 531         prs_struct qbuf, rbuf;
 532         SRV_Q_NET_FILE_CLOSE q;
 533         SRV_R_NET_FILE_CLOSE r;
 534         WERROR result = W_ERROR(ERRgeneral);
 535
 536         ZERO_STRUCT(q);
 537         ZERO_STRUCT(r);
 538
 539         /* Initialise parse structures */
 540
 541         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 542         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 543
 544         /* Initialise input parameters */
 545
 546         init_srv_q_net_file_close(&q, cli->srv_name_slash, file_id);
 547
 548         /* Marshall data and send request */
 549
 550         if (!srv_io_q_net_file_close("", &q, &qbuf, 0) ||
 551             !rpc_api_pipe_req(cli, PI_SRVSVC, SRV_NET_FILE_CLOSE, &qbuf, &rbuf))
 552                 goto done;
 553
 554         /* Unmarshall response */
 555
 556         if (!srv_io_r_net_file_close("", &r, &rbuf, 0))
 557                 goto done;
 558
 559         result = r.status;
 560  done:
 561         prs_mem_free(&qbuf);
 562         prs_mem_free(&rbuf);
 563         return result;
 564 }