masqmail: e230bcd0f1c6 src/deliver.c

masqmail

view src/deliver.c @ 311:e230bcd0f1c6

removed protocol option from route config It was somehow redundant. Now, if `pipe' is set, the protocol will be pipe, otherwise it'll be smtp. That's just natural.

author	meillo@marmaro.de
date	Sun, 24 Apr 2011 19:37:56 +0200
parents	f10a56dc7481
children	c98aa884d2cb

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 foreach(msgout_list, msgout_node) {

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

273 gboolean flag, ok_fail = FALSE;

274 message *msg = msgout->msg;

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

276

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

278

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

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

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

282 continue;

283 }

284

285 ok = FALSE;

286 foreach(rcpt_list, rcpt_node) {

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

288 gchar *cmd = g_malloc(256);

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

290

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

292

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

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

295 } else {

296

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

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

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

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

301 addr_mark_delivered(rcpt);

302 ok = TRUE;

303 } else {

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

305

306 if (route->connect_error_fail) {

307 addr_mark_failed(rcpt);

308 } else {

309 addr_mark_defered(rcpt);

310 }

311 }

312 }

313

314 destroy_table(var_table);

315 }

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

317

318 if (flag) {

319 msg_free_data(msg);

320 }

321 if (ok || ok_fail) {

322 deliver_finish(msgout);

323 }

324 }

325

326 return ok;

327 }

328

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

330 delivered to at least one rcpt.

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

332 */

333 gboolean

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

335 {

336 gboolean ok = FALSE;

337 GList *msgout_node;

338 smtp_base *psb;

339 gint port = 25;

340

341 /* paranoid check: */

342 if (!msgout_list) {

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

344 return FALSE;

345 }

346

347 if (!host) {

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

349 host = route->mail_host->address;

350 port = route->mail_host->port;

351 }

352

353 if (route->wrapper) {

354 psb = smtp_out_open_child(route->wrapper);

355 } else {

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

357 }

358

359 if (!psb) {

360 /* smtp_out_open() failed */

361 foreach(msgout_list, msgout_node) {

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

363 GList *rcpt_node;

364

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

366 rcpt_node;

367 rcpt_node = g_list_next(rcpt_node)) {

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

369 gboolean ret = FALSE;

370

371 addr_unmark_delivered(rcpt);

372 if (route->connect_error_fail) {

373 addr_mark_failed(rcpt);

374 } else {

375 addr_mark_defered(rcpt);

376 }

377 if (route->wrapper) {

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

379 } else {

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

381 }

382 if (ret) {

383 deliver_finish(msgout);

384 }

385 }

386 }

387 return ok;

388 }

389

390

391 if (route->wrapper) {

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