Mix/Src/mix3.h

/* 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.

   Function prototypes
   $Id: mix3.h,v 1.8 2002/07/29 23:52:00 weaselp Exp $ */


#ifndef _MIX3_H
#define _MIX3_H
#define COPYRIGHT "Copyright Anonymizer Inc."

#include "config.h"
#include "mix.h"

#ifdef WIN32
#ifndef USE_SOCK
#define _WINSOCKAPI_            /* don't include winsock */
#endif
#include <windows.h>
#ifdef _MSC
#define snprintf _snprintf
#endif
#define DIRSEP '\\'
#define DIRSEPSTR "\\"
#else
#define DIRSEP '/'
#define DIRSEPSTR "/"
#endif

#define NOT_IMPLEMENTED {printf("Function not implemented.\n");return -1;}
#define SECONDSPERDAY 86400

/* Dynamically allocated buffers */

int buf_reset(BUFFER *buffer);
int buf_clear(BUFFER *buffer);
int buf_append(BUFFER *buffer, byte *mess, int len);
int buf_cat(BUFFER *to, BUFFER *from);
int buf_set(BUFFER *to, BUFFER *from);
int buf_rest(BUFFER *to, BUFFER *from);
int buf_appendrnd(BUFFER *to, int n);
int buf_appendzero(BUFFER *to, int n);
int buf_setc(BUFFER *buf, byte c);
int buf_appendc(BUFFER *to, byte b);
int buf_setrnd(BUFFER *b, int n);
int buf_setf(BUFFER *buffer, char *fmt, ...);
int buf_appendf(BUFFER *buffer, char *fmt, ...);
int buf_sets(BUFFER *buf, char *s);
int buf_appends(BUFFER *buffer, char *s);
int buf_nl(BUFFER *buffer);
int buf_pad(BUFFER *buffer, int size);
int buf_prepare(BUFFER *buffer, int size);
int buf_rewind(BUFFER *buffer);
int buf_getc(BUFFER *buffer);
void buf_ungetc(BUFFER *buffer);
int buf_get(BUFFER *buffer, BUFFER *to, int n);
int buf_getline(BUFFER *buffer, BUFFER *line);
int buf_chop(BUFFER *b);
void buf_move(BUFFER *dest, BUFFER *src);
byte *buf_data(BUFFER *buffer);
int buf_isheader(BUFFER *buffer);
int buf_getheader(BUFFER *buffer, BUFFER *field, BUFFER *content);
int buf_appendheader(BUFFER *buffer, BUFFER *field, BUFFER *contents);
int buf_lookahead(BUFFER *buffer, BUFFER *line);
int buf_eq(BUFFER *b1, BUFFER *b2);
int buf_ieq(BUFFER *b1, BUFFER *b2);
void buf_cut_out(BUFFER *buffer, BUFFER *cut_out, BUFFER *rest,
                 int from, int len);

int buf_appendl(BUFFER *b, long l);
int buf_appendl_lo(BUFFER *b, long l);
long buf_getl(BUFFER *b);
long buf_getl_lo(BUFFER *b);
int buf_appendi(BUFFER *b, int i);
int buf_appendi_lo(BUFFER *b, int i);
int buf_geti(BUFFER *b);
int buf_geti_lo(BUFFER *b);

/* String comparison */
int strieq(const char *s1, const char *s2);
int strileft(const char *string, const char *keyword);
int striright(const char *string, const char *keyword);
int strifind(const char *string, const char *keyword);

int streq(const char *s1, const char *s2);
int strfind(const char *string, const char *keyword);
int strleft(const char *string, const char *keyword);

void strcatn(char *dest, const char *src, int n);

int bufleft(BUFFER *b, char *k);
int buffind(BUFFER *b, char *k);
int bufeq(BUFFER *b, char *k);

int bufileft(BUFFER *b, char *k);
int bufifind(BUFFER *b, char *k);
int bufiright(BUFFER *b, char *k);
int bufieq(BUFFER *b, char *k);

