masqmail: a408411ff8df src/masqmail.h

masqmail

view src/masqmail.h @ 387:a408411ff8df

Added a glob-pattern aliasing facility. One use-case is virtual hosting another catch-all maildrops, but you may use it as a more flexible aliasing mechanism as well.

author	markus schnalke <meillo@marmaro.de>
date	Sat, 18 Feb 2012 12:35:12 +0100
parents	5781ba87df95
children	5f0829f8e6c7

line source

1 /*

2 ** MasqMail

5 **

6 ** This program is free software; you can redistribute it and/or modify

7 ** it under the terms of the GNU General Public License as published by

8 ** the Free Software Foundation; either version 2 of the License, or

9 ** (at your option) any later version.

10 **

11 ** This program is distributed in the hope that it will be useful,

12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of

13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14 ** GNU General Public License for more details.

15 **

16 ** You should have received a copy of the GNU General Public License

17 ** along with this program; if not, write to the Free Software

18 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

19 */

20 #include <config.h>

22 #include <stdio.h>

23 #include <stdarg.h>

24 #include <errno.h>

25 #include <stdlib.h>

26 #include <string.h>

27 #include <ctype.h>

28 #include <unistd.h>

29 #include <pwd.h>

30 #include <sys/types.h>

31 #include <sys/socket.h>

32 #include <netinet/in.h>

33 #include <time.h>

34 #include <sys/time.h>

35 #include <netinet/in.h>

36 #include <arpa/inet.h>

37 #include <netdb.h>

38 #include <syslog.h>

39 #include <signal.h>

40 #include <fcntl.h>

42 #include <glib.h>

44 #include "lookup.h"

46 typedef struct _interface {

47 gchar *address;

48 gint port;

49 } interface;

51 #define ADDR_FLAG_DELIVERED 0x01

52 #define ADDR_FLAG_DEFERED 0x02

53 #define ADDR_FLAG_FAILED 0x04

54 #define ADDR_FLAG_LAST_ROUTE 0x40

56 typedef struct _address {

57 gchar *address;

58 gchar *local_part;

59 gchar *domain;

60 gint flags;

61 GList *children;

62 struct _address *parent;

63 } address;

65 #define addr_mark_delivered(addr) { addr->flags |= ADDR_FLAG_DELIVERED; }

66 #define addr_unmark_delivered(addr) { addr->flags &= ~ADDR_FLAG_DELIVERED; }

67 #define addr_is_delivered(addr) ((addr->flags & ADDR_FLAG_DELIVERED) != 0 )

69 #define addr_mark_defered(addr) { addr->flags |= ADDR_FLAG_DEFERED; }

70 #define addr_unmark_defered(addr) { addr->flags &= ~ADDR_FLAG_DEFERED; }

71 #define addr_is_defered(addr) ((addr->flags & ADDR_FLAG_DEFERED) != 0 )

73 #define addr_mark_failed(addr) { addr->flags |= ADDR_FLAG_FAILED; }

74 #define addr_unmark_failed(addr) { addr->flags &= ~ADDR_FLAG_FAILED; }

75 #define addr_is_failed(addr) ((addr->flags & ADDR_FLAG_FAILED) != 0 )

77 typedef struct _connect_route {

78 gchar *name;

79 gchar *filename;

81 gboolean is_perma;

82 gboolean last_route;

84 GList *allowed_senders;

85 GList *denied_senders;

86 GList *allowed_recipients;

87 GList *denied_recipients;

89 interface *mail_host;

90 gboolean connect_error_fail;

91 GList *resolve_list;

92 gchar *helo_name;

93 gboolean do_correct_helo;

94 gboolean instant_helo;

95 gboolean do_pipelining;

96 gchar *auth_name;

97 gchar *auth_login;

98 gchar *auth_secret;

99 gchar *wrapper;

100

101 gchar *set_h_from_domain;

102 gchar *set_h_reply_to_domain;

103 gchar *set_return_path_domain;

104 GList *map_h_from_addresses;

105 GList *map_h_reply_to_addresses;

106 GList *map_h_mail_followup_to_addresses;

107 GList *map_return_path_addresses;

108 gboolean expand_h_sender_domain;

109 gboolean expand_h_sender_address;

110

111 gchar *pipe;

112 gboolean pipe_fromline;

113 gboolean pipe_fromhack;

114 } connect_route;

115

