masqmail: 180a7f6a9383 src/route.c

227 if (fnmatch(pat->domain, rcpt->domain, FNM_CASEFOLD)==0 && fnmatch(pat->local_part, rcpt->local_part, 0)==0) { /* TODO: match local_part caseless? */

228 break;

229 }

230 }

231 if (pat_node) {

232 if (rl_matching)

233 *rl_matching = g_list_append(*rl_matching, rcpt);

234 } else {

235 if (rl_others)

236 *rl_others = g_list_append(*rl_others, rcpt);

237 }

238 }

239 }

240 }

241

242 /*

243 ** Return a new list of the local rcpts in the rcpt_list

244 ** TODO: This function is almost exactly the same as remote_rcpts(). Merge?

245 */

246 GList*

247 local_rcpts(GList *rcpt_list)

248 {

249 GList *rcpt_node;

250 GList *local_rcpts = NULL;

251 address *rcpt = NULL;

252

253 if (!rcpt_list) {

254 return NULL;

255 }

256 foreach(rcpt_list, rcpt_node) {

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

258 if (addr_is_local(rcpt)) {

259 local_rcpts = g_list_append(local_rcpts, rcpt);

260 }

261 }

262 return local_rcpts;

263 }

264

265 /*

266 ** Return a new list of non-local rcpts in the rcpt_list

267 ** TODO: This function is almost exactly the same as local_rcpts(). Merge?

268 */

269 GList*

270 remote_rcpts(GList *rcpt_list)

271 {

272 GList *rcpt_node;

273 GList *remote_rcpts = NULL;

274 address *rcpt = NULL;

275

276 if (!rcpt_list) {

277 return NULL;

278 }

279 foreach(rcpt_list, rcpt_node) {

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

281 if (!addr_is_local(rcpt)) {

282 remote_rcpts = g_list_append(remote_rcpts, rcpt);

283 }

284 }

285 return remote_rcpts;

286 }

287

288 static gint

289 _g_list_addrcmp(gconstpointer pattern, gconstpointer addr)

290 {

291 int res;

292 address *patternaddr = (address*) pattern;

293 address *stringaddr = (address*) addr;

294

295 DEBUG(6) debugf("_g_list_addrcmp: pattern `%s' `%s' on string `%s' `%s'\n",

296 patternaddr->local_part, patternaddr->domain,

297 stringaddr->local_part, stringaddr->domain);

298 /* TODO: check if we should match here dependent on caseless_matching */

299 res = fnmatch(patternaddr->local_part, stringaddr->local_part, 0);

300 if (res != 0) {

301 DEBUG(6) debugf("_g_list_addrcmp: ... failed on local_part\n");

302 return res;

303 }

304 res = fnmatch(patternaddr->domain, stringaddr->domain, FNM_CASEFOLD);

305 DEBUG(6) debugf("_g_list_addrcmp: ... %s\n", (res==0) ? "matched" : "failed on domain");

306 return res;

307 }

308

309 gboolean

310 route_sender_is_allowed(connect_route *route, address *ret_path)

311 {

312 if (route->denied_senders && g_list_find_custom(route->denied_senders, ret_path, _g_list_addrcmp)) {

313 return FALSE;

314 }

315 if (route->allowed_senders) {

316 if (g_list_find_custom(route->allowed_senders, ret_path, _g_list_addrcmp)) {

317 return TRUE;

318 } else {

319 return FALSE;

320 }

321 }

322 return TRUE;

323 }

324

325 /*

326 ** Make lists of matching/not matching rcpts.

327 ** Local domains are NOT regared here, these should be sorted out previously

328 */

329 void

330 route_split_rcpts(connect_route *route, GList *rcpt_list, GList **p_rcpt_list, GList **p_non_rcpt_list)

331 {

332 GList *tmp_list = NULL;

333 /* sort out those domains that can be sent over this connection: */

334 if (route->allowed_recipients) {

335 DEBUG(5) debugf("testing for route->allowed_recipients\n");

336 split_rcpts(rcpt_list, route->allowed_recipients, NULL, &tmp_list, p_non_rcpt_list);

337 } else {

338 DEBUG(5) debugf("route->allowed_recipients == NULL\n");

339 tmp_list = g_list_copy(rcpt_list);

340 }

341

342 /* sort out those domains that cannot be sent over this connection: */

343 split_rcpts(tmp_list, route->denied_recipients, NULL, p_non_rcpt_list, p_rcpt_list);

344 g_list_free(tmp_list);

345 }

346

347 gboolean

348 route_from_hdr_is_allowed(connect_route *route, char *from_hdr)

349 {

350 address *addr = create_address_qualified(from_hdr, FALSE,

351 conf.host_name);

352 if (route->denied_from_hdrs && g_list_find_custom(route->denied_from_hdrs, addr, _g_list_addrcmp)) {

353 return FALSE;

354 }

355 if (route->allowed_from_hdrs) {

356 if (g_list_find_custom(route->allowed_from_hdrs, addr,

357 _g_list_addrcmp)) {

358 return TRUE;

359 } else {

360 return FALSE;

361 }

362 }

363 return TRUE;

364 }

