icputils.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "DAEstatus.h"
#include "icputils.h"

Poco::SingletonHolder<ICPClock> g_icp_clock;

std::string convertLatin1ToUTF8(const std::string& latin_string)
{
        Poco::Latin1Encoding latin1;
        Poco::UTF8Encoding utf8;
        Poco::TextConverter text_converter(latin1, utf8);
        std::string utf8_string;
        text_converter.convert(latin_string, utf8_string);
        return utf8_string;
}

std::string convertWindows1252ToUTF8(const std::string& win_string)
{
        Poco::Windows1252Encoding win1252;
        Poco::UTF8Encoding utf8;
        Poco::TextConverter text_converter(win1252, utf8);
        std::string utf8_string;
        text_converter.convert(win_string, utf8_string);
        return utf8_string;
}


ICPTimer::ICPTimer() : m_status(NULL)
{
        start();
}

ICPTimer::ICPTimer(const char* title, DAEstatus& status) : m_status(&status)
{
        start(title);
}

ICPTimer::~ICPTimer()
{
        if (m_status != NULL)
        {
                info(m_title.c_str(), *m_status);
        }
}

void ICPTimer::start(const char* title)
{
        if (title != NULL)
        {
                m_title = title;
        }
        m_ts.fromEpochTime(time(NULL));
        GetSystemTime(&m_st);
        ftime(&m_tb);
        if (GetThreadTimes(GetCurrentThread(), &m_thread_times.create, &m_thread_times.exit, &m_thread_times.kernel, &m_thread_times.user) == 0)
        {
                memset(&m_thread_times, 0, sizeof(m_thread_times));
        }
        if (GetProcessTimes(GetCurrentProcess(), &m_process_times.create, &m_process_times.exit, &m_process_times.kernel, &m_process_times.user) == 0)
        {
                memset(&m_process_times, 0, sizeof(m_process_times));
        }
}

// labview by default only unescapes &lt; &gt; and &amp; so we need to do any others ourselves

static const char* escape_sequence[] = { "&quot;", "&apos;" };
static const int escape_length[] = { 6, 6 };  // lengths of above
static const char* escape_replace[] = { "\"", "\'" };

std::string unescapeXML(const char* xml_str)
{
        std::string s;
        size_t n = strlen(xml_str);
        s.reserve(n);
        int j;
        size_t i = 0;
        bool done_escape;
        while(i<n)
        {
                if (xml_str[i] == '&')
                {
                        done_escape = false;
                        for(j=0; !done_escape && (j < sizeof(escape_sequence) / sizeof(const char*)); j++)
                        {
                                if (strncmp(xml_str+i, escape_sequence[j], escape_length[j]) == 0)
                                {
                                        s.push_back(*(escape_replace[j]));
                                        i += escape_length[j];
                                        done_escape = true;
                                }
                        }
                        // maybe &#nnn; sequence
                        if ( !done_escape && (xml_str[i+1] == '#') )
                        {
                                sscanf(xml_str+i, "&#%d;", &j);
                                s.push_back((char)j);
                                i = i + 4 + (j > 9 ? 1 : 0) + (j > 99 ? 1 : 0);
                                done_escape = true;
                        }
                        // unrecognised escape sequence - could be &amp; (OK) or one we don't yet know to handle (not OK)
                        if ( !done_escape )
                        {
                                s.push_back(xml_str[i]);
                                ++i;
                        }
                }
                else
                {
                        s.push_back(xml_str[i]);
                        ++i;
                }
        }
        return s;
}

std::string escapeXML(const char* xml_str)
{
        char buffer[10];
        std::string s;
        size_t n = strlen(xml_str);
        s.reserve(n+10);
    while (*xml_str)
    {
          if (*xml_str == '&')
                        s.append("&amp;");
          else if (*xml_str == '<')
            s.append("&lt;");
          else if (*xml_str == '>')
            s.append("&gt;");
          else if (*xml_str == '\"')
            s.append("&quot;");
          else if (*xml_str == '\'')
            s.append("&apos;");
          else if (*xml_str & 128)
          {
           /*
            * Convert UTF-8 to Unicode constant...
            */
            int ch;                     /* Unicode character */
            ch = *xml_str & 255;
            if ((ch & 0xe0) == 0xc0)
            {
              ch = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
                  xml_str++;
            }
            else if ((ch & 0xf0) == 0xe0)
            {
              ch = ((((ch * 0x0f) << 6) | (s[1] & 0x3f)) << 6) | (s[2] & 0x3f);
                  xml_str += 2;
            }

            if (ch == 0xa0)
            {
             /*
              * Handle non-breaking space as-is...
                  */
                           s.append("&nbsp;");
            }
            else
                        {
              sprintf(buffer, "&#x%x;", ch);
                          s.append(buffer);
                        }
                  }
          else
                  {
                          s.push_back(*xml_str);
                  }
          xml_str++;
    }
        return s;
}


