Exemple #1
13
const char* mega_inet_ntop(int af, const void* src, char* dst, int cnt)
{
    wchar_t ip[INET6_ADDRSTRLEN];
    int len = INET6_ADDRSTRLEN;
    int ret = 1;

    if (af == AF_INET)
    {
        struct sockaddr_in in = {};
        in.sin_family = AF_INET;
        memcpy(&in.sin_addr, src, sizeof(struct in_addr));
        ret = WSAAddressToString((struct sockaddr*) &in, sizeof(struct sockaddr_in), 0, ip, (LPDWORD)&len);
    }
    else if (af == AF_INET6)
    {
        struct sockaddr_in6 in = {};
        in.sin6_family = AF_INET6;
        memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
        ret = WSAAddressToString((struct sockaddr*) &in, sizeof(struct sockaddr_in6), 0, ip, (LPDWORD)&len);
    }

    if (ret != 0)
    {
        return NULL;
    }

    if (!WideCharToMultiByte(CP_UTF8, 0, ip, len, dst, cnt, NULL, NULL))
    {
        return NULL;
    }

    return dst;
}
static const char *inet_ntop(sa_family_t family, void *addr, char *buf, size_t bufsize)
{
    if (family == AF_INET) {
        struct sockaddr_in saddr = { 0 };
        saddr.sin_family = AF_INET;
        saddr.sin_addr = *(struct in_addr *)addr;

        DWORD len = bufsize;

        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), NULL, buf, &len))
            return NULL;

        return buf;
    } else if (family == AF_INET6) {
        struct sockaddr_in6 saddr = { 0 };
        saddr.sin6_family = AF_INET6;
        saddr.sin6_addr = *(struct in6_addr *)addr;

        DWORD len = bufsize;

        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), NULL, buf, &len))
            return NULL;

        return buf;
    }

    return NULL;
}
Exemple #3
0
const char *
inet_ntop (int af, const void *src, char *dst, socklen_t cnt)
{
  /* struct sockaddr can't accomodate struct sockaddr_in6. */
  union {
    struct sockaddr_in6 sin6;
    struct sockaddr_in sin;
  } sa;
  DWORD dstlen = cnt;
  size_t srcsize;

  xzero (sa);
  switch (af)
    {
    case AF_INET:
      sa.sin.sin_family = AF_INET;
      sa.sin.sin_addr = *(struct in_addr *) src;
      srcsize = sizeof (sa.sin);
      break;
    case AF_INET6:
      sa.sin6.sin6_family = AF_INET6;
      sa.sin6.sin6_addr = *(struct in6_addr *) src;
      srcsize = sizeof (sa.sin6);
      break;
    default:
      abort ();
    }

  if (WSAAddressToString ((struct sockaddr *) &sa, srcsize, NULL, dst, &dstlen) != 0)
    {
      errno = WSAGetLastError();
      return NULL;
    }
  return (const char *) dst;
}
Exemple #4
0
static const char *
inet_ntop (int address_family, const void *source,
           char *destination, socklen_t destination_length)
{
    DWORD socket_address_length;
    DWORD winsock_destination_length = destination_length;

    switch (address_family) {
    case AF_INET:
        socket_address_length = sizeof(struct sockaddr_in);
        break;
    case AF_INET6:
        socket_address_length = sizeof(struct sockaddr_in6);
        break;
    default:
        return NULL;
        break;
    }

    if (WSAAddressToString((LPSOCKADDR)source, socket_address_length, NULL,
                           destination, &winsock_destination_length)) {
        return NULL;
    } else {
        return destination;
    }
}
Exemple #5
0
CGPacket::CGPacket(LPBYTE lpData, DWORD dwLen, CProperty& Property)
{
	if (lpData == NULL || dwLen == 0)return;

	m_pBuf = new BYTE[dwLen];
	memcpy(m_pBuf, lpData, dwLen);
	m_dwSize = dwLen;
	m_property = Property;
	m_pRawBuf = lpData;
	m_bFiltered = FALSE;
	if (Property.s != INVALID_SOCKET)
	{
		sockaddr_in sin;
		int sinlen = sizeof(sin);
		if (0 == getpeername(Property.s, (sockaddr*)&sin, &sinlen))
		{
			TCHAR tszTemp[256], tszIP[64];
			DWORD dwLen = sizeof(tszTemp), dwPort;

			if (0 == WSAAddressToString((SOCKADDR *)&sin, sizeof(SOCKADDR), NULL, tszTemp, (LPDWORD)&dwLen))
			{
				_stscanf_s(tszTemp, _T("%[0-9,.]:%d"), tszIP, sizeof(tszIP), &dwPort);
				m_property.strIpAddr = tszIP;
				m_property.dwPort = dwPort;

				TCHAR szBuf[32];
				_itot(dwPort, szBuf, 10);
				m_property.strPort = Tstring(szBuf);
			}
		}
	}
}
Exemple #6
0
FString FWebSocket::RemoteEndPoint(bool bAppendPort)
{
	// Windows XP does not have support for inet_ntop
#if PLATFORM_WINDOWS && _WIN32_WINNT <= 0x0502
	TCHAR Buffer[INET_ADDRSTRLEN];
	::DWORD BufferSize = INET_ADDRSTRLEN;
	FString remote = "";
	sockaddr_in AddressToConvert = RemoteAddr;
	if (!bAppendPort)
	{
		AddressToConvert.sin_port = 0;
	}
	if (WSAAddressToString((sockaddr*)&AddressToConvert, sizeof(AddressToConvert), NULL, Buffer, &BufferSize) == 0)
	{
		remote = Buffer;
	}
#else
	ANSICHAR Buffer[INET_ADDRSTRLEN];
	FString remote(ANSI_TO_TCHAR(inet_ntop(AF_INET, &RemoteAddr.sin_addr, Buffer, INET_ADDRSTRLEN)));
	if ( bAppendPort )
	{
		remote += FString::Printf(TEXT(":%i"), ntohs(RemoteAddr.sin_port));
	}
#endif

	return remote;
}
Exemple #7
0
const char *
inet_ntop(int af, const void *src, char *dst, socklen_t size)
{
    struct sockaddr_storage ss;
    unsigned long s = size;

    ZeroMemory(&ss, sizeof(ss));
    ss.ss_family = af;

    switch (af)
    {
        case AF_INET:
            ((struct sockaddr_in *)&ss)->sin_addr = *(struct in_addr *)src;
            break;

        case AF_INET6:
            ((struct sockaddr_in6 *)&ss)->sin6_addr = *(struct in6_addr *)src;
            break;

        default:
            return NULL;
    }
    /* cannot direclty use &size because of strict aliasing rules */
    return (WSAAddressToString((struct sockaddr *)&ss, sizeof(ss), NULL, dst, &s) == 0) ?
           dst : NULL;
}
BOOL FillIpAddr(TCHAR * buff,
                SOCKET_ADDRESS& Address,
                int i, CDeviceMgr_i::IPADDR IpAddr[10] )
{
    DWORD bufflen = 256;
    buff[0] = 0;

    WSAAddressToString(Address.lpSockaddr, Address.iSockaddrLength, NULL, buff,&bufflen);
    if(i<10)
    {
        StrCpyN(IpAddr[i].szAddr, buff, MAX_IP_ADDR_CNT);
        IpAddr[i].sa_family = Address.lpSockaddr->sa_family;
        if(Address.lpSockaddr->sa_family == AF_INET)
        {
            IpAddr[i].IsIpV6 = 0;
        }
        else if(Address.lpSockaddr->sa_family == AF_INET6)
        {
            IpAddr[i].IsIpV6 = 1;
        }
    }
    else
    {
        return FALSE;
    }

    return TRUE;
}
Exemple #9
0
PHPAPI const char* inet_ntop(int af, const void* src, char* dst, size_t size)
{
	int address_length;
	DWORD string_length = size;
	struct sockaddr_storage sa;
	struct sockaddr_in *sin = (struct sockaddr_in *)&sa;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&sa;

	memset (&sa, 0, sizeof (sa));
	switch (af) {
		case AF_INET:
			address_length = sizeof (struct sockaddr_in);
			sin->sin_family = af;
			memcpy (&sin->sin_addr, src, sizeof (struct in_addr));
			break;

		case AF_INET6:
			address_length = sizeof (struct sockaddr_in6);
			sin6->sin6_family = af;
			memcpy (&sin6->sin6_addr, src, sizeof (struct in6_addr));
			break;

		default:
			return NULL;
	}

	if (WSAAddressToString ((LPSOCKADDR) &sa, address_length, NULL, dst, &string_length) == 0) {
		return dst;
	}

	return NULL;
}
Exemple #10
0
/** This is inet_ntop, but it works on Windows
 * @param af The protocol type, AF_INET or AF_INET6
 * @param src Network address structure
 * @param dst After converting put it here
 * @param size sizeof the dest
 * @return dst
 */
