fs/cifs/smb2inode.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002, 2011
   5  *                 Etersoft, 2012
   6  *   Author(s): Pavel Shilovsky (pshilovsky@samba.org),
   7  *              Steve French (sfrench@us.ibm.com)
   8  *
   9  */
  10 #include <linux/fs.h>
  11 #include <linux/stat.h>
  12 #include <linux/slab.h>
  13 #include <linux/pagemap.h>
  14 #include <asm/div64.h>
  15 #include "cifsfs.h"
  16 #include "cifspdu.h"
  17 #include "cifsglob.h"
  18 #include "cifsproto.h"
  19 #include "cifs_debug.h"
  20 #include "cifs_fs_sb.h"
  21 #include "cifs_unicode.h"
  22 #include "fscache.h"
  23 #include "smb2glob.h"
  24 #include "smb2pdu.h"
  25 #include "smb2proto.h"
  26 #include "cached_dir.h"
  27 #include "smb2status.h"
  28
  29 static void
  30 free_set_inf_compound(struct smb_rqst *rqst)
  31 {
  32         if (rqst[1].rq_iov)
  33                 SMB2_set_info_free(&rqst[1]);
  34         if (rqst[2].rq_iov)
  35                 SMB2_close_free(&rqst[2]);
  36 }
  37
  38
  39 struct cop_vars {
  40         struct cifs_open_parms oparms;
  41         struct kvec rsp_iov[3];
  42         struct smb_rqst rqst[3];
  43         struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
  44         struct kvec qi_iov[1];
  45         struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE];
  46         struct kvec close_iov[1];
  47         struct smb2_file_rename_info rename_info;
  48         struct smb2_file_link_info link_info;
  49 };
  50
  51 /*
  52  * note: If cfile is passed, the reference to it is dropped here.
  53  * So make sure that you do not reuse cfile after return from this func.
  54  *
  55  * If passing @err_iov and @err_buftype, ensure to make them both large enough (>= 3) to hold all
  56  * error responses.  Caller is also responsible for freeing them up.
  57  */
  58 static int smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
  59                             struct cifs_sb_info *cifs_sb, const char *full_path,
  60                             __u32 desired_access, __u32 create_disposition, __u32 create_options,
  61                             umode_t mode, void *ptr, int command, struct cifsFileInfo *cfile,
  62                             __u8 **extbuf, size_t *extbuflen,
  63                             struct kvec *err_iov, int *err_buftype)
  64 {
  65         struct cop_vars *vars = NULL;
  66         struct kvec *rsp_iov;
  67         struct smb_rqst *rqst;
  68         int rc;
  69         __le16 *utf16_path = NULL;
  70         __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
  71         struct cifs_fid fid;
  72         struct cifs_ses *ses = tcon->ses;
  73         struct TCP_Server_Info *server;
  74         int num_rqst = 0;
  75         int resp_buftype[3];
  76         struct smb2_query_info_rsp *qi_rsp = NULL;
  77         struct cifs_open_info_data *idata;
  78         int flags = 0;
  79         __u8 delete_pending[8] = {1, 0, 0, 0, 0, 0, 0, 0};
  80         unsigned int size[2];
  81         void *data[2];
  82         int len;
  83
  84         vars = kzalloc(sizeof(*vars), GFP_ATOMIC);
  85         if (vars == NULL)
  86                 return -ENOMEM;
  87         rqst = &vars->rqst[0];
  88         rsp_iov = &vars->rsp_iov[0];
  89
  90         server = cifs_pick_channel(ses);
  91
  92         if (smb3_encryption_required(tcon))
  93                 flags |= CIFS_TRANSFORM_REQ;
  94
  95         resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
  96
  97         /* We already have a handle so we can skip the open */
  98         if (cfile)
  99                 goto after_open;
 100
 101         /* Open */
 102         utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
 103         if (!utf16_path) {
 104                 rc = -ENOMEM;
 105                 goto finished;
 106         }
 107
 108         vars->oparms = (struct cifs_open_parms) {
 109                 .tcon = tcon,
 110                 .desired_access = desired_access,
 111                 .disposition = create_disposition,
 112                 .create_options = cifs_create_options(cifs_sb, create_options),
 113                 .fid = &fid,
 114                 .mode = mode,
 115                 .cifs_sb = cifs_sb,
 116         };
 117
 118         rqst[num_rqst].rq_iov = &vars->open_iov[0];
 119         rqst[num_rqst].rq_nvec = SMB2_CREATE_IOV_SIZE;
 120         rc = SMB2_open_init(tcon, server,
 121                             &rqst[num_rqst], &oplock, &vars->oparms,
 122                             utf16_path);
 123         kfree(utf16_path);
 124         if (rc)
 125                 goto finished;
 126
 127         smb2_set_next_command(tcon, &rqst[num_rqst]);
 128  after_open:
 129         num_rqst++;
 130         rc = 0;
 131
 132         /* Operation */
 133         switch (command) {
 134         case SMB2_OP_QUERY_INFO:
 135                 rqst[num_rqst].rq_iov = &vars->qi_iov[0];
 136                 rqst[num_rqst].rq_nvec = 1;
 137
 138                 if (cfile)
 139                         rc = SMB2_query_info_init(tcon, server,
 140                                 &rqst[num_rqst],
 141                                 cfile->fid.persistent_fid,
 142                                 cfile->fid.volatile_fid,
 143                                 FILE_ALL_INFORMATION,
 144                                 SMB2_O_INFO_FILE, 0,
 145                                 sizeof(struct smb2_file_all_info) +
 146                                           PATH_MAX * 2, 0, NULL);
 147                 else {
 148                         rc = SMB2_query_info_init(tcon, server,
 149                                 &rqst[num_rqst],
 150                                 COMPOUND_FID,
 151                                 COMPOUND_FID,
 152                                 FILE_ALL_INFORMATION,
 153                                 SMB2_O_INFO_FILE, 0,
 154                                 sizeof(struct smb2_file_all_info) +
 155                                           PATH_MAX * 2, 0, NULL);
 156                         if (!rc) {
 157                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 158                                 smb2_set_related(&rqst[num_rqst]);
 159                         }
 160                 }
 161
 162                 if (rc)
 163                         goto finished;
 164                 num_rqst++;
 165                 trace_smb3_query_info_compound_enter(xid, ses->Suid, tcon->tid,
 166                                                      full_path);
 167                 break;
 168         case SMB2_OP_POSIX_QUERY_INFO:
 169                 rqst[num_rqst].rq_iov = &vars->qi_iov[0];
 170                 rqst[num_rqst].rq_nvec = 1;
 171
 172                 if (cfile)
 173                         rc = SMB2_query_info_init(tcon, server,
 174                                 &rqst[num_rqst],
 175                                 cfile->fid.persistent_fid,
 176                                 cfile->fid.volatile_fid,
 177                                 SMB_FIND_FILE_POSIX_INFO,
 178                                 SMB2_O_INFO_FILE, 0,
 179                                 /* TBD: fix following to allow for longer SIDs */
 180                                 sizeof(struct smb311_posix_qinfo *) + (PATH_MAX * 2) +
 181                                 (sizeof(struct cifs_sid) * 2), 0, NULL);
 182                 else {
 183                         rc = SMB2_query_info_init(tcon, server,
 184                                 &rqst[num_rqst],
 185                                 COMPOUND_FID,
 186                                 COMPOUND_FID,
 187                                 SMB_FIND_FILE_POSIX_INFO,
 188                                 SMB2_O_INFO_FILE, 0,
 189                                 sizeof(struct smb311_posix_qinfo *) + (PATH_MAX * 2) +
 190                                 (sizeof(struct cifs_sid) * 2), 0, NULL);
 191                         if (!rc) {
 192                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 193                                 smb2_set_related(&rqst[num_rqst]);
 194                         }
 195                 }
 196
 197                 if (rc)
 198                         goto finished;
 199                 num_rqst++;
 200                 trace_smb3_posix_query_info_compound_enter(xid, ses->Suid, tcon->tid, full_path);
 201                 break;
 202         case SMB2_OP_DELETE:
 203                 trace_smb3_delete_enter(xid, ses->Suid, tcon->tid, full_path);
 204                 break;
 205         case SMB2_OP_MKDIR:
 206                 /*
 207                  * Directories are created through parameters in the
 208                  * SMB2_open() call.
 209                  */
 210                 trace_smb3_mkdir_enter(xid, ses->Suid, tcon->tid, full_path);
 211                 break;
 212         case SMB2_OP_RMDIR:
 213                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 214                 rqst[num_rqst].rq_nvec = 1;
 215
 216                 size[0] = 1; /* sizeof __u8 See MS-FSCC section 2.4.11 */
 217                 data[0] = &delete_pending[0];
 218
 219                 rc = SMB2_set_info_init(tcon, server,
 220                                         &rqst[num_rqst], COMPOUND_FID,
 221                                         COMPOUND_FID, current->tgid,
 222                                         FILE_DISPOSITION_INFORMATION,
 223                                         SMB2_O_INFO_FILE, 0, data, size);
 224                 if (rc)
 225                         goto finished;
 226                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 227                 smb2_set_related(&rqst[num_rqst++]);
 228                 trace_smb3_rmdir_enter(xid, ses->Suid, tcon->tid, full_path);
 229                 break;
 230         case SMB2_OP_SET_EOF:
 231                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 232                 rqst[num_rqst].rq_nvec = 1;
 233
 234                 size[0] = 8; /* sizeof __le64 */
 235                 data[0] = ptr;
 236
 237                 if (cfile) {
 238                         rc = SMB2_set_info_init(tcon, server,
 239                                                 &rqst[num_rqst],
 240                                                 cfile->fid.persistent_fid,
 241                                                 cfile->fid.volatile_fid,
 242                                                 current->tgid,
 243                                                 FILE_END_OF_FILE_INFORMATION,
 244                                                 SMB2_O_INFO_FILE, 0,
 245                                                 data, size);
 246                 } else {
 247                         rc = SMB2_set_info_init(tcon, server,
 248                                                 &rqst[num_rqst],
 249                                                 COMPOUND_FID,
 250                                                 COMPOUND_FID,
 251                                                 current->tgid,
 252                                                 FILE_END_OF_FILE_INFORMATION,
 253                                                 SMB2_O_INFO_FILE, 0,
 254                                                 data, size);
 255                         if (!rc) {
 256                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 257                                 smb2_set_related(&rqst[num_rqst]);
 258                         }
 259                 }
 260                 if (rc)
 261                         goto finished;
 262                 num_rqst++;
 263                 trace_smb3_set_eof_enter(xid, ses->Suid, tcon->tid, full_path);
 264                 break;
 265         case SMB2_OP_SET_INFO:
 266                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 267                 rqst[num_rqst].rq_nvec = 1;
 268
 269
 270                 size[0] = sizeof(FILE_BASIC_INFO);
 271                 data[0] = ptr;
 272
 273                 if (cfile)
 274                         rc = SMB2_set_info_init(tcon, server,
 275                                 &rqst[num_rqst],
 276                                 cfile->fid.persistent_fid,
 277                                 cfile->fid.volatile_fid, current->tgid,
 278                                 FILE_BASIC_INFORMATION,
 279                                 SMB2_O_INFO_FILE, 0, data, size);
 280                 else {
 281                         rc = SMB2_set_info_init(tcon, server,
 282                                 &rqst[num_rqst],
 283                                 COMPOUND_FID,
 284                                 COMPOUND_FID, current->tgid,
 285                                 FILE_BASIC_INFORMATION,
 286                                 SMB2_O_INFO_FILE, 0, data, size);
 287                         if (!rc) {
 288                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 289                                 smb2_set_related(&rqst[num_rqst]);
 290                         }
 291                 }
 292
 293                 if (rc)
 294                         goto finished;
 295                 num_rqst++;
 296                 trace_smb3_set_info_compound_enter(xid, ses->Suid, tcon->tid,
 297                                                    full_path);
 298                 break;
 299         case SMB2_OP_RENAME:
 300                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 301                 rqst[num_rqst].rq_nvec = 2;
 302
 303                 len = (2 * UniStrnlen((wchar_t *)ptr, PATH_MAX));
 304
 305                 vars->rename_info.ReplaceIfExists = 1;
 306                 vars->rename_info.RootDirectory = 0;
 307                 vars->rename_info.FileNameLength = cpu_to_le32(len);
 308
 309                 size[0] = sizeof(struct smb2_file_rename_info);
 310                 data[0] = &vars->rename_info;
 311
 312                 size[1] = len + 2 /* null */;
 313                 data[1] = (__le16 *)ptr;
 314
 315                 if (cfile)
 316                         rc = SMB2_set_info_init(tcon, server,
 317                                                 &rqst[num_rqst],
 318                                                 cfile->fid.persistent_fid,
 319                                                 cfile->fid.volatile_fid,
 320                                         current->tgid, FILE_RENAME_INFORMATION,
 321                                         SMB2_O_INFO_FILE, 0, data, size);
 322                 else {
 323                         rc = SMB2_set_info_init(tcon, server,
 324                                         &rqst[num_rqst],
 325                                         COMPOUND_FID, COMPOUND_FID,
 326                                         current->tgid, FILE_RENAME_INFORMATION,
 327                                         SMB2_O_INFO_FILE, 0, data, size);
 328                         if (!rc) {
 329                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 330                                 smb2_set_related(&rqst[num_rqst]);
 331                         }
 332                 }
 333                 if (rc)
 334                         goto finished;
 335                 num_rqst++;
 336                 trace_smb3_rename_enter(xid, ses->Suid, tcon->tid, full_path);
 337                 break;
 338         case SMB2_OP_HARDLINK:
 339                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 340                 rqst[num_rqst].rq_nvec = 2;
 341
 342                 len = (2 * UniStrnlen((wchar_t *)ptr, PATH_MAX));
 343
 344                 vars->link_info.ReplaceIfExists = 0;
 345                 vars->link_info.RootDirectory = 0;
 346                 vars->link_info.FileNameLength = cpu_to_le32(len);
 347
 348                 size[0] = sizeof(struct smb2_file_link_info);
 349                 data[0] = &vars->link_info;
 350
 351                 size[1] = len + 2 /* null */;
 352                 data[1] = (__le16 *)ptr;
 353
 354                 rc = SMB2_set_info_init(tcon, server,
 355                                         &rqst[num_rqst], COMPOUND_FID,
 356                                         COMPOUND_FID, current->tgid,
 357                                         FILE_LINK_INFORMATION,
 358                                         SMB2_O_INFO_FILE, 0, data, size);
 359                 if (rc)
 360                         goto finished;
 361                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 362                 smb2_set_related(&rqst[num_rqst++]);
 363                 trace_smb3_hardlink_enter(xid, ses->Suid, tcon->tid, full_path);
 364                 break;
 365         default:
 366                 cifs_dbg(VFS, "Invalid command\n");
 367                 rc = -EINVAL;
 368         }
 369         if (rc)
 370                 goto finished;
 371
 372         /* We already have a handle so we can skip the close */
 373         if (cfile)
 374                 goto after_close;
 375         /* Close */
 376         flags |= CIFS_CP_CREATE_CLOSE_OP;
 377         rqst[num_rqst].rq_iov = &vars->close_iov[0];
 378         rqst[num_rqst].rq_nvec = 1;
 379         rc = SMB2_close_init(tcon, server,
 380                              &rqst[num_rqst], COMPOUND_FID,
 381                              COMPOUND_FID, false);
 382         smb2_set_related(&rqst[num_rqst]);
 383         if (rc)
 384                 goto finished;
 385  after_close:
 386         num_rqst++;
 387
 388         if (cfile) {
 389                 rc = compound_send_recv(xid, ses, server,
 390                                         flags, num_rqst - 2,
 391                                         &rqst[1], &resp_buftype[1],
 392                                         &rsp_iov[1]);
 393         } else
 394                 rc = compound_send_recv(xid, ses, server,
 395                                         flags, num_rqst,
 396                                         rqst, resp_buftype,
 397                                         rsp_iov);
 398
 399  finished:
 400         if (cfile)
 401                 cifsFileInfo_put(cfile);
 402
 403         SMB2_open_free(&rqst[0]);
 404         if (rc == -EREMCHG) {
 405                 pr_warn_once("server share %s deleted\n", tcon->tree_name);
 406                 tcon->need_reconnect = true;
 407         }
 408
 409         switch (command) {
 410         case SMB2_OP_QUERY_INFO:
 411                 idata = ptr;
 412                 if (rc == 0 && cfile && cfile->symlink_target) {
 413                         idata->symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
 414                         if (!idata->symlink_target)
 415                                 rc = -ENOMEM;
 416                 }
 417                 if (rc == 0) {
 418                         qi_rsp = (struct smb2_query_info_rsp *)
 419                                 rsp_iov[1].iov_base;
 420                         rc = smb2_validate_and_copy_iov(
 421                                 le16_to_cpu(qi_rsp->OutputBufferOffset),
 422                                 le32_to_cpu(qi_rsp->OutputBufferLength),
 423                                 &rsp_iov[1], sizeof(idata->fi), (char *)&idata->fi);
 424                 }
 425                 if (rqst[1].rq_iov)
 426                         SMB2_query_info_free(&rqst[1]);
 427                 if (rqst[2].rq_iov)
 428                         SMB2_close_free(&rqst[2]);
 429                 if (rc)
 430                         trace_smb3_query_info_compound_err(xid,  ses->Suid,
 431                                                 tcon->tid, rc);
 432                 else
 433                         trace_smb3_query_info_compound_done(xid, ses->Suid,
 434                                                 tcon->tid);
 435                 break;
 436         case SMB2_OP_POSIX_QUERY_INFO:
 437                 idata = ptr;
 438                 if (rc == 0 && cfile && cfile->symlink_target) {
 439                         idata->symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
 440                         if (!idata->symlink_target)
 441                                 rc = -ENOMEM;
 442                 }
 443                 if (rc == 0) {
 444                         qi_rsp = (struct smb2_query_info_rsp *)
 445                                 rsp_iov[1].iov_base;
 446                         rc = smb2_validate_and_copy_iov(
 447                                 le16_to_cpu(qi_rsp->OutputBufferOffset),
 448                                 le32_to_cpu(qi_rsp->OutputBufferLength),
 449                                 &rsp_iov[1], sizeof(idata->posix_fi) /* add SIDs */,
 450                                 (char *)&idata->posix_fi);
 451                 }
 452                 if (rc == 0) {
 453                         unsigned int length = le32_to_cpu(qi_rsp->OutputBufferLength);
 454
 455                         if (length > sizeof(idata->posix_fi)) {
 456                                 char *base = (char *)rsp_iov[1].iov_base +
 457                                         le16_to_cpu(qi_rsp->OutputBufferOffset) +
 458                                         sizeof(idata->posix_fi);
 459                                 *extbuflen = length - sizeof(idata->posix_fi);
 460                                 *extbuf = kmemdup(base, *extbuflen, GFP_KERNEL);
 461                                 if (!*extbuf)
 462                                         rc = -ENOMEM;
 463                         } else {
 464                                 rc = -EINVAL;
 465                         }
 466                 }
 467                 if (rqst[1].rq_iov)
 468                         SMB2_query_info_free(&rqst[1]);
 469                 if (rqst[2].rq_iov)
 470                         SMB2_close_free(&rqst[2]);
 471                 if (rc)
 472                         trace_smb3_posix_query_info_compound_err(xid,  ses->Suid, tcon->tid, rc);
 473                 else
 474                         trace_smb3_posix_query_info_compound_done(xid, ses->Suid, tcon->tid);
 475                 break;
 476         case SMB2_OP_DELETE:
 477                 if (rc)
 478                         trace_smb3_delete_err(xid,  ses->Suid, tcon->tid, rc);
 479                 else
 480                         trace_smb3_delete_done(xid, ses->Suid, tcon->tid);
 481                 if (rqst[1].rq_iov)
 482                         SMB2_close_free(&rqst[1]);
 483                 break;
 484         case SMB2_OP_MKDIR:
 485                 if (rc)
 486                         trace_smb3_mkdir_err(xid,  ses->Suid, tcon->tid, rc);
 487                 else
 488                         trace_smb3_mkdir_done(xid, ses->Suid, tcon->tid);
 489                 if (rqst[1].rq_iov)
 490                         SMB2_close_free(&rqst[1]);
 491                 break;
 492         case SMB2_OP_HARDLINK:
 493                 if (rc)
 494                         trace_smb3_hardlink_err(xid,  ses->Suid, tcon->tid, rc);
 495                 else
 496                         trace_smb3_hardlink_done(xid, ses->Suid, tcon->tid);
 497                 free_set_inf_compound(rqst);
 498                 break;
 499         case SMB2_OP_RENAME:
 500                 if (rc)
 501                         trace_smb3_rename_err(xid,  ses->Suid, tcon->tid, rc);
 502                 else
 503                         trace_smb3_rename_done(xid, ses->Suid, tcon->tid);
 504                 free_set_inf_compound(rqst);
 505                 break;
 506         case SMB2_OP_RMDIR:
 507                 if (rc)
 508                         trace_smb3_rmdir_err(xid,  ses->Suid, tcon->tid, rc);
 509                 else
 510                         trace_smb3_rmdir_done(xid, ses->Suid, tcon->tid);
 511                 free_set_inf_compound(rqst);
 512                 break;
 513         case SMB2_OP_SET_EOF:
 514                 if (rc)
 515                         trace_smb3_set_eof_err(xid,  ses->Suid, tcon->tid, rc);
 516                 else
 517                         trace_smb3_set_eof_done(xid, ses->Suid, tcon->tid);
 518                 free_set_inf_compound(rqst);
 519                 break;
 520         case SMB2_OP_SET_INFO:
 521                 if (rc)
 522                         trace_smb3_set_info_compound_err(xid,  ses->Suid,
 523                                                 tcon->tid, rc);
 524                 else
 525                         trace_smb3_set_info_compound_done(xid, ses->Suid,
 526                                                 tcon->tid);
 527                 free_set_inf_compound(rqst);
 528                 break;
 529         }
 530
 531         if (rc && err_iov && err_buftype) {
 532                 memcpy(err_iov, rsp_iov, 3 * sizeof(*err_iov));
 533                 memcpy(err_buftype, resp_buftype, 3 * sizeof(*err_buftype));
 534         } else {
 535                 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
 536                 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
 537                 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
 538         }
 539         kfree(vars);
 540         return rc;
 541 }
 542
 543 int smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
 544                          struct cifs_sb_info *cifs_sb, const char *full_path,
 545                          struct cifs_open_info_data *data, bool *adjust_tz, bool *reparse)
 546 {
 547         __u32 create_options = 0;
 548         struct cifsFileInfo *cfile;
 549         struct cached_fid *cfid = NULL;
 550         struct kvec err_iov[3] = {};
 551         int err_buftype[3] = {};
 552         bool islink;
 553         int rc, rc2;
 554
 555         *adjust_tz = false;
 556         *reparse = false;
 557
 558         if (strcmp(full_path, ""))
 559                 rc = -ENOENT;
 560         else
 561                 rc = open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid);
 562         /* If it is a root and its handle is cached then use it */
 563         if (!rc) {
 564                 if (cfid->file_all_info_is_valid) {
 565                         memcpy(&data->fi, &cfid->file_all_info, sizeof(data->fi));
 566                 } else {
 567                         rc = SMB2_query_info(xid, tcon, cfid->fid.persistent_fid,
 568                                              cfid->fid.volatile_fid, &data->fi);
 569                 }
 570                 close_cached_dir(cfid);
 571                 return rc;
 572         }
 573
 574         cifs_get_readable_path(tcon, full_path, &cfile);
 575         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, FILE_READ_ATTRIBUTES, FILE_OPEN,
 576                               create_options, ACL_NO_MODE, data, SMB2_OP_QUERY_INFO, cfile,
 577                               NULL, NULL, err_iov, err_buftype);
 578         if (rc) {
 579                 struct smb2_hdr *hdr = err_iov[0].iov_base;
 580
 581                 if (unlikely(!hdr || err_buftype[0] == CIFS_NO_BUFFER))
 582                         goto out;
 583                 if (rc == -EOPNOTSUPP && hdr->Command == SMB2_CREATE &&
 584                     hdr->Status == STATUS_STOPPED_ON_SYMLINK) {
 585                         rc = smb2_parse_symlink_response(cifs_sb, err_iov,
 586                                                          &data->symlink_target);
 587                         if (rc)
 588                                 goto out;
 589
 590                         *reparse = true;
 591                         create_options |= OPEN_REPARSE_POINT;
 592
 593                         /* Failed on a symbolic link - query a reparse point info */
 594                         cifs_get_readable_path(tcon, full_path, &cfile);
 595                         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
 596                                               FILE_READ_ATTRIBUTES, FILE_OPEN,
 597                                               create_options, ACL_NO_MODE, data,
 598                                               SMB2_OP_QUERY_INFO, cfile, NULL, NULL,
 599                                               NULL, NULL);
 600                         goto out;
 601                 } else if (rc != -EREMOTE && hdr->Status == STATUS_OBJECT_NAME_INVALID) {
 602                         rc2 = cifs_inval_name_dfs_link_error(xid, tcon, cifs_sb,
 603                                                              full_path, &islink);
 604                         if (rc2) {
 605                                 rc = rc2;
 606                                 goto out;
 607                         }
 608                         if (islink)
 609                                 rc = -EREMOTE;
 610                 }
 611                 if (rc == -EREMOTE && IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) && cifs_sb &&
 612                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS))
 613                         rc = -EOPNOTSUPP;
 614         }
 615
 616 out:
 617         free_rsp_buf(err_buftype[0], err_iov[0].iov_base);
 618         free_rsp_buf(err_buftype[1], err_iov[1].iov_base);
 619         free_rsp_buf(err_buftype[2], err_iov[2].iov_base);
 620         return rc;
 621 }
 622
 623
 624 int smb311_posix_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
 625                                  struct cifs_sb_info *cifs_sb, const char *full_path,
 626                                  struct cifs_open_info_data *data,
 627                                  struct cifs_sid *owner,
 628                                  struct cifs_sid *group,
 629                                  bool *adjust_tz, bool *reparse)
 630 {
 631         int rc;
 632         __u32 create_options = 0;
 633         struct cifsFileInfo *cfile;
 634         struct kvec err_iov[3] = {};
 635         int err_buftype[3] = {};
 636         __u8 *sidsbuf = NULL;
 637         __u8 *sidsbuf_end = NULL;
 638         size_t sidsbuflen = 0;
 639         size_t owner_len, group_len;
 640
 641         *adjust_tz = false;
 642         *reparse = false;
 643
 644         /*
 645          * BB TODO: Add support for using the cached root handle.
 646          * Create SMB2_query_posix_info worker function to do non-compounded query
 647          * when we already have an open file handle for this. For now this is fast enough
 648          * (always using the compounded version).
 649          */
 650
 651         cifs_get_readable_path(tcon, full_path, &cfile);
 652         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, FILE_READ_ATTRIBUTES, FILE_OPEN,
 653                               create_options, ACL_NO_MODE, data, SMB2_OP_POSIX_QUERY_INFO, cfile,
 654                               &sidsbuf, &sidsbuflen, err_iov, err_buftype);
 655         if (rc == -EOPNOTSUPP) {
 656                 /* BB TODO: When support for special files added to Samba re-verify this path */
 657                 if (err_iov[0].iov_base && err_buftype[0] != CIFS_NO_BUFFER &&
 658                     ((struct smb2_hdr *)err_iov[0].iov_base)->Command == SMB2_CREATE &&
 659                     ((struct smb2_hdr *)err_iov[0].iov_base)->Status == STATUS_STOPPED_ON_SYMLINK) {
 660                         rc = smb2_parse_symlink_response(cifs_sb, err_iov, &data->symlink_target);
 661                         if (rc)
 662                                 goto out;
 663                 }
 664                 *reparse = true;
 665                 create_options |= OPEN_REPARSE_POINT;
 666
 667                 /* Failed on a symbolic link - query a reparse point info */
 668                 cifs_get_readable_path(tcon, full_path, &cfile);
 669                 rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, FILE_READ_ATTRIBUTES,
 670                                       FILE_OPEN, create_options, ACL_NO_MODE, data,
 671                                       SMB2_OP_POSIX_QUERY_INFO, cfile,
 672                                       &sidsbuf, &sidsbuflen, NULL, NULL);
 673         }
 674
 675         if (rc == 0) {
 676                 sidsbuf_end = sidsbuf + sidsbuflen;
 677
 678                 owner_len = posix_info_sid_size(sidsbuf, sidsbuf_end);
 679                 if (owner_len == -1) {
 680                         rc = -EINVAL;
 681                         goto out;
 682                 }
 683                 memcpy(owner, sidsbuf, owner_len);
 684
 685                 group_len = posix_info_sid_size(
 686                         sidsbuf + owner_len, sidsbuf_end);
 687                 if (group_len == -1) {
 688                         rc = -EINVAL;
 689                         goto out;
 690                 }
 691                 memcpy(group, sidsbuf + owner_len, group_len);
 692         }
 693
 694 out:
 695         kfree(sidsbuf);
 696         free_rsp_buf(err_buftype[0], err_iov[0].iov_base);
 697         free_rsp_buf(err_buftype[1], err_iov[1].iov_base);
 698         free_rsp_buf(err_buftype[2], err_iov[2].iov_base);
 699         return rc;
 700 }
 701
 702 int
 703 smb2_mkdir(const unsigned int xid, struct inode *parent_inode, umode_t mode,
 704            struct cifs_tcon *tcon, const char *name,
 705            struct cifs_sb_info *cifs_sb)
 706 {
 707         return smb2_compound_op(xid, tcon, cifs_sb, name,
 708                                 FILE_WRITE_ATTRIBUTES, FILE_CREATE,
 709                                 CREATE_NOT_FILE, mode, NULL, SMB2_OP_MKDIR,
 710                                 NULL, NULL, NULL, NULL, NULL);
 711 }
 712
 713 void
 714 smb2_mkdir_setinfo(struct inode *inode, const char *name,
 715                    struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
 716                    const unsigned int xid)
 717 {
 718         FILE_BASIC_INFO data;
 719         struct cifsInodeInfo *cifs_i;
 720         struct cifsFileInfo *cfile;
 721         u32 dosattrs;
 722         int tmprc;
 723
 724         memset(&data, 0, sizeof(data));
 725         cifs_i = CIFS_I(inode);
 726         dosattrs = cifs_i->cifsAttrs | ATTR_READONLY;
 727         data.Attributes = cpu_to_le32(dosattrs);
 728         cifs_get_writable_path(tcon, name, FIND_WR_ANY, &cfile);
 729         tmprc = smb2_compound_op(xid, tcon, cifs_sb, name,
 730                                  FILE_WRITE_ATTRIBUTES, FILE_CREATE,
 731                                  CREATE_NOT_FILE, ACL_NO_MODE,
 732                                  &data, SMB2_OP_SET_INFO, cfile, NULL, NULL, NULL, NULL);
 733         if (tmprc == 0)
 734                 cifs_i->cifsAttrs = dosattrs;
 735 }
 736
 737 int
 738 smb2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 739            struct cifs_sb_info *cifs_sb)
 740 {
 741         drop_cached_dir_by_name(xid, tcon, name, cifs_sb);
 742         return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
 743                                 CREATE_NOT_FILE, ACL_NO_MODE,
 744                                 NULL, SMB2_OP_RMDIR, NULL, NULL, NULL, NULL, NULL);
 745 }
 746
 747 int
 748 smb2_unlink(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 749             struct cifs_sb_info *cifs_sb)
 750 {
 751         return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
 752                                 CREATE_DELETE_ON_CLOSE | OPEN_REPARSE_POINT,
 753                                 ACL_NO_MODE, NULL, SMB2_OP_DELETE, NULL, NULL, NULL, NULL, NULL);
 754 }
 755
 756 static int
 757 smb2_set_path_attr(const unsigned int xid, struct cifs_tcon *tcon,
 758                    const char *from_name, const char *to_name,
 759                    struct cifs_sb_info *cifs_sb, __u32 access, int command,
 760                    struct cifsFileInfo *cfile)
 761 {
 762         __le16 *smb2_to_name = NULL;
 763         int rc;
 764
 765         smb2_to_name = cifs_convert_path_to_utf16(to_name, cifs_sb);
 766         if (smb2_to_name == NULL) {
 767                 rc = -ENOMEM;
 768                 goto smb2_rename_path;
 769         }
 770         rc = smb2_compound_op(xid, tcon, cifs_sb, from_name, access,
 771                               FILE_OPEN, 0, ACL_NO_MODE, smb2_to_name,
 772                               command, cfile, NULL, NULL, NULL, NULL);
 773 smb2_rename_path:
 774         kfree(smb2_to_name);
 775         return rc;
 776 }
 777
 778 int
 779 smb2_rename_path(const unsigned int xid, struct cifs_tcon *tcon,
 780                  const char *from_name, const char *to_name,
 781                  struct cifs_sb_info *cifs_sb)
 782 {
 783         struct cifsFileInfo *cfile;
 784
 785         drop_cached_dir_by_name(xid, tcon, from_name, cifs_sb);
 786         cifs_get_writable_path(tcon, from_name, FIND_WR_WITH_DELETE, &cfile);
 787
 788         return smb2_set_path_attr(xid, tcon, from_name, to_name,
 789                                   cifs_sb, DELETE, SMB2_OP_RENAME, cfile);
 790 }
 791
 792 int
 793 smb2_create_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
 794                      const char *from_name, const char *to_name,
 795                      struct cifs_sb_info *cifs_sb)
 796 {
 797         return smb2_set_path_attr(xid, tcon, from_name, to_name, cifs_sb,
 798                                   FILE_READ_ATTRIBUTES, SMB2_OP_HARDLINK,
 799                                   NULL);
 800 }
 801
 802 int
 803 smb2_set_path_size(const unsigned int xid, struct cifs_tcon *tcon,
 804                    const char *full_path, __u64 size,
 805                    struct cifs_sb_info *cifs_sb, bool set_alloc)
 806 {
 807         __le64 eof = cpu_to_le64(size);
 808         struct cifsFileInfo *cfile;
 809
 810         cifs_get_writable_path(tcon, full_path, FIND_WR_ANY, &cfile);
 811         return smb2_compound_op(xid, tcon, cifs_sb, full_path,
 812                                 FILE_WRITE_DATA, FILE_OPEN, 0, ACL_NO_MODE,
 813                                 &eof, SMB2_OP_SET_EOF, cfile, NULL, NULL, NULL, NULL);
 814 }
 815
 816 int
 817 smb2_set_file_info(struct inode *inode, const char *full_path,
 818                    FILE_BASIC_INFO *buf, const unsigned int xid)
 819 {
 820         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 821         struct tcon_link *tlink;
 822         struct cifs_tcon *tcon;
 823         struct cifsFileInfo *cfile;
 824         int rc;
 825
 826         if ((buf->CreationTime == 0) && (buf->LastAccessTime == 0) &&
 827             (buf->LastWriteTime == 0) && (buf->ChangeTime == 0) &&
 828             (buf->Attributes == 0))
 829                 return 0; /* would be a no op, no sense sending this */
 830
 831         tlink = cifs_sb_tlink(cifs_sb);
 832         if (IS_ERR(tlink))
 833                 return PTR_ERR(tlink);
 834         tcon = tlink_tcon(tlink);
 835
 836         cifs_get_writable_path(tcon, full_path, FIND_WR_ANY, &cfile);
 837         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
 838                               FILE_WRITE_ATTRIBUTES, FILE_OPEN,
 839                               0, ACL_NO_MODE, buf, SMB2_OP_SET_INFO, cfile,
 840                               NULL, NULL, NULL, NULL);
 841         cifs_put_tlink(tlink);
 842         return rc;
 843 }