Changeset 751fac6b567d675afee10e627efb5cf786ce5c83

Show
Ignore:
Timestamp:
08/24/10 21:31:46 (18 months ago)
Author:
Antti-Juhani Kaijanaho <antti-juhani@…>
Children:
7eb42bed950e3f81ef9f0d39432e07c55f12cc22
Parents:
ec0da3f87768820f9ca9e8065c7998e9d825bd4c
git-committer:
Antti-Juhani Kaijanaho <antti-juhani@…> (08/24/10 21:31:46)
Message:

[http::request] Cleanup

Signed-off-by: Antti-Juhani Kaijanaho <antti-juhani@…>

Location:
http
Files:
15 modified

Legend:

Unmodified
Added
Removed

  • http/article.cc

    rd3efc81 r751fac6  
    9595                boost::shared_ptr<db::user> u = req->get_user(); 
    9696 
    97                 if (is_single && u && req->get_query_param("markread") != "no") 
     97                if (is_single && u && req->get_form_field("markread") != "no") 
    9898                        u->mark_read(art->msgid()); 
    9999                 

  • http/authn.cc

    rcc0a570 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    9393        authn::tlate_value(boost::shared_ptr<request> req) 
    9494        { 
    95                 std::multimap<std::string,std::string> fb =  
    96                         req->get_form_data(); 
    9795                std::string ruri = req->get_path(); 
    98                 std::string query = req->get_query_or_body(); 
     96                std::string query = req->get_form_as_query(); 
    9997                if (!query.empty()) ruri += "?" + query; 
    10098                tlate::value::ptr rv(new authn_value(req->get_user(), 
    101                                                      lookup 
    102                                                      (fb, "user.authn.message"), 
     99                                                     req->get_form_field 
     100                                                     ("user.authn.message"), 
    103101                                                     ruri)); 
    104102                return rv; 
    … …  
    108106                (boost::shared_ptr<request> req, response::factory rf) 
    109107        { 
    110                 std::multimap<std::string,std::string> fb = 
    111                         req->get_form_data(); 
    112                 ::uri redir = lookup(fb, "redirect"); 
     108                ::uri redir = req->get_form_field("redirect"); 
    113109 
    114110                std::string msg_name = "user.authn.message"; 
    115111                 
    116                 if (req->get_path() == "/login" && fb.find("login") != fb.end()) 
     112                if (req->get_path() == "/login" && req->has_form_field("login")) 
    117113                { 
    118                         std::string user = lookup(fb, "userid"); 
    119                         std::string pass = lookup(fb, "passwd"); 
     114                        std::string user = req->get_form_field("userid"); 
     115                        std::string pass = req->get_form_field("passwd"); 
    120116                        boost::shared_ptr<session> sess(new session()); 
    121117                        sess->authenticate(cb.dbase().lookup_user(user), pass); 

  • http/compose.cc

    r4c34ee2 r751fac6  
    9696        void compose::reload_action(boost::shared_ptr<request> req, 
    9797                                    tlate::data_model::ptr am, 
    98                                     std::multimap<std::string,std::string> &fb, 
    9998                                    std::string error_message) 
    10099        { 
    101                 typedef std::multimap<std::string,std::string>::const_iterator  
    102                         cit_type; 
     100                typedef request::form_data_iterator cit_type; 
    103101                std::pair<cit_type, cit_type> its; 
    104102 
    105103                if (!error_message.empty()) 
    106104                        am->insert("error", html::quote(error_message, false)); 
    107                 am->insert("subject", lookup(fb, "subject")); 
    108                 am->insert("references", lookup(fb, "references")); 
    109                 am->insert("body", lookup(fb, "body")); 
     105                am->insert("subject", req->get_form_field("subject")); 
     106                am->insert("references", req->get_form_field("references")); 
     107                am->insert("body", req->get_form_field("body")); 
    110108                    
    111109                std::list<std::string> ngs; 
    112                 its = fb.equal_range("newsgroups"); 
     110                its = req->get_form_fields("newsgroups"); 
    113111                for (cit_type it = its.first; it != its.second; it++) 
    114112                        ngs.push_back(it->second); 
    115113 
    116114                std::list<std::string> fus; 
    117                 its = fb.equal_range("followups"); 
     115                its = req->get_form_fields("followups"); 
    118116                for (cit_type it = its.first; it != its.second; it++) 
    119117                        fus.push_back(it->second); 
    … …  
    123121 
    124122        void compose::post_action(boost::shared_ptr<request> req, 
    125                                   tlate::data_model::ptr am, 
    126                                   std::multimap<std::string,std::string> &fb) 
     123                                  tlate::data_model::ptr am) 
    127124        { 
    128125                std::ostringstream os; 
    … …  
    141138                os << "Newsgroups: "; 
    142139                bool first = true; 
    143                 its = fb.equal_range("newsgroups"); 
     140                its = req->get_form_fields("newsgroups"); 
    144141                for (cit_type it = its.first; it != its.second; it++) 
    145142                { 
    … …  
    150147                os << "\r\n"; 
    151148 
    152                 its = fb.equal_range("followups"); 
     149                its = req->get_form_fields("followups"); 
    153150                if (its.first != its.second) 
    154151                { 
    … …  
    165162 
    166163                os << "Subject: " 
    167                    << msg::encode_unstructured(lookup(fb, "subject"))  
     164                   << msg::encode_unstructured(req->get_form_field("subject"))  
    168165                   << "\r\n"; 
    169166 
    170                 std::string refs = lookup(fb, "references"); 
     167                std::string refs = req->get_form_field("references"); 
    171168                if (!refs.empty()) 
    172169                { 
    … …  
    180177                        " format=flowed; delsp=yes"; 
    181178 
    182                 msg::text_plain tp(msg::crlf_canonize(lookup(fb, "body")), 
     179                msg::text_plain tp(msg::crlf_canonize(req->get_form_field("body")), 
    183180                                   msg::content_type(content_type)); 
    184181 
    … …  
    235232                catch (std::exception &e) 
    236233                { 
    237                         return reload_action(req, am, fb, e.what()); 
     234                        return reload_action(req, am, e.what()); 
    238235                } 
    239236                logger::logline ll; 
    … …  
    266263                } 
    267264 
    268                 std::multimap<std::string,std::string> fb =  
    269                         req->get_form_data(); 
    270                 std::map<std::string,std::string>::const_iterator fbit; 
    271  
    272                 fbit = fb.find("post_button"); 
    273                 if (fbit != fb.end())  
     265                if (req->has_form_field("post_button")) 
    274266                { 
    275267                        if (req->get_method() == "POST") 
    276                                 return post_action(req, am, fb); 
     268                                return post_action(req, am); 
    277269                        else 
    278                                 return reload_action(req, am, fb); 
    279                 } 
    280  
    281                 fbit = fb.find("group"); 
    282                 if (fbit != fb.end()) 
     270                                return reload_action(req, am); 
     271                } 
     272 
     273                if (req->has_form_field("group")) 
    283274                { 
    284275                        boost::shared_ptr<db::group> group; 
    285276                        try 
    286277                        { 
    287                                 group = cb.dbase().lookup_group(fbit->second); 
     278                                group = cb.dbase().lookup_group 
     279                                        (req->get_form_field("group")); 
    288280                        } 
    289281                        catch (db::no_such_group) 
    … …  
    291283                                resp.reset(new error_resource 
    292284                                           (cb, "404 No such group " +  
    293                                             fbit->second)); 
     285                                            req->get_form_field("group"))); 
    294286                                throw resource_exception(resp); 
    295287                        } 
    296288                        return new_thread(req, am, group); 
    297289                } 
    298                 fbit = fb.find("precursor"); 
    299                 if (fbit != fb.end()) 
     290 
     291                if (req->has_form_field("precursor")) 
    300292                { 
    301293                        boost::shared_ptr<msg::msg> art; 
     294                        std::string pre = req->get_form_field("precursor"); 
    302295                        try 
    303296                        { 
    304                                 art = cb.dbase().lookup_msgid(fbit->second); 
     297                                art = cb.dbase().lookup_msgid(pre); 
    305298                        } 
    306299                        catch (db::no_such_article) 
    307300                        { 
    308301                                resp.reset(new error_resource 
    309                                            (cb, "404 No such article " +  
    310                                             fbit->second)); 
     302                                           (cb, "404 No such article " + pre)); 
    311303                                throw resource_exception(resp); 
    312304                        } 

  • http/compose.hh

    r868b365 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    3535                void reload_action(boost::shared_ptr<request> req, 
    3636                                   tlate::data_model::ptr, 
    37                                    std::multimap<std::string,std::string> &fb, 
    3837                                   std::string error_message = ""); 
    3938 
    4039                void post_action(boost::shared_ptr<request> req, 
    41                                  tlate::data_model::ptr, 
    42                                  std::multimap<std::string,std::string> &fb); 
     40                                 tlate::data_model::ptr); 
    4341 
    4442                void respond_compose(boost::shared_ptr<request>, 

  • http/error_resource.cc

    r868b365 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    3333                am->insert("host", req->get_host()); 
    3434                std::string rpath = req->get_path(); 
    35                 std::string query = req->get_query_or_body(); 
     35                std::string query = req->get_form_as_query(); 
    3636                if (!query.empty()) rpath += "?" + query; 
    3737                am->insert("path", rpath); 

  • http/markread.cc

    rec0da3f r751fac6  
    5050                } 
    5151 
    52                 std::multimap<std::string,std::string> fd = req->get_form_data(); 
    53                 std::string ajax = lookup(fd, "ajax"); 
    54                 bool value = lookup(fd, "undo") != "yes"; 
    55                 std::string msgid = lookup(fd, "msgid"); 
    56                 ::uri redir = lookup(fd, "redir"); 
     52                std::string ajax = req->get_form_field("ajax"); 
     53                bool value = req->get_form_field("undo") != "yes"; 
     54                std::string msgid = req->get_form_field("msgid"); 
     55                ::uri redir = req->get_form_field("redir"); 
    5756                redir.replace_query_param("markread","no"); 
    5857 

  • http/passwd.cc

    rcc0a570 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    5454                std::string (*const dep)(std::string) = uri::percent_decode; 
    5555 
    56                 std::multimap<std::string,std::string> fb =  
    57                         req->get_form_data(); 
    58                 std::string uid = dep(lookup(fb, "userid")); 
    59                 std::string pw1 = dep(lookup(fb, "password")); 
    60                 std::string pw2 = dep(lookup(fb, "repass")); 
    61                 std::string tokstr = dep(lookup(fb, "token")); 
     56                std::string uid = dep(req->get_form_field("userid")); 
     57                std::string pw1 = dep(req->get_form_field("password")); 
     58                std::string pw2 = dep(req->get_form_field("repass")); 
     59                std::string tokstr = dep(req->get_form_field("token")); 
    6260                 
    6361                boost::shared_ptr<token> &tok = cb.get_http_token(tokstr); 
    … …  
    176174                } 
    177175 
    178                 std::multimap<std::string,std::string> fb =  
    179                         req->get_form_data(); 
    180  
    181176                std::string tokstr; 
    182177                boost::shared_ptr<token> tok; 
    … …  
    224219                am->insert("accept_charlist", q("utf8",false)); 
    225220 
    226                 std::string errmsg = dep(lookup(fb, "msg")); 
     221                std::string errmsg = dep(req->get_form_field("msg")); 
    227222                if (!errmsg.empty())  
    228223                        am->insert("errmsg", q(errmsg, false)); 

  • http/recovered.cc

    rcc0a570 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    5757                std::string (*const dep)(std::string) = uri::percent_decode; 
    5858 
    59                 std::multimap<std::string,std::string> fb = 
    60                         req->get_form_data(); 
    61                 std::string user = dep(lookup(fb, "userid")); 
     59                std::string user = dep(req->get_form_field("userid")); 
    6260                am->insert("userid", q(user,false)); 
    6361        } 

  • http/recovery.cc

    rcc0a570 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    8080//              std::string (*const dep)(std::string) = uri::percent_decode; 
    8181 
    82                 std::multimap<std::string,std::string> fb = 
    83                         req->get_form_data(); 
    84  
    85                 std::string user = lookup(fb, "userid"); 
     82                std::string user = req->get_form_field("userid"); 
    8683                boost::shared_ptr<db::user> u = cb.dbase().lookup_user(user); 
    8784                if (u) 

  • http/reguser.cc

    rcc0a570 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    5656                void reload_action(boost::shared_ptr<request> req, 
    5757                                   tlate::data_model::ptr, 
    58                                    std::multimap<std::string,std::string> &fb, 
    5958                                   std::string error_message = ""); 
    6059 
    6160                void post_action(boost::shared_ptr<request> req, 
    62                                  tlate::data_model::ptr, 
    63                                  std::multimap<std::string,std::string> &fb); 
     61                                 tlate::data_model::ptr); 
    6462        }; 
    6563 
    66         void reguser::reload_action(boost::shared_ptr<request>, 
     64        void reguser::reload_action(boost::shared_ptr<request> req, 
    6765                                    tlate::data_model::ptr am, 
    68                                     std::multimap<std::string,std::string> &fb, 
    6966                                    std::string error_message) 
    7067        { 
    7168                if (!error_message.empty()) 
    7269                        am->insert("error", html::quote(error_message, false)); 
    73                 am->insert("userid", lookup(fb, "userid")); 
     70                am->insert("userid", req->get_form_field("userid")); 
    7471        } 
    7572 
    7673        void reguser::post_action(boost::shared_ptr<request> req, 
    77                                   tlate::data_model::ptr am, 
    78                                   std::multimap<std::string,std::string> &fb) 
     74                                  tlate::data_model::ptr am) 
    7975        { 
    8076                boost::random_device rand; 
    8177                std::string (*const pd)(std::string) = uri::percent_decode; 
    8278 
    83                 std::string pw1 = lookup(fb, "passwd"); 
    84                 std::string pw2 = lookup(fb, "repass"); 
     79                std::string pw1 = req->get_form_field("passwd"); 
     80                std::string pw2 = req->get_form_field("repass"); 
    8581 
    8682                std::string err = db::user::passwd_problems(pw1); 
    … …  
    8985                if (!err.empty()) 
    9086                { 
    91                         reload_action(req, am, fb, err); 
     87                        reload_action(req, am, err); 
    9288                        return; 
    9389                } 
    9490 
    95                 std::string uid = pd(lookup(fb, "userid")); 
     91                std::string uid = pd(req->get_form_field("userid")); 
    9692                if (uid.find_first_of("\t ") != std::string::npos) 
    9793                { 
    98                         reload_action(req, am, fb, 
     94                        reload_action(req, am, 
    9995                                      "User id should not contain whitespace."); 
    10096                        return; 
    … …  
    104100                try 
    105101                { 
    106                         u = cb.dbase().create_user(pd(lookup(fb, "userid")), 
     102                        u = cb.dbase().create_user(pd(req->get_form_field("userid")), 
    107103                                                   pw1); 
    108104                } 
    109105                catch (db::user_exists) 
    110106                { 
    111                         reload_action(req, am, fb,  
     107                        reload_action(req, am,  
    112108                                      "That user id is not available."); 
    113109                        return; 
    … …  
    115111 
    116112                boost::shared_ptr<session> sess(new session()); 
    117                 sess->authenticate(u, lookup(fb, "passwd")); 
     113                sess->authenticate(u, req->get_form_field("passwd")); 
    118114 
    119115                boost::shared_ptr<resource> rr 
    … …  
    131127                        throw resource_exception(resp); 
    132128                } 
    133                 std::multimap<std::string,std::string> fb =  
    134                         req->get_form_data(); 
    135  
    136129                if (req->is_authenticated()) 
    137130                { 
    138                         reload_action(req, am, fb, 
     131                        reload_action(req, am, 
    139132                                      "You must log out before" 
    140133                                      " you can continue registration"); 
    … …  
    142135                } 
    143136 
    144                 std::map<std::string,std::string>::const_iterator fbit; 
    145  
    146                 fbit = fb.find("regbut"); 
    147                 if (fbit != fb.end()) 
     137                if (req->has_form_field("regbut")) 
    148138                { 
    149139                        if (req->get_method() == "POST") 
    150                                 post_action(req, am, fb); 
     140                                post_action(req, am); 
    151141                        else 
    152                                 reload_action(req, am, fb); 
     142                                reload_action(req, am); 
    153143                } 
    154144 

  • http/request.cc

    r868b365 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    5353                         boost::asio::ip::address peer) 
    5454                : cb(cb), peer(peer), v11(true), close(false) 
     55                , form_data_ready(false) 
    5556        { 
    5657                typedef bad_request fv; 
    … …  
    108109                        if (v11 && token == "close") close = true; 
    109110                } 
     111 
     112        } 
     113 
     114        void request::parse_form() const 
     115        { 
     116                if (form_data_ready) return; 
     117                if (method != "POST" || 
     118                    get_header("content-type") 
     119                    == "application/x-www-form-urlencoded") 
     120                { 
     121                        std::string bd = method == "POST" 
     122                                ? body 
     123                                : uri.get_query(); 
     124                        while (!bd.empty()) 
     125                        { 
     126                                std::string entry = util::split1R(bd, "&"); 
     127                                for (size_t i = 0; i < entry.length(); i++) 
     128                                        if (entry[i] == '+') entry[i] = ' '; 
     129                                std::string name = util::split1R(entry, "="); 
     130                                name = uri::percent_decode(name); 
     131                                entry = uri::percent_decode(entry); 
     132                                form_data.insert(std::make_pair(name, entry)); 
     133                        } 
     134                } 
     135                form_data_ready = true; 
     136        } 
     137 
     138        std::string request::get_form_as_query() const 
     139        { 
     140                if (!form_data_ready) parse_form(); 
     141                std::string rv; 
     142                for (std::multimap<std::string, std::string>::const_iterator it 
     143                             = form_data.begin(); 
     144                     it != form_data.end(); it++) 
     145                { 
     146                        std::string name = uri::percent_encode(it->first); 
     147                        std::string value = uri::percent_encode(it->second); 
     148                        if (!rv.empty()) rv += '&'; 
     149                        rv += name; 
     150                        rv += "="; 
     151                        rv += value; 
     152                } 
     153                return rv; 
    110154        } 
    111155 
    … …  
    117161                if (it == header.end()) return ""; 
    118162                return it->second; 
    119         } 
    120  
    121         std::string request::get_query_or_body() const 
    122         { 
    123                 if (method == "POST") 
    124                 { 
    125                         std::string ct = get_header("content-type"); 
    126                         util::strip(ct); 
    127                         if (ct != "application/x-www-form-urlencoded") 
    128                                 std::cerr << "FIXME get_query_or_body: " << ct 
    129                                           << std::endl; 
    130                         return body; 
    131                 } 
    132                 else 
    133                 { 
    134                         return uri.get_query(); 
    135                 } 
    136         } 
    137  
    138         std::multimap<std::string,std::string> request::get_form_data() const 
    139         { 
    140                 std::multimap<std::string, std::string> rv; 
    141  
    142                 std::string bd = get_query_or_body(); 
    143                 while (!bd.empty()) 
    144                 { 
    145                         std::string entry = util::split1R(bd, "&"); 
    146                         for (size_t i = 0; i < entry.length(); i++) 
    147                                 if (entry[i] == '+') entry[i] = ' '; 
    148                         std::string name = util::split1R(entry, "="); 
    149                         name = uri::percent_decode(name); 
    150                         entry = uri::percent_decode(entry); 
    151                         rv.insert(std::make_pair(name, entry)); 
    152                 } 
    153                 return rv; 
    154163        } 
    155164 
    … …  
    241250                } 
    242251                if (sessid.empty() || !cb.get_session(sessid)) return ""; 
    243                 std::multimap<std::string,std::string> fd = get_form_data(); 
    244                 std::string fd_session = lookup(fd, "alue_sessid"); 
     252                std::string fd_session = get_form_field("alue_sessid"); 
    245253                if (method != "POST" && !fd_session.empty()) 
    246254                { 

  • http/request.hh

    ra7da244 r751fac6  
    3434        { 
    3535        public: 
     36                typedef std::multimap<std::string,std::string>::const_iterator 
     37                form_data_iterator; 
     38 
    3639                request(std::string, server::conn_cb cb, 
    3740                        boost::asio::ip::address); 
    … …  
    3942                bool get_close() const { return close; } 
    4043 
    41                 void body_append(std::string b) { body += b; } 
     44                void body_append(std::string b) { 
     45                        form_data_ready = false; 
     46                        body += b; 
     47                } 
    4248                std::string get_body() const { return body; } 
    43  
    44                 std::multimap<std::string,std::string> get_form_data() const; 
    4549 
    4650                bool has_body() const { 
    … …  
    5660                int get_port() const { return port; } 
    5761                std::string get_path() const { return uri.get_path(); } 
    58                 std::string get_query() const { return uri.get_query(); } 
    5962 
    60                 std::string get_query_param(std::string name) const { 
    61                         return uri.get_query_param(name); 
     63                std::string get_form_field(std::string name) const; 
     64                bool has_form_field(std::string name) const; 
     65                std::pair<form_data_iterator,form_data_iterator> 
     66                get_form_fields(std::string name) const { 
     67                        if (!form_data_ready) parse_form(); 
     68                        return form_data.equal_range(name); 
    6269                } 
     70 
     71                std::string get_form_as_query() const; 
    6372                 
    6473                std::string get_header(std::string s) const; 
    65  
    66                 std::string get_query_or_body() const; 
    6774 
    6875                std::string logbit() const { 
    … …  
    9198                int port; 
    9299                std::string body; 
     100                mutable bool form_data_ready; 
     101                mutable std::multimap<std::string,std::string> form_data; 
    93102 
    94103                void parse_header(std::string); 
     104                void parse_form() const; 
    95105        }; 
    96106 
    97107        inline 
    98         std::string lookup(const std::multimap<std::string, std::string> &mm,  
    99                            std::string k) 
     108        std::string request::get_form_field(std::string k) const 
    100109        { 
     110                if (!form_data_ready) parse_form(); 
    101111                std::multimap<std::string, std::string>::const_iterator it  
    102                         = mm.find(k); 
    103                 if (it == mm.end()) 
     112                        = form_data.find(k); 
     113                if (it == form_data.end()) 
    104114                { 
    105115                        return ""; 
    … …  
    107117                return it->second; 
    108118        } 
     119        inline 
     120        bool request::has_form_field(std::string k) const 
     121        { 
     122                if (!form_data_ready) parse_form(); 
     123                std::multimap<std::string, std::string>::const_iterator it  
     124                        = form_data.find(k); 
     125                return it != form_data.end(); 
     126        } 
    109127} 
    110128 

  • http/smanage.cc

    rd0c602a r751fac6  
    5151                void reload_action(boost::shared_ptr<request>, 
    5252                                   tlate::data_model::ptr, 
    53                                    std::multimap<std::string,std::string> &fb, 
    5453                                   std::string error_message = ""); 
    5554 
    5655                void post_action(boost::shared_ptr<request> req, 
    57                                  tlate::data_model::ptr, 
    58                                  std::multimap<std::string,std::string> &fb); 
     56                                 tlate::data_model::ptr); 
    5957        }; 
    6058 
    6159        void smanage::reload_action(boost::shared_ptr<request> req, 
    6260                                    tlate::data_model::ptr am, 
    63                                     std::multimap<std::string,std::string> &fb, 
    6461                                    std::string error_message) 
    6562        { 
    66                 typedef std::multimap<std::string,std::string>::const_iterator  
    67                         cit_type; 
    68                 std::pair<cit_type, cit_type> its; 
    69  
    7063                if (!error_message.empty()) 
    7164                        am->insert("error", html::quote(error_message, false)); 
    72                 am->insert("diname", lookup(fb, "diname")); 
    73                 am->insert("diaddr", lookup(fb, "diaddr")); 
    74                 std::string deaddr = lookup(fb, "deaddr"); 
     65                am->insert("diname", req->get_form_field("diname")); 
     66                am->insert("diaddr", req->get_form_field("diaddr")); 
     67                std::string deaddr = req->get_form_field("deaddr"); 
    7568                am->insert("deaddr", deaddr); 
    7669                db::user::ptr u = req->get_session()->get_user(); 
    … …  
    8174                        am->insert("verify"); 
    8275 
    83                 if (fb.find("allow_clear") != fb.end()) 
    84                         am->insert("allow_clear", lookup(fb, "allow_clear")); 
     76                if (req->has_form_field("allow_clear")) 
     77                        am->insert("allow_clear", 
     78                                   req->get_form_field("allow_clear")); 
    8579        } 
    8680 
    8781        void smanage::post_action(boost::shared_ptr<request> req, 
    88                                   tlate::data_model::ptr am, 
    89                                   std::multimap<std::string,std::string> &fb) 
     82                                  tlate::data_model::ptr am) 
    9083        { 
    9184                std::string (*const pd)(std::string) = uri::percent_decode; 
    … …  
    9386                boost::shared_ptr<db::user> u = req->get_session()->get_user(); 
    9487 
    95                 u->set_display_name(pd(lookup(fb, "diname"))); 
    96                 u->set_display_email(pd(lookup(fb, "diaddr"))); 
    97                 if (u->set_delivery_email(pd(lookup(fb, "deaddr")))) { 
     88                u->set_display_name(pd(req->get_form_field("diname"))); 
     89                u->set_display_email(pd(req->get_form_field("diaddr"))); 
     90                if (u->set_delivery_email(pd(req->get_form_field("deaddr")))) { 
    9891                        u->send_delivery_email_cookie 
    9992                                (cb, req->get_peer().to_string()); 
    10093                } 
    10194                u->set_allow_cleartext_password 
    102                         (fb.find("allow_clear") != fb.end()); 
    103                 reload_action(req, am, fb, "Saved."); 
     95                        (req->has_form_field("allow_clear")); 
     96                reload_action(req, am, "Saved."); 
    10497        } 
    10598 
    … …  
    121114                } 
    122115 
    123                 std::multimap<std::string,std::string> fb =  
    124                         req->get_form_data(); 
    125                 std::map<std::string,std::string>::const_iterator fbit_ch; 
    126                 std::map<std::string,std::string>::const_iterator fbit_ve; 
    127  
    128                 fbit_ch = fb.find("change_button"); 
    129                 fbit_ve = fb.find("verify_button"); 
    130                 if (fbit_ch != fb.end())  
     116                if (req->has_form_field("change_button")) 
    131117                { 
    132118                        if (req->get_method() == "POST") 
    133                                 post_action(req, am, fb); 
     119                                post_action(req, am); 
    134120                        else 
    135                                 reload_action(req, am, fb); 
     121                                reload_action(req, am); 
    136122                         
    137123                } 
    138                 else if (fbit_ve != fb.end()) 
     124                else if (req->has_form_field("verify_button")) 
    139125                { 
    140126                        boost::shared_ptr<db::user> u = 
    … …  
    144130                                u->send_delivery_email_cookie 
    145131                                        (cb, req->get_peer().to_string()); 
    146                                 reload_action(req, am, fb, 
     132                                reload_action(req, am, 
    147133                                              "Verification email has been " 
    148134                                              "sent to " + 
    … …  
    150136                        } 
    151137                        else 
    152                                 reload_action(req, am, fb); 
     138                                reload_action(req, am); 
    153139                } 
    154140                else 
    … …  
    166152                        if (u->allow_cleartext_password()) 
    167153                                am->insert("allow_clear", 
    168                                            lookup(fb, "allow_clear")); 
     154                                           req->get_form_field("allow_clear")); 
    169155                } 
    170156 

  • http/sub.cc

    r4c34ee2 r751fac6  
    5050        (boost::shared_ptr<request> req, response::factory) 
    5151        { 
    52                 std::multimap<std::string,std::string> fb =  
    53                         req->get_form_data(); 
    54                 std::string redir = lookup(fb, "redir"); 
     52                std::string redir = req->get_form_field("redir"); 
    5553                if (redir.empty()) 
    5654                { 
    … …  
    8179                try 
    8280                { 
    83                         gr = cb.dbase().lookup_group(lookup(fb, "group")); 
     81                        gr = cb.dbase().lookup_group(req->get_form_field("group")); 
    8482                } 
    8583                catch (db::no_such_group) 
    8684                { 
    8785                        logger::logline ll; 
    88                         ll << "no such group " << lookup(fb, "group"); 
     86                        ll << "no such group " << req->get_form_field("group"); 
    8987                        throw resource_exception(resp); 
    9088                } 

  • http/threads.cc

    r299b297 r751fac6  
    11/*  This file is part of Alue, the multiprotocol Internet discussion daemon 
    22 
    3     Copyright © 2009 Antti-Juhani Kaijanaho 
     3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho 
    44 
    55    Alue is free software: you can redistribute it and/or modify it 
    … …  
    7878                } 
    7979 
    80                 std::multimap<std::string,std::string> fb =  
    81                         req->get_form_data(); 
    82                 bool only_summary = lookup(fb, "summary") == "true"; 
     80                bool only_summary = req->get_form_field("summary") == "true"; 
    8381 
    8482                am->insert("group", new tlate::group_value(gr, u));