Mix/Src/rem2.c

/* Mixmaster version 3  --  (C) 1999 Anonymizer Inc.

   Mixmaster may be redistributed and modified under certain conditions.
   This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   ANY KIND, either express or implied. See the file COPYRIGHT for
   details.

   Process Mixmaster remailer messages
   $Id: rem2.c,v 1.1 2001/10/31 08:19:53 rabbi Exp $ */


#include "mix3.h"
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef POSIX
#include <unistd.h>
#else
#include <io.h>
#endif
#ifndef _MSC
#include <dirent.h>
#endif
#include <assert.h>

int mix_dearmor(BUFFER *in, BUFFER *out)
{
  BUFFER *line, *md;
  int tempbuf = 0;
  int err = 0;

  line = buf_new();
  md = buf_new();

  if (in == out) {
    tempbuf = 1;
    out = buf_new();
  }
  do {
    err = buf_getline(in, line);
    if (err == -1)
      goto end;
  }
  while (!bufeq(line, begin_remailer));

  do {
    /* skip lines before message digest */
    if (buf_getline(in, md) == -1)
      break;
  } while (strlen(md->data) != 24);

  decode(in, out);

  err = buf_getline(in, line);
  if (err != 0 || !bufeq(line, end_remailer))
    err = -1;
  else {
    digest_md5(out, line);
    encode(line, 0);
    if (!buf_eq(md, line))
      err = -1;
    if (out->length != 20480)
      err = -1;
  }

end:
  if (err == -1)
    errlog(NOTICE, "Malformatted message.\n");

  if (tempbuf) {
    buf_move(in, out);
    buf_free(out);
  }
  buf_free(line);
  buf_free(md);
  return (err);
}

#ifdef USE_RSA

static int isnewid(BUFFER *id, long timestamp)
{
  FILE *f;
  char idstr[33], line[LINELEN];
  int ret = 1;
  long now, old = 0;
  LOCK *i = NULL;

  now = time(NULL);
  id_encode(id->data, idstr);

  if ((f = mix_openfile(IDLOG, "r+")) != NULL)
    fscanf(f, "%*s %ld", &old);
  else {
    if (IDEXP == 0) {
      if (timestamp > 0 && timestamp <= now - 7 * SECONDSPERDAY) {
        errlog(LOG, "Ignoring old message.\n");
        return (0);
      }
    } else {
      if ((f = mix_openfile(IDLOG, "w")) != NULL) {
        fprintf(f, "new %ld\n%s %ld\n", now, idstr, now);
        fclose(f);
        errlog(NOTICE, "Creating %s\n", IDLOG);
      } else {
        errlog(ERRORMSG, "Can't create %s\n", IDLOG);
      }
      return (1);
    }
  }

  if (now - old < 5 * SECONDSPERDAY)    /* never reject messages less than */
    old = now - 5 * SECONDSPERDAY;      /* 5 days old (== minimum IDEXP) */

  if (timestamp > 0 && timestamp <= old) {
    errlog(LOG, "Ignoring old message.\n");
    ret = 0;
    goto end;
  }
  i = lockfile(IDLOG);
  while (fgets(line, sizeof(line), f) != NULL) {
    if (strleft(line, idstr)) {
      errlog(LOG, "Ignoring redundant message.\n");
      ret = 0;
      goto end;
    }
  }
  fprintf(f, "%s %ld\n", idstr, now);
end:
  if (i)
    unlockfile(i);
  fclose(f);
  return (ret);
}