/* Utility functions */
void whoami(char *addr, char *defaultname);
int sendinfofile(char *name, char *log, BUFFER *address, BUFFER *subject);
int stats(BUFFER *out);
int conf(BUFFER *out);
void conf_premail(BUFFER *out);

void rfc822_addr(BUFFER *line, BUFFER *list);
void rfc822_name(BUFFER *line, BUFFER *name);
void sendmail_begin(void);      /* begin mail sending session */
void sendmail_end(void);        /* end mail sending session */
int sendmail_loop(BUFFER *message, char *from, BUFFER *address);
int sendmail(BUFFER *message, char *from, BUFFER *address);
int mixfile(char *path, const char *name);
int file_to_out(const char *name);
FILE *mix_openfile(const char *name, const char *a);
FILE *openpipe(const char *prog);
int closepipe(FILE *fp);

typedef struct {
  char *name;
  FILE *f;
} LOCK;

int lock(FILE *f);
int unlock(FILE *f);
LOCK *lockfile(char *filename);
int unlockfile(LOCK *lock);

int filtermsg(BUFFER *msg);
BUFFER *readdestblk( );
int doblock(BUFFER *line, BUFFER *filter, int logandreset);
int doallow(BUFFER *line, BUFFER *filter);
int allowmessage(BUFFER *in);

void errlog(int type, char *format,...);
void clienterr(BUFFER *msgbuf, char *err);
void logmail(char *mailbox, BUFFER *message);

void mix_status(char *fmt,...);
void mix_genericerror(void);

#define ERRORMSG 1
#define WARNING 2
#define NOTICE 3
#define LOG 4
#define DEBUGINFO 5

int decode(BUFFER *in, BUFFER *out);
int encode(BUFFER *b, int linelen);
void id_encode(byte id[], byte *s);
void id_decode(byte *s, byte id[]);

int decode_header(BUFFER *content);
int boundary(BUFFER *line, BUFFER *mboundary);
void get_parameter(BUFFER *content, char *attribute, BUFFER *value);
int get_type(BUFFER *content, BUFFER *type, BUFFER *subtype);
int mail_encode(BUFFER *in, int encoding);
int hdr_encode(BUFFER *in, int n);
int attachfile(BUFFER *message, BUFFER *filename);
int pgpmime_sign(BUFFER *message, BUFFER *uid, BUFFER *pass, char *secring);
int mime_attach(BUFFER *message, BUFFER *attachment, BUFFER *type);
void mimedecode(BUFFER *msg);
int qp_decode_message(BUFFER *msg);

#define MIME_8BIT 1   /* transport is 8bit */
#define MIME_7BIT 2   /* transport is 7bit */

/* randomness */
int rnd_bytes(byte *b, int n);
byte rnd_byte(void);
int rnd_number(int n);
int rnd_add(byte *b, int l);
int rnd_seed(void);
void rnd_time(void);

int rnd_init(void);
int rnd_final(void);
void rnd_error(void);

#define RND_QUERY 0
#define RND_NOTSEEDED -1
#define RND_SEEDED 1
#define RND_WILLSEED 2
extern int rnd_state; /* flag for PRNG status */

/* compression */
int buf_compress(BUFFER *b);
int buf_zip(BUFFER *out, BUFFER *in, int bits);
int buf_uncompress(BUFFER *b);
int buf_unzip(BUFFER *b, int type);

/* crypto functions */
int digest_md5(BUFFER *b, BUFFER *md);
int isdigest_md5(BUFFER *b, BUFFER *md);
int digestmem_md5(byte *b, int n, BUFFER *md);
int digest_sha1(BUFFER *b, BUFFER *md);
int digest_rmd160(BUFFER *b, BUFFER *md);

int keymgt(int force);
int key(BUFFER *b);
int adminkey(BUFFER *b);

#define ENCRYPT 1
#define DECRYPT 0
int buf_crypt(BUFFER *b, BUFFER *key, BUFFER *iv, int enc);

