masqmail: 5781ba87df95 src/deliver.c

masqmail

view src/deliver.c @ 378:5781ba87df95

Removed ident. This had been discussed on the mailing list in Oct 2011. Ident is hardly useful in typical setups for masqmail. Probably Oliver had used it in his setup; that would make sense. Now, I know of nobody who needs it.

author	markus schnalke <meillo@marmaro.de>
date	Sat, 14 Jan 2012 21:36:58 +0100
parents	a96bb42f597d
children	a408411ff8df

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

21 #include <fnmatch.h>

22 #include <sysexits.h>

23 #include <netdb.h>

25 #include "masqmail.h"

26 #include "smtp_out.h"

28 /*

29 ** collect failed/defered rcpts for failure/warning messages

30 ** returns TRUE if either there are no failures or a failure message has

31 ** been successfully sent

32 */

33 gboolean

34 delivery_failures(message *msg, GList *rcpt_list, gchar *err_fmt, ...)

35 {

36 gboolean ok_fail = TRUE, ok_warn = TRUE;

37 time_t now = time(NULL);

39 GList *failed_list = NULL, *defered_list = NULL, *rcpt_node;

40 va_list args;

41 va_start(args, err_fmt);

43 foreach(rcpt_list, rcpt_node) {

44 address *rcpt = (address *) (rcpt_node->data);

46 if (addr_is_defered(rcpt)) {

47 if ((now - msg->received_time) >= conf.max_defer_time) {

48 addr_mark_failed(rcpt);

49 } else {

50 defered_list = g_list_prepend(defered_list, rcpt);

51 }

52 }

53 if (addr_is_failed(rcpt)) {

54 failed_list = g_list_prepend(failed_list, rcpt);

55 }

56 }

57 if (failed_list) {

58 ok_fail = fail_msg(msg, conf.errmsg_file, failed_list, err_fmt, args);

59 g_list_free(failed_list);

60 }

61 if (defered_list) {

62 ok_warn = warn_msg(msg, conf.warnmsg_file, defered_list, err_fmt, args);

63 g_list_free(defered_list);

64 }

65 va_end(args);

66 return ok_fail && ok_warn;

67 }

69 static gint

70 _g_list_strcasecmp(gconstpointer a, gconstpointer b)

71 {

72 return (gint) strcasecmp(a, b);

73 }

75 gboolean

76 deliver_local_mbox(message *msg, GList *hdr_list, address *rcpt, address *env_addr)

77 {

78 DEBUG(1) debugf("attempting to deliver %s with mbox\n", msg->uid);

79 if (append_file(msg, hdr_list, rcpt->local_part)) {

80 if (env_addr != rcpt) {

81 logwrite(LOG_NOTICE, "%s => %s@%s <%s@%s> with mbox\n", msg->uid, rcpt->local_part, rcpt->domain, env_addr->local_part, env_addr->domain);

82 } else {

83 logwrite(LOG_NOTICE, "%s => <%s@%s> with mbox\n", msg->uid, rcpt->local_part, rcpt->domain);

84 }

85 addr_mark_delivered(rcpt);

86 return TRUE;

87 }

89 /* prevents 'Resource temporarily unavailable (11)' */

90 if (errno != EAGAIN) {

91 addr_mark_failed(rcpt);

92 } else {

93 addr_mark_defered(rcpt);

94 }

95 return FALSE;

96 }

98 gboolean

99 deliver_local_pipe(message *msg, GList *hdr_list, address *rcpt, address *env_addr)

100 {

101 guint flags;

102

103 DEBUG(1) debugf("attempting to deliver %s with pipe\n", msg->uid);

104

105 flags = (conf.pipe_fromline) ? MSGSTR_FROMLINE : 0;

106 flags |= (conf.pipe_fromhack) ? MSGSTR_FROMHACK : 0;

107 if (pipe_out(msg, hdr_list, rcpt, &(rcpt->local_part[1]), flags)) {

108 logwrite(LOG_NOTICE, "%s => %s <%s@%s> with pipe\n",

109 msg->uid, rcpt->local_part, env_addr->local_part, env_addr->domain);

110 addr_mark_delivered(rcpt);

111 return TRUE;

112 }

113

114 if ((errno != (1024 + EX_TEMPFAIL)) && (errno != EAGAIN)) {

115 addr_mark_failed(rcpt);

116 } else {

117 addr_mark_defered(rcpt);

118 /* has no effect yet, except that mail remains in spool */

119 }

120 return FALSE;

121 }

122

123 gboolean

