source4/libcli/raw/rawsetfileinfo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RAW_SFILEINFO_* calls
   4    Copyright (C) James Myers 2003
   5    Copyright (C) Andrew Tridgell 2003
   6    Copyright (C) James Peach 2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "libcli/raw/libcliraw.h"
  24 #include "librpc/gen_ndr/ndr_security.h"
  25
  26
  27 /*
  28   Handle setfileinfo/setpathinfo passthu constructions
  29 */
  30 bool smb_raw_setfileinfo_passthru(TALLOC_CTX *mem_ctx,
  31                                   enum smb_setfileinfo_level level,
  32                                   union smb_setfileinfo *parms,
  33                                   DATA_BLOB *blob)
  34 {
  35         uint_t len;
  36
  37 #define NEED_BLOB(n) do { \
  38           *blob = data_blob_talloc(mem_ctx, NULL, n); \
  39           if (blob->data == NULL) return false; \
  40         } while (0)
  41
  42         switch (level) {
  43         case RAW_SFILEINFO_BASIC_INFORMATION:
  44                 NEED_BLOB(40);
  45                 smbcli_push_nttime(blob->data,  0, parms->basic_info.in.create_time);
  46                 smbcli_push_nttime(blob->data,  8, parms->basic_info.in.access_time);
  47                 smbcli_push_nttime(blob->data, 16, parms->basic_info.in.write_time);
  48                 smbcli_push_nttime(blob->data, 24, parms->basic_info.in.change_time);
  49                 SIVAL(blob->data,           32, parms->basic_info.in.attrib);
  50                 SIVAL(blob->data,           36, 0); /* padding */
  51                 return true;
  52
  53         case RAW_SFILEINFO_DISPOSITION_INFORMATION:
  54                 NEED_BLOB(4);
  55                 SIVAL(blob->data, 0, parms->disposition_info.in.delete_on_close);
  56                 return true;
  57
  58         case RAW_SFILEINFO_ALLOCATION_INFORMATION:
  59                 NEED_BLOB(8);
  60                 SBVAL(blob->data, 0, parms->allocation_info.in.alloc_size);
  61                 return true;
  62
  63         case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
  64                 NEED_BLOB(8);
  65                 SBVAL(blob->data, 0, parms->end_of_file_info.in.size);
  66                 return true;
  67
  68         case RAW_SFILEINFO_RENAME_INFORMATION:
  69                 NEED_BLOB(12);
  70                 SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
  71                 SIVAL(blob->data, 4, parms->rename_information.in.root_fid);
  72                 len = smbcli_blob_append_string(NULL, mem_ctx, blob,
  73                                                 parms->rename_information.in.new_name,
  74                                                 STR_UNICODE|STR_TERMINATE);
  75                 SIVAL(blob->data, 8, len - 2);
  76                 return true;
  77
  78         case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
  79                 NEED_BLOB(20);
  80                 SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
  81                 SBVAL(blob->data, 8, parms->rename_information.in.root_fid);
  82                 len = smbcli_blob_append_string(NULL, mem_ctx, blob,
  83                                                 parms->rename_information.in.new_name,
  84                                                 STR_UNICODE|STR_TERMINATE);
  85                 SIVAL(blob->data, 16, len - 2);
  86                 return true;
  87
  88         case RAW_SFILEINFO_POSITION_INFORMATION:
  89                 NEED_BLOB(8);
  90                 SBVAL(blob->data, 0, parms->position_information.in.position);
  91                 return true;
  92
  93         case RAW_SFILEINFO_MODE_INFORMATION:
  94                 NEED_BLOB(4);
  95                 SIVAL(blob->data, 0, parms->mode_information.in.mode);
  96                 return true;
  97
  98         case RAW_FILEINFO_SEC_DESC: {
  99                 enum ndr_err_code ndr_err;
 100
 101                 ndr_err = ndr_push_struct_blob(blob, mem_ctx, NULL,
 102                                                parms->set_secdesc.in.sd,
 103                                                (ndr_push_flags_fn_t)ndr_push_security_descriptor);
 104                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 105                         return false;
 106                 }
 107
 108                 return true;
 109         }
 110
 111                 /* Unhandled levels */
 112         case RAW_SFILEINFO_1023:
 113         case RAW_SFILEINFO_1025:
 114         case RAW_SFILEINFO_1029:
 115         case RAW_SFILEINFO_1032:
 116         case RAW_SFILEINFO_1039:
 117         case RAW_SFILEINFO_1040:
 118                 break;
 119
 120         default:
 121                 DEBUG(0,("Unhandled setfileinfo passthru level %d\n", level));
 122                 return false;
 123         }
 124
 125         return false;
 126 }
 127
 128 /*
 129   Handle setfileinfo/setpathinfo trans2 backend.
 130 */
 131 static bool smb_raw_setinfo_backend(struct smbcli_tree *tree,
 132                                     TALLOC_CTX *mem_ctx,
 133                                     union smb_setfileinfo *parms,
 134                                     DATA_BLOB *blob)
 135 {
 136         switch (parms->generic.level) {
 137         case RAW_SFILEINFO_GENERIC:
 138         case RAW_SFILEINFO_SETATTR:
 139         case RAW_SFILEINFO_SETATTRE:
 140         case RAW_SFILEINFO_SEC_DESC:
 141                 /* not handled here */
 142                 return false;
 143
 144         case RAW_SFILEINFO_STANDARD:
 145                 NEED_BLOB(12);
 146                 raw_push_dos_date2(tree->session->transport,
 147                                   blob->data, 0, parms->standard.in.create_time);
 148                 raw_push_dos_date2(tree->session->transport,
 149                                   blob->data, 4, parms->standard.in.access_time);
 150                 raw_push_dos_date2(tree->session->transport,
 151                                   blob->data, 8, parms->standard.in.write_time);
 152                 return true;
 153
 154         case RAW_SFILEINFO_EA_SET:
 155                 NEED_BLOB(ea_list_size(parms->ea_set.in.num_eas, parms->ea_set.in.eas));
 156                 ea_put_list(blob->data, parms->ea_set.in.num_eas, parms->ea_set.in.eas);
 157                 return true;
 158
 159         case RAW_SFILEINFO_BASIC_INFO:
 160         case RAW_SFILEINFO_BASIC_INFORMATION:
 161                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_BASIC_INFORMATION,
 162                                                     parms, blob);
 163
 164         case RAW_SFILEINFO_UNIX_BASIC:
 165                 NEED_BLOB(100);
 166                 SBVAL(blob->data, 0, parms->unix_basic.in.end_of_file);
 167                 SBVAL(blob->data, 8, parms->unix_basic.in.num_bytes);
 168                 smbcli_push_nttime(blob->data, 16, parms->unix_basic.in.status_change_time);
 169                 smbcli_push_nttime(blob->data, 24, parms->unix_basic.in.access_time);
 170                 smbcli_push_nttime(blob->data, 32, parms->unix_basic.in.change_time);
 171                 SBVAL(blob->data, 40, parms->unix_basic.in.uid);
 172                 SBVAL(blob->data, 48, parms->unix_basic.in.gid);
 173                 SIVAL(blob->data, 56, parms->unix_basic.in.file_type);
 174                 SBVAL(blob->data, 60, parms->unix_basic.in.dev_major);
 175                 SBVAL(blob->data, 68, parms->unix_basic.in.dev_minor);
 176                 SBVAL(blob->data, 76, parms->unix_basic.in.unique_id);
 177                 SBVAL(blob->data, 84, parms->unix_basic.in.permissions);
 178                 SBVAL(blob->data, 92, parms->unix_basic.in.nlink);
 179                 return true;
 180
 181         case RAW_SFILEINFO_UNIX_INFO2:
 182                 NEED_BLOB(116);
 183                 SBVAL(blob->data,   0, parms->unix_info2.in.end_of_file);
 184                 SBVAL(blob->data,   8, parms->unix_info2.in.num_bytes);
 185                 smbcli_push_nttime(blob->data, 16, parms->unix_info2.in.status_change_time);
 186                 smbcli_push_nttime(blob->data, 24, parms->unix_info2.in.access_time);
 187                 smbcli_push_nttime(blob->data, 32, parms->unix_info2.in.change_time);
 188                 SBVAL(blob->data,  40,parms->unix_info2.in.uid);
 189                 SBVAL(blob->data,  48,parms->unix_info2.in.gid);
 190                 SIVAL(blob->data,  56,parms->unix_info2.in.file_type);
 191                 SBVAL(blob->data,  60,parms->unix_info2.in.dev_major);
 192                 SBVAL(blob->data,  68,parms->unix_info2.in.dev_minor);
 193                 SBVAL(blob->data,  76,parms->unix_info2.in.unique_id);
 194                 SBVAL(blob->data,  84,parms->unix_info2.in.permissions);
 195                 SBVAL(blob->data,  92,parms->unix_info2.in.nlink);
 196                 smbcli_push_nttime(blob->data, 100, parms->unix_info2.in.create_time);
 197                 SIVAL(blob->data, 108, parms->unix_info2.in.file_flags);
 198                 SIVAL(blob->data, 112, parms->unix_info2.in.flags_mask);
 199                 return true;
 200
 201         case RAW_SFILEINFO_DISPOSITION_INFO:
 202         case RAW_SFILEINFO_DISPOSITION_INFORMATION:
 203                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_DISPOSITION_INFORMATION,
 204                                                     parms, blob);
 205
 206         case RAW_SFILEINFO_ALLOCATION_INFO:
 207         case RAW_SFILEINFO_ALLOCATION_INFORMATION:
 208                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_ALLOCATION_INFORMATION,
 209                                                     parms, blob);
 210
 211         case RAW_SFILEINFO_END_OF_FILE_INFO:
 212         case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
 213                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_END_OF_FILE_INFORMATION,
 214                                                     parms, blob);
 215
 216         case RAW_SFILEINFO_RENAME_INFORMATION:
 217                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_RENAME_INFORMATION,
 218                                                     parms, blob);
 219
 220         case RAW_SFILEINFO_POSITION_INFORMATION:
 221                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_POSITION_INFORMATION,
 222                                                     parms, blob);
 223
 224         case RAW_SFILEINFO_MODE_INFORMATION:
 225                 return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_MODE_INFORMATION,
 226                                                     parms, blob);
 227
 228                 /* Unhandled passthru levels */
 229         case RAW_SFILEINFO_1023:
 230         case RAW_SFILEINFO_1025:
 231         case RAW_SFILEINFO_1029:
 232         case RAW_SFILEINFO_1032:
 233         case RAW_SFILEINFO_1039:
 234         case RAW_SFILEINFO_1040:
 235                 return smb_raw_setfileinfo_passthru(mem_ctx, parms->generic.level,
 236                                                     parms, blob);
 237
 238                 /* Unhandled levels */
 239
 240         case RAW_SFILEINFO_UNIX_LINK:
 241         case RAW_SFILEINFO_UNIX_HLINK:
 242         case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
 243                 break;
 244         }
 245
 246         return false;
 247 }
 248
 249 /****************************************************************************
 250  Very raw set file info - takes data blob (async send)
 251 ****************************************************************************/
 252 static struct smbcli_request *smb_raw_setfileinfo_blob_send(struct smbcli_tree *tree,
 253                                                          TALLOC_CTX *mem_ctx,
 254                                                          uint16_t fnum,
 255                                                          uint16_t info_level,
 256                                                          DATA_BLOB *blob)
 257 {
 258         struct smb_trans2 tp;
 259         uint16_t setup = TRANSACT2_SETFILEINFO;
 260
 261         tp.in.max_setup = 0;
 262         tp.in.flags = 0;
 263         tp.in.timeout = 0;
 264         tp.in.setup_count = 1;
 265         tp.in.max_param = 2;
 266         tp.in.max_data = 0;
 267         tp.in.setup = &setup;
 268
 269         tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
 270         if (!tp.in.params.data) {
 271                 return NULL;
 272         }
 273         SSVAL(tp.in.params.data, 0, fnum);
 274         SSVAL(tp.in.params.data, 2, info_level);
 275         SSVAL(tp.in.params.data, 4, 0); /* reserved */
 276
 277         tp.in.data = *blob;
 278
 279         return smb_raw_trans2_send(tree, &tp);
 280 }
 281
 282 /****************************************************************************
 283  Very raw set path info - takes data blob
 284 ****************************************************************************/
 285 static struct smbcli_request *smb_raw_setpathinfo_blob_send(struct smbcli_tree *tree,
 286                                                             TALLOC_CTX *mem_ctx,
 287                                                             const char *fname,
 288                                                             uint16_t info_level,
 289                                                             DATA_BLOB *blob)
 290 {
 291         struct smb_trans2 tp;
 292         uint16_t setup = TRANSACT2_SETPATHINFO;
 293
 294         tp.in.max_setup = 0;
 295         tp.in.flags = 0;
 296         tp.in.timeout = 0;
 297         tp.in.setup_count = 1;
 298         tp.in.max_param = 2;
 299         tp.in.max_data = 0;
 300         tp.in.setup = &setup;
 301
 302         tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
 303         if (!tp.in.params.data) {
 304                 return NULL;
 305         }
 306         SSVAL(tp.in.params.data, 0, info_level);
 307         SIVAL(tp.in.params.data, 2, 0);
 308         smbcli_blob_append_string(tree->session, mem_ctx,
 309                                   &tp.in.params,
 310                                   fname, STR_TERMINATE);
 311
 312         tp.in.data = *blob;
 313
 314         return smb_raw_trans2_send(tree, &tp);
 315 }
 316
 317 /****************************************************************************
 318  Handle setattr (async send)
 319 ****************************************************************************/
 320 static struct smbcli_request *smb_raw_setattr_send(struct smbcli_tree *tree,
 321                                                 union smb_setfileinfo *parms)
 322 {
 323         struct smbcli_request *req;
 324
 325         req = smbcli_request_setup(tree, SMBsetatr, 8, 0);
 326         if (!req) return NULL;
 327
 328         SSVAL(req->out.vwv,         VWV(0), parms->setattr.in.attrib);
 329         raw_push_dos_date3(tree->session->transport,
 330                           req->out.vwv, VWV(1), parms->setattr.in.write_time);
 331         memset(req->out.vwv + VWV(3), 0, 10); /* reserved */
 332         smbcli_req_append_ascii4(req, parms->setattr.in.file.path, STR_TERMINATE);
 333         smbcli_req_append_ascii4(req, "", STR_TERMINATE);
 334
 335         if (!smbcli_request_send(req)) {
 336                 smbcli_request_destroy(req);
 337                 return NULL;
 338         }
 339
 340         return req;
 341 }
 342
 343 /****************************************************************************
 344  Handle setattrE. (async send)
 345 ****************************************************************************/
 346 static struct smbcli_request *smb_raw_setattrE_send(struct smbcli_tree *tree,
 347                                                  union smb_setfileinfo *parms)
 348 {
 349         struct smbcli_request *req;
 350
 351         req = smbcli_request_setup(tree, SMBsetattrE, 7, 0);
 352         if (!req) return NULL;
 353
 354         SSVAL(req->out.vwv,         VWV(0), parms->setattre.in.file.fnum);
 355         raw_push_dos_date2(tree->session->transport,
 356                           req->out.vwv, VWV(1), parms->setattre.in.create_time);
 357         raw_push_dos_date2(tree->session->transport,
 358                           req->out.vwv, VWV(3), parms->setattre.in.access_time);
 359         raw_push_dos_date2(tree->session->transport,
 360                           req->out.vwv, VWV(5), parms->setattre.in.write_time);
 361
 362         if (!smbcli_request_send(req)) {
 363                 smbcli_request_destroy(req);
 364                 return NULL;
 365         }
 366
 367         return req;
 368 }
 369
 370 /****************************************************************************
 371  Set file info (async send)
 372 ****************************************************************************/
 373 struct smbcli_request *smb_raw_setfileinfo_send(struct smbcli_tree *tree,
 374                                              union smb_setfileinfo *parms)
 375 {
 376         DATA_BLOB blob;
 377         TALLOC_CTX *mem_ctx;
 378         struct smbcli_request *req;
 379
 380         if (parms->generic.level == RAW_SFILEINFO_SETATTRE) {
 381                 return smb_raw_setattrE_send(tree, parms);
 382         }
 383         if (parms->generic.level == RAW_SFILEINFO_SEC_DESC) {
 384                 return smb_raw_set_secdesc_send(tree, parms);
 385         }
 386         if (parms->generic.level >= RAW_SFILEINFO_GENERIC) {
 387                 return NULL;
 388         }
 389
 390         mem_ctx = talloc_init("setpathinfo");
 391         if (!mem_ctx) return NULL;
 392
 393         if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
 394                 talloc_free(mem_ctx);
 395                 return NULL;
 396         }
 397
 398         /* send request and process the output */
 399         req = smb_raw_setfileinfo_blob_send(tree,
 400                                             mem_ctx,
 401                                             parms->generic.in.file.fnum,
 402                                             parms->generic.level,
 403                                             &blob);
 404
 405         talloc_free(mem_ctx);
 406         return req;
 407 }
 408
 409 /****************************************************************************
 410  Set file info (async send)
 411 ****************************************************************************/
 412 NTSTATUS smb_raw_setfileinfo(struct smbcli_tree *tree,
 413                              union smb_setfileinfo *parms)
 414 {
 415         struct smbcli_request *req = smb_raw_setfileinfo_send(tree, parms);
 416         return smbcli_request_simple_recv(req);
 417 }
 418
 419
 420 /****************************************************************************
 421  Set path info (async send)
 422 ****************************************************************************/
 423 struct smbcli_request *smb_raw_setpathinfo_send(struct smbcli_tree *tree,
 424                                              union smb_setfileinfo *parms)
 425 {
 426         DATA_BLOB blob;
 427         TALLOC_CTX *mem_ctx;
 428         struct smbcli_request *req;
 429
 430         if (parms->generic.level == RAW_SFILEINFO_SETATTR) {
 431                 return smb_raw_setattr_send(tree, parms);
 432         }
 433         if (parms->generic.level >= RAW_SFILEINFO_GENERIC) {
 434                 return NULL;
 435         }
 436
 437         mem_ctx = talloc_init("setpathinfo");
 438         if (!mem_ctx) return NULL;
 439
 440         if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
 441                 talloc_free(mem_ctx);
 442                 return NULL;
 443         }
 444
 445         /* send request and process the output */
 446         req = smb_raw_setpathinfo_blob_send(tree,
 447                                             mem_ctx,
 448                                             parms->generic.in.file.path,
 449                                             parms->generic.level,
 450                                             &blob);
 451
 452         talloc_free(mem_ctx);
 453         return req;
 454 }
 455
 456 /****************************************************************************
 457  Set path info (sync interface)
 458 ****************************************************************************/
 459 NTSTATUS smb_raw_setpathinfo(struct smbcli_tree *tree,
 460                              union smb_setfileinfo *parms)
 461 {
 462         struct smbcli_request *req = smb_raw_setpathinfo_send(tree, parms);
 463         return smbcli_request_simple_recv(req);
 464 }