/*
 * SecurityAuthIdentity.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9 2.0

// 2011/1/11

#pragma once
#include <sol/Object.h>
#include <sol/Exception.h>
#include <rpc.h>

/*
typedef struct _SEC_WINNT_AUTH_IDENTITY {
  unsigned short __RPC_FAR *User;
  unsigned long            UserLength;
  unsigned short __RPC_FAR *Domain;
  unsigned long            DomainLength;
  unsigned short __RPC_FAR *Password;
  unsigned long            PasswordLength;
  unsigned long            Flags;
} SEC_WINNT_AUTH_IDENTITY, *PSEC_WINNT_AUTH_IDENTITY;

*/

namespace SOL {

class SecurityAuthIdentity :public Object {

private:
    SEC_WINNT_AUTH_IDENTITY* credentials;

public:
    SecurityAuthIdentity(const TCHAR* user=NULL, const TCHAR* password=NULL, const TCHAR* domain=NULL)
    :credentials(NULL)
    {    
        if (user || password || domain) {
            credentials = (SEC_WINNT_AUTH_IDENTITY*) new BYTE[sizeof(credentials)];

            memset(credentials, '\0', sizeof(credentials));
#ifdef UNICODE
            credentials->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
#else
            credentials->Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;   
#endif
            set(user, password, domain);
        }
    }


public:
    ~SecurityAuthIdentity()
    {
        if (credentials) {
            delete [] (BYTE*)credentials;
        }
    }

public:
    void set(const TCHAR* user=NULL, const TCHAR* password=NULL, const TCHAR* domain=NULL)
    {
        if (credentials) {
            if (user) {
#ifdef UNICODE
                credentials->User = (unsigned short*)user;
#else
                credentials->User = (unsigned char*)(void*)user; 
#endif
                credentials->UserLength = strlen(user);
            }
            if (password) {
#ifdef UNICODE
                credentials->Password = (unsigned short*) password;
#else
                credentials->Password = (unsigned char*) password;

#endif
                credentials->PasswordLength = strlen(password);

            }
            if (domain) {
#ifdef UNICODE
                credentials->Domain =(unsigned short*) domain;
#else
                credentials->Domain =(unsigned char*) domain;
#endif
                credentials->DomainLength = strlen(domain);
            }
        }
    }

public:
    bool hasUserName() 
    {
        bool rc = false;

        if (credentials->User && credentials->UserLength>0) {
            rc = true;
        }
        return rc;
    }

public:
    const TCHAR* getUser() 
    {
        const TCHAR* user=NULL;
        if (credentials) {
            user = (const TCHAR*)credentials->User;
        }
        return user;
    }

public:
    const TCHAR* getPassword() 
    {
        const TCHAR* password=NULL;
        if (credentials) {
            password = (const TCHAR*)credentials->Password;
        }
        return password;
    }

public:
    const TCHAR* getDomain() 
    {
        const TCHAR* domain=NULL;
        if (credentials) {
            domain = (const TCHAR*)credentials->Domain;
        }
        return domain;
    }

public:
    operator const SEC_WINNT_AUTH_IDENTITY*() const 
    {
        return credentials;
    }

public:
    const SEC_WINNT_AUTH_IDENTITY* getCredentials() const 
    {
        return credentials;
    }

public:
    void display()
    {
        _tprintf(_T("User    =%s\n"), getUser());
        _tprintf(_T("Password=%s\n"), getPassword());
        _tprintf(_T("Domain  =%s\n"), getDomain());

    }

};

}