124 deliver_local_mda(message *msg, GList *hdr_list, address *rcpt, address *env_addr)

125 {

126 gboolean ok = FALSE;

127 gchar *cmd = g_malloc(256);

128 GList *var_table = var_table_rcpt(var_table_msg(NULL, msg), rcpt);

129 guint flags;

130

131 DEBUG(1) debugf("attempting to deliver %s with mda\n", msg->uid);

132

133 if (!expand(var_table, conf.mda, cmd, 256)) {

134 logwrite(LOG_ALERT, "could not expand string %s\n", conf.mda);

135 destroy_table(var_table);

136 return FALSE;

137 }

138

139 flags = (conf.mda_fromline) ? MSGSTR_FROMLINE : 0;

140 flags |= (conf.mda_fromhack) ? MSGSTR_FROMHACK : 0;

141 if (pipe_out(msg, hdr_list, rcpt, cmd, flags)) {

142 logwrite(LOG_NOTICE, "%s => %s@%s with mda (cmd = '%s')\n",

143 msg->uid, rcpt->local_part, rcpt->domain, cmd);

144 addr_mark_delivered(rcpt);

145 ok = TRUE;

146 } else if ((errno != (1024 + EX_TEMPFAIL)) && (errno != EAGAIN)) {

147 addr_mark_failed(rcpt);

148 } else {

149 addr_mark_defered(rcpt);

150 /* has no effect yet, except that mail remains in spool */

151 }

152

153 destroy_table(var_table);

154 return ok;

155 }

156

157 gboolean

158 deliver_local(msg_out *msgout)

159 {

160 message *msg = msgout->msg;

161 GList *rcpt_list = msgout->rcpt_list;

162 GList *rcpt_node;

163 gboolean ok = FALSE, flag = FALSE, ok_fail = FALSE;

164

165 DEBUG(5) debugf("deliver_local entered\n");

166

167 flag = (msg->data_list == NULL);

168 if (flag && !spool_read_data(msg)) {

169 logwrite(LOG_ALERT, "could not open data spool file for %s\n", msg->uid);

170 return FALSE;

171 }

172

173 for (rcpt_node = g_list_first(rcpt_list); rcpt_node; rcpt_node = g_list_next(rcpt_node)) {

174 GList *hdr_list;

175 address *rcpt = (address *) (rcpt_node->data);

176 address *env_addr = addr_find_ancestor(rcpt);

177 address *ret_path = msg->return_path;

178 header *retpath_hdr, *envto_hdr;

179

180 /*

181 ** we need a private copy of the hdr list because we add

182 ** headers here that belong to the rcpt only. g_list_copy

183 ** copies only the nodes, so it is safe to g_list_free it

184 */

185 hdr_list = g_list_copy(msg->hdr_list);

186 retpath_hdr = create_header(HEAD_ENVELOPE_TO, "Envelope-to: %s\n", addr_string(env_addr));

187 envto_hdr = create_header(HEAD_RETURN_PATH, "Return-path: %s\n", addr_string(ret_path));

188

189 hdr_list = g_list_prepend(hdr_list, envto_hdr);

190 hdr_list = g_list_prepend(hdr_list, retpath_hdr);

191

192 if (rcpt->local_part[0] == '|') {

193 /*

194 ** probably for expanded aliases, but why not done

195 ** like with the mda? //meillo 2010-12-06

196 */

197 if (deliver_local_pipe(msg, hdr_list, rcpt, env_addr)) {

198 ok = TRUE;

199 }

200 } else {

201 /* figure out which mailbox type should be used for this user */

202 gchar *user = rcpt->local_part;

203 gchar *mbox_type = conf.mbox_default;

204

205 if (g_list_find_custom (conf.mbox_users, user, _g_list_strcasecmp)) {

206 mbox_type = "mbox";

207 } else if (g_list_find_custom (conf.mda_users, user, _g_list_strcasecmp)) {

208 mbox_type = "mda";

209 }

210

211 if (strcmp(mbox_type, "mbox") == 0) {

212 if (deliver_local_mbox(msg, hdr_list, rcpt, env_addr)) {

213 ok = TRUE;

214 }

215 } else if (strcmp(mbox_type, "mda") == 0) {

216 if (conf.mda) {

217 if (deliver_local_mda(msg, hdr_list, rcpt, env_addr)) {

218 ok = TRUE;

219 }

220 } else {

221 logwrite(LOG_ALERT, "mbox type is mda, but no mda command given in configuration\n");

222 }

223

224 } else {

225 logwrite(LOG_ALERT, "unknown mbox type '%s'\n", mbox_type);

226 }

227 }

228

229 destroy_header(retpath_hdr);

230 destroy_header(envto_hdr);

231

232 g_list_free(hdr_list);

233 }

234 ok_fail = delivery_failures(msg, rcpt_list, "%s (%d)", ext_strerror(errno), errno);

235

236 if (flag) {

237 msg_free_data(msg);

238 }

239 if (ok || ok_fail) {

240 deliver_finish(msgout);

241 }

242

243 return ok;

244 }