const char *windows_inet_ntop(int af, const void *src, char *dst, size_t size)
{
	int address_length;
	DWORD string_length = size;
	sockaddr_storage sa;
	sockaddr_in *sin = reinterpret_cast<sockaddr_in *>(&sa);
	sockaddr_in6 *sin6 = reinterpret_cast<sockaddr_in6 *>(&sa);

	memset(&sa, 0, sizeof(sa));

	switch (af)
	{
		case AF_INET:
			address_length = sizeof(sockaddr_in);
			sin->sin_family = af;
			memcpy(&sin->sin_addr, src, sizeof(in_addr));
			break;
		case AF_INET6:
			address_length = sizeof(sockaddr_in6);
			sin6->sin6_family = af;
			memcpy(&sin6->sin6_addr, src, sizeof(in6_addr));
			break;
		default:
			return NULL;
	}

	if (!WSAAddressToString(reinterpret_cast<LPSOCKADDR>(&sa), address_length, NULL, dst, &string_length))
		return dst;

	return NULL;
}
Exemple #11
0
/**
 * IpToString
 *
 * Converts a sockaddr struct into a string.
 *
 * @param Address the address
 */
const char *IpToString(sockaddr *Address) {
	static char Buffer[256];

#ifdef _WIN32
	DWORD BufferLength = sizeof(Buffer);

	if (WSAAddressToString(Address, SOCKADDR_LEN(Address->sa_family), NULL, Buffer, &BufferLength) != 0) {
		return NULL;
	}
#else
	void *IpAddress;

	if (Address->sa_family == AF_INET) {
		IpAddress = &(((sockaddr_in *)Address)->sin_addr);
	} else {
		IpAddress = &(((sockaddr_in6 *)Address)->sin6_addr);
	}

	if (inet_ntop(Address->sa_family, IpAddress, Buffer, sizeof(Buffer)) == NULL) {
		return NULL;
	}
#endif

	return Buffer;
}
Exemple #12
0
/**
 *  Convert a numeric address to character string
 *  @param sa	socket numerical address
 *  @param sock socket
 *  @return the peer information
 */
