xref: /openbmc/linux/fs/smb/server/mgmt/user_session.c (revision 7190d0ff)
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;
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), GFP_KERNEL);
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 	xa_store(&sess->rpc_handle_list, entry->id, entry, GFP_KERNEL);
110 
111 	resp = ksmbd_rpc_open(sess, entry->id);
112 	if (!resp)
113 		goto free_id;
114 
115 	kvfree(resp);
116 	return entry->id;
117 free_id:
118 	xa_erase(&sess->rpc_handle_list, entry->id);
119 	ksmbd_rpc_id_free(entry->id);
120 free_entry:
121 	kfree(entry);
122 	return -EINVAL;
123 }
124 
125 void ksmbd_session_rpc_close(struct ksmbd_session *sess, int id)
126 {
127 	struct ksmbd_session_rpc *entry;
128 
129 	entry = xa_erase(&sess->rpc_handle_list, id);
130 	if (entry)
131 		__session_rpc_close(sess, entry);
132 }
133 
134 int ksmbd_session_rpc_method(struct ksmbd_session *sess, int id)
135 {
136 	struct ksmbd_session_rpc *entry;
137 
138 	entry = xa_load(&sess->rpc_handle_list, id);
139 	return entry ? entry->method : 0;
140 }
141 
142 void ksmbd_session_destroy(struct ksmbd_session *sess)
143 {
144 	if (!sess)
145 		return;
146 
147 	if (sess->user)
148 		ksmbd_free_user(sess->user);
149 
150 	ksmbd_tree_conn_session_logoff(sess);
151 	ksmbd_destroy_file_table(&sess->file_table);
152 	ksmbd_session_rpc_clear_list(sess);
153 	free_channel_list(sess);
154 	kfree(sess->Preauth_HashValue);
155 	ksmbd_release_id(&session_ida, sess->id);
156 	kfree(sess);
157 }
158 
159 static struct ksmbd_session *__session_lookup(unsigned long long id)
160 {
161 	struct ksmbd_session *sess;
162 
163 	hash_for_each_possible(sessions_table, sess, hlist, id) {
164 		if (id == sess->id) {
165 			sess->last_active = jiffies;
166 			return sess;
167 		}
168 	}
169 	return NULL;
170 }
171 
172 static void ksmbd_expire_session(struct ksmbd_conn *conn)
173 {
174 	unsigned long id;
175 	struct ksmbd_session *sess;
176 
177 	down_write(&sessions_table_lock);
178 	xa_for_each(&conn->sessions, id, sess) {
179 		if (sess->state != SMB2_SESSION_VALID ||
180 		    time_after(jiffies,
181 			       sess->last_active + SMB2_SESSION_TIMEOUT)) {
182 			xa_erase(&conn->sessions, sess->id);
183 			hash_del(&sess->hlist);
184 			ksmbd_session_destroy(sess);
185 			continue;
186 		}
187 	}
188 	up_write(&sessions_table_lock);
189 }
190 
191 int ksmbd_session_register(struct ksmbd_conn *conn,
192 			   struct ksmbd_session *sess)
193 {
194 	sess->dialect = conn->dialect;
195 	memcpy(sess->ClientGUID, conn->ClientGUID, SMB2_CLIENT_GUID_SIZE);
196 	ksmbd_expire_session(conn);
197 	return xa_err(xa_store(&conn->sessions, sess->id, sess, GFP_KERNEL));
198 }
199 
200 static int ksmbd_chann_del(struct ksmbd_conn *conn, struct ksmbd_session *sess)
201 {
202 	struct channel *chann;
203 
204 	chann = xa_erase(&sess->ksmbd_chann_list, (long)conn);
205 	if (!chann)
206 		return -ENOENT;
207 
208 	kfree(chann);
209 	return 0;
210 }
211 
212 void ksmbd_sessions_deregister(struct ksmbd_conn *conn)
213 {
214 	struct ksmbd_session *sess;
215 	unsigned long id;
216 
217 	down_write(&sessions_table_lock);
218 	if (conn->binding) {
219 		int bkt;
220 		struct hlist_node *tmp;
221 
222 		hash_for_each_safe(sessions_table, bkt, tmp, sess, hlist) {
223 			if (!ksmbd_chann_del(conn, sess) &&
224 			    xa_empty(&sess->ksmbd_chann_list)) {
225 				hash_del(&sess->hlist);
226 				ksmbd_session_destroy(sess);
227 			}
228 		}
229 	}
230 
231 	xa_for_each(&conn->sessions, id, sess) {
232 		unsigned long chann_id;
233 		struct channel *chann;
234 
235 		xa_for_each(&sess->ksmbd_chann_list, chann_id, chann) {
236 			if (chann->conn != conn)
237 				ksmbd_conn_set_exiting(chann->conn);
238 		}
239 
240 		ksmbd_chann_del(conn, sess);
241 		if (xa_empty(&sess->ksmbd_chann_list)) {
242 			xa_erase(&conn->sessions, sess->id);
243 			hash_del(&sess->hlist);
244 			ksmbd_session_destroy(sess);
245 		}
246 	}
247 	up_write(&sessions_table_lock);
248 }
249 
250 struct ksmbd_session *ksmbd_session_lookup(struct ksmbd_conn *conn,
251 					   unsigned long long id)
252 {
253 	struct ksmbd_session *sess;
254 
255 	sess = xa_load(&conn->sessions, id);
256 	if (sess)
257 		sess->last_active = jiffies;
258 	return sess;
259 }
260 
261 struct ksmbd_session *ksmbd_session_lookup_slowpath(unsigned long long id)
262 {
263 	struct ksmbd_session *sess;
264 
265 	down_read(&sessions_table_lock);
266 	sess = __session_lookup(id);
267 	if (sess)
268 		sess->last_active = jiffies;
269 	up_read(&sessions_table_lock);
270 
271 	return sess;
272 }
273 
274 struct ksmbd_session *ksmbd_session_lookup_all(struct ksmbd_conn *conn,
275 					       unsigned long long id)
276 {
277 	struct ksmbd_session *sess;
278 
279 	sess = ksmbd_session_lookup(conn, id);
280 	if (!sess && conn->binding)
281 		sess = ksmbd_session_lookup_slowpath(id);
282 	if (sess && sess->state != SMB2_SESSION_VALID)
283 		sess = NULL;
284 	return sess;
285 }
286 
287 struct preauth_session *ksmbd_preauth_session_alloc(struct ksmbd_conn *conn,
288 						    u64 sess_id)
289 {
290 	struct preauth_session *sess;
291 
292 	sess = kmalloc(sizeof(struct preauth_session), GFP_KERNEL);
293 	if (!sess)
294 		return NULL;
295 
296 	sess->id = sess_id;
297 	memcpy(sess->Preauth_HashValue, conn->preauth_info->Preauth_HashValue,
298 	       PREAUTH_HASHVALUE_SIZE);
299 	list_add(&sess->preauth_entry, &conn->preauth_sess_table);
300 
301 	return sess;
302 }
303 
304 static bool ksmbd_preauth_session_id_match(struct preauth_session *sess,
305 					   unsigned long long id)
306 {
307 	return sess->id == id;
308 }
309 
310 struct preauth_session *ksmbd_preauth_session_lookup(struct ksmbd_conn *conn,
311 						     unsigned long long id)
312 {
313 	struct preauth_session *sess = NULL;
314 
315 	list_for_each_entry(sess, &conn->preauth_sess_table, preauth_entry) {
316 		if (ksmbd_preauth_session_id_match(sess, id))
317 			return sess;
318 	}
319 	return NULL;
320 }
321 
322 static int __init_smb2_session(struct ksmbd_session *sess)
323 {
324 	int id = ksmbd_acquire_smb2_uid(&session_ida);
325 
326 	if (id < 0)
327 		return -EINVAL;
328 	sess->id = id;
329 	return 0;
330 }
331 
332 static struct ksmbd_session *__session_create(int protocol)
333 {
334 	struct ksmbd_session *sess;
335 	int ret;
336 
337 	if (protocol != CIFDS_SESSION_FLAG_SMB2)
338 		return NULL;
339 
340 	sess = kzalloc(sizeof(struct ksmbd_session), GFP_KERNEL);
341 	if (!sess)
342 		return NULL;
343 
344 	if (ksmbd_init_file_table(&sess->file_table))
345 		goto error;
346 
347 	sess->last_active = jiffies;
348 	sess->state = SMB2_SESSION_IN_PROGRESS;
349 	set_session_flag(sess, protocol);
350 	xa_init(&sess->tree_conns);
351 	xa_init(&sess->ksmbd_chann_list);
352 	xa_init(&sess->rpc_handle_list);
353 	sess->sequence_number = 1;
354 
355 	ret = __init_smb2_session(sess);
356 	if (ret)
357 		goto error;
358 
359 	ida_init(&sess->tree_conn_ida);
360 
361 	down_write(&sessions_table_lock);
362 	hash_add(sessions_table, &sess->hlist, sess->id);
363 	up_write(&sessions_table_lock);
364 
365 	return sess;
366 
367 error:
368 	ksmbd_session_destroy(sess);
369 	return NULL;
370 }
371 
372 struct ksmbd_session *ksmbd_smb2_session_create(void)
373 {
374 	return __session_create(CIFDS_SESSION_FLAG_SMB2);
375 }
376 
377 int ksmbd_acquire_tree_conn_id(struct ksmbd_session *sess)
378 {
379 	int id = -EINVAL;
380 
381 	if (test_session_flag(sess, CIFDS_SESSION_FLAG_SMB2))
382 		id = ksmbd_acquire_smb2_tid(&sess->tree_conn_ida);
383 
384 	return id;
385 }
386 
387 void ksmbd_release_tree_conn_id(struct ksmbd_session *sess, int id)
388 {
389 	if (id >= 0)
390 		ksmbd_release_id(&sess->tree_conn_ida, id);
391 }
392