1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Based on net/ipv6/ip6_output.c
4 * Authors:
5 * Pedro Roque <roque@di.fc.ul.pt>
6 *
7 * Changes:
8 * A.N.Kuznetsov : airthmetics in fragmentation.
9 * extension headers are implemented.
10 * route changes now work.
11 * ip6_forward does not confuse sniffers.
12 * etc.
13 *
14 * H. von Brand : Added missing #include <linux/string.h>
15 * Imran Patel : frag id should be in NBO
16 * Kazunori MIYAZAWA @USAGI
17 * : add ip6_append_data and related functions
18 * for datagram xmit
19 *
20 * NewIP output functions
21 * Linux NewIP INET implementation
22 */
23 #define pr_fmt(fmt) KBUILD_MODNAME ": [%s:%d] " fmt, __func__, __LINE__
24
25 #include <linux/errno.h>
26 #include <linux/kernel.h>
27 #include <linux/string.h>
28 #include <linux/socket.h>
29 #include <linux/net.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/nip.h>
33 #include <linux/route.h>
34 #include <linux/module.h>
35 #include <linux/time.h>
36 #include <linux/netfilter.h>
37
38 #include <net/sock.h>
39 #include <net/nndisc.h>
40 #include <net/protocol.h>
41 #include <net/checksum.h>
42 #include <net/nip.h>
43 #include <net/nip_udp.h>
44 #include <net/nip_route.h>
45 #include <net/tcp_nip.h>
46
47 #include "nip_hdr.h"
48 #include "nip_checksum.h"
49 #include "tcp_nip_parameter.h"
50
51 #define NIP_BIT_TO_BYTE 1024
update_memory_rate(const char * upper_fun)52 void update_memory_rate(const char *upper_fun)
53 {
54 struct sysinfo mem_info;
55 unsigned long total;
56 unsigned long free;
57 unsigned int uint_kb;
58
59 si_meminfo(&mem_info);
60 uint_kb = mem_info.mem_unit / NIP_BIT_TO_BYTE;
61 total = (unsigned long)mem_info.totalram * uint_kb;
62 free = (unsigned long)mem_info.freeram * uint_kb;
63 if (total > free)
64 nip_dbg("%s call cur-func mem total: %ld KB, mem used: %ld KB",
65 upper_fun, total, total - free);
66 else
67 nip_dbg("%s call cur-func mem total: %ld KB, mem free: %ld KB",
68 upper_fun, total, free);
69 }
70
nip_output(struct net * net,struct sock * sk,struct sk_buff * skb)71 int nip_output(struct net *net, struct sock *sk, struct sk_buff *skb)
72 {
73 struct dst_entry *dst = skb_dst(skb);
74 struct nip_addr *nexthop;
75 struct neighbour *neigh;
76 int ret = 0;
77 struct net_device *dev = skb_dst(skb)->dev;
78
79 skb->protocol = htons(ETH_P_NEWIP);
80 skb->dev = dev;
81
82 /* prepare to build ethernet header */
83 nexthop = nip_nexthop((struct nip_rt_info *)dst, &nipcb(skb)->dstaddr);
84
85 rcu_read_lock_bh();
86
87 neigh = __nip_neigh_lookup_noref(dev, nexthop);
88 if (unlikely(!neigh))
89 neigh = __neigh_create(&nnd_tbl, nexthop, dev, false);
90 if (!IS_ERR(neigh)) {
91 int res = neigh_output(neigh, skb, false);
92
93 rcu_read_unlock_bh();
94 return res;
95 }
96 nip_dbg("find neigh and create neigh failed");
97
98 rcu_read_unlock_bh();
99 kfree_skb(skb);
100 return ret;
101 }
102
nip_forward(struct sk_buff * skb)103 int nip_forward(struct sk_buff *skb)
104 {
105 return nip_output(NULL, NULL, skb);
106 }
107
nip_local_out(struct net * net,struct sock * sk,struct sk_buff * skb)108 static int nip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
109 {
110 int err;
111
112 err = dst_output(net, sk, skb);
113 return err;
114 }
115
nip_send_skb(struct sk_buff * skb)116 int nip_send_skb(struct sk_buff *skb)
117 {
118 struct net *net;
119 int err = 0;
120
121 net = skb->sk ? sock_net(skb->sk) : dev_net(skb_dst(skb)->dev);
122 err = nip_local_out(net, skb->sk, skb);
123 if (err) {
124 if (err > 0)
125 err = net_xmit_errno(err);
126 nip_dbg("failed to out skb, err = %d", err);
127 }
128
129 return err;
130 }
131
nip_get_output_checksum(struct sk_buff * skb,struct nip_hdr_encap * head)132 unsigned short nip_get_output_checksum(struct sk_buff *skb,
133 struct nip_hdr_encap *head)
134 {
135 struct nip_pseudo_header nph = {0};
136 u8 *udp_hdr = skb_transport_header(skb);
137 unsigned short check_len = head->trans_hdr_len + head->usr_data_len;
138
139 nph.nexthdr = IPPROTO_UDP;
140 nph.saddr = nipcb(skb)->srcaddr;
141 nph.daddr = nipcb(skb)->dstaddr;
142 nph.check_len = htons(check_len);
143 return nip_check_sum_build(udp_hdr, check_len, &nph);
144 }
145
_nip_alloc_skb(struct sock * sk,struct nip_hdr_encap * head,struct nip_pkt_seg_info * seg_info,struct dst_entry * dst)146 static struct sk_buff *_nip_alloc_skb(struct sock *sk,
147 struct nip_hdr_encap *head,
148 struct nip_pkt_seg_info *seg_info,
149 struct dst_entry *dst)
150 {
151 int len;
152 int nip_hdr_len = get_nip_hdr_len(NIP_HDR_UDP, &head->saddr, &head->daddr);
153 struct sk_buff *skb;
154
155 nip_hdr_len = nip_hdr_len == 0 ? NIP_HDR_MAX : nip_hdr_len;
156 len = NIP_ETH_HDR_LEN + nip_hdr_len + head->trans_hdr_len + seg_info->mid_usr_pkt_len;
157 skb = alloc_skb(len, 0);
158 if (!skb) {
159 nip_dbg("no space for skb");
160 return NULL;
161 }
162
163 skb->protocol = htons(ETH_P_NEWIP);
164 skb->ip_summed = CHECKSUM_NONE;
165 skb->csum = 0;
166 skb->sk = sk;
167
168 dst_hold(dst);
169 nip_dbg("malloc_len=%d, dst->__refcnt=%u", len, atomic_read(&dst->__refcnt));
170 skb_dst_set(skb, dst);
171 memset(nipcb(skb), 0, sizeof(struct ninet_skb_parm));
172
173 return skb;
174 }
175
_nip_udp_single_output(struct sock * sk,struct nip_hdr_encap * head,struct nip_pkt_seg_info * seg_info,struct dst_entry * dst)176 static int _nip_udp_single_output(struct sock *sk,
177 struct nip_hdr_encap *head,
178 struct nip_pkt_seg_info *seg_info,
179 struct dst_entry *dst)
180 {
181 int len;
182 int ret;
183 struct msghdr *from = (struct msghdr *)head->usr_data;
184 struct sk_buff *skb = _nip_alloc_skb(sk, head, seg_info, dst);
185 unsigned short check = 0;
186
187 if (IS_ERR_OR_NULL(skb)) {
188 nip_dbg("skb alloc fail");
189 return -ENOMEM;
190 }
191
192 /* Reserved Position of the Ethernet header (to be filled after the
193 * Ethernet header is delivered to the link layer)
194 */
195 skb_reserve(skb, NIP_ETH_HDR_LEN);
196
197 /* Fill in the Network-layer Header (newIP) */
198 skb_reset_network_header(skb);
199 head->hdr_buf = skb->data;
200 nip_hdr_udp_encap(head);
201 skb_reserve(skb, head->hdr_buf_pos);
202 nipcb(skb)->dstaddr = head->daddr;
203 nipcb(skb)->srcaddr = head->saddr;
204 nipcb(skb)->nexthdr = IPPROTO_UDP;
205
206 /* Fill in the Transport Layer Header (UDP) */
207 skb_reset_transport_header(skb);
208 nip_build_udp_hdr(head->sport, head->dport,
209 htons(head->trans_hdr_len + head->usr_data_len),
210 skb->data, htons(0));
211 skb_reserve(skb, head->trans_hdr_len);
212 len = copy_from_iter(skb->data, head->usr_data_len, &from->msg_iter);
213 if (len < 0) {
214 /* The DST has been set to the SKB. When the SKB is released,
215 * the DST is automatically released
216 */
217 nip_dbg("copy from iter fail (datalen=%u)", head->usr_data_len);
218 kfree_skb(skb);
219 return -EFBIG;
220 }
221
222 /* insert check sum */
223 check = nip_get_output_checksum(skb, head);
224 nip_build_udp_hdr(head->sport, head->dport,
225 htons(head->trans_hdr_len + head->usr_data_len),
226 skb->data - head->trans_hdr_len, htons(check));
227
228 /* Refresh the data/tail of the SKB after the packet copy is complete */
229 skb_put(skb, head->usr_data_len);
230 skb->data = skb_network_header(skb);
231 skb->len = head->hdr_buf_pos + head->trans_hdr_len +
232 head->usr_data_len;
233
234 /* Add the actual size of the current SKB to the SOCK send cache count
235 * and set destructor to __sock_wfree to reduce the SOCK send cache size
236 * when the SKB is released.
237 */
238 skb->destructor = __sock_wfree;
239 refcount_add(skb->truesize, &sk->sk_wmem_alloc);
240 skb->priority = sk->sk_priority;
241
242 ret = nip_send_skb(skb);
243 nip_dbg("output finish (ret=%d, datalen=%u)", ret, head->usr_data_len);
244 update_memory_rate(__func__);
245 return ret;
246 }
247
_nip_udp_output(struct sock * sk,void * from,int datalen,int transhdrlen,const struct nip_addr * saddr,ushort sport,const struct nip_addr * daddr,ushort dport,struct dst_entry * dst)248 int _nip_udp_output(struct sock *sk, void *from, int datalen,
249 int transhdrlen, const struct nip_addr *saddr,
250 ushort sport, const struct nip_addr *daddr,
251 ushort dport, struct dst_entry *dst)
252 {
253 int i;
254 u32 ret = 0;
255 u32 mtu = dst_mtu(dst);
256 struct nip_pkt_seg_info seg_info = {0};
257 struct nip_hdr_encap head = {0};
258 int nip_hdr_len = get_nip_hdr_len(NIP_HDR_UDP, saddr, daddr);
259
260 head.saddr = *saddr;
261 head.daddr = *daddr;
262 head.sport = sport;
263 head.dport = dport;
264 head.usr_data = from;
265 head.ttl = NIP_DEFAULT_TTL;
266 head.nexthdr = IPPROTO_UDP;
267 head.trans_hdr_len = transhdrlen;
268
269 nip_hdr_len = nip_hdr_len == 0 ? NIP_HDR_MAX : nip_hdr_len;
270 nip_calc_pkt_frag_num(mtu, nip_hdr_len, datalen, &seg_info);
271
272 /* Send intermediate data segments */
273 for (i = 0; i < seg_info.mid_pkt_num; i++) {
274 head.usr_data_len = seg_info.mid_usr_pkt_len;
275 ret = _nip_udp_single_output(sk, &head, &seg_info, dst);
276 if (ret)
277 goto end;
278 }
279
280 /* Send the last data segment */
281 if (seg_info.last_pkt_num) {
282 head.usr_data_len = seg_info.last_usr_pkt_len;
283 ret = _nip_udp_single_output(sk, &head, &seg_info, dst);
284 }
285
286 end:
287 return ret;
288 }
289
nip_sk_dst_check(struct dst_entry * dst,struct flow_nip * fln)290 static int nip_sk_dst_check(struct dst_entry *dst,
291 struct flow_nip *fln)
292 {
293 int err = 0;
294
295 if (!dst)
296 goto out;
297
298 if (fln->FLOWIN_OIF && fln->FLOWIN_OIF != dst->dev->ifindex)
299 err = -EPERM;
300
301 out:
302 return err;
303 }
304
305 /* 1. Based on FLN, the routing table is searched to obtain the corresponding DST
306 * 2. The newIP address of the source end is obtained based on the routing table
307 * search result and stored in the fln->saddr
308 */
nip_dst_lookup_tail(struct net * net,const struct sock * sk,struct dst_entry ** dst,struct flow_nip * fln)309 static int nip_dst_lookup_tail(struct net *net, const struct sock *sk,
310 struct dst_entry **dst, struct flow_nip *fln)
311 {
312 int err;
313 struct nip_rt_info *rt;
314
315 if (!(*dst))
316 *dst = nip_route_output(net, sk, fln);
317
318 err = (*dst)->error;
319 if (err) {
320 rt = NULL;
321 nip_dbg("route output search error");
322 goto out_err_release;
323 }
324
325 err = nip_sk_dst_check(*dst, fln);
326 if (err)
327 goto out_err_release;
328
329 rt = (struct nip_rt_info *)*dst;
330 if (*dst == &net->newip.nip_broadcast_entry->dst) {
331 fln->saddr = fln->daddr;
332 err = 0;
333 } else {
334 err = nip_route_get_saddr(net, rt, &fln->daddr, &fln->saddr);
335 }
336
337 if (err)
338 goto out_err_release;
339
340 return 0;
341
342 out_err_release:
343 dst_release(*dst);
344 *dst = NULL;
345
346 return err;
347 }
348
nip_dst_lookup_flow(struct net * net,const struct sock * sk,struct flow_nip * fln,const struct nip_addr * final_dst)349 struct dst_entry *nip_dst_lookup_flow(struct net *net, const struct sock *sk,
350 struct flow_nip *fln,
351 const struct nip_addr *final_dst)
352 {
353 struct dst_entry *dst = NULL;
354 int err;
355
356 err = nip_dst_lookup_tail(net, sk, &dst, fln);
357 if (err)
358 return ERR_PTR(err);
359 if (final_dst)
360 fln->daddr = *final_dst;
361
362 return dst;
363 }
364
nip_sk_dst_lookup_flow(struct sock * sk,struct flow_nip * fln)365 struct dst_entry *nip_sk_dst_lookup_flow(struct sock *sk, struct flow_nip *fln)
366 {
367 struct dst_entry *dst = NULL;
368 int err;
369
370 err = nip_dst_lookup_tail(sock_net(sk), sk, &dst, fln);
371 if (err)
372 return ERR_PTR(err);
373
374 return dst;
375 }
376
tcp_nip_queue_xmit(struct sock * sk,struct sk_buff * skb,struct flowi * fl)377 int tcp_nip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
378 {
379 int err = -EHOSTUNREACH;
380 struct net *net = sock_net(sk);
381 struct nip_addr *saddr, *daddr;
382 struct dst_entry *dst;
383 struct flow_nip fln;
384 struct nip_hdr_encap head = {0};
385 unsigned char hdr_buf[NIP_HDR_MAX]; /* Cache the newIP header */
386
387 rcu_read_lock();
388 skb->protocol = htons(ETH_P_NEWIP);
389 skb->ip_summed = CHECKSUM_NONE;
390 skb->csum = 0;
391 saddr = &sk->SK_NIP_RCV_SADDR;
392 daddr = &sk->SK_NIP_DADDR;
393
394 head.saddr = *saddr;
395 head.daddr = *daddr;
396 head.ttl = NIP_DEFAULT_TTL;
397 head.nexthdr = IPPROTO_TCP;
398 head.hdr_buf = hdr_buf;
399 nip_hdr_comm_encap(&head);
400 head.total_len = head.hdr_buf_pos + skb->len;
401 nip_update_total_len(&head, htons(head.total_len));
402
403 fln.daddr = sk->SK_NIP_DADDR;
404 dst = __sk_dst_check(sk, 0);
405 if (!dst) {
406 nip_dbg("no dst cache for sk, search newip rt");
407 dst = nip_route_output(net, sk, &fln);
408 if (!dst) {
409 nip_dbg("cannot find dst");
410 goto out;
411 }
412 if (dst->error)
413 goto out_err_release;
414 sk_dst_set(sk, dst);
415 }
416 skb_dst_set_noref(skb, dst);
417
418 /* build nwk header */
419 skb_push(skb, head.hdr_buf_pos);
420 memcpy(skb->data, head.hdr_buf, head.hdr_buf_pos);
421
422 skb_reset_network_header(skb);
423 nipcb(skb)->srcaddr = *saddr;
424 nipcb(skb)->dstaddr = *daddr;
425 nipcb(skb)->nexthdr = head.nexthdr;
426
427 skb->priority = sk->sk_priority;
428 head.total_len = skb->len;
429 err = nip_send_skb(skb);
430 if (err)
431 nip_dbg("failed to send skb, skb->len=%u", head.total_len);
432 else
433 nip_dbg("send skb ok, skb->len=%u", head.total_len);
434
435 out:
436 rcu_read_unlock();
437 return err;
438
439 out_err_release:
440 rcu_read_unlock();
441 dst_release(dst);
442 dst = NULL;
443 sk->sk_err_soft = -err;
444 sk->sk_route_caps = 0;
445 kfree_skb(skb);
446 return err;
447 }
448
tcp_nip_actual_send_reset(struct sock * sk,struct sk_buff * skb,u32 seq,u32 ack_seq,u32 win,int rst,u32 priority)449 void tcp_nip_actual_send_reset(struct sock *sk, struct sk_buff *skb, u32 seq,
450 u32 ack_seq, u32 win, int rst, u32 priority)
451 {
452 const struct tcphdr *th = tcp_hdr(skb);
453 struct tcphdr *t1;
454 struct sk_buff *buff;
455 struct flow_nip fln;
456 struct net *net;
457 struct nip_addr *saddr, *daddr;
458 unsigned int tot_len = sizeof(struct tcphdr);
459 struct nip_hdr_encap head = {0};
460 unsigned char hdr_buf[NIP_HDR_MAX];
461 struct dst_entry *dst;
462 int err;
463
464 net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
465
466 /* alloc skb */
467 buff = alloc_skb(MAX_TCP_HEADER, priority);
468 if (!buff)
469 /* If you add log here, there will be an alarm:
470 * WARNING: Possible unnecessary 'out of memory' message
471 */
472 return;
473
474 skb_reserve(buff, MAX_TCP_HEADER);
475
476 buff->sk = sk; // sk could be NULL
477 saddr = &(nipcb(skb)->dstaddr);
478 daddr = &(nipcb(skb)->srcaddr);
479
480 /* Fill in tcp header */
481 t1 = skb_push(buff, sizeof(struct tcphdr));
482 skb_reset_transport_header(buff);
483 memset(t1, 0, sizeof(*t1));
484 t1->dest = th->source;
485 t1->source = th->dest;
486 t1->doff = tot_len / TCP_NUM_4;
487 t1->seq = htonl(seq);
488 t1->ack_seq = htonl(ack_seq);
489 t1->ack = !rst || !th->ack;
490 t1->rst = rst;
491 t1->window = htons(win);
492 t1->check = htons(nip_get_output_checksum_tcp(buff, *saddr, *daddr));
493 nip_dbg("host dport=%u, net dport=0x%x, host sport=%u, net sport=0x%x",
494 ntohs(t1->dest), t1->dest, ntohs(t1->source), t1->source);
495 nip_dbg("host seq=%u, net seq=0x%x, host ack_seq=%u, net ack_seq=0x%x",
496 seq, t1->seq, ack_seq, t1->ack_seq);
497
498 buff->protocol = htons(ETH_P_NEWIP);
499 buff->ip_summed = CHECKSUM_NONE;
500 buff->csum = 0;
501
502 /* Fill in nip header */
503 head.saddr = *saddr;
504 head.daddr = *daddr;
505 head.ttl = NIP_DEFAULT_TTL;
506 head.nexthdr = IPPROTO_TCP;
507 head.hdr_buf = hdr_buf;
508 nip_hdr_comm_encap(&head);
509 head.total_len = head.hdr_buf_pos + buff->len;
510 nip_update_total_len(&head, htons(head.total_len));
511
512 /* Check routine */
513 fln.daddr = *daddr;
514 dst = nip_route_output(net, sk, &fln); // here, sk not used.
515 if (!dst) {
516 nip_dbg("cannot find dst");
517 goto out;
518 }
519 skb_dst_set_noref(buff, dst);
520
521 /* Build newip header */
522 skb_push(buff, head.hdr_buf_pos);
523 memcpy(buff->data, head.hdr_buf, head.hdr_buf_pos);
524
525 skb_reset_network_header(buff);
526 nipcb(buff)->srcaddr = *saddr;
527 nipcb(buff)->dstaddr = *daddr;
528 nipcb(buff)->nexthdr = head.nexthdr;
529
530 buff->priority = priority;
531 head.total_len = buff->len;
532 err = nip_send_skb(buff);
533 if (err)
534 nip_dbg("failed to send skb, skb->len=%u", head.total_len);
535 else
536 nip_dbg("send skb ok, skb->len=%u", head.total_len);
537
538 out:
539 return;
540 }
541