test/smtp.cpp

   1
   2 #include <ioevent>
   3
   4 #include <EvBufferEvent.hpp>
   5
   6 #include <evhttp.h>
   7
   8 #include <iostream>
   9
  10 extern "C" {
  11 #include "smtpfsm.h"
  12 }
  13
  14 extern "C" {
  15 void smtpfsm_advance(struct myfsm * fsm, int, void *);
  16 }
  17
  18 struct smtp_ctx {
  19         struct myfsm * fsm;
  20
  21         EvBufferEvent * be;
  22         struct bufferevent * bev;
  23
  24         const char * cur_line;
  25
  26         smtp_ctx() : fsm(MYFSM_INIT()) { }
  27
  28         ~smtp_ctx() {
  29                 MYFSM_FREE(fsm);
  30         }
  31 };
  32
  33 extern "C" void helo_enter(enum myevent ev, enum mystate old_state, void *ctx)
  34 {
  35         smtp_ctx * c = (smtp_ctx *)ctx;
  36
  37         bufferevent * bev = c->bev;
  38         evbuffer * b = ::evbuffer_new();
  39
  40         const char * line = c->cur_line;
  41
  42         ::evbuffer_add_printf(b, "250 Hello %s\r\n", line + 5);
  43         ::bufferevent_write_buffer(bev, b);
  44
  45         ::evbuffer_free(b);
  46 }
  47
  48 extern "C" void react_250_ok(smtp_ctx * c)
  49 {
  50         bufferevent * bev = c->bev;
  51         evbuffer * b = ::evbuffer_new();
  52
  53         ::evbuffer_add_printf(b, "250 Ok\r\n");
  54         ::bufferevent_write_buffer(bev, b);
  55
  56         ::evbuffer_free(b);
  57 }
  58
  59 extern "C" void mail_enter(enum myevent ev, enum mystate old_state, void *ctx)
  60 {
  61         smtp_ctx * c = (smtp_ctx *)ctx;
  62
  63         react_250_ok(c);
  64 }
  65
  66 extern "C" void rcpt_enter(enum myevent ev, enum mystate old_state, void *ctx)
  67 {
  68         smtp_ctx * c = (smtp_ctx *)ctx;
  69
  70         react_250_ok(c);
  71 }
  72
  73 extern "C" void data_enter(enum myevent ev, enum mystate old_state, void *ctx)
  74 {
  75         smtp_ctx * c = (smtp_ctx *)ctx;
  76
  77         bufferevent * bev = c->bev;
  78         evbuffer * b = ::evbuffer_new();
  79
  80         ::evbuffer_add_printf(b, "354 End data with <CR><LF>.<CR><LF>\r\n");
  81         ::bufferevent_write_buffer(bev, b);
  82
  83         ::evbuffer_free(b);
  84 }
  85
  86 extern "C" void quit_callback(enum myevent ev, void *ctx)
  87 {
  88         smtp_ctx * c = (smtp_ctx *)ctx;
  89
  90         bufferevent * bev = c->bev;
  91         evbuffer * b = ::evbuffer_new();
  92
  93         ::evbuffer_add_printf(b, "221 Bye\r\n");
  94         ::bufferevent_write_buffer(bev, b);
  95
  96         ::evbuffer_free(b);
  97 }
  98
  99 extern "C" void quit_enter(enum myevent ev, enum mystate old_state, void *ctx)
 100 {
 101
 102 }
 103
 104 void readcb(struct bufferevent *bev, void * v)
 105 {
 106         char * line;
 107
 108         smtp_ctx * c = (smtp_ctx *)v;
 109
 110         while (line = ::evbuffer_readline(bev->input))
 111         {
 112                 c->cur_line = line;
 113
 114                 if (MYFSM_CURRENT(c->fsm) != DATA)
 115                 {
 116                         if (!strncmp(line, "HELO ", 5) ||
 117                             !strncmp(line, "EHLO ", 5))
 118                         {
 119                                 //react_helo(c);
 120                                 //myfsm_advance(c->fsm, HELO, c, myerr, MYERR_LEN);
 121                                 smtpfsm_advance(c->fsm, HELO, c);
 122                         }
 123                         else
 124                         if (!strncmp(line, "MAIL", 4))
 125                         {
 126                                 //react_250_ok(c);
 127                                 //myfsm_advance(c->fsm, MAIL, c, myerr, MYERR_LEN);
 128                                 smtpfsm_advance(c->fsm, MAIL, c);
 129                         }
 130                         else
 131                         if (!strncmp(line, "RCPT", 4))
 132                         {
 133                                 //react_250_ok(c);
 134                                 //myfsm_advance(c->fsm, RCPT, c, myerr, MYERR_LEN);
 135                                 smtpfsm_advance(c->fsm, RCPT, c);
 136                         }
 137                         else
 138                         if (!strncmp(line, "DATA", 4))
 139                         {
 140                                 //react_data(c);
 141                                 //myfsm_advance(c->fsm, DATA, c, myerr, MYERR_LEN);
 142                                 smtpfsm_advance(c->fsm, DATA, c);
 143                         }
 144                         else
 145                         if (!strncmp(line, "QUIT", 4))
 146                         {
 147                                 //react_bye(c);
 148                                 //myfsm_advance(c->fsm, QUIT, c, myerr, MYERR_LEN);
 149                                 smtpfsm_advance(c->fsm, QUIT, c);
 150                         }
 151                 }
 152                 else
 153                 {
 154                         if (!strcmp(line, "."))
 155                         {
 156                                 //react_data_line(c);
 157                                 //myfsm_advance(c->fsm, END_DATA, c, myerr, sizeof myerr - 1);
 158                                 //myfsm_advance(c->fsm, END_DATA, c, myerr, sizeof(myerr) - 1);
 159                                 smtpfsm_advance(c->fsm, END_DATA, c);
 160                         }
 161                 }
 162
 163                 free(line);
 164                 c->cur_line = NULL;
 165         }
 166
 167 }
 168
 169 void writecb(struct bufferevent *, void *)
 170 {
 171
 172 }
 173
 174 void errorcb(struct bufferevent *, short, void *)
 175 {
 176
 177 }
 178
 179 void accept_handler(int s1, short, void *)
 180 {
 181         smtp_ctx * c = new smtp_ctx;
 182
 183         EvBufferEvent * be = new EvBufferEvent(readcb, writecb, errorcb, c);
 184
 185         be->accept(s1);
 186
 187         c->be = be;
 188         c->bev = be->_bufferevent;
 189
 190         c->cur_line = NULL;
 191
 192         ::bufferevent_enable(be->_bufferevent, EV_READ);
 193
 194         be->write("220 www.example.com ESMTP postfix\r\n", 35);
 195
 196 }
 197
 198 main()
 199 {
 200         ::event_init();
 201
 202         int sock = ::bind_socket(NULL, 5525);
 203
 204         ::bufev_socket_listen(sock, 10);
 205
 206         ioevent accept_event(sock, EV_READ, &accept_handler, NULL);
 207         ::event_add(&accept_event, NULL);
 208
 209         ::event_dispatch();
 210
 211 }