~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/dtc/util.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.15 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.73 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.144 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.193 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.193 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright 2011 The Chromium Authors, All Rights Reserved.
  3  * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc.
  4  *
  5  * util_is_printable_string contributed by
  6  *      Pantelis Antoniou <pantelis.antoniou AT gmail.com>
  7  *
  8  * 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 
 24 #include <ctype.h>
 25 #include <stdio.h>
 26 #include <stdlib.h>
 27 #include <stdarg.h>
 28 #include <string.h>
 29 #include <assert.h>
 30 
 31 #include <errno.h>
 32 #include <fcntl.h>
 33 #include <unistd.h>
 34 
 35 #include "libfdt.h"
 36 #include "util.h"
 37 
 38 char *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 
 48 char *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 }
 71 
 72 int 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  */
102 static 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  */
125 static 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 
142 char 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 '':
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 
194 int 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 
238 char *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 
252 int 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 
284 int 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 
295 int 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 }
332 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp