Common.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701
  1. /*
  2. * Common.c
  3. *
  4. * Created on: 2021年8月7日
  5. * Author: Wendell
  6. */
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <stdbool.h>
  10. #include <string.h>
  11. #include <stdarg.h>
  12. #include <time.h>
  13. #include <sys/timeb.h>
  14. #include "Common.h"
  15. int StoreSysLogMsg(const char *fmt, ...)
  16. {
  17. char Buf[4096+256];
  18. char buffer[4096];
  19. va_list args;
  20. struct timeb SeqEndTime;
  21. struct tm *tm;
  22. va_start(args, fmt);
  23. int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
  24. va_end(args);
  25. memset(Buf,0,sizeof(Buf));
  26. ftime(&SeqEndTime);
  27. SeqEndTime.time = time(NULL);
  28. tm=localtime(&SeqEndTime.time);
  29. sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]SystemLog",
  30. tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
  31. buffer,
  32. tm->tm_year+1900,tm->tm_mon+1);
  33. system(Buf);
  34. return rc;
  35. }
  36. int StorePsuLogMsg(const char *fmt, ...)
  37. {
  38. char Buf[4096+256];
  39. char buffer[4096];
  40. va_list args;
  41. struct timeb SeqEndTime;
  42. struct tm *tm;
  43. va_start(args, fmt);
  44. int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
  45. va_end(args);
  46. memset(Buf,0,sizeof(Buf));
  47. ftime(&SeqEndTime);
  48. SeqEndTime.time = time(NULL);
  49. tm=localtime(&SeqEndTime.time);
  50. sprintf(Buf,"echo \"%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\" >> /Storage/SystemLog/[%04d.%02d]PsuLog",
  51. tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
  52. buffer,
  53. tm->tm_year+1900,tm->tm_mon+1);
  54. system(Buf);
  55. return rc;
  56. }
  57. int StoreEventLogMsg(const char *fmt, ...)
  58. {
  59. char Buf[4096+256];
  60. char buffer[4096];
  61. va_list args;
  62. struct timeb SeqEndTime;
  63. struct tm *tm;
  64. va_start(args, fmt);
  65. int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
  66. va_end(args);
  67. memset(Buf,0,sizeof(Buf));
  68. ftime(&SeqEndTime);
  69. SeqEndTime.time = time(NULL);
  70. tm=localtime(&SeqEndTime.time);
  71. sprintf(Buf,"echo \"%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\" >> /Storage/EventLog/[%04d.%02d]EventLog",
  72. tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
  73. buffer,
  74. tm->tm_year+1900,tm->tm_mon+1);
  75. system(Buf);
  76. return rc;
  77. }
  78. int StoreAuthLogMsg(const char *fmt, ...)
  79. {
  80. char Buf[4096+256];
  81. char buffer[4096];
  82. va_list args;
  83. struct timeb SeqEndTime;
  84. struct tm *tm;
  85. va_start(args, fmt);
  86. int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
  87. va_end(args);
  88. memset(Buf,0,sizeof(Buf));
  89. ftime(&SeqEndTime);
  90. SeqEndTime.time = time(NULL);
  91. tm=localtime(&SeqEndTime.time);
  92. sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]AuthLog",
  93. tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
  94. buffer,
  95. tm->tm_year+1900,tm->tm_mon+1);
  96. system(Buf);
  97. return rc;
  98. }
  99. int StoreEvCommMsg(const char *fmt, ...)
  100. {
  101. char Buf[4096+256];
  102. char buffer[4096];
  103. va_list args;
  104. struct timeb SeqEndTime;
  105. struct tm *tm;
  106. va_start(args, fmt);
  107. int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
  108. va_end(args);
  109. memset(Buf,0,sizeof(Buf));
  110. ftime(&SeqEndTime);
  111. SeqEndTime.time = time(NULL);
  112. tm=localtime(&SeqEndTime.time);
  113. sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]EvCommLog",
  114. tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
  115. buffer,
  116. tm->tm_year+1900,tm->tm_mon+1);
  117. system(Buf);
  118. return rc;
  119. }
  120. int StoreDbMsg(const char *fmt, ...)
  121. {
  122. char Buf[4096+256];
  123. char buffer[4096];
  124. va_list args;
  125. struct timeb SeqEndTime;
  126. struct tm *tm;
  127. va_start(args, fmt);
  128. int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
  129. va_end(args);
  130. memset(Buf,0,sizeof(Buf));
  131. ftime(&SeqEndTime);
  132. SeqEndTime.time = time(NULL);
  133. tm=localtime(&SeqEndTime.time);
  134. sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]DbLog",
  135. tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
  136. buffer,
  137. tm->tm_year+1900,tm->tm_mon+1);
  138. system(Buf);
  139. return rc;
  140. }
  141. void GetClockTime(struct timespec *_now_time)
  142. {
  143. clock_gettime(CLOCK_MONOTONIC, _now_time);
  144. }
  145. // return value unit: 1us
  146. unsigned long GetTimeoutValue(struct timespec _start_time)
  147. {
  148. struct timespec ts_end;
  149. unsigned long ret = 0;
  150. clock_gettime(CLOCK_MONOTONIC, &ts_end);
  151. ret = ((unsigned long)(ts_end.tv_sec - _start_time.tv_sec) * 1000000) + ((unsigned long)((ts_end.tv_nsec / 1000) - (_start_time.tv_nsec/ 1000)));
  152. /*
  153. printf("\r\n TimeInterval: %ld.%09ld - %ld.%09ld = %ld.%06ld ns",
  154. ts_end.tv_sec, ts_end.tv_nsec, _start_time.tv_sec, _start_time.tv_nsec,
  155. (ret / 1000000), (ret % 1000000));
  156. */
  157. #if 0
  158. struct timespec ts_interval;
  159. ts_interval.tv_sec = ts_end.tv_sec - _start_time.tv_sec;
  160. ts_interval.tv_nsec = ts_end.tv_nsec - _start_time.tv_nsec;
  161. if(ts_interval.tv_nsec < 0)
  162. {
  163. ts_interval.tv_nsec += 1000000000;
  164. ts_interval.tv_sec--;
  165. }
  166. #endif
  167. return ret;
  168. }
  169. // return value unit: 1s
  170. unsigned long GetSecTimeoutValue(struct timespec _start_time)
  171. {
  172. struct timespec ts_end;
  173. unsigned long ret = 0;
  174. clock_gettime(CLOCK_MONOTONIC, &ts_end);
  175. ret = ((unsigned long)(ts_end.tv_sec - _start_time.tv_sec) * 1000) + ((unsigned long)((ts_end.tv_nsec / 1000000) - (_start_time.tv_nsec / 1000000)));
  176. /*
  177. printf("\r\n TimeInterval: %ld.%09ld - %ld.%09ld = %ld.%03ld ms",
  178. ts_end.tv_sec, ts_end.tv_nsec, _start_time.tv_sec, _start_time.tv_nsec,
  179. (ret / 1000), (ret % 1000));
  180. */
  181. ret /= 1000;
  182. return ret;
  183. }
  184. int StatusCodeCompose(char *oriCode, char *newCode)
  185. {
  186. if(strlen(oriCode) > 0)
  187. {
  188. strcat(oriCode, ",");
  189. }
  190. strcat(oriCode, newCode);
  191. return strlen(oriCode);
  192. }
  193. void getNowDatetime(unsigned char *data)
  194. {
  195. time_t t = time(NULL);
  196. struct tm tm = *localtime(&t);
  197. sprintf((char*)data, "%04d-%02d-%02dT%02d:%02d:%02dZ", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
  198. }
  199. int IsModelNameMatch_ForUpdate(char *model_1, char *model_2)
  200. {
  201. if(strlen(model_1) < MODELNAME_LENGTH || strlen(model_2) < MODELNAME_LENGTH)
  202. {
  203. return NO;
  204. }
  205. if(model_1[0] == model_2[0] &&
  206. model_1[1] == model_2[1] &&
  207. model_1[7] == model_2[7] &&
  208. model_1[8] == model_2[8] &&
  209. model_1[9] == model_2[9] &&
  210. model_1[11] == model_2[11] &&
  211. model_1[12] == model_2[12] &&
  212. model_1[13] == model_2[13])
  213. {
  214. return YES;
  215. }
  216. return NO;
  217. }
  218. int IsCabinetModelNameLegal(char *modelName)
  219. {
  220. if(strlen(modelName) != MODELNAME_LENGTH || modelName[0] != 'D')
  221. {
  222. return false;
  223. }
  224. if(modelName[1] != 'O' && modelName[1] != 'B' && modelName[1] != 'K')
  225. {
  226. return false;
  227. }
  228. return true;
  229. }
  230. int IsSerialNumberLegal(char *sn)
  231. {
  232. if(strlen(sn) != SERIAL_NUMBER_LENGTH)
  233. {
  234. return false;
  235. }
  236. return true;
  237. }
  238. int IsSystemIdLegal(char *systemId)
  239. {
  240. if(strlen(systemId) > SYSTEM_ID_LENGTH)
  241. {
  242. return false;
  243. }
  244. return true;
  245. }
  246. char *strrpc(char *str, char *oldStr, char *newStr)
  247. {
  248. char bstr[strlen(str)];
  249. memset(bstr, 0x00, sizeof(bstr));
  250. for(int i = 0; i < strlen(str); i++)
  251. {
  252. if(!strncmp(str+i, oldStr, strlen(oldStr)))
  253. {
  254. strcat(bstr, newStr);
  255. i += strlen(oldStr) - 1;
  256. }
  257. else
  258. {
  259. strncat(bstr, str + i, 1);
  260. }
  261. }
  262. strcpy(str,bstr);
  263. return str;
  264. }
  265. // return the start position of the first occurrence
  266. int StringInStr(char *string, char *key)
  267. {
  268. int startIndex = -1;
  269. char *startPtr;
  270. startPtr = strstr(string, key);
  271. if(startPtr > 0)
  272. {
  273. startIndex = (int)startPtr - (int)string;
  274. }
  275. return startIndex;
  276. }
  277. int FindStringInStr(char *sourceString, char *key, char *findString)
  278. {
  279. int len = 0;
  280. char *findPtr = strstr(sourceString, key);
  281. if(findPtr > 0)
  282. {
  283. len = StringInStr(findPtr, " ");
  284. if(len > 0)
  285. {
  286. memcpy(findString, findPtr, len);
  287. findString[len] = '\0';
  288. }
  289. }
  290. return len;
  291. }
  292. // return quantity of number
  293. int Trim_String(char *string , int len)
  294. {
  295. bool find = false;
  296. int quantity = 0;
  297. for(int i = 0 ; i < len; i++)
  298. {
  299. if(!(string[i] == '.' || (string[i] >= '0' && string[i] <= '9')))
  300. {
  301. if(find)
  302. {
  303. string[i] = ' ';
  304. }
  305. else
  306. {
  307. memmove(&string[i], &string[i + 1], len - i);
  308. i -= 1;
  309. len -= 1;
  310. }
  311. find = false;
  312. }
  313. else
  314. {
  315. if(!find)
  316. {
  317. quantity++;
  318. }
  319. find = true;
  320. }
  321. }
  322. string[len] = '\0';
  323. return quantity;
  324. }
  325. int Split(char **array, char *strSource, const char *key)
  326. {
  327. int quantity = 0;
  328. char *ptrSave, *ptrToken;
  329. ptrToken = strtok_r(strSource, key, &ptrSave);
  330. while(ptrToken != NULL)
  331. {
  332. *array++ = ptrToken;
  333. quantity++;
  334. ptrToken = strtok_r(NULL, key, &ptrSave);
  335. }
  336. return quantity;
  337. }
  338. float PriceParsing(char *PriceString, char *ParseKey, char *SplitKey)
  339. {
  340. char strSource[1024];
  341. char *splitStringList[128];
  342. int splitQuantity = 0;
  343. float fee = 0;
  344. memset(strSource, 0x00, sizeof(strSource));
  345. strcpy(strSource, PriceString);
  346. if(strlen(ParseKey) > 0)
  347. {
  348. splitQuantity = Split(splitStringList, strSource, SplitKey);
  349. for(int i = 0; (i < splitQuantity && i < 128); i++)
  350. {
  351. if(strstr(splitStringList[i], ParseKey) > 0)
  352. {
  353. Trim_String(splitStringList[i], strlen(splitStringList[i]));
  354. fee = atof(splitStringList[i]);
  355. break;
  356. }
  357. }
  358. }
  359. else
  360. {
  361. Trim_String(PriceString, strlen(PriceString));
  362. fee = atof(PriceString);
  363. }
  364. return fee;
  365. }
  366. // Shell Default & User Price Parsing
  367. // input: priceString
  368. // output: resultPrice
  369. char *ShellPriceParsing(char *priceString, char *resultPrice)
  370. {
  371. char strSource[1024];
  372. memset(strSource, 0x00, sizeof(strSource));
  373. strcpy(strSource, priceString);
  374. strcpy(strSource, strrpc(strSource,"\n", " "));
  375. strcpy(resultPrice, strSource);
  376. return resultPrice;
  377. }
  378. // Shell RunningCost Parsing
  379. float ShellRunningCostParsing(char *runningCostString)
  380. {
  381. int splitCnt = 0;
  382. float energy = 0, fee = 0;
  383. int connector = 0;
  384. char *splitStringList[128];
  385. char strSource[1024];
  386. int trimCnt = 0;
  387. memset(strSource, 0x00, sizeof(strSource));
  388. strcpy(strSource, runningCostString);
  389. splitCnt = Split(splitStringList, strSource, "\n");
  390. for(int i = 0; i < splitCnt; i++)
  391. {
  392. if(strstr(splitStringList[i], "Current Total") > 0)
  393. {
  394. trimCnt = Trim_String(splitStringList[i], strlen(splitStringList[i]));
  395. if(trimCnt == 3)
  396. {
  397. sscanf(splitStringList[i], "%f %f %d", &energy, &fee, &connector);
  398. }
  399. break;
  400. }
  401. }
  402. return fee;
  403. }
  404. // Shell FinalCost
  405. float ShellFinalCostParsing(char *finalCostString)
  406. {
  407. int splitCnt = 0;
  408. float fee = 0;
  409. char *splitStringList[128];
  410. char strSource[1024];
  411. memset(strSource, 0x00, sizeof(strSource));
  412. strcpy(strSource, finalCostString);
  413. splitCnt = Split(splitStringList, strSource, "\n");
  414. for(int i = 0; i < splitCnt; i++)
  415. {
  416. if(strstr(splitStringList[i], "Total") > 0)
  417. {
  418. for(int j = i + 1; j < splitCnt; j++)
  419. {
  420. if(strstr(splitStringList[j], "Cost:") > 0)
  421. {
  422. Trim_String(splitStringList[j], strlen(splitStringList[j]));
  423. fee = atof(splitStringList[j]);
  424. break;
  425. }
  426. }
  427. break;
  428. }
  429. }
  430. return fee;
  431. }
  432. int GetShellReceiptInfo(char *finalCostString, char *receiptInfo)
  433. {
  434. int splitCnt = 0;
  435. int length = 0;
  436. char *splitStringList[128];
  437. char strSource[1024];
  438. memset(strSource, 0x00, sizeof(strSource));
  439. strcpy(strSource, finalCostString);
  440. splitCnt = Split(splitStringList, strSource, "\n");
  441. for(int i = 0; i < splitCnt; i++)
  442. {
  443. if(strstr(splitStringList[i], "Total") > 0)
  444. {
  445. for(int j = i + 1; j < splitCnt; j++)
  446. {
  447. if(strstr(splitStringList[j], "Receipt:") > 0)
  448. {
  449. length = FindStringInStr(splitStringList[j], "http", receiptInfo);
  450. }
  451. }
  452. break;
  453. }
  454. }
  455. return length;
  456. }
  457. float DefaultPriceParsing(char *StringItem)
  458. {
  459. char *ptrSave, *ptrToken;
  460. char strSource[128];
  461. float fee = 0;
  462. memcpy(strSource, StringItem, 128);
  463. ptrToken = strtok_r(strSource, ",", &ptrSave);
  464. while(ptrToken != NULL)
  465. {
  466. char *strFee = strstr(ptrToken, "$");
  467. if(strFee != NULL)
  468. {
  469. strFee++;
  470. fee = atof(strFee);
  471. break;
  472. }
  473. else
  474. {
  475. fee = atof(ptrToken);
  476. break;
  477. }
  478. ptrToken = strtok_r(NULL, ",", &ptrSave);
  479. }
  480. return fee;
  481. }
  482. float GetNowTimePricing(float *price)
  483. {
  484. float fee = 0;
  485. time_t CurrentTime;
  486. struct tm *tm;
  487. CurrentTime = time(NULL);
  488. tm=localtime(&CurrentTime);
  489. fee = price[tm->tm_hour];
  490. return fee;
  491. }
  492. // Shell RunningCost Parsing
  493. float TccDefaultPriceParsing(char *costString, float *price)
  494. {
  495. int splitCnt = 0;
  496. float fee = 0;
  497. char *splitStringList[128];
  498. char strSource[1024];
  499. memset(strSource, 0x00, sizeof(strSource));
  500. strcpy(strSource, costString);
  501. splitCnt = Split(splitStringList, strSource, "|");
  502. if(splitCnt == 24)
  503. {
  504. for(int i = 0; i < splitCnt; i++)
  505. {
  506. Trim_String(splitStringList[i], strlen(splitStringList[i]));
  507. price[i] = atof(splitStringList[i]);
  508. }
  509. fee = GetNowTimePricing(price);
  510. }
  511. return fee;
  512. }
  513. unsigned short ParsingRatingPower(char *modelname)
  514. {
  515. char strVal[3], strExp[2];
  516. unsigned short value = 0, exponent = 0;
  517. memset(strVal, 0x00, sizeof(strVal));
  518. memset(strExp, 0x00, sizeof(strExp));
  519. memcpy(strVal, &modelname[4], 2);
  520. memcpy(strExp, &modelname[6], 1);
  521. value = atoi(strVal);
  522. exponent = atoi(strExp);
  523. if(value < 0 || exponent < 0)
  524. {
  525. return 0;
  526. }
  527. for(int i = 0; i < exponent; i++)
  528. {
  529. value *= 10;
  530. }
  531. return value;
  532. }
  533. //***************************************** No Use *****************************************
  534. float TariffParsing(char *StringItem, char *TariffCode)
  535. {
  536. char *ptrSave, *ptrToken;
  537. char strSource[128];
  538. float fee = 0;
  539. memcpy(strSource, StringItem, 128);
  540. ptrToken = strtok_r(strSource, ";", &ptrSave);
  541. while(ptrToken != NULL)
  542. {
  543. char *strTariff = strstr(ptrToken, TariffCode);
  544. if(strTariff != NULL)
  545. {
  546. char *strFee = strstr(strTariff, "$");
  547. if(strFee != NULL)
  548. {
  549. strFee++;
  550. fee = atof(strFee);
  551. break;
  552. }
  553. }
  554. ptrToken = strtok_r(NULL, ";", &ptrSave);
  555. }
  556. return fee;
  557. }
  558. float PhTariffParsing(char *StringItem, char *TariffCode)
  559. {
  560. char *ptrSave, *ptrToken;
  561. char strSource[128];
  562. float fee = 0;
  563. memcpy(strSource, StringItem, 128);
  564. ptrToken = strtok_r(strSource, ",", &ptrSave);
  565. while(ptrToken != NULL)
  566. {
  567. char *strTariff = strstr(ptrToken, TariffCode);
  568. if(strTariff != NULL)
  569. {
  570. char *strFee = strstr(strTariff, ":");
  571. if(strFee != NULL)
  572. {
  573. strFee++;
  574. fee = atof(strFee);
  575. break;
  576. }
  577. }
  578. ptrToken = strtok_r(NULL, ",", &ptrSave);
  579. }
  580. return fee;
  581. }
  582. //***************************************** No Use *****************************************