mdocml.c

   1 /* $Id: mdocml.c,v 1.14 2008/11/28 11:21:12 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the
   7  * above copyright notice and this permission notice appear in all
   8  * copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include <sys/param.h>
  20 #include <sys/stat.h>
  21
  22 #include <assert.h>
  23 #include <err.h>
  24 #include <fcntl.h>
  25 #include <getopt.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include "libmdocml.h"
  32
  33 #define BUFFER_IN_DEF   BUFSIZ   /* See begin_bufs. */
  34 #define BUFFER_OUT_DEF  BUFSIZ   /* See begin_bufs. */
  35
  36 static  void             usage(void);
  37
  38 static  int              begin_io(const struct md_args *,
  39                                 char *, char *);
  40 static  int              leave_io(const struct md_buf *,
  41                                 const struct md_buf *, int);
  42 static  int              begin_bufs(const struct md_args *,
  43                                 struct md_buf *, struct md_buf *);
  44 static int               leave_bufs(const struct md_buf *,
  45                                 const struct md_buf *, int);
  46
  47 int
  48 main(int argc, char *argv[])
  49 {
  50         int              c;
  51         char            *out, *in;
  52         struct md_args   args;
  53
  54         extern char     *optarg;
  55         extern int       optind;
  56
  57         out = in = NULL;
  58
  59         (void)memset(&args, 0, sizeof(struct md_args));
  60
  61         while (-1 != (c = getopt(argc, argv, "o:vW")))
  62                 switch (c) {
  63                 case ('o'):
  64                         out = optarg;
  65                         break;
  66                 case ('v'):
  67                         args.verbosity++;
  68                         break;
  69                 case ('W'):
  70                         args.warnings |= MD_WARN_ALL;
  71                         break;
  72                 default:
  73                         usage();
  74                         return(1);
  75                 }
  76
  77         argv += optind;
  78         argc -= optind;
  79
  80         if (1 == argc)
  81                 in = *argv++;
  82
  83         return(begin_io(&args, out ? out : "-", in ? in : "-"));
  84 }
  85
  86
  87 /*
  88  * Close out file descriptors opened in begin_io.  If the descriptor
  89  * refers to stdin/stdout, then do nothing.
  90  */
  91 static int
  92 leave_io(const struct md_buf *out,
  93                 const struct md_buf *in, int c)
  94 {
  95         assert(out);
  96         assert(in);
  97
  98         if (-1 != in->fd && -1 == close(in->fd)) {
  99                 assert(in->name);
 100                 warn("%s", in->name);
 101                 c = 1;
 102         }
 103         if (-1 != out->fd && STDOUT_FILENO != out->fd &&
 104                         -1 == close(out->fd)) {
 105                 assert(out->name);
 106                 warn("%s", out->name);
 107                 c = 1;
 108         }
 109
 110         return(c);
 111 }
 112
 113
 114 /*
 115  * Open file descriptors or assign stdin/stdout, if dictated by the "-"
 116  * token instead of a filename.
 117  */
 118 static int
 119 begin_io(const struct md_args *args, char *out, char *in)
 120 {
 121         struct md_buf    fi;
 122         struct md_buf    fo;
 123
 124 #define FI_FL   O_RDONLY
 125 #define FO_FL   O_WRONLY|O_CREAT|O_TRUNC
 126
 127         assert(args);
 128         assert(out);
 129         assert(in);
 130
 131         bzero(&fi, sizeof(struct md_buf));
 132         bzero(&fo, sizeof(struct md_buf));
 133
 134         fi.fd = STDIN_FILENO;
 135         fo.fd = STDOUT_FILENO;
 136
 137         fi.name = in;
 138         fo.name = out;
 139
 140         if (0 != strncmp(fi.name, "-", 1))
 141                 if (-1 == (fi.fd = open(fi.name, FI_FL, 0))) {
 142                         warn("%s", fi.name);
 143                         return(leave_io(&fo, &fi, 1));
 144                 }
 145
 146         if (0 != strncmp(fo.name, "-", 1))
 147                 if (-1 == (fo.fd = open(fo.name, FO_FL, 0644))) {
 148                         warn("%s", fo.name);
 149                         return(leave_io(&fo, &fi, 1));
 150                 }
 151
 152         return(leave_io(&fo, &fi, begin_bufs(args, &fo, &fi)));
 153 }
 154
 155
 156 /*
 157  * Free buffers allocated in begin_bufs.
 158  */
 159 static int
 160 leave_bufs(const struct md_buf *out,
 161                 const struct md_buf *in, int c)
 162 {
 163         assert(out);
 164         assert(in);
 165         if (out->buf)
 166                 free(out->buf);
 167         if (in->buf)
 168                 free(in->buf);
 169         return(c);
 170 }
 171
 172
 173 /*
 174  * Allocate buffers to the maximum of either the input file's blocksize
 175  * or BUFFER_IN_DEF/BUFFER_OUT_DEF, which should be around BUFSIZE.
 176  */
 177 static int
 178 begin_bufs(const struct md_args *args,
 179                 struct md_buf *out, struct md_buf *in)
 180 {
 181         struct stat      stin, stout;
 182         int              c;
 183
 184         assert(args);
 185         assert(in);
 186         assert(out);
 187
 188         if (-1 == fstat(in->fd, &stin)) {
 189                 warn("%s", in->name);
 190                 return(1);
 191         } else if (STDIN_FILENO != in->fd && 0 == stin.st_size) {
 192                 warnx("%s: empty file", in->name);
 193                 return(1);
 194         } else if (-1 == fstat(out->fd, &stout)) {
 195                 warn("%s", out->name);
 196                 return(1);
 197         }
 198
 199         in->bufsz = MAX(stin.st_blksize, BUFFER_IN_DEF);
 200         out->bufsz = MAX(stout.st_blksize, BUFFER_OUT_DEF);
 201
 202         if (NULL == (in->buf = malloc(in->bufsz))) {
 203                 warn("malloc");
 204                 return(leave_bufs(out, in, 1));
 205         } else if (NULL == (out->buf = malloc(out->bufsz))) {
 206                 warn("malloc");
 207                 return(leave_bufs(out, in, 1));
 208         }
 209
 210         c = md_run(args, out, in);
 211         return(leave_bufs(out, in, -1 == c ? 1 : 0));
 212 }
 213
 214
 215 static void
 216 usage(void)
 217 {
 218         extern char     *__progname;
 219
 220         (void)printf("usage: %s [-vW] [-o outfile] [infile]\n", __progname);
 221 }