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 40bdbdf70099411f5929e6af8287e048d312023d..0320ca92c423470b411fb510f27186ed4cb49c69 100644 (file)
--- 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 ea9f205282824cfb9f6f2212e6de5dc214ba1e36..df83b76992c12c7bc1ed786e01bfc8a52e7eb962 100644 (file)
--- 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 4edbf2bc114fc45fb659b4718005696fb01c26b7..f9abc66634235943372e8087ca22d281e5d1e604 100644 (file)
--- 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 dc43e179c7c5cd824572d5c9ad192ffd069b520d..5fc0aee0ab1e3ab1bc9a2cd04a04dcf63fcf3467 100644 (file)
--- 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 b674b7106d73f87f1739fe45ad2a7301920c4191..3061225738f7f76d38394fd41ff3a12d43381df0 100644 (file)
--- 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 94f4a3087bdada773102eb7326a8215ec685dc42..ceaf0cf2d9b25892571f1b1ef5412ab8ccf7a4d9 100644 (file)
--- 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 db50a244945d98799946652ce678238e65852c67..fd5ce5533a674c66989b530e0d8aa7095e7a80b2 100644 (file)
--- 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 e05f7cdffa48ed300c6c241c6a70b5e871b6fdff..dd377e66d42a82452a4581b543d30c457299b1d6 100644 (file)
--- 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 640a80ac63073cc1afab48fd979e55f05437adc9..1ef190a022c7e3c59aaa23f3a37ad5fca1391365 100644 (file)
--- 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 cfa06e84547ad7c56c1208a3a5c04f43677c4441..e7a81e75513b0122dcc4df02637f10b422cb3442 100644 (file)
--- 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;