diplodocus.org Git - nmh/blob - sbr/mime_type.c

   1 /*
   2  * mime_type.c -- routine to determine the MIME Content-Type of a file
   3  *
   4  * This code is Copyright (c) 2014, by the authors of nmh.  See the
   5  * COPYRIGHT file in the root directory of the nmh distribution for
   6  * complete copyright information.
   7  */
   8
   9 #include <h/mh.h>
  10 #include <h/utils.h>
  11 #include <h/tws.h>
  12
  13 #ifdef MIMETYPEPROC
  14 static char *get_file_info(const char *, const char *);
  15 #endif /* MIMETYPEPROC */
  16
  17 /*
  18  * Try to use external command to determine mime type, and possibly
  19  * encoding.  If that fails try using the filename extension.  Caller
  20  * is responsible for free'ing returned memory.
  21  */
  22 char *
  23 mime_type(const char *file_name) {
  24     char *content_type = NULL;  /* mime content type */
  25     char *p;
  26     static int loaded_defaults = 0;
  27
  28 #ifdef MIMETYPEPROC
  29     char *mimetype;
  30
  31     if ((mimetype = get_file_info(MIMETYPEPROC, file_name))) {
  32 #ifdef MIMEENCODINGPROC
  33         /* Try to append charset for text content. */
  34         char *mimeencoding;
  35
  36         if (strncasecmp(mimetype, "text", 4) == 0) {
  37             if ((mimeencoding = get_file_info(MIMEENCODINGPROC, file_name))) {
  38                 content_type = concat(mimetype, "; charset=", mimeencoding,
  39                                       NULL);
  40                 free (mimetype);
  41             } else {
  42                 content_type = mimetype;
  43             }
  44         } else {
  45             content_type = mimetype;
  46         }
  47 #else  /* MIMEENCODINGPROC */
  48         content_type = mimetype;
  49 #endif /* MIMEENCODINGPROC */
  50     }
  51 #endif /* MIMETYPEPROC */
  52
  53     /*
  54      * If we didn't get the MIME type from the contents (or we don't support
  55      * the necessary command) then use the mhshow suffix.
  56      */
  57
  58     if (content_type == NULL) {
  59         struct node *np;                /* Content scan node pointer */
  60         FILE *fp;                       /* File pointer for mhn.defaults */
  61
  62         if (! loaded_defaults &&
  63                         (fp = fopen(p = etcpath("mhn.defaults"), "r"))) {
  64             loaded_defaults = 1;
  65             readconfig(NULL, fp, p, 0);
  66             fclose(fp);
  67         }
  68
  69         if ((p = strrchr(file_name, '.')) != NULL) {
  70             for (np = m_defs; np; np = np->n_next) {
  71                 if (strncasecmp(np->n_name, "mhshow-suffix-", 14) == 0 &&
  72                     strcasecmp(p, np->n_field ? np->n_field : "") == 0) {
  73                     content_type = strdup(np->n_name + 14);
  74                     break;
  75                 }
  76             }
  77         }
  78
  79         /*
  80          * If we didn't match any filename extension, try to infer the
  81          * content type. If we have binary, assume application/octet-stream;
  82          * otherwise, assume text/plain.
  83          */
  84
  85         if (content_type == NULL) {
  86             FILE *fp;
  87             int binary = 0, c;
  88
  89             if (!(fp = fopen(file_name, "r"))) {
  90                 advise (NULL, "unable to access file \"%s\"", file_name);
  91                 return NULL;
  92             }
  93
  94             while ((c = getc(fp)) != EOF) {
  95                 if (! isascii(c)  ||  c == 0) {
  96                     binary = 1;
  97                     break;
  98                 }
  99             }
 100
 101             fclose(fp);
 102
 103             content_type =
 104                 strdup(binary ? "application/octet-stream" : "text/plain");
 105         }
 106     }
 107
 108     return content_type;
 109 }
 110
 111
 112 #ifdef MIMETYPEPROC
 113 /*
 114  * Get information using proc about a file.
 115  */
 116 static char *
 117 get_file_info(const char *proc, const char *file_name) {
 118     char *cmd, *cp;
 119     char *quotec = "'";
 120
 121     if ((cp = strchr(file_name, '\''))) {
 122         /* file_name contains a single quote. */
 123         if (strchr(file_name, '"')) {
 124             advise(NULL, "filenames containing both single and double quotes "
 125                    "are unsupported for attachment");
 126             return NULL;
 127         } else {
 128             quotec = "\"";
 129         }
 130     }
 131
 132     if ((cmd = concat(proc, " ", quotec, file_name, quotec, NULL))) {
 133         FILE *fp;
 134
 135         if ((fp = popen(cmd, "r")) != NULL) {
 136             char buf[BUFSIZ >= 2048  ?  BUFSIZ  : 2048];
 137
 138             buf[0] = '\0';
 139             if (fgets(buf, sizeof buf, fp)) {
 140                 char *eol;
 141
 142                 /* Skip leading <filename>:<whitespace>, if present. */
 143                 if ((cp = strchr(buf, ':')) != NULL) {
 144                     ++cp;
 145                     while (*cp  &&  isblank((unsigned char) *cp)) {
 146                         ++cp;
 147                     }
 148                 } else {
 149                     cp = buf;
 150                 }
 151
 152                 /* Truncate at newline (LF or CR), if present. */
 153                 if ((eol = strpbrk(cp, "\n\r")) != NULL) {
 154                     *eol = '\0';
 155                 }
 156             } else if (buf[0] == '\0') {
 157                 /* This can happen on Cygwin if the popen()
 158                    mysteriously fails.  Return NULL so that the caller
 159                    will use another method to determine the info. */
 160                 free (cp);
 161                 cp = NULL;
 162             }
 163
 164             (void) pclose(fp);
 165         } else {
 166             advise(NULL, "no output from %s", cmd);
 167         }
 168
 169         free(cmd);
 170     } else {
 171         advise(NULL, "concat with \"%s\" failed, out of memory?", proc);
 172     }
 173
 174     return cp  ?  strdup(cp)  :  NULL;
 175 }
 176 #endif /* MIMETYPEPROC */