New style MIME typing; maps MIME types to DataTypes and DefIcon format names.

Currently only able to resolve DataTypes to MIME Types.

TODO:
- DT MIME type guessing needs mostly removing (only use if no matches in mimetypes
file)
- Migrate the rest of filetype.c to the new format (can filetype using icon.library
and reverse lookup MIME type, for example)
- Use to distinguish between CONTENT_IMAGE types
- Simplify so DefIcon type defaults to lowercase DataType name

svn path=/trunk/netsurf/; revision=12360

1 files changed, 168 insertions, 0 deletions

diff --git a/amiga/filetype.c b/amiga/filetype.c
index 5995ec8d5..009ce6d64 100644
--- a/amiga/filetype.c
+++ b/amiga/filetype.c
@@ -19,6 +19,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "amiga/filetype.h"
+#include "amiga/object.h"
 #include "content/fetch.h"
 #include "content/content.h"
 #include "utils/log.h"
@@ -26,12 +27,23 @@
 #include <proto/icon.h>
 #include <proto/dos.h>
 #include <proto/datatypes.h>
+#include <proto/exec.h>
 #include <workbench/icon.h>
 
 /**
  * filetype -- determine the MIME type of a local file
  */
 
+struct MinList *ami_mime_list;
+
+struct ami_mime_entry
+{
+	lwc_string *mimetype;
+	lwc_string *datatype;
+	lwc_string *filetype;
+	lwc_string *plugincmd;
+};
+
 const char *fetch_filetype(const char *unix_path)
 {
 	static char mimetype[50];
@@ -215,3 +227,159 @@ bool ami_mime_compare(struct hlcache_handle *c, const char *type)
 	}
 	else return false;
 }
+
+nserror ami_mime_init(const char *mimefile)
+{
+	lwc_string *type;
+	lwc_error lerror;
+	nserror error;
+	char buffer[256];
+	BPTR fh = 0;
+	struct RDArgs *rargs = NULL;
+	STRPTR template = "MIMETYPE/A,DT=DATATYPE/K,TYPE=DEFICON/K,CMD=PLUGINCMD/K";
+	long rarray[] = {0,0,0,0};
+	struct nsObject *node;
+	struct ami_mime_entry *mimeentry;
+
+	enum
+	{
+		A_MIMETYPE,
+		A_DATATYPE,
+		A_FILETYPE,
+		A_PLUGINCMD
+	};
+
+	ami_mime_list = NewObjList();
+
+	rargs = AllocDosObjectTags(DOS_RDARGS,TAG_DONE);
+
+	if(fh = FOpen(mimefile, MODE_OLDFILE, 0))
+	{
+		while(FGets(fh, (UBYTE *)&buffer, 256) != 0)
+		{
+			rargs->RDA_Source.CS_Buffer = (char *)&buffer;
+			rargs->RDA_Source.CS_Length = 256;
+			rargs->RDA_Source.CS_CurChr = 0;
+
+			rargs->RDA_DAList = NULL;
+			rargs->RDA_Buffer = NULL;
+			rargs->RDA_BufSiz = 0;
+			rargs->RDA_ExtHelp = NULL;
+			rargs->RDA_Flags = 0;
+
+			rarray[A_MIMETYPE] = 0;
+			rarray[A_DATATYPE] = 0;
+			rarray[A_FILETYPE] = 0;
+			rarray[A_PLUGINCMD] = 0;
+
+			if(ReadArgs(template, rarray, rargs))
+			{
+				node = AddObject(ami_mime_list, AMINS_MIME);
+				mimeentry = AllocVec(sizeof(struct ami_mime_entry), MEMF_PRIVATE | MEMF_CLEAR);
+				node->objstruct = mimeentry;
+
+				if(rarray[A_MIMETYPE])
+				{
+					lerror = lwc_intern_string((char *)rarray[A_MIMETYPE],
+								strlen((char *)rarray[A_MIMETYPE]), &mimeentry->mimetype);
+					if (lerror != lwc_error_ok)
+						return NSERROR_NOMEM;
+				}
+
+				if(rarray[A_DATATYPE])
+				{
+					lerror = lwc_intern_string((char *)rarray[A_DATATYPE],
+								strlen((char *)rarray[A_DATATYPE]), &mimeentry->datatype);
+					if (lerror != lwc_error_ok)
+						return NSERROR_NOMEM;
+				}
+
+				if(rarray[A_FILETYPE])
+				{
+					lerror = lwc_intern_string((char *)rarray[A_FILETYPE],
+								strlen((char *)rarray[A_FILETYPE]), &mimeentry->filetype);
+					if (lerror != lwc_error_ok)
+						return NSERROR_NOMEM;
+				}
+
+				if(rarray[A_PLUGINCMD])
+				{
+					lerror = lwc_intern_string((char *)rarray[A_PLUGINCMD],
+								strlen((char *)rarray[A_PLUGINCMD]), &mimeentry->plugincmd);
+					if (lerror != lwc_error_ok)
+						return NSERROR_NOMEM;
+				}
+			}
+		}
+		FClose(fh);
+	}
+}
+
+void ami_mime_free(void)
+{
+	FreeObjList(ami_mime_list);
+}
+
+void ami_mime_entry_free(struct ami_mime_entry *mimeentry)
+{
+	if(mimeentry->mimetype) lwc_string_unref(mimeentry->mimetype);
+	if(mimeentry->datatype) lwc_string_unref(mimeentry->datatype);
+	if(mimeentry->filetype) lwc_string_unref(mimeentry->filetype);
+	if(mimeentry->plugincmd) lwc_string_unref(mimeentry->plugincmd);
+}
+
+/**
+ * Return a MIME Type matching a DataType
+ *
+ * \param dt a DataType structure
+ * \param mimetype lwc_string to hold the MIME type
+ * \param start_node node to feed back in to continue search
+ * \return node or NULL if no match
+ */
+
+struct Node *ami_mime_from_datatype(struct DataType *dt,
+		lwc_string **mimetype, struct Node *start_node)
+{
+	struct DataTypeHeader *dth = dt->dtn_Header;
+	struct nsObject *node;
+	struct nsObject *nnode;
+	struct ami_mime_entry *mimeentry;
+	lwc_string *dt_name;
+	lwc_error lerror;
+	bool ret = false;
+
+	if(IsMinListEmpty(ami_mime_list)) return NULL;
+
+	lerror = lwc_intern_string(dth->dth_Name, strlen(dth->dth_Name), &dt_name);
+	if (lerror != lwc_error_ok)
+		return NULL;
+
+	if(start_node)
+	{
+		node = (struct nsObject *)GetSucc(start_node);
+		if(node == NULL) return NULL;
+	}
+	else
+	{
+		node = (struct nsObject *)GetHead((struct List *)ami_mime_list);
+	}
+
+	do
+	{
+		nnode=(struct nsObject *)GetSucc((struct Node *)node);
+		mimeentry = node->objstruct;
+		lerror = lwc_string_isequal(mimeentry->datatype, dt_name, &ret);
+
+		if((lerror == lwc_error_ok) && (ret == true))
+		{
+			*mimetype = mimeentry->mimetype;
+			break;
+		}
+
+	}while(node=nnode);
+
+	lwc_string_unref(dt_name);
+
+	if(ret == true) return (struct Node *)node;
+		else return NULL;
+}