id
stringlengths 15
19
| content
stringlengths 62
138k
|
|---|---|
primevul_data_1
|
void UpdateNetworkManagerStatus() {
if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
NewRunnableMethod(this,
&NetworkLibraryImpl::UpdateNetworkManagerStatus));
return;
}
SystemInfo* system = GetSystemInfo();
if (!system)
return;
std::string prev_cellular_service_path = cellular_ ?
cellular_->service_path() : std::string();
ClearNetworks();
ParseSystem(system, ðernet_, &wifi_networks_, &cellular_networks_,
&remembered_wifi_networks_);
wifi_ = NULL;
for (size_t i = 0; i < wifi_networks_.size(); i++) {
if (wifi_networks_[i]->connecting_or_connected()) {
wifi_ = wifi_networks_[i];
break; // There is only one connected or connecting wifi network.
}
}
cellular_ = NULL;
for (size_t i = 0; i < cellular_networks_.size(); i++) {
if (cellular_networks_[i]->connecting_or_connected()) {
cellular_ = cellular_networks_[i];
if (cellular_networks_[i]->service_path() !=
prev_cellular_service_path) {
CellularDataPlanList* list = RetrieveCellularDataPlans(
cellular_->service_path().c_str());
UpdateCellularDataPlan(list);
FreeCellularDataPlanList(list);
}
break; // There is only one connected or connecting cellular network.
}
}
available_devices_ = system->available_technologies;
enabled_devices_ = system->enabled_technologies;
connected_devices_ = system->connected_technologies;
offline_mode_ = system->offline_mode;
NotifyNetworkManagerChanged();
FreeSystemInfo(system);
}
The vulnerability label is: Vulnerable
|
primevul_data_2
|
int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) {
HostUsageMap::const_iterator found = cached_usage_.find(host);
if (found == cached_usage_.end())
return 0;
int64 usage = 0;
const UsageMap& map = found->second;
for (UsageMap::const_iterator iter = map.begin();
iter != map.end(); ++iter) {
usage += iter->second;
}
return usage;
}
The vulnerability label is: Vulnerable
|
primevul_data_3
|
void AddInstallerCopyTasks(const InstallerState& installer_state,
const FilePath& setup_path,
const FilePath& archive_path,
const FilePath& temp_path,
const Version& new_version,
WorkItemList* install_list) {
DCHECK(install_list);
FilePath installer_dir(installer_state.GetInstallerDirectory(new_version));
install_list->AddCreateDirWorkItem(installer_dir);
FilePath exe_dst(installer_dir.Append(setup_path.BaseName()));
FilePath archive_dst(installer_dir.Append(archive_path.BaseName()));
install_list->AddMoveTreeWorkItem(setup_path.value(), exe_dst.value(),
temp_path.value(), WorkItem::ALWAYS_MOVE);
install_list->AddMoveTreeWorkItem(archive_path.value(), archive_dst.value(),
temp_path.value(), WorkItem::ALWAYS_MOVE);
}
The vulnerability label is: Vulnerable
|
primevul_data_4
|
bool decode(ArgumentDecoder* decoder, RetainPtr<CFURLRef>& result)
{
RetainPtr<CFURLRef> baseURL;
bool hasBaseURL;
if (!decoder->decodeBool(hasBaseURL))
return false;
if (hasBaseURL) {
if (!decode(decoder, baseURL))
return false;
}
RetainPtr<CFStringRef> string;
if (!decode(decoder, string))
return false;
CFURLRef url = CFURLCreateWithString(0, string.get(), baseURL.get());
if (!url)
return false;
result.adoptCF(url);
return true;
}
The vulnerability label is: Vulnerable
|
primevul_data_5
|
void WebProcessProxy::addExistingWebPage(WebPageProxy* webPage, uint64_t pageID)
{
m_pageMap.set(pageID, webPage);
globalPageMap().set(pageID, webPage);
#if PLATFORM(MAC)
if (pageIsProcessSuppressible(webPage));
m_processSuppressiblePages.add(pageID);
updateProcessSuppressionState();
#endif
}
The vulnerability label is: Vulnerable
|
primevul_data_6
|
v8::Handle<v8::Value> V8ThrowException::createDOMException(v8::Isolate* isolate, int ec, const String& sanitizedMessage, const String& unsanitizedMessage, const v8::Handle<v8::Object>& creationContext)
{
if (ec <= 0 || v8::V8::IsExecutionTerminating())
return v8Undefined();
ASSERT(ec == SecurityError || unsanitizedMessage.isEmpty());
if (ec == V8GeneralError)
return V8ThrowException::createGeneralError(isolate, sanitizedMessage);
if (ec == V8TypeError)
return V8ThrowException::createTypeError(isolate, sanitizedMessage);
if (ec == V8RangeError)
return V8ThrowException::createRangeError(isolate, sanitizedMessage);
if (ec == V8SyntaxError)
return V8ThrowException::createSyntaxError(isolate, sanitizedMessage);
if (ec == V8ReferenceError)
return V8ThrowException::createReferenceError(isolate, sanitizedMessage);
RefPtrWillBeRawPtr<DOMException> domException = DOMException::create(ec, sanitizedMessage, unsanitizedMessage);
v8::Handle<v8::Value> exception = toV8(domException.get(), creationContext, isolate);
if (exception.IsEmpty())
return v8Undefined();
v8::Handle<v8::Value> error = v8::Exception::Error(v8String(isolate, domException->message()));
ASSERT(!error.IsEmpty());
ASSERT(exception->IsObject());
exception->ToObject(isolate)->SetAccessor(v8AtomicString(isolate, "stack"), domExceptionStackGetter, domExceptionStackSetter, error);
V8HiddenValue::setHiddenValue(isolate, exception->ToObject(isolate), V8HiddenValue::error(isolate), error);
return exception;
}
The vulnerability label is: Vulnerable
|
primevul_data_7
|
void OverlayWindowViews::OnGestureEvent(ui::GestureEvent* event) {
if (event->type() != ui::ET_GESTURE_TAP)
return;
hide_controls_timer_.Reset();
if (!GetControlsScrimLayer()->visible()) {
UpdateControlsVisibility(true);
return;
}
if (GetCloseControlsBounds().Contains(event->location())) {
controller_->Close(true /* should_pause_video */,
true /* should_reset_pip_player */);
event->SetHandled();
} else if (GetPlayPauseControlsBounds().Contains(event->location())) {
TogglePlayPause();
event->SetHandled();
}
views::Widget::OnGestureEvent(event);
}
The vulnerability label is: Vulnerable
|
primevul_data_8
|
std::string CellularNetwork::ActivationStateToString(
ActivationState activation_state) {
switch (activation_state) {
case ACTIVATION_STATE_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATED);
break;
case ACTIVATION_STATE_ACTIVATING:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATING);
break;
case ACTIVATION_STATE_NOT_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED);
break;
case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_PARTIALLY_ACTIVATED);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_UNKNOWN);
break;
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_9
|
virtual void AddCellularDataPlanObserver(CellularDataPlanObserver* observer) {
if (!data_plan_observers_.HasObserver(observer))
data_plan_observers_.AddObserver(observer);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_10
|
virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {
if (!network_manager_observers_.HasObserver(observer))
network_manager_observers_.AddObserver(observer);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_11
|
virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_12
|
virtual void AddNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {
DCHECK(observer);
if (!EnsureCrosLoaded())
return;
NetworkObserverMap::iterator iter = network_observers_.find(service_path);
NetworkObserverList* oblist;
if (iter != network_observers_.end()) {
oblist = iter->second;
} else {
std::pair<NetworkObserverMap::iterator, bool> inserted =
network_observers_.insert(
std::make_pair<std::string, NetworkObserverList*>(
service_path,
new NetworkObserverList(this, service_path)));
oblist = inserted.first->second;
}
if (!oblist->HasObserver(observer))
oblist->AddObserver(observer);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_13
|
virtual void AddNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_14
|
CellularNetwork::CellularNetwork()
: WirelessNetwork(),
activation_state_(ACTIVATION_STATE_UNKNOWN),
network_technology_(NETWORK_TECHNOLOGY_UNKNOWN),
roaming_state_(ROAMING_STATE_UNKNOWN),
restricted_pool_(false),
prl_version_(0) {
type_ = TYPE_CELLULAR;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_15
|
CellularNetwork::CellularNetwork(const CellularNetwork& network)
: WirelessNetwork(network) {
activation_state_ = network.activation_state();
network_technology_ = network.network_technology();
roaming_state_ = network.roaming_state();
restricted_pool_ = network.restricted_pool();
service_name_ = network.service_name();
operator_name_ = network.operator_name();
operator_code_ = network.operator_code();
payment_url_ = network.payment_url();
meid_ = network.meid();
imei_ = network.imei();
imsi_ = network.imsi();
esn_ = network.esn();
mdn_ = network.mdn();
min_ = network.min();
model_id_ = network.model_id();
manufacturer_ = network.manufacturer();
firmware_revision_ = network.firmware_revision();
hardware_revision_ = network.hardware_revision();
last_update_ = network.last_update();
prl_version_ = network.prl_version();
type_ = TYPE_CELLULAR;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_16
|
CellularNetwork::CellularNetwork(const ServiceInfo* service)
: WirelessNetwork(service) {
service_name_ = SafeString(service->name);
activation_state_ = service->activation_state;
network_technology_ = service->network_technology;
roaming_state_ = service->roaming_state;
restricted_pool_ = service->restricted_pool;
if (service->carrier_info) {
operator_name_ = SafeString(service->carrier_info->operator_name);
operator_code_ = SafeString(service->carrier_info->operator_code);
payment_url_ = SafeString(service->carrier_info->payment_url);
}
if (service->device_info) {
meid_ = SafeString(service->device_info->MEID);
imei_ = SafeString(service->device_info->IMEI);
imsi_ = SafeString(service->device_info->IMSI);
esn_ = SafeString(service->device_info->ESN);
mdn_ = SafeString(service->device_info->MDN);
min_ = SafeString(service->device_info->MIN);
model_id_ = SafeString(service->device_info->model_id);
manufacturer_ = SafeString(service->device_info->manufacturer);
firmware_revision_ = SafeString(service->device_info->firmware_revision);
hardware_revision_ = SafeString(service->device_info->hardware_revision);
last_update_ = SafeString(service->device_info->last_update);
prl_version_ = service->device_info->PRL_version;
}
type_ = TYPE_CELLULAR;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_17
|
void Network::Clear() {
state_ = STATE_UNKNOWN;
error_ = ERROR_UNKNOWN;
service_path_.clear();
device_path_.clear();
ip_address_.clear();
is_active_ = false;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_18
|
void WirelessNetwork::Clear() {
Network::Clear();
name_.clear();
strength_ = 0;
auto_connect_ = false;
favorite_ = false;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_19
|
void CellularNetwork::Clear() {
WirelessNetwork::Clear();
activation_state_ = ACTIVATION_STATE_UNKNOWN;
roaming_state_ = ROAMING_STATE_UNKNOWN;
network_technology_ = NETWORK_TECHNOLOGY_UNKNOWN;
restricted_pool_ = false;
service_name_.clear();
operator_name_.clear();
operator_code_.clear();
payment_url_.clear();
meid_.clear();
imei_.clear();
imsi_.clear();
esn_.clear();
mdn_.clear();
min_.clear();
model_id_.clear();
manufacturer_.clear();
firmware_revision_.clear();
hardware_revision_.clear();
last_update_.clear();
prl_version_ = 0;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_20
|
void WifiNetwork::Clear() {
WirelessNetwork::Clear();
encryption_ = SECURITY_NONE;
passphrase_.clear();
identity_.clear();
cert_path_.clear();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_21
|
void ClearNetworks() {
if (ethernet_)
delete ethernet_;
ethernet_ = NULL;
wifi_ = NULL;
cellular_ = NULL;
STLDeleteElements(&wifi_networks_);
wifi_networks_.clear();
STLDeleteElements(&cellular_networks_);
cellular_networks_.clear();
STLDeleteElements(&remembered_wifi_networks_);
remembered_wifi_networks_.clear();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_22
|
virtual void ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
const std::string& certpath) {
DCHECK(network);
if (!EnsureCrosLoaded())
return;
if (ConnectToNetworkWithCertInfo(network->service_path().c_str(),
password.empty() ? NULL : password.c_str(),
identity.empty() ? NULL : identity.c_str(),
certpath.empty() ? NULL : certpath.c_str())) {
WifiNetwork* wifi = GetWirelessNetworkByPath(
wifi_networks_, network->service_path());
if (wifi) {
wifi->set_passphrase(password);
wifi->set_identity(identity);
wifi->set_cert_path(certpath);
wifi->set_connecting(true);
wifi_ = wifi;
}
NotifyNetworkManagerChanged();
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_23
|
virtual void ConnectToWifiNetwork(ConnectionSecurity security,
const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
bool auto_connect) {
if (!EnsureCrosLoaded())
return;
ServiceInfo* service = GetWifiService(ssid.c_str(), security);
if (service) {
SetAutoConnect(service->service_path, auto_connect);
ConnectToNetworkWithCertInfo(service->service_path,
password.empty() ? NULL : password.c_str(),
identity.empty() ? NULL : identity.c_str(),
certpath.empty() ? NULL : certpath.c_str());
FreeServiceInfo(service);
} else {
LOG(WARNING) << "Cannot find hidden network: " << ssid;
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_24
|
virtual void ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
const std::string& certpath) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_25
|
virtual void ConnectToWifiNetwork(ConnectionSecurity security,
const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
bool auto_connect) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_26
|
bool Connected() const {
return ethernet_connected() || wifi_connected() || cellular_connected();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_27
|
bool Connected() const { return true; }
The vulnerability label is: Non-vulnerable
|
primevul_data_28
|
bool Connecting() const {
return ethernet_connecting() || wifi_connecting() || cellular_connecting();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_29
|
bool Connecting() const { return false; }
The vulnerability label is: Non-vulnerable
|
primevul_data_30
|
virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
if (DisconnectFromNetwork(network->service_path().c_str())) {
if (network->type() == TYPE_WIFI) {
WifiNetwork* wifi = GetWirelessNetworkByPath(
wifi_networks_, network->service_path());
if (wifi) {
wifi->set_connected(false);
wifi_ = NULL;
}
} else if (network->type() == TYPE_CELLULAR) {
CellularNetwork* cellular = GetWirelessNetworkByPath(
cellular_networks_, network->service_path());
if (cellular) {
cellular->set_connected(false);
cellular_ = NULL;
}
}
NotifyNetworkManagerChanged();
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_31
|
virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_32
|
virtual void EnableCellularNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_CELLULAR, enable);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_33
|
virtual void EnableEthernetNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_ETHERNET, enable);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_34
|
virtual void EnableEthernetNetworkDevice(bool enable) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_35
|
void EnableNetworkDeviceType(ConnectionType device, bool enable) {
if (!EnsureCrosLoaded())
return;
if (enable && (enabled_devices_ & (1 << device))) {
LOG(WARNING) << "Trying to enable a device that's already enabled: "
<< device;
return;
}
if (!enable && !(enabled_devices_ & (1 << device))) {
LOG(WARNING) << "Trying to disable a device that's already disabled: "
<< device;
return;
}
EnableNetworkDevice(device, enable);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_36
|
virtual void EnableOfflineMode(bool enable) {
if (!EnsureCrosLoaded())
return;
if (enable && offline_mode_) {
VLOG(1) << "Trying to enable offline mode when it's already enabled.";
return;
}
if (!enable && !offline_mode_) {
VLOG(1) << "Trying to disable offline mode when it's already disabled.";
return;
}
if (SetOfflineMode(enable)) {
offline_mode_ = enable;
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_37
|
virtual void EnableOfflineMode(bool enable) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_38
|
virtual void EnableWifiNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_WIFI, enable);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_39
|
virtual CellularNetwork* FindCellularNetworkByPath(
const std::string& path) { return NULL; }
The vulnerability label is: Non-vulnerable
|
primevul_data_40
|
virtual WifiNetwork* FindWifiNetworkByPath(
const std::string& path) {
return GetWirelessNetworkByPath(wifi_networks_, path);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_41
|
virtual WifiNetwork* FindWifiNetworkByPath(
const std::string& path) { return NULL; }
The vulnerability label is: Non-vulnerable
|
primevul_data_42
|
virtual void ForgetWifiNetwork(const std::string& service_path) {
if (!EnsureCrosLoaded())
return;
if (DeleteRememberedService(service_path.c_str())) {
for (WifiNetworkVector::iterator iter =
remembered_wifi_networks_.begin();
iter != remembered_wifi_networks_.end();
++iter) {
if ((*iter)->service_path() == service_path) {
delete (*iter);
remembered_wifi_networks_.erase(iter);
break;
}
}
NotifyNetworkManagerChanged();
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_43
|
std::string CellularNetwork::GetActivationStateString() const {
return ActivationStateToString(this->activation_state_);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_44
|
std::string WifiNetwork::GetEncryptionString() {
switch (encryption_) {
case SECURITY_UNKNOWN:
break;
case SECURITY_NONE:
return "";
case SECURITY_WEP:
return "WEP";
case SECURITY_WPA:
return "WPA";
case SECURITY_RSN:
return "RSN";
case SECURITY_8021X:
return "8021X";
}
return "Unknown";
}
The vulnerability label is: Non-vulnerable
|
primevul_data_45
|
std::string Network::GetErrorString() const {
switch (error_) {
case ERROR_UNKNOWN:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
case ERROR_OUT_OF_RANGE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OUT_OF_RANGE);
case ERROR_PIN_MISSING:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_PIN_MISSING);
case ERROR_DHCP_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_DHCP_FAILED);
case ERROR_CONNECT_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_CONNECT_FAILED);
case ERROR_BAD_PASSPHRASE:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_BAD_PASSPHRASE);
case ERROR_BAD_WEPKEY:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_BAD_WEPKEY);
case ERROR_ACTIVATION_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_ACTIVATION_FAILED);
case ERROR_NEED_EVDO:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_NEED_EVDO);
case ERROR_NEED_HOME_NETWORK:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_NEED_HOME_NETWORK);
case ERROR_OTASP_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OTASP_FAILED);
case ERROR_AAA_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_AAA_FAILED);
default:
break;
}
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_46
|
virtual std::string GetHtmlInfo(int refresh) {
std::string output;
output.append("<html><head><title>About Network</title>");
if (refresh > 0)
output.append("<meta http-equiv=\"refresh\" content=\"" +
base::IntToString(refresh) + "\"/>");
output.append("</head><body>");
if (refresh > 0) {
output.append("(Auto-refreshing page every " +
base::IntToString(refresh) + "s)");
} else {
output.append("(To auto-refresh this page: about:network/<secs>)");
}
output.append("<h3>Ethernet:</h3><table border=1>");
if (ethernet_ && ethernet_enabled()) {
output.append("<tr>" + ToHtmlTableHeader(ethernet_) + "</tr>");
output.append("<tr>" + ToHtmlTableRow(ethernet_) + "</tr>");
}
output.append("</table><h3>Wifi:</h3><table border=1>");
for (size_t i = 0; i < wifi_networks_.size(); ++i) {
if (i == 0)
output.append("<tr>" + ToHtmlTableHeader(wifi_networks_[i]) + "</tr>");
output.append("<tr>" + ToHtmlTableRow(wifi_networks_[i]) + "</tr>");
}
output.append("</table><h3>Cellular:</h3><table border=1>");
for (size_t i = 0; i < cellular_networks_.size(); ++i) {
if (i == 0)
output.append("<tr>" + ToHtmlTableHeader(cellular_networks_[i]) +
"</tr>");
output.append("<tr>" + ToHtmlTableRow(cellular_networks_[i]) + "</tr>");
}
output.append("</table><h3>Remembered Wifi:</h3><table border=1>");
for (size_t i = 0; i < remembered_wifi_networks_.size(); ++i) {
if (i == 0)
output.append(
"<tr>" + ToHtmlTableHeader(remembered_wifi_networks_[i]) +
"</tr>");
output.append("<tr>" + ToHtmlTableRow(remembered_wifi_networks_[i]) +
"</tr>");
}
output.append("</table></body></html>");
return output;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_47
|
virtual std::string GetHtmlInfo(int refresh) { return std::string(); }
The vulnerability label is: Non-vulnerable
|
primevul_data_48
|
virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
std::string* hardware_address) {
hardware_address->clear();
NetworkIPConfigVector ipconfig_vector;
if (EnsureCrosLoaded() && !device_path.empty()) {
IPConfigStatus* ipconfig_status = ListIPConfigs(device_path.c_str());
if (ipconfig_status) {
for (int i = 0; i < ipconfig_status->size; i++) {
IPConfig ipconfig = ipconfig_status->ips[i];
ipconfig_vector.push_back(
NetworkIPConfig(device_path, ipconfig.type, ipconfig.address,
ipconfig.netmask, ipconfig.gateway,
ipconfig.name_servers));
}
*hardware_address = ipconfig_status->hardware_address;
FreeIPConfigStatus(ipconfig_status);
std::sort(ipconfig_vector.begin(), ipconfig_vector.end());
}
}
return ipconfig_vector;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_49
|
virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
std::string* hardware_address) {
hardware_address->clear();
return NetworkIPConfigVector();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_50
|
NetworkLibrary* NetworkLibrary::GetImpl(bool stub) {
if (stub)
return new NetworkLibraryStubImpl();
else
return new NetworkLibraryImpl();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_51
|
std::string CellularNetwork::GetRoamingStateString() const {
switch (this->roaming_state_) {
case ROAMING_STATE_HOME:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_HOME);
break;
case ROAMING_STATE_ROAMING:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_ROAMING);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_UNKNOWN);
break;
};
}
The vulnerability label is: Non-vulnerable
|
primevul_data_52
|
std::string Network::GetStateString() const {
switch (state_) {
case STATE_UNKNOWN:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNKNOWN);
case STATE_IDLE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_IDLE);
case STATE_CARRIER:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CARRIER);
case STATE_ASSOCIATION:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ASSOCIATION);
case STATE_CONFIGURATION:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CONFIGURATION);
case STATE_READY:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_READY);
case STATE_DISCONNECT:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_DISCONNECT);
case STATE_FAILURE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_FAILURE);
case STATE_ACTIVATION_FAILURE:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE);
default:
break;
}
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_53
|
virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) {
if (!EnsureCrosLoaded())
return false;
DeviceNetworkList* network_list = GetDeviceNetworkList();
if (network_list == NULL)
return false;
result->clear();
result->reserve(network_list->network_size);
const base::Time now = base::Time::Now();
for (size_t i = 0; i < network_list->network_size; ++i) {
DCHECK(network_list->networks[i].address);
DCHECK(network_list->networks[i].name);
WifiAccessPoint ap;
ap.mac_address = SafeString(network_list->networks[i].address);
ap.name = SafeString(network_list->networks[i].name);
ap.timestamp = now -
base::TimeDelta::FromSeconds(network_list->networks[i].age_seconds);
ap.signal_strength = network_list->networks[i].strength;
ap.channel = network_list->networks[i].channel;
result->push_back(ap);
}
FreeDeviceNetworkList(network_list);
return true;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_54
|
virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) {
return false;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_55
|
WifiNetwork* GetWifiNetworkByName(const std::string& name) {
for (size_t i = 0; i < wifi_networks_.size(); ++i) {
if (wifi_networks_[i]->name().compare(name) == 0) {
return wifi_networks_[i];
}
}
return NULL;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_56
|
template<typename T> T GetWirelessNetworkByPath(
std::vector<T>& networks, const std::string& path) {
typedef typename std::vector<T>::iterator iter_t;
iter_t iter = std::find_if(networks.begin(), networks.end(),
WirelessNetwork::ServicePathEq(path));
return (iter != networks.end()) ? *iter : NULL;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_57
|
template<typename T> const T GetWirelessNetworkByPath(
const std::vector<T>& networks, const std::string& path) const {
typedef typename std::vector<T>::const_iterator iter_t;
iter_t iter = std::find_if(networks.begin(), networks.end(),
WirelessNetwork::ServicePathEq(path));
return (iter != networks.end()) ? *iter : NULL;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_58
|
const std::string& IPAddress() const {
const Network* active = active_network();
if (active != NULL)
return active->ip_address();
if (ethernet_)
return ethernet_->ip_address();
static std::string null_address("0.0.0.0");
return null_address;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_59
|
const std::string& IPAddress() const { return ip_address_; }
The vulnerability label is: Non-vulnerable
|
primevul_data_60
|
void Init() {
VLOG(1) << "Getting initial CrOS network info.";
UpdateSystemInfo();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_61
|
void InitTestData() {
ethernet_ = new EthernetNetwork();
ethernet_->set_connected(true);
ethernet_->set_service_path("eth1");
STLDeleteElements(&wifi_networks_);
wifi_networks_.clear();
WifiNetwork* wifi1 = new WifiNetwork();
wifi1->set_service_path("fw1");
wifi1->set_name("Fake Wifi 1");
wifi1->set_strength(90);
wifi1->set_connected(false);
wifi1->set_encryption(SECURITY_NONE);
wifi_networks_.push_back(wifi1);
WifiNetwork* wifi2 = new WifiNetwork();
wifi2->set_service_path("fw2");
wifi2->set_name("Fake Wifi 2");
wifi2->set_strength(70);
wifi2->set_connected(true);
wifi2->set_encryption(SECURITY_WEP);
wifi_networks_.push_back(wifi2);
WifiNetwork* wifi3 = new WifiNetwork();
wifi3->set_service_path("fw3");
wifi3->set_name("Fake Wifi 3");
wifi3->set_strength(50);
wifi3->set_connected(false);
wifi3->set_encryption(SECURITY_WEP);
wifi_networks_.push_back(wifi3);
wifi_ = wifi2;
STLDeleteElements(&cellular_networks_);
cellular_networks_.clear();
CellularNetwork* cellular1 = new CellularNetwork();
cellular1->set_service_path("fc1");
cellular1->set_name("Fake Cellular 1");
cellular1->set_strength(70);
cellular1->set_connected(true);
cellular1->set_activation_state(ACTIVATION_STATE_PARTIALLY_ACTIVATED);
cellular1->set_payment_url(std::string("http://www.google.com"));
cellular_networks_.push_back(cellular1);
cellular_ = cellular1;
remembered_wifi_networks_.clear();
remembered_wifi_networks_.push_back(new WifiNetwork(*wifi2));
int devices = (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) |
(1 << TYPE_CELLULAR);
available_devices_ = devices;
enabled_devices_ = devices;
connected_devices_ = devices;
offline_mode_ = false;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_62
|
bool WifiNetwork::IsCertificateLoaded() const {
static const std::string settings_string("SETTINGS:");
static const std::string pkcs11_key("key_id");
if (cert_path_.find(settings_string) == 0) {
std::string::size_type idx = cert_path_.find(pkcs11_key);
if (idx != std::string::npos)
idx = cert_path_.find_first_not_of(kWhitespaceASCII,
idx + pkcs11_key.length());
if (idx != std::string::npos && cert_path_[idx] == '=')
return true;
}
return false;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_63
|
Network::Network(const Network& network) {
service_path_ = network.service_path();
device_path_ = network.device_path();
ip_address_ = network.ip_address();
type_ = network.type();
state_ = network.state();
error_ = network.error();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_64
|
Network::Network(const ServiceInfo* service) {
type_ = service->type;
state_ = service->state;
error_ = service->error;
service_path_ = SafeString(service->service_path);
device_path_ = SafeString(service->device_path);
is_active_ = service->is_active;
ip_address_.clear();
if (EnsureCrosLoaded() && connected() && service->device_path) {
IPConfigStatus* ipconfig_status = ListIPConfigs(service->device_path);
if (ipconfig_status) {
for (int i = 0; i < ipconfig_status->size; i++) {
IPConfig ipconfig = ipconfig_status->ips[i];
if (strlen(ipconfig.address) > 0)
ip_address_ = ipconfig.address;
}
FreeIPConfigStatus(ipconfig_status);
}
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_65
|
NetworkLibraryImpl()
: network_manager_monitor_(NULL),
data_plan_monitor_(NULL),
ethernet_(NULL),
wifi_(NULL),
cellular_(NULL),
available_devices_(0),
enabled_devices_(0),
connected_devices_(0),
offline_mode_(false) {
if (EnsureCrosLoaded()) {
Init();
network_manager_monitor_ =
MonitorNetworkManager(&NetworkManagerStatusChangedHandler,
this);
data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler,
this);
} else {
InitTestData();
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_66
|
NetworkObserverList(NetworkLibraryImpl* library,
const std::string& service_path) {
network_monitor_ = MonitorNetworkService(&NetworkStatusChangedHandler,
service_path.c_str(),
library);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_67
|
static void NetworkStatusChangedHandler(void* object,
const char* path,
const char* key,
const Value* value) {
NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
DCHECK(networklib);
networklib->UpdateNetworkStatus(path, key, value);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_68
|
void NotifyNetworkChanged(Network* network) {
DCHECK(network);
NetworkObserverMap::const_iterator iter = network_observers_.find(
network->service_path());
if (iter != network_observers_.end()) {
FOR_EACH_OBSERVER(NetworkObserver,
*(iter->second),
OnNetworkChanged(this, network));
} else {
NOTREACHED() <<
"There weren't supposed to be any property change observers of " <<
network->service_path();
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_69
|
static ActivationState ParseActivationState(
const std::string& activation_state) {
if (activation_state == kActivationStateActivated)
return ACTIVATION_STATE_ACTIVATED;
if (activation_state == kActivationStateActivating)
return ACTIVATION_STATE_ACTIVATING;
if (activation_state == kActivationStateNotActivated)
return ACTIVATION_STATE_NOT_ACTIVATED;
if (activation_state == kActivationStateUnknown)
return ACTIVATION_STATE_UNKNOWN;
if (activation_state == kActivationStatePartiallyActivated)
return ACTIVATION_STATE_PARTIALLY_ACTIVATED;
return ACTIVATION_STATE_UNKNOWN;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_70
|
static NetworkTechnology ParseNetworkTechnology(
const std::string& technology) {
if (technology == kNetworkTechnology1Xrtt)
return NETWORK_TECHNOLOGY_1XRTT;
if (technology == kNetworkTechnologyEvdo)
return NETWORK_TECHNOLOGY_EVDO;
if (technology == kNetworkTechnologyGprs)
return NETWORK_TECHNOLOGY_GPRS;
if (technology == kNetworkTechnologyEdge)
return NETWORK_TECHNOLOGY_EDGE;
if (technology == kNetworkTechnologyUmts)
return NETWORK_TECHNOLOGY_UMTS;
if (technology == kNetworkTechnologyHspa)
return NETWORK_TECHNOLOGY_HSPA;
if (technology == kNetworkTechnologyHspaPlus)
return NETWORK_TECHNOLOGY_HSPA_PLUS;
if (technology == kNetworkTechnologyLte)
return NETWORK_TECHNOLOGY_LTE;
if (technology == kNetworkTechnologyLteAdvanced)
return NETWORK_TECHNOLOGY_LTE_ADVANCED;
return NETWORK_TECHNOLOGY_UNKNOWN;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_71
|
static NetworkRoamingState ParseRoamingState(
const std::string& roaming_state) {
if (roaming_state == kRoamingStateHome)
return ROAMING_STATE_HOME;
if (roaming_state == kRoamingStateRoaming)
return ROAMING_STATE_ROAMING;
if (roaming_state == kRoamingStateUnknown)
return ROAMING_STATE_UNKNOWN;
return ROAMING_STATE_UNKNOWN;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_72
|
static ConnectionState ParseState(const std::string& state) {
if (state == kStateIdle)
return STATE_IDLE;
if (state == kStateCarrier)
return STATE_CARRIER;
if (state == kStateAssociation)
return STATE_ASSOCIATION;
if (state == kStateConfiguration)
return STATE_CONFIGURATION;
if (state == kStateReady)
return STATE_READY;
if (state == kStateDisconnect)
return STATE_DISCONNECT;
if (state == kStateFailure)
return STATE_FAILURE;
if (state == kStateActivationFailure)
return STATE_ACTIVATION_FAILURE;
return STATE_UNKNOWN;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_73
|
static void ParseSystem(SystemInfo* system,
EthernetNetwork** ethernet,
WifiNetworkVector* wifi_networks,
CellularNetworkVector* cellular_networks,
WifiNetworkVector* remembered_wifi_networks) {
DVLOG(1) << "ParseSystem:";
DCHECK(!(*ethernet));
for (int i = 0; i < system->service_size; i++) {
const ServiceInfo* service = system->GetServiceInfo(i);
DVLOG(1) << " (" << service->type << ") " << service->name
<< " mode=" << service->mode
<< " state=" << service->state
<< " sec=" << service->security
<< " req=" << service->passphrase_required
<< " pass=" << service->passphrase
<< " id=" << service->identity
<< " certpath=" << service->cert_path
<< " str=" << service->strength
<< " fav=" << service->favorite
<< " auto=" << service->auto_connect
<< " is_active=" << service->is_active
<< " error=" << service->error;
if (service->type == TYPE_ETHERNET)
(*ethernet) = new EthernetNetwork(service);
else if (service->type == TYPE_WIFI) {
wifi_networks->push_back(new WifiNetwork(service));
} else if (service->type == TYPE_CELLULAR) {
cellular_networks->push_back(new CellularNetwork(service));
}
}
if (!(*ethernet))
(*ethernet) = new EthernetNetwork();
DVLOG(1) << "Remembered networks:";
for (int i = 0; i < system->remembered_service_size; i++) {
const ServiceInfo* service = system->GetRememberedServiceInfo(i);
if (service->auto_connect) {
DVLOG(1) << " (" << service->type << ") " << service->name
<< " mode=" << service->mode
<< " sec=" << service->security
<< " pass=" << service->passphrase
<< " id=" << service->identity
<< " certpath=" << service->cert_path
<< " auto=" << service->auto_connect;
if (service->type == TYPE_WIFI) {
remembered_wifi_networks->push_back(new WifiNetwork(service));
}
}
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_74
|
virtual void RefreshCellularDataPlans(const CellularNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
RequestCellularDataPlanUpdate(network->service_path().c_str());
}
The vulnerability label is: Non-vulnerable
|
primevul_data_75
|
virtual void RefreshCellularDataPlans(const CellularNetwork* network) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_76
|
virtual void RemoveCellularDataPlanObserver(
CellularDataPlanObserver* observer) {
data_plan_observers_.RemoveObserver(observer);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_77
|
virtual void RemoveCellularDataPlanObserver(
CellularDataPlanObserver* observer) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_78
|
virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {
network_manager_observers_.RemoveObserver(observer);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_79
|
virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_80
|
virtual void RemoveNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {
DCHECK(observer);
DCHECK(service_path.size());
NetworkObserverMap::iterator map_iter =
network_observers_.find(service_path);
if (map_iter != network_observers_.end()) {
map_iter->second->RemoveObserver(observer);
if (!map_iter->second->size()) {
delete map_iter->second;
network_observers_.erase(map_iter++);
}
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_81
|
virtual void RemoveNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_82
|
virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {
DCHECK(observer);
NetworkObserverMap::iterator map_iter = network_observers_.begin();
while (map_iter != network_observers_.end()) {
map_iter->second->RemoveObserver(observer);
if (!map_iter->second->size()) {
delete map_iter->second;
network_observers_.erase(map_iter++);
} else {
++map_iter;
}
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_83
|
virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_84
|
virtual void RequestWifiScan() {
if (EnsureCrosLoaded()) {
RequestScan(TYPE_WIFI);
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_85
|
virtual void RequestWifiScan() {}
The vulnerability label is: Non-vulnerable
|
primevul_data_86
|
static std::string SafeString(const char* s) {
return s ? std::string(s) : std::string();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_87
|
virtual void SaveCellularNetwork(const CellularNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
SetAutoConnect(network->service_path().c_str(), network->auto_connect());
}
The vulnerability label is: Non-vulnerable
|
primevul_data_88
|
virtual void SaveCellularNetwork(const CellularNetwork* network) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_89
|
virtual void SaveWifiNetwork(const WifiNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
SetPassphrase(
network->service_path().c_str(), network->passphrase().c_str());
SetIdentity(network->service_path().c_str(),
network->identity().c_str());
SetCertPath(network->service_path().c_str(),
network->cert_path().c_str());
SetAutoConnect(network->service_path().c_str(), network->auto_connect());
}
The vulnerability label is: Non-vulnerable
|
primevul_data_90
|
virtual void SaveWifiNetwork(const WifiNetwork* network) {}
The vulnerability label is: Non-vulnerable
|
primevul_data_91
|
bool CellularNetwork::StartActivation() const {
if (!EnsureCrosLoaded())
return false;
return ActivateCellularModem(service_path_.c_str(), NULL);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_92
|
static std::string ToHtmlTableHeader(Network* network) {
std::string str;
if (network->type() == TYPE_WIFI || network->type() == TYPE_CELLULAR) {
str += WrapWithTH("Name") + WrapWithTH("Auto-Connect") +
WrapWithTH("Strength");
if (network->type() == TYPE_WIFI)
str += WrapWithTH("Encryption") + WrapWithTH("Passphrase") +
WrapWithTH("Identity") + WrapWithTH("Certificate");
}
str += WrapWithTH("State") + WrapWithTH("Error") + WrapWithTH("IP Address");
return str;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_93
|
static std::string ToHtmlTableRow(Network* network) {
std::string str;
if (network->type() == TYPE_WIFI || network->type() == TYPE_CELLULAR) {
WirelessNetwork* wireless = static_cast<WirelessNetwork*>(network);
str += WrapWithTD(wireless->name()) +
WrapWithTD(base::IntToString(wireless->auto_connect())) +
WrapWithTD(base::IntToString(wireless->strength()));
if (network->type() == TYPE_WIFI) {
WifiNetwork* wifi = static_cast<WifiNetwork*>(network);
str += WrapWithTD(wifi->GetEncryptionString()) +
WrapWithTD(std::string(wifi->passphrase().length(), '*')) +
WrapWithTD(wifi->identity()) + WrapWithTD(wifi->cert_path());
}
}
str += WrapWithTD(network->GetStateString()) +
WrapWithTD(network->failed() ? network->GetErrorString() : "") +
WrapWithTD(network->ip_address());
return str;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_94
|
void UpdateCellularDataPlan(const CellularDataPlanList* data_plans) {
DCHECK(cellular_);
cellular_->SetDataPlans(data_plans);
NotifyCellularDataPlanChanged();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_95
|
void UpdateNetworkStatus(const char* path,
const char* key,
const Value* value) {
if (key == NULL || value == NULL)
return;
if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
NewRunnableMethod(this,
&NetworkLibraryImpl::UpdateNetworkStatus,
path, key, value));
return;
}
bool boolval = false;
int intval = 0;
std::string stringval;
Network* network;
if (ethernet_->service_path() == path) {
network = ethernet_;
} else {
CellularNetwork* cellular =
GetWirelessNetworkByPath(cellular_networks_, path);
WifiNetwork* wifi =
GetWirelessNetworkByPath(wifi_networks_, path);
if (cellular == NULL && wifi == NULL)
return;
WirelessNetwork* wireless;
if (wifi != NULL)
wireless = static_cast<WirelessNetwork*>(wifi);
else
wireless = static_cast<WirelessNetwork*>(cellular);
if (strcmp(key, kSignalStrengthProperty) == 0) {
if (value->GetAsInteger(&intval))
wireless->set_strength(intval);
} else if (cellular != NULL) {
if (strcmp(key, kRestrictedPoolProperty) == 0) {
if (value->GetAsBoolean(&boolval))
cellular->set_restricted_pool(boolval);
} else if (strcmp(key, kActivationStateProperty) == 0) {
if (value->GetAsString(&stringval))
cellular->set_activation_state(ParseActivationState(stringval));
} else if (strcmp(key, kPaymentURLProperty) == 0) {
if (value->GetAsString(&stringval))
cellular->set_payment_url(stringval);
} else if (strcmp(key, kNetworkTechnologyProperty) == 0) {
if (value->GetAsString(&stringval))
cellular->set_network_technology(
ParseNetworkTechnology(stringval));
} else if (strcmp(key, kRoamingStateProperty) == 0) {
if (value->GetAsString(&stringval))
cellular->set_roaming_state(ParseRoamingState(stringval));
}
}
network = wireless;
}
if (strcmp(key, kIsActiveProperty) == 0) {
if (value->GetAsBoolean(&boolval))
network->set_active(boolval);
} else if (strcmp(key, kStateProperty) == 0) {
if (value->GetAsString(&stringval))
network->set_state(ParseState(stringval));
}
NotifyNetworkChanged(network);
}
The vulnerability label is: Non-vulnerable
|
primevul_data_96
|
void UpdateSystemInfo() {
if (EnsureCrosLoaded()) {
UpdateNetworkManagerStatus();
}
}
The vulnerability label is: Non-vulnerable
|
primevul_data_97
|
WifiNetwork::WifiNetwork()
: WirelessNetwork(),
encryption_(SECURITY_NONE) {
type_ = TYPE_WIFI;
}
The vulnerability label is: Non-vulnerable
|
primevul_data_98
|
WifiNetwork::WifiNetwork(const WifiNetwork& network)
: WirelessNetwork(network) {
encryption_ = network.encryption();
passphrase_ = network.passphrase();
identity_ = network.identity();
cert_path_ = network.cert_path();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_99
|
WirelessNetwork::WirelessNetwork(const WirelessNetwork& network)
: Network(network) {
name_ = network.name();
strength_ = network.strength();
auto_connect_ = network.auto_connect();
favorite_ = network.favorite();
}
The vulnerability label is: Non-vulnerable
|
primevul_data_100
|
WirelessNetwork::WirelessNetwork(const ServiceInfo* service)
: Network(service) {
name_ = SafeString(service->name);
strength_ = service->strength;
auto_connect_ = service->auto_connect;
favorite_ = service->favorite;
}
The vulnerability label is: Non-vulnerable
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 1