Task 605: .RB File Format
1. List of all the properties of this file format intrinsic to its file system
Based on the specifications for the Rocket eBook (.RB) file format, the intrinsic properties refer to the structural elements and fields that define the file's format and content organization. These are not file system metadata (like permissions or timestamps) but the internal binary structure. The list includes all key fields from the header, Table of Contents (ToC), and associated flags/structures:
- Magic number: 4 bytes, always B0 0C B0 0C (hex) or variant B0 0C F0 0D.
- Version number: 2 bytes, major and minor version (e.g., 02 00 for version 2.0).
- Identifier string: 4 bytes, "NUVO" or zeros.
- Reserved (after identifier): 4 bytes, zeros.
- Creation year: 2 bytes, int16 (full year or tm_year value).
- Creation month: 1 byte, int8 (1-based).
- Creation day: 1 byte, int8 (1-based).
- Reserved (after date): 2 bytes, zeros.
- Table of Contents offset: 4 bytes, int32, absolute offset to ToC.
- File length: 4 bytes, int32, total length of the .RB file.
- Reserved area: 104 bytes, zeros or encryption-related data.
- Number of entries: 4 bytes, int32, count of page entries in ToC.
- Entry name (per entry): 32 bytes, zero-padded string.
- Entry length (per entry): 4 bytes, int32, data length.
- Entry offset (per entry): 4 bytes, int32, absolute offset to data.
- Entry flag (per entry): 4 bytes, int32 (bits: 1=encrypted, 2=info page, 8=compressed; combinations possible).
- Padding at end: 20 bytes of 01h.
Additional properties for specific page types (derived from flags and suffixes):
- Info page properties (flag 2): NAME=VALUE pairs (e.g., TITLE, AUTHOR, BODY).
- Compressed data properties (flag 8): Chunk count (4 bytes), uncompressed length (4 bytes), chunk sizes (4 bytes per chunk).
- HTML-Index (.hidx): Tags section, paragraphs section, names (anchors) section.
- HTML-Key (.hkey): Word-tab-offset lines.
- Image (.png): Raw PNG data.
All multi-byte integers are little-endian.
2. Two direct download links for files of format .RB
After extensive search, public direct download links for genuine Rocket eBook .RB files are not readily available online due to the format's obsolescence (dating to 1998) and potential copyright issues for commercial titles. Free conversions from Project Gutenberg texts were possible in the past using tools like RocketLibrarian, but no direct .RB files were found. For illustration, you can create .RB files using open-source tools like rbmake (available at https://sourceforge.net/projects/rbmake/files/). No safe, public direct downloads were identified.
3. Ghost blog embedded HTML JavaScript for drag-and-drop .RB file dump
Here's a self-contained HTML page with embedded JavaScript that can be embedded in a blog (e.g., Ghost blog platform). It allows dragging and dropping a .RB file and dumps all properties to the screen. It uses FileReader and DataView to parse the binary file.
Drag and drop a .RB file here
Note: This parses the header and ToC; for full data decoding (e.g., decompressing chunks), additional logic would be needed.
4. Python class for .RB file
import struct
class RBFile:
def __init__(self, filepath):
self.filepath = filepath
self.properties = {}
self.entries = []
self._read_and_decode()
def _read_and_decode(self):
with open(self.filepath, 'rb') as f:
data = f.read()
# Header
self.properties['magic'] = struct.unpack_from('<I', data, 0)[0]
self.properties['version_major'] = data[4]
self.properties['version_minor'] = data[5]
self.properties['identifier'] = data[6:10].decode('ascii', errors='ignore')
self.properties['year'] = struct.unpack_from('<H', data, 14)[0]
self.properties['month'] = data[16]
self.properties['day'] = data[17]
self.properties['toc_offset'] = struct.unpack_from('<I', data, 24)[0]
self.properties['file_length'] = struct.unpack_from('<I', data, 28)[0]
# ToC
toc = self.properties['toc_offset']
num_entries = struct.unpack_from('<I', data, toc)[0]
self.properties['num_entries'] = num_entries
offset = toc + 4
for i in range(num_entries):
name = data[offset:offset+32].rstrip(b'\0').decode('ascii', errors='ignore')
offset += 32
length = struct.unpack_from('<I', data, offset)[0]
offset += 4
entry_offset = struct.unpack_from('<I', data, offset)[0]
offset += 4
flag = struct.unpack_from('<I', data, offset)[0]
offset += 4
self.entries.append({'name': name, 'length': length, 'offset': entry_offset, 'flag': flag})
def print_properties(self):
for key, value in self.properties.items():
print(f"{key}: {value}")
for i, entry in enumerate(self.entries):
print(f"Entry {i+1}: {entry}")
def write(self, new_filepath=None):
# Basic write: Reassemble from current properties and entries (no data modification)
if not new_filepath:
new_filepath = self.filepath + '.new'
with open(self.filepath, 'rb') as f:
original_data = f.read()
with open(new_filepath, 'wb') as f:
# Write header
f.write(original_data) # For simplicity, copy original; in full impl, rebuild header/ToC/data
# Example usage
# rb = RBFile('example.rb')
# rb.print_properties()
# rb.write()
Note: The write method is basic (copies the file); a full implementation would rebuild the binary from modified properties/data.
5. Java class for .RB file
import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class RBFile {
private String filepath;
private Map<String, Object> properties = new HashMap<>();
private List<Map<String, Object>> entries = new ArrayList<>();
public RBFile(String filepath) {
this.filepath = filepath;
readAndDecode();
}
private void readAndDecode() {
try (RandomAccessFile raf = new RandomAccessFile(filepath, "r")) {
FileChannel channel = raf.getChannel();
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, raf.length());
buffer.order(ByteOrder.LITTLE_ENDIAN);
properties.put("magic", buffer.getInt(0));
properties.put("version_major", Byte.toUnsignedInt(buffer.get(4)));
properties.put("version_minor", Byte.toUnsignedInt(buffer.get(5)));
byte[] idBytes = new byte[4];
buffer.position(6);
buffer.get(idBytes);
properties.put("identifier", new String(idBytes));
properties.put("year", Short.toUnsignedInt(buffer.getShort(14)));
properties.put("month", Byte.toUnsignedInt(buffer.get(16)));
properties.put("day", Byte.toUnsignedInt(buffer.get(17)));
properties.put("toc_offset", buffer.getInt(24));
properties.put("file_length", buffer.getInt(28));
int toc = (int) properties.get("toc_offset");
int numEntries = buffer.getInt(toc);
properties.put("num_entries", numEntries);
int offset = toc + 4;
for (int i = 0; i < numEntries; i++) {
byte[] nameBytes = new byte[32];
buffer.position(offset);
buffer.get(nameBytes);
String name = new String(nameBytes).trim();
offset += 32;
int length = buffer.getInt(offset);
offset += 4;
int entryOffset = buffer.getInt(offset);
offset += 4;
int flag = buffer.getInt(offset);
offset += 4;
Map<String, Object> entry = new HashMap<>();
entry.put("name", name);
entry.put("length", length);
entry.put("offset", entryOffset);
entry.put("flag", flag);
entries.add(entry);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void printProperties() {
properties.forEach((key, value) -> System.out.println(key + ": " + value));
for (int i = 0; i < entries.size(); i++) {
System.out.println("Entry " + (i + 1) + ": " + entries.get(i));
}
}
public void write(String newFilepath) throws IOException {
// Basic write: Copy the file; full impl would rebuild
try (FileInputStream fis = new FileInputStream(filepath);
FileOutputStream fos = new FileOutputStream(newFilepath == null ? filepath + ".new" : newFilepath)) {
byte[] buf = new byte[4096];
int len;
while ((len = fis.read(buf)) > 0) {
fos.write(buf, 0, len);
}
}
}
// Example usage
// public static void main(String[] args) {
// RBFile rb = new RBFile("example.rb");
// rb.printProperties();
// rb.write(null);
// }
}
6. JavaScript class for .RB file
This is a Node.js class (requires fs module); for browser, see the HTML in part 3.
const fs = require('fs');
class RBFile {
constructor(filepath) {
this.filepath = filepath;
this.properties = {};
this.entries = [];
this.readAndDecode();
}
readAndDecode() {
const data = fs.readFileSync(this.filepath);
const dv = new DataView(data.buffer);
this.properties.magic = dv.getUint32(0, true);
this.properties.version_major = dv.getUint8(4);
this.properties.version_minor = dv.getUint8(5);
this.properties.identifier = String.fromCharCode(dv.getUint8(6), dv.getUint8(7), dv.getUint8(8), dv.getUint8(9));
this.properties.year = dv.getUint16(14, true);
this.properties.month = dv.getUint8(16);
this.properties.day = dv.getUint8(17);
this.properties.toc_offset = dv.getUint32(24, true);
this.properties.file_length = dv.getUint32(28, true);
const toc = this.properties.toc_offset;
const numEntries = dv.getUint32(toc, true);
this.properties.num_entries = numEntries;
let offset = toc + 4;
for (let i = 0; i < numEntries; i++) {
let name = '';
for (let j = 0; j < 32; j++) {
const char = dv.getUint8(offset + j);
if (char === 0) break;
name += String.fromCharCode(char);
}
offset += 32;
const length = dv.getUint32(offset, true);
offset += 4;
const entryOffset = dv.getUint32(offset, true);
offset += 4;
const flag = dv.getUint32(offset, true);
offset += 4;
this.entries.push({name, length, offset: entryOffset, flag});
}
}
printProperties() {
console.log(this.properties);
this.entries.forEach((entry, i) => console.log(`Entry ${i+1}:`, entry));
}
write(newFilepath = this.filepath + '.new') {
// Basic copy; full impl rebuilds
fs.copyFileSync(this.filepath, newFilepath);
}
}
// Example usage
// const rb = new RBFile('example.rb');
// rb.printProperties();
// rb.write();
7. C code for .RB file (using struct instead of class)
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
typedef struct {
char name[33];
uint32_t length;
uint32_t offset;
uint32_t flag;
} Entry;
typedef struct {
uint32_t magic;
uint8_t version_major;
uint8_t version_minor;
char identifier[5];
uint16_t year;
uint8_t month;
uint8_t day;
uint32_t toc_offset;
uint32_t file_length;
uint32_t num_entries;
Entry* entries;
} RBFile;
RBFile* rb_open(const char* filepath) {
FILE* f = fopen(filepath, "rb");
if (!f) return NULL;
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t* data = malloc(size);
fread(data, 1, size, f);
fclose(f);
RBFile* rb = malloc(sizeof(RBFile));
memcpy(&rb->magic, data, 4);
rb->version_major = data[4];
rb->version_minor = data[5];
memcpy(rb->identifier, data + 6, 4);
rb->identifier[4] = '\0';
memcpy(&rb->year, data + 14, 2);
rb->month = data[16];
rb->day = data[17];
memcpy(&rb->toc_offset, data + 24, 4);
memcpy(&rb->file_length, data + 28, 4);
uint32_t toc = rb->toc_offset;
memcpy(&rb->num_entries, data + toc, 4);
rb->entries = malloc(rb->num_entries * sizeof(Entry));
uint32_t offset = toc + 4;
for (uint32_t i = 0; i < rb->num_entries; i++) {
memcpy(rb->entries[i].name, data + offset, 32);
rb->entries[i].name[32] = '\0';
strrchr(rb->entries[i].name, '\0')[0] = '\0'; // Trim zeros
offset += 32;
memcpy(&rb->entries[i].length, data + offset, 4);
offset += 4;
memcpy(&rb->entries[i].offset, data + offset, 4);
offset += 4;
memcpy(&rb->entries[i].flag, data + offset, 4);
offset += 4;
}
free(data);
return rb;
}
void rb_print_properties(RBFile* rb) {
printf("magic: %u\n", rb->magic);
printf("version_major: %u\n", rb->version_major);
printf("version_minor: %u\n", rb->version_minor);
printf("identifier: %s\n", rb->identifier);
printf("year: %u\n", rb->year);
printf("month: %u\n", rb->month);
printf("day: %u\n", rb->day);
printf("toc_offset: %u\n", rb->toc_offset);
printf("file_length: %u\n", rb->file_length);
printf("num_entries: %u\n", rb->num_entries);
for (uint32_t i = 0; i < rb->num_entries; i++) {
printf("Entry %u: name=%s, length=%u, offset=%u, flag=%u\n",
i + 1, rb->entries[i].name, rb->entries[i].length, rb->entries[i].offset, rb->entries[i].flag);
}
}
void rb_write(RBFile* rb, const char* new_filepath, const char* original_filepath) {
// Basic copy; full impl rebuilds
FILE* src = fopen(original_filepath, "rb");
FILE* dst = fopen(new_filepath ? new_filepath : "example.rb.new", "wb");
uint8_t buf[4096];
size_t len;
while ((len = fread(buf, 1, sizeof(buf), src)) > 0) {
fwrite(buf, 1, len, dst);
}
fclose(src);
fclose(dst);
}
void rb_close(RBFile* rb) {
free(rb->entries);
free(rb);
}
// Example usage
// int main() {
// RBFile* rb = rb_open("example.rb");
// rb_print_properties(rb);
// rb_write(rb, NULL, "example.rb");
// rb_close(rb);
// return 0;
// }