pptp.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Point-to-Point Tunneling Protocol for Linux
  4. *
  5. * Authors: Dmitry Kozlov <xeb@mail.ru>
  6. */
  7. #include <linux/string.h>
  8. #include <linux/module.h>
  9. #include <linux/kernel.h>
  10. #include <linux/slab.h>
  11. #include <linux/errno.h>
  12. #include <linux/netdevice.h>
  13. #include <linux/net.h>
  14. #include <linux/skbuff.h>
  15. #include <linux/vmalloc.h>
  16. #include <linux/init.h>
  17. #include <linux/ppp_channel.h>
  18. #include <linux/ppp_defs.h>
  19. #include <linux/if_pppox.h>
  20. #include <linux/ppp-ioctl.h>
  21. #include <linux/notifier.h>
  22. #include <linux/file.h>
  23. #include <linux/in.h>
  24. #include <linux/ip.h>
  25. #include <linux/rcupdate.h>
  26. #include <linux/spinlock.h>
  27. #include <net/sock.h>
  28. #include <net/protocol.h>
  29. #include <net/ip.h>
  30. #include <net/icmp.h>
  31. #include <net/route.h>
  32. #include <net/gre.h>
  33. #include <net/pptp.h>
  34. #include <linux/uaccess.h>
  35. #define PPTP_DRIVER_VERSION "0.8.5"
  36. #define MAX_CALLID 65535
  37. static DECLARE_BITMAP(callid_bitmap, MAX_CALLID + 1);
  38. static struct pppox_sock __rcu **callid_sock;
  39. static DEFINE_SPINLOCK(chan_lock);
  40. static struct proto pptp_sk_proto __read_mostly;
  41. static const struct ppp_channel_ops pptp_chan_ops;
  42. static const struct proto_ops pptp_ops;
  43. static struct pppox_sock *lookup_chan(u16 call_id, __be32 s_addr)
  44. {
  45. struct pppox_sock *sock;
  46. struct pptp_opt *opt;
  47. rcu_read_lock();
  48. sock = rcu_dereference(callid_sock[call_id]);
  49. if (sock) {
  50. opt = &sock->proto.pptp;
  51. if (opt->dst_addr.sin_addr.s_addr != s_addr)
  52. sock = NULL;
  53. else
  54. sock_hold(sk_pppox(sock));
  55. }
  56. rcu_read_unlock();
  57. return sock;
  58. }
  59. static int lookup_chan_dst(u16 call_id, __be32 d_addr)
  60. {
  61. struct pppox_sock *sock;
  62. struct pptp_opt *opt;
  63. int i;
  64. rcu_read_lock();
  65. i = 1;
  66. for_each_set_bit_from(i, callid_bitmap, MAX_CALLID) {
  67. sock = rcu_dereference(callid_sock[i]);
  68. if (!sock)
  69. continue;
  70. opt = &sock->proto.pptp;
  71. if (opt->dst_addr.call_id == call_id &&
  72. opt->dst_addr.sin_addr.s_addr == d_addr)
  73. break;
  74. }
  75. rcu_read_unlock();
  76. return i < MAX_CALLID;
  77. }
  78. static int add_chan(struct pppox_sock *sock,
  79. struct pptp_addr *sa)
  80. {
  81. static int call_id;
  82. spin_lock(&chan_lock);
  83. if (!sa->call_id) {
  84. call_id = find_next_zero_bit(callid_bitmap, MAX_CALLID, call_id + 1);
  85. if (call_id == MAX_CALLID) {
  86. call_id = find_next_zero_bit(callid_bitmap, MAX_CALLID, 1);
  87. if (call_id == MAX_CALLID)
  88. goto out_err;
  89. }
  90. sa->call_id = call_id;
  91. } else if (test_bit(sa->call_id, callid_bitmap)) {
  92. goto out_err;
  93. }
  94. sock->proto.pptp.src_addr = *sa;
  95. set_bit(sa->call_id, callid_bitmap);
  96. rcu_assign_pointer(callid_sock[sa->call_id], sock);
  97. spin_unlock(&chan_lock);
  98. return 0;
  99. out_err:
  100. spin_unlock(&chan_lock);
  101. return -1;
  102. }
  103. static void del_chan(struct pppox_sock *sock)
  104. {
  105. spin_lock(&chan_lock);
  106. clear_bit(sock->proto.pptp.src_addr.call_id, callid_bitmap);
  107. RCU_INIT_POINTER(callid_sock[sock->proto.pptp.src_addr.call_id], NULL);
  108. spin_unlock(&chan_lock);
  109. }
  110. static int pptp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
  111. {
  112. struct sock *sk = (struct sock *) chan->private;
  113. struct pppox_sock *po = pppox_sk(sk);
  114. struct net *net = sock_net(sk);
  115. struct pptp_opt *opt = &po->proto.pptp;
  116. struct pptp_gre_header *hdr;
  117. unsigned int header_len = sizeof(*hdr);
  118. struct flowi4 fl4;
  119. int islcp;
  120. int len;
  121. unsigned char *data;
  122. __u32 seq_recv;
  123. struct rtable *rt;
  124. struct net_device *tdev;
  125. struct iphdr *iph;
  126. int max_headroom;
  127. if (sk_pppox(po)->sk_state & PPPOX_DEAD)
  128. goto tx_error;
  129. rt = ip_route_output_ports(net, &fl4, NULL,
  130. opt->dst_addr.sin_addr.s_addr,
  131. opt->src_addr.sin_addr.s_addr,
  132. 0, 0, IPPROTO_GRE,
  133. RT_TOS(0), sk->sk_bound_dev_if);
  134. if (IS_ERR(rt))
  135. goto tx_error;
  136. tdev = rt->dst.dev;
  137. max_headroom = LL_RESERVED_SPACE(tdev) + sizeof(*iph) + sizeof(*hdr) + 2;
  138. if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
  139. struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
  140. if (!new_skb) {
  141. ip_rt_put(rt);
  142. goto tx_error;
  143. }
  144. if (skb->sk)
  145. skb_set_owner_w(new_skb, skb->sk);
  146. consume_skb(skb);
  147. skb = new_skb;
  148. }
  149. data = skb->data;
  150. islcp = ((data[0] << 8) + data[1]) == PPP_LCP && 1 <= data[2] && data[2] <= 7;
  151. /* compress protocol field */
  152. if ((opt->ppp_flags & SC_COMP_PROT) && data[0] == 0 && !islcp)
  153. skb_pull(skb, 1);
  154. /* Put in the address/control bytes if necessary */
  155. if ((opt->ppp_flags & SC_COMP_AC) == 0 || islcp) {
  156. data = skb_push(skb, 2);
  157. data[0] = PPP_ALLSTATIONS;
  158. data[1] = PPP_UI;
  159. }
  160. len = skb->len;
  161. seq_recv = opt->seq_recv;
  162. if (opt->ack_sent == seq_recv)
  163. header_len -= sizeof(hdr->ack);
  164. /* Push down and install GRE header */
  165. skb_push(skb, header_len);
  166. hdr = (struct pptp_gre_header *)(skb->data);
  167. hdr->gre_hd.flags = GRE_KEY | GRE_VERSION_1 | GRE_SEQ;
  168. hdr->gre_hd.protocol = GRE_PROTO_PPP;
  169. hdr->call_id = htons(opt->dst_addr.call_id);
  170. hdr->seq = htonl(++opt->seq_sent);
  171. if (opt->ack_sent != seq_recv) {
  172. /* send ack with this message */
  173. hdr->gre_hd.flags |= GRE_ACK;
  174. hdr->ack = htonl(seq_recv);
  175. opt->ack_sent = seq_recv;
  176. }
  177. hdr->payload_len = htons(len);
  178. /* Push down and install the IP header. */
  179. skb_reset_transport_header(skb);
  180. skb_push(skb, sizeof(*iph));
  181. skb_reset_network_header(skb);
  182. memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
  183. IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED | IPSKB_REROUTED);
  184. iph = ip_hdr(skb);
  185. iph->version = 4;
  186. iph->ihl = sizeof(struct iphdr) >> 2;
  187. if (ip_dont_fragment(sk, &rt->dst))
  188. iph->frag_off = htons(IP_DF);
  189. else
  190. iph->frag_off = 0;
  191. iph->protocol = IPPROTO_GRE;
  192. iph->tos = 0;
  193. iph->daddr = fl4.daddr;
  194. iph->saddr = fl4.saddr;
  195. iph->ttl = ip4_dst_hoplimit(&rt->dst);
  196. iph->tot_len = htons(skb->len);
  197. skb_dst_drop(skb);
  198. skb_dst_set(skb, &rt->dst);
  199. nf_reset_ct(skb);
  200. skb->ip_summed = CHECKSUM_NONE;
  201. ip_select_ident(net, skb, NULL);
  202. ip_send_check(iph);
  203. ip_local_out(net, skb->sk, skb);
  204. return 1;
  205. tx_error:
  206. kfree_skb(skb);
  207. return 1;
  208. }
  209. static int pptp_rcv_core(struct sock *sk, struct sk_buff *skb)
  210. {
  211. struct pppox_sock *po = pppox_sk(sk);
  212. struct pptp_opt *opt = &po->proto.pptp;
  213. int headersize, payload_len, seq;
  214. __u8 *payload;
  215. struct pptp_gre_header *header;
  216. if (!(sk->sk_state & PPPOX_CONNECTED)) {
  217. if (sock_queue_rcv_skb(sk, skb))
  218. goto drop;
  219. return NET_RX_SUCCESS;
  220. }
  221. header = (struct pptp_gre_header *)(skb->data);
  222. headersize = sizeof(*header);
  223. /* test if acknowledgement present */
  224. if (GRE_IS_ACK(header->gre_hd.flags)) {
  225. __u32 ack;
  226. if (!pskb_may_pull(skb, headersize))
  227. goto drop;
  228. header = (struct pptp_gre_header *)(skb->data);
  229. /* ack in different place if S = 0 */
  230. ack = GRE_IS_SEQ(header->gre_hd.flags) ? header->ack : header->seq;
  231. ack = ntohl(ack);
  232. if (ack > opt->ack_recv)
  233. opt->ack_recv = ack;
  234. /* also handle sequence number wrap-around */
  235. if (WRAPPED(ack, opt->ack_recv))
  236. opt->ack_recv = ack;
  237. } else {
  238. headersize -= sizeof(header->ack);
  239. }
  240. /* test if payload present */
  241. if (!GRE_IS_SEQ(header->gre_hd.flags))
  242. goto drop;
  243. payload_len = ntohs(header->payload_len);
  244. seq = ntohl(header->seq);
  245. /* check for incomplete packet (length smaller than expected) */
  246. if (!pskb_may_pull(skb, headersize + payload_len))
  247. goto drop;
  248. payload = skb->data + headersize;
  249. /* check for expected sequence number */
  250. if (seq < opt->seq_recv + 1 || WRAPPED(opt->seq_recv, seq)) {
  251. if ((payload[0] == PPP_ALLSTATIONS) && (payload[1] == PPP_UI) &&
  252. (PPP_PROTOCOL(payload) == PPP_LCP) &&
  253. ((payload[4] == PPP_LCP_ECHOREQ) || (payload[4] == PPP_LCP_ECHOREP)))
  254. goto allow_packet;
  255. } else {
  256. opt->seq_recv = seq;
  257. allow_packet:
  258. skb_pull(skb, headersize);
  259. if (payload[0] == PPP_ALLSTATIONS && payload[1] == PPP_UI) {
  260. /* chop off address/control */
  261. if (skb->len < 3)
  262. goto drop;
  263. skb_pull(skb, 2);
  264. }
  265. skb->ip_summed = CHECKSUM_NONE;
  266. skb_set_network_header(skb, skb->head-skb->data);
  267. ppp_input(&po->chan, skb);
  268. return NET_RX_SUCCESS;
  269. }
  270. drop:
  271. kfree_skb(skb);
  272. return NET_RX_DROP;
  273. }
  274. static int pptp_rcv(struct sk_buff *skb)
  275. {
  276. struct pppox_sock *po;
  277. struct pptp_gre_header *header;
  278. struct iphdr *iph;
  279. if (skb->pkt_type != PACKET_HOST)
  280. goto drop;
  281. if (!pskb_may_pull(skb, 12))
  282. goto drop;
  283. iph = ip_hdr(skb);
  284. header = (struct pptp_gre_header *)skb->data;
  285. if (header->gre_hd.protocol != GRE_PROTO_PPP || /* PPTP-GRE protocol for PPTP */
  286. GRE_IS_CSUM(header->gre_hd.flags) || /* flag CSUM should be clear */
  287. GRE_IS_ROUTING(header->gre_hd.flags) || /* flag ROUTING should be clear */
  288. !GRE_IS_KEY(header->gre_hd.flags) || /* flag KEY should be set */
  289. (header->gre_hd.flags & GRE_FLAGS)) /* flag Recursion Ctrl should be clear */
  290. /* if invalid, discard this packet */
  291. goto drop;
  292. po = lookup_chan(htons(header->call_id), iph->saddr);
  293. if (po) {
  294. skb_dst_drop(skb);
  295. nf_reset_ct(skb);
  296. return sk_receive_skb(sk_pppox(po), skb, 0);
  297. }
  298. drop:
  299. kfree_skb(skb);
  300. return NET_RX_DROP;
  301. }
  302. static int pptp_bind(struct socket *sock, struct sockaddr *uservaddr,
  303. int sockaddr_len)
  304. {
  305. struct sock *sk = sock->sk;
  306. struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
  307. struct pppox_sock *po = pppox_sk(sk);
  308. int error = 0;
  309. if (sockaddr_len < sizeof(struct sockaddr_pppox))
  310. return -EINVAL;
  311. lock_sock(sk);
  312. if (sk->sk_state & PPPOX_DEAD) {
  313. error = -EALREADY;
  314. goto out;
  315. }
  316. if (sk->sk_state & PPPOX_BOUND) {
  317. error = -EBUSY;
  318. goto out;
  319. }
  320. if (add_chan(po, &sp->sa_addr.pptp))
  321. error = -EBUSY;
  322. else
  323. sk->sk_state |= PPPOX_BOUND;
  324. out:
  325. release_sock(sk);
  326. return error;
  327. }
  328. static int pptp_connect(struct socket *sock, struct sockaddr *uservaddr,
  329. int sockaddr_len, int flags)
  330. {
  331. struct sock *sk = sock->sk;
  332. struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
  333. struct pppox_sock *po = pppox_sk(sk);
  334. struct pptp_opt *opt = &po->proto.pptp;
  335. struct rtable *rt;
  336. struct flowi4 fl4;
  337. int error = 0;
  338. if (sockaddr_len < sizeof(struct sockaddr_pppox))
  339. return -EINVAL;
  340. if (sp->sa_protocol != PX_PROTO_PPTP)
  341. return -EINVAL;
  342. if (lookup_chan_dst(sp->sa_addr.pptp.call_id, sp->sa_addr.pptp.sin_addr.s_addr))
  343. return -EALREADY;
  344. lock_sock(sk);
  345. /* Check for already bound sockets */
  346. if (sk->sk_state & PPPOX_CONNECTED) {
  347. error = -EBUSY;
  348. goto end;
  349. }
  350. /* Check for already disconnected sockets, on attempts to disconnect */
  351. if (sk->sk_state & PPPOX_DEAD) {
  352. error = -EALREADY;
  353. goto end;
  354. }
  355. if (!opt->src_addr.sin_addr.s_addr || !sp->sa_addr.pptp.sin_addr.s_addr) {
  356. error = -EINVAL;
  357. goto end;
  358. }
  359. po->chan.private = sk;
  360. po->chan.ops = &pptp_chan_ops;
  361. rt = ip_route_output_ports(sock_net(sk), &fl4, sk,
  362. opt->dst_addr.sin_addr.s_addr,
  363. opt->src_addr.sin_addr.s_addr,
  364. 0, 0,
  365. IPPROTO_GRE, RT_CONN_FLAGS(sk),
  366. sk->sk_bound_dev_if);
  367. if (IS_ERR(rt)) {
  368. error = -EHOSTUNREACH;
  369. goto end;
  370. }
  371. sk_setup_caps(sk, &rt->dst);
  372. po->chan.mtu = dst_mtu(&rt->dst);
  373. if (!po->chan.mtu)
  374. po->chan.mtu = PPP_MRU;
  375. po->chan.mtu -= PPTP_HEADER_OVERHEAD;
  376. po->chan.hdrlen = 2 + sizeof(struct pptp_gre_header);
  377. error = ppp_register_channel(&po->chan);
  378. if (error) {
  379. pr_err("PPTP: failed to register PPP channel (%d)\n", error);
  380. goto end;
  381. }
  382. opt->dst_addr = sp->sa_addr.pptp;
  383. sk->sk_state |= PPPOX_CONNECTED;
  384. end:
  385. release_sock(sk);
  386. return error;
  387. }
  388. static int pptp_getname(struct socket *sock, struct sockaddr *uaddr,
  389. int peer)
  390. {
  391. int len = sizeof(struct sockaddr_pppox);
  392. struct sockaddr_pppox sp;
  393. memset(&sp.sa_addr, 0, sizeof(sp.sa_addr));
  394. sp.sa_family = AF_PPPOX;
  395. sp.sa_protocol = PX_PROTO_PPTP;
  396. sp.sa_addr.pptp = pppox_sk(sock->sk)->proto.pptp.src_addr;
  397. memcpy(uaddr, &sp, len);
  398. return len;
  399. }
  400. static int pptp_release(struct socket *sock)
  401. {
  402. struct sock *sk = sock->sk;
  403. struct pppox_sock *po;
  404. int error = 0;
  405. if (!sk)
  406. return 0;
  407. lock_sock(sk);
  408. if (sock_flag(sk, SOCK_DEAD)) {
  409. release_sock(sk);
  410. return -EBADF;
  411. }
  412. po = pppox_sk(sk);
  413. del_chan(po);
  414. synchronize_rcu();
  415. pppox_unbind_sock(sk);
  416. sk->sk_state = PPPOX_DEAD;
  417. sock_orphan(sk);
  418. sock->sk = NULL;
  419. release_sock(sk);
  420. sock_put(sk);
  421. return error;
  422. }
  423. static void pptp_sock_destruct(struct sock *sk)
  424. {
  425. if (!(sk->sk_state & PPPOX_DEAD)) {
  426. del_chan(pppox_sk(sk));
  427. pppox_unbind_sock(sk);
  428. }
  429. skb_queue_purge(&sk->sk_receive_queue);
  430. dst_release(rcu_dereference_protected(sk->sk_dst_cache, 1));
  431. }
  432. static int pptp_create(struct net *net, struct socket *sock, int kern)
  433. {
  434. int error = -ENOMEM;
  435. struct sock *sk;
  436. struct pppox_sock *po;
  437. struct pptp_opt *opt;
  438. sk = sk_alloc(net, PF_PPPOX, GFP_KERNEL, &pptp_sk_proto, kern);
  439. if (!sk)
  440. goto out;
  441. sock_init_data(sock, sk);
  442. sock->state = SS_UNCONNECTED;
  443. sock->ops = &pptp_ops;
  444. sk->sk_backlog_rcv = pptp_rcv_core;
  445. sk->sk_state = PPPOX_NONE;
  446. sk->sk_type = SOCK_STREAM;
  447. sk->sk_family = PF_PPPOX;
  448. sk->sk_protocol = PX_PROTO_PPTP;
  449. sk->sk_destruct = pptp_sock_destruct;
  450. po = pppox_sk(sk);
  451. opt = &po->proto.pptp;
  452. opt->seq_sent = 0; opt->seq_recv = 0xffffffff;
  453. opt->ack_recv = 0; opt->ack_sent = 0xffffffff;
  454. error = 0;
  455. out:
  456. return error;
  457. }
  458. static int pptp_ppp_ioctl(struct ppp_channel *chan, unsigned int cmd,
  459. unsigned long arg)
  460. {
  461. struct sock *sk = (struct sock *) chan->private;
  462. struct pppox_sock *po = pppox_sk(sk);
  463. struct pptp_opt *opt = &po->proto.pptp;
  464. void __user *argp = (void __user *)arg;
  465. int __user *p = argp;
  466. int err, val;
  467. err = -EFAULT;
  468. switch (cmd) {
  469. case PPPIOCGFLAGS:
  470. val = opt->ppp_flags;
  471. if (put_user(val, p))
  472. break;
  473. err = 0;
  474. break;
  475. case PPPIOCSFLAGS:
  476. if (get_user(val, p))
  477. break;
  478. opt->ppp_flags = val & ~SC_RCV_BITS;
  479. err = 0;
  480. break;
  481. default:
  482. err = -ENOTTY;
  483. }
  484. return err;
  485. }
  486. static const struct ppp_channel_ops pptp_chan_ops = {
  487. .start_xmit = pptp_xmit,
  488. .ioctl = pptp_ppp_ioctl,
  489. };
  490. static struct proto pptp_sk_proto __read_mostly = {
  491. .name = "PPTP",
  492. .owner = THIS_MODULE,
  493. .obj_size = sizeof(struct pppox_sock),
  494. };
  495. static const struct proto_ops pptp_ops = {
  496. .family = AF_PPPOX,
  497. .owner = THIS_MODULE,
  498. .release = pptp_release,
  499. .bind = pptp_bind,
  500. .connect = pptp_connect,
  501. .socketpair = sock_no_socketpair,
  502. .accept = sock_no_accept,
  503. .getname = pptp_getname,
  504. .listen = sock_no_listen,
  505. .shutdown = sock_no_shutdown,
  506. .sendmsg = sock_no_sendmsg,
  507. .recvmsg = sock_no_recvmsg,
  508. .mmap = sock_no_mmap,
  509. .ioctl = pppox_ioctl,
  510. #ifdef CONFIG_COMPAT
  511. .compat_ioctl = pppox_compat_ioctl,
  512. #endif
  513. };
  514. static const struct pppox_proto pppox_pptp_proto = {
  515. .create = pptp_create,
  516. .owner = THIS_MODULE,
  517. };
  518. static const struct gre_protocol gre_pptp_protocol = {
  519. .handler = pptp_rcv,
  520. };
  521. static int __init pptp_init_module(void)
  522. {
  523. int err = 0;
  524. pr_info("PPTP driver version " PPTP_DRIVER_VERSION "\n");
  525. callid_sock = vzalloc(array_size(sizeof(void *), (MAX_CALLID + 1)));
  526. if (!callid_sock)
  527. return -ENOMEM;
  528. err = gre_add_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
  529. if (err) {
  530. pr_err("PPTP: can't add gre protocol\n");
  531. goto out_mem_free;
  532. }
  533. err = proto_register(&pptp_sk_proto, 0);
  534. if (err) {
  535. pr_err("PPTP: can't register sk_proto\n");
  536. goto out_gre_del_protocol;
  537. }
  538. err = register_pppox_proto(PX_PROTO_PPTP, &pppox_pptp_proto);
  539. if (err) {
  540. pr_err("PPTP: can't register pppox_proto\n");
  541. goto out_unregister_sk_proto;
  542. }
  543. return 0;
  544. out_unregister_sk_proto:
  545. proto_unregister(&pptp_sk_proto);
  546. out_gre_del_protocol:
  547. gre_del_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
  548. out_mem_free:
  549. vfree(callid_sock);
  550. return err;
  551. }
  552. static void __exit pptp_exit_module(void)
  553. {
  554. unregister_pppox_proto(PX_PROTO_PPTP);
  555. proto_unregister(&pptp_sk_proto);
  556. gre_del_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
  557. vfree(callid_sock);
  558. }
  559. module_init(pptp_init_module);
  560. module_exit(pptp_exit_module);
  561. MODULE_DESCRIPTION("Point-to-Point Tunneling Protocol");
  562. MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
  563. MODULE_LICENSE("GPL");
  564. MODULE_ALIAS_NET_PF_PROTO(PF_PPPOX, PX_PROTO_PPTP);