laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/rdoff/rdfload.c

@@ -0,0 +1,213 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rdfload.c	RDOFF Object File loader library
+ */
+
+/*
+ * TODO: this has been modified from previous version only in very
+ * simplistic ways. Needs to be improved drastically, especially:
+ *   - support for more than the 2 standard segments
+ *   - support for segment relocations (hard to do in ANSI C)
+ */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "rdfload.h"
+#include "symtab.h"
+#include "collectn.h"
+
+extern int rdf_errno;
+
+rdfmodule *rdfload(const char *filename)
+{
+    rdfmodule *f;
+    int32_t bsslength = 0;
+    char *hdr;
+    rdfheaderrec *r;
+
+    f = nasm_malloc(sizeof(rdfmodule));
+    if (f == NULL) {
+        rdf_errno = RDF_ERR_NOMEM;
+        return NULL;
+    }
+
+    f->symtab = symtabNew();
+    if (!f->symtab) {
+        nasm_free(f);
+        rdf_errno = RDF_ERR_NOMEM;
+        return NULL;
+    }
+
+    /* open the file */
+    if (rdfopen(&(f->f), filename)) {
+        nasm_free(f);
+        return NULL;
+    }
+
+    /* read in text and data segments, and header */
+
+    f->t = nasm_malloc(f->f.seg[0].length);
+    f->d = nasm_malloc(f->f.seg[1].length);  /* BSS seg allocated later */
+    hdr = nasm_malloc(f->f.header_len);
+
+    if (!f->t || !f->d || !hdr) {
+        rdf_errno = RDF_ERR_NOMEM;
+        rdfclose(&f->f);
+        if (f->t)
+            nasm_free(f->t);
+        if (f->d)
+            nasm_free(f->d);
+        nasm_free(f);
+        nasm_free(hdr);
+        return NULL;
+    }
+
+    if (rdfloadseg(&f->f, RDOFF_HEADER, hdr) ||
+        rdfloadseg(&f->f, RDOFF_CODE, f->t) ||
+        rdfloadseg(&f->f, RDOFF_DATA, f->d)) {
+        rdfclose(&f->f);
+        nasm_free(f->t);
+        nasm_free(f->d);
+        nasm_free(f);
+        nasm_free(hdr);
+        return NULL;
+    }
+
+    rdfclose(&f->f);
+
+    /* Allocate BSS segment; step through header and count BSS records */
+
+    while ((r = rdfgetheaderrec(&f->f))) {
+        if (r->type == 5)
+            bsslength += r->b.amount;
+    }
+
+    f->b = nasm_malloc(bsslength);
+    if (bsslength && (!f->b)) {
+        nasm_free(f->t);
+        nasm_free(f->d);
+        nasm_free(f);
+        nasm_free(hdr);
+        rdf_errno = RDF_ERR_NOMEM;
+        return NULL;
+    }
+
+    rdfheaderrewind(&f->f);
+
+    f->textrel = (int32_t)(size_t)f->t;
+    f->datarel = (int32_t)(size_t)f->d;
+    f->bssrel  = (int32_t)(size_t)f->b;
+
+    return f;
+}
+
+int rdf_relocate(rdfmodule * m)
+{
+    rdfheaderrec *r;
+    Collection imports;
+    symtabEnt e;
+    int32_t rel;
+    uint8_t *seg;
+
+    rdfheaderrewind(&m->f);
+    collection_init(&imports);
+
+    while ((r = rdfgetheaderrec(&m->f))) {
+        switch (r->type) {
+        case 1:                /* Relocation record */
+
+            /* calculate relocation factor */
+
+            if (r->r.refseg == 0)
+                rel = m->textrel;
+            else if (r->r.refseg == 1)
+                rel = m->datarel;
+            else if (r->r.refseg == 2)
+                rel = m->bssrel;
+            else
+                /* We currently do not support load-time linkage.
+                   This should be added some time soon... */
+
+                return 1;       /* return error code */
+
+            if ((r->r.segment & 63) == 0)
+                seg = m->t;
+            else if ((r->r.segment & 63) == 1)
+                seg = m->d;
+            else
+                continue;       /* relocation not in a loaded segment */
+
+            /* it doesn't matter in this case that the code is non-portable,
+               as the entire concept of executing a module like this is
+               non-portable */
+            switch (r->r.length) {
+            case 1:
+                seg[r->r.offset] += (char)rel;
+                break;
+            case 2:
+                *(uint16_t *) (seg + r->r.offset) += (uint16_t) rel;
+                break;
+            case 4:
+                *(int32_t *)(seg + r->r.offset) += rel;
+                break;
+            }
+            break;
+
+        case 3:                /* export record - add to symtab */
+            e.segment = r->e.segment;
+            e.offset = r->e.offset + (e.segment == 0 ? m->textrel :     /* 0 -> code */
+                                      e.segment == 1 ? m->datarel :     /* 1 -> data */
+                                      m->bssrel);       /* 2 -> bss  */
+            e.flags = 0;
+            e.name = nasm_malloc(strlen(r->e.label) + 1);
+            if (!e.name)
+                return 1;
+
+            strcpy(e.name, r->e.label);
+            symtabInsert(m->symtab, &e);
+            break;
+
+        case 6:                /* segment relocation */
+            fprintf(stderr, "%s: segment relocation not supported by this "
+                    "loader\n", m->f.name);
+            return 1;
+        }
+    }
+    return 0;
+}

