Deleted Added
sdiff udiff text old ( 198339 ) new ( 210568 )
full compact
common.c (198339) common.c (210568)
1/*-
2 * Copyright (c) 1998-2004 Dag-Erling Co�dan Sm�rgrav
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 13 unchanged lines hidden (view full) ---

22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 1998-2004 Dag-Erling Co�dan Sm�rgrav
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 13 unchanged lines hidden (view full) ---

22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/lib/libfetch/common.c 198339 2009-10-21 18:29:26Z fabient $");
30__FBSDID("$FreeBSD: head/lib/libfetch/common.c 210568 2010-07-28 16:11:22Z des $");
31
32#include <sys/param.h>
33#include <sys/socket.h>
34#include <sys/time.h>
35#include <sys/uio.h>
36
37#include <netinet/in.h>
38
39#include <ctype.h>
40#include <errno.h>
31
32#include <sys/param.h>
33#include <sys/socket.h>
34#include <sys/time.h>
35#include <sys/uio.h>
36
37#include <netinet/in.h>
38
39#include <ctype.h>
40#include <errno.h>
41#include <fcntl.h>
41#include <netdb.h>
42#include <pwd.h>
43#include <stdarg.h>
44#include <stdlib.h>
45#include <stdio.h>
46#include <string.h>
47#include <unistd.h>
48

--- 241 unchanged lines hidden (view full) ---

290 res->ai_protocol)) == -1)
291 continue;
292 if (bindaddr != NULL && *bindaddr != '\0' &&
293 fetch_bind(sd, res->ai_family, bindaddr) != 0) {
294 fetch_info("failed to bind to '%s'", bindaddr);
295 close(sd);
296 continue;
297 }
42#include <netdb.h>
43#include <pwd.h>
44#include <stdarg.h>
45#include <stdlib.h>
46#include <stdio.h>
47#include <string.h>
48#include <unistd.h>
49

--- 241 unchanged lines hidden (view full) ---

291 res->ai_protocol)) == -1)
292 continue;
293 if (bindaddr != NULL && *bindaddr != '\0' &&
294 fetch_bind(sd, res->ai_family, bindaddr) != 0) {
295 fetch_info("failed to bind to '%s'", bindaddr);
296 close(sd);
297 continue;
298 }
298 if (connect(sd, res->ai_addr, res->ai_addrlen) == 0)
299 if (connect(sd, res->ai_addr, res->ai_addrlen) == 0 &&
300 fcntl(sd, F_SETFL, O_NONBLOCK) == 0)
299 break;
300 close(sd);
301 }
302 freeaddrinfo(res0);
303 if (sd == -1) {
304 fetch_syserr();
305 return (NULL);
306 }

--- 7 unchanged lines hidden (view full) ---

314
315
316/*
317 * Enable SSL on a connection.
318 */
319int
320fetch_ssl(conn_t *conn, int verbose)
321{
301 break;
302 close(sd);
303 }
304 freeaddrinfo(res0);
305 if (sd == -1) {
306 fetch_syserr();
307 return (NULL);
308 }

--- 7 unchanged lines hidden (view full) ---

316
317
318/*
319 * Enable SSL on a connection.
320 */
321int
322fetch_ssl(conn_t *conn, int verbose)
323{
324 int ret, ssl_err;
322
323#ifdef WITH_SSL
324 /* Init the SSL library and context */
325 if (!SSL_library_init()){
326 fprintf(stderr, "SSL library init failed\n");
327 return (-1);
328 }
329

--- 4 unchanged lines hidden (view full) ---

334 SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY);
335
336 conn->ssl = SSL_new(conn->ssl_ctx);
337 if (conn->ssl == NULL){
338 fprintf(stderr, "SSL context creation failed\n");
339 return (-1);
340 }
341 SSL_set_fd(conn->ssl, conn->sd);
325
326#ifdef WITH_SSL
327 /* Init the SSL library and context */
328 if (!SSL_library_init()){
329 fprintf(stderr, "SSL library init failed\n");
330 return (-1);
331 }
332

--- 4 unchanged lines hidden (view full) ---

