[thirdparty/bash.git] / mailcheck.c

/* mailcheck.c -- The check is in the mail... */

/* Copyright (C) 1987,1989 Free Software Foundation, Inc.

This file is part of GNU Bash, the Bourne Again SHell.

Bash 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 1, or (at your option) any later
version.

Bash 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 Bash; see the file COPYING.  If not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */

#include "config.h"

#include <stdio.h>
#include "bashtypes.h"
#include "posixstat.h"
#include <sys/param.h>
#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif
#include "bashansi.h"

#include "shell.h"
#include "maxpath.h"
#include "execute_cmd.h"
#include "mailcheck.h"
#include <tilde/tilde.h>

#ifndef NOW
#define NOW ((time_t)time ((time_t *)0))
#endif

typedef struct {
  char *name;
  char *msg;
  time_t access_time;
  time_t mod_time;
  long file_size;
} FILEINFO;

/* The list of remembered mail files. */
static FILEINFO **mailfiles = (FILEINFO **)NULL;

/* Number of mail files that we have. */
static int mailfiles_count;

/* The last known time that mail was checked. */
static int last_time_mail_checked;

/* Non-zero means warn if a mail file has been read since last checked. */
int mail_warning;

/* Returns non-zero if it is time to check mail. */
int
time_to_check_mail ()
{
  char *temp;
  time_t now;
  long seconds;

  temp = get_string_value ("MAILCHECK");
  seconds = -1L;

  /* Skip leading whitespace in MAILCHECK. */
  if (temp)
    {
      while (whitespace (*temp))
	temp++;

      seconds = atoi (temp);
    }

  /* Negative number, or non-numbers (such as empty string) cause no
     checking to take place. */
  if (seconds < 0)
    return (0);

  now = NOW;
  /* Time to check if MAILCHECK is explicitly set to zero, or if enough
     time has passed since the last check. */
  return (seconds == 0 || ((now - last_time_mail_checked) >= seconds));
}

/* Okay, we have checked the mail.  Perhaps I should make this function
   go away. */
void
reset_mail_timer ()
{
  last_time_mail_checked = NOW;
}

/* Locate a file in the list.  Return index of
   entry, or -1 if not found. */
static int
find_mail_file (file)
     char *file;
{
  register int i;

  for (i = 0; i < mailfiles_count; i++)
    if (STREQ (mailfiles[i]->name, file))
      return i;

  return -1;
}

#define RESET_MAIL_FILE(i) \
  do \
    { \
      mailfiles[i]->access_time = mailfiles[i]->mod_time = 0; \
      mailfiles[i]->file_size = 0L; \
    } \
  while (0)

static void
update_mail_file (i)
     int i;
{
  char *file;
  struct stat finfo;

  file = mailfiles[i]->name;
  if (stat (file, &finfo) == 0)
    {
      mailfiles[i]->access_time = finfo.st_atime;
      mailfiles[i]->mod_time = finfo.st_mtime;
      mailfiles[i]->file_size = finfo.st_size;
    }
  else
    RESET_MAIL_FILE (i);
}

/* Add this file to the list of remembered files and return its index
   in the list of mail files. */
static int
add_mail_file (file, msg)
     char *file, *msg;
{
  struct stat finfo;
  char *filename;
  int i;

  filename = full_pathname (file);
  i = find_mail_file (filename);
  if (i >= 0)
    {
      if (stat (filename, &finfo) == 0)
	{
	  mailfiles[i]->mod_time = finfo.st_mtime;
	  mailfiles[i]->access_time = finfo.st_atime;
	  mailfiles[i]->file_size = (long)finfo.st_size;
	}
      free (filename);
      return i;
    }

  i = mailfiles_count++;
  mailfiles = (FILEINFO **)xrealloc
		(mailfiles, mailfiles_count * sizeof (FILEINFO *));

  mailfiles[i] = (FILEINFO *)xmalloc (sizeof (FILEINFO));
  mailfiles[i]->name = filename;
  mailfiles[i]->msg = msg ? savestring (msg) : (char *)NULL;
  update_mail_file (i);
  return i;
}

/* Reset the existing mail files access and modification times to zero. */
void
reset_mail_files ()
{
  register int i;

  for (i = 0; i < mailfiles_count; i++)
    {
      RESET_MAIL_FILE (i);
    }
}

