init.c

Go to the documentation of this file.

/*
 COPYRIGHT (C) 2005 RIVERDRUMS

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/


#include "init.h"

/* Riverdrums Library */
#include <rd/conf.h>
#include <rd/log.h>

#define VF_VERSION                "0.3.3"     
#define VF_READ_BUFSIZE           1024        
#define VF_DEFAULT_HOST           "localhost"   
#define VF_DEFAULT_PORT           25            
#define VF_DEFAULT_LOGFILE        "/var/log/veldfire.log" 
#define VF_DEFAULT_LOGLEVEL       3                       
#define VF_DEFAULT_CONFIGFILE     "/etc/veldfire/veldfire.conf" 
#define VF_DEFAULT_SECTION        "veldfire"    
#define VF_DEFAULT_TIMEOUT        60            
#define VF_DEFAULT_MAXCONNECTION  128           

#define VF_USER_CONFIGFILE        ".veldfirerc"   
#define VF_ENV_FROM               "VELDFIRE_FROM"           
#define VF_ENV_SUBJECT            "VELDFIRE_SUBJECT"        
#define VF_ENV_HOST               "VELDFIRE_HOST"           
#define VF_ENV_PORT               "VELDFIRE_PORT"           
#define VF_ENV_LOGFILE            "VELDFIRE_LOGFILE"        
#define VF_ENV_LOGLEVEL           "VELDFIRE_LOGLEVEL"       
#define VF_ENV_CONFIGFILE         "VELDFIRE_CONFIGFILE"     
#define VF_ENV_SECTION            "VELDFIRE_SECTION"        
#define VF_ENV_REPORT             "VELDFIRE_REPORT"         
#define VF_ENV_SENDTIMEOUT        "VELDFIRE_SENDTIMEOUT"    
#define VF_ENV_RECVTIMEOUT        "VELDFIRE_RECVTIMEOUT"    
#define VF_ENV_TIMEOUT            "VELDFIRE_TIMEOUT"        
#define VF_ENV_MAXCONNECTION      "VELDFIRE_MAXCONNECTION"  
#define VF_ENV_FOREGROUND         "VELDFIRE_FOREGROUND"     
#define VF_ENV_PRINTLOG           "VELDFIRE_PRINTLOG"       


#define VF_CONF_TO                "to"                
#define VF_CONF_FROM              "from"              
#define VF_CONF_SUBJECT           "subject"           
#define VF_CONF_HOST              "host"              
#define VF_CONF_PORT              "port"              
#define VF_CONF_LOGFILE           "logfile"           
#define VF_CONF_LOGLEVEL          "loglevel"          
#define VF_CONF_REPORT            "report"            
#define VF_CONF_MAXCONNECTION     "maxconnection"     
#define VF_CONF_SENDTIMEOUT       "sendtimeout"       
#define VF_CONF_RECVTIMEOUT       "recvtimeout"       
#define VF_CONF_TIMEOUT           "timeout"           
#define VF_CONF_BULK              "bulk"              
#define VF_CONF_NOMESSAGE         "nomessage"         
#define VF_CONF_DEBUG             "debug"             
#define VF_CONF_FOREGROUND        "foreground"        
#define VF_CONF_HEADER            "header"            
#define VF_CONF_PRINTLOG          "printlog"          

#define VF_USERAGENT              "User-Agent: Veldfire-" VF_VERSION  
/* Private function declarations */
veldfire * __veldfire_init(void);
void       __veldfire_defaults(veldfire *v);
void       __veldfire_env(veldfire *v);
void       __veldfire_configfile(veldfire *v);
void       __veldfire_commandline(veldfire *v, int ac, char *av[]);
char **    __veldfire_add_header(veldfire *v, char *header);
void       __veldfire_cleanup(veldfire *v);

