File: | src/usr.bin/rsync/socket.c |
Warning: | line 108, column 11 Although the value stored to 'c' is used in the enclosing expression, the value is never actually read from 'c' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: socket.c,v 1.33 2022/12/26 19:16:02 jmc Exp $ */ |
2 | /* |
3 | * Copyright (c) 2019 Kristaps Dzonsons <kristaps@bsd.lv> |
4 | * |
5 | * Permission to use, copy, modify, and distribute this software for any |
6 | * purpose with or without fee is hereby granted, provided that the above |
7 | * copyright notice and this permission notice appear in all copies. |
8 | * |
9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
16 | */ |
17 | #include <sys/stat.h> |
18 | #include <sys/socket.h> |
19 | #include <arpa/inet.h> |
20 | #include <netinet/in.h> |
21 | |
22 | #include <assert.h> |
23 | #include <ctype.h> |
24 | #include <errno(*__errno()).h> |
25 | #include <fcntl.h> |
26 | #include <inttypes.h> |
27 | #include <netdb.h> |
28 | #include <poll.h> |
29 | #include <resolv.h> |
30 | #include <stdlib.h> |
31 | #include <string.h> |
32 | #include <unistd.h> |
33 | #include <err.h> |
34 | |
35 | #include "extern.h" |
36 | |
37 | /* |
38 | * Defines a resolved IP address for the host |
39 | * There can be many, IPV4 or IPV6. |
40 | */ |
41 | struct source { |
42 | int family; /* PF_INET or PF_INET6 */ |
43 | char ip[INET6_ADDRSTRLEN46]; /* formatted string */ |
44 | struct sockaddr_storage sa; /* socket */ |
45 | socklen_t salen; /* length of socket buffer */ |
46 | }; |
47 | |
48 | /* |
49 | * Try to bind to a local IP address matching the address family passed. |
50 | * Return -1 on failure to bind to any address, 0 on success. |
51 | */ |
52 | static int |
53 | inet_bind(int s, sa_family_t af, const struct source *bsrc, size_t bsrcsz) |
54 | { |
55 | size_t i; |
56 | |
57 | if (bsrc == NULL((void *)0)) |
58 | return 0; |
59 | for (i = 0; i < bsrcsz; i++) { |
60 | if (bsrc[i].family != af) |
61 | continue; |
62 | if (bind(s, (const struct sockaddr *)&bsrc[i].sa, |
63 | bsrc[i].salen) == -1) |
64 | continue; |
65 | return 0; |
66 | } |
67 | return -1; |
68 | } |
69 | |
70 | /* |
71 | * Connect to an IP address representing a host. |
72 | * Return <0 on failure, 0 on try another address, >0 on success. |
73 | */ |
74 | static int |
75 | inet_connect(int *sd, const struct source *src, const char *host, |
76 | const struct source *bsrc, size_t bsrcsz) |
77 | { |
78 | struct pollfd pfd; |
79 | socklen_t optlen; |
80 | int c; |
81 | int optval; |
82 | |
83 | if (*sd != -1) |
84 | close(*sd); |
85 | |
86 | LOG2("trying: %s, %s", src->ip, host)rsync_log( 1, ("trying: %s, %s"), src->ip, host); |
87 | |
88 | if ((*sd = socket(src->family, SOCK_STREAM1 | SOCK_NONBLOCK0x4000, 0)) |
89 | == -1) { |
90 | ERR("socket")rsync_err( ("socket")); |
91 | return -1; |
92 | } |
93 | |
94 | if (inet_bind(*sd, src->family, bsrc, bsrcsz) == -1) { |
95 | ERR("bind")rsync_err( ("bind")); |
96 | return -1; |
97 | } |
98 | |
99 | /* |
100 | * Initiate blocking connection. |
101 | * We use non-blocking connect() so we can poll() for contimeout. |
102 | */ |
103 | |
104 | if ((c = connect(*sd, (const struct sockaddr *)&src->sa, src->salen)) |
105 | != 0 && errno(*__errno()) == EINPROGRESS36) { |
106 | pfd.fd = *sd; |
107 | pfd.events = POLLOUT0x0004; |
108 | switch (c = poll(&pfd, 1, poll_contimeout)) { |
Although the value stored to 'c' is used in the enclosing expression, the value is never actually read from 'c' | |
109 | case 1: |
110 | optlen = sizeof(optval); |
111 | if ((c = getsockopt(*sd, SOL_SOCKET0xffff, SO_ERROR0x1007, &optval, |
112 | &optlen)) == 0) { |
113 | errno(*__errno()) = optval; |
114 | if (optval != 0) |
115 | c = -1; |
116 | } |
117 | break; |
118 | case 0: |
119 | errno(*__errno()) = ETIMEDOUT60; |
120 | WARNX("connect timeout: %s, %s", src->ip, host)rsync_warnx( ("connect timeout: %s, %s"), src->ip, host); |
121 | return 0; |
122 | default: |
123 | ERR("poll failed")rsync_err( ("poll failed")); |
124 | return -1; |
125 | } |
126 | } |
127 | if (c == -1) { |
128 | if (errno(*__errno()) == EADDRNOTAVAIL49) |
129 | return 0; |
130 | if (errno(*__errno()) == ECONNREFUSED61 || errno(*__errno()) == EHOSTUNREACH65) { |
131 | WARNX("connect refused: %s, %s", src->ip, host)rsync_warnx( ("connect refused: %s, %s"), src->ip, host); |
132 | return 0; |
133 | } |
134 | ERR("connect")rsync_err( ("connect")); |
135 | return -1; |
136 | } |
137 | |
138 | return 1; |
139 | } |
140 | |
141 | /* |
142 | * Resolve the socket addresses for host, both in IPV4 and IPV6. |
143 | * Once completed, the "dns" pledge may be dropped. |
144 | * Returns the addresses on success, NULL on failure (sz is always zero, |
145 | * in this case). |
146 | */ |
147 | static struct source * |
148 | inet_resolve(struct sess *sess, const char *host, size_t *sz, int passive) |
149 | { |
150 | struct addrinfo hints, *res0, *res; |
151 | struct sockaddr *sa; |
152 | struct source *src = NULL((void *)0); |
153 | const char *port = sess->opts->port; |
154 | size_t i, srcsz = 0; |
155 | int error; |
156 | |
157 | *sz = 0; |
158 | |
159 | memset(&hints, 0, sizeof(hints)); |
160 | hints.ai_family = PF_UNSPEC0; |
161 | hints.ai_socktype = SOCK_STREAM1; |
162 | if (passive) { |
163 | hints.ai_flags = SOCK_STREAM1; |
164 | port = NULL((void *)0); |
165 | } |
166 | |
167 | error = getaddrinfo(host, port, &hints, &res0); |
168 | |
169 | LOG2("resolving: %s", host)rsync_log( 1, ("resolving: %s"), host); |
170 | |
171 | if (error == EAI_AGAIN-3 || error == EAI_NONAME-2) { |
172 | ERRX("could not resolve hostname %s: %s",rsync_errx( ("could not resolve hostname %s: %s"), host, gai_strerror (error)) |
173 | host, gai_strerror(error))rsync_errx( ("could not resolve hostname %s: %s"), host, gai_strerror (error)); |
174 | return NULL((void *)0); |
175 | } else if (error == EAI_SERVICE-8) { |
176 | ERRX("could not resolve service rsync: %s",rsync_errx( ("could not resolve service rsync: %s"), gai_strerror (error)) |
177 | gai_strerror(error))rsync_errx( ("could not resolve service rsync: %s"), gai_strerror (error)); |
178 | return NULL((void *)0); |
179 | } else if (error) { |
180 | ERRX("getaddrinfo: %s: %s", host, gai_strerror(error))rsync_errx( ("getaddrinfo: %s: %s"), host, gai_strerror(error )); |
181 | return NULL((void *)0); |
182 | } |
183 | |
184 | /* Allocate for all available addresses. */ |
185 | |
186 | for (res = res0; res != NULL((void *)0); res = res->ai_next) |
187 | if (res->ai_family == AF_INET2 || |
188 | res->ai_family == AF_INET624) |
189 | srcsz++; |
190 | |
191 | if (srcsz == 0) { |
192 | ERRX("no addresses resolved: %s", host)rsync_errx( ("no addresses resolved: %s"), host); |
193 | freeaddrinfo(res0); |
194 | return NULL((void *)0); |
195 | } |
196 | |
197 | src = calloc(srcsz, sizeof(struct source)); |
198 | if (src == NULL((void *)0)) { |
199 | ERRX("calloc")rsync_errx( ("calloc")); |
200 | freeaddrinfo(res0); |
201 | return NULL((void *)0); |
202 | } |
203 | |
204 | for (i = 0, res = res0; res != NULL((void *)0); res = res->ai_next) { |
205 | if (res->ai_family != AF_INET2 && |
206 | res->ai_family != AF_INET624) |
207 | continue; |
208 | |
209 | assert(i < srcsz)((i < srcsz) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 209, __func__, "i < srcsz")); |
210 | |
211 | /* Copy the socket address. */ |
212 | |
213 | src[i].salen = res->ai_addrlen; |
214 | memcpy(&src[i].sa, res->ai_addr, src[i].salen); |
215 | |
216 | /* Format as a string, too. */ |
217 | |
218 | sa = res->ai_addr; |
219 | if (res->ai_family == AF_INET2) { |
220 | src[i].family = PF_INET2; |
221 | inet_ntop(AF_INET2, |
222 | &(((struct sockaddr_in *)sa)->sin_addr), |
223 | src[i].ip, INET6_ADDRSTRLEN46); |
224 | } else { |
225 | src[i].family = PF_INET624; |
226 | inet_ntop(AF_INET624, |
227 | &(((struct sockaddr_in6 *)sa)->sin6_addr), |
228 | src[i].ip, INET6_ADDRSTRLEN46); |
229 | } |
230 | |
231 | LOG2("hostname resolved: %s: %s", host, src[i].ip)rsync_log( 1, ("hostname resolved: %s: %s"), host, src[i].ip); |
232 | i++; |
233 | } |
234 | |
235 | freeaddrinfo(res0); |
236 | *sz = srcsz; |
237 | return src; |
238 | } |
239 | |
240 | /* |
241 | * Process an rsyncd preamble line. |
242 | * This is either free-form text or @RSYNCD commands. |
243 | * Return <0 on failure, 0 on try more lines, >0 on finished. |
244 | */ |
245 | static int |
246 | protocol_line(struct sess *sess, __attribute__((unused)) const char *host, |
247 | const char *cp) |
248 | { |
249 | int major, minor; |
250 | |
251 | if (strncmp(cp, "@RSYNCD: ", 9)) { |
252 | if (sess->opts->no_motd == 0) |
253 | LOG1("%s", cp)rsync_log( 0, ("%s"), cp); |
254 | return 0; |
255 | } |
256 | |
257 | cp += 9; |
258 | while (isspace((unsigned char)*cp)) |
259 | cp++; |
260 | |
261 | /* @RSYNCD: OK indicates that we're finished. */ |
262 | |
263 | if (strcmp(cp, "OK") == 0) |
264 | return 1; |
265 | |
266 | /* |
267 | * Otherwise, all we have left is our version. |
268 | * There are two formats: x.y (w/submodule) and x. |
269 | */ |
270 | |
271 | if (sscanf(cp, "%d.%d", &major, &minor) == 2) { |
272 | sess->rver = major; |
273 | return 0; |
274 | } else if (sscanf(cp, "%d", &major) == 1) { |
275 | sess->rver = major; |
276 | return 0; |
277 | } |
278 | |
279 | ERRX("rsyncd protocol error: unknown command")rsync_errx( ("rsyncd protocol error: unknown command")); |
280 | return -1; |
281 | } |
282 | |
283 | /* |
284 | * Connect to a remote rsync://-enabled server sender. |
285 | * Returns exit code 0 on success, 1 on failure. |
286 | */ |
287 | int |
288 | rsync_connect(const struct opts *opts, int *sd, const struct fargs *f) |
289 | { |
290 | struct sess sess; |
291 | struct source *src = NULL((void *)0), *bsrc = NULL((void *)0); |
292 | size_t i, srcsz = 0, bsrcsz = 0; |
293 | int c, rc = 1; |
294 | |
295 | if (pledge("stdio unix rpath wpath cpath dpath inet fattr chown dns getpw unveil", |
296 | NULL((void *)0)) == -1) |
297 | err(ERR_IPC14, "pledge"); |
298 | |
299 | memset(&sess, 0, sizeof(struct sess)); |
300 | sess.opts = opts; |
301 | |
302 | assert(f->host != NULL)((f->host != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 302, __func__, "f->host != NULL")); |
303 | |
304 | /* Resolve all IP addresses from the host. */ |
305 | |
306 | if ((src = inet_resolve(&sess, f->host, &srcsz, 0)) == NULL((void *)0)) { |
307 | ERRX1("inet_resolve")rsync_errx1( ("inet_resolve")); |
308 | exit(1); |
309 | } |
310 | if (opts->address != NULL((void *)0)) |
311 | if ((bsrc = inet_resolve(&sess, opts->address, &bsrcsz, 1)) == |
312 | NULL((void *)0)) { |
313 | ERRX1("inet_resolve bind")rsync_errx1( ("inet_resolve bind")); |
314 | exit(1); |
315 | } |
316 | |
317 | /* Drop the DNS pledge. */ |
318 | |
319 | if (pledge("stdio unix rpath wpath cpath dpath fattr chown getpw inet unveil", |
320 | NULL((void *)0)) == -1) { |
321 | ERR("pledge")rsync_err( ("pledge")); |
322 | exit(1); |
323 | } |
324 | |
325 | /* |
326 | * Iterate over all addresses, trying to connect. |
327 | * When we succeed, then continue using the connected socket. |
328 | */ |
329 | |
330 | assert(srcsz)((srcsz) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 330, __func__, "srcsz")); |
331 | for (i = 0; i < srcsz; i++) { |
332 | c = inet_connect(sd, &src[i], f->host, bsrc, bsrcsz); |
333 | if (c < 0) { |
334 | ERRX1("inet_connect")rsync_errx1( ("inet_connect")); |
335 | goto out; |
336 | } else if (c > 0) |
337 | break; |
338 | } |
339 | |
340 | /* Drop the inet pledge. */ |
341 | if (pledge("stdio unix rpath wpath cpath dpath fattr chown getpw unveil", |
342 | NULL((void *)0)) == -1) { |
343 | ERR("pledge")rsync_err( ("pledge")); |
344 | goto out; |
345 | } |
346 | |
347 | if (i == srcsz) { |
348 | ERRX("cannot connect to host: %s", f->host)rsync_errx( ("cannot connect to host: %s"), f->host); |
349 | goto out; |
350 | } |
351 | |
352 | LOG2("connected: %s, %s", src[i].ip, f->host)rsync_log( 1, ("connected: %s, %s"), src[i].ip, f->host); |
353 | |
354 | free(src); |
355 | free(bsrc); |
356 | return 0; |
357 | out: |
358 | free(src); |
359 | free(bsrc); |
360 | if (*sd != -1) |
361 | close(*sd); |
362 | return rc; |
363 | } |
364 | |
365 | /* |
366 | * Talk to a remote rsync://-enabled server sender. |
367 | * Returns exit code 0 on success, 1 on failure, 2 on failure with |
368 | * incompatible protocols. |
369 | */ |
370 | int |
371 | rsync_socket(const struct opts *opts, int sd, const struct fargs *f) |
372 | { |
373 | struct sess sess; |
374 | size_t i, skip; |
375 | int c, rc = 1; |
376 | char **args, buf[BUFSIZ1024]; |
377 | uint8_t byte; |
378 | |
379 | if (pledge("stdio unix rpath wpath cpath dpath fattr chown getpw unveil", |
380 | NULL((void *)0)) == -1) |
381 | err(ERR_IPC14, "pledge"); |
382 | |
383 | memset(&sess, 0, sizeof(struct sess)); |
384 | sess.lver = RSYNC_PROTOCOL(27); |
385 | sess.opts = opts; |
386 | |
387 | assert(f->host != NULL)((f->host != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 387, __func__, "f->host != NULL")); |
388 | assert(f->module != NULL)((f->module != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 388, __func__, "f->module != NULL")); |
389 | |
390 | args = fargs_cmdline(&sess, f, &skip); |
391 | |
392 | /* Initiate with the rsyncd version and module request. */ |
393 | |
394 | (void)snprintf(buf, sizeof(buf), "@RSYNCD: %d", sess.lver); |
395 | if (!io_write_line(&sess, sd, buf)) { |
396 | ERRX1("io_write_line")rsync_errx1( ("io_write_line")); |
397 | goto out; |
398 | } |
399 | |
400 | LOG2("requesting module: %s, %s", f->module, f->host)rsync_log( 1, ("requesting module: %s, %s"), f->module, f-> host); |
401 | |
402 | if (!io_write_line(&sess, sd, f->module)) { |
403 | ERRX1("io_write_line")rsync_errx1( ("io_write_line")); |
404 | goto out; |
405 | } |
406 | |
407 | /* |
408 | * Now we read the server's response, byte-by-byte, one newline |
409 | * terminated at a time, limited to BUFSIZ line length. |
410 | * For this protocol version, this consists of either @RSYNCD |
411 | * followed by some text (just "ok" and the remote version) or |
412 | * the message of the day. |
413 | */ |
414 | |
415 | for (;;) { |
416 | for (i = 0; i < sizeof(buf); i++) { |
417 | if (!io_read_byte(&sess, sd, &byte)) { |
418 | ERRX1("io_read_byte")rsync_errx1( ("io_read_byte")); |
419 | goto out; |
420 | } |
421 | if ((buf[i] = byte) == '\n') |
422 | break; |
423 | } |
424 | if (i == sizeof(buf)) { |
425 | ERRX("line buffer overrun")rsync_errx( ("line buffer overrun")); |
426 | goto out; |
427 | } else if (i == 0) |
428 | continue; |
429 | |
430 | /* |
431 | * The rsyncd protocol isn't very clear as to whether we |
432 | * get a CRLF or not: I don't actually see this being |
433 | * transmitted over the wire. |
434 | */ |
435 | |
436 | assert(i > 0)((i > 0) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 436, __func__, "i > 0")); |
437 | buf[i] = '\0'; |
438 | if (buf[i - 1] == '\r') |
439 | buf[i - 1] = '\0'; |
440 | |
441 | if ((c = protocol_line(&sess, f->host, buf)) < 0) { |
442 | ERRX1("protocol_line")rsync_errx1( ("protocol_line")); |
443 | goto out; |
444 | } else if (c > 0) |
445 | break; |
446 | } |
447 | |
448 | /* |
449 | * Now we've exchanged all of our protocol information. |
450 | * We want to send our command-line arguments over the wire, |
451 | * each with a newline termination. |
452 | * Use the same arguments when invoking the server, but leave |
453 | * off the binary name(s). |
454 | * Emit a standalone newline afterward. |
455 | */ |
456 | |
457 | for (i = skip ; args[i] != NULL((void *)0); i++) |
458 | if (!io_write_line(&sess, sd, args[i])) { |
459 | ERRX1("io_write_line")rsync_errx1( ("io_write_line")); |
460 | goto out; |
461 | } |
462 | if (!io_write_byte(&sess, sd, '\n')) { |
463 | ERRX1("io_write_line")rsync_errx1( ("io_write_line")); |
464 | goto out; |
465 | } |
466 | |
467 | /* |
468 | * All data after this point is going to be multiplexed, so turn |
469 | * on the multiplexer for our reads and writes. |
470 | */ |
471 | |
472 | /* Protocol exchange: get the random seed. */ |
473 | |
474 | if (!io_read_int(&sess, sd, &sess.seed)) { |
475 | ERRX1("io_read_int")rsync_errx1( ("io_read_int")); |
476 | goto out; |
477 | } |
478 | |
479 | /* Now we've completed the handshake. */ |
480 | |
481 | if (sess.rver < sess.lver) { |
482 | ERRX("remote protocol is older than our own (%d < %d): "rsync_errx( ("remote protocol is older than our own (%d < %d): " "this is not supported"), sess.rver, sess.lver) |
483 | "this is not supported",rsync_errx( ("remote protocol is older than our own (%d < %d): " "this is not supported"), sess.rver, sess.lver) |
484 | sess.rver, sess.lver)rsync_errx( ("remote protocol is older than our own (%d < %d): " "this is not supported"), sess.rver, sess.lver); |
485 | rc = 2; |
486 | goto out; |
487 | } |
488 | |
489 | sess.mplex_reads = 1; |
490 | LOG2("read multiplexing enabled")rsync_log( 1, ("read multiplexing enabled")); |
491 | |
492 | LOG2("socket detected client version %d, server version %d, seed %d",rsync_log( 1, ("socket detected client version %d, server version %d, seed %d" ), sess.lver, sess.rver, sess.seed) |
493 | sess.lver, sess.rver, sess.seed)rsync_log( 1, ("socket detected client version %d, server version %d, seed %d" ), sess.lver, sess.rver, sess.seed); |
494 | |
495 | assert(f->mode == FARGS_RECEIVER)((f->mode == FARGS_RECEIVER) ? (void)0 : __assert2("/usr/src/usr.bin/rsync/socket.c" , 495, __func__, "f->mode == FARGS_RECEIVER")); |
496 | |
497 | LOG2("client starting receiver: %s", f->host)rsync_log( 1, ("client starting receiver: %s"), f->host); |
498 | if (!rsync_receiver(&sess, sd, sd, f->sink)) { |
499 | ERRX1("rsync_receiver")rsync_errx1( ("rsync_receiver")); |
500 | goto out; |
501 | } |
502 | |
503 | #if 0 |
504 | /* Probably the EOF. */ |
505 | if (io_read_check(&sess, sd)) |
506 | WARNX("data remains in read pipe")rsync_warnx( ("data remains in read pipe")); |
507 | #endif |
508 | |
509 | rc = 0; |
510 | out: |
511 | free(args); |
512 | return rc; |
513 | } |