/src/ttap3_util.c

https://gitlab.com/farmos_public/libtp3 · C · 958 lines · 779 code · 138 blank · 41 comment · 123 complexity · 9df09e59d1c660f64e981611bb730c1f MD5 · raw file 

    

  1. /** 

    2. 

  2.  * \file ttap3_util.c

    3. 

  3.  * \brief TTAK.KO-06.0288 Part 3 구현에 사용되는 유틸리티 함수 및 데이터타입

    4. 

  4.  */

    5. 

  5. 

    6. 

  6. #include <stdio.h>

    7. 

  7. #include <stdlib.h>

    8. 

  8. #include <string.h>

    9. 

  9. #include <time.h>

    10. 

  10. 

    11. 

  11. #include <ttap3_define.h>

    12. 

  12. #include <ttap3_config.h>

    13. 

  13. #include <ttap3_base.h>

    14. 

  14. #include <ttap3_util.h>

    15. 

  15. 

    16. 

  16. #include <../util/mem.h>

    17. 

  17. 

    18. 

  18. #ifdef _MSC_VER

    19. 

  19. #define localtime_r	localtime_s

    20. 

  20. #endif

    21. 

  21. 

    22. 

  22. void

    23. 

  23. tp3_setgcgprof (ptp3_gcgprof_t pgcgprof, byte *serial, byte *model, byte *ipv4, byte *ipv6, int installsite, byte mcutype, byte ostype, int osver, byte ramsize, byte powertype, int swver) {

    24. 

  24. 	strcpy ((char *)pgcgprof->serial, (const char *)serial);

    25. 

  25. 	strcpy ((char *)pgcgprof->model, (const char *)model);

    26. 

  26. 	memcpy (pgcgprof->ipv4, ipv4, 4);

    27. 

  27. 	memcpy (pgcgprof->ipv6, ipv6, 6);

    28. 

  28. 	pgcgprof->installsite = installsite;

    29. 

  29. 	pgcgprof->mcutype = mcutype;

    30. 

  30. 	pgcgprof->ostype = ostype;

    31. 

  31. 	pgcgprof->osver = osver;

    32. 

  32. 	pgcgprof->ramsize = ramsize;

    33. 

  33. 	pgcgprof->powertype = powertype;

    34. 

  34. 	pgcgprof->swver = swver;

    35. 

  35. }

    36. 

  36. 

    37. 

  37. tp3_stat_t

    38. 

  38. tp3_readfields_gcgprof (ptp3_msg_t pmsg, ptp3_gcgprof_t pgcgprof) {

    39. 

  39. 	tp3_fdata_t data;

    40. 

  40. 	int len;

    41. 

  41. 

    42. 

  42. 	len = tp3_readfield (pmsg, TP3_FC_SERIALNUM, &data);

    43. 

  43. 	strncpy ((char *)pgcgprof->serial, (const char *)data.pbyte, len);

    44. 

  44. 	(pgcgprof->serial)[len] = '\0';

    45. 

  45. 	len = tp3_readfield (pmsg, TP3_FC_MODELNUM, &data);

    46. 

  46. 	strncpy ((char *)pgcgprof->model, (const char *)data.pbyte, len);

    47. 

  47. 	(pgcgprof->model)[len] = '\0';

    48. 

  48. 	len = tp3_readfield (pmsg, TP3_FC_IPV4ADDR, &data);

    49. 

  49. 	memcpy (pgcgprof->ipv4, &(data.data), 4);

    50. 

  50. 	len = tp3_readfield (pmsg, TP3_FC_IPV6ADDR, &data);

    51. 

  51. 	memcpy (pgcgprof->ipv6, data.pbyte, 6);

    52. 

  52. 	len = tp3_readfield (pmsg, TP3_FC_INSTSITE, &data);

    53. 

  53. 	pgcgprof->installsite = data.data;

    54. 

  54. 	len = tp3_readfield (pmsg, TP3_FC_MCUTYPE, &data);

    55. 

  55. 	pgcgprof->mcutype = data.data;

    56. 

  56. 	len = tp3_readfield (pmsg, TP3_FC_OSTYPE, &data);

    57. 

  57. 	pgcgprof->ostype = data.data;

    58. 

  58. 	len = tp3_readfield (pmsg, TP3_FC_OSVER, &data);

    59. 

  59. 	pgcgprof->osver = data.data;

    60. 

  60. 	len = tp3_readfield (pmsg, TP3_FC_RAMSIZE, &data);

    61. 

  61. 	pgcgprof->ramsize = data.data;

    62. 

  62. 	len = tp3_readfield (pmsg, TP3_FC_POWTYPE, &data);

    63. 

  63. 	pgcgprof->powertype = data.data;

    64. 

  64. 	len = tp3_readfield (pmsg, TP3_FC_SWVER, &data);

    65. 

  65. 	pgcgprof->swver = data.data;

    66. 

  66. 

    67. 

  67. 	return TP3_SC_NOERROR;

    68. 

  68. }

    69. 

  69. 

    70. 

  70. tp3_stat_t

    71. 

  71. tp3_addfields_gcgprof (ptp3_msg_t pmsg, ptp3_gcgprof_t pgcgprof) {

    72. 

  72. 	TP3_STAT_NOERROR (

    73. 

  73. 			tp3_addfield_nbytes (pmsg, TP3_FC_SERIALNUM, 

    74. 

  74. 				strlen ((const char *)pgcgprof->serial), pgcgprof->serial));

    75. 

  75. 	TP3_STAT_NOERROR (

    76. 

  76. 			tp3_addfield_nbytes (pmsg, TP3_FC_MODELNUM, 

    77. 

  77. 				strlen ((const char *)pgcgprof->model), pgcgprof->model));

    78. 

  78. 	TP3_STAT_NOERROR (

    79. 

  79. 			tp3_addfield_nbytes (pmsg, TP3_FC_IPV4ADDR, 4, pgcgprof->ipv4));

    80. 

  80. 	TP3_STAT_NOERROR (

    81. 

  81. 			tp3_addfield_nbytes (pmsg, TP3_FC_IPV6ADDR, 6, pgcgprof->ipv6));

    82. 

  82. 	TP3_STAT_NOERROR (

    83. 

  83. 			tp3_addfield_num (pmsg, TP3_FC_INSTSITE, pgcgprof->installsite));

    84. 

  84. 	TP3_STAT_NOERROR (

    85. 

  85. 			tp3_addfield_num (pmsg, TP3_FC_MCUTYPE, pgcgprof->mcutype));

    86. 

  86. 	TP3_STAT_NOERROR (

    87. 

  87. 			tp3_addfield_num (pmsg, TP3_FC_OSTYPE, pgcgprof->ostype));

    88. 

  88. 	TP3_STAT_NOERROR (

    89. 

  89. 			tp3_addfield_num (pmsg, TP3_FC_OSVER, pgcgprof->osver));

    90. 

  90. 	TP3_STAT_NOERROR (

    91. 

  91. 			tp3_addfield_num (pmsg, TP3_FC_RAMSIZE, pgcgprof->ramsize));

    92. 

  92. 	TP3_STAT_NOERROR (

    93. 

  93. 			tp3_addfield_num (pmsg, TP3_FC_POWTYPE, pgcgprof->powertype));

    94. 

  94. 	TP3_STAT_NOERROR (

    95. 

  95. 			tp3_addfield_num (pmsg, TP3_FC_SWVER, pgcgprof->swver));

    96. 

  96. 

    97. 

  97. 	return TP3_SC_NOERROR;

    98. 

  98. }

    99. 

  99. 

    100. 

  100. tp3_stat_t

    101. 

  101. tp3_readfields_senattr (ptp3_msg_t pmsg, ptp3_senattr_t psenattr) {

    102. 

  102. 	tp3_fdata_t data;

    103. 

  103. 	int tmp;

    104. 

  104. 

    105. 

  105. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_SNID, &data), TP3_SC_NOREQFIELD_ERR);

    106. 

  106. 	tmp = data.data;

    107. 

  107. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_SID, &data), TP3_SC_NOREQFIELD_ERR);

    108. 

  108. 	psenattr->gsid = tp3_getgid (tmp, data.data);

    109. 

  109. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_SENTYPE, &data), TP3_SC_NOREQFIELD_ERR);

    110. 

  110. 	psenattr->sentype = data.data;

    111. 

  111. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_SENDATATYPE, &data), TP3_SC_NOREQFIELD_ERR);

    112. 

  112. 	psenattr->datatype = data.data;

    113. 

  113. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_SENGETTYPE, &data), TP3_SC_NOREQFIELD_ERR);

    114. 

  114. 	psenattr->gathertype = data.data;

    115. 

  115. 	if (psenattr->gathertype == TP3_SENGT_PERIOD) {

    116. 

  116. 		TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_SENGETINTV, &data), TP3_SC_NOREQFIELD_ERR);

    117. 

  117. 		psenattr->gatherinterval = tp3_getinterval (data.pbyte);

    118. 

  118. 	}

    119. 

  119. 	if (tp3_readfield (pmsg, TP3_FC_MAXVALUE, &data) > 0)

    120. 

  120. 		psenattr->maxval = data.data;

    121. 

  121. 	if (tp3_readfield (pmsg, TP3_FC_MINVALUE, &data) > 0)

    122. 

  122. 		psenattr->minval = data.data;

    123. 

  123. 	if (tp3_readfield (pmsg, TP3_FC_PRECISION, &data) > 0)

    124. 

  124. 		psenattr->precision = data.data;

    125. 

  125. 	if (tp3_readfield (pmsg, TP3_FC_ERRRANGE, &data) > 0)

    126. 

  126. 		psenattr->errrange = data.data;

    127. 

  127. 

    128. 

  128. 	if (psenattr->gathertype == TP3_SENGT_EVENT) {

    129. 

  129. 		TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_THRESHOLDTYPE, &data), TP3_SC_NOREQFIELD_ERR);

    130. 

  130. 		psenattr->thresholdtype = data.data;

    131. 

  131. 		TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_THRESHOLD, &data), TP3_SC_NOREQFIELD_ERR);

    132. 

  132. 		psenattr->threshold = data.data;

    133. 

  133. 	}

    134. 

  134. 

    135. 

  135. 	return TP3_SC_NOERROR;

    136. 

  136. }

    137. 

  137. 

    138. 

  138. tp3_stat_t

    139. 

  139. tp3_addfields_senattr (ptp3_msg_t pmsg, ptp3_senattr_t psenattr) {

    140. 

  140. 	TP3_STAT_NOERROR (

    141. 

  141. 			tp3_addfield_num (pmsg, TP3_FC_SNID, tp3_getnid(psenattr->gsid)));

    142. 

  142. 	TP3_STAT_NOERROR (

    143. 

  143. 			tp3_addfield_num (pmsg, TP3_FC_SID, tp3_getdevid(psenattr->gsid)));

    144. 

  144. 	TP3_STAT_NOERROR (

    145. 

  145. 			tp3_addfield_num (pmsg, TP3_FC_SENTYPE, psenattr->sentype));

    146. 

  146. 	TP3_STAT_NOERROR (

    147. 

  147. 			tp3_addfield_num (pmsg, TP3_FC_SENDATATYPE, psenattr->datatype));

    148. 

  148. 	TP3_STAT_NOERROR (

    149. 

  149. 			tp3_addfield_num (pmsg, TP3_FC_SENGETTYPE, psenattr->gathertype));

    150. 

  150. 	if (psenattr->gathertype == TP3_SENGT_PERIOD) {

    151. 

  151. 		TP3_STAT_NOERROR (

    152. 

  152. 			tp3_addfield_interval (pmsg, TP3_FC_SENGETINTV, psenattr->gatherinterval));

    153. 

  153. 	}

    154. 

  154. 	TP3_STAT_NOERROR (

    155. 

  155. 			tp3_addfield_num (pmsg, TP3_FC_MAXVALUE, psenattr->maxval));

    156. 

  156. 	TP3_STAT_NOERROR (

    157. 

  157. 			tp3_addfield_num (pmsg, TP3_FC_MINVALUE, psenattr->minval));

    158. 

  158. 	TP3_STAT_NOERROR (

    159. 

  159. 			tp3_addfield_num (pmsg, TP3_FC_PRECISION, psenattr->precision));

    160. 

  160. 	TP3_STAT_NOERROR (

    161. 

  161. 			tp3_addfield_num (pmsg, TP3_FC_ERRRANGE, psenattr->errrange));

    162. 

  162. 	if (psenattr->gathertype == TP3_SENGT_EVENT) {

    163. 

  163. 		TP3_STAT_NOERROR (

    164. 

  164. 			tp3_addfield_interval (pmsg, TP3_FC_THRESHOLDTYPE, psenattr->thresholdtype));

    165. 

  165. 		TP3_STAT_NOERROR (

    166. 

  166. 			tp3_addfield_interval (pmsg, TP3_FC_THRESHOLD, psenattr->threshold));

    167. 

  167. 	}

    168. 

  168. 	

    169. 

  169. 	return TP3_SC_NOERROR;

    170. 

  170. }

    171. 

  171. 

    172. 

  172. tp3_stat_t

    173. 

  173. tp3_readfields_actattr (ptp3_msg_t pmsg, ptp3_actattr_t pactattr) {

    174. 

  174. 	tp3_fdata_t data;

    175. 

  175. 	int tmp;

    176. 

  176. 

    177. 

  177. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_ANID, &data), TP3_SC_NOREQFIELD_ERR);

    178. 

  178. 	tmp = data.data;

    179. 

  179. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_AID, &data), TP3_SC_NOREQFIELD_ERR);

    180. 

  180. 	pactattr->gaid = tp3_getgid (tmp, data.data);

    181. 

  181. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_ACTTYPE, &data), TP3_SC_NOREQFIELD_ERR);

    182. 

  182. 	pactattr->acttype = data.data;

    183. 

  183. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_ACTDATATYPE, &data), TP3_SC_NOREQFIELD_ERR);

    184. 

  184. 	pactattr->datatype = data.data;

    185. 

  185. 	TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_ACTGETTYPE, &data), TP3_SC_NOREQFIELD_ERR);

    186. 

  186. 	pactattr->gathertype = data.data;

    187. 

  187. 	if (pactattr->gathertype == TP3_ACTGT_PERIOD) {

    188. 

  188. 		TP3_STAT_RETURN (0 > tp3_readfield (pmsg, TP3_FC_ACTGETINTV, &data), TP3_SC_NOREQFIELD_ERR);

    189. 

  189. 		pactattr->gatherinterval = tp3_getinterval (data.pbyte);

    190. 

  190. 	}

    191. 

  191. 			

    192. 

  192. 	return TP3_SC_NOERROR;

    193. 

  193. }

    194. 

  194. 

    195. 

  195. tp3_stat_t

    196. 

  196. tp3_addfields_actattr (ptp3_msg_t pmsg, ptp3_actattr_t pactattr) {

    197. 

  197. 	TP3_STAT_NOERROR (

    198. 

  198. 			tp3_addfield_num (pmsg, TP3_FC_ANID, tp3_getnid(pactattr->gaid)));

    199. 

  199. 	TP3_STAT_NOERROR (

    200. 

  200. 			tp3_addfield_num (pmsg, TP3_FC_AID, tp3_getdevid(pactattr->gaid)));

    201. 

  201. 	TP3_STAT_NOERROR (

    202. 

  202. 			tp3_addfield_num (pmsg, TP3_FC_ACTTYPE, pactattr->acttype));

    203. 

  203. 	TP3_STAT_NOERROR (

    204. 

  204. 			tp3_addfield_num (pmsg, TP3_FC_ACTDATATYPE, pactattr->datatype));

    205. 

  205. 	TP3_STAT_NOERROR (

    206. 

  206. 			tp3_addfield_num (pmsg, TP3_FC_ACTGETTYPE, pactattr->gathertype));

    207. 

  207. 	if (pactattr->gathertype == TP3_ACTGT_PERIOD) {

    208. 

  208. 		TP3_STAT_NOERROR (

    209. 

  209. 			tp3_addfield_interval (pmsg, TP3_FC_SENGETINTV, pactattr->gatherinterval));

    210. 

  210. 	}

    211. 

  211. 			

    212. 

  212. 	return TP3_SC_NOERROR;

    213. 

  213. }

    214. 

  214. 

    215. 

  215. int

    216. 

  216. tp3_getgid (int nid, int devid) {

    217. 

  217. 	return (nid << 8) + devid;

    218. 

  218. }

    219. 

  219. 

    220. 

  220. int

    221. 

  221. tp3_getdevid (int gid) {

    222. 

  222. 	return gid & 0xFF;

    223. 

  223. }

    224. 

  224. 

    225. 

  225. int

    226. 

  226. tp3_getnid (int gid) {

    227. 

  227. 	return gid >> 8;

    228. 

  228. }

    229. 

  229. 

    230. 

  230. 

    231. 

  231. tp3_stat_t

    232. 

  232. tp3_initnodedata (ptp3_nodedata_t pnode, int numofdev, int *gids, tp3_dev_t devtype) {

    233. 

  233. 	TP3_STAT_RETURN ((devtype != TP3_DEV_SNODE) && (devtype != TP3_DEV_ANODE), 

    234. 

  234. 			TP3_SC_NOT_PROPER_DEVTYPE);

    235. 

  235. 

    236. 

  236. 	memset ((void *)pnode, 0x00, sizeof (tp3_nodedata_t));

    237. 

  237. 

    238. 

  238. 	pnode->numofdev = numofdev;

    239. 

  239. 	pnode->devtype = devtype;

    240. 

  240. 

    241. 

  241. 	if (numofdev > 0) {

    242. 

  242. 		pnode->gids = (int *)MALLOC(sizeof(int) * numofdev);

    243. 

  243. 		pnode->stats = (tp3_devstat_t *)MALLOC(sizeof(tp3_devstat_t) * numofdev);

    244. 

  244. 		pnode->envs = (int *)MALLOC(sizeof(int) * numofdev);

    245. 

  245. 		if (devtype == TP3_DEV_SENSOR) {

    246. 

  246. 			pnode->attrs = (void *)MALLOC(sizeof(tp3_senattr_t) * numofdev);

    247. 

  247. 		} else {

    248. 

  248. 			pnode->attrs = (void *)MALLOC(sizeof(tp3_actattr_t) * numofdev);

    249. 

  249. 		}

    250. 

  250. 

    251. 

  251. 		if (pnode->gids == NULL || pnode->stats == NULL 

    252. 

  252. 				|| pnode->envs == NULL || pnode->attrs == NULL) {

    253. 

  253. 			FREE (pnode->gids);

    254. 

  254. 			FREE (pnode->stats);

    255. 

  255. 			FREE (pnode->envs);

    256. 

  256. 			FREE (pnode->attrs);

    257. 

  257. 

    258. 

  258. 			TP3_STAT_PRETURN ("tp3_initnodedata : memory allocation for ptp3_nodedata_t",

    259. 

  259. 					TP3_SC_MEMORY_ALLOCATION_FAIL);

    260. 

  260. 		}

    261. 

  261. 

    262. 

  262. 		memcpy ((void *)(pnode->gids), (void *)gids, sizeof(int) * numofdev);

    263. 

  263. 		memset ((void *)(pnode->stats), 0x00, sizeof(tp3_nodestat_t) * numofdev);

    264. 

  264. 		memset ((void *)(pnode->envs), 0x00, sizeof(int) * numofdev);

    265. 

  265. 		if (devtype == TP3_DEV_SENSOR) {

    266. 

  266. 			memset ((void *)(pnode->attrs), 0x00, sizeof(tp3_senattr_t) * numofdev);

    267. 

  267. 		} else {

    268. 

  268. 			memset ((void *)(pnode->attrs), 0x00, sizeof(tp3_actattr_t) * numofdev);

    269. 

  269. 		}

    270. 

  270. 	}

    271. 

  271. 

    272. 

  272. 	return TP3_SC_NOERROR;

    273. 

  273. }

    274. 

  274. 

    275. 

  275. int

    276. 

  276. tp3_getidxdev (ptp3_nodedata_t pnode, int gid) {

    277. 

  277. 	int i;

    278. 

  278. 	for (i = 0; i < pnode->numofdev; i++) {

    279. 

  279. 		if ((pnode->gids)[i] == gid) {

    280. 

  280. 			return i;

    281. 

  281. 		}

    282. 

  282. 	}

    283. 

  283. 	return -1;

    284. 

  284. }

    285. 

  285. 

    286. 

  286. tp3_stat_t

    287. 

  287. tp3_setdevenv (ptp3_nodedata_t pnode, int gid, int env) {

    288. 

  288. 	int idx = tp3_getidxdev(pnode, gid);

    289. 

  289. 	TP3_STAT_RETURN (idx < 0, TP3_SC_NOT_FOUND_DEVID);

    290. 

  290. 	(pnode->envs)[idx] = env;

    291. 

  291. 	return TP3_SC_NOERROR;

    292. 

  292. }

    293. 

  293. 

    294. 

  294. tp3_stat_t

    295. 

  295. tp3_setdevstat (ptp3_nodedata_t pnode, int gid, tp3_devstat_t stat) {

    296. 

  296. 	int idx = tp3_getidxdev(pnode, gid);

    297. 

  297. 	TP3_STAT_RETURN (idx < 0, TP3_SC_NOT_FOUND_DEVID);

    298. 

  298. 	(pnode->stats)[idx] = stat;

    299. 

  299. 	return TP3_SC_NOERROR;

    300. 

  300. }

    301. 

  301. 

    302. 

  302. tp3_stat_t

    303. 

  303. tp3_setdevattr (ptp3_nodedata_t pnode, int gid, void *attr) {

    304. 

  304. 	int idx = tp3_getidxdev(pnode, gid);

    305. 

  305. 	TP3_STAT_RETURN (idx < 0, TP3_SC_NOT_FOUND_DEVID);

    306. 

  306. 	if (pnode->devtype == TP3_DEV_SENSOR) {

    307. 

  307. 		ptp3_senattr_t pattr = (ptp3_senattr_t)(pnode->attrs);

    308. 

  308. 		memcpy ((void *)(pattr + idx), attr, sizeof(tp3_senattr_t));

    309. 

  309. 	} else {

    310. 

  310. 		ptp3_actattr_t pattr = (ptp3_actattr_t)(pnode->attrs);

    311. 

  311. 		memcpy ((void *)(pattr + idx), attr, sizeof(tp3_actattr_t));

    312. 

  312. 	}

    313. 

  313. 	return TP3_SC_NOERROR;

    314. 

  314. }

    315. 

  315. 

    316. 

  316. void

    317. 

  317. tp3_releasenodedata (ptp3_nodedata_t pnode) {

    318. 

  318. 	FREE (pnode->gids);

    319. 

  319. 	FREE (pnode->envs);

    320. 

  320. 	FREE (pnode->stats);

    321. 

  321. 	FREE (pnode->attrs);

    322. 

  322. }

    323. 

  323. 

    324. 

  324. void

    325. 

  325. tp3_setsenattr (ptp3_senattr_t psenattr, int gsid, tp3_sentype_t sentype, tp3_sendatatype_t datatype, tp3_sengathertype_t gathertype, int gatherinterval, int maxval, int minval, int precision, int errrange, tp3_senthrsdtype_t thresholdtype, int threshold) {

    326. 

  326. 	psenattr->gsid = gsid;

    327. 

  327. 	psenattr->sentype = sentype;

    328. 

  328. 	psenattr->datatype = datatype;

    329. 

  329. 	psenattr->gathertype = gathertype;

    330. 

  330. 	psenattr->gatherinterval = gatherinterval;

    331. 

  331. 	psenattr->maxval = maxval;

    332. 

  332. 	psenattr->minval = minval;

    333. 

  333. 	psenattr->precision = precision;

    334. 

  334. 	psenattr->errrange = errrange;

    335. 

  335. 	psenattr->thresholdtype = thresholdtype;

    336. 

  336. 	psenattr->threshold = threshold;

    337. 

  337. }

    338. 

  338. 

    339. 

  339. void

    340. 

  340. tp3_setactattr (ptp3_actattr_t pactattr, int gaid, tp3_acttype_t acttype, tp3_actdatatype_t datatype, tp3_actgathertype_t gathertype, int gatherinterval) {

    341. 

  341. 	pactattr->gaid = gaid;

    342. 

  342. 	pactattr->acttype = acttype;

    343. 

  343. 	pactattr->datatype = datatype;

    344. 

  344. 	pactattr->gathertype = gathertype;

    345. 

  345. 	pactattr->gatherinterval = gatherinterval;

    346. 

  346. }

    347. 

  347. 

    348. 

  348. void

    349. 

  349. tp3_initnset (ptp3_nsetdata_t pnset) {

    350. 

  350. 	memset ((void *)pnset, 0x00, sizeof (tp3_nsetdata_t));

    351. 

  351. }

    352. 

  352. 

    353. 

  353. int

    354. 

  354. tp3_getidxnode (ptp3_nsetdata_t pnset, int nodeid) {

    355. 

  355. 	int i;

    356. 

  356. 	for (i = 0; i < pnset->numofnode; i++) {

    357. 

  357. 		if ((pnset->nids)[i] == nodeid) {

    358. 

  358. 			return i;

    359. 

  359. 		}

    360. 

  360. 	}

    361. 

  361. 	return -1;

    362. 

  362. }

    363. 

  363. 

    364. 

  364. tp3_stat_t

    365. 

  365. tp3_updatenset (ptp3_nsetdata_t pnset, int nodeid, ptp3_nodedata_t pnode) {

    366. 

  366. 	int idx = tp3_getidxnode(pnset, nodeid);

    367. 

  367. 

    368. 

  368. 	if (pnode == NULL) {

    369. 

  369. 		TP3_STAT_RETURN (idx < 0, TP3_SC_NOT_FOUND_NODEID);

    370. 

  370. 

    371. 

  371. 		return tp3_delnset (pnset, nodeid);

    372. 

  372. 	} else {

    373. 

  373. 		if (idx < 0) {

    374. 

  374. 			return tp3_addnset (pnset, nodeid, pnode);

    375. 

  375. 		} else {

    376. 

  376. 			pnset->numofdev += (pnode->numofdev - (pnset->nodedata)[idx].numofdev);

    377. 

  377. 			tp3_releasenodedata ((pnset->nodedata) + idx);

    378. 

  378. 			memcpy ((void *)((pnset->nodedata) + idx), (void *)pnode, sizeof(tp3_nodedata_t));

    379. 

  379. 			return TP3_SC_NOERROR;

    380. 

  380. 		}

    381. 

  381. 	}

    382. 

  382. }

    383. 

  383. 

    384. 

  384. tp3_stat_t

    385. 

  385. tp3_addnset (ptp3_nsetdata_t pnset, int nodeid, ptp3_nodedata_t pnode) {

    386. 

  386. 	int idx = tp3_getidxnode(pnset, nodeid);

    387. 

  387. 	void *ptr1, *ptr2, *ptr3;

    388. 

  388. 

    389. 

  389. 	TP3_STAT_RETURN (idx >= 0, TP3_SC_EXIST_NODEID);

    390. 

  390. 

    391. 

  391. 	(pnset->numofnode)++;

    392. 

  392. 

    393. 

  393. 	ptr1 = REALLOC(pnset->nids, sizeof(int) * pnset->numofnode);

    394. 

  394. 	ptr2 = REALLOC(pnset->stats, sizeof(tp3_nodestat_t) * pnset->numofnode);

    395. 

  395. 	ptr3 = REALLOC(pnset->nodedata, sizeof(tp3_nodedata_t) * pnset->numofnode);

    396. 

  396. 

    397. 

  397. 	if (ptr1 == NULL || ptr2 == NULL || ptr3 == NULL) {

    398. 

  398. 		if (ptr1 == NULL) {

    399. 

  399. 			FREE (pnset->nids);

    400. 

  400. 		} else if (ptr2 == NULL) {

    401. 

  401. 			FREE (pnset->stats);

    402. 

  402. 		} else {

    403. 

  403. 			FREE (pnset->nodedata);

    404. 

  404. 		}

    405. 

  405. 

    406. 

  406. 		FREE (ptr1);

    407. 

  407. 		FREE (ptr2);

    408. 

  408. 		FREE (ptr3);

    409. 

  409. 

    410. 

  410. 		TP3_STAT_PRETURN ("tp3_initnset : memory reallocation for ptp3_nsetdata_t",

    411. 

  411. 				TP3_SC_MEMORY_ALLOCATION_FAIL);

    412. 

  412. 	}

    413. 

  413. 

    414. 

  414. 	pnset->nids = (int *)ptr1;

    415. 

  415. 	pnset->stats = (tp3_nodestat_t *)ptr2;

    416. 

  416. 	pnset->nodedata = (tp3_nodedata_t *)ptr3;

    417. 

  417. 

    418. 

  418. 	(pnset->nids)[pnset->numofnode - 1] = nodeid;

    419. 

  419. 	(pnset->stats)[pnset->numofnode - 1] = TP3_NODEST_NORMAL;

    420. 

  420. 	memcpy ((void *)((pnset->nodedata) + (pnset->numofnode - 1)), (void *)pnode, sizeof(tp3_nodedata_t));

    421. 

  421. 	pnset->numofdev += pnode->numofdev;

    422. 

  422. 	

    423. 

  423. 	return TP3_SC_NOERROR;

    424. 

  424. }

    425. 

  425. 

    426. 

  426. tp3_stat_t

    427. 

  427. tp3_delnset (ptp3_nsetdata_t pnset, int nodeid) {

    428. 

  428. 	int idx = tp3_getidxnode(pnset, nodeid);

    429. 

  429. 

    430. 

  430. 	TP3_STAT_RETURN (idx < 0, TP3_SC_NOT_FOUND_NODEID);

    431. 

  431. 

    432. 

  432. 	(pnset->numofnode)--;

    433. 

  433. 	pnset->numofdev -= (pnset->nodedata + idx)->numofdev;

    434. 

  434. 	tp3_releasenodedata (pnset->nodedata + idx);

    435. 

  435. 

    436. 

  436. 	(pnset->nids)[idx] = (pnset->nids)[pnset->numofnode];

    437. 

  437. 	(pnset->stats)[idx] = (pnset->stats)[pnset->numofnode];

    438. 

  438. 	(pnset->nodedata)[idx] = (pnset->nodedata)[pnset->numofnode];

    439. 

  439. 	

    440. 

  440. 	return TP3_SC_NOERROR;

    441. 

  441. }

    442. 

  442. 

    443. 

  443. tp3_stat_t

    444. 

  444. tp3_setnodestat (ptp3_nsetdata_t pnset, int nodeid, tp3_nodestat_t nstat) {

    445. 

  445. 	int idx = tp3_getidxnode(pnset, nodeid);

    446. 

  446. 

    447. 

  447. 	TP3_STAT_RETURN (idx < 0, TP3_SC_NOT_FOUND_NODEID);

    448. 

  448. 

    449. 

  449. 	(pnset->stats)[idx] = nstat;

    450. 

  450. 

    451. 

  451. 	return TP3_SC_NOERROR;

    452. 

  452. }

    453. 

  453. 

    454. 

  454. void

    455. 

  455. tp3_releasenset (ptp3_nsetdata_t pnset) {

    456. 

  456. 	int i;

    457. 

  457. 	for (i = 0; i < pnset->numofnode; i++) {

    458. 

  458. 		tp3_releasenodedata (pnset->nodedata + i);

    459. 

  459. 	}

    460. 

  460. 

    461. 

  461. 	FREE (pnset->nids);

    462. 

  462. 	FREE (pnset->stats);

    463. 

  463. 	FREE (pnset->nodedata);

    464. 

  464. }

    465. 

  465. 

    466. 

  466. int

    467. 

  467. tp3_readfield_array (ptp3_msg_t pmsg, tp3_fieldcode_t fc, int *arr, int maxsize) {

    468. 

  468. 	tp3_fdata_t data;

    469. 

  469. 	//int i, size, len;

    470. 

  470. 	int len;

    471. 

  471. 	byte *ptr;

    472. 

  472. 

    473. 

  473. 	len = tp3_readfield (pmsg, fc, &data);

    474. 

  474. 	TP3_EXP_RETURN (len < 0, -1, TP3_SC_NOREQFIELD_ERR);

    475. 

  475. 

    476. 

  476. 	/*

    477. 

  477. 	switch (fc) {

    478. 

  478. 		case TP3_FC_ARROFSNID:

    479. 

  479. 		case TP3_FC_ARROFANID:

    480. 

  480. 			//size = _TP3_NODEID_SIZE;

    481. 

  481. 			//break;

    482. 

  482. 		case TP3_FC_ARROFGSID:

    483. 

  483. 		case TP3_FC_ARROFGAID:

    484. 

  484. 			//size = _TP3_GID_SIZE;

    485. 

  485. 			//break;

    486. 

  486. 		case TP3_FC_ARROFSNSTAT:

    487. 

  487. 		case TP3_FC_ARROFANSTAT:

    488. 

  488. 		case TP3_FC_ARROFSENSSTAT:

    489. 

  489. 		case TP3_FC_ARROFACTSSTAT:

    490. 

  490. 			//size = _TP3_STAT_SIZE;

    491. 

  491. 			//break;

    492. 

  492. 		case TP3_FC_ARROFSENSVAL:

    493. 

  493. 			//size = _TP3_SENDATA_SIZE;

    494. 

  494. 			//break;

    495. 

  495. 		case TP3_FC_ARROFACTSVAL:

    496. 

  496. 			//size = _TP3_ACTDATA_SIZE;

    497. 

  497. 			break;

    498. 

  498. 		default:

    499. 

  499. 			TP3_EXP_RETURN (1, -1, TP3_SC_NOREQFIELD_ERR);

    500. 

  500. 	}

    501. 

  501. 	*/

    502. 

  502. 	if (len > _TP3_FDATA_LIMIT)

    503. 

  503. 		ptr = data.pbyte;

    504. 

  504. 	else

    505. 

  505. 		ptr = (byte *)&(data.data);

    506. 

  506. 

    507. 

  507. 	if (len > maxsize * sizeof(int))

    508. 

  508. 		len = maxsize * sizeof(int);

    509. 

  509. 	memcpy (arr, ptr, len);

    510. 

  510. 	return len / sizeof(int);

    511. 

  511. 	/*

    512. 

  512. 	len = len / size;

    513. 

  513. 	for (i = 0; i < len && i < maxsize; i++) {

    514. 

  514. 		arr[i] = tp3_readnum (ptr + i * size, size);

    515. 

  515. 	}

    516. 

  516. 	return i;

    517. 

  517. 	*/

    518. 

  518. }

    519. 

  519. 

    520. 

  520. tp3_stat_t

    521. 

  521. tp3_nsettoarray (ptp3_nsetdata_t pnset, tp3_fieldcode_t fc, int *length, byte **pbyte) {

    522. 

  522. 	int len, i, j;

    523. 

  523. 	ptp3_nodedata_t pdev;

    524. 

  524. 	int *ptr; 

    525. 

  525. 

    526. 

  526. 	switch (fc) {

    527. 

  527. 		case TP3_FC_ARROFSNID:

    528. 

  528. 		case TP3_FC_ARROFANID:

    529. 

  529. 			len = pnset->numofnode;

    530. 

  530. 			ptr = (int *) MALLOC (len * sizeof(int));

    531. 

  531. 			TP3_STAT_RETURN ((ptr == NULL), TP3_SC_MEMORY_ALLOCATION_FAIL);

    532. 

  532. 			for (i = 0; i < len; i ++) {

    533. 

  533. 				ptr[i] = pnset->nids[i];

    534. 

  534. 			}

    535. 

  535. 			break;

    536. 

  536. 

    537. 

  537. 		case TP3_FC_ARROFGSID:

    538. 

  538. 		case TP3_FC_ARROFGAID:

    539. 

  539. 			len = pnset->numofdev;

    540. 

  540. 			ptr = (int *) MALLOC (len * sizeof(int));

    541. 

  541. 			TP3_STAT_RETURN ((ptr == NULL), TP3_SC_MEMORY_ALLOCATION_FAIL);

    542. 

  542. 			pdev = pnset->nodedata;

    543. 

  543. 			j = 0;

    544. 

  544. 			if ( pdev->gids != NULL ) {

    545. 

  545. 				for (i = 0; i < len; i++) {

    546. 

  546. 					ptr[i] = pdev->gids[j++];

    547. 

  547. 					if (j == pdev->numofdev) {

    548. 

  548. 						pdev++;

    549. 

  549. 						j = 0;

    550. 

  550. 					}

    551. 

  551. 				}

    552. 

  552. 			}

    553. 

  553. 			break;

    554. 

  554. 

    555. 

  555. 		case TP3_FC_ARROFSNSTAT:

    556. 

  556. 		case TP3_FC_ARROFANSTAT:

    557. 

  557. 			len = pnset->numofnode;

    558. 

  558. 			ptr = (int *) MALLOC (len * sizeof(int));

    559. 

  559. 			TP3_STAT_RETURN ((ptr == NULL), TP3_SC_MEMORY_ALLOCATION_FAIL);

    560. 

  560. 			for (i = 0; i < len; i++) {

    561. 

  561. 				ptr[i] = pnset->stats[i];

    562. 

  562. 			}

    563. 

  563. 			break;

    564. 

  564. 

    565. 

  565. 		case TP3_FC_ARROFSENSSTAT:

    566. 

  566. 		case TP3_FC_ARROFACTSSTAT:

    567. 

  567. 			len = pnset->numofdev;

    568. 

  568. 			ptr = (int *) MALLOC (len * sizeof(int));

    569. 

  569. 			TP3_STAT_RETURN ((ptr == NULL), TP3_SC_MEMORY_ALLOCATION_FAIL);

    570. 

  570. 			pdev = pnset->nodedata;

    571. 

  571. 			j = 0;

    572. 

  572. 			if ( pdev->stats != NULL ) {

    573. 

  573. 				for (i = 0; i < len; i++) {

    574. 

  574. 					ptr[i] = pdev->stats[j++];

    575. 

  575. 					if (j == pdev->numofdev) {

    576. 

  576. 						pdev++;

    577. 

  577. 						j = 0;

    578. 

  578. 					}

    579. 

  579. 				}

    580. 

  580. 			}

    581. 

  581. 			break;

    582. 

  582. 

    583. 

  583. 		case TP3_FC_ARROFSENSVAL:

    584. 

  584. 		case TP3_FC_ARROFACTSVAL:

    585. 

  585. 			len = pnset->numofdev;

    586. 

  586. 			ptr = (int *) MALLOC (len * sizeof(int));

    587. 

  587. 			TP3_STAT_RETURN ((ptr == NULL), TP3_SC_MEMORY_ALLOCATION_FAIL);

    588. 

  588. 			pdev = pnset->nodedata;

    589. 

  589. 			j = 0;

    590. 

  590. 			if ( pdev->envs != NULL ){

    591. 

  591. 				for (i = 0; i < len; i++) {

    592. 

  592. 					ptr[i] = pdev->envs[j++];

    593. 

  593. 					if (j == pdev->numofdev) {

    594. 

  594. 						pdev++;

    595. 

  595. 						j = 0;

    596. 

  596. 					}

    597. 

  597. 				}

    598. 

  598. 			}

    599. 

  599. 			break;

    600. 

  600. 

    601. 

  601. 		default:

    602. 

  602. 			return TP3_SC_MSGTYPE_ERR;

    603. 

  603. 	}

    604. 

  604. 

    605. 

  605. 	*length = len * sizeof(int);

    606. 

  606. 	*pbyte = (byte *)ptr;

    607. 

  607. 

    608. 

  608. 	return TP3_SC_NOERROR;

    609. 

  609. }

    610. 

  610. 

    611. 

  611. tp3_stat_t

    612. 

  612. tp3_addfield_nsetdata (ptp3_msg_t pmsg, tp3_fieldcode_t fc, ptp3_nsetdata_t pnset) {

    613. 

  613. 	int length;

    614. 

  614. 	byte *pbyte;

    615. 

  615. 

    616. 

  616. 	TP3_STAT_NOERROR (tp3_nsettoarray (pnset, fc, &length, &pbyte));

    617. 

  617. 	TP3_STAT_NOERROR (tp3_addfield_nbytes (pmsg, fc, length, pbyte));

    618. 

  618. 	// by chj 2015.9.30 

    619. 

  619. 	// memory leak

    620. 

  620. 	FREE(pbyte) ;

    621. 

  621. 	return TP3_SC_NOERROR;

    622. 

  622. }

    623. 

  623. 

    624. 

  624. void

    625. 

  625. tp3_settimestamp (byte *ptr, time_t epoch) {

    626. 

  626. 	struct tm t;

    627. 

  627. 	byte tmp;

    628. 

  628. 

    629. 

  629. 	localtime_r (&epoch, &t);

    630. 

  630. 	tmp = (t.tm_year + 1900) / 100;

    631. 

  631. 	ptr[0] = ((tmp / 10) << 4) | tmp % 10;

    632. 

  632. 	tmp = (t.tm_year + 1900) % 100;

    633. 

  633. 	ptr[1] = ((tmp / 10) << 4) | tmp % 10;

    634. 

  634. 	tmp = (t.tm_mon + 1);

    635. 

  635. 	ptr[2] = ((tmp / 10) << 4) | tmp % 10;

    636. 

  636. 	tmp = t.tm_mday;

    637. 

  637. 	ptr[3] = ((tmp / 10) << 4) | tmp % 10;

    638. 

  638. 	tmp = t.tm_hour;

    639. 

  639. 	ptr[4] = ((tmp / 10) << 4) | tmp % 10;

    640. 

  640. 	tmp = t.tm_min;

    641. 

  641. 	ptr[5] = ((tmp / 10) << 4) | tmp % 10;

    642. 

  642. 	tmp = t.tm_sec;

    643. 

  643. 	ptr[6] = ((tmp / 10) << 4) | tmp % 10;

    644. 

  644. }

    645. 

  645. 

    646. 

  646. time_t

    647. 

  647. tp3_getepoch (byte *ptr) {

    648. 

  648. 	struct tm t;

    649. 

  649. 

    650. 

  650. 	t.tm_year = ((ptr[0] / 16) * 10 + (ptr[0] & 0xF)) * 100;

    651. 

  651. 	t.tm_year += (ptr[1] / 16) * 10 + (ptr[1] & 0xF) - 1900;

    652. 

  652. 	t.tm_mon = (ptr[2] / 16) * 10 + (ptr[2] & 0xF) - 1;

    653. 

  653. 	t.tm_mday = (ptr[3] / 16) * 10 + (ptr[3] & 0xF);

    654. 

  654. 	t.tm_hour = (ptr[4] / 16) * 10 + (ptr[4] & 0xF);

    655. 

  655. 	t.tm_min = (ptr[5] / 16) * 10 + (ptr[5] & 0xF);

    656. 

  656. 	t.tm_sec = (ptr[6] / 16) * 10 + (ptr[6] & 0xF);

    657. 

  657. 

    658. 

  658. 	return mktime (&t);

    659. 

  659. }

    660. 

  660. 

    661. 

  661. tp3_stat_t

    662. 

  662. tp3_addfield_timestamp (ptp3_msg_t pmsg, tp3_fieldcode_t fc, time_t stamp) {

    663. 

  663. 	byte ptr[7];

    664. 

  664. 	tp3_settimestamp (ptr, stamp);

    665. 

  665. 	return tp3_addfield_bytes (pmsg, fc, ptr);

    666. 

  666. }

    667. 

  667. 

    668. 

  668. int

    669. 

  669. tp3_getinterval (byte *ptr) {

    670. 

  670. 	return (ptr[0] - '0') * 36000 + (ptr[1] - '0') * 3600

    671. 

  671. 		+ (ptr[2] - '0') * 600 + (ptr[3] - '0') * 60

    672. 

  672. 		+ (ptr[4] - '0') * 10 + (ptr[5] - '0');

    673. 

  673. }

    674. 

  674. 

    675. 

  675. tp3_stat_t

    676. 

  676. tp3_addfield_interval (ptp3_msg_t pmsg, tp3_fieldcode_t fc, int interval) {

    677. 

  677. 	int tmp;

    678. 

  678. 	byte ptr[6];

    679. 

  679. 

    680. 

  680. 	tmp = interval / 3600;

    681. 

  681. 	ptr[0] = tmp / 10 + '0'; 

    682. 

  682. 	ptr[1] = tmp % 10 + '0'; 

    683. 

  683. 	tmp = (interval - tmp * 3600) / 60;

    684. 

  684. 	ptr[2] = tmp / 10 + '0';

    685. 

  685. 	ptr[3] = tmp % 10 + '0';

    686. 

  686. 	ptr[4] = (interval % 60) / 10 + '0';

    687. 

  687. 	ptr[5] = (interval % 10) + '0';

    688. 

  688. 

    689. 

  689. 	return tp3_addfield_bytes (pmsg, fc, ptr);

    690. 

  690. }

    691. 

  691. 

    692. 

  692. tp3_stat_t

    693. 

  693. tp3_initblock (ptp3_block_t pblock, int rows, int numofsn, int numofsens, int numofan, int numofacts) {

    694. 

  694. 	pblock->pitems = (tp3_blockitem_t *)MALLOC(sizeof(tp3_blockitem_t) * rows);

    695. 

  695. 	TP3_STAT_RETURN (pblock->pitems == NULL, TP3_SC_MEMORY_ALLOCATION_FAIL);

    696. 

  696. 	memset ((void *)(pblock->pitems), 0x00, sizeof(tp3_blockitem_t) * rows);

    697. 

  697. 

    698. 

  698. 	pblock->rows = rows;

    699. 

  699. 	pblock->numofdev[TP3_DEV_SNODE] = numofsn;

    700. 

  700. 	pblock->numofdev[TP3_DEV_ANODE] = numofan;

    701. 

  701. 	pblock->numofdev[TP3_DEV_SENSOR] = numofsens;

    702. 

  702. 	pblock->numofdev[TP3_DEV_ACTUATOR] = numofacts;

    703. 

  703. 	pblock->pcuritem = pblock->pitems;

    704. 

  704. 	

    705. 

  705. 	return TP3_SC_NOERROR;

    706. 

  706. }

    707. 

  707. 

    708. 

  708. void

    709. 

  709. tp3_nextemptyblockitem (ptp3_block_t pblock, time_t timestamp, tp3_gcgstat_t gcgstat) {

    710. 

  710. 	while ((pblock->pcuritem)->timestamp != 0) {

    711. 

  711. 		//ASSERT (pblock->pcuritem < pblock->pitems + pblock->rows);

    712. 

  712. 		(pblock->pcuritem)++;

    713. 

  713. 	}

    714. 

  714. 

    715. 

  715. 	(pblock->pcuritem)->timestamp = timestamp;

    716. 

  716. 	(pblock->pcuritem)->gcgstat = gcgstat;

    717. 

  717. 	(pblock->itemidx)[TP3_DEV_SNODE] = (pblock->itemidx)[TP3_DEV_ANODE] 

    718. 

  718. 		= (pblock->itemidx)[TP3_DEV_SENSOR] = (pblock->itemidx)[TP3_DEV_ACTUATOR] = 0;

    719. 

  719. }

    720. 

  720. 

    721. 

  721. void

    722. 

  722. tp3_setblockitem (ptp3_block_t pblock, int id, int value, tp3_dev_t devtype) {

    723. 

  723. 	ptp3_blockitem_t pitem = pblock->pcuritem;

    724. 

  724. 	int *idx = pblock->itemidx;

    725. 

  725. 

    726. 

  726. 	pitem->ids[devtype][idx[devtype]] = id;

    727. 

  727. 	pitem->vals[devtype][idx[devtype]] = value;

    728. 

  728. 	idx[devtype] ++;

    729. 

  729. }

    730. 

  730. 

    731. 

  731. byte *

    732. 

  732. tp3_setstatblockbytes (byte *ptr, int numofdev, tp3_dev_t devtype, ptp3_blockitem_t pitem) {

    733. 

  733. 	int i;

    734. 

  734. 

    735. 

  735. 	*ptr = (byte)numofdev;

    736. 

  736. 	ptr++;

    737. 

  737. 

    738. 

  738. 	if (devtype == TP3_DEV_SNODE || devtype == TP3_DEV_ANODE) {

    739. 

  739. 		for (i = 0; i < numofdev; i++) {

    740. 

  740. 			tp3_set3bytes (ptr, (pitem->ids)[devtype][i]);

    741. 

  741. 			ptr += _TP3_NODEID_SIZE;

    742. 

  742. 		}

    743. 

  743. 	} else {

    744. 

  744. 		for (i = 0; i < numofdev; i++) {

    745. 

  745. 			tp3_set4bytes (ptr, (pitem->ids)[devtype][i]);

    746. 

  746. 			ptr += _TP3_GID_SIZE;

    747. 

  747. 		}

    748. 

  748. 	}

    749. 

  749. 

    750. 

  750. 	for (i = 0; i < numofdev; i++) {

    751. 

  751. 		*ptr = (pitem->vals)[devtype][i];

    752. 

  752. 		ptr++;

    753. 

  753. 	}

    754. 

  754. 

    755. 

  755. 	return ptr;

    756. 

  756. }

    757. 

  757. 

    758. 

  758. tp3_stat_t

    759. 

  759. tp3_addfield_statblock (ptp3_msg_t pmsg, ptp3_block_t pblock) {

    760. 

  760. 	int i;

    761. 

  761. 	byte *pblk, *ptr;

    762. 

  762. 	int step = 1 /* 1: gcgstat */

    763. 

  763. 			+ 1 + 4 * pblock->numofdev[TP3_DEV_SNODE] /* 3 : node id, 1 : status */

    764. 

  764. 		 	+ 1 + 4 * pblock->numofdev[TP3_DEV_ANODE] /* 3 : node id, 1 : status */

    765. 

  765. 		 	+ 1 + 5 * pblock->numofdev[TP3_DEV_SENSOR] /* 4 : gid, 1 : status */

    766. 

  766. 		 	+ 1 + 5 * pblock->numofdev[TP3_DEV_ACTUATOR] /* 4 : gid, 1 : status */

    767. 

  767. 		 	+ 7; /* 7 : timestamp */

    768. 

  768. 	int size = pblock->rows * step;

    769. 

  769. 

    770. 

  770. 	pblk = (byte *)MALLOC (sizeof(byte) * size);

    771. 

  771. 	TP3_STAT_RETURN (pblk == NULL, TP3_SC_MEMORY_ALLOCATION_FAIL);

    772. 

  772. 

    773. 

  773. 	for (i = 0; i < pblock->rows; i++) {

    774. 

  774. 		ptr = pblk + step * i;

    775. 

  775. 		*ptr = (byte)((pblock->pitems + i)->gcgstat);

    776. 

  776. 		ptr++;

    777. 

  777. 		ptr = tp3_setstatblockbytes (ptr, pblock->numofdev[TP3_DEV_SNODE], TP3_DEV_SNODE, pblock->pitems + i);

    778. 

  778. 		ptr = tp3_setstatblockbytes (ptr, pblock->numofdev[TP3_DEV_ANODE], TP3_DEV_ANODE, pblock->pitems + i);

    779. 

  779. 		ptr = tp3_setstatblockbytes (ptr, pblock->numofdev[TP3_DEV_SENSOR], TP3_DEV_SENSOR, pblock->pitems + i);

    780. 

  780. 		ptr = tp3_setstatblockbytes (ptr, pblock->numofdev[TP3_DEV_ACTUATOR], TP3_DEV_ACTUATOR, pblock->pitems + i);

    781. 

  781. 		tp3_settimestamp (ptr, ((pblock->pitems + i)->timestamp));

    782. 

  782. 	}

    783. 

  783. 

    784. 

  784. 	TP3_STAT_NOERROR (tp3_addfield_nbytes (pmsg, TP3_FC_BLKOFSTAT, size, pblk));

    785. 

  785. 	return TP3_SC_NOERROR;

    786. 

  786. }

    787. 

  787. 

    788. 

  788. byte *

    789. 

  789. tp3_getstatblockbytes (byte *ptr, int numofdev, tp3_dev_t devtype, ptp3_blockitem_t pitem) {

    790. 

  790. 	int j;

    791. 

  791. 

    792. 

  792. 	if (devtype == TP3_DEV_SNODE || devtype == TP3_DEV_ANODE) {

    793. 

  793. 		for (j = 0; j < numofdev; j++) {

    794. 

  794. 			(pitem->ids)[devtype][j] = tp3_readnum (ptr, _TP3_NODEID_SIZE);

    795. 

  795. 			ptr += _TP3_NODEID_SIZE;

    796. 

  796. 		}

    797. 

  797. 	} else {

    798. 

  798. 		for (j = 0; j < numofdev; j++) {

    799. 

  799. 			(pitem->ids)[devtype][j] = tp3_readnum (ptr, _TP3_GID_SIZE);

    800. 

  800. 			ptr += _TP3_GID_SIZE;

    801. 

  801. 		}

    802. 

  802. 	}

    803. 

  803. 	for (j = 0; j < numofdev; j++) {

    804. 

  804. 		(pitem->vals)[devtype][j] = *ptr;

    805. 

  805. 		ptr++;

    806. 

  806. 	}

    807. 

  807. 

    808. 

  808. 	return ptr;

    809. 

  809. }

    810. 

  810. 

    811. 

  811. tp3_stat_t

    812. 

  812. tp3_parsestatblock (ptp3_block_t pblock, int rows, byte *ptr, int len) {

    813. 

  813. 	int numofsn, numofsens, numofan, numofacts;

    814. 

  814. 	int i, step;

    815. 

  815. 	byte *pblk;

    816. 

  816. 	ptp3_blockitem_t pitem;

    817. 

  817. 

    818. 

  818. 	numofsn = ptr[1];

    819. 

  819. 	numofan = ptr[1 + 1 + 4 * numofsn];

    820. 

  820. 	numofsens = ptr[1 + 1 + 4 * numofsn + 1 + 4 * numofan];

    821. 

  821. 	numofacts = ptr[1 + 1 + 4 * numofsn + 1 + 4 * numofan + 1 + 5 * numofsens];

    822. 

  822. 

    823. 

  823. 	tp3_initblock (pblock, rows, numofsn, numofsens, numofan, numofacts);

    824. 

  824. 	step = 1 /* 1: gcgstat */

    825. 

  825. 			+ 1 + 4 * pblock->numofdev[TP3_DEV_SNODE] /* 3 : node id, 1 : status */

    826. 

  826. 		 	+ 1 + 4 * pblock->numofdev[TP3_DEV_ANODE] /* 3 : node id, 1 : status */

    827. 

  827. 		 	+ 1 + 5 * pblock->numofdev[TP3_DEV_SENSOR] /* 4 : gid, 1 : status */

    828. 

  828. 		 	+ 1 + 5 * pblock->numofdev[TP3_DEV_ACTUATOR] /* 4 : gid, 1 : status */

    829. 

  829. 		 	+ 7; /* 7 : timestamp */

    830. 

  830. 

    831. 

  831. 	for (i = 0; i < rows; i++) {

    832. 

  832. 		pblk = ptr + i * step;

    833. 

  833. 		pitem = pblock->pitems + i;

    834. 

  834. 

    835. 

  835. 		pitem->gcgstat = *pblk;

    836. 

  836. 		pblk += 2;

    837. 

  837. 

    838. 

  838. 		pblk = tp3_getstatblockbytes (pblk, numofsn, TP3_DEV_SNODE, pitem);

    839. 

  839. 		pblk++;

    840. 

  840. 		pblk = tp3_getstatblockbytes (pblk, numofan, TP3_DEV_ANODE, pitem);

    841. 

  841. 		pblk++;

    842. 

  842. 		pblk = tp3_getstatblockbytes (pblk, numofsens, TP3_DEV_SENSOR, pitem);

    843. 

  843. 		pblk++;

    844. 

  844. 		pblk = tp3_getstatblockbytes (pblk, numofacts, TP3_DEV_ACTUATOR, pitem);

    845. 

  845. 		pitem->timestamp = tp3_getepoch (pblk);

    846. 

  846. 	}

    847. 

  847. 

    848. 

  848. 	return TP3_SC_NOERROR;

    849. 

  849. }

    850. 

  850. 

    851. 

  851. byte *

    852. 

  852. tp3_setenvblockbytes (byte *ptr, int numofdev, tp3_dev_t devtype, ptp3_blockitem_t pitem) {

    853. 

  853. 	int i;

    854. 

  854. 

    855. 

  855. 	*ptr = (byte)numofdev;

    856. 

  856. 	ptr++;

    857. 

  857. 

    858. 

  858. 	for (i = 0; i < numofdev; i++) {

    859. 

  859. 		tp3_set4bytes (ptr, (pitem->ids)[devtype][i]);

    860. 

  860. 		ptr += _TP3_GID_SIZE;

    861. 

  861. 	}

    862. 

  862. 

    863. 

  863. 	if (devtype == TP3_DEV_ACTUATOR) {

    864. 

  864. 		for (i = 0; i < numofdev; i++) {

    865. 

  865. 			tp3_set2bytes (ptr, (pitem->vals)[devtype][i]);

    866. 

  866. 			ptr += _TP3_ACTDATA_SIZE;

    867. 

  867. 		}

    868. 

  868. 	} else {

    869. 

  869. 		for (i = 0; i < numofdev; i++) {

    870. 

  870. 			tp3_set4bytes (ptr, (pitem->vals)[devtype][i]);

    871. 

  871. 			ptr += _TP3_SENDATA_SIZE;

    872. 

  872. 		}

    873. 

  873. 	}

    874. 

  874. 

    875. 

  875. 	return ptr;

    876. 

  876. }

    877. 

  877. 

    878. 

  878. byte *

    879. 

  879. tp3_getenvblockbytes (byte *ptr, int numofdev, tp3_dev_t devtype, ptp3_blockitem_t pitem) {

    880. 

  880. 	int i;

    881. 

  881. 

    882. 

  882. 	for (i = 0; i < numofdev; i++) {

    883. 

  883. 		(pitem->ids)[devtype][i] = tp3_readnum (ptr, _TP3_GID_SIZE);

    884. 

  884. 		ptr += _TP3_GID_SIZE;

    885. 

  885. 	}

    886. 

  886. 

    887. 

  887. 	if (devtype == TP3_DEV_ACTUATOR) {

    888. 

  888. 		for (i = 0; i < numofdev; i++) {

    889. 

  889. 			(pitem->vals)[devtype][i] = tp3_readnum (ptr, _TP3_ACTDATA_SIZE);

    890. 

  890. 			ptr += _TP3_ACTDATA_SIZE;

    891. 

  891. 		}

    892. 

  892. 	} else {

    893. 

  893. 		for (i = 0; i < numofdev; i++) {

    894. 

  894. 			(pitem->vals)[devtype][i] = tp3_readnum (ptr, _TP3_SENDATA_SIZE);

    895. 

  895. 			ptr += _TP3_SENDATA_SIZE;

    896. 

  896. 		}

    897. 

  897. 	}

    898. 

  898. 	return ptr;

    899. 

  899. }

    900. 

  900. 

    901. 

  901. tp3_stat_t

    902. 

  902. tp3_parseenvblock (ptp3_block_t pblock, int rows, byte *ptr, int len) {

    903. 

  903. 	int numofsens, numofacts;

    904. 

  904. 	int i, step;

    905. 

  905. 	byte *pblk;

    906. 

  906. 	ptp3_blockitem_t pitem;

    907. 

  907. 

    908. 

  908. 	numofsens = ptr[0];

    909. 

  909. 	numofacts = ptr[1 + 8 * numofsens];

    910. 

  910. 

    911. 

  911. 	tp3_initblock (pblock, rows, 0, numofsens, 0, numofacts);

    912. 

  912. 	step = 1 + 8 * pblock->numofdev[TP3_DEV_SENSOR] /* 4 : gid, 4 : env */

    913. 

  913. 			+ 1 + 6 * pblock->numofdev[TP3_DEV_ACTUATOR] /* 4 : gid, 2 : env */

    914. 

  914. 		 	+ 7; /* 7 : timestamp */

    915. 

  915. 

    916. 

  916. 	for (i = 0; i < rows; i++) {

    917. 

  917. 		pblk = ptr + i * step;

    918. 

  918. 		pitem = pblock->pitems + i;

    919. 

  919. 

    920. 

  920. 		pblk++;

    921. 

  921. 		pblk = tp3_getenvblockbytes (pblk, numofsens, TP3_DEV_SENSOR, pitem);

    922. 

  922. 		pblk++;

    923. 

  923. 		pblk = tp3_getenvblockbytes (pblk, numofacts, TP3_DEV_ACTUATOR, pitem);

    924. 

  924. 		pitem->timestamp = tp3_getepoch (pblk);

    925. 

  925. 	}

    926. 

  926. 

    927. 

  927. 	return TP3_SC_NOERROR;

    928. 

  928. }

    929. 

  929. 

    930. 

  930. 

    931. 

  931. tp3_stat_t

    932. 

  932. tp3_addfield_envblock (ptp3_msg_t pmsg, ptp3_block_t pblock) {

    933. 

  933. 	int i;

    934. 

  934. 	byte *pblk, *ptr;

    935. 

  935. 	int step = 1 + 8 * pblock->numofdev[TP3_DEV_SENSOR] /* 4 : gid, 4 : env */

    936. 

  936. 		 	+ 1 + 6 * pblock->numofdev[TP3_DEV_ACTUATOR] /* 4 : gid, 2 : env */

    937. 

  937. 		 	+ 7; /* 7 : timestamp */

    938. 

  938. 	int size = pblock->rows * step;

    939. 

  939. 

    940. 

  940. 	pblk = (byte *)MALLOC (sizeof(byte) * size);

    941. 

  941. 	TP3_STAT_RETURN (pblk == NULL, TP3_SC_MEMORY_ALLOCATION_FAIL);

    942. 

  942. 

    943. 

  943. 	for (i = 0; i < pblock->rows; i++) {

    944. 

  944. 		ptr = pblk + step * i;

    945. 

  945. 		ptr = tp3_setenvblockbytes (ptr, pblock->numofdev[TP3_DEV_SENSOR], TP3_DEV_SENSOR, pblock->pitems + i);

    946. 

  946. 		ptr = tp3_setenvblockbytes (ptr, pblock->numofdev[TP3_DEV_ACTUATOR], TP3_DEV_ACTUATOR, pblock->pitems + i);

    947. 

  947. 		tp3_settimestamp (ptr, ((pblock->pitems + i)->timestamp));

    948. 

  948. 	}

    949. 

  949. 

    950. 

  950. 	TP3_STAT_NOERROR (tp3_addfield_nbytes (pmsg, TP3_FC_BLKOFENV, size, pblk));

    951. 

  951. 	return TP3_SC_NOERROR;

    952. 

  952. }

    953. 

  953. 

    954. 

  954. void

    955. 

  955. tp3_releaseblock (ptp3_block_t pblock) {

    956. 

  956. 	FREE (pblock->pitems);

    957. 

  957. }
    958.