data/vendor/repo.or.cz/nasm/rdoff/rdfload.h

@@ -0,0 +1,29 @@
+/* rdfload.h	RDOFF Object File loader library header file
+ *
+ * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the license given in the file "LICENSE"
+ * distributed in the NASM archive.
+ *
+ * See the file 'rdfload.c' for special license information for this
+ * file.
+ */
+
+#ifndef RDOFF_RDFLOAD_H
+#define RDOFF_RDFLOAD_H 1
+
+#include "rdfutils.h"
+
+typedef struct RDFModuleStruct {
+    rdffile f;                  /* file structure */
+    uint8_t *t, *d, *b;   /* text, data, and bss segments */
+    uint32_t textrel;
+    uint32_t datarel;
+    uint32_t bssrel;
+    void *symtab;
+} rdfmodule;
+
+rdfmodule *rdfload(const char *filename);
+int rdf_relocate(rdfmodule * m);
+
+#endif

data/vendor/repo.or.cz/nasm/rdoff/rdfutils.h

@@ -0,0 +1,165 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rdfutils.h
+ *
+ * Internal header file for RDOFF utilities
+ */
+
+#ifndef RDOFF_RDFUTILS_H
+#define RDOFF_RDFUTILS_H 1
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "rdoff.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+typedef union RDFHeaderRec {
+    char type;                  /* invariant throughout all below */
+    struct GenericRec g;        /* type 0 */
+    struct RelocRec r;          /* type == 1 / 6 */
+    struct ImportRec i;         /* type == 2 / 7 */
+    struct ExportRec e;         /* type == 3 */
+    struct DLLRec d;            /* type == 4 */
+    struct BSSRec b;            /* type == 5 */
+    struct ModRec m;            /* type == 8 */
+    struct CommonRec c;         /* type == 10 */
+} rdfheaderrec;
+
+struct SegmentHeaderRec {
+    /* information from file */
+    uint16_t type;
+    uint16_t number;
+    uint16_t reserved;
+    int32_t length;
+
+    /* information built up here */
+    int32_t offset;
+    uint8_t *data;                 /* pointer to segment data if it exists in memory */
+};
+
+typedef struct RDFFileInfo {
+    FILE *fp;                   /* file descriptor; must be open to use this struct */
+    int rdoff_ver;              /* should be 1; any higher => not guaranteed to work */
+    int32_t header_len;
+    int32_t header_ofs;
+
+    uint8_t *header_loc;           /* keep location of header */
+    int32_t header_fp;             /* current location within header for reading */
+
+    struct SegmentHeaderRec seg[RDF_MAXSEGS];
+    int nsegs;
+
+    int32_t eof_offset;            /* offset of the first uint8_t beyond the end of this
+                                   module */
+
+    char *name;                 /* name of module in libraries */
+    int *refcount;              /* pointer to reference count on file, or NULL */
+} rdffile;
+
+#define BUF_BLOCK_LEN 4088      /* selected to match page size (4096)
+                                 * on 80x86 machines for efficiency */
+typedef struct memorybuffer {
+    int length;
+    uint8_t buffer[BUF_BLOCK_LEN];
+    struct memorybuffer *next;
+} memorybuffer;
+
+typedef struct {
+    memorybuffer *buf;          /* buffer containing header records */
+    int nsegments;              /* number of segments to be written */
+    int32_t seglength;             /* total length of all the segments */
+} rdf_headerbuf;
+
+/* segments used by RDOFF, understood by rdoffloadseg */
+#define RDOFF_CODE	0
+#define RDOFF_DATA	1
+#define RDOFF_HEADER	-1
+/* mask for 'segment' in relocation records to find if relative relocation */
+#define RDOFF_RELATIVEMASK 64
+/* mask to find actual segment value in relocation records */
+#define RDOFF_SEGMENTMASK 63
+
+extern int rdf_errno;
+
+/* rdf_errno can hold these error codes */
+enum {
+    /* 0 */ RDF_OK,
+    /* 1 */ RDF_ERR_OPEN,
+    /* 2 */ RDF_ERR_FORMAT,
+    /* 3 */ RDF_ERR_READ,
+    /* 4 */ RDF_ERR_UNKNOWN,
+    /* 5 */ RDF_ERR_HEADER,
+    /* 6 */ RDF_ERR_NOMEM,
+    /* 7 */ RDF_ERR_VER,
+    /* 8 */ RDF_ERR_RECTYPE,
+    /* 9 */ RDF_ERR_RECLEN,
+    /* 10 */ RDF_ERR_SEGMENT
+};
+
+/* library init */
+void rdoff_init(void);
+
+/* utility functions */
+int32_t translateint32_t(int32_t in);
+uint16_t translateint16_t(uint16_t in);
+char *translatesegmenttype(uint16_t type);
+
+/* RDOFF file manipulation functions */
+int rdfopen(rdffile * f, const char *name);
+int rdfopenhere(rdffile * f, FILE * fp, int *refcount, const char *name);
+int rdfclose(rdffile * f);
+int rdffindsegment(rdffile * f, int segno);
+int rdfloadseg(rdffile * f, int segment, void *buffer);
+rdfheaderrec *rdfgetheaderrec(rdffile * f);     /* returns static storage */
+void rdfheaderrewind(rdffile * f);      /* back to start of header */
+void rdfperror(const char *app, const char *name);
+
+/* functions to write a new RDOFF header to a file -
+   use rdfnewheader to allocate a header, rdfaddheader to add records to it,
+   rdfaddsegment to notify the header routines that a segment exists, and
+   to tell it how int32_t the segment will be.
+   rdfwriteheader to write the file id, object length, and header
+   to a file, and then rdfdoneheader to dispose of the header */
+
+rdf_headerbuf *rdfnewheader(void);
+int rdfaddheader(rdf_headerbuf * h, rdfheaderrec * r);
+int rdfaddsegment(rdf_headerbuf * h, int32_t seglength);
+int rdfwriteheader(FILE * fp, rdf_headerbuf * h);
+void rdfdoneheader(rdf_headerbuf * h);
+
+#endif                          /* RDOFF_RDFUTILS_H */

