shib-target/shib-target.h

   1 /*
   2  * The Shibboleth License, Version 1.
   3  * Copyright (c) 2002
   4  * University Corporation for Advanced Internet Development, Inc.
   5  * All rights reserved
   6  *
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * Redistributions of source code must retain the above copyright notice, this
  12  * list of conditions and the following disclaimer.
  13  *
  14  * Redistributions in binary form must reproduce the above copyright notice,
  15  * this list of conditions and the following disclaimer in the documentation
  16  * and/or other materials provided with the distribution, if any, must include
  17  * the following acknowledgment: "This product includes software developed by
  18  * the University Corporation for Advanced Internet Development
  19  * <http://www.ucaid.edu>Internet2 Project. Alternately, this acknowledegement
  20  * may appear in the software itself, if and wherever such third-party
  21  * acknowledgments normally appear.
  22  *
  23  * Neither the name of Shibboleth nor the names of its contributors, nor
  24  * Internet2, nor the University Corporation for Advanced Internet Development,
  25  * Inc., nor UCAID may be used to endorse or promote products derived from this
  26  * software without specific prior written permission. For written permission,
  27  * please contact shibboleth@shibboleth.org
  28  *
  29  * Products derived from this software may not be called Shibboleth, Internet2,
  30  * UCAID, or the University Corporation for Advanced Internet Development, nor
  31  * may Shibboleth appear in their name, without prior written permission of the
  32  * University Corporation for Advanced Internet Development.
  33  *
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  36  * AND WITH ALL FAULTS. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  38  * PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED AND THE ENTIRE RISK
  39  * OF SATISFACTORY QUALITY, PERFORMANCE, ACCURACY, AND EFFORT IS WITH LICENSEE.
  40  * IN NO EVENT SHALL THE COPYRIGHT OWNER, CONTRIBUTORS OR THE UNIVERSITY
  41  * CORPORATION FOR ADVANCED INTERNET DEVELOPMENT, INC. BE LIABLE FOR ANY DIRECT,
  42  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  43  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  44  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  47  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50 /*
  51  * shib-target.h -- top-level header file for the SHIB Common Target Library
  52  *
  53  * Created by:  Derek Atkins <derek@ihtfp.com>
  54  *
  55  * $Id$
  56  */
  57
  58 #ifndef SHIB_TARGET_H
  59 #define SHIB_TARGET_H
  60
  61 #ifdef __cplusplus
  62 # include <saml/saml.h>
  63 # include <shib/shib.h>
  64 #endif
  65
  66 #ifdef WIN32
  67 # ifndef SHIBTARGET_EXPORTS
  68 #  define SHIBTARGET_EXPORTS __declspec(dllimport)
  69 # endif
  70 #else
  71 # define SHIBTARGET_EXPORTS
  72 #endif
  73
  74 #include <shib-target/shibrpc.h>
  75
  76 #ifdef __cplusplus
  77 extern "C" {
  78 #endif
  79
  80 #ifdef WIN32
  81
  82 #include <winsock.h>
  83 typedef SOCKET ShibSocket;
  84 typedef u_short ShibSockName;
  85 #define SHIB_SHAR_SOCKET 12345  /* shar portnumber */
  86
  87 #else  /* UNIX */
  88
  89 typedef int ShibSocket;
  90 typedef char * ShibSockName;
  91 #define SHIB_SHAR_SOCKET "/tmp/shar-socket"
  92
  93 #endif
  94
  95 /* shib-rpcutil.c */
  96
  97 /* Create an RPC Client handle for the _connected_ socket sock, attaching
  98  * the RPC program and version.
  99  *
 100  * returns a CLIENT on success, or NULL on error.  The caller can
 101  * call clnt_pcreateerror ("<string>") to output an error message from
 102  * the RPC library.
 103  */
 104 SHIBTARGET_EXPORTS CLIENT * shibrpc_client_create (ShibSocket sock, u_long program, u_long version);
 105
 106 /* shib-sock.c */
 107
 108 /* Create a new socket and put it into sock.
 109  *
 110  * Returns 0 on success, non-zero on error
 111  */
 112 SHIBTARGET_EXPORTS int shib_sock_create (ShibSocket *sock);
 113
 114 /*
 115  * bind the socket s to the "port" name.
 116  *
 117  * Returns 0 on success; non-zero on error.
 118  *
 119  * SIDE EFFECT: On error, the socket is closed!
 120  */
 121 SHIBTARGET_EXPORTS int shib_sock_bind (ShibSocket s, ShibSockName name);
 122
 123 /*
 124  * connect the socket s to the "port" name on the local host.
 125  *
 126  * Returns 0 on success; non-zero on error.
 127  */
 128 SHIBTARGET_EXPORTS int shib_sock_connect (ShibSocket s, ShibSockName name);
 129
 130 /*
 131  * accept a connection.  Returns 0 on success, non-zero on failure.
 132  */
 133 SHIBTARGET_EXPORTS int shib_sock_accept (ShibSocket listener, ShibSocket* s);
 134
 135 /*
 136  * close the socket
 137  */
 138 SHIBTARGET_EXPORTS void shib_sock_close (ShibSocket s, ShibSockName name);
 139
 140 /* shib-target.cpp */
 141
 142 /* application names */
 143 #define SHIBTARGET_GENERAL  "general"
 144 #define SHIBTARGET_SHAR     "shar"
 145 #define SHIBTARGET_SHIRE    "shire"
 146 #define SHIBTARGET_RM       "rm"
 147 #define SHIBTARGET_POLICIES "policies"
 148
 149 /* configuration tags */
 150 #define SHIBTARGET_TAG_LOGGER   "logger"
 151 #define SHIBTARGET_TAG_SCHEMAS  "schemadir"
 152 #define SHIBTARGET_TAG_CERTFILE "certfile"
 153 #define SHIBTARGET_TAG_KEYFILE  "keyfile"
 154 #define SHIBTARGET_TAG_KEYPASS  "keypass"
 155 #define SHIBTARGET_TAG_CALIST   "calist"
 156
 157 #define SHIBTARGET_TAG_AATIMEOUT    "AATimeout"
 158 #define SHIBTARGET_TAG_AACONNECTTO  "AAConnectTimeout"
 159 #define SHIBTARGET_TAG_SAMLCOMPAT   "SAMLCompat"
 160
 161 #define SHIBTARGET_TAG_METADATA "metadata"
 162
 163 #define SHIBTARGET_TAG_DEFAULTLIFE  "defaultLife"
 164
 165 #define SHIBTARGET_TAG_CACHETYPE    "cacheType"
 166 #define SHIBTARGET_TAG_CACHECLEAN   "cacheClean"
 167 #define SHIBTARGET_TAG_CACHETIMEOUT "cacheTimeout"
 168
 169 #define SHIBTARGET_TAG_REQATTRS     "requestAttributes"
 170
 171 /* initialize and finalize the target library (return 0 on success, 1 on failure) */
 172 SHIBTARGET_EXPORTS int shib_target_initialize (const char* application, const char* ini_file);
 173 SHIBTARGET_EXPORTS void shib_target_finalize (void);
 174 SHIBTARGET_EXPORTS ShibSockName shib_target_sockname(void);
 175
 176 #ifdef __cplusplus
 177 }
 178
 179
 180 namespace shibtarget {
 181   class ResourcePriv;
 182   class SHIBTARGET_EXPORTS Resource
 183   {
 184   public:
 185     Resource(const char* resource_url);
 186     Resource(std::string resource_url);
 187     ~Resource();
 188
 189     const char* getResource() const;
 190     const char* getURL() const;
 191     bool equals(Resource*) const;
 192     saml::Iterator<saml::SAMLAttribute*> getDesignators() const;
 193
 194   private:
 195     ResourcePriv *m_priv;
 196   };
 197
 198   class RPCHandleInternal;
 199   class SHIBTARGET_EXPORTS RPCHandle
 200   {
 201   public:
 202     RPCHandle(ShibSockName shar, u_long program, u_long version);
 203     ~RPCHandle();
 204
 205     CLIENT *    connect(void);  /* locks the HANDLE and returns the CLIENT */
 206     void        release(void);  /* unlocks the HANDLE */
 207     void        disconnect(void); /* disconnects */
 208
 209   private:
 210     RPCHandleInternal *m_priv;
 211   };
 212
 213   class SHIBTARGET_EXPORTS ShibTargetException : public std::exception
 214   {
 215   public:
 216     explicit ShibTargetException() { m_code = SHIBRPC_OK; }
 217     explicit ShibTargetException(ShibRpcStatus code, const char* msg,
 218                                  const XMLCh* origin = NULL)
 219         { m_code = code; if (msg) m_msg=msg; if (origin) m_origin = origin; }
 220     explicit ShibTargetException(ShibRpcStatus code, const std::string& msg,
 221                                  const XMLCh* origin = NULL) : m_msg(msg)
 222         { m_code=code; if(origin) m_origin = origin; }
 223     virtual ~ShibTargetException() throw () {}
 224     virtual const char* what() const throw () { return (m_msg.c_str()); }
 225     virtual ShibRpcStatus which() const throw () { return (m_code); }
 226     virtual const XMLCh* where() const throw () { return m_origin.c_str(); }
 227
 228   private:
 229     ShibRpcStatus       m_code;
 230     std::string         m_msg;
 231     saml::xstring       m_origin;
 232   };
 233
 234   class RPCErrorPriv;
 235   class SHIBTARGET_EXPORTS RPCError
 236   {
 237   public:
 238     RPCError() { init(0, "", NULL); }
 239     RPCError(ShibRpcError* error);
 240     RPCError(int s, char const* st, const XMLCh* orig = NULL) { init (s,st,orig); }
 241     RPCError(ShibTargetException &exp) { init(exp.which(), exp.what(), exp.where()); }
 242     ~RPCError();
 243
 244     bool        isError();
 245     bool        isRetryable();
 246
 247     // Return a set of strings that corresponds to the type, text, and desc
 248     const char* getType();
 249     const char* getText();
 250     const char* getDesc();
 251     std::string getOriginErrorURL();
 252     std::string getOriginContactName();
 253     std::string getOriginContactEmail();
 254     int getCode();
 255
 256   private:
 257     void init(int stat, char const* msg, const XMLCh* origin);
 258     RPCErrorPriv* m_priv;
 259   };
 260
 261   class SHIBTARGET_EXPORTS SHIREConfig
 262   {
 263   public:
 264     bool        checkIPAddress;
 265     time_t      lifetime;
 266     time_t      timeout;
 267   };
 268
 269   class SHIREPriv;
 270   class SHIBTARGET_EXPORTS SHIRE
 271   {
 272   public:
 273     SHIRE(RPCHandle *rpc, SHIREConfig config, std::string shire_url);
 274     ~SHIRE();
 275
 276     RPCError* sessionIsValid(const char* cookie, const char* ip, const char* url);
 277     RPCError* sessionCreate(const char* post, const char* ip,
 278                              std::string &cookie);
 279   private:
 280     SHIREPriv *m_priv;
 281   };
 282
 283   class SHIBTARGET_EXPORTS RMConfig
 284   {
 285   public:
 286     bool        checkIPAddress;
 287   };
 288
 289   class RMPriv;
 290   class SHIBTARGET_EXPORTS RM
 291   {
 292   public:
 293     RM(RPCHandle *rpc, RMConfig config);
 294     ~RM();
 295
 296     RPCError* getAssertions(const char* cookie, const char* ip,
 297                             const char* url,
 298                             std::vector<saml::SAMLAssertion*> &assertions,
 299                             saml::SAMLAuthenticationStatement **statement = NULL);
 300     static void serialize(saml::SAMLAssertion &assertion, std::string &result);
 301     static saml::Iterator<saml::SAMLAttribute*> getAttributes(saml::SAMLAssertion &assertion);
 302   private:
 303     RMPriv *m_priv;
 304   };
 305
 306   class ShibINIPriv;
 307   class SHIBTARGET_EXPORTS ShibINI {
 308   public:
 309     ShibINI (std::string& file, bool case_sensitive = true) { init(file,case_sensitive); }
 310     ShibINI (const char *file, bool case_sensitive = true) {
 311       std::string f = file;
 312       init(f, case_sensitive);
 313     }
 314     ~ShibINI ();
 315
 316     void refresh(void);
 317
 318     const std::string get (const std::string& header, const std::string& tag);
 319     const std::string get (const char* header, const char* tag) {
 320       std::string h = header, t = tag;
 321       return get(h,t);
 322     }
 323
 324     const std::string operator() (const std::string& header, const std::string& tag)  {
 325       return get(header,tag);
 326     }
 327     const std::string operator() (const char* header, const char* tag) {
 328       std::string h = header, t = tag;
 329       return get(h,t);
 330     }
 331
 332     bool exists(const std::string& header);
 333     bool exists(const std::string& header, const std::string& tag);
 334
 335     bool exists(const char* header) {
 336       std::string s = header;
 337       return exists(s);
 338     }
 339     bool exists(const char* header, const char* tag) {
 340       std::string h = header, t = tag;
 341       return exists(h,t);
 342     }
 343
 344     // Special method to look for a tag in one header and maybe in the
 345     // 'SHIBTARGET_GENERAL' header
 346     bool get_tag(std::string& header, std::string& tag, bool try_general,
 347                  std::string* result);
 348
 349     bool get_tag(std::string& header, const char* tag, bool try_general,
 350                  std::string* result) {
 351       std::string t = tag;
 352       return get_tag (header,t,try_general,result);
 353     }
 354
 355     bool get_tag(const char* header, const char* tag, bool try_general,
 356                  std::string* result) {
 357       std::string h = header, t = tag;
 358       return get_tag (h,t,try_general,result);
 359     }
 360
 361     // Dump out the inifile to the output stream
 362     void dump(std::ostream& os);
 363
 364     // Iterators
 365
 366     // The begin() functions reset the iterator and return the first element
 367     // (or 0 if there are no elements.)
 368     // The next() functions return the next element, or 0 if there are no
 369     // elements left.
 370     //
 371     // Example:
 372     // for (const foo* current = begin(); current; current = next()) {
 373     //   ...
 374     // }
 375     //
 376     // NOTE: Holding an Iterator will lock the INI file and cause it to
 377     // stop updating itself.  You should destroy the iterator as soon as
 378     // you are done with it.
 379     //
 380     // ALSO NOTE: the string* returned from the Iterator is only valid
 381     // while you hold the iterator.  You should copy the de-reference
 382     // of the pointer to your own copy if you want to keep the string.
 383
 384     class SHIBTARGET_EXPORTS Iterator {
 385     public:
 386       virtual ~Iterator() {}
 387       virtual const std::string* begin() = 0;
 388       virtual const std::string* next() = 0;
 389     };
 390
 391     Iterator* header_iterator();
 392     Iterator* tag_iterator(const std::string& header);
 393
 394     static bool boolean(std::string& value);
 395
 396   private:
 397     ShibINIPriv *m_priv;
 398     void init(std::string& file, bool case_sensitive);
 399   };
 400
 401   class ShibMLPPriv;
 402   class SHIBTARGET_EXPORTS ShibMLP {
 403   public:
 404     ShibMLP();
 405     ~ShibMLP();
 406
 407     void insert (const std::string& key, const std::string& value);
 408     void insert (const std::string& key, const char* value) {
 409       std::string v = value;
 410       insert (key, v);
 411     }
 412     void insert (const char* key, const std::string& value) {
 413       std::string k = key;
 414       insert (k, value);
 415     }
 416     void insert (const char* key, const char* value) {
 417       std::string k = key, v = value;
 418       insert(k,v);
 419     }
 420     void insert (RPCError& e);
 421
 422     void clear () { m_map.clear(); }
 423
 424     std::string run (std::istream& s) const;
 425     std::string run (const std::string& input) const;
 426     std::string run (const char* input) const {
 427       std::string i = input;
 428       return run(i);
 429     }
 430
 431   private:
 432     ShibMLPPriv *m_priv;
 433     std::map<std::string,std::string> m_map;
 434   };
 435
 436   class SHIBTARGET_EXPORTS ShibTargetConfig
 437   {
 438   public:
 439     static void preinit();
 440     static ShibTargetConfig& init(const char* app_name, const char* inifile);
 441     static ShibTargetConfig& getConfig();
 442     virtual void init() = 0;
 443     virtual void shutdown() = 0;
 444     virtual ~ShibTargetConfig();
 445     virtual ShibINI& getINI() = 0;
 446     virtual saml::Iterator<const XMLCh*> getPolicies() = 0;
 447
 448     ShibSockName m_SocketName;
 449   };
 450
 451 } // namespace
 452 #endif
 453
 454 #endif /* SHIB_TARGET_H */