1 files changed, 2 insertions, 4 deletions

diff --git a/lib/sreg.cc b/lib/sreg.cc
index b40cd45..0bd4d2e 100644
--- a/lib/sreg.cc
+++ b/lib/sreg.cc
@@ -1,159 +1,157 @@
 #include <opkele/exception.h>
 #include <opkele/sreg.h>
 #include <opkele/uris.h>
 #include <algorithm>
 
 namespace opkele {
     using std::find;
 
     static const struct _sreg_field {
         const char *fieldname;
         sreg_t::fieldbit_t fieldbit;
             }fields[] = {
         { "nickname", sreg_t::field_nickname },
         { "email", sreg_t::field_email },
         { "fullname", sreg_t::field_fullname },
         { "dob", sreg_t::field_dob },
         { "gender", sreg_t::field_gender },
         { "postcode", sreg_t::field_postcode },
         { "country", sreg_t::field_country },
         { "language", sreg_t::field_language },
         { "timezone", sreg_t::field_timezone }
     };
         #   define fields_BEGINfields
 #   define fields_END &fields[sizeof(fields)/sizeof(*fields)]
     typedef const struct _sreg_field *fields_iterator;
 
     bool operator==(const struct _sreg_field& fd,const string& fn) {
         return fd.fieldname==fn;
     }
 
     void sreg_t::rp_checkid_hook(basic_openid_message& om) {
         string fr, fo;
         for(fields_iterator f=fields_BEGIN;f<fields_END;++f) {
             if(f->fieldbit&fields_required) {
                 if(!fr.empty()) fr+=",";
                 fr += f->fieldname;
             }
             if(f->fieldbit&fields_optional) {
                 if(!fo.empty()) fo+=",";
                 fo += f->fieldname;
             }
         }
         string pfx = om.allocate_ns(OIURI_SREG11,"sreg");
         if(!fr.empty()) om.set_field(pfx+".required",fr);
         if(!fo.empty()) om.set_field(pfx+".optional",fo);
         if(!policy_url.empty()) om.set_field(pfx+".policy_url",policy_url);
     }
 
     void sreg_t::checkid_hook(basic_openid_message& om) {
         rp_checkid_hook(om); }
 
     void sreg_t::rp_id_res_hook(const basic_openid_message& om,
             const basic_openid_message& sp) {
         clear();
         string pfx;
         try {
             pfx = om.find_ns(OIURI_SREG11,"sreg");
-        }catch(failed_lookup& fl) {
+        }catch(failed_lookup&) {
             try {
                 pfx = om.find_ns(OIURI_SREG10,"sreg");
-            }catch(failed_lookup& fl) {
-                return;
-            }
+            }catch(failed_lookup&) { return; }
         }
         pfx += '.';
         for(fields_iterator f=fields_BEGIN;f<fields_END;++f) {
             string fn = pfx; fn+=f->fieldname;
             if(!sp.has_field(fn)) continue;
             has_fields |= f->fieldbit;
             response[f->fieldbit]=sp.get_field(fn);
         }
     }
 
     void sreg_t::id_res_hook(const basic_openid_message& om,
             const basic_openid_message& sp) {
         rp_id_res_hook(om,sp); }
 
     const string& sreg_t::get_field(fieldbit_t fb) const {
         response_t::const_iterator i = response.find(fb);
         if(i==response.end())
             throw failed_lookup(OPKELE_CP_ "no field data available");
         return i->second;
     }
 
     void sreg_t::set_field(fieldbit_t fb,const string& fv) {
         response[fb] = fv;
         has_fields |= fb;
     }
 
     void sreg_t::reset_field(fieldbit_t fb) {
         has_fields &= ~fb;
         response.erase(fb);
     }
 
     void sreg_t::clear() {
         has_fields = 0; response.clear();
     }
 
     static long fields_list_to_bitmask(string& fl) {
         long rv = 0;
         while(!fl.empty()) {
             string::size_type co = fl.find(',');
             string fn;
             if(co==string::npos) {
                 fn = fl; fl.erase();
             }else{
                 fn = fl.substr(0,co); fl.erase(0,co+1);
             }
             fields_iterator f = find(fields_BEGIN,fields_END,fn);
             if(f!=fields_END)
                 rv |= f->fieldbit;
         }
         return rv;
     }
 
     void sreg_t::op_checkid_hook(const basic_openid_message& inm) {
         string ins = inm.find_ns(OIURI_SREG11,"sreg");
         fields_optional = 0; fields_required = 0; policy_url.erase();
         fields_response = 0;
         try {
             string fl = inm.get_field(ins+".required");
             fields_required = fields_list_to_bitmask(fl);
         }catch(failed_lookup&) { }
         try {
             string fl = inm.get_field(ins+".optional");
             fields_optional = fields_list_to_bitmask(fl);
         }catch(failed_lookup&) { }
         try {
             policy_url = inm.get_field(ins+".policy_url");
         }catch(failed_lookup&) { }
     }
 
     void sreg_t::op_id_res_hook(basic_openid_message& oum) {
         string ons = oum.allocate_ns(OIURI_SREG11,"sreg");
         fields_response &= has_fields;
         string signeds = "ns."+ons;
         for(fields_iterator f=fields_BEGIN;f<fields_END;++f) {
             if(!(f->fieldbit&fields_response)) continue;
             signeds +=',';
             string pn = ons; pn += '.'; pn += f->fieldname;
             signeds += pn;
             oum.set_field(pn,get_field(f->fieldbit));
         }
         oum.add_to_signed(signeds);
     }
 
     void sreg_t::checkid_hook(const basic_openid_message& inm,
             basic_openid_message& oum) {
         op_checkid_hook(inm);
         setup_response(inm,oum);
         op_id_res_hook(oum);
     }
 
     void sreg_t::setup_response(const basic_openid_message& /* inm */,basic_openid_message& /* oum */) {
         setup_response();
     }
     void sreg_t::setup_response() {
         fields_response = (fields_required|fields_optional)&has_fields;
     }