Commit 6d70a831 authored by captainwong's avatar captainwong

prettier, nothing new

parent 8770892b
This diff is collapsed.
This diff is collapsed.
#!/bin/bash
set -e
CURRENT_DIR=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
cd ${CURRENT_DIR}
mkdir -p ./uvlib
cp -r /g/dev_libs/ademco/uvlib/llhttp ./uvlib/
cp /g/dev_libs/ademco/uvlib/*.h ./uvlib/
cp /g/dev_libs/ademco/uvlib/*.c ./uvlib/
\ No newline at end of file
This diff is collapsed.
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup> <ItemGroup>
<Filter Include="Source Files"> <Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier> <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions> <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter> </Filter>
<Filter Include="Header Files"> <Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier> <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions> <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter> </Filter>
<Filter Include="Resource Files"> <Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier> <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions> <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter> </Filter>
<Filter Include="ademco"> <Filter Include="ademco">
<UniqueIdentifier>{e5563916-4ea7-4065-9be4-f34d41d6e97f}</UniqueIdentifier> <UniqueIdentifier>{e5563916-4ea7-4065-9be4-f34d41d6e97f}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="uvlib"> <Filter Include="uvlib">
<UniqueIdentifier>{ccce695b-7cff-4961-8c57-f722d12402cb}</UniqueIdentifier> <UniqueIdentifier>{ccce695b-7cff-4961-8c57-f722d12402cb}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="uvlib\llhttp"> <Filter Include="uvlib\llhttp">
<UniqueIdentifier>{d87a50b2-ba54-4102-940a-ec65bb393464}</UniqueIdentifier> <UniqueIdentifier>{d87a50b2-ba54-4102-940a-ec65bb393464}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="cJSON"> <Filter Include="cJSON">
<UniqueIdentifier>{7d7954ed-fb8d-4e25-9f82-2c8780f8b7b8}</UniqueIdentifier> <UniqueIdentifier>{7d7954ed-fb8d-4e25-9f82-2c8780f8b7b8}</UniqueIdentifier>
</Filter> </Filter>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="..\..\ademco.c"> <ClCompile Include="..\..\ademco.c">
<Filter>ademco</Filter> <Filter>ademco</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\hb_com.c"> <ClCompile Include="..\..\hb_com.c">
<Filter>ademco</Filter> <Filter>ademco</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="httprelay.c"> <ClCompile Include="httprelay.c">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\llhttp\src\api.c"> <ClCompile Include="uvlib\llhttp\src\api.c">
<Filter>uvlib\llhttp</Filter> <Filter>uvlib\llhttp</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\llhttp\src\http.c"> <ClCompile Include="uvlib\llhttp\src\http.c">
<Filter>uvlib\llhttp</Filter> <Filter>uvlib\llhttp</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\llhttp\src\llhttp.c"> <ClCompile Include="uvlib\llhttp\src\llhttp.c">
<Filter>uvlib\llhttp</Filter> <Filter>uvlib\llhttp</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\mybuf.c"> <ClCompile Include="uvlib\mybuf.c">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\uv_httpd.c"> <ClCompile Include="uvlib\uv_httpd.c">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\uv_log.c"> <ClCompile Include="uvlib\uv_log.c">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\uv_tcpserver.c"> <ClCompile Include="uvlib\uv_tcpserver.c">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\uv_httpc.c"> <ClCompile Include="uvlib\uv_httpc.c">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="uvlib\uv_tcpclient.c"> <ClCompile Include="uvlib\uv_tcpclient.c">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="cJSON\cJSON.c"> <ClCompile Include="cJSON\cJSON.c">
<Filter>cJSON</Filter> <Filter>cJSON</Filter>
</ClCompile> </ClCompile>
</ItemGroup> <ClCompile Include="uvlib\uv_tcp.c">
<ItemGroup> <Filter>uvlib</Filter>
<ClInclude Include="..\..\ademco.h"> </ClCompile>
<Filter>ademco</Filter> </ItemGroup>
</ClInclude> <ItemGroup>
<ClInclude Include="..\..\hb_com.h"> <ClInclude Include="..\..\ademco.h">
<Filter>ademco</Filter> <Filter>ademco</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\list.h"> <ClInclude Include="..\..\hb_com.h">
<Filter>uvlib</Filter> <Filter>ademco</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\mybuf.h"> <ClInclude Include="uvlib\list.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_http.h"> <ClInclude Include="uvlib\mybuf.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_httpd.h"> <ClInclude Include="uvlib\uv_http.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_log.h"> <ClInclude Include="uvlib\uv_httpd.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_tcp.h"> <ClInclude Include="uvlib\uv_log.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_tcpserver.h"> <ClInclude Include="uvlib\uv_tcp.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_httpc.h"> <ClInclude Include="uvlib\uv_tcpserver.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="uvlib\uv_tcpclient.h"> <ClInclude Include="uvlib\uv_httpc.h">
<Filter>uvlib</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="cJSON\cJSON.h"> <ClInclude Include="uvlib\uv_tcpclient.h">
<Filter>cJSON</Filter> <Filter>uvlib</Filter>
</ClInclude> </ClInclude>
</ItemGroup> <ClInclude Include="cJSON\cJSON.h">
<Filter>cJSON</Filter>
</ClInclude>
</ItemGroup>
</Project> </Project>
\ No newline at end of file
#ifndef __LIST_H__ #ifndef __LIST_H__
#define __LIST_H__ #define __LIST_H__
#pragma once #pragma once
#define list_append(type, l, node) \ #define list_append(type, l, node) \
do { \ do { \
type* tail_ = (l); \ type* tail_ = (l); \
while (tail_ && tail_->next) \ while (tail_ && tail_->next) \
tail_ = tail_->next; \ tail_ = tail_->next; \
if (tail_) \ if (tail_) \
tail_->next = (node); \ tail_->next = (node); \
else \ else \
(l) = node; \ (l) = node; \
} while (0); } while (0);
#endif
#endif
#include <stdio.h> #include "mybuf.h"
#include <stdlib.h>
#include <string.h> #include <stdarg.h>
#include <stdarg.h> #include <stdio.h>
#include "mybuf.h" #include <stdlib.h>
#include "uv_log.h" #include <string.h>
void mybuf_init(mybuf_t* buf) { #include "uv_log.h"
buf->buf = buf->mybuf;
buf->size = 0; void mybuf_init(mybuf_t* buf) {
buf->capacity = MYBUF_DEFAULT_SIZE; buf->buf = buf->mybuf;
} buf->size = 0;
buf->capacity = MYBUF_DEFAULT_SIZE;
size_t mybuf_space(mybuf_t* buf) { }
return buf->capacity - buf->size;
} size_t mybuf_space(mybuf_t* buf) {
return buf->capacity - buf->size;
void mybuf_reserve(mybuf_t* buf, size_t size) { }
if (mybuf_space(buf) < size) {
//fprintf(stderr, "WARN: mybuf_t not enough, space=%zu, needed=%zu\n", mybuf_space(buf), size); void mybuf_reserve(mybuf_t* buf, size_t size) {
while (mybuf_space(buf) < size) { if (mybuf_space(buf) < size) {
buf->capacity *= 2; // fprintf(stderr, "WARN: mybuf_t not enough, space=%zu, needed=%zu\n", mybuf_space(buf), size);
} while (mybuf_space(buf) < size) {
if (buf->buf == buf->mybuf) { buf->capacity *= 2;
buf->buf = (char*)malloc(buf->capacity); }
fatal_if_null(buf->buf); if (buf->buf == buf->mybuf) {
memcpy(buf->buf, buf->mybuf, buf->size); buf->buf = (char*)malloc(buf->capacity);
} else { fatal_if_null(buf->buf);
char* tmp = (char*)realloc(buf->buf, buf->capacity); memcpy(buf->buf, buf->mybuf, buf->size);
fatal_if_null(tmp); } else {
buf->buf = tmp; char* tmp = (char*)realloc(buf->buf, buf->capacity);
} fatal_if_null(tmp);
} buf->buf = tmp;
} }
}
void mybuf_append(mybuf_t* buf, const char* data, size_t len) { }
if (mybuf_space(buf) >= len) {
memcpy(buf->buf + buf->size, data, len); void mybuf_append(mybuf_t* buf, const char* data, size_t len) {
buf->size += len; if (mybuf_space(buf) >= len) {
} else { memcpy(buf->buf + buf->size, data, len);
//fprintf(stderr, "WARN: mybuf_t not enough, space=%zu, needed=%zu\n", mybuf_space(buf), len); buf->size += len;
while (mybuf_space(buf) < len) { } else {
buf->capacity *= 2; // fprintf(stderr, "WARN: mybuf_t not enough, space=%zu, needed=%zu\n", mybuf_space(buf), len);
} while (mybuf_space(buf) < len) {
if (buf->buf == buf->mybuf) { buf->capacity *= 2;
buf->buf = (char*)malloc(buf->capacity); }
fatal_if_null(buf->buf); if (buf->buf == buf->mybuf) {
memcpy(buf->buf, buf->mybuf, buf->size); buf->buf = (char*)malloc(buf->capacity);
} else { fatal_if_null(buf->buf);
char* tmp = (char*)realloc(buf->buf, buf->capacity); memcpy(buf->buf, buf->mybuf, buf->size);
fatal_if_null(tmp); } else {
buf->buf = tmp; char* tmp = (char*)realloc(buf->buf, buf->capacity);
} fatal_if_null(tmp);
memcpy(buf->buf + buf->size, data, len); buf->buf = tmp;
buf->size += len; }
} memcpy(buf->buf + buf->size, data, len);
} buf->size += len;
}
static void mybuf_cat_vprintf(mybuf_t* buf, const char* fmt, va_list ap) { }
va_list cpy;
int l; static void mybuf_cat_vprintf(mybuf_t* buf, const char* fmt, va_list ap) {
va_list cpy;
while (1) { int l;
va_copy(cpy, ap);
l = vsnprintf(buf->buf + buf->size, mybuf_space(buf), fmt, cpy); while (1) {
va_end(cpy); va_copy(cpy, ap);
if (l < 0) { l = vsnprintf(buf->buf + buf->size, mybuf_space(buf), fmt, cpy);
uvlog_error("mybuf_cat_vprintf error:%d", l); va_end(cpy);
return; if (l < 0) {
} else if ((size_t)l >= mybuf_space(buf)) { uvlog_error("mybuf_cat_vprintf error:%d", l);
mybuf_reserve(buf, (size_t)l + 1); return;
continue; } else if ((size_t)l >= mybuf_space(buf)) {
} else { mybuf_reserve(buf, (size_t)l + 1);
break; continue;
} } else {
} break;
buf->size += (size_t)l; }
} }
buf->size += (size_t)l;
void mybuf_cat_printf(mybuf_t* buf, const char* fmt, ...) { }
va_list ap;
va_start(ap, fmt); void mybuf_cat_printf(mybuf_t* buf, const char* fmt, ...) {
mybuf_cat_vprintf(buf, fmt, ap); va_list ap;
va_end(ap); va_start(ap, fmt);
} mybuf_cat_vprintf(buf, fmt, ap);
va_end(ap);
void mybuf_clear(mybuf_t* buf) { }
if (buf->buf != buf->mybuf) {
free(buf->buf); void mybuf_clear(mybuf_t* buf) {
buf->buf = buf->mybuf; if (buf->buf != buf->mybuf) {
} free(buf->buf);
buf->size = 0; buf->buf = buf->mybuf;
buf->capacity = MYBUF_DEFAULT_SIZE; }
} buf->size = 0;
buf->capacity = MYBUF_DEFAULT_SIZE;
}
void mybuf_clear_append(mybuf_t* buf, const char* data, size_t len) {
mybuf_t tmp;
mybuf_init(&tmp);
mybuf_append(&tmp, data, len);
mybuf_clear(buf);
mybuf_append(buf, tmp.buf, tmp.size);
mybuf_clear(&tmp);
}
#ifndef __MYBUF_H__ #ifndef __MYBUF_H__
#define __MYBUF_H__ #define __MYBUF_H__
#pragma once #pragma once
#include <stddef.h> // size_t #include <stddef.h> // size_t
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef MYBUF_DEFAULT_SIZE #ifndef MYBUF_DEFAULT_SIZE
#define MYBUF_DEFAULT_SIZE 4096 #define MYBUF_DEFAULT_SIZE 4096
#endif #endif
typedef struct { typedef struct {
char* buf; char* buf;
char mybuf[MYBUF_DEFAULT_SIZE]; char mybuf[MYBUF_DEFAULT_SIZE];
size_t size, capacity; size_t size, capacity;
}mybuf_t; } mybuf_t;
void mybuf_init(mybuf_t* buf); void mybuf_init(mybuf_t* buf);
size_t mybuf_space(mybuf_t* buf); size_t mybuf_space(mybuf_t* buf);
void mybuf_reserve(mybuf_t* buf, size_t size); void mybuf_reserve(mybuf_t* buf, size_t size);
void mybuf_append(mybuf_t* buf, const char* data, size_t len); void mybuf_append(mybuf_t* buf, const char* data, size_t len);
#ifdef __GNUC__ #ifdef __GNUC__
void mybuf_cat_printf(mybuf_t* buf, const char* fmt, ...) void mybuf_cat_printf(mybuf_t* buf, const char* fmt, ...)
__attribute__((format(printf, 2, 3))); __attribute__((format(printf, 2, 3)));
#else #else
void mybuf_cat_printf(mybuf_t* buf, const char* fmt, ...); void mybuf_cat_printf(mybuf_t* buf, const char* fmt, ...);
#endif #endif
void mybuf_clear(mybuf_t* buf); void mybuf_clear(mybuf_t* buf);
// safe to call me when data in buf
#ifdef __cplusplus void mybuf_clear_append(mybuf_t* buf, const char* data, size_t len);
}
#endif #ifdef __cplusplus
}
#endif #endif
#endif
#ifndef __UV_HTTP_H__ #ifndef __UV_HTTP_H__
#define __UV_HTTP_H__ #define __UV_HTTP_H__
#pragma once #pragma once
#endif // !__UV_HTTP_H__
#endif // !__UV_HTTP_H__
This diff is collapsed.
// uv http client // uv http client
#ifndef __UV_HTTPC_H__ #ifndef __UV_HTTPC_H__
#define __UV_HTTPC_H__ #define __UV_HTTPC_H__
#pragma once #pragma once
#include <uv.h> #include <uv.h>
#include "mybuf.h"
#include "mybuf.h"
#ifdef __cplusplus
extern "C" { #ifdef __cplusplus
#endif extern "C" {
#endif
typedef struct uv_httpc_s uv_httpc_t;
typedef struct uv_httpc_s uv_httpc_t;
typedef struct uv_httpc_headers_s {
char* data; typedef struct uv_httpc_headers_s {
struct uv_httpc_headers_s* next; char* data;
}uv_httpc_headers_t; struct uv_httpc_headers_s* next;
} uv_httpc_headers_t;
typedef enum {
uv_httpc_ok, typedef enum {
uv_httpc_resolve_failed, uv_httpc_ok,
uv_httpc_connection_failed, uv_httpc_resolve_failed,
uv_httpc_connection_reset, uv_httpc_connection_failed,
uv_httpc_connection_timeout, uv_httpc_connection_reset,
uv_httpc_parse_failed, uv_httpc_connection_timeout,
}uv_httpc_code; uv_httpc_parse_failed,
} uv_httpc_code;
typedef struct uv_httpc_response_s {
uv_httpc_code code; typedef struct uv_httpc_response_s {
int uvcode; uv_httpc_code code;
uv_httpc_headers_t* headers; int uvcode;
int http_status; uv_httpc_headers_t* headers;
char* body; int http_status;
size_t len; char* body;
}uv_httpc_response_t; size_t len;
} uv_httpc_response_t;
typedef void(*uv_httpc_on_response_t)(uv_httpc_t* httpc, uv_httpc_response_t* res);
typedef void (*uv_httpc_on_response_t)(uv_httpc_t* httpc, uv_httpc_response_t* res);
int uv_httpc_create(uv_httpc_t** httpc, uv_loop_t* loop, const char* host, const char* port,
uv_httpc_on_response_t on_response); int uv_httpc_create(uv_httpc_t** httpc, uv_loop_t* loop, const char* host, const char* port,
int uv_httpc_post(uv_httpc_t* httpc, const char* url, uv_httpc_headers_t* headers, uv_httpc_on_response_t on_response);
const char* data, size_t len, int timeout); int uv_httpc_post(uv_httpc_t* httpc, const char* url, uv_httpc_headers_t* headers,
int uv_httpc_stop(uv_httpc_t* httpc); const char* data, size_t len, int timeout);
void uv_httpc_free(uv_httpc_t* httpc); int uv_httpc_stop(uv_httpc_t* httpc);
uv_httpc_headers_t* uv_httpc_headers_append(uv_httpc_headers_t* headers, char* data); void uv_httpc_free(uv_httpc_t* httpc);
uv_httpc_headers_t* uv_httpc_headers_append_nodup(uv_httpc_headers_t* headers, char* data); uv_httpc_headers_t* uv_httpc_headers_append(uv_httpc_headers_t* headers, char* data);
uv_httpc_headers_t* uv_httpc_headers_dup(uv_httpc_headers_t* headers); uv_httpc_headers_t* uv_httpc_headers_append_nodup(uv_httpc_headers_t* headers, char* data);
void uv_httpc_headers_free_all(uv_httpc_headers_t* headers, int freedata); uv_httpc_headers_t* uv_httpc_headers_dup(uv_httpc_headers_t* headers);
void uv_httpc_headers_free_all(uv_httpc_headers_t* headers, int freedata);
#ifdef WEUV_TEST
int uv_httpc_test_main(int argc, char** argv); #ifdef WEUV_TEST
#endif int uv_httpc_test_main(int argc, char** argv);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
This diff is collapsed.
#ifndef __UV_HTTPD_H__ #ifndef __UV_HTTPD_H__
#define __UV_HTTPD_H__ #define __UV_HTTPD_H__
#pragma once #pragma once
#include <uv.h> #include <uv.h>
#include "llhttp/include/llhttp.h" #include "llhttp/include/llhttp.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef struct { typedef struct {
size_t offset; size_t offset;
size_t len; size_t len;
}uv_httpd_string_t; }uv_httpd_string_t;
typedef struct { typedef struct {
uv_httpd_string_t key; uv_httpd_string_t key;
uv_httpd_string_t value; uv_httpd_string_t value;
}uv_httpd_header_t; }uv_httpd_header_t;
typedef struct { typedef struct {
size_t n; size_t n;
uv_httpd_header_t* headers; uv_httpd_header_t* headers;
}uv_httpd_headers_t; }uv_httpd_headers_t;
typedef struct { typedef struct {
char ip[24]; // peer address char ip[24]; // peer address
const char* base; // base address for offset/len const char* base; // base address for offset/len
uv_httpd_string_t remote; // remote address ip:port uv_httpd_string_t remote; // remote address ip:port
llhttp_method_t method; llhttp_method_t method;
uv_httpd_string_t url; uv_httpd_string_t url;
uv_httpd_string_t version; uv_httpd_string_t version;
uv_httpd_headers_t headers; // user should NOT free uv_httpd_headers_t headers; // user should NOT free
uv_httpd_string_t body; uv_httpd_string_t body;
}uv_httpd_request_t; }uv_httpd_request_t;
typedef struct uv_httpd_client_s uv_httpd_client_t; typedef struct uv_httpd_client_s uv_httpd_client_t;
typedef struct uv_httpd_server_s uv_httpd_server_t; typedef struct uv_httpd_server_s uv_httpd_server_t;
typedef void(*on_request_t)(uv_httpd_server_t* server, uv_httpd_client_t* client, uv_httpd_request_t* req); typedef void(*on_request_t)(uv_httpd_server_t* server, uv_httpd_client_t* client, uv_httpd_request_t* req);
void nprintf(const char* msg, size_t len, int newline); void nprintf(const char* msg, size_t len, int newline);
int string_ncmp(const char* s1, size_t len1, const char* s2, size_t len2); int string_ncmp(const char* s1, size_t len1, const char* s2, size_t len2);
int string0_ncmp(const char* s1, const char* s2, size_t len2); int string0_ncmp(const char* s1, const char* s2, size_t len2);
int string_nicmp(const char* s1, size_t len1, const char* s2, size_t len2); int string_nicmp(const char* s1, size_t len1, const char* s2, size_t len2);
int string0_nicmp(const char* s1, const char* s2, size_t len2); int string0_nicmp(const char* s1, const char* s2, size_t len2);
// enable `printf`s, default is disabled // enable `printf`s, default is disabled
void uv_httpd_enable_printf(int enable); void uv_httpd_enable_printf(int enable);
// return 0 for success, otherwise it is `uv_errno_t` // return 0 for success, otherwise it is `uv_errno_t`
// if your want to use a existing `uv_loop_t`, pass it by `loop` // if your want to use a existing `uv_loop_t`, pass it by `loop`
// otherwise a new `uv_loop_t` will be created. // otherwise a new `uv_loop_t` will be created.
int uv_httpd_create(uv_httpd_server_t** server, uv_loop_t* loop, on_request_t on_request); int uv_httpd_create(uv_httpd_server_t** server, uv_loop_t* loop, on_request_t on_request);
void uv_httpd_stop(uv_httpd_server_t* server); void uv_httpd_stop(uv_httpd_server_t* server);
void uv_httpd_free(uv_httpd_server_t* server); void uv_httpd_free(uv_httpd_server_t* server);
// return 0 for success, otherwise it is uv_errno_t // return 0 for success, otherwise it is uv_errno_t
int uv_httpd_listen(uv_httpd_server_t* server, const char* ip, int port); int uv_httpd_listen(uv_httpd_server_t* server, const char* ip, int port);
// return 0 for success, otherwise it is uv_errno_t // return 0 for success, otherwise it is uv_errno_t
int uv_httpd_write_response(uv_httpd_client_t* client, char* response, size_t len); int uv_httpd_write_response(uv_httpd_client_t* client, char* response, size_t len);
struct uv_httpd_server_s { struct uv_httpd_server_s {
uv_tcp_t tcp; uv_tcp_t tcp;
llhttp_settings_t http_settings; llhttp_settings_t http_settings;
on_request_t on_request; on_request_t on_request;
void* data; void* data;
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
#include <stdio.h> #include "uv_log.h"
#include <stdarg.h>
#include <time.h> #include <stdarg.h>
#include <string.h> #include <stdio.h>
#include <uv.h> #include <string.h>
#include "uv_log.h" #include <time.h>
#include <uv.h>
static uv_log_level_t g_level = uv_log_level_info;
static char g_logfile[1024] = { 0 }; static uv_log_level_t g_level = uv_log_level_info;
static char g_logfile[1024] = {0};
void uv_log_set_level(uv_log_level_t level) {
g_level = level; void uv_log_set_level(uv_log_level_t level) {
} g_level = level;
}
void uv_log_set_log_file(const char* file) {
if (file) { void uv_log_set_log_file(const char* file) {
strncpy(g_logfile, file, sizeof(g_logfile)); if (file) {
} else { strncpy(g_logfile, file, sizeof(g_logfile));
g_logfile[0] = '\0'; } else {
} g_logfile[0] = '\0';
} }
}
uv_log_level_t uv_log_get_level() {
return g_level; uv_log_level_t uv_log_get_level() {
} return g_level;
}
void uv_log_raw(uv_log_level_t level, const char* msg) {
size_t off; void uv_log_raw(uv_log_level_t level, const char* msg) {
uv_timeval64_t now; size_t off;
char buf[64]; uv_timeval64_t now;
const char* c = "ADIWEF"; char buf[64];
int log_to_stdout = g_logfile[0] == '\0'; const char* c = "ADIWEF";
FILE* fp = NULL; int log_to_stdout = g_logfile[0] == '\0';
FILE* fp = NULL;
if (level < g_level || level > uv_log_level_fatal) return;
fp = log_to_stdout ? stdout : fopen(g_logfile, "a"); if (level < g_level || level > uv_log_level_fatal) return;
if (!fp) return; fp = log_to_stdout ? stdout : fopen(g_logfile, "a");
if (!fp) return;
uv_gettimeofday(&now);
off = strftime(buf, sizeof(buf), "%b %d %H:%M:%S.", localtime(&now.tv_sec)); uv_gettimeofday(&now);
snprintf(buf + off, sizeof(buf) - off, "%03d", (int)(now.tv_usec / 1000)); off = strftime(buf, sizeof(buf), "%b %d %H:%M:%S.", localtime(&now.tv_sec));
fprintf(fp, "%s %c %s\n", buf, c[level], msg); snprintf(buf + off, sizeof(buf) - off, "%03d", (int)(now.tv_usec / 1000));
fflush(fp); fprintf(fp, "%s %c %s\n", buf, c[level], msg);
if (!log_to_stdout) fclose(fp); fflush(fp);
} if (!log_to_stdout) fclose(fp);
}
static void uv_log_vprintf(uv_log_level_t level, const char* fmt, va_list ap) {
va_list cpy; static void uv_log_vprintf(uv_log_level_t level, const char* fmt, va_list ap) {
char msg[1024], * p = msg; va_list cpy;
size_t len = sizeof(msg); char msg[1024], *p = msg;
int l = 0; size_t len = sizeof(msg);
int l = 0;
while (1) {
va_copy(cpy, ap); while (1) {
l = vsnprintf(p, len, fmt, cpy); va_copy(cpy, ap);
va_end(cpy); l = vsnprintf(p, len, fmt, cpy);
va_end(cpy);
if (l < 0) {
return; if (l < 0) {
} else if ((size_t)l >= len) { return;
if (p != msg) free(p); } else if ((size_t)l >= len) {
len = (size_t)l + 1; if (p != msg) free(p);
p = malloc(len); len = (size_t)l + 1;
if (p == NULL) { p = malloc(len);
return; if (p == NULL) {
} return;
continue; }
} continue;
break; }
} break;
}
uv_log_raw(level, p);
if (p != msg) uv_log_raw(level, p);
free(p); if (p != msg)
} free(p);
}
void uv_log(uv_log_level_t level, const char* fmt, ...) {
va_list ap; void uv_log(uv_log_level_t level, const char* fmt, ...) {
if (level < g_level) return; va_list ap;
va_start(ap, fmt); if (level < g_level) return;
uv_log_vprintf(level, fmt, ap); va_start(ap, fmt);
va_end(ap); uv_log_vprintf(level, fmt, ap);
va_end(ap);
} }
#ifndef __UV_LOG_H__ #ifndef __UV_LOG_H__
#define __UV_LOG_H__ #define __UV_LOG_H__
#pragma once #pragma once
#include <stdlib.h> #include <stdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef enum { typedef enum {
uv_log_level_all, uv_log_level_all,
uv_log_level_debug, uv_log_level_debug,
uv_log_level_info, uv_log_level_info,
uv_log_level_warn, uv_log_level_warn,
uv_log_level_error, uv_log_level_error,
uv_log_level_fatal, uv_log_level_fatal,
uv_log_level_raw = 1 << 10, // modifier to log without timestamp uv_log_level_raw = 1 << 10, // modifier to log without timestamp
}uv_log_level_t; } uv_log_level_t;
void uv_log_set_level(uv_log_level_t level); void uv_log_set_level(uv_log_level_t level);
void uv_log_set_log_file(const char* file); void uv_log_set_log_file(const char* file);
uv_log_level_t uv_log_get_level(); uv_log_level_t uv_log_get_level();
void uv_log(uv_log_level_t level, const char* fmt, ...); void uv_log(uv_log_level_t level, const char* fmt, ...);
void uv_log_raw(uv_log_level_t level, const char* msg); void uv_log_raw(uv_log_level_t level, const char* msg);
#define uvlog_all(...) uv_log(uv_log_level_all, __VA_ARGS__) #define uvlog_all(...) uv_log(uv_log_level_all, __VA_ARGS__)
#define uvlog_debug(...) uv_log(uv_log_level_debug, __VA_ARGS__) #define uvlog_debug(...) uv_log(uv_log_level_debug, __VA_ARGS__)
#define uvlog_dline uvlog_debug("%s:%d", __FILE__, __LINE__) #define uvlog_dline uvlog_debug("%s:%d", __FILE__, __LINE__)
#define uvlog_info(...) uv_log(uv_log_level_info, __VA_ARGS__) #define uvlog_info(...) uv_log(uv_log_level_info, __VA_ARGS__)
#define uvlog_warn(...) uv_log(uv_log_level_warn, __VA_ARGS__) #define uvlog_warn(...) uv_log(uv_log_level_warn, __VA_ARGS__)
#define uvlog_error(...) uv_log(uv_log_level_error, __VA_ARGS__) #define uvlog_error(...) uv_log(uv_log_level_error, __VA_ARGS__)
#define uvlog_fatal(...) uv_log(uv_log_level_fatal, __VA_ARGS__) #define uvlog_fatal(...) uv_log(uv_log_level_fatal, __VA_ARGS__)
#define warn_on_uv_err(r, msg) \ #define warn_on_uv_err(r, msg) \
do { \ do { \
if (r) { \ if (r) { \
uvlog_warn("WARN: %s:%d %s: %d %s %s", \ uvlog_warn("WARN: %s:%d %s: %d %s %s", \
__FILE__, __LINE__, \ __FILE__, __LINE__, \
(msg), (r), uv_err_name((r)), uv_strerror((r))); \ (msg), (r), uv_err_name((r)), uv_strerror((r))); \
} \ } \
} while (0); } while (0);
#define fatal_on_uv_err(r, msg) \ #define fatal_on_uv_err(r, msg) \
do { \ do { \
if ((r)) { \ if ((r)) { \
uvlog_fatal("FATAL %s:%d %s: %d %s %s", \ uvlog_fatal("FATAL %s:%d %s: %d %s %s", \
__FILE__, __LINE__, \ __FILE__, __LINE__, \
(msg), r, uv_err_name(r), uv_strerror((r))); \ (msg), r, uv_err_name(r), uv_strerror((r))); \
exit(r); \ exit(r); \
} \ } \
} while (0); } while (0);
#define fatal_if_null(p) \ #define fatal_if_null(p) \
do { \ do { \
if ((p) == NULL) { \ if ((p) == NULL) { \
uvlog_fatal("FATAL %s:%d malloc failed", \ uvlog_fatal("FATAL %s:%d malloc failed", \
__FILE__, __LINE__); \ __FILE__, __LINE__); \
abort(); \ abort(); \
} \ } \
} while (0); } while (0);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
#include "uv_tcp.h"
#include "uv_log.h"
int getpeeraddr(uv_tcp_t* tcp, char* ip, size_t len, uint16_t* port) {
struct sockaddr_in addr;
int addrlen = sizeof(addr);
int r = uv_tcp_getpeername(tcp, (struct sockaddr*)&addr, &addrlen);
if (r) {
warn_on_uv_err(r, "uv_tcp_getpeername");
return r;
}
r = uv_ip4_name(&addr, ip, len);
if (r) {
warn_on_uv_err(r, "uv_ip4_name");
}
if (len)
ip[len - 1] = '\0';
if (port) {
*port = ntohs(addr.sin_port);
}
return r;
}
#ifndef __UV_TCP_H__ #ifndef __UV_TCP_H__
#define __UV_TCP_H__ #define __UV_TCP_H__
#pragma once #pragma once
#include <uv.h> #include <uv.h>
#ifdef __cplusplus
#ifdef __cplusplus extern "C" {
extern "C" { #endif
#endif
typedef enum {
uv_tcp_parse_ok = 0,
typedef enum { uv_tcp_parse_not_enough,
uv_tcp_parse_ok = 0, uv_tcp_parse_error,
uv_tcp_parse_not_enough, } uv_tcp_parse_result_t;
uv_tcp_parse_error,
}uv_tcp_parse_result_t; int getpeeraddr(uv_tcp_t* tcp, char* ip, size_t len, uint16_t* port);
#ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
This diff is collapsed.
#ifndef __UV_TCPCLIENT_H__ #ifndef __UV_TCPCLIENT_H__
#define __UV_TCPCLIENT_H__ #define __UV_TCPCLIENT_H__
#pragma once #pragma once
#include "uv_tcp.h" #include "mybuf.h"
#include "mybuf.h" #include "uv_tcp.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef struct uv_tcpclient_s uv_tcpclient_t;
typedef struct uv_tcpclient_s uv_tcpclient_t; typedef struct uv_tcpclient_settings_s uv_tcpclient_settings_t;
typedef struct uv_tcpclient_settings_s uv_tcpclient_settings_t;
typedef uv_tcp_parse_result_t (*uv_tcpclient_on_parse_t)(uv_tcpclient_t* client, const char* buf, size_t len, size_t* ate);
typedef uv_tcp_parse_result_t(*uv_tcpclient_on_parse_t)(uv_tcpclient_t* client, const char* buf, size_t len, size_t* ate); typedef void (*uv_tcpclient_on_connect_t)(uv_tcpclient_t* client, int connected);
typedef void(*uv_tcpclient_on_connect_t)(uv_tcpclient_t* client, int connected); typedef void (*uv_tcpclient_on_closed_t)(uv_tcpclient_t* client);
typedef void(*uv_tcpclient_on_closed_t)(uv_tcpclient_t* client);
int uv_tcpclient_new(uv_tcpclient_t** client, uv_loop_t* loop, uv_tcpclient_settings_t* settings);
int uv_tcpclient_new(uv_tcpclient_t** client, uv_loop_t* loop, uv_tcpclient_settings_t* settings); int uv_tcpclient_start(uv_tcpclient_t* client, const char* domain, const char* port);
int uv_tcpclient_start(uv_tcpclient_t* client, const char* domain, const char* port); void uv_tcpclient_send(uv_tcpclient_t* client, const char* buf, size_t len);
void uv_tcpclient_send(uv_tcpclient_t* client, const char* buf, size_t len); void uv_tcpclient_stop(uv_tcpclient_t* client);
void uv_tcpclient_stop(uv_tcpclient_t* client); void uv_tcpclient_free(uv_tcpclient_t* client);
void uv_tcpclient_free(uv_tcpclient_t* client);
struct uv_tcpclient_settings_s {
uv_tcpclient_on_connect_t on_connect;
struct uv_tcpclient_settings_s { uv_tcpclient_on_parse_t on_parse;
uv_tcpclient_on_connect_t on_connect; uv_tcpclient_on_closed_t on_close;
uv_tcpclient_on_parse_t on_parse; };
uv_tcpclient_on_closed_t on_close;
}; struct uv_tcpclient_s {
void* data;
struct uv_tcpclient_s { uv_loop_t* loop;
void* data; uv_tcp_t* tcp;
uv_loop_t* loop; uv_timer_t* reconn_timer;
uv_tcp_t* tcp; uv_getaddrinfo_t resolver;
uv_timer_t* reconn_timer; uv_connect_t connect_req;
uv_getaddrinfo_t resolver; uv_tcpclient_settings_t* settings;
uv_connect_t connect_req; char* domain;
uv_tcpclient_settings_t* settings; char* port;
char* domain; mybuf_t buf;
char* port; int connected;
mybuf_t buf; int enable_reconn;
int connected; };
int enable_reconn;
}; #ifdef __cplusplus
}
#endif
#ifdef __cplusplus #endif
}
#endif
#endif
This diff is collapsed.
#ifndef __UV_TCPSERVER_H__ #ifndef __UV_TCPSERVER_H__
#define __UV_TCPSERVER_H__ #define __UV_TCPSERVER_H__
#pragma once #pragma once
#include <uv.h> #include <uv.h>
#include "mybuf.h"
#include "uv_tcp.h" #include "mybuf.h"
#include "uv_tcp.h"
#ifdef __cplusplus
extern "C" { #ifdef __cplusplus
#endif extern "C" {
#endif
typedef struct uv_tcpserver_s uv_tcpserver_t;
typedef struct uv_tcpserver_client_context_s uv_tcpserver_client_context_t; typedef struct uv_tcpserver_s uv_tcpserver_t;
typedef struct uv_tcpserver_client_context_s uv_tcpserver_client_context_t;
typedef void(*uv_tcpserver_on_connection_t)(uv_tcpserver_client_context_t* client, int connected);
typedef uv_tcp_parse_result_t(*uv_tcpserver_on_parse_t)(uv_tcpserver_client_context_t* client, const char* buf, size_t len, size_t* ate); typedef void (*uv_tcpserver_on_connection_t)(uv_tcpserver_client_context_t* client, int connected);
typedef void(*uv_tcpserver_on_server_shutdown_t)(uv_tcpserver_t* server); typedef uv_tcp_parse_result_t (*uv_tcpserver_on_parse_t)(uv_tcpserver_client_context_t* client, const char* buf, size_t len, size_t* ate);
typedef struct uv_tcpserver_settings_s uv_tcpserver_settings_t; typedef void (*uv_tcpserver_on_server_shutdown_t)(uv_tcpserver_t* server);
typedef struct uv_tcpserver_settings_s uv_tcpserver_settings_t;
int uv_tcpserver_create(uv_tcpserver_t** server, uv_loop_t* loop, uv_tcpserver_settings_t* settings);
int uv_tcpserver_start_listen(uv_tcpserver_t* server, const char* listen_addr, int listen_port); int uv_tcpserver_create(uv_tcpserver_t** server, uv_loop_t* loop, uv_tcpserver_settings_t* settings);
void uv_tcpserver_stop(uv_tcpserver_t* server); int uv_tcpserver_start_listen(uv_tcpserver_t* server, const char* listen_addr, int listen_port);
void uv_tcpserver_free(uv_tcpserver_t* server); void uv_tcpserver_stop(uv_tcpserver_t* server);
void uv_tcpserver_close_cli(uv_tcpserver_client_context_t* cli); void uv_tcpserver_free(uv_tcpserver_t* server);
// cli must be diconnected already, safe pattern is call this function in callback `on_connect` with `connected = 0` void uv_tcpserver_close_cli(uv_tcpserver_client_context_t* cli);
void uv_tcpserver_free_cli_ctx(uv_tcpserver_client_context_t* cli); // cli must be diconnected already, safe pattern is call this function in callback `on_connect` with `connected = 0`
int uv_tcpserver_send_to_cli(uv_tcpserver_client_context_t* cli, const char* buf, size_t len); void uv_tcpserver_free_cli_ctx(uv_tcpserver_client_context_t* cli);
int uv_tcpserver_send_to_cli(uv_tcpserver_client_context_t* cli, const char* buf, size_t len);
struct uv_tcpserver_s {
void* data;
uv_tcp_t tcp;
uv_tcpserver_settings_t* settings;
};
struct uv_tcpserver_s {
void* data; struct uv_tcpserver_settings_s {
uv_tcp_t tcp; uv_tcpserver_on_connection_t on_connect;
uv_tcpserver_settings_t* settings; uv_tcpserver_on_parse_t on_parse;
}; uv_tcpserver_on_server_shutdown_t on_server_shutdown;
};
struct uv_tcpserver_settings_s {
uv_tcpserver_on_connection_t on_connect; struct uv_tcpserver_client_context_s {
uv_tcpserver_on_parse_t on_parse; void* data;
uv_tcpserver_on_server_shutdown_t on_server_shutdown; uv_tcpserver_t* server;
}; uv_tcp_t tcp;
mybuf_t buf;
struct uv_tcpserver_client_context_s { };
void* data;
uv_tcpserver_t* server; #ifdef __cplusplus
uv_tcp_t tcp; }
mybuf_t buf; #endif
};
#endif
#ifdef __cplusplus
}
#endif
#endif
#ifndef __UVLIB_H__
#define __UVLIB_H__
#pragma once
#include "list.h"
#include "mybuf.h"
#include "uv_httpc.h"
#include "uv_httpd.h"
#include "uv_log.h"
#include "uv_tcpclient.h"
#include "uv_tcpserver.h"
#ifdef _WIN32
#define UVLIB_DIR "G:/dev_libs/ademco/"
#ifdef UVLIB_USE_MT
#define UVLIB_NAME "uvlib_mt.lib"
#else
#define UVLIB_NAME "uvlib.lib"
#endif
#ifdef _WIN64
#ifdef _DEBUG
#pragma comment(lib, UVLIB_DIR "x64/Debug/" UVLIB_NAME)
#else
#pragma comment(lib, UVLIB_DIR "x64/Release/" UVLIB_NAME)
#endif
#else // WIN32
#ifdef _DEBUG
#pragma comment(lib, UVLIB_DIR "Debug/" UVLIB_NAME)
#else
#pragma comment(lib, UVLIB_DIR "Release/" UVLIB_NAME)
#endif
#endif
#endif // _WIN32
#endif
...@@ -115,18 +115,17 @@ int hbIsValidZoneStrict(HbMachineType type, uint16_t zone) { ...@@ -115,18 +115,17 @@ int hbIsValidZoneStrict(HbMachineType type, uint16_t zone) {
} }
int hbMachineIsSelling(HbMachineType type) { int hbMachineIsSelling(HbMachineType type) {
return type == HMT_NETMOD return type == HMT_GPRS_IOT ||
|| type == HMT_GPRS type == HMT_NETMOD ||
|| type == HMT_GPRS_IOT type == HMT_GPRS ||
|| type == HMT_IOT type == HMT_IOT ||
|| type == HMT_LCD type == HMT_LCD ||
|| type == HMT_WIRED type == HMT_WIRED ||
|| type == HMT_TRUE_COLOR type == HMT_TRUE_COLOR ||
|| type == HMT_3_SECTION type == HMT_3_SECTION ||
|| type == HMT_GPRS_PHONE type == HMT_GPRS_PHONE ||
|| type == HMT_NB type == HMT_NB ||
|| type == HMT_WIFI2 type == HMT_WIFI2;
;
} }
int hbMachineCanArm(HbMachineType type) { int hbMachineCanArm(HbMachineType type) {
...@@ -142,37 +141,32 @@ int hbMachineCanEnterSettings(HbMachineType type) { ...@@ -142,37 +141,32 @@ int hbMachineCanEnterSettings(HbMachineType type) {
} }
int hbMachineCanHalfArm(HbMachineType type) { int hbMachineCanHalfArm(HbMachineType type) {
return type == HMT_NETMOD return type == HMT_NETMOD || type == HMT_LCD;
|| type == HMT_LCD
;
} }
int hbMachineCanReportSignalStrength(HbMachineType type) { int hbMachineCanReportSignalStrength(HbMachineType type) {
return type == HMT_GPRS return type == HMT_GPRS ||
|| type == HMT_GPRS_IOT type == HMT_GPRS_IOT ||
|| type == HMT_IOT type == HMT_IOT ||
|| type == HMT_LCD type == HMT_LCD ||
|| type == HMT_TRUE_COLOR type == HMT_TRUE_COLOR ||
|| type == HMT_3_SECTION type == HMT_3_SECTION ||
|| type == HMT_GPRS_PHONE type == HMT_GPRS_PHONE ||
|| type == HMT_NB type == HMT_NB;
;
} }
int hbMachineCanReportBySMS(HbMachineType type) { int hbMachineCanReportBySMS(HbMachineType type) {
return type == HMT_GPRS return type == HMT_GPRS ||
|| type == HMT_LCD type == HMT_LCD ||
|| type == HMT_TRUE_COLOR type == HMT_TRUE_COLOR ||
|| type == HMT_3_SECTION type == HMT_3_SECTION ||
|| type == HMT_GPRS_PHONE type == HMT_GPRS_PHONE;
;
} }
int hbMachineHasWiredZone(HbMachineType type) { int hbMachineHasWiredZone(HbMachineType type) {
return type == HMT_NETMOD return type == HMT_NETMOD ||
|| type == HMT_TRUE_COLOR type == HMT_TRUE_COLOR ||
|| type == HMT_3_SECTION type == HMT_3_SECTION;
;
} }
AdemcoZone hbWiredZoneMin(HbMachineType type) { AdemcoZone hbWiredZoneMin(HbMachineType type) {
...@@ -463,11 +457,11 @@ int hbCheckSum(const uint8_t* data, size_t len) { ...@@ -463,11 +457,11 @@ int hbCheckSum(const uint8_t* data, size_t len) {
return sum == *p; return sum == *p;
} }
#define copy_data_to_com \ #define copy_data_to_com \
if (cd) { \ if (cd) { \
cd->len = len & 0xFF; \ cd->len = len & 0xFF; \
memcpy(cd->data, data, len & 0xFF); \ memcpy(cd->data, data, len & 0xFF); \
} }
HbComRequestType hbComParseRequest(const uint8_t* data, size_t len, HbComData* cd) { HbComRequestType hbComParseRequest(const uint8_t* data, size_t len, HbComData* cd) {
do { do {
......
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment