modularization/src/common/modulecomm/shm/procsm.cpp

#include <iostream>
#include <thread>
#include <QTime>
#include <QThread>
#include <algorithm>
#include "procsm.h"

#ifdef Q_OS_LINUX
#include <unistd.h>
#endif

#include <QFile>
#include <QDir>


//#define RESET   "\033[0m"
//#define BLACK   "\033[30m"      /* Black */
//#define RED     "\033[31m"      /* Red */
//#define GREEN   "\033[32m"      /* Green */
//#define YELLOW  "\033[33m"      /* Yellow */
//#define BLUE    "\033[34m"      /* Blue */
//#define MAGENTA "\033[35m"      /* Magenta */
//#define CYAN    "\033[36m"      /* Cyan */
//#define WHITE   "\033[37m"      /* White */
//#define BOLDBLACK   "\033[1m\033[30m"      /* Bold Black */
//#define BOLDRED     "\033[1m\033[31m"      /* Bold Red */
//#define BOLDGREEN   "\033[1m\033[32m"      /* Bold Green */
//#define BOLDYELLOW  "\033[1m\033[33m"      /* Bold Yellow */
//#define BOLDBLUE    "\033[1m\033[34m"      /* Bold Blue */
//#define BOLDMAGENTA "\033[1m\033[35m"      /* Bold Magenta */
//#define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
//#define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */

class AttachThread : public QThread
{
  public:
    AttachThread(QSharedMemory * pa,bool & bAttach)
    {
       mbAttach = bAttach;
       mpa = pa;
       mbrun = true;
    }
    QSharedMemory * mpa;
    bool mbAttach = false;
    bool mbrun = true;
    void run()
    {
        mbAttach = mpa->attach();
        mbrun = false;
    }
};