double ICPTimer::info(const char* title, std::ostream& os, bool add_nl)
{
        ICPTimer tim_end;
        double tdiff1ms = ( (tim_end.m_tb.millitm - m_tb.millitm) +
                                         1000.0 * difftime(tim_end.m_tb.time, m_tb.time) );
        double tdiff1 = tdiff1ms / 1000.0;
// tdiff2 does not allow for a day change
        double tdiff2 = 3600.0 * (double)(tim_end.m_st.wHour - m_st.wHour) +
                              60.0 * (double)(tim_end.m_st.wMinute - m_st.wMinute) +
                                             (double)(tim_end.m_st.wSecond - m_st.wSecond) + 
                                             (double)(tim_end.m_st.wMilliseconds - m_st.wMilliseconds) / 1000.0;
        double tdiff3 = m_ts.elapsed() / 1.0e6;
        os << "*** Timing information for " << title << ": real(" << tdiff3 << 
                                ") thread(kernel=" << diffFileTimesInMilliSec(m_thread_times.kernel, tim_end.m_thread_times.kernel) / 1.0e3 <<
                                ", user=" << diffFileTimesInMilliSec(m_thread_times.user, tim_end.m_thread_times.user) / 1.0e3 <<
                    ") process(kernel=" << diffFileTimesInMilliSec(m_process_times.kernel, tim_end.m_process_times.kernel) / 1.0e3 <<
                    ", user=" << diffFileTimesInMilliSec(m_process_times.user, tim_end.m_process_times.user) / 1.0e3 << (add_nl ? ")\n" : ")");
    return tdiff3;
}


double ICPTimer::info(const char* title, DAEstatus& status)
{
        std::ostringstream oss;
        double d = info(title, oss, false);
        status.addInfo(FAC_DAE, oss.str());
        return d;
}

   void AddEventSource( PCTSTR pszName, PCTSTR pszMessageFile, DWORD dwCategoryCount)
    {
        HKEY    hRegKey = NULL; 
        DWORD   dwError = 0;
        TCHAR   szPath[ MAX_PATH ];
        
        _stprintf( szPath, 
          _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s"), 
          pszName );

        // Create the event source registry key
        dwError = RegCreateKey( HKEY_LOCAL_MACHINE, szPath, &hRegKey );

        // Name of the PE module that contains the message resource
        GetModuleFileName( NULL, szPath, MAX_PATH );

        // Register EventMessageFile
        dwError = RegSetValueEx( hRegKey, 
                  _T("EventMessageFile"), 0, REG_EXPAND_SZ, 
                  (PBYTE) pszMessageFile, (_tcslen( pszMessageFile) + 1) * sizeof TCHAR ); 
        
        // Register supported event types
        DWORD dwTypes = EVENTLOG_ERROR_TYPE | 
              EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE | EVENTLOG_SUCCESS; 
        dwError = RegSetValueEx( hRegKey, _T("TypesSupported"), 0, REG_DWORD, 
                                (LPBYTE) &dwTypes, sizeof dwTypes );

        // If we want to support event categories,
        // we have also to register the CategoryMessageFile.
        // and set CategoryCount. Note that categories
        // need to have the message ids 1 to CategoryCount!

        if( dwCategoryCount > 0 ) {

            dwError = RegSetValueEx( hRegKey, _T("CategoryMessageFile"), 
                      0, REG_EXPAND_SZ, (PBYTE) szPath, 
                      (_tcslen( szPath) + 1) * sizeof TCHAR );

            dwError = RegSetValueEx( hRegKey, _T("CategoryCount"), 0, REG_DWORD, 
                      (PBYTE) &dwCategoryCount, sizeof dwCategoryCount );
        }
            
        RegCloseKey( hRegKey );
    } 


// md5sum must be long enough to take 16 characters (see md5checksum_t )
int md5sumFile(const char* filename, unsigned char* md5sum, DAEstatus& status)
{
        struct stat stat_buffer;
        int len;
        memset(md5sum, 0, sizeof(md5checksum_t));
        if (stat(filename, &stat_buffer) != 0)
        {
                return DAEstatus::Failure;
        }
        FILE* f = _fsopen(filename, "rbN", _SH_DENYNO);
        if (f == NULL)
        {
                return DAEstatus::Failure;
        }
        len = stat_buffer.st_size;
        unsigned char* buffer = new unsigned char[len];
        fread(buffer, 1, len, f);
        fclose(f);
        md5sumString(buffer, len, md5sum, status);
        delete []buffer;
        return status.result();
}