char* Socket_getaddrname(struct sockaddr* sa, int sock)
{
/**
 * maximum length of the address string
 */
#define ADDRLEN INET6_ADDRSTRLEN+1
/**
 * maximum length of the port string
 */
#define PORTLEN 10
	static char addr_string[ADDRLEN + PORTLEN];

#if defined(WIN32) || defined(WIN64)
	int buflen = ADDRLEN*2;
	wchar_t buf[ADDRLEN*2];
	if (WSAAddressToString(sa, sizeof(struct sockaddr_in6), NULL, buf, (LPDWORD)&buflen) == SOCKET_ERROR)
		Socket_error("WSAAddressToString", sock);
	else
		wcstombs(addr_string, buf, sizeof(addr_string));
	/* TODO: append the port information - format: [00:00:00::]:port */
	/* strcpy(&addr_string[strlen(addr_string)], "what?"); */
#else
	struct sockaddr_in *sin = (struct sockaddr_in *)sa;
	inet_ntop(sin->sin_family, &sin->sin_addr, addr_string, ADDRLEN);
	sprintf(&addr_string[strlen(addr_string)], ":%d", ntohs(sin->sin_port));
#endif
	return addr_string;
}
Exemple #13
0
/* 
 * convert a network format address to presentation format.
 *
 * return:
 *    pointer to presentation format address (`dst'), or NULL.
 */
