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, struct dentry *dentry) 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->c.flc_type = F_UNLCK; 2070 else { 2071 if (parm_data->lock_type == 2072 cpu_to_le16(CIFS_RDLCK)) 2073 pLockData->c.flc_type = F_RDLCK; 2074 else if (parm_data->lock_type == 2075 cpu_to_le16(CIFS_WRLCK)) 2076 pLockData->c.flc_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->c.flc_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 CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon, 2153 struct dentry *source_dentry, 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 CIFSCreateHardLink(const unsigned int xid, 2534 struct cifs_tcon *tcon, 2535 struct dentry *source_dentry, 2536 const char *from_name, const char *to_name, 2537 struct cifs_sb_info *cifs_sb) 2538 { 2539 int rc = 0; 2540 NT_RENAME_REQ *pSMB = NULL; 2541 RENAME_RSP *pSMBr = NULL; 2542 int bytes_returned; 2543 int name_len, name_len2; 2544 __u16 count; 2545 int remap = cifs_remap(cifs_sb); 2546 2547 cifs_dbg(FYI, "In CIFSCreateHardLink\n"); 2548 winCreateHardLinkRetry: 2549 2550 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB, 2551 (void **) &pSMBr); 2552 if (rc) 2553 return rc; 2554 2555 pSMB->SearchAttributes = 2556 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM | 2557 ATTR_DIRECTORY); 2558 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK); 2559 pSMB->ClusterCount = 0; 2560 2561 pSMB->BufferFormat = 0x04; 2562 2563 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2564 name_len = 2565 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name, 2566 PATH_MAX, cifs_sb->local_nls, remap); 2567 name_len++; /* trailing null */ 2568 name_len *= 2; 2569 2570 /* protocol specifies ASCII buffer format (0x04) for unicode */ 2571 pSMB->OldFileName[name_len] = 0x04; 2572 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */ 2573 name_len2 = 2574 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2], 2575 to_name, PATH_MAX, cifs_sb->local_nls, 2576 remap); 2577 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ; 2578 name_len2 *= 2; /* convert to bytes */ 2579 } else { 2580 name_len = copy_path_name(pSMB->OldFileName, from_name); 2581 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */ 2582 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, to_name); 2583 name_len2++; /* signature byte */ 2584 } 2585 2586 count = 1 /* string type byte */ + name_len + name_len2; 2587 inc_rfc1001_len(pSMB, count); 2588 pSMB->ByteCount = cpu_to_le16(count); 2589 2590 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2591 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2592 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks); 2593 if (rc) 2594 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc); 2595 2596 cifs_buf_release(pSMB); 2597 if (rc == -EAGAIN) 2598 goto winCreateHardLinkRetry; 2599 2600 return rc; 2601 } 2602 2603 int 2604 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon, 2605 const unsigned char *searchName, char **symlinkinfo, 2606 const struct nls_table *nls_codepage, int remap) 2607 { 2608 /* SMB_QUERY_FILE_UNIX_LINK */ 2609 TRANSACTION2_QPI_REQ *pSMB = NULL; 2610 TRANSACTION2_QPI_RSP *pSMBr = NULL; 2611 int rc = 0; 2612 int bytes_returned; 2613 int name_len; 2614 __u16 params, byte_count; 2615 char *data_start; 2616 2617 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName); 2618 2619 querySymLinkRetry: 2620 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 2621 (void **) &pSMBr); 2622 if (rc) 2623 return rc; 2624 2625 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 2626 name_len = 2627 cifsConvertToUTF16((__le16 *) pSMB->FileName, 2628 searchName, PATH_MAX, nls_codepage, 2629 remap); 2630 name_len++; /* trailing null */ 2631 name_len *= 2; 2632 } else { 2633 name_len = copy_path_name(pSMB->FileName, searchName); 2634 } 2635 2636 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ; 2637 pSMB->TotalDataCount = 0; 2638 pSMB->MaxParameterCount = cpu_to_le16(2); 2639 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 2640 pSMB->MaxSetupCount = 0; 2641 pSMB->Reserved = 0; 2642 pSMB->Flags = 0; 2643 pSMB->Timeout = 0; 2644 pSMB->Reserved2 = 0; 2645 pSMB->ParameterOffset = cpu_to_le16(offsetof( 2646 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 2647 pSMB->DataCount = 0; 2648 pSMB->DataOffset = 0; 2649 pSMB->SetupCount = 1; 2650 pSMB->Reserved3 = 0; 2651 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 2652 byte_count = params + 1 /* pad */ ; 2653 pSMB->TotalParameterCount = cpu_to_le16(params); 2654 pSMB->ParameterCount = pSMB->TotalParameterCount; 2655 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK); 2656 pSMB->Reserved4 = 0; 2657 inc_rfc1001_len(pSMB, byte_count); 2658 pSMB->ByteCount = cpu_to_le16(byte_count); 2659 2660 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2661 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2662 if (rc) { 2663 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc); 2664 } else { 2665 /* decode response */ 2666 2667 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 2668 /* BB also check enough total bytes returned */ 2669 if (rc || get_bcc(&pSMBr->hdr) < 2) 2670 rc = -EIO; 2671 else { 2672 bool is_unicode; 2673 u16 count = le16_to_cpu(pSMBr->t2.DataCount); 2674 2675 data_start = ((char *) &pSMBr->hdr.Protocol) + 2676 le16_to_cpu(pSMBr->t2.DataOffset); 2677 2678 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) 2679 is_unicode = true; 2680 else 2681 is_unicode = false; 2682 2683 /* BB FIXME investigate remapping reserved chars here */ 2684 *symlinkinfo = cifs_strndup_from_utf16(data_start, 2685 count, is_unicode, nls_codepage); 2686 if (!*symlinkinfo) 2687 rc = -ENOMEM; 2688 } 2689 } 2690 cifs_buf_release(pSMB); 2691 if (rc == -EAGAIN) 2692 goto querySymLinkRetry; 2693 return rc; 2694 } 2695 2696 int cifs_query_reparse_point(const unsigned int xid, 2697 struct cifs_tcon *tcon, 2698 struct cifs_sb_info *cifs_sb, 2699 const char *full_path, 2700 u32 *tag, struct kvec *rsp, 2701 int *rsp_buftype) 2702 { 2703 struct reparse_data_buffer *buf; 2704 struct cifs_open_parms oparms; 2705 TRANSACT_IOCTL_REQ *io_req = NULL; 2706 TRANSACT_IOCTL_RSP *io_rsp = NULL; 2707 struct cifs_fid fid; 2708 __u32 data_offset, data_count, len; 2709 __u8 *start, *end; 2710 int io_rsp_len; 2711 int oplock = 0; 2712 int rc; 2713 2714 cifs_tcon_dbg(FYI, "%s: path=%s\n", __func__, full_path); 2715 2716 if (cap_unix(tcon->ses)) 2717 return -EOPNOTSUPP; 2718 2719 oparms = (struct cifs_open_parms) { 2720 .tcon = tcon, 2721 .cifs_sb = cifs_sb, 2722 .desired_access = FILE_READ_ATTRIBUTES, 2723 .create_options = cifs_create_options(cifs_sb, 2724 OPEN_REPARSE_POINT), 2725 .disposition = FILE_OPEN, 2726 .path = full_path, 2727 .fid = &fid, 2728 }; 2729 2730 rc = CIFS_open(xid, &oparms, &oplock, NULL); 2731 if (rc) 2732 return rc; 2733 2734 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, 2735 (void **)&io_req, (void **)&io_rsp); 2736 if (rc) 2737 goto error; 2738 2739 io_req->TotalParameterCount = 0; 2740 io_req->TotalDataCount = 0; 2741 io_req->MaxParameterCount = cpu_to_le32(2); 2742 /* BB find exact data count max from sess structure BB */ 2743 io_req->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00); 2744 io_req->MaxSetupCount = 4; 2745 io_req->Reserved = 0; 2746 io_req->ParameterOffset = 0; 2747 io_req->DataCount = 0; 2748 io_req->DataOffset = 0; 2749 io_req->SetupCount = 4; 2750 io_req->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL); 2751 io_req->ParameterCount = io_req->TotalParameterCount; 2752 io_req->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT); 2753 io_req->IsFsctl = 1; 2754 io_req->IsRootFlag = 0; 2755 io_req->Fid = fid.netfid; 2756 io_req->ByteCount = 0; 2757 2758 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)io_req, 2759 (struct smb_hdr *)io_rsp, &io_rsp_len, 0); 2760 if (rc) 2761 goto error; 2762 2763 data_offset = le32_to_cpu(io_rsp->DataOffset); 2764 data_count = le32_to_cpu(io_rsp->DataCount); 2765 if (get_bcc(&io_rsp->hdr) < 2 || data_offset > 512 || 2766 !data_count || data_count > 2048) { 2767 rc = -EIO; 2768 goto error; 2769 } 2770 2771 end = 2 + get_bcc(&io_rsp->hdr) + (__u8 *)&io_rsp->ByteCount; 2772 start = (__u8 *)&io_rsp->hdr.Protocol + data_offset; 2773 if (start >= end) { 2774 rc = -EIO; 2775 goto error; 2776 } 2777 2778 data_count = le16_to_cpu(io_rsp->ByteCount); 2779 buf = (struct reparse_data_buffer *)start; 2780 len = sizeof(*buf); 2781 if (data_count < len || 2782 data_count < le16_to_cpu(buf->ReparseDataLength) + len) { 2783 rc = -EIO; 2784 goto error; 2785 } 2786 2787 *tag = le32_to_cpu(buf->ReparseTag); 2788 rsp->iov_base = io_rsp; 2789 rsp->iov_len = io_rsp_len; 2790 *rsp_buftype = CIFS_LARGE_BUFFER; 2791 CIFSSMBClose(xid, tcon, fid.netfid); 2792 return 0; 2793 2794 error: 2795 cifs_buf_release(io_req); 2796 CIFSSMBClose(xid, tcon, fid.netfid); 2797 return rc; 2798 } 2799 2800 int 2801 CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon, 2802 __u16 fid) 2803 { 2804 int rc = 0; 2805 int bytes_returned; 2806 struct smb_com_transaction_compr_ioctl_req *pSMB; 2807 struct smb_com_transaction_ioctl_rsp *pSMBr; 2808 2809 cifs_dbg(FYI, "Set compression for %u\n", fid); 2810 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB, 2811 (void **) &pSMBr); 2812 if (rc) 2813 return rc; 2814 2815 pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT); 2816 2817 pSMB->TotalParameterCount = 0; 2818 pSMB->TotalDataCount = cpu_to_le32(2); 2819 pSMB->MaxParameterCount = 0; 2820 pSMB->MaxDataCount = 0; 2821 pSMB->MaxSetupCount = 4; 2822 pSMB->Reserved = 0; 2823 pSMB->ParameterOffset = 0; 2824 pSMB->DataCount = cpu_to_le32(2); 2825 pSMB->DataOffset = 2826 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req, 2827 compression_state) - 4); /* 84 */ 2828 pSMB->SetupCount = 4; 2829 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL); 2830 pSMB->ParameterCount = 0; 2831 pSMB->FunctionCode = cpu_to_le32(FSCTL_SET_COMPRESSION); 2832 pSMB->IsFsctl = 1; /* FSCTL */ 2833 pSMB->IsRootFlag = 0; 2834 pSMB->Fid = fid; /* file handle always le */ 2835 /* 3 byte pad, followed by 2 byte compress state */ 2836 pSMB->ByteCount = cpu_to_le16(5); 2837 inc_rfc1001_len(pSMB, 5); 2838 2839 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 2840 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 2841 if (rc) 2842 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc); 2843 2844 cifs_buf_release(pSMB); 2845 2846 /* 2847 * Note: On -EAGAIN error only caller can retry on handle based calls 2848 * since file handle passed in no longer valid. 2849 */ 2850 return rc; 2851 } 2852 2853 2854 #ifdef CONFIG_CIFS_POSIX 2855 2856 #ifdef CONFIG_FS_POSIX_ACL 2857 /** 2858 * cifs_init_posix_acl - convert ACL from cifs to POSIX ACL format 2859 * @ace: POSIX ACL entry to store converted ACL into 2860 * @cifs_ace: ACL in cifs format 2861 * 2862 * Convert an Access Control Entry from wire format to local POSIX xattr 2863 * format. 2864 * 2865 * Note that the @cifs_uid member is used to store both {g,u}id_t. 2866 */ 2867 static void cifs_init_posix_acl(struct posix_acl_entry *ace, 2868 struct cifs_posix_ace *cifs_ace) 2869 { 2870 /* u8 cifs fields do not need le conversion */ 2871 ace->e_perm = cifs_ace->cifs_e_perm; 2872 ace->e_tag = cifs_ace->cifs_e_tag; 2873 2874 switch (ace->e_tag) { 2875 case ACL_USER: 2876 ace->e_uid = make_kuid(&init_user_ns, 2877 le64_to_cpu(cifs_ace->cifs_uid)); 2878 break; 2879 case ACL_GROUP: 2880 ace->e_gid = make_kgid(&init_user_ns, 2881 le64_to_cpu(cifs_ace->cifs_uid)); 2882 break; 2883 } 2884 return; 2885 } 2886 2887 /** 2888 * cifs_to_posix_acl - copy cifs ACL format to POSIX ACL format 2889 * @acl: ACLs returned in POSIX ACL format 2890 * @src: ACLs in cifs format 2891 * @acl_type: type of POSIX ACL requested 2892 * @size_of_data_area: size of SMB we got 2893 * 2894 * This function converts ACLs from cifs format to POSIX ACL format. 2895 * If @acl is NULL then the size of the buffer required to store POSIX ACLs in 2896 * their uapi format is returned. 2897 */ 2898 static int cifs_to_posix_acl(struct posix_acl **acl, char *src, 2899 const int acl_type, const int size_of_data_area) 2900 { 2901 int size = 0; 2902 __u16 count; 2903 struct cifs_posix_ace *pACE; 2904 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src; 2905 struct posix_acl *kacl = NULL; 2906 struct posix_acl_entry *pa, *pe; 2907 2908 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION) 2909 return -EOPNOTSUPP; 2910 2911 if (acl_type == ACL_TYPE_ACCESS) { 2912 count = le16_to_cpu(cifs_acl->access_entry_count); 2913 pACE = &cifs_acl->ace_array[0]; 2914 size = sizeof(struct cifs_posix_acl); 2915 size += sizeof(struct cifs_posix_ace) * count; 2916 /* check if we would go beyond end of SMB */ 2917 if (size_of_data_area < size) { 2918 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n", 2919 size_of_data_area, size); 2920 return -EINVAL; 2921 } 2922 } else if (acl_type == ACL_TYPE_DEFAULT) { 2923 count = le16_to_cpu(cifs_acl->access_entry_count); 2924 size = sizeof(struct cifs_posix_acl); 2925 size += sizeof(struct cifs_posix_ace) * count; 2926 /* skip past access ACEs to get to default ACEs */ 2927 pACE = &cifs_acl->ace_array[count]; 2928 count = le16_to_cpu(cifs_acl->default_entry_count); 2929 size += sizeof(struct cifs_posix_ace) * count; 2930 /* check if we would go beyond end of SMB */ 2931 if (size_of_data_area < size) 2932 return -EINVAL; 2933 } else { 2934 /* illegal type */ 2935 return -EINVAL; 2936 } 2937 2938 /* Allocate number of POSIX ACLs to store in VFS format. */ 2939 kacl = posix_acl_alloc(count, GFP_NOFS); 2940 if (!kacl) 2941 return -ENOMEM; 2942 2943 FOREACH_ACL_ENTRY(pa, kacl, pe) { 2944 cifs_init_posix_acl(pa, pACE); 2945 pACE++; 2946 } 2947 2948 *acl = kacl; 2949 return 0; 2950 } 2951 2952 /** 2953 * cifs_init_ace - convert ACL entry from POSIX ACL to cifs format 2954 * @cifs_ace: the cifs ACL entry to store into 2955 * @local_ace: the POSIX ACL entry to convert 2956 */ 2957 static void cifs_init_ace(struct cifs_posix_ace *cifs_ace, 2958 const struct posix_acl_entry *local_ace) 2959 { 2960 cifs_ace->cifs_e_perm = local_ace->e_perm; 2961 cifs_ace->cifs_e_tag = local_ace->e_tag; 2962 2963 switch (local_ace->e_tag) { 2964 case ACL_USER: 2965 cifs_ace->cifs_uid = 2966 cpu_to_le64(from_kuid(&init_user_ns, local_ace->e_uid)); 2967 break; 2968 case ACL_GROUP: 2969 cifs_ace->cifs_uid = 2970 cpu_to_le64(from_kgid(&init_user_ns, local_ace->e_gid)); 2971 break; 2972 default: 2973 cifs_ace->cifs_uid = cpu_to_le64(-1); 2974 } 2975 } 2976 2977 /** 2978 * posix_acl_to_cifs - convert ACLs from POSIX ACL to cifs format 2979 * @parm_data: ACLs in cifs format to conver to 2980 * @acl: ACLs in POSIX ACL format to convert from 2981 * @acl_type: the type of POSIX ACLs stored in @acl 2982 * 2983 * Return: the number cifs ACL entries after conversion 2984 */ 2985 static __u16 posix_acl_to_cifs(char *parm_data, const struct posix_acl *acl, 2986 const int acl_type) 2987 { 2988 __u16 rc = 0; 2989 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data; 2990 const struct posix_acl_entry *pa, *pe; 2991 int count; 2992 int i = 0; 2993 2994 if ((acl == NULL) || (cifs_acl == NULL)) 2995 return 0; 2996 2997 count = acl->a_count; 2998 cifs_dbg(FYI, "setting acl with %d entries\n", count); 2999 3000 /* 3001 * Note that the uapi POSIX ACL version is verified by the VFS and is 3002 * independent of the cifs ACL version. Changing the POSIX ACL version 3003 * is a uapi change and if it's changed we will pass down the POSIX ACL 3004 * version in struct posix_acl from the VFS. For now there's really 3005 * only one that all filesystems know how to deal with. 3006 */ 3007 cifs_acl->version = cpu_to_le16(1); 3008 if (acl_type == ACL_TYPE_ACCESS) { 3009 cifs_acl->access_entry_count = cpu_to_le16(count); 3010 cifs_acl->default_entry_count = cpu_to_le16(0xFFFF); 3011 } else if (acl_type == ACL_TYPE_DEFAULT) { 3012 cifs_acl->default_entry_count = cpu_to_le16(count); 3013 cifs_acl->access_entry_count = cpu_to_le16(0xFFFF); 3014 } else { 3015 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type); 3016 return 0; 3017 } 3018 FOREACH_ACL_ENTRY(pa, acl, pe) { 3019 cifs_init_ace(&cifs_acl->ace_array[i++], pa); 3020 } 3021 if (rc == 0) { 3022 rc = (__u16)(count * sizeof(struct cifs_posix_ace)); 3023 rc += sizeof(struct cifs_posix_acl); 3024 /* BB add check to make sure ACL does not overflow SMB */ 3025 } 3026 return rc; 3027 } 3028 3029 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon, 3030 const unsigned char *searchName, struct posix_acl **acl, 3031 const int acl_type, const struct nls_table *nls_codepage, 3032 int remap) 3033 { 3034 /* SMB_QUERY_POSIX_ACL */ 3035 TRANSACTION2_QPI_REQ *pSMB = NULL; 3036 TRANSACTION2_QPI_RSP *pSMBr = NULL; 3037 int rc = 0; 3038 int bytes_returned; 3039 int name_len; 3040 __u16 params, byte_count; 3041 3042 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName); 3043 3044 queryAclRetry: 3045 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3046 (void **) &pSMBr); 3047 if (rc) 3048 return rc; 3049 3050 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3051 name_len = 3052 cifsConvertToUTF16((__le16 *) pSMB->FileName, 3053 searchName, PATH_MAX, nls_codepage, 3054 remap); 3055 name_len++; /* trailing null */ 3056 name_len *= 2; 3057 pSMB->FileName[name_len] = 0; 3058 pSMB->FileName[name_len+1] = 0; 3059 } else { 3060 name_len = copy_path_name(pSMB->FileName, searchName); 3061 } 3062 3063 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ; 3064 pSMB->TotalDataCount = 0; 3065 pSMB->MaxParameterCount = cpu_to_le16(2); 3066 /* BB find exact max data count below from sess structure BB */ 3067 pSMB->MaxDataCount = cpu_to_le16(4000); 3068 pSMB->MaxSetupCount = 0; 3069 pSMB->Reserved = 0; 3070 pSMB->Flags = 0; 3071 pSMB->Timeout = 0; 3072 pSMB->Reserved2 = 0; 3073 pSMB->ParameterOffset = cpu_to_le16( 3074 offsetof(struct smb_com_transaction2_qpi_req, 3075 InformationLevel) - 4); 3076 pSMB->DataCount = 0; 3077 pSMB->DataOffset = 0; 3078 pSMB->SetupCount = 1; 3079 pSMB->Reserved3 = 0; 3080 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 3081 byte_count = params + 1 /* pad */ ; 3082 pSMB->TotalParameterCount = cpu_to_le16(params); 3083 pSMB->ParameterCount = pSMB->TotalParameterCount; 3084 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL); 3085 pSMB->Reserved4 = 0; 3086 inc_rfc1001_len(pSMB, byte_count); 3087 pSMB->ByteCount = cpu_to_le16(byte_count); 3088 3089 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3090 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3091 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get); 3092 if (rc) { 3093 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc); 3094 } else { 3095 /* decode response */ 3096 3097 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3098 /* BB also check enough total bytes returned */ 3099 if (rc || get_bcc(&pSMBr->hdr) < 2) 3100 rc = -EIO; /* bad smb */ 3101 else { 3102 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3103 __u16 count = le16_to_cpu(pSMBr->t2.DataCount); 3104 rc = cifs_to_posix_acl(acl, 3105 (char *)&pSMBr->hdr.Protocol+data_offset, 3106 acl_type, count); 3107 } 3108 } 3109 cifs_buf_release(pSMB); 3110 /* 3111 * The else branch after SendReceive() doesn't return EAGAIN so if we 3112 * allocated @acl in cifs_to_posix_acl() we are guaranteed to return 3113 * here and don't leak POSIX ACLs. 3114 */ 3115 if (rc == -EAGAIN) 3116 goto queryAclRetry; 3117 return rc; 3118 } 3119 3120 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 3121 const unsigned char *fileName, const struct posix_acl *acl, 3122 const int acl_type, const struct nls_table *nls_codepage, 3123 int remap) 3124 { 3125 struct smb_com_transaction2_spi_req *pSMB = NULL; 3126 struct smb_com_transaction2_spi_rsp *pSMBr = NULL; 3127 char *parm_data; 3128 int name_len; 3129 int rc = 0; 3130 int bytes_returned = 0; 3131 __u16 params, byte_count, data_count, param_offset, offset; 3132 3133 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName); 3134 setAclRetry: 3135 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3136 (void **) &pSMBr); 3137 if (rc) 3138 return rc; 3139 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3140 name_len = 3141 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 3142 PATH_MAX, nls_codepage, remap); 3143 name_len++; /* trailing null */ 3144 name_len *= 2; 3145 } else { 3146 name_len = copy_path_name(pSMB->FileName, fileName); 3147 } 3148 params = 6 + name_len; 3149 pSMB->MaxParameterCount = cpu_to_le16(2); 3150 /* BB find max SMB size from sess */ 3151 pSMB->MaxDataCount = cpu_to_le16(1000); 3152 pSMB->MaxSetupCount = 0; 3153 pSMB->Reserved = 0; 3154 pSMB->Flags = 0; 3155 pSMB->Timeout = 0; 3156 pSMB->Reserved2 = 0; 3157 param_offset = offsetof(struct smb_com_transaction2_spi_req, 3158 InformationLevel) - 4; 3159 offset = param_offset + params; 3160 parm_data = ((char *)pSMB) + sizeof(pSMB->hdr.smb_buf_length) + offset; 3161 pSMB->ParameterOffset = cpu_to_le16(param_offset); 3162 3163 /* convert to on the wire format for POSIX ACL */ 3164 data_count = posix_acl_to_cifs(parm_data, acl, acl_type); 3165 3166 if (data_count == 0) { 3167 rc = -EOPNOTSUPP; 3168 goto setACLerrorExit; 3169 } 3170 pSMB->DataOffset = cpu_to_le16(offset); 3171 pSMB->SetupCount = 1; 3172 pSMB->Reserved3 = 0; 3173 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 3174 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL); 3175 byte_count = 3 /* pad */ + params + data_count; 3176 pSMB->DataCount = cpu_to_le16(data_count); 3177 pSMB->TotalDataCount = pSMB->DataCount; 3178 pSMB->ParameterCount = cpu_to_le16(params); 3179 pSMB->TotalParameterCount = pSMB->ParameterCount; 3180 pSMB->Reserved4 = 0; 3181 inc_rfc1001_len(pSMB, byte_count); 3182 pSMB->ByteCount = cpu_to_le16(byte_count); 3183 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3184 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3185 if (rc) 3186 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc); 3187 3188 setACLerrorExit: 3189 cifs_buf_release(pSMB); 3190 if (rc == -EAGAIN) 3191 goto setAclRetry; 3192 return rc; 3193 } 3194 #else 3195 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon, 3196 const unsigned char *searchName, struct posix_acl **acl, 3197 const int acl_type, const struct nls_table *nls_codepage, 3198 int remap) 3199 { 3200 return -EOPNOTSUPP; 3201 } 3202 3203 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 3204 const unsigned char *fileName, const struct posix_acl *acl, 3205 const int acl_type, const struct nls_table *nls_codepage, 3206 int remap) 3207 { 3208 return -EOPNOTSUPP; 3209 } 3210 #endif /* CONFIG_FS_POSIX_ACL */ 3211 3212 int 3213 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon, 3214 const int netfid, __u64 *pExtAttrBits, __u64 *pMask) 3215 { 3216 int rc = 0; 3217 struct smb_t2_qfi_req *pSMB = NULL; 3218 struct smb_t2_qfi_rsp *pSMBr = NULL; 3219 int bytes_returned; 3220 __u16 params, byte_count; 3221 3222 cifs_dbg(FYI, "In GetExtAttr\n"); 3223 if (tcon == NULL) 3224 return -ENODEV; 3225 3226 GetExtAttrRetry: 3227 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3228 (void **) &pSMBr); 3229 if (rc) 3230 return rc; 3231 3232 params = 2 /* level */ + 2 /* fid */; 3233 pSMB->t2.TotalDataCount = 0; 3234 pSMB->t2.MaxParameterCount = cpu_to_le16(4); 3235 /* BB find exact max data count below from sess structure BB */ 3236 pSMB->t2.MaxDataCount = cpu_to_le16(4000); 3237 pSMB->t2.MaxSetupCount = 0; 3238 pSMB->t2.Reserved = 0; 3239 pSMB->t2.Flags = 0; 3240 pSMB->t2.Timeout = 0; 3241 pSMB->t2.Reserved2 = 0; 3242 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req, 3243 Fid) - 4); 3244 pSMB->t2.DataCount = 0; 3245 pSMB->t2.DataOffset = 0; 3246 pSMB->t2.SetupCount = 1; 3247 pSMB->t2.Reserved3 = 0; 3248 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 3249 byte_count = params + 1 /* pad */ ; 3250 pSMB->t2.TotalParameterCount = cpu_to_le16(params); 3251 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount; 3252 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS); 3253 pSMB->Pad = 0; 3254 pSMB->Fid = netfid; 3255 inc_rfc1001_len(pSMB, byte_count); 3256 pSMB->t2.ByteCount = cpu_to_le16(byte_count); 3257 3258 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3259 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3260 if (rc) { 3261 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc); 3262 } else { 3263 /* decode response */ 3264 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3265 /* BB also check enough total bytes returned */ 3266 if (rc || get_bcc(&pSMBr->hdr) < 2) 3267 /* If rc should we check for EOPNOSUPP and 3268 disable the srvino flag? or in caller? */ 3269 rc = -EIO; /* bad smb */ 3270 else { 3271 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3272 __u16 count = le16_to_cpu(pSMBr->t2.DataCount); 3273 struct file_chattr_info *pfinfo; 3274 3275 if (count != 16) { 3276 cifs_dbg(FYI, "Invalid size ret in GetExtAttr\n"); 3277 rc = -EIO; 3278 goto GetExtAttrOut; 3279 } 3280 pfinfo = (struct file_chattr_info *) 3281 (data_offset + (char *) &pSMBr->hdr.Protocol); 3282 *pExtAttrBits = le64_to_cpu(pfinfo->mode); 3283 *pMask = le64_to_cpu(pfinfo->mask); 3284 } 3285 } 3286 GetExtAttrOut: 3287 cifs_buf_release(pSMB); 3288 if (rc == -EAGAIN) 3289 goto GetExtAttrRetry; 3290 return rc; 3291 } 3292 3293 #endif /* CONFIG_POSIX */ 3294 3295 /* 3296 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that 3297 * all NT TRANSACTS that we init here have total parm and data under about 400 3298 * bytes (to fit in small cifs buffer size), which is the case so far, it 3299 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of 3300 * returned setup area) and MaxParameterCount (returned parms size) must be set 3301 * by caller 3302 */ 3303 static int 3304 smb_init_nttransact(const __u16 sub_command, const int setup_count, 3305 const int parm_len, struct cifs_tcon *tcon, 3306 void **ret_buf) 3307 { 3308 int rc; 3309 __u32 temp_offset; 3310 struct smb_com_ntransact_req *pSMB; 3311 3312 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon, 3313 (void **)&pSMB); 3314 if (rc) 3315 return rc; 3316 *ret_buf = (void *)pSMB; 3317 pSMB->Reserved = 0; 3318 pSMB->TotalParameterCount = cpu_to_le32(parm_len); 3319 pSMB->TotalDataCount = 0; 3320 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00); 3321 pSMB->ParameterCount = pSMB->TotalParameterCount; 3322 pSMB->DataCount = pSMB->TotalDataCount; 3323 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) + 3324 (setup_count * 2) - 4 /* for rfc1001 length itself */; 3325 pSMB->ParameterOffset = cpu_to_le32(temp_offset); 3326 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len); 3327 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */ 3328 pSMB->SubCommand = cpu_to_le16(sub_command); 3329 return 0; 3330 } 3331 3332 static int 3333 validate_ntransact(char *buf, char **ppparm, char **ppdata, 3334 __u32 *pparmlen, __u32 *pdatalen) 3335 { 3336 char *end_of_smb; 3337 __u32 data_count, data_offset, parm_count, parm_offset; 3338 struct smb_com_ntransact_rsp *pSMBr; 3339 u16 bcc; 3340 3341 *pdatalen = 0; 3342 *pparmlen = 0; 3343 3344 if (buf == NULL) 3345 return -EINVAL; 3346 3347 pSMBr = (struct smb_com_ntransact_rsp *)buf; 3348 3349 bcc = get_bcc(&pSMBr->hdr); 3350 end_of_smb = 2 /* sizeof byte count */ + bcc + 3351 (char *)&pSMBr->ByteCount; 3352 3353 data_offset = le32_to_cpu(pSMBr->DataOffset); 3354 data_count = le32_to_cpu(pSMBr->DataCount); 3355 parm_offset = le32_to_cpu(pSMBr->ParameterOffset); 3356 parm_count = le32_to_cpu(pSMBr->ParameterCount); 3357 3358 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset; 3359 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset; 3360 3361 /* should we also check that parm and data areas do not overlap? */ 3362 if (*ppparm > end_of_smb) { 3363 cifs_dbg(FYI, "parms start after end of smb\n"); 3364 return -EINVAL; 3365 } else if (parm_count + *ppparm > end_of_smb) { 3366 cifs_dbg(FYI, "parm end after end of smb\n"); 3367 return -EINVAL; 3368 } else if (*ppdata > end_of_smb) { 3369 cifs_dbg(FYI, "data starts after end of smb\n"); 3370 return -EINVAL; 3371 } else if (data_count + *ppdata > end_of_smb) { 3372 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n", 3373 *ppdata, data_count, (data_count + *ppdata), 3374 end_of_smb, pSMBr); 3375 return -EINVAL; 3376 } else if (parm_count + data_count > bcc) { 3377 cifs_dbg(FYI, "parm count and data count larger than SMB\n"); 3378 return -EINVAL; 3379 } 3380 *pdatalen = data_count; 3381 *pparmlen = parm_count; 3382 return 0; 3383 } 3384 3385 /* Get Security Descriptor (by handle) from remote server for a file or dir */ 3386 int 3387 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid, 3388 struct cifs_ntsd **acl_inf, __u32 *pbuflen) 3389 { 3390 int rc = 0; 3391 int buf_type = 0; 3392 QUERY_SEC_DESC_REQ *pSMB; 3393 struct kvec iov[1]; 3394 struct kvec rsp_iov; 3395 3396 cifs_dbg(FYI, "GetCifsACL\n"); 3397 3398 *pbuflen = 0; 3399 *acl_inf = NULL; 3400 3401 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0, 3402 8 /* parm len */, tcon, (void **) &pSMB); 3403 if (rc) 3404 return rc; 3405 3406 pSMB->MaxParameterCount = cpu_to_le32(4); 3407 /* BB TEST with big acls that might need to be e.g. larger than 16K */ 3408 pSMB->MaxSetupCount = 0; 3409 pSMB->Fid = fid; /* file handle always le */ 3410 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP | 3411 CIFS_ACL_DACL); 3412 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */ 3413 inc_rfc1001_len(pSMB, 11); 3414 iov[0].iov_base = (char *)pSMB; 3415 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4; 3416 3417 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type, 3418 0, &rsp_iov); 3419 cifs_small_buf_release(pSMB); 3420 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get); 3421 if (rc) { 3422 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc); 3423 } else { /* decode response */ 3424 __le32 *parm; 3425 __u32 parm_len; 3426 __u32 acl_len; 3427 struct smb_com_ntransact_rsp *pSMBr; 3428 char *pdata; 3429 3430 /* validate_nttransact */ 3431 rc = validate_ntransact(rsp_iov.iov_base, (char **)&parm, 3432 &pdata, &parm_len, pbuflen); 3433 if (rc) 3434 goto qsec_out; 3435 pSMBr = (struct smb_com_ntransact_rsp *)rsp_iov.iov_base; 3436 3437 cifs_dbg(FYI, "smb %p parm %p data %p\n", 3438 pSMBr, parm, *acl_inf); 3439 3440 if (le32_to_cpu(pSMBr->ParameterCount) != 4) { 3441 rc = -EIO; /* bad smb */ 3442 *pbuflen = 0; 3443 goto qsec_out; 3444 } 3445 3446 /* BB check that data area is minimum length and as big as acl_len */ 3447 3448 acl_len = le32_to_cpu(*parm); 3449 if (acl_len != *pbuflen) { 3450 cifs_dbg(VFS, "acl length %d does not match %d\n", 3451 acl_len, *pbuflen); 3452 if (*pbuflen > acl_len) 3453 *pbuflen = acl_len; 3454 } 3455 3456 /* check if buffer is big enough for the acl 3457 header followed by the smallest SID */ 3458 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) || 3459 (*pbuflen >= 64 * 1024)) { 3460 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen); 3461 rc = -EINVAL; 3462 *pbuflen = 0; 3463 } else { 3464 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL); 3465 if (*acl_inf == NULL) { 3466 *pbuflen = 0; 3467 rc = -ENOMEM; 3468 } 3469 } 3470 } 3471 qsec_out: 3472 free_rsp_buf(buf_type, rsp_iov.iov_base); 3473 return rc; 3474 } 3475 3476 int 3477 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid, 3478 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag) 3479 { 3480 __u16 byte_count, param_count, data_count, param_offset, data_offset; 3481 int rc = 0; 3482 int bytes_returned = 0; 3483 SET_SEC_DESC_REQ *pSMB = NULL; 3484 void *pSMBr; 3485 3486 setCifsAclRetry: 3487 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr); 3488 if (rc) 3489 return rc; 3490 3491 pSMB->MaxSetupCount = 0; 3492 pSMB->Reserved = 0; 3493 3494 param_count = 8; 3495 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4; 3496 data_count = acllen; 3497 data_offset = param_offset + param_count; 3498 byte_count = 3 /* pad */ + param_count; 3499 3500 pSMB->DataCount = cpu_to_le32(data_count); 3501 pSMB->TotalDataCount = pSMB->DataCount; 3502 pSMB->MaxParameterCount = cpu_to_le32(4); 3503 pSMB->MaxDataCount = cpu_to_le32(16384); 3504 pSMB->ParameterCount = cpu_to_le32(param_count); 3505 pSMB->ParameterOffset = cpu_to_le32(param_offset); 3506 pSMB->TotalParameterCount = pSMB->ParameterCount; 3507 pSMB->DataOffset = cpu_to_le32(data_offset); 3508 pSMB->SetupCount = 0; 3509 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC); 3510 pSMB->ByteCount = cpu_to_le16(byte_count+data_count); 3511 3512 pSMB->Fid = fid; /* file handle always le */ 3513 pSMB->Reserved2 = 0; 3514 pSMB->AclFlags = cpu_to_le32(aclflag); 3515 3516 if (pntsd && acllen) { 3517 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) + 3518 data_offset, pntsd, acllen); 3519 inc_rfc1001_len(pSMB, byte_count + data_count); 3520 } else 3521 inc_rfc1001_len(pSMB, byte_count); 3522 3523 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3524 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3525 3526 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n", 3527 bytes_returned, rc); 3528 if (rc) 3529 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc); 3530 cifs_buf_release(pSMB); 3531 3532 if (rc == -EAGAIN) 3533 goto setCifsAclRetry; 3534 3535 return (rc); 3536 } 3537 3538 3539 /* Legacy Query Path Information call for lookup to old servers such 3540 as Win9x/WinME */ 3541 int 3542 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon, 3543 const char *search_name, FILE_ALL_INFO *data, 3544 const struct nls_table *nls_codepage, int remap) 3545 { 3546 QUERY_INFORMATION_REQ *pSMB; 3547 QUERY_INFORMATION_RSP *pSMBr; 3548 int rc = 0; 3549 int bytes_returned; 3550 int name_len; 3551 3552 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name); 3553 QInfRetry: 3554 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB, 3555 (void **) &pSMBr); 3556 if (rc) 3557 return rc; 3558 3559 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3560 name_len = 3561 cifsConvertToUTF16((__le16 *) pSMB->FileName, 3562 search_name, PATH_MAX, nls_codepage, 3563 remap); 3564 name_len++; /* trailing null */ 3565 name_len *= 2; 3566 } else { 3567 name_len = copy_path_name(pSMB->FileName, search_name); 3568 } 3569 pSMB->BufferFormat = 0x04; 3570 name_len++; /* account for buffer type byte */ 3571 inc_rfc1001_len(pSMB, (__u16)name_len); 3572 pSMB->ByteCount = cpu_to_le16(name_len); 3573 3574 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3575 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3576 if (rc) { 3577 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc); 3578 } else if (data) { 3579 struct timespec64 ts; 3580 __u32 time = le32_to_cpu(pSMBr->last_write_time); 3581 3582 /* decode response */ 3583 /* BB FIXME - add time zone adjustment BB */ 3584 memset(data, 0, sizeof(FILE_ALL_INFO)); 3585 ts.tv_nsec = 0; 3586 ts.tv_sec = time; 3587 /* decode time fields */ 3588 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts)); 3589 data->LastWriteTime = data->ChangeTime; 3590 data->LastAccessTime = 0; 3591 data->AllocationSize = 3592 cpu_to_le64(le32_to_cpu(pSMBr->size)); 3593 data->EndOfFile = data->AllocationSize; 3594 data->Attributes = 3595 cpu_to_le32(le16_to_cpu(pSMBr->attr)); 3596 } else 3597 rc = -EIO; /* bad buffer passed in */ 3598 3599 cifs_buf_release(pSMB); 3600 3601 if (rc == -EAGAIN) 3602 goto QInfRetry; 3603 3604 return rc; 3605 } 3606 3607 int 3608 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 3609 u16 netfid, FILE_ALL_INFO *pFindData) 3610 { 3611 struct smb_t2_qfi_req *pSMB = NULL; 3612 struct smb_t2_qfi_rsp *pSMBr = NULL; 3613 int rc = 0; 3614 int bytes_returned; 3615 __u16 params, byte_count; 3616 3617 QFileInfoRetry: 3618 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3619 (void **) &pSMBr); 3620 if (rc) 3621 return rc; 3622 3623 params = 2 /* level */ + 2 /* fid */; 3624 pSMB->t2.TotalDataCount = 0; 3625 pSMB->t2.MaxParameterCount = cpu_to_le16(4); 3626 /* BB find exact max data count below from sess structure BB */ 3627 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 3628 pSMB->t2.MaxSetupCount = 0; 3629 pSMB->t2.Reserved = 0; 3630 pSMB->t2.Flags = 0; 3631 pSMB->t2.Timeout = 0; 3632 pSMB->t2.Reserved2 = 0; 3633 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req, 3634 Fid) - 4); 3635 pSMB->t2.DataCount = 0; 3636 pSMB->t2.DataOffset = 0; 3637 pSMB->t2.SetupCount = 1; 3638 pSMB->t2.Reserved3 = 0; 3639 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 3640 byte_count = params + 1 /* pad */ ; 3641 pSMB->t2.TotalParameterCount = cpu_to_le16(params); 3642 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount; 3643 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO); 3644 pSMB->Pad = 0; 3645 pSMB->Fid = netfid; 3646 inc_rfc1001_len(pSMB, byte_count); 3647 pSMB->t2.ByteCount = cpu_to_le16(byte_count); 3648 3649 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3650 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3651 if (rc) { 3652 cifs_dbg(FYI, "Send error in QFileInfo = %d\n", rc); 3653 } else { /* decode response */ 3654 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3655 3656 if (rc) /* BB add auto retry on EOPNOTSUPP? */ 3657 rc = -EIO; 3658 else if (get_bcc(&pSMBr->hdr) < 40) 3659 rc = -EIO; /* bad smb */ 3660 else if (pFindData) { 3661 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3662 memcpy((char *) pFindData, 3663 (char *) &pSMBr->hdr.Protocol + 3664 data_offset, sizeof(FILE_ALL_INFO)); 3665 } else 3666 rc = -ENOMEM; 3667 } 3668 cifs_buf_release(pSMB); 3669 if (rc == -EAGAIN) 3670 goto QFileInfoRetry; 3671 3672 return rc; 3673 } 3674 3675 int 3676 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 3677 const char *search_name, FILE_ALL_INFO *data, 3678 int legacy /* old style infolevel */, 3679 const struct nls_table *nls_codepage, int remap) 3680 { 3681 /* level 263 SMB_QUERY_FILE_ALL_INFO */ 3682 TRANSACTION2_QPI_REQ *pSMB = NULL; 3683 TRANSACTION2_QPI_RSP *pSMBr = NULL; 3684 int rc = 0; 3685 int bytes_returned; 3686 int name_len; 3687 __u16 params, byte_count; 3688 3689 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */ 3690 QPathInfoRetry: 3691 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3692 (void **) &pSMBr); 3693 if (rc) 3694 return rc; 3695 3696 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3697 name_len = 3698 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name, 3699 PATH_MAX, nls_codepage, remap); 3700 name_len++; /* trailing null */ 3701 name_len *= 2; 3702 } else { 3703 name_len = copy_path_name(pSMB->FileName, search_name); 3704 } 3705 3706 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */; 3707 pSMB->TotalDataCount = 0; 3708 pSMB->MaxParameterCount = cpu_to_le16(2); 3709 /* BB find exact max SMB PDU from sess structure BB */ 3710 pSMB->MaxDataCount = cpu_to_le16(4000); 3711 pSMB->MaxSetupCount = 0; 3712 pSMB->Reserved = 0; 3713 pSMB->Flags = 0; 3714 pSMB->Timeout = 0; 3715 pSMB->Reserved2 = 0; 3716 pSMB->ParameterOffset = cpu_to_le16(offsetof( 3717 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 3718 pSMB->DataCount = 0; 3719 pSMB->DataOffset = 0; 3720 pSMB->SetupCount = 1; 3721 pSMB->Reserved3 = 0; 3722 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 3723 byte_count = params + 1 /* pad */ ; 3724 pSMB->TotalParameterCount = cpu_to_le16(params); 3725 pSMB->ParameterCount = pSMB->TotalParameterCount; 3726 if (legacy) 3727 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD); 3728 else 3729 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO); 3730 pSMB->Reserved4 = 0; 3731 inc_rfc1001_len(pSMB, byte_count); 3732 pSMB->ByteCount = cpu_to_le16(byte_count); 3733 3734 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3735 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3736 if (rc) { 3737 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc); 3738 } else { /* decode response */ 3739 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3740 3741 if (rc) /* BB add auto retry on EOPNOTSUPP? */ 3742 rc = -EIO; 3743 else if (!legacy && get_bcc(&pSMBr->hdr) < 40) 3744 rc = -EIO; /* bad smb */ 3745 else if (legacy && get_bcc(&pSMBr->hdr) < 24) 3746 rc = -EIO; /* 24 or 26 expected but we do not read 3747 last field */ 3748 else if (data) { 3749 int size; 3750 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3751 3752 /* 3753 * On legacy responses we do not read the last field, 3754 * EAsize, fortunately since it varies by subdialect and 3755 * also note it differs on Set vs Get, ie two bytes or 4 3756 * bytes depending but we don't care here. 3757 */ 3758 if (legacy) 3759 size = sizeof(FILE_INFO_STANDARD); 3760 else 3761 size = sizeof(FILE_ALL_INFO); 3762 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol + 3763 data_offset, size); 3764 } else 3765 rc = -ENOMEM; 3766 } 3767 cifs_buf_release(pSMB); 3768 if (rc == -EAGAIN) 3769 goto QPathInfoRetry; 3770 3771 return rc; 3772 } 3773 3774 int 3775 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 3776 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData) 3777 { 3778 struct smb_t2_qfi_req *pSMB = NULL; 3779 struct smb_t2_qfi_rsp *pSMBr = NULL; 3780 int rc = 0; 3781 int bytes_returned; 3782 __u16 params, byte_count; 3783 3784 UnixQFileInfoRetry: 3785 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3786 (void **) &pSMBr); 3787 if (rc) 3788 return rc; 3789 3790 params = 2 /* level */ + 2 /* fid */; 3791 pSMB->t2.TotalDataCount = 0; 3792 pSMB->t2.MaxParameterCount = cpu_to_le16(4); 3793 /* BB find exact max data count below from sess structure BB */ 3794 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 3795 pSMB->t2.MaxSetupCount = 0; 3796 pSMB->t2.Reserved = 0; 3797 pSMB->t2.Flags = 0; 3798 pSMB->t2.Timeout = 0; 3799 pSMB->t2.Reserved2 = 0; 3800 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req, 3801 Fid) - 4); 3802 pSMB->t2.DataCount = 0; 3803 pSMB->t2.DataOffset = 0; 3804 pSMB->t2.SetupCount = 1; 3805 pSMB->t2.Reserved3 = 0; 3806 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION); 3807 byte_count = params + 1 /* pad */ ; 3808 pSMB->t2.TotalParameterCount = cpu_to_le16(params); 3809 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount; 3810 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC); 3811 pSMB->Pad = 0; 3812 pSMB->Fid = netfid; 3813 inc_rfc1001_len(pSMB, byte_count); 3814 pSMB->t2.ByteCount = cpu_to_le16(byte_count); 3815 3816 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3817 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3818 if (rc) { 3819 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d\n", rc); 3820 } else { /* decode response */ 3821 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3822 3823 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) { 3824 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n"); 3825 rc = -EIO; /* bad smb */ 3826 } else { 3827 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3828 memcpy((char *) pFindData, 3829 (char *) &pSMBr->hdr.Protocol + 3830 data_offset, 3831 sizeof(FILE_UNIX_BASIC_INFO)); 3832 } 3833 } 3834 3835 cifs_buf_release(pSMB); 3836 if (rc == -EAGAIN) 3837 goto UnixQFileInfoRetry; 3838 3839 return rc; 3840 } 3841 3842 int 3843 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 3844 const unsigned char *searchName, 3845 FILE_UNIX_BASIC_INFO *pFindData, 3846 const struct nls_table *nls_codepage, int remap) 3847 { 3848 /* SMB_QUERY_FILE_UNIX_BASIC */ 3849 TRANSACTION2_QPI_REQ *pSMB = NULL; 3850 TRANSACTION2_QPI_RSP *pSMBr = NULL; 3851 int rc = 0; 3852 int bytes_returned = 0; 3853 int name_len; 3854 __u16 params, byte_count; 3855 3856 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName); 3857 UnixQPathInfoRetry: 3858 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3859 (void **) &pSMBr); 3860 if (rc) 3861 return rc; 3862 3863 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3864 name_len = 3865 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName, 3866 PATH_MAX, nls_codepage, remap); 3867 name_len++; /* trailing null */ 3868 name_len *= 2; 3869 } else { 3870 name_len = copy_path_name(pSMB->FileName, searchName); 3871 } 3872 3873 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */; 3874 pSMB->TotalDataCount = 0; 3875 pSMB->MaxParameterCount = cpu_to_le16(2); 3876 /* BB find exact max SMB PDU from sess structure BB */ 3877 pSMB->MaxDataCount = cpu_to_le16(4000); 3878 pSMB->MaxSetupCount = 0; 3879 pSMB->Reserved = 0; 3880 pSMB->Flags = 0; 3881 pSMB->Timeout = 0; 3882 pSMB->Reserved2 = 0; 3883 pSMB->ParameterOffset = cpu_to_le16(offsetof( 3884 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 3885 pSMB->DataCount = 0; 3886 pSMB->DataOffset = 0; 3887 pSMB->SetupCount = 1; 3888 pSMB->Reserved3 = 0; 3889 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 3890 byte_count = params + 1 /* pad */ ; 3891 pSMB->TotalParameterCount = cpu_to_le16(params); 3892 pSMB->ParameterCount = pSMB->TotalParameterCount; 3893 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC); 3894 pSMB->Reserved4 = 0; 3895 inc_rfc1001_len(pSMB, byte_count); 3896 pSMB->ByteCount = cpu_to_le16(byte_count); 3897 3898 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 3899 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 3900 if (rc) { 3901 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d\n", rc); 3902 } else { /* decode response */ 3903 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 3904 3905 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) { 3906 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n"); 3907 rc = -EIO; /* bad smb */ 3908 } else { 3909 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 3910 memcpy((char *) pFindData, 3911 (char *) &pSMBr->hdr.Protocol + 3912 data_offset, 3913 sizeof(FILE_UNIX_BASIC_INFO)); 3914 } 3915 } 3916 cifs_buf_release(pSMB); 3917 if (rc == -EAGAIN) 3918 goto UnixQPathInfoRetry; 3919 3920 return rc; 3921 } 3922 3923 /* xid, tcon, searchName and codepage are input parms, rest are returned */ 3924 int 3925 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon, 3926 const char *searchName, struct cifs_sb_info *cifs_sb, 3927 __u16 *pnetfid, __u16 search_flags, 3928 struct cifs_search_info *psrch_inf, bool msearch) 3929 { 3930 /* level 257 SMB_ */ 3931 TRANSACTION2_FFIRST_REQ *pSMB = NULL; 3932 TRANSACTION2_FFIRST_RSP *pSMBr = NULL; 3933 T2_FFIRST_RSP_PARMS *parms; 3934 struct nls_table *nls_codepage; 3935 unsigned int lnoff; 3936 __u16 params, byte_count; 3937 int bytes_returned = 0; 3938 int name_len, remap; 3939 int rc = 0; 3940 3941 cifs_dbg(FYI, "In FindFirst for %s\n", searchName); 3942 3943 findFirstRetry: 3944 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 3945 (void **) &pSMBr); 3946 if (rc) 3947 return rc; 3948 3949 nls_codepage = cifs_sb->local_nls; 3950 remap = cifs_remap(cifs_sb); 3951 3952 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 3953 name_len = 3954 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName, 3955 PATH_MAX, nls_codepage, remap); 3956 /* We can not add the asterik earlier in case 3957 it got remapped to 0xF03A as if it were part of the 3958 directory name instead of a wildcard */ 3959 name_len *= 2; 3960 if (msearch) { 3961 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb); 3962 pSMB->FileName[name_len+1] = 0; 3963 pSMB->FileName[name_len+2] = '*'; 3964 pSMB->FileName[name_len+3] = 0; 3965 name_len += 4; /* now the trailing null */ 3966 /* null terminate just in case */ 3967 pSMB->FileName[name_len] = 0; 3968 pSMB->FileName[name_len+1] = 0; 3969 name_len += 2; 3970 } 3971 } else { 3972 name_len = copy_path_name(pSMB->FileName, searchName); 3973 if (msearch) { 3974 if (WARN_ON_ONCE(name_len > PATH_MAX-2)) 3975 name_len = PATH_MAX-2; 3976 /* overwrite nul byte */ 3977 pSMB->FileName[name_len-1] = CIFS_DIR_SEP(cifs_sb); 3978 pSMB->FileName[name_len] = '*'; 3979 pSMB->FileName[name_len+1] = 0; 3980 name_len += 2; 3981 } 3982 } 3983 3984 params = 12 + name_len /* includes null */ ; 3985 pSMB->TotalDataCount = 0; /* no EAs */ 3986 pSMB->MaxParameterCount = cpu_to_le16(10); 3987 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00); 3988 pSMB->MaxSetupCount = 0; 3989 pSMB->Reserved = 0; 3990 pSMB->Flags = 0; 3991 pSMB->Timeout = 0; 3992 pSMB->Reserved2 = 0; 3993 byte_count = params + 1 /* pad */ ; 3994 pSMB->TotalParameterCount = cpu_to_le16(params); 3995 pSMB->ParameterCount = pSMB->TotalParameterCount; 3996 pSMB->ParameterOffset = cpu_to_le16( 3997 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes) 3998 - 4); 3999 pSMB->DataCount = 0; 4000 pSMB->DataOffset = 0; 4001 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */ 4002 pSMB->Reserved3 = 0; 4003 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST); 4004 pSMB->SearchAttributes = 4005 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM | 4006 ATTR_DIRECTORY); 4007 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO)); 4008 pSMB->SearchFlags = cpu_to_le16(search_flags); 4009 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level); 4010 4011 /* BB what should we set StorageType to? Does it matter? BB */ 4012 pSMB->SearchStorageType = 0; 4013 inc_rfc1001_len(pSMB, byte_count); 4014 pSMB->ByteCount = cpu_to_le16(byte_count); 4015 4016 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4017 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4018 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst); 4019 4020 if (rc) { 4021 /* 4022 * BB: add logic to retry regular search if Unix search rejected 4023 * unexpectedly by server. 4024 */ 4025 /* BB: add code to handle unsupported level rc */ 4026 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc); 4027 cifs_buf_release(pSMB); 4028 /* 4029 * BB: eventually could optimize out free and realloc of buf for 4030 * this case. 4031 */ 4032 if (rc == -EAGAIN) 4033 goto findFirstRetry; 4034 return rc; 4035 } 4036 /* decode response */ 4037 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4038 if (rc) { 4039 cifs_buf_release(pSMB); 4040 return rc; 4041 } 4042 4043 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE); 4044 psrch_inf->ntwrk_buf_start = (char *)pSMBr; 4045 psrch_inf->smallBuf = false; 4046 psrch_inf->srch_entries_start = (char *)&pSMBr->hdr.Protocol + 4047 le16_to_cpu(pSMBr->t2.DataOffset); 4048 4049 parms = (T2_FFIRST_RSP_PARMS *)((char *)&pSMBr->hdr.Protocol + 4050 le16_to_cpu(pSMBr->t2.ParameterOffset)); 4051 psrch_inf->endOfSearch = !!parms->EndofSearch; 4052 4053 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount); 4054 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ + 4055 psrch_inf->entries_in_buffer; 4056 lnoff = le16_to_cpu(parms->LastNameOffset); 4057 if (CIFSMaxBufSize < lnoff) { 4058 cifs_dbg(VFS, "ignoring corrupt resume name\n"); 4059 psrch_inf->last_entry = NULL; 4060 } else { 4061 psrch_inf->last_entry = psrch_inf->srch_entries_start + lnoff; 4062 if (pnetfid) 4063 *pnetfid = parms->SearchHandle; 4064 } 4065 return 0; 4066 } 4067 4068 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon, 4069 __u16 searchHandle, __u16 search_flags, 4070 struct cifs_search_info *psrch_inf) 4071 { 4072 TRANSACTION2_FNEXT_REQ *pSMB = NULL; 4073 TRANSACTION2_FNEXT_RSP *pSMBr = NULL; 4074 T2_FNEXT_RSP_PARMS *parms; 4075 unsigned int name_len; 4076 unsigned int lnoff; 4077 __u16 params, byte_count; 4078 char *response_data; 4079 int bytes_returned; 4080 int rc = 0; 4081 4082 cifs_dbg(FYI, "In FindNext\n"); 4083 4084 if (psrch_inf->endOfSearch) 4085 return -ENOENT; 4086 4087 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4088 (void **) &pSMBr); 4089 if (rc) 4090 return rc; 4091 4092 params = 14; /* includes 2 bytes of null string, converted to LE below*/ 4093 byte_count = 0; 4094 pSMB->TotalDataCount = 0; /* no EAs */ 4095 pSMB->MaxParameterCount = cpu_to_le16(8); 4096 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00); 4097 pSMB->MaxSetupCount = 0; 4098 pSMB->Reserved = 0; 4099 pSMB->Flags = 0; 4100 pSMB->Timeout = 0; 4101 pSMB->Reserved2 = 0; 4102 pSMB->ParameterOffset = cpu_to_le16( 4103 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4); 4104 pSMB->DataCount = 0; 4105 pSMB->DataOffset = 0; 4106 pSMB->SetupCount = 1; 4107 pSMB->Reserved3 = 0; 4108 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT); 4109 pSMB->SearchHandle = searchHandle; /* always kept as le */ 4110 pSMB->SearchCount = 4111 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO)); 4112 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level); 4113 pSMB->ResumeKey = psrch_inf->resume_key; 4114 pSMB->SearchFlags = cpu_to_le16(search_flags); 4115 4116 name_len = psrch_inf->resume_name_len; 4117 params += name_len; 4118 if (name_len < PATH_MAX) { 4119 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len); 4120 byte_count += name_len; 4121 /* 14 byte parm len above enough for 2 byte null terminator */ 4122 pSMB->ResumeFileName[name_len] = 0; 4123 pSMB->ResumeFileName[name_len+1] = 0; 4124 } else { 4125 cifs_buf_release(pSMB); 4126 return -EINVAL; 4127 } 4128 byte_count = params + 1 /* pad */ ; 4129 pSMB->TotalParameterCount = cpu_to_le16(params); 4130 pSMB->ParameterCount = pSMB->TotalParameterCount; 4131 inc_rfc1001_len(pSMB, byte_count); 4132 pSMB->ByteCount = cpu_to_le16(byte_count); 4133 4134 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4135 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4136 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext); 4137 4138 if (rc) { 4139 cifs_buf_release(pSMB); 4140 if (rc == -EBADF) { 4141 psrch_inf->endOfSearch = true; 4142 rc = 0; /* search probably was closed at end of search*/ 4143 } else { 4144 cifs_dbg(FYI, "FindNext returned = %d\n", rc); 4145 } 4146 return rc; 4147 } 4148 4149 /* decode response */ 4150 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4151 if (rc) { 4152 cifs_buf_release(pSMB); 4153 return rc; 4154 } 4155 /* BB fixme add lock for file (srch_info) struct here */ 4156 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE); 4157 response_data = (char *)&pSMBr->hdr.Protocol + 4158 le16_to_cpu(pSMBr->t2.ParameterOffset); 4159 parms = (T2_FNEXT_RSP_PARMS *)response_data; 4160 response_data = (char *)&pSMBr->hdr.Protocol + 4161 le16_to_cpu(pSMBr->t2.DataOffset); 4162 4163 if (psrch_inf->smallBuf) 4164 cifs_small_buf_release(psrch_inf->ntwrk_buf_start); 4165 else 4166 cifs_buf_release(psrch_inf->ntwrk_buf_start); 4167 4168 psrch_inf->srch_entries_start = response_data; 4169 psrch_inf->ntwrk_buf_start = (char *)pSMB; 4170 psrch_inf->smallBuf = false; 4171 psrch_inf->endOfSearch = !!parms->EndofSearch; 4172 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount); 4173 psrch_inf->index_of_last_entry += psrch_inf->entries_in_buffer; 4174 lnoff = le16_to_cpu(parms->LastNameOffset); 4175 if (CIFSMaxBufSize < lnoff) { 4176 cifs_dbg(VFS, "ignoring corrupt resume name\n"); 4177 psrch_inf->last_entry = NULL; 4178 } else { 4179 psrch_inf->last_entry = 4180 psrch_inf->srch_entries_start + lnoff; 4181 } 4182 /* BB fixme add unlock here */ 4183 4184 /* 4185 * BB: On error, should we leave previous search buf 4186 * (and count and last entry fields) intact or free the previous one? 4187 * 4188 * Note: On -EAGAIN error only caller can retry on handle based calls 4189 * since file handle passed in no longer valid. 4190 */ 4191 return 0; 4192 } 4193 4194 int 4195 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon, 4196 const __u16 searchHandle) 4197 { 4198 int rc = 0; 4199 FINDCLOSE_REQ *pSMB = NULL; 4200 4201 cifs_dbg(FYI, "In CIFSSMBFindClose\n"); 4202 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB); 4203 4204 /* no sense returning error if session restarted 4205 as file handle has been closed */ 4206 if (rc == -EAGAIN) 4207 return 0; 4208 if (rc) 4209 return rc; 4210 4211 pSMB->FileID = searchHandle; 4212 pSMB->ByteCount = 0; 4213 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 4214 cifs_small_buf_release(pSMB); 4215 if (rc) 4216 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc); 4217 4218 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose); 4219 4220 /* Since session is dead, search handle closed on server already */ 4221 if (rc == -EAGAIN) 4222 rc = 0; 4223 4224 return rc; 4225 } 4226 4227 int 4228 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon, 4229 const char *search_name, __u64 *inode_number, 4230 const struct nls_table *nls_codepage, int remap) 4231 { 4232 int rc = 0; 4233 TRANSACTION2_QPI_REQ *pSMB = NULL; 4234 TRANSACTION2_QPI_RSP *pSMBr = NULL; 4235 int name_len, bytes_returned; 4236 __u16 params, byte_count; 4237 4238 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name); 4239 if (tcon == NULL) 4240 return -ENODEV; 4241 4242 GetInodeNumberRetry: 4243 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4244 (void **) &pSMBr); 4245 if (rc) 4246 return rc; 4247 4248 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 4249 name_len = 4250 cifsConvertToUTF16((__le16 *) pSMB->FileName, 4251 search_name, PATH_MAX, nls_codepage, 4252 remap); 4253 name_len++; /* trailing null */ 4254 name_len *= 2; 4255 } else { 4256 name_len = copy_path_name(pSMB->FileName, search_name); 4257 } 4258 4259 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ; 4260 pSMB->TotalDataCount = 0; 4261 pSMB->MaxParameterCount = cpu_to_le16(2); 4262 /* BB find exact max data count below from sess structure BB */ 4263 pSMB->MaxDataCount = cpu_to_le16(4000); 4264 pSMB->MaxSetupCount = 0; 4265 pSMB->Reserved = 0; 4266 pSMB->Flags = 0; 4267 pSMB->Timeout = 0; 4268 pSMB->Reserved2 = 0; 4269 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4270 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 4271 pSMB->DataCount = 0; 4272 pSMB->DataOffset = 0; 4273 pSMB->SetupCount = 1; 4274 pSMB->Reserved3 = 0; 4275 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 4276 byte_count = params + 1 /* pad */ ; 4277 pSMB->TotalParameterCount = cpu_to_le16(params); 4278 pSMB->ParameterCount = pSMB->TotalParameterCount; 4279 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO); 4280 pSMB->Reserved4 = 0; 4281 inc_rfc1001_len(pSMB, byte_count); 4282 pSMB->ByteCount = cpu_to_le16(byte_count); 4283 4284 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4285 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4286 if (rc) { 4287 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc); 4288 } else { 4289 /* decode response */ 4290 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4291 /* BB also check enough total bytes returned */ 4292 if (rc || get_bcc(&pSMBr->hdr) < 2) 4293 /* If rc should we check for EOPNOSUPP and 4294 disable the srvino flag? or in caller? */ 4295 rc = -EIO; /* bad smb */ 4296 else { 4297 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4298 __u16 count = le16_to_cpu(pSMBr->t2.DataCount); 4299 struct file_internal_info *pfinfo; 4300 /* BB Do we need a cast or hash here ? */ 4301 if (count < 8) { 4302 cifs_dbg(FYI, "Invalid size ret in QryIntrnlInf\n"); 4303 rc = -EIO; 4304 goto GetInodeNumOut; 4305 } 4306 pfinfo = (struct file_internal_info *) 4307 (data_offset + (char *) &pSMBr->hdr.Protocol); 4308 *inode_number = le64_to_cpu(pfinfo->UniqueId); 4309 } 4310 } 4311 GetInodeNumOut: 4312 cifs_buf_release(pSMB); 4313 if (rc == -EAGAIN) 4314 goto GetInodeNumberRetry; 4315 return rc; 4316 } 4317 4318 int 4319 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses, 4320 const char *search_name, struct dfs_info3_param **target_nodes, 4321 unsigned int *num_of_nodes, 4322 const struct nls_table *nls_codepage, int remap) 4323 { 4324 /* TRANS2_GET_DFS_REFERRAL */ 4325 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL; 4326 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL; 4327 int rc = 0; 4328 int bytes_returned; 4329 int name_len; 4330 __u16 params, byte_count; 4331 *num_of_nodes = 0; 4332 *target_nodes = NULL; 4333 4334 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name); 4335 if (ses == NULL || ses->tcon_ipc == NULL) 4336 return -ENODEV; 4337 4338 getDFSRetry: 4339 /* 4340 * Use smb_init_no_reconnect() instead of smb_init() as 4341 * CIFSGetDFSRefer() may be called from cifs_reconnect_tcon() and thus 4342 * causing an infinite recursion. 4343 */ 4344 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, ses->tcon_ipc, 4345 (void **)&pSMB, (void **)&pSMBr); 4346 if (rc) 4347 return rc; 4348 4349 /* server pointer checked in called function, 4350 but should never be null here anyway */ 4351 pSMB->hdr.Mid = get_next_mid(ses->server); 4352 pSMB->hdr.Tid = ses->tcon_ipc->tid; 4353 pSMB->hdr.Uid = ses->Suid; 4354 if (ses->capabilities & CAP_STATUS32) 4355 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS; 4356 if (ses->capabilities & CAP_DFS) 4357 pSMB->hdr.Flags2 |= SMBFLG2_DFS; 4358 4359 if (ses->capabilities & CAP_UNICODE) { 4360 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE; 4361 name_len = 4362 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName, 4363 search_name, PATH_MAX, nls_codepage, 4364 remap); 4365 name_len++; /* trailing null */ 4366 name_len *= 2; 4367 } else { /* BB improve the check for buffer overruns BB */ 4368 name_len = copy_path_name(pSMB->RequestFileName, search_name); 4369 } 4370 4371 if (ses->server->sign) 4372 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE; 4373 4374 pSMB->hdr.Uid = ses->Suid; 4375 4376 params = 2 /* level */ + name_len /*includes null */ ; 4377 pSMB->TotalDataCount = 0; 4378 pSMB->DataCount = 0; 4379 pSMB->DataOffset = 0; 4380 pSMB->MaxParameterCount = 0; 4381 /* BB find exact max SMB PDU from sess structure BB */ 4382 pSMB->MaxDataCount = cpu_to_le16(4000); 4383 pSMB->MaxSetupCount = 0; 4384 pSMB->Reserved = 0; 4385 pSMB->Flags = 0; 4386 pSMB->Timeout = 0; 4387 pSMB->Reserved2 = 0; 4388 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4389 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4); 4390 pSMB->SetupCount = 1; 4391 pSMB->Reserved3 = 0; 4392 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL); 4393 byte_count = params + 3 /* pad */ ; 4394 pSMB->ParameterCount = cpu_to_le16(params); 4395 pSMB->TotalParameterCount = pSMB->ParameterCount; 4396 pSMB->MaxReferralLevel = cpu_to_le16(3); 4397 inc_rfc1001_len(pSMB, byte_count); 4398 pSMB->ByteCount = cpu_to_le16(byte_count); 4399 4400 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB, 4401 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4402 if (rc) { 4403 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc); 4404 goto GetDFSRefExit; 4405 } 4406 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4407 4408 /* BB Also check if enough total bytes returned? */ 4409 if (rc || get_bcc(&pSMBr->hdr) < 17) { 4410 rc = -EIO; /* bad smb */ 4411 goto GetDFSRefExit; 4412 } 4413 4414 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n", 4415 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset)); 4416 4417 /* parse returned result into more usable form */ 4418 rc = parse_dfs_referrals(&pSMBr->dfs_data, 4419 le16_to_cpu(pSMBr->t2.DataCount), 4420 num_of_nodes, target_nodes, nls_codepage, 4421 remap, search_name, 4422 (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) != 0); 4423 4424 GetDFSRefExit: 4425 cifs_buf_release(pSMB); 4426 4427 if (rc == -EAGAIN) 4428 goto getDFSRetry; 4429 4430 return rc; 4431 } 4432 4433 /* Query File System Info such as free space to old servers such as Win 9x */ 4434 int 4435 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon, 4436 struct kstatfs *FSData) 4437 { 4438 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */ 4439 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4440 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4441 FILE_SYSTEM_ALLOC_INFO *response_data; 4442 int rc = 0; 4443 int bytes_returned = 0; 4444 __u16 params, byte_count; 4445 4446 cifs_dbg(FYI, "OldQFSInfo\n"); 4447 oldQFSInfoRetry: 4448 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4449 (void **) &pSMBr); 4450 if (rc) 4451 return rc; 4452 4453 params = 2; /* level */ 4454 pSMB->TotalDataCount = 0; 4455 pSMB->MaxParameterCount = cpu_to_le16(2); 4456 pSMB->MaxDataCount = cpu_to_le16(1000); 4457 pSMB->MaxSetupCount = 0; 4458 pSMB->Reserved = 0; 4459 pSMB->Flags = 0; 4460 pSMB->Timeout = 0; 4461 pSMB->Reserved2 = 0; 4462 byte_count = params + 1 /* pad */ ; 4463 pSMB->TotalParameterCount = cpu_to_le16(params); 4464 pSMB->ParameterCount = pSMB->TotalParameterCount; 4465 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4466 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4467 pSMB->DataCount = 0; 4468 pSMB->DataOffset = 0; 4469 pSMB->SetupCount = 1; 4470 pSMB->Reserved3 = 0; 4471 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4472 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION); 4473 inc_rfc1001_len(pSMB, byte_count); 4474 pSMB->ByteCount = cpu_to_le16(byte_count); 4475 4476 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4477 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4478 if (rc) { 4479 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc); 4480 } else { /* decode response */ 4481 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4482 4483 if (rc || get_bcc(&pSMBr->hdr) < 18) 4484 rc = -EIO; /* bad smb */ 4485 else { 4486 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4487 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n", 4488 get_bcc(&pSMBr->hdr), data_offset); 4489 4490 response_data = (FILE_SYSTEM_ALLOC_INFO *) 4491 (((char *) &pSMBr->hdr.Protocol) + data_offset); 4492 FSData->f_bsize = 4493 le16_to_cpu(response_data->BytesPerSector) * 4494 le32_to_cpu(response_data-> 4495 SectorsPerAllocationUnit); 4496 /* 4497 * much prefer larger but if server doesn't report 4498 * a valid size than 4K is a reasonable minimum 4499 */ 4500 if (FSData->f_bsize < 512) 4501 FSData->f_bsize = 4096; 4502 4503 FSData->f_blocks = 4504 le32_to_cpu(response_data->TotalAllocationUnits); 4505 FSData->f_bfree = FSData->f_bavail = 4506 le32_to_cpu(response_data->FreeAllocationUnits); 4507 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n", 4508 (unsigned long long)FSData->f_blocks, 4509 (unsigned long long)FSData->f_bfree, 4510 FSData->f_bsize); 4511 } 4512 } 4513 cifs_buf_release(pSMB); 4514 4515 if (rc == -EAGAIN) 4516 goto oldQFSInfoRetry; 4517 4518 return rc; 4519 } 4520 4521 int 4522 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon, 4523 struct kstatfs *FSData) 4524 { 4525 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */ 4526 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4527 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4528 FILE_SYSTEM_INFO *response_data; 4529 int rc = 0; 4530 int bytes_returned = 0; 4531 __u16 params, byte_count; 4532 4533 cifs_dbg(FYI, "In QFSInfo\n"); 4534 QFSInfoRetry: 4535 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4536 (void **) &pSMBr); 4537 if (rc) 4538 return rc; 4539 4540 params = 2; /* level */ 4541 pSMB->TotalDataCount = 0; 4542 pSMB->MaxParameterCount = cpu_to_le16(2); 4543 pSMB->MaxDataCount = cpu_to_le16(1000); 4544 pSMB->MaxSetupCount = 0; 4545 pSMB->Reserved = 0; 4546 pSMB->Flags = 0; 4547 pSMB->Timeout = 0; 4548 pSMB->Reserved2 = 0; 4549 byte_count = params + 1 /* pad */ ; 4550 pSMB->TotalParameterCount = cpu_to_le16(params); 4551 pSMB->ParameterCount = pSMB->TotalParameterCount; 4552 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4553 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4554 pSMB->DataCount = 0; 4555 pSMB->DataOffset = 0; 4556 pSMB->SetupCount = 1; 4557 pSMB->Reserved3 = 0; 4558 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4559 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO); 4560 inc_rfc1001_len(pSMB, byte_count); 4561 pSMB->ByteCount = cpu_to_le16(byte_count); 4562 4563 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4564 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4565 if (rc) { 4566 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc); 4567 } else { /* decode response */ 4568 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4569 4570 if (rc || get_bcc(&pSMBr->hdr) < 24) 4571 rc = -EIO; /* bad smb */ 4572 else { 4573 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4574 4575 response_data = 4576 (FILE_SYSTEM_INFO 4577 *) (((char *) &pSMBr->hdr.Protocol) + 4578 data_offset); 4579 FSData->f_bsize = 4580 le32_to_cpu(response_data->BytesPerSector) * 4581 le32_to_cpu(response_data-> 4582 SectorsPerAllocationUnit); 4583 /* 4584 * much prefer larger but if server doesn't report 4585 * a valid size than 4K is a reasonable minimum 4586 */ 4587 if (FSData->f_bsize < 512) 4588 FSData->f_bsize = 4096; 4589 4590 FSData->f_blocks = 4591 le64_to_cpu(response_data->TotalAllocationUnits); 4592 FSData->f_bfree = FSData->f_bavail = 4593 le64_to_cpu(response_data->FreeAllocationUnits); 4594 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n", 4595 (unsigned long long)FSData->f_blocks, 4596 (unsigned long long)FSData->f_bfree, 4597 FSData->f_bsize); 4598 } 4599 } 4600 cifs_buf_release(pSMB); 4601 4602 if (rc == -EAGAIN) 4603 goto QFSInfoRetry; 4604 4605 return rc; 4606 } 4607 4608 int 4609 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon) 4610 { 4611 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */ 4612 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4613 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4614 FILE_SYSTEM_ATTRIBUTE_INFO *response_data; 4615 int rc = 0; 4616 int bytes_returned = 0; 4617 __u16 params, byte_count; 4618 4619 cifs_dbg(FYI, "In QFSAttributeInfo\n"); 4620 QFSAttributeRetry: 4621 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4622 (void **) &pSMBr); 4623 if (rc) 4624 return rc; 4625 4626 params = 2; /* level */ 4627 pSMB->TotalDataCount = 0; 4628 pSMB->MaxParameterCount = cpu_to_le16(2); 4629 /* BB find exact max SMB PDU from sess structure BB */ 4630 pSMB->MaxDataCount = cpu_to_le16(1000); 4631 pSMB->MaxSetupCount = 0; 4632 pSMB->Reserved = 0; 4633 pSMB->Flags = 0; 4634 pSMB->Timeout = 0; 4635 pSMB->Reserved2 = 0; 4636 byte_count = params + 1 /* pad */ ; 4637 pSMB->TotalParameterCount = cpu_to_le16(params); 4638 pSMB->ParameterCount = pSMB->TotalParameterCount; 4639 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4640 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4641 pSMB->DataCount = 0; 4642 pSMB->DataOffset = 0; 4643 pSMB->SetupCount = 1; 4644 pSMB->Reserved3 = 0; 4645 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4646 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO); 4647 inc_rfc1001_len(pSMB, byte_count); 4648 pSMB->ByteCount = cpu_to_le16(byte_count); 4649 4650 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4651 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4652 if (rc) { 4653 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc); 4654 } else { /* decode response */ 4655 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4656 4657 if (rc || get_bcc(&pSMBr->hdr) < 13) { 4658 /* BB also check if enough bytes returned */ 4659 rc = -EIO; /* bad smb */ 4660 } else { 4661 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4662 response_data = 4663 (FILE_SYSTEM_ATTRIBUTE_INFO 4664 *) (((char *) &pSMBr->hdr.Protocol) + 4665 data_offset); 4666 memcpy(&tcon->fsAttrInfo, response_data, 4667 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO)); 4668 } 4669 } 4670 cifs_buf_release(pSMB); 4671 4672 if (rc == -EAGAIN) 4673 goto QFSAttributeRetry; 4674 4675 return rc; 4676 } 4677 4678 int 4679 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon) 4680 { 4681 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */ 4682 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4683 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4684 FILE_SYSTEM_DEVICE_INFO *response_data; 4685 int rc = 0; 4686 int bytes_returned = 0; 4687 __u16 params, byte_count; 4688 4689 cifs_dbg(FYI, "In QFSDeviceInfo\n"); 4690 QFSDeviceRetry: 4691 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4692 (void **) &pSMBr); 4693 if (rc) 4694 return rc; 4695 4696 params = 2; /* level */ 4697 pSMB->TotalDataCount = 0; 4698 pSMB->MaxParameterCount = cpu_to_le16(2); 4699 /* BB find exact max SMB PDU from sess structure BB */ 4700 pSMB->MaxDataCount = cpu_to_le16(1000); 4701 pSMB->MaxSetupCount = 0; 4702 pSMB->Reserved = 0; 4703 pSMB->Flags = 0; 4704 pSMB->Timeout = 0; 4705 pSMB->Reserved2 = 0; 4706 byte_count = params + 1 /* pad */ ; 4707 pSMB->TotalParameterCount = cpu_to_le16(params); 4708 pSMB->ParameterCount = pSMB->TotalParameterCount; 4709 pSMB->ParameterOffset = cpu_to_le16(offsetof( 4710 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4711 4712 pSMB->DataCount = 0; 4713 pSMB->DataOffset = 0; 4714 pSMB->SetupCount = 1; 4715 pSMB->Reserved3 = 0; 4716 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4717 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO); 4718 inc_rfc1001_len(pSMB, byte_count); 4719 pSMB->ByteCount = cpu_to_le16(byte_count); 4720 4721 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4722 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4723 if (rc) { 4724 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc); 4725 } else { /* decode response */ 4726 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4727 4728 if (rc || get_bcc(&pSMBr->hdr) < 4729 sizeof(FILE_SYSTEM_DEVICE_INFO)) 4730 rc = -EIO; /* bad smb */ 4731 else { 4732 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4733 response_data = 4734 (FILE_SYSTEM_DEVICE_INFO *) 4735 (((char *) &pSMBr->hdr.Protocol) + 4736 data_offset); 4737 memcpy(&tcon->fsDevInfo, response_data, 4738 sizeof(FILE_SYSTEM_DEVICE_INFO)); 4739 } 4740 } 4741 cifs_buf_release(pSMB); 4742 4743 if (rc == -EAGAIN) 4744 goto QFSDeviceRetry; 4745 4746 return rc; 4747 } 4748 4749 int 4750 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon) 4751 { 4752 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */ 4753 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4754 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4755 FILE_SYSTEM_UNIX_INFO *response_data; 4756 int rc = 0; 4757 int bytes_returned = 0; 4758 __u16 params, byte_count; 4759 4760 cifs_dbg(FYI, "In QFSUnixInfo\n"); 4761 QFSUnixRetry: 4762 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon, 4763 (void **) &pSMB, (void **) &pSMBr); 4764 if (rc) 4765 return rc; 4766 4767 params = 2; /* level */ 4768 pSMB->TotalDataCount = 0; 4769 pSMB->DataCount = 0; 4770 pSMB->DataOffset = 0; 4771 pSMB->MaxParameterCount = cpu_to_le16(2); 4772 /* BB find exact max SMB PDU from sess structure BB */ 4773 pSMB->MaxDataCount = cpu_to_le16(100); 4774 pSMB->MaxSetupCount = 0; 4775 pSMB->Reserved = 0; 4776 pSMB->Flags = 0; 4777 pSMB->Timeout = 0; 4778 pSMB->Reserved2 = 0; 4779 byte_count = params + 1 /* pad */ ; 4780 pSMB->ParameterCount = cpu_to_le16(params); 4781 pSMB->TotalParameterCount = pSMB->ParameterCount; 4782 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 4783 smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4784 pSMB->SetupCount = 1; 4785 pSMB->Reserved3 = 0; 4786 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4787 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO); 4788 inc_rfc1001_len(pSMB, byte_count); 4789 pSMB->ByteCount = cpu_to_le16(byte_count); 4790 4791 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4792 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4793 if (rc) { 4794 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc); 4795 } else { /* decode response */ 4796 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4797 4798 if (rc || get_bcc(&pSMBr->hdr) < 13) { 4799 rc = -EIO; /* bad smb */ 4800 } else { 4801 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4802 response_data = 4803 (FILE_SYSTEM_UNIX_INFO 4804 *) (((char *) &pSMBr->hdr.Protocol) + 4805 data_offset); 4806 memcpy(&tcon->fsUnixInfo, response_data, 4807 sizeof(FILE_SYSTEM_UNIX_INFO)); 4808 } 4809 } 4810 cifs_buf_release(pSMB); 4811 4812 if (rc == -EAGAIN) 4813 goto QFSUnixRetry; 4814 4815 4816 return rc; 4817 } 4818 4819 int 4820 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap) 4821 { 4822 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */ 4823 TRANSACTION2_SETFSI_REQ *pSMB = NULL; 4824 TRANSACTION2_SETFSI_RSP *pSMBr = NULL; 4825 int rc = 0; 4826 int bytes_returned = 0; 4827 __u16 params, param_offset, offset, byte_count; 4828 4829 cifs_dbg(FYI, "In SETFSUnixInfo\n"); 4830 SETFSUnixRetry: 4831 /* BB switch to small buf init to save memory */ 4832 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon, 4833 (void **) &pSMB, (void **) &pSMBr); 4834 if (rc) 4835 return rc; 4836 4837 params = 4; /* 2 bytes zero followed by info level. */ 4838 pSMB->MaxSetupCount = 0; 4839 pSMB->Reserved = 0; 4840 pSMB->Flags = 0; 4841 pSMB->Timeout = 0; 4842 pSMB->Reserved2 = 0; 4843 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum) 4844 - 4; 4845 offset = param_offset + params; 4846 4847 pSMB->MaxParameterCount = cpu_to_le16(4); 4848 /* BB find exact max SMB PDU from sess structure BB */ 4849 pSMB->MaxDataCount = cpu_to_le16(100); 4850 pSMB->SetupCount = 1; 4851 pSMB->Reserved3 = 0; 4852 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION); 4853 byte_count = 1 /* pad */ + params + 12; 4854 4855 pSMB->DataCount = cpu_to_le16(12); 4856 pSMB->ParameterCount = cpu_to_le16(params); 4857 pSMB->TotalDataCount = pSMB->DataCount; 4858 pSMB->TotalParameterCount = pSMB->ParameterCount; 4859 pSMB->ParameterOffset = cpu_to_le16(param_offset); 4860 pSMB->DataOffset = cpu_to_le16(offset); 4861 4862 /* Params. */ 4863 pSMB->FileNum = 0; 4864 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO); 4865 4866 /* Data. */ 4867 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION); 4868 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION); 4869 pSMB->ClientUnixCap = cpu_to_le64(cap); 4870 4871 inc_rfc1001_len(pSMB, byte_count); 4872 pSMB->ByteCount = cpu_to_le16(byte_count); 4873 4874 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4875 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4876 if (rc) { 4877 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc); 4878 } else { /* decode response */ 4879 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4880 if (rc) 4881 rc = -EIO; /* bad smb */ 4882 } 4883 cifs_buf_release(pSMB); 4884 4885 if (rc == -EAGAIN) 4886 goto SETFSUnixRetry; 4887 4888 return rc; 4889 } 4890 4891 4892 4893 int 4894 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon, 4895 struct kstatfs *FSData) 4896 { 4897 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */ 4898 TRANSACTION2_QFSI_REQ *pSMB = NULL; 4899 TRANSACTION2_QFSI_RSP *pSMBr = NULL; 4900 FILE_SYSTEM_POSIX_INFO *response_data; 4901 int rc = 0; 4902 int bytes_returned = 0; 4903 __u16 params, byte_count; 4904 4905 cifs_dbg(FYI, "In QFSPosixInfo\n"); 4906 QFSPosixRetry: 4907 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 4908 (void **) &pSMBr); 4909 if (rc) 4910 return rc; 4911 4912 params = 2; /* level */ 4913 pSMB->TotalDataCount = 0; 4914 pSMB->DataCount = 0; 4915 pSMB->DataOffset = 0; 4916 pSMB->MaxParameterCount = cpu_to_le16(2); 4917 /* BB find exact max SMB PDU from sess structure BB */ 4918 pSMB->MaxDataCount = cpu_to_le16(100); 4919 pSMB->MaxSetupCount = 0; 4920 pSMB->Reserved = 0; 4921 pSMB->Flags = 0; 4922 pSMB->Timeout = 0; 4923 pSMB->Reserved2 = 0; 4924 byte_count = params + 1 /* pad */ ; 4925 pSMB->ParameterCount = cpu_to_le16(params); 4926 pSMB->TotalParameterCount = pSMB->ParameterCount; 4927 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 4928 smb_com_transaction2_qfsi_req, InformationLevel) - 4); 4929 pSMB->SetupCount = 1; 4930 pSMB->Reserved3 = 0; 4931 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION); 4932 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO); 4933 inc_rfc1001_len(pSMB, byte_count); 4934 pSMB->ByteCount = cpu_to_le16(byte_count); 4935 4936 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 4937 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 4938 if (rc) { 4939 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc); 4940 } else { /* decode response */ 4941 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 4942 4943 if (rc || get_bcc(&pSMBr->hdr) < 13) { 4944 rc = -EIO; /* bad smb */ 4945 } else { 4946 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 4947 response_data = 4948 (FILE_SYSTEM_POSIX_INFO 4949 *) (((char *) &pSMBr->hdr.Protocol) + 4950 data_offset); 4951 FSData->f_bsize = 4952 le32_to_cpu(response_data->BlockSize); 4953 /* 4954 * much prefer larger but if server doesn't report 4955 * a valid size than 4K is a reasonable minimum 4956 */ 4957 if (FSData->f_bsize < 512) 4958 FSData->f_bsize = 4096; 4959 4960 FSData->f_blocks = 4961 le64_to_cpu(response_data->TotalBlocks); 4962 FSData->f_bfree = 4963 le64_to_cpu(response_data->BlocksAvail); 4964 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) { 4965 FSData->f_bavail = FSData->f_bfree; 4966 } else { 4967 FSData->f_bavail = 4968 le64_to_cpu(response_data->UserBlocksAvail); 4969 } 4970 if (response_data->TotalFileNodes != cpu_to_le64(-1)) 4971 FSData->f_files = 4972 le64_to_cpu(response_data->TotalFileNodes); 4973 if (response_data->FreeFileNodes != cpu_to_le64(-1)) 4974 FSData->f_ffree = 4975 le64_to_cpu(response_data->FreeFileNodes); 4976 } 4977 } 4978 cifs_buf_release(pSMB); 4979 4980 if (rc == -EAGAIN) 4981 goto QFSPosixRetry; 4982 4983 return rc; 4984 } 4985 4986 4987 /* 4988 * We can not use write of zero bytes trick to set file size due to need for 4989 * large file support. Also note that this SetPathInfo is preferred to 4990 * SetFileInfo based method in next routine which is only needed to work around 4991 * a sharing violation bugin Samba which this routine can run into. 4992 */ 4993 int 4994 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon, 4995 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb, 4996 bool set_allocation, struct dentry *dentry) 4997 { 4998 struct smb_com_transaction2_spi_req *pSMB = NULL; 4999 struct smb_com_transaction2_spi_rsp *pSMBr = NULL; 5000 struct file_end_of_file_info *parm_data; 5001 int name_len; 5002 int rc = 0; 5003 int bytes_returned = 0; 5004 int remap = cifs_remap(cifs_sb); 5005 5006 __u16 params, byte_count, data_count, param_offset, offset; 5007 5008 cifs_dbg(FYI, "In SetEOF\n"); 5009 SetEOFRetry: 5010 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5011 (void **) &pSMBr); 5012 if (rc) 5013 return rc; 5014 5015 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5016 name_len = 5017 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name, 5018 PATH_MAX, cifs_sb->local_nls, remap); 5019 name_len++; /* trailing null */ 5020 name_len *= 2; 5021 } else { 5022 name_len = copy_path_name(pSMB->FileName, file_name); 5023 } 5024 params = 6 + name_len; 5025 data_count = sizeof(struct file_end_of_file_info); 5026 pSMB->MaxParameterCount = cpu_to_le16(2); 5027 pSMB->MaxDataCount = cpu_to_le16(4100); 5028 pSMB->MaxSetupCount = 0; 5029 pSMB->Reserved = 0; 5030 pSMB->Flags = 0; 5031 pSMB->Timeout = 0; 5032 pSMB->Reserved2 = 0; 5033 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5034 InformationLevel) - 4; 5035 offset = param_offset + params; 5036 if (set_allocation) { 5037 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5038 pSMB->InformationLevel = 5039 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2); 5040 else 5041 pSMB->InformationLevel = 5042 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO); 5043 } else /* Set File Size */ { 5044 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5045 pSMB->InformationLevel = 5046 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2); 5047 else 5048 pSMB->InformationLevel = 5049 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO); 5050 } 5051 5052 parm_data = 5053 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) + 5054 offset); 5055 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5056 pSMB->DataOffset = cpu_to_le16(offset); 5057 pSMB->SetupCount = 1; 5058 pSMB->Reserved3 = 0; 5059 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5060 byte_count = 3 /* pad */ + params + data_count; 5061 pSMB->DataCount = cpu_to_le16(data_count); 5062 pSMB->TotalDataCount = pSMB->DataCount; 5063 pSMB->ParameterCount = cpu_to_le16(params); 5064 pSMB->TotalParameterCount = pSMB->ParameterCount; 5065 pSMB->Reserved4 = 0; 5066 inc_rfc1001_len(pSMB, byte_count); 5067 parm_data->FileSize = cpu_to_le64(size); 5068 pSMB->ByteCount = cpu_to_le16(byte_count); 5069 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5070 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5071 if (rc) 5072 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc); 5073 5074 cifs_buf_release(pSMB); 5075 5076 if (rc == -EAGAIN) 5077 goto SetEOFRetry; 5078 5079 return rc; 5080 } 5081 5082 int 5083 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon, 5084 struct cifsFileInfo *cfile, __u64 size, bool set_allocation) 5085 { 5086 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5087 struct file_end_of_file_info *parm_data; 5088 int rc = 0; 5089 __u16 params, param_offset, offset, byte_count, count; 5090 5091 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n", 5092 (long long)size); 5093 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5094 5095 if (rc) 5096 return rc; 5097 5098 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid); 5099 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16)); 5100 5101 params = 6; 5102 pSMB->MaxSetupCount = 0; 5103 pSMB->Reserved = 0; 5104 pSMB->Flags = 0; 5105 pSMB->Timeout = 0; 5106 pSMB->Reserved2 = 0; 5107 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5108 offset = param_offset + params; 5109 5110 count = sizeof(struct file_end_of_file_info); 5111 pSMB->MaxParameterCount = cpu_to_le16(2); 5112 /* BB find exact max SMB PDU from sess structure BB */ 5113 pSMB->MaxDataCount = cpu_to_le16(1000); 5114 pSMB->SetupCount = 1; 5115 pSMB->Reserved3 = 0; 5116 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5117 byte_count = 3 /* pad */ + params + count; 5118 pSMB->DataCount = cpu_to_le16(count); 5119 pSMB->ParameterCount = cpu_to_le16(params); 5120 pSMB->TotalDataCount = pSMB->DataCount; 5121 pSMB->TotalParameterCount = pSMB->ParameterCount; 5122 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5123 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 5124 parm_data = 5125 (struct file_end_of_file_info *)(((char *)pSMB) + offset + 4); 5126 pSMB->DataOffset = cpu_to_le16(offset); 5127 parm_data->FileSize = cpu_to_le64(size); 5128 pSMB->Fid = cfile->fid.netfid; 5129 if (set_allocation) { 5130 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5131 pSMB->InformationLevel = 5132 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2); 5133 else 5134 pSMB->InformationLevel = 5135 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO); 5136 } else /* Set File Size */ { 5137 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5138 pSMB->InformationLevel = 5139 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2); 5140 else 5141 pSMB->InformationLevel = 5142 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO); 5143 } 5144 pSMB->Reserved4 = 0; 5145 inc_rfc1001_len(pSMB, byte_count); 5146 pSMB->ByteCount = cpu_to_le16(byte_count); 5147 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5148 cifs_small_buf_release(pSMB); 5149 if (rc) { 5150 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n", 5151 rc); 5152 } 5153 5154 /* Note: On -EAGAIN error only caller can retry on handle based calls 5155 since file handle passed in no longer valid */ 5156 5157 return rc; 5158 } 5159 5160 /* Some legacy servers such as NT4 require that the file times be set on 5161 an open handle, rather than by pathname - this is awkward due to 5162 potential access conflicts on the open, but it is unavoidable for these 5163 old servers since the only other choice is to go from 100 nanosecond DCE 5164 time and resort to the original setpathinfo level which takes the ancient 5165 DOS time format with 2 second granularity */ 5166 int 5167 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 5168 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener) 5169 { 5170 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5171 char *data_offset; 5172 int rc = 0; 5173 __u16 params, param_offset, offset, byte_count, count; 5174 5175 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n"); 5176 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5177 5178 if (rc) 5179 return rc; 5180 5181 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener); 5182 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16)); 5183 5184 params = 6; 5185 pSMB->MaxSetupCount = 0; 5186 pSMB->Reserved = 0; 5187 pSMB->Flags = 0; 5188 pSMB->Timeout = 0; 5189 pSMB->Reserved2 = 0; 5190 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5191 offset = param_offset + params; 5192 5193 data_offset = (char *)pSMB + 5194 offsetof(struct smb_hdr, Protocol) + offset; 5195 5196 count = sizeof(FILE_BASIC_INFO); 5197 pSMB->MaxParameterCount = cpu_to_le16(2); 5198 /* BB find max SMB PDU from sess */ 5199 pSMB->MaxDataCount = cpu_to_le16(1000); 5200 pSMB->SetupCount = 1; 5201 pSMB->Reserved3 = 0; 5202 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5203 byte_count = 3 /* pad */ + params + count; 5204 pSMB->DataCount = cpu_to_le16(count); 5205 pSMB->ParameterCount = cpu_to_le16(params); 5206 pSMB->TotalDataCount = pSMB->DataCount; 5207 pSMB->TotalParameterCount = pSMB->ParameterCount; 5208 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5209 pSMB->DataOffset = cpu_to_le16(offset); 5210 pSMB->Fid = fid; 5211 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5212 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2); 5213 else 5214 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO); 5215 pSMB->Reserved4 = 0; 5216 inc_rfc1001_len(pSMB, byte_count); 5217 pSMB->ByteCount = cpu_to_le16(byte_count); 5218 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO)); 5219 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5220 cifs_small_buf_release(pSMB); 5221 if (rc) 5222 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n", 5223 rc); 5224 5225 /* Note: On -EAGAIN error only caller can retry on handle based calls 5226 since file handle passed in no longer valid */ 5227 5228 return rc; 5229 } 5230 5231 int 5232 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon, 5233 bool delete_file, __u16 fid, __u32 pid_of_opener) 5234 { 5235 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5236 char *data_offset; 5237 int rc = 0; 5238 __u16 params, param_offset, offset, byte_count, count; 5239 5240 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n"); 5241 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5242 5243 if (rc) 5244 return rc; 5245 5246 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener); 5247 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16)); 5248 5249 params = 6; 5250 pSMB->MaxSetupCount = 0; 5251 pSMB->Reserved = 0; 5252 pSMB->Flags = 0; 5253 pSMB->Timeout = 0; 5254 pSMB->Reserved2 = 0; 5255 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5256 offset = param_offset + params; 5257 5258 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 5259 data_offset = (char *)(pSMB) + offset + 4; 5260 5261 count = 1; 5262 pSMB->MaxParameterCount = cpu_to_le16(2); 5263 /* BB find max SMB PDU from sess */ 5264 pSMB->MaxDataCount = cpu_to_le16(1000); 5265 pSMB->SetupCount = 1; 5266 pSMB->Reserved3 = 0; 5267 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5268 byte_count = 3 /* pad */ + params + count; 5269 pSMB->DataCount = cpu_to_le16(count); 5270 pSMB->ParameterCount = cpu_to_le16(params); 5271 pSMB->TotalDataCount = pSMB->DataCount; 5272 pSMB->TotalParameterCount = pSMB->ParameterCount; 5273 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5274 pSMB->DataOffset = cpu_to_le16(offset); 5275 pSMB->Fid = fid; 5276 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO); 5277 pSMB->Reserved4 = 0; 5278 inc_rfc1001_len(pSMB, byte_count); 5279 pSMB->ByteCount = cpu_to_le16(byte_count); 5280 *data_offset = delete_file ? 1 : 0; 5281 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5282 cifs_small_buf_release(pSMB); 5283 if (rc) 5284 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc); 5285 5286 return rc; 5287 } 5288 5289 static int 5290 CIFSSMBSetPathInfoFB(const unsigned int xid, struct cifs_tcon *tcon, 5291 const char *fileName, const FILE_BASIC_INFO *data, 5292 const struct nls_table *nls_codepage, 5293 struct cifs_sb_info *cifs_sb) 5294 { 5295 int oplock = 0; 5296 struct cifs_open_parms oparms; 5297 struct cifs_fid fid; 5298 int rc; 5299 5300 oparms = (struct cifs_open_parms) { 5301 .tcon = tcon, 5302 .cifs_sb = cifs_sb, 5303 .desired_access = GENERIC_WRITE, 5304 .create_options = cifs_create_options(cifs_sb, 0), 5305 .disposition = FILE_OPEN, 5306 .path = fileName, 5307 .fid = &fid, 5308 }; 5309 5310 rc = CIFS_open(xid, &oparms, &oplock, NULL); 5311 if (rc) 5312 goto out; 5313 5314 rc = CIFSSMBSetFileInfo(xid, tcon, data, fid.netfid, current->tgid); 5315 CIFSSMBClose(xid, tcon, fid.netfid); 5316 out: 5317 5318 return rc; 5319 } 5320 5321 int 5322 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 5323 const char *fileName, const FILE_BASIC_INFO *data, 5324 const struct nls_table *nls_codepage, 5325 struct cifs_sb_info *cifs_sb) 5326 { 5327 TRANSACTION2_SPI_REQ *pSMB = NULL; 5328 TRANSACTION2_SPI_RSP *pSMBr = NULL; 5329 int name_len; 5330 int rc = 0; 5331 int bytes_returned = 0; 5332 char *data_offset; 5333 __u16 params, param_offset, offset, byte_count, count; 5334 int remap = cifs_remap(cifs_sb); 5335 5336 cifs_dbg(FYI, "In SetTimes\n"); 5337 5338 SetTimesRetry: 5339 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5340 (void **) &pSMBr); 5341 if (rc) 5342 return rc; 5343 5344 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5345 name_len = 5346 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 5347 PATH_MAX, nls_codepage, remap); 5348 name_len++; /* trailing null */ 5349 name_len *= 2; 5350 } else { 5351 name_len = copy_path_name(pSMB->FileName, fileName); 5352 } 5353 5354 params = 6 + name_len; 5355 count = sizeof(FILE_BASIC_INFO); 5356 pSMB->MaxParameterCount = cpu_to_le16(2); 5357 /* BB find max SMB PDU from sess structure BB */ 5358 pSMB->MaxDataCount = cpu_to_le16(1000); 5359 pSMB->MaxSetupCount = 0; 5360 pSMB->Reserved = 0; 5361 pSMB->Flags = 0; 5362 pSMB->Timeout = 0; 5363 pSMB->Reserved2 = 0; 5364 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5365 InformationLevel) - 4; 5366 offset = param_offset + params; 5367 data_offset = (char *) (&pSMB->hdr.Protocol) + offset; 5368 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5369 pSMB->DataOffset = cpu_to_le16(offset); 5370 pSMB->SetupCount = 1; 5371 pSMB->Reserved3 = 0; 5372 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5373 byte_count = 3 /* pad */ + params + count; 5374 5375 pSMB->DataCount = cpu_to_le16(count); 5376 pSMB->ParameterCount = cpu_to_le16(params); 5377 pSMB->TotalDataCount = pSMB->DataCount; 5378 pSMB->TotalParameterCount = pSMB->ParameterCount; 5379 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU) 5380 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2); 5381 else 5382 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO); 5383 pSMB->Reserved4 = 0; 5384 inc_rfc1001_len(pSMB, byte_count); 5385 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO)); 5386 pSMB->ByteCount = cpu_to_le16(byte_count); 5387 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5388 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5389 if (rc) 5390 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc); 5391 5392 cifs_buf_release(pSMB); 5393 5394 if (rc == -EAGAIN) 5395 goto SetTimesRetry; 5396 5397 if (rc == -EOPNOTSUPP) 5398 return CIFSSMBSetPathInfoFB(xid, tcon, fileName, data, 5399 nls_codepage, cifs_sb); 5400 5401 return rc; 5402 } 5403 5404 static void 5405 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset, 5406 const struct cifs_unix_set_info_args *args) 5407 { 5408 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64; 5409 u64 mode = args->mode; 5410 5411 if (uid_valid(args->uid)) 5412 uid = from_kuid(&init_user_ns, args->uid); 5413 if (gid_valid(args->gid)) 5414 gid = from_kgid(&init_user_ns, args->gid); 5415 5416 /* 5417 * Samba server ignores set of file size to zero due to bugs in some 5418 * older clients, but we should be precise - we use SetFileSize to 5419 * set file size and do not want to truncate file size to zero 5420 * accidentally as happened on one Samba server beta by putting 5421 * zero instead of -1 here 5422 */ 5423 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64); 5424 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64); 5425 data_offset->LastStatusChange = cpu_to_le64(args->ctime); 5426 data_offset->LastAccessTime = cpu_to_le64(args->atime); 5427 data_offset->LastModificationTime = cpu_to_le64(args->mtime); 5428 data_offset->Uid = cpu_to_le64(uid); 5429 data_offset->Gid = cpu_to_le64(gid); 5430 /* better to leave device as zero when it is */ 5431 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device)); 5432 data_offset->DevMinor = cpu_to_le64(MINOR(args->device)); 5433 data_offset->Permissions = cpu_to_le64(mode); 5434 5435 if (S_ISREG(mode)) 5436 data_offset->Type = cpu_to_le32(UNIX_FILE); 5437 else if (S_ISDIR(mode)) 5438 data_offset->Type = cpu_to_le32(UNIX_DIR); 5439 else if (S_ISLNK(mode)) 5440 data_offset->Type = cpu_to_le32(UNIX_SYMLINK); 5441 else if (S_ISCHR(mode)) 5442 data_offset->Type = cpu_to_le32(UNIX_CHARDEV); 5443 else if (S_ISBLK(mode)) 5444 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV); 5445 else if (S_ISFIFO(mode)) 5446 data_offset->Type = cpu_to_le32(UNIX_FIFO); 5447 else if (S_ISSOCK(mode)) 5448 data_offset->Type = cpu_to_le32(UNIX_SOCKET); 5449 } 5450 5451 int 5452 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon, 5453 const struct cifs_unix_set_info_args *args, 5454 u16 fid, u32 pid_of_opener) 5455 { 5456 struct smb_com_transaction2_sfi_req *pSMB = NULL; 5457 char *data_offset; 5458 int rc = 0; 5459 u16 params, param_offset, offset, byte_count, count; 5460 5461 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n"); 5462 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB); 5463 5464 if (rc) 5465 return rc; 5466 5467 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener); 5468 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16)); 5469 5470 params = 6; 5471 pSMB->MaxSetupCount = 0; 5472 pSMB->Reserved = 0; 5473 pSMB->Flags = 0; 5474 pSMB->Timeout = 0; 5475 pSMB->Reserved2 = 0; 5476 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4; 5477 offset = param_offset + params; 5478 5479 data_offset = (char *)pSMB + 5480 offsetof(struct smb_hdr, Protocol) + offset; 5481 5482 count = sizeof(FILE_UNIX_BASIC_INFO); 5483 5484 pSMB->MaxParameterCount = cpu_to_le16(2); 5485 /* BB find max SMB PDU from sess */ 5486 pSMB->MaxDataCount = cpu_to_le16(1000); 5487 pSMB->SetupCount = 1; 5488 pSMB->Reserved3 = 0; 5489 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION); 5490 byte_count = 3 /* pad */ + params + count; 5491 pSMB->DataCount = cpu_to_le16(count); 5492 pSMB->ParameterCount = cpu_to_le16(params); 5493 pSMB->TotalDataCount = pSMB->DataCount; 5494 pSMB->TotalParameterCount = pSMB->ParameterCount; 5495 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5496 pSMB->DataOffset = cpu_to_le16(offset); 5497 pSMB->Fid = fid; 5498 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC); 5499 pSMB->Reserved4 = 0; 5500 inc_rfc1001_len(pSMB, byte_count); 5501 pSMB->ByteCount = cpu_to_le16(byte_count); 5502 5503 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args); 5504 5505 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0); 5506 cifs_small_buf_release(pSMB); 5507 if (rc) 5508 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n", 5509 rc); 5510 5511 /* Note: On -EAGAIN error only caller can retry on handle based calls 5512 since file handle passed in no longer valid */ 5513 5514 return rc; 5515 } 5516 5517 int 5518 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon, 5519 const char *file_name, 5520 const struct cifs_unix_set_info_args *args, 5521 const struct nls_table *nls_codepage, int remap) 5522 { 5523 TRANSACTION2_SPI_REQ *pSMB = NULL; 5524 TRANSACTION2_SPI_RSP *pSMBr = NULL; 5525 int name_len; 5526 int rc = 0; 5527 int bytes_returned = 0; 5528 FILE_UNIX_BASIC_INFO *data_offset; 5529 __u16 params, param_offset, offset, count, byte_count; 5530 5531 cifs_dbg(FYI, "In SetUID/GID/Mode\n"); 5532 setPermsRetry: 5533 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5534 (void **) &pSMBr); 5535 if (rc) 5536 return rc; 5537 5538 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5539 name_len = 5540 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name, 5541 PATH_MAX, nls_codepage, remap); 5542 name_len++; /* trailing null */ 5543 name_len *= 2; 5544 } else { 5545 name_len = copy_path_name(pSMB->FileName, file_name); 5546 } 5547 5548 params = 6 + name_len; 5549 count = sizeof(FILE_UNIX_BASIC_INFO); 5550 pSMB->MaxParameterCount = cpu_to_le16(2); 5551 /* BB find max SMB PDU from sess structure BB */ 5552 pSMB->MaxDataCount = cpu_to_le16(1000); 5553 pSMB->MaxSetupCount = 0; 5554 pSMB->Reserved = 0; 5555 pSMB->Flags = 0; 5556 pSMB->Timeout = 0; 5557 pSMB->Reserved2 = 0; 5558 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5559 InformationLevel) - 4; 5560 offset = param_offset + params; 5561 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */ 5562 data_offset = (FILE_UNIX_BASIC_INFO *)((char *) pSMB + offset + 4); 5563 memset(data_offset, 0, count); 5564 pSMB->DataOffset = cpu_to_le16(offset); 5565 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5566 pSMB->SetupCount = 1; 5567 pSMB->Reserved3 = 0; 5568 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5569 byte_count = 3 /* pad */ + params + count; 5570 pSMB->ParameterCount = cpu_to_le16(params); 5571 pSMB->DataCount = cpu_to_le16(count); 5572 pSMB->TotalParameterCount = pSMB->ParameterCount; 5573 pSMB->TotalDataCount = pSMB->DataCount; 5574 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC); 5575 pSMB->Reserved4 = 0; 5576 inc_rfc1001_len(pSMB, byte_count); 5577 5578 cifs_fill_unix_set_info(data_offset, args); 5579 5580 pSMB->ByteCount = cpu_to_le16(byte_count); 5581 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5582 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5583 if (rc) 5584 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc); 5585 5586 cifs_buf_release(pSMB); 5587 if (rc == -EAGAIN) 5588 goto setPermsRetry; 5589 return rc; 5590 } 5591 5592 #ifdef CONFIG_CIFS_XATTR 5593 /* 5594 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common 5595 * function used by listxattr and getxattr type calls. When ea_name is set, 5596 * it looks for that attribute name and stuffs that value into the EAData 5597 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the 5598 * buffer. In both cases, the return value is either the length of the 5599 * resulting data or a negative error code. If EAData is a NULL pointer then 5600 * the data isn't copied to it, but the length is returned. 5601 */ 5602 ssize_t 5603 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon, 5604 const unsigned char *searchName, const unsigned char *ea_name, 5605 char *EAData, size_t buf_size, 5606 struct cifs_sb_info *cifs_sb) 5607 { 5608 /* BB assumes one setup word */ 5609 TRANSACTION2_QPI_REQ *pSMB = NULL; 5610 TRANSACTION2_QPI_RSP *pSMBr = NULL; 5611 int remap = cifs_remap(cifs_sb); 5612 struct nls_table *nls_codepage = cifs_sb->local_nls; 5613 int rc = 0; 5614 int bytes_returned; 5615 int list_len; 5616 struct fealist *ea_response_data; 5617 struct fea *temp_fea; 5618 char *temp_ptr; 5619 char *end_of_smb; 5620 __u16 params, byte_count, data_offset; 5621 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0; 5622 5623 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName); 5624 QAllEAsRetry: 5625 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5626 (void **) &pSMBr); 5627 if (rc) 5628 return rc; 5629 5630 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5631 list_len = 5632 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName, 5633 PATH_MAX, nls_codepage, remap); 5634 list_len++; /* trailing null */ 5635 list_len *= 2; 5636 } else { 5637 list_len = copy_path_name(pSMB->FileName, searchName); 5638 } 5639 5640 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */; 5641 pSMB->TotalDataCount = 0; 5642 pSMB->MaxParameterCount = cpu_to_le16(2); 5643 /* BB find exact max SMB PDU from sess structure BB */ 5644 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize); 5645 pSMB->MaxSetupCount = 0; 5646 pSMB->Reserved = 0; 5647 pSMB->Flags = 0; 5648 pSMB->Timeout = 0; 5649 pSMB->Reserved2 = 0; 5650 pSMB->ParameterOffset = cpu_to_le16(offsetof( 5651 struct smb_com_transaction2_qpi_req, InformationLevel) - 4); 5652 pSMB->DataCount = 0; 5653 pSMB->DataOffset = 0; 5654 pSMB->SetupCount = 1; 5655 pSMB->Reserved3 = 0; 5656 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION); 5657 byte_count = params + 1 /* pad */ ; 5658 pSMB->TotalParameterCount = cpu_to_le16(params); 5659 pSMB->ParameterCount = pSMB->TotalParameterCount; 5660 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS); 5661 pSMB->Reserved4 = 0; 5662 inc_rfc1001_len(pSMB, byte_count); 5663 pSMB->ByteCount = cpu_to_le16(byte_count); 5664 5665 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5666 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5667 if (rc) { 5668 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc); 5669 goto QAllEAsOut; 5670 } 5671 5672 5673 /* BB also check enough total bytes returned */ 5674 /* BB we need to improve the validity checking 5675 of these trans2 responses */ 5676 5677 rc = validate_t2((struct smb_t2_rsp *)pSMBr); 5678 if (rc || get_bcc(&pSMBr->hdr) < 4) { 5679 rc = -EIO; /* bad smb */ 5680 goto QAllEAsOut; 5681 } 5682 5683 /* check that length of list is not more than bcc */ 5684 /* check that each entry does not go beyond length 5685 of list */ 5686 /* check that each element of each entry does not 5687 go beyond end of list */ 5688 /* validate_trans2_offsets() */ 5689 /* BB check if start of smb + data_offset > &bcc+ bcc */ 5690 5691 data_offset = le16_to_cpu(pSMBr->t2.DataOffset); 5692 ea_response_data = (struct fealist *) 5693 (((char *) &pSMBr->hdr.Protocol) + data_offset); 5694 5695 list_len = le32_to_cpu(ea_response_data->list_len); 5696 cifs_dbg(FYI, "ea length %d\n", list_len); 5697 if (list_len <= 8) { 5698 cifs_dbg(FYI, "empty EA list returned from server\n"); 5699 /* didn't find the named attribute */ 5700 if (ea_name) 5701 rc = -ENODATA; 5702 goto QAllEAsOut; 5703 } 5704 5705 /* make sure list_len doesn't go past end of SMB */ 5706 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr); 5707 if ((char *)ea_response_data + list_len > end_of_smb) { 5708 cifs_dbg(FYI, "EA list appears to go beyond SMB\n"); 5709 rc = -EIO; 5710 goto QAllEAsOut; 5711 } 5712 5713 /* account for ea list len */ 5714 list_len -= 4; 5715 temp_fea = &ea_response_data->list; 5716 temp_ptr = (char *)temp_fea; 5717 while (list_len > 0) { 5718 unsigned int name_len; 5719 __u16 value_len; 5720 5721 list_len -= 4; 5722 temp_ptr += 4; 5723 /* make sure we can read name_len and value_len */ 5724 if (list_len < 0) { 5725 cifs_dbg(FYI, "EA entry goes beyond length of list\n"); 5726 rc = -EIO; 5727 goto QAllEAsOut; 5728 } 5729 5730 name_len = temp_fea->name_len; 5731 value_len = le16_to_cpu(temp_fea->value_len); 5732 list_len -= name_len + 1 + value_len; 5733 if (list_len < 0) { 5734 cifs_dbg(FYI, "EA entry goes beyond length of list\n"); 5735 rc = -EIO; 5736 goto QAllEAsOut; 5737 } 5738 5739 if (ea_name) { 5740 if (ea_name_len == name_len && 5741 memcmp(ea_name, temp_ptr, name_len) == 0) { 5742 temp_ptr += name_len + 1; 5743 rc = value_len; 5744 if (buf_size == 0) 5745 goto QAllEAsOut; 5746 if ((size_t)value_len > buf_size) { 5747 rc = -ERANGE; 5748 goto QAllEAsOut; 5749 } 5750 memcpy(EAData, temp_ptr, value_len); 5751 goto QAllEAsOut; 5752 } 5753 } else { 5754 /* account for prefix user. and trailing null */ 5755 rc += (5 + 1 + name_len); 5756 if (rc < (int) buf_size) { 5757 memcpy(EAData, "user.", 5); 5758 EAData += 5; 5759 memcpy(EAData, temp_ptr, name_len); 5760 EAData += name_len; 5761 /* null terminate name */ 5762 *EAData = 0; 5763 ++EAData; 5764 } else if (buf_size == 0) { 5765 /* skip copy - calc size only */ 5766 } else { 5767 /* stop before overrun buffer */ 5768 rc = -ERANGE; 5769 break; 5770 } 5771 } 5772 temp_ptr += name_len + 1 + value_len; 5773 temp_fea = (struct fea *)temp_ptr; 5774 } 5775 5776 /* didn't find the named attribute */ 5777 if (ea_name) 5778 rc = -ENODATA; 5779 5780 QAllEAsOut: 5781 cifs_buf_release(pSMB); 5782 if (rc == -EAGAIN) 5783 goto QAllEAsRetry; 5784 5785 return (ssize_t)rc; 5786 } 5787 5788 int 5789 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon, 5790 const char *fileName, const char *ea_name, const void *ea_value, 5791 const __u16 ea_value_len, const struct nls_table *nls_codepage, 5792 struct cifs_sb_info *cifs_sb) 5793 { 5794 struct smb_com_transaction2_spi_req *pSMB = NULL; 5795 struct smb_com_transaction2_spi_rsp *pSMBr = NULL; 5796 struct fealist *parm_data; 5797 int name_len; 5798 int rc = 0; 5799 int bytes_returned = 0; 5800 __u16 params, param_offset, byte_count, offset, count; 5801 int remap = cifs_remap(cifs_sb); 5802 5803 cifs_dbg(FYI, "In SetEA\n"); 5804 SetEARetry: 5805 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, 5806 (void **) &pSMBr); 5807 if (rc) 5808 return rc; 5809 5810 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) { 5811 name_len = 5812 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName, 5813 PATH_MAX, nls_codepage, remap); 5814 name_len++; /* trailing null */ 5815 name_len *= 2; 5816 } else { 5817 name_len = copy_path_name(pSMB->FileName, fileName); 5818 } 5819 5820 params = 6 + name_len; 5821 5822 /* done calculating parms using name_len of file name, 5823 now use name_len to calculate length of ea name 5824 we are going to create in the inode xattrs */ 5825 if (ea_name == NULL) 5826 name_len = 0; 5827 else 5828 name_len = strnlen(ea_name, 255); 5829 5830 count = sizeof(*parm_data) + 1 + ea_value_len + name_len; 5831 pSMB->MaxParameterCount = cpu_to_le16(2); 5832 /* BB find max SMB PDU from sess */ 5833 pSMB->MaxDataCount = cpu_to_le16(1000); 5834 pSMB->MaxSetupCount = 0; 5835 pSMB->Reserved = 0; 5836 pSMB->Flags = 0; 5837 pSMB->Timeout = 0; 5838 pSMB->Reserved2 = 0; 5839 param_offset = offsetof(struct smb_com_transaction2_spi_req, 5840 InformationLevel) - 4; 5841 offset = param_offset + params; 5842 pSMB->InformationLevel = 5843 cpu_to_le16(SMB_SET_FILE_EA); 5844 5845 parm_data = (void *)pSMB + offsetof(struct smb_hdr, Protocol) + offset; 5846 pSMB->ParameterOffset = cpu_to_le16(param_offset); 5847 pSMB->DataOffset = cpu_to_le16(offset); 5848 pSMB->SetupCount = 1; 5849 pSMB->Reserved3 = 0; 5850 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION); 5851 byte_count = 3 /* pad */ + params + count; 5852 pSMB->DataCount = cpu_to_le16(count); 5853 parm_data->list_len = cpu_to_le32(count); 5854 parm_data->list.EA_flags = 0; 5855 /* we checked above that name len is less than 255 */ 5856 parm_data->list.name_len = (__u8)name_len; 5857 /* EA names are always ASCII and NUL-terminated */ 5858 strscpy(parm_data->list.name, ea_name ?: "", name_len + 1); 5859 parm_data->list.value_len = cpu_to_le16(ea_value_len); 5860 /* caller ensures that ea_value_len is less than 64K but 5861 we need to ensure that it fits within the smb */ 5862 5863 /*BB add length check to see if it would fit in 5864 negotiated SMB buffer size BB */ 5865 /* if (ea_value_len > buffer_size - 512 (enough for header)) */ 5866 if (ea_value_len) 5867 memcpy(parm_data->list.name + name_len + 1, 5868 ea_value, ea_value_len); 5869 5870 pSMB->TotalDataCount = pSMB->DataCount; 5871 pSMB->ParameterCount = cpu_to_le16(params); 5872 pSMB->TotalParameterCount = pSMB->ParameterCount; 5873 pSMB->Reserved4 = 0; 5874 inc_rfc1001_len(pSMB, byte_count); 5875 pSMB->ByteCount = cpu_to_le16(byte_count); 5876 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 5877 (struct smb_hdr *) pSMBr, &bytes_returned, 0); 5878 if (rc) 5879 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc); 5880 5881 cifs_buf_release(pSMB); 5882 5883 if (rc == -EAGAIN) 5884 goto SetEARetry; 5885 5886 return rc; 5887 } 5888 #endif 5889