warifserver.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarIfServer.h"   // class implemented
#include "WarLogWin32NtEventHandler.h"
#include "WarLogEngine.h"
#include "WarLogIoStreamHandler.h"
#include "WarLogFileHandler.h"
#include "WarFile.h"
#include "WarIfLogModule.h"
#include "WarIfRoot.h"
#include "WarIfSite.h"
#include "WarOptionList.h"
#include "WarOptionWin32.h"
#include "WarIfOptions.h"
#include "WarNtServiceSvc.h"
#include "WarSvrDefinitionHttp.h"
#include "WarSvrEngine.h"
#include "WarOs.h"
#include "WarFsys.h"
#include "WarIfMimeTypes.h"

using namespace std;

/////////////////////////////// PUBLIC ///////////////////////////////////////

//============================= LIFECYCLE ====================================

WarIfServer::WarIfServer(war_if_root_ptr_t& rootInterface) :
mRootPtr(rootInterface)
{
    mName = rootInterface->GetRegKey().GetRef().GetPath().GetFilename().GetPath();
    mRegKey.Open(rootInterface->GetRegKey().GetRef());
#if WAR_CRYPTO
    mRegKey.LoadPamFile();
#endif
}// WarIfServer

WarIfServer::~WarIfServer()
{
}// ~WarIfServer


//============================= OPERATORS ====================================
//============================= OPERATIONS ===================================


void WarIfServer::StartLogModules() const
        throw (WarException)
{
    strlist_t modules;

    EnumLogModules(modules, true);

    for(strlist_t::const_iterator P = modules.begin()
        ; P != modules.end()
        ; P++)
    {
        WarCollector<char> log_name = P->c_str();
        war_registrypath_t module_path;
        
        module_path << mRegKey.GetRef().GetPath().GetPath() 
            << WAR_SYSSLASH << WAR_WINNT_REG_LOG_MODULES
            << WAR_SYSSLASH << *P;
        
        WarWin32Registry module_key;
        module_key.Open(WarWin32Registry::open_t(mRegKey, module_path));
        
        if (!module_key.GetIntValue(WAR_WINNT_REG_ENABLE, false))
            continue;
        
        war_regstr_t module_clsid 
            = module_key.GetStrValue(WAR_WINNT_REG_CLASSID, NULL, true);
        
        if (module_clsid == war_regstr_t(_T(WAR_CLSID_LOG_COUT)))
        {
            WarLogEngine::GetEngine().InstallHandler(
                new WarLogIoStreamHandler(cout, "cout"));
            
        } else if (module_clsid == war_regstr_t(_T(WAR_CLSID_LOG_FILE)))
        {
            war_file_ptr_t log_file;
            war_syspath_t log_path = module_key.GetStrValue(_T("File Name"));
            log_file = WarFile::Create(log_path);
            
            try
            {
                log_file->Open(WarFileEnums::F_APPEND 
                    | WarFileEnums::F_WRITE
                    | WarFileEnums::F_SHREAD
                    | WarFileEnums::F_CREATE
                    | WarFileEnums::F_SEQUENTIAL);
            }
            catch(WarException)
            {

                WAR_CERR << _T("Failed to open logfile ") << log_path.GetPath() << endl;
                continue;
            }
            
            WarLogEngine::GetEngine().InstallHandler(
                new WarLogFileHandler(log_file, "logfile"));
            
        } else if (module_clsid == war_regstr_t(_T(WAR_CLSID_LOG_NTEVLOG)))
        {
            WarLogEngine::GetEngine().InstallHandler(
                new WarLogWin32NtEventHandler("eventlog", 
                (const WarLogWin32NtEventHandler::str_t) module_key.GetStrValue(_T("Tag Name")).c_str()));
        }
        else
        {
            WAR_CERR << _T("Unknown log module: ") << *P << endl;
            continue;
        }
        
        WarCollector<char> events = module_key.GetStrValue(_T("Events")); 
        
        if (!events.GetValue().empty())
        {
            WarLogEngine::GetEngine().EnableEvent(log_name.GetValue().c_str(), 
                events.GetValue().c_str());
        }
    }
}

war_if_log_module_ptr_t WarIfServer::GetLogModule(war_ccsysstr_t logName) 
    const throw (WarException)
{
    WarIfLogModule *pnew_module = new WarIfLogModule;
    pnew_module->Open(mRegKey, logName);

    return pnew_module;
}

