io_srec.c File Reference

#include <rz_io.h>
#include <rz_lib.h>
#include <rz_util.h>

Go to the source code of this file.

Classes
struct	srec_t

Macros
#define	SREC_SIZE   64
#define	NMAX   100
#define	SREC_PATH_PREFIX   "srec://"

Typedefs
typedef struct srec_t	SRecord

Functions
static void	write_S3_record (FILE *fd, ut32 address, const ut8 *buffer, ut16 size)
static st32	__write (RzIO *io, RzIODesc *fd, const ut8 *buf, st32 count)
static st32	__read (RzIO *io, RzIODesc *fd, ut8 *buf, st32 count)
static st32	__close (RzIODesc *fd)
static ut64	__lseek (struct rz_io_t *io, RzIODesc *fd, ut64 offset, st32 whence)
static bool	__plugin_open (RzIO *io, const char *pathname, bool many)
static bool	srecord_parse (RzBuffer *buf, char *str)
static RzIODesc *	__open (RzIO *io, const char *pathname, st32 rw, st32 mode)
static bool	__resize (RzIO *io, RzIODesc *fd, ut64 size)

Variables
RzIOPlugin	rz_io_plugin_srec
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

NMAX

#define NMAX   100

Definition at line 20 of file io_srec.c.

SREC_PATH_PREFIX

#define SREC_PATH_PREFIX   "srec://"

Definition at line 21 of file io_srec.c.

SREC_SIZE

#define SREC_SIZE   64

Definition at line 19 of file io_srec.c.

Typedef Documentation

SRecord

typedef struct srec_t SRecord

Function Documentation

__close()

static st32 __close ( RzIODesc *  fd )

static

Definition at line 116 of file io_srec.c.

                                  {
    rz_return_val_if_fail(fd && fd->data, -1);
 
    SRecord *srec = (SRecord *)fd->data;
    rz_buf_free(srec->buf);
    free(srec);
    fd->data = NULL;
    return 0;
}

References srec_t::buf, fd, free(), NULL, rz_buf_free(), and rz_return_val_if_fail.

__lseek()

static ut64 __lseek ( struct rz_io_t *  io, RzIODesc *  fd, ut64  offset, st32  whence  )

static

Definition at line 126 of file io_srec.c.

                                                                                {
    rz_return_val_if_fail(fd && fd->data, 0);
    SRecord *srec = (SRecord *)fd->data;
    io->off = rz_buf_seek(srec->buf, offset, whence);
    return io->off;
}

References srec_t::buf, fd, rz_io_t::off, rz_buf_seek(), and rz_return_val_if_fail.

__open()

static RzIODesc* __open ( RzIO *  io, const char *  pathname, st32  rw, st32  mode  )

static

Definition at line 505 of file io_srec.c.

                                                                            {
    rz_return_val_if_fail(io && pathname, NULL);
 
    SRecord *mal = NULL;
    char *str = NULL;
    if (__plugin_open(io, pathname, 0)) {
        str = rz_file_slurp(pathname + 7, NULL);
        if (!str) {
            return NULL;
        }
        mal = RZ_NEW0(SRecord);
        if (!mal) {
            free(str);
            return NULL;
        }
        mal->buf = rz_buf_new_sparse(io->Oxff);
        if (!mal->buf) {
            free(str);
            free(mal);
            return NULL;
        }
        if (!srecord_parse(mal->buf, str)) {
            RZ_LOG_ERROR("srec: failed to parse file\n");
            free(str);
            rz_buf_free(mal->buf);
            free(mal);
            return NULL;
        }
        free(str);
        return rz_io_desc_new(io, &rz_io_plugin_srec, pathname, rw, mode, mal);
    }
    return NULL;
}

References __plugin_open(), free(), mal, NULL, rz_io_t::Oxff, pathname, rz_buf_free(), rz_buf_new_sparse(), rz_file_slurp(), rz_io_desc_new(), rz_io_plugin_srec, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, srecord_parse(), and cmd_descs_generate::str.

__plugin_open()

static bool __plugin_open ( RzIO *  io, const char *  pathname, bool  many  )

static

Definition at line 133 of file io_srec.c.

                                                                     {
    return (!strncmp(pathname, SREC_PATH_PREFIX, strlen(SREC_PATH_PREFIX)));
}

References pathname, and SREC_PATH_PREFIX.

Referenced by __open().

__read()

static st32 __read ( RzIO *  io, RzIODesc *  fd, ut8 *  buf, st32  count  )

