net/netfilter/ipvs/ip_vs_pe_sip.c

   1 #define KMSG_COMPONENT "IPVS"
   2 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
   3
   4 #include <linux/module.h>
   5 #include <linux/kernel.h>
   6
   7 #include <net/ip_vs.h>
   8 #include <net/netfilter/nf_conntrack.h>
   9 #include <linux/netfilter/nf_conntrack_sip.h>
  10
  11 #ifdef CONFIG_IP_VS_DEBUG
  12 static const char *ip_vs_dbg_callid(char *buf, size_t buf_len,
  13                                     const char *callid, size_t callid_len,
  14                                     int *idx)
  15 {
  16         size_t len = min(min(callid_len, (size_t)64), buf_len - *idx - 1);
  17         memcpy(buf + *idx, callid, len);
  18         buf[*idx+len] = '\0';
  19         *idx += len + 1;
  20         return buf + *idx - len;
  21 }
  22
  23 #define IP_VS_DEBUG_CALLID(callid, len)                                 \
  24         ip_vs_dbg_callid(ip_vs_dbg_buf, sizeof(ip_vs_dbg_buf),          \
  25                          callid, len, &ip_vs_dbg_idx)
  26 #endif
  27
  28 static int get_callid(const char *dptr, unsigned int dataoff,
  29                       unsigned int datalen,
  30                       unsigned int *matchoff, unsigned int *matchlen)
  31 {
  32         /* Find callid */
  33         while (1) {
  34                 int ret = ct_sip_get_header(NULL, dptr, dataoff, datalen,
  35                                             SIP_HDR_CALL_ID, matchoff,
  36                                             matchlen);
  37                 if (ret > 0)
  38                         break;
  39                 if (!ret)
  40                         return 0;
  41                 dataoff += *matchoff;
  42         }
  43
  44         /* Empty callid is useless */
  45         if (!*matchlen)
  46                 return -EINVAL;
  47
  48         /* Too large is useless */
  49         if (*matchlen > IP_VS_PEDATA_MAXLEN)
  50                 return -EINVAL;
  51
  52         /* SIP headers are always followed by a line terminator */
  53         if (*matchoff + *matchlen == datalen)
  54                 return -EINVAL;
  55
  56         /* RFC 2543 allows lines to be terminated with CR, LF or CRLF,
  57          * RFC 3261 allows only CRLF, we support both. */
  58         if (*(dptr + *matchoff + *matchlen) != '\r' &&
  59             *(dptr + *matchoff + *matchlen) != '\n')
  60                 return -EINVAL;
  61
  62         IP_VS_DBG_BUF(9, "SIP callid %s (%d bytes)\n",
  63                       IP_VS_DEBUG_CALLID(dptr + *matchoff, *matchlen),
  64                       *matchlen);
  65         return 0;
  66 }
  67
  68 static int
  69 ip_vs_sip_fill_param(struct ip_vs_conn_param *p, struct sk_buff *skb)
  70 {
  71         struct ip_vs_iphdr iph;
  72         unsigned int dataoff, datalen, matchoff, matchlen;
  73         const char *dptr;
  74
  75         ip_vs_fill_iphdr(p->af, skb_network_header(skb), &iph);
  76
  77         /* Only useful with UDP */
  78         if (iph.protocol != IPPROTO_UDP)
  79                 return -EINVAL;
  80
  81         /* No Data ? */
  82         dataoff = iph.len + sizeof(struct udphdr);
  83         if (dataoff >= skb->len)
  84                 return -EINVAL;
  85
  86         dptr = skb->data + dataoff;
  87         datalen = skb->len - dataoff;
  88
  89         if (get_callid(dptr, dataoff, datalen, &matchoff, &matchlen))
  90                 return -EINVAL;
  91
  92         p->pe_data = kmalloc(matchlen, GFP_ATOMIC);
  93         if (!p->pe_data)
  94                 return -ENOMEM;
  95
  96         /* N.B: pe_data is only set on success,
  97          * this allows fallback to the default persistence logic on failure
  98          */
  99         memcpy(p->pe_data, dptr + matchoff, matchlen);
 100         p->pe_data_len = matchlen;
 101
 102         return 0;
 103 }
 104
 105 static bool ip_vs_sip_ct_match(const struct ip_vs_conn_param *p,
 106                                   struct ip_vs_conn *ct)
 107
 108 {
 109         bool ret = 0;
 110
 111         if (ct->af == p->af &&
 112             ip_vs_addr_equal(p->af, p->caddr, &ct->caddr) &&
 113             /* protocol should only be IPPROTO_IP if
 114              * d_addr is a fwmark */
 115             ip_vs_addr_equal(p->protocol == IPPROTO_IP ? AF_UNSPEC : p->af,
 116                              p->vaddr, &ct->vaddr) &&
 117             ct->vport == p->vport &&
 118             ct->flags & IP_VS_CONN_F_TEMPLATE &&
 119             ct->protocol == p->protocol &&
 120             ct->pe_data && ct->pe_data_len == p->pe_data_len &&
 121             !memcmp(ct->pe_data, p->pe_data, p->pe_data_len))
 122                 ret = 1;
 123
 124         IP_VS_DBG_BUF(9, "SIP template match %s %s->%s:%d %s\n",
 125                       ip_vs_proto_name(p->protocol),
 126                       IP_VS_DEBUG_CALLID(p->pe_data, p->pe_data_len),
 127                       IP_VS_DBG_ADDR(p->af, p->vaddr), ntohs(p->vport),
 128                       ret ? "hit" : "not hit");
 129
 130         return ret;
 131 }
 132
 133 static u32 ip_vs_sip_hashkey_raw(const struct ip_vs_conn_param *p,
 134                                  u32 initval, bool inverse)
 135 {
 136         return jhash(p->pe_data, p->pe_data_len, initval);
 137 }
 138
 139 static int ip_vs_sip_show_pe_data(const struct ip_vs_conn *cp, char *buf)
 140 {
 141         memcpy(buf, cp->pe_data, cp->pe_data_len);
 142         return cp->pe_data_len;
 143 }
 144
 145 static struct ip_vs_pe ip_vs_sip_pe =
 146 {
 147         .name =                 "sip",
 148         .refcnt =               ATOMIC_INIT(0),
 149         .module =               THIS_MODULE,
 150         .n_list =               LIST_HEAD_INIT(ip_vs_sip_pe.n_list),
 151         .fill_param =           ip_vs_sip_fill_param,
 152         .ct_match =             ip_vs_sip_ct_match,
 153         .hashkey_raw =          ip_vs_sip_hashkey_raw,
 154         .show_pe_data =         ip_vs_sip_show_pe_data,
 155 };
 156
 157 static int __init ip_vs_sip_init(void)
 158 {
 159         return register_ip_vs_pe(&ip_vs_sip_pe);
 160 }
 161
 162 static void __exit ip_vs_sip_cleanup(void)
 163 {
 164         unregister_ip_vs_pe(&ip_vs_sip_pe);
 165 }
 166
 167 module_init(ip_vs_sip_init);
 168 module_exit(ip_vs_sip_cleanup);
 169 MODULE_LICENSE("GPL");