[BACK]Return to mail.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/mail.C between versions 1.46 and 1.122

version 1.46, 2001/12/19 09:53:28 version 1.122, 2015/04/02 22:18:25
Line 1 Line 1
 /** @file  /** @file
         Parser: @b mail parser class.          Parser: @b mail parser class.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$  
 */  */
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   #include "pa_vmethod_frame.h"
 #ifdef _MSC_VER  
 #       include "smtp/smtp.h"  
 #endif  
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_request.h"  #include "pa_request.h"
Line 19 Line 14
 #include "pa_exec.h"  #include "pa_exec.h"
 #include "pa_charsets.h"  #include "pa_charsets.h"
 #include "pa_charset.h"  #include "pa_charset.h"
   #include "pa_uue.h"
   #include "pa_vmail.h"
   
   #include "smtp.h"
   
   volatile const char * IDENT_MAIL_C="$Id$";
   
 // defines  // defines
   
 #define MAIL_CLASS_NAME "mail"  #define MAIL_CLASS_NAME "mail"
   #define SENDMAIL_NAME "sendmail"
   
 #define MAIL_NAME "MAIL"  // consts
   
 // global variable  
   
 Methoded *mail_class;  const int ATTACHMENT_WEIGHT=100;
   
 // class  // class
   
 class MMail : public Methoded {  class MMail: public Methoded {
 public:  
         MMail(Pool& pool);  
 public: // Methoded  public: // Methoded
         bool used_directly() { return true; }          bool used_directly() { return false; }
         void configure_user(Request& r);          void configure_user(Request& r);
 private:  
         String mail_name;  public:
         String content_disposition_name;          MMail();
         String content_disposition_filename_name;  
 };  };
   
 // helpers  // global variable
   
 // uuencode  DECLARE_CLASS_VAR(mail, 0/*fictive*/, new MMail);
   
 static unsigned char uue_table[64] = {  // defines for statics
   '`', '!', '"', '#', '$', '%', '&', '\'',  
   '(', ')', '*', '+', ',', '-', '.', '/',  
   '0', '1', '2', '3', '4', '5', '6', '7',  
   '8', '9', ':', ';', '<', '=', '>', '?',  
   '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',  
   'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',  
   'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',  
   'X', 'Y', 'Z', '[', '\\',']', '^', '_'  
 };  
 static void uuencode(String& result, const char *file_name_cstr, const VFile& vfile) {  
         //header  
         result << "content-transfer-encoding: x-uuencode\n" << "\n";  
         result << "begin 644 " << file_name_cstr << "\n";  
   
         //body  
         const unsigned char *in=(const unsigned char *)vfile.value_ptr();  
         size_t in_length=vfile.value_size();  
   
         int count=45;  
         for(const unsigned char *itemp=in; itemp<(in+in_length); itemp+=count) {  
                 int index;        
   
                 if((itemp+count)>(in+in_length))   
                         count=in_length-(itemp-in);  
   
                 char *buf=(char *)result.pool().malloc(MAX_STRING);  
                 char *optr=buf;  
                   
                 /*  
                 * for UU and XX, encode the number of bytes as first character  
                 */  
                 *optr++ = uue_table[count];  
                   
                 for (index=0; index<=count-3; index+=3) {  
                         *optr++ = uue_table[itemp[index] >> 2];  
                         *optr++ = uue_table[((itemp[index  ] & 0x03) << 4) | (itemp[index+1] >> 4)];  
                         *optr++ = uue_table[((itemp[index+1] & 0x0f) << 2) | (itemp[index+2] >> 6)];  
                         *optr++ = uue_table[  itemp[index+2] & 0x3f];  
                 }  
                   
                 /*  
                 * Special handlitempg for itempcomplete litempes  
                 */  
                 if (index != count) {  
                         if (count - index == 2) {  
                                 *optr++ = uue_table[itemp[index] >> 2];  
                                 *optr++ = uue_table[((itemp[index  ] & 0x03) << 4) |   
                                         ( itemp[index+1] >> 4)];  
                                 *optr++ = uue_table[((itemp[index+1] & 0x0f) << 2)];  
                                 *optr++ = uue_table[0];  
                         }  
                         else if (count - index == 1) {  
                                 *optr++ = uue_table[ itemp[index] >> 2];  
                                 *optr++ = uue_table[(itemp[index] & 0x03) << 4];  
                                 *optr++ = uue_table[0];  
                                 *optr++ = uue_table[0];  
                         }  
                 }  
                 /*  
                 * end of line  
                 */  
                 *optr++ = '\n';   
                 *optr = 0;  
                 result << buf;  
         }  
           
         //footer  
         result.APPEND_AS_IS((const char *)uue_table, 1/* one char */, 0, 0) << "\n"  
                 "end\n";  
 }  
   
 /** ^mail:send[$attach[$type[uue|mime64] $value[DATA]]]   #define MAIL_NAME "MAIL"
         @todo solve - bad with html attaches  
 */  // statics
 static const String& attach_hash_to_string(Request& r, const String& origin_string,   
                                                                                    Hash& attach_hash) {  
         Pool& pool=r.pool();  
   
         Value *vformat=static_cast<Value *>(attach_hash.get(*new(pool) String(pool, "format")));  
   
         const VFile *vfile;  
         if(Value *value=static_cast<Value *>(attach_hash.get(*value_name)))  
                 vfile=value->as_vfile(String::UL_AS_IS); // bad with html attaches. todo: solve  
         else  
                 throw Exception(0, 0,  
                         &origin_string,  
                         "has no $value");  
   
         const String *file_name;  
         if(Value *vfile_name=static_cast<Value *>(attach_hash.get(  
                 *new(pool) String(pool, "file-name")))) // specified $file-name  
                 file_name=&vfile_name->as_string();  
         else // no $file-name, VFile surely knows name  
                 file_name=&static_cast<Value *>(vfile->fields().get(*name_name))->as_string();  
         const char *file_name_cstr=file_name->cstr(String::UL_FILE_SPEC);  
   
         String& result=*new(pool) String(pool);  
   
         // content-type: application/octet-stream  
         result << "content-type: " << r.mime_type_of(file_name_cstr) << "\n";  
         // content-disposition: attachment; filename="user_file_name"  
         result << "content-disposition: attachment; filename=\"" << file_name_cstr << "\"\n";  
   
         const String *type=vformat?&vformat->as_string():0;  
         if(!type/*default = uue*/ || *type=="uue") {  
                 uuencode(result, file_name_cstr, *vfile);  
         } else // for now  
                 throw Exception(0, 0,  
                         type,  
                         "unknown attachment encode format");  
                   
         return result;  static const String mail_name(MAIL_NAME);
 }  static const String mail_sendmail_name(SENDMAIL_NAME);
   
   // helpers
   
 #ifndef DOXYGEN  static void sendmail(
 struct Mail_info {                          Value* 
         Charset *charset;  #ifndef WIN32
         String *header;                          vmail_conf
         const String **from, **to;  
 };  
 #endif  #endif
 static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,                           , Value* smtp_server_port,
                                                                  void *info) {                          const String& message, 
                           const String* from,
                           const String* to,
                           const String* 
   #ifndef WIN32
                            options
   #endif
                            ) {
           const char* exception_type="email.format";
           if(!from) // we use in sendmail -f {from} && SMTP MAIL from: {from}
                   throw Exception(exception_type,
                           0,
                           "parameter does not specify 'from' header field");
   
           const char* message_cstr=message.untaint_cstr(String::L_AS_IS);
   
           if(smtp_server_port) {
                   if(!to) // we use only in SMTP RCPT to: {to}
                           throw Exception(exception_type,
                                   0,
                                   "parameter does not specify 'to' header field");
   
         Value& lmeaning=*static_cast<Value *>(ameaning);                  SMTP smtp;
         Mail_info& mi=*static_cast<Mail_info *>(info);                  char* server=smtp_server_port->as_string().cstrm();
                   const char* port=rsplit(server, ':');
                   if(!port)
                           port="25";
   
         // exclude one attribute [body]                  smtp.Send(server, port, message_cstr, from->cstrm(), to->cstrm());
         if(aattribute==BODY_NAME  
                 || aattribute==CHARSET_NAME)  
                 return;                  return;
           }
   
         // fetch from & to from header for SMTP  #ifdef WIN32
         if(mi.from && aattribute=="from")          // win32 without SMTP server configured
                 *mi.from=&lmeaning.as_string();          throw Exception(PARSER_RUNTIME,
         if(mi.to && aattribute=="to")                  0,
                 *mi.to=&lmeaning.as_string();                  "$"MAIN_CLASS_NAME":"MAIL_NAME".SMTP not defined");
   #else
         // append header line          // unix
         *mi.header <<           // $MAIN:MAIL.sendmail["/usr/sbin/sendmail -t -i -f postmaster"] default
                 aattribute << ":" <<           // $MAIN:MAIL.sendmail["/usr/lib/sendmail -t -i  -f postmaster"] default
                 attributed_meaning_to_string(lmeaning, String::UL_MAIL_HEADER).  
                         cstr(String::UL_UNSPECIFIED, 0, mi.charset) <<   
                 "\n";  
 }  
   
 #ifndef DOXYGEN          String* sendmail_command=new String;
 struct Mail_seq_item {          if(vmail_conf) {
         const String *part_name;  #ifdef PA_FORCED_SENDMAIL
         Value *part_value;                  throw Exception(PARSER_RUNTIME,
 };                          0,
                           "Parser was configured with --with-sendmail=" PA_FORCED_SENDMAIL
                           " key, to change sendmail you should reconfigure and recompie it");
   #else
                   if(Value* sendmail_value=vmail_conf->get_hash()->get(mail_sendmail_name))
                           *sendmail_command<<sendmail_value->as_string();
                   else
                           throw Exception(PARSER_RUNTIME,
                                   0,
                                   "$" MAIN_CLASS_NAME ":" MAIL_NAME "." SENDMAIL_NAME " not defined");
 #endif  #endif
 static void add_part(const Hash::Key& part_name, Hash::Val *part_value,           } else {
                                          void *info) {  #ifdef PA_FORCED_SENDMAIL
         Mail_seq_item **seq_ref=static_cast<Mail_seq_item **>(info);                  *sendmail_command<<PA_FORCED_SENDMAIL;
         (**seq_ref).part_name=&part_name;  #else
         (**seq_ref).part_value=static_cast<Value *>(part_value);                  String* test=new String("/usr/sbin/sendmail");
         (*seq_ref)++;                  if(!file_executable(*test))
 }                          test=new String("/usr/lib/sendmail");
 static double key_of_part(const void *item) {                  *sendmail_command<<*test;
         const char *cstr=static_cast<const Mail_seq_item *>(item)->part_name->cstr();                  *sendmail_command<<" -t -i -f postmaster";
         char *error_pos;  #endif
         return strtod(cstr, &error_pos);          }
 }          if(options)
 static int sort_cmp_string_double_value(const void *a, const void *b) {                  *sendmail_command<<" "<<*options;
         double va=key_of_part(a);  
         double vb=key_of_part(b);  
   
         // 0 logically equals infinity. so that attachments would go last  
         if(va==0)  
                 return +1;  
         if(vb==0)  
                 return -1;  
   
         if(va<vb)  
                 return -1;  
         else if(va>vb)  
                 return +1;  
         else   
                 return 0;  
 }  
 static const String& letter_hash_to_string(Request& r, const String& method_name,   
                                                                                    Hash& letter_hash, int level,  
                                                                                    const String **from, const String **to) {  
         Pool& pool=r.pool();  
   
         // prepare header: 'hash' without "body"  
         String& result=*new(pool) String(pool);  
   
         Charset *charset;  
         if(Value *vcharset_name=static_cast<Value *>(letter_hash.get(*charset_name)))  
                 charset=&charsets->get_charset(vcharset_name->as_string());  
         else  
                 charset=&pool.get_source_charset();  
   
         if(from)          // we know sendmail_command here, should replace "postmaster" with "$from" from message
                 *from=0;          size_t at_postmaster=sendmail_command->pos("postmaster");
         if(to)          if(at_postmaster!=STRING_NOT_FOUND) {
                 *to=0;                  String& reconstructed=sendmail_command->mid(0, at_postmaster);
         Mail_info mail_info={                  reconstructed << *from;
                 charset,                  reconstructed << sendmail_command->mid(at_postmaster+10/*postmaster*/, sendmail_command->length());
                 &result,                  sendmail_command=&reconstructed;
                 from, to          }
         };  
         letter_hash.for_each(add_header_attribute, &mail_info);  
   
         if(Value *body_element=static_cast<Value *>(letter_hash.get(*body_name))) {  
                 if(Hash *body_hash=body_element->get_hash(&method_name)) {  
                         char *boundary=(char *)pool.malloc(MAX_NUMBER);  
                         snprintf(boundary, MAX_NUMBER-5/*lEvEl*/, "lEvEl%d", level);  
                         // multi-part  
                         result << "content-type: multipart/mixed; boundary=\"" << boundary << "\"\n";  
                         result << "\n"   
                                 "This is a multi-part message in MIME format.";  
   
                         // body parts..  
                         // ..collect  
                         Mail_seq_item *seq=(Mail_seq_item *)pool.malloc(sizeof(Mail_seq_item)*body_hash->size());  
                         Mail_seq_item *seq_ref=seq;  body_hash->for_each(add_part, &seq_ref);  
                         // ..sort  
                         _qsort(seq, body_hash->size(), sizeof(Mail_seq_item),   
                                 sort_cmp_string_double_value);  
                         // ..insert in 'seq' order  
                         for(int i=0; i<body_hash->size(); i++) {  
                                 // intermediate boundary  
                                 result << "\n--" << boundary << "\n";  
   
                                 if(Hash *part_hash=seq[i].part_value->get_hash(&method_name))  
                                         if(seq[i].part_name->mid(0, 6/*attach*/)=="attach")  
                                                 result << attach_hash_to_string(r, *seq[i].part_name, *part_hash);  
                                         else   
                                                 result << letter_hash_to_string(r, method_name, *part_hash,   
                                                         level+1, 0, 0);  
                                 else  
                                         throw Exception(0, 0,  
                                                 seq[i].part_name,  
                                                 "part is not hash");  
                         }  
   
                         // finish boundary  
                         result << "\n--" << boundary << "--\n";  
                 } else {  
                         result <<   
                                 "\n"; // header|body separator  
   
                         const String& body=body_element->as_string();  
                         const void *body_ptr=body.cstr();  // body  
                         size_t body_size=body.size();  // body  
                         const void *mail_ptr;  
                         size_t mail_size;  
                         Charset::transcode(pool,   
                                 pool.get_source_charset(), body_ptr, body_size,  
                                 *charset/*always set - either mail.charset or $request:charset*/, mail_ptr, mail_size);  
                         result.APPEND_CLEAN((const char*)mail_ptr, mail_size, 0, 0);  
                 }  
         } else   
                 throw Exception(0, 0,  
                         &method_name,  
                         "has no $body");  
   
         return result;          // execute it
 }          ArrayString argv;
           const String* file_spec;
           size_t after_file_spec=sendmail_command->pos(' ');
           if(after_file_spec==STRING_NOT_FOUND || after_file_spec==0)
                   file_spec=sendmail_command;
           else {
                   size_t pos_after=after_file_spec;
                   file_spec=&sendmail_command->mid(0, pos_after++);
                   sendmail_command->split(argv, pos_after, " ", String::L_AS_IS);
           }
   
 static void sendmail(Request& r, const String& method_name,           if(!file_executable(*file_spec))
                                          const String& letter,                   throw Exception("email.send",
                                          const String *from, const String *to) {                          file_spec, 
         Pool& pool=r.pool();                          "is not executable."
   #ifdef PA_FORCED_SENDMAIL
         char *letter_cstr=letter.cstr();                          " Use configure key \"--with-sendmail=appropriate sendmail command\""
         Hash *mail_conf=static_cast<Hash *>(r.classes_conf.get(mail_class->name()));  #else
                           " Set $" MAIN_CLASS_NAME ":" MAIL_NAME "." SENDMAIL_NAME " to appropriate sendmail command"
 #ifdef _MSC_VER  #endif
         if(!from)                  );
                 throw Exception(0, 0,  
                         &method_name,  
                         "has no 'from' header specified");  
         if(!to)  
                 throw Exception(0, 0,  
                         &method_name,  
                         "has no 'to' header specified");  
   
         SMTP& smtp=*new(pool) SMTP(pool, method_name);  
         Value *server_port;  
         // $MAIN:MAIL.SMTP[mail.yourdomain.ru[:port]]  
         if(mail_conf &&   
                 (server_port=static_cast<Value *>(mail_conf->get(  
                         *new(pool) String(pool, "SMTP"))))) {  
                 char *server=server_port->as_string().cstr();  
                 const char *port=rsplit(server, ':');  
                 if(!port)  
                         port="25";  
   
                 smtp.Send(server, port, letter_cstr, from->cstr(), to->cstr());  
         } else          String in(message_cstr);
                 throw Exception(0, 0,          PA_exec_result exec=pa_exec(
                         &method_name,                  // forced_allow
                         "$"MAIN_CLASS_NAME":"MAIL_NAME".SMTP not defined");  #ifdef PA_FORCED_SENDMAIL
                   true
 #else  #else
         // unix                  false
         // $MAIN:MAIL.prog1["/usr/sbin/sendmail -t"] default  
         // $MAIN:MAIL.prog2["/usr/lib/sendmail -t"] default  
         char no_cstr[MAX_NUMBER];  
         for(int no=-2; ; no++) {  
                 const String *prog_string;  
                 switch(no) {  
                 case -2: prog_string=new(pool) String(pool, "/usr/sbin/sendmail -t"); break;  
                 case -1: prog_string=new(pool) String(pool, "/usr/lib/sendmail -t"); break;  
                 default:   
                         {  
                                 String prog_key(pool, "prog");  
                                 snprintf(no_cstr, MAX_NUMBER, "%d", no);  
                                 prog_key << no_cstr;  
                                 if(mail_conf) {  
                                         if(Value *prog_value=static_cast<Value *>(mail_conf->get(prog_key)))  
                                                 prog_string=&prog_value->as_string();  
                                         else  
                                                 if(no==0)  
                                                         continue;  
                                                 else  
                                                         throw Exception(0, 0,  
                                                                 &method_name,  
                                                                 "$"MAIN_CLASS_NAME":"MAIL_NAME".%s not defined",   
                                                                 prog_key.cstr());  
                                 } else  
                                         throw Exception(0, 0,  
                                                 &method_name,  
                                                 "$" MAIN_CLASS_NAME ":" MAIL_NAME " not defined");  
                         }  
                 }  
                 // we know prog_string here  
                 Array argv(pool);  
                 const String *file_spec;  
                 int after_file_spec=prog_string->pos(" ", 1);  
                 if(after_file_spec<=0)  
                         file_spec=prog_string;  
                 else {  
                         size_t pos_after=after_file_spec;  
                         file_spec=&prog_string->mid(0, pos_after);  
                         prog_string->split(argv, &pos_after, " ", 1, String::UL_CLEAN);  
                 }  
   
                 // skip unavailable default programs  
                 if(no<0 && !file_executable(*file_spec))  
                         continue;  
   
                 String in(pool, letter_cstr); String out(pool); String err(pool);  
                 int exit_status=pa_exec(*file_spec,  
                         0/*default env*/,  
                         &argv,  
                         in, out, err);  
                 if(exit_status || err.size())  
                         throw Exception(0, 0,  
                                 &method_name,  
                                 "'%s' reported problem: %s (%d)",  
                                         file_spec->cstr(),  
                                         err.size()?err.cstr():"UNKNOWN",   
                                         exit_status);  
                 break;  
         }  
 #endif  #endif
                   , *file_spec,
                   0 /* pass env */,
                   argv,
                   in);
           if(exec.status || exec.err.length())
                   throw Exception("email.send",
                           0,
                           "'%s' reported problem: %s (%d)",
                                   file_spec->cstr(),
                                   exec.err.length()?exec.err.cstr():"UNKNOWN", 
                                   exec.status);
   #endif //WIN32
 }  }
   
   
 // methods  // methods
   
 static void _send(Request& r, const String& method_name, MethodParams *params) {  static void _send(Request& r, MethodParams& params) {
         Pool& pool=r.pool();          HashStringValue* hash=params.as_hash(0, "message");
           if(!hash || !hash->count())
                   return;
           // todo@ check if enough options are specified.
           // now ^mail:send[^hash::create[]] and ^mail:send[$.print-debug(1)] "work".
   
         Value& vhash=params->as_no_junction(0, "message must not be code");          const String* soptions=0;
         Hash *hash=vhash.get_hash(&method_name);          if(Value* voptions=hash->get(MAIL_OPTIONS_NAME))
         if(!hash)                  soptions=&voptions->as_string();
                 throw Exception(0, 0,  
                         &method_name,          bool print_debug=false;
                         "message must be hash");          if(Value* vdebug=hash->get(MAIL_DEBUG_NAME))
                   print_debug=vdebug->as_bool();
   
           Value* vmail_conf=static_cast<Value*>(r.classes_conf.get(mail_base_class->name()));
           Value* smtp_server_port=0;
           if(vmail_conf) {
                   // $MAIN:MAIL.SMTP[mail.yourdomain.ru[:port]]
                   smtp_server_port=vmail_conf->get_hash()->get(String::Body("SMTP"));
           }
   
         const String *from, *to;  
         const String& letter=letter_hash_to_string(r, method_name, *hash, 0, &from, &to);  
   
 //      r.write_assign_lang(*new(pool) VString(letter));          const String* from=0;
         sendmail(r, method_name, letter, from, to);          String* to=0;
           const String& message=
                   GET_SELF(r, VMail).message_hash_to_string(r, hash, 0, from, 
                           smtp_server_port?true:false /*send by SMTP=strip to?*/, to);
   
           if(print_debug)
                   r.write_pass_lang(message);
           else
                   sendmail(vmail_conf, smtp_server_port, message, from, to, soptions);
 }  }
   
 // constructor & configurator  // constructor & configurator
   
 MMail::MMail(Pool& apool) : Methoded(apool),  MMail::MMail(): Methoded(MAIL_CLASS_NAME) {
         mail_name(apool, MAIL_NAME),  
         content_disposition_name(apool, CONTENT_DISPOSITION_NAME),  
         content_disposition_filename_name(apool, CONTENT_DISPOSITION_FILENAME_NAME)  
 {  
         set_name(*NEW String(pool(), MAIL_CLASS_NAME));  
   
         // ^mail:send{hash}          // ^mail:send{hash}
         add_native_method("send", Method::CT_STATIC, _send, 1, 1);          add_native_method("send", Method::CT_STATIC, _send, 1, 1);
 }  }
   
 void MMail::configure_user(Request& r) {  void MMail::configure_user(Request& r) {
         Pool& pool=r.pool();  
   
         // $MAIN:MAIL[$SMTP[mail.design.ru]]          // $MAIN:MAIL[$SMTP[mail.design.ru]]
         if(Value *mail_element=r.main_class->get_element(mail_name))          if(Value* mail_element=r.main_class.get_element(mail_name))
                 if(Hash *mail_conf=mail_element->get_hash(0))                  if(mail_element->get_hash())
                         r.classes_conf.put(name(), mail_conf);                          r.classes_conf.put(name(), mail_element);
                 else                  else
                         throw Exception(0, 0,                          if( !mail_element->is_string() )
                                 0,                                  throw Exception(PARSER_RUNTIME,
                                 "$" MAIL_CLASS_NAME ":" MAIL_NAME " is not hash");                                          0,
 }                                          "$" MAIL_CLASS_NAME ":" MAIL_NAME " is not hash");
   
 // creator  
   
 Methoded *MMail_create(Pool& pool) {  
         return mail_class=new(pool) MMail(pool);  
 }  }
Removed from v.1.46  
changed lines
  Added in v.1.122

E-mail: