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 case ICMP_REDIRECT: 35 break; 36 default: 37 return 0; 38 } 39 40 spi = htonl(ntohs(ipch->cpi)); 41 x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr, 42 spi, IPPROTO_COMP, AF_INET); 43 if (!x) 44 return 0; 45 46 if (icmp_hdr(skb)->type == ICMP_DEST_UNREACH) 47 ipv4_update_pmtu(skb, net, info, 0, IPPROTO_COMP); 48 else 49 ipv4_redirect(skb, net, 0, IPPROTO_COMP); 50 xfrm_state_put(x); 51 52 return 0; 53 } 54 55 /* We always hold one tunnel user reference to indicate a tunnel */ 56 static struct xfrm_state *ipcomp_tunnel_create(struct xfrm_state *x) 57 { 58 struct net *net = xs_net(x); 59 struct xfrm_state *t; 60 61 t = xfrm_state_alloc(net); 62 if (!t) 63 goto out; 64 65 t->id.proto = IPPROTO_IPIP; 66 t->id.spi = x->props.saddr.a4; 67 t->id.daddr.a4 = x->id.daddr.a4; 68 memcpy(&t->sel, &x->sel, sizeof(t->sel)); 69 t->props.family = AF_INET; 70 t->props.mode = x->props.mode; 71 t->props.saddr.a4 = x->props.saddr.a4; 72 t->props.flags = x->props.flags; 73 t->props.extra_flags = x->props.extra_flags; 74 memcpy(&t->mark, &x->mark, sizeof(t->mark)); 75 76 if (xfrm_init_state(t)) 77 goto error; 78 79 atomic_set(&t->tunnel_users, 1); 80 out: 81 return t; 82 83 error: 84 t->km.state = XFRM_STATE_DEAD; 85 xfrm_state_put(t); 86 t = NULL; 87 goto out; 88 } 89 90 /* 91 * Must be protected by xfrm_cfg_mutex. State and tunnel user references are 92 * always incremented on success. 93 */ 94 static int ipcomp_tunnel_attach(struct xfrm_state *x) 95 { 96 struct net *net = xs_net(x); 97 int err = 0; 98 struct xfrm_state *t; 99 u32 mark = x->mark.v & x->mark.m; 100 101 t = xfrm_state_lookup(net, mark, (xfrm_address_t *)&x->id.daddr.a4, 102 x->props.saddr.a4, IPPROTO_IPIP, AF_INET); 103 if (!t) { 104 t = ipcomp_tunnel_create(x); 105 if (!t) { 106 err = -EINVAL; 107 goto out; 108 } 109 xfrm_state_insert(t); 110 xfrm_state_hold(t); 111 } 112 x->tunnel = t; 113 atomic_inc(&t->tunnel_users); 114 out: 115 return err; 116 } 117 118 static int ipcomp4_init_state(struct xfrm_state *x) 119 { 120 int err = -EINVAL; 121 122 x->props.header_len = 0; 123 switch (x->props.mode) { 124 case XFRM_MODE_TRANSPORT: 125 break; 126 case XFRM_MODE_TUNNEL: 127 x->props.header_len += sizeof(struct iphdr); 128 break; 129 default: 130 goto out; 131 } 132 133 err = ipcomp_init_state(x); 134 if (err) 135 goto out; 136 137 if (x->props.mode == XFRM_MODE_TUNNEL) { 138 err = ipcomp_tunnel_attach(x); 139 if (err) 140 goto out; 141 } 142 143 err = 0; 144 out: 145 return err; 146 } 147 148 static int ipcomp4_rcv_cb(struct sk_buff *skb, int err) 149 { 150 return 0; 151 } 152 153 static const struct xfrm_type ipcomp_type = { 154 .description = "IPCOMP4", 155 .owner = THIS_MODULE, 156 .proto = IPPROTO_COMP, 157 .init_state = ipcomp4_init_state, 158 .destructor = ipcomp_destroy, 159 .input = ipcomp_input, 160 .output = ipcomp_output 161 }; 162 163 static struct xfrm4_protocol ipcomp4_protocol = { 164 .handler = xfrm4_rcv, 165 .input_handler = xfrm_input, 166 .cb_handler = ipcomp4_rcv_cb, 167 .err_handler = ipcomp4_err, 168 .priority = 0, 169 }; 170 171 static int __init ipcomp4_init(void) 172 { 173 if (xfrm_register_type(&ipcomp_type, AF_INET) < 0) { 174 pr_info("%s: can't add xfrm type\n", __func__); 175 return -EAGAIN; 176 } 177 if (xfrm4_protocol_register(&ipcomp4_protocol, IPPROTO_COMP) < 0) { 178 pr_info("%s: can't add protocol\n", __func__); 179 xfrm_unregister_type(&ipcomp_type, AF_INET); 180 return -EAGAIN; 181 } 182 return 0; 183 } 184 185 static void __exit ipcomp4_fini(void) 186 { 187 if (xfrm4_protocol_deregister(&ipcomp4_protocol, IPPROTO_COMP) < 0) 188 pr_info("%s: can't remove protocol\n", __func__); 189 if (xfrm_unregister_type(&ipcomp_type, AF_INET) < 0) 190 pr_info("%s: can't remove xfrm type\n", __func__); 191 } 192 193 module_init(ipcomp4_init); 194 module_exit(ipcomp4_fini); 195 196 MODULE_LICENSE("GPL"); 197 MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp/IPv4) - RFC3173"); 198 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 199 200 MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_COMP); 201