365

366

367 msg_out*

368 route_prepare_msgout(connect_route *route, msg_out *msgout)

369 {

370 message *msg = msgout->msg;

371 GList *rcpt_list = msgout->rcpt_list;

372

373 if (rcpt_list != NULL) {

374 /* found a few */

375 DEBUG(5) {

376 GList *node;

377 debugf("rcpts for routed delivery, route = %s, id = %s\n", route->name, msg->uid);

378 foreach(rcpt_list, node) {

379 address *rcpt = (address *) (node->data);

380 debugf(" rcpt for routed delivery: <%s@%s>\n",

381 rcpt->local_part, rcpt->domain);

382 }

383 }

384

385 /*

386 ** rewrite return path if there is a table, use that

387 ** if an address is found and if it has a domain, use that

388 */

389 if (route->map_return_path_addresses) {

390 address *ret_path = NULL;

391 DEBUG(5) debugf("looking up %s in map_return_path_addresses\n", msg->return_path->local_part);

392 ret_path = (address *) table_find_fnmatch(route->map_return_path_addresses, msg->return_path->local_part);

393 if (ret_path) {

394 DEBUG(5) debugf("found <%s@%s>\n", ret_path->local_part, ret_path->domain);

395 if (ret_path->domain == NULL)

396 ret_path->domain = route->set_return_path_domain

397 ? route->set_return_path_domain

398 : msg->return_path->domain;

399 msgout->return_path = copy_address(ret_path);

400 }

401 }

402 if (msgout->return_path == NULL) {

403 DEBUG(5) debugf("setting return path to %s\n", route->set_return_path_domain);

404 msgout->return_path = copy_modify_address(msg->return_path, NULL, route->set_return_path_domain);

405 }

406 rewrite_headers(msgout, route);

407

408 return msgout;

409 }

410 return NULL;

411 }

412

413 /*

414 ** put msgout's is msgout_list into bins (msgout_perhost structs) for each

415 ** host. Used if there is no mail_host.

416 ** route param is not used, we leave it here because that may change.

417 */

418 GList*

419 route_msgout_list(connect_route *route, GList *msgout_list)

420 {

421 GList *mo_ph_list = NULL;

422 GList *msgout_node;

423

424 foreach(msgout_list, msgout_node) {

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

426 msg_out *msgout_new;

427 GList *rcpt_list = msgout->rcpt_list;

428 GList *rcpt_node;

429

430 foreach(rcpt_list, rcpt_node) {

431 address *rcpt = rcpt_node->data;

432 msgout_perhost *mo_ph = NULL;

433 GList *mo_ph_node = NULL;

434

435 /* search host in mo_ph_list */

436 foreach(mo_ph_list, mo_ph_node) {

437 mo_ph = (msgout_perhost *) (mo_ph_node->data);

438 if (strcasecmp(mo_ph->host, rcpt->domain) == 0)

439 break;

440 }

441 if (mo_ph_node != NULL) {

442 /* there is already a rcpt for this host */

443 msg_out *msgout_last = (msg_out *) ((g_list_last(mo_ph->msgout_list))->data);

444 if (msgout_last->msg == msgout->msg) {

445 /*

446 ** if it is also the same message,

447 ** it must be the last one

448 ** appended to mo_ph->msgout_list

449 ** (since outer loop goes through

450 ** msgout_list)

451 */

452 msgout_last->rcpt_list = g_list_append(msgout_last->rcpt_list, rcpt);

453 } else {

454 /* if not, we append a new msgout */

455 /* make a copy of msgout */

456 msgout_new = create_msg_out(msgout->msg);

457 msgout_new->return_path = msgout->return_path;

458 msgout_new->hdr_list = msgout->hdr_list;

459

460 /* append our rcpt to it */

461 /* It is the 1st rcpt for this msg to this host, therefore we safely give NULL */

462 msgout_new->rcpt_list = g_list_append(NULL, rcpt);

463 mo_ph->msgout_list = g_list_append(mo_ph->msgout_list, msgout_new);

464 }

465 } else {

466 /* this rcpt to goes to another host */

467 mo_ph = create_msgout_perhost(rcpt->domain);

468 mo_ph_list = g_list_append(mo_ph_list, mo_ph);

469

470 /* make a copy of msgout */

471 msgout_new = create_msg_out(msgout->msg);

472 msgout_new->return_path = msgout->return_path;

473 msgout_new->hdr_list = msgout->hdr_list;

474

475 /* append our rcpt to it */

476 /* It is the 1st rcpt for this msg to this host, therefore we safely give NULL */

477 msgout_new->rcpt_list = g_list_append(NULL, rcpt);

478 mo_ph->msgout_list = g_list_append(mo_ph->msgout_list, msgout_new);

479 } /* if mo_ph != NULL */

480 } /* foreach(rcpt_list, ... */

481 } /* foreach(msgout_list, ... */

482

483 return mo_ph_list;

484 }