arduino-libraries / arduinobearssl Goto Github PK

Error compiling for board Arduino/Genuino MKR1000

Linking .pio\build\teensy40\firmware.elf
c:/users/ganna/.platformio/packages/toolchain-gccarmnoneeabi/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv7e-m/fpu/fpv5-d16\libc.a(lib_a-gettimeofdayr.o): In function `_gettimeofday_r':
gettimeofdayr.c:(.text._gettimeofday_r+0x10): undefined reference to `_gettimeofday'
collect2.exe: error: ld returned 1 exit status
*** [.pio\build\teensy40\firmware.elf] Error 1

  /*
    ArduinoBearSSL SHA256
  
    This sketch demonstrates how to create a SHA256 hash and HMAC
    for an input string.
  
    This example code is in the public domain.
  */
  
  #include <HTTPClient.h>
  #include <ArduinoBearSSL.h>
  #include "SHA256.h"
  
  #ifdef ARDUINO_ARCH_MEGAAVR
  // Create the object
  SHA256Class SHA256;
  #endif
  
  void setup() {
    Serial.begin(9600);
    while (!Serial);
  
    // expect 0xE3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855
    printSHA256("");
  
    // expect 0xD7A8FBB307D7809469CA9ABCB0082E4F8D5651E46D3CDB762D02D0BF37C9E592
    printSHA256("The quick brown fox jumps over the lazy dog");
  
    // expect 0xB613679A0814D9EC772F95D778C35FC5FF1697C493715653C6C712144292C5AD
    printHMACSHA256("", "");
  
    // expect 0xF7BC83F430538424B13298E6AA6FB143EF4D59A14946175997479DBC2D1A3CD8
    printHMACSHA256("key", "The quick brown fox jumps over the lazy dog");
  }
  
  void loop() {
  }
  
  void printSHA256(const char* str) {
    Serial.print("SHA256 of '");
    Serial.print(str);
    Serial.print("' is 0x");
  
    SHA256.beginHash();
    SHA256.print(str);
    SHA256.endHash();
  
    printResult();
  }
  
  void printHMACSHA256(const char* secret, const char* str) {
    Serial.print("HMAC-SHA256 of '");
    Serial.print(str);
    Serial.print("' with secret '");
    Serial.print(secret);
    Serial.print("' is 0x");
  
    SHA256.beginHmac(secret);
    SHA256.print(str);
    SHA256.endHmac();
  
    printResult();
  }
  
  void printResult()
  {
    while (SHA256.available()) {
      byte b = SHA256.read();
  
      if (b < 16) {
        Serial.print("0");
      }
  
      Serial.print(b, HEX);
    }
    Serial.println();
  }

  In file included from d:\Onedrive - Microsoft\Documents\Arduino\libraries\ArduinoBearSSL\src/ArduinoBearSSL.h:35,
                   from C:\Users\kevinsay\AppData\Local\Temp\.arduinoIDE-unsaved2023911-24336-1vv5l1k.d1vj\SHA256\SHA256.ino:11:
  d:\Onedrive - Microsoft\Documents\Arduino\libraries\ArduinoBearSSL\src/SHA1.h:50:18: error: 'SHA1Class SHA1' redeclared as different kind of symbol
   extern SHA1Class SHA1;
                    ^~~~
  In file included from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11/tools/sdk/esp32s3/include/hal/include/hal/sha_types.h:25,
                   from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11/tools/sdk/esp32s3/include/mbedtls/port/include/sha512_alt.h:28,
                   from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11/tools/sdk/esp32s3/include/mbedtls/mbedtls/include/mbedtls/sha512.h:69,
                   from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11/tools/sdk/esp32s3/include/mbedtls/mbedtls/include/mbedtls/entropy.h:34,
                   from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11\libraries\WiFiClientSecure\src/ssl_client.h:11,
                   from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11\libraries\WiFiClientSecure\src/WiFiClientSecure.h:26,
                   from C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11\libraries\HTTPClient\src/HTTPClient.h:37,
                   from C:\Users\kevinsay\AppData\Local\Temp\.arduinoIDE-unsaved2023911-24336-1vv5l1k.d1vj\SHA256\SHA256.ino:10:
  C:\Users\kevinsay\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.11/tools/sdk/esp32s3/include/esp_rom/include/esp32s3/rom/sha.h:25:5: note: previous declaration 'SHA_TYPE SHA1'
       SHA1 = 0,
       ^~~~
  
  exit status 1
  
  Compilation error: exit status 1

20:30:59.796 -> connected with Coxinha-Sala, channel 3 
20:30:59.796 -> dhcp client start... 
20:30:59.831 -> ip:192.168.20.28,mask:255.255.255.0,gw:192.168.20.1 
20:31:00.043 -> BSSL:_connectSSL: start connection 
20:31:00.315 -> BSSL:_wait_for_handshake: failed 
20:31:00.315 -> BSSL:Couldn't connect. Error = 'Unknown error code.' 
20:31:00.315 -> numNewMessages: 0 
20:31:01.539 -> BSSL:_connectSSL: start connection 
20:31:01.810 -> BSSL:_wait_for_handshake: failed 
20:31:01.810 -> BSSL:Couldn't connect. Error = 'Unknown error code.' 
20:31:01.810 -> numNewMessages: 0 
20:31:03.039 -> BSSL:_connectSSL: start connection 
20:31:03.313 -> BSSL:_wait_for_handshake: failed 
20:31:03.313 -> BSSL:Couldn't connect. Error = 'Unknown error code.' 
20:31:03.313 -> numNewMessages: 0 
20:31:04.546 -> BSSL:_connectSSL: start connection 
20:31:04.784 -> BSSL:_wait_for_handshake: failed 
20:31:04.784 -> BSSL:Couldn't connect. Error = 'Unknown error code.' 
20:31:04.784 -> numNewMessages: 0 
20:31:05.783 -> state: 5 -> 2 (3c0) 
20:31:05.783 -> rm 0 
20:31:05.783 -> BSSL:connect: Unable to connect TCP socket 
20:31:05.783 -> numNewMessages: 0 
20:31:06.793 -> reconnect 
20:31:06.793 -> state: 2 -> 0 (0) 
20:31:06.793 -> BSSL:connect: Unable to connect TCP socket 
20:31:06.793 -> numNewMessages: 0 
20:31:06.929 -> scandone 
20:31:06.929 -> state: 0 -> 2 (b0) 20:31:06.929 -> state: 2 -> 3 (0) 
20:31:06.929 -> state: 3 -> 5 (10) 20:31:06.929 -> add 0 
20:31:06.929 -> aid 2 20:31:06.929 -> cnt 
20:31:07.794 -> BSSL:connect: Unable to connect TCP socket 
20:31:07.794 -> numNewMessages: 0 
20:31:07.827 ->

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <UniversalTelegramBot.h>

#ifndef STASSID
#define STASSID "Coxinha-Sala"
#define STAPSK "mercadolivrez"
#define BOTTOKEN "1041453184:AAH4WVWmWLyQ62btyxV5-gWqetUZB_306GY"
#endif

const char* ssid = STASSID;
const char* password = STAPSK;
const char* bot_token = BOTTOKEN;

ESP8266WebServer server(80);

const int ledPin = 2;
WiFiClientSecure client;
UniversalTelegramBot *bot;
const int Bot_mtbs = 1000; //mean time between scan messages
long Bot_lasttime; //last time messages' scan has been done

void handleRoot() {
digitalWrite(ledPin, LOW);
server.send(200, "text/plain", "hello from esp8266!");
delay(300);
digitalWrite(ledPin, HIGH);
}

void setup(void) {
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, 0);
Serial.begin(115200);

startLedSequence();

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
Serial.println("");

// Wait for connection
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());

if (MDNS.begin("esp8266")) {
Serial.println("MDNS responder started");
}

server.on("/", handleRoot);

server.on("/inline", {
server.send(200, "text/plain", "this works as well");
});

server.onNotFound(handleNotFound);

server.begin();
Serial.println("HTTP server started");

client.setInsecure();

