M5StickC – Sasapea's Lab

PC向けのKlapプロトコル対応版をESP32(Arduino)へ移植してみた。ESP32で電源制御や電力モニターしたい人には役に立つかも。

TP-LINK Tapo P105/P110M のKlapプロトコル対応版 (Windows/Linux)

【対応ファームウェア】
P110M: 1.1.0 Build 231009 Rel.155719 以降
P105: 1.4.1 Build 20231103 Rel. 36519 以降

【概要】

bool Tapo2::begin(const char *deviceIp, const char *username, const char *password)

1	bool Tapo2::begin(const char deviceIp, const char username, const char *password)

開始処理を行う。戻り値は無視して良い。

void Tapo2::end(void)

1	void Tapo2::end(void)

終了処理を行う。

bool Tapo2::setDeviceOn(bool on)

1	bool Tapo2::setDeviceOn(bool on)

プラグデバイスのスイッチを制御する。on=trueならオンしon=falseならオフする。成功時はtrue、失敗時はfalseを返す。

bool Tapo2::getDeviceInfo(String &info)

1	bool Tapo2::getDeviceInfo(String &info)

デバイス情報を取得する。成功時はinfoに情報を格納しtrue、失敗時はfalseを返す。

bool Tapo2::getEnergyUsage(String &info)

1	bool Tapo2::getEnergyUsage(String &info)

プラクデバイスの電力モニター情報を取得する。成功時はinfoに情報を格納しtrue、失敗時はfalseを返す。

【ダウンロード (Arduino zip library)】
ライブラリ形式にしたのは久しぶり。かも？(-_-;)

tapo2-esp32.zip

【修正】
2024-10-08
crypt.hのrandom()の不具合を直すのを忘れていたので更新したがコンパイルエラーになってしまうので再度更新。今更だけど直さなくてもよかったのかも．．．

2024-01-13
昨日からP105を回し続けているがエラーもなく別端末からの排他制御エラー(-1012)も発生しなくなったようだ。ということは現状でＯＫということかな？ふと気になって参考にさせて頂いたplugp100で試してみたらP105の電源オンオフは出来なかった。もしかして世界初のP105のKlapプロトコル対応？．．．それはともかく昨日はお天気も良くロケットも気持ちよさそうに飛び立っていって良き日であった。(^o^)
と思っていたらいきなりP105がエラーばかり起こして何もできなくなった。TAPOアプリからの操作も出来ない。でも暫く待ってたら復旧した。普段はそう頻繁にオンオフすることはないだろうという前提であれば大丈夫なのかな．．．(-_-;)

2024-01-12
P105の挙動が怪しい。HTTPリクエストの送信処理を変更してみたところだいぶましにはなったような気もするがごくまれにP105がハングアップしてしまうことがある。P105にはタイミングバグがあるのかな？もしそうだとすると厄介だ。P110Mは一日中ぶん回しても問題ないのに．．．
P105の-1301エラーは処理遅延の警告みたいであるが頻繁に出てウザイので無視するように修正。

2024-01-11
昨日はうまく動作していたP105が今日はなぜか-1012エラーで動かない．．．orz
そういえばP105のon/off操作にはterminalUUID指定が必要なことを思い出し実装を追加してみたところうまく動作するようにはなったが端末Ａからon/off操作した後に端末Ｂからon/off操作しようとしても２分経過しないと-1012エラーになってしまう。なぜだろう？
とりあえず動作するようにはなったので再公開。(-_-;)
ちなみにP105はHWの処理能力が足りないのか不安定っぽい。これから購入する人はP110Mのほうが安定してるのでお勧め。

2024-01-10
mbedtlsの使い方のミスによるメモリーリークの修正、及び、通信毎にソケットを接続切断するように修正。
★★★昨日までにＤＬした方は入れ替えをお願いします。★★★

2024-01-09
ESP32のWiFiClient以外にも対応できるように汎用化してみた。
下記のようにコンストラクタにClientクラスの派生クラスを指定する。

#include <tapo2.h>
#include <xxx.h>

XXXClient client;
Tapo2 tapo(client);

#include <tapo2.h>

#include <xxx.h>

XXXClient client;

Tapo2 tapo(client);

【サンプル・スケッチ】

#include <tapo2.h>

Tapo2 tapo;

void setup()
{
  /* Setup Debug Print Output */
  Serial.begin(115200);

  /* Setup WiFi */
  WiFi.begin("ssid", "password");
  while (WiFi.status() != WL_CONNECTED)
    yield();

  /* Setup TAPO Klap Device *.
  tapo.begin("ipaddress", "username", "password");
}

void loop()
{
  String info;

  /* Get Energy Usage */
  tapo.getEnergyUsage(info);
  Serial.printf("getEnergyUsage() = %s\n\n", info.c_str());

  /* Get Device Info */
  tapo.getDeviceInfo(info);
  Serial.printf("getDeviceInfo() = %s\n\n", info.c_str());

  /* Plug ON */
  tapo.setDeviceOn(true);
  delay(1000);

  /* Plug OFF */
  tapo.setDeviceOn(false);
  delay(1000);
}

#include <tapo2.h>

Tapo2 tapo;

void setup()

{

/* Setup Debug Print Output */

Serial.begin(115200);

/* Setup WiFi */

WiFi.begin("ssid", "password");

while (WiFi.status() != WL_CONNECTED)

yield();

/* Setup TAPO Klap Device *.

tapo.begin("ipaddress", "username", "password");

}

void loop()

{

String info;

/* Get Energy Usage */

tapo.getEnergyUsage(info);

Serial.printf("getEnergyUsage() = %s\n\n", info.c_str());

/* Get Device Info */

tapo.getDeviceInfo(info);

Serial.printf("getDeviceInfo() = %s\n\n", info.c_str());

/* Plug ON */

tapo.setDeviceOn(true);

delay(1000);

/* Plug OFF */

tapo.setDeviceOn(false);

delay(1000);

}

【ライブラリ】

