/*  Simple program for dumping DMI/SMBIOS data
 *  Based on code from python-dmidecode/dmidecode.c
 *
 *   Copyright 2009      David Sommerseth <davids@redhat.com>
 *   Copyright 2002-2008 Jean Delvare <khali@linux-fr.org>
 *   Copyright 2000-2002 Alan Cox <alan@redhat.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
 *
 *   For the avoidance of doubt the "preferred form" of this code is one which
 *   is in an open unpatent encumbered format. Where cryptographic key signing
 *   forms part of the process of creating an executable the information
 *   including keys needed to generate an equivalently functional executable
 *   are deemed to be part of the source code.
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "types.h"
#include "util.h"

#include "dmidump.h"
#include "efi.h"

/*
 * Build a crafted entry point with table address hard-coded to 32,
 * as this is where we will put it in the output file. We adjust the
 * DMI checksum appropriately. The SMBIOS checksum needs no adjustment.
 */
static void overwrite_dmi_address(u8 * buf)
{
        buf[0x05] += buf[0x08] + buf[0x09] + buf[0x0A] + buf[0x0B] - 32;
        buf[0x08] = 32;
        buf[0x09] = 0;
        buf[0x0A] = 0;
        buf[0x0B] = 0;
}

/* Same thing for SMBIOS3 entry points */
static void overwrite_smbios3_address(u8 *buf)
{
        buf[0x05] += buf[0x10] + buf[0x11] + buf[0x12] + buf[0x13]
                        + buf[0x14] + buf[0x15] + buf[0x16] + buf[0x17] - 32;
        buf[0x10] = 32;
        buf[0x11] = 0;
        buf[0x12] = 0;
        buf[0x13] = 0;
        buf[0x14] = 0;
        buf[0x15] = 0;
        buf[0x16] = 0;
        buf[0x17] = 0;
}

void dmi_table_dump(const u8 *buf, u32 len, const char *dumpfile)
{
        write_dump(32, len, buf, dumpfile, 0);
}

void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
                      u32 flags, const char *dumpfile)
{
        u8 *buf;
        size_t size = len;

        buf = read_file(NULL, flags & FLAG_NO_FILE_OFFSET ? 0 : base,
                        &size, devmem);
        len = size;

        if (buf == NULL)
        {
                printf("read failed\n");
        }
        dmi_table_dump(buf, len, dumpfile);
        free(buf);
}

static int smbios3_decode(u8 *buf, const char *devmem, u32 flags, const char *dumpfile)
{
        u32 ver;
        u64 offset;
        offset = QWORD(buf + 0x10);
        ver = (buf[0x07] << 16) + (buf[0x08] << 8) + buf[0x09];

        if (!checksum(buf, buf[0x06]))
                return 0;

        dmi_table(((off_t)offset.h << 32) | offset.l,DWORD(buf + 0x0C), 0, ver, devmem, flags | FLAG_STOP_AT_EOT, dumpfile);

        u8 crafted[32];
        memcpy(crafted, buf, 32);
        overwrite_smbios3_address(crafted);
        //overwrite_dmi_address(crafted);
        //printf("Writing %d bytes to %s.",crafted[0x06], dumpfile);
        write_dump(0, crafted[0x06], crafted, dumpfile, 1);
        return 1;
}

static int smbios_decode(u8 *buf, const char *devmem, u32 flags, const char *dumpfile)
{
        u16 ver;
        if (!checksum(buf, buf[0x05])
         || memcmp(buf + 0x10, "_DMI_", 5) != 0
         || !checksum(buf + 0x10, 0x0F))
                return 0;

        ver = (buf[0x06] << 8) + buf[0x07];
        switch (ver)
        {
                case 0x021F:
                case 0x0221:
                        ver = 0x0203;
                        break;
                case 0x0233:
                        ver = 0x0206;
                        break;
        }


        dmi_table(DWORD(buf + 0x18), WORD(buf + 0x16), WORD(buf + 0x1C),
                ver << 8, devmem, flags, dumpfile);

        u8 crafted[32];
        memcpy(crafted, buf, 32);
        overwrite_dmi_address(crafted + 0x10);
        write_dump(0, crafted[0x05], crafted, dumpfile, 1);

        return 1;
}

