aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/README
blob: 5eaa51e95b8f7ad38ad2b416e49dc10d3bff1211 (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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
These are scripts or configuration snippets to help you running
fetchmail in special situations.

Note: you're on your own using these -- the fetchmail team undertakes no
efforts in understanding them, they are just passing them along.
								--esr, ma

This file is currently unsorted. Use your pager's search function when
looking for the description of a particular file in this directory.  --ma

### 0*.html:
Messages from the archives of the old fetchmail-friends mailing list,
for off-line reading.

### maildaemon:
Larry Fahnoe wrote this for driving fetchmail from cron.  It may be useful if
you want to force a PPP link up and then poll for mail at specified times.
I have rearranged it slightly to make it easier to configure.

### novell:

Some mail from Dan Newcombe describing how to write a procmail rule that
will domainify Novell server names.

### login & logout:

These are intended to help if you typically have multiple logins active.
Here's the script composer's original README:

	Please find attached 2 files, ~/.bash_login & ~/.bash_logout
	What these do is try to keep track of WHO is the process/tty
	that ran fetchmail in daemon mode.  I tried to use the bash
	Variable PPID, but when using xterm the PPID is set to the
	xterm's pid not the bash shell's pid so....

	They have been lightly tested.

	Any comments...

 				Hth, JimL <babydr@nwrain.net>

Doug Carter <dougc@canus.com> suggests this instead:

Add the following to your login script. (.ie .bash_profile, .profile, etc)

LOGINS=`who | grep $USER | wc -l`
if [ $LOGINS = 1 ]; then
    /usr/bin/fetchmail > /dev/null 2>&1
fi

Then add the following to your logout script. (.ie .bash_logout, etc)

LOGINS=`who | grep $USER | wc -l`
if [ $LOGINS = 1 ]; then
    /usr/bin/fetchmail -q > /dev/null 2>&1
fi

### ip-up:

A note from James Stevens about using fetchmail in an ip-up script without
disabling timeouts.

### runfetchmail:

A shellscript front end for fetchmail that mails you various statistics on
the downloaded mail and the state of your folders.  A good example of what
you can do with your own front end.

### fetchspool:

If you find that the speed of forwarding to port 25 is limited by the
SMTP listener's speed, it may make sense to locally spool all the mail
first and feed it to sendmail after you hang up the network link.
This shellscript aims to do exactly that.  It would be smarter to
figure out why sendmail is slow, however.

### fetchsetup:

This is a shell script for creating a $HOME/.fetchmailrc file, it will ask
you some questions and based on your answers it will create a .fetchmailrc
file. fetchsetup is linux specific so it may not work on another operating
system.

### mailqueue.pl:

This script will connect to your ISP (if not already connected),
send any outgoing mail and retrieve any incoming mail.  If this
program made the connection, it will also break the connection
when it is done.  By Bill Adams, <bill@evil.inetarena.com>.  The
latest version is carried at <http://evil.inetarena.com/>.

### redhat_rc:

A fetchmail boot-time init file compatible with RedHat 5.1.  It leaves
fetchmail in background to get messages when you connect to your ISP.
The invoked fetchmail expects to find its configuration in
/etc/fetchmailrc, and must include the proper "interface" directive.

### debian_rc:

A fetchmail boot-time init file compatible with Debian.  It leaves
fetchmail in background to get messages when you connect to your ISP.
The invoked fetchmail expects to find its configuration in
/root/.fetchmailrc, and must include the proper "interface" directive.

Matthias Andree adds: note that current Debian packages (as of January
2007) ship with their own init files.

### start_dynamic_ppp:

An admittedly scratchy ip-up script that Ryan Murray wrote to cope with
dynamic PPP addressing.  Will need some customizing.

	http://www.inetarena.com/~badams/linux/programs/mailqueue.pl

### getfetchmail:

Here's a script that gets Eric's most recent fetchmail source rpm,
downloads it and (if the rpm's not broken) rebuilds it.

With fairly simple changes it can be used to download the latest i386 rpm
or tar.gz.

Those who are addicted to having the latest of everything could filter mail
from fetchmail announce through it and get new versions as they're
announced. However, if we all did that, Eric's ftp server might feel a
little stressed.

The script as written works on bash 2.  By John Summerfield
<summer@os2.ami.com.au>.

### zsh-completion:

These commands set up command completion for fetchmail under zsh.
Jay Kominek <jay.kominek@colorado.edu>.

### getmail/gotmail:

These scripts are front ends for fetchmail in daemon mode that can gather
log statistics and generate text or HTML reports.  See README.getmail for
details.  Scripts by Thomas Nesges <ThomaNesges@TNT-Computer.de>.

### fetchmaildistrib:

This script resolves the issue where the sysadmin polls for mail with fetchmail
only at set intervals, but where a user wishes to see his email right
away. The duplication in /etc/fetchmailrc and ~/.fetchmailrc files is
automated with this script; whenever /etc/fetchmailrc is changed, this
script is run to distribute the stuff into all user's ~/.fetchmailrc
files.

### multidrop:

Martijn Lievaart's sendmail hacks to make multidrop reliable.

### domino:

Gustavo Chaves <gustavo@cpqd.com.br> wrote this script to deal with 
the boundary-mismatch bug in Domino (see FAQ item X5).  If you use
this with --mda, the broken boundaries will be fixed and the result
passed to procmail.

### toprocmail:

John Lim Eng Hooi <jleh@mail.com> wrote this script, yet another 
mda plugin, to be used with fetchmail in foreground mode.  It displays
some header lines to stdout in color, passing them (and the rest of the
message content) to procmail.

### preauth-harness:

Emmanuel Dreyfus's Perl test script for exercising IMAP PREAUTH
connections.  You'll have to patch in your username and password.

### sm-hybrid:

Peter 'Rattacresh' Backes sent this patch to improve the behavior of 
sendmail 8.11.0 with multidrop.

### fetchmailnochda.pl

Watchdog script to check whether fetchmail is working in daemon mode.

### mold-remover.py

A short python script to remove old read mail from a pop3 mailserver.
Dovetails with fetchmail with keep option.  Run it as a cron job.

### PopDel.py

PopDel stands for Pop Delete; this program deletes selected email from a
pop mail server. (By Richard Harris, improved by Joshua Crawford.)

### fetchmail.logrotate (added 2007-01-14, --ma)

A logrotate configuration file developped by Daniel Leidert for Debian,
when he wanted to use /var/log/fetchmail instead of the usual syslog.
It probably needs to be adjusted for use on other systems.

### delete-later (added 2007-03-17, --ma)

A MySQL/Tcl/Expect-based client-side script to remove messages at a
certain age.  See delete-later.README for details.
(By Carsten Ralle, Yoo GmbH, Germany.)

### gai (added 2013-02-03, --ma)

A trivial getaddrinfo() program to check the getaddrinfo() call from the
system, as a research tool for the fetchmail developers.
88; font-weight: bold } /* Keyword.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
/*
 * uid.c -- UIDL handling for POP3 servers without LAST
 *
 * For license terms, see the file COPYING in this directory.
 */

#include "config.h"

#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <limits.h>
#if defined(STDC_HEADERS)
#include <stdlib.h>
#include <string.h>
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif

#include "fetchmail.h"
#include "i18n.h"

/*
 * Machinery for handling UID lists live here.  This is mainly to support
 * RFC1725-conformant POP3 servers without a LAST command, but may also be
 * useful for making the IMAP4 querying logic UID-oriented, if a future
 * revision of IMAP forces me to.
 *
 * These functions are also used by the rest of the code to maintain
 * string lists.
 *
 * Here's the theory:
 *
 * At start of a query, we have a (possibly empty) list of UIDs to be
 * considered seen in `oldsaved'.  These are messages that were left in
 * the mailbox and *not deleted* on previous queries (we don't need to
 * remember the UIDs of deleted messages because ... well, they're gone!)
 * This list is initially set up by initialize_saved_list() from the
 * .fetchids file.
 *
 * Early in the query, during the execution of the protocol-specific 
 * getrange code, the driver expects that the host's `newsaved' member
 * will be filled with a list of UIDs and message numbers representing
 * the mailbox state.  If this list is empty, the server did
 * not respond to the request for a UID listing.
 *
 * Each time a message is fetched, we can check its UID against the
 * `oldsaved' list to see if it is old.
 *
 * Each time a message-id is seen, we mark it with MARK_SEEN.
 *
 * Each time a message is deleted, we mark its id UID_DELETED in the
 * `newsaved' member.  When we want to assert that an expunge has been
 * done on the server, we call expunge_uid() to register that all
 * deleted messages are gone by marking them UID_EXPUNGED.
 *
 * At the end of the query, the `newsaved' member becomes the
 * `oldsaved' list.  The old `oldsaved' list is freed.
 *
 * At the end of the fetchmail run, seen and non-EXPUNGED members of all
 * current `oldsaved' lists are flushed out to the .fetchids file to
 * be picked up by the next run.  If there are no un-expunged
 * messages, the file is deleted.
 *
 * Note: some comparisons (those used for DNS address lists) are caseblind!  
 */

/* UIDs associated with un-queried hosts */
static struct idlist *scratchlist;

#ifdef POP3_ENABLE
void initialize_saved_lists(struct query *hostlist, const char *idfile)
/* read file of saved IDs and attach to each host */
{
    struct stat statbuf;
    FILE	*tmpfp;
    struct query *ctl;

    /* make sure lists are initially empty */
    for (ctl = hostlist; ctl; ctl = ctl->next)
	ctl->skipped = ctl->oldsaved = ctl->newsaved = (struct idlist *)NULL;

    errno = 0;

    /*
     * Croak if the uidl directory does not exist.
     * This probably means an NFS mount failed and we can't
     * see a uidl file that ought to be there.
     * Question: is this a portable check? It's not clear
     * that all implementations of lstat() will return ENOTDIR
     * rather than plain ENOENT in this case...
     */
   if (lstat(idfile, &statbuf) < 0) {
     if (errno == ENOTDIR) 
    {
      report(stderr, GT_("lstat: %s: %s\n"), idfile, strerror(errno));
      exit(PS_IOERR);
    }
   }

    /* let's get stored message UIDs from previous queries */
    if ((tmpfp = fopen(idfile, "r")) != (FILE *)NULL)
    {
	char buf[POPBUFSIZE+1];
	char *host = NULL;	/* pacify -Wall */
	char *user;
	char *id;
	char *atsign;	/* temp pointer used in parsing user and host */
	char *delimp1;
	char saveddelim1;
	char *delimp2;
	char saveddelim2 = '\0';	/* pacify -Wall */

	while (fgets(buf, POPBUFSIZE, tmpfp) != (char *)NULL)
	{
	    /*
	     * At this point, we assume the bug has two fields -- a user@host 
	     * part, and an ID part. Either field may contain spurious @ signs.
	     * The previous version of this code presumed one could split at 
	     * the rightmost '@'.  This is not correct, as InterMail puts an 
	     * '@' in the UIDL.
	     */
	  
	    /* first, skip leading spaces */
	    user = buf + strspn(buf, " \t");

	    /*
	     * First, we split the buf into a userhost part and an id
	     * part ... but id doesn't necessarily start with a '<',
	     * espescially if the POP server returns an X-UIDL header
	     * instead of a Message-ID, as GMX's (www.gmx.net) POP3
	     * StreamProxy V1.0 does.
	     */
	    if ((id = strchr(user, ' ')) != NULL )
	    {

	      /*
	       * this is one other trick. The userhost part 
	       * may contain ' ' in the user part, at least in
	       * the lotus notes case.
	       * So we start looking for the '@' after which the
	       * host will follow with the ' ' seperator finaly id.
	       */
	        delimp1 = strchr(user, '@');
	        id = strchr(delimp1,' ');
	        for (delimp1 = id; delimp1 >= user; delimp1--)
		    if ((*delimp1 != ' ') && (*delimp1 != '\t'))
			break;

		/* 
		 * It should be safe to assume that id starts after
		 * the " " - after all, we're writing the " "
		 * ourselves in write_saved_lists() :-)
		 */
		id = id + strspn(id, " ");

		delimp1++; /* but what if there is only white space ?!? */
	  	saveddelim1 = *delimp1;	/* save char after token */
		*delimp1 = '\0';		/* delimit token with \0 */
		if (id != NULL) 
		{
		    /* now remove trailing white space chars from id */
		    if ((delimp2 = strpbrk(id, " \t\n")) != NULL ) {
			saveddelim2 = *delimp2;
			*delimp2 = '\0';
		    }
		    atsign = strrchr(user, '@');
		    if (atsign) {
			*atsign = '\0';
			host = atsign + 1;

		    }
		    for (ctl = hostlist; ctl; ctl = ctl->next) {
			if (strcasecmp(host, ctl->server.queryname) == 0
			    && strcasecmp(user, ctl->remotename) == 0) {
	
			    save_str(&ctl->oldsaved, id, UID_SEEN);
			    break;
			}
		    }
		    /* 
		     * If it's not in a host we're querying,
		     * save it anyway.  Otherwise we'd lose UIDL
		     * information any time we queried an explicit
		     * subset of hosts.
		     */
		    if (ctl == (struct query *)NULL) {
				/* restore string */
			*delimp1 = saveddelim1;
			*atsign = '@';
			if (delimp2 != NULL) {
			    *delimp2 = saveddelim2;
			}
			save_str(&scratchlist, buf, UID_SEEN);
		    }
		}
	    }
	}
	fclose(tmpfp);	/* not checking should be safe, mode was "r" */
    }

    if (outlevel >= O_DEBUG)
    {
	struct idlist	*idp;
	int uidlcount = 0;

	for (ctl = hostlist; ctl; ctl = ctl->next)
	    if (ctl->server.uidl)
	    {
		report_build(stdout, GT_("Old UID list from %s:"), 
			     ctl->server.pollname);
		for (idp = ctl->oldsaved; idp; idp = idp->next)
		    report_build(stdout, " %s", idp->id);
		if (!idp)
		    report_build(stdout, GT_(" <empty>"));
		report_complete(stdout, "\n");
		uidlcount++;
	    }

	if (uidlcount)
	{
	    report_build(stdout, GT_("Scratch list of UIDs:"));
	    for (idp = scratchlist; idp; idp = idp->next)
		report_build(stdout, " %s", idp->id);
	    if (!idp)
		report_build(stdout, GT_(" <empty>"));
	    report_complete(stdout, "\n");
	}
    }
}
#endif /* POP3_ENABLE */

struct idlist *save_str(struct idlist **idl, const char *str, flag status)
/* save a number/UID pair on the given UID list */
{
    struct idlist **end;

    /* do it nonrecursively so the list is in the right order */
    for (end = idl; *end; end = &(*end)->next)
	continue;

    *end = (struct idlist *)xmalloc(sizeof(struct idlist));
    (*end)->val.status.mark = status;
    (*end)->id = str ? xstrdup(str) : (char *)NULL;
    (*end)->next = NULL;

    return(*end);
}

void free_str_list(struct idlist **idl)
/* free the given UID list */
{
    if (*idl == (struct idlist *)NULL)
	return;

    free_str_list(&(*idl)->next);
    free ((*idl)->id);
    free(*idl);
    *idl = (struct idlist *)NULL;
}

void save_str_pair(struct idlist **idl, const char *str1, const char *str2)
/* save an ID pair on the given list */
{
    struct idlist **end;

    /* do it nonrecursively so the list is in the right order */
    for (end = idl; *end; end = &(*end)->next)
	continue;

    *end = (struct idlist *)xmalloc(sizeof(struct idlist));
    (*end)->id = str1 ? xstrdup(str1) : (char *)NULL;
    if (str2)
	(*end)->val.id2 = xstrdup(str2);
    else
	(*end)->val.id2 = (char *)NULL;
    (*end)->next = (struct idlist *)NULL;
}

#ifdef __UNUSED__
void free_str_pair_list(struct idlist **idl)
/* free the given ID pair list */
{
    if (*idl == (struct idlist *)NULL)
	return;

    free_idpair_list(&(*idl)->next);
    free ((*idl)->id);
    free ((*idl)->val.id2);
    free(*idl);
    *idl = (struct idlist *)NULL;
}
#endif

int str_in_list(struct idlist **idl, const char *str, const flag caseblind)
/* is a given ID in the given list? (comparison may be caseblind) */
{
    if (*idl == (struct idlist *)NULL || str == (char *) NULL)
	return(0);
    else if (!caseblind && strcmp(str, (*idl)->id) == 0)
	return(1);
    else if (caseblind && strcasecmp(str, (*idl)->id) == 0)
	return(1);
    else
	return(str_in_list(&(*idl)->next, str, caseblind));
}

int str_nr_in_list( struct idlist **idl, const char *str )
  /* return the position of str in idl */
{
    int nr;
    struct idlist *walk;
    if ( !str )
        return -1;
    for( walk = *idl, nr = 0; walk; nr ++, walk = walk->next )
        if( strcmp( str, walk->id) == 0 )
	    return nr;
    return -1;
}

int str_nr_last_in_list( struct idlist **idl, const char *str)
/* return the last position of str in idl */
{
    int nr, ret = -1;
    struct idlist *walk;
    if ( !str )
        return -1;
    for( walk = *idl, nr = 0; walk; nr ++, walk = walk->next )
        if( strcmp( str, walk->id) == 0 )
	    ret = nr;
    return ret;
}

void str_set_mark( struct idlist **idl, const char *str, const flag val)
/* update the mark on an of an id to given value */
{
    int nr;
    struct idlist *walk;
    if (!str)
        return;
    for(walk = *idl, nr = 0; walk; nr ++, walk = walk->next)
        if (strcmp(str, walk->id) == 0)
	    walk->val.status.mark = val;
}

int count_list( struct idlist **idl)
/* count the number of elements in the list */
{
  if( !*idl )
    return 0;
  return 1 + count_list( &(*idl)->next );
}

char *str_from_nr_list(struct idlist **idl, int number)
/* return the number'th string in idl */
{
    if( !*idl  || number < 0)
        return 0;
    if( number == 0 )
        return (*idl)->id;
    return str_from_nr_list(&(*idl)->next, number-1);
}

    
char *str_find(struct idlist **idl, int number)
/* return the id of the given number in the given list. */
{
    if (*idl == (struct idlist *) 0)
	return((char *) 0);
    else if (number == (*idl)->val.status.num)
	return((*idl)->id);
    else
	return(str_find(&(*idl)->next, number));
}

char *idpair_find(struct idlist **idl, const char *id)
/* return the id of the given id in the given list (caseblind comparison) */
{
    if (*idl == (struct idlist *) 0)
	return((char *) 0);
    else if (strcasecmp(id, (*idl)->id) == 0)
	return((*idl)->val.id2 ? (*idl)->val.id2 : (*idl)->id);
    else
	return(idpair_find(&(*idl)->next, id));
}

int delete_str(struct idlist **idl, int num)
/* delete given message from given list */
{
    struct idlist	*idp;

    for (idp = *idl; idp; idp = idp->next)
	if (idp->val.status.num == num)
	{
	    idp->val.status.mark = UID_DELETED;
	    return(1);
	}
    return(0);
}

struct idlist *copy_str_list(struct idlist *idl)
/* copy the given UID list */
{
    struct idlist *newnode ;

    if (idl == (struct idlist *)NULL)
	return(NULL);
    else
    {
	newnode = (struct idlist *)xmalloc(sizeof(struct idlist));
	memcpy(newnode, idl, sizeof(struct idlist));
	newnode->next = copy_str_list(idl->next);
	return(newnode);
    }
}

void append_str_list(struct idlist **idl, struct idlist **nidl)
/* append nidl to idl (does not copy *) */
{
    if ((*nidl) == (struct idlist *)NULL || *nidl == *idl)
	return;
    else if ((*idl) == (struct idlist *)NULL)
	*idl = *nidl;
    else if ((*idl)->next == (struct idlist *)NULL)
	(*idl)->next = *nidl;
    else if ((*idl)->next != *nidl)
	append_str_list(&(*idl)->next, nidl);
}

#ifdef POP3_ENABLE
void expunge_uids(struct query *ctl)
/* assert that all UIDs marked deleted have actually been expunged */
{
    struct idlist *idl;

    for (idl = ctl->newsaved; idl; idl = idl->next)
	if (idl->val.status.mark == UID_DELETED)
	    idl->val.status.mark = UID_EXPUNGED;
}

void uid_swap_lists(struct query *ctl) 
/* finish a query */
{
    /* debugging code */
    if (ctl->server.uidl && outlevel >= O_DEBUG)
    {
	struct idlist *idp;

	report_build(stdout, GT_("New UID list from %s:"), ctl->server.pollname);
	for (idp = ctl->newsaved; idp; idp = idp->next)
	    report_build(stdout, " %s = %d", idp->id, idp->val.status.mark);
	if (!idp)
	    report_build(stdout, GT_(" <empty>"));
	report_complete(stdout, "\n");
    }

    /*
     * Don't swap UID lists unless we've actually seen UIDLs.
     * This is necessary in order to keep UIDL information
     * from being heedlessly deleted later on.
     *
     * Older versions of fetchmail did
     *
     *     free_str_list(&scratchlist);
     *
     * after swap.  This was wrong; we need to preserve the UIDL information
     * from unqueried hosts.  Unfortunately, not doing this means that
     * under some circumstances UIDLs can end up being stored forever --
     * specifically, if a user description is removed from .fetchmailrc
     * with UIDLs from that account in .fetchids, there is no way for
     * them to ever get garbage-collected.
     */
    if (ctl->newsaved)
    {
	/* old state of mailbox may now be irrelevant */
	if (outlevel >= O_DEBUG)
	    report(stdout, GT_("swapping UID lists\n"));
	free_str_list(&ctl->oldsaved);
	ctl->oldsaved = ctl->newsaved;
	ctl->newsaved = (struct idlist *) NULL;
    }
    else if (outlevel >= O_DEBUG)
	report(stdout, GT_("not swapping UID lists, no UIDs seen this query\n"));
}

void write_saved_lists(struct query *hostlist, const char *idfile)
/* perform end-of-run write of seen-messages list */
{
    int		idcount;
    FILE	*tmpfp;
    struct query *ctl;
    struct idlist *idp;

    /* if all lists are empty, nuke the file */
    idcount = 0;
    for (ctl = hostlist; ctl; ctl = ctl->next) {
        for (idp = ctl->oldsaved; idp; idp = idp->next)
            if (idp->val.status.mark == UID_SEEN
	    			|| idp->val.status.mark == UID_DELETED)
                idcount++;
    }

    /* either nuke the file or write updated last-seen IDs */
    if (!idcount && !scratchlist)
    {
	if (outlevel >= O_DEBUG)
	    report(stdout, GT_("Deleting fetchids file.\n"));
	unlink(idfile);
    }
    else
    {
	if (outlevel >= O_DEBUG)
	    report(stdout, GT_("Writing fetchids file.\n"));
	if ((tmpfp = fopen(idfile, "w")) != (FILE *)NULL) {
	    for (ctl = hostlist; ctl; ctl = ctl->next) {
		for (idp = ctl->oldsaved; idp; idp = idp->next)
		    if (idp->val.status.mark == UID_SEEN
				|| idp->val.status.mark == UID_DELETED)
			fprintf(tmpfp, "%s@%s %s\n", 
			    ctl->remotename, ctl->server.queryname, idp->id);
	    }
	    for (idp = scratchlist; idp; idp = idp->next)
		fputs(idp->id, tmpfp);
	    fclose(tmpfp);
	}
    }
}
#endif /* POP3_ENABLE */

/* uid.c ends here */