summaryrefslogtreecommitdiffabout
path: root/include/opkele
Side-by-side diff
Diffstat (limited to 'include/opkele') (more/less context) (ignore whitespace changes)
-rw-r--r--include/opkele/basic_op.h2
-rw-r--r--include/opkele/expat.h16
-rw-r--r--include/opkele/iterator.h19
-rw-r--r--include/opkele/types.h1
4 files changed, 20 insertions, 18 deletions
diff --git a/include/opkele/basic_op.h b/include/opkele/basic_op.h
index 0326508..12306dd 100644
--- a/include/opkele/basic_op.h
+++ b/include/opkele/basic_op.h
@@ -1,112 +1,114 @@
#ifndef __OPKELE_BASIC_OP_H
#define __OPKELE_BASIC_OP_H
#include <string>
#include <opkele/types.h>
#include <opkele/extension.h>
namespace opkele {
using std::string;
/**
* Implementation of basic OP functionality
*/
class basic_OP {
public:
/**
* The request mode for the request being processed
*/
mode_t mode;
/**
* association used in transaction. reset in case of dumb operation
*/
assoc_t assoc;
/**
* true if the request is openid2 request
*/
bool openid2;
/**
* The return_to RP endpoint
*/
string return_to;
/**
* The realm we authenticate for
*/
string realm;
/**
* Claimed identifier
*/
string claimed_id;
/**
* The OP-Local identifier
*/
string identity;
/**
* The invalidate handle for the reply request
*/
string invalidate_handle;
+ virtual ~basic_OP() { }
+
void reset_vars();
/**
* @name Request information access
* Setting and retrieval of the information pertaining to the request being processed
* @{
*/
/**
* Check if the RP expects us to get back to them.
* @return true if RP supplied return_to URL
*/
bool has_return_to() const;
/**
* Find out where the RP is waiting for us.
* @return the return_to URL supplied
* @throw no_return_to if no return_to is supplied with the request
*/
const string& get_return_to() const;
/**
* Find out what realm we are authenticating user for
* @return the realm
*/
const string& get_realm() const;
/**
* Check if request is about identity
* @return true if so
*/
bool has_identity() const;
/**
* Get claimed identifier supplied with the request
* @return claimed identifier
* @throw non_identity if request is not about identity
*/
const string& get_claimed_id() const;
/**
* Get the identity (OP-Local identifier) being confirmed
* @return identity
* @throw non_identity if request is not about identity
*/
const string& get_identity() const;
/**
* Is identifier supposed to be selected on our side?
* @return true if identity is a special identifier select URI
*/
bool is_id_select() const;
/**
* Select the identity for identifier select request
* @param cid claimed identifier
* @param lid local identifier
*/
void select_identity(const string& cid,const string& lid);
/**
* Set claimed identifier (for instance if it's supposed to have
* fragment part)
* @param cid claimed identifier
*/
void set_claimed_id(const string& cid);
/**
* @}
*/
diff --git a/include/opkele/expat.h b/include/opkele/expat.h
index 60c41ac..3ab1630 100644
--- a/include/opkele/expat.h
+++ b/include/opkele/expat.h
@@ -1,91 +1,91 @@
#ifndef __OPKELE_EXPAT_H
#define __OPKELE_EXPAT_H
#include <cassert>
#include <expat.h>
namespace opkele {
namespace util {
class expat_t {
public:
XML_Parser _x;
expat_t() : _x(0) { }
expat_t(XML_Parser x) : _x(x) { }
virtual ~expat_t() throw();
expat_t& operator=(XML_Parser x);
operator const XML_Parser(void) const { return _x; }
operator XML_Parser(void) { return _x; }
inline bool parse(const char *s,int len,bool final=false) {
assert(_x);
return XML_Parse(_x,s,len,final);
}
- virtual void start_element(const XML_Char *n,const XML_Char **a) { }
- virtual void end_element(const XML_Char *n) { }
+ virtual void start_element(const XML_Char * /* n */,const XML_Char ** /* a */) { }
+ virtual void end_element(const XML_Char * /* n */) { }
void set_element_handler();
- virtual void character_data(const XML_Char *s,int l) { }
+ virtual void character_data(const XML_Char * /* s */,int /* l */) { }
void set_character_data_handler();
- virtual void processing_instruction(const XML_Char *t,const XML_Char *d) { }
+ virtual void processing_instruction(const XML_Char * /* t */,const XML_Char * /* d */) { }
void set_processing_instruction_handler();
- virtual void comment(const XML_Char *d) { }
+ virtual void comment(const XML_Char * /* d */) { }
void set_comment_handler();
virtual void start_cdata_section() { }
virtual void end_cdata_section() { }
void set_cdata_section_handler();
- virtual void default_handler(const XML_Char *s,int l) { }
+ virtual void default_handler(const XML_Char * /* s */,int /* l */) { }
void set_default_handler();
void set_default_handler_expand();
- virtual void start_namespace_decl(const XML_Char *p,const XML_Char *u) { }
- virtual void end_namespace_decl(const XML_Char *p) { }
+ virtual void start_namespace_decl(const XML_Char * /* p */,const XML_Char * /* u */) { }
+ virtual void end_namespace_decl(const XML_Char * /* p */) { }
void set_namespace_decl_handler();
inline enum XML_Error get_error_code() {
assert(_x); return XML_GetErrorCode(_x); }
static inline const XML_LChar *error_string(XML_Error c) {
return XML_ErrorString(c); }
inline long get_current_byte_index() {
assert(_x); return XML_GetCurrentByteIndex(_x); }
inline int get_current_line_number() {
assert(_x); return XML_GetCurrentLineNumber(_x); }
inline int get_current_column_number() {
assert(_x); return XML_GetCurrentColumnNumber(_x); }
inline void set_user_data() {
assert(_x); XML_SetUserData(_x,this); }
inline bool set_base(const XML_Char *b) {
assert(_x); return XML_SetBase(_x,b); }
inline const XML_Char *get_base() {
assert(_x); return XML_GetBase(_x); }
inline int get_specified_attribute_count() {
assert(_x); return XML_GetSpecifiedAttributeCount(_x); }
inline bool set_param_entity_parsing(enum XML_ParamEntityParsing c) {
assert(_x); return XML_SetParamEntityParsing(_x,c); }
inline static XML_Parser parser_create(const XML_Char *e=0) {
return XML_ParserCreate(e); }
inline static XML_Parser parser_create_ns(const XML_Char *e=0,XML_Char s='\t') {
return XML_ParserCreateNS(e,s); }
};
}
}
#endif /* __OPKELE_EXPAT_H */
diff --git a/include/opkele/iterator.h b/include/opkele/iterator.h
index 812a786..28c1c83 100644
--- a/include/opkele/iterator.h
+++ b/include/opkele/iterator.h
@@ -1,217 +1,216 @@
#ifndef __OPKELE_ITERATOR_H
#define __OPKELE_ITERATOR_H
#include <cassert>
#include <iterator>
namespace opkele {
namespace util {
using std::iterator;
using std::forward_iterator_tag;
using std::output_iterator_tag;
template <typename T>
class basic_output_iterator_proxy_impl : public iterator<output_iterator_tag,T,void,T*,T&> {
public:
virtual ~basic_output_iterator_proxy_impl() { }
virtual basic_output_iterator_proxy_impl<T>* dup() const = 0;
basic_output_iterator_proxy_impl<T>& operator*() { return *this; };
virtual basic_output_iterator_proxy_impl<T>& operator=(const T& x) = 0;
};
template<typename IT,typename T=typename IT::value_type>
class output_iterator_proxy_impl : public basic_output_iterator_proxy_impl<T> {
public:
IT i;
- output_iterator_proxy_impl(const IT& i) : i(i) { }
+ output_iterator_proxy_impl(const IT& _i) : i(_i) { }
basic_output_iterator_proxy_impl<T>* dup() const {
return new output_iterator_proxy_impl<IT,T>(i); }
basic_output_iterator_proxy_impl<T>& operator=(const T& x) {
- (*i) = x;
- }
+ (*i) = x; return *this; }
};
template<typename T>
class output_iterator_proxy : public iterator<output_iterator_tag,T,void,T*,T&> {
public:
basic_output_iterator_proxy_impl<T> *I;
template<typename IT>
output_iterator_proxy(const IT& i)
: I(new output_iterator_proxy_impl<IT,T>(i)) { }
output_iterator_proxy(const output_iterator_proxy<T>& x)
: I(x.I->dup()) { }
~output_iterator_proxy() { delete I; }
output_iterator_proxy& operator=(const output_iterator_proxy<T>& x) {
delete I; I = x.I->dup(); }
output_iterator_proxy& operator*() { return *this; }
output_iterator_proxy& operator=(const T& x) {
- (**I) = x; }
+ (**I) = x; return *this; }
output_iterator_proxy& operator++() { return *this; }
output_iterator_proxy& operator++(int) { return *this; }
};
template <typename T,typename TR=T&,typename TP=T*>
class basic_forward_iterator_proxy_impl : public iterator<forward_iterator_tag,T,void,TP,TR> {
public:
virtual ~basic_forward_iterator_proxy_impl() { }
virtual basic_forward_iterator_proxy_impl<T,TR,TP>* dup() const = 0;
virtual bool operator==(const basic_forward_iterator_proxy_impl<T,TR,TP>& x) const = 0;
virtual bool operator!=(const basic_forward_iterator_proxy_impl<T,TR,TP>& x) const {
return !((*this)==x); }
virtual TR operator*() const = 0;
virtual TP operator->() const = 0;
virtual void advance() = 0;
};
template <typename IT>
class forward_iterator_proxy_impl : public basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer> {
public:
IT i;
- forward_iterator_proxy_impl(const IT& i) : i(i) { }
+ forward_iterator_proxy_impl(const IT& _i) : i(_i) { }
virtual basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>* dup() const {
return new forward_iterator_proxy_impl<IT>(i); }
virtual bool operator==(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
return i==static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
virtual bool operator!=(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
return i!=static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
virtual typename IT::reference operator*() const { return *i; }
virtual typename IT::pointer operator->() const { return i.operator->(); }
virtual void advance() { ++i; }
};
template<typename T,typename TR=T&,typename TP=T*>
class forward_iterator_proxy : public iterator<forward_iterator_tag,T,void,TP,TR> {
public:
basic_forward_iterator_proxy_impl<T,TR,TP> *I;
template<typename IT>
forward_iterator_proxy(const IT& i)
: I(new forward_iterator_proxy_impl<IT>(i)) { }
forward_iterator_proxy(const forward_iterator_proxy<T,TR,TP>& x)
: I(x.I->dup()) { }
~forward_iterator_proxy() { delete I; }
forward_iterator_proxy& operator=(const forward_iterator_proxy<T,TR,TP>& x) {
delete I; I = x.I->dup(); }
bool operator==(const forward_iterator_proxy<T,TR,TP>& x) const {
return (*I)==(*(x.I)); }
bool operator!=(const forward_iterator_proxy<T,TR,TP>& x) const {
return (*I)!=(*(x.I)); }
TR operator*() const {
return **I; }
TP operator->() const {
return I->operator->(); }
forward_iterator_proxy<T,TR,TP>& operator++() {
I->advance(); return *this; }
forward_iterator_proxy<T,TR,TP>& operator++(int) {
forward_iterator_proxy<T,TR,TP> rv(*this);
I->advance(); return rv; }
};
template<typename IT>
class basic_filterator : public iterator<
typename IT::iterator_category,
typename IT::value_type,
typename IT::difference_type,
typename IT::pointer,
typename IT::reference> {
public:
IT it;
IT ei;
bool empty;
basic_filterator() : empty(true) { }
- basic_filterator(const IT& bi,const IT& ei)
- : it(bi), ei(ei) { empty = (bi==ei); }
+ basic_filterator(const IT& _bi,const IT& _ei)
+ : it(_bi), ei(_ei) { empty = (it==ei); }
basic_filterator(const basic_filterator<IT>& x)
: it(x.it), ei(x.ei), empty(x.empty) { }
virtual ~basic_filterator() { }
bool operator==(const basic_filterator<IT>& x) const {
return empty?x.empty:(it==x.it); }
bool operator!=(const basic_filterator<IT>& x) const {
return empty!=x.empty || it!=x.it; }
typename IT::reference operator*() const {
assert(!empty);
return *it; }
typename IT::pointer operator->() const {
assert(!empty);
return it.operator->(); }
basic_filterator<IT>& operator++() {
bool found = false;
for(++it;!(it==ei || (found=is_interesting()));++it);
if(!found) empty=true;
return *this;
}
basic_filterator<IT> operator++(int) {
basic_filterator<IT> rv(*this);
++(*this);
return rv;
}
void prepare() {
bool found = false;
for(;!(it==ei || (found=is_interesting()));++it);
if(!found) empty = true;
}
virtual bool is_interesting() const = 0;
};
template<typename IT,typename T=typename IT::value_type::first_type,typename TR=T&,typename TP=T*>
class map_keys_iterator : public iterator<
typename IT::iterator_category,
T,void,TP,TR> {
public:
typedef map_keys_iterator<IT,T,TR,TP> self_type;
IT it;
IT ei;
bool empty;
map_keys_iterator() : empty(true) { }
- map_keys_iterator(const IT& bi,
- const IT& ei)
- : it(bi), ei(ei) { empty = (bi==ei); }
+ map_keys_iterator(const IT& _bi,
+ const IT& _ei)
+ : it(_bi), ei(_ei) { empty = (it==ei); }
map_keys_iterator(const self_type& x)
: it(x.it), ei(x.ei), empty(x.empty) { }
bool operator==(const self_type& x) const {
return empty?x.empty:(it==x.it); }
bool operator!=(const self_type& x) const {
return empty!=x.empty || it!=x.it; }
TR operator*() const {
assert(!empty);
return it->first; }
TP operator->() const {
assert(!empty);
return &(it->first); }
self_type& operator++() {
assert(!empty);
empty=((++it)==ei); return *this; }
self_type operator++(int) {
self_type rv(*this);
++(*this); return rv; }
};
}
}
#endif /* __OPKELE_ITERATOR_H */
diff --git a/include/opkele/types.h b/include/opkele/types.h
index 6ab51ef..a3b657d 100644
--- a/include/opkele/types.h
+++ b/include/opkele/types.h
@@ -65,128 +65,129 @@ namespace opkele {
* decode cleartext secret from base64
* @param b64 base64-encoded representation of the secret value
*/
void from_base64(const string& b64);
};
/**
* Interface to the association.
*/
class association_t {
public:
virtual ~association_t() { }
/**
* retrieve the server with which association was established.
* @return server name
*/
virtual string server() const = 0;
/**
* retrieve the association handle.
* @return handle
*/
virtual string handle() const = 0;
/**
* retrieve the association type.
* @return association type
*/
virtual string assoc_type() const = 0;
/**
* retrieve the association secret.
* @return association secret
*/
virtual secret_t secret() const = 0;
/**
* retrieve the number of seconds the association expires in.
* @return seconds till expiration
*/
virtual int expires_in() const = 0;
/**
* check whether the association is stateless.
* @return true if stateless
*/
virtual bool stateless() const = 0;
/**
* check whether the association is expired.
* @return true if expired
*/
virtual bool is_expired() const = 0;
};
/**
* the shared_ptr<> for association_t object type
*/
typedef tr1mem::shared_ptr<association_t> assoc_t;
class basic_openid_message {
public:
typedef list<string> fields_t;
typedef util::forward_iterator_proxy<
string,const string&,const string*
> fields_iterator;
basic_openid_message() { }
+ virtual ~basic_openid_message() { }
basic_openid_message(const basic_openid_message& x);
void copy_to(basic_openid_message& x) const;
virtual bool has_field(const string& n) const = 0;
virtual const string& get_field(const string& n) const = 0;
virtual bool has_ns(const string& uri) const;
virtual string get_ns(const string& uri) const;
virtual fields_iterator fields_begin() const = 0;
virtual fields_iterator fields_end() const = 0;
virtual string append_query(const string& url) const;
virtual string query_string() const;
virtual void reset_fields();
virtual void set_field(const string& n,const string& v);
virtual void reset_field(const string& n);
virtual void from_keyvalues(const string& kv);
virtual void to_keyvalues(ostream& o) const;
virtual void to_htmlhiddens(ostream& o) const;
void add_to_signed(const string& fields);
string find_ns(const string& uri,const char *pfx) const;
string allocate_ns(const string& uri,const char *pfx);
};
class openid_message_t : public basic_openid_message, public map<string,string> {
public:
openid_message_t() { }
openid_message_t(const basic_openid_message& x)
: basic_openid_message(x) { }
void copy_to(basic_openid_message& x) const;
bool has_field(const string& n) const;
const string& get_field(const string& n) const;
virtual fields_iterator fields_begin() const;
virtual fields_iterator fields_end() const;
void reset_fields();
void set_field(const string& n,const string& v);
void reset_field(const string& n);
};
/**
* request/response parameters map
*/
class params_t : public openid_message_t {
public:
/**
* check whether the parameter is present.
* @param n the parameter name
* @return true if yes
*/
bool has_param(const string& n) const {
return has_field(n); }
/**
* retrieve the parameter (const version)
* @param n the parameter name