xref: /illumos-gate/usr/src/lib/fm/topo/libtopo/common/topo_string.c (revision 9c994d5813a279f66e588d5d28541b252e482bae)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 /*
27  * Copyright 2019 Joyent, Inc.
28  * Copyright 2023 Oxide computer Company
29  */
30 
31 #include <strings.h>
32 #include <ctype.h>
33 #include <fm/libtopo.h>
34 #include <fm/topo_mod.h>
35 #include <topo_alloc.h>
36 
37 char *
topo_hdl_strdup(topo_hdl_t * thp,const char * s)38 topo_hdl_strdup(topo_hdl_t *thp, const char *s)
39 {
40 	char *p;
41 
42 	if (s != NULL)
43 		p = topo_hdl_alloc(thp, strlen(s) + 1);
44 	else
45 		p = NULL;
46 
47 	if (p != NULL)
48 		(void) strcpy(p, s);
49 
50 	return (p);
51 }
52 
53 void
topo_hdl_strfree(topo_hdl_t * thp,char * s)54 topo_hdl_strfree(topo_hdl_t *thp, char *s)
55 {
56 	if (s != NULL)
57 		topo_hdl_free(thp, s, strlen(s) + 1);
58 }
59 
60 void
topo_hdl_strfreev(topo_hdl_t * thp,char ** strarr,uint_t nelem)61 topo_hdl_strfreev(topo_hdl_t *thp, char **strarr, uint_t nelem)
62 {
63 	for (uint_t i = 0; i < nelem; i++)
64 		topo_hdl_strfree(thp, strarr[i]);
65 
66 	topo_hdl_free(thp, strarr, (nelem * sizeof (char *)));
67 }
68 
69 char *
topo_mod_strdup(topo_mod_t * mod,const char * s)70 topo_mod_strdup(topo_mod_t *mod, const char *s)
71 {
72 	return (topo_hdl_strdup(mod->tm_hdl, s));
73 }
74 
75 int
topo_hdl_vasprintf(topo_hdl_t * thp,char ** str,const char * fmt,va_list ap)76 topo_hdl_vasprintf(topo_hdl_t *thp, char **str, const char *fmt, va_list ap)
77 {
78 	int len, ret;
79 
80 	*str = NULL;
81 	len = vsnprintf(NULL, 0, fmt, ap);
82 	if (len < 0) {
83 		return (len);
84 	}
85 
86 	if (len == INT_MAX) {
87 		return (-1);
88 	}
89 	len++;
90 
91 	*str = topo_hdl_alloc(thp, len);
92 	if (*str == NULL) {
93 		return (-1);
94 	}
95 
96 	/*
97 	 * If an attempt to format a given string is inconsistent, then that
98 	 * means something is extremely wrong and we're not going to try again
99 	 * and leave that ultimately to the caller to deal with as it suggests
100 	 * they were changing something about the arguments themselves. While
101 	 * asprintf(3C) does loop on this, we are not as forgiving.
102 	 */
103 	ret = vsnprintf(*str, len, fmt, ap);
104 	if (ret < 0 || ret + 1 != len) {
105 		topo_hdl_free(thp, *str, len + 1);
106 		*str = NULL;
107 		return (-1);
108 	}
109 
110 	return (ret);
111 }
112 
113 int
topo_hdl_asprintf(topo_hdl_t * thp,char ** str,const char * fmt,...)114 topo_hdl_asprintf(topo_hdl_t *thp, char **str, const char *fmt, ...)
115 {
116 	int ret;
117 	va_list ap;
118 
119 	va_start(ap, fmt);
120 	ret = topo_hdl_vasprintf(thp, str, fmt, ap);
121 	va_end(ap);
122 	return (ret);
123 }
124 
125 int
topo_mod_vasprintf(topo_mod_t * mod,char ** str,const char * fmt,va_list ap)126 topo_mod_vasprintf(topo_mod_t *mod, char **str, const char *fmt, va_list ap)
127 {
128 	return (topo_hdl_vasprintf(mod->tm_hdl, str, fmt, ap));
129 }
130 
131 int
topo_mod_asprintf(topo_mod_t * mod,char ** str,const char * fmt,...)132 topo_mod_asprintf(topo_mod_t *mod, char **str, const char *fmt, ...)
133 {
134 	int ret;
135 	va_list ap;
136 
137 	va_start(ap, fmt);
138 	ret = topo_hdl_vasprintf(mod->tm_hdl, str, fmt, ap);
139 	va_end(ap);
140 	return (ret);
141 }
142 
143 void
topo_mod_strfree(topo_mod_t * mod,char * s)144 topo_mod_strfree(topo_mod_t *mod, char *s)
145 {
146 	topo_hdl_strfree(mod->tm_hdl, s);
147 }
148 
149 void
topo_mod_strfreev(topo_mod_t * mod,char ** strarr,uint_t nelem)150 topo_mod_strfreev(topo_mod_t *mod, char **strarr, uint_t nelem)
151 {
152 	topo_hdl_strfreev(mod->tm_hdl, strarr, nelem);
153 }
154 
155 const char *
topo_strbasename(const char * s)156 topo_strbasename(const char *s)
157 {
158 	const char *p = strrchr(s, '/');
159 
160 	if (p == NULL)
161 		return (s);
162 
163 	return (++p);
164 }
165 
166 char *
topo_strdirname(char * s)167 topo_strdirname(char *s)
168 {
169 	static char slash[] = "/";
170 	static char dot[] = ".";
171 	char *p;
172 
173 	if (s == NULL || *s == '\0')
174 		return (dot);
175 
176 	for (p = s + strlen(s); p != s && *--p == '/'; )
177 		continue;
178 
179 	if (p == s && *p == '/')
180 		return (slash);
181 
182 	while (p != s) {
183 		if (*--p == '/') {
184 			while (*p == '/' && p != s)
185 				p--;
186 			*++p = '\0';
187 			return (s);
188 		}
189 	}
190 
191 	return (dot);
192 }
193 
194 ulong_t
topo_strhash(const char * key)195 topo_strhash(const char *key)
196 {
197 	ulong_t g, h = 0;
198 	const char *p;
199 
200 	for (p = key; *p != '\0'; p++) {
201 		h = (h << 4) + *p;
202 
203 		if ((g = (h & 0xf0000000)) != 0) {
204 			h ^= (g >> 24);
205 			h ^= g;
206 		}
207 	}
208 
209 	return (h);
210 }
211 
212 /*
213  * Transform string s inline, converting each embedded C escape sequence string
214  * to the corresponding character.  For example, the substring "\n" is replaced
215  * by an inline '\n' character.  The length of the resulting string is returned.
216  */
217 size_t
topo_stresc2chr(char * s)218 topo_stresc2chr(char *s)
219 {
220 	char *p, *q, c;
221 	int esc = 0;
222 	int x;
223 
224 	for (p = q = s; (c = *p) != '\0'; p++) {
225 		if (esc) {
226 			switch (c) {
227 			case '0':
228 			case '1':
229 			case '2':
230 			case '3':
231 			case '4':
232 			case '5':
233 			case '6':
234 			case '7':
235 				c -= '0';
236 				p++;
237 
238 				if (*p >= '0' && *p <= '7') {
239 					c = c * 8 + *p++ - '0';
240 
241 					if (*p >= '0' && *p <= '7')
242 						c = c * 8 + *p - '0';
243 					else
244 						p--;
245 				} else
246 					p--;
247 
248 				*q++ = c;
249 				break;
250 
251 			case 'a':
252 				*q++ = '\a';
253 				break;
254 			case 'b':
255 				*q++ = '\b';
256 				break;
257 			case 'f':
258 				*q++ = '\f';
259 				break;
260 			case 'n':
261 				*q++ = '\n';
262 				break;
263 			case 'r':
264 				*q++ = '\r';
265 				break;
266 			case 't':
267 				*q++ = '\t';
268 				break;
269 			case 'v':
270 				*q++ = '\v';
271 				break;
272 
273 			case 'x':
274 				for (x = 0; (c = *++p) != '\0'; ) {
275 					if (c >= '0' && c <= '9')
276 						x = x * 16 + c - '0';
277 					else if (c >= 'a' && c <= 'f')
278 						x = x * 16 + c - 'a' + 10;
279 					else if (c >= 'A' && c <= 'F')
280 						x = x * 16 + c - 'A' + 10;
281 					else
282 						break;
283 				}
284 				*q++ = (char)x;
285 				p--;
286 				break;
287 
288 			case '"':
289 			case '\\':
290 				*q++ = c;
291 				break;
292 			default:
293 				*q++ = '\\';
294 				*q++ = c;
295 			}
296 
297 			esc = 0;
298 
299 		} else {
300 			if ((esc = c == '\\') == 0)
301 				*q++ = c;
302 		}
303 	}
304 
305 	*q = '\0';
306 	return ((size_t)(q - s));
307 }
308 
309 int
topo_strmatch(const char * s,const char * p)310 topo_strmatch(const char *s, const char *p)
311 {
312 	char c;
313 
314 	if (p == NULL)
315 		return (0);
316 
317 	if (s == NULL)
318 		s = ""; /* treat NULL string as the empty string */
319 
320 	do {
321 		if ((c = *p++) == '\0')
322 			return (*s == '\0');
323 
324 		if (c == '*') {
325 			while (*p == '*')
326 				p++; /* consecutive *'s can be collapsed */
327 
328 			if (*p == '\0')
329 				return (1);
330 
331 			while (*s != '\0') {
332 				if (topo_strmatch(s++, p) != 0)
333 					return (1);
334 			}
335 
336 			return (0);
337 		}
338 	} while (c == *s++);
339 
340 	return (0);
341 }
342