masqmail: c8e3d1a79313 src/smtp

masqmail

view src/smtp_in.c @ 394:c8e3d1a79313

Refactoring in conf.c: read_rval().

author	markus schnalke <meillo@marmaro.de>
date	Sat, 18 Feb 2012 19:32:40 +0100
parents	b27f66555ba8
children

line source

1 /*

2 ** MasqMail

5 **

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

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

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

9 ** (at your option) any later version.

10 **

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

12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of

13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14 ** GNU General Public License for more details.

15 **

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

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

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

19 */

21 #include "masqmail.h"

22 #include "readsock.h"

24 /*

25 ** I always forget these rfc numbers:

26 ** RFC 821 (SMTP)

27 ** RFC 1869 (ESMTP)

28 ** RFC 1870 (ESMTP SIZE)

29 ** RFC 2197 (ESMTP PIPELINE)

30 ** RFC 2554 (ESMTP AUTH)

31 */

34 smtp_cmd smtp_cmds[] = {

35 {SMTP_HELO, "HELO",},

36 {SMTP_EHLO, "EHLO",},

37 {SMTP_MAIL_FROM, "MAIL FROM:",},

38 {SMTP_RCPT_TO, "RCPT TO:",},

39 {SMTP_DATA, "DATA",},

40 {SMTP_QUIT, "QUIT",},

41 {SMTP_RSET, "RSET",},

42 {SMTP_NOOP, "NOOP",},

43 {SMTP_HELP, "HELP"},

44 };

46 static smtp_cmd_id

47 get_id(const gchar *line)

48 {

49 gint i;

50 for (i = 0; i < SMTP_NUM_IDS; i++) {

51 if (strncasecmp(smtp_cmds[i].cmd, line, strlen(smtp_cmds[i].cmd)) == 0) {

52 return (smtp_cmd_id) i;

53 }

54 }

55 return SMTP_ERROR;

56 }

58 static gboolean

59 get_size(gchar *line, unsigned long *msize) {

60 gchar *s = NULL;

62 /* hope we need not to handle cases like SiZe= ...*/

63 s = strstr(line, "SIZE=");

64 if (!s) {

65 /* try it in lowercase too */

66 if (!(s = strstr(line, "size="))) {

67 return FALSE;

68 }

69 }

70 s += 5;

71 *msize = atol(s);

72 DEBUG(5) debugf("get_size(): line=%s, msize=%ld\n", line, *msize);

74 return TRUE;

75 }

78 /*

79 ** this is a quick hack: we expect the address to be syntactically correct

80 ** and containing the mailbox only, though we first check for size in

81 ** smtp_in().

82 ** Return false if address is too long.

83 */

84 static gboolean

85 get_address(gchar *line, gchar *addr)

86 {

87 gchar *p = line;

88 gchar *q = addr;

90 /* skip MAIL FROM: and RCPT TO: */

91 while (*p && (*p != ':')) {

92 p++;

93 }

94 p++;

96 /* skip spaces: */

97 while (*p && isspace(*p)) {

98 p++;

99 }

100

101 /* get address: */

102 while (*p && !isspace(*p)) {

103 if (q >= addr + MAX_ADDRESS-1) {

104 *q = '\0';

105 return FALSE;

106 }

107 *(q++) = *(p++);

108 }

109 *q = '\0';

110

111 return TRUE;

112 }

113

114 static smtp_connection*

115 create_base(gchar *remote_host)

116 {

117 smtp_connection *base = g_malloc(sizeof(smtp_connection));

118 if (!base) {

119 return NULL;

120 }

121

122 base->remote_host = g_strdup(remote_host);

123

124 base->prot = PROT_SMTP;

125 base->next_id = 0;

126 base->helo_seen = 0;

127 base->from_seen = 0;

128 base->rcpt_seen = 0;

129 base->msg = NULL;

130

131 return base;

132 }

133

134 static void

135 smtp_printf(FILE *out, gchar *fmt, ...)

136 {

137 va_list args;

138 va_start(args, fmt);

139

140 DEBUG(4) {

141 gchar buf[256];

142 va_list args_copy;

143

144 va_copy(args_copy, args);

145 vsnprintf(buf, 255, fmt, args_copy);

146 va_end(args_copy);

147

148 debugf(">>>%s\n", buf);

149 }

150

151 vfprintf(out, fmt, args);

152 fflush(out);

153

154 va_end(args);

155 }

156

157 void

158 smtp_in(FILE *in, FILE *out, gchar *remote_host, gchar *ident)

