AuthenticatedUser.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Embedded Web-Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: AuthenticatedUser.h 5394 2023-02-21 18:41:44Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2006 - 2023
 *
 *   This software is copyrighted by and is the sole property of Real
 *   Time Logic LLC.  All rights, title, ownership, or other interests in
 *   the software remain the property of Real Time Logic LLC.  This
 *   software may only be used in accordance with the terms and
 *   conditions stipulated in the corresponding license agreement under
 *   which the software has been supplied.  Any unauthorized use,
 *   duplication, transmission, distribution, or disclosure of this
 *   software is expressly forbidden.
 *                                                                        
 *   This Copyright notice may not be removed or modified without prior
 *   written consent of Real Time Logic LLC.
 *                                                                         
 *   Real Time Logic LLC. reserves the right to modify this software
 *   without notice.
 *
 *               http://www.realtimelogic.com
 ****************************************************************************
 *
 *
 */
#ifndef __AuthenticatedUser_h
#define __AuthenticatedUser_h
 
#include <HttpServer.h>
#include <BaServerLib.h>
#include <DoubleList.h>
#include <SplayTree.h>
 
#ifndef __DOXYGEN__
struct AuthenticatorIntf;
struct UserIntf;
struct AuthorizerIntf;
struct AuthenticatedUser;
struct LoginRespIntf;
struct LoginTracker;
struct LoginTrackerIntf;
struct LoginTrackerNode;
struct AuthInfo;
#endif
 
 
#ifdef __cplusplus
extern "C" {
#endif
extern const char BasicAuthUser_derivedType[];
extern const char DigestAuthUser_derivedType[];
extern const char FormAuthUser_derivedType[];
#ifdef __cplusplus
}
#endif
 
 
typedef enum {
   AuthenticatedUserType_Unknown,
   AuthenticatedUserType_Digest,
   AuthenticatedUserType_Basic,
   AuthenticatedUserType_Form
} AuthenticatedUserType;
 
 
typedef BaBool (*AuthorizerIntf_Authorize)(
   struct AuthorizerIntf* intf,
   struct AuthenticatedUser* user,
   HttpMethod httpMethod,
   const char* path);
 
typedef struct AuthorizerIntf
{
#ifdef __cplusplus
      AuthorizerIntf(){}
 
      AuthorizerIntf(AuthorizerIntf_Authorize authorize);
 
      bool authorize(struct AuthenticatedUser* user,
                     HttpMethod method,
                     const char* path);
#endif
      AuthorizerIntf_Authorize authorizeFP;
} AuthorizerIntf;
 
#define AuthorizerIntf_constructor(o, authorize) (o)->authorizeFP=authorize
#define AuthorizerIntf_authorize(o, user, method, path) \
  (o)->authorizeFP(o, user, method, path)
 
#ifdef __cplusplus
inline
AuthorizerIntf::AuthorizerIntf(AuthorizerIntf_Authorize authorize) {
   AuthorizerIntf_constructor(this,authorize); }
inline bool
AuthorizerIntf::authorize(struct AuthenticatedUser* user,
                             HttpMethod method,
                             const char* path) {
   return AuthorizerIntf_authorize(this,user,method,path) ? true : false; }
#endif
 
 
typedef void (*UserIntf_GetPwd)(struct UserIntf* intf,struct AuthInfo* info);
 
typedef struct UserIntf
{
#ifdef __cplusplus
 
      UserIntf() {}
      
      UserIntf(UserIntf_GetPwd getPwd);
 
#endif
      UserIntf_GetPwd getPwdFp;
} UserIntf;
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define UserIntf_constructor(o, getPwd) (o)->getPwdFp = getPwd
 
#define UserIntf_getPwd(o, username) (o)->getPwdFp(o, username)
#ifdef __cplusplus
}
inline UserIntf::UserIntf(
   UserIntf_GetPwd getPwd) {
   UserIntf_constructor(this, getPwd);
}
#endif
 
 
#ifndef __DOXYGEN__
typedef struct AuthUserList
{
#ifdef __cplusplus
#endif
      SplayTreeNode super; /* inherits from SplayTreeNode */
      DoubleList list; /* List of AuthenticatedUser objects */
      struct UserIntf* userDb;
      HttpServer* server;
      char* username;
      char* password;
      int listLen; /* Number of objects in 'list' */
} AuthUserList;
#endif
 
BA_API int AuthUserList_createOrCheck(struct AuthInfo* info,
                               UserIntf* userDb,
                               void** ptr,
                               size_t size);
 
 
typedef DoubleListEnumerator AuthUserListEnumerator;
#define AuthUserListEnumerator_constructor(e, o) \
   DoubleListEnumerator_constructor(e, &(o)->list)