veldfire *
VF__init(int ac, char *av[])
{
  veldfire *v = NULL;

  if ( (v = __veldfire_init()) == NULL) {
    return NULL;
  }

  __veldfire_defaults(v);
  __veldfire_env(v);
  __veldfire_commandline(v, ac, av);
  __veldfire_configfile(v);
  __veldfire_commandline(v, ac, av);

  if (VF__check_config(v) < 0) {
    __veldfire_cleanup(v);
    v = NULL;
  } else {
    v->log = RD__log_init(v->logfile, v->loglevel, 0, 1, 0, 1, 1, v->printlog);
  }

  return v;
}

void VF__cleanup(veldfire *v) { __veldfire_cleanup(v); }

veldfire *
__veldfire_init(void)
{
  veldfire *v = NULL;

  if ( (v = (veldfire *) malloc(sizeof(veldfire))) ) {
    memset(v, 0, sizeof(veldfire));
  }

  return v;
}


void
__veldfire_defaults(veldfire *v)
{
  char *p = getenv("HOME");

  v->host           = VF_DEFAULT_HOST;
  v->port           = VF_DEFAULT_PORT;
  v->logfile        = VF_DEFAULT_LOGFILE;
  v->loglevel       = VF_DEFAULT_LOGLEVEL;
  v->configfile     = VF_DEFAULT_CONFIGFILE;
  v->section        = VF_DEFAULT_SECTION;
  v->maxconnection  = VF_DEFAULT_MAXCONNECTION;
  v->sendtimeout    = VF_DEFAULT_TIMEOUT;
  v->recvtimeout    = VF_DEFAULT_TIMEOUT;

  /*
   * A bit of advertising
   */
  __veldfire_add_header(v, VF_USERAGENT);

  /* 
   * If there is a $HOME/.veldfirerc, then use that instead
   * of the system one
   */

  if (p) {
    int l = strlen(p) + strlen(VF_USER_CONFIGFILE) + 2;
    char *cf = (char *) malloc(l);
    struct stat st;

    if (cf == NULL) {
      /* Tough luck */
      return;
    }

    snprintf(cf, l, "%s/%s", p, VF_USER_CONFIGFILE);
    if (stat(cf, &st) == 0) {
      /* This is one malloc that can't be freed ... */
      v->configfile = cf;
    } else {
      free(cf);
    }
  }
}


void
__veldfire_env(veldfire *v)
{
  char *p;

  if ( (p = getenv(VF_ENV_FROM)) )          v->from          = p;
  if ( (p = getenv(VF_ENV_SUBJECT)) )       v->subject       = p;
  if ( (p = getenv(VF_ENV_HOST)) )          v->host          = p;
  if ( (p = getenv(VF_ENV_PORT)) )          v->port          = atoi(p);
  if ( (p = getenv(VF_ENV_LOGFILE)) )       v->logfile       = p;
  if ( (p = getenv(VF_ENV_LOGLEVEL)) )      v->loglevel      = atoi(p);
  if ( (p = getenv(VF_ENV_CONFIGFILE)) )    v->configfile    = p;
  if ( (p = getenv(VF_ENV_SECTION)) )       v->section       = p;
  if ( (p = getenv(VF_ENV_REPORT)) )        v->report        = p;
  if ( (p = getenv(VF_ENV_MAXCONNECTION)) ) v->maxconnection = atoi(p);
  if ( (p = getenv(VF_ENV_TIMEOUT)) ) {
    v->sendtimeout = atoi(p);
    v->recvtimeout = atoi(p);
  }
  if ( (p = getenv(VF_ENV_SENDTIMEOUT)) )   v->sendtimeout   = atoi(p);
  if ( (p = getenv(VF_ENV_RECVTIMEOUT)) )   v->recvtimeout   = atoi(p);
  if ( (p = getenv(VF_ENV_FOREGROUND)) )    v->foreground    = atoi(p);
  if ( (p = getenv(VF_ENV_PRINTLOG)) )      v->printlog      = atoi(p);
}


