src/daemon/utils_subst.c

   1 /**
   2  * collectd - src/utils_subst.c
   3  * Copyright (C) 2008       Sebastian Harl
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Sebastian "tokkee" Harl <sh at tokkee.org>
  25  **/
  26
  27 /*
  28  * This module provides functions for string substitution.
  29  */
  30
  31 #include "collectd.h"
  32 #include "common.h"
  33 #include "utils_subst.h"
  34
  35 char *subst (char *buf, size_t buflen, const char *string, size_t off1, size_t off2,
  36                 const char *replacement)
  37 {
  38         char *out = buf;
  39
  40         char const *front;
  41         char const *back;
  42         size_t front_len;
  43         size_t replacement_len;
  44         size_t back_len;
  45
  46         if ((NULL == buf) || (0 == buflen) || (NULL == string) || (NULL == replacement))
  47                 return NULL;
  48
  49         size_t string_len = strlen (string);
  50         if ((off1 > string_len) || (off2 > string_len) || (off1 > off2))
  51                 return NULL;
  52
  53         front = string;
  54         back = string + off2;
  55         front_len = off1;
  56         replacement_len = strlen (replacement);
  57         back_len = strlen (back);
  58
  59         if (front_len >= buflen) {
  60                 front_len = buflen - 1;
  61                 replacement_len = 0;
  62                 back_len = 0;
  63         } else if ((front_len + replacement_len) >= buflen) {
  64                 replacement_len = buflen - (front_len + 1);
  65                 back_len = 0;
  66         } else if ((front_len + replacement_len + back_len) >= buflen) {
  67                 back_len = buflen - (front_len + replacement_len + 1);
  68         } else {
  69                 buflen = front_len + replacement_len + back_len + 1;
  70         }
  71         assert ((front_len + replacement_len + back_len) == (buflen - 1));
  72
  73         if (front_len != 0) {
  74                 sstrncpy (out, front, front_len + 1);
  75                 out += front_len;
  76         }
  77
  78         if (replacement_len != 0) {
  79                 sstrncpy (out, replacement, replacement_len + 1);
  80                 out += replacement_len;
  81         }
  82
  83         if (back_len != 0) {
  84                 sstrncpy (out, back, back_len + 1);
  85                 out += back_len;
  86         }
  87
  88         out[0] = 0;
  89         return buf;
  90 } /* subst */
  91
  92 char *asubst (const char *string, int off1, int off2, const char *replacement)
  93 {
  94         char *buf;
  95         int   len;
  96
  97         char *ret;
  98
  99         if ((NULL == string) || (0 > off1) || (0 > off2) || (off1 > off2)
 100                         || (NULL ==replacement))
 101                 return NULL;
 102
 103         len = off1 + strlen (replacement) + strlen (string) - off2 + 1;
 104
 105         buf = malloc (len);
 106         if (NULL == buf)
 107                 return NULL;
 108
 109         ret = subst (buf, len, string, off1, off2, replacement);
 110         if (NULL == ret)
 111                 free (buf);
 112         return ret;
 113 } /* asubst */
 114
 115 char *subst_string (char *buf, size_t buflen, const char *string,
 116                 const char *needle, const char *replacement)
 117 {
 118         size_t needle_len;
 119         size_t i;
 120
 121         if ((buf == NULL) || (string == NULL)
 122                         || (needle == NULL) || (replacement == NULL))
 123                 return (NULL);
 124
 125         needle_len = strlen (needle);
 126         sstrncpy (buf, string, buflen);
 127
 128         /* Limit the loop to prevent endless loops. */
 129         for (i = 0; i < buflen; i++)
 130         {
 131                 char temp[buflen];
 132                 char *begin_ptr;
 133                 size_t begin;
 134
 135                 /* Find `needle' in `buf'. */
 136                 begin_ptr = strstr (buf, needle);
 137                 if (begin_ptr == NULL)
 138                         break;
 139
 140                 /* Calculate the start offset. */
 141                 begin = begin_ptr - buf;
 142
 143                 /* Substitute the region using `subst'. The result is stored in
 144                  * `temp'. */
 145                 begin_ptr = subst (temp, buflen, buf,
 146                                 begin, begin + needle_len,
 147                                 replacement);
 148                 if (begin_ptr == NULL)
 149                 {
 150                         WARNING ("subst_string: subst failed.");
 151                         break;
 152                 }
 153
 154                 /* Copy the new string in `temp' to `buf' for the next round. */
 155                 strncpy (buf, temp, buflen);
 156         }
 157
 158         if (i >= buflen)
 159         {
 160                 WARNING ("subst_string: Loop exited after %zu iterations: "
 161                                 "string = %s; needle = %s; replacement = %s;",
 162                                 i, string, needle, replacement);
 163         }
 164
 165         return (buf);
 166 } /* char *subst_string */
 167
 168 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */
 169