[Feature][ZXW-144] add gnss agps function
Only Configure：No
Affected branch：master
Affected module：GNSS
Is it affected on both ZXIC and MTK: only ZXIC
Self-test: Yes
Doc Update: Yes
Change-Id: I9dc5b923f958569f67886728b4e19e2dea612382
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/liblynq-qser-gnss/liblynq-qser-gnss.bb b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/liblynq-qser-gnss/liblynq-qser-gnss.bb
index 469ee92..bebad96 100755
--- a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/liblynq-qser-gnss/liblynq-qser-gnss.bb
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/liblynq-qser-gnss/liblynq-qser-gnss.bb
@@ -38,18 +38,19 @@
#INHIBIT_PACKAGE_STRIP = "1"
do_compile () {
- oe_runmake all -C ${SRC-DIR} ROOT=${STAGING_DIR_HOST} OFLAGS="--sysroot=${STAGING_DIR_HOST} -Os -Wl,--hash-style=gnu -DTELEPHONYWARE"
+ oe_runmake all -C ${SRC-DIR} ROOT=${STAGING_DIR_HOST} OFLAGS="--sysroot=${STAGING_DIR_HOST} -Os -Wl,--hash-style=gnu -DTELEPHONYWARE"
}
do_install () {
oe_runmake install -C ${SRC-DIR} ROOT=${D}
-
+
if [ -d "${WORKONSRC}" ] ; then
install -d ${D}${includedir}/
cp -raf ${SRC-DIR}/include/ ${D}${includedir}/
install -d ${D}/data/gnss_update
- install -m 644 ${WORKONSRC}UC6228CI-R3.2.10.100Build8019_mfg.pkg ${D}/data/gnss_update
+ install -m 644 ${WORKONSRC}UC6228CI-R3.2.10.100Build8019_mfg.pkg ${D}/data/gnss_update
install -m 644 ${WORKONSRC}bootloader_r3.0.0_build6773_uartboot_921600.pkg ${D}/data/gnss_update
+ install -m 644 ${WORKONSRC}agps.conf ${D}/data/gnss_update
ln -sf ./UC6228CI-R3.2.10.100Build8019_mfg.pkg ${D}/data/gnss_update/firmware.pkg
ln -sf ./bootloader_r3.0.0_build6773_uartboot_921600.pkg ${D}/data/gnss_update/bootloader.pkg
fi
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/agps.conf b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/agps.conf
new file mode 100755
index 0000000..71ed385
--- /dev/null
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/agps.conf
@@ -0,0 +1,2 @@
+ ID1: IcoeTempID1Expire20231031
+ Base 64 PW: YVoyWXNXcWp0RFRqVXlVeQ==
\ No newline at end of file
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/lynq_qser_gnss.h b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/lynq_qser_gnss.h
index d69af22..1fe5ab3 100755
--- a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/lynq_qser_gnss.h
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/lynq_qser_gnss.h
@@ -115,6 +115,8 @@
int qser_Gnss_Delete_Aiding_Data(uint32_t h_gnss,DELETE_AIDING_DATA_TYPE_T flags);
int qser_Gnss_InjectTime(uint32_t h_gnss,LYNQ_INJECT_TIME_INTO_T *time_info);
int qser_firmware_update(uint32_t* ph_gnss);
+int qser_Gnss_injectEphemeris(uint32_t h_gnss);
+int qser_Gnss_download_tle();
#ifdef __cplusplus
}
#endif
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_http.h b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_http.h
new file mode 100755
index 0000000..c1c6e9e
--- /dev/null
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_http.h
@@ -0,0 +1,364 @@
+/*************************************************************
+Description:
+ MBTK HTTP Header file.
+Author:
+ LiuBin
+Date:
+ 2020/4/29 17:25:55
+*************************************************************/
+#ifndef _MBTK_HTTP_2_H
+#define _MBTK_HTTP_2_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdio.h>
+#include "mbtk_type.h"
+//#include "mbtk_sock2.h"
+
+
+/*************************************************************
+ Constants and Macros
+*************************************************************/
+#define MBTK_HTTP_URI_MAX 512
+#define MBTK_HTTP_HOST_MAX 50
+#define MBTK_HTTP_URL_MAX (MBTK_HTTP_URI_MAX + MBTK_HTTP_HOST_MAX)
+#define MBTK_HTTP_PORT_DEF 80
+#define MBTK_HTTPS_PORT_DEF 443
+#define HTTP_HANDLE_MAX 3
+#define HTTP_SESSION_MAX 5
+#define HTTP_REQUEST_HEADER_MAX 30
+#define HTTP_RESPONSE_HEADER_MAX 30
+#define HTTP_CONTENT_LEN_MAX 1024
+#define HTTP_MSG_LEN_MAX 1024
+
+#define HTTP_IPC_MSG_PATH "/dev"
+#define HTTP_IPC_MSG_ID 'H'
+
+/*************************************************************
+ Definitions:enum,struct,union,class
+*************************************************************/
+typedef enum {
+ HTTP_VERSION_1_0 = 0,
+ HTTP_VERSION_1_1,
+ HTTP_VERSION_2,
+ HTTP_VERSION_3
+} mbtk_http_version_enum;
+
+typedef enum {
+ HTTP_OPTION_HEAD = 0,
+ HTTP_OPTION_GET,
+ HTTP_OPTION_POST,
+ HTTP_OPTION_PUT,
+ HTTP_OPTION_DELETE,
+ HTTP_OPTION_OPTIONS,
+ HTTP_OPTION_TRACE,
+ HTTP_OPTION_CONNECT,
+ HTTP_OPTION_LINK,
+ HTTP_OPTION_UNLINK
+} mbtk_http_option_enum;
+
+#if 0
+typedef enum {
+ HTTP_HEADER_GENERAL = 0,
+ HTTP_HEADER_REQUEST,
+ HTTP_HEADER_RESPONSE,
+ HTTP_HEADER_ENTITY,
+ HTTP_HEADER_OTHERS
+} mbtk_http_header_type_e;
+
+typedef enum {
+ // General field start.
+ HTTP_HEADER_INDEX_CACHE_CONTROL = 0,
+ HTTP_HEADER_INDEX_CONNECTION,
+ HTTP_HEADER_INDEX_DATE,
+ HTTP_HEADER_INDEX_PRAGMA,
+ HTTP_HEADER_INDEX_TRAILER,
+ HTTP_HEADER_INDEX_TRANSFER_ENCODING,
+ HTTP_HEADER_INDEX_UPGRADE,
+ HTTP_HEADER_INDEX_VIA,
+ HTTP_HEADER_INDEX_WARNING,
+ // General field end.
+ // Request field start.
+ HTTP_HEADER_INDEX_ACCEPT,
+ HTTP_HEADER_INDEX_ACCEPT_CHARSET,
+ HTTP_HEADER_INDEX_ACCEPT_ENCODING,
+ HTTP_HEADER_INDEX_ACCEPT_LANGUAGE,
+ HTTP_HEADER_INDEX_AUTHORIZATION,
+ HTTP_HEADER_INDEX_EXPECT,
+ HTTP_HEADER_INDEX_FROM,
+ HTTP_HEADER_INDEX_HOST,
+ HTTP_HEADER_INDEX_IF_MATCH,
+ HTTP_HEADER_INDEX_IF_MODIFIED_SINCE,
+ HTTP_HEADER_INDEX_IF_NONE_MATCH,
+ HTTP_HEADER_INDEX_IF_RANGE,
+ HTTP_HEADER_INDEX_IF_UNMODIFIED_SINCE,
+ HTTP_HEADER_INDEX_MAX_FORWARDS,
+ HTTP_HEADER_INDEX_PROXY_AUTHORIZATION,
+ HTTP_HEADER_INDEX_RANGE,
+ HTTP_HEADER_INDEX_REFERER,
+ HTTP_HEADER_INDEX_TE,
+ HTTP_HEADER_INDEX_USER_AGENT,
+ // Request field end.
+ // Response field start.
+ HTTP_HEADER_INDEX_ACCEPT_RANGES,
+ HTTP_HEADER_INDEX_AGE,
+ HTTP_HEADER_INDEX_ETAG,
+ HTTP_HEADER_INDEX_LOCATION,
+ HTTP_HEADER_INDEX_PROXY_AUTHENTICATE,
+ HTTP_HEADER_INDEX_RETRY_AFTER,
+ HTTP_HEADER_INDEX_SERVER,
+ HTTP_HEADER_INDEX_VARY,
+ HTTP_HEADER_INDEX_WWW_AUTHENTICATE,
+ // Response field end.
+ // Entity field start.
+ HTTP_HEADER_INDEX_ALLOW,
+ HTTP_HEADER_INDEX_CONTENT_ENCODING,
+ HTTP_HEADER_INDEX_CONTENT_LANGUAGE,
+ HTTP_HEADER_INDEX_CONTENT_LENGTH,
+ HTTP_HEADER_INDEX_CONTENT_LOCATION,
+ HTTP_HEADER_INDEX_CONTENT_MD5,
+ HTTP_HEADER_INDEX_CONTENT_RANGE,
+ HTTP_HEADER_INDEX_CONTENT_TYPE,
+ HTTP_HEADER_INDEX_EXPIRES,
+ HTTP_HEADER_INDEX_LAST_MODIFIED,
+ // Entity field end.
+ // Other field start.
+ HTTP_HEADER_INDEX_SET_COOKIE,
+ HTTP_HEADER_INDEX_COOKIE,
+ HTTP_HEADER_INDEX_X_FRAME_OPTIONS,
+ HTTP_HEADER_INDEX_X_XSS_PROTECTION,
+ HTTP_HEADER_INDEX_DNT,
+ HTTP_HEADER_INDEX_P3P
+ // Other field end.
+} mbtk_http_header_index_e;
+#endif
+
+typedef enum {
+ HTTP_SESSION_STATE_NON = 0,
+ HTTP_SESSION_STATE_CONN,
+ HTTP_SESSION_STATE_WRITE_HEADER,
+ HTTP_SESSION_STATE_WRITE_CONTENT,
+ HTTP_SESSION_STATE_WRITE_END,
+ HTTP_SESSION_STATE_READ_HEADER,
+ HTTP_SESSION_STATE_READ_CONTENT,
+ HTTP_SESSION_STATE_READ_END
+} http_session_state_e;
+
+typedef enum {
+ MBTK_HTTP_STATE_CODE_200 = 200,
+ MBTK_HTTP_STATE_CODE_204 = 204,
+ MBTK_HTTP_STATE_CODE_206 = 206,
+ MBTK_HTTP_STATE_CODE_301 = 301,
+ MBTK_HTTP_STATE_CODE_302 = 302,
+ MBTK_HTTP_STATE_CODE_303 = 303,
+ MBTK_HTTP_STATE_CODE_304 = 304,
+ MBTK_HTTP_STATE_CODE_307 = 307,
+ MBTK_HTTP_STATE_CODE_400 = 400,
+ MBTK_HTTP_STATE_CODE_401 = 401,
+ MBTK_HTTP_STATE_CODE_403 = 403,
+ MBTK_HTTP_STATE_CODE_404 = 404,
+ MBTK_HTTP_STATE_CODE_500 = 500,
+ MBTK_HTTP_STATE_CODE_503 = 503
+} mbtk_http_state_code_e;
+
+typedef enum {
+ MBTK_HTTP_DATA_NON = 0,
+ MBTK_HTTP_DATA_HEADER,
+ MBTK_HTTP_DATA_CONTENT,
+ MBTK_HTTP_DATA_COMPLETE
+} mbtk_http_data_type_enum;
+
+typedef void (*mbtk_http_data_callback_func)(
+ int session_id, mbtk_http_data_type_enum type,
+ void *data,int data_len);
+
+typedef struct mbtk_http_header {
+ char name[30];
+ char *value;
+} mbtk_http_header_t;
+
+typedef struct {
+ int header_cnt;
+ mbtk_http_header_t *req_h[HTTP_REQUEST_HEADER_MAX];
+
+ int content_len; // Post content lenght
+ int content_len_send; // Post content lenght for send.
+ char *content;
+} mbtk_http_session_req_t;
+
+typedef struct {
+ int state_code;
+ mbtk_http_version_enum version;
+
+ int content_length;
+ bool is_chunked;
+ int header_cnt;
+ mbtk_http_header_t *rsp_h[HTTP_RESPONSE_HEADER_MAX];
+} mbtk_http_session_rsp_t;
+
+typedef struct mbtk_http_session{
+ int handle_id;
+ int id;
+ int sock_fd;
+ FILE *sock_file;
+ http_session_state_e state;
+ char host[MBTK_HTTP_HOST_MAX + 1];
+ mbtk_http_option_enum option;
+ mbtk_http_version_enum version;
+ char uri[MBTK_HTTP_URI_MAX + 1];
+ int port;
+ bool is_ssl;
+
+ mbtk_http_session_req_t req;
+ mbtk_http_session_rsp_t rsp;
+} mbtk_http_session_t;
+
+typedef struct mbtk_http_handle{
+ int id;
+ bool show_rsp_header;
+ mbtk_http_data_callback_func data_cb;
+
+ int session_cnt;
+ mbtk_http_session_t *session[HTTP_SESSION_MAX];
+} mbtk_http_handle_t;
+
+#if 0
+typedef enum {
+ HTTP_MSG_SESSION_CREATE_REQ,
+ HTTP_MSG_SESSION_CREATE_RSP,
+ HTTP_MSG_SESSION_FREE_REQ,
+ HTTP_MSG_SESSION_FREE_RSP,
+ HTTP_MSG_SESSION_URL_SET_REQ,
+ HTTP_MSG_SESSION_URL_SET_RSP,
+ HTTP_MSG_SESSION_HEAD_SET_REQ,
+ HTTP_MSG_SESSION_HEAD_SET_RSP,
+ HTTP_MSG_SESSION_CONTENT_SET_REQ,
+ HTTP_MSG_SESSION_CONTENT_SET_RSP,
+ HTTP_MSG_SESSION_ACTION_REQ,
+ HTTP_MSG_SESSION_ACTION_RSP,
+ HTTP_MSG_SESSION_CONTENT_SEND_REQ,
+ HTTP_MSG_SESSION_CONTENT_SEND_RSP
+} mbtk_http_msg_type_enum;
+#endif
+
+typedef enum {
+ HTTP_MSG_SESSION_CREATE,
+ HTTP_MSG_SESSION_FREE,
+ HTTP_MSG_SESSION_HEAD_SET,
+ HTTP_MSG_SESSION_CONTENT_SET,
+ HTTP_MSG_SESSION_ACTION,
+ HTTP_MSG_SESSION_CONTENT_SEND,
+ HTTP_MSG_HANDLE_EXIT
+} mbtk_http_msg_type_enum;
+
+typedef enum {
+ MBTK_HTTP_ERR_SUCCESS,
+ MBTK_HTTP_ERR_UNKNOWN
+} mbtk_http_err_enum;
+
+typedef struct {
+ mbtk_http_msg_type_enum type;
+ int int_arg1;
+ int int_arg2;
+ char str_small[30];
+ char str_large[HTTP_MSG_LEN_MAX];
+} mbtk_http_msg_req_t;
+
+typedef struct {
+ mbtk_http_msg_type_enum type;
+ mbtk_http_err_enum err;
+
+ mbtk_http_data_type_enum data_type;
+ int buff_len;
+ char buff[HTTP_MSG_LEN_MAX];
+} mbtk_http_msg_rsp_t;
+
+/*************************************************************
+ Extern variables
+*************************************************************/
+#if 0
+const mbtk_http_header_field_t mbtk_http_headers[] = {
+ {HTTP_HEADER_INDEX_CACHE_CONTROL, HTTP_HEADER_GENERAL,"Cache-Control"},
+ {HTTP_HEADER_INDEX_CONNECTION, HTTP_HEADER_GENERAL,"Connection"},
+ {HTTP_HEADER_INDEX_DATE, HTTP_HEADER_GENERAL,"Date"},
+ {HTTP_HEADER_INDEX_PRAGMA, HTTP_HEADER_GENERAL,"Pragma"},
+ {HTTP_HEADER_INDEX_TRAILER, HTTP_HEADER_GENERAL,"Trailer"},
+ {HTTP_HEADER_INDEX_TRANSFER_ENCODING, HTTP_HEADER_GENERAL,"Transfer-Encoding"},
+ {HTTP_HEADER_INDEX_UPGRADE, HTTP_HEADER_GENERAL,"Upgrade"},
+ {HTTP_HEADER_INDEX_VIA, HTTP_HEADER_GENERAL,"Via"},
+ {HTTP_HEADER_INDEX_WARNING, HTTP_HEADER_GENERAL,"Warning"},
+ {HTTP_HEADER_INDEX_ACCEPT, HTTP_HEADER_REQUEST,"Accept"},
+ {HTTP_HEADER_INDEX_ACCEPT_CHARSET, HTTP_HEADER_REQUEST,"Accept-Charset"},
+ {HTTP_HEADER_INDEX_ACCEPT_ENCODING, HTTP_HEADER_REQUEST,"Accept-Encoding"},
+ {HTTP_HEADER_INDEX_ACCEPT_LANGUAGE, HTTP_HEADER_REQUEST,"Accept-Language"},
+ {HTTP_HEADER_INDEX_AUTHORIZATION, HTTP_HEADER_REQUEST,"Authorization"},
+ {HTTP_HEADER_INDEX_EXPECT, HTTP_HEADER_REQUEST,"Expect"},
+ {HTTP_HEADER_INDEX_FROM, HTTP_HEADER_REQUEST,"From"},
+ {HTTP_HEADER_INDEX_HOST, HTTP_HEADER_REQUEST,"Host"},
+ {HTTP_HEADER_INDEX_IF_MATCH, HTTP_HEADER_REQUEST,"If-Match"},
+ {HTTP_HEADER_INDEX_IF_MODIFIED_SINCE, HTTP_HEADER_REQUEST,"If-Modified-Since"},
+ {HTTP_HEADER_INDEX_IF_NONE_MATCH, HTTP_HEADER_REQUEST,"If-None-Match"},
+ {HTTP_HEADER_INDEX_IF_RANGE, HTTP_HEADER_REQUEST,"If-Range"},
+ {HTTP_HEADER_INDEX_IF_UNMODIFIED_SINCE, HTTP_HEADER_REQUEST,"If-Unmodified-Since"},
+ {HTTP_HEADER_INDEX_MAX_FORWARDS, HTTP_HEADER_REQUEST,"Max-Forwards"},
+ {HTTP_HEADER_INDEX_PROXY_AUTHORIZATION, HTTP_HEADER_REQUEST,"Proxy-Authorization"},
+ {HTTP_HEADER_INDEX_RANGE, HTTP_HEADER_REQUEST,"Range"},
+ {HTTP_HEADER_INDEX_REFERER, HTTP_HEADER_REQUEST,"Referer"},
+ {HTTP_HEADER_INDEX_TE, HTTP_HEADER_REQUEST,"TE"},
+ {HTTP_HEADER_INDEX_USER_AGENT, HTTP_HEADER_REQUEST,"User-Agent"},
+ {HTTP_HEADER_INDEX_ACCEPT_RANGES, HTTP_HEADER_RESPONSE,"Accept-Ranges"},
+ {HTTP_HEADER_INDEX_AGE, HTTP_HEADER_RESPONSE,"Age"},
+ {HTTP_HEADER_INDEX_ETAG, HTTP_HEADER_RESPONSE,"ETag"},
+ {HTTP_HEADER_INDEX_LOCATION, HTTP_HEADER_RESPONSE,"Location"},
+ {HTTP_HEADER_INDEX_PROXY_AUTHENTICATE, HTTP_HEADER_RESPONSE,"Proxy-Authenticate"},
+ {HTTP_HEADER_INDEX_RETRY_AFTER, HTTP_HEADER_RESPONSE,"Retry-After"},
+ {HTTP_HEADER_INDEX_SERVER, HTTP_HEADER_RESPONSE,"Server"},
+ {HTTP_HEADER_INDEX_VARY, HTTP_HEADER_RESPONSE,"Vary"},
+ {HTTP_HEADER_INDEX_WWW_AUTHENTICATE, HTTP_HEADER_RESPONSE,"WWW-Authenticate"},
+ {HTTP_HEADER_INDEX_ALLOW, HTTP_HEADER_ENTITY,"Allow"},
+ {HTTP_HEADER_INDEX_CONTENT_ENCODING, HTTP_HEADER_ENTITY,"Content-Encoding"},
+ {HTTP_HEADER_INDEX_CONTENT_LANGUAGE, HTTP_HEADER_ENTITY,"Content-Language"},
+ {HTTP_HEADER_INDEX_CONTENT_LENGTH, HTTP_HEADER_ENTITY,"Content-Length"},
+ {HTTP_HEADER_INDEX_CONTENT_LOCATION, HTTP_HEADER_ENTITY,"Content-Location"},
+ {HTTP_HEADER_INDEX_CONTENT_MD5, HTTP_HEADER_ENTITY,"Content-MD5"},
+ {HTTP_HEADER_INDEX_CONTENT_RANGE, HTTP_HEADER_ENTITY,"Content-Range"},
+ {HTTP_HEADER_INDEX_CONTENT_TYPE, HTTP_HEADER_ENTITY,"Content-Type"},
+ {HTTP_HEADER_INDEX_EXPIRES, HTTP_HEADER_ENTITY,"Expires"},
+ {HTTP_HEADER_INDEX_LAST_MODIFIED, HTTP_HEADER_ENTITY,"Last-Modified"},
+ {HTTP_HEADER_INDEX_SET_COOKIE, HTTP_HEADER_OTHERS,"Set-Cookie"},
+ {HTTP_HEADER_INDEX_COOKIE, HTTP_HEADER_OTHERS,"Cookie"},
+ {HTTP_HEADER_INDEX_X_FRAME_OPTIONS, HTTP_HEADER_OTHERS,"X-Frame-Options"},
+ {HTTP_HEADER_INDEX_X_XSS_PROTECTION, HTTP_HEADER_OTHERS,"X-XSS-Protection"},
+ {HTTP_HEADER_INDEX_DNT, HTTP_HEADER_OTHERS,"DNT"},
+ {HTTP_HEADER_INDEX_P3P, HTTP_HEADER_OTHERS,"P3P"}
+};
+#endif
+/*************************************************************
+ Public Function Declaration
+*************************************************************/
+int mbtk_http_handle_get(bool show_rsp_header,mbtk_http_data_callback_func data_cb);
+int mbtk_http_handle_free(int handle_id);
+int mbtk_http_session_create(int handle_id, mbtk_http_option_enum option,
+ mbtk_http_version_enum version);
+int mbtk_http_session_option_reset(int handle_id, int session_id, mbtk_http_option_enum option);
+int mbtk_http_session_free(int handle_id,int session_id);
+int mbtk_http_session_url_set(int handle_id,int session_id,void *url);
+int mbtk_http_session_head_add(int handle_id,int session_id,
+ char *name, char *value);
+int mbtk_http_session_content_set(int handle_id,int session_id,
+ char *content,uint32 content_len);
+int mbtk_http_session_start(int handle_id,int session_id);
+int mbtk_http_session_content_send(int handle_id,int session_id,
+ char *data,int data_len);
+const mbtk_http_session_t* mbtk_http_session_get(int handle_id,int session_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MBTK_HTTP_2_H */
+
+
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_http_base.h b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_http_base.h
new file mode 100755
index 0000000..e8ae710
--- /dev/null
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_http_base.h
@@ -0,0 +1,44 @@
+#include <cstdio>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int mbtk_http_init();
+int mbtk_http_deinit();
+int mbtk_http_open
+(
+ //bool is_ssl,
+ //bool ingnore_cert,
+ const void *host,
+ int *port
+);
+int mbtk_http_read
+(
+ int sock_fd,
+ void *buf,
+ uint16_t len,
+ int timeout_ms
+);
+
+int mbtk_http_read_line
+(
+ int sock_fd,
+ void *buf,
+ uint16_t len
+);
+int mbtk_http_write
+(
+ int sock_fd,
+ void *buf,
+ uint16_t len
+);
+int mbtk_http_close(int sock_fd);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_type.h b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_type.h
new file mode 100755
index 0000000..c5fc1a0
--- /dev/null
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/include/mbtk_type.h
@@ -0,0 +1,127 @@
+#ifndef MBTK_TYPE_INCLUDE
+#define MBTK_TYPE_INCLUDE
+#include <stdio.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#ifndef MBTK_PLATFORM_LINUX
+#define MBTK_PLATFORM_LINUX
+#endif
+
+#ifndef MBTK_PLATFORM_QCOMM
+//#define MBTK_PLATFORM_QCOMM
+#endif
+
+#define MBTK_SUCCESS 0
+#define MBTK_FAILE (-1)
+
+#ifndef UNUSED
+#define UNUSED(param) ((void) param)
+#define UNUSEDPARAM UNUSED
+#endif
+
+#ifndef TRUE
+#define TRUE 1 /* Boolean true value. */
+#endif
+
+#ifndef true
+#define true 1 /* Boolean true value. */
+#endif
+
+#ifndef FALSE
+#define FALSE 0 /* Boolean false value. */
+#endif
+
+#ifndef false
+#define false 0 /* Boolean false value. */
+#endif
+
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+
+#ifndef null
+#define null 0
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * Compiler-digit : 16
+ * char : 1 (%c)
+ * char* : 2
+ * short int : 2
+ * int : 2 (%d)
+ * unsigned int : 2 (%u)
+ * float : 4 (%f)
+ * double : 8 (%f)
+ * long : 4
+ * unsigned long : 4
+ * long long : 8
+ * unsigned long long : 8
+ *
+ *
+ * Compiler-digit : 32
+ * char : 1
+ * char* : 4
+ * short int : 2
+ * int : 4
+ * unsigned int : 4
+ * float : 4
+ * double : 8
+ * long : 4
+ * unsigned long : 4
+ * long long : 8
+ * unsigned long long : 8
+ *
+ *
+ * Compiler-digit : 64
+ * char : 1
+ * char* : 8
+ * short int : 2
+ * int : 4
+ * unsigned int : 4
+ * float : 4
+ * double : 8
+ * long : 8
+ * unsigned long : 8
+ * long long : 8
+ * unsigned long long : 8
+ */
+typedef unsigned char boolean; /* Boolean value type. */
+// typedef unsigned char bool; /* Boolean value type. */
+typedef unsigned long long uint64; /* Unsigned 64 bit value */
+typedef unsigned long long uint64_t; /* Unsigned 64 bit value */
+typedef unsigned int uint32; /* Unsigned 32 bit value */
+typedef unsigned int uint32_t; /* Unsigned 32 bit value */
+typedef unsigned short uint16; /* Unsigned 16 bit value */
+typedef unsigned short uint16_t;
+typedef unsigned char uint8; /* Unsigned 8 bit value */
+typedef unsigned char uint8_t;
+typedef signed long long int64; /* Signed 64 bit value */
+typedef signed long long sint64; /* Signed 64 bit value */
+typedef signed int int32; /* Signed 32 bit value */
+typedef signed int sint32; /* Signed 32 bit value */
+typedef signed short int16; /* Signed 16 bit value */
+typedef signed short sint16; /* Signed 16 bit value */
+typedef signed char int8; /* Signed 8 bit value */
+typedef signed char sint8; /* Signed 8 bit value */
+typedef unsigned char byte; /* byte type */
+
+
+typedef struct
+{
+ char *buffer;
+ int size;
+ int size_max;
+}mbtk_buffer_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* MBTK_TYPE_INCLUDE */
+
+
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/lynq_qser_gnss.cpp b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/lynq_qser_gnss.cpp
index 735f467..a7f7191 100755
--- a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/lynq_qser_gnss.cpp
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/lynq_qser_gnss.cpp
@@ -233,6 +233,28 @@
return 0;
}
+int qser_Gnss_download_tle()
+{
+ int ret;
+ ret = mopen_gnss_download_tle();
+ if(ret < 0)
+ {
+ return -1;
+ }
+ return 0;
+}
+
+int qser_Gnss_injectEphemeris(uint32_t h_gnss)
+{
+ int ret;
+ ret = mopen_gnss_injects_aidpos(h_gnss);
+ if(ret < 0)
+ {
+ return -1;
+ }
+ return 0;
+}
+
void atsvc_incb_entity(char *input,int length);
int lynq_at_cgps(int at_type,int gnss_state_type);
int lynq_at_cgpsnmea(int at_type,int gnss_state_type);
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_gnss.cpp b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_gnss.cpp
index cffc6a9..5721c83 100755
--- a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_gnss.cpp
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_gnss.cpp
@@ -18,6 +18,8 @@
#include <sys/time.h>
#include <liblog/lynq_deflog.h>
#include "mbtk_gnss_internal.h"
+#include "mbtk_http.h"
+#include "mbtk_type.h"
#include "ringbuffer.h"
#ifdef __cplusplus
extern "C" {
@@ -1198,12 +1200,196 @@
return 0;
}
-#define AGNSS_TLE_FILE "/tmp/agnss_tle"
+#define AGNSS_TLE_FILE "/mnt/userdata/agnss_tle"
+static void http_data_cb_func(
+ int session_id, mbtk_http_data_type_enum type,
+ void *data,int data_len)
+{
+ static int agnss_fd = 0;
+ int ret = 0;
+ if(type == MBTK_HTTP_DATA_HEADER) {
+ printf("Header(%d):%s\n", data_len, (char*)data);
+ if(agnss_fd > 0)
+ return;
+ unlink(AGNSS_TLE_FILE);
+ agnss_fd = open(AGNSS_TLE_FILE, O_RDWR|O_CREAT|O_TRUNC, 0644);
+ if (agnss_fd <= 0)
+ printf("file open error\n");
+ printf("agnss file open: %d\n", agnss_fd);
+ } else if(type == MBTK_HTTP_DATA_CONTENT) {
+ printf("http Data(%d)\n", data_len);
+ ret = write(agnss_fd, (char*)data, data_len);
+ if (ret < 0) {
+ printf("%s: error writing to file!\n", __FUNCTION__);
+ } else if (ret < data_len) {
+ printf("%s: wrote less the buffer size!\n", __FUNCTION__);
+ }
+ } else {
+ printf(">>>>>Complete<<<<<\n");
+ if(agnss_fd <= 0)
+ return;
+ close(agnss_fd);
+ agnss_fd = 0;
+ }
+}
-#define AGNSS_CONFIG_FILE "/etc/mbtk/gps.conf"
+static int gnss_http_requst(char *id, char *pw)
+{
+ char tmp[128] = {0};
+
+ int http_handle = mbtk_http_handle_get(TRUE, http_data_cb_func);
+ if(http_handle < 0)
+ {
+ printf("mbtk_http_handle_get() fail.");
+ return -1;
+ }
+ int http_session = mbtk_http_session_create(http_handle, HTTP_OPTION_POST, HTTP_VERSION_1_1);
+ if(http_handle < 0)
+ {
+ printf("mbtk_http_session_create() fail.");
+ return -2;
+ }
+ if(mbtk_http_session_url_set(http_handle, http_session, "http://unicore-api.rx-networks.cn/rxn-api/locationApi/rtcm")) {
+ printf("mbtk_http_session_url_set() fail.\n");
+ return -3;
+ }
+
+ char* post_data = "[{\"rtAssistance\":{\"format\":\"rtcm\",\"msgs\":[\"GPS:2NAF\",\"BDS:2NAF\",\"QZS:2NAF\"]}}]\r\n";
+
+ mbtk_http_session_head_add(http_handle, http_session, \
+ "Host", "unicore-api.rx-networks.cn");
+
+ sprintf(tmp, "RXN-BASIC cId=%s,mId=Unicore,dId=12-23-34-45-58,pw=%s", id, pw);
+ mbtk_http_session_head_add(http_handle, http_session, \
+ "Authorization", tmp);
+
+ mbtk_http_session_head_add(http_handle, http_session, \
+ "Content-Type", "application/json");
+
+ mbtk_http_session_head_add(http_handle, http_session, \
+ "Accept", "application/octet-stream");
+ mbtk_http_session_content_set(http_handle, http_session,
+ post_data, strlen(post_data));
+
+ if(mbtk_http_session_start(http_handle, http_session)) {
+ printf("mbtk_http_session_start() fail.\n");
+ return -4;
+ }
+ if(mbtk_http_handle_free(http_handle))
+ {
+ printf("mbtk_http_handle_free() fail.");
+ return -5;
+ }
+
+ return 0;
+}
+
+/**********************************
+
+ ID1: TempID1Expire20221031
+ Base 64 PW1: RlJYdkFTNE9DWXJhN2ZWTA==
+**************************************/
+#define AGNSS_CONFIG_FILE "/data/gnss_update/agps.conf"
+
+/**
+ * @brief mopen_gnss_download_tle
+ *
+ * @details 下载星历数据
+ * (卫星星历，又称为两行轨道数据（TLE，Two-Line Orbital Element）)
+ * 保存到文件:AGNSS_TLE_FILE
+ * @param param
+ *
+ * @return return type
+ */
+int mopen_gnss_download_tle(void)
+{
+ FILE *fp;
+ char StrLine[64];
+ char _id[28] = {0};
+ char _passwd[28] = {0};
+ int i;
+ if((fp = fopen(AGNSS_CONFIG_FILE, "r")) == NULL)
+ {
+ printf("open %s error!\n", AGNSS_CONFIG_FILE);
+ return -1;
+ }
+
+ while (!feof(fp))
+ {
+ memset(StrLine, 0, 64);
+ fgets(StrLine, 64, fp);
+ gnss_log("%s\n", StrLine);
+ i = strstr_n(StrLine, ": ");
+ if(i && strstr_n(StrLine, "ID"))
+ {
+ memcpy(_id, &StrLine[i + 1], strlen(StrLine) - i - 2);
+ printf("%s\n",_id);
+ }
+ else if( i && strstr_n(StrLine, "Base 64"))
+ {
+ memcpy(_passwd, &StrLine[i + 1], strlen(StrLine) - i - 1);
+ printf("%s\n",_passwd);
+ }
+ }
+ fclose(fp);
+ gnss_log("%s : %s[%d], %s[%d]\n", __FUNCTION__, _id, strlen(_id), _passwd, strlen(_passwd));
+ return gnss_http_requst(_id, _passwd);
+}
+
+/**
+ * @brief mopen_gnss_injects_aidpos
+ *
+ * @details 注入星历, 128 bytes
+ *
+ * @param param
+ *
+ * @return return type
+ */
+int mopen_gnss_injects_aidpos(uint32 h_gnss)
+{
+ int ret;
+ int agnss_fd = 0;
+ int size = 0;
+
+ if(0 == h_gnss)
+ {
+ printf("%s handler invalid.\n", __func__);
+ return -1;
+ }
+
+ agnss_fd = open(AGNSS_TLE_FILE, O_RDWR);
+ if (agnss_fd <= 0)
+ {
+ printf("%s open file FAIL. errno:%d\n", __FUNCTION__, errno);
+ return -1;
+ }
+ char* databuf = (char*)malloc(128);
+ if(databuf == NULL)
+ {
+ gnss_log("%s malloc() fail.", __FUNCTION__);
+ return -1;
+ }
+ memset(databuf, 0, 128);
+ while(0 < (size = read(agnss_fd, databuf, 128)))
+ {
+ gnss_log("%s Write[%d]\r\n", __FUNCTION__, size);
+ ret = lynq_gnss_send_cmd(h_gnss, databuf, size);
+ if(ret < 0)
+ {
+ printf("%s send cmd FAIL. ret:%d\n", __FUNCTION__, ret);
+ break;
+ }
+ memset(databuf, 0, 128);
+ }
+ close(agnss_fd);
+ free(databuf);
+ lynq_gnss_get_aidinfo(h_gnss);
+
+ return 0;
+}
/**
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_http.cpp b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_http.cpp
new file mode 100755
index 0000000..1963359
--- /dev/null
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_http.cpp
@@ -0,0 +1,1370 @@
+/*************************************************************
+Description:
+ MBTK HTTP c file.
+Author:
+
+Date:
+
+*************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <log/log.h>
+#include <liblog/lynq_deflog.h>
+#include "mbtk_http_base.h"
+#include "mbtk_http.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*************************************************************
+ Constants and Macros
+*************************************************************/
+
+/*************************************************************
+ Variables:local
+*************************************************************/
+static mbtk_http_handle_t http_handles[HTTP_HANDLE_MAX] =
+{
+ {
+ .id = -1,
+ .data_cb = NULL,
+ .session_cnt = 0,
+ .session = {NULL}
+ }
+};
+
+/*************************************************************
+ Variables:public
+*************************************************************/
+
+
+/*************************************************************
+ Local Function Declaration
+*************************************************************/
+
+
+/*************************************************************
+ Local Function Definitions
+*************************************************************/
+static void http_session_free(mbtk_http_session_t *session)
+{
+ if(session)
+ {
+ if(session->req.header_cnt > 0)
+ {
+ int index;
+ for(index = 0; index < HTTP_REQUEST_HEADER_MAX; index++)
+ {
+ if(session->req.req_h[index] != NULL)
+ {
+ if(session->req.req_h[index]->value)
+ free(session->req.req_h[index]->value);
+ free(session->req.req_h[index]);
+ session->req.req_h[index] = NULL;
+ }
+ }
+ session->req.header_cnt = 0;
+ }
+
+ if(session->req.content)
+ {
+ free(session->req.content);
+ session->req.content = NULL;
+ }
+
+ if(session->rsp.header_cnt > 0)
+ {
+ int index;
+ for(index = 0; index < HTTP_REQUEST_HEADER_MAX; index++)
+ {
+ if(session->rsp.rsp_h[index] != NULL)
+ {
+ if(session->rsp.rsp_h[index]->value)
+ free(session->rsp.rsp_h[index]->value);
+ free(session->rsp.rsp_h[index]);
+ session->rsp.rsp_h[index] = NULL;
+ }
+ }
+ session->rsp.header_cnt = 0;
+ }
+
+ free(session);
+ }
+}
+
+static int http_session_close(mbtk_http_session_t *session)
+{
+ if(session)
+ {
+ if(session->sock_fd > 0)
+ {
+ if(mbtk_http_close(session->sock_fd))
+ {
+ RLOGD("mbtk_http_close() fail.");
+ return -1;
+ }
+ session->sock_fd = -1;
+ }
+
+ session->state = HTTP_SESSION_STATE_NON;
+
+ return 0;
+ }
+
+ return -1;
+}
+
+
+static bool http_handle_check(int handle_id)
+{
+ if(handle_id < 0 || handle_id >= HTTP_HANDLE_MAX
+ || http_handles[handle_id].id < 0)
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static bool http_session_check(int handle_id, int session_id)
+{
+ if(handle_id < 0 || handle_id >= HTTP_HANDLE_MAX
+ || http_handles[handle_id].id < 0
+ || http_handles[handle_id].id != handle_id)
+ {
+ return FALSE;
+ }
+
+ if(session_id < 0 || session_id >= HTTP_SESSION_MAX
+ || http_handles[handle_id].session[session_id] == NULL
+ || http_handles[handle_id].session[session_id]->id != session_id)
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static bool http_is_space_char(char ch)
+{
+ if(ch == ' ' || ch == '\r' || ch == '\t' || ch == '\n')
+ return TRUE;
+
+ return FALSE;
+}
+
+static bool http_str_empty(char *str)
+{
+ if(str == NULL || strlen(str) == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+
+static int http_url_parse
+(
+ void* url,
+ void *host,
+ void *uri,
+ int *port,
+ bool *is_ssl
+)
+{
+ if(strlen(url) == 0)
+ {
+ return -1;
+ }
+ char *url_ptr = (char*)url;
+ char *host_ptr = (char*)host;
+
+ RLOGD("URL[%d]:%s",strlen(url_ptr),url_ptr);
+
+ if(!memcmp(url_ptr,"https://",8))
+ {
+ *is_ssl = TRUE;
+ url_ptr += 8;
+ }
+ else if(!memcmp(url_ptr,"http://",7))
+ {
+ *is_ssl = FALSE;
+ url_ptr += 7;
+ }
+ else
+ {
+ *is_ssl = FALSE;
+ }
+
+ // ptr point to host.
+ while(*url_ptr)
+ {
+ if(*url_ptr == ':' || *url_ptr == '/') // Host end
+ break;
+ if(http_is_space_char(*url_ptr))
+ {
+ url_ptr++;
+ continue;
+ }
+ *host_ptr++ = *url_ptr++;
+ }
+
+ // "www.baidu.com"
+ if(*url_ptr == '\0') // No port and uri
+ {
+ if(*is_ssl)
+ {
+ *port = MBTK_HTTPS_PORT_DEF;
+ }
+ else
+ {
+ *port = MBTK_HTTP_PORT_DEF;
+ }
+ memcpy(uri,"/",1);
+
+ RLOGD("HTTP parse success:'%s','%s', %d, %d",(char*)host,(char*)uri,*port,*is_ssl);
+ return 0;
+ }
+ else
+ {
+ //LOGI("Host end with:%x",*url_ptr);
+ if(*url_ptr == ':') // Port exist.
+ {
+ *port = atoi(url_ptr + 1);
+
+ // Point to '/' or NULL
+ while(*url_ptr && *url_ptr != '/')
+ {
+ url_ptr++;
+ }
+
+ // "www.baidu.com:80"
+ if(*url_ptr == '\0') // No uri
+ {
+ if(*port == 0)
+ {
+ if(*is_ssl)
+ {
+ *port = MBTK_HTTPS_PORT_DEF;
+ }
+ else
+ {
+ *port = MBTK_HTTP_PORT_DEF;
+ }
+ }
+ memcpy(uri,"/",1);
+
+ RLOGD("HTTP parse success:'%s','%s', %d, %d",(char*)host,(char*)uri,*port,*is_ssl);
+ return 0;
+ }
+ }
+
+ // "www.baidu.com/xxx" or "www.baidu.com:80/xxx"
+ // Now,url_ptr point to '/'
+ if(*url_ptr != '/')
+ {
+ RLOGD("URI must start with '/'.");
+ return -1;
+ }
+
+ //LOGI("URL3[%d]:%s",strlen(url_ptr),url_ptr);
+
+ memcpy(uri,url_ptr,strlen(url_ptr));
+
+ if(*port == 0)
+ {
+ if(*is_ssl)
+ {
+ *port = MBTK_HTTPS_PORT_DEF;
+ }
+ else
+ {
+ *port = MBTK_HTTP_PORT_DEF;
+ }
+ }
+
+ RLOGD("HTTP parse success:'%s','%s', %d, %d",(char*)host,(char*)uri,*port,*is_ssl);
+ return 0;
+ }
+}
+
+static int http_session_req_head_add(mbtk_http_session_t *session,bool replace,
+ char *name, char *value)
+{
+ if(session == NULL || value == NULL)
+ return -1;
+
+ RLOGD("Add request header - %s:%s",name,value);
+
+ int i = 0;
+ while(i < HTTP_REQUEST_HEADER_MAX)
+ {
+ if(session->req.req_h[i]
+ && !strncasecmp(session->req.req_h[i]->name,name,strlen(name))) // Is change value
+ {
+ break;
+ }
+ i++;
+ }
+
+ if(i == HTTP_REQUEST_HEADER_MAX) // Should add new header.
+ {
+ i = 0;
+ while(i < HTTP_REQUEST_HEADER_MAX)
+ {
+ if(session->req.req_h[i] == NULL) // Find NULL request.
+ {
+ session->req.req_h[i] = (mbtk_http_header_t*)malloc(sizeof(mbtk_http_header_t));
+ if(session->req.req_h[i] == NULL)
+ {
+ RLOGD("malloc() fail.");
+ return -1;
+ }
+
+ memset(session->req.req_h[i],0x0,sizeof(mbtk_http_header_t));
+ memcpy(session->req.req_h[i]->name, name, strlen(name));
+ session->req.req_h[i]->value = NULL;
+ session->req.header_cnt++;
+ break;
+ }
+ i++;
+ }
+ }
+ else // Is change value
+ {
+ if(!replace)
+ {
+ RLOGD("Found this header[%s],no replace.",name);
+ return 0;
+ }
+ }
+
+ if(i == HTTP_REQUEST_HEADER_MAX)
+ {
+ RLOGD("Request header is full.");
+ return -1;
+ }
+
+ if(session->req.req_h[i]->value)
+ {
+ free(session->req.req_h[i]->value);
+ }
+ session->req.req_h[i]->value = (char*)malloc(strlen(value) + 1);
+ if(session->req.req_h[i]->value == NULL)
+ {
+ RLOGD("malloc() fail.");
+ return -1;
+ }
+ memset(session->req.req_h[i]->value,0x0,strlen(value) + 1);
+ memcpy(session->req.req_h[i]->value,value,strlen(value));
+
+ return 0;
+}
+
+#if 0
+static int http_session_rsp_head_add(mbtk_http_session_t *session,
+ char *name, char *value)
+{
+ if(session == NULL || value == NULL)
+ return -1;
+
+ int i = 0;
+ while(i < HTTP_REQUEST_HEADER_MAX)
+ {
+ if(session->rsp.rsp_h[i] == NULL) // Find NULL request.
+ {
+ session->rsp.rsp_h[i] = (mbtk_http_header_t*)malloc(sizeof(mbtk_http_header_t));
+ if(session->rsp.rsp_h[i] == NULL)
+ {
+ RLOGD("malloc() fail.");
+ return -1;
+ }
+
+ memcpy(session->rsp.rsp_h[i]->name,name,strlen(name));
+ session->rsp.rsp_h[i]->value = (char*)malloc(strlen(value) + 1);
+ if(session->rsp.rsp_h[i]->value == NULL)
+ {
+ RLOGD("malloc() fail.");
+ return -1;
+ }
+ memset(session->rsp.rsp_h[i]->value,0x0,strlen(value) + 1);
+ memcpy(session->rsp.rsp_h[i]->value,value,strlen(value));
+
+ session->rsp.header_cnt++;
+ return 0;
+ }
+ i++;
+ }
+
+ return -1;
+}
+#endif
+
+static char* http_option_str_get(mbtk_http_option_enum option)
+{
+ switch(option)
+ {
+ case HTTP_OPTION_HEAD:
+ return "HEAD";
+ case HTTP_OPTION_GET:
+ return "GET";
+ case HTTP_OPTION_POST:
+ return "POST";
+ case HTTP_OPTION_PUT:
+ return "PUT";
+ case HTTP_OPTION_DELETE:
+ return "DELETE";
+ case HTTP_OPTION_OPTIONS:
+ return "OPTIONS";
+ case HTTP_OPTION_TRACE:
+ return "TRACE";
+ case HTTP_OPTION_CONNECT:
+ return "CONNECT";
+ case HTTP_OPTION_LINK:
+ return "LINK";
+ case HTTP_OPTION_UNLINK:
+ return "UNLINK";
+ default:
+ return "";
+ }
+}
+
+static char* http_version_str_get(mbtk_http_version_enum version)
+{
+ switch(version)
+ {
+ case HTTP_VERSION_1_0:
+ return "1.0";
+ case HTTP_VERSION_1_1:
+ return "1.1";
+ case HTTP_VERSION_2:
+ return "2";
+ case HTTP_VERSION_3:
+ return "3";
+ default:
+ return "";
+ }
+}
+
+static char* http_header_find(mbtk_http_session_t *session,char* name)
+{
+ int i = 0;
+ while(i < HTTP_REQUEST_HEADER_MAX)
+ {
+ if(session->req.req_h[i] &&
+ !strncasecmp(session->req.req_h[i]->name,name,strlen(name)))
+ {
+ return session->req.req_h[i]->value;
+ }
+
+ i++;
+ }
+ return NULL;
+}
+
+static int http_header_str_get(mbtk_http_header_t *header,char *header_str,int header_str_len)
+{
+ if(header == NULL || header->value == NULL
+ || header_str == NULL)
+ return 0;
+
+ int len = 0;
+ len = snprintf(header_str,header_str_len,"%s: %s\r\n",
+ header->name, header->value);
+
+ return len;
+}
+
+static mbtk_http_version_enum http_version_get_by_str(char *version_str)
+{
+ if(!memcmp(version_str,"1.0",3))
+ return HTTP_VERSION_1_0;
+ else if(!memcmp(version_str,"1.1",3))
+ return HTTP_VERSION_1_1;
+ else if(!memcmp(version_str,"2",1))
+ return HTTP_VERSION_2;
+ else if(!memcmp(version_str,"3",1))
+ return HTTP_VERSION_3;
+ else
+ return HTTP_VERSION_1_1;
+}
+
+static int http_header_read(mbtk_http_session_t *session)
+{
+#define BUFFER_SIZE 2048
+ char line[BUFFER_SIZE];
+ char *ptr = NULL;
+ int len = 0;
+ while((len = mbtk_http_read_line(session->sock_fd,line,BUFFER_SIZE)) > 0)
+ {
+ if(!memcmp(line,"\r\n",2))
+ {
+ RLOGD("Read empty line.");
+ break;
+ }
+
+ // Delete "\r\n"
+ ptr = line + len - 1; // Point to last char.
+ while(http_is_space_char(*ptr))
+ {
+ *ptr = '\0';
+ len--;
+ ptr--;
+ }
+
+ RLOGD("LINE:%s",line);
+
+ if(http_handles[session->handle_id].show_rsp_header &&
+ http_handles[session->handle_id].data_cb)
+ {
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_HEADER,line,len);
+ }
+
+ if(!memcmp(line,"HTTP/",5)) // "HTTP/1.1 200 OK"
+ {
+ session->rsp.state_code = atoi(line + 9);
+ session->rsp.version = http_version_get_by_str(line + 5);
+ }
+ else // Is response header item.
+ {
+ if(!strncasecmp(line,"Content-Length",14))
+ {
+ ptr = line + 14;
+ while(ptr && !isdigit(*ptr))
+ {
+ ptr++;
+ }
+
+ if(ptr)
+ {
+ session->rsp.content_length = atol(ptr);
+ }
+ }
+ else if(!strncasecmp(line,"Transfer-Encoding",17))
+ {
+ ptr = line + 17;
+ while(ptr && !isalpha(*ptr))
+ {
+ ptr++;
+ }
+
+ if(ptr && !memcmp(ptr,"chunked",7))
+ {
+ session->rsp.is_chunked = TRUE;
+ }
+ }
+ }
+ }
+#undef BUFFER_SIZE
+
+ RLOGD("RSP:HTTP/%s %d, is_chunked:%d,Content-Length:%d",http_version_str_get(session->rsp.version),
+ session->rsp.state_code,session->rsp.is_chunked,session->rsp.content_length);
+
+ return 0;
+}
+
+static int http_session_start_write(mbtk_http_session_t *session)
+{
+ RLOGD("Start HTTP write.");
+
+#define BUFFER_SIZE 1024
+ session->state = HTTP_SESSION_STATE_WRITE_HEADER;
+ char buff[BUFFER_SIZE];
+ int len = 0;
+ int index = 0;
+ len += snprintf(buff + len,BUFFER_SIZE - len,"%s %s HTTP/%s\r\n",
+ http_option_str_get(session->option),
+ session->uri,
+ http_version_str_get(session->version));
+
+ // if no set "Host",should set default host.
+ char *host = http_header_find(session,"Host");
+ if(!host)
+ {
+ len += snprintf(buff + len,BUFFER_SIZE - len,"Host: %s\r\n", session->host);
+ }
+
+ if(mbtk_http_write(session->sock_fd,buff,len) != len)
+ {
+ RLOGD("mbtk_http_write() fail.");
+ return -1;
+ }
+
+ char header_str[BUFFER_SIZE];
+ int header_str_len = 0;
+ while(index < HTTP_REQUEST_HEADER_MAX)
+ {
+ if(session->req.req_h[index] &&
+ (header_str_len = http_header_str_get(session->req.req_h[index], header_str, BUFFER_SIZE)) > 0)
+ {
+ if(mbtk_http_write(session->sock_fd,header_str,header_str_len) != header_str_len)
+ {
+ RLOGD("mbtk_http_write() fail.");
+ return -1;
+ }
+ }
+ index++;
+ }
+
+ // Write request header success.
+ RLOGD("HTTP write header complete.");
+
+#undef BUFFER_SIZE
+
+ // Write "\r\n"
+ if(mbtk_http_write(session->sock_fd,"\r\n",2) != 2)
+ {
+ RLOGD("mbtk_http_write() fail.");
+ return -1;
+ }
+
+ RLOGD("Start write HTTPsession->option. %d", session->option);
+ if(session->option == HTTP_OPTION_POST)
+ {
+ session->state = HTTP_SESSION_STATE_WRITE_CONTENT;
+ RLOGD("Start write HTTP content data.");
+
+ if(session->req.content && session->req.content_len > 0)
+ {
+ if(mbtk_http_write(session->sock_fd,session->req.content,session->req.content_len) != session->req.content_len)
+ {
+ RLOGD("mbtk_http_write() fail.");
+ return -1;
+ }
+
+ session->state = HTTP_SESSION_STATE_WRITE_END;
+ }
+ }
+ else
+ {
+ session->state = HTTP_SESSION_STATE_WRITE_END;
+
+ RLOGD("HTTP write complete.");
+ }
+ return 0;
+}
+
+/*static int http_session_read_by_chunk(mbtk_http_session_t *session)
+{
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 2048
+ http_chunk_code chunk_code;
+ http_chunker_t chunker;
+ char read_buf[BUFFER_SIZE + 1];
+ int read_len = 0;
+ char chunk_buf[BUFFER_SIZE + 1];
+ int chunk_len;
+ http_chunk_init(&chunker);
+ while(TRUE)
+ {
+ read_len = mbtk_http_read(session->sock_fd,read_buf,BUFFER_SIZE,3000);
+ //read_len = mbtk_http_read_line(session->sock_file,read_buf,BUFFER_SIZE);
+ if(read_len <= 0)
+ {
+ RLOGD("Read fail.");
+ return -1;
+ }
+
+ chunk_code = http_chunk_parse(&chunker, read_buf, read_len, chunk_buf, &chunk_len);
+ if(chunk_code > CHUNKE_OK) // Fail.
+ {
+ RLOGD("http_chunk_parse() fail[err - %d].",chunk_code);
+ return -1;
+ }
+
+ RLOGD("Read chunk_len:%d",chunk_len);
+ chunk_buf[chunk_len] = '\0';
+
+ if(http_handles[session->handle_id].data_cb)
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_CONTENT,chunk_buf,chunk_len);
+
+ if(CHUNKE_STOP == chunk_code)
+ {
+ if(http_handles[session->handle_id].data_cb)
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_COMPLETE,NULL,0);
+
+ break;
+ }
+ }
+
+ RLOGD("Chunk read success.");
+
+ return 0;
+}*/
+
+static int http_session_read_by_length(mbtk_http_session_t *session)
+{
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 2048
+ char read_buf[BUFFER_SIZE + 1];
+ int read_len = 0;
+ int64 read_count = 0;
+ while(TRUE)
+ {
+ memset(read_buf,0x0,BUFFER_SIZE + 1);
+ read_len = mbtk_http_read(session->sock_fd,read_buf,BUFFER_SIZE,3000);
+ if(read_len <= 0)
+ {
+ RLOGD("Read fail.");
+ return -1;
+ }
+
+ if(read_count + read_len >= session->rsp.content_length) // Read data complete.
+ {
+ if(http_handles[session->handle_id].data_cb)
+ {
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_CONTENT,read_buf,session->rsp.content_length - read_count);
+
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_COMPLETE,NULL,0);
+ }
+ break;
+ }
+
+ if(http_handles[session->handle_id].data_cb)
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_CONTENT,read_buf,read_len);
+
+ read_count += read_len;
+ }
+
+ return 0;
+}
+
+static int http_session_read_by_general(mbtk_http_session_t *session)
+{
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 2048
+ char read_buf[BUFFER_SIZE + 1];
+ int read_len = 0;
+ while(TRUE)
+ {
+ read_len = mbtk_http_read(session->sock_fd,read_buf,BUFFER_SIZE,1000);
+ if(read_len <= 0)
+ {
+ if(read_len == -2 || read_len == 0) // Timeout or end
+ break;
+
+ RLOGD("Read end[read_len - %d].",read_len);
+ //return -1;
+ break;
+ }
+
+ read_buf[read_len] = '\0';
+
+ if(http_handles[session->handle_id].data_cb)
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_CONTENT,read_buf,read_len);
+ }
+
+ if(http_handles[session->handle_id].data_cb)
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_COMPLETE,NULL,0);
+
+ return 0;
+}
+
+static int http_session_start_read(mbtk_http_session_t *session)
+{
+ RLOGD("Start HTTP read.");
+ int result = 0;
+// usleep(500000);
+ session->state = HTTP_SESSION_STATE_READ_HEADER;
+ if(http_header_read(session))
+ {
+ result = -1;
+ goto read_end;
+ }
+
+ if(session->option != HTTP_OPTION_HEAD)
+ {
+ session->state = HTTP_SESSION_STATE_READ_CONTENT;
+ /*if(session->rsp.is_chunked)
+ {
+ if(http_session_read_by_chunk(session))
+ {
+ result = -1;
+ goto read_end;
+ }
+ }*/
+ if(session->rsp.content_length > 0)
+ {
+ if(http_session_read_by_length(session))
+ {
+ result = -1;
+ goto read_end;
+ }
+ }
+ else
+ {
+ if(http_session_read_by_general(session))
+ {
+ result = -1;
+ goto read_end;
+ }
+ }
+ }
+ else
+ {
+ if(http_handles[session->handle_id].data_cb)
+ http_handles[session->handle_id].data_cb(session->id,
+ MBTK_HTTP_DATA_COMPLETE,NULL,0);
+ }
+
+read_end:
+ session->state = HTTP_SESSION_STATE_READ_END;
+
+ RLOGD("HTTP request complete[result - %d].",result);
+ if(http_session_close(session))
+ {
+ return -1;
+ }
+
+#if 0
+ // Free session after HTTP request complete.
+ http_session_free(session);
+ http_handles[handle_id].session[session_id] = NULL;
+ http_handles[handle_id].session_cnt--;
+#endif
+
+ return result;
+}
+
+static bool http_session_req_check(mbtk_http_session_t *session)
+{
+ if(session == NULL || session->port == 0 ||
+ strlen(session->host) == 0)
+ {
+ RLOGD("Session not set host or port.");
+ return FALSE;
+ }
+
+ if(session->option != HTTP_OPTION_HEAD &&
+ session->option != HTTP_OPTION_POST &&
+ session->option != HTTP_OPTION_GET)
+ {
+ RLOGD("Only support HEAD/GET/POST");
+ return FALSE;
+ }
+
+#if 0
+ if(session->version != HTTP_VERSION_1_0 &&
+ session->version != HTTP_VERSION_1_1)
+ {
+ RLOGD("Only support HTTP 1.0/1.1");
+ return FALSE;
+ }
+#endif
+
+ if(session->option == HTTP_OPTION_POST)
+ {
+ char *value = NULL;
+ value = http_header_find(session, "Content-Length");
+ if(!value)
+ {
+ RLOGD("POST must set 'Content-Length'");
+ return FALSE;
+ }
+ if(session->req.content_len != atoi(value))
+ {
+ RLOGD("POST 'Content-Length' error.");
+ return FALSE;
+ }
+
+ value = http_header_find(session, "Content-Type");
+ if(!value)
+ {
+ RLOGD("POST must set 'Content-Type'");
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+
+/*************************************************************
+ Public Function Definitions
+*************************************************************/
+int mbtk_http_handle_get(bool show_rsp_header,mbtk_http_data_callback_func data_cb)
+{
+ int index = 0;
+ int i = 0;
+ for(; index < HTTP_HANDLE_MAX; index++)
+ {
+ if(http_handles[index].id < 0) // Find free handle
+ {
+ break;
+ }
+ }
+
+ if(index == HTTP_HANDLE_MAX)
+ {
+ RLOGD("HTTP Handle is full.");
+ return -1;
+ }
+
+ memset(&(http_handles[index]),0x0,sizeof(mbtk_http_handle_t));
+ http_handles[index].id = index;
+ http_handles[index].show_rsp_header = show_rsp_header;
+ http_handles[index].data_cb = data_cb;
+ http_handles[index].session_cnt = 0;
+ for(i = 0; i < HTTP_SESSION_MAX; i++)
+ {
+ http_handles[index].session[i] = NULL;
+ }
+
+ if(mbtk_http_init())
+ {
+ RLOGD("mbtk_http_init() fail.");
+ return -1;
+ }
+
+ return http_handles[index].id;
+}
+
+int mbtk_http_handle_free(int handle_id)
+{
+ int i = 0;
+ if(!http_handle_check(handle_id))
+ {
+ RLOGD("Handle error.");
+ return -1;
+ }
+
+ http_handles[handle_id].id = -1;
+ http_handles[handle_id].data_cb = NULL;
+ if(http_handles[handle_id].session_cnt > 0)
+ {
+ for(i = 0; i < HTTP_SESSION_MAX; i++)
+ {
+ if(http_handles[handle_id].session[i] != NULL)
+ {
+ if(http_handles[handle_id].session[i]->state != HTTP_SESSION_STATE_NON)
+ {
+ if(http_session_close(http_handles[handle_id].session[i]))
+ {
+ return -1;
+ }
+ }
+
+ http_session_free(http_handles[handle_id].session[i]);
+ http_handles[handle_id].session[i] = NULL;
+ }
+ }
+
+ http_handles[handle_id].session_cnt = 0;
+ }
+
+ if(mbtk_http_deinit())
+ {
+ RLOGD("mbtk_http_deinit() fail.");
+ return -1;
+ }
+
+ return 0;
+}
+
+int mbtk_http_session_create(int handle_id, mbtk_http_option_enum option,
+ mbtk_http_version_enum version)
+{
+ int handle_index = 0;
+ int session_index = 0;
+ if(!http_handle_check(handle_id))
+ {
+ RLOGD("Handle error.");
+ return -1;
+ }
+
+ for(; handle_index < HTTP_HANDLE_MAX; handle_index++)
+ {
+ if(http_handles[handle_index].id == handle_id) // Find handle
+ {
+ break;
+ }
+ }
+
+ if(handle_index == HTTP_HANDLE_MAX)
+ {
+ RLOGD("No found handle[handle - %d].",handle_id);
+ return -1;
+ }
+
+ if(http_handles[handle_index].session_cnt >= HTTP_SESSION_MAX)
+ {
+ RLOGD("Session is full.");
+ return -1;
+ }
+
+ for(; session_index < HTTP_SESSION_MAX; session_index++)
+ {
+ if(http_handles[handle_index].session[session_index] == NULL) // Find first NULL session
+ {
+ break;
+ }
+ }
+
+ if(session_index == HTTP_SESSION_MAX)
+ {
+ RLOGD("Session is full.");
+ return -1;
+ }
+
+ mbtk_http_session_t* session = (mbtk_http_session_t*)malloc(sizeof(mbtk_http_session_t));
+ if(session == NULL)
+ {
+ RLOGD("malloc() fail.");
+ return -1;
+ }
+ memset(session,0x0,sizeof(mbtk_http_session_t));
+ session->sock_fd = -1;
+ session->sock_file = NULL;
+ session->handle_id = handle_id;
+ session->id = session_index;
+ session->state = HTTP_SESSION_STATE_NON;
+ session->is_ssl = FALSE;
+ session->version = version;
+ session->option = option;
+ session->req.content_len = 0;
+ session->req.content_len_send = 0;
+ session->rsp.is_chunked = FALSE;
+ session->rsp.content_length = 0;
+ session->rsp.header_cnt = 0;
+ http_handles[handle_index].session[session_index] = session;
+ http_handles[handle_index].session_cnt++;
+
+ return session->id;
+}
+
+int mbtk_http_session_option_reset(int handle_id, int session_id, mbtk_http_option_enum option)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return -1;
+ }
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state != HTTP_SESSION_STATE_NON)
+ {
+ RLOGD("Session state error.[%d]",session->state);
+ return -1;
+ }
+
+ session->option = option;
+ return 0;
+}
+
+int mbtk_http_session_free(int handle_id,int session_id)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return -1;
+ }
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state != HTTP_SESSION_STATE_NON)
+ {
+ if(http_session_close(session))
+ {
+ return -1;
+ }
+ }
+
+ http_session_free(session);
+ http_handles[handle_id].session[session_id] = NULL;
+ http_handles[handle_id].session_cnt--;
+ return 0;
+}
+
+int mbtk_http_session_url_set(int handle_id,int session_id,void *url)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return -1;
+ }
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state == HTTP_SESSION_STATE_NON)
+ return http_url_parse(url, session->host,session->uri,&(session->port),&(session->is_ssl));
+ else
+ {
+ RLOGD("Currenr session is process[state - %d].",session->state);
+ return -1;
+ }
+}
+
+int mbtk_http_session_head_add(int handle_id,int session_id,
+ char *name, char *value)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return -1;
+ }
+
+ if(http_str_empty(name) || http_str_empty(value))
+ {
+ RLOGD("Param error.");
+ return -1;
+ }
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state == HTTP_SESSION_STATE_NON)
+ {
+ int result = http_session_req_head_add(session,TRUE,name,value);
+ if(!result && !strncasecmp(name,"Content-Length",14))
+ {
+ session->req.content_len = atoi(value);
+ }
+ return result;
+ }
+ else
+ {
+ RLOGD("Currenr session is process[state - %d].",session->state);
+ return -1;
+ }
+}
+
+int mbtk_http_session_content_set(int handle_id,int session_id,
+ char *content,uint32 content_len)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return -1;
+ }
+
+ if(content_len <= 0 || content_len > HTTP_CONTENT_LEN_MAX)
+ {
+ RLOGD("Content lenght error[%d].",content_len);
+ return -1;
+ }
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state == HTTP_SESSION_STATE_NON)
+ {
+ if(session->option != HTTP_OPTION_POST)
+ {
+ RLOGD("Content only for post.");
+ return -1;
+ }
+
+ if(session->req.content)
+ {
+ free(session->req.content);
+ session->req.content_len = 0;
+ }
+
+ session->req.content = (char*)malloc(content_len);
+ if(session->req.content == NULL)
+ {
+ RLOGD("malloc() fail.");
+ return -1;
+ }
+
+ char *content_type = NULL;
+ if(strlen(content) == content_len) //
+ {
+ content_type = "text/plain";
+ }
+ else
+ {
+ content_type = "application/octet-stream";
+ }
+
+ if(http_session_req_head_add(session, FALSE, "Content-Type", content_type))
+ {
+ RLOGD("Set 'Content-Type' fail.");
+ return -1;
+ }
+
+ memcpy(session->req.content,content,content_len);
+ session->req.content_len = content_len;
+
+ char len_str[20] = {0};
+ snprintf(len_str,20,"%d",content_len);
+ if(http_session_req_head_add(session,FALSE,"Content-Length",len_str))
+ {
+ RLOGD("Set 'Content-Length' fail.");
+ return -1;
+ }
+
+
+ return 0;
+ }
+ else
+ {
+ RLOGD("Currenr session is process[state - %d].",session->state);
+ return -1;
+ }
+}
+
+int mbtk_http_session_start(int handle_id,int session_id)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ printf("Session error.");
+ return -1;
+ }
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state == HTTP_SESSION_STATE_NON)
+ {
+ if(!http_session_req_check(session))
+ {
+ printf("http_session_req_check() fail.");
+ return -1;
+ }
+
+ // Must set "Connection" for post.
+ if(session->option == HTTP_OPTION_POST)
+ {
+ if(http_session_req_head_add(session,FALSE,"Connection","KeepAlive"))
+ {
+ printf("Set 'Content-Length' fail.");
+ return -1;
+ }
+ }
+
+ printf("HTTP request start.\n");
+ printf("host:%s\n, port:%d\n, uri:%s\n",session->host,session->port,session->uri);
+ printf("is_ssl:%d\n, version:%d\n, option:%d\n, content_len:%d\n",session->is_ssl,
+ session->version,session->option,session->req.content_len);
+
+ int sock_fd = mbtk_http_open(session->host,&(session->port));//session->is_ssl,TRUE,
+ if(sock_fd < 0)
+ {
+ printf("open fail\n");
+ return -1;
+ }
+ session->sock_fd = sock_fd;
+// int fd = mbtk_sock_fd_get(sock_fd);
+// if(fd < 0) {
+// LOGE("mbtk_sock_fd_get() fail.");
+// return -1;
+// }
+ // session->sock_file = fdopen(sock_fd,"r");
+ session->state = HTTP_SESSION_STATE_CONN;
+
+// if(!session->sock_file) {
+// LOGE("fdopen() fail.");
+// return -1;
+// }
+
+ printf("HTTP connected.");
+
+ if(http_session_start_write(session))
+ {
+ return -1;
+ }
+
+ if(session->state == HTTP_SESSION_STATE_WRITE_END)
+ {
+ if(http_session_start_read(session))
+ {
+ return -1;
+ }
+ }
+ else
+ {
+ printf("Waitting post content data...");
+ }
+
+ return 0;
+ }
+ else
+ {
+ printf("Currenr session is process[state - %d].",session->state);
+ return -1;
+ }
+}
+
+int mbtk_http_session_content_send(int handle_id,int session_id,
+ char *data,int data_len)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return -1;
+ }
+
+ if(data_len <= 0 || data_len > HTTP_CONTENT_LEN_MAX)
+ {
+ RLOGD("Content lenght error[%d].",data_len);
+ return -1;
+ }
+
+ RLOGD("Post send:%d - %s",data_len,data);
+
+ mbtk_http_session_t *session = http_handles[handle_id].session[session_id];
+ if(session->state == HTTP_SESSION_STATE_WRITE_CONTENT)
+ {
+ if(session->option != HTTP_OPTION_POST)
+ {
+ RLOGD("Content only for post.");
+ return -1;
+ }
+
+ if(session->req.content || session->req.content_len <= 0)
+ {
+ RLOGD("This post not spit package.");
+ return -1;
+ }
+
+ // Discard excess data.
+ if(session->req.content_len_send + data_len > session->req.content_len)
+ data_len = session->req.content_len - session->req.content_len_send;
+
+ if(data_len != mbtk_http_write(session->sock_fd,data,data_len))
+ {
+ return -1;
+ }
+
+ session->req.content_len_send += data_len;
+
+ RLOGD("HTTP post data send: %d / %d",session->req.content_len_send,
+ session->req.content_len);
+
+ // Post data send complete.
+ if(session->req.content_len_send >= session->req.content_len)
+ {
+ session->state = HTTP_SESSION_STATE_WRITE_END;
+
+ RLOGD("HTTP write complete.");
+ if(http_session_start_read(session))
+ {
+ return -1;
+ }
+ }
+
+ return 0;
+ }
+ else
+ {
+ RLOGD("Currenr session state error[%d].",session->state);
+ return -1;
+ }
+}
+
+const mbtk_http_session_t* mbtk_http_session_get(int handle_id,int session_id)
+{
+ if(!http_session_check(handle_id,session_id))
+ {
+ RLOGD("Session error.");
+ return NULL;
+ }
+
+ return http_handles[handle_id].session[session_id];
+}
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_http_base.cpp b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_http_base.cpp
new file mode 100755
index 0000000..607a199
--- /dev/null
+++ b/cap/zx297520v3/src/lynq/lib/liblynq-qser-gnss/src/mbtk_http_base.cpp
@@ -0,0 +1,240 @@
+#include <sys/epoll.h>
+#include <string.h>
+#include <log/log.h>
+#include <liblog/lynq_deflog.h>
+//#include "mbtk_log.h"
+#include "mbtk_http_base.h"
+#include "mbtk_http.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static bool http_sock_inited = FALSE;
+static int http_handle = -1;
+static int http_fd = -1;
+//static void http_sock_cb_func(int handle, int fd, int event);
+
+/*static mbtk_init_info =
+{
+ MBTK_NET_LINUX,
+ NULL,
+ http_sock_cb_func
+} http_init_info;*/
+
+
+
+/*static void http_sock_cb_func(int handle, int fd, int event)
+{
+ if(http_handle == handle && http_fd == fd) {
+ if(event & EPOLLIN) { // READ
+
+ } else if(event & EPOLLRDHUP) { // Close
+
+ } else {
+ RLOGD("Unknown event:%x",event);
+ }
+ }
+}*/
+
+int mbtk_sock_open()
+{
+
+ return 0;
+}
+
+int mbtk_http_init()
+{
+ if(http_sock_inited) {
+ RLOGD("HTTP has inited.");
+ return -1;
+ }
+
+ http_handle = socket(AF_INET,SOCK_STREAM,0);
+ if(http_handle < 0)
+ {
+ RLOGD("mbtk_sock_init() fail.");
+ return -1;
+ }
+
+ http_sock_inited = TRUE;
+ return 0;
+}
+
+int mbtk_http_deinit()
+{
+ if(!http_sock_inited) {
+ RLOGD("HTTP not inited.");
+ return -1;
+ }
+
+ close(http_handle);
+ http_handle = -1;
+ http_sock_inited = FALSE;
+ return 0;
+}
+
+
+int mbtk_http_open
+(
+ const void *host,
+ int *port
+)
+{
+ struct addrinfo server;
+ struct addrinfo* serverInfo;
+ int ret;
+
+ server.ai_family = AF_INET;
+ server.ai_socktype = SOCK_STREAM;
+ server.ai_protocol = IPPROTO_TCP;
+ server.ai_flags = AI_PASSIVE;
+ char portStr[6];
+ snprintf(portStr, sizeof(portStr), "%d", *port);
+ memset(&server, 0, sizeof(server));
+ ret = getaddrinfo(host, portStr, &server, &serverInfo);
+ if (ret != 0)
+ {
+ printf("ret = %s\n",gai_strerror(ret));
+ printf("getaddrinfo error: \n");
+ return -1;
+ }
+ ret = connect(http_handle, serverInfo->ai_addr, serverInfo->ai_addrlen);
+ if(ret < 0)
+ {
+ printf("connect fail http_handle:%d\n",http_handle);
+ close(http_handle);
+ freeaddrinfo(serverInfo);
+ return -1;
+ }
+ printf("http_handle: %d\n",http_handle);
+ return http_handle;
+}
+
+/*=============================================
+FUNCTION
+ mbtk_http_read
+
+DESCRIPTION
+ read content from socket.
+
+DEPENDENCIES
+ None
+
+PARAMETERS
+ *buf Store read content.
+ len the length of Content.
+ timeout Set timeout
+
+RETURN VALUE
+ Length of read content
+
+SIDE EFFECTS
+ None
+=============================================*/
+int mbtk_http_read
+(
+ int sock_fd,
+ void *buf,
+ uint16_t len,
+ int timeout_ms
+)
+{
+ sleep(timeout_ms / 1000);
+ int read_len = recv(sock_fd, buf, len, 0);
+ if(read_len < 0)
+ {
+ return -1;
+ }
+ else
+ {
+ return read_len;
+ }
+}
+
+
+int mbtk_http_read_line
+(
+ int sock_fd,
+ void *buf,
+ uint16_t len
+)
+{
+ if(sock_fd > 0) {
+ char *buf_ptr = (char*)buf;
+ char read_buf[1];
+ int read_len = 0;
+ while(TRUE) {
+ if(recv(sock_fd, read_buf, 1, 0) == 1) {
+ *buf_ptr++ = read_buf[0];
+ read_len++;
+
+ if(read_buf[0] == '\n' || read_len >= len) {
+ return read_len;
+ }
+ } else {
+ return -1;
+ }
+ }
+ }
+
+
+ return -1;
+}
+
+
+/*=============================================
+FUNCTION
+ mbtk_http_write
+
+DESCRIPTION
+ Write content to socket.
+
+DEPENDENCIES
+ None
+
+PARAMETERS
+ *buf Content to be transferred
+ len the length of Content.
+
+RETURN VALUE
+ Length of written content
+
+SIDE EFFECTS
+ None
+=============================================*/
+int mbtk_http_write(int sock_fd, void *buf, uint16_t len)
+{
+ RLOGD("Write[%d]:%s",len,(char*)buf);
+ return send(sock_fd, buf, len, 0);
+}
+
+/*=============================================
+FUNCTION
+ mbtk_http_close
+
+DESCRIPTION
+ close HTTP service.
+
+DEPENDENCIES
+ None
+
+PARAMETERS
+ *err Error number
+
+RETURN VALUE
+ TURE or FALSE
+
+SIDE EFFECTS
+ None
+=============================================*/
+int mbtk_http_close(int sock_fd)
+{
+
+ close(sock_fd);
+ sock_fd = -1;
+ return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file