Merge 10.2 into 10.3

4 files changed, 98 insertions, 32 deletions

diff --git a/mysys/mf_iocache2.c b/mysys/mf_iocache2.c
index 2bb36129c91..6bd6fb10c14 100644
--- a/mysys/mf_iocache2.c
+++ b/mysys/mf_iocache2.c
@@ -23,51 +23,56 @@
 #include <stdarg.h>
 #include <m_ctype.h>
 
-/*
-  Copy contents of an IO_CACHE to a file.
-
-  SYNOPSIS
-    my_b_copy_to_file()
-    cache  IO_CACHE to copy from
-    file   File to copy to
-
-  DESCRIPTION
-    Copy the contents of the cache to the file. The cache will be
-    re-inited to a read cache and will read from the beginning of the
-    cache.
-
-    If a failure to write fully occurs, the cache is only copied
-    partially.
+/**
+  Copy the cache to the file. Copying can be constrained to @c count
+  number of bytes when the parameter is less than SIZE_T_MAX.  The
+  cache will be optionally re-inited to a read cache and will read
+  from the beginning of the cache.  If a failure to write fully
+  occurs, the cache is only copied partially.
 
   TODO
-    Make this function solid by handling partial reads from the cache
-    in a correct manner: it should be atomic.
-
-  RETURN VALUE
-    0  All OK
-    1  An error occurred
+  Make this function solid by handling partial reads from the cache
+  in a correct manner: it should be atomic.
+
+  @param cache      IO_CACHE to copy from
+  @param file       File to copy to
+  @param count      the copied size or the max of the type
+                    when the whole cache is to be copied.
+  @return
+         0          All OK
+         1          An error occurred
 */
 int
-my_b_copy_to_file(IO_CACHE *cache, FILE *file)
+my_b_copy_to_file(IO_CACHE *cache, FILE *file,
+                  size_t count)
 {
-  size_t bytes_in_cache;
+  size_t curr_write, bytes_in_cache;
   DBUG_ENTER("my_b_copy_to_file");
 
-  /* Reinit the cache to read from the beginning of the cache */
-  if (reinit_io_cache(cache, READ_CACHE, 0L, FALSE, FALSE))
-    DBUG_RETURN(1);
   bytes_in_cache= my_b_bytes_in_cache(cache);
   do
   {
-    if (my_fwrite(file, cache->read_pos, bytes_in_cache,
+    curr_write= MY_MIN(bytes_in_cache, count);
+    if (my_fwrite(file, cache->read_pos, curr_write,
                   MYF(MY_WME | MY_NABP)) == (size_t) -1)
       DBUG_RETURN(1);
-  } while ((bytes_in_cache= my_b_fill(cache)));
+
+    cache->read_pos += curr_write;
+    count -= curr_write;
+  } while (count && (bytes_in_cache= my_b_fill(cache)));
   if(cache->error == -1)
     DBUG_RETURN(1);
   DBUG_RETURN(0);
 }
 
+int my_b_copy_all_to_file(IO_CACHE *cache, FILE *file)
+{
+  DBUG_ENTER("my_b_copy_all_to_file");
+  /* Reinit the cache to read from the beginning of the cache */
+  if (reinit_io_cache(cache, READ_CACHE, 0L, FALSE, FALSE))
+    DBUG_RETURN(1);
+  DBUG_RETURN(my_b_copy_to_file(cache, file, SIZE_T_MAX));
+}
 
 my_off_t my_b_append_tell(IO_CACHE* info)
 {
diff --git a/mysys/my_delete.c b/mysys/my_delete.c
index beece473a01..c7023b61df0 100644
--- a/mysys/my_delete.c
+++ b/mysys/my_delete.c
@@ -18,6 +18,7 @@
 #include <my_sys.h>
 
 #ifdef _WIN32
+#include <direct.h> /* rmdir */
 static int my_win_unlink(const char *name);
 #endif
 
@@ -160,3 +161,63 @@ error:
   DBUG_RETURN(-1);
 }
 #endif
+
+/*
+   Remove directory recursively.
+*/
+int my_rmtree(const char *dir, myf MyFlags)
+{
+  char path[FN_REFLEN];
+  char sep[] = { FN_LIBCHAR, 0 };
+  int err = 0;
+  uint i;
+
+  MY_DIR *dir_info = my_dir(dir, MYF(MY_DONT_SORT | MY_WANT_STAT));
+  if (!dir_info)
+    return 1;
+
+  for (i = 0; i < dir_info->number_of_files; i++)
+  {
+    FILEINFO *file = dir_info->dir_entry + i;
+    /* Skip "." and ".." */
+    if (!strcmp(file->name, ".") || !strcmp(file->name, ".."))
+      continue;
+
+    strxnmov(path, sizeof(path), dir, sep, file->name, NULL);
+
+    if (!MY_S_ISDIR(file->mystat->st_mode))
+    {
+      err = my_delete(path, MyFlags);
+#ifdef _WIN32
+      /*
+        On Windows, check and possible reset readonly attribute.
+        my_delete(), or DeleteFile does not remove theses files.
+      */
+      if (err)
+      {
+        DWORD attr = GetFileAttributes(path);
+        if (attr != INVALID_FILE_ATTRIBUTES &&
+          (attr & FILE_ATTRIBUTE_READONLY))
+        {
+          SetFileAttributes(path, attr &~FILE_ATTRIBUTE_READONLY);
+          err = my_delete(path, MyFlags);
+        }
+      }
+#endif
+    }
+    else
+      err = my_rmtree(path, MyFlags);
+
+    if (err)
+      break;
+  }
+
+  my_dirend(dir_info);
+
+  if (!err)
+    err = rmdir(dir);
+
+  return err;
+}
+
+
diff --git a/mysys/my_file.c b/mysys/my_file.c
index a23ab487d00..23226595b2e 100644
--- a/mysys/my_file.c
+++ b/mysys/my_file.c
@@ -52,10 +52,9 @@ static uint set_max_open_files(uint max_file_limit)
     DBUG_PRINT("info", ("rlim_cur: %u  rlim_max: %u",
 			(uint) rlimit.rlim_cur,
 			(uint) rlimit.rlim_max));
-    if ((ulonglong) rlimit.rlim_cur == (ulonglong) RLIM_INFINITY)
-      rlimit.rlim_cur = max_file_limit;
-    if (rlimit.rlim_cur >= max_file_limit)
-      DBUG_RETURN(rlimit.rlim_cur);		/* purecov: inspected */
+    if ((ulonglong) rlimit.rlim_cur == (ulonglong) RLIM_INFINITY ||
+        rlimit.rlim_cur >= max_file_limit)
+      DBUG_RETURN(max_file_limit);
     rlimit.rlim_cur= rlimit.rlim_max= max_file_limit;
     if (setrlimit(RLIMIT_NOFILE, &rlimit))
       max_file_limit= old_cur;			/* Use original value */
diff --git a/mysys/my_malloc.c b/mysys/my_malloc.c
index 6a3ec8da093..78b61e8f761 100644
--- a/mysys/my_malloc.c
+++ b/mysys/my_malloc.c
@@ -117,6 +117,7 @@ void *my_malloc(size_t size, myf my_flags)
                       MY_TEST(my_flags & MY_THREAD_SPECIFIC));
     update_malloc_size(size + MALLOC_PREFIX_SIZE,
                        MY_TEST(my_flags & MY_THREAD_SPECIFIC));
+    TRASH_ALLOC(point, size);
     DBUG_EXECUTE_IF("simulate_out_of_memory",
                     {
                       /* my_free() handles memory accounting */