smtp.cpp

   1 #include <gflags/gflags.h>
   2 namespace gflags {
   3 }
   4
   5 // This needs to be at least the length of each string it's trying to match.
   6 DEFINE_uint64(bfr_size, 4 * 1024, "parser buffer size");
   7
   8 DEFINE_uint64(max_xfer_size, 64 * 1024, "maximum BDAT transfer size");
   9
  10 #include <fstream>
  11
  12 #include "Session.hpp"
  13 #include "esc.hpp"
  14 #include "fs.hpp"
  15 #include "iobuffer.hpp"
  16 #include "osutil.hpp"
  17
  18 #include <cstdlib>
  19 #include <memory>
  20
  21 #include <signal.h>
  22
  23 #include <tao/pegtl.hpp>
  24 #include <tao/pegtl/contrib/abnf.hpp>
  25
  26 using namespace tao::pegtl;
  27 using namespace tao::pegtl::abnf;
  28
  29 namespace RFC5321 {
  30
  31 struct Ctx {
  32   Session session;
  33
  34   std::string mb_loc;
  35   std::string mb_dom;
  36
  37   std::pair<std::string, std::string>          param;
  38   std::unordered_map<std::string, std::string> parameters;
  39
  40   std::streamsize chunk_size;
  41
  42   Ctx(fs::path config_path, std::function<void(void)> read_hook)
  43     : session(config_path, read_hook)
  44   {
  45   }
  46 };
  47
  48 // clang-format off
  49
  50 struct UTF8_tail : range<'\x80', '\xBF'> {};
  51
  52 struct UTF8_1 : range<'\x00', '\x7F'> {};
  53
  54 struct UTF8_2 : seq<range<'\xC2', '\xDF'>, UTF8_tail> {};
  55
  56 struct UTF8_3 : sor<seq<one<'\xE0'>, range<'\xA0', '\xBF'>, UTF8_tail>,
  57                     seq<range<'\xE1', '\xEC'>, rep<2, UTF8_tail>>,
  58                     seq<one<'\xED'>, range<'\x80', '\x9F'>, UTF8_tail>,
  59                     seq<range<'\xEE', '\xEF'>, rep<2, UTF8_tail>>> {};
  60
  61 struct UTF8_4 : sor<seq<one<'\xF0'>, range<'\x90', '\xBF'>, rep<2, UTF8_tail>>,
  62                     seq<range<'\xF1', '\xF3'>, rep<3, UTF8_tail>>,
  63                     seq<one<'\xF4'>, range<'\x80', '\x8F'>, rep<2, UTF8_tail>>> {};
  64
  65 struct UTF8_non_ascii : sor<UTF8_2, UTF8_3, UTF8_4> {};
  66
  67 struct quoted_pair : seq<one<'\\'>, sor<VCHAR, WSP>> {};
  68
  69 using dot = one<'.'>;
  70 using colon = one<':'>;
  71 using dash = one<'-'>;
  72
  73 struct u_let_dig : sor<ALPHA, DIGIT, UTF8_non_ascii> {};
  74
  75 struct u_ldh_tail : star<sor<seq<plus<one<'-'>>, u_let_dig>, u_let_dig>> {};
  76
  77 struct u_label : seq<u_let_dig, u_ldh_tail> {};
  78
  79 struct let_dig : sor<ALPHA, DIGIT> {};
  80
  81 struct ldh_tail : star<sor<seq<plus<one<'-'>>, let_dig>, let_dig>> {};
  82
  83 struct ldh_str : seq<let_dig, ldh_tail> {};
  84
  85 // struct label : seq<let_dig, opt<ldh_str>> {};
  86
  87 struct sub_domain : u_label {};
  88
  89 struct domain : list_tail<sub_domain, dot> {};
  90
  91 struct dec_octet : sor<seq<string<'2','5'>, range<'0','5'>>,
  92                        seq<one<'2'>, range<'0','4'>, DIGIT>,
  93                        seq<range<'0', '1'>, rep<2, DIGIT>>,
  94                        rep_min_max<1, 2, DIGIT>> {};
  95
  96 struct IPv4_address_literal
  97     : seq<dec_octet, dot, dec_octet, dot, dec_octet, dot, dec_octet> {};
  98
  99 struct h16 : rep_min_max<1, 4, HEXDIG> {};
 100
 101 struct ls32 : sor<seq<h16, colon, h16>, IPv4_address_literal> {};
 102
 103 struct dcolon : two<':'> {};
 104
 105 struct IPv6address : sor<seq<                                          rep<6, h16, colon>, ls32>,
 106                          seq<                                  dcolon, rep<5, h16, colon>, ls32>,
 107                          seq<opt<h16                        >, dcolon, rep<4, h16, colon>, ls32>,
 108                          seq<opt<h16,     opt<   colon, h16>>, dcolon, rep<3, h16, colon>, ls32>,
 109                          seq<opt<h16, rep_opt<2, colon, h16>>, dcolon, rep<2, h16, colon>, ls32>,
 110                          seq<opt<h16, rep_opt<3, colon, h16>>, dcolon,        h16, colon,  ls32>,
 111                          seq<opt<h16, rep_opt<4, colon, h16>>, dcolon,                     ls32>,
 112                          seq<opt<h16, rep_opt<5, colon, h16>>, dcolon,                      h16>,
 113                          seq<opt<h16, rep_opt<6, colon, h16>>, dcolon                          >> {};
 114
 115 struct IPv6_address_literal : seq<TAO_PEGTL_ISTRING("IPv6:"), IPv6address> {};
 116
 117 struct dcontent : ranges<33, 90, 94, 126> {};
 118
 119 struct standardized_tag : ldh_str {};
 120
 121 struct general_address_literal : seq<standardized_tag, colon, plus<dcontent>> {};
 122
 123 // See rfc 5321 Section 4.1.3
 124 struct address_literal : seq<one<'['>,
 125                              sor<IPv4_address_literal,
 126                                  IPv6_address_literal,
 127                                  general_address_literal>,
 128                              one<']'>> {};
 129
 130 struct at_domain : seq<one<'@'>, domain> {};
 131
 132 struct a_d_l : list<at_domain, one<','>> {};
 133
 134 // The qtextSMTP rule explained: it's ASCII...
 135 // excluding all the control chars below SPACE
 136 //           34 '"' the double quote
 137 //           92 '\\' the back slash
 138 //           DEL
 139 // So including:
 140 // 32-33:  ' ' and '!'
 141 // 35-91:  "#$%&'()*+,-./" 0-9 ":;<=>?@"  A-Z  '['
 142 // 93-126: "]^_`"  a-z  "{|}~"
 143
 144 struct qtextSMTP : sor<ranges<32, 33, 35, 91, 93, 126>, UTF8_non_ascii> {};
 145
 146 struct graphic : range<32, 126> {};
 147
 148 struct quoted_pairSMTP : seq<one<'\\'>, graphic> {};
 149
 150 struct qcontentSMTP : sor<qtextSMTP, quoted_pairSMTP> {};
 151
 152 struct quoted_string : seq<one<'"'>, star<qcontentSMTP>, one<'"'>> {};
 153
 154 // excluded from atext are the “specials”: "()<>[]:;@\\,."
 155
 156 struct atext : sor<ALPHA, DIGIT,
 157                    one<'!', '#',
 158                        '$', '%',
 159                        '&', '\'',
 160                        '*', '+',
 161                        '-', '/',
 162                        '=', '?',
 163                        '^', '_',
 164                        '`', '{',
 165                        '|', '}',
 166                        '~'>,
 167                    UTF8_non_ascii> {};
 168
 169 struct atom : plus<atext> {};
 170
 171 struct dot_string : list<atom, dot> {};
 172
 173 struct local_part : sor<dot_string, quoted_string> {};
 174
 175 struct non_local_part : sor<domain, address_literal> {};
 176
 177 struct mailbox : seq<local_part, one<'@'>, non_local_part> {};
 178
 179 struct path : seq<one<'<'>, seq<opt<seq<a_d_l, colon>>, mailbox, one<'>'>>> {};
 180
 181 struct bounce_path : TAO_PEGTL_ISTRING("<>") {};
 182
 183 struct reverse_path : sor<path, bounce_path> {};
 184
 185 struct magic_postmaster : TAO_PEGTL_ISTRING("<Postmaster>") {};
 186
 187 struct forward_path : sor<path, magic_postmaster> {};
 188
 189 struct esmtp_keyword : seq<sor<ALPHA, DIGIT>, star<sor<ALPHA, DIGIT, dash>>> {};
 190
 191 struct esmtp_value : plus<sor<range<33, 60>, range<62, 126>, UTF8_non_ascii>> {};
 192
 193 struct esmtp_param : seq<esmtp_keyword, opt<seq<one<'='>, esmtp_value>>> {};
 194
 195 struct mail_parameters : list<esmtp_param, SP> {};
 196
 197 struct rcpt_parameters : list<esmtp_param, SP> {};
 198
 199 struct string : sor<quoted_string, atom> {};
 200
 201 struct helo : seq<TAO_PEGTL_ISTRING("HELO"),
 202                   SP,
 203                   sor<domain, address_literal>,
 204                   CRLF> {};
 205
 206 struct ehlo : seq<TAO_PEGTL_ISTRING("EHLO"),
 207                   SP,
 208                   sor<domain, address_literal>,
 209                   CRLF> {};
 210
 211 struct mail_from : seq<TAO_PEGTL_ISTRING("MAIL"),
 212                        TAO_PEGTL_ISTRING(" FROM:"),
 213                        opt<SP>, // common enough error, we'll allow it
 214                        reverse_path,
 215                        opt<seq<SP, mail_parameters>>,
 216                        CRLF> {};
 217
 218 struct rcpt_to : seq<TAO_PEGTL_ISTRING("RCPT"),
 219                      TAO_PEGTL_ISTRING(" TO:"),
 220                      opt<SP>, // common error
 221                      forward_path,
 222                      opt<seq<SP, rcpt_parameters>>,
 223                      CRLF> {};
 224
 225 struct chunk_size : plus<DIGIT> {};
 226
 227 struct last : TAO_PEGTL_ISTRING("LAST") {};
 228
 229 struct bdat : seq<TAO_PEGTL_ISTRING("BDAT"), SP, chunk_size, CRLF> {};
 230
 231 struct bdat_last : seq<TAO_PEGTL_ISTRING("BDAT"), SP, chunk_size, SP, last, CRLF> {};
 232
 233 struct data : seq<TAO_PEGTL_ISTRING("DATA"), CRLF> {};
 234
 235 struct data_end : seq<dot, CRLF> {};
 236
 237 struct data_blank : CRLF {};
 238
 239 // Rules for strict RFC adherence:
 240
 241 // RFC 5321 text line length section 4.5.3.1.6.
 242 struct data_dot
 243     : seq<one<'.'>, rep_min_max<1, 998, not_one<'\r', '\n'>>, CRLF> {};
 244
 245 struct data_plain : seq<rep_min_max<1, 998, not_one<'\r', '\n'>>, CRLF> {};
 246
 247 // But let's accept real-world crud, up to a point...
 248
 249 struct anything_else : seq<star<not_one<'\n'>>, one<'\n'>> {};
 250
 251 // This particular crud will trigger an error return with the "no bare
 252 // LF" message.
 253
 254 struct not_data_end : seq<dot, LF> {};
 255
 256 struct data_line : sor<at<data_end>,
 257                        seq<sor<data_blank,
 258                                data_dot,
 259                                data_plain,
 260                                not_data_end,
 261                                anything_else>,
 262                            discard>> {};
 263
 264 struct data_grammar : until<data_end, data_line> {};
 265
 266 struct rset : seq<TAO_PEGTL_ISTRING("RSET"), CRLF> {};
 267
 268 struct noop : seq<TAO_PEGTL_ISTRING("NOOP"), opt<seq<SP, string>>, CRLF> {};
 269
 270 struct vrfy : seq<TAO_PEGTL_ISTRING("VRFY"), opt<seq<SP, string>>, CRLF> {};
 271
 272 struct help : seq<TAO_PEGTL_ISTRING("HELP"), opt<seq<SP, string>>, CRLF> {};
 273
 274 struct starttls
 275     : seq<TAO_PEGTL_ISTRING("STAR"), TAO_PEGTL_ISTRING("TTLS"), CRLF> {};
 276
 277 struct quit : seq<TAO_PEGTL_ISTRING("QUIT"), CRLF> {};
 278
 279 // Anti-AUTH support
 280
 281 // base64-char     = ALPHA / DIGIT / "+" / "/"
 282 //                   ;; Case-sensitive
 283
 284 struct base64_char : sor<ALPHA, DIGIT, one<'+', '/'>> {};
 285
 286 // base64-terminal = (2base64-char "==") / (3base64-char "=")
 287
 288 struct base64_terminal : sor<seq<rep<2, base64_char>, TAO_PEGTL_ISTRING("==")>,
 289                              seq<rep<3, base64_char>, one<'='>>
 290                              > {};
 291
 292 // base64          = base64-terminal /
 293 //                   ( 1*(4base64-char) [base64-terminal] )
 294
 295 struct base64 : sor<base64_terminal,
 296                     seq<plus<rep<4, base64_char>>,
 297                         opt<base64_terminal>>
 298                     > {};
 299
 300 // initial-response= base64 / "="
 301
 302 struct initial_response : sor<base64, one<'='>> {};
 303
 304 // cancel-response = "*"
 305
 306 struct cancel_response : one<'*'> {};
 307
 308 struct UPPER_ALPHA : range<'A', 'Z'> {};
 309
 310 using HYPHEN = one<'-'>;
 311 using UNDERSCORE = one<'_'>;
 312
 313 struct mech_char : sor<UPPER_ALPHA, DIGIT, HYPHEN, UNDERSCORE> {};
 314 struct sasl_mech : rep_min_max<1, 20, mech_char> {};
 315
 316 // auth-command    = "AUTH" SP sasl-mech [SP initial-response]
 317 //                   *(CRLF [base64]) [CRLF cancel-response]
 318 //                   CRLF
 319 //                   ;; <sasl-mech> is defined in RFC 4422
 320
 321 struct auth : seq<TAO_PEGTL_ISTRING("AUTH"), SP, sasl_mech,
 322                   opt<seq<SP, initial_response>>,
 323                   // star<CRLF, opt<base64>>,
 324                   // opt<seq<CRLF, cancel_response>>,
 325                   CRLF> {};
 326 // bad commands:
 327
 328 struct bogus_cmd_short : seq<rep_min_max<0, 3, not_one<'\r', '\n'>>, CRLF> {};
 329 struct bogus_cmd_long : seq<rep_min_max<4, 1000, not_one<'\r', '\n'>>, CRLF> {};
 330
 331 // commands in size order
 332
 333 struct any_cmd : seq<sor<bogus_cmd_short,
 334                          data,
 335                          quit,
 336                          rset,
 337                          noop,
 338                          vrfy,
 339                          help,
 340                          helo,
 341                          ehlo,
 342                          bdat,
 343                          bdat_last,
 344                          starttls,
 345                          rcpt_to,
 346                          mail_from,
 347                          auth,
 348                          bogus_cmd_long,
 349                          anything_else>,
 350                      discard> {};
 351
 352 struct grammar : plus<any_cmd> {};
 353
 354 // clang-format on
 355
 356 template <typename Rule>
 357 struct action : nothing<Rule> {
 358 };
 359
 360 template <typename Rule>
 361 struct data_action : nothing<Rule> {
 362 };
 363
 364 template <>
 365 struct action<esmtp_keyword> {
 366   template <typename Input>
 367   static void apply(Input const& in, Ctx& ctx)
 368   {
 369     ctx.param.first = in.string();
 370   }
 371 };
 372
 373 template <>
 374 struct action<bogus_cmd_short> {
 375   template <typename Input>
 376   static void apply(Input const& in, Ctx& ctx)
 377   {
 378     LOG(INFO) << "bogus_cmd_short";
 379     ctx.session.cmd_unrecognized(in.string());
 380   }
 381 };
 382
 383 template <>
 384 struct action<bogus_cmd_long> {
 385   template <typename Input>
 386   static void apply(Input const& in, Ctx& ctx)
 387   {
 388     LOG(INFO) << "bogus_cmd_long";
 389     ctx.session.cmd_unrecognized(in.string());
 390   }
 391 };
 392
 393 template <>
 394 struct action<anything_else> {
 395   template <typename Input>
 396   static void apply(Input const& in, Ctx& ctx)
 397   {
 398     LOG(INFO) << "anything_else";
 399     ctx.session.cmd_unrecognized(in.string());
 400   }
 401 };
 402
 403 template <>
 404 struct action<esmtp_value> {
 405   template <typename Input>
 406   static void apply(Input const& in, Ctx& ctx)
 407   {
 408     ctx.param.second = in.string();
 409   }
 410 };
 411
 412 template <>
 413 struct action<esmtp_param> {
 414   template <typename Input>
 415   static void apply(Input const& in, Ctx& ctx)
 416   {
 417     ctx.parameters.insert(ctx.param);
 418     ctx.param.first.clear();
 419     ctx.param.second.clear();
 420   }
 421 };
 422
 423 template <>
 424 struct action<local_part> {
 425   template <typename Input>
 426   static void apply(Input const& in, Ctx& ctx)
 427   {
 428     ctx.mb_loc = in.string();
 429     // RFC 5321, section 4.5.3.1.1.
 430     if (ctx.mb_loc.length() > 64) {
 431       LOG(WARNING) << "local part too long " << ctx.mb_loc;
 432     }
 433   }
 434 };
 435
 436 template <>
 437 struct action<non_local_part> {
 438   template <typename Input>
 439   static void apply(Input const& in, Ctx& ctx)
 440   {
 441     ctx.mb_dom = in.string();
 442     // RFC 5321, section 4.5.3.1.2.
 443     if (ctx.mb_dom.length() > 255) {
 444       LOG(WARNING) << "domain name or number too long " << ctx.mb_dom;
 445     }
 446   }
 447 };
 448
 449 template <>
 450 struct action<magic_postmaster> {
 451   static void apply0(Ctx& ctx)
 452   {
 453     ctx.mb_loc = std::string{"Postmaster"};
 454     ctx.mb_dom.clear();
 455   }
 456 };
 457
 458 template <>
 459 struct action<helo> {
 460   template <typename Input>
 461   static void apply(Input const& in, Ctx& ctx)
 462   {
 463     auto const b = begin(in) + 5; // +5 for the length of "HELO "
 464     auto const e = std::find(b, end(in) - 2, ' '); // -2 for the CRLF
 465     ctx.session.helo(std::string_view(b, e - b));
 466   }
 467 };
 468
 469 template <>
 470 struct action<ehlo> {
 471   template <typename Input>
 472   static void apply(Input const& in, Ctx& ctx)
 473   {
 474     auto const b = begin(in) + 5; // +5 for the length of "EHLO "
 475     auto const e = std::find(b, end(in) - 2, ' '); // -2 for the CRLF
 476     ctx.session.ehlo(std::string_view(b, e - b));
 477   }
 478 };
 479
 480 template <>
 481 struct action<mail_from> {
 482   static void apply0(Ctx& ctx)
 483   {
 484     ctx.session.mail_from(Mailbox{ctx.mb_loc, ctx.mb_dom}, ctx.parameters);
 485     ctx.mb_loc.clear();
 486     ctx.mb_dom.clear();
 487     ctx.parameters.clear();
 488   }
 489 };
 490
 491 template <>
 492 struct action<rcpt_to> {
 493   static void apply0(Ctx& ctx)
 494   {
 495     ctx.session.rcpt_to(Mailbox{ctx.mb_loc, ctx.mb_dom}, ctx.parameters);
 496     ctx.mb_loc.clear();
 497     ctx.mb_dom.clear();
 498     ctx.parameters.clear();
 499   }
 500 };
 501
 502 template <>
 503 struct action<chunk_size> {
 504   template <typename Input>
 505   static void apply(Input const& in, Ctx& ctx)
 506   {
 507     ctx.chunk_size = std::strtoull(in.string().c_str(), nullptr, 10);
 508   }
 509 };
 510
 511 void bdat_act(Ctx& ctx, bool last)
 512 {
 513   auto status_returned = false;
 514
 515   if (!ctx.session.bdat_start(ctx.chunk_size))
 516     status_returned = true;
 517
 518   auto to_xfer = ctx.chunk_size;
 519
 520   auto const bfr_size{std::min(to_xfer, std::streamsize(FLAGS_max_xfer_size))};
 521   iobuffer<char> bfr(bfr_size);
 522
 523   while (to_xfer) {
 524     auto const xfer_sz{std::min(to_xfer, bfr_size)};
 525
 526     ctx.session.in().read(bfr.data(), xfer_sz);
 527     if (!ctx.session.in()) {
 528       LOG(ERROR) << "attempt to read " << xfer_sz << " octets but only got "
 529                  << ctx.session.in().gcount();
 530       if (ctx.session.maxed_out()) {
 531         LOG(ERROR) << "input maxed out";
 532         if (!status_returned)
 533           ctx.session.bdat_size_error();
 534       }
 535       else if (ctx.session.timed_out()) {
 536         LOG(ERROR) << "input timed out";
 537         if (!status_returned)
 538           ctx.session.bdat_io_error();
 539       }
 540       else if (ctx.session.in().eof()) {
 541         LOG(ERROR) << "EOF in BDAT";
 542         if (!status_returned)
 543           ctx.session.bdat_io_error();
 544       }
 545       else {
 546         LOG(ERROR) << "I/O error in BDAT";
 547         if (!status_returned)
 548           ctx.session.bdat_io_error();
 549       }
 550       return;
 551     }
 552     if (!ctx.session.msg_write(bfr.data(), xfer_sz)) {
 553       if (!status_returned)
 554         ctx.session.bdat_size_error();
 555       status_returned = true;
 556     }
 557
 558     to_xfer -= xfer_sz;
 559   }
 560
 561   if (!status_returned) {
 562     ctx.session.bdat_done(ctx.chunk_size, last);
 563   }
 564 }
 565
 566 template <>
 567 struct action<bdat> {
 568   static void apply0(Ctx& ctx)
 569   {
 570     bdat_act(ctx, false);
 571   }
 572 };
 573
 574 template <>
 575 struct action<bdat_last> {
 576   static void apply0(Ctx& ctx)
 577   {
 578     bdat_act(ctx, true);
 579   }
 580 };
 581
 582 template <>
 583 struct data_action<data_end> {
 584   static void apply0(Ctx& ctx) { ctx.session.data_done(); }
 585 };
 586
 587 template <>
 588 struct data_action<data_blank> {
 589   static void apply0(Ctx& ctx)
 590   {
 591     constexpr char CRLF[]{'\r', '\n'};
 592     ctx.session.msg_write(CRLF, sizeof(CRLF));
 593   }
 594 };
 595
 596 template <>
 597 struct data_action<data_plain> {
 598   template <typename Input>
 599   static void apply(Input const& in, Ctx& ctx)
 600   {
 601     auto const len{end(in) - begin(in)};
 602     ctx.session.msg_write(begin(in), len);
 603   }
 604 };
 605
 606 template <>
 607 struct data_action<data_dot> {
 608   template <typename Input>
 609   static void apply(Input const& in, Ctx& ctx)
 610   {
 611     auto const len{end(in) - begin(in) - 1};
 612     ctx.session.msg_write(begin(in) + 1, len);
 613   }
 614 };
 615
 616 template <>
 617 struct data_action<not_data_end> {
 618   static void apply0(Ctx& ctx) __attribute__((noreturn))
 619   {
 620     ctx.session.bare_lf();
 621   }
 622 };
 623
 624 template <>
 625 struct data_action<anything_else> {
 626   template <typename Input>
 627   static void apply(Input const& in, Ctx& ctx)
 628   {
 629     LOG(WARNING) << "garbage in data stream: \"" << esc(in.string()) << "\"";
 630     auto const len{end(in) - begin(in)};
 631     if (len)
 632       ctx.session.msg_write(begin(in), len);
 633     if (len > 1000) {
 634       LOG(WARNING) << "line too long at " << len << " octets";
 635     }
 636   }
 637 };
 638
 639 template <>
 640 struct action<data> {
 641   template <typename Input>
 642   static void apply(Input const& in, Ctx& ctx)
 643   {
 644     if (ctx.session.data_start()) {
 645       auto din = istream_input<eol::crlf, 1>(ctx.session.in(), FLAGS_bfr_size,
 646                                              "data");
 647       try {
 648         if (!parse_nested<RFC5321::data_grammar, RFC5321::data_action>(in, din,
 649                                                                        ctx)) {
 650           ctx.session.log_stats();
 651           if (!(ctx.session.maxed_out() || ctx.session.timed_out())) {
 652             ctx.session.error("bad DATA syntax");
 653           }
 654         }
 655         return;
 656       }
 657       catch (parse_error const& e) {
 658         LOG(WARNING) << e.what();
 659         ctx.session.error("unable to parse DATA stream");
 660       }
 661       catch (std::exception const& e) {
 662         LOG(WARNING) << e.what();
 663         ctx.session.error("unknown problem in DATA stream");
 664       }
 665     }
 666   }
 667 };
 668
 669 template <>
 670 struct action<rset> {
 671   static void apply0(Ctx& ctx) { ctx.session.rset(); }
 672 };
 673
 674 template <typename Input>
 675 std::string_view get_string_view(Input const& in)
 676 {
 677   auto const b   = begin(in) + 4;
 678   auto const len = end(in) - b;
 679   auto       str = std::string_view(b, len);
 680   if (str.front() == ' ')
 681     str.remove_prefix(1);
 682   return str;
 683 }
 684
 685 template <>
 686 struct action<noop> {
 687   template <typename Input>
 688   static void apply(Input const& in, Ctx& ctx)
 689   {
 690     auto const str = get_string_view(in);
 691     ctx.session.noop(str);
 692   }
 693 };
 694
 695 template <>
 696 struct action<vrfy> {
 697   template <typename Input>
 698   static void apply(Input const& in, Ctx& ctx)
 699   {
 700     auto const str = get_string_view(in);
 701     ctx.session.vrfy(str);
 702   }
 703 };
 704
 705 template <>
 706 struct action<help> {
 707   template <typename Input>
 708   static void apply(Input const& in, Ctx& ctx)
 709   {
 710     auto const str = get_string_view(in);
 711     ctx.session.help(str);
 712   }
 713 };
 714
 715 template <>
 716 struct action<starttls> {
 717   static void apply0(Ctx& ctx) { ctx.session.starttls(); }
 718 };
 719
 720 template <>
 721 struct action<quit> {
 722   static void apply0(Ctx& ctx) __attribute__((noreturn)) { ctx.session.quit(); }
 723 };
 724
 725 template <>
 726 struct action<auth> {
 727   static void apply0(Ctx& ctx) __attribute__((noreturn)) { ctx.session.auth(); }
 728 };
 729 } // namespace RFC5321
 730
 731 void timeout(int signum) __attribute__((noreturn));
 732 void timeout(int signum)
 733 {
 734   const char errmsg[] = "421 4.4.2 time-out\r\n";
 735   write(STDOUT_FILENO, errmsg, sizeof errmsg - 1);
 736   _Exit(1);
 737 }
 738
 739 int main(int argc, char* argv[])
 740 {
 741   std::ios::sync_with_stdio(false);
 742
 743   { // Need to work with either namespace.
 744     using namespace gflags;
 745     using namespace google;
 746     ParseCommandLineFlags(&argc, &argv, true);
 747   }
 748
 749   // Set timeout signal handler to limit total run time.
 750   struct sigaction sact {
 751   };
 752   PCHECK(sigemptyset(&sact.sa_mask) == 0);
 753   sact.sa_flags   = 0;
 754   sact.sa_handler = timeout;
 755   PCHECK(sigaction(SIGALRM, &sact, nullptr) == 0);
 756
 757   auto const log_dir{getenv("GOOGLE_LOG_DIR")};
 758   if (log_dir) {
 759     error_code ec;
 760     fs::create_directories(log_dir, ec);
 761   }
 762
 763   google::InitGoogleLogging(argv[0]);
 764
 765   std::unique_ptr<RFC5321::Ctx> ctx;
 766
 767   // Don't wait for STARTTLS to fail if no cert.
 768   auto const config_path = osutil::get_config_dir();
 769   auto const certs = osutil::list_directory(config_path, Config::cert_fn_re);
 770   CHECK_GE(certs.size(), 1) << "no certs found";
 771
 772   auto const read_hook{[&ctx]() { ctx->session.flush(); }};
 773   ctx = std::make_unique<RFC5321::Ctx>(config_path, read_hook);
 774
 775   ctx->session.greeting();
 776
 777   istream_input<eol::crlf, 1> in{ctx->session.in(), FLAGS_bfr_size, "session"};
 778
 779   int ret = 0;
 780   try {
 781     ret = !parse<RFC5321::grammar, RFC5321::action>(in, *ctx);
 782   }
 783   catch (std::exception const& e) {
 784     LOG(WARNING) << e.what();
 785   }
 786
 787   if (ctx->session.maxed_out()) {
 788     ctx->session.max_out();
 789   }
 790   else if (ctx->session.timed_out()) {
 791     ctx->session.time_out();
 792   }
 793   // else {
 794   //   ctx->session.error("session end without QUIT command from client");
 795   // }
 796
 797   return ret;
 798 }