const char *ompi_inet_ntop(int af, const void *src, char *dst, size_t size)
{
    int addr_len;
    struct sockaddr sa;
    DWORD str_len = size;
	struct sockaddr_in *sin = (struct sockaddr_in *)&sa;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&sa;

    memset (&sa, 0, sizeof (struct sockaddr));

    switch (af) {
    case AF_INET:
        addr_len = sizeof(struct sockaddr_in);
		sin->sin_family = af;
		memcpy (&sin->sin_addr, src, sizeof (struct in_addr));
        break;

    case AF_INET6:
        addr_len = sizeof(struct sockaddr_in6);
		sin6->sin6_family = af;
		memcpy (&sin6->sin6_addr, src, sizeof (struct in6_addr));
        break;

    default:
        return NULL;
    }

    if ( 0 == WSAAddressToString ((LPSOCKADDR) &sa, addr_len, NULL, dst, &str_len )) {
        return dst;
    } else {
        opal_output(0, "WSAAddressToString failed %s:%d. Error code: %d", __FILE__, __LINE__, GetLastError());
        return NULL;
    }
}
/*
    Prints the given socket address in a printable string format.
*/
void PrintAddressString(LPSOCKADDR pSockAddr, DWORD dwSockAddrLen)
{
    // INET6_ADDRSTRLEN is the maximum size of a valid IPv6 address 
    // including port,colons,NULL,etc.
    char buf[INET6_ADDRSTRLEN];
    DWORD dwBufSize = 0;    

    memset(buf,0,sizeof(buf));
    dwBufSize = sizeof(buf);

    // This function converts the pSockAddr to a printable format into buf.   
    if (WSAAddressToString(pSockAddr, 
                           dwSockAddrLen, 
                           NULL, 
                           buf, 
                           &dwBufSize) == SOCKET_ERROR)
    {
        printf("ERROR: WSAAddressToString failed %d \n", WSAGetLastError());
        goto CLEANUP;
    }

    printf("%s\n", buf);

CLEANUP:
    return;
}
Exemple #15
0
xstring inetAddrToString(sockaddr_in* sin)
{
	TCHAR buff[MAX_PATH] = {};
	DWORD buffLen = MAX_PATH;
	if (SOCKET_ERROR == WSAAddressToString(reinterpret_cast<sockaddr*>(sin), sizeof(sockaddr_in), nullptr, buff, &buffLen))
	{
		return xstring();
	}
	return xstring(buff);
}
Exemple #16
0
/* satop(struct sockaddr *sa, char *dst, socklen_t size) 
 * Convert a sockaddr to a printable address.
 */
