git.sip-router.org Git - kamailio/blob - src/modules/usrloc/ul_keepalive.c

   1 /*
   2  * Usrloc module - keepalive
   3  *
   4  * Copyright (C) 2020 Asipto.com
   5  *
   6  * This file is part of Kamailio, a free SIP server.
   7  *
   8  * Kamailio is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version
  12  *
  13  * Kamailio is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <time.h>
  28 #include <sys/time.h>
  29
  30 #include "../../core/dprint.h"
  31 #include "../../core/ut.h"
  32 #include "../../core/resolve.h"
  33 #include "../../core/forward.h"
  34 #include "../../core/globals.h"
  35 #include "../../core/pvar.h"
  36 #include "../../core/parser/parse_uri.h"
  37 #include "../../core/parser/parse_from.h"
  38 #include "../../core/parser/parse_to.h"
  39 #include "../../core/parser/parse_rr.h"
  40
  41 #include "ul_keepalive.h"
  42
  43 extern int ul_keepalive_timeout;
  44
  45 static int ul_ka_send(str *kamsg, dest_info_t *kadst);
  46
  47 /**
  48  *
  49 _KAMETHOD_ _URI_ SIP/2.0\r\n
  50 Via: SIP/2.0/_PROTO_ _IP_:_PORT_;branch=z9hG4bKx._GCNT_._BCNT_.0\r\n
  51 __KAROUTES__
  52 From: <_KAFROM_>;tag=_RUID_-_AORHASH_-_TIMESEC_-_TIMEUSEC_-_GCNT_._BCNT_\r\n
  53 To: <sip:_AOR_>\r\n
  54 Call-ID: _KACALLID_\r\n
  55 CSeq: 1 _KAMETHOD_\r\n
  56 Content-Length: 0\r\n\r\n"
  57
  58 */
  59
  60 #define ULKA_CALLID_PREFIX "ksrulka-"
  61 #define ULKA_CALLID_PREFIX_LEN (sizeof(ULKA_CALLID_PREFIX) - 1)
  62
  63 #define ULKA_MSG "%.*s %.*s SIP/2.0\r\n" \
  64   "Via: SIP/2.0/%.*s %.*s:%.*s;branch=z9hG4bKx.%u.%u.0\r\n" \
  65   "%s%.*s%.*s" \
  66   "From: <%.*s>;tag=%.*s-%x-%lx-%lx-%x.%x\r\n" \
  67   "To: <sip:%.*s%s%.*s>\r\n" \
  68   "Call-ID: " ULKA_CALLID_PREFIX "%u.%u\r\n" \
  69   "CSeq: 80 %.*s\r\n" \
  70   "Content-Length: 0\r\n\r\n"
  71
  72 extern str ul_ka_from;
  73 extern str ul_ka_domain;
  74 extern str ul_ka_method;
  75 extern int ul_ka_mode;
  76 extern int ul_ka_filter;
  77 extern int ul_ka_loglevel;
  78 extern pv_elem_t *ul_ka_logfmt;
  79
  80 extern unsigned int ul_nat_bflag;
  81
  82 static unsigned int _ul_ka_counter = 0;
  83
  84 /**
  85  *
  86  */
  87 int ul_ka_urecord(urecord_t *ur)
  88 {
  89         ucontact_t *uc;
  90 #define ULKA_BUF_SIZE 2048
  91         char kabuf[ULKA_BUF_SIZE];
  92         int kabuf_len;
  93         str kamsg;
  94         str vaddr;
  95         str vport;
  96         str sdst = STR_NULL;
  97         str sproto = STR_NULL;
  98         sip_uri_t duri;
  99         char dproto;
 100         struct hostent *he;
 101         socket_info_t *ssock;
 102         dest_info_t idst;
 103         unsigned int bcnt = 0;
 104         int aortype = 0;
 105         int i;
 106         struct timeval tv;
 107         time_t tnow = 0;
 108
 109         if (ul_ka_mode == ULKA_NONE) {
 110                 return 0;
 111         }
 112         LM_DBG("keepalive for aor: %.*s\n", ur->aor.len, ur->aor.s);
 113         tnow = time(NULL);
 114
 115         for(i=0; i<ur->aor.len; i++) {
 116                 if(ur->aor.s[i] == '@') {
 117                         aortype = 1;
 118                         break;
 119                 }
 120         }
 121         _ul_ka_counter++;
 122         for (uc = ur->contacts; uc != NULL; uc = uc->next) {
 123                 if (uc->c.len <= 0) {
 124                         continue;
 125                 }
 126                 if((ul_ka_filter&GAU_OPT_SERVER_ID) && (uc->server_id != server_id)) {
 127                         continue;
 128                 }
 129                 if(ul_keepalive_timeout>0 && uc->last_keepalive>0) {
 130                         if(uc->last_keepalive+ul_keepalive_timeout < tnow) {
 131                                 /* set contact as expired in 10s */
 132                                 LM_DBG("set expired contact on keepalive - aor: %.*s c: %.*s\n",
 133                                                 ur->aor.len, ur->aor.s, uc->c.len, uc->c.s);
 134                                 if(uc->expires > tnow + 10) {
 135                                         uc->expires = tnow + 10;
 136                                         continue;
 137                                 }
 138                         }
 139                 }
 140
 141                 if(ul_ka_mode & ULKA_NAT) {
 142                         /* keepalive for natted contacts only */
 143                         if (ul_nat_bflag == 0) {
 144                                 continue;
 145                         }
 146                         if ((uc->cflags & ul_nat_bflag) != ul_nat_bflag) {
 147                                 continue;
 148                         }
 149                 }
 150                 if(uc->received.len > 0) {
 151                         sdst = uc->received;
 152                 } else {
 153                         if (uc->path.len > 0) {
 154                                 if(get_path_dst_uri(&uc->path, &sdst) < 0) {
 155                                         LM_ERR("failed to get first uri for path\n");
 156                                         continue;
 157                                 }
 158                         } else {
 159                                 sdst = uc->c;
 160                         }
 161                 }
 162                 if(parse_uri(sdst.s, sdst.len, &duri) < 0) {
 163                         LM_ERR("cannot parse next hop uri\n");
 164                         continue;
 165                 }
 166
 167                 if(duri.port_no == 0) {
 168                         duri.port_no = SIP_PORT;
 169                 }
 170                 dproto = duri.proto;
 171                 he = sip_resolvehost(&duri.host, &duri.port_no, &dproto);
 172                 if(he == NULL) {
 173                         LM_ERR("cannot resolve destination\n");
 174                         continue;
 175                 }
 176                 if(ul_ka_mode & ULKA_UDP) {
 177                         if(dproto != PROTO_UDP) {
 178                                 LM_DBG("skipping non-udp contact - proto %d\n", (int)dproto);
 179                                 continue;
 180                         }
 181                 }
 182                 init_dest_info(&idst);
 183                 hostent2su(&idst.to, he, 0, duri.port_no);
 184                 ssock = uc->sock;
 185                 if(ssock == NULL) {
 186                         ssock = get_send_socket(0, &idst.to, dproto);
 187                 }
 188                 if(ssock == NULL) {
 189                         LM_ERR("cannot get sending socket\n");
 190                         continue;
 191                 }
 192                 idst.proto = dproto;
 193                 idst.send_sock = ssock;
 194
 195                 if(ssock->useinfo.name.len > 0) {
 196                         vaddr = ssock->useinfo.name;
 197                 } else {
 198                         vaddr = ssock->address_str;
 199                 }
 200                 if(ssock->useinfo.port_no > 0) {
 201                         vport = ssock->useinfo.port_no_str;
 202                 } else {
 203                         vport = ssock->port_no_str;
 204                 }
 205                 get_valid_proto_string(dproto, 1, 1, &sproto);
 206
 207                 bcnt++;
 208                 gettimeofday(&tv, NULL);
 209                 kabuf_len = snprintf(kabuf, ULKA_BUF_SIZE - 1, ULKA_MSG,
 210                                 ul_ka_method.len, ul_ka_method.s,
 211                                 uc->c.len, uc->c.s,
 212                                 sproto.len, sproto.s,
 213                                 vaddr.len, vaddr.s,
 214                                 vport.len, vport.s,
 215                                 _ul_ka_counter, bcnt,
 216                                 (uc->path.len>0)?"Route: ":"",
 217                                 (uc->path.len>0)?uc->path.len:0,
 218                                 (uc->path.len>0)?uc->path.s:"",
 219                                 (uc->path.len>0)?2:0,
 220                                 (uc->path.len>0)?"\r\n":"",
 221                                 ul_ka_from.len, ul_ka_from.s,
 222                                 uc->ruid.len, uc->ruid.s, ur->aorhash,
 223                                 (unsigned long)tv.tv_sec, (unsigned long)tv.tv_usec,
 224                                 _ul_ka_counter, bcnt,
 225                                 ur->aor.len, ur->aor.s,
 226                                 (aortype==1)?"":"@",
 227                                 (aortype==1)?0:ul_ka_domain.len, (aortype==1)?"":ul_ka_domain.s,
 228                                 _ul_ka_counter, bcnt,
 229                                 ul_ka_method.len, ul_ka_method.s);
 230                 if(kabuf_len<=0 || kabuf_len>=ULKA_BUF_SIZE) {
 231                         LM_ERR("failed to print the keepalive request\n");
 232                 } else {
 233                         LM_DBG("keepalive request (len: %d) [[\n%.*s]]\n",
 234                                         kabuf_len, kabuf_len, kabuf);
 235                         kamsg.s = kabuf;
 236                         kamsg.len = kabuf_len;
 237                         ul_ka_send(&kamsg, &idst);
 238                 }
 239
 240         }
 241         return 0;
 242 }
 243
 244 /**
 245  *
 246  */
 247 static int ul_ka_send(str *kamsg, dest_info_t *kadst)
 248 {
 249         if (kadst->proto == PROTO_UDP) {
 250                 return udp_send(kadst, kamsg->s, kamsg->len);
 251         }
 252
 253 #ifdef USE_TCP
 254         else if(kadst->proto == PROTO_TCP) {
 255                 /*tcp*/
 256                 kadst->id=0;
 257                 return tcp_send(kadst, 0, kamsg->s, kamsg->len);
 258         }
 259 #endif
 260 #ifdef USE_TLS
 261         else if(kadst->proto == PROTO_TLS) {
 262                 /*tls*/
 263                 kadst->id=0;
 264                 return tcp_send(kadst, 0, kamsg->s, kamsg->len);
 265         }
 266 #endif
 267 #ifdef USE_SCTP
 268         else if(kadst->proto == PROTO_SCTP) {
 269                 /*sctp*/
 270                 return sctp_core_msg_send(kadst, kamsg->s, kamsg->len);
 271         }
 272 #endif
 273         else {
 274                 LM_ERR("unknown proto [%d] for sending keepalive\n",
 275                                 kadst->proto);
 276                 return -1;
 277         }
 278 }
 279
 280 /**
 281  *
 282  */
 283 unsigned long ul_ka_fromhex(str *shex, int *err)
 284 {
 285     unsigned long v = 0;
 286         int i;
 287
 288         *err = 0;
 289     for (i=0; i<shex->len; i++) {
 290         char b = shex->s[i];
 291         if (b >= '0' && b <= '9') b = b - '0';
 292         else if (b >= 'a' && b <='f') b = b - 'a' + 10;
 293         else if (b >= 'A' && b <='F') b = b - 'A' + 10;
 294                 else { *err = 1; return 0; };
 295         v = (v << 4) | (b & 0xF);
 296     }
 297     return v;
 298 }
 299
 300 /**
 301  *
 302  */
 303 int ul_ka_reply_received(sip_msg_t *msg)
 304 {
 305         to_body_t *fb;
 306         str ruid;
 307         str tok;
 308         int err;
 309         unsigned int aorhash;
 310         char *p;
 311         struct timeval tvm;
 312         struct timeval tvn;
 313         unsigned int tvdiff;
 314
 315         if(msg->cseq == NULL) {
 316                 if((parse_headers(msg, HDR_CSEQ_F, 0) == -1) || (msg->cseq == NULL)) {
 317                         LM_ERR("invalid CSeq header\n");
 318                         return -1;
 319                 }
 320         }
 321
 322         if(get_cseq(msg)->method.len != ul_ka_method.len) {
 323                 return 1;
 324         }
 325         if(strncmp(get_cseq(msg)->method.s, ul_ka_method.s, ul_ka_method.len) != 0) {
 326                 return 1;
 327         }
 328
 329         /* there must be no second via */
 330         if(!(parse_headers(msg, HDR_VIA2_F, 0) == -1 || (msg->via2 == 0)
 331                            || (msg->via2->error != PARSE_OK))) {
 332                 return 1;
 333         }
 334
 335         /* from uri check */
 336         if((parse_from_header(msg)) < 0) {
 337                 LM_ERR("cannot parse From header\n");
 338                 return -1;
 339         }
 340
 341         fb = get_from(msg);
 342         if(fb->uri.len != ul_ka_from.len
 343                         || strncmp(fb->uri.s, ul_ka_from.s, ul_ka_from.len) != 0) {
 344                 return 1;
 345         }
 346
 347         /* from-tag is: ruid-aorhash-tmsec-tmusec-counter */
 348         if(fb->tag_value.len <= 8) {
 349                 return 1;
 350         }
 351
 352         LM_DBG("checking keepalive reply [%.*s]\n", fb->tag_value.len,
 353                         fb->tag_value.s);
 354
 355         /* todo: macro/function to tokenize */
 356         /* skip counter */
 357         p = q_memrchr(fb->tag_value.s, '-', fb->tag_value.len);
 358         if(p == NULL) {
 359                 LM_DBG("from tag format mismatch [%.*s]\n", fb->tag_value.len,
 360                                 fb->tag_value.s);
 361                 return 1;
 362         }
 363
 364         /* tv_usec hash */
 365         tok.len = p - fb->tag_value.s;
 366         p = q_memrchr(fb->tag_value.s, '-', tok.len);
 367         if(p == NULL) {
 368                 LM_DBG("from tag format mismatch [%.*s]\n", fb->tag_value.len,
 369                                 fb->tag_value.s);
 370                 return 1;
 371         }
 372         tok.s = p + 1;
 373         tok.len = fb->tag_value.s + tok.len - tok.s;
 374         if(tok.len <= 0) {
 375                 LM_DBG("empty token\n");
 376                 return 1;
 377         }
 378         LM_DBG("tv usec string is [%.*s] (%d)\n", tok.len, tok.s, tok.len);
 379         tvm.tv_usec = ul_ka_fromhex(&tok, &err);
 380         if(err==1) {
 381                 LM_DBG("invalid tv usec value\n");
 382                 return 1;
 383         }
 384         LM_DBG("tv usec is [%lu]\n", (unsigned long)tvm.tv_usec);
 385
 386         /* tv_sec hash */
 387         tok.len = p - fb->tag_value.s;
 388         p = q_memrchr(fb->tag_value.s, '-', tok.len);
 389         if(p == NULL) {
 390                 LM_DBG("from tag format mismatch [%.*s]\n", fb->tag_value.len,
 391                                 fb->tag_value.s);
 392                 return 1;
 393         }
 394         tok.s = p + 1;
 395         tok.len = fb->tag_value.s + tok.len - tok.s;
 396         if(tok.len <= 0) {
 397                 LM_DBG("empty token\n");
 398                 return 1;
 399         }
 400         LM_DBG("tv sec string is [%.*s] (%d)\n", tok.len, tok.s, tok.len);
 401         tvm.tv_sec = ul_ka_fromhex(&tok, &err);
 402         if(err==1) {
 403                 LM_DBG("invalid tv sec value\n");
 404                 return 1;
 405         }
 406         LM_DBG("tv sec is [%lu]\n", (unsigned long)tvm.tv_sec);
 407
 408         /* aor hash */
 409         tok.len = p - fb->tag_value.s;
 410         p = q_memrchr(fb->tag_value.s, '-', tok.len);
 411         if(p == NULL) {
 412                 LM_DBG("from tag format mismatch [%.*s]\n", fb->tag_value.len,
 413                                 fb->tag_value.s);
 414                 return 1;
 415         }
 416         tok.s = p + 1;
 417         tok.len = fb->tag_value.s + tok.len - tok.s;
 418         if(tok.len <= 0) {
 419                 LM_DBG("empty token\n");
 420                 return 1;
 421         }
 422         LM_DBG("aor hash string is [%.*s] (%d)\n", tok.len, tok.s, tok.len);
 423         aorhash = ul_ka_fromhex(&tok, &err);
 424         if(err==1) {
 425                 LM_DBG("invalid aor hash value\n");
 426                 return 1;
 427         }
 428         LM_DBG("aor hash is [%u]\n", aorhash);
 429
 430         ruid.s = fb->tag_value.s;
 431         ruid.len = tok.s - ruid.s - 1;
 432
 433         if(ruid.len <= 0) {
 434                 LM_DBG("cannot get ruid in [%.*s]\n", fb->tag_value.len,
 435                                 fb->tag_value.s);
 436                 return 1;
 437         }
 438
 439         gettimeofday(&tvn, NULL);
 440         tvdiff = (tvn.tv_sec - tvm.tv_sec) * 1000000
 441                                         + (tvn.tv_usec - tvm.tv_usec);
 442         ul_update_keepalive(aorhash, &ruid, tvn.tv_sec, tvdiff);
 443
 444         if(ul_ka_loglevel != 255 && ul_ka_logfmt != NULL) {
 445                 if (pv_printf_s(msg, ul_ka_logfmt, &tok) == 0) {
 446                         LOG(ul_ka_loglevel, "keepalive roundtrip: %u.%06u sec - ruid [%.*s]%.*s\n",
 447                                         tvdiff/1000000, tvdiff%1000000, ruid.len, ruid.s,
 448                                         tok.len, tok.s);
 449                         return 0;
 450                 }
 451         }
 452
 453         LM_DBG("response of keepalive for ruid [%.*s] aorhash [%u] roundtrip: %u.%06u secs\n",
 454                         ruid.len, ruid.s, aorhash, tvdiff/1000000, tvdiff%1000000);
 455
 456         return 0;
 457 }