xmlcatalog.c

Go to the documentation of this file.

/*
 * xmlcatalog.c : a small utility program to handle XML catalogs
 *
 * See Copyright for the status of this software.
 *
 * daniel@veillard.com
 */
 
#include "libxml.h"
 
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
 
#ifdef HAVE_LIBREADLINE
#include <readline/readline.h>
#ifdef HAVE_LIBHISTORY
#include <readline/history.h>
#endif
#endif
 
#include <libxml/xmlmemory.h>
#include <libxml/uri.h>
#include <libxml/catalog.h>
#include <libxml/parser.h>
#include <libxml/globals.h>
 
#if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
static int shell = 0;
static int sgml = 0;
static int noout = 0;
static int create = 0;
static int add = 0;
static int del = 0;
static int convert = 0;
static int no_super_update = 0;
static int verbose = 0;
static char *filename = NULL;
 
 
#ifndef XML_SGML_DEFAULT_CATALOG
#define XML_SGML_DEFAULT_CATALOG SYSCONFDIR "/sgml/catalog"
#endif
 
/************************************************************************
 *                                  *
 *          Shell Interface                 *
 *                                  *
 ************************************************************************/
static char *
xmlShellReadline(const char *prompt) {
#ifdef HAVE_LIBREADLINE
    char *line_read;
 
    /* Get a line from the user. */
    line_read = readline (prompt);
 
    /* If the line has any text in it, save it on the history. */
    if (line_read && *line_read)
    add_history (line_read);
 
    return (line_read);
#else
    char line_read[501];
    char *ret;
    int len;
 
    if (prompt != NULL)
    fprintf(stdout, "%s", prompt);
    fflush(stdout);
    if (!fgets(line_read, 500, stdin))
        return(NULL);
    line_read[500] = 0;
    len = strlen(line_read);
    ret = (char *) malloc(len + 1);
    if (ret != NULL) {
    memcpy (ret, line_read, len + 1);
    }
    return(ret);
#endif
}
 