static int legacy_decode(u8 *buf, const char *devmem, u32 flags,  const char *dumpfile)
{
        u8 crafted[16];

        //dmi_table();
        dmi_table(DWORD(buf + 0x08), WORD(buf + 0x06), WORD(buf + 0x0C),
                ((buf[0x0E] & 0xF0) << 12) + ((buf[0x0E] & 0x0F) << 8),
                devmem, flags, dumpfile);

        memcpy(crafted, buf, 16);
        overwrite_smbios3_address(crafted);
        write_dump(0, 0x0F, crafted, dumpfile, 1);

        return 1;
}

int dump(const char *memdev, const char *dumpfile)
{
        /* On success, return found, otherwise return 0 */
        int ret = 0;
        int found = 0;
        size_t fp;
        int efi;
        u8 *buf;
        size_t size;

        /*
         * First try reading from sysfs tables.  The entry point file could
         * contain one of several types of entry points, so read enough for
         * the largest one, then determine what type it contains.
         */
        size = 0x20;
        if ( (buf = read_file(NULL, 0, &size, SYS_ENTRY_FILE)) != NULL){
                if (size >= 24 && memcmp(buf, "_SM3_", 5) == 0){
                        if (smbios3_decode(buf, SYS_TABLE_FILE, FLAG_NO_FILE_OFFSET, dumpfile))
                                found++;
                } else if (size >= 31 && memcmp(buf, "_SM_", 4) == 0) {
                        if (smbios_decode(buf, SYS_TABLE_FILE, FLAG_NO_FILE_OFFSET, dumpfile))
                                found++;
                } else if (size >= 15 && memcmp(buf, "_DMI_", 5) == 0){
                        if (legacy_decode(buf, SYS_TABLE_FILE, FLAG_NO_FILE_OFFSET, dumpfile))
                                found++;
                }
                if (found){
                        ret = 1;
                        goto exit_free;
                }
        }

        /* First try EFI (ia64, Intel-based Mac) */
        efi = address_from_efi(NULL, &fp);
        switch(efi)
        {
                case EFI_NOT_FOUND:
                        goto memory_scan;
                case EFI_NO_SMBIOS:
                        ret = 1;
                        goto exit_free;
        }

        if ((buf = mem_chunk(NULL, fp, 0x20, memdev )) == NULL){
                ret = 1;
                goto exit_free;
        }

        if (memcmp(buf, "_SM3_", 5) == 0){
                if(smbios3_decode(buf, memdev, 0, dumpfile))
                        found++;
        } else if (memcmp(buf, "_SM_", 4) == 0){
                if(smbios_decode(buf, memdev, 0, dumpfile))
                        found++;
        }
        goto done;

memory_scan:
#if defined __i386__ || defined __x86_64__
        /* Fallback to memory scan (x86, x86_64) */
        if((buf = mem_chunk(NULL, 0xF0000, 0x10000, memdev)) == NULL) {
                ret = 1;
                goto exit_free;
        }

        /* Look for a 64-bit entry point first */
        for(fp = 0; fp <= 0xFFF0; fp += 16){
                if(memcmp(buf + fp, "_SM3_", 5) == 0 && fp <= 0xFFE0){
                        if(smbios3_decode(buf + fp, memdev, 0, dumpfile)){
                                found++;
                                goto done;
                        }
                }
        }

        /* If none found, look for a 32-bit entry point */
        for(fp = 0; fp <= 0xFFF0; fp += 16) {
                if(memcmp(buf + fp, "_SM_", 4) == 0 && fp <= 0xFFE0) {
                        if(smbios_decode(buf + fp, memdev, 0, dumpfile)){
                                found++;
                                goto done;
                        }
                } else if (memcmp(buf+fp, "_DMI_", 5) == 0){
                        if(legacy_decode(buf+fp, memdev, 0, dumpfile)){
                                found++;
                                goto done;
                        }
                }
        }
#endif

done:
        if(!found){
                printf("No SMBIOS nor DMI entry point found, sorry.\n");
        }
        free(buf);

exit_free:
        if (!found)
                free(buf);

        return ret;
}


#ifdef _DMIDUMP_MAIN_
int main(int argc, char **argv)
{
        if( argc != 3 ) {
                fprintf(stderr, "Usage:   %s </dev/mem device> <destfile>\n", argv[0]);
                return 1;
        }
        dump(argv[1], argv[2]);

        return 0;
}
#endif