void
__veldfire_configfile(veldfire *v)
{
  int i;
  char *p;
  char **cp;

  v->c = RD__conf_read_section(v->configfile, v->section);

  if (v->c == NULL) {
    return;
  }

  if ( (p = RD__conf_get_val(v->c, v->section, VF_CONF_TO))) {
    v->to = p;
  }

  if ( (p = RD__conf_get_val(v->c, v->section, VF_CONF_FROM))) {
    v->from = p;
  }

  if ( (p = RD__conf_get_val(v->c, v->section, VF_CONF_SUBJECT))) {
    v->subject = p;
  }

  if ( (p = RD__conf_get_val(v->c, v->section, VF_CONF_HOST))) {
    v->host = p;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_PORT)) > 0) {
    v->port = i;
  }

  if ( (p = RD__conf_get_val(v->c, v->section, VF_CONF_LOGFILE))) {
    v->logfile = p;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_LOGLEVEL)) > 0) {
    v->loglevel = i;
  }

  if ( (p = RD__conf_get_val(v->c, v->section, VF_CONF_REPORT))) {
    v->report = p;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_MAXCONNECTION)) > 0) {
    v->maxconnection = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_TIMEOUT)) > 0) {
    v->sendtimeout = i;
    v->recvtimeout = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_SENDTIMEOUT)) > 0) {
    v->sendtimeout = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_RECVTIMEOUT)) > 0) {
    v->recvtimeout = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_BULK)) > 0) {
    v->bulk = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_NOMESSAGE)) > 0) {
    v->nomessage = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_DEBUG)) > 0) {
    v->debug = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_FOREGROUND)) > 0) {
    v->foreground = i;
  }

  if ( (i = RD__conf_get_int(v->c, v->section, VF_CONF_PRINTLOG)) > 0) {
    v->printlog = i;
  }


  /* This array of pointers does not get freed by RD__conf_free(). If
   * it needs to be freed, it has to happen on its own.
   */
  if ( (cp = RD__conf_get_vals(v->c, v->section, VF_CONF_HEADER))) {
    int s = 0;
    /* 
     * There might already be headers from the command line, so
     * we need to add these ones to that array
     */

    while (cp[s]) {
      __veldfire_add_header(v, cp[s]);
      s++;
    }
  }

}


void
__veldfire_commandline(veldfire *v, int ac, char *av[])
{
  int i = 1;
  char *p;

  v->prog = ( (p = strrchr(av[0], '/')) && *(p + 1)) ? p + 1 : av[0];

  /*  H */
  /*  b c d e f g h i l m n o p r s t v x y z */
  /* a               jk        q     u w */

  for (i = 1; i < ac; i++) {
    if (av[i][0] == '-') {
      if ( ++i >= ac && 
           av[i - 1][1] != 'x' &&
           av[i - 1][1] != 'd' &&
           av[i - 1][1] != 'g' &&
           av[i - 1][1] != 'i' &&
           av[i - 1][1] != 'v' && 
           av[i - 1][1] != 'h') {
        VF__help(v);
      }

      switch (av[i - 1][1]) {
        case 'f' : v->from        = av[i];           break;
        case 't' : v->to          = av[i];           break;
        case 's' : v->subject     = av[i];           break;
        case 'H' : __veldfire_add_header(v, av[i]);  break;
        case 'm' : v->host        = av[i];           break;
        case 'p' : v->port        = atoi(av[i]);     break;
        case 'l' : v->logfile     = av[i];           break;
        case 'e' : v->loglevel    = atoi(av[i]);     break;
        case 'c' : v->configfile  = av[i];           break;
        case 'n' : v->section     = av[i];           break;
        case 'r' : v->report      = av[i];           break;
        case 'o' : v->maxconnection = atoi(av[i]);   break;
        case 'y' : v->sendtimeout = atoi(av[i]);     break;
        case 'z' : v->recvtimeout = atoi(av[i]);     break;
        case 'b' : v->bulk        = 1; i--;          break;
        case 'x' : v->nomessage   = 1; i--;          break;
        case 'd' : v->debug       = 1; i--;          break;
        case 'g' : v->foreground  = 1; i--;          break;
        case 'i' : v->printlog    = 1; i--;          break;
        case 'v' : VF__version(v);                   break;
        case 'h' : 
        case '?' :
        default  : VF__help(v);
      }
    } else {
      /* Options are over, files follow */
      v->files = &av[i];
      break;
    }
  }
}

