source/rpc_client/cli_dfs.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4    Copyright (C) Tim Potter                        2000-2001,
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /* Query DFS support */
  24
  25 NTSTATUS cli_dfs_exist(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  26                        BOOL *dfs_exists)
  27 {
  28         prs_struct qbuf, rbuf;
  29         DFS_Q_DFS_EXIST q;
  30         DFS_R_DFS_EXIST r;
  31         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  32
  33         ZERO_STRUCT(q);
  34         ZERO_STRUCT(r);
  35
  36         /* Initialise parse structures */
  37
  38         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  39         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  40
  41         /* Marshall data and send request */
  42
  43         init_dfs_q_dfs_exist(&q);
  44
  45         if (!dfs_io_q_dfs_exist("", &q, &qbuf, 0) ||
  46             !rpc_api_pipe_req(cli, DFS_EXIST, &qbuf, &rbuf)) {
  47                 goto done;
  48         }
  49
  50         /* Unmarshall response */
  51
  52         if (!dfs_io_r_dfs_exist("", &r, &rbuf, 0)) {
  53                 goto done;
  54         }
  55
  56         /* Return result */
  57
  58         *dfs_exists = (r.status != 0);
  59
  60         result = NT_STATUS_OK;
  61
  62  done:
  63         prs_mem_free(&qbuf);
  64         prs_mem_free(&rbuf);
  65
  66         return result;
  67 }
  68
  69 NTSTATUS cli_dfs_add(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  70                      char *entrypath, char *servername, char *sharename,
  71                      char *comment, uint32 flags)
  72 {
  73         prs_struct qbuf, rbuf;
  74         DFS_Q_DFS_ADD q;
  75         DFS_R_DFS_ADD r;
  76         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  77
  78         ZERO_STRUCT(q);
  79         ZERO_STRUCT(r);
  80
  81         /* Initialise parse structures */
  82
  83         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  84         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  85
  86         /* Marshall data and send request */
  87
  88         init_dfs_q_dfs_add(&q, entrypath, servername, sharename, comment,
  89                            flags);
  90
  91         if (!dfs_io_q_dfs_add("", &q, &qbuf, 0) ||
  92             !rpc_api_pipe_req(cli, DFS_ADD, &qbuf, &rbuf)) {
  93                 goto done;
  94         }
  95
  96         /* Unmarshall response */
  97
  98         if (!dfs_io_r_dfs_add("", &r, &rbuf, 0)) {
  99                 goto done;
 100         }
 101
 102         /* Return result */
 103
 104         result = werror_to_ntstatus(r.status);
 105
 106  done:
 107         prs_mem_free(&qbuf);
 108         prs_mem_free(&rbuf);
 109
 110         return result;
 111 }
 112
 113 NTSTATUS cli_dfs_remove(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 114                         char *entrypath, char *servername, char *sharename)
 115 {
 116         prs_struct qbuf, rbuf;
 117         DFS_Q_DFS_REMOVE q;
 118         DFS_R_DFS_REMOVE r;
 119         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 120
 121         ZERO_STRUCT(q);
 122         ZERO_STRUCT(r);
 123
 124         /* Initialise parse structures */
 125
 126         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 127         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 128
 129         /* Marshall data and send request */
 130
 131         init_dfs_q_dfs_remove(&q, entrypath, servername, sharename);
 132
 133         if (!dfs_io_q_dfs_remove("", &q, &qbuf, 0) ||
 134             !rpc_api_pipe_req(cli, DFS_REMOVE, &qbuf, &rbuf)) {
 135                 goto done;
 136         }
 137
 138         /* Unmarshall response */
 139
 140         if (!dfs_io_r_dfs_remove("", &r, &rbuf, 0)) {
 141                 goto done;
 142         }
 143
 144         /* Return result */
 145
 146         result = werror_to_ntstatus(r.status);
 147
 148  done:
 149         prs_mem_free(&qbuf);
 150         prs_mem_free(&rbuf);
 151
 152         return result;
 153 }
 154
 155 NTSTATUS cli_dfs_get_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 156                           char *entrypath, char *servername, char *sharename,
 157                           uint32 info_level, DFS_INFO_CTR *ctr)
 158
 159 {
 160         prs_struct qbuf, rbuf;
 161         DFS_Q_DFS_GET_INFO q;
 162         DFS_R_DFS_GET_INFO r;
 163         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 164
 165         ZERO_STRUCT(q);
 166         ZERO_STRUCT(r);
 167
 168         /* Initialise parse structures */
 169
 170         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 171         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 172
 173         /* Marshall data and send request */
 174
 175         init_dfs_q_dfs_get_info(&q, entrypath, servername, sharename,
 176                                 info_level);
 177
 178         if (!dfs_io_q_dfs_get_info("", &q, &qbuf, 0) ||
 179             !rpc_api_pipe_req(cli, DFS_GET_INFO, &qbuf, &rbuf)) {
 180                 goto done;
 181         }
 182
 183         /* Unmarshall response */
 184
 185         if (!dfs_io_r_dfs_get_info("", &r, &rbuf, 0)) {
 186                 goto done;
 187         }
 188
 189         /* Return result */
 190
 191         result = werror_to_ntstatus(r.status);
 192         *ctr = r.ctr;
 193
 194  done:
 195         prs_mem_free(&qbuf);
 196         prs_mem_free(&rbuf);
 197
 198         return result;
 199 }
 200
 201 /* Enumerate dfs shares */
 202
 203 NTSTATUS cli_dfs_enum(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 204                       uint32 info_level, DFS_INFO_CTR *ctr)
 205 {
 206         prs_struct qbuf, rbuf;
 207         DFS_Q_DFS_ENUM q;
 208         DFS_R_DFS_ENUM r;
 209         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 210
 211         ZERO_STRUCT(q);
 212         ZERO_STRUCT(r);
 213
 214         /* Initialise parse structures */
 215
 216         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 217         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 218
 219         /* Marshall data and send request */
 220
 221         init_dfs_q_dfs_enum(&q, info_level, ctr);
 222
 223         if (!dfs_io_q_dfs_enum("", &q, &qbuf, 0) ||
 224             !rpc_api_pipe_req(cli, DFS_ENUM, &qbuf, &rbuf)) {
 225                 goto done;
 226         }
 227
 228         /* Unmarshall response */
 229
 230         r.ctr = ctr;
 231
 232         if (!dfs_io_r_dfs_enum("", &r, &rbuf, 0)) {
 233                 goto done;
 234         }
 235
 236         /* Return result */
 237
 238         result = werror_to_ntstatus(r.status);
 239
 240  done:
 241         prs_mem_free(&qbuf);
 242         prs_mem_free(&rbuf);
 243
 244         return result;
 245 }