static

Definition at line 102 of file io_srec.c.

                                                                 {
    rz_return_val_if_fail(io && fd && fd->data && buf && count > 0, -1);
 
    SRecord *srec = (SRecord *)fd->data;
    memset(buf, io->Oxff, count);
    st32 r = rz_buf_read_at(srec->buf, io->off, buf, count);
    if (r >= 0) {
        rz_buf_seek(srec->buf, r, RZ_BUF_CUR);
    }
    // sparse read return >= 0 but < count still means everything was read successfully,
    // just maybe not entirely populated by chunks:
    return r < 0 ? -1 : count;
}

References srec_t::buf, count, fd, memset(), rz_io_t::off, rz_io_t::Oxff, r, RZ_BUF_CUR, rz_buf_read_at(), rz_buf_seek(), rz_return_val_if_fail, and st32.

__resize()

static bool __resize ( RzIO *  io, RzIODesc *  fd, ut64  size  )

static

Definition at line 539 of file io_srec.c.

                                                        {
    rz_return_val_if_fail(fd && fd->data, false);
 
    SRecord *srec = (SRecord *)fd->data;
    if (srec) {
        return rz_buf_resize(srec->buf, size);
    }
    return false;
}

References srec_t::buf, fd, if(), rz_buf_resize(), and rz_return_val_if_fail.

__write()

static st32 __write ( RzIO *  io, RzIODesc *  fd, const ut8 *  buf, st32  count  )

static

Definition at line 48 of file io_srec.c.

                                                                        {
    rz_return_val_if_fail(fd && fd->data && fd->perm & RZ_PERM_W && count > 0, -1);
 
    const char *pathname = NULL;
    FILE *out = NULL;
    SRecord *srec = NULL;
    ut32 address = 0, size = 0;
    ut8 n_bytes = 0;
    size_t chunks_count = 0;
    const RzBufferSparseChunk *chunks = NULL;
    const RzBufferSparseChunk *sparse = NULL;
 
    srec = (SRecord *)fd->data;
    pathname = fd->name + strlen(SREC_PATH_PREFIX);
    out = rz_sys_fopen(pathname, "w");
 
    if (!out) {
        RZ_LOG_ERROR("srec:write(): cannot open '%s' for writing\n", pathname);
        return -1;
    }
 
    // starting record, contains "rizin-srec\0"
    fprintf(out, "S00E000072697A696E2D7372656300EB\n");
 
    /* mem write */
    if (rz_buf_write_at(srec->buf, io->off, buf, count) != count) {
        RZ_LOG_ERROR("srec:write(): cannot write into buffer\n");
        fclose(out);
        return -1;
    }
 
    rz_buf_seek(srec->buf, count, RZ_BUF_CUR);
    chunks = rz_buf_sparse_get_chunks(srec->buf, &chunks_count);
 
    for (size_t i = 0; i < chunks_count; i++) {
        sparse = &chunks[i];
        size = sparse->to - sparse->from;
        for (ut32 offset = 0; offset < size; offset += SREC_SIZE) {
            address = sparse->from + offset;
            n_bytes = SREC_SIZE;
            if (offset + SREC_SIZE > size) {
                n_bytes = size - offset;
            }
            write_S3_record(out, address, sparse->data + offset, n_bytes);
        }
    }
 
    // termination
    fprintf(out, "S70500000000FA\n");
    fclose(out);
    out = NULL;
    return 0;
}

References srec_t::buf, count, rz_buf_sparse_chunk_t::data, fd, benchmark::FILE, rz_buf_sparse_chunk_t::from, i, z80_opcode::name, NULL, rz_io_t::off, out, pathname, RZ_BUF_CUR, rz_buf_seek(), rz_buf_sparse_get_chunks(), rz_buf_write_at(), RZ_LOG_ERROR, RZ_PERM_W, rz_return_val_if_fail, rz_sys_fopen(), SREC_PATH_PREFIX, SREC_SIZE, rz_buf_sparse_chunk_t::to, and write_S3_record().

srecord_parse()

static bool srecord_parse ( RzBuffer *  buf, char *  str  )

static

