aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/fetchsetup
blob: 83223a116a1c5dce35df624600533b28efb2d26a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#!/bin/sh

MSG() {
cat << EOF

# Fetchsetup is a shell script for creating a .fetchmailrc file, that will be
# used by the program "fetchmail" to connect to your mail domain and retrieve
# your mail.
# This script is linux specific, so it may not work on another system.
# Kent Robotti <krobot@erols.com> (3-31-99)

EOF
}

if [ "$(id -ur)" != "0" ]; then
    echo >&2 "$0: You need to be root [found $(id -un)] to run this script."
    echo >&2 "You could login as root"
    echo >&2 "You could also try one of these: # sudo fetchsetup"
    echo >&2 "                                 # su root -c fetchsetup"
    exit 1
fi

MSG
echo -n "Continue? (Y/n) : "
read ans
if [ "$ans" = "n" -o "$ans" = "N" ]; then
    echo "Cancelled."
    exit 0
fi

stty erase "^?" 2>/dev/null

echo
echo "Remote mail site?: pop.boo.com   <Your service providers mail domain name>"
echo -n "Remote mail site?: "
read SITE
echo
echo "Protocol?: pop3   <My service provider uses the 'pop3' mail protocol>"
echo "Protocol?: auto   <If not sure put: auto>"
echo "Choices: apop auto etrn imap imap-gss imap-k4 kpop pop2 pop3 rpop sdps"
echo -n "Protocol?: "
read PROTO
echo
echo "Remote username?: jerry   <My username or login is jerry>"
echo -n "Remote username?: "
read USR
echo
echo "Remote password?: ?       <What's the password for?: $USR>"
echo -n "Remote password?: "
read PASS

echo
echo -n "Create $HOME/.fetchmailrc file? (Y/n) : "
read ans
if [ "$ans" = "n" -o "$ans" = "N" ]; then
    echo
    echo "Fetchsetup cancelled."
    echo
    exit 0
fi

echo 'poll "'$SITE'"' > $HOME/.fetchmailrc
echo "protocol $PROTO" >> $HOME/.fetchmailrc
echo 'username "'$USR'"' >> $HOME/.fetchmailrc
echo 'password "'$PASS'"' >> $HOME/.fetchmailrc

PROCMAIL=`type -all procmail | sed -n "1 p" | cut -d' ' -f3`
SENDMAIL=`type -all sendmail | sed -n "1 p" | cut -d' ' -f3`

if [ ! "$PROCMAIL" = "" ]; then
    echo 'mda "'$PROCMAIL -d %s'"' >> $HOME/.fetchmailrc
    MDA="1"
elif [ ! "$SENDMAIL" = "" ]; then
    echo 'mda "'$SENDMAIL %s'"' >> $HOME/.fetchmailrc
    MDA="2"
else
    MDA="3"
fi

echo >> $HOME/.fetchmailrc
echo
echo "This is your $HOME/.fetchmailrc file."

chmod 600 $HOME/.fetchmailrc

echo
cat $HOME/.fetchmailrc

if [ ! "$MAIL" = "" ]; then
    echo "Fetchmail will retrieve your mail and put it in:"
    echo "$MAIL"
    if [ ! -f "$MAIL" ]; then
	touch $MAIL 2>/dev/null
	chmod 600 $MAIL 2>/dev/null
    fi
fi

echo
if [ "$MDA" = "1" ]; then
    echo "I put that (m)ail (d)elivery (a)gent in .fetchmailrc"
    echo "because i found it on your system, this doesn't mean"
    echo "it's correct or the one you want to use."
    echo
    echo "The first time you run fetchmail, you should run it"
    echo "this way: # fetchmail -k"
    echo
elif [ "$MDA" = "2" ]; then
    echo "You seem to have sendmail, sendmail will be used"
    echo "as the (m)ail (d)elivery (a)gent for fetchmail."
    echo
    echo "WARNING! There's no way to know if sendmail is set up"
    echo "properly for local mail delivery, so the first time you"
    echo "run fetchmail run it this way: # fetchmail -k"
    echo
    echo "If the mail that fetchmail retrieves is not put in your mailbox,"
    echo "you'll know that sendmail is not set up properly for the delivery"
    echo "of local mail."
    echo
elif [ "$MDA" = "3" ]; then
    echo "I Don't know what (m)ail (d)elivery (a)gent you're going to use."
    echo "You need a <mda> to deliver the mail to you, after <fetchmail> retrieves it."
    echo
    echo "Put the <mda> in your .fetchmailrc file, like below."
    echo "password $PASS"
    echo mda '"/usr/bin/procmail -d %s"'
    echo mda '"/usr/sbin/sendmail %s"'
    echo
    echo "The first time you run fetchmail, you should run it"
    echo "this way: # fetchmail -k"
    echo