int satop(struct sockaddr *sa, char *dst, socklen_t size)
{
    sa_family_t af;
    struct sockaddr_in *sa4;
    struct sockaddr_in6 *sa6;
#ifdef WIN32
    int newlength;
#endif

    af = sa->sa_family;

    switch (af)
    {
    case AF_INET:
        sa4 = (struct sockaddr_in *) sa;
#ifdef WIN32
        newlength = size;
        WSAAddressToString((LPSOCKADDR) sa4, sizeof(struct sockaddr_in), 
                           NULL, dst, (LPDWORD) &newlength);
#else
        inet_ntop(af, (const void *) &(sa4->sin_addr), dst, size);
#endif
        return(0);
    case AF_INET6:
        sa6 = (struct sockaddr_in6 *) sa;
#ifdef WIN32
        newlength = size;
        WSAAddressToString((LPSOCKADDR) sa6, sizeof(struct sockaddr_in6), 
                           NULL, dst, (LPDWORD) &newlength);
#else
        inet_ntop(af, (const void *) &(sa6->sin6_addr), dst, size);
#endif
        if (IN6_IS_ADDR_V4MAPPED(&(sa6->sin6_addr)))
        {  /* extract the embedded IPv4 address */
            memmove(dst, dst+7, size-7);
        }
        return(0);
    default:  
        *dst = '\0';
        return(-1);     
    }
}
Exemple #17
0
const char *inet_ntop(int af, const void *src, char *dst, int len){
  struct sockaddr_in srcaddr;
  memset(&srcaddr, 0, sizeof(struct sockaddr_in));
  memcpy(&(srcaddr.sin_addr), src, sizeof(srcaddr.sin_addr));
  srcaddr.sin_family = af;
  if (WSAAddressToString((struct sockaddr*) &srcaddr, sizeof(struct sockaddr_in), 0, dst, (LPDWORD) &len) != 0) {
    DWORD rv = WSAGetLastError();
    printf("WSAAddressToString() : %d\n",rv);
    return NULL;
  }
  return dst;
}
Exemple #18
0
const char* myqtt_win32_inet_ntop (int af, const void* src, char* dst, int cnt)
{
 
    struct sockaddr_in srcaddr;
    memset (&srcaddr, 0, sizeof(struct sockaddr_in));
    memcpy (&(srcaddr.sin_addr), src, sizeof(srcaddr.sin_addr));
 
    srcaddr.sin_family = af;
    if (WSAAddressToString((struct sockaddr*) &srcaddr, sizeof(struct sockaddr_in), 0, dst, (LPDWORD) &cnt) != 0) {
        return NULL;
    }
    return dst;
}
Exemple #19
0
const char *IPV6Address::getHostname(void) const
{
	struct hostent *hp = NULL;
	struct in6_addr addr0;
	static char strbuf[64];

	memset(&addr0, 0, sizeof(addr0));
	if(!memcmp(&addr0, &ipaddr[0], sizeof(addr0)))
		return NULL;

	if(!memcmp(&in6addr_loopback, &ipaddr[0], sizeof(addr0)))
		return "localhost";

#if defined(__GLIBC__)
	char   hbuf[8192];
	struct hostent hb;
	int    rtn;
	if(gethostbyaddr_r((char *)&ipaddr[0], sizeof(addr0), AF_INET6, &hb, hbuf, sizeof(hbuf), &hp, &rtn))
		hp = NULL;
#elif defined(sun)
	char   hbuf[8192];
	struct hostent hb;
	int    rtn;
	hp = gethostbyaddr_r((char *)&ipaddr[0], sizeof(addr0), AF_INET6, &hb, hbuf, (int)sizeof(hbuf), &rtn);
#elif defined(__osf__) || defined(WIN32)
	hp = gethostbyaddr((char *)&ipaddr[0], sizeof(addr0), AF_INET6);
#else
	mutex.enterMutex();
	hp = gethostbyaddr((char *)&ipaddr[0], sizeof(addr0), AF_INET6);
	mutex.leaveMutex();
#endif
	if(hp) {
		if(hostname)
			delString(hostname);
		hostname = newString(hp->h_name);
		return hostname;
	} else {
#ifdef	WIN32
		struct sockaddr saddr;
		struct sockaddr_in6 *paddr = (struct sockaddr_in6 *)&saddr;
		DWORD slen = sizeof(strbuf);
		memset(&saddr, 0, sizeof(saddr));
		paddr->sin6_family = AF_INET6;
		paddr->sin6_addr = ipaddr[0];
		WSAAddressToString(&saddr, sizeof(saddr), NULL, strbuf, &slen);
		return strbuf;
#else
		return inet_ntop(AF_INET6, &ipaddr[0], strbuf, sizeof(strbuf));
#endif
	}
}
int main(int argc, char *argv[])
{
    WSADATA wsa;
    if(WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
        return 1;

    /*----------------*/
    /* IPv4 변환 연습 */
    /*----------------*/
    // 원래의 IPv4 주소 출력
    char *ipv4test = "147.46.114.70";
    printf("IPv4 주소(변환 전) = %s\n", ipv4test);

    // inet_addr() 함수 연습
    printf("IPv4 주소(변환 후) = 0x%x\n", inet_addr(ipv4test));

    // inet_ntoa() 함수 연습
    IN_ADDR ipv4num;
    ipv4num.s_addr = inet_addr(ipv4test);
    printf("IPv4 주소(다시 변환 후) = %s\n", inet_ntoa(ipv4num));

    printf("\n");

    /*----------------*/
    /* IPv6 변환 연습 */
    /*----------------*/
    // 원래의 IPv6 주소 출력
    char *ipv6test = "2001:0230:abcd:ffab:0023:eb00:ffff:1111";
    printf("IPv6 주소(변환 전) = %s\n", ipv6test);

    // WSAStringToAddress() 함수 연습
    SOCKADDR_IN6 ipv6num;
    int addrlen = sizeof(ipv6num);
    WSAStringToAddress(ipv6test, AF_INET6, NULL,
                       (SOCKADDR *)&ipv6num, &addrlen);
    printf("IPv6 주소(변환 후) = 0x");
    for(int i=0; i<16; i++)
        printf("%02x", ipv6num.sin6_addr.u.Byte[i]);
    printf("\n");

    // WSAAddressToString() 함수 연습
    char ipaddr[50];
    DWORD ipaddrlen = sizeof(ipaddr);
    WSAAddressToString((SOCKADDR *)&ipv6num, sizeof(ipv6num),
                       NULL, ipaddr, &ipaddrlen);
    printf("IPv6 주소(다시 변환 후) = %s\n", ipaddr);

    WSACleanup();
    return 0;
}
Exemple #21
0
void CCustomIOCPBaseList::GetLocalAddrs(vector<tstring> &Addrs)
{
	LPSTR sHostName;
	ADDRINFOT _Hints;
	int _Retval;
	PADDRINFOT _ResultAddInfo;
	PADDRINFOT _NextAddInfo;

	Addrs.clear();
	sHostName = new char[MAX_PATH];
	if (gethostname(sHostName, MAX_PATH) == SOCKET_ERROR) {
		return;
	}

	ZeroMemory(&_Hints, sizeof(_Hints));
	_Hints.ai_family = AF_UNSPEC;
	_Hints.ai_socktype = SOCK_STREAM;
	_Hints.ai_protocol = IPPROTO_TCP;
	std::tstring hostname = string_to_tstring(std::string(sHostName));
	_Retval = GetAddrInfo(hostname.c_str(), NULL, &_Hints, &_ResultAddInfo);
	if (_Retval == 0) {
		DWORD _AddrStringLen;
		LPTSTR _AddrString;

		_NextAddInfo = _ResultAddInfo;
		// 申请缓冲区
		_AddrString = new TCHAR[ADDR_STRING_MAX_LEN];

		while (_NextAddInfo != NULL) {
			_AddrStringLen = ADDR_STRING_MAX_LEN;
			// 获取

			if (WSAAddressToString(_NextAddInfo->ai_addr, (DWORD)_NextAddInfo->ai_addrlen, NULL,
				_AddrString, &_AddrStringLen) == 0) {
				// 改为真实长度,这里的_AddrStringLen包含了末尾的字符#0,所以要减去这个#0的长度
				_AddrStringLen--;
				Addrs.push_back(tstring(_AddrString));
				OutputDebugStr(_T("ai_addr:%s,ai_flags:%d,ai_canonname=%s\n"),
					_AddrString, _NextAddInfo->ai_flags, _NextAddInfo->ai_canonname);
			} else {
				OutputDebugStr(_T("WSAAddressToString Error:%d\n"), WSAGetLastError());
			}

			_NextAddInfo = _NextAddInfo->ai_next;
		}
		delete[] _AddrString;
		FreeAddrInfo(_ResultAddInfo);
	}
	delete[] sHostName;
}
Exemple #22
0
char *GetIpAddr(apr_pool_t *pool, PSOCKADDR pAddr)
{
	DWORD len = 50;
	char *buf = (char *)apr_palloc(pool, len);

	if(buf == NULL)
		return "";

	buf[0] = 0;

	WSAAddressToString(pAddr, sizeof(SOCKADDR), NULL, buf, &len);

	return buf;
}
Exemple #23
0
 const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
   union { struct sockaddr sa; struct sockaddr_in sai;
           struct sockaddr_in6 sai6; } addr;
   int res;
   memset(&addr, 0, sizeof(addr));
   addr.sa.sa_family = af;
   if (af == AF_INET6) {
     memcpy(&addr.sai6.sin6_addr, src, sizeof(addr.sai6.sin6_addr));
   } else {
     memcpy(&addr.sai.sin_addr, src, sizeof(addr.sai.sin_addr));
   }
   res = WSAAddressToString(&addr.sa, sizeof(addr), 0, dst, (LPDWORD) &size);
   if (res != 0) return NULL;
   return dst;
 }
