udp_mail.c-Dateireferenz

#include <udp.h>
#include <udp_mail.h>
Include-Abhängigkeitsdiagramm für udp_mail.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define DEBUG(x)

Funktionen

private int match_mud_name (string mudname, string match_str)
static void save_spool_item ()
void deliver_mail (string recipient, string mud, string from, string subj, string mail_body, int status_flag, string spool_name)
static void start_retry_callout ()
static void remove_from_spool (string spool_file)
static void retry_send ()
static void failed_to_deliver (mapping data)
static void get_pending_deliveries ()
void create ()
int query_valid_mail_host (string hostname)
void udp_reply (mapping data)

Variablen

mapping spool_item
static string * spool

Makro-Dokumentation

#define DEBUG ( x   ) 

Definiert in Zeile 22 der Datei udp_mail.c.

Dokumentation der Funktionen

void create (  ) 

Definiert in Zeile 189 der Datei udp_mail.c.

Benutzt get_pending_deliveries().

00190 {
00191                 seteuid(getuid(this_object()));
00192   get_pending_deliveries();
00193 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void deliver_mail ( string  recipient,
string  mud,
string  from,
string  subj,
string  mail_body,
int  status_flag,
string  spool_name 
)

Definiert in Zeile 209 der Datei udp_mail.c.

00211 {
00212   mapping data;
00213 
00214   // Geloggt wird, wenn ein aufrufendes Objekt nicht sicher ist.
00215   if (object_name(previous_object())[0..7]!="/secure/")
00216     write_file("/secure/ARCH/DELIVER_MAIL",
00217       sprintf("%s : Aufruf von /secure/udp_mail->deliver_mail()\n"
00218               "  Sender: %O Empfaenger: %O@%O\n  PO: %O TI: %O TP:%O\n\n",
00219               ctime(time()),from, recipient, mud,
00220               previous_object(), this_interactive(), this_player()));
00221   
00222   data=([
00223                 REQUEST: "mail",
00224                 RECIPIENT: recipient,
00225         SENDER: this_object(),
00226                 UDPM_STATUS: status_flag,
00227                 UDPM_WRITER: lower_case(from),
00228                 UDPM_SUBJECT: subj,
00229         UDPM_SPOOL_NAME: spool_name,
00230                 DATA: mail_body
00231   ]);
00232 
00233   INETD->_send_udp(mud,data,1);
00234 }

static void failed_to_deliver ( mapping  data  )  [static]

Definiert in Zeile 131 der Datei udp_mail.c.

Benutzt DATA, find_player(), LOCAL_MAILER, LOCAL_NAME, msg(), NAME, RECIPIENT, save_spool_item(), spool_item, start_retry_callout(), SYSTEM, TIME_OUT, UDPM_SUBJECT, UDPM_WRITER, UDPMS_BODY, UDPMS_DEST, UDPMS_FROM, UDPMS_SUBJECT, UDPMS_TIME und UDPMS_TO.

00132 {
00133   string msg;
00134   object obj;
00135 
00136   if(!data[SYSTEM] || data[SYSTEM] != TIME_OUT)
00137     {
00138       msg="Reason: Error in connection to remote site \""+data[NAME]+"\"\n\n"+
00139                 "INCLUDED MESSAGE FOLLOWS :-\n\n"+
00140                 "To: "+data[RECIPIENT]+"\n"+
00141                 "Subject: "+data[UDPM_SUBJECT]+"\n"+data[DATA];
00142 
00143       LOCAL_MAILER->deliver_mail(
00144                                 data[UDPM_WRITER],              /* TO */
00145                                 "Mailer@"+LOCAL_NAME,           /* FROM */
00146                                 "Bounced Mail",                 /* SUBJECT */
00147                                 msg                                             /* MAIL BODY */
00148       );
00149       return;
00150     }
00151 
00152   /* OK transmission timed out.. place in mail spool */
00153   
00154   if((obj=find_player(data[UDPM_WRITER])))
00155     {
00156       tell_object(obj,"Mail delivery to "+data[RECIPIENT]+"@"+data[NAME]+
00157                 " Timed Out. Placing mail in spool.\n");
00158     }
00159 
00160   spool_item=([
00161                 UDPMS_TIME:     time(),
00162                 UDPMS_TO:       data[RECIPIENT],
00163                 UDPMS_DEST:     data[NAME],
00164                 UDPMS_FROM:     data[UDPM_WRITER],
00165                 UDPMS_SUBJECT:  data[UDPM_SUBJECT],
00166                 UDPMS_BODY:     data[DATA]
00167   ]);
00168 
00169   save_spool_item();
00170 
00171   start_retry_callout();
00172 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void get_pending_deliveries (  )  [static]

Definiert in Zeile 174 der Datei udp_mail.c.

Benutzt i, spool, start_retry_callout() und UDPM_SPOOL_DIR.

Wird benutzt von create().

00175 {
00176   string *entries;
00177   int i;
00178 
00179   entries=get_dir(UDPM_SPOOL_DIR+"*.o");
00180   if(!entries || !sizeof(entries)) return;
00181 
00182   spool=allocate(sizeof(entries));
00183   for(i=0;i<sizeof(entries);++i)
00184     spool[i]=entries[i][0..<3];
00185 
00186   start_retry_callout();
00187 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

private int match_mud_name ( string  mudname,
string  match_str 
)

Definiert in Zeile 28 der Datei udp_mail.c.

00028                                                              {
00029     return mudname[0..strlen(match_str)-1] == match_str;
00030 }

int query_valid_mail_host ( string  hostname  ) 

Definiert in Zeile 199 der Datei udp_mail.c.

Benutzt INETD.

00200 {
00201   string *match;
00202 
00203   match=filter(m_indices((mapping)INETD->query("hosts")),
00204                                 #'match_mud_name,lower_case(hostname));
00205 
00206   return (sizeof(match)==1);
00207 }

static void remove_from_spool ( string  spool_file  )  [static]

Definiert in Zeile 60 der Datei udp_mail.c.

Benutzt INETD_LOG_FILE, log_file, member_array(), spool und UDPM_SPOOL_DIR.

Wird benutzt von retry_send().

00061 {
00062   int idx;
00063 
00064   if(spool && (idx=member_array(spool_file,spool))!=-1)
00065     {
00066       spool -= ({ spool_file });
00067       if(!sizeof(spool))
00068         spool=-0;
00069     }
00070 
00071   if(file_size("/"+UDPM_SPOOL_DIR+spool_file+".o")>0)
00072     if(!rm("/"+UDPM_SPOOL_DIR+spool_file+".o"))
00073       log_file(INETD_LOG_FILE,"UPD_MAIL: Can't delete spool file "+
00074                                 "/"+UDPM_SPOOL_DIR+spool_file+".o");
00075 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static void retry_send (  )  [static]

Definiert in Zeile 77 der Datei udp_mail.c.

Benutzt deliver_mail(), i, INETD_LOG_FILE, LOCAL_MAILER, LOCAL_NAME, log_file, msg(), remove_from_spool(), restore_object(), spool, spool_item, start_retry_callout(), UDPM_SEND_FAIL, UDPM_SPOOL_DIR, UDPM_STATUS_IN_SPOOL, UDPMS_BODY, UDPMS_DEST, UDPMS_FROM, UDPMS_SUBJECT, UDPMS_TIME und UDPMS_TO.

00078 {
00079   int i;
00080   string msg;
00081 
00082   if(!spool || !sizeof(spool)) return;
00083 
00084   for(i=0;i<sizeof(spool);++i)
00085     {
00086       if(!restore_object(UDPM_SPOOL_DIR+spool[i]))
00087         {
00088           log_file(INETD_LOG_FILE,"UDP_MAIL: Falied to restore spool file "+
00089                                 UDPM_SPOOL_DIR+spool[i]);
00090           continue;
00091         }
00092 
00093       if(time() - spool_item[UDPMS_TIME] > UDPM_SEND_FAIL*60)
00094         {
00095           msg="Reason: Unable to connect to site \""+spool_item[UDPMS_DEST]+
00096                                 "\"\n\nINCLUDED MESSAGE FOLLOWS :-\n\n"+
00097                                 "To: "+spool_item[UDPMS_TO]+"\n"+
00098                                 "Subject: "+spool_item[UDPMS_SUBJECT]+"\n"+
00099                                 spool_item[UDPMS_BODY];
00100 
00101           LOCAL_MAILER->deliver_mail(
00102                                 spool_item[UDPMS_FROM],         /* TO */
00103                                 "Mailer@"+LOCAL_NAME,           /* FROM */
00104                                 "Bounced Mail",                 /* SUBJECT */
00105                                 msg                                             /* MAIL BODY */
00106                   );
00107           remove_from_spool(spool[i]);
00108           return;
00109         }
00110 
00111       deliver_mail(
00112                 spool_item[UDPMS_TO],
00113                 spool_item[UDPMS_DEST],
00114                 spool_item[UDPMS_FROM],
00115                 spool_item[UDPMS_SUBJECT],
00116                 spool_item[UDPMS_BODY],
00117                 UDPM_STATUS_IN_SPOOL,
00118                 spool[i]);
00119     }
00120 
00121   start_retry_callout();
00122 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void save_spool_item (  )  [static]

Definiert in Zeile 32 der Datei udp_mail.c.

Benutzt count, member_array(), name, save_object(), spool, spool_item, UDPM_SPOOL_DIR und UDPMS_DEST.

Wird benutzt von failed_to_deliver().

00033 {
00034   string name;
00035   int count;
00036 
00037   if(!spool_item || !mappingp(spool_item) || spool_item==([]))
00038     return;
00039 
00040   do {
00041     ++count;
00042     name=spool_item[UDPMS_DEST]+"-"+to_string(count);
00043   } while(spool && member_array(name,spool)!=-1);
00044 
00045   save_object(UDPM_SPOOL_DIR+name);
00046 
00047   if(!spool || !sizeof(spool))
00048     spool = ({ name });
00049   else
00050     spool += ({ name });
00051 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static void start_retry_callout (  )  [static]

Definiert in Zeile 124 der Datei udp_mail.c.

Benutzt call_out() und UDPM_RETRY_SEND.

Wird benutzt von failed_to_deliver(), get_pending_deliveries() und retry_send().

00125 {
00126   if(find_call_out("retry_send")!= -1 ) return;
00127 
00128   call_out("retry_send",UDPM_RETRY_SEND*60);
00129 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void udp_reply ( mapping  data  ) 

Definiert in Zeile 236 der Datei udp_mail.c.

00237 {
00238   object sender;
00239 
00240   DEBUG(sprintf("MAILER RECEIVED %O\n",data));
00241   if (!member(data,UDPM_STATUS))
00242   {
00243      DEBUG("BOUNCING\n");
00244      LOCAL_MAILER->deliver_mail(
00245         data[UDPM_WRITER],      /* TO */
00246                 "INETD@"+data[NAME],            /* FROM */
00247                 "Bounced Mail(No mail support yet?)",                           /* SUBJECT */
00248                 data[DATA]                      /* MAIL BODY */
00249                 );
00250         if(data[UDPM_SPOOL_NAME])
00251           remove_from_spool(data[UDPM_SPOOL_NAME]);
00252   } else
00253   switch(data[UDPM_STATUS])
00254     {
00255       case UDPM_STATUS_TIME_OUT:
00256         failed_to_deliver(data);
00257         break;
00258 
00259       case UDPM_STATUS_DELIVERED_OK:
00260         if((sender=find_player(data[UDPM_WRITER])))
00261           {
00262             tell_object(sender,"Mailer@"+data[NAME]+": "+
00263                                 "Mail to "+capitalize(data[DATA])+" delivered ok.\n");
00264           }
00265         if(data[UDPM_SPOOL_NAME])
00266           remove_from_spool(data[UDPM_SPOOL_NAME]);
00267 
00268         break;
00269 
00270       case UDPM_STATUS_UNKNOWN_PLAYER:
00271         LOCAL_MAILER->deliver_mail(
00272                                 data[UDPM_WRITER],              /* TO */
00273                                 "Mailer@"+data[NAME],           /* FROM */
00274                                 "Bounced Mail",                 /* SUBJECT */
00275                                 data[DATA]                      /* MAIL BODY */
00276                 );
00277         if(data[UDPM_SPOOL_NAME])
00278           remove_from_spool(data[UDPM_SPOOL_NAME]);
00279         break;
00280 
00281                 case UDPM_STATUS_IN_SPOOL:
00282           /* Do nothing */
00283           break;
00284     }
00285 }

Variablen-Dokumentation

string* spool [static]

Definiert in Zeile 26 der Datei udp_mail.c.

Wird benutzt von get_pending_deliveries(), remove_from_spool(), retry_send() und save_spool_item().

mapping spool_item

Definiert in Zeile 24 der Datei udp_mail.c.

Wird benutzt von failed_to_deliver(), retry_send() und save_spool_item().

Erzeugt am Thu Jun 3 14:42:03 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3