collectd.h: remove unused defines
[collectd.git] / 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