UserFile::UserFile(Class *cls,
const req::ptr<StreamContext>& context /*= null */)
: UserFSNode(cls, context) {
m_StreamOpen = lookupMethod(s_stream_open.get());
m_StreamClose = lookupMethod(s_stream_close.get());
m_StreamRead = lookupMethod(s_stream_read.get());
m_StreamWrite = lookupMethod(s_stream_write.get());
m_StreamSeek = lookupMethod(s_stream_seek.get());
m_StreamTell = lookupMethod(s_stream_tell.get());
m_StreamEof = lookupMethod(s_stream_eof.get());
m_StreamFlush = lookupMethod(s_stream_flush.get());
m_StreamTruncate = lookupMethod(s_stream_truncate.get());
m_StreamLock = lookupMethod(s_stream_lock.get());
m_StreamStat = lookupMethod(s_stream_stat.get());
m_UrlStat = lookupMethod(s_url_stat.get());
m_Unlink = lookupMethod(s_unlink.get());
m_Rename = lookupMethod(s_rename.get());
m_Mkdir = lookupMethod(s_mkdir.get());
m_Rmdir = lookupMethod(s_rmdir.get());
m_StreamMetadata = lookupMethod(s_stream_metadata.get());
m_StreamCast = lookupMethod(s_stream_cast.get());
setIsLocal(true);
// UserFile, to match Zend, should not call stream_close() unless it was ever
// opened. This is a bit of a misuse of this field but the API doesn't allow
// one direct access to an not-yet-opened stream resource so it should be
// safe.
setIsClosed(true);
}
bool UserFile::openImpl(const String& filename, const String& mode,
int options) {
// bool stream_open($path, $mode, $options, &$opened_path)
bool invoked = false;
Variant opened_path;
Variant ret = invoke(
m_StreamOpen,
s_stream_open,
PackedArrayInit(4)
.append(filename)
.append(mode)
.append(options)
.appendRef(opened_path)
.toArray(),
invoked
);
if (!invoked || !ret.toBoolean()) {
raise_warning("\"%s::stream_open\" call failed", m_cls->name()->data());
return false;
}
if (m_StreamTell && (memchr(mode.data(), 'a', mode.size()) != nullptr)) {
// Call stream_tell() to determine if the initial position isn't 0. If the
// call fails just assume we're starting at a position of 0.
ret = invoke(m_StreamTell, s_stream_tell, Array::Create(), invoked);
if (invoked && ret.isInteger()) {
setPosition(ret.toInt64());
}
}
setIsClosed(false);
return true;
}
bool BuiltinFile::close() {
invokeFiltersOnClose();
auto status = ::fclose(m_stream);
setIsClosed(true);
m_stream = nullptr;
setFd(-1);
File::closeImpl();
return status == 0;
}
void BuiltinFile::sweep() {
invokeFiltersOnClose();
// This object was just a wrapper around a FILE* or fd owned by someone else,
// so don't close it except in explicit calls to close(). Beware this doesn't
// call PlainFile::sweep().
m_stream = nullptr;
setFd(-1);
setIsClosed(true);
File::sweep();
}
bool MemFile::closeImpl() {
s_pcloseRet = 0;
setIsClosed(true);
if (m_malloced && m_data) {
free(m_data);
m_data = nullptr;
}
File::closeImpl();
return true;
}
bool BZ2File::closeImpl() {
assert(m_bzFile);
bool ret = true;
BZ2_bzclose(m_bzFile);
m_bzFile = nullptr;
setIsClosed(true);
m_innerFile->close();
File::closeImpl();
setEof(false);
return ret;
}
bool UserFile::close() {
// fclose() should prevent this from being called on a closed stream
assert(!isClosed());
// PHP's streams layer explicitly flushes on close
// Mimick that for user-wrappers by pushing the flush here
// without impacting other HPHP stream types.
bool ret = flushImpl(false) || !RuntimeOption::CheckFlushOnUserClose;
// void stream_close()
invoke(m_StreamClose, s_stream_close, Array::Create());
setIsClosed(true);
return ret;
}
bool PlainFile::closeImpl() {
bool ret = true;
s_pcloseRet = 0;
if (!isClosed()) {
if (m_stream) {
s_pcloseRet = fclose(m_stream);
m_stream = nullptr;
} else if (getFd() >= 0) {
s_pcloseRet = ::close(getFd());
}
if (m_buffer) {
free(m_buffer);
m_buffer = nullptr;
}
ret = (s_pcloseRet == 0);
setIsClosed(true);
setFd(-1);
}
File::closeImpl();
return ret;
}
bool ZipFile::closeImpl() {
bool ret = true;
s_pcloseRet = 0;
if (!isClosed()) {
if (m_gzFile) {
s_pcloseRet = gzclose(m_gzFile);
ret = (s_pcloseRet == 0);
m_gzFile = nullptr;
}
setIsClosed(true);
if (m_innerFile.is<File>()) {
m_innerFile.getTyped<File>()->close();
}
if (m_tempFile.is<File>()) {
m_tempFile.getTyped<File>()->close();
m_tempFile.reset();
}
}
File::closeImpl();
return ret;
}
BuiltinFile::~BuiltinFile() {
setIsClosed(true);
m_stream = nullptr;
setFd(-1);
}
