masqmail: ea5f86e0a81c src/deliver.c

masqmail

view src/deliver.c @ 281:ea5f86e0a81c

modes are now enforced exclusive Other MTAs (exim, postfix) are more relaxing, but as combinations of exclusive modes are senseless we behave more obvious if we fail early. This makes understanding the behavior easier too.

author	markus schnalke <meillo@marmaro.de>
date	Tue, 07 Dec 2010 14:04:56 -0300
parents	5f9f3a65032e
children	f10a56dc7481

line source

1 /* MasqMail

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

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

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

8 (at your option) any later version.

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

11 but WITHOUT ANY WARRANTY; without even the implied warranty of

12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

13 GNU General Public License for more details.

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

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

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

18 */

20 #include <fnmatch.h>

21 #include <sysexits.h>

22 #include <netdb.h>

24 #include "masqmail.h"

25 #include "smtp_out.h"

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

28 /* returns TRUE if either there are no failures or a failure message has been successfully sent */

29 gboolean

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

31 {

32 gboolean ok_fail = TRUE, ok_warn = TRUE;

33 time_t now = time(NULL);

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

36 va_list args;

37 va_start(args, err_fmt);

39 foreach(rcpt_list, rcpt_node) {

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

42 if (addr_is_defered(rcpt)) {

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

44 addr_mark_failed(rcpt);

45 } else {

46 defered_list = g_list_prepend(defered_list, rcpt);

47 }

48 }

49 if (addr_is_failed(rcpt)) {

50 failed_list = g_list_prepend(failed_list, rcpt);

51 }

52 }

53 if (failed_list) {

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

55 g_list_free(failed_list);

56 }

57 if (defered_list) {

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

59 g_list_free(defered_list);

60 }

61 va_end(args);

62 return ok_fail && ok_warn;

63 }

65 static gint

66 _g_list_strcasecmp(gconstpointer a, gconstpointer b)

67 {

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

69 }

71 gboolean

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

73 {

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

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

76 if (env_addr != rcpt) {

77 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);

78 } else {

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

80 }

81 addr_mark_delivered(rcpt);

82 return TRUE;

83 }

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

86 if (errno != EAGAIN) {

87 addr_mark_failed(rcpt);

88 } else {

89 addr_mark_defered(rcpt);

90 }

91 return FALSE;

92 }

94 gboolean

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

96 {

97 guint flags;

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

100

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

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

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

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

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

106 addr_mark_delivered(rcpt);

107 return TRUE;

108 }

109

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

111 addr_mark_failed(rcpt);

112 } else {

113 addr_mark_defered(rcpt);

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

115 }

116 return FALSE;

117 }

118

119 gboolean

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

121 {

122 gboolean ok = FALSE;

123 gchar *cmd = g_malloc(256);

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

125 guint flags;

126

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

128

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

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

131 destroy_table(var_table);

132 return FALSE;

133 }

134

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

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

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

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

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

140 addr_mark_delivered(rcpt);

141 ok = TRUE;

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

143 addr_mark_failed(rcpt);

144 } else {

145 addr_mark_defered(rcpt);

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

147 }

148

149 destroy_table(var_table);

150 return ok;

151 }

152

153 gboolean

154 deliver_local(msg_out * msgout)

155 {

156 message *msg = msgout->msg;

157 GList *rcpt_list = msgout->rcpt_list;

158 GList *rcpt_node;

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

160

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

162

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

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

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

166 return FALSE;

167 }

168

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

170 GList *hdr_list;

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

172 address *env_addr = addr_find_ancestor(rcpt);

173 address *ret_path = msg->return_path;

174 header *retpath_hdr, *envto_hdr;

175

176 /* we need a private copy of the hdr list because we add headers

177 here that belong to the rcpt only. g_list_copy copies only

178 the nodes, so it is safe to g_list_free it */

179 hdr_list = g_list_copy(msg->hdr_list);

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

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

182

183 hdr_list = g_list_prepend(hdr_list, envto_hdr);

184 hdr_list = g_list_prepend(hdr_list, retpath_hdr);

185

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