data/vendor/repo.or.cz/nasm/rdoff/rdlar.c

@@ -0,0 +1,492 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rdlar.c - new librarian/archiver for RDOFF2.
+ */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "rdlar.h"
+
+#define PROGRAM_VERSION "0.1"
+
+/** Constants **/
+const char commands[] = "adnrtx";
+const char modifiers[] = "cflouvV";
+
+/** Global variables **/
+char *progname = "rdlar";
+char **_argv = NULL;
+struct {
+    bool createok;
+    bool usefname;
+    bool align;
+    bool odate;
+    bool fresh;
+    int verbose;
+} options = {
+0, 0, 0, 0, 0, 0};
+
+#define _ENDIANNESS 0           /* 0 for little, 1 for big */
+
+/*
+ * Convert int32_t to little endian (if we were compiled on big-endian machine)
+ */
+static void int32_ttolocal(int32_t *l)
+{
+#if _ENDIANNESS
+    uint8_t t;
+    uint8_t *p = (uint8_t *)l;
+
+    t = p[0];
+    p[0] = p[3];
+    p[3] = t;
+    t = p[1];
+    p[1] = p[2];
+    p[2] = p[1];
+#endif
+}
+
+/*
+ * Print version information
+ */
+void show_version(void)
+{
+    puts("New RDOFF2 librarian/archiver, version " PROGRAM_VERSION);
+}
+
+/*
+ * Print usage instructions
+ */
+void usage(void)
+{
+    printf("Usage:  %s [-]{%s}[%s] libfile [module-name] [files]\n",
+           progname, commands, modifiers);
+    puts(" commands:\n"
+         "  a            - add module(s) to the library\n"
+         "  d            - delete module(s) from the library\n"
+         "  n            - create the library\n"
+         "  r            - replace module(s)\n"
+         "  t            - display contents of library\n"
+         "  x            - extract module(s)\n"
+         " command specific modifiers:\n"
+         "  o            - preserve original dates\n"
+         "  u            - only replace modules that are newer than library contents\n"
+         " generic modifiers:\n"
+         "  c            - do not warn if the library had to be created\n"
+         "  f            - use file name as a module name\n"
+         "  v            - be verbose\n"
+         "  V            - display version information");
+}
+
+/*
+ * Print an error message and exit
+ */
+void error_exit(int errcode, bool useperror, const char *fmt, ...)
+{
+    va_list ap;
+
+    fprintf(stderr, "%s: ", progname);
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    putc('\n', stderr);
+    if (useperror)
+        perror(progname);
+    exit(errcode);
+}
+
+/*
+ * Fill in and write a header
+ */
+void put_header(struct rdlm_hdr *hdr, FILE * libfp, char *modname)
+{
+    int n = 0;
+
+    hdr->hdrsize = sizeof(*hdr);
+    if (modname)
+        hdr->hdrsize += (n = strlen(modname) + 1);
+    if (libfp == NULL)
+        return;
+    if (fwrite(hdr, 1, sizeof(*hdr), libfp) != sizeof(*hdr) ||
+        (modname && (fwrite(modname, 1, n, libfp) != n)))
+        error_exit(3, true, "could not write header");
+}
+
+/*
+ * Copy n bytes from one file to another and return last character read.
+ */
+char copybytes(FILE * fp, FILE * fp2, int n)
+{
+    int i, t = 0;
+
+    for (i = 0; i < n; i++) {
+        t = fgetc(fp);
+        if (t == EOF)
+            error_exit(1, false, "premature end of file in '%s'",
+                       _argv[2]);
+        if (fp2)
+            if (fputc(t, fp2) == EOF)
+                error_exit(1, false, "write error");
+    }
+    return (char)t;
+}
+
+/*
+ * Copy uint32_t from one file to another.
+ * Return local presentation of int32_t.
+ */
+int32_t copyint32_t(FILE * fp, FILE * fp2)
+{
+    int32_t l;
+    int i, t;
+    uint8_t *p = (uint8_t *)&l;
+
+    for (i = 0; i < 4; i++) {
+        t = fgetc(fp);
+        if (t == EOF)
+            error_exit(1, false, "premature end of file in '%s'",
+                       _argv[2]);
+        if (fp2)
+            if (fputc(t, fp2) == EOF)
+                error_exit(1, false, "write error");
+        *p++ = t;
+    }
+    int32_ttolocal(&l);
+    return l;
+}
+
+/*
+ * Create a new library
+ */
+int create_library(char *libname)
+{
+    FILE *libfp;
+    struct rdlm_hdr hdr;
+
+    hdr.magic = RDLAMAG;
+    hdr.hdrsize = 0;
+    hdr.date = time(NULL);
+    hdr.owner = getuid();
+    hdr.group = getgid();
+    hdr.mode = umask(022);
+    hdr.size = 0;
+
+    libfp = fopen(libname, "wb");
+    if (!libfp)
+        error_exit(1, true, "could not open '%s'\n", libname);
+
+    /* Write library header */
+    put_header(&hdr, libfp, NULL);
+
+    fclose(libfp);
+    return true;
+}
+
+/*
+ * Add a module to the library
+ */
+int add_module(FILE * libfp, const char *fname, char *modname)
+{
+    FILE *modfp;
+    struct rdlm_hdr hdr = { RDLMMAG, 0, 0, 0, 0, 0, 0 };
+    struct stat finfo;
+    int i;
+
+    if (options.verbose)
+        fprintf(stderr, "adding module %s\n", modname);
+
+    /* Initialize some fields in the module header */
+    if (stat(fname, &finfo) < 0)
+        error_exit(1, true, "could not stat '%s'", fname);
+    hdr.date = finfo.st_mtime;
+    hdr.owner = finfo.st_uid;
+    hdr.group = finfo.st_gid;
+    hdr.size = finfo.st_size;
+
+    modfp = fopen(fname, "rb");
+    if (!modfp)
+        error_exit(1, true, "could not open '%s'", fname);
+
+    /* Write module header */
+    put_header(&hdr, libfp, modname);
+
+    /* Put the module itself */
+    while (!feof(modfp)) {
+        i = fgetc(modfp);
+        if (i == EOF)
+            break;
+        if (fputc(i, libfp) == EOF)
+            error_exit(1, false, "write error");
+    }
+
+    fclose(modfp);
+    return true;
+}
+
+/*
+ * Main
+ */
+int main(int argc, char **argv)
+{
+    FILE *libfp, *tmpfp, *modfp = NULL;
+    struct stat finfo;
+    struct rdlm_hdr hdr;
+    char buf[MAXMODNAMELEN], *p = NULL;
+    char c;
+    int i;
+
+    progname = argv[0];
+    _argv = argv;
+
+    if (argc < 2) {
+        usage();
+        exit(1);
+    }
+
+    rdoff_init();
+
+    /* Check whether some modifiers were specified */
+    for (i = 1; i < strlen(argv[1]); i++) {
+        switch (c = argv[1][i]) {
+        case 'c':
+            options.createok = true;
+            break;
+        case 'f':
+            options.usefname = true;
+            break;
+        case 'l':
+            options.align = true;
+            break;
+        case 'o':
+            options.odate = true;
+            break;
+        case 'u':
+            options.fresh = true;
+            break;
+        case 'v':
+            options.verbose++;
+            break;
+        case 'V':
+            show_version();
+            exit(0);
+        default:
+            if (strchr(commands, c) == NULL)
+                error_exit(2, false, "invalid command or modifier '%c'",
+                           c);
+        }
+    }
+
+    if (argc < 3)
+        error_exit(2, false, "missing library name");
+
+    /* Process the command */
+    if (argv[1][0] == '-')
+        argv[1]++;
+    switch (c = argv[1][0]) {
+    case 'a':                  /* add a module */
+        if (argc < 4 || (!options.usefname && argc != 5))
+            error_exit(2, false, "invalid number of arguments");
+
+        /* Check if a library already exists. If not - create it */
+        if (access(argv[2], F_OK) < 0) {
+            if (!options.createok)
+                fprintf(stderr, "creating library %s\n", argv[2]);
+            create_library(argv[2]);
+        }
+
+        libfp = fopen(argv[2], "ab");
+        if (!libfp)
+            error_exit(1, true, "could not open '%s'", argv[2]);
+
+        if (!options.usefname)
+            add_module(libfp, argv[4], argv[3]);
+        else
+            for (i = 3; i < argc; i++)
+                add_module(libfp, argv[i], argv[i]);
+
+        fclose(libfp);
+        break;
+
+    case 'n':                  /* create library */
+        create_library(argv[2]);
+        break;
+
+    case 'x':                  /* extract module(s) */
+        if (!options.usefname)
+            argc--;
+        if (argc < 4)
+            error_exit(2, false, "required parameter missing");
+        p = options.usefname ? argv[3] : argv[4];
+    case 't':                  /* list library contents */
+        libfp = fopen(argv[2], "rb");
+        if (!libfp)
+            error_exit(1, true, "could not open '%s'\n", argv[2]);
+
+        /* Read library header */
+        if (fread(&hdr, 1, sizeof(hdr), libfp) != sizeof(hdr) ||
+            hdr.magic != RDLAMAG)
+            error_exit(1, false, "invalid library format");
+
+        /* Walk through the library looking for requested module */
+        while (!feof(libfp)) {
+            /* Read module header */
+            i = fread(&hdr, 1, sizeof(hdr), libfp);
+            if (feof(libfp))
+                break;
+            if (i != sizeof(hdr) || hdr.magic != RDLMMAG)
+                error_exit(1, false, "invalid module header");
+            /* Read module name */
+            i = hdr.hdrsize - sizeof(hdr);
+            if (i > sizeof(buf) || fread(buf, 1, i, libfp) != i)
+                error_exit(1, false, "invalid module name");
+            if (c == 'x') {
+                /* Check against desired name */
+                if (!strcmp(buf, argv[3])) {
+                    if (options.verbose)
+                        fprintf(stderr,
+                                "extracting module %s to file %s\n", buf,
+                                p);
+                    modfp = fopen(p, "wb");
+                    if (!modfp)
+                        error_exit(1, true, "could not open '%s'", p);
+                }
+            } else {
+                printf("%-40s ", buf);
+                if (options.verbose) {
+                    printf("%ld bytes", hdr.size);
+                }
+                putchar('\n');
+            }
+
+            copybytes(libfp, modfp, hdr.size);
+            if (modfp)
+                break;
+        }
+
+        fclose(libfp);
+        if (modfp)
+            fclose(modfp);
+        else if (c == 'x')
+            error_exit(1, false, "module '%s' not found in '%s'",
+                       argv[3], argv[2]);
+        break;
+
+    case 'r':                  /* replace module(s) */
+        argc--;
+        if (stat(argv[4], &finfo) < 0)
+            error_exit(1, true, "could not stat '%s'", argv[4]);
+    case 'd':                  /* delete module(s) */
+        if (argc < 4)
+            error_exit(2, false, "required parameter missing");
+
+        libfp = fopen(argv[2], "rb");
+        if (!libfp)
+            error_exit(1, true, "could not open '%s'", argv[2]);
+
+        /* Copy the library into a temporary file */
+        tmpfp = tmpfile();
+        if (!tmpfp)
+            error_exit(1, true, "could not open temporary file");
+
+        stat(argv[2], &finfo);
+        copybytes(libfp, tmpfp, finfo.st_size);
+        rewind(tmpfp);
+        freopen(argv[2], "wb", libfp);
+
+        /* Read library header and write it to a new file */
+        if (fread(&hdr, 1, sizeof(hdr), tmpfp) != sizeof(hdr) ||
+            hdr.magic != RDLAMAG)
+            error_exit(1, false, "invalid library format");
+        put_header(&hdr, libfp, NULL);
+
+        /* Walk through the library looking for requested module */
+        while (!feof(tmpfp)) {
+            /* Read module header */
+            if (fread(&hdr, 1, sizeof(hdr), tmpfp) != sizeof(hdr) ||
+                hdr.magic != RDLMMAG)
+                error_exit(1, false, "invalid module header");
+            /* Read module name */
+            i = hdr.hdrsize - sizeof(hdr);
+            if (i > sizeof(buf) || fread(buf, 1, i, tmpfp) != i)
+                error_exit(1, false, "invalid module name");
+            /* Check against desired name */
+            if (!strcmp(buf, argv[3]) &&
+                (c == 'd' || !options.odate
+                 || finfo.st_mtime <= hdr.date)) {
+                if (options.verbose)
+                    fprintf(stderr, "deleting module %s\n", buf);
+                fseek(tmpfp, hdr.size, SEEK_CUR);
+                break;
+            } else {
+                put_header(&hdr, libfp, buf);
+                copybytes(tmpfp, libfp, hdr.size);
+            }
+        }
+
+        if (c == 'r') {
+            /* Copy new module into library */
+            p = options.usefname ? argv[4] : argv[3];
+            add_module(libfp, argv[4], p);
+        }
+
+        /* Copy rest of library if any */
+        while (!feof(tmpfp)) {
+            if ((i = fgetc(tmpfp)) == EOF)
+                break;
+
+            if (fputc(i, libfp) == EOF)
+                error_exit(1, false, "write error");
+        }
+
+        fclose(libfp);
+        fclose(tmpfp);
+        break;
+
+    default:
+        error_exit(2, false, "invalid command '%c'\n", c);
+    }
+
+    return 0;
+}