9784403662

Committed 03 Jul 2024 08:26PM UTC coverage: 96.597%. First build

Build # 9784403662

Build Type

push

github

Committed by

bblanchon

Commit Message

Initial implementation

Run Details

39 of 57 new or added lines in 2 files covered. (68.42%)

880 of 911 relevant lines covered (96.6%)

1433.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.86

/src/StreamUtils/Policies/ChunkDecodingPolicy.hpp

// StreamUtils - github.com/bblanchon/ArduinoStreamUtils
// Copyright Benoit Blanchon 2019-2024
// MIT License

#pragma once

#include <Client.h>
#include <assert.h>

namespace StreamUtils {

class ChunkDecodingPolicy {
  enum class State {
    Size,
    Extensions,
    StartCrLf,
    Body,
    Error,
  };

 public:
  int available(Stream &target) {
    if (!isInChunkBody(target))
      return 0;
    return min(target.available(), remaining_);
  }

  int read(Stream &target) {
    if (!isInChunkBody(target))
      return -1;
    int c = target.read();
    if (c >= 0)
      remaining_--;
    return c;
  }

  int peek(Stream &target) {
    if (!isInChunkBody(target))
      return -1;
    return target.peek();
  }

  size_t readBytes(Stream &target, char *buffer, size_t size) {
    if (!isInChunkBody(target))
      return 0;
    size_t n = target.readBytes(buffer, min(size, remaining_));
    remaining_ -= n;
    return n;
  }

  int read(Client &target, uint8_t *buffer, size_t size) {
    return readBytes(target, reinterpret_cast<char *>(buffer), size);
  }

 private:
  bool isInChunkBody(Stream &target) {
    while (state_ != State::Error && state_ != State::Body &&
           target.available()) {
      state_ = injestNext(target);
    }
    return state_ == State::Body;
  }

  State injestNext(Stream &target) {
    int c = target.read();
    switch (state_) {
      case State::Size:
        if (c >= '0' && c <= '9')
          return appendSizeHexDigit(c - '0');
        else if (c >= 'A' && c <= 'F')
          return appendSizeHexDigit(c - 'A' + 10);
        else if (c >= 'a' && c <= 'f')
          return appendSizeHexDigit(c - 'a' + 10);
        else if (c == '\r')
          return State::StartCrLf;
        else if (c == ' ' || c == '\t' || c == ';')
          return State::Extensions;
        else
          return State::Error;

      case State::Extensions:
        if (c == '\r')
          return State::StartCrLf;
        else
          return State::Extensions;

      case State::StartCrLf:
        if (c == '\n')
          return State::Body;
        else
          return State::Error;

      default:
        assert(false);
        return State::Error;
    }
  }

  State appendSizeHexDigit(uint8_t digit) {
    remaining_ = remaining_ * 16 + digit;
    return State::Size;
  }

  size_t min(size_t a, size_t b) {
    return a < b ? a : b;
  }

  size_t remaining_ = 0;
  State state_ = State::Size;
};

}  // namespace StreamUtils

1	// StreamUtils - github.com/bblanchon/ArduinoStreamUtils
2	// Copyright Benoit Blanchon 2019-2024
3	// MIT License
4
5	#pragma once
6
7	#include <Client.h>
8	#include <assert.h>
9
10	namespace StreamUtils {
11
12	class ChunkDecodingPolicy {
13	enum class State {
14	Size,
15	Extensions,
16	StartCrLf,
17	Body,
18	Error,
19	};
20
21	public:
22	int available(Stream &target) {	60✔
23	if (!isInChunkBody(target))	60✔
24	return 0;	12✔
25	return min(target.available(), remaining_);	48✔
26	}
27
28	int read(Stream &target) {	72✔
29	if (!isInChunkBody(target))	72✔
30	return -1;	24✔
31	int c = target.read();	48✔
32	if (c >= 0)	48✔
33	remaining_--;	36✔
34	return c;	48✔
35	}
36
37	int peek(Stream &target) {	24✔
38	if (!isInChunkBody(target))	24✔
39	return -1;	12✔
40	return target.peek();	12✔
41	}
42
NEW 43	size_t readBytes(Stream &target, char *buffer, size_t size) {	×
NEW 44	if (!isInChunkBody(target))	×
NEW 45	return 0;	×
NEW 46	size_t n = target.readBytes(buffer, min(size, remaining_));	×
NEW 47	remaining_ -= n;	×
NEW 48	return n;	×
49	}
50
51	int read(Client &target, uint8_t *buffer, size_t size) {
52	return readBytes(target, reinterpret_cast<char *>(buffer), size);
53	}
54
55	private:
56	bool isInChunkBody(Stream &target) {	156✔
57	while (state_ != State::Error && state_ != State::Body &&	276✔
58	target.available()) {	84✔
59	state_ = injestNext(target);	36✔
60	}
61	return state_ == State::Body;	156✔
62	}
63
64	State injestNext(Stream &target) {	36✔
65	int c = target.read();	36✔
66	switch (state_) {	36✔
67	case State::Size:	24✔
68	if (c >= '0' && c <= '9')	24✔
69	return appendSizeHexDigit(c - '0');	12✔
70	else if (c >= 'A' && c <= 'F')	12✔
NEW 71	return appendSizeHexDigit(c - 'A' + 10);	×
72	else if (c >= 'a' && c <= 'f')	12✔
NEW 73	return appendSizeHexDigit(c - 'a' + 10);	×
74	else if (c == '\r')	12✔
75	return State::StartCrLf;	12✔
NEW 76	else if (c == ' ' \|\| c == '\t' \|\| c == ';')	×
NEW 77	return State::Extensions;	×
78	else
NEW 79	return State::Error;	×
80
NEW 81	case State::Extensions:	×
NEW 82	if (c == '\r')	×
NEW 83	return State::StartCrLf;	×
84	else
NEW 85	return State::Extensions;	×
86
87	case State::StartCrLf:	12✔
88	if (c == '\n')	12✔
89	return State::Body;	12✔
90	else
NEW 91	return State::Error;	×
92
NEW 93	default:	×
NEW 94	assert(false);	×
95	return State::Error;
96	}
97	}
98
99	State appendSizeHexDigit(uint8_t digit) {	12✔
100	remaining_ = remaining_ * 16 + digit;	12✔
101	return State::Size;	12✔
102	}
103
104	size_t min(size_t a, size_t b) {	48✔
105	return a < b ? a : b;	48✔
106	}
107
108	size_t remaining_ = 0;
109	State state_ = State::Size;
110	};
111
112	} // namespace StreamUtils

bblanchon / ArduinoStreamUtils / 9784403662

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous