1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
4 */
5
6 #include <linux/jhash.h>
7 #include <linux/slab.h>
8 #include <linux/rwsem.h>
9 #include <linux/mutex.h>
10 #include <linux/wait.h>
11 #include <linux/hashtable.h>
12 #include <net/net_namespace.h>
13 #include <net/genetlink.h>
14 #include <linux/socket.h>
15 #include <linux/workqueue.h>
16 #include <linux/overflow.h>
17
18 #include "vfs_cache.h"
19 #include "transport_ipc.h"
20 #include "server.h"
21 #include "smb_common.h"
22
23 #include "mgmt/user_config.h"
24 #include "mgmt/share_config.h"
25 #include "mgmt/user_session.h"
26 #include "mgmt/tree_connect.h"
27 #include "mgmt/ksmbd_ida.h"
28 #include "connection.h"
29 #include "transport_tcp.h"
30 #include "transport_rdma.h"
31
32 #define IPC_WAIT_TIMEOUT (2 * HZ)
33
34 #define IPC_MSG_HASH_BITS 3
35 static DEFINE_HASHTABLE(ipc_msg_table, IPC_MSG_HASH_BITS);
36 static DECLARE_RWSEM(ipc_msg_table_lock);
37 static DEFINE_MUTEX(startup_lock);
38
39 static DEFINE_IDA(ipc_ida);
40
41 static unsigned int ksmbd_tools_pid;
42
ksmbd_ipc_validate_version(struct genl_info * m)43 static bool ksmbd_ipc_validate_version(struct genl_info *m)
44 {
45 if (m->genlhdr->version != KSMBD_GENL_VERSION) {
46 pr_err("%s. ksmbd: %d, kernel module: %d. %s.\n",
47 "Daemon and kernel module version mismatch",
48 m->genlhdr->version,
49 KSMBD_GENL_VERSION,
50 "User-space ksmbd should terminate");
51 return false;
52 }
53 return true;
54 }
55
56 struct ksmbd_ipc_msg {
57 unsigned int type;
58 unsigned int sz;
59 unsigned char payload[] __counted_by(sz);
60 };
61
62 struct ipc_msg_table_entry {
63 unsigned int handle;
64 unsigned int type;
65 wait_queue_head_t wait;
66 struct hlist_node ipc_table_hlist;
67
68 void *response;
69 unsigned int msg_sz;
70 };
71
72 static struct delayed_work ipc_timer_work;
73
74 static int handle_startup_event(struct sk_buff *skb, struct genl_info *info);
75 static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info);
76 static int handle_generic_event(struct sk_buff *skb, struct genl_info *info);
77 static int ksmbd_ipc_heartbeat_request(void);
78
79 static const struct nla_policy ksmbd_nl_policy[KSMBD_EVENT_MAX + 1] = {
80 [KSMBD_EVENT_UNSPEC] = {
81 .len = 0,
82 },
83 [KSMBD_EVENT_HEARTBEAT_REQUEST] = {
84 .len = sizeof(struct ksmbd_heartbeat),
85 },
86 [KSMBD_EVENT_STARTING_UP] = {
87 .len = sizeof(struct ksmbd_startup_request),
88 },
89 [KSMBD_EVENT_SHUTTING_DOWN] = {
90 .len = sizeof(struct ksmbd_shutdown_request),
91 },
92 [KSMBD_EVENT_LOGIN_REQUEST] = {
93 .len = sizeof(struct ksmbd_login_request),
94 },
95 [KSMBD_EVENT_LOGIN_RESPONSE] = {
96 .len = sizeof(struct ksmbd_login_response),
97 },
98 [KSMBD_EVENT_SHARE_CONFIG_REQUEST] = {
99 .len = sizeof(struct ksmbd_share_config_request),
100 },
101 [KSMBD_EVENT_SHARE_CONFIG_RESPONSE] = {
102 .len = sizeof(struct ksmbd_share_config_response),
103 },
104 [KSMBD_EVENT_TREE_CONNECT_REQUEST] = {
105 .len = sizeof(struct ksmbd_tree_connect_request),
106 },
107 [KSMBD_EVENT_TREE_CONNECT_RESPONSE] = {
108 .len = sizeof(struct ksmbd_tree_connect_response),
109 },
110 [KSMBD_EVENT_TREE_DISCONNECT_REQUEST] = {
111 .len = sizeof(struct ksmbd_tree_disconnect_request),
112 },
113 [KSMBD_EVENT_LOGOUT_REQUEST] = {
114 .len = sizeof(struct ksmbd_logout_request),
115 },
116 [KSMBD_EVENT_RPC_REQUEST] = {
117 },
118 [KSMBD_EVENT_RPC_RESPONSE] = {
119 },
120 [KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST] = {
121 },
122 [KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE] = {
123 },
124 [KSMBD_EVENT_LOGIN_REQUEST_EXT] = {
125 .len = sizeof(struct ksmbd_login_request),
126 },
127 [KSMBD_EVENT_LOGIN_RESPONSE_EXT] = {
128 .len = sizeof(struct ksmbd_login_response_ext),
129 },
130 };
131
132 static struct genl_ops ksmbd_genl_ops[] = {
133 {
134 .cmd = KSMBD_EVENT_UNSPEC,
135 .doit = handle_unsupported_event,
136 },
137 {
138 .cmd = KSMBD_EVENT_HEARTBEAT_REQUEST,
139 .doit = handle_unsupported_event,
140 },
141 {
142 .cmd = KSMBD_EVENT_STARTING_UP,
143 .doit = handle_startup_event,
144 },
145 {
146 .cmd = KSMBD_EVENT_SHUTTING_DOWN,
147 .doit = handle_unsupported_event,
148 },
149 {
150 .cmd = KSMBD_EVENT_LOGIN_REQUEST,
151 .doit = handle_unsupported_event,
152 },
153 {
154 .cmd = KSMBD_EVENT_LOGIN_RESPONSE,
155 .doit = handle_generic_event,
156 },
157 {
158 .cmd = KSMBD_EVENT_SHARE_CONFIG_REQUEST,
159 .doit = handle_unsupported_event,
160 },
161 {
162 .cmd = KSMBD_EVENT_SHARE_CONFIG_RESPONSE,
163 .doit = handle_generic_event,
164 },
165 {
166 .cmd = KSMBD_EVENT_TREE_CONNECT_REQUEST,
167 .doit = handle_unsupported_event,
168 },
169 {
170 .cmd = KSMBD_EVENT_TREE_CONNECT_RESPONSE,
171 .doit = handle_generic_event,
172 },
173 {
174 .cmd = KSMBD_EVENT_TREE_DISCONNECT_REQUEST,
175 .doit = handle_unsupported_event,
176 },
177 {
178 .cmd = KSMBD_EVENT_LOGOUT_REQUEST,
179 .doit = handle_unsupported_event,
180 },
181 {
182 .cmd = KSMBD_EVENT_RPC_REQUEST,
183 .doit = handle_unsupported_event,
184 },
185 {
186 .cmd = KSMBD_EVENT_RPC_RESPONSE,
187 .doit = handle_generic_event,
188 },
189 {
190 .cmd = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST,
191 .doit = handle_unsupported_event,
192 },
193 {
194 .cmd = KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE,
195 .doit = handle_generic_event,
196 },
197 {
198 .cmd = KSMBD_EVENT_LOGIN_REQUEST_EXT,
199 .doit = handle_unsupported_event,
200 },
201 {
202 .cmd = KSMBD_EVENT_LOGIN_RESPONSE_EXT,
203 .doit = handle_generic_event,
204 },
205 };
206
207 static struct genl_family ksmbd_genl_family = {
208 .name = KSMBD_GENL_NAME,
209 .version = KSMBD_GENL_VERSION,
210 .hdrsize = 0,
211 .maxattr = KSMBD_EVENT_MAX,
212 .netnsok = true,
213 .module = THIS_MODULE,
214 .ops = ksmbd_genl_ops,
215 .n_ops = ARRAY_SIZE(ksmbd_genl_ops),
216 .resv_start_op = KSMBD_EVENT_LOGIN_RESPONSE_EXT + 1,
217 };
218
ksmbd_nl_init_fixup(void)219 static void ksmbd_nl_init_fixup(void)
220 {
221 int i;
222
223 for (i = 0; i < ARRAY_SIZE(ksmbd_genl_ops); i++)
224 ksmbd_genl_ops[i].validate = GENL_DONT_VALIDATE_STRICT |
225 GENL_DONT_VALIDATE_DUMP;
226
227 ksmbd_genl_family.policy = ksmbd_nl_policy;
228 }
229
rpc_context_flags(struct ksmbd_session * sess)230 static int rpc_context_flags(struct ksmbd_session *sess)
231 {
232 if (user_guest(sess->user))
233 return KSMBD_RPC_RESTRICTED_CONTEXT;
234 return 0;
235 }
236
ipc_update_last_active(void)237 static void ipc_update_last_active(void)
238 {
239 if (server_conf.ipc_timeout)
240 server_conf.ipc_last_active = jiffies;
241 }
242
ipc_msg_alloc(size_t sz)243 static struct ksmbd_ipc_msg *ipc_msg_alloc(size_t sz)
244 {
245 struct ksmbd_ipc_msg *msg;
246
247 msg = kvzalloc_flex(*msg, payload, sz, KSMBD_DEFAULT_GFP);
248 if (msg)
249 msg->sz = sz;
250 return msg;
251 }
252
ipc_msg_free(struct ksmbd_ipc_msg * msg)253 static void ipc_msg_free(struct ksmbd_ipc_msg *msg)
254 {
255 kvfree(msg);
256 }
257
ipc_msg_handle_free(int handle)258 static void ipc_msg_handle_free(int handle)
259 {
260 if (handle >= 0)
261 ksmbd_release_id(&ipc_ida, handle);
262 }
263
handle_response(int type,void * payload,size_t sz)264 static int handle_response(int type, void *payload, size_t sz)
265 {
266 unsigned int handle;
267 struct ipc_msg_table_entry *entry;
268 int ret = 0;
269
270 /* Prevent 4-byte read beyond declared payload size */
271 if (sz < sizeof(unsigned int))
272 return -EINVAL;
273
274 handle = *(unsigned int *)payload;
275
276 ipc_update_last_active();
277 down_read(&ipc_msg_table_lock);
278 hash_for_each_possible(ipc_msg_table, entry, ipc_table_hlist, handle) {
279 if (handle != entry->handle)
280 continue;
281
282 entry->response = NULL;
283 /*
284 * Response message type value should be equal to
285 * request message type + 1.
286 */
287 if (entry->type + 1 != type) {
288 pr_err("Waiting for IPC type %d, got %d. Ignore.\n",
289 entry->type + 1, type);
290 continue;
291 }
292
293 entry->response = kvzalloc(sz, KSMBD_DEFAULT_GFP);
294 if (!entry->response) {
295 ret = -ENOMEM;
296 break;
297 }
298
299 memcpy(entry->response, payload, sz);
300 entry->msg_sz = sz;
301 wake_up_interruptible(&entry->wait);
302 ret = 0;
303 break;
304 }
305 up_read(&ipc_msg_table_lock);
306
307 return ret;
308 }
309
ipc_server_config_on_startup(struct ksmbd_startup_request * req)310 static int ipc_server_config_on_startup(struct ksmbd_startup_request *req)
311 {
312 int ret;
313
314 ksmbd_set_fd_limit(req->file_max);
315 server_conf.flags = req->flags;
316 server_conf.signing = req->signing;
317 server_conf.tcp_port = req->tcp_port;
318 server_conf.ipc_timeout = req->ipc_timeout * HZ;
319 if (check_mul_overflow(req->deadtime, SMB_ECHO_INTERVAL,
320 &server_conf.deadtime)) {
321 ret = -EINVAL;
322 goto out;
323 }
324 server_conf.share_fake_fscaps = req->share_fake_fscaps;
325
326 /* AAPL model string for Finder icon */
327 if (req->aapl_model[0])
328 strscpy(server_conf.aapl_model, req->aapl_model,
329 sizeof(server_conf.aapl_model));
330 else
331 strscpy(server_conf.aapl_model, "Xserve",
332 sizeof(server_conf.aapl_model));
333
334 ksmbd_init_domain(req->sub_auth);
335
336 if (req->smb2_max_read)
337 init_smb2_max_read_size(req->smb2_max_read);
338 if (req->smb2_max_write)
339 init_smb2_max_write_size(req->smb2_max_write);
340 if (req->smb2_max_trans)
341 init_smb2_max_trans_size(req->smb2_max_trans);
342 if (req->smb2_max_credits) {
343 init_smb2_max_credits(req->smb2_max_credits);
344 server_conf.max_inflight_req =
345 req->smb2_max_credits;
346 }
347 if (req->smbd_max_io_size)
348 init_smbd_max_io_size(req->smbd_max_io_size);
349
350 if (req->max_connections)
351 server_conf.max_connections = req->max_connections;
352
353 if (req->max_ip_connections)
354 server_conf.max_ip_connections = req->max_ip_connections;
355
356 ret = ksmbd_set_netbios_name(req->netbios_name);
357 ret |= ksmbd_set_server_string(req->server_string);
358 ret |= ksmbd_set_work_group(req->work_group);
359 server_conf.bind_interfaces_only = req->bind_interfaces_only;
360 ret |= ksmbd_tcp_set_interfaces(KSMBD_STARTUP_CONFIG_INTERFACES(req),
361 req->ifc_list_sz);
362 out:
363 if (ret) {
364 pr_err("Server configuration error: %s %s %s\n",
365 req->netbios_name, req->server_string,
366 req->work_group);
367 return ret;
368 }
369
370 if (req->min_prot[0]) {
371 ret = ksmbd_lookup_protocol_idx(req->min_prot);
372 if (ret >= 0)
373 server_conf.min_protocol = ret;
374 }
375 if (req->max_prot[0]) {
376 ret = ksmbd_lookup_protocol_idx(req->max_prot);
377 if (ret >= 0)
378 server_conf.max_protocol = ret;
379 }
380
381 if (server_conf.ipc_timeout)
382 schedule_delayed_work(&ipc_timer_work, server_conf.ipc_timeout);
383 return 0;
384 }
385
handle_startup_event(struct sk_buff * skb,struct genl_info * info)386 static int handle_startup_event(struct sk_buff *skb, struct genl_info *info)
387 {
388 int ret = 0;
389
390 #ifdef CONFIG_SMB_SERVER_CHECK_CAP_NET_ADMIN
391 if (!netlink_capable(skb, CAP_NET_ADMIN))
392 return -EPERM;
393 #endif
394
395 if (!ksmbd_ipc_validate_version(info))
396 return -EINVAL;
397
398 if (!info->attrs[KSMBD_EVENT_STARTING_UP])
399 return -EINVAL;
400
401 mutex_lock(&startup_lock);
402 if (!ksmbd_server_configurable()) {
403 mutex_unlock(&startup_lock);
404 pr_err("Server reset is in progress, can't start daemon\n");
405 return -EINVAL;
406 }
407
408 if (ksmbd_tools_pid) {
409 if (ksmbd_ipc_heartbeat_request() == 0) {
410 ret = -EINVAL;
411 goto out;
412 }
413
414 pr_err("Reconnect to a new user space daemon\n");
415 } else {
416 struct ksmbd_startup_request *req;
417
418 req = nla_data(info->attrs[info->genlhdr->cmd]);
419 ret = ipc_server_config_on_startup(req);
420 if (ret)
421 goto out;
422 server_queue_ctrl_init_work();
423 }
424
425 ksmbd_tools_pid = info->snd_portid;
426 ipc_update_last_active();
427
428 out:
429 mutex_unlock(&startup_lock);
430 return ret;
431 }
432
handle_unsupported_event(struct sk_buff * skb,struct genl_info * info)433 static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info)
434 {
435 pr_err("Unknown IPC event: %d, ignore.\n", info->genlhdr->cmd);
436 return -EINVAL;
437 }
438
handle_generic_event(struct sk_buff * skb,struct genl_info * info)439 static int handle_generic_event(struct sk_buff *skb, struct genl_info *info)
440 {
441 void *payload;
442 int sz;
443 int type = info->genlhdr->cmd;
444
445 #ifdef CONFIG_SMB_SERVER_CHECK_CAP_NET_ADMIN
446 if (!netlink_capable(skb, CAP_NET_ADMIN))
447 return -EPERM;
448 #endif
449
450 if (type > KSMBD_EVENT_MAX) {
451 WARN_ON(1);
452 return -EINVAL;
453 }
454
455 if (!ksmbd_ipc_validate_version(info))
456 return -EINVAL;
457
458 if (!info->attrs[type])
459 return -EINVAL;
460
461 payload = nla_data(info->attrs[info->genlhdr->cmd]);
462 sz = nla_len(info->attrs[info->genlhdr->cmd]);
463 return handle_response(type, payload, sz);
464 }
465
ipc_msg_send(struct ksmbd_ipc_msg * msg)466 static int ipc_msg_send(struct ksmbd_ipc_msg *msg)
467 {
468 struct genlmsghdr *nlh;
469 struct sk_buff *skb;
470 int ret = -EINVAL;
471
472 if (!ksmbd_tools_pid)
473 return ret;
474
475 skb = genlmsg_new(msg->sz, KSMBD_DEFAULT_GFP);
476 if (!skb)
477 return -ENOMEM;
478
479 nlh = genlmsg_put(skb, 0, 0, &ksmbd_genl_family, 0, msg->type);
480 if (!nlh)
481 goto out;
482
483 ret = nla_put(skb, msg->type, msg->sz, msg->payload);
484 if (ret) {
485 genlmsg_cancel(skb, nlh);
486 goto out;
487 }
488
489 genlmsg_end(skb, nlh);
490 ret = genlmsg_unicast(&init_net, skb, ksmbd_tools_pid);
491 if (!ret)
492 ipc_update_last_active();
493 return ret;
494
495 out:
496 nlmsg_free(skb);
497 return ret;
498 }
499
ipc_validate_msg(struct ipc_msg_table_entry * entry)500 static int ipc_validate_msg(struct ipc_msg_table_entry *entry)
501 {
502 unsigned int msg_sz = entry->msg_sz;
503
504 switch (entry->type) {
505 case KSMBD_EVENT_RPC_REQUEST:
506 {
507 struct ksmbd_rpc_command *resp = entry->response;
508
509 if (entry->msg_sz < sizeof(struct ksmbd_rpc_command))
510 return -EINVAL;
511
512 if (check_add_overflow(sizeof(struct ksmbd_rpc_command),
513 resp->payload_sz, &msg_sz))
514 return -EINVAL;
515 break;
516 }
517 case KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST:
518 {
519 struct ksmbd_spnego_authen_response *resp = entry->response;
520
521 if (entry->msg_sz < sizeof(struct ksmbd_spnego_authen_response))
522 return -EINVAL;
523
524 msg_sz = sizeof(struct ksmbd_spnego_authen_response) +
525 resp->session_key_len + resp->spnego_blob_len;
526 break;
527 }
528 case KSMBD_EVENT_SHARE_CONFIG_REQUEST:
529 {
530 struct ksmbd_share_config_response *resp = entry->response;
531
532 if (entry->msg_sz < sizeof(struct ksmbd_share_config_response))
533 return -EINVAL;
534
535 if (strnlen(resp->share_name, sizeof(resp->share_name)) ==
536 sizeof(resp->share_name))
537 return -EINVAL;
538
539 if (resp->veto_list_sz > resp->payload_sz)
540 return -EINVAL;
541
542 if (resp->flags != KSMBD_SHARE_FLAG_INVALID &&
543 !(resp->flags & KSMBD_SHARE_FLAG_PIPE) &&
544 resp->payload_sz <= resp->veto_list_sz)
545 return -EINVAL;
546
547 if (check_add_overflow(sizeof(struct ksmbd_share_config_response),
548 resp->payload_sz, &msg_sz))
549 return -EINVAL;
550 break;
551 }
552 case KSMBD_EVENT_LOGIN_REQUEST_EXT:
553 {
554 struct ksmbd_login_response_ext *resp = entry->response;
555
556 if (entry->msg_sz < sizeof(struct ksmbd_login_response_ext))
557 return -EINVAL;
558
559 if (resp->ngroups) {
560 if (resp->ngroups < 0 ||
561 resp->ngroups > NGROUPS_MAX) {
562 pr_err("ngroups(%d) from login response exceeds max groups(%d)\n",
563 resp->ngroups, NGROUPS_MAX);
564 return -EINVAL;
565 }
566 msg_sz = sizeof(struct ksmbd_login_response_ext) +
567 resp->ngroups * sizeof(gid_t);
568 }
569 }
570 }
571
572 return entry->msg_sz != msg_sz ? -EINVAL : 0;
573 }
574
ipc_msg_send_request(struct ksmbd_ipc_msg * msg,unsigned int handle)575 static void *ipc_msg_send_request(struct ksmbd_ipc_msg *msg, unsigned int handle)
576 {
577 struct ipc_msg_table_entry entry;
578 int ret;
579
580 if ((int)handle < 0)
581 return NULL;
582
583 entry.type = msg->type;
584 entry.response = NULL;
585 init_waitqueue_head(&entry.wait);
586
587 down_write(&ipc_msg_table_lock);
588 entry.handle = handle;
589 hash_add(ipc_msg_table, &entry.ipc_table_hlist, entry.handle);
590 up_write(&ipc_msg_table_lock);
591
592 ret = ipc_msg_send(msg);
593 if (ret) {
594 down_write(&ipc_msg_table_lock);
595 goto out;
596 }
597
598 ret = wait_event_interruptible_timeout(entry.wait,
599 entry.response != NULL,
600 IPC_WAIT_TIMEOUT);
601
602 down_write(&ipc_msg_table_lock);
603 if (entry.response) {
604 ret = ipc_validate_msg(&entry);
605 if (ret) {
606 kvfree(entry.response);
607 entry.response = NULL;
608 }
609 }
610 out:
611 hash_del(&entry.ipc_table_hlist);
612 up_write(&ipc_msg_table_lock);
613 return entry.response;
614 }
615
ksmbd_ipc_heartbeat_request(void)616 static int ksmbd_ipc_heartbeat_request(void)
617 {
618 struct ksmbd_ipc_msg *msg;
619 int ret;
620
621 msg = ipc_msg_alloc(sizeof(struct ksmbd_heartbeat));
622 if (!msg)
623 return -EINVAL;
624
625 msg->type = KSMBD_EVENT_HEARTBEAT_REQUEST;
626 ret = ipc_msg_send(msg);
627 ipc_msg_free(msg);
628 return ret;
629 }
630
ksmbd_ipc_login_request(const char * account)631 struct ksmbd_login_response *ksmbd_ipc_login_request(const char *account)
632 {
633 struct ksmbd_ipc_msg *msg;
634 struct ksmbd_login_request *req;
635 struct ksmbd_login_response *resp;
636
637 if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
638 return NULL;
639
640 msg = ipc_msg_alloc(sizeof(struct ksmbd_login_request));
641 if (!msg)
642 return NULL;
643
644 msg->type = KSMBD_EVENT_LOGIN_REQUEST;
645 req = (struct ksmbd_login_request *)msg->payload;
646 req->handle = ksmbd_acquire_id(&ipc_ida);
647 strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
648
649 resp = ipc_msg_send_request(msg, req->handle);
650 ipc_msg_handle_free(req->handle);
651 ipc_msg_free(msg);
652 return resp;
653 }
654
ksmbd_ipc_login_request_ext(const char * account)655 struct ksmbd_login_response_ext *ksmbd_ipc_login_request_ext(const char *account)
656 {
657 struct ksmbd_ipc_msg *msg;
658 struct ksmbd_login_request *req;
659 struct ksmbd_login_response_ext *resp;
660
661 if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
662 return NULL;
663
664 msg = ipc_msg_alloc(sizeof(struct ksmbd_login_request));
665 if (!msg)
666 return NULL;
667
668 msg->type = KSMBD_EVENT_LOGIN_REQUEST_EXT;
669 req = (struct ksmbd_login_request *)msg->payload;
670 req->handle = ksmbd_acquire_id(&ipc_ida);
671 strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
672 resp = ipc_msg_send_request(msg, req->handle);
673 ipc_msg_handle_free(req->handle);
674 ipc_msg_free(msg);
675 return resp;
676 }
677
678 struct ksmbd_spnego_authen_response *
ksmbd_ipc_spnego_authen_request(const char * spnego_blob,int blob_len)679 ksmbd_ipc_spnego_authen_request(const char *spnego_blob, int blob_len)
680 {
681 struct ksmbd_ipc_msg *msg;
682 struct ksmbd_spnego_authen_request *req;
683 struct ksmbd_spnego_authen_response *resp;
684
685 if (blob_len > KSMBD_IPC_MAX_PAYLOAD)
686 return NULL;
687
688 msg = ipc_msg_alloc(sizeof(struct ksmbd_spnego_authen_request) +
689 blob_len);
690 if (!msg)
691 return NULL;
692
693 msg->type = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST;
694 req = (struct ksmbd_spnego_authen_request *)msg->payload;
695 req->handle = ksmbd_acquire_id(&ipc_ida);
696 req->spnego_blob_len = blob_len;
697 memcpy(req->spnego_blob, spnego_blob, blob_len);
698
699 resp = ipc_msg_send_request(msg, req->handle);
700 ipc_msg_handle_free(req->handle);
701 ipc_msg_free(msg);
702 return resp;
703 }
704
705 struct ksmbd_tree_connect_response *
ksmbd_ipc_tree_connect_request(struct ksmbd_session * sess,struct ksmbd_share_config * share,struct ksmbd_tree_connect * tree_conn,struct sockaddr * peer_addr)706 ksmbd_ipc_tree_connect_request(struct ksmbd_session *sess,
707 struct ksmbd_share_config *share,
708 struct ksmbd_tree_connect *tree_conn,
709 struct sockaddr *peer_addr)
710 {
711 struct ksmbd_ipc_msg *msg;
712 struct ksmbd_tree_connect_request *req;
713 struct ksmbd_tree_connect_response *resp;
714
715 if (strlen(user_name(sess->user)) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
716 return NULL;
717
718 if (strlen(share->name) >= KSMBD_REQ_MAX_SHARE_NAME)
719 return NULL;
720
721 msg = ipc_msg_alloc(sizeof(struct ksmbd_tree_connect_request));
722 if (!msg)
723 return NULL;
724
725 msg->type = KSMBD_EVENT_TREE_CONNECT_REQUEST;
726 req = (struct ksmbd_tree_connect_request *)msg->payload;
727
728 req->handle = ksmbd_acquire_id(&ipc_ida);
729 req->account_flags = sess->user->flags;
730 req->session_id = sess->id;
731 req->connect_id = tree_conn->id;
732 strscpy(req->account, user_name(sess->user), KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
733 strscpy(req->share, share->name, KSMBD_REQ_MAX_SHARE_NAME);
734 snprintf(req->peer_addr, sizeof(req->peer_addr), "%pIS", peer_addr);
735
736 if (peer_addr->sa_family == AF_INET6)
737 req->flags |= KSMBD_TREE_CONN_FLAG_REQUEST_IPV6;
738 if (test_session_flag(sess, CIFDS_SESSION_FLAG_SMB2))
739 req->flags |= KSMBD_TREE_CONN_FLAG_REQUEST_SMB2;
740
741 resp = ipc_msg_send_request(msg, req->handle);
742 ipc_msg_handle_free(req->handle);
743 ipc_msg_free(msg);
744 return resp;
745 }
746
ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,unsigned long long connect_id)747 int ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,
748 unsigned long long connect_id)
749 {
750 struct ksmbd_ipc_msg *msg;
751 struct ksmbd_tree_disconnect_request *req;
752 int ret;
753
754 msg = ipc_msg_alloc(sizeof(struct ksmbd_tree_disconnect_request));
755 if (!msg)
756 return -ENOMEM;
757
758 msg->type = KSMBD_EVENT_TREE_DISCONNECT_REQUEST;
759 req = (struct ksmbd_tree_disconnect_request *)msg->payload;
760 req->session_id = session_id;
761 req->connect_id = connect_id;
762
763 ret = ipc_msg_send(msg);
764 ipc_msg_free(msg);
765 return ret;
766 }
767
ksmbd_ipc_logout_request(const char * account,int flags)768 int ksmbd_ipc_logout_request(const char *account, int flags)
769 {
770 struct ksmbd_ipc_msg *msg;
771 struct ksmbd_logout_request *req;
772 int ret;
773
774 if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
775 return -EINVAL;
776
777 msg = ipc_msg_alloc(sizeof(struct ksmbd_logout_request));
778 if (!msg)
779 return -ENOMEM;
780
781 msg->type = KSMBD_EVENT_LOGOUT_REQUEST;
782 req = (struct ksmbd_logout_request *)msg->payload;
783 req->account_flags = flags;
784 strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
785
786 ret = ipc_msg_send(msg);
787 ipc_msg_free(msg);
788 return ret;
789 }
790
791 struct ksmbd_share_config_response *
ksmbd_ipc_share_config_request(const char * name)792 ksmbd_ipc_share_config_request(const char *name)
793 {
794 struct ksmbd_ipc_msg *msg;
795 struct ksmbd_share_config_request *req;
796 struct ksmbd_share_config_response *resp;
797
798 if (strlen(name) >= KSMBD_REQ_MAX_SHARE_NAME)
799 return NULL;
800
801 msg = ipc_msg_alloc(sizeof(struct ksmbd_share_config_request));
802 if (!msg)
803 return NULL;
804
805 msg->type = KSMBD_EVENT_SHARE_CONFIG_REQUEST;
806 req = (struct ksmbd_share_config_request *)msg->payload;
807 req->handle = ksmbd_acquire_id(&ipc_ida);
808 strscpy(req->share_name, name, KSMBD_REQ_MAX_SHARE_NAME);
809
810 resp = ipc_msg_send_request(msg, req->handle);
811 ipc_msg_handle_free(req->handle);
812 ipc_msg_free(msg);
813 return resp;
814 }
815
ksmbd_rpc_open(struct ksmbd_session * sess,int handle)816 struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess, int handle)
817 {
818 struct ksmbd_ipc_msg *msg;
819 struct ksmbd_rpc_command *req;
820 struct ksmbd_rpc_command *resp;
821
822 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
823 if (!msg)
824 return NULL;
825
826 msg->type = KSMBD_EVENT_RPC_REQUEST;
827 req = (struct ksmbd_rpc_command *)msg->payload;
828 req->handle = handle;
829 req->flags = ksmbd_session_rpc_method(sess, handle);
830 req->flags |= KSMBD_RPC_OPEN_METHOD;
831 req->payload_sz = 0;
832
833 resp = ipc_msg_send_request(msg, req->handle);
834 ipc_msg_free(msg);
835 return resp;
836 }
837
ksmbd_rpc_close(struct ksmbd_session * sess,int handle)838 struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess, int handle)
839 {
840 struct ksmbd_ipc_msg *msg;
841 struct ksmbd_rpc_command *req;
842 struct ksmbd_rpc_command *resp;
843
844 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
845 if (!msg)
846 return NULL;
847
848 msg->type = KSMBD_EVENT_RPC_REQUEST;
849 req = (struct ksmbd_rpc_command *)msg->payload;
850 req->handle = handle;
851 req->flags = ksmbd_session_rpc_method(sess, handle);
852 req->flags |= KSMBD_RPC_CLOSE_METHOD;
853 req->payload_sz = 0;
854
855 resp = ipc_msg_send_request(msg, req->handle);
856 ipc_msg_free(msg);
857 return resp;
858 }
859
ksmbd_rpc_write(struct ksmbd_session * sess,int handle,void * payload,size_t payload_sz)860 struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess, int handle,
861 void *payload, size_t payload_sz)
862 {
863 struct ksmbd_ipc_msg *msg;
864 struct ksmbd_rpc_command *req;
865 struct ksmbd_rpc_command *resp;
866
867 if (payload_sz > KSMBD_IPC_MAX_PAYLOAD)
868 return NULL;
869
870 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz);
871 if (!msg)
872 return NULL;
873
874 lockdep_assert_not_held(&sess->rpc_lock);
875
876 down_read(&sess->rpc_lock);
877 msg->type = KSMBD_EVENT_RPC_REQUEST;
878 req = (struct ksmbd_rpc_command *)msg->payload;
879 req->handle = handle;
880 req->flags = ksmbd_session_rpc_method(sess, handle);
881 req->flags |= rpc_context_flags(sess);
882 req->flags |= KSMBD_RPC_WRITE_METHOD;
883 req->payload_sz = payload_sz;
884 memcpy(req->payload, payload, payload_sz);
885 up_read(&sess->rpc_lock);
886
887 resp = ipc_msg_send_request(msg, req->handle);
888 ipc_msg_free(msg);
889 return resp;
890 }
891
ksmbd_rpc_read(struct ksmbd_session * sess,int handle)892 struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess, int handle)
893 {
894 struct ksmbd_ipc_msg *msg;
895 struct ksmbd_rpc_command *req;
896 struct ksmbd_rpc_command *resp;
897
898 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
899 if (!msg)
900 return NULL;
901
902 lockdep_assert_not_held(&sess->rpc_lock);
903
904 down_read(&sess->rpc_lock);
905 msg->type = KSMBD_EVENT_RPC_REQUEST;
906 req = (struct ksmbd_rpc_command *)msg->payload;
907 req->handle = handle;
908 req->flags = ksmbd_session_rpc_method(sess, handle);
909 req->flags |= rpc_context_flags(sess);
910 req->flags |= KSMBD_RPC_READ_METHOD;
911 req->payload_sz = 0;
912 up_read(&sess->rpc_lock);
913
914 resp = ipc_msg_send_request(msg, req->handle);
915 ipc_msg_free(msg);
916 return resp;
917 }
918
ksmbd_rpc_ioctl(struct ksmbd_session * sess,int handle,void * payload,size_t payload_sz)919 struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess, int handle,
920 void *payload, size_t payload_sz)
921 {
922 struct ksmbd_ipc_msg *msg;
923 struct ksmbd_rpc_command *req;
924 struct ksmbd_rpc_command *resp;
925
926 if (payload_sz > KSMBD_IPC_MAX_PAYLOAD)
927 return NULL;
928
929 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz);
930 if (!msg)
931 return NULL;
932
933 lockdep_assert_not_held(&sess->rpc_lock);
934
935 down_read(&sess->rpc_lock);
936 msg->type = KSMBD_EVENT_RPC_REQUEST;
937 req = (struct ksmbd_rpc_command *)msg->payload;
938 req->handle = handle;
939 req->flags = ksmbd_session_rpc_method(sess, handle);
940 req->flags |= rpc_context_flags(sess);
941 req->flags |= KSMBD_RPC_IOCTL_METHOD;
942 req->payload_sz = payload_sz;
943 memcpy(req->payload, payload, payload_sz);
944 up_read(&sess->rpc_lock);
945
946 resp = ipc_msg_send_request(msg, req->handle);
947 ipc_msg_free(msg);
948 return resp;
949 }
950
__ipc_heartbeat(void)951 static int __ipc_heartbeat(void)
952 {
953 unsigned long delta;
954
955 if (!ksmbd_server_running())
956 return 0;
957
958 if (time_after(jiffies, server_conf.ipc_last_active)) {
959 delta = (jiffies - server_conf.ipc_last_active);
960 } else {
961 ipc_update_last_active();
962 schedule_delayed_work(&ipc_timer_work,
963 server_conf.ipc_timeout);
964 return 0;
965 }
966
967 if (delta < server_conf.ipc_timeout) {
968 schedule_delayed_work(&ipc_timer_work,
969 server_conf.ipc_timeout - delta);
970 return 0;
971 }
972
973 if (ksmbd_ipc_heartbeat_request() == 0) {
974 schedule_delayed_work(&ipc_timer_work,
975 server_conf.ipc_timeout);
976 return 0;
977 }
978
979 mutex_lock(&startup_lock);
980 WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
981 server_conf.ipc_last_active = 0;
982 ksmbd_tools_pid = 0;
983 pr_err("No IPC daemon response for %lus\n", delta / HZ);
984 mutex_unlock(&startup_lock);
985 return -EINVAL;
986 }
987
ipc_timer_heartbeat(struct work_struct * w)988 static void ipc_timer_heartbeat(struct work_struct *w)
989 {
990 if (__ipc_heartbeat())
991 server_queue_ctrl_reset_work();
992 }
993
ksmbd_ipc_id_alloc(void)994 int ksmbd_ipc_id_alloc(void)
995 {
996 return ksmbd_acquire_id(&ipc_ida);
997 }
998
ksmbd_rpc_id_free(int handle)999 void ksmbd_rpc_id_free(int handle)
1000 {
1001 ksmbd_release_id(&ipc_ida, handle);
1002 }
1003
ksmbd_ipc_release(void)1004 void ksmbd_ipc_release(void)
1005 {
1006 cancel_delayed_work_sync(&ipc_timer_work);
1007 genl_unregister_family(&ksmbd_genl_family);
1008 }
1009
ksmbd_ipc_soft_reset(void)1010 void ksmbd_ipc_soft_reset(void)
1011 {
1012 mutex_lock(&startup_lock);
1013 ksmbd_tools_pid = 0;
1014 cancel_delayed_work_sync(&ipc_timer_work);
1015 mutex_unlock(&startup_lock);
1016 }
1017
ksmbd_ipc_init(void)1018 int ksmbd_ipc_init(void)
1019 {
1020 int ret = 0;
1021
1022 ksmbd_nl_init_fixup();
1023 INIT_DELAYED_WORK(&ipc_timer_work, ipc_timer_heartbeat);
1024
1025 ret = genl_register_family(&ksmbd_genl_family);
1026 if (ret) {
1027 pr_err("Failed to register KSMBD netlink interface %d\n", ret);
1028 cancel_delayed_work_sync(&ipc_timer_work);
1029 }
1030
1031 return ret;
1032 }
1033