masqmail: 9149d893eb52 src/deliver.c

masqmail

view src/deliver.c @ 343:9149d893eb52

refactoring: ``insourced'' create_msg_out_list() The function is only four lines and used only once. It's simpler to have the four lines just at the actual place.

author	markus schnalke <meillo@marmaro.de>
date	Sat, 03 Sep 2011 18:25:02 +0200
parents	412385b57dc4
children	0410c8aabac2

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

239 return a new copy of the list */

240 void

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

242 {

243 GList *rcpt_node;

244

245 foreach(rcpt_list, rcpt_node) {

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

247 GList *dom_node;

248

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

250

251 /* search for local host list: */

252 foreach(conf.local_hosts, dom_node) {

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

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

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

256 break;

257 } else {

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

259 }

260 }

261 }

262 }

263

264 gboolean

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

266 {

267 gboolean ok = TRUE;

268 GList *msgout_node;

269

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

271

272 foreach(msgout_list, msgout_node) {

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

274 gboolean flag, ok_fail = FALSE;

275 message *msg = msgout->msg;

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

277

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

279

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

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

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

283 continue;

284 }

285

286 ok = FALSE;

287 foreach(rcpt_list, rcpt_node) {

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

289 gchar *cmd = g_malloc(256);

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

291

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

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

294

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

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

297 destroy_table(var_table);

298 continue;

299 }

300

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

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

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

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

305 addr_mark_delivered(rcpt);

306 ok = TRUE;

307 } else {

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

309

310 if (route->connect_error_fail) {

311 addr_mark_failed(rcpt);

312 } else {

313 addr_mark_defered(rcpt);

314 }

315 }

316

317 destroy_table(var_table);

318 }

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

320

321 if (flag) {

322 msg_free_data(msg);

323 }

324 if (ok || ok_fail) {

325 deliver_finish(msgout);

326 }

327 }

328

329 return ok;

330 }

331

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

333 delivered to at least one rcpt.

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

335 */

336 gboolean

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

338 {

339 gboolean ok = FALSE;

340 GList *msgout_node;

341 smtp_base *psb;

342 gint port = 25;

343

344 /* paranoid check: */

345 if (!msgout_list) {

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

347 return FALSE;

348 }

349

350 if (!host) {

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

352 host = route->mail_host->address;

353 port = route->mail_host->port;

354 }

355

356 if (route->wrapper) {

357 psb = smtp_out_open_child(route->wrapper, host);

358 } else {

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

360 }

361

362 if (!psb) {

363 /* smtp_out_open() failed */

364 foreach(msgout_list, msgout_node) {

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

366 GList *rcpt_node;

367

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

369 rcpt_node;

370 rcpt_node = g_list_next(rcpt_node)) {

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

372 gboolean ret = FALSE;

373

374 addr_unmark_delivered(rcpt);

375 if (route->connect_error_fail) {

376 addr_mark_failed(rcpt);

377 } else {

378 addr_mark_defered(rcpt);

379 }

380 if (route->wrapper) {

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

382 } else {

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

384 }

385 if (ret) {

386 deliver_finish(msgout);

387 }

388 }

389 }

390 return ok;

391 }

392

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

394

395 #ifdef ENABLE_AUTH