Lines Matching defs:server
94 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
102 struct TCP_Server_Info *server)
107 if (server) {
108 spin_lock(&server->req_lock);
110 if (server->credits >= server->max_credits)
114 min_t(int, server->max_credits -
115 server->credits, 10));
116 spin_unlock(&server->req_lock);
127 if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
138 * to pass the path on the Open SMB prefixed by \\server\share.
141 * illegal to send an empty path name (without \\server\share prefix)
149 if (server && server->sign && !smb3_encryption_required(tcon))
157 struct TCP_Server_Info *server)
190 (!tcon->ses->server) || !server)
194 retries = server->nr_targets;
201 while (server->tcpStatus == CifsNeedReconnect) {
217 rc = wait_event_interruptible_timeout(server->response_q,
218 (server->tcpStatus != CifsNeedReconnect),
227 if (server->tcpStatus != CifsNeedReconnect)
235 * retrying until process is killed or server comes
242 retries = server->nr_targets;
258 * and the server never sends an answer the socket will be closed
261 if (server->tcpStatus == CifsNeedReconnect) {
270 if (server->is_channel) {
272 ses->binding_chan = cifs_ses_find_chan(ses, server);
315 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
324 * BB Is flush done by server on drop of tcp session? Should we special
346 struct TCP_Server_Info *server,
360 smb2_hdr_assemble(&spdu->sync_hdr, smb2_command, tcon, server);
372 struct TCP_Server_Info *server,
390 fill_small_buf(smb2_command, tcon, server,
404 struct TCP_Server_Info *server,
409 rc = smb2_reconnect(smb2_command, tcon, server);
413 return __smb2_plain_req_init(smb2_command, tcon, server, request_buf,
418 struct TCP_Server_Info *server,
423 return __smb2_plain_req_init(SMB2_IOCTL, tcon, server,
426 return smb2_plain_req_init(SMB2_IOCTL, tcon, server,
485 /* copy up to max of first 100 bytes of server name to NetName field */
518 struct TCP_Server_Info *server, unsigned int *total_len)
548 if (server->compress_algorithm) {
561 server->hostname);
575 pr_warn_once("server sent bad preauth context\n");
578 pr_warn_once("server sent invalid SaltLength\n");
587 static void decode_compress_ctx(struct TCP_Server_Info *server,
594 pr_warn_once("server sent bad compression cntxt\n");
605 server->compress_algorithm = ctxt->CompressionAlgorithms[0];
608 static int decode_encrypt_ctx(struct TCP_Server_Info *server,
615 pr_warn_once("server sent bad crypto ctxt len\n");
631 * e.g. if server only supported AES256_CCM (very unlikely)
632 * or server supported no encryption types or had all disabled.
636 * seal not requested by client, since server is allowed to
639 server->cipher_type = 0;
640 server->capabilities &= ~SMB2_GLOBAL_CAP_ENCRYPTION;
646 /* server returned a cipher we didn't ask for */
650 server->cipher_type = ctxt->Ciphers[0];
651 server->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION;
656 struct TCP_Server_Info *server,
691 rc = decode_encrypt_ctx(server,
694 decode_compress_ctx(server,
697 server->posix_ext_supported = true;
798 struct TCP_Server_Info *server = cifs_ses_server(ses);
806 if (!server) {
807 WARN(1, "%s: server is NULL!\n", __func__);
811 rc = smb2_plain_req_init(SMB2_NEGOTIATE, NULL, server,
818 memset(server->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE);
821 if (strcmp(server->vals->version_string,
827 } else if (strcmp(server->vals->version_string,
837 req->Dialects[0] = cpu_to_le16(server->vals->protocol_id);
850 req->Capabilities = cpu_to_le32(server->vals->req_capabilities);
855 if (server->vals->protocol_id == SMB20_PROT_ID)
858 memcpy(req->ClientGUID, server->client_guid,
860 if ((server->vals->protocol_id == SMB311_PROT_ID) ||
861 (strcmp(server->vals->version_string,
863 assemble_neg_contexts(req, server, &total_len);
872 rc = cifs_send_recv(xid, ses, server,
881 cifs_server_dbg(VFS, "Dialect not supported by server. Consider specifying vers=1.0 or vers=2.0 on mount for accessing older servers\n");
886 if (strcmp(server->vals->version_string,
897 } else if (strcmp(server->vals->version_string,
905 server->ops = &smb21_operations;
906 server->vals = &smb21_values;
908 server->ops = &smb311_operations;
909 server->vals = &smb311_values;
912 server->vals->protocol_id) {
932 cifs_server_dbg(VFS, "Invalid dialect returned by server 0x%x\n",
937 server->dialect = le16_to_cpu(rsp->DialectRevision);
942 * server.
944 memcpy(server->preauth_sha_hash, ses->preauth_sha_hash,
948 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
950 server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),
952 server->max_read = le32_to_cpu(rsp->MaxReadSize);
953 server->max_write = le32_to_cpu(rsp->MaxWriteSize);
954 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
955 if ((server->sec_mode & SMB2_SEC_MODE_FLAGS_ALL) != server->sec_mode)
957 server->sec_mode);
958 server->capabilities = le32_to_cpu(rsp->Capabilities);
960 server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES;
966 if (server->dialect == SMB30_PROT_ID && (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
967 server->cipher_type = SMB2_ENCRYPTION_AES128_CCM;
976 * We just found a server which sets blob length to zero expecting raw.
980 server->sec_ntlmssp = true;
983 rc = cifs_enable_signing(server, ses->sign);
987 rc = decode_negTokenInit(security_blob, blob_length, server);
996 rc = smb311_decode_neg_context(rsp, server,
1013 struct TCP_Server_Info *server = tcon->ses->server;
1018 if (server->dialect == SMB311_PROT_ID)
1037 cifs_tcon_dbg(VFS, "Unexpected null user (anonymous) auth flag sent by server\n");
1044 cpu_to_le32(server->vals->req_capabilities);
1048 memcpy(pneg_inbuf->Guid, server->client_guid,
1061 if (strcmp(server->vals->version_string,
1069 } else if (strcmp(server->vals->version_string,
1081 cpu_to_le16(server->vals->protocol_id);
1094 * Old Windows versions or Netapp SMB server can return
1118 if (pneg_rsp->Dialect != cpu_to_le16(server->dialect))
1121 if (pneg_rsp->SecurityMode != cpu_to_le16(server->sec_mode))
1124 /* do not validate server guid because not saved at negprot time yet */
1127 SMB2_LARGE_FILES) != server->capabilities)
1145 smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
1154 if (server->sec_ntlmssp &&
1157 if ((server->sec_kerberos || server->sec_mskerberos) &&
1191 struct TCP_Server_Info *server = cifs_ses_server(ses);
1194 rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server,
1220 if (server->sign)
1288 struct TCP_Server_Info *server = cifs_ses_server(ses);
1290 mutex_lock(&server->srv_mutex);
1291 if (server->ops->generate_signingkey) {
1292 rc = server->ops->generate_signingkey(ses);
1296 mutex_unlock(&server->srv_mutex);
1300 if (!server->session_estab) {
1301 server->sequence_number = 0x2;
1302 server->session_estab = true;
1304 mutex_unlock(&server->srv_mutex);
1541 if (ses->server->dialect < SMB30_PROT_ID) {
1596 struct TCP_Server_Info *server = cifs_ses_server(ses);
1601 if (!server) {
1602 WARN(1, "%s: server is NULL!\n", __func__);
1620 * Initialize the session hash with the server one.
1622 memcpy(ses->preauth_sha_hash, server->preauth_sha_hash,
1642 struct TCP_Server_Info *server;
1651 if (ses && (ses->server))
1652 server = ses->server;
1660 rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server,
1670 else if (server->sign)
1682 rc = cifs_send_recv(xid, ses, ses->server,
1699 #define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */)
1724 struct TCP_Server_Info *server;
1727 server = ses->server;
1731 if (!server || !tree)
1748 rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server,
1773 if ((server->dialect == SMB311_PROT_ID) &&
1787 rc = cifs_send_recv(xid, ses, server,
1831 !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
1835 if (server->ops->validate_negotiate)
1836 rc = server->ops->validate_negotiate(xid, tcon);
1865 if (!ses || !(ses->server))
1873 rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, ses->server,
1891 rc = cifs_send_recv(xid, ses, ses->server,
1995 smb2_parse_contexts(struct TCP_Server_Info *server,
2025 *oplock = server->ops->parse_lease_buf(cc, epoch,
2055 add_lease_context(struct TCP_Server_Info *server, struct kvec *iov,
2061 iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock);
2064 iov[num].iov_len = server->vals->create_lease_size;
2071 server->vals->create_lease_size);
2094 * NB: Handle timeout defaults to 0, which allows server to choose
2512 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2521 if (!ses || !server) {
2527 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
2614 rc = cifs_send_recv(xid, ses, server,
2644 SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
2658 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
2721 if ((!server->oplocks) || (tcon->no_lease))
2724 if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||
2727 else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) &&
2731 rc = add_lease_context(server, iov, &n_iov,
2739 if (server->capabilities & SMB2_GLOBAL_CAP_LEASING) {
2743 cpu_to_le32(server->vals->create_lease_size);
2847 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2855 if (!ses || !server)
2866 rc = SMB2_open_init(tcon, server,
2874 rc = cifs_send_recv(xid, ses, server,
2890 pr_warn_once("server share %s deleted\n",
2918 smb2_parse_contexts(server, rsp, &oparms->fid->epoch,
2927 SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
2939 rc = smb2_ioctl_req_init(opcode, tcon, server,
2990 * ioctls it may be useful to allow server to send more. No point
2991 * limiting what the server can send as long as fits in one credit
3040 struct TCP_Server_Info *server;
3063 server = cifs_pick_channel(ses);
3064 if (!server)
3075 rc = SMB2_ioctl_init(tcon, server,
3081 rc = cifs_send_recv(xid, ses, server,
3114 goto ioctl_exit; /* server returned no data */
3170 SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3179 rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server,
3211 struct TCP_Server_Info *server = cifs_pick_channel(ses);
3221 if (!ses || !server)
3232 /* check if need to ask server to return timestamps in close response */
3237 rc = SMB2_close_init(tcon, server,
3243 rc = cifs_send_recv(xid, ses, server,
3312 cifs_dbg(VFS, "Invalid server response, bad offset to data\n");
3344 SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3360 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
3405 struct TCP_Server_Info *server;
3413 server = cifs_pick_channel(ses);
3414 if (!server)
3425 rc = SMB2_query_info_init(tcon, server,
3435 rc = cifs_send_recv(xid, ses, server,
3534 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3543 rc = smb2_plain_req_init(SMB2_CHANGE_NOTIFY, tcon, server,
3571 struct TCP_Server_Info *server = cifs_pick_channel(ses);
3580 if (!ses || !server)
3591 rc = SMB2_notify_init(xid, &rqst, tcon, server,
3599 rc = cifs_send_recv(xid, ses, server,
3621 * rather in the fact that the server sent one and that server->lstrp
3629 struct TCP_Server_Info *server = mid->callback_data;
3636 credits.instance = server->reconnect_instance;
3640 add_credits(server, &credits, CIFS_ECHO_OP);
3645 struct TCP_Server_Info *server = container_of(work,
3656 mutex_lock(&server->reconnect_mutex);
3662 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
3681 * Get the reference to server struct to be sure that the last call of
3682 * cifs_put_tcon() in the loop below won't release the server pointer.
3685 server->srv_count++;
3690 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server);
3704 queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ);
3705 mutex_unlock(&server->reconnect_mutex);
3709 cifs_put_tcp_session(server, 1);
3713 SMB2_echo(struct TCP_Server_Info *server)
3724 if (server->tcpStatus == CifsNeedNegotiate) {
3726 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
3730 rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,
3740 rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,
3741 server, CIFS_ECHO_OP, NULL);
3758 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3766 rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,
3788 struct TCP_Server_Info *server = cifs_pick_channel(ses);
3794 if (!ses || !(ses->server))
3805 rc = SMB2_flush_init(xid, &rqst, tcon, server,
3811 rc = cifs_send_recv(xid, ses, server,
3840 struct TCP_Server_Info *server = io_parms->server;
3842 rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,
3847 if (server == NULL)
3871 if (server->rdma && rdata && !server->sign &&
3872 rdata->bytes >= server->smbd_conn->rdma_readwrite_threshold) {
3875 bool need_invalidate = server->dialect == SMB30_PROT_ID;
3878 server->smbd_conn, rdata->pages,
3932 struct TCP_Server_Info *server = rdata->server;
3947 WARN_ONCE(rdata->server != mid->server,
3948 "rdata server %p != mid server %p",
3949 rdata->server, mid->server);
3958 credits.instance = server->reconnect_instance;
3960 if (server->sign && !mid->decrypted) {
3963 rc = smb2_verify_signature(&rqst, server);
3975 if (server->sign && rdata->got_bytes)
3984 credits.instance = server->reconnect_instance;
4014 add_credits(server, &credits, 0);
4027 struct TCP_Server_Info *server;
4034 if (!rdata->server)
4035 rdata->server = cifs_pick_channel(tcon->ses);
4038 io_parms.server = server = rdata->server;
4063 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4071 rc = cifs_call_async(server, &rqst,
4103 if (!io_parms->server)
4104 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4121 rc = cifs_send_recv(xid, ses, io_parms->server,
4178 struct TCP_Server_Info *server = wdata->server;
4183 WARN_ONCE(wdata->server != mid->server,
4184 "wdata server %p != mid server %p",
4185 wdata->server, mid->server);
4190 credits.instance = server->reconnect_instance;
4191 wdata->result = smb2_check_receive(mid, server, 0);
4198 * by the server is greater than bytes requested by the
4216 credits.instance = server->reconnect_instance;
4252 add_credits(server, &credits, 0);
4264 struct TCP_Server_Info *server = wdata->server;
4269 if (!wdata->server)
4270 server = wdata->server = cifs_pick_channel(tcon->ses);
4272 rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,
4297 * If we want to do a server RDMA read, fill in and append
4300 if (server->rdma && !server->sign && wdata->bytes >=
4301 server->smbd_conn->rdma_readwrite_threshold) {
4304 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4307 server->smbd_conn, wdata->pages,
4369 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
4377 rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,
4411 struct TCP_Server_Info *server;
4418 if (!io_parms->server)
4419 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4420 server = io_parms->server;
4421 if (server == NULL)
4424 rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,
4457 rc = cifs_send_recv(xid, io_parms->tcon->ses, server,
4633 struct TCP_Server_Info *server,
4648 rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,
4684 output_size = min_t(unsigned int, output_size, server->maxBuf);
4792 struct TCP_Server_Info *server = cifs_pick_channel(ses);
4795 if (!ses || !(ses->server))
4806 rc = SMB2_query_directory_init(xid, tcon, server,
4813 rc = cifs_send_recv(xid, ses, server,
4851 SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
4862 rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,
4914 struct TCP_Server_Info *server = cifs_pick_channel(ses);
4917 if (!ses || !server)
4934 rc = SMB2_set_info_init(tcon, server,
4944 rc = cifs_send_recv(xid, ses, server,
5008 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5016 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5038 rc = cifs_send_recv(xid, ses, server,
5083 struct TCP_Server_Info *server,
5093 if ((tcon->ses == NULL) || server == NULL)
5096 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
5132 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5136 rc = build_qfs_info_req(&iov, tcon, server,
5150 rc = cifs_send_recv(xid, ses, server,
5183 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5187 rc = build_qfs_info_req(&iov, tcon, server,
5201 rc = cifs_send_recv(xid, ses, server,
5234 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5255 rc = build_qfs_info_req(&iov, tcon, server,
5268 rc = cifs_send_recv(xid, ses, server,
5322 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
5326 rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,
5353 rc = cifs_send_recv(xid, tcon->ses, server,
5399 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
5402 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5426 rc = cifs_send_recv(xid, ses, server,