116 typedef struct _masqmail_conf {

117 gint mail_uid;

118 gint mail_gid;

119

120 gint orig_uid;

121 gint orig_gid;

122

123 gboolean run_as_user;

124

125 gchar *mail_dir;

126 gchar *lock_dir;

127 gchar *spool_dir;

128 gchar *log_dir;

129

130 gint debug_level;

131 gboolean use_syslog;

132 guint log_max_pri;

133

134 gchar *host_name;

135 GList *local_hosts;

136 GList *local_addresses;

137 GList *not_local_addresses;

138 GList *listen_addresses;

139

140 /*

141 ** ANSI C defines unsigned long to be at least 32bit

142 ** i.e. ca. 4GB max; that should be enough.

143 */

144 gulong max_msg_size;

145

146 gboolean do_save_envelope_to;

147

148 gboolean defer_all;

149 gboolean do_relay;

150

151 gboolean do_queue;

152

153 gboolean do_verbose;

154

155 gchar *mbox_default;

156 GList *mbox_users;

157 GList *mda_users;

158

159 gchar *mda;

160 gboolean mda_fromline;

161 gboolean mda_fromhack;

162

163 gboolean pipe_fromline;

164 gboolean pipe_fromhack;

165

166 gchar *alias_file;

167 int (*localpartcmp) (const char *, const char *);

168 gchar *globalias_file;

169

170 GList *perma_routes;

171 GList *query_routes; /* list of pairs which point to lists */

172

173 gchar *online_query;

174

175 gchar *errmsg_file;

176 gchar *warnmsg_file;

177 GList *warn_intervals;

178 gint max_defer_time;

179

180 gchar *log_user;

181 } masqmail_conf;

182

183 extern masqmail_conf conf;

184

185 typedef struct _table_pair {

186 gchar *key;

187 gpointer *value;

188 } table_pair;

189

190

191 /* must match the contents of prot_names[] in accept.c */

192 typedef enum _prot_id {

193 PROT_LOCAL = 0,

194 PROT_SMTP,

195 PROT_ESMTP,

196 PROT_NUM

197 } prot_id;

198

199 extern gchar *prot_names[];

200

201 typedef enum _header_id {

202 HEAD_FROM = 0,

203 HEAD_SENDER,

204 HEAD_TO,

205 HEAD_CC,

206 HEAD_BCC,

207 HEAD_DATE,

208 HEAD_MESSAGE_ID,

209 HEAD_REPLY_TO,

210 HEAD_SUBJECT,

211 HEAD_RETURN_PATH,

212 HEAD_ENVELOPE_TO,

213 HEAD_RECEIVED,

214 HEAD_NUM_IDS,

215 HEAD_STATUS,

216 HEAD_UNKNOWN = HEAD_NUM_IDS,

217 HEAD_NONE = -1,

218 } header_id;

219

220 typedef struct _header_name {

221 gchar *header;

222 header_id id;

223 } header_name;

224

225 typedef struct _header {

226 header_id id;

227 gchar *header;

228 gchar *value;

229 } header;

230

231

232 typedef struct _message {

233 gchar *uid;

234

235 gchar *received_host;

236 prot_id received_prot;

237 gchar *ident;

238 gint transfer_id; /* for multiple messages per transfer */

239

240 address *return_path;

241 GList *rcpt_list;

242 GList *non_rcpt_list;

243

244 GList *hdr_list;

245 GList *data_list;

246

247 gint data_size;

248 time_t received_time;

249 time_t warned_time;

250

251 gchar *full_sender_name;

252 } message;

253

254 typedef struct _msg_out {

255 message *msg;

256

257 address *return_path;

258 GList *rcpt_list;

259

260 GList *hdr_list;

261 GList *xtra_hdr_list; /* rewritten headers */

262 } msg_out;

263

264 typedef struct _msgout_perhost {

265 gchar *host;

266 GList *msgout_list;

267 } msgout_perhost;

268

269 /* flags for accept() */

270 #define ACC_RCPT_FROM_HEAD 0x08 /* -t option, get rcpts from headers */

271 #define ACC_DOT_IGNORE 0x10 /* a dot on a line itself does not end the message (-oi option) */

272 #define ACC_MAIL_FROM_HEAD 0x40 /* get return path from header */

273 #define ACC_NODOT_RELAX 0x80 /* do not be picky if message ist not terminated by a dot on a line */

274 #define ACC_SAVE_ENVELOPE_TO 0x0100 /* save an existent Envelope-to header as X-Orig-Envelope-to */

275

276 #define DLVR_LOCAL 0x01

277 #define DLVR_ONLINE 0x02

278 #define DLVR_ALL (DLVR_LOCAL|DLVR_ONLINE)

279

280 /* transport flags */

281 #define MSGSTR_FROMLINE 0x01

282 #define MSGSTR_FROMHACK 0x02

283

284 typedef enum _accept_error {

285 AERR_OK = 0,

286 AERR_TIMEOUT,

287 AERR_EOF,

288 AERR_OVERFLOW,

289 AERR_SYNTAX,

290 AERR_NOSPOOL,

291 AERR_NORCPT,

292 AERR_SIZE, /* max msg size exeeded (SMTP SIZE) */

293 AERR_UNKNOWN

294 } accept_error;

295

296 #define BUF_LEN 1024

297 #define MAX_ADDRESS 256

298 #define MAX_DATALINE 4096

299

