Add some higher-level file-read APIs and use them.

Add wtap_read_bytes(), which takes a FILE_T, a pointer, a byte count, an
error number pointer, and an error string pointer as arguments, and that
treats a short read of any sort, including a read that returns 0 bytes,
as a WTAP_ERR_SHORT_READ error, and that returns the error number and
string through its last two arguments.

Add wtap_read_bytes_or_eof(), which is similar, but that treats a read
that returns 0 bytes as an EOF, supplying an error number of 0 as an EOF
indication.

Use those in file readers; that simplifies the code and makes it less
likely that somebody will fail to supply the error number and error
string on a file read error.

Change-Id: Ia5dba2a6f81151e87b614461349d611cffc16210
Reviewed-on: https://code.wireshark.org/review/4512
Reviewed-by: Guy Harris <guy@alum.mit.edu>

1 files changed, 61 insertions, 11 deletions

diff --git a/wiretap/wtap.c b/wiretap/wtap.c
index a4fb756059..95d6ef11af 100644
--- a/wiretap/wtap.c
+++ b/wiretap/wtap.c
@@ -1036,25 +1036,56 @@ wtap_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 }
 
 /*
- * Read packet data into a Buffer, growing the buffer as necessary.
+ * Read a given number of bytes from a file.
  *
- * This returns an error on a short read, even if the short read hit
- * the EOF immediately.  (The assumption is that each packet has a
- * header followed by raw packet data, and that we've already read the
- * header, so if we get an EOF trying to read the packet data, the file
- * has been cut short, even if the read didn't read any data at all.)
+ * If we succeed, return TRUE.
+ *
+ * If we get an EOF, return FALSE with *err set to 0, reporting this
+ * as an EOF.
+ *
+ * If we get fewer bytes than the specified number, return FALSE with
+ * *err set to WTAP_ERR_SHORT_READ, reporting this as a short read
+ * error.
+ *
+ * If we get a read error, return FALSE with *err and *err_info set
+ * appropriately.
  */
 gboolean
-wtap_read_packet_bytes(FILE_T fh, Buffer *buf, guint length, int *err,
+wtap_read_bytes_or_eof(FILE_T fh, void *buf, unsigned int count, int *err,
     gchar **err_info)
 {
 	int	bytes_read;
 
-	ws_buffer_assure_space(buf, length);
-	errno = WTAP_ERR_CANT_READ;
-	bytes_read = file_read(ws_buffer_start_ptr(buf), length, fh);
+	bytes_read = file_read(buf, count, fh);
+	if (bytes_read < 0 || (guint)bytes_read != count) {
+		*err = file_error(fh, err_info);
+		if (*err == 0 && bytes_read > 0)
+			*err = WTAP_ERR_SHORT_READ;
+		return FALSE;
+	}
+	return TRUE;
+}
 
-	if (bytes_read < 0 || (guint)bytes_read != length) {
+/*
+ * Read a given number of bytes from a file.
+ *
+ * If we succeed, return TRUE.
+ *
+ * If we get fewer bytes than the specified number, including getting
+ * an EOF, return FALSE with *err set to WTAP_ERR_SHORT_READ, reporting
+ * this as a short read error.
+ *
+ * If we get a read error, return FALSE with *err and *err_info set
+ * appropriately.
+ */
+gboolean
+wtap_read_bytes(FILE_T fh, void *buf, unsigned int count, int *err,
+    gchar **err_info)
+{
+	int	bytes_read;
+
+	bytes_read = file_read(buf, count, fh);
+	if (bytes_read < 0 || (guint)bytes_read != count) {
 		*err = file_error(fh, err_info);
 		if (*err == 0)
 			*err = WTAP_ERR_SHORT_READ;
@@ -1064,6 +1095,25 @@ wtap_read_packet_bytes(FILE_T fh, Buffer *buf, guint length, int *err,
 }
 
 /*
+ * Read packet data into a Buffer, growing the buffer as necessary.
+ *
+ * This returns an error on a short read, even if the short read hit
+ * the EOF immediately.  (The assumption is that each packet has a
+ * header followed by raw packet data, and that we've already read the
+ * header, so if we get an EOF trying to read the packet data, the file
+ * has been cut short, even if the read didn't read any data at all.)
+ */
+gboolean
+wtap_read_packet_bytes(FILE_T fh, Buffer *buf, guint length, int *err,
+    gchar **err_info)
+{
+	ws_buffer_assure_space(buf, length);
+	errno = WTAP_ERR_CANT_READ;
+	return wtap_read_bytes(fh, ws_buffer_start_ptr(buf), length, err,
+	    err_info);
+}
+
+/*
  * Return an approximation of the amount of data we've read sequentially
  * from the file so far.  (gint64, in case that's 64 bits.)
  */