Annotation of libelwix/src/str.c, revision 1.9.30.1
1.1 misho 1: /*************************************************************************
2: * (C) 2013 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
1.9.30.1! misho 6: * $Id: str.c,v 1.9 2019/01/23 13:26:28 misho Exp $
1.1 misho 7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
1.9 misho 15: Copyright 2004 - 2019
1.1 misho 16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /*
50: * str_FreeNullTerm() - Free dynamic allocated null terminated array with strings
51: *
52: * @arr = Pointer to array for free
53: * return: none
54: */
1.3 misho 55: void
1.1 misho 56: str_FreeNullTerm(char *** __restrict arr)
57: {
58: char **a;
59:
60: if (arr && *arr) {
61: a = *arr;
62: while (a && *a)
63: e_free(*a++);
64: e_free(*arr);
65: *arr = NULL;
66: }
67: }
68:
69: /*
70: * str_ArgsNum() Parse and calculate number of arguments
71: *
72: * @csArgs = Input arguments line
73: * @csDelim = Delimiter(s) for separate
74: * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
75: */
1.3 misho 76: int
1.1 misho 77: str_ArgsNum(const char *csArgs, const char *csDelim)
78: {
79: register int res;
80: char *pos;
81:
82: if (!csArgs || !csDelim)
83: return -1;
84:
85: for (res = 1, pos = (char*) csArgs; (pos = strpbrk(pos, csDelim)); res++, pos++);
86:
87: return res;
88: }
89:
90: /*
91: * str_ExecArgs() - Build exec arguments from other array
92: *
93: * @psProg = Program name for execute
94: * @oldarg = Arguments array
95: * return: NULL error; !=NULL Allocated execution array(must be e_free)
96: */
97: char **
98: str_ExecArgs(const char *psProg, const char **oldarg)
99: {
100: char **newarg, **el;
101: register int i, num;
102:
103: if (!psProg || !oldarg)
104: return NULL;
105: else
106: newarg = el = NULL;
107:
108: /* count items arguments */
109: for (num = 0; oldarg[num]; num++);
110:
111: /* create and copy new arguments */
112: newarg = e_calloc(num + 2, sizeof(char*));
113: if (!newarg)
114: return NULL;
115: else
116: el = newarg;
117:
118: *el = e_strdup(psProg);
119: el++;
120:
121: for (i = 0; oldarg[i]; i++, el++)
122: *el = e_strdup(oldarg[i]);
123: *el = NULL;
124:
125: return newarg;
126: }
127:
128: /*
129: * str_CopyEnv() - Copy environment to new environment array;
130: *
131: * @oldenv = Environment array
132: * return: NULL error; !=NULL Allocated new environment array(must be e_free)
133: */
134: char **
135: str_CopyEnv(const char **oldenv)
136: {
137: char **newenv, **el;
138: register int i, num;
139:
140: if (!oldenv)
141: return NULL;
142: else
143: newenv = el = NULL;
144:
145: /* count items environment */
146: for (i = num = 0; oldenv[i]; i++)
147: if (*strchr(oldenv[i], '='))
148: num++;
149:
150: /* create and copy new environment */
151: newenv = e_calloc(num + 1, sizeof(char*));
152: if (!newenv)
153: return NULL;
154: else
155: el = newenv;
156:
157: for (i = 0; oldenv[i]; i++)
158: if (*strchr(oldenv[i], '=')) {
159: *el = e_strdup(oldenv[i]);
160: el++;
161: }
162: *el = NULL;
163:
164: return newenv;
165: }
166:
167: /*
168: * str_Ast() - Function for evaluate string like asterisk variable "{text[:[-]#[:#]]}"
169: *
170: * @csString = Input string
171: * return: NULL error, !=NULL Allocated new string evaluated from input string,
172: * must be ait_freeVar()
173: */
174: ait_val_t *
175: str_Ast(const char *csString)
176: {
177: char *ext, *str, *eb;
178: int e[2] = { 0, 0 };
179: ait_val_t *out = NULL;
180:
181: if (!csString)
182: return NULL;
183:
184: if (!strchr(csString, '{') || !strrchr(csString, '}')) {
185: elwix_SetErr(EINVAL, "Invalid input string format ... must be like "
186: "{text[:[-]#[:#]]}");
187: return NULL;
188: } else if (!(out = ait_allocVar()))
189: return NULL;
190: else {
191: AIT_INIT_VAL2(out, string);
192:
193: str = e_strdup(strchr(csString, '{') + 1);
194: *strrchr(str, '}') = 0;
195: }
196:
197: if ((ext = strchr(str, ':'))) {
198: *ext++ = 0;
199: e[0] = strtol(ext, &eb, 0);
200: if ((ext = strchr(eb, ':')))
201: e[1] = strtol(++ext, NULL, 0);
202:
203: /* make cut prefix */
204: if (e[0] >= 0)
205: ext = str + MIN(e[0], strlen(str));
206: else
207: ext = str + MAX(strlen(str) + e[0], 0);
208: /* make cut suffix */
209: if (e[1] > 0)
210: *(ext + MIN(e[1], strlen(ext))) = 0;
211: } else
212: /* ok, clear show */
213: ext = str;
214:
215: AIT_SET_STR(out, ext);
216: e_free(str);
217:
218: return out;
219: }
220:
221: /*
222: * str_Hex2Dig() - Convert from Hex string to digit array
223: *
224: * @psLine = Text string
225: * return: NULL nothing to do or error;
226: * !=0 Allocated new converted data (must be ait_freeVar())
227: */
228: ait_val_t *
229: str_Hex2Dig(const char *psLine)
230: {
231: register int i, j;
232: char *str, szWork[3] = { 0, 0, 0 };
1.7 misho 233: ait_val_t *v, s = AIT_VAL_INIT;
1.1 misho 234: u_char *b;
235: int n;
236:
237: if (!psLine || !*psLine)
238: return NULL;
239: else {
240: v = ait_allocVar();
241: if (!v)
242: return NULL;
243:
244: /* normalize input string if not even */
245: n = strlen(psLine);
246: if (n % 2)
247: n++;
248: AIT_SET_STRSIZ(&s, n);
249: for (i = strlen(psLine) - 1, j = n - 1, str = AIT_GET_STR(&s), *str = '0';
250: i > -1; i--, j--)
251: str[j] = psLine[i];
252: }
253:
254: AIT_SET_BUFSIZ(v, 0, n / 2);
255: for (i = 0, b = AIT_GET_BUF(v); i < n && str[i * 2]; i++) {
256: strncpy(szWork, &str[i * 2], 2);
257: b[i] = (u_char) strtol(szWork, NULL, 16);
258: }
259:
260: AIT_FREE_VAL(&s);
261: return v;
262: }
263:
264: /*
265: * str_Dig2Hex() - Convert from digit array to Hex string
266: *
267: * @digz = Digits
268: * return: NULL nothing to do or error;
269: * !=0 Allocated new converted string (must be e_free())
270: */
271: char *
272: str_Dig2Hex(ait_val_t *digz)
273: {
274: register int i;
275: char szWork[3] = { 0, 0, 0 }, *str;
276: u_char *b;
277:
278: if (!digz || AIT_ISEMPTY(digz))
279: return NULL;
280:
281: str = e_malloc(AIT_LEN(digz) * 2 + 1);
282: if (!str)
283: return NULL;
284: else
285: memset(str, 0, AIT_LEN(digz) * 2 + 1);
286:
287: for (i = 0, b = AIT_GET_BUF(digz); i < AIT_LEN(digz); i++) {
1.9 misho 288: snprintf(szWork, sizeof szWork, "%02hhX", b[i]);
1.9.30.1! misho 289: strcat(str, szWork);
1.9 misho 290: }
291:
292: return str;
293: }
294:
295: /*
296: * str_Dig2Hex2() - Convert from digit array to Hex string
297: *
298: * @digz = Digits array
299: * @diglen = Array length
300: * return: NULL nothing to do or error;
301: * !=0 Allocated new converted string (must be e_free())
302: */
303: char *
304: str_Dig2Hex2(u_char * __restrict digz, int diglen)
305: {
306: register int i;
307: char szWork[3] = { 0, 0, 0 }, *str;
308: u_char *b;
309:
310: if (!digz || !diglen)
311: return NULL;
312:
313: str = e_malloc(diglen * 2 + 1);
314: if (!str)
315: return NULL;
316: else
317: memset(str, 0, diglen * 2 + 1);
318:
319: for (i = 0, b = digz; i < diglen; i++) {
1.1 misho 320: snprintf(szWork, sizeof szWork, "%02hhX", b[i]);
1.9.30.1! misho 321: strcat(str, szWork);
1.1 misho 322: }
323:
324: return str;
325: }
326:
327: /*
328: * str_LTrim() - Remove left whitespaces from text string
329: *
330: * @psLine = Text string
331: * return: 0 nothing to do; !=0 Removed bytes
332: */
1.3 misho 333: int
1.1 misho 334: str_LTrim(char * __restrict psLine)
335: {
336: int pos = 0;
337: char *s;
338:
339: if (!psLine || !*psLine)
340: return 0;
341:
342: for (s = psLine; isspace((u_char) *s); s++);
343: pos = s - psLine;
344:
345: memmove(psLine, s, (strlen(psLine) - pos) + 1);
346: return pos;
347: }
348:
349: /*
350: * str_RTrim() - Remove right whitespaces from text string
351: *
352: * @psLine = Text string
353: * return: 0 nothing to do; !=0 Removed bytes
354: */
1.3 misho 355: int
1.1 misho 356: str_RTrim(char * __restrict psLine)
357: {
358: char *t, *pos;
359:
360: if (!psLine || !*psLine)
361: return 0;
362:
363: pos = psLine + strlen(psLine);
364: for (t = pos - 1; t > psLine && isspace((u_char) *t); t--);
365: *++t = 0;
366:
367: return pos - t;
368: }
369:
370: /*
371: * str_Trim() - Remove left and right whitespaces from text string
372: *
373: * @psLine = Text string
374: * return: 0 nothing to do; !=0 Removed bytes
375: */
1.3 misho 376: int
1.1 misho 377: str_Trim(char * __restrict psLine)
378: {
379: int ret = 0;
380:
381: ret = str_LTrim(psLine);
382: ret += str_RTrim(psLine);
383:
384: return ret;
385: }
386:
387: /*
388: * str_Unquot() - Remove quots from input text string
389: *
390: * @psLine = Text string
391: * return: 0 nothing to do; 1 successful unquoted string
392: */
1.3 misho 393: int
1.1 misho 394: str_Unquot(char * __restrict psLine)
395: {
396: char *pos, *str = NULL;
397: int flg;
398:
399: if (!psLine || !*psLine)
400: return 0;
401:
402: if (*psLine == '"' || *psLine == '\'') {
403: str = e_strdup(psLine + 1);
404: for (pos = str, flg = 0; *pos; flg = ('\\' == *pos), pos++) {
405: if (!flg && *pos == *psLine) {
406: *pos = 0;
407: strlcpy(psLine, str, strlen(psLine) + 1);
408: break;
409: }
410: }
411: e_free(str);
412: return 1;
413: }
414:
415: return 0;
416: }
417:
1.2 misho 418: /*
419: * str_Upper() - Convert all lower characters to upper
420: *
421: * @psLine = Text string
422: * return: 0 nothing to do; !=0 converted chars
423: */
1.3 misho 424: int
1.2 misho 425: str_Upper(char * __restrict psLine)
426: {
427: char *s;
428: register int cx = 0;
429:
430: if (!psLine || !*psLine)
431: return 0;
432:
433: for (s = psLine; *s; s++)
434: if (islower(*s)) {
435: *s = toupper(*s);
436: cx++;
437: }
438:
439: return cx;
440: }
441:
442: /*
443: * str_Lower() - Convert all upper characters to lower
444: *
445: * @psLine = Text string
446: * return: 0 nothing to do; !=0 converted chars
447: */
1.3 misho 448: int
1.2 misho 449: str_Lower(char * __restrict psLine)
450: {
451: char *s;
452: register int cx = 0;
453:
454: if (!psLine || !*psLine)
455: return 0;
456:
457: for (s = psLine; *s; s++)
458: if (isupper(*s)) {
459: *s = tolower(*s);
460: cx++;
461: }
462:
463: return cx;
464: }
1.5 misho 465:
466: /*
1.8 misho 467: * str_getString() - Get NULL delimited string from data buffer
1.5 misho 468: *
1.8 misho 469: * @data = Const data buffer
1.5 misho 470: * @dlen = Data length
471: * @next = Return next position after string if !=NULL
472: * return: -1 error or size of string
473: */
474: int
475: str_getString(const u_char * __restrict data, int dlen, char ** __restrict next)
476: {
477: const u_char *pos;
478:
479: if (!data || !dlen)
480: return -1;
481:
482: for (pos = data; pos < data + dlen; pos++)
483: if (!*pos)
484: break;
485: if (*pos) {
486: elwix_SetErr(ENOEXEC, "Not found null-terminated string");
487: return -1;
488: }
489:
490: if (next)
491: *next = (char*) pos + 1;
492: return pos - data + 1;
1.8 misho 493: }
494:
495: /*
496: * str_getString2() - Get string from data buffer with delimiter
497: *
498: * @data = Data buffer
499: * @dlen = Data length
500: * @delim = Data delimiter
501: * @next = Return next position after delimited string if !=NULL
502: * return: -1 error or size of string
503: */
504: int
505: str_getString2(char * __restrict data, int dlen, char delim, char ** __restrict next)
506: {
507: char *pos;
508:
509: if (!data || !dlen)
510: return -1;
511:
512: for (pos = data; pos < data + dlen; pos++)
513: if (!*pos || *pos == (u_char) delim) {
514: *pos = 0;
515: break;
516: }
517: if (*pos) {
518: elwix_SetErr(ENOEXEC, "Not found null-terminated string");
519: return -1;
520: }
521:
522: if (next)
523: *next = (char*) pos + 1;
524: return pos - data;
1.5 misho 525: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to str.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src