static void usershell(void) {
    char *cmdline = NULL, *cur;
    int nbargs;
    char command[100];
    char arg[400];
    char *argv[20];
    int i, ret;
    xmlChar *ans;
 
    while (1) {
    cmdline = xmlShellReadline("> ");
    if (cmdline == NULL)
        return;
 
    /*
     * Parse the command itself
     */
    cur = cmdline;
    nbargs = 0;
    while ((*cur == ' ') || (*cur == '\t')) cur++;
    i = 0;
    while ((*cur != ' ') && (*cur != '\t') &&
           (*cur != '\n') && (*cur != '\r')) {
        if (*cur == 0)
        break;
        command[i++] = *cur++;
    }
    command[i] = 0;
    if (i == 0) {
        free(cmdline);
        continue;
    }
 
    /*
     * Parse the argument string
     */
    memset(arg, 0, sizeof(arg));
    while ((*cur == ' ') || (*cur == '\t')) cur++;
    i = 0;
    while ((*cur != '\n') && (*cur != '\r') && (*cur != 0)) {
        if (*cur == 0)
        break;
        arg[i++] = *cur++;
    }
    arg[i] = 0;
 
    /*
     * Parse the arguments
     */
    i = 0;
    nbargs = 0;
    cur = arg;
    memset(argv, 0, sizeof(argv));
    while (*cur != 0) {
        while ((*cur == ' ') || (*cur == '\t')) cur++;
        if (*cur == '\'') {
        cur++;
        argv[i] = cur;
        while ((*cur != 0) && (*cur != '\'')) cur++;
        if (*cur == '\'') {
            *cur = 0;
            nbargs++;
            i++;
            cur++;
        }
        } else if (*cur == '"') {
        cur++;
        argv[i] = cur;
        while ((*cur != 0) && (*cur != '"')) cur++;
        if (*cur == '"') {
            *cur = 0;
            nbargs++;
            i++;
            cur++;
        }
        } else {
        argv[i] = cur;
        while ((*cur != 0) && (*cur != ' ') && (*cur != '\t'))
            cur++;
        *cur = 0;
        nbargs++;
        i++;
        cur++;
        }
    }
 
    /*
     * start interpreting the command
     */
    if (!strcmp(command, "exit") ||
        !strcmp(command, "quit") ||
        !strcmp(command, "bye")) {
        free(cmdline);
        break;
    }
 
    if (!strcmp(command, "public")) {
        if (nbargs != 1) {
        printf("public requires 1 arguments\n");
        } else {
        ans = xmlCatalogResolvePublic((const xmlChar *) argv[0]);
        if (ans == NULL) {
            printf("No entry for PUBLIC %s\n", argv[0]);
        } else {
            printf("%s\n", (char *) ans);
            xmlFree(ans);
        }
        }
    } else if (!strcmp(command, "system")) {
        if (nbargs != 1) {
        printf("system requires 1 arguments\n");
        } else {
        ans = xmlCatalogResolveSystem((const xmlChar *) argv[0]);
        if (ans == NULL) {
            printf("No entry for SYSTEM %s\n", argv[0]);
        } else {
            printf("%s\n", (char *) ans);
            xmlFree(ans);
        }
        }
    } else if (!strcmp(command, "add")) {
        if ((nbargs != 3) && (nbargs != 2)) {
        printf("add requires 2 or 3 arguments\n");
        } else {
        if (argv[2] == NULL)
        ret = xmlCatalogAdd(BAD_CAST argv[0], NULL,
                    BAD_CAST argv[1]);
        else
            ret = xmlCatalogAdd(BAD_CAST argv[0], BAD_CAST argv[1],
                    BAD_CAST argv[2]);
        if (ret != 0)
            printf("add command failed\n");
        }
    } else if (!strcmp(command, "del")) {
        if (nbargs != 1) {
        printf("del requires 1\n");
        } else {
        ret = xmlCatalogRemove(BAD_CAST argv[0]);
        if (ret <= 0)
            printf("del command failed\n");
 
        }
    } else if (!strcmp(command, "resolve")) {
        if (nbargs != 2) {
        printf("resolve requires 2 arguments\n");
        } else {
        ans = xmlCatalogResolve(BAD_CAST argv[0],
                            BAD_CAST argv[1]);
        if (ans == NULL) {
            printf("Resolver failed to find an answer\n");
        } else {
            printf("%s\n", (char *) ans);
            xmlFree(ans);
        }
        }
    } else if (!strcmp(command, "dump")) {
        if (nbargs != 0) {
        printf("dump has no arguments\n");
        } else {
        xmlCatalogDump(stdout);
        }
    } else if (!strcmp(command, "debug")) {
        if (nbargs != 0) {
        printf("debug has no arguments\n");
        } else {
        verbose++;
        xmlCatalogSetDebug(verbose);
        }
    } else if (!strcmp(command, "quiet")) {
        if (nbargs != 0) {
        printf("quiet has no arguments\n");
        } else {
        if (verbose > 0)
            verbose--;
        xmlCatalogSetDebug(verbose);
        }
    } else {
        if (strcmp(command, "help")) {
        printf("Unrecognized command %s\n", command);
        }
        printf("Commands available:\n");
        printf("\tpublic PublicID: make a PUBLIC identifier lookup\n");
        printf("\tsystem SystemID: make a SYSTEM identifier lookup\n");
        printf("\tresolve PublicID SystemID: do a full resolver lookup\n");
        printf("\tadd 'type' 'orig' 'replace' : add an entry\n");
        printf("\tdel 'values' : remove values\n");
        printf("\tdump: print the current catalog state\n");
        printf("\tdebug: increase the verbosity level\n");
        printf("\tquiet: decrease the verbosity level\n");
        printf("\texit:  quit the shell\n");
    }
    free(cmdline); /* not xmlFree here ! */
    }
}
 
/************************************************************************
 *                                  *
 *          Main                        *
 *                                  *
 ************************************************************************/
