status_t
BAbstractSocket::Connect(const BNetworkAddress& peer, int type,
bigtime_t timeout)
{
Disconnect();
fInitStatus = _OpenIfNeeded(peer.Family(), type);
if (fInitStatus == B_OK)
fInitStatus = SetTimeout(timeout);
if (fInitStatus == B_OK && !IsBound()) {
BNetworkAddress local;
local.SetToWildcard(peer.Family());
fInitStatus = Bind(local);
}
if (fInitStatus != B_OK)
return fInitStatus;
BNetworkAddress normalized = peer;
if (connect(fSocket, normalized, normalized.Length()) != 0) {
TRACE("%p: connecting to %s: %s\n", this,
normalized.ToString().c_str(), strerror(errno));
return fInitStatus = errno;
}
fIsConnected = true;
fPeer = normalized;
_UpdateLocalAddress();
TRACE("%p: connected to %s (local %s)\n", this, peer.ToString().c_str(),
fLocal.ToString().c_str());
return fInitStatus = B_OK;
}
void
BSocket::_SetTo(int fd, const BNetworkAddress& local,
const BNetworkAddress& peer)
{
Disconnect();
fInitStatus = B_OK;
fSocket = fd;
fLocal = local;
fPeer = peer;
TRACE("%p: accepted from %s to %s\n", this, local.ToString().c_str(),
peer.ToString().c_str());
}
status_t
SocketConnection::Connect(const char* server, uint32 port)
{
if (fSocket >= 0)
Disconnect();
TRACE("SocketConnection to server %s:%i\n", server, (int)port);
BNetworkAddress address;
status_t status = address.SetTo(server, port);
if (status != B_OK) {
TRACE("%s: Address Error: %s\n", __func__, strerror(status));
return status;
}
TRACE("Server resolves to %s\n", address.ToString().String());
fSocket = socket(address.Family(), SOCK_STREAM, 0);
if (fSocket < 0) {
TRACE("%s: Socket Error: %s\n", __func__, strerror(errno));
return errno;
}
int result = connect(fSocket, address, address.Length());
if (result < 0) {
TRACE("%s: Connect Error: %s\n", __func__, strerror(errno));
close(fSocket);
return errno;
}
TRACE("SocketConnection: connected\n");
return B_OK;
}
void
Settings::ReadConfiguration()
{
BNetworkInterface interface(fName);
BNetworkAddress hardwareAddress;
if (interface.GetHardwareAddress(hardwareAddress) != B_OK)
return;
fHardwareAddress = hardwareAddress.ToString();
BNetworkInterfaceAddress address;
// TODO: We only get the first address
if (interface.GetAddressAt(0, address) != B_OK)
return;
fIP = address.Address().ToString();
fNetmask = address.Mask().ToString();
int family = AF_INET;
if (address.Address().Family() != AF_UNSPEC)
family = address.Address().Family();
BNetworkAddress gatewayAddress;
if (interface.GetDefaultRoute(family, gatewayAddress) != B_OK)
return;
fGateway = gatewayAddress.ToString();
uint32 flags = interface.Flags();
fAuto = (flags & (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
fDisabled = (flags & IFF_UP) == 0;
// 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];
}
}
const char*
NetworkSettings::HardwareAddress()
{
BNetworkAddress macAddress;
if (fNetworkInterface->GetHardwareAddress(macAddress) == B_OK)
return macAddress.ToString();
return NULL;
}
bool
list_interface(const char* name)
{
printf("%s", name);
size_t length = strlen(name);
if (length < 8)
putchar('\t');
else
printf("\n\t");
// get link level interface for this interface
BNetworkInterface interface(name);
if (!interface.Exists()) {
printf("Interface not found!\n");
return false;
}
BNetworkAddress linkAddress;
status_t status = interface.GetHardwareAddress(linkAddress);
if (status == B_OK) {
const char *type = "unknown";
switch (linkAddress.LinkLevelType()) {
case IFT_ETHER:
type = "Ethernet";
break;
case IFT_LOOP:
type = "Local Loopback";
break;
case IFT_MODEM:
type = "Modem";
break;
}
BString address = linkAddress.ToString();
if (address.Length() == 0)
address = "none";
printf("Hardware type: %s, Address: %s\n", type, address.String());
} else
printf("No link level: %s\n", strerror(status));
int media = interface.Media();
if ((media & IFM_ACTIVE) != 0) {
// dump media state in case we're linked
const char* type = "unknown";
bool show = false;
for (int32 i = 0; kMediaTypes[i].type >= 0; i++) {
// loopback don't really have a media anyway
if (IFM_TYPE(media) == 0/*IFT_LOOP*/)
break;
// only check for generic or correct subtypes
if (kMediaTypes[i].type
&& kMediaTypes[i].type != IFM_TYPE(media))
continue;
for (int32 j = 0; kMediaTypes[i].subtypes[j].subtype >= 0; j++) {
if (kMediaTypes[i].subtypes[j].subtype == IFM_SUBTYPE(media)) {
// found a match
type = kMediaTypes[i].subtypes[j].pretty;
show = true;
break;
}
}
}
if (show)
printf("\tMedia type: %s\n", type);
}
// Print associated wireless network(s)
BNetworkDevice device(name);
if (device.IsWireless()) {
wireless_network network;
bool first = true;
uint32 cookie = 0;
while (device.GetNextAssociatedNetwork(cookie, network) == B_OK) {
if (first) {
printf("\tNetwork: ");
first = false;
} else
printf("\t\t");
printf("%s, Address: %s, %s", network.name,
network.address.ToString().String(),
get_authentication_mode(network.authentication_mode,
network.flags));
const char* keyMode = get_key_mode(network.key_mode);
if (keyMode != NULL)
printf(", %s/%s", keyMode, get_cipher(network.cipher));
putchar('\n');
}
}
uint32 flags = interface.Flags();
list_interface_addresses(interface, flags);
// Print MTU, metric, flags
printf("\tMTU: %" B_PRId32 ", Metric: %" B_PRId32, interface.MTU(),
interface.Metric());
if (flags != 0) {
const struct {
int value;
const char *name;
} kFlags[] = {
{IFF_UP, "up"},
{IFF_NOARP, "noarp"},
{IFF_BROADCAST, "broadcast"},
{IFF_LOOPBACK, "loopback"},
{IFF_PROMISC, "promiscuous"},
{IFF_ALLMULTI, "allmulti"},
{IFF_AUTOUP, "autoup"},
{IFF_LINK, "link"},
{IFF_AUTO_CONFIGURED, "auto-configured"},
{IFF_CONFIGURING, "configuring"},
};
bool first = true;
for (uint32 i = 0; i < sizeof(kFlags) / sizeof(kFlags[0]); i++) {
if ((flags & kFlags[i].value) != 0) {
if (first) {
printf(",");
first = false;
}
putchar(' ');
printf(kFlags[i].name);
}
}
}
putchar('\n');
// Print statistics
ifreq_stats stats;
if (interface.GetStats(stats) == B_OK) {
printf("\tReceive: %d packets, %d errors, %Ld bytes, %d mcasts, %d "
"dropped\n", stats.receive.packets, stats.receive.errors,
stats.receive.bytes, stats.receive.multicast_packets,
stats.receive.dropped);
printf("\tTransmit: %d packets, %d errors, %Ld bytes, %d mcasts, %d "
"dropped\n", stats.send.packets, stats.send.errors,
stats.send.bytes, stats.send.multicast_packets, stats.send.dropped);
printf("\tCollisions: %d\n", stats.collisions);
}
putchar('\n');
return true;
}
void
list_routes(int socket, const char *interfaceName, route_entry &route)
{
// get a list of all routes
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(socket, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
void *buffer = malloc(size);
if (buffer == NULL) {
fprintf(stderr, "%s: Out of memory.\n", kProgramName);
return;
}
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(socket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
return;
ifreq *interface = (ifreq*)buffer;
ifreq *end = (ifreq*)((uint8*)buffer + size);
// find family (we use the family of the first address as this is
// called on a socket for a single family)
const address_family *family = NULL;
for (int32 i = 0; kFamilies[i].family >= 0; i++) {
if (interface->ifr_route.destination->sa_family
== kFamilies[i].family) {
family = &kFamilies[i];
break;
}
}
int addressLength = family->maxAddressLength;
printf("%s routing table:\n", family->name);
if (family->preferredPrefixFormat == PREFIX_PREFER_NETMASK) {
printf("%*s %*s %*s Flags Interface\n", addressLength, "Destination",
addressLength, "Netmask", addressLength, "Gateway");
} else {
printf("%*s %*s Flags Interface\n", addressLength, "Destination",
addressLength, "Gateway");
}
while (interface < end) {
route_entry& route = interface->ifr_route;
// apply filters
if (interfaceName == NULL
|| !strcmp(interfaceName, interface->ifr_name)) {
if (family != NULL) {
BNetworkAddress destination(*route.destination);
printf("%*s", addressLength, destination.ToString().String());
if (route.mask != NULL) {
BNetworkAddress mask;
mask.SetTo(*route.mask);
if (family->preferredPrefixFormat
== PREFIX_PREFER_NETMASK) {
printf(" %*s ", addressLength,
mask.ToString().String());
} else {
printf("/%-3zd ", mask.PrefixLength());
}
} else {
if (family->preferredPrefixFormat
== PREFIX_PREFER_NETMASK) {
printf(" %*s ", addressLength, "-");
} else
printf(" ");
}
if ((route.flags & RTF_GATEWAY) != 0) {
BNetworkAddress gateway;
if (route.gateway != NULL)
gateway.SetTo(*route.gateway);
printf("%*s ", addressLength, gateway.ToString().String());
} else
printf("%*s ", family->maxAddressLength, "-");
} else
printf("unknown family ");
if (route.flags != 0) {
const struct {
int value;
const char *name;
} kFlags[] = {
{RTF_DEFAULT, "D"},
{RTF_REJECT, "R"},
{RTF_HOST, "H"},
{RTF_LOCAL, "L"},
{RTF_DYNAMIC, "D"},
{RTF_MODIFIED, "M"},
};
for (uint32 i = 0; i < sizeof(kFlags) / sizeof(kFlags[0]);
i++) {
if ((route.flags & kFlags[i].value) != 0) {
printf(kFlags[i].name);
} else
putchar('-');
}
printf(" ");
} else
printf("------ ");
printf("%s", interface->ifr_name);
putchar('\n');
}
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);
}
putchar('\n');
free(buffer);
}
