Line data Source code
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 <limits>
34 :
35 : #include "platform.hpp"
36 : #if defined ZMQ_HAVE_WINDOWS
37 : #include "windows.hpp"
38 : #endif
39 :
40 : #include "decoder.hpp"
41 : #include "v1_decoder.hpp"
42 : #include "likely.hpp"
43 : #include "wire.hpp"
44 : #include "err.hpp"
45 :
46 0 : zmq::v1_decoder_t::v1_decoder_t (size_t bufsize_, int64_t maxmsgsize_) :
47 : c_single_allocator(bufsize_),
48 : decoder_base_t <v1_decoder_t> (this),
49 0 : maxmsgsize (maxmsgsize_)
50 : {
51 0 : int rc = in_progress.init ();
52 0 : errno_assert (rc == 0);
53 :
54 : // At the beginning, read one byte and go to one_byte_size_ready state.
55 0 : next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
56 0 : }
57 :
58 0 : zmq::v1_decoder_t::~v1_decoder_t ()
59 : {
60 0 : int rc = in_progress.close ();
61 0 : errno_assert (rc == 0);
62 0 : }
63 :
64 0 : int zmq::v1_decoder_t::one_byte_size_ready (unsigned char const*)
65 : {
66 : // First byte of size is read. If it is 0xff read 8-byte size.
67 : // Otherwise allocate the buffer for message data and read the
68 : // message data into it.
69 0 : if (*tmpbuf == 0xff)
70 0 : next_step (tmpbuf, 8, &v1_decoder_t::eight_byte_size_ready);
71 : else {
72 :
73 : // There has to be at least one byte (the flags) in the message).
74 0 : if (!*tmpbuf) {
75 0 : errno = EPROTO;
76 0 : return -1;
77 : }
78 :
79 0 : if (maxmsgsize >= 0 && (int64_t) (*tmpbuf - 1) > maxmsgsize) {
80 0 : errno = EMSGSIZE;
81 0 : return -1;
82 : }
83 :
84 0 : int rc = in_progress.close();
85 : assert(rc == 0);
86 0 : rc = in_progress.init_size (*tmpbuf - 1);
87 0 : if (rc != 0) {
88 0 : errno_assert (errno == ENOMEM);
89 0 : rc = in_progress.init ();
90 0 : errno_assert (rc == 0);
91 0 : errno = ENOMEM;
92 0 : return -1;
93 : }
94 :
95 0 : next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
96 : }
97 : return 0;
98 : }
99 :
100 0 : int zmq::v1_decoder_t::eight_byte_size_ready (unsigned char const*)
101 : {
102 : // 8-byte payload length is read. Allocate the buffer
103 : // for message body and read the message data into it.
104 0 : const uint64_t payload_length = get_uint64 (tmpbuf);
105 :
106 : // There has to be at least one byte (the flags) in the message).
107 0 : if (payload_length == 0) {
108 0 : errno = EPROTO;
109 0 : return -1;
110 : }
111 :
112 : // Message size must not exceed the maximum allowed size.
113 0 : if (maxmsgsize >= 0 && payload_length - 1 > (uint64_t) maxmsgsize) {
114 0 : errno = EMSGSIZE;
115 0 : return -1;
116 : }
117 :
118 : // Message size must fit within range of size_t data type.
119 : if (payload_length - 1 > std::numeric_limits <size_t>::max ()) {
120 : errno = EMSGSIZE;
121 : return -1;
122 : }
123 :
124 0 : const size_t msg_size = static_cast <size_t> (payload_length - 1);
125 :
126 0 : int rc = in_progress.close();
127 : assert(rc == 0);
128 0 : rc = in_progress.init_size (msg_size);
129 0 : if (rc != 0) {
130 0 : errno_assert (errno == ENOMEM);
131 0 : rc = in_progress.init ();
132 0 : errno_assert (rc == 0);
133 0 : errno = ENOMEM;
134 0 : return -1;
135 : }
136 :
137 0 : next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
138 0 : return 0;
139 : }
140 :
141 0 : int zmq::v1_decoder_t::flags_ready (unsigned char const*)
142 : {
143 : // Store the flags from the wire into the message structure.
144 0 : in_progress.set_flags (tmpbuf [0] & msg_t::more);
145 :
146 : next_step (in_progress.data (), in_progress.size (),
147 0 : &v1_decoder_t::message_ready);
148 :
149 0 : return 0;
150 : }
151 :
152 0 : int zmq::v1_decoder_t::message_ready (unsigned char const*)
153 : {
154 : // Message is completely read. Push it further and start reading
155 : // new message. (in_progress is a 0-byte message after this point.)
156 0 : next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
157 0 : return 1;
158 : }
|
