Gitiles
Code Review Sign In
192.168.1.100 / T108_Public / 94baa7cf36c2d59bd49d02d2e0ec95e9bc84977c / . / mbtk / mbtk_lib / src / mbtk_info.c
blob: 7ff93450fbb42b6ebcd557dd7fbbe272e7ad1d3e [file] [log] [blame]
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <errno.h>
5#include <sys/socket.h>
6#include <string.h>
7
8#include "mbtk_info.h"
9#include "mbtk_list.h"
10#include "mbtk_utils.h"
11
12static int sock_read(int fd, uint8 *msg, int data_len)
13{
14 memset(msg, 0, data_len);
15 int len = 0;
16 int read_len = 0;
17 while(1)
18 {
19 len = read(fd, msg + read_len, data_len - read_len);
20 if(len > 0)
21 {
22 read_len += len;
23 }
24 else if(len == 0)
25 {
26 LOG("read() end.");
27 break;
28 }
29 else
30 {
31 if(EAGAIN == errno)
32 {
33 LOG("Read end, lenght = %d", read_len);
34 }
35 else
36 {
37 LOG("read() error[%d].", errno);
38 }
39 break;
40 }
41 }
42
43 if(read_len > 0)
44 {
45 log_hex("DATA_RECV", msg, read_len);
46 return read_len;
47 }
48 else
49 {
50 return -1;
51 }
52}
53
54static int sock_write(int fd, uint8 *msg, int data_len)
55{
56 int len = 0;
57 int write_len = 0;
58 while(write_len < data_len)
59 {
60 len = write(fd, msg + write_len, data_len - write_len);
61 if(len > 0)
62 {
63 write_len += len;
64 }
65 else if(len == 0)
66 {
67 LOG("write() end.");
68 break;
69 }
70 else
71 {
72 LOG("write() error[%d].", errno);
73 break;
74 }
75 }
76
77 if(write_len > 0)
78 {
79 log_hex("DATA_SEND", msg, write_len);
80 return write_len;
81 }
82 else
83 {
84 return -1;
85 }
86}
87
88static int pack_num_check(const void* data, int data_len)
89{
90 int count = 0;
91 int pack_len;
92 const uint8* ptr = (const uint8*)data;
93 while(ptr < (const uint8*)data + data_len)
94 {
95 if(MBTK_INFO_PACKET_FLAG != byte_2_uint32(ptr, true))
96 {
97 LOG("pack_num_check() - TAG error.");
98 break;
99 }
100 ptr += sizeof(uint32);
101
102 pack_len = byte_2_uint16(ptr, false);
103 if(pack_len < SOCK_PACK_LEN_MIN - SOCK_PACK_EXTRA_LEN)
104 {
105 LOG("pack_num_check() - Packet length error.");
106 break;
107 }
108 ptr += sizeof(uint16);
109 ptr += pack_len;
110
111 count++;
112 }
113
114 return count;
115}
116
117char* type2str(mbtk_info_type_enum type)
118{
119 switch(type)
120 {
121 case MBTK_INFO_TYPE_REQ:
122 return "REQ";
123 case MBTK_INFO_TYPE_RSP:
124 return "RSP";
125 case MBTK_INFO_TYPE_IND:
126 return "IND";
127 default:
128 {
129 return "UNKNOWN";
130 }
131 }
132}
133
134char* apn2str(mbtk_ip_type_enum type)
135{
136 switch(type)
137 {
138 case MBTK_IP_TYPE_IP:
139 return "IP";
140 case MBTK_IP_TYPE_IPV6:
141 return "IPV6";
142 case MBTK_IP_TYPE_IPV4V6:
143 return "IPV4V6";
144 case MBTK_IP_TYPE_PPP:
145 return "PPP";
146 default:
147 {
148 return "UNKNOWN";
149 }
150 }
151}
152
153/*
154IPv6 : 254.128.0.0.0.0.0.0.0.1.0.2.144.5.212.239 -> uint128
155*/
156int str_2_ipv6(const void *ip_str, void *ipv6)
157{
158 const uint8 *ptr = (const uint8*)ip_str;
159 uint8 *ipv6_ptr = (uint8*)ipv6;
160 ipv6_ptr[0] = (uint8)atoi(ptr);
161 int i = 1;
162 while(i < 16) {
163 ptr = (const uint8*)strstr(ptr, ".");
164 if(ptr == NULL)
165 return -1;
166 ptr++;
167 ipv6_ptr[i] = (uint8)atoi(ptr);
168 i++;
169 }
170
171 return 0;
172}
173
174/*
175IPv6 : uint128 -> fe80::215:1dff:fe81:484c
176*/
177int ipv6_2_str(const void *ipv6, void *ipv6_str)
178{
179 const uint8 *ptr = (const uint8*)ipv6;
180 uint8 *ipv6_ptr = (uint8*)ipv6_str;
181 int i = 0;
182 int index = 0;
183 while(i < 16) {
184 index += sprintf(ipv6_ptr + index, "%02x%02x", ptr[i], ptr[i + 1]);
185 index += sprintf(ipv6_ptr + index, ":");
186 i += 2;
187 }
188
189 ipv6_ptr[index - 1] = '\0'; // Delete last ':'
190
191 return 0;
192}
193
194
195
196char* id2str(int id)
197{
198 switch(id)
199 {
200 // <string> IMEI
201 case MBTK_INFO_ID_DEV_IMEI_REQ:
202 case MBTK_INFO_ID_DEV_IMEI_RSP:
203 return "IMEI";
204 // <string> SN
205 case MBTK_INFO_ID_DEV_SN_REQ:
206 case MBTK_INFO_ID_DEV_SN_RSP:
207 return "SN";
208 // <string> MEID
209 case MBTK_INFO_ID_DEV_MEID_REQ:
210 case MBTK_INFO_ID_DEV_MEID_RSP:
211 return "MEID";
212 // <string> VERSION
213 case MBTK_INFO_ID_DEV_VERSION_REQ:
214 case MBTK_INFO_ID_DEV_VERSION_RSP:
215 return "VERSION";
216 // <uint8> 0:Close 1:Open
217 case MBTK_INFO_ID_DEV_VOLTE_REQ:
218 case MBTK_INFO_ID_DEV_VOLTE_RSP:
219 return "VOLTE";
220 // <string> Temperature
221 case MBTK_INFO_ID_DEV_TEMP_REQ: // Temperature
222 case MBTK_INFO_ID_DEV_TEMP_RSP:
223 return "TEMPERATURE";
224 case MBTK_INFO_ID_DEV_TIME_REQ: // Time
225 case MBTK_INFO_ID_DEV_TIME_RSP:
226 return "Time";
227 // Sim Information
228 // <uint8> 0:NOT_EXIST 1:READY ...
229 case MBTK_INFO_ID_SIM_STATE_REQ:
230 case MBTK_INFO_ID_SIM_STATE_RSP:
231 return "SIM_STATE";
232 // <string> PIN
233 case MBTK_INFO_ID_SIM_PIN_REQ:
234 case MBTK_INFO_ID_SIM_PIN_RSP:
235 return "SIM_PIN";
236 // <string> PUK
237 case MBTK_INFO_ID_SIM_PUK_REQ:
238 case MBTK_INFO_ID_SIM_PUK_RSP:
239 return "SIM_PUK";
240 // <string> IMSI
241 case MBTK_INFO_ID_SIM_IMSI_REQ:
242 case MBTK_INFO_ID_SIM_IMSI_RSP:
243 return "IMSI";
244 // <string> ICCID
245 case MBTK_INFO_ID_SIM_ICCID_REQ:
246 case MBTK_INFO_ID_SIM_ICCID_RSP:
247 return "ICCID";
248 // <string> Phone Number
249 case MBTK_INFO_ID_SIM_PN_REQ:
250 case MBTK_INFO_ID_SIM_PN_RSP:
251 return "PHONE_NUMBER";
252 // Network Information
253 // <uint8> 0:OFF 1:ON
254 case MBTK_INFO_ID_NET_RADIO_REQ:
255 case MBTK_INFO_ID_NET_RADIO_RSP:
256 return "RADIO_STATE";
257 case MBTK_INFO_ID_NET_AVAILABLE_REQ:
258 case MBTK_INFO_ID_NET_AVAILABLE_RSP:
259 return "NET_AVAILABLE";
260 case MBTK_INFO_ID_NET_SEL_MODE_REQ:
261 case MBTK_INFO_ID_NET_SEL_MODE_RSP:
262 return "NET_SEL_MODE";
263 case MBTK_INFO_ID_NET_BAND_REQ:
264 case MBTK_INFO_ID_NET_BAND_RSP:
265 return "NET_BNAD";
266 // <uint16>[4] rssi,rscp,rsrp,snr
267 case MBTK_INFO_ID_NET_SIGNAL_REQ:
268 case MBTK_INFO_ID_NET_SIGNAL_RSP:
269 return "SIGNAL";
270 case MBTK_INFO_ID_NET_REG_REQ:
271 case MBTK_INFO_ID_NET_REG_RSP:
272 return "NET_REG";
273 // <string> cmnet/ctnet/3gnet/...
274 case MBTK_INFO_ID_NET_APN_REQ:
275 case MBTK_INFO_ID_NET_APN_RSP:
276 return "APN";
277 // Lock net/cell/frequency
278 case MBTK_INFO_ID_NET_CELL_REQ:
279 case MBTK_INFO_ID_NET_CELL_RSP:
280 return "NET_CELL";
281 case MBTK_INFO_ID_NET_DATA_CALL_REQ:
282 case MBTK_INFO_ID_NET_DATA_CALL_RSP:
283 return "DATA_CALL";
284 // Call Information
285 case MBTK_INFO_ID_CALL_STATE_REQ:
286 case MBTK_INFO_ID_CALL_STATE_RSP:
287 return "CALL_STATE";
288 // SMS Information
289 case MBTK_INFO_ID_SMS_STATE_REQ:
290 case MBTK_INFO_ID_SMS_STATE_RSP:
291 return "SMS_STATE";
292 // PhoneBook Information
293 case MBTK_INFO_ID_PB_STATE_REQ:
294 case MBTK_INFO_ID_PB_STATE_RSP:
295 return "PB_STATE";
296 // IND Information
297 // <uint8> State
298 case MBTK_INFO_ID_IND_NET_STATE_CHANGE:
299 return "IND_NET_STATE";
300 // <uint8> State
301 case MBTK_INFO_ID_IND_CALL_STATE_CHANGE:
302 return "IND_CALL_STATE";
303 // <uint8> State
304 case MBTK_INFO_ID_IND_SMS_STATE_CHANGE:
305 return "IND_SMS_STATE";
306 // <uint8> State
307 case MBTK_INFO_ID_IND_RADIO_STATE_CHANGE:
308 return "IND_RADIO_STATE";
309 // <uint8> State
310 case MBTK_INFO_ID_IND_SIM_STATE_CHANGE:
311 return "IND_SIM_STATE";
312 // <uint8> State
313 case MBTK_INFO_ID_IND_PDP_STATE_CHANGE:
314 return "IND_PDP_STATE";
315 // <uint8> State
316 case MBTK_INFO_ID_IND_SERVER_STATE_CHANGE:
317 return "IND_SERVER_STATE";
318 default:
319 {
320 return "UNKNOWN";
321 }
322 }
323}
324
325char* err2str(mbtk_info_err_enum err)
326{
327 switch(err)
328 {
329 case MBTK_INFO_ERR_SUCCESS:
330 return "SUCCESS";
331 case MBTK_INFO_ERR_FORMAT:
332 return "ERR_FORMAT";
333 case MBTK_INFO_ERR_REQ_UNKNOWN:
334 return "ERR_REQ_UNKNOWN";
335 case MBTK_INFO_ERR_REQ_PARAMETER:
336 return "ERR_REQ_PARAMETER";
337 case MBTK_INFO_ERR_UNSUPPORTED:
338 return "ERR_UNSUPPORTED";
339 case MBTK_INFO_ERR_MEMORY:
340 return "ERR_MEMORY";
341 case MBTK_INFO_ERR_IND_FULL:
342 return "ERR_IND_FULL";
343 case MBTK_INFO_ERR_IND_UNKNOWN:
344 return "ERR_IND_UNKNOWN";
345 case MBTK_INFO_ERR_CID_EXIST:
346 return "ERR_CID_EXIS";
347 case MBTK_INFO_ERR_CID_NO_EXIST:
348 return "ERR_CID_NO_EXIST";
349 case MBTK_INFO_ERR_NET_NO_INIT:
350 return "ERR_CID_NO_EXIST";
351 default:
352 {
353 if(err >= MBTK_INFO_ERR_CME) {
354 return "CME ERROR";
355 }
356
357 return "UNKNOWN";
358 }
359 }
360}
361
362/*
3630 GSM
3641 GSM_COMPACT
3652 UTRAN
3663 GSM_EGPRS
3674 UTRAN_HSDPA
3685 UTRAN_HSUPA
3696 UTRAN_HSDPA_HSUPA
3707 EUTRAN
3718 ECGSM
372*/
373mbtk_net_type_enum mbtk_net_type_get(mbtk_radio_technology_enum radio_tech)
374{
375 switch(radio_tech)
376 {
377 case MBTK_RADIO_TECH_GSM:
378 case MBTK_RADIO_TECH_GSM_COMPACT:
379 case MBTK_RADIO_TECH_GSM_EGPRS:
380 case MBTK_RADIO_TECH_UTRAN_HSPA:
381 {
382 return MBTK_NET_TYPE_GSM;
383 }
384 case MBTK_RADIO_TECH_UTRAN:
385 case MBTK_RADIO_TECH_UTRAN_HSDPA:
386 case MBTK_RADIO_TECH_UTRAN_HSUPA:
387 case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
388 {
389 return MBTK_NET_TYPE_UMTS;
390 }
391 case MBTK_RADIO_TECH_E_UTRAN:
392 {
393 return MBTK_NET_TYPE_LTE;
394 }
395 default:
396 {
397 return MBTK_NET_TYPE_UNKNOWN;
398 }
399 }
400}
401
402
403#if 0
404void net_list_free(void *data)
405{
406 if (data)
407 {
408 mbtk_net_info_t *info = (mbtk_net_info_t*) data;
409 LOG("Free net [%s].", info->plmn);
410 free(info);
411 }
412}
413#endif
414
415mbtk_info_type_enum mbtk_info_type_get(int info_id)
416{
417 if(info_id > MBTK_INFO_ID_IND_BEGIN && info_id < MBTK_INFO_ID_IND_END)
418 {
419 return MBTK_INFO_TYPE_IND;
420 }
421 else if(info_id == MBTK_INFO_ID_DEV_BEGIN ||
422 info_id == MBTK_INFO_ID_DEV_END ||
423 info_id == MBTK_INFO_ID_SIM_BEGIN ||
424 info_id == MBTK_INFO_ID_SIM_END ||
425 info_id == MBTK_INFO_ID_NET_BEGIN ||
426 info_id == MBTK_INFO_ID_NET_END ||
427 info_id == MBTK_INFO_ID_CALL_BEGIN ||
428 info_id == MBTK_INFO_ID_CALL_END ||
429 info_id == MBTK_INFO_ID_SMS_BEGIN ||
430 info_id == MBTK_INFO_ID_SMS_END ||
431 info_id == MBTK_INFO_ID_PB_BEGIN ||
432 info_id == MBTK_INFO_ID_PB_END ||
433 info_id == MBTK_INFO_ID_REQ_UNKNOWN)
434 {
435 return MBTK_INFO_TYPE_UNKNOWN;
436 }
437 else if(info_id % 2 == 1)
438 {
439 return MBTK_INFO_TYPE_REQ;
440 }
441 else
442 {
443 return MBTK_INFO_TYPE_RSP;
444 }
445}
446
447mbtk_info_pack_t* mbtk_info_pack_creat(int info_id)
448{
449 mbtk_info_pack_t *pack = (mbtk_info_pack_t *)malloc(sizeof(mbtk_info_pack_t));
450 if(!pack)
451 {
452 LOG("malloc() error[%d]", errno);
453 return NULL;
454 }
455
456 pack->info_id = (uint16)info_id;
457 pack->info_err = (uint16)0;
458 pack->data_len = (uint16)0;
459 pack->data = NULL;
460
461 return pack;
462}
463
464#if 0
465int mbtk_info_pack_data_set(mbtk_info_pack_t *pack, const void *data, int data_len)
466{
467 if(!pack)
468 {
469 LOG("Packet is NULL.");
470 return -1;
471 }
472
473 mbtk_info_type_enum info_type = mbtk_info_type_get(pack->info_id);
474 // IND
475 if(info_type == MBTK_INFO_TYPE_IND)
476 {
477 switch(pack->info_id)
478 {
479 // <uint8> State
480 case MBTK_INFO_ID_IND_NET_STATE_CHANGE:
481 case MBTK_INFO_ID_IND_CALL_STATE_CHANGE:
482 case MBTK_INFO_ID_IND_SMS_STATE_CHANGE:
483 case MBTK_INFO_ID_IND_RADIO_STATE_CHANGE:
484 case MBTK_INFO_ID_IND_SIM_STATE_CHANGE:
485 {
486 pack->data_len = (uint16)data_len;
487 pack->data = (uint8*)memdup(data, pack->data_len);
488 break;
489 }
490 default:
491 {
492 LOG("Unknown IND : %s", id2str(pack->info_id));
493 break;
494 }
495 }
496 }
497 //else if(pack->info_id % 2 == 1) // REQ (Set Data)
498 else if(info_type == MBTK_INFO_TYPE_REQ || info_type == MBTK_INFO_TYPE_RSP) // REQ or RSP
499 {
500 switch(pack->info_id)
501 {
502 case MBTK_INFO_ID_DEV_VOLTE_REQ: // <uint8> 0:Close 1:Open
503 case MBTK_INFO_ID_DEV_VOLTE_RSP:
504 case MBTK_INFO_ID_SIM_STATE_REQ: // <uint8> 0:NOT_EXIST 1:READY ...
505 case MBTK_INFO_ID_SIM_STATE_RSP:
506 case MBTK_INFO_ID_NET_RADIO_REQ: // <uint8> 0:OFF 1:ON
507 case MBTK_INFO_ID_NET_RADIO_RSP:
508 case MBTK_INFO_ID_NET_BAND_REQ: // mbtk_band_info_t
509 case MBTK_INFO_ID_NET_BAND_RSP:
510 case MBTK_INFO_ID_NET_CELL_REQ: // Lock net/cell/frequency
511 case MBTK_INFO_ID_NET_CELL_RSP:
512 case MBTK_INFO_ID_DEV_IMEI_REQ: // <string> SN
513 case MBTK_INFO_ID_DEV_IMEI_RSP:
514 case MBTK_INFO_ID_DEV_SN_REQ: // <string> SN
515 case MBTK_INFO_ID_DEV_SN_RSP:
516 case MBTK_INFO_ID_DEV_MEID_REQ: // <string> MEID
517 case MBTK_INFO_ID_DEV_MEID_RSP:
518 case MBTK_INFO_ID_DEV_VERSION_REQ: // <string> VERSION
519 case MBTK_INFO_ID_DEV_VERSION_RSP:
520 case MBTK_INFO_ID_DEV_TEMP_REQ: // <string> Temperature
521 case MBTK_INFO_ID_DEV_TEMP_RSP:
522 case MBTK_INFO_ID_SIM_PIN_REQ: // <string> PIN
523 case MBTK_INFO_ID_SIM_PIN_RSP:
524 case MBTK_INFO_ID_SIM_PUK_REQ: // <string> PUK
525 case MBTK_INFO_ID_SIM_PUK_RSP:
526 case MBTK_INFO_ID_SIM_IMSI_REQ: // <string> IMSI
527 case MBTK_INFO_ID_SIM_IMSI_RSP:
528 case MBTK_INFO_ID_SIM_ICCID_REQ: // <string> ICCID
529 case MBTK_INFO_ID_SIM_ICCID_RSP:
530 case MBTK_INFO_ID_NET_APN_REQ: // <string> cmnet/ctnet/3gnet/...
531 case MBTK_INFO_ID_NET_APN_RSP:
532 case MBTK_INFO_ID_NET_SEL_MODE_REQ: // mbtk_net_info_t
533 case MBTK_INFO_ID_NET_SEL_MODE_RSP:
534 case MBTK_INFO_ID_NET_AVAILABLE_REQ: // mbtk_net_info_t[]
535 case MBTK_INFO_ID_NET_AVAILABLE_RSP:
536 {
537 pack->data_len = (uint16)data_len;
538#if 1
539 pack->data = (uint8*)memdup(data, pack->data_len);
540#else
541 LOG("%d -> %d", data_len, pack->data_len);
542 log_hex("pack1", pack, sizeof(mbtk_info_pack_t));
543 #if 0
544 pack->data = (uint8*)memdup(data, pack->data_len);
545 #else
546
547 LOG("1 pack->%p,data->%p", pack, pack->data);
548 pack->data = (uint8*)calloc(pack->data_len, sizeof(uint8));
549 LOG("2 pack->%p,data->%p", pack, pack->data);
550
551 memcpy(pack->data, data, data_len);
552 #endif
553
554 LOG("data_len - %d", pack->data_len);
555 log_hex("pack2", pack, sizeof(mbtk_info_pack_t));
556#endif
557 break;
558 }
559 case MBTK_INFO_ID_NET_SIGNAL_REQ: // <sint16>[4] rssi,rscp,rsrp,snr
560 case MBTK_INFO_ID_NET_SIGNAL_RSP:
561 {
562 // const mbtk_net_signal_t* signal = (const mbtk_net_signal_t*)data;
563 pack->data_len = (uint16)sizeof(mbtk_net_signal_t);
564 pack->data = (uint8*)memdup(data, pack->data_len);
565 break;
566 }
567 case MBTK_INFO_ID_NET_IPV4_DNS_REQ: // <uint32>[2] Preferred DNS,Alternate DNS
568 case MBTK_INFO_ID_NET_IPV4_DNS_RSP:
569 {
570 // const mbtk_net_dns_ipv4_t* dns_ipv4 = (const mbtk_net_dns_ipv4_t*)data;
571 pack->data_len = (uint16)sizeof(mbtk_net_dns_ipv4_t);
572 pack->data = (uint8*)memdup(data, pack->data_len);
573 break;
574 }
575 case MBTK_INFO_ID_NET_IPV6_DNS_REQ: // <uint32>[8] Preferred DNS,Alternate DNS
576 case MBTK_INFO_ID_NET_IPV6_DNS_RSP:
577 {
578 // const mbtk_net_dns_ipv6_t* dns_ipv6 = (const mbtk_net_dns_ipv6_t*)data;
579 pack->data_len = (uint16)sizeof(mbtk_net_dns_ipv6_t);
580 pack->data = (uint8*)memdup(data, pack->data_len);
581 break;
582 }
583 case MBTK_INFO_ID_NET_IPV4_REQ: // <uint32> IPv4
584 case MBTK_INFO_ID_NET_IPV4_RSP:
585 {
586 pack->data_len = (uint16)sizeof(uint32);
587 pack->data = (uint8*)memdup(data, pack->data_len);
588 break;
589 }
590 case MBTK_INFO_ID_NET_IPV6_REQ: // <uint32>[4] IPv6
591 case MBTK_INFO_ID_NET_IPV6_RSP:
592 {
593 pack->data_len = (uint16)(sizeof(uint32) * 4);
594 pack->data = (uint8*)memdup(data, pack->data_len);
595 break;
596 }
597 case MBTK_INFO_ID_NET_LOCAL_REQ: // <uint16>[2] tag,earfcn
598 case MBTK_INFO_ID_NET_LOCAL_RSP:
599 {
600 pack->data_len = (uint16)sizeof(mbtk_local_info_t);
601 pack->data = (uint8*)memdup(data, pack->data_len);
602 break;
603 }
604#if 0
605 case MBTK_INFO_ID_NET_SEL_MODE_REQ:
606 case MBTK_INFO_ID_NET_SEL_MODE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)
607 {
608 const mbtk_net_info_t* net = (const mbtk_net_info_t*)data;
609 pack->data_len = sizeof(uint8) + sizeof(uint8) + sizeof(uint32);
610 pack->data = (uint8*)malloc(pack->data_len);
611 if(pack->data == NULL) {
612 LOG("malloc() fail.");
613 return -1;
614 }
615
616 pack->data[0] = net->net_sel_mode;
617 pack->data[1] = net->net_type;
618 uint32_2_byte((uint32)atoi((char*)net->plmn), pack->data + 2,false);
619 break;
620 }
621#endif
622#if 0
623 case MBTK_INFO_ID_NET_AVAILABLE_REQ:
624 case MBTK_INFO_ID_NET_AVAILABLE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)...sel_mode(uint8)type(uint8)plmn(uint32)
625 {
626 const mbtk_net_array_info_t* nets = (const mbtk_net_array_info_t*)data;
627 mbtk_net_info_t *net = NULL;
628 //LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP set");
629 //sleep(1);
630 list_first(nets->net_list);
631 pack->data_len = nets->count * sizeof(mbtk_net_info_t);
632 if(pack->data_len > 0) {
633 int i = 0;
634 pack->data = (uint8*)malloc(pack->data_len);
635 if(pack->data == NULL) {
636 LOG("malloc() fail.");
637 return -1;
638 }
639 memset(pack->data, 0, pack->data_len);
640
641 while ((net = (mbtk_net_info_t*) list_next(nets->net_list)))
642 {
643 #if 0
644 memcpy(pack->data + i, net, sizeof(mbtk_net_info_t));
645 i += sizeof(mbtk_net_info_t);
646 #else
647 pack->data[i++] = net->net_sel_mode;
648 pack->data[i++] = net->net_type;
649 //uint32_2_byte((uint32)atoi((char*)net->plmn), pack->data + i,false);
650 uint32_2_byte(net->plmn, pack->data + i,false);
651 i += sizeof(uint32);
652 #endif
653 }
654 }
655 break;
656 }
657#endif
658 default:
659 {
660 LOG("Unknown REQ/RSP : %s", id2str(pack->info_id));
661 break;
662 }
663 }
664 }
665 else
666 {
667 LOG("Unknown info : %s", id2str(pack->info_id));
668 return -1;
669 }
670 return 0;
671}
672
673void* mbtk_info_pack_data_get(mbtk_info_pack_t *pack, int *data_len)
674{
675 if(pack == NULL || pack->data_len == 0 || pack->data == NULL)
676 {
677 LOG("Packet is NULL.");
678 return NULL;
679 }
680
681 mbtk_info_type_enum info_type = mbtk_info_type_get(pack->info_id);
682 // IND
683 if(info_type == MBTK_INFO_TYPE_IND)
684 {
685 switch(pack->info_id)
686 {
687 // <uint8> State
688 case MBTK_INFO_ID_IND_NET_STATE_CHANGE:
689 case MBTK_INFO_ID_IND_CALL_STATE_CHANGE:
690 case MBTK_INFO_ID_IND_SMS_STATE_CHANGE:
691 case MBTK_INFO_ID_IND_RADIO_STATE_CHANGE:
692 case MBTK_INFO_ID_IND_SIM_STATE_CHANGE:
693 {
694 return pack->data;
695 }
696 default:
697 {
698 LOG("Unknown IND : %s", id2str(pack->info_id));
699 break;
700 }
701 }
702 }
703 //else if(pack->info_id % 2 == 1) // REQ (Set Data)
704 else if(info_type == MBTK_INFO_TYPE_REQ || info_type == MBTK_INFO_TYPE_RSP) // REQ or RSP
705 {
706 switch(pack->info_id)
707 {
708 case MBTK_INFO_ID_DEV_VOLTE_REQ: // <uint8> 0:Close 1:Open
709 case MBTK_INFO_ID_DEV_VOLTE_RSP:
710 case MBTK_INFO_ID_SIM_STATE_REQ: // <uint8> 0:NOT_EXIST 1:READY ...
711 case MBTK_INFO_ID_SIM_STATE_RSP:
712 case MBTK_INFO_ID_NET_RADIO_REQ: // <uint8> 0:OFF 1:ON
713 case MBTK_INFO_ID_NET_RADIO_RSP:
714 case MBTK_INFO_ID_DEV_IMEI_REQ: // <string> SN
715 case MBTK_INFO_ID_DEV_IMEI_RSP:
716 case MBTK_INFO_ID_DEV_SN_REQ: // <string> SN
717 case MBTK_INFO_ID_DEV_SN_RSP:
718 case MBTK_INFO_ID_DEV_MEID_REQ: // <string> MEID
719 case MBTK_INFO_ID_DEV_MEID_RSP:
720 case MBTK_INFO_ID_DEV_VERSION_REQ: // <string> VERSION
721 case MBTK_INFO_ID_DEV_VERSION_RSP:
722 case MBTK_INFO_ID_DEV_TEMP_REQ: // <string> Temperature
723 case MBTK_INFO_ID_DEV_TEMP_RSP:
724 case MBTK_INFO_ID_SIM_PIN_REQ: // <string> PIN
725 case MBTK_INFO_ID_SIM_PIN_RSP:
726 case MBTK_INFO_ID_SIM_PUK_REQ: // <string> PUK
727 case MBTK_INFO_ID_SIM_PUK_RSP:
728 case MBTK_INFO_ID_SIM_IMSI_REQ: // <string> IMSI
729 case MBTK_INFO_ID_SIM_IMSI_RSP:
730 case MBTK_INFO_ID_SIM_ICCID_REQ: // <string> ICCID
731 case MBTK_INFO_ID_SIM_ICCID_RSP:
732 case MBTK_INFO_ID_NET_APN_REQ: // <string> cmnet/ctnet/3gnet/...
733 case MBTK_INFO_ID_NET_APN_RSP:
734 case MBTK_INFO_ID_NET_BAND_REQ: // mbtk_band_info_t
735 case MBTK_INFO_ID_NET_BAND_RSP:
736 case MBTK_INFO_ID_NET_CELL_REQ: // Lock net/cell/frequency
737 case MBTK_INFO_ID_NET_CELL_RSP:
738 case MBTK_INFO_ID_NET_SEL_MODE_REQ: // mbtk_net_info_t
739 case MBTK_INFO_ID_NET_SEL_MODE_RSP:
740 case MBTK_INFO_ID_NET_AVAILABLE_REQ: // mbtk_net_info_t[]
741 case MBTK_INFO_ID_NET_AVAILABLE_RSP:
742 {
743 return pack->data;
744 }
745 case MBTK_INFO_ID_NET_SIGNAL_REQ: // <sint16>[4] rssi,rscp,rsrp,snr
746 case MBTK_INFO_ID_NET_SIGNAL_RSP:
747 {
748 mbtk_net_signal_t* signal = (mbtk_net_signal_t*)malloc(sizeof(mbtk_net_signal_t));
749 if(!signal)
750 {
751 LOG("malloc() error[%d]", errno);
752 return NULL;
753 }
754
755 signal->rssi = (sint16)byte_2_uint16(pack->data, false);
756 signal->rscp = (sint16)byte_2_uint16(pack->data + sizeof(uint16), false);
757 signal->rsrp = (sint16)byte_2_uint16(pack->data + sizeof(uint16) * 2, false);
758 signal->snr = (sint16)byte_2_uint16(pack->data + sizeof(uint16) * 3, false);
759 return signal;
760 }
761 case MBTK_INFO_ID_NET_IPV4_DNS_REQ: // <uint32>[2] Preferred DNS,Alternate DNS
762 case MBTK_INFO_ID_NET_IPV4_DNS_RSP:
763 {
764 mbtk_net_dns_ipv4_t* dns_ipv4 = (mbtk_net_dns_ipv4_t*)malloc(sizeof(mbtk_net_dns_ipv4_t));
765 if(!dns_ipv4)
766 {
767 LOG("malloc() error[%d]", errno);
768 return NULL;
769 }
770
771 dns_ipv4->preferred_dns = byte_2_uint32(pack->data, false);
772 dns_ipv4->alternate_dns = byte_2_uint32(pack->data + sizeof(uint32), false);
773 return dns_ipv4;
774 }
775 case MBTK_INFO_ID_NET_IPV6_DNS_REQ: // <uint32>[8] Preferred DNS,Alternate DNS
776 case MBTK_INFO_ID_NET_IPV6_DNS_RSP:
777 {
778 return memdup(pack->data, sizeof(mbtk_net_dns_ipv6_t));
779 }
780 case MBTK_INFO_ID_NET_IPV4_REQ: // <uint32> IPv4
781 case MBTK_INFO_ID_NET_IPV4_RSP:
782 {
783 return memdup(pack->data, sizeof(uint32));
784 break;
785 }
786 case MBTK_INFO_ID_NET_IPV6_REQ: // <uint32>[4] IPv6
787 case MBTK_INFO_ID_NET_IPV6_RSP:
788 {
789 return memdup(pack->data, sizeof(uint32) * 4);
790 break;
791 }
792 case MBTK_INFO_ID_NET_LOCAL_REQ: // <uint16>[2] tag,earfcn
793 case MBTK_INFO_ID_NET_LOCAL_RSP:
794 {
795 mbtk_local_info_t* local = (mbtk_local_info_t*)malloc(sizeof(mbtk_local_info_t));
796 if(!local)
797 {
798 LOG("malloc() error[%d]", errno);
799 return NULL;
800 }
801
802 local->tag = (sint16)byte_2_uint16(pack->data, false);
803 local->earfcn = (sint16)byte_2_uint16(pack->data + sizeof(uint16), false);
804 return local;
805 }
806#if 0
807 case MBTK_INFO_ID_NET_SEL_MODE_REQ:
808 case MBTK_INFO_ID_NET_SEL_MODE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)
809 {
810 mbtk_net_info_t* net = (mbtk_net_info_t*)malloc(sizeof(mbtk_net_info_t));
811 if(!net)
812 {
813 LOG("malloc() error[%d]", errno);
814 return NULL;
815 }
816 memset(net, 0, sizeof(mbtk_net_info_t));
817 net->net_sel_mode = pack->data[0];
818 net->net_type = pack->data[1];
819 //itoa(byte_2_uint32(pack->data + 2, false), net->plmn, 10);
820 sprintf(net->plmn, "%d", byte_2_uint32(pack->data + 2, false));
821
822 return net;
823 }
824#endif
825#if 0
826 case MBTK_INFO_ID_NET_AVAILABLE_REQ:
827 case MBTK_INFO_ID_NET_AVAILABLE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)...sel_mode(uint8)type(uint8)plmn(uint32)
828 {
829 mbtk_net_array_info_t* nets = (mbtk_net_array_info_t*)malloc(sizeof(mbtk_net_array_info_t));
830 if(!nets)
831 {
832 LOG("malloc() error[%d]", errno);
833 return NULL;
834 }
835 nets->count = 0;
836 nets->net_list = list_create(NULL);
837 if(nets->net_list == NULL)
838 {
839 LOG("list_create() fail.");
840 free(nets);
841 return NULL;
842 }
843
844 int i = 0;
845 while(i < pack->data_len) {
846 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 1");
847 sleep(1);
848 mbtk_net_info_t* net = (mbtk_net_info_t*)malloc(sizeof(mbtk_net_info_t));
849 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 2");
850 sleep(1);
851 if(!net)
852 {
853 LOG("malloc() error[%d]", errno);
854 sleep(3);
855 //list_free(nets->net_list);
856 //free(nets);
857 return NULL;
858 }
859 memset(net, 0, sizeof(mbtk_net_info_t));
860
861 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 3");
862 sleep(1);
863#if 1
864 #if 1
865 #if 0
866 memcpy(net, pack->data + i, sizeof(mbtk_net_info_t));
867 i += sizeof(mbtk_net_info_t);
868 #else
869 net->net_sel_mode = pack->data[i++];
870 net->net_type = pack->data[i++];
871 //sprintf(net->plmn, "%d", byte_2_uint32(pack->data + i, false));
872 net->plmn = byte_2_uint32(pack->data + i, false);
873 i += sizeof(uint32);
874 #endif
875 #endif
876
877 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 5");
878 log_hex("NET 2", net, sizeof(mbtk_net_info_t));
879 sleep(1);
880
881 list_add(nets->net_list, net);
882
883#endif
884 LOG("list_add");
885 sleep(1);
886 }
887
888 sleep(10);
889
890 // Data lenght changed.
891 *data_len = sizeof(mbtk_net_array_info_t);
892 return nets;
893 }
894#endif
895 default:
896 {
897 LOG("Unknown REQ/RSP : %s", id2str(pack->info_id));
898 break;
899 }
900 }
901 }
902 else
903 {
904 LOG("Unknown info : %s", id2str(pack->info_id));
905 }
906
907 return NULL;
908}
909#endif
910
911int mbtk_info_pack_send(int fd, mbtk_info_pack_t *pack)
912{
913 if(!pack)
914 {
915 LOG("Packet is NULL.");
916 return -1;
917 }
918 uint8 data[SOCK_MSG_LEN_MAX] = {0};
919 uint8* data_ptr = data + SOCK_PACK_EXTRA_LEN;
920
921 data_ptr += uint16_2_byte(pack->info_id, data_ptr, false);
922 data_ptr += uint16_2_byte(pack->info_err, data_ptr, false);
923 data_ptr += uint16_2_byte(pack->data_len, data_ptr, false);
924 //log_hex("DATA1", data, 40);
925 if(pack->data_len > 0)
926 {
927 memcpy(data_ptr, pack->data, pack->data_len);
928 data_ptr += pack->data_len;
929 //log_hex("DATA2", data, 40);
930 }
931
932 // Set flag and packet length.
933 uint32_2_byte(MBTK_INFO_PACKET_FLAG, data, true);
934 uint16_2_byte(data_ptr - data - SOCK_PACK_EXTRA_LEN, data + sizeof(uint32), false);
935
936 //log_hex("DATA3", data, 40);
937 return sock_write(fd, data, data_ptr - data);
938}
939
940mbtk_info_pack_t** mbtk_info_pack_recv(int fd, bool is_server, mbtk_info_err_enum *err)
941{
942 uint8 msg[SOCK_MSG_LEN_MAX + 1];
943 *err = MBTK_INFO_ERR_SUCCESS;
944 int len = sock_read(fd, msg, SOCK_MSG_LEN_MAX + 1);
945 if(len < SOCK_PACK_LEN_MIN)
946 {
947 if(len > 0)
948 {
949 *err = MBTK_INFO_ERR_FORMAT;
950 LOG("Insufficient packet data.");
951 }
952 return NULL;
953 }
954
955 int pack_count = pack_num_check(msg, len);
956 LOG("Packet number : %d", pack_count);
957 if(pack_count < 1)
958 {
959 *err = MBTK_INFO_ERR_FORMAT;
960 LOG("Packet not found.");
961 return NULL;
962 }
963 uint8 *ptr = msg;
964 mbtk_info_pack_t** packs = (mbtk_info_pack_t**)malloc(sizeof(mbtk_info_pack_t*) * (pack_count + 1));
965 int i = 0;
966 while(i < pack_count)
967 {
968 // TAG
969 if(MBTK_INFO_PACKET_FLAG != byte_2_uint32(ptr, true))
970 {
971 *err = MBTK_INFO_ERR_FORMAT;
972 LOG("Packet TAG error.");
973 goto error;
974 }
975 ptr += sizeof(uint32);
976
977 // Jump packet length.
978 ptr += sizeof(uint16);
979
980 mbtk_info_id_enum info_id = (mbtk_info_id_enum)byte_2_uint16(ptr, false);
981 mbtk_info_type_enum info_type = mbtk_info_type_get(info_id);
982 if(is_server)
983 {
984 // For server,"info_type" must by REQ or IND(Register IND).
985 if(info_type != MBTK_INFO_TYPE_REQ && info_type != MBTK_INFO_TYPE_IND)
986 {
987 *err = MBTK_INFO_ERR_FORMAT;
988 LOG("Packet Type error.");
989 goto error;
990 }
991 }
992 else
993 {
994 // For client,"info_type" must by RSP or IND.
995 if(info_type != MBTK_INFO_TYPE_RSP && info_type != MBTK_INFO_TYPE_IND)
996 {
997 *err = MBTK_INFO_ERR_FORMAT;
998 LOG("Packet Type error.");
999 goto error;
1000 }
1001 }
1002 ptr += sizeof(uint16);
1003
1004 mbtk_info_pack_t* pack = mbtk_info_pack_creat(info_id);
1005 if(pack == NULL)
1006 {
1007 *err = MBTK_INFO_ERR_MEMORY;
1008 LOG("Packet malloc() fail.");
1009 goto error;
1010 }
1011
1012 // "info_err"
1013 pack->info_err = byte_2_uint16(ptr, false);
1014 ptr += sizeof(uint16);
1015
1016 // "data_len"
1017 pack->data_len = byte_2_uint16(ptr, false);
1018 ptr += sizeof(uint16);
1019
1020 if(pack->data_len > 0)
1021 {
1022 pack->data = (uint8*)memdup(ptr, pack->data_len);
1023 ptr += pack->data_len;
1024 }
1025
1026 packs[i++] = pack;
1027 }
1028 packs[i] = NULL;
1029
1030 return packs;
1031
1032error:
1033 LOG("mbtk_info_pack_recv error, will free().");
1034 if(packs)
1035 {
1036 mbtk_info_pack_t** pack_ptr = packs;
1037 while(*pack_ptr)
1038 {
1039 mbtk_info_pack_free(pack_ptr);
1040 pack_ptr++;
1041 }
1042
1043 free(packs);
1044 }
1045 return NULL;
1046}
1047
1048int mbtk_info_pack_free(mbtk_info_pack_t **pack)
1049{
1050 if(pack == NULL || *pack == NULL)
1051 {
1052 LOG("Packet is NULL.");
1053 return -1;
1054 }
1055
1056 // LOG("Free packet : %s", id2str((*pack)->info_id));
1057#if 0
1058 if((*pack)->data)
1059 {
1060 free((*pack)->data);
1061 }
1062#endif
1063 free(*pack);
1064 *pack = NULL;
1065 return 0;
1066}
1067
1068