1

/* $Id$ */

     2

     3

/** @file host.cpp Functions related to getting host specific data (IPs). */

     4

     5

#ifdef ENABLE_NETWORK

     6

     7

#include "../../stdafx.h"

     8

#include "../../debug.h"

     9

#include "os_abstraction.h"

    10

    11

/**

    12

 * Internal implementation for finding the broadcast IPs.

    13

 * This function is implemented multiple times for multiple targets.

    14

 * @param broadcast the list of broadcasts to write into.

    15

 * @param limit     the maximum number of items to add.

    16

 */

    17

static int NetworkFindBroadcastIPsInternal(uint32 *broadcast, int limit);

    18

    19

#if defined(PSP)

    20

static int NetworkFindBroadcastIPsInternal(uint32 *broadcast, int limit) // PSP implementation

    21

{

    22

	return 0;

    23

}

    24

    25

#elif defined(BEOS_NET_SERVER) /* doesn't have neither getifaddrs or net/if.h */

    26

/* Based on Andrew Bachmann's netstat+.c. Big thanks to him! */

    27

int _netstat(int fd, char **output, int verbose);

    28

    29

int seek_past_header(char **pos, const char *header)

    30

{

    31

	char *new_pos = strstr(*pos, header);

    32

	if (new_pos == 0) {

    33

		return B_ERROR;

    34

	}

    35

	*pos += strlen(header) + new_pos - *pos + 1;

    36

	return B_OK;

    37

}

    38

    39

static int NetworkFindBroadcastIPsInternal(uint32 *broadcast, int limit) // BEOS implementation

    40

{

    41

	int sock = socket(AF_INET, SOCK_DGRAM, 0);

    42

    43

	if (sock < 0) {

    44

		DEBUG(net, 0, "[core] error creating socket");

    45

		return;

    46

	}

    47

    48

	char *output_pointer = NULL;

    49

	int output_length = _netstat(sock, &output_pointer, 1);

    50

	if (output_length < 0) {

    51

		DEBUG(net, 0, "[core] error running _netstat");

    52

		return;

    53

	}

    54

    55

	int index;

    56

	char **output = &output_pointer;

    57

	if (seek_past_header(output, "IP Interfaces:") == B_OK) {

    58

		while (index != limit) {

    59

    60

			uint32 n, fields, read;

    61

			uint8 i1, i2, i3, i4, j1, j2, j3, j4;

    62

			struct in_addr inaddr;

    63

			uint32 ip;

    64

			uint32 netmask;

    65

    66

			fields = sscanf(*output, "%u: %hhu.%hhu.%hhu.%hhu, netmask %hhu.%hhu.%hhu.%hhu%n",

    67

												&n, &i1, &i2, &i3, &i4, &j1, &j2, &j3, &j4, &read);

    68

			read += 1;

    69

			if (fields != 9) {

    70

				break;

    71

			}

    72

    73

			ip      = (uint32)i1 << 24 | (uint32)i2 << 16 | (uint32)i3 << 8 | (uint32)i4;

    74

			netmask = (uint32)j1 << 24 | (uint32)j2 << 16 | (uint32)j3 << 8 | (uint32)j4;

    75

    76

			if (ip != INADDR_LOOPBACK && ip != INADDR_ANY) {

    77

				inaddr.s_addr = htonl(ip | ~netmask);

    78

				broadcast[index] = inaddr.s_addr;

    79

				index++;

    80

			}

    81

			if (read < 0) {

    82

				break;

    83

			}

    84

			*output += read;

    85

		}

    86

		closesocket(sock);

    87

	}

    88

    89

	return index;

    90

}

    91

    92

#elif defined(HAVE_GETIFADDRS)

    93

static int NetworkFindBroadcastIPsInternal(uint32 *broadcast, int limit) // GETIFADDRS implementation

    94

{

    95

	struct ifaddrs *ifap, *ifa;

    96

    97

	if (getifaddrs(&ifap) != 0) return 0;

    98

    99

	int index = 0;

   100

	for (ifa = ifap; ifa != NULL && index != limit; ifa = ifa->ifa_next) {

   101

		if (!(ifa->ifa_flags & IFF_BROADCAST)) continue;

   102

		if (ifa->ifa_broadaddr == NULL) continue;

   103

		if (ifa->ifa_broadaddr->sa_family != AF_INET) continue;

   104

   105

		broadcast[index] = ((struct sockaddr_in*)ifa->ifa_broadaddr)->sin_addr.s_addr;

   106

		index++;

   107

	}

   108

	freeifaddrs(ifap);

   109

   110

	return index;

   111

}

   112

   113

#elif defined(WIN32)

   114

static int NetworkFindBroadcastIPsInternal(uint32 *broadcast, int limit) // Win32 implementation

   115

