fs/ksmbd/smb_common.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
   4  *   Copyright (C) 2018 Namjae Jeon <linkinjeon@kernel.org>
   5  */
   6
   7 #include <linux/user_namespace.h>
   8
   9 #include "smb_common.h"
  10 #include "server.h"
  11 #include "misc.h"
  12 #include "smbstatus.h"
  13 #include "connection.h"
  14 #include "ksmbd_work.h"
  15 #include "mgmt/user_session.h"
  16 #include "mgmt/user_config.h"
  17 #include "mgmt/tree_connect.h"
  18 #include "mgmt/share_config.h"
  19
  20 /*for shortname implementation */
  21 static const char basechars[43] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%";
  22 #define MANGLE_BASE (sizeof(basechars) / sizeof(char) - 1)
  23 #define MAGIC_CHAR '~'
  24 #define PERIOD '.'
  25 #define mangle(V) ((char)(basechars[(V) % MANGLE_BASE]))
  26
  27 struct smb_protocol {
  28         int             index;
  29         char            *name;
  30         char            *prot;
  31         __u16           prot_id;
  32 };
  33
  34 static struct smb_protocol smb1_protos[] = {
  35         {
  36                 SMB21_PROT,
  37                 "\2SMB 2.1",
  38                 "SMB2_10",
  39                 SMB21_PROT_ID
  40         },
  41         {
  42                 SMB2X_PROT,
  43                 "\2SMB 2.???",
  44                 "SMB2_22",
  45                 SMB2X_PROT_ID
  46         },
  47 };
  48
  49 static struct smb_protocol smb2_protos[] = {
  50         {
  51                 SMB21_PROT,
  52                 "\2SMB 2.1",
  53                 "SMB2_10",
  54                 SMB21_PROT_ID
  55         },
  56         {
  57                 SMB30_PROT,
  58                 "\2SMB 3.0",
  59                 "SMB3_00",
  60                 SMB30_PROT_ID
  61         },
  62         {
  63                 SMB302_PROT,
  64                 "\2SMB 3.02",
  65                 "SMB3_02",
  66                 SMB302_PROT_ID
  67         },
  68         {
  69                 SMB311_PROT,
  70                 "\2SMB 3.1.1",
  71                 "SMB3_11",
  72                 SMB311_PROT_ID
  73         },
  74 };
  75
  76 unsigned int ksmbd_server_side_copy_max_chunk_count(void)
  77 {
  78         return 256;
  79 }
  80
  81 unsigned int ksmbd_server_side_copy_max_chunk_size(void)
  82 {
  83         return (2U << 30) - 1;
  84 }
  85
  86 unsigned int ksmbd_server_side_copy_max_total_size(void)
  87 {
  88         return (2U << 30) - 1;
  89 }
  90
  91 inline int ksmbd_min_protocol(void)
  92 {
  93         return SMB21_PROT;
  94 }
  95
  96 inline int ksmbd_max_protocol(void)
  97 {
  98         return SMB311_PROT;
  99 }
 100
 101 int ksmbd_lookup_protocol_idx(char *str)
 102 {
 103         int offt = ARRAY_SIZE(smb1_protos) - 1;
 104         int len = strlen(str);
 105
 106         while (offt >= 0) {
 107                 if (!strncmp(str, smb1_protos[offt].prot, len)) {
 108                         ksmbd_debug(SMB, "selected %s dialect idx = %d\n",
 109                                     smb1_protos[offt].prot, offt);
 110                         return smb1_protos[offt].index;
 111                 }
 112                 offt--;
 113         }
 114
 115         offt = ARRAY_SIZE(smb2_protos) - 1;
 116         while (offt >= 0) {
 117                 if (!strncmp(str, smb2_protos[offt].prot, len)) {
 118                         ksmbd_debug(SMB, "selected %s dialect idx = %d\n",
 119                                     smb2_protos[offt].prot, offt);
 120                         return smb2_protos[offt].index;
 121                 }
 122                 offt--;
 123         }
 124         return -1;
 125 }
 126
 127 /**
 128  * ksmbd_verify_smb_message() - check for valid smb2 request header
 129  * @work:       smb work
 130  *
 131  * check for valid smb signature and packet direction(request/response)
 132  *
 133  * Return:      0 on success, otherwise -EINVAL
 134  */
 135 int ksmbd_verify_smb_message(struct ksmbd_work *work)
 136 {
 137         struct smb2_hdr *smb2_hdr = ksmbd_req_buf_next(work);
 138         struct smb_hdr *hdr;
 139
 140         if (smb2_hdr->ProtocolId == SMB2_PROTO_NUMBER)
 141                 return ksmbd_smb2_check_message(work);
 142
 143         hdr = work->request_buf;
 144         if (*(__le32 *)hdr->Protocol == SMB1_PROTO_NUMBER &&
 145             hdr->Command == SMB_COM_NEGOTIATE) {
 146                 work->conn->outstanding_credits++;
 147                 return 0;
 148         }
 149
 150         return -EINVAL;
 151 }
 152
 153 /**
 154  * ksmbd_smb_request() - check for valid smb request type
 155  * @conn:       connection instance
 156  *
 157  * Return:      true on success, otherwise false
 158  */
 159 bool ksmbd_smb_request(struct ksmbd_conn *conn)
 160 {
 161         return conn->request_buf[0] == 0;
 162 }
 163
 164 static bool supported_protocol(int idx)
 165 {
 166         if (idx == SMB2X_PROT &&
 167             (server_conf.min_protocol >= SMB21_PROT ||
 168              server_conf.max_protocol <= SMB311_PROT))
 169                 return true;
 170
 171         return (server_conf.min_protocol <= idx &&
 172                 idx <= server_conf.max_protocol);
 173 }
 174
 175 static char *next_dialect(char *dialect, int *next_off, int bcount)
 176 {
 177         dialect = dialect + *next_off;
 178         *next_off = strnlen(dialect, bcount);
 179         if (dialect[*next_off] != '\0')
 180                 return NULL;
 181         return dialect;
 182 }
 183
 184 static int ksmbd_lookup_dialect_by_name(char *cli_dialects, __le16 byte_count)
 185 {
 186         int i, seq_num, bcount, next;
 187         char *dialect;
 188
 189         for (i = ARRAY_SIZE(smb1_protos) - 1; i >= 0; i--) {
 190                 seq_num = 0;
 191                 next = 0;
 192                 dialect = cli_dialects;
 193                 bcount = le16_to_cpu(byte_count);
 194                 do {
 195                         dialect = next_dialect(dialect, &next, bcount);
 196                         if (!dialect)
 197                                 break;
 198                         ksmbd_debug(SMB, "client requested dialect %s\n",
 199                                     dialect);
 200                         if (!strcmp(dialect, smb1_protos[i].name)) {
 201                                 if (supported_protocol(smb1_protos[i].index)) {
 202                                         ksmbd_debug(SMB,
 203                                                     "selected %s dialect\n",
 204                                                     smb1_protos[i].name);
 205                                         if (smb1_protos[i].index == SMB1_PROT)
 206                                                 return seq_num;
 207                                         return smb1_protos[i].prot_id;
 208                                 }
 209                         }
 210                         seq_num++;
 211                         bcount -= (++next);
 212                 } while (bcount > 0);
 213         }
 214
 215         return BAD_PROT_ID;
 216 }
 217
 218 int ksmbd_lookup_dialect_by_id(__le16 *cli_dialects, __le16 dialects_count)
 219 {
 220         int i;
 221         int count;
 222
 223         for (i = ARRAY_SIZE(smb2_protos) - 1; i >= 0; i--) {
 224                 count = le16_to_cpu(dialects_count);
 225                 while (--count >= 0) {
 226                         ksmbd_debug(SMB, "client requested dialect 0x%x\n",
 227                                     le16_to_cpu(cli_dialects[count]));
 228                         if (le16_to_cpu(cli_dialects[count]) !=
 229                                         smb2_protos[i].prot_id)
 230                                 continue;
 231
 232                         if (supported_protocol(smb2_protos[i].index)) {
 233                                 ksmbd_debug(SMB, "selected %s dialect\n",
 234                                             smb2_protos[i].name);
 235                                 return smb2_protos[i].prot_id;
 236                         }
 237                 }
 238         }
 239
 240         return BAD_PROT_ID;
 241 }
 242
 243 static int ksmbd_negotiate_smb_dialect(void *buf)
 244 {
 245         int smb_buf_length = get_rfc1002_len(buf);
 246         __le32 proto = ((struct smb2_hdr *)smb2_get_msg(buf))->ProtocolId;
 247
 248         if (proto == SMB2_PROTO_NUMBER) {
 249                 struct smb2_negotiate_req *req;
 250                 int smb2_neg_size =
 251                         offsetof(struct smb2_negotiate_req, Dialects);
 252
 253                 req = (struct smb2_negotiate_req *)smb2_get_msg(buf);
 254                 if (smb2_neg_size > smb_buf_length)
 255                         goto err_out;
 256
 257                 if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof(__le16) >
 258                     smb_buf_length)
 259                         goto err_out;
 260
 261                 return ksmbd_lookup_dialect_by_id(req->Dialects,
 262                                                   req->DialectCount);
 263         }
 264
 265         proto = *(__le32 *)((struct smb_hdr *)buf)->Protocol;
 266         if (proto == SMB1_PROTO_NUMBER) {
 267                 struct smb_negotiate_req *req;
 268
 269                 req = (struct smb_negotiate_req *)buf;
 270                 if (le16_to_cpu(req->ByteCount) < 2)
 271                         goto err_out;
 272
 273                 if (offsetof(struct smb_negotiate_req, DialectsArray) - 4 +
 274                         le16_to_cpu(req->ByteCount) > smb_buf_length) {
 275                         goto err_out;
 276                 }
 277
 278                 return ksmbd_lookup_dialect_by_name(req->DialectsArray,
 279                                                     req->ByteCount);
 280         }
 281
 282 err_out:
 283         return BAD_PROT_ID;
 284 }
 285
 286 int ksmbd_init_smb_server(struct ksmbd_work *work)
 287 {
 288         struct ksmbd_conn *conn = work->conn;
 289
 290         if (conn->need_neg == false)
 291                 return 0;
 292
 293         init_smb3_11_server(conn);
 294
 295         if (conn->ops->get_cmd_val(work) != SMB_COM_NEGOTIATE)
 296                 conn->need_neg = false;
 297         return 0;
 298 }
 299
 300 int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
 301                                       struct ksmbd_file *dir,
 302                                       struct ksmbd_dir_info *d_info,
 303                                       char *search_pattern,
 304                                       int (*fn)(struct ksmbd_conn *, int,
 305                                                 struct ksmbd_dir_info *,
 306                                                 struct ksmbd_kstat *))
 307 {
 308         int i, rc = 0;
 309         struct ksmbd_conn *conn = work->conn;
 310         struct mnt_idmap *idmap = file_mnt_idmap(dir->filp);
 311
 312         for (i = 0; i < 2; i++) {
 313                 struct kstat kstat;
 314                 struct ksmbd_kstat ksmbd_kstat;
 315                 struct dentry *dentry;
 316
 317                 if (!dir->dot_dotdot[i]) { /* fill dot entry info */
 318                         if (i == 0) {
 319                                 d_info->name = ".";
 320                                 d_info->name_len = 1;
 321                                 dentry = dir->filp->f_path.dentry;
 322                         } else {
 323                                 d_info->name = "..";
 324                                 d_info->name_len = 2;
 325                                 dentry = dir->filp->f_path.dentry->d_parent;
 326                         }
 327
 328                         if (!match_pattern(d_info->name, d_info->name_len,
 329                                            search_pattern)) {
 330                                 dir->dot_dotdot[i] = 1;
 331                                 continue;
 332                         }
 333
 334                         ksmbd_kstat.kstat = &kstat;
 335                         ksmbd_vfs_fill_dentry_attrs(work,
 336                                                     idmap,
 337                                                     dentry,
 338                                                     &ksmbd_kstat);
 339                         rc = fn(conn, info_level, d_info, &ksmbd_kstat);
 340                         if (rc)
 341                                 break;
 342                         if (d_info->out_buf_len <= 0)
 343                                 break;
 344
 345                         dir->dot_dotdot[i] = 1;
 346                         if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) {
 347                                 d_info->out_buf_len = 0;
 348                                 break;
 349                         }
 350                 }
 351         }
 352
 353         return rc;
 354 }
 355
 356 /**
 357  * ksmbd_extract_shortname() - get shortname from long filename
 358  * @conn:       connection instance
 359  * @longname:   source long filename
 360  * @shortname:  destination short filename
 361  *
 362  * Return:      shortname length or 0 when source long name is '.' or '..'
 363  * TODO: Though this function comforms the restriction of 8.3 Filename spec,
 364  * but the result is different with Windows 7's one. need to check.
 365  */
 366 int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname,
 367                             char *shortname)
 368 {
 369         const char *p;
 370         char base[9], extension[4];
 371         char out[13] = {0};
 372         int baselen = 0;
 373         int extlen = 0, len = 0;
 374         unsigned int csum = 0;
 375         const unsigned char *ptr;
 376         bool dot_present = true;
 377
 378         p = longname;
 379         if ((*p == '.') || (!(strcmp(p, "..")))) {
 380                 /*no mangling required */
 381                 return 0;
 382         }
 383
 384         p = strrchr(longname, '.');
 385         if (p == longname) { /*name starts with a dot*/
 386                 strscpy(extension, "___", strlen("___"));
 387         } else {
 388                 if (p) {
 389                         p++;
 390                         while (*p && extlen < 3) {
 391                                 if (*p != '.')
 392                                         extension[extlen++] = toupper(*p);
 393                                 p++;
 394                         }
 395                         extension[extlen] = '\0';
 396                 } else {
 397                         dot_present = false;
 398                 }
 399         }
 400
 401         p = longname;
 402         if (*p == '.') {
 403                 p++;
 404                 longname++;
 405         }
 406         while (*p && (baselen < 5)) {
 407                 if (*p != '.')
 408                         base[baselen++] = toupper(*p);
 409                 p++;
 410         }
 411
 412         base[baselen] = MAGIC_CHAR;
 413         memcpy(out, base, baselen + 1);
 414
 415         ptr = longname;
 416         len = strlen(longname);
 417         for (; len > 0; len--, ptr++)
 418                 csum += *ptr;
 419
 420         csum = csum % (MANGLE_BASE * MANGLE_BASE);
 421         out[baselen + 1] = mangle(csum / MANGLE_BASE);
 422         out[baselen + 2] = mangle(csum);
 423         out[baselen + 3] = PERIOD;
 424
 425         if (dot_present)
 426                 memcpy(&out[baselen + 4], extension, 4);
 427         else
 428                 out[baselen + 4] = '\0';
 429         smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX,
 430                           conn->local_nls, 0);
 431         len = strlen(out) * 2;
 432         return len;
 433 }
 434
 435 static int __smb2_negotiate(struct ksmbd_conn *conn)
 436 {
 437         return (conn->dialect >= SMB20_PROT_ID &&
 438                 conn->dialect <= SMB311_PROT_ID);
 439 }
 440
 441 static int smb_handle_negotiate(struct ksmbd_work *work)
 442 {
 443         struct smb_negotiate_rsp *neg_rsp = work->response_buf;
 444
 445         ksmbd_debug(SMB, "Unsupported SMB1 protocol\n");
 446
 447         /*
 448          * Remove 4 byte direct TCP header, add 2 byte bcc and
 449          * 2 byte DialectIndex.
 450          */
 451         *(__be32 *)work->response_buf =
 452                 cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2 + 2);
 453         neg_rsp->hdr.Status.CifsError = STATUS_SUCCESS;
 454
 455         neg_rsp->hdr.Command = SMB_COM_NEGOTIATE;
 456         *(__le32 *)neg_rsp->hdr.Protocol = SMB1_PROTO_NUMBER;
 457         neg_rsp->hdr.Flags = SMBFLG_RESPONSE;
 458         neg_rsp->hdr.Flags2 = SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS |
 459                 SMBFLG2_EXT_SEC | SMBFLG2_IS_LONG_NAME;
 460
 461         neg_rsp->hdr.WordCount = 1;
 462         neg_rsp->DialectIndex = cpu_to_le16(work->conn->dialect);
 463         neg_rsp->ByteCount = 0;
 464         return 0;
 465 }
 466
 467 int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command)
 468 {
 469         struct ksmbd_conn *conn = work->conn;
 470         int ret;
 471
 472         conn->dialect =
 473                 ksmbd_negotiate_smb_dialect(work->request_buf);
 474         ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect);
 475
 476         if (command == SMB2_NEGOTIATE_HE) {
 477                 struct smb2_hdr *smb2_hdr = smb2_get_msg(work->request_buf);
 478
 479                 if (smb2_hdr->ProtocolId != SMB2_PROTO_NUMBER) {
 480                         ksmbd_debug(SMB, "Downgrade to SMB1 negotiation\n");
 481                         command = SMB_COM_NEGOTIATE;
 482                 }
 483         }
 484
 485         if (command == SMB2_NEGOTIATE_HE) {
 486                 ret = smb2_handle_negotiate(work);
 487                 init_smb2_neg_rsp(work);
 488                 return ret;
 489         }
 490
 491         if (command == SMB_COM_NEGOTIATE) {
 492                 if (__smb2_negotiate(conn)) {
 493                         conn->need_neg = true;
 494                         init_smb3_11_server(conn);
 495                         init_smb2_neg_rsp(work);
 496                         ksmbd_debug(SMB, "Upgrade to SMB2 negotiation\n");
 497                         return 0;
 498                 }
 499                 return smb_handle_negotiate(work);
 500         }
 501
 502         pr_err("Unknown SMB negotiation command: %u\n", command);
 503         return -EINVAL;
 504 }
 505
 506 enum SHARED_MODE_ERRORS {
 507         SHARE_DELETE_ERROR,
 508         SHARE_READ_ERROR,
 509         SHARE_WRITE_ERROR,
 510         FILE_READ_ERROR,
 511         FILE_WRITE_ERROR,
 512         FILE_DELETE_ERROR,
 513 };
 514
 515 static const char * const shared_mode_errors[] = {
 516         "Current access mode does not permit SHARE_DELETE",
 517         "Current access mode does not permit SHARE_READ",
 518         "Current access mode does not permit SHARE_WRITE",
 519         "Desired access mode does not permit FILE_READ",
 520         "Desired access mode does not permit FILE_WRITE",
 521         "Desired access mode does not permit FILE_DELETE",
 522 };
 523
 524 static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp,
 525                                   struct ksmbd_file *curr_fp)
 526 {
 527         ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]);
 528         ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n",
 529                     prev_fp->saccess, curr_fp->daccess);
 530 }
 531
 532 int ksmbd_smb_check_shared_mode(struct file *filp, struct ksmbd_file *curr_fp)
 533 {
 534         int rc = 0;
 535         struct ksmbd_file *prev_fp;
 536
 537         /*
 538          * Lookup fp in master fp list, and check desired access and
 539          * shared mode between previous open and current open.
 540          */
 541         read_lock(&curr_fp->f_ci->m_lock);
 542         list_for_each_entry(prev_fp, &curr_fp->f_ci->m_fp_list, node) {
 543                 if (file_inode(filp) != file_inode(prev_fp->filp))
 544                         continue;
 545
 546                 if (filp == prev_fp->filp)
 547                         continue;
 548
 549                 if (ksmbd_stream_fd(prev_fp) && ksmbd_stream_fd(curr_fp))
 550                         if (strcmp(prev_fp->stream.name, curr_fp->stream.name))
 551                                 continue;
 552
 553                 if (prev_fp->attrib_only != curr_fp->attrib_only)
 554                         continue;
 555
 556                 if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) &&
 557                     curr_fp->daccess & FILE_DELETE_LE) {
 558                         smb_shared_mode_error(SHARE_DELETE_ERROR,
 559                                               prev_fp,
 560                                               curr_fp);
 561                         rc = -EPERM;
 562                         break;
 563                 }
 564
 565                 /*
 566                  * Only check FILE_SHARE_DELETE if stream opened and
 567                  * normal file opened.
 568                  */
 569                 if (ksmbd_stream_fd(prev_fp) && !ksmbd_stream_fd(curr_fp))
 570                         continue;
 571
 572                 if (!(prev_fp->saccess & FILE_SHARE_READ_LE) &&
 573                     curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) {
 574                         smb_shared_mode_error(SHARE_READ_ERROR,
 575                                               prev_fp,
 576                                               curr_fp);
 577                         rc = -EPERM;
 578                         break;
 579                 }
 580
 581                 if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) &&
 582                     curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) {
 583                         smb_shared_mode_error(SHARE_WRITE_ERROR,
 584                                               prev_fp,
 585                                               curr_fp);
 586                         rc = -EPERM;
 587                         break;
 588                 }
 589
 590                 if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) &&
 591                     !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
 592                         smb_shared_mode_error(FILE_READ_ERROR,
 593                                               prev_fp,
 594                                               curr_fp);
 595                         rc = -EPERM;
 596                         break;
 597                 }
 598
 599                 if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) &&
 600                     !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
 601                         smb_shared_mode_error(FILE_WRITE_ERROR,
 602                                               prev_fp,
 603                                               curr_fp);
 604                         rc = -EPERM;
 605                         break;
 606                 }
 607
 608                 if (prev_fp->daccess & FILE_DELETE_LE &&
 609                     !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
 610                         smb_shared_mode_error(FILE_DELETE_ERROR,
 611                                               prev_fp,
 612                                               curr_fp);
 613                         rc = -EPERM;
 614                         break;
 615                 }
 616         }
 617         read_unlock(&curr_fp->f_ci->m_lock);
 618
 619         return rc;
 620 }
 621
 622 bool is_asterisk(char *p)
 623 {
 624         return p && p[0] == '*';
 625 }
 626
 627 int ksmbd_override_fsids(struct ksmbd_work *work)
 628 {
 629         struct ksmbd_session *sess = work->sess;
 630         struct ksmbd_share_config *share = work->tcon->share_conf;
 631         struct cred *cred;
 632         struct group_info *gi;
 633         unsigned int uid;
 634         unsigned int gid;
 635
 636         uid = user_uid(sess->user);
 637         gid = user_gid(sess->user);
 638         if (share->force_uid != KSMBD_SHARE_INVALID_UID)
 639                 uid = share->force_uid;
 640         if (share->force_gid != KSMBD_SHARE_INVALID_GID)
 641                 gid = share->force_gid;
 642
 643         cred = prepare_kernel_cred(&init_task);
 644         if (!cred)
 645                 return -ENOMEM;
 646
 647         cred->fsuid = make_kuid(&init_user_ns, uid);
 648         cred->fsgid = make_kgid(&init_user_ns, gid);
 649
 650         gi = groups_alloc(0);
 651         if (!gi) {
 652                 abort_creds(cred);
 653                 return -ENOMEM;
 654         }
 655         set_groups(cred, gi);
 656         put_group_info(gi);
 657
 658         if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID))
 659                 cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
 660
 661         WARN_ON(work->saved_cred);
 662         work->saved_cred = override_creds(cred);
 663         if (!work->saved_cred) {
 664                 abort_creds(cred);
 665                 return -EINVAL;
 666         }
 667         return 0;
 668 }
 669
 670 void ksmbd_revert_fsids(struct ksmbd_work *work)
 671 {
 672         const struct cred *cred;
 673
 674         WARN_ON(!work->saved_cred);
 675
 676         cred = current_cred();
 677         revert_creds(work->saved_cred);
 678         put_cred(cred);
 679         work->saved_cred = NULL;
 680 }
 681
 682 __le32 smb_map_generic_desired_access(__le32 daccess)
 683 {
 684         if (daccess & FILE_GENERIC_READ_LE) {
 685                 daccess |= cpu_to_le32(GENERIC_READ_FLAGS);
 686                 daccess &= ~FILE_GENERIC_READ_LE;
 687         }
 688
 689         if (daccess & FILE_GENERIC_WRITE_LE) {
 690                 daccess |= cpu_to_le32(GENERIC_WRITE_FLAGS);
 691                 daccess &= ~FILE_GENERIC_WRITE_LE;
 692         }
 693
 694         if (daccess & FILE_GENERIC_EXECUTE_LE) {
 695                 daccess |= cpu_to_le32(GENERIC_EXECUTE_FLAGS);
 696                 daccess &= ~FILE_GENERIC_EXECUTE_LE;
 697         }
 698
 699         if (daccess & FILE_GENERIC_ALL_LE) {
 700                 daccess |= cpu_to_le32(GENERIC_ALL_FLAGS);
 701                 daccess &= ~FILE_GENERIC_ALL_LE;
 702         }
 703
 704         return daccess;
 705 }