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