Exemple #24
0
void
GetIPv6AddressString(TCHAR *szBuffer, PSOCKADDR_IN6 pAddr)
{
    DWORD dwBufLen = INET6_ADDRSTRLEN;

    if (WSAAddressToString(
                          (struct sockaddr *)pAddr,
                          sizeof(SOCKADDR_IN6),
                          NULL,
                          szBuffer,
                          &dwBufLen)) {
        DEBUGMSG(ZONE_ERROR, (TEXT("NETUIQC: Error from WSAAddressToString():0x%X"),WSAGetLastError()));
        LoadString(v_hInst, IDS_QC_V6_ADDR_UNAVAIL, szBuffer, INET6_ADDRSTRLEN);
    }
}
Exemple #25
0
/**F*****************************************************************/
char *addr2ip (args_t *p)
/**
 * PURPOSE : Convert network address to ip string
 *
 * RETURN :  String ASCII representation of network address
 *
 * NOTES :   None
 *
 *F*/
{
    DWORD ip_size=64;
    WSAAddressToString (p->ai_addr, p->ai_addrlen,
                        NULL, (char*)p->ip, &ip_size);

    return (char*)p->ip;
}
/**
 * gnome_vfs_address_to_string:
 * @address: A pointer to a #GnomeVFSAddress
 * 
 * Translate @address to a printable string.
 * 
 * Returns: A newly alloced string representation of @address which
 * the caller must free.
 *
 * Since: 2.8
 **/