// md5sum must be long enough to take 16 characters (see md5checksum_t )
int md5sumString(const void* buffer, int len, unsigned char* md5sum, DAEstatus& status)
{
        static MD5Init_t MD5Init = 0;
        static MD5Update_t MD5Update = 0;
        static MD5Final_t MD5Final = 0;
        static HINSTANCE hcrypt = 0;
        memset(md5sum, 0, sizeof(md5checksum_t));
        if (MD5Init == 0)
        {
                hcrypt = LoadLibrary("cryptdll.dll");
                if (hcrypt == 0)
                {
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                "cannot load cryptdll.dll");
                        return DAEstatus::Failure;
                }
                MD5Init = (MD5Init_t)GetProcAddress(hcrypt, "MD5Init");
                MD5Update = (MD5Update_t)GetProcAddress(hcrypt, "MD5Update");
                MD5Final = (MD5Final_t)GetProcAddress(hcrypt, "MD5Final");
        }
        if (MD5Init == 0)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                "cannot find MD5Init in cryptdll.dll");
                return DAEstatus::Failure;
        }
        MD5_CTX context;
        (*MD5Init)(&context);
        (*MD5Update)(&context, (const unsigned char*)buffer, len);
        (*MD5Final)(&context);
        memcpy((char*)md5sum, (const char*)context.digest, sizeof(context.digest));
        return DAEstatus::Success;
}

// return true if checksums the same
// all zeros means uninitialised checksum so return false if compare two
bool compareChecksums(const unsigned char* md5sum1, const unsigned char* md5sum2)
{
        int i, sum = 0;
        for(i=0; i<sizeof(md5checksum_t); i++)
        {
                sum = sum + md5sum1[i] + md5sum2[i];
                if (md5sum1[i] != md5sum2[i])
                {
                        return false;
                }
        }
        if (sum == 0)
        {
                return false;
        }
        return true;
}

int updateChecksum(unsigned char* md5sum1, const unsigned char* md5sum2)
{
        memcpy(md5sum1, md5sum2, sizeof(md5checksum_t));
        return DAEstatus::Success;
}

// parge a [23:234] expression
int parseSpectraRange(const std::string& spec_range, int& spec_from, int& spec_to)
{
        size_t i, j, k;
        spec_from = spec_to = 0;
        i = spec_range.find('[');
        j = spec_range.find(':');
        k = spec_range.find(']');
        if (i == std::string::npos || j == std::string::npos || k == std::string::npos)
        {
                return DAEstatus::Failure;
        }
        spec_from = atoi(spec_range.substr(i+1,j-i-1).c_str());
        spec_to = atoi(spec_range.substr(j+1,k-j-1).c_str());
        return DAEstatus::Success;
}

std::string checksumAsString(md5checksum_t checksum)
{
        std::stringstream s;
        s << std::hex;
        for(int i=0; i<sizeof(md5checksum_t); i++)
        {
                s << (unsigned)checksum[i];
        }
        s << std::dec;
        return s.str();
}



struct MyOverlapped : public OVERLAPPED
{
private:
        MyOverlapped() {}
public:
        overlap_complete_func_t func;
        void* arg;
        MyOverlapped(overlap_complete_func_t func_, void* arg_) : func(func_), arg(arg_)
        {
                memset(this, 0, sizeof(OVERLAPPED));
        }
};

struct my_overlap_t
{
private:
        my_overlap_t() {}
public:
        HANDLE h;
    char* data;
        my_overlap_t(HANDLE h_, const char* data_) : h(h_), data(0) 
        {
                data = strdup(data_);
        }
        ~my_overlap_t()
        {
                free(data);
                if (h != INVALID_HANDLE_VALUE)
                {
                        CloseHandle(h);
                }
        }
};

static void my_overlap(void* arg)
{
        my_overlap_t* ov = (my_overlap_t*)arg;
        delete ov;
}

static HANDLE file_complete = NULL;

void my_io_complete(void* arg)
{
        DWORD ntrans = 0;
        ULONG_PTR key = 0;
        MyOverlapped* overlapped = 0;
        while(true)
        {
                GetQueuedCompletionStatus(file_complete, &ntrans, &key, (OVERLAPPED**)&overlapped, INFINITE);
                (*(overlapped->func))(overlapped->arg);
                delete overlapped;
        }
}


