14 files changed, 41 insertions, 37 deletions

diff --git a/src/bucket.c b/src/bucket.c
index 2289594..e17019c 100644
--- a/src/bucket.c
+++ b/src/bucket.c
@@ -109,13 +109,13 @@ _gdbm_get_bucket (GDBM_FILE dbf, int dir_index)
             }
         }
 
       /* It is not in the cache, read it from the disk. */
 
       /* Position the file pointer */
-      file_pos = __lseek (dbf, bucket_adr, SEEK_SET);
+      file_pos = gdbm_file_seek (dbf, bucket_adr, SEEK_SET);
       if (file_pos != bucket_adr)
         {
           GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE);
           _gdbm_fatal (dbf, _("lseek error"));
           return -1;
         }
@@ -184,13 +184,13 @@ _gdbm_read_bucket_at (GDBM_FILE dbf, off_t off, hash_bucket *bucket,
           memcpy (bucket, dbf->bucket_cache[i].ca_bucket, size);
           return 0;
         }
     }
 
   /* Read the bucket. */
-  file_pos = __lseek (dbf, off, SEEK_SET);
+  file_pos = gdbm_file_seek (dbf, off, SEEK_SET);
   if (file_pos != off)
     {
       GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE);
       return -1;
     }
   if (_gdbm_full_read (dbf, bucket, size))
@@ -429,13 +429,13 @@ _gdbm_split_bucket (GDBM_FILE dbf, int next_insert)
 int
 _gdbm_write_bucket (GDBM_FILE dbf, cache_elem *ca_entry)
 {
   int rc;
   off_t file_pos;       /* The return value for lseek. */
 
-  file_pos = __lseek (dbf, ca_entry->ca_adr, SEEK_SET);
+  file_pos = gdbm_file_seek (dbf, ca_entry->ca_adr, SEEK_SET);
   if (file_pos != ca_entry->ca_adr)
     {
       GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE);
       _gdbm_fatal (dbf, _("lseek error"));
       return -1;
     }
diff --git a/src/falloc.c b/src/falloc.c
index 13ee0ed..2f21ebe 100644
--- a/src/falloc.c
+++ b/src/falloc.c
@@ -188,13 +188,13 @@ pop_avail_block (GDBM_FILE dbf)
       GDBM_SET_ERRNO (dbf, GDBM_MALLOC_ERROR, TRUE);
       _gdbm_fatal (dbf, _("malloc failed"));
       return -1;
     }
 
   /* Read the block. */
-  file_pos = __lseek (dbf, new_el.av_adr, SEEK_SET);
+  file_pos = gdbm_file_seek (dbf, new_el.av_adr, SEEK_SET);
   if (file_pos != new_el.av_adr)
     {
       GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE);
       free (new_blk);
       _gdbm_fatal (dbf, _("lseek error"));
       return -1;
@@ -318,13 +318,13 @@ push_avail_block (GDBM_FILE dbf)
   /* Free the unneeded space. */
   new_loc.av_adr += av_size;
   new_loc.av_size -= av_size;
   _gdbm_free (dbf, new_loc.av_adr, new_loc.av_size);
 
   /* Update the disk. */
-  file_pos = __lseek (dbf, av_adr, SEEK_SET);
+  file_pos = gdbm_file_seek (dbf, av_adr, SEEK_SET);
   if (file_pos != av_adr)
     {
       GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE);
       _gdbm_fatal (dbf, _("lseek error"));
       return -1;
     }
diff --git a/src/findkey.c b/src/findkey.c
index 9bb4553..9c8fd71 100644
--- a/src/findkey.c
+++ b/src/findkey.c
@@ -80,13 +80,13 @@ _gdbm_read_entry (GDBM_FILE dbf, int elem_loc)
       GDBM_SET_ERRNO2 (dbf, GDBM_MALLOC_ERROR, FALSE, GDBM_DEBUG_LOOKUP);
       _gdbm_fatal (dbf, _("malloc error"));
       return NULL;
     }
 
   /* Read into the cache. */
