blob: 2422c34e11dfd381b26d11c1fec39d9369b17d62 [file] [log] [blame]
John Bonesio658f29a2010-11-17 15:28:20 -08001/*
Stephen Warrencd296722012-09-28 21:25:59 +00002 * Copyright 2011 The Chromium Authors, All Rights Reserved.
John Bonesio658f29a2010-11-17 15:28:20 -08003 * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc.
4 *
Stephen Warrencd296722012-09-28 21:25:59 +00005 * util_is_printable_string contributed by
6 * Pantelis Antoniou <pantelis.antoniou AT gmail.com>
7 *
John Bonesio658f29a2010-11-17 15:28:20 -08008 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of the
11 * License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
21 * USA
22 */
23
Stephen Warrencd296722012-09-28 21:25:59 +000024#include <ctype.h>
John Bonesio658f29a2010-11-17 15:28:20 -080025#include <stdio.h>
26#include <stdlib.h>
27#include <stdarg.h>
28#include <string.h>
Stephen Warrencd296722012-09-28 21:25:59 +000029#include <assert.h>
John Bonesio658f29a2010-11-17 15:28:20 -080030
Stephen Warrencd296722012-09-28 21:25:59 +000031#include <errno.h>
32#include <fcntl.h>
33#include <unistd.h>
34
35#include "libfdt.h"
John Bonesio658f29a2010-11-17 15:28:20 -080036#include "util.h"
37
38char *xstrdup(const char *s)
39{
40 int len = strlen(s) + 1;
41 char *dup = xmalloc(len);
42
43 memcpy(dup, s, len);
44
45 return dup;
46}
47
48char *join_path(const char *path, const char *name)
49{
50 int lenp = strlen(path);
51 int lenn = strlen(name);
52 int len;
53 int needslash = 1;
54 char *str;
55
56 len = lenp + lenn + 2;
57 if ((lenp > 0) && (path[lenp-1] == '/')) {
58 needslash = 0;
59 len--;
60 }
61
62 str = xmalloc(len);
63 memcpy(str, path, lenp);
64 if (needslash) {
65 str[lenp] = '/';
66 lenp++;
67 }
68 memcpy(str+lenp, name, lenn+1);
69 return str;
70}
Stephen Warrencd296722012-09-28 21:25:59 +000071
72int util_is_printable_string(const void *data, int len)
73{
74 const char *s = data;
75 const char *ss;
76
77 /* zero length is not */
78 if (len == 0)
79 return 0;
80
81 /* must terminate with zero */
82 if (s[len - 1] != '\0')
83 return 0;
84
85 ss = s;
86 while (*s && isprint(*s))
87 s++;
88
89 /* not zero, or not done yet */
90 if (*s != '\0' || (s + 1 - ss) < len)
91 return 0;
92
93 return 1;
94}
95
96/*
97 * Parse a octal encoded character starting at index i in string s. The
98 * resulting character will be returned and the index i will be updated to
99 * point at the character directly after the end of the encoding, this may be
100 * the '\0' terminator of the string.
101 */
102static char get_oct_char(const char *s, int *i)
103{
104 char x[4];
105 char *endx;
106 long val;
107
108 x[3] = '\0';
109 strncpy(x, s + *i, 3);
110
111 val = strtol(x, &endx, 8);
112
113 assert(endx > x);
114
115 (*i) += endx - x;
116 return val;
117}
118
119/*
120 * Parse a hexadecimal encoded character starting at index i in string s. The
121 * resulting character will be returned and the index i will be updated to
122 * point at the character directly after the end of the encoding, this may be
123 * the '\0' terminator of the string.
124 */
125static char get_hex_char(const char *s, int *i)
126{
127 char x[3];
128 char *endx;
129 long val;
130
131 x[2] = '\0';
132 strncpy(x, s + *i, 2);
133
134 val = strtol(x, &endx, 16);
135 if (!(endx > x))
136 die("\\x used with no following hex digits\n");
137
138 (*i) += endx - x;
139 return val;
140}
141
142char get_escape_char(const char *s, int *i)
143{
144 char c = s[*i];
145 int j = *i + 1;
146 char val;
147
148 assert(c);
149 switch (c) {
150 case 'a':
151 val = '\a';
152 break;
153 case 'b':
154 val = '\b';
155 break;
156 case 't':
157 val = '\t';
158 break;
159 case 'n':
160 val = '\n';
161 break;
162 case 'v':
163 val = '\v';
164 break;
165 case 'f':
166 val = '\f';
167 break;
168 case 'r':
169 val = '\r';
170 break;
171 case '0':
172 case '1':
173 case '2':
174 case '3':
175 case '4':
176 case '5':
177 case '6':
178 case '7':
179 j--; /* need to re-read the first digit as
180 * part of the octal value */
181 val = get_oct_char(s, &j);
182 break;
183 case 'x':
184 val = get_hex_char(s, &j);
185 break;
186 default:
187 val = c;
188 }
189
190 (*i) = j;
191 return val;
192}
193
194int utilfdt_read_err(const char *filename, char **buffp)
195{
196 int fd = 0; /* assume stdin */
197 char *buf = NULL;
198 off_t bufsize = 1024, offset = 0;
199 int ret = 0;
200
201 *buffp = NULL;
202 if (strcmp(filename, "-") != 0) {
203 fd = open(filename, O_RDONLY);
204 if (fd < 0)
205 return errno;
206 }
207
208 /* Loop until we have read everything */
209 buf = malloc(bufsize);
210 do {
211 /* Expand the buffer to hold the next chunk */
212 if (offset == bufsize) {
213 bufsize *= 2;
214 buf = realloc(buf, bufsize);
215 if (!buf) {
216 ret = ENOMEM;
217 break;
218 }
219 }
220
221 ret = read(fd, &buf[offset], bufsize - offset);
222 if (ret < 0) {
223 ret = errno;
224 break;
225 }
226 offset += ret;
227 } while (ret != 0);
228
229 /* Clean up, including closing stdin; return errno on error */
230 close(fd);
231 if (ret)
232 free(buf);
233 else
234 *buffp = buf;
235 return ret;
236}
237
238char *utilfdt_read(const char *filename)
239{
240 char *buff;
241 int ret = utilfdt_read_err(filename, &buff);
242
243 if (ret) {
244 fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
245 strerror(ret));
246 return NULL;
247 }
248 /* Successful read */
249 return buff;
250}
251
252int utilfdt_write_err(const char *filename, const void *blob)
253{
254 int fd = 1; /* assume stdout */
255 int totalsize;
256 int offset;
257 int ret = 0;
258 const char *ptr = blob;
259
260 if (strcmp(filename, "-") != 0) {
261 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
262 if (fd < 0)
263 return errno;
264 }
265
266 totalsize = fdt_totalsize(blob);
267 offset = 0;
268
269 while (offset < totalsize) {
270 ret = write(fd, ptr + offset, totalsize - offset);
271 if (ret < 0) {
272 ret = -errno;
273 break;
274 }
275 offset += ret;
276 }
277 /* Close the file/stdin; return errno on error */
278 if (fd != 1)
279 close(fd);
280 return ret < 0 ? -ret : 0;
281}
282
283
284int utilfdt_write(const char *filename, const void *blob)
285{
286 int ret = utilfdt_write_err(filename, blob);
287
288 if (ret) {
289 fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
290 strerror(ret));
291 }
292 return ret ? -1 : 0;
293}
294
295int utilfdt_decode_type(const char *fmt, int *type, int *size)
296{
297 int qualifier = 0;
298
299 if (!*fmt)
300 return -1;
301
302 /* get the conversion qualifier */
303 *size = -1;
304 if (strchr("hlLb", *fmt)) {
305 qualifier = *fmt++;
306 if (qualifier == *fmt) {
307 switch (*fmt++) {
308/* TODO: case 'l': qualifier = 'L'; break;*/
309 case 'h':
310 qualifier = 'b';
311 break;
312 }
313 }
314 }
315
316 /* we should now have a type */
317 if ((*fmt == '\0') || !strchr("iuxs", *fmt))
318 return -1;
319
320 /* convert qualifier (bhL) to byte size */
321 if (*fmt != 's')
322 *size = qualifier == 'b' ? 1 :
323 qualifier == 'h' ? 2 :
324 qualifier == 'l' ? 4 : -1;
325 *type = *fmt++;
326
327 /* that should be it! */
328 if (*fmt)
329 return -1;
330 return 0;
331}