367 lines
9.4 KiB
C
367 lines
9.4 KiB
C
/* mailcheck.c The thing that checks the mail files... */
|
|
|
|
/* 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 <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/param.h>
|
|
#include "shell.h"
|
|
|
|
#ifndef MAXPATHLEN
|
|
#define MAXPATHLEN 1024
|
|
#endif
|
|
|
|
#define NOW ((time_t)time ((time_t *)0))
|
|
|
|
typedef struct {
|
|
char *name;
|
|
time_t access_time;
|
|
time_t mod_time;
|
|
} FILEINFO;
|
|
|
|
/* The list of remembered mail files. */
|
|
FILEINFO **mailfiles = (FILEINFO **)NULL;
|
|
|
|
/* Number of mail files that we have. */
|
|
int mailfiles_count = 0;
|
|
|
|
/* The last known time that mail was checked. */
|
|
int last_time_mail_checked = 0;
|
|
|
|
/* Returns non-zero if it is time to check mail. */
|
|
time_to_check_mail ()
|
|
{
|
|
char *temp = get_string_value ("MAILCHECK");
|
|
time_t now = NOW;
|
|
unsigned seconds = 0;
|
|
|
|
if ((!temp || sscanf (temp, "%u", &seconds) == 0) ||
|
|
((now - last_time_mail_checked < seconds)))
|
|
return (0);
|
|
|
|
return (1);
|
|
}
|
|
|
|
/* Okay, we have checked the mail. Perhaps I should make this function
|
|
go away. */
|
|
reset_mail_timer ()
|
|
{
|
|
last_time_mail_checked = NOW;
|
|
}
|
|
|
|
/* Locate a file in the list. Return index of
|
|
entry, or -1 if not found. */
|
|
find_mail_file (file)
|
|
char *file;
|
|
{
|
|
register int index = 0;
|
|
|
|
while (index < mailfiles_count)
|
|
if (strcmp ((mailfiles[index])->name, file) == 0) return index;
|
|
else index++;
|
|
return (-1);
|
|
}
|
|
|
|
/* Add this file to the list of remembered files. */
|
|
add_mail_file (file)
|
|
char *file;
|
|
{
|
|
struct stat finfo;
|
|
char *full_pathname ();
|
|
char *filename = full_pathname (file);
|
|
int index = find_mail_file (file);
|
|
|
|
if (index > -1)
|
|
{
|
|
if (stat (filename, &finfo) == 0)
|
|
{
|
|
mailfiles[index]->mod_time = finfo.st_mtime;
|
|
mailfiles[index]->access_time = finfo.st_atime;
|
|
}
|
|
free (filename);
|
|
return;
|
|
}
|
|
|
|
if (!mailfiles)
|
|
mailfiles =
|
|
(FILEINFO **)xmalloc ((mailfiles_count = 1) * sizeof (FILEINFO *));
|
|
else
|
|
mailfiles =
|
|
(FILEINFO **)xrealloc (mailfiles,
|
|
((++mailfiles_count) * sizeof (FILEINFO *)));
|
|
|
|
mailfiles[mailfiles_count - 1] = (FILEINFO *)xmalloc (sizeof (FILEINFO));
|
|
mailfiles[mailfiles_count - 1]->name = filename;
|
|
if (stat (filename, &finfo) == 0)
|
|
{
|
|
mailfiles[mailfiles_count - 1]->access_time = finfo.st_atime;
|
|
mailfiles[mailfiles_count - 1]->mod_time = finfo.st_mtime;
|
|
}
|
|
else
|
|
{
|
|
mailfiles[mailfiles_count - 1]->access_time
|
|
= mailfiles[mailfiles_count - 1]->mod_time = (time_t)-1;
|
|
}
|
|
}
|
|
|
|
/* Reset the existing mail files access and modification times to zero. */
|
|
reset_mail_files ()
|
|
{
|
|
register int i;
|
|
|
|
for (i = 0; i < mailfiles_count; i++)
|
|
mailfiles[i]->access_time = mailfiles[i]->mod_time = 0;
|
|
}
|
|
|
|
/* Free the information that we have about the remembered mail files. */
|
|
free_mail_files ()
|
|
{
|
|
while (mailfiles_count--)
|
|
{
|
|
free (mailfiles[mailfiles_count]->name);
|
|
free (mailfiles[mailfiles_count]);
|
|
}
|
|
mailfiles_count = 0;
|
|
free (mailfiles);
|
|
mailfiles = (FILEINFO **)NULL;
|
|
}
|
|
|
|
/* Return the full pathname of FILE. Easy. Filenames that begin
|
|
with a '/' are returned as themselves. Other filenames have
|
|
the current working directory prepended. A new string is
|
|
returned in either case. */
|
|
char *
|
|
full_pathname (file)
|
|
char *file;
|
|
{
|
|
char *tilde_expand (), *disposer;
|
|
extern int disallow_filename_globbing;
|
|
|
|
if (!disallow_filename_globbing && *file == '~')
|
|
file = tilde_expand (file);
|
|
else
|
|
file = savestring (file);
|
|
|
|
if (absolute_pathname (file))
|
|
if (*file == '/')
|
|
return (file);
|
|
|
|
disposer = file;
|
|
|
|
{
|
|
char *current_dir = (char *)xmalloc (2 + MAXPATHLEN + strlen (file));
|
|
if (!getwd (current_dir))
|
|
{
|
|
report_error (current_dir);
|
|
free (current_dir);
|
|
return ((char *)NULL);
|
|
}
|
|
strcat (current_dir, "/");
|
|
|
|
/* Turn /foo/./bar into /foo/bar. */
|
|
if (strncmp (file, "./", 2) == 0)
|
|
file += 2;
|
|
|
|
strcat (current_dir, file);
|
|
free (disposer);
|
|
return (current_dir);
|
|
}
|
|
}
|
|
|
|
/* Return non-zero if FILE's mod date has changed. */
|
|
file_mod_date_changed (file)
|
|
char *file;
|
|
{
|
|
time_t time = (time_t)NULL;
|
|
struct stat finfo;
|
|
|
|
int index = find_mail_file (file);
|
|
if (index != -1)
|
|
time = mailfiles[index]->mod_time;
|
|
|
|
if (stat (file, &finfo) == 0)
|
|
{
|
|
if (finfo.st_size != 0)
|
|
return (time != finfo.st_mtime);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/* Return non-zero if FILE's access date has changed. */
|
|
file_access_date_changed (file)
|
|
char *file;
|
|
{
|
|
time_t time = (time_t)NULL;
|
|
struct stat finfo;
|
|
|
|
int index = find_mail_file (file);
|
|
if (index != -1)
|
|
time = mailfiles[index]->access_time;
|
|
|
|
if (stat (file, &finfo) == 0)
|
|
{
|
|
if (finfo.st_size != 0)
|
|
return (time != finfo.st_atime);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
#ifdef SYSV
|
|
#define DEFAULT_MAIL_PATH "/usr/mail/"
|
|
#else
|
|
#define DEFAULT_MAIL_PATH "/usr/spool/mail/"
|
|
#endif
|
|
|
|
/* Return the colon separated list of pathnames to check for mail. */
|
|
char *
|
|
get_mailpaths ()
|
|
{
|
|
extern char *current_user_name;
|
|
char *mailpaths = get_string_value ("MAILPATH");
|
|
if (!mailpaths) mailpaths = get_string_value ("MAIL");
|
|
if (!mailpaths)
|
|
{
|
|
mailpaths = (char *)alloca (1 + strlen (DEFAULT_MAIL_PATH)
|
|
+ strlen (current_user_name));
|
|
strcpy (mailpaths, DEFAULT_MAIL_PATH);
|
|
strcat (mailpaths, current_user_name);
|
|
}
|
|
return (savestring (mailpaths));
|
|
}
|
|
|
|
/* 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. */
|
|
remember_mail_dates ()
|
|
{
|
|
char *mailpaths = get_mailpaths ();
|
|
char *mailfile, *extract_colon_unit ();
|
|
int index = 0;
|
|
|
|
while (mailfile = extract_colon_unit (mailpaths, &index))
|
|
{
|
|
register int i;
|
|
for (i = 0;
|
|
mailfile[i] && mailfile[i] != '?' && mailfile[i] != '%';
|
|
i++);
|
|
mailfile[i] = '\0';
|
|
add_mail_file (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 shell variable MAIL_WARNING is on 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. */
|
|
check_mail ()
|
|
{
|
|
char *extract_colon_unit ();
|
|
char *current_mail_file, *you_have_mail_message;
|
|
char *mailpaths = get_mailpaths ();
|
|
int index = 0;
|
|
register int string_index;
|
|
|
|
while ((current_mail_file = extract_colon_unit (mailpaths, &index)))
|
|
{
|
|
char *t, *tilde_expand ();
|
|
int use_user_notification;
|
|
|
|
if (!*current_mail_file)
|
|
{
|
|
free (current_mail_file);
|
|
continue;
|
|
}
|
|
|
|
t = full_pathname (current_mail_file);
|
|
free (current_mail_file);
|
|
current_mail_file = t;
|
|
|
|
use_user_notification = 0;
|
|
you_have_mail_message = "You have mail in $_";
|
|
|
|
for (string_index = 0; current_mail_file[string_index]; string_index++)
|
|
if (current_mail_file[string_index] == '?'
|
|
|| current_mail_file[string_index] == '%')
|
|
{
|
|
current_mail_file[string_index] = '\0';
|
|
you_have_mail_message = current_mail_file + string_index + 1;
|
|
use_user_notification++;
|
|
break;
|
|
}
|
|
|
|
if (file_mod_date_changed (current_mail_file))
|
|
{
|
|
WORD_LIST *tlist, *expand_string ();
|
|
char *string_list ();
|
|
int i;
|
|
bind_variable ("_", current_mail_file);
|
|
|
|
add_mail_file (current_mail_file);
|
|
|
|
i = find_mail_file (current_mail_file);
|
|
|
|
/* 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. */
|
|
if (i != -1 &&
|
|
mailfiles[i]->access_time == mailfiles[i]->mod_time)
|
|
goto next_mail_file;
|
|
|
|
if (!use_user_notification)
|
|
{
|
|
if (i != -1 &&
|
|
mailfiles[i]->access_time < mailfiles[i]->mod_time)
|
|
you_have_mail_message = "You have new mail in $_";
|
|
}
|
|
|
|
if ((tlist = expand_string (you_have_mail_message)))
|
|
{
|
|
char *tem = string_list (tlist);
|
|
you_have_mail_message = (char *)alloca (1 + strlen (tem));
|
|
strcpy (you_have_mail_message, tem);
|
|
free (tem);
|
|
}
|
|
else
|
|
you_have_mail_message = "";
|
|
|
|
printf ("%s\n", you_have_mail_message);
|
|
dispose_words (tlist);
|
|
}
|
|
|
|
if (find_variable ("MAIL_WARNING")
|
|
&& file_access_date_changed (current_mail_file))
|
|
{
|
|
add_mail_file (current_mail_file);
|
|
printf ("The mail in %s has been read!\n", current_mail_file);
|
|
}
|
|
next_mail_file:
|
|
free (current_mail_file);
|
|
}
|
|
free (mailpaths);
|
|
}
|