projects / openwrt / staging / yousong.git / blob
? search:


b635f41a17291a33f2d5e8dd569813f6c58ed0f6
[openwrt/staging/yousong.git] / target / linux / generic-2.4 / patches / 603-netfilter_nat_pptp.patch
1 Index: linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack.h
2 ===================================================================
3 --- linux-2.4.35.4.orig/include/linux/netfilter_ipv4/ip_conntrack.h
4 +++ linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack.h
5 @@ -50,16 +50,19 @@ enum ip_conntrack_status {
6
7 #include <linux/netfilter_ipv4/ip_conntrack_tcp.h>
8 #include <linux/netfilter_ipv4/ip_conntrack_icmp.h>
9 +#include <linux/netfilter_ipv4/ip_conntrack_proto_gre.h>
10
11 /* per conntrack: protocol private data */
12 union ip_conntrack_proto {
13 /* insert conntrack proto private data here */
14 struct ip_ct_tcp tcp;
15 struct ip_ct_icmp icmp;
16 + struct ip_ct_gre gre;
17 };
18
19 union ip_conntrack_expect_proto {
20 /* insert expect proto private data here */
21 + struct ip_ct_gre_expect gre;
22 };
23
24 /* Add protocol helper include file here */
25 @@ -67,6 +70,7 @@ union ip_conntrack_expect_proto {
26
27 #include <linux/netfilter_ipv4/ip_conntrack_ftp.h>
28 #include <linux/netfilter_ipv4/ip_conntrack_irc.h>
29 +#include <linux/netfilter_ipv4/ip_conntrack_pptp.h>
30
31 /* per expectation: application helper private data */
32 union ip_conntrack_expect_help {
33 @@ -74,6 +78,7 @@ union ip_conntrack_expect_help {
34 struct ip_ct_amanda_expect exp_amanda_info;
35 struct ip_ct_ftp_expect exp_ftp_info;
36 struct ip_ct_irc_expect exp_irc_info;
37 + struct ip_ct_pptp_expect exp_pptp_info;
38
39 #ifdef CONFIG_IP_NF_NAT_NEEDED
40 union {
41 @@ -87,14 +92,17 @@ union ip_conntrack_help {
42 /* insert conntrack helper private data (master) here */
43 struct ip_ct_ftp_master ct_ftp_info;
44 struct ip_ct_irc_master ct_irc_info;
45 + struct ip_ct_pptp_master ct_pptp_info;
46 };
47
48 #ifdef CONFIG_IP_NF_NAT_NEEDED
49 #include <linux/netfilter_ipv4/ip_nat.h>
50 +#include <linux/netfilter_ipv4/ip_nat_pptp.h>
51
52 /* per conntrack: nat application helper private data */
53 union ip_conntrack_nat_help {
54 /* insert nat helper private data here */
55 + struct ip_nat_pptp nat_pptp_info;
56 };
57 #endif
58
59 Index: linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack_pptp.h
60 ===================================================================
61 --- /dev/null
62 +++ linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack_pptp.h
63 @@ -0,0 +1,313 @@
64 +/* PPTP constants and structs */
65 +#ifndef _CONNTRACK_PPTP_H
66 +#define _CONNTRACK_PPTP_H
67 +
68 +/* state of the control session */
69 +enum pptp_ctrlsess_state {
70 + PPTP_SESSION_NONE, /* no session present */
71 + PPTP_SESSION_ERROR, /* some session error */
72 + PPTP_SESSION_STOPREQ, /* stop_sess request seen */
73 + PPTP_SESSION_REQUESTED, /* start_sess request seen */
74 + PPTP_SESSION_CONFIRMED, /* session established */
75 +};
76 +
77 +/* state of the call inside the control session */
78 +enum pptp_ctrlcall_state {
79 + PPTP_CALL_NONE,
80 + PPTP_CALL_ERROR,
81 + PPTP_CALL_OUT_REQ,
82 + PPTP_CALL_OUT_CONF,
83 + PPTP_CALL_IN_REQ,
84 + PPTP_CALL_IN_REP,
85 + PPTP_CALL_IN_CONF,
86 + PPTP_CALL_CLEAR_REQ,
87 +};
88 +
89 +
90 +/* conntrack private data */
91 +struct ip_ct_pptp_master {
92 + enum pptp_ctrlsess_state sstate; /* session state */
93 +
94 + /* everything below is going to be per-expectation in newnat,
95 + * since there could be more than one call within one session */
96 + enum pptp_ctrlcall_state cstate; /* call state */
97 + u_int16_t pac_call_id; /* call id of PAC, host byte order */
98 + u_int16_t pns_call_id; /* call id of PNS, host byte order */
99 +};
100 +
101 +/* conntrack_expect private member */
102 +struct ip_ct_pptp_expect {
103 + enum pptp_ctrlcall_state cstate; /* call state */
104 + u_int16_t pac_call_id; /* call id of PAC */
105 + u_int16_t pns_call_id; /* call id of PNS */
106 +};
107 +
108 +
109 +#ifdef __KERNEL__
110 +
111 +#include <linux/netfilter_ipv4/lockhelp.h>
112 +DECLARE_LOCK_EXTERN(ip_pptp_lock);
113 +
114 +#define IP_CONNTR_PPTP PPTP_CONTROL_PORT
115 +
116 +union pptp_ctrl_union {
117 + void *rawreq;
118 + struct PptpStartSessionRequest *sreq;
119 + struct PptpStartSessionReply *srep;
120 + struct PptpStopSessionRequest *streq;
121 + struct PptpStopSessionReply *strep;
122 + struct PptpOutCallRequest *ocreq;
123 + struct PptpOutCallReply *ocack;
124 + struct PptpInCallRequest *icreq;
125 + struct PptpInCallReply *icack;
126 + struct PptpInCallConnected *iccon;
127 + struct PptpClearCallRequest *clrreq;
128 + struct PptpCallDisconnectNotify *disc;
129 + struct PptpWanErrorNotify *wanerr;
130 + struct PptpSetLinkInfo *setlink;
131 +};
132 +
133 +
134 +
135 +#define PPTP_CONTROL_PORT 1723
136 +
137 +#define PPTP_PACKET_CONTROL 1
138 +#define PPTP_PACKET_MGMT 2
139 +
140 +#define PPTP_MAGIC_COOKIE 0x1a2b3c4d
141 +
142 +struct pptp_pkt_hdr {
143 + __u16 packetLength;
144 + __u16 packetType;
145 + __u32 magicCookie;
146 +};
147 +
148 +/* PptpControlMessageType values */
149 +#define PPTP_START_SESSION_REQUEST 1
150 +#define PPTP_START_SESSION_REPLY 2
151 +#define PPTP_STOP_SESSION_REQUEST 3
152 +#define PPTP_STOP_SESSION_REPLY 4
153 +#define PPTP_ECHO_REQUEST 5
154 +#define PPTP_ECHO_REPLY 6
155 +#define PPTP_OUT_CALL_REQUEST 7
156 +#define PPTP_OUT_CALL_REPLY 8
157 +#define PPTP_IN_CALL_REQUEST 9
158 +#define PPTP_IN_CALL_REPLY 10
159 +#define PPTP_IN_CALL_CONNECT 11
160 +#define PPTP_CALL_CLEAR_REQUEST 12
161 +#define PPTP_CALL_DISCONNECT_NOTIFY 13
162 +#define PPTP_WAN_ERROR_NOTIFY 14
163 +#define PPTP_SET_LINK_INFO 15
164 +
165 +#define PPTP_MSG_MAX 15
166 +
167 +/* PptpGeneralError values */
168 +#define PPTP_ERROR_CODE_NONE 0
169 +#define PPTP_NOT_CONNECTED 1
170 +#define PPTP_BAD_FORMAT 2
171 +#define PPTP_BAD_VALUE 3
172 +#define PPTP_NO_RESOURCE 4
173 +#define PPTP_BAD_CALLID 5
174 +#define PPTP_REMOVE_DEVICE_ERROR 6
175 +
176 +struct PptpControlHeader {
177 + __u16 messageType;
178 + __u16 reserved;
179 +};
180 +
181 +/* FramingCapability Bitmap Values */
182 +#define PPTP_FRAME_CAP_ASYNC 0x1
183 +#define PPTP_FRAME_CAP_SYNC 0x2
184 +
185 +/* BearerCapability Bitmap Values */
186 +#define PPTP_BEARER_CAP_ANALOG 0x1
187 +#define PPTP_BEARER_CAP_DIGITAL 0x2
188 +
189 +struct PptpStartSessionRequest {
190 + __u16 protocolVersion;
191 + __u8 reserved1;
192 + __u8 reserved2;
193 + __u32 framingCapability;
194 + __u32 bearerCapability;
195 + __u16 maxChannels;
196 + __u16 firmwareRevision;
197 + __u8 hostName[64];
198 + __u8 vendorString[64];
199 +};
200 +
201 +/* PptpStartSessionResultCode Values */
202 +#define PPTP_START_OK 1
203 +#define PPTP_START_GENERAL_ERROR 2
204 +#define PPTP_START_ALREADY_CONNECTED 3
205 +#define PPTP_START_NOT_AUTHORIZED 4
206 +#define PPTP_START_UNKNOWN_PROTOCOL 5
207 +
208 +struct PptpStartSessionReply {
209 + __u16 protocolVersion;
210 + __u8 resultCode;
211 + __u8 generalErrorCode;
212 + __u32 framingCapability;
213 + __u32 bearerCapability;
214 + __u16 maxChannels;
215 + __u16 firmwareRevision;
216 + __u8 hostName[64];
217 + __u8 vendorString[64];
218 +};
219 +
220 +/* PptpStopReasons */
221 +#define PPTP_STOP_NONE 1
222 +#define PPTP_STOP_PROTOCOL 2
223 +#define PPTP_STOP_LOCAL_SHUTDOWN 3
224 +
225 +struct PptpStopSessionRequest {
226 + __u8 reason;
227 +};
228 +
229 +/* PptpStopSessionResultCode */
230 +#define PPTP_STOP_OK 1
231 +#define PPTP_STOP_GENERAL_ERROR 2
232 +
233 +struct PptpStopSessionReply {
234 + __u8 resultCode;
235 + __u8 generalErrorCode;
236 +};
237 +
238 +struct PptpEchoRequest {
239 + __u32 identNumber;
240 +};
241 +
242 +/* PptpEchoReplyResultCode */
243 +#define PPTP_ECHO_OK 1
244 +#define PPTP_ECHO_GENERAL_ERROR 2
245 +
246 +struct PptpEchoReply {
247 + __u32 identNumber;
248 + __u8 resultCode;
249 + __u8 generalErrorCode;
250 + __u16 reserved;
251 +};
252 +
253 +/* PptpFramingType */
254 +#define PPTP_ASYNC_FRAMING 1
255 +#define PPTP_SYNC_FRAMING 2
256 +#define PPTP_DONT_CARE_FRAMING 3
257 +
258 +/* PptpCallBearerType */
259 +#define PPTP_ANALOG_TYPE 1
260 +#define PPTP_DIGITAL_TYPE 2
261 +#define PPTP_DONT_CARE_BEARER_TYPE 3
262 +
263 +struct PptpOutCallRequest {
264 + __u16 callID;
265 + __u16 callSerialNumber;
266 + __u32 minBPS;
267 + __u32 maxBPS;
268 + __u32 bearerType;
269 + __u32 framingType;
270 + __u16 packetWindow;
271 + __u16 packetProcDelay;
272 + __u16 reserved1;
273 + __u16 phoneNumberLength;
274 + __u16 reserved2;
275 + __u8 phoneNumber[64];
276 + __u8 subAddress[64];
277 +};
278 +
279 +/* PptpCallResultCode */
280 +#define PPTP_OUTCALL_CONNECT 1
281 +#define PPTP_OUTCALL_GENERAL_ERROR 2
282 +#define PPTP_OUTCALL_NO_CARRIER 3
283 +#define PPTP_OUTCALL_BUSY 4
284 +#define PPTP_OUTCALL_NO_DIAL_TONE 5
285 +#define PPTP_OUTCALL_TIMEOUT 6
286 +#define PPTP_OUTCALL_DONT_ACCEPT 7
287 +
288 +struct PptpOutCallReply {
289 + __u16 callID;
290 + __u16 peersCallID;
291 + __u8 resultCode;
292 + __u8 generalErrorCode;
293 + __u16 causeCode;
294 + __u32 connectSpeed;
295 + __u16 packetWindow;
296 + __u16 packetProcDelay;
297 + __u32 physChannelID;
298 +};
299 +
300 +struct PptpInCallRequest {
301 + __u16 callID;
302 + __u16 callSerialNumber;
303 + __u32 callBearerType;
304 + __u32 physChannelID;
305 + __u16 dialedNumberLength;
306 + __u16 dialingNumberLength;
307 + __u8 dialedNumber[64];
308 + __u8 dialingNumber[64];
309 + __u8 subAddress[64];
310 +};
311 +
312 +/* PptpInCallResultCode */
313 +#define PPTP_INCALL_ACCEPT 1
314 +#define PPTP_INCALL_GENERAL_ERROR 2
315 +#define PPTP_INCALL_DONT_ACCEPT 3
316 +
317 +struct PptpInCallReply {
318 + __u16 callID;
319 + __u16 peersCallID;
320 + __u8 resultCode;
321 + __u8 generalErrorCode;
322 + __u16 packetWindow;
323 + __u16 packetProcDelay;
324 + __u16 reserved;
325 +};
326 +
327 +struct PptpInCallConnected {
328 + __u16 peersCallID;
329 + __u16 reserved;
330 + __u32 connectSpeed;
331 + __u16 packetWindow;
332 + __u16 packetProcDelay;
333 + __u32 callFramingType;
334 +};
335 +
336 +struct PptpClearCallRequest {
337 + __u16 callID;
338 + __u16 reserved;
339 +};
340 +
341 +struct PptpCallDisconnectNotify {
342 + __u16 callID;
343 + __u8 resultCode;
344 + __u8 generalErrorCode;
345 + __u16 causeCode;
346 + __u16 reserved;
347 + __u8 callStatistics[128];
348 +};
349 +
350 +struct PptpWanErrorNotify {
351 + __u16 peersCallID;
352 + __u16 reserved;
353 + __u32 crcErrors;
354 + __u32 framingErrors;
355 + __u32 hardwareOverRuns;
356 + __u32 bufferOverRuns;
357 + __u32 timeoutErrors;
358 + __u32 alignmentErrors;
359 +};
360 +
361 +struct PptpSetLinkInfo {
362 + __u16 peersCallID;
363 + __u16 reserved;
364 + __u32 sendAccm;
365 + __u32 recvAccm;
366 +};
367 +
368 +
369 +struct pptp_priv_data {
370 + __u16 call_id;
371 + __u16 mcall_id;
372 + __u16 pcall_id;
373 +};
374 +
375 +#endif /* __KERNEL__ */
376 +#endif /* _CONNTRACK_PPTP_H */
377 Index: linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack_proto_gre.h
378 ===================================================================
379 --- /dev/null
380 +++ linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack_proto_gre.h
381 @@ -0,0 +1,123 @@
382 +#ifndef _CONNTRACK_PROTO_GRE_H
383 +#define _CONNTRACK_PROTO_GRE_H
384 +#include <asm/byteorder.h>
385 +
386 +/* GRE PROTOCOL HEADER */
387 +
388 +/* GRE Version field */
389 +#define GRE_VERSION_1701 0x0
390 +#define GRE_VERSION_PPTP 0x1
391 +
392 +/* GRE Protocol field */
393 +#define GRE_PROTOCOL_PPTP 0x880B
394 +
395 +/* GRE Flags */
396 +#define GRE_FLAG_C 0x80
397 +#define GRE_FLAG_R 0x40
398 +#define GRE_FLAG_K 0x20
399 +#define GRE_FLAG_S 0x10
400 +#define GRE_FLAG_A 0x80
401 +
402 +#define GRE_IS_C(f) ((f)&GRE_FLAG_C)
403 +#define GRE_IS_R(f) ((f)&GRE_FLAG_R)
404 +#define GRE_IS_K(f) ((f)&GRE_FLAG_K)
405 +#define GRE_IS_S(f) ((f)&GRE_FLAG_S)
406 +#define GRE_IS_A(f) ((f)&GRE_FLAG_A)
407 +
408 +/* GRE is a mess: Four different standards */
409 +struct gre_hdr {
410 +#if defined(__LITTLE_ENDIAN_BITFIELD)
411 + __u16 rec:3,
412 + srr:1,
413 + seq:1,
414 + key:1,
415 + routing:1,
416 + csum:1,
417 + version:3,
418 + reserved:4,
419 + ack:1;
420 +#elif defined(__BIG_ENDIAN_BITFIELD)
421 + __u16 csum:1,
422 + routing:1,
423 + key:1,
424 + seq:1,
425 + srr:1,
426 + rec:3,
427 + ack:1,
428 + reserved:4,
429 + version:3;
430 +#else
431 +#error "Adjust your <asm/byteorder.h> defines"
432 +#endif
433 + __u16 protocol;
434 +};
435 +
436 +/* modified GRE header for PPTP */
437 +struct gre_hdr_pptp {
438 + __u8 flags; /* bitfield */
439 + __u8 version; /* should be GRE_VERSION_PPTP */
440 + __u16 protocol; /* should be GRE_PROTOCOL_PPTP */
441 + __u16 payload_len; /* size of ppp payload, not inc. gre header */
442 + __u16 call_id; /* peer's call_id for this session */
443 + __u32 seq; /* sequence number. Present if S==1 */
444 + __u32 ack; /* seq number of highest packet recieved by */
445 + /* sender in this session */
446 +};
447 +
448 +
449 +/* this is part of ip_conntrack */
450 +struct ip_ct_gre {
451 + unsigned int stream_timeout;
452 + unsigned int timeout;
453 +};
454 +
455 +/* this is part of ip_conntrack_expect */
456 +struct ip_ct_gre_expect {
457 + struct ip_ct_gre_keymap *keymap_orig, *keymap_reply;
458 +};
459 +
460 +#ifdef __KERNEL__
461 +struct ip_conntrack_expect;
462 +
463 +/* structure for original <-> reply keymap */
464 +struct ip_ct_gre_keymap {
465 + struct list_head list;
466 +
467 + struct ip_conntrack_tuple tuple;
468 +};
469 +
470 +
471 +/* add new tuple->key_reply pair to keymap */
472 +int ip_ct_gre_keymap_add(struct ip_conntrack_expect *exp,
473 + struct ip_conntrack_tuple *t,
474 + int reply);
475 +
476 +/* change an existing keymap entry */
477 +void ip_ct_gre_keymap_change(struct ip_ct_gre_keymap *km,
478 + struct ip_conntrack_tuple *t);
479 +
480 +/* delete keymap entries */
481 +void ip_ct_gre_keymap_destroy(struct ip_conntrack_expect *exp);
482 +
483 +
484 +/* get pointer to gre key, if present */
485 +static inline u_int32_t *gre_key(struct gre_hdr *greh)
486 +{
487 + if (!greh->key)
488 + return NULL;
489 + if (greh->csum || greh->routing)
490 + return (u_int32_t *) (greh+sizeof(*greh)+4);
491 + return (u_int32_t *) (greh+sizeof(*greh));
492 +}
493 +
494 +/* get pointer ot gre csum, if present */
495 +static inline u_int16_t *gre_csum(struct gre_hdr *greh)
496 +{
497 + if (!greh->csum)
498 + return NULL;
499 + return (u_int16_t *) (greh+sizeof(*greh));
500 +}
501 +
502 +#endif /* __KERNEL__ */
503 +
504 +#endif /* _CONNTRACK_PROTO_GRE_H */
505 Index: linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
506 ===================================================================
507 --- linux-2.4.35.4.orig/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
508 +++ linux-2.4.35.4/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
509 @@ -14,7 +14,7 @@
510 union ip_conntrack_manip_proto
511 {
512 /* Add other protocols here. */
513 - u_int16_t all;
514 + u_int32_t all;
515
516 struct {
517 u_int16_t port;
518 @@ -25,6 +25,9 @@ union ip_conntrack_manip_proto
519 struct {
520 u_int16_t id;
521 } icmp;
522 + struct {
523 + u_int32_t key;
524 + } gre;
525 };
526
527 /* The manipulable part of the tuple. */
528 @@ -44,7 +47,7 @@ struct ip_conntrack_tuple
529 u_int32_t ip;
530 union {
531 /* Add other protocols here. */
532 - u_int16_t all;
533 + u_int32_t all;
534
535 struct {
536 u_int16_t port;
537 @@ -55,6 +58,9 @@ struct ip_conntrack_tuple
538 struct {
539 u_int8_t type, code;
540 } icmp;
541 + struct {
542 + u_int32_t key;
543 + } gre;
544 } u;
545
546 /* The protocol. */
547 @@ -80,10 +86,16 @@ enum ip_conntrack_dir
548 #ifdef __KERNEL__
549
550 #define DUMP_TUPLE(tp) \
551 -DEBUGP("tuple %p: %u %u.%u.%u.%u:%hu -> %u.%u.%u.%u:%hu\n", \
552 +DEBUGP("tuple %p: %u %u.%u.%u.%u:%u -> %u.%u.%u.%u:%u\n", \
553 (tp), (tp)->dst.protonum, \
554 - NIPQUAD((tp)->src.ip), ntohs((tp)->src.u.all), \
555 - NIPQUAD((tp)->dst.ip), ntohs((tp)->dst.u.all))
556 + NIPQUAD((tp)->src.ip), ntohl((tp)->src.u.all), \
557 + NIPQUAD((tp)->dst.ip), ntohl((tp)->dst.u.all))
558 +
559 +#define DUMP_TUPLE_RAW(x) \
560 + DEBUGP("tuple %p: %u %u.%u.%u.%u:0x%08x -> %u.%u.%u.%u:0x%08x\n",\
561 + (x), (x)->dst.protonum, \
562 + NIPQUAD((x)->src.ip), ntohl((x)->src.u.all), \
563 + NIPQUAD((x)->dst.ip), ntohl((x)->dst.u.all))
564
565 #define CTINFO2DIR(ctinfo) ((ctinfo) >= IP_CT_IS_REPLY ? IP_CT_DIR_REPLY : IP_CT_DIR_ORIGINAL)
566
567 Index: linux-2.4.35.4/include/linux/netfilter_ipv4/ip_nat_pptp.h
568 ===================================================================
569 --- /dev/null
570 +++ linux-2.4.35.4/include/linux/netfilter_ipv4/ip_nat_pptp.h
571 @@ -0,0 +1,11 @@
572 +/* PPTP constants and structs */
573 +#ifndef _NAT_PPTP_H
574 +#define _NAT_PPTP_H
575 +
576 +/* conntrack private data */
577 +struct ip_nat_pptp {
578 + u_int16_t pns_call_id; /* NAT'ed PNS call id */
579 + u_int16_t pac_call_id; /* NAT'ed PAC call id */
580 +};
581 +
582 +#endif /* _NAT_PPTP_H */
583 Index: linux-2.4.35.4/net/ipv4/netfilter/Config.in
584 ===================================================================
585 --- linux-2.4.35.4.orig/net/ipv4/netfilter/Config.in
586 +++ linux-2.4.35.4/net/ipv4/netfilter/Config.in
587 @@ -10,6 +10,8 @@ if [ "$CONFIG_IP_NF_CONNTRACK" != "n" ];
588 dep_tristate ' Amanda protocol support' CONFIG_IP_NF_AMANDA $CONFIG_IP_NF_CONNTRACK
589 dep_tristate ' TFTP protocol support' CONFIG_IP_NF_TFTP $CONFIG_IP_NF_CONNTRACK
590 dep_tristate ' IRC protocol support' CONFIG_IP_NF_IRC $CONFIG_IP_NF_CONNTRACK
591 + dep_tristate ' GRE protocol support' CONFIG_IP_NF_CT_PROTO_GRE $CONFIG_IP_NF_CONNTRACK
592 + dep_tristate ' PPTP protocol support' CONFIG_IP_NF_PPTP $CONFIG_IP_NF_CT_PROTO_GRE
593 fi
594
595 if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
596 @@ -63,6 +65,20 @@ if [ "$CONFIG_IP_NF_IPTABLES" != "n" ];
597 define_bool CONFIG_IP_NF_NAT_NEEDED y
598 dep_tristate ' MASQUERADE target support' CONFIG_IP_NF_TARGET_MASQUERADE $CONFIG_IP_NF_NAT
599 dep_tristate ' REDIRECT target support' CONFIG_IP_NF_TARGET_REDIRECT $CONFIG_IP_NF_NAT
600 + if [ "$CONFIG_IP_NF_PPTP" = "m" ]; then
601 + define_tristate CONFIG_IP_NF_NAT_PPTP m
602 + else
603 + if [ "$CONFIG_IP_NF_PPTP" = "y" ]; then
604 + define_tristate CONFIG_IP_NF_NAT_PPTP $CONFIG_IP_NF_NAT
605 + fi
606 + fi
607 + if [ "$CONFIG_IP_NF_CT_PROTO_GRE" = "m" ]; then
608 + define_tristate CONFIG_IP_NF_NAT_PROTO_GRE m
609 + else
610 + if [ "$CONFIG_IP_NF_CT_PROTO_GRE" = "y" ]; then
611 + define_tristate CONFIG_IP_NF_NAT_PROTO_GRE $CONFIG_IP_NF_NAT
612 + fi
613 + fi
614 if [ "$CONFIG_IP_NF_AMANDA" = "m" ]; then
615 define_tristate CONFIG_IP_NF_NAT_AMANDA m
616 else
617 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_core.c
618 ===================================================================
619 --- linux-2.4.35.4.orig/net/ipv4/netfilter/ip_conntrack_core.c
620 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_core.c
621 @@ -143,6 +143,8 @@ ip_ct_get_tuple(const struct iphdr *iph,
622 tuple->dst.ip = iph->daddr;
623 tuple->dst.protonum = iph->protocol;
624
625 + tuple->src.u.all = tuple->dst.u.all = 0;
626 +
627 ret = protocol->pkt_to_tuple((u_int32_t *)iph + iph->ihl,
628 len - 4*iph->ihl,
629 tuple);
630 @@ -158,6 +160,8 @@ invert_tuple(struct ip_conntrack_tuple *
631 inverse->dst.ip = orig->src.ip;
632 inverse->dst.protonum = orig->dst.protonum;
633
634 + inverse->src.u.all = inverse->dst.u.all = 0;
635 +
636 return protocol->invert_tuple(inverse, orig);
637 }
638
639 @@ -970,8 +974,8 @@ int ip_conntrack_expect_related(struct i
640 * so there is no need to use the tuple lock too */
641
642 DEBUGP("ip_conntrack_expect_related %p\n", related_to);
643 - DEBUGP("tuple: "); DUMP_TUPLE(&expect->tuple);
644 - DEBUGP("mask: "); DUMP_TUPLE(&expect->mask);
645 + DEBUGP("tuple: "); DUMP_TUPLE_RAW(&expect->tuple);
646 + DEBUGP("mask: "); DUMP_TUPLE_RAW(&expect->mask);
647
648 old = LIST_FIND(&ip_conntrack_expect_list, resent_expect,
649 struct ip_conntrack_expect *, &expect->tuple,
650 @@ -1089,15 +1093,14 @@ int ip_conntrack_change_expect(struct ip
651
652 MUST_BE_READ_LOCKED(&ip_conntrack_lock);
653 WRITE_LOCK(&ip_conntrack_expect_tuple_lock);
654 -
655 DEBUGP("change_expect:\n");
656 - DEBUGP("exp tuple: "); DUMP_TUPLE(&expect->tuple);
657 - DEBUGP("exp mask: "); DUMP_TUPLE(&expect->mask);
658 - DEBUGP("newtuple: "); DUMP_TUPLE(newtuple);
659 + DEBUGP("exp tuple: "); DUMP_TUPLE_RAW(&expect->tuple);
660 + DEBUGP("exp mask: "); DUMP_TUPLE_RAW(&expect->mask);
661 + DEBUGP("newtuple: "); DUMP_TUPLE_RAW(newtuple);
662 if (expect->ct_tuple.dst.protonum == 0) {
663 /* Never seen before */
664 DEBUGP("change expect: never seen before\n");
665 - if (!ip_ct_tuple_equal(&expect->tuple, newtuple)
666 + if (!ip_ct_tuple_mask_cmp(&expect->tuple, newtuple, &expect->mask)
667 && LIST_FIND(&ip_conntrack_expect_list, expect_clash,
668 struct ip_conntrack_expect *, newtuple, &expect->mask)) {
669 /* Force NAT to find an unused tuple */
670 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_pptp_priv.h
671 ===================================================================
672 --- /dev/null
673 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_pptp_priv.h
674 @@ -0,0 +1,24 @@
675 +#ifndef _IP_CT_PPTP_PRIV_H
676 +#define _IP_CT_PPTP_PRIV_H
677 +
678 +/* PptpControlMessageType names */
679 +static const char *strMName[] = {
680 + "UNKNOWN_MESSAGE",
681 + "START_SESSION_REQUEST",
682 + "START_SESSION_REPLY",
683 + "STOP_SESSION_REQUEST",
684 + "STOP_SESSION_REPLY",
685 + "ECHO_REQUEST",
686 + "ECHO_REPLY",
687 + "OUT_CALL_REQUEST",
688 + "OUT_CALL_REPLY",
689 + "IN_CALL_REQUEST",
690 + "IN_CALL_REPLY",
691 + "IN_CALL_CONNECT",
692 + "CALL_CLEAR_REQUEST",
693 + "CALL_DISCONNECT_NOTIFY",
694 + "WAN_ERROR_NOTIFY",
695 + "SET_LINK_INFO"
696 +};
697 +
698 +#endif
699 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_proto_gre.c
700 ===================================================================
701 --- /dev/null
702 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_proto_gre.c
703 @@ -0,0 +1,333 @@
704 +/*
705 + * ip_conntrack_proto_gre.c - Version 1.2
706 + *
707 + * Connection tracking protocol helper module for GRE.
708 + *
709 + * GRE is a generic encapsulation protocol, which is generally not very
710 + * suited for NAT, as it has no protocol-specific part as port numbers.
711 + *
712 + * It has an optional key field, which may help us distinguishing two
713 + * connections between the same two hosts.
714 + *
715 + * GRE is defined in RFC 1701 and RFC 1702, as well as RFC 2784
716 + *
717 + * PPTP is built on top of a modified version of GRE, and has a mandatory
718 + * field called "CallID", which serves us for the same purpose as the key
719 + * field in plain GRE.
720 + *
721 + * Documentation about PPTP can be found in RFC 2637
722 + *
723 + * (C) 2000-2003 by Harald Welte <laforge@gnumonks.org>
724 + *
725 + * Development of this code funded by Astaro AG (http://www.astaro.com/)
726 + *
727 + */
728 +
729 +#include <linux/config.h>
730 +#include <linux/module.h>
731 +#include <linux/types.h>
732 +#include <linux/timer.h>
733 +#include <linux/netfilter.h>
734 +#include <linux/ip.h>
735 +#include <linux/in.h>
736 +#include <linux/list.h>
737 +
738 +#include <linux/netfilter_ipv4/lockhelp.h>
739 +
740 +DECLARE_RWLOCK(ip_ct_gre_lock);
741 +#define ASSERT_READ_LOCK(x) MUST_BE_READ_LOCKED(&ip_ct_gre_lock)
742 +#define ASSERT_WRITE_LOCK(x) MUST_BE_WRITE_LOCKED(&ip_ct_gre_lock)
743 +
744 +#include <linux/netfilter_ipv4/listhelp.h>
745 +#include <linux/netfilter_ipv4/ip_conntrack_protocol.h>
746 +#include <linux/netfilter_ipv4/ip_conntrack_helper.h>
747 +#include <linux/netfilter_ipv4/ip_conntrack_core.h>
748 +
749 +#include <linux/netfilter_ipv4/ip_conntrack_proto_gre.h>
750 +#include <linux/netfilter_ipv4/ip_conntrack_pptp.h>
751 +
752 +MODULE_LICENSE("GPL");
753 +MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>");
754 +MODULE_DESCRIPTION("netfilter connection tracking protocol helper for GRE");
755 +
756 +/* shamelessly stolen from ip_conntrack_proto_udp.c */
757 +#define GRE_TIMEOUT (30*HZ)
758 +#define GRE_STREAM_TIMEOUT (180*HZ)
759 +
760 +#if 0
761 +#define DEBUGP(format, args...) printk(KERN_DEBUG __FILE__ ":" __FUNCTION__ \
762 + ": " format, ## args)
763 +#define DUMP_TUPLE_GRE(x) printk("%u.%u.%u.%u:0x%x -> %u.%u.%u.%u:0x%x:%u:0x%x\n", \
764 + NIPQUAD((x)->src.ip), ntohl((x)->src.u.gre.key), \
765 + NIPQUAD((x)->dst.ip), ntohl((x)->dst.u.gre.key))
766 +#else
767 +#define DEBUGP(x, args...)
768 +#define DUMP_TUPLE_GRE(x)
769 +#endif
770 +
771 +/* GRE KEYMAP HANDLING FUNCTIONS */
772 +static LIST_HEAD(gre_keymap_list);
773 +
774 +static inline int gre_key_cmpfn(const struct ip_ct_gre_keymap *km,
775 + const struct ip_conntrack_tuple *t)
776 +{
777 + return ((km->tuple.src.ip == t->src.ip) &&
778 + (km->tuple.dst.ip == t->dst.ip) &&
779 + (km->tuple.dst.protonum == t->dst.protonum) &&
780 + (km->tuple.dst.u.all == t->dst.u.all));
781 +}
782 +
783 +/* look up the source key for a given tuple */
784 +static u_int32_t gre_keymap_lookup(struct ip_conntrack_tuple *t)
785 +{
786 + struct ip_ct_gre_keymap *km;
787 + u_int32_t key;
788 +
789 + READ_LOCK(&ip_ct_gre_lock);
790 + km = LIST_FIND(&gre_keymap_list, gre_key_cmpfn,
791 + struct ip_ct_gre_keymap *, t);
792 + if (!km) {
793 + READ_UNLOCK(&ip_ct_gre_lock);
794 + return 0;
795 + }
796 +
797 + key = km->tuple.src.u.gre.key;
798 + READ_UNLOCK(&ip_ct_gre_lock);
799 +
800 + return key;
801 +}
802 +
803 +/* add a single keymap entry, associate with specified expect */
804 +int ip_ct_gre_keymap_add(struct ip_conntrack_expect *exp,
805 + struct ip_conntrack_tuple *t, int reply)
806 +{
807 + struct ip_ct_gre_keymap *km;
808 +
809 + km = kmalloc(sizeof(*km), GFP_ATOMIC);
810 + if (!km)
811 + return -1;
812 +
813 + /* initializing list head should be sufficient */
814 + memset(km, 0, sizeof(*km));
815 +
816 + memcpy(&km->tuple, t, sizeof(*t));
817 +
818 + if (!reply)
819 + exp->proto.gre.keymap_orig = km;
820 + else
821 + exp->proto.gre.keymap_reply = km;
822 +
823 + DEBUGP("adding new entry %p: ", km);
824 + DUMP_TUPLE_GRE(&km->tuple);
825 +
826 + WRITE_LOCK(&ip_ct_gre_lock);
827 + list_append(&gre_keymap_list, km);
828 + WRITE_UNLOCK(&ip_ct_gre_lock);
829 +
830 + return 0;
831 +}
832 +
833 +/* change the tuple of a keymap entry (used by nat helper) */
834 +void ip_ct_gre_keymap_change(struct ip_ct_gre_keymap *km,
835 + struct ip_conntrack_tuple *t)
836 +{
837 + DEBUGP("changing entry %p to: ", km);
838 + DUMP_TUPLE_GRE(t);
839 +
840 + WRITE_LOCK(&ip_ct_gre_lock);
841 + memcpy(&km->tuple, t, sizeof(km->tuple));
842 + WRITE_UNLOCK(&ip_ct_gre_lock);
843 +}
844 +
845 +/* destroy the keymap entries associated with specified expect */
846 +void ip_ct_gre_keymap_destroy(struct ip_conntrack_expect *exp)
847 +{
848 + DEBUGP("entering for exp %p\n", exp);
849 + WRITE_LOCK(&ip_ct_gre_lock);
850 + if (exp->proto.gre.keymap_orig) {
851 + DEBUGP("removing %p from list\n", exp->proto.gre.keymap_orig);
852 + list_del(&exp->proto.gre.keymap_orig->list);
853 + kfree(exp->proto.gre.keymap_orig);
854 + exp->proto.gre.keymap_orig = NULL;
855 + }
856 + if (exp->proto.gre.keymap_reply) {
857 + DEBUGP("removing %p from list\n", exp->proto.gre.keymap_reply);
858 + list_del(&exp->proto.gre.keymap_reply->list);
859 + kfree(exp->proto.gre.keymap_reply);
860 + exp->proto.gre.keymap_reply = NULL;
861 + }
862 + WRITE_UNLOCK(&ip_ct_gre_lock);
863 +}
864 +
865 +
866 +/* PUBLIC CONNTRACK PROTO HELPER FUNCTIONS */
867 +
868 +/* invert gre part of tuple */
869 +static int gre_invert_tuple(struct ip_conntrack_tuple *tuple,
870 + const struct ip_conntrack_tuple *orig)
871 +{
872 + tuple->dst.u.gre.key = orig->src.u.gre.key;
873 + tuple->src.u.gre.key = orig->dst.u.gre.key;
874 +
875 + return 1;
876 +}
877 +
878 +/* gre hdr info to tuple */
879 +static int gre_pkt_to_tuple(const void *datah, size_t datalen,
880 + struct ip_conntrack_tuple *tuple)
881 +{
882 + struct gre_hdr *grehdr = (struct gre_hdr *) datah;
883 + struct gre_hdr_pptp *pgrehdr = (struct gre_hdr_pptp *) datah;
884 + u_int32_t srckey;
885 +
886 + /* core guarantees 8 protocol bytes, no need for size check */
887 +
888 + switch (grehdr->version) {
889 + case GRE_VERSION_1701:
890 + if (!grehdr->key) {
891 + DEBUGP("Can't track GRE without key\n");
892 + return 0;
893 + }
894 + tuple->dst.u.gre.key = *(gre_key(grehdr));
895 + break;
896 +
897 + case GRE_VERSION_PPTP:
898 + if (ntohs(grehdr->protocol) != GRE_PROTOCOL_PPTP) {
899 + DEBUGP("GRE_VERSION_PPTP but unknown proto\n");
900 + return 0;
901 + }
902 + tuple->dst.u.gre.key = htonl(ntohs(pgrehdr->call_id));
903 + break;
904 +
905 + default:
906 + printk(KERN_WARNING "unknown GRE version %hu\n",
907 + grehdr->version);
908 + return 0;
909 + }
910 +
911 + srckey = gre_keymap_lookup(tuple);
912 +
913 +#if 0
914 + DEBUGP("found src key %x for tuple ", ntohl(srckey));
915 + DUMP_TUPLE_GRE(tuple);
916 +#endif
917 + tuple->src.u.gre.key = srckey;
918 +
919 + return 1;
920 +}
921 +
922 +/* print gre part of tuple */
923 +static unsigned int gre_print_tuple(char *buffer,
924 + const struct ip_conntrack_tuple *tuple)
925 +{
926 + return sprintf(buffer, "srckey=0x%x dstkey=0x%x ",
927 + ntohl(tuple->src.u.gre.key),
928 + ntohl(tuple->dst.u.gre.key));
929 +}
930 +
931 +/* print private data for conntrack */
932 +static unsigned int gre_print_conntrack(char *buffer,
933 + const struct ip_conntrack *ct)
934 +{
935 + return sprintf(buffer, "timeout=%u, stream_timeout=%u ",
936 + (ct->proto.gre.timeout / HZ),
937 + (ct->proto.gre.stream_timeout / HZ));
938 +}
939 +
940 +/* Returns verdict for packet, and may modify conntrack */
941 +static int gre_packet(struct ip_conntrack *ct,
942 + struct iphdr *iph, size_t len,
943 + enum ip_conntrack_info conntrackinfo)
944 +{
945 + /* If we've seen traffic both ways, this is a GRE connection.
946 + * Extend timeout. */
947 + if (ct->status & IPS_SEEN_REPLY) {
948 + ip_ct_refresh_acct(ct, ct->proto.gre.stream_timeout);
949 + /* Also, more likely to be important, and not a probe. */
950 + set_bit(IPS_ASSURED_BIT, &ct->status);
951 + } else
952 + ip_ct_refresh_acct(ct, ct->proto.gre.timeout);
953 +
954 + return NF_ACCEPT;
955 +}
956 +
957 +/* Called when a new connection for this protocol found. */
958 +static int gre_new(struct ip_conntrack *ct,
959 + struct iphdr *iph, size_t len)
960 +{
961 + DEBUGP(": ");
962 + DUMP_TUPLE_GRE(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple);
963 +
964 + /* initialize to sane value. Ideally a conntrack helper
965 + * (e.g. in case of pptp) is increasing them */
966 + ct->proto.gre.stream_timeout = GRE_STREAM_TIMEOUT;
967 + ct->proto.gre.timeout = GRE_TIMEOUT;
968 +
969 + return 1;
970 +}
971 +
972 +/* Called when a conntrack entry has already been removed from the hashes
973 + * and is about to be deleted from memory */
974 +static void gre_destroy(struct ip_conntrack *ct)
975 +{
976 + struct ip_conntrack_expect *master = ct->master;
977 +
978 + DEBUGP(" entering\n");
979 +
980 + if (!master) {
981 + DEBUGP("no master exp for ct %p\n", ct);
982 + return;
983 + }
984 +
985 + ip_ct_gre_keymap_destroy(master);
986 +}
987 +
988 +/* protocol helper struct */
989 +static struct ip_conntrack_protocol gre = { { NULL, NULL }, IPPROTO_GRE,
990 + "gre",
991 + gre_pkt_to_tuple,
992 + gre_invert_tuple,
993 + gre_print_tuple,
994 + gre_print_conntrack,
995 + gre_packet,
996 + gre_new,
997 + gre_destroy,
998 + NULL,
999 + THIS_MODULE };
1000 +
1001 +/* ip_conntrack_proto_gre initialization */
1002 +static int __init init(void)
1003 +{
1004 + int retcode;
1005 +
1006 + if ((retcode = ip_conntrack_protocol_register(&gre))) {
1007 + printk(KERN_ERR "Unable to register conntrack protocol "
1008 + "helper for gre: %d\n", retcode);
1009 + return -EIO;
1010 + }
1011 +
1012 + return 0;
1013 +}
1014 +
1015 +static void __exit fini(void)
1016 +{
1017 + struct list_head *pos, *n;
1018 +
1019 + /* delete all keymap entries */
1020 + WRITE_LOCK(&ip_ct_gre_lock);
1021 + list_for_each_safe(pos, n, &gre_keymap_list) {
1022 + DEBUGP("deleting keymap %p at module unload time\n", pos);
1023 + list_del(pos);
1024 + kfree(pos);
1025 + }
1026 + WRITE_UNLOCK(&ip_ct_gre_lock);
1027 +
1028 + ip_conntrack_protocol_unregister(&gre);
1029 +}
1030 +
1031 +EXPORT_SYMBOL(ip_ct_gre_keymap_add);
1032 +EXPORT_SYMBOL(ip_ct_gre_keymap_change);
1033 +EXPORT_SYMBOL(ip_ct_gre_keymap_destroy);
1034 +
1035 +module_init(init);
1036 +module_exit(fini);
1037 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_nat_core.c
1038 ===================================================================
1039 --- linux-2.4.35.4.orig/net/ipv4/netfilter/ip_nat_core.c
1040 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_nat_core.c
1041 @@ -424,7 +424,7 @@ get_unique_tuple(struct ip_conntrack_tup
1042 *tuple = *orig_tuple;
1043 while ((rptr = find_best_ips_proto_fast(tuple, mr, conntrack, hooknum))
1044 != NULL) {
1045 - DEBUGP("Found best for "); DUMP_TUPLE(tuple);
1046 + DEBUGP("Found best for "); DUMP_TUPLE_RAW(tuple);
1047 /* 3) The per-protocol part of the manip is made to
1048 map into the range to make a unique tuple. */
1049
1050 @@ -564,9 +564,9 @@ ip_nat_setup_info(struct ip_conntrack *c
1051 HOOK2MANIP(hooknum)==IP_NAT_MANIP_SRC ? "SRC" : "DST",
1052 conntrack);
1053 DEBUGP("Original: ");
1054 - DUMP_TUPLE(&orig_tp);
1055 + DUMP_TUPLE_RAW(&orig_tp);
1056 DEBUGP("New: ");
1057 - DUMP_TUPLE(&new_tuple);
1058 + DUMP_TUPLE_RAW(&new_tuple);
1059 #endif
1060
1061 /* We now have two tuples (SRCIP/SRCPT/DSTIP/DSTPT):
1062 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_nat_pptp.c
1063 ===================================================================
1064 --- /dev/null
1065 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_nat_pptp.c
1066 @@ -0,0 +1,482 @@
1067 +/*
1068 + * ip_nat_pptp.c - Version 1.5
1069 + *
1070 + * NAT support for PPTP (Point to Point Tunneling Protocol).
1071 + * PPTP is a a protocol for creating virtual private networks.
1072 + * It is a specification defined by Microsoft and some vendors
1073 + * working with Microsoft. PPTP is built on top of a modified
1074 + * version of the Internet Generic Routing Encapsulation Protocol.
1075 + * GRE is defined in RFC 1701 and RFC 1702. Documentation of
1076 + * PPTP can be found in RFC 2637
1077 + *
1078 + * (C) 2000-2003 by Harald Welte <laforge@gnumonks.org>
1079 + *
1080 + * Development of this code funded by Astaro AG (http://www.astaro.com/)
1081 + *
1082 + * TODO: - Support for multiple calls within one session
1083 + * (needs netfilter newnat code)
1084 + * - NAT to a unique tuple, not to TCP source port
1085 + * (needs netfilter tuple reservation)
1086 + *
1087 + * Changes:
1088 + * 2002-02-10 - Version 1.3
1089 + * - Use ip_nat_mangle_tcp_packet() because of cloned skb's
1090 + * in local connections (Philip Craig <philipc@snapgear.com>)
1091 + * - add checks for magicCookie and pptp version
1092 + * - make argument list of pptp_{out,in}bound_packet() shorter
1093 + * - move to C99 style initializers
1094 + * - print version number at module loadtime
1095 + * 2003-09-22 - Version 1.5
1096 + * - use SNATed tcp sourceport as callid, since we get called before
1097 + * TCP header is mangled (Philip Craig <philipc@snapgear.com>)
1098 + *
1099 + */
1100 +
1101 +#include <linux/config.h>
1102 +#include <linux/module.h>
1103 +#include <linux/ip.h>
1104 +#include <linux/tcp.h>
1105 +#include <net/tcp.h>
1106 +#include <linux/netfilter_ipv4/ip_nat.h>
1107 +#include <linux/netfilter_ipv4/ip_nat_rule.h>
1108 +#include <linux/netfilter_ipv4/ip_nat_helper.h>
1109 +#include <linux/netfilter_ipv4/ip_nat_pptp.h>
1110 +#include <linux/netfilter_ipv4/ip_conntrack_helper.h>
1111 +#include <linux/netfilter_ipv4/ip_conntrack_proto_gre.h>
1112 +#include <linux/netfilter_ipv4/ip_conntrack_pptp.h>
1113 +
1114 +#define IP_NAT_PPTP_VERSION "1.5"
1115 +
1116 +MODULE_LICENSE("GPL");
1117 +MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>");
1118 +MODULE_DESCRIPTION("Netfilter NAT helper module for PPTP");
1119 +
1120 +
1121 +#if 0
1122 +#include "ip_conntrack_pptp_priv.h"
1123 +#define DEBUGP(format, args...) printk(KERN_DEBUG __FILE__ ":" __FUNCTION__ \
1124 + ": " format, ## args)
1125 +#else
1126 +#define DEBUGP(format, args...)
1127 +#endif
1128 +
1129 +static unsigned int
1130 +pptp_nat_expected(struct sk_buff **pskb,
1131 + unsigned int hooknum,
1132 + struct ip_conntrack *ct,
1133 + struct ip_nat_info *info)
1134 +{
1135 + struct ip_conntrack *master = master_ct(ct);
1136 + struct ip_nat_multi_range mr;
1137 + struct ip_ct_pptp_master *ct_pptp_info;
1138 + struct ip_nat_pptp *nat_pptp_info;
1139 + u_int32_t newip, newcid;
1140 + int ret;
1141 +
1142 + IP_NF_ASSERT(info);
1143 + IP_NF_ASSERT(master);
1144 + IP_NF_ASSERT(!(info->initialized & (1 << HOOK2MANIP(hooknum))));
1145 +
1146 + DEBUGP("we have a connection!\n");
1147 +
1148 + LOCK_BH(&ip_pptp_lock);
1149 + ct_pptp_info = &master->help.ct_pptp_info;
1150 + nat_pptp_info = &master->nat.help.nat_pptp_info;
1151 +
1152 + /* need to alter GRE tuple because conntrack expectfn() used 'wrong'
1153 + * (unmanipulated) values */
1154 + if (HOOK2MANIP(hooknum) == IP_NAT_MANIP_DST) {
1155 + DEBUGP("completing tuples with NAT info \n");
1156 + /* we can do this, since we're unconfirmed */
1157 + if (ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u.gre.key ==
1158 + htonl(ct_pptp_info->pac_call_id)) {
1159 + /* assume PNS->PAC */
1160 + ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u.gre.key =
1161 + htonl(nat_pptp_info->pns_call_id);
1162 + ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.gre.key =
1163 + htonl(nat_pptp_info->pns_call_id);
1164 + newip = master->tuplehash[IP_CT_DIR_REPLY].tuple.src.ip;
1165 + newcid = htonl(nat_pptp_info->pac_call_id);
1166 + } else {
1167 + /* assume PAC->PNS */
1168 + ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u.gre.key =
1169 + htonl(nat_pptp_info->pac_call_id);
1170 + ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.gre.key =
1171 + htonl(nat_pptp_info->pac_call_id);
1172 + newip = master->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.ip;
1173 + newcid = htonl(nat_pptp_info->pns_call_id);
1174 + }
1175 + } else {
1176 + if (ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u.gre.key ==
1177 + htonl(ct_pptp_info->pac_call_id)) {
1178 + /* assume PNS->PAC */
1179 + newip = master->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip;
1180 + newcid = htonl(ct_pptp_info->pns_call_id);
1181 + }
1182 + else {
1183 + /* assume PAC->PNS */
1184 + newip = master->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.ip;
1185 + newcid = htonl(ct_pptp_info->pac_call_id);
1186 + }
1187 + }
1188 +
1189 + mr.rangesize = 1;
1190 + mr.range[0].flags = IP_NAT_RANGE_MAP_IPS | IP_NAT_RANGE_PROTO_SPECIFIED;
1191 + mr.range[0].min_ip = mr.range[0].max_ip = newip;
1192 + mr.range[0].min = mr.range[0].max =
1193 + ((union ip_conntrack_manip_proto ) { newcid });
1194 + DEBUGP("change ip to %u.%u.%u.%u\n",
1195 + NIPQUAD(newip));
1196 + DEBUGP("change key to 0x%x\n", ntohl(newcid));
1197 + ret = ip_nat_setup_info(ct, &mr, hooknum);
1198 +
1199 + UNLOCK_BH(&ip_pptp_lock);
1200 +
1201 + return ret;
1202 +
1203 +}
1204 +
1205 +/* outbound packets == from PNS to PAC */
1206 +static inline unsigned int
1207 +pptp_outbound_pkt(struct sk_buff **pskb,
1208 + struct ip_conntrack *ct,
1209 + enum ip_conntrack_info ctinfo,
1210 + struct ip_conntrack_expect *exp)
1211 +
1212 +{
1213 + struct iphdr *iph = (*pskb)->nh.iph;
1214 + struct tcphdr *tcph = (void *) iph + iph->ihl*4;
1215 + struct pptp_pkt_hdr *pptph = (struct pptp_pkt_hdr *)
1216 + ((void *)tcph + tcph->doff*4);
1217 +
1218 + struct PptpControlHeader *ctlh;
1219 + union pptp_ctrl_union pptpReq;
1220 + struct ip_ct_pptp_master *ct_pptp_info = &ct->help.ct_pptp_info;
1221 + struct ip_nat_pptp *nat_pptp_info = &ct->nat.help.nat_pptp_info;
1222 +
1223 + u_int16_t msg, *cid = NULL, new_callid;
1224 +
1225 + /* FIXME: size checks !!! */
1226 + ctlh = (struct PptpControlHeader *) ((void *) pptph + sizeof(*pptph));
1227 + pptpReq.rawreq = (void *) ((void *) ctlh + sizeof(*ctlh));
1228 +
1229 + new_callid = htons(ct_pptp_info->pns_call_id);
1230 +
1231 + switch (msg = ntohs(ctlh->messageType)) {
1232 + case PPTP_OUT_CALL_REQUEST:
1233 + cid = &pptpReq.ocreq->callID;
1234 + /* FIXME: ideally we would want to reserve a call ID
1235 + * here. current netfilter NAT core is not able to do
1236 + * this :( For now we use TCP source port. This breaks
1237 + * multiple calls within one control session */
1238 +
1239 + /* save original call ID in nat_info */
1240 + nat_pptp_info->pns_call_id = ct_pptp_info->pns_call_id;
1241 +
1242 + /* don't use tcph->source since we are at a DSTmanip
1243 + * hook (e.g. PREROUTING) and pkt is not mangled yet */
1244 + new_callid = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.tcp.port;
1245 +
1246 + /* save new call ID in ct info */
1247 + ct_pptp_info->pns_call_id = ntohs(new_callid);
1248 + break;
1249 + case PPTP_IN_CALL_REPLY:
1250 + cid = &pptpReq.icreq->callID;
1251 + break;
1252 + case PPTP_CALL_CLEAR_REQUEST:
1253 + cid = &pptpReq.clrreq->callID;
1254 + break;
1255 + default:
1256 + DEBUGP("unknown outbound packet 0x%04x:%s\n", msg,
1257 + (msg <= PPTP_MSG_MAX)? strMName[msg]:strMName[0]);
1258 + /* fall through */
1259 +
1260 + case PPTP_SET_LINK_INFO:
1261 + /* only need to NAT in case PAC is behind NAT box */
1262 + case PPTP_START_SESSION_REQUEST:
1263 + case PPTP_START_SESSION_REPLY:
1264 + case PPTP_STOP_SESSION_REQUEST:
1265 + case PPTP_STOP_SESSION_REPLY:
1266 + case PPTP_ECHO_REQUEST:
1267 + case PPTP_ECHO_REPLY:
1268 + /* no need to alter packet */
1269 + return NF_ACCEPT;
1270 + }
1271 +
1272 + IP_NF_ASSERT(cid);
1273 +
1274 + DEBUGP("altering call id from 0x%04x to 0x%04x\n",
1275 + ntohs(*cid), ntohs(new_callid));
1276 +
1277 + /* mangle packet */
1278 + ip_nat_mangle_tcp_packet(pskb, ct, ctinfo, (void *)cid - (void *)pptph,
1279 + sizeof(new_callid), (char *)&new_callid,
1280 + sizeof(new_callid));
1281 +
1282 + return NF_ACCEPT;
1283 +}
1284 +
1285 +/* inbound packets == from PAC to PNS */
1286 +static inline unsigned int
1287 +pptp_inbound_pkt(struct sk_buff **pskb,
1288 + struct ip_conntrack *ct,
1289 + enum ip_conntrack_info ctinfo,
1290 + struct ip_conntrack_expect *oldexp)
1291 +{
1292 + struct iphdr *iph = (*pskb)->nh.iph;
1293 + struct tcphdr *tcph = (void *) iph + iph->ihl*4;
1294 + struct pptp_pkt_hdr *pptph = (struct pptp_pkt_hdr *)
1295 + ((void *)tcph + tcph->doff*4);
1296 +
1297 + struct PptpControlHeader *ctlh;
1298 + union pptp_ctrl_union pptpReq;
1299 + struct ip_ct_pptp_master *ct_pptp_info = &ct->help.ct_pptp_info;
1300 + struct ip_nat_pptp *nat_pptp_info = &ct->nat.help.nat_pptp_info;
1301 +
1302 + u_int16_t msg, new_cid = 0, new_pcid, *pcid = NULL, *cid = NULL;
1303 + u_int32_t old_dst_ip;
1304 +
1305 + struct ip_conntrack_tuple t, inv_t;
1306 + struct ip_conntrack_tuple *orig_t, *reply_t;
1307 +
1308 + /* FIXME: size checks !!! */
1309 + ctlh = (struct PptpControlHeader *) ((void *) pptph + sizeof(*pptph));
1310 + pptpReq.rawreq = (void *) ((void *) ctlh + sizeof(*ctlh));
1311 +
1312 + new_pcid = htons(nat_pptp_info->pns_call_id);
1313 +
1314 + switch (msg = ntohs(ctlh->messageType)) {
1315 + case PPTP_OUT_CALL_REPLY:
1316 + pcid = &pptpReq.ocack->peersCallID;
1317 + cid = &pptpReq.ocack->callID;
1318 + if (!oldexp) {
1319 + DEBUGP("outcall but no expectation\n");
1320 + break;
1321 + }
1322 + old_dst_ip = oldexp->tuple.dst.ip;
1323 + t = oldexp->tuple;
1324 + invert_tuplepr(&inv_t, &t);
1325 +
1326 + /* save original PAC call ID in nat_info */
1327 + nat_pptp_info->pac_call_id = ct_pptp_info->pac_call_id;
1328 +
1329 + /* alter expectation */
1330 + orig_t = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
1331 + reply_t = &ct->tuplehash[IP_CT_DIR_REPLY].tuple;
1332 + if (t.src.ip == orig_t->src.ip && t.dst.ip == orig_t->dst.ip) {
1333 + /* expectation for PNS->PAC direction */
1334 + t.src.u.gre.key = htonl(nat_pptp_info->pns_call_id);
1335 + t.dst.u.gre.key = htonl(ct_pptp_info->pac_call_id);
1336 + inv_t.src.ip = reply_t->src.ip;
1337 + inv_t.dst.ip = reply_t->dst.ip;
1338 + inv_t.src.u.gre.key = htonl(nat_pptp_info->pac_call_id);
1339 + inv_t.dst.u.gre.key = htonl(ct_pptp_info->pns_call_id);
1340 + } else {
1341 + /* expectation for PAC->PNS direction */
1342 + t.src.u.gre.key = htonl(nat_pptp_info->pac_call_id);
1343 + t.dst.u.gre.key = htonl(ct_pptp_info->pns_call_id);
1344 + inv_t.src.ip = orig_t->src.ip;
1345 + inv_t.dst.ip = orig_t->dst.ip;
1346 + inv_t.src.u.gre.key = htonl(nat_pptp_info->pns_call_id);
1347 + inv_t.dst.u.gre.key = htonl(ct_pptp_info->pac_call_id);
1348 + }
1349 +
1350 + if (!ip_conntrack_change_expect(oldexp, &t)) {
1351 + DEBUGP("successfully changed expect\n");
1352 + } else {
1353 + DEBUGP("can't change expect\n");
1354 + }
1355 + if (oldexp->proto.gre.keymap_orig)
1356 + ip_ct_gre_keymap_change(oldexp->proto.gre.keymap_orig,
1357 + &t);
1358 + if (oldexp->proto.gre.keymap_reply)
1359 + ip_ct_gre_keymap_change(oldexp->proto.gre.keymap_reply,
1360 + &inv_t);
1361 + break;
1362 + case PPTP_IN_CALL_CONNECT:
1363 + pcid = &pptpReq.iccon->peersCallID;
1364 + if (!oldexp)
1365 + break;
1366 + old_dst_ip = oldexp->tuple.dst.ip;
1367 + t = oldexp->tuple;
1368 +
1369 + /* alter expectation, no need for callID */
1370 + if (t.dst.ip == ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.ip) {
1371 + /* expectation for PNS->PAC direction */
1372 + t.src.ip = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip;
1373 + } else {
1374 + /* expectation for PAC->PNS direction */
1375 + t.dst.ip = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip;
1376 + }
1377 +
1378 + if (!ip_conntrack_change_expect(oldexp, &t)) {
1379 + DEBUGP("successfully changed expect\n");
1380 + } else {
1381 + DEBUGP("can't change expect\n");
1382 + }
1383 + break;
1384 + case PPTP_IN_CALL_REQUEST:
1385 + /* only need to nat in case PAC is behind NAT box */
1386 + break;
1387 + case PPTP_WAN_ERROR_NOTIFY:
1388 + pcid = &pptpReq.wanerr->peersCallID;
1389 + break;
1390 + case PPTP_CALL_DISCONNECT_NOTIFY:
1391 + pcid = &pptpReq.disc->callID;
1392 + break;
1393 + case PPTP_SET_LINK_INFO:
1394 + pcid = &pptpReq.setlink->peersCallID;
1395 + break;
1396 +
1397 + default:
1398 + DEBUGP("unknown inbound packet %s\n",
1399 + (msg <= PPTP_MSG_MAX)? strMName[msg]:strMName[0]);
1400 + /* fall through */
1401 +
1402 + case PPTP_START_SESSION_REQUEST:
1403 + case PPTP_START_SESSION_REPLY:
1404 + case PPTP_STOP_SESSION_REQUEST:
1405 + case PPTP_STOP_SESSION_REPLY:
1406 + case PPTP_ECHO_REQUEST:
1407 + case PPTP_ECHO_REPLY:
1408 + /* no need to alter packet */
1409 + return NF_ACCEPT;
1410 + }
1411 +
1412 + /* mangle packet */
1413 + IP_NF_ASSERT(pcid);
1414 + DEBUGP("altering peer call id from 0x%04x to 0x%04x\n",
1415 + ntohs(*pcid), ntohs(new_pcid));
1416 + ip_nat_mangle_tcp_packet(pskb, ct, ctinfo, (void *)pcid - (void *)pptph,
1417 + sizeof(new_pcid), (char *)&new_pcid,
1418 + sizeof(new_pcid));
1419 +
1420 + if (new_cid) {
1421 + IP_NF_ASSERT(cid);
1422 + DEBUGP("altering call id from 0x%04x to 0x%04x\n",
1423 + ntohs(*cid), ntohs(new_cid));
1424 + ip_nat_mangle_tcp_packet(pskb, ct, ctinfo,
1425 + (void *)cid - (void *)pptph,
1426 + sizeof(new_cid), (char *)&new_cid,
1427 + sizeof(new_cid));
1428 + }
1429 +
1430 + /* great, at least we don't need to resize packets */
1431 + return NF_ACCEPT;
1432 +}
1433 +
1434 +
1435 +static unsigned int tcp_help(struct ip_conntrack *ct,
1436 + struct ip_conntrack_expect *exp,
1437 + struct ip_nat_info *info,
1438 + enum ip_conntrack_info ctinfo,
1439 + unsigned int hooknum, struct sk_buff **pskb)
1440 +{
1441 + struct iphdr *iph = (*pskb)->nh.iph;
1442 + struct tcphdr *tcph = (void *) iph + iph->ihl*4;
1443 + unsigned int datalen = (*pskb)->len - iph->ihl*4 - tcph->doff*4;
1444 + struct pptp_pkt_hdr *pptph;
1445 +
1446 + int dir;
1447 +
1448 + DEBUGP("entering\n");
1449 +
1450 + /* Only mangle things once: DST for original direction
1451 + and SRC for reply direction. */
1452 + dir = CTINFO2DIR(ctinfo);
1453 + if (!((HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC
1454 + && dir == IP_CT_DIR_ORIGINAL)
1455 + || (HOOK2MANIP(hooknum) == IP_NAT_MANIP_DST
1456 + && dir == IP_CT_DIR_REPLY))) {
1457 + DEBUGP("Not touching dir %s at hook %s\n",
1458 + dir == IP_CT_DIR_ORIGINAL ? "ORIG" : "REPLY",
1459 + hooknum == NF_IP_POST_ROUTING ? "POSTROUTING"
1460 + : hooknum == NF_IP_PRE_ROUTING ? "PREROUTING"
1461 + : hooknum == NF_IP_LOCAL_OUT ? "OUTPUT"
1462 + : hooknum == NF_IP_LOCAL_IN ? "INPUT" : "???");
1463 + return NF_ACCEPT;
1464 + }
1465 +
1466 + /* if packet is too small, just skip it */
1467 + if (datalen < sizeof(struct pptp_pkt_hdr)+
1468 + sizeof(struct PptpControlHeader)) {
1469 + DEBUGP("pptp packet too short\n");
1470 + return NF_ACCEPT;
1471 + }
1472 +
1473 + pptph = (struct pptp_pkt_hdr *) ((void *)tcph + tcph->doff*4);
1474 +
1475 + /* if it's not a control message, we can't handle it */
1476 + if (ntohs(pptph->packetType) != PPTP_PACKET_CONTROL ||
1477 + ntohl(pptph->magicCookie) != PPTP_MAGIC_COOKIE) {
1478 + DEBUGP("not a pptp control packet\n");
1479 + return NF_ACCEPT;
1480 + }
1481 +
1482 + LOCK_BH(&ip_pptp_lock);
1483 +
1484 + if (dir == IP_CT_DIR_ORIGINAL) {
1485 + /* reuqests sent by client to server (PNS->PAC) */
1486 + pptp_outbound_pkt(pskb, ct, ctinfo, exp);
1487 + } else {
1488 + /* response from the server to the client (PAC->PNS) */
1489 + pptp_inbound_pkt(pskb, ct, ctinfo, exp);
1490 + }
1491 +
1492 + UNLOCK_BH(&ip_pptp_lock);
1493 +
1494 + return NF_ACCEPT;
1495 +}
1496 +
1497 +/* nat helper struct for control connection */
1498 +static struct ip_nat_helper pptp_tcp_helper = {
1499 + .list = { NULL, NULL },
1500 + .name = "pptp",
1501 + .flags = IP_NAT_HELPER_F_ALWAYS,
1502 + .me = THIS_MODULE,
1503 + .tuple = { .src = { .ip = 0,
1504 + .u = { .tcp = { .port =
1505 + __constant_htons(PPTP_CONTROL_PORT) }
1506 + }
1507 + },
1508 + .dst = { .ip = 0,
1509 + .u = { .all = 0 },
1510 + .protonum = IPPROTO_TCP
1511 + }
1512 + },
1513 +
1514 + .mask = { .src = { .ip = 0,
1515 + .u = { .tcp = { .port = 0xFFFF } }
1516 + },
1517 + .dst = { .ip = 0,
1518 + .u = { .all = 0 },
1519 + .protonum = 0xFFFF
1520 + }
1521 + },
1522 + .help = tcp_help,
1523 + .expect = pptp_nat_expected
1524 +};
1525 +
1526 +
1527 +static int __init init(void)
1528 +{
1529 + DEBUGP("%s: registering NAT helper\n", __FILE__);
1530 + if (ip_nat_helper_register(&pptp_tcp_helper)) {
1531 + printk(KERN_ERR "Unable to register NAT application helper "
1532 + "for pptp\n");
1533 + return -EIO;
1534 + }
1535 +
1536 + printk("ip_nat_pptp version %s loaded\n", IP_NAT_PPTP_VERSION);
1537 + return 0;
1538 +}
1539 +
1540 +static void __exit fini(void)
1541 +{
1542 + DEBUGP("cleanup_module\n" );
1543 + ip_nat_helper_unregister(&pptp_tcp_helper);
1544 + printk("ip_nat_pptp version %s unloaded\n", IP_NAT_PPTP_VERSION);
1545 +}
1546 +
1547 +module_init(init);
1548 +module_exit(fini);
1549 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_nat_proto_gre.c
1550 ===================================================================
1551 --- /dev/null
1552 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_nat_proto_gre.c
1553 @@ -0,0 +1,202 @@
1554 +/*
1555 + * ip_nat_proto_gre.c - Version 1.2
1556 + *
1557 + * NAT protocol helper module for GRE.
1558 + *
1559 + * GRE is a generic encapsulation protocol, which is generally not very
1560 + * suited for NAT, as it has no protocol-specific part as port numbers.
1561 + *
1562 + * It has an optional key field, which may help us distinguishing two
1563 + * connections between the same two hosts.
1564 + *
1565 + * GRE is defined in RFC 1701 and RFC 1702, as well as RFC 2784
1566 + *
1567 + * PPTP is built on top of a modified version of GRE, and has a mandatory
1568 + * field called "CallID", which serves us for the same purpose as the key
1569 + * field in plain GRE.
1570 + *
1571 + * Documentation about PPTP can be found in RFC 2637
1572 + *
1573 + * (C) 2000-2003 by Harald Welte <laforge@gnumonks.org>
1574 + *
1575 + * Development of this code funded by Astaro AG (http://www.astaro.com/)
1576 + *
1577 + */
1578 +
1579 +#include <linux/config.h>
1580 +#include <linux/module.h>
1581 +#include <linux/ip.h>
1582 +#include <linux/netfilter_ipv4/ip_nat.h>
1583 +#include <linux/netfilter_ipv4/ip_nat_rule.h>
1584 +#include <linux/netfilter_ipv4/ip_nat_protocol.h>
1585 +#include <linux/netfilter_ipv4/ip_conntrack_proto_gre.h>
1586 +
1587 +MODULE_LICENSE("GPL");
1588 +MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>");
1589 +MODULE_DESCRIPTION("Netfilter NAT protocol helper module for GRE");
1590 +
1591 +#if 0
1592 +#define DEBUGP(format, args...) printk(KERN_DEBUG __FILE__ ":" __FUNCTION__ \
1593 + ": " format, ## args)
1594 +#else
1595 +#define DEBUGP(x, args...)
1596 +#endif
1597 +
1598 +/* is key in given range between min and max */
1599 +static int
1600 +gre_in_range(const struct ip_conntrack_tuple *tuple,
1601 + enum ip_nat_manip_type maniptype,
1602 + const union ip_conntrack_manip_proto *min,
1603 + const union ip_conntrack_manip_proto *max)
1604 +{
1605 + u_int32_t key;
1606 +
1607 + if (maniptype == IP_NAT_MANIP_SRC)
1608 + key = tuple->src.u.gre.key;
1609 + else
1610 + key = tuple->dst.u.gre.key;
1611 +
1612 + return ntohl(key) >= ntohl(min->gre.key)
1613 + && ntohl(key) <= ntohl(max->gre.key);
1614 +}
1615 +
1616 +/* generate unique tuple ... */
1617 +static int
1618 +gre_unique_tuple(struct ip_conntrack_tuple *tuple,
1619 + const struct ip_nat_range *range,
1620 + enum ip_nat_manip_type maniptype,
1621 + const struct ip_conntrack *conntrack)
1622 +{
1623 + u_int32_t min, i, range_size;
1624 + u_int32_t key = 0, *keyptr;
1625 +
1626 + if (maniptype == IP_NAT_MANIP_SRC)
1627 + keyptr = &tuple->src.u.gre.key;
1628 + else
1629 + keyptr = &tuple->dst.u.gre.key;
1630 +
1631 + if (!(range->flags & IP_NAT_RANGE_PROTO_SPECIFIED)) {
1632 +
1633 + DEBUGP("%p: NATing GRE PPTP\n", conntrack);
1634 + min = 1;
1635 + range_size = 0xffff;
1636 +
1637 + } else {
1638 + min = ntohl(range->min.gre.key);
1639 + range_size = ntohl(range->max.gre.key) - min + 1;
1640 + }
1641 +
1642 + DEBUGP("min = %u, range_size = %u\n", min, range_size);
1643 +
1644 + for (i = 0; i < range_size; i++, key++) {
1645 + *keyptr = htonl(min + key % range_size);
1646 + if (!ip_nat_used_tuple(tuple, conntrack))
1647 + return 1;
1648 + }
1649 +
1650 + DEBUGP("%p: no NAT mapping\n", conntrack);
1651 +
1652 + return 0;
1653 +}
1654 +
1655 +/* manipulate a GRE packet according to maniptype */
1656 +static void
1657 +gre_manip_pkt(struct iphdr *iph, size_t len,
1658 + const struct ip_conntrack_manip *manip,
1659 + enum ip_nat_manip_type maniptype)
1660 +{
1661 + struct gre_hdr *greh = (struct gre_hdr *)((u_int32_t *)iph+iph->ihl);
1662 + struct gre_hdr_pptp *pgreh = (struct gre_hdr_pptp *) greh;
1663 +
1664 + /* we only have destination manip of a packet, since 'source key'
1665 + * is not present in the packet itself */
1666 + if (maniptype == IP_NAT_MANIP_DST) {
1667 + /* key manipulation is always dest */
1668 + switch (greh->version) {
1669 + case 0:
1670 + if (!greh->key) {
1671 + DEBUGP("can't nat GRE w/o key\n");
1672 + break;
1673 + }
1674 + if (greh->csum) {
1675 + /* FIXME: Never tested this code... */
1676 + *(gre_csum(greh)) =
1677 + ip_nat_cheat_check(~*(gre_key(greh)),
1678 + manip->u.gre.key,
1679 + *(gre_csum(greh)));
1680 + }
1681 + *(gre_key(greh)) = manip->u.gre.key;
1682 + break;
1683 + case GRE_VERSION_PPTP:
1684 + DEBUGP("call_id -> 0x%04x\n",
1685 + ntohl(manip->u.gre.key));
1686 + pgreh->call_id = htons(ntohl(manip->u.gre.key));
1687 + break;
1688 + default:
1689 + DEBUGP("can't nat unknown GRE version\n");
1690 + break;
1691 + }
1692 + }
1693 +}
1694 +
1695 +/* print out a nat tuple */
1696 +static unsigned int
1697 +gre_print(char *buffer,
1698 + const struct ip_conntrack_tuple *match,
1699 + const struct ip_conntrack_tuple *mask)
1700 +{
1701 + unsigned int len = 0;
1702 +
1703 + if (mask->src.u.gre.key)
1704 + len += sprintf(buffer + len, "srckey=0x%x ",
1705 + ntohl(match->src.u.gre.key));
1706 +
1707 + if (mask->dst.u.gre.key)
1708 + len += sprintf(buffer + len, "dstkey=0x%x ",
1709 + ntohl(match->src.u.gre.key));
1710 +
1711 + return len;
1712 +}
1713 +
1714 +/* print a range of keys */
1715 +static unsigned int
1716 +gre_print_range(char *buffer, const struct ip_nat_range *range)
1717 +{
1718 + if (range->min.gre.key != 0
1719 + || range->max.gre.key != 0xFFFF) {
1720 + if (range->min.gre.key == range->max.gre.key)
1721 + return sprintf(buffer, "key 0x%x ",
1722 + ntohl(range->min.gre.key));
1723 + else
1724 + return sprintf(buffer, "keys 0x%u-0x%u ",
1725 + ntohl(range->min.gre.key),
1726 + ntohl(range->max.gre.key));
1727 + } else
1728 + return 0;
1729 +}
1730 +
1731 +/* nat helper struct */
1732 +static struct ip_nat_protocol gre =
1733 + { { NULL, NULL }, "GRE", IPPROTO_GRE,
1734 + gre_manip_pkt,
1735 + gre_in_range,
1736 + gre_unique_tuple,
1737 + gre_print,
1738 + gre_print_range
1739 + };
1740 +
1741 +static int __init init(void)
1742 +{
1743 + if (ip_nat_protocol_register(&gre))
1744 + return -EIO;
1745 +
1746 + return 0;
1747 +}
1748 +
1749 +static void __exit fini(void)
1750 +{
1751 + ip_nat_protocol_unregister(&gre);
1752 +}
1753 +
1754 +module_init(init);
1755 +module_exit(fini);
1756 Index: linux-2.4.35.4/net/ipv4/netfilter/Makefile
1757 ===================================================================
1758 --- linux-2.4.35.4.orig/net/ipv4/netfilter/Makefile
1759 +++ linux-2.4.35.4/net/ipv4/netfilter/Makefile
1760 @@ -36,23 +36,32 @@ obj-$(CONFIG_IP_NF_AMANDA) += ip_conntra
1761 ifdef CONFIG_IP_NF_AMANDA
1762 export-objs += ip_conntrack_amanda.o
1763 endif
1764 -
1765 obj-$(CONFIG_IP_NF_TFTP) += ip_conntrack_tftp.o
1766 obj-$(CONFIG_IP_NF_FTP) += ip_conntrack_ftp.o
1767 ifdef CONFIG_IP_NF_FTP
1768 export-objs += ip_conntrack_ftp.o
1769 endif
1770 -
1771 obj-$(CONFIG_IP_NF_IRC) += ip_conntrack_irc.o
1772 ifdef CONFIG_IP_NF_IRC
1773 export-objs += ip_conntrack_irc.o
1774 endif
1775 +obj-$(CONFIG_IP_NF_CT_PROTO_GRE) += ip_conntrack_proto_gre.o
1776 +ifdef CONFIG_IP_NF_CT_PROTO_GRE
1777 + export-objs += ip_conntrack_proto_gre.o
1778 +endif
1779 +obj-$(CONFIG_IP_NF_PPTP) += ip_conntrack_pptp.o
1780 +ifdef CONFIG_IP_NF_NAT_PPTP
1781 + export-objs += ip_conntrack_pptp.o
1782 +endif
1783 +
1784
1785 # NAT helpers
1786 obj-$(CONFIG_IP_NF_NAT_AMANDA) += ip_nat_amanda.o
1787 obj-$(CONFIG_IP_NF_NAT_TFTP) += ip_nat_tftp.o
1788 obj-$(CONFIG_IP_NF_NAT_FTP) += ip_nat_ftp.o
1789 obj-$(CONFIG_IP_NF_NAT_IRC) += ip_nat_irc.o
1790 +obj-$(CONFIG_IP_NF_NAT_PROTO_GRE) += ip_nat_proto_gre.o
1791 +obj-$(CONFIG_IP_NF_NAT_PPTP) += ip_nat_pptp.o
1792
1793 # generic IP tables
1794 obj-$(CONFIG_IP_NF_IPTABLES) += ip_tables.o
1795 Index: linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_pptp.c
1796 ===================================================================
1797 --- /dev/null
1798 +++ linux-2.4.35.4/net/ipv4/netfilter/ip_conntrack_pptp.c
1799 @@ -0,0 +1,635 @@
1800 +/*
1801 + * ip_conntrack_pptp.c - Version 1.9
1802 + *
1803 + * Connection tracking support for PPTP (Point to Point Tunneling Protocol).
1804 + * PPTP is a a protocol for creating virtual private networks.
1805 + * It is a specification defined by Microsoft and some vendors
1806 + * working with Microsoft. PPTP is built on top of a modified
1807 + * version of the Internet Generic Routing Encapsulation Protocol.
1808 + * GRE is defined in RFC 1701 and RFC 1702. Documentation of
1809 + * PPTP can be found in RFC 2637
1810 + *
1811 + * (C) 2000-2003 by Harald Welte <laforge@gnumonks.org>
1812 + *
1813 + * Development of this code funded by Astaro AG (http://www.astaro.com/)
1814 + *
1815 + * Limitations:
1816 + * - We blindly assume that control connections are always
1817 + * established in PNS->PAC direction. This is a violation
1818 + * of RFFC2673
1819 + *
1820 + * TODO: - finish support for multiple calls within one session
1821 + * (needs expect reservations in newnat)
1822 + * - testing of incoming PPTP calls
1823 + *
1824 + * Changes:
1825 + * 2002-02-05 - Version 1.3
1826 + * - Call ip_conntrack_unexpect_related() from
1827 + * pptp_timeout_related() to destroy expectations in case
1828 + * CALL_DISCONNECT_NOTIFY or tcp fin packet was seen
1829 + * (Philip Craig <philipc@snapgear.com>)
1830 + * - Add Version information at module loadtime
1831 + * 2002-02-10 - Version 1.6
1832 + * - move to C99 style initializers
1833 + * - remove second expectation if first arrives
1834 + *
1835 + */
1836 +
1837 +#include <linux/config.h>
1838 +#include <linux/module.h>
1839 +#include <linux/netfilter.h>
1840 +#include <linux/ip.h>
1841 +#include <net/checksum.h>
1842 +#include <net/tcp.h>
1843 +
1844 +#include <linux/netfilter_ipv4/lockhelp.h>
1845 +#include <linux/netfilter_ipv4/ip_conntrack_helper.h>
1846 +#include <linux/netfilter_ipv4/ip_conntrack_proto_gre.h>
1847 +#include <linux/netfilter_ipv4/ip_conntrack_pptp.h>
1848 +
1849 +#define IP_CT_PPTP_VERSION "1.9"
1850 +
1851 +MODULE_LICENSE("GPL");
1852 +MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>");
1853 +MODULE_DESCRIPTION("Netfilter connection tracking helper module for PPTP");
1854 +
1855 +DECLARE_LOCK(ip_pptp_lock);
1856 +
1857 +#if 0
1858 +#include "ip_conntrack_pptp_priv.h"
1859 +#define DEBUGP(format, args...) printk(KERN_DEBUG __FILE__ ":" __FUNCTION__ \
1860 + ": " format, ## args)
1861 +#else
1862 +#define DEBUGP(format, args...)
1863 +#endif
1864 +
1865 +#define SECS *HZ
1866 +#define MINS * 60 SECS
1867 +#define HOURS * 60 MINS
1868 +#define DAYS * 24 HOURS
1869 +
1870 +#define PPTP_GRE_TIMEOUT (10 MINS)
1871 +#define PPTP_GRE_STREAM_TIMEOUT (5 DAYS)
1872 +
1873 +static int pptp_expectfn(struct ip_conntrack *ct)
1874 +{
1875 + struct ip_conntrack *master;
1876 + struct ip_conntrack_expect *exp;
1877 +
1878 + DEBUGP("increasing timeouts\n");
1879 + /* increase timeout of GRE data channel conntrack entry */
1880 + ct->proto.gre.timeout = PPTP_GRE_TIMEOUT;
1881 + ct->proto.gre.stream_timeout = PPTP_GRE_STREAM_TIMEOUT;
1882 +
1883 + master = master_ct(ct);
1884 + if (!master) {
1885 + DEBUGP(" no master!!!\n");
1886 + return 0;
1887 + }
1888 +
1889 + exp = ct->master;
1890 + if (!exp) {
1891 + DEBUGP("no expectation!!\n");
1892 + return 0;
1893 + }
1894 +
1895 + DEBUGP("completing tuples with ct info\n");
1896 + /* we can do this, since we're unconfirmed */
1897 + if (ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u.gre.key ==
1898 + htonl(master->help.ct_pptp_info.pac_call_id)) {
1899 + /* assume PNS->PAC */
1900 + ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u.gre.key =
1901 + htonl(master->help.ct_pptp_info.pns_call_id);
1902 + ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.gre.key =
1903 + htonl(master->help.ct_pptp_info.pns_call_id);
1904 + } else {
1905 + /* assume PAC->PNS */
1906 + ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u.gre.key =
1907 + htonl(master->help.ct_pptp_info.pac_call_id);
1908 + ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.gre.key =
1909 + htonl(master->help.ct_pptp_info.pac_call_id);
1910 + }
1911 +
1912 + /* delete other expectation */
1913 + if (exp->expected_list.next != &exp->expected_list) {
1914 + struct ip_conntrack_expect *other_exp;
1915 + struct list_head *cur_item, *next;
1916 +
1917 + for (cur_item = master->sibling_list.next;
1918 + cur_item != &master->sibling_list; cur_item = next) {
1919 + next = cur_item->next;
1920 + other_exp = list_entry(cur_item,
1921 + struct ip_conntrack_expect,
1922 + expected_list);
1923 + /* remove only if occurred at same sequence number */
1924 + if (other_exp != exp && other_exp->seq == exp->seq) {
1925 + DEBUGP("unexpecting other direction\n");
1926 + ip_ct_gre_keymap_destroy(other_exp);
1927 + ip_conntrack_unexpect_related(other_exp);
1928 + }
1929 + }
1930 + }
1931 +
1932 + return 0;
1933 +}
1934 +
1935 +/* timeout GRE data connections */
1936 +static int pptp_timeout_related(struct ip_conntrack *ct)
1937 +{
1938 + struct list_head *cur_item, *next;
1939 + struct ip_conntrack_expect *exp;
1940 + enum ip_conntrack_info ctinfo;
1941 + struct iphdr *iph;
1942 +
1943 + /* FIXME: do we have to lock something ? */
1944 + for (cur_item = ct->sibling_list.next;
1945 + cur_item != &ct->sibling_list; cur_item = next) {
1946 + next = cur_item->next;
1947 + exp = list_entry(cur_item, struct ip_conntrack_expect,
1948 + expected_list);
1949 +
1950 + ip_ct_gre_keymap_destroy(exp);
1951 + if (!exp->sibling) {
1952 + ip_conntrack_unexpect_related(exp);
1953 + continue;
1954 + }
1955 +
1956 + DEBUGP("setting timeout of conntrack %p to 0\n",
1957 + exp->sibling);
1958 + exp->sibling->proto.gre.timeout = 0;
1959 + exp->sibling->proto.gre.stream_timeout = 0;
1960 + ip_ct_refresh_acct(exp->sibling, ctinfo, iph, 0);
1961 + }
1962 +
1963 + return 0;
1964 +}
1965 +
1966 +/* expect GRE connections (PNS->PAC and PAC->PNS direction) */
1967 +static inline int
1968 +exp_gre(struct ip_conntrack *master,
1969 + u_int32_t seq,
1970 + u_int16_t callid,
1971 + u_int16_t peer_callid)
1972 +{
1973 + struct ip_conntrack_expect exp;
1974 + struct ip_conntrack_tuple inv_tuple;
1975 +
1976 + memset(&exp, 0, sizeof(exp));
1977 + /* tuple in original direction, PNS->PAC */
1978 + exp.tuple.src.ip = master->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.ip;
1979 + exp.tuple.src.u.gre.key = htonl(ntohs(peer_callid));
1980 + exp.tuple.dst.ip = master->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.ip;
1981 + exp.tuple.dst.u.gre.key = htonl(ntohs(callid));
1982 + exp.tuple.dst.protonum = IPPROTO_GRE;
1983 +
1984 + exp.mask.src.ip = 0xffffffff;
1985 + exp.mask.src.u.all = 0;
1986 + exp.mask.dst.u.all = 0;
1987 + exp.mask.dst.u.gre.key = 0xffffffff;
1988 + exp.mask.dst.ip = 0xffffffff;
1989 + exp.mask.dst.protonum = 0xffff;
1990 +
1991 + exp.seq = seq;
1992 + exp.expectfn = pptp_expectfn;
1993 +
1994 + exp.help.exp_pptp_info.pac_call_id = ntohs(callid);
1995 + exp.help.exp_pptp_info.pns_call_id = ntohs(peer_callid);
1996 +
1997 + DEBUGP("calling expect_related ");
1998 + DUMP_TUPLE_RAW(&exp.tuple);
1999 +
2000 + /* Add GRE keymap entries */
2001 + if (ip_ct_gre_keymap_add(&exp, &exp.tuple, 0) != 0)
2002 + return 1;
2003 +
2004 + invert_tuplepr(&inv_tuple, &exp.tuple);
2005 + if (ip_ct_gre_keymap_add(&exp, &inv_tuple, 1) != 0) {
2006 + ip_ct_gre_keymap_destroy(&exp);
2007 + return 1;
2008 + }
2009 +
2010 + if (ip_conntrack_expect_related(master, &exp) != 0) {
2011 + ip_ct_gre_keymap_destroy(&exp);
2012 + DEBUGP("cannot expect_related()\n");
2013 + return 1;
2014 + }
2015 +
2016 + /* tuple in reply direction, PAC->PNS */
2017 + exp.tuple.src.ip = master->tuplehash[IP_CT_DIR_REPLY].tuple.src.ip;
2018 + exp.tuple.src.u.gre.key = htonl(ntohs(callid));
2019 + exp.tuple.dst.ip = master->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip;
2020 + exp.tuple.dst.u.gre.key = htonl(ntohs(peer_callid));
2021 +
2022 + DEBUGP("calling expect_related ");
2023 + DUMP_TUPLE_RAW(&exp.tuple);
2024 +
2025 + /* Add GRE keymap entries */
2026 + ip_ct_gre_keymap_add(&exp, &exp.tuple, 0);
2027 + invert_tuplepr(&inv_tuple, &exp.tuple);
2028 + ip_ct_gre_keymap_add(&exp, &inv_tuple, 1);
2029 + /* FIXME: cannot handle error correctly, since we need to free
2030 + * the above keymap :( */
2031 +
2032 + if (ip_conntrack_expect_related(master, &exp) != 0) {
2033 + /* free the second pair of keypmaps */
2034 + ip_ct_gre_keymap_destroy(&exp);
2035 + DEBUGP("cannot expect_related():\n");
2036 + return 1;
2037 + }
2038 +
2039 + return 0;
2040 +}
2041 +
2042 +static inline int
2043 +pptp_inbound_pkt(struct tcphdr *tcph,
2044 + struct pptp_pkt_hdr *pptph,
2045 + size_t datalen,
2046 + struct ip_conntrack *ct,
2047 + enum ip_conntrack_info ctinfo)
2048 +{
2049 + struct PptpControlHeader *ctlh;
2050 + union pptp_ctrl_union pptpReq;
2051 +
2052 + struct ip_ct_pptp_master *info = &ct->help.ct_pptp_info;
2053 + u_int16_t msg, *cid, *pcid;
2054 + u_int32_t seq;
2055 +
2056 + ctlh = (struct PptpControlHeader *)
2057 + ((char *) pptph + sizeof(struct pptp_pkt_hdr));
2058 + pptpReq.rawreq = (void *)
2059 + ((char *) ctlh + sizeof(struct PptpControlHeader));
2060 +
2061 + msg = ntohs(ctlh->messageType);
2062 + DEBUGP("inbound control message %s\n", strMName[msg]);
2063 +
2064 + switch (msg) {
2065 + case PPTP_START_SESSION_REPLY:
2066 + /* server confirms new control session */
2067 + if (info->sstate < PPTP_SESSION_REQUESTED) {
2068 + DEBUGP("%s without START_SESS_REQUEST\n",
2069 + strMName[msg]);
2070 + break;
2071 + }
2072 + if (pptpReq.srep->resultCode == PPTP_START_OK)
2073 + info->sstate = PPTP_SESSION_CONFIRMED;
2074 + else
2075 + info->sstate = PPTP_SESSION_ERROR;
2076 + break;
2077 +
2078 + case PPTP_STOP_SESSION_REPLY:
2079 + /* server confirms end of control session */
2080 + if (info->sstate > PPTP_SESSION_STOPREQ) {
2081 + DEBUGP("%s without STOP_SESS_REQUEST\n",
2082 + strMName[msg]);
2083 + break;
2084 + }
2085 + if (pptpReq.strep->resultCode == PPTP_STOP_OK)
2086 + info->sstate = PPTP_SESSION_NONE;
2087 + else
2088 + info->sstate = PPTP_SESSION_ERROR;
2089 + break;
2090 +
2091 + case PPTP_OUT_CALL_REPLY:
2092 + /* server accepted call, we now expect GRE frames */
2093 + if (info->sstate != PPTP_SESSION_CONFIRMED) {
2094 + DEBUGP("%s but no session\n", strMName[msg]);
2095 + break;
2096 + }
2097 + if (info->cstate != PPTP_CALL_OUT_REQ &&
2098 + info->cstate != PPTP_CALL_OUT_CONF) {
2099 + DEBUGP("%s without OUTCALL_REQ\n", strMName[msg]);
2100 + break;
2101 + }
2102 + if (pptpReq.ocack->resultCode != PPTP_OUTCALL_CONNECT) {
2103 + info->cstate = PPTP_CALL_NONE;
2104 + break;
2105 + }
2106 +
2107 + cid = &pptpReq.ocack->callID;
2108 + pcid = &pptpReq.ocack->peersCallID;
2109 +
2110 + info->pac_call_id = ntohs(*cid);
2111 +
2112 + if (htons(info->pns_call_id) != *pcid) {
2113 + DEBUGP("%s for unknown callid %u\n",
2114 + strMName[msg], ntohs(*pcid));
2115 + break;
2116 + }
2117 +
2118 + DEBUGP("%s, CID=%X, PCID=%X\n", strMName[msg],
2119 + ntohs(*cid), ntohs(*pcid));
2120 +
2121 + info->cstate = PPTP_CALL_OUT_CONF;
2122 +
2123 + seq = ntohl(tcph->seq) + ((void *)pcid - (void *)pptph);
2124 + if (exp_gre(ct, seq, *cid, *pcid) != 0)
2125 + printk("ip_conntrack_pptp: error during exp_gre\n");
2126 + break;
2127 +
2128 + case PPTP_IN_CALL_REQUEST:
2129 + /* server tells us about incoming call request */
2130 + if (info->sstate != PPTP_SESSION_CONFIRMED) {
2131 + DEBUGP("%s but no session\n", strMName[msg]);
2132 + break;
2133 + }
2134 + pcid = &pptpReq.icack->peersCallID;
2135 + DEBUGP("%s, PCID=%X\n", strMName[msg], ntohs(*pcid));
2136 + info->cstate = PPTP_CALL_IN_REQ;
2137 + info->pac_call_id= ntohs(*pcid);
2138 + break;
2139 +
2140 + case PPTP_IN_CALL_CONNECT:
2141 + /* server tells us about incoming call established */
2142 + if (info->sstate != PPTP_SESSION_CONFIRMED) {
2143 + DEBUGP("%s but no session\n", strMName[msg]);
2144 + break;
2145 + }
2146 + if (info->sstate != PPTP_CALL_IN_REP
2147 + && info->sstate != PPTP_CALL_IN_CONF) {
2148 + DEBUGP("%s but never sent IN_CALL_REPLY\n",
2149 + strMName[msg]);
2150 + break;
2151 + }
2152 +
2153 + pcid = &pptpReq.iccon->peersCallID;
2154 + cid = &info->pac_call_id;
2155 +
2156 + if (info->pns_call_id != ntohs(*pcid)) {
2157 + DEBUGP("%s for unknown CallID %u\n",
2158 + strMName[msg], ntohs(*cid));
2159 + break;
2160 + }
2161 +
2162 + DEBUGP("%s, PCID=%X\n", strMName[msg], ntohs(*pcid));
2163 + info->cstate = PPTP_CALL_IN_CONF;
2164 +
2165 + /* we expect a GRE connection from PAC to PNS */
2166 + seq = ntohl(tcph->seq) + ((void *)pcid - (void *)pptph);
2167 + if (exp_gre(ct, seq, *cid, *pcid) != 0)
2168 + printk("ip_conntrack_pptp: error during exp_gre\n");
2169 +
2170 + break;
2171 +
2172 + case PPTP_CALL_DISCONNECT_NOTIFY:
2173 + /* server confirms disconnect */
2174 + cid = &pptpReq.disc->callID;
2175 + DEBUGP("%s, CID=%X\n", strMName[msg], ntohs(*cid));
2176 + info->cstate = PPTP_CALL_NONE;
2177 +
2178 + /* untrack this call id, unexpect GRE packets */
2179 + pptp_timeout_related(ct);
2180 + break;
2181 +
2182 + case PPTP_WAN_ERROR_NOTIFY:
2183 + break;
2184 +
2185 + case PPTP_ECHO_REQUEST:
2186 + case PPTP_ECHO_REPLY:
2187 + /* I don't have to explain these ;) */
2188 + break;
2189 + default:
2190 + DEBUGP("invalid %s (TY=%d)\n", (msg <= PPTP_MSG_MAX)
2191 + ? strMName[msg]:strMName[0], msg);
2192 + break;
2193 + }
2194 +
2195 + return NF_ACCEPT;
2196 +
2197 +}
2198 +
2199 +static inline int
2200 +pptp_outbound_pkt(struct tcphdr *tcph,
2201 + struct pptp_pkt_hdr *pptph,
2202 + size_t datalen,
2203 + struct ip_conntrack *ct,
2204 + enum ip_conntrack_info ctinfo)
2205 +{
2206 + struct PptpControlHeader *ctlh;
2207 + union pptp_ctrl_union pptpReq;
2208 + struct ip_ct_pptp_master *info = &ct->help.ct_pptp_info;
2209 + u_int16_t msg, *cid, *pcid;
2210 +
2211 + ctlh = (struct PptpControlHeader *) ((void *) pptph + sizeof(*pptph));
2212 + pptpReq.rawreq = (void *) ((void *) ctlh + sizeof(*ctlh));
2213 +
2214 + msg = ntohs(ctlh->messageType);
2215 + DEBUGP("outbound control message %s\n", strMName[msg]);
2216 +
2217 + switch (msg) {
2218 + case PPTP_START_SESSION_REQUEST:
2219 + /* client requests for new control session */
2220 + if (info->sstate != PPTP_SESSION_NONE) {
2221 + DEBUGP("%s but we already have one",
2222 + strMName[msg]);
2223 + }
2224 + info->sstate = PPTP_SESSION_REQUESTED;
2225 + break;
2226 + case PPTP_STOP_SESSION_REQUEST:
2227 + /* client requests end of control session */
2228 + info->sstate = PPTP_SESSION_STOPREQ;
2229 + break;
2230 +
2231 + case PPTP_OUT_CALL_REQUEST:
2232 + /* client initiating connection to server */
2233 + if (info->sstate != PPTP_SESSION_CONFIRMED) {
2234 + DEBUGP("%s but no session\n",
2235 + strMName[msg]);
2236 + break;
2237 + }
2238 + info->cstate = PPTP_CALL_OUT_REQ;
2239 + /* track PNS call id */
2240 + cid = &pptpReq.ocreq->callID;
2241 + DEBUGP("%s, CID=%X\n", strMName[msg], ntohs(*cid));
2242 + info->pns_call_id = ntohs(*cid);
2243 + break;
2244 + case PPTP_IN_CALL_REPLY:
2245 + /* client answers incoming call */
2246 + if (info->cstate != PPTP_CALL_IN_REQ
2247 + && info->cstate != PPTP_CALL_IN_REP) {
2248 + DEBUGP("%s without incall_req\n",
2249 + strMName[msg]);
2250 + break;
2251 + }
2252 + if (pptpReq.icack->resultCode != PPTP_INCALL_ACCEPT) {
2253 + info->cstate = PPTP_CALL_NONE;
2254 + break;
2255 + }
2256 + pcid = &pptpReq.icack->peersCallID;
2257 + if (info->pac_call_id != ntohs(*pcid)) {
2258 + DEBUGP("%s for unknown call %u\n",
2259 + strMName[msg], ntohs(*pcid));
2260 + break;
2261 + }
2262 + DEBUGP("%s, CID=%X\n", strMName[msg], ntohs(*pcid));
2263 + /* part two of the three-way handshake */
2264 + info->cstate = PPTP_CALL_IN_REP;
2265 + info->pns_call_id = ntohs(pptpReq.icack->callID);
2266 + break;
2267 +
2268 + case PPTP_CALL_CLEAR_REQUEST:
2269 + /* client requests hangup of call */
2270 + if (info->sstate != PPTP_SESSION_CONFIRMED) {
2271 + DEBUGP("CLEAR_CALL but no session\n");
2272 + break;
2273 + }
2274 + /* FUTURE: iterate over all calls and check if
2275 + * call ID is valid. We don't do this without newnat,
2276 + * because we only know about last call */
2277 + info->cstate = PPTP_CALL_CLEAR_REQ;
2278 + break;
2279 + case PPTP_SET_LINK_INFO:
2280 + break;
2281 + case PPTP_ECHO_REQUEST:
2282 + case PPTP_ECHO_REPLY:
2283 + /* I don't have to explain these ;) */
2284 + break;
2285 + default:
2286 + DEBUGP("invalid %s (TY=%d)\n", (msg <= PPTP_MSG_MAX)?
2287 + strMName[msg]:strMName[0], msg);
2288 + /* unknown: no need to create GRE masq table entry */
2289 + break;
2290 + }
2291 +
2292 + return NF_ACCEPT;
2293 +}
2294 +
2295 +
2296 +/* track caller id inside control connection, call expect_related */
2297 +static int
2298 +conntrack_pptp_help(const struct iphdr *iph, size_t len,
2299 + struct ip_conntrack *ct, enum ip_conntrack_info ctinfo)
2300 +
2301 +{
2302 + struct pptp_pkt_hdr *pptph;
2303 +
2304 + struct tcphdr *tcph = (void *) iph + iph->ihl * 4;
2305 + u_int32_t tcplen = len - iph->ihl * 4;
2306 + u_int32_t datalen = tcplen - tcph->doff * 4;
2307 + void *datalimit;
2308 + int dir = CTINFO2DIR(ctinfo);
2309 + struct ip_ct_pptp_master *info = &ct->help.ct_pptp_info;
2310 +
2311 + int oldsstate, oldcstate;
2312 + int ret;
2313 +
2314 + /* don't do any tracking before tcp handshake complete */
2315 + if (ctinfo != IP_CT_ESTABLISHED
2316 + && ctinfo != IP_CT_ESTABLISHED+IP_CT_IS_REPLY) {
2317 + DEBUGP("ctinfo = %u, skipping\n", ctinfo);
2318 + return NF_ACCEPT;
2319 + }
2320 +
2321 + /* not a complete TCP header? */
2322 + if (tcplen < sizeof(struct tcphdr) || tcplen < tcph->doff * 4) {
2323 + DEBUGP("tcplen = %u\n", tcplen);
2324 + return NF_ACCEPT;
2325 + }
2326 +
2327 + /* checksum invalid? */
2328 + if (tcp_v4_check(tcph, tcplen, iph->saddr, iph->daddr,
2329 + csum_partial((char *) tcph, tcplen, 0))) {
2330 + printk(KERN_NOTICE __FILE__ ": bad csum\n");
2331 + /* W2K PPTP server sends TCP packets with wrong checksum :(( */
2332 + //return NF_ACCEPT;
2333 + }
2334 +
2335 + if (tcph->fin || tcph->rst) {
2336 + DEBUGP("RST/FIN received, timeouting GRE\n");
2337 + /* can't do this after real newnat */
2338 + info->cstate = PPTP_CALL_NONE;
2339 +
2340 + /* untrack this call id, unexpect GRE packets */
2341 + pptp_timeout_related(ct);
2342 + }
2343 +
2344 +
2345 + pptph = (struct pptp_pkt_hdr *) ((void *) tcph + tcph->doff * 4);
2346 + datalimit = (void *) pptph + datalen;
2347 +
2348 + /* not a full pptp packet header? */
2349 + if ((void *) pptph+sizeof(*pptph) >= datalimit) {
2350 + DEBUGP("no full PPTP header, can't track\n");
2351 + return NF_ACCEPT;
2352 + }
2353 +
2354 + /* if it's not a control message we can't do anything with it */
2355 + if (ntohs(pptph->packetType) != PPTP_PACKET_CONTROL ||
2356 + ntohl(pptph->magicCookie) != PPTP_MAGIC_COOKIE) {
2357 + DEBUGP("not a control packet\n");
2358 + return NF_ACCEPT;
2359 + }
2360 +
2361 + oldsstate = info->sstate;
2362 + oldcstate = info->cstate;
2363 +
2364 + LOCK_BH(&ip_pptp_lock);
2365 +
2366 + /* FIXME: We just blindly assume that the control connection is always
2367 + * established from PNS->PAC. However, RFC makes no guarantee */
2368 + if (dir == IP_CT_DIR_ORIGINAL)
2369 + /* client -> server (PNS -> PAC) */
2370 + ret = pptp_outbound_pkt(tcph, pptph, datalen, ct, ctinfo);
2371 + else
2372 + /* server -> client (PAC -> PNS) */
2373 + ret = pptp_inbound_pkt(tcph, pptph, datalen, ct, ctinfo);
2374 + DEBUGP("sstate: %d->%d, cstate: %d->%d\n",
2375 + oldsstate, info->sstate, oldcstate, info->cstate);
2376 + UNLOCK_BH(&ip_pptp_lock);
2377 +
2378 + return ret;
2379 +}
2380 +
2381 +/* control protocol helper */
2382 +static struct ip_conntrack_helper pptp = {
2383 + .list = { NULL, NULL },
2384 + .name = "pptp",
2385 + .flags = IP_CT_HELPER_F_REUSE_EXPECT,
2386 + .me = THIS_MODULE,
2387 + .max_expected = 2,
2388 + .timeout = 0,
2389 + .tuple = { .src = { .ip = 0,
2390 + .u = { .tcp = { .port =
2391 + __constant_htons(PPTP_CONTROL_PORT) } }
2392 + },
2393 + .dst = { .ip = 0,
2394 + .u = { .all = 0 },
2395 + .protonum = IPPROTO_TCP
2396 + }
2397 + },
2398 + .mask = { .src = { .ip = 0,
2399 + .u = { .tcp = { .port = 0xffff } }
2400 + },
2401 + .dst = { .ip = 0,
2402 + .u = { .all = 0 },
2403 + .protonum = 0xffff
2404 + }
2405 + },
2406 + .help = conntrack_pptp_help
2407 +};
2408 +
2409 +/* ip_conntrack_pptp initialization */
2410 +static int __init init(void)
2411 +{
2412 + int retcode;
2413 +
2414 + DEBUGP(__FILE__ ": registering helper\n");
2415 + if ((retcode = ip_conntrack_helper_register(&pptp))) {
2416 + printk(KERN_ERR "Unable to register conntrack application "
2417 + "helper for pptp: %d\n", retcode);
2418 + return -EIO;
2419 + }
2420 +
2421 + printk("ip_conntrack_pptp version %s loaded\n", IP_CT_PPTP_VERSION);
2422 + return 0;
2423 +}
2424 +
2425 +static void __exit fini(void)
2426 +{
2427 + ip_conntrack_helper_unregister(&pptp);
2428 + printk("ip_conntrack_pptp version %s unloaded\n", IP_CT_PPTP_VERSION);
2429 +}
2430 +
2431 +module_init(init);
2432 +module_exit(fini);
2433 +
2434 +EXPORT_SYMBOL(ip_pptp_lock);
Yousong Zhou staging tree