{

   116

	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);

   117

	if (sock == INVALID_SOCKET) return 0;

   118

   119

	DWORD len = 0;

   120

	INTERFACE_INFO ifo[MAX_INTERFACES];

   121

	memset(&ifo[0], 0, sizeof(ifo));

   122

	if ((WSAIoctl(sock, SIO_GET_INTERFACE_LIST, NULL, 0, &ifo[0], sizeof(ifo), &len, NULL, NULL)) != 0) {

   123

		closesocket(sock);

   124

		return;

   125

	}

   126

   127

	int index = 0;

   128

	for (int j = 0; j < len / sizeof(*ifo) && index != limit; j++) {

   129

		if (ifo[j].iiFlags & IFF_LOOPBACK) continue;

   130

		if (!(ifo[j].iiFlags & IFF_BROADCAST)) continue;

   131

   132

		/* iiBroadcast is unusable, because it always seems to be set to 255.255.255.255. */

   133

		broadcast[index++] = ifo[j].iiAddress.AddressIn.sin_addr.s_addr | ~ifo[j].iiNetmask.AddressIn.sin_addr.s_addr;

   134

	}

   135

   136

	closesocket(sock);

   137

	return index;

   138

}

   139

   140

#else /* not HAVE_GETIFADDRS */

   141

static int NetworkFindBroadcastIPsInternal(uint32 *broadcast, int limit) // !GETIFADDRS implementation

   142

{

   143

	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);

   144

	if (sock == INVALID_SOCKET) return 0;

   145

   146

	char buf[4 * 1024]; // Arbitrary buffer size

   147

	struct ifconf ifconf;

   148

   149

	ifconf.ifc_len = sizeof(buf);

   150

	ifconf.ifc_buf = buf;

   151

	if (ioctl(sock, SIOCGIFCONF, &ifconf) == -1) {

   152

		closesocket(sock);

   153

		return 0;

   154

	}

   155

   156

	const char *buf_end = buf + ifconf.ifc_len;

   157

	int index;

   158

	for (const char *p = buf; p < buf_end && index != 0;) {

   159

		const struct ifreq* req = (const struct ifreq*)p;

   160

   161

		if (req->ifr_addr.sa_family == AF_INET) {

   162

			struct ifreq r;

   163

   164

			strncpy(r.ifr_name, req->ifr_name, lengthof(r.ifr_name));

   165

			if (ioctl(sock, SIOCGIFFLAGS, &r) != -1 &&

   166

					r.ifr_flags & IFF_BROADCAST &&

   167

					ioctl(sock, SIOCGIFBRDADDR, &r) != -1) {

   168

				broadcast[index++] = ((struct sockaddr_in*)&r.ifr_broadaddr)->sin_addr.s_addr;

   169

			}

   170

		}

   171

   172

		p += sizeof(struct ifreq);

   173

#if defined(AF_LINK) && !defined(SUNOS)

   174

		p += req->ifr_addr.sa_len - sizeof(struct sockaddr);

   175

#endif

   176

	}

   177

   178

	closesocket(sock);

   179

}

   180

#endif /* all NetworkFindBroadcastIPsInternals */

   181

   182

/**

   183

 * Find the IPs to broadcast.

   184

 * @param broadcast the list of broadcasts to write into.

   185

 * @param limit     the maximum number of items to add.

   186

 */

   187

void NetworkFindBroadcastIPs(uint32 *broadcast, int limit)

   188

{

   189

	int count = NetworkFindBroadcastIPsInternal(broadcast, limit);

   190

   191

	/* Make sure the list is terminated. */

   192

	broadcast[count] = 0;

   193

   194

	/* Now display to the debug all the detected ips */

   195

	DEBUG(net, 3, "Detected broadcast addresses:");

   196

	for (int i = 0; broadcast[i] != 0; i++) {

   197

		DEBUG(net, 3, "%d) %s", i, inet_ntoa(*(struct in_addr *)&broadcast[i])); //inet_ntoa(inaddr));

   198

	}

   199

}

   200

   201

   202

/**

   203

 * Resolve a hostname to an ip.

   204

 * @param hsotname the hostname to resolve

   205

 * @return the IP belonging to that hostname, or 0 on failure.

   206

 */

   207

uint32 NetworkResolveHost(const char *hostname)

   208

{

   209

	/* Is this an IP address? */

   210

	in_addr_t ip = inet_addr(hostname);

   211

   212

	if (ip != INADDR_NONE) return ip;

   213

   214

	/* No, try to resolve the name */

   215

	struct in_addr addr;

   216

#if !defined(PSP)

   217

	struct hostent *he = gethostbyname(hostname);

   218

	if (he == NULL) {

   219

		DEBUG(net, 0, "[NET] Cannot resolve %s", hostname);

   220

		return 0;

   221

	}

   222

	addr = *(struct in_addr *)he->h_addr_list[0];

   223

#else

   224

	int rid = -1;

   225

	char buf[1024];

   226

   227

	/* Create a resolver */

   228

	if (sceNetResolverCreate(&rid, buf, sizeof(buf)) < 0) {

   229

		DEBUG(net, 0, "[NET] Error connecting resolver");

   230

		return 0;

   231

	}

   232

   233

	/* Try to resolve the name */

   234

	if (sceNetResolverStartNtoA(rid, hostname, &addr, 2, 3) < 0) {

   235

		DEBUG(net, 0, "[NET] Cannot resolve %s", hostname);

   236

		sceNetResolverDelete(rid);

   237

		return 0;

   238

	}

   239

	sceNetResolverDelete(rid);

   240

#endif /* PSP */

   241

   242

	DEBUG(net, 1, "[NET] Resolved %s to %s", hostname, inet_ntoa(addr));

   243

	ip = addr.s_addr;

   244

	return ip;

   245

}

   246

   247

#endif /* ENABLE_NETWORK */