Gitiles
Code Review Sign In
192.168.1.100 / T108_Public / fca7c4734960fcc35a6a50496e5b870cf3d6e526 / . / mbtk / libmbtk_ril / mbtk_info.c
blob: d7ea54faccfd505e6608518d2e522c8e18c1a08f [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";
r.xiao06db9a12024-04-14 18:51:15 -0700[diff] [blame]284 //ims
285 case MBTK_INFO_ID_NET_IMS_REQ:
286 case MBTK_INFO_ID_NET_IMS_RSP:
287 return "IMS";
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]288 // Call Information
289 case MBTK_INFO_ID_CALL_STATE_REQ:
290 case MBTK_INFO_ID_CALL_STATE_RSP:
291 return "CALL_STATE";
292 // SMS Information
293 case MBTK_INFO_ID_SMS_STATE_REQ:
294 case MBTK_INFO_ID_SMS_STATE_RSP:
295 return "SMS_STATE";
296 // PhoneBook Information
297 case MBTK_INFO_ID_PB_STATE_REQ:
298 case MBTK_INFO_ID_PB_STATE_RSP:
299 return "PB_STATE";
wangyouqiang38e53362024-01-23 10:53:48 +0800[diff] [blame]300 //led
301 case MBTK_INFO_ID_LED_REQ:
302 case MBTK_INFO_ID_LED_RSP:
303 return "LED";
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]304 // IND Information
305 // <uint8> State
306 case MBTK_INFO_ID_IND_NET_STATE_CHANGE:
307 return "IND_NET_STATE";
308 // <uint8> State
309 case MBTK_INFO_ID_IND_CALL_STATE_CHANGE:
310 return "IND_CALL_STATE";
311 // <uint8> State
312 case MBTK_INFO_ID_IND_SMS_STATE_CHANGE:
313 return "IND_SMS_STATE";
314 // <uint8> State
315 case MBTK_INFO_ID_IND_RADIO_STATE_CHANGE:
316 return "IND_RADIO_STATE";
317 // <uint8> State
318 case MBTK_INFO_ID_IND_SIM_STATE_CHANGE:
319 return "IND_SIM_STATE";
320 // <uint8> State
321 case MBTK_INFO_ID_IND_PDP_STATE_CHANGE:
322 return "IND_PDP_STATE";
323 // <uint8> State
324 case MBTK_INFO_ID_IND_SERVER_STATE_CHANGE:
325 return "IND_SERVER_STATE";
r.xiaofca7c472024-04-24 01:00:23 -0700[diff] [blame^]326 // <uint8> State
327 case MBTK_INFO_ID_IND_SIGNAL_STATE_CHANGE:
328 return "IND_SIGNAL_STATE";
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]329 default:
330 {
331 return "UNKNOWN";
332 }
333 }
334}
335
336char* err2str(mbtk_info_err_enum err)
337{
338 switch(err)
339 {
340 case MBTK_INFO_ERR_SUCCESS:
341 return "SUCCESS";
342 case MBTK_INFO_ERR_FORMAT:
343 return "ERR_FORMAT";
344 case MBTK_INFO_ERR_REQ_UNKNOWN:
345 return "ERR_REQ_UNKNOWN";
346 case MBTK_INFO_ERR_REQ_PARAMETER:
347 return "ERR_REQ_PARAMETER";
348 case MBTK_INFO_ERR_UNSUPPORTED:
349 return "ERR_UNSUPPORTED";
350 case MBTK_INFO_ERR_MEMORY:
351 return "ERR_MEMORY";
352 case MBTK_INFO_ERR_IND_FULL:
353 return "ERR_IND_FULL";
354 case MBTK_INFO_ERR_IND_UNKNOWN:
355 return "ERR_IND_UNKNOWN";
356 case MBTK_INFO_ERR_CID_EXIST:
357 return "ERR_CID_EXIS";
358 case MBTK_INFO_ERR_CID_NO_EXIST:
359 return "ERR_CID_NO_EXIST";
360 case MBTK_INFO_ERR_NET_NO_INIT:
wangyouqiang8ebeafe2024-04-15 10:07:44 +0800[diff] [blame]361 return "ERR_CID_NO_NET";
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]362 default:
363 {
364 if(err >= MBTK_INFO_ERR_CME) {
365 return "CME ERROR";
366 }
367
368 return "UNKNOWN";
369 }
370 }
371}
372
373/*
3740 GSM
3751 GSM_COMPACT
3762 UTRAN
3773 GSM_EGPRS
3784 UTRAN_HSDPA
3795 UTRAN_HSUPA
3806 UTRAN_HSDPA_HSUPA
3817 EUTRAN
3828 ECGSM
383*/
384mbtk_net_type_enum mbtk_net_type_get(mbtk_radio_technology_enum radio_tech)
385{
386 switch(radio_tech)
387 {
388 case MBTK_RADIO_TECH_GSM:
389 case MBTK_RADIO_TECH_GSM_COMPACT:
390 case MBTK_RADIO_TECH_GSM_EGPRS:
391 case MBTK_RADIO_TECH_UTRAN_HSPA:
392 {
393 return MBTK_NET_TYPE_GSM;
394 }
395 case MBTK_RADIO_TECH_UTRAN:
396 case MBTK_RADIO_TECH_UTRAN_HSDPA:
397 case MBTK_RADIO_TECH_UTRAN_HSUPA:
398 case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
399 {
400 return MBTK_NET_TYPE_UMTS;
401 }
402 case MBTK_RADIO_TECH_E_UTRAN:
403 {
404 return MBTK_NET_TYPE_LTE;
405 }
406 default:
407 {
408 return MBTK_NET_TYPE_UNKNOWN;
409 }
410 }
411}
412
413
414#if 0
415void net_list_free(void *data)
416{
417 if (data)
418 {
419 mbtk_net_info_t *info = (mbtk_net_info_t*) data;
420 LOG("Free net [%s].", info->plmn);
421 free(info);
422 }
423}
424#endif
425
426mbtk_info_type_enum mbtk_info_type_get(int info_id)
427{
428 if(info_id > MBTK_INFO_ID_IND_BEGIN && info_id < MBTK_INFO_ID_IND_END)
429 {
430 return MBTK_INFO_TYPE_IND;
431 }
432 else if(info_id == MBTK_INFO_ID_DEV_BEGIN ||
433 info_id == MBTK_INFO_ID_DEV_END ||
434 info_id == MBTK_INFO_ID_SIM_BEGIN ||
435 info_id == MBTK_INFO_ID_SIM_END ||
436 info_id == MBTK_INFO_ID_NET_BEGIN ||
437 info_id == MBTK_INFO_ID_NET_END ||
438 info_id == MBTK_INFO_ID_CALL_BEGIN ||
439 info_id == MBTK_INFO_ID_CALL_END ||
440 info_id == MBTK_INFO_ID_SMS_BEGIN ||
441 info_id == MBTK_INFO_ID_SMS_END ||
442 info_id == MBTK_INFO_ID_PB_BEGIN ||
443 info_id == MBTK_INFO_ID_PB_END ||
wangyouqiang38e53362024-01-23 10:53:48 +0800[diff] [blame]444 info_id == MBTK_INFO_ID_LED_BEGIN ||
445 info_id == MBTK_INFO_ID_LED_END ||
r.xiaocfd7c682024-01-22 03:59:46 -0800[diff] [blame]446 info_id == MBTK_INFO_ID_WAKEUP_STA_BEGIN ||
447 info_id == MBTK_INFO_ID_WAKEUP_STA_END ||
448 info_id == MBTK_INFO_ID_OOS_STA_BEGIN ||
449 info_id == MBTK_INFO_ID_OOS_STA_END ||
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]450 info_id == MBTK_INFO_ID_REQ_UNKNOWN)
451 {
452 return MBTK_INFO_TYPE_UNKNOWN;
453 }
454 else if(info_id % 2 == 1)
455 {
456 return MBTK_INFO_TYPE_REQ;
457 }
458 else
459 {
460 return MBTK_INFO_TYPE_RSP;
461 }
462}
463
464mbtk_info_pack_t* mbtk_info_pack_creat(int info_id)
465{
466 mbtk_info_pack_t *pack = (mbtk_info_pack_t *)malloc(sizeof(mbtk_info_pack_t));
467 if(!pack)
468 {
469 LOG("malloc() error[%d]", errno);
470 return NULL;
471 }
472
473 pack->info_id = (uint16)info_id;
474 pack->info_err = (uint16)0;
475 pack->data_len = (uint16)0;
476 pack->data = NULL;
477
478 return pack;
479}
480
481#if 0
482int mbtk_info_pack_data_set(mbtk_info_pack_t *pack, const void *data, int data_len)
483{
484 if(!pack)
485 {
486 LOG("Packet is NULL.");
487 return -1;
488 }
489
490 mbtk_info_type_enum info_type = mbtk_info_type_get(pack->info_id);
491 // IND
492 if(info_type == MBTK_INFO_TYPE_IND)
493 {
494 switch(pack->info_id)
495 {
496 // <uint8> State
497 case MBTK_INFO_ID_IND_NET_STATE_CHANGE:
498 case MBTK_INFO_ID_IND_CALL_STATE_CHANGE:
499 case MBTK_INFO_ID_IND_SMS_STATE_CHANGE:
500 case MBTK_INFO_ID_IND_RADIO_STATE_CHANGE:
501 case MBTK_INFO_ID_IND_SIM_STATE_CHANGE:
502 {
503 pack->data_len = (uint16)data_len;
504 pack->data = (uint8*)memdup(data, pack->data_len);
505 break;
506 }
507 default:
508 {
509 LOG("Unknown IND : %s", id2str(pack->info_id));
510 break;
511 }
512 }
513 }
514 //else if(pack->info_id % 2 == 1) // REQ (Set Data)
515 else if(info_type == MBTK_INFO_TYPE_REQ || info_type == MBTK_INFO_TYPE_RSP) // REQ or RSP
516 {
517 switch(pack->info_id)
518 {
519 case MBTK_INFO_ID_DEV_VOLTE_REQ: // <uint8> 0:Close 1:Open
520 case MBTK_INFO_ID_DEV_VOLTE_RSP:
521 case MBTK_INFO_ID_SIM_STATE_REQ: // <uint8> 0:NOT_EXIST 1:READY ...
522 case MBTK_INFO_ID_SIM_STATE_RSP:
523 case MBTK_INFO_ID_NET_RADIO_REQ: // <uint8> 0:OFF 1:ON
524 case MBTK_INFO_ID_NET_RADIO_RSP:
525 case MBTK_INFO_ID_NET_BAND_REQ: // mbtk_band_info_t
526 case MBTK_INFO_ID_NET_BAND_RSP:
527 case MBTK_INFO_ID_NET_CELL_REQ: // Lock net/cell/frequency
528 case MBTK_INFO_ID_NET_CELL_RSP:
529 case MBTK_INFO_ID_DEV_IMEI_REQ: // <string> SN
530 case MBTK_INFO_ID_DEV_IMEI_RSP:
531 case MBTK_INFO_ID_DEV_SN_REQ: // <string> SN
532 case MBTK_INFO_ID_DEV_SN_RSP:
533 case MBTK_INFO_ID_DEV_MEID_REQ: // <string> MEID
534 case MBTK_INFO_ID_DEV_MEID_RSP:
535 case MBTK_INFO_ID_DEV_VERSION_REQ: // <string> VERSION
536 case MBTK_INFO_ID_DEV_VERSION_RSP:
537 case MBTK_INFO_ID_DEV_TEMP_REQ: // <string> Temperature
538 case MBTK_INFO_ID_DEV_TEMP_RSP:
539 case MBTK_INFO_ID_SIM_PIN_REQ: // <string> PIN
540 case MBTK_INFO_ID_SIM_PIN_RSP:
541 case MBTK_INFO_ID_SIM_PUK_REQ: // <string> PUK
542 case MBTK_INFO_ID_SIM_PUK_RSP:
543 case MBTK_INFO_ID_SIM_IMSI_REQ: // <string> IMSI
544 case MBTK_INFO_ID_SIM_IMSI_RSP:
545 case MBTK_INFO_ID_SIM_ICCID_REQ: // <string> ICCID
546 case MBTK_INFO_ID_SIM_ICCID_RSP:
547 case MBTK_INFO_ID_NET_APN_REQ: // <string> cmnet/ctnet/3gnet/...
548 case MBTK_INFO_ID_NET_APN_RSP:
549 case MBTK_INFO_ID_NET_SEL_MODE_REQ: // mbtk_net_info_t
550 case MBTK_INFO_ID_NET_SEL_MODE_RSP:
551 case MBTK_INFO_ID_NET_AVAILABLE_REQ: // mbtk_net_info_t[]
552 case MBTK_INFO_ID_NET_AVAILABLE_RSP:
553 {
554 pack->data_len = (uint16)data_len;
555#if 1
556 pack->data = (uint8*)memdup(data, pack->data_len);
557#else
558 LOG("%d -> %d", data_len, pack->data_len);
559 log_hex("pack1", pack, sizeof(mbtk_info_pack_t));
560 #if 0
561 pack->data = (uint8*)memdup(data, pack->data_len);
562 #else
563
564 LOG("1 pack->%p,data->%p", pack, pack->data);
565 pack->data = (uint8*)calloc(pack->data_len, sizeof(uint8));
566 LOG("2 pack->%p,data->%p", pack, pack->data);
567
568 memcpy(pack->data, data, data_len);
569 #endif
570
571 LOG("data_len - %d", pack->data_len);
572 log_hex("pack2", pack, sizeof(mbtk_info_pack_t));
573#endif
574 break;
575 }
576 case MBTK_INFO_ID_NET_SIGNAL_REQ: // <sint16>[4] rssi,rscp,rsrp,snr
577 case MBTK_INFO_ID_NET_SIGNAL_RSP:
578 {
579 // const mbtk_net_signal_t* signal = (const mbtk_net_signal_t*)data;
580 pack->data_len = (uint16)sizeof(mbtk_net_signal_t);
581 pack->data = (uint8*)memdup(data, pack->data_len);
582 break;
583 }
584 case MBTK_INFO_ID_NET_IPV4_DNS_REQ: // <uint32>[2] Preferred DNS,Alternate DNS
585 case MBTK_INFO_ID_NET_IPV4_DNS_RSP:
586 {
587 // const mbtk_net_dns_ipv4_t* dns_ipv4 = (const mbtk_net_dns_ipv4_t*)data;
588 pack->data_len = (uint16)sizeof(mbtk_net_dns_ipv4_t);
589 pack->data = (uint8*)memdup(data, pack->data_len);
590 break;
591 }
592 case MBTK_INFO_ID_NET_IPV6_DNS_REQ: // <uint32>[8] Preferred DNS,Alternate DNS
593 case MBTK_INFO_ID_NET_IPV6_DNS_RSP:
594 {
595 // const mbtk_net_dns_ipv6_t* dns_ipv6 = (const mbtk_net_dns_ipv6_t*)data;
596 pack->data_len = (uint16)sizeof(mbtk_net_dns_ipv6_t);
597 pack->data = (uint8*)memdup(data, pack->data_len);
598 break;
599 }
600 case MBTK_INFO_ID_NET_IPV4_REQ: // <uint32> IPv4
601 case MBTK_INFO_ID_NET_IPV4_RSP:
602 {
603 pack->data_len = (uint16)sizeof(uint32);
604 pack->data = (uint8*)memdup(data, pack->data_len);
605 break;
606 }
607 case MBTK_INFO_ID_NET_IPV6_REQ: // <uint32>[4] IPv6
608 case MBTK_INFO_ID_NET_IPV6_RSP:
609 {
610 pack->data_len = (uint16)(sizeof(uint32) * 4);
611 pack->data = (uint8*)memdup(data, pack->data_len);
612 break;
613 }
614 case MBTK_INFO_ID_NET_LOCAL_REQ: // <uint16>[2] tag,earfcn
615 case MBTK_INFO_ID_NET_LOCAL_RSP:
616 {
617 pack->data_len = (uint16)sizeof(mbtk_local_info_t);
618 pack->data = (uint8*)memdup(data, pack->data_len);
619 break;
620 }
621#if 0
622 case MBTK_INFO_ID_NET_SEL_MODE_REQ:
623 case MBTK_INFO_ID_NET_SEL_MODE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)
624 {
625 const mbtk_net_info_t* net = (const mbtk_net_info_t*)data;
626 pack->data_len = sizeof(uint8) + sizeof(uint8) + sizeof(uint32);
627 pack->data = (uint8*)malloc(pack->data_len);
628 if(pack->data == NULL) {
629 LOG("malloc() fail.");
630 return -1;
631 }
632
633 pack->data[0] = net->net_sel_mode;
634 pack->data[1] = net->net_type;
635 uint32_2_byte((uint32)atoi((char*)net->plmn), pack->data + 2,false);
636 break;
637 }
638#endif
639#if 0
640 case MBTK_INFO_ID_NET_AVAILABLE_REQ:
641 case MBTK_INFO_ID_NET_AVAILABLE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)...sel_mode(uint8)type(uint8)plmn(uint32)
642 {
643 const mbtk_net_array_info_t* nets = (const mbtk_net_array_info_t*)data;
644 mbtk_net_info_t *net = NULL;
645 //LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP set");
646 //sleep(1);
647 list_first(nets->net_list);
648 pack->data_len = nets->count * sizeof(mbtk_net_info_t);
649 if(pack->data_len > 0) {
650 int i = 0;
651 pack->data = (uint8*)malloc(pack->data_len);
652 if(pack->data == NULL) {
653 LOG("malloc() fail.");
654 return -1;
655 }
656 memset(pack->data, 0, pack->data_len);
657
658 while ((net = (mbtk_net_info_t*) list_next(nets->net_list)))
659 {
660 #if 0
661 memcpy(pack->data + i, net, sizeof(mbtk_net_info_t));
662 i += sizeof(mbtk_net_info_t);
663 #else
664 pack->data[i++] = net->net_sel_mode;
665 pack->data[i++] = net->net_type;
666 //uint32_2_byte((uint32)atoi((char*)net->plmn), pack->data + i,false);
667 uint32_2_byte(net->plmn, pack->data + i,false);
668 i += sizeof(uint32);
669 #endif
670 }
671 }
672 break;
673 }
674#endif
675 default:
676 {
677 LOG("Unknown REQ/RSP : %s", id2str(pack->info_id));
678 break;
679 }
680 }
681 }
682 else
683 {
684 LOG("Unknown info : %s", id2str(pack->info_id));
685 return -1;
686 }
687 return 0;
688}
689
690void* mbtk_info_pack_data_get(mbtk_info_pack_t *pack, int *data_len)
691{
692 if(pack == NULL || pack->data_len == 0 || pack->data == NULL)
693 {
694 LOG("Packet is NULL.");
695 return NULL;
696 }
697
698 mbtk_info_type_enum info_type = mbtk_info_type_get(pack->info_id);
699 // IND
700 if(info_type == MBTK_INFO_TYPE_IND)
701 {
702 switch(pack->info_id)
703 {
704 // <uint8> State
705 case MBTK_INFO_ID_IND_NET_STATE_CHANGE:
706 case MBTK_INFO_ID_IND_CALL_STATE_CHANGE:
707 case MBTK_INFO_ID_IND_SMS_STATE_CHANGE:
708 case MBTK_INFO_ID_IND_RADIO_STATE_CHANGE:
709 case MBTK_INFO_ID_IND_SIM_STATE_CHANGE:
710 {
711 return pack->data;
712 }
713 default:
714 {
715 LOG("Unknown IND : %s", id2str(pack->info_id));
716 break;
717 }
718 }
719 }
720 //else if(pack->info_id % 2 == 1) // REQ (Set Data)
721 else if(info_type == MBTK_INFO_TYPE_REQ || info_type == MBTK_INFO_TYPE_RSP) // REQ or RSP
722 {
723 switch(pack->info_id)
724 {
725 case MBTK_INFO_ID_DEV_VOLTE_REQ: // <uint8> 0:Close 1:Open
726 case MBTK_INFO_ID_DEV_VOLTE_RSP:
727 case MBTK_INFO_ID_SIM_STATE_REQ: // <uint8> 0:NOT_EXIST 1:READY ...
728 case MBTK_INFO_ID_SIM_STATE_RSP:
729 case MBTK_INFO_ID_NET_RADIO_REQ: // <uint8> 0:OFF 1:ON
730 case MBTK_INFO_ID_NET_RADIO_RSP:
731 case MBTK_INFO_ID_DEV_IMEI_REQ: // <string> SN
732 case MBTK_INFO_ID_DEV_IMEI_RSP:
733 case MBTK_INFO_ID_DEV_SN_REQ: // <string> SN
734 case MBTK_INFO_ID_DEV_SN_RSP:
735 case MBTK_INFO_ID_DEV_MEID_REQ: // <string> MEID
736 case MBTK_INFO_ID_DEV_MEID_RSP:
737 case MBTK_INFO_ID_DEV_VERSION_REQ: // <string> VERSION
738 case MBTK_INFO_ID_DEV_VERSION_RSP:
739 case MBTK_INFO_ID_DEV_TEMP_REQ: // <string> Temperature
740 case MBTK_INFO_ID_DEV_TEMP_RSP:
741 case MBTK_INFO_ID_SIM_PIN_REQ: // <string> PIN
742 case MBTK_INFO_ID_SIM_PIN_RSP:
743 case MBTK_INFO_ID_SIM_PUK_REQ: // <string> PUK
744 case MBTK_INFO_ID_SIM_PUK_RSP:
745 case MBTK_INFO_ID_SIM_IMSI_REQ: // <string> IMSI
746 case MBTK_INFO_ID_SIM_IMSI_RSP:
747 case MBTK_INFO_ID_SIM_ICCID_REQ: // <string> ICCID
748 case MBTK_INFO_ID_SIM_ICCID_RSP:
749 case MBTK_INFO_ID_NET_APN_REQ: // <string> cmnet/ctnet/3gnet/...
750 case MBTK_INFO_ID_NET_APN_RSP:
751 case MBTK_INFO_ID_NET_BAND_REQ: // mbtk_band_info_t
752 case MBTK_INFO_ID_NET_BAND_RSP:
753 case MBTK_INFO_ID_NET_CELL_REQ: // Lock net/cell/frequency
754 case MBTK_INFO_ID_NET_CELL_RSP:
755 case MBTK_INFO_ID_NET_SEL_MODE_REQ: // mbtk_net_info_t
756 case MBTK_INFO_ID_NET_SEL_MODE_RSP:
757 case MBTK_INFO_ID_NET_AVAILABLE_REQ: // mbtk_net_info_t[]
758 case MBTK_INFO_ID_NET_AVAILABLE_RSP:
759 {
760 return pack->data;
761 }
762 case MBTK_INFO_ID_NET_SIGNAL_REQ: // <sint16>[4] rssi,rscp,rsrp,snr
763 case MBTK_INFO_ID_NET_SIGNAL_RSP:
764 {
765 mbtk_net_signal_t* signal = (mbtk_net_signal_t*)malloc(sizeof(mbtk_net_signal_t));
766 if(!signal)
767 {
768 LOG("malloc() error[%d]", errno);
769 return NULL;
770 }
771
772 signal->rssi = (sint16)byte_2_uint16(pack->data, false);
773 signal->rscp = (sint16)byte_2_uint16(pack->data + sizeof(uint16), false);
774 signal->rsrp = (sint16)byte_2_uint16(pack->data + sizeof(uint16) * 2, false);
775 signal->snr = (sint16)byte_2_uint16(pack->data + sizeof(uint16) * 3, false);
776 return signal;
777 }
778 case MBTK_INFO_ID_NET_IPV4_DNS_REQ: // <uint32>[2] Preferred DNS,Alternate DNS
779 case MBTK_INFO_ID_NET_IPV4_DNS_RSP:
780 {
781 mbtk_net_dns_ipv4_t* dns_ipv4 = (mbtk_net_dns_ipv4_t*)malloc(sizeof(mbtk_net_dns_ipv4_t));
782 if(!dns_ipv4)
783 {
784 LOG("malloc() error[%d]", errno);
785 return NULL;
786 }
787
788 dns_ipv4->preferred_dns = byte_2_uint32(pack->data, false);
789 dns_ipv4->alternate_dns = byte_2_uint32(pack->data + sizeof(uint32), false);
790 return dns_ipv4;
791 }
792 case MBTK_INFO_ID_NET_IPV6_DNS_REQ: // <uint32>[8] Preferred DNS,Alternate DNS
793 case MBTK_INFO_ID_NET_IPV6_DNS_RSP:
794 {
795 return memdup(pack->data, sizeof(mbtk_net_dns_ipv6_t));
796 }
797 case MBTK_INFO_ID_NET_IPV4_REQ: // <uint32> IPv4
798 case MBTK_INFO_ID_NET_IPV4_RSP:
799 {
800 return memdup(pack->data, sizeof(uint32));
801 break;
802 }
803 case MBTK_INFO_ID_NET_IPV6_REQ: // <uint32>[4] IPv6
804 case MBTK_INFO_ID_NET_IPV6_RSP:
805 {
806 return memdup(pack->data, sizeof(uint32) * 4);
807 break;
808 }
809 case MBTK_INFO_ID_NET_LOCAL_REQ: // <uint16>[2] tag,earfcn
810 case MBTK_INFO_ID_NET_LOCAL_RSP:
811 {
812 mbtk_local_info_t* local = (mbtk_local_info_t*)malloc(sizeof(mbtk_local_info_t));
813 if(!local)
814 {
815 LOG("malloc() error[%d]", errno);
816 return NULL;
817 }
818
819 local->tag = (sint16)byte_2_uint16(pack->data, false);
820 local->earfcn = (sint16)byte_2_uint16(pack->data + sizeof(uint16), false);
821 return local;
822 }
823#if 0
824 case MBTK_INFO_ID_NET_SEL_MODE_REQ:
825 case MBTK_INFO_ID_NET_SEL_MODE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)
826 {
827 mbtk_net_info_t* net = (mbtk_net_info_t*)malloc(sizeof(mbtk_net_info_t));
828 if(!net)
829 {
830 LOG("malloc() error[%d]", errno);
831 return NULL;
832 }
833 memset(net, 0, sizeof(mbtk_net_info_t));
834 net->net_sel_mode = pack->data[0];
835 net->net_type = pack->data[1];
836 //itoa(byte_2_uint32(pack->data + 2, false), net->plmn, 10);
837 sprintf(net->plmn, "%d", byte_2_uint32(pack->data + 2, false));
838
839 return net;
840 }
841#endif
842#if 0
843 case MBTK_INFO_ID_NET_AVAILABLE_REQ:
844 case MBTK_INFO_ID_NET_AVAILABLE_RSP: // sel_mode(uint8)type(uint8)plmn(uint32)...sel_mode(uint8)type(uint8)plmn(uint32)
845 {
846 mbtk_net_array_info_t* nets = (mbtk_net_array_info_t*)malloc(sizeof(mbtk_net_array_info_t));
847 if(!nets)
848 {
849 LOG("malloc() error[%d]", errno);
850 return NULL;
851 }
852 nets->count = 0;
853 nets->net_list = list_create(NULL);
854 if(nets->net_list == NULL)
855 {
856 LOG("list_create() fail.");
857 free(nets);
858 return NULL;
859 }
860
861 int i = 0;
862 while(i < pack->data_len) {
863 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 1");
864 sleep(1);
865 mbtk_net_info_t* net = (mbtk_net_info_t*)malloc(sizeof(mbtk_net_info_t));
866 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 2");
867 sleep(1);
868 if(!net)
869 {
870 LOG("malloc() error[%d]", errno);
871 sleep(3);
872 //list_free(nets->net_list);
873 //free(nets);
874 return NULL;
875 }
876 memset(net, 0, sizeof(mbtk_net_info_t));
877
878 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 3");
879 sleep(1);
880#if 1
881 #if 1
882 #if 0
883 memcpy(net, pack->data + i, sizeof(mbtk_net_info_t));
884 i += sizeof(mbtk_net_info_t);
885 #else
886 net->net_sel_mode = pack->data[i++];
887 net->net_type = pack->data[i++];
888 //sprintf(net->plmn, "%d", byte_2_uint32(pack->data + i, false));
889 net->plmn = byte_2_uint32(pack->data + i, false);
890 i += sizeof(uint32);
891 #endif
892 #endif
893
894 LOG("MBTK_INFO_ID_NET_AVAILABLE_RSP get 5");
895 log_hex("NET 2", net, sizeof(mbtk_net_info_t));
896 sleep(1);
897
898 list_add(nets->net_list, net);
899
900#endif
901 LOG("list_add");
902 sleep(1);
903 }
904
905 sleep(10);
906
907 // Data lenght changed.
908 *data_len = sizeof(mbtk_net_array_info_t);
909 return nets;
910 }
911#endif
912 default:
913 {
914 LOG("Unknown REQ/RSP : %s", id2str(pack->info_id));
915 break;
916 }
917 }
918 }
919 else
920 {
921 LOG("Unknown info : %s", id2str(pack->info_id));
922 }
923
924 return NULL;
925}
926#endif
927
928int mbtk_info_pack_send(int fd, mbtk_info_pack_t *pack)
929{
930 if(!pack)
931 {
932 LOG("Packet is NULL.");
933 return -1;
934 }
935 uint8 data[SOCK_MSG_LEN_MAX] = {0};
936 uint8* data_ptr = data + SOCK_PACK_EXTRA_LEN;
937
938 data_ptr += uint16_2_byte(pack->info_id, data_ptr, false);
939 data_ptr += uint16_2_byte(pack->info_err, data_ptr, false);
940 data_ptr += uint16_2_byte(pack->data_len, data_ptr, false);
941 //log_hex("DATA1", data, 40);
942 if(pack->data_len > 0)
943 {
944 memcpy(data_ptr, pack->data, pack->data_len);
945 data_ptr += pack->data_len;
946 //log_hex("DATA2", data, 40);
947 }
948
949 // Set flag and packet length.
950 uint32_2_byte(MBTK_INFO_PACKET_FLAG, data, true);
951 uint16_2_byte(data_ptr - data - SOCK_PACK_EXTRA_LEN, data + sizeof(uint32), false);
952
953 //log_hex("DATA3", data, 40);
954 return sock_write(fd, data, data_ptr - data);
955}
956
957mbtk_info_pack_t** mbtk_info_pack_recv(int fd, bool is_server, mbtk_info_err_enum *err)
958{
959 uint8 msg[SOCK_MSG_LEN_MAX + 1];
960 *err = MBTK_INFO_ERR_SUCCESS;
961 int len = sock_read(fd, msg, SOCK_MSG_LEN_MAX + 1);
962 if(len < SOCK_PACK_LEN_MIN)
963 {
964 if(len > 0)
965 {
966 *err = MBTK_INFO_ERR_FORMAT;
967 LOG("Insufficient packet data.");
968 }
969 return NULL;
970 }
971
972 int pack_count = pack_num_check(msg, len);
973 LOG("Packet number : %d", pack_count);
974 if(pack_count < 1)
975 {
976 *err = MBTK_INFO_ERR_FORMAT;
977 LOG("Packet not found.");
978 return NULL;
979 }
980 uint8 *ptr = msg;
981 mbtk_info_pack_t** packs = (mbtk_info_pack_t**)malloc(sizeof(mbtk_info_pack_t*) * (pack_count + 1));
982 int i = 0;
983 while(i < pack_count)
984 {
985 // TAG
986 if(MBTK_INFO_PACKET_FLAG != byte_2_uint32(ptr, true))
987 {
988 *err = MBTK_INFO_ERR_FORMAT;
989 LOG("Packet TAG error.");
990 goto error;
991 }
992 ptr += sizeof(uint32);
993
994 // Jump packet length.
995 ptr += sizeof(uint16);
996
997 mbtk_info_id_enum info_id = (mbtk_info_id_enum)byte_2_uint16(ptr, false);
998 mbtk_info_type_enum info_type = mbtk_info_type_get(info_id);
999 if(is_server)
1000 {
1001 // For server,"info_type" must by REQ or IND(Register IND).
1002 if(info_type != MBTK_INFO_TYPE_REQ && info_type != MBTK_INFO_TYPE_IND)
1003 {
1004 *err = MBTK_INFO_ERR_FORMAT;
1005 LOG("Packet Type error.");
1006 goto error;
1007 }
1008 }
1009 else
1010 {
1011 // For client,"info_type" must by RSP or IND.
1012 if(info_type != MBTK_INFO_TYPE_RSP && info_type != MBTK_INFO_TYPE_IND)
1013 {
1014 *err = MBTK_INFO_ERR_FORMAT;
1015 LOG("Packet Type error.");
1016 goto error;
1017 }
1018 }
1019 ptr += sizeof(uint16);
1020
1021 mbtk_info_pack_t* pack = mbtk_info_pack_creat(info_id);
1022 if(pack == NULL)
1023 {
1024 *err = MBTK_INFO_ERR_MEMORY;
1025 LOG("Packet malloc() fail.");
1026 goto error;
1027 }
1028
1029 // "info_err"
1030 pack->info_err = byte_2_uint16(ptr, false);
1031 ptr += sizeof(uint16);
1032
1033 // "data_len"
1034 pack->data_len = byte_2_uint16(ptr, false);
1035 ptr += sizeof(uint16);
1036
1037 if(pack->data_len > 0)
1038 {
1039 pack->data = (uint8*)memdup(ptr, pack->data_len);
1040 ptr += pack->data_len;
1041 }
1042
1043 packs[i++] = pack;
1044 }
1045 packs[i] = NULL;
1046
1047 return packs;
1048
1049error:
1050 LOG("mbtk_info_pack_recv error, will free().");
1051 if(packs)
1052 {
1053 mbtk_info_pack_t** pack_ptr = packs;
1054 while(*pack_ptr)
1055 {
1056 mbtk_info_pack_free(pack_ptr);
1057 pack_ptr++;
1058 }
1059
1060 free(packs);
1061 }
1062 return NULL;
1063}
1064
1065int mbtk_info_pack_free(mbtk_info_pack_t **pack)
1066{
1067 if(pack == NULL || *pack == NULL)
1068 {
1069 LOG("Packet is NULL.");
1070 return -1;
1071 }
1072
1073 // LOG("Free packet : %s", id2str((*pack)->info_id));
1074#if 0
1075 if((*pack)->data)
1076 {
1077 free((*pack)->data);
1078 }
1079#endif
1080 free(*pack);
1081 *pack = NULL;
1082 return 0;
1083}
1084
1085