300 typedef enum _smtp_cmd_id {

301 SMTP_HELO = 0,

302 SMTP_EHLO,

303 SMTP_MAIL_FROM,

304 SMTP_RCPT_TO,

305 SMTP_DATA,

306 SMTP_QUIT,

307 SMTP_RSET,

308 SMTP_NOOP,

309 SMTP_HELP,

310 SMTP_NUM_IDS,

311 SMTP_EOF = -1,

312 SMTP_ERROR = -2,

313 } smtp_cmd_id;

314

315 typedef struct _smtp_cmd {

316 smtp_cmd_id id;

317 gchar *cmd;

318 } smtp_cmd;

319

320 typedef struct _smtp_connection {

321 gchar *remote_host;

322

323 prot_id prot;

324 gint next_id;

325

326 gboolean helo_seen;

327 gboolean from_seen;

328 gboolean rcpt_seen;

329

330 message *msg;

331 } smtp_connection;

332

333 /* alias.c*/

334 gboolean addr_is_local(address *addr);

335 GList *alias_expand(GList *alias_table, GList *rcpt_list, GList *non_rcpt_list,

336 int doglob);

337

338 /* child.c */

339 int child(const char *command);

340

341 /* conf.c */

342 void init_conf();

343 gboolean read_conf(gchar *filename);

344 connect_route *read_route(gchar *filename, gboolean is_perma);

345 GList *read_route_list(GList *rf_list, gboolean is_perma);

346 void destroy_route(connect_route *r);

347 void destroy_route_list(GList *list);

348

349 /* expand.c */

350 GList *var_table_rcpt(GList *var_table, address *rcpt);

351 GList *var_table_msg(GList *var_table, message *msg);

352 GList *var_table_conf(GList *var_table);

353 gint expand(GList *var_list, gchar *format, gchar *result, gint result_len);

354

355 /* message.c */

356 message *create_message(void);

357 void destroy_message(message *msg);

358 void destroy_msg_list(GList *msg_list);

359 void msg_free_data(message *msg);

360 gint msg_calc_size(message *msg, gboolean is_smtp);

361

362 msg_out *create_msg_out(message *msg);

363 msg_out *clone_msg_out(msg_out *msgout_orig);

364 void destroy_msg_out(msg_out *msgout);

365 void destroy_msg_out_list(GList *msgout_list);

366

367 /* address.c */

368 address *create_address(gchar *path, gboolean is_rfc821);

369 address *create_address_qualified(gchar *path, gboolean is_rfc821, gchar *domain);

370 address *create_address_pipe(gchar *path);

371 void destroy_address(address *addr);

372 address *copy_modify_address(const address *orig, gchar *l_part, gchar *dom);

373 #define copy_address(addr) copy_modify_address(addr, NULL, NULL)

374 gboolean addr_isequal(address *addr1, address *addr2, int (*cmpfunc) (const char*, const char*));

375 gboolean addr_isequal_parent(address *addr1, address *addr2, int (*cmpfunc) (const char*, const char*));

376 address *addr_find_ancestor(address *addr);

377 gboolean addr_is_delivered_children(address *addr);

378 gboolean addr_is_finished_children(address *addr);

379 gchar *addr_string(address *addr);

380

381 /* accept.c */

382 accept_error accept_message(FILE *in, message *msg, guint flags);

383 accept_error accept_message_prepare(message *msg, guint flags);

384

385 /* header.c */

386 gchar *rec_timestamp();

387 GList *find_header(GList *hdr_list, header_id id, gchar *hdr_str);

388 void header_unfold(header *hdr);

389 void header_fold(header *hdr, unsigned int maxlen);

390 header *create_header(header_id id, gchar *fmt, ...);

391 void destroy_header(header *hdr);

392 header *copy_header(header *hdr);

393 header *get_header(gchar *line);

394

395 /* smtp_in.c */

396 void smtp_in(FILE *in, FILE *out, gchar *remote_host, gchar *ident);

397

398 /* listen.c */

399 void listen_port(GList *addr_list, gint qival, char *argv[]);

400

401 /* parse.c */

402 gboolean split_address(const gchar *path, gchar **local_part, gchar **domain, gboolean is_rfc821);

403 gboolean parse_address_rfc822(gchar *string, gchar **local_begin, gchar **local_end, gchar **domain_begin, gchar **domain_end, gchar **address_end);

404 gboolean parse_address_rfc821(gchar *string, gchar **local_begin, gchar **local_end, gchar **domain_begin, gchar **domain_end, gchar **address_end);

405 address *_create_address(gchar *string, gchar **end, gboolean is_rfc821);

406 address *create_address_rfc821(gchar *string, gchar **end);

407 address *create_address_rfc822(gchar *string, gchar **end);

408 GList *addr_list_append_rfc822(GList *addr_list, gchar *string, gchar *domain);

409

410 /* connect.c */

411 mxip_addr *connect_hostlist(int *psockfd, gchar *host, guint port, GList *addr_list);

412 mxip_addr *connect_resolvelist(int *psockfd, gchar *host, guint port, GList *res_funcs);

413

414 /* deliver.c */

415 void msg_rcptlist_local(GList *rcpt_list, GList **, GList **);

416 gboolean deliver_local(msg_out *msgout);