linux/scripts/dtc/util.c
<<
>>
Prefs
   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
  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}
  71
  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}
 332
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.