src/lib/eina_str.c

   1 /* Leave the OpenBSD version below so we can track upstream fixes */
   2 /*      $OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $        */
   3
   4 /*
   5  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <limits.h>
  29 #include <ctype.h>
  30
  31 #ifdef HAVE_ICONV
  32 # include <errno.h>
  33 # include <iconv.h>
  34 #endif
  35
  36 #include "eina_private.h"
  37 #include "eina_str.h"
  38
  39 /*============================================================================*
  40 *                                  Local                                     *
  41 *============================================================================*/
  42
  43 /**
  44  * @cond LOCAL
  45  */
  46
  47 /*
  48  * Internal helper function used by eina_str_has_suffix() and
  49  * eina_str_has_extension()
  50  */
  51 static inline Eina_Bool
  52 eina_str_has_suffix_helper(const char *str,
  53                            const char *suffix,
  54                            int (*cmp)(const char *, const char *))
  55 {
  56    size_t str_len;
  57    size_t suffix_len;
  58
  59    if ((!str) || (!suffix)) return EINA_FALSE;
  60    str_len = strlen(str);
  61    suffix_len = eina_strlen_bounded(suffix, str_len);
  62    if (suffix_len == (size_t)-1)
  63       return EINA_FALSE;
  64
  65    return cmp(str + str_len - suffix_len, suffix) == 0;
  66 }
  67
  68 static inline char **
  69 eina_str_split_full_helper(const char *str,
  70                            const char *delim,
  71                            int max_tokens,
  72                            unsigned int *elements)
  73 {
  74    char *s, *pos, **str_array;
  75    const char *src;
  76    size_t len, dlen;
  77    unsigned int tokens = 0, x;
  78    const char *idx[256] = {NULL};
  79
  80    if (max_tokens < 0) max_tokens = 0;
  81    if (max_tokens == 1)
  82      {
  83         str_array = malloc(sizeof(char *) * 2);
  84         if (!str_array)
  85           {
  86              if (elements)
  87                 *elements = 0;
  88
  89              return NULL;
  90           }
  91
  92         s = strdup(str);
  93         if (!s)
  94           {
  95              free(str_array);
  96              if (elements)
  97                 *elements = 0;
  98
  99              return NULL;
 100           }
 101         if (elements)
 102           *elements = 1;
 103         str_array[0] = s;
 104         return str_array;
 105      }
 106    dlen = strlen(delim);
 107    if (dlen == 0)
 108      {
 109         if (elements)
 110            *elements = 0;
 111
 112         return NULL;
 113      }
 114
 115    src = str;
 116    /* count tokens and check strlen(str) */
 117    while (*src != '\0')
 118      {
 119         const char *d = delim, *d_end = d + dlen;
 120         const char *tmp = src;
 121         for (; (d < d_end) && (*tmp != '\0'); d++, tmp++)
 122           {
 123              if (EINA_LIKELY(*d != *tmp))
 124                 break;
 125           }
 126         if (EINA_UNLIKELY(d == d_end))
 127           {
 128              src = tmp;
 129              if (tokens < (sizeof(idx) / sizeof(idx[0])))
 130                {
 131                   idx[tokens] = tmp;
 132                   //printf("token %d='%s'\n", tokens + 1, idx[tokens]);
 133                }
 134              tokens++;
 135              if (tokens && (tokens == (unsigned int)max_tokens)) break;
 136           }
 137         else
 138            src++;
 139      }
 140    len = src - str + strlen(src);
 141
 142    str_array = malloc(sizeof(char *) * (tokens + 2));
 143    if (!str_array)
 144      {
 145         if (elements)
 146            *elements = 0;
 147
 148         return NULL;
 149      }
 150
 151    if (!tokens)
 152      {
 153         s = strdup(str);
 154         if (!s)
 155           {
 156              free(str_array);
 157              if (elements)
 158                 *elements = 0;
 159
 160              return NULL;
 161           }
 162         str_array[0] = s;
 163         str_array[1] = NULL;
 164         if (elements)
 165           *elements = 1;
 166         return str_array;
 167      }
 168
 169    s = malloc(len + 1);
 170    if (!s)
 171      {
 172         free(str_array);
 173         if (elements)
 174            *elements = 0;
 175
 176         return NULL;
 177      }
 178
 179    str_array[0] = s;
 180
 181    if (len == tokens * dlen)
 182      {
 183         /* someone's having a laugh somewhere */
 184         memset(s, 0, len + 1);
 185         for (x = 1; x < tokens + 1; x++)
 186           str_array[x] = s + x;
 187         str_array[x] = NULL;
 188         if (elements)
 189           *elements = x;
 190         return str_array;
 191      }
 192    /* copy tokens and string */
 193    if (idx[0] - str - dlen > len)
 194      {
 195         /* FIXME: don't think this can happen but putting this here just in case */
 196         abort();
 197      }
 198    pos = s;
 199    for (x = 0; x < MIN(tokens, (sizeof(idx) / sizeof(idx[0]))); x++)
 200      {
 201         if (x + 1 < (sizeof(idx) / sizeof(idx[0])))
 202           {
 203              /* first one is special */
 204              if (!x)
 205                {
 206                   eina_strlcpy(pos, str, idx[x] - str - dlen + 1);
 207                   str_array[x] = pos;
 208                   //printf("str_array[%d] = '%s'\n", x, str_array[x]);
 209                   pos += idx[x] - str - dlen + 1;
 210                   if ((tokens == 1) && (idx[0]))
 211                     {
 212                        eina_strlcpy(pos, idx[x], len + 1 - (pos - s));
 213                        x++, tokens++;
 214                        str_array[x] = pos;
 215                     }
 216                }
 217              /* more tokens */
 218              else if (idx[x + 1])
 219                {
 220                   eina_strlcpy(pos, idx[x - 1], idx[x] - idx[x - 1] - dlen + 1);
 221                   str_array[x] = pos;
 222                   //printf("str_array[%d] = '%s'\n", x, str_array[x]);
 223                   pos += idx[x] - idx[x - 1] - dlen + 1;
 224                }
 225              /* last token */
 226              else
 227                {
 228                   if (max_tokens && ((unsigned int)max_tokens < tokens + 1))
 229                     eina_strlcpy(pos, idx[x - 1], len + 1 - (pos - s));
 230                   else
 231                     {
 232                        //printf("diff: %d\n", len + 1 - (pos - s));
 233                        eina_strlcpy(pos, idx[x - 1], idx[x] - idx[x - 1] - dlen + 1);
 234                        str_array[x] = pos;
 235                        //printf("str_array[%d] = '%s'\n", x, str_array[x]);
 236                        pos += idx[x] - idx[x - 1] - dlen + 1;
 237                        x++, tokens++;
 238                        eina_strlcpy(pos, idx[x - 1], len + 1 - (pos - s));
 239                     }
 240                   str_array[x] = pos;
 241                   //printf("str_array[%d] = '%s'\n", x, str_array[x]);
 242                }
 243           }
 244         /* no more tokens saved after this one */
 245         else
 246           {
 247              eina_strlcpy(pos, idx[x - 1], idx[x] - idx[x - 1] - dlen + 1);
 248              str_array[x] = pos;
 249              //printf("str_array[%d] = '%s'\n", x, str_array[x]);
 250              pos += idx[x] - idx[x - 1] - dlen + 1;
 251              src = idx[x];
 252              x++, tokens++;
 253              str_array[x] = s = pos;
 254              break;
 255           }
 256      }
 257    if ((x != tokens) && ((!max_tokens) || (x < tokens)))
 258      {
 259         while (*src != '\0')
 260           {
 261              const char *d = delim, *d_end = d + dlen;
 262              const char *tmp = src;
 263              for (; (d < d_end) && (*tmp != '\0'); d++, tmp++)
 264                {
 265                   if (EINA_LIKELY(*d != *tmp))
 266                      break;
 267                }
 268              if (((!max_tokens) || (((tokens == (unsigned int)max_tokens) || x < tokens - 2))) && (EINA_UNLIKELY(d == d_end)))
 269                {
 270                   src = tmp;
 271                   *s = '\0';
 272                   s++, x++;
 273                   //printf("str_array[%d] = '%s'\n", x, str_array[x - 1]);
 274                   str_array[x] = s;
 275                }
 276              else
 277                {
 278                   *s = *src;
 279                   s++, src++;
 280                }
 281           }
 282         *s = 0;
 283      }
 284    str_array[tokens] = NULL;
 285    if (elements)
 286      *elements = tokens;
 287
 288    return str_array;
 289 }
 290
 291 /**
 292  * @endcond
 293  */
 294
 295 /*============================================================================*
 296 *                                 Global                                     *
 297 *============================================================================*/
 298
 299 /*============================================================================*
 300 *                                   API                                      *
 301 *============================================================================*/
 302
 303 EAPI size_t
 304 eina_strlcpy(char *dst, const char *src, size_t siz)
 305 {
 306 #ifdef HAVE_STRLCPY
 307    return strlcpy(dst, src, siz);
 308 #else
 309    char *d = dst;
 310    const char *s = src;
 311    size_t n = siz;
 312
 313    /* Copy as many bytes as will fit */
 314    if (n != 0)
 315       while (--n != 0)
 316         {
 317            if ((*d++ = *s++) == '\0')
 318               break;
 319         }
 320
 321    /* Not enough room in dst, add NUL and traverse rest of src */
 322    if (n == 0)
 323      {
 324         if (siz != 0)
 325            *d = '\0';  /* NUL-terminate dst */
 326
 327         while (*s++)
 328            ;
 329      }
 330
 331    return(s - src - 1); /* count does not include NUL */
 332 #endif
 333 }
 334
 335 EAPI size_t
 336 eina_strlcat(char *dst, const char *src, size_t siz)
 337 {
 338    char *d = dst;
 339    const char *s = src;
 340    size_t n = siz;
 341    size_t dlen;
 342
 343    /* Find the end of dst and adjust bytes left but don't go past end */
 344    while (n-- != 0 && *d != '\0')
 345       d++;
 346    dlen = d - dst;
 347    n = siz - dlen;
 348
 349    if (n == 0)
 350       return(dlen + strlen(s));
 351
 352    while (*s != '\0') {
 353         if (n != 1)
 354           {
 355              *d++ = *s;
 356              n--;
 357           }
 358
 359         s++;
 360      }
 361    *d = '\0';
 362
 363    return(dlen + (s - src)); /* count does not include NUL */
 364 }
 365
 366 EAPI Eina_Bool
 367 eina_str_has_prefix(const char *str, const char *prefix)
 368 {
 369    size_t str_len;
 370    size_t prefix_len;
 371
 372    str_len = strlen(str);
 373    prefix_len = eina_strlen_bounded(prefix, str_len);
 374    if (prefix_len == (size_t)-1)
 375       return EINA_FALSE;
 376
 377    return (strncmp(str, prefix, prefix_len) == 0);
 378 }
 379
 380 EAPI Eina_Bool
 381 eina_str_has_suffix(const char *str, const char *suffix)
 382 {
 383    return eina_str_has_suffix_helper(str, suffix, strcmp);
 384 }
 385
 386 EAPI Eina_Bool
 387 eina_str_has_extension(const char *str, const char *ext)
 388 {
 389    return eina_str_has_suffix_helper(str, ext, strcasecmp);
 390 }
 391
 392 EAPI char **
 393 eina_str_split_full(const char *str,
 394                     const char *delim,
 395                     int max_tokens,
 396                     unsigned int *elements)
 397 {
 398    return eina_str_split_full_helper(str, delim, max_tokens, elements);
 399 }
 400
 401
 402 EAPI char **
 403 eina_str_split(const char *str, const char *delim, int max_tokens)
 404 {
 405    return eina_str_split_full_helper(str, delim, max_tokens, NULL);
 406 }
 407
 408 EAPI size_t
 409 eina_str_join_len(char *dst,
 410                   size_t size,
 411                   char sep,
 412                   const char *a,
 413                   size_t a_len,
 414                   const char *b,
 415                   size_t b_len)
 416 {
 417    size_t ret = a_len + b_len + 1;
 418    size_t off;
 419
 420    if (size < 1)
 421       return ret;
 422
 423    if (size <= a_len)
 424      {
 425         memcpy(dst, a, size - 1);
 426         dst[size - 1] = '\0';
 427         return ret;
 428      }
 429
 430         memcpy(dst, a, a_len);
 431    off = a_len;
 432
 433    if (size <= off + 1)
 434      {
 435         dst[size - 1] = '\0';
 436         return ret;
 437      }
 438
 439    dst[off] = sep;
 440    off++;
 441
 442    if (size <= off + b_len + 1)
 443      {
 444         memcpy(dst + off, b, size - off - 1);
 445         dst[size - 1] = '\0';
 446         return ret;
 447      }
 448
 449         memcpy(dst + off, b, b_len);
 450    dst[off + b_len] = '\0';
 451    return ret;
 452 }
 453
 454 #ifdef HAVE_ICONV
 455 EAPI char *
 456 eina_str_convert(const char *enc_from, const char *enc_to, const char *text)
 457 {
 458    iconv_t ic;
 459    char *new_txt, *inp, *outp;
 460    size_t inb, outb, outlen, tob, outalloc;
 461
 462    if (!text)
 463       return NULL;
 464
 465    ic = iconv_open(enc_to, enc_from);
 466    if (ic == (iconv_t)(-1))
 467       return NULL;
 468
 469    new_txt = malloc(64);
 470    inb = strlen(text);
 471    outb = 64;
 472    inp = (char *)text;
 473    outp = new_txt;
 474    outalloc = 64;
 475    outlen = 0;
 476
 477    for (;; )
 478      {
 479         size_t count;
 480
 481         tob = outb;
 482         count = iconv(ic, &inp, &inb, &outp, &outb);
 483         outlen += tob - outb;
 484         if (count == (size_t)(-1))
 485           {
 486              if (errno == E2BIG)
 487                {
 488                   new_txt = realloc(new_txt, outalloc + 64);
 489                   outp = new_txt + outlen;
 490                   outalloc += 64;
 491                   outb += 64;
 492                }
 493              else if (errno == EILSEQ)
 494                {
 495                   if (new_txt)
 496                      free(new_txt);
 497
 498                   new_txt = NULL;
 499                   break;
 500                }
 501              else if (errno == EINVAL)
 502                {
 503                   if (new_txt)
 504                      free(new_txt);
 505
 506                   new_txt = NULL;
 507                   break;
 508                }
 509              else
 510                {
 511                   if (new_txt)
 512                      free(new_txt);
 513
 514                   new_txt = NULL;
 515                   break;
 516                }
 517           }
 518
 519         if (inb == 0)
 520           {
 521              if (outalloc == outlen)
 522                 new_txt = realloc(new_txt, outalloc + 1);
 523
 524              new_txt[outlen] = 0;
 525              break;
 526           }
 527      }
 528    iconv_close(ic);
 529    return new_txt;
 530 }
 531 #else
 532 EAPI char *
 533 eina_str_convert(const char *enc_from __UNUSED__,
 534                  const char *enc_to __UNUSED__,
 535                  const char *text __UNUSED__)
 536 {
 537    return NULL;
 538 }
 539 #endif
 540
 541 EAPI char *
 542 eina_str_escape(const char *str)
 543 {
 544    char *s2, *d;
 545    const char *s;
 546
 547    s2 = malloc((strlen(str) * 2) + 1);
 548    if (!s2)
 549       return NULL;
 550
 551    for (s = str, d = s2; *s != 0; s++, d++)
 552      {
 553         if ((*s == ' ') || (*s == '\\') || (*s == '\''))
 554           {
 555              *d = '\\';
 556              d++;
 557           }
 558
 559         *d = *s;
 560      }
 561    *d = 0;
 562    return s2;
 563 }
 564
 565 EAPI void
 566 eina_str_tolower(char **str)
 567 {
 568    char *p;
 569    if ((!str) || (!(*str)))
 570       return;
 571
 572    for (p = *str; (*p); p++)
 573       *p = tolower((unsigned char )(*p));
 574 }
 575
 576 EAPI void
 577 eina_str_toupper(char **str)
 578 {
 579    char *p;
 580    if ((!str) || (!(*str)))
 581       return;
 582
 583    for (p = *str; (*p); p++)
 584       *p = toupper((unsigned char)(*p));
 585 }