void WarIfServer::CwdToServerDir() throw(WarException)
{
    if (!::SetCurrentDirectory(
        mRegKey.GetStrValue(WAR_WINNT_STARTUP_PATH).c_str()))
    {
        WarSystemError sys_err;

        // We don't have the log-module yet
        WAR_CERR << _T("Failed to change to directory: ") 
            << WAR_WINNT_STARTUP_PATH 
            << endl;

        WarThrow(sys_err, NULL);
    }
}

void WarIfServer::CreateDirectories() throw(WarException)
{
    // Create directories we depend on
    std::string def_tmp_path = WarOptionList::GetGlobalOptions().GetOption("core_TMPDIR");
    WarOs::tmpfile_path_t tmp_path =
        WarOs::GetOs().GetNewTmpFileName(def_tmp_path.c_str());
    
    try
    {
        WarFsysCreateDirectory(WarUrl(tmp_path.GetPathname().GetPath()));
    }
    catch(WarException)
    {
    }

}

void WarIfServer::LoadOptions() throw(WarException)
{
    WarWin32Registry reg_options;

    reg_options.Create(mRegKey.GetRef(WAR_WINNT_REG_OPTIONS));

    WarOptionList my_list;
    
    WarOptionList& global_opts = WarOptionList::GetGlobalOptions();
    reg_options >> global_opts;

    // Get the default values too. 
    WarWin32Registry my_key;
    war_registrypath_t my_path;
    my_path << mRegKey.GetRef().GetPath().GetPath() << WAR_SYSSLASH
        << WAR_WINNT_REG_MODULES << WAR_SYSSLASH
        << WAR_WINNT_REG_OPTIONS;

    my_key.Open(WarWin32Registry::open_t(mRegKey, my_path));

    WarWin32Registry::keyname_list_t val_list;
    my_key.EnumKey(val_list);

    for(WarWin32Registry::keyname_list_t::const_iterator P = 
        val_list.begin()
        ; P != val_list.end()
        ; ++P)
    {
        WarWin32Registry opt_key;
        opt_key.Open(my_key.GetRef(P->c_str()));
        
        global_opts.insert(war_option_pair_t(
            WarCollector<char>(*P).GetValue(), 
            WarCollector<char>(opt_key.GetStrValue(WAR_WINNT_REG_DEF_VALUE)).GetValue()));
    }
}

war_if_options_ptr_t WarIfServer::GetOptions() throw (WarException)
{
    return new WarIfOptions(*this);
}

void WarIfServer::UninstallNtService() throw(WarException)
{
    WarNtServiceSvc my_service;

    try
    {
        my_service.Create(mRootPtr->GetMachineName().c_str(),
            SC_MANAGER_ALL_ACCESS, mName.c_str(), SERVICE_ALL_ACCESS);

        if (!DeleteService(my_service))
            WarThrow(WarSystemError(), NULL);
        
    }
    catch(WarException)
    {
    }   
}