337 SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY);
338
339 conn->ssl = SSL_new(conn->ssl_ctx);
340 if (conn->ssl == NULL){
341 fprintf(stderr, "SSL context creation failed\n");
342 return (-1);
343 }
344 SSL_set_fd(conn->ssl, conn->sd);
342 if (SSL_connect(conn->ssl) == -1){
343 ERR_print_errors_fp(stderr);
344 return (-1);
345 while ((ret = SSL_connect(conn->ssl)) == -1) {
346 ssl_err = SSL_get_error(conn->ssl, ret);
347 if (ssl_err != SSL_ERROR_WANT_READ &&
348 ssl_err != SSL_ERROR_WANT_WRITE) {
349 ERR_print_errors_fp(stderr);
350 return (-1);
351 }
345 }
346
347 if (verbose) {
348 X509_NAME *name;
349 char *str;
350
351 fprintf(stderr, "SSL connection established using %s\n",
352 SSL_get_cipher(conn->ssl));

--- 12 unchanged lines hidden (view full) ---

365#else
366 (void)conn;
367 (void)verbose;
368 fprintf(stderr, "SSL support disabled\n");
369 return (-1);
370#endif
371}
372
352 }
353
354 if (verbose) {
355 X509_NAME *name;
356 char *str;
357
358 fprintf(stderr, "SSL connection established using %s\n",
359 SSL_get_cipher(conn->ssl));

--- 12 unchanged lines hidden (view full) ---

372#else
373 (void)conn;
374 (void)verbose;
375 fprintf(stderr, "SSL support disabled\n");
376 return (-1);
377#endif
378}
379
380#define FETCH_READ_WAIT -2
381#define FETCH_READ_ERROR -1
382#define FETCH_READ_DONE 0
373
383
384#ifdef WITH_SSL
385static ssize_t
386fetch_ssl_read(SSL *ssl, char *buf, size_t len)
387{
388 ssize_t rlen;
389 int ssl_err;
390
391 rlen = SSL_read(ssl, buf, len);
392 if (rlen < 0) {
393 ssl_err = SSL_get_error(ssl, rlen);
394 if (ssl_err == SSL_ERROR_WANT_READ ||
395 ssl_err == SSL_ERROR_WANT_WRITE) {
396 return (FETCH_READ_WAIT);
397 } else {
398 ERR_print_errors_fp(stderr);
399 return (FETCH_READ_ERROR);
400 }
401 }
402 return (rlen);
403}
404#endif
405
406static ssize_t
407fetch_socket_read(int sd, char *buf, size_t len)
408{
409 ssize_t rlen;
410
411 rlen = read(sd, buf, len);
412 if (rlen < 0) {
413 if (errno == EAGAIN || (errno == EINTR && fetchRestartCalls))
414 return (FETCH_READ_WAIT);
415 else
416 return (FETCH_READ_ERROR);
417 }
418 return (rlen);
419}
420
374/*
375 * Read a character from a connection w/ timeout
376 */
377ssize_t
378fetch_read(conn_t *conn, char *buf, size_t len)
379{
380 struct timeval now, timeout, delta;
381 fd_set readfds;
382 ssize_t rlen, total;
383 int r;
384
385 if (fetchTimeout) {
386 FD_ZERO(&readfds);
387 gettimeofday(&timeout, NULL);
388 timeout.tv_sec += fetchTimeout;
389 }
390
391 total = 0;
392 while (len > 0) {
421/*
422 * Read a character from a connection w/ timeout
423 */
424ssize_t
425fetch_read(conn_t *conn, char *buf, size_t len)
426{
427 struct timeval now, timeout, delta;
428 fd_set readfds;
429 ssize_t rlen, total;
430 int r;
431
432 if (fetchTimeout) {
433 FD_ZERO(&readfds);
434 gettimeofday(&timeout, NULL);
435 timeout.tv_sec += fetchTimeout;
436 }
437
438 total = 0;
439 while (len > 0) {
440 /*
441 * The socket is non-blocking. Instead of the canonical
442 * select() -> read(), we do the following:
443 *
444 * 1) call read() or SSL_read().
445 * 2) if an error occurred, return -1.
446 * 3) if we received data but we still expect more,
447 * update our counters and loop.
448 * 4) if read() or SSL_read() signaled EOF, return.
449 * 5) if we did not receive any data but we're not at EOF,
450 * call select().
451 *
452 * In the SSL case, this is necessary because if we
453 * receive a close notification, we have to call
454 * SSL_read() one additional time after we've read
455 * everything we received.
456 *
457 * In the non-SSL case, it may improve performance (very
458 * slightly) when reading small amounts of data.
459 */
460#ifdef WITH_SSL
461 if (conn->ssl != NULL)
462 rlen = fetch_ssl_read(conn->ssl, buf, len);
463 else
464#endif
465 rlen = fetch_socket_read(conn->sd, buf, len);
466 if (rlen == 0) {
467 break;
468 } else if (rlen > 0) {
469 len -= rlen;
470 buf += rlen;
471 total += rlen;
472 continue;
473 } else if (rlen == FETCH_READ_ERROR) {
474 return (-1);
475 }
476 // assert(rlen == FETCH_READ_WAIT);
393 while (fetchTimeout && !FD_ISSET(conn->sd, &readfds)) {
394 FD_SET(conn->sd, &readfds);
395 gettimeofday(&now, NULL);
396 delta.tv_sec = timeout.tv_sec - now.tv_sec;
397 delta.tv_usec = timeout.tv_usec - now.tv_usec;
398 if (delta.tv_usec < 0) {
399 delta.tv_usec += 1000000;
400 delta.tv_sec--;

--- 7 unchanged lines hidden (view full) ---

408 r = select(conn->sd + 1, &readfds, NULL, NULL, &delta);
409 if (r == -1) {
410 if (errno == EINTR && fetchRestartCalls)
411 continue;
412 fetch_syserr();
413 return (-1);
414 }
415 }
477 while (fetchTimeout && !FD_ISSET(conn->sd, &readfds)) {
478 FD_SET(conn->sd, &readfds);
479 gettimeofday(&now, NULL);
480 delta.tv_sec = timeout.tv_sec - now.tv_sec;
481 delta.tv_usec = timeout.tv_usec - now.tv_usec;
482 if (delta.tv_usec < 0) {
483 delta.tv_usec += 1000000;
484 delta.tv_sec--;

--- 7 unchanged lines hidden (view full) ---

492 r = select(conn->sd + 1, &readfds, NULL, NULL, &delta);
493 if (r == -1) {
494 if (errno == EINTR && fetchRestartCalls)
495 continue;
496 fetch_syserr();
497 return (-1);
498 }
499 }
416#ifdef WITH_SSL
417 if (conn->ssl != NULL)
418 rlen = SSL_read(conn->ssl, buf, len);
419 else
420#endif
421 rlen = read(conn->sd, buf, len);
422 if (rlen == 0)
423 break;
424 if (rlen < 0) {
425 if (errno == EINTR && fetchRestartCalls)
426 continue;
427 return (-1);
428 }
429 len -= rlen;
430 buf += rlen;
431 total += rlen;
432 }
433 return (total);
434}
435
436
437/*
438 * Read a line of text from a connection w/ timeout
439 */

--- 103 unchanged lines hidden (view full) ---

543 if (conn->ssl != NULL)
544 wlen = SSL_write(conn->ssl,
545 iov->iov_base, iov->iov_len);
546 else
547#endif
548 wlen = writev(conn->sd, iov, iovcnt);
549 if (wlen == 0) {
550 /* we consider a short write a failure */
500 }
501 return (total);
502}
503
504
505/*
506 * Read a line of text from a connection w/ timeout
507 */

--- 103 unchanged lines hidden (view full) ---

611 if (conn->ssl != NULL)
612 wlen = SSL_write(conn->ssl,
613 iov->iov_base, iov->iov_len);
614 else
615#endif
616 wlen = writev(conn->sd, iov, iovcnt);
617 if (wlen == 0) {
618 /* we consider a short write a failure */
619 /* XXX perhaps we shouldn't in the SSL case */
551 errno = EPIPE;
552 fetch_syserr();
553 return (-1);
554 }
555 if (wlen < 0) {
556 if (errno == EINTR && fetchRestartCalls)
557 continue;
558 return (-1);

--- 228 unchanged lines hidden --- 		620 errno = EPIPE;
621 fetch_syserr();
622 return (-1);
623 }
624 if (wlen < 0) {
625 if (errno == EINTR && fetchRestartCalls)
626 continue;
627 return (-1);

--- 228 unchanged lines hidden ---