masqmail: e3e1a030c703 src/smtp

masqmail

view src/smtp_in.c @ 296:e3e1a030c703

ran aclocal and autoconf

author	markus schnalke <meillo@marmaro.de>
date	Thu, 09 Dec 2010 10:58:40 -0300
parents	5745edd5b769
children	794071925a22

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 "masqmail.h"

21 #include "readsock.h"

23 /*

24 I always forget these rfc numbers:

25 RFC 821 (SMTP)

26 RFC 1869 (ESMTP)

27 RFC 1870 (ESMTP SIZE)

28 RFC 2197 (ESMTP PIPELINE)

29 RFC 2554 (ESMTP AUTH)

30 */

33 smtp_cmd smtp_cmds[] = {

34 {SMTP_HELO, "HELO",},

35 {SMTP_EHLO, "EHLO",},

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

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

38 {SMTP_DATA, "DATA",},

39 {SMTP_QUIT, "QUIT",},

40 {SMTP_RSET, "RSET",},

41 {SMTP_NOOP, "NOOP",},

42 {SMTP_HELP, "HELP"},

43 };

45 static smtp_cmd_id

46 get_id(const gchar * line)

47 {

48 gint i;

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

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

51 return (smtp_cmd_id) i;

52 }

53 }

54 return SMTP_ERROR;

55 }

57 static gboolean

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

59 gchar *s = NULL;

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

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

63 if (!s) {

64 /* try it in lowercase too */

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

66 return FALSE;

67 }

68 }

69 s += 5;

70 *msize = atol(s);

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

73 return TRUE;

74 }

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

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

79 smtp_in().

80 Return false if address is too long.

81 */

82 static gboolean

83 get_address(gchar * line, gchar * addr)

84 {

85 gchar *p = line;

86 gchar *q = addr;

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

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

90 p++;

91 }

92 p++;

94 /* skip spaces: */

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

96 p++;

97 }

99 /* get address: */

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

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

102 *q = '\0';

103 return FALSE;

104 }

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

106 }

107 *q = '\0';

108

109 return TRUE;

110 }

111

112 static smtp_connection*

113 create_base(gchar * remote_host)

114 {

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

116 if (!base) {

117 return NULL;

118 }

119

120 base->remote_host = g_strdup(remote_host);

121

122 base->prot = PROT_SMTP;

123 base->next_id = 0;

124 base->helo_seen = 0;

125 base->from_seen = 0;

126 base->rcpt_seen = 0;

127 base->msg = NULL;

128

129 return base;

130 }

131

132 static void

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

134 {

135 va_list args;

136 va_start(args, fmt);

137

138 DEBUG(4) {

139 gchar buf[256];

140 va_list args_copy;

141

142 va_copy(args_copy, args);

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

144 va_end(args_copy);

145

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

147 }

148

149 vfprintf(out, fmt, args);

150 fflush(out);

151

152 va_end(args);

153 }

154

155 void

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

157 {

158 gchar *buffer;

159 smtp_cmd_id cmd_id;

160 message *msg = NULL;

161 smtp_connection *psc;

162 int len;

163 unsigned long size, msize;

164

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

166

167 psc = create_base(remote_host);

168 psc->msg = msg;

169

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

171 if (!buffer) {

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

173 aborts on failure */

174 return;

175 }

176

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

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

179

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

181 cmd_id = get_id(buffer);

182

183 if (conf.defer_all) {

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

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

186 destroy_message(msg);

187 msg = NULL;

188 return;

189 }

190

191 switch (cmd_id) {

192 case SMTP_HELO:

193 psc->prot = PROT_SMTP;

194 psc->helo_seen = TRUE;

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

196 break;

197

198 case SMTP_EHLO:

199 psc->prot = PROT_ESMTP;

200 psc->helo_seen = TRUE;

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

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

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

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

205 break;

206

207 case SMTP_MAIL_FROM:

208 {

209 gchar buf[MAX_ADDRESS];

210 address *addr;

211

212 if (!psc->helo_seen) {

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

214 break;

215 }

216 if (psc->from_seen) {

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

218 break;

219 }

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

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

222 msize, conf.max_msg_size);

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

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

225 break;

226 }

227 }

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

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

230 break;

231 }

232

233 msg = create_message();

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

235 msg->received_prot = psc->prot;

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

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

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

239

240 if (remote_host) {

241 addr = create_address(buf, TRUE);

242 } else {

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

244 }

245 if (!addr) {

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

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

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

249 } else {

250 psc->from_seen = TRUE;

251 msg->return_path = addr;

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

253 }

254 }

255 break;

256

257 case SMTP_RCPT_TO:

258 {

259 char buf[MAX_ADDRESS];

260 address *addr;

261

262 if (!psc->helo_seen) {

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

264 break;

265 }

266 if (!psc->from_seen) {

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

268 break;

269 }

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

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

272 break;

273 }

274

275 if (remote_host) {

276 addr = create_address(buf, TRUE);

277 } else {

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

279 }

280 if (!addr) {

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

282 break;

283 }

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

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

286 break;

287 }

288 if (!addr->domain) {

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

290 break;

291 }

292 gboolean do_relay = conf.do_relay;

293 if (!do_relay) {

294 do_relay = addr_is_local(msg->return_path);

295 if (!do_relay) {

296 do_relay = addr_is_local(addr);

297 }

298 }

299 if (!do_relay) {

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

301 break;

302 }

303 psc->rcpt_seen = TRUE;

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

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

306 }

307 break;

308

309 case SMTP_DATA:

310 if (!psc->helo_seen) {

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

312 break;

313 }

314 if (!psc->rcpt_seen) {

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

316 break;

317 }

318 accept_error err;

319

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

321

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

323 if (err != AERR_OK) {

324 switch (err) {

325 case AERR_TIMEOUT:

326 case AERR_EOF:

327 return;

328 case AERR_SIZE:

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

330 return;

331 default:

332 /* should never happen: */

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

334 return;

335 }

336 }

337

338

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

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

341 return;

342 }

343 pid_t pid;

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

345

346 if (remote_host != NULL) {

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

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

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

350 } else {

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

352 msg->return_path->local_part, msg->return_path->domain,

353 prot_names[psc->prot]);

354 }

355

356 if (conf.do_queue) {

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

358 } else {

359 pid = fork();

360 if (pid == 0) {

361 _exit(deliver(msg));

362 } else if (pid < 0) {

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

364 }

365 }

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

367 destroy_message(msg);

368 msg = NULL;

369 break;

370

371 case SMTP_QUIT:

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

373 destroy_message(msg);

374 msg = NULL;

375 return;

376

377 case SMTP_RSET:

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

379 destroy_message(msg);

380 msg = NULL;

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

382 break;

383

384 case SMTP_NOOP:

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

386 break;

387

388 case SMTP_HELP:

389 {

390 int i;

391

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

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

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

395 }

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

397 }

398 break;

399

400 default:

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

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

403 break;

404 }

405 }

406 switch (len) {

407 case -3:

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

409 break;

410 case -2:

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

412 break;

413 case -1:

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

415 break;

416 default:

417 break;

418 }

419 }