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

#include "../../core/alloc_func.hpp"

    11

    12

/**

    13

 * Internal implementation for finding the broadcast IPs.

    14

 * This function is implemented multiple times for multiple targets.

    15

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

    16

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

    17

 */

    18

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

    19

    20

#if defined(PSP)

    21

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

    22

{

    23

	return 0;

    24

}

    25

    26

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

    27

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

    28

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

    29

    30

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

    31

{

    32

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

    33

	if (new_pos == 0) {

    34

		return B_ERROR;

    35

	}

    36

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

    37

	return B_OK;

    38

}

    39

    40

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

    41

{

    42

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

    43

    44

	if (sock < 0) {

    45

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

    46

		return 0;

    47

	}

    48

    49

	char *output_pointer = NULL;

    50

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

    51

	if (output_length < 0) {

    52

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

    53

		return 0;

    54

	}

    55

    56

	int index;

    57

	char **output = &output_pointer;

    58

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

    59

		while (index != limit) {

    60

    61

			uint32 n, fields, read;

    62

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

    63

			struct in_addr inaddr;

    64

			uint32 ip;

    65

			uint32 netmask;

    66

    67

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

    68

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

    69

			read += 1;

    70

			if (fields != 9) {

    71

				break;

    72

			}

    73

    74

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

    75

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

    76

    77

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

    78

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

    79

				broadcast[index] = inaddr.s_addr;

    80

				index++;

    81

			}

    82

			if (read < 0) {

    83

				break;

    84

			}

    85

			*output += read;

    86

		}

    87

		closesocket(sock);

    88

	}

    89

    90

	return index;

    91

}

    92

    93

#elif defined(HAVE_GETIFADDRS)

    94

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

    95

{

    96

	struct ifaddrs *ifap, *ifa;

    97

    98

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

    99

   100

	int index = 0;

   101

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

   102

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

   103

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

   104

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

   105

   106

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

   107

		index++;

   108

	}

   109

	freeifaddrs(ifap);

   110

   111

	return index;

   112

}

   113

   114

#elif defined(WIN32)

   115

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

   116

{

   117

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

   118

	if (sock == INVALID_SOCKET) return 0;

   119

   120

	DWORD len = 0;

   121

	INTERFACE_INFO *ifo = AllocaM(INTERFACE_INFO, limit);

   122

	memset(ifo, 0, limit * sizeof(*ifo));

   123

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

   124

		closesocket(sock);

   125

		return 0;

   126

	}

   127

   128

	int index = 0;

   129

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

   130

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

   131

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

   132

   133

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

   134

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

   135

	}

   136

   137

	closesocket(sock);

   138

	return index;

   139

}

   140

   141

#else /* not HAVE_GETIFADDRS */

   142

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

   143

{

   144

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

   145

	if (sock == INVALID_SOCKET) return 0;

   146

   147

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

   148

	struct ifconf ifconf;

   149

   150

	ifconf.ifc_len = sizeof(buf);

   151

	ifconf.ifc_buf = buf;

   152

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

   153

		closesocket(sock);

   154

		return 0;

   155

	}

   156

   157

	const char *buf_end = buf + ifconf.ifc_len;

   158

	int index = 0;

   159

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

   160

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

   161

   162

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

   163

			struct ifreq r;

   164

   165

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

   166

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

   167

					r.ifr_flags & IFF_BROADCAST &&

   168

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

   169

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

   170

			}

   171

		}

   172

   173

		p += sizeof(struct ifreq);

   174

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

   175

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

   176

#endif

   177

	}

   178

   179

	closesocket(sock);

   181

	return index;

   182

}

   183

#endif /* all NetworkFindBroadcastIPsInternals */

   184

   185

/**

   186

 * Find the IPs to broadcast.

   187

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

   188

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

   189

 */

   190

void NetworkFindBroadcastIPs(uint32 *broadcast, int limit)

   191

{

   192

	int count = NetworkFindBroadcastIPsInternal(broadcast, limit);

   193

   194

	/* Make sure the list is terminated. */

   195

	broadcast[count] = 0;

   196

   197

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

   198

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

   199

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

   200

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

   201

	}

   202

}

   203

   204

   205

/**

   206

 * Resolve a hostname to an ip.

   207

 * @param hsotname the hostname to resolve

   208

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

   209

 */

   210

uint32 NetworkResolveHost(const char *hostname)

   211

{

   212

	/* Is this an IP address? */

   213

	in_addr_t ip = inet_addr(hostname);

   214

   215

	if (ip != INADDR_NONE) return ip;

   216

   217

	/* No, try to resolve the name */

   218

	struct in_addr addr;

   219

#if !defined(PSP)

   220

	struct hostent *he = gethostbyname(hostname);

   221

	if (he == NULL) {

   222

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

   223

		return 0;

   224

	}

   225

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

   226

#else

   227

	int rid = -1;

   228

	char buf[1024];

   229

   230

	/* Create a resolver */

   231

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

   232

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

   233

		return 0;

   234

	}

   235

   236

	/* Try to resolve the name */

   237

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

   238

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

   239

		sceNetResolverDelete(rid);

   240

		return 0;

   241

	}

   242

	sceNetResolverDelete(rid);

   243

#endif /* PSP */

   244

   245

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

   246

	ip = addr.s_addr;

   247

	return ip;

   248

}

   249

   250

#endif /* ENABLE_NETWORK */