/* Free the information that we have about the remembered mail files. */
void
free_mail_files ()
{
  register int i;

  for (i = 0; i < mailfiles_count; i++)
    {
      free (mailfiles[i]->name);
      FREE (mailfiles[i]->msg);
      free (mailfiles[i]);
    }

  if (mailfiles)
    free (mailfiles);

  mailfiles_count = 0;
  mailfiles = (FILEINFO **)NULL;
}

/* Return non-zero if FILE's mod date has changed and it has not been
   accessed since modified. */
static int
file_mod_date_changed (i)
     int i;
{
  time_t mtime;
  struct stat finfo;
  char *file;

  file = mailfiles[i]->name;
  mtime = mailfiles[i]->mod_time;

  if ((stat (file, &finfo) == 0) && (finfo.st_size > 0))
    return (mtime != finfo.st_mtime);

  return (0);
}

/* Return non-zero if FILE's access date has changed. */
static int
file_access_date_changed (i)
     int i;
{
  time_t atime;
  struct stat finfo;
  char *file;

  file = mailfiles[i]->name;
  atime = mailfiles[i]->access_time;

  if ((stat (file, &finfo) == 0) && (finfo.st_size > 0))
    return (atime != finfo.st_atime);

  return (0);
}

/* Return non-zero if FILE's size has increased. */
static int
file_has_grown (i)
     int i;
{
  long size;
  struct stat finfo;
  char *file;

  file = mailfiles[i]->name;
  size = mailfiles[i]->file_size;

  return ((stat (file, &finfo) == 0) && (finfo.st_size > size));
}

/* Take an element from $MAILPATH and return the portion from
   the first unquoted `?' or `%' to the end of the string.  This is the
   message to be printed when the file contents change. */
static char *
parse_mailpath_spec (str)
     char *str;
{
  char *s;
  int pass_next;

  for (s = str, pass_next = 0; s && *s; s++)
    {
      if (pass_next)
	{
	  pass_next = 0;
	  continue;
	}
      if (*s == '\\')
	{
	  pass_next++;
	  continue;
	}
      if (*s == '?' || *s == '%')
        return s;
    }
  return ((char *)NULL);
}

char *
make_default_mailpath ()
{
  char *mp;

  mp = xmalloc (2 + sizeof (DEFAULT_MAIL_DIRECTORY) + strlen (current_user.user_name));
  strcpy (mp, DEFAULT_MAIL_DIRECTORY);
  mp[sizeof(DEFAULT_MAIL_DIRECTORY) - 1] = '/';
  strcpy (mp + sizeof (DEFAULT_MAIL_DIRECTORY), current_user.user_name);
  return (mp);
}

/* Remember the dates of the files specified by MAILPATH, or if there is
   no MAILPATH, by the file specified in MAIL.  If neither exists, use a
   default value, which we randomly concoct from using Unix. */
void
remember_mail_dates ()
{
  char *mailpaths;
  char *mailfile, *mp;
  int i = 0;

  mailpaths = get_string_value ("MAILPATH");

  /* If no $MAILPATH, but $MAIL, use that as a single filename to check. */
  if (mailpaths == 0 && (mailpaths = get_string_value ("MAIL")))
    {
      add_mail_file (mailpaths, (char *)NULL);
      return;
    }

  if (mailpaths == 0)
    {
      mailpaths = make_default_mailpath ();
      add_mail_file (mailpaths, (char *)NULL);
      free (mailpaths);
      return;
    }

  while (mailfile = extract_colon_unit (mailpaths, &i))
    {
      mp = parse_mailpath_spec (mailfile);
      if (mp && *mp)
	*mp++ = '\0';
      add_mail_file (mailfile, mp);
      free (mailfile);
    }
}

/* check_mail () is useful for more than just checking mail.  Since it has
   the paranoids dream ability of telling you when someone has read your
   mail, it can just as easily be used to tell you when someones .profile
   file has been read, thus letting one know when someone else has logged
   in.  Pretty good, huh? */

/* Check for mail in some files.  If the modification date of any
   of the files in MAILPATH has changed since we last did a
   remember_mail_dates () then mention that the user has mail.
   Special hack:  If the variable MAIL_WARNING is non-zero and the
   mail file has been accessed since the last time we remembered, then
   the message "The mail in <mailfile> has been read" is printed. */
