com_select(): Improve message.
[paraslash.git] / sideband.c
1 /* Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
2
3 /** \file sideband.c Implementation of the sideband API. */
4
5 #include <regex.h>
6
7 #include "para.h"
8 #include "error.h"
9 #include "portable_io.h"
10 #include "string.h"
11 #include "sideband.h"
12
13 /** Each sideband packet consists of a header and a data part. */
14 #define SIDEBAND_HEADER_SIZE 5
15
16 struct sb_context {
17 char header[SIDEBAND_HEADER_SIZE];
18 size_t bytes_dispatched; /* including header */
19 sb_transformation trafo;
20 void *trafo_context;
21 struct sb_buffer sbb;
22 size_t max_size;
23 bool dont_free;
24 };
25
26 /**
27 * Prepare to receive a sideband packet.
28 *
29 * \param max_size Do not allocate more than this many bytes.
30 * \param t Optional sideband transformation.
31 * \param trafo_context Passed verbatim to \a t.
32 *
33 * \a trafo_context is ignored if \a t is \p NULL.
34 *
35 * \return An opaque sideband handle.
36 */
37 struct sb_context *sb_new_recv(size_t max_size, sb_transformation t,
38 void *trafo_context)
39 {
40 struct sb_context *c = para_calloc(sizeof(*c));
41
42 c->max_size = max_size;
43 c->trafo = t;
44 c->trafo_context = trafo_context;
45 return c;
46 }
47
48 /**
49 * Prepare to write a sideband packet.
50 *
51 * \param sbb Data and meta data to send.
52 * \param dont_free Do not try to deallocate the sideband buffer.
53 * \param t See \ref sb_new_recv().
54 * \param trafo_context See \ref sb_new_recv().
55 *
56 * It's OK to supply a zero-sized buffer in \a sbb. In this case only the band
57 * designator is sent through the sideband channel. Otherwise, if \a dont_free
58 * is false, the buffer of \a sbb is freed after the data has been sent.
59 *
60 * \return See \ref sb_new_recv().
61 */
62 struct sb_context *sb_new_send(struct sb_buffer *sbb, bool dont_free,
63 sb_transformation t, void *trafo_context)
64 {
65 struct sb_context *c = para_calloc(sizeof(*c));
66 struct iovec src, dst, *srcp, *dstp;
67
68 assert(sbb);
69 c->trafo = t;
70 c->trafo_context = trafo_context;
71 c->dont_free = dont_free;
72 c->sbb = *sbb;
73 write_u32(c->header, sbb->iov.iov_len);
74 write_u8(c->header + 4, sbb->band);
75 if (!t)
76 goto out;
77 src = (typeof(src)){.iov_base = c->header, .iov_len = SIDEBAND_HEADER_SIZE};
78 t(&src, &dst, trafo_context);
79 if (src.iov_base != dst.iov_base) {
80 memcpy(c->header, dst.iov_base, SIDEBAND_HEADER_SIZE);
81 free(dst.iov_base);
82 }
83 if (!iov_valid(&sbb->iov))
84 goto out;
85 srcp = &sbb->iov;
86 dstp = &c->sbb.iov;
87 t(srcp, dstp, trafo_context);
88 if (srcp->iov_base != dstp->iov_base) {
89 if (!c->dont_free)
90 free(srcp->iov_base);
91 c->dont_free = false;
92 }
93 out:
94 return c;
95 }
96
97 /**
98 * Deallocate all memory associated with a sideband handle.
99 *
100 * \param c The sideband handle.
101 *
102 * \a c must point to a handle previously returned by \ref sb_new_recv() or
103 * \ref sb_new_send(). It \a c is \p NULL, the function does nothing.
104 */
105 void sb_free(struct sb_context *c)
106 {
107 if (!c)
108 return;
109 if (!c->dont_free)
110 free(c->sbb.iov.iov_base);
111 free(c);
112 }
113
114 /**
115 * Obtain pointer(s) to the sideband send buffer(s).
116 *
117 * \param c The sideband handle.
118 * \param iov Array of two I/O vectors.
119 *
120 * \return The number of buffers that need to be sent, either 1 or 2.
121 *
122 * This function fills out the buffers described by \a iov. The result can be
123 * passed to \ref xwritev() or similar.
124 *
125 * \sa \ref sb_get_recv_buffer().
126 */
127 int sb_get_send_buffers(struct sb_context *c, struct iovec iov[2])
128 {
129 struct sb_buffer *sbb = &c->sbb;
130 size_t n = c->bytes_dispatched;
131
132 if (n < SIDEBAND_HEADER_SIZE) {
133 iov[0].iov_base = c->header + n;
134 iov[0].iov_len = SIDEBAND_HEADER_SIZE - n;
135 if (!iov_valid(&sbb->iov))
136 goto out;
137 iov[1] = sbb->iov;
138 return 2;
139 }
140 n -= SIDEBAND_HEADER_SIZE;
141 assert(n < sbb->iov.iov_len);
142 iov[0].iov_base = sbb->iov.iov_base + n;
143 iov[0].iov_len = sbb->iov.iov_len - n;
144 out:
145 iov[1].iov_base = NULL;
146 iov[1].iov_len = 0;
147 return 1;
148 }
149
150 /**
151 * Update the sideband context after data has been sent.
152 *
153 * \param c The sideband handle.
154 * \param nbytes The number of sent bytes.
155 *
156 * \return False if more data must be sent to complete the sideband transfer,
157 * true if the transfer is complete. In this case all resources are freed and
158 * the sideband handle must not be used any more.
159 */
160 bool sb_sent(struct sb_context *c, size_t nbytes)
161 {
162 struct sb_buffer *sbb = &c->sbb;
163 size_t sz = SIDEBAND_HEADER_SIZE + sbb->iov.iov_len;
164
165 assert(c->bytes_dispatched + nbytes <= sz);
166 c->bytes_dispatched += nbytes;
167 if (c->bytes_dispatched < sz)
168 return false;
169 sb_free(c);
170 return true;
171 }
172
173 /**
174 * Obtain a pointer to the next sideband read buffer.
175 *
176 * \param c The sideband handle.
177 * \param iov Result IO vector.
178 *
179 * This fills in \a iov to point to the buffer to which the next chunk of
180 * received data should be written.
181 */
182 void sb_get_recv_buffer(struct sb_context *c, struct iovec *iov)
183 {
184 struct sb_buffer *sbb = &c->sbb;
185 size_t n = c->bytes_dispatched;
186
187 if (n < SIDEBAND_HEADER_SIZE) {
188 iov->iov_base = c->header + n;
189 iov->iov_len = SIDEBAND_HEADER_SIZE - n;
190 return;
191 }
192 n -= SIDEBAND_HEADER_SIZE;
193 assert(sbb->iov.iov_base);
194 assert(sbb->iov.iov_len > n);
195 iov->iov_base = sbb->iov.iov_base + n;
196 iov->iov_len = sbb->iov.iov_len - n;
197 }
198
199 /**
200 * Update the sideband context after data has been received.
201 *
202 * \param c The sideband handle.
203 * \param nbytes The number of bytes that have been received.
204 * \param result The received sideband packet.
205 *
206 * \return Negative on errors, zero if more data needs to be read to complete
207 * this sideband packet, one if the sideband packet has been received
208 * completely.
209 *
210 * Only if the function returns one, the sideband buffer pointed to by \a
211 * result is set to point to the received data.
212 */
213 int sb_received(struct sb_context *c, size_t nbytes, struct sb_buffer *result)
214 {
215 struct sb_buffer *sbb = &c->sbb;
216 size_t n = c->bytes_dispatched,
217 sz = SIDEBAND_HEADER_SIZE + sbb->iov.iov_len;
218
219 assert(n + nbytes <= sz);
220 c->bytes_dispatched += nbytes;
221 if (c->bytes_dispatched < SIDEBAND_HEADER_SIZE)
222 return 0;
223 if (n >= SIDEBAND_HEADER_SIZE) { /* header has already been received */
224 if (c->bytes_dispatched < sz) /* need to recv more body data */
225 return 0;
226 /* received everything, decrypt and return sbb */
227 if (c->trafo) {
228 struct iovec dst;
229 c->trafo(&sbb->iov, &dst, c->trafo_context);
230 if (sbb->iov.iov_base != dst.iov_base) {
231 free(sbb->iov.iov_base);
232 sbb->iov.iov_base = dst.iov_base;
233 }
234 }
235 ((char *)(sbb->iov.iov_base))[sbb->iov.iov_len] = '\0';
236 goto success;
237 }
238 /* header has been received, decrypt and decode it */
239 if (c->trafo) { /* decrypt */
240 struct iovec dst, src = (typeof(src)) {
241 .iov_base = c->header,
242 .iov_len = SIDEBAND_HEADER_SIZE
243 };
244 c->trafo(&src, &dst, c->trafo_context);
245 if (src.iov_base != dst.iov_base) {
246 memcpy(c->header, dst.iov_base,
247 SIDEBAND_HEADER_SIZE);
248 free(dst.iov_base);
249 }
250 }
251 /* Decode header, setup sbb */
252 sbb->iov.iov_len = read_u32(c->header);
253 sbb->band = read_u8(c->header + 4);
254 sbb->iov.iov_base = NULL;
255 if (sbb->iov.iov_len == 0) /* zero-sized msg */
256 goto success;
257 if (c->max_size > 0 && sbb->iov.iov_len > c->max_size) {
258 PARA_ERROR_LOG("packet too big (is %zu, max %zu)\n",
259 sbb->iov.iov_len, c->max_size);
260 return -E_SB_PACKET_SIZE;
261 }
262 /*
263 * We like to reserve one extra byte for the terminating NULL
264 * character. However, we must make sure the +1 below does not
265 * overflow iov_len.
266 */
267 if (sbb->iov.iov_len == (size_t)-1)
268 return -E_SB_PACKET_SIZE;
269 sbb->iov.iov_base = para_malloc(sbb->iov.iov_len + 1);
270 return 0; /* ready to read body */
271 success:
272 *result = c->sbb;
273 free(c);
274 return 1;
275 }