| /* |
| * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc. |
| * |
| * util_is_printable_string contributed by |
| * Pantelis Antoniou <pantelis.antoniou AT gmail.com> |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation; either version 2 of the |
| * License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 |
| * USA |
| */ |
| |
| #include <ctype.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <assert.h> |
| |
| #include "util.h" |
| |
| char *xstrdup(const char *s) |
| { |
| int len = strlen(s) + 1; |
| char *dup = xmalloc(len); |
| |
| memcpy(dup, s, len); |
| |
| return dup; |
| } |
| |
| char *join_path(const char *path, const char *name) |
| { |
| int lenp = strlen(path); |
| int lenn = strlen(name); |
| int len; |
| int needslash = 1; |
| char *str; |
| |
| len = lenp + lenn + 2; |
| if ((lenp > 0) && (path[lenp-1] == '/')) { |
| needslash = 0; |
| len--; |
| } |
| |
| str = xmalloc(len); |
| memcpy(str, path, lenp); |
| if (needslash) { |
| str[lenp] = '/'; |
| lenp++; |
| } |
| memcpy(str+lenp, name, lenn+1); |
| return str; |
| } |
| |
| int util_is_printable_string(const void *data, int len) |
| { |
| const char *s = data; |
| const char *ss; |
| |
| /* zero length is not */ |
| if (len == 0) |
| return 0; |
| |
| /* must terminate with zero */ |
| if (s[len - 1] != '\0') |
| return 0; |
| |
| ss = s; |
| while (*s && isprint(*s)) |
| s++; |
| |
| /* not zero, or not done yet */ |
| if (*s != '\0' || (s + 1 - ss) < len) |
| return 0; |
| |
| return 1; |
| } |
| |
| /* |
| * Parse a octal encoded character starting at index i in string s. The |
| * resulting character will be returned and the index i will be updated to |
| * point at the character directly after the end of the encoding, this may be |
| * the '\0' terminator of the string. |
| */ |
| static char get_oct_char(const char *s, int *i) |
| { |
| char x[4]; |
| char *endx; |
| long val; |
| |
| x[3] = '\0'; |
| strncpy(x, s + *i, 3); |
| |
| val = strtol(x, &endx, 8); |
| |
| assert(endx > x); |
| |
| (*i) += endx - x; |
| return val; |
| } |
| |
| /* |
| * Parse a hexadecimal encoded character starting at index i in string s. The |
| * resulting character will be returned and the index i will be updated to |
| * point at the character directly after the end of the encoding, this may be |
| * the '\0' terminator of the string. |
| */ |
| static char get_hex_char(const char *s, int *i) |
| { |
| char x[3]; |
| char *endx; |
| long val; |
| |
| x[2] = '\0'; |
| strncpy(x, s + *i, 2); |
| |
| val = strtol(x, &endx, 16); |
| if (!(endx > x)) |
| die("\\x used with no following hex digits\n"); |
| |
| (*i) += endx - x; |
| return val; |
| } |
| |
| char get_escape_char(const char *s, int *i) |
| { |
| char c = s[*i]; |
| int j = *i + 1; |
| char val; |
| |
| assert(c); |
| switch (c) { |
| case 'a': |
| val = '\a'; |
| break; |
| case 'b': |
| val = '\b'; |
| break; |
| case 't': |
| val = '\t'; |
| break; |
| case 'n': |
| val = '\n'; |
| break; |
| case 'v': |
| val = '\v'; |
| break; |
| case 'f': |
| val = '\f'; |
| break; |
| case 'r': |
| val = '\r'; |
| break; |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| j--; /* need to re-read the first digit as |
| * part of the octal value */ |
| val = get_oct_char(s, &j); |
| break; |
| case 'x': |
| val = get_hex_char(s, &j); |
| break; |
| default: |
| val = c; |
| } |
| |
| (*i) = j; |
| return val; |
| } |