1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
4 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
5 */
6
7 #include <linux/freezer.h>
8
9 #include "smb_common.h"
10 #include "server.h"
11 #include "auth.h"
12 #include "connection.h"
13 #include "transport_tcp.h"
14
15 #define IFACE_STATE_DOWN BIT(0)
16 #define IFACE_STATE_CONFIGURED BIT(1)
17
18 static atomic_t active_num_conn;
19
20 struct interface {
21 struct task_struct *ksmbd_kthread;
22 struct socket *ksmbd_socket;
23 struct list_head entry;
24 char *name;
25 int state;
26 };
27
28 static LIST_HEAD(iface_list);
29
30 static int bind_additional_ifaces;
31
32 struct tcp_transport {
33 struct ksmbd_transport transport;
34 struct socket *sock;
35 struct kvec *iov;
36 unsigned int nr_iov;
37 };
38
39 static const struct ksmbd_transport_ops ksmbd_tcp_transport_ops;
40
41 static void tcp_stop_kthread(struct task_struct *kthread);
42 static void ksmbd_tcp_stop_listener(struct interface *iface);
43 static struct interface *alloc_iface(char *ifname);
44 static void ksmbd_tcp_disconnect(struct ksmbd_transport *t);
45
46 #define KSMBD_TRANS(t) (&(t)->transport)
47 #define TCP_TRANS(t) ((struct tcp_transport *)container_of(t, \
48 struct tcp_transport, transport))
49
ksmbd_tcp_nodelay(struct socket * sock)50 static inline void ksmbd_tcp_nodelay(struct socket *sock)
51 {
52 tcp_sock_set_nodelay(sock->sk);
53 }
54
ksmbd_tcp_reuseaddr(struct socket * sock)55 static inline void ksmbd_tcp_reuseaddr(struct socket *sock)
56 {
57 sock_set_reuseaddr(sock->sk);
58 }
59
alloc_transport(struct socket * client_sk)60 static struct tcp_transport *alloc_transport(struct socket *client_sk)
61 {
62 struct tcp_transport *t;
63 struct ksmbd_conn *conn;
64
65 t = kzalloc_obj(*t, KSMBD_DEFAULT_GFP);
66 if (!t)
67 return NULL;
68 t->sock = client_sk;
69
70 conn = ksmbd_conn_alloc();
71 if (!conn) {
72 kfree(t);
73 return NULL;
74 }
75
76 #if IS_ENABLED(CONFIG_IPV6)
77 if (client_sk->sk->sk_family == AF_INET6) {
78 memcpy(&conn->inet6_addr, &client_sk->sk->sk_v6_daddr, 16);
79 conn->inet_hash = ipv6_addr_hash(&client_sk->sk->sk_v6_daddr);
80 } else {
81 conn->inet_addr = inet_sk(client_sk->sk)->inet_daddr;
82 conn->inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
83 }
84 #else
85 conn->inet_addr = inet_sk(client_sk->sk)->inet_daddr;
86 conn->inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
87 #endif
88 down_write(&conn_list_lock);
89 hash_add(conn_list, &conn->hlist, conn->inet_hash);
90 up_write(&conn_list_lock);
91
92 conn->transport = KSMBD_TRANS(t);
93 KSMBD_TRANS(t)->conn = conn;
94 KSMBD_TRANS(t)->ops = &ksmbd_tcp_transport_ops;
95 return t;
96 }
97
ksmbd_tcp_free_transport(struct ksmbd_transport * kt)98 static void ksmbd_tcp_free_transport(struct ksmbd_transport *kt)
99 {
100 struct tcp_transport *t = TCP_TRANS(kt);
101
102 sock_release(t->sock);
103 kfree(t->iov);
104 kfree(t);
105 }
106
free_transport(struct tcp_transport * t)107 static void free_transport(struct tcp_transport *t)
108 {
109 kernel_sock_shutdown(t->sock, SHUT_RDWR);
110 ksmbd_conn_free(KSMBD_TRANS(t)->conn);
111 }
112
113 /**
114 * kvec_array_init() - initialize a IO vector segment
115 * @new: IO vector to be initialized
116 * @iov: base IO vector
117 * @nr_segs: number of segments in base iov
118 * @bytes: total iovec length so far for read
119 *
120 * Return: Number of IO segments
121 */
kvec_array_init(struct kvec * new,struct kvec * iov,unsigned int nr_segs,size_t bytes)122 static unsigned int kvec_array_init(struct kvec *new, struct kvec *iov,
123 unsigned int nr_segs, size_t bytes)
124 {
125 size_t base = 0;
126
127 while (bytes || !iov->iov_len) {
128 int copy = min(bytes, iov->iov_len);
129
130 bytes -= copy;
131 base += copy;
132 if (iov->iov_len == base) {
133 iov++;
134 nr_segs--;
135 base = 0;
136 }
137 }
138
139 memcpy(new, iov, sizeof(*iov) * nr_segs);
140 new->iov_base += base;
141 new->iov_len -= base;
142 return nr_segs;
143 }
144
145 /**
146 * get_conn_iovec() - get connection iovec for reading from socket
147 * @t: TCP transport instance
148 * @nr_segs: number of segments in iov
149 *
150 * Return: return existing or newly allocate iovec
151 */
get_conn_iovec(struct tcp_transport * t,unsigned int nr_segs)152 static struct kvec *get_conn_iovec(struct tcp_transport *t, unsigned int nr_segs)
153 {
154 struct kvec *new_iov;
155
156 if (t->iov && nr_segs <= t->nr_iov)
157 return t->iov;
158
159 /* not big enough -- allocate a new one and release the old */
160 new_iov = kmalloc_objs(*new_iov, nr_segs, KSMBD_DEFAULT_GFP);
161 if (new_iov) {
162 kfree(t->iov);
163 t->iov = new_iov;
164 t->nr_iov = nr_segs;
165 }
166 return new_iov;
167 }
168
169 /**
170 * ksmbd_tcp_new_connection() - create a new tcp session on mount
171 * @client_sk: socket associated with new connection
172 *
173 * whenever a new connection is requested, create a conn thread
174 * (session thread) to handle new incoming smb requests from the connection
175 *
176 * Return: 0 on success, otherwise error
177 */
ksmbd_tcp_new_connection(struct socket * client_sk)178 static int ksmbd_tcp_new_connection(struct socket *client_sk)
179 {
180 int rc = 0;
181 struct tcp_transport *t;
182 struct task_struct *handler;
183
184 t = alloc_transport(client_sk);
185 if (!t) {
186 sock_release(client_sk);
187 if (server_conf.max_connections)
188 atomic_dec(&active_num_conn);
189 return -ENOMEM;
190 }
191
192 #if IS_ENABLED(CONFIG_IPV6)
193 if (client_sk->sk->sk_family == AF_INET6)
194 handler = kthread_run(ksmbd_conn_handler_loop,
195 KSMBD_TRANS(t)->conn, "ksmbd:%pI6c",
196 &KSMBD_TRANS(t)->conn->inet6_addr);
197 else
198 handler = kthread_run(ksmbd_conn_handler_loop,
199 KSMBD_TRANS(t)->conn, "ksmbd:%pI4",
200 &KSMBD_TRANS(t)->conn->inet_addr);
201 #else
202 handler = kthread_run(ksmbd_conn_handler_loop,
203 KSMBD_TRANS(t)->conn, "ksmbd:%pI4",
204 &KSMBD_TRANS(t)->conn->inet_addr);
205 #endif
206 if (IS_ERR(handler)) {
207 pr_err("cannot start conn thread\n");
208 rc = PTR_ERR(handler);
209 ksmbd_tcp_disconnect(KSMBD_TRANS(t));
210 }
211 return rc;
212 }
213
214 /**
215 * ksmbd_kthread_fn() - listen to new SMB connections and callback server
216 * @p: arguments to forker thread
217 *
218 * Return: 0 on success, error number otherwise
219 */
ksmbd_kthread_fn(void * p)220 static int ksmbd_kthread_fn(void *p)
221 {
222 struct socket *client_sk = NULL;
223 struct interface *iface = (struct interface *)p;
224 struct ksmbd_conn *conn;
225 int ret, inet_hash;
226 unsigned int max_ip_conns;
227
228 while (!kthread_should_stop()) {
229 if (!iface->ksmbd_socket) {
230 break;
231 }
232 ret = kernel_accept(iface->ksmbd_socket, &client_sk, 0);
233 if (ret == -EINVAL)
234 break;
235 if (ret)
236 continue;
237
238 if (!server_conf.max_ip_connections)
239 goto skip_max_ip_conns_limit;
240
241 /*
242 * Limits repeated connections from clients with the same IP.
243 */
244 #if IS_ENABLED(CONFIG_IPV6)
245 if (client_sk->sk->sk_family == AF_INET6)
246 inet_hash = ipv6_addr_hash(&client_sk->sk->sk_v6_daddr);
247 else
248 inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
249 #else
250 inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
251 #endif
252
253 max_ip_conns = 0;
254 down_read(&conn_list_lock);
255 hash_for_each_possible(conn_list, conn, hlist, inet_hash) {
256 #if IS_ENABLED(CONFIG_IPV6)
257 if (client_sk->sk->sk_family == AF_INET6) {
258 if (memcmp(&client_sk->sk->sk_v6_daddr,
259 &conn->inet6_addr, 16) == 0)
260 max_ip_conns++;
261 } else if (inet_sk(client_sk->sk)->inet_daddr ==
262 conn->inet_addr)
263 max_ip_conns++;
264 #else
265 if (inet_sk(client_sk->sk)->inet_daddr ==
266 conn->inet_addr)
267 max_ip_conns++;
268 #endif
269 if (server_conf.max_ip_connections <= max_ip_conns) {
270 pr_info_ratelimited("Maximum IP connections exceeded (%u/%u)\n",
271 max_ip_conns, server_conf.max_ip_connections);
272 ret = -EAGAIN;
273 break;
274 }
275 }
276 up_read(&conn_list_lock);
277 if (ret == -EAGAIN) {
278 /* Per-IP limit hit: release the just-accepted socket. */
279 sock_release(client_sk);
280 continue;
281 }
282
283 skip_max_ip_conns_limit:
284 if (server_conf.max_connections &&
285 atomic_inc_return(&active_num_conn) > server_conf.max_connections) {
286 pr_info_ratelimited("Limit the maximum number of connections(%u)\n",
287 atomic_read(&active_num_conn));
288 atomic_dec(&active_num_conn);
289 sock_release(client_sk);
290 continue;
291 }
292
293 ksmbd_debug(CONN, "connect success: accepted new connection\n");
294 client_sk->sk->sk_rcvtimeo = KSMBD_TCP_RECV_TIMEOUT;
295 client_sk->sk->sk_sndtimeo = KSMBD_TCP_SEND_TIMEOUT;
296 /*
297 * Detect peers that disappear without sending a FIN or RST.
298 * Otherwise the connection handler can retry receive timeouts
299 * indefinitely and keep the connection in conn_list.
300 */
301 sock_set_keepalive(client_sk->sk);
302
303 ksmbd_tcp_new_connection(client_sk);
304 }
305
306 ksmbd_debug(CONN, "releasing socket\n");
307 return 0;
308 }
309
310 /**
311 * ksmbd_tcp_run_kthread() - start forker thread
312 * @iface: pointer to struct interface
313 *
314 * start forker thread(ksmbd/0) at module init time to listen
315 * on port 445 for new SMB connection requests. It creates per connection
316 * server threads(ksmbd/x)
317 *
318 * Return: 0 on success or error number
319 */
ksmbd_tcp_run_kthread(struct interface * iface)320 static int ksmbd_tcp_run_kthread(struct interface *iface)
321 {
322 int rc;
323 struct task_struct *kthread;
324
325 kthread = kthread_create(ksmbd_kthread_fn, (void *)iface, "ksmbd-%s",
326 iface->name);
327 if (IS_ERR(kthread)) {
328 rc = PTR_ERR(kthread);
329 return rc;
330 }
331
332 /*
333 * The listener can exit after its socket is shutdown, so keep the
334 * task_struct alive until the caller has stopped it.
335 */
336 get_task_struct(kthread);
337 iface->ksmbd_kthread = kthread;
338 wake_up_process(kthread);
339
340 return 0;
341 }
342
343 /**
344 * ksmbd_tcp_readv() - read data from socket in given iovec
345 * @t: TCP transport instance
346 * @iov_orig: base IO vector
347 * @nr_segs: number of segments in base iov
348 * @to_read: number of bytes to read from socket
349 * @max_retries: maximum retry count
350 *
351 * Return: on success return number of bytes read from socket,
352 * otherwise return error number
353 */
ksmbd_tcp_readv(struct tcp_transport * t,struct kvec * iov_orig,unsigned int nr_segs,unsigned int to_read,int max_retries)354 static int ksmbd_tcp_readv(struct tcp_transport *t, struct kvec *iov_orig,
355 unsigned int nr_segs, unsigned int to_read,
356 int max_retries)
357 {
358 int length = 0;
359 int total_read;
360 unsigned int segs;
361 struct msghdr ksmbd_msg;
362 struct kvec *iov;
363 struct ksmbd_conn *conn = KSMBD_TRANS(t)->conn;
364
365 iov = get_conn_iovec(t, nr_segs);
366 if (!iov)
367 return -ENOMEM;
368
369 ksmbd_msg.msg_control = NULL;
370 ksmbd_msg.msg_controllen = 0;
371
372 for (total_read = 0; to_read; total_read += length, to_read -= length) {
373 try_to_freeze();
374
375 if (!ksmbd_conn_alive(conn)) {
376 total_read = -ESHUTDOWN;
377 break;
378 }
379 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
380
381 length = kernel_recvmsg(t->sock, &ksmbd_msg,
382 iov, segs, to_read, 0);
383
384 if (length == -EINTR) {
385 total_read = -ESHUTDOWN;
386 break;
387 } else if (ksmbd_conn_need_reconnect(conn)) {
388 total_read = -EAGAIN;
389 break;
390 } else if (length == -ERESTARTSYS || length == -EAGAIN) {
391 /*
392 * If max_retries is negative, Allow unlimited
393 * retries to keep connection with inactive sessions.
394 */
395 if (max_retries == 0) {
396 total_read = length;
397 break;
398 } else if (max_retries > 0) {
399 max_retries--;
400 }
401
402 usleep_range(1000, 2000);
403 length = 0;
404 continue;
405 } else if (length <= 0) {
406 total_read = length;
407 break;
408 }
409 }
410 return total_read;
411 }
412
413 /**
414 * ksmbd_tcp_read() - read data from socket in given buffer
415 * @t: TCP transport instance
416 * @buf: buffer to store read data from socket
417 * @to_read: number of bytes to read from socket
418 * @max_retries: number of retries if reading from socket fails
419 *
420 * Return: on success return number of bytes read from socket,
421 * otherwise return error number
422 */
ksmbd_tcp_read(struct ksmbd_transport * t,char * buf,unsigned int to_read,int max_retries)423 static int ksmbd_tcp_read(struct ksmbd_transport *t, char *buf,
424 unsigned int to_read, int max_retries)
425 {
426 struct kvec iov;
427
428 iov.iov_base = buf;
429 iov.iov_len = to_read;
430
431 return ksmbd_tcp_readv(TCP_TRANS(t), &iov, 1, to_read, max_retries);
432 }
433
ksmbd_tcp_writev(struct ksmbd_transport * t,const struct ksmbd_transport_write * tx)434 static int ksmbd_tcp_writev(struct ksmbd_transport *t,
435 const struct ksmbd_transport_write *tx)
436 {
437 struct msghdr smb_msg = {
438 .msg_flags = MSG_NOSIGNAL | tx->msg_flags,
439 };
440
441 return kernel_sendmsg(TCP_TRANS(t)->sock, &smb_msg, tx->iov,
442 tx->iov_cnt, tx->size);
443 }
444
ksmbd_tcp_disconnect(struct ksmbd_transport * t)445 static void ksmbd_tcp_disconnect(struct ksmbd_transport *t)
446 {
447 free_transport(TCP_TRANS(t));
448 if (server_conf.max_connections)
449 atomic_dec(&active_num_conn);
450 }
451
ksmbd_tcp_shutdown(struct ksmbd_transport * t)452 static void ksmbd_tcp_shutdown(struct ksmbd_transport *t)
453 {
454 kernel_sock_shutdown(TCP_TRANS(t)->sock, SHUT_RDWR);
455 }
456
tcp_destroy_socket(struct socket * ksmbd_socket)457 static void tcp_destroy_socket(struct socket *ksmbd_socket)
458 {
459 int ret;
460
461 if (!ksmbd_socket)
462 return;
463
464 ret = kernel_sock_shutdown(ksmbd_socket, SHUT_RDWR);
465 if (ret)
466 pr_err("Failed to shutdown socket: %d\n", ret);
467 sock_release(ksmbd_socket);
468 }
469
470 /**
471 * create_socket - create socket for ksmbd/0
472 * @iface: interface to bind the created socket to
473 *
474 * Return: 0 on success, error number otherwise
475 */
create_socket(struct interface * iface)476 static int create_socket(struct interface *iface)
477 {
478 int ret;
479 struct sockaddr_in6 sin6;
480 struct sockaddr_in sin;
481 struct socket *ksmbd_socket;
482 bool ipv4 = false;
483
484 ret = sock_create_kern(current->nsproxy->net_ns, PF_INET6, SOCK_STREAM,
485 IPPROTO_TCP, &ksmbd_socket);
486 if (ret) {
487 if (ret != -EAFNOSUPPORT)
488 pr_err("Can't create socket for ipv6, fallback to ipv4: %d\n", ret);
489 ret = sock_create_kern(current->nsproxy->net_ns, PF_INET,
490 SOCK_STREAM, IPPROTO_TCP, &ksmbd_socket);
491 if (ret) {
492 pr_err("Can't create socket for ipv4: %d\n", ret);
493 goto out_clear;
494 }
495
496 sin.sin_family = PF_INET;
497 sin.sin_addr.s_addr = htonl(INADDR_ANY);
498 sin.sin_port = htons(server_conf.tcp_port);
499 ipv4 = true;
500 } else {
501 sin6.sin6_family = PF_INET6;
502 sin6.sin6_addr = in6addr_any;
503 sin6.sin6_port = htons(server_conf.tcp_port);
504
505 lock_sock(ksmbd_socket->sk);
506 ksmbd_socket->sk->sk_ipv6only = false;
507 release_sock(ksmbd_socket->sk);
508 }
509
510 ksmbd_tcp_nodelay(ksmbd_socket);
511 ksmbd_tcp_reuseaddr(ksmbd_socket);
512
513 ret = sock_setsockopt(ksmbd_socket,
514 SOL_SOCKET,
515 SO_BINDTODEVICE,
516 KERNEL_SOCKPTR(iface->name),
517 strlen(iface->name));
518 if (ret != -ENODEV && ret < 0) {
519 pr_err("Failed to set SO_BINDTODEVICE: %d\n", ret);
520 goto out_error;
521 }
522
523 if (ipv4)
524 ret = kernel_bind(ksmbd_socket, (struct sockaddr_unsized *)&sin,
525 sizeof(sin));
526 else
527 ret = kernel_bind(ksmbd_socket, (struct sockaddr_unsized *)&sin6,
528 sizeof(sin6));
529 if (ret) {
530 pr_err("Failed to bind socket: %d\n", ret);
531 goto out_error;
532 }
533
534 /*
535 * Accepted sockets inherit the listener's net reference. Keep TCP
536 * timers alive after a kernel socket is released.
537 */
538 sk_net_refcnt_upgrade(ksmbd_socket->sk);
539
540 ret = kernel_listen(ksmbd_socket, KSMBD_SOCKET_BACKLOG);
541 if (ret) {
542 pr_err("Port listen() error: %d\n", ret);
543 goto out_error;
544 }
545
546 iface->ksmbd_socket = ksmbd_socket;
547 ret = ksmbd_tcp_run_kthread(iface);
548 if (ret) {
549 pr_err("Can't start ksmbd main kthread: %d\n", ret);
550 goto out_error;
551 }
552 iface->state = IFACE_STATE_CONFIGURED;
553
554 return 0;
555
556 out_error:
557 tcp_destroy_socket(ksmbd_socket);
558 out_clear:
559 iface->ksmbd_socket = NULL;
560 return ret;
561 }
562
ksmbd_find_netdev_name_iface_list(char * netdev_name)563 struct interface *ksmbd_find_netdev_name_iface_list(char *netdev_name)
564 {
565 struct interface *iface;
566
567 list_for_each_entry(iface, &iface_list, entry)
568 if (!strcmp(iface->name, netdev_name))
569 return iface;
570 return NULL;
571 }
572
ksmbd_netdev_event(struct notifier_block * nb,unsigned long event,void * ptr)573 static int ksmbd_netdev_event(struct notifier_block *nb, unsigned long event,
574 void *ptr)
575 {
576 struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
577 struct interface *iface;
578 int ret;
579
580 switch (event) {
581 case NETDEV_UP:
582 if (netif_is_bridge_port(netdev))
583 return NOTIFY_OK;
584
585 iface = ksmbd_find_netdev_name_iface_list(netdev->name);
586 if (iface && iface->state == IFACE_STATE_DOWN) {
587 ksmbd_debug(CONN, "netdev-up event: netdev(%s) is going up\n",
588 iface->name);
589 ret = create_socket(iface);
590 if (ret)
591 return NOTIFY_OK;
592 }
593 if (!iface && bind_additional_ifaces) {
594 iface = alloc_iface(kstrdup(netdev->name, KSMBD_DEFAULT_GFP));
595 if (!iface)
596 return NOTIFY_OK;
597 ksmbd_debug(CONN, "netdev-up event: netdev(%s) is going up\n",
598 iface->name);
599 ret = create_socket(iface);
600 if (ret)
601 break;
602 }
603 break;
604 case NETDEV_DOWN:
605 iface = ksmbd_find_netdev_name_iface_list(netdev->name);
606 if (iface && iface->state == IFACE_STATE_CONFIGURED) {
607 ksmbd_debug(CONN, "netdev-down event: netdev(%s) is going down\n",
608 iface->name);
609 ksmbd_tcp_stop_listener(iface);
610 iface->state = IFACE_STATE_DOWN;
611 break;
612 }
613 break;
614 }
615
616 return NOTIFY_DONE;
617 }
618
619 static struct notifier_block ksmbd_netdev_notifier = {
620 .notifier_call = ksmbd_netdev_event,
621 };
622
ksmbd_tcp_init(void)623 int ksmbd_tcp_init(void)
624 {
625 register_netdevice_notifier(&ksmbd_netdev_notifier);
626
627 return 0;
628 }
629
tcp_stop_kthread(struct task_struct * kthread)630 static void tcp_stop_kthread(struct task_struct *kthread)
631 {
632 int ret;
633
634 if (!kthread)
635 return;
636
637 ret = kthread_stop_put(kthread);
638 if (ret)
639 pr_err("failed to stop forker thread\n");
640 }
641
ksmbd_tcp_stop_listener(struct interface * iface)642 static void ksmbd_tcp_stop_listener(struct interface *iface)
643 {
644 if (iface->ksmbd_socket)
645 kernel_sock_shutdown(iface->ksmbd_socket, SHUT_RDWR);
646
647 tcp_stop_kthread(iface->ksmbd_kthread);
648 iface->ksmbd_kthread = NULL;
649
650 if (iface->ksmbd_socket) {
651 sock_release(iface->ksmbd_socket);
652 iface->ksmbd_socket = NULL;
653 }
654 }
655
ksmbd_tcp_destroy(void)656 void ksmbd_tcp_destroy(void)
657 {
658 struct interface *iface, *tmp;
659
660 unregister_netdevice_notifier(&ksmbd_netdev_notifier);
661
662 list_for_each_entry_safe(iface, tmp, &iface_list, entry) {
663 ksmbd_tcp_stop_listener(iface);
664 list_del(&iface->entry);
665 kfree(iface->name);
666 kfree(iface);
667 }
668 }
669
alloc_iface(char * ifname)670 static struct interface *alloc_iface(char *ifname)
671 {
672 struct interface *iface;
673
674 if (!ifname)
675 return NULL;
676
677 iface = kzalloc_obj(struct interface, KSMBD_DEFAULT_GFP);
678 if (!iface) {
679 kfree(ifname);
680 return NULL;
681 }
682
683 iface->name = ifname;
684 iface->state = IFACE_STATE_DOWN;
685 list_add(&iface->entry, &iface_list);
686 return iface;
687 }
688
ksmbd_tcp_set_interfaces(char * ifc_list,int ifc_list_sz)689 int ksmbd_tcp_set_interfaces(char *ifc_list, int ifc_list_sz)
690 {
691 int sz = 0;
692
693 if (!ifc_list_sz) {
694 bind_additional_ifaces = 1;
695 return 0;
696 }
697
698 while (ifc_list_sz > 0) {
699 if (!alloc_iface(kstrdup(ifc_list, KSMBD_DEFAULT_GFP)))
700 return -ENOMEM;
701
702 sz = strlen(ifc_list);
703 if (!sz)
704 break;
705
706 ifc_list += sz + 1;
707 ifc_list_sz -= (sz + 1);
708 }
709
710 bind_additional_ifaces = 0;
711
712 return 0;
713 }
714
715 static const struct ksmbd_transport_ops ksmbd_tcp_transport_ops = {
716 .read = ksmbd_tcp_read,
717 .writev = ksmbd_tcp_writev,
718 .disconnect = ksmbd_tcp_disconnect,
719 .shutdown = ksmbd_tcp_shutdown,
720 .free_transport = ksmbd_tcp_free_transport,
721 };
722