char *
gnome_vfs_address_to_string (GnomeVFSAddress *address)
{
#ifdef G_OS_WIN32
	char text_addr[100];
	DWORD text_length = sizeof (text_addr);

	if (WSAAddressToString (address->sa, SA_SIZE (address->sa),
				NULL, text_addr, &text_length) == 0)
		return g_strdup (text_addr);

	return NULL;
#else
	const char *text_addr;
#ifdef HAVE_INET_NTOP
	char buf[MAX_ADDRSTRLEN];
#endif	
	g_return_val_if_fail (address != NULL, NULL);

	text_addr = NULL;

	switch (address->sa->sa_family) {
#if defined (ENABLE_IPV6) && defined (HAVE_INET_NTOP)	
	case AF_INET6:
			 
		text_addr = inet_ntop (AF_INET6,
				       &SIN6 (address->sa)->sin6_addr,
				       buf,
				       sizeof (buf));
		break;
#endif
	case AF_INET:
#if HAVE_INET_NTOP
		text_addr = inet_ntop (AF_INET,
				       &SIN (address->sa)->sin_addr,
				       buf,
				       sizeof (buf));
#else
		text_addr = inet_ntoa (SIN (address->sa)->sin_addr);
#endif  /* HAVE_INET_NTOP */
		break;
	}
	   
	  
	return text_addr != NULL ? g_strdup (text_addr) : NULL;
#endif
}
Exemple #27
0
    static std::string      GetIP(addr_IPvX& _address)
    {
        long unsigned int length = (_address.sa_family == AF_INET) ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN;
        std::vector<char> ip(length);
#if defined(__unix__) || defined(__APPLE__)
        inet_ntop(_address.sa_family, _address.sa_data, ip.data(), length);
#endif
#ifdef _WIN32
        if (WSAAddressToString(&_address, length, NULL, ip.data(), &length) == SOCKET_ERROR)
        {
            char tmp[256];
            strerror_s(tmp, errno);
            throw tmp;
        }
#endif
        return std::string(ip.data());
    }
