2023-12-242024-03-18 投稿者: researcher

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

お待たせしました！って誰も待ってないか．．．v(-_-;)

P105/P110MのKlapプロトコル(最新ファーム)対応版を作ってみた。

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

※ESP32対応版は下記を参照。
TP-LINK Tapo P110M のKlapプロトコル対応版 (ESP32)

ちなみにKlapプロトコル専用なので古いファームには下記投稿のコマンドを使用する必要がある。
TP-LINK TAPO P100/P105/P110をLinux/Windowsから直接制御する

【既知の問題】
現状ではセッション開始後の最初のリクエストがときどきHTTP-403エラーになるという不具合が残されている。セッション開始のためのハンドシェーク処理は成功するもののその後のリクエストがなぜかエラーになってしまいハンドシェークからやり直さないとリカバリーできないという現象でリクエストが成功した場合にはその後も問題はない。時間をかけて調べてみたが今のところ原因不明．．．orz

【セッション復元機能】
試験では通常０～２回、まれに最大５回までのリトライで成功してはいるがコマンド実行毎に新たにセッションを開始するとリトライにより実行時間にかなり悪影響を与えてしまう。

改善策としてセッション情報を保存／復元できるようにしてみたところ効果バツグン。通常ならコマンド実行毎に３回の通信が必要なところセッション復元できれば１回の通信で済むから３倍速となる。

セッション情報は次の場所に”tapo2-xxx.xxx.xxx.xxx”の名前でデバイス毎に保存され間違って削除されても問題はない。

linux: /var/tmp
windows: TEMP或いはTMP環境変数が示すフォルダ

【参照ライブラリ】
libb64は変更なし。（というか変更してはいけない）
json-developを3.11.3にアップデート。
mbedtlsを2.28.6にアップデート。

※mbedtlsの現在の最新はV3系であるが環境依存ファイルを生成するためにpythonやperlが必須となってしまったため断念しV2系の最新にアップデート。

【コンパイルの事前準備】
適当なフォルダにsources.zipを展開する。展開されたmbedtls-2.28.6フォルダに入って次のコマンドを実行する。

linux: make no_test
windows(MSYS2-MinGW): make CC=gcc no_test WINDOWS=1

【コンパイル】
展開先フォルダでmakeを実行する。再コンパイルするときはmakeする前にmake cleanを実行する。

【ダウンロード】
sources.zip
tapo2.exe (windows-x64)

【修正履歴】
2024-03-18
HiroさんよりCrypt::random()が落ちるというフィードバックあり。ググッてみたらmbedtlsのmbedtls_ctr_drbg_seed()にメモリリークの可能性があるらしいのでとりあえずrand()関数による実装に変更。おまけとしてVisual C++でもコンパイルできるようなコードに修正してみた．．．試してないけど。(-_-;)

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
httpclint.hが、ごちゃごちゃしてだいぶ見苦しなってきたので整理整頓＆修正を行った。

2024-01-08
細かな改良。

2023-12-28
HTTP処理を改良しリトライの処理時間を短縮してみた。リトライしたのがわからないぐらいにはなった。かな。

2023-12-26
軽微なバグを修正。RaspberryPi/Ubuntu/Windowsで動作を確認。

2023-12-25
セッションタイムアウト値が間違っていたので修正。

【ソースコード】

