Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 358c2ec1 authored by Tao Bao's avatar Tao Bao
Browse files

Remove ota_close(int) and ota_fclose(FILE*). 

We should always use unique_fd or unique_file to hold the FD or FILE*
pointer when opening via ota_(f)open functions.

This CL avoids accidentally closing raw FDs or FILE* pointers that are
managed by unique_fd/unique_file.

Test: recovery_component_test passes.
Change-Id: If58eb8b5c5da507563f85efd5d56276472a1c957
parent 3dc14cb4

applypatch/applypatch.cpp

+2 −2
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ int LoadFileContents(const char* filename, FileContents* file) { 
  }



  std::vector<unsigned char> data(file->st.st_size);

  std::unique_ptr<FILE, int (*)(FILE*)> f(ota_fopen(filename, "rb"), ota_fclose);

  unique_file f(ota_fopen(filename, "rb"));

  if (!f) {

    printf("failed to open \"%s\": %s\n", filename, strerror(errno));

    return -1;
@@ -118,7 +118,7 @@ static int LoadPartitionContents(const std::string& filename, FileContents* file 
  std::sort(pairs.begin(), pairs.end());



  const char* partition = pieces[1].c_str();

  std::unique_ptr<FILE, int (*)(FILE*)> dev(ota_fopen(partition, "rb"), ota_fclose);

  unique_file dev(ota_fopen(partition, "rb"));

  if (!dev) {

    printf("failed to open emmc partition \"%s\": %s\n", partition, strerror(errno));

    return -1;

otafault/ota_io.cpp

+14 −6
Original line number Diff line number Diff line
@@ -70,23 +70,31 @@ FILE* ota_fopen(const char* path, const char* mode) { 
    return fh;

}



int ota_close(int fd) {

static int __ota_close(int fd) {

    // descriptors can be reused, so make sure not to leave them in the cache

    filename_cache.erase(fd);

    return close(fd);

}



void OtaCloser::Close(int fd) {

    __ota_close(fd);

}



int ota_close(unique_fd& fd) {

    return ota_close(fd.release());

    return __ota_close(fd.release());

}



int ota_fclose(FILE* fh) {

    filename_cache.erase((intptr_t)fh);

static int __ota_fclose(FILE* fh) {

    filename_cache.erase(reinterpret_cast<intptr_t>(fh));

    return fclose(fh);

}



int ota_fclose(std::unique_ptr<FILE, int (*)(FILE*)>& fh) {

    return ota_fclose(fh.release());

void OtaFcloser::operator()(FILE* f) {

    __ota_fclose(f);

};



int ota_fclose(unique_file& fh) {

  return __ota_fclose(fh.release());

}



size_t ota_fread(void* ptr, size_t size, size_t nitems, FILE* stream) {

otafault/ota_io.h

+8 −8
Original line number Diff line number Diff line
@@ -40,10 +40,6 @@ int ota_open(const char* path, int oflags, mode_t mode); 


FILE* ota_fopen(const char* filename, const char* mode);



int ota_close(int fd);



int ota_fclose(FILE* fh);



size_t ota_fread(void* ptr, size_t size, size_t nitems, FILE* stream);



ssize_t ota_read(int fd, void* buf, size_t nbyte);
@@ -55,15 +51,19 @@ ssize_t ota_write(int fd, const void* buf, size_t nbyte); 
int ota_fsync(int fd);



struct OtaCloser {

  static void Close(int fd) {

    ota_close(fd);

  }

  static void Close(int);

};



using unique_fd = android::base::unique_fd_impl<OtaCloser>;



int ota_close(unique_fd& fd);



int ota_fclose(std::unique_ptr<FILE, int (*)(FILE*)>& fh);

struct OtaFcloser {

  void operator()(FILE*);

};



using unique_file = std::unique_ptr<FILE, OtaFcloser>;



int ota_fclose(unique_file& fh);



#endif

updater/install.cpp

+69 −73
Original line number Diff line number Diff line
@@ -509,8 +509,8 @@ Value* PackageExtractFileFn(const char* name, State* state, int argc, Expr* argv 
      return StringValue("");

    }



    int fd = TEMP_FAILURE_RETRY(

        ota_open(dest_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR));

    unique_fd fd(TEMP_FAILURE_RETRY(

        ota_open(dest_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)));

    if (fd == -1) {

      printf("%s: can't open %s for write: %s\n", name, dest_path.c_str(), strerror(errno));

      return StringValue("");
@@ -896,16 +896,15 @@ Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) { 
  }



  std::string buffer(st.st_size, '\0');

    FILE* f = ota_fopen(filename.c_str(), "rb");

  unique_file f(ota_fopen(filename.c_str(), "rb"));

  if (f == nullptr) {

        return ErrorAbort(state, kFileOpenFailure, "%s: failed to open %s: %s", name,

                          filename.c_str(), strerror(errno));

    return ErrorAbort(state, kFileOpenFailure, "%s: failed to open %s: %s", name, filename.c_str(),

                      strerror(errno));

  }



    if (ota_fread(&buffer[0], 1, st.st_size, f) != static_cast<size_t>(st.st_size)) {

        ErrorAbort(state, kFreadFailure, "%s: failed to read %zu bytes from %s",

                   name, static_cast<size_t>(st.st_size), filename.c_str());

        ota_fclose(f);

  if (ota_fread(&buffer[0], 1, st.st_size, f.get()) != static_cast<size_t>(st.st_size)) {

    ErrorAbort(state, kFreadFailure, "%s: failed to read %zu bytes from %s", name,

               static_cast<size_t>(st.st_size), filename.c_str());

    return nullptr;

  }
@@ -1307,13 +1306,10 @@ Value* WipeBlockDeviceFn(const char* name, State* state, int argc, Expr* argv[]) 
  if (!android::base::ParseUint(len_str.c_str(), &len)) {

    return nullptr;

  }

    int fd = ota_open(filename.c_str(), O_WRONLY, 0644);

  unique_fd fd(ota_open(filename.c_str(), O_WRONLY, 0644));

  // The wipe_block_device function in ext4_utils returns 0 on success and 1

  // for failure.

  int status = wipe_block_device(fd, len);



    ota_close(fd);



  return StringValue((status == 0) ? "t" : "");

}