BA_API struct AuthenticatedUser*
AuthUserListEnumerator_getElement(DoubleListEnumerator* o);
BA_API struct AuthenticatedUser*
AuthUserListEnumerator_nextElement(DoubleListEnumerator* o);
void AuthUserList_termIfEmpty(AuthUserList* o);
 
 
 
typedef struct AuthenticatedUser
{
#ifdef __cplusplus
 
      static AuthenticatedUser* get(HttpRequest* request);
 
 
      static AuthenticatedUser* get(HttpSession* session);
 
      HttpSession* getSession();
 
      const char* getPassword();
 
      const char* getName();
 
      void logout(bool all=false);
 
      AuthenticatedUserType getType();
 
      static AuthenticatedUser* getAnonymous();
#endif
      HttpSessionAttribute superClass; /*as if inherited */
      DoubleLink dlink; /* In AuthUserList */
      AuthUserList* authUserList;
      const char* derivedType; /* Used for dynamic cast */
} AuthenticatedUser;
 
#ifdef __cplusplus
extern "C" {
#endif
 
BA_API void
AuthenticatedUser_constructor(AuthenticatedUser* o,
                              const char* derivedType,
                              AuthUserList* list,
                              HttpSessionAttribute_Destructor destructor);
BA_API void AuthenticatedUser_destructor(AuthenticatedUser* o);
BA_API AuthenticatedUser* AuthenticatedUser_get1(HttpRequest* request);
BA_API AuthenticatedUser* AuthenticatedUser_get2(HttpSession* session);
#define AuthenticatedUser_getName(o) \
  ((o) && (o)->authUserList && (o)->authUserList->username ? \
  (o)->authUserList->username : 0)
#define AuthenticatedUser_getDerivedType(o) (o)->derivedType
#define AuthenticatedUser_getSession(o) \
   HttpSessionAttribute_getSession((HttpSessionAttribute*)o)
#define AuthenticatedUser_getPassword(o) \
   ((o) && (o)->authUserList && (o)->authUserList->password ? \
    (o)->authUserList->password : 0)
BA_API void AuthenticatedUser_logout(AuthenticatedUser* o, BaBool all);
BA_API AuthenticatedUserType AuthenticatedUser_getType(AuthenticatedUser* o);
BA_API AuthenticatedUser* AuthenticatedUser_getAnonymous(void);
#ifdef __cplusplus
}
inline AuthenticatedUser* AuthenticatedUser::get(HttpRequest* request){
   return AuthenticatedUser_get1(request); }
inline AuthenticatedUser* AuthenticatedUser::get(HttpSession* session){
   return AuthenticatedUser_get2(session); }
inline const char* AuthenticatedUser::getName() {
   return AuthenticatedUser_getName(this); }
inline HttpSession* AuthenticatedUser::getSession() {
   return AuthenticatedUser_getSession(this); }
inline const char* AuthenticatedUser::getPassword() {
   return AuthenticatedUser_getPassword(this); }
inline void AuthenticatedUser::logout(bool all) {
   AuthenticatedUser_logout(this, all ? TRUE : FALSE); }
inline AuthenticatedUserType AuthenticatedUser::getType() {
   return AuthenticatedUser_getType(this); }
inline AuthenticatedUser* AuthenticatedUser::getAnonymous() {
   return AuthenticatedUser_getAnonymous(); }
#endif
 
typedef AuthenticatedUser* (*AuthenticatorIntf_Authenticate)(
   struct AuthenticatorIntf* super,
   const char* relPath,
   HttpCommand* cmd);
 
 
typedef struct AuthenticatorIntf
{
#ifdef __cplusplus
      /*Only to be used as default constructor when sub-classing with C code*/
      AuthenticatorIntf(){}
 
      AuthenticatorIntf(AuthenticatorIntf_Authenticate authenticate);
 
      AuthenticatedUser* authenticate(const char* relPath, HttpCommand* cmd);
#endif
      AuthenticatorIntf_Authenticate authenticateCB;
} AuthenticatorIntf;
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define AuthenticatorIntf_authenticate(o, relPath, cmd) \
  (o)->authenticateCB(o, relPath, cmd)
 
BA_API void AuthenticatorIntf_constructor(
   AuthenticatorIntf* o,
   AuthenticatorIntf_Authenticate authenticate);
