int socket_input_stream::unsafe_read()
{
if (pos_ < mark_) {
return buffer_[pos_++];
}
int r = blocking_ ?
recv(file_descriptor(), buffer_, STREAM_BUFFER_SIZE, 0) :
recv(file_descriptor(), buffer_, STREAM_BUFFER_SIZE, MSG_DONTWAIT);
if (r < 0) {
switch (errno) {
case EAGAIN:
return EOF;
case EINTR:
return stream_result::INTERRUPTED;
default:
throw std::runtime_error(strerror(errno));
}
}
else if (r == 0) {
return EOF;
}
else {
mark_ = r;
pos_ = 0;
return buffer_[pos_++];
}
}
void FileBase::removexattr(const char* name)
{
#ifdef __APPLE__
auto rc = ::fremovexattr(file_descriptor(), name, 0);
#else
auto rc = ::fremovexattr(file_descriptor(), name);
#endif
if (rc < 0)
throw OSException(errno);
}
ssize_t FileBase::listxattr(char* buffer, size_t size)
{
#ifdef __APPLE__
auto rc = ::flistxattr(file_descriptor(), buffer, size, 0);
#else
auto rc = ::flistxattr(file_descriptor(), buffer, size);
#endif
if (rc < 0)
throw OSException(errno);
return rc;
}
int socket_input_stream::read()
{
if (file_descriptor() == -1) {
return stream_result::INVALID_HANDLE;
}
return unsafe_read();
}
tcp_socket accept(int flags) {
int sock_fd = accept4(fd.getfd(), nullptr, nullptr, flags);
if(sock_fd == -1) {
throw errno_exception("acceptor::accept");
}
return tcp_socket(file_descriptor(sock_fd));
}
int socket_output_stream::write(char c)
{
if (file_descriptor() == -1) {
return stream_result::INVALID_HANDLE;
}
return unsafe_write(c);
}
int socket_output_stream::write_string(const char *str, size_t max_len, size_t *written)
{
if (file_descriptor() == -1) {
if (written) {
*written = 0;
}
return stream_result::INVALID_HANDLE;
}
if (max_len == 0) {
max_len = std::numeric_limits<size_t>::max();
}
for (size_t i = 0; max_len == 0 || i < max_len; i++) {
char c = str[i];
if (c == 0) {
if (written) {
*written = i;
}
return i;
}
int w = unsafe_write(c);
if (w < 0) {
if (written) {
*written = i;
}
return w;
}
}
return stream_result::DATA_TRUNCATED;
}
void JarFileParser::dispose() const {
FileDescriptor::Raw desc = file_descriptor();
desc().dispose();
#ifdef AZZERT
BufferedFile::Raw bf = buffered_file();
bf().junk_file_pointer();
#endif
}
file_descriptor openSlave() const {
char *name = ptsname(master_fd.getfd());
if (name) {
return file_descriptor(::open(name, O_RDWR));
} else {
throw errno_exception("pseudoterminal::openSlave, ptsname");
}
}
locked_pid_file::locked_pid_file(const boost::filesystem::path& path) :
pid_file(path)
{
if (::flock(file_descriptor(), LOCK_EX) != 0)
{
throw boost::system::system_error(errno, boost::system::system_category(), "Locking on the PID file");
}
}
ssize_t FileBase::getxattr(const char* name, char* value, size_t size)
{
if (!name)
throw OSException(EFAULT);
auto true_size = fgetxattr_wrapper(file_descriptor(), name, value, size);
if (true_size < 0)
throw OSException(errno);
if (!value)
return true_size;
byte meta[XATTR_IV_LENGTH + XATTR_MAC_LENGTH];
auto true_meta_size = fgetxattr_wrapper(m_meta_fd, name, meta, sizeof(meta));
if (true_meta_size < 0)
{
if (errno == ERANGE)
errno = EIO;
throw OSException(errno);
}
auto name_len = strlen(name);
std::unique_ptr<byte[]> header(new byte[name_len + ID_LENGTH]);
memcpy(header.get(), get_id().data(), ID_LENGTH);
memcpy(header.get() + ID_LENGTH, name, name_len);
byte* iv = meta;
byte* mac = meta + XATTR_IV_LENGTH;
byte* ciphertext = reinterpret_cast<byte*>(value);
bool success = aes_gcm_decrypt(ciphertext,
true_size,
header.get(),
name_len + ID_LENGTH,
get_key().data(),
get_key().size(),
iv,
XATTR_IV_LENGTH,
mac,
XATTR_MAC_LENGTH,
value);
if (m_check && !success)
throw XattrVerificationException(get_id(), name);
return true_size;
}
int socket_output_stream::unsafe_send(size_t offset, size_t count, bool do_throw)
{
int w = send(file_descriptor(), buffer_ + offset, count, MSG_DONTWAIT);
if (w == -1) {
switch (errno) {
case ECONNRESET:
return stream_result::RESET_BY_PEER;
case EAGAIN:
return 0;
case EINTR:
return stream_result::INTERRUPTED;
default:
if (do_throw) {
throw std::runtime_error(strerror(errno));
}
}
}
return w;
}
void FileBase::setxattr(const char* name, const char* value, size_t size, int flags)
{
if (!name || !value)
throw OSException(EFAULT);
std::unique_ptr<byte[]> buffer(new byte[size]);
byte* ciphertext = buffer.get();
byte meta[XATTR_MAC_LENGTH + XATTR_IV_LENGTH];
byte* iv = meta;
byte* mac = iv + XATTR_IV_LENGTH;
generate_random(iv, XATTR_IV_LENGTH);
auto name_len = strlen(name);
std::unique_ptr<byte[]> header(new byte[name_len + ID_LENGTH]);
memcpy(header.get(), get_id().data(), ID_LENGTH);
memcpy(header.get() + ID_LENGTH, name, name_len);
aes_gcm_encrypt(value,
size,
header.get(),
name_len + ID_LENGTH,
get_key().data(),
get_key().size(),
iv,
XATTR_IV_LENGTH,
mac,
XATTR_MAC_LENGTH,
ciphertext);
auto rc = fsetxattr_wrapper(file_descriptor(), name, ciphertext, size, flags);
if (rc < 0)
throw OSException(errno);
rc = fsetxattr_wrapper(m_meta_fd, name, meta, sizeof(meta), flags);
if (rc < 0)
throw OSException(errno);
}
bool socket_input_stream::canReadFromBuffer() const
{
return file_descriptor() != -1 && pos_ < mark_;
}
void socket_output_stream::close_file()
{
::close(file_descriptor());
}
void socket_output_stream::flush()
{
if (file_descriptor() >= 0) {
unsafe_flush(false);
}
}
bool socket_output_stream::canWriteToBuffer() const
{
return file_descriptor() != -1 && pos_ < STREAM_BUFFER_SIZE;
}
OsFile_Handle JarFileParser::handle() const {
FileDescriptor::Raw desc = file_descriptor();
GUARANTEE(desc().valid(), "sanity");
return desc().handle();
}
locked_pid_file::~locked_pid_file()
{
::flock(file_descriptor(), LOCK_UN);
}