HANDLE createAppendFile(const char* filename)
{
        if (file_complete == NULL)
        {
                file_complete = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 1);
                _beginthread(my_io_complete, 0, NULL);
        }
        // need to specify FILE_SHARE_WRITE so other threads in this process can access it etc.
        HANDLE h = CreateFile(filename, FILE_APPEND_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, 
                        defaultNoInheritHandles(), OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
        if (h != INVALID_HANDLE_VALUE)
    {
            CreateIoCompletionPort(h, file_complete, 0 ,1);
    }
        return h;
}

void appendToFileAsync(HANDLE h, const char* message, bool close_after_write)
{
        if (message == NULL)
        {
                return;
        }
        if (h != INVALID_HANDLE_VALUE)
        {
                my_overlap_t* arg;
                if (close_after_write)
                {
                        arg = new my_overlap_t(h, message);
                }
                else
                {
                        arg = new my_overlap_t(INVALID_HANDLE_VALUE, message);
                }
                MyOverlapped* overlapped = new MyOverlapped(my_overlap, arg);
                WriteFile(h, arg->data, static_cast<DWORD>(strlen(message)), NULL, overlapped);
        }
}

void appendToFileAsync(const char* filename, const char* message)
{
        if (message == NULL)
        {
                return;
        }
        HANDLE h = createAppendFile(filename);
        if (h != INVALID_HANDLE_VALUE)
        {
                appendToFileAsync(h, message, true);
        }
}


int findFiles(const char* directory, const char* pattern, std::vector<std::string>& list, bool full_path)
{
  WIN32_FIND_DATA FindFileData;
  HANDLE hFind;
  list.clear();
  std::string match = std::string(directory) + "\\" + std::string(pattern);
  std::string file;
  hFind = FindFirstFile(match.c_str(), &FindFileData);
  if (hFind == INVALID_HANDLE_VALUE)
  {
          return 0;
  }
  if (full_path)
  {
          file = std::string(directory) + "\\" + std::string(FindFileData.cFileName);
  }
  else
  {
          file = std::string(FindFileData.cFileName);
  }
  list.push_back(file);
  while(FindNextFile(hFind, &FindFileData) != 0)
  {
        if (full_path)
        {
          file = std::string(directory) + "\\" + std::string(FindFileData.cFileName);
        }
        else
        {
          file = std::string(FindFileData.cFileName);
        }
        list.push_back(file);
  }
  FindClose(hFind);
  return 0;
}

#include "Poco/StreamCopier.h"
#include "Poco/Path.h"
#include "Poco/URI.h"
#include "Poco/Exception.h"

#include "Poco/Net/HTTPClientSession.h"
#include "Poco/Net/HTTPRequest.h"
#include "Poco/Net/HTTPResponse.h"
#include "Poco/Net/HTMLForm.h"

#include "Poco/Net/SMTPClientSession.h"
#include "Poco/Net/MailMessage.h"
#include "Poco/Net/MailRecipient.h"
#include "Poco/Net/StringPartSource.h"

#include "Poco/StringTokenizer.h"

static int sendSMSMain(const std::string& phone, const std::string& message, DAEstatus& status)
{
        using Poco::Net::HTTPClientSession;
        using Poco::Net::HTTPRequest;
        using Poco::Net::HTTPResponse;
        using Poco::Net::HTTPMessage;
        using Poco::Net::HTMLForm;
        using Poco::StreamCopier;
        using Poco::Path;
        using Poco::URI;
        using Poco::Exception;
        try
        {
                HTTPClientSession session("www.kapow.co.uk");
                HTMLForm form;
                form.set("username","isissms");
                form.set("password","camacdead");
                form.set("mobile",phone);
                form.set("sms",message);
                session.setProxy("wwwcache.rl.ac.uk", 8080);
                HTTPRequest request(HTTPRequest::HTTP_POST, "/scripts/sendsms.php", HTTPMessage::HTTP_1_1);
                std::ostringstream oss;
                form.prepareSubmit(request);
                HTTPResponse res;
                std::ostream& os = session.sendRequest(request);
                form.write(os);
                std::istream& rs = session.receiveResponse(res);
                oss << "SMS status: " << res.getStatus() << " " << res.getReason() << " ";
                StreamCopier::copyStream(rs, oss);
                status.addInfo(FAC_DAE, oss.str());
        }
        catch(Exception& exc)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, exc.displayText());
        }
        return 0;
}

int sendSMS(const std::string& phone, const std::string& message, DAEstatus& status)
{
        using Poco::StringTokenizer;
        status.addInfoVa(FAC_DAE, "Sending SMS text to %s: %s", phone.c_str(), message.c_str());
        StringTokenizer tokenizer(phone, ";,", StringTokenizer::TOK_IGNORE_EMPTY|StringTokenizer::TOK_TRIM);
        for (StringTokenizer::Iterator it = tokenizer.begin(); it != tokenizer.end(); ++it)
        {
                sendSMSMain(*it, message, status);
        }
//      sendSMSMain("07766422175", message, status);
        return 0;
}

int sendEmail(const std::string& sender, const std::string& recipient, const std::string& subject, const std::string& content, DAEstatus& status)
{
        using Poco::Net::MailMessage;
        using Poco::Net::MailRecipient;
        using Poco::Net::SMTPClientSession;
        using Poco::Net::StringPartSource;
        using Poco::Path;
        using Poco::Exception;
        using Poco::StringTokenizer;
        status.addInfoVa(FAC_DAE, "Sending email to %s: %s", recipient.c_str(), subject.c_str());
        try
        {
                MailMessage message;
                message.setSender(sender);
                StringTokenizer tokenizer(recipient, ";,", StringTokenizer::TOK_IGNORE_EMPTY|StringTokenizer::TOK_TRIM);
                for (StringTokenizer::Iterator it = tokenizer.begin(); it != tokenizer.end(); ++it)
                {
                        message.addRecipient(MailRecipient(MailRecipient::PRIMARY_RECIPIENT, *it));
                }
                if (tokenizer.count() == 0)
                {
                        message.addRecipient(MailRecipient(MailRecipient::PRIMARY_RECIPIENT, "freddie.akeroyd@stfc.ac.uk"));
                }
                else
                {
                        message.addRecipient(MailRecipient(MailRecipient::BCC_RECIPIENT, "freddie.akeroyd@stfc.ac.uk"));
                }
                message.setSubject(subject);
                message.addContent(new StringPartSource(content));
                SMTPClientSession session("outbox.nd.rl.ac.uk");
                session.login();
                session.sendMessage(message);
                session.close();
        }
        catch(Exception& exc)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, exc.displayText());
        }
        return 0;
}

double diffFileTimesInMilliSec(const FILETIME& start, const FILETIME& finish)
{
        return diffFileTimes(start, finish) / 1.0e4;
}

LONGLONG diffFileTimes(const FILETIME& start, const FILETIME& finish)
{
        ULARGE_INTEGER ularge1, ularge2;
        ularge1.LowPart = start.dwLowDateTime;
        ularge1.HighPart = start.dwHighDateTime;
        ularge2.LowPart = finish.dwLowDateTime;
        ularge2.HighPart= finish.dwHighDateTime;
        if (ularge2.QuadPart > ularge1.QuadPart)
        {
                return ularge2.QuadPart - ularge1.QuadPart;
        }
        else
        {
                return -static_cast<LONGLONG>(ularge1.QuadPart - ularge2.QuadPart);
        }
}

off_t file_size_bytes(const std::string& filename)
{
        struct stat stat_buffer;
        if (stat(filename.c_str(), &stat_buffer) == 0)
        {
                return stat_buffer.st_size;
        }
        else
        {
                return 0;
        }
}


template <typename T>
void findConsecutive(const std::vector<T>& vec, T invalid_val, std::vector<int>& indexes, std::vector<int>& sizes)
{
        indexes.clear();
        sizes.clear();
        int start = -1;
        for(int i=0; i<vec.size(); ++i)
        {
                if (vec[i] != invalid_val)
                {
                        start = i;
                        break;
                }
        }
        if (start == -1)
        {
                return;
        }
        indexes.push_back(start);
        int len = 1;
        int j = start + 1;
        while(j < vec.size())
        {
                if (vec[j] != invalid_val)
                {
                        if ( (vec[j] - vec[j-1]) == 1 )
                        {
                                ++len;
                        }
                        else
                        {
                                sizes.push_back(len);
                                indexes.push_back(j);
                                len = 1;
                        }
                        ++j;
                }
                else
                {
                        start = -1;
                        for(int k=j+1; (k < vec.size()) && (start == -1); ++k)
                        {
                                if (vec[k] != invalid_val)
                                {
                                        start = k;
                                }
                        }
                        if (start != -1)
                        {
                                j = start + 1;
                                sizes.push_back(len);
                                indexes.push_back(start);
                                len = 1;
                        }
                        else
                        {
                                j = vec.size();   // terminate loop
                        }
                }
        }
        sizes.push_back(len);
        // check result
        for(int i=0; i<indexes.size(); ++i)
        {
                for(j=0; j<sizes[i]; ++j)
                {
                        if (vec[indexes[i]+j] == invalid_val)
                        {
                                throw std::exception("invalid val");
                        }
                        if ( (j != 0) && ((vec[indexes[i]+j] - vec[indexes[i]+j-1]) != 1) )
                        {
                                throw std::exception("not consec");
                        }
                }
        }
        for(int i=1; i<indexes.size(); ++i)
        {
                if ( (indexes[i-1] + sizes[i-1]) > indexes[i] )
                {
                        throw std::exception("range overlap");
                }
        }
}