#ifdef USE_IDEA
int buf_ideacrypt(BUFFER *b, BUFFER *key, BUFFER *iv, int enc);
#endif
int buf_bfcrypt(BUFFER *b, BUFFER *key, BUFFER *iv, int enc);
int buf_3descrypt(BUFFER *b, BUFFER *key, BUFFER *iv, int enc);
int buf_castcrypt(BUFFER *b, BUFFER *key, BUFFER *iv, int enc);
#ifdef USE_AES
int buf_aescrypt(BUFFER *b, BUFFER *key, BUFFER *iv, int enc);
#endif

int db_getseckey(byte keyid[], BUFFER *key);
int db_getpubkey(byte keyid[], BUFFER *key);
int pk_decrypt(BUFFER *encrypted, BUFFER *privkey);
int pk_encrypt(BUFFER *plaintext, BUFFER *privkey);
int check_seckey(BUFFER *buf, const byte id[]);
int check_pubkey(BUFFER *buf, const byte id[]);
int v2createkey(void);
int seckeytopub(BUFFER *pub, BUFFER *sec, byte keyid[]);

/* configuration, general remailer functions */
int mix_configline(char *line);
int mix_initialized(void);
int mix_daily(void);

/* message pool */
#define INTERMEDIATE 0
int pool_send(void);
int pool_read(BUFFER *pool);
int pool_add(BUFFER *msg, char *type);
FILE *pool_new(char *type, char *tmpname, char *path);
int mix_pool(BUFFER *msg, int type, long latent);
int pool_packetfile(char *fname, BUFFER *mid, int packetnum);
void pool_packetexp(void);
int idexp(void);
void pop3get(void);

typedef struct {  /* added for binary id.log change */
  char id[16];
  long time;
} idlog_t;

/* statistics */
int stats_log(int);
int stats_out(int);

/* OpenPGP */
int pgp_keymgt(int force);
int pgp_armor(BUFFER *buf, int mode);
int pgp_dearmor(BUFFER *buf, BUFFER *out);
int pgp_pubkeycert(BUFFER *userid, char *keyring, BUFFER *pass,
                   BUFFER *out, int remail);
int pgp_signtxt(BUFFER *msg, BUFFER *uid, BUFFER *pass,
                char *secring, int remail);
int pgp_isconventional(BUFFER *buf);
int pgp_mailenc(int mode, BUFFER *msg, char *sigid,
                BUFFER *pass, char *pubring, char *secring);
int pgp_signhashalgo(BUFFER *algo, BUFFER *userid, char *secring,
                     BUFFER *pass);

/* menu */
int menu_initialized;
void menu_main(void);
void menu_folder(char command, char *name);
int menu_getuserpass(BUFFER *p, int mode);

int user_pass(BUFFER *b);
int user_confirmpass(BUFFER *b);
void user_delpass(void);

/* remailer */
typedef struct {
  char name[20];
  int version;
  char addr[128];
  byte keyid[16];
  struct {
    unsigned int mix:1;
    unsigned int compress:1;

    unsigned int cpunk:1;
    unsigned int pgp:1;
    unsigned int pgponly:1;
    unsigned int latent:1;
    unsigned int hash:1;
    unsigned int ek:1;
    unsigned int esub:1;

    unsigned int nym:1;
    unsigned int newnym:1;

    unsigned int post:1;
    unsigned int middle:1;
  } flags;
  struct rinfo {
    int reliability;
    int latency;
    char history[13];
  } info[2];
} REMAILER;

#define CHAINMAX 421
#define MAXREM 100
int print_type2list();
int mix2_rlist(REMAILER remailer[]);
int t1_rlist(REMAILER remailer[]);
int pgp_rlist(REMAILER remailer[], int n);
int chain_select(int hop[], char *chainstr, int maxrem, REMAILER *remailer,
                 int type, BUFFER *feedback);
int chain_rand(REMAILER *remailer, int maxrem,
               int thischain[], int chainlen, int t);
int chain_randfinal(int type, REMAILER *remailer, int maxrem, int t);