/*
  tapo2.h - TP-Link Tapo Klap Client Library

  Copyright (c) 2023 Sasapea's Lab. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#pragma once

#include <Arduino.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <string>
#include "httpclient.h"
#include "crypt.h"
#include "debug.h"

// Requires installation.
#include "Arduino_JSON.h"

#define TAPO_HTTP_403_RETRY 10
#define TAPO_SEED_SIZE      16
#define TAPO_SHA1_SIZE      20
#define TAPO_SHA256_SIZE    32
#define TAPO_KEY_SIZE       (128 >> 3)
#define TAPO_SEQ_TYPE       int32_t
#define TAPO_DEBUG          0

class Tapo2
{
  public:

    Tapo2(Client& client)
    {
      _http.client(client);
    }

#if defined(ESP32)

    Tapo2(void)
    {
    }

#endif

    virtual ~Tapo2(void)
    {
    }

    bool begin(const char *deviceIp, const char *username, const char *password)
    {
      struct __attribute__((packed))
      {
        unsigned char username[TAPO_SHA1_SIZE];
        unsigned char password[TAPO_SHA1_SIZE];
      } auth;

      endSession();

      _deviceIp = deviceIp;

      _crypt.digest(_crypt.MD_SHA1, (const unsigned char *)username, strlen(username), auth.username);
      _crypt.digest(_crypt.MD_SHA1, (const unsigned char *)password, strlen(password), auth.password);
      _crypt.digest(_crypt.MD_SHA256, auth.username, sizeof(auth), _authHash);

      return true;
    }

    void end(void)
    {
      endSession();
    }

    bool setDeviceOn(bool on)
    {
      JSONVar payload, response;
      payload["method"] = "set_device_info";
      payload["params"]["device_on"] = on;
      payload["terminalUUID"] = getTerminalUUID(); /* for P105 */
      payload["requestTimeMils"] = millis();       /* for P105 */
      if (request(payload, response))
      {
        int status = response["error_code"];
        if ((status != 0) && (status != -1301))
          Debug::printf(__FILE__, __LINE__, "TAPO Error Code (%d)\n", status);
        else
          return true;
      }
      return false;
    }

    bool getDeviceInfo(String &info)
    {
      JSONVar payload, response;
      payload["method"] = "get_device_info";
      if (request(payload, response))
      {
        int status = response["error_code"];
        if (status)
          Debug::printf(__FILE__, __LINE__, "TAPO Error Code = %d\n", status);
        else
        {
          char *temp = (char *)_request.data;
          String str;
          str = JSONVar::stringify(response["result"]["ssid"]);
          temp[_crypt.base64Decode(str.c_str(), str.length(), temp)] = 0;
          response["result"]["ssid"] = temp;
          str = JSONVar::stringify(response["result"]["nickname"]);
          temp[_crypt.base64Decode(str.c_str(), str.length(), temp)] = 0;
          response["result"]["nickname"] = temp;
          info = JSONVar::stringify(response["result"]);
          /* for P105 */
          str = JSONVar::stringify(response["result"]["mac"]);
          snprintf(_session.terminalUUID, sizeof(_session.terminalUUID), "%s", str.c_str());
          return true;
        }
      }
      info.clear();
      return false;
    }

    bool getEnergyUsage(String &info)
    {
      JSONVar payload, response;
      payload["method"] = "get_energy_usage";
      if (request(payload, response))
      {
        int status = response["error_code"];
        if (status)
          Debug::printf(__FILE__, __LINE__, "TAPO Error Code = %d\n", status);
        else
        {
          info = JSONVar::stringify(response["result"]);
          return true;
        }
      }
      info.clear();
      return false;
    }

  private:

    const char *getTerminalUUID(void)
    {
      if (!_session.terminalUUID[0])
      {
        /* for P105 */
        String info;
        getDeviceInfo(info);
      }
      return _session.terminalUUID;
    }

    bool request(JSONVar& message, JSONVar& response)
    {
      int status = 403;
      for (int i = 0; (status == 403) && (i < TAPO_HTTP_403_RETRY); ++i)
      {
        if (beginSession())
        {
          unsigned char hash[sizeof(_authHash)];

          std::string msg = JSONVar::stringify(message).c_str();
          std::string url = "app/request?seq=";
          url += std::to_string(++_session.seq);

          memcpy(_request.sig, _session.sig, sizeof(_request.sig));
          _request.seq[0] = _session.iv.seq[0] = (unsigned char)(_session.seq >> 24);
          _request.seq[1] = _session.iv.seq[1] = (unsigned char)(_session.seq >> 16);
          _request.seq[2] = _session.iv.seq[2] = (unsigned char)(_session.seq >>  8);
          _request.seq[3] = _session.iv.seq[3] = (unsigned char)(_session.seq >>  0);
          size_t len = _crypt.cipher(_crypt.OPERATION_ENCRYPT, (const unsigned char *)msg.c_str(), msg.length(), _request.data, _session.key, _session.iv.hash);
          _crypt.digest(_crypt.MD_SHA256, _request.sig, len + sizeof(hash), hash);
          memcpy(_request.sig, hash, sizeof(_request.sig) + sizeof(_request.seq));

          _session.sessionStart = time(NULL);
          _http.clear();
          _http.addHeader(_http.HTTP_CONTENT_TYPE, HTTP_CONTENT_TYPE);
          _http.addHeader(_http.HTTP_COOKIE, _session.sessionId);
          if ((status = _http.request(_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, url.c_str(), _request.sig, len + sizeof(hash))) != HTTP_CODE_OK)
          {
            if (TAPO_DEBUG || (i == TAPO_HTTP_403_RETRY - 1) || (status != 403))
              Debug::printf(__FILE__, __LINE__, "(%d) HttpClient::request(\"%s\", %d, \"%s\", \"%s\", %p, %zu) = %d\n",
                i, _deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, url.c_str(), _request.sig, len + sizeof(hash), status);
          }
          else
          {
            _request.data[_crypt.cipher(_crypt.OPERATION_DECRYPT, (unsigned char *)_http.response().content() + sizeof(hash),
              _http.response().length() - sizeof(hash), _request.data, _session.key, _session.iv.hash)] = 0;
            response = JSONVar::parse((const char *)_request.data);
            if (TAPO_DEBUG && i)
              Debug::printf(__FILE__, __LINE__, "TAPO Session Retries (%d)\n", i);
            return true;
          }
        }
        endSession();
      }
      return false;
    }

    bool handshake1(void)
    {
      typedef struct __attribute__((packed))
      {
        unsigned char remoteSeed[sizeof(_localSeed)];
        unsigned char serverHash[sizeof(_authHash)];
      } response_t;

      int status;
      unsigned char hash[sizeof(_authHash)];
      struct __attribute__((packed))
      {
        unsigned char localSeed[sizeof(_localSeed)];
        unsigned char remoteSeed[sizeof(_remoteSeed)];
        unsigned char authHash[sizeof(_authHash)];
      } auth;

      _crypt.random(_localSeed, sizeof(_localSeed));

      _session.sessionStart = time(NULL);
      _http.clear();
      _http.addHeader(_http.HTTP_CONTENT_TYPE, HTTP_CONTENT_TYPE);
      if ((status = _http.request(_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake1", _localSeed, sizeof(_localSeed))) != HTTP_CODE_OK)
        Debug::printf(__FILE__, __LINE__, "HttpClient::request(\"%s\", %d, \"%s\", \"%s\", %p, %zu) = %d\n",
          _deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake1", _localSeed, sizeof(_localSeed), status);
      else
      {
        response_t *response = (response_t *)_http.response().content();
        memcpy(_remoteSeed, response->remoteSeed, sizeof(_remoteSeed));
        memcpy(auth.remoteSeed, _remoteSeed, sizeof(auth.remoteSeed));
        memcpy(auth.localSeed , _localSeed , sizeof(auth.localSeed ));
        memcpy(auth.authHash  , _authHash  , sizeof(auth.authHash  ));
        _crypt.digest(_crypt.MD_SHA256, auth.localSeed, sizeof(auth), hash);
        if (memcmp(hash, response->serverHash, sizeof(hash)) != 0)
          Debug::printf(__FILE__, __LINE__, "Login failed\n");
        else
        {
          std::string cookie = _http.response().getHeader(_http.HTTP_SET_COOKIE, "");
          // parse cookie
          int left  = 0;
          int right = -1;
          while (right + 1 < (int)cookie.length())
          {
            left  = right + 1;
            right = cookie.find_first_of(';', left);
            if (right < 0)
              right = cookie.length();
            int mid = cookie.find_first_of('=', left);
            if (mid < 0)
              mid = right;
            std::string name  = cookie.substr(left, mid - left);
            std::string value = cookie.substr(mid + 1, right - (mid + 1));
            if (strcasecmp(name.c_str(), "TP_SESSIONID") == 0)
              snprintf(_session.sessionId, sizeof(_session.sessionId), "%s", cookie.substr(left, right - left).c_str());
            if (strcasecmp(name.c_str(), "TIMEOUT") == 0)
              _session.sessionExpire = atoi(value.c_str()) - 60;
          }
          if ((_session.sessionId[0] != 0) && (_session.sessionExpire != 0))
            return true;
          Debug::printf(__FILE__, __LINE__, "Cookie not set\n");
        }
      }
      return false;
    }

    bool handshake2(void)
    {
      int status;
      unsigned char hash[sizeof(_authHash)];
      struct __attribute__((packed))
      {
        unsigned char remoteSeed[sizeof(_remoteSeed)];
        unsigned char localSeed[sizeof(_localSeed)];
        unsigned char authHash[sizeof(_authHash)];
      } auth;

      memcpy(auth.remoteSeed, _remoteSeed, sizeof(auth.remoteSeed));
      memcpy(auth.localSeed , _localSeed , sizeof(auth.localSeed ));
      memcpy(auth.authHash  , _authHash  , sizeof(auth.authHash  ));
      _crypt.digest(_crypt.MD_SHA256, auth.remoteSeed, sizeof(auth), hash);

      _session.sessionStart = time(NULL);
      _http.clear();
      _http.addHeader(_http.HTTP_CONTENT_TYPE, HTTP_CONTENT_TYPE);
      _http.addHeader(_http.HTTP_COOKIE, _session.sessionId);
      if ((status = _http.request(_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake2", hash, sizeof(hash))) != HTTP_CODE_OK)
        Debug::printf(__FILE__, __LINE__, "HttpClient::request(\"%s\", %d, \"%s\", \"%s\", %p, %zu) = %d\n",
          _deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake2", hash, sizeof(hash), status);
      else
      {
        struct __attribute__((packed))
        {
          unsigned char prefix[3];
          unsigned char localSeed[sizeof(_localSeed)];
          unsigned char remoteSeed[sizeof(_remoteSeed)];
          unsigned char authHash[sizeof(_authHash)];
        } cipher;

        memcpy(cipher.localSeed , _localSeed , sizeof(cipher.localSeed ));
        memcpy(cipher.remoteSeed, _remoteSeed, sizeof(cipher.remoteSeed));
        memcpy(cipher.authHash  , _authHash  , sizeof(cipher.authHash  ));

        // key
        cipher.prefix[0] = 'l';
        cipher.prefix[1] = 's';
        cipher.prefix[2] = 'k';
        _crypt.digest(_crypt.MD_SHA256, cipher.prefix, sizeof(cipher), hash);
        memcpy(_session.key, hash, sizeof(_session.key));
        // sig
        cipher.prefix[0] ='l';
        cipher.prefix[1] ='d';
        cipher.prefix[2] ='k';
        _crypt.digest(_crypt.MD_SHA256, cipher.prefix, sizeof(cipher), hash);
        memcpy(_session.sig, hash, sizeof(_session.sig));
        // iv
        cipher.prefix[1] = 'i';
        cipher.prefix[2] = 'v';
        _crypt.digest(_crypt.MD_SHA256, cipher.prefix + 1, sizeof(cipher) - 1, hash);
        memcpy(_session.iv.hash, hash, sizeof(_session.iv));
        _session.seq = ((uint32_t)_session.iv.seq[0] << 24) | ((uint32_t)_session.iv.seq[1] << 16) | ((uint16_t)_session.iv.seq[2] << 8) | (_session.iv.seq[3] << 0);
      }
      return status == HTTP_CODE_OK;
    }

    bool beginSession(void)
    {
      // session timeouted ?
      if ((_session.sessionExpire != 0) && (time(NULL) - _session.sessionStart < _session.sessionExpire))
        return true;
      // handshake
      if (handshake1() && handshake2())
        return true;
      endSession();
      return false;
    }

    void endSession(void)
    {
      memset(&_session, 0, sizeof(_session));
    }

    struct
    {
      time_t sessionStart;
      time_t sessionExpire;
      char   sessionId[64];
      TAPO_SEQ_TYPE seq;
      unsigned char key[TAPO_KEY_SIZE];
      unsigned char sig[TAPO_SHA256_SIZE - sizeof(TAPO_SEQ_TYPE)];
      struct __attribute__((packed))
      {
        unsigned char hash[TAPO_KEY_SIZE - sizeof(TAPO_SEQ_TYPE)];
        unsigned char seq[sizeof(TAPO_SEQ_TYPE)];
      } iv;
      char terminalUUID[32]; /* for P105 */
    } _session;

    struct __attribute__((packed))
    {
      unsigned char sig[sizeof(_session.sig)];
      unsigned char seq[sizeof(_session.seq)];
      unsigned char data[HTTP_MAX_CONTENT_LENGTH];
    } _request;

    std::string   _deviceIp;
    HttpClient    _http;
    Crypt         _crypt;
    unsigned char _localSeed[TAPO_SEED_SIZE];
    unsigned char _remoteSeed[TAPO_SEED_SIZE];
    unsigned char _authHash[TAPO_SHA256_SIZE];

    const char *HTTP_CONTENT_TYPE = "application/octet-stream";
};

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

tapo2.h - TP-Link Tapo Klap Client Library

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#pragma once

#include <Arduino.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#include <time.h>

#include <string>

#include "httpclient.h"

#include "crypt.h"

#include "debug.h"

// Requires installation.

#include "Arduino_JSON.h"

#define TAPO_HTTP_403_RETRY 10

#define TAPO_SEED_SIZE 16

#define TAPO_SHA1_SIZE 20

#define TAPO_SHA256_SIZE 32

#define TAPO_KEY_SIZE (128 >> 3)

#define TAPO_SEQ_TYPE int32_t

#define TAPO_DEBUG 0

class Tapo2

{

public:

Tapo2(Client& client)

{

_http.client(client);

}

#if defined(ESP32)

Tapo2(void)

{

}

#endif

virtual ~Tapo2(void)

{

}

bool begin(const char *deviceIp, const char *username, const char *password)

{

struct __attribute__((packed))

{

unsigned char username[TAPO_SHA1_SIZE];

unsigned char password[TAPO_SHA1_SIZE];

} auth;

endSession();

_deviceIp = deviceIp;

_crypt.digest(_crypt.MD_SHA1, (const unsigned char *)username, strlen(username), auth.username);

_crypt.digest(_crypt.MD_SHA1, (const unsigned char *)password, strlen(password), auth.password);

_crypt.digest(_crypt.MD_SHA256, auth.username, sizeof(auth), _authHash);

return true;

}

void end(void)

{

endSession();

}

bool setDeviceOn(bool on)

{

JSONVar payload, response;

payload["method"] = "set_device_info";

payload["params"]["device_on"] = on;

payload["terminalUUID"] = getTerminalUUID(); /* for P105 */

payload["requestTimeMils"] = millis(); /* for P105 */

if (request(payload, response))

{

int status = response["error_code"];

if ((status != 0) && (status != -1301))

Debug::printf(__FILE__, __LINE__, "TAPO Error Code (%d)\n", status);

else

return true;

}

return false;

}

bool getDeviceInfo(String &info)

{

JSONVar payload, response;

payload["method"] = "get_device_info";

if (request(payload, response))

{

int status = response["error_code"];

if (status)

Debug::printf(__FILE__, __LINE__, "TAPO Error Code = %d\n", status);

else

{

char *temp = (char *)_request.data;

String str;

str = JSONVar::stringify(response["result"]["ssid"]);

temp[_crypt.base64Decode(str.c_str(), str.length(), temp)] = 0;

response["result"]["ssid"] = temp;

str = JSONVar::stringify(response["result"]["nickname"]);

temp[_crypt.base64Decode(str.c_str(), str.length(), temp)] = 0;

response["result"]["nickname"] = temp;

info = JSONVar::stringify(response["result"]);

/* for P105 */

str = JSONVar::stringify(response["result"]["mac"]);

snprintf(_session.terminalUUID, sizeof(_session.terminalUUID), "%s", str.c_str());

return true;

}

info.clear();

return false;

}

bool getEnergyUsage(String &info)

{

JSONVar payload, response;

payload["method"] = "get_energy_usage";

if (request(payload, response))

{

int status = response["error_code"];

if (status)

Debug::printf(__FILE__, __LINE__, "TAPO Error Code = %d\n", status);

else

{

info = JSONVar::stringify(response["result"]);

return true;

}

info.clear();

return false;

}

private:

const char *getTerminalUUID(void)

{

if (!_session.terminalUUID[0])

{

/* for P105 */

String info;

getDeviceInfo(info);

}

return _session.terminalUUID;

}

bool request(JSONVar& message, JSONVar& response)

{

int status = 403;

for (int i = 0; (status == 403) && (i < TAPO_HTTP_403_RETRY); ++i)

{

if (beginSession())

{

unsigned char hash[sizeof(_authHash)];

std::string msg = JSONVar::stringify(message).c_str();

std::string url = "app/request?seq=";

url += std::to_string(++_session.seq);

memcpy(_request.sig, _session.sig, sizeof(_request.sig));

_request.seq[0] = _session.iv.seq[0] = (unsigned char)(_session.seq >> 24);

_request.seq[1] = _session.iv.seq[1] = (unsigned char)(_session.seq >> 16);

_request.seq[2] = _session.iv.seq[2] = (unsigned char)(_session.seq >> 8);

_request.seq[3] = _session.iv.seq[3] = (unsigned char)(_session.seq >> 0);

size_t len = _crypt.cipher(_crypt.OPERATION_ENCRYPT, (const unsigned char *)msg.c_str(), msg.length(), _request.data, _session.key, _session.iv.hash);

_crypt.digest(_crypt.MD_SHA256, _request.sig, len + sizeof(hash), hash);

memcpy(_request.sig, hash, sizeof(_request.sig) + sizeof(_request.seq));

_session.sessionStart = time(NULL);

_http.clear();

_http.addHeader(_http.HTTP_CONTENT_TYPE, HTTP_CONTENT_TYPE);

_http.addHeader(_http.HTTP_COOKIE, _session.sessionId);

if ((status = _http.request(_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, url.c_str(), _request.sig, len + sizeof(hash))) != HTTP_CODE_OK)

{

if (TAPO_DEBUG || (i == TAPO_HTTP_403_RETRY - 1) || (status != 403))

Debug::printf(__FILE__, __LINE__, "(%d) HttpClient::request(\"%s\", %d, \"%s\", \"%s\", %p, %zu) = %d\n",

i, _deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, url.c_str(), _request.sig, len + sizeof(hash), status);

}

else

{

_request.data[_crypt.cipher(_crypt.OPERATION_DECRYPT, (unsigned char *)_http.response().content() + sizeof(hash),

_http.response().length() - sizeof(hash), _request.data, _session.key, _session.iv.hash)] = 0;

response = JSONVar::parse((const char *)_request.data);

if (TAPO_DEBUG && i)

Debug::printf(__FILE__, __LINE__, "TAPO Session Retries (%d)\n", i);

return true;

}

endSession();

}

return false;

}

bool handshake1(void)

{

typedef struct __attribute__((packed))

{

unsigned char remoteSeed[sizeof(_localSeed)];

unsigned char serverHash[sizeof(_authHash)];

} response_t;

int status;

unsigned char hash[sizeof(_authHash)];

struct __attribute__((packed))

{

unsigned char localSeed[sizeof(_localSeed)];

unsigned char remoteSeed[sizeof(_remoteSeed)];

unsigned char authHash[sizeof(_authHash)];

} auth;

_crypt.random(_localSeed, sizeof(_localSeed));

_session.sessionStart = time(NULL);

_http.clear();

_http.addHeader(_http.HTTP_CONTENT_TYPE, HTTP_CONTENT_TYPE);

if ((status = _http.request(_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake1", _localSeed, sizeof(_localSeed))) != HTTP_CODE_OK)

Debug::printf(__FILE__, __LINE__, "HttpClient::request(\"%s\", %d, \"%s\", \"%s\", %p, %zu) = %d\n",

_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake1", _localSeed, sizeof(_localSeed), status);

else

{

response_t *response = (response_t *)_http.response().content();

memcpy(_remoteSeed, response->remoteSeed, sizeof(_remoteSeed));

memcpy(auth.remoteSeed, _remoteSeed, sizeof(auth.remoteSeed));

memcpy(auth.localSeed , _localSeed , sizeof(auth.localSeed ));

memcpy(auth.authHash , _authHash , sizeof(auth.authHash ));

_crypt.digest(_crypt.MD_SHA256, auth.localSeed, sizeof(auth), hash);

if (memcmp(hash, response->serverHash, sizeof(hash)) != 0)

Debug::printf(__FILE__, __LINE__, "Login failed\n");

else

{

std::string cookie = _http.response().getHeader(_http.HTTP_SET_COOKIE, "");

// parse cookie

int left = 0;

int right = -1;

while (right + 1 < (int)cookie.length())

{

left = right + 1;

right = cookie.find_first_of(';', left);

if (right < 0)

right = cookie.length();

int mid = cookie.find_first_of('=', left);

if (mid < 0)

mid = right;

std::string name = cookie.substr(left, mid - left);

std::string value = cookie.substr(mid + 1, right - (mid + 1));

if (strcasecmp(name.c_str(), "TP_SESSIONID") == 0)

snprintf(_session.sessionId, sizeof(_session.sessionId), "%s", cookie.substr(left, right - left).c_str());

if (strcasecmp(name.c_str(), "TIMEOUT") == 0)

_session.sessionExpire = atoi(value.c_str()) - 60;

}

if ((_session.sessionId[0] != 0) && (_session.sessionExpire != 0))

return true;

Debug::printf(__FILE__, __LINE__, "Cookie not set\n");

}

return false;

}

bool handshake2(void)

{

int status;

unsigned char hash[sizeof(_authHash)];

struct __attribute__((packed))

{

unsigned char remoteSeed[sizeof(_remoteSeed)];

unsigned char localSeed[sizeof(_localSeed)];

unsigned char authHash[sizeof(_authHash)];

} auth;

memcpy(auth.remoteSeed, _remoteSeed, sizeof(auth.remoteSeed));

memcpy(auth.localSeed , _localSeed , sizeof(auth.localSeed ));

memcpy(auth.authHash , _authHash , sizeof(auth.authHash ));

_crypt.digest(_crypt.MD_SHA256, auth.remoteSeed, sizeof(auth), hash);

_session.sessionStart = time(NULL);

_http.clear();

_http.addHeader(_http.HTTP_CONTENT_TYPE, HTTP_CONTENT_TYPE);

_http.addHeader(_http.HTTP_COOKIE, _session.sessionId);

if ((status = _http.request(_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake2", hash, sizeof(hash))) != HTTP_CODE_OK)

Debug::printf(__FILE__, __LINE__, "HttpClient::request(\"%s\", %d, \"%s\", \"%s\", %p, %zu) = %d\n",

_deviceIp.c_str(), 80, _http.HTTP_METHOD_POST, "app/handshake2", hash, sizeof(hash), status);

else

{

struct __attribute__((packed))

{

unsigned char prefix[3];

unsigned char localSeed[sizeof(_localSeed)];

unsigned char remoteSeed[sizeof(_remoteSeed)];

unsigned char authHash[sizeof(_authHash)];

} cipher;

memcpy(cipher.localSeed , _localSeed , sizeof(cipher.localSeed ));

memcpy(cipher.remoteSeed, _remoteSeed, sizeof(cipher.remoteSeed));

memcpy(cipher.authHash , _authHash , sizeof(cipher.authHash ));

// key

cipher.prefix[0] = 'l';

cipher.prefix[1] = 's';

cipher.prefix[2] = 'k';

_crypt.digest(_crypt.MD_SHA256, cipher.prefix, sizeof(cipher), hash);

memcpy(_session.key, hash, sizeof(_session.key));

// sig

cipher.prefix[0] ='l';

cipher.prefix[1] ='d';

cipher.prefix[2] ='k';

_crypt.digest(_crypt.MD_SHA256, cipher.prefix, sizeof(cipher), hash);

memcpy(_session.sig, hash, sizeof(_session.sig));

// iv

cipher.prefix[1] = 'i';

cipher.prefix[2] = 'v';

_crypt.digest(_crypt.MD_SHA256, cipher.prefix + 1, sizeof(cipher) - 1, hash);

memcpy(_session.iv.hash, hash, sizeof(_session.iv));

_session.seq = ((uint32_t)_session.iv.seq[0] << 24) | ((uint32_t)_session.iv.seq[1] << 16) | ((uint16_t)_session.iv.seq[2] << 8) | (_session.iv.seq[3] << 0);

}

return status == HTTP_CODE_OK;

}

bool beginSession(void)

{

// session timeouted ?

if ((_session.sessionExpire != 0) && (time(NULL) - _session.sessionStart < _session.sessionExpire))

return true;

// handshake

if (handshake1() && handshake2())

return true;

endSession();

return false;

}

void endSession(void)

{

memset(&_session, 0, sizeof(_session));

}

struct

{

time_t sessionStart;

time_t sessionExpire;

char sessionId[64];

TAPO_SEQ_TYPE seq;

unsigned char key[TAPO_KEY_SIZE];

unsigned char sig[TAPO_SHA256_SIZE - sizeof(TAPO_SEQ_TYPE)];

struct __attribute__((packed))

{

unsigned char hash[TAPO_KEY_SIZE - sizeof(TAPO_SEQ_TYPE)];

unsigned char seq[sizeof(TAPO_SEQ_TYPE)];

} iv;

char terminalUUID[32]; /* for P105 */

} _session;

struct __attribute__((packed))

{

unsigned char sig[sizeof(_session.sig)];

unsigned char seq[sizeof(_session.seq)];

unsigned char data[HTTP_MAX_CONTENT_LENGTH];

} _request;

std::string _deviceIp;

HttpClient _http;

Crypt _crypt;

unsigned char _localSeed[TAPO_SEED_SIZE];

unsigned char _remoteSeed[TAPO_SEED_SIZE];

unsigned char _authHash[TAPO_SHA256_SIZE];

const char *HTTP_CONTENT_TYPE = "application/octet-stream";

};

/*
  httpclient.h - HTTP Client Library for Linux/Windows/Arduino

  Copyright (c) 2023 Sasapea's Lab. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <vector>

#define HTTP_CODE_OK 200
#define HTTP_CONNECT_TIMEOUT    3000
#define HTTP_SESSION_TIMEOUT    1000
#define HTTP_SESSION_TIMEOUT2   20
#define HTTP_MAX_CONTENT_LENGTH 2048

typedef struct
{
  std::string name;
  std::string value;
} http_name_value_t;

class HttpHeader
{
  protected:

    std::vector<http_name_value_t> _headers;

    void addNameValue(std::vector<http_name_value_t> &vec, const char *name, int value)
    {
      addNameValue(vec, name, std::to_string(value).c_str());
    }

    void addNameValue(std::vector<http_name_value_t> &vec, const char *name, const char *value)
    {
      for(auto it = vec.begin(); it != vec.end(); ++it)
      {
        if (strcasecmp(it->name.c_str(), name) == 0)
        {
          it->value = value;
          return;
        }
      }
      vec.push_back({name, value});
    }

    const char *getNameValue(std::vector<http_name_value_t> &vec, const char *name, const char *defval = "")
    {
      for(auto it = vec.begin(); it != vec.end(); ++it)
      {
        if (strcasecmp(it->name.c_str(), name) == 0)
          return it->value.c_str();
      }
      return defval;
    }

    std::string& listNameValue(std::string& list, std::vector<http_name_value_t> &vec, const char *sep, const char *dlm, bool last)
    {
      for(auto it = vec.begin(); it != vec.end(); ++it)
      {
        if (list.size())
          list += dlm;
        list += it->name;
        list += sep;
        list += it->value;
      }
      if (last && list.size())
        list += dlm;
      return list;
    }

  public:

    void addHeader(const char *name, const char *value)
    {
      addNameValue(_headers, name, value);
    }

    void addHeader(const char *name, int value)
    {
      addNameValue(_headers, name, value);
    }

    const char *getHeader(const char *name, const char *defval = "")
    {
      return getNameValue(_headers, name, defval);
    }

    static const char *HTTP_METHOD_GET;
    static const char *HTTP_METHOD_POST;
    static const char *HTTP_HOST;
    static const char *HTTP_CONNECTION;
    static const char *HTTP_CONTENT_TYPE;
    static const char *HTTP_CONTENT_LENGTH;
    static const char *HTTP_SET_COOKIE;
    static const char *HTTP_COOKIE;
    static const char *HTTP_MIME_TEXT_HTML;
    static const char *HTTP_MIME_TEXT_PLAIN;
    static const char *HTTP_LF;
};

class HttpRequest : public HttpHeader
{
  public:

    void clear(void)
    {
      _headers.clear();
//      addHeader(HTTP_CONNECTION, "close");
      addHeader(HTTP_CONTENT_TYPE, HTTP_MIME_TEXT_HTML);
      addHeader(HTTP_CONTENT_LENGTH, "0");
    }

    std::string& getHttpString(std::string& str, const char *host, const char *path, const char *method, int clen)
    {
      std::vector<http_name_value_t> headers = _headers;
      str = method;
      str += " /";
      str += path;
      str += " HTTP/";
      if (host && *host)
      {
        str += "1.1";
        addNameValue(headers, HTTP_HOST, host);
      }
      else
        str += "1.0";
      addNameValue(headers, HTTP_CONTENT_LENGTH, clen);
      listNameValue(str, headers, ": ", HTTP_LF, true);
      str += HTTP_LF;
      return str;
    }
};

class HttpResponse : public HttpHeader
{
  private:

    char        _content[HTTP_MAX_CONTENT_LENGTH];
    size_t      _maxlen;
    size_t      _length;
    int         _mode;
    std::string _result[3];

  public:

    HttpResponse(void)
    {
      clear();
    }

    virtual ~HttpResponse(void)
    {
    }

    void clear(void)
    {
      _mode      = 0;
      _maxlen    = SIZE_MAX;
      _length    = 0;
      _result[0] = "";
      _result[1] = "-1";
      _result[2] = "";
      _headers.clear();
    }

    char *buffer(size_t& len)
    {
      len = sizeof(_content) - _length;
      return _content + _length;
    }

    bool parse(int append)
    {
      char *p, *q, *r;
      int n;
      if (append > 0)
      {
        _length += append;
        if (_mode < 2)
        {
          for (p = _content, r = nullptr; (q = (char *)memchr(p, '\n', _length)); p = r)
          {
            if (*(q - 1) == '\r')
              *(q - 1) = 0;
            *q = 0;
            r = q + 1;
            if (_mode == 0)
            {
              for (size_t i = 0; p && *p; ++i)
              {
                p += strspn(p, " ");
                if ((q = strchr(p, ' ')))
                  *q++ = 0;
                if (i < sizeof(_result) / sizeof(_result[0]))
                  _result[i] = p;
                p = q;
              }
              _mode = 1;
            }
            else if (*p == 0)
            {
              _mode = 2;
              break;
            }
            else
            {
              p += strspn(p, " ");
              if ((q = strchr(p, ':')))
              {
                *q++ = 0;
                q += strspn(q, " ");
                n = strlen(q);
                while (n && (*(q + --n) == ' '))
                  *(q + n) = 0;
                n = strlen(p);
                while (n && (*(p + --n) == ' '))
                  *(p + n) = 0;
                addHeader(p, q);
                if (strcasecmp(p, HTTP_CONTENT_LENGTH) == 0)
                {
                  if ((n = atoi(q)) >= 0)
                    _maxlen = n;
                }
              }
            }
            if (r >= _content + _length)
              break;
          }
          if (r)
            memcpy(_content, r, _length -= (size_t)(r - _content));
        }
      }
      return (_mode < 2) || (_length < _maxlen);
    }

    const char *getHttpVersion(void)
    {
      return _result[0].c_str();
    }

    int getHttpStatus(void)
    {
      return std::stoi(_result[1]);
    }

    const char *getHttpMessage(void)
    {
      return _result[2].c_str();
    }

    const char *getContentType(void)
    {
      return getHeader(HTTP_CONTENT_TYPE, "");
    }

    int getContentLength(void)
    {
      return std::stoi(getHeader(HTTP_CONTENT_LENGTH, "-1"), nullptr, 10);
    }

    size_t length(void)
    {
      return _mode == 2 ? _length : 0;
    }

    const char *content(void)
    {
      return _content;
    }

    std::string& getHttpString(std::string& str)
    {
      str.clear();
      for (size_t i = 0; i < sizeof(_result) / sizeof(_result[0]); ++i)
      {
        str += _result[i];
        if (i + 1 < sizeof(_result) / sizeof(_result[0]))
          str += ' ';
      }
      listNameValue(str, _headers, ": ", "\n", true);
      return str;
    }
};

class BaseHttpClient : public HttpRequest
{
  protected:

    HttpResponse _response;

  public:

    BaseHttpClient(void)
    {
    }

    virtual ~BaseHttpClient(void)
    {
    }

    void clear(void)
    {
      HttpRequest::clear();
      _response.clear();
    }

    virtual int open(const char *host, int port = 80) = 0;
    virtual void close(int sock) = 0;
    virtual int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) = 0;

    int request(const char *host, int port, const char *method, const char *path, const unsigned char *content, size_t clen)
    {
      int sock, status = -1;
      if ((sock = open(host, port)) >= 0)
      {
        status = request0(sock, method, path, content, clen);
        close(sock);
      }
      return status;
    }

    HttpResponse& response(void)
    {
      return _response;
    }

    virtual bool startup(void)
    {
      return true;
    }

    virtual void cleanup(void)
    {
    }
};

/************************************************************
  ARDUINO
 ************************************************************/

#if defined(ARDUINO)

#include <Arduino.h>

#if defined(ESP32)
  #include <WiFi.h>
#endif

class HttpClient : public BaseHttpClient
{
  private:

    Client *_client;

#if defined(ESP32)
    WiFiClient _esp32_wificlient;
    bool _esp32_wificlient_class;
#endif

  public:

    HttpClient(void)
    {
  #if defined(ESP32)
      _client = &_esp32_wificlient;
      _esp32_wificlient_class = true;
  #else
      _client = nullptr;
  #endif
    }

    void client(Client& client)
    {
      _client = &client;
#if defined(ESP32)
      _esp32_wificlient_class = false;
#endif
    }

    int open(const char *host, int port = 80) override
    {
      if (!_client)
        return -1;
#if defined(ESP32)
      if (_esp32_wificlient_class)
      {
        int status = ((WiFiClient *)_client)->connect(host, port, HTTP_CONNECT_TIMEOUT);
        if (status >= 0)
          ((WiFiClient *)_client)->setNoDelay(true);
        return status;
      }
#endif
      return _client->connect(host, port);
    }

    void close(int sock) override
    {
      if ((sock >= 0) && _client)
        _client->stop();
    }

    int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) override
    {
      _response.clear();
      if ((sock >= 0) && _client)
      {
        std::string http, localIp;
#if defined(EP32)
        if (_esp32_wificlient_class)
          localIp = ((WiFiClient *)_client)->localIP().toString().c_str();
#endif
        getHttpString(http, localIp.c_str(), path, method, clen);
        size_t len;
        char *buf = _response.buffer(len);
        if (len < http.size() + clen)
          return -3;
        strcpy(buf, http.c_str());
        memcpy(buf + http.size(), content, clen);
        if (_client->write((const unsigned char *)buf, http.size() + clen) != http.size() + clen)
          return -2;
        _client->setTimeout(HTTP_SESSION_TIMEOUT);
        while (1)
        {
          buf = _response.buffer(len);
          len = _client->read((unsigned char *)buf, len);
          if (((len == 0) && !_client->connected()) || !_response.parse(len))
            break;
          _client->setTimeout(HTTP_SESSION_TIMEOUT2);
          yield();
        }
      }
      return _response.getHttpStatus();
    }
};

/************************************************************
  WINDOWS
 ************************************************************/

#elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)

#include <ws2tcpip.h>

class HttpClient : public BaseHttpClient
{
  public:

    int open(const char *host, int port = 80) override
    {
      int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
      if (sock >= 0)
      {
        struct sockaddr_in addr = {};
        addr.sin_family = AF_INET;
        addr.sin_port   = htons(port);
        addr.sin_addr.s_addr = inet_addr(host);
        unsigned long mode;
        mode = 1;
        ioctlsocket(sock, FIONBIO, &mode);
        ::connect(sock, (const struct sockaddr *)&addr, sizeof(addr));
        mode = 0;
        ioctlsocket(sock, FIONBIO, &mode);
        struct timeval timeout = { HTTP_CONNECT_TIMEOUT / 1000, (HTTP_CONNECT_TIMEOUT % 1000) * 1000 };
        fd_set wrfds;
        FD_ZERO(&wrfds);
        FD_SET(sock, &wrfds);
        if (select(sock + 1, NULL, &wrfds, NULL, &timeout) > 0)
        {
          char noDelay = 1;
          setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &noDelay, sizeof(noDelay));
        }
        else
        {
          closesocket(sock);
          sock = -1;
        }
      }
      return sock;
    }

    void close(int sock) override
    {
      if (sock >= 0)
      {
        char c;
        shutdown(sock, SD_SEND);
        recv(sock, &c, sizeof(c), 0);
        closesocket(sock);
      }
    }

    int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) override
    {
      _response.clear();
      if (sock >= 0)
      {
        std::string http, localIp;
        struct sockaddr_in addr;
        socklen_t socklen = sizeof(addr);
        if (getsockname(sock, (struct sockaddr*)&addr, &socklen) == 0)
          localIp = inet_ntoa(addr.sin_addr);
        getHttpString(http, localIp.c_str(), path, method, clen);
        size_t len;
        char *buf = _response.buffer(len);
        if (len < http.size() + clen)
          return -3;
        strcpy(buf, http.c_str());
        memcpy(buf + http.size(), content, clen);
        if ((size_t)send(sock, buf, http.size() + clen, 0) != http.size() + clen)
          return -2;
        struct timeval timeout = { HTTP_SESSION_TIMEOUT / 1000, (HTTP_SESSION_TIMEOUT % 1000) * 1000 };
        while (1)
        {
          fd_set rdfds;
          int n;
          FD_ZERO(&rdfds);
          FD_SET(sock, &rdfds);
          if ((n = select(sock + 1, &rdfds, NULL, NULL, &timeout)) < 0)
            break;
          if (n > 0)
          {
            buf = _response.buffer(len);
            n = recv(sock, buf, len, 0);
          }
          if ((n <= 0) || !_response.parse(n))
            break;
          timeout = { HTTP_SESSION_TIMEOUT2 / 1000, (HTTP_SESSION_TIMEOUT2 % 1000) * 1000 };
        }
      }
      return _response.getHttpStatus();
    }

    bool startup(void) override
    {
      WSADATA wsaData;
      return WSAStartup(MAKEWORD(2, 2), &wsaData) == 0;
    }

    void cleanup(void) override
    {
      WSACleanup();
    }
};

/************************************************************
  LINUX
 ************************************************************/

#else

#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>

class HttpClient : public BaseHttpClient
{
  public:

    int open(const char *host, int port = 80) override
    {
      int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
      if (sock >= 0)
      {
        struct sockaddr_in addr = {};
        addr.sin_family = AF_INET;
        addr.sin_port   = htons(port);
        addr.sin_addr.s_addr = inet_addr(host);
        int flags = fcntl(sock, F_GETFL);
        fcntl(sock, F_SETFL, flags | O_NONBLOCK);
        ::connect(sock, (const struct sockaddr *)&addr, sizeof(addr));
        fcntl(sock, F_SETFL, flags);
        struct timeval timeout = { HTTP_CONNECT_TIMEOUT / 1000, (HTTP_CONNECT_TIMEOUT % 1000) * 1000 };
        fd_set wrfds;
        FD_ZERO(&wrfds);
        FD_SET(sock, &wrfds);
        if (select(sock + 1, NULL, &wrfds, NULL, &timeout) > 0)
        {
          int noDelay = 1;
          setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &noDelay, sizeof(noDelay));
        }
        else
        {
          ::close(sock);
          sock = -1;
        }
      }
      return sock;
    }

    void close(int sock) override
    {
      if (sock >= 0)
      {
        char c;
        shutdown(sock, SHUT_WR);
        recv(sock, &c, sizeof(c), 0);
        ::close(sock);
      }
    }

    int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) override
    {
      _response.clear();
      if (sock >= 0)
      {
        std::string http, localIp;
        struct sockaddr_in addr;
        socklen_t socklen = sizeof(addr);
        if (getsockname(sock, (struct sockaddr*)&addr, &socklen) == 0)
          localIp = inet_ntoa(addr.sin_addr);
        getHttpString(http, localIp.c_str(), path, method, clen);
        size_t len;
        char *buf = _response.buffer(len);
        if (len < http.size() + clen)
          return -3;
        strcpy(buf, http.c_str());
        memcpy(buf + http.size(), content, clen);
        if ((size_t)send(sock, buf, http.size() + clen, MSG_NOSIGNAL) != http.size() + clen)
          return -2;
        struct timeval timeout = { HTTP_SESSION_TIMEOUT / 1000, (HTTP_SESSION_TIMEOUT % 1000) * 1000 };
        while (1)
        {
          fd_set rdfds;
          int n;
          FD_ZERO(&rdfds);
          FD_SET(sock, &rdfds);
          if ((n = select(sock + 1, &rdfds, NULL, NULL, &timeout)) < 0)
            break;
          if (n > 0)
          {
            buf = _response.buffer(len);
            n = recv(sock, buf, len, 0);
          }
          if ((n <= 0) || !_response.parse(n))
            break;
          timeout = { HTTP_SESSION_TIMEOUT2 / 1000, (HTTP_SESSION_TIMEOUT2 % 1000) * 1000 };
        }
      }
      return _response.getHttpStatus();
    }
};

#endif

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

httpclient.h - HTTP Client Library for Linux/Windows/Arduino

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#pragma once

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <limits.h>

#include <string>

#include <vector>

#define HTTP_CODE_OK 200

#define HTTP_CONNECT_TIMEOUT 3000

#define HTTP_SESSION_TIMEOUT 1000

#define HTTP_SESSION_TIMEOUT2 20

#define HTTP_MAX_CONTENT_LENGTH 2048

typedef struct

{

std::string name;

std::string value;

} http_name_value_t;

class HttpHeader

{

protected:

std::vector<http_name_value_t> _headers;

void addNameValue(std::vector<http_name_value_t> &vec, const char *name, int value)

{

addNameValue(vec, name, std::to_string(value).c_str());

}

void addNameValue(std::vector<http_name_value_t> &vec, const char *name, const char *value)

{

for(auto it = vec.begin(); it != vec.end(); ++it)

{

if (strcasecmp(it->name.c_str(), name) == 0)

{

it->value = value;

return;

}

vec.push_back({name, value});

}

const char *getNameValue(std::vector<http_name_value_t> &vec, const char *name, const char *defval = "")

{

for(auto it = vec.begin(); it != vec.end(); ++it)

{

if (strcasecmp(it->name.c_str(), name) == 0)

return it->value.c_str();

}

return defval;

}

std::string& listNameValue(std::string& list, std::vector<http_name_value_t> &vec, const char *sep, const char *dlm, bool last)

{

for(auto it = vec.begin(); it != vec.end(); ++it)

{

if (list.size())

list += dlm;

list += it->name;

list += sep;

list += it->value;

}

if (last && list.size())

list += dlm;

return list;

}

public:

void addHeader(const char *name, const char *value)

{

addNameValue(_headers, name, value);

}

void addHeader(const char *name, int value)

{

addNameValue(_headers, name, value);

}

const char *getHeader(const char *name, const char *defval = "")

{

return getNameValue(_headers, name, defval);

}

static const char *HTTP_METHOD_GET;

static const char *HTTP_METHOD_POST;

static const char *HTTP_HOST;

static const char *HTTP_CONNECTION;

static const char *HTTP_CONTENT_TYPE;

static const char *HTTP_CONTENT_LENGTH;

static const char *HTTP_SET_COOKIE;

static const char *HTTP_COOKIE;

static const char *HTTP_MIME_TEXT_HTML;

static const char *HTTP_MIME_TEXT_PLAIN;

static const char *HTTP_LF;

};

class HttpRequest : public HttpHeader

{

public:

void clear(void)

{

_headers.clear();

// addHeader(HTTP_CONNECTION, "close");

addHeader(HTTP_CONTENT_TYPE, HTTP_MIME_TEXT_HTML);

addHeader(HTTP_CONTENT_LENGTH, "0");

}

std::string& getHttpString(std::string& str, const char *host, const char *path, const char *method, int clen)

{

std::vector<http_name_value_t> headers = _headers;

str = method;

str += " /";

str += path;

str += " HTTP/";

if (host && *host)

{

str += "1.1";

addNameValue(headers, HTTP_HOST, host);

}

else

str += "1.0";

addNameValue(headers, HTTP_CONTENT_LENGTH, clen);

listNameValue(str, headers, ": ", HTTP_LF, true);

str += HTTP_LF;

return str;

}

};

class HttpResponse : public HttpHeader

{

private:

char _content[HTTP_MAX_CONTENT_LENGTH];

size_t _maxlen;

size_t _length;

int _mode;

std::string _result[3];

public:

HttpResponse(void)

{

clear();

}

virtual ~HttpResponse(void)

{

}

void clear(void)

{

_mode = 0;

_maxlen = SIZE_MAX;

_length = 0;

_result[0] = "";

_result[1] = "-1";

_result[2] = "";

_headers.clear();

}

char *buffer(size_t& len)

{

len = sizeof(_content) - _length;

return _content + _length;

}

bool parse(int append)

{

char *p, *q, *r;

int n;

if (append > 0)

{

_length += append;

if (_mode < 2)

{

for (p = _content, r = nullptr; (q = (char *)memchr(p, '\n', _length)); p = r)

{

if (*(q - 1) == '\r')

*(q - 1) = 0;

*q = 0;

r = q + 1;

if (_mode == 0)

{

for (size_t i = 0; p && *p; ++i)

{

p += strspn(p, " ");

if ((q = strchr(p, ' ')))

*q++ = 0;

if (i < sizeof(_result) / sizeof(_result[0]))

_result[i] = p;

p = q;

}

_mode = 1;

}

else if (*p == 0)

{

_mode = 2;

break;

}

else

{

p += strspn(p, " ");

if ((q = strchr(p, ':')))

{

*q++ = 0;

q += strspn(q, " ");

n = strlen(q);

while (n && (*(q + --n) == ' '))

*(q + n) = 0;

n = strlen(p);

while (n && (*(p + --n) == ' '))

*(p + n) = 0;

addHeader(p, q);

if (strcasecmp(p, HTTP_CONTENT_LENGTH) == 0)

{

if ((n = atoi(q)) >= 0)

_maxlen = n;

}

if (r >= _content + _length)

break;

}

if (r)

memcpy(_content, r, _length -= (size_t)(r - _content));

}

return (_mode < 2) || (_length < _maxlen);

}

const char *getHttpVersion(void)

{

return _result[0].c_str();

}

int getHttpStatus(void)

{

return std::stoi(_result[1]);

}

const char *getHttpMessage(void)

{

return _result[2].c_str();

}

const char *getContentType(void)

{

return getHeader(HTTP_CONTENT_TYPE, "");

}

int getContentLength(void)

{

return std::stoi(getHeader(HTTP_CONTENT_LENGTH, "-1"), nullptr, 10);

}

size_t length(void)

{

return _mode == 2 ? _length : 0;

}

const char *content(void)

{

return _content;

}

std::string& getHttpString(std::string& str)

{

str.clear();

for (size_t i = 0; i < sizeof(_result) / sizeof(_result[0]); ++i)

{

str += _result[i];

if (i + 1 < sizeof(_result) / sizeof(_result[0]))

str += ' ';

}

listNameValue(str, _headers, ": ", "\n", true);

return str;

}

};

class BaseHttpClient : public HttpRequest

{

protected:

HttpResponse _response;

public:

BaseHttpClient(void)

{

}

virtual ~BaseHttpClient(void)

{

}

void clear(void)

{

HttpRequest::clear();

_response.clear();

}

virtual int open(const char *host, int port = 80) = 0;

virtual void close(int sock) = 0;

virtual int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) = 0;

int request(const char *host, int port, const char *method, const char *path, const unsigned char *content, size_t clen)

{

int sock, status = -1;

if ((sock = open(host, port)) >= 0)

{

status = request0(sock, method, path, content, clen);

close(sock);

}

return status;

}

HttpResponse& response(void)

{

return _response;

}

virtual bool startup(void)

{

return true;

}

virtual void cleanup(void)

{

}

};

/************************************************************

ARDUINO

************************************************************/

#if defined(ARDUINO)

#include <Arduino.h>

#if defined(ESP32)

#include <WiFi.h>

#endif

class HttpClient : public BaseHttpClient

{

private:

Client *_client;

#if defined(ESP32)

WiFiClient _esp32_wificlient;

bool _esp32_wificlient_class;

#endif

public:

HttpClient(void)

{

#if defined(ESP32)

_client = &_esp32_wificlient;

_esp32_wificlient_class = true;

#else

_client = nullptr;

#endif

}

void client(Client& client)

{

_client = &client;

#if defined(ESP32)

_esp32_wificlient_class = false;

#endif

}

int open(const char *host, int port = 80) override

{

if (!_client)

return -1;

#if defined(ESP32)

if (_esp32_wificlient_class)

{

int status = ((WiFiClient *)_client)->connect(host, port, HTTP_CONNECT_TIMEOUT);

if (status >= 0)

((WiFiClient *)_client)->setNoDelay(true);

return status;

}

#endif

return _client->connect(host, port);

}

void close(int sock) override

{

if ((sock >= 0) && _client)

_client->stop();

}

int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) override

{

_response.clear();

if ((sock >= 0) && _client)

{

std::string http, localIp;

#if defined(EP32)

if (_esp32_wificlient_class)

localIp = ((WiFiClient *)_client)->localIP().toString().c_str();

#endif

getHttpString(http, localIp.c_str(), path, method, clen);

size_t len;

char *buf = _response.buffer(len);

if (len < http.size() + clen)

return -3;

strcpy(buf, http.c_str());

memcpy(buf + http.size(), content, clen);

if (_client->write((const unsigned char *)buf, http.size() + clen) != http.size() + clen)

return -2;

_client->setTimeout(HTTP_SESSION_TIMEOUT);

while (1)

{

buf = _response.buffer(len);

len = _client->read((unsigned char *)buf, len);

if (((len == 0) && !_client->connected()) || !_response.parse(len))

break;

_client->setTimeout(HTTP_SESSION_TIMEOUT2);

yield();

}

return _response.getHttpStatus();

}

};

/************************************************************

WINDOWS

************************************************************/

#elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)

#include <ws2tcpip.h>

class HttpClient : public BaseHttpClient

{

public:

int open(const char *host, int port = 80) override

{

int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

if (sock >= 0)

{

struct sockaddr_in addr = {};

addr.sin_family = AF_INET;

addr.sin_port = htons(port);

addr.sin_addr.s_addr = inet_addr(host);

unsigned long mode;

mode = 1;

ioctlsocket(sock, FIONBIO, &mode);

::connect(sock, (const struct sockaddr *)&addr, sizeof(addr));

mode = 0;

ioctlsocket(sock, FIONBIO, &mode);

struct timeval timeout = { HTTP_CONNECT_TIMEOUT / 1000, (HTTP_CONNECT_TIMEOUT % 1000) * 1000 };

fd_set wrfds;

FD_ZERO(&wrfds);

FD_SET(sock, &wrfds);

if (select(sock + 1, NULL, &wrfds, NULL, &timeout) > 0)

{

char noDelay = 1;

setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &noDelay, sizeof(noDelay));

}

else

{

closesocket(sock);

sock = -1;

}

return sock;

}

void close(int sock) override

{

if (sock >= 0)

{

char c;

shutdown(sock, SD_SEND);

recv(sock, &c, sizeof(c), 0);

closesocket(sock);

}

int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) override

{

_response.clear();

if (sock >= 0)

{

std::string http, localIp;

struct sockaddr_in addr;

socklen_t socklen = sizeof(addr);

if (getsockname(sock, (struct sockaddr*)&addr, &socklen) == 0)

localIp = inet_ntoa(addr.sin_addr);

getHttpString(http, localIp.c_str(), path, method, clen);

size_t len;

char *buf = _response.buffer(len);

if (len < http.size() + clen)

return -3;

strcpy(buf, http.c_str());

memcpy(buf + http.size(), content, clen);

if ((size_t)send(sock, buf, http.size() + clen, 0) != http.size() + clen)

return -2;

struct timeval timeout = { HTTP_SESSION_TIMEOUT / 1000, (HTTP_SESSION_TIMEOUT % 1000) * 1000 };

while (1)

{

fd_set rdfds;

int n;

FD_ZERO(&rdfds);

FD_SET(sock, &rdfds);

if ((n = select(sock + 1, &rdfds, NULL, NULL, &timeout)) < 0)

break;

if (n > 0)

{

buf = _response.buffer(len);

n = recv(sock, buf, len, 0);

}

if ((n <= 0) || !_response.parse(n))

break;

timeout = { HTTP_SESSION_TIMEOUT2 / 1000, (HTTP_SESSION_TIMEOUT2 % 1000) * 1000 };

}

return _response.getHttpStatus();

}

bool startup(void) override

{

WSADATA wsaData;

return WSAStartup(MAKEWORD(2, 2), &wsaData) == 0;

}

void cleanup(void) override

{

WSACleanup();

}

};

/************************************************************

LINUX

************************************************************/

#else

#include <time.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <arpa/inet.h>

class HttpClient : public BaseHttpClient

{

public:

int open(const char *host, int port = 80) override

{

int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

if (sock >= 0)

{

struct sockaddr_in addr = {};

addr.sin_family = AF_INET;

addr.sin_port = htons(port);

addr.sin_addr.s_addr = inet_addr(host);

int flags = fcntl(sock, F_GETFL);

fcntl(sock, F_SETFL, flags | O_NONBLOCK);

::connect(sock, (const struct sockaddr *)&addr, sizeof(addr));

fcntl(sock, F_SETFL, flags);

struct timeval timeout = { HTTP_CONNECT_TIMEOUT / 1000, (HTTP_CONNECT_TIMEOUT % 1000) * 1000 };

fd_set wrfds;

FD_ZERO(&wrfds);

FD_SET(sock, &wrfds);

if (select(sock + 1, NULL, &wrfds, NULL, &timeout) > 0)

{

int noDelay = 1;

setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &noDelay, sizeof(noDelay));

}

else

{

::close(sock);

sock = -1;

}

return sock;

}

void close(int sock) override

{

if (sock >= 0)

{

char c;

shutdown(sock, SHUT_WR);

recv(sock, &c, sizeof(c), 0);

::close(sock);

}

int request0(int sock, const char *method, const char *path, const unsigned char *content, size_t clen) override

{

_response.clear();

if (sock >= 0)

{

std::string http, localIp;

struct sockaddr_in addr;

socklen_t socklen = sizeof(addr);

if (getsockname(sock, (struct sockaddr*)&addr, &socklen) == 0)

localIp = inet_ntoa(addr.sin_addr);

getHttpString(http, localIp.c_str(), path, method, clen);

size_t len;

char *buf = _response.buffer(len);

if (len < http.size() + clen)

return -3;

strcpy(buf, http.c_str());

memcpy(buf + http.size(), content, clen);

if ((size_t)send(sock, buf, http.size() + clen, MSG_NOSIGNAL) != http.size() + clen)

return -2;

struct timeval timeout = { HTTP_SESSION_TIMEOUT / 1000, (HTTP_SESSION_TIMEOUT % 1000) * 1000 };

while (1)

{

fd_set rdfds;

int n;

FD_ZERO(&rdfds);

FD_SET(sock, &rdfds);

if ((n = select(sock + 1, &rdfds, NULL, NULL, &timeout)) < 0)

break;

if (n > 0)

{

buf = _response.buffer(len);

n = recv(sock, buf, len, 0);

}

if ((n <= 0) || !_response.parse(n))

break;

timeout = { HTTP_SESSION_TIMEOUT2 / 1000, (HTTP_SESSION_TIMEOUT2 % 1000) * 1000 };

}

return _response.getHttpStatus();

}

};

#endif

/*
  httpclient.cpp - HTTP Client Library for Linux/Windows/Arduino

  Copyright (c) 2023 Sasapea's Lab. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#include "httpclient.h"

const char *HttpHeader::HTTP_METHOD_GET      = "GET";
const char *HttpHeader::HTTP_METHOD_POST     = "POST";
const char *HttpHeader::HTTP_HOST            = "Host";
const char *HttpHeader::HTTP_CONNECTION      = "Connection";
const char *HttpHeader::HTTP_CONTENT_TYPE    = "Content-Type";
const char *HttpHeader::HTTP_CONTENT_LENGTH  = "Content-Length";
const char *HttpHeader::HTTP_SET_COOKIE      = "Set-Cookie";
const char *HttpHeader::HTTP_COOKIE          = "Cookie";
const char *HttpHeader::HTTP_MIME_TEXT_HTML  = "text/html";
const char *HttpHeader::HTTP_MIME_TEXT_PLAIN = "text/plain";
const char *HttpHeader::HTTP_LF              = "\r\n";

httpclient.cpp - HTTP Client Library for Linux/Windows/Arduino

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#include "httpclient.h"

const char *HttpHeader::HTTP_METHOD_GET = "GET";

const char *HttpHeader::HTTP_METHOD_POST = "POST";

const char *HttpHeader::HTTP_HOST = "Host";

const char *HttpHeader::HTTP_CONNECTION = "Connection";

const char *HttpHeader::HTTP_CONTENT_TYPE = "Content-Type";

const char *HttpHeader::HTTP_CONTENT_LENGTH = "Content-Length";

const char *HttpHeader::HTTP_SET_COOKIE = "Set-Cookie";

const char *HttpHeader::HTTP_COOKIE = "Cookie";

const char *HttpHeader::HTTP_MIME_TEXT_HTML = "text/html";

const char *HttpHeader::HTTP_MIME_TEXT_PLAIN = "text/plain";

const char *HttpHeader::HTTP_LF = "\r\n";

/*
  crypt.h - Crypt Library for MBEDTLS

  Copyright (c) 2023 Sasapea's Lab. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#pragma once

#include <string.h>
#include <stdlib.h>
#include <time.h>
#include "mbedtls/entropy.h"
#include "mbedtls/ctr_drbg.h"
#include "mbedtls/cipher.h"
#include "mbedtls/pk.h"
#include "libb64/cencode.h"
#include "libb64/cdecode.h"
#include "debug.h"

#define CRYPT_RANDOM_BUGFIX 1

class Crypt
{
  public:

    typedef enum
    {
      CIPHER_ID_NONE = MBEDTLS_CIPHER_ID_NONE,
      CIPHER_ID_NULL = MBEDTLS_CIPHER_ID_NULL,
      CIPHER_ID_AES  = MBEDTLS_CIPHER_ID_AES,
      CIPHER_ID_DES  = MBEDTLS_CIPHER_ID_DES
    } CIPHER_ID;

    typedef enum
    {
      CIPHER_MODE_NONE   = MBEDTLS_MODE_NONE,
      CIPHER_MODE_ECB    = MBEDTLS_MODE_ECB,
      CIPHER_MODE_CBC    = MBEDTLS_MODE_CBC,
      CIPHER_MODE_CFB    = MBEDTLS_MODE_CFB,
      CIPHER_MODE_OFB    = MBEDTLS_MODE_OFB,
      CIPHER_MODE_CTR    = MBEDTLS_MODE_CTR,
      CIPHER_MODE_GCM    = MBEDTLS_MODE_GCM,
      CIPHER_MODE_STREAM = MBEDTLS_MODE_STREAM,
      CIPHER_MODE_CCM    = MBEDTLS_MODE_CCM
    } CIPHER_MODE;

    typedef enum
    {
      PADDING_PKCS7         = MBEDTLS_PADDING_PKCS7,
      PADDING_ONE_AND_ZEROS = MBEDTLS_PADDING_ONE_AND_ZEROS,
      PADDING_ZEROS_AND_LEN = MBEDTLS_PADDING_ZEROS_AND_LEN,
      PADDING_ZEROS         = MBEDTLS_PADDING_ZEROS,
      PADDING_NONE          = MBEDTLS_PADDING_NONE
    } PADDING;

    typedef enum
    {
      MD_NONE      = MBEDTLS_MD_NONE,
      // MD_MD2       = MBEDTLS_MD_MD2,
      // MD_MD4       = MBEDTLS_MD_MD4,
      MD_MD5       = MBEDTLS_MD_MD5,
      MD_SHA1      = MBEDTLS_MD_SHA1,
      MD_SHA224    = MBEDTLS_MD_SHA224,
      MD_SHA256    = MBEDTLS_MD_SHA256,
      MD_SHA384    = MBEDTLS_MD_SHA384,
      MD_SHA512    = MBEDTLS_MD_SHA512,
      MD_RIPEMD160 = MBEDTLS_MD_RIPEMD160
    } MD;

    typedef enum
    {
      OPERATION_NONE    = MBEDTLS_OPERATION_NONE,
      OPERATION_DECRYPT = MBEDTLS_DECRYPT,
      OPERATION_ENCRYPT = MBEDTLS_ENCRYPT
    } OPERATION;

    Crypt(CIPHER_ID cipher_id = CIPHER_ID_AES, int key_bitlen = 128, CIPHER_MODE cipher_mode = CIPHER_MODE_CBC, PADDING padding_mode = PADDING_PKCS7) :
    _key_bitlen(key_bitlen),
    _cipher_id((mbedtls_cipher_id_t)cipher_id),
    _cipher_mode((mbedtls_cipher_mode_t)cipher_mode),
    _padding_mode((mbedtls_cipher_padding_t)padding_mode)
    {
    }

    virtual ~Crypt(void)
    {
    }

    bool random(unsigned char *output, size_t olen, const unsigned char *custom = nullptr, size_t len = 0)
    {
#if CRYPT_RANDOM_BUGFIX
      srand(time(NULL));
      while (olen)
      {
        unsigned short n = rand();
        for (size_t i = 0; i < sizeof(n); ++i)
        {
          *output++ = n;
          if (--olen == 0)
            break;
          n >>= 8;
        }
      }
      return true;
#else
      int status;
      mbedtls_ctr_drbg_context ctr_drbg;
      mbedtls_entropy_context  entropy;
      mbedtls_entropy_init(&entropy);
      mbedtls_ctr_drbg_init(&ctr_drbg);
      if ((status = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, custom, len)) != 0)
        Debug::printf(__FILE__, __LINE__, "mbedtls_ctr_drbg_seed(%p, %p, %p, %p, %zu) = %d\n", &ctr_drbg, mbedtls_entropy_func, &entropy, custom, len, status);
      else if ((status = mbedtls_ctr_drbg_random(&ctr_drbg, output, olen)) != 0)
        Debug::printf(__FILE__, __LINE__, "mbedtls_ctr_drbg_random(%p, %p, %zu) = %d\n", &ctr_drbg, output, olen, status);
      mbedtls_ctr_drbg_free(&ctr_drbg);
      mbedtls_entropy_free(&entropy);
      return status == 0;
#endif
    }

    size_t digest(MD md_type, const unsigned char *input, size_t ilen, unsigned char *output)
    {
      int status = 0;
      const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type((mbedtls_md_type_t)md_type);
      size_t olen = mbedtls_md_get_size(md_info);
      if (input && output)
      {
        if ((status = mbedtls_md(md_info, input, ilen, output)) != 0)
          Debug::printf(__FILE__, __LINE__, "mbedtls_md(%p, %p, %zu, %p) = %d\n", md_info, input, ilen, output, status);
      }
      return status == 0 ? olen : 0;
    }

    size_t cipher(OPERATION operation, const unsigned char *input, size_t ilen, unsigned char *output, const unsigned char *key, const unsigned char *iv)
    {
      int status;
      size_t olen = 0;
      size_t iv_len = _key_bitlen >> 3;
      mbedtls_cipher_context_t cipher;
      mbedtls_cipher_init(&cipher);
      const mbedtls_cipher_info_t *cipher_info = mbedtls_cipher_info_from_values(_cipher_id, _key_bitlen, _cipher_mode);
      if ((status = mbedtls_cipher_setup(&cipher, cipher_info)) != 0)
        Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_setup(%p, %p) = %d\n", &cipher, cipher_info, status);
      else if ((status = mbedtls_cipher_set_padding_mode(&cipher, _padding_mode)) != 0)
        Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_set_padding_mode(%p, %d) = %d\n", &cipher, _padding_mode, status);
      else if ((status = mbedtls_cipher_setkey(&cipher, key, _key_bitlen, (mbedtls_operation_t)operation)) != 0)
        Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_setkey(%p, %p, %zu, %d) = %d\n", &cipher, key, _key_bitlen, operation, status);
      else if ((status = mbedtls_cipher_crypt(&cipher, iv, iv_len, input, ilen, output, &olen)) != 0)
        Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_crypt(%p, %p, %zu, %p, %zu, %p, %p) = %d\n", &cipher, iv, iv_len, input, ilen, output, &olen, status);
      mbedtls_cipher_free(&cipher);
      return olen;
    }

    int base64Encode(const char *input, int ilen, char *output)
    {
      base64_encodestate state;
      base64_init_encodestate(&state);
      ilen =  base64_encode_block(input, ilen, output, &state);
      return ilen + base64_encode_blockend(output + ilen, &state);
    }

    int base64Decode(const char *input, int ilen, char *output)
    {
      base64_decodestate state;
      base64_init_decodestate(&state);
      return base64_decode_block(input, ilen, output, &state);
    }

  private:

      int                      _key_bitlen;
      mbedtls_cipher_id_t      _cipher_id;
      mbedtls_cipher_mode_t    _cipher_mode;
      mbedtls_cipher_padding_t _padding_mode;
};

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

crypt.h - Crypt Library for MBEDTLS

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#pragma once

#include <string.h>

#include <stdlib.h>

#include <time.h>

#include "mbedtls/entropy.h"

#include "mbedtls/ctr_drbg.h"

#include "mbedtls/cipher.h"

#include "mbedtls/pk.h"

#include "libb64/cencode.h"

#include "libb64/cdecode.h"

#include "debug.h"

#define CRYPT_RANDOM_BUGFIX 1

class Crypt

{

public:

typedef enum

{

CIPHER_ID_NONE = MBEDTLS_CIPHER_ID_NONE,

CIPHER_ID_NULL = MBEDTLS_CIPHER_ID_NULL,

CIPHER_ID_AES = MBEDTLS_CIPHER_ID_AES,

CIPHER_ID_DES = MBEDTLS_CIPHER_ID_DES

} CIPHER_ID;

typedef enum

{

CIPHER_MODE_NONE = MBEDTLS_MODE_NONE,

CIPHER_MODE_ECB = MBEDTLS_MODE_ECB,

CIPHER_MODE_CBC = MBEDTLS_MODE_CBC,

CIPHER_MODE_CFB = MBEDTLS_MODE_CFB,

CIPHER_MODE_OFB = MBEDTLS_MODE_OFB,

CIPHER_MODE_CTR = MBEDTLS_MODE_CTR,

CIPHER_MODE_GCM = MBEDTLS_MODE_GCM,

CIPHER_MODE_STREAM = MBEDTLS_MODE_STREAM,

CIPHER_MODE_CCM = MBEDTLS_MODE_CCM

} CIPHER_MODE;

typedef enum

{

PADDING_PKCS7 = MBEDTLS_PADDING_PKCS7,

PADDING_ONE_AND_ZEROS = MBEDTLS_PADDING_ONE_AND_ZEROS,

PADDING_ZEROS_AND_LEN = MBEDTLS_PADDING_ZEROS_AND_LEN,

PADDING_ZEROS = MBEDTLS_PADDING_ZEROS,

PADDING_NONE = MBEDTLS_PADDING_NONE

} PADDING;

typedef enum

{

MD_NONE = MBEDTLS_MD_NONE,

// MD_MD2 = MBEDTLS_MD_MD2,

// MD_MD4 = MBEDTLS_MD_MD4,

MD_MD5 = MBEDTLS_MD_MD5,

MD_SHA1 = MBEDTLS_MD_SHA1,

MD_SHA224 = MBEDTLS_MD_SHA224,

MD_SHA256 = MBEDTLS_MD_SHA256,

MD_SHA384 = MBEDTLS_MD_SHA384,

MD_SHA512 = MBEDTLS_MD_SHA512,

MD_RIPEMD160 = MBEDTLS_MD_RIPEMD160

} MD;

typedef enum

{

OPERATION_NONE = MBEDTLS_OPERATION_NONE,

OPERATION_DECRYPT = MBEDTLS_DECRYPT,

OPERATION_ENCRYPT = MBEDTLS_ENCRYPT

} OPERATION;

Crypt(CIPHER_ID cipher_id = CIPHER_ID_AES, int key_bitlen = 128, CIPHER_MODE cipher_mode = CIPHER_MODE_CBC, PADDING padding_mode = PADDING_PKCS7) :

_key_bitlen(key_bitlen),

_cipher_id((mbedtls_cipher_id_t)cipher_id),

_cipher_mode((mbedtls_cipher_mode_t)cipher_mode),

_padding_mode((mbedtls_cipher_padding_t)padding_mode)

{

}

virtual ~Crypt(void)

{

}

bool random(unsigned char *output, size_t olen, const unsigned char *custom = nullptr, size_t len = 0)

{

#if CRYPT_RANDOM_BUGFIX

srand(time(NULL));

while (olen)

{

unsigned short n = rand();

for (size_t i = 0; i < sizeof(n); ++i)

{

*output++ = n;

if (--olen == 0)

break;

n >>= 8;

}

return true;

#else

int status;

mbedtls_ctr_drbg_context ctr_drbg;

mbedtls_entropy_context entropy;

mbedtls_entropy_init(&entropy);

mbedtls_ctr_drbg_init(&ctr_drbg);

if ((status = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, custom, len)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_ctr_drbg_seed(%p, %p, %p, %p, %zu) = %d\n", &ctr_drbg, mbedtls_entropy_func, &entropy, custom, len, status);

else if ((status = mbedtls_ctr_drbg_random(&ctr_drbg, output, olen)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_ctr_drbg_random(%p, %p, %zu) = %d\n", &ctr_drbg, output, olen, status);

mbedtls_ctr_drbg_free(&ctr_drbg);

mbedtls_entropy_free(&entropy);

return status == 0;

#endif

}

size_t digest(MD md_type, const unsigned char *input, size_t ilen, unsigned char *output)

{

int status = 0;

const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type((mbedtls_md_type_t)md_type);

size_t olen = mbedtls_md_get_size(md_info);

if (input && output)

{

if ((status = mbedtls_md(md_info, input, ilen, output)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_md(%p, %p, %zu, %p) = %d\n", md_info, input, ilen, output, status);

}

return status == 0 ? olen : 0;

}

size_t cipher(OPERATION operation, const unsigned char *input, size_t ilen, unsigned char *output, const unsigned char *key, const unsigned char *iv)

{

int status;

size_t olen = 0;

size_t iv_len = _key_bitlen >> 3;

mbedtls_cipher_context_t cipher;

mbedtls_cipher_init(&cipher);

const mbedtls_cipher_info_t *cipher_info = mbedtls_cipher_info_from_values(_cipher_id, _key_bitlen, _cipher_mode);

if ((status = mbedtls_cipher_setup(&cipher, cipher_info)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_setup(%p, %p) = %d\n", &cipher, cipher_info, status);

else if ((status = mbedtls_cipher_set_padding_mode(&cipher, _padding_mode)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_set_padding_mode(%p, %d) = %d\n", &cipher, _padding_mode, status);

else if ((status = mbedtls_cipher_setkey(&cipher, key, _key_bitlen, (mbedtls_operation_t)operation)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_setkey(%p, %p, %zu, %d) = %d\n", &cipher, key, _key_bitlen, operation, status);

else if ((status = mbedtls_cipher_crypt(&cipher, iv, iv_len, input, ilen, output, &olen)) != 0)

Debug::printf(__FILE__, __LINE__, "mbedtls_cipher_crypt(%p, %p, %zu, %p, %zu, %p, %p) = %d\n", &cipher, iv, iv_len, input, ilen, output, &olen, status);

mbedtls_cipher_free(&cipher);

return olen;

}

int base64Encode(const char *input, int ilen, char *output)

{

base64_encodestate state;

base64_init_encodestate(&state);

ilen = base64_encode_block(input, ilen, output, &state);

return ilen + base64_encode_blockend(output + ilen, &state);

}

int base64Decode(const char *input, int ilen, char *output)

{

base64_decodestate state;

base64_init_decodestate(&state);

return base64_decode_block(input, ilen, output, &state);

}

private:

int _key_bitlen;

mbedtls_cipher_id_t _cipher_id;

mbedtls_cipher_mode_t _cipher_mode;

mbedtls_cipher_padding_t _padding_mode;

};

/*
  debug.h - Debug Utility

  Copyright (c) 2023 Sasapea's Lab. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#pragma once

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

class Debug
{
  private:

    static bool _output;

  public:

    static bool enable(void)
    {
      return _output;
    }

    static void enable(bool output)
    {
      _output = output;
    }

    static void printf(const char *file, int line, const char *format,...)
    {
      if (_output)
      {
        const char *p = strrchr(file, '/');
        const char *q = strrchr(file, '\\');
        if (p < q)
          p = q;
        fprintf(stderr, "[%s:%d] ", p ? p + 1 : file, line);
        va_list ap;
        va_start(ap, format);
        vfprintf(stderr, format, ap);
        va_end(ap);
      }
    }

    static void printf(const char *format,...)
    {
      if (_output)
      {
        va_list ap;
        va_start(ap, format);
        vfprintf(stderr, format, ap);
        va_end(ap);
      }
    }

    static void printbytes(const unsigned char *buf, size_t len)
    {
      if (_output)
      {
        while (len--)
          fprintf(stderr, "%02X", *buf++);
        fprintf(stderr, "\n");
      }
    }
};

debug.h - Debug Utility

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#pragma once

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

class Debug

{

private:

static bool _output;

public:

static bool enable(void)

{

return _output;

}

static void enable(bool output)

{

_output = output;

}

static void printf(const char *file, int line, const char *format,...)

{

if (_output)

{

const char *p = strrchr(file, '/');

const char *q = strrchr(file, '\\');

if (p < q)

p = q;

fprintf(stderr, "[%s:%d] ", p ? p + 1 : file, line);

va_list ap;

va_start(ap, format);

vfprintf(stderr, format, ap);

va_end(ap);

}

static void printf(const char *format,...)

{

if (_output)

{

va_list ap;

va_start(ap, format);

vfprintf(stderr, format, ap);

va_end(ap);

}

static void printbytes(const unsigned char *buf, size_t len)

{

if (_output)

{

while (len--)

fprintf(stderr, "%02X", *buf++);

fprintf(stderr, "\n");

}

};

/*
  debug.cpp - Debug Utility

  Copyright (c) 2023 Sasapea's Lab. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#include "debug.h"

bool Debug::_output = true;

debug.cpp - Debug Utility

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#include "debug.h"

bool Debug::_output = true;

カテゴリー: M5StickC

TP-LINK Tapo P105/P110M のKlapプロトコル対応版 (ESP32)