Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0-or-later
       2             : /*
       3             :  *  UDPLITE     An implementation of the UDP-Lite protocol (RFC 3828).
       4             :  *
       5             :  *  Authors:    Gerrit Renker       <gerrit@erg.abdn.ac.uk>
       6             :  *
       7             :  *  Changes:
       8             :  *  Fixes:
       9             :  */
      10             : 
      11             : #define pr_fmt(fmt) "UDPLite: " fmt
      12             : 
      13             : #include <linux/export.h>
      14             : #include <linux/proc_fs.h>
      15             : #include "udp_impl.h"
      16             : 
      17             : struct udp_table        udplite_table __read_mostly;
      18             : EXPORT_SYMBOL(udplite_table);
      19             : 
      20           0 : static int udplite_rcv(struct sk_buff *skb)
      21             : {
      22           0 :         return __udp4_lib_rcv(skb, &udplite_table, IPPROTO_UDPLITE);
      23             : }
      24             : 
      25           0 : static int udplite_err(struct sk_buff *skb, u32 info)
      26             : {
      27           0 :         return __udp4_lib_err(skb, info, &udplite_table);
      28             : }
      29             : 
      30             : static const struct net_protocol udplite_protocol = {
      31             :         .handler        = udplite_rcv,
      32             :         .err_handler    = udplite_err,
      33             :         .no_policy      = 1,
      34             :         .netns_ok       = 1,
      35             : };
      36             : 
      37             : struct proto    udplite_prot = {
      38             :         .name              = "UDP-Lite",
      39             :         .owner             = THIS_MODULE,
      40             :         .close             = udp_lib_close,
      41             :         .connect           = ip4_datagram_connect,
      42             :         .disconnect        = udp_disconnect,
      43             :         .ioctl             = udp_ioctl,
      44             :         .init              = udplite_sk_init,
      45             :         .destroy           = udp_destroy_sock,
      46             :         .setsockopt        = udp_setsockopt,
      47             :         .getsockopt        = udp_getsockopt,
      48             :         .sendmsg           = udp_sendmsg,
      49             :         .recvmsg           = udp_recvmsg,
      50             :         .sendpage          = udp_sendpage,
      51             :         .hash              = udp_lib_hash,
      52             :         .unhash            = udp_lib_unhash,
      53             :         .rehash            = udp_v4_rehash,
      54             :         .get_port          = udp_v4_get_port,
      55             :         .memory_allocated  = &udp_memory_allocated,
      56             :         .sysctl_mem        = sysctl_udp_mem,
      57             :         .obj_size          = sizeof(struct udp_sock),
      58             :         .h.udp_table       = &udplite_table,
      59             : };
      60             : EXPORT_SYMBOL(udplite_prot);
      61             : 
      62             : static struct inet_protosw udplite4_protosw = {
      63             :         .type           =  SOCK_DGRAM,
      64             :         .protocol       =  IPPROTO_UDPLITE,
      65             :         .prot           =  &udplite_prot,
      66             :         .ops            =  &inet_dgram_ops,
      67             :         .flags          =  INET_PROTOSW_PERMANENT,
      68             : };
      69             : 
      70             : #ifdef CONFIG_PROC_FS
      71             : static struct udp_seq_afinfo udplite4_seq_afinfo = {
      72             :         .family         = AF_INET,
      73             :         .udp_table      = &udplite_table,
      74             : };
      75             : 
      76           1 : static int __net_init udplite4_proc_init_net(struct net *net)
      77             : {
      78           1 :         if (!proc_create_net_data("udplite", 0444, net->proc_net, &udp_seq_ops,
      79             :                         sizeof(struct udp_iter_state), &udplite4_seq_afinfo))
      80           0 :                 return -ENOMEM;
      81             :         return 0;
      82             : }
      83             : 
      84           0 : static void __net_exit udplite4_proc_exit_net(struct net *net)
      85             : {
      86           0 :         remove_proc_entry("udplite", net->proc_net);
      87           0 : }
      88             : 
      89             : static struct pernet_operations udplite4_net_ops = {
      90             :         .init = udplite4_proc_init_net,
      91             :         .exit = udplite4_proc_exit_net,
      92             : };
      93             : 
      94           1 : static __init int udplite4_proc_init(void)
      95             : {
      96           1 :         return register_pernet_subsys(&udplite4_net_ops);
      97             : }
      98             : #else
      99             : static inline int udplite4_proc_init(void)
     100             : {
     101             :         return 0;
     102             : }
     103             : #endif
     104             : 
     105           1 : void __init udplite4_register(void)
     106             : {
     107           1 :         udp_table_init(&udplite_table, "UDP-Lite");
     108           1 :         if (proto_register(&udplite_prot, 1))
     109           0 :                 goto out_register_err;
     110             : 
     111           1 :         if (inet_add_protocol(&udplite_protocol, IPPROTO_UDPLITE) < 0)
     112           0 :                 goto out_unregister_proto;
     113             : 
     114           1 :         inet_register_protosw(&udplite4_protosw);
     115             : 
     116           1 :         if (udplite4_proc_init())
     117           0 :                 pr_err("%s: Cannot register /proc!\n", __func__);
     118             :         return;
     119             : 
     120           0 : out_unregister_proto:
     121           0 :         proto_unregister(&udplite_prot);
     122           0 : out_register_err:
     123           0 :         pr_crit("%s: Cannot add UDP-Lite protocol\n", __func__);
     124             : }