mirror of
https://github.com/edeproject/ede.git
synced 2023-08-10 21:13:03 +03:00
310 lines
8.3 KiB
C++
310 lines
8.3 KiB
C++
/*
|
|
* $Id$
|
|
*
|
|
* EFiler - EDE File Manager
|
|
* Part of Equinox Desktop Environment (EDE).
|
|
* Copyright (c) 2000-2007 EDE Authors.
|
|
*
|
|
* This program is licenced under terms of the
|
|
* GNU General Public Licence version 2 or newer.
|
|
* See COPYING for details.
|
|
*/
|
|
|
|
|
|
// References:
|
|
// [1] Mutt documentation, chapter on mailcap
|
|
// http://www.mutt.org/doc/manual/manual-5.html
|
|
// [2] RFC 1524
|
|
// http://www.faqs.org/rfcs/rfc1524.html
|
|
|
|
|
|
#include "mailcap.h"
|
|
|
|
#include <edelib/String.h>
|
|
#include <edelib/List.h>
|
|
#include <edelib/Util.h>
|
|
#include <edelib/Directory.h>
|
|
#include <edelib/File.h>
|
|
#include <edelib/StrUtil.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
// See: [2] Appendix A
|
|
#define MAILCAPS "/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"
|
|
|
|
// FIXME: use favourite aplications to find xterm
|
|
#define TERM "xterm"
|
|
|
|
// Maximum length of a mailcap spec
|
|
// We could've used edelib::String, but that would make the whole code a bit
|
|
// more complex and a bit slower. There's no reason for mailcap to be longer
|
|
// (very long mailcaps are usually application specific codes /e.g. mutt/ which
|
|
// isn't useful to us)
|
|
#define BUFLEN 1000
|
|
|
|
|
|
using namespace edelib; // this drastically shortened the code...
|
|
|
|
|
|
struct mime_db_struct {
|
|
String type;
|
|
String viewcmd;
|
|
String createcmd;
|
|
String editcmd;
|
|
String printcmd;
|
|
bool copiousoutput;
|
|
bool needsterminal;
|
|
};
|
|
|
|
|
|
// database of parsed mimetypes
|
|
list<mime_db_struct> mime_db;
|
|
|
|
// flag to know if we should call read_files()
|
|
bool files_read=false;
|
|
|
|
|
|
// Expand various macros in mailcap command spec and prevent
|
|
// certain security issues
|
|
|
|
String mailcap_sanitize(char* cmd, String type) {
|
|
String s(cmd);
|
|
|
|
// no %s, file should be piped to stdin
|
|
unsigned int k = s.find("%s");
|
|
if (k==String::npos) {
|
|
s = String("cat '%s' | ") + cmd;
|
|
} else {
|
|
// replace %s with '%s' (see: [1])
|
|
while (k!=String::npos) {
|
|
s = s.substr(0,k)+ "'%s'" + s.substr(k+2);
|
|
k = s.find("%s",k+2);
|
|
}
|
|
}
|
|
|
|
// replace %t with mimetype
|
|
k = s.find("%t");
|
|
while (k!=String::npos) {
|
|
s = s.substr(0,k) + type + s.substr(k+2);
|
|
k = s.find("%t",k+1);
|
|
}
|
|
// we don't know the charset
|
|
k = s.find("%{charset}");
|
|
while (k!=String::npos) {
|
|
s = s.substr(0,k) + "us-ascii" + s.substr(k+10);
|
|
k = s.find("%{charset}",k+1);
|
|
}
|
|
// ignore other mutt specific codes
|
|
k = s.find("%{");
|
|
while (k!=String::npos) {
|
|
s = s.substr(0,k) + s.substr(k+2);
|
|
k = s.find("}",k); // there has to be a closing brace...
|
|
if (k!=String::npos) s= s.substr(0,k) + s.substr(k+1);
|
|
k = s.find("%{",k+1);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
// Read contents of mailcap file
|
|
|
|
void read_files() {
|
|
list<String> locations;
|
|
|
|
// RFC compliant list of mailcap locations
|
|
stringtok(locations, String(MAILCAPS), ":");
|
|
// Add ~/.mailcap
|
|
locations.push_front(dir_home() + E_DIR_SEPARATOR_STR".mailcap");
|
|
// Add EDE specific configuration
|
|
if (user_config_dir() != "")
|
|
locations.push_front(user_config_dir() + E_DIR_SEPARATOR_STR"ede"E_DIR_SEPARATOR_STR"mailcap");
|
|
|
|
// Test all these locations
|
|
const char* mailcap = NULL;
|
|
{
|
|
list<String>::iterator it = locations.begin(), it_end = locations.end();
|
|
|
|
for(; it != it_end; ++it) {
|
|
if (file_exists((*it).c_str())) {
|
|
mailcap=(*it).c_str();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
fprintf (stderr, " ------ mailcap: %s\n",mailcap);
|
|
|
|
// Read data into list
|
|
FILE *fp = fopen(mailcap,"r");
|
|
char buffer[BUFLEN];
|
|
while (fgets(buffer,BUFLEN,fp)) {
|
|
str_trim(buffer);
|
|
if (buffer[0]=='#') continue; //comment
|
|
if (strlen(buffer)<2) continue; //empty line
|
|
|
|
// Multiline
|
|
if (buffer[strlen(buffer)-1]=='\\') {
|
|
String line(buffer); //Use string for dynamic growing
|
|
while (fgets(buffer,BUFLEN,fp)) {
|
|
str_trim(buffer);
|
|
line = line.substr(0, line.length()-2);
|
|
line += buffer;
|
|
if (buffer[strlen(buffer)-1]!='\\') break;
|
|
}
|
|
// Use just the first BUFLEN chars
|
|
strncpy(buffer, line.c_str(), BUFLEN);
|
|
buffer[BUFLEN-1]='\0';
|
|
}
|
|
|
|
// Parse line
|
|
mime_db_struct parsed;
|
|
char *tmp = strtok(buffer, ";");
|
|
str_trim(tmp);
|
|
parsed.type=tmp;
|
|
|
|
// Command for viewing file
|
|
tmp = strtok(NULL, ";");
|
|
if (tmp==NULL) continue; // no view cmd in line!?
|
|
str_trim(tmp);
|
|
parsed.viewcmd = mailcap_sanitize(tmp, parsed.type);
|
|
|
|
// Other mailcap parameters...
|
|
parsed.copiousoutput = parsed.needsterminal = false;
|
|
while ((tmp = strtok(NULL, ";")) != NULL) {
|
|
str_trim(tmp);
|
|
if (strcmp(tmp,"copiousoutput")==0)
|
|
parsed.copiousoutput = true;
|
|
else if (strcmp(tmp,"needsterminal")==0)
|
|
parsed.needsterminal = true;
|
|
else if (strncmp(tmp,"compose=",8)==0)
|
|
parsed.createcmd = mailcap_sanitize(tmp+8, parsed.type);
|
|
else if (strncmp(tmp,"print=",6)==0)
|
|
parsed.printcmd = mailcap_sanitize(tmp+6, parsed.type);
|
|
else if (strncmp(tmp,"edit=",5)==0)
|
|
parsed.editcmd = mailcap_sanitize(tmp+5, parsed.type);
|
|
// We ignore other parameters
|
|
}
|
|
mime_db.push_back(parsed);
|
|
}
|
|
fclose(fp);
|
|
|
|
files_read=true;
|
|
}
|
|
|
|
|
|
// Helper function for searching mime_db
|
|
|
|
list<mime_db_struct>::iterator find_type(const char* type) {
|
|
list<mime_db_struct>::iterator it = mime_db.begin(), it_end = mime_db.end();
|
|
for(; it != it_end; ++it)
|
|
if ((*it).type==type) return it;
|
|
|
|
it = mime_db.begin();
|
|
for(; it != it_end; ++it) {
|
|
String s((*it).type);
|
|
if (s[s.length()-1]=='*' && strncmp(type, s.c_str(), s.length()-1)==0)
|
|
return it;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Command for performing given action on files of given type
|
|
|
|
const char* mailcap_opener(const char* type, MailcapAction action) {
|
|
static char buffer[BUFLEN];
|
|
if (!files_read) read_files();
|
|
list<mime_db_struct>::iterator it = find_type(type);
|
|
if (it==0) return 0;
|
|
|
|
if (action==MAILCAP_VIEW) {
|
|
const char *c = (*it).viewcmd.c_str();
|
|
if ((*it).copiousoutput) {
|
|
// copiousoutput and needsterminal are mutually exclusive [2]
|
|
// TODO: use enotepad? - when it supports stdin
|
|
snprintf(buffer, BUFLEN-1, TERM" -e \"%s\" | less", c);
|
|
} else if ((*it).needsterminal) {
|
|
snprintf(buffer, BUFLEN-1, TERM" -e \"%s\"", c);
|
|
} else return c;
|
|
return buffer;
|
|
}
|
|
|
|
else if (action==MAILCAP_CREATE) return (*it).createcmd.c_str();
|
|
else if (action==MAILCAP_EDIT) return (*it).editcmd.c_str();
|
|
else if (action==MAILCAP_PRINT) return (*it).printcmd.c_str();
|
|
else return 0;
|
|
}
|
|
|
|
|
|
// List of actions available for given type
|
|
|
|
int mailcap_actions(const char* type) {
|
|
if (!files_read) read_files();
|
|
list<mime_db_struct>::iterator it = find_type(type);
|
|
if (it==0) return 0;
|
|
int result=0;
|
|
if ((*it).viewcmd != "") result += MAILCAP_VIEW;
|
|
if ((*it).createcmd != "") result += MAILCAP_CREATE;
|
|
if ((*it).editcmd != "") result += MAILCAP_EDIT;
|
|
if ((*it).printcmd != "") result += MAILCAP_PRINT;
|
|
return result;
|
|
}
|
|
|
|
|
|
// Add a new opener for given type
|
|
// NOTE: This will be written in EDE-specific location. If EDE-specific
|
|
// mailcap file doesn't exist, it will be created and existing mimetypes
|
|
// will be added. Thus, users of EDE will get a new type in addition to
|
|
// old ones, however other applications will not.
|
|
|
|
void mailcap_add_type(const char* type, const char* opener) {
|
|
// Find old type, edit if it exists
|
|
list<mime_db_struct>::iterator it = find_type(type);
|
|
if (it != 0) {
|
|
(*it).viewcmd = opener;
|
|
(*it).viewcmd += " %s";
|
|
} else {
|
|
mime_db_struct newtype;
|
|
newtype.type = type;
|
|
newtype.viewcmd = opener;
|
|
newtype.viewcmd += " %s";
|
|
newtype.createcmd = "";
|
|
newtype.editcmd = "";
|
|
newtype.printcmd = "";
|
|
newtype.copiousoutput = false;
|
|
newtype.needsterminal = false;
|
|
mime_db.push_back(newtype);
|
|
}
|
|
|
|
// Write mime_db contents to file
|
|
String ede_mailcap = user_config_dir() + E_DIR_SEPARATOR_STR"ede"E_DIR_SEPARATOR_STR"mailcap";
|
|
FILE *fp = fopen(ede_mailcap.c_str(),"w");
|
|
|
|
it = mime_db.begin();
|
|
list<mime_db_struct>::iterator it_end = mime_db.end();
|
|
while (it != it_end) {
|
|
char buffer[BUFLEN];
|
|
snprintf(buffer, BUFLEN-1, "%s; %s", (*it).type.c_str(), (*it).viewcmd.c_str());
|
|
if ((*it).createcmd != "") {
|
|
strncat(buffer, "; compose=", BUFLEN-1-strlen(buffer));
|
|
strncat(buffer, (*it).createcmd.c_str(), BUFLEN-1-strlen(buffer));
|
|
}
|
|
if ((*it).editcmd != "") {
|
|
strncat(buffer, "; edit=", BUFLEN-1-strlen(buffer));
|
|
strncat(buffer, (*it).editcmd.c_str(), BUFLEN-1-strlen(buffer));
|
|
}
|
|
if ((*it).printcmd != "") {
|
|
strncat(buffer, "; print=", BUFLEN-1-strlen(buffer));
|
|
strncat(buffer, (*it).printcmd.c_str(), BUFLEN-1-strlen(buffer));
|
|
}
|
|
if (strlen(buffer)>BUFLEN-2)
|
|
// Even if line is too long, we don't want to mangle the next one
|
|
buffer[strlen(buffer)-1]='\n';
|
|
else
|
|
strcat(buffer, "\n");
|
|
fputs(buffer, fp);
|
|
++it;
|
|
}
|
|
fclose(fp);
|
|
|
|
}
|