187 /* probably for expanded aliases, but why not done

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

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

190 ok = TRUE;

191 }

192 } else {

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

194 gchar *user = rcpt->local_part;

195 gchar *mbox_type = conf.mbox_default;

196

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

198 mbox_type = "mbox";

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

200 mbox_type = "mda";

201 }

202

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

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

205 ok = TRUE;

206 }

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

208 if (conf.mda) {

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

210 ok = TRUE;

211 }

212 } else {

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

214 }

215

216 } else {

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

218 }

219 }

220

221 destroy_header(retpath_hdr);

222 destroy_header(envto_hdr);

223

224 g_list_free(hdr_list);

225 }

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

227

228 if (flag) {

229 msg_free_data(msg);

230 }

231 if (ok || ok_fail) {

232 deliver_finish(msgout);

233 }

234

235 return ok;

236 }

237

238 /* make a list of rcpt's of a message that are local return a new copy of the list */

239 void

240 msg_rcptlist_local(GList * rcpt_list, GList ** p_local_list, GList ** p_nonlocal_list)

241 {

242 GList *rcpt_node;

243

244 foreach(rcpt_list, rcpt_node) {

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

246 GList *dom_node;

247

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

249

250 /* search for local host list: */

251 foreach(conf.local_hosts, dom_node) {

252 if (strcasecmp(dom_node->data, rcpt->domain) == 0) {

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

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

255 break;

256 } else {

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

258 }

259 }

260 }

261 }

262

263 gboolean

264 deliver_msglist_host_pipe(connect_route * route, GList * msgout_list, gchar * host, GList * res_list)

265 {

266 gboolean ok = TRUE;

267 GList *msgout_node;

268

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

270

271 if (route->pipe == NULL) {

272 logwrite(LOG_ALERT, "no pipe command given for route (protocol is pipe!)\n");

273 return FALSE;

274 }

275

276 foreach(msgout_list, msgout_node) {

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

278 gboolean flag, ok_fail = FALSE;

279 message *msg = msgout->msg;

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

281

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

283

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

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

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

287 continue;

288 }

289

290 ok = FALSE;

291 foreach(rcpt_list, rcpt_node) {

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

293 gchar *cmd = g_malloc(256);

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

295

296 DEBUG(1) debugf("attempting to deliver %s to %s@%s with pipe\n", msg->uid, rcpt->local_part, rcpt->domain);

297

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

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

300 } else {

301

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

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

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

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

306 addr_mark_delivered(rcpt);

307 ok = TRUE;

308 } else {

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

310

311 if (route->connect_error_fail) {

312 addr_mark_failed(rcpt);

313 } else {

314 addr_mark_defered(rcpt);

315 }

316 }

317 }

318

319 destroy_table(var_table);

320 }

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

322

323 if (flag) {

324 msg_free_data(msg);

325 }

326 if (ok || ok_fail) {

327 deliver_finish(msgout);

328 }

329 }

330

331 return ok;

332 }

333

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

335 delivered to at least one rcpt.

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

337 */

338 gboolean

339 deliver_msglist_host_smtp(connect_route * route, GList * msgout_list, gchar * host, GList * res_list)

340 {

341 gboolean ok = FALSE;

342 GList *msgout_node;

343 smtp_base *psb;

344 gint port = 25;

345

346 /* paranoid check: */

347 if (!msgout_list) {

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

349 return FALSE;

350 }

351

352 if (!host) {

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

354 host = route->mail_host->address;

355 port = route->mail_host->port;

356 }

357

358 if (route->wrapper) {

359 psb = smtp_out_open_child(route->wrapper);

360 } else {

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

362 }

363

364 if (!psb) {

365 /* smtp_out_open() failed */

366 foreach(msgout_list, msgout_node) {

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

368 GList *rcpt_node;

369

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

371 rcpt_node;

372 rcpt_node = g_list_next(rcpt_node)) {

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

374 gboolean ret = FALSE;

375

376 addr_unmark_delivered(rcpt);

377 if (route->connect_error_fail) {

378 addr_mark_failed(rcpt);

379 } else {

380 addr_mark_defered(rcpt);

381 }

382 if (route->wrapper) {

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

384 } else {

385 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));

386 }

387 if (ret) {

388 deliver_finish(msgout);

389 }

390 }

391 }

392 return ok;

393 }

394

395

396 if (route->wrapper) {

397 /* it seems as if the remote_host is only set for logging