bot = new UniversalTelegramBot(bot_token, client);

Serial.println(ESP.getFullVersion());
}

void loop(void) {
server.handleClient();
MDNS.update();

if (millis() > Bot_lasttime + Bot_mtbs) {
int numNewMessages = bot->getUpdates(bot->last_message_received + 1) + 0;
Serial.println("numNewMessages: " + (String)numNewMessages);
while (numNewMessages) {
Serial.println("Message received from: " + bot->messages[0].from_id);
// handleNewMessages(numNewMessages);
numNewMessages = bot->getUpdates(bot->last_message_received + 1);
}
Bot_lasttime = millis();
}
}

void startLedSequence() {
Serial.println("Starting...");

digitalWrite(ledPin, HIGH); // Turn the LED off by making the voltage HIGH
Serial.println("ledPin off");

Serial.println("Starting led sequence completed.");

}

void handleNewMessages(int numNewMessages) {

Serial.println("Received " + String(numNewMessages) + " new request(s)...");

}

int BearSSLClient::clientRead(void *ctx, unsigned char *buf, size_t len)
{
  static bool notAvailableFlag = false;
  static uint32_t lastNotAvailableMillis;

  Client* c = (Client*)ctx;

  if (!c->connected() && !c->available()) {

    return -1;			// connection lost or closed by peer (in ssl_io.c low_read, which points to this function, fails on a -1. which it should if a connection is lost)
  }

  int result = c->read(buf, len);
  if (result == 0) {
    if(notAvailableFlag) {
      if(millis() - lastNotAvailableMillis > c->getTimeout()) {
        notAvailableFlag = false;  // for the next round

        return -1;		// timout read (in ssl_io.c low_read, which points to this function, fails on a -1. which it should if a connection is lost or closed by peer)
      }
    } else {
      notAvailableFlag = true; // First time no data available
      lastNotAvailableMillis = millis();
    }
  
    delay(10);			// Needed?
  } else {
    notAvailableFlag = false; // This flag was set but new data is available, so start again
  }

#ifdef DEBUGSERIAL
  DEBUGSERIAL.print("BearSSLClient::clientRead - ");
  DEBUGSERIAL.print(result);
  DEBUGSERIAL.print(" - ");  
  for (size_t i = 0; i < result; i++) {
    byte b = buf[i];

    if (b < 16) {
      DEBUGSERIAL.print("0");
    }
    DEBUGSERIAL.print(b, HEX);
  }
  DEBUGSERIAL.println();
#endif

  return result;
}

int BearSSLClient::clientWrite(void *ctx, const unsigned char *buf, size_t len)
{
  static bool notAvailableForWriteFlag = false;
  static uint32_t lastNotAvailableForWriteMillis;

  Client* c = (Client*)ctx;

  if (!c->connected()) {

    return -1;			// connection lost or closed by peer (in ssl_io.c low_write, which points to this function, fails on a -1. which it should if a connection is lost)
  }

  int result = c->write(buf, len);
  if (result == 0) {

    if(notAvailableForWriteFlag) {
      if(millis() - lastNotAvailableForWriteMillis > c->getTimeout()) {
        notAvailableForWriteFlag = false;  // for the next round

        return -1;		// timout write (in ssl_io.c low_write, which points to this function, fails on a -1. which it should if a connection is lost or closed by peer)
      }
    } else {
      notAvailableForWriteFlag = true; // First time impossible to write data to peer
      lastNotAvailableForWriteMillis = millis();
    }

    delay(10);			// Needed?
  } else {
    notAvailableForWriteFlag = false; // This flag was set but new data was written, so start again
  }

#ifdef DEBUGSERIAL
  DEBUGSERIAL.print("BearSSLClient::clientWrite - ");
  DEBUGSERIAL.print(len);
  DEBUGSERIAL.print(" - ");
  for (size_t i = 0; i < len; i++) {
    byte b = buf[i];

    if (b < 16) {
      DEBUGSERIAL.print("0");
    }
    DEBUGSERIAL.print(b, HEX);
  }
  DEBUGSERIAL.println();
#endif

  return result;
}