Exemple #28
0
char *addr2ip(args_t *p)
{
  void *src;
#ifdef WIN
  DWORD ip_size=INET6_ADDRSTRLEN;
  WSAAddressToString (p->ai_addr, p->ai_addrlen, 
    NULL, (char*)p->ip, &ip_size);
#else
  if (p->ai_family==AF_INET) {
    src=(void*)&p->v4.sin_addr;
  } else {
    src=(void*)&p->v6.sin6_addr;
  }
  inet_ntop(p->ai_family, src, p->ip, INET6_ADDRSTRLEN);
#endif
  return p->ip;
}
Exemple #29
0
    void	unpackIP(void const* src, char* dst, size_t size)
    {
#ifdef __unix__
      if (inet_ntop(AF_INET, src, dst, size) == NULL)
	printf("inet_ntop failed\n");
#elif defined _WIN32
      SOCKADDR_IN	addr;
      addr.sin_family = AF_INET;
      addr.sin_port = 0;
      memcpy(&addr.sin_addr, src, 8); // TODO : 8 ????
      if (WSAAddressToString((LPSOCKADDR)&addr, sizeof(SOCKADDR), NULL, dst, (LPDWORD)&size) == SOCKET_ERROR)
	{
	  printf("pack ip wsa address to string%d\n", WSAGetLastError());
	  throw;
	}
#endif
    }
// Function: EnumerateATMAddresses()
// Description: Enumerate all ATM interfaces and print their addresses
void EnumerateATMAddresses_atm(WSAPROTOCOL_INFO *lpProtocol)
{
    SOCKET             s;
    SOCKADDR_ATM       atm_addr;
    char               szAddress[MAX_ATM_ADDR_LEN];
    DWORD              dwNumInterfaces, dwAddrLen=MAX_ATM_ADDR_LEN, i;
 
    s = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, lpProtocol, 0, WSA_FLAG_OVERLAPPED);
    if (s == INVALID_SOCKET)
    {
        printf("WSASocket() failed with error code %d\n", WSAGetLastError());
        return;
    }
    else
        printf("WSASocket() is OK!\n");
 
    dwNumInterfaces = GetNumATMInterfaces_atm(s);
 
    for(i=0; i < dwNumInterfaces ;i++)
    {
		ZeroMemory((PVOID)&atm_addr, sizeof(SOCKADDR_ATM));
		ZeroMemory((PVOID)szAddress, MAX_ATM_ADDR_LEN);

		if (GetATMAddress_atm(s, i, &atm_addr.satm_number) == FALSE)
		{
			printf("GetATMAddress() failed!\n");
			break;
		}

		atm_addr.satm_family                 = AF_ATM;
		atm_addr.satm_number.AddressType     = ATM_NSAP;
		atm_addr.satm_number.NumofDigits     = ATM_ADDR_SIZE;
		atm_addr.satm_blli.Layer2Protocol    = SAP_FIELD_ANY;
		atm_addr.satm_blli.Layer3Protocol    = SAP_FIELD_ABSENT;
		atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
		if (WSAAddressToString((LPSOCKADDR)&atm_addr, sizeof(atm_addr),lpProtocol, (LPWSTR)szAddress, &dwAddrLen))
		{
			printf("WSAAddressToString() failed with error code %d\n", WSAGetLastError());
			break;
		}
		printf("ATM ADDRESS <%d>: '%s'\n", i, szAddress);
    }
    closesocket(s);
    return;
}