#ifdef __cplusplus
}
inline AuthenticatorIntf::AuthenticatorIntf(
   AuthenticatorIntf_Authenticate authenticate) {
   AuthenticatorIntf_constructor(this,authenticate);
}
inline AuthenticatedUser* AuthenticatorIntf::authenticate(
   const char* relPath, HttpCommand* cmd) {
   return AuthenticatorIntf_authenticate(this, relPath, cmd);
}
#endif
 
 
typedef void (*LoginRespIntf_Service)(struct LoginRespIntf* intf,
                                      struct AuthInfo* info);
 
typedef struct LoginRespIntf
{
#ifdef __cplusplus
      LoginRespIntf() {}
      LoginRespIntf(LoginRespIntf_Service service);
#endif
      LoginRespIntf_Service serviceFp;
} LoginRespIntf;
 
#define LoginRespIntf_constructor(o, service) (o)->serviceFp=service
#ifdef __cplusplus
inline LoginRespIntf::LoginRespIntf(LoginRespIntf_Service service) {
   LoginRespIntf_constructor(this, service); }
#endif
 
 
typedef enum {
   AuthInfoCT_Password=5,
   AuthInfoCT_HA1,
   AuthInfoCT_Valid,
 
   AuthInfoCT_Invalid
} AuthInfoCT;
 
 
typedef struct AuthInfo
{
   struct LoginTracker* tracker;
 
   HttpCommand* cmd;
 
   const char* username;
 
   const char* upwd;
 
   AuthenticatedUser* user;
 
   AuthenticatedUserType type;
   
   AuthInfoCT ct;
 
   void* userObj;
 
   AuthUserList* authUserList;
 
   BaTime maxInactiveInterval;
 
   U32 seed;
   U32 seedKey;
 
   int maxUsers;
 
   int loginAttempts;
 
   BaBool denied;
 
   BaBool recycle;
 
   U8 password[100];
} AuthInfo;
 
#define AuthInfo_constructor(o, trackerMA, cmdMA, typeMA) do {\
   memset(o, 0, sizeof(AuthInfo));\
   (o)->tracker=trackerMA;\
   (o)->cmd=cmdMA;\
   (o)->type=typeMA;\
   (o)->maxUsers=3;\
   (o)->ct=AuthInfoCT_Password;\
   (o)->password[0]=0;\
} while(0)
 
typedef BaBool (*LoginTrackerIntf_Validate)(
   struct LoginTrackerIntf* o,
   AuthInfo* info,
   struct LoginTrackerNode* node);
 
 
typedef void (*LoginTrackerIntf_Login)(
   struct LoginTrackerIntf* o,
   AuthInfo* info,
   struct LoginTrackerNode* node);
 
typedef void (*LoginTrackerIntf_LoginFailed)(
   struct LoginTrackerIntf* o,
   AuthInfo* info,
   struct LoginTrackerNode* node);
 
typedef void (*LoginTrackerIntf_TerminateNode)(
   struct LoginTrackerIntf* o,
   struct LoginTrackerNode* node);
 
 
typedef struct LoginTrackerIntf
{
#ifdef __cplusplus
      LoginTrackerIntf(LoginTrackerIntf_Validate validate,
                       LoginTrackerIntf_Login login,
                       LoginTrackerIntf_LoginFailed loginFailed,
                       LoginTrackerIntf_TerminateNode terminateNode);
#endif
      LoginTrackerIntf_Validate validate;
      LoginTrackerIntf_Login login;
      LoginTrackerIntf_LoginFailed loginFailed;
      LoginTrackerIntf_TerminateNode terminateNode;
} LoginTrackerIntf;
 
#define LoginTrackerIntf_constructor(\
 o, validateMA, loginMA, loginFailedMA, terminateNodeMA) do {\
   (o)->validate=validateMA;\
   (o)->login=loginMA;\
   (o)->loginFailed=loginFailedMA;\
   (o)->terminateNode=terminateNodeMA;\
} while(0)
#define LoginTrackerIntf_validate(o, request, node) \
  (o)->validate(o, request, node)
#define LoginTrackerIntf_login(o, request, user) \
  (o)->login(o, request, user)
#define LoginTrackerIntf_loginFailed(o, node, loginName) \
  (o)->loginFailed(o, node, loginName)
#define LoginTrackerIntf_terminateNode(o, node) \
  (o)->terminateNode(o, node)
 
#ifdef __cplusplus
inline LoginTrackerIntf::LoginTrackerIntf(
   LoginTrackerIntf_Validate validate,
   LoginTrackerIntf_Login login,
   LoginTrackerIntf_LoginFailed loginFailed,
   LoginTrackerIntf_TerminateNode terminateNode) {
   LoginTrackerIntf_constructor(this,validate,login,loginFailed,terminateNode);
}
#endif
 
 
typedef struct LoginTrackerNode
{
#ifdef __cplusplus
      U32 getCounter();
 
      U32 getAuxCounter();
 
      void setAuxCounter(U32 count);
 
      HttpSockaddr* getAddr();
 
      void setUserData(void* data);
 
      void* getUserData();
 
      BaTime getTime();
#endif
      SplayTreeNode super;
      DoubleLink dlink;
      HttpSockaddr addr;
      void* userData;
      BaTime t;
      U32 loginCounter;
      U32 auxCounter;
} LoginTrackerNode;
 
