~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/netfilter/nf_conntrack_sip.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SIP extension for IP connection tracking.
  2  *
  3  * (C) 2005 by Christian Hentschel <chentschel@arnet.com.ar>
  4  * based on RR's ip_conntrack_ftp.c and other modules.
  5  * (C) 2007 United Security Providers
  6  * (C) 2007, 2008 Patrick McHardy <kaber@trash.net>
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License version 2 as
 10  * published by the Free Software Foundation.
 11  */
 12 
 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 14 
 15 #include <linux/module.h>
 16 #include <linux/ctype.h>
 17 #include <linux/skbuff.h>
 18 #include <linux/inet.h>
 19 #include <linux/in.h>
 20 #include <linux/udp.h>
 21 #include <linux/tcp.h>
 22 #include <linux/netfilter.h>
 23 
 24 #include <net/netfilter/nf_conntrack.h>
 25 #include <net/netfilter/nf_conntrack_core.h>
 26 #include <net/netfilter/nf_conntrack_expect.h>
 27 #include <net/netfilter/nf_conntrack_helper.h>
 28 #include <net/netfilter/nf_conntrack_zones.h>
 29 #include <linux/netfilter/nf_conntrack_sip.h>
 30 
 31 MODULE_LICENSE("GPL");
 32 MODULE_AUTHOR("Christian Hentschel <chentschel@arnet.com.ar>");
 33 MODULE_DESCRIPTION("SIP connection tracking helper");
 34 MODULE_ALIAS("ip_conntrack_sip");
 35 MODULE_ALIAS_NFCT_HELPER("sip");
 36 
 37 #define MAX_PORTS       8
 38 static unsigned short ports[MAX_PORTS];
 39 static unsigned int ports_c;
 40 module_param_array(ports, ushort, &ports_c, 0400);
 41 MODULE_PARM_DESC(ports, "port numbers of SIP servers");
 42 
 43 static unsigned int sip_timeout __read_mostly = SIP_TIMEOUT;
 44 module_param(sip_timeout, uint, 0600);
 45 MODULE_PARM_DESC(sip_timeout, "timeout for the master SIP session");
 46 
 47 static int sip_direct_signalling __read_mostly = 1;
 48 module_param(sip_direct_signalling, int, 0600);
 49 MODULE_PARM_DESC(sip_direct_signalling, "expect incoming calls from registrar "
 50                                         "only (default 1)");
 51 
 52 static int sip_direct_media __read_mostly = 1;
 53 module_param(sip_direct_media, int, 0600);
 54 MODULE_PARM_DESC(sip_direct_media, "Expect Media streams between signalling "
 55                                    "endpoints only (default 1)");
 56 
 57 const struct nf_nat_sip_hooks *nf_nat_sip_hooks;
 58 EXPORT_SYMBOL_GPL(nf_nat_sip_hooks);
 59 
 60 static int string_len(const struct nf_conn *ct, const char *dptr,
 61                       const char *limit, int *shift)
 62 {
 63         int len = 0;
 64 
 65         while (dptr < limit && isalpha(*dptr)) {
 66                 dptr++;
 67                 len++;
 68         }
 69         return len;
 70 }
 71 
 72 static int digits_len(const struct nf_conn *ct, const char *dptr,
 73                       const char *limit, int *shift)
 74 {
 75         int len = 0;
 76         while (dptr < limit && isdigit(*dptr)) {
 77                 dptr++;
 78                 len++;
 79         }
 80         return len;
 81 }
 82 
 83 static int iswordc(const char c)
 84 {
 85         if (isalnum(c) || c == '!' || c == '"' || c == '%' ||
 86             (c >= '(' && c <= '+') || c == ':' || c == '<' || c == '>' ||
 87             c == '?' || (c >= '[' && c <= ']') || c == '_' || c == '`' ||
 88             c == '{' || c == '}' || c == '~' || (c >= '-' && c <= '/') ||
 89             c == '\'')
 90                 return 1;
 91         return 0;
 92 }
 93 
 94 static int word_len(const char *dptr, const char *limit)
 95 {
 96         int len = 0;
 97         while (dptr < limit && iswordc(*dptr)) {
 98                 dptr++;
 99                 len++;
100         }
101         return len;
102 }
103 
104 static int callid_len(const struct nf_conn *ct, const char *dptr,
105                       const char *limit, int *shift)
106 {
107         int len, domain_len;
108 
109         len = word_len(dptr, limit);
110         dptr += len;
111         if (!len || dptr == limit || *dptr != '@')
112                 return len;
113         dptr++;
114         len++;
115 
116         domain_len = word_len(dptr, limit);
117         if (!domain_len)
118                 return 0;
119         return len + domain_len;
120 }
121 
122 /* get media type + port length */
123 static int media_len(const struct nf_conn *ct, const char *dptr,
124                      const char *limit, int *shift)
125 {
126         int len = string_len(ct, dptr, limit, shift);
127 
128         dptr += len;
129         if (dptr >= limit || *dptr != ' ')
130                 return 0;
131         len++;
132         dptr++;
133 
134         return len + digits_len(ct, dptr, limit, shift);
135 }
136 
137 static int sip_parse_addr(const struct nf_conn *ct, const char *cp,
138                           const char **endp, union nf_inet_addr *addr,
139                           const char *limit, bool delim)
140 {
141         const char *end;
142         int ret;
143 
144         if (!ct)
145                 return 0;
146 
147         memset(addr, 0, sizeof(*addr));
148         switch (nf_ct_l3num(ct)) {
149         case AF_INET:
150                 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);
151                 if (ret == 0)
152                         return 0;
153                 break;
154         case AF_INET6:
155                 if (cp < limit && *cp == '[')
156                         cp++;
157                 else if (delim)
158                         return 0;
159 
160                 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);
161                 if (ret == 0)
162                         return 0;
163 
164                 if (end < limit && *end == ']')
165                         end++;
166                 else if (delim)
167                         return 0;
168                 break;
169         default:
170                 BUG();
171         }
172 
173         if (endp)
174                 *endp = end;
175         return 1;
176 }
177 
178 /* skip ip address. returns its length. */
179 static int epaddr_len(const struct nf_conn *ct, const char *dptr,
180                       const char *limit, int *shift)
181 {
182         union nf_inet_addr addr;
183         const char *aux = dptr;
184 
185         if (!sip_parse_addr(ct, dptr, &dptr, &addr, limit, true)) {
186                 pr_debug("ip: %s parse failed.!\n", dptr);
187                 return 0;
188         }
189 
190         /* Port number */
191         if (*dptr == ':') {
192                 dptr++;
193                 dptr += digits_len(ct, dptr, limit, shift);
194         }
195         return dptr - aux;
196 }
197 
198 /* get address length, skiping user info. */
199 static int skp_epaddr_len(const struct nf_conn *ct, const char *dptr,
200                           const char *limit, int *shift)
201 {
202         const char *start = dptr;
203         int s = *shift;
204 
205         /* Search for @, but stop at the end of the line.
206          * We are inside a sip: URI, so we don't need to worry about
207          * continuation lines. */
208         while (dptr < limit &&
209                *dptr != '@' && *dptr != '\r' && *dptr != '\n') {
210                 (*shift)++;
211                 dptr++;
212         }
213 
214         if (dptr < limit && *dptr == '@') {
215                 dptr++;
216                 (*shift)++;
217         } else {
218                 dptr = start;
219                 *shift = s;
220         }
221 
222         return epaddr_len(ct, dptr, limit, shift);
223 }
224 
225 /* Parse a SIP request line of the form:
226  *
227  * Request-Line = Method SP Request-URI SP SIP-Version CRLF
228  *
229  * and return the offset and length of the address contained in the Request-URI.
230  */
231 int ct_sip_parse_request(const struct nf_conn *ct,
232                          const char *dptr, unsigned int datalen,
233                          unsigned int *matchoff, unsigned int *matchlen,
234                          union nf_inet_addr *addr, __be16 *port)
235 {
236         const char *start = dptr, *limit = dptr + datalen, *end;
237         unsigned int mlen;
238         unsigned int p;
239         int shift = 0;
240 
241         /* Skip method and following whitespace */
242         mlen = string_len(ct, dptr, limit, NULL);
243         if (!mlen)
244                 return 0;
245         dptr += mlen;
246         if (++dptr >= limit)
247                 return 0;
248 
249         /* Find SIP URI */
250         for (; dptr < limit - strlen("sip:"); dptr++) {
251                 if (*dptr == '\r' || *dptr == '\n')
252                         return -1;
253                 if (strncasecmp(dptr, "sip:", strlen("sip:")) == 0) {
254                         dptr += strlen("sip:");
255                         break;
256                 }
257         }
258         if (!skp_epaddr_len(ct, dptr, limit, &shift))
259                 return 0;
260         dptr += shift;
261 
262         if (!sip_parse_addr(ct, dptr, &end, addr, limit, true))
263                 return -1;
264         if (end < limit && *end == ':') {
265                 end++;
266                 p = simple_strtoul(end, (char **)&end, 10);
267                 if (p < 1024 || p > 65535)
268                         return -1;
269                 *port = htons(p);
270         } else
271                 *port = htons(SIP_PORT);
272 
273         if (end == dptr)
274                 return 0;
275         *matchoff = dptr - start;
276         *matchlen = end - dptr;
277         return 1;
278 }
279 EXPORT_SYMBOL_GPL(ct_sip_parse_request);
280 
281 /* SIP header parsing: SIP headers are located at the beginning of a line, but
282  * may span several lines, in which case the continuation lines begin with a
283  * whitespace character. RFC 2543 allows lines to be terminated with CR, LF or
284  * CRLF, RFC 3261 allows only CRLF, we support both.
285  *
286  * Headers are followed by (optionally) whitespace, a colon, again (optionally)
287  * whitespace and the values. Whitespace in this context means any amount of
288  * tabs, spaces and continuation lines, which are treated as a single whitespace
289  * character.
290  *
291  * Some headers may appear multiple times. A comma separated list of values is
292  * equivalent to multiple headers.
293  */
294 static const struct sip_header ct_sip_hdrs[] = {
295         [SIP_HDR_CSEQ]                  = SIP_HDR("CSeq", NULL, NULL, digits_len),
296         [SIP_HDR_FROM]                  = SIP_HDR("From", "f", "sip:", skp_epaddr_len),
297         [SIP_HDR_TO]                    = SIP_HDR("To", "t", "sip:", skp_epaddr_len),
298         [SIP_HDR_CONTACT]               = SIP_HDR("Contact", "m", "sip:", skp_epaddr_len),
299         [SIP_HDR_VIA_UDP]               = SIP_HDR("Via", "v", "UDP ", epaddr_len),
300         [SIP_HDR_VIA_TCP]               = SIP_HDR("Via", "v", "TCP ", epaddr_len),
301         [SIP_HDR_EXPIRES]               = SIP_HDR("Expires", NULL, NULL, digits_len),
302         [SIP_HDR_CONTENT_LENGTH]        = SIP_HDR("Content-Length", "l", NULL, digits_len),
303         [SIP_HDR_CALL_ID]               = SIP_HDR("Call-Id", "i", NULL, callid_len),
304 };
305 
306 static const char *sip_follow_continuation(const char *dptr, const char *limit)
307 {
308         /* Walk past newline */
309         if (++dptr >= limit)
310                 return NULL;
311 
312         /* Skip '\n' in CR LF */
313         if (*(dptr - 1) == '\r' && *dptr == '\n') {
314                 if (++dptr >= limit)
315                         return NULL;
316         }
317 
318         /* Continuation line? */
319         if (*dptr != ' ' && *dptr != '\t')
320                 return NULL;
321 
322         /* skip leading whitespace */
323         for (; dptr < limit; dptr++) {
324                 if (*dptr != ' ' && *dptr != '\t')
325                         break;
326         }
327         return dptr;
328 }
329 
330 static const char *sip_skip_whitespace(const char *dptr, const char *limit)
331 {
332         for (; dptr < limit; dptr++) {
333                 if (*dptr == ' ' || *dptr == '\t')
334                         continue;
335                 if (*dptr != '\r' && *dptr != '\n')
336                         break;
337                 dptr = sip_follow_continuation(dptr, limit);
338                 break;
339         }
340         return dptr;
341 }
342 
343 /* Search within a SIP header value, dealing with continuation lines */
344 static const char *ct_sip_header_search(const char *dptr, const char *limit,
345                                         const char *needle, unsigned int len)
346 {
347         for (limit -= len; dptr < limit; dptr++) {
348                 if (*dptr == '\r' || *dptr == '\n') {
349                         dptr = sip_follow_continuation(dptr, limit);
350                         if (dptr == NULL)
351                                 break;
352                         continue;
353                 }
354 
355                 if (strncasecmp(dptr, needle, len) == 0)
356                         return dptr;
357         }
358         return NULL;
359 }
360 
361 int ct_sip_get_header(const struct nf_conn *ct, const char *dptr,
362                       unsigned int dataoff, unsigned int datalen,
363                       enum sip_header_types type,
364                       unsigned int *matchoff, unsigned int *matchlen)
365 {
366         const struct sip_header *hdr = &ct_sip_hdrs[type];
367         const char *start = dptr, *limit = dptr + datalen;
368         int shift = 0;
369 
370         for (dptr += dataoff; dptr < limit; dptr++) {
371                 /* Find beginning of line */
372                 if (*dptr != '\r' && *dptr != '\n')
373                         continue;
374                 if (++dptr >= limit)
375                         break;
376                 if (*(dptr - 1) == '\r' && *dptr == '\n') {
377                         if (++dptr >= limit)
378                                 break;
379                 }
380 
381                 /* Skip continuation lines */
382                 if (*dptr == ' ' || *dptr == '\t')
383                         continue;
384 
385                 /* Find header. Compact headers must be followed by a
386                  * non-alphabetic character to avoid mismatches. */
387                 if (limit - dptr >= hdr->len &&
388                     strncasecmp(dptr, hdr->name, hdr->len) == 0)
389                         dptr += hdr->len;
390                 else if (hdr->cname && limit - dptr >= hdr->clen + 1 &&
391                          strncasecmp(dptr, hdr->cname, hdr->clen) == 0 &&
392                          !isalpha(*(dptr + hdr->clen)))
393                         dptr += hdr->clen;
394                 else
395                         continue;
396 
397                 /* Find and skip colon */
398                 dptr = sip_skip_whitespace(dptr, limit);
399                 if (dptr == NULL)
400                         break;
401                 if (*dptr != ':' || ++dptr >= limit)
402                         break;
403 
404                 /* Skip whitespace after colon */
405                 dptr = sip_skip_whitespace(dptr, limit);
406                 if (dptr == NULL)
407                         break;
408 
409                 *matchoff = dptr - start;
410                 if (hdr->search) {
411                         dptr = ct_sip_header_search(dptr, limit, hdr->search,
412                                                     hdr->slen);
413                         if (!dptr)
414                                 return -1;
415                         dptr += hdr->slen;
416                 }
417 
418                 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
419                 if (!*matchlen)
420                         return -1;
421                 *matchoff = dptr - start + shift;
422                 return 1;
423         }
424         return 0;
425 }
426 EXPORT_SYMBOL_GPL(ct_sip_get_header);
427 
428 /* Get next header field in a list of comma separated values */
429 static int ct_sip_next_header(const struct nf_conn *ct, const char *dptr,
430                               unsigned int dataoff, unsigned int datalen,
431                               enum sip_header_types type,
432                               unsigned int *matchoff, unsigned int *matchlen)
433 {
434         const struct sip_header *hdr = &ct_sip_hdrs[type];
435         const char *start = dptr, *limit = dptr + datalen;
436         int shift = 0;
437 
438         dptr += dataoff;
439 
440         dptr = ct_sip_header_search(dptr, limit, ",", strlen(","));
441         if (!dptr)
442                 return 0;
443 
444         dptr = ct_sip_header_search(dptr, limit, hdr->search, hdr->slen);
445         if (!dptr)
446                 return 0;
447         dptr += hdr->slen;
448 
449         *matchoff = dptr - start;
450         *matchlen = hdr->match_len(ct, dptr, limit, &shift);
451         if (!*matchlen)
452                 return -1;
453         *matchoff += shift;
454         return 1;
455 }
456 
457 /* Walk through headers until a parsable one is found or no header of the
458  * given type is left. */
459 static int ct_sip_walk_headers(const struct nf_conn *ct, const char *dptr,
460                                unsigned int dataoff, unsigned int datalen,
461                                enum sip_header_types type, int *in_header,
462                                unsigned int *matchoff, unsigned int *matchlen)
463 {
464         int ret;
465 
466         if (in_header && *in_header) {
467                 while (1) {
468                         ret = ct_sip_next_header(ct, dptr, dataoff, datalen,
469                                                  type, matchoff, matchlen);
470                         if (ret > 0)
471                                 return ret;
472                         if (ret == 0)
473                                 break;
474                         dataoff += *matchoff;
475                 }
476                 *in_header = 0;
477         }
478 
479         while (1) {
480                 ret = ct_sip_get_header(ct, dptr, dataoff, datalen,
481                                         type, matchoff, matchlen);
482                 if (ret > 0)
483                         break;
484                 if (ret == 0)
485                         return ret;
486                 dataoff += *matchoff;
487         }
488 
489         if (in_header)
490                 *in_header = 1;
491         return 1;
492 }
493 
494 /* Locate a SIP header, parse the URI and return the offset and length of
495  * the address as well as the address and port themselves. A stream of
496  * headers can be parsed by handing in a non-NULL datalen and in_header
497  * pointer.
498  */
499 int ct_sip_parse_header_uri(const struct nf_conn *ct, const char *dptr,
500                             unsigned int *dataoff, unsigned int datalen,
501                             enum sip_header_types type, int *in_header,
502                             unsigned int *matchoff, unsigned int *matchlen,
503                             union nf_inet_addr *addr, __be16 *port)
504 {
505         const char *c, *limit = dptr + datalen;
506         unsigned int p;
507         int ret;
508 
509         ret = ct_sip_walk_headers(ct, dptr, dataoff ? *dataoff : 0, datalen,
510                                   type, in_header, matchoff, matchlen);
511         WARN_ON(ret < 0);
512         if (ret == 0)
513                 return ret;
514 
515         if (!sip_parse_addr(ct, dptr + *matchoff, &c, addr, limit, true))
516                 return -1;
517         if (*c == ':') {
518                 c++;
519                 p = simple_strtoul(c, (char **)&c, 10);
520                 if (p < 1024 || p > 65535)
521                         return -1;
522                 *port = htons(p);
523         } else
524                 *port = htons(SIP_PORT);
525 
526         if (dataoff)
527                 *dataoff = c - dptr;
528         return 1;
529 }
530 EXPORT_SYMBOL_GPL(ct_sip_parse_header_uri);
531 
532 static int ct_sip_parse_param(const struct nf_conn *ct, const char *dptr,
533                               unsigned int dataoff, unsigned int datalen,
534                               const char *name,
535                               unsigned int *matchoff, unsigned int *matchlen)
536 {
537         const char *limit = dptr + datalen;
538         const char *start;
539         const char *end;
540 
541         limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
542         if (!limit)
543                 limit = dptr + datalen;
544 
545         start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
546         if (!start)
547                 return 0;
548         start += strlen(name);
549 
550         end = ct_sip_header_search(start, limit, ";", strlen(";"));
551         if (!end)
552                 end = limit;
553 
554         *matchoff = start - dptr;
555         *matchlen = end - start;
556         return 1;
557 }
558 
559 /* Parse address from header parameter and return address, offset and length */
560 int ct_sip_parse_address_param(const struct nf_conn *ct, const char *dptr,
561                                unsigned int dataoff, unsigned int datalen,
562                                const char *name,
563                                unsigned int *matchoff, unsigned int *matchlen,
564                                union nf_inet_addr *addr, bool delim)
565 {
566         const char *limit = dptr + datalen;
567         const char *start, *end;
568 
569         limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
570         if (!limit)
571                 limit = dptr + datalen;
572 
573         start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
574         if (!start)
575                 return 0;
576 
577         start += strlen(name);
578         if (!sip_parse_addr(ct, start, &end, addr, limit, delim))
579                 return 0;
580         *matchoff = start - dptr;
581         *matchlen = end - start;
582         return 1;
583 }
584 EXPORT_SYMBOL_GPL(ct_sip_parse_address_param);
585 
586 /* Parse numerical header parameter and return value, offset and length */
587 int ct_sip_parse_numerical_param(const struct nf_conn *ct, const char *dptr,
588                                  unsigned int dataoff, unsigned int datalen,
589                                  const char *name,
590                                  unsigned int *matchoff, unsigned int *matchlen,
591                                  unsigned int *val)
592 {
593         const char *limit = dptr + datalen;
594         const char *start;
595         char *end;
596 
597         limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
598         if (!limit)
599                 limit = dptr + datalen;
600 
601         start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
602         if (!start)
603                 return 0;
604 
605         start += strlen(name);
606         *val = simple_strtoul(start, &end, 0);
607         if (start == end)
608                 return 0;
609         if (matchoff && matchlen) {
610                 *matchoff = start - dptr;
611                 *matchlen = end - start;
612         }
613         return 1;
614 }
615 EXPORT_SYMBOL_GPL(ct_sip_parse_numerical_param);
616 
617 static int ct_sip_parse_transport(struct nf_conn *ct, const char *dptr,
618                                   unsigned int dataoff, unsigned int datalen,
619                                   u8 *proto)
620 {
621         unsigned int matchoff, matchlen;
622 
623         if (ct_sip_parse_param(ct, dptr, dataoff, datalen, "transport=",
624                                &matchoff, &matchlen)) {
625                 if (!strncasecmp(dptr + matchoff, "TCP", strlen("TCP")))
626                         *proto = IPPROTO_TCP;
627                 else if (!strncasecmp(dptr + matchoff, "UDP", strlen("UDP")))
628                         *proto = IPPROTO_UDP;
629                 else
630                         return 0;
631 
632                 if (*proto != nf_ct_protonum(ct))
633                         return 0;
634         } else
635                 *proto = nf_ct_protonum(ct);
636 
637         return 1;
638 }
639 
640 static int sdp_parse_addr(const struct nf_conn *ct, const char *cp,
641                           const char **endp, union nf_inet_addr *addr,
642                           const char *limit)
643 {
644         const char *end;
645         int ret;
646 
647         memset(addr, 0, sizeof(*addr));
648         switch (nf_ct_l3num(ct)) {
649         case AF_INET:
650                 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);
651                 break;
652         case AF_INET6:
653                 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);
654                 break;
655         default:
656                 BUG();
657         }
658 
659         if (ret == 0)
660                 return 0;
661         if (endp)
662                 *endp = end;
663         return 1;
664 }
665 
666 /* skip ip address. returns its length. */
667 static int sdp_addr_len(const struct nf_conn *ct, const char *dptr,
668                         const char *limit, int *shift)
669 {
670         union nf_inet_addr addr;
671         const char *aux = dptr;
672 
673         if (!sdp_parse_addr(ct, dptr, &dptr, &addr, limit)) {
674                 pr_debug("ip: %s parse failed.!\n", dptr);
675                 return 0;
676         }
677 
678         return dptr - aux;
679 }
680 
681 /* SDP header parsing: a SDP session description contains an ordered set of
682  * headers, starting with a section containing general session parameters,
683  * optionally followed by multiple media descriptions.
684  *
685  * SDP headers always start at the beginning of a line. According to RFC 2327:
686  * "The sequence CRLF (0x0d0a) is used to end a record, although parsers should
687  * be tolerant and also accept records terminated with a single newline
688  * character". We handle both cases.
689  */
690 static const struct sip_header ct_sdp_hdrs_v4[] = {
691         [SDP_HDR_VERSION]       = SDP_HDR("v=", NULL, digits_len),
692         [SDP_HDR_OWNER]         = SDP_HDR("o=", "IN IP4 ", sdp_addr_len),
693         [SDP_HDR_CONNECTION]    = SDP_HDR("c=", "IN IP4 ", sdp_addr_len),
694         [SDP_HDR_MEDIA]         = SDP_HDR("m=", NULL, media_len),
695 };
696 
697 static const struct sip_header ct_sdp_hdrs_v6[] = {
698         [SDP_HDR_VERSION]       = SDP_HDR("v=", NULL, digits_len),
699         [SDP_HDR_OWNER]         = SDP_HDR("o=", "IN IP6 ", sdp_addr_len),
700         [SDP_HDR_CONNECTION]    = SDP_HDR("c=", "IN IP6 ", sdp_addr_len),
701         [SDP_HDR_MEDIA]         = SDP_HDR("m=", NULL, media_len),
702 };
703 
704 /* Linear string search within SDP header values */
705 static const char *ct_sdp_header_search(const char *dptr, const char *limit,
706                                         const char *needle, unsigned int len)
707 {
708         for (limit -= len; dptr < limit; dptr++) {
709                 if (*dptr == '\r' || *dptr == '\n')
710                         break;
711                 if (strncmp(dptr, needle, len) == 0)
712                         return dptr;
713         }
714         return NULL;
715 }
716 
717 /* Locate a SDP header (optionally a substring within the header value),
718  * optionally stopping at the first occurrence of the term header, parse
719  * it and return the offset and length of the data we're interested in.
720  */
721 int ct_sip_get_sdp_header(const struct nf_conn *ct, const char *dptr,
722                           unsigned int dataoff, unsigned int datalen,
723                           enum sdp_header_types type,
724                           enum sdp_header_types term,
725                           unsigned int *matchoff, unsigned int *matchlen)
726 {
727         const struct sip_header *hdrs, *hdr, *thdr;
728         const char *start = dptr, *limit = dptr + datalen;
729         int shift = 0;
730 
731         hdrs = nf_ct_l3num(ct) == NFPROTO_IPV4 ? ct_sdp_hdrs_v4 : ct_sdp_hdrs_v6;
732         hdr = &hdrs[type];
733         thdr = &hdrs[term];
734 
735         for (dptr += dataoff; dptr < limit; dptr++) {
736                 /* Find beginning of line */
737                 if (*dptr != '\r' && *dptr != '\n')
738                         continue;
739                 if (++dptr >= limit)
740                         break;
741                 if (*(dptr - 1) == '\r' && *dptr == '\n') {
742                         if (++dptr >= limit)
743                                 break;
744                 }
745 
746                 if (term != SDP_HDR_UNSPEC &&
747                     limit - dptr >= thdr->len &&
748                     strncasecmp(dptr, thdr->name, thdr->len) == 0)
749                         break;
750                 else if (limit - dptr >= hdr->len &&
751                          strncasecmp(dptr, hdr->name, hdr->len) == 0)
752                         dptr += hdr->len;
753                 else
754                         continue;
755 
756                 *matchoff = dptr - start;
757                 if (hdr->search) {
758                         dptr = ct_sdp_header_search(dptr, limit, hdr->search,
759                                                     hdr->slen);
760                         if (!dptr)
761                                 return -1;
762                         dptr += hdr->slen;
763                 }
764 
765                 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
766                 if (!*matchlen)
767                         return -1;
768                 *matchoff = dptr - start + shift;
769                 return 1;
770         }
771         return 0;
772 }
773 EXPORT_SYMBOL_GPL(ct_sip_get_sdp_header);
774 
775 static int ct_sip_parse_sdp_addr(const struct nf_conn *ct, const char *dptr,
776                                  unsigned int dataoff, unsigned int datalen,
777                                  enum sdp_header_types type,
778                                  enum sdp_header_types term,
779                                  unsigned int *matchoff, unsigned int *matchlen,
780                                  union nf_inet_addr *addr)
781 {
782         int ret;
783 
784         ret = ct_sip_get_sdp_header(ct, dptr, dataoff, datalen, type, term,
785                                     matchoff, matchlen);
786         if (ret <= 0)
787                 return ret;
788 
789         if (!sdp_parse_addr(ct, dptr + *matchoff, NULL, addr,
790                             dptr + *matchoff + *matchlen))
791                 return -1;
792         return 1;
793 }
794 
795 static int refresh_signalling_expectation(struct nf_conn *ct,
796                                           union nf_inet_addr *addr,
797                                           u8 proto, __be16 port,
798                                           unsigned int expires)
799 {
800         struct nf_conn_help *help = nfct_help(ct);
801         struct nf_conntrack_expect *exp;
802         struct hlist_node *next;
803         int found = 0;
804 
805         spin_lock_bh(&nf_conntrack_expect_lock);
806         hlist_for_each_entry_safe(exp, next, &help->expectations, lnode) {
807                 if (exp->class != SIP_EXPECT_SIGNALLING ||
808                     !nf_inet_addr_cmp(&exp->tuple.dst.u3, addr) ||
809                     exp->tuple.dst.protonum != proto ||
810                     exp->tuple.dst.u.udp.port != port)
811                         continue;
812                 if (mod_timer_pending(&exp->timeout, jiffies + expires * HZ)) {
813                         exp->flags &= ~NF_CT_EXPECT_INACTIVE;
814                         found = 1;
815                         break;
816                 }
817         }
818         spin_unlock_bh(&nf_conntrack_expect_lock);
819         return found;
820 }
821 
822 static void flush_expectations(struct nf_conn *ct, bool media)
823 {
824         struct nf_conn_help *help = nfct_help(ct);
825         struct nf_conntrack_expect *exp;
826         struct hlist_node *next;
827 
828         spin_lock_bh(&nf_conntrack_expect_lock);
829         hlist_for_each_entry_safe(exp, next, &help->expectations, lnode) {
830                 if ((exp->class != SIP_EXPECT_SIGNALLING) ^ media)
831                         continue;
832                 if (!nf_ct_remove_expect(exp))
833                         continue;
834                 if (!media)
835                         break;
836         }
837         spin_unlock_bh(&nf_conntrack_expect_lock);
838 }
839 
840 static int set_expected_rtp_rtcp(struct sk_buff *skb, unsigned int protoff,
841                                  unsigned int dataoff,
842                                  const char **dptr, unsigned int *datalen,
843                                  union nf_inet_addr *daddr, __be16 port,
844                                  enum sip_expectation_classes class,
845                                  unsigned int mediaoff, unsigned int medialen)
846 {
847         struct nf_conntrack_expect *exp, *rtp_exp, *rtcp_exp;
848         enum ip_conntrack_info ctinfo;
849         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
850         struct net *net = nf_ct_net(ct);
851         enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
852         union nf_inet_addr *saddr;
853         struct nf_conntrack_tuple tuple;
854         int direct_rtp = 0, skip_expect = 0, ret = NF_DROP;
855         u_int16_t base_port;
856         __be16 rtp_port, rtcp_port;
857         const struct nf_nat_sip_hooks *hooks;
858 
859         saddr = NULL;
860         if (sip_direct_media) {
861                 if (!nf_inet_addr_cmp(daddr, &ct->tuplehash[dir].tuple.src.u3))
862                         return NF_ACCEPT;
863                 saddr = &ct->tuplehash[!dir].tuple.src.u3;
864         }
865 
866         /* We need to check whether the registration exists before attempting
867          * to register it since we can see the same media description multiple
868          * times on different connections in case multiple endpoints receive
869          * the same call.
870          *
871          * RTP optimization: if we find a matching media channel expectation
872          * and both the expectation and this connection are SNATed, we assume
873          * both sides can reach each other directly and use the final
874          * destination address from the expectation. We still need to keep
875          * the NATed expectations for media that might arrive from the
876          * outside, and additionally need to expect the direct RTP stream
877          * in case it passes through us even without NAT.
878          */
879         memset(&tuple, 0, sizeof(tuple));
880         if (saddr)
881                 tuple.src.u3 = *saddr;
882         tuple.src.l3num         = nf_ct_l3num(ct);
883         tuple.dst.protonum      = IPPROTO_UDP;
884         tuple.dst.u3            = *daddr;
885         tuple.dst.u.udp.port    = port;
886 
887         rcu_read_lock();
888         do {
889                 exp = __nf_ct_expect_find(net, nf_ct_zone(ct), &tuple);
890 
891                 if (!exp || exp->master == ct ||
892                     nfct_help(exp->master)->helper != nfct_help(ct)->helper ||
893                     exp->class != class)
894                         break;
895 #ifdef CONFIG_NF_NAT_NEEDED
896                 if (!direct_rtp &&
897                     (!nf_inet_addr_cmp(&exp->saved_addr, &exp->tuple.dst.u3) ||
898                      exp->saved_proto.udp.port != exp->tuple.dst.u.udp.port) &&
899                     ct->status & IPS_NAT_MASK) {
900                         *daddr                  = exp->saved_addr;
901                         tuple.dst.u3            = exp->saved_addr;
902                         tuple.dst.u.udp.port    = exp->saved_proto.udp.port;
903                         direct_rtp = 1;
904                 } else
905 #endif
906                         skip_expect = 1;
907         } while (!skip_expect);
908 
909         base_port = ntohs(tuple.dst.u.udp.port) & ~1;
910         rtp_port = htons(base_port);
911         rtcp_port = htons(base_port + 1);
912 
913         if (direct_rtp) {
914                 hooks = rcu_dereference(nf_nat_sip_hooks);
915                 if (hooks &&
916                     !hooks->sdp_port(skb, protoff, dataoff, dptr, datalen,
917                                      mediaoff, medialen, ntohs(rtp_port)))
918                         goto err1;
919         }
920 
921         if (skip_expect) {
922                 rcu_read_unlock();
923                 return NF_ACCEPT;
924         }
925 
926         rtp_exp = nf_ct_expect_alloc(ct);
927         if (rtp_exp == NULL)
928                 goto err1;
929         nf_ct_expect_init(rtp_exp, class, nf_ct_l3num(ct), saddr, daddr,
930                           IPPROTO_UDP, NULL, &rtp_port);
931 
932         rtcp_exp = nf_ct_expect_alloc(ct);
933         if (rtcp_exp == NULL)
934                 goto err2;
935         nf_ct_expect_init(rtcp_exp, class, nf_ct_l3num(ct), saddr, daddr,
936                           IPPROTO_UDP, NULL, &rtcp_port);
937 
938         hooks = rcu_dereference(nf_nat_sip_hooks);
939         if (hooks && ct->status & IPS_NAT_MASK && !direct_rtp)
940                 ret = hooks->sdp_media(skb, protoff, dataoff, dptr,
941                                        datalen, rtp_exp, rtcp_exp,
942                                        mediaoff, medialen, daddr);
943         else {
944                 if (nf_ct_expect_related(rtp_exp) == 0) {
945                         if (nf_ct_expect_related(rtcp_exp) != 0)
946                                 nf_ct_unexpect_related(rtp_exp);
947                         else
948                                 ret = NF_ACCEPT;
949                 }
950         }
951         nf_ct_expect_put(rtcp_exp);
952 err2:
953         nf_ct_expect_put(rtp_exp);
954 err1:
955         rcu_read_unlock();
956         return ret;
957 }
958 
959 static const struct sdp_media_type sdp_media_types[] = {
960         SDP_MEDIA_TYPE("audio ", SIP_EXPECT_AUDIO),
961         SDP_MEDIA_TYPE("video ", SIP_EXPECT_VIDEO),
962         SDP_MEDIA_TYPE("image ", SIP_EXPECT_IMAGE),
963 };
964 
965 static const struct sdp_media_type *sdp_media_type(const char *dptr,
966                                                    unsigned int matchoff,
967                                                    unsigned int matchlen)
968 {
969         const struct sdp_media_type *t;
970         unsigned int i;
971 
972         for (i = 0; i < ARRAY_SIZE(sdp_media_types); i++) {
973                 t = &sdp_media_types[i];
974                 if (matchlen < t->len ||
975                     strncmp(dptr + matchoff, t->name, t->len))
976                         continue;
977                 return t;
978         }
979         return NULL;
980 }
981 
982 static int process_sdp(struct sk_buff *skb, unsigned int protoff,
983                        unsigned int dataoff,
984                        const char **dptr, unsigned int *datalen,
985                        unsigned int cseq)
986 {
987         enum ip_conntrack_info ctinfo;
988         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
989         unsigned int matchoff, matchlen;
990         unsigned int mediaoff, medialen;
991         unsigned int sdpoff;
992         unsigned int caddr_len, maddr_len;
993         unsigned int i;
994         union nf_inet_addr caddr, maddr, rtp_addr;
995         const struct nf_nat_sip_hooks *hooks;
996         unsigned int port;
997         const struct sdp_media_type *t;
998         int ret = NF_ACCEPT;
999 
1000         hooks = rcu_dereference(nf_nat_sip_hooks);
1001 
1002         /* Find beginning of session description */
1003         if (ct_sip_get_sdp_header(ct, *dptr, 0, *datalen,
1004                                   SDP_HDR_VERSION, SDP_HDR_UNSPEC,
1005                                   &matchoff, &matchlen) <= 0)
1006                 return NF_ACCEPT;
1007         sdpoff = matchoff;
1008 
1009         /* The connection information is contained in the session description
1010          * and/or once per media description. The first media description marks
1011          * the end of the session description. */
1012         caddr_len = 0;
1013         if (ct_sip_parse_sdp_addr(ct, *dptr, sdpoff, *datalen,
1014                                   SDP_HDR_CONNECTION, SDP_HDR_MEDIA,
1015                                   &matchoff, &matchlen, &caddr) > 0)
1016                 caddr_len = matchlen;
1017 
1018         mediaoff = sdpoff;
1019         for (i = 0; i < ARRAY_SIZE(sdp_media_types); ) {
1020                 if (ct_sip_get_sdp_header(ct, *dptr, mediaoff, *datalen,
1021                                           SDP_HDR_MEDIA, SDP_HDR_UNSPEC,
1022                                           &mediaoff, &medialen) <= 0)
1023                         break;
1024 
1025                 /* Get media type and port number. A media port value of zero
1026                  * indicates an inactive stream. */
1027                 t = sdp_media_type(*dptr, mediaoff, medialen);
1028                 if (!t) {
1029                         mediaoff += medialen;
1030                         continue;
1031                 }
1032                 mediaoff += t->len;
1033                 medialen -= t->len;
1034 
1035                 port = simple_strtoul(*dptr + mediaoff, NULL, 10);
1036                 if (port == 0)
1037                         continue;
1038                 if (port < 1024 || port > 65535) {
1039                         nf_ct_helper_log(skb, ct, "wrong port %u", port);
1040                         return NF_DROP;
1041                 }
1042 
1043                 /* The media description overrides the session description. */
1044                 maddr_len = 0;
1045                 if (ct_sip_parse_sdp_addr(ct, *dptr, mediaoff, *datalen,
1046                                           SDP_HDR_CONNECTION, SDP_HDR_MEDIA,
1047                                           &matchoff, &matchlen, &maddr) > 0) {
1048                         maddr_len = matchlen;
1049                         memcpy(&rtp_addr, &maddr, sizeof(rtp_addr));
1050                 } else if (caddr_len)
1051                         memcpy(&rtp_addr, &caddr, sizeof(rtp_addr));
1052                 else {
1053                         nf_ct_helper_log(skb, ct, "cannot parse SDP message");
1054                         return NF_DROP;
1055                 }
1056 
1057                 ret = set_expected_rtp_rtcp(skb, protoff, dataoff,
1058                                             dptr, datalen,
1059                                             &rtp_addr, htons(port), t->class,
1060                                             mediaoff, medialen);
1061                 if (ret != NF_ACCEPT) {
1062                         nf_ct_helper_log(skb, ct,
1063                                          "cannot add expectation for voice");
1064                         return ret;
1065                 }
1066 
1067                 /* Update media connection address if present */
1068                 if (maddr_len && hooks && ct->status & IPS_NAT_MASK) {
1069                         ret = hooks->sdp_addr(skb, protoff, dataoff,
1070                                               dptr, datalen, mediaoff,
1071                                               SDP_HDR_CONNECTION,
1072                                               SDP_HDR_MEDIA,
1073                                               &rtp_addr);
1074                         if (ret != NF_ACCEPT) {
1075                                 nf_ct_helper_log(skb, ct, "cannot mangle SDP");
1076                                 return ret;
1077                         }
1078                 }
1079                 i++;
1080         }
1081 
1082         /* Update session connection and owner addresses */
1083         hooks = rcu_dereference(nf_nat_sip_hooks);
1084         if (hooks && ct->status & IPS_NAT_MASK)
1085                 ret = hooks->sdp_session(skb, protoff, dataoff,
1086                                          dptr, datalen, sdpoff,
1087                                          &rtp_addr);
1088 
1089         return ret;
1090 }
1091 static int process_invite_response(struct sk_buff *skb, unsigned int protoff,
1092                                    unsigned int dataoff,
1093                                    const char **dptr, unsigned int *datalen,
1094                                    unsigned int cseq, unsigned int code)
1095 {
1096         enum ip_conntrack_info ctinfo;
1097         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1098         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1099 
1100         if ((code >= 100 && code <= 199) ||
1101             (code >= 200 && code <= 299))
1102                 return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1103         else if (ct_sip_info->invite_cseq == cseq)
1104                 flush_expectations(ct, true);
1105         return NF_ACCEPT;
1106 }
1107 
1108 static int process_update_response(struct sk_buff *skb, unsigned int protoff,
1109                                    unsigned int dataoff,
1110                                    const char **dptr, unsigned int *datalen,
1111                                    unsigned int cseq, unsigned int code)
1112 {
1113         enum ip_conntrack_info ctinfo;
1114         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1115         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1116 
1117         if ((code >= 100 && code <= 199) ||
1118             (code >= 200 && code <= 299))
1119                 return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1120         else if (ct_sip_info->invite_cseq == cseq)
1121                 flush_expectations(ct, true);
1122         return NF_ACCEPT;
1123 }
1124 
1125 static int process_prack_response(struct sk_buff *skb, unsigned int protoff,
1126                                   unsigned int dataoff,
1127                                   const char **dptr, unsigned int *datalen,
1128                                   unsigned int cseq, unsigned int code)
1129 {
1130         enum ip_conntrack_info ctinfo;
1131         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1132         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1133 
1134         if ((code >= 100 && code <= 199) ||
1135             (code >= 200 && code <= 299))
1136                 return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1137         else if (ct_sip_info->invite_cseq == cseq)
1138                 flush_expectations(ct, true);
1139         return NF_ACCEPT;
1140 }
1141 
1142 static int process_invite_request(struct sk_buff *skb, unsigned int protoff,
1143                                   unsigned int dataoff,
1144                                   const char **dptr, unsigned int *datalen,
1145                                   unsigned int cseq)
1146 {
1147         enum ip_conntrack_info ctinfo;
1148         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1149         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1150         unsigned int ret;
1151 
1152         flush_expectations(ct, true);
1153         ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1154         if (ret == NF_ACCEPT)
1155                 ct_sip_info->invite_cseq = cseq;
1156         return ret;
1157 }
1158 
1159 static int process_bye_request(struct sk_buff *skb, unsigned int protoff,
1160                                unsigned int dataoff,
1161                                const char **dptr, unsigned int *datalen,
1162                                unsigned int cseq)
1163 {
1164         enum ip_conntrack_info ctinfo;
1165         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1166 
1167         flush_expectations(ct, true);
1168         return NF_ACCEPT;
1169 }
1170 
1171 /* Parse a REGISTER request and create a permanent expectation for incoming
1172  * signalling connections. The expectation is marked inactive and is activated
1173  * when receiving a response indicating success from the registrar.
1174  */
1175 static int process_register_request(struct sk_buff *skb, unsigned int protoff,
1176                                     unsigned int dataoff,
1177                                     const char **dptr, unsigned int *datalen,
1178                                     unsigned int cseq)
1179 {
1180         enum ip_conntrack_info ctinfo;
1181         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1182         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1183         enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1184         unsigned int matchoff, matchlen;
1185         struct nf_conntrack_expect *exp;
1186         union nf_inet_addr *saddr, daddr;
1187         const struct nf_nat_sip_hooks *hooks;
1188         __be16 port;
1189         u8 proto;
1190         unsigned int expires = 0;
1191         int ret;
1192 
1193         /* Expected connections can not register again. */
1194         if (ct->status & IPS_EXPECTED)
1195                 return NF_ACCEPT;
1196 
1197         /* We must check the expiration time: a value of zero signals the
1198          * registrar to release the binding. We'll remove our expectation
1199          * when receiving the new bindings in the response, but we don't
1200          * want to create new ones.
1201          *
1202          * The expiration time may be contained in Expires: header, the
1203          * Contact: header parameters or the URI parameters.
1204          */
1205         if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1206                               &matchoff, &matchlen) > 0)
1207                 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1208 
1209         ret = ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen,
1210                                       SIP_HDR_CONTACT, NULL,
1211                                       &matchoff, &matchlen, &daddr, &port);
1212         if (ret < 0) {
1213                 nf_ct_helper_log(skb, ct, "cannot parse contact");
1214                 return NF_DROP;
1215         } else if (ret == 0)
1216                 return NF_ACCEPT;
1217 
1218         /* We don't support third-party registrations */
1219         if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3, &daddr))
1220                 return NF_ACCEPT;
1221 
1222         if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen, *datalen,
1223                                    &proto) == 0)
1224                 return NF_ACCEPT;
1225 
1226         if (ct_sip_parse_numerical_param(ct, *dptr,
1227                                          matchoff + matchlen, *datalen,
1228                                          "expires=", NULL, NULL, &expires) < 0) {
1229                 nf_ct_helper_log(skb, ct, "cannot parse expires");
1230                 return NF_DROP;
1231         }
1232 
1233         if (expires == 0) {
1234                 ret = NF_ACCEPT;
1235                 goto store_cseq;
1236         }
1237 
1238         exp = nf_ct_expect_alloc(ct);
1239         if (!exp) {
1240                 nf_ct_helper_log(skb, ct, "cannot alloc expectation");
1241                 return NF_DROP;
1242         }
1243 
1244         saddr = NULL;
1245         if (sip_direct_signalling)
1246                 saddr = &ct->tuplehash[!dir].tuple.src.u3;
1247 
1248         nf_ct_expect_init(exp, SIP_EXPECT_SIGNALLING, nf_ct_l3num(ct),
1249                           saddr, &daddr, proto, NULL, &port);
1250         exp->timeout.expires = sip_timeout * HZ;
1251         exp->helper = nfct_help(ct)->helper;
1252         exp->flags = NF_CT_EXPECT_PERMANENT | NF_CT_EXPECT_INACTIVE;
1253 
1254         hooks = rcu_dereference(nf_nat_sip_hooks);
1255         if (hooks && ct->status & IPS_NAT_MASK)
1256                 ret = hooks->expect(skb, protoff, dataoff, dptr, datalen,
1257                                     exp, matchoff, matchlen);
1258         else {
1259                 if (nf_ct_expect_related(exp) != 0) {
1260                         nf_ct_helper_log(skb, ct, "cannot add expectation");
1261                         ret = NF_DROP;
1262                 } else
1263                         ret = NF_ACCEPT;
1264         }
1265         nf_ct_expect_put(exp);
1266 
1267 store_cseq:
1268         if (ret == NF_ACCEPT)
1269                 ct_sip_info->register_cseq = cseq;
1270         return ret;
1271 }
1272 
1273 static int process_register_response(struct sk_buff *skb, unsigned int protoff,
1274                                      unsigned int dataoff,
1275                                      const char **dptr, unsigned int *datalen,
1276                                      unsigned int cseq, unsigned int code)
1277 {
1278         enum ip_conntrack_info ctinfo;
1279         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1280         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1281         enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1282         union nf_inet_addr addr;
1283         __be16 port;
1284         u8 proto;
1285         unsigned int matchoff, matchlen, coff = 0;
1286         unsigned int expires = 0;
1287         int in_contact = 0, ret;
1288 
1289         /* According to RFC 3261, "UAs MUST NOT send a new registration until
1290          * they have received a final response from the registrar for the
1291          * previous one or the previous REGISTER request has timed out".
1292          *
1293          * However, some servers fail to detect retransmissions and send late
1294          * responses, so we store the sequence number of the last valid
1295          * request and compare it here.
1296          */
1297         if (ct_sip_info->register_cseq != cseq)
1298                 return NF_ACCEPT;
1299 
1300         if (code >= 100 && code <= 199)
1301                 return NF_ACCEPT;
1302         if (code < 200 || code > 299)
1303                 goto flush;
1304 
1305         if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1306                               &matchoff, &matchlen) > 0)
1307                 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1308 
1309         while (1) {
1310                 unsigned int c_expires = expires;
1311 
1312                 ret = ct_sip_parse_header_uri(ct, *dptr, &coff, *datalen,
1313                                               SIP_HDR_CONTACT, &in_contact,
1314                                               &matchoff, &matchlen,
1315                                               &addr, &port);
1316                 if (ret < 0) {
1317                         nf_ct_helper_log(skb, ct, "cannot parse contact");
1318                         return NF_DROP;
1319                 } else if (ret == 0)
1320                         break;
1321 
1322                 /* We don't support third-party registrations */
1323                 if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3, &addr))
1324                         continue;
1325 
1326                 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen,
1327                                            *datalen, &proto) == 0)
1328                         continue;
1329 
1330                 ret = ct_sip_parse_numerical_param(ct, *dptr,
1331                                                    matchoff + matchlen,
1332                                                    *datalen, "expires=",
1333                                                    NULL, NULL, &c_expires);
1334                 if (ret < 0) {
1335                         nf_ct_helper_log(skb, ct, "cannot parse expires");
1336                         return NF_DROP;
1337                 }
1338                 if (c_expires == 0)
1339                         break;
1340                 if (refresh_signalling_expectation(ct, &addr, proto, port,
1341                                                    c_expires))
1342                         return NF_ACCEPT;
1343         }
1344 
1345 flush:
1346         flush_expectations(ct, false);
1347         return NF_ACCEPT;
1348 }
1349 
1350 static const struct sip_handler sip_handlers[] = {
1351         SIP_HANDLER("INVITE", process_invite_request, process_invite_response),
1352         SIP_HANDLER("UPDATE", process_sdp, process_update_response),
1353         SIP_HANDLER("ACK", process_sdp, NULL),
1354         SIP_HANDLER("PRACK", process_sdp, process_prack_response),
1355         SIP_HANDLER("BYE", process_bye_request, NULL),
1356         SIP_HANDLER("REGISTER", process_register_request, process_register_response),
1357 };
1358 
1359 static int process_sip_response(struct sk_buff *skb, unsigned int protoff,
1360                                 unsigned int dataoff,
1361                                 const char **dptr, unsigned int *datalen)
1362 {
1363         enum ip_conntrack_info ctinfo;
1364         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1365         unsigned int matchoff, matchlen, matchend;
1366         unsigned int code, cseq, i;
1367 
1368         if (*datalen < strlen("SIP/2.0 200"))
1369                 return NF_ACCEPT;
1370         code = simple_strtoul(*dptr + strlen("SIP/2.0 "), NULL, 10);
1371         if (!code) {
1372                 nf_ct_helper_log(skb, ct, "cannot get code");
1373                 return NF_DROP;
1374         }
1375 
1376         if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1377                               &matchoff, &matchlen) <= 0) {
1378                 nf_ct_helper_log(skb, ct, "cannot parse cseq");
1379                 return NF_DROP;
1380         }
1381         cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1382         if (!cseq && *(*dptr + matchoff) != '') {
1383                 nf_ct_helper_log(skb, ct, "cannot get cseq");
1384                 return NF_DROP;
1385         }
1386         matchend = matchoff + matchlen + 1;
1387 
1388         for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) {
1389                 const struct sip_handler *handler;
1390 
1391                 handler = &sip_handlers[i];
1392                 if (handler->response == NULL)
1393                         continue;
1394                 if (*datalen < matchend + handler->len ||
1395                     strncasecmp(*dptr + matchend, handler->method, handler->len))
1396                         continue;
1397                 return handler->response(skb, protoff, dataoff, dptr, datalen,
1398                                          cseq, code);
1399         }
1400         return NF_ACCEPT;
1401 }
1402 
1403 static int process_sip_request(struct sk_buff *skb, unsigned int protoff,
1404                                unsigned int dataoff,
1405                                const char **dptr, unsigned int *datalen)
1406 {
1407         enum ip_conntrack_info ctinfo;
1408         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1409         struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1410         enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1411         unsigned int matchoff, matchlen;
1412         unsigned int cseq, i;
1413         union nf_inet_addr addr;
1414         __be16 port;
1415 
1416         /* Many Cisco IP phones use a high source port for SIP requests, but
1417          * listen for the response on port 5060.  If we are the local
1418          * router for one of these phones, save the port number from the
1419          * Via: header so that nf_nat_sip can redirect the responses to
1420          * the correct port.
1421          */
1422         if (ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen,
1423                                     SIP_HDR_VIA_UDP, NULL, &matchoff,
1424                                     &matchlen, &addr, &port) > 0 &&
1425             port != ct->tuplehash[dir].tuple.src.u.udp.port &&
1426             nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3))
1427                 ct_sip_info->forced_dport = port;
1428 
1429         for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) {
1430                 const struct sip_handler *handler;
1431 
1432                 handler = &sip_handlers[i];
1433                 if (handler->request == NULL)
1434                         continue;
1435                 if (*datalen < handler->len + 2 ||
1436                     strncasecmp(*dptr, handler->method, handler->len))
1437                         continue;
1438                 if ((*dptr)[handler->len] != ' ' ||
1439                     !isalpha((*dptr)[handler->len+1]))
1440                         continue;
1441 
1442                 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1443                                       &matchoff, &matchlen) <= 0) {
1444                         nf_ct_helper_log(skb, ct, "cannot parse cseq");
1445                         return NF_DROP;
1446                 }
1447                 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1448                 if (!cseq && *(*dptr + matchoff) != '') {
1449                         nf_ct_helper_log(skb, ct, "cannot get cseq");
1450                         return NF_DROP;
1451                 }
1452 
1453                 return handler->request(skb, protoff, dataoff, dptr, datalen,
1454                                         cseq);
1455         }
1456         return NF_ACCEPT;
1457 }
1458 
1459 static int process_sip_msg(struct sk_buff *skb, struct nf_conn *ct,
1460                            unsigned int protoff, unsigned int dataoff,
1461                            const char **dptr, unsigned int *datalen)
1462 {
1463         const struct nf_nat_sip_hooks *hooks;
1464         int ret;
1465 
1466         if (strncasecmp(*dptr, "SIP/2.0 ", strlen("SIP/2.0 ")) != 0)
1467                 ret = process_sip_request(skb, protoff, dataoff, dptr, datalen);
1468         else
1469                 ret = process_sip_response(skb, protoff, dataoff, dptr, datalen);
1470 
1471         if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) {
1472                 hooks = rcu_dereference(nf_nat_sip_hooks);
1473                 if (hooks && !hooks->msg(skb, protoff, dataoff,
1474                                          dptr, datalen)) {
1475                         nf_ct_helper_log(skb, ct, "cannot NAT SIP message");
1476                         ret = NF_DROP;
1477                 }
1478         }
1479 
1480         return ret;
1481 }
1482 
1483 static int sip_help_tcp(struct sk_buff *skb, unsigned int protoff,
1484                         struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1485 {
1486         struct tcphdr *th, _tcph;
1487         unsigned int dataoff, datalen;
1488         unsigned int matchoff, matchlen, clen;
1489         unsigned int msglen, origlen;
1490         const char *dptr, *end;
1491         s16 diff, tdiff = 0;
1492         int ret = NF_ACCEPT;
1493         bool term;
1494 
1495         if (ctinfo != IP_CT_ESTABLISHED &&
1496             ctinfo != IP_CT_ESTABLISHED_REPLY)
1497                 return NF_ACCEPT;
1498 
1499         /* No Data ? */
1500         th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
1501         if (th == NULL)
1502                 return NF_ACCEPT;
1503         dataoff = protoff + th->doff * 4;
1504         if (dataoff >= skb->len)
1505                 return NF_ACCEPT;
1506 
1507         nf_ct_refresh(ct, skb, sip_timeout * HZ);
1508 
1509         if (unlikely(skb_linearize(skb)))
1510                 return NF_DROP;
1511 
1512         dptr = skb->data + dataoff;
1513         datalen = skb->len - dataoff;
1514         if (datalen < strlen("SIP/2.0 200"))
1515                 return NF_ACCEPT;
1516 
1517         while (1) {
1518                 if (ct_sip_get_header(ct, dptr, 0, datalen,
1519                                       SIP_HDR_CONTENT_LENGTH,
1520                                       &matchoff, &matchlen) <= 0)
1521                         break;
1522 
1523                 clen = simple_strtoul(dptr + matchoff, (char **)&end, 10);
1524                 if (dptr + matchoff == end)
1525                         break;
1526 
1527                 term = false;
1528                 for (; end + strlen("\r\n\r\n") <= dptr + datalen; end++) {
1529                         if (end[0] == '\r' && end[1] == '\n' &&
1530                             end[2] == '\r' && end[3] == '\n') {
1531                                 term = true;
1532                                 break;
1533                         }
1534                 }
1535                 if (!term)
1536                         break;
1537                 end += strlen("\r\n\r\n") + clen;
1538 
1539                 msglen = origlen = end - dptr;
1540                 if (msglen > datalen)
1541                         return NF_ACCEPT;
1542 
1543                 ret = process_sip_msg(skb, ct, protoff, dataoff,
1544                                       &dptr, &msglen);
1545                 /* process_sip_* functions report why this packet is dropped */
1546                 if (ret != NF_ACCEPT)
1547                         break;
1548                 diff     = msglen - origlen;
1549                 tdiff   += diff;
1550 
1551                 dataoff += msglen;
1552                 dptr    += msglen;
1553                 datalen  = datalen + diff - msglen;
1554         }
1555 
1556         if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) {
1557                 const struct nf_nat_sip_hooks *hooks;
1558 
1559                 hooks = rcu_dereference(nf_nat_sip_hooks);
1560                 if (hooks)
1561                         hooks->seq_adjust(skb, protoff, tdiff);
1562         }
1563 
1564         return ret;
1565 }
1566 
1567 static int sip_help_udp(struct sk_buff *skb, unsigned int protoff,
1568                         struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1569 {
1570         unsigned int dataoff, datalen;
1571         const char *dptr;
1572 
1573         /* No Data ? */
1574         dataoff = protoff + sizeof(struct udphdr);
1575         if (dataoff >= skb->len)
1576                 return NF_ACCEPT;
1577 
1578         nf_ct_refresh(ct, skb, sip_timeout * HZ);
1579 
1580         if (unlikely(skb_linearize(skb)))
1581                 return NF_DROP;
1582 
1583         dptr = skb->data + dataoff;
1584         datalen = skb->len - dataoff;
1585         if (datalen < strlen("SIP/2.0 200"))
1586                 return NF_ACCEPT;
1587 
1588         return process_sip_msg(skb, ct, protoff, dataoff, &dptr, &datalen);
1589 }
1590 
1591 static struct nf_conntrack_helper sip[MAX_PORTS * 4] __read_mostly;
1592 
1593 static const struct nf_conntrack_expect_policy sip_exp_policy[SIP_EXPECT_MAX + 1] = {
1594         [SIP_EXPECT_SIGNALLING] = {
1595                 .name           = "signalling",
1596                 .max_expected   = 1,
1597                 .timeout        = 3 * 60,
1598         },
1599         [SIP_EXPECT_AUDIO] = {
1600                 .name           = "audio",
1601                 .max_expected   = 2 * IP_CT_DIR_MAX,
1602                 .timeout        = 3 * 60,
1603         },
1604         [SIP_EXPECT_VIDEO] = {
1605                 .name           = "video",
1606                 .max_expected   = 2 * IP_CT_DIR_MAX,
1607                 .timeout        = 3 * 60,
1608         },
1609         [SIP_EXPECT_IMAGE] = {
1610                 .name           = "image",
1611                 .max_expected   = IP_CT_DIR_MAX,
1612                 .timeout        = 3 * 60,
1613         },
1614 };
1615 
1616 static void nf_conntrack_sip_fini(void)
1617 {
1618         nf_conntrack_helpers_unregister(sip, ports_c * 4);
1619 }
1620 
1621 static int __init nf_conntrack_sip_init(void)
1622 {
1623         int i, ret;
1624 
1625         NF_CT_HELPER_BUILD_BUG_ON(sizeof(struct nf_ct_sip_master));
1626 
1627         if (ports_c == 0)
1628                 ports[ports_c++] = SIP_PORT;
1629 
1630         for (i = 0; i < ports_c; i++) {
1631                 nf_ct_helper_init(&sip[4 * i], AF_INET, IPPROTO_UDP, "sip",
1632                                   SIP_PORT, ports[i], i, sip_exp_policy,
1633                                   SIP_EXPECT_MAX, sip_help_udp,
1634                                   NULL, THIS_MODULE);
1635                 nf_ct_helper_init(&sip[4 * i + 1], AF_INET, IPPROTO_TCP, "sip",
1636                                   SIP_PORT, ports[i], i, sip_exp_policy,
1637                                   SIP_EXPECT_MAX, sip_help_tcp,
1638                                   NULL, THIS_MODULE);
1639                 nf_ct_helper_init(&sip[4 * i + 2], AF_INET6, IPPROTO_UDP, "sip",
1640                                   SIP_PORT, ports[i], i, sip_exp_policy,
1641                                   SIP_EXPECT_MAX, sip_help_udp,
1642                                   NULL, THIS_MODULE);
1643                 nf_ct_helper_init(&sip[4 * i + 3], AF_INET6, IPPROTO_TCP, "sip",
1644                                   SIP_PORT, ports[i], i, sip_exp_policy,
1645                                   SIP_EXPECT_MAX, sip_help_tcp,
1646                                   NULL, THIS_MODULE);
1647         }
1648 
1649         ret = nf_conntrack_helpers_register(sip, ports_c * 4);
1650         if (ret < 0) {
1651                 pr_err("failed to register helpers\n");
1652                 return ret;
1653         }
1654         return 0;
1655 }
1656 
1657 module_init(nf_conntrack_sip_init);
1658 module_exit(nf_conntrack_sip_fini);
1659 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp