1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ipc/file_descriptor_set_posix.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
FileDescriptorSet::FileDescriptorSet()
: consumed_descriptor_highwater_(0) {
}
FileDescriptorSet::~FileDescriptorSet() {
if (consumed_descriptor_highwater_ == size())
return;
// We close all the owning descriptors. If this message should have
// been transmitted, then closing those with close flags set mirrors
// the expected behaviour.
//
// If this message was received with more descriptors than expected
// (which could a DOS against the browser by a rogue renderer) then all
// the descriptors have their close flag set and we free all the extra
// kernel resources.
LOG(WARNING) << "FileDescriptorSet destroyed with unconsumed descriptors: "
<< consumed_descriptor_highwater_ << "/" << size();
}
bool FileDescriptorSet::AddToBorrow(base::PlatformFile fd) {
DCHECK_EQ(consumed_descriptor_highwater_, 0u);
if (size() == kMaxDescriptorsPerMessage) {
DLOG(WARNING) << "Cannot add file descriptor. FileDescriptorSet full.";
return false;
}
descriptors_.push_back(fd);
return true;
}
bool FileDescriptorSet::AddToOwn(base::ScopedFD fd) {
DCHECK_EQ(consumed_descriptor_highwater_, 0u);
if (size() == kMaxDescriptorsPerMessage) {
DLOG(WARNING) << "Cannot add file descriptor. FileDescriptorSet full.";
return false;
}
descriptors_.push_back(fd.get());
owned_descriptors_.push_back(new base::ScopedFD(fd.Pass()));
DCHECK(size() <= kMaxDescriptorsPerMessage);
return true;
}
base::PlatformFile FileDescriptorSet::TakeDescriptorAt(unsigned index) {
if (index >= size()) {
DLOG(WARNING) << "Accessing out of bound index:"
<< index << "/" << size();
return -1;
}
// We should always walk the descriptors in order, so it's reasonable to
// enforce this. Consider the case where a compromised renderer sends us
// the following message:
//
// ExampleMsg:
// num_fds:2 msg:FD(index = 1) control:SCM_RIGHTS {n, m}
//
// Here the renderer sent us a message which should have a descriptor, but
// actually sent two in an attempt to fill our fd table and kill us. By
// setting the index of the descriptor in the message to 1 (it should be
// 0), we would record a highwater of 1 and then consider all the
// descriptors to have been used.
//
// So we can either track of the use of each descriptor in a bitset, or we
// can enforce that we walk the indexes strictly in order.
//
// There's one more wrinkle: When logging messages, we may reparse them. So
// we have an exception: When the consumed_descriptor_highwater_ is at the
// end of the array and index 0 is requested, we reset the highwater value.
// TODO(morrita): This is absurd. This "wringle" disallow to introduce clearer
// ownership model. Only client is NaclIPCAdapter. See crbug.com/415294
if (index == 0 && consumed_descriptor_highwater_ == descriptors_.size())
consumed_descriptor_highwater_ = 0;
if (index != consumed_descriptor_highwater_)
return -1;
consumed_descriptor_highwater_ = index + 1;
base::PlatformFile file = descriptors_[index];
// TODO(morrita): In production, descriptors_.size() should be same as
// owned_descriptors_.size() as all read descriptors are owned by Message.
// We have to do this because unit test breaks this assumption. It should be
// changed to exercise with own-able descriptors.
for (ScopedVector<base::ScopedFD>::const_iterator i =
owned_descriptors_.begin();
i != owned_descriptors_.end();
++i) {
if ((*i)->get() == file) {
ignore_result((*i)->release());
break;
}
}
return file;
}
void FileDescriptorSet::PeekDescriptors(base::PlatformFile* buffer) const {
std::copy(descriptors_.begin(), descriptors_.end(), buffer);
}
bool FileDescriptorSet::ContainsDirectoryDescriptor() const {
struct stat st;
for (std::vector<base::PlatformFile>::const_iterator i = descriptors_.begin();
i != descriptors_.end();
++i) {
if (fstat(*i, &st) == 0 && S_ISDIR(st.st_mode))
return true;
}
return false;
}
void FileDescriptorSet::CommitAll() {
descriptors_.clear();
owned_descriptors_.clear();
consumed_descriptor_highwater_ = 0;
}
void FileDescriptorSet::ReleaseFDsToClose(
std::vector<base::PlatformFile>* fds) {
for (ScopedVector<base::ScopedFD>::iterator i = owned_descriptors_.begin();
i != owned_descriptors_.end();
++i) {
fds->push_back((*i)->release());
}
CommitAll();
}
void FileDescriptorSet::AddDescriptorsToOwn(const base::PlatformFile* buffer,
unsigned count) {
DCHECK(count <= kMaxDescriptorsPerMessage);
DCHECK_EQ(size(), 0u);
DCHECK_EQ(consumed_descriptor_highwater_, 0u);
descriptors_.reserve(count);
owned_descriptors_.reserve(count);
for (unsigned i = 0; i < count; ++i) {
descriptors_.push_back(buffer[i]);
owned_descriptors_.push_back(new base::ScopedFD(buffer[i]));
}
}
|