fi
e program_name program_invocation_name # include <errno.h> #else /* The calling program should define program_name and set it to the name of the executing program. */ extern char *program_name; # if !HAVE_STRERROR && !defined(strerror) char *strerror (errnum) int errnum; { extern char *sys_errlist[]; extern int sys_nerr; if (errnum > 0 && errnum <= sys_nerr) return sys_errlist[errnum]; return _("Unknown system error"); } # endif /* HAVE_STRERROR */ #endif /* _LIBC */ /* Print the program name and error message MESSAGE, which is a printf-style format string with optional args. If ERRNUM is nonzero, print its corresponding system error message. */ /* VARARGS */ void #ifdef HAVE_STDARG_H report (FILE *errfp, const char *message, ...) #else report (FILE *errfp, message, va_alist) const char *message; va_dcl #endif { #ifdef VA_START va_list args; #endif /* If a partially built message exists, print it now so it's not lost. */ if (partial_message_size_used != 0) { partial_message_size_used = 0; report (errfp, 0, _("%s (log message incomplete)"), partial_message); } #if defined(HAVE_SYSLOG) if (use_syslog) { int priority; #ifdef VA_START VA_START (args, message); #endif priority = (errfp == stderr) ? LOG_ERR : LOG_INFO; #ifdef HAVE_VSYSLOG vsyslog (priority, message, args); #else { char *a1 = va_arg(args, char *); char *a2 = va_arg(args, char *); char *a3 = va_arg(args, char *); char *a4 = va_arg(args, char *); char *a5 = va_arg(args, char *); char *a6 = va_arg(args, char *); char *a7 = va_arg(args, char *); char *a8 = va_arg(args, char *); syslog (priority, message, a1, a2, a3, a4, a5, a6, a7, a8); } #endif #ifdef VA_START va_end(args); #endif } else #endif { if (error_print_progname) (*error_print_progname) (); else { fflush (errfp); if ( *message == '\n' ) { fputc( '\n', errfp ); ++message; } fprintf (errfp, "%s: ", program_name); } #ifdef VA_START VA_START (args, message); # if HAVE_VPRINTF || _LIBC vfprintf (errfp, message, args); # else _doprnt (message, args, errfp); # endif va_end (args); #else fprintf (errfp, message, a1, a2, a3, a4, a5, a6, a7, a8); #endif fflush (errfp); } ++error_message_count; } /* * Calling report_init(1) causes error_build and error_complete to write * to errfp without buffering. This is needed for the ticker dots to * work correctly. */ void report_init(int mode) { switch(mode) { case 0: /* errfp, buffered */ default: use_stderr = FALSE; use_syslog = FALSE; break; case 1: /* errfp, unbuffered */ use_stderr = TRUE; use_syslog = FALSE; break; #ifdef HAVE_SYSLOG case -1: /* syslogd */ use_stderr = FALSE; use_syslog = TRUE; break; #endif /* HAVE_SYSLOG */ } } /* Build an error message by appending MESSAGE, which is a printf-style format string with optional args, to the existing error message (which may be empty.) The completed error message is finally printed (and reset to empty) by calling error_complete(). If an intervening call to report() occurs when a partially constructed message exists, then, in an attempt to keep the messages in their proper sequence, the partial message will be printed as-is (with a trailing newline) before report() prints its message. */ /* VARARGS */ void #ifdef HAVE_STDARG_H report_build (FILE *errfp, const char *message, ...) #else report_build (FILE *errfp, message, va_alist) const char *message; va_dcl #endif { #ifdef VA_START va_list args; int n; #endif /* Make an initial guess for the size of any single message fragment. */ if (partial_message_size == 0) { partial_message_size_used = 0; partial_message_size = 2048; partial_message = MALLOC (partial_message_size); } else if (partial_message_size - partial_message_size_used < 1024) { partial_message_size += 2048; partial_message = REALLOC (partial_message, partial_message_size); } #if defined(VA_START) VA_START (args, message); #if HAVE_VSNPRINTF || _LIBC for ( ; ; ) { n = vsnprintf (partial_message + partial_message_size_used, partial_message_size - partial_message_size_used, message, args); if (n < partial_message_size - partial_message_size_used) { partial_message_size_used += n; break; } partial_message_size += 2048; partial_message = REALLOC (partial_message, partial_message_size); } #else vsprintf (partial_message + partial_message_size_used, message, args); partial_message_size_used += strlen(partial_message+partial_message_size_used); /* Attempt to catch memory overwrites... */ if (partial_message_size_used >= partial_message_size) { partial_message_size_used = 0; report (stderr, _("partial error message buffer overflow")); } #endif va_end (args); #else #if HAVE_SNPRINTF for ( ; ; ) { n = snprintf (partial_message + partial_message_size_used, partial_message_size - partial_message_size_used, message, a1, a2, a3, a4, a5, a6, a7, a8); if (n < partial_message_size - partial_message_size_used) { partial_message_size_used += n; break; } partial_message_size += 2048; partial_message = REALLOC (partial_message, partial_message_size); } #else sprintf (partial_message + partial_message_size_used, message, a1, a2, a3, a4, a5, a6, a7, a8); /* Attempt to catch memory overwrites... */ if ((partial_message_size_used = strlen (partial_message)) >= partial_message_size) { partial_message_size_used = 0; report (stderr, _("partial error message buffer overflow")); } #endif #endif if (use_stderr && partial_message_size_used != 0) { partial_message_size_used = 0; fputs(partial_message, errfp); } } /* Complete an error message by appending MESSAGE, which is a printf-style format string with optional args, to the existing error message (which may be empty.) The completed error message is then printed (and reset to empty.) */ /* VARARGS */ void #ifdef HAVE_STDARG_H report_complete (FILE *errfp, const char *message, ...) #else report_complete (FILE *errfp, message, va_alist) const char *message; va_dcl #endif { #ifdef VA_START va_list args; int n; #endif /* Make an initial guess for the size of any single message fragment. */ if (partial_message_size == 0) { partial_message_size_used = 0; partial_message_size = 2048; partial_message = MALLOC (partial_message_size); } else if (partial_message_size - partial_message_size_used < 1024) { partial_message_size += 2048; partial_message = REALLOC (partial_message, partial_message_size); } #if defined(VA_START) VA_START (args, message); #if HAVE_VSNPRINTF || _LIBC for ( ; ; ) { n = vsnprintf (partial_message + partial_message_size_used, partial_message_size - partial_message_size_used, message, args); if (n < partial_message_size - partial_message_size_used) { partial_message_size_used += n; break; } partial_message_size += 2048; partial_message = REALLOC (partial_message, partial_message_size); } #else vsprintf (partial_message + partial_message_size_used, message, args); partial_message_size_used += strlen(partial_message+partial_message_size_used); /* Attempt to catch memory overwrites... */ if (partial_message_size_used >= partial_message_size) { partial_message_size_used = 0; report (stderr, _("partial error message buffer overflow")); } #endif va_end (args); #else #if HAVE_SNPRINTF for ( ; ; ) { n = snprintf (partial_message + partial_message_size_used, partial_message_size - partial_message_size_used, message, a1, a2, a3, a4, a5, a6, a7, a8); if (n < partial_message_size - partial_message_size_used) { partial_message_size_used += n; break; } partial_message_size += 2048; partial_message = REALLOC (partial_message, partial_message_size); } #else sprintf (partial_message + partial_message_size_used, message, a1, a2, a3, a4, a5, a6, a7, a8); /* Attempt to catch memory overwrites... */ if ((partial_message_size_used = strlen (partial_message)) >= partial_message_size) { partial_message_size_used = 0; report (stderr, _("partial error message buffer overflow")); } #endif #endif /* Finally... print it. */ partial_message_size_used = 0; if (use_stderr) { fputs(partial_message, errfp); fflush (errfp); ++error_message_count; } else report(errfp, "%s", partial_message); } /* Sometimes we want to have at most one error per line. This variable controls whether this mode is selected or not. */ int error_one_per_line; void #ifdef HAVE_STDARG_H report_at_line (FILE *errfp, int errnum, const char *file_name, unsigned int line_number, const char *message, ...) #else report_at_line (FILE *errfp, errnum, file_name, line_number, message, va_alist) int errnum; const char *file_name; unsigned int line_number; const char *message; va_dcl #endif { #ifdef VA_START va_list args; #endif if (error_one_per_line) { static const char *old_file_name; static unsigned int old_line_number; if (old_line_number == line_number && (file_name == old_file_name || !strcmp (old_file_name, file_name))) /* Simply return and print nothing. */ return; old_file_name = file_name; old_line_number = line_number; } if (error_print_progname) (*error_print_progname) (); else { fflush (errfp); if ( *message == '\n' ) { fputc( '\n', errfp ); ++message; } fprintf (errfp, "%s:", program_name); } if (file_name != NULL) fprintf (errfp, "%s:%d: ", file_name, line_number); #ifdef VA_START VA_START (args, message); # if HAVE_VPRINTF || _LIBC vfprintf (errfp, message, args); # else _doprnt (message, args, errfp); # endif va_end (args); #else fprintf (errfp, message, a1, a2, a3, a4, a5, a6, a7, a8); #endif ++error_message_count; if (errnum) fprintf (errfp, ": %s", strerror (errnum)); putc ('\n', errfp); fflush (errfp); }