void WarIfServer::InstallNtService(bool doAutoStart, 
                                   war_ccsysstr_t userName,
                                   war_ccsysstr_t userPasswd)
{
    war_syspath_t startup_path, user_name;
    
    if (userName && *userName)
    {
        war_ccsysstr_t p = userName;
        while(*p)
        {
            if (*p == '\\')
                break;
            ++p;
        }
        
        if (!*p)
            user_name << ".\\"; // Need Prefix
    }
    
    user_name << userName;
    
    startup_path << '\"'
        << mRegKey.GetStrValue(WAR_WINNT_STARTUP_PATH, NULL, true)
        << WAR_SYSSLASH
        << mRegKey.GetStrValue(WAR_WINNT_PROGRAM_NAME, NULL, true)
        << '\"'
        << ' '
        << "--daemon "
        << "\"--name=" << mName << '\"';

    if (mIsNtService() && userName && *userName)
    {
        // Update properties
        WarNtServiceSvc my_svc;
        my_svc.Create(mRootPtr->GetMachineName().c_str(),
            SC_MANAGER_ALL_ACCESS, mName.c_str(), 
            SERVICE_CHANGE_CONFIG, true);
        
        if (!ChangeServiceConfig(my_svc, 
            SERVICE_NO_CHANGE,
            doAutoStart ? SERVICE_AUTO_START : SERVICE_DEMAND_START,
            SERVICE_NO_CHANGE,
            NULL,
            NULL,
            NULL,
            NULL,
            (userName && *userName) ? user_name.GetPath() : NULL,
            (userPasswd && *userPasswd) ? userPasswd : NULL,
            NULL))
        {
            WarThrow(WarSystemError(), "ChangeServiceConfig()");
        }
    } 
    else
    {
        if (mIsNtService())
        {
            UninstallNtService();
            for(int i = 0; i < 60; i++)
            {
                ::Sleep(500);
                if (!mIsNtService())
                    break;
            }
            if (i == 60)
                WarThrow(WarError(WAR_ERR_TIMED_OUT), "UninstallNtService()");
        }
        WarNtServiceMgr my_mgr;
        my_mgr.Create(mRootPtr->GetMachineName().c_str(),
            SC_MANAGER_ALL_ACCESS, true);

        // Install 
        SC_HANDLE sc_svc = ::CreateService(my_mgr,
            mName.c_str(),
            mRegKey.GetStrValue(WAR_WINNT_REG_NAME, NULL, true).c_str(),
            SERVICE_ALL_ACCESS,
            SERVICE_WIN32_OWN_PROCESS,
            doAutoStart ? SERVICE_AUTO_START : SERVICE_DEMAND_START,
            SERVICE_ERROR_NORMAL,
            startup_path.GetPath(),
            NULL,
            NULL,
            NULL,
            (userName && *userName) ? user_name.GetPath() : NULL,
            (userPasswd && *userPasswd) ? userPasswd : NULL);
        
        if (NULL == sc_svc)
            WarThrow(WarSystemError(), NULL);
        
        ::CloseServiceHandle(sc_svc);
    }

    mRegKey.SetValue(WAR_WINNT_RUN_AS_USER, userName ? userName : _T("System"));
    mRegKey.SetValue(WAR_WINNT_RUN_AS_USER_PWD, 
        userPasswd ? userPasswd : _T(""), true);
}

void WarIfServer::SetPriority(const WarPrioritiesDefE newPriority)
{
    mRegKey.SetValue(WAR_WINNT_REG_PRIORITY, newPriority);
}

void WarIfServer::StartService() throw (WarException)
{
    WarNtServiceSvc my_svc;
    
    my_svc.Create(mRootPtr->GetMachineName().c_str(),
        SC_MANAGER_ALL_ACCESS, mName.c_str(), 
        SERVICE_ALL_ACCESS);

    my_svc.StartService();
}

void WarIfServer::PauseService() throw (WarException)
{
    WarNtServiceSvc my_svc;
    
    my_svc.Create(mRootPtr->GetMachineName().c_str(),
        SC_MANAGER_ALL_ACCESS, mName.c_str(), 
        SERVICE_ALL_ACCESS);

    my_svc.PauseService();
}

void WarIfServer::StopService() throw (WarException)
{
    WarNtServiceSvc my_svc;
    
    my_svc.Create(mRootPtr->GetMachineName().c_str(),
        SC_MANAGER_ALL_ACCESS, mName.c_str(), 
        SERVICE_ALL_ACCESS);

    my_svc.StopService();
}

//============================= ACCESS     ===================================
//============================= INQUIRY    ===================================

WarPrioritiesDefE WarIfServer::GetPriority() const
{
    return (WarPrioritiesDefE)mRegKey.GetIntValue(
        WAR_WINNT_REG_PRIORITY, WAR_THRD_PRI_NORMAL);
}

void WarIfServer::EnumLogModules(strlist_t& logModuleList, 
                                 bool hideDisabled) const 
                                 throw (WarException)
{
    WarWin32Registry log_key;
    WarWin32Registry::keyname_list_t keys;

    log_key.Open(mRegKey.GetRef(WAR_WINNT_REG_LOG_MODULES));

    log_key.EnumKey(keys);

    for(WarWin32Registry::keyname_list_t::const_iterator P = keys.begin()
        ; P != keys.end()
        ; P++)
    {
        WarWin32Registry module_key;

        try
        {
            module_key.Open(log_key.GetRef(P->c_str()));

            // Bail out if there is no "Class ID" 
            module_key.GetStrValue(WAR_WINNT_REG_CLASSID, NULL, true);

            if (hideDisabled 
                && !module_key.GetIntValue(WAR_WINNT_REG_ENABLE, false))
                continue;

            // Add it
            logModuleList.push_back(*P);
        }
        catch(WarException) 
        {
            ;
        }
    }
}

