libextractor

odf_extractor.c (9455B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2004, 2009, 2012 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
 */
 /**
  * @file plugins/odf_extractor.c
  * @brief plugin to support ODF files
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include <ctype.h>
 #include "extractor.h"
 #include "unzip.h"
 
 /**
  * Maximum length of a filename allowed inside the ZIP archive.
  */
 #define MAXFILENAME 256
 
 /**
  * Name of the file with the meta-data in OO documents.
  */
 #define METAFILE "meta.xml"
 
 
 /**
  * Mapping from ODF meta data strings to LE types.
  */
 struct Matches
 {
   /**
    * ODF description.
    */
   const char *text;
 
   /**
    * Corresponding LE type.
    */
   enum EXTRACTOR_MetaType type;
 };
 
 
 /**
  * NULL-terminated map from ODF meta data strings to LE types.
  */
 static struct Matches tmap[] = {
   { "meta:generator",     EXTRACTOR_METATYPE_CREATED_BY_SOFTWARE },
   { "meta:page-count",    EXTRACTOR_METATYPE_PAGE_COUNT },
   { "meta:creation-date", EXTRACTOR_METATYPE_CREATION_DATE },
   { "dc:date",            EXTRACTOR_METATYPE_UNKNOWN_DATE },
   { "dc:creator",         EXTRACTOR_METATYPE_CREATOR },
   { "dc:language",        EXTRACTOR_METATYPE_LANGUAGE },
   { "dc:title",           EXTRACTOR_METATYPE_TITLE },
   { "dc:description",     EXTRACTOR_METATYPE_DESCRIPTION },
   { "dc:subject",         EXTRACTOR_METATYPE_SUBJECT },
   { "meta:keyword",       EXTRACTOR_METATYPE_KEYWORDS },
   { "meta:user-defined meta:name=\"Info 1\"", EXTRACTOR_METATYPE_COMMENT },
   { "meta:user-defined meta:name=\"Info 2\"", EXTRACTOR_METATYPE_COMMENT },
   { "meta:user-defined meta:name=\"Info 3\"", EXTRACTOR_METATYPE_COMMENT },
   { "meta:user-defined meta:name=\"Info 4\"", EXTRACTOR_METATYPE_COMMENT },
   { NULL, 0 }
 };
 
 
 /**
  * Obtain the mimetype of the archive by reading the 'mimetype'
  * file of the ZIP.
  *
  * @param uf unzip context to extract the mimetype from
  * @return NULL if no mimetype could be found, otherwise the mime type
  */
 static char *
 libextractor_oo_getmimetype (struct EXTRACTOR_UnzipFile *uf)
 {
   char filename_inzip[MAXFILENAME];
   struct EXTRACTOR_UnzipFileInfo file_info;
   char *buf;
   size_t buf_size;
 
   if (EXTRACTOR_UNZIP_OK !=
       EXTRACTOR_common_unzip_go_find_local_file (uf,
                                                  "mimetype",
                                                  2))
     return NULL;
   if (EXTRACTOR_UNZIP_OK !=
       EXTRACTOR_common_unzip_get_current_file_info (uf,
                                                     &file_info,
                                                     filename_inzip,
                                                     sizeof (filename_inzip),
                                                     NULL,
                                                     0,
                                                     NULL,
                                                     0))
     return NULL;
   if (EXTRACTOR_UNZIP_OK !=
       EXTRACTOR_common_unzip_open_current_file (uf))
     return NULL;
   buf_size = file_info.uncompressed_size;
   if (buf_size > 1024)
   {
     /* way too large! */
     EXTRACTOR_common_unzip_close_current_file (uf);
     return NULL;
   }
   if (NULL == (buf = malloc (1 + buf_size)))
   {
     /* memory exhausted! */
     EXTRACTOR_common_unzip_close_current_file (uf);
     return NULL;
   }
   if (buf_size !=
       (size_t) EXTRACTOR_common_unzip_read_current_file (uf,
                                                          buf,
                                                          buf_size))
   {
     free (buf);
     EXTRACTOR_common_unzip_close_current_file (uf);
     return NULL;
   }
   /* found something */
   buf[buf_size] = '\0';
   while ( (0 < buf_size) &&
           isspace ( (unsigned char) buf[buf_size - 1]))
     buf[--buf_size] = '\0';
   if ('\0' == buf[0])
   {
     free (buf);
     buf = NULL;
   }
   EXTRACTOR_common_unzip_close_current_file (uf);
   return buf;
 }
 
 
 /**
  * Main entry method for the ODF extraction plugin.
  *
  * @param ec extraction context provided to the plugin
  */
 void
 EXTRACTOR_odf_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
   char filename_inzip[MAXFILENAME];
   struct EXTRACTOR_UnzipFile *uf;
   struct EXTRACTOR_UnzipFileInfo file_info;
   char *buf;
   char *pbuf;
   size_t buf_size;
   unsigned int i;
   char *mimetype;
 
   if (NULL == (uf = EXTRACTOR_common_unzip_open (ec)))
     return;
   if (NULL != (mimetype = libextractor_oo_getmimetype (uf)))
   {
     if (0 != ec->proc (ec->cls,
                        "odf",
                        EXTRACTOR_METATYPE_MIMETYPE,
                        EXTRACTOR_METAFORMAT_UTF8,
                        "text/plain",
                        mimetype,
                        strlen (mimetype) + 1))
     {
       EXTRACTOR_common_unzip_close (uf);
       free (mimetype);
       return;
     }
     free (mimetype);
   }
   if (EXTRACTOR_UNZIP_OK !=
       EXTRACTOR_common_unzip_go_find_local_file (uf,
                                                  METAFILE,
                                                  2))
   {
     /* metafile not found */
     EXTRACTOR_common_unzip_close (uf);
     return;
   }
   if (EXTRACTOR_UNZIP_OK !=
       EXTRACTOR_common_unzip_get_current_file_info (uf,
                                                     &file_info,
                                                     filename_inzip,
                                                     sizeof (filename_inzip),
                                                     NULL, 0, NULL, 0))
   {
     /* problems accessing metafile */
     EXTRACTOR_common_unzip_close (uf);
     return;
   }
   if (EXTRACTOR_UNZIP_OK !=
       EXTRACTOR_common_unzip_open_current_file (uf))
   {
     /* problems with unzip */
     EXTRACTOR_common_unzip_close (uf);
     return;
   }
 
   buf_size = file_info.uncompressed_size;
   if (buf_size > 128 * 1024)
   {
     /* too big to be meta-data! */
     EXTRACTOR_common_unzip_close_current_file (uf);
     EXTRACTOR_common_unzip_close (uf);
     return;
   }
   if (NULL == (buf = malloc (buf_size + 1)))
   {
     /* out of memory */
     EXTRACTOR_common_unzip_close_current_file (uf);
     EXTRACTOR_common_unzip_close (uf);
     return;
   }
   if (buf_size != EXTRACTOR_common_unzip_read_current_file (uf, buf, buf_size))
   {
     EXTRACTOR_common_unzip_close_current_file (uf);
     goto CLEANUP;
   }
   EXTRACTOR_common_unzip_close_current_file (uf);
   /* we don't do "proper" parsing of the meta-data but rather use some heuristics
      to get values out that we understand */
   buf[buf_size] = '\0';
   /* printf("%s\n", buf); */
   /* try to find some of the typical OO xml headers */
   if ( (strstr (buf, "xmlns:meta=\"http://openoffice.org/2000/meta\"") !=
         NULL) ||
        (strstr (buf, "xmlns:dc=\"http://purl.org/dc/elements/1.1/\"") !=
         NULL) ||
        (strstr (buf, "xmlns:xlink=\"http://www.w3.org/1999/xlink\"") != NULL) )
   {
     /* accept as meta-data */
     for (i = 0; NULL  != tmap[i].text; i++)
     {
       char *spos;
       char *epos;
       char needle[256];
       int oc;
 
       pbuf = buf;
 
       while (1)
       {
         strcpy (needle, "<");
         strcat (needle, tmap[i].text);
         strcat (needle, ">");
         spos = strstr (pbuf, needle);
         if (NULL == spos)
         {
           strcpy (needle, tmap[i].text);
           strcat (needle, "=\"");
           spos = strstr (pbuf, needle);
           if (spos == NULL)
             break;
           spos += strlen (needle);
           epos = spos;
           while ( (epos[0] != '\0') &&
                   (epos[0] != '"') )
             epos++;
         }
         else
         {
           oc = 0;
           spos += strlen (needle);
           while ( (spos[0] != '\0') &&
                   ( (spos[0] == '<') ||
                     (oc > 0) ) )
           {
             if (spos[0] == '<')
               oc++;
             if (spos[0] == '>')
               oc--;
             spos++;
           }
           epos = spos;
           while ( (epos[0] != '\0') &&
                   (epos[0] != '<') &&
                   (epos[0] != '>') )
           {
             epos++;
           }
         }
         if (spos != epos)
         {
           char key[epos - spos + 1];
 
           memcpy (key, spos, epos - spos);
           key[epos - spos] = '\0';
           if (0 != ec->proc (ec->cls,
                              "odf",
                              tmap[i].type,
                              EXTRACTOR_METAFORMAT_UTF8,
                              "text/plain",
                              key,
                              epos - spos + 1))
             goto CLEANUP;
           pbuf = epos;
         }
         else
           break;
       }
     }
   }
 CLEANUP:
   free (buf);
   EXTRACTOR_common_unzip_close (uf);
 }
 
 
 /* end of odf_extractor.c */