summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--utils/rk27utils/README15
-rw-r--r--utils/rk27utils/rkwtool/Makefile7
-rw-r--r--utils/rk27utils/rkwtool/main.c129
-rw-r--r--utils/rk27utils/rkwtool/rkw.c538
-rw-r--r--utils/rk27utils/rkwtool/rkw.h123
5 files changed, 812 insertions, 0 deletions
diff --git a/utils/rk27utils/README b/utils/rk27utils/README
index d0343580b8..802f5a559b 100644
--- a/utils/rk27utils/README
+++ b/utils/rk27utils/README
@@ -36,6 +36,21 @@ rockchip player.
You need libusb-1.0 + header files in order to compile this utility.
+
+rkwtool
+This directory contains tool to inspect and extract content of
+'full' update RKW file.
+
+The RKW file contains specific section which instruct update
+routine of the DAP what to do, custom archive with firmware files,
+images of stage1 and stage2 nand bootloader and Rock27Boot.bin file
+image. Nand bootloader images are stored in scrambled form but
+the tool deciphers it to plain binary during extraction.
+
+More complete descritpion of file format can be found on wiki:
+http://www.rockbox.org/wiki/RKWFileFormat
+
+
nandextract
This directory contains quick and dirty tool which allows to extract
nand bootloader from raw dump of the first nand block. The main reason
diff --git a/utils/rk27utils/rkwtool/Makefile b/utils/rk27utils/rkwtool/Makefile
new file mode 100644
index 0000000000..239733cb87
--- /dev/null
+++ b/utils/rk27utils/rkwtool/Makefile
@@ -0,0 +1,7 @@
+all: rkwtool
+
+rkwtool: rkw.c main.c
+ gcc -g -std=c99 -o $@ -W -Wall $^
+
+clean:
+ rm -fr rkwtool
diff --git a/utils/rk27utils/rkwtool/main.c b/utils/rk27utils/rkwtool/main.c
new file mode 100644
index 0000000000..dacfd9ffab
--- /dev/null
+++ b/utils/rk27utils/rkwtool/main.c
@@ -0,0 +1,129 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ *
+ * Copyright (C) 2014 by Marcin Bukat
+ *
+ * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <getopt.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include "rkw.h"
+
+#define VERSION "v0.1"
+
+static void banner(void)
+{
+ printf("RKWtool " VERSION " (C) Marcin Bukat 2014\n");
+ printf("This is free software; see the source for copying conditions. There is NO\n");
+ printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
+}
+
+static void usage(char *name)
+{
+ banner();
+
+ printf("Usage: %s [-i] [-b] [-e] [-a] [-o prefix] file.rkw\n", name);
+ printf("-i\t\tprint info about RKW file\n");
+ printf("-b\t\textract nand bootloader images (s1.bin and s2.bin)\n");
+ printf("-e\t\textract firmware files stored in RKST section\n");
+ printf("-o prefix\twhen extracting firmware files put it there\n");
+ printf("-a\t\textract additional file(s) (usually Rock27Boot.bin)\n");
+ printf("-A\t\textract all data\n");
+ printf("file.rkw\tRKW file to be processed\n");
+}
+
+int main(int argc, char **argv)
+{
+ int opt;
+ struct rkw_info_t *rkw_info = NULL;
+ char *prefix = NULL;
+ bool info = false;
+ bool extract = false;
+ bool bootloader = false;
+ bool addfile = false;
+
+ while ((opt = getopt(argc, argv, "iebo:aA")) != -1)
+ {
+ switch (opt)
+ {
+ case 'i':
+ info = true;
+ break;
+
+ case 'e':
+ extract = true;
+ break;
+
+ case 'b':
+ bootloader = true;
+ break;
+
+ case 'o':
+ prefix = optarg;
+ break;
+
+ case 'a':
+ addfile = true;
+ break;
+
+ case 'A':
+ extract = true;
+ bootloader = true;
+ addfile = true;
+ break;
+
+ default:
+ usage(argv[0]);
+ break;
+ }
+ }
+
+ if ((argc - optind) != 1 ||
+ (!info && !extract && ! bootloader && !addfile))
+ {
+ usage(argv[0]);
+ return -1;
+ }
+
+ banner();
+
+ rkw_info = rkw_slurp(argv[optind]);
+
+ if (rkw_info)
+ {
+ if (info)
+ {
+ rkrs_list_named_items(rkw_info);
+ rkst_list_named_items(rkw_info);
+ }
+
+ if (extract)
+ unpack_rkst(rkw_info, prefix);
+
+ if (bootloader)
+ unpack_bootloader(rkw_info, prefix);
+
+ if (addfile)
+ unpack_addfile(rkw_info, prefix);
+
+ rkw_free(rkw_info);
+ return 0;
+ }
+
+ return -1;
+}
diff --git a/utils/rk27utils/rkwtool/rkw.c b/utils/rk27utils/rkwtool/rkw.c
new file mode 100644
index 0000000000..eacef87b8e
--- /dev/null
+++ b/utils/rk27utils/rkwtool/rkw.c
@@ -0,0 +1,538 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ *
+ * Copyright (C) 2014 by Marcin Bukat
+ *
+ * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "rkw.h"
+
+const char *section_name[] = {
+ "RKLD",
+ "RKRS",
+ "RKST"
+};
+
+const uint32_t section_magic[] = {
+ RKLD_MAGIC,
+ RKRS_MAGIC,
+ RKST_MAGIC
+};
+
+const char *rkrs_action_name[] = {
+ [act_null] = "null",
+ [act_mkdir] = "mkdir",
+ [act_fcopy] = "fcopy",
+ [act_fsoper] = "fsoper",
+ [act_format] = "format",
+ [act_loader] = "loader",
+ [act_dispbmp] = "dispbmp",
+ [act_dispstr] = "dispstr",
+ [act_setfont] = "setfont",
+ [act_delay] = "delay",
+ [act_system] = "system",
+ [act_readme] = "readme",
+ [act_copyright] = "copyright",
+ [act_select] = "select",
+ [act_restart] = "restart",
+ [act_regkey] = "regkey",
+ [act_version] = "version",
+ [act_freplace] = "freplace",
+ [act_fpreplace] = "fpreplace",
+ [act_fsdel] = "fsdel",
+ [act_space] = "space",
+ [act_addfile] = "addfile",
+ [act_setmem] = "setmem",
+ [act_getmem] = "getmem"
+};
+
+/* scrambling/descrambling reverse engineered by AleMaxx */
+static void encode_page(uint8_t *inpg, uint8_t *outpg, const int size)
+{
+
+uint8_t key[] = {
+ 0x7C, 0x4E, 0x03, 0x04,
+ 0x55, 0x05, 0x09, 0x07,
+ 0x2D, 0x2C, 0x7B, 0x38,
+ 0x17, 0x0D, 0x17, 0x11
+};
+ int i, i3, x, val, idx;
+
+ uint8_t key1[0x100];
+ uint8_t key2[0x100];
+
+ for (i=0; i<0x100; i++) {
+ key1[i] = i;
+ key2[i] = key[i&0xf];
+ }
+
+ i3 = 0;
+ for (i=0; i<0x100; i++) {
+ x = key1[i];
+ i3 = key1[i] + i3;
+ i3 += key2[i];
+ i3 &= 0xff;
+ key1[i] = key1[i3];
+ key1[i3] = x;
+ }
+
+ idx = 0;
+ for (i=0; i<size; i++) {
+ x = key1[(i+1) & 0xff];
+ val = x;
+ idx = (x + idx) & 0xff;
+ key1[(i+1) & 0xff] = key1[idx];
+ key1[idx] = (x & 0xff);
+ val = (key1[(i+1)&0xff] + x) & 0xff;
+ val = key1[val];
+ outpg[i] = val ^ inpg[i];
+ }
+}
+
+/* take path as stored in RKST and convert it to unix path
+ * with optional prefix
+ */
+static char *unixpath(char *path, char *prefix)
+{
+ char *parsed, *ptr;
+ size_t size = 0;
+
+ if (NULL == path)
+ return NULL;
+
+ size = strlen(path) + 1;
+
+ /* full windows path i.e C:\something */
+ if (strlen(path) > 2 && ':' == path[1])
+ path += 3;
+
+ if (prefix)
+ {
+ /* account for '/' after prefix */
+ size += strlen(prefix) + 1;
+ }
+
+ /* allocate buffer */
+ parsed = malloc(size);
+ ptr = parsed;
+
+ /* malloc failed */
+ if (NULL == ptr)
+ return NULL;
+
+ /* copy prefix */
+ if (prefix)
+ {
+ strcpy(ptr, prefix);
+ ptr += strlen(prefix);
+ *ptr++ = '/';
+ }
+
+ do
+ {
+ if (*path == '\\')
+ *ptr = '/';
+ else
+ *ptr = *path;
+
+ ptr++;
+ } while ('\0' != *(path++));
+
+ return parsed;
+}
+
+/* returns pointer to the rkrs header in rkw file */
+static char *find_section(struct rkw_info_t *rkw_info, enum section_type_t type)
+{
+ char *ptr;
+ struct section_header_t *h;
+
+ switch(type)
+ {
+ case ST_RKRS:
+ case ST_RKST:
+ for (ptr=(char *)rkw_info->rkw; ptr<(char *)rkw_info->rkw+rkw_info->size; ptr++)
+ {
+ h = (struct section_header_t *)ptr;
+ if (h->magic == section_magic[type] &&
+ h->size == sizeof(struct section_header_t) &&
+ h->number_of_named_entries != 0)
+ {
+ fprintf(stderr, "[info]: %s found at 0x%0x\n",
+ section_name[type], (int)(ptr - rkw_info->rkw));
+
+ return ptr;
+ }
+ }
+ break;
+
+ default:
+ fprintf(stderr, "[error]: Not supported section type %d\n", type);
+ return NULL;
+ }
+ return NULL;
+}
+
+/* load rkw file into memory and setup pointers to various sections */
+struct rkw_info_t *rkw_slurp(char *filename)
+{
+ FILE *fp;
+ struct rkw_info_t *rkw_info;
+
+ rkw_info = (struct rkw_info_t *)malloc(sizeof(struct rkw_info_t));
+
+ if (NULL == rkw_info)
+ {
+ fprintf(stderr, "[error]: Can't allocate %ld bytes of memory\n",
+ sizeof(struct rkw_info_t));
+
+ return NULL;
+ }
+
+ fp = fopen(filename, "rb");
+
+ if (NULL == fp)
+ {
+ fprintf(stderr, "[error]: Can't open %s\n", filename);
+ free(rkw_info);
+ return NULL;
+ }
+
+ fseek(fp, 0, SEEK_END);
+ rkw_info->size = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ rkw_info->rkw = (char *)malloc(rkw_info->size);
+
+ if (NULL == rkw_info->rkw)
+ {
+ fprintf(stderr, "[error]: Can't allocate %ld bytes of memory\n",
+ rkw_info->size);
+
+ free(rkw_info);
+ fclose(fp);
+ return NULL;
+ }
+
+ if (fread(rkw_info->rkw, rkw_info->size, 1, fp) != 1)
+ {
+ fprintf(stderr, "[error]: Can't read %s\n", filename);
+ free(rkw_info);
+ fclose(fp);
+ return NULL;
+ }
+
+ rkw_info->rkrs_info.header = find_section(rkw_info, ST_RKRS);
+ rkw_info->rkrs_info.items = rkw_info->rkrs_info.header +
+ ((struct section_header_t *)
+ (rkw_info->rkrs_info.header))->offset_of_named_entries;
+
+ rkw_info->rkst_info.header = find_section(rkw_info, ST_RKST);
+ rkw_info->rkst_info.items = rkw_info->rkst_info.header +
+ ((struct section_header_t *)
+ (rkw_info->rkst_info.header))->offset_of_named_entries;
+
+ fclose(fp);
+ return rkw_info;
+}
+
+void rkw_free(struct rkw_info_t *rkw_info)
+{
+ free(rkw_info->rkw);
+ free(rkw_info);
+}
+
+static void rkrs_named_item_info(struct rkrs_named_t *item)
+{
+ fprintf(stderr, "[info]: size=0x%0x (%d)\n", item->size, item->size);
+ fprintf(stderr, "[info]: type=0x%0x (%d) %s\n", item->type, item->type, rkrs_action_name[item->type]);
+ fprintf(stderr, "[info]: data_offset=0x%0x (%d)\n", item->data_offset, item->data_offset);
+ fprintf(stderr, "[info]: data_size=0x%0x (%d)\n", item->data_size, item->data_size);
+ fprintf(stderr, "[info]: param[0]=0x%0x (%d)\n", item->param[0], item->param[0]);
+ fprintf(stderr, "[info]: param[1]=0x%0x (%d)\n", item->param[1], item->param[1]);
+ fprintf(stderr, "[info]: param[2]=0x%0x (%d)\n", item->param[2], item->param[2]);
+ fprintf(stderr, "[info]: param[3]=0x%0x (%d)\n", item->param[3], item->param[3]);
+}
+
+static void rkst_named_item_info(struct rkst_named_t *item)
+{
+ fprintf(stderr, "[info]: size=0x%0x (%d)\n", item->size, item->size);
+ fprintf(stderr, "[info]: action=0x%0x (%d) %s\n", item->action, item->action, rkrs_action_name[item->action]);
+ fprintf(stderr, "[info]: data_offset=0x%0x (%d)\n", item->data_offset, item->data_offset);
+ fprintf(stderr, "[info]: data_size=0x%0x (%d)\n", item->data_size, item->data_size);
+ fprintf(stderr, "[info]: name=\"%s\"\n", &item->name);
+}
+
+static struct rkrs_named_t *find_item(struct rkw_info_t *rkw_info, enum rkst_action_t type, bool search_start)
+{
+ static struct rkrs_named_t *item;
+
+ if (search_start)
+ {
+ item = (struct rkrs_named_t *)rkw_info->rkrs_info.items;
+ }
+ else
+ {
+ if (item)
+ item++;
+ else
+ return NULL;
+ }
+
+ while (item->size > 0)
+ {
+ if (item->type == type)
+ {
+ fprintf(stderr, "[info]: Item type=%d found at 0x%x\n", type,
+ (int)((char *)item - rkw_info->rkw));
+ return item;
+ }
+ item++;
+ }
+
+ return NULL;
+}
+
+void rkrs_list_named_items(struct rkw_info_t *rkw_info)
+{
+ struct rkrs_named_t *item = (struct rkrs_named_t *)rkw_info->rkrs_info.items;
+ struct section_header_t *rkrs_header = (struct section_header_t *)(rkw_info->rkrs_info.header);
+ int i;
+
+ for (i=0; i<rkrs_header->number_of_named_entries; i++)
+ {
+ fprintf(stderr, "[info]: rkrs named entry %d\n", i);
+ rkrs_named_item_info(item++);
+ fprintf(stderr, "\n");
+ }
+}
+
+void rkst_list_named_items(struct rkw_info_t *rkw_info)
+{
+ struct rkst_named_t *item = (struct rkst_named_t *)rkw_info->rkst_info.items;
+ struct section_header_t *rkst_header = (struct section_header_t *)(rkw_info->rkst_info.header);
+ int i;
+
+ for (i=0; i<rkst_header->number_of_named_entries; i++)
+ {
+ fprintf(stderr, "[info]: rkst named entry %d\n", i);
+ rkst_named_item_info(item);
+ item = (struct rkst_named_t *)((char *)item + item->size);
+ fprintf(stderr, "\n");
+ }
+}
+
+void unpack_bootloader(struct rkw_info_t *rkw_info, char *prefix)
+{
+ FILE *fp;
+ char *ptr;
+ size_t size;
+ int len;
+ char *buf;
+ struct rkrs_named_t *item = find_item(rkw_info, act_loader, true);
+
+ if (NULL == item)
+ {
+ fprintf(stderr, "[error]: Can't find nand bootloader\n");
+ return;
+ }
+
+ ptr = (char *)(rkw_info->rkrs_info.header) + item->data_offset;
+ size = item->param[0];
+ buf = malloc(size);
+
+ if (NULL == buf)
+ {
+ fprintf(stderr, "[error]: Can't allocate %ld bytes of memory\n",
+ size);
+ return;
+ }
+
+ /* make a copy for decryption */
+ memcpy(buf, ptr, size);
+ encode_page((uint8_t *)buf, (uint8_t *)buf, size);
+ fp = fopen(unixpath("s1.bin", prefix), "w");
+
+ if (NULL == fp)
+ {
+ fprintf(stderr, "[error]: Can't open s1.bin for writing\n");
+ free(buf);
+ return;
+ }
+
+ if (fwrite(buf, size, 1, fp) != 1)
+ {
+ fprintf(stderr, "[error]: Can't write s1.bin file\n");
+ free(buf);
+ fclose(fp);
+ return;
+ }
+
+ fclose(fp);
+
+ ptr = (char *)(rkw_info->rkrs_info.header) + item->param[1];
+ size = item->param[2];
+ len = size;
+ buf = realloc(buf, size);
+
+ if (NULL == buf)
+ {
+ fprintf(stderr, "[error]: Can't allocate %ld bytes of memory\n",
+ size);
+
+ free(buf);
+ return;
+ }
+
+ memcpy(buf, ptr, size);
+ ptr = buf;
+
+ while (len >= 0x200)
+ {
+ encode_page((uint8_t *)ptr, (uint8_t *)ptr, 0x200);
+ ptr += 0x200;
+ len -= 0x200;
+ }
+ encode_page((uint8_t *)ptr, (uint8_t *)ptr, len);
+
+ fp = fopen(unixpath("s2.bin", prefix), "w");
+
+ if (NULL == fp)
+ {
+ fprintf(stderr, "[error]: Can't open s2.bin for writing\n");
+ free(buf);
+ return;
+ }
+
+ if (fwrite(buf, size, 1, fp) != 1)
+ {
+ fprintf(stderr, "[error]: Can't write s2.bin file\n");
+ free(buf);
+ fclose(fp);
+ return;
+ }
+
+ fclose(fp);
+ free(buf);
+ fprintf(stderr, "[info]: Extracted bootloader version: %x.%x\n",
+ (item->param[3] >> 8) & 0xff, item->param[3] & 0xff);
+}
+
+void unpack_addfile(struct rkw_info_t *rkw_info, char *prefix)
+{
+ FILE *fp;
+ char *name;
+ int name_len;
+
+ struct rkrs_named_t *item = find_item(rkw_info, act_addfile, true);
+
+ do
+ {
+ name = unixpath(rkw_info->rkrs_info.header + item->data_offset, prefix);
+ name_len = item->param[0];
+
+ fprintf(stderr, "[info]: unpacking addfile %s\n", name);
+
+ fp = fopen(name, "w");
+
+ if (NULL == fp)
+ {
+ fprintf(stderr, "[error]: Can't open %s for writing\n", name);
+ return;
+ }
+
+ if (fwrite(rkw_info->rkrs_info.header + item->data_offset + name_len,
+ item->data_size - name_len, 1, fp) != 1)
+ {
+ fprintf(stderr, "[error]: Can't write %s file\n", name);
+ fclose(fp);
+ return;
+ }
+
+ fclose(fp);
+ } while (NULL != (item = find_item(rkw_info, act_addfile, false)));
+}
+
+/* unpack content of RKST section
+ * this mimics what is done when processing 'fsoper' field of RKRS
+ */
+void unpack_rkst(struct rkw_info_t *rkw_info, char *prefix)
+{
+ FILE *fp;
+ struct rkst_named_t *item = (struct rkst_named_t *)rkw_info->rkst_info.items;
+ struct section_header_t *rkst_header = (struct section_header_t *)(rkw_info->rkst_info.header);
+ char *name;
+ int i;
+
+ if (prefix)
+ {
+ if (0 != mkdir(prefix, 0755))
+ {
+ fprintf(stderr, "[error]: Can't create %s directory (%s)\n",
+ prefix, strerror(errno));
+ return;
+ }
+ }
+
+ fprintf(stderr, "[info]: Unpacking content of RKST section\n");
+
+ for (i=0; i<rkst_header->number_of_named_entries; i++)
+ {
+ name = unixpath((char *)&(item->name), prefix);
+
+ switch (item->action)
+ {
+ case act_mkdir:
+ if (0 != mkdir(name, 0755))
+ {
+ fprintf(stderr, "[error]: Can't create %s directory (%s)\n",
+ name, strerror(errno));
+ return;
+ }
+ fprintf(stderr, "[info]: mkdir %s\n", name);
+ break;
+
+ case act_fcopy:
+ fp = fopen(name, "w");
+ if (NULL == fp)
+ {
+ fprintf(stderr, "[error]: Can't open %s for writing (%s)\n",
+ name, strerror(errno));
+ return;
+ }
+
+ fwrite((char *)rkst_header + item->data_offset, item->data_size, 1, fp);
+ fprintf(stderr, "[info]: unpack %s\n", name);
+ fclose(fp);
+ break;
+
+ default:
+ break;
+ }
+
+ if (name) free(name);
+ item = (struct rkst_named_t *)((char *)item + item->size);
+ }
+}
diff --git a/utils/rk27utils/rkwtool/rkw.h b/utils/rk27utils/rkwtool/rkw.h
new file mode 100644
index 0000000000..eba673c974
--- /dev/null
+++ b/utils/rk27utils/rkwtool/rkw.h
@@ -0,0 +1,123 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ *
+ * Copyright (C) 2014 by Marcin Bukat
+ *
+ * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <stdint.h>
+
+#define RKLD_MAGIC 0x4C44524B
+#define RKRS_MAGIC 0x53524B52
+#define RKST_MAGIC 0X53544B52
+
+enum section_type_t {
+ ST_RKLD,
+ ST_RKRS,
+ ST_RKST
+};
+
+enum rkst_action_t {
+ act_null = 0,
+ act_mkdir = 1,
+ act_fcopy = 2,
+ act_fsoper = 3,
+ act_format = 4,
+ act_loader = 5,
+
+ act_dispbmp = 10,
+ act_dispstr = 11,
+ act_setfont = 12,
+
+ act_delay = 20,
+
+ act_system = 100,
+ act_uilogo = 100,
+ act_readme = 101,
+ act_copyright = 102,
+ act_select = 103,
+ act_restart = 104,
+
+ act_regkey = 120,
+ act_version = 121,
+
+ act_freplace = 130,
+ act_fpreplace = 131,
+ act_fsdel = 132,
+
+ act_space = 200,
+
+ act_addfile = 300,
+
+ act_setmem = 1000,
+ act_getmem = 1001,
+};
+
+struct section_header_t {
+ uint32_t size;
+ uint32_t magic;
+ uint32_t property;
+ uint32_t timestamp;
+ uint32_t allign;
+ uint32_t file_size;
+ uint16_t size_of_name_dir;
+ uint16_t size_of_id_dir;
+ uint16_t number_of_named_entries;
+ uint16_t number_of_id_entries;
+ uint32_t offset_of_named_entries;
+ uint32_t offset_of_id_entries;
+} __attribute__((__packed__));
+
+struct rkrs_named_t {
+ uint32_t size;
+ uint32_t type;
+ uint32_t data_offset;
+ uint32_t data_size;
+ uint32_t param[4];
+} __attribute__((__packed__));
+
+struct rkst_named_t {
+ uint32_t size;
+ uint32_t action;
+ uint32_t data_offset;
+ uint32_t data_size;
+ uint8_t name;
+};
+
+struct section_info_t {
+ char *header;
+ char *items;
+};
+
+struct rkw_info_t {
+ char *rkw;
+ long size;
+ struct section_info_t rkrs_info;
+ struct section_info_t rkst_info;
+};
+
+/* general functions */
+struct rkw_info_t *rkw_slurp(char *filename);
+void rkw_free(struct rkw_info_t *rkw_info);
+
+/* info functions */
+void rkrs_list_named_items(struct rkw_info_t *rkw_info);
+void rkst_list_named_items(struct rkw_info_t *rkw_info);
+
+/* extract functions */
+void unpack_bootloader(struct rkw_info_t *rkw_info, char *prefix);
+void unpack_rkst(struct rkw_info_t *rkw_info, char *prefix);
+void unpack_addfile(struct rkw_info_t *rkw_info, char *prefix);
generated by cgit (git 2.34.1) at 2024-04-16 17:52:34 +0000