void
check_mail ()
{
  char *current_mail_file, *message;
  int i, use_user_notification;
  char *dollar_underscore, *temp;
  WORD_LIST *tlist;

  dollar_underscore = get_string_value ("_");
  if (dollar_underscore)
    dollar_underscore = savestring (dollar_underscore);

  for (i = 0; i < mailfiles_count; i++)
    {
      current_mail_file = mailfiles[i]->name;

      if (*current_mail_file == '\0')
	continue;

      if (file_mod_date_changed (i))
	{
	  int file_is_bigger;

	  use_user_notification = mailfiles[i]->msg != (char *)NULL;
	  message = mailfiles[i]->msg ? mailfiles[i]->msg : "You have mail in $_";

	  bind_variable ("_", current_mail_file);

#define atime mailfiles[i]->access_time
#define mtime mailfiles[i]->mod_time

	  /* Have to compute this before the call to update_mail_file, which
	     resets all the information. */
	  file_is_bigger = file_has_grown (i);

	  update_mail_file (i);

	  /* If the user has just run a program which manipulates the
	     mail file, then don't bother explaining that the mail
	     file has been manipulated.  Since some systems don't change
	     the access time to be equal to the modification time when
	     the mail in the file is manipulated, check the size also.  If
	     the file has not grown, continue. */
	  if ((atime >= mtime) && !file_is_bigger)
	    continue;

	  /* If the mod time is later than the access time and the file
	     has grown, note the fact that this is *new* mail. */
	  if (use_user_notification == 0 && (atime < mtime) && file_is_bigger)
	    message = "You have new mail in $_";
#undef atime
#undef mtime

	  if ((tlist = expand_string (message, Q_DOUBLE_QUOTES)))
	    {
	      temp = string_list (tlist);
	      puts (temp);
	      free (temp);
	      dispose_words (tlist);
	    }
	  else
	    putchar ('\n');
	}

      if (mail_warning && file_access_date_changed (i))
	{
	  update_mail_file (i);
	  printf ("The mail in %s has been read\n", current_mail_file);
	}
    }

  if (dollar_underscore)
    {
      bind_variable ("_", dollar_underscore);
      free (dollar_underscore);
    }
  else
    unbind_variable ("_");
}
Commit	Line	Data
726f6388 JA	1	/* mailcheck.c -- The check is in the mail... */
	2
	3	/* Copyright (C) 1987,1989 Free Software Foundation, Inc.
	4
	5	This file is part of GNU Bash, the Bourne Again SHell.
	6
	7	Bash is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
	9	Software Foundation; either version 1, or (at your option) any later
	10	version.
	11
	12	Bash is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License along
	18	with Bash; see the file COPYING. If not, write to the Free Software
	19	Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
ccc6cda3 JA	21	#include "config.h"
ccc6cda3 JA	22
726f6388 JA	23	#include <stdio.h>
	24	#include "bashtypes.h"
	25	#include "posixstat.h"
	26	#include <sys/param.h>
ccc6cda3 JA	27	#if defined (HAVE_UNISTD_H)
	28	# include <unistd.h>
	29	#endif
726f6388	30	#include "bashansi.h"
ccc6cda3	31
726f6388 JA	32	#include "shell.h"
	33	#include "maxpath.h"
	34	#include "execute_cmd.h"
ccc6cda3	35	#include "mailcheck.h"
726f6388 JA	36	#include <tilde/tilde.h>
	37
	38	#ifndef NOW
	39	#define NOW ((time_t)time ((time_t *)0))
	40	#endif
	41
	42	typedef struct {
	43	char *name;
ccc6cda3	44	char *msg;
726f6388 JA	45	time_t access_time;
	46	time_t mod_time;
	47	long file_size;
	48	} FILEINFO;
	49
	50	/* The list of remembered mail files. */
ccc6cda3	51	static FILEINFO mailfiles = (FILEINFO )NULL;
726f6388 JA	52
726f6388 JA	53	/* Number of mail files that we have. */
ccc6cda3	54	static int mailfiles_count;
726f6388 JA	55
726f6388 JA	56	/* The last known time that mail was checked. */
ccc6cda3 JA	57	static int last_time_mail_checked;
	58
	59	/* Non-zero means warn if a mail file has been read since last checked. */
	60	int mail_warning;