#define LoginTrackerNode_getCounter(o) (o)->loginCounter
#define LoginTrackerNode_getAuxCounter(o) (o)->auxCounter
#define LoginTrackerNode_setAuxCounter(o, count) (o)->auxCounter=count
#define LoginTrackerNode_getAddr(o) (&(o)->addr)
#define LoginTrackerNode_setUserData(o, data) (o)->userData=data
#define LoginTrackerNode_getUserData(o) (o)->userData
#define LoginTrackerNode_getTime(o) (o)->t
 
#ifdef __cplusplus
inline U32 LoginTrackerNode::getCounter() {
   return LoginTrackerNode_getCounter(this);
}
inline U32 LoginTrackerNode::getAuxCounter() {
   return LoginTrackerNode_getAuxCounter(this);
}
 
inline void LoginTrackerNode::setAuxCounter(U32 count) {
   LoginTrackerNode_setAuxCounter(this, count);
}
 
inline HttpSockaddr* LoginTrackerNode::getAddr() {
   return LoginTrackerNode_getAddr(this);
}
inline void LoginTrackerNode::setUserData(void* data) {
   LoginTrackerNode_setUserData(this, data);
}
inline void* LoginTrackerNode::getUserData() {
   return  LoginTrackerNode_getUserData(this);
}
inline BaTime LoginTrackerNode::getTime() {
   return LoginTrackerNode_getTime(this);
}
#endif
 
typedef struct LoginTracker
{
#ifdef __cplusplus
      LoginTracker(U32 noOfLoginTrackerNodes,
                   LoginTrackerIntf* intf,
                   AllocatorIntf* allocator = AllocatorIntf::getDefault());
 
      void clearCache();
 
      LoginTrackerNode* getFirstNode();
 
      LoginTrackerNode* getNextNode(LoginTrackerNode* n);
 
      LoginTrackerNode* find(HttpRequest* request);
#endif
      SplayTree tree;
      DoubleList dInUseList;
      DoubleList dFreeList;
      LoginTrackerIntf* loginTrackerIntf;
      U32 cursor;
      U32 noOfLoginTrackerNodes;
      LoginTrackerNode* nodes;
} LoginTracker;
 
 
#ifdef __cplusplus
extern "C" {
#endif
BA_API void LoginTracker_constructor(LoginTracker* o,
                                     U32 noOfLoginTrackerNodes,
                                     LoginTrackerIntf* intf,
                                     AllocatorIntf* allocator);
BA_API void LoginTracker_destructor(LoginTracker* o);
BA_API void LoginTracker_clearCache(LoginTracker* o);
BA_API LoginTrackerNode* LoginTracker_getFirstNode(LoginTracker* o);
BA_API LoginTrackerNode* LoginTracker_getNextNode(
   LoginTracker* o, LoginTrackerNode* n);
BA_API LoginTrackerNode* LoginTracker_find(LoginTracker*o, HttpRequest* req);
BA_API void LoginTracker_loginFailed(
   LoginTracker* o, AuthInfo* info);
BA_API BaBool LoginTracker_validate(LoginTracker* o, AuthInfo* info);
BA_API void LoginTracker_login(LoginTracker* o, AuthInfo* info);
#ifdef __cplusplus
}
inline LoginTracker::LoginTracker(U32 noOfLoginTrackerNodes,
                                  LoginTrackerIntf* intf,
                                  AllocatorIntf* allocator) {
   LoginTracker_constructor(this, noOfLoginTrackerNodes, intf, allocator);
}
inline void LoginTracker::clearCache() {
   LoginTracker_clearCache(this);
}
inline LoginTrackerNode* LoginTracker::getFirstNode() {
   return LoginTracker_getFirstNode(this);
}
inline LoginTrackerNode* LoginTracker::getNextNode(LoginTrackerNode* n) {
   return LoginTracker_getNextNode(this,n);
}
inline LoginTrackerNode* LoginTracker::find(HttpRequest* request) {
      return LoginTracker_find(this,request);
}
#endif
 
 /* end of Authentication */
 
/* Internal func */
void calculateHA1Hex(
   const char* realm, const char* uname, const char* pwd, U8 hexbuf[33]);
 
#endif