net/netfilter/nf_conntrack_sip.c

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