xref: /openbmc/linux/drivers/net/ppp/pptp.c (revision e290ed81) 
1 /*
2  *  Point-to-Point Tunneling Protocol for Linux
3  *
4  *	Authors: Dmitry Kozlov <xeb@mail.ru>
5  *
6  *	This program is free software; you can redistribute it and/or
7  *	modify it under the terms of the GNU General Public License
8  *	as published by the Free Software Foundation; either version
9  *	2 of the License, or (at your option) any later version.
10  *
11  */
12 
13 #include <linux/string.h>
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/errno.h>
18 #include <linux/netdevice.h>
19 #include <linux/net.h>
20 #include <linux/skbuff.h>
21 #include <linux/vmalloc.h>
22 #include <linux/init.h>
23 #include <linux/ppp_channel.h>
24 #include <linux/ppp_defs.h>
25 #include <linux/if_pppox.h>
26 #include <linux/if_ppp.h>
27 #include <linux/notifier.h>
28 #include <linux/file.h>
29 #include <linux/in.h>
30 #include <linux/ip.h>
31 #include <linux/netfilter.h>
32 #include <linux/netfilter_ipv4.h>
33 #include <linux/rcupdate.h>
34 #include <linux/spinlock.h>
35 
36 #include <net/sock.h>
37 #include <net/protocol.h>
38 #include <net/ip.h>
39 #include <net/icmp.h>
40 #include <net/route.h>
41 #include <net/gre.h>
42 
43 #include <linux/uaccess.h>
44 
45 #define PPTP_DRIVER_VERSION "0.8.5"
46 
47 #define MAX_CALLID 65535
48 
49 static DECLARE_BITMAP(callid_bitmap, MAX_CALLID + 1);
50 static struct pppox_sock **callid_sock;
51 
52 static DEFINE_SPINLOCK(chan_lock);
53 
54 static struct proto pptp_sk_proto __read_mostly;
55 static const struct ppp_channel_ops pptp_chan_ops;
56 static const struct proto_ops pptp_ops;
57 
58 #define PPP_LCP_ECHOREQ 0x09
59 #define PPP_LCP_ECHOREP 0x0A
60 #define SC_RCV_BITS	(SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
61 
62 #define MISSING_WINDOW 20
63 #define WRAPPED(curseq, lastseq)\
64 	((((curseq) & 0xffffff00) == 0) &&\
65 	(((lastseq) & 0xffffff00) == 0xffffff00))
66 
67 #define PPTP_GRE_PROTO  0x880B
68 #define PPTP_GRE_VER    0x1
69 
70 #define PPTP_GRE_FLAG_C	0x80
71 #define PPTP_GRE_FLAG_R	0x40
72 #define PPTP_GRE_FLAG_K	0x20
73 #define PPTP_GRE_FLAG_S	0x10
74 #define PPTP_GRE_FLAG_A	0x80
75 
76 #define PPTP_GRE_IS_C(f) ((f)&PPTP_GRE_FLAG_C)
77 #define PPTP_GRE_IS_R(f) ((f)&PPTP_GRE_FLAG_R)
78 #define PPTP_GRE_IS_K(f) ((f)&PPTP_GRE_FLAG_K)
79 #define PPTP_GRE_IS_S(f) ((f)&PPTP_GRE_FLAG_S)
80 #define PPTP_GRE_IS_A(f) ((f)&PPTP_GRE_FLAG_A)
81 
82 #define PPTP_HEADER_OVERHEAD (2+sizeof(struct pptp_gre_header))
83 struct pptp_gre_header {
84 	u8  flags;
85 	u8  ver;
86 	u16 protocol;
87 	u16 payload_len;
88 	u16 call_id;
89 	u32 seq;
90 	u32 ack;
91 } __packed;
92 
93 static struct pppox_sock *lookup_chan(u16 call_id, __be32 s_addr)
94 {
95 	struct pppox_sock *sock;
96 	struct pptp_opt *opt;
97 
98 	rcu_read_lock();
99 	sock = rcu_dereference(callid_sock[call_id]);
100 	if (sock) {
101 		opt = &sock->proto.pptp;
102 		if (opt->dst_addr.sin_addr.s_addr != s_addr)
103 			sock = NULL;
104 		else
105 			sock_hold(sk_pppox(sock));
106 	}
107 	rcu_read_unlock();
108 
109 	return sock;
110 }
111 
112 static int lookup_chan_dst(u16 call_id, __be32 d_addr)
113 {
114 	struct pppox_sock *sock;
115 	struct pptp_opt *opt;
116 	int i;
117 
118 	rcu_read_lock();
119 	for (i = find_next_bit(callid_bitmap, MAX_CALLID, 1); i < MAX_CALLID;
120 	     i = find_next_bit(callid_bitmap, MAX_CALLID, i + 1)) {
121 		sock = rcu_dereference(callid_sock[i]);
122 		if (!sock)
123 			continue;
124 		opt = &sock->proto.pptp;
125 		if (opt->dst_addr.call_id == call_id &&
126 			  opt->dst_addr.sin_addr.s_addr == d_addr)
127 			break;
128 	}
129 	rcu_read_unlock();
130 
131 	return i < MAX_CALLID;
132 }
133 
134 static int add_chan(struct pppox_sock *sock)
135 {
136 	static int call_id;
137 
138 	spin_lock(&chan_lock);
139 	if (!sock->proto.pptp.src_addr.call_id)	{
140 		call_id = find_next_zero_bit(callid_bitmap, MAX_CALLID, call_id + 1);
141 		if (call_id == MAX_CALLID) {
142 			call_id = find_next_zero_bit(callid_bitmap, MAX_CALLID, 1);
143 			if (call_id == MAX_CALLID)
144 				goto out_err;
145 		}
146 		sock->proto.pptp.src_addr.call_id = call_id;
147 	} else if (test_bit(sock->proto.pptp.src_addr.call_id, callid_bitmap))
148 		goto out_err;
149 
150 	set_bit(sock->proto.pptp.src_addr.call_id, callid_bitmap);
151 	rcu_assign_pointer(callid_sock[sock->proto.pptp.src_addr.call_id], sock);
152 	spin_unlock(&chan_lock);
153 
154 	return 0;
155 
156 out_err:
157 	spin_unlock(&chan_lock);
158 	return -1;
159 }
160 
161 static void del_chan(struct pppox_sock *sock)
162 {
163 	spin_lock(&chan_lock);
164 	clear_bit(sock->proto.pptp.src_addr.call_id, callid_bitmap);
165 	rcu_assign_pointer(callid_sock[sock->proto.pptp.src_addr.call_id], NULL);
166 	spin_unlock(&chan_lock);
167 	synchronize_rcu();
168 }
169 
170 static int pptp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
171 {
172 	struct sock *sk = (struct sock *) chan->private;
173 	struct pppox_sock *po = pppox_sk(sk);
174 	struct pptp_opt *opt = &po->proto.pptp;
175 	struct pptp_gre_header *hdr;
176 	unsigned int header_len = sizeof(*hdr);
177 	struct flowi4 fl4;
178 	int islcp;
179 	int len;
180 	unsigned char *data;
181 	__u32 seq_recv;
182 
183 
184 	struct rtable *rt;
185 	struct net_device *tdev;
186 	struct iphdr  *iph;
187 	int    max_headroom;
188 
189 	if (sk_pppox(po)->sk_state & PPPOX_DEAD)
190 		goto tx_error;
191 
192 	rt = ip_route_output_ports(&init_net, &fl4, NULL,
193 				   opt->dst_addr.sin_addr.s_addr,
194 				   opt->src_addr.sin_addr.s_addr,
195 				   0, 0, IPPROTO_GRE,
196 				   RT_TOS(0), 0);
197 	if (IS_ERR(rt))
198 		goto tx_error;
199 
200 	tdev = rt->dst.dev;
201 
202 	max_headroom = LL_RESERVED_SPACE(tdev) + sizeof(*iph) + sizeof(*hdr) + 2;
203 
204 	if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
205 		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
206 		if (!new_skb) {
207 			ip_rt_put(rt);
208 			goto tx_error;
209 		}
210 		if (skb->sk)
211 			skb_set_owner_w(new_skb, skb->sk);
212 		kfree_skb(skb);
213 		skb = new_skb;
214 	}
215 
216 	data = skb->data;
217 	islcp = ((data[0] << 8) + data[1]) == PPP_LCP && 1 <= data[2] && data[2] <= 7;
218 
219 	/* compress protocol field */
220 	if ((opt->ppp_flags & SC_COMP_PROT) && data[0] == 0 && !islcp)
221 		skb_pull(skb, 1);
222 
223 	/* Put in the address/control bytes if necessary */
224 	if ((opt->ppp_flags & SC_COMP_AC) == 0 || islcp) {
225 		data = skb_push(skb, 2);
226 		data[0] = PPP_ALLSTATIONS;
227 		data[1] = PPP_UI;
228 	}
229 
230 	len = skb->len;
231 
232 	seq_recv = opt->seq_recv;
233 
234 	if (opt->ack_sent == seq_recv)
235 		header_len -= sizeof(hdr->ack);
236 
237 	/* Push down and install GRE header */
238 	skb_push(skb, header_len);
239 	hdr = (struct pptp_gre_header *)(skb->data);
240 
241 	hdr->flags       = PPTP_GRE_FLAG_K;
242 	hdr->ver         = PPTP_GRE_VER;
243 	hdr->protocol    = htons(PPTP_GRE_PROTO);
244 	hdr->call_id     = htons(opt->dst_addr.call_id);
245 
246 	hdr->flags      |= PPTP_GRE_FLAG_S;
247 	hdr->seq         = htonl(++opt->seq_sent);
248 	if (opt->ack_sent != seq_recv)	{
249 		/* send ack with this message */
250 		hdr->ver |= PPTP_GRE_FLAG_A;
251 		hdr->ack  = htonl(seq_recv);
252 		opt->ack_sent = seq_recv;
253 	}
254 	hdr->payload_len = htons(len);
255 
256 	/*	Push down and install the IP header. */
257 
258 	skb_reset_transport_header(skb);
259 	skb_push(skb, sizeof(*iph));
260 	skb_reset_network_header(skb);
261 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
262 	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED | IPSKB_REROUTED);
263 
264 	iph =	ip_hdr(skb);
265 	iph->version =	4;
266 	iph->ihl =	sizeof(struct iphdr) >> 2;
267 	if (ip_dont_fragment(sk, &rt->dst))
268 		iph->frag_off	=	htons(IP_DF);
269 	else
270 		iph->frag_off	=	0;
271 	iph->protocol = IPPROTO_GRE;
272 	iph->tos      = 0;
273 	iph->daddr    = fl4.daddr;
274 	iph->saddr    = fl4.saddr;
275 	iph->ttl      = ip4_dst_hoplimit(&rt->dst);
276 	iph->tot_len  = htons(skb->len);
277 
278 	skb_dst_drop(skb);
279 	skb_dst_set(skb, &rt->dst);
280 
281 	nf_reset(skb);
282 
283 	skb->ip_summed = CHECKSUM_NONE;
284 	ip_select_ident(iph, &rt->dst, NULL);
285 	ip_send_check(iph);
286 
287 	ip_local_out(skb);
288 
289 tx_error:
290 	return 1;
291 }
292 
293 static int pptp_rcv_core(struct sock *sk, struct sk_buff *skb)
294 {
295 	struct pppox_sock *po = pppox_sk(sk);
296 	struct pptp_opt *opt = &po->proto.pptp;
297 	int headersize, payload_len, seq;
298 	__u8 *payload;
299 	struct pptp_gre_header *header;
300 
301 	if (!(sk->sk_state & PPPOX_CONNECTED)) {
302 		if (sock_queue_rcv_skb(sk, skb))
303 			goto drop;
304 		return NET_RX_SUCCESS;
305 	}
306 
307 	header = (struct pptp_gre_header *)(skb->data);
308 
309 	/* test if acknowledgement present */
310 	if (PPTP_GRE_IS_A(header->ver)) {
311 		__u32 ack = (PPTP_GRE_IS_S(header->flags)) ?
312 				header->ack : header->seq; /* ack in different place if S = 0 */
313 
314 		ack = ntohl(ack);
315 
316 		if (ack > opt->ack_recv)
317 			opt->ack_recv = ack;
318 		/* also handle sequence number wrap-around  */
319 		if (WRAPPED(ack, opt->ack_recv))
320 			opt->ack_recv = ack;
321 	}
322 
323 	/* test if payload present */
324 	if (!PPTP_GRE_IS_S(header->flags))
325 		goto drop;
326 
327 	headersize  = sizeof(*header);
328 	payload_len = ntohs(header->payload_len);
329 	seq         = ntohl(header->seq);
330 
331 	/* no ack present? */
332 	if (!PPTP_GRE_IS_A(header->ver))
333 		headersize -= sizeof(header->ack);
334 	/* check for incomplete packet (length smaller than expected) */
335 	if (skb->len - headersize < payload_len)
336 		goto drop;
337 
338 	payload = skb->data + headersize;
339 	/* check for expected sequence number */
340 	if (seq < opt->seq_recv + 1 || WRAPPED(opt->seq_recv, seq)) {
341 		if ((payload[0] == PPP_ALLSTATIONS) && (payload[1] == PPP_UI) &&
342 				(PPP_PROTOCOL(payload) == PPP_LCP) &&
343 				((payload[4] == PPP_LCP_ECHOREQ) || (payload[4] == PPP_LCP_ECHOREP)))
344 			goto allow_packet;
345 	} else {
346 		opt->seq_recv = seq;
347 allow_packet:
348 		skb_pull(skb, headersize);
349 
350 		if (payload[0] == PPP_ALLSTATIONS && payload[1] == PPP_UI) {
351 			/* chop off address/control */
352 			if (skb->len < 3)
353 				goto drop;
354 			skb_pull(skb, 2);
355 		}
356 
357 		if ((*skb->data) & 1) {
358 			/* protocol is compressed */
359 			skb_push(skb, 1)[0] = 0;
360 		}
361 
362 		skb->ip_summed = CHECKSUM_NONE;
363 		skb_set_network_header(skb, skb->head-skb->data);
364 		ppp_input(&po->chan, skb);
365 
366 		return NET_RX_SUCCESS;
367 	}
368 drop:
369 	kfree_skb(skb);
370 	return NET_RX_DROP;
371 }
372 
373 static int pptp_rcv(struct sk_buff *skb)
374 {
375 	struct pppox_sock *po;
376 	struct pptp_gre_header *header;
377 	struct iphdr *iph;
378 
379 	if (skb->pkt_type != PACKET_HOST)
380 		goto drop;
381 
382 	if (!pskb_may_pull(skb, 12))
383 		goto drop;
384 
385 	iph = ip_hdr(skb);
386 
387 	header = (struct pptp_gre_header *)skb->data;
388 
389 	if (ntohs(header->protocol) != PPTP_GRE_PROTO || /* PPTP-GRE protocol for PPTP */
390 		PPTP_GRE_IS_C(header->flags) ||                /* flag C should be clear */
391 		PPTP_GRE_IS_R(header->flags) ||                /* flag R should be clear */
392 		!PPTP_GRE_IS_K(header->flags) ||               /* flag K should be set */
393 		(header->flags&0xF) != 0)                      /* routing and recursion ctrl = 0 */
394 		/* if invalid, discard this packet */
395 		goto drop;
396 
397 	po = lookup_chan(htons(header->call_id), iph->saddr);
398 	if (po) {
399 		skb_dst_drop(skb);
400 		nf_reset(skb);
401 		return sk_receive_skb(sk_pppox(po), skb, 0);
402 	}
403 drop:
404 	kfree_skb(skb);
405 	return NET_RX_DROP;
406 }
407 
408 static int pptp_bind(struct socket *sock, struct sockaddr *uservaddr,
409 	int sockaddr_len)
410 {
411 	struct sock *sk = sock->sk;
412 	struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
413 	struct pppox_sock *po = pppox_sk(sk);
414 	struct pptp_opt *opt = &po->proto.pptp;
415 	int error = 0;
416 
417 	lock_sock(sk);
418 
419 	opt->src_addr = sp->sa_addr.pptp;
420 	if (add_chan(po)) {
421 		release_sock(sk);
422 		error = -EBUSY;
423 	}
424 
425 	release_sock(sk);
426 	return error;
427 }
428 
429 static int pptp_connect(struct socket *sock, struct sockaddr *uservaddr,
430 	int sockaddr_len, int flags)
431 {
432 	struct sock *sk = sock->sk;
433 	struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
434 	struct pppox_sock *po = pppox_sk(sk);
435 	struct pptp_opt *opt = &po->proto.pptp;
436 	struct rtable *rt;
437 	struct flowi4 fl4;
438 	int error = 0;
439 
440 	if (sp->sa_protocol != PX_PROTO_PPTP)
441 		return -EINVAL;
442 
443 	if (lookup_chan_dst(sp->sa_addr.pptp.call_id, sp->sa_addr.pptp.sin_addr.s_addr))
444 		return -EALREADY;
445 
446 	lock_sock(sk);
447 	/* Check for already bound sockets */
448 	if (sk->sk_state & PPPOX_CONNECTED) {
449 		error = -EBUSY;
450 		goto end;
451 	}
452 
453 	/* Check for already disconnected sockets, on attempts to disconnect */
454 	if (sk->sk_state & PPPOX_DEAD) {
455 		error = -EALREADY;
456 		goto end;
457 	}
458 
459 	if (!opt->src_addr.sin_addr.s_addr || !sp->sa_addr.pptp.sin_addr.s_addr) {
460 		error = -EINVAL;
461 		goto end;
462 	}
463 
464 	po->chan.private = sk;
465 	po->chan.ops = &pptp_chan_ops;
466 
467 	rt = ip_route_output_ports(&init_net, &fl4, sk,
468 				   opt->dst_addr.sin_addr.s_addr,
469 				   opt->src_addr.sin_addr.s_addr,
470 				   0, 0,
471 				   IPPROTO_GRE, RT_CONN_FLAGS(sk), 0);
472 	if (IS_ERR(rt)) {
473 		error = -EHOSTUNREACH;
474 		goto end;
475 	}
476 	sk_setup_caps(sk, &rt->dst);
477 
478 	po->chan.mtu = dst_mtu(&rt->dst);
479 	if (!po->chan.mtu)
480 		po->chan.mtu = PPP_MTU;
481 	ip_rt_put(rt);
482 	po->chan.mtu -= PPTP_HEADER_OVERHEAD;
483 
484 	po->chan.hdrlen = 2 + sizeof(struct pptp_gre_header);
485 	error = ppp_register_channel(&po->chan);
486 	if (error) {
487 		pr_err("PPTP: failed to register PPP channel (%d)\n", error);
488 		goto end;
489 	}
490 
491 	opt->dst_addr = sp->sa_addr.pptp;
492 	sk->sk_state = PPPOX_CONNECTED;
493 
494  end:
495 	release_sock(sk);
496 	return error;
497 }
498 
499 static int pptp_getname(struct socket *sock, struct sockaddr *uaddr,
500 	int *usockaddr_len, int peer)
501 {
502 	int len = sizeof(struct sockaddr_pppox);
503 	struct sockaddr_pppox sp;
504 
505 	sp.sa_family	  = AF_PPPOX;
506 	sp.sa_protocol  = PX_PROTO_PPTP;
507 	sp.sa_addr.pptp = pppox_sk(sock->sk)->proto.pptp.src_addr;
508 
509 	memcpy(uaddr, &sp, len);
510 
511 	*usockaddr_len = len;
512 
513 	return 0;
514 }
515 
516 static int pptp_release(struct socket *sock)
517 {
518 	struct sock *sk = sock->sk;
519 	struct pppox_sock *po;
520 	struct pptp_opt *opt;
521 	int error = 0;
522 
523 	if (!sk)
524 		return 0;
525 
526 	lock_sock(sk);
527 
528 	if (sock_flag(sk, SOCK_DEAD)) {
529 		release_sock(sk);
530 		return -EBADF;
531 	}
532 
533 	po = pppox_sk(sk);
534 	opt = &po->proto.pptp;
535 	del_chan(po);
536 
537 	pppox_unbind_sock(sk);
538 	sk->sk_state = PPPOX_DEAD;
539 
540 	sock_orphan(sk);
541 	sock->sk = NULL;
542 
543 	release_sock(sk);
544 	sock_put(sk);
545 
546 	return error;
547 }
548 
549 static void pptp_sock_destruct(struct sock *sk)
550 {
551 	if (!(sk->sk_state & PPPOX_DEAD)) {
552 		del_chan(pppox_sk(sk));
553 		pppox_unbind_sock(sk);
554 	}
555 	skb_queue_purge(&sk->sk_receive_queue);
556 }
557 
558 static int pptp_create(struct net *net, struct socket *sock)
559 {
560 	int error = -ENOMEM;
561 	struct sock *sk;
562 	struct pppox_sock *po;
563 	struct pptp_opt *opt;
564 
565 	sk = sk_alloc(net, PF_PPPOX, GFP_KERNEL, &pptp_sk_proto);
566 	if (!sk)
567 		goto out;
568 
569 	sock_init_data(sock, sk);
570 
571 	sock->state = SS_UNCONNECTED;
572 	sock->ops   = &pptp_ops;
573 
574 	sk->sk_backlog_rcv = pptp_rcv_core;
575 	sk->sk_state       = PPPOX_NONE;
576 	sk->sk_type        = SOCK_STREAM;
577 	sk->sk_family      = PF_PPPOX;
578 	sk->sk_protocol    = PX_PROTO_PPTP;
579 	sk->sk_destruct    = pptp_sock_destruct;
580 
581 	po = pppox_sk(sk);
582 	opt = &po->proto.pptp;
583 
584 	opt->seq_sent = 0; opt->seq_recv = 0;
585 	opt->ack_recv = 0; opt->ack_sent = 0;
586 
587 	error = 0;
588 out:
589 	return error;
590 }
591 
592 static int pptp_ppp_ioctl(struct ppp_channel *chan, unsigned int cmd,
593 	unsigned long arg)
594 {
595 	struct sock *sk = (struct sock *) chan->private;
596 	struct pppox_sock *po = pppox_sk(sk);
597 	struct pptp_opt *opt = &po->proto.pptp;
598 	void __user *argp = (void __user *)arg;
599 	int __user *p = argp;
600 	int err, val;
601 
602 	err = -EFAULT;
603 	switch (cmd) {
604 	case PPPIOCGFLAGS:
605 		val = opt->ppp_flags;
606 		if (put_user(val, p))
607 			break;
608 		err = 0;
609 		break;
610 	case PPPIOCSFLAGS:
611 		if (get_user(val, p))
612 			break;
613 		opt->ppp_flags = val & ~SC_RCV_BITS;
614 		err = 0;
615 		break;
616 	default:
617 		err = -ENOTTY;
618 	}
619 
620 	return err;
621 }
622 
623 static const struct ppp_channel_ops pptp_chan_ops = {
624 	.start_xmit = pptp_xmit,
625 	.ioctl      = pptp_ppp_ioctl,
626 };
627 
628 static struct proto pptp_sk_proto __read_mostly = {
629 	.name     = "PPTP",
630 	.owner    = THIS_MODULE,
631 	.obj_size = sizeof(struct pppox_sock),
632 };
633 
634 static const struct proto_ops pptp_ops = {
635 	.family     = AF_PPPOX,
636 	.owner      = THIS_MODULE,
637 	.release    = pptp_release,
638 	.bind       = pptp_bind,
639 	.connect    = pptp_connect,
640 	.socketpair = sock_no_socketpair,
641 	.accept     = sock_no_accept,
642 	.getname    = pptp_getname,
643 	.poll       = sock_no_poll,
644 	.listen     = sock_no_listen,
645 	.shutdown   = sock_no_shutdown,
646 	.setsockopt = sock_no_setsockopt,
647 	.getsockopt = sock_no_getsockopt,
648 	.sendmsg    = sock_no_sendmsg,
649 	.recvmsg    = sock_no_recvmsg,
650 	.mmap       = sock_no_mmap,
651 	.ioctl      = pppox_ioctl,
652 };
653 
654 static const struct pppox_proto pppox_pptp_proto = {
655 	.create = pptp_create,
656 	.owner  = THIS_MODULE,
657 };
658 
659 static const struct gre_protocol gre_pptp_protocol = {
660 	.handler = pptp_rcv,
661 };
662 
663 static int __init pptp_init_module(void)
664 {
665 	int err = 0;
666 	pr_info("PPTP driver version " PPTP_DRIVER_VERSION "\n");
667 
668 	callid_sock = vzalloc((MAX_CALLID + 1) * sizeof(void *));
669 	if (!callid_sock) {
670 		pr_err("PPTP: cann't allocate memory\n");
671 		return -ENOMEM;
672 	}
673 
674 	err = gre_add_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
675 	if (err) {
676 		pr_err("PPTP: can't add gre protocol\n");
677 		goto out_mem_free;
678 	}
679 
680 	err = proto_register(&pptp_sk_proto, 0);
681 	if (err) {
682 		pr_err("PPTP: can't register sk_proto\n");
683 		goto out_gre_del_protocol;
684 	}
685 
686 	err = register_pppox_proto(PX_PROTO_PPTP, &pppox_pptp_proto);
687 	if (err) {
688 		pr_err("PPTP: can't register pppox_proto\n");
689 		goto out_unregister_sk_proto;
690 	}
691 
692 	return 0;
693 
694 out_unregister_sk_proto:
695 	proto_unregister(&pptp_sk_proto);
696 out_gre_del_protocol:
697 	gre_del_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
698 out_mem_free:
699 	vfree(callid_sock);
700 
701 	return err;
702 }
703 
704 static void __exit pptp_exit_module(void)
705 {
706 	unregister_pppox_proto(PX_PROTO_PPTP);
707 	proto_unregister(&pptp_sk_proto);
708 	gre_del_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
709 	vfree(callid_sock);
710 }
711 
712 module_init(pptp_init_module);
713 module_exit(pptp_exit_module);
714 
715 MODULE_DESCRIPTION("Point-to-Point Tunneling Protocol");
716 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
717 MODULE_LICENSE("GPL");
718