From: Tim Kientzle <kientzle@gmail.com>
Date: Sun, 21 Feb 2010 20:33:51 +0000 (-0500)
Subject: Prepare for the 3.0 ABI by switching a bunch of uses of off_t, dev_t,
X-Git-Tag: v3.0.0a~1218
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=73f39d903cd3f34d24c1227caad6f07a8263f9c8;p=thirdparty%2Flibarchive.git

Prepare for the 3.0 ABI by switching a bunch of uses of off_t, dev_t,
ino_t, uid_t, and gid_t to use int64_t instead.  These are all
conditional on ARCHIVE_VERSION_NUMBER >= 3000000 so we still have the
option of cutting a 2.9 release with the old ABI.

SVN-Revision: 1945
---

diff --git a/libarchive/archive.h b/libarchive/archive.h
index 40bdbdf70..0320ca92c 100644
--- a/libarchive/archive.h
+++ b/libarchive/archive.h
@@ -42,7 +42,9 @@
 #endif
 
 #include <sys/stat.h>
-#include <sys/types.h>  /* Linux requires this for off_t */
+#if ARCHIVE_VERSION_NUMBER < 3000000
+#include <sys/types.h>  /* Linux needs this for off_t; 3.0+ doesn't need it */
+#endif
 #ifdef __LA_STDINT_H
 # include __LA_STDINT_H /* int64_t, etc. */
 #endif
