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