726f6388 JA	61
	62	/* Returns non-zero if it is time to check mail. */
	63	int
	64	time_to_check_mail ()
	65	{
ccc6cda3 JA	66	char *temp;
	67	time_t now;
	68	long seconds;
	69
	70	temp = get_string_value ("MAILCHECK");
	71	seconds = -1L;
726f6388 JA	72
	73	/* Skip leading whitespace in MAILCHECK. */
	74	if (temp)
	75	{
	76	while (whitespace (*temp))
	77	temp++;
	78
	79	seconds = atoi (temp);
	80	}
	81
	82	/* Negative number, or non-numbers (such as empty string) cause no
	83	checking to take place. */
	84	if (seconds < 0)
	85	return (0);
	86
ccc6cda3	87	now = NOW;
726f6388 JA	88	/* Time to check if MAILCHECK is explicitly set to zero, or if enough
726f6388 JA	89	time has passed since the last check. */
ccc6cda3	90	return (seconds == 0 \|\| ((now - last_time_mail_checked) >= seconds));
726f6388 JA	91	}
	92
	93	/* Okay, we have checked the mail. Perhaps I should make this function
	94	go away. */
	95	void
	96	reset_mail_timer ()
	97	{
	98	last_time_mail_checked = NOW;
	99	}
	100
	101	/* Locate a file in the list. Return index of
	102	entry, or -1 if not found. */
	103	static int
	104	find_mail_file (file)
	105	char *file;
	106	{
	107	register int i;
	108
	109	for (i = 0; i < mailfiles_count; i++)
ccc6cda3	110	if (STREQ (mailfiles[i]->name, file))
726f6388 JA	111	return i;
	112
	113	return -1;
	114	}
	115
ccc6cda3 JA	116	#define RESET_MAIL_FILE(i) \
	117	do \
	118	{ \
	119	mailfiles[i]->access_time = mailfiles[i]->mod_time = 0; \
	120	mailfiles[i]->file_size = 0L; \
	121	} \
	122	while (0)
	123
	124	static void
	125	update_mail_file (i)
	126	int i;
	127	{
	128	char *file;
	129	struct stat finfo;
	130
	131	file = mailfiles[i]->name;
	132	if (stat (file, &finfo) == 0)
	133	{
	134	mailfiles[i]->access_time = finfo.st_atime;
	135	mailfiles[i]->mod_time = finfo.st_mtime;
	136	mailfiles[i]->file_size = finfo.st_size;
	137	}
	138	else
	139	RESET_MAIL_FILE (i);
	140	}
	141
726f6388 JA	142	/* Add this file to the list of remembered files and return its index
	143	in the list of mail files. */
	144	static int
ccc6cda3 JA	145	add_mail_file (file, msg)
ccc6cda3 JA	146	char file, msg;
726f6388 JA	147	{
	148	struct stat finfo;
	149	char *filename;
	150	int i;
	151
	152	filename = full_pathname (file);
e8ce775d	153	i = find_mail_file (filename);
ccc6cda3	154	if (i >= 0)
726f6388 JA	155	{
	156	if (stat (filename, &finfo) == 0)
	157	{
	158	mailfiles[i]->mod_time = finfo.st_mtime;
	159	mailfiles[i]->access_time = finfo.st_atime;
	160	mailfiles[i]->file_size = (long)finfo.st_size;
	161	}
	162	free (filename);
	163	return i;
	164	}
	165
	166	i = mailfiles_count++;
	167	mailfiles = (FILEINFO **)xrealloc
	168	(mailfiles, mailfiles_count * sizeof (FILEINFO *));
	169
	170	mailfiles[i] = (FILEINFO *)xmalloc (sizeof (FILEINFO));
	171	mailfiles[i]->name = filename;
ccc6cda3 JA	172	mailfiles[i]->msg = msg ? savestring (msg) : (char *)NULL;
ccc6cda3 JA	173	update_mail_file (i);
726f6388 JA	174	return i;
	175	}
	176
	177	/* Reset the existing mail files access and modification times to zero. */
	178	void
	179	reset_mail_files ()
	180	{
	181	register int i;
	182
	183	for (i = 0; i < mailfiles_count; i++)
	184	{
ccc6cda3	185	RESET_MAIL_FILE (i);
726f6388 JA	186	}
	187	}
	188
	189	/* Free the information that we have about the remembered mail files. */
	190	void
	191	free_mail_files ()
	192	{
	193	register int i;
	194
	195	for (i = 0; i < mailfiles_count; i++)
	196	{
	197	free (mailfiles[i]->name);
ccc6cda3	198	FREE (mailfiles[i]->msg);
726f6388 JA	199	free (mailfiles[i]);
	200	}
	201
	202	if (mailfiles)
	203	free (mailfiles);
	204
	205	mailfiles_count = 0;
	206	mailfiles = (FILEINFO **)NULL;
	207	}
	208
	209	/* Return non-zero if FILE's mod date has changed and it has not been
	210	accessed since modified. */
	211	static int
ccc6cda3 JA	212	file_mod_date_changed (i)
ccc6cda3 JA	213	int i;
726f6388	214	{
ccc6cda3	215	time_t mtime;
726f6388	216	struct stat finfo;
ccc6cda3	217	char *file;
726f6388	218
ccc6cda3 JA	219	file = mailfiles[i]->name;
ccc6cda3 JA	220	mtime = mailfiles[i]->mod_time;
726f6388 JA	221
726f6388 JA	222	if ((stat (file, &finfo) == 0) && (finfo.st_size > 0))
ccc6cda3	223	return (mtime != finfo.st_mtime);
726f6388 JA	224
	225	return (0);
	226	}
	227
	228	/* Return non-zero if FILE's access date has changed. */
	229	static int
ccc6cda3 JA	230	file_access_date_changed (i)
ccc6cda3 JA	231	int i;
726f6388	232	{
ccc6cda3	233	time_t atime;
726f6388	234	struct stat finfo;
ccc6cda3	235	char *file;
726f6388	236
ccc6cda3 JA	237	file = mailfiles[i]->name;
ccc6cda3 JA	238	atime = mailfiles[i]->access_time;
726f6388 JA	239
726f6388 JA	240	if ((stat (file, &finfo) == 0) && (finfo.st_size > 0))
ccc6cda3	241	return (atime != finfo.st_atime);
726f6388 JA	242
	243	return (0);
	244	}
	245
	246	/* Return non-zero if FILE's size has increased. */
	247	static int
ccc6cda3 JA	248	file_has_grown (i)
ccc6cda3 JA	249	int i;
726f6388	250	{
ccc6cda3	251	long size;
726f6388	252	struct stat finfo;
ccc6cda3	253	char *file;
726f6388	254
ccc6cda3 JA	255	file = mailfiles[i]->name;
ccc6cda3 JA	256	size = mailfiles[i]->file_size;
726f6388 JA	257
	258	return ((stat (file, &finfo) == 0) && (finfo.st_size > size));
	259	}
	260
726f6388 JA	261	/* Take an element from $MAILPATH and return the portion from
	262	the first unquoted `?' or `%' to the end of the string. This is the
	263	message to be printed when the file contents change. */
	264	static char *
	265	parse_mailpath_spec (str)
	266	char *str;
	267	{
	268	char *s;
	269	int pass_next;
	270
	271	for (s = str, pass_next = 0; s && *s; s++)
	272	{
	273	if (pass_next)
	274	{
	275	pass_next = 0;
	276	continue;
	277	}
	278	if (*s == '\\')
	279	{
	280	pass_next++;
	281	continue;
	282	}
	283	if (s == '?' \|\| s == '%')
	284	return s;
	285	}
	286	return ((char *)NULL);
	287	}
ccc6cda3 JA	288
	289	char *
	290	make_default_mailpath ()
	291	{
	292	char *mp;
	293
d166f048	294	mp = xmalloc (2 + sizeof (DEFAULT_MAIL_DIRECTORY) + strlen (current_user.user_name));
ccc6cda3	295	strcpy (mp, DEFAULT_MAIL_DIRECTORY);
d166f048 JA	296	mp[sizeof(DEFAULT_MAIL_DIRECTORY) - 1] = '/';
d166f048 JA	297	strcpy (mp + sizeof (DEFAULT_MAIL_DIRECTORY), current_user.user_name);
ccc6cda3 JA	298	return (mp);
	299	}
	300