int mix2_decrypt(BUFFER *m)
     /* 0: ok  -1: error  -2: old message */
{
  int err = 0;
  int i;
  BUFFER *privkey;
  BUFFER *keyid;
  BUFFER *dec, *deskey;
  BUFFER *packetid, *mid, *digest, *addr, *temp, *iv, *ivvec;
  int type, packet = 0, numpackets = 0, timestamp = 0;
  BUFFER *body;
  BUFFER *header, *out;

  privkey = buf_new();
  keyid = buf_new();
  dec = buf_new();
  deskey = buf_new();
  packetid = buf_new();
  mid = buf_new();
  digest = buf_new();
  addr = buf_new();
  temp = buf_new();
  iv = buf_new();
  ivvec = buf_new();
  body = buf_new();
  header = buf_new();
  out = buf_new();

  buf_get(m, keyid, 16);
  err = db_getseckey(keyid->data, privkey);
  if (err == -1)
    goto end;
  buf_get(m, deskey, buf_getc(m));
  err = pk_decrypt(deskey, privkey);
  if (err == -1 || deskey->length != 24) {
    err = -1;
    errlog(NOTICE, "Cannot decrypt message.\n");
    goto end;
  }
  buf_get(m, iv, 8);
  buf_get(m, dec, 328);
  buf_crypt(dec, deskey, iv, DECRYPT);
  buf_get(dec, packetid, 16);
  buf_get(dec, deskey, 24);
  type = buf_getc(dec);
  switch (type) {
  case 0:
    buf_get(dec, ivvec, 152);
    buf_get(dec, addr, 80);
    break;
  case 1:
    buf_get(dec, mid, 16);
    buf_get(dec, iv, 8);
    break;
  case 2:
    packet = buf_getc(dec);
    numpackets = buf_getc(dec);
    buf_get(dec, mid, 16);
    buf_get(dec, iv, 8);
    break;
  default:
    errlog(WARNING, "Unknown message type.\n");
    err = -1;
    goto end;
  }
  if (dec->data[dec->ptr] == '0' && dec->data[dec->ptr + 1] == '0' &&
      dec->data[dec->ptr + 2] == '0' && dec->data[dec->ptr + 3] == '0' &&
      dec->data[dec->ptr + 4] == '\0') {
    dec->ptr += 5;
    timestamp = buf_geti_lo(dec);
  }
  buf_get(dec, digest, 16);

  dec->length = dec->ptr - 16;  /* ignore digest */
  dec->ptr = dec->length;

  if (!isdigest_md5(dec, digest)) {
    errlog(NOTICE, "Message digest does not match.\n");
    err = -1;
    goto end;
  }
  if (!isnewid(packetid, timestamp * SECONDSPERDAY)) {
    err = -2;
    goto end;
  }
  buf_append(body, m->data + 20 * 512, 10240);

  switch (type) {
  case 0:
    buf_chop(addr);
    buf_cat(out, addr);
    buf_nl(out);
    for (i = 0; i < 19; i++) {
      buf_reset(header);
      buf_append(header, m->data + (i + 1) * 512, 512);
      buf_reset(iv);
      buf_append(iv, ivvec->data + i * 8, 8);
      buf_crypt(header, deskey, iv, DECRYPT);
      buf_cat(out, header);
    }
    buf_reset(header);
    buf_pad(header, 512);
    buf_cat(out, header);
    buf_reset(iv);
    buf_append(iv, ivvec->data + 144, 8);
    buf_crypt(body, deskey, iv, DECRYPT);
    buf_cat(out, body);
    mix_pool(out, INTERMEDIATE, -1);
    break;
  case 1:
    buf_crypt(body, deskey, iv, DECRYPT);
    err = v2body_setlen(body);
    if (err == -1)
      goto end;
    assert(body->ptr == 4);
    v2body(body);
    break;
  case 2:
    buf_crypt(body, deskey, iv, DECRYPT);
    v2partial(body, mid, packet, numpackets);
    break;
  }
end:
  buf_free(privkey);
  buf_free(keyid);
  buf_free(dec);
  buf_free(deskey);
  buf_free(packetid);
  buf_free(mid);
  buf_free(digest);
  buf_free(addr);
  buf_free(temp);
  buf_free(iv);
  buf_free(ivvec);
  buf_free(body);
  buf_free(header);
  buf_free(out);

  return (err);
}

int v2body_setlen(BUFFER *body)
{
  long length;

  length = buf_getl_lo(body);
  if (length < 0 || length > body->length)
    return (-1);
  body->length = length + 4;
  return (0);
}

