1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * IP Payload Compression Protocol (IPComp) - RFC3173. 4 * 5 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au> 6 * 7 * Todo: 8 * - Tunable compression parameters. 9 * - Compression stats. 10 * - Adaptive compression. 11 */ 12 #include <linux/module.h> 13 #include <linux/err.h> 14 #include <linux/rtnetlink.h> 15 #include <net/ip.h> 16 #include <net/xfrm.h> 17 #include <net/icmp.h> 18 #include <net/ipcomp.h> 19 #include <net/protocol.h> 20 #include <net/sock.h> 21 22 static int ipcomp4_err(struct sk_buff *skb, u32 info) 23 { 24 struct net *net = dev_net(skb->dev); 25 __be32 spi; 26 const struct iphdr *iph = (const struct iphdr *)skb->data; 27 struct ip_comp_hdr *ipch = (struct ip_comp_hdr *)(skb->data+(iph->ihl<<2)); 28 struct xfrm_state *x; 29 30 switch (icmp_hdr(skb)->type) { 31 case ICMP_DEST_UNREACH: 32 if (icmp_hdr(skb)->code != ICMP_FRAG_NEEDED) 33 return 0; 34 break; 35 case ICMP_REDIRECT: 36 break; 37 default: 38 return 0; 39 } 40 41 spi = htonl(ntohs(ipch->cpi)); 42 x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr, 43 spi, IPPROTO_COMP, AF_INET); 44 if (!x) 45 return 0; 46 47 if (icmp_hdr(skb)->type == ICMP_DEST_UNREACH) 48 ipv4_update_pmtu(skb, net, info, 0, IPPROTO_COMP); 49 else 50 ipv4_redirect(skb, net, 0, IPPROTO_COMP); 51 xfrm_state_put(x); 52 53 return 0; 54 } 55 56 /* We always hold one tunnel user reference to indicate a tunnel */ 57 static struct lock_class_key xfrm_state_lock_key; 58 static struct xfrm_state *ipcomp_tunnel_create(struct xfrm_state *x) 59 { 60 struct net *net = xs_net(x); 61 struct xfrm_state *t; 62 63 t = xfrm_state_alloc(net); 64 if (!t) 65 goto out; 66 lockdep_set_class(&t->lock, &xfrm_state_lock_key); 67 68 t->id.proto = IPPROTO_IPIP; 69 t->id.spi = x->props.saddr.a4; 70 t->id.daddr.a4 = x->id.daddr.a4; 71 memcpy(&t->sel, &x->sel, sizeof(t->sel)); 72 t->props.family = AF_INET; 73 t->props.mode = x->props.mode; 74 t->props.saddr.a4 = x->props.saddr.a4; 75 t->props.flags = x->props.flags; 76 t->props.extra_flags = x->props.extra_flags; 77 memcpy(&t->mark, &x->mark, sizeof(t->mark)); 78 t->if_id = x->if_id; 79 80 if (xfrm_init_state(t)) 81 goto error; 82 83 atomic_set(&t->tunnel_users, 1); 84 out: 85 return t; 86 87 error: 88 t->km.state = XFRM_STATE_DEAD; 89 xfrm_state_put(t); 90 t = NULL; 91 goto out; 92 } 93 94 /* 95 * Must be protected by xfrm_cfg_mutex. State and tunnel user references are 96 * always incremented on success. 97 */ 98 static int ipcomp_tunnel_attach(struct xfrm_state *x) 99 { 100 struct net *net = xs_net(x); 101 int err = 0; 102 struct xfrm_state *t; 103 u32 mark = x->mark.v & x->mark.m; 104 105 t = xfrm_state_lookup(net, mark, (xfrm_address_t *)&x->id.daddr.a4, 106 x->props.saddr.a4, IPPROTO_IPIP, AF_INET); 107 if (!t) { 108 t = ipcomp_tunnel_create(x); 109 if (!t) { 110 err = -EINVAL; 111 goto out; 112 } 113 xfrm_state_insert(t); 114 xfrm_state_hold(t); 115 } 116 x->tunnel = t; 117 atomic_inc(&t->tunnel_users); 118 out: 119 return err; 120 } 121 122 static int ipcomp4_init_state(struct xfrm_state *x, 123 struct netlink_ext_ack *extack) 124 { 125 int err = -EINVAL; 126 127 x->props.header_len = 0; 128 switch (x->props.mode) { 129 case XFRM_MODE_TRANSPORT: 130 break; 131 case XFRM_MODE_TUNNEL: 132 x->props.header_len += sizeof(struct iphdr); 133 break; 134 default: 135 NL_SET_ERR_MSG(extack, "Unsupported XFRM mode for IPcomp"); 136 goto out; 137 } 138 139 err = ipcomp_init_state(x, extack); 140 if (err) 141 goto out; 142 143 if (x->props.mode == XFRM_MODE_TUNNEL) { 144 err = ipcomp_tunnel_attach(x); 145 if (err) { 146 NL_SET_ERR_MSG(extack, "Kernel error: failed to initialize the associated state"); 147 goto out; 148 } 149 } 150 151 err = 0; 152 out: 153 return err; 154 } 155 156 static int ipcomp4_rcv_cb(struct sk_buff *skb, int err) 157 { 158 return 0; 159 } 160 161 static const struct xfrm_type ipcomp_type = { 162 .owner = THIS_MODULE, 163 .proto = IPPROTO_COMP, 164 .init_state = ipcomp4_init_state, 165 .destructor = ipcomp_destroy, 166 .input = ipcomp_input, 167 .output = ipcomp_output 168 }; 169 170 static struct xfrm4_protocol ipcomp4_protocol = { 171 .handler = xfrm4_rcv, 172 .input_handler = xfrm_input, 173 .cb_handler = ipcomp4_rcv_cb, 174 .err_handler = ipcomp4_err, 175 .priority = 0, 176 }; 177 178 static int __init ipcomp4_init(void) 179 { 180 if (xfrm_register_type(&ipcomp_type, AF_INET) < 0) { 181 pr_info("%s: can't add xfrm type\n", __func__); 182 return -EAGAIN; 183 } 184 if (xfrm4_protocol_register(&ipcomp4_protocol, IPPROTO_COMP) < 0) { 185 pr_info("%s: can't add protocol\n", __func__); 186 xfrm_unregister_type(&ipcomp_type, AF_INET); 187 return -EAGAIN; 188 } 189 return 0; 190 } 191 192 static void __exit ipcomp4_fini(void) 193 { 194 if (xfrm4_protocol_deregister(&ipcomp4_protocol, IPPROTO_COMP) < 0) 195 pr_info("%s: can't remove protocol\n", __func__); 196 xfrm_unregister_type(&ipcomp_type, AF_INET); 197 } 198 199 module_init(ipcomp4_init); 200 module_exit(ipcomp4_fini); 201 202 MODULE_LICENSE("GPL"); 203 MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp/IPv4) - RFC3173"); 204 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 205 206 MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_COMP); 207