mirror of
https://github.com/arendst/Tasmota.git
synced 2025-07-24 11:16:34 +00:00
Merge branch 'development' into pre-release-12.1
This commit is contained in:
Theo Arends
commit
806c5762bc
@ -3,10 +3,10 @@ All notable changes to this project will be documented in this file.
|
||||
|
||||
## [Released]
|
||||
|
||||
## [12.1.0] 20220817
|
||||
## [12.1.0] 20220818
|
||||
- Release Patricia
|
||||
|
||||
## [12.0.2.4] 20220817
|
||||
## [12.0.2.4] 20220818
|
||||
### Added
|
||||
- Command ``SetOption45 1..250`` to change default bistable latching relay pulse length of 40 milliseconds
|
||||
- Support for Modbus bridge adding commands ``ModbusSend``, ``ModbusBaudrate`` and ``ModbusSerialConfig`` (#16013)
|
||||
@ -21,6 +21,7 @@ All notable changes to this project will be documented in this file.
|
||||
### Changed
|
||||
- ESP32 LVGL library from v8.2.0 to v8.3.0 (#16019)
|
||||
- Tasmota ESP32 Arduino core from v2.0.4 to v2.0.4.1 (#16110)
|
||||
- TasmotaModbus library from v3.4.0 to v3.5.0 (#16245)
|
||||
|
||||
### Fixed
|
||||
- Restore EnergyToday after using command ``restart 2`` and power cycle (#16118)
|
||||
|
||||
@ -129,6 +129,7 @@ The latter links can be used for OTA upgrades too like ``OtaUrl http://ota.tasmo
|
||||
### Breaking Changed
|
||||
|
||||
### Changed
|
||||
- TasmotaModbus library from v3.4.0 to v3.5.0 [#16245](https://github.com/arendst/Tasmota/issues/16245)
|
||||
- ESP32 Arduino core from v2.0.3 to v2.0.4.1 [#15940](https://github.com/arendst/Tasmota/issues/15940)
|
||||
- ESP32 LVGL library from v8.2.0 to v8.3.0 [#16019](https://github.com/arendst/Tasmota/issues/16019)
|
||||
- Driver DHT v6 consolidation for both ESP8266 and ESP32 to support SI7021, THS01 and MS01 on ESP32 [#15856](https://github.com/arendst/Tasmota/issues/15856)
|
||||
|
||||
@ -1,7 +0,0 @@
|
||||
# TasmotaSerial
|
||||
|
||||
Implementation of software serial with hardware serial fallback library for the ESP8266
|
||||
|
||||
Allows for several instances to be active at the same time.
|
||||
|
||||
Please note that due to the fact that the ESP always have other activities ongoing, there will be some inexactness in interrupt timings. This may lead to bit errors when having heavy data traffic.
|
||||
@ -1,10 +1,10 @@
|
||||
{
|
||||
"name": "TasmotaModbus",
|
||||
"version": "3.4.0",
|
||||
"version": "3.5.0",
|
||||
"keywords": [
|
||||
"serial", "io", "TasmotaModbus"
|
||||
],
|
||||
"description": "Basic modbus wrapper for TasmotaSerial for ESP8266.",
|
||||
"description": "Modbus wrapper for TasmotaSerial.",
|
||||
"repository":
|
||||
{
|
||||
"type": "git",
|
||||
@ -1,5 +1,5 @@
|
||||
name=TasmotaModbus
|
||||
version=3.4.0
|
||||
version=3.5.0
|
||||
author=Theo Arends
|
||||
maintainer=Theo Arends <theo@arends.com>
|
||||
sentence=Basic modbus wrapper for TasmotaSerial for ESP8266.
|
||||
@ -1,4 +1,4 @@
|
||||
/*
|
||||
/*
|
||||
TasmotaModbus.cpp - Basic modbus wrapper for TasmotaSerial for Tasmota
|
||||
|
||||
Copyright (C) 2021 Theo Arends
|
||||
@ -15,6 +15,8 @@
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Documentation about modbus protocol: https://www.modbustools.com/modbus.html
|
||||
*/
|
||||
|
||||
#include "TasmotaModbus.h"
|
||||
@ -53,24 +55,81 @@ int TasmotaModbus::Begin(long speed, uint32_t config)
|
||||
return result;
|
||||
}
|
||||
|
||||
void TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count)
|
||||
uint8_t TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count, uint16_t *registers)
|
||||
{
|
||||
uint8_t frame[8];
|
||||
uint8_t *frame;
|
||||
uint8_t framepointer = 0;
|
||||
|
||||
if (function_code < 7)
|
||||
{
|
||||
frame = (uint8_t *)malloc(8); // Addres(1), Function(1), Start/Coil Address(2), Registercount or Data (2), CRC(2)
|
||||
}
|
||||
else
|
||||
{
|
||||
frame = (uint8_t *)malloc(9 + (register_count * 2)); // Addres(1), Function(1), Start/Coil Address(2),Quantity of registers (2), Bytecount(1), Data(1..n), CRC(2)
|
||||
}
|
||||
|
||||
mb_address = device_address; // Save address for receipt check
|
||||
|
||||
frame[0] = mb_address; // 0xFE default device address or dedicated like 0x01
|
||||
frame[1] = function_code;
|
||||
frame[2] = (uint8_t)(start_address >> 8); // MSB
|
||||
frame[3] = (uint8_t)(start_address); // LSB
|
||||
frame[4] = (uint8_t)(register_count >> 8); // MSB
|
||||
frame[5] = (uint8_t)(register_count); // LSB
|
||||
uint16_t crc = CalculateCRC(frame, 6);
|
||||
frame[6] = (uint8_t)(crc);
|
||||
frame[7] = (uint8_t)(crc >> 8);
|
||||
frame[framepointer++] = mb_address; // 0xFE default device address or dedicated like 0x01
|
||||
frame[framepointer++] = function_code;
|
||||
frame[framepointer++] = (uint8_t)(start_address >> 8); // MSB
|
||||
frame[framepointer++] = (uint8_t)(start_address); // LSB
|
||||
if (function_code < 5)
|
||||
{
|
||||
frame[framepointer++] = (uint8_t)(register_count >> 8); // MSB
|
||||
frame[framepointer++] = (uint8_t)(register_count); // LSB
|
||||
}
|
||||
else if ((function_code == 5) || (function_code == 6))
|
||||
{
|
||||
if (registers == NULL)
|
||||
{
|
||||
free(frame);
|
||||
return 13; // Register data not specified
|
||||
}
|
||||
if (register_count != 1)
|
||||
{
|
||||
free(frame);
|
||||
return 12; // Wrong register count
|
||||
}
|
||||
frame[framepointer++] = (uint8_t)(registers[0] >> 8); // MSB
|
||||
frame[framepointer++] = (uint8_t)(registers[0]); // LSB
|
||||
}
|
||||
else if ((function_code == 15) || (function_code == 16))
|
||||
{
|
||||
frame[framepointer++] = (uint8_t)(register_count >> 8); // MSB
|
||||
frame[framepointer++] = (uint8_t)(register_count); // LSB
|
||||
frame[framepointer++] = register_count * 2;
|
||||
if (registers == NULL)
|
||||
{
|
||||
free(frame);
|
||||
return 13; // Register data not specified
|
||||
}
|
||||
if (register_count == 0)
|
||||
{
|
||||
free(frame);
|
||||
return 12; // Wrong register count
|
||||
}
|
||||
for (int registerpointer = 0; registerpointer < register_count; registerpointer++)
|
||||
{
|
||||
frame[framepointer++] = (uint8_t)(registers[registerpointer] >> 8); // MSB
|
||||
frame[framepointer++] = (uint8_t)(registers[registerpointer]); // LSB
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
free(frame);
|
||||
return 1; // Wrong function code
|
||||
}
|
||||
|
||||
uint16_t crc = CalculateCRC(frame, framepointer);
|
||||
frame[framepointer++] = (uint8_t)(crc);
|
||||
frame[framepointer++] = (uint8_t)(crc >> 8);
|
||||
|
||||
flush();
|
||||
write(frame, sizeof(frame));
|
||||
write(frame, framepointer);
|
||||
free(frame);
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool TasmotaModbus::ReceiveReady()
|
||||
@ -78,11 +137,12 @@ bool TasmotaModbus::ReceiveReady()
|
||||
return (available() > 4);
|
||||
}
|
||||
|
||||
uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
|
||||
uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t data_count)
|
||||
{
|
||||
mb_len = 0;
|
||||
uint32_t timeout = millis() + 10;
|
||||
while ((mb_len < (register_count *2) + 5) && (millis() < timeout)) {
|
||||
uint8_t header_length = 3;
|
||||
while ((mb_len < (data_count * 2) + header_length + 2) && (millis() < timeout)) {
|
||||
if (available()) {
|
||||
uint8_t data = (uint8_t)read();
|
||||
if (!mb_len) { // Skip leading data as provided by hardware serial
|
||||
@ -106,6 +166,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
|
||||
// 10 = Gateway Path Unavailable
|
||||
// 11 = Gateway Target device failed to respond
|
||||
}
|
||||
if ((buffer[1] == 5) || (buffer[1] == 6) || (buffer[1] == 15) || (buffer[1] == 16)) header_length = 4; // Addr, Func, StartAddr
|
||||
}
|
||||
}
|
||||
|
||||
@ -114,7 +175,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
|
||||
}
|
||||
}
|
||||
|
||||
if (mb_len < 7) { return 7; } // 7 = Not enough data
|
||||
if (mb_len < 6) { return 7; } // 7 = Not enough data
|
||||
|
||||
/*
|
||||
if (mb_len != buffer[2] + 5) {
|
||||
@ -131,6 +192,22 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
|
||||
return 0; // 0 = No error
|
||||
}
|
||||
|
||||
uint8_t TasmotaModbus::Receive8BitRegister(uint8_t *value)
|
||||
{
|
||||
// 0 1 2 3 4 5
|
||||
// 01 04 02 43 HH LL
|
||||
// Id Cc Sz Regis Crc--
|
||||
|
||||
uint8_t buffer[6];
|
||||
|
||||
uint8_t error = ReceiveBuffer(buffer, 1); // 1 x 16bit register
|
||||
if (!error) {
|
||||
*value = buffer[3];
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
uint8_t TasmotaModbus::Receive16BitRegister(uint16_t *value)
|
||||
{
|
||||
// 0 1 2 3 4 5 6
|
||||
@ -34,8 +34,6 @@ class TasmotaModbus : public TasmotaSerial {
|
||||
|
||||
uint16_t CalculateCRC(uint8_t *frame, uint8_t num);
|
||||
|
||||
void Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count);
|
||||
|
||||
bool ReceiveReady();
|
||||
|
||||
/* Return codes:
|
||||
@ -51,8 +49,13 @@ class TasmotaModbus : public TasmotaSerial {
|
||||
* 9 = Crc error
|
||||
* 10 = Gateway Path Unavailable
|
||||
* 11 = Gateway Target device failed to respond
|
||||
* 12 = Wrong number of registers
|
||||
* 13 = Register data not specified
|
||||
* 14 = To many registers
|
||||
*/
|
||||
uint8_t Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count, uint16_t *registers = NULL);
|
||||
uint8_t ReceiveBuffer(uint8_t *buffer, uint8_t register_count);
|
||||
uint8_t Receive8BitRegister(uint8_t *value);
|
||||
uint8_t Receive16BitRegister(uint16_t *value);
|
||||
uint8_t Receive32BitRegister(float *value);
|
||||
|
||||
@ -2026,12 +2026,13 @@ api_mul(unsigned char *G, size_t Glen,
|
||||
p256_jacobian P;
|
||||
|
||||
(void)curve;
|
||||
if (Glen != 65) {
|
||||
return 0;
|
||||
}
|
||||
r = p256_decode(&P, G, Glen);
|
||||
p256_mul(&P, x, xlen);
|
||||
if (Glen >= 65) {
|
||||
p256_to_affine(&P);
|
||||
p256_encode(G, &P);
|
||||
}
|
||||
p256_to_affine(&P);
|
||||
p256_encode(G, &P);
|
||||
return r;
|
||||
}
|
||||
|
||||
@ -2046,16 +2047,6 @@ api_mulgen(unsigned char *R,
|
||||
p256_to_affine(&P);
|
||||
p256_encode(R, &P);
|
||||
return 65;
|
||||
|
||||
/*
|
||||
const unsigned char *G;
|
||||
size_t Glen;
|
||||
|
||||
G = api_generator(curve, &Glen);
|
||||
memcpy(R, G, Glen);
|
||||
api_mul(R, Glen, x, xlen, curve);
|
||||
return Glen;
|
||||
*/
|
||||
}
|
||||
|
||||
static uint32_t
|
||||
@ -2068,6 +2059,9 @@ api_muladd(unsigned char *A, const unsigned char *B, size_t len,
|
||||
int i;
|
||||
|
||||
(void)curve;
|
||||
if (len != 65) {
|
||||
return 0;
|
||||
}
|
||||
r = p256_decode(&P, A, len);
|
||||
p256_mul(&P, x, xlen);
|
||||
if (B == NULL) {
|
||||
|
||||
@ -735,11 +735,12 @@ api_mul(unsigned char *G, size_t Glen,
|
||||
jacobian P;
|
||||
|
||||
cc = id_to_curve(curve);
|
||||
if (Glen != cc->point_len) {
|
||||
return 0;
|
||||
}
|
||||
r = point_decode(&P, G, Glen, cc);
|
||||
point_mul(&P, x, xlen, cc);
|
||||
if (Glen == cc->point_len) {
|
||||
point_encode(G, &P, cc);
|
||||
}
|
||||
point_encode(G, &P, cc);
|
||||
return r;
|
||||
}
|
||||
|
||||
@ -772,6 +773,9 @@ api_muladd(unsigned char *A, const unsigned char *B, size_t len,
|
||||
*/
|
||||
|
||||
cc = id_to_curve(curve);
|
||||
if (len != cc->point_len) {
|
||||
return 0;
|
||||
}
|
||||
r = point_decode(&P, A, len, cc);
|
||||
if (B == NULL) {
|
||||
size_t Glen;
|
||||
|
||||
@ -1,113 +1,50 @@
|
||||
/* pgmspace_bearssl.h - Accessor utilities/types for accessing PROGMEM data */
|
||||
/* PGMSPACE.H - Accessor utilities/types for accessing PROGMEM data */
|
||||
|
||||
//#pragma GCC optimize ("O2") // -Os is the default, forcing -O2 for BearSSL
|
||||
//#define PGM_READ_UNALIGNED 0 // all calls are aligned, take the optimized version
|
||||
//#include <sys/pgmspace.h>
|
||||
|
||||
|
||||
#ifndef _PGMSPACE_H_
|
||||
#define _PGMSPACE_H_
|
||||
#ifndef _PGMSPACEWRAPPER_H_
|
||||
#define _PGMSPACEWRAPPER_H_
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef ESP32
|
||||
#ifndef ICACHE_RODATA_ATTR
|
||||
#define ICACHE_RODATA_ATTR __attribute__((section(".irom.text")))
|
||||
#endif
|
||||
#ifndef PROGMEM
|
||||
// The following two macros cause a parameter to be enclosed in quotes
|
||||
// by the preopressor (i.e. for concatenating ints to strings)
|
||||
#define __STRINGIZE_NX(A) #A
|
||||
#define __STRINGIZE(A) __STRINGIZE_NX(A)
|
||||
// Since __section__ is supposed to be only use for global variables,
|
||||
// there could be conflicts when a static/inlined function has them in the
|
||||
// same file as a non-static PROGMEM object.
|
||||
// Ref: https://gcc.gnu.org/onlinedocs/gcc-3.2/gcc/Variable-Attributes.html
|
||||
// Place each progmem object into its own named section, avoiding conflicts
|
||||
#define PROGMEM __attribute__((section( "\".irom.text." __FILE__ "." __STRINGIZE(__LINE__) "." __STRINGIZE(__COUNTER__) "\"")))
|
||||
#endif
|
||||
#endif //ESP32
|
||||
#ifndef PGM_P
|
||||
#define PGM_P const char *
|
||||
#endif
|
||||
#ifndef PGM_VOID_P
|
||||
#define PGM_VOID_P const void *
|
||||
#endif
|
||||
|
||||
// PSTR() macro modified to start on a 32-bit boundary. This adds on average
|
||||
// 1.5 bytes/string, but in return memcpy_P and strcpy_P will work 4~8x faster
|
||||
#ifndef PSTR
|
||||
#define PSTR(s) (__extension__({static const char __c[] __attribute__((__aligned__(4))) PROGMEM = (s); &__c[0];}))
|
||||
#endif
|
||||
|
||||
#ifdef ESP8266
|
||||
// Flash memory must be read using 32 bit aligned addresses else a processor
|
||||
// exception will be triggered.
|
||||
// The order within the 32 bit values are:
|
||||
// --------------
|
||||
// b3, b2, b1, b0
|
||||
// w1, w0
|
||||
|
||||
#define pgm_read_with_offset(addr, res) \
|
||||
__asm__ ("extui %0, %1, 0, 2\n" /* Extract offset within word (in bytes) */ \
|
||||
"sub %1, %1, %0\n" /* Subtract offset from addr, yielding an aligned address */ \
|
||||
"l32i.n %1, %1, 0x0\n" /* Load word from aligned address */ \
|
||||
"slli %0, %0, 3\n" /* Mulitiply offset by 8, yielding an offset in bits */ \
|
||||
"ssr %0\n" /* Prepare to shift by offset (in bits) */ \
|
||||
"srl %0, %1\n" /* Shift right; now the requested byte is the first one */ \
|
||||
:"=r"(res), "=r"(addr) \
|
||||
:"1"(addr) \
|
||||
:);
|
||||
#include <sys/pgmspace.h>
|
||||
|
||||
static inline uint8_t pgm_read_byte_inlined(const void* addr) {
|
||||
register uint32_t res;
|
||||
pgm_read_with_offset(addr, res);
|
||||
return (uint8_t) res; /* This masks the lower byte from the returned word */
|
||||
}
|
||||
#else //!ESP8266
|
||||
|
||||
/* Although this says "word", it's actually 16 bit, i.e. half word on Xtensa */
|
||||
static inline uint16_t pgm_read_word_inlined(const void* addr) {
|
||||
register uint32_t res;
|
||||
pgm_read_with_offset(addr, res);
|
||||
return (uint16_t) res; /* This masks the lower half-word from the returned word */
|
||||
}
|
||||
|
||||
#define pgm_read_byte(addr) pgm_read_byte_inlined(addr)
|
||||
#define pgm_read_word(addr) pgm_read_word_inlined(addr)
|
||||
#ifdef __cplusplus
|
||||
#define pgm_read_dword(addr) (*reinterpret_cast<const uint32_t*>(addr))
|
||||
#define pgm_read_float(addr) (*reinterpret_cast<const float*>(addr))
|
||||
#define pgm_read_ptr(addr) (*reinterpret_cast<const void* const *>(addr))
|
||||
#else
|
||||
#define pgm_read_dword(addr) (*(const uint32_t*)(addr))
|
||||
#define pgm_read_float(addr) (*(const float*)(addr))
|
||||
#define pgm_read_ptr(addr) (*(const void* const*)(addr))
|
||||
#ifndef ICACHE_RODATA_ATTR
|
||||
#define ICACHE_RODATA_ATTR
|
||||
#endif
|
||||
|
||||
#else // ESP8266
|
||||
#ifndef PROGMEM
|
||||
#define PROGMEM
|
||||
#endif
|
||||
|
||||
#ifndef PGM_P
|
||||
#define PGM_P const char *
|
||||
#endif
|
||||
|
||||
#ifndef PGM_VOID_P
|
||||
#define PGM_VOID_P const void *
|
||||
#endif
|
||||
|
||||
#ifndef PSTR
|
||||
#define PSTR
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define pgm_read_byte(addr) (*reinterpret_cast<const uint8_t*>(addr))
|
||||
#define pgm_read_word(addr) (*reinterpret_cast<const uint16_t*>(addr))
|
||||
#define pgm_read_dword(addr) (*reinterpret_cast<const uint32_t*>(addr))
|
||||
#define pgm_read_float(addr) (*reinterpret_cast<const float>(addr))
|
||||
#define pgm_read_ptr(addr) (*reinterpret_cast<const void* const *>(addr))
|
||||
#define pgm_read_float(addr) (*reinterpret_cast<const float*>(addr))
|
||||
#define pgm_read_ptr(addr) (*reinterpret_cast<const void const *>(addr))
|
||||
#else
|
||||
#define pgm_read_byte(addr) (*(const uint8_t*)(addr))
|
||||
#define pgm_read_word(addr) (*(const uint16_t*)(addr))
|
||||
#define pgm_read_dword(addr) (*(const uint32_t*)(addr))
|
||||
#define pgm_read_float(addr) (*(const float)(addr))
|
||||
#define pgm_read_ptr(addr) (*(const void* const *)(addr))
|
||||
#define pgm_read_float(addr) (*(const float*)(addr))
|
||||
#define pgm_read_ptr(addr) (*(const void const *)(addr))
|
||||
#endif
|
||||
|
||||
|
||||
#endif // ESP8266
|
||||
|
||||
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
|
||||
#define pgm_read_word_near(addr) pgm_read_word(addr)
|
||||
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
|
||||
@ -119,24 +56,9 @@ static inline uint16_t pgm_read_word_inlined(const void* addr) {
|
||||
#define pgm_read_float_far(addr) pgm_read_float(addr)
|
||||
#define pgm_read_ptr_far(addr) pgm_read_ptr(addr)
|
||||
|
||||
#define _SFR_BYTE(n) (n)
|
||||
#define memcpy_P memcpy
|
||||
#define memcmp_P memcmp
|
||||
|
||||
#ifdef __PROG_TYPES_COMPAT__
|
||||
|
||||
typedef void prog_void;
|
||||
typedef char prog_char;
|
||||
typedef unsigned char prog_uchar;
|
||||
typedef int8_t prog_int8_t;
|
||||
typedef uint8_t prog_uint8_t;
|
||||
typedef int16_t prog_int16_t;
|
||||
typedef uint16_t prog_uint16_t;
|
||||
typedef int32_t prog_int32_t;
|
||||
typedef uint32_t prog_uint32_t;
|
||||
|
||||
#endif // defined(__PROG_TYPES_COMPAT__)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif // !ESP8266
|
||||
|
||||
#endif
|
||||
|
||||
@ -114,7 +114,7 @@ br_rsa_pss_sig_unpad(const br_hash_class *hf_data,
|
||||
* in the string.
|
||||
*/
|
||||
for (u = 0; u < hash_len; u ++) {
|
||||
r |= tmp[u] ^ x[(xlen - salt_len - 1) + u];
|
||||
r |= tmp[u] ^ x[(xlen - hash_len - 1) + u];
|
||||
}
|
||||
|
||||
return EQ0(r);
|
||||
|
||||
@ -1232,6 +1232,21 @@ void
|
||||
br_ssl_engine_close(br_ssl_engine_context *cc)
|
||||
{
|
||||
if (!br_ssl_engine_closed(cc)) {
|
||||
/*
|
||||
* If we are not already closed, then we need to
|
||||
* initiate the closure. Once closing, any incoming
|
||||
* application data is discarded; we should also discard
|
||||
* application data which is already there but has not
|
||||
* been acknowledged by the application yet (this mimics
|
||||
* usual semantics on BSD sockets: you cannot read()
|
||||
* once you called close(), even if there was some
|
||||
* unread data already buffered).
|
||||
*/
|
||||
size_t len;
|
||||
|
||||
if (br_ssl_engine_recvapp_buf(cc, &len) != NULL && len != 0) {
|
||||
br_ssl_engine_recvapp_ack(cc, len);
|
||||
}
|
||||
jump_handshake(cc, 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -136,7 +136,7 @@ cbc_decrypt(br_sslrec_in_cbc_context *cc,
|
||||
|
||||
/*
|
||||
* Use the last decrypted byte to compute the actual payload
|
||||
* length. Take care not to underflow (we use unsigned types).
|
||||
* length. Take care not to overflow (we use unsigned types).
|
||||
*/
|
||||
pad_len = buf[max_len];
|
||||
good = LE(pad_len, (uint32_t)(max_len - min_len));
|
||||
|
||||
@ -137,9 +137,13 @@
|
||||
#include "t_bearssl_x509.h"
|
||||
#include "t_bearssl_pem.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** \brief Type for a configuration option.
|
||||
*
|
||||
* A "t_configuration option" is a value that is selected when the BearSSL
|
||||
* A "configuration option" is a value that is selected when the BearSSL
|
||||
* library itself is compiled. Most options are boolean; their value is
|
||||
* then either 1 (option is enabled) or 0 (option is disabled). Some
|
||||
* values have other integer values. Option names correspond to macro
|
||||
@ -167,4 +171,13 @@ typedef struct {
|
||||
*/
|
||||
const br_config_option *br_get_config(void);
|
||||
|
||||
/* ======================================================================= */
|
||||
|
||||
/** \brief Version feature: support for time callback. */
|
||||
#define BR_FEATURE_X509_TIME_CALLBACK 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -1251,8 +1251,8 @@ static inline void
|
||||
br_ssl_engine_set_versions(br_ssl_engine_context *cc,
|
||||
unsigned version_min, unsigned version_max)
|
||||
{
|
||||
cc->version_min = version_min;
|
||||
cc->version_max = version_max;
|
||||
cc->version_min = (uint16_t)version_min;
|
||||
cc->version_max = (uint16_t)version_max;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1325,7 +1325,7 @@ br_ssl_engine_set_protocol_names(br_ssl_engine_context *ctx,
|
||||
const char **names, size_t num)
|
||||
{
|
||||
ctx->protocol_names = names;
|
||||
ctx->protocol_names_num = num;
|
||||
ctx->protocol_names_num = (uint16_t)num;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -890,7 +890,10 @@ void br_x509_minimal_init_full(br_x509_minimal_context *ctx,
|
||||
* - Seconds are counted since midnight, from 0 to 86400 (a count of
|
||||
* 86400 is possible only if a leap second happened).
|
||||
*
|
||||
* The validation date and time is understood in the UTC time zone.
|
||||
* The validation date and time is understood in the UTC time zone. The
|
||||
* "Unix Epoch" (January 1st, 1970, 00:00 UTC) corresponds to days=719528
|
||||
* and seconds=0; the "Windows Epoch" (January 1st, 1601, 00:00 UTC) is
|
||||
* days=584754, seconds=0.
|
||||
*
|
||||
* If the validation date and time are not explicitly set, but BearSSL
|
||||
* was compiled with support for the system clock on the underlying
|
||||
|
||||
@ -325,9 +325,20 @@
|
||||
* values are documented on:
|
||||
* https://sourceforge.net/p/predef/wiki/OperatingSystems/
|
||||
*
|
||||
* TODO: enrich the list of detected system. Also add detection for
|
||||
* alternate system calls like getentropy(), which are usually
|
||||
* preferable when available.
|
||||
* Win32's CryptGenRandom() should be available on Windows systems.
|
||||
*
|
||||
* /dev/urandom should work on all Unix-like systems (including macOS X).
|
||||
*
|
||||
* getentropy() is present on Linux (Glibc 2.25+), FreeBSD (12.0+) and
|
||||
* OpenBSD (5.6+). For OpenBSD, there does not seem to be easy to use
|
||||
* macros to test the minimum version, so we just assume that it is
|
||||
* recent enough (last version without getentropy() has gone out of
|
||||
* support in May 2015).
|
||||
*
|
||||
* Ideally we should use getentropy() on macOS (10.12+) too, but I don't
|
||||
* know how to test the exact OS version with preprocessor macros.
|
||||
*
|
||||
* TODO: enrich the list of detected system.
|
||||
*/
|
||||
|
||||
#ifndef BR_USE_URANDOM
|
||||
@ -344,6 +355,15 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef BR_USE_GETENTROPY
|
||||
#if (defined __linux__ \
|
||||
&& (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 25))) \
|
||||
|| (defined __FreeBSD__ && __FreeBSD__ >= 12) \
|
||||
|| defined __OpenBSD__
|
||||
#define BR_USE_GETENTROPY 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef BR_USE_WIN32_RAND
|
||||
#if defined _WIN32 || defined _WIN64
|
||||
#define BR_USE_WIN32_RAND 1
|
||||
|
||||
@ -525,7 +525,7 @@ static const unsigned char t0_codeblock[] PROGMEM = {
|
||||
|
||||
0x00, 0x01, 0x00, 0x0D, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x01,
|
||||
0x00, 0x11, 0x00, 0x00, 0x01, 0x01, 0x09, 0x00, 0x00, 0x01, 0x01, 0x0A,
|
||||
0x00, 0x00, 0x24, 0x24, 0x00, 0x00, 0x01,
|
||||
0x00, 0x00, 0x25, 0x25, 0x00, 0x00, 0x01,
|
||||
T0_INT1(BR_ERR_X509_BAD_BOOLEAN), 0x00, 0x00, 0x01,
|
||||
T0_INT1(BR_ERR_X509_BAD_DN), 0x00, 0x00, 0x01,
|
||||
T0_INT1(BR_ERR_X509_BAD_SERVER_NAME), 0x00, 0x00, 0x01,
|
||||
@ -563,227 +563,224 @@ static const unsigned char t0_codeblock[] PROGMEM = {
|
||||
T0_INT2(offsetof(CONTEXT_NAME, next_dn_hash)), 0x00, 0x00, 0x01,
|
||||
T0_INT2(offsetof(CONTEXT_NAME, num_certs)), 0x00, 0x00, 0x01,
|
||||
T0_INT2(offsetof(CONTEXT_NAME, pad)), 0x00, 0x00, 0x01,
|
||||
T0_INT2(offsetof(CONTEXT_NAME, saved_dn_hash)), 0x00, 0x00, 0xC9, 0x71,
|
||||
0x00, 0x00, 0x01, 0x80, 0x73, 0x00, 0x00, 0x01, 0x80, 0x7C, 0x00, 0x00,
|
||||
0x01, 0x81, 0x02, 0x00, 0x00, 0x92, 0x05, 0x05, 0x34, 0x42, 0x01, 0x00,
|
||||
0x00, 0x34, 0x01, 0x0A, 0x0E, 0x09, 0x01, 0x9A, 0xFF, 0xB8, 0x00, 0x0A,
|
||||
0x00, 0x00, 0x01, 0x82, 0x19, 0x00, 0x00, 0x01, 0x82, 0x01, 0x00, 0x00,
|
||||
0x01, 0x81, 0x68, 0x00, 0x04, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02, 0x03,
|
||||
0x03, 0x02, 0x03, 0x02, 0x01, 0x11, 0x06, 0x07, 0x02, 0x02, 0x02, 0x00,
|
||||
0x0D, 0x04, 0x05, 0x02, 0x03, 0x02, 0x01, 0x0D, 0x00, 0x02, 0x03, 0x00,
|
||||
0x03, 0x01, 0x25, 0x02, 0x01, 0x13, 0x3B, 0x02, 0x00, 0x0F, 0x15, 0x00,
|
||||
0x00, 0x01, 0x81, 0x74, 0x00, 0x00, 0x05, 0x02, 0x52, 0x28, 0x00, 0x00,
|
||||
0x06, 0x02, 0x53, 0x28, 0x00, 0x00, 0x01, 0x10, 0x77, 0x00, 0x00, 0x11,
|
||||
0x05, 0x02, 0x56, 0x28, 0x74, 0x00, 0x00, 0x11, 0x05, 0x02, 0x56, 0x28,
|
||||
0x75, 0x00, 0x00, 0x06, 0x02, 0x4C, 0x28, 0x00, 0x00, 0x01, 0x82, 0x11,
|
||||
0x00, 0x00, 0x25, 0x20, 0x01, 0x08, 0x0E, 0x3B, 0x40, 0x20, 0x09, 0x00,
|
||||
0x09, 0x03, 0x00, 0x5B, 0x2B, 0xAF, 0x39, 0xAF, 0xB3, 0x25, 0x01, 0x20,
|
||||
0x11, 0x06, 0x11, 0x24, 0x74, 0xAD, 0xB3, 0x01, 0x02, 0x78, 0xB0, 0x01,
|
||||
0x02, 0x12, 0x06, 0x02, 0x57, 0x28, 0x79, 0xB3, 0x01, 0x02, 0x78, 0xAE,
|
||||
0xAF, 0xC2, 0x9C, 0x65, 0x61, 0x21, 0x16, 0xAF, 0xA7, 0x29, 0x69, 0x06,
|
||||
0x02, 0x4B, 0x28, 0xA7, 0x29, 0x71, 0x06, 0x02, 0x4B, 0x28, 0x79, 0x02,
|
||||
0x00, 0x06, 0x05, 0x9D, 0x03, 0x01, 0x04, 0x09, 0x9C, 0x61, 0x68, 0x21,
|
||||
0x27, 0x05, 0x02, 0x4A, 0x28, 0x68, 0x65, 0x21, 0x16, 0xAF, 0xAF, 0x9E,
|
||||
0x05, 0x02, 0x57, 0x28, 0xBC, 0x26, 0x06, 0x27, 0xC2, 0xA4, 0xAF, 0x63,
|
||||
0xAA, 0x03, 0x03, 0x63, 0x3B, 0x02, 0x03, 0x09, 0x3B, 0x02, 0x03, 0x0A,
|
||||
0xAA, 0x03, 0x04, 0x79, 0x64, 0x2A, 0x01, 0x81, 0x00, 0x09, 0x02, 0x03,
|
||||
0x12, 0x06, 0x02, 0x58, 0x28, 0x79, 0x5A, 0x03, 0x02, 0x04, 0x3A, 0x88,
|
||||
0x26, 0x06, 0x34, 0x9E, 0x05, 0x02, 0x57, 0x28, 0x6A, 0x26, 0x06, 0x04,
|
||||
0x01, 0x17, 0x04, 0x12, 0x6B, 0x26, 0x06, 0x04, 0x01, 0x18, 0x04, 0x0A,
|
||||
0x6C, 0x26, 0x06, 0x04, 0x01, 0x19, 0x04, 0x02, 0x57, 0x28, 0x03, 0x05,
|
||||
0x79, 0xA4, 0x25, 0x03, 0x06, 0x25, 0x63, 0x34, 0x0D, 0x06, 0x02, 0x50,
|
||||
0x28, 0xA5, 0x59, 0x03, 0x02, 0x04, 0x02, 0x57, 0x28, 0x79, 0x02, 0x00,
|
||||
0x06, 0x21, 0x02, 0x02, 0x5A, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02, 0x03,
|
||||
0x02, 0x04, 0x1D, 0x04, 0x10, 0x59, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02,
|
||||
0x05, 0x02, 0x06, 0x1C, 0x04, 0x03, 0x57, 0x28, 0x24, 0x04, 0x24, 0x02,
|
||||
0x02, 0x5A, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02, 0x03, 0x02, 0x04, 0x23,
|
||||
0x04, 0x10, 0x59, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02, 0x05, 0x02, 0x06,
|
||||
0x22, 0x04, 0x03, 0x57, 0x28, 0x24, 0x25, 0x06, 0x01, 0x28, 0x24, 0x01,
|
||||
0x00, 0x03, 0x07, 0xB4, 0x01, 0x21, 0x8F, 0x01, 0x22, 0x8F, 0x25, 0x01,
|
||||
0x23, 0x11, 0x06, 0x81, 0x20, 0x24, 0x74, 0xAD, 0xAF, 0x25, 0x06, 0x81,
|
||||
0x14, 0x01, 0x00, 0x03, 0x08, 0xAF, 0x9E, 0x24, 0xB3, 0x25, 0x01, 0x01,
|
||||
0x11, 0x06, 0x04, 0xA6, 0x03, 0x08, 0xB3, 0x01, 0x04, 0x78, 0xAD, 0x70,
|
||||
0x26, 0x06, 0x0F, 0x02, 0x00, 0x06, 0x03, 0xC3, 0x04, 0x05, 0x99, 0x01,
|
||||
0x7F, 0x03, 0x07, 0x04, 0x80, 0x66, 0x91, 0x26, 0x06, 0x06, 0x02, 0x00,
|
||||
0x9B, 0x04, 0x80, 0x5C, 0xC5, 0x26, 0x06, 0x11, 0x02, 0x00, 0x06, 0x09,
|
||||
0x01, 0x00, 0x03, 0x01, 0x98, 0x03, 0x01, 0x04, 0x01, 0xC3, 0x04, 0x80,
|
||||
0x47, 0x73, 0x26, 0x06, 0x0A, 0x02, 0x08, 0x06, 0x03, 0x9A, 0x04, 0x01,
|
||||
0xC3, 0x04, 0x39, 0x6F, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x32, 0xC8, 0x26,
|
||||
0x06, 0x03, 0xC3, 0x04, 0x2B, 0x90, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x24,
|
||||
0xC6, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x1D, 0x7A, 0x26, 0x06, 0x03, 0xC3,
|
||||
0x04, 0x16, 0x85, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x0F, 0x6E, 0x26, 0x06,
|
||||
0x03, 0xC3, 0x04, 0x08, 0xC7, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x01, 0xC3,
|
||||
0x79, 0x79, 0x04, 0xFE, 0x68, 0x79, 0x79, 0x04, 0x08, 0x01, 0x7F, 0x11,
|
||||
0x05, 0x02, 0x56, 0x28, 0x24, 0x79, 0x3A, 0x02, 0x00, 0x06, 0x08, 0x02,
|
||||
0x01, 0x3C, 0x2F, 0x05, 0x02, 0x45, 0x28, 0x02, 0x00, 0x06, 0x01, 0x17,
|
||||
0x02, 0x00, 0x02, 0x07, 0x2F, 0x05, 0x02, 0x51, 0x28, 0xB3, 0x76, 0xAD,
|
||||
0x9E, 0x06, 0x80, 0x77, 0xBD, 0x26, 0x06, 0x07, 0x01, 0x02, 0x5A, 0x8A,
|
||||
0x04, 0x80, 0x5E, 0xBE, 0x26, 0x06, 0x07, 0x01, 0x03, 0x5A, 0x8B, 0x04,
|
||||
0x80, 0x53, 0xBF, 0x26, 0x06, 0x07, 0x01, 0x04, 0x5A, 0x8C, 0x04, 0x80,
|
||||
0x48, 0xC0, 0x26, 0x06, 0x06, 0x01, 0x05, 0x5A, 0x8D, 0x04, 0x3E, 0xC1,
|
||||
0x26, 0x06, 0x06, 0x01, 0x06, 0x5A, 0x8E, 0x04, 0x34, 0x7F, 0x26, 0x06,
|
||||
0x06, 0x01, 0x02, 0x59, 0x8A, 0x04, 0x2A, 0x80, 0x26, 0x06, 0x06, 0x01,
|
||||
0x03, 0x59, 0x8B, 0x04, 0x20, 0x81, 0x26, 0x06, 0x06, 0x01, 0x04, 0x59,
|
||||
0x8C, 0x04, 0x16, 0x82, 0x26, 0x06, 0x06, 0x01, 0x05, 0x59, 0x8D, 0x04,
|
||||
0x0C, 0x83, 0x26, 0x06, 0x06, 0x01, 0x06, 0x59, 0x8E, 0x04, 0x02, 0x57,
|
||||
0x28, 0x5E, 0x35, 0x60, 0x37, 0x1B, 0x25, 0x05, 0x02, 0x57, 0x28, 0x5D,
|
||||
0x37, 0x04, 0x02, 0x57, 0x28, 0xC2, 0xA4, 0x25, 0x01,
|
||||
T0_INT2(BR_X509_BUFSIZE_SIG), 0x12, 0x06, 0x02, 0x50, 0x28, 0x25, 0x5F,
|
||||
0x35, 0x5C, 0xA5, 0x79, 0x79, 0x01, 0x00, 0x5B, 0x36, 0x18, 0x00, 0x00,
|
||||
0x01, 0x30, 0x0A, 0x25, 0x01, 0x00, 0x01, 0x09, 0x72, 0x05, 0x02, 0x48,
|
||||
0x28, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x01, 0x81, 0x08, 0x00, 0x00,
|
||||
0x01, 0x81, 0x10, 0x00, 0x00, 0x01, 0x81, 0x19, 0x00, 0x00, 0x01, 0x81,
|
||||
0x22, 0x00, 0x00, 0x01, 0x81, 0x2B, 0x00, 0x01, 0x7E, 0x01, 0x01, 0x11,
|
||||
0x3B, 0x01, 0x83, 0xFD, 0x7F, 0x11, 0x15, 0x06, 0x03, 0x3B, 0x24, 0x00,
|
||||
0x3B, 0x25, 0x03, 0x00, 0x25, 0xCA, 0x05, 0x04, 0x42, 0x01, 0x00, 0x00,
|
||||
0x25, 0x01, 0x81, 0x00, 0x0D, 0x06, 0x04, 0x96, 0x04, 0x80, 0x49, 0x25,
|
||||
0x01, 0x90, 0x00, 0x0D, 0x06, 0x0F, 0x01, 0x06, 0x14, 0x01, 0x81, 0x40,
|
||||
0x2F, 0x96, 0x02, 0x00, 0x01, 0x00, 0x97, 0x04, 0x33, 0x25, 0x01, 0x83,
|
||||
0xFF, 0x7F, 0x0D, 0x06, 0x14, 0x01, 0x0C, 0x14, 0x01, 0x81, 0x60, 0x2F,
|
||||
0x96, 0x02, 0x00, 0x01, 0x06, 0x97, 0x02, 0x00, 0x01, 0x00, 0x97, 0x04,
|
||||
0x17, 0x01, 0x12, 0x14, 0x01, 0x81, 0x70, 0x2F, 0x96, 0x02, 0x00, 0x01,
|
||||
0x0C, 0x97, 0x02, 0x00, 0x01, 0x06, 0x97, 0x02, 0x00, 0x01, 0x00, 0x97,
|
||||
0x00, 0x00, 0x01, 0x82, 0x15, 0x00, 0x00, 0x25, 0x01, 0x83, 0xB0, 0x00,
|
||||
0x01, 0x83, 0xB7, 0x7F, 0x72, 0x00, 0x00, 0x01, 0x81, 0x34, 0x00, 0x00,
|
||||
0x01, 0x80, 0x6B, 0x00, 0x00, 0x01, 0x81, 0x78, 0x00, 0x00, 0x01, 0x3D,
|
||||
0x00, 0x00, 0x01, 0x80, 0x43, 0x00, 0x00, 0x01, 0x80, 0x4D, 0x00, 0x00,
|
||||
0x01, 0x80, 0x57, 0x00, 0x00, 0x01, 0x80, 0x61, 0x00, 0x00, 0x30, 0x11,
|
||||
0x06, 0x04, 0x42, 0xAD, 0xC2, 0xB4, 0x00, 0x00, 0x01, 0x82, 0x09, 0x00,
|
||||
0x00, 0x01, 0x81, 0x6C, 0x00, 0x00, 0x25, 0x01, 0x83, 0xB8, 0x00, 0x01,
|
||||
0x83, 0xBF, 0x7F, 0x72, 0x00, 0x00, 0x01, 0x30, 0x62, 0x37, 0x01, 0x7F,
|
||||
0x7C, 0x19, 0x01, 0x00, 0x7C, 0x19, 0x04, 0x7A, 0x00, 0x01, 0x81, 0x38,
|
||||
0x00, 0x01, 0x7E, 0x0D, 0x06, 0x02, 0x4F, 0x28, 0x25, 0x03, 0x00, 0x0A,
|
||||
0x02, 0x00, 0x00, 0x00, 0x30, 0x25, 0x3F, 0x3B, 0x01, 0x82, 0x00, 0x13,
|
||||
0x2F, 0x06, 0x04, 0x42, 0x01, 0x00, 0x00, 0x30, 0x67, 0x09, 0x37, 0x40,
|
||||
0x00, 0x00, 0x14, 0x01, 0x3F, 0x15, 0x01, 0x81, 0x00, 0x2F, 0x96, 0x00,
|
||||
0x02, 0x01, 0x00, 0x03, 0x00, 0xAF, 0x25, 0x06, 0x80, 0x59, 0xB3, 0x01,
|
||||
0x20, 0x30, 0x11, 0x06, 0x17, 0x24, 0x74, 0xAD, 0x9E, 0x24, 0x01, 0x7F,
|
||||
0x2E, 0x03, 0x01, 0xB3, 0x01, 0x20, 0x77, 0xAD, 0xB2, 0x02, 0x01, 0x1F,
|
||||
0x79, 0x79, 0x04, 0x38, 0x01, 0x21, 0x30, 0x11, 0x06, 0x08, 0x24, 0x75,
|
||||
0xB6, 0x01, 0x01, 0x1E, 0x04, 0x2A, 0x01, 0x22, 0x30, 0x11, 0x06, 0x11,
|
||||
0x24, 0x75, 0xB6, 0x25, 0x06, 0x06, 0x2C, 0x02, 0x00, 0x2F, 0x03, 0x00,
|
||||
0x01, 0x02, 0x1E, 0x04, 0x13, 0x01, 0x26, 0x30, 0x11, 0x06, 0x08, 0x24,
|
||||
0x75, 0xB6, 0x01, 0x06, 0x1E, 0x04, 0x05, 0x42, 0xAE, 0x01, 0x00, 0x24,
|
||||
0x04, 0xFF, 0x23, 0x79, 0x02, 0x00, 0x00, 0x00, 0xAF, 0xB4, 0x25, 0x01,
|
||||
0x01, 0x11, 0x06, 0x08, 0xA6, 0x05, 0x02, 0x51, 0x28, 0xB4, 0x04, 0x02,
|
||||
0x51, 0x28, 0x25, 0x01, 0x02, 0x11, 0x06, 0x0C, 0x24, 0x75, 0xB0, 0x66,
|
||||
0x2B, 0x41, 0x0D, 0x06, 0x02, 0x51, 0x28, 0xB4, 0x01, 0x7F, 0x10, 0x06,
|
||||
0x02, 0x56, 0x28, 0x24, 0x79, 0x00, 0x00, 0xAF, 0x25, 0x06, 0x1A, 0xAF,
|
||||
0x9E, 0x24, 0x25, 0x06, 0x11, 0xAF, 0x25, 0x06, 0x0C, 0xAF, 0x9E, 0x24,
|
||||
0x89, 0x26, 0x05, 0x02, 0x49, 0x28, 0xC2, 0x04, 0x71, 0x79, 0x79, 0x04,
|
||||
0x63, 0x79, 0x00, 0x02, 0x03, 0x00, 0xB3, 0x01, 0x03, 0x78, 0xAD, 0xBA,
|
||||
0x03, 0x01, 0x02, 0x01, 0x01, 0x07, 0x12, 0x06, 0x02, 0x56, 0x28, 0x25,
|
||||
0x01, 0x00, 0x30, 0x11, 0x06, 0x05, 0x24, 0x4D, 0x28, 0x04, 0x15, 0x01,
|
||||
0x01, 0x30, 0x11, 0x06, 0x0A, 0x24, 0xBA, 0x02, 0x01, 0x14, 0x02, 0x01,
|
||||
0x0E, 0x04, 0x05, 0x24, 0xBA, 0x01, 0x00, 0x24, 0x02, 0x00, 0x06, 0x19,
|
||||
0x01, 0x00, 0x30, 0x01, 0x38, 0x15, 0x06, 0x03, 0x01, 0x10, 0x2F, 0x3B,
|
||||
0x01, 0x81, 0x40, 0x15, 0x06, 0x03, 0x01, 0x20, 0x2F, 0x62, 0x37, 0x04,
|
||||
0x07, 0x01, 0x04, 0x15, 0x05, 0x02, 0x4D, 0x28, 0xC2, 0x00, 0x00, 0x38,
|
||||
0xAF, 0xC2, 0x1A, 0x00, 0x03, 0x01, 0x00, 0x03, 0x00, 0x38, 0xAF, 0x25,
|
||||
0x06, 0x30, 0xB3, 0x01, 0x11, 0x77, 0xAD, 0x25, 0x05, 0x02, 0x44, 0x28,
|
||||
0x25, 0x06, 0x20, 0xAF, 0x9E, 0x24, 0x87, 0x26, 0x03, 0x01, 0x01, 0x00,
|
||||
0x2E, 0x03, 0x02, 0xB2, 0x25, 0x02, 0x01, 0x15, 0x06, 0x07, 0x2C, 0x06,
|
||||
0x04, 0x01, 0x7F, 0x03, 0x00, 0x02, 0x02, 0x1F, 0x79, 0x04, 0x5D, 0x79,
|
||||
0x04, 0x4D, 0x79, 0x1A, 0x02, 0x00, 0x00, 0x00, 0xB3, 0x01, 0x06, 0x78,
|
||||
0xB1, 0x00, 0x00, 0xB8, 0x86, 0x06, 0x0E, 0x3B, 0x25, 0x05, 0x06, 0x42,
|
||||
0x01, 0x00, 0x01, 0x00, 0x00, 0xB8, 0x6D, 0x04, 0x08, 0x92, 0x06, 0x05,
|
||||
0x24, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0xB9, 0x86, 0x06, 0x0E, 0x3B,
|
||||
0x25, 0x05, 0x06, 0x42, 0x01, 0x00, 0x01, 0x00, 0x00, 0xB9, 0x6D, 0x04,
|
||||
0x08, 0x92, 0x06, 0x05, 0x24, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBA,
|
||||
0x25, 0x01, 0x81, 0x00, 0x0D, 0x06, 0x04, 0x00, 0x04, 0x80, 0x55, 0x25,
|
||||
0x01, 0x81, 0x40, 0x0D, 0x06, 0x07, 0x24, 0x01, 0x00, 0x00, 0x04, 0x80,
|
||||
0x47, 0x25, 0x01, 0x81, 0x60, 0x0D, 0x06, 0x0E, 0x01, 0x1F, 0x15, 0x01,
|
||||
0x01, 0xA3, 0x01, 0x81, 0x00, 0x01, 0x8F, 0x7F, 0x04, 0x32, 0x25, 0x01,
|
||||
0x81, 0x70, 0x0D, 0x06, 0x0F, 0x01, 0x0F, 0x15, 0x01, 0x02, 0xA3, 0x01,
|
||||
0x90, 0x00, 0x01, 0x83, 0xFF, 0x7F, 0x04, 0x1C, 0x25, 0x01, 0x81, 0x78,
|
||||
0x0D, 0x06, 0x11, 0x01, 0x07, 0x15, 0x01, 0x03, 0xA3, 0x01, 0x84, 0x80,
|
||||
0x00, 0x01, 0x80, 0xC3, 0xFF, 0x7F, 0x04, 0x04, 0x24, 0x01, 0x00, 0x00,
|
||||
0x72, 0x05, 0x03, 0x24, 0x01, 0x00, 0x00, 0x00, 0x3B, 0x25, 0x05, 0x06,
|
||||
0x42, 0x01, 0x00, 0x01, 0x7F, 0x00, 0xBA, 0x34, 0x25, 0x3D, 0x06, 0x03,
|
||||
0x3B, 0x24, 0x00, 0x01, 0x06, 0x0E, 0x3B, 0x25, 0x01, 0x06, 0x14, 0x01,
|
||||
0x02, 0x10, 0x06, 0x04, 0x42, 0x01, 0x7F, 0x00, 0x01, 0x3F, 0x15, 0x09,
|
||||
0x00, 0x00, 0x25, 0x06, 0x06, 0x0B, 0xA2, 0x34, 0x41, 0x04, 0x77, 0x24,
|
||||
0x25, 0x00, 0x00, 0xB3, 0x01, 0x03, 0x78, 0xAD, 0xBA, 0x06, 0x02, 0x55,
|
||||
0x28, 0x00, 0x00, 0x3B, 0x25, 0x06, 0x07, 0x31, 0x25, 0x06, 0x01, 0x19,
|
||||
0x04, 0x76, 0x42, 0x00, 0x00, 0x01, 0x01, 0x78, 0xAC, 0x01, 0x01, 0x10,
|
||||
0x06, 0x02, 0x43, 0x28, 0xBA, 0x3E, 0x00, 0x04, 0xB3, 0x25, 0x01, 0x17,
|
||||
0x01, 0x18, 0x72, 0x05, 0x02, 0x48, 0x28, 0x01, 0x18, 0x11, 0x03, 0x00,
|
||||
0x75, 0xAD, 0xA8, 0x02, 0x00, 0x06, 0x0C, 0x01, 0x80, 0x64, 0x08, 0x03,
|
||||
0x01, 0xA8, 0x02, 0x01, 0x09, 0x04, 0x0E, 0x25, 0x01, 0x32, 0x0D, 0x06,
|
||||
0x04, 0x01, 0x80, 0x64, 0x09, 0x01, 0x8E, 0x6C, 0x09, 0x03, 0x01, 0x02,
|
||||
0x01, 0x01, 0x82, 0x6D, 0x08, 0x02, 0x01, 0x01, 0x03, 0x09, 0x01, 0x04,
|
||||
0x0C, 0x09, 0x02, 0x01, 0x01, 0x80, 0x63, 0x09, 0x01, 0x80, 0x64, 0x0C,
|
||||
0x0A, 0x02, 0x01, 0x01, 0x83, 0x0F, 0x09, 0x01, 0x83, 0x10, 0x0C, 0x09,
|
||||
0x03, 0x03, 0x01, 0x01, 0x01, 0x0C, 0xA9, 0x41, 0x01, 0x01, 0x0E, 0x02,
|
||||
0x01, 0x01, 0x04, 0x07, 0x3F, 0x02, 0x01, 0x01, 0x80, 0x64, 0x07, 0x3E,
|
||||
0x02, 0x01, 0x01, 0x83, 0x10, 0x07, 0x3F, 0x2F, 0x15, 0x06, 0x03, 0x01,
|
||||
0x18, 0x09, 0x94, 0x09, 0x7B, 0x25, 0x01, 0x05, 0x14, 0x02, 0x03, 0x09,
|
||||
0x03, 0x03, 0x01, 0x1F, 0x15, 0x01, 0x01, 0x3B, 0xA9, 0x02, 0x03, 0x09,
|
||||
0x41, 0x03, 0x03, 0x01, 0x00, 0x01, 0x17, 0xA9, 0x01, 0x9C, 0x10, 0x08,
|
||||
0x03, 0x02, 0x01, 0x00, 0x01, 0x3B, 0xA9, 0x01, 0x3C, 0x08, 0x02, 0x02,
|
||||
0x09, 0x03, 0x02, 0x01, 0x00, 0x01, 0x3C, 0xA9, 0x02, 0x02, 0x09, 0x03,
|
||||
0x02, 0xBA, 0x25, 0x01, 0x2E, 0x11, 0x06, 0x0D, 0x24, 0xBA, 0x25, 0x01,
|
||||
0x30, 0x01, 0x39, 0x72, 0x06, 0x03, 0x24, 0x04, 0x74, 0x01, 0x80, 0x5A,
|
||||
0x10, 0x06, 0x02, 0x48, 0x28, 0x79, 0x02, 0x03, 0x02, 0x02, 0x00, 0x01,
|
||||
0xBA, 0x7D, 0x01, 0x0A, 0x08, 0x03, 0x00, 0xBA, 0x7D, 0x02, 0x00, 0x09,
|
||||
0x00, 0x02, 0x03, 0x00, 0x03, 0x01, 0xA8, 0x25, 0x02, 0x01, 0x02, 0x00,
|
||||
0x72, 0x05, 0x02, 0x48, 0x28, 0x00, 0x00, 0x34, 0xB3, 0x01, 0x02, 0x78,
|
||||
0x0B, 0xAB, 0x00, 0x03, 0x25, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02, 0xAD,
|
||||
0xBA, 0x25, 0x01, 0x81, 0x00, 0x13, 0x06, 0x02, 0x54, 0x28, 0x25, 0x01,
|
||||
0x00, 0x11, 0x06, 0x0B, 0x24, 0x25, 0x05, 0x04, 0x24, 0x01, 0x00, 0x00,
|
||||
0xBA, 0x04, 0x6F, 0x02, 0x01, 0x25, 0x05, 0x02, 0x50, 0x28, 0x41, 0x03,
|
||||
0x01, 0x02, 0x02, 0x37, 0x02, 0x02, 0x40, 0x03, 0x02, 0x25, 0x06, 0x03,
|
||||
0xBA, 0x04, 0x68, 0x24, 0x02, 0x00, 0x02, 0x01, 0x0A, 0x00, 0x01, 0xBA,
|
||||
0x25, 0x01, 0x81, 0x00, 0x0D, 0x06, 0x01, 0x00, 0x01, 0x81, 0x00, 0x0A,
|
||||
0x25, 0x05, 0x02, 0x4E, 0x28, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01,
|
||||
0x00, 0x12, 0x06, 0x19, 0x02, 0x00, 0x41, 0x03, 0x00, 0x25, 0x01, 0x83,
|
||||
0xFF, 0xFF, 0x7F, 0x12, 0x06, 0x02, 0x4F, 0x28, 0x01, 0x08, 0x0E, 0x3B,
|
||||
0xBA, 0x34, 0x09, 0x04, 0x60, 0x00, 0x00, 0xAC, 0x95, 0x00, 0x00, 0xAD,
|
||||
0xC2, 0x00, 0x00, 0xB3, 0x76, 0xAD, 0x00, 0x01, 0xAD, 0x25, 0x05, 0x02,
|
||||
0x54, 0x28, 0xBA, 0x25, 0x01, 0x81, 0x00, 0x13, 0x06, 0x02, 0x54, 0x28,
|
||||
0x03, 0x00, 0x25, 0x06, 0x16, 0xBA, 0x02, 0x00, 0x25, 0x01, 0x87, 0xFF,
|
||||
0xFF, 0x7F, 0x13, 0x06, 0x02, 0x54, 0x28, 0x01, 0x08, 0x0E, 0x09, 0x03,
|
||||
0x00, 0x04, 0x67, 0x24, 0x02, 0x00, 0x00, 0x00, 0xAD, 0x25, 0x01, 0x81,
|
||||
0x7F, 0x12, 0x06, 0x08, 0xC2, 0x01, 0x00, 0x67, 0x37, 0x01, 0x00, 0x00,
|
||||
0x25, 0x67, 0x37, 0x67, 0x40, 0xA5, 0x01, 0x7F, 0x00, 0x00, 0xB3, 0x01,
|
||||
0x0C, 0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB6, 0x04, 0x3E, 0x01, 0x12,
|
||||
0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x33, 0x01, 0x13, 0x30,
|
||||
0x11, 0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x28, 0x01, 0x14, 0x30, 0x11,
|
||||
0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x1D, 0x01, 0x16, 0x30, 0x11, 0x06,
|
||||
0x05, 0x24, 0x75, 0xB7, 0x04, 0x12, 0x01, 0x1E, 0x30, 0x11, 0x06, 0x05,
|
||||
0x24, 0x75, 0xB5, 0x04, 0x07, 0x42, 0xAE, 0x01, 0x00, 0x01, 0x00, 0x24,
|
||||
0x00, 0x01, 0xBA, 0x03, 0x00, 0x02, 0x00, 0x01, 0x05, 0x14, 0x01, 0x01,
|
||||
0x15, 0x2D, 0x02, 0x00, 0x01, 0x06, 0x14, 0x25, 0x01, 0x01, 0x15, 0x06,
|
||||
0x02, 0x46, 0x28, 0x01, 0x04, 0x0E, 0x02, 0x00, 0x01, 0x1F, 0x15, 0x25,
|
||||
0x01, 0x1F, 0x11, 0x06, 0x02, 0x47, 0x28, 0x09, 0x00, 0x00, 0x25, 0x05,
|
||||
0x05, 0x01, 0x00, 0x01, 0x7F, 0x00, 0xB3, 0x00, 0x01, 0xAD, 0x25, 0x05,
|
||||
0x05, 0x67, 0x37, 0x01, 0x7F, 0x00, 0x01, 0x01, 0x03, 0x00, 0x9F, 0x25,
|
||||
0x01, 0x83, 0xFF, 0x7E, 0x11, 0x06, 0x16, 0x24, 0x25, 0x06, 0x10, 0xA0,
|
||||
0x25, 0x05, 0x05, 0x24, 0xC2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x84, 0x03,
|
||||
0x00, 0x04, 0x6D, 0x04, 0x1B, 0x25, 0x05, 0x05, 0x24, 0xC2, 0x01, 0x00,
|
||||
0x00, 0x02, 0x00, 0x84, 0x03, 0x00, 0x25, 0x06, 0x0B, 0x9F, 0x25, 0x05,
|
||||
0x05, 0x24, 0xC2, 0x01, 0x00, 0x00, 0x04, 0x6D, 0x24, 0x02, 0x00, 0x25,
|
||||
0x05, 0x01, 0x00, 0x41, 0x67, 0x37, 0x01, 0x7F, 0x00, 0x01, 0xAD, 0x01,
|
||||
0x01, 0x03, 0x00, 0x25, 0x06, 0x10, 0xA1, 0x25, 0x05, 0x05, 0x24, 0xC2,
|
||||
0x01, 0x00, 0x00, 0x02, 0x00, 0x84, 0x03, 0x00, 0x04, 0x6D, 0x24, 0x02,
|
||||
0x00, 0x25, 0x05, 0x01, 0x00, 0x41, 0x67, 0x37, 0x01, 0x7F, 0x00, 0x01,
|
||||
0xAD, 0x01, 0x01, 0x03, 0x00, 0x25, 0x06, 0x10, 0xBA, 0x25, 0x05, 0x05,
|
||||
0x24, 0xC2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x84, 0x03, 0x00, 0x04, 0x6D,
|
||||
0x24, 0x02, 0x00, 0x25, 0x05, 0x01, 0x00, 0x41, 0x67, 0x37, 0x01, 0x7F,
|
||||
0x00, 0x00, 0xBA, 0x01, 0x08, 0x0E, 0x3B, 0xBA, 0x34, 0x09, 0x00, 0x00,
|
||||
0xBA, 0x3B, 0xBA, 0x01, 0x08, 0x0E, 0x34, 0x09, 0x00, 0x00, 0x25, 0x05,
|
||||
0x02, 0x4F, 0x28, 0x41, 0xBB, 0x00, 0x00, 0x32, 0x25, 0x01, 0x00, 0x13,
|
||||
0x06, 0x01, 0x00, 0x24, 0x19, 0x04, 0x74, 0x00, 0x01, 0x01, 0x00, 0x00,
|
||||
0x01, 0x0B, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x1F, 0x00, 0x00,
|
||||
0x01, 0x29, 0x00, 0x00, 0x01, 0x33, 0x00, 0x00, 0xC3, 0x24, 0x00, 0x00,
|
||||
0x25, 0x06, 0x07, 0xC4, 0x25, 0x06, 0x01, 0x19, 0x04, 0x76, 0x00, 0x00,
|
||||
0x01, 0x00, 0x30, 0x31, 0x0B, 0x42, 0x00, 0x00, 0x01, 0x81, 0x70, 0x00,
|
||||
0x00, 0x01, 0x82, 0x0D, 0x00, 0x00, 0x01, 0x82, 0x22, 0x00, 0x00, 0x01,
|
||||
0x82, 0x05, 0x00, 0x00, 0x01, 0x03, 0x33, 0x01, 0x03, 0x33, 0x00, 0x00,
|
||||
0x25, 0x01, 0x83, 0xFB, 0x50, 0x01, 0x83, 0xFB, 0x6F, 0x72, 0x06, 0x04,
|
||||
0x24, 0x01, 0x00, 0x00, 0x25, 0x01, 0x83, 0xB0, 0x00, 0x01, 0x83, 0xBF,
|
||||
0x7F, 0x72, 0x06, 0x04, 0x24, 0x01, 0x00, 0x00, 0x01, 0x83, 0xFF, 0x7F,
|
||||
0x15, 0x01, 0x83, 0xFF, 0x7E, 0x0D, 0x00
|
||||
T0_INT2(offsetof(CONTEXT_NAME, saved_dn_hash)), 0x00, 0x00, 0x01, 0x80,
|
||||
0x73, 0x00, 0x00, 0x01, 0x80, 0x7C, 0x00, 0x00, 0x01, 0x81, 0x02, 0x00,
|
||||
0x00, 0x8F, 0x05, 0x05, 0x33, 0x41, 0x01, 0x00, 0x00, 0x33, 0x01, 0x0A,
|
||||
0x0E, 0x09, 0x01, 0x9A, 0xFF, 0xB8, 0x00, 0x0A, 0x00, 0x00, 0x01, 0x82,
|
||||
0x19, 0x00, 0x00, 0x01, 0x82, 0x01, 0x00, 0x00, 0x01, 0x81, 0x68, 0x00,
|
||||
0x02, 0x03, 0x00, 0x03, 0x01, 0x26, 0x02, 0x01, 0x13, 0x3A, 0x02, 0x00,
|
||||
0x0F, 0x15, 0x00, 0x00, 0x01, 0x81, 0x74, 0x00, 0x00, 0x05, 0x02, 0x51,
|
||||
0x29, 0x00, 0x00, 0x06, 0x02, 0x52, 0x29, 0x00, 0x00, 0x01, 0x10, 0x74,
|
||||
0x00, 0x00, 0x11, 0x05, 0x02, 0x55, 0x29, 0x71, 0x00, 0x00, 0x11, 0x05,
|
||||
0x02, 0x55, 0x29, 0x72, 0x00, 0x00, 0x06, 0x02, 0x4B, 0x29, 0x00, 0x00,
|
||||
0x01, 0x82, 0x11, 0x00, 0x00, 0x26, 0x21, 0x01, 0x08, 0x0E, 0x3A, 0x3F,
|
||||
0x21, 0x09, 0x00, 0x0B, 0x03, 0x00, 0x5A, 0x2B, 0xAC, 0x38, 0xAC, 0xB0,
|
||||
0x26, 0x01, 0x20, 0x11, 0x06, 0x11, 0x25, 0x71, 0xAA, 0xB0, 0x01, 0x02,
|
||||
0x75, 0xAD, 0x01, 0x02, 0x12, 0x06, 0x02, 0x56, 0x29, 0x76, 0xB0, 0x01,
|
||||
0x02, 0x75, 0xAB, 0xAC, 0xBF, 0x99, 0x64, 0x60, 0x22, 0x16, 0xAC, 0xA4,
|
||||
0x03, 0x01, 0x03, 0x02, 0xA4, 0x02, 0x02, 0x02, 0x01, 0x19, 0x06, 0x02,
|
||||
0x4A, 0x29, 0x76, 0x02, 0x00, 0x06, 0x05, 0x9A, 0x03, 0x03, 0x04, 0x09,
|
||||
0x99, 0x60, 0x67, 0x22, 0x28, 0x05, 0x02, 0x49, 0x29, 0x67, 0x64, 0x22,
|
||||
0x16, 0xAC, 0xAC, 0x9B, 0x05, 0x02, 0x56, 0x29, 0xB9, 0x27, 0x06, 0x27,
|
||||
0xBF, 0xA1, 0xAC, 0x62, 0xA7, 0x03, 0x05, 0x62, 0x3A, 0x02, 0x05, 0x09,
|
||||
0x3A, 0x02, 0x05, 0x0A, 0xA7, 0x03, 0x06, 0x76, 0x63, 0x2A, 0x01, 0x81,
|
||||
0x00, 0x09, 0x02, 0x05, 0x12, 0x06, 0x02, 0x57, 0x29, 0x76, 0x59, 0x03,
|
||||
0x04, 0x04, 0x3A, 0x85, 0x27, 0x06, 0x34, 0x9B, 0x05, 0x02, 0x56, 0x29,
|
||||
0x68, 0x27, 0x06, 0x04, 0x01, 0x17, 0x04, 0x12, 0x69, 0x27, 0x06, 0x04,
|
||||
0x01, 0x18, 0x04, 0x0A, 0x6A, 0x27, 0x06, 0x04, 0x01, 0x19, 0x04, 0x02,
|
||||
0x56, 0x29, 0x03, 0x07, 0x76, 0xA1, 0x26, 0x03, 0x08, 0x26, 0x62, 0x33,
|
||||
0x0D, 0x06, 0x02, 0x4F, 0x29, 0xA2, 0x58, 0x03, 0x04, 0x04, 0x02, 0x56,
|
||||
0x29, 0x76, 0x02, 0x00, 0x06, 0x21, 0x02, 0x04, 0x59, 0x30, 0x11, 0x06,
|
||||
0x08, 0x25, 0x02, 0x05, 0x02, 0x06, 0x1E, 0x04, 0x10, 0x58, 0x30, 0x11,
|
||||
0x06, 0x08, 0x25, 0x02, 0x07, 0x02, 0x08, 0x1D, 0x04, 0x03, 0x56, 0x29,
|
||||
0x25, 0x04, 0x24, 0x02, 0x04, 0x59, 0x30, 0x11, 0x06, 0x08, 0x25, 0x02,
|
||||
0x05, 0x02, 0x06, 0x24, 0x04, 0x10, 0x58, 0x30, 0x11, 0x06, 0x08, 0x25,
|
||||
0x02, 0x07, 0x02, 0x08, 0x23, 0x04, 0x03, 0x56, 0x29, 0x25, 0x26, 0x06,
|
||||
0x01, 0x29, 0x25, 0x01, 0x00, 0x03, 0x09, 0xB1, 0x01, 0x21, 0x8C, 0x01,
|
||||
0x22, 0x8C, 0x26, 0x01, 0x23, 0x11, 0x06, 0x81, 0x26, 0x25, 0x71, 0xAA,
|
||||
0xAC, 0x26, 0x06, 0x81, 0x1A, 0x01, 0x00, 0x03, 0x0A, 0xAC, 0x9B, 0x25,
|
||||
0xB0, 0x26, 0x01, 0x01, 0x11, 0x06, 0x04, 0xA3, 0x03, 0x0A, 0xB0, 0x01,
|
||||
0x04, 0x75, 0xAA, 0x6E, 0x27, 0x06, 0x0F, 0x02, 0x00, 0x06, 0x03, 0xC0,
|
||||
0x04, 0x05, 0x96, 0x01, 0x7F, 0x03, 0x09, 0x04, 0x80, 0x6C, 0x8E, 0x27,
|
||||
0x06, 0x06, 0x02, 0x00, 0x98, 0x04, 0x80, 0x62, 0xC2, 0x27, 0x06, 0x11,
|
||||
0x02, 0x00, 0x06, 0x09, 0x01, 0x00, 0x03, 0x03, 0x95, 0x03, 0x03, 0x04,
|
||||
0x01, 0xC0, 0x04, 0x80, 0x4D, 0x70, 0x27, 0x06, 0x0A, 0x02, 0x0A, 0x06,
|
||||
0x03, 0x97, 0x04, 0x01, 0xC0, 0x04, 0x3F, 0x6D, 0x27, 0x06, 0x03, 0xC0,
|
||||
0x04, 0x38, 0xC5, 0x27, 0x06, 0x03, 0xC0, 0x04, 0x31, 0x8D, 0x27, 0x06,
|
||||
0x03, 0xC0, 0x04, 0x2A, 0xC3, 0x27, 0x06, 0x03, 0xC0, 0x04, 0x23, 0x77,
|
||||
0x27, 0x06, 0x03, 0xC0, 0x04, 0x1C, 0x82, 0x27, 0x06, 0x03, 0xC0, 0x04,
|
||||
0x15, 0x6C, 0x27, 0x06, 0x03, 0xC0, 0x04, 0x0E, 0xC4, 0x27, 0x06, 0x03,
|
||||
0xC0, 0x04, 0x07, 0x02, 0x0A, 0x06, 0x02, 0x48, 0x29, 0xC0, 0x76, 0x76,
|
||||
0x04, 0xFE, 0x62, 0x76, 0x76, 0x04, 0x08, 0x01, 0x7F, 0x11, 0x05, 0x02,
|
||||
0x55, 0x29, 0x25, 0x76, 0x39, 0x02, 0x00, 0x06, 0x08, 0x02, 0x03, 0x3B,
|
||||
0x2F, 0x05, 0x02, 0x44, 0x29, 0x02, 0x00, 0x06, 0x01, 0x17, 0x02, 0x00,
|
||||
0x02, 0x09, 0x2F, 0x05, 0x02, 0x50, 0x29, 0xB0, 0x73, 0xAA, 0x9B, 0x06,
|
||||
0x80, 0x77, 0xBA, 0x27, 0x06, 0x07, 0x01, 0x02, 0x59, 0x87, 0x04, 0x80,
|
||||
0x5E, 0xBB, 0x27, 0x06, 0x07, 0x01, 0x03, 0x59, 0x88, 0x04, 0x80, 0x53,
|
||||
0xBC, 0x27, 0x06, 0x07, 0x01, 0x04, 0x59, 0x89, 0x04, 0x80, 0x48, 0xBD,
|
||||
0x27, 0x06, 0x06, 0x01, 0x05, 0x59, 0x8A, 0x04, 0x3E, 0xBE, 0x27, 0x06,
|
||||
0x06, 0x01, 0x06, 0x59, 0x8B, 0x04, 0x34, 0x7C, 0x27, 0x06, 0x06, 0x01,
|
||||
0x02, 0x58, 0x87, 0x04, 0x2A, 0x7D, 0x27, 0x06, 0x06, 0x01, 0x03, 0x58,
|
||||
0x88, 0x04, 0x20, 0x7E, 0x27, 0x06, 0x06, 0x01, 0x04, 0x58, 0x89, 0x04,
|
||||
0x16, 0x7F, 0x27, 0x06, 0x06, 0x01, 0x05, 0x58, 0x8A, 0x04, 0x0C, 0x80,
|
||||
0x27, 0x06, 0x06, 0x01, 0x06, 0x58, 0x8B, 0x04, 0x02, 0x56, 0x29, 0x5D,
|
||||
0x34, 0x5F, 0x36, 0x1C, 0x26, 0x05, 0x02, 0x56, 0x29, 0x5C, 0x36, 0x04,
|
||||
0x02, 0x56, 0x29, 0xBF, 0xA1, 0x26, 0x01, T0_INT2(BR_X509_BUFSIZE_SIG),
|
||||
0x12, 0x06, 0x02, 0x4F, 0x29, 0x26, 0x5E, 0x34, 0x5B, 0xA2, 0x76, 0x76,
|
||||
0x01, 0x00, 0x5A, 0x35, 0x18, 0x00, 0x00, 0x01, 0x30, 0x0A, 0x26, 0x01,
|
||||
0x00, 0x01, 0x09, 0x6F, 0x05, 0x02, 0x47, 0x29, 0x00, 0x00, 0x30, 0x30,
|
||||
0x00, 0x00, 0x01, 0x81, 0x08, 0x00, 0x00, 0x01, 0x81, 0x10, 0x00, 0x00,
|
||||
0x01, 0x81, 0x19, 0x00, 0x00, 0x01, 0x81, 0x22, 0x00, 0x00, 0x01, 0x81,
|
||||
0x2B, 0x00, 0x01, 0x7B, 0x01, 0x01, 0x11, 0x3A, 0x01, 0x83, 0xFD, 0x7F,
|
||||
0x11, 0x15, 0x06, 0x03, 0x3A, 0x25, 0x00, 0x3A, 0x26, 0x03, 0x00, 0x26,
|
||||
0xC6, 0x05, 0x04, 0x41, 0x01, 0x00, 0x00, 0x26, 0x01, 0x81, 0x00, 0x0D,
|
||||
0x06, 0x04, 0x93, 0x04, 0x80, 0x49, 0x26, 0x01, 0x90, 0x00, 0x0D, 0x06,
|
||||
0x0F, 0x01, 0x06, 0x14, 0x01, 0x81, 0x40, 0x2F, 0x93, 0x02, 0x00, 0x01,
|
||||
0x00, 0x94, 0x04, 0x33, 0x26, 0x01, 0x83, 0xFF, 0x7F, 0x0D, 0x06, 0x14,
|
||||
0x01, 0x0C, 0x14, 0x01, 0x81, 0x60, 0x2F, 0x93, 0x02, 0x00, 0x01, 0x06,
|
||||
0x94, 0x02, 0x00, 0x01, 0x00, 0x94, 0x04, 0x17, 0x01, 0x12, 0x14, 0x01,
|
||||
0x81, 0x70, 0x2F, 0x93, 0x02, 0x00, 0x01, 0x0C, 0x94, 0x02, 0x00, 0x01,
|
||||
0x06, 0x94, 0x02, 0x00, 0x01, 0x00, 0x94, 0x00, 0x00, 0x01, 0x82, 0x15,
|
||||
0x00, 0x00, 0x26, 0x01, 0x83, 0xB0, 0x00, 0x01, 0x83, 0xB7, 0x7F, 0x6F,
|
||||
0x00, 0x00, 0x01, 0x81, 0x34, 0x00, 0x00, 0x01, 0x80, 0x6B, 0x00, 0x00,
|
||||
0x01, 0x81, 0x78, 0x00, 0x00, 0x01, 0x3D, 0x00, 0x00, 0x01, 0x80, 0x43,
|
||||
0x00, 0x00, 0x01, 0x80, 0x4D, 0x00, 0x00, 0x01, 0x80, 0x57, 0x00, 0x00,
|
||||
0x01, 0x80, 0x61, 0x00, 0x00, 0x30, 0x11, 0x06, 0x04, 0x41, 0xAA, 0xBF,
|
||||
0xB1, 0x00, 0x00, 0x01, 0x82, 0x09, 0x00, 0x00, 0x01, 0x81, 0x6C, 0x00,
|
||||
0x00, 0x26, 0x01, 0x83, 0xB8, 0x00, 0x01, 0x83, 0xBF, 0x7F, 0x6F, 0x00,
|
||||
0x00, 0x01, 0x30, 0x61, 0x36, 0x01, 0x7F, 0x79, 0x1A, 0x01, 0x00, 0x79,
|
||||
0x1A, 0x04, 0x7A, 0x00, 0x01, 0x81, 0x38, 0x00, 0x01, 0x7B, 0x0D, 0x06,
|
||||
0x02, 0x4E, 0x29, 0x26, 0x03, 0x00, 0x0A, 0x02, 0x00, 0x00, 0x00, 0x30,
|
||||
0x26, 0x3E, 0x3A, 0x01, 0x82, 0x00, 0x13, 0x2F, 0x06, 0x04, 0x41, 0x01,
|
||||
0x00, 0x00, 0x30, 0x66, 0x09, 0x36, 0x3F, 0x00, 0x00, 0x14, 0x01, 0x3F,
|
||||
0x15, 0x01, 0x81, 0x00, 0x2F, 0x93, 0x00, 0x02, 0x01, 0x00, 0x03, 0x00,
|
||||
0xAC, 0x26, 0x06, 0x80, 0x59, 0xB0, 0x01, 0x20, 0x30, 0x11, 0x06, 0x17,
|
||||
0x25, 0x71, 0xAA, 0x9B, 0x25, 0x01, 0x7F, 0x2E, 0x03, 0x01, 0xB0, 0x01,
|
||||
0x20, 0x74, 0xAA, 0xAF, 0x02, 0x01, 0x20, 0x76, 0x76, 0x04, 0x38, 0x01,
|
||||
0x21, 0x30, 0x11, 0x06, 0x08, 0x25, 0x72, 0xB3, 0x01, 0x01, 0x1F, 0x04,
|
||||
0x2A, 0x01, 0x22, 0x30, 0x11, 0x06, 0x11, 0x25, 0x72, 0xB3, 0x26, 0x06,
|
||||
0x06, 0x2C, 0x02, 0x00, 0x2F, 0x03, 0x00, 0x01, 0x02, 0x1F, 0x04, 0x13,
|
||||
0x01, 0x26, 0x30, 0x11, 0x06, 0x08, 0x25, 0x72, 0xB3, 0x01, 0x06, 0x1F,
|
||||
0x04, 0x05, 0x41, 0xAB, 0x01, 0x00, 0x25, 0x04, 0xFF, 0x23, 0x76, 0x02,
|
||||
0x00, 0x00, 0x00, 0xAC, 0xB1, 0x26, 0x01, 0x01, 0x11, 0x06, 0x08, 0xA3,
|
||||
0x05, 0x02, 0x50, 0x29, 0xB1, 0x04, 0x02, 0x50, 0x29, 0x26, 0x01, 0x02,
|
||||
0x11, 0x06, 0x0C, 0x25, 0x72, 0xAD, 0x65, 0x2B, 0x40, 0x0D, 0x06, 0x02,
|
||||
0x50, 0x29, 0xB1, 0x01, 0x7F, 0x10, 0x06, 0x02, 0x55, 0x29, 0x25, 0x76,
|
||||
0x00, 0x00, 0xAC, 0x26, 0x06, 0x1A, 0xAC, 0x9B, 0x25, 0x26, 0x06, 0x11,
|
||||
0xAC, 0x26, 0x06, 0x0C, 0xAC, 0x9B, 0x25, 0x86, 0x27, 0x05, 0x02, 0x48,
|
||||
0x29, 0xBF, 0x04, 0x71, 0x76, 0x76, 0x04, 0x63, 0x76, 0x00, 0x02, 0x03,
|
||||
0x00, 0xB0, 0x01, 0x03, 0x75, 0xAA, 0xB7, 0x03, 0x01, 0x02, 0x01, 0x01,
|
||||
0x07, 0x12, 0x06, 0x02, 0x55, 0x29, 0x26, 0x01, 0x00, 0x30, 0x11, 0x06,
|
||||
0x05, 0x25, 0x4C, 0x29, 0x04, 0x15, 0x01, 0x01, 0x30, 0x11, 0x06, 0x0A,
|
||||
0x25, 0xB7, 0x02, 0x01, 0x14, 0x02, 0x01, 0x0E, 0x04, 0x05, 0x25, 0xB7,
|
||||
0x01, 0x00, 0x25, 0x02, 0x00, 0x06, 0x19, 0x01, 0x00, 0x30, 0x01, 0x38,
|
||||
0x15, 0x06, 0x03, 0x01, 0x10, 0x2F, 0x3A, 0x01, 0x81, 0x40, 0x15, 0x06,
|
||||
0x03, 0x01, 0x20, 0x2F, 0x61, 0x36, 0x04, 0x07, 0x01, 0x04, 0x15, 0x05,
|
||||
0x02, 0x4C, 0x29, 0xBF, 0x00, 0x00, 0x37, 0xAC, 0xBF, 0x1B, 0x00, 0x03,
|
||||
0x01, 0x00, 0x03, 0x00, 0x37, 0xAC, 0x26, 0x06, 0x30, 0xB0, 0x01, 0x11,
|
||||
0x74, 0xAA, 0x26, 0x05, 0x02, 0x43, 0x29, 0x26, 0x06, 0x20, 0xAC, 0x9B,
|
||||
0x25, 0x84, 0x27, 0x03, 0x01, 0x01, 0x00, 0x2E, 0x03, 0x02, 0xAF, 0x26,
|
||||
0x02, 0x01, 0x15, 0x06, 0x07, 0x2C, 0x06, 0x04, 0x01, 0x7F, 0x03, 0x00,
|
||||
0x02, 0x02, 0x20, 0x76, 0x04, 0x5D, 0x76, 0x04, 0x4D, 0x76, 0x1B, 0x02,
|
||||
0x00, 0x00, 0x00, 0xB0, 0x01, 0x06, 0x75, 0xAE, 0x00, 0x00, 0xB5, 0x83,
|
||||
0x06, 0x0E, 0x3A, 0x26, 0x05, 0x06, 0x41, 0x01, 0x00, 0x01, 0x00, 0x00,
|
||||
0xB5, 0x6B, 0x04, 0x08, 0x8F, 0x06, 0x05, 0x25, 0x01, 0x00, 0x04, 0x00,
|
||||
0x00, 0x00, 0xB6, 0x83, 0x06, 0x0E, 0x3A, 0x26, 0x05, 0x06, 0x41, 0x01,
|
||||
0x00, 0x01, 0x00, 0x00, 0xB6, 0x6B, 0x04, 0x08, 0x8F, 0x06, 0x05, 0x25,
|
||||
0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0xB7, 0x26, 0x01, 0x81, 0x00, 0x0D,
|
||||
0x06, 0x04, 0x00, 0x04, 0x80, 0x55, 0x26, 0x01, 0x81, 0x40, 0x0D, 0x06,
|
||||
0x07, 0x25, 0x01, 0x00, 0x00, 0x04, 0x80, 0x47, 0x26, 0x01, 0x81, 0x60,
|
||||
0x0D, 0x06, 0x0E, 0x01, 0x1F, 0x15, 0x01, 0x01, 0xA0, 0x01, 0x81, 0x00,
|
||||
0x01, 0x8F, 0x7F, 0x04, 0x32, 0x26, 0x01, 0x81, 0x70, 0x0D, 0x06, 0x0F,
|
||||
0x01, 0x0F, 0x15, 0x01, 0x02, 0xA0, 0x01, 0x90, 0x00, 0x01, 0x83, 0xFF,
|
||||
0x7F, 0x04, 0x1C, 0x26, 0x01, 0x81, 0x78, 0x0D, 0x06, 0x11, 0x01, 0x07,
|
||||
0x15, 0x01, 0x03, 0xA0, 0x01, 0x84, 0x80, 0x00, 0x01, 0x80, 0xC3, 0xFF,
|
||||
0x7F, 0x04, 0x04, 0x25, 0x01, 0x00, 0x00, 0x6F, 0x05, 0x03, 0x25, 0x01,
|
||||
0x00, 0x00, 0x00, 0x3A, 0x26, 0x05, 0x06, 0x41, 0x01, 0x00, 0x01, 0x7F,
|
||||
0x00, 0xB7, 0x33, 0x26, 0x3C, 0x06, 0x03, 0x3A, 0x25, 0x00, 0x01, 0x06,
|
||||
0x0E, 0x3A, 0x26, 0x01, 0x06, 0x14, 0x01, 0x02, 0x10, 0x06, 0x04, 0x41,
|
||||
0x01, 0x7F, 0x00, 0x01, 0x3F, 0x15, 0x09, 0x00, 0x00, 0x26, 0x06, 0x06,
|
||||
0x0B, 0x9F, 0x33, 0x40, 0x04, 0x77, 0x25, 0x26, 0x00, 0x00, 0xB0, 0x01,
|
||||
0x03, 0x75, 0xAA, 0xB7, 0x06, 0x02, 0x54, 0x29, 0x00, 0x00, 0x3A, 0x26,
|
||||
0x06, 0x07, 0x31, 0x26, 0x06, 0x01, 0x1A, 0x04, 0x76, 0x41, 0x00, 0x00,
|
||||
0x01, 0x01, 0x75, 0xA9, 0x01, 0x01, 0x10, 0x06, 0x02, 0x42, 0x29, 0xB7,
|
||||
0x3D, 0x00, 0x04, 0xB0, 0x26, 0x01, 0x17, 0x01, 0x18, 0x6F, 0x05, 0x02,
|
||||
0x47, 0x29, 0x01, 0x18, 0x11, 0x03, 0x00, 0x72, 0xAA, 0xA5, 0x02, 0x00,
|
||||
0x06, 0x0C, 0x01, 0x80, 0x64, 0x08, 0x03, 0x01, 0xA5, 0x02, 0x01, 0x09,
|
||||
0x04, 0x0E, 0x26, 0x01, 0x32, 0x0D, 0x06, 0x04, 0x01, 0x80, 0x64, 0x09,
|
||||
0x01, 0x8E, 0x6C, 0x09, 0x03, 0x01, 0x02, 0x01, 0x01, 0x82, 0x6D, 0x08,
|
||||
0x02, 0x01, 0x01, 0x03, 0x09, 0x01, 0x04, 0x0C, 0x09, 0x02, 0x01, 0x01,
|
||||
0x80, 0x63, 0x09, 0x01, 0x80, 0x64, 0x0C, 0x0A, 0x02, 0x01, 0x01, 0x83,
|
||||
0x0F, 0x09, 0x01, 0x83, 0x10, 0x0C, 0x09, 0x03, 0x03, 0x01, 0x01, 0x01,
|
||||
0x0C, 0xA6, 0x40, 0x01, 0x01, 0x0E, 0x02, 0x01, 0x01, 0x04, 0x07, 0x3E,
|
||||
0x02, 0x01, 0x01, 0x80, 0x64, 0x07, 0x3D, 0x02, 0x01, 0x01, 0x83, 0x10,
|
||||
0x07, 0x3E, 0x2F, 0x15, 0x06, 0x03, 0x01, 0x18, 0x09, 0x91, 0x09, 0x78,
|
||||
0x26, 0x01, 0x05, 0x14, 0x02, 0x03, 0x09, 0x03, 0x03, 0x01, 0x1F, 0x15,
|
||||
0x01, 0x01, 0x3A, 0xA6, 0x02, 0x03, 0x09, 0x40, 0x03, 0x03, 0x01, 0x00,
|
||||
0x01, 0x17, 0xA6, 0x01, 0x9C, 0x10, 0x08, 0x03, 0x02, 0x01, 0x00, 0x01,
|
||||
0x3B, 0xA6, 0x01, 0x3C, 0x08, 0x02, 0x02, 0x09, 0x03, 0x02, 0x01, 0x00,
|
||||
0x01, 0x3C, 0xA6, 0x02, 0x02, 0x09, 0x03, 0x02, 0xB7, 0x26, 0x01, 0x2E,
|
||||
0x11, 0x06, 0x0D, 0x25, 0xB7, 0x26, 0x01, 0x30, 0x01, 0x39, 0x6F, 0x06,
|
||||
0x03, 0x25, 0x04, 0x74, 0x01, 0x80, 0x5A, 0x10, 0x06, 0x02, 0x47, 0x29,
|
||||
0x76, 0x02, 0x03, 0x02, 0x02, 0x00, 0x01, 0xB7, 0x7A, 0x01, 0x0A, 0x08,
|
||||
0x03, 0x00, 0xB7, 0x7A, 0x02, 0x00, 0x09, 0x00, 0x02, 0x03, 0x00, 0x03,
|
||||
0x01, 0xA5, 0x26, 0x02, 0x01, 0x02, 0x00, 0x6F, 0x05, 0x02, 0x47, 0x29,
|
||||
0x00, 0x00, 0x33, 0xB0, 0x01, 0x02, 0x75, 0x0B, 0xA8, 0x00, 0x03, 0x26,
|
||||
0x03, 0x00, 0x03, 0x01, 0x03, 0x02, 0xAA, 0xB7, 0x26, 0x01, 0x81, 0x00,
|
||||
0x13, 0x06, 0x02, 0x53, 0x29, 0x26, 0x01, 0x00, 0x11, 0x06, 0x0B, 0x25,
|
||||
0x26, 0x05, 0x04, 0x25, 0x01, 0x00, 0x00, 0xB7, 0x04, 0x6F, 0x02, 0x01,
|
||||
0x26, 0x05, 0x02, 0x4F, 0x29, 0x40, 0x03, 0x01, 0x02, 0x02, 0x36, 0x02,
|
||||
0x02, 0x3F, 0x03, 0x02, 0x26, 0x06, 0x03, 0xB7, 0x04, 0x68, 0x25, 0x02,
|
||||
0x00, 0x02, 0x01, 0x0A, 0x00, 0x01, 0xB7, 0x26, 0x01, 0x81, 0x00, 0x0D,
|
||||
0x06, 0x01, 0x00, 0x01, 0x81, 0x00, 0x0A, 0x26, 0x05, 0x02, 0x4D, 0x29,
|
||||
0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x12, 0x06, 0x19, 0x02,
|
||||
0x00, 0x40, 0x03, 0x00, 0x26, 0x01, 0x83, 0xFF, 0xFF, 0x7F, 0x12, 0x06,
|
||||
0x02, 0x4E, 0x29, 0x01, 0x08, 0x0E, 0x3A, 0xB7, 0x33, 0x09, 0x04, 0x60,
|
||||
0x00, 0x00, 0xA9, 0x92, 0x00, 0x00, 0xAA, 0xBF, 0x00, 0x00, 0xB0, 0x73,
|
||||
0xAA, 0x00, 0x01, 0xAA, 0x26, 0x05, 0x02, 0x53, 0x29, 0xB7, 0x26, 0x01,
|
||||
0x81, 0x00, 0x13, 0x06, 0x02, 0x53, 0x29, 0x03, 0x00, 0x26, 0x06, 0x16,
|
||||
0xB7, 0x02, 0x00, 0x26, 0x01, 0x87, 0xFF, 0xFF, 0x7F, 0x13, 0x06, 0x02,
|
||||
0x53, 0x29, 0x01, 0x08, 0x0E, 0x09, 0x03, 0x00, 0x04, 0x67, 0x25, 0x02,
|
||||
0x00, 0x00, 0x00, 0xAA, 0x26, 0x01, 0x81, 0x7F, 0x12, 0x06, 0x08, 0xBF,
|
||||
0x01, 0x00, 0x66, 0x36, 0x01, 0x00, 0x00, 0x26, 0x66, 0x36, 0x66, 0x3F,
|
||||
0xA2, 0x01, 0x7F, 0x00, 0x00, 0xB0, 0x01, 0x0C, 0x30, 0x11, 0x06, 0x05,
|
||||
0x25, 0x72, 0xB3, 0x04, 0x3E, 0x01, 0x12, 0x30, 0x11, 0x06, 0x05, 0x25,
|
||||
0x72, 0xB4, 0x04, 0x33, 0x01, 0x13, 0x30, 0x11, 0x06, 0x05, 0x25, 0x72,
|
||||
0xB4, 0x04, 0x28, 0x01, 0x14, 0x30, 0x11, 0x06, 0x05, 0x25, 0x72, 0xB4,
|
||||
0x04, 0x1D, 0x01, 0x16, 0x30, 0x11, 0x06, 0x05, 0x25, 0x72, 0xB4, 0x04,
|
||||
0x12, 0x01, 0x1E, 0x30, 0x11, 0x06, 0x05, 0x25, 0x72, 0xB2, 0x04, 0x07,
|
||||
0x41, 0xAB, 0x01, 0x00, 0x01, 0x00, 0x25, 0x00, 0x01, 0xB7, 0x03, 0x00,
|
||||
0x02, 0x00, 0x01, 0x05, 0x14, 0x01, 0x01, 0x15, 0x2D, 0x02, 0x00, 0x01,
|
||||
0x06, 0x14, 0x26, 0x01, 0x01, 0x15, 0x06, 0x02, 0x45, 0x29, 0x01, 0x04,
|
||||
0x0E, 0x02, 0x00, 0x01, 0x1F, 0x15, 0x26, 0x01, 0x1F, 0x11, 0x06, 0x02,
|
||||
0x46, 0x29, 0x09, 0x00, 0x00, 0x26, 0x05, 0x05, 0x01, 0x00, 0x01, 0x7F,
|
||||
0x00, 0xB0, 0x00, 0x01, 0xAA, 0x26, 0x05, 0x05, 0x66, 0x36, 0x01, 0x7F,
|
||||
0x00, 0x01, 0x01, 0x03, 0x00, 0x9C, 0x26, 0x01, 0x83, 0xFF, 0x7E, 0x11,
|
||||
0x06, 0x16, 0x25, 0x26, 0x06, 0x10, 0x9D, 0x26, 0x05, 0x05, 0x25, 0xBF,
|
||||
0x01, 0x00, 0x00, 0x02, 0x00, 0x81, 0x03, 0x00, 0x04, 0x6D, 0x04, 0x1B,
|
||||
0x26, 0x05, 0x05, 0x25, 0xBF, 0x01, 0x00, 0x00, 0x02, 0x00, 0x81, 0x03,
|
||||
0x00, 0x26, 0x06, 0x0B, 0x9C, 0x26, 0x05, 0x05, 0x25, 0xBF, 0x01, 0x00,
|
||||
0x00, 0x04, 0x6D, 0x25, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x40, 0x66,
|
||||
0x36, 0x01, 0x7F, 0x00, 0x01, 0xAA, 0x01, 0x01, 0x03, 0x00, 0x26, 0x06,
|
||||
0x10, 0x9E, 0x26, 0x05, 0x05, 0x25, 0xBF, 0x01, 0x00, 0x00, 0x02, 0x00,
|
||||
0x81, 0x03, 0x00, 0x04, 0x6D, 0x25, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00,
|
||||
0x40, 0x66, 0x36, 0x01, 0x7F, 0x00, 0x01, 0xAA, 0x01, 0x01, 0x03, 0x00,
|
||||
0x26, 0x06, 0x10, 0xB7, 0x26, 0x05, 0x05, 0x25, 0xBF, 0x01, 0x00, 0x00,
|
||||
0x02, 0x00, 0x81, 0x03, 0x00, 0x04, 0x6D, 0x25, 0x02, 0x00, 0x26, 0x05,
|
||||
0x01, 0x00, 0x40, 0x66, 0x36, 0x01, 0x7F, 0x00, 0x00, 0xB7, 0x01, 0x08,
|
||||
0x0E, 0x3A, 0xB7, 0x33, 0x09, 0x00, 0x00, 0xB7, 0x3A, 0xB7, 0x01, 0x08,
|
||||
0x0E, 0x33, 0x09, 0x00, 0x00, 0x26, 0x05, 0x02, 0x4E, 0x29, 0x40, 0xB8,
|
||||
0x00, 0x00, 0x32, 0x26, 0x01, 0x00, 0x13, 0x06, 0x01, 0x00, 0x25, 0x1A,
|
||||
0x04, 0x74, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x0B, 0x00, 0x00, 0x01,
|
||||
0x15, 0x00, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x01, 0x29, 0x00, 0x00, 0x01,
|
||||
0x33, 0x00, 0x00, 0xC0, 0x25, 0x00, 0x00, 0x26, 0x06, 0x07, 0xC1, 0x26,
|
||||
0x06, 0x01, 0x1A, 0x04, 0x76, 0x00, 0x00, 0x01, 0x00, 0x30, 0x31, 0x0B,
|
||||
0x41, 0x00, 0x00, 0x01, 0x81, 0x70, 0x00, 0x00, 0x01, 0x82, 0x0D, 0x00,
|
||||
0x00, 0x01, 0x82, 0x22, 0x00, 0x00, 0x01, 0x82, 0x05, 0x00, 0x00, 0x26,
|
||||
0x01, 0x83, 0xFB, 0x50, 0x01, 0x83, 0xFB, 0x6F, 0x6F, 0x06, 0x04, 0x25,
|
||||
0x01, 0x00, 0x00, 0x26, 0x01, 0x83, 0xB0, 0x00, 0x01, 0x83, 0xBF, 0x7F,
|
||||
0x6F, 0x06, 0x04, 0x25, 0x01, 0x00, 0x00, 0x01, 0x83, 0xFF, 0x7F, 0x15,
|
||||
0x01, 0x83, 0xFF, 0x7E, 0x0D, 0x00
|
||||
};
|
||||
|
||||
static const uint16_t t0_caddr[] PROGMEM = {
|
||||
@ -833,106 +830,103 @@ static const uint16_t t0_caddr[] PROGMEM = {
|
||||
188,
|
||||
193,
|
||||
198,
|
||||
202,
|
||||
207,
|
||||
212,
|
||||
217,
|
||||
238,
|
||||
243,
|
||||
248,
|
||||
253,
|
||||
282,
|
||||
297,
|
||||
203,
|
||||
208,
|
||||
213,
|
||||
234,
|
||||
239,
|
||||
244,
|
||||
249,
|
||||
264,
|
||||
269,
|
||||
275,
|
||||
281,
|
||||
286,
|
||||
294,
|
||||
302,
|
||||
308,
|
||||
314,
|
||||
319,
|
||||
327,
|
||||
335,
|
||||
341,
|
||||
346,
|
||||
357,
|
||||
986,
|
||||
1001,
|
||||
1005,
|
||||
1010,
|
||||
1015,
|
||||
1020,
|
||||
1025,
|
||||
1030,
|
||||
1144,
|
||||
1149,
|
||||
1161,
|
||||
1166,
|
||||
1171,
|
||||
1176,
|
||||
1180,
|
||||
1185,
|
||||
1190,
|
||||
1195,
|
||||
1200,
|
||||
1210,
|
||||
1215,
|
||||
1220,
|
||||
1232,
|
||||
1247,
|
||||
1252,
|
||||
1266,
|
||||
1288,
|
||||
1299,
|
||||
1402,
|
||||
1449,
|
||||
1482,
|
||||
1573,
|
||||
1579,
|
||||
1642,
|
||||
1649,
|
||||
1677,
|
||||
1705,
|
||||
1810,
|
||||
1852,
|
||||
313,
|
||||
324,
|
||||
960,
|
||||
975,
|
||||
979,
|
||||
984,
|
||||
989,
|
||||
994,
|
||||
999,
|
||||
1004,
|
||||
1118,
|
||||
1123,
|
||||
1135,
|
||||
1140,
|
||||
1145,
|
||||
1150,
|
||||
1154,
|
||||
1159,
|
||||
1164,
|
||||
1169,
|
||||
1174,
|
||||
1184,
|
||||
1189,
|
||||
1194,
|
||||
1206,
|
||||
1221,
|
||||
1226,
|
||||
1240,
|
||||
1262,
|
||||
1273,
|
||||
1376,
|
||||
1423,
|
||||
1456,
|
||||
1547,
|
||||
1553,
|
||||
1616,
|
||||
1623,
|
||||
1651,
|
||||
1679,
|
||||
1784,
|
||||
1826,
|
||||
1839,
|
||||
1851,
|
||||
1865,
|
||||
1877,
|
||||
1891,
|
||||
1906,
|
||||
2126,
|
||||
1880,
|
||||
2100,
|
||||
2114,
|
||||
2131,
|
||||
2140,
|
||||
2157,
|
||||
2166,
|
||||
2233,
|
||||
2289,
|
||||
2293,
|
||||
2297,
|
||||
2302,
|
||||
2207,
|
||||
2263,
|
||||
2267,
|
||||
2271,
|
||||
2276,
|
||||
2324,
|
||||
2350,
|
||||
2376,
|
||||
2452,
|
||||
2496,
|
||||
2507,
|
||||
2592,
|
||||
2630,
|
||||
2668,
|
||||
2678,
|
||||
2426,
|
||||
2470,
|
||||
2481,
|
||||
2566,
|
||||
2604,
|
||||
2642,
|
||||
2652,
|
||||
2662,
|
||||
2671,
|
||||
2684,
|
||||
2688,
|
||||
2697,
|
||||
2710,
|
||||
2714,
|
||||
2718,
|
||||
2722,
|
||||
2726,
|
||||
2730,
|
||||
2734,
|
||||
2738,
|
||||
2750,
|
||||
2758,
|
||||
2763,
|
||||
2768,
|
||||
2773,
|
||||
2778,
|
||||
2786
|
||||
2692,
|
||||
2696,
|
||||
2700,
|
||||
2704,
|
||||
2708,
|
||||
2712,
|
||||
2724,
|
||||
2732,
|
||||
2737,
|
||||
2742,
|
||||
2747,
|
||||
2752
|
||||
};
|
||||
|
||||
#define T0_INTERPRETED 61
|
||||
#define T0_INTERPRETED 60
|
||||
|
||||
#define T0_ENTER(ip, rp, slot) do { \
|
||||
const unsigned char *t0_newip; \
|
||||
@ -953,7 +947,7 @@ name(void *ctx) \
|
||||
T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
|
||||
}
|
||||
|
||||
T0_DEFENTRY(br_x509_minimal_init_main, 147)
|
||||
T0_DEFENTRY(br_x509_minimal_init_main, 144)
|
||||
|
||||
#define T0_NEXT(t0ipp) (pgm_read_byte((*t0ipp)++))
|
||||
|
||||
@ -1268,11 +1262,53 @@ br_x509_minimal_run(void *t0ctx)
|
||||
}
|
||||
break;
|
||||
case 25: {
|
||||
/* check-validity-range */
|
||||
|
||||
uint32_t nbs = T0_POP();
|
||||
uint32_t nbd = T0_POP();
|
||||
uint32_t nas = T0_POP();
|
||||
uint32_t nad = T0_POP();
|
||||
int r;
|
||||
uint32_t vd = CTX->days;
|
||||
uint32_t vs = CTX->seconds;
|
||||
if (vd == 0 && vs == 0) {
|
||||
#if BR_USE_UNIX_TIME
|
||||
time_t x = time(NULL);
|
||||
|
||||
vd = (uint32_t)(x / 86400) + 719528;
|
||||
vs = (uint32_t)(x % 86400);
|
||||
#elif BR_USE_WIN32_TIME
|
||||
FILETIME ft;
|
||||
uint64_t x;
|
||||
|
||||
GetSystemTimeAsFileTime(&ft);
|
||||
x = ((uint64_t)ft.dwHighDateTime << 32)
|
||||
+ (uint64_t)ft.dwLowDateTime;
|
||||
x = (x / 10000000);
|
||||
vd = (uint32_t)(x / 86400) + 584754;
|
||||
vs = (uint32_t)(x % 86400);
|
||||
#else
|
||||
CTX->err = BR_ERR_X509_TIME_UNKNOWN;
|
||||
T0_CO();
|
||||
#endif
|
||||
}
|
||||
if (vd < nbd || (vd == nbd && vs < nbs)) {
|
||||
r = -1;
|
||||
} else if (vd > nad || (vd == nad && vs > nas)) {
|
||||
r = 1;
|
||||
} else {
|
||||
r = 0;
|
||||
}
|
||||
T0_PUSHi(r);
|
||||
|
||||
}
|
||||
break;
|
||||
case 26: {
|
||||
/* co */
|
||||
T0_CO();
|
||||
}
|
||||
break;
|
||||
case 26: {
|
||||
case 27: {
|
||||
/* compute-dn-hash */
|
||||
|
||||
CTX->dn_hash_impl->out(&CTX->dn_hash.vtable, CTX->current_dn_hash);
|
||||
@ -1280,7 +1316,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 27: {
|
||||
case 28: {
|
||||
/* compute-tbs-hash */
|
||||
|
||||
int id = T0_POPi();
|
||||
@ -1290,7 +1326,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 28: {
|
||||
case 29: {
|
||||
/* copy-ee-ec-pkey */
|
||||
|
||||
size_t qlen = T0_POP();
|
||||
@ -1303,7 +1339,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 29: {
|
||||
case 30: {
|
||||
/* copy-ee-rsa-pkey */
|
||||
|
||||
size_t elen = T0_POP();
|
||||
@ -1317,7 +1353,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 30: {
|
||||
case 31: {
|
||||
/* copy-name-SAN */
|
||||
|
||||
unsigned tag = T0_POP();
|
||||
@ -1343,7 +1379,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 31: {
|
||||
case 32: {
|
||||
/* copy-name-element */
|
||||
|
||||
size_t len;
|
||||
@ -1369,7 +1405,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 32: {
|
||||
case 33: {
|
||||
/* data-get8 */
|
||||
|
||||
size_t addr = T0_POP();
|
||||
@ -1377,14 +1413,14 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 33: {
|
||||
case 34: {
|
||||
/* dn-hash-length */
|
||||
|
||||
T0_PUSH(DNHASH_LEN);
|
||||
|
||||
}
|
||||
break;
|
||||
case 34: {
|
||||
case 35: {
|
||||
/* do-ecdsa-vrfy */
|
||||
|
||||
size_t qlen = T0_POP();
|
||||
@ -1399,7 +1435,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 35: {
|
||||
case 36: {
|
||||
/* do-rsa-vrfy */
|
||||
|
||||
size_t elen = T0_POP();
|
||||
@ -1415,17 +1451,17 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 36: {
|
||||
case 37: {
|
||||
/* drop */
|
||||
(void)T0_POP();
|
||||
}
|
||||
break;
|
||||
case 37: {
|
||||
case 38: {
|
||||
/* dup */
|
||||
T0_PUSH(T0_PEEK(0));
|
||||
}
|
||||
break;
|
||||
case 38: {
|
||||
case 39: {
|
||||
/* eqOID */
|
||||
|
||||
const unsigned char *a2 = &t0_datablock[T0_POP()];
|
||||
@ -1441,7 +1477,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 39: {
|
||||
case 40: {
|
||||
/* eqblob */
|
||||
|
||||
size_t len = T0_POP();
|
||||
@ -1451,42 +1487,12 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 40: {
|
||||
case 41: {
|
||||
/* fail */
|
||||
|
||||
CTX->err = T0_POPi();
|
||||
T0_CO();
|
||||
|
||||
}
|
||||
break;
|
||||
case 41: {
|
||||
/* get-system-date */
|
||||
|
||||
if (CTX->days == 0 && CTX->seconds == 0) {
|
||||
#if BR_USE_UNIX_TIME
|
||||
time_t x = time(NULL);
|
||||
|
||||
T0_PUSH((uint32_t)(x / 86400) + 719528);
|
||||
T0_PUSH((uint32_t)(x % 86400));
|
||||
#elif BR_USE_WIN32_TIME
|
||||
FILETIME ft;
|
||||
uint64_t x;
|
||||
|
||||
GetSystemTimeAsFileTime(&ft);
|
||||
x = ((uint64_t)ft.dwHighDateTime << 32)
|
||||
+ (uint64_t)ft.dwLowDateTime;
|
||||
x = (x / 10000000);
|
||||
T0_PUSH((uint32_t)(x / 86400) + 584754);
|
||||
T0_PUSH((uint32_t)(x % 86400));
|
||||
#else
|
||||
CTX->err = BR_ERR_X509_TIME_UNKNOWN;
|
||||
T0_CO();
|
||||
#endif
|
||||
} else {
|
||||
T0_PUSH(CTX->days);
|
||||
T0_PUSH(CTX->seconds);
|
||||
}
|
||||
|
||||
}
|
||||
break;
|
||||
case 42: {
|
||||
@ -1642,16 +1648,11 @@ br_x509_minimal_run(void *t0ctx)
|
||||
}
|
||||
break;
|
||||
case 51: {
|
||||
/* roll */
|
||||
T0_ROLL(T0_POP());
|
||||
}
|
||||
break;
|
||||
case 52: {
|
||||
/* rot */
|
||||
T0_ROT();
|
||||
}
|
||||
break;
|
||||
case 53: {
|
||||
case 52: {
|
||||
/* set16 */
|
||||
|
||||
uint32_t addr = T0_POP();
|
||||
@ -1659,7 +1660,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 54: {
|
||||
case 53: {
|
||||
/* set32 */
|
||||
|
||||
uint32_t addr = T0_POP();
|
||||
@ -1667,7 +1668,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 55: {
|
||||
case 54: {
|
||||
/* set8 */
|
||||
|
||||
uint32_t addr = T0_POP();
|
||||
@ -1675,7 +1676,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 56: {
|
||||
case 55: {
|
||||
/* start-dn-hash */
|
||||
|
||||
CTX->dn_hash_impl->init(&CTX->dn_hash.vtable);
|
||||
@ -1683,7 +1684,7 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 57: {
|
||||
case 56: {
|
||||
/* start-tbs-hash */
|
||||
|
||||
br_multihash_init(&CTX->mhash);
|
||||
@ -1691,19 +1692,19 @@ br_x509_minimal_run(void *t0ctx)
|
||||
|
||||
}
|
||||
break;
|
||||
case 58: {
|
||||
case 57: {
|
||||
/* stop-tbs-hash */
|
||||
|
||||
CTX->do_mhash = 0;
|
||||
|
||||
}
|
||||
break;
|
||||
case 59: {
|
||||
case 58: {
|
||||
/* swap */
|
||||
T0_SWAP();
|
||||
}
|
||||
break;
|
||||
case 60: {
|
||||
case 59: {
|
||||
/* zero-server-name */
|
||||
|
||||
T0_PUSHi(-(CTX->server_name == NULL));
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -611,7 +611,7 @@ const char kI2SAudio_Commands[] PROGMEM = "I2S|"
|
||||
#ifdef USE_I2S_WEBRADIO
|
||||
"|WR"
|
||||
#endif // USE_I2S_WEBRADIO
|
||||
#if ( (defined(USE_I2S_AUDIO) && defined(USE_I2S_MIC)) || defined(USE_M5STACK_CORE2) || defined(ESP32S3_BOX) )
|
||||
#if defined(USE_SHINE) && ( (defined(USE_I2S_AUDIO) && defined(USE_I2S_MIC)) || defined(USE_M5STACK_CORE2) || defined(ESP32S3_BOX) )
|
||||
"|REC"
|
||||
"|MGain"
|
||||
#if defined(USE_SHINE) && defined(MP3_MIC_STREAM)
|
||||
@ -634,7 +634,7 @@ void (* const I2SAudio_Command[])(void) PROGMEM = {
|
||||
#ifdef USE_I2S_WEBRADIO
|
||||
,&Cmd_WebRadio
|
||||
#endif // USE_I2S_WEBRADIO
|
||||
#if ( (defined(USE_I2S_AUDIO) && defined(USE_I2S_MIC)) || defined(USE_M5STACK_CORE2) || defined(ESP32S3_BOX) )
|
||||
#if defined(USE_SHINE) && ( (defined(USE_I2S_AUDIO) && defined(USE_I2S_MIC)) || defined(USE_M5STACK_CORE2) || defined(ESP32S3_BOX) )
|
||||
,&Cmd_MicRec
|
||||
,&Cmd_MicGain
|
||||
#if defined(USE_SHINE) && defined(MP3_MIC_STREAM)
|
||||
|
||||
@ -22,12 +22,16 @@
|
||||
* Modbus Bridge using Modbus library (TasmotaModbus)
|
||||
*
|
||||
* Can be used trough web/mqtt commands and also via direct TCP connection (when defined)
|
||||
*
|
||||
*
|
||||
* When USE_MODBUS_BRIDGE_TCP is also defined, this bridge can also be used as an ModbusTCP
|
||||
* bridge.
|
||||
*
|
||||
* Example Command:
|
||||
* -- Read Input Register --
|
||||
* ModbusSend {"deviceaddress": 1, "functioncode": 3, "startaddress": 1, "type":"uint16", "count":2}
|
||||
*
|
||||
* -- Write multiple coils --
|
||||
* ModbusSend {"deviceaddress": 1, "functioncode": 15, "startaddress": 1, "type":"uint16", "count":4, "values":[1,2,3,4]}
|
||||
\*********************************************************************************************/
|
||||
|
||||
#define XDRV_63 63
|
||||
@ -97,30 +101,36 @@ enum class ModbusBridgeError
|
||||
wrongfunctioncode = 3,
|
||||
wrongstartaddress = 4,
|
||||
wrongtype = 5,
|
||||
wrongregistercount = 6,
|
||||
wrongcount = 7
|
||||
wrongdataCount = 6,
|
||||
wrongcount = 7,
|
||||
tomanydata = 8
|
||||
};
|
||||
|
||||
enum class ModbusBridgeFunctionCode
|
||||
{
|
||||
mb_undefined = 0,
|
||||
mb_readCoilstartregister = 1,
|
||||
mb_readContactstartregister = 2,
|
||||
mb_readHoldingstartregister = 3,
|
||||
mb_readInputstartregister = 4,
|
||||
mb_readCoilStatus = 1,
|
||||
mb_readContactStatus = 2,
|
||||
mb_readHoldingRegisters = 3,
|
||||
mb_readInputRegisters = 4,
|
||||
mb_writeSingleCoil = 5,
|
||||
mb_writeSinglestartregister = 6
|
||||
mb_writeSingleRegister = 6,
|
||||
mb_writeMultipleCoils = 15,
|
||||
mb_writeMultipleRegisters = 16
|
||||
};
|
||||
|
||||
enum class ModbusBridgeType
|
||||
{
|
||||
mb_undefined,
|
||||
mb_uint8,
|
||||
mb_uint16,
|
||||
mb_uint32,
|
||||
mb_int8,
|
||||
mb_int16,
|
||||
mb_int32,
|
||||
mb_float,
|
||||
mb_raw,
|
||||
mb_hex,
|
||||
mb_bit
|
||||
};
|
||||
|
||||
@ -139,7 +149,7 @@ struct ModbusBridge
|
||||
ModbusBridgeFunctionCode functionCode = ModbusBridgeFunctionCode::mb_undefined;
|
||||
ModbusBridgeType type = ModbusBridgeType::mb_undefined;
|
||||
|
||||
uint16_t registerCount = 0;
|
||||
uint16_t dataCount = 0;
|
||||
uint16_t startAddress = 0;
|
||||
uint8_t deviceAddress = 0;
|
||||
uint8_t count = 0;
|
||||
@ -154,8 +164,10 @@ ModbusBridge modbusBridge;
|
||||
//
|
||||
bool ModbusBridgeBegin(void)
|
||||
{
|
||||
if ((Settings->modbus_sbaudrate < 300 / 300) || (Settings->modbus_sbaudrate > 115200 / 300)) Settings->modbus_sbaudrate = (uint8_t)((uint32_t)MBR_BAUDRATE / 300);
|
||||
if (Settings->modbus_sconfig > TS_SERIAL_8O2) Settings->modbus_sconfig = TS_SERIAL_8N1;
|
||||
if ((Settings->modbus_sbaudrate < 1) || (Settings->modbus_sbaudrate > (115200 / 300)))
|
||||
Settings->modbus_sbaudrate = (uint8_t)((uint32_t)MBR_BAUDRATE / 300);
|
||||
if (Settings->modbus_sconfig > TS_SERIAL_8O2)
|
||||
Settings->modbus_sconfig = TS_SERIAL_8N1;
|
||||
|
||||
int result = tasmotaModbus->Begin(Settings->modbus_sbaudrate * 300, ConvertSerialConfig(Settings->modbus_sconfig)); // Reinitialize modbus port with new baud rate
|
||||
if (result)
|
||||
@ -186,7 +198,7 @@ void SetModbusBridgeBaudrate(uint32_t baudrate)
|
||||
{
|
||||
if ((baudrate >= 300) && (baudrate <= 115200))
|
||||
{
|
||||
if (baudrate / 300 != Settings->modbus_sbaudrate)
|
||||
if (baudrate / 300 != Settings->modbus_sbaudrate)
|
||||
{
|
||||
Settings->modbus_sbaudrate = baudrate / 300;
|
||||
ModbusBridgeBegin();
|
||||
@ -204,12 +216,12 @@ void ModbusBridgeHandle(void)
|
||||
if (data_ready)
|
||||
{
|
||||
uint8_t *buffer;
|
||||
buffer = (uint8_t *)malloc(5 + (modbusBridge.registerCount * 2)); // Addres(1), Function(1), Length(1), Data(1..n), CRC(2)
|
||||
uint32_t error = tasmotaModbus->ReceiveBuffer(buffer, modbusBridge.registerCount);
|
||||
buffer = (uint8_t *)malloc(9 + (modbusBridge.dataCount * 2)); // Addres(1), Function(1), Length(1), Data(1..n), CRC(2)
|
||||
uint32_t error = tasmotaModbus->ReceiveBuffer(buffer, modbusBridge.dataCount);
|
||||
|
||||
if (error)
|
||||
{
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Driver error %d"), error);
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Driver receive error %d"), error);
|
||||
free(buffer);
|
||||
return;
|
||||
}
|
||||
@ -225,17 +237,17 @@ void ModbusBridgeHandle(void)
|
||||
MBAP_Header[1] = modbusBridgeTCP.tcp_transaction_id;
|
||||
MBAP_Header[2] = 0;
|
||||
MBAP_Header[3] = 0;
|
||||
MBAP_Header[4] = ((modbusBridge.registerCount * 2) + 3) >> 8;
|
||||
MBAP_Header[5] = (modbusBridge.registerCount * 2) + 3;
|
||||
MBAP_Header[4] = ((modbusBridge.dataCount * 2) + 3) >> 8;
|
||||
MBAP_Header[5] = (modbusBridge.dataCount * 2) + 3;
|
||||
MBAP_Header[6] = buffer[0]; // Send slave address
|
||||
client.write(MBAP_Header, 7);
|
||||
client.write(buffer + 1, 1); // Send Functioncode
|
||||
client.write(buffer + 1, 1); // Send Functioncode
|
||||
uint8_t bytecount[1];
|
||||
bytecount[0] = modbusBridge.registerCount * 2;
|
||||
client.write(bytecount, 1); // Send length of rtu data
|
||||
client.write(buffer + 3, (modbusBridge.registerCount * 2)); // Don't send CRC
|
||||
bytecount[0] = modbusBridge.dataCount * 2;
|
||||
client.write(bytecount, 1); // Send length of rtu data
|
||||
client.write(buffer + 3, (modbusBridge.dataCount * 2)); // Don't send CRC
|
||||
client.flush();
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBRTCP from Modbus deviceAddress %d, writing %d bytes to client"), buffer[0], (modbusBridge.registerCount * 2) + 9);
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBRTCP from Modbus deviceAddress %d, writing %d bytes to client"), buffer[0], (modbusBridge.dataCount * 2) + 9);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -257,13 +269,34 @@ void ModbusBridgeHandle(void)
|
||||
errorcode = ModbusBridgeError::wrongdeviceaddress;
|
||||
else if ((uint8_t)modbusBridge.functionCode != (uint8_t)buffer[1])
|
||||
errorcode = ModbusBridgeError::wrongfunctioncode;
|
||||
else if ((uint8_t)modbusBridge.registerCount * 2 != (uint8_t)buffer[2])
|
||||
errorcode = ModbusBridgeError::wrongregistercount;
|
||||
else
|
||||
else if ((uint8_t)modbusBridge.functionCode < 5)
|
||||
{
|
||||
if ((uint8_t)modbusBridge.functionCode < 3)
|
||||
{
|
||||
if ((uint8_t)(((modbusBridge.dataCount - 1) >> 3) + 1) != (uint8_t)buffer[2])
|
||||
errorcode = ModbusBridgeError::wrongdataCount;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((modbusBridge.type == ModbusBridgeType::mb_int8 || modbusBridge.type == ModbusBridgeType::mb_uint8)
|
||||
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
|
||||
errorcode = ModbusBridgeError::wrongdataCount;
|
||||
else if ((modbusBridge.type == ModbusBridgeType::mb_bit)
|
||||
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
|
||||
errorcode = ModbusBridgeError::wrongdataCount;
|
||||
else if ((modbusBridge.type == ModbusBridgeType::mb_int16 || modbusBridge.type == ModbusBridgeType::mb_uint16)
|
||||
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
|
||||
errorcode = ModbusBridgeError::wrongdataCount;
|
||||
else if ((modbusBridge.type == ModbusBridgeType::mb_int32 || modbusBridge.type == ModbusBridgeType::mb_uint32 || modbusBridge.type == ModbusBridgeType::mb_float)
|
||||
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
|
||||
errorcode = ModbusBridgeError::wrongdataCount;
|
||||
}
|
||||
}
|
||||
if (errorcode == ModbusBridgeError::noerror)
|
||||
{
|
||||
if (modbusBridge.type == ModbusBridgeType::mb_raw)
|
||||
{
|
||||
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":["));
|
||||
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{\"RAW\":["));
|
||||
for (uint8_t i = 0; i < tasmotaModbus->ReceiveCount(); i++)
|
||||
{
|
||||
ResponseAppend_P(PSTR("%d"), buffer[i]);
|
||||
@ -274,38 +307,103 @@ void ModbusBridgeHandle(void)
|
||||
ResponseJsonEnd();
|
||||
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
|
||||
}
|
||||
else if ((buffer[1] > 0) && (buffer[1] < 5)) // Read Registers, writing is not supported at this moment
|
||||
else if (modbusBridge.type == ModbusBridgeType::mb_hex)
|
||||
{
|
||||
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{\"HEX\":["));
|
||||
for (uint8_t i = 0; i < tasmotaModbus->ReceiveCount(); i++)
|
||||
{
|
||||
ResponseAppend_P(PSTR("0x%02X"), buffer[i]);
|
||||
if (i < tasmotaModbus->ReceiveCount() - 1)
|
||||
ResponseAppend_P(PSTR(","));
|
||||
}
|
||||
ResponseAppend_P(PSTR("]}"));
|
||||
ResponseJsonEnd();
|
||||
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
|
||||
}
|
||||
else if ((buffer[1] > 0) && (buffer[1] < 7)) // Read Registers
|
||||
{
|
||||
uint8_t dataOffset = 3;
|
||||
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{"));
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_DEVICE_ADDRESS "\":%d,"), buffer[0]);
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_FUNCTION_CODE "\":%d,"), buffer[1]);
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), modbusBridge.startAddress);
|
||||
if (buffer[1] < 5)
|
||||
{
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), modbusBridge.startAddress);
|
||||
}
|
||||
else
|
||||
{
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), (buffer[2] << 8) + buffer[3]);
|
||||
dataOffset = 4;
|
||||
}
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_LENGTH "\":%d,"), tasmotaModbus->ReceiveCount());
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_COUNT "\":%d,"), modbusBridge.count);
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_VALUES "\":["));
|
||||
|
||||
for (uint8_t count = 0; count < modbusBridge.count; count++)
|
||||
uint8_t data_count = modbusBridge.count;
|
||||
if ((uint8_t)modbusBridge.functionCode < 3)
|
||||
{
|
||||
if (modbusBridge.type == ModbusBridgeType::mb_int8 || modbusBridge.type == ModbusBridgeType::mb_uint8)
|
||||
data_count = (uint8_t)(((modbusBridge.count - 1) >> 3) + 1);
|
||||
else if (modbusBridge.type == ModbusBridgeType::mb_int16 || modbusBridge.type == ModbusBridgeType::mb_uint16)
|
||||
data_count = (uint8_t)(((modbusBridge.count - 1) >> 4) + 1);
|
||||
else if (modbusBridge.type == ModbusBridgeType::mb_int32 || modbusBridge.type == ModbusBridgeType::mb_uint32 || modbusBridge.type == ModbusBridgeType::mb_float)
|
||||
data_count = (uint8_t)(((modbusBridge.count - 1) >> 5) + 1);
|
||||
}
|
||||
for (uint8_t count = 0; count < data_count; count++)
|
||||
{
|
||||
char svalue[MBR_MAX_VALUE_LENGTH + 1] = "";
|
||||
if (modbusBridge.type == ModbusBridgeType::mb_float)
|
||||
{
|
||||
float value = 0;
|
||||
((uint8_t *)&value)[3] = buffer[3 + (count * 4)]; // Get float values
|
||||
((uint8_t *)&value)[2] = buffer[4 + (count * 4)];
|
||||
((uint8_t *)&value)[1] = buffer[5 + (count * 4)];
|
||||
((uint8_t *)&value)[0] = buffer[6 + (count * 4)];
|
||||
if (buffer[1] < 3)
|
||||
{
|
||||
if (buffer[2] - (count * 4))
|
||||
((uint8_t *)&value)[0] = buffer[dataOffset + (count * 4)]; // Get int values
|
||||
if ((buffer[2] - (count * 4)) >> 1)
|
||||
((uint8_t *)&value)[1] = buffer[dataOffset + 1 + (count * 4)];
|
||||
if ((buffer[2] - (count * 4) - 1) >> 1)
|
||||
((uint8_t *)&value)[2] = buffer[dataOffset + 2 + (count * 4)];
|
||||
if ((buffer[2] - (count * 4)) >> 2)
|
||||
((uint8_t *)&value)[3] = buffer[dataOffset + 3 + (count * 4)];
|
||||
}
|
||||
else
|
||||
{
|
||||
((uint8_t *)&value)[3] = buffer[dataOffset + (count * 4)]; // Get float values
|
||||
((uint8_t *)&value)[2] = buffer[dataOffset + 1 + (count * 4)];
|
||||
((uint8_t *)&value)[1] = buffer[dataOffset + 2 + (count * 4)];
|
||||
((uint8_t *)&value)[0] = buffer[dataOffset + 3 + (count * 4)];
|
||||
}
|
||||
ext_snprintf_P(svalue, sizeof(svalue), "%*_f", 10, &value);
|
||||
}
|
||||
else if (modbusBridge.type == ModbusBridgeType::mb_bit)
|
||||
{
|
||||
uint8_t value = (uint8_t)(buffer[dataOffset + (count >> 3)]);
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", ((value >> (count & 7)) & 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((modbusBridge.type == ModbusBridgeType::mb_int32) ||
|
||||
(modbusBridge.type == ModbusBridgeType::mb_uint32))
|
||||
{
|
||||
uint32_t value = 0;
|
||||
((uint8_t *)&value)[3] = buffer[3 + (count * 4)]; // Get int values
|
||||
((uint8_t *)&value)[2] = buffer[4 + (count * 4)];
|
||||
((uint8_t *)&value)[1] = buffer[5 + (count * 4)];
|
||||
((uint8_t *)&value)[0] = buffer[6 + (count * 4)];
|
||||
if (buffer[1] < 3)
|
||||
{
|
||||
if (buffer[2] - (count * 4))
|
||||
((uint8_t *)&value)[0] = buffer[dataOffset + (count * 4)]; // Get int values
|
||||
if ((buffer[2] - (count * 4)) >> 1)
|
||||
((uint8_t *)&value)[1] = buffer[dataOffset + 1 + (count * 4)];
|
||||
if ((buffer[2] - (count * 4) - 1) >> 1)
|
||||
((uint8_t *)&value)[2] = buffer[dataOffset + 2 + (count * 4)];
|
||||
if ((buffer[2] - (count * 4)) >> 2)
|
||||
((uint8_t *)&value)[3] = buffer[dataOffset + 3 + (count * 4)];
|
||||
}
|
||||
else
|
||||
{
|
||||
((uint8_t *)&value)[3] = buffer[dataOffset + (count * 4)]; // Get int values
|
||||
((uint8_t *)&value)[2] = buffer[dataOffset + 1 + (count * 4)];
|
||||
((uint8_t *)&value)[1] = buffer[dataOffset + 2 + (count * 4)];
|
||||
((uint8_t *)&value)[0] = buffer[dataOffset + 3 + (count * 4)];
|
||||
}
|
||||
if (modbusBridge.type == ModbusBridgeType::mb_int32)
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value);
|
||||
else
|
||||
@ -315,21 +413,41 @@ void ModbusBridgeHandle(void)
|
||||
(modbusBridge.type == ModbusBridgeType::mb_uint16))
|
||||
{
|
||||
uint16_t value = 0;
|
||||
((uint8_t *)&value)[1] = buffer[3 + (count * 2)];
|
||||
((uint8_t *)&value)[0] = buffer[4 + (count * 2)];
|
||||
if (buffer[1] < 3)
|
||||
{
|
||||
if (buffer[2] - (count * 2))
|
||||
((uint8_t *)&value)[0] = buffer[dataOffset + (count * 2)];
|
||||
if ((buffer[2] - (count * 2)) >> 1)
|
||||
((uint8_t *)&value)[1] = buffer[dataOffset + 1 + (count * 2)];
|
||||
}
|
||||
else
|
||||
{
|
||||
((uint8_t *)&value)[1] = buffer[dataOffset + (count * 2)];
|
||||
((uint8_t *)&value)[0] = buffer[dataOffset + 1 + (count * 2)];
|
||||
}
|
||||
if (modbusBridge.type == ModbusBridgeType::mb_int16)
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value);
|
||||
else
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value);
|
||||
}
|
||||
else if ((modbusBridge.type == ModbusBridgeType::mb_int8) ||
|
||||
(modbusBridge.type == ModbusBridgeType::mb_uint8))
|
||||
{
|
||||
uint8_t value = buffer[dataOffset + (count * 1)];
|
||||
if (modbusBridge.type == ModbusBridgeType::mb_int8)
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value);
|
||||
else
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value);
|
||||
}
|
||||
/*
|
||||
else if (modbusBridge.type == ModbusBridgeType::mb_bit)
|
||||
{
|
||||
uint8_t value = (uint8_t)(buffer[3 + count]);
|
||||
uint8_t value = (uint8_t)(buffer[dataOffset + count]);
|
||||
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d%d%d%d%d%d%d%d", ((value >> 7) & 1), ((value >> 6) & 1), ((value >> 5) & 1), ((value >> 4) & 1), ((value >> 3) & 1), ((value >> 2) & 1), ((value >> 1) & 1), (value & 1));
|
||||
}
|
||||
}*/
|
||||
}
|
||||
ResponseAppend_P(PSTR("%s"), svalue);
|
||||
if (count < modbusBridge.count - 1)
|
||||
if (count < data_count - 1)
|
||||
ResponseAppend_P(PSTR(","));
|
||||
}
|
||||
|
||||
@ -339,6 +457,19 @@ void ModbusBridgeHandle(void)
|
||||
if (errorcode == ModbusBridgeError::noerror)
|
||||
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
|
||||
}
|
||||
else if ((buffer[1] == 15) || (buffer[1] == 16)) // Write Multiple Registers
|
||||
{
|
||||
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{"));
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_DEVICE_ADDRESS "\":%d,"), buffer[0]);
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_FUNCTION_CODE "\":%d,"), buffer[1]);
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), (buffer[2] << 8) + buffer[3]);
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_LENGTH "\":%d,"), tasmotaModbus->ReceiveCount());
|
||||
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_COUNT "\":%d"), (buffer[4] << 8) + buffer[5]);
|
||||
ResponseAppend_P(PSTR("}"));
|
||||
ResponseJsonEnd();
|
||||
if (errorcode == ModbusBridgeError::noerror)
|
||||
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
|
||||
}
|
||||
else
|
||||
errorcode = ModbusBridgeError::wrongfunctioncode;
|
||||
}
|
||||
@ -450,13 +581,13 @@ void ModbusTCPHandle(void)
|
||||
uint8_t mbdeviceaddress = (uint8_t)modbusBridgeTCP.tcp_buf[6];
|
||||
uint8_t mbfunctioncode = (uint8_t)modbusBridgeTCP.tcp_buf[7];
|
||||
uint16_t mbstartaddress = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[8]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[9]));
|
||||
modbusBridge.registerCount = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[10]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[11]));
|
||||
modbusBridge.dataCount = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[10]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[11]));
|
||||
modbusBridgeTCP.tcp_transaction_id = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[0]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[1]));
|
||||
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("MBS: MBRTCP to Modbus Transactionid:%d, deviceAddress:%d, functionCode:%d, startAddress:%d, Count:%d"),
|
||||
modbusBridgeTCP.tcp_transaction_id, mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.registerCount);
|
||||
modbusBridgeTCP.tcp_transaction_id, mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.dataCount);
|
||||
|
||||
tasmotaModbus->Send(mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.registerCount);
|
||||
tasmotaModbus->Send(mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.dataCount);
|
||||
}
|
||||
}
|
||||
yield(); // avoid WDT if heavy traffic
|
||||
@ -470,6 +601,10 @@ void ModbusTCPHandle(void)
|
||||
|
||||
void CmndModbusBridgeSend(void)
|
||||
{
|
||||
uint16_t *writeData = NULL;
|
||||
uint8_t writeDataSize = 0;
|
||||
ModbusBridgeError errorcode = ModbusBridgeError::noerror;
|
||||
|
||||
JsonParser parser(XdrvMailbox.data);
|
||||
JsonParserObject root = parser.getRootObject();
|
||||
if (!root)
|
||||
@ -478,16 +613,16 @@ void CmndModbusBridgeSend(void)
|
||||
modbusBridge.deviceAddress = root.getUInt(PSTR(D_JSON_MODBUS_DEVICE_ADDRESS), 0);
|
||||
uint8_t functionCode = root.getUInt(PSTR(D_JSON_MODBUS_FUNCTION_CODE), 0);
|
||||
modbusBridge.startAddress = root.getULong(PSTR(D_JSON_MODBUS_START_ADDRESS), 0);
|
||||
|
||||
const char *stype = root.getStr(PSTR(D_JSON_MODBUS_TYPE), "uint8");
|
||||
modbusBridge.count = root.getUInt(PSTR(D_JSON_MODBUS_COUNT), 1);
|
||||
ModbusBridgeError errorcode = ModbusBridgeError::noerror;
|
||||
|
||||
if (modbusBridge.deviceAddress == 0)
|
||||
errorcode = ModbusBridgeError::wrongdeviceaddress;
|
||||
else if (modbusBridge.startAddress == 0)
|
||||
;
|
||||
else if (functionCode > 4)
|
||||
errorcode = ModbusBridgeError::wrongfunctioncode; // Writing is not supported
|
||||
else if ((functionCode > (uint8_t)ModbusBridgeFunctionCode::mb_writeSingleRegister) &&
|
||||
(functionCode != (uint8_t)ModbusBridgeFunctionCode::mb_writeMultipleCoils) &&
|
||||
(functionCode != (uint8_t)ModbusBridgeFunctionCode::mb_writeMultipleRegisters))
|
||||
errorcode = ModbusBridgeError::wrongfunctioncode; // Invalid function code
|
||||
else
|
||||
{
|
||||
modbusBridge.functionCode = static_cast<ModbusBridgeFunctionCode>(functionCode);
|
||||
@ -496,54 +631,166 @@ void CmndModbusBridgeSend(void)
|
||||
}
|
||||
|
||||
modbusBridge.type = ModbusBridgeType::mb_undefined;
|
||||
if (strcmp(stype, "int16") == 0)
|
||||
if (strcmp(stype, "int8") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_int8;
|
||||
modbusBridge.dataCount = ((modbusBridge.count - 1)/ 2) + 1;
|
||||
}
|
||||
else if (strcmp(stype, "int16") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_int16;
|
||||
modbusBridge.registerCount = modbusBridge.count;
|
||||
modbusBridge.dataCount = modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "int32") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_int32;
|
||||
modbusBridge.registerCount = 2 * modbusBridge.count;
|
||||
modbusBridge.dataCount = 2 * modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "uint16") == 0)
|
||||
else if ((strcmp(stype, "uint8") == 0))
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_uint8;
|
||||
modbusBridge.dataCount = ((modbusBridge.count - 1)/ 2) + 1;
|
||||
}
|
||||
else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_uint16;
|
||||
modbusBridge.registerCount = modbusBridge.count;
|
||||
modbusBridge.dataCount = modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "uint32") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_uint32;
|
||||
modbusBridge.registerCount = 2 * modbusBridge.count;
|
||||
modbusBridge.dataCount = 2 * modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "float") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_float;
|
||||
modbusBridge.registerCount = 2 * modbusBridge.count;
|
||||
modbusBridge.dataCount = 2 * modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "raw") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_raw;
|
||||
modbusBridge.registerCount = modbusBridge.count;
|
||||
modbusBridge.dataCount = modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "hex") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_hex;
|
||||
modbusBridge.dataCount = modbusBridge.count;
|
||||
}
|
||||
else if (strcmp(stype, "bit") == 0)
|
||||
{
|
||||
modbusBridge.type = ModbusBridgeType::mb_bit;
|
||||
modbusBridge.registerCount = modbusBridge.count;
|
||||
modbusBridge.dataCount = ((modbusBridge.count - 1) / 16) + 1;
|
||||
}
|
||||
else
|
||||
errorcode = ModbusBridgeError::wrongtype;
|
||||
|
||||
if (modbusBridge.registerCount > MBR_MAX_REGISTERS)
|
||||
if (modbusBridge.dataCount > MBR_MAX_REGISTERS)
|
||||
errorcode = ModbusBridgeError::wrongcount;
|
||||
|
||||
// If write data is specified in JSON copy it into writeData array
|
||||
JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_VALUES)].getArray();
|
||||
if (jsonDataArray.isArray())
|
||||
{
|
||||
if (modbusBridge.dataCount > 40)
|
||||
{
|
||||
errorcode = ModbusBridgeError::tomanydata;
|
||||
}
|
||||
else
|
||||
{
|
||||
writeDataSize = jsonDataArray.size();
|
||||
|
||||
if (modbusBridge.count != writeDataSize)
|
||||
{
|
||||
errorcode = ModbusBridgeError::wrongcount;
|
||||
}
|
||||
else
|
||||
{
|
||||
writeData = (uint16_t *)malloc(writeDataSize * 2);
|
||||
for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++)
|
||||
{
|
||||
switch (modbusBridge.type)
|
||||
{
|
||||
case ModbusBridgeType::mb_bit:
|
||||
{
|
||||
// Set 2 following bytes to 0
|
||||
if (jsonDataArrayPointer % 16 == 0)
|
||||
{
|
||||
writeData[jsonDataArrayPointer/15] = 0;
|
||||
}
|
||||
// Swap low and high bytes according to modbus specification
|
||||
uint16_t bitValue = (jsonDataArray[jsonDataArrayPointer].getUInt(0) == 1) ? 1 : 0;
|
||||
uint8_t bitPointer = (jsonDataArrayPointer % 15) + 8;
|
||||
if (bitPointer > 15) bitPointer -= 16;
|
||||
|
||||
writeData[jsonDataArrayPointer/15] += bitValue << bitPointer;
|
||||
}
|
||||
break;
|
||||
case ModbusBridgeType::mb_int8:
|
||||
if (jsonDataArrayPointer % 2) writeData[jsonDataArrayPointer / 2] += (int8_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
|
||||
else writeData[jsonDataArrayPointer] = (int8_t)jsonDataArray[jsonDataArrayPointer / 2].getInt(0) << 8;
|
||||
break;
|
||||
case ModbusBridgeType::mb_uint8:
|
||||
if (jsonDataArrayPointer % 2) writeData[jsonDataArrayPointer / 2] += (uint8_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
|
||||
else writeData[jsonDataArrayPointer / 2] = (uint8_t)jsonDataArray[jsonDataArrayPointer].getInt(0) << 8;
|
||||
break;
|
||||
case ModbusBridgeType::mb_int16:
|
||||
writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
|
||||
break;
|
||||
case ModbusBridgeType::mb_uint16:
|
||||
writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0);
|
||||
break;
|
||||
case ModbusBridgeType::mb_float:
|
||||
// TODO
|
||||
errorcode = ModbusBridgeError::wrongtype;
|
||||
break;
|
||||
case ModbusBridgeType::mb_int32:
|
||||
writeData[jsonDataArrayPointer++] = (int16_t)(jsonDataArray[jsonDataArrayPointer].getInt(0) >> 16);
|
||||
writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
|
||||
break;
|
||||
case ModbusBridgeType::mb_uint32:
|
||||
writeData[jsonDataArrayPointer++] = (uint16_t)(jsonDataArray[jsonDataArrayPointer].getUInt(0) >> 16);
|
||||
writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0);
|
||||
break;
|
||||
case ModbusBridgeType::mb_raw:
|
||||
writeData[jsonDataArrayPointer] = (uint8_t)jsonDataArray[jsonDataArrayPointer*2].getUInt(0) << 8 + (uint8_t)jsonDataArray[(jsonDataArrayPointer*2)+1].getUInt(0);
|
||||
break;
|
||||
case ModbusBridgeType::mb_hex:
|
||||
writeData[jsonDataArrayPointer] = (uint8_t)jsonDataArray[jsonDataArrayPointer*2].getUInt(0) << 8 + (uint8_t)jsonDataArray[(jsonDataArrayPointer*2)+1].getUInt(0);
|
||||
break;
|
||||
default:
|
||||
errorcode = ModbusBridgeError::wrongtype;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handle errorcode and exit function when an error has occured
|
||||
if (errorcode != ModbusBridgeError::noerror)
|
||||
{
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Send Error %d"), (uint8_t)errorcode);
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Send Error %u"), (uint8_t)errorcode);
|
||||
free(writeData);
|
||||
return;
|
||||
}
|
||||
|
||||
tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.registerCount);
|
||||
// Adapt data according to modbus protocol
|
||||
for (uint8_t writeDataPointer = 0; writeDataPointer < modbusBridge.dataCount; writeDataPointer++)
|
||||
{
|
||||
// For function code 5, on and off are 0xFF00 and 0x0000, not 1 and 0
|
||||
if (modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleCoil)
|
||||
{
|
||||
writeData[writeDataPointer] = writeData[writeDataPointer] ? 0xFF00 : 0x0000;
|
||||
}
|
||||
}
|
||||
|
||||
// If writing a single coil or single register, the register count is always 1. We also prevent writing data out of range
|
||||
if ((modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleCoil) || (modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleRegister))
|
||||
modbusBridge.dataCount = 1;
|
||||
|
||||
uint8_t error = tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.dataCount, writeData);
|
||||
if (error) AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Driver send error %u"), error);
|
||||
free(writeData);
|
||||
ResponseCmndDone();
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user