int v2body(BUFFER *body)
{
  int i, n;
  BUFFER *to, *newsgroups;
  BUFFER *temp, *out;
  BUFFER *line;
  int type = MSG_MAIL;
  int subject = 0;

  line = buf_new();
  to = buf_new();
  newsgroups = buf_new();
  temp = buf_new();
  out = buf_new();

  n = buf_getc(body);
  for (i = 0; i < n; i++) {
    buf_get(body, line, 80);
    buf_chop(line);
    if (bufileft(line, "null:"))
      goto end;
    if (bufileft(line, "post:")) {
      type = MSG_POST;
      if (line->length > 5) {
        int j = 5;

        while (j < line->length && isspace(line->data[j]))
          j++;
        if (newsgroups->length > 0)
          buf_appends(newsgroups, ",");
        buf_append(newsgroups, line->data + j, line->length - j);
      }
    } else {
      if (to->length > 0)
        buf_appends(to, ",");
      buf_cat(to, line);
    }
  }
  if (to->length > 0) {
    buf_appends(out, "To: ");
    buf_cat(out, to);
    buf_nl(out);
  }
  if (newsgroups->length > 0) {
    buf_appends(out, "Newsgroups: ");
    buf_cat(out, newsgroups);
    buf_nl(out);
  }
  n = buf_getc(body);
  for (i = 0; i < n; i++) {
    buf_get(body, line, 80);
    buf_chop(line);
    if (bufileft(line, "Subject:"))
      subject = 1;
    buf_cat(out, line);
    buf_nl(out);
  }

  buf_rest(temp, body);
  buf_uncompress(temp);
  buf_set(body, temp);
  buf_reset(temp);

  if (buf_lookahead(body, line) == 0 && isline(line, HASHMARK)) {
    buf_getline(body, line);
    while (buf_getline(body, line) == 0) {
      if (bufileft(line, "subject:"))
        subject = 1;
      buf_cat(out, line);
      buf_nl(out);
    }
  }
  if (type == MSG_POST && !subject)
    buf_appends(out, "Subject: (no subject)\n");

  buf_nl(out);
  buf_rest(out, body);
  buf_reset(body);
  mix_pool(out, type, -1);

end:
  buf_free(line);
  buf_free(to);
  buf_free(newsgroups);
  buf_free(temp);
  buf_free(out);
  return (0);
}

int v2_merge(BUFFER *mid)
{
  char fname[PATHMAX], line[LINELEN];
  BUFFER *temp, *msg;
  FILE *l, *f;
  int i, numpackets;
  struct stat sb;
  long d;
  int n;
  int err = -1;

  temp = buf_new();
  msg = buf_new();
  pool_packetfile(fname, mid, 0);
  l = fopen(fname, "a+");
  if (l != NULL)
    lock(l);

  pool_packetfile(fname, mid, 1);
  f = fopen(fname, "rb");
  if (f == NULL)
    goto end;
  fscanf(f, "%32s %ld %d %d\n", line, &d, &i, &numpackets);
  fclose(f);

  /* do we have all packets? */
  for (i = 1; i <= numpackets; i++) {
    pool_packetfile(fname, mid, i);
    if (stat(fname, &sb) != 0)
      goto end;
  }
  errlog(LOG, "Reassembling multipart message.\n");
  for (i = 1; i <= numpackets; i++) {
    pool_packetfile(fname, mid, i);
    f = fopen(fname, "rb");
    if (f == NULL)
      goto end;
    fscanf(f, "%32s %ld %d %d\n", line, &d, &n, &n);
    buf_clear(temp);
    buf_read(temp, f);
    v2body_setlen(temp);
    buf_append(msg, temp->data + 4, temp->length - 4);
    fclose(f);
    unlink(fname);
  }
  err = v2body(msg);

end:
  if (l != NULL)
    fclose(l);
  pool_packetfile(fname, mid, 0);
  unlink(fname);
  buf_free(temp);
  buf_free(msg);
  return (err);
}

int v2partial(BUFFER *m, BUFFER *mid, int packet, int numpackets)
{
  char fname[PATHMAX], idstr[33];
  FILE *f;
  int err = 1;

  pool_packetfile(fname, mid, packet);
  f = fopen(fname, "wb");
  if (f == NULL) {
    err = -1;
    goto end;
  }
  id_encode(mid->data, idstr);
  fprintf(f, "%s %ld %d %d\n", idstr, (long) time(NULL), packet,
          numpackets);
  buf_write(m, f);
  buf_reset(m);
  fclose(f);
  v2_merge(mid);
end:
  return (err);
}

#else