war_ccsysstr_t WarIfServer::GetName() const
{
    return mName.c_str();
}

void WarIfServer::EnumSites(war_if_site_list_t& siteList,
        bool hideDisabled)  
        throw (WarException)
{
    WarWin32Registry sites_root_key;
    WarWin32Registry::keyname_list_t keys;

    sites_root_key.Open(mRegKey.GetRef(WAR_WINNT_REG_SITES));
    sites_root_key.EnumKey(keys);

     for(WarWin32Registry::keyname_list_t::const_iterator P = keys.begin()
        ; P != keys.end()
        ; P++)
    {
        WarWin32Registry site_key;

        try
        {
            site_key.Open(sites_root_key.GetRef(P->c_str()));

            // Bail out if there is no "Class ID" 
            war_regstr_t class_id = site_key.GetStrValue(
                WAR_WINNT_REG_CLASSID, NULL, true);

            if (class_id != war_regstr_t(_T(WAR_CLSID_SITE)))
                continue;

            if (hideDisabled 
                && !site_key.GetIntValue(WAR_WINNT_REG_ENABLE, false))
                continue;

            // Add it
            siteList.push_back(new WarIfSite(
                war_if_server_ptr_t(this), site_key));

        }
        catch(WarException) 
        {
            ;
        }
    }
}

bool WarIfServer::mIsNtService() const
{
    bool rval = false;

    WarNtServiceSvc my_service;

    try
    {
        my_service.Create(mRootPtr->GetMachineName().c_str(),
            GENERIC_READ, mName.c_str(), SERVICE_QUERY_CONFIG);
        rval = true;
    }
    catch(WarException)
    {
    }
    
    return rval;
}

bool WarIfServer::mIsAutoStartNtService() const
{
    bool rval = false;

    WarNtServiceSvc my_service;

    try
    {
        my_service.Create(mRootPtr->GetMachineName().c_str(),
            GENERIC_READ, mName.c_str(), SERVICE_QUERY_CONFIG);
    }
    catch(WarException)
    {
    }
    
#define QSC_BUF_LEN (1024 * 16)
    char buf[QSC_BUF_LEN];
    LPQUERY_SERVICE_CONFIG qsc_buf = (LPQUERY_SERVICE_CONFIG)buf;
    memset(qsc_buf, 0, QSC_BUF_LEN);
    DWORD foo = 0;
    
    if (QueryServiceConfig(my_service, qsc_buf, QSC_BUF_LEN, &foo))
    {
        rval = (qsc_buf->dwStartType == SERVICE_AUTO_START);
    }
    
    return rval;
}

WarIfServer::namestr_t WarIfServer::GetLoginName() const
{
    return mRegKey.GetStrValue(WAR_WINNT_RUN_AS_USER);
}

WarIfServer::passwdstr_t WarIfServer::GetLoginPasswd() const
{
    WarIfServer::passwdstr_t buf(WarIfServer::passwdstr_t::SM_ERASE);
    
    buf = mRegKey.GetStrValue(WAR_WINNT_RUN_AS_USER_PWD, NULL, false, true);

    {
        char erase_stack[1024];
        memset(erase_stack, 0, sizeof(erase_stack));
    }

    return buf;
}

void WarIfServer::GetNtServiceStatus(SERVICE_STATUS& currentStatus)
throw(WarException)
{
    WarNtServiceSvc my_svc;

    memset(&currentStatus, 0, sizeof(currentStatus));
    
    my_svc.Create(mRootPtr->GetMachineName().c_str(),
        SC_MANAGER_ALL_ACCESS, mName.c_str(), 
        SERVICE_QUERY_STATUS);

    if (!::QueryServiceStatus(my_svc, &currentStatus))
        WarThrow(WarSystemError(), "QueryServiceStatus()");
}


/////////////////////////////// PROTECTED  ///////////////////////////////////


/////////////////////////////// PRIVATE    ///////////////////////////////////