11452150858

Committed 22 Oct 2024 02:32AM UTC coverage: 37.403% (+0.02%) from 37.381%

Build # 11452150858

Build Type

push

github

Committed by

web-flow

Commit Message

camera_server: prevent double ack+message (#2430)

It turns out we were sending the ack and message for storage information
as well as capture status twice, once directly in the request handler
callback, and once the MAVSDK user would call the respond function.

We should only call it in the respond function, not in the callback.

Run Details

11105 of 29690 relevant lines covered (37.4%)

255.6 hits per line

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

0.0

/src/mavsdk/core/base64.cpp

#include "base64.h"

namespace mavsdk {

static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                        "abcdefghijklmnopqrstuvwxyz"
                                        "0123456789+/";

static inline bool is_base64(uint8_t c)
{
    return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string base64_encode(std::vector<uint8_t>& raw)
{
    uint8_t* buf = raw.data();
    size_t bufLen = raw.size();

    std::string ret;
    int i = 0;
    int j = 0;
    uint8_t char_array_3[3];
    uint8_t char_array_4[4];

    while (bufLen--) {
        char_array_3[i++] = *(buf++);
        if (i == 3) {
            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for (i = 0; (i < 4); i++)
                ret += base64_chars[char_array_4[i]];
            i = 0;
        }
    }

    if (i) {
        for (j = i; j < 3; j++)
            char_array_3[j] = '\0';

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (j = 0; (j < i + 1); j++)
            ret += base64_chars[char_array_4[j]];

        while ((i++ < 3))
            ret += '=';
    }

    return ret;
}

std::vector<uint8_t> base64_decode(std::string const& encoded_string)
{
    int in_len = encoded_string.size();
    int i = 0;
    int j = 0;
    int in_ = 0;
    uint8_t char_array_4[4], char_array_3[3];
    std::vector<uint8_t> ret;

    while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
        char_array_4[i++] = encoded_string[in_];
        in_++;
        if (i == 4) {
            for (i = 0; i < 4; i++)
                char_array_4[i] = base64_chars.find(char_array_4[i]);

            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

            for (i = 0; (i < 3); i++)
                ret.push_back(char_array_3[i]);
            i = 0;
        }
    }

    if (i) {
        for (j = i; j < 4; j++)
            char_array_4[j] = 0;

        for (j = 0; j < 4; j++)
            char_array_4[j] = base64_chars.find(char_array_4[j]);

        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

        for (j = 0; (j < i - 1); j++)
            ret.push_back(char_array_3[j]);
    }

    return ret;
}

} // namespace mavsdk

1	#include "base64.h"
2
3	namespace mavsdk {
4
5	static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
6	"abcdefghijklmnopqrstuvwxyz"
7	"0123456789+/";
8
9	static inline bool is_base64(uint8_t c)	×
10	{
11	return (isalnum(c) \|\| (c == '+') \|\| (c == '/'));	×
12	}
13
14	std::string base64_encode(std::vector<uint8_t>& raw)	×
15	{
16	uint8_t* buf = raw.data();	×
17	size_t bufLen = raw.size();	×
18
19	std::string ret;	×
20	int i = 0;	×
21	int j = 0;	×
22	uint8_t char_array_3[3];	×
23	uint8_t char_array_4[4];	×
24
25	while (bufLen--) {	×
26	char_array_3[i++] = *(buf++);	×
27	if (i == 3) {	×
28	char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;	×
29	char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);	×
30	char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);	×
31	char_array_4[3] = char_array_3[2] & 0x3f;	×
32
33	for (i = 0; (i < 4); i++)	×
34	ret += base64_chars[char_array_4[i]];	×
35	i = 0;	×
36	}
37	}
38
39	if (i) {	×
40	for (j = i; j < 3; j++)	×
41	char_array_3[j] = '\0';	×
42
43	char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;	×
44	char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);	×
45	char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);	×
46	char_array_4[3] = char_array_3[2] & 0x3f;	×
47
48	for (j = 0; (j < i + 1); j++)	×
49	ret += base64_chars[char_array_4[j]];	×
50
51	while ((i++ < 3))	×
52	ret += '=';	×
53	}
54
55	return ret;	×
56	}
57
58	std::vector<uint8_t> base64_decode(std::string const& encoded_string)	×
59	{
60	int in_len = encoded_string.size();	×
61	int i = 0;	×
62	int j = 0;	×
63	int in_ = 0;	×
64	uint8_t char_array_4[4], char_array_3[3];	×
65	std::vector<uint8_t> ret;	×
66
67	while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {	×
68	char_array_4[i++] = encoded_string[in_];	×
69	in_++;	×
70	if (i == 4) {	×
71	for (i = 0; i < 4; i++)	×
72	char_array_4[i] = base64_chars.find(char_array_4[i]);	×
73
74	char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);	×
75	char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);	×
76	char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];	×
77
78	for (i = 0; (i < 3); i++)	×
79	ret.push_back(char_array_3[i]);	×
80	i = 0;	×
81	}
82	}
83
84	if (i) {	×
85	for (j = i; j < 4; j++)	×
86	char_array_4[j] = 0;	×
87
88	for (j = 0; j < 4; j++)	×
89	char_array_4[j] = base64_chars.find(char_array_4[j]);	×
90
91	char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);	×
92	char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);	×
93	char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];	×
94
95	for (j = 0; (j < i - 1); j++)	×
96	ret.push_back(char_array_3[j]);	×
97	}
98
99	return ret;	×
100	}
101
102	} // namespace mavsdk

mavlink / MAVSDK / 11452150858

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