Call the dumper routine to finish write a file the "finish" routine.

It doesn't actually *close* any handle, so it's best called a "finish"
routine rather than a "close" routine.

In libwiretap modules, don't bother setting the finish routine pointer
to null - it's already initialized to null (it's probably best not to
require modules to set it).

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

21 files changed, 59 insertions, 69 deletions

diff --git a/epan/wslua/wslua.h b/epan/wslua/wslua.h
index 4d0ca22b60..80226b1fb7 100644
--- a/epan/wslua/wslua.h
+++ b/epan/wslua/wslua.h
@@ -290,7 +290,7 @@ struct _wslua_filehandler {
     int can_write_encap_ref;
     int write_open_ref;
     int write_ref;
-    int write_close_ref;
+    int write_finish_ref;
     int file_type;
     gboolean registered;
 };
diff --git a/epan/wslua/wslua_file_handler.c b/epan/wslua/wslua_file_handler.c
index 033686bf17..ea4fa8d186 100644
--- a/epan/wslua/wslua_file_handler.c
+++ b/epan/wslua/wslua_file_handler.c
@@ -464,7 +464,7 @@ static gboolean
 wslua_filehandler_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                       const guint8 *pd, int *err, gchar **err_info);
 static gboolean
-wslua_filehandler_dump_close(wtap_dumper *wdh, int *err);
+wslua_filehandler_dump_finish(wtap_dumper *wdh, int *err);
 
 
 /* The classic wtap dump_open function.
@@ -514,11 +514,11 @@ wslua_filehandler_dump_open(wtap_dumper *wdh, int *err)
             return 0;
         }
 
-        /* it's ok to not have a close routine */
-        if (fh->write_close_ref != LUA_NOREF)
-            wdh->subtype_close = wslua_filehandler_dump_close;
+        /* it's ok to not have a finish routine */
+        if (fh->write_finish_ref != LUA_NOREF)
+            wdh->subtype_finish = wslua_filehandler_dump_finish;
         else
-            wdh->subtype_close = NULL;
+            wdh->subtype_finish = NULL;
     }
     else {
         /* not our file type? */
@@ -570,11 +570,11 @@ wslua_filehandler_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     return (retval == 1);
 }
 
-/* The classic wtap dump_close routine.  This returns TRUE if it closes cleanly,
- * else FALSE.
+/* The classic wtap dump_finish routine.  This returns TRUE if it
+ * writes out the last information cleanly, else FALSE.
 */
 static gboolean
-wslua_filehandler_dump_close(wtap_dumper *wdh, int *err)
+wslua_filehandler_dump_finish(wtap_dumper *wdh, int *err)
 {
     FileHandler fh = (FileHandler)(wdh->wslua_data);
     int retval = -1;
@@ -582,7 +582,7 @@ wslua_filehandler_dump_close(wtap_dumper *wdh, int *err)
     File *fp = NULL;
     CaptureInfoConst *fc = NULL;
 
-    INIT_FILEHANDLER_ROUTINE(write_close,FALSE);
+    INIT_FILEHANDLER_ROUTINE(write_finish,FALSE);
 
     /* Reset errno */
     if (err) {
@@ -597,7 +597,7 @@ wslua_filehandler_dump_close(wtap_dumper *wdh, int *err)
         case 0:
             retval = wslua_optboolint(L,-1,0);
             break;
-        CASE_ERROR("write_close")
+        CASE_ERROR("write_finish")
     }
 
     END_FILEHANDLER_ROUTINE();
@@ -656,7 +656,7 @@ WSLUA_CONSTRUCTOR FileHandler_new(lua_State* L) {
     fh->seq_read_close_ref = LUA_NOREF;
     fh->write_open_ref = LUA_NOREF;
     fh->write_ref = LUA_NOREF;
-    fh->write_close_ref = LUA_NOREF;
+    fh->write_finish_ref = LUA_NOREF;
     fh->can_write_encap_ref = LUA_NOREF;
 
     fh->registered = FALSE;
@@ -795,7 +795,7 @@ WSLUA_FUNCTION wslua_deregister_filehandler(lua_State* L) {
     int can_write_encap_ref;
     int write_open_ref;
     int write_ref;
-    int write_close_ref;
+    int write_finish_ref;
 */
 
 /* WSLUA_ATTRIBUTE FileHandler_read_open WO The Lua function to be called when Wireshark opens a file for reading.
@@ -884,7 +884,7 @@ WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,can_write_encap);
 
     The called Lua function should return true on success, or false if it hit an error.
 
-    Also make sure to set the `FileHandler.write` (and potentially `FileHandler.write_close`) functions before
+    Also make sure to set the `FileHandler.write` (and potentially `FileHandler.write_finish`) functions before
     returning true from this function. */
 WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,write_open);
 
@@ -900,7 +900,7 @@ WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,write_open);
     The called Lua function should return true on success, or false if it hit an error. */
 WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,write);
 