float chain_reliability(char *chain, int chaintype,
                        char *reliability_string);
int mix2_encrypt(int type, BUFFER *message, char *chainstr, int numcopies,
                 BUFFER *feedback);
int t1_encrypt(int type, BUFFER *message, char *chainstr, int latency,
               BUFFER *ek, BUFFER *feedback);

int t1_getreply(BUFFER *msg, BUFFER *ek, int len);

int t1_decrypt(BUFFER *in);
int t2_decrypt(BUFFER *in);

int mix2_decrypt(BUFFER *m);
int mix3_decrypt(BUFFER *m);

/* type 2 */
#define MAGIC0 0
#define MAGIC1 3

int v3_magic(byte *b);
int v2body(BUFFER *body);
int v2body_setlen(BUFFER *body);
int v2partial(BUFFER *body, BUFFER *mid, int packet, int numpackets);
int v2_merge(BUFFER *mid);
int mix_armor(BUFFER *in);
int mix_dearmor(BUFFER *armored, BUFFER *bin);

/* type 1 */
#define HDRMARK "::"
#define EKMARK "**"
#define HASHMARK "##"
int isline(BUFFER *line, char *text);

/* nym database */

#define NYM_WAITING 0
#define NYM_OK 1
#define NYM_DELETED 2
#define NYM_ANY -1

int nymlist_read(BUFFER *n);
int nymlist_write(BUFFER *list);
int nymlist_get(BUFFER *list, char *nym, BUFFER *config, BUFFER *ek,
                BUFFER *options, BUFFER *name, BUFFER *rblocks, int *status);
int nymlist_append(BUFFER *list, char *nym, BUFFER *config, BUFFER *options,
                   BUFFER *name, BUFFER *chains, BUFFER *eklist, int status);
int nymlist_del(BUFFER *list, char *nym);
int nymlist_getnym(char *nym, BUFFER *config, BUFFER *ek, BUFFER *opt,
                   BUFFER *name, BUFFER *rblocks);
int nymlist_getstatus(char *nym);

/* Visual C lacks dirent */
#ifdef _MSC
typedef HANDLE DIR;

struct dirent {
  char d_name[PATHMAX];
};

DIR *opendir(const char *name);
struct dirent *readdir(DIR *dir);
int closedir(DIR *dir);
#endif

/* sockets */
#if defined(WIN32) && defined(USE_SOCK)
#include <winsock.h>
int sock_init(void);
void sock_exit(void);

#else
typedef int SOCKET;

#define INVALID_SOCKET -1
SOCKET opensocket(char *hostname, int port);
int closesocket(SOCKET s);

#endif

#ifdef WIN32
int is_nt_service(void);
void set_nt_exit_event();
#endif

/* check for memory leaks */
#ifdef DEBUG
#define malloc mix3_malloc
#define free mix3_free
BUFFER *mix3_bufnew(char *, int, char*);
#if __GNUC__ >= 2
# define buf_new() mix3_bufnew(__FILE__, __LINE__, __PRETTY_FUNCTION__)
#else
# define buf_new() mix3_bufnew(__FILE__, __LINE__, "file")
#endif
#endif /* DEBUG */