int mix2_decrypt(BUFFER *m)
{
  return (-1);
}
#endif
1	/* Mixmaster version 3 -- (C) 1999 Anonymizer Inc.
2
3	Mixmaster may be redistributed and modified under certain conditions.
4	This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
5	ANY KIND, either express or implied. See the file COPYRIGHT for
6	details.
7
8	Process Mixmaster remailer messages
9	$Id: rem2.c,v 1.1 2001/10/31 08:19:53 rabbi Exp $ */
10
11
12	#include "mix3.h"
13	#include <string.h>
14	#include <time.h>
15	#include <ctype.h>
16	#include <sys/types.h>
17	#include <sys/stat.h>
18	#ifdef POSIX
19	#include <unistd.h>
20	#else
21	#include <io.h>
22	#endif
23	#ifndef _MSC
24	#include <dirent.h>
25	#endif
26	#include <assert.h>
27
28	int mix_dearmor(BUFFER in, BUFFER out)
29	{
30	BUFFER line, md;
31	int tempbuf = 0;
32	int err = 0;
33
34	line = buf_new();
35	md = buf_new();
36
37	if (in == out) {
38	tempbuf = 1;
39	out = buf_new();
40	}
41	do {
42	err = buf_getline(in, line);
43	if (err == -1)
44	goto end;
45	}
46	while (!bufeq(line, begin_remailer));
47
48	do {
49	/* skip lines before message digest */
50	if (buf_getline(in, md) == -1)
51	break;
52	} while (strlen(md->data) != 24);
53
54	decode(in, out);
55
56	err = buf_getline(in, line);
57	if (err != 0 \|\| !bufeq(line, end_remailer))
58	err = -1;
59	else {
60	digest_md5(out, line);
61	encode(line, 0);
62	if (!buf_eq(md, line))
63	err = -1;
64	if (out->length != 20480)
65	err = -1;
66	}
67
68	end:
69	if (err == -1)
70	errlog(NOTICE, "Malformatted message.\n");
71
72	if (tempbuf) {
73	buf_move(in, out);
74	buf_free(out);
75	}
76	buf_free(line);
77	buf_free(md);
78	return (err);
79	}
80
81	#ifdef USE_RSA
82
83	static int isnewid(BUFFER *id, long timestamp)
84	{
85	FILE *f;
86	char idstr[33], line[LINELEN];
87	int ret = 1;
88	long now, old = 0;
89	LOCK *i = NULL;
90
91	now = time(NULL);
92	id_encode(id->data, idstr);
93
94	if ((f = mix_openfile(IDLOG, "r+")) != NULL)
95	fscanf(f, "%*s %ld", &old);
96	else {
97	if (IDEXP == 0) {
98	if (timestamp > 0 && timestamp <= now - 7 * SECONDSPERDAY) {
99	errlog(LOG, "Ignoring old message.\n");
100	return (0);
101	}
102	} else {
103	if ((f = mix_openfile(IDLOG, "w")) != NULL) {
104	fprintf(f, "new %ld\n%s %ld\n", now, idstr, now);
105	fclose(f);
106	errlog(NOTICE, "Creating %s\n", IDLOG);
107	} else {
108	errlog(ERRORMSG, "Can't create %s\n", IDLOG);
109	}
110	return (1);
111	}
112	}
113
114	if (now - old < 5 * SECONDSPERDAY) /* never reject messages less than */
115	old = now - 5 * SECONDSPERDAY; /* 5 days old (== minimum IDEXP) */
116
117	if (timestamp > 0 && timestamp <= old) {
118	errlog(LOG, "Ignoring old message.\n");
119	ret = 0;
120	goto end;
121	}
122	i = lockfile(IDLOG);
123	while (fgets(line, sizeof(line), f) != NULL) {
124	if (strleft(line, idstr)) {
125	errlog(LOG, "Ignoring redundant message.\n");
126	ret = 0;
127	goto end;
128	}
129	}
130	fprintf(f, "%s %ld\n", idstr, now);
131	end:
132	if (i)
133	unlockfile(i);
134	fclose(f);
135	return (ret);
136	}
137
138	int mix2_decrypt(BUFFER *m)
139	/* 0: ok -1: error -2: old message */
140	{
141	int err = 0;
142	int i;
143	BUFFER *privkey;
144	BUFFER *keyid;
145	BUFFER dec, deskey;
146	BUFFER packetid, mid, digest, addr, temp, iv, *ivvec;
147	int type, packet = 0, numpackets = 0, timestamp = 0;
148	BUFFER *body;
149	BUFFER header, out;
150
151	privkey = buf_new();
152	keyid = buf_new();
153	dec = buf_new();
154	deskey = buf_new();
155	packetid = buf_new();
156	mid = buf_new();
157	digest = buf_new();
158	addr = buf_new();
159	temp = buf_new();
160	iv = buf_new();
161	ivvec = buf_new();
162	body = buf_new();
163	header = buf_new();
164	out = buf_new();
165
166	buf_get(m, keyid, 16);
167	err = db_getseckey(keyid->data, privkey);
168	if (err == -1)
169	goto end;
170	buf_get(m, deskey, buf_getc(m));
171	err = pk_decrypt(deskey, privkey);
172	if (err == -1 \|\| deskey->length != 24) {
173	err = -1;
174	errlog(NOTICE, "Cannot decrypt message.\n");
175	goto end;
176	}
177	buf_get(m, iv, 8);
178	buf_get(m, dec, 328);
179	buf_crypt(dec, deskey, iv, DECRYPT);
180	buf_get(dec, packetid, 16);
181	buf_get(dec, deskey, 24);
182	type = buf_getc(dec);
183	switch (type) {
184	case 0:
185	buf_get(dec, ivvec, 152);
186	buf_get(dec, addr, 80);
187	break;
188	case 1:
189	buf_get(dec, mid, 16);
190	buf_get(dec, iv, 8);
191	break;
192	case 2:
193	packet = buf_getc(dec);
194	numpackets = buf_getc(dec);
195	buf_get(dec, mid, 16);
196	buf_get(dec, iv, 8);
197	break;
198	default:
199	errlog(WARNING, "Unknown message type.\n");
200	err = -1;
201	goto end;
202	}
203	if (dec->data[dec->ptr] == '0' && dec->data[dec->ptr + 1] == '0' &&
204	dec->data[dec->ptr + 2] == '0' && dec->data[dec->ptr + 3] == '0' &&
205	dec->data[dec->ptr + 4] == '\0') {
206	dec->ptr += 5;
207	timestamp = buf_geti_lo(dec);
208	}
209	buf_get(dec, digest, 16);
210
211	dec->length = dec->ptr - 16; /* ignore digest */
212	dec->ptr = dec->length;
213
214	if (!isdigest_md5(dec, digest)) {
215	errlog(NOTICE, "Message digest does not match.\n");
216	err = -1;
217	goto end;
218	}
219	if (!isnewid(packetid, timestamp * SECONDSPERDAY)) {
220	err = -2;
221	goto end;
222	}
223	buf_append(body, m->data + 20 * 512, 10240);
224
225	switch (type) {
226	case 0:
227	buf_chop(addr);
228	buf_cat(out, addr);
229	buf_nl(out);
230	for (i = 0; i < 19; i++) {
231	buf_reset(header);
232	buf_append(header, m->data + (i + 1) * 512, 512);
233	buf_reset(iv);
234	buf_append(iv, ivvec->data + i * 8, 8);
235	buf_crypt(header, deskey, iv, DECRYPT);
236	buf_cat(out, header);
237	}
238	buf_reset(header);
239	buf_pad(header, 512);
240	buf_cat(out, header);
241	buf_reset(iv);
242	buf_append(iv, ivvec->data + 144, 8);
243	buf_crypt(body, deskey, iv, DECRYPT);
244	buf_cat(out, body);
245	mix_pool(out, INTERMEDIATE, -1);
246	break;
247	case 1:
248	buf_crypt(body, deskey, iv, DECRYPT);
249	err = v2body_setlen(body);
250	if (err == -1)
251	goto end;
252	assert(body->ptr == 4);
253	v2body(body);
254	break;
255	case 2:
256	buf_crypt(body, deskey, iv, DECRYPT);
257	v2partial(body, mid, packet, numpackets);
258	break;
259	}
260	end:
261	buf_free(privkey);
262	buf_free(keyid);
263	buf_free(dec);
264	buf_free(deskey);
265	buf_free(packetid);
266	buf_free(mid);
267	buf_free(digest);
268	buf_free(addr);
269	buf_free(temp);
270	buf_free(iv);
271	buf_free(ivvec);
272	buf_free(body);
273	buf_free(header);
274	buf_free(out);
275
276	return (err);
277	}
278
279	int v2body_setlen(BUFFER *body)
280	{
281	long length;
282
283	length = buf_getl_lo(body);
284	if (length < 0 \|\| length > body->length)
285	return (-1);
286	body->length = length + 4;
287	return (0);
288	}
289
290	int v2body(BUFFER *body)
291	{
292	int i, n;
293	BUFFER to, newsgroups;
294	BUFFER temp, out;
295	BUFFER *line;
296	int type = MSG_MAIL;
297	int subject = 0;
298
299	line = buf_new();
300	to = buf_new();
301	newsgroups = buf_new();
302	temp = buf_new();
303	out = buf_new();
304
305	n = buf_getc(body);
306	for (i = 0; i < n; i++) {
307	buf_get(body, line, 80);
308	buf_chop(line);
309	if (bufileft(line, "null:"))
310	goto end;
311	if (bufileft(line, "post:")) {
312	type = MSG_POST;
313	if (line->length > 5) {
314	int j = 5;
315
316	while (j < line->length && isspace(line->data[j]))
317	j++;
318	if (newsgroups->length > 0)
319	buf_appends(newsgroups, ",");
320	buf_append(newsgroups, line->data + j, line->length - j);
321	}
322	} else {
323	if (to->length > 0)
324	buf_appends(to, ",");
325	buf_cat(to, line);
326	}
327	}
328	if (to->length > 0) {
329	buf_appends(out, "To: ");
330	buf_cat(out, to);
331	buf_nl(out);
332	}
333	if (newsgroups->length > 0) {
334	buf_appends(out, "Newsgroups: ");
335	buf_cat(out, newsgroups);
336	buf_nl(out);
337	}
338	n = buf_getc(body);
339	for (i = 0; i < n; i++) {
340	buf_get(body, line, 80);
341	buf_chop(line);
342	if (bufileft(line, "Subject:"))
343	subject = 1;
344	buf_cat(out, line);
345	buf_nl(out);
346	}
347
348	buf_rest(temp, body);
349	buf_uncompress(temp);
350	buf_set(body, temp);
351	buf_reset(temp);
352
353	if (buf_lookahead(body, line) == 0 && isline(line, HASHMARK)) {
354	buf_getline(body, line);
355	while (buf_getline(body, line) == 0) {
356	if (bufileft(line, "subject:"))
357	subject = 1;
358	buf_cat(out, line);
359	buf_nl(out);
360	}
361	}
362	if (type == MSG_POST && !subject)
363	buf_appends(out, "Subject: (no subject)\n");
364
365	buf_nl(out);
366	buf_rest(out, body);
367	buf_reset(body);
368	mix_pool(out, type, -1);
369
370	end:
371	buf_free(line);
372	buf_free(to);
373	buf_free(newsgroups);
374	buf_free(temp);
375	buf_free(out);
376	return (0);
377	}
378
379	int v2_merge(BUFFER *mid)
380	{
381	char fname[PATHMAX], line[LINELEN];
382	BUFFER temp, msg;
383	FILE l, f;
384	int i, numpackets;
385	struct stat sb;
386	long d;
387	int n;
388	int err = -1;
389
390	temp = buf_new();
391	msg = buf_new();
392	pool_packetfile(fname, mid, 0);
393	l = fopen(fname, "a+");
394	if (l != NULL)
395	lock(l);
396
397	pool_packetfile(fname, mid, 1);
398	f = fopen(fname, "rb");
399	if (f == NULL)
400	goto end;
401	fscanf(f, "%32s %ld %d %d\n", line, &d, &i, &numpackets);
402	fclose(f);
403
404	/* do we have all packets? */
405	for (i = 1; i <= numpackets; i++) {
406	pool_packetfile(fname, mid, i);
407	if (stat(fname, &sb) != 0)
408	goto end;
409	}
410	errlog(LOG, "Reassembling multipart message.\n");
411	for (i = 1; i <= numpackets; i++) {
412	pool_packetfile(fname, mid, i);
413	f = fopen(fname, "rb");
414	if (f == NULL)
415	goto end;
416	fscanf(f, "%32s %ld %d %d\n", line, &d, &n, &n);
417	buf_clear(temp);
418	buf_read(temp, f);
419	v2body_setlen(temp);
420	buf_append(msg, temp->data + 4, temp->length - 4);
421	fclose(f);
422	unlink(fname);
423	}
424	err = v2body(msg);
425
426	end:
427	if (l != NULL)
428	fclose(l);
429	pool_packetfile(fname, mid, 0);
430	unlink(fname);
431	buf_free(temp);
432	buf_free(msg);
433	return (err);
434	}
435
436	int v2partial(BUFFER m, BUFFER mid, int packet, int numpackets)
437	{
438	char fname[PATHMAX], idstr[33];
439	FILE *f;
440	int err = 1;
441
442	pool_packetfile(fname, mid, packet);
443	f = fopen(fname, "wb");
444	if (f == NULL) {
445	err = -1;
446	goto end;
447	}
448	id_encode(mid->data, idstr);
449	fprintf(f, "%s %ld %d %d\n", idstr, (long) time(NULL), packet,
450	numpackets);
451	buf_write(m, f);
452	buf_reset(m);
453	fclose(f);
454	v2_merge(mid);
455	end:
456	return (err);
457	}
458
459	#else
460
461	int mix2_decrypt(BUFFER *m)
462	{
463	return (-1);
464	}
465	#endif