Lines Matching refs:server
81 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
89 struct TCP_Server_Info *server)
97 if (server) {
99 if (server->dialect >= SMB30_PROT_ID) {
105 if (SERVER_IS_CHAN(server))
107 cpu_to_le16(server->primary_server->channel_sequence_num);
110 cpu_to_le16(server->channel_sequence_num);
112 spin_lock(&server->req_lock);
114 if (server->credits >= server->max_credits)
118 min_t(int, server->max_credits -
119 server->credits, 10));
120 spin_unlock(&server->req_lock);
131 if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
142 * to pass the path on the Open SMB prefixed by \\server\share.
145 * illegal to send an empty path name (without \\server\share prefix)
153 if (server && server->sign && !smb3_encryption_required(tcon))
162 struct TCP_Server_Info *server,
168 if (SERVER_IS_CHAN(server)) {
170 "server %s does not support multichannel anymore. Skip secondary channel\n",
171 ses->server->hostname);
174 chan_index = cifs_ses_get_chan_index(ses, server);
180 ses->chans[chan_index].server = NULL;
181 server->terminate = true;
185 * the above reference of server by channel
190 cifs_put_tcp_session(server, from_reconnect);
192 cifs_signal_cifsd_for_reconnect(server, false);
194 /* mark primary server as needing reconnect */
195 pserver = server->primary_server;
202 "server does not support multichannel anymore. Disable all other channels\n");
211 struct TCP_Server_Info *server, bool from_reconnect)
256 if (!ses->server || !server)
259 spin_lock(&server->srv_lock);
260 if (server->tcpStatus == CifsNeedReconnect) {
273 spin_unlock(&server->srv_lock);
278 /* if server is marked for termination, cifsd will cleanup */
279 if (server->terminate) {
280 spin_unlock(&server->srv_lock);
283 spin_unlock(&server->srv_lock);
286 rc = cifs_wait_for_server_reconnect(server, tcon->retry);
291 if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {
306 spin_lock(&server->srv_lock);
307 if (server->tcpStatus == CifsExiting) {
308 spin_unlock(&server->srv_lock);
316 * and the server never sends an answer the socket will be closed
319 if (server->tcpStatus == CifsNeedReconnect) {
320 spin_unlock(&server->srv_lock);
329 spin_unlock(&server->srv_lock);
339 if (!cifs_chan_needs_reconnect(ses, server) &&
353 rc = cifs_negotiate_protocol(0, ses, server);
356 * if server stopped supporting multichannel
360 !(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
361 rc = cifs_chan_skip_or_disable(ses, server,
369 rc = cifs_setup_session(0, ses, server, nls_codepage);
412 (server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
416 * query server network interfaces, in case they change
424 * some servers like Azure SMB server do not advertise
425 * that multichannel has been disabled with server
427 * treat this as server not supporting multichannel
430 rc = cifs_chan_skip_or_disable(ses, server,
434 cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n",
439 !SERVER_IS_CHAN(server)) {
458 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
467 * BB Is flush done by server on drop of tcp session? Should we special
487 struct TCP_Server_Info *server,
501 smb2_hdr_assemble(&spdu->hdr, smb2_command, tcon, server);
513 struct TCP_Server_Info *server,
531 fill_small_buf(smb2_command, tcon, server,
545 struct TCP_Server_Info *server,
550 rc = smb2_reconnect(smb2_command, tcon, server, false);
554 return __smb2_plain_req_init(smb2_command, tcon, server, request_buf,
559 struct TCP_Server_Info *server,
564 return __smb2_plain_req_init(SMB2_IOCTL, tcon, server,
567 return smb2_plain_req_init(SMB2_IOCTL, tcon, server,
648 /* copy up to max of first 100 bytes of server name to NetName field */
680 struct TCP_Server_Info *server, unsigned int *total_len)
716 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
734 if (server->compress_algorithm) {
766 pr_warn_once("server sent bad preauth context\n");
769 pr_warn_once("server sent invalid SaltLength\n");
778 static void decode_compress_ctx(struct TCP_Server_Info *server,
789 pr_warn_once("server sent bad compression cntxt\n");
800 server->compress_algorithm = ctxt->CompressionAlgorithms[0];
803 static int decode_encrypt_ctx(struct TCP_Server_Info *server,
815 pr_warn_once("server sent bad crypto ctxt len\n");
831 * e.g. if server only supported AES256_CCM (very unlikely)
832 * or server supported no encryption types or had all disabled.
836 * seal not requested by client, since server is allowed to
839 server->cipher_type = 0;
840 server->capabilities &= ~SMB2_GLOBAL_CAP_ENCRYPTION;
846 /* server returned a cipher we didn't ask for */
850 server->cipher_type = ctxt->Ciphers[0];
851 server->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION;
855 static void decode_signing_ctx(struct TCP_Server_Info *server,
866 pr_warn_once("server sent bad signing negcontext\n");
878 server->signing_negotiated = true;
879 server->signing_algorithm = le16_to_cpu(pctxt->SigningAlgorithms[0]);
881 server->signing_algorithm);
886 struct TCP_Server_Info *server,
926 rc = decode_encrypt_ctx(server,
929 decode_compress_ctx(server,
932 server->posix_ext_supported = true;
934 decode_signing_ctx(server,
1021 struct TCP_Server_Info *server)
1037 if (!server) {
1038 WARN(1, "%s: server is NULL!\n", __func__);
1042 rc = smb2_plain_req_init(SMB2_NEGOTIATE, NULL, server,
1049 memset(server->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE);
1052 if (strcmp(server->vals->version_string,
1059 } else if (strcmp(server->vals->version_string,
1069 req->Dialects[0] = cpu_to_le16(server->vals->protocol_id);
1082 req->Capabilities = cpu_to_le32(server->vals->req_capabilities);
1087 if (server->vals->protocol_id == SMB20_PROT_ID)
1090 memcpy(req->ClientGUID, server->client_guid,
1092 if ((server->vals->protocol_id == SMB311_PROT_ID) ||
1093 (strcmp(server->vals->version_string,
1095 (strcmp(server->vals->version_string,
1097 assemble_neg_contexts(req, server, &total_len);
1106 rc = cifs_send_recv(xid, ses, server,
1115 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");
1121 if (strcmp(server->vals->version_string,
1133 server->ops = &smb311_operations;
1134 server->vals = &smb311_values;
1136 } else if (strcmp(server->vals->version_string,
1144 server->ops = &smb21_operations;
1145 server->vals = &smb21_values;
1147 server->ops = &smb311_operations;
1148 server->vals = &smb311_values;
1151 server->vals->protocol_id) {
1171 cifs_server_dbg(VFS, "Invalid dialect returned by server 0x%x\n",
1177 server->dialect = le16_to_cpu(rsp->DialectRevision);
1182 * server.
1184 memcpy(server->preauth_sha_hash, ses->preauth_sha_hash,
1188 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
1190 server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),
1192 server->max_read = le32_to_cpu(rsp->MaxReadSize);
1193 server->max_write = le32_to_cpu(rsp->MaxWriteSize);
1194 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
1195 if ((server->sec_mode & SMB2_SEC_MODE_FLAGS_ALL) != server->sec_mode)
1197 server->sec_mode);
1198 server->capabilities = le32_to_cpu(rsp->Capabilities);
1200 server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES;
1206 if (server->dialect == SMB30_PROT_ID && (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
1207 server->cipher_type = SMB2_ENCRYPTION_AES128_CCM;
1216 * We just found a server which sets blob length to zero expecting raw.
1220 server->sec_ntlmssp = true;
1223 rc = cifs_enable_signing(server, ses->sign);
1227 rc = decode_negTokenInit(security_blob, blob_length, server);
1236 rc = smb311_decode_neg_context(rsp, server,
1253 struct TCP_Server_Info *server = tcon->ses->server;
1258 if (server->dialect == SMB311_PROT_ID)
1277 cifs_tcon_dbg(VFS, "Unexpected null user (anonymous) auth flag sent by server\n");
1284 cpu_to_le32(server->vals->req_capabilities);
1288 memcpy(pneg_inbuf->Guid, server->client_guid,
1301 if (strcmp(server->vals->version_string,
1310 } else if (strcmp(server->vals->version_string,
1322 cpu_to_le16(server->vals->protocol_id);
1335 * Old Windows versions or Netapp SMB server can return
1359 if (pneg_rsp->Dialect != cpu_to_le16(server->dialect))
1362 if (pneg_rsp->SecurityMode != cpu_to_le16(server->sec_mode))
1365 /* do not validate server guid because not saved at negprot time yet */
1368 SMB2_LARGE_FILES) != server->capabilities)
1386 smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
1395 if (server->sec_ntlmssp &&
1398 if ((server->sec_kerberos || server->sec_mskerberos) &&
1410 struct TCP_Server_Info *server;
1432 struct TCP_Server_Info *server = sess_data->server;
1437 rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server,
1467 if (server->credits >= server->max_credits)
1471 min_t(int, server->max_credits -
1472 server->credits, 130));
1475 if (server->sign)
1534 sess_data->server,
1554 struct TCP_Server_Info *server = sess_data->server;
1556 cifs_server_lock(server);
1557 if (server->ops->generate_signingkey) {
1558 rc = server->ops->generate_signingkey(ses, server);
1562 cifs_server_unlock(server);
1566 if (!server->session_estab) {
1567 server->sequence_number = 0x2;
1568 server->session_estab = true;
1570 cifs_server_unlock(server);
1582 struct TCP_Server_Info *server = sess_data->server;
1592 spnego_key = cifs_get_spnego_key(ses, server);
1677 struct TCP_Server_Info *server = sess_data->server;
1700 &blob_length, ses, server,
1769 struct TCP_Server_Info *server = sess_data->server;
1785 ses, server,
1819 if (ses->server->dialect < SMB30_PROT_ID) {
1847 struct TCP_Server_Info *server = sess_data->server;
1849 type = smb2_select_sectype(server, ses->sectype);
1873 struct TCP_Server_Info *server,
1881 if (!server) {
1882 WARN(1, "%s: server is NULL!\n", __func__);
1892 sess_data->server = server;
1902 * Initialize the session hash with the server one.
1904 memcpy(ses->preauth_sha_hash, server->preauth_sha_hash,
1924 struct TCP_Server_Info *server;
1933 if (ses && (ses->server))
1934 server = ses->server;
1946 rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server,
1956 else if (server->sign)
1968 rc = cifs_send_recv(xid, ses, ses->server,
1985 #define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */)
2010 struct TCP_Server_Info *server;
2013 server = ses->server;
2017 if (!server || !tree)
2034 rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server,
2059 if ((server->dialect == SMB311_PROT_ID) &&
2071 if (server->credits >= server->max_credits)
2075 min_t(int, server->max_credits -
2076 server->credits, 64));
2078 rc = cifs_send_recv(xid, ses, server,
2118 !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
2122 if (server->ops->validate_negotiate)
2123 rc = server->ops->validate_negotiate(xid, tcon);
2126 server->nosharesock = true;
2154 if (!ses || !(ses->server))
2168 rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, ses->server,
2186 rc = cifs_send_recv(xid, ses, ses->server,
2292 int smb2_parse_contexts(struct TCP_Server_Info *server,
2338 *oplock = server->ops->parse_lease_buf(cc, epoch,
2372 add_lease_context(struct TCP_Server_Info *server,
2379 iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock);
2382 iov[num].iov_len = server->vals->create_lease_size;
2406 * NB: Handle timeout defaults to 0, which allows server to choose
2788 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2797 if (!ses || !server) {
2803 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
2893 rc = cifs_send_recv(xid, ses, server,
2933 SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
2947 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
3008 if ((!server->oplocks) || (tcon->no_lease))
3011 if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||
3014 else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) &&
3018 rc = add_lease_context(server, req, iov, &n_iov,
3124 struct TCP_Server_Info *server = cifs_pick_channel(ses);
3132 if (!ses || !server)
3143 rc = SMB2_open_init(tcon, server,
3151 rc = cifs_send_recv(xid, ses, server,
3167 pr_warn_once("server share %s deleted\n",
3199 rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch,
3208 SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3220 rc = smb2_ioctl_req_init(opcode, tcon, server,
3271 * ioctls it may be useful to allow server to send more. No point
3272 * limiting what the server can send as long as fits in one credit
3322 struct TCP_Server_Info *server;
3345 server = cifs_pick_channel(ses);
3346 if (!server)
3357 rc = SMB2_ioctl_init(tcon, server,
3363 rc = cifs_send_recv(xid, ses, server,
3406 goto ioctl_exit; /* server returned no data */
3462 SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3471 rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server,
3503 struct TCP_Server_Info *server = cifs_pick_channel(ses);
3513 if (!ses || !server)
3524 /* check if need to ask server to return timestamps in close response */
3529 rc = SMB2_close_init(tcon, server,
3535 rc = cifs_send_recv(xid, ses, server,
3602 cifs_dbg(VFS, "Invalid server response, bad offset to data\n");
3634 SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3650 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
3695 struct TCP_Server_Info *server;
3703 server = cifs_pick_channel(ses);
3704 if (!server)
3715 rc = SMB2_query_info_init(tcon, server,
3725 rc = cifs_send_recv(xid, ses, server,
3829 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3838 rc = smb2_plain_req_init(SMB2_CHANGE_NOTIFY, tcon, server,
3867 struct TCP_Server_Info *server = cifs_pick_channel(ses);
3877 if (!ses || !server)
3891 rc = SMB2_notify_init(xid, &rqst, tcon, server,
3899 rc = cifs_send_recv(xid, ses, server,
3940 * rather in the fact that the server sent one and that server->lstrp
3948 struct TCP_Server_Info *server = mid->callback_data;
3955 credits.instance = server->reconnect_instance;
3959 add_credits(server, &credits, CIFS_ECHO_OP);
3964 struct TCP_Server_Info *server = container_of(work,
3977 if (!server->srv_count) {
3981 server->srv_count++;
3984 /* If server is a channel, select the primary channel */
3985 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
3990 /* if the server is marked for termination, drop the ref count here */
3991 if (server->terminate) {
3992 cifs_put_tcp_session(server, true);
4034 if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) {
4044 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4077 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4088 queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ);
4092 cifs_put_tcp_session(server, true);
4096 SMB2_echo(struct TCP_Server_Info *server)
4105 cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id);
4107 spin_lock(&server->srv_lock);
4108 if (server->ops->need_neg &&
4109 server->ops->need_neg(server)) {
4110 spin_unlock(&server->srv_lock);
4112 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
4115 spin_unlock(&server->srv_lock);
4117 rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,
4127 rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,
4128 server, CIFS_ECHO_OP, NULL);
4145 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
4153 rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,
4175 struct TCP_Server_Info *server = cifs_pick_channel(ses);
4181 if (!ses || !(ses->server))
4192 rc = SMB2_flush_init(xid, &rqst, tcon, server,
4198 rc = cifs_send_recv(xid, ses, server,
4218 struct TCP_Server_Info *server = io_parms->server;
4222 if (!server || !tcon)
4226 if (!server->rdma || !server->smbd_conn)
4230 if (server->sign)
4238 if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold)
4257 struct TCP_Server_Info *server = io_parms->server;
4259 rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,
4264 if (server == NULL)
4290 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4292 rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->iter,
4345 struct TCP_Server_Info *server = rdata->server;
4356 WARN_ONCE(rdata->server != mid->server,
4357 "rdata server %p != mid server %p",
4358 rdata->server, mid->server);
4367 credits.instance = server->reconnect_instance;
4369 if (server->sign && !mid->decrypted) {
4374 rc = smb2_verify_signature(&rqst, server);
4386 if (server->sign && rdata->got_bytes)
4395 credits.instance = server->reconnect_instance;
4425 add_credits(server, &credits, 0);
4438 struct TCP_Server_Info *server;
4446 if (!rdata->server)
4447 rdata->server = cifs_pick_channel(tcon->ses);
4450 io_parms.server = server = rdata->server;
4474 if (server->credits >= server->max_credits)
4478 min_t(int, server->max_credits -
4479 server->credits, credit_request));
4481 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4489 rc = cifs_call_async(server, &rqst,
4521 if (!io_parms->server)
4522 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4539 rc = cifs_send_recv(xid, ses, io_parms->server,
4597 struct TCP_Server_Info *server = wdata->server;
4602 WARN_ONCE(wdata->server != mid->server,
4603 "wdata server %p != mid server %p",
4604 wdata->server, mid->server);
4609 credits.instance = server->reconnect_instance;
4610 wdata->result = smb2_check_receive(mid, server, 0);
4617 * by the server is greater than bytes requested by the
4635 credits.instance = server->reconnect_instance;
4671 add_credits(server, &credits, 0);
4683 struct TCP_Server_Info *server = wdata->server;
4691 if (!wdata->server)
4692 server = wdata->server = cifs_pick_channel(tcon->ses);
4700 .server = server,
4709 rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,
4739 * If we want to do a server RDMA read, fill in and append
4745 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4747 wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->iter,
4795 if (server->credits >= server->max_credits)
4799 min_t(int, server->max_credits -
4800 server->credits, credit_request));
4802 rc = adjust_credits(server, &wdata->credits, io_parms->length);
4810 rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,
4848 struct TCP_Server_Info *server;
4855 if (!io_parms->server)
4856 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4857 server = io_parms->server;
4858 if (server == NULL)
4861 rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,
4894 rc = cifs_send_recv(xid, io_parms->tcon->ses, server,
5070 struct TCP_Server_Info *server,
5085 rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,
5124 output_size = min_t(unsigned int, output_size, server->maxBuf);
5235 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5238 if (!ses || !(ses->server))
5249 rc = SMB2_query_directory_init(xid, tcon, server,
5256 rc = cifs_send_recv(xid, ses, server,
5294 SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
5305 rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,
5356 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5359 if (!ses || !server)
5376 rc = SMB2_set_info_init(tcon, server,
5386 rc = cifs_send_recv(xid, ses, server,
5452 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5460 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5482 rc = cifs_send_recv(xid, ses, server,
5527 struct TCP_Server_Info *server,
5537 if ((tcon->ses == NULL) || server == NULL)
5540 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
5576 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5580 rc = build_qfs_info_req(&iov, tcon, server,
5594 rc = cifs_send_recv(xid, ses, server,
5627 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5631 rc = build_qfs_info_req(&iov, tcon, server,
5645 rc = cifs_send_recv(xid, ses, server,
5678 struct TCP_Server_Info *server = cifs_pick_channel(ses);
5699 rc = build_qfs_info_req(&iov, tcon, server,
5712 rc = cifs_send_recv(xid, ses, server,
5766 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
5770 rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,
5797 rc = cifs_send_recv(xid, tcon->ses, server,
5843 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
5846 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5870 rc = cifs_send_recv(xid, ses, server,