@@ -487,8 +489,13 @@ __LA_DECL void	 archive_read_extract_set_progress_callback(struct archive *,
 
 /* Record the dev/ino of a file that will not be written.  This is
  * generally set to the dev/ino of the archive being read. */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 __LA_DECL void		archive_read_extract_set_skip_file(struct archive *,
 		     dev_t, ino_t);
+#else
+__LA_DECL void		archive_read_extract_set_skip_file(struct archive *,
+		     __LA_INT64_T, __LA_INT64_T);
+#endif
 
 /* Close the file and release most resources. */
 __LA_DECL int		 archive_read_close(struct archive *);
@@ -526,7 +533,12 @@ __LA_DECL int archive_write_get_bytes_in_last_block(struct archive *);
 
 /* The dev/ino of a file that won't be archived.  This is used
  * to avoid recursively adding an archive to itself. */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 __LA_DECL int archive_write_set_skip_file(struct archive *, dev_t, ino_t);
+#else
+__LA_DECL int archive_write_set_skip_file(struct archive *,
+    __LA_INT64_T, __LA_INT64_T);
+#endif
 
 #if ARCHIVE_VERSION_NUMBER < 4000000
 __LA_DECL int archive_write_set_compression_bzip2(struct archive *);
@@ -639,8 +651,13 @@ __LA_DECL int		archive_write_set_options(struct archive *_a,
  */
 __LA_DECL struct archive	*archive_write_disk_new(void);
 /* This file will not be overwritten. */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 __LA_DECL int		 archive_write_disk_set_skip_file(struct archive *,
 		     dev_t, ino_t);
+#else
+__LA_DECL int archive_write_disk_set_skip_file(struct archive *,
+    __LA_INT64_T, __LA_INT64_T);
+#endif
 /* Set flags to control how the next item gets created.
  * This accepts a bitmask of ARCHIVE_EXTRACT_XXX flags defined above. */
 __LA_DECL int		 archive_write_disk_set_options(struct archive *,
@@ -668,6 +685,7 @@ __LA_DECL int	 archive_write_disk_set_standard_lookup(struct archive *);
  * your needs, you can write your own and register them.  Be sure to
  * include a cleanup function if you have allocated private data.
  */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 __LA_DECL int	 archive_write_disk_set_group_lookup(struct archive *,
 			    void * /* private_data */,
 			    __LA_GID_T (*)(void *, const char *, __LA_GID_T),
@@ -676,6 +694,16 @@ __LA_DECL int	 archive_write_disk_set_user_lookup(struct archive *,
 			    void * /* private_data */,
 			    __LA_UID_T (*)(void *, const char *, __LA_UID_T),
 			    void (* /* cleanup */)(void *));
+#else
+__LA_DECL int archive_write_disk_set_group_lookup(struct archive *,
+    void * /* private_data */,
+    __LA_INT64_T (*)(void *, const char *, __LA_INT64_T),
+    void (* /* cleanup */)(void *));
+__LA_DECL int archive_write_disk_set_user_lookup(struct archive *,
+    void * /* private_data */,
+    __LA_INT64_T (*)(void *, const char *, __LA_INT64_T),
+    void (* /* cleanup */)(void *));
+#endif
 
 /*
  * ARCHIVE_READ_DISK API
@@ -696,12 +724,18 @@ __LA_DECL int archive_read_disk_entry_from_file(struct archive *,
     struct archive_entry *, int /* fd */, const struct stat *);
 /* Look up gname for gid or uname for uid. */
 /* Default implementations are very, very stupid. */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 __LA_DECL const char *archive_read_disk_gname(struct archive *, __LA_GID_T);
 __LA_DECL const char *archive_read_disk_uname(struct archive *, __LA_UID_T);
+#else
+__LA_DECL const char *archive_read_disk_gname(struct archive *, __LA_INT64_T);
+__LA_DECL const char *archive_read_disk_uname(struct archive *, __LA_INT64_T);
+#endif
 /* "Standard" implementation uses getpwuid_r, getgrgid_r and caches the
  * results for performance. */
 __LA_DECL int	archive_read_disk_set_standard_lookup(struct archive *);
 /* You can install your own lookups if you like. */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 __LA_DECL int	archive_read_disk_set_gname_lookup(struct archive *,
     void * /* private_data */,
     const char *(* /* lookup_fn */)(void *, __LA_GID_T),
@@ -710,6 +744,16 @@ __LA_DECL int	archive_read_disk_set_uname_lookup(struct archive *,
     void * /* private_data */,
     const char *(* /* lookup_fn */)(void *, __LA_UID_T),
     void (* /* cleanup_fn */)(void *));
+#else
+__LA_DECL int	archive_read_disk_set_gname_lookup(struct archive *,
+    void * /* private_data */,
+    const char *(* /* lookup_fn */)(void *, __LA_INT64_T),
+    void (* /* cleanup_fn */)(void *));
+__LA_DECL int	archive_read_disk_set_uname_lookup(struct archive *,
+    void * /* private_data */,
+    const char *(* /* lookup_fn */)(void *, __LA_INT64_T),
+    void (* /* cleanup_fn */)(void *));
+#endif
 
 /*
  * Accessor functions to read/set various information in
diff --git a/libarchive/archive_private.h b/libarchive/archive_private.h
index ea9f20528..df83b7699 100644
--- a/libarchive/archive_private.h
+++ b/libarchive/archive_private.h
@@ -64,7 +64,7 @@ struct archive_vtable {
 	ssize_t	(*archive_write_data)(struct archive *,
 	    const void *, size_t);
 	ssize_t	(*archive_write_data_block)(struct archive *,
-	    const void *, size_t, off_t);
+	    const void *, size_t, int64_t);
 
 	int	(*archive_filter_count)(struct archive *);
 	int64_t (*archive_filter_bytes)(struct archive *, int);
diff --git a/libarchive/archive_read.c b/libarchive/archive_read.c
index 4edbf2bc1..f9abc6663 100644
--- a/libarchive/archive_read.c
+++ b/libarchive/archive_read.c
@@ -106,8 +106,13 @@ archive_read_new(void)
 /*
  * Record the do-not-extract-to file. This belongs in archive_read_extract.c.
  */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 void
 archive_read_extract_set_skip_file(struct archive *_a, dev_t d, ino_t i)
+#else
+void
+archive_read_extract_set_skip_file(struct archive *_a, int64_t d, int64_t i)
+#endif
 {
 	struct archive_read *a = (struct archive_read *)_a;
 	__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_ANY,
@@ -700,9 +705,15 @@ archive_read_data_skip(struct archive *_a)
  * Returns ARCHIVE_OK if the operation is successful, ARCHIVE_EOF if
  * the end of entry is encountered.
  */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_read_data_block(struct archive *_a,
     const void **buff, size_t *size, off_t *offset)
+#else
+int
+archive_read_data_block(struct archive *_a,
+    const void **buff, size_t *size, int64_t *offset)
+#endif
 {
 	struct archive_read *a = (struct archive_read *)_a;
 	__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
diff --git a/libarchive/archive_read_disk.c b/libarchive/archive_read_disk.c
index dc43e179c..5fc0aee0a 100644
--- a/libarchive/archive_read_disk.c
+++ b/libarchive/archive_read_disk.c
@@ -35,9 +35,13 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_disk.c 189429 2009-03-06 04
 
 static int	_archive_read_free(struct archive *);
 static int	_archive_read_close(struct archive *);
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static const char *trivial_lookup_gname(void *, gid_t gid);
 static const char *trivial_lookup_uname(void *, uid_t uid);
-
+#else
+static const char *trivial_lookup_gname(void *, int64_t gid);
+static const char *trivial_lookup_uname(void *, int64_t uid);
+#endif
 static struct archive_vtable *
 archive_read_disk_vtable(void)
 {
@@ -51,8 +55,13 @@ archive_read_disk_vtable(void)
 	return (&av);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 const char *
 archive_read_disk_gname(struct archive *_a, gid_t gid)
+#else
+const char *
+archive_read_disk_gname(struct archive *_a, int64_t gid)
+#endif
 {
 	struct archive_read_disk *a = (struct archive_read_disk *)_a;
 	if (a->lookup_gname != NULL)
@@ -60,8 +69,13 @@ archive_read_disk_gname(struct archive *_a, gid_t gid)
 	return (NULL);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 const char *
 archive_read_disk_uname(struct archive *_a, uid_t uid)
+#else
+const char *
+archive_read_disk_uname(struct archive *_a, int64_t uid)
+#endif
 {
 	struct archive_read_disk *a = (struct archive_read_disk *)_a;
 	if (a->lookup_uname != NULL)
@@ -69,11 +83,19 @@ archive_read_disk_uname(struct archive *_a, uid_t uid)
 	return (NULL);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_read_disk_set_gname_lookup(struct archive *_a,
     void *private_data,
     const char * (*lookup_gname)(void *private, gid_t gid),
     void (*cleanup_gname)(void *private))
+#else
+int
+archive_read_disk_set_gname_lookup(struct archive *_a,
+    void *private_data,
+    const char * (*lookup_gname)(void *private, int64_t gid),
+    void (*cleanup_gname)(void *private))
+#endif
 {
 	struct archive_read_disk *a = (struct archive_read_disk *)_a;
 	__archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
@@ -88,11 +110,19 @@ archive_read_disk_set_gname_lookup(struct archive *_a,
 	return (ARCHIVE_OK);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_read_disk_set_uname_lookup(struct archive *_a,
     void *private_data,
     const char * (*lookup_uname)(void *private, uid_t uid),
     void (*cleanup_uname)(void *private))
+#else
+int
+archive_read_disk_set_uname_lookup(struct archive *_a,
+    void *private_data,
+    const char * (*lookup_uname)(void *private, int64_t uid),
+    void (*cleanup_uname)(void *private))
+#endif
 {
 	struct archive_read_disk *a = (struct archive_read_disk *)_a;
 	__archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
@@ -181,16 +211,26 @@ archive_read_disk_set_symlink_hybrid(struct archive *_a)
  * These are normally overridden by the client, but these stub
  * versions ensure that we always have something that works.
  */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static const char *
 trivial_lookup_gname(void *private_data, gid_t gid)
+#else
+static const char *
+trivial_lookup_gname(void *private_data, int64_t gid)
+#endif
 {
 	(void)private_data; /* UNUSED */
 	(void)gid; /* UNUSED */
 	return (NULL);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static const char *
 trivial_lookup_uname(void *private_data, uid_t uid)
+#else
+static const char *
+trivial_lookup_uname(void *private_data, int64_t uid)
+#endif
 {
 	(void)private_data; /* UNUSED */
 	(void)uid; /* UNUSED */
diff --git a/libarchive/archive_read_disk_private.h b/libarchive/archive_read_disk_private.h
index b674b7106..306122573 100644
--- a/libarchive/archive_read_disk_private.h
+++ b/libarchive/archive_read_disk_private.h
@@ -51,10 +51,18 @@ struct archive_read_disk {
 	 */
 	char	follow_symlinks;  /* Either 'L' or 'P'. */
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 	const char * (*lookup_gname)(void *private, gid_t gid);
+#else
+	const char * (*lookup_gname)(void *private, int64_t gid);
+#endif
 	void	(*cleanup_gname)(void *private);
 	void	 *lookup_gname_data;
-	const char * (*lookup_uname)(void *private, gid_t gid);
+#if ARCHIVE_VERSION_NUMBER < 3000000
+	const char * (*lookup_uname)(void *private, uid_t uid);
+#else
+	const char * (*lookup_uname)(void *private, int64_t uid);
+#endif
 	void	(*cleanup_uname)(void *private);
 	void	 *lookup_uname_data;
 };
diff --git a/libarchive/archive_read_disk_set_standard_lookup.c b/libarchive/archive_read_disk_set_standard_lookup.c
index 94f4a3087..ceaf0cf2d 100644
--- a/libarchive/archive_read_disk_set_standard_lookup.c
+++ b/libarchive/archive_read_disk_set_standard_lookup.c
@@ -72,8 +72,13 @@ struct name_cache {
 	} cache[name_cache_size];
 };
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static const char *	lookup_gname(void *, gid_t);
 static const char *	lookup_uname(void *, uid_t);
+#else
+static const char *	lookup_gname(void *, int64_t);
+static const char *	lookup_uname(void *, int64_t);
+#endif
 static void	cleanup(void *);
 static const char *	lookup_gname_helper(struct name_cache *, id_t gid);
 static const char *	lookup_uname_helper(struct name_cache *, id_t uid);
@@ -174,8 +179,13 @@ lookup_name(struct name_cache *cache,
 	return (cache->cache[slot].name);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static const char *
 lookup_uname(void *data, uid_t uid)
+#else
+static const char *
+lookup_uname(void *data, int64_t uid)
+#endif
 {
 	struct name_cache *uname_cache = (struct name_cache *)data;
 	return (lookup_name(uname_cache,
@@ -223,8 +233,13 @@ lookup_uname_helper(struct name_cache *cache, id_t id)
 	return strdup(result->pw_name);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static const char *
 lookup_gname(void *data, gid_t gid)
+#else
+static const char *
+lookup_gname(void *data, int64_t gid)
+#endif
 {
 	struct name_cache *gname_cache = (struct name_cache *)data;
 	return (lookup_name(gname_cache,
diff --git a/libarchive/archive_virtual.c b/libarchive/archive_virtual.c
index db50a2449..fd5ce5533 100644
--- a/libarchive/archive_virtual.c
+++ b/libarchive/archive_virtual.c
@@ -115,8 +115,13 @@ archive_write_data(struct archive *a, const void *buff, size_t s)
 	return ((a->vtable->archive_write_data)(a, buff, s));
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 ssize_t
 archive_write_data_block(struct archive *a, const void *buff, size_t s, off_t o)
+#else
+ssize_t
+archive_write_data_block(struct archive *a, const void *buff, size_t s, int64_t o)
+#endif
 {
 	return ((a->vtable->archive_write_data_block)(a, buff, s, o));
 }
diff --git a/libarchive/archive_write.c b/libarchive/archive_write.c
index e05f7cdff..dd377e66d 100644
--- a/libarchive/archive_write.c
+++ b/libarchive/archive_write.c
@@ -300,8 +300,13 @@ archive_write_get_bytes_in_last_block(struct archive *_a)
  * dev/ino of a file to be rejected.  Used to prevent adding
  * an archive to itself recursively.
  */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_write_set_skip_file(struct archive *_a, dev_t d, ino_t i)
+#else
+int
+archive_write_set_skip_file(struct archive *_a, int64_t d, int64_t i)
+#endif
 {
 	struct archive_write *a = (struct archive_write *)_a;
 	__archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
diff --git a/libarchive/archive_write_disk.c b/libarchive/archive_write_disk.c
index 640a80ac6..1ef190a02 100644
--- a/libarchive/archive_write_disk.c
+++ b/libarchive/archive_write_disk.c
@@ -154,15 +154,23 @@ struct archive_write_disk {
 	mode_t			 user_umask;
 	struct fixup_entry	*fixup_list;
 	struct fixup_entry	*current_fixup;
-	uid_t			 user_uid;
+	int64_t			 user_uid;
 	dev_t			 skip_file_dev;
 	ino_t			 skip_file_ino;
 	time_t			 start_time;
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 	gid_t (*lookup_gid)(void *private, const char *gname, gid_t gid);
+#else
+	int64_t (*lookup_gid)(void *private, const char *gname, int64_t gid);
+#endif
 	void  (*cleanup_gid)(void *private);
 	void			*lookup_gid_data;
-	uid_t (*lookup_uid)(void *private, const char *gname, gid_t gid);
+#if ARCHIVE_VERSION_NUMBER < 3000000
+	uid_t (*lookup_uid)(void *private, const char *uname, uid_t uid);
+#else
+	int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid);
+#endif
 	void  (*cleanup_uid)(void *private);
 	void			*lookup_uid_data;
 
@@ -204,8 +212,8 @@ struct archive_write_disk {
 	/* Mode we should use for this entry; affected by _PERM and umask. */
 	mode_t			 mode;
 	/* UID/GID to use in restoring this entry. */
-	uid_t			 uid;
-	gid_t			 gid;
+	int64_t			 uid;
+	int64_t			 gid;
 };
 
 /*
@@ -249,8 +257,13 @@ static int	set_mode(struct archive_write_disk *, int mode);
 static int	set_time(int, int, const char *, time_t, long, time_t, long);
 static int	set_times(struct archive_write_disk *);
 static struct fixup_entry *sort_dir_list(struct fixup_entry *p);
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static gid_t	trivial_lookup_gid(void *, const char *, gid_t);
 static uid_t	trivial_lookup_uid(void *, const char *, uid_t);
+#else
+static int64_t	trivial_lookup_gid(void *, const char *, int64_t);
+static int64_t	trivial_lookup_uid(void *, const char *, int64_t);
+#endif
 static ssize_t	write_data_block(struct archive_write_disk *,
 		    const char *, size_t);
 
@@ -262,7 +275,7 @@ static int	_archive_write_disk_header(struct archive *, struct archive_entry *);
 static int64_t	_archive_write_disk_filter_bytes(struct archive *, int);
 static int	_archive_write_disk_finish_entry(struct archive *);
 static ssize_t	_archive_write_disk_data(struct archive *, const void *, size_t);
-static ssize_t	_archive_write_disk_data_block(struct archive *, const void *, size_t, off_t);
+static ssize_t	_archive_write_disk_data_block(struct archive *, const void *, size_t, int64_t);
 
 static int
 lazy_stat(struct archive_write_disk *a)
@@ -576,8 +589,13 @@ done:
 	return (ret);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_write_disk_set_skip_file(struct archive *_a, dev_t d, ino_t i)
+#else
+int
+archive_write_disk_set_skip_file(struct archive *_a, int64_t d, int64_t i)
+#endif
 {
 	struct archive_write_disk *a = (struct archive_write_disk *)_a;
 	__archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
@@ -675,7 +693,7 @@ write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
 
 static ssize_t
 _archive_write_disk_data_block(struct archive *_a,
-    const void *buff, size_t size, off_t offset)
+    const void *buff, size_t size, int64_t offset)
 {
 	struct archive_write_disk *a = (struct archive_write_disk *)_a;
 	ssize_t r;
@@ -837,11 +855,19 @@ _archive_write_disk_finish_entry(struct archive *_a)
 	return (ret);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_write_disk_set_group_lookup(struct archive *_a,
     void *private_data,
     gid_t (*lookup_gid)(void *private, const char *gname, gid_t gid),
     void (*cleanup_gid)(void *private))
+#else
+int
+archive_write_disk_set_group_lookup(struct archive *_a,
+    void *private_data,
+    int64_t (*lookup_gid)(void *private, const char *gname, int64_t gid),
+    void (*cleanup_gid)(void *private))
+#endif
 {
 	struct archive_write_disk *a = (struct archive_write_disk *)_a;
 	__archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
@@ -853,11 +879,19 @@ archive_write_disk_set_group_lookup(struct archive *_a,
 	return (ARCHIVE_OK);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 int
 archive_write_disk_set_user_lookup(struct archive *_a,
     void *private_data,
     uid_t (*lookup_uid)(void *private, const char *uname, uid_t uid),
     void (*cleanup_uid)(void *private))
+#else
+int
+archive_write_disk_set_user_lookup(struct archive *_a,
+    void *private_data,
+    int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid),
+    void (*cleanup_uid)(void *private))
+#endif
 {
 	struct archive_write_disk *a = (struct archive_write_disk *)_a;
 	__archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
@@ -2612,16 +2646,26 @@ set_xattrs(struct archive_write_disk *a)
  * These are normally overridden by the client, but these stub
  * versions ensure that we always have something that works.
  */
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static gid_t
 trivial_lookup_gid(void *private_data, const char *gname, gid_t gid)
+#else
+static int64_t
+trivial_lookup_gid(void *private_data, const char *gname, int64_t gid)
+#endif
 {
 	(void)private_data; /* UNUSED */
 	(void)gname; /* UNUSED */
 	return (gid);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static uid_t
 trivial_lookup_uid(void *private_data, const char *uname, uid_t uid)
+#else
+static int64_t
+trivial_lookup_uid(void *private_data, const char *uname, int64_t uid)
+#endif
 {
 	(void)private_data; /* UNUSED */
 	(void)uname; /* UNUSED */
diff --git a/libarchive/archive_write_disk_set_standard_lookup.c b/libarchive/archive_write_disk_set_standard_lookup.c
index cfa06e845..e7a81e755 100644
--- a/libarchive/archive_write_disk_set_standard_lookup.c
+++ b/libarchive/archive_write_disk_set_standard_lookup.c
@@ -58,8 +58,13 @@ struct bucket {
 
 static const size_t cache_size = 127;
 static unsigned int	hash(const char *);
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static gid_t	lookup_gid(void *, const char *uname, gid_t);
 static uid_t	lookup_uid(void *, const char *uname, uid_t);
+#else
+static int64_t	lookup_gid(void *, const char *uname, int64_t);
+static int64_t	lookup_uid(void *, const char *uname, int64_t);
+#endif
 static void	cleanup(void *);
 
 /*
@@ -93,8 +98,13 @@ archive_write_disk_set_standard_lookup(struct archive *a)
 	return (ARCHIVE_OK);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static gid_t
 lookup_gid(void *private_data, const char *gname, gid_t gid)
+#else
+static int64_t
+lookup_gid(void *private_data, const char *gname, int64_t gid)
+#endif
 {
 	int h;
 	struct bucket *b;
@@ -153,8 +163,13 @@ lookup_gid(void *private_data, const char *gname, gid_t gid)
 	return (gid);
 }
 
+#if ARCHIVE_VERSION_NUMBER < 3000000
 static uid_t
 lookup_uid(void *private_data, const char *uname, uid_t uid)
+#else
+static int64_t
+lookup_uid(void *private_data, const char *uname, int64_t uid)
+#endif
 {
 	int h;
 	struct bucket *b;