source3/lib/netapi/file.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  NetApi File Support
   4  *  Copyright (C) Guenther Deschner 2008
   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 3 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21
  22 #include "librpc/gen_ndr/libnetapi.h"
  23 #include "lib/netapi/netapi.h"
  24 #include "lib/netapi/netapi_private.h"
  25 #include "lib/netapi/libnetapi.h"
  26 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
  27
  28 /****************************************************************
  29 ****************************************************************/
  30
  31 WERROR NetFileClose_r(struct libnetapi_ctx *ctx,
  32                       struct NetFileClose *r)
  33 {
  34         WERROR werr;
  35         NTSTATUS status;
  36         struct dcerpc_binding_handle *b;
  37
  38         werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
  39                                             &ndr_table_srvsvc,
  40                                             &b);
  41         if (!W_ERROR_IS_OK(werr)) {
  42                 goto done;
  43         }
  44
  45         status = dcerpc_srvsvc_NetFileClose(b, talloc_tos(),
  46                                             r->in.server_name,
  47                                             r->in.fileid,
  48                                             &werr);
  49         if (!NT_STATUS_IS_OK(status)) {
  50                 werr = ntstatus_to_werror(status);
  51                 goto done;
  52         }
  53
  54  done:
  55         return werr;
  56 }
  57
  58 /****************************************************************
  59 ****************************************************************/
  60
  61 WERROR NetFileClose_l(struct libnetapi_ctx *ctx,
  62                       struct NetFileClose *r)
  63 {
  64         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetFileClose);
  65 }
  66
  67 /****************************************************************
  68 ****************************************************************/
  69
  70 static NTSTATUS map_srvsvc_FileInfo_to_FILE_INFO_buffer(TALLOC_CTX *mem_ctx,
  71                                                         uint32_t level,
  72                                                         union srvsvc_NetFileInfo *info,
  73                                                         uint8_t **buffer,
  74                                                         uint32_t *num_entries)
  75 {
  76         struct FILE_INFO_2 i2;
  77         struct FILE_INFO_3 i3;
  78
  79         switch (level) {
  80                 case 2:
  81                         i2.fi2_id               = info->info2->fid;
  82
  83                         ADD_TO_ARRAY(mem_ctx, struct FILE_INFO_2, i2,
  84                                      (struct FILE_INFO_2 **)buffer,
  85                                      num_entries);
  86                         break;
  87                 case 3:
  88                         i3.fi3_id               = info->info3->fid;
  89                         i3.fi3_permissions      = info->info3->permissions;
  90                         i3.fi3_num_locks        = info->info3->num_locks;
  91                         i3.fi3_pathname         = talloc_strdup(mem_ctx, info->info3->path);
  92                         i3.fi3_username         = talloc_strdup(mem_ctx, info->info3->user);
  93
  94                         NT_STATUS_HAVE_NO_MEMORY(i3.fi3_pathname);
  95                         NT_STATUS_HAVE_NO_MEMORY(i3.fi3_username);
  96
  97                         ADD_TO_ARRAY(mem_ctx, struct FILE_INFO_3, i3,
  98                                      (struct FILE_INFO_3 **)buffer,
  99                                      num_entries);
 100                         break;
 101                 default:
 102                         return NT_STATUS_INVALID_INFO_CLASS;
 103         }
 104
 105         return NT_STATUS_OK;
 106 }
 107
 108 /****************************************************************
 109 ****************************************************************/
 110
 111 WERROR NetFileGetInfo_r(struct libnetapi_ctx *ctx,
 112                         struct NetFileGetInfo *r)
 113 {
 114         WERROR werr;
 115         NTSTATUS status;
 116         union srvsvc_NetFileInfo info;
 117         uint32_t num_entries = 0;
 118         struct dcerpc_binding_handle *b;
 119
 120         if (!r->out.buffer) {
 121                 return WERR_INVALID_PARAM;
 122         }
 123
 124         switch (r->in.level) {
 125                 case 2:
 126                 case 3:
 127                         break;
 128                 default:
 129                         return WERR_UNKNOWN_LEVEL;
 130         }
 131
 132         werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
 133                                             &ndr_table_srvsvc,
 134                                             &b);
 135         if (!W_ERROR_IS_OK(werr)) {
 136                 goto done;
 137         }
 138
 139         status = dcerpc_srvsvc_NetFileGetInfo(b, talloc_tos(),
 140                                               r->in.server_name,
 141                                               r->in.fileid,
 142                                               r->in.level,
 143                                               &info,
 144                                               &werr);
 145         if (!NT_STATUS_IS_OK(status)) {
 146                 werr = ntstatus_to_werror(status);
 147                 goto done;
 148         }
 149
 150         if (!W_ERROR_IS_OK(werr)) {
 151                 goto done;
 152         }
 153
 154         status = map_srvsvc_FileInfo_to_FILE_INFO_buffer(ctx,
 155                                                          r->in.level,
 156                                                          &info,
 157                                                          r->out.buffer,
 158                                                          &num_entries);
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 werr = ntstatus_to_werror(status);
 161                 goto done;
 162         }
 163  done:
 164         return werr;
 165 }
 166
 167 /****************************************************************
 168 ****************************************************************/
 169
 170 WERROR NetFileGetInfo_l(struct libnetapi_ctx *ctx,
 171                         struct NetFileGetInfo *r)
 172 {
 173         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetFileGetInfo);
 174 }
 175
 176 /****************************************************************
 177 ****************************************************************/
 178
 179 WERROR NetFileEnum_r(struct libnetapi_ctx *ctx,
 180                      struct NetFileEnum *r)
 181 {
 182         WERROR werr;
 183         NTSTATUS status;
 184         struct srvsvc_NetFileInfoCtr info_ctr;
 185         struct srvsvc_NetFileCtr2 ctr2;
 186         struct srvsvc_NetFileCtr3 ctr3;
 187         uint32_t num_entries = 0;
 188         uint32_t i;
 189         struct dcerpc_binding_handle *b;
 190
 191         if (!r->out.buffer) {
 192                 return WERR_INVALID_PARAM;
 193         }
 194
 195         switch (r->in.level) {
 196                 case 2:
 197                 case 3:
 198                         break;
 199                 default:
 200                         return WERR_UNKNOWN_LEVEL;
 201         }
 202
 203         werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
 204                                             &ndr_table_srvsvc,
 205                                             &b);
 206         if (!W_ERROR_IS_OK(werr)) {
 207                 goto done;
 208         }
 209
 210         ZERO_STRUCT(info_ctr);
 211
 212         info_ctr.level = r->in.level;
 213         switch (r->in.level) {
 214                 case 2:
 215                         ZERO_STRUCT(ctr2);
 216                         info_ctr.ctr.ctr2 = &ctr2;
 217                         break;
 218                 case 3:
 219                         ZERO_STRUCT(ctr3);
 220                         info_ctr.ctr.ctr3 = &ctr3;
 221                         break;
 222         }
 223
 224         status = dcerpc_srvsvc_NetFileEnum(b, talloc_tos(),
 225                                            r->in.server_name,
 226                                            r->in.base_path,
 227                                            r->in.user_name,
 228                                            &info_ctr,
 229                                            r->in.prefmaxlen,
 230                                            r->out.total_entries,
 231                                            r->out.resume_handle,
 232                                            &werr);
 233         if (!NT_STATUS_IS_OK(status)) {
 234                 werr = ntstatus_to_werror(status);
 235                 goto done;
 236         }
 237
 238         if (!W_ERROR_IS_OK(werr) && !W_ERROR_EQUAL(werr, WERR_MORE_DATA)) {
 239                 goto done;
 240         }
 241
 242         for (i=0; i < info_ctr.ctr.ctr2->count; i++) {
 243                 union srvsvc_NetFileInfo _i;
 244                 switch (r->in.level) {
 245                         case 2:
 246                                 _i.info2 = &info_ctr.ctr.ctr2->array[i];
 247                                 break;
 248                         case 3:
 249                                 _i.info3 = &info_ctr.ctr.ctr3->array[i];
 250                                 break;
 251                 }
 252
 253                 status = map_srvsvc_FileInfo_to_FILE_INFO_buffer(ctx,
 254                                                                  r->in.level,
 255                                                                  &_i,
 256                                                                  r->out.buffer,
 257                                                                  &num_entries);
 258                 if (!NT_STATUS_IS_OK(status)) {
 259                         werr = ntstatus_to_werror(status);
 260                         goto done;
 261                 }
 262         }
 263
 264         if (r->out.entries_read) {
 265                 *r->out.entries_read = num_entries;
 266         }
 267
 268         if (r->out.total_entries) {
 269                 *r->out.total_entries = num_entries;
 270         }
 271
 272  done:
 273         return werr;
 274 }
 275
 276 /****************************************************************
 277 ****************************************************************/
 278
 279 WERROR NetFileEnum_l(struct libnetapi_ctx *ctx,
 280                      struct NetFileEnum *r)
 281 {
 282         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetFileEnum);
 283 }