GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/cache_transport.cc
Date: 2026-10-11 02:40:02
Exec Total Coverage
Lines: 327 373 87.7%
Branches: 167 230 72.6%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #include "cache_transport.h"
6
7 #include <alloca.h>
8 #include <errno.h>
9 #include <sys/socket.h>
10
11 #include <cassert>
12 #include <cstdlib>
13 #include <cstring>
14
15 #include "cache.h"
16 #include "crypto/hash.h"
17 #include "util/exception.h"
18 #include "util/logging.h"
19 #include "util/posix.h"
20 #include "util/smalloc.h"
21
22 // TODO(jblomer): Check for possible starvation of plugin by dying clients
23 // (blocking read). Probably only relevant for TCP sockets.
24
25 using namespace std; // NOLINT
26
27 const char
28 *CacheTransport::kEnvReadyNotifyFd = "__CVMFS_CACHE_EXTERNAL_PIPE_READY__";
29
30 /**
31 * Called on the sender side to wrap a message into a MsgRpc message for wire
32 * transfer.
33 */
34 68910 cvmfs::MsgRpc *CacheTransport::Frame::GetMsgRpc() {
35
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68910 times.
 68910 assert(msg_typed_ != NULL);
36
1/2
✓ Branch 0 taken 68910 times.
✗ Branch 1 not taken.
 68910 if (!is_wrapped_)
37 68910 WrapMsg();
38 68910 return &msg_rpc_;
39 }
40
41
42 /**
43 * Called on the receiving end of an RPC to extract the actual message from the
44 * MsgRpc.
45 */
46 85102 google::protobuf::MessageLite *CacheTransport::Frame::GetMsgTyped() {
47
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 85110 times.
 85102 assert(msg_rpc_.IsInitialized());
48
2/2
✓ Branch 0 taken 68290 times.
✓ Branch 1 taken 16820 times.
 85110 if (msg_typed_ == NULL)
49 68290 UnwrapMsg();
50 85086 return msg_typed_;
51 }
52
53
54 85110 CacheTransport::Frame::Frame()
55 85102 : owns_msg_typed_(false)
56 85102 , msg_typed_(NULL)
57 85102 , attachment_(NULL)
58 85102 , att_size_(0)
59 85102 , is_wrapped_(false)
60 85110 , is_msg_out_of_band_(false) { }
61
62
63 68918 CacheTransport::Frame::Frame(google::protobuf::MessageLite *m)
64 68918 : owns_msg_typed_(false)
65 68918 , msg_typed_(m)
66 68918 , attachment_(NULL)
67 68918 , att_size_(0)
68 68918 , is_wrapped_(false)
69 68918 , is_msg_out_of_band_(false) { }
70
71
72 154004 CacheTransport::Frame::~Frame() { Reset(0); }
73
74
75 16820 bool CacheTransport::Frame::IsMsgOutOfBand() {
76
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16820 times.
 16820 assert(msg_rpc_.IsInitialized());
77
1/2
✓ Branch 0 taken 16820 times.
✗ Branch 1 not taken.
 16820 if (msg_typed_ == NULL)
78 16820 UnwrapMsg();
79 16820 return is_msg_out_of_band_;
80 }
81
82
83 16224 void CacheTransport::Frame::MergeFrom(const Frame &other) {
84 16224 msg_rpc_.CheckTypeAndMergeFrom(other.msg_rpc_);
85 16224 owns_msg_typed_ = true;
86
2/2
✓ Branch 0 taken 14400 times.
✓ Branch 1 taken 1824 times.
 16224 if (other.att_size_ > 0) {
87
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14400 times.
 14400 assert(att_size_ >= other.att_size_);
88 14400 memcpy(attachment_, other.attachment_, other.att_size_);
89 14400 att_size_ = other.att_size_;
90 }
91 16224 }
92
93
94 68886 bool CacheTransport::Frame::ParseMsgRpc(void *buffer, uint32_t size) {
95 68886 const bool retval = msg_rpc_.ParseFromArray(buffer, size);
96
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68886 times.
 68886 if (!retval)
97 ✗ return false;
98
99 // Cleanup typed message when Frame leaves scope
100 68886 owns_msg_typed_ = true;
101 68886 return true;
102 }
103
104
105 154020 void CacheTransport::Frame::Release() {
106
2/2
✓ Branch 0 taken 85102 times.
✓ Branch 1 taken 68918 times.
 154020 if (owns_msg_typed_)
107 85102 return;
108
109 68918 (void)msg_rpc_.release_msg_refcount_req();
110 68918 (void)msg_rpc_.release_msg_refcount_reply();
111 68910 (void)msg_rpc_.release_msg_read_req();
112 68918 (void)msg_rpc_.release_msg_read_reply();
113 68918 (void)msg_rpc_.release_msg_object_info_req();
114 68918 (void)msg_rpc_.release_msg_object_info_reply();
115 68918 (void)msg_rpc_.release_msg_store_req();
116 68910 (void)msg_rpc_.release_msg_store_abort_req();
117 68918 (void)msg_rpc_.release_msg_store_reply();
118 68918 (void)msg_rpc_.release_msg_handshake();
119 68918 (void)msg_rpc_.release_msg_handshake_ack();
120 68910 (void)msg_rpc_.release_msg_quit();
121 68918 (void)msg_rpc_.release_msg_ioctl();
122 68918 (void)msg_rpc_.release_msg_info_req();
123 68918 (void)msg_rpc_.release_msg_info_reply();
124 68918 (void)msg_rpc_.release_msg_shrink_req();
125 68918 (void)msg_rpc_.release_msg_shrink_reply();
126 68918 (void)msg_rpc_.release_msg_list_req();
127 68918 (void)msg_rpc_.release_msg_list_reply();
128 68918 (void)msg_rpc_.release_msg_detach();
129 68918 (void)msg_rpc_.release_msg_breadcrumb_store_req();
130 68918 (void)msg_rpc_.release_msg_breadcrumb_load_req();
131 68918 (void)msg_rpc_.release_msg_breadcrumb_reply();
132 }
133
134
135 154012 void CacheTransport::Frame::Reset(uint32_t original_att_size) {
136 154012 msg_typed_ = NULL;
137 154012 att_size_ = original_att_size;
138 154012 is_wrapped_ = false;
139 154012 is_msg_out_of_band_ = false;
140 154012 Release();
141 154028 msg_rpc_.Clear();
142 154012 owns_msg_typed_ = false;
143 154012 }
144
145
146 68910 void CacheTransport::Frame::WrapMsg() {
147
2/2
✓ Branch 3 taken 170 times.
✓ Branch 4 taken 68748 times.
 68910 if (msg_typed_->GetTypeName() == "cvmfs.MsgHandshake") {
148 170 msg_rpc_.set_allocated_msg_handshake(
149 170 reinterpret_cast<cvmfs::MsgHandshake *>(msg_typed_));
150
2/2
✓ Branch 3 taken 144 times.
✓ Branch 4 taken 68604 times.
 68748 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgHandshakeAck") {
151 144 msg_rpc_.set_allocated_msg_handshake_ack(
152 144 reinterpret_cast<cvmfs::MsgHandshakeAck *>(msg_typed_));
153
2/2
✓ Branch 3 taken 168 times.
✓ Branch 4 taken 68436 times.
 68604 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgQuit") {
154 168 msg_rpc_.set_allocated_msg_quit(
155 168 reinterpret_cast<cvmfs::MsgQuit *>(msg_typed_));
156
2/2
✓ Branch 3 taken 32 times.
✓ Branch 4 taken 68404 times.
 68436 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgIoctl") {
157 32 msg_rpc_.set_allocated_msg_ioctl(
158 32 reinterpret_cast<cvmfs::MsgIoctl *>(msg_typed_));
159
2/2
✓ Branch 3 taken 7016 times.
✓ Branch 4 taken 61388 times.
 68404 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgRefcountReq") {
160 7016 msg_rpc_.set_allocated_msg_refcount_req(
161 7016 reinterpret_cast<cvmfs::MsgRefcountReq *>(msg_typed_));
162
2/2
✓ Branch 3 taken 4512 times.
✓ Branch 4 taken 56876 times.
 61388 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgRefcountReply") {
163 4512 msg_rpc_.set_allocated_msg_refcount_reply(
164 4512 reinterpret_cast<cvmfs::MsgRefcountReply *>(msg_typed_));
165
2/2
✓ Branch 3 taken 152 times.
✓ Branch 4 taken 56724 times.
 56876 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgObjectInfoReq") {
166 152 msg_rpc_.set_allocated_msg_object_info_req(
167 152 reinterpret_cast<cvmfs::MsgObjectInfoReq *>(msg_typed_));
168
2/2
✓ Branch 3 taken 128 times.
✓ Branch 4 taken 56596 times.
 56724 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgObjectInfoReply") {
169 128 msg_rpc_.set_allocated_msg_object_info_reply(
170 128 reinterpret_cast<cvmfs::MsgObjectInfoReply *>(msg_typed_));
171
2/2
✓ Branch 3 taken 18384 times.
✓ Branch 4 taken 38212 times.
 56596 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgReadReq") {
172 18384 msg_rpc_.set_allocated_msg_read_req(
173 18384 reinterpret_cast<cvmfs::MsgReadReq *>(msg_typed_));
174
2/2
✓ Branch 3 taken 17688 times.
✓ Branch 4 taken 20524 times.
 38212 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgReadReply") {
175 17688 msg_rpc_.set_allocated_msg_read_reply(
176 17688 reinterpret_cast<cvmfs::MsgReadReply *>(msg_typed_));
177
2/2
✓ Branch 3 taken 7278 times.
✓ Branch 4 taken 13246 times.
 20524 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgStoreReq") {
178 7278 msg_rpc_.set_allocated_msg_store_req(
179 7278 reinterpret_cast<cvmfs::MsgStoreReq *>(msg_typed_));
180
2/2
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 13238 times.
 13246 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgStoreAbortReq") {
181 8 msg_rpc_.set_allocated_msg_store_abort_req(
182 8 reinterpret_cast<cvmfs::MsgStoreAbortReq *>(msg_typed_));
183
2/2
✓ Branch 3 taken 4872 times.
✓ Branch 4 taken 8366 times.
 13238 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgStoreReply") {
184 4872 msg_rpc_.set_allocated_msg_store_reply(
185 4872 reinterpret_cast<cvmfs::MsgStoreReply *>(msg_typed_));
186
2/2
✓ Branch 3 taken 56 times.
✓ Branch 4 taken 8310 times.
 8366 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgInfoReq") {
187 56 msg_rpc_.set_allocated_msg_info_req(
188 56 reinterpret_cast<cvmfs::MsgInfoReq *>(msg_typed_));
189
2/2
✓ Branch 3 taken 32 times.
✓ Branch 4 taken 8278 times.
 8310 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgInfoReply") {
190 32 msg_rpc_.set_allocated_msg_info_reply(
191 32 reinterpret_cast<cvmfs::MsgInfoReply *>(msg_typed_));
192
2/2
✓ Branch 3 taken 24 times.
✓ Branch 4 taken 8254 times.
 8278 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgShrinkReq") {
193 24 msg_rpc_.set_allocated_msg_shrink_req(
194 24 reinterpret_cast<cvmfs::MsgShrinkReq *>(msg_typed_));
195
2/2
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 8238 times.
 8254 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgShrinkReply") {
196 16 msg_rpc_.set_allocated_msg_shrink_reply(
197 16 reinterpret_cast<cvmfs::MsgShrinkReply *>(msg_typed_));
198
2/2
✓ Branch 3 taken 88 times.
✓ Branch 4 taken 8150 times.
 8238 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgListReq") {
199 88 msg_rpc_.set_allocated_msg_list_req(
200 88 reinterpret_cast<cvmfs::MsgListReq *>(msg_typed_));
201
2/2
✓ Branch 3 taken 80 times.
✓ Branch 4 taken 8070 times.
 8150 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgListReply") {
202 80 msg_rpc_.set_allocated_msg_list_reply(
203 80 reinterpret_cast<cvmfs::MsgListReply *>(msg_typed_));
204
2/2
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 8060 times.
 8070 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgBreadcrumbStoreReq") {
205 10 msg_rpc_.set_allocated_msg_breadcrumb_store_req(
206 10 reinterpret_cast<cvmfs::MsgBreadcrumbStoreReq *>(msg_typed_));
207
2/2
✓ Branch 3 taken 20 times.
✓ Branch 4 taken 8040 times.
 8060 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgBreadcrumbLoadReq") {
208 20 msg_rpc_.set_allocated_msg_breadcrumb_load_req(
209 20 reinterpret_cast<cvmfs::MsgBreadcrumbLoadReq *>(msg_typed_));
210
2/2
✓ Branch 3 taken 24 times.
✓ Branch 4 taken 8016 times.
 8040 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgBreadcrumbReply") {
211 24 msg_rpc_.set_allocated_msg_breadcrumb_reply(
212 24 reinterpret_cast<cvmfs::MsgBreadcrumbReply *>(msg_typed_));
213
1/2
✓ Branch 3 taken 8016 times.
✗ Branch 4 not taken.
 8016 } else if (msg_typed_->GetTypeName() == "cvmfs.MsgDetach") {
214 8016 msg_rpc_.set_allocated_msg_detach(
215 8016 reinterpret_cast<cvmfs::MsgDetach *>(msg_typed_));
216 8016 is_msg_out_of_band_ = true;
217 } else {
218 // Unexpected message type, should never happen
219 ✗ PANIC(NULL);
220 }
221 68918 is_wrapped_ = true;
222 68918 }
223
224
225 85110 void CacheTransport::Frame::UnwrapMsg() {
226
2/2
✓ Branch 1 taken 144 times.
✓ Branch 2 taken 84942 times.
 85110 if (msg_rpc_.has_msg_handshake()) {
227 144 msg_typed_ = msg_rpc_.mutable_msg_handshake();
228
2/2
✓ Branch 1 taken 170 times.
✓ Branch 2 taken 84788 times.
 84942 } else if (msg_rpc_.has_msg_handshake_ack()) {
229 170 msg_typed_ = msg_rpc_.mutable_msg_handshake_ack();
230
2/2
✓ Branch 1 taken 144 times.
✓ Branch 2 taken 84644 times.
 84788 } else if (msg_rpc_.has_msg_quit()) {
231 144 msg_typed_ = msg_rpc_.mutable_msg_quit();
232
2/2
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 84604 times.
 84644 } else if (msg_rpc_.has_msg_ioctl()) {
233 32 msg_typed_ = msg_rpc_.mutable_msg_ioctl();
234
2/2
✓ Branch 1 taken 4512 times.
✓ Branch 2 taken 80084 times.
 84604 } else if (msg_rpc_.has_msg_refcount_req()) {
235 4512 msg_typed_ = msg_rpc_.mutable_msg_refcount_req();
236
2/2
✓ Branch 1 taken 7168 times.
✓ Branch 2 taken 72900 times.
 80084 } else if (msg_rpc_.has_msg_refcount_reply()) {
237 7168 msg_typed_ = msg_rpc_.mutable_msg_refcount_reply();
238
2/2
✓ Branch 1 taken 128 times.
✓ Branch 2 taken 72796 times.
 72900 } else if (msg_rpc_.has_msg_object_info_req()) {
239 128 msg_typed_ = msg_rpc_.mutable_msg_object_info_req();
240
2/2
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 72556 times.
 72796 } else if (msg_rpc_.has_msg_object_info_reply()) {
241 224 msg_typed_ = msg_rpc_.mutable_msg_object_info_reply();
242
2/2
✓ Branch 1 taken 17688 times.
✓ Branch 2 taken 54884 times.
 72556 } else if (msg_rpc_.has_msg_read_req()) {
243 17688 msg_typed_ = msg_rpc_.mutable_msg_read_req();
244
2/2
✓ Branch 1 taken 32784 times.
✓ Branch 2 taken 22116 times.
 54884 } else if (msg_rpc_.has_msg_read_reply()) {
245 32784 msg_typed_ = msg_rpc_.mutable_msg_read_reply();
246
2/2
✓ Branch 1 taken 4864 times.
✓ Branch 2 taken 17252 times.
 22116 } else if (msg_rpc_.has_msg_store_req()) {
247 4864 msg_typed_ = msg_rpc_.mutable_msg_store_req();
248
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 17244 times.
 17252 } else if (msg_rpc_.has_msg_store_abort_req()) {
249 8 msg_typed_ = msg_rpc_.mutable_msg_store_abort_req();
250
2/2
✓ Branch 1 taken 8886 times.
✓ Branch 2 taken 8358 times.
 17244 } else if (msg_rpc_.has_msg_store_reply()) {
251 8886 msg_typed_ = msg_rpc_.mutable_msg_store_reply();
252
2/2
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 8326 times.
 8358 } else if (msg_rpc_.has_msg_info_req()) {
253 32 msg_typed_ = msg_rpc_.mutable_msg_info_req();
254
2/2
✓ Branch 1 taken 56 times.
✓ Branch 2 taken 8270 times.
 8326 } else if (msg_rpc_.has_msg_info_reply()) {
255 56 msg_typed_ = msg_rpc_.mutable_msg_info_reply();
256
2/2
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 8254 times.
 8270 } else if (msg_rpc_.has_msg_shrink_req()) {
257 16 msg_typed_ = msg_rpc_.mutable_msg_shrink_req();
258
2/2
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 8230 times.
 8254 } else if (msg_rpc_.has_msg_shrink_reply()) {
259 24 msg_typed_ = msg_rpc_.mutable_msg_shrink_reply();
260
2/2
✓ Branch 1 taken 80 times.
✓ Branch 2 taken 8150 times.
 8230 } else if (msg_rpc_.has_msg_list_req()) {
261 80 msg_typed_ = msg_rpc_.mutable_msg_list_req();
262
2/2
✓ Branch 1 taken 88 times.
✓ Branch 2 taken 8062 times.
 8150 } else if (msg_rpc_.has_msg_list_reply()) {
263 88 msg_typed_ = msg_rpc_.mutable_msg_list_reply();
264
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 8054 times.
 8062 } else if (msg_rpc_.has_msg_breadcrumb_store_req()) {
265 8 msg_typed_ = msg_rpc_.mutable_msg_breadcrumb_store_req();
266
2/2
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 8038 times.
 8054 } else if (msg_rpc_.has_msg_breadcrumb_load_req()) {
267 16 msg_typed_ = msg_rpc_.mutable_msg_breadcrumb_load_req();
268
2/2
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 8008 times.
 8038 } else if (msg_rpc_.has_msg_breadcrumb_reply()) {
269 30 msg_typed_ = msg_rpc_.mutable_msg_breadcrumb_reply();
270
1/2
✓ Branch 1 taken 8008 times.
✗ Branch 2 not taken.
 8008 } else if (msg_rpc_.has_msg_detach()) {
271 8008 msg_typed_ = msg_rpc_.mutable_msg_detach();
272 8008 is_msg_out_of_band_ = true;
273 } else {
274 // Unexpected message type, should never happen
275 ✗ PANIC(NULL);
276 }
277 85102 }
278
279
280 //------------------------------------------------------------------------------
281
282
283 170 CacheTransport::CacheTransport(int fd_connection)
284 170 : fd_connection_(fd_connection), flags_(0) {
285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170 times.
 170 assert(fd_connection_ >= 0);
286 170 }
287
288
289 35688 CacheTransport::CacheTransport(int fd_connection, uint32_t flags)
290 35688 : fd_connection_(fd_connection), flags_(flags) {
291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35688 times.
 35688 assert(fd_connection_ >= 0);
292 35688 }
293
294
295 1614829 void CacheTransport::FillMsgHash(const shash::Any &hash,
296 cvmfs::MsgHash *msg_hash) {
297
3/4
✓ Branch 0 taken 1614787 times.
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
 1614829 switch (hash.algorithm) {
298 1614787 case shash::kSha1:
299 1614787 msg_hash->set_algorithm(cvmfs::HASH_SHA1);
300 1614787 break;
301 12 case shash::kRmd160:
302 12 msg_hash->set_algorithm(cvmfs::HASH_RIPEMD160);
303 12 break;
304 30 case shash::kShake128:
305 30 msg_hash->set_algorithm(cvmfs::HASH_SHAKE128);
306 30 break;
307 ✗ default:
308 ✗ PANIC(NULL);
309 }
310 1614829 msg_hash->set_digest(hash.digest, shash::kDigestSizes[hash.algorithm]);
311 1614837 }
312
313
314 7270 void CacheTransport::FillObjectType(int object_flags,
315 cvmfs::EnumObjectType *wire_type) {
316 7270 *wire_type = cvmfs::OBJECT_REGULAR;
317
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7270 times.
 7270 if (object_flags & CacheManager::kLabelCatalog)
318 ✗ *wire_type = cvmfs::OBJECT_CATALOG;
319
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7270 times.
 7270 if (object_flags & CacheManager::kLabelVolatile)
320 ✗ *wire_type = cvmfs::OBJECT_VOLATILE;
321 7270 }
322
323
324 27210 bool CacheTransport::ParseMsgHash(const cvmfs::MsgHash &msg_hash,
325 shash::Any *hash) {
326
2/4
✓ Branch 1 taken 27192 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 18 times.
✗ Branch 4 not taken.
 27210 switch (msg_hash.algorithm()) {
327 27192 case cvmfs::HASH_SHA1:
328 27192 hash->algorithm = shash::kSha1;
329 27192 break;
330 ✗ case cvmfs::HASH_RIPEMD160:
331 ✗ hash->algorithm = shash::kRmd160;
332 ✗ break;
333 18 case cvmfs::HASH_SHAKE128:
334 18 hash->algorithm = shash::kShake128;
335 18 break;
336 ✗ default:
337 ✗ return false;
338 }
339 27210 const unsigned digest_size = shash::kDigestSizes[hash->algorithm];
340
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 27210 times.
 27210 if (msg_hash.digest().length() != digest_size)
341 ✗ return false;
342 27210 memcpy(hash->digest, msg_hash.digest().data(), digest_size);
343 27210 return true;
344 }
345
346
347 ✗ bool CacheTransport::ParseObjectType(cvmfs::EnumObjectType wire_type,
348 int *object_flags) {
349 ✗ *object_flags = 0;
350 ✗ switch (wire_type) {
351 ✗ case cvmfs::OBJECT_REGULAR:
352 ✗ return true;
353 ✗ case cvmfs::OBJECT_CATALOG:
354 ✗ *object_flags |= CacheManager::kLabelCatalog;
355 ✗ return true;
356 ✗ case cvmfs::OBJECT_VOLATILE:
357 ✗ *object_flags |= CacheManager::kLabelVolatile;
358 ✗ return true;
359 ✗ default:
360 ✗ return false;
361 }
362 }
363
364
365 68894 bool CacheTransport::RecvFrame(CacheTransport::Frame *frame) {
366 uint32_t size;
367 bool has_attachment;
368
1/2
✓ Branch 1 taken 68894 times.
✗ Branch 2 not taken.
 68894 bool retval = RecvHeader(&size, &has_attachment);
369
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 68886 times.
 68894 if (!retval)
370 8 return false;
371
372 void *buffer;
373
2/2
✓ Branch 0 taken 45885 times.
✓ Branch 1 taken 23001 times.
 68886 if (size <= kMaxStackAlloc)
374 45885 buffer = alloca(size);
375 else
376 23001 buffer = smalloc(size);
377
1/2
✓ Branch 1 taken 68886 times.
✗ Branch 2 not taken.
 68886 const ssize_t nbytes = SafeRead(fd_connection_, buffer, size);
378
2/4
✓ Branch 0 taken 68886 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 68886 times.
 68886 if ((nbytes < 0) || (static_cast<uint32_t>(nbytes) != size)) {
379 ✗ if (size > kMaxStackAlloc) {
380 ✗ free(buffer);
381 }
382 ✗ return false;
383 }
384
385 68886 uint32_t msg_size = size;
386
2/2
✓ Branch 0 taken 23226 times.
✓ Branch 1 taken 45660 times.
 68886 if (has_attachment) {
387
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23226 times.
 23226 if (size < 2) {
388 // kMaxStackAlloc is > 2 (of course!) but we'll leave the condition here
389 // for consistency.
390 ✗ if (size > kMaxStackAlloc) {
391 ✗ free(buffer);
392 }
393 ✗ return false;
394 }
395 23226 msg_size = (*reinterpret_cast<unsigned char *>(buffer))
396 23226 + ((*(reinterpret_cast<unsigned char *>(buffer) + 1)) << 8);
397
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23226 times.
 23226 if ((msg_size + kInnerHeaderSize) > size) {
398 ✗ if (size > kMaxStackAlloc) {
399 ✗ free(buffer);
400 }
401 ✗ return false;
402 }
403 }
404
405 68886 void *ptr_msg = has_attachment
406
2/2
✓ Branch 0 taken 23226 times.
✓ Branch 1 taken 45660 times.
 68886 ? (reinterpret_cast<char *>(buffer) + kInnerHeaderSize)
407 : buffer;
408
1/2
✓ Branch 1 taken 68886 times.
✗ Branch 2 not taken.
 68886 retval = frame->ParseMsgRpc(ptr_msg, msg_size);
409
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68886 times.
 68886 if (!retval) {
410 ✗ if (size > kMaxStackAlloc) {
411 ✗ free(buffer);
412 }
413 ✗ return false;
414 }
415
416
2/2
✓ Branch 0 taken 23226 times.
✓ Branch 1 taken 45660 times.
 68886 if (has_attachment) {
417 23226 const uint32_t attachment_size = size - (msg_size + kInnerHeaderSize);
418
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 23226 times.
 23226 if (frame->att_size() < attachment_size) {
419 ✗ if (size > kMaxStackAlloc) {
420 ✗ free(buffer);
421 }
422 ✗ return false;
423 }
424 23226 void *ptr_attachment = reinterpret_cast<char *>(buffer) + kInnerHeaderSize
425 23226 + msg_size;
426 23226 memcpy(frame->attachment(), ptr_attachment, attachment_size);
427 23226 frame->set_att_size(attachment_size);
428 } else {
429 45660 frame->set_att_size(0);
430 }
431
2/2
✓ Branch 0 taken 23001 times.
✓ Branch 1 taken 45877 times.
 68878 if (size > kMaxStackAlloc) {
432 23001 free(buffer);
433 }
434 68878 return true;
435 }
436
437
438 68894 bool CacheTransport::RecvHeader(uint32_t *size, bool *has_attachment) {
439 unsigned char header[kHeaderSize];
440
1/2
✓ Branch 1 taken 68894 times.
✗ Branch 2 not taken.
 68894 const ssize_t nbytes = SafeRead(fd_connection_, header, kHeaderSize);
441
3/4
✓ Branch 0 taken 68894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 68886 times.
 68894 if ((nbytes < 0) || (static_cast<unsigned>(nbytes) != kHeaderSize))
442 8 return false;
443
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68886 times.
 68886 if ((header[0] & (~kFlagHasAttachment)) != kWireProtocolVersion)
444 ✗ return false;
445 68886 *has_attachment = header[0] & kFlagHasAttachment;
446 68886 *size = header[1] + (header[2] << 8) + (header[3] << 16);
447
2/4
✓ Branch 0 taken 68886 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68886 times.
✗ Branch 3 not taken.
 68886 return (*size > 0) && (*size <= kMaxMsgSize);
448 }
449
450
451 68918 void CacheTransport::SendData(void *message,
452 uint32_t msg_size,
453 void *attachment,
454 uint32_t att_size) {
455 137836 const uint32_t total_size = msg_size + att_size
456
2/2
✓ Branch 0 taken 24948 times.
✓ Branch 1 taken 43970 times.
 68918 + ((att_size > 0) ? kInnerHeaderSize : 0);
457
458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68918 times.
 68918 assert(total_size > 0);
459
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68918 times.
 68918 assert(total_size <= kMaxMsgSize);
460
1/2
✓ Branch 1 taken 63184 times.
✗ Branch 2 not taken.
 63184 LogCvmfs(kLogCache, kLogDebug,
461 "sending message of size %u to cache transport", total_size);
462
463 unsigned char header[kHeaderSize];
464
2/2
✓ Branch 0 taken 43970 times.
✓ Branch 1 taken 24948 times.
 68918 header[0] = kWireProtocolVersion | ((att_size == 0) ? 0 : kFlagHasAttachment);
465 68918 header[1] = (total_size & 0x000000FF);
466 68918 header[2] = (total_size & 0x0000FF00) >> 8;
467 68918 header[3] = (total_size & 0x00FF0000) >> 16;
468 // Only transferred if an attachment is present. Otherwise the overall size
469 // is also the size of the protobuf message.
470 unsigned char inner_header[kInnerHeaderSize];
471
472 struct iovec iov[4];
473 68918 iov[0].iov_base = header;
474 68918 iov[0].iov_len = kHeaderSize;
475
476
2/2
✓ Branch 0 taken 24948 times.
✓ Branch 1 taken 43970 times.
 68918 if (att_size > 0) {
477 24948 inner_header[0] = (msg_size & 0x000000FF);
478 24948 inner_header[1] = (msg_size & 0x0000FF00) >> 8;
479 24948 iov[1].iov_base = inner_header;
480 24948 iov[1].iov_len = kInnerHeaderSize;
481 24948 iov[2].iov_base = message;
482 24948 iov[2].iov_len = msg_size;
483 24948 iov[3].iov_base = attachment;
484 24948 iov[3].iov_len = att_size;
485 } else {
486 43970 iov[1].iov_base = message;
487 43970 iov[1].iov_len = msg_size;
488 }
489
2/2
✓ Branch 0 taken 8016 times.
✓ Branch 1 taken 60902 times.
 68918 if (flags_ & kFlagSendNonBlocking) {
490
2/4
✓ Branch 0 taken 8016 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 8016 times.
✗ Branch 4 not taken.
 8016 SendNonBlocking(iov, (att_size == 0) ? 2 : 4);
491 8016 return;
492 }
493
3/4
✓ Branch 0 taken 35954 times.
✓ Branch 1 taken 24948 times.
✓ Branch 3 taken 60894 times.
✗ Branch 4 not taken.
 60902 const bool retval = SafeWriteV(fd_connection_, iov, (att_size == 0) ? 2 : 4);
494
495
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 60894 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 60894 if (!retval && !(flags_ & kFlagSendIgnoreFailure)) {
496 ✗ PANIC(kLogSyslogErr | kLogDebug,
497 "failed to write to external cache transport (%d), aborting", errno);
498 }
499 }
500
501 8016 void CacheTransport::SendNonBlocking(struct iovec *iov, unsigned iovcnt) {
502
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8016 times.
 8016 assert(iovcnt > 0);
503 8016 unsigned total_size = 0;
504
2/2
✓ Branch 0 taken 16032 times.
✓ Branch 1 taken 8016 times.
 24048 for (unsigned i = 0; i < iovcnt; ++i)
505 16032 total_size += iov[i].iov_len;
506 8016 unsigned char *buffer = reinterpret_cast<unsigned char *>(alloca(total_size));
507
508 8016 unsigned pos = 0;
509
2/2
✓ Branch 0 taken 16032 times.
✓ Branch 1 taken 8016 times.
 24048 for (unsigned i = 0; i < iovcnt; ++i) {
510 16032 memcpy(buffer + pos, iov[i].iov_base, iov[i].iov_len);
511 16032 pos += iov[i].iov_len;
512 }
513
514 8016 const int retval = send(fd_connection_, buffer, total_size, MSG_DONTWAIT);
515
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8016 times.
 8016 if (retval < 0) {
516 ✗ assert(errno != EMSGSIZE);
517 ✗ if (!(flags_ & kFlagSendIgnoreFailure)) {
518 ✗ PANIC(kLogSyslogErr | kLogDebug,
519 "failed to write to external cache transport (%d), aborting",
520 errno);
521 }
522 }
523 8016 }
524
525
526 68910 void CacheTransport::SendFrame(CacheTransport::Frame *frame) {
527 68910 cvmfs::MsgRpc *msg_rpc = frame->GetMsgRpc();
528 68910 const size_t byte_size = msg_rpc->ByteSizeLong();
529
2/4
✓ Branch 0 taken 68918 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68918 times.
✗ Branch 3 not taken.
 68918 assert((byte_size > 0) && (byte_size <= kMaxMsgSize));
530 68918 const uint32_t size = static_cast<uint32_t>(byte_size);
531 #ifdef __APPLE__
532 void *buffer = smalloc(size);
533 #else
534 68918 void *buffer = alloca(size);
535 #endif
536 68918 const bool retval = msg_rpc->SerializeToArray(buffer, size);
537
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68918 times.
 68918 assert(retval);
538 68918 SendData(buffer, size, frame->attachment(), frame->att_size());
539 #ifdef __APPLE__
540 free(buffer);
541 #endif
542 68910 }
543