-/* WSLUA_ATTRIBUTE FileHandler_write_close WO The Lua function to be called when Wireshark wants to close the written file.
+/* WSLUA_ATTRIBUTE FileHandler_write_finish WO The Lua function to be called when Wireshark wants to close the written file.
 
     When later called by Wireshark, the Lua function will be given:
         1. A `File` object
@@ -908,7 +908,7 @@ WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,write);
 
     It is not necessary to set this field to a Lua function - `FileHandler` can be registered without doing so - it is available
     in case there is memory/state to clear in your script when the file is closed. */
-WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,write_close);
+WSLUA_ATTRIBUTE_FUNC_SETTER(FileHandler,write_finish);
 
 /* generate other member accessors setters/getters */
 
@@ -957,7 +957,7 @@ WSLUA_ATTRIBUTES FileHandler_attributes[] = {
     WSLUA_ATTRIBUTE_WOREG(FileHandler,can_write_encap),
     WSLUA_ATTRIBUTE_WOREG(FileHandler,write_open),
     WSLUA_ATTRIBUTE_WOREG(FileHandler,write),
-    WSLUA_ATTRIBUTE_WOREG(FileHandler,write_close),
+    WSLUA_ATTRIBUTE_WOREG(FileHandler,write_finish),
     WSLUA_ATTRIBUTE_ROREG(FileHandler,type),
     WSLUA_ATTRIBUTE_RWREG(FileHandler,extensions),
     WSLUA_ATTRIBUTE_RWREG(FileHandler,writing_must_seek),
diff --git a/wiretap/5views.c b/wiretap/5views.c
index ce0e4cf34e..1c693a4c58 100644
--- a/wiretap/5views.c
+++ b/wiretap/5views.c
@@ -105,7 +105,7 @@ static int _5views_read_header(wtap *wth, FILE_T fh, t_5VW_TimeStamped_Header *h
     struct wtap_pkthdr *phdr, int *err, gchar **err_info);
 
 static gboolean _5views_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, const guint8 *pd, int *err, gchar **err_info);
-static gboolean _5views_dump_close(wtap_dumper *wdh, int *err);
+static gboolean _5views_dump_finish(wtap_dumper *wdh, int *err);
 
 
 wtap_open_return_val
@@ -337,7 +337,7 @@ gboolean _5views_dump_open(wtap_dumper *wdh, int *err)
 
 	/* This is a 5Views file */
 	wdh->subtype_write = _5views_dump;
-	wdh->subtype_close = _5views_dump_close;
+	wdh->subtype_finish = _5views_dump_finish;
 	_5views = (_5views_dump_t *)g_malloc(sizeof(_5views_dump_t));
 	wdh->priv = (void *)_5views;
 	_5views->nframes = 0;
@@ -395,7 +395,7 @@ static gboolean _5views_dump(wtap_dumper *wdh,
 	return TRUE;
 }
 