static void usage(const char *name) {
    /* split into 2 printf's to avoid overly long string (gcc warning) */
    printf("\
Usage : %s [options] catalogfile entities...\n\
\tParse the catalog file (void specification possibly expressed as \"\"\n\
\tappoints the default system one) and query it for the entities\n\
\t--sgml : handle SGML Super catalogs for --add and --del\n\
\t--shell : run a shell allowing interactive queries\n\
\t--create : create a new catalog\n\
\t--add 'type' 'orig' 'replace' : add an XML entry\n\
\t--add 'entry' : add an SGML entry\n", name);
    printf("\
\t--del 'values' : remove values\n\
\t--noout: avoid dumping the result on stdout\n\
\t         used with --add or --del, it saves the catalog changes\n\
\t         and with --sgml it automatically updates the super catalog\n\
\t--no-super-update: do not update the SGML super catalog\n\
\t-v --verbose : provide debug information\n");
}
int main(int argc, char **argv) {
    int i;
    int ret;
    int exit_value = 0;
 
 
    if (argc <= 1) {
    usage(argv[0]);
    return(1);
    }
 
    LIBXML_TEST_VERSION
    for (i = 1; i < argc ; i++) {
    if (!strcmp(argv[i], "-"))
        break;
 
    if (argv[i][0] != '-')
        break;
    if ((!strcmp(argv[i], "-verbose")) ||
        (!strcmp(argv[i], "-v")) ||
        (!strcmp(argv[i], "--verbose"))) {
        verbose++;
        xmlCatalogSetDebug(verbose);
    } else if ((!strcmp(argv[i], "-noout")) ||
        (!strcmp(argv[i], "--noout"))) {
            noout = 1;
    } else if ((!strcmp(argv[i], "-shell")) ||
        (!strcmp(argv[i], "--shell"))) {
        shell++;
            noout = 1;
    } else if ((!strcmp(argv[i], "-sgml")) ||
        (!strcmp(argv[i], "--sgml"))) {
        sgml++;
    } else if ((!strcmp(argv[i], "-create")) ||
        (!strcmp(argv[i], "--create"))) {
        create++;
    } else if ((!strcmp(argv[i], "-convert")) ||
        (!strcmp(argv[i], "--convert"))) {
        convert++;
    } else if ((!strcmp(argv[i], "-no-super-update")) ||
        (!strcmp(argv[i], "--no-super-update"))) {
        no_super_update++;
    } else if ((!strcmp(argv[i], "-add")) ||
        (!strcmp(argv[i], "--add"))) {
        if (sgml)
        i += 2;
        else
        i += 3;
        add++;
    } else if ((!strcmp(argv[i], "-del")) ||
        (!strcmp(argv[i], "--del"))) {
        i += 1;
        del++;
    } else {
        fprintf(stderr, "Unknown option %s\n", argv[i]);
        usage(argv[0]);
        return(1);
    }
    }
 
    for (i = 1; i < argc; i++) {
    if ((!strcmp(argv[i], "-add")) ||
        (!strcmp(argv[i], "--add"))) {
        if (sgml)
        i += 2;
        else
        i += 3;
        continue;
    } else if ((!strcmp(argv[i], "-del")) ||
        (!strcmp(argv[i], "--del"))) {
        i += 1;
 
        /* No catalog entry specified */
        if (i == argc || (sgml && i + 1 == argc)) {
        fprintf(stderr, "No catalog entry specified to remove from\n");
        usage (argv[0]);
        return(1);
        }
 
        continue;
    } else if (argv[i][0] == '-')
        continue;
 
    if (filename == NULL && argv[i][0] == '\0') {
        /* Interpret empty-string catalog specification as
           a shortcut for a default system catalog. */
        xmlInitializeCatalog();
    } else {
        filename = argv[i];
        ret = xmlLoadCatalog(argv[i]);
        if ((ret < 0) && (create)) {
        xmlCatalogAdd(BAD_CAST "catalog", BAD_CAST argv[i], NULL);
        }
    }
    break;
    }
 
    if (convert)
        ret = xmlCatalogConvert();
 
    if ((add) || (del)) {
    for (i = 1; i < argc ; i++) {
        if (!strcmp(argv[i], "-"))
        break;
 
        if (argv[i][0] != '-')
        continue;
        if (strcmp(argv[i], "-add") && strcmp(argv[i], "--add") &&
        strcmp(argv[i], "-del") && strcmp(argv[i], "--del"))
        continue;
 
        if (sgml) {
        /*
         * Maintenance of SGML catalogs.
         */
        xmlCatalogPtr catal = NULL;
        xmlCatalogPtr super = NULL;
 
        catal = xmlLoadSGMLSuperCatalog(argv[i + 1]);
 
        if ((!strcmp(argv[i], "-add")) ||
            (!strcmp(argv[i], "--add"))) {
            if (catal == NULL)
            catal = xmlNewCatalog(1);
            xmlACatalogAdd(catal, BAD_CAST "CATALOG",
                     BAD_CAST argv[i + 2], NULL);
 
            if (!no_super_update) {
            super = xmlLoadSGMLSuperCatalog(XML_SGML_DEFAULT_CATALOG);
            if (super == NULL)
                super = xmlNewCatalog(1);
 
            xmlACatalogAdd(super, BAD_CAST "CATALOG",
                         BAD_CAST argv[i + 1], NULL);
            }
        } else {
            if (catal != NULL)
            ret = xmlACatalogRemove(catal, BAD_CAST argv[i + 2]);
            else
            ret = -1;
            if (ret < 0) {
            fprintf(stderr, "Failed to remove entry from %s\n",
                argv[i + 1]);
            exit_value = 1;
            }
            if ((!no_super_update) && (noout) && (catal != NULL) &&
            (xmlCatalogIsEmpty(catal))) {
            super = xmlLoadSGMLSuperCatalog(
                   XML_SGML_DEFAULT_CATALOG);
            if (super != NULL) {
                ret = xmlACatalogRemove(super,
                    BAD_CAST argv[i + 1]);
                if (ret < 0) {
                fprintf(stderr,
                    "Failed to remove entry from %s\n",
                    XML_SGML_DEFAULT_CATALOG);
                exit_value = 1;
                }
            }
            }
        }
        if (noout) {
            FILE *out;
 
            if (xmlCatalogIsEmpty(catal)) {
            remove(argv[i + 1]);
            } else {
            out = fopen(argv[i + 1], "w");
            if (out == NULL) {
                fprintf(stderr, "could not open %s for saving\n",
                    argv[i + 1]);
                exit_value = 2;
                noout = 0;
            } else {
                xmlACatalogDump(catal, out);
                fclose(out);
            }
            }
            if (!no_super_update && super != NULL) {
            if (xmlCatalogIsEmpty(super)) {
                remove(XML_SGML_DEFAULT_CATALOG);
            } else {
                out = fopen(XML_SGML_DEFAULT_CATALOG, "w");
                if (out == NULL) {
                fprintf(stderr,
                    "could not open %s for saving\n",
                    XML_SGML_DEFAULT_CATALOG);
                exit_value = 2;
                noout = 0;
                } else {
 
                xmlACatalogDump(super, out);
                fclose(out);
                }
            }
            }
        } else {
            xmlACatalogDump(catal, stdout);
        }
        i += 2;
        } else {
        if ((!strcmp(argv[i], "-add")) ||
            (!strcmp(argv[i], "--add"))) {
            if ((argv[i + 3] == NULL) || (argv[i + 3][0] == 0))
                ret = xmlCatalogAdd(BAD_CAST argv[i + 1], NULL,
                        BAD_CAST argv[i + 2]);
            else
                ret = xmlCatalogAdd(BAD_CAST argv[i + 1],
                        BAD_CAST argv[i + 2],
                        BAD_CAST argv[i + 3]);
            if (ret != 0) {
                printf("add command failed\n");
                exit_value = 3;
            }
            i += 3;
        } else if ((!strcmp(argv[i], "-del")) ||
            (!strcmp(argv[i], "--del"))) {
            ret = xmlCatalogRemove(BAD_CAST argv[i + 1]);
            if (ret < 0) {
            fprintf(stderr, "Failed to remove entry %s\n",
                argv[i + 1]);
            exit_value = 1;
            }
            i += 1;
        }
        }
    }
 
    } else if (shell) {
    usershell();
    } else {
    for (i++; i < argc; i++) {
        xmlURIPtr uri;
        xmlChar *ans;
 
        uri = xmlParseURI(argv[i]);
        if (uri == NULL) {
        ans = xmlCatalogResolvePublic((const xmlChar *) argv[i]);
        if (ans == NULL) {
            printf("No entry for PUBLIC %s\n", argv[i]);
            exit_value = 4;
        } else {
            printf("%s\n", (char *) ans);
            xmlFree(ans);
        }
        } else {
                xmlFreeURI(uri);
        ans = xmlCatalogResolveSystem((const xmlChar *) argv[i]);
        if (ans == NULL) {
            printf("No entry for SYSTEM %s\n", argv[i]);
            ans = xmlCatalogResolveURI ((const xmlChar *) argv[i]);
            if (ans == NULL) {
            printf ("No entry for URI %s\n", argv[i]);
                exit_value = 4;
            } else {
                printf("%s\n", (char *) ans);
            xmlFree (ans);
            }
        } else {
            printf("%s\n", (char *) ans);
            xmlFree(ans);
        }
        }
    }
    }
    if ((!sgml) && ((add) || (del) || (create) || (convert))) {
    if (noout && filename && *filename) {
        FILE *out;
 
        out = fopen(filename, "w");
        if (out == NULL) {
        fprintf(stderr, "could not open %s for saving\n", filename);
        exit_value = 2;
        noout = 0;
        } else {
        xmlCatalogDump(out);
        }
    } else {
        xmlCatalogDump(stdout);
    }
    }
 
    /*
     * Cleanup and check for memory leaks
     */
    xmlCleanupParser();
    xmlMemoryDump();
    return(exit_value);
}
#else
int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
    fprintf(stderr, "libxml was not compiled with catalog and output support\n");
    return(1);
}
#endif