Changeset 272


Ignore:
Timestamp:
Jan 27, 2010, 10:52:20 PM (11 years ago)
Author:
katerina
Message:

Fixes tickets #190, #191, #192, #193, and #194.

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/Makefile.in

    r269 r272  
    906906          echo "Package $$DEBFILE built."; \
    907907          cp $$DEBFILE ./$(PACKAGE)-$(VERSION)-$(BUILD_NUM).deb; \
     908          ln -s ./$(PACKAGE)-$(VERSION)-$(BUILD_NUM).deb ./$(PACKAGE)-$(VERSION).deb; \
    908909        fi; \
    909910        echo
  • trunk/configure.ac

    r269 r272  
    1212dnl start
    1313dnl
    14 AM_INIT_AUTOMAKE(samhain, 2.6.1b)
     14AM_INIT_AUTOMAKE(samhain, 2.6.2)
    1515AC_DEFINE([SAMHAIN], 1, [Application is samhain])
    1616AC_CANONICAL_HOST
  • trunk/docs/Changelog

    r271 r272  
    112.6.2:
     2        * Makefile.in: fix problem in deploy system caused
     3          by adding build number for debs in 2.5.9 (reported
     4          by roman)
     5        * add option for per-rule email alias in log monitoring
     6          module
     7        * sh_readconf.c: make keywords case-independent
     8        * sh_mail.c: on error, report full reply of mail server
     9        * sh_mail.c: report smtp transcript at debug level
     10        * make sure mail aliases are not emailed twice, and
     11          recipients cannot be defined after aliasing them
    212        * handle named pipes in log monitoring module
    313          (open in nonblocking mode, ignore read error if empty)
  • trunk/include/sh_error_min.h

    r265 r272  
    2525                      long errnum, unsigned long  msg_index, ...);
    2626
     27/* this function should be called to (only) send mail
     28 */
     29void sh_error_mail (const char * alias, int sev,
     30                    const char * file, long line,
     31                    long status, unsigned long msg_id, ...);
     32
    2733/* convert a string to a numeric priority
    2834 */
  • trunk/include/sh_fifo.h

    r214 r272  
    6868sh_string * tag_list (SH_FIFO * fifo, char * tag,
    6969                      int(*check)(int, const char*, const char*, const void*),
    70                       const void * info);
     70                      const void * info, int okNull);
    7171void rollback_list (SH_FIFO * fifo);
    7272void mark_list (SH_FIFO * fifo);
  • trunk/include/sh_log_evalrule.h

    r265 r272  
    4949  enum policies     policy;
    5050  int               severity;
     51  sh_string       * alias;
    5152  time_t            interval;        /* if EVAL_SUM, interval   */
    5253  struct sh_qeval * next;
     
    5657
    5758int sh_log_lookup_severity(const char * str);
     59sh_string * sh_log_lookup_alias(const char * str);
    5860
    5961#endif
  • trunk/include/sh_mail_int.h

    r232 r272  
    2525  dnsrep           * mx_list;
    2626  int                severity;
    27   int                send_mail;
     27  short              send_mail;
     28  short              isAlias;
    2829  sh_filter_type   * mail_filter;
    2930  struct alias     * next;
  • trunk/include/slib.h

    r252 r272  
    220220
    221221  /*
    222    * robust strncmp replacement
     222   * robust strn[case]cmp replacement
    223223   */
    224224  int sl_strncmp(const char * a, const char * b, size_t n);
     225
     226  int sl_strncasecmp(const char * a, const char * b, size_t n);
    225227
    226228  /*
  • trunk/src/sh_error.c

    r214 r272  
    13321332/*@i@*/}
    13331333
     1334#if defined(SH_WITH_MAIL)
     1335void sh_error_mail (const char * alias, int sev,
     1336                    const char * file, long line,
     1337                    long status, unsigned long msg_id, ...)
     1338{
     1339  va_list         vl;                 /* argument list          */
     1340  struct _log_t * lmsg;
     1341
     1342  int    severity;
     1343  unsigned int class;
     1344  char * fmt;
     1345  int retval;
     1346
     1347  SL_ENTER(_("sh_error_mail"));
     1348
     1349  /* Returns pointer to (constant|thread-specific) static memory
     1350   */
     1351  fmt = /*@i@*/get_format (msg_id, &severity, &class);
     1352
     1353  if (!fmt)
     1354    {
     1355      SL_RET0(_("sh_error_mail"));
     1356    }
     1357
     1358  /* --- Override the catalogue severity. ---
     1359   */
     1360  if (sev != (-1))
     1361    severity = sev;
     1362
     1363  /* --- Build the message. ---
     1364   */
     1365  lmsg = (struct _log_t *) SH_ALLOC(sizeof(struct _log_t));
     1366  MLOCK( (char *) lmsg, sizeof(struct _log_t));
     1367  /*@i@*/lmsg->msg = NULL;
     1368
     1369  /*@i@*/(void) sl_strlcpy(lmsg->format, fmt, SH_PATHBUF);
     1370  (void) sl_strlcpy(lmsg->file, file, SH_PATHBUF);
     1371  lmsg->severity = severity;
     1372  lmsg->class    = (int) class;
     1373  lmsg->line     = line;
     1374  lmsg->status   = status;
     1375
     1376  /* Format the log message with timestamp etc.
     1377   * Allocate lmsg->msg
     1378   */
     1379  va_start (vl, msg_id);
     1380  (void) sh_error_string (lmsg, vl);
     1381  va_end (vl);
     1382
     1383  if ( (severity & SH_ERR_FATAL) == 0)
     1384    retval = sh_nmail_pushstack (severity, lmsg->msg, alias);
     1385  else
     1386    retval = sh_nmail_msg (severity, lmsg->msg, alias);
     1387 
     1388  if (retval == -2)
     1389    {
     1390      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_QUEUE_FULL,
     1391                       _("email"));
     1392    }
     1393  SL_RET0(_("sh_error_mail"));
     1394}
     1395#else
     1396void sh_error_mail (const char * alias, int sev,
     1397                    const char * file, long line,
     1398                    long status, unsigned long msg_id, ...)
     1399{
     1400  (void) alias;
     1401  (void) sev;
     1402  (void) file;
     1403  (void) line;
     1404  (void) status;
     1405  (void) msg_id;
     1406
     1407  return;
     1408}
     1409/* defined(SH_WITH_MAIL) */
     1410#endif
    13341411
    13351412/* ------------------------- 
  • trunk/src/sh_fifo.c

    r214 r272  
    4444#define SH_FIFO_MARKED 4
    4545
    46 /* Prepare an email message and return it.
     46/* Prepare an email message and return it. Iterate over list on stack and
     47 * check for each if it is valid for recipient 'tag'. If yes, add to the
     48 * returned string.
     49 * okNull == False means that item->s_xtra must be defined
    4750 */
    4851sh_string * tag_list (SH_FIFO * fifo, char * tag,
    4952                      int(*valid)(int, const char*, const char*, const void*),
    50                       const void * info)
     53                      const void * info, int okNull)
    5154{
    5255  struct dlist * item;
     
    5962      while (item)
    6063        {
     64          /* Same recipient, or no recipient ( := all )
     65           */
    6166          if ( (tag && item->s_xtra && 0 == strcmp(item->s_xtra, tag)) ||
    62                !(item->s_xtra) )
     67               ((okNull == S_TRUE) && !(item->s_xtra)) )
    6368            {
    6469              if (valid == NULL)
     
    6873              else
    6974                {
     75                  /* level, message, recipient, list */
    7076                  if (!valid(item->i_xtra, item->data, tag, info))
    7177                    goto skipped;
  • trunk/src/sh_getopt.c

    r210 r272  
    454454  fputs (_(" using time server"), stdout); ++num;
    455455#endif
     456#if defined(HAVE_REGEX_H)
     457  if (num > 0) fputc ('\n', stdout);
     458  fputs (_(" posix regex support"), stdout); ++num;
     459#endif
     460
    456461
    457462#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
  • trunk/src/sh_log_check.c

    r271 r272  
    11791179
    11801180/* Define a reporting queue.
    1181  * Format: Label : [Interval] : TYPE : Severity
     1181 * Format: Label : [Interval] : TYPE : Severity[:alias]
    11821182 * TYPE must be 'report' or 'sum'
    11831183 * Interval is ignored for TYPE='report'
  • trunk/src/sh_log_correlate.c

    r265 r272  
    282282              if (val >= 0)
    283283                {
     284                  sh_string * alias;
    284285                  SH_MUTEX_LOCK(mutex_thread_nolog);
    285286                  sh_error_handle (mkeep->queue->severity, FIL__, __LINE__, 0,
    286287                                   MSG_LOGMON_COR, sh_string_str(mkeep->label),
    287288                                   val);
     289
     290                  alias = mkeep->queue->alias;
     291                  if (alias)
     292                    {
     293                      sh_error_mail (sh_string_str(alias),
     294                                     mkeep->queue->severity, FIL__, __LINE__, 0,
     295                                     MSG_LOGMON_COR, sh_string_str(mkeep->label),
     296                                     val);
     297                    }
     298                 
    288299                  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    289300                }
  • trunk/src/sh_log_evalrule.c

    r265 r272  
    151151  char **      splits = split_array(new, &nfields, ':', lengths);
    152152
     153  /* group is label:regex
     154   */
     155
    153156  if (group_open)
    154157    group_open = NULL;
     
    313316  struct sh_qeval * nq;
    314317  int     severity;
    315   unsigned int nfields = 4; /* label:interval:(report|sum):severity */
    316   size_t  lengths[4];
     318  unsigned int nfields = 5; /* label:interval:(report|sum):severity[:alias] */
     319  size_t  lengths[5];
    317320  char *  new = sh_util_strdup(str);
    318321  char ** splits = split_array(new, &nfields, ':', lengths);
    319322
    320   if (nfields != 4)
     323  if (nfields < 4)
    321324    {
    322325      SH_FREE(splits);
     
    356359  nq = SH_ALLOC(sizeof(struct sh_qeval));
    357360  nq->label = sh_string_new_from_lchar(splits[0], lengths[0]);
     361  nq->alias = NULL;
    358362
    359363  DEBUG("debug: splits[2] = %s, policy = %d\n",splits[2],nq->policy);
     
    368372
    369373  nq->severity = severity;
     374
     375  if (nfields == 5)
     376    {
     377      nq->alias = sh_string_new_from_lchar(splits[4], lengths[4]);
     378    }
     379
    370380  nq->next     = queuelist;
    371381  queuelist    = nq;
     
    408418  return SH_ERR_SEVERE;
    409419}
     420
     421sh_string * sh_log_lookup_alias(const char * str)
     422{
     423  struct sh_qeval * queue;
     424
     425  if (str)
     426    {
     427      if (0 != strcmp(str, _("trash")))
     428        {
     429          queue = sh_log_find_queue(str);
     430         
     431          if (queue)
     432            return queue->alias;
     433        }
     434    }
     435  return NULL;
     436}
     437
    410438
    411439static char * get_label_and_time(const char * inprefix, char * str,
     
    9931021}
    9941022
    995 static void msg_report(int severity, struct sh_geval * rule, struct sh_logrecord * record)
     1023static void msg_report(int severity, const sh_string * alias,
     1024                       struct sh_geval * rule, struct sh_logrecord * record)
    9961025{
    9971026  char      * tmp;
     
    10171046                   sh_string_str(record->host),
    10181047                   tmp);
     1048  if (alias)
     1049    {
     1050      sh_error_mail (sh_string_str(alias),
     1051                     severity, FIL__, __LINE__, 0, MSG_LOGMON_REP,
     1052                     msg,
     1053                     ttt,
     1054                     sh_string_str(record->host),
     1055                     tmp);
     1056    }
    10191057  SH_FREE(ttt);
    10201058  SH_FREE(msg);
     
    10251063}
    10261064
    1027 static void sum_report(int severity, sh_string * host, sh_string * message, sh_string * path)
     1065static void sum_report(int severity, const sh_string * alias,
     1066                       sh_string * host, sh_string * message, sh_string * path)
    10281067{
    10291068  char * tmp;
     
    10371076                   sh_string_str(host),
    10381077                   tmp);
     1078  if (alias)
     1079    {
     1080      sh_error_mail (sh_string_str(alias),
     1081                     severity, FIL__, __LINE__, 0, MSG_LOGMON_SUM,
     1082                     msg,
     1083                     sh_string_str(host),
     1084                     tmp);
     1085    }
    10391086  SH_FREE(msg);
    10401087  SH_FREE(tmp);
     
    11081155    {
    11091156      DEBUG("debug: report count\n");
    1110       sum_report(rule->queue->severity, counter->hostname,
    1111                  counter->counted_str, counter->filename);
     1157      sum_report(rule->queue->severity, rule->queue->alias,
     1158                 counter->hostname, counter->counted_str, counter->filename);
    11121159      counter->start = time(NULL);
    11131160      counter->count = 0;
     
    11311178                 sh_string_str(record->host),
    11321179                 sh_string_str(record->message));
    1133           msg_report(queue->severity, rule, record);
     1180          msg_report(queue->severity, queue->alias, rule, record);
    11341181          retval = 0;
    11351182        }
     
    11771224        {
    11781225          DEBUG("debug: (%lu) no rule found\n", i); ++i;
    1179           msg_report(DEFAULT_SEVERITY, NULL, record);
     1226          msg_report(DEFAULT_SEVERITY, NULL, NULL, record);
    11801227        }
    11811228
  • trunk/src/sh_log_mark.c

    r265 r272  
    221221    {
    222222      int severity;
     223      sh_string * alias;
    223224      SH_MUTEX_LOCK(mutex_thread_nolog);
    224225
     
    233234                       sh_string_str(event->label),
    234235                       (unsigned long) delay);
     236      alias = sh_log_lookup_alias(sh_string_str(event->queue_id));
     237      if (alias)
     238        {
     239          sh_error_mail (sh_string_str(alias), severity,
     240                         FIL__, __LINE__, 0, MSG_LOGMON_MARK,
     241                         sh_string_str(event->label),
     242                         (unsigned long) delay);
     243        }
     244
    235245      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    236246    }
  • trunk/src/sh_log_repeat.c

    r265 r272  
    521521      char * tmpmsg;
    522522      char * tmphost;
     523      sh_string * alias;
    523524
    524525      /* issue report             */
     
    530531                       FIL__, __LINE__, 0, MSG_LOGMON_BURST,
    531532                       repeat, tmpmsg, tmphost);
     533      alias = sh_log_lookup_alias(sh_repeat_queue);
     534      if (alias)
     535        {
     536          sh_error_mail (sh_string_str(alias),
     537                         sh_log_lookup_severity(sh_repeat_queue),
     538                         FIL__, __LINE__, 0, MSG_LOGMON_BURST,
     539                         repeat, tmpmsg, tmphost);
     540        }
    532541      SH_FREE(tmpmsg);
    533542      SH_FREE(tmphost);
  • trunk/src/sh_mail.c

    r252 r272  
    947947
    948948static time_t time_wait = 300;
     949static void report_smtp (char * reply);
    949950
    950951static FILE * sh_mail_start_conn (struct alias * ma_address,
     
    11131114  if (0 != is_numeric(sh.host.name))
    11141115    {
    1115       TPT(( 0, FIL__, __LINE__, _("msg=<HELO [%s]>%c%c"),
    1116             sh.host.name, 13, 10));
     1116      sl_snprintf(error_msg, sizeof(error_msg), "HELO [%s]",
     1117                  sh.host.name);
    11171118    }
    11181119  else
    11191120    {
    1120       TPT(( 0, FIL__, __LINE__, _("msg=<HELO %s>%c%c"),
    1121             sh.host.name, 13, 10));
    1122     }
     1121      sl_snprintf(error_msg, sizeof(error_msg), "HELO %s",
     1122                  sh.host.name);
     1123    }
     1124  report_smtp(error_msg);
     1125
    11231126  if (0 != is_numeric(sh.host.name))
    11241127    fprintf(connFile, _("HELO [%s]%c%c"), sh.host.name, 13, 10);
     
    11521155    }
    11531156
    1154   TPT(( 0, FIL__, __LINE__,  _("msg=<MAIL FROM:<%s>>%c%c"),
    1155         this_address, 13, 10));
     1157  sl_snprintf(error_msg, sizeof(error_msg), "MAIL FROM:<%s>",
     1158              this_address);
     1159  report_smtp(error_msg);
    11561160
    11571161  (void) fflush(connFile);
     
    11751179  if (aFlag == 0)
    11761180    {
    1177       TPT(( 0, FIL__, __LINE__,  _("msg=<RCPT TO:<%s>>%c%c"),
    1178             address, 13, 10));
     1181      sl_snprintf(error_msg, sizeof(error_msg), "RCPT TO:<%s>",
     1182                  address);
     1183      report_smtp(error_msg);
    11791184
    11801185      (void) fflush(connFile);
     
    12101215          ++address_num;
    12111216
    1212           TPT(( 0, FIL__, __LINE__,  _("msg=<RCPT TO:<%s>>%c%c"),
    1213                 sh_string_str(ma_address->recipient), 13, 10));
     1217          sl_snprintf(error_msg, sizeof(error_msg), "RCPT TO:<%s>",
     1218                      sh_string_str(ma_address->recipient));
     1219          report_smtp(error_msg);
    12141220         
    12151221          (void) fflush(connFile);
     
    12411247  /* Send the message
    12421248   */
    1243   TPT(( 0, FIL__, __LINE__,  _("msg=<DATA>%c%c"), 13, 10));
     1249  report_smtp(_("DATA"));
    12441250
    12451251  (void) fflush(connFile);
     
    12731279  TPT(( 0, FIL__, __LINE__,  _("msg=<From: <%s>%c%cTo: <%s>%c%cDate: %s>%c%c"),
    12741280        this_address, 13, 10, address, 13, 10, my_tbuf, 13, 10));
     1281
     1282  report_smtp(_("sending data.."));
    12751283
    12761284  (void) fflush(connFile);
     
    12991307  time_wait = 300;
    13001308
     1309  report_smtp(_("."));
     1310
    13011311  (void) fflush(connFile);
    13021312  fprintf(connFile, _("%c%c.%c%c"), 13, 10, 13, 10);   
    13031313  (void) fflush(connFile);
    1304 
    1305   TPT(( 0, FIL__, __LINE__, _("msg=<message end written>\n")));
    13061314
    13071315  if (0 != sh_mail_wait(250, fd))
     
    13321340 *
    13331341 */
     1342extern int flag_err_debug;
     1343
     1344static void report_smtp (char * reply)
     1345{
     1346  char * tmp;
     1347
     1348  if (flag_err_debug == SL_TRUE)
     1349    {
     1350      tmp = sh_util_safe_name_keepspace(reply);
     1351
     1352      sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN,
     1353                       tmp,
     1354                       _("report_smtp") );
     1355      SH_FREE(tmp);
     1356    }
     1357  return;
     1358}
     1359
    13341360
    13351361static int sh_mail_wait(int code, int ma_socket)
     
    13391365  char c;
    13401366
    1341   char errmsg[128];
     1367  char errmsg[194];
     1368  char reply[128];
     1369  unsigned int  ireply = 0;
    13421370
    13431371  enum {
     
    13571385   */
    13581386
    1359   rcode = 0;
    1360   state = WAIT_CODE_START;
     1387  rcode    = 0;
     1388  state    = WAIT_CODE_START;
     1389  reply[0] = '\0';
    13611390
    13621391  while (sl_read_timeout_fd (ma_socket, &c, 1, time_wait, SL_FALSE) > 0) {
     1392
     1393    if (ireply < (sizeof(reply) - 1))
     1394      {
     1395        if (c != '\n' && c != '\r')
     1396          {
     1397            reply[ireply] = c;
     1398            ++ireply;
     1399            reply[ireply] = '\0';
     1400          }
     1401      }
    13631402
    13641403    g = (int) c;
     
    13791418      if (0 != isspace(g))
    13801419        break;             /* Skip white space                    */
    1381       if (0 == isdigit(g))
    1382         return 0;          /* No leading number                   */
     1420      if (0 == isdigit(g))
     1421        {
     1422          report_smtp(reply);
     1423          SL_RETURN( 0, _("mail_wait")); /* No leading number     */
     1424        }
    13831425      rcode = g-(int)'0';  /* convert to number                   */
    13841426      state = WAIT_CODE;
     
    14111453      if (g != 1)
    14121454        {
     1455          char * tmp = sh_util_safe_name_keepspace(reply);
    14131456          sl_snprintf(errmsg, sizeof(errmsg),
    1414                       _("Bad response (%d), expected %d"), rcode, code);
     1457                      _("Bad response (%s), expected %d"), tmp, code);
     1458          SH_FREE(tmp);
    14151459
    14161460          sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
    14171461                          errmsg, _("sh_mail_wait"),
    14181462                          _("mail"), _("SMTP server"));
     1463        }
     1464      else
     1465        {
     1466          report_smtp(reply);
    14191467        }
    14201468      waited_time = time(NULL) - waited_time;
     
    14381486
    14391487      TPT((0, FIL__, __LINE__, _("msg=<mail_wait: bad>\n")));
     1488      report_smtp(reply);
    14401489      SL_RETURN( 0, _("mail_wait"));
    14411490     
     
    14461495
    14471496  /* Failed, EOF or error on socket */
     1497  report_smtp(reply);
    14481498  SL_RETURN( 0, _("mail_wait"));
    14491499}
  • trunk/src/sh_nmail.c

    r240 r272  
    6565struct alias * all_recipients = NULL;
    6666
    67 int check_double (const char * str, struct alias * list)
     67/* Check if addr is in list. If list is all_recipients,
     68 * must iterate over ->all_next instead of ->next
     69 */
     70static int check_double (const char * str, struct alias * list, int isAll)
    6871{
    6972  if (str && list)
     
    7376      while (item)
    7477        {
     78          fprintf(stderr, "FIXME check %s %s\n", str, sh_string_str(item->recipient));
     79
    7580          if (0 == strcmp(sh_string_str(item->recipient), str))
    7681            return -1;
    77           item = item->next;
     82          if (isAll)
     83            item = item->all_next;
     84          else
     85            item = item->next;
    7886        }
    7987    }
     
    8189}
    8290
     91/* Add recipient to 'list' AND to all_recipients. If
     92 * it already is in all_recipients, mark it as an alias
     93 * (isAlias = 1).
     94 */
    8395struct alias * add_recipient_intern(const char * str,
    8496                                    struct alias * list)
     
    93105      new->severity       = (-1);
    94106      new->send_mail      = 0;
     107      new->isAlias        = 0;
    95108      new->recipient      = sh_string_new_from_lchar(str, strlen(str));
    96109      list                = new;
    97110
    98111      SH_MUTEX_LOCK_UNSAFE(mutex_listall);
     112      fprintf(stderr, "FIXME intern %s\n", str);
     113      if (0 == check_double(str, all_recipients, S_TRUE))
     114        {
     115          new->isAlias    = 1;
     116        }
    99117      new->all_next       = all_recipients;
    100118      all_recipients      = new;
     119      fprintf(stderr, "FIXME intern end\n");
    101120      SH_MUTEX_UNLOCK_UNSAFE(mutex_listall);
    102121    }
     
    116135}
    117136
    118 /* Add a single recipient
     137/* Add a single recipient. Must not be in in
     138 * recipient_list already, and not in all_recipients.
    119139 */
    120140int sh_nmail_add_recipient(const char * str)
    121141{
    122   if (0 == check_double(str,  recipient_list))
     142  /* return error if duplicate, or
     143   * already defined within an alias list.
     144   */
     145  if (0 == check_double(str,  recipient_list, S_FALSE) &&
     146      0 == check_double(str,  all_recipients, S_TRUE))
    123147    {
    124148      recipient_list = add_recipient_intern(str, recipient_list);
     
    133157int sh_nmail_add_compiled_recipient(const char * str)
    134158{
    135   if (0 == check_double(str,  compiled_recipient_list))
     159  if (0 == check_double(str,  compiled_recipient_list, S_FALSE))
    136160    {
    137161      compiled_recipient_list =
     
    164188      if (strlen(new) > 0)
    165189        {
     190          /* strip trailing space
     191           */
    166192          --q; while ((q != new) && *q == ' ') { *q = '\0'; --q; }
    167193        }
     
    171197        }
    172198
    173       if (0 == check_double(new, alias_list))
    174         {
     199      if (0 == check_double(new, alias_list, S_FALSE))
     200        {
     201
     202          fprintf(stderr, "FIXME LIST %s\n", p);
    175203
    176204          array = split_array_list(p, &nfields, lengths);
    177205
     206          fprintf(stderr, "FIXME LIST %d\n", nfields);
     207
    178208          if (array && nfields > 0)
    179209            {
    180               struct alias * newalias  = SH_ALLOC(sizeof(struct alias));
    181               newalias->recipient_list = NULL;
    182               newalias->mail_filter    = NULL;
    183               newalias->mx_list        = NULL;
    184               newalias->severity       = (-1);
    185               /* This is the alias */
    186               newalias->recipient = sh_string_new_from_lchar(new, strlen(new));
    187 
    188               for (i = 0; i < nfields; ++i)
     210              struct alias * newalias = NULL;
     211
     212              /* Enforce that all list members are defined already
     213               */
     214              int                nflag = 0;
     215
     216              for (i = 0; i < nfields; ++i) {
     217                if (0 == check_double(array[i],  all_recipients, S_TRUE))
     218                  nflag = 1;
     219              }
     220
     221              if (nflag == 0)
    189222                {
    190                   if (lengths[i] > 0 &&
    191                       0 == check_double(array[i], newalias->recipient_list))
     223                  newalias                 = SH_ALLOC(sizeof(struct alias));
     224                  newalias->recipient_list = NULL;
     225                  newalias->mail_filter    = NULL;
     226                  newalias->mx_list        = NULL;
     227                  newalias->severity       = (-1);
     228                 
     229                  /* This is the alias */
     230                  newalias->recipient = sh_string_new_from_lchar(new, strlen(new));
     231                 
     232                  for (i = 0; i < nfields; ++i)
    192233                    {
    193                       newalias->recipient_list =
    194                         add_recipient_intern(array[i],newalias->recipient_list);
     234                      fprintf(stderr, "FIXME LIST(%d) %s\n", lengths[i], array[i]);
     235                     
     236                      if (lengths[i] > 0 &&
     237                          0 == check_double(array[i], newalias->recipient_list, S_FALSE))
     238                        {
     239                          fprintf(stderr, "FIXME add %s\n", array[i]);
     240                         
     241                          newalias->recipient_list =
     242                            add_recipient_intern(array[i], newalias->recipient_list);
     243                        }
    195244                    }
    196245                }
     
    198247              SH_FREE(array);
    199248
    200               if (newalias->recipient_list == NULL)
     249              if (newalias && newalias->recipient_list == NULL)
    201250                {
    202251                  SH_FREE(newalias);
     
    304353    }
    305354
     355  if (alias)
     356    {
     357      fprintf(stderr, "FIXME %s, %s, %s\n", alias,
     358              (rcv->mail_filter) ? "filtered" : "NULL", message);
     359    }
     360
    306361  return 1;
    307362}
     
    365420          /* Mark the entry
    366421           */
    367           if (flagit)
    368             list->send_mail = 1;
    369422          if (flag)
    370             list = list->all_next;
     423            {
     424              /* Don't mark aliases
     425               */
     426              if (flagit && list->isAlias == 0)
     427                list->send_mail = 1;
     428              list = list->all_next;
     429            }
    371430          else
    372             list = list->next;
     431            {
     432              if (flagit)
     433                  list->send_mail = 1;
     434              list = list->next;
     435            }
    373436          ++retval;
    374437        }
     
    551614  reset_list(fifo_mail);
    552615
    553   /* Compiled recipients
     616  fprintf(stderr, "FIXME Compiled\n");
     617
     618  /* Compiled recipients. These share threshold and filter,
     619   * hence only the first recipient needs to be tested.
    554620   */
    555621  list  = compiled_recipient_list;
     
    558624    {
    559625      msg   = tag_list(fifo_mail, sh_string_str(list->recipient),
    560                        sh_nmail_valid_message_for_alias, list);
     626                       sh_nmail_valid_message_for_alias, list, S_TRUE);
    561627    }
    562628
     
    585651    }
    586652
     653  fprintf(stderr, "FIXME Aliases\n");
     654
    587655  /* Aliases
    588656   */
    589 
    590657  list  = alias_list;
    591658
     
    601668      {
    602669        msg   = tag_list(fifo_mail, sh_string_str(list->recipient),
    603                          sh_nmail_valid_message_for_alias, list);
     670                         sh_nmail_valid_message_for_alias, list, S_FALSE);
    604671
    605672        if (msg)
     
    624691            while (lnew)
    625692              {
     693                fprintf(stderr, "FIXME %s\n", sh_string_str(lnew->recipient));
    626694                lnew->send_mail = 1;
    627695                lnew= lnew->next;
     
    659727
    660728
     729  fprintf(stderr, "FIXME Single\n");
     730
    661731  /* Single recipients
    662732   */
     
    673743      {
    674744        msg   = tag_list(fifo_mail, sh_string_str(list->recipient),
    675                        sh_nmail_valid_message_for_alias, list);
     745                         sh_nmail_valid_message_for_alias, list, S_TRUE);
    676746
    677747        if (msg)
  • trunk/src/sh_readconf.c

    r265 r272  
    182182    ++p; while (isspace((int)*p)) ++p;
    183183
    184     if (0 != strncmp(p, _("if "),   3)) {
     184    if (0 != strncasecmp(p, _("if "),   3)) {
    185185      cond_type = SH_RC_HOST; /* [!]$host */
    186186    }
     
    190190      p += 3; while (isspace((int)*p)) ++p; /* skip the 'if\s+' */
    191191
    192       if (0 == strncmp(p, _("not "), 4))
     192      if (0 == strncasecmp(p, _("not "), 4))
    193193        {
    194194          p += 4; while (isspace((int)*p)) ++p;
     
    201201        }
    202202 
    203       if (0 == strncmp(p, _("file_exists "), 12))
     203      if (0 == strncasecmp(p, _("file_exists "), 12))
    204204        {
    205205          p += 12; cond_type = SH_RC_FILE;
    206206        }
    207       else if (0 == strncmp(p, _("interface_exists "), 17))
     207      else if (0 == strncasecmp(p, _("interface_exists "), 17))
    208208        {
    209209          p += 17; cond_type = SH_RC_IFACE;
    210210        }
    211       else if (0 == strncmp(p, _("hostname_matches "), 17))
     211      else if (0 == strncasecmp(p, _("hostname_matches "), 17))
    212212        {
    213213          p += 17; cond_type = SH_RC_HOST;
    214214        }
    215       else if (0 == strncmp(p, _("system_matches "), 15))
     215      else if (0 == strncasecmp(p, _("system_matches "), 15))
    216216        {
    217217          p += 15; cond_type = SH_RC_SYSTEM;
    218218        }
    219       else if (0 == strncmp(p, _("command_succeeds "), 17))
     219      else if (0 == strncasecmp(p, _("command_succeeds "), 17))
    220220        {
    221221          p += 17; cond_type = SH_RC_CMD;
     
    289289      ++p; while (isspace((int)*p)) ++p;
    290290      if (
    291           (0 == strncmp (p, _("end"), 3) && (p[3] == '\0' || isspace((int)p[3]))) ||
    292           (0 == strncmp (p, _("fi"),  2) && (p[2] == '\0' || isspace((int)p[2])))
     291          (0 == strncasecmp (p, _("end"), 3) && (p[3] == '\0' || isspace((int)p[3]))) ||
     292          (0 == strncasecmp (p, _("fi"),  2) && (p[2] == '\0' || isspace((int)p[2])))
    293293           )
    294294        {
     
    307307      char * p = str;
    308308      ++p; while (isspace((int)*p)) ++p;
    309       if ( 0 == strncmp (p, _("else"), 4) && (p[4] == '\0' || isspace((int)p[4])) )
     309      if ( 0 == strncasecmp (p, _("else"), 4) && (p[4] == '\0' || isspace((int)p[4])) )
    310310        {
    311311          return 1;
     
    586586        read_mode = SH_SECTION_NONE;
    587587
    588         if (0 == sl_strncmp (line,  _("[EOF]"), 5)) {
     588        if (0 == sl_strncasecmp (line,  _("[EOF]"), 5)) {
    589589          goto nopel;
    590590        }
     
    594594        while (tab_ListSections[i].name != 0)
    595595          {
    596             if (sl_strncmp (line, _(tab_ListSections[i].name),
    597                             sl_strlen(tab_ListSections[i].name)) == 0)
     596            if (sl_strncasecmp (line, _(tab_ListSections[i].name),
     597                                sl_strlen(tab_ListSections[i].name)) == 0)
    598598              {
    599599                read_mode = tab_ListSections[i].type;
     
    608608            for (modnum = 0; modList[modnum].name != NULL; ++modnum)
    609609              {
    610                 if (0 == sl_strncmp (line, _(modList[modnum].conf_section),
    611                                     sl_strlen(modList[modnum].conf_section)) )
     610                if (0 == sl_strncasecmp (line, _(modList[modnum].conf_section),
     611                                        sl_strlen(modList[modnum].conf_section)) )
    612612                  read_mode = SH_SECTION_OTHER;
    613613              }
     
    626626      {
    627627#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
    628         if (line[0] == '!' && 0 == sl_strcmp(&(line[2]), _("SCHEDULE_TWO")))
     628        if (line[0] == '!' && 0 == sl_strcasecmp(&(line[2]), _("SCHEDULE_TWO")))
    629629          set_dirList(1);
    630         else if (0 == sl_strcmp(&(line[1]), _("SCHEDULE_TWO")))
     630        else if (0 == sl_strcasecmp(&(line[1]), _("SCHEDULE_TWO")))
    631631          set_dirList(2);
    632632#else
  • trunk/src/sh_socket.c

    r270 r272  
    209209static void sh_socket_add2list (struct socket_cmd * in);
    210210
    211 void sh_socket_probe4reload (void)
     211static void sh_socket_probe4reload (void)
    212212{
    213213  struct reload_cmd  * new;
  • trunk/src/slib.c

    r252 r272  
    10801080  if (a != NULL && b != NULL)
    10811081    return (strncmp(a, b, n));
     1082  else if (a == NULL && b != NULL)
     1083    return (-1);
     1084  else if (a != NULL && b == NULL)
     1085    return (1);
     1086  else
     1087    return (-7); /* default to not equal */
     1088}
     1089
     1090int sl_strncasecmp(const char * a, const char * b, size_t n)
     1091{
     1092#ifdef SL_FAIL_ON_ERROR
     1093  SL_REQUIRE (a != NULL, _("a != NULL"));
     1094  SL_REQUIRE (b != NULL, _("b != NULL"));
     1095  SL_REQUIRE (n > 0, _("n > 0"));
     1096#endif
     1097
     1098  if (a != NULL && b != NULL)
     1099    return (strncasecmp(a, b, n));
    10821100  else if (a == NULL && b != NULL)
    10831101    return (-1);
Note: See TracChangeset for help on using the changeset viewer.