xref: /linux/fs/smb/server/mgmt/user_session.c (revision a6d0dbba950880e269d433222ca6d516ebe8a6ae) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
4  */
5 
6 #include <linux/list.h>
7 #include <linux/slab.h>
8 #include <linux/rwsem.h>
9 #include <linux/xarray.h>
10 
11 #include "ksmbd_ida.h"
12 #include "user_session.h"
13 #include "user_config.h"
14 #include "tree_connect.h"
15 #include "../transport_ipc.h"
16 #include "../connection.h"
17 #include "../vfs_cache.h"
18 
19 static DEFINE_IDA(session_ida);
20 
21 #define SESSION_HASH_BITS		3
22 static DEFINE_HASHTABLE(sessions_table, SESSION_HASH_BITS);
23 static DECLARE_RWSEM(sessions_table_lock);
24 
25 struct ksmbd_session_rpc {
26 	int			id;
27 	unsigned int		method;
28 };
29 
30 static void free_channel_list(struct ksmbd_session *sess)
31 {
32 	struct channel *chann;
33 	unsigned long index;
34 
35 	xa_for_each(&sess->ksmbd_chann_list, index, chann) {
36 		xa_erase(&sess->ksmbd_chann_list, index);
37 		kfree(chann);
38 	}
39 
40 	xa_destroy(&sess->ksmbd_chann_list);
41 }
42 
43 static void __session_rpc_close(struct ksmbd_session *sess,
44 				struct ksmbd_session_rpc *entry)
45 {
46 	struct ksmbd_rpc_command *resp;
47 
48 	resp = ksmbd_rpc_close(sess, entry->id);
49 	if (!resp)
50 		pr_err("Unable to close RPC pipe %d\n", entry->id);
51 
52 	kvfree(resp);
53 	ksmbd_rpc_id_free(entry->id);
54 	kfree(entry);
55 }
56 
57 static void ksmbd_session_rpc_clear_list(struct ksmbd_session *sess)
58 {
59 	struct ksmbd_session_rpc *entry;
60 	long index;
61 
62 	xa_for_each(&sess->rpc_handle_list, index, entry) {
63 		xa_erase(&sess->rpc_handle_list, index);
64 		__session_rpc_close(sess, entry);
65 	}
66 
67 	xa_destroy(&sess->rpc_handle_list);
68 }
69 
70 static int __rpc_method(char *rpc_name)
71 {
72 	if (!strcmp(rpc_name, "\\srvsvc") || !strcmp(rpc_name, "srvsvc"))
73 		return KSMBD_RPC_SRVSVC_METHOD_INVOKE;
74 
75 	if (!strcmp(rpc_name, "\\wkssvc") || !strcmp(rpc_name, "wkssvc"))
76 		return KSMBD_RPC_WKSSVC_METHOD_INVOKE;
77 
78 	if (!strcmp(rpc_name, "LANMAN") || !strcmp(rpc_name, "lanman"))
79 		return KSMBD_RPC_RAP_METHOD;
80 
81 	if (!strcmp(rpc_name, "\\samr") || !strcmp(rpc_name, "samr"))
82 		return KSMBD_RPC_SAMR_METHOD_INVOKE;
83 
84 	if (!strcmp(rpc_name, "\\lsarpc") || !strcmp(rpc_name, "lsarpc"))
85 		return KSMBD_RPC_LSARPC_METHOD_INVOKE;
86 
87 	pr_err("Unsupported RPC: %s\n", rpc_name);
88 	return 0;
89 }
90 
91 int ksmbd_session_rpc_open(struct ksmbd_session *sess, char *rpc_name)
92 {
93 	struct ksmbd_session_rpc *entry, *old;
94 	struct ksmbd_rpc_command *resp;
95 	int method;
96 
97 	method = __rpc_method(rpc_name);
98 	if (!method)
99 		return -EINVAL;
100 
101 	entry = kzalloc(sizeof(struct ksmbd_session_rpc), KSMBD_DEFAULT_GFP);
102 	if (!entry)
103 		return -ENOMEM;
104 
105 	entry->method = method;
106 	entry->id = ksmbd_ipc_id_alloc();
107 	if (entry->id < 0)
108 		goto free_entry;
109 	old = xa_store(&sess->rpc_handle_list, entry->id, entry, KSMBD_DEFAULT_GFP);
110 	if (xa_is_err(old))
111 		goto free_id;
112 
113 	resp = ksmbd_rpc_open(sess, entry->id);
114 	if (!resp)
115 		goto erase_xa;
116 
117 	kvfree(resp);
118 	return entry->id;
119 erase_xa:
120 	xa_erase(&sess->rpc_handle_list, entry->id);
121 free_id:
122 	ksmbd_rpc_id_free(entry->id);
123 free_entry:
124 	kfree(entry);
125 	return -EINVAL;
126 }
127 
128 void ksmbd_session_rpc_close(struct ksmbd_session *sess, int id)
129 {
130 	struct ksmbd_session_rpc *entry;
131 
132 	entry = xa_erase(&sess->rpc_handle_list, id);
133 	if (entry)
134 		__session_rpc_close(sess, entry);
135 }
136 
137 int ksmbd_session_rpc_method(struct ksmbd_session *sess, int id)
138 {
139 	struct ksmbd_session_rpc *entry;
140 
141 	entry = xa_load(&sess->rpc_handle_list, id);
142 	return entry ? entry->method : 0;
143 }
144 
145 void ksmbd_session_destroy(struct ksmbd_session *sess)
146 {
147 	if (!sess)
148 		return;
149 
150 	if (sess->user)
151 		ksmbd_free_user(sess->user);
152 
153 	ksmbd_tree_conn_session_logoff(sess);
154 	ksmbd_destroy_file_table(&sess->file_table);
155 	ksmbd_launch_ksmbd_durable_scavenger();
156 	ksmbd_session_rpc_clear_list(sess);
157 	free_channel_list(sess);
158 	kfree(sess->Preauth_HashValue);
159 	ksmbd_release_id(&session_ida, sess->id);
160 	kfree(sess);
161 }
162 
163 struct ksmbd_session *__session_lookup(unsigned long long id)
164 {
165 	struct ksmbd_session *sess;
166 
167 	hash_for_each_possible(sessions_table, sess, hlist, id) {
168 		if (id == sess->id) {
169 			sess->last_active = jiffies;
170 			return sess;
171 		}
172 	}
173 	return NULL;
174 }
175 
176 static void ksmbd_expire_session(struct ksmbd_conn *conn)
177 {
178 	unsigned long id;
179 	struct ksmbd_session *sess;
180 
181 	down_write(&sessions_table_lock);
182 	down_write(&conn->session_lock);
183 	xa_for_each(&conn->sessions, id, sess) {
184 		if (atomic_read(&sess->refcnt) == 0 &&
185 		    (sess->state != SMB2_SESSION_VALID ||
186 		     time_after(jiffies,
187 			       sess->last_active + SMB2_SESSION_TIMEOUT))) {
188 			xa_erase(&conn->sessions, sess->id);
189 			hash_del(&sess->hlist);
190 			ksmbd_session_destroy(sess);
191 			continue;
192 		}
193 	}
194 	up_write(&conn->session_lock);
195 	up_write(&sessions_table_lock);
196 }
197 
198 int ksmbd_session_register(struct ksmbd_conn *conn,
199 			   struct ksmbd_session *sess)
200 {
201 	sess->dialect = conn->dialect;
202 	memcpy(sess->ClientGUID, conn->ClientGUID, SMB2_CLIENT_GUID_SIZE);
203 	ksmbd_expire_session(conn);
204 	return xa_err(xa_store(&conn->sessions, sess->id, sess, KSMBD_DEFAULT_GFP));
205 }
206 
207 static int ksmbd_chann_del(struct ksmbd_conn *conn, struct ksmbd_session *sess)
208 {
209 	struct channel *chann;
210 
211 	chann = xa_erase(&sess->ksmbd_chann_list, (long)conn);
212 	if (!chann)
213 		return -ENOENT;
214 
215 	kfree(chann);
216 	return 0;
217 }
218 
219 void ksmbd_sessions_deregister(struct ksmbd_conn *conn)
220 {
221 	struct ksmbd_session *sess;
222 	unsigned long id;
223 
224 	down_write(&sessions_table_lock);
225 	if (conn->binding) {
226 		int bkt;
227 		struct hlist_node *tmp;
228 
229 		hash_for_each_safe(sessions_table, bkt, tmp, sess, hlist) {
230 			if (!ksmbd_chann_del(conn, sess) &&
231 			    xa_empty(&sess->ksmbd_chann_list)) {
232 				hash_del(&sess->hlist);
233 				down_write(&conn->session_lock);
234 				xa_erase(&conn->sessions, sess->id);
235 				up_write(&conn->session_lock);
236 				ksmbd_session_destroy(sess);
237 			}
238 		}
239 	}
240 
241 	down_write(&conn->session_lock);
242 	xa_for_each(&conn->sessions, id, sess) {
243 		unsigned long chann_id;
244 		struct channel *chann;
245 
246 		xa_for_each(&sess->ksmbd_chann_list, chann_id, chann) {
247 			if (chann->conn != conn)
248 				ksmbd_conn_set_exiting(chann->conn);
249 		}
250 
251 		ksmbd_chann_del(conn, sess);
252 		if (xa_empty(&sess->ksmbd_chann_list)) {
253 			xa_erase(&conn->sessions, sess->id);
254 			hash_del(&sess->hlist);
255 			ksmbd_session_destroy(sess);
256 		}
257 	}
258 	up_write(&conn->session_lock);
259 	up_write(&sessions_table_lock);
260 }
261 
262 bool is_ksmbd_session_in_connection(struct ksmbd_conn *conn,
263 				   unsigned long long id)
264 {
265 	struct ksmbd_session *sess;
266 
267 	down_read(&conn->session_lock);
268 	sess = xa_load(&conn->sessions, id);
269 	if (sess) {
270 		up_read(&conn->session_lock);
271 		return true;
272 	}
273 	up_read(&conn->session_lock);
274 
275 	return false;
276 }
277 
278 struct ksmbd_session *ksmbd_session_lookup(struct ksmbd_conn *conn,
279 					   unsigned long long id)
280 {
281 	struct ksmbd_session *sess;
282 
283 	down_read(&conn->session_lock);
284 	sess = xa_load(&conn->sessions, id);
285 	if (sess) {
286 		sess->last_active = jiffies;
287 		ksmbd_user_session_get(sess);
288 	}
289 	up_read(&conn->session_lock);
290 	return sess;
291 }
292 
293 struct ksmbd_session *ksmbd_session_lookup_slowpath(unsigned long long id)
294 {
295 	struct ksmbd_session *sess;
296 
297 	down_read(&sessions_table_lock);
298 	sess = __session_lookup(id);
299 	if (sess)
300 		ksmbd_user_session_get(sess);
301 	up_read(&sessions_table_lock);
302 
303 	return sess;
304 }
305 
306 struct ksmbd_session *ksmbd_session_lookup_all(struct ksmbd_conn *conn,
307 					       unsigned long long id)
308 {
309 	struct ksmbd_session *sess;
310 
311 	sess = ksmbd_session_lookup(conn, id);
312 	if (!sess && conn->binding)
313 		sess = ksmbd_session_lookup_slowpath(id);
314 	if (sess && sess->state != SMB2_SESSION_VALID)
315 		sess = NULL;
316 	return sess;
317 }
318 
319 void ksmbd_user_session_get(struct ksmbd_session *sess)
320 {
321 	atomic_inc(&sess->refcnt);
322 }
323 
324 void ksmbd_user_session_put(struct ksmbd_session *sess)
325 {
326 	if (!sess)
327 		return;
328 
329 	if (atomic_read(&sess->refcnt) <= 0)
330 		WARN_ON(1);
331 	else
332 		atomic_dec(&sess->refcnt);
333 }
334 
335 struct preauth_session *ksmbd_preauth_session_alloc(struct ksmbd_conn *conn,
336 						    u64 sess_id)
337 {
338 	struct preauth_session *sess;
339 
340 	sess = kmalloc(sizeof(struct preauth_session), KSMBD_DEFAULT_GFP);
341 	if (!sess)
342 		return NULL;
343 
344 	sess->id = sess_id;
345 	memcpy(sess->Preauth_HashValue, conn->preauth_info->Preauth_HashValue,
346 	       PREAUTH_HASHVALUE_SIZE);
347 	list_add(&sess->preauth_entry, &conn->preauth_sess_table);
348 
349 	return sess;
350 }
351 
352 void destroy_previous_session(struct ksmbd_conn *conn,
353 			      struct ksmbd_user *user, u64 id)
354 {
355 	struct ksmbd_session *prev_sess;
356 	struct ksmbd_user *prev_user;
357 	int err;
358 
359 	down_write(&sessions_table_lock);
360 	down_write(&conn->session_lock);
361 	prev_sess = __session_lookup(id);
362 	if (!prev_sess || prev_sess->state == SMB2_SESSION_EXPIRED)
363 		goto out;
364 
365 	prev_user = prev_sess->user;
366 	if (!prev_user ||
367 	    strcmp(user->name, prev_user->name) ||
368 	    user->passkey_sz != prev_user->passkey_sz ||
369 	    memcmp(user->passkey, prev_user->passkey, user->passkey_sz))
370 		goto out;
371 
372 	ksmbd_all_conn_set_status(id, KSMBD_SESS_NEED_RECONNECT);
373 	err = ksmbd_conn_wait_idle_sess_id(conn, id);
374 	if (err) {
375 		ksmbd_all_conn_set_status(id, KSMBD_SESS_NEED_NEGOTIATE);
376 		goto out;
377 	}
378 
379 	ksmbd_destroy_file_table(&prev_sess->file_table);
380 	prev_sess->state = SMB2_SESSION_EXPIRED;
381 	ksmbd_all_conn_set_status(id, KSMBD_SESS_NEED_NEGOTIATE);
382 	ksmbd_launch_ksmbd_durable_scavenger();
383 out:
384 	up_write(&conn->session_lock);
385 	up_write(&sessions_table_lock);
386 }
387 
388 static bool ksmbd_preauth_session_id_match(struct preauth_session *sess,
389 					   unsigned long long id)
390 {
391 	return sess->id == id;
392 }
393 
394 struct preauth_session *ksmbd_preauth_session_lookup(struct ksmbd_conn *conn,
395 						     unsigned long long id)
396 {
397 	struct preauth_session *sess = NULL;
398 
399 	list_for_each_entry(sess, &conn->preauth_sess_table, preauth_entry) {
400 		if (ksmbd_preauth_session_id_match(sess, id))
401 			return sess;
402 	}
403 	return NULL;
404 }
405 
406 static int __init_smb2_session(struct ksmbd_session *sess)
407 {
408 	int id = ksmbd_acquire_smb2_uid(&session_ida);
409 
410 	if (id < 0)
411 		return -EINVAL;
412 	sess->id = id;
413 	return 0;
414 }
415 
416 static struct ksmbd_session *__session_create(int protocol)
417 {
418 	struct ksmbd_session *sess;
419 	int ret;
420 
421 	if (protocol != CIFDS_SESSION_FLAG_SMB2)
422 		return NULL;
423 
424 	sess = kzalloc(sizeof(struct ksmbd_session), KSMBD_DEFAULT_GFP);
425 	if (!sess)
426 		return NULL;
427 
428 	if (ksmbd_init_file_table(&sess->file_table))
429 		goto error;
430 
431 	sess->last_active = jiffies;
432 	sess->state = SMB2_SESSION_IN_PROGRESS;
433 	set_session_flag(sess, protocol);
434 	xa_init(&sess->tree_conns);
435 	xa_init(&sess->ksmbd_chann_list);
436 	xa_init(&sess->rpc_handle_list);
437 	sess->sequence_number = 1;
438 	rwlock_init(&sess->tree_conns_lock);
439 	atomic_set(&sess->refcnt, 1);
440 
441 	ret = __init_smb2_session(sess);
442 	if (ret)
443 		goto error;
444 
445 	ida_init(&sess->tree_conn_ida);
446 
447 	down_write(&sessions_table_lock);
448 	hash_add(sessions_table, &sess->hlist, sess->id);
449 	up_write(&sessions_table_lock);
450 
451 	return sess;
452 
453 error:
454 	ksmbd_session_destroy(sess);
455 	return NULL;
456 }
457 
458 struct ksmbd_session *ksmbd_smb2_session_create(void)
459 {
460 	return __session_create(CIFDS_SESSION_FLAG_SMB2);
461 }
462 
463 int ksmbd_acquire_tree_conn_id(struct ksmbd_session *sess)
464 {
465 	int id = -EINVAL;
466 
467 	if (test_session_flag(sess, CIFDS_SESSION_FLAG_SMB2))
468 		id = ksmbd_acquire_smb2_tid(&sess->tree_conn_ida);
469 
470 	return id;
471 }
472 
473 void ksmbd_release_tree_conn_id(struct ksmbd_session *sess, int id)
474 {
475 	if (id >= 0)
476 		ksmbd_release_id(&sess->tree_conn_ida, id);
477 }
478