726f6388 JA	301	/* Remember the dates of the files specified by MAILPATH, or if there is
	302	no MAILPATH, by the file specified in MAIL. If neither exists, use a
	303	default value, which we randomly concoct from using Unix. */
	304	void
	305	remember_mail_dates ()
	306	{
	307	char *mailpaths;
	308	char mailfile, mp;
	309	int i = 0;
	310
ccc6cda3 JA	311	mailpaths = get_string_value ("MAILPATH");
	312
	313	/* If no $MAILPATH, but $MAIL, use that as a single filename to check. */
	314	if (mailpaths == 0 && (mailpaths = get_string_value ("MAIL")))
	315	{
	316	add_mail_file (mailpaths, (char *)NULL);
	317	return;
	318	}
	319
	320	if (mailpaths == 0)
	321	{
	322	mailpaths = make_default_mailpath ();
	323	add_mail_file (mailpaths, (char *)NULL);
	324	free (mailpaths);
	325	return;
	326	}
	327
726f6388 JA	328	while (mailfile = extract_colon_unit (mailpaths, &i))
	329	{
	330	mp = parse_mailpath_spec (mailfile);
	331	if (mp && *mp)
ccc6cda3 JA	332	*mp++ = '\0';
ccc6cda3 JA	333	add_mail_file (mailfile, mp);
726f6388 JA	334	free (mailfile);
726f6388 JA	335	}
726f6388 JA	336	}
	337
	338	/* check_mail () is useful for more than just checking mail. Since it has
	339	the paranoids dream ability of telling you when someone has read your
	340	mail, it can just as easily be used to tell you when someones .profile
	341	file has been read, thus letting one know when someone else has logged
	342	in. Pretty good, huh? */
	343
	344	/* Check for mail in some files. If the modification date of any
	345	of the files in MAILPATH has changed since we last did a
	346	remember_mail_dates () then mention that the user has mail.
ccc6cda3	347	Special hack: If the variable MAIL_WARNING is non-zero and the
726f6388 JA	348	mail file has been accessed since the last time we remembered, then
	349	the message "The mail in <mailfile> has been read" is printed. */
	350	void
	351	check_mail ()
	352	{
ccc6cda3 JA	353	char current_mail_file, message;
	354	int i, use_user_notification;
	355	char dollar_underscore, temp;
	356	WORD_LIST *tlist;
726f6388 JA	357
726f6388 JA	358	dollar_underscore = get_string_value ("_");
726f6388 JA	359	if (dollar_underscore)
	360	dollar_underscore = savestring (dollar_underscore);
	361
ccc6cda3	362	for (i = 0; i < mailfiles_count; i++)
726f6388	363	{
ccc6cda3	364	current_mail_file = mailfiles[i]->name;
726f6388	365
ccc6cda3 JA	366	if (*current_mail_file == '\0')
ccc6cda3 JA	367	continue;
726f6388	368
ccc6cda3	369	if (file_mod_date_changed (i))
726f6388	370	{
ccc6cda3 JA	371	int file_is_bigger;
	372
	373	use_user_notification = mailfiles[i]->msg != (char *)NULL;
	374	message = mailfiles[i]->msg ? mailfiles[i]->msg : "You have mail in $_";
726f6388	375
726f6388	376	bind_variable ("_", current_mail_file);
ccc6cda3	377
726f6388 JA	378	#define atime mailfiles[i]->access_time
	379	#define mtime mailfiles[i]->mod_time
	380
ccc6cda3	381	/* Have to compute this before the call to update_mail_file, which
726f6388	382	resets all the information. */
ccc6cda3	383	file_is_bigger = file_has_grown (i);
726f6388	384
ccc6cda3	385	update_mail_file (i);
726f6388 JA	386
	387	/* If the user has just run a program which manipulates the
	388	mail file, then don't bother explaining that the mail
	389	file has been manipulated. Since some systems don't change
	390	the access time to be equal to the modification time when
	391	the mail in the file is manipulated, check the size also. If
	392	the file has not grown, continue. */
	393	if ((atime >= mtime) && !file_is_bigger)
ccc6cda3	394	continue;
726f6388 JA	395
	396	/* If the mod time is later than the access time and the file
	397	has grown, note the fact that this is new mail. */
ccc6cda3 JA	398	if (use_user_notification == 0 && (atime < mtime) && file_is_bigger)
ccc6cda3 JA	399	message = "You have new mail in $_";
726f6388 JA	400	#undef atime
	401	#undef mtime
	402
ccc6cda3	403	if ((tlist = expand_string (message, Q_DOUBLE_QUOTES)))
726f6388	404	{
ccc6cda3 JA	405	temp = string_list (tlist);
	406	puts (temp);
	407	free (temp);
726f6388 JA	408	dispose_words (tlist);
	409	}
	410	else
ccc6cda3	411	putchar ('\n');
726f6388 JA	412	}
726f6388 JA	413
ccc6cda3	414	if (mail_warning && file_access_date_changed (i))
726f6388	415	{
ccc6cda3 JA	416	update_mail_file (i);
ccc6cda3 JA	417	printf ("The mail in %s has been read\n", current_mail_file);
726f6388	418	}
726f6388	419	}
726f6388 JA	420
	421	if (dollar_underscore)
	422	{
	423	bind_variable ("_", dollar_underscore);
	424	free (dollar_underscore);
	425	}
	426	else
	427	unbind_variable ("_");
	428	}