-static gboolean _5views_dump_close(wtap_dumper *wdh, int *err)
+static gboolean _5views_dump_finish(wtap_dumper *wdh, int *err)
 {
 	_5views_dump_t *_5views = (_5views_dump_t *)wdh->priv;
 	t_5VW_Capture_Header file_hdr;
diff --git a/wiretap/btsnoop.c b/wiretap/btsnoop.c
index a04c71b68f..5ecb42690a 100644
--- a/wiretap/btsnoop.c
+++ b/wiretap/btsnoop.c
@@ -399,9 +399,8 @@ gboolean btsnoop_dump_open_h1(wtap_dumper *wdh, int *err)
 {
     struct btsnoop_hdr file_hdr;
 
-    /* This is a libpcap file */
+    /* This is a btsnoop file */
     wdh->subtype_write = btsnoop_dump_h1;
-    wdh->subtype_close = NULL;
 
     /* Write the file header. */
     switch (wdh->file_type_subtype) {
@@ -441,9 +440,8 @@ gboolean btsnoop_dump_open_h4(wtap_dumper *wdh, int *err)
 {
     struct btsnoop_hdr file_hdr;
 
-    /* This is a libpcap file */
+    /* This is a btsnoop file */
     wdh->subtype_write = btsnoop_dump_h4;
-    wdh->subtype_close = NULL;
 
     /* Write the file header. */
     switch (wdh->file_type_subtype) {
diff --git a/wiretap/commview.c b/wiretap/commview.c
index c14f268798..1d99fbc051 100644
--- a/wiretap/commview.c
+++ b/wiretap/commview.c
@@ -390,7 +390,6 @@ int commview_dump_can_write_encap(int encap)
 gboolean commview_dump_open(wtap_dumper *wdh, int *err _U_)
 {
 	wdh->subtype_write = commview_dump;
-	wdh->subtype_close = NULL;
 
 	/* There is no file header to write out */
 	wdh->bytes_dumped = 0;
diff --git a/wiretap/erf.c b/wiretap/erf.c
index 5906d80cc5..a00eaed0eb 100644
--- a/wiretap/erf.c
+++ b/wiretap/erf.c
@@ -722,7 +722,6 @@ int erf_dump_can_write_encap(int encap)
 int erf_dump_open(wtap_dumper *wdh, int *err)
 {
   wdh->subtype_write = erf_dump;
-  wdh->subtype_close = NULL;
 
   switch(wdh->file_type_subtype){
     case WTAP_FILE_TYPE_SUBTYPE_ERF:
diff --git a/wiretap/eyesdn.c b/wiretap/eyesdn.c
index f65902dd40..494e99f7e1 100644
--- a/wiretap/eyesdn.c
+++ b/wiretap/eyesdn.c
@@ -359,7 +359,6 @@ static gboolean eyesdn_dump(wtap_dumper *wdh,
 gboolean eyesdn_dump_open(wtap_dumper *wdh, int *err)
 {
 	wdh->subtype_write=eyesdn_dump;
-	wdh->subtype_close=NULL;
 
 	if (!wtap_dump_file_write(wdh, eyesdn_hdr_magic,
 	    EYESDN_HDR_MAGIC_SIZE, err))
diff --git a/wiretap/file_access.c b/wiretap/file_access.c
index 9d59f1274c..15e5940ac7 100644
--- a/wiretap/file_access.c
+++ b/wiretap/file_access.c
@@ -2436,9 +2436,9 @@ wtap_dump_close(wtap_dumper *wdh, int *err)
 {
 	gboolean ret = TRUE;
 
-	if (wdh->subtype_close != NULL) {
-		/* There's a close routine for this dump stream. */
-		if (!(wdh->subtype_close)(wdh, err))
+	if (wdh->subtype_finish != NULL) {
+		/* There's a finish routine for this dump stream. */
+		if (!(wdh->subtype_finish)(wdh, err))
 			ret = FALSE;
 	}
 	errno = WTAP_ERR_CANT_CLOSE;
diff --git a/wiretap/k12.c b/wiretap/k12.c
index 58f0301030..b5558a0cf4 100644
--- a/wiretap/k12.c
+++ b/wiretap/k12.c
@@ -1302,7 +1302,7 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 
 static const guint8 k12_eof[] = {0xff,0xff};
 
-static gboolean k12_dump_close(wtap_dumper *wdh, int *err) {
+static gboolean k12_dump_finish(wtap_dumper *wdh, int *err) {
     k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
     union {
         guint8 b[sizeof(guint32)];
@@ -1360,7 +1360,7 @@ gboolean k12_dump_open(wtap_dumper *wdh, int *err) {
         return FALSE;
 
     wdh->subtype_write = k12_dump;
-    wdh->subtype_close = k12_dump_close;
+    wdh->subtype_finish = k12_dump_finish;
 
     k12 = (k12_dump_t *)g_malloc(sizeof(k12_dump_t));
     wdh->priv = (void *)k12;
diff --git a/wiretap/lanalyzer.c b/wiretap/lanalyzer.c
index af8f7514aa..50ce3339e0 100644
--- a/wiretap/lanalyzer.c
+++ b/wiretap/lanalyzer.c
@@ -273,7 +273,7 @@ static gboolean lanalyzer_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean lanalyzer_seek_read(wtap *wth, gint64 seek_off,
     struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
-static gboolean lanalyzer_dump_close(wtap_dumper *wdh, int *err);
+static gboolean lanalyzer_dump_finish(wtap_dumper *wdh, int *err);
 
 wtap_open_return_val lanalyzer_open(wtap *wth, int *err, gchar **err_info)
 {
@@ -740,9 +740,9 @@ gboolean lanalyzer_dump_open(wtap_dumper *wdh, int *err)
             }
 
       ((LA_TmpInfo*)tmp)->init = FALSE;
-      wdh->priv          = tmp;
-      wdh->subtype_write = lanalyzer_dump;
-      wdh->subtype_close = lanalyzer_dump_close;
+      wdh->priv           = tmp;
+      wdh->subtype_write  = lanalyzer_dump;
+      wdh->subtype_finish = lanalyzer_dump_finish;
 
       /* Some of the fields in the file header aren't known yet so
        just skip over it for now.  It will be created after all
@@ -894,7 +894,7 @@ static gboolean lanalyzer_dump_header(wtap_dumper *wdh, int *err)
  * Finish writing to a dump file.
  * Returns TRUE on success, FALSE on failure.
  *---------------------------------------------------*/
-static gboolean lanalyzer_dump_close(wtap_dumper *wdh, int *err)
+static gboolean lanalyzer_dump_finish(wtap_dumper *wdh, int *err)
 {
       lanalyzer_dump_header(wdh,err);
       return *err ? FALSE : TRUE;
diff --git a/wiretap/libpcap.c b/wiretap/libpcap.c
index 59eda26002..66572425e1 100644
--- a/wiretap/libpcap.c
+++ b/wiretap/libpcap.c
@@ -824,7 +824,6 @@ gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
 
 	/* This is a libpcap file */
 	wdh->subtype_write = libpcap_dump;
-	wdh->subtype_close = NULL;
 
 	/* Write the file header. */
 	switch (wdh->file_type_subtype) {
diff --git a/wiretap/logcat.c b/wiretap/logcat.c
index a7bb0d5580..a20c5bd2d9 100644
--- a/wiretap/logcat.c
+++ b/wiretap/logcat.c
@@ -342,7 +342,6 @@ static gboolean logcat_binary_dump(wtap_dumper *wdh,
 gboolean logcat_binary_dump_open(wtap_dumper *wdh, int *err)
 {
     wdh->subtype_write = logcat_binary_dump;
-    wdh->subtype_close = NULL;
 
     switch (wdh->encap) {
         case WTAP_ENCAP_LOGCAT:
diff --git a/wiretap/logcat_text.c b/wiretap/logcat_text.c
index 7742ab6159..e3c0811c4e 100644
--- a/wiretap/logcat_text.c
+++ b/wiretap/logcat_text.c
@@ -548,7 +548,6 @@ static gboolean logcat_text_dump_open(wtap_dumper *wdh, guint dump_type, int *er
 
     wdh->priv = dumper;
     wdh->subtype_write = logcat_text_dump_text;
-    wdh->subtype_close = NULL;
 
     return TRUE;
 }
diff --git a/wiretap/netmon.c b/wiretap/netmon.c
index 7abc7c677d..b792c2ddfd 100644
--- a/wiretap/netmon.c
+++ b/wiretap/netmon.c
@@ -183,7 +183,7 @@ static gboolean netmon_read_atm_pseudoheader(FILE_T fh,
 static void netmon_sequential_close(wtap *wth);
 static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     const guint8 *pd, int *err, gchar **err_info);
-static gboolean netmon_dump_close(wtap_dumper *wdh, int *err);
+static gboolean netmon_dump_finish(wtap_dumper *wdh, int *err);
 
 wtap_open_return_val netmon_open(wtap *wth, int *err, gchar **err_info)
 {
@@ -945,7 +945,7 @@ gboolean netmon_dump_open(wtap_dumper *wdh, int *err)
 		return FALSE;
 
 	wdh->subtype_write = netmon_dump;
-	wdh->subtype_close = netmon_dump_close;
+	wdh->subtype_finish = netmon_dump_finish;
 
 	netmon = (netmon_dump_t *)g_malloc(sizeof(netmon_dump_t));
 	wdh->priv = (void *)netmon;
@@ -1208,7 +1208,7 @@ static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 
 /* Finish writing to a dump file.
    Returns TRUE on success, FALSE on failure. */
-static gboolean netmon_dump_close(wtap_dumper *wdh, int *err)
+static gboolean netmon_dump_finish(wtap_dumper *wdh, int *err)
 {
 	netmon_dump_t *netmon = (netmon_dump_t *)wdh->priv;
 	size_t n_to_write;
diff --git a/wiretap/nettl.c b/wiretap/nettl.c
index 9b07029721..76f22dce3c 100644
--- a/wiretap/nettl.c
+++ b/wiretap/nettl.c
@@ -658,7 +658,6 @@ gboolean nettl_dump_open(wtap_dumper *wdh, int *err)
 
     /* This is a nettl file */
     wdh->subtype_write = nettl_dump;
-    wdh->subtype_close = NULL;
 
     /* Write the file header. */
     memset(&file_hdr,0,sizeof(file_hdr));
diff --git a/wiretap/netxray.c b/wiretap/netxray.c
index 536afc3dfd..ab23bd62c7 100644
--- a/wiretap/netxray.c
+++ b/wiretap/netxray.c
@@ -412,11 +412,11 @@ static void netxray_guess_atm_type(wtap *wth, struct wtap_pkthdr *phdr,
 static gboolean netxray_dump_1_1(wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
     const guint8 *pd, int *err, gchar **err_info);
-static gboolean netxray_dump_close_1_1(wtap_dumper *wdh, int *err);
+static gboolean netxray_dump_finish_1_1(wtap_dumper *wdh, int *err);
 static gboolean netxray_dump_2_0(wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
     const guint8 *pd, int *err, gchar **err_info);
-static gboolean netxray_dump_close_2_0(wtap_dumper *wdh, int *err);
+static gboolean netxray_dump_finish_2_0(wtap_dumper *wdh, int *err);
 
 wtap_open_return_val
 netxray_open(wtap *wth, int *err, gchar **err_info)
@@ -1709,7 +1709,7 @@ netxray_dump_open_1_1(wtap_dumper *wdh, int *err)
 	netxray_dump_t *netxray;
 
 	wdh->subtype_write = netxray_dump_1_1;
-	wdh->subtype_close = netxray_dump_close_1_1;
+	wdh->subtype_finish = netxray_dump_finish_1_1;
 
 	/* We can't fill in all the fields in the file header, as we
 	   haven't yet written any packets.  As we'll have to rewrite
@@ -1797,7 +1797,7 @@ netxray_dump_1_1(wtap_dumper *wdh,
 /* Finish writing to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean
-netxray_dump_close_1_1(wtap_dumper *wdh, int *err)
+netxray_dump_finish_1_1(wtap_dumper *wdh, int *err)
 {
 	char hdr_buf[CAPTUREFILE_HEADER_SIZE - sizeof(netxray_magic)];
 	netxray_dump_t *netxray = (netxray_dump_t *)wdh->priv;
@@ -1886,7 +1886,7 @@ netxray_dump_open_2_0(wtap_dumper *wdh, int *err)
 	netxray_dump_t *netxray;
 
 	wdh->subtype_write = netxray_dump_2_0;
-	wdh->subtype_close = netxray_dump_close_2_0;
+	wdh->subtype_finish = netxray_dump_finish_2_0;
 
 	/* We can't fill in all the fields in the file header, as we
 	   haven't yet written any packets.  As we'll have to rewrite
@@ -2006,7 +2006,7 @@ netxray_dump_2_0(wtap_dumper *wdh,
 /* Finish writing to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean
-netxray_dump_close_2_0(wtap_dumper *wdh, int *err)
+netxray_dump_finish_2_0(wtap_dumper *wdh, int *err)
 {
 	char hdr_buf[CAPTUREFILE_HEADER_SIZE - sizeof(netxray_magic)];
 	netxray_dump_t *netxray = (netxray_dump_t *)wdh->priv;
diff --git a/wiretap/ngsniffer.c b/wiretap/ngsniffer.c
index ed89e61233..79fd2971e2 100644
--- a/wiretap/ngsniffer.c
+++ b/wiretap/ngsniffer.c
@@ -527,7 +527,7 @@ static void ngsniffer_sequential_close(wtap *wth);
 static void ngsniffer_close(wtap *wth);
 static gboolean ngsniffer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     const guint8 *pd, int *err, gchar **err_info);
-static gboolean ngsniffer_dump_close(wtap_dumper *wdh, int *err);
+static gboolean ngsniffer_dump_finish(wtap_dumper *wdh, int *err);
 static int SnifferDecompress( unsigned char * inbuf, size_t inlen,
     unsigned char * outbuf, size_t outlen, int *err, gchar **err_info );
 static gboolean ng_read_bytes_or_eof(wtap *wth, void *buffer,
@@ -1970,7 +1970,7 @@ ngsniffer_dump_open(wtap_dumper *wdh, int *err)
 
 	/* This is a sniffer file */
 	wdh->subtype_write = ngsniffer_dump;
-	wdh->subtype_close = ngsniffer_dump_close;
+	wdh->subtype_finish = ngsniffer_dump_finish;
 
 	ngsniffer = (ngsniffer_dump_t *)g_malloc(sizeof(ngsniffer_dump_t));
 	wdh->priv = (void *)ngsniffer;
@@ -2128,7 +2128,7 @@ ngsniffer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 /* Finish writing to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean
-ngsniffer_dump_close(wtap_dumper *wdh, int *err)
+ngsniffer_dump_finish(wtap_dumper *wdh, int *err)
 {
 	/* EOF record */
 	char buf[6] = {REC_EOF, 0x00, 0x00, 0x00, 0x00, 0x00};
diff --git a/wiretap/pcapng.c b/wiretap/pcapng.c
index 5ccaed3fb5..a9cad5fc4f 100644
--- a/wiretap/pcapng.c
+++ b/wiretap/pcapng.c
@@ -3912,7 +3912,7 @@ static gboolean pcapng_dump(wtap_dumper *wdh,
 
 /* Finish writing to a dump file.
    Returns TRUE on success, FALSE on failure. */
-static gboolean pcapng_dump_close(wtap_dumper *wdh, int *err)
+static gboolean pcapng_dump_finish(wtap_dumper *wdh, int *err)
 {
     guint i, j;
 
@@ -3929,14 +3929,14 @@ static gboolean pcapng_dump_close(wtap_dumper *wdh, int *err)
             wtapng_if_stats_t if_stats;
 
             if_stats = g_array_index(int_data.interface_statistics, wtapng_if_stats_t, j);
-            pcapng_debug("pcapng_dump_close: write ISB for interface %u",if_stats.interface_id);
+            pcapng_debug("pcapng_dump_finish: write ISB for interface %u",if_stats.interface_id);
             if (!pcapng_write_interface_statistics_block(wdh, &if_stats, err)) {
                 return FALSE;
             }
         }
     }
 
-    pcapng_debug("pcapng_dump_close");
+    pcapng_debug("pcapng_dump_finish");
     return TRUE;
 }
 
@@ -3951,7 +3951,7 @@ pcapng_dump_open(wtap_dumper *wdh, int *err)
     pcapng_debug("pcapng_dump_open");
     /* This is a pcapng file */
     wdh->subtype_write = pcapng_dump;
-    wdh->subtype_close = pcapng_dump_close;
+    wdh->subtype_finish = pcapng_dump_finish;
 
     if (wdh->interface_data->len == 0) {
         pcapng_debug("There are no interfaces. Can't handle that...");
diff --git a/wiretap/snoop.c b/wiretap/snoop.c
index 7ed4f7d6fb..1fcfada8fe 100644
--- a/wiretap/snoop.c
+++ b/wiretap/snoop.c
@@ -796,7 +796,6 @@ gboolean snoop_dump_open(wtap_dumper *wdh, int *err)
 
 	/* This is a snoop file */
 	wdh->subtype_write = snoop_dump;
-	wdh->subtype_close = NULL;
 
 	/* Write the file header. */
 	if (!wtap_dump_file_write(wdh, &snoop_magic, sizeof snoop_magic, err))
diff --git a/wiretap/visual.c b/wiretap/visual.c
index dd40f2971e..2bf675a444 100644
--- a/wiretap/visual.c
+++ b/wiretap/visual.c
@@ -165,7 +165,7 @@ static gboolean visual_read_packet(wtap *wth, FILE_T fh,
     struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
 static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     const guint8 *pd, int *err, gchar **err_info);
-static gboolean visual_dump_close(wtap_dumper *wdh, int *err);
+static gboolean visual_dump_finish(wtap_dumper *wdh, int *err);
 static void visual_dump_free(wtap_dumper *wdh);
 
 
@@ -612,7 +612,7 @@ gboolean visual_dump_open(wtap_dumper *wdh, int *err)
 
     /* Set the write routines for a visual file. */
     wdh->subtype_write = visual_dump;
-    wdh->subtype_close = visual_dump_close;
+    wdh->subtype_finish = visual_dump_finish;
 
     /* Create a struct to hold file information for the duration
        of the write */
@@ -760,7 +760,7 @@ static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 
 /* Finish writing to a dump file.
    Returns TRUE on success, FALSE on failure. */
-static gboolean visual_dump_close(wtap_dumper *wdh, int *err)
+static gboolean visual_dump_finish(wtap_dumper *wdh, int *err)
 {
     struct visual_write_info * visual = (struct visual_write_info *)wdh->priv;
     size_t n_to_write;
diff --git a/wiretap/wtap-int.h b/wiretap/wtap-int.h
index 8b73ae5aef..91656bdfaa 100644
--- a/wiretap/wtap-int.h
+++ b/wiretap/wtap-int.h
@@ -91,7 +91,7 @@ typedef void *WFILE_T;
 typedef gboolean (*subtype_write_func)(struct wtap_dumper*,
                                        const struct wtap_pkthdr*,
                                        const guint8*, int*, gchar**);
-typedef gboolean (*subtype_close_func)(struct wtap_dumper*, int*);
+typedef gboolean (*subtype_finish_func)(struct wtap_dumper*, int*);
 
 struct wtap_dumper {
     WFILE_T                 fh;
@@ -101,19 +101,19 @@ struct wtap_dumper {
     gboolean                compressed;
     gint64                  bytes_dumped;
 
-    void                    *priv;       /* this one holds per-file state and is free'd automatically by wtap_dump_close() */
-    void                    *wslua_data; /* this one holds wslua state info and is not free'd */
+    void                    *priv;          /* this one holds per-file state and is free'd automatically by wtap_dump_close() */
+    void                    *wslua_data;    /* this one holds wslua state info and is not free'd */
 
-    subtype_write_func      subtype_write;
-    subtype_close_func      subtype_close;
+    subtype_write_func      subtype_write;  /* write out a record */
+    subtype_finish_func     subtype_finish; /* write out information to finish writing file */
 
     int                     tsprecision;    /**< timestamp precision of the lower 32bits
                                              * e.g. WTAP_TSPREC_USEC
                                              */
-    addrinfo_lists_t        *addrinfo_lists;    /**< Struct containing lists of resolved addresses */
+    addrinfo_lists_t        *addrinfo_lists; /**< Struct containing lists of resolved addresses */
     wtapng_section_t        *shb_hdr;
-    wtapng_name_res_t       *nrb_hdr;           /**< name resolution comment/custom_opt, or NULL */
-    GArray                  *interface_data;    /**< An array holding the interface data from pcapng IDB:s or equivalent(?) NULL if not present.*/
+    wtapng_name_res_t       *nrb_hdr;        /**< name resolution comment/custom_opt, or NULL */
+    GArray                  *interface_data; /**< An array holding the interface data from pcapng IDB:s or equivalent(?) NULL if not present.*/
 };
 
 WS_DLL_PUBLIC gboolean wtap_dump_file_write(wtap_dumper *wdh, const void *buf,