1 // SPDX-License-Identifier: LGPL-2.1 2 /* 3 * 4 * Copyright (C) International Business Machines Corp., 2002,2010 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * 7 * Contains the routines for constructing the SMB PDUs themselves 8 * 9 */ 10 11 /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c */ 12 /* These are mostly routines that operate on a pathname, or on a tree id */ 13 /* (mounted volume), but there are eight handle based routines which must be */ 14 /* treated slightly differently for reconnection purposes since we never */ 15 /* want to reuse a stale file handle and only the caller knows the file info */ 16 17 #include <linux/fs.h> 18 #include <linux/filelock.h> 19 #include <linux/kernel.h> 20 #include <linux/vfs.h> 21 #include <linux/slab.h> 22 #include <linux/posix_acl_xattr.h> 23 #include <linux/pagemap.h> 24 #include <linux/swap.h> 25 #include <linux/task_io_accounting_ops.h> 26 #include <linux/uaccess.h> 27 #include "cifspdu.h" 28 #include "cifsfs.h" 29 #include "cifsglob.h" 30 #include "cifsacl.h" 31 #include "cifsproto.h" 32 #include "cifs_unicode.h" 33 #include "cifs_debug.h" 34 #include "fscache.h" 35 #include "smbdirect.h" 36 #ifdef CONFIG_CIFS_DFS_UPCALL 37 #include "dfs_cache.h" 38 #endif 39 40 #ifdef CONFIG_CIFS_POSIX 41 static struct { 42 int index; 43 char *name; 44 } protocols[] = { 45 {CIFS_PROT, "\2NT LM 0.12"}, 46 {POSIX_PROT, "\2POSIX 2"}, 47 {BAD_PROT, "\2"} 48 }; 49 #else 50 static struct { 51 int index; 52 char *name; 53 } protocols[] = { 54 {CIFS_PROT, "\2NT LM 0.12"}, 55 {BAD_PROT, "\2"} 56 }; 57 #endif 58 59 /* define the number of elements in the cifs dialect array */ 60 #ifdef CONFIG_CIFS_POSIX 61 #define CIFS_NUM_PROT 2 62 #else /* not posix */ 63 #define CIFS_NUM_PROT 1 64 #endif /* CIFS_POSIX */ 65 66 67 /* reconnect the socket, tcon, and smb session if needed */ 68 static int 69 cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command) 70 { 71 int rc; 72 struct cifs_ses *ses; 73 struct TCP_Server_Info *server; 74 struct nls_table *nls_codepage = NULL; 75 76 /* 77 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for 78 * tcp and smb session status done differently for those three - in the 79 * calling routine 80 */ 81 if (!tcon) 82 return 0; 83 84 ses = tcon->ses; 85 server = ses->server; 86 87 /* 88 * only tree disconnect, open, and write, (and ulogoff which does not 89 * have tcon) are allowed as we start umount 90 */ 91 spin_lock(&tcon->tc_lock); 92 if (tcon->status == TID_EXITING) { 93 if (smb_command != SMB_COM_TREE_DISCONNECT) { 94 spin_unlock(&tcon->tc_lock); 95 cifs_dbg(FYI, "can not send cmd %d while umounting\n", 96 smb_command); 97 return -ENODEV; 98 } 99 } 100 spin_unlock(&tcon->tc_lock); 101 102 again: 103 rc = cifs_wait_for_server_reconnect(server, tcon->retry); 104 if (rc) 105 return rc; 106 107 spin_lock(&ses->chan_lock); 108 if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) { 109 spin_unlock(&ses->chan_lock); 110 return 0; 111 } 112 spin_unlock(&ses->chan_lock); 113 114 mutex_lock(&ses->session_mutex); 115 /* 116 * Recheck after acquire mutex. If another thread is negotiating 117 * and the server never sends an answer the socket will be closed 118 * and tcpStatus set to reconnect. 119 */ 120 spin_lock(&server->srv_lock); 121 if (server->tcpStatus == CifsNeedReconnect) { 122 spin_unlock(&server->srv_lock); 123 mutex_unlock(&ses->session_mutex); 124 125 if (tcon->retry) 126 goto again; 127 rc = -EHOSTDOWN; 128 goto out; 129 } 130 spin_unlock(&server->srv_lock); 131 132 nls_codepage = ses->local_nls; 133 134 /* 135 * need to prevent multiple threads trying to simultaneously 136 * reconnect the same SMB session 137 */ 138 spin_lock(&ses->ses_lock); 139 spin_lock(&ses->chan_lock); 140 if (!cifs_chan_needs_reconnect(ses, server) && 141 ses->ses_status == SES_GOOD) { 142 spin_unlock(&ses->chan_lock); 143 spin_unlock(&ses->ses_lock); 144 145 /* this means that we only need to tree connect */ 146 if (tcon->need_reconnect) 147 goto skip_sess_setup; 148 149 mutex_unlock(&ses->session_mutex); 150 goto out; 151 } 152 spin_unlock(&ses->chan_lock); 153 spin_unlock(&ses->ses_lock); 154 155 rc = cifs_negotiate_protocol(0, ses, server); 156 if (!rc) 157 rc = cifs_setup_session(0, ses, server, nls_codepage); 158 159 /* do we need to reconnect tcon? */ 160 if (rc || !tcon->need_reconnect) { 161 mutex_unlock(&ses->session_mutex); 162 goto out; 163 } 164 165 skip_sess_setup: 166 cifs_mark_open_files_invalid(tcon); 167 rc = cifs_tree_connect(0, tcon, nls_codepage); 168 mutex_unlock(&ses->session_mutex); 169 cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc); 170 171 if (rc) { 172 pr_warn_once("reconnect tcon failed rc = %d\n", rc); 173 goto out; 174 } 175 176 atomic_inc(&tconInfoReconnectCount); 177 178 /* tell server Unix caps we support */ 179 if (cap_unix(ses)) 180 reset_cifs_unix_caps(0, tcon, NULL, NULL); 181 182 /* 183 * Removed call to reopen open files here. It is safer (and faster) to 184 * reopen files one at a time as needed in read and write. 185 * 186 * FIXME: what about file locks? don't we need to reclaim them ASAP? 187 */ 188 189 out: 190 /* 191 * Check if handle based operation so we know whether we can continue 192 * or not without returning to caller to reset file handle 193 */ 194 switch (smb_command) { 195 case SMB_COM_READ_ANDX: 196 case SMB_COM_WRITE_ANDX: 197 case SMB_COM_CLOSE: 198 case SMB_COM_FIND_CLOSE2: 199 case SMB_COM_LOCKING_ANDX: 200 rc = -EAGAIN; 201 } 202 203 return rc; 204 } 205 206 /* Allocate and return pointer to an SMB request buffer, and set basic 207 SMB information in the SMB header. If the return code is zero, this 208 function must have filled in request_buf pointer */ 209 static int 210 small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon, 211 void **request_buf) 212 { 213 int rc; 214 215 rc = cifs_reconnect_tcon(tcon, smb_command); 216 if (rc) 217 return rc; 218 219 *request_buf = cifs_small_buf_get(); 220 if (*request_buf == NULL) { 221 /* BB should we add a retry in here if not a writepage? */ 222 return -ENOMEM; 223 } 224 225 header_assemble((struct smb_hdr *) *request_buf, smb_command, 226 tcon, wct); 227 228 if (tcon != NULL) 229 cifs_stats_inc(&tcon->num_smbs_sent); 230 231 return 0; 232 } 233 234 int 235 small_smb_init_no_tc(const int smb_command, const int wct, 236 struct cifs_ses *ses, void **request_buf) 237 { 238 int rc; 239 struct smb_hdr *buffer; 240 241 rc = small_smb_init(smb_command, wct, NULL, request_buf); 242 if (rc) 243 return rc; 244 245 buffer = (struct smb_hdr *)*request_buf; 246 buffer->Mid = get_next_mid(ses->server); 247 if (ses->capabilities & CAP_UNICODE) 248 buffer->Flags2 |= SMBFLG2_UNICODE; 249 if (ses->capabilities & CAP_STATUS32) 250 buffer->Flags2 |= SMBFLG2_ERR_STATUS; 251 252 /* uid, tid can stay at zero as set in header assemble */ 253 254 /* BB add support for turning on the signing when 255 this function is used after 1st of session setup requests */ 256 257 return rc; 258 } 259 260 /* If the return code is zero, this function must fill in request_buf pointer */ 261 static int 262 __smb_init(int smb_command, int wct, struct cifs_tcon *tcon, 263 void **request_buf, void **response_buf) 264 { 265 *request_buf = cifs_buf_get(); 266 if (*request_buf == NULL) { 267 /* BB should we add a retry in here if not a writepage? */ 268 return -ENOMEM; 269 } 270 /* Although the original thought was we needed the response buf for */ 271 /* potential retries of smb operations it turns out we can determine */ 272 /* from the mid flags when the request buffer can be resent without */ 273 /* having to use a second distinct buffer for the response */ 274 if (response_buf) 275 *response_buf = *request_buf; 276 277 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon, 278 wct); 279 280 if (tcon != NULL) 281 cifs_stats_inc(&tcon->num_smbs_sent); 282 283 return 0; 284 } 285 286 /* If the return code is zero, this function must fill in request_buf pointer */ 287 static int 288 smb_init(int smb_command, int wct, struct cifs_tcon *tcon, 289 void **request_buf, void **response_buf) 290 { 291 int rc; 292 293 rc = cifs_reconnect_tcon(tcon, smb_command); 294 if (rc) 295 return rc; 296 297 return __smb_init(smb_command, wct, tcon, request_buf, response_buf); 298 } 299 300 static int 301 smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon, 302 void **request_buf, void **response_buf) 303 { 304 spin_lock(&tcon->ses->chan_lock); 305 if (cifs_chan_needs_reconnect(tcon->ses, tcon->ses->server) || 306 tcon->need_reconnect) { 307 spin_unlock(&tcon->ses->chan_lock); 308 return -EHOSTDOWN; 309 } 310 spin_unlock(&tcon->ses->chan_lock); 311 312 return __smb_init(smb_command, wct, tcon, request_buf, response_buf); 313 } 314 315 static int validate_t2(struct smb_t2_rsp *pSMB) 316 { 317 unsigned int total_size; 318 319 /* check for plausible wct */ 320 if (pSMB->hdr.WordCount < 10) 321 goto vt2_err; 322 323 /* check for parm and data offset going beyond end of smb */ 324 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 || 325 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024) 326 goto vt2_err; 327 328 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount); 329 if (total_size >= 512) 330 goto vt2_err; 331 332 /* check that bcc is at least as big as parms + data, and that it is 333 * less than negotiated smb buffer 334 */ 335 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount); 336 if (total_size > get_bcc(&pSMB->hdr) || 337 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) 338 goto vt2_err; 339 340 return 0; 341 vt2_err: 342 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB, 343 sizeof(struct smb_t2_rsp) + 16); 344 return -EINVAL; 345 } 346 347 static int 348 decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr) 349 { 350 int rc = 0; 351 u16 count; 352 char *guid = pSMBr->u.extended_response.GUID; 353 struct TCP_Server_Info *server = ses->server; 354 355 count = get_bcc(&pSMBr->hdr); 356 if (count < SMB1_CLIENT_GUID_SIZE) 357 return -EIO; 358 359 spin_lock(&cifs_tcp_ses_lock); 360 if (server->srv_count > 1) { 361 spin_unlock(&cifs_tcp_ses_lock); 362 if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) { 363 cifs_dbg(FYI, "server UID changed\n"); 364 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE); 365 } 366 } else { 367 spin_unlock(&cifs_tcp_ses_lock); 368 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE); 369 } 370 371 if (count == SMB1_CLIENT_GUID_SIZE) { 372 server->sec_ntlmssp = true; 373 } else { 374 count -= SMB1_CLIENT_GUID_SIZE; 375 rc = decode_negTokenInit( 376 pSMBr->u.extended_response.SecurityBlob, count, server); 377 if (rc != 1) 378 return -EINVAL; 379 } 380 381 return 0; 382 } 383 384 static bool 385 should_set_ext_sec_flag(enum securityEnum sectype) 386 { 387 switch (sectype) { 388 case RawNTLMSSP: 389 case Kerberos: 390 return true; 391 case Unspecified: 392 if (global_secflags & 393 (CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)) 394 return true; 395 fallthrough; 396 default: 397 return false; 398 } 399 } 400 401 int 402 CIFSSMBNegotiate(const unsigned int xid, 403 struct cifs_ses *ses, 404 struct TCP_Server_Info *server) 405 { 406 NEGOTIATE_REQ *pSMB; 407 NEGOTIATE_RSP *pSMBr; 408 int rc = 0; 409 int bytes_returned; 410 int i; 411 u16 count; 412 413 if (!server) { 414 WARN(1, "%s: server is NULL!\n", __func__); 415 return -EIO; 416 } 417 418 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ , 419 (void **) &pSMB, (void **) &pSMBr); 420 if (rc) 421 return rc; 422 423 pSMB->hdr.Mid = get_next_mid(server); 424 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS); 425 426 if (should_set_ext_sec_flag(ses->sectype)) { 427 cifs_dbg(FYI, "Requesting extended security\n"); 428 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC; 429 } 430 431 count = 0; 432 /* 433 * We know that all the name entries in the protocols array 434 * are short (< 16 bytes anyway) and are NUL terminated. 435 */ 436 for (i = 0; i < CIFS_NUM_PROT; i++) { 437 size_t len = strlen(protocols[i].name) + 1; 438 439 memcpy(&pSMB->DialectsArray[count], protocols[i].name, len); 440 count += len; 441 } 442 inc_rfc1001_len(pSMB, count); 443 pSMB->ByteCount = cpu_to_le16(count); 444 445 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB, 446 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 447 if (rc != 0) 448 goto neg_err_exit; 449 450 server->dialect = le16_to_cpu(pSMBr->DialectIndex); 451 cifs_dbg(FYI, "Dialect: %d\n", server->dialect); 452 /* Check wct = 1 error case */ 453 if ((pSMBr->hdr.WordCount <= 13) || (server->dialect == BAD_PROT)) { 454 /* core returns wct = 1, but we do not ask for core - otherwise 455 small wct just comes when dialect index is -1 indicating we 456 could not negotiate a common dialect */ 457 rc = -EOPNOTSUPP; 458 goto neg_err_exit; 459 } else if (pSMBr->hdr.WordCount != 17) { 460 /* unknown wct */ 461 rc = -EOPNOTSUPP; 462 goto neg_err_exit; 463 } 464 /* else wct == 17, NTLM or better */ 465 466 server->sec_mode = pSMBr->SecurityMode; 467 if ((server->sec_mode & SECMODE_USER) == 0) 468 cifs_dbg(FYI, "share mode security\n"); 469 470 /* one byte, so no need to convert this or EncryptionKeyLen from 471 little endian */ 472 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount), 473 cifs_max_pending); 474 set_credits(server, server->maxReq); 475 /* probably no need to store and check maxvcs */ 476 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize); 477 /* set up max_read for readahead check */ 478 server->max_read = server->maxBuf; 479 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize); 480 cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf); 481 server->capabilities = le32_to_cpu(pSMBr->Capabilities); 482 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone); 483 server->timeAdj *= 60; 484 485 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) { 486 server->negflavor = CIFS_NEGFLAVOR_UNENCAP; 487 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey, 488 CIFS_CRYPTO_KEY_SIZE); 489 } else if (pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC || 490 server->capabilities & CAP_EXTENDED_SECURITY) { 491 server->negflavor = CIFS_NEGFLAVOR_EXTENDED; 492 rc = decode_ext_sec_blob(ses, pSMBr); 493 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) { 494 rc = -EIO; /* no crypt key only if plain text pwd */ 495 } else { 496 server->negflavor = CIFS_NEGFLAVOR_UNENCAP; 497 server->capabilities &= ~CAP_EXTENDED_SECURITY; 498 } 499 500 if (!rc) 501 rc = cifs_enable_signing(server, ses->sign); 502 neg_err_exit: 503 cifs_buf_release(pSMB); 504 505 cifs_dbg(FYI, "negprot rc %d\n", rc); 506 return rc; 507 } 508 509 int 510 CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon) 511 { 512 struct smb_hdr *smb_buffer; 513 int rc = 0; 514 515 cifs_dbg(FYI, "In tree disconnect\n"); 516 517 /* BB: do we need to check this? These should never be NULL. */ 518 if ((tcon->ses == NULL) || (tcon->ses->server == NULL)) 519 return -EIO; 520 521 /* 522 * No need to return error on this operation if tid invalidated and 523 * closed on server already e.g. due to tcp session crashing. Also, 524 * the tcon is no longer on the list, so no need to take lock before 525 * checking this. 526 */ 527 spin_lock(&tcon->ses->chan_lock); 528 if ((tcon->need_reconnect) || CIFS_ALL_CHANS_NEED_RECONNECT(tcon->ses)) { 529 spin_unlock(&tcon->ses->chan_lock); 530 return -EIO; 531 } 532 spin_unlock(&tcon->ses->chan_lock); 533 534 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon, 535 (void **)&smb_buffer); 536 if (rc) 537 return rc; 538 539 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0); 540 cifs_small_buf_release(smb_buffer); 541 if (rc) 542 cifs_dbg(FYI, "Tree disconnect failed %d\n", rc); 543 544 /* No need to return error on this operation if tid invalidated and 545 closed on server already e.g. due to tcp session crashing */ 546 if (rc == -EAGAIN) 547 rc = 0; 548 549 return rc; 550 } 551 552 /* 553 * This is a no-op for now. We're not really interested in the reply, but 554 * rather in the fact that the server sent one and that server->lstrp 555 * gets updated. 556 * 557 * FIXME: maybe we should consider checking that the reply matches request? 558 */ 559 static void 560 cifs_echo_callback(struct mid_q_entry *mid) 561 { 562 struct TCP_Server_Info *server = mid->callback_data; 563 struct cifs_credits credits = { .value = 1, .instance = 0 }; 564 565 release_mid(mid); 566 add_credits(server, &credits, CIFS_ECHO_OP); 567 } 568 569 int 570 CIFSSMBEcho(struct TCP_Server_Info *server) 571 { 572 ECHO_REQ *smb; 573 int rc = 0; 574 struct kvec iov[2]; 575 struct smb_rqst rqst = { .rq_iov = iov, 576 .rq_nvec = 2 }; 577 578 cifs_dbg(FYI, "In echo request\n"); 579 580 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb); 581 if (rc) 582 return rc; 583 584 if (server->capabilities & CAP_UNICODE) 585 smb->hdr.Flags2 |= SMBFLG2_UNICODE; 586 587 /* set up echo request */ 588 smb->hdr.Tid = 0xffff; 589 smb->hdr.WordCount = 1; 590 put_unaligned_le16(1, &smb->EchoCount); 591 put_bcc(1, &smb->hdr); 592 smb->Data[0] = 'a'; 593 inc_rfc1001_len(smb, 3); 594 595 iov[0].iov_len = 4; 596 iov[0].iov_base = smb; 597 iov[1].iov_len = get_rfc1002_length(smb); 598 iov[1].iov_base = (char *)smb + 4; 599 600 rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback, NULL, 601 server, CIFS_NON_BLOCKING | CIFS_ECHO_OP, NULL); 602 if (rc) 603 cifs_dbg(FYI, "Echo request failed: %d\n", rc); 604 605 cifs_small_buf_release(smb); 606 607 return rc; 608 } 609 610 int 611 CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses) 612 { 613 LOGOFF_ANDX_REQ *pSMB; 614 int rc = 0; 615 616 cifs_dbg(FYI, "In SMBLogoff for session disconnect\n"); 617 618 /* 619 * BB: do we need to check validity of ses and server? They should 620 * always be valid since we have an active reference. If not, that 621 * should probably be a BUG() 622 */ 623 if (!ses || !ses->server) 624 return -EIO; 625 626 mutex_lock(&ses->session_mutex); 627 spin_lock(&ses->chan_lock); 628 if (CIFS_ALL_CHANS_NEED_RECONNECT(ses)) { 629 spin_unlock(&ses->chan_lock); 630 goto session_already_dead; /* no need to send SMBlogoff if uid 631 already closed due to reconnect */ 632 } 633 spin_unlock(&ses->chan_lock); 634 635 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB); 636 if (rc) { 637 mutex_unlock(&ses->session_mutex); 638 return rc; 639 } 640 641 pSMB->hdr.Mid = get_next_mid(ses->server); 642 643 if (ses->server->sign) 644 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE; 645 646 pSMB->hdr.Uid = ses->Suid; 647 648 pSMB->AndXCommand = 0xFF; 649 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0); 650 cifs_small_buf_release(pSMB); 651 session_already_dead: 652 mutex_unlock(&ses->session_mutex); 653 654 /* if session dead then we do not need to do ulogoff, 655 since server closed smb session, no sense reporting 656 error */ 657 if (rc == -EAGAIN) 658 rc = 0; 659 return rc; 660 } 661 662 int 663 CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon, 664 const char *fileName, __u16 type, 665 const struct nls_table *nls_codepage, int remap) 666 { 667 TRANSACTION2_SPI_REQ *pSMB = NULL; 668 TRANSACTION2_SPI_RSP *pSMBr = NULL; 669 struct unlink_psx_rq *pRqD; 670 int name_len; 671 int rc = 0; 672 int bytes_returned = 0; 673 __u16 params, param_offset, offset, byte_count; 674 675 cifs_dbg(FYI, "In POSIX delete\n"); 676 PsxDelete: 677 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 678 (void **) &pSMBr); 679 if (rc) 680 return rc; 681 682 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 683 name_len = 684 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 685 PATH_MAX, nls_codepage, remap); 686 name_len++; /* trailing null */ 687 name_len *= 2; 688 } else { 689 name_len = copy_path_name(pSMB->FileName, fileName); 690 } 691 692 params = 6 + name_len; 693 pSMB->MaxParameterCount = cpu_to_le16(2); 694 pSMB->MaxDataCount = 0; /* BB double check this with jra */ 695 pSMB->MaxSetupCount = 0; 696 pSMB->Reserved = 0; 697 pSMB->Flags = 0; 698 pSMB->Timeout = 0; 699 pSMB->Reserved2 = 0; 700 param_offset = offsetof(struct smb_com_transaction2_spi_req, 701 InformationLevel) - 4; 702 offset = param_offset + params; 703 704 /* Setup pointer to Request Data (inode type). 705 * Note that SMB offsets are from the beginning of SMB which is 4 bytes 706 * in, after RFC1001 field 707 */ 708 pRqD = (struct unlink_psx_rq *)((char *)(pSMB) + offset + 4); 709 pRqD->type = cpu_to_le16(type); 710 pSMB->ParameterOffset = cpu_to_le16(param_offset); 711 pSMB->DataOffset = cpu_to_le16(offset); 712 pSMB->SetupCount = 1; 713 pSMB->Reserved3 = 0; 714 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 715 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq); 716 717 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq)); 718 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq)); 719 pSMB->ParameterCount = cpu_to_le16(params); 720 pSMB->TotalParameterCount = pSMB->ParameterCount; 721 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK); 722 pSMB->Reserved4 = 0; 723 inc_rfc1001_len(pSMB, byte_count); 724 pSMB->ByteCount = cpu_to_le16(byte_count); 725 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 726 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 727 if (rc) 728 cifs_dbg(FYI, "Posix delete returned %d\n", rc); 729 cifs_buf_release(pSMB); 730 731 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes); 732 733 if (rc == -EAGAIN) 734 goto PsxDelete; 735 736 return rc; 737 } 738 739 int 740 CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name, 741 struct cifs_sb_info *cifs_sb) 742 { 743 DELETE_FILE_REQ *pSMB = NULL; 744 DELETE_FILE_RSP *pSMBr = NULL; 745 int rc = 0; 746 int bytes_returned; 747 int name_len; 748 int remap = cifs_remap(cifs_sb); 749 750 DelFileRetry: 751 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB, 752 (void **) &pSMBr); 753 if (rc) 754 return rc; 755 756 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 757 name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name, 758 PATH_MAX, cifs_sb->local_nls, 759 remap); 760 name_len++; /* trailing null */ 761 name_len *= 2; 762 } else { 763 name_len = copy_path_name(pSMB->fileName, name); 764 } 765 pSMB->SearchAttributes = 766 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM); 767 pSMB->BufferFormat = 0x04; 768 inc_rfc1001_len(pSMB, name_len + 1); 769 pSMB->ByteCount = cpu_to_le16(name_len + 1); 770 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 771 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 772 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes); 773 if (rc) 774 cifs_dbg(FYI, "Error in RMFile = %d\n", rc); 775 776 cifs_buf_release(pSMB); 777 if (rc == -EAGAIN) 778 goto DelFileRetry; 779 780 return rc; 781 } 782 783 int 784 CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name, 785 struct cifs_sb_info *cifs_sb) 786 { 787 DELETE_DIRECTORY_REQ *pSMB = NULL; 788 DELETE_DIRECTORY_RSP *pSMBr = NULL; 789 int rc = 0; 790 int bytes_returned; 791 int name_len; 792 int remap = cifs_remap(cifs_sb); 793 794 cifs_dbg(FYI, "In CIFSSMBRmDir\n"); 795 RmDirRetry: 796 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB, 797 (void **) &pSMBr); 798 if (rc) 799 return rc; 800 801 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 802 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name, 803 PATH_MAX, cifs_sb->local_nls, 804 remap); 805 name_len++; /* trailing null */ 806 name_len *= 2; 807 } else { 808 name_len = copy_path_name(pSMB->DirName, name); 809 } 810 811 pSMB->BufferFormat = 0x04; 812 inc_rfc1001_len(pSMB, name_len + 1); 813 pSMB->ByteCount = cpu_to_le16(name_len + 1); 814 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 815 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 816 cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs); 817 if (rc) 818 cifs_dbg(FYI, "Error in RMDir = %d\n", rc); 819 820 cifs_buf_release(pSMB); 821 if (rc == -EAGAIN) 822 goto RmDirRetry; 823 return rc; 824 } 825 826 int 827 CIFSSMBMkDir(const unsigned int xid, struct inode *inode, umode_t mode, 828 struct cifs_tcon *tcon, const char *name, 829 struct cifs_sb_info *cifs_sb) 830 { 831 int rc = 0; 832 CREATE_DIRECTORY_REQ *pSMB = NULL; 833 CREATE_DIRECTORY_RSP *pSMBr = NULL; 834 int bytes_returned; 835 int name_len; 836 int remap = cifs_remap(cifs_sb); 837 838 cifs_dbg(FYI, "In CIFSSMBMkDir\n"); 839 MkDirRetry: 840 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB, 841 (void **) &pSMBr); 842 if (rc) 843 return rc; 844 845 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 846 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name, 847 PATH_MAX, cifs_sb->local_nls, 848 remap); 849 name_len++; /* trailing null */ 850 name_len *= 2; 851 } else { 852 name_len = copy_path_name(pSMB->DirName, name); 853 } 854 855 pSMB->BufferFormat = 0x04; 856 inc_rfc1001_len(pSMB, name_len + 1); 857 pSMB->ByteCount = cpu_to_le16(name_len + 1); 858 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 859 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 860 cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs); 861 if (rc) 862 cifs_dbg(FYI, "Error in Mkdir = %d\n", rc); 863 864 cifs_buf_release(pSMB); 865 if (rc == -EAGAIN) 866 goto MkDirRetry; 867 return rc; 868 } 869 870 int 871 CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon, 872 __u32 posix_flags, __u64 mode, __u16 *netfid, 873 FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock, 874 const char *name, const struct nls_table *nls_codepage, 875 int remap) 876 { 877 TRANSACTION2_SPI_REQ *pSMB = NULL; 878 TRANSACTION2_SPI_RSP *pSMBr = NULL; 879 int name_len; 880 int rc = 0; 881 int bytes_returned = 0; 882 __u16 params, param_offset, offset, byte_count, count; 883 OPEN_PSX_REQ *pdata; 884 OPEN_PSX_RSP *psx_rsp; 885 886 cifs_dbg(FYI, "In POSIX Create\n"); 887 PsxCreat: 888 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 889 (void **) &pSMBr); 890 if (rc) 891 return rc; 892 893 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 894 name_len = 895 cifsConvertToUTF16((__le16 *) pSMB->FileName, name, 896 PATH_MAX, nls_codepage, remap); 897 name_len++; /* trailing null */ 898 name_len *= 2; 899 } else { 900 name_len = copy_path_name(pSMB->FileName, name); 901 } 902 903 params = 6 + name_len; 904 count = sizeof(OPEN_PSX_REQ); 905 pSMB->MaxParameterCount = cpu_to_le16(2); 906 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */ 907 pSMB->MaxSetupCount = 0; 908 pSMB->Reserved = 0; 909 pSMB->Flags = 0; 910 pSMB->Timeout = 0; 911 pSMB->Reserved2 = 0; 912 param_offset = offsetof(struct smb_com_transaction2_spi_req, 913 InformationLevel) - 4; 914 offset = param_offset + params; 915 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 916 pdata = (OPEN_PSX_REQ *)((char *)(pSMB) + offset + 4); 917 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC); 918 pdata->Permissions = cpu_to_le64(mode); 919 pdata->PosixOpenFlags = cpu_to_le32(posix_flags); 920 pdata->OpenFlags = cpu_to_le32(*pOplock); 921 pSMB->ParameterOffset = cpu_to_le16(param_offset); 922 pSMB->DataOffset = cpu_to_le16(offset); 923 pSMB->SetupCount = 1; 924 pSMB->Reserved3 = 0; 925 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 926 byte_count = 3 /* pad */ + params + count; 927 928 pSMB->DataCount = cpu_to_le16(count); 929 pSMB->ParameterCount = cpu_to_le16(params); 930 pSMB->TotalDataCount = pSMB->DataCount; 931 pSMB->TotalParameterCount = pSMB->ParameterCount; 932 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN); 933 pSMB->Reserved4 = 0; 934 inc_rfc1001_len(pSMB, byte_count); 935 pSMB->ByteCount = cpu_to_le16(byte_count); 936 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 937 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 938 if (rc) { 939 cifs_dbg(FYI, "Posix create returned %d\n", rc); 940 goto psx_create_err; 941 } 942 943 cifs_dbg(FYI, "copying inode info\n"); 944 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 945 946 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) { 947 rc = -EIO; /* bad smb */ 948 goto psx_create_err; 949 } 950 951 /* copy return information to pRetData */ 952 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol 953 + le16_to_cpu(pSMBr->t2.DataOffset)); 954 955 *pOplock = le16_to_cpu(psx_rsp->OplockFlags); 956 if (netfid) 957 *netfid = psx_rsp->Fid; /* cifs fid stays in le */ 958 /* Let caller know file was created so we can set the mode. */ 959 /* Do we care about the CreateAction in any other cases? */ 960 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction) 961 *pOplock |= CIFS_CREATE_ACTION; 962 /* check to make sure response data is there */ 963 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) { 964 pRetData->Type = cpu_to_le32(-1); /* unknown */ 965 cifs_dbg(NOISY, "unknown type\n"); 966 } else { 967 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP) 968 + sizeof(FILE_UNIX_BASIC_INFO)) { 969 cifs_dbg(VFS, "Open response data too small\n"); 970 pRetData->Type = cpu_to_le32(-1); 971 goto psx_create_err; 972 } 973 memcpy((char *) pRetData, 974 (char *)psx_rsp + sizeof(OPEN_PSX_RSP), 975 sizeof(FILE_UNIX_BASIC_INFO)); 976 } 977 978 psx_create_err: 979 cifs_buf_release(pSMB); 980 981 if (posix_flags & SMB_O_DIRECTORY) 982 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs); 983 else 984 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens); 985 986 if (rc == -EAGAIN) 987 goto PsxCreat; 988 989 return rc; 990 } 991 992 static __u16 convert_disposition(int disposition) 993 { 994 __u16 ofun = 0; 995 996 switch (disposition) { 997 case FILE_SUPERSEDE: 998 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC; 999 break; 1000 case FILE_OPEN: 1001 ofun = SMBOPEN_OAPPEND; 1002 break; 1003 case FILE_CREATE: 1004 ofun = SMBOPEN_OCREATE; 1005 break; 1006 case FILE_OPEN_IF: 1007 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND; 1008 break; 1009 case FILE_OVERWRITE: 1010 ofun = SMBOPEN_OTRUNC; 1011 break; 1012 case FILE_OVERWRITE_IF: 1013 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC; 1014 break; 1015 default: 1016 cifs_dbg(FYI, "unknown disposition %d\n", disposition); 1017 ofun = SMBOPEN_OAPPEND; /* regular open */ 1018 } 1019 return ofun; 1020 } 1021 1022 static int 1023 access_flags_to_smbopen_mode(const int access_flags) 1024 { 1025 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE); 1026 1027 if (masked_flags == GENERIC_READ) 1028 return SMBOPEN_READ; 1029 else if (masked_flags == GENERIC_WRITE) 1030 return SMBOPEN_WRITE; 1031 1032 /* just go for read/write */ 1033 return SMBOPEN_READWRITE; 1034 } 1035 1036 int 1037 SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon, 1038 const char *fileName, const int openDisposition, 1039 const int access_flags, const int create_options, __u16 *netfid, 1040 int *pOplock, FILE_ALL_INFO *pfile_info, 1041 const struct nls_table *nls_codepage, int remap) 1042 { 1043 int rc; 1044 OPENX_REQ *pSMB = NULL; 1045 OPENX_RSP *pSMBr = NULL; 1046 int bytes_returned; 1047 int name_len; 1048 __u16 count; 1049 1050 OldOpenRetry: 1051 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB, 1052 (void **) &pSMBr); 1053 if (rc) 1054 return rc; 1055 1056 pSMB->AndXCommand = 0xFF; /* none */ 1057 1058 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 1059 count = 1; /* account for one byte pad to word boundary */ 1060 name_len = 1061 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1), 1062 fileName, PATH_MAX, nls_codepage, remap); 1063 name_len++; /* trailing null */ 1064 name_len *= 2; 1065 } else { 1066 count = 0; /* no pad */ 1067 name_len = copy_path_name(pSMB->fileName, fileName); 1068 } 1069 if (*pOplock & REQ_OPLOCK) 1070 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK); 1071 else if (*pOplock & REQ_BATCHOPLOCK) 1072 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK); 1073 1074 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO); 1075 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags)); 1076 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */ 1077 /* set file as system file if special file such 1078 as fifo and server expecting SFU style and 1079 no Unix extensions */ 1080 1081 if (create_options & CREATE_OPTION_SPECIAL) 1082 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM); 1083 else /* BB FIXME BB */ 1084 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/); 1085 1086 if (create_options & CREATE_OPTION_READONLY) 1087 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY); 1088 1089 /* BB FIXME BB */ 1090 /* pSMB->CreateOptions = cpu_to_le32(create_options & 1091 CREATE_OPTIONS_MASK); */ 1092 /* BB FIXME END BB */ 1093 1094 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY); 1095 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition)); 1096 count += name_len; 1097 inc_rfc1001_len(pSMB, count); 1098 1099 pSMB->ByteCount = cpu_to_le16(count); 1100 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 1101 (struct smb_hdr *)pSMBr, &bytes_returned, 0); 1102 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens); 1103 if (rc) { 1104 cifs_dbg(FYI, "Error in Open = %d\n", rc); 1105 } else { 1106 /* BB verify if wct == 15 */ 1107 1108 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/ 1109 1110 *netfid = pSMBr->Fid; /* cifs fid stays in le */ 1111 /* Let caller know file was created so we can set the mode. */ 1112 /* Do we care about the CreateAction in any other cases? */ 1113 /* BB FIXME BB */ 1114 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction) 1115 *pOplock |= CIFS_CREATE_ACTION; */ 1116 /* BB FIXME END */ 1117 1118 if (pfile_info) { 1119 pfile_info->CreationTime = 0; /* BB convert CreateTime*/ 1120 pfile_info->LastAccessTime = 0; /* BB fixme */ 1121 pfile_info->LastWriteTime = 0; /* BB fixme */ 1122 pfile_info->ChangeTime = 0; /* BB fixme */ 1123 pfile_info->Attributes = 1124 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes)); 1125 /* the file_info buf is endian converted by caller */ 1126 pfile_info->AllocationSize = 1127 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile)); 1128 pfile_info->EndOfFile = pfile_info->AllocationSize; 1129 pfile_info->NumberOfLinks = cpu_to_le32(1); 1130 pfile_info->DeletePending = 0; 1131 } 1132 } 1133 1134 cifs_buf_release(pSMB); 1135 if (rc == -EAGAIN) 1136 goto OldOpenRetry; 1137 return rc; 1138 } 1139 1140 int 1141 CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock, 1142 FILE_ALL_INFO *buf) 1143 { 1144 int rc; 1145 OPEN_REQ *req = NULL; 1146 OPEN_RSP *rsp = NULL; 1147 int bytes_returned; 1148 int name_len; 1149 __u16 count; 1150 struct cifs_sb_info *cifs_sb = oparms->cifs_sb; 1151 struct cifs_tcon *tcon = oparms->tcon; 1152 int remap = cifs_remap(cifs_sb); 1153 const struct nls_table *nls = cifs_sb->local_nls; 1154 int create_options = oparms->create_options; 1155 int desired_access = oparms->desired_access; 1156 int disposition = oparms->disposition; 1157 const char *path = oparms->path; 1158 1159 openRetry: 1160 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **)&req, 1161 (void **)&rsp); 1162 if (rc) 1163 return rc; 1164 1165 /* no commands go after this */ 1166 req->AndXCommand = 0xFF; 1167 1168 if (req->hdr.Flags2 & SMBFLG2_UNICODE) { 1169 /* account for one byte pad to word boundary */ 1170 count = 1; 1171 name_len = cifsConvertToUTF16((__le16 *)(req->fileName + 1), 1172 path, PATH_MAX, nls, remap); 1173 /* trailing null */ 1174 name_len++; 1175 name_len *= 2; 1176 req->NameLength = cpu_to_le16(name_len); 1177 } else { 1178 /* BB improve check for buffer overruns BB */ 1179 /* no pad */ 1180 count = 0; 1181 name_len = copy_path_name(req->fileName, path); 1182 req->NameLength = cpu_to_le16(name_len); 1183 } 1184 1185 if (*oplock & REQ_OPLOCK) 1186 req->OpenFlags = cpu_to_le32(REQ_OPLOCK); 1187 else if (*oplock & REQ_BATCHOPLOCK) 1188 req->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK); 1189 1190 req->DesiredAccess = cpu_to_le32(desired_access); 1191 req->AllocationSize = 0; 1192 1193 /* 1194 * Set file as system file if special file such as fifo and server 1195 * expecting SFU style and no Unix extensions. 1196 */ 1197 if (create_options & CREATE_OPTION_SPECIAL) 1198 req->FileAttributes = cpu_to_le32(ATTR_SYSTEM); 1199 else 1200 req->FileAttributes = cpu_to_le32(ATTR_NORMAL); 1201 1202 /* 1203 * XP does not handle ATTR_POSIX_SEMANTICS but it helps speed up case 1204 * sensitive checks for other servers such as Samba. 1205 */ 1206 if (tcon->ses->capabilities & CAP_UNIX) 1207 req->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS); 1208 1209 if (create_options & CREATE_OPTION_READONLY) 1210 req->FileAttributes |= cpu_to_le32(ATTR_READONLY); 1211 1212 req->ShareAccess = cpu_to_le32(FILE_SHARE_ALL); 1213 req->CreateDisposition = cpu_to_le32(disposition); 1214 req->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK); 1215 1216 /* BB Expirement with various impersonation levels and verify */ 1217 req->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION); 1218 req->SecurityFlags = SECURITY_CONTEXT_TRACKING|SECURITY_EFFECTIVE_ONLY; 1219 1220 count += name_len; 1221 inc_rfc1001_len(req, count); 1222 1223 req->ByteCount = cpu_to_le16(count); 1224 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)req, 1225 (struct smb_hdr *)rsp, &bytes_returned, 0); 1226 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens); 1227 if (rc) { 1228 cifs_dbg(FYI, "Error in Open = %d\n", rc); 1229 cifs_buf_release(req); 1230 if (rc == -EAGAIN) 1231 goto openRetry; 1232 return rc; 1233 } 1234 1235 /* 1 byte no need to le_to_cpu */ 1236 *oplock = rsp->OplockLevel; 1237 /* cifs fid stays in le */ 1238 oparms->fid->netfid = rsp->Fid; 1239 oparms->fid->access = desired_access; 1240 1241 /* Let caller know file was created so we can set the mode. */ 1242 /* Do we care about the CreateAction in any other cases? */ 1243 if (cpu_to_le32(FILE_CREATE) == rsp->CreateAction) 1244 *oplock |= CIFS_CREATE_ACTION; 1245 1246 if (buf) { 1247 /* copy commonly used attributes */ 1248 memcpy(&buf->common_attributes, 1249 &rsp->common_attributes, 1250 sizeof(buf->common_attributes)); 1251 /* the file_info buf is endian converted by caller */ 1252 buf->AllocationSize = rsp->AllocationSize; 1253 buf->EndOfFile = rsp->EndOfFile; 1254 buf->NumberOfLinks = cpu_to_le32(1); 1255 buf->DeletePending = 0; 1256 } 1257 1258 cifs_buf_release(req); 1259 return rc; 1260 } 1261 1262 static void 1263 cifs_readv_callback(struct mid_q_entry *mid) 1264 { 1265 struct cifs_readdata *rdata = mid->callback_data; 1266 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink); 1267 struct TCP_Server_Info *server = tcon->ses->server; 1268 struct smb_rqst rqst = { .rq_iov = rdata->iov, 1269 .rq_nvec = 2, 1270 .rq_iter_size = iov_iter_count(&rdata->iter), 1271 .rq_iter = rdata->iter }; 1272 struct cifs_credits credits = { .value = 1, .instance = 0 }; 1273 1274 cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n", 1275 __func__, mid->mid, mid->mid_state, rdata->result, 1276 rdata->bytes); 1277 1278 switch (mid->mid_state) { 1279 case MID_RESPONSE_RECEIVED: 1280 /* result already set, check signature */ 1281 if (server->sign) { 1282 int rc = 0; 1283 1284 rc = cifs_verify_signature(&rqst, server, 1285 mid->sequence_number); 1286 if (rc) 1287 cifs_dbg(VFS, "SMB signature verification returned error = %d\n", 1288 rc); 1289 } 1290 /* FIXME: should this be counted toward the initiating task? */ 1291 task_io_account_read(rdata->got_bytes); 1292 cifs_stats_bytes_read(tcon, rdata->got_bytes); 1293 break; 1294 case MID_REQUEST_SUBMITTED: 1295 case MID_RETRY_NEEDED: 1296 rdata->result = -EAGAIN; 1297 if (server->sign && rdata->got_bytes) 1298 /* reset bytes number since we can not check a sign */ 1299 rdata->got_bytes = 0; 1300 /* FIXME: should this be counted toward the initiating task? */ 1301 task_io_account_read(rdata->got_bytes); 1302 cifs_stats_bytes_read(tcon, rdata->got_bytes); 1303 break; 1304 default: 1305 rdata->result = -EIO; 1306 } 1307 1308 queue_work(cifsiod_wq, &rdata->work); 1309 release_mid(mid); 1310 add_credits(server, &credits, 0); 1311 } 1312 1313 /* cifs_async_readv - send an async write, and set up mid to handle result */ 1314 int 1315 cifs_async_readv(struct cifs_readdata *rdata) 1316 { 1317 int rc; 1318 READ_REQ *smb = NULL; 1319 int wct; 1320 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink); 1321 struct smb_rqst rqst = { .rq_iov = rdata->iov, 1322 .rq_nvec = 2 }; 1323 1324 cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n", 1325 __func__, rdata->offset, rdata->bytes); 1326 1327 if (tcon->ses->capabilities & CAP_LARGE_FILES) 1328 wct = 12; 1329 else { 1330 wct = 10; /* old style read */ 1331 if ((rdata->offset >> 32) > 0) { 1332 /* can not handle this big offset for old */ 1333 return -EIO; 1334 } 1335 } 1336 1337 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb); 1338 if (rc) 1339 return rc; 1340 1341 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid); 1342 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16)); 1343 1344 smb->AndXCommand = 0xFF; /* none */ 1345 smb->Fid = rdata->cfile->fid.netfid; 1346 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF); 1347 if (wct == 12) 1348 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32); 1349 smb->Remaining = 0; 1350 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF); 1351 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16); 1352 if (wct == 12) 1353 smb->ByteCount = 0; 1354 else { 1355 /* old style read */ 1356 struct smb_com_readx_req *smbr = 1357 (struct smb_com_readx_req *)smb; 1358 smbr->ByteCount = 0; 1359 } 1360 1361 /* 4 for RFC1001 length + 1 for BCC */ 1362 rdata->iov[0].iov_base = smb; 1363 rdata->iov[0].iov_len = 4; 1364 rdata->iov[1].iov_base = (char *)smb + 4; 1365 rdata->iov[1].iov_len = get_rfc1002_length(smb); 1366 1367 kref_get(&rdata->refcount); 1368 rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive, 1369 cifs_readv_callback, NULL, rdata, 0, NULL); 1370 1371 if (rc == 0) 1372 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads); 1373 else 1374 kref_put(&rdata->refcount, cifs_readdata_release); 1375 1376 cifs_small_buf_release(smb); 1377 return rc; 1378 } 1379 1380 int 1381 CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms, 1382 unsigned int *nbytes, char **buf, int *pbuf_type) 1383 { 1384 int rc = -EACCES; 1385 READ_REQ *pSMB = NULL; 1386 READ_RSP *pSMBr = NULL; 1387 char *pReadData = NULL; 1388 int wct; 1389 int resp_buf_type = 0; 1390 struct kvec iov[1]; 1391 struct kvec rsp_iov; 1392 __u32 pid = io_parms->pid; 1393 __u16 netfid = io_parms->netfid; 1394 __u64 offset = io_parms->offset; 1395 struct cifs_tcon *tcon = io_parms->tcon; 1396 unsigned int count = io_parms->length; 1397 1398 cifs_dbg(FYI, "Reading %d bytes on fid %d\n", count, netfid); 1399 if (tcon->ses->capabilities & CAP_LARGE_FILES) 1400 wct = 12; 1401 else { 1402 wct = 10; /* old style read */ 1403 if ((offset >> 32) > 0) { 1404 /* can not handle this big offset for old */ 1405 return -EIO; 1406 } 1407 } 1408 1409 *nbytes = 0; 1410 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB); 1411 if (rc) 1412 return rc; 1413 1414 pSMB->hdr.Pid = cpu_to_le16((__u16)pid); 1415 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16)); 1416 1417 /* tcon and ses pointer are checked in smb_init */ 1418 if (tcon->ses->server == NULL) 1419 return -ECONNABORTED; 1420 1421 pSMB->AndXCommand = 0xFF; /* none */ 1422 pSMB->Fid = netfid; 1423 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF); 1424 if (wct == 12) 1425 pSMB->OffsetHigh = cpu_to_le32(offset >> 32); 1426 1427 pSMB->Remaining = 0; 1428 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF); 1429 pSMB->MaxCountHigh = cpu_to_le32(count >> 16); 1430 if (wct == 12) 1431 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */ 1432 else { 1433 /* old style read */ 1434 struct smb_com_readx_req *pSMBW = 1435 (struct smb_com_readx_req *)pSMB; 1436 pSMBW->ByteCount = 0; 1437 } 1438 1439 iov[0].iov_base = (char *)pSMB; 1440 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4; 1441 rc = SendReceive2(xid, tcon->ses, iov, 1, &resp_buf_type, 1442 CIFS_LOG_ERROR, &rsp_iov); 1443 cifs_small_buf_release(pSMB); 1444 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads); 1445 pSMBr = (READ_RSP *)rsp_iov.iov_base; 1446 if (rc) { 1447 cifs_dbg(VFS, "Send error in read = %d\n", rc); 1448 } else { 1449 int data_length = le16_to_cpu(pSMBr->DataLengthHigh); 1450 data_length = data_length << 16; 1451 data_length += le16_to_cpu(pSMBr->DataLength); 1452 *nbytes = data_length; 1453 1454 /*check that DataLength would not go beyond end of SMB */ 1455 if ((data_length > CIFSMaxBufSize) 1456 || (data_length > count)) { 1457 cifs_dbg(FYI, "bad length %d for count %d\n", 1458 data_length, count); 1459 rc = -EIO; 1460 *nbytes = 0; 1461 } else { 1462 pReadData = (char *) (&pSMBr->hdr.Protocol) + 1463 le16_to_cpu(pSMBr->DataOffset); 1464 /* if (rc = copy_to_user(buf, pReadData, data_length)) { 1465 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc); 1466 rc = -EFAULT; 1467 }*/ /* can not use copy_to_user when using page cache*/ 1468 if (*buf) 1469 memcpy(*buf, pReadData, data_length); 1470 } 1471 } 1472 1473 if (*buf) { 1474 free_rsp_buf(resp_buf_type, rsp_iov.iov_base); 1475 } else if (resp_buf_type != CIFS_NO_BUFFER) { 1476 /* return buffer to caller to free */ 1477 *buf = rsp_iov.iov_base; 1478 if (resp_buf_type == CIFS_SMALL_BUFFER) 1479 *pbuf_type = CIFS_SMALL_BUFFER; 1480 else if (resp_buf_type == CIFS_LARGE_BUFFER) 1481 *pbuf_type = CIFS_LARGE_BUFFER; 1482 } /* else no valid buffer on return - leave as null */ 1483 1484 /* Note: On -EAGAIN error only caller can retry on handle based calls 1485 since file handle passed in no longer valid */ 1486 return rc; 1487 } 1488 1489 1490 int 1491 CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms, 1492 unsigned int *nbytes, const char *buf) 1493 { 1494 int rc = -EACCES; 1495 WRITE_REQ *pSMB = NULL; 1496 WRITE_RSP *pSMBr = NULL; 1497 int bytes_returned, wct; 1498 __u32 bytes_sent; 1499 __u16 byte_count; 1500 __u32 pid = io_parms->pid; 1501 __u16 netfid = io_parms->netfid; 1502 __u64 offset = io_parms->offset; 1503 struct cifs_tcon *tcon = io_parms->tcon; 1504 unsigned int count = io_parms->length; 1505 1506 *nbytes = 0; 1507 1508 /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/ 1509 if (tcon->ses == NULL) 1510 return -ECONNABORTED; 1511 1512 if (tcon->ses->capabilities & CAP_LARGE_FILES) 1513 wct = 14; 1514 else { 1515 wct = 12; 1516 if ((offset >> 32) > 0) { 1517 /* can not handle big offset for old srv */ 1518 return -EIO; 1519 } 1520 } 1521 1522 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB, 1523 (void **) &pSMBr); 1524 if (rc) 1525 return rc; 1526 1527 pSMB->hdr.Pid = cpu_to_le16((__u16)pid); 1528 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16)); 1529 1530 /* tcon and ses pointer are checked in smb_init */ 1531 if (tcon->ses->server == NULL) 1532 return -ECONNABORTED; 1533 1534 pSMB->AndXCommand = 0xFF; /* none */ 1535 pSMB->Fid = netfid; 1536 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF); 1537 if (wct == 14) 1538 pSMB->OffsetHigh = cpu_to_le32(offset >> 32); 1539 1540 pSMB->Reserved = 0xFFFFFFFF; 1541 pSMB->WriteMode = 0; 1542 pSMB->Remaining = 0; 1543 1544 /* Can increase buffer size if buffer is big enough in some cases ie we 1545 can send more if LARGE_WRITE_X capability returned by the server and if 1546 our buffer is big enough or if we convert to iovecs on socket writes 1547 and eliminate the copy to the CIFS buffer */ 1548 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) { 1549 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count); 1550 } else { 1551 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) 1552 & ~0xFF; 1553 } 1554 1555 if (bytes_sent > count) 1556 bytes_sent = count; 1557 pSMB->DataOffset = 1558 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4); 1559 if (buf) 1560 memcpy(pSMB->Data, buf, bytes_sent); 1561 else if (count != 0) { 1562 /* No buffer */ 1563 cifs_buf_release(pSMB); 1564 return -EINVAL; 1565 } /* else setting file size with write of zero bytes */ 1566 if (wct == 14) 1567 byte_count = bytes_sent + 1; /* pad */ 1568 else /* wct == 12 */ 1569 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */ 1570 1571 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF); 1572 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16); 1573 inc_rfc1001_len(pSMB, byte_count); 1574 1575 if (wct == 14) 1576 pSMB->ByteCount = cpu_to_le16(byte_count); 1577 else { /* old style write has byte count 4 bytes earlier 1578 so 4 bytes pad */ 1579 struct smb_com_writex_req *pSMBW = 1580 (struct smb_com_writex_req *)pSMB; 1581 pSMBW->ByteCount = cpu_to_le16(byte_count); 1582 } 1583 1584 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 1585 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 1586 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes); 1587 if (rc) { 1588 cifs_dbg(FYI, "Send error in write = %d\n", rc); 1589 } else { 1590 *nbytes = le16_to_cpu(pSMBr->CountHigh); 1591 *nbytes = (*nbytes) << 16; 1592 *nbytes += le16_to_cpu(pSMBr->Count); 1593 1594 /* 1595 * Mask off high 16 bits when bytes written as returned by the 1596 * server is greater than bytes requested by the client. Some 1597 * OS/2 servers are known to set incorrect CountHigh values. 1598 */ 1599 if (*nbytes > count) 1600 *nbytes &= 0xFFFF; 1601 } 1602 1603 cifs_buf_release(pSMB); 1604 1605 /* Note: On -EAGAIN error only caller can retry on handle based calls 1606 since file handle passed in no longer valid */ 1607 1608 return rc; 1609 } 1610 1611 /* 1612 * Check the mid_state and signature on received buffer (if any), and queue the 1613 * workqueue completion task. 1614 */ 1615 static void 1616 cifs_writev_callback(struct mid_q_entry *mid) 1617 { 1618 struct cifs_writedata *wdata = mid->callback_data; 1619 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink); 1620 unsigned int written; 1621 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf; 1622 struct cifs_credits credits = { .value = 1, .instance = 0 }; 1623 1624 switch (mid->mid_state) { 1625 case MID_RESPONSE_RECEIVED: 1626 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0); 1627 if (wdata->result != 0) 1628 break; 1629 1630 written = le16_to_cpu(smb->CountHigh); 1631 written <<= 16; 1632 written += le16_to_cpu(smb->Count); 1633 /* 1634 * Mask off high 16 bits when bytes written as returned 1635 * by the server is greater than bytes requested by the 1636 * client. OS/2 servers are known to set incorrect 1637 * CountHigh values. 1638 */ 1639 if (written > wdata->bytes) 1640 written &= 0xFFFF; 1641 1642 if (written < wdata->bytes) 1643 wdata->result = -ENOSPC; 1644 else 1645 wdata->bytes = written; 1646 break; 1647 case MID_REQUEST_SUBMITTED: 1648 case MID_RETRY_NEEDED: 1649 wdata->result = -EAGAIN; 1650 break; 1651 default: 1652 wdata->result = -EIO; 1653 break; 1654 } 1655 1656 queue_work(cifsiod_wq, &wdata->work); 1657 release_mid(mid); 1658 add_credits(tcon->ses->server, &credits, 0); 1659 } 1660 1661 /* cifs_async_writev - send an async write, and set up mid to handle result */ 1662 int 1663 cifs_async_writev(struct cifs_writedata *wdata, 1664 void (*release)(struct kref *kref)) 1665 { 1666 int rc = -EACCES; 1667 WRITE_REQ *smb = NULL; 1668 int wct; 1669 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink); 1670 struct kvec iov[2]; 1671 struct smb_rqst rqst = { }; 1672 1673 if (tcon->ses->capabilities & CAP_LARGE_FILES) { 1674 wct = 14; 1675 } else { 1676 wct = 12; 1677 if (wdata->offset >> 32 > 0) { 1678 /* can not handle big offset for old srv */ 1679 return -EIO; 1680 } 1681 } 1682 1683 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb); 1684 if (rc) 1685 goto async_writev_out; 1686 1687 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid); 1688 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16)); 1689 1690 smb->AndXCommand = 0xFF; /* none */ 1691 smb->Fid = wdata->cfile->fid.netfid; 1692 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF); 1693 if (wct == 14) 1694 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32); 1695 smb->Reserved = 0xFFFFFFFF; 1696 smb->WriteMode = 0; 1697 smb->Remaining = 0; 1698 1699 smb->DataOffset = 1700 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4); 1701 1702 /* 4 for RFC1001 length + 1 for BCC */ 1703 iov[0].iov_len = 4; 1704 iov[0].iov_base = smb; 1705 iov[1].iov_len = get_rfc1002_length(smb) + 1; 1706 iov[1].iov_base = (char *)smb + 4; 1707 1708 rqst.rq_iov = iov; 1709 rqst.rq_nvec = 2; 1710 rqst.rq_iter = wdata->iter; 1711 rqst.rq_iter_size = iov_iter_count(&wdata->iter); 1712 1713 cifs_dbg(FYI, "async write at %llu %u bytes\n", 1714 wdata->offset, wdata->bytes); 1715 1716 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF); 1717 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16); 1718 1719 if (wct == 14) { 1720 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1); 1721 put_bcc(wdata->bytes + 1, &smb->hdr); 1722 } else { 1723 /* wct == 12 */ 1724 struct smb_com_writex_req *smbw = 1725 (struct smb_com_writex_req *)smb; 1726 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5); 1727 put_bcc(wdata->bytes + 5, &smbw->hdr); 1728 iov[1].iov_len += 4; /* pad bigger by four bytes */ 1729 } 1730 1731 kref_get(&wdata->refcount); 1732 rc = cifs_call_async(tcon->ses->server, &rqst, NULL, 1733 cifs_writev_callback, NULL, wdata, 0, NULL); 1734 1735 if (rc == 0) 1736 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes); 1737 else 1738 kref_put(&wdata->refcount, release); 1739 1740 async_writev_out: 1741 cifs_small_buf_release(smb); 1742 return rc; 1743 } 1744 1745 int 1746 CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms, 1747 unsigned int *nbytes, struct kvec *iov, int n_vec) 1748 { 1749 int rc; 1750 WRITE_REQ *pSMB = NULL; 1751 int wct; 1752 int smb_hdr_len; 1753 int resp_buf_type = 0; 1754 __u32 pid = io_parms->pid; 1755 __u16 netfid = io_parms->netfid; 1756 __u64 offset = io_parms->offset; 1757 struct cifs_tcon *tcon = io_parms->tcon; 1758 unsigned int count = io_parms->length; 1759 struct kvec rsp_iov; 1760 1761 *nbytes = 0; 1762 1763 cifs_dbg(FYI, "write2 at %lld %d bytes\n", (long long)offset, count); 1764 1765 if (tcon->ses->capabilities & CAP_LARGE_FILES) { 1766 wct = 14; 1767 } else { 1768 wct = 12; 1769 if ((offset >> 32) > 0) { 1770 /* can not handle big offset for old srv */ 1771 return -EIO; 1772 } 1773 } 1774 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB); 1775 if (rc) 1776 return rc; 1777 1778 pSMB->hdr.Pid = cpu_to_le16((__u16)pid); 1779 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16)); 1780 1781 /* tcon and ses pointer are checked in smb_init */ 1782 if (tcon->ses->server == NULL) 1783 return -ECONNABORTED; 1784 1785 pSMB->AndXCommand = 0xFF; /* none */ 1786 pSMB->Fid = netfid; 1787 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF); 1788 if (wct == 14) 1789 pSMB->OffsetHigh = cpu_to_le32(offset >> 32); 1790 pSMB->Reserved = 0xFFFFFFFF; 1791 pSMB->WriteMode = 0; 1792 pSMB->Remaining = 0; 1793 1794 pSMB->DataOffset = 1795 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4); 1796 1797 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF); 1798 pSMB->DataLengthHigh = cpu_to_le16(count >> 16); 1799 /* header + 1 byte pad */ 1800 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1; 1801 if (wct == 14) 1802 inc_rfc1001_len(pSMB, count + 1); 1803 else /* wct == 12 */ 1804 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */ 1805 if (wct == 14) 1806 pSMB->ByteCount = cpu_to_le16(count + 1); 1807 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ { 1808 struct smb_com_writex_req *pSMBW = 1809 (struct smb_com_writex_req *)pSMB; 1810 pSMBW->ByteCount = cpu_to_le16(count + 5); 1811 } 1812 iov[0].iov_base = pSMB; 1813 if (wct == 14) 1814 iov[0].iov_len = smb_hdr_len + 4; 1815 else /* wct == 12 pad bigger by four bytes */ 1816 iov[0].iov_len = smb_hdr_len + 8; 1817 1818 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0, 1819 &rsp_iov); 1820 cifs_small_buf_release(pSMB); 1821 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes); 1822 if (rc) { 1823 cifs_dbg(FYI, "Send error Write2 = %d\n", rc); 1824 } else if (resp_buf_type == 0) { 1825 /* presumably this can not happen, but best to be safe */ 1826 rc = -EIO; 1827 } else { 1828 WRITE_RSP *pSMBr = (WRITE_RSP *)rsp_iov.iov_base; 1829 *nbytes = le16_to_cpu(pSMBr->CountHigh); 1830 *nbytes = (*nbytes) << 16; 1831 *nbytes += le16_to_cpu(pSMBr->Count); 1832 1833 /* 1834 * Mask off high 16 bits when bytes written as returned by the 1835 * server is greater than bytes requested by the client. OS/2 1836 * servers are known to set incorrect CountHigh values. 1837 */ 1838 if (*nbytes > count) 1839 *nbytes &= 0xFFFF; 1840 } 1841 1842 free_rsp_buf(resp_buf_type, rsp_iov.iov_base); 1843 1844 /* Note: On -EAGAIN error only caller can retry on handle based calls 1845 since file handle passed in no longer valid */ 1846 1847 return rc; 1848 } 1849 1850 int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon, 1851 const __u16 netfid, const __u8 lock_type, const __u32 num_unlock, 1852 const __u32 num_lock, LOCKING_ANDX_RANGE *buf) 1853 { 1854 int rc = 0; 1855 LOCK_REQ *pSMB = NULL; 1856 struct kvec iov[2]; 1857 struct kvec rsp_iov; 1858 int resp_buf_type; 1859 __u16 count; 1860 1861 cifs_dbg(FYI, "cifs_lockv num lock %d num unlock %d\n", 1862 num_lock, num_unlock); 1863 1864 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB); 1865 if (rc) 1866 return rc; 1867 1868 pSMB->Timeout = 0; 1869 pSMB->NumberOfLocks = cpu_to_le16(num_lock); 1870 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock); 1871 pSMB->LockType = lock_type; 1872 pSMB->AndXCommand = 0xFF; /* none */ 1873 pSMB->Fid = netfid; /* netfid stays le */ 1874 1875 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE); 1876 inc_rfc1001_len(pSMB, count); 1877 pSMB->ByteCount = cpu_to_le16(count); 1878 1879 iov[0].iov_base = (char *)pSMB; 1880 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 - 1881 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE); 1882 iov[1].iov_base = (char *)buf; 1883 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE); 1884 1885 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks); 1886 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, 1887 CIFS_NO_RSP_BUF, &rsp_iov); 1888 cifs_small_buf_release(pSMB); 1889 if (rc) 1890 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc); 1891 1892 return rc; 1893 } 1894 1895 int 1896 CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon, 1897 const __u16 smb_file_id, const __u32 netpid, const __u64 len, 1898 const __u64 offset, const __u32 numUnlock, 1899 const __u32 numLock, const __u8 lockType, 1900 const bool waitFlag, const __u8 oplock_level) 1901 { 1902 int rc = 0; 1903 LOCK_REQ *pSMB = NULL; 1904 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */ 1905 int bytes_returned; 1906 int flags = 0; 1907 __u16 count; 1908 1909 cifs_dbg(FYI, "CIFSSMBLock timeout %d numLock %d\n", 1910 (int)waitFlag, numLock); 1911 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB); 1912 1913 if (rc) 1914 return rc; 1915 1916 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) { 1917 /* no response expected */ 1918 flags = CIFS_NO_SRV_RSP | CIFS_NON_BLOCKING | CIFS_OBREAK_OP; 1919 pSMB->Timeout = 0; 1920 } else if (waitFlag) { 1921 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */ 1922 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */ 1923 } else { 1924 pSMB->Timeout = 0; 1925 } 1926 1927 pSMB->NumberOfLocks = cpu_to_le16(numLock); 1928 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock); 1929 pSMB->LockType = lockType; 1930 pSMB->OplockLevel = oplock_level; 1931 pSMB->AndXCommand = 0xFF; /* none */ 1932 pSMB->Fid = smb_file_id; /* netfid stays le */ 1933 1934 if ((numLock != 0) || (numUnlock != 0)) { 1935 pSMB->Locks[0].Pid = cpu_to_le16(netpid); 1936 /* BB where to store pid high? */ 1937 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len); 1938 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32)); 1939 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset); 1940 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32)); 1941 count = sizeof(LOCKING_ANDX_RANGE); 1942 } else { 1943 /* oplock break */ 1944 count = 0; 1945 } 1946 inc_rfc1001_len(pSMB, count); 1947 pSMB->ByteCount = cpu_to_le16(count); 1948 1949 if (waitFlag) 1950 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB, 1951 (struct smb_hdr *) pSMB, &bytes_returned); 1952 else 1953 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags); 1954 cifs_small_buf_release(pSMB); 1955 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks); 1956 if (rc) 1957 cifs_dbg(FYI, "Send error in Lock = %d\n", rc); 1958 1959 /* Note: On -EAGAIN error only caller can retry on handle based calls 1960 since file handle passed in no longer valid */ 1961 return rc; 1962 } 1963 1964 int 1965 CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon, 1966 const __u16 smb_file_id, const __u32 netpid, 1967 const loff_t start_offset, const __u64 len, 1968 struct file_lock *pLockData, const __u16 lock_type, 1969 const bool waitFlag) 1970 { 1971 struct smb_com_transaction2_sfi_req *pSMB = NULL; 1972 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL; 1973 struct cifs_posix_lock *parm_data; 1974 int rc = 0; 1975 int timeout = 0; 1976 int bytes_returned = 0; 1977 int resp_buf_type = 0; 1978 __u16 params, param_offset, offset, byte_count, count; 1979 struct kvec iov[1]; 1980 struct kvec rsp_iov; 1981 1982 cifs_dbg(FYI, "Posix Lock\n"); 1983 1984 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 1985 1986 if (rc) 1987 return rc; 1988 1989 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB; 1990 1991 params = 6; 1992 pSMB->MaxSetupCount = 0; 1993 pSMB->Reserved = 0; 1994 pSMB->Flags = 0; 1995 pSMB->Reserved2 = 0; 1996 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 1997 offset = param_offset + params; 1998 1999 count = sizeof(struct cifs_posix_lock); 2000 pSMB->MaxParameterCount = cpu_to_le16(2); 2001 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */ 2002 pSMB->SetupCount = 1; 2003 pSMB->Reserved3 = 0; 2004 if (pLockData) 2005 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 2006 else 2007 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 2008 byte_count = 3 /* pad */ + params + count; 2009 pSMB->DataCount = cpu_to_le16(count); 2010 pSMB->ParameterCount = cpu_to_le16(params); 2011 pSMB->TotalDataCount = pSMB->DataCount; 2012 pSMB->TotalParameterCount = pSMB->ParameterCount; 2013 pSMB->ParameterOffset = cpu_to_le16(param_offset); 2014 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 2015 parm_data = (struct cifs_posix_lock *) 2016 (((char *)pSMB) + offset + 4); 2017 2018 parm_data->lock_type = cpu_to_le16(lock_type); 2019 if (waitFlag) { 2020 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */ 2021 parm_data->lock_flags = cpu_to_le16(1); 2022 pSMB->Timeout = cpu_to_le32(-1); 2023 } else 2024 pSMB->Timeout = 0; 2025 2026 parm_data->pid = cpu_to_le32(netpid); 2027 parm_data->start = cpu_to_le64(start_offset); 2028 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */ 2029 2030 pSMB->DataOffset = cpu_to_le16(offset); 2031 pSMB->Fid = smb_file_id; 2032 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK); 2033 pSMB->Reserved4 = 0; 2034 inc_rfc1001_len(pSMB, byte_count); 2035 pSMB->ByteCount = cpu_to_le16(byte_count); 2036 if (waitFlag) { 2037 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB, 2038 (struct smb_hdr *) pSMBr, &bytes_returned); 2039 } else { 2040 iov[0].iov_base = (char *)pSMB; 2041 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4; 2042 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */, 2043 &resp_buf_type, timeout, &rsp_iov); 2044 pSMBr = (struct smb_com_transaction2_sfi_rsp *)rsp_iov.iov_base; 2045 } 2046 cifs_small_buf_release(pSMB); 2047 2048 if (rc) { 2049 cifs_dbg(FYI, "Send error in Posix Lock = %d\n", rc); 2050 } else if (pLockData) { 2051 /* lock structure can be returned on get */ 2052 __u16 data_offset; 2053 __u16 data_count; 2054 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 2055 2056 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) { 2057 rc = -EIO; /* bad smb */ 2058 goto plk_err_exit; 2059 } 2060 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 2061 data_count = le16_to_cpu(pSMBr->t2.DataCount); 2062 if (data_count < sizeof(struct cifs_posix_lock)) { 2063 rc = -EIO; 2064 goto plk_err_exit; 2065 } 2066 parm_data = (struct cifs_posix_lock *) 2067 ((char *)&pSMBr->hdr.Protocol + data_offset); 2068 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK)) 2069 pLockData->fl_type = F_UNLCK; 2070 else { 2071 if (parm_data->lock_type == 2072 cpu_to_le16(CIFS_RDLCK)) 2073 pLockData->fl_type = F_RDLCK; 2074 else if (parm_data->lock_type == 2075 cpu_to_le16(CIFS_WRLCK)) 2076 pLockData->fl_type = F_WRLCK; 2077 2078 pLockData->fl_start = le64_to_cpu(parm_data->start); 2079 pLockData->fl_end = pLockData->fl_start + 2080 (le64_to_cpu(parm_data->length) ? 2081 le64_to_cpu(parm_data->length) - 1 : 0); 2082 pLockData->fl_pid = -le32_to_cpu(parm_data->pid); 2083 } 2084 } 2085 2086 plk_err_exit: 2087 free_rsp_buf(resp_buf_type, rsp_iov.iov_base); 2088 2089 /* Note: On -EAGAIN error only caller can retry on handle based calls 2090 since file handle passed in no longer valid */ 2091 2092 return rc; 2093 } 2094 2095 2096 int 2097 CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id) 2098 { 2099 int rc = 0; 2100 CLOSE_REQ *pSMB = NULL; 2101 cifs_dbg(FYI, "In CIFSSMBClose\n"); 2102 2103 /* do not retry on dead session on close */ 2104 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB); 2105 if (rc == -EAGAIN) 2106 return 0; 2107 if (rc) 2108 return rc; 2109 2110 pSMB->FileID = (__u16) smb_file_id; 2111 pSMB->LastWriteTime = 0xFFFFFFFF; 2112 pSMB->ByteCount = 0; 2113 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 2114 cifs_small_buf_release(pSMB); 2115 cifs_stats_inc(&tcon->stats.cifs_stats.num_closes); 2116 if (rc) { 2117 if (rc != -EINTR) { 2118 /* EINTR is expected when user ctl-c to kill app */ 2119 cifs_dbg(VFS, "Send error in Close = %d\n", rc); 2120 } 2121 } 2122 2123 /* Since session is dead, file will be closed on server already */ 2124 if (rc == -EAGAIN) 2125 rc = 0; 2126 2127 return rc; 2128 } 2129 2130 int 2131 CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id) 2132 { 2133 int rc = 0; 2134 FLUSH_REQ *pSMB = NULL; 2135 cifs_dbg(FYI, "In CIFSSMBFlush\n"); 2136 2137 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB); 2138 if (rc) 2139 return rc; 2140 2141 pSMB->FileID = (__u16) smb_file_id; 2142 pSMB->ByteCount = 0; 2143 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 2144 cifs_small_buf_release(pSMB); 2145 cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes); 2146 if (rc) 2147 cifs_dbg(VFS, "Send error in Flush = %d\n", rc); 2148 2149 return rc; 2150 } 2151 2152 int 2153 CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon, 2154 const char *from_name, const char *to_name, 2155 struct cifs_sb_info *cifs_sb) 2156 { 2157 int rc = 0; 2158 RENAME_REQ *pSMB = NULL; 2159 RENAME_RSP *pSMBr = NULL; 2160 int bytes_returned; 2161 int name_len, name_len2; 2162 __u16 count; 2163 int remap = cifs_remap(cifs_sb); 2164 2165 cifs_dbg(FYI, "In CIFSSMBRename\n"); 2166 renameRetry: 2167 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB, 2168 (void **) &pSMBr); 2169 if (rc) 2170 return rc; 2171 2172 pSMB->BufferFormat = 0x04; 2173 pSMB->SearchAttributes = 2174 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM | 2175 ATTR_DIRECTORY); 2176 2177 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2178 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName, 2179 from_name, PATH_MAX, 2180 cifs_sb->local_nls, remap); 2181 name_len++; /* trailing null */ 2182 name_len *= 2; 2183 pSMB->OldFileName[name_len] = 0x04; /* pad */ 2184 /* protocol requires ASCII signature byte on Unicode string */ 2185 pSMB->OldFileName[name_len + 1] = 0x00; 2186 name_len2 = 2187 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2], 2188 to_name, PATH_MAX, cifs_sb->local_nls, 2189 remap); 2190 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ; 2191 name_len2 *= 2; /* convert to bytes */ 2192 } else { 2193 name_len = copy_path_name(pSMB->OldFileName, from_name); 2194 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, to_name); 2195 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */ 2196 name_len2++; /* signature byte */ 2197 } 2198 2199 count = 1 /* 1st signature byte */ + name_len + name_len2; 2200 inc_rfc1001_len(pSMB, count); 2201 pSMB->ByteCount = cpu_to_le16(count); 2202 2203 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2204 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2205 cifs_stats_inc(&tcon->stats.cifs_stats.num_renames); 2206 if (rc) 2207 cifs_dbg(FYI, "Send error in rename = %d\n", rc); 2208 2209 cifs_buf_release(pSMB); 2210 2211 if (rc == -EAGAIN) 2212 goto renameRetry; 2213 2214 return rc; 2215 } 2216 2217 int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon, 2218 int netfid, const char *target_name, 2219 const struct nls_table *nls_codepage, int remap) 2220 { 2221 struct smb_com_transaction2_sfi_req *pSMB = NULL; 2222 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL; 2223 struct set_file_rename *rename_info; 2224 char *data_offset; 2225 char dummy_string[30]; 2226 int rc = 0; 2227 int bytes_returned = 0; 2228 int len_of_str; 2229 __u16 params, param_offset, offset, count, byte_count; 2230 2231 cifs_dbg(FYI, "Rename to File by handle\n"); 2232 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB, 2233 (void **) &pSMBr); 2234 if (rc) 2235 return rc; 2236 2237 params = 6; 2238 pSMB->MaxSetupCount = 0; 2239 pSMB->Reserved = 0; 2240 pSMB->Flags = 0; 2241 pSMB->Timeout = 0; 2242 pSMB->Reserved2 = 0; 2243 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 2244 offset = param_offset + params; 2245 2246 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 2247 data_offset = (char *)(pSMB) + offset + 4; 2248 rename_info = (struct set_file_rename *) data_offset; 2249 pSMB->MaxParameterCount = cpu_to_le16(2); 2250 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */ 2251 pSMB->SetupCount = 1; 2252 pSMB->Reserved3 = 0; 2253 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 2254 byte_count = 3 /* pad */ + params; 2255 pSMB->ParameterCount = cpu_to_le16(params); 2256 pSMB->TotalParameterCount = pSMB->ParameterCount; 2257 pSMB->ParameterOffset = cpu_to_le16(param_offset); 2258 pSMB->DataOffset = cpu_to_le16(offset); 2259 /* construct random name ".cifs_tmp<inodenum><mid>" */ 2260 rename_info->overwrite = cpu_to_le32(1); 2261 rename_info->root_fid = 0; 2262 /* unicode only call */ 2263 if (target_name == NULL) { 2264 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid); 2265 len_of_str = 2266 cifsConvertToUTF16((__le16 *)rename_info->target_name, 2267 dummy_string, 24, nls_codepage, remap); 2268 } else { 2269 len_of_str = 2270 cifsConvertToUTF16((__le16 *)rename_info->target_name, 2271 target_name, PATH_MAX, nls_codepage, 2272 remap); 2273 } 2274 rename_info->target_name_len = cpu_to_le32(2 * len_of_str); 2275 count = sizeof(struct set_file_rename) + (2 * len_of_str); 2276 byte_count += count; 2277 pSMB->DataCount = cpu_to_le16(count); 2278 pSMB->TotalDataCount = pSMB->DataCount; 2279 pSMB->Fid = netfid; 2280 pSMB->InformationLevel = 2281 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION); 2282 pSMB->Reserved4 = 0; 2283 inc_rfc1001_len(pSMB, byte_count); 2284 pSMB->ByteCount = cpu_to_le16(byte_count); 2285 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB, 2286 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2287 cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames); 2288 if (rc) 2289 cifs_dbg(FYI, "Send error in Rename (by file handle) = %d\n", 2290 rc); 2291 2292 cifs_buf_release(pSMB); 2293 2294 /* Note: On -EAGAIN error only caller can retry on handle based calls 2295 since file handle passed in no longer valid */ 2296 2297 return rc; 2298 } 2299 2300 int 2301 CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon, 2302 const char *fromName, const __u16 target_tid, const char *toName, 2303 const int flags, const struct nls_table *nls_codepage, int remap) 2304 { 2305 int rc = 0; 2306 COPY_REQ *pSMB = NULL; 2307 COPY_RSP *pSMBr = NULL; 2308 int bytes_returned; 2309 int name_len, name_len2; 2310 __u16 count; 2311 2312 cifs_dbg(FYI, "In CIFSSMBCopy\n"); 2313 copyRetry: 2314 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB, 2315 (void **) &pSMBr); 2316 if (rc) 2317 return rc; 2318 2319 pSMB->BufferFormat = 0x04; 2320 pSMB->Tid2 = target_tid; 2321 2322 pSMB->Flags = cpu_to_le16(flags & COPY_TREE); 2323 2324 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2325 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName, 2326 fromName, PATH_MAX, nls_codepage, 2327 remap); 2328 name_len++; /* trailing null */ 2329 name_len *= 2; 2330 pSMB->OldFileName[name_len] = 0x04; /* pad */ 2331 /* protocol requires ASCII signature byte on Unicode string */ 2332 pSMB->OldFileName[name_len + 1] = 0x00; 2333 name_len2 = 2334 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2], 2335 toName, PATH_MAX, nls_codepage, remap); 2336 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ; 2337 name_len2 *= 2; /* convert to bytes */ 2338 } else { 2339 name_len = copy_path_name(pSMB->OldFileName, fromName); 2340 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */ 2341 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, toName); 2342 name_len2++; /* signature byte */ 2343 } 2344 2345 count = 1 /* 1st signature byte */ + name_len + name_len2; 2346 inc_rfc1001_len(pSMB, count); 2347 pSMB->ByteCount = cpu_to_le16(count); 2348 2349 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2350 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2351 if (rc) { 2352 cifs_dbg(FYI, "Send error in copy = %d with %d files copied\n", 2353 rc, le16_to_cpu(pSMBr->CopyCount)); 2354 } 2355 cifs_buf_release(pSMB); 2356 2357 if (rc == -EAGAIN) 2358 goto copyRetry; 2359 2360 return rc; 2361 } 2362 2363 int 2364 CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon, 2365 const char *fromName, const char *toName, 2366 const struct nls_table *nls_codepage, int remap) 2367 { 2368 TRANSACTION2_SPI_REQ *pSMB = NULL; 2369 TRANSACTION2_SPI_RSP *pSMBr = NULL; 2370 char *data_offset; 2371 int name_len; 2372 int name_len_target; 2373 int rc = 0; 2374 int bytes_returned = 0; 2375 __u16 params, param_offset, offset, byte_count; 2376 2377 cifs_dbg(FYI, "In Symlink Unix style\n"); 2378 createSymLinkRetry: 2379 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 2380 (void **) &pSMBr); 2381 if (rc) 2382 return rc; 2383 2384 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2385 name_len = 2386 cifsConvertToUTF16((__le16 *) pSMB->FileName, fromName, 2387 /* find define for this maxpathcomponent */ 2388 PATH_MAX, nls_codepage, remap); 2389 name_len++; /* trailing null */ 2390 name_len *= 2; 2391 2392 } else { 2393 name_len = copy_path_name(pSMB->FileName, fromName); 2394 } 2395 params = 6 + name_len; 2396 pSMB->MaxSetupCount = 0; 2397 pSMB->Reserved = 0; 2398 pSMB->Flags = 0; 2399 pSMB->Timeout = 0; 2400 pSMB->Reserved2 = 0; 2401 param_offset = offsetof(struct smb_com_transaction2_spi_req, 2402 InformationLevel) - 4; 2403 offset = param_offset + params; 2404 2405 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 2406 data_offset = (char *)pSMB + offset + 4; 2407 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2408 name_len_target = 2409 cifsConvertToUTF16((__le16 *) data_offset, toName, 2410 /* find define for this maxpathcomponent */ 2411 PATH_MAX, nls_codepage, remap); 2412 name_len_target++; /* trailing null */ 2413 name_len_target *= 2; 2414 } else { 2415 name_len_target = copy_path_name(data_offset, toName); 2416 } 2417 2418 pSMB->MaxParameterCount = cpu_to_le16(2); 2419 /* BB find exact max on data count below from sess */ 2420 pSMB->MaxDataCount = cpu_to_le16(1000); 2421 pSMB->SetupCount = 1; 2422 pSMB->Reserved3 = 0; 2423 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 2424 byte_count = 3 /* pad */ + params + name_len_target; 2425 pSMB->DataCount = cpu_to_le16(name_len_target); 2426 pSMB->ParameterCount = cpu_to_le16(params); 2427 pSMB->TotalDataCount = pSMB->DataCount; 2428 pSMB->TotalParameterCount = pSMB->ParameterCount; 2429 pSMB->ParameterOffset = cpu_to_le16(param_offset); 2430 pSMB->DataOffset = cpu_to_le16(offset); 2431 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK); 2432 pSMB->Reserved4 = 0; 2433 inc_rfc1001_len(pSMB, byte_count); 2434 pSMB->ByteCount = cpu_to_le16(byte_count); 2435 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2436 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2437 cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks); 2438 if (rc) 2439 cifs_dbg(FYI, "Send error in SetPathInfo create symlink = %d\n", 2440 rc); 2441 2442 cifs_buf_release(pSMB); 2443 2444 if (rc == -EAGAIN) 2445 goto createSymLinkRetry; 2446 2447 return rc; 2448 } 2449 2450 int 2451 CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon, 2452 const char *fromName, const char *toName, 2453 const struct nls_table *nls_codepage, int remap) 2454 { 2455 TRANSACTION2_SPI_REQ *pSMB = NULL; 2456 TRANSACTION2_SPI_RSP *pSMBr = NULL; 2457 char *data_offset; 2458 int name_len; 2459 int name_len_target; 2460 int rc = 0; 2461 int bytes_returned = 0; 2462 __u16 params, param_offset, offset, byte_count; 2463 2464 cifs_dbg(FYI, "In Create Hard link Unix style\n"); 2465 createHardLinkRetry: 2466 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 2467 (void **) &pSMBr); 2468 if (rc) 2469 return rc; 2470 2471 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2472 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName, 2473 PATH_MAX, nls_codepage, remap); 2474 name_len++; /* trailing null */ 2475 name_len *= 2; 2476 2477 } else { 2478 name_len = copy_path_name(pSMB->FileName, toName); 2479 } 2480 params = 6 + name_len; 2481 pSMB->MaxSetupCount = 0; 2482 pSMB->Reserved = 0; 2483 pSMB->Flags = 0; 2484 pSMB->Timeout = 0; 2485 pSMB->Reserved2 = 0; 2486 param_offset = offsetof(struct smb_com_transaction2_spi_req, 2487 InformationLevel) - 4; 2488 offset = param_offset + params; 2489 2490 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 2491 data_offset = (char *)pSMB + offset + 4; 2492 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2493 name_len_target = 2494 cifsConvertToUTF16((__le16 *) data_offset, fromName, 2495 PATH_MAX, nls_codepage, remap); 2496 name_len_target++; /* trailing null */ 2497 name_len_target *= 2; 2498 } else { 2499 name_len_target = copy_path_name(data_offset, fromName); 2500 } 2501 2502 pSMB->MaxParameterCount = cpu_to_le16(2); 2503 /* BB find exact max on data count below from sess*/ 2504 pSMB->MaxDataCount = cpu_to_le16(1000); 2505 pSMB->SetupCount = 1; 2506 pSMB->Reserved3 = 0; 2507 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 2508 byte_count = 3 /* pad */ + params + name_len_target; 2509 pSMB->ParameterCount = cpu_to_le16(params); 2510 pSMB->TotalParameterCount = pSMB->ParameterCount; 2511 pSMB->DataCount = cpu_to_le16(name_len_target); 2512 pSMB->TotalDataCount = pSMB->DataCount; 2513 pSMB->ParameterOffset = cpu_to_le16(param_offset); 2514 pSMB->DataOffset = cpu_to_le16(offset); 2515 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK); 2516 pSMB->Reserved4 = 0; 2517 inc_rfc1001_len(pSMB, byte_count); 2518 pSMB->ByteCount = cpu_to_le16(byte_count); 2519 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2520 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2521 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks); 2522 if (rc) 2523 cifs_dbg(FYI, "Send error in SetPathInfo (hard link) = %d\n", 2524 rc); 2525 2526 cifs_buf_release(pSMB); 2527 if (rc == -EAGAIN) 2528 goto createHardLinkRetry; 2529 2530 return rc; 2531 } 2532 2533 int 2534 CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon, 2535 const char *from_name, const char *to_name, 2536 struct cifs_sb_info *cifs_sb) 2537 { 2538 int rc = 0; 2539 NT_RENAME_REQ *pSMB = NULL; 2540 RENAME_RSP *pSMBr = NULL; 2541 int bytes_returned; 2542 int name_len, name_len2; 2543 __u16 count; 2544 int remap = cifs_remap(cifs_sb); 2545 2546 cifs_dbg(FYI, "In CIFSCreateHardLink\n"); 2547 winCreateHardLinkRetry: 2548 2549 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB, 2550 (void **) &pSMBr); 2551 if (rc) 2552 return rc; 2553 2554 pSMB->SearchAttributes = 2555 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM | 2556 ATTR_DIRECTORY); 2557 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK); 2558 pSMB->ClusterCount = 0; 2559 2560 pSMB->BufferFormat = 0x04; 2561 2562 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2563 name_len = 2564 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name, 2565 PATH_MAX, cifs_sb->local_nls, remap); 2566 name_len++; /* trailing null */ 2567 name_len *= 2; 2568 2569 /* protocol specifies ASCII buffer format (0x04) for unicode */ 2570 pSMB->OldFileName[name_len] = 0x04; 2571 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */ 2572 name_len2 = 2573 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2], 2574 to_name, PATH_MAX, cifs_sb->local_nls, 2575 remap); 2576 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ; 2577 name_len2 *= 2; /* convert to bytes */ 2578 } else { 2579 name_len = copy_path_name(pSMB->OldFileName, from_name); 2580 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */ 2581 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, to_name); 2582 name_len2++; /* signature byte */ 2583 } 2584 2585 count = 1 /* string type byte */ + name_len + name_len2; 2586 inc_rfc1001_len(pSMB, count); 2587 pSMB->ByteCount = cpu_to_le16(count); 2588 2589 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2590 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2591 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks); 2592 if (rc) 2593 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc); 2594 2595 cifs_buf_release(pSMB); 2596 if (rc == -EAGAIN) 2597 goto winCreateHardLinkRetry; 2598 2599 return rc; 2600 } 2601 2602 int 2603 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon, 2604 const unsigned char *searchName, char **symlinkinfo, 2605 const struct nls_table *nls_codepage, int remap) 2606 { 2607 /* SMB_QUERY_FILE_UNIX_LINK */ 2608 TRANSACTION2_QPI_REQ *pSMB = NULL; 2609 TRANSACTION2_QPI_RSP *pSMBr = NULL; 2610 int rc = 0; 2611 int bytes_returned; 2612 int name_len; 2613 __u16 params, byte_count; 2614 char *data_start; 2615 2616 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName); 2617 2618 querySymLinkRetry: 2619 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 2620 (void **) &pSMBr); 2621 if (rc) 2622 return rc; 2623 2624 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2625 name_len = 2626 cifsConvertToUTF16((__le16 *) pSMB->FileName, 2627 searchName, PATH_MAX, nls_codepage, 2628 remap); 2629 name_len++; /* trailing null */ 2630 name_len *= 2; 2631 } else { 2632 name_len = copy_path_name(pSMB->FileName, searchName); 2633 } 2634 2635 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ; 2636 pSMB->TotalDataCount = 0; 2637 pSMB->MaxParameterCount = cpu_to_le16(2); 2638 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 2639 pSMB->MaxSetupCount = 0; 2640 pSMB->Reserved = 0; 2641 pSMB->Flags = 0; 2642 pSMB->Timeout = 0; 2643 pSMB->Reserved2 = 0; 2644 pSMB->ParameterOffset = cpu_to_le16(offsetof( 2645 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 2646 pSMB->DataCount = 0; 2647 pSMB->DataOffset = 0; 2648 pSMB->SetupCount = 1; 2649 pSMB->Reserved3 = 0; 2650 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 2651 byte_count = params + 1 /* pad */ ; 2652 pSMB->TotalParameterCount = cpu_to_le16(params); 2653 pSMB->ParameterCount = pSMB->TotalParameterCount; 2654 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK); 2655 pSMB->Reserved4 = 0; 2656 inc_rfc1001_len(pSMB, byte_count); 2657 pSMB->ByteCount = cpu_to_le16(byte_count); 2658 2659 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2660 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2661 if (rc) { 2662 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc); 2663 } else { 2664 /* decode response */ 2665 2666 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 2667 /* BB also check enough total bytes returned */ 2668 if (rc || get_bcc(&pSMBr->hdr) < 2) 2669 rc = -EIO; 2670 else { 2671 bool is_unicode; 2672 u16 count = le16_to_cpu(pSMBr->t2.DataCount); 2673 2674 data_start = ((char *) &pSMBr->hdr.Protocol) + 2675 le16_to_cpu(pSMBr->t2.DataOffset); 2676 2677 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) 2678 is_unicode = true; 2679 else 2680 is_unicode = false; 2681 2682 /* BB FIXME investigate remapping reserved chars here */ 2683 *symlinkinfo = cifs_strndup_from_utf16(data_start, 2684 count, is_unicode, nls_codepage); 2685 if (!*symlinkinfo) 2686 rc = -ENOMEM; 2687 } 2688 } 2689 cifs_buf_release(pSMB); 2690 if (rc == -EAGAIN) 2691 goto querySymLinkRetry; 2692 return rc; 2693 } 2694 2695 int cifs_query_reparse_point(const unsigned int xid, 2696 struct cifs_tcon *tcon, 2697 struct cifs_sb_info *cifs_sb, 2698 const char *full_path, 2699 u32 *tag, struct kvec *rsp, 2700 int *rsp_buftype) 2701 { 2702 struct cifs_open_parms oparms; 2703 TRANSACT_IOCTL_REQ *io_req = NULL; 2704 TRANSACT_IOCTL_RSP *io_rsp = NULL; 2705 struct cifs_fid fid; 2706 __u32 data_offset, data_count; 2707 __u8 *start, *end; 2708 int io_rsp_len; 2709 int oplock = 0; 2710 int rc; 2711 2712 cifs_tcon_dbg(FYI, "%s: path=%s\n", __func__, full_path); 2713 2714 if (cap_unix(tcon->ses)) 2715 return -EOPNOTSUPP; 2716 2717 oparms = (struct cifs_open_parms) { 2718 .tcon = tcon, 2719 .cifs_sb = cifs_sb, 2720 .desired_access = FILE_READ_ATTRIBUTES, 2721 .create_options = cifs_create_options(cifs_sb, 2722 OPEN_REPARSE_POINT), 2723 .disposition = FILE_OPEN, 2724 .path = full_path, 2725 .fid = &fid, 2726 }; 2727 2728 rc = CIFS_open(xid, &oparms, &oplock, NULL); 2729 if (rc) 2730 return rc; 2731 2732 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, 2733 (void **)&io_req, (void **)&io_rsp); 2734 if (rc) 2735 goto error; 2736 2737 io_req->TotalParameterCount = 0; 2738 io_req->TotalDataCount = 0; 2739 io_req->MaxParameterCount = cpu_to_le32(2); 2740 /* BB find exact data count max from sess structure BB */ 2741 io_req->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00); 2742 io_req->MaxSetupCount = 4; 2743 io_req->Reserved = 0; 2744 io_req->ParameterOffset = 0; 2745 io_req->DataCount = 0; 2746 io_req->DataOffset = 0; 2747 io_req->SetupCount = 4; 2748 io_req->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL); 2749 io_req->ParameterCount = io_req->TotalParameterCount; 2750 io_req->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT); 2751 io_req->IsFsctl = 1; 2752 io_req->IsRootFlag = 0; 2753 io_req->Fid = fid.netfid; 2754 io_req->ByteCount = 0; 2755 2756 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)io_req, 2757 (struct smb_hdr *)io_rsp, &io_rsp_len, 0); 2758 if (rc) 2759 goto error; 2760 2761 data_offset = le32_to_cpu(io_rsp->DataOffset); 2762 data_count = le32_to_cpu(io_rsp->DataCount); 2763 if (get_bcc(&io_rsp->hdr) < 2 || data_offset > 512 || 2764 !data_count || data_count > 2048) { 2765 rc = -EIO; 2766 goto error; 2767 } 2768 2769 end = 2 + get_bcc(&io_rsp->hdr) + (__u8 *)&io_rsp->ByteCount; 2770 start = (__u8 *)&io_rsp->hdr.Protocol + data_offset; 2771 if (start >= end) { 2772 rc = -EIO; 2773 goto error; 2774 } 2775 2776 *tag = le32_to_cpu(((struct reparse_data_buffer *)start)->ReparseTag); 2777 rsp->iov_base = io_rsp; 2778 rsp->iov_len = io_rsp_len; 2779 *rsp_buftype = CIFS_LARGE_BUFFER; 2780 CIFSSMBClose(xid, tcon, fid.netfid); 2781 return 0; 2782 2783 error: 2784 cifs_buf_release(io_req); 2785 CIFSSMBClose(xid, tcon, fid.netfid); 2786 return rc; 2787 } 2788 2789 int 2790 CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon, 2791 __u16 fid) 2792 { 2793 int rc = 0; 2794 int bytes_returned; 2795 struct smb_com_transaction_compr_ioctl_req *pSMB; 2796 struct smb_com_transaction_ioctl_rsp *pSMBr; 2797 2798 cifs_dbg(FYI, "Set compression for %u\n", fid); 2799 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB, 2800 (void **) &pSMBr); 2801 if (rc) 2802 return rc; 2803 2804 pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT); 2805 2806 pSMB->TotalParameterCount = 0; 2807 pSMB->TotalDataCount = cpu_to_le32(2); 2808 pSMB->MaxParameterCount = 0; 2809 pSMB->MaxDataCount = 0; 2810 pSMB->MaxSetupCount = 4; 2811 pSMB->Reserved = 0; 2812 pSMB->ParameterOffset = 0; 2813 pSMB->DataCount = cpu_to_le32(2); 2814 pSMB->DataOffset = 2815 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req, 2816 compression_state) - 4); /* 84 */ 2817 pSMB->SetupCount = 4; 2818 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL); 2819 pSMB->ParameterCount = 0; 2820 pSMB->FunctionCode = cpu_to_le32(FSCTL_SET_COMPRESSION); 2821 pSMB->IsFsctl = 1; /* FSCTL */ 2822 pSMB->IsRootFlag = 0; 2823 pSMB->Fid = fid; /* file handle always le */ 2824 /* 3 byte pad, followed by 2 byte compress state */ 2825 pSMB->ByteCount = cpu_to_le16(5); 2826 inc_rfc1001_len(pSMB, 5); 2827 2828 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2829 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2830 if (rc) 2831 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc); 2832 2833 cifs_buf_release(pSMB); 2834 2835 /* 2836 * Note: On -EAGAIN error only caller can retry on handle based calls 2837 * since file handle passed in no longer valid. 2838 */ 2839 return rc; 2840 } 2841 2842 2843 #ifdef CONFIG_CIFS_POSIX 2844 2845 #ifdef CONFIG_FS_POSIX_ACL 2846 /** 2847 * cifs_init_posix_acl - convert ACL from cifs to POSIX ACL format 2848 * @ace: POSIX ACL entry to store converted ACL into 2849 * @cifs_ace: ACL in cifs format 2850 * 2851 * Convert an Access Control Entry from wire format to local POSIX xattr 2852 * format. 2853 * 2854 * Note that the @cifs_uid member is used to store both {g,u}id_t. 2855 */ 2856 static void cifs_init_posix_acl(struct posix_acl_entry *ace, 2857 struct cifs_posix_ace *cifs_ace) 2858 { 2859 /* u8 cifs fields do not need le conversion */ 2860 ace->e_perm = cifs_ace->cifs_e_perm; 2861 ace->e_tag = cifs_ace->cifs_e_tag; 2862 2863 switch (ace->e_tag) { 2864 case ACL_USER: 2865 ace->e_uid = make_kuid(&init_user_ns, 2866 le64_to_cpu(cifs_ace->cifs_uid)); 2867 break; 2868 case ACL_GROUP: 2869 ace->e_gid = make_kgid(&init_user_ns, 2870 le64_to_cpu(cifs_ace->cifs_uid)); 2871 break; 2872 } 2873 return; 2874 } 2875 2876 /** 2877 * cifs_to_posix_acl - copy cifs ACL format to POSIX ACL format 2878 * @acl: ACLs returned in POSIX ACL format 2879 * @src: ACLs in cifs format 2880 * @acl_type: type of POSIX ACL requested 2881 * @size_of_data_area: size of SMB we got 2882 * 2883 * This function converts ACLs from cifs format to POSIX ACL format. 2884 * If @acl is NULL then the size of the buffer required to store POSIX ACLs in 2885 * their uapi format is returned. 2886 */ 2887 static int cifs_to_posix_acl(struct posix_acl **acl, char *src, 2888 const int acl_type, const int size_of_data_area) 2889 { 2890 int size = 0; 2891 __u16 count; 2892 struct cifs_posix_ace *pACE; 2893 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src; 2894 struct posix_acl *kacl = NULL; 2895 struct posix_acl_entry *pa, *pe; 2896 2897 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION) 2898 return -EOPNOTSUPP; 2899 2900 if (acl_type == ACL_TYPE_ACCESS) { 2901 count = le16_to_cpu(cifs_acl->access_entry_count); 2902 pACE = &cifs_acl->ace_array[0]; 2903 size = sizeof(struct cifs_posix_acl); 2904 size += sizeof(struct cifs_posix_ace) * count; 2905 /* check if we would go beyond end of SMB */ 2906 if (size_of_data_area < size) { 2907 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n", 2908 size_of_data_area, size); 2909 return -EINVAL; 2910 } 2911 } else if (acl_type == ACL_TYPE_DEFAULT) { 2912 count = le16_to_cpu(cifs_acl->access_entry_count); 2913 size = sizeof(struct cifs_posix_acl); 2914 size += sizeof(struct cifs_posix_ace) * count; 2915 /* skip past access ACEs to get to default ACEs */ 2916 pACE = &cifs_acl->ace_array[count]; 2917 count = le16_to_cpu(cifs_acl->default_entry_count); 2918 size += sizeof(struct cifs_posix_ace) * count; 2919 /* check if we would go beyond end of SMB */ 2920 if (size_of_data_area < size) 2921 return -EINVAL; 2922 } else { 2923 /* illegal type */ 2924 return -EINVAL; 2925 } 2926 2927 /* Allocate number of POSIX ACLs to store in VFS format. */ 2928 kacl = posix_acl_alloc(count, GFP_NOFS); 2929 if (!kacl) 2930 return -ENOMEM; 2931 2932 FOREACH_ACL_ENTRY(pa, kacl, pe) { 2933 cifs_init_posix_acl(pa, pACE); 2934 pACE++; 2935 } 2936 2937 *acl = kacl; 2938 return 0; 2939 } 2940 2941 /** 2942 * cifs_init_ace - convert ACL entry from POSIX ACL to cifs format 2943 * @cifs_ace: the cifs ACL entry to store into 2944 * @local_ace: the POSIX ACL entry to convert 2945 */ 2946 static void cifs_init_ace(struct cifs_posix_ace *cifs_ace, 2947 const struct posix_acl_entry *local_ace) 2948 { 2949 cifs_ace->cifs_e_perm = local_ace->e_perm; 2950 cifs_ace->cifs_e_tag = local_ace->e_tag; 2951 2952 switch (local_ace->e_tag) { 2953 case ACL_USER: 2954 cifs_ace->cifs_uid = 2955 cpu_to_le64(from_kuid(&init_user_ns, local_ace->e_uid)); 2956 break; 2957 case ACL_GROUP: 2958 cifs_ace->cifs_uid = 2959 cpu_to_le64(from_kgid(&init_user_ns, local_ace->e_gid)); 2960 break; 2961 default: 2962 cifs_ace->cifs_uid = cpu_to_le64(-1); 2963 } 2964 } 2965 2966 /** 2967 * posix_acl_to_cifs - convert ACLs from POSIX ACL to cifs format 2968 * @parm_data: ACLs in cifs format to conver to 2969 * @acl: ACLs in POSIX ACL format to convert from 2970 * @acl_type: the type of POSIX ACLs stored in @acl 2971 * 2972 * Return: the number cifs ACL entries after conversion 2973 */ 2974 static __u16 posix_acl_to_cifs(char *parm_data, const struct posix_acl *acl, 2975 const int acl_type) 2976 { 2977 __u16 rc = 0; 2978 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data; 2979 const struct posix_acl_entry *pa, *pe; 2980 int count; 2981 int i = 0; 2982 2983 if ((acl == NULL) || (cifs_acl == NULL)) 2984 return 0; 2985 2986 count = acl->a_count; 2987 cifs_dbg(FYI, "setting acl with %d entries\n", count); 2988 2989 /* 2990 * Note that the uapi POSIX ACL version is verified by the VFS and is 2991 * independent of the cifs ACL version. Changing the POSIX ACL version 2992 * is a uapi change and if it's changed we will pass down the POSIX ACL 2993 * version in struct posix_acl from the VFS. For now there's really 2994 * only one that all filesystems know how to deal with. 2995 */ 2996 cifs_acl->version = cpu_to_le16(1); 2997 if (acl_type == ACL_TYPE_ACCESS) { 2998 cifs_acl->access_entry_count = cpu_to_le16(count); 2999 cifs_acl->default_entry_count = cpu_to_le16(0xFFFF); 3000 } else if (acl_type == ACL_TYPE_DEFAULT) { 3001 cifs_acl->default_entry_count = cpu_to_le16(count); 3002 cifs_acl->access_entry_count = cpu_to_le16(0xFFFF); 3003 } else { 3004 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type); 3005 return 0; 3006 } 3007 FOREACH_ACL_ENTRY(pa, acl, pe) { 3008 cifs_init_ace(&cifs_acl->ace_array[i++], pa); 3009 } 3010 if (rc == 0) { 3011 rc = (__u16)(count * sizeof(struct cifs_posix_ace)); 3012 rc += sizeof(struct cifs_posix_acl); 3013 /* BB add check to make sure ACL does not overflow SMB */ 3014 } 3015 return rc; 3016 } 3017 3018 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon, 3019 const unsigned char *searchName, struct posix_acl **acl, 3020 const int acl_type, const struct nls_table *nls_codepage, 3021 int remap) 3022 { 3023 /* SMB_QUERY_POSIX_ACL */ 3024 TRANSACTION2_QPI_REQ *pSMB = NULL; 3025 TRANSACTION2_QPI_RSP *pSMBr = NULL; 3026 int rc = 0; 3027 int bytes_returned; 3028 int name_len; 3029 __u16 params, byte_count; 3030 3031 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName); 3032 3033 queryAclRetry: 3034 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3035 (void **) &pSMBr); 3036 if (rc) 3037 return rc; 3038 3039 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3040 name_len = 3041 cifsConvertToUTF16((__le16 *) pSMB->FileName, 3042 searchName, PATH_MAX, nls_codepage, 3043 remap); 3044 name_len++; /* trailing null */ 3045 name_len *= 2; 3046 pSMB->FileName[name_len] = 0; 3047 pSMB->FileName[name_len+1] = 0; 3048 } else { 3049 name_len = copy_path_name(pSMB->FileName, searchName); 3050 } 3051 3052 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ; 3053 pSMB->TotalDataCount = 0; 3054 pSMB->MaxParameterCount = cpu_to_le16(2); 3055 /* BB find exact max data count below from sess structure BB */ 3056 pSMB->MaxDataCount = cpu_to_le16(4000); 3057 pSMB->MaxSetupCount = 0; 3058 pSMB->Reserved = 0; 3059 pSMB->Flags = 0; 3060 pSMB->Timeout = 0; 3061 pSMB->Reserved2 = 0; 3062 pSMB->ParameterOffset = cpu_to_le16( 3063 offsetof(struct smb_com_transaction2_qpi_req, 3064 InformationLevel) - 4); 3065 pSMB->DataCount = 0; 3066 pSMB->DataOffset = 0; 3067 pSMB->SetupCount = 1; 3068 pSMB->Reserved3 = 0; 3069 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 3070 byte_count = params + 1 /* pad */ ; 3071 pSMB->TotalParameterCount = cpu_to_le16(params); 3072 pSMB->ParameterCount = pSMB->TotalParameterCount; 3073 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL); 3074 pSMB->Reserved4 = 0; 3075 inc_rfc1001_len(pSMB, byte_count); 3076 pSMB->ByteCount = cpu_to_le16(byte_count); 3077 3078 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3079 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3080 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get); 3081 if (rc) { 3082 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc); 3083 } else { 3084 /* decode response */ 3085 3086 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3087 /* BB also check enough total bytes returned */ 3088 if (rc || get_bcc(&pSMBr->hdr) < 2) 3089 rc = -EIO; /* bad smb */ 3090 else { 3091 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3092 __u16 count = le16_to_cpu(pSMBr->t2.DataCount); 3093 rc = cifs_to_posix_acl(acl, 3094 (char *)&pSMBr->hdr.Protocol+data_offset, 3095 acl_type, count); 3096 } 3097 } 3098 cifs_buf_release(pSMB); 3099 /* 3100 * The else branch after SendReceive() doesn't return EAGAIN so if we 3101 * allocated @acl in cifs_to_posix_acl() we are guaranteed to return 3102 * here and don't leak POSIX ACLs. 3103 */ 3104 if (rc == -EAGAIN) 3105 goto queryAclRetry; 3106 return rc; 3107 } 3108 3109 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 3110 const unsigned char *fileName, const struct posix_acl *acl, 3111 const int acl_type, const struct nls_table *nls_codepage, 3112 int remap) 3113 { 3114 struct smb_com_transaction2_spi_req *pSMB = NULL; 3115 struct smb_com_transaction2_spi_rsp *pSMBr = NULL; 3116 char *parm_data; 3117 int name_len; 3118 int rc = 0; 3119 int bytes_returned = 0; 3120 __u16 params, byte_count, data_count, param_offset, offset; 3121 3122 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName); 3123 setAclRetry: 3124 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3125 (void **) &pSMBr); 3126 if (rc) 3127 return rc; 3128 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3129 name_len = 3130 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 3131 PATH_MAX, nls_codepage, remap); 3132 name_len++; /* trailing null */ 3133 name_len *= 2; 3134 } else { 3135 name_len = copy_path_name(pSMB->FileName, fileName); 3136 } 3137 params = 6 + name_len; 3138 pSMB->MaxParameterCount = cpu_to_le16(2); 3139 /* BB find max SMB size from sess */ 3140 pSMB->MaxDataCount = cpu_to_le16(1000); 3141 pSMB->MaxSetupCount = 0; 3142 pSMB->Reserved = 0; 3143 pSMB->Flags = 0; 3144 pSMB->Timeout = 0; 3145 pSMB->Reserved2 = 0; 3146 param_offset = offsetof(struct smb_com_transaction2_spi_req, 3147 InformationLevel) - 4; 3148 offset = param_offset + params; 3149 parm_data = ((char *)pSMB) + sizeof(pSMB->hdr.smb_buf_length) + offset; 3150 pSMB->ParameterOffset = cpu_to_le16(param_offset); 3151 3152 /* convert to on the wire format for POSIX ACL */ 3153 data_count = posix_acl_to_cifs(parm_data, acl, acl_type); 3154 3155 if (data_count == 0) { 3156 rc = -EOPNOTSUPP; 3157 goto setACLerrorExit; 3158 } 3159 pSMB->DataOffset = cpu_to_le16(offset); 3160 pSMB->SetupCount = 1; 3161 pSMB->Reserved3 = 0; 3162 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 3163 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL); 3164 byte_count = 3 /* pad */ + params + data_count; 3165 pSMB->DataCount = cpu_to_le16(data_count); 3166 pSMB->TotalDataCount = pSMB->DataCount; 3167 pSMB->ParameterCount = cpu_to_le16(params); 3168 pSMB->TotalParameterCount = pSMB->ParameterCount; 3169 pSMB->Reserved4 = 0; 3170 inc_rfc1001_len(pSMB, byte_count); 3171 pSMB->ByteCount = cpu_to_le16(byte_count); 3172 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3173 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3174 if (rc) 3175 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc); 3176 3177 setACLerrorExit: 3178 cifs_buf_release(pSMB); 3179 if (rc == -EAGAIN) 3180 goto setAclRetry; 3181 return rc; 3182 } 3183 #else 3184 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon, 3185 const unsigned char *searchName, struct posix_acl **acl, 3186 const int acl_type, const struct nls_table *nls_codepage, 3187 int remap) 3188 { 3189 return -EOPNOTSUPP; 3190 } 3191 3192 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 3193 const unsigned char *fileName, const struct posix_acl *acl, 3194 const int acl_type, const struct nls_table *nls_codepage, 3195 int remap) 3196 { 3197 return -EOPNOTSUPP; 3198 } 3199 #endif /* CONFIG_FS_POSIX_ACL */ 3200 3201 int 3202 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon, 3203 const int netfid, __u64 *pExtAttrBits, __u64 *pMask) 3204 { 3205 int rc = 0; 3206 struct smb_t2_qfi_req *pSMB = NULL; 3207 struct smb_t2_qfi_rsp *pSMBr = NULL; 3208 int bytes_returned; 3209 __u16 params, byte_count; 3210 3211 cifs_dbg(FYI, "In GetExtAttr\n"); 3212 if (tcon == NULL) 3213 return -ENODEV; 3214 3215 GetExtAttrRetry: 3216 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3217 (void **) &pSMBr); 3218 if (rc) 3219 return rc; 3220 3221 params = 2 /* level */ + 2 /* fid */; 3222 pSMB->t2.TotalDataCount = 0; 3223 pSMB->t2.MaxParameterCount = cpu_to_le16(4); 3224 /* BB find exact max data count below from sess structure BB */ 3225 pSMB->t2.MaxDataCount = cpu_to_le16(4000); 3226 pSMB->t2.MaxSetupCount = 0; 3227 pSMB->t2.Reserved = 0; 3228 pSMB->t2.Flags = 0; 3229 pSMB->t2.Timeout = 0; 3230 pSMB->t2.Reserved2 = 0; 3231 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req, 3232 Fid) - 4); 3233 pSMB->t2.DataCount = 0; 3234 pSMB->t2.DataOffset = 0; 3235 pSMB->t2.SetupCount = 1; 3236 pSMB->t2.Reserved3 = 0; 3237 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 3238 byte_count = params + 1 /* pad */ ; 3239 pSMB->t2.TotalParameterCount = cpu_to_le16(params); 3240 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount; 3241 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS); 3242 pSMB->Pad = 0; 3243 pSMB->Fid = netfid; 3244 inc_rfc1001_len(pSMB, byte_count); 3245 pSMB->t2.ByteCount = cpu_to_le16(byte_count); 3246 3247 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3248 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3249 if (rc) { 3250 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc); 3251 } else { 3252 /* decode response */ 3253 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3254 /* BB also check enough total bytes returned */ 3255 if (rc || get_bcc(&pSMBr->hdr) < 2) 3256 /* If rc should we check for EOPNOSUPP and 3257 disable the srvino flag? or in caller? */ 3258 rc = -EIO; /* bad smb */ 3259 else { 3260 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3261 __u16 count = le16_to_cpu(pSMBr->t2.DataCount); 3262 struct file_chattr_info *pfinfo; 3263 3264 if (count != 16) { 3265 cifs_dbg(FYI, "Invalid size ret in GetExtAttr\n"); 3266 rc = -EIO; 3267 goto GetExtAttrOut; 3268 } 3269 pfinfo = (struct file_chattr_info *) 3270 (data_offset + (char *) &pSMBr->hdr.Protocol); 3271 *pExtAttrBits = le64_to_cpu(pfinfo->mode); 3272 *pMask = le64_to_cpu(pfinfo->mask); 3273 } 3274 } 3275 GetExtAttrOut: 3276 cifs_buf_release(pSMB); 3277 if (rc == -EAGAIN) 3278 goto GetExtAttrRetry; 3279 return rc; 3280 } 3281 3282 #endif /* CONFIG_POSIX */ 3283 3284 /* 3285 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that 3286 * all NT TRANSACTS that we init here have total parm and data under about 400 3287 * bytes (to fit in small cifs buffer size), which is the case so far, it 3288 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of 3289 * returned setup area) and MaxParameterCount (returned parms size) must be set 3290 * by caller 3291 */ 3292 static int 3293 smb_init_nttransact(const __u16 sub_command, const int setup_count, 3294 const int parm_len, struct cifs_tcon *tcon, 3295 void **ret_buf) 3296 { 3297 int rc; 3298 __u32 temp_offset; 3299 struct smb_com_ntransact_req *pSMB; 3300 3301 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon, 3302 (void **)&pSMB); 3303 if (rc) 3304 return rc; 3305 *ret_buf = (void *)pSMB; 3306 pSMB->Reserved = 0; 3307 pSMB->TotalParameterCount = cpu_to_le32(parm_len); 3308 pSMB->TotalDataCount = 0; 3309 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00); 3310 pSMB->ParameterCount = pSMB->TotalParameterCount; 3311 pSMB->DataCount = pSMB->TotalDataCount; 3312 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) + 3313 (setup_count * 2) - 4 /* for rfc1001 length itself */; 3314 pSMB->ParameterOffset = cpu_to_le32(temp_offset); 3315 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len); 3316 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */ 3317 pSMB->SubCommand = cpu_to_le16(sub_command); 3318 return 0; 3319 } 3320 3321 static int 3322 validate_ntransact(char *buf, char **ppparm, char **ppdata, 3323 __u32 *pparmlen, __u32 *pdatalen) 3324 { 3325 char *end_of_smb; 3326 __u32 data_count, data_offset, parm_count, parm_offset; 3327 struct smb_com_ntransact_rsp *pSMBr; 3328 u16 bcc; 3329 3330 *pdatalen = 0; 3331 *pparmlen = 0; 3332 3333 if (buf == NULL) 3334 return -EINVAL; 3335 3336 pSMBr = (struct smb_com_ntransact_rsp *)buf; 3337 3338 bcc = get_bcc(&pSMBr->hdr); 3339 end_of_smb = 2 /* sizeof byte count */ + bcc + 3340 (char *)&pSMBr->ByteCount; 3341 3342 data_offset = le32_to_cpu(pSMBr->DataOffset); 3343 data_count = le32_to_cpu(pSMBr->DataCount); 3344 parm_offset = le32_to_cpu(pSMBr->ParameterOffset); 3345 parm_count = le32_to_cpu(pSMBr->ParameterCount); 3346 3347 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset; 3348 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset; 3349 3350 /* should we also check that parm and data areas do not overlap? */ 3351 if (*ppparm > end_of_smb) { 3352 cifs_dbg(FYI, "parms start after end of smb\n"); 3353 return -EINVAL; 3354 } else if (parm_count + *ppparm > end_of_smb) { 3355 cifs_dbg(FYI, "parm end after end of smb\n"); 3356 return -EINVAL; 3357 } else if (*ppdata > end_of_smb) { 3358 cifs_dbg(FYI, "data starts after end of smb\n"); 3359 return -EINVAL; 3360 } else if (data_count + *ppdata > end_of_smb) { 3361 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n", 3362 *ppdata, data_count, (data_count + *ppdata), 3363 end_of_smb, pSMBr); 3364 return -EINVAL; 3365 } else if (parm_count + data_count > bcc) { 3366 cifs_dbg(FYI, "parm count and data count larger than SMB\n"); 3367 return -EINVAL; 3368 } 3369 *pdatalen = data_count; 3370 *pparmlen = parm_count; 3371 return 0; 3372 } 3373 3374 /* Get Security Descriptor (by handle) from remote server for a file or dir */ 3375 int 3376 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid, 3377 struct cifs_ntsd **acl_inf, __u32 *pbuflen) 3378 { 3379 int rc = 0; 3380 int buf_type = 0; 3381 QUERY_SEC_DESC_REQ *pSMB; 3382 struct kvec iov[1]; 3383 struct kvec rsp_iov; 3384 3385 cifs_dbg(FYI, "GetCifsACL\n"); 3386 3387 *pbuflen = 0; 3388 *acl_inf = NULL; 3389 3390 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0, 3391 8 /* parm len */, tcon, (void **) &pSMB); 3392 if (rc) 3393 return rc; 3394 3395 pSMB->MaxParameterCount = cpu_to_le32(4); 3396 /* BB TEST with big acls that might need to be e.g. larger than 16K */ 3397 pSMB->MaxSetupCount = 0; 3398 pSMB->Fid = fid; /* file handle always le */ 3399 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP | 3400 CIFS_ACL_DACL); 3401 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */ 3402 inc_rfc1001_len(pSMB, 11); 3403 iov[0].iov_base = (char *)pSMB; 3404 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4; 3405 3406 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type, 3407 0, &rsp_iov); 3408 cifs_small_buf_release(pSMB); 3409 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get); 3410 if (rc) { 3411 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc); 3412 } else { /* decode response */ 3413 __le32 *parm; 3414 __u32 parm_len; 3415 __u32 acl_len; 3416 struct smb_com_ntransact_rsp *pSMBr; 3417 char *pdata; 3418 3419 /* validate_nttransact */ 3420 rc = validate_ntransact(rsp_iov.iov_base, (char **)&parm, 3421 &pdata, &parm_len, pbuflen); 3422 if (rc) 3423 goto qsec_out; 3424 pSMBr = (struct smb_com_ntransact_rsp *)rsp_iov.iov_base; 3425 3426 cifs_dbg(FYI, "smb %p parm %p data %p\n", 3427 pSMBr, parm, *acl_inf); 3428 3429 if (le32_to_cpu(pSMBr->ParameterCount) != 4) { 3430 rc = -EIO; /* bad smb */ 3431 *pbuflen = 0; 3432 goto qsec_out; 3433 } 3434 3435 /* BB check that data area is minimum length and as big as acl_len */ 3436 3437 acl_len = le32_to_cpu(*parm); 3438 if (acl_len != *pbuflen) { 3439 cifs_dbg(VFS, "acl length %d does not match %d\n", 3440 acl_len, *pbuflen); 3441 if (*pbuflen > acl_len) 3442 *pbuflen = acl_len; 3443 } 3444 3445 /* check if buffer is big enough for the acl 3446 header followed by the smallest SID */ 3447 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) || 3448 (*pbuflen >= 64 * 1024)) { 3449 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen); 3450 rc = -EINVAL; 3451 *pbuflen = 0; 3452 } else { 3453 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL); 3454 if (*acl_inf == NULL) { 3455 *pbuflen = 0; 3456 rc = -ENOMEM; 3457 } 3458 } 3459 } 3460 qsec_out: 3461 free_rsp_buf(buf_type, rsp_iov.iov_base); 3462 return rc; 3463 } 3464 3465 int 3466 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid, 3467 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag) 3468 { 3469 __u16 byte_count, param_count, data_count, param_offset, data_offset; 3470 int rc = 0; 3471 int bytes_returned = 0; 3472 SET_SEC_DESC_REQ *pSMB = NULL; 3473 void *pSMBr; 3474 3475 setCifsAclRetry: 3476 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr); 3477 if (rc) 3478 return rc; 3479 3480 pSMB->MaxSetupCount = 0; 3481 pSMB->Reserved = 0; 3482 3483 param_count = 8; 3484 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4; 3485 data_count = acllen; 3486 data_offset = param_offset + param_count; 3487 byte_count = 3 /* pad */ + param_count; 3488 3489 pSMB->DataCount = cpu_to_le32(data_count); 3490 pSMB->TotalDataCount = pSMB->DataCount; 3491 pSMB->MaxParameterCount = cpu_to_le32(4); 3492 pSMB->MaxDataCount = cpu_to_le32(16384); 3493 pSMB->ParameterCount = cpu_to_le32(param_count); 3494 pSMB->ParameterOffset = cpu_to_le32(param_offset); 3495 pSMB->TotalParameterCount = pSMB->ParameterCount; 3496 pSMB->DataOffset = cpu_to_le32(data_offset); 3497 pSMB->SetupCount = 0; 3498 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC); 3499 pSMB->ByteCount = cpu_to_le16(byte_count+data_count); 3500 3501 pSMB->Fid = fid; /* file handle always le */ 3502 pSMB->Reserved2 = 0; 3503 pSMB->AclFlags = cpu_to_le32(aclflag); 3504 3505 if (pntsd && acllen) { 3506 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) + 3507 data_offset, pntsd, acllen); 3508 inc_rfc1001_len(pSMB, byte_count + data_count); 3509 } else 3510 inc_rfc1001_len(pSMB, byte_count); 3511 3512 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3513 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3514 3515 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n", 3516 bytes_returned, rc); 3517 if (rc) 3518 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc); 3519 cifs_buf_release(pSMB); 3520 3521 if (rc == -EAGAIN) 3522 goto setCifsAclRetry; 3523 3524 return (rc); 3525 } 3526 3527 3528 /* Legacy Query Path Information call for lookup to old servers such 3529 as Win9x/WinME */ 3530 int 3531 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon, 3532 const char *search_name, FILE_ALL_INFO *data, 3533 const struct nls_table *nls_codepage, int remap) 3534 { 3535 QUERY_INFORMATION_REQ *pSMB; 3536 QUERY_INFORMATION_RSP *pSMBr; 3537 int rc = 0; 3538 int bytes_returned; 3539 int name_len; 3540 3541 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name); 3542 QInfRetry: 3543 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB, 3544 (void **) &pSMBr); 3545 if (rc) 3546 return rc; 3547 3548 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3549 name_len = 3550 cifsConvertToUTF16((__le16 *) pSMB->FileName, 3551 search_name, PATH_MAX, nls_codepage, 3552 remap); 3553 name_len++; /* trailing null */ 3554 name_len *= 2; 3555 } else { 3556 name_len = copy_path_name(pSMB->FileName, search_name); 3557 } 3558 pSMB->BufferFormat = 0x04; 3559 name_len++; /* account for buffer type byte */ 3560 inc_rfc1001_len(pSMB, (__u16)name_len); 3561 pSMB->ByteCount = cpu_to_le16(name_len); 3562 3563 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3564 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3565 if (rc) { 3566 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc); 3567 } else if (data) { 3568 struct timespec64 ts; 3569 __u32 time = le32_to_cpu(pSMBr->last_write_time); 3570 3571 /* decode response */ 3572 /* BB FIXME - add time zone adjustment BB */ 3573 memset(data, 0, sizeof(FILE_ALL_INFO)); 3574 ts.tv_nsec = 0; 3575 ts.tv_sec = time; 3576 /* decode time fields */ 3577 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts)); 3578 data->LastWriteTime = data->ChangeTime; 3579 data->LastAccessTime = 0; 3580 data->AllocationSize = 3581 cpu_to_le64(le32_to_cpu(pSMBr->size)); 3582 data->EndOfFile = data->AllocationSize; 3583 data->Attributes = 3584 cpu_to_le32(le16_to_cpu(pSMBr->attr)); 3585 } else 3586 rc = -EIO; /* bad buffer passed in */ 3587 3588 cifs_buf_release(pSMB); 3589 3590 if (rc == -EAGAIN) 3591 goto QInfRetry; 3592 3593 return rc; 3594 } 3595 3596 int 3597 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 3598 u16 netfid, FILE_ALL_INFO *pFindData) 3599 { 3600 struct smb_t2_qfi_req *pSMB = NULL; 3601 struct smb_t2_qfi_rsp *pSMBr = NULL; 3602 int rc = 0; 3603 int bytes_returned; 3604 __u16 params, byte_count; 3605 3606 QFileInfoRetry: 3607 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3608 (void **) &pSMBr); 3609 if (rc) 3610 return rc; 3611 3612 params = 2 /* level */ + 2 /* fid */; 3613 pSMB->t2.TotalDataCount = 0; 3614 pSMB->t2.MaxParameterCount = cpu_to_le16(4); 3615 /* BB find exact max data count below from sess structure BB */ 3616 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 3617 pSMB->t2.MaxSetupCount = 0; 3618 pSMB->t2.Reserved = 0; 3619 pSMB->t2.Flags = 0; 3620 pSMB->t2.Timeout = 0; 3621 pSMB->t2.Reserved2 = 0; 3622 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req, 3623 Fid) - 4); 3624 pSMB->t2.DataCount = 0; 3625 pSMB->t2.DataOffset = 0; 3626 pSMB->t2.SetupCount = 1; 3627 pSMB->t2.Reserved3 = 0; 3628 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 3629 byte_count = params + 1 /* pad */ ; 3630 pSMB->t2.TotalParameterCount = cpu_to_le16(params); 3631 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount; 3632 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO); 3633 pSMB->Pad = 0; 3634 pSMB->Fid = netfid; 3635 inc_rfc1001_len(pSMB, byte_count); 3636 pSMB->t2.ByteCount = cpu_to_le16(byte_count); 3637 3638 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3639 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3640 if (rc) { 3641 cifs_dbg(FYI, "Send error in QFileInfo = %d\n", rc); 3642 } else { /* decode response */ 3643 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3644 3645 if (rc) /* BB add auto retry on EOPNOTSUPP? */ 3646 rc = -EIO; 3647 else if (get_bcc(&pSMBr->hdr) < 40) 3648 rc = -EIO; /* bad smb */ 3649 else if (pFindData) { 3650 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3651 memcpy((char *) pFindData, 3652 (char *) &pSMBr->hdr.Protocol + 3653 data_offset, sizeof(FILE_ALL_INFO)); 3654 } else 3655 rc = -ENOMEM; 3656 } 3657 cifs_buf_release(pSMB); 3658 if (rc == -EAGAIN) 3659 goto QFileInfoRetry; 3660 3661 return rc; 3662 } 3663 3664 int 3665 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 3666 const char *search_name, FILE_ALL_INFO *data, 3667 int legacy /* old style infolevel */, 3668 const struct nls_table *nls_codepage, int remap) 3669 { 3670 /* level 263 SMB_QUERY_FILE_ALL_INFO */ 3671 TRANSACTION2_QPI_REQ *pSMB = NULL; 3672 TRANSACTION2_QPI_RSP *pSMBr = NULL; 3673 int rc = 0; 3674 int bytes_returned; 3675 int name_len; 3676 __u16 params, byte_count; 3677 3678 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */ 3679 QPathInfoRetry: 3680 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3681 (void **) &pSMBr); 3682 if (rc) 3683 return rc; 3684 3685 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3686 name_len = 3687 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name, 3688 PATH_MAX, nls_codepage, remap); 3689 name_len++; /* trailing null */ 3690 name_len *= 2; 3691 } else { 3692 name_len = copy_path_name(pSMB->FileName, search_name); 3693 } 3694 3695 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */; 3696 pSMB->TotalDataCount = 0; 3697 pSMB->MaxParameterCount = cpu_to_le16(2); 3698 /* BB find exact max SMB PDU from sess structure BB */ 3699 pSMB->MaxDataCount = cpu_to_le16(4000); 3700 pSMB->MaxSetupCount = 0; 3701 pSMB->Reserved = 0; 3702 pSMB->Flags = 0; 3703 pSMB->Timeout = 0; 3704 pSMB->Reserved2 = 0; 3705 pSMB->ParameterOffset = cpu_to_le16(offsetof( 3706 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 3707 pSMB->DataCount = 0; 3708 pSMB->DataOffset = 0; 3709 pSMB->SetupCount = 1; 3710 pSMB->Reserved3 = 0; 3711 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 3712 byte_count = params + 1 /* pad */ ; 3713 pSMB->TotalParameterCount = cpu_to_le16(params); 3714 pSMB->ParameterCount = pSMB->TotalParameterCount; 3715 if (legacy) 3716 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD); 3717 else 3718 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO); 3719 pSMB->Reserved4 = 0; 3720 inc_rfc1001_len(pSMB, byte_count); 3721 pSMB->ByteCount = cpu_to_le16(byte_count); 3722 3723 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3724 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3725 if (rc) { 3726 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc); 3727 } else { /* decode response */ 3728 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3729 3730 if (rc) /* BB add auto retry on EOPNOTSUPP? */ 3731 rc = -EIO; 3732 else if (!legacy && get_bcc(&pSMBr->hdr) < 40) 3733 rc = -EIO; /* bad smb */ 3734 else if (legacy && get_bcc(&pSMBr->hdr) < 24) 3735 rc = -EIO; /* 24 or 26 expected but we do not read 3736 last field */ 3737 else if (data) { 3738 int size; 3739 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3740 3741 /* 3742 * On legacy responses we do not read the last field, 3743 * EAsize, fortunately since it varies by subdialect and 3744 * also note it differs on Set vs Get, ie two bytes or 4 3745 * bytes depending but we don't care here. 3746 */ 3747 if (legacy) 3748 size = sizeof(FILE_INFO_STANDARD); 3749 else 3750 size = sizeof(FILE_ALL_INFO); 3751 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol + 3752 data_offset, size); 3753 } else 3754 rc = -ENOMEM; 3755 } 3756 cifs_buf_release(pSMB); 3757 if (rc == -EAGAIN) 3758 goto QPathInfoRetry; 3759 3760 return rc; 3761 } 3762 3763 int 3764 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 3765 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData) 3766 { 3767 struct smb_t2_qfi_req *pSMB = NULL; 3768 struct smb_t2_qfi_rsp *pSMBr = NULL; 3769 int rc = 0; 3770 int bytes_returned; 3771 __u16 params, byte_count; 3772 3773 UnixQFileInfoRetry: 3774 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3775 (void **) &pSMBr); 3776 if (rc) 3777 return rc; 3778 3779 params = 2 /* level */ + 2 /* fid */; 3780 pSMB->t2.TotalDataCount = 0; 3781 pSMB->t2.MaxParameterCount = cpu_to_le16(4); 3782 /* BB find exact max data count below from sess structure BB */ 3783 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 3784 pSMB->t2.MaxSetupCount = 0; 3785 pSMB->t2.Reserved = 0; 3786 pSMB->t2.Flags = 0; 3787 pSMB->t2.Timeout = 0; 3788 pSMB->t2.Reserved2 = 0; 3789 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req, 3790 Fid) - 4); 3791 pSMB->t2.DataCount = 0; 3792 pSMB->t2.DataOffset = 0; 3793 pSMB->t2.SetupCount = 1; 3794 pSMB->t2.Reserved3 = 0; 3795 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 3796 byte_count = params + 1 /* pad */ ; 3797 pSMB->t2.TotalParameterCount = cpu_to_le16(params); 3798 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount; 3799 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC); 3800 pSMB->Pad = 0; 3801 pSMB->Fid = netfid; 3802 inc_rfc1001_len(pSMB, byte_count); 3803 pSMB->t2.ByteCount = cpu_to_le16(byte_count); 3804 3805 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3806 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3807 if (rc) { 3808 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d\n", rc); 3809 } else { /* decode response */ 3810 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3811 3812 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) { 3813 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n"); 3814 rc = -EIO; /* bad smb */ 3815 } else { 3816 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3817 memcpy((char *) pFindData, 3818 (char *) &pSMBr->hdr.Protocol + 3819 data_offset, 3820 sizeof(FILE_UNIX_BASIC_INFO)); 3821 } 3822 } 3823 3824 cifs_buf_release(pSMB); 3825 if (rc == -EAGAIN) 3826 goto UnixQFileInfoRetry; 3827 3828 return rc; 3829 } 3830 3831 int 3832 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 3833 const unsigned char *searchName, 3834 FILE_UNIX_BASIC_INFO *pFindData, 3835 const struct nls_table *nls_codepage, int remap) 3836 { 3837 /* SMB_QUERY_FILE_UNIX_BASIC */ 3838 TRANSACTION2_QPI_REQ *pSMB = NULL; 3839 TRANSACTION2_QPI_RSP *pSMBr = NULL; 3840 int rc = 0; 3841 int bytes_returned = 0; 3842 int name_len; 3843 __u16 params, byte_count; 3844 3845 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName); 3846 UnixQPathInfoRetry: 3847 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3848 (void **) &pSMBr); 3849 if (rc) 3850 return rc; 3851 3852 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3853 name_len = 3854 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName, 3855 PATH_MAX, nls_codepage, remap); 3856 name_len++; /* trailing null */ 3857 name_len *= 2; 3858 } else { 3859 name_len = copy_path_name(pSMB->FileName, searchName); 3860 } 3861 3862 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */; 3863 pSMB->TotalDataCount = 0; 3864 pSMB->MaxParameterCount = cpu_to_le16(2); 3865 /* BB find exact max SMB PDU from sess structure BB */ 3866 pSMB->MaxDataCount = cpu_to_le16(4000); 3867 pSMB->MaxSetupCount = 0; 3868 pSMB->Reserved = 0; 3869 pSMB->Flags = 0; 3870 pSMB->Timeout = 0; 3871 pSMB->Reserved2 = 0; 3872 pSMB->ParameterOffset = cpu_to_le16(offsetof( 3873 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 3874 pSMB->DataCount = 0; 3875 pSMB->DataOffset = 0; 3876 pSMB->SetupCount = 1; 3877 pSMB->Reserved3 = 0; 3878 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 3879 byte_count = params + 1 /* pad */ ; 3880 pSMB->TotalParameterCount = cpu_to_le16(params); 3881 pSMB->ParameterCount = pSMB->TotalParameterCount; 3882 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC); 3883 pSMB->Reserved4 = 0; 3884 inc_rfc1001_len(pSMB, byte_count); 3885 pSMB->ByteCount = cpu_to_le16(byte_count); 3886 3887 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3888 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3889 if (rc) { 3890 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d\n", rc); 3891 } else { /* decode response */ 3892 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3893 3894 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) { 3895 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n"); 3896 rc = -EIO; /* bad smb */ 3897 } else { 3898 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3899 memcpy((char *) pFindData, 3900 (char *) &pSMBr->hdr.Protocol + 3901 data_offset, 3902 sizeof(FILE_UNIX_BASIC_INFO)); 3903 } 3904 } 3905 cifs_buf_release(pSMB); 3906 if (rc == -EAGAIN) 3907 goto UnixQPathInfoRetry; 3908 3909 return rc; 3910 } 3911 3912 /* xid, tcon, searchName and codepage are input parms, rest are returned */ 3913 int 3914 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon, 3915 const char *searchName, struct cifs_sb_info *cifs_sb, 3916 __u16 *pnetfid, __u16 search_flags, 3917 struct cifs_search_info *psrch_inf, bool msearch) 3918 { 3919 /* level 257 SMB_ */ 3920 TRANSACTION2_FFIRST_REQ *pSMB = NULL; 3921 TRANSACTION2_FFIRST_RSP *pSMBr = NULL; 3922 T2_FFIRST_RSP_PARMS *parms; 3923 struct nls_table *nls_codepage; 3924 unsigned int lnoff; 3925 __u16 params, byte_count; 3926 int bytes_returned = 0; 3927 int name_len, remap; 3928 int rc = 0; 3929 3930 cifs_dbg(FYI, "In FindFirst for %s\n", searchName); 3931 3932 findFirstRetry: 3933 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3934 (void **) &pSMBr); 3935 if (rc) 3936 return rc; 3937 3938 nls_codepage = cifs_sb->local_nls; 3939 remap = cifs_remap(cifs_sb); 3940 3941 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3942 name_len = 3943 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName, 3944 PATH_MAX, nls_codepage, remap); 3945 /* We can not add the asterik earlier in case 3946 it got remapped to 0xF03A as if it were part of the 3947 directory name instead of a wildcard */ 3948 name_len *= 2; 3949 if (msearch) { 3950 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb); 3951 pSMB->FileName[name_len+1] = 0; 3952 pSMB->FileName[name_len+2] = '*'; 3953 pSMB->FileName[name_len+3] = 0; 3954 name_len += 4; /* now the trailing null */ 3955 /* null terminate just in case */ 3956 pSMB->FileName[name_len] = 0; 3957 pSMB->FileName[name_len+1] = 0; 3958 name_len += 2; 3959 } 3960 } else { 3961 name_len = copy_path_name(pSMB->FileName, searchName); 3962 if (msearch) { 3963 if (WARN_ON_ONCE(name_len > PATH_MAX-2)) 3964 name_len = PATH_MAX-2; 3965 /* overwrite nul byte */ 3966 pSMB->FileName[name_len-1] = CIFS_DIR_SEP(cifs_sb); 3967 pSMB->FileName[name_len] = '*'; 3968 pSMB->FileName[name_len+1] = 0; 3969 name_len += 2; 3970 } 3971 } 3972 3973 params = 12 + name_len /* includes null */ ; 3974 pSMB->TotalDataCount = 0; /* no EAs */ 3975 pSMB->MaxParameterCount = cpu_to_le16(10); 3976 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00); 3977 pSMB->MaxSetupCount = 0; 3978 pSMB->Reserved = 0; 3979 pSMB->Flags = 0; 3980 pSMB->Timeout = 0; 3981 pSMB->Reserved2 = 0; 3982 byte_count = params + 1 /* pad */ ; 3983 pSMB->TotalParameterCount = cpu_to_le16(params); 3984 pSMB->ParameterCount = pSMB->TotalParameterCount; 3985 pSMB->ParameterOffset = cpu_to_le16( 3986 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes) 3987 - 4); 3988 pSMB->DataCount = 0; 3989 pSMB->DataOffset = 0; 3990 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */ 3991 pSMB->Reserved3 = 0; 3992 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST); 3993 pSMB->SearchAttributes = 3994 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM | 3995 ATTR_DIRECTORY); 3996 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO)); 3997 pSMB->SearchFlags = cpu_to_le16(search_flags); 3998 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level); 3999 4000 /* BB what should we set StorageType to? Does it matter? BB */ 4001 pSMB->SearchStorageType = 0; 4002 inc_rfc1001_len(pSMB, byte_count); 4003 pSMB->ByteCount = cpu_to_le16(byte_count); 4004 4005 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4006 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4007 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst); 4008 4009 if (rc) { 4010 /* 4011 * BB: add logic to retry regular search if Unix search rejected 4012 * unexpectedly by server. 4013 */ 4014 /* BB: add code to handle unsupported level rc */ 4015 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc); 4016 cifs_buf_release(pSMB); 4017 /* 4018 * BB: eventually could optimize out free and realloc of buf for 4019 * this case. 4020 */ 4021 if (rc == -EAGAIN) 4022 goto findFirstRetry; 4023 return rc; 4024 } 4025 /* decode response */ 4026 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4027 if (rc) { 4028 cifs_buf_release(pSMB); 4029 return rc; 4030 } 4031 4032 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE); 4033 psrch_inf->ntwrk_buf_start = (char *)pSMBr; 4034 psrch_inf->smallBuf = false; 4035 psrch_inf->srch_entries_start = (char *)&pSMBr->hdr.Protocol + 4036 le16_to_cpu(pSMBr->t2.DataOffset); 4037 4038 parms = (T2_FFIRST_RSP_PARMS *)((char *)&pSMBr->hdr.Protocol + 4039 le16_to_cpu(pSMBr->t2.ParameterOffset)); 4040 psrch_inf->endOfSearch = !!parms->EndofSearch; 4041 4042 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount); 4043 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ + 4044 psrch_inf->entries_in_buffer; 4045 lnoff = le16_to_cpu(parms->LastNameOffset); 4046 if (CIFSMaxBufSize < lnoff) { 4047 cifs_dbg(VFS, "ignoring corrupt resume name\n"); 4048 psrch_inf->last_entry = NULL; 4049 } else { 4050 psrch_inf->last_entry = psrch_inf->srch_entries_start + lnoff; 4051 if (pnetfid) 4052 *pnetfid = parms->SearchHandle; 4053 } 4054 return 0; 4055 } 4056 4057 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon, 4058 __u16 searchHandle, __u16 search_flags, 4059 struct cifs_search_info *psrch_inf) 4060 { 4061 TRANSACTION2_FNEXT_REQ *pSMB = NULL; 4062 TRANSACTION2_FNEXT_RSP *pSMBr = NULL; 4063 T2_FNEXT_RSP_PARMS *parms; 4064 unsigned int name_len; 4065 unsigned int lnoff; 4066 __u16 params, byte_count; 4067 char *response_data; 4068 int bytes_returned; 4069 int rc = 0; 4070 4071 cifs_dbg(FYI, "In FindNext\n"); 4072 4073 if (psrch_inf->endOfSearch) 4074 return -ENOENT; 4075 4076 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4077 (void **) &pSMBr); 4078 if (rc) 4079 return rc; 4080 4081 params = 14; /* includes 2 bytes of null string, converted to LE below*/ 4082 byte_count = 0; 4083 pSMB->TotalDataCount = 0; /* no EAs */ 4084 pSMB->MaxParameterCount = cpu_to_le16(8); 4085 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00); 4086 pSMB->MaxSetupCount = 0; 4087 pSMB->Reserved = 0; 4088 pSMB->Flags = 0; 4089 pSMB->Timeout = 0; 4090 pSMB->Reserved2 = 0; 4091 pSMB->ParameterOffset = cpu_to_le16( 4092 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4); 4093 pSMB->DataCount = 0; 4094 pSMB->DataOffset = 0; 4095 pSMB->SetupCount = 1; 4096 pSMB->Reserved3 = 0; 4097 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT); 4098 pSMB->SearchHandle = searchHandle; /* always kept as le */ 4099 pSMB->SearchCount = 4100 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO)); 4101 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level); 4102 pSMB->ResumeKey = psrch_inf->resume_key; 4103 pSMB->SearchFlags = cpu_to_le16(search_flags); 4104 4105 name_len = psrch_inf->resume_name_len; 4106 params += name_len; 4107 if (name_len < PATH_MAX) { 4108 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len); 4109 byte_count += name_len; 4110 /* 14 byte parm len above enough for 2 byte null terminator */ 4111 pSMB->ResumeFileName[name_len] = 0; 4112 pSMB->ResumeFileName[name_len+1] = 0; 4113 } else { 4114 cifs_buf_release(pSMB); 4115 return -EINVAL; 4116 } 4117 byte_count = params + 1 /* pad */ ; 4118 pSMB->TotalParameterCount = cpu_to_le16(params); 4119 pSMB->ParameterCount = pSMB->TotalParameterCount; 4120 inc_rfc1001_len(pSMB, byte_count); 4121 pSMB->ByteCount = cpu_to_le16(byte_count); 4122 4123 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4124 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4125 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext); 4126 4127 if (rc) { 4128 cifs_buf_release(pSMB); 4129 if (rc == -EBADF) { 4130 psrch_inf->endOfSearch = true; 4131 rc = 0; /* search probably was closed at end of search*/ 4132 } else { 4133 cifs_dbg(FYI, "FindNext returned = %d\n", rc); 4134 } 4135 return rc; 4136 } 4137 4138 /* decode response */ 4139 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4140 if (rc) { 4141 cifs_buf_release(pSMB); 4142 return rc; 4143 } 4144 /* BB fixme add lock for file (srch_info) struct here */ 4145 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE); 4146 response_data = (char *)&pSMBr->hdr.Protocol + 4147 le16_to_cpu(pSMBr->t2.ParameterOffset); 4148 parms = (T2_FNEXT_RSP_PARMS *)response_data; 4149 response_data = (char *)&pSMBr->hdr.Protocol + 4150 le16_to_cpu(pSMBr->t2.DataOffset); 4151 4152 if (psrch_inf->smallBuf) 4153 cifs_small_buf_release(psrch_inf->ntwrk_buf_start); 4154 else 4155 cifs_buf_release(psrch_inf->ntwrk_buf_start); 4156 4157 psrch_inf->srch_entries_start = response_data; 4158 psrch_inf->ntwrk_buf_start = (char *)pSMB; 4159 psrch_inf->smallBuf = false; 4160 psrch_inf->endOfSearch = !!parms->EndofSearch; 4161 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount); 4162 psrch_inf->index_of_last_entry += psrch_inf->entries_in_buffer; 4163 lnoff = le16_to_cpu(parms->LastNameOffset); 4164 if (CIFSMaxBufSize < lnoff) { 4165 cifs_dbg(VFS, "ignoring corrupt resume name\n"); 4166 psrch_inf->last_entry = NULL; 4167 } else { 4168 psrch_inf->last_entry = 4169 psrch_inf->srch_entries_start + lnoff; 4170 } 4171 /* BB fixme add unlock here */ 4172 4173 /* 4174 * BB: On error, should we leave previous search buf 4175 * (and count and last entry fields) intact or free the previous one? 4176 * 4177 * Note: On -EAGAIN error only caller can retry on handle based calls 4178 * since file handle passed in no longer valid. 4179 */ 4180 return 0; 4181 } 4182 4183 int 4184 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon, 4185 const __u16 searchHandle) 4186 { 4187 int rc = 0; 4188 FINDCLOSE_REQ *pSMB = NULL; 4189 4190 cifs_dbg(FYI, "In CIFSSMBFindClose\n"); 4191 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB); 4192 4193 /* no sense returning error if session restarted 4194 as file handle has been closed */ 4195 if (rc == -EAGAIN) 4196 return 0; 4197 if (rc) 4198 return rc; 4199 4200 pSMB->FileID = searchHandle; 4201 pSMB->ByteCount = 0; 4202 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 4203 cifs_small_buf_release(pSMB); 4204 if (rc) 4205 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc); 4206 4207 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose); 4208 4209 /* Since session is dead, search handle closed on server already */ 4210 if (rc == -EAGAIN) 4211 rc = 0; 4212 4213 return rc; 4214 } 4215 4216 int 4217 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon, 4218 const char *search_name, __u64 *inode_number, 4219 const struct nls_table *nls_codepage, int remap) 4220 { 4221 int rc = 0; 4222 TRANSACTION2_QPI_REQ *pSMB = NULL; 4223 TRANSACTION2_QPI_RSP *pSMBr = NULL; 4224 int name_len, bytes_returned; 4225 __u16 params, byte_count; 4226 4227 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name); 4228 if (tcon == NULL) 4229 return -ENODEV; 4230 4231 GetInodeNumberRetry: 4232 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4233 (void **) &pSMBr); 4234 if (rc) 4235 return rc; 4236 4237 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 4238 name_len = 4239 cifsConvertToUTF16((__le16 *) pSMB->FileName, 4240 search_name, PATH_MAX, nls_codepage, 4241 remap); 4242 name_len++; /* trailing null */ 4243 name_len *= 2; 4244 } else { 4245 name_len = copy_path_name(pSMB->FileName, search_name); 4246 } 4247 4248 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ; 4249 pSMB->TotalDataCount = 0; 4250 pSMB->MaxParameterCount = cpu_to_le16(2); 4251 /* BB find exact max data count below from sess structure BB */ 4252 pSMB->MaxDataCount = cpu_to_le16(4000); 4253 pSMB->MaxSetupCount = 0; 4254 pSMB->Reserved = 0; 4255 pSMB->Flags = 0; 4256 pSMB->Timeout = 0; 4257 pSMB->Reserved2 = 0; 4258 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4259 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 4260 pSMB->DataCount = 0; 4261 pSMB->DataOffset = 0; 4262 pSMB->SetupCount = 1; 4263 pSMB->Reserved3 = 0; 4264 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 4265 byte_count = params + 1 /* pad */ ; 4266 pSMB->TotalParameterCount = cpu_to_le16(params); 4267 pSMB->ParameterCount = pSMB->TotalParameterCount; 4268 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO); 4269 pSMB->Reserved4 = 0; 4270 inc_rfc1001_len(pSMB, byte_count); 4271 pSMB->ByteCount = cpu_to_le16(byte_count); 4272 4273 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4274 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4275 if (rc) { 4276 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc); 4277 } else { 4278 /* decode response */ 4279 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4280 /* BB also check enough total bytes returned */ 4281 if (rc || get_bcc(&pSMBr->hdr) < 2) 4282 /* If rc should we check for EOPNOSUPP and 4283 disable the srvino flag? or in caller? */ 4284 rc = -EIO; /* bad smb */ 4285 else { 4286 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4287 __u16 count = le16_to_cpu(pSMBr->t2.DataCount); 4288 struct file_internal_info *pfinfo; 4289 /* BB Do we need a cast or hash here ? */ 4290 if (count < 8) { 4291 cifs_dbg(FYI, "Invalid size ret in QryIntrnlInf\n"); 4292 rc = -EIO; 4293 goto GetInodeNumOut; 4294 } 4295 pfinfo = (struct file_internal_info *) 4296 (data_offset + (char *) &pSMBr->hdr.Protocol); 4297 *inode_number = le64_to_cpu(pfinfo->UniqueId); 4298 } 4299 } 4300 GetInodeNumOut: 4301 cifs_buf_release(pSMB); 4302 if (rc == -EAGAIN) 4303 goto GetInodeNumberRetry; 4304 return rc; 4305 } 4306 4307 int 4308 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses, 4309 const char *search_name, struct dfs_info3_param **target_nodes, 4310 unsigned int *num_of_nodes, 4311 const struct nls_table *nls_codepage, int remap) 4312 { 4313 /* TRANS2_GET_DFS_REFERRAL */ 4314 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL; 4315 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL; 4316 int rc = 0; 4317 int bytes_returned; 4318 int name_len; 4319 __u16 params, byte_count; 4320 *num_of_nodes = 0; 4321 *target_nodes = NULL; 4322 4323 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name); 4324 if (ses == NULL || ses->tcon_ipc == NULL) 4325 return -ENODEV; 4326 4327 getDFSRetry: 4328 /* 4329 * Use smb_init_no_reconnect() instead of smb_init() as 4330 * CIFSGetDFSRefer() may be called from cifs_reconnect_tcon() and thus 4331 * causing an infinite recursion. 4332 */ 4333 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, ses->tcon_ipc, 4334 (void **)&pSMB, (void **)&pSMBr); 4335 if (rc) 4336 return rc; 4337 4338 /* server pointer checked in called function, 4339 but should never be null here anyway */ 4340 pSMB->hdr.Mid = get_next_mid(ses->server); 4341 pSMB->hdr.Tid = ses->tcon_ipc->tid; 4342 pSMB->hdr.Uid = ses->Suid; 4343 if (ses->capabilities & CAP_STATUS32) 4344 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS; 4345 if (ses->capabilities & CAP_DFS) 4346 pSMB->hdr.Flags2 |= SMBFLG2_DFS; 4347 4348 if (ses->capabilities & CAP_UNICODE) { 4349 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE; 4350 name_len = 4351 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName, 4352 search_name, PATH_MAX, nls_codepage, 4353 remap); 4354 name_len++; /* trailing null */ 4355 name_len *= 2; 4356 } else { /* BB improve the check for buffer overruns BB */ 4357 name_len = copy_path_name(pSMB->RequestFileName, search_name); 4358 } 4359 4360 if (ses->server->sign) 4361 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE; 4362 4363 pSMB->hdr.Uid = ses->Suid; 4364 4365 params = 2 /* level */ + name_len /*includes null */ ; 4366 pSMB->TotalDataCount = 0; 4367 pSMB->DataCount = 0; 4368 pSMB->DataOffset = 0; 4369 pSMB->MaxParameterCount = 0; 4370 /* BB find exact max SMB PDU from sess structure BB */ 4371 pSMB->MaxDataCount = cpu_to_le16(4000); 4372 pSMB->MaxSetupCount = 0; 4373 pSMB->Reserved = 0; 4374 pSMB->Flags = 0; 4375 pSMB->Timeout = 0; 4376 pSMB->Reserved2 = 0; 4377 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4378 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4); 4379 pSMB->SetupCount = 1; 4380 pSMB->Reserved3 = 0; 4381 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL); 4382 byte_count = params + 3 /* pad */ ; 4383 pSMB->ParameterCount = cpu_to_le16(params); 4384 pSMB->TotalParameterCount = pSMB->ParameterCount; 4385 pSMB->MaxReferralLevel = cpu_to_le16(3); 4386 inc_rfc1001_len(pSMB, byte_count); 4387 pSMB->ByteCount = cpu_to_le16(byte_count); 4388 4389 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB, 4390 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4391 if (rc) { 4392 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc); 4393 goto GetDFSRefExit; 4394 } 4395 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4396 4397 /* BB Also check if enough total bytes returned? */ 4398 if (rc || get_bcc(&pSMBr->hdr) < 17) { 4399 rc = -EIO; /* bad smb */ 4400 goto GetDFSRefExit; 4401 } 4402 4403 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n", 4404 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset)); 4405 4406 /* parse returned result into more usable form */ 4407 rc = parse_dfs_referrals(&pSMBr->dfs_data, 4408 le16_to_cpu(pSMBr->t2.DataCount), 4409 num_of_nodes, target_nodes, nls_codepage, 4410 remap, search_name, 4411 (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) != 0); 4412 4413 GetDFSRefExit: 4414 cifs_buf_release(pSMB); 4415 4416 if (rc == -EAGAIN) 4417 goto getDFSRetry; 4418 4419 return rc; 4420 } 4421 4422 /* Query File System Info such as free space to old servers such as Win 9x */ 4423 int 4424 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon, 4425 struct kstatfs *FSData) 4426 { 4427 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */ 4428 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4429 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4430 FILE_SYSTEM_ALLOC_INFO *response_data; 4431 int rc = 0; 4432 int bytes_returned = 0; 4433 __u16 params, byte_count; 4434 4435 cifs_dbg(FYI, "OldQFSInfo\n"); 4436 oldQFSInfoRetry: 4437 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4438 (void **) &pSMBr); 4439 if (rc) 4440 return rc; 4441 4442 params = 2; /* level */ 4443 pSMB->TotalDataCount = 0; 4444 pSMB->MaxParameterCount = cpu_to_le16(2); 4445 pSMB->MaxDataCount = cpu_to_le16(1000); 4446 pSMB->MaxSetupCount = 0; 4447 pSMB->Reserved = 0; 4448 pSMB->Flags = 0; 4449 pSMB->Timeout = 0; 4450 pSMB->Reserved2 = 0; 4451 byte_count = params + 1 /* pad */ ; 4452 pSMB->TotalParameterCount = cpu_to_le16(params); 4453 pSMB->ParameterCount = pSMB->TotalParameterCount; 4454 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4455 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4456 pSMB->DataCount = 0; 4457 pSMB->DataOffset = 0; 4458 pSMB->SetupCount = 1; 4459 pSMB->Reserved3 = 0; 4460 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4461 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION); 4462 inc_rfc1001_len(pSMB, byte_count); 4463 pSMB->ByteCount = cpu_to_le16(byte_count); 4464 4465 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4466 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4467 if (rc) { 4468 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc); 4469 } else { /* decode response */ 4470 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4471 4472 if (rc || get_bcc(&pSMBr->hdr) < 18) 4473 rc = -EIO; /* bad smb */ 4474 else { 4475 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4476 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n", 4477 get_bcc(&pSMBr->hdr), data_offset); 4478 4479 response_data = (FILE_SYSTEM_ALLOC_INFO *) 4480 (((char *) &pSMBr->hdr.Protocol) + data_offset); 4481 FSData->f_bsize = 4482 le16_to_cpu(response_data->BytesPerSector) * 4483 le32_to_cpu(response_data-> 4484 SectorsPerAllocationUnit); 4485 /* 4486 * much prefer larger but if server doesn't report 4487 * a valid size than 4K is a reasonable minimum 4488 */ 4489 if (FSData->f_bsize < 512) 4490 FSData->f_bsize = 4096; 4491 4492 FSData->f_blocks = 4493 le32_to_cpu(response_data->TotalAllocationUnits); 4494 FSData->f_bfree = FSData->f_bavail = 4495 le32_to_cpu(response_data->FreeAllocationUnits); 4496 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n", 4497 (unsigned long long)FSData->f_blocks, 4498 (unsigned long long)FSData->f_bfree, 4499 FSData->f_bsize); 4500 } 4501 } 4502 cifs_buf_release(pSMB); 4503 4504 if (rc == -EAGAIN) 4505 goto oldQFSInfoRetry; 4506 4507 return rc; 4508 } 4509 4510 int 4511 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon, 4512 struct kstatfs *FSData) 4513 { 4514 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */ 4515 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4516 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4517 FILE_SYSTEM_INFO *response_data; 4518 int rc = 0; 4519 int bytes_returned = 0; 4520 __u16 params, byte_count; 4521 4522 cifs_dbg(FYI, "In QFSInfo\n"); 4523 QFSInfoRetry: 4524 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4525 (void **) &pSMBr); 4526 if (rc) 4527 return rc; 4528 4529 params = 2; /* level */ 4530 pSMB->TotalDataCount = 0; 4531 pSMB->MaxParameterCount = cpu_to_le16(2); 4532 pSMB->MaxDataCount = cpu_to_le16(1000); 4533 pSMB->MaxSetupCount = 0; 4534 pSMB->Reserved = 0; 4535 pSMB->Flags = 0; 4536 pSMB->Timeout = 0; 4537 pSMB->Reserved2 = 0; 4538 byte_count = params + 1 /* pad */ ; 4539 pSMB->TotalParameterCount = cpu_to_le16(params); 4540 pSMB->ParameterCount = pSMB->TotalParameterCount; 4541 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4542 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4543 pSMB->DataCount = 0; 4544 pSMB->DataOffset = 0; 4545 pSMB->SetupCount = 1; 4546 pSMB->Reserved3 = 0; 4547 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4548 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO); 4549 inc_rfc1001_len(pSMB, byte_count); 4550 pSMB->ByteCount = cpu_to_le16(byte_count); 4551 4552 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4553 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4554 if (rc) { 4555 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc); 4556 } else { /* decode response */ 4557 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4558 4559 if (rc || get_bcc(&pSMBr->hdr) < 24) 4560 rc = -EIO; /* bad smb */ 4561 else { 4562 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4563 4564 response_data = 4565 (FILE_SYSTEM_INFO 4566 *) (((char *) &pSMBr->hdr.Protocol) + 4567 data_offset); 4568 FSData->f_bsize = 4569 le32_to_cpu(response_data->BytesPerSector) * 4570 le32_to_cpu(response_data-> 4571 SectorsPerAllocationUnit); 4572 /* 4573 * much prefer larger but if server doesn't report 4574 * a valid size than 4K is a reasonable minimum 4575 */ 4576 if (FSData->f_bsize < 512) 4577 FSData->f_bsize = 4096; 4578 4579 FSData->f_blocks = 4580 le64_to_cpu(response_data->TotalAllocationUnits); 4581 FSData->f_bfree = FSData->f_bavail = 4582 le64_to_cpu(response_data->FreeAllocationUnits); 4583 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n", 4584 (unsigned long long)FSData->f_blocks, 4585 (unsigned long long)FSData->f_bfree, 4586 FSData->f_bsize); 4587 } 4588 } 4589 cifs_buf_release(pSMB); 4590 4591 if (rc == -EAGAIN) 4592 goto QFSInfoRetry; 4593 4594 return rc; 4595 } 4596 4597 int 4598 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon) 4599 { 4600 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */ 4601 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4602 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4603 FILE_SYSTEM_ATTRIBUTE_INFO *response_data; 4604 int rc = 0; 4605 int bytes_returned = 0; 4606 __u16 params, byte_count; 4607 4608 cifs_dbg(FYI, "In QFSAttributeInfo\n"); 4609 QFSAttributeRetry: 4610 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4611 (void **) &pSMBr); 4612 if (rc) 4613 return rc; 4614 4615 params = 2; /* level */ 4616 pSMB->TotalDataCount = 0; 4617 pSMB->MaxParameterCount = cpu_to_le16(2); 4618 /* BB find exact max SMB PDU from sess structure BB */ 4619 pSMB->MaxDataCount = cpu_to_le16(1000); 4620 pSMB->MaxSetupCount = 0; 4621 pSMB->Reserved = 0; 4622 pSMB->Flags = 0; 4623 pSMB->Timeout = 0; 4624 pSMB->Reserved2 = 0; 4625 byte_count = params + 1 /* pad */ ; 4626 pSMB->TotalParameterCount = cpu_to_le16(params); 4627 pSMB->ParameterCount = pSMB->TotalParameterCount; 4628 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4629 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4630 pSMB->DataCount = 0; 4631 pSMB->DataOffset = 0; 4632 pSMB->SetupCount = 1; 4633 pSMB->Reserved3 = 0; 4634 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4635 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO); 4636 inc_rfc1001_len(pSMB, byte_count); 4637 pSMB->ByteCount = cpu_to_le16(byte_count); 4638 4639 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4640 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4641 if (rc) { 4642 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc); 4643 } else { /* decode response */ 4644 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4645 4646 if (rc || get_bcc(&pSMBr->hdr) < 13) { 4647 /* BB also check if enough bytes returned */ 4648 rc = -EIO; /* bad smb */ 4649 } else { 4650 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4651 response_data = 4652 (FILE_SYSTEM_ATTRIBUTE_INFO 4653 *) (((char *) &pSMBr->hdr.Protocol) + 4654 data_offset); 4655 memcpy(&tcon->fsAttrInfo, response_data, 4656 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO)); 4657 } 4658 } 4659 cifs_buf_release(pSMB); 4660 4661 if (rc == -EAGAIN) 4662 goto QFSAttributeRetry; 4663 4664 return rc; 4665 } 4666 4667 int 4668 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon) 4669 { 4670 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */ 4671 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4672 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4673 FILE_SYSTEM_DEVICE_INFO *response_data; 4674 int rc = 0; 4675 int bytes_returned = 0; 4676 __u16 params, byte_count; 4677 4678 cifs_dbg(FYI, "In QFSDeviceInfo\n"); 4679 QFSDeviceRetry: 4680 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4681 (void **) &pSMBr); 4682 if (rc) 4683 return rc; 4684 4685 params = 2; /* level */ 4686 pSMB->TotalDataCount = 0; 4687 pSMB->MaxParameterCount = cpu_to_le16(2); 4688 /* BB find exact max SMB PDU from sess structure BB */ 4689 pSMB->MaxDataCount = cpu_to_le16(1000); 4690 pSMB->MaxSetupCount = 0; 4691 pSMB->Reserved = 0; 4692 pSMB->Flags = 0; 4693 pSMB->Timeout = 0; 4694 pSMB->Reserved2 = 0; 4695 byte_count = params + 1 /* pad */ ; 4696 pSMB->TotalParameterCount = cpu_to_le16(params); 4697 pSMB->ParameterCount = pSMB->TotalParameterCount; 4698 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4699 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4700 4701 pSMB->DataCount = 0; 4702 pSMB->DataOffset = 0; 4703 pSMB->SetupCount = 1; 4704 pSMB->Reserved3 = 0; 4705 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4706 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO); 4707 inc_rfc1001_len(pSMB, byte_count); 4708 pSMB->ByteCount = cpu_to_le16(byte_count); 4709 4710 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4711 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4712 if (rc) { 4713 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc); 4714 } else { /* decode response */ 4715 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4716 4717 if (rc || get_bcc(&pSMBr->hdr) < 4718 sizeof(FILE_SYSTEM_DEVICE_INFO)) 4719 rc = -EIO; /* bad smb */ 4720 else { 4721 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4722 response_data = 4723 (FILE_SYSTEM_DEVICE_INFO *) 4724 (((char *) &pSMBr->hdr.Protocol) + 4725 data_offset); 4726 memcpy(&tcon->fsDevInfo, response_data, 4727 sizeof(FILE_SYSTEM_DEVICE_INFO)); 4728 } 4729 } 4730 cifs_buf_release(pSMB); 4731 4732 if (rc == -EAGAIN) 4733 goto QFSDeviceRetry; 4734 4735 return rc; 4736 } 4737 4738 int 4739 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon) 4740 { 4741 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */ 4742 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4743 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4744 FILE_SYSTEM_UNIX_INFO *response_data; 4745 int rc = 0; 4746 int bytes_returned = 0; 4747 __u16 params, byte_count; 4748 4749 cifs_dbg(FYI, "In QFSUnixInfo\n"); 4750 QFSUnixRetry: 4751 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon, 4752 (void **) &pSMB, (void **) &pSMBr); 4753 if (rc) 4754 return rc; 4755 4756 params = 2; /* level */ 4757 pSMB->TotalDataCount = 0; 4758 pSMB->DataCount = 0; 4759 pSMB->DataOffset = 0; 4760 pSMB->MaxParameterCount = cpu_to_le16(2); 4761 /* BB find exact max SMB PDU from sess structure BB */ 4762 pSMB->MaxDataCount = cpu_to_le16(100); 4763 pSMB->MaxSetupCount = 0; 4764 pSMB->Reserved = 0; 4765 pSMB->Flags = 0; 4766 pSMB->Timeout = 0; 4767 pSMB->Reserved2 = 0; 4768 byte_count = params + 1 /* pad */ ; 4769 pSMB->ParameterCount = cpu_to_le16(params); 4770 pSMB->TotalParameterCount = pSMB->ParameterCount; 4771 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 4772 smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4773 pSMB->SetupCount = 1; 4774 pSMB->Reserved3 = 0; 4775 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4776 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO); 4777 inc_rfc1001_len(pSMB, byte_count); 4778 pSMB->ByteCount = cpu_to_le16(byte_count); 4779 4780 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4781 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4782 if (rc) { 4783 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc); 4784 } else { /* decode response */ 4785 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4786 4787 if (rc || get_bcc(&pSMBr->hdr) < 13) { 4788 rc = -EIO; /* bad smb */ 4789 } else { 4790 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4791 response_data = 4792 (FILE_SYSTEM_UNIX_INFO 4793 *) (((char *) &pSMBr->hdr.Protocol) + 4794 data_offset); 4795 memcpy(&tcon->fsUnixInfo, response_data, 4796 sizeof(FILE_SYSTEM_UNIX_INFO)); 4797 } 4798 } 4799 cifs_buf_release(pSMB); 4800 4801 if (rc == -EAGAIN) 4802 goto QFSUnixRetry; 4803 4804 4805 return rc; 4806 } 4807 4808 int 4809 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap) 4810 { 4811 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */ 4812 TRANSACTION2_SETFSI_REQ *pSMB = NULL; 4813 TRANSACTION2_SETFSI_RSP *pSMBr = NULL; 4814 int rc = 0; 4815 int bytes_returned = 0; 4816 __u16 params, param_offset, offset, byte_count; 4817 4818 cifs_dbg(FYI, "In SETFSUnixInfo\n"); 4819 SETFSUnixRetry: 4820 /* BB switch to small buf init to save memory */ 4821 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon, 4822 (void **) &pSMB, (void **) &pSMBr); 4823 if (rc) 4824 return rc; 4825 4826 params = 4; /* 2 bytes zero followed by info level. */ 4827 pSMB->MaxSetupCount = 0; 4828 pSMB->Reserved = 0; 4829 pSMB->Flags = 0; 4830 pSMB->Timeout = 0; 4831 pSMB->Reserved2 = 0; 4832 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum) 4833 - 4; 4834 offset = param_offset + params; 4835 4836 pSMB->MaxParameterCount = cpu_to_le16(4); 4837 /* BB find exact max SMB PDU from sess structure BB */ 4838 pSMB->MaxDataCount = cpu_to_le16(100); 4839 pSMB->SetupCount = 1; 4840 pSMB->Reserved3 = 0; 4841 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION); 4842 byte_count = 1 /* pad */ + params + 12; 4843 4844 pSMB->DataCount = cpu_to_le16(12); 4845 pSMB->ParameterCount = cpu_to_le16(params); 4846 pSMB->TotalDataCount = pSMB->DataCount; 4847 pSMB->TotalParameterCount = pSMB->ParameterCount; 4848 pSMB->ParameterOffset = cpu_to_le16(param_offset); 4849 pSMB->DataOffset = cpu_to_le16(offset); 4850 4851 /* Params. */ 4852 pSMB->FileNum = 0; 4853 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO); 4854 4855 /* Data. */ 4856 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION); 4857 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION); 4858 pSMB->ClientUnixCap = cpu_to_le64(cap); 4859 4860 inc_rfc1001_len(pSMB, byte_count); 4861 pSMB->ByteCount = cpu_to_le16(byte_count); 4862 4863 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4864 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4865 if (rc) { 4866 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc); 4867 } else { /* decode response */ 4868 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4869 if (rc) 4870 rc = -EIO; /* bad smb */ 4871 } 4872 cifs_buf_release(pSMB); 4873 4874 if (rc == -EAGAIN) 4875 goto SETFSUnixRetry; 4876 4877 return rc; 4878 } 4879 4880 4881 4882 int 4883 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon, 4884 struct kstatfs *FSData) 4885 { 4886 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */ 4887 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4888 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4889 FILE_SYSTEM_POSIX_INFO *response_data; 4890 int rc = 0; 4891 int bytes_returned = 0; 4892 __u16 params, byte_count; 4893 4894 cifs_dbg(FYI, "In QFSPosixInfo\n"); 4895 QFSPosixRetry: 4896 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4897 (void **) &pSMBr); 4898 if (rc) 4899 return rc; 4900 4901 params = 2; /* level */ 4902 pSMB->TotalDataCount = 0; 4903 pSMB->DataCount = 0; 4904 pSMB->DataOffset = 0; 4905 pSMB->MaxParameterCount = cpu_to_le16(2); 4906 /* BB find exact max SMB PDU from sess structure BB */ 4907 pSMB->MaxDataCount = cpu_to_le16(100); 4908 pSMB->MaxSetupCount = 0; 4909 pSMB->Reserved = 0; 4910 pSMB->Flags = 0; 4911 pSMB->Timeout = 0; 4912 pSMB->Reserved2 = 0; 4913 byte_count = params + 1 /* pad */ ; 4914 pSMB->ParameterCount = cpu_to_le16(params); 4915 pSMB->TotalParameterCount = pSMB->ParameterCount; 4916 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 4917 smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4918 pSMB->SetupCount = 1; 4919 pSMB->Reserved3 = 0; 4920 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4921 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO); 4922 inc_rfc1001_len(pSMB, byte_count); 4923 pSMB->ByteCount = cpu_to_le16(byte_count); 4924 4925 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4926 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4927 if (rc) { 4928 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc); 4929 } else { /* decode response */ 4930 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4931 4932 if (rc || get_bcc(&pSMBr->hdr) < 13) { 4933 rc = -EIO; /* bad smb */ 4934 } else { 4935 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4936 response_data = 4937 (FILE_SYSTEM_POSIX_INFO 4938 *) (((char *) &pSMBr->hdr.Protocol) + 4939 data_offset); 4940 FSData->f_bsize = 4941 le32_to_cpu(response_data->BlockSize); 4942 /* 4943 * much prefer larger but if server doesn't report 4944 * a valid size than 4K is a reasonable minimum 4945 */ 4946 if (FSData->f_bsize < 512) 4947 FSData->f_bsize = 4096; 4948 4949 FSData->f_blocks = 4950 le64_to_cpu(response_data->TotalBlocks); 4951 FSData->f_bfree = 4952 le64_to_cpu(response_data->BlocksAvail); 4953 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) { 4954 FSData->f_bavail = FSData->f_bfree; 4955 } else { 4956 FSData->f_bavail = 4957 le64_to_cpu(response_data->UserBlocksAvail); 4958 } 4959 if (response_data->TotalFileNodes != cpu_to_le64(-1)) 4960 FSData->f_files = 4961 le64_to_cpu(response_data->TotalFileNodes); 4962 if (response_data->FreeFileNodes != cpu_to_le64(-1)) 4963 FSData->f_ffree = 4964 le64_to_cpu(response_data->FreeFileNodes); 4965 } 4966 } 4967 cifs_buf_release(pSMB); 4968 4969 if (rc == -EAGAIN) 4970 goto QFSPosixRetry; 4971 4972 return rc; 4973 } 4974 4975 4976 /* 4977 * We can not use write of zero bytes trick to set file size due to need for 4978 * large file support. Also note that this SetPathInfo is preferred to 4979 * SetFileInfo based method in next routine which is only needed to work around 4980 * a sharing violation bugin Samba which this routine can run into. 4981 */ 4982 int 4983 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon, 4984 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb, 4985 bool set_allocation) 4986 { 4987 struct smb_com_transaction2_spi_req *pSMB = NULL; 4988 struct smb_com_transaction2_spi_rsp *pSMBr = NULL; 4989 struct file_end_of_file_info *parm_data; 4990 int name_len; 4991 int rc = 0; 4992 int bytes_returned = 0; 4993 int remap = cifs_remap(cifs_sb); 4994 4995 __u16 params, byte_count, data_count, param_offset, offset; 4996 4997 cifs_dbg(FYI, "In SetEOF\n"); 4998 SetEOFRetry: 4999 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5000 (void **) &pSMBr); 5001 if (rc) 5002 return rc; 5003 5004 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5005 name_len = 5006 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name, 5007 PATH_MAX, cifs_sb->local_nls, remap); 5008 name_len++; /* trailing null */ 5009 name_len *= 2; 5010 } else { 5011 name_len = copy_path_name(pSMB->FileName, file_name); 5012 } 5013 params = 6 + name_len; 5014 data_count = sizeof(struct file_end_of_file_info); 5015 pSMB->MaxParameterCount = cpu_to_le16(2); 5016 pSMB->MaxDataCount = cpu_to_le16(4100); 5017 pSMB->MaxSetupCount = 0; 5018 pSMB->Reserved = 0; 5019 pSMB->Flags = 0; 5020 pSMB->Timeout = 0; 5021 pSMB->Reserved2 = 0; 5022 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5023 InformationLevel) - 4; 5024 offset = param_offset + params; 5025 if (set_allocation) { 5026 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5027 pSMB->InformationLevel = 5028 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2); 5029 else 5030 pSMB->InformationLevel = 5031 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO); 5032 } else /* Set File Size */ { 5033 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5034 pSMB->InformationLevel = 5035 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2); 5036 else 5037 pSMB->InformationLevel = 5038 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO); 5039 } 5040 5041 parm_data = 5042 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) + 5043 offset); 5044 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5045 pSMB->DataOffset = cpu_to_le16(offset); 5046 pSMB->SetupCount = 1; 5047 pSMB->Reserved3 = 0; 5048 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5049 byte_count = 3 /* pad */ + params + data_count; 5050 pSMB->DataCount = cpu_to_le16(data_count); 5051 pSMB->TotalDataCount = pSMB->DataCount; 5052 pSMB->ParameterCount = cpu_to_le16(params); 5053 pSMB->TotalParameterCount = pSMB->ParameterCount; 5054 pSMB->Reserved4 = 0; 5055 inc_rfc1001_len(pSMB, byte_count); 5056 parm_data->FileSize = cpu_to_le64(size); 5057 pSMB->ByteCount = cpu_to_le16(byte_count); 5058 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5059 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5060 if (rc) 5061 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc); 5062 5063 cifs_buf_release(pSMB); 5064 5065 if (rc == -EAGAIN) 5066 goto SetEOFRetry; 5067 5068 return rc; 5069 } 5070 5071 int 5072 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon, 5073 struct cifsFileInfo *cfile, __u64 size, bool set_allocation) 5074 { 5075 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5076 struct file_end_of_file_info *parm_data; 5077 int rc = 0; 5078 __u16 params, param_offset, offset, byte_count, count; 5079 5080 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n", 5081 (long long)size); 5082 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5083 5084 if (rc) 5085 return rc; 5086 5087 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid); 5088 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16)); 5089 5090 params = 6; 5091 pSMB->MaxSetupCount = 0; 5092 pSMB->Reserved = 0; 5093 pSMB->Flags = 0; 5094 pSMB->Timeout = 0; 5095 pSMB->Reserved2 = 0; 5096 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5097 offset = param_offset + params; 5098 5099 count = sizeof(struct file_end_of_file_info); 5100 pSMB->MaxParameterCount = cpu_to_le16(2); 5101 /* BB find exact max SMB PDU from sess structure BB */ 5102 pSMB->MaxDataCount = cpu_to_le16(1000); 5103 pSMB->SetupCount = 1; 5104 pSMB->Reserved3 = 0; 5105 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5106 byte_count = 3 /* pad */ + params + count; 5107 pSMB->DataCount = cpu_to_le16(count); 5108 pSMB->ParameterCount = cpu_to_le16(params); 5109 pSMB->TotalDataCount = pSMB->DataCount; 5110 pSMB->TotalParameterCount = pSMB->ParameterCount; 5111 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5112 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 5113 parm_data = 5114 (struct file_end_of_file_info *)(((char *)pSMB) + offset + 4); 5115 pSMB->DataOffset = cpu_to_le16(offset); 5116 parm_data->FileSize = cpu_to_le64(size); 5117 pSMB->Fid = cfile->fid.netfid; 5118 if (set_allocation) { 5119 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5120 pSMB->InformationLevel = 5121 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2); 5122 else 5123 pSMB->InformationLevel = 5124 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO); 5125 } else /* Set File Size */ { 5126 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5127 pSMB->InformationLevel = 5128 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2); 5129 else 5130 pSMB->InformationLevel = 5131 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO); 5132 } 5133 pSMB->Reserved4 = 0; 5134 inc_rfc1001_len(pSMB, byte_count); 5135 pSMB->ByteCount = cpu_to_le16(byte_count); 5136 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5137 cifs_small_buf_release(pSMB); 5138 if (rc) { 5139 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n", 5140 rc); 5141 } 5142 5143 /* Note: On -EAGAIN error only caller can retry on handle based calls 5144 since file handle passed in no longer valid */ 5145 5146 return rc; 5147 } 5148 5149 /* Some legacy servers such as NT4 require that the file times be set on 5150 an open handle, rather than by pathname - this is awkward due to 5151 potential access conflicts on the open, but it is unavoidable for these 5152 old servers since the only other choice is to go from 100 nanosecond DCE 5153 time and resort to the original setpathinfo level which takes the ancient 5154 DOS time format with 2 second granularity */ 5155 int 5156 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 5157 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener) 5158 { 5159 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5160 char *data_offset; 5161 int rc = 0; 5162 __u16 params, param_offset, offset, byte_count, count; 5163 5164 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n"); 5165 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5166 5167 if (rc) 5168 return rc; 5169 5170 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener); 5171 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16)); 5172 5173 params = 6; 5174 pSMB->MaxSetupCount = 0; 5175 pSMB->Reserved = 0; 5176 pSMB->Flags = 0; 5177 pSMB->Timeout = 0; 5178 pSMB->Reserved2 = 0; 5179 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5180 offset = param_offset + params; 5181 5182 data_offset = (char *)pSMB + 5183 offsetof(struct smb_hdr, Protocol) + offset; 5184 5185 count = sizeof(FILE_BASIC_INFO); 5186 pSMB->MaxParameterCount = cpu_to_le16(2); 5187 /* BB find max SMB PDU from sess */ 5188 pSMB->MaxDataCount = cpu_to_le16(1000); 5189 pSMB->SetupCount = 1; 5190 pSMB->Reserved3 = 0; 5191 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5192 byte_count = 3 /* pad */ + params + count; 5193 pSMB->DataCount = cpu_to_le16(count); 5194 pSMB->ParameterCount = cpu_to_le16(params); 5195 pSMB->TotalDataCount = pSMB->DataCount; 5196 pSMB->TotalParameterCount = pSMB->ParameterCount; 5197 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5198 pSMB->DataOffset = cpu_to_le16(offset); 5199 pSMB->Fid = fid; 5200 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5201 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2); 5202 else 5203 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO); 5204 pSMB->Reserved4 = 0; 5205 inc_rfc1001_len(pSMB, byte_count); 5206 pSMB->ByteCount = cpu_to_le16(byte_count); 5207 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO)); 5208 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5209 cifs_small_buf_release(pSMB); 5210 if (rc) 5211 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n", 5212 rc); 5213 5214 /* Note: On -EAGAIN error only caller can retry on handle based calls 5215 since file handle passed in no longer valid */ 5216 5217 return rc; 5218 } 5219 5220 int 5221 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon, 5222 bool delete_file, __u16 fid, __u32 pid_of_opener) 5223 { 5224 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5225 char *data_offset; 5226 int rc = 0; 5227 __u16 params, param_offset, offset, byte_count, count; 5228 5229 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n"); 5230 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5231 5232 if (rc) 5233 return rc; 5234 5235 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener); 5236 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16)); 5237 5238 params = 6; 5239 pSMB->MaxSetupCount = 0; 5240 pSMB->Reserved = 0; 5241 pSMB->Flags = 0; 5242 pSMB->Timeout = 0; 5243 pSMB->Reserved2 = 0; 5244 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5245 offset = param_offset + params; 5246 5247 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 5248 data_offset = (char *)(pSMB) + offset + 4; 5249 5250 count = 1; 5251 pSMB->MaxParameterCount = cpu_to_le16(2); 5252 /* BB find max SMB PDU from sess */ 5253 pSMB->MaxDataCount = cpu_to_le16(1000); 5254 pSMB->SetupCount = 1; 5255 pSMB->Reserved3 = 0; 5256 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5257 byte_count = 3 /* pad */ + params + count; 5258 pSMB->DataCount = cpu_to_le16(count); 5259 pSMB->ParameterCount = cpu_to_le16(params); 5260 pSMB->TotalDataCount = pSMB->DataCount; 5261 pSMB->TotalParameterCount = pSMB->ParameterCount; 5262 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5263 pSMB->DataOffset = cpu_to_le16(offset); 5264 pSMB->Fid = fid; 5265 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO); 5266 pSMB->Reserved4 = 0; 5267 inc_rfc1001_len(pSMB, byte_count); 5268 pSMB->ByteCount = cpu_to_le16(byte_count); 5269 *data_offset = delete_file ? 1 : 0; 5270 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5271 cifs_small_buf_release(pSMB); 5272 if (rc) 5273 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc); 5274 5275 return rc; 5276 } 5277 5278 static int 5279 CIFSSMBSetPathInfoFB(const unsigned int xid, struct cifs_tcon *tcon, 5280 const char *fileName, const FILE_BASIC_INFO *data, 5281 const struct nls_table *nls_codepage, 5282 struct cifs_sb_info *cifs_sb) 5283 { 5284 int oplock = 0; 5285 struct cifs_open_parms oparms; 5286 struct cifs_fid fid; 5287 int rc; 5288 5289 oparms = (struct cifs_open_parms) { 5290 .tcon = tcon, 5291 .cifs_sb = cifs_sb, 5292 .desired_access = GENERIC_WRITE, 5293 .create_options = cifs_create_options(cifs_sb, 0), 5294 .disposition = FILE_OPEN, 5295 .path = fileName, 5296 .fid = &fid, 5297 }; 5298 5299 rc = CIFS_open(xid, &oparms, &oplock, NULL); 5300 if (rc) 5301 goto out; 5302 5303 rc = CIFSSMBSetFileInfo(xid, tcon, data, fid.netfid, current->tgid); 5304 CIFSSMBClose(xid, tcon, fid.netfid); 5305 out: 5306 5307 return rc; 5308 } 5309 5310 int 5311 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 5312 const char *fileName, const FILE_BASIC_INFO *data, 5313 const struct nls_table *nls_codepage, 5314 struct cifs_sb_info *cifs_sb) 5315 { 5316 TRANSACTION2_SPI_REQ *pSMB = NULL; 5317 TRANSACTION2_SPI_RSP *pSMBr = NULL; 5318 int name_len; 5319 int rc = 0; 5320 int bytes_returned = 0; 5321 char *data_offset; 5322 __u16 params, param_offset, offset, byte_count, count; 5323 int remap = cifs_remap(cifs_sb); 5324 5325 cifs_dbg(FYI, "In SetTimes\n"); 5326 5327 SetTimesRetry: 5328 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5329 (void **) &pSMBr); 5330 if (rc) 5331 return rc; 5332 5333 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5334 name_len = 5335 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 5336 PATH_MAX, nls_codepage, remap); 5337 name_len++; /* trailing null */ 5338 name_len *= 2; 5339 } else { 5340 name_len = copy_path_name(pSMB->FileName, fileName); 5341 } 5342 5343 params = 6 + name_len; 5344 count = sizeof(FILE_BASIC_INFO); 5345 pSMB->MaxParameterCount = cpu_to_le16(2); 5346 /* BB find max SMB PDU from sess structure BB */ 5347 pSMB->MaxDataCount = cpu_to_le16(1000); 5348 pSMB->MaxSetupCount = 0; 5349 pSMB->Reserved = 0; 5350 pSMB->Flags = 0; 5351 pSMB->Timeout = 0; 5352 pSMB->Reserved2 = 0; 5353 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5354 InformationLevel) - 4; 5355 offset = param_offset + params; 5356 data_offset = (char *) (&pSMB->hdr.Protocol) + offset; 5357 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5358 pSMB->DataOffset = cpu_to_le16(offset); 5359 pSMB->SetupCount = 1; 5360 pSMB->Reserved3 = 0; 5361 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5362 byte_count = 3 /* pad */ + params + count; 5363 5364 pSMB->DataCount = cpu_to_le16(count); 5365 pSMB->ParameterCount = cpu_to_le16(params); 5366 pSMB->TotalDataCount = pSMB->DataCount; 5367 pSMB->TotalParameterCount = pSMB->ParameterCount; 5368 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5369 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2); 5370 else 5371 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO); 5372 pSMB->Reserved4 = 0; 5373 inc_rfc1001_len(pSMB, byte_count); 5374 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO)); 5375 pSMB->ByteCount = cpu_to_le16(byte_count); 5376 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5377 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5378 if (rc) 5379 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc); 5380 5381 cifs_buf_release(pSMB); 5382 5383 if (rc == -EAGAIN) 5384 goto SetTimesRetry; 5385 5386 if (rc == -EOPNOTSUPP) 5387 return CIFSSMBSetPathInfoFB(xid, tcon, fileName, data, 5388 nls_codepage, cifs_sb); 5389 5390 return rc; 5391 } 5392 5393 static void 5394 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset, 5395 const struct cifs_unix_set_info_args *args) 5396 { 5397 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64; 5398 u64 mode = args->mode; 5399 5400 if (uid_valid(args->uid)) 5401 uid = from_kuid(&init_user_ns, args->uid); 5402 if (gid_valid(args->gid)) 5403 gid = from_kgid(&init_user_ns, args->gid); 5404 5405 /* 5406 * Samba server ignores set of file size to zero due to bugs in some 5407 * older clients, but we should be precise - we use SetFileSize to 5408 * set file size and do not want to truncate file size to zero 5409 * accidentally as happened on one Samba server beta by putting 5410 * zero instead of -1 here 5411 */ 5412 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64); 5413 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64); 5414 data_offset->LastStatusChange = cpu_to_le64(args->ctime); 5415 data_offset->LastAccessTime = cpu_to_le64(args->atime); 5416 data_offset->LastModificationTime = cpu_to_le64(args->mtime); 5417 data_offset->Uid = cpu_to_le64(uid); 5418 data_offset->Gid = cpu_to_le64(gid); 5419 /* better to leave device as zero when it is */ 5420 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device)); 5421 data_offset->DevMinor = cpu_to_le64(MINOR(args->device)); 5422 data_offset->Permissions = cpu_to_le64(mode); 5423 5424 if (S_ISREG(mode)) 5425 data_offset->Type = cpu_to_le32(UNIX_FILE); 5426 else if (S_ISDIR(mode)) 5427 data_offset->Type = cpu_to_le32(UNIX_DIR); 5428 else if (S_ISLNK(mode)) 5429 data_offset->Type = cpu_to_le32(UNIX_SYMLINK); 5430 else if (S_ISCHR(mode)) 5431 data_offset->Type = cpu_to_le32(UNIX_CHARDEV); 5432 else if (S_ISBLK(mode)) 5433 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV); 5434 else if (S_ISFIFO(mode)) 5435 data_offset->Type = cpu_to_le32(UNIX_FIFO); 5436 else if (S_ISSOCK(mode)) 5437 data_offset->Type = cpu_to_le32(UNIX_SOCKET); 5438 } 5439 5440 int 5441 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 5442 const struct cifs_unix_set_info_args *args, 5443 u16 fid, u32 pid_of_opener) 5444 { 5445 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5446 char *data_offset; 5447 int rc = 0; 5448 u16 params, param_offset, offset, byte_count, count; 5449 5450 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n"); 5451 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5452 5453 if (rc) 5454 return rc; 5455 5456 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener); 5457 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16)); 5458 5459 params = 6; 5460 pSMB->MaxSetupCount = 0; 5461 pSMB->Reserved = 0; 5462 pSMB->Flags = 0; 5463 pSMB->Timeout = 0; 5464 pSMB->Reserved2 = 0; 5465 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5466 offset = param_offset + params; 5467 5468 data_offset = (char *)pSMB + 5469 offsetof(struct smb_hdr, Protocol) + offset; 5470 5471 count = sizeof(FILE_UNIX_BASIC_INFO); 5472 5473 pSMB->MaxParameterCount = cpu_to_le16(2); 5474 /* BB find max SMB PDU from sess */ 5475 pSMB->MaxDataCount = cpu_to_le16(1000); 5476 pSMB->SetupCount = 1; 5477 pSMB->Reserved3 = 0; 5478 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5479 byte_count = 3 /* pad */ + params + count; 5480 pSMB->DataCount = cpu_to_le16(count); 5481 pSMB->ParameterCount = cpu_to_le16(params); 5482 pSMB->TotalDataCount = pSMB->DataCount; 5483 pSMB->TotalParameterCount = pSMB->ParameterCount; 5484 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5485 pSMB->DataOffset = cpu_to_le16(offset); 5486 pSMB->Fid = fid; 5487 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC); 5488 pSMB->Reserved4 = 0; 5489 inc_rfc1001_len(pSMB, byte_count); 5490 pSMB->ByteCount = cpu_to_le16(byte_count); 5491 5492 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args); 5493 5494 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5495 cifs_small_buf_release(pSMB); 5496 if (rc) 5497 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n", 5498 rc); 5499 5500 /* Note: On -EAGAIN error only caller can retry on handle based calls 5501 since file handle passed in no longer valid */ 5502 5503 return rc; 5504 } 5505 5506 int 5507 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 5508 const char *file_name, 5509 const struct cifs_unix_set_info_args *args, 5510 const struct nls_table *nls_codepage, int remap) 5511 { 5512 TRANSACTION2_SPI_REQ *pSMB = NULL; 5513 TRANSACTION2_SPI_RSP *pSMBr = NULL; 5514 int name_len; 5515 int rc = 0; 5516 int bytes_returned = 0; 5517 FILE_UNIX_BASIC_INFO *data_offset; 5518 __u16 params, param_offset, offset, count, byte_count; 5519 5520 cifs_dbg(FYI, "In SetUID/GID/Mode\n"); 5521 setPermsRetry: 5522 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5523 (void **) &pSMBr); 5524 if (rc) 5525 return rc; 5526 5527 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5528 name_len = 5529 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name, 5530 PATH_MAX, nls_codepage, remap); 5531 name_len++; /* trailing null */ 5532 name_len *= 2; 5533 } else { 5534 name_len = copy_path_name(pSMB->FileName, file_name); 5535 } 5536 5537 params = 6 + name_len; 5538 count = sizeof(FILE_UNIX_BASIC_INFO); 5539 pSMB->MaxParameterCount = cpu_to_le16(2); 5540 /* BB find max SMB PDU from sess structure BB */ 5541 pSMB->MaxDataCount = cpu_to_le16(1000); 5542 pSMB->MaxSetupCount = 0; 5543 pSMB->Reserved = 0; 5544 pSMB->Flags = 0; 5545 pSMB->Timeout = 0; 5546 pSMB->Reserved2 = 0; 5547 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5548 InformationLevel) - 4; 5549 offset = param_offset + params; 5550 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 5551 data_offset = (FILE_UNIX_BASIC_INFO *)((char *) pSMB + offset + 4); 5552 memset(data_offset, 0, count); 5553 pSMB->DataOffset = cpu_to_le16(offset); 5554 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5555 pSMB->SetupCount = 1; 5556 pSMB->Reserved3 = 0; 5557 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5558 byte_count = 3 /* pad */ + params + count; 5559 pSMB->ParameterCount = cpu_to_le16(params); 5560 pSMB->DataCount = cpu_to_le16(count); 5561 pSMB->TotalParameterCount = pSMB->ParameterCount; 5562 pSMB->TotalDataCount = pSMB->DataCount; 5563 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC); 5564 pSMB->Reserved4 = 0; 5565 inc_rfc1001_len(pSMB, byte_count); 5566 5567 cifs_fill_unix_set_info(data_offset, args); 5568 5569 pSMB->ByteCount = cpu_to_le16(byte_count); 5570 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5571 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5572 if (rc) 5573 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc); 5574 5575 cifs_buf_release(pSMB); 5576 if (rc == -EAGAIN) 5577 goto setPermsRetry; 5578 return rc; 5579 } 5580 5581 #ifdef CONFIG_CIFS_XATTR 5582 /* 5583 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common 5584 * function used by listxattr and getxattr type calls. When ea_name is set, 5585 * it looks for that attribute name and stuffs that value into the EAData 5586 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the 5587 * buffer. In both cases, the return value is either the length of the 5588 * resulting data or a negative error code. If EAData is a NULL pointer then 5589 * the data isn't copied to it, but the length is returned. 5590 */ 5591 ssize_t 5592 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon, 5593 const unsigned char *searchName, const unsigned char *ea_name, 5594 char *EAData, size_t buf_size, 5595 struct cifs_sb_info *cifs_sb) 5596 { 5597 /* BB assumes one setup word */ 5598 TRANSACTION2_QPI_REQ *pSMB = NULL; 5599 TRANSACTION2_QPI_RSP *pSMBr = NULL; 5600 int remap = cifs_remap(cifs_sb); 5601 struct nls_table *nls_codepage = cifs_sb->local_nls; 5602 int rc = 0; 5603 int bytes_returned; 5604 int list_len; 5605 struct fealist *ea_response_data; 5606 struct fea *temp_fea; 5607 char *temp_ptr; 5608 char *end_of_smb; 5609 __u16 params, byte_count, data_offset; 5610 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0; 5611 5612 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName); 5613 QAllEAsRetry: 5614 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5615 (void **) &pSMBr); 5616 if (rc) 5617 return rc; 5618 5619 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5620 list_len = 5621 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName, 5622 PATH_MAX, nls_codepage, remap); 5623 list_len++; /* trailing null */ 5624 list_len *= 2; 5625 } else { 5626 list_len = copy_path_name(pSMB->FileName, searchName); 5627 } 5628 5629 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */; 5630 pSMB->TotalDataCount = 0; 5631 pSMB->MaxParameterCount = cpu_to_le16(2); 5632 /* BB find exact max SMB PDU from sess structure BB */ 5633 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 5634 pSMB->MaxSetupCount = 0; 5635 pSMB->Reserved = 0; 5636 pSMB->Flags = 0; 5637 pSMB->Timeout = 0; 5638 pSMB->Reserved2 = 0; 5639 pSMB->ParameterOffset = cpu_to_le16(offsetof( 5640 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 5641 pSMB->DataCount = 0; 5642 pSMB->DataOffset = 0; 5643 pSMB->SetupCount = 1; 5644 pSMB->Reserved3 = 0; 5645 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 5646 byte_count = params + 1 /* pad */ ; 5647 pSMB->TotalParameterCount = cpu_to_le16(params); 5648 pSMB->ParameterCount = pSMB->TotalParameterCount; 5649 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS); 5650 pSMB->Reserved4 = 0; 5651 inc_rfc1001_len(pSMB, byte_count); 5652 pSMB->ByteCount = cpu_to_le16(byte_count); 5653 5654 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5655 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5656 if (rc) { 5657 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc); 5658 goto QAllEAsOut; 5659 } 5660 5661 5662 /* BB also check enough total bytes returned */ 5663 /* BB we need to improve the validity checking 5664 of these trans2 responses */ 5665 5666 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 5667 if (rc || get_bcc(&pSMBr->hdr) < 4) { 5668 rc = -EIO; /* bad smb */ 5669 goto QAllEAsOut; 5670 } 5671 5672 /* check that length of list is not more than bcc */ 5673 /* check that each entry does not go beyond length 5674 of list */ 5675 /* check that each element of each entry does not 5676 go beyond end of list */ 5677 /* validate_trans2_offsets() */ 5678 /* BB check if start of smb + data_offset > &bcc+ bcc */ 5679 5680 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 5681 ea_response_data = (struct fealist *) 5682 (((char *) &pSMBr->hdr.Protocol) + data_offset); 5683 5684 list_len = le32_to_cpu(ea_response_data->list_len); 5685 cifs_dbg(FYI, "ea length %d\n", list_len); 5686 if (list_len <= 8) { 5687 cifs_dbg(FYI, "empty EA list returned from server\n"); 5688 /* didn't find the named attribute */ 5689 if (ea_name) 5690 rc = -ENODATA; 5691 goto QAllEAsOut; 5692 } 5693 5694 /* make sure list_len doesn't go past end of SMB */ 5695 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr); 5696 if ((char *)ea_response_data + list_len > end_of_smb) { 5697 cifs_dbg(FYI, "EA list appears to go beyond SMB\n"); 5698 rc = -EIO; 5699 goto QAllEAsOut; 5700 } 5701 5702 /* account for ea list len */ 5703 list_len -= 4; 5704 temp_fea = &ea_response_data->list; 5705 temp_ptr = (char *)temp_fea; 5706 while (list_len > 0) { 5707 unsigned int name_len; 5708 __u16 value_len; 5709 5710 list_len -= 4; 5711 temp_ptr += 4; 5712 /* make sure we can read name_len and value_len */ 5713 if (list_len < 0) { 5714 cifs_dbg(FYI, "EA entry goes beyond length of list\n"); 5715 rc = -EIO; 5716 goto QAllEAsOut; 5717 } 5718 5719 name_len = temp_fea->name_len; 5720 value_len = le16_to_cpu(temp_fea->value_len); 5721 list_len -= name_len + 1 + value_len; 5722 if (list_len < 0) { 5723 cifs_dbg(FYI, "EA entry goes beyond length of list\n"); 5724 rc = -EIO; 5725 goto QAllEAsOut; 5726 } 5727 5728 if (ea_name) { 5729 if (ea_name_len == name_len && 5730 memcmp(ea_name, temp_ptr, name_len) == 0) { 5731 temp_ptr += name_len + 1; 5732 rc = value_len; 5733 if (buf_size == 0) 5734 goto QAllEAsOut; 5735 if ((size_t)value_len > buf_size) { 5736 rc = -ERANGE; 5737 goto QAllEAsOut; 5738 } 5739 memcpy(EAData, temp_ptr, value_len); 5740 goto QAllEAsOut; 5741 } 5742 } else { 5743 /* account for prefix user. and trailing null */ 5744 rc += (5 + 1 + name_len); 5745 if (rc < (int) buf_size) { 5746 memcpy(EAData, "user.", 5); 5747 EAData += 5; 5748 memcpy(EAData, temp_ptr, name_len); 5749 EAData += name_len; 5750 /* null terminate name */ 5751 *EAData = 0; 5752 ++EAData; 5753 } else if (buf_size == 0) { 5754 /* skip copy - calc size only */ 5755 } else { 5756 /* stop before overrun buffer */ 5757 rc = -ERANGE; 5758 break; 5759 } 5760 } 5761 temp_ptr += name_len + 1 + value_len; 5762 temp_fea = (struct fea *)temp_ptr; 5763 } 5764 5765 /* didn't find the named attribute */ 5766 if (ea_name) 5767 rc = -ENODATA; 5768 5769 QAllEAsOut: 5770 cifs_buf_release(pSMB); 5771 if (rc == -EAGAIN) 5772 goto QAllEAsRetry; 5773 5774 return (ssize_t)rc; 5775 } 5776 5777 int 5778 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon, 5779 const char *fileName, const char *ea_name, const void *ea_value, 5780 const __u16 ea_value_len, const struct nls_table *nls_codepage, 5781 struct cifs_sb_info *cifs_sb) 5782 { 5783 struct smb_com_transaction2_spi_req *pSMB = NULL; 5784 struct smb_com_transaction2_spi_rsp *pSMBr = NULL; 5785 struct fealist *parm_data; 5786 int name_len; 5787 int rc = 0; 5788 int bytes_returned = 0; 5789 __u16 params, param_offset, byte_count, offset, count; 5790 int remap = cifs_remap(cifs_sb); 5791 5792 cifs_dbg(FYI, "In SetEA\n"); 5793 SetEARetry: 5794 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5795 (void **) &pSMBr); 5796 if (rc) 5797 return rc; 5798 5799 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5800 name_len = 5801 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 5802 PATH_MAX, nls_codepage, remap); 5803 name_len++; /* trailing null */ 5804 name_len *= 2; 5805 } else { 5806 name_len = copy_path_name(pSMB->FileName, fileName); 5807 } 5808 5809 params = 6 + name_len; 5810 5811 /* done calculating parms using name_len of file name, 5812 now use name_len to calculate length of ea name 5813 we are going to create in the inode xattrs */ 5814 if (ea_name == NULL) 5815 name_len = 0; 5816 else 5817 name_len = strnlen(ea_name, 255); 5818 5819 count = sizeof(*parm_data) + 1 + ea_value_len + name_len; 5820 pSMB->MaxParameterCount = cpu_to_le16(2); 5821 /* BB find max SMB PDU from sess */ 5822 pSMB->MaxDataCount = cpu_to_le16(1000); 5823 pSMB->MaxSetupCount = 0; 5824 pSMB->Reserved = 0; 5825 pSMB->Flags = 0; 5826 pSMB->Timeout = 0; 5827 pSMB->Reserved2 = 0; 5828 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5829 InformationLevel) - 4; 5830 offset = param_offset + params; 5831 pSMB->InformationLevel = 5832 cpu_to_le16(SMB_SET_FILE_EA); 5833 5834 parm_data = (void *)pSMB + offsetof(struct smb_hdr, Protocol) + offset; 5835 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5836 pSMB->DataOffset = cpu_to_le16(offset); 5837 pSMB->SetupCount = 1; 5838 pSMB->Reserved3 = 0; 5839 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5840 byte_count = 3 /* pad */ + params + count; 5841 pSMB->DataCount = cpu_to_le16(count); 5842 parm_data->list_len = cpu_to_le32(count); 5843 parm_data->list.EA_flags = 0; 5844 /* we checked above that name len is less than 255 */ 5845 parm_data->list.name_len = (__u8)name_len; 5846 /* EA names are always ASCII */ 5847 if (ea_name) 5848 strncpy(parm_data->list.name, ea_name, name_len); 5849 parm_data->list.name[name_len] = '\0'; 5850 parm_data->list.value_len = cpu_to_le16(ea_value_len); 5851 /* caller ensures that ea_value_len is less than 64K but 5852 we need to ensure that it fits within the smb */ 5853 5854 /*BB add length check to see if it would fit in 5855 negotiated SMB buffer size BB */ 5856 /* if (ea_value_len > buffer_size - 512 (enough for header)) */ 5857 if (ea_value_len) 5858 memcpy(parm_data->list.name + name_len + 1, 5859 ea_value, ea_value_len); 5860 5861 pSMB->TotalDataCount = pSMB->DataCount; 5862 pSMB->ParameterCount = cpu_to_le16(params); 5863 pSMB->TotalParameterCount = pSMB->ParameterCount; 5864 pSMB->Reserved4 = 0; 5865 inc_rfc1001_len(pSMB, byte_count); 5866 pSMB->ByteCount = cpu_to_le16(byte_count); 5867 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5868 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5869 if (rc) 5870 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc); 5871 5872 cifs_buf_release(pSMB); 5873 5874 if (rc == -EAGAIN) 5875 goto SetEARetry; 5876 5877 return rc; 5878 } 5879 #endif 5880