net/netfilter/nf_conntrack_h323_main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * H.323 connection tracking helper
   4  *
   5  * Copyright (c) 2006 Jing Min Zhao <zhaojingmin@users.sourceforge.net>
   6  * Copyright (c) 2006-2012 Patrick McHardy <kaber@trash.net>
   7  *
   8  * Based on the 'brute force' H.323 connection tracking module by
   9  * Jozsef Kadlecsik <kadlec@netfilter.org>
  10  *
  11  * For more information, please see http://nath323.sourceforge.net/
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/moduleparam.h>
  16 #include <linux/ctype.h>
  17 #include <linux/inet.h>
  18 #include <linux/in.h>
  19 #include <linux/ip.h>
  20 #include <linux/slab.h>
  21 #include <linux/udp.h>
  22 #include <linux/tcp.h>
  23 #include <linux/skbuff.h>
  24 #include <net/route.h>
  25 #include <net/ip6_route.h>
  26 #include <linux/netfilter_ipv6.h>
  27
  28 #include <net/netfilter/nf_conntrack.h>
  29 #include <net/netfilter/nf_conntrack_core.h>
  30 #include <net/netfilter/nf_conntrack_tuple.h>
  31 #include <net/netfilter/nf_conntrack_expect.h>
  32 #include <net/netfilter/nf_conntrack_ecache.h>
  33 #include <net/netfilter/nf_conntrack_helper.h>
  34 #include <net/netfilter/nf_conntrack_zones.h>
  35 #include <linux/netfilter/nf_conntrack_h323.h>
  36
  37 #define H323_MAX_SIZE 65535
  38
  39 /* Parameters */
  40 static unsigned int default_rrq_ttl __read_mostly = 300;
  41 module_param(default_rrq_ttl, uint, 0600);
  42 MODULE_PARM_DESC(default_rrq_ttl, "use this TTL if it's missing in RRQ");
  43
  44 static int gkrouted_only __read_mostly = 1;
  45 module_param(gkrouted_only, int, 0600);
  46 MODULE_PARM_DESC(gkrouted_only, "only accept calls from gatekeeper");
  47
  48 static bool callforward_filter __read_mostly = true;
  49 module_param(callforward_filter, bool, 0600);
  50 MODULE_PARM_DESC(callforward_filter, "only create call forwarding expectations "
  51                                      "if both endpoints are on different sides "
  52                                      "(determined by routing information)");
  53
  54 const struct nfct_h323_nat_hooks __rcu *nfct_h323_nat_hook __read_mostly;
  55 EXPORT_SYMBOL_GPL(nfct_h323_nat_hook);
  56
  57 static DEFINE_SPINLOCK(nf_h323_lock);
  58 static char *h323_buffer;
  59
  60 static struct nf_conntrack_helper nf_conntrack_helper_h245;
  61 static struct nf_conntrack_helper nf_conntrack_helper_q931[];
  62 static struct nf_conntrack_helper nf_conntrack_helper_ras[];
  63
  64 static int get_tpkt_data(struct sk_buff *skb, unsigned int protoff,
  65                          struct nf_conn *ct, enum ip_conntrack_info ctinfo,
  66                          unsigned char **data, int *datalen, int *dataoff)
  67 {
  68         struct nf_ct_h323_master *info = nfct_help_data(ct);
  69         int dir = CTINFO2DIR(ctinfo);
  70         const struct tcphdr *th;
  71         struct tcphdr _tcph;
  72         int tcpdatalen;
  73         int tcpdataoff;
  74         unsigned char *tpkt;
  75         int tpktlen;
  76         int tpktoff;
  77
  78         /* Get TCP header */
  79         th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
  80         if (th == NULL)
  81                 return 0;
  82
  83         /* Get TCP data offset */
  84         tcpdataoff = protoff + th->doff * 4;
  85
  86         /* Get TCP data length */
  87         tcpdatalen = skb->len - tcpdataoff;
  88         if (tcpdatalen <= 0)    /* No TCP data */
  89                 goto clear_out;
  90
  91         if (tcpdatalen > H323_MAX_SIZE)
  92                 tcpdatalen = H323_MAX_SIZE;
  93
  94         if (*data == NULL) {    /* first TPKT */
  95                 /* Get first TPKT pointer */
  96                 tpkt = skb_header_pointer(skb, tcpdataoff, tcpdatalen,
  97                                           h323_buffer);
  98                 if (!tpkt)
  99                         goto clear_out;
 100
 101                 /* Validate TPKT identifier */
 102                 if (tcpdatalen < 4 || tpkt[0] != 0x03 || tpkt[1] != 0) {
 103                         /* Netmeeting sends TPKT header and data separately */
 104                         if (info->tpkt_len[dir] > 0) {
 105                                 pr_debug("nf_ct_h323: previous packet "
 106                                          "indicated separate TPKT data of %hu "
 107                                          "bytes\n", info->tpkt_len[dir]);
 108                                 if (info->tpkt_len[dir] <= tcpdatalen) {
 109                                         /* Yes, there was a TPKT header
 110                                          * received */
 111                                         *data = tpkt;
 112                                         *datalen = info->tpkt_len[dir];
 113                                         *dataoff = 0;
 114                                         goto out;
 115                                 }
 116
 117                                 /* Fragmented TPKT */
 118                                 pr_debug("nf_ct_h323: fragmented TPKT\n");
 119                                 goto clear_out;
 120                         }
 121
 122                         /* It is not even a TPKT */
 123                         return 0;
 124                 }
 125                 tpktoff = 0;
 126         } else {                /* Next TPKT */
 127                 tpktoff = *dataoff + *datalen;
 128                 tcpdatalen -= tpktoff;
 129                 if (tcpdatalen <= 4)    /* No more TPKT */
 130                         goto clear_out;
 131                 tpkt = *data + *datalen;
 132
 133                 /* Validate TPKT identifier */
 134                 if (tpkt[0] != 0x03 || tpkt[1] != 0)
 135                         goto clear_out;
 136         }
 137
 138         /* Validate TPKT length */
 139         tpktlen = tpkt[2] * 256 + tpkt[3];
 140         if (tpktlen < 4)
 141                 goto clear_out;
 142         if (tpktlen > tcpdatalen) {
 143                 if (tcpdatalen == 4) {  /* Separate TPKT header */
 144                         /* Netmeeting sends TPKT header and data separately */
 145                         pr_debug("nf_ct_h323: separate TPKT header indicates "
 146                                  "there will be TPKT data of %d bytes\n",
 147                                  tpktlen - 4);
 148                         info->tpkt_len[dir] = tpktlen - 4;
 149                         return 0;
 150                 }
 151
 152                 pr_debug("nf_ct_h323: incomplete TPKT (fragmented?)\n");
 153                 goto clear_out;
 154         }
 155
 156         /* This is the encapsulated data */
 157         *data = tpkt + 4;
 158         *datalen = tpktlen - 4;
 159         *dataoff = tpktoff + 4;
 160
 161       out:
 162         /* Clear TPKT length */
 163         info->tpkt_len[dir] = 0;
 164         return 1;
 165
 166       clear_out:
 167         info->tpkt_len[dir] = 0;
 168         return 0;
 169 }
 170
 171 static int get_h245_addr(struct nf_conn *ct, const unsigned char *data,
 172                          H245_TransportAddress *taddr,
 173                          union nf_inet_addr *addr, __be16 *port)
 174 {
 175         const unsigned char *p;
 176         int len;
 177
 178         if (taddr->choice != eH245_TransportAddress_unicastAddress)
 179                 return 0;
 180
 181         switch (taddr->unicastAddress.choice) {
 182         case eUnicastAddress_iPAddress:
 183                 if (nf_ct_l3num(ct) != AF_INET)
 184                         return 0;
 185                 p = data + taddr->unicastAddress.iPAddress.network;
 186                 len = 4;
 187                 break;
 188         case eUnicastAddress_iP6Address:
 189                 if (nf_ct_l3num(ct) != AF_INET6)
 190                         return 0;
 191                 p = data + taddr->unicastAddress.iP6Address.network;
 192                 len = 16;
 193                 break;
 194         default:
 195                 return 0;
 196         }
 197
 198         memcpy(addr, p, len);
 199         memset((void *)addr + len, 0, sizeof(*addr) - len);
 200         memcpy(port, p + len, sizeof(__be16));
 201
 202         return 1;
 203 }
 204
 205 static int expect_rtp_rtcp(struct sk_buff *skb, struct nf_conn *ct,
 206                            enum ip_conntrack_info ctinfo,
 207                            unsigned int protoff,
 208                            unsigned char **data, int dataoff,
 209                            H245_TransportAddress *taddr)
 210 {
 211         const struct nfct_h323_nat_hooks *nathook;
 212         int dir = CTINFO2DIR(ctinfo);
 213         int ret = 0;
 214         __be16 port;
 215         __be16 rtp_port, rtcp_port;
 216         union nf_inet_addr addr;
 217         struct nf_conntrack_expect *rtp_exp;
 218         struct nf_conntrack_expect *rtcp_exp;
 219
 220         /* Read RTP or RTCP address */
 221         if (!get_h245_addr(ct, *data, taddr, &addr, &port) ||
 222             memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3, sizeof(addr)) ||
 223             port == 0)
 224                 return 0;
 225
 226         /* RTP port is even */
 227         rtp_port = port & ~htons(1);
 228         rtcp_port = port | htons(1);
 229
 230         /* Create expect for RTP */
 231         if ((rtp_exp = nf_ct_expect_alloc(ct)) == NULL)
 232                 return -1;
 233         nf_ct_expect_init(rtp_exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
 234                           &ct->tuplehash[!dir].tuple.src.u3,
 235                           &ct->tuplehash[!dir].tuple.dst.u3,
 236                           IPPROTO_UDP, NULL, &rtp_port);
 237
 238         /* Create expect for RTCP */
 239         if ((rtcp_exp = nf_ct_expect_alloc(ct)) == NULL) {
 240                 nf_ct_expect_put(rtp_exp);
 241                 return -1;
 242         }
 243         nf_ct_expect_init(rtcp_exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
 244                           &ct->tuplehash[!dir].tuple.src.u3,
 245                           &ct->tuplehash[!dir].tuple.dst.u3,
 246                           IPPROTO_UDP, NULL, &rtcp_port);
 247
 248         nathook = rcu_dereference(nfct_h323_nat_hook);
 249         if (memcmp(&ct->tuplehash[dir].tuple.src.u3,
 250                    &ct->tuplehash[!dir].tuple.dst.u3,
 251                    sizeof(ct->tuplehash[dir].tuple.src.u3)) &&
 252                    nathook &&
 253                    nf_ct_l3num(ct) == NFPROTO_IPV4 &&
 254                    ct->status & IPS_NAT_MASK) {
 255                 /* NAT needed */
 256                 ret = nathook->nat_rtp_rtcp(skb, ct, ctinfo, protoff, data, dataoff,
 257                                             taddr, port, rtp_port, rtp_exp, rtcp_exp);
 258         } else {                /* Conntrack only */
 259                 if (nf_ct_expect_related(rtp_exp, 0) == 0) {
 260                         if (nf_ct_expect_related(rtcp_exp, 0) == 0) {
 261                                 pr_debug("nf_ct_h323: expect RTP ");
 262                                 nf_ct_dump_tuple(&rtp_exp->tuple);
 263                                 pr_debug("nf_ct_h323: expect RTCP ");
 264                                 nf_ct_dump_tuple(&rtcp_exp->tuple);
 265                         } else {
 266                                 nf_ct_unexpect_related(rtp_exp);
 267                                 ret = -1;
 268                         }
 269                 } else
 270                         ret = -1;
 271         }
 272
 273         nf_ct_expect_put(rtp_exp);
 274         nf_ct_expect_put(rtcp_exp);
 275
 276         return ret;
 277 }
 278
 279 static int expect_t120(struct sk_buff *skb,
 280                        struct nf_conn *ct,
 281                        enum ip_conntrack_info ctinfo,
 282                        unsigned int protoff,
 283                        unsigned char **data, int dataoff,
 284                        H245_TransportAddress *taddr)
 285 {
 286         const struct nfct_h323_nat_hooks *nathook;
 287         int dir = CTINFO2DIR(ctinfo);
 288         int ret = 0;
 289         __be16 port;
 290         union nf_inet_addr addr;
 291         struct nf_conntrack_expect *exp;
 292
 293         /* Read T.120 address */
 294         if (!get_h245_addr(ct, *data, taddr, &addr, &port) ||
 295             memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3, sizeof(addr)) ||
 296             port == 0)
 297                 return 0;
 298
 299         /* Create expect for T.120 connections */
 300         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
 301                 return -1;
 302         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
 303                           &ct->tuplehash[!dir].tuple.src.u3,
 304                           &ct->tuplehash[!dir].tuple.dst.u3,
 305                           IPPROTO_TCP, NULL, &port);
 306         exp->flags = NF_CT_EXPECT_PERMANENT;    /* Accept multiple channels */
 307
 308         nathook = rcu_dereference(nfct_h323_nat_hook);
 309         if (memcmp(&ct->tuplehash[dir].tuple.src.u3,
 310                    &ct->tuplehash[!dir].tuple.dst.u3,
 311                    sizeof(ct->tuplehash[dir].tuple.src.u3)) &&
 312             nathook &&
 313             nf_ct_l3num(ct) == NFPROTO_IPV4 &&
 314             ct->status & IPS_NAT_MASK) {
 315                 /* NAT needed */
 316                 ret = nathook->nat_t120(skb, ct, ctinfo, protoff, data,
 317                                         dataoff, taddr, port, exp);
 318         } else {                /* Conntrack only */
 319                 if (nf_ct_expect_related(exp, 0) == 0) {
 320                         pr_debug("nf_ct_h323: expect T.120 ");
 321                         nf_ct_dump_tuple(&exp->tuple);
 322                 } else
 323                         ret = -1;
 324         }
 325
 326         nf_ct_expect_put(exp);
 327
 328         return ret;
 329 }
 330
 331 static int process_h245_channel(struct sk_buff *skb,
 332                                 struct nf_conn *ct,
 333                                 enum ip_conntrack_info ctinfo,
 334                                 unsigned int protoff,
 335                                 unsigned char **data, int dataoff,
 336                                 H2250LogicalChannelParameters *channel)
 337 {
 338         int ret;
 339
 340         if (channel->options & eH2250LogicalChannelParameters_mediaChannel) {
 341                 /* RTP */
 342                 ret = expect_rtp_rtcp(skb, ct, ctinfo, protoff, data, dataoff,
 343                                       &channel->mediaChannel);
 344                 if (ret < 0)
 345                         return -1;
 346         }
 347
 348         if (channel->
 349             options & eH2250LogicalChannelParameters_mediaControlChannel) {
 350                 /* RTCP */
 351                 ret = expect_rtp_rtcp(skb, ct, ctinfo, protoff, data, dataoff,
 352                                       &channel->mediaControlChannel);
 353                 if (ret < 0)
 354                         return -1;
 355         }
 356
 357         return 0;
 358 }
 359
 360 static int process_olc(struct sk_buff *skb, struct nf_conn *ct,
 361                        enum ip_conntrack_info ctinfo,
 362                        unsigned int protoff,
 363                        unsigned char **data, int dataoff,
 364                        OpenLogicalChannel *olc)
 365 {
 366         int ret;
 367
 368         pr_debug("nf_ct_h323: OpenLogicalChannel\n");
 369
 370         if (olc->forwardLogicalChannelParameters.multiplexParameters.choice ==
 371             eOpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
 372         {
 373                 ret = process_h245_channel(skb, ct, ctinfo,
 374                                            protoff, data, dataoff,
 375                                            &olc->
 376                                            forwardLogicalChannelParameters.
 377                                            multiplexParameters.
 378                                            h2250LogicalChannelParameters);
 379                 if (ret < 0)
 380                         return -1;
 381         }
 382
 383         if ((olc->options &
 384              eOpenLogicalChannel_reverseLogicalChannelParameters) &&
 385             (olc->reverseLogicalChannelParameters.options &
 386              eOpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters)
 387             && (olc->reverseLogicalChannelParameters.multiplexParameters.
 388                 choice ==
 389                 eOpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters))
 390         {
 391                 ret =
 392                     process_h245_channel(skb, ct, ctinfo,
 393                                          protoff, data, dataoff,
 394                                          &olc->
 395                                          reverseLogicalChannelParameters.
 396                                          multiplexParameters.
 397                                          h2250LogicalChannelParameters);
 398                 if (ret < 0)
 399                         return -1;
 400         }
 401
 402         if ((olc->options & eOpenLogicalChannel_separateStack) &&
 403             olc->forwardLogicalChannelParameters.dataType.choice ==
 404             eDataType_data &&
 405             olc->forwardLogicalChannelParameters.dataType.data.application.
 406             choice == eDataApplicationCapability_application_t120 &&
 407             olc->forwardLogicalChannelParameters.dataType.data.application.
 408             t120.choice == eDataProtocolCapability_separateLANStack &&
 409             olc->separateStack.networkAddress.choice ==
 410             eNetworkAccessParameters_networkAddress_localAreaAddress) {
 411                 ret = expect_t120(skb, ct, ctinfo, protoff, data, dataoff,
 412                                   &olc->separateStack.networkAddress.
 413                                   localAreaAddress);
 414                 if (ret < 0)
 415                         return -1;
 416         }
 417
 418         return 0;
 419 }
 420
 421 static int process_olca(struct sk_buff *skb, struct nf_conn *ct,
 422                         enum ip_conntrack_info ctinfo,
 423                         unsigned int protoff, unsigned char **data, int dataoff,
 424                         OpenLogicalChannelAck *olca)
 425 {
 426         H2250LogicalChannelAckParameters *ack;
 427         int ret;
 428
 429         pr_debug("nf_ct_h323: OpenLogicalChannelAck\n");
 430
 431         if ((olca->options &
 432              eOpenLogicalChannelAck_reverseLogicalChannelParameters) &&
 433             (olca->reverseLogicalChannelParameters.options &
 434              eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters)
 435             && (olca->reverseLogicalChannelParameters.multiplexParameters.
 436                 choice ==
 437                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters))
 438         {
 439                 ret = process_h245_channel(skb, ct, ctinfo,
 440                                            protoff, data, dataoff,
 441                                            &olca->
 442                                            reverseLogicalChannelParameters.
 443                                            multiplexParameters.
 444                                            h2250LogicalChannelParameters);
 445                 if (ret < 0)
 446                         return -1;
 447         }
 448
 449         if ((olca->options &
 450              eOpenLogicalChannelAck_forwardMultiplexAckParameters) &&
 451             (olca->forwardMultiplexAckParameters.choice ==
 452              eOpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters))
 453         {
 454                 ack = &olca->forwardMultiplexAckParameters.
 455                     h2250LogicalChannelAckParameters;
 456                 if (ack->options &
 457                     eH2250LogicalChannelAckParameters_mediaChannel) {
 458                         /* RTP */
 459                         ret = expect_rtp_rtcp(skb, ct, ctinfo,
 460                                               protoff, data, dataoff,
 461                                               &ack->mediaChannel);
 462                         if (ret < 0)
 463                                 return -1;
 464                 }
 465
 466                 if (ack->options &
 467                     eH2250LogicalChannelAckParameters_mediaControlChannel) {
 468                         /* RTCP */
 469                         ret = expect_rtp_rtcp(skb, ct, ctinfo,
 470                                               protoff, data, dataoff,
 471                                               &ack->mediaControlChannel);
 472                         if (ret < 0)
 473                                 return -1;
 474                 }
 475         }
 476
 477         if ((olca->options & eOpenLogicalChannelAck_separateStack) &&
 478                 olca->separateStack.networkAddress.choice ==
 479                 eNetworkAccessParameters_networkAddress_localAreaAddress) {
 480                 ret = expect_t120(skb, ct, ctinfo, protoff, data, dataoff,
 481                                   &olca->separateStack.networkAddress.
 482                                   localAreaAddress);
 483                 if (ret < 0)
 484                         return -1;
 485         }
 486
 487         return 0;
 488 }
 489
 490 static int process_h245(struct sk_buff *skb, struct nf_conn *ct,
 491                         enum ip_conntrack_info ctinfo,
 492                         unsigned int protoff, unsigned char **data, int dataoff,
 493                         MultimediaSystemControlMessage *mscm)
 494 {
 495         switch (mscm->choice) {
 496         case eMultimediaSystemControlMessage_request:
 497                 if (mscm->request.choice ==
 498                     eRequestMessage_openLogicalChannel) {
 499                         return process_olc(skb, ct, ctinfo,
 500                                            protoff, data, dataoff,
 501                                            &mscm->request.openLogicalChannel);
 502                 }
 503                 pr_debug("nf_ct_h323: H.245 Request %d\n",
 504                          mscm->request.choice);
 505                 break;
 506         case eMultimediaSystemControlMessage_response:
 507                 if (mscm->response.choice ==
 508                     eResponseMessage_openLogicalChannelAck) {
 509                         return process_olca(skb, ct, ctinfo,
 510                                             protoff, data, dataoff,
 511                                             &mscm->response.
 512                                             openLogicalChannelAck);
 513                 }
 514                 pr_debug("nf_ct_h323: H.245 Response %d\n",
 515                          mscm->response.choice);
 516                 break;
 517         default:
 518                 pr_debug("nf_ct_h323: H.245 signal %d\n", mscm->choice);
 519                 break;
 520         }
 521
 522         return 0;
 523 }
 524
 525 static int h245_help(struct sk_buff *skb, unsigned int protoff,
 526                      struct nf_conn *ct, enum ip_conntrack_info ctinfo)
 527 {
 528         static MultimediaSystemControlMessage mscm;
 529         unsigned char *data = NULL;
 530         int datalen;
 531         int dataoff;
 532         int ret;
 533
 534         /* Until there's been traffic both ways, don't look in packets. */
 535         if (ctinfo != IP_CT_ESTABLISHED && ctinfo != IP_CT_ESTABLISHED_REPLY)
 536                 return NF_ACCEPT;
 537
 538         pr_debug("nf_ct_h245: skblen = %u\n", skb->len);
 539
 540         spin_lock_bh(&nf_h323_lock);
 541
 542         /* Process each TPKT */
 543         while (get_tpkt_data(skb, protoff, ct, ctinfo,
 544                              &data, &datalen, &dataoff)) {
 545                 pr_debug("nf_ct_h245: TPKT len=%d ", datalen);
 546                 nf_ct_dump_tuple(&ct->tuplehash[CTINFO2DIR(ctinfo)].tuple);
 547
 548                 /* Decode H.245 signal */
 549                 ret = DecodeMultimediaSystemControlMessage(data, datalen,
 550                                                            &mscm);
 551                 if (ret < 0) {
 552                         pr_debug("nf_ct_h245: decoding error: %s\n",
 553                                  ret == H323_ERROR_BOUND ?
 554                                  "out of bound" : "out of range");
 555                         /* We don't drop when decoding error */
 556                         break;
 557                 }
 558
 559                 /* Process H.245 signal */
 560                 if (process_h245(skb, ct, ctinfo, protoff,
 561                                  &data, dataoff, &mscm) < 0)
 562                         goto drop;
 563         }
 564
 565         spin_unlock_bh(&nf_h323_lock);
 566         return NF_ACCEPT;
 567
 568       drop:
 569         spin_unlock_bh(&nf_h323_lock);
 570         nf_ct_helper_log(skb, ct, "cannot process H.245 message");
 571         return NF_DROP;
 572 }
 573
 574 static const struct nf_conntrack_expect_policy h245_exp_policy = {
 575         .max_expected   = H323_RTP_CHANNEL_MAX * 4 + 2 /* T.120 */,
 576         .timeout        = 240,
 577 };
 578
 579 static struct nf_conntrack_helper nf_conntrack_helper_h245 __read_mostly = {
 580         .name                   = "H.245",
 581         .me                     = THIS_MODULE,
 582         .tuple.src.l3num        = AF_UNSPEC,
 583         .tuple.dst.protonum     = IPPROTO_UDP,
 584         .help                   = h245_help,
 585         .expect_policy          = &h245_exp_policy,
 586 };
 587
 588 int get_h225_addr(struct nf_conn *ct, unsigned char *data,
 589                   TransportAddress *taddr,
 590                   union nf_inet_addr *addr, __be16 *port)
 591 {
 592         const unsigned char *p;
 593         int len;
 594
 595         switch (taddr->choice) {
 596         case eTransportAddress_ipAddress:
 597                 if (nf_ct_l3num(ct) != AF_INET)
 598                         return 0;
 599                 p = data + taddr->ipAddress.ip;
 600                 len = 4;
 601                 break;
 602         case eTransportAddress_ip6Address:
 603                 if (nf_ct_l3num(ct) != AF_INET6)
 604                         return 0;
 605                 p = data + taddr->ip6Address.ip;
 606                 len = 16;
 607                 break;
 608         default:
 609                 return 0;
 610         }
 611
 612         memcpy(addr, p, len);
 613         memset((void *)addr + len, 0, sizeof(*addr) - len);
 614         memcpy(port, p + len, sizeof(__be16));
 615
 616         return 1;
 617 }
 618 EXPORT_SYMBOL_GPL(get_h225_addr);
 619
 620 static int expect_h245(struct sk_buff *skb, struct nf_conn *ct,
 621                        enum ip_conntrack_info ctinfo,
 622                        unsigned int protoff, unsigned char **data, int dataoff,
 623                        TransportAddress *taddr)
 624 {
 625         const struct nfct_h323_nat_hooks *nathook;
 626         int dir = CTINFO2DIR(ctinfo);
 627         int ret = 0;
 628         __be16 port;
 629         union nf_inet_addr addr;
 630         struct nf_conntrack_expect *exp;
 631
 632         /* Read h245Address */
 633         if (!get_h225_addr(ct, *data, taddr, &addr, &port) ||
 634             memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3, sizeof(addr)) ||
 635             port == 0)
 636                 return 0;
 637
 638         /* Create expect for h245 connection */
 639         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
 640                 return -1;
 641         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
 642                           &ct->tuplehash[!dir].tuple.src.u3,
 643                           &ct->tuplehash[!dir].tuple.dst.u3,
 644                           IPPROTO_TCP, NULL, &port);
 645         exp->helper = &nf_conntrack_helper_h245;
 646
 647         nathook = rcu_dereference(nfct_h323_nat_hook);
 648         if (memcmp(&ct->tuplehash[dir].tuple.src.u3,
 649                    &ct->tuplehash[!dir].tuple.dst.u3,
 650                    sizeof(ct->tuplehash[dir].tuple.src.u3)) &&
 651             nathook &&
 652             nf_ct_l3num(ct) == NFPROTO_IPV4 &&
 653             ct->status & IPS_NAT_MASK) {
 654                 /* NAT needed */
 655                 ret = nathook->nat_h245(skb, ct, ctinfo, protoff, data,
 656                                         dataoff, taddr, port, exp);
 657         } else {                /* Conntrack only */
 658                 if (nf_ct_expect_related(exp, 0) == 0) {
 659                         pr_debug("nf_ct_q931: expect H.245 ");
 660                         nf_ct_dump_tuple(&exp->tuple);
 661                 } else
 662                         ret = -1;
 663         }
 664
 665         nf_ct_expect_put(exp);
 666
 667         return ret;
 668 }
 669
 670 /* If the calling party is on the same side of the forward-to party,
 671  * we don't need to track the second call
 672  */
 673 static int callforward_do_filter(struct net *net,
 674                                  const union nf_inet_addr *src,
 675                                  const union nf_inet_addr *dst,
 676                                  u_int8_t family)
 677 {
 678         int ret = 0;
 679
 680         switch (family) {
 681         case AF_INET: {
 682                 struct flowi4 fl1, fl2;
 683                 struct rtable *rt1, *rt2;
 684
 685                 memset(&fl1, 0, sizeof(fl1));
 686                 fl1.daddr = src->ip;
 687
 688                 memset(&fl2, 0, sizeof(fl2));
 689                 fl2.daddr = dst->ip;
 690                 if (!nf_ip_route(net, (struct dst_entry **)&rt1,
 691                                  flowi4_to_flowi(&fl1), false)) {
 692                         if (!nf_ip_route(net, (struct dst_entry **)&rt2,
 693                                          flowi4_to_flowi(&fl2), false)) {
 694                                 if (rt_nexthop(rt1, fl1.daddr) ==
 695                                     rt_nexthop(rt2, fl2.daddr) &&
 696                                     rt1->dst.dev  == rt2->dst.dev)
 697                                         ret = 1;
 698                                 dst_release(&rt2->dst);
 699                         }
 700                         dst_release(&rt1->dst);
 701                 }
 702                 break;
 703         }
 704 #if IS_ENABLED(CONFIG_IPV6)
 705         case AF_INET6: {
 706                 struct rt6_info *rt1, *rt2;
 707                 struct flowi6 fl1, fl2;
 708
 709                 memset(&fl1, 0, sizeof(fl1));
 710                 fl1.daddr = src->in6;
 711
 712                 memset(&fl2, 0, sizeof(fl2));
 713                 fl2.daddr = dst->in6;
 714                 if (!nf_ip6_route(net, (struct dst_entry **)&rt1,
 715                                   flowi6_to_flowi(&fl1), false)) {
 716                         if (!nf_ip6_route(net, (struct dst_entry **)&rt2,
 717                                           flowi6_to_flowi(&fl2), false)) {
 718                                 if (ipv6_addr_equal(rt6_nexthop(rt1, &fl1.daddr),
 719                                                     rt6_nexthop(rt2, &fl2.daddr)) &&
 720                                     rt1->dst.dev == rt2->dst.dev)
 721                                         ret = 1;
 722                                 dst_release(&rt2->dst);
 723                         }
 724                         dst_release(&rt1->dst);
 725                 }
 726                 break;
 727         }
 728 #endif
 729         }
 730         return ret;
 731
 732 }
 733
 734 static int expect_callforwarding(struct sk_buff *skb,
 735                                  struct nf_conn *ct,
 736                                  enum ip_conntrack_info ctinfo,
 737                                  unsigned int protoff,
 738                                  unsigned char **data, int dataoff,
 739                                  TransportAddress *taddr)
 740 {
 741         const struct nfct_h323_nat_hooks *nathook;
 742         int dir = CTINFO2DIR(ctinfo);
 743         int ret = 0;
 744         __be16 port;
 745         union nf_inet_addr addr;
 746         struct nf_conntrack_expect *exp;
 747         struct net *net = nf_ct_net(ct);
 748
 749         /* Read alternativeAddress */
 750         if (!get_h225_addr(ct, *data, taddr, &addr, &port) || port == 0)
 751                 return 0;
 752
 753         /* If the calling party is on the same side of the forward-to party,
 754          * we don't need to track the second call
 755          */
 756         if (callforward_filter &&
 757             callforward_do_filter(net, &addr, &ct->tuplehash[!dir].tuple.src.u3,
 758                                   nf_ct_l3num(ct))) {
 759                 pr_debug("nf_ct_q931: Call Forwarding not tracked\n");
 760                 return 0;
 761         }
 762
 763         /* Create expect for the second call leg */
 764         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
 765                 return -1;
 766         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
 767                           &ct->tuplehash[!dir].tuple.src.u3, &addr,
 768                           IPPROTO_TCP, NULL, &port);
 769         exp->helper = nf_conntrack_helper_q931;
 770
 771         nathook = rcu_dereference(nfct_h323_nat_hook);
 772         if (memcmp(&ct->tuplehash[dir].tuple.src.u3,
 773                    &ct->tuplehash[!dir].tuple.dst.u3,
 774                    sizeof(ct->tuplehash[dir].tuple.src.u3)) &&
 775             nathook &&
 776             nf_ct_l3num(ct) == NFPROTO_IPV4 &&
 777             ct->status & IPS_NAT_MASK) {
 778                 /* Need NAT */
 779                 ret = nathook->nat_callforwarding(skb, ct, ctinfo,
 780                                                   protoff, data, dataoff,
 781                                                   taddr, port, exp);
 782         } else {                /* Conntrack only */
 783                 if (nf_ct_expect_related(exp, 0) == 0) {
 784                         pr_debug("nf_ct_q931: expect Call Forwarding ");
 785                         nf_ct_dump_tuple(&exp->tuple);
 786                 } else
 787                         ret = -1;
 788         }
 789
 790         nf_ct_expect_put(exp);
 791
 792         return ret;
 793 }
 794
 795 static int process_setup(struct sk_buff *skb, struct nf_conn *ct,
 796                          enum ip_conntrack_info ctinfo,
 797                          unsigned int protoff,
 798                          unsigned char **data, int dataoff,
 799                          Setup_UUIE *setup)
 800 {
 801         const struct nfct_h323_nat_hooks *nathook;
 802         int dir = CTINFO2DIR(ctinfo);
 803         int ret;
 804         int i;
 805         __be16 port;
 806         union nf_inet_addr addr;
 807
 808         pr_debug("nf_ct_q931: Setup\n");
 809
 810         if (setup->options & eSetup_UUIE_h245Address) {
 811                 ret = expect_h245(skb, ct, ctinfo, protoff, data, dataoff,
 812                                   &setup->h245Address);
 813                 if (ret < 0)
 814                         return -1;
 815         }
 816
 817         nathook = rcu_dereference(nfct_h323_nat_hook);
 818         if ((setup->options & eSetup_UUIE_destCallSignalAddress) &&
 819             nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
 820             ct->status & IPS_NAT_MASK &&
 821             get_h225_addr(ct, *data, &setup->destCallSignalAddress,
 822                           &addr, &port) &&
 823             memcmp(&addr, &ct->tuplehash[!dir].tuple.src.u3, sizeof(addr))) {
 824                 pr_debug("nf_ct_q931: set destCallSignalAddress %pI6:%hu->%pI6:%hu\n",
 825                          &addr, ntohs(port), &ct->tuplehash[!dir].tuple.src.u3,
 826                          ntohs(ct->tuplehash[!dir].tuple.src.u.tcp.port));
 827                 ret = nathook->set_h225_addr(skb, protoff, data, dataoff,
 828                                              &setup->destCallSignalAddress,
 829                                              &ct->tuplehash[!dir].tuple.src.u3,
 830                                              ct->tuplehash[!dir].tuple.src.u.tcp.port);
 831                 if (ret < 0)
 832                         return -1;
 833         }
 834
 835         if ((setup->options & eSetup_UUIE_sourceCallSignalAddress) &&
 836             nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
 837             ct->status & IPS_NAT_MASK &&
 838             get_h225_addr(ct, *data, &setup->sourceCallSignalAddress,
 839                           &addr, &port) &&
 840             memcmp(&addr, &ct->tuplehash[!dir].tuple.dst.u3, sizeof(addr))) {
 841                 pr_debug("nf_ct_q931: set sourceCallSignalAddress %pI6:%hu->%pI6:%hu\n",
 842                          &addr, ntohs(port), &ct->tuplehash[!dir].tuple.dst.u3,
 843                          ntohs(ct->tuplehash[!dir].tuple.dst.u.tcp.port));
 844                 ret = nathook->set_h225_addr(skb, protoff, data, dataoff,
 845                                              &setup->sourceCallSignalAddress,
 846                                              &ct->tuplehash[!dir].tuple.dst.u3,
 847                                              ct->tuplehash[!dir].tuple.dst.u.tcp.port);
 848                 if (ret < 0)
 849                         return -1;
 850         }
 851
 852         if (setup->options & eSetup_UUIE_fastStart) {
 853                 for (i = 0; i < setup->fastStart.count; i++) {
 854                         ret = process_olc(skb, ct, ctinfo,
 855                                           protoff, data, dataoff,
 856                                           &setup->fastStart.item[i]);
 857                         if (ret < 0)
 858                                 return -1;
 859                 }
 860         }
 861
 862         return 0;
 863 }
 864
 865 static int process_callproceeding(struct sk_buff *skb,
 866                                   struct nf_conn *ct,
 867                                   enum ip_conntrack_info ctinfo,
 868                                   unsigned int protoff,
 869                                   unsigned char **data, int dataoff,
 870                                   CallProceeding_UUIE *callproc)
 871 {
 872         int ret;
 873         int i;
 874
 875         pr_debug("nf_ct_q931: CallProceeding\n");
 876
 877         if (callproc->options & eCallProceeding_UUIE_h245Address) {
 878                 ret = expect_h245(skb, ct, ctinfo, protoff, data, dataoff,
 879                                   &callproc->h245Address);
 880                 if (ret < 0)
 881                         return -1;
 882         }
 883
 884         if (callproc->options & eCallProceeding_UUIE_fastStart) {
 885                 for (i = 0; i < callproc->fastStart.count; i++) {
 886                         ret = process_olc(skb, ct, ctinfo,
 887                                           protoff, data, dataoff,
 888                                           &callproc->fastStart.item[i]);
 889                         if (ret < 0)
 890                                 return -1;
 891                 }
 892         }
 893
 894         return 0;
 895 }
 896
 897 static int process_connect(struct sk_buff *skb, struct nf_conn *ct,
 898                            enum ip_conntrack_info ctinfo,
 899                            unsigned int protoff,
 900                            unsigned char **data, int dataoff,
 901                            Connect_UUIE *connect)
 902 {
 903         int ret;
 904         int i;
 905
 906         pr_debug("nf_ct_q931: Connect\n");
 907
 908         if (connect->options & eConnect_UUIE_h245Address) {
 909                 ret = expect_h245(skb, ct, ctinfo, protoff, data, dataoff,
 910                                   &connect->h245Address);
 911                 if (ret < 0)
 912                         return -1;
 913         }
 914
 915         if (connect->options & eConnect_UUIE_fastStart) {
 916                 for (i = 0; i < connect->fastStart.count; i++) {
 917                         ret = process_olc(skb, ct, ctinfo,
 918                                           protoff, data, dataoff,
 919                                           &connect->fastStart.item[i]);
 920                         if (ret < 0)
 921                                 return -1;
 922                 }
 923         }
 924
 925         return 0;
 926 }
 927
 928 static int process_alerting(struct sk_buff *skb, struct nf_conn *ct,
 929                             enum ip_conntrack_info ctinfo,
 930                             unsigned int protoff,
 931                             unsigned char **data, int dataoff,
 932                             Alerting_UUIE *alert)
 933 {
 934         int ret;
 935         int i;
 936
 937         pr_debug("nf_ct_q931: Alerting\n");
 938
 939         if (alert->options & eAlerting_UUIE_h245Address) {
 940                 ret = expect_h245(skb, ct, ctinfo, protoff, data, dataoff,
 941                                   &alert->h245Address);
 942                 if (ret < 0)
 943                         return -1;
 944         }
 945
 946         if (alert->options & eAlerting_UUIE_fastStart) {
 947                 for (i = 0; i < alert->fastStart.count; i++) {
 948                         ret = process_olc(skb, ct, ctinfo,
 949                                           protoff, data, dataoff,
 950                                           &alert->fastStart.item[i]);
 951                         if (ret < 0)
 952                                 return -1;
 953                 }
 954         }
 955
 956         return 0;
 957 }
 958
 959 static int process_facility(struct sk_buff *skb, struct nf_conn *ct,
 960                             enum ip_conntrack_info ctinfo,
 961                             unsigned int protoff,
 962                             unsigned char **data, int dataoff,
 963                             Facility_UUIE *facility)
 964 {
 965         int ret;
 966         int i;
 967
 968         pr_debug("nf_ct_q931: Facility\n");
 969
 970         if (facility->reason.choice == eFacilityReason_callForwarded) {
 971                 if (facility->options & eFacility_UUIE_alternativeAddress)
 972                         return expect_callforwarding(skb, ct, ctinfo,
 973                                                      protoff, data, dataoff,
 974                                                      &facility->
 975                                                      alternativeAddress);
 976                 return 0;
 977         }
 978
 979         if (facility->options & eFacility_UUIE_h245Address) {
 980                 ret = expect_h245(skb, ct, ctinfo, protoff, data, dataoff,
 981                                   &facility->h245Address);
 982                 if (ret < 0)
 983                         return -1;
 984         }
 985
 986         if (facility->options & eFacility_UUIE_fastStart) {
 987                 for (i = 0; i < facility->fastStart.count; i++) {
 988                         ret = process_olc(skb, ct, ctinfo,
 989                                           protoff, data, dataoff,
 990                                           &facility->fastStart.item[i]);
 991                         if (ret < 0)
 992                                 return -1;
 993                 }
 994         }
 995
 996         return 0;
 997 }
 998
 999 static int process_progress(struct sk_buff *skb, struct nf_conn *ct,
1000                             enum ip_conntrack_info ctinfo,
1001                             unsigned int protoff,
1002                             unsigned char **data, int dataoff,
1003                             Progress_UUIE *progress)
1004 {
1005         int ret;
1006         int i;
1007
1008         pr_debug("nf_ct_q931: Progress\n");
1009
1010         if (progress->options & eProgress_UUIE_h245Address) {
1011                 ret = expect_h245(skb, ct, ctinfo, protoff, data, dataoff,
1012                                   &progress->h245Address);
1013                 if (ret < 0)
1014                         return -1;
1015         }
1016
1017         if (progress->options & eProgress_UUIE_fastStart) {
1018                 for (i = 0; i < progress->fastStart.count; i++) {
1019                         ret = process_olc(skb, ct, ctinfo,
1020                                           protoff, data, dataoff,
1021                                           &progress->fastStart.item[i]);
1022                         if (ret < 0)
1023                                 return -1;
1024                 }
1025         }
1026
1027         return 0;
1028 }
1029
1030 static int process_q931(struct sk_buff *skb, struct nf_conn *ct,
1031                         enum ip_conntrack_info ctinfo,
1032                         unsigned int protoff, unsigned char **data, int dataoff,
1033                         Q931 *q931)
1034 {
1035         H323_UU_PDU *pdu = &q931->UUIE.h323_uu_pdu;
1036         int i;
1037         int ret = 0;
1038
1039         switch (pdu->h323_message_body.choice) {
1040         case eH323_UU_PDU_h323_message_body_setup:
1041                 ret = process_setup(skb, ct, ctinfo, protoff, data, dataoff,
1042                                     &pdu->h323_message_body.setup);
1043                 break;
1044         case eH323_UU_PDU_h323_message_body_callProceeding:
1045                 ret = process_callproceeding(skb, ct, ctinfo,
1046                                              protoff, data, dataoff,
1047                                              &pdu->h323_message_body.
1048                                              callProceeding);
1049                 break;
1050         case eH323_UU_PDU_h323_message_body_connect:
1051                 ret = process_connect(skb, ct, ctinfo, protoff, data, dataoff,
1052                                       &pdu->h323_message_body.connect);
1053                 break;
1054         case eH323_UU_PDU_h323_message_body_alerting:
1055                 ret = process_alerting(skb, ct, ctinfo, protoff, data, dataoff,
1056                                        &pdu->h323_message_body.alerting);
1057                 break;
1058         case eH323_UU_PDU_h323_message_body_facility:
1059                 ret = process_facility(skb, ct, ctinfo, protoff, data, dataoff,
1060                                        &pdu->h323_message_body.facility);
1061                 break;
1062         case eH323_UU_PDU_h323_message_body_progress:
1063                 ret = process_progress(skb, ct, ctinfo, protoff, data, dataoff,
1064                                        &pdu->h323_message_body.progress);
1065                 break;
1066         default:
1067                 pr_debug("nf_ct_q931: Q.931 signal %d\n",
1068                          pdu->h323_message_body.choice);
1069                 break;
1070         }
1071
1072         if (ret < 0)
1073                 return -1;
1074
1075         if (pdu->options & eH323_UU_PDU_h245Control) {
1076                 for (i = 0; i < pdu->h245Control.count; i++) {
1077                         ret = process_h245(skb, ct, ctinfo,
1078                                            protoff, data, dataoff,
1079                                            &pdu->h245Control.item[i]);
1080                         if (ret < 0)
1081                                 return -1;
1082                 }
1083         }
1084
1085         return 0;
1086 }
1087
1088 static int q931_help(struct sk_buff *skb, unsigned int protoff,
1089                      struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1090 {
1091         static Q931 q931;
1092         unsigned char *data = NULL;
1093         int datalen;
1094         int dataoff;
1095         int ret;
1096
1097         /* Until there's been traffic both ways, don't look in packets. */
1098         if (ctinfo != IP_CT_ESTABLISHED && ctinfo != IP_CT_ESTABLISHED_REPLY)
1099                 return NF_ACCEPT;
1100
1101         pr_debug("nf_ct_q931: skblen = %u\n", skb->len);
1102
1103         spin_lock_bh(&nf_h323_lock);
1104
1105         /* Process each TPKT */
1106         while (get_tpkt_data(skb, protoff, ct, ctinfo,
1107                              &data, &datalen, &dataoff)) {
1108                 pr_debug("nf_ct_q931: TPKT len=%d ", datalen);
1109                 nf_ct_dump_tuple(&ct->tuplehash[CTINFO2DIR(ctinfo)].tuple);
1110
1111                 /* Decode Q.931 signal */
1112                 ret = DecodeQ931(data, datalen, &q931);
1113                 if (ret < 0) {
1114                         pr_debug("nf_ct_q931: decoding error: %s\n",
1115                                  ret == H323_ERROR_BOUND ?
1116                                  "out of bound" : "out of range");
1117                         /* We don't drop when decoding error */
1118                         break;
1119                 }
1120
1121                 /* Process Q.931 signal */
1122                 if (process_q931(skb, ct, ctinfo, protoff,
1123                                  &data, dataoff, &q931) < 0)
1124                         goto drop;
1125         }
1126
1127         spin_unlock_bh(&nf_h323_lock);
1128         return NF_ACCEPT;
1129
1130       drop:
1131         spin_unlock_bh(&nf_h323_lock);
1132         nf_ct_helper_log(skb, ct, "cannot process Q.931 message");
1133         return NF_DROP;
1134 }
1135
1136 static const struct nf_conntrack_expect_policy q931_exp_policy = {
1137         /* T.120 and H.245 */
1138         .max_expected           = H323_RTP_CHANNEL_MAX * 4 + 4,
1139         .timeout                = 240,
1140 };
1141
1142 static struct nf_conntrack_helper nf_conntrack_helper_q931[] __read_mostly = {
1143         {
1144                 .name                   = "Q.931",
1145                 .me                     = THIS_MODULE,
1146                 .tuple.src.l3num        = AF_INET,
1147                 .tuple.src.u.tcp.port   = cpu_to_be16(Q931_PORT),
1148                 .tuple.dst.protonum     = IPPROTO_TCP,
1149                 .help                   = q931_help,
1150                 .expect_policy          = &q931_exp_policy,
1151         },
1152         {
1153                 .name                   = "Q.931",
1154                 .me                     = THIS_MODULE,
1155                 .tuple.src.l3num        = AF_INET6,
1156                 .tuple.src.u.tcp.port   = cpu_to_be16(Q931_PORT),
1157                 .tuple.dst.protonum     = IPPROTO_TCP,
1158                 .help                   = q931_help,
1159                 .expect_policy          = &q931_exp_policy,
1160         },
1161 };
1162
1163 static unsigned char *get_udp_data(struct sk_buff *skb, unsigned int protoff,
1164                                    int *datalen)
1165 {
1166         const struct udphdr *uh;
1167         struct udphdr _uh;
1168         int dataoff;
1169
1170         uh = skb_header_pointer(skb, protoff, sizeof(_uh), &_uh);
1171         if (uh == NULL)
1172                 return NULL;
1173         dataoff = protoff + sizeof(_uh);
1174         if (dataoff >= skb->len)
1175                 return NULL;
1176         *datalen = skb->len - dataoff;
1177         if (*datalen > H323_MAX_SIZE)
1178                 *datalen = H323_MAX_SIZE;
1179
1180         return skb_header_pointer(skb, dataoff, *datalen, h323_buffer);
1181 }
1182
1183 static struct nf_conntrack_expect *find_expect(struct nf_conn *ct,
1184                                                union nf_inet_addr *addr,
1185                                                __be16 port)
1186 {
1187         struct net *net = nf_ct_net(ct);
1188         struct nf_conntrack_expect *exp;
1189         struct nf_conntrack_tuple tuple;
1190
1191         memset(&tuple.src.u3, 0, sizeof(tuple.src.u3));
1192         tuple.src.u.tcp.port = 0;
1193         memcpy(&tuple.dst.u3, addr, sizeof(tuple.dst.u3));
1194         tuple.dst.u.tcp.port = port;
1195         tuple.dst.protonum = IPPROTO_TCP;
1196
1197         exp = __nf_ct_expect_find(net, nf_ct_zone(ct), &tuple);
1198         if (exp && exp->master == ct)
1199                 return exp;
1200         return NULL;
1201 }
1202
1203 static int expect_q931(struct sk_buff *skb, struct nf_conn *ct,
1204                        enum ip_conntrack_info ctinfo,
1205                        unsigned int protoff, unsigned char **data,
1206                        TransportAddress *taddr, int count)
1207 {
1208         struct nf_ct_h323_master *info = nfct_help_data(ct);
1209         const struct nfct_h323_nat_hooks *nathook;
1210         int dir = CTINFO2DIR(ctinfo);
1211         int ret = 0;
1212         int i;
1213         __be16 port;
1214         union nf_inet_addr addr;
1215         struct nf_conntrack_expect *exp;
1216
1217         /* Look for the first related address */
1218         for (i = 0; i < count; i++) {
1219                 if (get_h225_addr(ct, *data, &taddr[i], &addr, &port) &&
1220                     memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3,
1221                            sizeof(addr)) == 0 && port != 0)
1222                         break;
1223         }
1224
1225         if (i >= count)         /* Not found */
1226                 return 0;
1227
1228         /* Create expect for Q.931 */
1229         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
1230                 return -1;
1231         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
1232                           gkrouted_only ? /* only accept calls from GK? */
1233                                 &ct->tuplehash[!dir].tuple.src.u3 : NULL,
1234                           &ct->tuplehash[!dir].tuple.dst.u3,
1235                           IPPROTO_TCP, NULL, &port);
1236         exp->helper = nf_conntrack_helper_q931;
1237         exp->flags = NF_CT_EXPECT_PERMANENT;    /* Accept multiple calls */
1238
1239         nathook = rcu_dereference(nfct_h323_nat_hook);
1240         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1241             ct->status & IPS_NAT_MASK) {        /* Need NAT */
1242                 ret = nathook->nat_q931(skb, ct, ctinfo, protoff, data,
1243                                         taddr, i, port, exp);
1244         } else {                /* Conntrack only */
1245                 if (nf_ct_expect_related(exp, 0) == 0) {
1246                         pr_debug("nf_ct_ras: expect Q.931 ");
1247                         nf_ct_dump_tuple(&exp->tuple);
1248
1249                         /* Save port for looking up expect in processing RCF */
1250                         info->sig_port[dir] = port;
1251                 } else
1252                         ret = -1;
1253         }
1254
1255         nf_ct_expect_put(exp);
1256
1257         return ret;
1258 }
1259
1260 static int process_grq(struct sk_buff *skb, struct nf_conn *ct,
1261                        enum ip_conntrack_info ctinfo,
1262                        unsigned int protoff,
1263                        unsigned char **data, GatekeeperRequest *grq)
1264 {
1265         const struct nfct_h323_nat_hooks *nathook;
1266
1267         pr_debug("nf_ct_ras: GRQ\n");
1268
1269         nathook = rcu_dereference(nfct_h323_nat_hook);
1270         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1271             ct->status & IPS_NAT_MASK)  /* NATed */
1272                 return nathook->set_ras_addr(skb, ct, ctinfo, protoff, data,
1273                                              &grq->rasAddress, 1);
1274         return 0;
1275 }
1276
1277 static int process_gcf(struct sk_buff *skb, struct nf_conn *ct,
1278                        enum ip_conntrack_info ctinfo,
1279                        unsigned int protoff,
1280                        unsigned char **data, GatekeeperConfirm *gcf)
1281 {
1282         int dir = CTINFO2DIR(ctinfo);
1283         int ret = 0;
1284         __be16 port;
1285         union nf_inet_addr addr;
1286         struct nf_conntrack_expect *exp;
1287
1288         pr_debug("nf_ct_ras: GCF\n");
1289
1290         if (!get_h225_addr(ct, *data, &gcf->rasAddress, &addr, &port))
1291                 return 0;
1292
1293         /* Registration port is the same as discovery port */
1294         if (!memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3, sizeof(addr)) &&
1295             port == ct->tuplehash[dir].tuple.src.u.udp.port)
1296                 return 0;
1297
1298         /* Avoid RAS expectation loops. A GCF is never expected. */
1299         if (test_bit(IPS_EXPECTED_BIT, &ct->status))
1300                 return 0;
1301
1302         /* Need new expect */
1303         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
1304                 return -1;
1305         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
1306                           &ct->tuplehash[!dir].tuple.src.u3, &addr,
1307                           IPPROTO_UDP, NULL, &port);
1308         exp->helper = nf_conntrack_helper_ras;
1309
1310         if (nf_ct_expect_related(exp, 0) == 0) {
1311                 pr_debug("nf_ct_ras: expect RAS ");
1312                 nf_ct_dump_tuple(&exp->tuple);
1313         } else
1314                 ret = -1;
1315
1316         nf_ct_expect_put(exp);
1317
1318         return ret;
1319 }
1320
1321 static int process_rrq(struct sk_buff *skb, struct nf_conn *ct,
1322                        enum ip_conntrack_info ctinfo,
1323                        unsigned int protoff,
1324                        unsigned char **data, RegistrationRequest *rrq)
1325 {
1326         struct nf_ct_h323_master *info = nfct_help_data(ct);
1327         const struct nfct_h323_nat_hooks *nathook;
1328         int ret;
1329
1330         pr_debug("nf_ct_ras: RRQ\n");
1331
1332         ret = expect_q931(skb, ct, ctinfo, protoff, data,
1333                           rrq->callSignalAddress.item,
1334                           rrq->callSignalAddress.count);
1335         if (ret < 0)
1336                 return -1;
1337
1338         nathook = rcu_dereference(nfct_h323_nat_hook);
1339         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1340             ct->status & IPS_NAT_MASK) {
1341                 ret = nathook->set_ras_addr(skb, ct, ctinfo, protoff, data,
1342                                             rrq->rasAddress.item,
1343                                             rrq->rasAddress.count);
1344                 if (ret < 0)
1345                         return -1;
1346         }
1347
1348         if (rrq->options & eRegistrationRequest_timeToLive) {
1349                 pr_debug("nf_ct_ras: RRQ TTL = %u seconds\n", rrq->timeToLive);
1350                 info->timeout = rrq->timeToLive;
1351         } else
1352                 info->timeout = default_rrq_ttl;
1353
1354         return 0;
1355 }
1356
1357 static int process_rcf(struct sk_buff *skb, struct nf_conn *ct,
1358                        enum ip_conntrack_info ctinfo,
1359                        unsigned int protoff,
1360                        unsigned char **data, RegistrationConfirm *rcf)
1361 {
1362         struct nf_ct_h323_master *info = nfct_help_data(ct);
1363         const struct nfct_h323_nat_hooks *nathook;
1364         int dir = CTINFO2DIR(ctinfo);
1365         int ret;
1366         struct nf_conntrack_expect *exp;
1367
1368         pr_debug("nf_ct_ras: RCF\n");
1369
1370         nathook = rcu_dereference(nfct_h323_nat_hook);
1371         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1372             ct->status & IPS_NAT_MASK) {
1373                 ret = nathook->set_sig_addr(skb, ct, ctinfo, protoff, data,
1374                                             rcf->callSignalAddress.item,
1375                                             rcf->callSignalAddress.count);
1376                 if (ret < 0)
1377                         return -1;
1378         }
1379
1380         if (rcf->options & eRegistrationConfirm_timeToLive) {
1381                 pr_debug("nf_ct_ras: RCF TTL = %u seconds\n", rcf->timeToLive);
1382                 info->timeout = rcf->timeToLive;
1383         }
1384
1385         if (info->timeout > 0) {
1386                 pr_debug("nf_ct_ras: set RAS connection timeout to "
1387                          "%u seconds\n", info->timeout);
1388                 nf_ct_refresh(ct, skb, info->timeout * HZ);
1389
1390                 /* Set expect timeout */
1391                 spin_lock_bh(&nf_conntrack_expect_lock);
1392                 exp = find_expect(ct, &ct->tuplehash[dir].tuple.dst.u3,
1393                                   info->sig_port[!dir]);
1394                 if (exp) {
1395                         pr_debug("nf_ct_ras: set Q.931 expect "
1396                                  "timeout to %u seconds for",
1397                                  info->timeout);
1398                         nf_ct_dump_tuple(&exp->tuple);
1399                         mod_timer_pending(&exp->timeout,
1400                                           jiffies + info->timeout * HZ);
1401                 }
1402                 spin_unlock_bh(&nf_conntrack_expect_lock);
1403         }
1404
1405         return 0;
1406 }
1407
1408 static int process_urq(struct sk_buff *skb, struct nf_conn *ct,
1409                        enum ip_conntrack_info ctinfo,
1410                        unsigned int protoff,
1411                        unsigned char **data, UnregistrationRequest *urq)
1412 {
1413         struct nf_ct_h323_master *info = nfct_help_data(ct);
1414         const struct nfct_h323_nat_hooks *nathook;
1415         int dir = CTINFO2DIR(ctinfo);
1416         int ret;
1417
1418         pr_debug("nf_ct_ras: URQ\n");
1419
1420         nathook = rcu_dereference(nfct_h323_nat_hook);
1421         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1422             ct->status & IPS_NAT_MASK) {
1423                 ret = nathook->set_sig_addr(skb, ct, ctinfo, protoff, data,
1424                                             urq->callSignalAddress.item,
1425                                             urq->callSignalAddress.count);
1426                 if (ret < 0)
1427                         return -1;
1428         }
1429
1430         /* Clear old expect */
1431         nf_ct_remove_expectations(ct);
1432         info->sig_port[dir] = 0;
1433         info->sig_port[!dir] = 0;
1434
1435         /* Give it 30 seconds for UCF or URJ */
1436         nf_ct_refresh(ct, skb, 30 * HZ);
1437
1438         return 0;
1439 }
1440
1441 static int process_arq(struct sk_buff *skb, struct nf_conn *ct,
1442                        enum ip_conntrack_info ctinfo,
1443                        unsigned int protoff,
1444                        unsigned char **data, AdmissionRequest *arq)
1445 {
1446         const struct nf_ct_h323_master *info = nfct_help_data(ct);
1447         const struct nfct_h323_nat_hooks *nathook;
1448         int dir = CTINFO2DIR(ctinfo);
1449         __be16 port;
1450         union nf_inet_addr addr;
1451
1452         pr_debug("nf_ct_ras: ARQ\n");
1453
1454         nathook = rcu_dereference(nfct_h323_nat_hook);
1455         if (!nathook)
1456                 return 0;
1457
1458         if ((arq->options & eAdmissionRequest_destCallSignalAddress) &&
1459             get_h225_addr(ct, *data, &arq->destCallSignalAddress,
1460                           &addr, &port) &&
1461             !memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3, sizeof(addr)) &&
1462             port == info->sig_port[dir] &&
1463             nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1464             ct->status & IPS_NAT_MASK) {
1465                 /* Answering ARQ */
1466                 return nathook->set_h225_addr(skb, protoff, data, 0,
1467                                               &arq->destCallSignalAddress,
1468                                               &ct->tuplehash[!dir].tuple.dst.u3,
1469                                               info->sig_port[!dir]);
1470         }
1471
1472         if ((arq->options & eAdmissionRequest_srcCallSignalAddress) &&
1473             get_h225_addr(ct, *data, &arq->srcCallSignalAddress,
1474                           &addr, &port) &&
1475             !memcmp(&addr, &ct->tuplehash[dir].tuple.src.u3, sizeof(addr)) &&
1476             nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1477             ct->status & IPS_NAT_MASK) {
1478                 /* Calling ARQ */
1479                 return nathook->set_h225_addr(skb, protoff, data, 0,
1480                                               &arq->srcCallSignalAddress,
1481                                               &ct->tuplehash[!dir].tuple.dst.u3,
1482                                               port);
1483         }
1484
1485         return 0;
1486 }
1487
1488 static int process_acf(struct sk_buff *skb, struct nf_conn *ct,
1489                        enum ip_conntrack_info ctinfo,
1490                        unsigned int protoff,
1491                        unsigned char **data, AdmissionConfirm *acf)
1492 {
1493         int dir = CTINFO2DIR(ctinfo);
1494         int ret = 0;
1495         __be16 port;
1496         union nf_inet_addr addr;
1497         struct nf_conntrack_expect *exp;
1498
1499         pr_debug("nf_ct_ras: ACF\n");
1500
1501         if (!get_h225_addr(ct, *data, &acf->destCallSignalAddress,
1502                            &addr, &port))
1503                 return 0;
1504
1505         if (!memcmp(&addr, &ct->tuplehash[dir].tuple.dst.u3, sizeof(addr))) {
1506                 const struct nfct_h323_nat_hooks *nathook;
1507
1508                 /* Answering ACF */
1509                 nathook = rcu_dereference(nfct_h323_nat_hook);
1510                 if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1511                     ct->status & IPS_NAT_MASK)
1512                         return nathook->set_sig_addr(skb, ct, ctinfo, protoff,
1513                                                      data,
1514                                                      &acf->destCallSignalAddress, 1);
1515                 return 0;
1516         }
1517
1518         /* Need new expect */
1519         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
1520                 return -1;
1521         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
1522                           &ct->tuplehash[!dir].tuple.src.u3, &addr,
1523                           IPPROTO_TCP, NULL, &port);
1524         exp->flags = NF_CT_EXPECT_PERMANENT;
1525         exp->helper = nf_conntrack_helper_q931;
1526
1527         if (nf_ct_expect_related(exp, 0) == 0) {
1528                 pr_debug("nf_ct_ras: expect Q.931 ");
1529                 nf_ct_dump_tuple(&exp->tuple);
1530         } else
1531                 ret = -1;
1532
1533         nf_ct_expect_put(exp);
1534
1535         return ret;
1536 }
1537
1538 static int process_lrq(struct sk_buff *skb, struct nf_conn *ct,
1539                        enum ip_conntrack_info ctinfo,
1540                        unsigned int protoff,
1541                        unsigned char **data, LocationRequest *lrq)
1542 {
1543         const struct nfct_h323_nat_hooks *nathook;
1544
1545         pr_debug("nf_ct_ras: LRQ\n");
1546
1547         nathook = rcu_dereference(nfct_h323_nat_hook);
1548         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1549             ct->status & IPS_NAT_MASK)
1550                 return nathook->set_ras_addr(skb, ct, ctinfo, protoff, data,
1551                                              &lrq->replyAddress, 1);
1552         return 0;
1553 }
1554
1555 static int process_lcf(struct sk_buff *skb, struct nf_conn *ct,
1556                        enum ip_conntrack_info ctinfo,
1557                        unsigned int protoff,
1558                        unsigned char **data, LocationConfirm *lcf)
1559 {
1560         int dir = CTINFO2DIR(ctinfo);
1561         int ret = 0;
1562         __be16 port;
1563         union nf_inet_addr addr;
1564         struct nf_conntrack_expect *exp;
1565
1566         pr_debug("nf_ct_ras: LCF\n");
1567
1568         if (!get_h225_addr(ct, *data, &lcf->callSignalAddress,
1569                            &addr, &port))
1570                 return 0;
1571
1572         /* Need new expect for call signal */
1573         if ((exp = nf_ct_expect_alloc(ct)) == NULL)
1574                 return -1;
1575         nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, nf_ct_l3num(ct),
1576                           &ct->tuplehash[!dir].tuple.src.u3, &addr,
1577                           IPPROTO_TCP, NULL, &port);
1578         exp->flags = NF_CT_EXPECT_PERMANENT;
1579         exp->helper = nf_conntrack_helper_q931;
1580
1581         if (nf_ct_expect_related(exp, 0) == 0) {
1582                 pr_debug("nf_ct_ras: expect Q.931 ");
1583                 nf_ct_dump_tuple(&exp->tuple);
1584         } else
1585                 ret = -1;
1586
1587         nf_ct_expect_put(exp);
1588
1589         /* Ignore rasAddress */
1590
1591         return ret;
1592 }
1593
1594 static int process_irr(struct sk_buff *skb, struct nf_conn *ct,
1595                        enum ip_conntrack_info ctinfo,
1596                        unsigned int protoff,
1597                        unsigned char **data, InfoRequestResponse *irr)
1598 {
1599         const struct nfct_h323_nat_hooks *nathook;
1600         int ret;
1601
1602         pr_debug("nf_ct_ras: IRR\n");
1603
1604         nathook = rcu_dereference(nfct_h323_nat_hook);
1605         if (nathook && nf_ct_l3num(ct) == NFPROTO_IPV4 &&
1606             ct->status & IPS_NAT_MASK) {
1607                 ret = nathook->set_ras_addr(skb, ct, ctinfo, protoff, data,
1608                                             &irr->rasAddress, 1);
1609                 if (ret < 0)
1610                         return -1;
1611
1612                 ret = nathook->set_sig_addr(skb, ct, ctinfo, protoff, data,
1613                                             irr->callSignalAddress.item,
1614                                             irr->callSignalAddress.count);
1615                 if (ret < 0)
1616                         return -1;
1617         }
1618
1619         return 0;
1620 }
1621
1622 static int process_ras(struct sk_buff *skb, struct nf_conn *ct,
1623                        enum ip_conntrack_info ctinfo,
1624                        unsigned int protoff,
1625                        unsigned char **data, RasMessage *ras)
1626 {
1627         switch (ras->choice) {
1628         case eRasMessage_gatekeeperRequest:
1629                 return process_grq(skb, ct, ctinfo, protoff, data,
1630                                    &ras->gatekeeperRequest);
1631         case eRasMessage_gatekeeperConfirm:
1632                 return process_gcf(skb, ct, ctinfo, protoff, data,
1633                                    &ras->gatekeeperConfirm);
1634         case eRasMessage_registrationRequest:
1635                 return process_rrq(skb, ct, ctinfo, protoff, data,
1636                                    &ras->registrationRequest);
1637         case eRasMessage_registrationConfirm:
1638                 return process_rcf(skb, ct, ctinfo, protoff, data,
1639                                    &ras->registrationConfirm);
1640         case eRasMessage_unregistrationRequest:
1641                 return process_urq(skb, ct, ctinfo, protoff, data,
1642                                    &ras->unregistrationRequest);
1643         case eRasMessage_admissionRequest:
1644                 return process_arq(skb, ct, ctinfo, protoff, data,
1645                                    &ras->admissionRequest);
1646         case eRasMessage_admissionConfirm:
1647                 return process_acf(skb, ct, ctinfo, protoff, data,
1648                                    &ras->admissionConfirm);
1649         case eRasMessage_locationRequest:
1650                 return process_lrq(skb, ct, ctinfo, protoff, data,
1651                                    &ras->locationRequest);
1652         case eRasMessage_locationConfirm:
1653                 return process_lcf(skb, ct, ctinfo, protoff, data,
1654                                    &ras->locationConfirm);
1655         case eRasMessage_infoRequestResponse:
1656                 return process_irr(skb, ct, ctinfo, protoff, data,
1657                                    &ras->infoRequestResponse);
1658         default:
1659                 pr_debug("nf_ct_ras: RAS message %d\n", ras->choice);
1660                 break;
1661         }
1662
1663         return 0;
1664 }
1665
1666 static int ras_help(struct sk_buff *skb, unsigned int protoff,
1667                     struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1668 {
1669         static RasMessage ras;
1670         unsigned char *data;
1671         int datalen = 0;
1672         int ret;
1673
1674         pr_debug("nf_ct_ras: skblen = %u\n", skb->len);
1675
1676         spin_lock_bh(&nf_h323_lock);
1677
1678         /* Get UDP data */
1679         data = get_udp_data(skb, protoff, &datalen);
1680         if (data == NULL)
1681                 goto accept;
1682         pr_debug("nf_ct_ras: RAS message len=%d ", datalen);
1683         nf_ct_dump_tuple(&ct->tuplehash[CTINFO2DIR(ctinfo)].tuple);
1684
1685         /* Decode RAS message */
1686         ret = DecodeRasMessage(data, datalen, &ras);
1687         if (ret < 0) {
1688                 pr_debug("nf_ct_ras: decoding error: %s\n",
1689                          ret == H323_ERROR_BOUND ?
1690                          "out of bound" : "out of range");
1691                 goto accept;
1692         }
1693
1694         /* Process RAS message */
1695         if (process_ras(skb, ct, ctinfo, protoff, &data, &ras) < 0)
1696                 goto drop;
1697
1698       accept:
1699         spin_unlock_bh(&nf_h323_lock);
1700         return NF_ACCEPT;
1701
1702       drop:
1703         spin_unlock_bh(&nf_h323_lock);
1704         nf_ct_helper_log(skb, ct, "cannot process RAS message");
1705         return NF_DROP;
1706 }
1707
1708 static const struct nf_conntrack_expect_policy ras_exp_policy = {
1709         .max_expected           = 32,
1710         .timeout                = 240,
1711 };
1712
1713 static struct nf_conntrack_helper nf_conntrack_helper_ras[] __read_mostly = {
1714         {
1715                 .name                   = "RAS",
1716                 .me                     = THIS_MODULE,
1717                 .tuple.src.l3num        = AF_INET,
1718                 .tuple.src.u.udp.port   = cpu_to_be16(RAS_PORT),
1719                 .tuple.dst.protonum     = IPPROTO_UDP,
1720                 .help                   = ras_help,
1721                 .expect_policy          = &ras_exp_policy,
1722         },
1723         {
1724                 .name                   = "RAS",
1725                 .me                     = THIS_MODULE,
1726                 .tuple.src.l3num        = AF_INET6,
1727                 .tuple.src.u.udp.port   = cpu_to_be16(RAS_PORT),
1728                 .tuple.dst.protonum     = IPPROTO_UDP,
1729                 .help                   = ras_help,
1730                 .expect_policy          = &ras_exp_policy,
1731         },
1732 };
1733
1734 static int __init h323_helper_init(void)
1735 {
1736         int ret;
1737
1738         ret = nf_conntrack_helper_register(&nf_conntrack_helper_h245);
1739         if (ret < 0)
1740                 return ret;
1741         ret = nf_conntrack_helpers_register(nf_conntrack_helper_q931,
1742                                         ARRAY_SIZE(nf_conntrack_helper_q931));
1743         if (ret < 0)
1744                 goto err1;
1745         ret = nf_conntrack_helpers_register(nf_conntrack_helper_ras,
1746                                         ARRAY_SIZE(nf_conntrack_helper_ras));
1747         if (ret < 0)
1748                 goto err2;
1749
1750         return 0;
1751 err2:
1752         nf_conntrack_helpers_unregister(nf_conntrack_helper_q931,
1753                                         ARRAY_SIZE(nf_conntrack_helper_q931));
1754 err1:
1755         nf_conntrack_helper_unregister(&nf_conntrack_helper_h245);
1756         return ret;
1757 }
1758
1759 static void __exit h323_helper_exit(void)
1760 {
1761         nf_conntrack_helpers_unregister(nf_conntrack_helper_ras,
1762                                         ARRAY_SIZE(nf_conntrack_helper_ras));
1763         nf_conntrack_helpers_unregister(nf_conntrack_helper_q931,
1764                                         ARRAY_SIZE(nf_conntrack_helper_q931));
1765         nf_conntrack_helper_unregister(&nf_conntrack_helper_h245);
1766 }
1767
1768 static void __exit nf_conntrack_h323_fini(void)
1769 {
1770         h323_helper_exit();
1771         kfree(h323_buffer);
1772         pr_debug("nf_ct_h323: fini\n");
1773 }
1774
1775 static int __init nf_conntrack_h323_init(void)
1776 {
1777         int ret;
1778
1779         NF_CT_HELPER_BUILD_BUG_ON(sizeof(struct nf_ct_h323_master));
1780
1781         h323_buffer = kmalloc(H323_MAX_SIZE + 1, GFP_KERNEL);
1782         if (!h323_buffer)
1783                 return -ENOMEM;
1784         ret = h323_helper_init();
1785         if (ret < 0)
1786                 goto err1;
1787         pr_debug("nf_ct_h323: init success\n");
1788         return 0;
1789 err1:
1790         kfree(h323_buffer);
1791         return ret;
1792 }
1793
1794 module_init(nf_conntrack_h323_init);
1795 module_exit(nf_conntrack_h323_fini);
1796
1797 MODULE_AUTHOR("Jing Min Zhao <zhaojingmin@users.sourceforge.net>");
1798 MODULE_DESCRIPTION("H.323 connection tracking helper");
1799 MODULE_LICENSE("GPL");
1800 MODULE_ALIAS("ip_conntrack_h323");
1801 MODULE_ALIAS_NFCT_HELPER("RAS");
1802 MODULE_ALIAS_NFCT_HELPER("Q.931");
1803 MODULE_ALIAS_NFCT_HELPER("H.245");