fs/smb/server/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         __le32 *proto;
 162
 163         if (conn->request_buf[0] != 0)
 164                 return false;
 165
 166         proto = (__le32 *)smb2_get_msg(conn->request_buf);
 167         if (*proto == SMB2_COMPRESSION_TRANSFORM_ID) {
 168                 pr_err_ratelimited("smb2 compression not support yet");
 169                 return false;
 170         }
 171
 172         if (*proto != SMB1_PROTO_NUMBER &&
 173             *proto != SMB2_PROTO_NUMBER &&
 174             *proto != SMB2_TRANSFORM_PROTO_NUM)
 175                 return false;
 176
 177         return true;
 178 }
 179
 180 static bool supported_protocol(int idx)
 181 {
 182         if (idx == SMB2X_PROT &&
 183             (server_conf.min_protocol >= SMB21_PROT ||
 184              server_conf.max_protocol <= SMB311_PROT))
 185                 return true;
 186
 187         return (server_conf.min_protocol <= idx &&
 188                 idx <= server_conf.max_protocol);
 189 }
 190
 191 static char *next_dialect(char *dialect, int *next_off, int bcount)
 192 {
 193         dialect = dialect + *next_off;
 194         *next_off = strnlen(dialect, bcount);
 195         if (dialect[*next_off] != '\0')
 196                 return NULL;
 197         return dialect;
 198 }
 199
 200 static int ksmbd_lookup_dialect_by_name(char *cli_dialects, __le16 byte_count)
 201 {
 202         int i, seq_num, bcount, next;
 203         char *dialect;
 204
 205         for (i = ARRAY_SIZE(smb1_protos) - 1; i >= 0; i--) {
 206                 seq_num = 0;
 207                 next = 0;
 208                 dialect = cli_dialects;
 209                 bcount = le16_to_cpu(byte_count);
 210                 do {
 211                         dialect = next_dialect(dialect, &next, bcount);
 212                         if (!dialect)
 213                                 break;
 214                         ksmbd_debug(SMB, "client requested dialect %s\n",
 215                                     dialect);
 216                         if (!strcmp(dialect, smb1_protos[i].name)) {
 217                                 if (supported_protocol(smb1_protos[i].index)) {
 218                                         ksmbd_debug(SMB,
 219                                                     "selected %s dialect\n",
 220                                                     smb1_protos[i].name);
 221                                         if (smb1_protos[i].index == SMB1_PROT)
 222                                                 return seq_num;
 223                                         return smb1_protos[i].prot_id;
 224                                 }
 225                         }
 226                         seq_num++;
 227                         bcount -= (++next);
 228                 } while (bcount > 0);
 229         }
 230
 231         return BAD_PROT_ID;
 232 }
 233
 234 int ksmbd_lookup_dialect_by_id(__le16 *cli_dialects, __le16 dialects_count)
 235 {
 236         int i;
 237         int count;
 238
 239         for (i = ARRAY_SIZE(smb2_protos) - 1; i >= 0; i--) {
 240                 count = le16_to_cpu(dialects_count);
 241                 while (--count >= 0) {
 242                         ksmbd_debug(SMB, "client requested dialect 0x%x\n",
 243                                     le16_to_cpu(cli_dialects[count]));
 244                         if (le16_to_cpu(cli_dialects[count]) !=
 245                                         smb2_protos[i].prot_id)
 246                                 continue;
 247
 248                         if (supported_protocol(smb2_protos[i].index)) {
 249                                 ksmbd_debug(SMB, "selected %s dialect\n",
 250                                             smb2_protos[i].name);
 251                                 return smb2_protos[i].prot_id;
 252                         }
 253                 }
 254         }
 255
 256         return BAD_PROT_ID;
 257 }
 258
 259 static int ksmbd_negotiate_smb_dialect(void *buf)
 260 {
 261         int smb_buf_length = get_rfc1002_len(buf);
 262         __le32 proto = ((struct smb2_hdr *)smb2_get_msg(buf))->ProtocolId;
 263
 264         if (proto == SMB2_PROTO_NUMBER) {
 265                 struct smb2_negotiate_req *req;
 266                 int smb2_neg_size =
 267                         offsetof(struct smb2_negotiate_req, Dialects);
 268
 269                 req = (struct smb2_negotiate_req *)smb2_get_msg(buf);
 270                 if (smb2_neg_size > smb_buf_length)
 271                         goto err_out;
 272
 273                 if (struct_size(req, Dialects, le16_to_cpu(req->DialectCount)) >
 274                     smb_buf_length)
 275                         goto err_out;
 276
 277                 return ksmbd_lookup_dialect_by_id(req->Dialects,
 278                                                   req->DialectCount);
 279         }
 280
 281         proto = *(__le32 *)((struct smb_hdr *)buf)->Protocol;
 282         if (proto == SMB1_PROTO_NUMBER) {
 283                 struct smb_negotiate_req *req;
 284
 285                 req = (struct smb_negotiate_req *)buf;
 286                 if (le16_to_cpu(req->ByteCount) < 2)
 287                         goto err_out;
 288
 289                 if (offsetof(struct smb_negotiate_req, DialectsArray) - 4 +
 290                         le16_to_cpu(req->ByteCount) > smb_buf_length) {
 291                         goto err_out;
 292                 }
 293
 294                 return ksmbd_lookup_dialect_by_name(req->DialectsArray,
 295                                                     req->ByteCount);
 296         }
 297
 298 err_out:
 299         return BAD_PROT_ID;
 300 }
 301
 302 #define SMB_COM_NEGOTIATE_EX    0x0
 303
 304 /**
 305  * get_smb1_cmd_val() - get smb command value from smb header
 306  * @work:       smb work containing smb header
 307  *
 308  * Return:      smb command value
 309  */
 310 static u16 get_smb1_cmd_val(struct ksmbd_work *work)
 311 {
 312         return SMB_COM_NEGOTIATE_EX;
 313 }
 314
 315 /**
 316  * init_smb1_rsp_hdr() - initialize smb negotiate response header
 317  * @work:       smb work containing smb request
 318  *
 319  * Return:      0 on success, otherwise -EINVAL
 320  */
 321 static int init_smb1_rsp_hdr(struct ksmbd_work *work)
 322 {
 323         struct smb_hdr *rsp_hdr = (struct smb_hdr *)work->response_buf;
 324         struct smb_hdr *rcv_hdr = (struct smb_hdr *)work->request_buf;
 325
 326         rsp_hdr->Command = SMB_COM_NEGOTIATE;
 327         *(__le32 *)rsp_hdr->Protocol = SMB1_PROTO_NUMBER;
 328         rsp_hdr->Flags = SMBFLG_RESPONSE;
 329         rsp_hdr->Flags2 = SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS |
 330                 SMBFLG2_EXT_SEC | SMBFLG2_IS_LONG_NAME;
 331         rsp_hdr->Pid = rcv_hdr->Pid;
 332         rsp_hdr->Mid = rcv_hdr->Mid;
 333         return 0;
 334 }
 335
 336 /**
 337  * smb1_check_user_session() - check for valid session for a user
 338  * @work:       smb work containing smb request buffer
 339  *
 340  * Return:      0 on success, otherwise error
 341  */
 342 static int smb1_check_user_session(struct ksmbd_work *work)
 343 {
 344         unsigned int cmd = work->conn->ops->get_cmd_val(work);
 345
 346         if (cmd == SMB_COM_NEGOTIATE_EX)
 347                 return 0;
 348
 349         return -EINVAL;
 350 }
 351
 352 /**
 353  * smb1_allocate_rsp_buf() - allocate response buffer for a command
 354  * @work:       smb work containing smb request
 355  *
 356  * Return:      0 on success, otherwise -ENOMEM
 357  */
 358 static int smb1_allocate_rsp_buf(struct ksmbd_work *work)
 359 {
 360         work->response_buf = kzalloc(MAX_CIFS_SMALL_BUFFER_SIZE,
 361                         GFP_KERNEL);
 362         work->response_sz = MAX_CIFS_SMALL_BUFFER_SIZE;
 363
 364         if (!work->response_buf) {
 365                 pr_err("Failed to allocate %u bytes buffer\n",
 366                                 MAX_CIFS_SMALL_BUFFER_SIZE);
 367                 return -ENOMEM;
 368         }
 369
 370         return 0;
 371 }
 372
 373 /**
 374  * set_smb1_rsp_status() - set error type in smb response header
 375  * @work:       smb work containing smb response header
 376  * @err:        error code to set in response
 377  */
 378 static void set_smb1_rsp_status(struct ksmbd_work *work, __le32 err)
 379 {
 380         work->send_no_response = 1;
 381 }
 382
 383 static struct smb_version_ops smb1_server_ops = {
 384         .get_cmd_val = get_smb1_cmd_val,
 385         .init_rsp_hdr = init_smb1_rsp_hdr,
 386         .allocate_rsp_buf = smb1_allocate_rsp_buf,
 387         .check_user_session = smb1_check_user_session,
 388         .set_rsp_status = set_smb1_rsp_status,
 389 };
 390
 391 static int smb1_negotiate(struct ksmbd_work *work)
 392 {
 393         return ksmbd_smb_negotiate_common(work, SMB_COM_NEGOTIATE);
 394 }
 395
 396 static struct smb_version_cmds smb1_server_cmds[1] = {
 397         [SMB_COM_NEGOTIATE_EX]  = { .proc = smb1_negotiate, },
 398 };
 399
 400 static int init_smb1_server(struct ksmbd_conn *conn)
 401 {
 402         conn->ops = &smb1_server_ops;
 403         conn->cmds = smb1_server_cmds;
 404         conn->max_cmds = ARRAY_SIZE(smb1_server_cmds);
 405         return 0;
 406 }
 407
 408 int ksmbd_init_smb_server(struct ksmbd_work *work)
 409 {
 410         struct ksmbd_conn *conn = work->conn;
 411         __le32 proto;
 412
 413         proto = *(__le32 *)((struct smb_hdr *)work->request_buf)->Protocol;
 414         if (conn->need_neg == false) {
 415                 if (proto == SMB1_PROTO_NUMBER)
 416                         return -EINVAL;
 417                 return 0;
 418         }
 419
 420         if (proto == SMB1_PROTO_NUMBER)
 421                 return init_smb1_server(conn);
 422         return init_smb3_11_server(conn);
 423 }
 424
 425 int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
 426                                       struct ksmbd_file *dir,
 427                                       struct ksmbd_dir_info *d_info,
 428                                       char *search_pattern,
 429                                       int (*fn)(struct ksmbd_conn *, int,
 430                                                 struct ksmbd_dir_info *,
 431                                                 struct ksmbd_kstat *))
 432 {
 433         int i, rc = 0;
 434         struct ksmbd_conn *conn = work->conn;
 435         struct mnt_idmap *idmap = file_mnt_idmap(dir->filp);
 436
 437         for (i = 0; i < 2; i++) {
 438                 struct kstat kstat;
 439                 struct ksmbd_kstat ksmbd_kstat;
 440                 struct dentry *dentry;
 441
 442                 if (!dir->dot_dotdot[i]) { /* fill dot entry info */
 443                         if (i == 0) {
 444                                 d_info->name = ".";
 445                                 d_info->name_len = 1;
 446                                 dentry = dir->filp->f_path.dentry;
 447                         } else {
 448                                 d_info->name = "..";
 449                                 d_info->name_len = 2;
 450                                 dentry = dir->filp->f_path.dentry->d_parent;
 451                         }
 452
 453                         if (!match_pattern(d_info->name, d_info->name_len,
 454                                            search_pattern)) {
 455                                 dir->dot_dotdot[i] = 1;
 456                                 continue;
 457                         }
 458
 459                         ksmbd_kstat.kstat = &kstat;
 460                         rc = ksmbd_vfs_fill_dentry_attrs(work,
 461                                                          idmap,
 462                                                          dentry,
 463                                                          &ksmbd_kstat);
 464                         if (rc)
 465                                 break;
 466
 467                         rc = fn(conn, info_level, d_info, &ksmbd_kstat);
 468                         if (rc)
 469                                 break;
 470                         if (d_info->out_buf_len <= 0)
 471                                 break;
 472
 473                         dir->dot_dotdot[i] = 1;
 474                         if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) {
 475                                 d_info->out_buf_len = 0;
 476                                 break;
 477                         }
 478                 }
 479         }
 480
 481         return rc;
 482 }
 483
 484 /**
 485  * ksmbd_extract_shortname() - get shortname from long filename
 486  * @conn:       connection instance
 487  * @longname:   source long filename
 488  * @shortname:  destination short filename
 489  *
 490  * Return:      shortname length or 0 when source long name is '.' or '..'
 491  * TODO: Though this function comforms the restriction of 8.3 Filename spec,
 492  * but the result is different with Windows 7's one. need to check.
 493  */
 494 int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname,
 495                             char *shortname)
 496 {
 497         const char *p;
 498         char base[9], extension[4];
 499         char out[13] = {0};
 500         int baselen = 0;
 501         int extlen = 0, len = 0;
 502         unsigned int csum = 0;
 503         const unsigned char *ptr;
 504         bool dot_present = true;
 505
 506         p = longname;
 507         if ((*p == '.') || (!(strcmp(p, "..")))) {
 508                 /*no mangling required */
 509                 return 0;
 510         }
 511
 512         p = strrchr(longname, '.');
 513         if (p == longname) { /*name starts with a dot*/
 514                 strscpy(extension, "___", strlen("___"));
 515         } else {
 516                 if (p) {
 517                         p++;
 518                         while (*p && extlen < 3) {
 519                                 if (*p != '.')
 520                                         extension[extlen++] = toupper(*p);
 521                                 p++;
 522                         }
 523                         extension[extlen] = '\0';
 524                 } else {
 525                         dot_present = false;
 526                 }
 527         }
 528
 529         p = longname;
 530         if (*p == '.') {
 531                 p++;
 532                 longname++;
 533         }
 534         while (*p && (baselen < 5)) {
 535                 if (*p != '.')
 536                         base[baselen++] = toupper(*p);
 537                 p++;
 538         }
 539
 540         base[baselen] = MAGIC_CHAR;
 541         memcpy(out, base, baselen + 1);
 542
 543         ptr = longname;
 544         len = strlen(longname);
 545         for (; len > 0; len--, ptr++)
 546                 csum += *ptr;
 547
 548         csum = csum % (MANGLE_BASE * MANGLE_BASE);
 549         out[baselen + 1] = mangle(csum / MANGLE_BASE);
 550         out[baselen + 2] = mangle(csum);
 551         out[baselen + 3] = PERIOD;
 552
 553         if (dot_present)
 554                 memcpy(out + baselen + 4, extension, 4);
 555         else
 556                 out[baselen + 4] = '\0';
 557         smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX,
 558                           conn->local_nls, 0);
 559         len = strlen(out) * 2;
 560         return len;
 561 }
 562
 563 static int __smb2_negotiate(struct ksmbd_conn *conn)
 564 {
 565         return (conn->dialect >= SMB20_PROT_ID &&
 566                 conn->dialect <= SMB311_PROT_ID);
 567 }
 568
 569 static int smb_handle_negotiate(struct ksmbd_work *work)
 570 {
 571         struct smb_negotiate_rsp *neg_rsp = work->response_buf;
 572
 573         ksmbd_debug(SMB, "Unsupported SMB1 protocol\n");
 574
 575         if (ksmbd_iov_pin_rsp(work, (void *)neg_rsp,
 576                               sizeof(struct smb_negotiate_rsp) - 4))
 577                 return -ENOMEM;
 578
 579         neg_rsp->hdr.Status.CifsError = STATUS_SUCCESS;
 580         neg_rsp->hdr.WordCount = 1;
 581         neg_rsp->DialectIndex = cpu_to_le16(work->conn->dialect);
 582         neg_rsp->ByteCount = 0;
 583         return 0;
 584 }
 585
 586 int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command)
 587 {
 588         struct ksmbd_conn *conn = work->conn;
 589         int ret;
 590
 591         conn->dialect =
 592                 ksmbd_negotiate_smb_dialect(work->request_buf);
 593         ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect);
 594
 595         if (command == SMB2_NEGOTIATE_HE) {
 596                 ret = smb2_handle_negotiate(work);
 597                 return ret;
 598         }
 599
 600         if (command == SMB_COM_NEGOTIATE) {
 601                 if (__smb2_negotiate(conn)) {
 602                         init_smb3_11_server(conn);
 603                         init_smb2_neg_rsp(work);
 604                         ksmbd_debug(SMB, "Upgrade to SMB2 negotiation\n");
 605                         return 0;
 606                 }
 607                 return smb_handle_negotiate(work);
 608         }
 609
 610         pr_err("Unknown SMB negotiation command: %u\n", command);
 611         return -EINVAL;
 612 }
 613
 614 enum SHARED_MODE_ERRORS {
 615         SHARE_DELETE_ERROR,
 616         SHARE_READ_ERROR,
 617         SHARE_WRITE_ERROR,
 618         FILE_READ_ERROR,
 619         FILE_WRITE_ERROR,
 620         FILE_DELETE_ERROR,
 621 };
 622
 623 static const char * const shared_mode_errors[] = {
 624         "Current access mode does not permit SHARE_DELETE",
 625         "Current access mode does not permit SHARE_READ",
 626         "Current access mode does not permit SHARE_WRITE",
 627         "Desired access mode does not permit FILE_READ",
 628         "Desired access mode does not permit FILE_WRITE",
 629         "Desired access mode does not permit FILE_DELETE",
 630 };
 631
 632 static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp,
 633                                   struct ksmbd_file *curr_fp)
 634 {
 635         ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]);
 636         ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n",
 637                     prev_fp->saccess, curr_fp->daccess);
 638 }
 639
 640 int ksmbd_smb_check_shared_mode(struct file *filp, struct ksmbd_file *curr_fp)
 641 {
 642         int rc = 0;
 643         struct ksmbd_file *prev_fp;
 644
 645         /*
 646          * Lookup fp in master fp list, and check desired access and
 647          * shared mode between previous open and current open.
 648          */
 649         down_read(&curr_fp->f_ci->m_lock);
 650         list_for_each_entry(prev_fp, &curr_fp->f_ci->m_fp_list, node) {
 651                 if (file_inode(filp) != file_inode(prev_fp->filp))
 652                         continue;
 653
 654                 if (filp == prev_fp->filp)
 655                         continue;
 656
 657                 if (ksmbd_stream_fd(prev_fp) && ksmbd_stream_fd(curr_fp))
 658                         if (strcmp(prev_fp->stream.name, curr_fp->stream.name))
 659                                 continue;
 660
 661                 if (prev_fp->attrib_only != curr_fp->attrib_only)
 662                         continue;
 663
 664                 if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) &&
 665                     curr_fp->daccess & FILE_DELETE_LE) {
 666                         smb_shared_mode_error(SHARE_DELETE_ERROR,
 667                                               prev_fp,
 668                                               curr_fp);
 669                         rc = -EPERM;
 670                         break;
 671                 }
 672
 673                 /*
 674                  * Only check FILE_SHARE_DELETE if stream opened and
 675                  * normal file opened.
 676                  */
 677                 if (ksmbd_stream_fd(prev_fp) && !ksmbd_stream_fd(curr_fp))
 678                         continue;
 679
 680                 if (!(prev_fp->saccess & FILE_SHARE_READ_LE) &&
 681                     curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) {
 682                         smb_shared_mode_error(SHARE_READ_ERROR,
 683                                               prev_fp,
 684                                               curr_fp);
 685                         rc = -EPERM;
 686                         break;
 687                 }
 688
 689                 if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) &&
 690                     curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) {
 691                         smb_shared_mode_error(SHARE_WRITE_ERROR,
 692                                               prev_fp,
 693                                               curr_fp);
 694                         rc = -EPERM;
 695                         break;
 696                 }
 697
 698                 if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) &&
 699                     !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
 700                         smb_shared_mode_error(FILE_READ_ERROR,
 701                                               prev_fp,
 702                                               curr_fp);
 703                         rc = -EPERM;
 704                         break;
 705                 }
 706
 707                 if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) &&
 708                     !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
 709                         smb_shared_mode_error(FILE_WRITE_ERROR,
 710                                               prev_fp,
 711                                               curr_fp);
 712                         rc = -EPERM;
 713                         break;
 714                 }
 715
 716                 if (prev_fp->daccess & FILE_DELETE_LE &&
 717                     !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
 718                         smb_shared_mode_error(FILE_DELETE_ERROR,
 719                                               prev_fp,
 720                                               curr_fp);
 721                         rc = -EPERM;
 722                         break;
 723                 }
 724         }
 725         up_read(&curr_fp->f_ci->m_lock);
 726
 727         return rc;
 728 }
 729
 730 bool is_asterisk(char *p)
 731 {
 732         return p && p[0] == '*';
 733 }
 734
 735 int ksmbd_override_fsids(struct ksmbd_work *work)
 736 {
 737         struct ksmbd_session *sess = work->sess;
 738         struct ksmbd_share_config *share = work->tcon->share_conf;
 739         struct cred *cred;
 740         struct group_info *gi;
 741         unsigned int uid;
 742         unsigned int gid;
 743
 744         uid = user_uid(sess->user);
 745         gid = user_gid(sess->user);
 746         if (share->force_uid != KSMBD_SHARE_INVALID_UID)
 747                 uid = share->force_uid;
 748         if (share->force_gid != KSMBD_SHARE_INVALID_GID)
 749                 gid = share->force_gid;
 750
 751         cred = prepare_kernel_cred(&init_task);
 752         if (!cred)
 753                 return -ENOMEM;
 754
 755         cred->fsuid = make_kuid(&init_user_ns, uid);
 756         cred->fsgid = make_kgid(&init_user_ns, gid);
 757
 758         gi = groups_alloc(0);
 759         if (!gi) {
 760                 abort_creds(cred);
 761                 return -ENOMEM;
 762         }
 763         set_groups(cred, gi);
 764         put_group_info(gi);
 765
 766         if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID))
 767                 cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
 768
 769         WARN_ON(work->saved_cred);
 770         work->saved_cred = override_creds(cred);
 771         if (!work->saved_cred) {
 772                 abort_creds(cred);
 773                 return -EINVAL;
 774         }
 775         return 0;
 776 }
 777
 778 void ksmbd_revert_fsids(struct ksmbd_work *work)
 779 {
 780         const struct cred *cred;
 781
 782         WARN_ON(!work->saved_cred);
 783
 784         cred = current_cred();
 785         revert_creds(work->saved_cred);
 786         put_cred(cred);
 787         work->saved_cred = NULL;
 788 }
 789
 790 __le32 smb_map_generic_desired_access(__le32 daccess)
 791 {
 792         if (daccess & FILE_GENERIC_READ_LE) {
 793                 daccess |= cpu_to_le32(GENERIC_READ_FLAGS);
 794                 daccess &= ~FILE_GENERIC_READ_LE;
 795         }
 796
 797         if (daccess & FILE_GENERIC_WRITE_LE) {
 798                 daccess |= cpu_to_le32(GENERIC_WRITE_FLAGS);
 799                 daccess &= ~FILE_GENERIC_WRITE_LE;
 800         }
 801
 802         if (daccess & FILE_GENERIC_EXECUTE_LE) {
 803                 daccess |= cpu_to_le32(GENERIC_EXECUTE_FLAGS);
 804                 daccess &= ~FILE_GENERIC_EXECUTE_LE;
 805         }
 806
 807         if (daccess & FILE_GENERIC_ALL_LE) {
 808                 daccess |= cpu_to_le32(GENERIC_ALL_FLAGS);
 809                 daccess &= ~FILE_GENERIC_ALL_LE;
 810         }
 811
 812         return daccess;
 813 }