[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.7 and 1.88.2.8

version 1.7, 2001/04/07 15:34:56 version 1.88.2.8, 2003/02/17 07:18:57
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-2003 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)  
   
         $Id$  
 */  */
   
 #include "pa_config_includes.h"  static const char* IDENT_MAIL_C="$Date$";
   
 #ifdef WIN32  #include "pa_config_includes.h"
 #       include "smtp/smtp.h"  #include "pa_vmethod_frame.h"
 #endif  
   
 #include "_mail.h"  
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_vfile.h"  #include "pa_vfile.h"
   #include "pa_exec.h"
   #include "pa_charsets.h"
   #include "pa_charset.h"
   #include "pa_uue.h"
   
 // global var  #ifdef _MSC_VER
   #       include "smtp/smtp.h"
   #endif
   
 VStateless_class *mail_class;  // defines
   
 // helpers  #define MAIL_CLASS_NAME "mail"
   
 /// ^mail:send[$attach[$type[uue|mime64] $value[DATA]]]   // consts
 static const String& attach_hash_to_string(Request& r, const String& origin_string,   
                                                                                    Hash& attach_hash) {  
         Pool& pool=r.pool();  
   
         Value *vtype=static_cast<Value *>(attach_hash.get(*new(pool) String(pool, "type")));  const int ATTACHMENT_WEIGHT=100;
         if(!vtype)  
                 PTHROW(0, 0,  // class
                         &origin_string,  
                         "has no $type");  
   
         Value *value=static_cast<Value *>(attach_hash.get(*value_name));  
         if(!value)  
                 PTHROW(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"))))  
                 file_name=&vfile_name->as_string();  
         else  
                 file_name=new(pool) String(pool, "noname.dat");  
   
         String& result=*new(pool) String(pool);  
   
         // content-disposition: attachment; filename="user_file_name"  
         result+="content-disposition: attachment; filename=\"";  
         result+=file_name->cstr(String::UL_FILE_NAME);  
         result+="\"\n";  
   
         const String& type=vtype->as_string();  
         if(type=="uue") {  
                 // content-transfer-encoding: x-uuencode  
                 result+="content-transfer-encoding: x-uuencode\n";  
                 result+="\n";  
                 result+="todo";  
         } else   
                 PTHROW(0, 0,  
                         &type,  
                         "unknown encode type");  
           
         return result;  
 }  
   
   class MMail : public Methoded {
   public: // Methoded
           bool used_directly() { return false; }
           void configure_user(Request& r);
   
 struct Mail_info {  public:
         String *attribute_to_exclude;          MMail();
         String *header;  
         const String **from, **to;  
 };  };
   
 static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,   // global variable
                                                                  void *info) {  
   
         Value& lmeaning=*static_cast<Value *>(ameaning);  MethodedPtr mail_class(0);
         Mail_info& mi=*static_cast<Mail_info *>(info);  MethodedPtr mail_base_class(new MMail);
   
         // exclude one attribute [body]  // defines for statics
         if(aattribute==*mi.attribute_to_exclude)  
                 return;  
   
         // fetch from & to from header for SMTP  
         if(mi.from && aattribute=="from")  
                 *mi.from=&lmeaning.as_string();  
         if(mi.to && aattribute=="to")  
                 *mi.to=&lmeaning.as_string();  
   
         // append header line  
         *mi.header+=aattribute;  
         *mi.header+=":";  
         *mi.header+=attributed_meaning_to_string(lmeaning, String::UL_MAIL_HEADER);  
         *mi.header+="\n";  
 }  
 struct Seq_item {  
         const String *part_name;  
         Value *part_value;  
 };  
 static void add_part(const Hash::Key& part_name, Hash::Val *part_value,   
                                          void *info) {  
         Seq_item **seq_ref=static_cast<Seq_item **>(info);  
         (**seq_ref).part_name=&part_name;  
         (**seq_ref).part_value=static_cast<Value *>(part_value);  
         (*seq_ref)++;  
 }  
 static double key_of_part(const void *item) {  
         const char *cstr=static_cast<const Seq_item *>(item)->part_name->cstr();  
         char *error_pos;  
         return strtod(cstr, &error_pos);  
 }  
 static int sort_cmp_string_double_value(const void *a, const void *b) {  
         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"  #define MAIL_NAME "MAIL"
         String& result=*new(pool) String(pool);  
         Mail_info mail_info={  
                 /*excluding*/ body_name,  
                 &result,  
                 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()) {  
                         char *boundary=(char *)pool.malloc(MAX_NUMBER);  
                         snprintf(boundary, MAX_NUMBER, "%d", level);  
                         // multi-part  
                         ((result+=  
                                 "content-type: multipart/mixed; boundary=\"")+=boundary)+="\"\n"  
                                 "\n"  
                                 "This is a multi-part message in MIME format.";  
   
                         // body parts..  
                         // ..collect  
                         Seq_item *seq=(Seq_item *)malloc(sizeof(Seq_item)*body_hash->size());  
                         Seq_item *seq_ref=seq;  body_hash->for_each(add_part, &seq_ref);  
                         // ..sort  
                         _qsort(seq, body_hash->size(), sizeof(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())  
                                         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  
                                         PTHROW(0, 0,  
                                                 seq[i].part_name,  
                                                 "part is not hash");  
                         }  
   
                         // finish boundary  
                         ((result+="\n--")+=boundary)+="--\n";  
                 } else {  
                         result+="\n"; // header|body separator  
                         result+=body_element->as_string();  // body  
                 }  
         } else   
                 PTHROW(0, 0,  
                         &method_name,  
                         "has no $body");  
   
         return result;  // statics
 }          
   static StringPtr mail_name(new String(MAIL_NAME));
   
 /// @test unix ver  // helpers
 static void sendmail(Request& r, const String& method_name,   
                                          const String& letter,   static void sendmail(Request& r, StringPtr method_name, 
                                          const String *from, const String *to) {                                           StringPtr message, 
                                            StringPtr from, StringPtr to) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
 #ifdef WIN32          CharPtr message_cstr=message->cstr(String::UL_UNSPECIFIED);
         if(!from)          Value* vmail_conf=static_cast<Value*>(r.classes_conf.get(mail_base_class->name()).get());
                 PTHROW(0, 0,  
                         &method_name,          const char *exception_type="email.format";
                         "not specified 'from'");          if(!from) // we use in sendmail -f {from} && SMTP MAIL from: {from}
         if(!to)                  throw Exception(exception_type,
                 PTHROW(0, 0,                          method_name,
                         &method_name,                          "parameter does not specify 'from' header field");
                         "not specified 'to'");  
   #ifdef _MSC_VER
         char *letter_cstr=letter.cstr();          if(!to) // we use only in SMTP RCPT to: {to}
         SMTP& smtp=*new(pool) SMTP(pool, method_name);                  throw Exception(exception_type,
         Value *server_port;                          method_name,
         // $MAIN:MAIL.SMTP[mail.design.ru]                          "parameter does not specify 'to' header field");
         if(r.mail &&   
                 (server_port=static_cast<Value *>(r.mail->get(          SMTPPtr smtp(new SMTP(method_name));
                         *new(pool) String(pool, "SMTP"))))) {          ValuePtr server_port;
                 char *server=server_port->as_string().cstr();          // $MAIN:MAIL.SMTP[mail.yourdomain.ru[:port]]
                 char *port=rsplit(server, ':');          if(vmail_conf && 
                   (server_port=vmail_conf->get_hash(method_name)->get(StringPtr(new String("SMTP"))))) {
                   CharPtr server=server_port->as_string(&pool)->cstr();
                   const char *port=rsplit(server, ':');
                 if(!port)                  if(!port)
                         port=const_cast<char *>("25");                          port="25";
   
                 smtp.Send(server, port, letter_cstr, from->cstr(), to->cstr());                  smtp->Send(server, port, message_cstr, from->cstr(), to->cstr());
         } else          } else
                 PTHROW(0, 0,                  throw Exception("parser.runtime",
                         &method_name,                          method_name,
                         "$MAIN:MAIL.SMTP not defined");                          "$"MAIN_CLASS_NAME":"MAIL_NAME".SMTP not defined");
 #else  #else
         PTHROW(0, 0,          // unix
                 &method_name,          // $MAIN:MAIL.sendmail["/usr/sbin/sendmail -t -i -f postmaster"] default
                 "todo");          // $MAIN:MAIL.sendmail["/usr/lib/sendmail -t -i  -f postmaster"] default
   
           const String *sendmail_command;
           const char *sendmailkey_cstr="sendmail";
           if(mail_conf) {
   #ifdef PA_FORCED_SENDMAIL
                   throw Exception("parser.runtime",
                           method_name,
                           "Parser was configured with --with-sendmail="PA_FORCED_SENDMAIL
                           " key, to change sendmail you should reconfigure and recompie it");
   #else
                   if(Value *sendmail_value=static_cast<Value *>(mail_conf->get(String(pool, sendmailkey_cstr))))
                           sendmail_command=&sendmail_value->as_string();
                   else
                           throw Exception("parser.runtime",
                                   method_name,
                                   "$"MAIN_CLASS_NAME":"MAIL_NAME".%s not defined", 
                                   sendmailkey_cstr);
 #endif  #endif
 }          } else {
   #ifdef PA_FORCED_SENDMAIL
                   sendmail_command=new(pool) String(pool, PA_FORCED_SENDMAIL);
   #else
                   String *test=new(pool) String(pool, "/usr/sbin/sendmail");
                   if(!file_executable(*test))
                           test=new(pool) String(pool, "/usr/lib/sendmail");
                   test->APPEND_CONST(" -t -i -f postmaster");
                   sendmail_command=test;
   #endif
           }
   
           // we know sendmail_command here, should replace "postmaster" with "$from" from message
           int at_postmaster=sendmail_command->pos("postmaster");
           if(at_postmaster>0) {
                   String& reconstructed=sendmail_command->mid(0, at_postmaster);
                   reconstructed << *from;
                   reconstructed << sendmail_command->mid(at_postmaster+10/*postmaster*/, sendmail_command->size());
                   sendmail_command=&reconstructed;
           }
   
           // execute it
           Array argv(pool);
           const String *file_spec;
           int after_file_spec=sendmail_command->pos(" ", 1);
           if(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, " ", 1, String::UL_AS_IS);
           }
   
           if(!file_executable(*file_spec))
                   throw Exception("email.send",
                           file_spec, 
                           "is not executable."
   #ifdef PA_FORCED_SENDMAIL
                           " Use configure key \"--with-sendmail=appropriate sendmail command\""
   #else
                           " Set $"MAIN_CLASS_NAME":"MAIL_NAME".%s to appropriate sendmail command", 
                                   sendmailkey_cstr
   #endif
                   );
   
   
           String in(pool, message_cstr); String out(pool); String err(pool);
           int exit_status=pa_exec(
                   // forced_allow
   #ifdef PA_FORCED_SENDMAIL
                   true
   #else
                   false
   #endif
                   , *file_spec,
                   0/*default env*/,
                   &argv,
                   in, out, err);
           if(exit_status || err.size())
                   throw Exception("email.send",
                           method_name,
                           "'%s' reported problem: %s (%d)",
                                   file_spec->cstr(),
                                   err.size()?err.cstr():"UNKNOWN", 
                                   exit_status);
   #endif
   }
   
 // methods  // methods
   
 static void _send(Request& r, const String& method_name, Array *params) {  static void _send(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& vhash=*static_cast<Value *>(params->get(0));          ValuePtr vhash=params.as_no_junction(0, "message must not be code");
         // forcing [this body type]          HashStringValue* hash=vhash->get_hash(method_name);
         r.fail_if_junction_(true, vhash, method_name, "message must not be code");  
   
         Hash *hash=vhash.get_hash();  
         if(!hash)          if(!hash)
                 PTHROW(0, 0,                  throw Exception("parser.runtime",
                         &method_name,                          method_name,
                         "message must be hash");                          "message must be hash");
   
         const String *from, *to;          StringPtr from(0);
         const String& letter=letter_hash_to_string(r, method_name, *hash, 0, &from, &to);          StringPtr to(0);
           StringPtr message=
                   GET_SELF(r, VMail).message_hash_to_string(r, method_name, hash, 0, from, to);
   
         r.write_assign_lang(*new(pool) VString(letter));          //r.write_pass_lang(message);
         //sendmail(r, method_name, letter, from, to);          sendmail(r, method_name, message, from, to);
 }  }
   
 // initialize  // constructor & configurator
 void initialize_mail_class(Pool& pool, VStateless_class& vclass) {  
   MMail::MMail(): Methoded(MAIL_CLASS_NAME) {
         // ^mail:send{hash}          // ^mail:send{hash}
         vclass.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) {
           Pool& pool=r.pool();
   
           // $MAIN:MAIL[$SMTP[mail.design.ru]]
           if(ValuePtr mail_element=r.main_class->get_element(mail_name, *r.main_class, false))
                   if(mail_element->get_hash(Exception::undefined_source))
                           r.classes_conf.put(name(), mail_element);
                   else
                           if( !mail_element->is_string() )
                                   throw Exception("parser.runtime",
                                           Exception::undefined_source,
                                           "$" MAIL_CLASS_NAME ":" MAIL_NAME " is not hash");
 }  }
Removed from v.1.7  
changed lines
  Added in v.1.88.2.8

E-mail: