/*
 * Copyright 2011 The Chromium Authors, All Rights Reserved.
 * 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 <errno.h>
#include <fcntl.h>
#include <unistd.h>

#include "libfdt.h"
#include "util.h"
#include "version_gen.h"

char *xstrdup(const char *s)
{
        int len = strlen(s) + 1;
        char *d = xmalloc(len);

        memcpy(d, s, len);

        return d;
}

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;
}

bool util_is_printable_string(const void *data, int len)
{
        const char *s = data;
        const char *ss, *se;

        /* zero length is not */
        if (len == 0)
                return 0;

        /* must terminate with zero */
        if (s[len - 1] != '\0')
                return 0;

        se = s + len;

        while (s < se) {
                ss = s;
                while (s < se && *s && isprint((unsigned char)*s))
                        s++;

                /* not zero, or not done yet */
                if (*s != '\0' || s == ss)
                        return 0;

                s++;
        }

        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;

        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;
}

int utilfdt_read_err_len(const char *filename, char **buffp, off_t *len)
{
        int fd = 0;     /* assume stdin */
        char *buf = NULL;
        off_t bufsize = 1024, offset = 0;
        int ret = 0;

        *buffp = NULL;
        if (strcmp(filename, "-") != 0) {
                fd = open(filename, O_RDONLY);
                if (fd < 0)
                        return errno;
        }

        /* Loop until we have read everything */
        buf = xmalloc(bufsize);
        do {
                /* Expand the buffer to hold the next chunk */
                if (offset == bufsize) {
                        bufsize *= 2;
                        buf = xrealloc(buf, bufsize);
                }

                ret = read(fd, &buf[offset], bufsize - offset);
                if (ret < 0) {
                        ret = errno;
                        break;
                }
                offset += ret;
        } while (ret != 0);

        /* Clean up, including closing stdin; return errno on error */
        close(fd);
        if (ret)
                free(buf);
        else
                *buffp = buf;
        *len = bufsize;
        return ret;
}

int utilfdt_read_err(const char *filename, char **buffp)
{
        off_t len;
        return utilfdt_read_err_len(filename, buffp, &len);
}

char *utilfdt_read_len(const char *filename, off_t *len)
{
        char *buff;
        int ret = utilfdt_read_err_len(filename, &buff, len);

        if (ret) {
                fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
                        strerror(ret));
                return NULL;
        }
        /* Successful read */
        return buff;
}

char *utilfdt_read(const char *filename)
{
        off_t len;
        return utilfdt_read_len(filename, &len);
}

int utilfdt_write_err(const char *filename, const void *blob)
{
        int fd = 1;     /* assume stdout */
        int totalsize;
        int offset;
        int ret = 0;
        const char *ptr = blob;

        if (strcmp(filename, "-") != 0) {
                fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
                if (fd < 0)
                        return errno;
        }

        totalsize = fdt_totalsize(blob);
        offset = 0;

        while (offset < totalsize) {
                ret = write(fd, ptr + offset, totalsize - offset);
                if (ret < 0) {
                        ret = -errno;
                        break;
                }
                offset += ret;
        }
        /* Close the file/stdin; return errno on error */
        if (fd != 1)
                close(fd);
        return ret < 0 ? -ret : 0;
}


int utilfdt_write(const char *filename, const void *blob)
{
        int ret = utilfdt_write_err(filename, blob);

        if (ret) {
                fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
                        strerror(ret));
        }
        return ret ? -1 : 0;
}

int utilfdt_decode_type(const char *fmt, int *type, int *size)
{
        int qualifier = 0;

        if (!*fmt)
                return -1;

        /* get the conversion qualifier */
        *size = -1;
        if (strchr("hlLb", *fmt)) {
                qualifier = *fmt++;
                if (qualifier == *fmt) {
                        switch (*fmt++) {
/* TODO:                case 'l': qualifier = 'L'; break;*/
                        case 'h':
                                qualifier = 'b';
                                break;
                        }
                }
        }

        /* we should now have a type */
        if ((*fmt == '\0') || !strchr("iuxs", *fmt))
                return -1;

        /* convert qualifier (bhL) to byte size */
        if (*fmt != 's')
                *size = qualifier == 'b' ? 1 :
                                qualifier == 'h' ? 2 :
                                qualifier == 'l' ? 4 : -1;
        *type = *fmt++;

        /* that should be it! */
        if (*fmt)
                return -1;
        return 0;
}

void utilfdt_print_data(const char *data, int len)
{
        int i;
        const char *s;

        /* no data, don't print */
        if (len == 0)
                return;

        if (util_is_printable_string(data, len)) {
                printf(" = ");

                s = data;
                do {
                        printf("\"%s\"", s);
                        s += strlen(s) + 1;
                        if (s < data + len)
                                printf(", ");
                } while (s < data + len);

        } else if ((len % 4) == 0) {
                const uint32_t *cell = (const uint32_t *)data;

                printf(" = <");
                for (i = 0, len /= 4; i < len; i++)
                        printf("0x%08x%s", fdt32_to_cpu(cell[i]),
                               i < (len - 1) ? " " : "");
                printf(">");
        } else {
                const unsigned char *p = (const unsigned char *)data;
                printf(" = [");
                for (i = 0; i < len; i++)
                        printf("%02x%s", *p++, i < len - 1 ? " " : "");
                printf("]");
        }
}

void util_version(void)
{
        printf("Version: %s\n", DTC_VERSION);
        exit(0);
}

void util_usage(const char *errmsg, const char *synopsis,
                const char *short_opts, struct option const long_opts[],
                const char * const opts_help[])
{
        FILE *fp = errmsg ? stderr : stdout;
        const char a_arg[] = "<arg>";
        size_t a_arg_len = strlen(a_arg) + 1;
        size_t i;
        int optlen;

        fprintf(fp,
                "Usage: %s\n"
                "\n"
                "Options: -[%s]\n", synopsis, short_opts);

        /* prescan the --long opt length to auto-align */
        optlen = 0;
        for (i = 0; long_opts[i].name; ++i) {
                /* +1 is for space between --opt and help text */
                int l = strlen(long_opts[i].name) + 1;
                if (long_opts[i].has_arg == a_argument)
                        l += a_arg_len;
                if (optlen < l)
                        optlen = l;
        }

        for (i = 0; long_opts[i].name; ++i) {
                /* helps when adding new applets or options */
                assert(opts_help[i] != NULL);

                /* first output the short flag if it has one */
                if (long_opts[i].val > '~')
                        fprintf(fp, "      ");
                else
                        fprintf(fp, "  -%c, ", long_opts[i].val);

                /* then the long flag */
                if (long_opts[i].has_arg == no_argument)
                        fprintf(fp, "--%-*s", optlen, long_opts[i].name);
                else
                        fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
                                (int)(optlen - strlen(long_opts[i].name) - a_arg_len), "");

                /* finally the help text */
                fprintf(fp, "%s\n", opts_help[i]);
        }

        if (errmsg) {
                fprintf(fp, "\nError: %s\n", errmsg);
                exit(EXIT_FAILURE);
        } else
                exit(EXIT_SUCCESS);
}