| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * httxt2dbm.c: simple program for converting RewriteMap text files to DBM |
| * Rewrite databases for the Apache HTTP server |
| * |
| */ |
| |
| #include "apr.h" |
| #include "apr_lib.h" |
| #include "apr_strings.h" |
| #include "apr_file_io.h" |
| #include "apr_file_info.h" |
| #include "apr_pools.h" |
| #include "apr_getopt.h" |
| #include "apu.h" |
| #include "apr_dbm.h" |
| |
| #if APR_HAVE_STDLIB_H |
| #include <stdlib.h> /* for atexit() */ |
| #endif |
| |
| static const char *input; |
| static const char *output; |
| static const char *format; |
| static const char *shortname; |
| static apr_file_t *errfile; |
| static int verbose; |
| |
| /* From mod_rewrite.c */ |
| #ifndef REWRITE_MAX_TXT_MAP_LINE |
| #define REWRITE_MAX_TXT_MAP_LINE 1024 |
| #endif |
| |
| #define NL APR_EOL_STR |
| |
| #define AVAIL "available" |
| #define UNAVAIL "unavailable" |
| |
| static void usage(void) |
| { |
| const char *have_sdbm; |
| const char *have_gdbm; |
| const char *have_ndbm; |
| const char *have_db; |
| |
| #if APU_HAVE_SDBM |
| have_sdbm = AVAIL; |
| #else |
| have_sdbm = UNAVAIL; |
| #endif |
| #if APU_HAVE_GDBM |
| have_gdbm = AVAIL; |
| #else |
| have_gdbm = UNAVAIL; |
| #endif |
| #if APU_HAVE_NDBM |
| have_ndbm = AVAIL; |
| #else |
| have_ndbm = UNAVAIL; |
| #endif |
| #if APU_HAVE_DB |
| have_db = AVAIL; |
| #else |
| have_db = UNAVAIL; |
| #endif |
| |
| apr_file_printf(errfile, |
| "%s -- Program to Create DBM Files for use by RewriteMap" NL |
| "Usage: %s [-v] [-f format] -i SOURCE_TXT -o OUTPUT_DBM" NL |
| NL |
| "Options: " NL |
| " -v More verbose output" NL |
| NL |
| " -i Source Text File. If '-', use stdin." NL |
| NL |
| " -o Output DBM." NL |
| NL |
| " -f DBM Format. If not specified, will use the APR Default." NL |
| " GDBM for GDBM files (%s)" NL |
| " SDBM for SDBM files (%s)" NL |
| " DB for berkeley DB files (%s)" NL |
| " NDBM for NDBM files (%s)" NL |
| " default for the default DBM type" NL |
| NL, |
| shortname, |
| shortname, |
| have_gdbm, |
| have_sdbm, |
| have_db, |
| have_ndbm); |
| } |
| |
| |
| static apr_status_t to_dbm(apr_dbm_t *dbm, apr_file_t *fp, apr_pool_t *pool) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| char line[REWRITE_MAX_TXT_MAP_LINE + 1]; /* +1 for \0 */ |
| apr_datum_t dbmkey; |
| apr_datum_t dbmval; |
| apr_pool_t* p; |
| |
| apr_pool_create(&p, pool); |
| |
| while (apr_file_gets(line, sizeof(line), fp) == APR_SUCCESS) { |
| char *c, *value; |
| |
| if (*line == '#' || apr_isspace(*line)) { |
| continue; |
| } |
| |
| c = line; |
| |
| while (*c && !apr_isspace(*c)) { |
| ++c; |
| } |
| |
| if (!*c) { |
| /* no value. solid line of data. */ |
| continue; |
| } |
| |
| dbmkey.dptr = apr_pstrmemdup(p, line, c - line); |
| dbmkey.dsize = (c - line); |
| |
| while (apr_isspace(*c)) { |
| ++c; |
| } |
| |
| if (!*c) { |
| apr_pool_clear(p); |
| continue; |
| } |
| |
| value = c; |
| |
| while (*c && !apr_isspace(*c)) { |
| ++c; |
| } |
| |
| dbmval.dptr = apr_pstrmemdup(p, value, c - value); |
| dbmval.dsize = (c - value); |
| |
| if (verbose) { |
| apr_file_printf(errfile, " '%s' -> '%s'" NL, |
| dbmkey.dptr, dbmval.dptr); |
| } |
| |
| rv = apr_dbm_store(dbm, dbmkey, dbmval); |
| |
| apr_pool_clear(p); |
| |
| if (rv != APR_SUCCESS) { |
| break; |
| } |
| } |
| |
| return rv; |
| } |
| |
| int main(int argc, const char *const argv[]) |
| { |
| apr_pool_t *pool; |
| apr_status_t rv = APR_SUCCESS; |
| apr_getopt_t *opt; |
| const char *opt_arg; |
| char ch; |
| apr_file_t *infile; |
| apr_dbm_t *outdbm; |
| |
| apr_app_initialize(&argc, &argv, NULL); |
| atexit(apr_terminate); |
| |
| verbose = 0; |
| format = NULL; |
| input = NULL; |
| output = NULL; |
| |
| apr_pool_create(&pool, NULL); |
| |
| if (argc) { |
| shortname = apr_filepath_name_get(argv[0]); |
| } |
| else { |
| shortname = "httxt2dbm"; |
| } |
| |
| apr_file_open_stderr(&errfile, pool); |
| rv = apr_getopt_init(&opt, pool, argc, argv); |
| |
| if (rv != APR_SUCCESS) { |
| apr_file_printf(errfile, "Error: apr_getopt_init failed." NL NL); |
| return 1; |
| } |
| |
| if (argc <= 1) { |
| usage(); |
| return 1; |
| } |
| |
| while ((rv = apr_getopt(opt, "vf::i::o::", &ch, &opt_arg)) == APR_SUCCESS) { |
| switch (ch) { |
| case 'v': |
| if (verbose) { |
| apr_file_printf(errfile, "Error: -v can only be passed once" NL NL); |
| usage(); |
| return 1; |
| } |
| verbose = 1; |
| break; |
| case 'f': |
| if (format) { |
| apr_file_printf(errfile, "Error: -f can only be passed once" NL NL); |
| usage(); |
| return 1; |
| } |
| format = apr_pstrdup(pool, opt_arg); |
| break; |
| case 'i': |
| if (input) { |
| apr_file_printf(errfile, "Error: -i can only be passed once" NL NL); |
| usage(); |
| return 1; |
| } |
| input = apr_pstrdup(pool, opt_arg); |
| break; |
| case 'o': |
| if (output) { |
| apr_file_printf(errfile, "Error: -o can only be passed once" NL NL); |
| usage(); |
| return 1; |
| } |
| output = apr_pstrdup(pool, opt_arg); |
| break; |
| } |
| } |
| |
| if (rv != APR_EOF) { |
| apr_file_printf(errfile, "Error: Parsing Arguments Failed" NL NL); |
| usage(); |
| return 1; |
| } |
| |
| if (!input) { |
| apr_file_printf(errfile, "Error: No input file specified." NL NL); |
| usage(); |
| return 1; |
| } |
| |
| if (!output) { |
| apr_file_printf(errfile, "Error: No output DBM specified." NL NL); |
| usage(); |
| return 1; |
| } |
| |
| if (!format) { |
| format = "default"; |
| } |
| |
| if (verbose) { |
| apr_file_printf(errfile, "DBM Format: %s" NL, format); |
| } |
| |
| if (!strcmp(input, "-")) { |
| rv = apr_file_open_stdin(&infile, pool); |
| } |
| else { |
| rv = apr_file_open(&infile, input, APR_READ|APR_BUFFERED, |
| APR_OS_DEFAULT, pool); |
| } |
| |
| if (rv != APR_SUCCESS) { |
| apr_file_printf(errfile, |
| "Error: Cannot open input file '%s': (%d) %pm" NL NL, |
| input, rv, &rv); |
| return 1; |
| } |
| |
| if (verbose) { |
| apr_file_printf(errfile, "Input File: %s" NL, input); |
| } |
| |
| rv = apr_dbm_open_ex(&outdbm, format, output, APR_DBM_RWCREATE, |
| APR_OS_DEFAULT, pool); |
| |
| if (APR_STATUS_IS_ENOTIMPL(rv)) { |
| apr_file_printf(errfile, |
| "Error: The requested DBM Format '%s' is not available." NL NL, |
| format); |
| return 1; |
| } |
| |
| if (rv != APR_SUCCESS) { |
| apr_file_printf(errfile, |
| "Error: Cannot open output DBM '%s': (%d) %pm" NL NL, |
| output, rv, &rv); |
| return 1; |
| } |
| |
| if (verbose) { |
| apr_file_printf(errfile, "DBM File: %s" NL, output); |
| } |
| |
| rv = to_dbm(outdbm, infile, pool); |
| |
| if (rv != APR_SUCCESS) { |
| apr_file_printf(errfile, |
| "Error: Converting to DBM: (%d) %pm" NL NL, |
| rv, &rv); |
| return 1; |
| } |
| |
| apr_dbm_close(outdbm); |
| |
| if (verbose) { |
| apr_file_printf(errfile, "Conversion Complete." NL); |
| } |
| |
| return 0; |
| } |
| |