/*
  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 <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 download. (https://github.com/nlohmann/json)
#include "nlohmann/json.hpp"
using json = nlohmann::json;  // for convenience

#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(void)
    {
    }

    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);

#if !(TAPO_DEBUG & 2)
      // load session data
      loadSession(deviceIp);
#endif

      // support for winsock
      if (!_http.startup())
      {
        Debug::printf(__FILE__, __LINE__, "HttpClient::startup() failed.\n");
        return false;
      }
      return true;
    }

    void end(void)
    {
      // save session data
      saveSession();
      endSession();
      // support for winsock
      _http.cleanup();
    }

    bool setDeviceOn(bool on)
    {
      json 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"].get<int>();
        if ((status != 0) && (status != -1301))
          Debug::printf(__FILE__, __LINE__, "TAPO Error Code (%d)\n", status);
        else
          return true;
      }
      return false;
    }

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

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

  private:

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

    bool request(json& message, json& 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 = message.dump();
          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 = json::parse(_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));
    }

    void loadSession(const char *deviceIp)
    {
      const char *temp;
#if __linux__
      temp = "/var/tmp";
#else
      const char *TEMPNAMES[] = { "TEMP", "TMP" };
      for (size_t i = 0; i < sizeof(TEMPNAMES) / sizeof(TEMPNAMES[0]); ++i)
      {
        temp = getenv(TEMPNAMES[i]);
        if (temp && *temp)
          break;
      }
#endif
      _sessionFile = temp && *temp ? temp : ".";
      _sessionFile += "/tapo2-";
      _sessionFile += deviceIp;
      FILE *fp;
      if ((fp = fopen(_sessionFile.c_str(), "rb")))
      {
        fread(&_session, 1, sizeof(_session), fp);
        fclose(fp);
      }
    }

    void saveSession(void)
    {
      FILE *fp;
      if ((fp = fopen(_sessionFile.c_str(), "wb")))
      {
        fwrite(&_session, 1, sizeof(_session), fp);
        fclose(fp);
      }
    }

    unsigned long millis(void)
    {
#if defined(_WIN32) || defined(_WIN64)
      return GetTickCount();
#else
      struct timespec ts;
      clock_gettime(CLOCK_MONOTONIC, &ts);
      return ((unsigned long long)ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
#endif
    }

    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   _sessionFile;
    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

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

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 <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 download. (https://github.com/nlohmann/json)

#include "nlohmann/json.hpp"

using json = nlohmann::json; // for convenience

#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(void)

{

}

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);

#if !(TAPO_DEBUG & 2)

// load session data

loadSession(deviceIp);

#endif

// support for winsock

if (!_http.startup())

{

Debug::printf(__FILE__, __LINE__, "HttpClient::startup() failed.\n");

return false;

}

return true;

}

void end(void)

{

// save session data

saveSession();

endSession();

// support for winsock

_http.cleanup();

}

bool setDeviceOn(bool on)

{

json 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"].get<int>();

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

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

else

return true;

}

return false;

}

bool getDeviceInfo(std::string &info)

{

json payload, response;

payload["method"] = "get_device_info";

if (request(payload, response))

{

int status = response["error_code"].get<int>();

if (status)

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

else

{

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

std::string str;

str = response["result"]["ssid"].dump();

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

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

str = response["result"]["nickname"].dump();

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

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

info = response["result"].dump();

/* for P105 */

str = response["result"]["mac"].dump();

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

return true;

}

info.clear();

return false;

}

bool getEnergyUsage(std::string &info)

{

json payload, response;

payload["method"] = "get_energy_usage";

if (request(payload, response))

{

int status = response["error_code"].get<int>();

if (status)

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

else

{

info = response["result"].dump();

return true;

}

info.clear();

return false;

}

private:

const char *getTerminalUUID(void)

{

if (!_session.terminalUUID[0])

{

/* for P105 */

std::string info;

getDeviceInfo(info);

}

return _session.terminalUUID;

}

bool request(json& message, json& 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 = message.dump();

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 = json::parse(_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));

}

void loadSession(const char *deviceIp)

{

const char *temp;

#if __linux__

temp = "/var/tmp";

#else

const char *TEMPNAMES[] = { "TEMP", "TMP" };

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

{

temp = getenv(TEMPNAMES[i]);

if (temp && *temp)

break;

}

#endif

_sessionFile = temp && *temp ? temp : ".";

_sessionFile += "/tapo2-";

_sessionFile += deviceIp;

FILE *fp;

if ((fp = fopen(_sessionFile.c_str(), "rb")))

{

fread(&_session, 1, sizeof(_session), fp);

fclose(fp);

}

void saveSession(void)

{

FILE *fp;

if ((fp = fopen(_sessionFile.c_str(), "wb")))

{

fwrite(&_session, 1, sizeof(_session), fp);

fclose(fp);

}

unsigned long millis(void)

{

#if defined(_WIN32) || defined(_WIN64)

return GetTickCount();

#else

struct timespec ts;

clock_gettime(CLOCK_MONOTONIC, &ts);

return ((unsigned long long)ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);

#endif

}

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 _sessionFile;

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(_WIN32) || defined(_WIN64)

#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(_WIN32) || defined(_WIN64)

#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

  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

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;

TARGET = tapo2

OBJS += tapo2.o
OBJS += httpclient.o
OBJS += debug.o
OBJS += ./libb64/cencode.o
OBJS += ./libb64/cdecode.o

INCLUDES += -I.
INCLUDES += -I./json-develop-3.11.3/include
INCLUDES += -I./mbedtls-2.28.6/include

LIBS += -L./mbedtls-2.28.6/library
LIBS += -lmbedcrypto
LIBS += -lm
ifeq ($(OS),Windows_NT)
	LIBS += -lwsock32
	LIBS += -lws2_32
endif
LIBS += -static -lstdc++

CFLAGS   += $(INCLUDES) -Wall
CXXFLAGS += $(CFLAGS) -std=c++11 -Wno-psabi
LDFLAGS =

.c.o:
	$(CC) $(CFLAGS) -c $< -o $(<:.c=.o)

.cpp.o:
	$(CXX) $(CXXFLAGS) -c $< -o $(<:.cpp=.o)

$(TARGET): $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)

all: $(TARGET)

.PHONY: clean

clean:
	$(RM) $(TARGET) $(OBJS)

TARGET = tapo2

OBJS += tapo2.o

OBJS += httpclient.o

OBJS += debug.o

OBJS += ./libb64/cencode.o

OBJS += ./libb64/cdecode.o

INCLUDES += -I.

INCLUDES += -I./json-develop-3.11.3/include

INCLUDES += -I./mbedtls-2.28.6/include

LIBS += -L./mbedtls-2.28.6/library

LIBS += -lmbedcrypto

LIBS += -lm

ifeq ($(OS),Windows_NT)

LIBS += -lwsock32

LIBS += -lws2_32

endif

LIBS += -static -lstdc++

CFLAGS += $(INCLUDES) -Wall

CXXFLAGS += $(CFLAGS) -std=c++11 -Wno-psabi

LDFLAGS =

.c.o:

$(CC) $(CFLAGS) -c $< -o $(<:.c=.o)

.cpp.o:

$(CXX) $(CXXFLAGS) -c $< -o $(<:.cpp=.o)

$(TARGET): $(OBJS)

$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)

all: $(TARGET)

.PHONY: clean

clean:

$(RM) $(TARGET) $(OBJS)

“TP-LINK Tapo P105/P110M のKlapプロトコル対応版 (Windows/Linux)” への22件の返信

hapi より:

2024-01-10 04:25

おお！素晴らしいソフトウェアを見つけた！と思い
早速使わせていただきましが。が…

P105を使っています。
ファームウェアは
1.4.1 Build 20231103 Rel. 36519
です。

tapo.exe だと
TAPO Status: [1003]
でダメなようでした。

tapo2.exe(2024-01-09) だと
[tapo2.h:309] HttpClient::request(292, “POST”, “app/handshake2”, 000000c8略, 32) = -1
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -1
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -1
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -1
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -2
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -2
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -2
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -2
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -2
[tapo2.h:246] HttpClient::request(292, “POST”, “app/handshake1”, 00007ff6略, 16) = -2
と表示され、ダメなようでした。
(何の数字かかりませんが念の為、数値を略しました。)

このファームウェアもKlapとやらなのでしょうか？
何とか動作させることはできませんでしょうか？

( https://github.com/achetronic/tapogo も何でか動かないし…泣)

返信
1. researcher より:
  
  2024-01-10 08:29
  
  コメントありがとうございます。
  P105の最新ファームでは試したことはありませんが、tapo.exeで1003エラーが出るということは新しいプロトコル(Klap)に変更されたものと思われます。
  調べてみると日本以外では数年前からKasa/Tapoとも既に変更されているみたいですが、なぜか日本だけ？が昨年から変更されつつあるようです。
  P110Mでも原因不明なエラーは出ますがリトライにより解消されるとの判断から公開したのですがまだまだ何かあるようですね．．．
  handshake1/handshake2での-1エラーはデバイス側からいきなり接続を切られると発生します。デバイスをコンセントから抜き差しすると正常に動作するようになることがありますが、それはさておき現状ではリトライ中の接続断には対応できていないのでそのへんの改良が必要みたいですね。検討してみたいと思いますのでお待ちください。
  
  返信
2. researcher より:
  
  2024-01-10 13:26
  
  手持ちのP105のファームを”1.4.1 Build 20231103 Rel. 36519″にアッブデートし、ついさきほど公開した最新版で試したところうまく動作しました。
  P110は通信毎に接続を切らないタイプのサーバーですがP105は通信毎に接続を切るタイプのサーバーですのでどちらにも対応できるようにしてみました。
  試してみてください。
  
  返信
hapi より:

2024-01-11 18:14

超早の対応、ありがとうございます！
P105
1.4.1 Build 20231103 Rel. 36519
にて一応動作しました。

なのですがどうも、一度でもAndroidのTapoアプリ(3.1.605)からON/OFFを行うと、以降 tapo2.exe にて
[tapo2.h:105] TAPO Error Code (-1012)
というエラーが出て、ON/OFF操作できなくなってしまいました。

その後、P105をコンセントプラグから一度抜いて挿し直すと、再び tapo2.exe にてON/OFF可能になります。

なお同じ上記ファームウェアの3台のP105で試しましたが、どれも同じ動作でした。
ちなみにON/OFF操作できない状態でもINFOは取れます。

他の方はどうでしょうか？

返信
1. researcher より:
  
  2024-01-11 18:30
  
  試して頂いてありがとうございます。
  -1012はP105の仕様みたいで２分経過するまで待つ必要があります。誤動作ではないため回避方法はありません。
  また、動作には問題ないようなのですがP105はＨＷの処理性能が低すぎて内部処理が間に合わない状況になると-1301エラーが返されることがあります。
  それらが気になるようなら安定して動作するP110Mをお勧めします。
  
  返信
2. researcher より:
  
  2024-01-11 18:53
  
  ごめんなさい。間違ってました。
  もう一度動作確認してみたらtapoアプリから操作後でも問題ありませんでした。
  本日、気になる点があり何度か更新＆ＵＰしたため途中の版を試されたのだと思います。
  再度ＤＬして試してみてください。
  
  返信
3. researcher より:
  
  2024-01-11 18:58
  
  たびたびすいません。
  TAPOアプリ操作後に-1012が出ることもあるようです。
  条件はわかりませんが．．．
  
  返信
Hiro より:

2024-01-13 18:15

はじめまして。ずっと前からお礼を言わななくちゃと思っていました。
前のプロトコルからありがたく利用させて頂いています。
本当に、待っていました！です。
VisualStudio2022に移植して、1/13版にて複数端末からP105を制御できました。
ファームは1.4.1 Build 20231103 Rel. 36519です。
うちにはP105が10台以上あって生活機能の一部になっているのでこの神ツールが無ければ途方に暮れるところでした。ありがとうございます。
今後のキャッチアップにもご期待しております。

返信
1. researcher より:
  
  2024-01-13 18:50
  
  コメント＆使って頂いてありがとうございます。
  P110Mのほうがいいですよ！とお勧めしたいところですがP105が10台とは．．．それだけ数があると買い替えるのも大変ですね。P105はクセがありすぎるので個人的には安心して使えるHS105を今でもメインで使っているのですが入手が難しくなったのと電力モニターが可能になるといろいろ面白そうなことができそうなので対応してみました。クラウドベースだと停電などインターネットが使えない緊急時に役に立たないのが辛すぎるので個人的に調べて作ってみたのが始まりです。何かのお役に立てれば幸いです。
  
  返信
kuny より:

2024-03-12 23:44

ネットの海をさまよっていましたところ発見。
今、自作の状況をモニターできるツールを自作し提案す。
手始めにBルートから自宅の総消費電力を引っ張ってWEBアプリで表示しており、温湿度などとも連動したいな…と思っている次第です。時間から気温から消費電力から、直近のゴミの日から何でもわかるツールを目指しています。

現状全コンセントの合計値しか取れないので、エアコンとネットワーク機器・PCなどのコンセントは個別で計測し表示したいと思い、だれかP110Mを解析してる方いないかな～と探したところドンピシャ。まさに神に出会えた気分です。

お給料入ったら何台か購入して試してみようと思います。ありがとうございます。頑張ってPythonに移植できたらいいのですが。

返信
1. researcher より:
  
  2024-03-13 07:44
  
  コメントありがとうございます。
  なにやら楽しそうなことをされているようですね。
  
  TP-LinkのプロトコルについてはK4CZP3Rという方がHAのために解析したのをpythonで公開されていて現在公開されているpython以外のプログラムの原本となっているようですのでpythonがお望みであれば元サイトを参考にされたほうが良いかもです。但し、P110Mで動作することは確認していますがP105(klap)には非対応です。
  
  https://github.com/petretiandrea/plugp100
  
  何かの参考になれば幸いです。頑張ってください！
  
  返信
  1. kuny より:
    
    2024-03-17 19:53
    
    すぐにお返事いただいていたのにすみません。巡回が遅くなってしまいました。なんとさらに元ネタが公開されているとは知りませんでした。こちらもさっそく、チェックしてみます！
    
    とりあえず、Bルートから瞬間消費電力と積算電力量を引っこ抜いてpostgresqlに突っ込むところはなんとかなり、次はP110Mかゴミ捨日表示機能の実装か、というところです。
    
    最終的に、ネットの海のどなたかが解析しているClova deskに表示できれば面白そうです。また来ます！
    
    返信
Hiro より:

2024-03-17 13:29

👆のVS2022に移植した者です。お久しぶりです。少しフィードバックを。
しばらく快調だったのですがある時からP105を制御できなくなり、調べると最初のhandshake1の中、
　_crypt.random(_localSeed, sizeof(_localSeed));
のところで強制終了が起こっていました。それからなぜか我が家の環境では再現100％なのです。
それで、特に意図せず上記をコメントアウトしたところ、何事もなかったかのように動作している現在です。
(なんらかの乱数初期化はされていないのでしょうが・・・)
お心当たりはあったりしますでしょうか？

お勧めのP110M導入してみました。確かにこれは便利で楽しいです！
L510も加え、今のところ上記応急処置版ですべて制御できています。

返信
1. researcher より:
  
  2024-03-18 08:00
  
  フィードバックありがとうございます。
  　_crypt.random(_localSeed, sizeof(_localSeed));
  これはバッファをランダムな値で埋めるだけなのでコメントアウトしても動作的には何も問題はありません。セキュリティ的は弱くなるのでしょうがセッション継続中に同じシード値を再利用することを考えると気にする必要もないかと思います。そういえば開発当初によく落ちていた処理のような気もするのでmbedtlsの使い方の問題或いはバグなのかもしれませんね．．．とりあえずrandom(時刻)を使って実装しなおしても良いのですが、あとで調べてみて何かわかりましたら連絡します。
  
  返信
2. researcher より:
  
  2024-03-18 09:14
  
  ググッてみたらmbedtlsにメモリリークの可能性があるようなのでrand()関数による実装に変更しておきました。
  詳細な内容のフィードバックは大変助かります。Hiroさん、ありがとうございました。<(_ _)>
  
  返信
  1. Hiro より:
    
    2024-03-20 09:08
    
    こちらこそお早いご対応ありがとうございます。3-18版でコンパイルし、安定しています！
    なるほどどうにかして_localSeedの中をランダマイズしてやれば良いところだったのですね。
    拙宅の3機種全12台を1本で制御できて、このツールやはり最高です。主にCGI化してWEBからの制御に使わせて頂いています。
    長らくarduinoから遠ざかっていましたが、ESP32でも使ってクローズドな何かもやってみたくなります☺
    
    返信
kuny より:

2024-08-11 07:01

Hiro様ご無沙汰しております。kunyです。下記、Ubuntu 22.04上で試行しております。

かなり時間がかかってしまいましたが、自宅の電気メータからwi-sunで情報を引っこ抜いてきて、現状値・日時値・月間値・今月の推定請求額などをgrafanaで算出できるダッシュボードができてきました。各部屋の温湿度取得もswitchbot経由で対応させています。

本筋ではないですが、自作のダッシュボードは契約している電力会社のプランと毎月の燃料調整費などを反映しておりかなり高精度にできています。

このダッシュボードの最後の作りこみとして、自宅全体だけでなく電気代が嵩みそうなエアコンやサーバといった箇所の消費電力量をtapoで取得したく、mihai-dinculescu/tapoというライブラリを使ってみたいのですが全く安定しません。そこでHiroさんのソースをコンパイルして実行してみています。

./tapo2 192.168.50.81 “hoge@example.com” “Abcd123456” info といった感じで入力していますが（内容はダミー）
[tapo2.h:257] Login failed　と帰ってきます。

ダブルクオートを抜いても状況が変わらず、これはtapo側がフリーズしているのでしょうか。初歩的で申し訳ございませんがお返事頂戴できますと幸甚です。

返信
kuny より:

2024-08-11 07:03

researcher 様
kunyです。連投してしまい申し訳ございません。
宛名がHiro様となっておりました。
盆休み1日目、序盤から徹夜しており判断力がなくなっており、大変なご無礼を失礼しました。内容については先ほど投稿のとおりです。

返信
kuny より:

2024-08-11 07:11

researcher 様
kunyです。先ほど6～7時ごろに誤ってHiro様宛として投稿した内容が反映されていないようで、
改めて投稿します。

環境：Ubuntu 22.04 LTS
状況：ソースをコンパイルし実行。
./tapo2 192.168.50.81 “hoge@example.com” “Abcd123456” info （メール・PWはダミー）
[tapo2.h:257] Login failed
となりログインできません。

経緯：前回書き込みで話していたダッシュボードを作りこみました。
自宅全体の電力消費量表示・年間＆月間＆日時集計と燃料調整費を反映した
精緻な請求額シミュレーション機能を実装しました。

switchbotの温湿度取得にも対応させています。ダッシュボードの新機能として、
自宅全体ではなく特定のコンセントの消費電力量をP110Mで監視しようとしています。

試しにmihai-dinculescu/tapoというライブラリを使っています。
おそらくissueにあるバグを踏んでいるらしく安定しません。
そこでresearcher 様のプログラムを組み込む形での実装を考えております。
初歩的なエラーで恐縮ですが、こいつはP110M側が悪いのでしょうか。
徹夜で頭がボケーっとしておりますので、いったん寝ようと思います（笑

返信
1. researcher より:
  
  2024-08-11 07:28
  
  徹夜でそうとうお疲れのようですね。v(-_-;)
  徹夜なんてなんだか懐かしい気がしますが．．．って、それはともかくエラーの個所から考えられるとしたらP110Mのファームが古いままアップデートされていない、つまり古いプロトコルで動作しているのではないかということです。まずはファームのバージョンを確認してみてください。
  
  【対応ファームウェア】
  P110M: 1.1.0 Build 231009 Rel.155719 以降
  P105: 1.4.1 Build 20231103 Rel. 36519 以降
  
  返信
kuny より:

2024-08-11 11:26

researcher様
お世話になっております。kunyです。
先ほどは乱文大変失礼いたしました。
アドバイスのとおりファームアップを行ったところ、見事動作いたしました！ありがとうございます。わざとUpdateを止めておりました。

どこかで製作記事を書こうかと思っているのですが、ドキュメントは全く書いておらずという状況です。qiitaに画像だけ張ってみようかと悩んだのですが、とりあえず下記のUploadしてみました。

https://f.yourl.jp/9a20a7ec/

取り急ぎ、お礼とご報告を申し上げます！
引き続き、Lineでの通知機能などを作っていこうかなと思っています。

返信
1. researcher より:
  
  2024-08-11 12:11
  
  kuny様
  動作して良かったですね。
  それと画像見ました。デザイン・センスがない私には絶対作れないカッコいい画面ですね。v(-_-;)
  
  返信

コメントを残すコメントをキャンセル

このサイトはスパムを低減するために Akismet を使っています。コメントデータの処理方法の詳細はこちらをご覧ください。

“TP-LINK Tapo P105/P110M のKlapプロトコル対応版 (Windows/Linux)” への22件の返信

コメントを残す コメントをキャンセル

コメントを残すコメントをキャンセル