245

246 /*

247 ** make a list of rcpt's of a message that are local

248 ** return a new copy of the list

249 */

250 void

251 msg_rcptlist_local(GList *rcpt_list, GList **p_local_list,

252 GList **p_nonlocal_list)

253 {

254 GList *rcpt_node;

255

256 foreach(rcpt_list, rcpt_node) {

257 address *rcpt = (address *) (rcpt_node->data);

258 GList *dom_node;

259

260 DEBUG(5) debugf("checking address %s\n", rcpt->address);

261

262 /* search for local host list: */

263 foreach(conf.local_hosts, dom_node) {

264 if (fnmatch(dom_node->data, rcpt->domain, FNM_CASEFOLD)==0) {

265 *p_local_list = g_list_append(*p_local_list, rcpt);

266 DEBUG(5) debugf("<%s@%s> is local\n", rcpt->local_part, rcpt->domain);

267 break;

268 } else {

269 *p_nonlocal_list = g_list_append(*p_nonlocal_list, rcpt);

270 }

271 }

272 }

273 }

274

275 gboolean

276 deliver_msglist_host_pipe(connect_route *route, GList *msgout_list,

277 gchar *host, GList *res_list)

278 {

279 gboolean ok = TRUE;

280 GList *msgout_node;

281

282 DEBUG(5) debugf("deliver_msglist_host_pipe entered\n");

283

284 foreach(msgout_list, msgout_node) {

285 msg_out *msgout = (msg_out *) (msgout_node->data);

286 gboolean flag, ok_fail = FALSE;

287 message *msg = msgout->msg;

288 GList *rcpt_node, *rcpt_list = msgout->rcpt_list;

289

290 DEBUG(1) debugf("attempting to deliver %s with pipe\n", msg->uid);

291

292 flag = (msg->data_list == NULL);

293 if (flag && !spool_read_data(msg)) {

294 logwrite(LOG_ALERT, "could not open data spool file for %s\n", msg->uid);

295 continue;

296 }

297

298 ok = FALSE;

299 foreach(rcpt_list, rcpt_node) {

300 address *rcpt = (address *) (rcpt_node->data);

301 gchar *cmd = g_malloc(256);

302 GList *var_table = var_table_rcpt(var_table_msg(NULL, msg), rcpt);

303

304 DEBUG(1) debugf("attempting to deliver %s to %s@%s with pipe\n",

305 msg->uid, rcpt->local_part, rcpt->domain);

306

307 if (!expand(var_table, route->pipe, cmd, 256)) {

308 logwrite(LOG_ALERT, "could not expand string `%s'\n", route->pipe);

309 destroy_table(var_table);

310 continue;

311 }

312

313 if (pipe_out(msg, msg->hdr_list, rcpt, cmd, (route->pipe_fromline ? MSGSTR_FROMLINE : 0)

314 | (route->pipe_fromhack ? MSGSTR_FROMHACK : 0))) {

315 logwrite(LOG_NOTICE, "%s => %s@%s with pipe (cmd = '%s')\n",

316 msg->uid, rcpt->local_part, rcpt->domain, cmd);

317 addr_mark_delivered(rcpt);

318 ok = TRUE;

319 } else {

320 logwrite(LOG_ALERT, "pipe_out '%s' failed\n", route->pipe);

321

322 if (route->connect_error_fail) {

323 addr_mark_failed(rcpt);

324 } else {

325 addr_mark_defered(rcpt);

326 }

327 }

328

329 destroy_table(var_table);

330 }

331 ok_fail = delivery_failures(msg, rcpt_list, "%s", strerror(errno));

332

333 if (flag) {

334 msg_free_data(msg);

335 }

336 if (ok || ok_fail) {

337 deliver_finish(msgout);

338 }

339 }

340

341 return ok;

342 }

343

344 /*

345 ** deliver list of messages to one host and finishes them if the message was

346 ** delivered to at least one rcpt.

347 ** Returns TRUE if at least one msg was delivered to at least one rcpt.

348 */

