bool
ReadMessageDriverSettings(const char *name, BMessage *message)
{
if(!name || !message)
return false;
void *handle = load_driver_settings(name);
if(!handle)
return false;
const driver_settings *settings = get_driver_settings(handle);
if(!settings) {
unload_driver_settings(handle);
return false;
}
for(int32 index = 0; index < settings->parameter_count; index++) {
BMessage parameter;
AddParameter(&settings->parameters[index], ¶meter);
message->AddMessage(MDSU_PARAMETERS, ¶meter);
}
unload_driver_settings(handle);
return true;
}
status_t
PackageSettings::Load(dev_t mountPointDeviceID, ino_t mountPointNodeID,
PackageFSMountType mountType)
{
status_t error = fPackageItems.Init();
if (error != B_OK)
RETURN_ERROR(error);
// get the mount point relative settings file path
const char* settingsFilePath = mountType == PACKAGE_FS_MOUNT_TYPE_HOME
? kUserSettingsGlobalDirectory "/packages"
+ strlen(kUserConfigDirectory) + 1
: kSystemSettingsDirectory "/packages" + strlen(kSystemDirectory) + 1;
// get an absolute path
KPath path;
if (path.InitCheck() != B_OK)
RETURN_ERROR(path.InitCheck());
error = vfs_entry_ref_to_path(mountPointDeviceID, mountPointNodeID,
NULL, true, path.LockBuffer(), path.BufferSize());
if (error != B_OK)
return error;
path.UnlockBuffer();
error = path.Append(settingsFilePath);
if (error != B_OK)
return error;
// load the driver settings
void* settingsHandle = load_driver_settings(path.Path());
if (settingsHandle == NULL)
return B_ENTRY_NOT_FOUND;
CObjectDeleter<void, status_t> settingsDeleter(settingsHandle,
&unload_driver_settings);
const driver_settings* settings = get_driver_settings(settingsHandle);
for (int i = 0; i < settings->parameter_count; i++) {
const driver_parameter& parameter = settings->parameters[i];
if (strcmp(parameter.name, "Package") != 0
|| parameter.value_count < 1) {
continue;
}
error = _AddPackageSettingsItem(parameter);
// abort only in case of serious issues (memory shortage)
if (error == B_NO_MEMORY)
return error;
}
return B_OK;
}
// Load
status_t
DriverSettings::Load(const char* driverName)
{
Unset();
fSettingsHandle = load_driver_settings(driverName);
if (!fSettingsHandle)
return B_ENTRY_NOT_FOUND;
fSettings = get_driver_settings(fSettingsHandle);
if (!fSettings) {
Unset();
return B_ERROR;
}
return B_OK;
}
/*static*/ PackageSettingsItem*
PackageSettingsItem::Load(::Directory* systemDirectory, const char* name)
{
// open the driver settings file
const char* settingsFilePath
= kSystemSettingsDirectory "/packages" + strlen(kSystemDirectory) + 1;
int fd = open_from(systemDirectory, settingsFilePath, B_READ_ONLY, 0);
if (fd < 0)
return NULL;
FileDescriptorCloser fdCloser(fd);
// load the driver settings
void* settingsHandle = load_driver_settings_file(fd);
if (settingsHandle == NULL)
return NULL;
CObjectDeleter<void, status_t> settingsDeleter(settingsHandle,
&unload_driver_settings);
const driver_settings* settings = get_driver_settings(settingsHandle);
for (int i = 0; i < settings->parameter_count; i++) {
const driver_parameter& parameter = settings->parameters[i];
if (strcmp(parameter.name, "Package") != 0
|| parameter.value_count < 1
|| strcmp(parameter.values[0], name) != 0) {
continue;
}
PackageSettingsItem* settingsItem
= new(std::nothrow) PackageSettingsItem;
if (settingsItem == NULL || settingsItem->Init(parameter) != B_OK) {
delete settingsItem;
return NULL;
}
return settingsItem;
}
return NULL;
}
/*! ReadConfiguration pulls the current interface settings
from the interfaces via BNetworkInterface and friends
and populates this classes private settings BAddresses
with them.
*/
void
NetworkSettings::ReadConfiguration()
{
fDisabled = (fNetworkInterface->Flags() & IFF_UP) == 0;
for (int index = 0; index < MAX_PROTOCOLS; index++) {
int inet_id = fProtocols[index].inet_id;
if (fProtocols[index].present) {
// --- Obtain IP Addresses
int32 zeroAddr = fNetworkInterface->FindFirstAddress(inet_id);
if (zeroAddr >= 0) {
fNetworkInterface->GetAddressAt(zeroAddr,
fInterfaceAddressMap[inet_id]);
fAddress[inet_id].SetTo(
fInterfaceAddressMap[inet_id].Address());
fNetmask[inet_id].SetTo(
fInterfaceAddressMap[inet_id].Mask());
}
// --- Obtain gateway
// TODO : maybe in the future no ioctls?
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
// Populate config with size of routing table
if (ioctl(fProtocols[index].socket_id, SIOCGRTSIZE,
&config, sizeof(config)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
// Malloc a buffer the size of the routing table
void* buffer = malloc(size);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(fProtocols[index].socket_id, SIOCGRTTABLE,
&config, sizeof(config)) < 0)
return;
ifreq* interface = (ifreq*)buffer;
ifreq* end = (ifreq*)((uint8*)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if ((route.flags & RTF_GATEWAY) != 0) {
if (inet_id == AF_INET) {
char addressOut[INET_ADDRSTRLEN];
sockaddr_in* socketAddr
= (sockaddr_in*)route.gateway;
inet_ntop(inet_id, &socketAddr->sin_addr,
addressOut, INET_ADDRSTRLEN);
fGateway[inet_id].SetTo(addressOut);
} else if (inet_id == AF_INET6) {
char addressOut[INET6_ADDRSTRLEN];
sockaddr_in6* socketAddr
= (sockaddr_in6*)route.gateway;
inet_ntop(inet_id, &socketAddr->sin6_addr,
addressOut, INET6_ADDRSTRLEN);
fGateway[inet_id].SetTo(addressOut);
} else {
printf("Cannot pull routes for unknown protocol: %d\n",
inet_id);
fGateway[inet_id].SetTo("");
}
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
// --- Obtain selfconfiguration options
// TODO : This needs to be determined by protocol flags
// AutoConfiguration on the IP level doesn't exist yet
// ( fInterfaceAddressMap[AF_INET].Flags() )
if (fProtocols[index].socket_id >= 0) {
fAutoConfigure[inet_id] = (fNetworkInterface->Flags()
& (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
}
}
}
// Read wireless network from interfaces
fWirelessNetwork.SetTo(NULL);
BPath path;
find_directory(B_SYSTEM_SETTINGS_DIRECTORY, &path);
path.Append("network");
path.Append("interfaces");
void* handle = load_driver_settings(path.Path());
if (handle != NULL) {
const driver_settings* settings = get_driver_settings(handle);
if (settings != NULL) {
for (int32 i = 0; i < settings->parameter_count; i++) {
driver_parameter& top = settings->parameters[i];
if (!strcmp(top.name, "interface")) {
// The name of the interface can either be the value of
// the "interface" parameter, or a separate "name" parameter
const char* name = NULL;
if (top.value_count > 0) {
name = top.values[0];
if (fName != name)
continue;
}
// search "network" parameter
for (int32 j = 0; j < top.parameter_count; j++) {
driver_parameter& sub = top.parameters[j];
if (name == NULL && !strcmp(sub.name, "name")
&& sub.value_count > 0) {
name = sub.values[0];
if (fName != sub.values[0])
break;
}
if (!strcmp(sub.name, "network")
&& sub.value_count > 0) {
fWirelessNetwork.SetTo(sub.values[0]);
break;
}
}
// We found our interface
if (fName == name)
break;
}
}
}
unload_driver_settings(handle);
}
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
