author | Michael Krelin <hacker@klever.net> | 2008-02-03 15:29:07 (UTC) |
---|---|---|
committer | Michael Krelin <hacker@klever.net> | 2008-02-03 15:29:07 (UTC) |
commit | 23a6d48436e24d3d145b742984ef68ec3bae2bfd (patch) (unidiff) | |
tree | 9cd085f583f4235e4f21e640cfc1b1ab1fb04b06 | |
parent | d1c45af16b3bd31f65d03eec0fcd1c61b4d69fb0 (diff) | |
download | libopkele-23a6d48436e24d3d145b742984ef68ec3bae2bfd.zip libopkele-23a6d48436e24d3d145b742984ef68ec3bae2bfd.tar.gz libopkele-23a6d48436e24d3d145b742984ef68ec3bae2bfd.tar.bz2 |
added provisions for discovery on RP
Signed-off-by: Michael Krelin <hacker@klever.net>
-rw-r--r-- | include/opkele/discovery.h | 5 | ||||
-rw-r--r-- | lib/discovery.cc | 45 |
2 files changed, 39 insertions, 11 deletions
diff --git a/include/opkele/discovery.h b/include/opkele/discovery.h index 677d7bb..4471597 100644 --- a/include/opkele/discovery.h +++ b/include/opkele/discovery.h | |||
@@ -1,112 +1,115 @@ | |||
1 | #ifndef __OPKELE_DISCOVERY_H | 1 | #ifndef __OPKELE_DISCOVERY_H |
2 | #define __OPKELE_DISCOVERY_H | 2 | #define __OPKELE_DISCOVERY_H |
3 | 3 | ||
4 | #include <string> | 4 | #include <string> |
5 | #include <opkele/types.h> | 5 | #include <opkele/types.h> |
6 | #include <opkele/basic_rp.h> | ||
7 | 6 | ||
8 | namespace opkele { | 7 | namespace opkele { |
9 | using std::string; | 8 | using std::string; |
10 | 9 | ||
11 | namespace xrd { | 10 | namespace xrd { |
12 | 11 | ||
13 | struct priority_compare { | 12 | struct priority_compare { |
14 | inline bool operator()(long a,long b) const { | 13 | inline bool operator()(long a,long b) const { |
15 | return (a<0) ? false : (b<0) ? true : (a<b); | 14 | return (a<0) ? false : (b<0) ? true : (a<b); |
16 | } | 15 | } |
17 | }; | 16 | }; |
18 | 17 | ||
19 | template <typename _DT> | 18 | template <typename _DT> |
20 | class priority_map : public multimap<long,_DT,priority_compare> { | 19 | class priority_map : public multimap<long,_DT,priority_compare> { |
21 | typedef multimap<long,_DT,priority_compare> map_type; | 20 | typedef multimap<long,_DT,priority_compare> map_type; |
22 | public: | 21 | public: |
23 | 22 | ||
24 | inline _DT& add(long priority,const _DT& d) { | 23 | inline _DT& add(long priority,const _DT& d) { |
25 | return insert(typename map_type::value_type(priority,d))->second; | 24 | return insert(typename map_type::value_type(priority,d))->second; |
26 | } | 25 | } |
27 | 26 | ||
28 | bool has_value(const _DT& d) const { | 27 | bool has_value(const _DT& d) const { |
29 | for(typename map_type::const_iterator i=this->begin();i!=this->end();++i) | 28 | for(typename map_type::const_iterator i=this->begin();i!=this->end();++i) |
30 | if(i->second==d) return true; | 29 | if(i->second==d) return true; |
31 | return false; | 30 | return false; |
32 | } | 31 | } |
33 | }; | 32 | }; |
34 | 33 | ||
35 | typedef priority_map<string> canonical_ids_t; | 34 | typedef priority_map<string> canonical_ids_t; |
36 | typedef priority_map<string> local_ids_t; | 35 | typedef priority_map<string> local_ids_t; |
37 | typedef set<string> types_t; | 36 | typedef set<string> types_t; |
38 | struct uri_t { | 37 | struct uri_t { |
39 | string uri; | 38 | string uri; |
40 | string append; | 39 | string append; |
41 | 40 | ||
42 | uri_t() { } | 41 | uri_t() { } |
43 | uri_t(const string& u) : uri(u) { } | 42 | uri_t(const string& u) : uri(u) { } |
44 | uri_t(const string& u,const string& a) : uri(u), append(a) { } | 43 | uri_t(const string& u,const string& a) : uri(u), append(a) { } |
45 | }; | 44 | }; |
46 | typedef priority_map<uri_t> uris_t; | 45 | typedef priority_map<uri_t> uris_t; |
47 | 46 | ||
48 | class service_t { | 47 | class service_t { |
49 | public: | 48 | public: |
50 | types_t types; | 49 | types_t types; |
51 | uris_t uris; | 50 | uris_t uris; |
52 | local_ids_t local_ids; | 51 | local_ids_t local_ids; |
53 | string provider_id; | 52 | string provider_id; |
54 | 53 | ||
55 | void clear() { | 54 | void clear() { |
56 | types.clear(); | 55 | types.clear(); |
57 | uris.clear(); local_ids.clear(); | 56 | uris.clear(); local_ids.clear(); |
58 | provider_id.clear(); | 57 | provider_id.clear(); |
59 | } | 58 | } |
60 | }; | 59 | }; |
61 | typedef priority_map<service_t> services_t; | 60 | typedef priority_map<service_t> services_t; |
62 | 61 | ||
63 | class XRD_t { | 62 | class XRD_t { |
64 | public: | 63 | public: |
65 | time_t expires; | 64 | time_t expires; |
66 | 65 | ||
67 | canonical_ids_t canonical_ids; | 66 | canonical_ids_t canonical_ids; |
68 | local_ids_t local_ids; | 67 | local_ids_t local_ids; |
69 | services_t services; | 68 | services_t services; |
70 | string provider_id; | 69 | string provider_id; |
71 | 70 | ||
72 | void clear() { | 71 | void clear() { |
73 | expires = 0; | 72 | expires = 0; |
74 | canonical_ids.clear(); local_ids.clear(); | 73 | canonical_ids.clear(); local_ids.clear(); |
75 | services.clear(); | 74 | services.clear(); |
76 | provider_id.clear(); | 75 | provider_id.clear(); |
77 | } | 76 | } |
78 | bool empty() const { | 77 | bool empty() const { |
79 | return | 78 | return |
80 | canonical_ids.empty() | 79 | canonical_ids.empty() |
81 | && local_ids.empty() | 80 | && local_ids.empty() |
82 | && services.empty(); | 81 | && services.empty(); |
83 | } | 82 | } |
84 | 83 | ||
85 | }; | 84 | }; |
86 | 85 | ||
87 | } | 86 | } |
88 | 87 | ||
89 | typedef util::output_iterator_proxy<openid_endpoint_t> | 88 | typedef util::output_iterator_proxy<openid_endpoint_t> |
90 | endpoint_discovery_iterator; | 89 | endpoint_discovery_iterator; |
91 | 90 | ||
92 | string idiscover( | 91 | string idiscover( |
93 | endpoint_discovery_iterator oi, | 92 | endpoint_discovery_iterator oi, |
94 | const string& identity); | 93 | const string& identity); |
94 | void yadiscover( | ||
95 | endpoint_discovery_iterator oi, | ||
96 | const string& yurl, | ||
97 | const char **types, bool redirs=false); | ||
95 | 98 | ||
96 | struct idiscovery_t { | 99 | struct idiscovery_t { |
97 | bool xri_identity; | 100 | bool xri_identity; |
98 | string normalized_id; | 101 | string normalized_id; |
99 | string canonicalized_id; | 102 | string canonicalized_id; |
100 | xrd::XRD_t xrd; | 103 | xrd::XRD_t xrd; |
101 | 104 | ||
102 | idiscovery_t() { } | 105 | idiscovery_t() { } |
103 | 106 | ||
104 | void clear() { | 107 | void clear() { |
105 | normalized_id.clear(); canonicalized_id.clear(); | 108 | normalized_id.clear(); canonicalized_id.clear(); |
106 | xrd.clear(); | 109 | xrd.clear(); |
107 | } | 110 | } |
108 | 111 | ||
109 | }; | 112 | }; |
110 | } | 113 | } |
111 | 114 | ||
112 | #endif /* __OPKELE_DISCOVERY_H */ | 115 | #endif /* __OPKELE_DISCOVERY_H */ |
diff --git a/lib/discovery.cc b/lib/discovery.cc index 6e20654..6f58339 100644 --- a/lib/discovery.cc +++ b/lib/discovery.cc | |||
@@ -1,328 +1,345 @@ | |||
1 | #include <list> | 1 | #include <list> |
2 | #include <opkele/curl.h> | 2 | #include <opkele/curl.h> |
3 | #include <opkele/expat.h> | 3 | #include <opkele/expat.h> |
4 | #include <opkele/uris.h> | 4 | #include <opkele/uris.h> |
5 | #include <opkele/discovery.h> | 5 | #include <opkele/discovery.h> |
6 | #include <opkele/exception.h> | 6 | #include <opkele/exception.h> |
7 | #include <opkele/util.h> | 7 | #include <opkele/util.h> |
8 | #include <opkele/tidy.h> | 8 | #include <opkele/tidy.h> |
9 | #include <opkele/debug.h> | 9 | #include <opkele/debug.h> |
10 | 10 | ||
11 | #include "config.h" | 11 | #include "config.h" |
12 | 12 | ||
13 | #define XRDS_HEADER "X-XRDS-Location" | 13 | #define XRDS_HEADER "X-XRDS-Location" |
14 | #define CT_HEADER "Content-Type" | 14 | #define CT_HEADER "Content-Type" |
15 | 15 | ||
16 | namespace opkele { | 16 | namespace opkele { |
17 | using std::list; | 17 | using std::list; |
18 | using xrd::XRD_t; | 18 | using xrd::XRD_t; |
19 | using xrd::service_t; | 19 | using xrd::service_t; |
20 | 20 | ||
21 | /* TODO: the whole discovery thing needs cleanup and optimization due to | 21 | /* TODO: the whole discovery thing needs cleanup and optimization due to |
22 | * many changes of concept. */ | 22 | * many changes of concept. */ |
23 | 23 | ||
24 | static const char *whitespace = " \t\r\n"; | 24 | static const char *whitespace = " \t\r\n"; |
25 | static const char *i_leaders = "=@+$!("; | 25 | static const char *i_leaders = "=@+$!("; |
26 | static const size_t max_html = 16384; | 26 | static const size_t max_html = 16384; |
27 | 27 | ||
28 | static const struct service_type_t { | 28 | static const struct service_type_t { |
29 | const char *uri; | 29 | const char *uri; |
30 | const char *forceid; | 30 | const char *forceid; |
31 | } service_types[] = { | 31 | } op_service_types[] = { |
32 | { STURI_OPENID20_OP, IDURI_SELECT20 }, | 32 | { STURI_OPENID20_OP, IDURI_SELECT20 }, |
33 | { STURI_OPENID20, 0 }, | 33 | { STURI_OPENID20, 0 }, |
34 | { STURI_OPENID11, 0 }, | 34 | { STURI_OPENID11, 0 }, |
35 | { STURI_OPENID10, 0 } | 35 | { STURI_OPENID10, 0 } |
36 | }; | 36 | }; |
37 | enum { | 37 | enum { |
38 | st_index_1 = 2, st_index_2 = 1 | 38 | st_index_1 = 2, st_index_2 = 1 |
39 | }; | 39 | }; |
40 | 40 | ||
41 | 41 | ||
42 | static inline bool is_qelement(const XML_Char *n,const char *qen) { | 42 | static inline bool is_qelement(const XML_Char *n,const char *qen) { |
43 | return !strcasecmp(n,qen); | 43 | return !strcasecmp(n,qen); |
44 | } | 44 | } |
45 | static inline bool is_element(const XML_Char *n,const char *en) { | 45 | static inline bool is_element(const XML_Char *n,const char *en) { |
46 | if(!strcasecmp(n,en)) return true; | 46 | if(!strcasecmp(n,en)) return true; |
47 | int nl = strlen(n), enl = strlen(en); | 47 | int nl = strlen(n), enl = strlen(en); |
48 | if( (nl>=(enl+1)) && n[nl-enl-1]=='\t' | 48 | if( (nl>=(enl+1)) && n[nl-enl-1]=='\t' |
49 | && !strcasecmp(&n[nl-enl],en) ) | 49 | && !strcasecmp(&n[nl-enl],en) ) |
50 | return true; | 50 | return true; |
51 | return false; | 51 | return false; |
52 | } | 52 | } |
53 | 53 | ||
54 | static long element_priority(const XML_Char **a) { | 54 | static long element_priority(const XML_Char **a) { |
55 | for(;*a;++a) | 55 | for(;*a;++a) |
56 | if(!strcasecmp(*(a++),"priority")) { | 56 | if(!strcasecmp(*(a++),"priority")) { |
57 | long rv; | 57 | long rv; |
58 | return (sscanf(*a,"%ld",&rv)==1)?rv:-1; | 58 | return (sscanf(*a,"%ld",&rv)==1)?rv:-1; |
59 | } | 59 | } |
60 | return -1; | 60 | return -1; |
61 | } | 61 | } |
62 | /* TODO: ideally all attributes should be | 62 | /* TODO: ideally all attributes should be |
63 | * retrieved in one run */ | 63 | * retrieved in one run */ |
64 | static const char *element_attr(const XML_Char **a, const char *at) { | 64 | static const char *element_attr(const XML_Char **a, const char *at) { |
65 | for(;*a;++a) | 65 | for(;*a;++a) |
66 | if(!strcasecmp(*(a++),at)) { | 66 | if(!strcasecmp(*(a++),at)) { |
67 | return *a; | 67 | return *a; |
68 | } | 68 | } |
69 | return 0; | 69 | return 0; |
70 | } | 70 | } |
71 | 71 | ||
72 | class idigger_t : public util::curl_t, public util::expat_t { | 72 | class idigger_t : public util::curl_t, public util::expat_t { |
73 | public: | 73 | public: |
74 | string xri_proxy; | 74 | string xri_proxy; |
75 | 75 | ||
76 | enum { | 76 | enum { |
77 | xmode_html = 1, xmode_xrd = 2, xmode_cid = 4 | 77 | xmode_html = 1, xmode_xrd = 2, xmode_cid = 4, |
78 | xmode_noredirs = 8 | ||
78 | }; | 79 | }; |
79 | int xmode; | 80 | int xmode; |
80 | 81 | ||
81 | string xrds_location; | 82 | string xrds_location; |
82 | string http_content_type; | 83 | string http_content_type; |
83 | service_t html_openid1; | 84 | service_t html_openid1; |
84 | service_t html_openid2; | 85 | service_t html_openid2; |
85 | string cdata_buf; | 86 | string cdata_buf; |
86 | long status_code; | 87 | long status_code; |
87 | string status_string; | 88 | string status_string; |
88 | 89 | ||
89 | typedef list<string> pt_stack_t; | 90 | typedef list<string> pt_stack_t; |
90 | pt_stack_t pt_stack; | 91 | pt_stack_t pt_stack; |
91 | int skipping; | 92 | int skipping; |
92 | bool parser_choked; | 93 | bool parser_choked; |
93 | string save_html; | 94 | string save_html; |
94 | 95 | ||
95 | XRD_t *xrd; | 96 | XRD_t *xrd; |
96 | service_t *xrd_service; | 97 | service_t *xrd_service; |
97 | string* cdata; | 98 | string* cdata; |
98 | 99 | ||
99 | idigger_t() | 100 | idigger_t() |
100 | : util::curl_t(easy_init()), | 101 | : util::curl_t(easy_init()), |
101 | util::expat_t(0), | 102 | util::expat_t(0), |
102 | xri_proxy(XRI_PROXY_URL) { | 103 | xri_proxy(XRI_PROXY_URL) { |
103 | CURLcode r; | 104 | CURLcode r; |
104 | (r=misc_sets()) | 105 | (r=misc_sets()) |
105 | || (r=set_write()) | 106 | || (r=set_write()) |
106 | || (r=set_header()) | 107 | || (r=set_header()) |
107 | ; | 108 | ; |
108 | if(r) | 109 | if(r) |
109 | throw exception_curl(OPKELE_CP_ "failed to set curly options",r); | 110 | throw exception_curl(OPKELE_CP_ "failed to set curly options",r); |
110 | } | 111 | } |
111 | ~idigger_t() throw() { } | 112 | ~idigger_t() throw() { } |
112 | 113 | ||
114 | void yadiscover(endpoint_discovery_iterator oi,const string& yurl,const char **types,bool redirs) { | ||
115 | idiscovery_t idis; | ||
116 | idis.xri_identity = false; | ||
117 | discover_at(idis,yurl,xmode_html|xmode_xrd|(redirs?0:xmode_noredirs)); | ||
118 | if(!xrds_location.empty()) { | ||
119 | idis.clear(); | ||
120 | discover_at(idis,xrds_location,xmode_xrd); | ||
121 | } | ||
122 | idis.normalized_id = idis.canonicalized_id = yurl; | ||
123 | service_type_t st; | ||
124 | for(st.uri=*types;*types;st.uri=*(++types)) | ||
125 | queue_endpoints(oi,idis,&st); | ||
126 | } | ||
127 | |||
113 | string discover(endpoint_discovery_iterator& oi,const string& identity) { | 128 | string discover(endpoint_discovery_iterator& oi,const string& identity) { |
114 | string rv; | 129 | string rv; |
115 | idiscovery_t idis; | 130 | idiscovery_t idis; |
116 | string::size_type fsc = identity.find_first_not_of(whitespace); | 131 | string::size_type fsc = identity.find_first_not_of(whitespace); |
117 | if(fsc==string::npos) | 132 | if(fsc==string::npos) |
118 | throw bad_input(OPKELE_CP_ "whitespace-only identity"); | 133 | throw bad_input(OPKELE_CP_ "whitespace-only identity"); |
119 | string::size_type lsc = identity.find_last_not_of(whitespace); | 134 | string::size_type lsc = identity.find_last_not_of(whitespace); |
120 | assert(lsc!=string::npos); | 135 | assert(lsc!=string::npos); |
121 | if(!strncasecmp(identity.c_str()+fsc,"xri://",sizeof("xri://")-1)) | 136 | if(!strncasecmp(identity.c_str()+fsc,"xri://",sizeof("xri://")-1)) |
122 | fsc += sizeof("xri://")-1; | 137 | fsc += sizeof("xri://")-1; |
123 | if((fsc+1)>=lsc) | 138 | if((fsc+1)>=lsc) |
124 | throw bad_input(OPKELE_CP_ "not a character of importance in identity"); | 139 | throw bad_input(OPKELE_CP_ "not a character of importance in identity"); |
125 | string id(identity,fsc,lsc-fsc+1); | 140 | string id(identity,fsc,lsc-fsc+1); |
126 | idis.clear(); | 141 | idis.clear(); |
127 | if(strchr(i_leaders,id[0])) { | 142 | if(strchr(i_leaders,id[0])) { |
128 | /* TODO: further normalize xri identity? Like folding case | 143 | /* TODO: further normalize xri identity? Like folding case |
129 | * or whatever... */ | 144 | * or whatever... */ |
130 | rv = id; | 145 | rv = id; |
131 | set<string> cids; | 146 | set<string> cids; |
132 | for(const struct service_type_t *st=service_types; | 147 | for(const struct service_type_t *st=op_service_types; |
133 | st<&service_types[sizeof(service_types)/sizeof(*service_types)];++st) { | 148 | st<&op_service_types[sizeof(op_service_types)/sizeof(*op_service_types)];++st) { |
134 | idis.clear(); | 149 | idis.clear(); |
135 | discover_at( idis, | 150 | discover_at( idis, |
136 | xri_proxy + util::url_encode(id)+ | 151 | xri_proxy + util::url_encode(id)+ |
137 | "?_xrd_t="+util::url_encode(st->uri)+ | 152 | "?_xrd_t="+util::url_encode(st->uri)+ |
138 | "&_xrd_r=application/xrd%2Bxml" | 153 | "&_xrd_r=application/xrd%2Bxml" |
139 | ";sep=true;refs=true", | 154 | ";sep=true;refs=true", |
140 | xmode_xrd ); | 155 | xmode_xrd ); |
141 | if(status_code==241) continue; | 156 | if(status_code==241) continue; |
142 | if(status_code!=100) | 157 | if(status_code!=100) |
143 | throw failed_xri_resolution(OPKELE_CP_ | 158 | throw failed_xri_resolution(OPKELE_CP_ |
144 | "XRI resolution failed with '"+status_string+"' message" | 159 | "XRI resolution failed with '"+status_string+"' message" |
145 | ", while looking for SEP with type '"+st->uri+"'", status_code); | 160 | ", while looking for SEP with type '"+st->uri+"'", status_code); |
146 | if(idis.xrd.canonical_ids.empty()) | 161 | if(idis.xrd.canonical_ids.empty()) |
147 | throw opkele::failed_discovery(OPKELE_CP_ "No CanonicalID found for XRI identity found"); | 162 | throw opkele::failed_discovery(OPKELE_CP_ "No CanonicalID found for XRI identity found"); |
148 | string cid = idis.xrd.canonical_ids.begin()->second; | 163 | string cid = idis.xrd.canonical_ids.begin()->second; |
149 | if(cids.find(cid)==cids.end()) { | 164 | if(cids.find(cid)==cids.end()) { |
150 | cids.insert(cid); | 165 | cids.insert(cid); |
151 | idis.clear(); | 166 | idis.clear(); |
152 | discover_at( idis, | 167 | discover_at( idis, |
153 | xri_proxy + util::url_encode(id)+ | 168 | xri_proxy + util::url_encode(id)+ |
154 | "?_xrd_t="+util::url_encode(st->uri)+ | 169 | "?_xrd_t="+util::url_encode(st->uri)+ |
155 | "&_xrd_r=application/xrd%2Bxml" | 170 | "&_xrd_r=application/xrd%2Bxml" |
156 | ";sep=true;refs=true", | 171 | ";sep=true;refs=true", |
157 | xmode_xrd ); | 172 | xmode_xrd ); |
158 | if(status_code==241) continue; | 173 | if(status_code==241) continue; |
159 | if(status_code!=100) | 174 | if(status_code!=100) |
160 | throw failed_xri_resolution(OPKELE_CP_ | 175 | throw failed_xri_resolution(OPKELE_CP_ |
161 | "XRI resolution failed with '"+status_string+"' message" | 176 | "XRI resolution failed with '"+status_string+"' message" |
162 | ", while looking for SEP with type '"+st->uri+"'" | 177 | ", while looking for SEP with type '"+st->uri+"'" |
163 | " on canonical id", status_code); | 178 | " on canonical id", status_code); |
164 | } | 179 | } |
165 | idis.canonicalized_id = cid; | 180 | idis.canonicalized_id = cid; |
166 | idis.normalized_id = rv; idis.xri_identity = true; | 181 | idis.normalized_id = rv; idis.xri_identity = true; |
167 | queue_endpoints(oi,idis,st); | 182 | queue_endpoints(oi,idis,st); |
168 | } | 183 | } |
169 | }else{ | 184 | }else{ |
170 | idis.xri_identity = false; | 185 | idis.xri_identity = false; |
171 | if(id.find("://")==string::npos) | 186 | if(id.find("://")==string::npos) |
172 | id.insert(0,"http://"); | 187 | id.insert(0,"http://"); |
173 | string::size_type fp = id.find('#'); | 188 | string::size_type fp = id.find('#'); |
174 | if(fp!=string::npos) { | 189 | if(fp!=string::npos) { |
175 | string::size_type qp = id.find('?'); | 190 | string::size_type qp = id.find('?'); |
176 | if(qp==string::npos || qp<fp) | 191 | if(qp==string::npos || qp<fp) |
177 | id.erase(fp); | 192 | id.erase(fp); |
178 | else if(qp>fp) | 193 | else if(qp>fp) |
179 | id.erase(fp,qp-fp); | 194 | id.erase(fp,qp-fp); |
180 | } | 195 | } |
181 | rv = idis.normalized_id = util::rfc_3986_normalize_uri(id); | 196 | rv = idis.normalized_id = util::rfc_3986_normalize_uri(id); |
182 | discover_at(idis,id,xmode_html|xmode_xrd); | 197 | discover_at(idis,id,xmode_html|xmode_xrd); |
183 | const char * eu = 0; | 198 | const char * eu = 0; |
184 | CURLcode r = easy_getinfo(CURLINFO_EFFECTIVE_URL,&eu); | 199 | CURLcode r = easy_getinfo(CURLINFO_EFFECTIVE_URL,&eu); |
185 | if(r) | 200 | if(r) |
186 | throw exception_curl(OPKELE_CP_ "failed to get CURLINFO_EFFECTIVE_URL",r); | 201 | throw exception_curl(OPKELE_CP_ "failed to get CURLINFO_EFFECTIVE_URL",r); |
187 | string cid = util::strip_uri_fragment_part( idis.canonicalized_id = util::rfc_3986_normalize_uri(eu) ); | 202 | string cid = util::strip_uri_fragment_part( idis.canonicalized_id = util::rfc_3986_normalize_uri(eu) ); |
188 | if(xrds_location.empty()) { | 203 | if(xrds_location.empty()) { |
189 | html2xrd(oi,idis); | 204 | html2xrd(oi,idis); |
190 | }else{ | 205 | }else{ |
191 | idis.clear(); | 206 | idis.clear(); |
192 | idis.canonicalized_id = cid; | 207 | idis.canonicalized_id = cid; |
193 | discover_at(idis,xrds_location,xmode_xrd); | 208 | discover_at(idis,xrds_location,xmode_xrd); |
194 | if(idis.xrd.empty()) | 209 | if(idis.xrd.empty()) |
195 | html2xrd(oi,idis); | 210 | html2xrd(oi,idis); |
196 | else{ | 211 | else{ |
197 | for(const service_type_t *st=service_types; | 212 | for(const service_type_t *st=op_service_types; |
198 | st<&service_types[sizeof(service_types)/sizeof(*service_types)];++st) | 213 | st<&op_service_types[sizeof(op_service_types)/sizeof(*op_service_types)];++st) |
199 | queue_endpoints(oi,idis,st); | 214 | queue_endpoints(oi,idis,st); |
200 | } | 215 | } |
201 | } | 216 | } |
202 | } | 217 | } |
203 | return rv; | 218 | return rv; |
204 | } | 219 | } |
205 | 220 | ||
206 | void discover_at(idiscovery_t& idis,const string& url,int xm) { | 221 | void discover_at(idiscovery_t& idis,const string& url,int xm) { |
207 | CURLcode r = easy_setopt(CURLOPT_URL,url.c_str()); | 222 | CURLcode r = easy_setopt(CURLOPT_MAXREDIRS, (xm&xmode_noredirs)?0:5); |
208 | if(r) | 223 | if(r) |
209 | throw exception_curl(OPKELE_CP_ "failed to set culry urlie",r); | 224 | throw exception_curl(OPKELE_CP_ "failed to set curly maxredirs option"); |
225 | if( (r=easy_setopt(CURLOPT_URL,url.c_str())) ) | ||
226 | throw exception_curl(OPKELE_CP_ "failed to set curly urlie",r); | ||
210 | 227 | ||
211 | http_content_type.clear(); | 228 | http_content_type.clear(); |
212 | xmode = xm; | 229 | xmode = xm; |
213 | prepare_to_parse(); | 230 | prepare_to_parse(); |
214 | if(xmode&xmode_html) { | 231 | if(xmode&xmode_html) { |
215 | xrds_location.clear(); | 232 | xrds_location.clear(); |
216 | save_html.clear(); | 233 | save_html.clear(); |
217 | save_html.reserve(max_html); | 234 | save_html.reserve(max_html); |
218 | } | 235 | } |
219 | xrd = &idis.xrd; | 236 | xrd = &idis.xrd; |
220 | 237 | ||
221 | r = easy_perform(); | 238 | r = easy_perform(); |
222 | if(r && r!=CURLE_WRITE_ERROR) | 239 | if(r && r!=CURLE_WRITE_ERROR) |
223 | throw exception_curl(OPKELE_CP_ "failed to perform curly request",r); | 240 | throw exception_curl(OPKELE_CP_ "failed to perform curly request",r); |
224 | 241 | ||
225 | if(!parser_choked) { | 242 | if(!parser_choked) { |
226 | parse(0,0,true); | 243 | parse(0,0,true); |
227 | }else{ | 244 | }else{ |
228 | /* TODO: do not bother if we've seen xml */ | 245 | /* TODO: do not bother if we've seen xml */ |
229 | try { | 246 | try { |
230 | util::tidy_doc_t td = util::tidy_doc_t::create(); | 247 | util::tidy_doc_t td = util::tidy_doc_t::create(); |
231 | if(!td) | 248 | if(!td) |
232 | throw exception_tidy(OPKELE_CP_ "failed to create htmltidy document"); | 249 | throw exception_tidy(OPKELE_CP_ "failed to create htmltidy document"); |
233 | #ifndef NDEBUG | 250 | #ifndef NDEBUG |
234 | td.opt_set(TidyQuiet,false); | 251 | td.opt_set(TidyQuiet,false); |
235 | td.opt_set(TidyShowWarnings,false); | 252 | td.opt_set(TidyShowWarnings,false); |
236 | #endif /* NDEBUG */ | 253 | #endif /* NDEBUG */ |
237 | td.opt_set(TidyForceOutput,true); | 254 | td.opt_set(TidyForceOutput,true); |
238 | td.opt_set(TidyXhtmlOut,true); | 255 | td.opt_set(TidyXhtmlOut,true); |
239 | td.opt_set(TidyDoctypeMode,TidyDoctypeOmit); | 256 | td.opt_set(TidyDoctypeMode,TidyDoctypeOmit); |
240 | td.opt_set(TidyMark,false); | 257 | td.opt_set(TidyMark,false); |
241 | if(td.parse_string(save_html)<=0) | 258 | if(td.parse_string(save_html)<=0) |
242 | throw exception_tidy(OPKELE_CP_ "tidy failed to parse document"); | 259 | throw exception_tidy(OPKELE_CP_ "tidy failed to parse document"); |
243 | if(td.clean_and_repair()<=0) | 260 | if(td.clean_and_repair()<=0) |
244 | throw exception_tidy(OPKELE_CP_ "tidy failed to clean and repair"); | 261 | throw exception_tidy(OPKELE_CP_ "tidy failed to clean and repair"); |
245 | util::tidy_buf_t tide; | 262 | util::tidy_buf_t tide; |
246 | if(td.save_buffer(tide)<=0) | 263 | if(td.save_buffer(tide)<=0) |
247 | throw exception_tidy(OPKELE_CP_ "tidy failed to save buffer"); | 264 | throw exception_tidy(OPKELE_CP_ "tidy failed to save buffer"); |
248 | prepare_to_parse(); | 265 | prepare_to_parse(); |
249 | parse(tide.c_str(),tide.size(),true); | 266 | parse(tide.c_str(),tide.size(),true); |
250 | }catch(exception_tidy& et) { } | 267 | }catch(exception_tidy& et) { } |
251 | } | 268 | } |
252 | save_html.clear(); | 269 | save_html.clear(); |
253 | } | 270 | } |
254 | 271 | ||
255 | void prepare_to_parse() { | 272 | void prepare_to_parse() { |
256 | (*(expat_t*)this) = parser_create_ns(); | 273 | (*(expat_t*)this) = parser_create_ns(); |
257 | set_user_data(); set_element_handler(); | 274 | set_user_data(); set_element_handler(); |
258 | set_character_data_handler(); | 275 | set_character_data_handler(); |
259 | 276 | ||
260 | if(xmode&xmode_html) { | 277 | if(xmode&xmode_html) { |
261 | html_openid1.clear(); html_openid2.clear(); | 278 | html_openid1.clear(); html_openid2.clear(); |
262 | parser_choked = false; | 279 | parser_choked = false; |
263 | } | 280 | } |
264 | 281 | ||
265 | cdata = 0; xrd_service = 0; skipping = 0; | 282 | cdata = 0; xrd_service = 0; skipping = 0; |
266 | pt_stack.clear(); | 283 | pt_stack.clear(); |
267 | status_code = 100; status_string.clear(); | 284 | status_code = 100; status_string.clear(); |
268 | } | 285 | } |
269 | 286 | ||
270 | void html2xrd(endpoint_discovery_iterator& oi,idiscovery_t& id) { | 287 | void html2xrd(endpoint_discovery_iterator& oi,idiscovery_t& id) { |
271 | XRD_t& x = id.xrd; | 288 | XRD_t& x = id.xrd; |
272 | if(!html_openid2.uris.empty()) { | 289 | if(!html_openid2.uris.empty()) { |
273 | html_openid2.types.insert(STURI_OPENID20); | 290 | html_openid2.types.insert(STURI_OPENID20); |
274 | x.services.add(-1,html_openid2); | 291 | x.services.add(-1,html_openid2); |
275 | queue_endpoints(oi,id,&service_types[st_index_2]); | 292 | queue_endpoints(oi,id,&op_service_types[st_index_2]); |
276 | } | 293 | } |
277 | if(!html_openid1.uris.empty()) { | 294 | if(!html_openid1.uris.empty()) { |
278 | html_openid1.types.insert(STURI_OPENID11); | 295 | html_openid1.types.insert(STURI_OPENID11); |
279 | x.services.add(-1,html_openid1); | 296 | x.services.add(-1,html_openid1); |
280 | queue_endpoints(oi,id,&service_types[st_index_1]); | 297 | queue_endpoints(oi,id,&op_service_types[st_index_1]); |
281 | } | 298 | } |
282 | } | 299 | } |
283 | 300 | ||
284 | size_t write(void *p,size_t s,size_t nm) { | 301 | size_t write(void *p,size_t s,size_t nm) { |
285 | /* TODO: limit total size */ | 302 | /* TODO: limit total size */ |
286 | size_t bytes = s*nm; | 303 | size_t bytes = s*nm; |
287 | const char *inbuf = (const char*)p; | 304 | const char *inbuf = (const char*)p; |
288 | if(xmode&xmode_html) { | 305 | if(xmode&xmode_html) { |
289 | size_t mbts = save_html.capacity()-save_html.size(); | 306 | size_t mbts = save_html.capacity()-save_html.size(); |
290 | size_t bts = 0; | 307 | size_t bts = 0; |
291 | if(mbts>0) { | 308 | if(mbts>0) { |
292 | bts = (bytes>mbts)?mbts:bytes; | 309 | bts = (bytes>mbts)?mbts:bytes; |
293 | save_html.append(inbuf,bts); | 310 | save_html.append(inbuf,bts); |
294 | } | 311 | } |
295 | if(skipping<0) return bts; | 312 | if(skipping<0) return bts; |
296 | } | 313 | } |
297 | if(skipping<0) return 0; | 314 | if(skipping<0) return 0; |
298 | bool rp = parse(inbuf,bytes,false); | 315 | bool rp = parse(inbuf,bytes,false); |
299 | if(!rp) { | 316 | if(!rp) { |
300 | parser_choked = true; | 317 | parser_choked = true; |
301 | skipping = -1; | 318 | skipping = -1; |
302 | if(!(xmode&xmode_html)) | 319 | if(!(xmode&xmode_html)) |
303 | bytes = 0; | 320 | bytes = 0; |
304 | } | 321 | } |
305 | return bytes; | 322 | return bytes; |
306 | } | 323 | } |
307 | size_t header(void *p,size_t s,size_t nm) { | 324 | size_t header(void *p,size_t s,size_t nm) { |
308 | size_t bytes = s*nm; | 325 | size_t bytes = s*nm; |
309 | const char *h = (const char*)p; | 326 | const char *h = (const char*)p; |
310 | const char *colon = (const char*)memchr(p,':',bytes); | 327 | const char *colon = (const char*)memchr(p,':',bytes); |
311 | const char *space = (const char*)memchr(p,' ',bytes); | 328 | const char *space = (const char*)memchr(p,' ',bytes); |
312 | if(space && ( (!colon) || space<colon ) ) { | 329 | if(space && ( (!colon) || space<colon ) ) { |
313 | xrds_location.clear(); http_content_type.clear(); | 330 | xrds_location.clear(); http_content_type.clear(); |
314 | }else if(colon) { | 331 | }else if(colon) { |
315 | const char *hv = ++colon; | 332 | const char *hv = ++colon; |
316 | int hnl = colon-h; | 333 | int hnl = colon-h; |
317 | int rb; | 334 | int rb; |
318 | for(rb = bytes-hnl-1;rb>0 && isspace(*hv);++hv,--rb); | 335 | for(rb = bytes-hnl-1;rb>0 && isspace(*hv);++hv,--rb); |
319 | while(rb>0 && isspace(hv[rb-1])) --rb; | 336 | while(rb>0 && isspace(hv[rb-1])) --rb; |
320 | if(rb) { | 337 | if(rb) { |
321 | if( (hnl>=sizeof(XRDS_HEADER)) | 338 | if( (hnl>=sizeof(XRDS_HEADER)) |
322 | && !strncasecmp(h,XRDS_HEADER":", | 339 | && !strncasecmp(h,XRDS_HEADER":", |
323 | sizeof(XRDS_HEADER)) ) { | 340 | sizeof(XRDS_HEADER)) ) { |
324 | xrds_location.assign(hv,rb); | 341 | xrds_location.assign(hv,rb); |
325 | }else if( (hnl>=sizeof(CT_HEADER)) | 342 | }else if( (hnl>=sizeof(CT_HEADER)) |
326 | && !strncasecmp(h,CT_HEADER":", | 343 | && !strncasecmp(h,CT_HEADER":", |
327 | sizeof(CT_HEADER)) ) { | 344 | sizeof(CT_HEADER)) ) { |
328 | const char *sc = (const char*)memchr( | 345 | const char *sc = (const char*)memchr( |
@@ -504,49 +521,57 @@ namespace opkele { | |||
504 | } | 521 | } |
505 | }else if(is_element(n,"body")) { | 522 | }else if(is_element(n,"body")) { |
506 | skipping = -1; | 523 | skipping = -1; |
507 | } | 524 | } |
508 | } | 525 | } |
509 | 526 | ||
510 | void queue_endpoints(endpoint_discovery_iterator& oi, | 527 | void queue_endpoints(endpoint_discovery_iterator& oi, |
511 | const idiscovery_t &id, | 528 | const idiscovery_t &id, |
512 | const service_type_t *st) { | 529 | const service_type_t *st) { |
513 | openid_endpoint_t ep; | 530 | openid_endpoint_t ep; |
514 | ep.claimed_id = id.canonicalized_id; | 531 | ep.claimed_id = id.canonicalized_id; |
515 | for(xrd::services_t::const_iterator isvc=id.xrd.services.begin(); | 532 | for(xrd::services_t::const_iterator isvc=id.xrd.services.begin(); |
516 | isvc!=id.xrd.services.end(); ++isvc) { | 533 | isvc!=id.xrd.services.end(); ++isvc) { |
517 | const xrd::service_t svc = isvc->second; | 534 | const xrd::service_t svc = isvc->second; |
518 | if(svc.types.find(st->uri)==svc.types.end()) continue; | 535 | if(svc.types.find(st->uri)==svc.types.end()) continue; |
519 | for(xrd::uris_t::const_iterator iu=svc.uris.begin();iu!=svc.uris.end();++iu) { | 536 | for(xrd::uris_t::const_iterator iu=svc.uris.begin();iu!=svc.uris.end();++iu) { |
520 | ep.uri = iu->second.uri; | 537 | ep.uri = iu->second.uri; |
521 | if(id.xri_identity) { | 538 | if(id.xri_identity) { |
522 | if(iu->second.append=="qxri") { | 539 | if(iu->second.append=="qxri") { |
523 | ep.uri += id.normalized_id; | 540 | ep.uri += id.normalized_id; |
524 | } /* TODO: else handle other append attribute values */ | 541 | } /* TODO: else handle other append attribute values */ |
525 | } | 542 | } |
526 | if(st->forceid) { | 543 | if(st->forceid) { |
527 | ep.local_id = ep.claimed_id = st->forceid; | 544 | ep.local_id = ep.claimed_id = st->forceid; |
528 | *(oi++) = ep; | 545 | *(oi++) = ep; |
529 | }else{ | 546 | }else{ |
530 | if(svc.local_ids.empty()) { | 547 | if(svc.local_ids.empty()) { |
531 | ep.local_id = ep.claimed_id; | 548 | ep.local_id = ep.claimed_id; |
532 | *(oi++) = ep; | 549 | *(oi++) = ep; |
533 | }else{ | 550 | }else{ |
534 | for(xrd::local_ids_t::const_iterator ilid=svc.local_ids.begin(); | 551 | for(xrd::local_ids_t::const_iterator ilid=svc.local_ids.begin(); |
535 | ilid!=svc.local_ids.end(); ++ilid) { | 552 | ilid!=svc.local_ids.end(); ++ilid) { |
536 | ep.local_id = ilid->second; | 553 | ep.local_id = ilid->second; |
537 | *(oi++) = ep; | 554 | *(oi++) = ep; |
538 | } | 555 | } |
539 | } | 556 | } |
540 | } | 557 | } |
541 | } | 558 | } |
542 | } | 559 | } |
543 | } | 560 | } |
544 | 561 | ||
545 | }; | 562 | }; |
546 | 563 | ||
547 | string idiscover(endpoint_discovery_iterator oi,const string& identity) { | 564 | string idiscover(endpoint_discovery_iterator oi,const string& identity) { |
548 | idigger_t idigger; | 565 | idigger_t idigger; |
549 | return idigger.discover(oi,identity); | 566 | return idigger.discover(oi,identity); |
550 | } | 567 | } |
551 | 568 | ||
569 | void yadiscover(endpoint_discovery_iterator oi,const string& yurl,const char **types,bool redirs) try { | ||
570 | idigger_t idigger; | ||
571 | idigger.yadiscover(oi,yurl,types,redirs); | ||
572 | }catch(exception_curl& ec) { | ||
573 | if(redirs || ec._error!=CURLE_TOO_MANY_REDIRECTS) | ||
574 | throw; | ||
575 | } | ||
576 | |||
552 | } | 577 | } |