-  file_pos = __lseek (dbf, dbf->bucket->h_table[elem_loc].data_pointer, 
+  file_pos = gdbm_file_seek (dbf, dbf->bucket->h_table[elem_loc].data_pointer, 
                       SEEK_SET);
   if (file_pos != dbf->bucket->h_table[elem_loc].data_pointer)
     {
       GDBM_SET_ERRNO2 (dbf, GDBM_FILE_SEEK_ERROR, TRUE, GDBM_DEBUG_LOOKUP);
       _gdbm_fatal (dbf, _("lseek error"));
       return NULL;
diff --git a/src/fullio.c b/src/fullio.c
index bdb51cb..84eea60 100644
--- a/src/fullio.c
+++ b/src/fullio.c
@@ -24,13 +24,13 @@
 int
 _gdbm_full_read (GDBM_FILE dbf, void *buffer, size_t size)
 {
   char *ptr = buffer;
   while (size)
     {
-      ssize_t rdbytes = __read (dbf, ptr, size);
+      ssize_t rdbytes = gdbm_file_read (dbf, ptr, size);
       if (rdbytes == -1)
         {
           if (errno == EINTR)
             continue;
           if (gdbm_last_errno (dbf) == GDBM_NO_ERROR)
             GDBM_SET_ERRNO (dbf, GDBM_FILE_READ_ERROR, FALSE);
@@ -52,13 +52,13 @@ _gdbm_full_read (GDBM_FILE dbf, void *buffer, size_t size)
 int
 _gdbm_full_write (GDBM_FILE dbf, void *buffer, size_t size)
 {
   char *ptr = buffer;
   while (size)
     {
-      ssize_t wrbytes = __write (dbf, ptr, size);
+      ssize_t wrbytes = gdbm_file_write (dbf, ptr, size);
       if (wrbytes == -1)
         {
           if (errno == EINTR)
             continue;
           if (gdbm_last_errno (dbf) == GDBM_NO_ERROR)
             GDBM_SET_ERRNO (dbf, GDBM_FILE_WRITE_ERROR, TRUE);
diff --git a/src/gdbmclose.c b/src/gdbmclose.c
index c638183..ead9187 100644
--- a/src/gdbmclose.c
+++ b/src/gdbmclose.c
@@ -32,13 +32,13 @@ gdbm_close (GDBM_FILE dbf)
   int index;    /* For freeing the bucket cache. */
 
   if (dbf->desc != -1)
     {
       /* Make sure the database is all on disk. */
       if (dbf->read_write != GDBM_READER)
-        __fsync (dbf);
+        gdbm_file_sync (dbf);
 
       /* Close the file and free all malloced memory. */
 #if HAVE_MMAP
       _gdbm_mapped_unmap (dbf);
 #endif
       if (dbf->file_locking)
diff --git a/src/gdbmopen.c b/src/gdbmopen.c
index 22e7ca6..53d62a4 100644
--- a/src/gdbmopen.c
+++ b/src/gdbmopen.c
@@ -426,13 +426,13 @@ gdbm_fd_open (int fd, const char *file_name, int block_size,
             dbf->desc = -1;
           SAVE_ERRNO (gdbm_close (dbf));
           return NULL;
         }
 
       /* Wait for initial configuration to be written to disk. */
-      __fsync (dbf);
+      gdbm_file_sync (dbf);
 
       free (dbf->bucket);
     }
   else
     {
       /* This is an old database.  Read in the information from the file
@@ -505,13 +505,13 @@ gdbm_fd_open (int fd, const char *file_name, int block_size,
           gdbm_close (dbf);
           GDBM_SET_ERRNO2 (NULL, GDBM_MALLOC_ERROR, FALSE, GDBM_DEBUG_OPEN);
           return NULL;
         }
 
       /* Read the hash table directory. */
-      file_pos = __lseek (dbf, dbf->header->dir, SEEK_SET);
+      file_pos = gdbm_file_seek (dbf, dbf->header->dir, SEEK_SET);
       if (file_pos != dbf->header->dir)