src/core/sipe-utils.c

   1 /**
   2  * @file sipe-utils.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2009-2016 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <time.h>
  28
  29 #include <glib.h>
  30
  31 #include "sip-transport.h"
  32 #include "sipe-backend.h"
  33 #include "sipe-core.h"    /* to ensure same API for backends */
  34 #include "sipe-core-private.h"
  35 #include "sipe-utils.h"
  36 #include "uuid.h"
  37
  38 /* Generate 16 random bits */
  39 #define RANDOM16BITS (rand() & 0xFFFF)
  40
  41 gchar *gencallid(void)
  42 {
  43         return g_strdup_printf("%04Xg%04Xa%04Xi%04Xm%04Xt%04Xb%04Xx%04Xx",
  44                                RANDOM16BITS, RANDOM16BITS, RANDOM16BITS,
  45                                RANDOM16BITS, RANDOM16BITS, RANDOM16BITS,
  46                                RANDOM16BITS, RANDOM16BITS);
  47 }
  48
  49 gchar *gentag(void)
  50 {
  51         return g_strdup_printf("%04d%04d", RANDOM16BITS, RANDOM16BITS);
  52 }
  53
  54 gchar *genconfid(void)
  55 {
  56         return g_strdup_printf("%04X%04X%04X%04X%04X%04X%04X%04X",
  57                                RANDOM16BITS, RANDOM16BITS, RANDOM16BITS,
  58                                RANDOM16BITS, RANDOM16BITS, RANDOM16BITS,
  59                                RANDOM16BITS, RANDOM16BITS);
  60 }
  61
  62 gchar *get_contact(const struct sipe_core_private *sipe_private)
  63 {
  64         return g_strdup(sipe_private->contact);
  65 }
  66
  67 gchar *parse_from(const gchar *hdr)
  68 {
  69         gchar *from;
  70         const gchar *tmp, *tmp2 = hdr;
  71
  72         if (!hdr) return NULL;
  73         SIPE_DEBUG_INFO("parsing address out of %s", hdr);
  74         tmp = strchr(hdr, '<');
  75
  76         /* i hate the different SIP UA behaviours... */
  77         if (tmp) { /* sip address in <...> */
  78                 tmp2 = tmp + 1;
  79                 tmp = strchr(tmp2, '>');
  80                 if (tmp) {
  81                         from = g_strndup(tmp2, tmp - tmp2);
  82                 } else {
  83                         SIPE_DEBUG_INFO_NOFORMAT("found < without > in From");
  84                         return NULL;
  85                 }
  86         } else {
  87                 tmp = strchr(tmp2, ';');
  88                 if (tmp) {
  89                         from = g_strndup(tmp2, tmp - tmp2);
  90                 } else {
  91                         from = g_strdup(tmp2);
  92                 }
  93         }
  94         SIPE_DEBUG_INFO("got %s", from);
  95         return from;
  96 }
  97
  98 gchar *sip_uri_from_name(const gchar *name)
  99 {
 100         return(g_strdup_printf("sip:%s", name));
 101 }
 102
 103 gchar *sip_uri(const gchar *string)
 104 {
 105         return(strstr(string, "sip:") ? g_strdup(string) : sip_uri_from_name(string));
 106 }
 107
 108 static gchar *escape_uri_part(const gchar *in, guint len)
 109 {
 110         gchar *escaped = NULL;
 111
 112         if (len) {
 113                 gchar *s;
 114
 115                 /* reserve space for worst case, i.e. every character needs escaping */
 116                 escaped = s = g_malloc(3 * len + 1);
 117                 while (len--) {
 118                         gchar c = *in++;
 119
 120                         /* only allow ASCII characters */
 121                         if (!isascii(c)) {
 122                                 g_free(escaped);
 123                                 return(NULL);
 124                         }
 125
 126                         /*
 127                          * RFC 3986 Appendix A
 128                          *
 129                          * authority     = [ userinfo "@" ] host [ ":" port ]
 130                          * userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
 131                          * host          = IP-literal / IPv4address / reg-name
 132                          * reg-name      = *( unreserved / pct-encoded / sub-delims )
 133                          * pct-encoded   = "%" HEXDIG HEXDIG
 134                          * unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
 135                          *
 136                          * Escape everything that isn't in "unreserved"
 137                          */
 138                         if (isalnum(c) ||
 139                             (c == '.') ||
 140                             (c == '-') ||
 141                             (c == '_') ||
 142                             (c == '~')) {
 143                                 *s++ = c;
 144                         } else {
 145                                 sprintf(s, "%%%1X%1X", c / 16, c % 16);
 146                                 s += 3;
 147                         }
 148                 }
 149                 *s = '\0';
 150         }
 151
 152         return(escaped);
 153 }
 154
 155 gchar *sip_uri_if_valid(const gchar *string)
 156 {
 157         /* strip possible sip: prefix */
 158         const gchar *uri = sipe_get_no_sip_uri(string);
 159         const gchar *at;
 160         gchar *result    = NULL;
 161
 162         /* only XXX@YYY is valid */
 163         if (uri && ((at = strchr(uri, '@')) != NULL)) {
 164                 gchar *userinfo = escape_uri_part(uri, at - uri);
 165
 166                 if (userinfo) {
 167                         gchar *host = escape_uri_part(at + 1, strlen(at + 1));
 168
 169                         if (host) {
 170                                 /* name is valid for URI, convert it */
 171                                 result = g_strdup_printf("sip:%s@%s",
 172                                                          userinfo,
 173                                                          host);
 174                                 g_free(host);
 175                         }
 176                         g_free(userinfo);
 177                 }
 178         }
 179
 180         return(result);
 181 }
 182
 183 const gchar *sipe_get_no_sip_uri(const gchar *sip_uri)
 184 {
 185 #define SIP_PREFIX "sip:"
 186
 187         if (!sip_uri) return NULL;
 188
 189         if (g_str_has_prefix(sip_uri, SIP_PREFIX)) {
 190                 return(sip_uri + strlen(SIP_PREFIX));
 191         } else {
 192                 return sip_uri;
 193         }
 194 }
 195
 196 gchar *get_uuid(struct sipe_core_private *sipe_private)
 197 {
 198         return(generateUUIDfromEPID(sip_transport_epid(sipe_private)));
 199 }
 200
 201
 202 guint
 203 sipe_get_pub_instance(struct sipe_core_private *sipe_private,
 204                       int publication_key)
 205 {
 206         unsigned res = 0;
 207
 208         sscanf(sip_transport_epid(sipe_private), "%08x", &res);
 209
 210         if (publication_key == SIPE_PUB_DEVICE) {
 211                 /* as is */
 212         } else if (publication_key == SIPE_PUB_STATE_MACHINE) {         /* First hexadecimal digit is 0x3 */
 213                 res = (res >> 4) | 0x30000000;
 214         } else if (publication_key == SIPE_PUB_STATE_USER) {
 215                 res = 0x20000000; /* fixed */
 216         } else if (publication_key == SIPE_PUB_STATE_CALENDAR) {        /* First hexadecimal digit is 0x4 */
 217                 res = (res >> 4) | 0x40000000;
 218         } else if (publication_key == SIPE_PUB_STATE_CALENDAR_OOF) {    /* First hexadecimal digit is 0x5 */
 219                 res = (res >> 4) | 0x50000000;
 220         } else if (publication_key == SIPE_PUB_CALENDAR_DATA ||
 221                    publication_key == SIPE_PUB_NOTE_OOF)
 222         { /* First hexadecimal digit is 0x4 */
 223                 unsigned calendar_id = 0;
 224                 char *mail_hash = sipe_get_epid(sipe_private->email, "", "");
 225
 226                 sscanf(mail_hash, "%08x", &calendar_id);
 227                 g_free(mail_hash);
 228                 res = (calendar_id >> 4) | 0x40000000;
 229         } else if (publication_key == SIPE_PUB_STATE_PHONE_VOIP) {      /* First hexadecimal digit is 0x8 */
 230                 res = (res >> 4) | 0x80000000;
 231         }
 232
 233         return res;
 234 }
 235
 236 gboolean
 237 sipe_is_bad_alias(const char *uri,
 238                   const char *alias)
 239 {
 240         char *uri_alias;
 241         gboolean result = FALSE;
 242
 243         if (!uri) return FALSE;
 244         if (!alias) return TRUE;
 245
 246         if (g_str_has_prefix(alias, "sip:") || g_str_has_prefix(alias, "sips:")) return TRUE;
 247
 248         /* check if alias is just SIP URI but without 'sip:' prefix */
 249         uri_alias = sip_uri_from_name(alias);
 250         if (sipe_strcase_equal(uri, uri_alias)) {
 251                 result = TRUE;
 252         }
 253         g_free(uri_alias);
 254
 255         return result;
 256 }
 257
 258 gboolean
 259 is_empty(const char *st)
 260 {
 261         if (!st || strlen(st) == 0)
 262         {
 263                 return TRUE;
 264         }
 265         /* suspicious leading or trailing spaces */
 266         else if (isspace((unsigned char) *st) ||
 267                  isspace((unsigned char) *(st + strlen(st) - 1)))
 268         {
 269                 /* to not modify original string */
 270                 char *dup = g_strdup(st);
 271                 if (strlen(g_strstrip(dup)) == 0) {
 272                         g_free(dup);
 273                         return TRUE;
 274                 }
 275                 g_free(dup);
 276         }
 277         return FALSE;
 278 }
 279
 280 void sipe_utils_message_debug(const gchar *type,
 281                               const gchar *header,
 282                               const gchar *body,
 283                               gboolean sending)
 284 {
 285         if (sipe_backend_debug_enabled()) {
 286                 GString *str         = g_string_new("");
 287                 GTimeVal currtime;
 288                 gchar *time_str;
 289                 const char *marker   = sending ?
 290                         ">>>>>>>>>>" :
 291                         "<<<<<<<<<<";
 292                 gchar *tmp;
 293
 294                 g_get_current_time(&currtime);
 295                 time_str = g_time_val_to_iso8601(&currtime);
 296                 g_string_append_printf(str, "\nMESSAGE START %s %s - %s\n", marker, type, time_str);
 297                 g_string_append(str, tmp = sipe_utils_str_replace(header, "\r\n", "\n"));
 298                 g_free(tmp);
 299                 g_string_append(str, "\n");
 300                 if (body) {
 301                         g_string_append(str, tmp = sipe_utils_str_replace(body, "\r\n", "\n"));
 302                         g_free(tmp);
 303                         g_string_append(str, "\n");
 304                 }
 305                 g_string_append_printf(str, "MESSAGE END %s %s - %s", marker, type, time_str);
 306                 g_free(time_str);
 307                 SIPE_DEBUG_INFO_NOFORMAT(str->str);
 308                 g_string_free(str, TRUE);
 309         }
 310 }
 311
 312 gboolean
 313 sipe_strequal(const gchar *left, const gchar *right)
 314 {
 315 #if GLIB_CHECK_VERSION(2,16,0)
 316         return (g_strcmp0(left, right) == 0);
 317 #else
 318         return ((left == NULL && right == NULL) ||
 319                 (left != NULL && right != NULL && strcmp(left, right) == 0));
 320 #endif
 321 }
 322
 323 gboolean
 324 sipe_strcase_equal(const gchar *left, const gchar *right)
 325 {
 326         return ((left == NULL && right == NULL) ||
 327                 (left != NULL && right != NULL && g_ascii_strcasecmp(left, right) == 0));
 328 }
 329
 330 gint sipe_strcompare(gconstpointer a, gconstpointer b)
 331 {
 332 #if GLIB_CHECK_VERSION(2,16,0)
 333         return (g_strcmp0(a, b));
 334 #else
 335         if (!a)
 336                 return -(a != b);
 337         if (!b)
 338                 return a != b;
 339         return strcmp(a, b);
 340 #endif
 341 }
 342
 343 time_t
 344 sipe_utils_str_to_time(const gchar *timestamp)
 345 {
 346         GTimeVal time;
 347         gboolean success = FALSE;
 348
 349         /* g_time_val_from_iso8601() warns about NULL pointer */
 350         if (timestamp) {
 351                 guint len;
 352
 353                 /* We have to make sure that the ISO8601 contains a time zone offset,
 354                    otherwise the time is interpreted as local time, not UTC!
 355                    @TODO: is there a better way to check this? */
 356                 if (((len = strlen(timestamp)) > 0) &&
 357                     isdigit(timestamp[len-1])) {
 358                         gchar *tmp = g_strdup_printf("%sZ", timestamp);
 359                         success = g_time_val_from_iso8601(tmp, &time);
 360                         g_free(tmp);
 361                 } else {
 362                         success = g_time_val_from_iso8601(timestamp, &time);
 363                 }
 364         }
 365
 366         if (!success) {
 367                 SIPE_DEBUG_ERROR("sipe_utils_str_to_time: failed to parse ISO8601 string '%s'",
 368                                  timestamp ? timestamp : "");
 369                 time.tv_sec = 0;
 370         }
 371
 372         return time.tv_sec;
 373 }
 374
 375 gchar *
 376 sipe_utils_time_to_str(time_t timestamp)
 377 {
 378         GTimeVal time = { timestamp, 0 };
 379         return g_time_val_to_iso8601(&time);
 380 }
 381
 382 const gchar *sipe_utils_time_to_debug_str(const struct tm *tm)
 383 {
 384         gchar *buffer = asctime(tm);
 385         size_t length;
 386
 387         if (!buffer)
 388                 return("");
 389
 390         /* asctime() appends "\n" to the resulting string -> strip it */
 391         length = strlen(buffer);
 392         if (length)
 393                 buffer[length - 1] = '\0';
 394
 395         return(buffer);
 396 }
 397
 398 size_t
 399 hex_str_to_buff(const char *hex_str, guint8 **buff)
 400 {
 401         char two_digits[3];
 402         size_t length;
 403         size_t i;
 404
 405         if (!buff) return 0;
 406         if (!hex_str) return 0;
 407
 408         length = strlen(hex_str)/2;
 409         *buff = (unsigned char *)g_malloc(length);
 410         for (i = 0; i < length; i++) {
 411                 two_digits[0] = hex_str[i * 2];
 412                 two_digits[1] = hex_str[i * 2 + 1];
 413                 two_digits[2] = '\0';
 414                 (*buff)[i] = (unsigned char)strtoul(two_digits, NULL, 16);
 415         }
 416
 417         return length;
 418 }
 419
 420 char *
 421 buff_to_hex_str(const guint8 *buff, const size_t buff_len)
 422 {
 423         char *res;
 424         size_t i, j;
 425
 426         if (!buff) return NULL;
 427
 428         res = g_malloc(buff_len * 2 + 1);
 429         for (i = 0, j = 0; i < buff_len; i++, j+=2) {
 430                 sprintf(&res[j], "%02X", buff[i]);
 431         }
 432         res[j] = '\0';
 433         return res;
 434 }
 435
 436 gboolean
 437 sipe_utils_parse_lines(GSList **list, gchar **lines, gchar *delimiter)
 438 {
 439         int i;
 440         gchar **parts;
 441         gchar *dummy;
 442         gchar *dummy2;
 443         gchar *tmp;
 444
 445         for(i = 0; lines[i] && strlen(lines[i]) > 2; i++) {
 446                 parts = g_strsplit(lines[i], delimiter, 2);
 447                 if(!parts[0] || !parts[1]) {
 448                         g_strfreev(parts);
 449                         return FALSE;
 450                 }
 451                 dummy = parts[1];
 452                 dummy2 = 0;
 453                 while(*dummy==' ' || *dummy=='\t') dummy++;
 454                 dummy2 = g_strdup(dummy);
 455                 while(lines[i+1] && (lines[i+1][0]==' ' || lines[i+1][0]=='\t')) {
 456                         i++;
 457                         dummy = lines[i];
 458                         while(*dummy==' ' || *dummy=='\t') dummy++;
 459                         tmp = g_strdup_printf("%s %s",dummy2, dummy);
 460                         g_free(dummy2);
 461                         dummy2 = tmp;
 462                 }
 463                 *list = sipe_utils_nameval_add(*list, parts[0], dummy2);
 464                 g_free(dummy2);
 465                 g_strfreev(parts);
 466         }
 467
 468         return TRUE;
 469 }
 470
 471 GSList*
 472 sipe_utils_nameval_add(GSList* list, const gchar *name, const gchar *value)
 473 {
 474         struct sipnameval *element = g_new0(struct sipnameval,1);
 475
 476         /* SANITY CHECK: the calling code must be fixed if this happens! */
 477         if (!value) {
 478                 SIPE_DEBUG_ERROR("sipe_utils_nameval_add: NULL value for %s",
 479                                  name);
 480                 value = "";
 481         }
 482
 483         element->name = g_strdup(name);
 484         element->value = g_strdup(value);
 485         return g_slist_append(list, element);
 486 }
 487
 488 void
 489 sipe_utils_nameval_free(GSList *list) {
 490         struct sipnameval *elem;
 491         while(list) {
 492                 elem = list->data;
 493                 list = g_slist_remove(list,elem);
 494                 g_free(elem->name);
 495                 g_free(elem->value);
 496                 g_free(elem);
 497         }
 498 }
 499
 500 const gchar *
 501 sipe_utils_nameval_find(const GSList *list, const gchar *name)
 502 {
 503         return sipe_utils_nameval_find_instance (list, name, 0);
 504 }
 505
 506 const gchar *
 507 sipe_utils_nameval_find_instance(const GSList *list, const gchar *name, int which)
 508 {
 509         const GSList *tmp;
 510         struct sipnameval *elem;
 511         int i = 0;
 512         tmp = list;
 513         while(tmp) {
 514                 elem = tmp->data;
 515                 // OCS2005 can send the same header in either all caps or mixed case
 516                 if (sipe_strcase_equal(elem->name, name)) {
 517                         if (i == which) {
 518                                 return elem->value;
 519                         }
 520                         i++;
 521                 }
 522                 tmp = g_slist_next(tmp);
 523         }
 524         return NULL;
 525 }
 526
 527 gchar *sipe_utils_str_replace(const gchar *string,
 528                               const gchar *delimiter,
 529                               const gchar *replacement)
 530 {
 531         gchar **split;
 532         gchar *result;
 533
 534         if (!string || !delimiter || !replacement) return NULL;
 535
 536         split = g_strsplit(string, delimiter, 0);
 537         result = g_strjoinv(replacement, split);
 538         g_strfreev(split);
 539
 540         return result;
 541 }
 542
 543 void sipe_utils_shrink_buffer(struct sipe_transport_connection *conn,
 544                               const gchar *unread)
 545 {
 546         conn->buffer_used -= unread - conn->buffer;
 547         /* string terminator is not included in buffer_used */
 548         memmove(conn->buffer, unread, conn->buffer_used + 1);
 549 }
 550
 551 gboolean sipe_utils_ip_is_private(const char *ip)
 552 {
 553         return g_str_has_prefix(ip, "10.")      ||
 554                g_str_has_prefix(ip, "172.16.")  ||
 555                g_str_has_prefix(ip, "192.168.");
 556 }
 557
 558 gchar *sipe_utils_presence_key(const gchar *uri)
 559 {
 560         return g_strdup_printf("<presence><%s>", uri);
 561 }
 562
 563 gchar *
 564 sipe_utils_uri_unescape(const gchar *string)
 565 {
 566         gchar *unescaped;
 567         gchar *tmp;
 568
 569         if (!string)
 570                 return NULL;
 571
 572 #if GLIB_CHECK_VERSION(2,16,0)
 573         unescaped = g_uri_unescape_string(string, NULL);
 574 #else
 575         // based on libpurple/util.c:purple_url_decode()
 576         {
 577                 GString *buf = g_string_new(NULL);
 578                 size_t len = strlen(string);
 579                 char hex[3];
 580
 581                 hex[2] = '\0';
 582
 583                 while (len--) {
 584                         gchar c = *string++;
 585
 586                         if ((len >= 2) && (c == '%')) {
 587                                 strncpy(hex, string, 2);
 588                                 c = strtol(hex, NULL, 16);
 589
 590                                 string += 2;
 591                                 len -= 2;
 592                         }
 593
 594                         g_string_append_c(buf, c);
 595                 }
 596
 597                 unescaped = g_string_free(buf, FALSE);
 598         }
 599 #endif
 600         if (unescaped && !g_utf8_validate(unescaped, -1, (const gchar **)&tmp))
 601                 *tmp = '\0';
 602
 603         return unescaped;
 604 }
 605
 606 GSList *sipe_utils_slist_insert_unique_sorted(GSList *list,
 607                                               gpointer data,
 608                                               GCompareFunc func,
 609                                               GDestroyNotify destroy)
 610 {
 611         if (g_slist_find_custom(list, data, func)) {
 612                 /* duplicate */
 613                 if (destroy)
 614                         (*destroy)(data);
 615                 return(list);
 616         } else {
 617                 /* unique: list takes ownership of "data" */
 618                 return(g_slist_insert_sorted(list, data, func));
 619         }
 620 }
 621
 622 void sipe_utils_slist_free_full(GSList *list,
 623                                 GDestroyNotify free)
 624 {
 625 #if GLIB_CHECK_VERSION(2,28,0)
 626         g_slist_free_full(list, free);
 627 #else
 628         GSList *entry = list;
 629         while (entry) {
 630                 (*free)(entry->data);
 631                 entry = entry->next;
 632         }
 633         g_slist_free(list);
 634 #endif
 635 }
 636
 637 /*
 638   Local Variables:
 639   mode: c
 640   c-file-style: "bsd"
 641   indent-tabs-mode: t
 642   tab-width: 8
 643   End:
 644 */