#endif
1	rabbi	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			Function prototypes
9	weaselp	116	$Id: mix3.h,v 1.8 2002/07/29 23:52:00 weaselp Exp $ */
10	rabbi	1
11
12			#ifndef _MIX3_H
13			#define _MIX3_H
14			#define COPYRIGHT "Copyright Anonymizer Inc."
15
16			#include "config.h"
17			#include "mix.h"
18
19			#ifdef WIN32
20			#ifndef USE_SOCK
21			#define _WINSOCKAPI_ /* don't include winsock */
22			#endif
23			#include <windows.h>
24	rabbi	11	#ifdef _MSC
25			#define snprintf _snprintf
26	rabbi	1	#endif
27	rabbi	11	#define DIRSEP '\\'
28			#define DIRSEPSTR "\\"
29			#else
30			#define DIRSEP '/'
31			#define DIRSEPSTR "/"
32			#endif
33	rabbi	1
34			#define NOT_IMPLEMENTED {printf("Function not implemented.\n");return -1;}
35			#define SECONDSPERDAY 86400
36
37			/* Dynamically allocated buffers */
38
39			int buf_reset(BUFFER *buffer);
40			int buf_clear(BUFFER *buffer);
41			int buf_append(BUFFER buffer, byte mess, int len);
42			int buf_cat(BUFFER to, BUFFER from);
43			int buf_set(BUFFER to, BUFFER from);
44			int buf_rest(BUFFER to, BUFFER from);
45			int buf_appendrnd(BUFFER *to, int n);
46			int buf_appendzero(BUFFER *to, int n);
47			int buf_setc(BUFFER *buf, byte c);
48			int buf_appendc(BUFFER *to, byte b);
49			int buf_setrnd(BUFFER *b, int n);
50			int buf_setf(BUFFER buffer, char fmt, ...);
51			int buf_appendf(BUFFER buffer, char fmt, ...);
52			int buf_sets(BUFFER buf, char s);
53			int buf_appends(BUFFER buffer, char s);
54			int buf_nl(BUFFER *buffer);
55			int buf_pad(BUFFER *buffer, int size);
56			int buf_prepare(BUFFER *buffer, int size);
57			int buf_rewind(BUFFER *buffer);
58			int buf_getc(BUFFER *buffer);
59			void buf_ungetc(BUFFER *buffer);
60			int buf_get(BUFFER buffer, BUFFER to, int n);
61			int buf_getline(BUFFER buffer, BUFFER line);
62			int buf_chop(BUFFER *b);
63			void buf_move(BUFFER dest, BUFFER src);
64			byte buf_data(BUFFER buffer);
65	weaselp	116	int buf_isheader(BUFFER *buffer);
66	rabbi	1	int buf_getheader(BUFFER buffer, BUFFER field, BUFFER *content);
67			int buf_appendheader(BUFFER buffer, BUFFER field, BUFFER *contents);
68			int buf_lookahead(BUFFER buffer, BUFFER line);
69			int buf_eq(BUFFER b1, BUFFER b2);
70			int buf_ieq(BUFFER b1, BUFFER b2);
71			void buf_cut_out(BUFFER buffer, BUFFER cut_out, BUFFER *rest,
72			int from, int len);
73
74			int buf_appendl(BUFFER *b, long l);
75			int buf_appendl_lo(BUFFER *b, long l);
76			long buf_getl(BUFFER *b);
77			long buf_getl_lo(BUFFER *b);
78			int buf_appendi(BUFFER *b, int i);
79			int buf_appendi_lo(BUFFER *b, int i);
80			int buf_geti(BUFFER *b);
81			int buf_geti_lo(BUFFER *b);
82
83			/* String comparison */
84			int strieq(const char s1, const char s2);
85			int strileft(const char string, const char keyword);
86			int striright(const char string, const char keyword);
87			int strifind(const char string, const char keyword);
88
89			int streq(const char s1, const char s2);
90			int strfind(const char string, const char keyword);
91			int strleft(const char string, const char keyword);
92
93			void strcatn(char dest, const char src, int n);
94
95			int bufleft(BUFFER b, char k);
96			int buffind(BUFFER b, char k);
97			int bufeq(BUFFER b, char k);
98
99			int bufileft(BUFFER b, char k);
100			int bufifind(BUFFER b, char k);
101			int bufiright(BUFFER b, char k);
102			int bufieq(BUFFER b, char k);
103
104			/* Utility functions */
105			void whoami(char addr, char defaultname);
106			int sendinfofile(char name, char log, BUFFER address, BUFFER subject);
107			int stats(BUFFER *out);
108			int conf(BUFFER *out);
109			void conf_premail(BUFFER *out);
110
111			void rfc822_addr(BUFFER line, BUFFER list);
112			void rfc822_name(BUFFER line, BUFFER name);
113			void sendmail_begin(void); /* begin mail sending session */
114			void sendmail_end(void); /* end mail sending session */
115	weaselp	116	int sendmail_loop(BUFFER message, char from, BUFFER *address);
116	rabbi	1	int sendmail(BUFFER message, char from, BUFFER *address);
117			int mixfile(char path, const char name);
118			int file_to_out(const char *name);
119			FILE mix_openfile(const char name, const char *a);
120			FILE openpipe(const char prog);
121			int closepipe(FILE *fp);
122
123			typedef struct {
124			char *name;
125			FILE *f;
126			} LOCK;
127
128			int lock(FILE *f);
129			int unlock(FILE *f);
130			LOCK lockfile(char filename);
131			int unlockfile(LOCK *lock);
132
133			int filtermsg(BUFFER *msg);
134			BUFFER *readdestblk( );
135			int doblock(BUFFER line, BUFFER filter, int logandreset);
136			int doallow(BUFFER line, BUFFER filter);
137			int allowmessage(BUFFER *in);
138
139			void errlog(int type, char *format,...);
140			void clienterr(BUFFER msgbuf, char err);
141			void logmail(char mailbox, BUFFER message);
142
143			void mix_status(char *fmt,...);
144			void mix_genericerror(void);
145
146			#define ERRORMSG 1
147			#define WARNING 2
148			#define NOTICE 3
149			#define LOG 4
150			#define DEBUGINFO 5
151
152			int decode(BUFFER in, BUFFER out);
153			int encode(BUFFER *b, int linelen);
154			void id_encode(byte id[], byte *s);
155			void id_decode(byte *s, byte id[]);
156
157			int decode_header(BUFFER *content);
158			int boundary(BUFFER line, BUFFER mboundary);
159			void get_parameter(BUFFER content, char attribute, BUFFER *value);
160			int get_type(BUFFER content, BUFFER type, BUFFER *subtype);
161			int mail_encode(BUFFER *in, int encoding);
162			int hdr_encode(BUFFER *in, int n);
163			int attachfile(BUFFER message, BUFFER filename);
164			int pgpmime_sign(BUFFER message, BUFFER uid, BUFFER pass, char secring);
165			int mime_attach(BUFFER message, BUFFER attachment, BUFFER *type);
166			void mimedecode(BUFFER *msg);
167	rabbi	41	int qp_decode_message(BUFFER *msg);
168	rabbi	1
169			#define MIME_8BIT 1 /* transport is 8bit */
170			#define MIME_7BIT 2 /* transport is 7bit */
171
172			/* randomness */
173			int rnd_bytes(byte *b, int n);
174			byte rnd_byte(void);
175			int rnd_number(int n);
176			int rnd_add(byte *b, int l);
177			int rnd_seed(void);
178			void rnd_time(void);
179
180			int rnd_init(void);
181			int rnd_final(void);
182			void rnd_error(void);
183
184			#define RND_QUERY 0
185			#define RND_NOTSEEDED -1
186			#define RND_SEEDED 1
187			#define RND_WILLSEED 2
188			extern int rnd_state; /* flag for PRNG status */
189
190			/* compression */
191			int buf_compress(BUFFER *b);
192			int buf_zip(BUFFER out, BUFFER in, int bits);
193			int buf_uncompress(BUFFER *b);
194			int buf_unzip(BUFFER *b, int type);
195
196			/* crypto functions */
197			int digest_md5(BUFFER b, BUFFER md);
198			int isdigest_md5(BUFFER b, BUFFER md);
199			int digestmem_md5(byte b, int n, BUFFER md);
200			int digest_sha1(BUFFER b, BUFFER md);
201			int digest_rmd160(BUFFER b, BUFFER md);
202
203			int keymgt(int force);
204			int key(BUFFER *b);
205			int adminkey(BUFFER *b);
206
207			#define ENCRYPT 1
208			#define DECRYPT 0
209			int buf_crypt(BUFFER b, BUFFER key, BUFFER *iv, int enc);
210
211			#ifdef USE_IDEA
212			int buf_ideacrypt(BUFFER b, BUFFER key, BUFFER *iv, int enc);
213			#endif
214			int buf_bfcrypt(BUFFER b, BUFFER key, BUFFER *iv, int enc);
215			int buf_3descrypt(BUFFER b, BUFFER key, BUFFER *iv, int enc);
216			int buf_castcrypt(BUFFER b, BUFFER key, BUFFER *iv, int enc);
217	rabbi	98	#ifdef USE_AES
218			int buf_aescrypt(BUFFER b, BUFFER key, BUFFER *iv, int enc);
219			#endif
220	rabbi	1
221			int db_getseckey(byte keyid[], BUFFER *key);
222			int db_getpubkey(byte keyid[], BUFFER *key);
223			int pk_decrypt(BUFFER encrypted, BUFFER privkey);
224			int pk_encrypt(BUFFER plaintext, BUFFER privkey);
225			int check_seckey(BUFFER *buf, const byte id[]);
226			int check_pubkey(BUFFER *buf, const byte id[]);
227			int v2createkey(void);
228			int seckeytopub(BUFFER pub, BUFFER sec, byte keyid[]);
229
230			/* configuration, general remailer functions */
231			int mix_configline(char *line);
232			int mix_initialized(void);
233			int mix_daily(void);
234
235			/* message pool */
236			#define INTERMEDIATE 0
237			int pool_send(void);
238			int pool_read(BUFFER *pool);
239			int pool_add(BUFFER msg, char type);
240			FILE pool_new(char type, char tmpname, char path);
241			int mix_pool(BUFFER *msg, int type, long latent);
242			int pool_packetfile(char fname, BUFFER mid, int packetnum);
243			void pool_packetexp(void);
244			int idexp(void);
245			void pop3get(void);
246
247	rabbi	82	typedef struct { /* added for binary id.log change */
248			char id[16];
249			long time;
250			} idlog_t;
251
252	rabbi	1	/* statistics */
253			int stats_log(int);
254			int stats_out(int);
255
256			/* OpenPGP */
257			int pgp_keymgt(int force);
258			int pgp_armor(BUFFER *buf, int mode);
259			int pgp_dearmor(BUFFER buf, BUFFER out);
260			int pgp_pubkeycert(BUFFER userid, char keyring, BUFFER *pass,
261			BUFFER *out, int remail);
262			int pgp_signtxt(BUFFER msg, BUFFER uid, BUFFER *pass,
263			char *secring, int remail);
264			int pgp_isconventional(BUFFER *buf);
265			int pgp_mailenc(int mode, BUFFER msg, char sigid,
266			BUFFER pass, char pubring, char *secring);
267			int pgp_signhashalgo(BUFFER algo, BUFFER userid, char *secring,
268			BUFFER *pass);
269
270			/* menu */
271			int menu_initialized;
272			void menu_main(void);
273			void menu_folder(char command, char *name);
274			int menu_getuserpass(BUFFER *p, int mode);
275
276			int user_pass(BUFFER *b);
277			int user_confirmpass(BUFFER *b);
278			void user_delpass(void);
279
280			/* remailer */
281			typedef struct {
282			char name[20];
283			int version;
284			char addr[128];
285			byte keyid[16];
286			struct {
287			unsigned int mix:1;
288			unsigned int compress:1;
289
290			unsigned int cpunk:1;
291			unsigned int pgp:1;
292			unsigned int pgponly:1;
293			unsigned int latent:1;
294			unsigned int hash:1;
295			unsigned int ek:1;
296			unsigned int esub:1;
297
298			unsigned int nym:1;
299			unsigned int newnym:1;
300
301			unsigned int post:1;
302			unsigned int middle:1;
303			} flags;
304			struct rinfo {
305			int reliability;
306			int latency;
307			char history[13];
308			} info[2];
309			} REMAILER;
310
311			#define CHAINMAX 421
312			#define MAXREM 100
313	rabbi	101	int print_type2list();
314	rabbi	1	int mix2_rlist(REMAILER remailer[]);
315			int t1_rlist(REMAILER remailer[]);
316			int pgp_rlist(REMAILER remailer[], int n);
317			int chain_select(int hop[], char chainstr, int maxrem, REMAILER remailer,
318			int type, BUFFER *feedback);
319			int chain_rand(REMAILER *remailer, int maxrem,
320			int thischain[], int chainlen, int t);
321			int chain_randfinal(int type, REMAILER *remailer, int maxrem, int t);
322
323			float chain_reliability(char *chain, int chaintype,
324			char *reliability_string);
325			int mix2_encrypt(int type, BUFFER message, char chainstr, int numcopies,
326			BUFFER *feedback);
327			int t1_encrypt(int type, BUFFER message, char chainstr, int latency,
328			BUFFER ek, BUFFER feedback);
329
330			int t1_getreply(BUFFER msg, BUFFER ek, int len);
331
332			int t1_decrypt(BUFFER *in);
333			int t2_decrypt(BUFFER *in);
334
335			int mix2_decrypt(BUFFER *m);
336			int mix3_decrypt(BUFFER *m);
337
338			/* type 2 */
339			#define MAGIC0 0
340			#define MAGIC1 3
341
342			int v3_magic(byte *b);
343			int v2body(BUFFER *body);
344			int v2body_setlen(BUFFER *body);
345			int v2partial(BUFFER body, BUFFER mid, int packet, int numpackets);
346			int v2_merge(BUFFER *mid);
347			int mix_armor(BUFFER *in);
348			int mix_dearmor(BUFFER armored, BUFFER bin);
349
350			/* type 1 */
351			#define HDRMARK "::"
352			#define EKMARK "**"
353			#define HASHMARK "##"
354			int isline(BUFFER line, char text);
355
356			/* nym database */
357
358			#define NYM_WAITING 0
359			#define NYM_OK 1
360			#define NYM_DELETED 2
361			#define NYM_ANY -1
362
363			int nymlist_read(BUFFER *n);
364			int nymlist_write(BUFFER *list);
365			int nymlist_get(BUFFER list, char nym, BUFFER config, BUFFER ek,
366			BUFFER options, BUFFER name, BUFFER rblocks, int status);
367			int nymlist_append(BUFFER list, char nym, BUFFER config, BUFFER options,
368			BUFFER name, BUFFER chains, BUFFER *eklist, int status);
369			int nymlist_del(BUFFER list, char nym);
370			int nymlist_getnym(char nym, BUFFER config, BUFFER ek, BUFFER opt,
371			BUFFER name, BUFFER rblocks);
372			int nymlist_getstatus(char *nym);
373
374			/* Visual C lacks dirent */
375			#ifdef _MSC
376			typedef HANDLE DIR;
377
378			struct dirent {
379			char d_name[PATHMAX];
380			};
381
382			DIR opendir(const char name);
383			struct dirent readdir(DIR dir);
384			int closedir(DIR *dir);
385			#endif
386
387			/* sockets */
388			#if defined(WIN32) && defined(USE_SOCK)
389			#include <winsock.h>
390			int sock_init(void);
391			void sock_exit(void);
392
393			#else
394			typedef int SOCKET;
395
396			#define INVALID_SOCKET -1
397			SOCKET opensocket(char *hostname, int port);
398			int closesocket(SOCKET s);
399
400			#endif
401
402	rabbi	30	#ifdef WIN32
403			int is_nt_service(void);
404			void set_nt_exit_event();
405			#endif
406
407	rabbi	1	/* check for memory leaks */
408			#ifdef DEBUG
409			#define malloc mix3_malloc
410			#define free mix3_free
411			BUFFER mix3_bufnew(char , int, char*);
412			#if __GNUC__ >= 2
413			# define buf_new() mix3_bufnew(__FILE__, __LINE__, __PRETTY_FUNCTION__)
414			#else
415			# define buf_new() mix3_bufnew(__FILE__, __LINE__, "file")
416			#endif
417			#endif /* DEBUG */
418
419			#endif