int compareBuffers(const std::string& title, const isisU32_t* buffer1, const isisU32_t* buffer2, int nbuffer, DAEstatus& status)
{
                int i;
                std::vector<int> error_locs;
                for(i=0; i<nbuffer; ++i)
                {
                        if (buffer1[i] != buffer2[i])
                        {
                                error_locs.push_back(i);
                        }
                }
                if (error_locs.size() > 0)
                {
                        std::ostringstream oss;
                        std::vector<int> indexes, sizes;
                        oss << title;
                        findConsecutive(error_locs, -1, indexes, sizes);
                        for(i=0; i<indexes.size(); ++i)
                        {
                                oss << " " << error_locs[indexes[i]] << "-" << error_locs[indexes[i]+sizes[i]-1];
                        }
                        status.addInfoVa(FAC_DAE, "%s", oss.str().c_str());
                }
                return 0;
}


template void findConsecutive(const std::vector<int>& vec, int invalid_val, std::vector<int>& indexes, std::vector<int>& sizes);

static Poco::Mutex atomic_mutex_impl;
Poco::Mutex* atomic_mutex = &atomic_mutex_impl;

class DebuggerChannel : public Poco::Channel
{
        public:
                void log(const Poco::Message& msg)
                {
                        OutputDebugString((msg.getText() + "\n").c_str());
                }
};

class ICPFileChannel : public Poco::Channel
{
        private:
                DAEstatus m_status;
                static DAEreport_func_t* m_report_func;
                static void* m_report_arg;

        public:
                ICPFileChannel() : Poco::Channel()
                {
                        m_status.reportImmediately(true);
                }

                static void setReporter(DAEreport_func_t* report_func, void* report_arg)
                {
                        m_report_func = report_func;
                        m_report_arg = report_arg;
                }

                void log(const Poco::Message& msg)
                {
                        m_status.setReportFunction(m_report_func, m_report_arg);
                        m_status.addInfo(FAC_DAE, msg.getText());
                }
};

DAEreport_func_t*ICPFileChannel::m_report_func = NULL;
void* ICPFileChannel::m_report_arg = NULL;

class TestChannel : public Poco::Channel
{
private:
        std::list<Poco::Message> m_messages;

public:
        void log(const Poco::Message& msg)
        {
                m_messages.push_back(msg);
        }
};

void registerExtraLoggerChannels()
{
        // the instantiators are deleted in the destructor for logging factory, so need to use "new"
        Poco::Instantiator<DebuggerChannel, Poco::Channel> *debugger_channel_instantiator = new Poco::Instantiator<DebuggerChannel, Poco::Channel>;
        Poco::Instantiator<ICPFileChannel, Poco::Channel> *icp_file_channel_instantiator = new Poco::Instantiator<ICPFileChannel, Poco::Channel>;
    Poco::LoggingFactory::defaultFactory().registerChannelClass("DebuggerChannel", debugger_channel_instantiator);
    Poco::LoggingFactory::defaultFactory().registerChannelClass("ICPFileChannel", icp_file_channel_instantiator);
}

void setICPChannelReporter(DAEreport_func_t* report_func, void* report_arg)
{
        ICPFileChannel::setReporter(report_func, report_arg);
}

void getConfigStringList(std::vector<std::string>& string_list, const std::string& config_item)
{
        string_list.clear();
        std::string config_value = Poco::Util::Application::instance().config().getString(config_item, "");
        Poco::StringTokenizer toks(config_value, ";", Poco::StringTokenizer::TOK_IGNORE_EMPTY|Poco::StringTokenizer::TOK_TRIM);
        std::copy(toks.begin(), toks.end(), back_inserter(string_list));
}

void getConfigIntList(std::vector<int>& int_list, const std::string& config_item)
{
        int_list.clear();
        std::vector<std::string> string_list;
        getConfigStringList(string_list, config_item);
        BOOST_FOREACH(const std::string& s, string_list)
        {
                int_list.push_back(atoi(s.c_str()));
        }
}

