Replace std::ofstream with llvm::raw_fd_ostream

[labath]

Summary

ofstream does not handle paths with non-ascii characters correctly on
windows, so I am switching these to llvm streams to fix that.

Ideally I'd like to replace the two occurences of ifstream as well, but
it's not clear to me what is the right replacement, as llvm interfaces
seem to be based around reading the full file, which seems wasteful, if
all I'm going to do is to stream it to a socket.

[zturner]

In the places where you want to read from an ifstream and write to a socket, you might consider using llvm::sys::fs::copy_file, declared in Support/FileSystem.h. Currently it takes two paths, but all it does is call openFileForRead() on the first one and openFileForWrite() on the second one to get FDs. So you could probably add an overload that takes two FDs, and have the path version just call the FD version. Then you could call the FD version directly with an FD for your file and an FD for your socket.

[labath]

In D31079#703911, @zturner wrote:

In the places where you want to read from an ifstream and write to a socket, you might consider using llvm::sys::fs::copy_file, declared in Support/FileSystem.h. Currently it takes two paths, but all it does is call openFileForRead() on the first one and openFileForWrite() on the second one to get FDs. So you could probably add an overload that takes two FDs, and have the path version just call the FD version. Then you could call the FD version directly with an FD for your file and an FD for your socket.

Unfortunately, that won't be enough. I need to split the data into chunks and add a header before each chunk. I guess I'll just stick with LLDB's File class for now (?)

lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp

 Error AdbClient::ShellToFile(const char *command, milliseconds timeout,
                              const FileSpec &output_file_spec) {
   std::vector<char> output_buffer;
   auto error = internalShell(command, timeout, output_buffer);
   if (error.Fail())
     return error;
 
   const auto output_filename = output_file_spec.GetPath();
-  std::ofstream dst(output_filename, std::ios::out | std::ios::binary);
-  if (!dst.is_open())
+  std::error_code EC;
+  llvm::raw_fd_ostream dst(output_filename, EC, llvm::sys::fs::F_None);
+  if (EC)
     return Error("Unable to open local file %s", output_filename.c_str());
 
   dst.write(&output_buffer[0], output_buffer.size());
   dst.close();
-  if (!dst)
+  if (dst.has_error())
     return Error("Failed to write file %s", output_filename.c_str());
   return Error();
 }
 
 std::unique_ptr<AdbClient::SyncService>
 AdbClient::GetSyncService(Error &error) {
   std::unique_ptr<SyncService> sync_service;
   error = StartSync();
   if (error.Success())
     sync_service.reset(new SyncService(std::move(m_conn)));
 
   return sync_service;
 }
 
 Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
                                                const FileSpec &local_file) {
   const auto local_file_path = local_file.GetPath();
   llvm::FileRemover local_file_remover(local_file_path);
 
-  std::ofstream dst(local_file_path, std::ios::out | std::ios::binary);
-  if (!dst.is_open())
+  std::error_code EC;
+  llvm::raw_fd_ostream dst(local_file_path, EC, llvm::sys::fs::F_None);
+  if (EC)
     return Error("Unable to open local file %s", local_file_path.c_str());
 
   const auto remote_file_path = remote_file.GetPath(false);
   auto error = SendSyncRequest(kRECV, remote_file_path.length(),
                                remote_file_path.c_str());
   if (error.Fail())
     return error;
 
   std::vector<char> chunk;
   bool eof = false;
   while (!eof) {
     error = PullFileChunk(chunk, eof);
     if (error.Fail())
       return error;
     if (!eof)
       dst.write(&chunk[0], chunk.size());
   }
+  dst.close();
+  if (dst.has_error())
+    return Error("Failed to write file %s", local_file_path.c_str());
 
   local_file_remover.releaseFile();
   return error;
 }
 
 Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
                                                const FileSpec &remote_file) {
   const auto local_file_path(local_file.GetPath());

lldb/trunk/source/Target/Platform.cpp

 }
 
 Error Platform::DownloadModuleSlice(const FileSpec &src_file_spec,
                                     const uint64_t src_offset,
                                     const uint64_t src_size,
                                     const FileSpec &dst_file_spec) {
   Error error;
 
-  std::ofstream dst(dst_file_spec.GetPath(), std::ios::out | std::ios::binary);
-  if (!dst.is_open()) {
+  std::error_code EC;
+  llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::F_None);
+  if (EC) {
     error.SetErrorStringWithFormat("unable to open destination file: %s",
                                    dst_file_spec.GetPath().c_str());
     return error;
   }
 
   auto src_fd = OpenFile(src_file_spec, File::eOpenOptionRead,
                          lldb::eFilePermissionsFileDefault, error);
 

lldb/trunk/tools/lldb-server/lldb-platform.cpp

 static Error save_socket_id_to_file(const std::string &socket_id,
                                     const FileSpec &file_spec) {
   FileSpec temp_file_spec(file_spec.GetDirectory().AsCString(), false);
   Error error(llvm::sys::fs::create_directory(temp_file_spec.GetPath()));
   if (error.Fail())
     return Error("Failed to create directory %s: %s",
                  temp_file_spec.GetCString(), error.AsCString());
 
-  llvm::SmallString<PATH_MAX> temp_file_path;
+  llvm::SmallString<64> temp_file_path;
   temp_file_spec.AppendPathComponent("port-file.%%%%%%");
-  auto err_code = llvm::sys::fs::createUniqueFile(temp_file_spec.GetCString(),
+  int FD;
+  auto err_code = llvm::sys::fs::createUniqueFile(temp_file_spec.GetPath(), FD,
                                                   temp_file_path);
   if (err_code)
     return Error("Failed to create temp file: %s", err_code.message().c_str());
 
-  llvm::FileRemover tmp_file_remover(temp_file_path.c_str());
+  llvm::FileRemover tmp_file_remover(temp_file_path);
 
   {
-    std::ofstream temp_file(temp_file_path.c_str(), std::ios::out);
-    if (!temp_file.is_open())
-      return Error("Failed to open temp file %s", temp_file_path.c_str());
+    llvm::raw_fd_ostream temp_file(FD, true);
     temp_file << socket_id;
+    temp_file.close();
+    if (temp_file.has_error())
+      return Error("Failed to write to port file.");
   }
 
-  err_code = llvm::sys::fs::rename(temp_file_path.c_str(), file_spec.GetPath());
+  err_code = llvm::sys::fs::rename(temp_file_path, file_spec.GetPath());
   if (err_code)
     return Error("Failed to rename file %s to %s: %s", temp_file_path.c_str(),
                  file_spec.GetPath().c_str(), err_code.message().c_str());
 
   tmp_file_remover.releaseFile();
   return Error();
 }