diff --git a/src/include/options.h b/src/include/options.h index b477a7e..65f244f 100644 --- a/src/include/options.h +++ b/src/include/options.h @@ -35,7 +35,7 @@ struct opts_s { /* structure describing run-time options */ bool bytes; /* bytes transferred flag */ bool bits; /* report transfer size in bits */ bool bufpercent; /* transfer buffer percentage flag */ - unsigned int lastwritten; /* show N bytes last written */ + size_t lastwritten; /* show N bytes last written */ bool force; /* force-if-not-terminal flag */ bool cursor; /* whether to use cursor positioning */ bool numeric; /* numeric output only */ diff --git a/src/include/pv-internal.h b/src/include/pv-internal.h index d104fff..3aece37 100644 --- a/src/include/pv-internal.h +++ b/src/include/pv-internal.h @@ -31,7 +31,7 @@ extern "C" { #define PV_DISPLAY_OUTPUTBUF 256 #define PV_DISPLAY_FINETA 512 -#define RATE_GRANULARITY 100000000.0L /* nsec between -L rate chunks */ +#define RATE_GRANULARITY 100000000 /* nsec between -L rate chunks */ #define RATE_BURST_WINDOW 5 /* rate burst window (multiples of rate) */ #define REMOTE_INTERVAL 100000000 /* nsec between checks for -R */ #define BUFFER_SIZE (size_t) 409600 /* default transfer buffer size */ @@ -170,8 +170,8 @@ struct pvstate_s { off_t initial_offset; /*@only@*/ char *display_buffer; long display_buffer_size; - int lastoutput_length; /* number of last-output bytes to show */ - unsigned char lastoutput_buffer[PV_SIZEOF_LASTOUTPUT_BUFFER]; + size_t lastoutput_length; /* number of last-output bytes to show */ + char lastoutput_buffer[PV_SIZEOF_LASTOUTPUT_BUFFER]; int prev_width; /* screen width last time we were called */ int prev_length; /* length of last string we output */ char str_name[PV_SIZEOF_STR_NAME]; @@ -226,7 +226,7 @@ struct pvstate_s { * is the offset in the buffer that we've written data up to. It * will always be less than or equal to read_position. */ - unsigned char *transfer_buffer; /* data transfer buffer */ + /*@keep@*/ /*@null@*/ char *transfer_buffer; /* data transfer buffer */ size_t buffer_size; /* size of buffer */ size_t read_position; /* amount of data in buffer */ size_t write_position; /* buffered data written */ @@ -285,7 +285,7 @@ void pv_error(pvstate_t, char *, ...); int pv_main_loop(pvstate_t); void pv_display(pvstate_t, long double, off_t, off_t); -off_t pv_transfer(pvstate_t, int, bool *, bool *, off_t, long *); +ssize_t pv_transfer(pvstate_t, int, bool *, bool *, off_t, long *); int pv_next_file(pvstate_t, unsigned int, int); /*@out@*/ const char *pv_current_file_name(pvstate_t); diff --git a/src/include/pv.h b/src/include/pv.h index 281320b..f1380a3 100644 --- a/src/include/pv.h +++ b/src/include/pv.h @@ -139,7 +139,7 @@ extern void pv_state_set_format(pvstate_t state, bool progress, bool fineta, bool rate, bool average_rate, bool bytes, bool bufpercent, - unsigned int lastwritten, + size_t lastwritten, /*@null@*/ const char *name); /* diff --git a/src/main/options.c b/src/main/options.c index fd84628..502c9c1 100644 --- a/src/main/options.c +++ b/src/main/options.c @@ -341,7 +341,7 @@ opts_t opts_parse(unsigned int argc, char **argv) opts->no_splice = true; break; case 'A': - opts->lastwritten = pv_getnum_ui(optarg); + opts->lastwritten = (size_t) pv_getnum_ui(optarg); numopts++; opts->no_splice = true; break; diff --git a/src/main/remote.c b/src/main/remote.c index 9b6e108..083ee90 100644 --- a/src/main/remote.c +++ b/src/main/remote.c @@ -35,7 +35,7 @@ struct remote_msg { bool average_rate; /* average rate counter flag */ bool bytes; /* bytes transferred flag */ bool bufpercent; /* transfer buffer percentage flag */ - unsigned int lastwritten; /* last-written bytes count */ + size_t lastwritten; /* last-written bytes count */ off_t rate_limit; /* rate limit, in bytes per second */ size_t buffer_size; /* buffer size, in bytes (0=default) */ off_t size; /* total size of data */ diff --git a/src/pv/loop.c b/src/pv/loop.c index 9b3ae5a..4c3eb73 100644 --- a/src/pv/loop.c +++ b/src/pv/loop.c @@ -33,8 +33,8 @@ */ int pv_main_loop(pvstate_t state) { - long written, lineswritten; - long long total_written, transferred_since_last, cansend; + long lineswritten; + off_t written, total_written, transferred_since_last, cansend; long double target; bool eof_in, eof_out, final_update; struct timespec start_time, next_update, next_ratecheck, cur_time; @@ -67,12 +67,20 @@ int pv_main_loop(pvstate_t state) eof_in = false; eof_out = false; total_written = 0; + lineswritten = 0; transferred_since_last = 0; state->initial_offset = 0; + memset(&cur_time, 0, sizeof(cur_time)); + memset(&start_time, 0, sizeof(start_time)); + pv_elapsedtime_read(&cur_time); pv_elapsedtime_copy(&start_time, &cur_time); + memset(&next_ratecheck, 0, sizeof(next_ratecheck)); + memset(&next_remotecheck, 0, sizeof(next_remotecheck)); + memset(&next_update, 0, sizeof(next_update)); + pv_elapsedtime_copy(&next_ratecheck, &cur_time); pv_elapsedtime_copy(&next_remotecheck, &cur_time); pv_elapsedtime_copy(&next_update, &cur_time); @@ -124,8 +132,8 @@ int pv_main_loop(pvstate_t state) * read and we weren't given a target buffer size. */ if ((0 == fstat(fd, &sb)) && (0 == state->target_buffer_size)) { - unsigned long long sz; - sz = sb.st_blksize * 32; + size_t sz; + sz = (size_t) (sb.st_blksize * 32); if (sz > BUFFER_SIZE_MAX) sz = BUFFER_SIZE_MAX; state->target_buffer_size = sz; @@ -147,7 +155,7 @@ int pv_main_loop(pvstate_t state) pv_elapsedtime_add_nsec(&next_remotecheck, REMOTE_INTERVAL); } - if (state->pv_sig_abort) + if (1 == state->pv_sig_abort) break; if (state->rate_limit > 0) { @@ -155,14 +163,15 @@ int pv_main_loop(pvstate_t state) if (pv_elapsedtime_compare(&cur_time, &next_ratecheck) > 0) { target += ((long double) (state->rate_limit)) / (long double) (1000000000.0 / - RATE_GRANULARITY); + (long + double) (RATE_GRANULARITY)); long double burst_max = ((long double) (state->rate_limit * RATE_BURST_WINDOW)); if (target > burst_max) { target = burst_max; } pv_elapsedtime_add_nsec(&next_ratecheck, RATE_GRANULARITY); } - cansend = target; + cansend = (off_t) target; } /* @@ -170,7 +179,7 @@ int pv_main_loop(pvstate_t state) * try to write more than we're allowed to. */ if ((0 < state->size) && (state->stop_at_size)) { - if (((long) (state->size) < (total_written + cansend)) + if ((state->size < (total_written + cansend)) || ((0 == cansend) && (0 == state->rate_limit))) { cansend = state->size - total_written; @@ -225,7 +234,7 @@ int pv_main_loop(pvstate_t state) if (eof_in && eof_out) { final_update = true; if ((state->display_visible) - || (0 == state->delay_start)) { + || (state->delay_start < 0.001)) { pv_elapsedtime_copy(&next_update, &cur_time); } } @@ -290,12 +299,14 @@ int pv_main_loop(pvstate_t state) * Calculate the effective start time: the time we actually * started, plus the total time we spent stopped. */ + memset(&init_time, 0, sizeof(init_time)); pv_elapsedtime_add(&init_time, &start_time, &(state->pv_sig_toffset)); /* * Now get the effective elapsed transfer time - current * time minus effective start time. */ + memset(&transfer_elapsed, 0, sizeof(transfer_elapsed)); pv_elapsedtime_subtract(&transfer_elapsed, &cur_time, &init_time); elapsed_seconds = pv_elapsedtime_seconds(&transfer_elapsed); @@ -304,7 +315,7 @@ int pv_main_loop(pvstate_t state) transferred_since_last = -1; /* Resize the display, if a resize signal was received. */ - if (state->pv_sig_newsize) { + if (1 == state->pv_sig_newsize) { unsigned int new_width, new_height; state->pv_sig_newsize = 0; @@ -332,7 +343,7 @@ int pv_main_loop(pvstate_t state) pv_write_retry(STDERR_FILENO, "\n", 1); } - if (state->pv_sig_abort) + if (1 == state->pv_sig_abort) state->exit_status |= 32; if (fd >= 0) @@ -360,6 +371,7 @@ int pv_watchfd_loop(pvstate_t state) int first_check; int rc; + memset(&info, 0, sizeof(info)); info.watch_pid = state->watch_pid; info.watch_fd = state->watch_fd; rc = pv_watchfd_info(state, &info, 0); @@ -385,6 +397,10 @@ int pv_watchfd_loop(pvstate_t state) } } + memset(&cur_time, 0, sizeof(cur_time)); + memset(&next_remotecheck, 0, sizeof(next_remotecheck)); + memset(&next_update, 0, sizeof(next_update)); + pv_elapsedtime_read(&cur_time); pv_elapsedtime_copy(&(info.start_time), &cur_time); pv_elapsedtime_copy(&next_remotecheck, &cur_time); @@ -405,7 +421,7 @@ int pv_watchfd_loop(pvstate_t state) pv_elapsedtime_add_nsec(&next_remotecheck, REMOTE_INTERVAL); } - if (state->pv_sig_abort) + if (1 == state->pv_sig_abort) break; position_now = pv_watchfd_position(&info); @@ -465,7 +481,7 @@ int pv_watchfd_loop(pvstate_t state) transferred_since_last = -1; /* Resize the display, if a resize signal was received. */ - if (state->pv_sig_newsize) { + if (1 == state->pv_sig_newsize) { unsigned int new_width, new_height; state->pv_sig_newsize = 0; @@ -488,7 +504,7 @@ int pv_watchfd_loop(pvstate_t state) if (!state->numeric) pv_write_retry(STDERR_FILENO, "\n", 1); - if (state->pv_sig_abort) + if (1 == state->pv_sig_abort) state->exit_status |= 32; return state->exit_status; @@ -514,7 +530,7 @@ int pv_watchpid_loop(pvstate_t state) struct timespec next_update, cur_time; int idx; int prev_displayed_lines, blank_lines; - int first_pass = 1; + bool first_pass = true; /* * Make sure the process exists first, so we can give an error if @@ -551,6 +567,9 @@ int pv_watchpid_loop(pvstate_t state) * Get things ready for the main loop. */ + memset(&cur_time, 0, sizeof(cur_time)); + memset(&next_update, 0, sizeof(next_update)); + pv_elapsedtime_read(&cur_time); pv_elapsedtime_copy(&next_update, &cur_time); pv_elapsedtime_add_nsec(&next_update, (long long) (1000000000.0 * state->interval)); @@ -561,10 +580,10 @@ int pv_watchpid_loop(pvstate_t state) prev_displayed_lines = 0; - while (1) { + while (true) { int rc, fd, displayed_lines; - if (state->pv_sig_abort) + if (1 == state->pv_sig_abort) break; pv_elapsedtime_read(&cur_time); @@ -601,7 +620,7 @@ int pv_watchpid_loop(pvstate_t state) pv_elapsedtime_copy(&next_update, &cur_time); /* Resize the display, if a resize signal was received. */ - if (state->pv_sig_newsize) { + if (1 == state->pv_sig_newsize) { state->pv_sig_newsize = 0; pv_screensize(&(state->width), &(state->height)); for (idx = 0; idx < array_length; idx++) { @@ -627,7 +646,7 @@ int pv_watchpid_loop(pvstate_t state) break; } - first_pass = 0; + first_pass = false; displayed_lines = 0; for (fd = 0; fd < FD_SETSIZE; fd++) { diff --git a/src/pv/state.c b/src/pv/state.c index 1b52b7c..29ae4c7 100644 --- a/src/pv/state.c +++ b/src/pv/state.c @@ -124,9 +124,12 @@ void pv_state_free(pvstate_t state) state->format_string = NULL; } + /*@-keeptrans@ */ if (NULL != state->transfer_buffer) free(state->transfer_buffer); state->transfer_buffer = NULL; + /*@+keeptrans@ */ + /* splint - explicitly freeing this structure, so free() here is OK. */ if (NULL != state->history) free(state->history); @@ -153,7 +156,7 @@ void pv_state_free(pvstate_t state) /* * Set the formatting string, given a set of old-style formatting options. */ -void pv_state_set_format(pvstate_t state, bool progress, bool timer, bool eta, bool fineta, bool rate, bool average_rate, bool bytes, bool bufpercent, unsigned int lastwritten, /*@null@ */ +void pv_state_set_format(pvstate_t state, bool progress, bool timer, bool eta, bool fineta, bool rate, bool average_rate, bool bytes, bool bufpercent, size_t lastwritten, /*@null@ */ const char *name) { #define PV_ADDFORMAT(x,y) if (x) { \ @@ -175,7 +178,7 @@ void pv_state_set_format(pvstate_t state, bool progress, bool timer, bool eta, b if (lastwritten > 0) { char buf[16]; /* flawfinder: ignore */ memset(buf, 0, sizeof(buf)); - (void) pv_snprintf(buf, sizeof(buf), "%%%uA", lastwritten); + (void) pv_snprintf(buf, sizeof(buf), "%%%uA", (unsigned int) lastwritten); PV_ADDFORMAT(lastwritten > 0, buf); /* * flawfinder rationale: large enough for string, zeroed diff --git a/src/pv/transfer.c b/src/pv/transfer.c index 2a97858..32019cd 100644 --- a/src/pv/transfer.c +++ b/src/pv/transfer.c @@ -306,14 +306,11 @@ static ssize_t pv__transfer_write_repeated(int fd, void *buf, size_t count, bool * sets *eof_in to true. If all data in the buffer has been written at this * point, then also sets *eof_out to true. */ -static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_out, size_t allowed) +static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t allowed) { bool do_not_skip_errors; size_t bytes_can_read; - off_t amount_to_skip; - long amount_skipped; - long orig_offset; - long skip_offset; + off_t amount_to_skip, amount_skipped, orig_offset, skip_offset; ssize_t nread; #ifdef HAVE_SPLICE size_t bytes_to_splice; @@ -332,7 +329,7 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou && (fd != state->splice_failed_fd) && (0 == state->to_write)) { if (state->rate_limit > 0 || allowed != 0) { - bytes_to_splice = allowed; + bytes_to_splice = (size_t) allowed; } else { bytes_to_splice = bytes_can_read; } @@ -445,7 +442,15 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou * reached the end of this file. */ if (do_not_skip_errors) { + /*@-compdef@ */ pv_error(state, "%s: %s: %s", pv_current_file_name(state), _("read failed"), strerror(errno)); + /*@+compdef@ */ + /* + * splint says the storage pointed to by the result of + * pv_current_file_name() is not fully defined. + * + * TODO: investigate and fix the reason for this. + */ *eof_in = true; if (state->write_position >= state->read_position) { *eof_out = true; @@ -460,12 +465,15 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou amount_skipped = -1; if (!state->read_error_warning_shown) { + /*@-compdef@ */ pv_error(state, "%s: %s: %s", pv_current_file_name(state), _("warning: read errors detected"), strerror(errno)); + /*@+compdef@ */ + /* splint - see previous pv_current_file_name() call. */ state->read_error_warning_shown = true; } - orig_offset = lseek(fd, 0, SEEK_CUR); + orig_offset = (off_t) lseek(fd, 0, SEEK_CUR); /* * If the file is not seekable, we can't skip past the error, so we @@ -473,7 +481,10 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou * of the file. */ if (0 > orig_offset) { + /*@-compdef@ */ pv_error(state, "%s: %s: %s", pv_current_file_name(state), _("file is not seekable"), strerror(errno)); + /*@+compdef@ */ + /* splint - see previous pv_current_file_name() calls. */ *eof_in = true; if (state->write_position >= state->read_position) { *eof_out = true; @@ -490,9 +501,10 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou amount_to_skip = state->error_skip_block; } else { if (state->read_errors_in_a_row < 10) { - amount_to_skip = state->read_errors_in_a_row < 5 ? 1 : 2; + amount_to_skip = (off_t) (state->read_errors_in_a_row < 5 ? 1 : 2); } else if (state->read_errors_in_a_row < 20) { - amount_to_skip = 1 << (state->read_errors_in_a_row - 10); + unsigned int shift_by = (unsigned int) (state->read_errors_in_a_row - 10); + amount_to_skip = (off_t) (1 << shift_by); } else { amount_to_skip = 512; } @@ -514,10 +526,13 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou /* * Trim the skip amount so we wouldn't read too much. */ - if (amount_to_skip > bytes_can_read) - amount_to_skip = bytes_can_read; + if (amount_to_skip > (off_t) bytes_can_read) + amount_to_skip = (off_t) bytes_can_read; - skip_offset = lseek(fd, orig_offset + amount_to_skip, SEEK_SET); + /*@+longintegral@ */ + /* splint complains about __off_t vs off_t */ + skip_offset = (off_t) lseek(fd, (off_t) (orig_offset + amount_to_skip), SEEK_SET); + /*@-longintegral@ */ /* * If the skip we just tried didn't work, try only skipping 1 byte @@ -525,7 +540,10 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou */ if (skip_offset < 0) { amount_to_skip = 1; - skip_offset = lseek(fd, orig_offset + amount_to_skip, SEEK_SET); + /*@+longintegral@ */ + /* see above */ + skip_offset = (off_t) lseek(fd, (off_t) (orig_offset + amount_to_skip), SEEK_SET); + /*@-longintegral@ */ } if (skip_offset < 0) { @@ -540,9 +558,12 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou * since it just means we've reached the end anyway. */ if (EINVAL != errno) { + /*@-compdef@ */ pv_error(state, "%s: %s: %s", pv_current_file_name(state), _("failed to seek past error"), strerror(errno)); + /*@+compdef@ */ + /* splint - see previous pv_current_file_name() calls. */ } } else { amount_skipped = skip_offset - orig_offset; @@ -553,12 +574,16 @@ static int pv__transfer_read(pvstate_t state, int fd, bool *eof_in, bool *eof_ou * of the transfer buffer, and update the buffer position. */ if (amount_skipped > 0) { - memset(state->transfer_buffer + state->read_position, 0, amount_skipped); + memset(state->transfer_buffer + state->read_position, 0, (size_t) amount_skipped); state->read_position += amount_skipped; if (state->skip_errors < 2) { + /*@-compdef@ */ pv_error(state, "%s: %s: %ld - %ld (%ld %s)", pv_current_file_name(state), - _("skipped past read error"), orig_offset, skip_offset, amount_skipped, _("B")); + _("skipped past read error"), (long) orig_offset, (long) skip_offset, + (long) amount_skipped, _("B")); + /*@+compdef@ */ + /* splint - see previous pv_current_file_name() calls. */ } } else { /* @@ -594,15 +619,29 @@ static int pv__transfer_write(pvstate_t state, bool *eof_in, bool *eof_out, long { ssize_t nwritten; + if (NULL == state->transfer_buffer) { + pv_error(state, "%s", _("no transfer buffer allocated")); + state->exit_status |= 64; + *eof_out = true; + state->written = -1; + return 1; + } + + nwritten = 0; + if (state->discard_input) { nwritten = state->to_write; - } else { - signal(SIGALRM, SIG_IGN); - alarm(1); + } else if (state->to_write > 0) { + if (signal(SIGALRM, SIG_IGN) == SIG_ERR) { + pv_error(state, "%s: %s", _("failed to set alarm signal handler"), strerror(errno)); + } else { + (void) alarm(1); + } nwritten = pv__transfer_write_repeated(STDOUT_FILENO, state->transfer_buffer + - state->write_position, state->to_write, state->sync_after_write); - alarm(0); + state->write_position, (size_t) (state->to_write), + state->sync_after_write); + (void) alarm(0); } if (0 == nwritten) { @@ -619,12 +658,12 @@ static int pv__transfer_write(pvstate_t state, bool *eof_in, bool *eof_out, long /* * Guillaume Marcais: use strchr to count \n */ - unsigned char save; + char save; char *ptr; long lines = 0; save = state->transfer_buffer[state->write_position + nwritten]; - state->transfer_buffer[state->write_position + nwritten] = 0; + state->transfer_buffer[state->write_position + nwritten] = '\0'; ptr = (char *) (state->transfer_buffer + state->write_position - 1); if (state->null_terminated_lines) { @@ -653,9 +692,9 @@ static int pv__transfer_write(pvstate_t state, bool *eof_in, bool *eof_out, long */ if (((state->components_used & PV_DISPLAY_OUTPUTBUF) != 0) && (nwritten > 0)) { - long new_portion_length, old_portion_length; + size_t new_portion_length, old_portion_length; - new_portion_length = nwritten; + new_portion_length = (size_t) nwritten; if (new_portion_length > state->lastoutput_length) new_portion_length = state->lastoutput_length; @@ -738,13 +777,13 @@ static int pv__transfer_write(pvstate_t state, bool *eof_in, bool *eof_out, long * * Returns NULL on complete allocation failure. */ -static unsigned char *pv__allocate_aligned_buffer(int fd, size_t target_size) + /*@null@*//*@only@ */ static char *pv__allocate_aligned_buffer(int fd, size_t target_size) { - unsigned char *newptr; + char *newptr; #if defined(HAVE_FPATHCONF) && defined(HAVE_POSIX_MEMALIGN) && defined(_PC_REC_XFER_ALIGN) long input_alignment, output_alignment, min_alignment; - size_t required_alignment; + long required_alignment; input_alignment = fd >= 0 ? fpathconf(fd, _PC_REC_XFER_ALIGN) : -1; output_alignment = fpathconf(STDOUT_FILENO, _PC_REC_XFER_ALIGN); @@ -769,13 +808,22 @@ static unsigned char *pv__allocate_aligned_buffer(int fd, size_t target_size) required_alignment = min_alignment; } - if (0 != posix_memalign((void **) (&newptr), required_alignment, target_size)) { - newptr = (unsigned char *) malloc(target_size); + newptr = NULL; + + /*@-unrecog@ */ + /* splice doesn't know of posix_memalign(). */ + if (0 != posix_memalign((void **) (&newptr), (size_t) required_alignment, target_size)) { + newptr = malloc(target_size); } + /*@+unrecog@ */ #else /* ! defined(HAVE_FPATHCONF) && defined(HAVE_POSIX_MEMALIGN) && defined(_PC_REC_XFER_ALIGN) */ - newptr = (unsigned char *) malloc(target_size); + newptr = malloc(target_size); #endif /* defined(HAVE_FPATHCONF) && defined(HAVE_POSIX_MEMALIGN) && defined(_PC_REC_XFER_ALIGN) */ + /* Initialise the buffer with zeroes. */ + if (NULL != newptr) + memset(newptr, 0, target_size); + return newptr; } @@ -791,7 +839,7 @@ static unsigned char *pv__allocate_aligned_buffer(int fd, size_t target_size) * state->exit_status is updated). In line mode, the number of lines written * will be put into *lineswritten. */ -off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t allowed, long *lineswritten) +ssize_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t allowed, long *lineswritten) { bool ready_to_read, ready_to_write; int check_read_fd, check_write_fd; @@ -807,11 +855,18 @@ off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t al */ if (state->direct_io_changed) { if (!(*eof_in)) { - fcntl(fd, F_SETFL, (state->direct_io ? O_DIRECT : 0) | fcntl(fd, F_GETFL)); + if (0 != fcntl(fd, F_SETFL, (state->direct_io ? O_DIRECT : 0) | fcntl(fd, F_GETFL))) { + /*@-compdef@ */ + debug("%s: %s: %s", pv_current_file_name(state), "fcntl", strerror(errno)); + /*@+compdef@ */ + /* splint - see previous pv_current_file_name() calls. */ + } } if (!(*eof_out)) { - fcntl(STDOUT_FILENO, F_SETFL, - (state->direct_io ? O_DIRECT : 0) | fcntl(STDOUT_FILENO, F_GETFL)); + if (0 != fcntl(STDOUT_FILENO, F_SETFL, + (state->direct_io ? O_DIRECT : 0) | fcntl(STDOUT_FILENO, F_GETFL))) { + debug("%s: %s: %s", "(stdout)", "fcntl", strerror(errno)); + } } state->direct_io_changed = false; } @@ -849,7 +904,7 @@ off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t al * and we can't realloc() an aligned buffer. */ if (state->buffer_size < state->target_buffer_size) { - unsigned char *newptr; + char *newptr; newptr = pv__allocate_aligned_buffer(fd, state->target_buffer_size + 32); if (NULL == newptr) { /* @@ -895,10 +950,10 @@ off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t al * is >0, then this puts an upper limit on how much we're allowed to * write. */ - state->to_write = state->read_position - state->write_position; + state->to_write = (ssize_t) (state->read_position - state->write_position); if ((state->rate_limit > 0) || (allowed > 0)) { - if (state->to_write > allowed) { - state->to_write = allowed; + if ((off_t) (state->to_write) > allowed) { + state->to_write = (ssize_t) allowed; } } @@ -924,8 +979,11 @@ off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t al /* * Any other error is a problem and we must report back. */ + /*@-compdef@ */ pv_error(state, "%s: %s: %d: %s", pv_current_file_name(state), _("select call failed"), n, strerror(errno)); + /*@+compdef@ */ + /* splint - see previous pv_current_file_name() calls. */ state->exit_status |= 16; @@ -953,12 +1011,12 @@ off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t al /* * Guillaume Marcais: use strrchr to find last \n */ - unsigned char save; + char save; char *start; char *end; save = state->transfer_buffer[state->write_position + state->to_write]; - state->transfer_buffer[state->write_position + state->to_write] = 0; + state->transfer_buffer[state->write_position + state->to_write] = '\0'; start = (char *) (state->transfer_buffer + state->write_position); end = strrchr(start, '\n'); @@ -979,7 +1037,8 @@ off_t pv_transfer(pvstate_t state, int fd, bool *eof_in, bool *eof_out, off_t al && (!state->splice_used) #endif /* HAVE_SPLICE */ && (state->read_position > state->write_position) - && (state->to_write > 0)) { + && (state->to_write > 0) + && (NULL != lineswritten)) { if (pv__transfer_write(state, eof_in, eof_out, lineswritten) == 0) return 0; }