开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mail.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：22k
源码类别：

MySQL数据库

开发平台：

Visual C++

mail.c：源码内容
  1. /*
  2.  * Copyright (C) 2001  Dizzy (dizzy@roedu.net)
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  */
  18. #define MAIL_INTERNAL_ACCESS
  19. #include "common/setup_before.h"
  20. #include <stdio.h>
  21. #ifdef HAVE_STDDEF_H
  22. # include <stddef.h>
  23. #else
  24. # ifndef NULL
  25. #  define NULL ((void *)0)
  26. # endif
  27. #endif
  28. #ifdef STDC_HEADERS
  29. # include <stdlib.h>
  30. #else
  31. # ifdef HAVE_MALLOC_H
  32. #  include <malloc.h>
  33. # endif
  34. #endif
  35. #ifdef HAVE_STRING_H
  36. # include <string.h>
  37. #else
  38. # ifdef HAVE_STRINGS_H
  39. #  include <strings.h>
  40. # endif
  41. #endif
  42. #include "compat/strcasecmp.h"
  43. #include <ctype.h>
  44. #include <errno.h>
  45. #include "compat/strerror.h"
  46. #ifdef TIME_WITH_SYS_TIME
  47. # include <sys/time.h>
  48. # include <time.h>
  49. #else
  50. # ifdef HAVE_SYS_TIME_H
  51. #  include <sys/time.h>
  52. # else
  53. #  include <time.h>
  54. # endif
  55. #endif
  56. #ifdef HAVE_SYS_TYPES_H
  57. # include <sys/types.h>
  58. #endif
  59. #ifdef HAVE_SYS_STAT_H
  60. # include <sys/stat.h>
  61. #endif
  62. #ifdef HAVE_UNISTD_H
  63. # include <unistd.h>
  64. #endif
  65. #include "compat/statmacros.h"
  66. #include "compat/mkdir.h"
  67. #include "compat/pdir.h"
  68. #ifdef HAVE_FCNTL_H
  69. # include <fcntl.h>
  70. #else
  71. # ifdef HAVE_SYS_FILE_H
  72. #  include <sys/file.h>
  73. # endif
  74. #endif
  75. #include "message.h"
  76. #include "connection.h"
  77. #include "common/util.h"
  78. #include "common/eventlog.h"
  79. #include "account.h"
  80. #include "prefs.h"
  81. #include "mail.h"
  82. #include "common/setup_after.h"
  85. static int identify_mail_function(const char *);
  86. static void mail_usage(t_connection*);
  87. static void mail_func_send(t_connection*,const char *);
  88. static void mail_func_read(t_connection*,const char *);
  89. static void mail_func_delete(t_connection*,const char *);
  90. static int get_mail_quota(t_account *);
  92. /* Mail API */
  93. /* for now this functions are only for internal use */
  94. static t_mailbox * mailbox_open(t_account *);
  95. static int mailbox_count(t_mailbox *);
  96. static int mailbox_deliver(t_mailbox *, const char *, const char *);
  97. static t_mail * mailbox_read(t_mailbox *, unsigned int);
  98. static void mailbox_unread(t_mail*);
  99. static struct maillist_struct * mailbox_get_list(t_mailbox *);
  100. static void mailbox_unget_list(struct maillist_struct *);
  101. static int mailbox_delete(t_mailbox *, unsigned int);
  102. static int mailbox_delete_all(t_mailbox *);
  103. static void mailbox_close(t_mailbox *);
  105. static char * clean_str(char *);
  108. static t_mailbox * mailbox_open(t_account * user) {
  109.    t_mailbox * rez;
  110.    char * path;
  111.    char const * maildir;
  113.    if ((rez=malloc(sizeof(t_mailbox)))==NULL) {
  114.       eventlog(eventlog_level_error,"mailbox_open","not enough memory");
  115.       return NULL;
  116.    }
  117.    maildir=prefs_get_maildir();
  118.    p_mkdir(maildir,S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
  119.    if ((path=malloc(strlen(maildir)+1+8+1))==NULL) {
  120.       eventlog(eventlog_level_error,"mailbox_open","not enough memory");
  121.       free(rez);
  122.       return NULL;
  123.    }
  124.    if (maildir[0]!='' && maildir[strlen(maildir)-1]=='/')
  125.       sprintf(path,"%s%06u",maildir,account_get_uid(user));
  126.    else
  127.       sprintf(path,"%s/%06u",maildir,account_get_uid(user));
  128.    p_mkdir(path,S_IRWXU | S_IXGRP | S_IRGRP | S_IROTH | S_IXOTH);
  129.    if ((rez->maildir=p_opendir(path))==NULL) {
  130.       eventlog(eventlog_level_error,"mailbox_open","error opening maildir");
  131.       free(path);
  132.       free(rez);
  133.       return NULL;
  134.    }
  135.    rez->uid=account_get_uid(user);
  136.    rez->path=path;
  137.    return rez;
  138. }
  140. static int mailbox_count(t_mailbox *mailbox) {
  141.    char const * dentry;
  142.    int count=0;
  143.    
  144.    if (mailbox==NULL) {
  145.       eventlog(eventlog_level_error,"mailbox_count","got NULL mailbox");
  146.       return -1;
  147.    }
  148.    if (mailbox->maildir==NULL) {
  149.       eventlog(eventlog_level_error,"mailbox_count","got NULL maildir");
  150.       return -1;
  151.    }
  152.    p_rewinddir(mailbox->maildir);
  153.    while ((dentry=p_readdir(mailbox->maildir))!=NULL) if (dentry[0]!='.') count++;
  154.    return count;
  155. }
  157. static int mailbox_deliver(t_mailbox * mailbox, const char * sender, const char * message) {
  158.    FILE * fd;
  159.    char * filename;
  161.    if (mailbox==NULL) {
  162.       eventlog(eventlog_level_error,"mailbox_deliver","got NULL mailbox");
  163.       return -1;
  164.    }
  165.    if (mailbox->maildir==NULL) {
  166.       eventlog(eventlog_level_error,"mailbox_deliver","got NULL maildir");
  167.       return -1;
  168.    }
  169.    if (mailbox->path==NULL) {
  170.       eventlog(eventlog_level_error,"mailbox_deliver","got NULL path");
  171.       return -1;
  172.    }
  173.    if ((filename=malloc(strlen(mailbox->path)+1+15+1))==NULL) {
  174.       eventlog(eventlog_level_error,"mailbox_deliver","not enough memory for filename");
  175.       return -1;
  176.    }
  177.    sprintf(filename,"%s/%015lu",mailbox->path,(unsigned long)time(NULL));
  178.    if ((fd=fopen(filename,"wb"))==NULL) {
  179.       eventlog(eventlog_level_error,"mailbox_deliver","got NULL file descriptor. check permissions");
  180.       free(filename);
  181.       return -1;
  182.    }
  183.    fprintf(fd,"%sn",sender); /* write the sender on the first line of message */
  184.    fprintf(fd,"%sn",message); /* then write the actual message */
  185.    fclose(fd);
  186.    free(filename);
  187.    return 0;
  188. }
  190. static t_mail * mailbox_read(t_mailbox * mailbox, unsigned int idx) {
  191.    char const * dentry;
  192.    unsigned int i;
  193.    t_mail *     rez;
  194.    FILE *       fd;
  195.    char *       filename;
  196.    
  197.    if (mailbox==NULL) {
  198.       eventlog(eventlog_level_error,"mailbox_read","got NULL mailbox");
  199.       return NULL;
  200.    }
  201.    if (mailbox->maildir==NULL) {
  202.       eventlog(eventlog_level_error,"mailbox_read","got NULL maildir");
  203.       return NULL;
  204.    }
  205.    if ((rez=malloc(sizeof(t_mail)))==NULL) {
  206.       eventlog(eventlog_level_error,"mailbox_read","not enough memory for message");
  207.       return NULL;
  208.    }
  209.    p_rewinddir(mailbox->maildir);
  210.    dentry = NULL; /* if idx < 1 we should not crash :) */
  211.    for(i=0;i<idx && (dentry=p_readdir(mailbox->maildir))!=NULL;i++)
  212.      if (dentry[0]=='.') i--;
  213.    if (dentry==NULL) {
  214.       eventlog(eventlog_level_error,"mailbox_read","index out of range");
  215.       free(rez);
  216.       return NULL;
  217.    }
  218.    rez->timestamp=atoi(dentry);
  219.    if ((filename=malloc(strlen(dentry)+1+strlen(mailbox->path)+1))==NULL) {
  220.       eventlog(eventlog_level_error,"mailbox_read","not enough memory for filename");
  221.       free(rez);
  222.       return NULL;
  223.    }
  224.    sprintf(filename,"%s/%s",mailbox->path,dentry);
  225.    if ((fd=fopen(filename,"rb"))==NULL) {
  226.       eventlog(eventlog_level_error,"mailbox_read","error while opening message");
  227.       free(rez);
  228.       free(filename);
  229.       return NULL;
  230.    }
  231.    free(filename);
  232.    if ((rez->sender=malloc(256))==NULL) {
  233.       eventlog(eventlog_level_error,"mailbox_read","not enough memory for storing sender");
  234.       fclose(fd);
  235.       free(rez);
  236.       return NULL;
  237.    }
  238.    fgets(rez->sender,256,fd); /* maybe 256 isnt the right value to bound a line but right now its all i have :) */
  239.    clean_str(rez->sender);
  240.    if ((rez->message=malloc(256))==NULL) {
  241.       eventlog(eventlog_level_error,"mailbox_read","not enough memory for storing message");
  242.       fclose(fd);
  243.       free(rez->sender);
  244.       free(rez);
  245.       return NULL;
  246.    }
  247.    fgets(rez->message,256,fd);
  248.    clean_str(rez->message);
  249.    fclose(fd);
  250.    rez->timestamp=atoi(dentry);
  251.    return rez;
  252. }
  254. static void mailbox_unread(t_mail * mail) {
  255.    if (mail==NULL)
  256.      eventlog(eventlog_level_error,"mailbox_unread","got NULL mail");
  257.    else {
  258.       if (mail->sender==NULL)
  259. eventlog(eventlog_level_error,"mailbox_unread","got NULL sender");
  260.       else free(mail->sender);
  261.       if (mail->message==NULL)
  262. eventlog(eventlog_level_error,"mailbox_unread","got NULL message");
  263.       else free(mail->message);
  264.       free(mail);
  265.    }
  266. }
  268. static struct maillist_struct * mailbox_get_list(t_mailbox *mailbox) {
  269.    char const * dentry;
  270.    FILE * fd;
  271.    struct maillist_struct *rez=NULL, *p=NULL,*q;
  272.    char *sender,*filename;
  273.    
  274.    if (mailbox==NULL) {
  275.       eventlog(eventlog_level_error,"mailbox_get_list","got NULL mailbox");
  276.       return NULL;
  277.    }
  278.    if (mailbox->maildir==NULL) {
  279.       eventlog(eventlog_level_error,"mailbox_get_list","got NULL maildir");
  280.       return NULL;
  281.    }
  282.    if ((filename=malloc(strlen(mailbox->path)+1+15+1))==NULL) {
  283.       eventlog(eventlog_level_error,"mailbox_get_list","not enough memory for filename");
  284.       return NULL;
  285.    }
  286.    p_rewinddir(mailbox->maildir);
  287.    for(;(dentry=p_readdir(mailbox->maildir))!=NULL;)
  288.      if (dentry[0]!='.') {
  289. q=malloc(sizeof(struct maillist_struct));
  290. if (q==NULL) {
  291.    eventlog(eventlog_level_error,"mailbox_get_list","not enough memory for list");
  292.    free(filename);
  293.    return rez;
  294. }
  295. sprintf(filename,"%s/%s",mailbox->path,dentry);
  296. if ((fd=fopen(filename,"rb"))==NULL) {
  297.    eventlog(eventlog_level_error,"mailbox_get_list","error while opening message file");
  298.    free(filename);
  299.    free(q);
  300.    return rez;
  301. }
  302. if ((sender=malloc(256))==NULL) {
  303.    eventlog(eventlog_level_error,"mailbox_get_list","not enough memory for sender");
  304.    fclose(fd);
  305.    free(filename);
  306.    free(q);
  307. }
  308. fgets(sender,256,fd);
  309. clean_str(sender);
  310. fclose(fd);
  311. q->sender=sender;
  312. q->timestamp=atoi(dentry);
  313. q->next=NULL;
  314. if (p==NULL) rez=q;
  315. else p->next=q;
  316. p=q;
  317.      }
  318.    free(filename);
  319.    return rez;
  320. }
  322. static void mailbox_unget_list(struct maillist_struct * maill) {
  323.    struct maillist_struct *p, *q;
  324.    
  325.    for(p=maill;p!=NULL;p=q) {
  326.       if (p->sender!=NULL) free(p->sender);
  327.       q=p->next;
  328.       free(p);
  329.    }
  330. }
  332. static int mailbox_delete(t_mailbox * mailbox, unsigned int idx) {
  333.    char *       filename;
  334.    char const * dentry;
  335.    unsigned int i;
  336.    int          rez;
  337.    
  338.    if (mailbox==NULL) {
  339.       eventlog(eventlog_level_error,"mailbox_delete","got NULL mailbox");
  340.       return -1;
  341.    }
  342.    if (mailbox->maildir==NULL) {
  343.       eventlog(eventlog_level_error,"mailbox_delete","got NULL maildir");
  344.       return -1;
  345.    }
  346.    p_rewinddir(mailbox->maildir);
  347.    dentry = NULL; /* if idx < 1 we should not crash :) */
  348.    for(i=0;i<idx && (dentry=p_readdir(mailbox->maildir))!=NULL;i++)
  349.      if (dentry[0]=='.') i--;
  350.    if (dentry==NULL) {
  351.       eventlog(eventlog_level_error,"mailbox_delete","index out of range");
  352.       return -1;
  353.    }
  354.    if ((filename=malloc(strlen(dentry)+1+strlen(mailbox->path)+1))==NULL) {
  355.       eventlog(eventlog_level_error,"mailbox_delete","not enough memory for filename");
  356.       return -1;
  357.    }
  358.    sprintf(filename,"%s/%s",mailbox->path,dentry);
  359.    rez=remove(filename);
  360.    if (rez<0) {
  361.        eventlog(eventlog_level_info,"mailbox_delete","could not remove file "%s" (remove: %s)",filename,strerror(errno));
  362.     }
  363.    free(filename);
  364.    return rez;
  365. }
  367. static int mailbox_delete_all(t_mailbox * mailbox) {
  368.    char *       filename;
  369.    char const * dentry;
  370.    int          count;
  371.    
  372.    if (mailbox==NULL) {
  373.       eventlog(eventlog_level_error,"mailbox_delete_all","got NULL mailbox");
  374.       return -1;
  375.    }
  376.    if (mailbox->maildir==NULL) {
  377.       eventlog(eventlog_level_error,"mailbox_delete_all","got NULL maildir");
  378.       return -1;
  379.    }
  380.    if ((filename=malloc(strlen(mailbox->path)+1+15+1))==NULL) {
  381.       eventlog(eventlog_level_error,"mailbox_delete_all","not enough memory for filename");
  382.       return -1;
  383.    }
  384.    p_rewinddir(mailbox->maildir);
  385.    count = 0;
  386.    while ((dentry=p_readdir(mailbox->maildir))!=NULL)
  387.      if (dentry[0]!='.') {
  388. sprintf(filename,"%s/%s",mailbox->path,dentry);
  389. if (!remove(filename)) count++;
  390.      }
  391.    free(filename);
  392.    return count;
  393. }
  395. static void mailbox_close(t_mailbox *mailbox) {
  396.    if (mailbox==NULL) {
  397.       eventlog(eventlog_level_error,"mailbox_close","got NULL mailbox");
  398.       return;
  399.    }
  400.    if (mailbox->maildir!=NULL) {
  401.       p_closedir(mailbox->maildir);
  402.    } else {
  403.       eventlog(eventlog_level_error,"mailbox_close","got NULL maildir");
  404.    }
  405.    if (mailbox->path) free(mailbox->path);
  406.    free(mailbox);
  407. }
  409. static char * clean_str(char * str) {
  410.    char *p;
  411.    
  412.    for(p=str;*p!='';p++)
  413.      if (*p=='n' || *p=='r') {
  414. *p=''; break;
  415.      }
  416.    return str;
  417. }
  419. extern int handle_mail_command(t_connection * c, char const * text)
  420. {
  421.    unsigned int i,j;
  422.    char         comm[MAX_FUNC_LEN];
  423.    
  424.    if (!prefs_get_mail_support()) { 
  425.       message_send_text(c,message_type_error,c,"This server has NO mail support.");
  426.       return -1;
  427.    }
  428.    
  429.    for (i=0; text[i]!=' ' && text[i]!=''; i++); /* skip /mail command */
  430.    for (; text[i]==' '; i++); /* skip any spaces after it */
  431.    
  432.    for (j=0; text[i]!=' ' && text[i]!='' && j<sizeof(comm)-1; i++) /* get function */
  433.      if (j<sizeof(comm)-1) comm[j++] = text[i];
  434.    comm[j] = '';
  435.    
  436.    switch (identify_mail_function(comm)) {
  437.     case MAIL_FUNC_SEND:
  438.       mail_func_send(c,text+i);
  439.       break;
  440.     case MAIL_FUNC_READ:
  441.       mail_func_read(c,text+i);
  442.       break;
  443.     case MAIL_FUNC_DELETE:
  444.       mail_func_delete(c,text+i);
  445.       break;
  446.     case MAIL_FUNC_HELP:
  447.       message_send_text(c,message_type_info,c,"The mail command supports the following patterns.");
  448.       mail_usage(c);
  449.       break;
  450.     default:
  451.       message_send_text(c,message_type_error,c,"The command its incorrect. Use one of the following patterns.");
  452.       mail_usage(c);
  453.    }
  454.    return 0;
  455. }
  457. static int identify_mail_function(const char *funcstr) {
  458.     if (strcasecmp(funcstr,"send")==0 ||
  459.         strcasecmp(funcstr,"s")==0)
  460. return MAIL_FUNC_SEND;
  461.     if (strcasecmp(funcstr,"read")==0 ||
  462.         strcasecmp(funcstr,"r")==0 ||
  463.         strcasecmp(funcstr,"")==0)
  464. return MAIL_FUNC_READ;
  465.     if (strcasecmp(funcstr,"delete")==0 ||
  466.         strcasecmp(funcstr,"del")==0)
  467. return MAIL_FUNC_DELETE;
  468.     if (strcasecmp(funcstr,"help")==0 ||
  469.         strcasecmp(funcstr,"h")==0)
  470. return MAIL_FUNC_HELP;
  471.     return MAIL_FUNC_UNKNOWN;
  472. }
  474. static int get_mail_quota(t_account * user) {
  475.    int quota;
  476.    char const * user_quota;
  478.    user_quota=account_get_strattr(user,"BNET\auth\mailquota");
  479.    if (user_quota==NULL) quota=prefs_get_mail_quota();
  480.    else {
  481.       quota=atoi(user_quota);
  482.       if (quota<1) quota=1;
  483.       if (quota>MAX_MAIL_QUOTA) quota=MAX_MAIL_QUOTA;
  484.    }
  485.    return quota;
  486. }
  488. static void mail_func_send(t_connection * c, const char * str) {
  489.    int i;
  490.    char *dest;
  491.    char const *p,*myname;   
  492.    t_account * recv;
  493.    t_mailbox * mailbox;
  494.    
  495.    if (c==NULL) {
  496.       eventlog(eventlog_level_error,"mail_func_send","got NULL connection");
  497.       return;
  498.    }
  499.    if (str==NULL) {
  500.       eventlog(eventlog_level_error,"mail_func_send","got NULL command string");
  501.       return;
  502.    }
  503.    for(i=0;str[i]==' ';i++); /* skip any spaces */
  504.    if (str[i]=='') { /* the %mail send command has no receiver */
  505.       message_send_text(c,message_type_error,c,"You must specify the receiver");
  506.       message_send_text(c,message_type_error,c,"Syntax: /mail send <receiver> <message>");
  507.       return;
  508.    }
  509.    p=str+i; /* set ip at the start of receiver string */
  510.    for(i=1;p[i]!=' ' && p[i]!='';i++); /* skip the receiver string */
  511.    if (p[i]=='') { /* it seems user forgot to write any message */
  512.       message_send_text(c,message_type_error,c,"Your message is empty!");
  513.       message_send_text(c,message_type_error,c,"Syntax: /mail send <receiver> <message>");
  514.       return;
  515.    }
  516.    if ((dest=malloc(i+1))==NULL) {
  517.       eventlog(eventlog_level_error,"mail_func_send","not enough memory for receiver");
  518.       message_send_text(c,message_type_error,c,"Not enough resources to complete request!");
  519.       return;
  520.    }
  521.    memmove(dest,p,i); dest[i]=''; /* copy receiver in his separate string */
  522.    if ((recv=accountlist_find_account(dest))==NULL) { /* is dest a valid account on this server ? */
  523.       message_send_text(c,message_type_error,c,"Receiver UNKNOWN!");
  524.       free(dest);
  525.       return;
  526.    }
  527.    free(dest); /* free dest here, the sooner the better */
  528.    if ((mailbox=mailbox_open(recv))==NULL) {
  529.       message_send_text(c,message_type_error,c,"There was an error completing your request!");
  530.       return;
  531.    }
  532.    if (get_mail_quota(recv)<=mailbox_count(mailbox)) { /* check quota */
  533.       message_send_text(c,message_type_error,c,"Receiver has reached his mail quota. Your message will NOT be sent.");
  534.       mailbox_close(mailbox);
  535.       return;
  536.    }
  537.    myname=conn_get_username(c); /* who am i ? */
  538.    if (mailbox_deliver(mailbox,myname,p+i+1)<0)
  539.      message_send_text(c,message_type_error,c,"There was an error completing your request!");
  540.    else 
  541.      message_send_text(c,message_type_info,c,"Your mail has been sent successfully.");
  542.    conn_unget_username(c,myname);
  543.    mailbox_close(mailbox);
  544. }
  546. static void mail_func_read(t_connection * c, const char * str) {
  547.    t_account * user;
  548.    t_mailbox * mailbox;
  549.    const char *p;
  550.    char tmp[256];
  551.    int i;
  552.    
  553.    if (c==NULL) {
  554.       eventlog(eventlog_level_error,"mail_func_read","got NULL connection");
  555.       return;
  556.    }
  557.    if (str==NULL) {
  558.       eventlog(eventlog_level_error,"mail_func_read","got NULL command string");
  559.       return;
  560.    }
  561.    for(i=0;str[i]==' ';i++);
  562.    p=str+i;
  563.    if ((user=conn_get_account(c))==NULL) {
  564.       eventlog(eventlog_level_error,"mail_func_read","got NULL account");
  565.       return;
  566.    }
  567.    if ((mailbox=mailbox_open(user))==NULL) {
  568.       eventlog(eventlog_level_error,"mail_func_read","got NULL mailbox");
  569.       return;
  570.    }
  571.    if (*p=='') { /* user wants to see the mail summary */
  572.       struct maillist_struct *maill, *mp;
  573.       unsigned int idx;
  574.       
  575.       if (mailbox_count(mailbox)==0) {
  576.  message_send_text(c,message_type_info,c,"You have no mail.");
  577.  mailbox_close(mailbox);
  578.  return;
  579.       }
  580.       if ((maill=mailbox_get_list(mailbox))==NULL) {
  581.  eventlog(eventlog_level_error,"mail_func_read","got NULL maillist");
  582.  mailbox_close(mailbox);
  583.  return;
  584.       }
  585.       sprintf(tmp,"You have %d messages. Your mail qouta is set to %d.",mailbox_count(mailbox),get_mail_quota(user));
  586.       message_send_text(c,message_type_info,c,tmp);
  587.       message_send_text(c,message_type_info,c,"ID    Sender          Date");
  588.       message_send_text(c,message_type_info,c,"-------------------------------------");
  589.       for(mp=maill,idx=1;mp!=NULL;mp=mp->next,idx++) {
  590.  sprintf(tmp,"%02u    %-14s %s",idx,mp->sender,ctime(&mp->timestamp));
  591.  clean_str(tmp); /* ctime() appends an newline that we get cleaned */
  592.  message_send_text(c,message_type_info,c,tmp);
  593.       }
  594.       message_send_text(c,message_type_info,c,"Use /mail read <ID> to read the content of any message");
  595.       mailbox_unget_list(maill);
  596.    }
  597.    else { /* user wants to read a message */
  598.       int idx;
  599.       t_mail * mail;
  600.       
  601.       for(i=0;p[i]>='0' && p[i]<='9' && p[i]!='';i++);
  602.       if (p[i]!='' && p[i]!=' ') {
  603.  message_send_text(c,message_type_error,c,"Invalid index. Please use /mail read <index> where <index> is a number.");
  604.  mailbox_close(mailbox);
  605.  return;
  606.       }
  607.       idx=atoi(p);
  608.       if (idx<1 || idx>mailbox_count(mailbox)) {
  609.  message_send_text(c,message_type_error,c,"That index is out of range.");
  610.  mailbox_close(mailbox);
  611.  return;
  612.       }
  613.       if ((mail=mailbox_read(mailbox,idx))==NULL) {
  614.  message_send_text(c,message_type_error,c,"There was an error completing your request.");
  615.  mailbox_close(mailbox);
  616.  return;
  617.       }
  618.       sprintf(tmp,"Message #%d from %s on %s:",idx,mail->sender,clean_str(ctime(&mail->timestamp)));
  619.       message_send_text(c,message_type_info,c,tmp);
  620.       message_send_text(c,message_type_info,c,mail->message);
  621.       mailbox_unread(mail);
  622.    }
  623.    mailbox_close(mailbox);
  624. }
  626. static void mail_func_delete(t_connection * c, const char * str) {
  627.    t_account * user;
  628.    t_mailbox * mailbox;
  629.    const char * p;
  630.    char tmp[256]; /* that should be enough */
  631.    int i;
  632.    
  633.    if (c==NULL) {
  634.       eventlog(eventlog_level_error,"mail_func_delete","got NULL connection");
  635.       return;
  636.    }
  637.    if (str==NULL) {
  638.       eventlog(eventlog_level_error,"mail_func_delete","got NULL command string");
  639.       return;
  640.    }
  641.    for(i=0;str[i]==' ';i++);
  642.    p=str+i;
  643.    if (*p=='') {
  644.       message_send_text(c,message_type_error,c,"Please specify which message to delete. Use the following syntax: /mail delete {<index>|all} .");
  645.       return;
  646.    }
  647.    if ((user=conn_get_account(c))==NULL) {
  648.       eventlog(eventlog_level_error,"mail_func_read","got NULL account");
  649.       return;
  650.    }
  651.    if ((mailbox=mailbox_open(user))==NULL) {
  652.       eventlog(eventlog_level_error,"mail_func_read","got NULL mailbox");
  653.       return;
  654.    }
  655.    if (strcmp(p,"all")==0) {
  656.       int rez;
  657.       
  658.       if ((rez=mailbox_delete_all(mailbox))<0) {
  659.  message_send_text(c,message_type_error,c,"There was an error completing your request.");
  660.  mailbox_close(mailbox);
  661.  return;
  662.       }
  663.       sprintf(tmp,"Successfuly deleted %d messages.",rez);
  664.       message_send_text(c,message_type_info,c,tmp);
  665.    }
  666.    else {
  667.       int idx;
  668.       
  669.       for(i=0;p[i]>='0' && p[i]<='9' && p[i]!='';i++);
  670.       if (p[i]!='' && p[i]!=' ') {
  671.  message_send_text(c,message_type_error,c,"Invalid index. Please use /mail delete {<index>|all} where <index> is a number.");
  672.  mailbox_close(mailbox);
  673.  return;
  674.       }
  675.       idx=atoi(p);
  676.       if (idx<1 || idx>mailbox_count(mailbox)) {
  677.  message_send_text(c,message_type_error,c,"That index is out of range.");
  678.  mailbox_close(mailbox);
  679.  return;
  680.       }
  681.       if (mailbox_delete(mailbox,idx)<0) {
  682.  message_send_text(c,message_type_error,c,"There was an error completing your request.");
  683.  mailbox_close(mailbox);
  684.  return;
  685.       }
  686.       sprintf(tmp,"Succesfully deleted message #%02d.",idx);
  687.       message_send_text(c,message_type_info,c,tmp);
  688.    }
  689.    mailbox_close(mailbox);
  690. }
  693. static void mail_usage(t_connection * c) {
  694.    message_send_text(c,message_type_info,c,"to print this information:");
  695.    message_send_text(c,message_type_info,c,"    /mail help");
  696.    message_send_text(c,message_type_info,c,"to print an index of you messages:");
  697.    message_send_text(c,message_type_info,c,"    /mail [read]");
  698.    message_send_text(c,message_type_info,c,"to send a message:");
  699.    message_send_text(c,message_type_info,c,"    /mail send <receiver> <message>");
  700.    message_send_text(c,message_type_info,c,"to read a message:");
  701.    message_send_text(c,message_type_info,c,"    /mail read <index num>");
  702.    message_send_text(c,message_type_info,c,"to delete a message:");
  703.    message_send_text(c,message_type_info,c,"    /mail delete {<index>|all}");
  704.    message_send_text(c,message_type_info,c,"Commands may be abbreviated as follows:");
  705.    message_send_text(c,message_type_info,c,"    help: h");
  706.    message_send_text(c,message_type_info,c,"    read: r");
  707.    message_send_text(c,message_type_info,c,"    send: s");
  708.    message_send_text(c,message_type_info,c,"    delete: del");
  709. }