int loadAppConfig(const std::string& app_name)
{
        Poco::Util::Application& the_app = Poco::Util::Application::instance();
        std::string app_dir;
        try 
        {
                app_dir = the_app.config().getString("application.dir");
        }
        catch(const std::exception& ex)
        {
                the_app.logger().fatal(std::string("Cannot determine application.dir ") + ex.what());
                std::cerr << "Cannot determine application.dir " << ex.what() << std::endl;
                return -1;
        }
        Poco::Path app_props(app_dir+"/../../..", app_name+".properties"); 
        Poco::Path app_props_default(app_dir+"/../../..", app_name+".default.properties"); 
        app_props.makeAbsolute();
        app_props_default.makeAbsolute();
        // poco configurations have priorities that govern search order
        // lower number -> searched first, with PRIO_APPLICATION searched before PRIO_DEFAULT before PRIO_SYSTEM
        try
        {
                the_app.loadConfiguration(app_props_default.toString(), Poco::Util::Application::PRIO_DEFAULT);
        }
        catch(const std::exception& ex)
        {
                the_app.logger().fatal(std::string("Cannot load ") + app_props_default.toString() + ex.what());
                std::cerr << "Cannot load " << app_props_default.toString() << ex.what() << std::endl;
                return -1;
        }
        try 
        {
                the_app.loadConfiguration(app_props.toString(), Poco::Util::Application::PRIO_APPLICATION);
        }
        catch(const std::exception& ex)
        {
                the_app.logger().information(std::string("Cannot load ") + app_props.toString() + ex.what());
                std::cerr << "Cannot load " << app_props.toString() << ex.what() << std::endl;
        }
        return 0;
}


// 0 on success, -1 on error
static int flushed_write(const std::vector<std::string>& files, const std::vector<const void*>& data, const std::vector<int>& nbytes)
{
        std::vector<FILE*> fp;
        BOOST_FOREACH(const std::string& filename, files)
        {
                fp.push_back(fopen(filename.c_str(), "wbcN"));    // "c" forces commit to disk on fflush() 
        }
        for(int i=0; i<files.size(); ++i)
        {
                FILE* f = fp[i];
                if (f != NULL)
                {
                        if (std::fwrite(data[i], 1, nbytes[i], f) != nbytes[i])
                        { 
                                std::fclose(f); 
                                throw std::runtime_error("cannot write data"); 
                        }
                }
                else
                {
                        throw std::runtime_error("cannot open file");
                }
        }
        for(int i=0; i<files.size(); ++i)
        {
                FILE* f = fp[i];
                if (std::fflush(f) != 0)
                { 
                        std::fclose(f); 
                        throw std::runtime_error("cannot flush data"); 
                }
                if (std::fclose(f) != 0)
                { 
                        throw std::runtime_error("cannot close data"); 
                }
        }
        return 0;
}

// 0 on success, -1 on error
int flushed_write(const std::string& file, const void* data, int nbytes)
{
        std::vector<std::string> file_v;
        std::vector<const void*>data_v;
        std::vector<int> nbytes_v;
        file_v.push_back(file);
        data_v.push_back(data);
        nbytes_v.push_back(nbytes);
        return flushed_write(file_v, data_v, nbytes_v);
}

HANDLE createEmptyFile(const std::string& file_name, size_t file_size)
{
    HANDLE h = CreateFile(file_name.c_str(), GENERIC_READ | GENERIC_WRITE, 0, defaultNoInheritHandles(), CREATE_ALWAYS, 0, 0);
        if (h == INVALID_HANDLE_VALUE)
        {
                return INVALID_HANDLE_VALUE;
        }
        LARGE_INTEGER li;
        li.QuadPart = file_size;
    if (SetFilePointerEx(h, li, 0, FILE_BEGIN) == 0)
        {
                CloseHandle(h); 
                return INVALID_HANDLE_VALUE;
        }
    if (SetEndOfFile(h) == 0)
        {
                CloseHandle(h); 
                return INVALID_HANDLE_VALUE;
        }
        return h;
}


static void deviceNameToDriveLetter(TCHAR* pszFilename)
{
        // Translate path with device name to drive letters.
        const int buffer_size = 512;
        TCHAR szTemp[buffer_size];
        szTemp[0] = '\0';

        if (GetLogicalDriveStrings(buffer_size-1, szTemp)) 
        {
                TCHAR szName[MAX_PATH];
                TCHAR szDrive[3] = TEXT(" :");
                BOOL bFound = FALSE;
                TCHAR* p = szTemp;

                do 
                {
                        // Copy the drive letter to the template string
                        *szDrive = *p;

                        // Look up each device name
                        if (QueryDosDevice(szDrive, szName, MAX_PATH))
                        {
                                size_t uNameLen = _tcslen(szName);

                                if (uNameLen < MAX_PATH) 
                                {
                                        bFound = _tcsnicmp(pszFilename, szName, uNameLen) == 0;

                                        if (bFound && *(pszFilename + uNameLen) == _T('\\')) 
                                        {
                                                // Reconstruct pszFilename using szTempFile
                                                // Replace device path with DOS path
                                                TCHAR szTempFile[MAX_PATH];
                                                _snprintf(szTempFile, MAX_PATH, "%s%s", szDrive, pszFilename+uNameLen);
                                                strncpy(pszFilename, szTempFile, MAX_PATH);
                                                //                  StringCchPrintf(szTempFile, MAX_PATH, TEXT("%s%s"), szDrive, pszFilename+uNameLen);
                                                //                  StringCchCopyN(pszFilename, MAX_PATH+1, szTempFile, _tcslen(szTempFile));
                                        }
                                }
                        }

                        // Go to the next NULL character.
                        while (*p++);
                } while (!bFound && *p); // end of string
        }
}

std::string fileNameFromMappedView(void* pMem)
{
        TCHAR pszFilename[MAX_PATH+1];
        int n = GetMappedFileName(GetCurrentProcess(), pMem, pszFilename, MAX_PATH);
        pszFilename[n] = '\0';
        if (n > 0)
        {
                deviceNameToDriveLetter(pszFilename);
                return pszFilename;
        }
        else
        {
                return "";
        }
}

int64_t fileSizeBytes(const std::string& filename)
{
        int64_t the_size = 0;
        WIN32_FILE_ATTRIBUTE_DATA file_attr;
        if ( GetFileAttributesEx(filename.c_str(), GetFileExInfoStandard, &file_attr) != 0 )
        {
                the_size = (static_cast<int64_t>(file_attr.nFileSizeHigh) << 32) | file_attr.nFileSizeLow;
        }
        return the_size;
}


int createEmptyFileAndClose(const std::string& file_name, size_t file_size)
{
    HANDLE h = createEmptyFile(file_name, file_size);
        if (h == INVALID_HANDLE_VALUE)
        {
                return DAEstatus::Failure;
        }
        CloseHandle(h);
        return DAEstatus::Success;
}

void printComputerMemoryStats(DAEstatus& status)
{
        MEMORYSTATUSEX statex;
        statex.dwLength = sizeof(statex);
        if (GlobalMemoryStatusEx(&statex) != 0)
        {
                status.addInfoVa(FAC_DAE, "There is  %8ld percent of memory in use.", statex.dwMemoryLoad);
                status.addInfoVa(FAC_DAE, "There are %8I64d total Kbytes of physical memory.", statex.ullTotalPhys/1024);
                status.addInfoVa(FAC_DAE, "There are %8I64d free Kbytes of physical memory.", statex.ullAvailPhys/1024);
                status.addInfoVa(FAC_DAE, "There are %8I64d total Kbytes of paging file.", statex.ullTotalPageFile/1024);
                status.addInfoVa(FAC_DAE, "There are %8I64d free Kbytes of paging file.", statex.ullAvailPageFile/1024);
                status.addInfoVa(FAC_DAE, "There are %8I64d total Kbytes of virtual memory.", statex.ullTotalVirtual/1024);
                status.addInfoVa(FAC_DAE, "There are %8I64d free Kbytes of virtual memory.", statex.ullAvailVirtual/1024);
                status.addInfoVa(FAC_DAE, "There are %8I64d free Kbytes of extended memory", statex.ullAvailExtendedVirtual/1024);
        }
}

int removeWithRetry(const char* filename)
{
        int ret = -1, nretry = 30;
        while( (--nretry > 0) && ((ret = std::remove(filename)) != 0) )
        {
                Poco::Thread::sleep(1000);
        }
        return ret;
}

void pollUntilTasksComplete(const Poco::TaskManager& tm, int poll_time_in_ms)
{
        while(tm.count() > 0)
        {
                Poco::Thread::sleep(poll_time_in_ms);
        }
}

struct my_SECURITY_ATTRIBUTES : public SECURITY_ATTRIBUTES
{
        my_SECURITY_ATTRIBUTES() : SECURITY_ATTRIBUTES()
        { 
                ZeroMemory(this, sizeof(SECURITY_ATTRIBUTES));
                nLength = sizeof(SECURITY_ATTRIBUTES);
                lpSecurityDescriptor = NULL;
                bInheritHandle = FALSE;
        }
};

static my_SECURITY_ATTRIBUTES my_security_attributes;

SECURITY_ATTRIBUTES* defaultNoInheritHandles()
{
        return &my_security_attributes;
}