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
 22static 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 */
 56static 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);
 80out:
 81	return t;
 82
 83error:
 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 */
 94static 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);
114out:
115	return err;
116}
117
118static 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;
144out:
145	return err;
146}
147
148static int ipcomp4_rcv_cb(struct sk_buff *skb, int err)
149{
150	return 0;
151}
152
153static 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
163static 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
171static 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
185static 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	xfrm_unregister_type(&ipcomp_type, AF_INET);
 
190}
191
192module_init(ipcomp4_init);
193module_exit(ipcomp4_fini);
194
195MODULE_LICENSE("GPL");
196MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp/IPv4) - RFC3173");
197MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
198
199MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_COMP);

 
  1/*
  2 * IP Payload Compression Protocol (IPComp) - RFC3173.
  3 *
  4 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
  5 *
  6 * This program is free software; you can redistribute it and/or modify it
  7 * under the terms of the GNU General Public License as published by the Free
  8 * Software Foundation; either version 2 of the License, or (at your option)
  9 * any later version.
 10 *
 11 * Todo:
 12 *   - Tunable compression parameters.
 13 *   - Compression stats.
 14 *   - Adaptive compression.
 15 */
 16#include <linux/module.h>
 17#include <linux/err.h>
 18#include <linux/rtnetlink.h>
 19#include <net/ip.h>
 20#include <net/xfrm.h>
 21#include <net/icmp.h>
 22#include <net/ipcomp.h>
 23#include <net/protocol.h>
 24#include <net/sock.h>
 25
 26static void ipcomp4_err(struct sk_buff *skb, u32 info)
 27{
 28	struct net *net = dev_net(skb->dev);
 29	__be32 spi;
 30	const struct iphdr *iph = (const struct iphdr *)skb->data;
 31	struct ip_comp_hdr *ipch = (struct ip_comp_hdr *)(skb->data+(iph->ihl<<2));
 32	struct xfrm_state *x;
 33
 34	if (icmp_hdr(skb)->type != ICMP_DEST_UNREACH ||
 35	    icmp_hdr(skb)->code != ICMP_FRAG_NEEDED)
 36		return;
 
 
 
 
 
 
 37
 38	spi = htonl(ntohs(ipch->cpi));
 39	x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr,
 40			      spi, IPPROTO_COMP, AF_INET);
 41	if (!x)
 42		return;
 43	NETDEBUG(KERN_DEBUG "pmtu discovery on SA IPCOMP/%08x/%pI4\n",
 44		 spi, &iph->daddr);
 
 
 
 45	xfrm_state_put(x);
 
 
 46}
 47
 48/* We always hold one tunnel user reference to indicate a tunnel */
 49static struct xfrm_state *ipcomp_tunnel_create(struct xfrm_state *x)
 50{
 51	struct net *net = xs_net(x);
 52	struct xfrm_state *t;
 53
 54	t = xfrm_state_alloc(net);
 55	if (t == NULL)
 56		goto out;
 57
 58	t->id.proto = IPPROTO_IPIP;
 59	t->id.spi = x->props.saddr.a4;
 60	t->id.daddr.a4 = x->id.daddr.a4;
 61	memcpy(&t->sel, &x->sel, sizeof(t->sel));
 62	t->props.family = AF_INET;
 63	t->props.mode = x->props.mode;
 64	t->props.saddr.a4 = x->props.saddr.a4;
 65	t->props.flags = x->props.flags;
 
 66	memcpy(&t->mark, &x->mark, sizeof(t->mark));
 67
 68	if (xfrm_init_state(t))
 69		goto error;
 70
 71	atomic_set(&t->tunnel_users, 1);
 72out:
 73	return t;
 74
 75error:
 76	t->km.state = XFRM_STATE_DEAD;
 77	xfrm_state_put(t);
 78	t = NULL;
 79	goto out;
 80}
 81
 82/*
 83 * Must be protected by xfrm_cfg_mutex.  State and tunnel user references are
 84 * always incremented on success.
 85 */
 86static int ipcomp_tunnel_attach(struct xfrm_state *x)
 87{
 88	struct net *net = xs_net(x);
 89	int err = 0;
 90	struct xfrm_state *t;
 91	u32 mark = x->mark.v & x->mark.m;
 92
 93	t = xfrm_state_lookup(net, mark, (xfrm_address_t *)&x->id.daddr.a4,
 94			      x->props.saddr.a4, IPPROTO_IPIP, AF_INET);
 95	if (!t) {
 96		t = ipcomp_tunnel_create(x);
 97		if (!t) {
 98			err = -EINVAL;
 99			goto out;
100		}
101		xfrm_state_insert(t);
102		xfrm_state_hold(t);
103	}
104	x->tunnel = t;
105	atomic_inc(&t->tunnel_users);
106out:
107	return err;
108}
109
110static int ipcomp4_init_state(struct xfrm_state *x)
111{
112	int err = -EINVAL;
113
114	x->props.header_len = 0;
115	switch (x->props.mode) {
116	case XFRM_MODE_TRANSPORT:
117		break;
118	case XFRM_MODE_TUNNEL:
119		x->props.header_len += sizeof(struct iphdr);
120		break;
121	default:
122		goto out;
123	}
124
125	err = ipcomp_init_state(x);
126	if (err)
127		goto out;
128
129	if (x->props.mode == XFRM_MODE_TUNNEL) {
130		err = ipcomp_tunnel_attach(x);
131		if (err)
132			goto out;
133	}
134
135	err = 0;
136out:
137	return err;
138}
139
 
 
 
 
 
140static const struct xfrm_type ipcomp_type = {
141	.description	= "IPCOMP4",
142	.owner		= THIS_MODULE,
143	.proto	     	= IPPROTO_COMP,
144	.init_state	= ipcomp4_init_state,
145	.destructor	= ipcomp_destroy,
146	.input		= ipcomp_input,
147	.output		= ipcomp_output
148};
149
150static const struct net_protocol ipcomp4_protocol = {
151	.handler	=	xfrm4_rcv,
 
 
152	.err_handler	=	ipcomp4_err,
153	.no_policy	=	1,
154};
155
156static int __init ipcomp4_init(void)
157{
158	if (xfrm_register_type(&ipcomp_type, AF_INET) < 0) {
159		printk(KERN_INFO "ipcomp init: can't add xfrm type\n");
160		return -EAGAIN;
161	}
162	if (inet_add_protocol(&ipcomp4_protocol, IPPROTO_COMP) < 0) {
163		printk(KERN_INFO "ipcomp init: can't add protocol\n");
164		xfrm_unregister_type(&ipcomp_type, AF_INET);
165		return -EAGAIN;
166	}
167	return 0;
168}
169
170static void __exit ipcomp4_fini(void)
171{
172	if (inet_del_protocol(&ipcomp4_protocol, IPPROTO_COMP) < 0)
173		printk(KERN_INFO "ip ipcomp close: can't remove protocol\n");
174	if (xfrm_unregister_type(&ipcomp_type, AF_INET) < 0)
175		printk(KERN_INFO "ip ipcomp close: can't remove xfrm type\n");
176}
177
178module_init(ipcomp4_init);
179module_exit(ipcomp4_fini);
180
181MODULE_LICENSE("GPL");
182MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp/IPv4) - RFC3173");
183MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
184
185MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_COMP);