char **
__veldfire_add_header(veldfire *v, char *header)
{
  char **tmp = v->headers;
  int s = 0;

  /*
   * Count existing headers
   */

  if (v->headers) {
    while (v->headers[s]) { 
      /* Don't add it twice */
      if (strcmp(v->headers[s], header) == 0) {
        return v->headers;
      }
      s++; 
    }
  }

  if ( (v->headers = (char **) 
             realloc(v->headers,
                     (s + 2) * sizeof(char *))) == NULL) {
    /* Well, who is going to notice ? */
    v->headers = tmp;
    return NULL;
  }

  /* Memory allocation is up to the calling function, we just point to
   * what they've passed us. If it disappears, we're in trouble. */
  v->headers[s++] = header;
  v->headers[s] = NULL;

  return v->headers;
}


void
VF__version(veldfire *v)
{
  printf("Veldfire-%s by Jason Armstrong <ja@riverdrums.com>\n", VF_VERSION);
  __veldfire_cleanup(v);
  exit(0);
}

void
VF__help(veldfire *v)
{
  printf(
"usage: %s [options] [files to attach]\n"
"\n"
"  -f FROM          From address\n"
"  -t TO            To address, or addresses separated by one of: ,:;\\t\\n\n"
"                   or file containing one address per line\n"
"  -s SUBJECT       Subject of the email\n"
"  -H HEADER        Add custom header field (multiple values possible)\n"
"  -m HOST          Mail host (default %s)\n"
"  -p PORT          Port on mail host (default %d)\n"
"  -l LOGFILE       Log File (default %s)\n"
"  -e LOGLEVEL      Log Level (1-6) (default %d)\n"
"  -c CONFIGFILE    Config file (default %s)\n"
"  -n SECTION       Section in config file (default %s)\n"
"  -r REPORT        Email address to send a report to\n"
"  -o MAXCONNECTION Maximum number of emails in one connection (default %d)\n"
"  -y SENDTIMEOUT   Timeout for sending data\n"
"  -z RECVTIMEOUT   Timeout for reading data\n"
//"  -b               Bulk mail (bundle recipients)\n"
"  -x               No message (don't wait for a msg on stdin)\n"
"  -g               Foreground (don't fork to the background)\n"
"  -i               Log to stdout as well as to the log file\n"
//"  -d               Debug (messages not sent)\n"
"  -h               Help\n"
"  -v               Version\n"
"\n"
"Email format: J Smith <j@smith.com> | j@smith.com | <j@smith.com>\n"
"Messages are read from stdin, and can be already formatted multi-part messages\n"
"\n", v->prog,
      VF_DEFAULT_HOST, VF_DEFAULT_PORT,
      VF_DEFAULT_LOGFILE, VF_DEFAULT_LOGLEVEL,
      VF_DEFAULT_CONFIGFILE, VF_DEFAULT_SECTION,
      VF_DEFAULT_MAXCONNECTION);

  __veldfire_cleanup(v);
  exit(0);
}

void
__veldfire_cleanup(veldfire *v)
{
  if (v) {
    if (v->c) RD__conf_free(v->c);
    if (v->msg && v->freemsg) free(v->msg);   

    /* We just free the array, we don't know what it points to */
    if (v->headers) free(v->headers);
    if (v->log) RD__log_free(v->log);
    free(v);
  }
}

