?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hwmon: (pmbus) Fix LINEAR16 data format
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / netfilter / nf_conntrack_proto_sctp.c
blobc6049c2d5ea8d9be54aa6f1d77accafa3b2eb920
1 /*
2 * Connection tracking protocol helper module for SCTP.
3 *
4 * SCTP is defined in RFC 2960. References to various sections in this code
5 * are to this RFC.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/types.h>
13 #include <linux/timer.h>
14 #include <linux/netfilter.h>
15 #include <linux/module.h>
16 #include <linux/in.h>
17 #include <linux/ip.h>
18 #include <linux/sctp.h>
19 #include <linux/string.h>
20 #include <linux/seq_file.h>
21 #include <linux/spinlock.h>
22 #include <linux/interrupt.h>
23
24 #include <net/netfilter/nf_conntrack.h>
25 #include <net/netfilter/nf_conntrack_l4proto.h>
26 #include <net/netfilter/nf_conntrack_ecache.h>
27
28 /* FIXME: Examine ipfilter's timeouts and conntrack transitions more
29 closely. They're more complex. --RR
30
31 And so for me for SCTP :D -Kiran */
32
33 static const char *const sctp_conntrack_names[] = {
34 "NONE",
35 "CLOSED",
36 "COOKIE_WAIT",
37 "COOKIE_ECHOED",
38 "ESTABLISHED",
39 "SHUTDOWN_SENT",
40 "SHUTDOWN_RECD",
41 "SHUTDOWN_ACK_SENT",
42 };
43
44 #define SECS * HZ
45 #define MINS * 60 SECS
46 #define HOURS * 60 MINS
47 #define DAYS * 24 HOURS
48
49 static unsigned int sctp_timeouts[SCTP_CONNTRACK_MAX] __read_mostly = {
50 [SCTP_CONNTRACK_CLOSED] = 10 SECS,
51 [SCTP_CONNTRACK_COOKIE_WAIT] = 3 SECS,
52 [SCTP_CONNTRACK_COOKIE_ECHOED] = 3 SECS,
53 [SCTP_CONNTRACK_ESTABLISHED] = 5 DAYS,
54 [SCTP_CONNTRACK_SHUTDOWN_SENT] = 300 SECS / 1000,
55 [SCTP_CONNTRACK_SHUTDOWN_RECD] = 300 SECS / 1000,
56 [SCTP_CONNTRACK_SHUTDOWN_ACK_SENT] = 3 SECS,
57 };
58
59 #define sNO SCTP_CONNTRACK_NONE
60 #define sCL SCTP_CONNTRACK_CLOSED
61 #define sCW SCTP_CONNTRACK_COOKIE_WAIT
62 #define sCE SCTP_CONNTRACK_COOKIE_ECHOED
63 #define sES SCTP_CONNTRACK_ESTABLISHED
64 #define sSS SCTP_CONNTRACK_SHUTDOWN_SENT
65 #define sSR SCTP_CONNTRACK_SHUTDOWN_RECD
66 #define sSA SCTP_CONNTRACK_SHUTDOWN_ACK_SENT
67 #define sIV SCTP_CONNTRACK_MAX
68
69 /*
70 These are the descriptions of the states:
71
72 NOTE: These state names are tantalizingly similar to the states of an
73 SCTP endpoint. But the interpretation of the states is a little different,
74 considering that these are the states of the connection and not of an end
75 point. Please note the subtleties. -Kiran
76
77 NONE - Nothing so far.
78 COOKIE WAIT - We have seen an INIT chunk in the original direction, or also
79 an INIT_ACK chunk in the reply direction.
80 COOKIE ECHOED - We have seen a COOKIE_ECHO chunk in the original direction.
81 ESTABLISHED - We have seen a COOKIE_ACK in the reply direction.
82 SHUTDOWN_SENT - We have seen a SHUTDOWN chunk in the original direction.
83 SHUTDOWN_RECD - We have seen a SHUTDOWN chunk in the reply directoin.
84 SHUTDOWN_ACK_SENT - We have seen a SHUTDOWN_ACK chunk in the direction opposite
85 to that of the SHUTDOWN chunk.
86 CLOSED - We have seen a SHUTDOWN_COMPLETE chunk in the direction of
87 the SHUTDOWN chunk. Connection is closed.
88 */
89
90 /* TODO
91 - I have assumed that the first INIT is in the original direction.
92 This messes things when an INIT comes in the reply direction in CLOSED
93 state.
94 - Check the error type in the reply dir before transitioning from
95 cookie echoed to closed.
96 - Sec 5.2.4 of RFC 2960
97 - Multi Homing support.
98 */
99
100 /* SCTP conntrack state transitions */
101 static const u8 sctp_conntracks[2][9][SCTP_CONNTRACK_MAX] = {
102 {
103 /* ORIGINAL */
104 /* sNO, sCL, sCW, sCE, sES, sSS, sSR, sSA */
105 /* init */ {sCW, sCW, sCW, sCE, sES, sSS, sSR, sSA},
106 /* init_ack */ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA},
107 /* abort */ {sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL},
108 /* shutdown */ {sCL, sCL, sCW, sCE, sSS, sSS, sSR, sSA},
109 /* shutdown_ack */ {sSA, sCL, sCW, sCE, sES, sSA, sSA, sSA},
110 /* error */ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA},/* Cant have Stale cookie*/
111 /* cookie_echo */ {sCL, sCL, sCE, sCE, sES, sSS, sSR, sSA},/* 5.2.4 - Big TODO */
112 /* cookie_ack */ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA},/* Cant come in orig dir */
113 /* shutdown_comp*/ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sCL}
114 },
115 {
116 /* REPLY */
117 /* sNO, sCL, sCW, sCE, sES, sSS, sSR, sSA */
118 /* init */ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sSA},/* INIT in sCL Big TODO */
119 /* init_ack */ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sSA},
120 /* abort */ {sIV, sCL, sCL, sCL, sCL, sCL, sCL, sCL},
121 /* shutdown */ {sIV, sCL, sCW, sCE, sSR, sSS, sSR, sSA},
122 /* shutdown_ack */ {sIV, sCL, sCW, sCE, sES, sSA, sSA, sSA},
123 /* error */ {sIV, sCL, sCW, sCL, sES, sSS, sSR, sSA},
124 /* cookie_echo */ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sSA},/* Cant come in reply dir */
125 /* cookie_ack */ {sIV, sCL, sCW, sES, sES, sSS, sSR, sSA},
126 /* shutdown_comp*/ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sCL}
127 }
128 };
129
130 static bool sctp_pkt_to_tuple(const struct sk_buff *skb, unsigned int dataoff,
131 struct nf_conntrack_tuple *tuple)
132 {
133 const struct sctphdr *hp;
134 struct sctphdr _hdr;
135
136 /* Actually only need first 8 bytes. */
137 hp = skb_header_pointer(skb, dataoff, 8, &_hdr);
138 if (hp == NULL)
139 return false;
140
141 tuple->src.u.sctp.port = hp->source;
142 tuple->dst.u.sctp.port = hp->dest;
143 return true;
144 }
145
146 static bool sctp_invert_tuple(struct nf_conntrack_tuple *tuple,
147 const struct nf_conntrack_tuple *orig)
148 {
149 tuple->src.u.sctp.port = orig->dst.u.sctp.port;
150 tuple->dst.u.sctp.port = orig->src.u.sctp.port;
151 return true;
152 }
153
154 /* Print out the per-protocol part of the tuple. */
155 static int sctp_print_tuple(struct seq_file *s,
156 const struct nf_conntrack_tuple *tuple)
157 {
158 return seq_printf(s, "sport=%hu dport=%hu ",
159 ntohs(tuple->src.u.sctp.port),
160 ntohs(tuple->dst.u.sctp.port));
161 }
162
163 /* Print out the private part of the conntrack. */
164 static int sctp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
165 {
166 enum sctp_conntrack state;
167
168 spin_lock_bh(&ct->lock);
169 state = ct->proto.sctp.state;
170 spin_unlock_bh(&ct->lock);
171
172 return seq_printf(s, "%s ", sctp_conntrack_names[state]);
173 }
174
175 #define for_each_sctp_chunk(skb, sch, _sch, offset, dataoff, count) \
176 for ((offset) = (dataoff) + sizeof(sctp_sctphdr_t), (count) = 0; \
177 (offset) < (skb)->len && \
178 ((sch) = skb_header_pointer((skb), (offset), sizeof(_sch), &(_sch))); \
179 (offset) += (ntohs((sch)->length) + 3) & ~3, (count)++)
180
181 /* Some validity checks to make sure the chunks are fine */
182 static int do_basic_checks(struct nf_conn *ct,
183 const struct sk_buff *skb,
184 unsigned int dataoff,
185 unsigned long *map)
186 {
187 u_int32_t offset, count;
188 sctp_chunkhdr_t _sch, *sch;
189 int flag;
190
191 flag = 0;
192
193 for_each_sctp_chunk (skb, sch, _sch, offset, dataoff, count) {
194 pr_debug("Chunk Num: %d Type: %d\n", count, sch->type);
195
196 if (sch->type == SCTP_CID_INIT ||
197 sch->type == SCTP_CID_INIT_ACK ||
198 sch->type == SCTP_CID_SHUTDOWN_COMPLETE)
199 flag = 1;
200
201 /*
202 * Cookie Ack/Echo chunks not the first OR
203 * Init / Init Ack / Shutdown compl chunks not the only chunks
204 * OR zero-length.
205 */
206 if (((sch->type == SCTP_CID_COOKIE_ACK ||
207 sch->type == SCTP_CID_COOKIE_ECHO ||
208 flag) &&
209 count != 0) || !sch->length) {
210 pr_debug("Basic checks failed\n");
211 return 1;
212 }
213
214 if (map)
215 set_bit(sch->type, map);
216 }
217
218 pr_debug("Basic checks passed\n");
219 return count == 0;
220 }
221
222 static int sctp_new_state(enum ip_conntrack_dir dir,
223 enum sctp_conntrack cur_state,
224 int chunk_type)
225 {
226 int i;
227
228 pr_debug("Chunk type: %d\n", chunk_type);
229
230 switch (chunk_type) {
231 case SCTP_CID_INIT:
232 pr_debug("SCTP_CID_INIT\n");
233 i = 0;
234 break;
235 case SCTP_CID_INIT_ACK:
236 pr_debug("SCTP_CID_INIT_ACK\n");
237 i = 1;
238 break;
239 case SCTP_CID_ABORT:
240 pr_debug("SCTP_CID_ABORT\n");
241 i = 2;
242 break;
243 case SCTP_CID_SHUTDOWN:
244 pr_debug("SCTP_CID_SHUTDOWN\n");
245 i = 3;
246 break;
247 case SCTP_CID_SHUTDOWN_ACK:
248 pr_debug("SCTP_CID_SHUTDOWN_ACK\n");
249 i = 4;
250 break;
251 case SCTP_CID_ERROR:
252 pr_debug("SCTP_CID_ERROR\n");
253 i = 5;
254 break;
255 case SCTP_CID_COOKIE_ECHO:
256 pr_debug("SCTP_CID_COOKIE_ECHO\n");
257 i = 6;
258 break;
259 case SCTP_CID_COOKIE_ACK:
260 pr_debug("SCTP_CID_COOKIE_ACK\n");
261 i = 7;
262 break;
263 case SCTP_CID_SHUTDOWN_COMPLETE:
264 pr_debug("SCTP_CID_SHUTDOWN_COMPLETE\n");
265 i = 8;
266 break;
267 default:
268 /* Other chunks like DATA, SACK, HEARTBEAT and
269 its ACK do not cause a change in state */
270 pr_debug("Unknown chunk type, Will stay in %s\n",
271 sctp_conntrack_names[cur_state]);
272 return cur_state;
273 }
274
275 pr_debug("dir: %d cur_state: %s chunk_type: %d new_state: %s\n",
276 dir, sctp_conntrack_names[cur_state], chunk_type,
277 sctp_conntrack_names[sctp_conntracks[dir][i][cur_state]]);
278
279 return sctp_conntracks[dir][i][cur_state];
280 }
281
282 /* Returns verdict for packet, or -NF_ACCEPT for invalid. */
283 static int sctp_packet(struct nf_conn *ct,
284 const struct sk_buff *skb,
285 unsigned int dataoff,
286 enum ip_conntrack_info ctinfo,
287 u_int8_t pf,
288 unsigned int hooknum)
289 {
290 enum sctp_conntrack new_state, old_state;
291 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
292 const struct sctphdr *sh;
293 struct sctphdr _sctph;
294 const struct sctp_chunkhdr *sch;
295 struct sctp_chunkhdr _sch;
296 u_int32_t offset, count;
297 unsigned long map[256 / sizeof(unsigned long)] = { 0 };
298
299 sh = skb_header_pointer(skb, dataoff, sizeof(_sctph), &_sctph);
300 if (sh == NULL)
301 goto out;
302
303 if (do_basic_checks(ct, skb, dataoff, map) != 0)
304 goto out;
305
306 /* Check the verification tag (Sec 8.5) */
307 if (!test_bit(SCTP_CID_INIT, map) &&
308 !test_bit(SCTP_CID_SHUTDOWN_COMPLETE, map) &&
309 !test_bit(SCTP_CID_COOKIE_ECHO, map) &&
310 !test_bit(SCTP_CID_ABORT, map) &&
311 !test_bit(SCTP_CID_SHUTDOWN_ACK, map) &&
312 sh->vtag != ct->proto.sctp.vtag[dir]) {
313 pr_debug("Verification tag check failed\n");
314 goto out;
315 }
316
317 old_state = new_state = SCTP_CONNTRACK_NONE;
318 spin_lock_bh(&ct->lock);
319 for_each_sctp_chunk (skb, sch, _sch, offset, dataoff, count) {
320 /* Special cases of Verification tag check (Sec 8.5.1) */
321 if (sch->type == SCTP_CID_INIT) {
322 /* Sec 8.5.1 (A) */
323 if (sh->vtag != 0)
324 goto out_unlock;
325 } else if (sch->type == SCTP_CID_ABORT) {
326 /* Sec 8.5.1 (B) */
327 if (sh->vtag != ct->proto.sctp.vtag[dir] &&
328 sh->vtag != ct->proto.sctp.vtag[!dir])
329 goto out_unlock;
330 } else if (sch->type == SCTP_CID_SHUTDOWN_COMPLETE) {
331 /* Sec 8.5.1 (C) */
332 if (sh->vtag != ct->proto.sctp.vtag[dir] &&
333 sh->vtag != ct->proto.sctp.vtag[!dir] &&
334 sch->flags & SCTP_CHUNK_FLAG_T)
335 goto out_unlock;
336 } else if (sch->type == SCTP_CID_COOKIE_ECHO) {
337 /* Sec 8.5.1 (D) */
338 if (sh->vtag != ct->proto.sctp.vtag[dir])
339 goto out_unlock;
340 }
341
342 old_state = ct->proto.sctp.state;
343 new_state = sctp_new_state(dir, old_state, sch->type);
344
345 /* Invalid */
346 if (new_state == SCTP_CONNTRACK_MAX) {
347 pr_debug("nf_conntrack_sctp: Invalid dir=%i ctype=%u "
348 "conntrack=%u\n",
349 dir, sch->type, old_state);
350 goto out_unlock;
351 }
352
353 /* If it is an INIT or an INIT ACK note down the vtag */
354 if (sch->type == SCTP_CID_INIT ||
355 sch->type == SCTP_CID_INIT_ACK) {
356 sctp_inithdr_t _inithdr, *ih;
357
358 ih = skb_header_pointer(skb, offset + sizeof(sctp_chunkhdr_t),
359 sizeof(_inithdr), &_inithdr);
360 if (ih == NULL)
361 goto out_unlock;
362 pr_debug("Setting vtag %x for dir %d\n",
363 ih->init_tag, !dir);
364 ct->proto.sctp.vtag[!dir] = ih->init_tag;
365 }
366
367 ct->proto.sctp.state = new_state;
368 if (old_state != new_state)
369 nf_conntrack_event_cache(IPCT_PROTOINFO, ct);
370 }
371 spin_unlock_bh(&ct->lock);
372
373 nf_ct_refresh_acct(ct, ctinfo, skb, sctp_timeouts[new_state]);
374
375 if (old_state == SCTP_CONNTRACK_COOKIE_ECHOED &&
376 dir == IP_CT_DIR_REPLY &&
377 new_state == SCTP_CONNTRACK_ESTABLISHED) {
378 pr_debug("Setting assured bit\n");
379 set_bit(IPS_ASSURED_BIT, &ct->status);
380 nf_conntrack_event_cache(IPCT_ASSURED, ct);
381 }
382
383 return NF_ACCEPT;
384
385 out_unlock:
386 spin_unlock_bh(&ct->lock);
387 out:
388 return -NF_ACCEPT;
389 }
390
391 /* Called when a new connection for this protocol found. */
392 static bool sctp_new(struct nf_conn *ct, const struct sk_buff *skb,
393 unsigned int dataoff)
394 {
395 enum sctp_conntrack new_state;
396 const struct sctphdr *sh;
397 struct sctphdr _sctph;
398 const struct sctp_chunkhdr *sch;
399 struct sctp_chunkhdr _sch;
400 u_int32_t offset, count;
401 unsigned long map[256 / sizeof(unsigned long)] = { 0 };
402
403 sh = skb_header_pointer(skb, dataoff, sizeof(_sctph), &_sctph);
404 if (sh == NULL)
405 return false;
406
407 if (do_basic_checks(ct, skb, dataoff, map) != 0)
408 return false;
409
410 /* If an OOTB packet has any of these chunks discard (Sec 8.4) */
411 if (test_bit(SCTP_CID_ABORT, map) ||
412 test_bit(SCTP_CID_SHUTDOWN_COMPLETE, map) ||
413 test_bit(SCTP_CID_COOKIE_ACK, map))
414 return false;
415
416 new_state = SCTP_CONNTRACK_MAX;
417 for_each_sctp_chunk (skb, sch, _sch, offset, dataoff, count) {
418 /* Don't need lock here: this conntrack not in circulation yet */
419 new_state = sctp_new_state(IP_CT_DIR_ORIGINAL,
420 SCTP_CONNTRACK_NONE, sch->type);
421
422 /* Invalid: delete conntrack */
423 if (new_state == SCTP_CONNTRACK_NONE ||
424 new_state == SCTP_CONNTRACK_MAX) {
425 pr_debug("nf_conntrack_sctp: invalid new deleting.\n");
426 return false;
427 }
428
429 /* Copy the vtag into the state info */
430 if (sch->type == SCTP_CID_INIT) {
431 if (sh->vtag == 0) {
432 sctp_inithdr_t _inithdr, *ih;
433
434 ih = skb_header_pointer(skb, offset + sizeof(sctp_chunkhdr_t),
435 sizeof(_inithdr), &_inithdr);
436 if (ih == NULL)
437 return false;
438
439 pr_debug("Setting vtag %x for new conn\n",
440 ih->init_tag);
441
442 ct->proto.sctp.vtag[IP_CT_DIR_REPLY] =
443 ih->init_tag;
444 } else {
445 /* Sec 8.5.1 (A) */
446 return false;
447 }
448 }
449 /* If it is a shutdown ack OOTB packet, we expect a return
450 shutdown complete, otherwise an ABORT Sec 8.4 (5) and (8) */
451 else {
452 pr_debug("Setting vtag %x for new conn OOTB\n",
453 sh->vtag);
454 ct->proto.sctp.vtag[IP_CT_DIR_REPLY] = sh->vtag;
455 }
456
457 ct->proto.sctp.state = new_state;
458 }
459
460 return true;
461 }
462
463 #if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
464
465 #include <linux/netfilter/nfnetlink.h>
466 #include <linux/netfilter/nfnetlink_conntrack.h>
467
468 static int sctp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
469 struct nf_conn *ct)
470 {
471 struct nlattr *nest_parms;
472
473 spin_lock_bh(&ct->lock);
474 nest_parms = nla_nest_start(skb, CTA_PROTOINFO_SCTP | NLA_F_NESTED);
475 if (!nest_parms)
476 goto nla_put_failure;
477
478 NLA_PUT_U8(skb, CTA_PROTOINFO_SCTP_STATE, ct->proto.sctp.state);
479
480 NLA_PUT_BE32(skb,
481 CTA_PROTOINFO_SCTP_VTAG_ORIGINAL,
482 ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL]);
483
484 NLA_PUT_BE32(skb,
485 CTA_PROTOINFO_SCTP_VTAG_REPLY,
486 ct->proto.sctp.vtag[IP_CT_DIR_REPLY]);
487
488 spin_unlock_bh(&ct->lock);
489
490 nla_nest_end(skb, nest_parms);
491
492 return 0;
493
494 nla_put_failure:
495 spin_unlock_bh(&ct->lock);
496 return -1;
497 }
498
499 static const struct nla_policy sctp_nla_policy[CTA_PROTOINFO_SCTP_MAX+1] = {
500 [CTA_PROTOINFO_SCTP_STATE] = { .type = NLA_U8 },
501 [CTA_PROTOINFO_SCTP_VTAG_ORIGINAL] = { .type = NLA_U32 },
502 [CTA_PROTOINFO_SCTP_VTAG_REPLY] = { .type = NLA_U32 },
503 };
504
505 static int nlattr_to_sctp(struct nlattr *cda[], struct nf_conn *ct)
506 {
507 struct nlattr *attr = cda[CTA_PROTOINFO_SCTP];
508 struct nlattr *tb[CTA_PROTOINFO_SCTP_MAX+1];
509 int err;
510
511 /* updates may not contain the internal protocol info, skip parsing */
512 if (!attr)
513 return 0;
514
515 err = nla_parse_nested(tb,
516 CTA_PROTOINFO_SCTP_MAX,
517 attr,
518 sctp_nla_policy);
519 if (err < 0)
520 return err;
521
522 if (!tb[CTA_PROTOINFO_SCTP_STATE] ||
523 !tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL] ||
524 !tb[CTA_PROTOINFO_SCTP_VTAG_REPLY])
525 return -EINVAL;
526
527 spin_lock_bh(&ct->lock);
528 ct->proto.sctp.state = nla_get_u8(tb[CTA_PROTOINFO_SCTP_STATE]);
529 ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL] =
530 nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL]);
531 ct->proto.sctp.vtag[IP_CT_DIR_REPLY] =
532 nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_REPLY]);
533 spin_unlock_bh(&ct->lock);
534
535 return 0;
536 }
537
538 static int sctp_nlattr_size(void)
539 {
540 return nla_total_size(0) /* CTA_PROTOINFO_SCTP */
541 + nla_policy_len(sctp_nla_policy, CTA_PROTOINFO_SCTP_MAX + 1);
542 }
543 #endif
544
545 #ifdef CONFIG_SYSCTL
546 static unsigned int sctp_sysctl_table_users;
547 static struct ctl_table_header *sctp_sysctl_header;
548 static struct ctl_table sctp_sysctl_table[] = {
549 {
550 .procname = "nf_conntrack_sctp_timeout_closed",
551 .data = &sctp_timeouts[SCTP_CONNTRACK_CLOSED],
552 .maxlen = sizeof(unsigned int),
553 .mode = 0644,
554 .proc_handler = proc_dointvec_jiffies,
555 },
556 {
557 .procname = "nf_conntrack_sctp_timeout_cookie_wait",
558 .data = &sctp_timeouts[SCTP_CONNTRACK_COOKIE_WAIT],
559 .maxlen = sizeof(unsigned int),
560 .mode = 0644,
561 .proc_handler = proc_dointvec_jiffies,
562 },
563 {
564 .procname = "nf_conntrack_sctp_timeout_cookie_echoed",
565 .data = &sctp_timeouts[SCTP_CONNTRACK_COOKIE_ECHOED],
566 .maxlen = sizeof(unsigned int),
567 .mode = 0644,
568 .proc_handler = proc_dointvec_jiffies,
569 },
570 {
571 .procname = "nf_conntrack_sctp_timeout_established",
572 .data = &sctp_timeouts[SCTP_CONNTRACK_ESTABLISHED],
573 .maxlen = sizeof(unsigned int),
574 .mode = 0644,
575 .proc_handler = proc_dointvec_jiffies,
576 },
577 {
578 .procname = "nf_conntrack_sctp_timeout_shutdown_sent",
579 .data = &sctp_timeouts[SCTP_CONNTRACK_SHUTDOWN_SENT],
580 .maxlen = sizeof(unsigned int),
581 .mode = 0644,
582 .proc_handler = proc_dointvec_jiffies,
583 },
584 {
585 .procname = "nf_conntrack_sctp_timeout_shutdown_recd",
586 .data = &sctp_timeouts[SCTP_CONNTRACK_SHUTDOWN_RECD],
587 .maxlen = sizeof(unsigned int),
588 .mode = 0644,
589 .proc_handler = proc_dointvec_jiffies,
590 },
591 {
592 .procname = "nf_conntrack_sctp_timeout_shutdown_ack_sent",
593 .data = &sctp_timeouts[SCTP_CONNTRACK_SHUTDOWN_ACK_SENT],
594 .maxlen = sizeof(unsigned int),
595 .mode = 0644,
596 .proc_handler = proc_dointvec_jiffies,
597 },
598 { }
599 };
600
601 #ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
602 static struct ctl_table sctp_compat_sysctl_table[] = {
603 {
604 .procname = "ip_conntrack_sctp_timeout_closed",
605 .data = &sctp_timeouts[SCTP_CONNTRACK_CLOSED],
606 .maxlen = sizeof(unsigned int),
607 .mode = 0644,
608 .proc_handler = proc_dointvec_jiffies,
609 },
610 {
611 .procname = "ip_conntrack_sctp_timeout_cookie_wait",
612 .data = &sctp_timeouts[SCTP_CONNTRACK_COOKIE_WAIT],
613 .maxlen = sizeof(unsigned int),
614 .mode = 0644,
615 .proc_handler = proc_dointvec_jiffies,
616 },
617 {
618 .procname = "ip_conntrack_sctp_timeout_cookie_echoed",
619 .data = &sctp_timeouts[SCTP_CONNTRACK_COOKIE_ECHOED],
620 .maxlen = sizeof(unsigned int),
621 .mode = 0644,
622 .proc_handler = proc_dointvec_jiffies,
623 },
624 {
625 .procname = "ip_conntrack_sctp_timeout_established",
626 .data = &sctp_timeouts[SCTP_CONNTRACK_ESTABLISHED],
627 .maxlen = sizeof(unsigned int),
628 .mode = 0644,
629 .proc_handler = proc_dointvec_jiffies,
630 },
631 {
632 .procname = "ip_conntrack_sctp_timeout_shutdown_sent",
633 .data = &sctp_timeouts[SCTP_CONNTRACK_SHUTDOWN_SENT],
634 .maxlen = sizeof(unsigned int),
635 .mode = 0644,
636 .proc_handler = proc_dointvec_jiffies,
637 },
638 {
639 .procname = "ip_conntrack_sctp_timeout_shutdown_recd",
640 .data = &sctp_timeouts[SCTP_CONNTRACK_SHUTDOWN_RECD],
641 .maxlen = sizeof(unsigned int),
642 .mode = 0644,
643 .proc_handler = proc_dointvec_jiffies,
644 },
645 {
646 .procname = "ip_conntrack_sctp_timeout_shutdown_ack_sent",
647 .data = &sctp_timeouts[SCTP_CONNTRACK_SHUTDOWN_ACK_SENT],
648 .maxlen = sizeof(unsigned int),
649 .mode = 0644,
650 .proc_handler = proc_dointvec_jiffies,
651 },
652 { }
653 };
654 #endif /* CONFIG_NF_CONNTRACK_PROC_COMPAT */
655 #endif
656
657 static struct nf_conntrack_l4proto nf_conntrack_l4proto_sctp4 __read_mostly = {
658 .l3proto = PF_INET,
659 .l4proto = IPPROTO_SCTP,
660 .name = "sctp",
661 .pkt_to_tuple = sctp_pkt_to_tuple,
662 .invert_tuple = sctp_invert_tuple,
663 .print_tuple = sctp_print_tuple,
664 .print_conntrack = sctp_print_conntrack,
665 .packet = sctp_packet,
666 .new = sctp_new,
667 .me = THIS_MODULE,
668 #if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
669 .to_nlattr = sctp_to_nlattr,
670 .nlattr_size = sctp_nlattr_size,
671 .from_nlattr = nlattr_to_sctp,
672 .tuple_to_nlattr = nf_ct_port_tuple_to_nlattr,
673 .nlattr_tuple_size = nf_ct_port_nlattr_tuple_size,
674 .nlattr_to_tuple = nf_ct_port_nlattr_to_tuple,
675 .nla_policy = nf_ct_port_nla_policy,
676 #endif
677 #ifdef CONFIG_SYSCTL
678 .ctl_table_users = &sctp_sysctl_table_users,
679 .ctl_table_header = &sctp_sysctl_header,
680 .ctl_table = sctp_sysctl_table,
681 #ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
682 .ctl_compat_table = sctp_compat_sysctl_table,
683 #endif
684 #endif
685 };
686
687 static struct nf_conntrack_l4proto nf_conntrack_l4proto_sctp6 __read_mostly = {
688 .l3proto = PF_INET6,
689 .l4proto = IPPROTO_SCTP,
690 .name = "sctp",
691 .pkt_to_tuple = sctp_pkt_to_tuple,
692 .invert_tuple = sctp_invert_tuple,
693 .print_tuple = sctp_print_tuple,
694 .print_conntrack = sctp_print_conntrack,
695 .packet = sctp_packet,
696 .new = sctp_new,
697 .me = THIS_MODULE,
698 #if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
699 .to_nlattr = sctp_to_nlattr,
700 .nlattr_size = sctp_nlattr_size,
701 .from_nlattr = nlattr_to_sctp,
702 .tuple_to_nlattr = nf_ct_port_tuple_to_nlattr,
703 .nlattr_tuple_size = nf_ct_port_nlattr_tuple_size,
704 .nlattr_to_tuple = nf_ct_port_nlattr_to_tuple,
705 .nla_policy = nf_ct_port_nla_policy,
706 #endif
707 #ifdef CONFIG_SYSCTL
708 .ctl_table_users = &sctp_sysctl_table_users,
709 .ctl_table_header = &sctp_sysctl_header,
710 .ctl_table = sctp_sysctl_table,
711 #endif
712 };
713
714 static int __init nf_conntrack_proto_sctp_init(void)
715 {
716 int ret;
717
718 ret = nf_conntrack_l4proto_register(&nf_conntrack_l4proto_sctp4);
719 if (ret) {
720 pr_err("nf_conntrack_l4proto_sctp4: protocol register failed\n");
721 goto out;
722 }
723 ret = nf_conntrack_l4proto_register(&nf_conntrack_l4proto_sctp6);
724 if (ret) {
725 pr_err("nf_conntrack_l4proto_sctp6: protocol register failed\n");
726 goto cleanup_sctp4;
727 }
728
729 return ret;
730
731 cleanup_sctp4:
732 nf_conntrack_l4proto_unregister(&nf_conntrack_l4proto_sctp4);
733 out:
734 return ret;
735 }
736
737 static void __exit nf_conntrack_proto_sctp_fini(void)
738 {
739 nf_conntrack_l4proto_unregister(&nf_conntrack_l4proto_sctp6);
740 nf_conntrack_l4proto_unregister(&nf_conntrack_l4proto_sctp4);
741 }
742
743 module_init(nf_conntrack_proto_sctp_init);
744 module_exit(nf_conntrack_proto_sctp_fini);
745
746 MODULE_LICENSE("GPL");
747 MODULE_AUTHOR("Kiran Kumar Immidi");
748 MODULE_DESCRIPTION("Netfilter connection tracking protocol helper for SCTP");
749 MODULE_ALIAS("ip_conntrack_proto_sctp");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree