1 | /* |
2 | Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file |
3 | |
4 | This file is part of libzmq, the ZeroMQ core engine in C++. |
5 | |
6 | libzmq is free software; you can redistribute it and/or modify it under |
7 | the terms of the GNU Lesser General Public License (LGPL) as published |
8 | by the Free Software Foundation; either version 3 of the License, or |
9 | (at your option) any later version. |
10 | |
11 | As a special exception, the Contributors give you permission to link |
12 | this library with independent modules to produce an executable, |
13 | regardless of the license terms of these independent modules, and to |
14 | copy and distribute the resulting executable under terms of your choice, |
15 | provided that you also meet, for each linked independent module, the |
16 | terms and conditions of the license of that module. An independent |
17 | module is a module which is not derived from or based on this library. |
18 | If you modify this library, you must extend this exception to your |
19 | version of the library. |
20 | |
21 | libzmq is distributed in the hope that it will be useful, but WITHOUT |
22 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
23 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public |
24 | License for more details. |
25 | |
26 | You should have received a copy of the GNU Lesser General Public License |
27 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
28 | */ |
29 | |
30 | #include "precompiled.hpp" |
31 | #include <stdlib.h> |
32 | #include <string.h> |
33 | #include <cmath> |
34 | |
35 | #include "v2_protocol.hpp" |
36 | #include "v2_decoder.hpp" |
37 | #include "likely.hpp" |
38 | #include "wire.hpp" |
39 | #include "err.hpp" |
40 | |
41 | zmq::v2_decoder_t::v2_decoder_t (size_t bufsize_, |
42 | int64_t maxmsgsize_, |
43 | bool zero_copy_) : |
44 | decoder_base_t<v2_decoder_t, shared_message_memory_allocator> (bufsize_), |
45 | _msg_flags (0), |
46 | _zero_copy (zero_copy_), |
47 | _max_msg_size (maxmsgsize_) |
48 | { |
49 | int rc = _in_progress.init (); |
50 | errno_assert (rc == 0); |
51 | |
52 | // At the beginning, read one byte and go to flags_ready state. |
53 | next_step (_tmpbuf, 1, &v2_decoder_t::flags_ready); |
54 | } |
55 | |
56 | zmq::v2_decoder_t::~v2_decoder_t () |
57 | { |
58 | int rc = _in_progress.close (); |
59 | errno_assert (rc == 0); |
60 | } |
61 | |
62 | int zmq::v2_decoder_t::flags_ready (unsigned char const *) |
63 | { |
64 | _msg_flags = 0; |
65 | if (_tmpbuf[0] & v2_protocol_t::more_flag) |
66 | _msg_flags |= msg_t::more; |
67 | if (_tmpbuf[0] & v2_protocol_t::command_flag) |
68 | _msg_flags |= msg_t::command; |
69 | |
70 | // The payload length is either one or eight bytes, |
71 | // depending on whether the 'large' bit is set. |
72 | if (_tmpbuf[0] & v2_protocol_t::large_flag) |
73 | next_step (_tmpbuf, 8, &v2_decoder_t::eight_byte_size_ready); |
74 | else |
75 | next_step (_tmpbuf, 1, &v2_decoder_t::one_byte_size_ready); |
76 | |
77 | return 0; |
78 | } |
79 | |
80 | int zmq::v2_decoder_t::one_byte_size_ready (unsigned char const *read_from_) |
81 | { |
82 | return size_ready (_tmpbuf[0], read_from_); |
83 | } |
84 | |
85 | int zmq::v2_decoder_t::eight_byte_size_ready (unsigned char const *read_from_) |
86 | { |
87 | // The payload size is encoded as 64-bit unsigned integer. |
88 | // The most significant byte comes first. |
89 | const uint64_t msg_size = get_uint64 (_tmpbuf); |
90 | |
91 | return size_ready (msg_size, read_from_); |
92 | } |
93 | |
94 | int zmq::v2_decoder_t::size_ready (uint64_t msg_size_, |
95 | unsigned char const *read_pos_) |
96 | { |
97 | // Message size must not exceed the maximum allowed size. |
98 | if (_max_msg_size >= 0) |
99 | if (unlikely (msg_size_ > static_cast<uint64_t> (_max_msg_size))) { |
100 | errno = EMSGSIZE; |
101 | return -1; |
102 | } |
103 | |
104 | // Message size must fit into size_t data type. |
105 | if (unlikely (msg_size_ != static_cast<size_t> (msg_size_))) { |
106 | errno = EMSGSIZE; |
107 | return -1; |
108 | } |
109 | |
110 | int rc = _in_progress.close (); |
111 | assert (rc == 0); |
112 | |
113 | // the current message can exceed the current buffer. We have to copy the buffer |
114 | // data into a new message and complete it in the next receive. |
115 | |
116 | shared_message_memory_allocator &allocator = get_allocator (); |
117 | if (unlikely (!_zero_copy |
118 | || msg_size_ > (size_t) (allocator.data () + allocator.size () |
119 | - read_pos_))) { |
120 | // a new message has started, but the size would exceed the pre-allocated arena |
121 | // this happens every time when a message does not fit completely into the buffer |
122 | rc = _in_progress.init_size (static_cast<size_t> (msg_size_)); |
123 | } else { |
124 | // construct message using n bytes from the buffer as storage |
125 | // increase buffer ref count |
126 | // if the message will be a large message, pass a valid refcnt memory location as well |
127 | rc = |
128 | _in_progress.init (const_cast<unsigned char *> (read_pos_), |
129 | static_cast<size_t> (msg_size_), |
130 | shared_message_memory_allocator::call_dec_ref, |
131 | allocator.buffer (), allocator.provide_content ()); |
132 | |
133 | // For small messages, data has been copied and refcount does not have to be increased |
134 | if (_in_progress.is_zcmsg ()) { |
135 | allocator.advance_content (); |
136 | allocator.inc_ref (); |
137 | } |
138 | } |
139 | |
140 | if (unlikely (rc)) { |
141 | errno_assert (errno == ENOMEM); |
142 | rc = _in_progress.init (); |
143 | errno_assert (rc == 0); |
144 | errno = ENOMEM; |
145 | return -1; |
146 | } |
147 | |
148 | _in_progress.set_flags (_msg_flags); |
149 | // this sets read_pos to |
150 | // the message data address if the data needs to be copied |
151 | // for small message / messages exceeding the current buffer |
152 | // or |
153 | // to the current start address in the buffer because the message |
154 | // was constructed to use n bytes from the address passed as argument |
155 | next_step (_in_progress.data (), _in_progress.size (), |
156 | &v2_decoder_t::message_ready); |
157 | |
158 | return 0; |
159 | } |
160 | |
161 | int zmq::v2_decoder_t::message_ready (unsigned char const *) |
162 | { |
163 | // Message is completely read. Signal this to the caller |
164 | // and prepare to decode next message. |
165 | next_step (_tmpbuf, 1, &v2_decoder_t::flags_ready); |
166 | return 1; |
167 | } |
168 | |