procsm.cpp 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807
  1. #include <iostream>
  2. #include <thread>
  3. #include <QTime>
  4. #include <QThread>
  5. #include <algorithm>
  6. #include "procsm.h"
  7. #ifdef Q_OS_LINUX
  8. #include <unistd.h>
  9. #endif
  10. #include <QFile>
  11. #include <QDir>
  12. //#define RESET "\033[0m"
  13. //#define BLACK "\033[30m" /* Black */
  14. //#define RED "\033[31m" /* Red */
  15. //#define GREEN "\033[32m" /* Green */
  16. //#define YELLOW "\033[33m" /* Yellow */
  17. //#define BLUE "\033[34m" /* Blue */
  18. //#define MAGENTA "\033[35m" /* Magenta */
  19. //#define CYAN "\033[36m" /* Cyan */
  20. //#define WHITE "\033[37m" /* White */
  21. //#define BOLDBLACK "\033[1m\033[30m" /* Bold Black */
  22. //#define BOLDRED "\033[1m\033[31m" /* Bold Red */
  23. //#define BOLDGREEN "\033[1m\033[32m" /* Bold Green */
  24. //#define BOLDYELLOW "\033[1m\033[33m" /* Bold Yellow */
  25. //#define BOLDBLUE "\033[1m\033[34m" /* Bold Blue */
  26. //#define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */
  27. //#define BOLDCYAN "\033[1m\033[36m" /* Bold Cyan */
  28. //#define BOLDWHITE "\033[1m\033[37m" /* Bold White */
  29. class AttachThread : public QThread
  30. {
  31. public:
  32. AttachThread(QSharedMemory * pa,bool & bAttach)
  33. {
  34. mbAttach = bAttach;
  35. mpa = pa;
  36. mbrun = true;
  37. }
  38. QSharedMemory * mpa;
  39. bool mbAttach = false;
  40. bool mbrun = true;
  41. void run()
  42. {
  43. mbAttach = mpa->attach();
  44. mbrun = false;
  45. }
  46. };
  47. void procsm::threadAttachMon()
  48. {
  49. std::cout<<"\033[1m\033[32m"<<mstrsmname<<" threadAttachMon run."<<"\033[0m"<<std::endl;
  50. int nCount = 0;
  51. while(mbAttachRun)
  52. {
  53. if(mbInitComplete)
  54. {
  55. std::cout<<"\033[1m\033[32m"<<mstrsmname<<" Init Succesffuly."<<"\033[0m"<<std::endl;
  56. break;
  57. }
  58. std::this_thread::sleep_for(std::chrono::milliseconds(10));
  59. nCount++;
  60. if(nCount>300)
  61. {
  62. setfailmark();
  63. std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" Attach Fail."<<" Now Exit."<<"\033[0m"<<std::endl;
  64. std::this_thread::sleep_for(std::chrono::milliseconds(10));
  65. exit(-1);
  66. }
  67. }
  68. mbAttachThreadComplete = true;
  69. }
  70. void procsm::setfailmark()
  71. {
  72. char strfailpath[300];
  73. QDateTime xdt = QDateTime::currentDateTime();
  74. snprintf(strfailpath,300,"/dev/shm/%04d%02d%02d-%s",xdt.date().year(),
  75. xdt.date().month(),xdt.date().day(),mstrsmname);
  76. std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" fail. set mark file"<<strfailpath<<"\033[0m"<<std::endl;
  77. QFile xFile;
  78. xFile.setFileName(strfailpath);
  79. if(xFile.open(QIODevice::ReadWrite))
  80. {
  81. xFile.write(strfailpath,strnlen(strfailpath,256));
  82. xFile.close();
  83. std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" had save mark"<<"\033[0m"<<std::endl;
  84. }
  85. else
  86. {
  87. std::cerr<<"\033[1m\033[31m"<<" modulecomm msg "<<mstrsmname<<" save mark fail."<<"\033[0m"<<std::endl;
  88. }
  89. }
  90. bool procsm::checkfailmark()
  91. {
  92. char strfailpath[300];
  93. QDateTime xdt = QDateTime::currentDateTime();
  94. snprintf(strfailpath,300,"/dev/shm/%04d%02d%02d-%s",xdt.date().year(),
  95. xdt.date().month(),xdt.date().day(),mstrsmname);
  96. QFile xFile;
  97. xFile.setFileName(strfailpath);
  98. if(xFile.exists())
  99. {
  100. QDir xDir("/dev/shm");
  101. xDir.remove(strfailpath);
  102. std::cout<<"\033[1m\033[32m"<<" Last Time Attach Fail. Now Direct Create."<<"\033[0m"<<std::endl;
  103. return true;
  104. }
  105. return false;
  106. }
  107. procsm::procsm(const char * strsmname,const unsigned int nBufSize,const unsigned int nMaxPacCount,const int nMode)
  108. {
  109. // mnBufSize = nBufSize;
  110. // qDebug("create dbus");
  111. strncpy(mstrsmname,strsmname,256);
  112. mpASMPtr = new QSharedMemory(strsmname);
  113. mpthreadattmon = new std::thread(&procsm::threadAttachMon,this);
  114. char strasmname[256];
  115. bool bSMExit = false;
  116. if(nMode == ModeWrite)
  117. {
  118. bool bres;
  119. // if(checkfailmark())
  120. // {
  121. // bres = false;
  122. // }
  123. // else
  124. // {
  125. // bres = mpASMPtr->attach();
  126. // }
  127. // if(bres == false)
  128. // {
  129. // mpASMPtr->create(sizeof(ASM_PTR));
  130. // }
  131. bres = mpASMPtr->create(sizeof(ASM_PTR));
  132. if(bres == true)
  133. {
  134. std::cout<<"\033[1m\033[32m"<<mstrsmname<<" create successfully."<<"\033[0m"<<std::endl;
  135. }
  136. else
  137. {
  138. bres = mpASMPtr->attach();
  139. if(bres == true)
  140. {
  141. bSMExit = true;
  142. std::cout<<"\033[1m\033[32m"<<mstrsmname<<" exist. attach successfully."<<"\033[0m"<<std::endl;
  143. }
  144. else
  145. {
  146. return;
  147. }
  148. }
  149. ASM_PTR * pasm = (ASM_PTR *)mpASMPtr->data();
  150. if(pasm == NULL)
  151. {
  152. qDebug("ASM_PTR is NULL.");
  153. return;
  154. }
  155. if(bSMExit == false)
  156. {
  157. qint64 uptime = std::chrono::system_clock::now().time_since_epoch().count();
  158. snprintf(strasmname,256,"%s_%lld",strsmname,uptime);
  159. mpASMPtr->lock();
  160. pasm->mnshmsize = sizeof(procsm_info)+nMaxPacCount*sizeof(procsm_head) + nBufSize;
  161. pasm->mnUpdateTime = uptime;
  162. strncpy(pasm->mstrshmname,strasmname,256);
  163. mpASMPtr->unlock();
  164. }
  165. else
  166. {
  167. mpASMPtr->lock();
  168. pasm->mnUpdateTime = std::chrono::system_clock::now().time_since_epoch().count();
  169. strncpy(strasmname,pasm->mstrshmname,256);
  170. mpASMPtr->unlock();
  171. }
  172. mASM_State = *pasm;
  173. }
  174. else
  175. {
  176. mbInitComplete = true;
  177. return;
  178. }
  179. // mpASM = new QSharedMemory(strsmname);
  180. mpASM = new QSharedMemory(strasmname);
  181. if(nMode == ModeWrite)
  182. {
  183. strncpy(mmodulemsg_type.mstrmsgidname,strsmname,255);
  184. mmodulemsg_type.mnBufSize = nBufSize;
  185. mmodulemsg_type.mnMsgBufCount = nMaxPacCount;
  186. strncpy(mmodulemsg_type.mstrmsgname,strasmname,255);
  187. #ifdef Q_OS_LINUX
  188. mmodulemsg_type.mnPID = getpid();
  189. #endif
  190. #ifndef USE_GROUPUDP
  191. #ifdef USEDBUS
  192. mmsg = QDBusMessage::createSignal("/catarc/adc", "adc.adciv.modulecomm", strsmname);
  193. mmsg<<1;
  194. #endif
  195. #endif
  196. bool bAttach= true;
  197. // AttachThread AT(mpASM,bAttach);
  198. // AT.start();
  199. // QTime xTime;
  200. // xTime.start();
  201. // while(xTime.elapsed()<100)
  202. // {
  203. // if(AT.mbrun == false)
  204. // {
  205. // bAttach = AT.mbAttach;
  206. // break;
  207. // }
  208. // }
  209. // // qDebug("time is %d",xTime.elapsed());
  210. // if(xTime.elapsed()>= 1000)
  211. // {
  212. // qDebug("in 1000ms Attach fail.terminate it .");
  213. // AT.terminate();
  214. // bAttach = false;
  215. // }
  216. // if(!mpASM->attach())
  217. bool bares = mpASM->create(sizeof(procsm_info)+nMaxPacCount*sizeof(procsm_head) + nBufSize);
  218. if(bares == false) //Exist.
  219. {
  220. bAttach = mpASM->attach();
  221. if(bAttach)
  222. {
  223. char * p = (char *)mpASM->data();
  224. if(p == NULL)
  225. {
  226. qDebug("Create SharedMemory Fail.");
  227. return;
  228. }
  229. mpinfo = (procsm_info *)p;
  230. mphead = (procsm_head *)(p+sizeof(procsm_info));
  231. }
  232. else
  233. {
  234. std::cout<<" Exist,But Fail Attach."<<std::endl;
  235. }
  236. }
  237. else
  238. {
  239. char * p = (char *)mpASM->data();
  240. if(p == NULL)
  241. {
  242. qDebug("Create SharedMemory Fail.");
  243. return;
  244. }
  245. mpASM->lock();
  246. mpinfo = (procsm_info *)p;
  247. mphead = (procsm_head *)(p+sizeof(procsm_info));
  248. mpinfo->mCap = nMaxPacCount;
  249. mpinfo->mnBufSize = nBufSize;
  250. mpinfo->mFirst = 0;
  251. mpinfo->mNext = 0;
  252. mpinfo->mLock = 0;
  253. mpASM->unlock();
  254. }
  255. if(mpASM->isAttached())
  256. {
  257. mbAttach = true;
  258. char * p = (char *)mpASM->data();
  259. mpinfo = (procsm_info *)p;
  260. mphead = (procsm_head *)(p+sizeof(procsm_info));
  261. mpASM->lock();
  262. mnMaxPacCount = mpinfo->mCap;
  263. mnBufSize = mpinfo->mnBufSize;
  264. mpASM->unlock();
  265. mstrtem = new char[mnBufSize];
  266. #ifndef USE_GROUPUDP
  267. #ifdef USEDBUS
  268. mmsgres = QDBusMessage::createSignal("/catarc/adc", "adciv.interface", "modulemsgres");
  269. mmsgres<<1;
  270. bool bconnect = QDBusConnection::sessionBus().connect(QString(),"/catarc/adc", "adciv.interface", "modulemsgquery",this,SLOT(onQuery()));
  271. if(bconnect == false)
  272. {
  273. std::cout<<"procsm_if_readthread::procsm_if_readthread bconect is false"<<std::endl;
  274. }
  275. #endif
  276. #endif
  277. }
  278. else
  279. {
  280. mbAttach = false;
  281. qDebug("Share Memory Error.");
  282. }
  283. }
  284. mbInitComplete = true;
  285. }
  286. procsm::~procsm()
  287. {
  288. if(mbAttachThreadComplete == false)
  289. {
  290. std::cout<<" Try to end Attach Monitor Thread."<<std::endl;
  291. mbAttachRun = false;
  292. mpthreadattmon->join();
  293. }
  294. if(mpASMPtr->isAttached())
  295. {
  296. std::cout<<"\033[32m"<<mstrsmname<<" detach ASMPtr "<<"\033[0m"<<std::endl;
  297. mpASMPtr->lock();
  298. if(mpASM->isAttached())
  299. {
  300. std::cout<<"\033[32m"<<mstrsmname<<" detach ASM "<<"\033[0m"<<std::endl;
  301. mpASM->detach();
  302. }
  303. mpASMPtr->unlock();
  304. delete mpASM;
  305. mpASMPtr->detach();
  306. }
  307. delete mpASMPtr;
  308. std::cout<<"\033[32m"<<mstrsmname<<" ~procsm() "<<"\033[0m"<<std::endl;
  309. }
  310. void procsm::recreateasm(int nbufsize)
  311. {
  312. mpASMPtr->lock();
  313. qDebug("recreate asms");
  314. mnBufSize = std::max(nbufsize*11/10,nbufsize+1000);
  315. // mnBufSize = nbufsize+100;
  316. char strasmname[256];
  317. ASM_PTR * pasm = (ASM_PTR *)mpASMPtr->data();
  318. snprintf(strasmname,256,"%s_%lld",mstrsmname,std::chrono::system_clock::now().time_since_epoch().count());//QDateTime::currentMSecsSinceEpoch());
  319. pasm->mnshmsize = sizeof(procsm_info)+mnMaxPacCount*sizeof(procsm_head) + mnBufSize;
  320. pasm->mnUpdateTime = std::chrono::system_clock::now().time_since_epoch().count();
  321. strncpy(pasm->mstrshmname,strasmname,256);
  322. mASM_State = *pasm;
  323. mmodulemsg_type.mnBufSize = mnBufSize;
  324. mmodulemsg_type.mnMsgBufCount = mnMaxPacCount;
  325. strncpy(mmodulemsg_type.mstrmsgname,mASM_State.mstrshmname,255);
  326. mpASM->lock();
  327. int noldmemsize = mpASM->size();
  328. char * px = new char[mpASM->size()];
  329. memcpy(px,mpASM->data(),noldmemsize);
  330. mpASM->unlock();
  331. mpASM->detach();
  332. qDebug("new asm name is %s,buffer size is %d ",mASM_State.mstrshmname,mnBufSize);
  333. mpASM = new QSharedMemory(mASM_State.mstrshmname);
  334. bool bAttach = false;
  335. AttachThread AT(mpASM,bAttach);
  336. AT.start();
  337. QTime xTime;
  338. xTime.start();
  339. while(xTime.elapsed()<100)
  340. {
  341. if(AT.mbrun == false)
  342. {
  343. bAttach = AT.mbAttach;
  344. break;
  345. }
  346. }
  347. // qDebug("time is %d",xTime.elapsed());
  348. if(xTime.elapsed()>= 1000)
  349. {
  350. qDebug("in 1000ms Attach fail.terminate it .");
  351. AT.terminate();
  352. bAttach = false;
  353. }
  354. // if(!mpASM->attach())
  355. if(!bAttach)
  356. {
  357. mpASM->create(sizeof(procsm_info)+mnMaxPacCount*sizeof(procsm_head) + mnBufSize);
  358. memcpy(mpASM->data(),px,noldmemsize);
  359. char * p = (char *)mpASM->data();
  360. mpinfo = (procsm_info *)p;
  361. mphead = (procsm_head *)(p+sizeof(procsm_info));
  362. mpinfo->mCap = mnMaxPacCount;
  363. mpinfo->mnBufSize = mnBufSize;
  364. // mpinfo->mFirst = nfirst;
  365. // mpinfo->mNext = nnext;
  366. // mpinfo->mLock = 0;
  367. }
  368. if(mpASM->isAttached())
  369. {
  370. mbAttach = true;
  371. char * p = (char *)mpASM->data();
  372. mpinfo = (procsm_info *)p;
  373. mphead = (procsm_head *)(p+sizeof(procsm_info));
  374. mnMaxPacCount = mpinfo->mCap;
  375. mnBufSize = mpinfo->mnBufSize;
  376. // qDebug("attach successful");
  377. // mstrtem = new char[mnBufSize];
  378. }
  379. else
  380. {
  381. mbAttach = false;
  382. qDebug("Share Memory Error.");
  383. }
  384. mpASMPtr->unlock();
  385. delete px;
  386. }
  387. #ifndef USE_GROUPUDP
  388. #ifdef USEDBUS
  389. void procsm::onQuery()
  390. {
  391. QByteArray ba;
  392. ba.append((char *)&mmodulemsg_type,sizeof(iv::modulemsg_type));
  393. QList<QVariant> x;
  394. x<<ba;
  395. mmsgres.setArguments(x);
  396. QDBusConnection::sessionBus().send(mmsgres);
  397. }
  398. #endif
  399. #endif
  400. bool procsm::AttachMem()
  401. {
  402. if(!mpASMPtr->isAttached())mpASMPtr->attach();
  403. if(mpASMPtr->isAttached())
  404. {
  405. ASM_PTR * pasmptr = (ASM_PTR *)(mpASMPtr->data());
  406. mASM_State = *pasmptr;
  407. if(mpASM != 0)
  408. {
  409. if(mpASM->isAttached())mpASM->detach();
  410. delete mpASM;
  411. }
  412. mpASM = new QSharedMemory(mASM_State.mstrshmname);
  413. mpASM->attach();
  414. if(mpASM->isAttached())
  415. {
  416. mbAttach = true;
  417. char * p = (char *)mpASM->data();
  418. mpinfo = (procsm_info *)p;
  419. mphead = (procsm_head *)(p+sizeof(procsm_info));
  420. mnMaxPacCount = mpinfo->mCap;
  421. mnBufSize = mpinfo->mnBufSize;
  422. return true;
  423. }
  424. else
  425. {
  426. return false;
  427. }
  428. }
  429. else
  430. {
  431. return false;
  432. }
  433. return false;
  434. mpASM->attach();
  435. if(mpASM->isAttached())
  436. {
  437. mbAttach = true;
  438. char * p = (char *)mpASM->data();
  439. mpinfo = (procsm_info *)p;
  440. mphead = (procsm_head *)(p+sizeof(procsm_info));
  441. mnMaxPacCount = mpinfo->mCap;
  442. mnBufSize = mpinfo->mnBufSize;
  443. return true;
  444. }
  445. else
  446. {
  447. return false;
  448. }
  449. }
  450. int procsm::MoveMem(const unsigned int nSize)
  451. {
  452. // qDebug("move mem");
  453. unsigned int nRemove = nSize;
  454. if(nRemove == 0)return -1;
  455. // unsigned int * pIndexFirst = (unsigned int *)mpASM->data();
  456. // unsigned int * pIndexNext = pIndexFirst+1;
  457. // qDebug("first = %d next = %d",*pIndexFirst,*pIndexNext);
  458. // unsigned int * pIndexNext = pIndexFirst;
  459. char * pH,*pD;
  460. pH = (char *)mpASM->data();pH = pH + sizeof(procsm_info);
  461. pD = (char *)mpASM->data();pD = pD + sizeof(procsm_info) + mnMaxPacCount * sizeof(procsm_head);
  462. procsm_head * phh = (procsm_head *)pH;
  463. unsigned int nPac = mpinfo->mNext - mpinfo->mFirst;
  464. if(nRemove >nPac)
  465. {
  466. // qDebug("procsm::MoveMem nRemove > nPac nRemove = %d",nRemove);
  467. nRemove = nPac;
  468. }
  469. if(nRemove == nPac)
  470. {
  471. mpinfo->mFirst = mpinfo->mFirst + (unsigned int)nRemove;
  472. return 0;
  473. }
  474. unsigned int i;
  475. int nDataMove = 0;
  476. for(i=0;i<nRemove;i++)
  477. {
  478. procsm_head * phd = phh+i;
  479. nDataMove = nDataMove + phd->mnLen;
  480. }
  481. unsigned int nDataTotal;
  482. for(i=0;i<(nPac - nRemove);i++)
  483. {
  484. memcpy(phh+i,phh+i+nRemove,sizeof(procsm_head));
  485. (phh+i)->mnPos = (phh+i)->mnPos - nDataMove;
  486. }
  487. nDataTotal = (phh + nPac-nRemove-1)->mnPos + (phh+nPac-nRemove-1)->mnLen;
  488. memcpy(mstrtem,pD+nDataMove,nDataTotal);
  489. memcpy(pD,mstrtem,nDataTotal);
  490. // for(i=0;i<nDataTotal;i++)
  491. // {
  492. // *(pD+i) = *(pD+i+nDataMove);
  493. // }
  494. mpinfo->mFirst = mpinfo->mFirst + (unsigned int)nRemove;
  495. return 0;
  496. }
  497. int procsm::checkasm()
  498. {
  499. mpASMPtr->lock();
  500. ASM_PTR * pASM_PTR = (ASM_PTR * )mpASMPtr->data();
  501. if((pASM_PTR->mnUpdateTime == mASM_State.mnUpdateTime) && (mbAttach == true) )
  502. {
  503. mpASMPtr->unlock();
  504. return 0;
  505. }
  506. qDebug("reattch mem.");
  507. mbAttach = false;
  508. AttachMem();
  509. mpASMPtr->unlock();
  510. return 1;
  511. }
  512. int procsm::writemsg(const char *str, const unsigned int nSize)
  513. {
  514. checkasm();
  515. if(nSize > mnBufSize)
  516. {
  517. if(nSize<1000000000)
  518. {
  519. recreateasm(nSize);
  520. checkasm();
  521. }
  522. else
  523. {
  524. qDebug("procsm::writemsg message size is very big");
  525. return -1;
  526. }
  527. }
  528. if(mbAttach == false)
  529. {
  530. std::cout<<mstrsmname<<"ShareMemory Attach fail."<<std::endl;
  531. return -1;
  532. }
  533. mpASM->lock();
  534. // unsigned int * pIndexFirst = (unsigned int *)mpASM->data();
  535. // unsigned int * pIndexNext = pIndexFirst+1;
  536. if(mpinfo->mLock == 1)
  537. {
  538. std::cout<<"ShareMemory have lock.Init."<<std::endl;
  539. mpinfo->mLock = 0;
  540. mpinfo->mFirst = 0;
  541. mpinfo->mNext = 0;
  542. }
  543. mpinfo->mLock =1;
  544. WRITEMSG:
  545. char * pH,*pD;
  546. QDateTime dt;
  547. pH = (char *)mpASM->data();pH = pH + sizeof(procsm_info);
  548. pD = (char *)mpASM->data();pD = pD + sizeof(procsm_info) + mnMaxPacCount * sizeof(procsm_head);
  549. procsm_head * phh = (procsm_head *)pH;
  550. unsigned int nPac = mpinfo->mNext - mpinfo->mFirst;
  551. if(nPac>=mnMaxPacCount)
  552. {
  553. unsigned int nRemove = mnMaxPacCount/3;
  554. if(nRemove == 0)nRemove = 1;
  555. MoveMem(nRemove);
  556. goto WRITEMSG;
  557. }
  558. if(nPac == 0)
  559. {
  560. memcpy(pD,str,nSize);
  561. dt = QDateTime::currentDateTime();
  562. // phh->mdt = dt;
  563. phh->SetDate(dt);
  564. // memcpy(&phh->mdt,&dt,sizeof(QDateTime));
  565. // phh->mdt = QDateTime::currentDateTime();
  566. phh->mindex = mpinfo->mNext;
  567. phh->mnPos = 0;
  568. phh->mnLen = nSize;
  569. mpinfo->mNext = mpinfo->mNext+1;
  570. }
  571. else
  572. {
  573. if(((phh+nPac-1)->mnPos+(phh+nPac-1)->mnLen + nSize)>=mnBufSize)
  574. {
  575. unsigned int nRemove = mnMaxPacCount/2;
  576. if(nRemove == 0)nRemove = 1;
  577. MoveMem(nRemove);
  578. goto WRITEMSG;
  579. }
  580. else
  581. {
  582. unsigned int nPos = (phh+nPac-1)->mnPos + (phh+nPac-1)->mnLen;
  583. // qDebug("write pos = %d",nPos);
  584. memcpy(pD+nPos,str,nSize);
  585. dt = QDateTime::currentDateTime();
  586. (phh+nPac)->SetDate(dt);
  587. // memcpy(&(phh+nPac)->mdt,&dt,sizeof(QDateTime));
  588. // (phh+nPac)->mdt = QDateTime::currentDateTime();
  589. (phh+nPac)->mindex = mpinfo->mNext;
  590. (phh+nPac)->mnPos = nPos;
  591. (phh+nPac)->mnLen = nSize;
  592. mpinfo->mNext = mpinfo->mNext+1;
  593. }
  594. }
  595. const unsigned int nTM = 0x6fffffff;
  596. if((mpinfo->mNext >nTM)&&(mpinfo->mFirst>nTM))
  597. {
  598. nPac = mpinfo->mNext - mpinfo->mFirst;
  599. unsigned int i;
  600. for(i=0;i<nPac;i++)
  601. {
  602. (phh+i)->mindex = (phh+i)->mindex-nTM;
  603. }
  604. mpinfo->mFirst = mpinfo->mFirst-nTM;
  605. mpinfo->mNext = mpinfo->mNext - nTM;
  606. }
  607. mpinfo->mLock = 0;
  608. mpASM->unlock();
  609. #ifndef USE_GROUPUDP
  610. #ifdef USEDBUS
  611. QDBusConnection::sessionBus().send(mmsg);
  612. #endif
  613. #endif
  614. // std::cout<<"write msg."<<std::endl;
  615. return 0;
  616. }
  617. unsigned int procsm::getcurrentnext()
  618. {
  619. checkasm();
  620. unsigned int nNext;
  621. mpASM->lock();
  622. nNext = mpinfo->mNext;
  623. mpASM->unlock();
  624. return nNext;
  625. }
  626. //if return 0 No Data.
  627. //if return -1 nMaxSize is small
  628. //if retrun -2 index is not in range,call getcurrentnext get position
  629. //if return > 0 readdata
  630. int procsm::readmsg(unsigned int index, char *str, unsigned int nMaxSize,unsigned int * nRead,QDateTime * pdt)
  631. {
  632. int ncheck = checkasm();
  633. // if(ncheck == 1)
  634. // {
  635. // return -100;
  636. // }
  637. if(mbAttach == false)
  638. {
  639. std::cout<<mstrsmname<<"ShareMemory Attach fail."<<std::endl;
  640. return -3;
  641. }
  642. int nRtn = 0;
  643. mpASM->lock();
  644. // if check is 1, maybe sharemem change. Read New Message.
  645. if(ncheck == 1)
  646. {
  647. if(mpinfo->mFirst < mpinfo->mNext)
  648. {
  649. std::cout<<" ShareMemroy Change. Read the newest."<<std::endl;
  650. mpASM->unlock();
  651. return -100;
  652. }
  653. else
  654. {
  655. mpASM->unlock();
  656. return -101;
  657. }
  658. }
  659. if((index< mpinfo->mFirst)||(index > mpinfo->mNext))
  660. {
  661. nRtn = -2;
  662. }
  663. if(nRtn != (-2))
  664. {
  665. if(index == mpinfo->mNext)
  666. {
  667. nRtn = 0;
  668. }
  669. else
  670. {
  671. char * pH,*pD;
  672. // pH = (char *)mpASM->data();pH = pH + 2*sizeof(unsigned int);
  673. // pD = (char *)mpASM->data();pD = pD + 2*sizeof(unsigned int) + mnMaxPacCount * sizeof(procsm_head);
  674. pD = (char *)mpASM->data();pD = pD+ sizeof(procsm_info) + mpinfo->mCap*sizeof(procsm_head);
  675. pH = (char *)mpASM->data();pH = pH+sizeof(procsm_info);
  676. procsm_head * phh = (procsm_head *)pH;
  677. unsigned int nPac = mpinfo->mNext - mpinfo->mFirst;
  678. if(nPac == 0)
  679. {
  680. nRtn = 0;
  681. }
  682. else
  683. {
  684. unsigned int nPos = index - mpinfo->mFirst;
  685. *nRead = (phh+nPos)->mnLen;
  686. if((phh+nPos)->mnLen > nMaxSize)
  687. {
  688. nRtn = -1;
  689. }
  690. else
  691. {
  692. // qDebug("read pos = %d",(phh+nPos)->mnPos);
  693. memcpy(str,pD + (phh+nPos)->mnPos,(phh+nPos)->mnLen);
  694. // qDebug("read pos = %d",(phh+nPos)->mnPos);
  695. nRtn = (phh+nPos)->mnLen;
  696. (phh+nPos)->GetDate(pdt);
  697. // memcpy(pdt,&((phh+nPos)->mdt),sizeof(QDateTime));
  698. }
  699. }
  700. }
  701. }
  702. mpASM->unlock();
  703. return nRtn;
  704. }