aboutsummaryrefslogtreecommitdiff
path: root/software
diff options
context:
space:
mode:
Diffstat (limited to 'software')
-rw-r--r--software/libs/libpq_esp32.cpp1546
-rw-r--r--software/libs/libpq_esp32.h270
2 files changed, 1816 insertions, 0 deletions
diff --git a/software/libs/libpq_esp32.cpp b/software/libs/libpq_esp32.cpp
new file mode 100644
index 0000000..0a89c2a
--- /dev/null
+++ b/software/libs/libpq_esp32.cpp
@@ -0,0 +1,1546 @@
+/*
+ * libpq_esp32.cpp
+ *
+ * Created on: 26.02.2022
+ * Author: michi
+ * SPDX-FileCopyrightText: 2022 MDC Service <info@mdc-service.de>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ * Ported from SimplePgSQL (https://github.com/ethanak/SimplePgSQL) to ESP IDF
+ * original SimplePgSQL: * Copyright (C) Bohdan R. Rau 2016 <ethanak@polip.com>
+ */
+
+#include "libpq_esp32.h"
+
+
+
+#ifdef ESP32
+#define strchr_P strchr
+#endif
+
+#ifdef PG_USE_MD5
+
+/**
+ * bytesToHex: convert bytes to HEX
+ *
+ * @param b byte array to con.vert
+ * @param s string result
+ */
+
+static void
+bytesToHex(const uint8_t b[16], char *s)
+{
+ int q, w;
+#ifndef ESP32
+ static PROGMEM const char hex[] = "0123456789abcdef";
+ for (q = 0, w = 0; q < 16; q++)
+ {
+ s[w++] = pgm_read_byte(&hex[(b[q] >> 4) & 0x0F]);
+ s[w++] = pgm_read_byte(&hex[b[q] & 0x0F]);
+ }
+#else
+ static const char hex[] = "0123456789abcdef";
+ for (q = 0, w = 0; q < 16; q++)
+ {
+ s[w++] = hex[(b[q] >> 4) & 0x0F];
+ s[w++] = hex[b[q] & 0x0F];
+ }
+#endif
+ s[w] = '\0';
+}
+
+#ifdef ESP32_IDF
+#include "esp_log.h"
+#endif
+
+#ifdef ESP32
+#include <mbedtls/md5.h>
+
+/**
+ * pg_md5_encrypt: md5 encryption for PostgreSQL
+ *
+ * @param password as unecrypted string
+ * @param salt parameter string for the md5 algorithm
+ * @param salt_len length of the salt parameter
+ * @param outbuf is the resulting md5 encrypted password
+ */
+
+static void pg_md5_encrypt(const char *password, char *salt, int salt_len, char *outbuf)
+{
+ md5_context_t context;
+ uint8_t sum[16];
+ *outbuf++ = 'm';
+ *outbuf++ = 'd';
+ *outbuf++ = '5';
+ mbedtls_md5_init(&context);
+ mbedtls_md5_update_ret(&context, (uint8_t *)password, strlen(password));
+ mbedtls_md5_update_ret(&context, (uint8_t *)salt, salt_len);
+ mbedtls_md5_finish_ret( &context, sum);
+ bytesToHex(sum, outbuf);
+}
+#elif defined(ESP8266)
+#include <md5.h>
+/**
+ * pg_md5_encrypt: md5 encryption for PostgreSQL
+ *
+ * @param password as unecrypted string
+ * @param salt parameter string for the md5 algorithm
+ * @param salt_len length of the salt parameter
+ * @param outbuf is the resulting md5 encrypted password
+ */
+static void pg_md5_encrypt(const char *password, char *salt, int salt_len, char *outbuf)
+{
+ md5_context_t context;
+ uint8_t sum[16];
+ *outbuf++ = 'm';
+ *outbuf++ = 'd';
+ *outbuf++ = '5';
+ MD5Init(&context);
+ MD5Update(&context, (uint8_t *)password, strlen(password));
+ MD5Update(&context, (uint8_t *)salt, salt_len);
+ MD5Final(sum, &context);
+ bytesToHex(sum, outbuf);
+}
+#else
+//#include <MD5.h>
+/**
+ * pg_md5_encrypt: md5 encryption for PostgreSQL
+ *
+ * @param password as unecrypted string
+ * @param salt parameter string for the md5 algorithm
+ * @param salt_len length of the salt parameter
+ * @param outbuf is the resulting md5 encrypted password
+ */
+static void pg_md5_encrypt(const char *password, char *salt, int salt_len, char *outbuf)
+{
+ MD5_CTX context;
+ uint8_t sum[16];
+ *outbuf++ = 'm';
+ *outbuf++ = 'd';
+ *outbuf++ = '5';
+
+ MD5::MD5Init(&context);
+ MD5::MD5Update(&context, (uint8_t *)password, strlen(password));
+ MD5::MD5Update(&context, (uint8_t *)salt, salt_len);
+ MD5::MD5Final(sum, &context);
+ bytesToHex(sum, outbuf);
+}
+#endif
+#endif
+
+#define MD5_PASSWD_LEN 35
+#define AUTH_REQ_OK 0 /* User is authenticated */
+#define AUTH_REQ_PASSWORD 3 /* Password */
+#define AUTH_REQ_MD5 5 /* md5 password */
+
+#ifndef ESP32_IDF
+static PROGMEM const char EM_OOM [] = "Out of memory";
+static PROGMEM const char EM_READ [] = "Backend read error";
+static PROGMEM const char EM_WRITE [] = "Backend write error";
+static PROGMEM const char EM_CONN [] = "Cannot connect to server";
+static PROGMEM const char EM_SYNC [] = "Backend out of sync";
+static PROGMEM const char EM_INTR [] = "Internal error";
+static PROGMEM const char EM_UAUTH [] = "Unsupported auth method";
+static PROGMEM const char EM_BIN [] = "Binary format not supported";
+static PROGMEM const char EM_EXEC [] = "Previous execution not finished";
+static PROGMEM const char EM_PASSWD [] = "Password required";
+static PROGMEM const char EM_EMPTY [] = "Query is empty";
+static PROGMEM const char EM_FORMAT [] = "Illegal formatting character";
+#else
+static const char EM_OOM [] = "Out of memory";
+static const char EM_READ [] = "Backend read error";
+static const char EM_WRITE [] = "Backend write error";
+static const char EM_CONN [] = "Cannot connect to server";
+static const char EM_SYNC [] = "Backend out of sync";
+static const char EM_INTR [] = "Internal error";
+static const char EM_UAUTH [] = "Unsupported auth method";
+static const char EM_BIN [] = "Binary format not supported";
+static const char EM_EXEC [] = "Previous execution not finished";
+static const char EM_PASSWD [] = "Password required";
+static const char EM_EMPTY [] = "Query is empty";
+static const char EM_FORMAT [] = "Illegal formatting character";
+
+#define PGTAG "PGSQL"
+#endif
+
+#ifndef ESP32_IDF
+/**
+ * PGconnection constructor for Arduino
+ *
+ * @param c the Arduino Client pointer
+ * @param flags for the connection. See the postgresql libpq documentation for more details
+ * @param memory specify buffer size
+ * @param foreignBuffer specify is internal or external memory is used.
+ */
+PGconnection::PGconnection(Client *c,
+ int flags,
+ int memory,
+ char *foreignBuffer)
+{
+ conn_status = CONNECTION_NEEDED;
+ client = c;
+ Buffer = foreignBuffer;
+ _passwd = NULL;
+ _flags = flags & ~PG_FLAG_STATIC_BUFFER;
+
+ if (memory <= 0) bufSize = PG_BUFFER_SIZE;
+ else bufSize = memory;
+ if (foreignBuffer) {
+ _flags |= PG_FLAG_STATIC_BUFFER;
+ }
+}
+#else
+
+/**
+ * PGconnection constructor for ESP IDF
+ *
+ * @param flags for the connection. See the postgresql libpq documentation for more details
+ * @param _Buffer points to the external allocated buffer
+ * @param _bufSize specify the buffer size.
+ */
+PGconnection::PGconnection(const int flags, const unsigned char *_Buffer, const int _bufSize) {
+ conn_status = CONNECTION_NEEDED;
+ _passwd = NULL;
+ _user = NULL;
+ Buffer = (char *) _Buffer;
+ bufSize = _bufSize;
+ bufPos = 0;
+ result_status=0;
+ _available=0;
+ _nfields=0;
+ _ntuples=0;
+ _flags=0;
+
+ conn_status = CONNECTION_NEEDED;
+ _flags = flags & ~PG_FLAG_STATIC_BUFFER;
+ bufSize = PG_BUFFER_SIZE;
+}
+#endif
+
+#ifndef ESP32_IDF
+
+/**
+ * PGconnection setDbLogin for Arduino
+ *
+ * @param IPAddress for the connection.
+ * @param user name, the PostgreSQL user name.
+ * @param passwd the PostgreSQL password.
+ * @param db the name of the database.
+ * @param charset the used char set
+ * @param port the TCP/IP port, typically 5432
+ * @returns the connection status
+ */
+
+int PGconnection::setDbLogin(IPAddress server,
+ const char *user,
+ const char *passwd,
+ const char *db,
+ const char *charset,
+ int port)
+{
+
+ char *startpacket;
+ int packetlen;
+ int len;
+
+ close();
+ if (!db) db = user;
+ len = strlen(user) + 1;
+ if (passwd) {
+ len += strlen(passwd) + 1;
+ }
+ _user = (char *)malloc(len);
+ strcpy(_user, user);
+ if (passwd) {
+ _passwd = _user + strlen(user) + 1;
+ strcpy(_passwd, passwd);
+ }
+ else {
+ _passwd = NULL;
+ }
+ if (!Buffer) Buffer = (char *) malloc(bufSize);
+ byte connected = client -> connect(server, port);
+ if (!connected) {
+ setMsg_P(EM_CONN, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ packetlen = build_startup_packet(NULL, db, charset);
+ if (packetlen > bufSize - 10) {
+ setMsg_P(EM_OOM, PG_RSTAT_HAVE_ERROR);
+ conn_status = CONNECTION_BAD;
+ return conn_status;
+ }
+ startpacket=Buffer + (bufSize - (packetlen + 1));
+ build_startup_packet(startpacket, db, charset);
+ if (pqPacketSend(0, startpacket, packetlen) < 0) {
+ setMsg_P(EM_WRITE, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ attempts = 0;
+ return conn_status = CONNECTION_AWAITING_RESPONSE;
+}
+#else
+
+/**
+ * PGconnection setDbLogin for ESP IDF
+ *
+ * @param ServerIP as char string.
+ * @param ServerPort, typically 5432
+ * @param dbName the name of the database.
+ * @param dbUser the user name of the database.
+ * @param dbPasswd the PostgreSQL password.
+ * @param charset the used char set
+ * @returns the connection status
+ */
+
+int PGconnection::setDbLogin(const char *ServerIP, int ServerPort, const char *dbName, const char *dbUser, const char *dbPasswd, const char *dbCharset) {
+
+ char *startpacket;
+ int packetlen;
+ int len;
+
+// close();
+ memset(&DestAddr, 0, sizeof(DestAddr));
+ AddrFamily = AF_INET;
+ ipProtocol = IPPROTO_IP;
+ DestAddr.sin_addr.s_addr = inet_addr(ServerIP);
+ DestAddr.sin_family = AF_INET;
+ DestAddr.sin_port = htons(ServerPort);
+
+ if (!dbName)
+ dbName = dbUser;
+ len = strlen(dbUser) + 1;
+ if (dbPasswd) {
+ len += strlen(dbPasswd) + 1;
+ }
+ _user = (char *) malloc(len);
+ strcpy(_user, dbUser);
+ if (dbPasswd) {
+ _passwd = _user + strlen(dbUser) + 1;
+ strcpy(_passwd, dbPasswd);
+ } else {
+ _passwd = NULL;
+ }
+
+ //int8_t connected = connect(client->connect(server, port);
+ SockH = socket(AddrFamily, SOCK_STREAM, ipProtocol);
+ if (SockH < 0) {
+ ESP_LOGE(PGTAG, "Unable to create socket: errno %d", errno);
+ setMsg_P(EM_CONN, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ } else {
+ int err = connect(SockH, (struct sockaddr *) &DestAddr, sizeof(DestAddr));
+ if (err != 0) {
+ ESP_LOGE(PGTAG, "Socket unable to connect: errno %d", errno);
+ return conn_status = CONNECTION_BAD;
+ }
+ NetConnected = 1;
+ ESP_LOGI(PGTAG, "Successfully connected");
+ }
+
+ packetlen = build_startup_packet(NULL, dbName, dbCharset);
+ if (packetlen > bufSize - 10) {
+ setMsg_P(EM_OOM, PG_RSTAT_HAVE_ERROR);
+ conn_status = CONNECTION_BAD;
+ return conn_status;
+ }
+
+ startpacket = Buffer + (bufSize - (packetlen + 1));
+ build_startup_packet(startpacket, dbName, dbCharset);
+ if (pqPacketSend(0, startpacket, packetlen) < 0) {
+ setMsg_P(EM_WRITE, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ attempts = 0;
+ return conn_status = CONNECTION_AWAITING_RESPONSE;
+}
+
+/**
+ * PGconnection close_socket for ESP IDF
+ *
+ * @param _SockH the socket handle.
+ */
+void close_socket(int _SockH)
+{
+ close(_SockH);
+}
+#endif
+
+/**
+ * PGconnection close. Free allocated resources
+ *
+ */
+
+void PGconnection::close(void)
+{
+#ifndef ESP32_IDF
+ if (client->connected()) {
+#else
+ if (NetConnected) {
+#endif
+ pqPacketSend('X', NULL, 0);
+#ifndef ESP32_IDF
+ client->stop();
+#else
+ shutdown(SockH, 0);
+ close_socket(SockH);
+#endif
+ }
+ if (Buffer && !(_flags & PG_FLAG_STATIC_BUFFER)) {
+ free(Buffer);
+ Buffer = NULL;
+ }
+ if (_user) {
+ free(_user);
+ _user = _passwd = NULL;
+ }
+ conn_status = CONNECTION_NEEDED;
+
+#ifndef ESP32_IDF
+ NetConnected = 0;
+#endif
+}
+
+#ifdef ESP32_IDF
+/**
+ * PGconnection dataAvailable.
+ *
+ * @returns number of Bytes available
+ */
+int PGconnection::dataAvailable() {
+ int res=0;
+// if (_available) return _available;
+ ioctl(SockH,FIONREAD,&res);
+ return res;
+}
+#endif
+
+/**
+ * PGconnection dataAvailable.
+ *
+ * @returns the current status of the connection
+ */
+
+int PGconnection::status(void)
+{
+ char bereq;
+ char rc;
+ int32_t msgLen;
+ int32_t areq;
+ char * pwd = _passwd;
+#ifdef PG_USE_MD5
+ char salt[4];
+#endif
+
+ switch(conn_status) {
+ case CONNECTION_NEEDED:
+ case CONNECTION_OK:
+ case CONNECTION_BAD:
+
+ return conn_status;
+
+ case CONNECTION_AWAITING_RESPONSE:
+#ifndef ESP32_IDF
+ if (!client->available()) return conn_status;
+#else
+ if (dataAvailable() == 0) return conn_status;
+#endif
+ if (attempts++ >= 2) {
+ setMsg_P(EM_SYNC, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ if (pqGetc(&bereq)) {
+ goto read_error;
+ }
+ if (bereq == 'E') {
+ pqGetInt4(&msgLen);
+ pqGetNotice(PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ if (bereq != 'R') {
+ setMsg_P(EM_SYNC, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ if (pqGetInt4(&msgLen)) {
+ goto read_error;
+ }
+ if (pqGetInt4(&areq)) {
+ goto read_error;
+ }
+ if (areq == AUTH_REQ_OK) {
+ if (_user) {
+ free(_user);
+ _user = _passwd=NULL;
+ }
+ result_status = PG_RSTAT_READY;
+ return conn_status = CONNECTION_AUTH_OK;
+ }
+ if (
+#ifdef PG_USE_MD5
+ areq != AUTH_REQ_MD5 &&
+#endif
+ areq != AUTH_REQ_PASSWORD) {
+ setMsg_P(EM_UAUTH, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ if (!_passwd || !*_passwd) {
+ setMsg_P(EM_PASSWD, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ pwd = _passwd;
+#ifdef PG_USE_MD5
+ if (areq == AUTH_REQ_MD5) {
+ if (pqGetnchar(salt, 4)) goto read_error;
+ if (bufSize < 3 * MD5_PASSWD_LEN + 10) {
+ setMsg_P(EM_OOM, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+ char *crypt_pwd = Buffer + (bufSize - (2 * (MD5_PASSWD_LEN + 1)));
+ char *crypt_pwd2 = crypt_pwd + MD5_PASSWD_LEN + 1;
+ pg_md5_encrypt(pwd, _user, strlen(_user), crypt_pwd2);
+ pg_md5_encrypt(crypt_pwd2 + 3, salt,4, crypt_pwd);
+ pwd = crypt_pwd;
+ }
+#endif
+ rc=pqPacketSend('p', pwd, strlen(pwd) + 1);
+ if (rc) {
+ goto write_error;
+ }
+ return conn_status;
+
+ case CONNECTION_AUTH_OK:
+ for (;;) {
+#ifndef ESP32_IDF
+ if (!client -> available()) return conn_status;
+#else
+ if (dataAvailable() == 0) return conn_status;
+#endif
+ if (pqGetc(&bereq)) goto read_error;
+ if (pqGetInt4(&msgLen)) goto read_error;
+ msgLen -= 4;
+ if (bereq == 'A' || bereq == 'N' || bereq == 'S' || bereq == 'K') {
+ if (pqSkipnchar(msgLen)) goto read_error;
+ continue;
+ }
+ if (bereq == 'E') {
+ pqGetNotice(PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+
+/* if (bereq == 'K') {
+ if (pqGetInt4(&be_pid)) goto read_error;
+ if (pqGetInt4(&be_key)) goto read_error;
+ continue;
+ }
+*/
+ if (bereq == 'Z') {
+ pqSkipnchar(msgLen);
+ return conn_status = CONNECTION_OK;
+ }
+ return conn_status = CONNECTION_BAD;
+ }
+
+ default:
+ setMsg_P(EM_INTR, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+ }
+read_error:
+ setMsg_P(EM_READ, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+write_error:
+ setMsg_P(EM_WRITE, PG_RSTAT_HAVE_ERROR);
+ return conn_status = CONNECTION_BAD;
+}
+
+/**
+ * PGconnection execute.
+ *
+ * @param query the SQL command.
+ * @param progmen inicates the usage of progmem on Arduino, not used on ESP IDF
+ * @returns 0 if ok, otherwise -1
+ */
+
+int PGconnection::execute(const char *query, int progmem)
+{
+#ifndef ESP32
+// for unknown reason, this status check get wrong on ESP32-IDF.
+// uncommenting solve the problem for now, but need invesitgation
+ if (!(result_status & PG_RSTAT_READY)) {
+ setMsg_P(EM_EXEC, PG_RSTAT_HAVE_ERROR);
+ return -1;
+ }
+#endif
+ int len =
+#ifndef ESP32
+ progmem ? strlen_P(query) :
+#endif
+ strlen(query);
+
+#ifndef ESP32_IDF
+ if (pqPacketSend('Q', query, len+1, progmem)) {
+#else
+ if (pqPacketSend('Q', query, len + 1)) {
+#endif
+ setMsg_P(EM_WRITE, PG_RSTAT_HAVE_ERROR);
+ conn_status = CONNECTION_BAD;
+ return -1;
+ }
+ result_status = PG_RSTAT_COMMAND_SENT;
+ return 0;
+
+}
+/*
+int PGconnection::PGexecute(const char *query) {
+ int len = strlen(query);
+ if (pqPacketSend('Q', query, len + 1)) {
+ setMsg_P(EM_WRITE, PG_RSTAT_HAVE_ERROR);
+ conn_status = CONNECTION_BAD;
+ return -1;
+ }
+ result_status = PG_RSTAT_COMMAND_SENT;
+ return 0;
+}
+*/
+
+/**
+ * PGconnection escapeName.
+ *
+ * @param inbuf the SQL command before names are escaped.
+ * @param outbuf the SQL command after names are escaped.
+ * @returns the lenght of the outbuf result
+ */
+
+int PGconnection::escapeName(const char *inbuf, char *outbuf)
+{
+ const char *c;
+ int l = 2;
+ for (c=inbuf; *c; c++) {
+ l++;
+ if (*c == '\\' || *c == '"') l++;
+ }
+ if (outbuf) {
+ *outbuf++='"';
+ for (c=inbuf; *c; c++) {
+ *outbuf++ = *c;
+ if (*c == '\\' || *c == '"') *outbuf++ = *c;
+ }
+ *outbuf++='"';
+ }
+ return l;
+}
+
+/**
+ * PGconnection escapeString.
+ *
+ * @param inbuf the SQL command before names are escaped.
+ * @param outbuf the SQL command after names are escaped.
+ * @returns the lenght of the outbuf result
+ */
+
+int PGconnection::escapeString(const char *inbuf, char *outbuf)
+{
+ const char *c;
+ int e = 0, l;
+ for (c=inbuf; *c; c++) {
+ if (*c == '\\' || *c == '\'') e++;
+ }
+ l = e + (c - inbuf) + (e ? 4 : 2);
+ if (outbuf) {
+ if (e) {
+ *outbuf++=' ';
+ *outbuf++='E';
+ }
+ *outbuf++='\'';
+ for (c=inbuf; *c; c++) {
+ *outbuf++ = *c;
+ if (*c == '\\' || *c == '\'') *outbuf++ = *c;
+ }
+ *outbuf++='\'';
+ }
+ return l;
+}
+
+/**
+ * PGconnection getValue.
+ *
+ * @param nr number of the row.
+ * @returns the value as char pointer.
+ */
+
+char * PGconnection::getValue(int nr)
+{
+ int i;
+ if (_null & (1<<nr)) return NULL;
+ char *c=Buffer;
+ if (nr < 0 || nr >= _nfields) return NULL;
+ for (i=0; i < nr; i++) {
+ if (_null & (1 <<i)) continue;
+ c += strlen(c) + 1;
+ }
+ return c;
+}
+
+/**
+ * PGconnection getColumn.
+ *
+ * @param n the column.
+ * @returns the char pointer to the column.
+ */
+char *PGconnection::getColumn(int n)
+{
+ char *c;int i;
+ if (!(result_status & PG_RSTAT_HAVE_COLUMNS)) return NULL;
+ if (n < 0 || n >= _nfields) return NULL;
+ for (c = Buffer, i = 0; i<n; i++) {
+ c += strlen(c) + 1;
+ }
+ return c;
+}
+
+/**
+ * PGconnection getMessage.
+ *
+ * @returns the last message, if any.
+ */
+
+char *PGconnection::getMessage(void)
+{
+ if (!(result_status & PG_RSTAT_HAVE_MESSAGE)) return NULL;
+ return Buffer;
+}
+
+/**
+ * PGconnection getData.
+ *
+ * @returns the availability status of data
+ */
+
+int PGconnection::getData(void)
+{
+ char id;
+ int32_t msgLen;
+ int rc;
+ char *c;
+#ifndef ESP32_IDF
+ if (!client -> available()) return 0;
+#else
+ if (dataAvailable() == 0) return 0;
+#endif
+
+
+ if (pqGetc(&id)) goto read_error;
+ if (pqGetInt4(&msgLen)) goto read_error;
+ //Serial.printf("ID=%c\n", id);
+ msgLen -= 4;
+ switch(id) {
+ case 'T':
+ if ((rc=pqGetRowDescriptions())) {
+ if (rc == -2) setMsg_P(EM_OOM, PG_RSTAT_HAVE_ERROR);
+ else if (rc == -3) setMsg_P(EM_BIN, PG_RSTAT_HAVE_ERROR);
+ goto read_error;
+ }
+ if (_flags & PG_FLAG_IGNORE_COLUMNS) {
+ result_status &= ~PG_RSTAT_HAVE_MASK;
+ return 0;
+ }
+ return result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | PG_RSTAT_HAVE_COLUMNS;
+
+ case 'E':
+ if (pqGetNotice(PG_RSTAT_HAVE_ERROR)) goto read_error;
+ return result_status;
+
+ case 'N':
+ if (_flags & PG_FLAG_IGNORE_NOTICES) {
+ if (pqSkipnchar(msgLen)) goto read_error;
+ return 0;
+ }
+ if(pqGetNotice(PG_RSTAT_HAVE_NOTICE)) goto read_error;
+ return result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | PG_RSTAT_HAVE_NOTICE;
+
+ case 'A':
+ if (_flags & PG_FLAG_IGNORE_NOTICES) {
+ if (pqSkipnchar(msgLen)) goto read_error;
+ return 0;
+ }
+ if (pqGetNotify(msgLen)) goto read_error;
+ return result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | PG_RSTAT_HAVE_NOTICE;
+
+ case 'Z':
+ if (pqSkipnchar(msgLen)) goto read_error;
+ result_status = (result_status & PG_RSTAT_HAVE_SUMMARY) | PG_RSTAT_READY;
+ return PG_RSTAT_READY;
+
+ case 'S': // parameters setting ignored
+ case 'K': // should not be here?
+ if (pqSkipnchar(msgLen)) goto read_error;
+ return 0;
+
+ case 'C': // summary
+ if (msgLen > bufSize - 1) goto oom;
+ if (pqGetnchar(Buffer, msgLen)) goto read_error;
+ Buffer[msgLen] = 0;
+ _ntuples = 0;
+ result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | PG_RSTAT_HAVE_SUMMARY;
+ for (c = Buffer; *c && !isdigit(*c); c++);
+ if (!*c) return result_status;
+ if (strncmp(Buffer,"SELECT ",7)) {
+ for (; *c && isdigit(*c); c++);
+ for (; *c && !isdigit(*c); c++);
+ }
+ if (*c) _ntuples = strtol(c, NULL, 10);
+ return result_status;
+
+ case 'D':
+ if ((rc=pqGetRow())) {
+ if (rc == -2) setMsg_P(EM_OOM, PG_RSTAT_HAVE_ERROR);
+ else if (rc == -3) setMsg_P(EM_SYNC, PG_RSTAT_HAVE_ERROR);
+ goto read_error;
+ }
+ if (_flags & PG_FLAG_IGNORE_COLUMNS) {
+ result_status &= ~PG_RSTAT_HAVE_MASK;
+ return 0;
+ }
+ return result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | PG_RSTAT_HAVE_ROW;
+
+ case 'I':
+ if (pqSkipnchar(msgLen)) goto read_error;
+ setMsg_P(EM_EMPTY, PG_RSTAT_HAVE_ERROR);
+ return result_status;
+
+ default:
+ setMsg_P(EM_SYNC, PG_RSTAT_HAVE_ERROR);
+ conn_status = CONNECTION_BAD;
+ return -1;
+ }
+
+oom:
+ setMsg_P(EM_OOM, PG_RSTAT_HAVE_ERROR);
+
+read_error:
+ if (!(result_status & PG_RSTAT_HAVE_ERROR)) {
+ setMsg_P(EM_READ, PG_RSTAT_HAVE_ERROR);
+ }
+ conn_status = CONNECTION_BAD;
+ return -1;
+}
+
+/**
+ * PGconnection executeFormat.
+ *
+ * @param progmem the SQL command.
+ * @param format the format string.
+ * @returns 0 on sucess, otherwise -1.
+ */
+
+int PGconnection::executeFormat(int progmem, const char *format, ...)
+{
+ int32_t msgLen;
+ va_list va;
+ va_start(va, format);
+ msgLen = writeFormattedQuery(0, progmem, format, va);
+ va_end(va);
+ if (msgLen < 0) return -1;
+ va_start(va, format);
+ msgLen = writeFormattedQuery(msgLen, progmem, format, va);
+ va_end(va);
+ if (msgLen) {
+ return -1;
+ }
+ result_status = PG_RSTAT_COMMAND_SENT;
+ return 0;
+}
+
+#ifdef ESP8266
+
+// there is no strchr_P in ESP8266 ROM :(
+
+static const char *strchr_P(const char *str, char c)
+{
+ char z;
+ for (;;) {
+ z = pgm_read_byte(str);
+ if (!z) return NULL;
+ if (z == c) return str;
+ str++;
+ }
+}
+
+#endif
+
+#ifdef ESP32_IDF
+//emulate Arduino PSTR()
+
+/**
+ * PSTR.
+ *
+ * @param str input string.
+ * @returns the result string.
+ */
+
+char *PSTR(char *str)
+{
+ return str;
+}
+const char *PSTR(const char *str)
+{
+ return str;
+}
+
+//emulate strcpy_P()
+/**
+ * strcpy_P(). for compatibility with the Arduino version on ESP IDF
+ *
+ * @param destination buffer.
+ * @param source buffer.
+ * @returns number of bytes copied
+ */
+char *strcpy_P(char * destination, const char * source )
+{
+ return strcpy(destination, source);
+}
+
+int strlen_P(char *str)
+{
+ return strlen(str);
+}
+int strlen_P(const char *str)
+{
+ return strlen(str);
+}
+#endif
+
+/**
+ * PGconnection build_startup_packet.
+ *
+ * @param packet buffer for the packet.
+ * @param db name of the database.
+ * @param charset name of the character set
+ * @returns the lenght of the packet
+ */
+
+int PGconnection::build_startup_packet(
+ char *packet,
+ const char *db,
+ const char *charset)
+{
+ int packet_len = 4;
+ if (packet) {
+ memcpy(packet,"\0\003\0\0", 4);
+ }
+#define ADD_STARTUP_OPTION(optname, optval) \
+ do { \
+ if (packet) \
+ strcpy_P(packet + packet_len, (char *)optname); \
+ packet_len += strlen_P((char *)optname) + 1; \
+ if (packet) \
+ strcpy(packet + packet_len, (char *)optval); \
+ packet_len += strlen((char *)optval) + 1; \
+ } while(0)
+
+#define ADD_STARTUP_OPTION_P(optname, optval) \
+ do { \
+ if (packet) \
+ strcpy_P(packet + packet_len, (char *)optname); \
+ packet_len += strlen_P((char *)optname) + 1; \
+ if (packet) \
+ strcpy_P(packet + packet_len, (char *)optval); \
+ packet_len += strlen_P((char *)optval) + 1; \
+ } while(0)
+
+ if (_user && _user[0])
+ ADD_STARTUP_OPTION(PSTR("user"), _user);
+ if (db && db[0])
+ ADD_STARTUP_OPTION(PSTR("database"), db);
+ if (charset && charset[0])
+ ADD_STARTUP_OPTION(PSTR("client_encoding"), charset);
+ ADD_STARTUP_OPTION_P(PSTR("application_name"), PSTR("arduino"));
+#undef ADD_STARTUP_OPTION
+ if (packet)
+ packet[packet_len] = '\0';
+ packet_len++;
+
+ return packet_len;
+}
+
+/**
+ * PGconnection pqPacketSend.
+ *
+ * @param pack_type type of the packet.
+ * @param buf the result buffer.
+ * @param buf_len length of the result buffer
+ * @progmem to be used on Arduino
+ * @returns 0 if success, network error code otherwise
+ */
+
+int PGconnection::pqPacketSend(char pack_type, const char *buf, int buf_len, int progmem)
+{
+ char *start = Buffer;
+ int l = bufSize - 4;
+#ifndef ESP32
+ int n;
+#endif
+ if (pack_type) {
+ *start++ = pack_type;
+ l--;
+ }
+#ifdef __AVR__
+ *start++=0;
+ *start++=0;
+#else
+ *start++ = ((buf_len + 4) >> 24) & 0xff;
+ *start++ = ((buf_len + 4) >> 16) & 0xff;
+#endif
+ *start++ = ((buf_len + 4) >> 8) & 0xff;
+ *start++ = (buf_len + 4) & 0xff;
+#ifndef ESP32
+ if (progmem) {
+ while (buf_len > 0) {
+ while (buf_len > 0 && l > 0) {
+ *start++ = pgm_read_byte(buf++);
+ buf_len--;
+ }
+ n = client->write((const uint8_t *)Buffer, start - Buffer);
+ if (n != start - Buffer) return -1;
+ start = Buffer;
+ l = bufSize;
+ }
+ }
+ else {
+#endif
+ if (buf) {
+ if (buf_len <= l) {
+ memcpy(start, buf, buf_len);
+ start += buf_len;
+ buf_len = 0;
+ }
+ else {
+ memcpy(start, buf, l);
+ start += l;
+ buf_len -= l;
+ buf += l;
+ }
+ }
+#ifndef ESP32_IDF
+ n = client->write((const uint8_t *)Buffer, start - Buffer);
+ if (n != start - Buffer) return -1;
+ if (buf && buf_len) {
+ n = client->write((const uint8_t *)buf, buf_len);
+ if (n != buf_len) return -1;
+ }
+#else
+ int err = send(SockH, /*_buffer*/Buffer, start - /*_buffer*/Buffer, 0);
+ if (err < 0) {
+ ESP_LOGE(PGTAG, "pqPacketSend: Send Error occurred during sending: errno %d", errno);
+ return err;
+ }
+ if (buf && buf_len) {
+ err = send(SockH, (const char *) buf, (size_t) buf_len, 0);
+ if (err < 0) {
+ ESP_LOGE(PGTAG, "Send2 Error occurred during sending: errno %d", errno);
+ return err;
+
+ }
+ }
+#endif
+
+#ifndef ESP32
+ }
+#endif
+ return 0;
+}
+
+/**
+ * PGconnection pqGetc.
+ *
+ * @param buf buffer to store received char.
+ * @returns length of received data
+ */
+
+int PGconnection::pqGetc(char *buf)
+{
+ int i;
+#ifndef ESP32_IDF
+ for (i=0; !client->available() && i < 10; i++) {
+ delay (i * 10 + 10);
+ }
+ if (!client->available()) {
+ return -1;
+ }
+ *buf = client->read();
+ return 0;
+#else
+ i = 0;
+ while (i<10) {
+ if (dataAvailable()>0) break;
+ else {
+ vTaskDelay(i++);
+ }
+ }
+ if (i==10) return -1;
+
+ int len = read(SockH, (void *) buf, 1);
+ _available-=len;
+ return -1+len;
+#endif
+}
+
+/**
+ * PGconnection pqGetInt4.
+ *
+ * @param result the converted result to int4.
+ * @returns 0 for sucess, otherwise -1.
+ */
+
+int PGconnection::pqGetInt4(int32_t *result)
+{
+ uint32_t tmp4 = 0;
+ byte tmp,i;
+ for (i = 0; i < 4; i++) {
+ if (pqGetc((char *)&tmp)) return -1;
+ tmp4 = (tmp4 << 8) | tmp;
+ }
+ *result = tmp4;
+ return 0;
+}
+
+/**
+ * PGconnection pqGetInt2.
+ *
+ * @param result the converted result to int2.
+ * @returns 0 for sucess, otherwise -1.
+ */
+
+int PGconnection::pqGetInt2(int16_t *result)
+{
+ uint16_t tmp2 = 0;
+ byte tmp,i;
+ for (i = 0; i < 2; i++) {
+ if (pqGetc((char *)&tmp)) return -1;
+ tmp2 = (tmp2 << 8) | tmp;
+ }
+ *result = tmp2;
+ return 0;
+}
+
+/**
+ * PGconnection pqGetnchar.
+ *
+ * @param s the string to search in
+ * @param len the lenght of the string
+ * @returns 0 for sucess, otherwise -1.
+ */
+
+int PGconnection::pqGetnchar(char *s, int len)
+{
+ while (len-- > 0) {
+ if (pqGetc(s++)) return -1;
+ }
+ return 0;
+}
+
+/**
+ * PGconnection pqGets.
+ *
+ * @param s the string to search in
+ * @param maxlen the lenght of the string
+ * @returns the position in the string, or -1 for an error
+ */
+
+int PGconnection::pqGets(char *s, int maxlen)
+{
+ int len;
+ char z;
+ for (len = 0;len < maxlen; len++) {
+ if (pqGetc(&z)) return -1;
+ if (s) *s++ = z;
+ if (!z) return len+1;
+ }
+ return - (len + 1);
+}
+
+/**
+ * PGconnection pqSkipnchar.
+ *
+ * @param len the lenght of the string
+ * @returns 0 for sucess, or -1 for an error
+ */
+
+int PGconnection::pqSkipnchar(int len)
+{
+ char dummy;
+ while (len-- > 0) {
+ if (pqGetc(&dummy)) return -1;
+ }
+ return 0;
+}
+
+/**
+ * PGconnection pqGetRow.
+ *
+ * @returns 0 for sucess, or -1 for an error
+ */
+
+int PGconnection::pqGetRow(void)
+{
+ int i;
+ int bufpos = 0;
+ int32_t len;
+ int16_t cols;
+
+ _null = 0;
+ if (pqGetInt2(&cols)) return -1;
+ if (cols != _nfields) {
+ return -3;
+ }
+ for (i=0; i < _nfields; i++) {
+ if (pqGetInt4(&len)) return -1;
+ if (len < 0) {
+ _null |= 1<<i;
+ continue;
+ }
+ if (bufpos + len + 1 > bufSize) {
+ return -2;
+ }
+ if (pqGetnchar(Buffer + bufpos, len)) return -1;
+ bufpos += len;
+ Buffer[bufpos++]=0;
+ }
+ return 0;
+}
+
+/**
+ * PGconnection pqGetRowDescriptions.
+ *
+ * @returns the row description, or -1 for an error
+ */
+
+int PGconnection::pqGetRowDescriptions(void)
+{
+ int i;
+ int16_t format;
+ int rc;
+ int bufpos;
+ if (pqGetInt2(&_nfields)) return -1;
+ if (_nfields > PG_MAX_FIELDS) return -2; // implementation limit
+ _formats = 0;
+ bufpos = 0;
+ for (i = 0;i < _nfields; i++) {
+ if (!(_flags & PG_FLAG_IGNORE_COLUMNS)) {
+ if (bufpos >= bufSize - 1) return -2;
+ rc = pqGets(Buffer + bufpos, bufSize - bufpos);
+ if (rc < 0) return -1;
+ bufpos += rc;
+ }
+ else {
+ if (pqGets(NULL, 8192) < 0) {
+ return -1;
+ }
+ }
+ if (pqSkipnchar(16)) return -1;
+ if (pqGetInt2(&format)) return -1;
+ format = format ? 1 : 0;
+ _formats |= format << i;
+ }
+ if (_formats) return -3;
+ return 0;
+}
+
+/**
+ * PGconnection setMsg.
+ *
+ * @param s the message
+ * @param len the lenght of the message
+ */
+void PGconnection::setMsg(const char *s, int type)
+{
+ strcpy(Buffer, s);
+ result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | type;
+}
+
+/**
+ * PGconnection setMsg_P.
+ *
+ * @param s the message
+ * @param len the lenght of the message
+ */
+void PGconnection::setMsg_P(const char *s, int type)
+{
+ strcpy_P(Buffer, s);
+ result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | type;
+}
+
+/**
+ * PGconnection pqGetNotice.
+ *
+ * @param type the notice type
+ * @returns 0 on success, or -1 for an error
+ */
+int PGconnection::pqGetNotice(int type)
+{
+ int bufpos = 0;
+ char id;
+ int rc;
+ for (;;) {
+ if (pqGetc(&id)) goto read_error;
+ if (!id) break;
+ if (id == 'S' || id == 'M') {
+ if (bufpos && bufpos < bufSize - 1) Buffer[bufpos++]=':';
+ rc = pqGets(Buffer + bufpos, bufSize - bufpos);
+ if (rc < 0) goto read_error;
+ bufpos += rc -1;
+ }
+ else {
+ rc = pqGets(NULL, 8192);
+ if (rc < 0) goto read_error;
+ }
+ }
+ Buffer[bufpos] = 0;
+ result_status = (result_status & ~PG_RSTAT_HAVE_MASK) | type;
+ return 0;
+
+read_error:
+ if (!bufpos) setMsg_P(EM_READ, PG_RSTAT_HAVE_ERROR);
+ return -1;
+}
+
+/**
+/* PGconnection pqGetNotify.
+ *
+ * @param msgLen the length of the message
+ * @returns 0 on success, or -1 for an error
+ */
+int PGconnection::pqGetNotify(int32_t msgLen)
+{
+ int32_t pid;
+ int bufpos, i;
+ if (pqGetInt4(&pid)) return -1;
+ msgLen -= 4;
+ bufpos = sprintf(Buffer,"%d:",pid);
+ if (msgLen > bufSize - (bufpos + 1)) {
+ if (pqGetnchar(Buffer+bufpos, bufSize - (bufpos + 1)))
+ return -1;
+ msgLen -= bufSize - (bufpos + 1);
+ if (pqSkipnchar(msgLen)) return -1;
+ Buffer[msgLen = bufSize - 1] = 0;
+
+ }
+ else {
+ if (pqGetnchar(Buffer+ bufpos, msgLen)) return -1;
+ Buffer[bufpos + msgLen] = 0;
+ msgLen += bufpos;
+ }
+ for (i=0; i<msgLen; i++) if (!Buffer[i]) Buffer[i] = ':';
+ return 0;
+}
+
+#ifndef ESP32
+int PGconnection::writeMsgPart_P(const char *s, int len, int fine)
+{
+ while (len > 0) {
+ if (bufPos >= bufSize) {
+ if (client->write((uint8_t *)Buffer, bufPos) != (size_t)bufPos) {
+ return -1;
+ }
+ bufPos = 0;
+ }
+ Buffer[bufPos++] = pgm_read_byte(s++);
+ len--;
+ }
+ if (bufPos && fine) {
+ if (client->write((uint8_t *)Buffer, bufPos) != (size_t)bufPos) {
+ return -1;
+ }
+ bufPos = 0;
+ }
+ return 0;
+}
+#endif
+
+/**
+/* PGconnection writeMsgPart.
+ *
+ * @param s message string
+ * @param len the length of the message
+ * @param fine write end
+ * @returns 0 on success, or -1 for an error
+ */
+int PGconnection::writeMsgPart(const char *s, int len, int fine)
+{
+ while (len > 0) {
+ int n = len;
+ if (n > bufSize - bufPos) n = bufSize - bufPos;
+ memcpy(Buffer + bufPos, s, n);
+ bufPos += n;
+ s += n;
+ len -= n;
+ if (bufPos >= bufSize) {
+#ifndef ESP32_IDF
+ if (client->write((uint8_t *)Buffer, bufPos) != (size_t)bufPos) {
+ return -1;
+ }
+#else
+ int err = send(SockH, /*_buffer*/Buffer, bufPos, 0);
+ if (err < 0)
+ return -1;
+#endif
+
+ bufPos = 0;
+ }
+ }
+ if (bufPos && fine) {
+#ifndef ESP32_IDF
+ if (client->write((uint8_t *)Buffer, bufPos) != (size_t)bufPos) {
+ return -1;
+ }
+#else
+ int err = send(SockH, /*_buffer*/Buffer, bufPos, 0);
+ if (err < 0)
+ return -1;
+#endif
+ bufPos = 0;
+ }
+
+ return 0;
+}
+
+/**
+/* PGconnection writeFormattedQuery.
+ *
+ * @param length the length of the message
+ * @param progmem the command
+ * @param format format string
+ * @param va parameters
+ * @returns 0 on success, or -1 for an error
+ */
+int32_t PGconnection::writeFormattedQuery(int32_t length, int progmem, const char *format, va_list va)
+{
+ int32_t msgLen = 0;
+ const char *percent;
+ int blen, rc;
+ char buf[32], znak;
+#ifdef ESP32
+ (void) progmem;
+#endif
+ if (length) {
+ length += 4;
+ bufPos = 0;
+ Buffer[bufPos++] = 'Q';
+ Buffer[bufPos++] = (length >> 24) & 0xff;
+ Buffer[bufPos++] = (length >> 16) & 0xff;
+ Buffer[bufPos++] = (length >> 8) & 0xff;
+ Buffer[bufPos++] = (length) & 0xff;
+ }
+ for (;;) {
+#ifndef ESP32
+ if (progmem) {
+ percent = strchr_P(format, '%');
+ }
+ else {
+#endif
+ percent = strchr(format, '%');
+#ifndef ESP32
+ }
+#endif
+ if (!percent) break;
+#ifndef ESP32
+ if (progmem) {
+ znak = pgm_read_byte(percent+1);
+ }
+ else {
+#endif
+ znak = percent[1];
+#ifndef ESP32
+ }
+#endif
+ if (!length) {
+ msgLen += (percent - format);
+ }
+ else {
+#ifndef ESP32
+ if (progmem) {
+ rc = writeMsgPart_P(format, percent - format, false);
+ }
+ else {
+#endif
+ rc = writeMsgPart(format, percent - format, false);
+#ifndef ESP32
+ }
+#endif
+ if (rc) goto write_error;
+ }
+ format = percent + 2;
+ if (znak == 's' || znak == 'n') {
+ char *str = va_arg(va, char *);
+ blen = (znak == 's') ? escapeString(str, NULL) : escapeName(str, NULL);
+ if (!length) {
+ msgLen += blen;
+ }
+ else {
+ if (bufPos + blen > bufSize) {
+ rc = writeMsgPart(NULL, 0, true);
+ if (rc) goto write_error;
+ }
+ }
+ if (znak == 's') {
+ escapeString(str, Buffer + bufPos);
+ }
+ else {
+ escapeName(str, Buffer + bufPos);
+ }
+ bufPos += blen;
+ continue;
+ }
+ if (znak == 'l' || znak == 'd') {
+ if (znak == 'l') {
+ long n = va_arg(va, long);
+ blen = snprintf(buf, 32, "'%ld'", n);
+ }
+ else {
+ int n = va_arg(va, int);
+ blen = snprintf(buf, 32, "'%d'", n);
+ }
+ if (length) {
+ rc = writeMsgPart(buf, blen, false);
+ if (rc) goto write_error;
+ }
+ else {
+ msgLen += blen;
+ }
+ }
+ setMsg_P(EM_FORMAT, PG_RSTAT_HAVE_ERROR);
+ return -1;
+ }
+#ifndef ESP32
+ if (progmem) {
+ blen = strlen_P(format);
+ }
+ else {
+#endif
+ blen = strlen(format);
+#ifndef ESP32
+ }
+#endif
+ if (length) {
+#ifndef ESP32
+ if (progmem) {
+ rc = writeMsgPart_P(format, blen, false);
+ }
+ else {
+#endif
+ rc = writeMsgPart(format, blen, false);
+#ifndef ESP32
+ }
+#endif
+ if (!rc) {
+ rc = writeMsgPart("\0",1,true);
+ }
+ if (rc) goto write_error;
+ }
+ else {
+ msgLen += blen + 1;
+ }
+ return msgLen;
+write_error:
+ setMsg_P(EM_WRITE, PG_RSTAT_HAVE_ERROR);
+ conn_status = CONNECTION_BAD;
+ return -1;
+}
diff --git a/software/libs/libpq_esp32.h b/software/libs/libpq_esp32.h
new file mode 100644
index 0000000..914b1b3
--- /dev/null
+++ b/software/libs/libpq_esp32.h
@@ -0,0 +1,270 @@
+/*
+ * libpq_esp32.h
+ *
+ * Created on: 26.02.2022
+ * Author: michi
+ * SPDX-FileCopyrightText: 2022 MDC Service <info@mdc-service.de>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ * Ported from SimplePgSQL (https://github.com/ethanak/SimplePgSQL) to ESP IDF
+ * original SimplePgSQL: * Copyright (C) Bohdan R. Rau 2016 <ethanak@polip.com>
+ */
+
+
+#ifndef _SIMPLEPGSQL
+#define _SIMPLEPGSQL 1
+
+//Michi begin
+#define ESP32
+#define ESP32_IDF
+//Michi end
+
+#ifdef __AVR__
+// You need MD5 library from https://github.com/tzikis/ArduinoMD5
+// for Arduino boards. Uncomment only if you have this library and
+// you must use md5 passwords.
+// Do not use it on 32 kB ATMega processors!
+
+// #define PG_USE_MD5 1
+
+#else
+// ESP8266 has MD5 code in ROM so there is no need to comment
+#define PG_USE_MD5 1
+#endif
+
+
+
+
+#ifndef ESP32_IDF
+ #include <Arduino.h>
+ #include <Client.h>
+#else
+ #include "esp_system.h"
+ #include "esp_netif.h"
+ #include "lwip/err.h"
+ #include "lwip/sockets.h"
+
+ #define byte uint8_t
+#endif
+
+typedef enum
+{
+ CONNECTION_OK,
+ CONNECTION_BAD,
+ CONNECTION_NEEDED, /* setDbLogin() needed */
+ /* Internal states here */
+ CONNECTION_AWAITING_RESPONSE, /* Waiting for a response from the
+ * postmaster. */
+ CONNECTION_AUTH_OK /* Received authentication; waiting for
+ * backend startup. */
+} ConnStatusType;
+
+#ifdef ESP8266
+#define PG_BUFFER_SIZE 2048
+#elif defined(ESP32)
+#define PG_BUFFER_SIZE 16384
+#else
+#define PG_BUFFER_SIZE 256
+#endif
+
+// maximum number of fields in backend response
+// must not exceed number of bits in _formats and _null
+#ifdef ESP32
+#define PG_MAX_FIELDS 64
+#else
+#define PG_MAX_FIELDS 32
+#endif
+// ignore notices and notifications
+#define PG_FLAG_IGNORE_NOTICES 1
+// do not store column names
+#define PG_FLAG_IGNORE_COLUMNS 2
+// never set this flag manually!
+# define PG_FLAG_STATIC_BUFFER 4
+
+// ready for next query
+#define PG_RSTAT_READY 1
+// command sent
+#define PG_RSTAT_COMMAND_SENT 2
+// column names in buffer
+#define PG_RSTAT_HAVE_COLUMNS 4
+// row values in buffer
+#define PG_RSTAT_HAVE_ROW 8
+// summary (number of tuples/affected rows) received
+#define PG_RSTAT_HAVE_SUMMARY 16
+// error message in buffer
+#define PG_RSTAT_HAVE_ERROR 32
+// notice/notification in buffer
+#define PG_RSTAT_HAVE_NOTICE 64
+
+#define PG_RSTAT_HAVE_MASK (PG_RSTAT_HAVE_COLUMNS | \
+ PG_RSTAT_HAVE_ROW | \
+ PG_RSTAT_HAVE_SUMMARY | \
+ PG_RSTAT_HAVE_ERROR | \
+ PG_RSTAT_HAVE_NOTICE)
+
+#define PG_RSTAT_HAVE_MESSAGE (PG_RSTAT_HAVE_ERROR | PG_RSTAT_HAVE_NOTICE)
+
+// Framework abstraction - Michi
+// only here, differences of Arduino, ESP32-Arduino, ESP32-IDF or Platform.io should be made
+//class fw_function {
+// public:
+// send_network_packet();
+//}
+
+
+class PGconnection {
+ public:
+#ifndef ESP32_IDF
+ PGconnection(Client *c, int flags = 0, int memory = 0, char *foreignBuffer = NULL);
+#else
+ PGconnection(const int flags, const unsigned char *_Buffer, const int bufSize);
+#endif
+ /*
+ * returns connection status.
+ * passwd may be null in case of 'trust' authorization.
+ * only 'trust', 'password' and 'md5' (if compiled in)
+ * authorization modes are implemented.
+ * ssl mode is not implemented.
+ * database name defaults to user name *
+ */
+#ifndef ESP32_IDF
+ int setDbLogin(IPAddress server, const char *user, const char *passwd = NULL, const char *db = NULL, const char *charset = NULL, int port = 5432);
+#else
+ int setDbLogin(const char *ServerIP, int ServerPort, const char *dbName, const char *dbUser, const char *dbPasswd, const char *charset);
+#endif
+ /*
+ * performs authorization tasks if needed
+ * returns current connection status
+ * must be called periodically until OK, BAD or NEEDED
+ */
+ int status(void);
+ /*
+ * sends termination command if possible
+ * closes client connection and frees internal buffer
+ */
+ void close(void);
+ /*
+ * sends query to backend
+ * returns negative value on error
+ * or zero on success
+ */
+ int execute(const char *query, int progmem = 0);
+ int PGexecute(const char *query); //old version from 17.02.2022
+
+ /* should be called periodically in idle state
+ * if notifications are enabled
+ * returns:
+ * - negative value on error
+ * - zero if no interesting data arrived
+ * - current data status if some data arrived
+ */
+
+ int getData(void);
+ /*
+ * returns pointer to n-th column name in internal buffer
+ * if available or null if column number out of range
+ * will be invalidated on next getData call
+ */
+ char *getColumn(int n);
+ /*
+ * returns pointer to n-th column value in internal buffer
+ * if available or null if column number out of range
+ * or value is NULL
+ * will be invalidated on next getData call
+ */
+ char *getValue(int);
+ /*
+ * returns pointer to message (error or notice)
+ * if available or NULL
+ * will be invalidated on next getData call
+ */
+ char *getMessage(void);
+ int dataStatus(void) {
+ return result_status;
+ };
+ int nfields(void) {
+ return _nfields;
+ };
+ int ntuples(void) {
+ return _ntuples;
+ };
+ /*
+ * returns length of escaped string
+ * single quotes and E prefix (if needed)
+ * will be added.
+ */
+ int escapeString(const char *inbuf, char *outbuf);
+ /*
+ * returns length of escaped string
+ * double quotes will be added.
+ */
+ int escapeName(const char *inbuf, char *outbuf);
+ /*
+ * sends formatted query to backend
+ * returns negative value on error
+ * or zero on success
+ * Formatting sequences:
+ * %s - string literal (will be escaped with escapeString)
+ * %n - name (will be escaped with escapeName)
+ * %d - int (single quotes will be added)
+ * %l - long int (single quotes will be added)
+ * %% - % character
+ */
+ int executeFormat(int progmem, const char *format, ...);
+
+
+ private:
+#ifndef ESP32_IDF
+ Client *client;
+#endif
+ int pqPacketSend(char pack_type, const char *buf, int buf_len, int progmem = 0);
+ int pqGetc(char *);
+ int pqGetInt4(int32_t *result);
+ int pqGetInt2(int16_t *result);
+ int pqGetnchar(char *s, int len);
+ int pqSkipnchar(int len);
+ int pqGets(char *s, int maxlen);
+ int pqGetRowDescriptions(void);
+ int pqGetRow(void);
+ void setMsg(const char *, int);
+ void setMsg_P(const char *, int);
+ int pqGetNotice(int);
+ int pqGetNotify(int32_t);
+ char *_user;
+ char *_passwd;
+ char *Buffer;
+ int bufSize;
+ int bufPos;
+ int writeMsgPart(const char *s, int len, int fine);
+ int writeMsgPart_P(const char *s, int len, int fine);
+ int32_t writeFormattedQuery(int32_t length, int progmem, const char *format, va_list va);
+
+ int build_startup_packet(char *packet, const char *db, const char *charset);
+ byte conn_status;
+ byte attempts;
+/*
+ int32_t be_pid;
+ int32_t be_key;
+*/
+ int16_t _nfields;
+ int16_t _ntuples;
+#ifdef ESP32_IDF
+ uint64_t _formats;
+ uint64_t _null;
+ uint32_t _available; //michi
+ struct sockaddr_in DestAddr;
+ int SockH = -1;
+ int ipProtocol = 0;
+ int AddrFamily = 0;
+ int NetConnected=0;
+
+ int dataAvailable(void);
+#else
+ uint32_t _formats;
+ uint32_t _null;
+#endif
+ byte _binary;
+ byte _flags;
+ int result_status;
+};
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-16 05:17:02 +0000