void procsm::threadAttachMon()
{
    std::cout<<"\033[1m\033[32m"<<mstrsmname<<" threadAttachMon run."<<"\033[0m"<<std::endl;

    int nCount = 0;
    while(mbAttachRun)
    {
        if(mbInitComplete)
        {
            std::cout<<"\033[1m\033[32m"<<mstrsmname<<" Init Succesffuly."<<"\033[0m"<<std::endl;
            break;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        nCount++;
        if(nCount>300)
        {
            setfailmark();
            std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" Attach Fail."<<" Now Exit."<<"\033[0m"<<std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            exit(-1);
        }
    }
    mbAttachThreadComplete = true;
}

void procsm::setfailmark()
{
    char strfailpath[300];
    QDateTime xdt = QDateTime::currentDateTime();
    snprintf(strfailpath,300,"/dev/shm/%04d%02d%02d-%s",xdt.date().year(),
             xdt.date().month(),xdt.date().day(),mstrsmname);
    std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" fail. set mark file"<<strfailpath<<"\033[0m"<<std::endl;
    QFile xFile;
    xFile.setFileName(strfailpath);
    if(xFile.open(QIODevice::ReadWrite))
    {
        xFile.write(strfailpath,strnlen(strfailpath,256));
        xFile.close();
        std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" had save mark"<<"\033[0m"<<std::endl;
    }
    else
    {
        std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" save mark fail."<<"\033[0m"<<std::endl;
    }
}

bool procsm::checkfailmark()
{
    char strfailpath[300];
    QDateTime xdt = QDateTime::currentDateTime();
    snprintf(strfailpath,300,"/dev/shm/%04d%02d%02d-%s",xdt.date().year(),
             xdt.date().month(),xdt.date().day(),mstrsmname);

    QFile xFile;
    xFile.setFileName(strfailpath);
    if(xFile.exists())
    {
        QDir xDir("/dev/shm");
        xDir.remove(strfailpath);
        std::cout<<"\033[1m\033[32m"<<" Last Time Attach Fail. Now Direct Create."<<"\033[0m"<<std::endl;
        return true;
    }
    return false;
}

procsm::procsm(const char * strsmname,const unsigned int nBufSize,const unsigned int nMaxPacCount,const int nMode)
{
//    mnBufSize = nBufSize;

//    qDebug("create dbus");



    strncpy(mstrsmname,strsmname,256);

    mpASMPtr = new QSharedMemory(strsmname);

    mpthreadattmon = new std::thread(&procsm::threadAttachMon,this);


    char strasmname[256];

    bool bSMExit = false;

    if(nMode == ModeWrite)
    {
        bool bres;
//        if(checkfailmark())
//        {
//            bres = false;
//        }
//        else
//        {
//            bres = mpASMPtr->attach();
//        }
//        if(bres == false)
//        {
//            mpASMPtr->create(sizeof(ASM_PTR));

//        }

        bres = mpASMPtr->create(sizeof(ASM_PTR));
        if(bres == true)
        {
            std::cout<<"\033[1m\033[32m"<<mstrsmname<<" create successfully."<<"\033[0m"<<std::endl;
        }
        else
        {
            bres = mpASMPtr->attach();
            if(bres == true)
            {
                bSMExit = true;
                std::cout<<"\033[1m\033[32m"<<mstrsmname<<" exist. attach successfully."<<"\033[0m"<<std::endl;
            }
            else
            {
                return;
            }
        }

        ASM_PTR * pasm = (ASM_PTR *)mpASMPtr->data();
        if(pasm == NULL)
        {
            qDebug("ASM_PTR is NULL.");
            return;
        }
        if(bSMExit == false)
        {
            qint64 uptime = std::chrono::system_clock::now().time_since_epoch().count();
            snprintf(strasmname,256,"%s_%lld",strsmname,uptime);
            mpASMPtr->lock();
            pasm->mnshmsize = sizeof(procsm_info)+nMaxPacCount*sizeof(procsm_head) + nBufSize;
            pasm->mnUpdateTime = uptime;
            strncpy(pasm->mstrshmname,strasmname,256);
            mpASMPtr->unlock();
        }
        else
        {
            mpASMPtr->lock();
            pasm->mnUpdateTime = std::chrono::system_clock::now().time_since_epoch().count();
            strncpy(strasmname,pasm->mstrshmname,256);
            mpASMPtr->unlock();
        }
        mASM_State = *pasm;
    }
    else
    {
        mbInitComplete = true;
        return;
    }

//    mpASM = new QSharedMemory(strsmname);
    mpASM = new QSharedMemory(strasmname);

    if(nMode == ModeWrite)
    {
        strncpy(mmodulemsg_type.mstrmsgidname,strsmname,255);
        mmodulemsg_type.mnBufSize = nBufSize;
        mmodulemsg_type.mnMsgBufCount = nMaxPacCount;
        strncpy(mmodulemsg_type.mstrmsgname,strasmname,255);
#ifdef Q_OS_LINUX
        mmodulemsg_type.mnPID = getpid();
#endif


#ifndef USE_GROUPUDP
#ifdef USEDBUS
        mmsg = QDBusMessage::createSignal("/catarc/adc",  "adc.adciv.modulecomm", strsmname);
        mmsg<<1;
#endif
#endif

        bool bAttach= true;
//        AttachThread AT(mpASM,bAttach);
//        AT.start();
//        QTime xTime;
//        xTime.start();
//        while(xTime.elapsed()<100)
//        {
//            if(AT.mbrun == false)
//            {
//                bAttach = AT.mbAttach;
//                break;
//            }
//        }
// //       qDebug("time is %d",xTime.elapsed());
//        if(xTime.elapsed()>= 1000)
//        {
//            qDebug("in 1000ms Attach fail.terminate it .");
//            AT.terminate();
//            bAttach = false;
//        }

 //       if(!mpASM->attach())

        bool bares = mpASM->create(sizeof(procsm_info)+nMaxPacCount*sizeof(procsm_head) + nBufSize);
        if(bares == false)   //Exist.
        {
            bAttach = mpASM->attach();

            if(bAttach)
            {
                char * p = (char *)mpASM->data();
                if(p == NULL)
                {
                    qDebug("Create SharedMemory Fail.");
                    return;
                }
                mpinfo = (procsm_info *)p;
                mphead = (procsm_head *)(p+sizeof(procsm_info));


            }
            else
            {
                std::cout<<" Exist,But Fail Attach."<<std::endl;
            }

        }
        else
        {
            char * p = (char *)mpASM->data();
            if(p == NULL)
            {
                qDebug("Create SharedMemory Fail.");
                return;
            }
            mpASM->lock();
            mpinfo = (procsm_info *)p;
            mphead = (procsm_head *)(p+sizeof(procsm_info));
            mpinfo->mCap = nMaxPacCount;
            mpinfo->mnBufSize = nBufSize;
            mpinfo->mFirst = 0;
            mpinfo->mNext = 0;
            mpinfo->mLock = 0;
            mpASM->unlock();
        }


        if(mpASM->isAttached())
        {

            mbAttach = true;
            char * p = (char *)mpASM->data();
            mpinfo = (procsm_info *)p;
            mphead = (procsm_head *)(p+sizeof(procsm_info));
            mpASM->lock();
            mnMaxPacCount = mpinfo->mCap;
            mnBufSize = mpinfo->mnBufSize;
            mpASM->unlock();
            mstrtem = new char[mnBufSize];

#ifndef USE_GROUPUDP
#ifdef USEDBUS
            mmsgres = QDBusMessage::createSignal("/catarc/adc",  "adciv.interface", "modulemsgres");
            mmsgres<<1;

            bool bconnect = QDBusConnection::sessionBus().connect(QString(),"/catarc/adc",  "adciv.interface", "modulemsgquery",this,SLOT(onQuery()));
            if(bconnect == false)
            {
                std::cout<<"procsm_if_readthread::procsm_if_readthread bconect is false"<<std::endl;
            }
#endif
#endif
        }
        else
        {
          mbAttach = false;
            qDebug("Share Memory Error.");
        }


    }

    mbInitComplete = true;
}

procsm::~procsm()
{
    if(mbAttachThreadComplete == false)
    {
        std::cout<<" Try to end Attach Monitor Thread."<<std::endl;
        mbAttachRun = false;
        mpthreadattmon->join();
    }

    if(mpASMPtr->isAttached())
    {
        std::cout<<"\033[32m"<<mstrsmname<<" detach ASMPtr "<<"\033[0m"<<std::endl;
        mpASMPtr->lock();
        if(mpASM->isAttached())
        {
            std::cout<<"\033[32m"<<mstrsmname<<" detach ASM "<<"\033[0m"<<std::endl;
            mpASM->detach();
        }
        mpASMPtr->unlock();
        delete mpASM;
        mpASMPtr->detach();
    }
    delete mpASMPtr;
    std::cout<<"\033[32m"<<mstrsmname<<" ~procsm() "<<"\033[0m"<<std::endl;


}

void procsm::recreateasm(int nbufsize)
{

    mpASMPtr->lock();
    qDebug("recreate asms");


    mnBufSize = std::max(nbufsize*11/10,nbufsize+1000);
 //   mnBufSize = nbufsize+100;
    char strasmname[256];
    ASM_PTR * pasm = (ASM_PTR *)mpASMPtr->data();
    snprintf(strasmname,256,"%s_%lld",mstrsmname,std::chrono::system_clock::now().time_since_epoch().count());//QDateTime::currentMSecsSinceEpoch());
    pasm->mnshmsize = sizeof(procsm_info)+mnMaxPacCount*sizeof(procsm_head) + mnBufSize;
    pasm->mnUpdateTime = std::chrono::system_clock::now().time_since_epoch().count();
    strncpy(pasm->mstrshmname,strasmname,256);
    mASM_State = *pasm;

    mmodulemsg_type.mnBufSize = mnBufSize;
    mmodulemsg_type.mnMsgBufCount = mnMaxPacCount;
    strncpy(mmodulemsg_type.mstrmsgname,mASM_State.mstrshmname,255);

    mpASM->lock();
    int noldmemsize = mpASM->size();
    char * px = new char[mpASM->size()];
    memcpy(px,mpASM->data(),noldmemsize);
    mpASM->unlock();
    mpASM->detach();

    qDebug("new asm name is %s,buffer size is %d ",mASM_State.mstrshmname,mnBufSize);
    mpASM = new QSharedMemory(mASM_State.mstrshmname);

    bool bAttach = false;
    AttachThread AT(mpASM,bAttach);
    AT.start();
    QTime xTime;
    xTime.start();
    while(xTime.elapsed()<100)
    {
        if(AT.mbrun == false)
        {
            bAttach = AT.mbAttach;
            break;
        }
    }
    //       qDebug("time is %d",xTime.elapsed());
    if(xTime.elapsed()>= 1000)
    {
        qDebug("in 1000ms Attach fail.terminate it .");
        AT.terminate();
        bAttach = false;
    }

    //       if(!mpASM->attach())
    if(!bAttach)
    {

        mpASM->create(sizeof(procsm_info)+mnMaxPacCount*sizeof(procsm_head) + mnBufSize);
        memcpy(mpASM->data(),px,noldmemsize);
        char * p = (char *)mpASM->data();
        mpinfo = (procsm_info *)p;
        mphead = (procsm_head *)(p+sizeof(procsm_info));
        mpinfo->mCap = mnMaxPacCount;
        mpinfo->mnBufSize = mnBufSize;
//        mpinfo->mFirst = nfirst;
//        mpinfo->mNext = nnext;
//        mpinfo->mLock = 0;
    }




    if(mpASM->isAttached())
    {

        mbAttach = true;
        char * p = (char *)mpASM->data();
        mpinfo = (procsm_info *)p;
        mphead = (procsm_head *)(p+sizeof(procsm_info));
        mnMaxPacCount = mpinfo->mCap;
        mnBufSize = mpinfo->mnBufSize;
        //        qDebug("attach successful");
 //       mstrtem = new char[mnBufSize];
    }
    else
    {
        mbAttach = false;
        qDebug("Share Memory Error.");
    }

    mpASMPtr->unlock();

    delete px;




}

#ifndef USE_GROUPUDP
#ifdef USEDBUS
    void procsm::onQuery()
    {
        QByteArray ba;
        ba.append((char *)&mmodulemsg_type,sizeof(iv::modulemsg_type));

        QList<QVariant> x;
        x<<ba;
        mmsgres.setArguments(x);
        QDBusConnection::sessionBus().send(mmsgres);
    }

#endif
#endif

bool procsm::AttachMem()
{

    if(!mpASMPtr->isAttached())mpASMPtr->attach();
    if(mpASMPtr->isAttached())
    {
        ASM_PTR * pasmptr = (ASM_PTR *)(mpASMPtr->data());
        mASM_State = *pasmptr;

        if(mpASM != 0)
        {
            if(mpASM->isAttached())mpASM->detach();
            delete mpASM;
        }
        mpASM = new QSharedMemory(mASM_State.mstrshmname);

        mpASM->attach();
        if(mpASM->isAttached())
        {
            mbAttach = true;
            char * p = (char *)mpASM->data();
            mpinfo = (procsm_info *)p;
            mphead = (procsm_head *)(p+sizeof(procsm_info));
            mnMaxPacCount = mpinfo->mCap;
            mnBufSize = mpinfo->mnBufSize;
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }

    return false;
    mpASM->attach();
    if(mpASM->isAttached())
    {
        mbAttach = true;
        char * p = (char *)mpASM->data();
        mpinfo = (procsm_info *)p;
        mphead = (procsm_head *)(p+sizeof(procsm_info));
        mnMaxPacCount = mpinfo->mCap;
        mnBufSize = mpinfo->mnBufSize;
        return true;
    }
    else
    {
        return false;
    }
}

int procsm::MoveMem(const unsigned int nSize)
{
//    qDebug("move mem");
     unsigned int nRemove = nSize;
     if(nRemove == 0)return -1;

//     unsigned int * pIndexFirst = (unsigned int *)mpASM->data();
//     unsigned int * pIndexNext = pIndexFirst+1;
//     qDebug("first = %d next = %d",*pIndexFirst,*pIndexNext);
//    unsigned int * pIndexNext = pIndexFirst;
    char * pH,*pD;
    pH = (char *)mpASM->data();pH = pH + sizeof(procsm_info);
    pD = (char *)mpASM->data();pD = pD + sizeof(procsm_info) + mnMaxPacCount * sizeof(procsm_head);
    procsm_head * phh = (procsm_head *)pH;
    unsigned int nPac = mpinfo->mNext - mpinfo->mFirst;

    if(nRemove >nPac)
    {
  //      qDebug("procsm::MoveMem nRemove > nPac nRemove = %d",nRemove);
        nRemove = nPac;
    }

    if(nRemove == nPac)
    {
        mpinfo->mFirst = mpinfo->mFirst + (unsigned int)nRemove;
        return 0;
    }

    unsigned int i;
    int nDataMove = 0;
    for(i=0;i<nRemove;i++)
    {
        procsm_head * phd = phh+i;
        nDataMove = nDataMove + phd->mnLen;
    }
    unsigned int nDataTotal;
    for(i=0;i<(nPac - nRemove);i++)
    {
        memcpy(phh+i,phh+i+nRemove,sizeof(procsm_head));
        (phh+i)->mnPos = (phh+i)->mnPos - nDataMove;
    }
    nDataTotal = (phh + nPac-nRemove-1)->mnPos + (phh+nPac-nRemove-1)->mnLen;
    memcpy(mstrtem,pD+nDataMove,nDataTotal);
    memcpy(pD,mstrtem,nDataTotal);

//    for(i=0;i<nDataTotal;i++)
//    {
//        *(pD+i) = *(pD+i+nDataMove);
//    }
    mpinfo->mFirst = mpinfo->mFirst + (unsigned int)nRemove;
    return 0;
}


int  procsm::checkasm()
{

    mpASMPtr->lock();
    ASM_PTR * pASM_PTR = (ASM_PTR * )mpASMPtr->data();
    if((pASM_PTR->mnUpdateTime == mASM_State.mnUpdateTime) && (mbAttach == true) )
    {

        mpASMPtr->unlock();
        return 0;
    }
    qDebug("reattch mem.");
    mbAttach = false;
    AttachMem();
    mpASMPtr->unlock();
    return 1;
}

int procsm::writemsg(const char *str, const unsigned int nSize)
{
    checkasm();
    if(nSize > mnBufSize)
    {
        if(nSize<1000000000)
        {
            recreateasm(nSize);
            checkasm();
        }
        else
        {
        qDebug("procsm::writemsg message size is very big");
        return -1;
        }
    }
    if(mbAttach == false)
    {
        std::cout<<mstrsmname<<"ShareMemory Attach fail."<<std::endl;
        return -1;
    }
    mpASM->lock();



//    unsigned int * pIndexFirst = (unsigned int *)mpASM->data();
//    unsigned int * pIndexNext = pIndexFirst+1;
    if(mpinfo->mLock == 1)
    {
        std::cout<<"ShareMemory have lock.Init."<<std::endl;
        mpinfo->mLock = 0;
        mpinfo->mFirst = 0;
        mpinfo->mNext = 0;
    }
    mpinfo->mLock =1;
WRITEMSG:
    char * pH,*pD;
    QDateTime dt;
    pH = (char *)mpASM->data();pH = pH + sizeof(procsm_info);
    pD = (char *)mpASM->data();pD = pD + sizeof(procsm_info) + mnMaxPacCount * sizeof(procsm_head);
    procsm_head * phh = (procsm_head *)pH;
    unsigned int nPac = mpinfo->mNext - mpinfo->mFirst;
    if(nPac>=mnMaxPacCount)
    {
        unsigned int nRemove = mnMaxPacCount/3;
        if(nRemove == 0)nRemove = 1;
        MoveMem(nRemove);
        goto WRITEMSG;
    }
    if(nPac == 0)
    {
        memcpy(pD,str,nSize);
        dt = QDateTime::currentDateTime();
    //    phh->mdt = dt;
        phh->SetDate(dt);
   //     memcpy(&phh->mdt,&dt,sizeof(QDateTime));
   //     phh->mdt = QDateTime::currentDateTime();
        phh->mindex = mpinfo->mNext;
        phh->mnPos = 0;
        phh->mnLen = nSize;
        mpinfo->mNext = mpinfo->mNext+1;
    }
    else
    {
        if(((phh+nPac-1)->mnPos+(phh+nPac-1)->mnLen + nSize)>=mnBufSize)
        {
            unsigned int nRemove = mnMaxPacCount/2;
            if(nRemove == 0)nRemove = 1;
            MoveMem(nRemove);
            goto WRITEMSG;
        }
        else
        {
            unsigned int nPos = (phh+nPac-1)->mnPos + (phh+nPac-1)->mnLen;
     //       qDebug("write pos = %d",nPos);
            memcpy(pD+nPos,str,nSize);
            dt = QDateTime::currentDateTime();
            (phh+nPac)->SetDate(dt);
 //           memcpy(&(phh+nPac)->mdt,&dt,sizeof(QDateTime));
 //           (phh+nPac)->mdt = QDateTime::currentDateTime();
            (phh+nPac)->mindex = mpinfo->mNext;
            (phh+nPac)->mnPos = nPos;
            (phh+nPac)->mnLen = nSize;
            mpinfo->mNext = mpinfo->mNext+1;
        }
    }

    const unsigned int nTM = 0x6fffffff;
    if((mpinfo->mNext >nTM)&&(mpinfo->mFirst>nTM))
    {
       nPac = mpinfo->mNext - mpinfo->mFirst;
       unsigned int i;
       for(i=0;i<nPac;i++)
       {
           (phh+i)->mindex = (phh+i)->mindex-nTM;
       }
       mpinfo->mFirst = mpinfo->mFirst-nTM;
       mpinfo->mNext = mpinfo->mNext - nTM;
    }

    mpinfo->mLock = 0;
    mpASM->unlock();

#ifndef USE_GROUPUDP
#ifdef USEDBUS
    QDBusConnection::sessionBus().send(mmsg);
#endif
#endif
//    std::cout<<"write msg."<<std::endl;
    return 0;
}

unsigned int procsm::getcurrentnext()
{

    checkasm();
    unsigned int nNext;
    mpASM->lock();
    nNext = mpinfo->mNext;
    mpASM->unlock();
    return nNext;
}


//if return 0 No Data.
//if return -1 nMaxSize is small
//if retrun -2 index is not in range,call getcurrentnext get position
//if return > 0 readdata
int procsm::readmsg(unsigned int index, char *str, unsigned int nMaxSize,unsigned int * nRead,QDateTime * pdt)
{
    int ncheck = checkasm();
//    if(ncheck == 1)
//    {
//        return -100;
//    }
    if(mbAttach == false)
    {
        std::cout<<mstrsmname<<"ShareMemory Attach fail."<<std::endl;
        return -3;
    }    
    int nRtn = 0;
    mpASM->lock();

//    if check is 1, maybe sharemem change. Read New Message.
    if(ncheck == 1)
    {

        if(mpinfo->mFirst < mpinfo->mNext)
        {
            std::cout<<" ShareMemroy Change. Read the newest."<<std::endl;
            mpASM->unlock();
            return -100;
        }
        else
        {
            mpASM->unlock();
            return -101;
        }
    }
    if((index< mpinfo->mFirst)||(index > mpinfo->mNext))
    {
        nRtn = -2;
    }
    if(nRtn != (-2))
    {
        if(index == mpinfo->mNext)
        {
            nRtn = 0;
        }
        else
        {
            char * pH,*pD;
 //           pH = (char *)mpASM->data();pH = pH + 2*sizeof(unsigned int);

 //           pD = (char *)mpASM->data();pD = pD + 2*sizeof(unsigned int) + mnMaxPacCount * sizeof(procsm_head);
            pD = (char *)mpASM->data();pD = pD+ sizeof(procsm_info) + mpinfo->mCap*sizeof(procsm_head);
            pH = (char *)mpASM->data();pH = pH+sizeof(procsm_info);
            procsm_head * phh = (procsm_head *)pH;
            unsigned int nPac = mpinfo->mNext - mpinfo->mFirst;
            if(nPac == 0)
            {
                nRtn = 0;
            }
            else
            {
                unsigned int nPos = index - mpinfo->mFirst;
                *nRead = (phh+nPos)->mnLen;
                if((phh+nPos)->mnLen > nMaxSize)
                {
                    nRtn = -1;

                }
                else
                {
        //            qDebug("read pos = %d",(phh+nPos)->mnPos);
                   memcpy(str,pD + (phh+nPos)->mnPos,(phh+nPos)->mnLen);
          //         qDebug("read pos = %d",(phh+nPos)->mnPos);
                   nRtn = (phh+nPos)->mnLen;
                   (phh+nPos)->GetDate(pdt);
           //        memcpy(pdt,&((phh+nPos)->mdt),sizeof(QDateTime));
                }
            }
        }
    }
    mpASM->unlock();

    return nRtn;
}