349 gboolean

350 deliver_msglist_host_smtp(connect_route *route, GList *msgout_list,

351 gchar *host, GList *res_list)

352 {

353 gboolean ok = FALSE;

354 GList *msgout_node;

355 smtp_base *psb;

356 gint port = 25;

357

358 /* paranoid check: */

359 if (!msgout_list) {

360 logwrite(LOG_ALERT, "Ooops: empty list of messages in deliver_msglist_host()\n");

361 return FALSE;

362 }

363

364 if (!host) {

365 /* XXX: what if mail_host isn't set? Is this possible? */

366 host = route->mail_host->address;

367 port = route->mail_host->port;

368 }

369

370 if (route->wrapper) {

371 psb = smtp_out_open_child(route->wrapper);

372 if (psb) {

373 psb->remote_host = host;

374 }

375 } else {

376 psb = smtp_out_open(host, port, res_list);

377 }

378

379 if (!psb) {

380 /* smtp_out_open() failed */

381 foreach(msgout_list, msgout_node) {

382 msg_out *msgout = (msg_out *) (msgout_node->data);

383 GList *rcpt_node;

384

385 for (rcpt_node = g_list_first(msgout->rcpt_list);

386 rcpt_node;

387 rcpt_node = g_list_next(rcpt_node)) {

388 address *rcpt = (address *) (rcpt_node->data);

389 gboolean ret = FALSE;

390

391 addr_unmark_delivered(rcpt);

392 if (route->connect_error_fail) {

393 addr_mark_failed(rcpt);

394 } else {

395 addr_mark_defered(rcpt);

396 }

397 if (route->wrapper) {

398 ret = delivery_failures(msgout->msg, msgout->rcpt_list, "could not open wrapper:\n\t%s", strerror(errno));

399 } else {

400 ret = delivery_failures(msgout->msg, msgout->rcpt_list, "could not open connection to %s:%d :\n\t%s", host, port, h_errno != 0 ? hstrerror(h_errno) : strerror(errno));

401 }

402 if (ret) {

403 deliver_finish(msgout);

404 }

405 }

406 }

407 return ok;

408 }

409

410 set_heloname(psb, route->helo_name ? route->helo_name : conf.host_name, route->do_correct_helo);

411

412 #ifdef ENABLE_AUTH

413 if (route->auth_name && route->auth_login && route->auth_secret) {

414 set_auth(psb, route->auth_name, route->auth_login, route->auth_secret);

415 }

416 #endif

417 if (!smtp_out_init(psb, route->instant_helo)) {

418 /* smtp_out_init() failed */

419 if ((psb->error==smtp_fail) || (psb->error==smtp_trylater) || (psb->error==smtp_syntax)) {

420 smtp_out_quit(psb);

421

422 foreach(msgout_list, msgout_node) {

423 msg_out *msgout = (msg_out *) (msgout_node->data);

424 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

425

426 if (delivery_failures(msgout->msg, msgout->rcpt_list, "while connected with %s, the server replied\n\t%s", (route->wrapper) ? "<wrapper>" : host, psb->buffer)) {

427 deliver_finish(msgout);

428 }

429 }

430 }

431 destroy_smtpbase(psb);

432 return ok;

433 }

434

435 if (!route->do_pipelining) {

436 psb->use_pipelining = FALSE;

437 }

438

439 foreach(msgout_list, msgout_node) {

440 msg_out *msgout = (msg_out *) (msgout_node->data);

441 gboolean flag, ok_msg = FALSE, ok_fail = FALSE;

442 message *msg = msgout->msg;

443

444 /* we may have to read the data at this point and remember if we did */

445 flag = (msg->data_list == NULL);

446 if (flag && !spool_read_data(msg)) {

447 logwrite(LOG_ALERT, "could not open data spool file %s\n", msg->uid);

448 break;

449 }

450

451 smtp_out_msg(psb, msg, msgout->return_path, msgout->rcpt_list, msgout->hdr_list);

452

453 ok_fail = delivery_failures(msg, msgout->rcpt_list, "while connected with %s, the server replied\n\t%s", (route->wrapper) ? "<wrapper>" : host, psb->buffer);

454

455 if ((psb->error == smtp_eof) || (psb->error == smtp_timeout)) {

456 /* connection lost */

457 break;

458 } else if (psb->error != smtp_ok) {

459 if (g_list_next(msgout_node) && !smtp_out_rset(psb)) {

460 break;

461 }

462 }

463 ok_msg = (psb->error == smtp_ok);

464

465 if (flag) {