Definition at line 137 of file io_srec.c.

                                                    {
    if (!str || *str != 'S') {
        return false;
    }
    ut8 *record_data = NULL;
    ut32 record_size = 0;
    ut32 record_begin = 0;
    ut32 record_addr = 0;
    ut32 record_next = 0;
    char record_type = 0;
    char *eol = NULL;
    ut8 cksum = 0;
    st32 byte_count = 0;
    st32 byte = 0, i = 0, counter = 0;
    int line = 0;
 
    record_data = malloc(UT16_MAX);
    if (!record_data) {
        goto fail;
    }
 
    do {
        line++;
        if (sscanf(str, "S%c%02x", &record_type, &byte_count) != 2) {
            RZ_LOG_ERROR("srec:parse(): invalid data in motorola srecord file at line %d\n", line);
            goto fail;
        }
 
        byte_count &= 0xff;
 
        switch (record_type) {
        case '0': // Header with 16-bit address
            counter = byte_count - 3;
            if (sscanf(str + 4, "%04x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid header hexadecimal address 16-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffff;
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += record_addr >> 8;
 
            for (i = 0; i < counter; i++) {
                if (sscanf(str + 8 + (i * 2), "%02x", &byte) != 1) {
                    RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value! at line %d\n", line);
                    goto fail;
                }
                cksum += byte;
            }
            cksum = ~cksum;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value! at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '1': // Data with 16-bit address
            counter = byte_count - 3;
            if (sscanf(str + 4, "%04x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid data hexadecimal address 16-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffff;
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += record_addr >> 8;
 
            if ((record_next != record_addr) || ((record_size + counter) > UT16_MAX)) {
                if (record_size && record_size < UT16_MAX) {
                    if (rz_buf_write_at(buf, record_begin, record_data, (st32)record_size) != record_size) {
                        RZ_LOG_ERROR("srec:parse(): cannot write buffer at 0x%x\n", record_begin);
                        goto fail;
                    }
                }
                record_begin = record_addr;
                record_next = record_addr;
                record_size = 0;
            }
 
            for (i = 0; i < byte_count - 3; i++) {
                if (sscanf(str + 8 + (i * 2), "%02x", &byte) != 1) {
                    RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                    goto fail;
                }
                if (record_size + i < UT16_MAX) {
                    record_data[record_size + i] = (ut8)byte & 0xff;
                }
                cksum += byte;
            }
            cksum = ~cksum;
            record_size += counter;
            record_next += counter;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '5': // Count with 16-bit address
            if (sscanf(str + 4, "%04x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid count hexadecimal address 16-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffff;
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += record_addr >> 8;
            cksum = ~cksum;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '9': // Terminator with 16-bit address
            if (sscanf(str + 4, "%04x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid terminator hexadecimal address 16-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffff;
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += record_addr >> 8;
            cksum = ~cksum;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
        case '2': // Data with 24-bit address
            counter = byte_count - 4;
            if (sscanf(str + 4, "%06x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid data hexadecimal address 24-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffffff;
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += (record_addr >> 8) & 0xff;
            cksum += record_addr >> 16;
 
            if ((record_next != record_addr) || ((record_size + counter) > UT16_MAX)) {
                if (record_size && record_size < UT16_MAX) {
                    if (rz_buf_write_at(buf, record_begin, record_data, (st32)record_size) != record_size) {
                        RZ_LOG_ERROR("srec:parse(): cannot write buffer at 0x%x\n", record_begin);
                        goto fail;
                    }
                }
                record_begin = record_addr;
                record_next = record_addr;
                record_size = 0;
            }
 
            for (i = 0; i < byte_count - 4; i++) {
                if (sscanf(str + 10 + (i * 2), "%02x", &byte) != 1) {
                    RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                    goto fail;
                }
                if (record_size + i < UT16_MAX) {
                    record_data[record_size + i] = (ut8)byte & 0xff;
                }
                cksum += byte;
            }
            cksum = ~cksum;
            record_size += counter;
            record_next += counter;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '6': // Count with 24-bit address
            if (sscanf(str + 4, "%06x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal address 24-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffffff;
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += (record_addr >> 8) & 0xff;
            cksum += record_addr >> 16;
            cksum = ~cksum;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '8': // Terminator with 24-bit address
            if (sscanf(str + 4, "%06x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal address 24-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffffff;
 
            eol = strchr(str + 1, 'S');
            if (eol) {
                *eol = 0;
            }
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += (record_addr >> 8) & 0xff;
            cksum += record_addr >> 16;
            cksum = ~cksum;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '3': // Data with 32-bit address
            counter = byte_count - 5;
            if (sscanf(str + 4, "%08x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal address 32-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffffffff;
 
            eol = strchr(str + 1, 'S');
            if (eol) {
                *eol = 0;
            }
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += (record_addr >> 8) & 0xff;
            cksum += (record_addr >> 16) & 0xff;
            cksum += record_addr >> 24;
 
            if ((record_next != record_addr) || ((record_size + counter) > UT16_MAX)) {
                if (record_size && record_size < UT16_MAX) {
                    if (rz_buf_write_at(buf, record_begin, record_data, (st32)record_size) != record_size) {
                        RZ_LOG_ERROR("srec:parse(): cannot write buffer at 0x%x\n", record_begin);
                        goto fail;
                    }
                }
                record_begin = record_addr;
                record_next = record_addr;
                record_size = 0;
            }
 
            for (i = 0; i < byte_count - 5; i++) {
                if (sscanf(str + 12 + (i * 2), "%02x", &byte) != 1) {
                    RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                    goto fail;
                }
                if (record_size + i < UT16_MAX) {
                    record_data[record_size + i] = (ut8)byte & 0xff;
                }
                cksum += byte;
            }
            cksum = ~cksum;
            record_size += counter;
            record_next += counter;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '7': // Terminator with 32-bit address
            if (sscanf(str + 4, "%08x", &record_addr) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal address 32-bit at line %d\n", line);
                goto fail;
            }
            record_addr &= 0xffffffff;
 
            eol = strchr(str + 1, 'S');
            if (eol) {
                *eol = 0;
            }
 
            cksum = byte_count;
            cksum += record_addr & 0xff;
            cksum += (record_addr >> 8) & 0xff;
            cksum += (record_addr >> 16) & 0xff;
            cksum += record_addr >> 24;
            cksum = ~cksum;
 
            if (sscanf(str + 2 + (byte_count * 2), "%02x", &byte) != 1) {
                RZ_LOG_ERROR("srec:parse(): invalid hexadecimal value at line %d\n", line);
                goto fail;
            } else if (cksum != byte) {
                RZ_LOG_ERROR("srec:parse(): checksum check failed (got %02x expected %02x) at line %d\n", byte, cksum, line);
                goto fail;
            }
 
            str = strchr(str + 1, 'S');
            break;
 
        case '4':
            break;
        default:
            RZ_LOG_ERROR("srec:parse(): invalid motorola srecord type '%c' at line %d\n", record_type, line);
            goto fail;
        }
    } while (str);
 
    if (record_size && record_size < UT16_MAX) {
        if (rz_buf_write_at(buf, record_begin, record_data, (st32)record_size) != record_size) {
            RZ_LOG_ERROR("srec:parse(): cannot write buffer at 0x%x\n", record_begin);
            goto fail;
        }
    }
 
    free(record_data);
    return true;
fail:
    free(record_data);
    return false;
}

References counter, fail, free(), i, setup::line, malloc(), NULL, rz_buf_write_at(), RZ_LOG_ERROR, st32, cmd_descs_generate::str, UT16_MAX, and ut8.

Referenced by __open().

write_S3_record()

static void write_S3_record ( FILE *  fd, ut32  address, const ut8 *  buffer, ut16  size  )

static

Definition at line 28 of file io_srec.c.

                                                                                  {
    rz_return_if_fail(fd && buffer);
 
    ut8 record_size = 4 + size + 1;
    ut8 checksum = record_size;
    checksum += address & 0xff;
    checksum += (address >> 8) & 0xff;
    checksum += (address >> 16) & 0xff;
    checksum += address >> 24;
 
    fprintf(fd, "S3%02x%08x", record_size, address);
 
    for (ut16 j = 0; j < size; j++) {
        checksum += buffer[j];
        fprintf(fd, "%02x", buffer[j]);
    }
 
    fprintf(fd, "%02x\n", checksum);
}

References fd, and rz_return_if_fail.

Referenced by __write().

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_IO,
    .data = &rz_io_plugin_srec,
    .version = RZ_VERSION
}

Definition at line 564 of file io_srec.c.

rz_io_plugin_srec

RzIOPlugin rz_io_plugin_srec

Initial value:

= {
    .name = "srec",
    .desc = "Motorola S-record file format",
    .uris = SREC_PATH_PREFIX,
    .license = "LGPL-3",
    .open = __open,
    .close = __close,
    .read = __read,
    .check = __plugin_open,
    .lseek = __lseek,
    .write = __write,
    .resize = __resize
}

Definition at line 549 of file io_srec.c.

Referenced by __open().