159 {

160 gchar *buffer;

161 smtp_cmd_id cmd_id;

162 message *msg = NULL;

163 smtp_connection *psc;

164 int len;

165 unsigned long msize;

166

167 DEBUG(5) debugf("smtp_in entered, remote_host = %s\n", remote_host);

168

169 psc = create_base(remote_host);

170 psc->msg = msg;

171

172 buffer = (gchar *) g_malloc(BUF_LEN);

173 if (!buffer) {

174 /* this check is actually unneccessary as g_malloc()

175 aborts on failure */

176 return;

177 }

178

179 /* send greeting string, containing ESMTP: */

180 smtp_printf(out, "220 %s MasqMail %s ESMTP\r\n", conf.host_name, VERSION);

181

182 while ((len = read_sockline(in, buffer, BUF_LEN, 5 * 60, READSOCKL_CHUG)) >= 0) {

183 cmd_id = get_id(buffer);

184

185 if (conf.defer_all) {

186 /* I need this to debug delivery failures */

187 smtp_printf(out, "421 %s service temporarily unavailable.\r\n", conf.host_name);

188 destroy_message(msg);

189 msg = NULL;

190 return;

191 }

192

193 switch (cmd_id) {

194 case SMTP_HELO:

195 psc->prot = PROT_SMTP;

196 psc->helo_seen = TRUE;

197 smtp_printf(out, "250 %s pretty old mailer, huh?\r\n", conf.host_name);

198 break;

199

200 case SMTP_EHLO:

201 psc->prot = PROT_ESMTP;

202 psc->helo_seen = TRUE;

203 smtp_printf(out, "250-%s Nice to meet you with ESMTP\r\n", conf.host_name);

204 smtp_printf(out, "250-SIZE %d\r\n", conf.max_msg_size);

205 smtp_printf(out, "250-PIPELINING\r\n");

206 smtp_printf(out, "250 HELP\r\n");

207 break;

208

209 case SMTP_MAIL_FROM:

210 {

211 gchar buf[MAX_ADDRESS];

212 address *addr;

213

214 if (!psc->helo_seen) {

215 smtp_printf(out, "503 need HELO or EHLO\r\n");

216 break;

217 }

218 if (psc->from_seen) {

219 smtp_printf(out, "503 MAIL FROM: already given.\r\n");

220 break;

221 }

222 if (get_size(buffer, &msize)) {

223 DEBUG(5) debugf("smtp_in(): get_size: msize=%ld, conf.mms=%d\n",

224 msize, conf.max_msg_size);

225 if (conf.max_msg_size && (msize > conf.max_msg_size)) {

226 smtp_printf(out, "552 Message size exceeds fixed limit.\r\n");

227 break;

228 }

229 }

230 if (!get_address(buffer, buf)) {

231 smtp_printf(out, "553 Address too long.\r\n");

232 break;

233 }

234

235 msg = create_message();

236 msg->received_host = remote_host ? g_strdup(remote_host) : NULL;

237 msg->received_prot = psc->prot;

238 msg->ident = ident ? g_strdup(ident) : NULL;

239 /* get transfer id and increment for next one */

240 msg->transfer_id = (psc->next_id)++;

241

242 if (remote_host) {

243 addr = create_address(buf, TRUE);

244 } else {

245 addr = create_address_qualified(buf, TRUE, conf.host_name);

246 }

247 if (!addr) {

248 smtp_printf(out, "501 %s: syntax error.\r\n", buf);

249 } else if (!addr->domain) {

250 smtp_printf(out, "501 return path must be qualified.\r\n", buf);

251 } else {

252 psc->from_seen = TRUE;

253 msg->return_path = addr;

254 smtp_printf(out, "250 OK %s is a nice guy.\r\n", addr->address);

255 }

256 }

257 break;

258

259 case SMTP_RCPT_TO:

260 {

261 char buf[MAX_ADDRESS];

262 address *addr;

263

264 if (!psc->helo_seen) {

265 smtp_printf(out, "503 need HELO or EHLO.\r\n");

266 break;

267 }

268 if (!psc->from_seen) {

269 smtp_printf(out, "503 need MAIL FROM: before RCPT TO:\r\n");

270 break;

271 }

272 if (!get_address(buffer, buf)) {

273 smtp_printf(out, "553 Address too long.\r\n");

274 break;

275 }

276

277 if (remote_host) {

278 addr = create_address(buf, TRUE);

279 } else {

280 addr = create_address_qualified(buf, TRUE, conf.host_name);

281 }

282 if (!addr) {

283 smtp_printf(out, "501 %s: syntax error in address.\r\n", buf);

284 break;

285 }

286 if (addr->local_part[0] == '|') {

287 smtp_printf(out, "501 %s: no pipe allowed for SMTP connections\r\n", buf);

288 break;

289 }

290 if (!addr->domain) {

291 /* TODO: ``postmaster'' may be unqualified */

292 smtp_printf(out, "501 recipient address must be qualified.\r\n", buf);

293 break;

294 }

295 if (!(conf.do_relay || addr_is_local(msg->return_path) || addr_is_local(addr))) {

296 smtp_printf(out, "550 relaying to %s denied.\r\n", addr_string(addr));

297 break;

298 }

299 psc->rcpt_seen = TRUE;

300 msg->rcpt_list = g_list_append(msg->rcpt_list, addr);

301 smtp_printf(out, "250 OK %s is our friend.\r\n", addr->address);

302 }

303 break;

304

305 case SMTP_DATA:

306 if (!psc->helo_seen) {

307 smtp_printf(out, "503 need HELO or EHLO.\r\n");

308 break;

309 }

310 if (!psc->rcpt_seen) {

311 smtp_printf(out, "503 need RCPT TO: before DATA\r\n");

312 break;

313 }

314 accept_error err;

315

316 smtp_printf(out, "354 okay, and do not forget the dot\r\n");

317

318 err = accept_message(in, msg, conf.do_save_envelope_to ? ACC_SAVE_ENVELOPE_TO : 0);

319 if (err != AERR_OK) {

320 switch (err) {

321 case AERR_TIMEOUT:

322 case AERR_EOF:

323 return;

324 case AERR_SIZE:

325 smtp_printf(out, "552 Error: message too large.\r\n");

326 return;

327 default:

328 /* should never happen: */

329 smtp_printf(out, "451 Unknown error\r\n");

330 return;

331 }

332 }

333

334

335 if (!spool_write(msg, TRUE)) {

336 smtp_printf(out, "451 Could not write spool file\r\n");

337 return;

338 }

339 pid_t pid;

340 smtp_printf(out, "250 OK id=%s\r\n", msg->uid);

341

342 if (remote_host != NULL) {

343 logwrite(LOG_NOTICE, "%s <= <%s@%s> host=%s with %s\n", msg->uid,

344 msg->return_path->local_part, msg->return_path->domain,

345 remote_host, prot_names[psc->prot]);

346 } else {

347 logwrite(LOG_NOTICE, "%s <= <%s@%s> with %s\n", msg->uid,

348 msg->return_path->local_part, msg->return_path->domain,

349 prot_names[psc->prot]);

350 }

351

352 if (conf.do_queue) {

353 DEBUG(1) debugf("queuing forced by configuration or option.\n");

354 } else {

355 pid = fork();

356 if (pid < 0) {

357 logwrite(LOG_ALERT, "could not fork for delivery, id = %s\n", msg->uid);

358 } else if (pid == 0) {

359 /* FIXME: most likely inverted exit code */

360 _exit(deliver(msg));

361 }

362 }

363 psc->rcpt_seen = psc->from_seen = FALSE;

364 destroy_message(msg);

365 msg = NULL;

366 break;

367

368 case SMTP_QUIT:

369 smtp_printf(out, "221 goodbye\r\n");

370 destroy_message(msg);

371 msg = NULL;

372 return;

373

374 case SMTP_RSET:

375 psc->from_seen = psc->rcpt_seen = FALSE;

376 destroy_message(msg);

377 msg = NULL;

378 smtp_printf(out, "250 OK\r\n");

379 break;

380

381 case SMTP_NOOP:

382 smtp_printf(out, "250 OK\r\n");

383 break;

384

385 case SMTP_HELP:

386 {

387 int i;

388

389 smtp_printf(out, "214-supported commands:\r\n");

390 for (i = 0; i < SMTP_NUM_IDS - 1; i++) {

391 smtp_printf(out, "214-%s\r\n", smtp_cmds[i].cmd);

392 }

393 smtp_printf(out, "214 %s\r\n", smtp_cmds[i].cmd);

394 }

395 break;

396

397 default:

398 smtp_printf(out, "501 command not recognized\r\n");

399 DEBUG(1) debugf("command not recognized, was '%s'\n", buffer);

400 break;

401 }

402 }

403 switch (len) {

404 case -3:

405 logwrite(LOG_NOTICE, "connection timed out\n");

406 break;

407 case -2:

408 logwrite(LOG_NOTICE, "line overflow\n");

409 break;

410 case -1:

411 logwrite(LOG_NOTICE, "received EOF\n");

412 break;

413 default:

414 break;

415 }

416 }