masqmail: 55b7bde95d37 src/deliver.c

masqmail

view src/deliver.c @ 317:55b7bde95d37

reworked allowed and denied addrs for routes The following refactorings had been made: - allowed_mail_locals + allowed_return_paths -> allowed_senders - not_allowed_mail_locals + not_allowed_return_paths -> denied_senders - allowed_rcpt_domains -> allowed_recipients - not_allowed_rcpt_domains -> denied_recipients The new options allow more consistent and more flexible matching.

author	meillo@marmaro.de
date	Thu, 28 Apr 2011 09:55:06 +0200
parents	c98aa884d2cb
children	412385b57dc4

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", msg->uid, rcpt->local_part, rcpt->domain);

293

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

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

296 } else {

297

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

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

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

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

302 addr_mark_delivered(rcpt);

303 ok = TRUE;

304 } else {

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

306

307 if (route->connect_error_fail) {

308 addr_mark_failed(rcpt);

309 } else {

310 addr_mark_defered(rcpt);

311 }

312 }

313 }

314

315 destroy_table(var_table);

316 }

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

318

319 if (flag) {

320 msg_free_data(msg);

321 }

322 if (ok || ok_fail) {

323 deliver_finish(msgout);

324 }

325 }

326

327 return ok;

328 }

329

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

331 delivered to at least one rcpt.

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

333 */

334 gboolean

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

336 {

337 gboolean ok = FALSE;

338 GList *msgout_node;

339 smtp_base *psb;

340 gint port = 25;

341

342 /* paranoid check: */

343 if (!msgout_list) {

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

345 return FALSE;

346 }

347

348 if (!host) {

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

350 host = route->mail_host->address;

351 port = route->mail_host->port;

352 }

353

354 if (route->wrapper) {

355 psb = smtp_out_open_child(route->wrapper);

356 } else {

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

358 }

359

360 if (!psb) {

361 /* smtp_out_open() failed */

362 foreach(msgout_list, msgout_node) {

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

364 GList *rcpt_node;

365

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

367 rcpt_node;

368 rcpt_node = g_list_next(rcpt_node)) {

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

370 gboolean ret = FALSE;

371

372 addr_unmark_delivered(rcpt);

373 if (route->connect_error_fail) {

374 addr_mark_failed(rcpt);

375 } else {

376 addr_mark_defered(rcpt);

377 }

378 if (route->wrapper) {

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

380 } else {

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

382 }

383 if (ret) {

384 deliver_finish(msgout);

385 }

386 }

387 }

388 return ok;

389 }

390

391

392 if (route->wrapper) {

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