int
VF__check_config(veldfire *v)
{
  int rc = 0;

  if (v->to == NULL) {
    rc = -1;
    fprintf(stderr, "Missing 'to' address\n");
  }

  /* Check that all files referred to are really files and
   * can be opened by us 
   */

  if (v->files) {
    int s = 0;
    struct stat st;

    while (v->files[s]) {
      if (stat(v->files[s], &st) < 0) {
        fprintf(stderr, "%s - %s\n", v->files[s], strerror(errno));
        rc = -1;
      } else {
        if ( !(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) ) {
          fprintf(stderr, "%s must be a file or a link to a file\n", v->files[s]);
          rc = -1;
        } else {
          FILE *fp = fopen(v->files[s], "r");

          /* Try to open and close the file read-only */
          if (fp == NULL) {
            fprintf(stderr, "%s - %s\n", v->files[s], strerror(errno));
            rc = -1;
          } else {
            fclose(fp);
          }
        }
      }
      s++;
    }
  }

  if (rc < 0) {
    VF__help(v);
  }

  return rc;
}

char *
VF__get_msg(veldfire *v)
{
  char *r = NULL, *t = NULL;
  int c, s = 0, l = 0;

  if (v->nomessage) {
    v->freemsg = 1;
    return (strdup(""));
  }

  if (isatty(fileno(stdin))) {
    printf("Your message please, end with EOF (^D):\n");
    fflush(stdout);
  }

  while ( (c = fgetc(stdin)) != EOF) {
    if (l >= s) {
      t = r;
      if ( (r = realloc(r, s + VF_READ_BUFSIZE + 3)) == NULL) {
        v->freemsg = 0;
        if (t) free(t);
        return NULL;
      }
      s += VF_READ_BUFSIZE + 1;
    }

    /* Auto detect a single dot on a line on its own ... */
    if ( (c == '\r' || c == '\n') && l > 2 && 
          r[l - 1] == '.' && r[l - 2] == '\n') {
      r[l++] = '.';
    }

    r[l++] = c;
  }

  if (r && l) {
    r[l] = 0;
  }

  v->freemsg = 1;

  return r;
}

#ifdef INITTEST

void 
_print_vf(veldfire *v)
{
  if (v == NULL) { 
    return;
  }
  printf("Name          : %s\n", v->prog ? v->prog : "(none)");
  printf("Config File   : %s\n", v->configfile ? v->configfile : "(none)");
  printf("Section       : %s\n", v->section ? v->section : "(none)");
  printf("LogFile       : %s\n", v->logfile ? v->logfile : "(none)");
  printf("LogLevel      : %d\n", v->loglevel);
  printf("Mail host     : %s\n", v->host ? v->host : "(none)");
  printf("Mailport      : %d\n", v->port);
  printf("From          : %s\n", v->from ? v->from : "(none)");
  printf("To            : %s\n", v->to ? v->to : "(none)");
  printf("Report        : %s\n", v->report ? v->report : "(none)");
  printf("Subject       : %s\n", v->subject ? v->subject : "(none)");
  printf("Bulk          : %d\n", v->bulk);
  printf("No Message    : %d\n", v->nomessage);
  printf("Debug         : %d\n", v->debug);
  printf("Foreground    : %d\n", v->foreground);
  printf("Printlog      : %d\n", v->printlog);
  printf("MaxConnection : %d\n", v->maxconnection);
  printf("Timeout Snd   : %d\n", v->sendtimeout);
  printf("Timeout Rcv   : %d\n", v->recvtimeout);
  printf("Msg           : %s\n", v->msg ? v->msg : "(none)");

  if (v->files) {
    int s = 0;
    while (v->files[s]) {
      printf("File : %s\n", v->files[s++]);
    }
  }

  if (v->headers) {
    int s = 0;
    while (v->headers[s]) {
      printf("Header: %s\n", v->headers[s++]);
    }
  }
}

int main(int argc, char *argv[]) {
  veldfire *v = VF__init(argc, argv);
  if (v) {
    v->msg = VF__get_msg(v);
    _print_vf(v);
  }
  VF__cleanup(v);

  return 0;
}


#endif

 

 

---

Jason Armstrong <ja@riverdrums.com>