rnp_input_from_path is never fclosed - keep windows file locked

[shemeshg]

I am using rnp_input_from_path

rnp_input_from_path(&input, filePath.c_str()); }

to open an encrypted file on Windows, but I noticed that the file descriptor is not freed after the function call. [There is no fclose or _wclose in the source code of rnp_input_destroy(input)

• .How can I fix this issue?

  This causes the file to remain locked by the OS, and I cannot write to it later.
  (This is not a problem on Mac or Linux, as verified with lsof -c pass-simple | wc -l.
  I guess on macos. it probably performs opportunistic open with no lock.
  )

• Can I manage the open and close of the fd from outside the library?

  (I sow the res = rnp_input_from_stdin(&input); but it does not accept standard istream,ostream, or standard C styleFILE *.
  (it is used to handel console std::cin only within enclosed within the function itself)

[ni4]

rnp_input_from_path() internally calls init_file_src() which later calls init_fd_src(), which then sets src->close function (in later commits - src->raw_close()withfile_src_close(). And rnp_input_destroy()in~rnp_input_t()` destructor must call this method. So I don't see RNP issue here, or does something happen not in this way?

If you need a custom input, you may use rnp_input_from_callback() function, you may see an example in dump.c or our test files.

[shemeshg]

Thanks, It helped: closing file process on rnpgp is correct.

Solved by RAII rnp_input_from_path

class RnpInputFromPath
{
public:
    RnpInputFromPath(const std::string &filePath)
        : filePath{filePath}
    {
        rnp_input_from_path(&input, filePath.c_str());
    }

    const rnp_input_t *getInput() const { return &input; }

    virtual ~RnpInputFromPath() { rnp_input_destroy(input); }

private:
    std::string filePath;
    rnp_input_t input = NULL;
};

class RnpOutputToPath
{
public:
    RnpOutputToPath(const std::string &filePath)
        : filePath{filePath}
    {
        rnp_output_to_path(&output, filePath.c_str()); 
    }

    const rnp_output_t *getOutput() const { return &output; }

    virtual ~RnpOutputToPath() { rnp_output_destroy(output); }

private:
    std::string filePath;
    rnp_output_t output = NULL;
};


class RnpOutputToMemory
{
    public:
    RnpOutputToMemory() { rnp_output_to_memory(&output, 0); }

    const rnp_output_t *getOutput() const { return &output; }

    virtual ~RnpOutputToMemory() { rnp_output_destroy(output); }

private:
    rnp_output_t output = NULL;
};

class RnpInputFromMemory
{
    public:
    RnpInputFromMemory(const std::string &inStr) { 
        message = inStr.c_str();
        rnp_input_from_memory(&input, (uint8_t *) message, strlen(message), false); 
        }

    const rnp_input_t *getInput() const { return &input; }

    virtual ~RnpInputFromMemory() { rnp_input_destroy(input); }

private:
    rnp_input_t input = NULL;
    const char *message;
};