modules/ml-neon.h

   1 #ifndef ML_NEON_H
   2 #define ML_NEON_H
   3
   4 #include "ml.h"
   5 #include "ml-id.h"
   6 #include "ml-store.h"
   7 #include "http-iconv.h"
   8 #include "util_string.h"
   9 #include "filemacro.h"
  10 #include <boost/scoped_ptr.hpp>
  11 #include <neon/ne_session.h>
  12 #include <neon/ne_request.h>
  13 #include <vector>
  14
  15 class  MNode;
  16 class  MlEnv;
  17 class  NeonQuery;
  18
  19 class  NeonPostBodyProvider {
  20  public:
  21     NeonQuery*  query;
  22     std::vector<std::pair<ustring, ustring> >  postFile;
  23     size_t  paramsLen;
  24     ustring  separator;
  25     enum {
  26         S_NONE,
  27         S_TEXT,
  28         S_FILEHEAD,
  29         S_FILEBODY,
  30         S_FILETERM,
  31         S_TAIL,
  32         S_DONE,
  33     }  state;
  34     MNode*  tp;
  35     std::vector<std::pair<ustring, ustring> >::iterator  bp;
  36     std::vector<std::pair<ustring, ustring> >::iterator  ep;
  37     ustring  ubuf;
  38     off_t  offset;
  39     FileMacro  fd;
  40
  41     NeonPostBodyProvider (NeonQuery* _query) {
  42         query = _query;
  43         paramsLen = 0;
  44         makeSeparator ();
  45         state = S_NONE;
  46         tp = NULL;
  47         offset = 0;
  48     };
  49     virtual  ~NeonPostBodyProvider () {};
  50
  51     void  pushFile (const ustring& name, const ustring& path);
  52     void  makeSeparator ();
  53     ustring  separatorLine ();
  54     ustring  separatorHeader ();
  55     ustring  textSeparator (const ustring& name);
  56     ustring  fileSeparator (const ustring& name, const ustring& filename);
  57     ustring  tailSeparator ();
  58     ne_off_t  calcLength ();
  59     char*  bodyProvider (char* buffer, size_t buflen);
  60  private:
  61     ssize_t  bodyProviderText (char* buffer, size_t buflen);
  62 };
  63
  64 class  NeonSession {
  65  public:
  66     typedef enum {
  67         PROTO_NONE,
  68         PROTO_HTTP,
  69         PROTO_HTTPS,
  70     }  proto_t;
  71
  72     ne_session*  session;
  73     proto_t  proto;
  74
  75     NeonSession (proto_t _proto, const ustring& host, unsigned int port);
  76     virtual  ~NeonSession ();
  77
  78     virtual ne_session&  operator * () const {
  79         return *session;
  80     };
  81     virtual ne_session*  operator -> () const {
  82         return session;
  83     };
  84     virtual ne_session*  get () const {
  85         return session;
  86     };
  87     virtual void  setNoVerify ();
  88     virtual void  setProxy (const ustring& host, int port);
  89 };
  90
  91 class  NeonQuery {
  92  public:
  93     typedef enum {
  94         METHOD_NONE,
  95         METHOD_GET,
  96         METHOD_POST,
  97         METHOD_PUT,
  98         METHOD_DELETE,
  99         METHOD_HEAD,
 100         METHOD_FILE,            /* pseudo method */
 101     }  method_t;
 102
 103     ne_request*  req;
 104     ne_session*  session;
 105     method_t  method;
 106     ustring  path;
 107     ustring  basicID;
 108     ustring  basicPW;
 109     MNodePtr  queryParam;
 110     MNodePtr  getQueryParam;
 111     StoreType  rawQuery;
 112     StoreType  rawGetQuery;
 113     ustring  querytype;         /* リクエストヘッダのcontent-type */
 114     MNodePtr  cookie;
 115     MNodePtr  header;
 116     boost::scoped_ptr<NeonPostBodyProvider>  qbody;
 117     boost::scoped_ptr<UIConv>  cv_in;
 118     boost::scoped_ptr<UIConv>  cv_out;
 119     enum {
 120         MODE_SETUP,
 121         MODE_DISPATCHED,
 122         MODE_RECEIVED,
 123     }  mode;
 124     ustring  errorMsg;
 125     std::vector<CookieInfo>  replyCookie;
 126     bool  replyCookieDone;
 127
 128     NeonQuery (ne_session* _session, MlEnv* _mlenv): rawQuery (_mlenv), rawGetQuery (_mlenv) {
 129         session = _session;
 130         req = NULL;
 131         method = METHOD_GET;
 132         mode = MODE_SETUP;
 133         replyCookieDone = false;
 134         qbody.reset (new NeonPostBodyProvider (this));
 135     };
 136     virtual  ~NeonQuery () {
 137         closeReq ();
 138     };
 139
 140     virtual void  closeReq ();
 141     virtual void  setIConv (const char* name);
 142     virtual void  submit ();
 143     virtual void  readBody (MotorOutput* out);
 144     virtual int  getStatus ();
 145     virtual ustring  cv (const ustring& src);
 146     virtual ustring  rcv (const ustring& src);
 147     virtual ustring  getResponseHeader (const char* name);
 148     virtual MNode*  getResponseHeaderAll ();
 149     virtual ustring  getResponseCookie (const ustring& name);
 150     virtual MNode*  getResponseCookieAll ();
 151  private:
 152     virtual const char*  methodStr ();
 153     virtual ustring  buildGetQuery ();
 154     virtual void  buildQuery (MNode* e, ustring& out);
 155     virtual ustring  buildMimeSeparator_text (const ustring& name);
 156     virtual ustring  buildMimeSeparator_file (const ustring& name, const ustring& filename);
 157     virtual ustring  filterPath ();
 158     virtual void  buildCookie ();
 159     virtual void  buildHeader ();
 160     virtual void  buildBasicAuthHeader ();
 161     virtual void  setFormType ();
 162     virtual void  setFormType_urlencoded ();
 163     virtual void  setFormType_formdata ();
 164     virtual void  parseCookie ();
 165     virtual void  setRawQuery (FileMacro& fd);
 166 };
 167
 168 class  MLNeon: public MLFunc {
 169  public:
 170     ustring  host;
 171     int  port;
 172     NeonSession::proto_t  proto;
 173     ustring  proxyhost;
 174     int  proxyport;
 175     ustring  proxyid;
 176     ustring  proxypw;
 177     bool  fnoverify;
 178     boost::scoped_ptr<NeonSession>  session;
 179     boost::scoped_ptr<NeonQuery>  query;
 180
 181     MLNeon (MlEnv* _mlenv): MLFunc (cMLNeonID, _mlenv) {
 182         proto = NeonSession::PROTO_HTTP;
 183         proxyport = 0;
 184         fnoverify = false;
 185     };
 186     virtual  ~MLNeon () {};
 187
 188     virtual void  newSession (MlEnv* mlenv);
 189 };
 190
 191 inline void  assignNLNeon (MLNeon*& var, MNode* e) {
 192     if (e && e->type == MNode::MC_LIBOBJ && e->libobj && e->libobj->id == cMLNeonID)
 193         var = (MLNeon*)e->libobj;
 194 }
 195
 196 MNode*  ml_neon (MNode* cell, MlEnv* mlenv);
 197 MNode*  ml_neon_http_request (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 198 MNode*  ml_neon_http_status (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 199 MNode*  ml_neon_http_response (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 200 MNode*  ml_neon_http_response_file (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 201 MNode*  ml_neon_http_response_output (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 202 MNode*  ml_neon_http_get_cookie (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 203 MNode*  ml_neon_http_get_all_cookies (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 204 MNode*  ml_neon_http_content_type (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 205 MNode*  ml_neon_http_get_header (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 206 MNode*  ml_neon_http_get_all_headers (MNode* cell, MlEnv* mlenv, MLFunc* mobj);
 207
 208 #endif /* ML_NEON_H */