Exemplo n.º 1
0
static int inet_pton(sa_family_t family, const char *addrString, void *addrbuf)
{
    if (family == AF_INET) {
        struct sockaddr_in saddr = { 0 };

        INT len = sizeof(saddr);

        if (WSAStringToAddress((LPTSTR)addrString, AF_INET, NULL, (LPSOCKADDR)&saddr, &len))
            return 0;

        *(struct in_addr *)addrbuf = saddr.sin_addr;

        return 1;
    } else if (family == AF_INET6) {
        struct sockaddr_in6 saddr = { 0 };

        INT len = sizeof(saddr);

        if (WSAStringToAddress((LPTSTR)addrString, AF_INET6, NULL, (LPSOCKADDR)&saddr, &len))
            return 0;

        *(struct in6_addr *)addrbuf = saddr.sin6_addr;

        return 1;
    }

    return 0;
}
Exemplo n.º 2
0
int win_inet_pton(int family, const char *src, void *dst)
{
	int rc;

	if (family == AF_INET6)
	{
		wchar_t buf[(INET6_ADDRSTRLEN+1)*2];
		int buflen = sizeof(buf);
		struct sockaddr_in6 sockaddr;

		mbstowcs(buf, src, sizeof(buf));
		rc = WSAStringToAddress(buf, AF_INET6, NULL, (struct sockaddr*)&sockaddr, &buflen);
		memcpy(dst, &sockaddr.sin6_addr.s6_addr, sizeof(sockaddr.sin6_addr.s6_addr));
	}
	else
	{
		wchar_t buf[(INET_ADDRSTRLEN+1)*2];
		int buflen = sizeof(buf);
		struct sockaddr_in sockaddr;

		mbstowcs(buf, src, sizeof(buf));
		rc = WSAStringToAddress(buf, AF_INET, NULL, (struct sockaddr*)&sockaddr, &buflen);
		memcpy(dst, &sockaddr.sin_addr.s_addr, sizeof(sockaddr.sin_addr.s_addr));
	}
	return rc;
}
Exemplo n.º 3
0
/**
 * gnome_vfs_address_new_from_string:
 * @address: A string representation of the address.
 * 
 * Creates a new #GnomeVFSAddress from the given string or %NULL
 * if @address isn't a valid.
 * 
 * Return value: The new #GnomeVFSAddress.
 *
 * Since: 2.8
 **/
GnomeVFSAddress *
gnome_vfs_address_new_from_string (const char *address)
{
	struct sockaddr_in sin;
#ifdef G_OS_WIN32
	int address_length;
#endif

#if (defined (G_OS_WIN32) || defined (HAVE_INET_PTON)) && defined (ENABLE_IPV6)
	struct sockaddr_in6 sin6;
#endif

	sin.sin_family = AF_INET;

#ifdef G_OS_WIN32
	address_length = SIN_LEN;
	if (WSAStringToAddress ((LPTSTR) address, AF_INET, NULL,
				(LPSOCKADDR) &sin.sin_addr,
				&address_length) == 0)
		return gnome_vfs_address_new_from_sockaddr (SA (&sin), SIN_LEN);
#  ifdef ENABLE_IPV6
	address_length = SIN6_LEN;
	if (WSAStringToAddress ((LPTSTR) address, AF_INET6, NULL,
				(LPSOCKADDR) &sin6.sin6_addr,
				&address_length) == 0) {
		sin6.sin6_family = AF_INET6;
		return gnome_vfs_address_new_from_sockaddr (SA (&sin6), SIN6_LEN);
	}
#  endif  /* ENABLE_IPV6 */

#elif defined (HAVE_INET_PTON)
	if (inet_pton (AF_INET, address, &sin.sin_addr) > 0)
		return gnome_vfs_address_new_from_sockaddr (SA (&sin), SIN_LEN);
#  ifdef ENABLE_IPV6		
	if (inet_pton (AF_INET6, address, &sin6.sin6_addr) > 0) {
		sin6.sin6_family = AF_INET6;
		return gnome_vfs_address_new_from_sockaddr (SA (&sin6), SIN6_LEN);
	}
#  endif /* ENABLE_IPV6 */

#elif defined (HAVE_INET_ATON)
	if (inet_aton (address, &sin.sin_addr) > 0)
		return gnome_vfs_address_new_from_sockaddr (SA (&sin), SIN_LEN);
#else
	if ((sin.sin_addr.s_addr = inet_addr (address)) != INADDR_NONE)
		return gnome_vfs_address_new_from_sockaddr (SA (&sin), SIN_LEN);
#endif	

	return NULL;
}
Exemplo n.º 4
0
int inet_pton(int af, const char *src, void *dst)
{
# ifdef WIN32
    /* As we already know, Microsoft always go its own way, so even if they do
     * provide IPv6, they don't provide the API. */
    struct sockaddr_storage addr;
    int len = sizeof( addr );

    /* Damn it, they didn't even put LPCSTR for the firs parameter!!! */
#ifdef UNICODE
    wchar_t *workaround_for_ill_designed_api =
        malloc( MAX_PATH * sizeof(wchar_t) );
    mbstowcs( workaround_for_ill_designed_api, src, MAX_PATH );
    workaround_for_ill_designed_api[MAX_PATH-1] = 0;
#else
    char *workaround_for_ill_designed_api = strdup( src );
#endif

    if( !WSAStringToAddress( workaround_for_ill_designed_api, af, NULL,
                             (LPSOCKADDR)&addr, &len ) )
    {
        free( workaround_for_ill_designed_api );
        return -1;
    }
    free( workaround_for_ill_designed_api );

    switch( af )
    {
        case AF_INET6:
            memcpy( dst, &((struct sockaddr_in6 *)&addr)->sin6_addr, 16 );
            break;

        case AF_INET:
            memcpy( dst, &((struct sockaddr_in *)&addr)->sin_addr, 4 );
            break;

        default:
            WSASetLastError( WSAEAFNOSUPPORT );
            return -1;
    }
# else
    /* Assume IPv6 is not supported. */
    /* Would be safer and more simpler to use inet_aton() but it is most
     * likely not provided either. */
    uint32_t ipv4;

    if( af != AF_INET )
    {
        errno = EAFNOSUPPORT;
        return -1;
    }

    ipv4 = inet_addr( src );
    if( ipv4 == INADDR_NONE )
        return -1;

    memcpy( dst, &ipv4, 4 );
# endif /* WIN32 */
    return 0;
}
Exemplo n.º 5
0
PHPAPI int inet_pton(int af, const char* src, void* dst)
{
	int address_length;
	struct sockaddr_storage sa;
	struct sockaddr_in *sin = (struct sockaddr_in *)&sa;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&sa;

	switch (af) {
		case AF_INET:
			address_length = sizeof (struct sockaddr_in);
			break;

		case AF_INET6:
			address_length = sizeof (struct sockaddr_in6);
			break;

		default:
			return -1;
	}

	if (WSAStringToAddress ((LPTSTR) src, af, NULL, (LPSOCKADDR) &sa, &address_length) == 0) {
		switch (af) {
			case AF_INET:
				memcpy (dst, &sin->sin_addr, sizeof (struct in_addr));
				break;

			case AF_INET6:
				memcpy (dst, &sin6->sin6_addr, sizeof (struct in6_addr));
				break;
		}
		return 1;
	}

	return 0;
}
Exemplo n.º 6
0
Arquivo: util.cpp Projeto: apprb/i2pd
int inet_pton(int af, const char *src, void *dst)
{ /* This function was written by Petar Korponai?. See
http://stackoverflow.com/questions/15660203/inet-pton-identifier-not-found */
    struct sockaddr_storage ss;
    int size = sizeof (ss);
    char src_copy[INET6_ADDRSTRLEN + 1];

    ZeroMemory (&ss, sizeof (ss));
    strncpy_s (src_copy, src, INET6_ADDRSTRLEN + 1);
    src_copy[INET6_ADDRSTRLEN] = 0;

    if (WSAStringToAddress (src_copy, af, NULL, (struct sockaddr *)&ss, &size) == 0)
    {
        switch (af)
        {
            case AF_INET:
                *(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
                return 1;
            case AF_INET6:
                *(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
                return 1;
        }
    }
    return 0;
}
Exemplo n.º 7
0
int win32_inet_pton(int af, const char * src, void * dst)
{
  struct sockaddr_in sa;
  int len = sizeof(SOCKADDR);
  int ret = -1;
  int strLen = strlen(src) + 1;
#ifdef UNICODE
  wchar_t *srcNonConst = (wchar_t *)malloc(strLen*sizeof(wchar_t));
  memset(srcNonConst, 0, strLen);
  MultiByteToWideChar(CP_ACP, 0, src, -1, srcNonConst, strLen);
#else
  char *srcNonConst = (char *)malloc(strLen);
  memset(srcNonConst, 0, strLen);
  strncpy(srcNonConst, src, strLen);
#endif

  if( WSAStringToAddress(srcNonConst,af,NULL,(LPSOCKADDR)&sa,&len) == 0 )
  {
	  ret = 1;
  }
  else
  {
    if(	WSAGetLastError() == WSAEINVAL )
    {
	    ret = -1;
    }
  }
  free(srcNonConst);
  memcpy(dst, &sa.sin_addr, sizeof(struct in_addr));
  return ret;
}
Exemplo n.º 8
0
int
inet_pton(int af, const char *src, void *dst)
{
    struct sockaddr_storage ss;
    int size = sizeof(ss);
    char src_copy[INET6_ADDRSTRLEN+1];

    ZeroMemory(&ss, sizeof(ss));
    /* stupid non-const API */
    strncpy(src_copy, src, INET6_ADDRSTRLEN+1);
    src_copy[INET6_ADDRSTRLEN] = 0;

    if (WSAStringToAddress(src_copy, af, NULL, (struct sockaddr *)&ss, &size) == 0)
    {
        switch (af) {
            case AF_INET:
                *(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
                return 1;

            case AF_INET6:
                *(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
                return 1;
        }
    }
    return 0;
}
Exemplo n.º 9
0
CoreExport int insp_inet_pton(int af, const char *src, void *dst)
{
	int address_length;
	sockaddr_storage sa;
	sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(&sa);
	sockaddr_in6* sin6 = reinterpret_cast<sockaddr_in6*>(&sa);

	switch (af)
	{
		case AF_INET:
			address_length = sizeof(sockaddr_in);
			break;
		case AF_INET6:
			address_length = sizeof(sockaddr_in6);
			break;
		default:
			return -1;
	}

	if (!WSAStringToAddress(static_cast<LPSTR>(const_cast<char *>(src)), af, NULL, reinterpret_cast<LPSOCKADDR>(&sa), &address_length))
	{
		switch (af)
		{
			case AF_INET:
				memcpy(dst, &sin->sin_addr, sizeof(in_addr));
				break;
			case AF_INET6:
				memcpy(dst, &sin6->sin6_addr, sizeof(in6_addr));
				break;
		}
		return 1;
	}
	
	return 0;
}
Exemplo n.º 10
0
void NetWorkInit(void)
{
	s32		nRet;
	s32		iLen = MAXADDRSTR;
	//Char	strDestMulti[]	= "127.0.0.1";
	u16		nDestPort		= 51122;
	
	nRet = _CheckWinsockVersion();
	CHECKRET(nRet);

	/*SOCKADDR_IN stDestAddr;
	nRet = WSAStringToAddress(strDestMulti, AF_INET, NULL, (LPSOCKADDR)&stDestAddr, &iLen);
	CHECKRET(nRet)*/

	nRet = WSAStringToAddress ( "127.0.0.1", AF_INET, NULL, (LPSOCKADDR)&g_stDestAddr, &iLen);
	CHECKRET(nRet)

	g_stDestAddr.sin_port = htons(52211);

	//Create socket
	g_hSock = WSASocket(AF_INET, SOCK_DGRAM,  IPPROTO_UDP, (LPWSAPROTOCOL_INFO)NULL, 0, 
						WSA_FLAG_OVERLAPPED/* | WSA_FLAG_MULTIPOINT_C_LEAF | WSA_FLAG_MULTIPOINT_D_LEAF*/);
	CHECKRET(g_hSock == INVALID_SOCKET)  

	g_hSSock = WSASocket(AF_INET, SOCK_DGRAM,  IPPROTO_UDP, (LPWSAPROTOCOL_INFO)NULL, 0, 
						WSA_FLAG_OVERLAPPED/* | WSA_FLAG_MULTIPOINT_C_LEAF | WSA_FLAG_MULTIPOINT_D_LEAF*/);
	CHECKRET(g_hSSock == INVALID_SOCKET) 

	g_stSrcAddr.sin_family = AF_INET;//PF_INET;
	g_stSrcAddr.sin_port = htons(nDestPort);
	g_stSrcAddr.sin_addr.s_addr = INADDR_ANY;
	nRet = bind(g_hSock, (struct sockaddr FAR *)&g_stSrcAddr, sizeof(struct sockaddr));
	CHECKRET(nRet == SOCKET_ERROR)

	/*s32		nIP_TTL = 1;
	DWORD	cbRet;
	nRet = WSAIoctl(g_hSock,SIO_MULTICAST_SCOPE,&nIP_TTL,sizeof(nIP_TTL),NULL,0,&cbRet,NULL,NULL);
	CHECKRET(nRet)

	bFlag = FALSE;
	nRet = WSAIoctl(g_hSock,SIO_MULTIPOINT_LOOPBACK,&bFlag,sizeof (bFlag),NULL,0,&cbRet,NULL,NULL);
	CHECKRET(nRet)*/
 
	/*stDestAddr.sin_family = PF_INET;
	nRet = WSAHtons(g_hSock, nDestPort, &(stDestAddr.sin_port));
	CHECKRET(nRet == SOCKET_ERROR)

	g_hNewSock = WSAJoinLeaf(g_hSock,(PSOCKADDR)&stDestAddr,sizeof(stDestAddr),NULL,NULL,NULL,NULL,JL_RECEIVER_ONLY);
	CHECKRET(g_hNewSock == INVALID_SOCKET)*/

	return;

Failed:
	WSACleanup();
	return;
}
Exemplo n.º 11
0
void FWebSocket::Connect(){
#if !PLATFORM_HTML5
	struct lws_client_connect_info ConnectInfo = {
			Context, TCHAR_TO_ANSI(*StrInetAddress), InetPort, false, "/", TCHAR_TO_ANSI(*StrInetAddress), TCHAR_TO_ANSI(*StrInetAddress), Protocols[1].name, -1, this
	};
	Wsi = lws_client_connect_via_info(&ConnectInfo);
	check(Wsi);

#else // PLATFORM_HTML5

	SockFd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (SockFd == -1) {
		UE_LOG(LogHTML5Networking, Error, TEXT("Socket creationg failed "));
	}
	else
	{
		UE_LOG(LogHTML5Networking, Warning, TEXT(" Socked %d created "), SockFd);
	}

	fcntl(SockFd, F_SETFL, O_NONBLOCK);

#endif

	// Windows XP does not have support for inet_pton
#if PLATFORM_WINDOWS && _WIN32_WINNT <= 0x0502
	memset(&RemoteAddr, 0, sizeof(RemoteAddr));
	int32 SizeOfRemoteAddr = sizeof(RemoteAddr);

	// Force ServerAddress into non-const array. API doesn't modify contents but old API still requires non-const string
	if (WSAStringToAddress(StrInetAddress.GetCharArray().GetData(), AF_INET, NULL, (sockaddr*)&RemoteAddr, &SizeOfRemoteAddr) != 0)
	{
		UE_LOG(LogHTML5Networking, Warning, TEXT("WSAStringToAddress failed "));
		return;
	}

	RemoteAddr.sin_family = AF_INET;
	RemoteAddr.sin_port = htons(InetPort);
#else
	memset(&RemoteAddr, 0, sizeof(RemoteAddr));
	RemoteAddr.sin_family = AF_INET;
	RemoteAddr.sin_port = htons(InetPort);

	if (inet_pton(AF_INET, TCHAR_TO_ANSI(*StrInetAddress), &RemoteAddr.sin_addr) != 1)
	{
		UE_LOG(LogHTML5Networking, Warning, TEXT("inet_pton failed "));
		return;
	}
#endif

#if PLATFORM_HTML5
	int Ret = connect(SockFd, (struct sockaddr *)&RemoteAddr, sizeof(RemoteAddr));
	UE_LOG(LogHTML5Networking, Warning, TEXT(" Connect socket returned %d"), Ret);
#endif

	IsDestroyed = false; 
}
Exemplo n.º 12
0
Arquivo: ssq.c Projeto: mpapierski/ssq
BOOL WINAPI SSQ_GetIpPort(char* address,PSOCKADDR socket_address)
{
	static char temp_address[256];
	static int length = sizeof(*socket_address);
	static char* port_string;
	static LPADDRINFO response;

	if(HIWORD(address)==0||lstrlen(address)>=sizeof(temp_address)||HIWORD(socket_address)==0)
	{
		SSQ_OutputDebugString(INTERNAL_SSQ_GET_IP_PORT,0,0,0);

		return FALSE;
	}
	else if(lstrcpy(temp_address,address)==0)
	{
		SSQ_OutputDebugString(INTERNAL_SSQ_GET_IP_PORT,0,0,(DWORD)lstrcpy);

		return FALSE;
	}
	else if(WSAStringToAddress(temp_address,AF_INET,0,socket_address,&length)==SOCKET_ERROR)
	{
		if(WSAGetLastError()==WSAEINVAL)
		{
			port_string = &temp_address[lstrlen(temp_address)-1];

			while(*port_string!=':'&&port_string>temp_address)
			{
				port_string--;
			}

			*port_string = 0;
			port_string++;

			if(getaddrinfo(temp_address,port_string,0,&response)!=0)
			{
				SSQ_OutputDebugString(INTERNAL_SSQ_GET_IP_PORT,1,0,(DWORD)getaddrinfo);

				return FALSE;
			}

			memcpy(socket_address,response->ai_addr,sizeof(*socket_address));
			freeaddrinfo(response);
		}
		else
		{
			SSQ_OutputDebugString(INTERNAL_SSQ_GET_IP_PORT,1,0,(DWORD)WSAStringToAddress);

			return FALSE;
		}
	}

	return TRUE;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
bool IOCP_Manager::Initialize()
{
    SYSTEM_INFO SystemInfo;
    GetSystemInfo(&SystemInfo);
    mIoThreadCount = SystemInfo.dwNumberOfProcessors * 2;

    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        printf_s("WSAStartup Error\n");
        return false;
    }

    mCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, mIoThreadCount);
    if (mCompletionPort == NULL)
    {
        printf_s("Create CompletionPort error\n");
        return false;
    }

    mListenSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, WSA_FLAG_OVERLAPPED);
    if (mListenSocket == INVALID_SOCKET)
    {
        printf_s("Create ListenSocket Error\n");
        return false;
    }

    int opt = 1;
    setsockopt(mListenSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(int));

    SOCKADDR_IN ServerAddr;
    int SizeServerAddr = sizeof(SOCKADDR_IN);
    memset(&ServerAddr, 0, SizeServerAddr);
    if (WSAStringToAddress(L"127.0.0.1:9001", AF_INET, NULL, (SOCKADDR*)&ServerAddr, &SizeServerAddr) == SOCKET_ERROR)
    {
        printf_s("ServerAddress Setting Error\n");
        return false;
    }

    if (bind(mListenSocket, (SOCKADDR*)&ServerAddr, SizeServerAddr) == SOCKET_ERROR)
    {
        printf_s("Bind Error\n");
        return false;
    }

    return true;
}
Exemplo n.º 15
0
int Evinet_pton(int af, const char *src, void *dst)
{
	if(!src || !dst || !(af == EV_AF_INET || af == EV_AF_INET6))
		return 0;

	if(af == EV_AF_INET)
	{
		*(unsigned long*)dst = Evinet_addr(src);

		if(*(unsigned long*)dst == EV_INADDR_NONE)
			return 0;
		
		return 1;
	}
	else if(af == EV_AF_INET6)
	{
		struct sockaddr_in6	sa6 = {0};
		int len = sizeof(sa6);
		
		sa6.sin6_family = AF_INET6;

	/* TLE : The following code does not compile for WM5 : not useful according to msdn */
	/*#ifdef _WIN32_WCE
		USES_CONVERSION;
		if (WSAStringToAddress(A2W(src), AF_INET6, NULL,
					(struct sockaddr*) &sa6, &len) != 0) 
		{
			return 0;
		}
	#else*/

		if (WSAStringToAddress(src, AF_INET6, NULL,
					(struct sockaddr*) &sa6, &len) != 0) 
		{
			return 0;
		}
	/* #endif */

		Evmemcpy(dst, &sa6.sin6_addr, sizeof(sa6.sin6_addr));
		return 1;
	}

	return 0;
}
Exemplo n.º 16
0
static int bind_socket (os_socket socket, unsigned short port, const char * address)
{
  int rc;
#if OS_SOCKET_HAS_IPV6
  if (config.useIpv6)
  {
    os_sockaddr_in6 socketname;
    memset (&socketname, 0, sizeof (socketname));
    socketname.sin6_family = AF_INET6;
    socketname.sin6_port = htons (port);
    if (address)
    {
#ifdef WIN32
      int sslen = sizeof (socketname);
      WSAStringToAddress ((LPTSTR) address, AF_INET6, NULL, (os_sockaddr*) &socketname, &sslen);
#else
      inet_pton (AF_INET6, address, &(socketname.sin6_addr));
#endif
    }
    else
    {
      socketname.sin6_addr = os_in6addr_any;
    }
    rc = os_sockBind (socket, (struct sockaddr *) &socketname, sizeof (socketname));
  }
  else
#endif
  {
    struct sockaddr_in socketname;
    socketname.sin_family = AF_INET;
    socketname.sin_port = htons (port);
    socketname.sin_addr.s_addr = (address == NULL) ? htonl (INADDR_ANY) : inet_addr (address);
    rc = os_sockBind (socket, (struct sockaddr *) &socketname, sizeof (socketname));
  }
  if (rc != os_resultSuccess)
  {
    if (os_sockError () != os_sockEADDRINUSE)
      print_sockerror ("bind");
    return -1;
  }
  return 0;
}
Exemplo n.º 17
0
Arquivo: ip.cpp Projeto: jdourlens/Zia
    void	packIP(char const* src, void* dst)
    {
#ifdef __unix__
      if (inet_pton(AF_INET, src, dst) <= 0)
	{
	  printf("inet_pton failed\n");
	  throw std::exception();
	}
#elif defined _WIN32
      int			len;
      SOCKADDR			addr;

      len = sizeof(SOCKADDR);
      if (WSAStringToAddress(const_cast<char*>(src), AF_INET, NULL, &addr, &len) == SOCKET_ERROR) {
	printf("pack ip wsa strig to address%d\n", WSAGetLastError());
	throw std::exception();
      }
      LPSOCKADDR_IN a = reinterpret_cast<LPSOCKADDR_IN>(&addr);
      memcpy(dst, &a->sin_addr, 8);
#endif
    }
Exemplo n.º 18
0
bool StringToIp(const char *IP, int Family, sockaddr *SockAddr, socklen_t Length) {
	memset(SockAddr, 0, Length);

#ifdef _WIN32
	socklen_t *LengthPtr = &Length;

	if (WSAStringToAddress(const_cast<char *>(IP), Family, NULL, SockAddr, LengthPtr) != 0) {
		return false;
	}
#else
	if (Length < SOCKADDR_LEN(Family)) {
		return false;
	}

	if (inet_pton(Family, IP, SockAddr) <= 0) {
		return false;
	}
#endif

	return true;
}
Exemplo n.º 19
0
/* 
 * convert from presentation format (which usually means ASCII printable)
 *    to network format (which is usually some kind of binary format).
 *
 * return:
 *    1 if the address was valid for the specified address family
 *    0 if the address wasn't valid (`dst' is untouched in this case)
 *    -1 if some other error occurred (`dst' is untouched in this case, too)
 */
int ompi_inet_pton(int af, const char *src, void *dst)
{
    int addr_len;
    struct sockaddr sa;
    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);
        break;

    case AF_INET6:
        addr_len = sizeof(struct sockaddr_in6);
        break;

    default:
        return -1;
    }

    if ( 0 == WSAStringToAddress ((LPTSTR) src, af, NULL, (LPSOCKADDR) &sa, &addr_len )) {
        switch (af) {
        case AF_INET:
            memcpy (dst, &sin->sin_addr, sizeof(struct in_addr));
            break;

        case AF_INET6:
            memcpy (dst, &sin6->sin6_addr, sizeof(struct in6_addr));
            break;
        }
        return 1;
    } else {
        opal_output(0, "WSAStringToAddress failed %s:%d. Error code: %d", __FILE__, __LINE__, GetLastError());
        return 0;
    }
}
Exemplo n.º 20
0
bool IPV6Address::setIPAddress(const char *host)
{
	if(!host)
		return false;

	struct in6_addr l_addr;

#ifdef	WIN32
	struct sockaddr saddr;
	int slen = sizeof(saddr);
	struct sockaddr_in6 *paddr = (struct sockaddr_in6 *)&saddr;
	int ok = WSAStringToAddress((LPSTR)host, AF_INET6, NULL, &saddr, &slen);
	l_addr = paddr->sin6_addr;
#else
	int ok = inet_pton(AF_INET6, host, &l_addr);
#endif
	if ( validator )
		(*validator)(l_addr);
	if ( !ok )
		return false;
	*this = l_addr;
	return true;
}
Exemplo n.º 21
0
    Address&
    Address::operator=(const char* address)
    {
      m_resolved = true;

#if defined(DUNE_SYS_HAS_INET_PTON)
      if (inet_pton(AF_INET, address, &m_ia.s_addr) > 0)
        return *this;

#elif defined(DUNE_SYS_HAS_INET_ATON)
      if (inet_aton(address, &m_ia.s_addr) == 1)
        return *this;

#elif defined(DUNE_SYS_HAS_WSA_STRING_TO_ADDRESS)
      SOCKADDR_IN sin;
      sin.sin_family = AF_INET;
      int len = sizeof(SOCKADDR_IN);
      if (WSAStringToAddress((char*)address, AF_INET, 0, (SOCKADDR*)&sin, &len) == 0)
      {
        m_ia.s_addr = sin.sin_addr.s_addr;
        return *this;
      }

#elif defined(DUNE_SYS_HAS_INET_ADDR)
      uint32_t rv = inet_addr(address);
      if (rv != INADDR_NONE)
      {
        m_ia.s_addr = rv;
        return *this;
      }
#endif
      m_resolved = false;
      m_host = address;
      std::memset(&m_ia, 0, sizeof(in_addr));
      resolve();
      return *this;
    }
Exemplo n.º 22
0
/*
 * Convert text to IPv4/IPv6 address.
 */
PJ_DEF(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst)
{
    char tempaddr[PJ_INET6_ADDRSTRLEN];

    PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EAFNOTSUP);
    PJ_ASSERT_RETURN(src && src->slen && dst, PJ_EINVAL);

    /* Initialize output with PJ_IN_ADDR_NONE for IPv4 (to be 
     * compatible with pj_inet_aton()
     */
    if (af==PJ_AF_INET) {
	((pj_in_addr*)dst)->s_addr = PJ_INADDR_NONE;
    }

    /* Caution:
     *	this function might be called with cp->slen >= 46
     *  (i.e. when called with hostname to check if it's an IP addr).
     */
    if (src->slen >= PJ_INET6_ADDRSTRLEN) {
	return PJ_ENAMETOOLONG;
    }

    pj_memcpy(tempaddr, src->ptr, src->slen);
    tempaddr[src->slen] = '\0';

#if defined(PJ_SOCK_HAS_INET_PTON) && PJ_SOCK_HAS_INET_PTON != 0
    /*
     * Implementation using inet_pton()
     */
    if (inet_pton(af, tempaddr, dst) != 1) {
	pj_status_t status = pj_get_netos_error();
	if (status == PJ_SUCCESS)
	    status = PJ_EUNKNOWN;

	return status;
    }

    return PJ_SUCCESS;

#elif defined(PJ_WIN32) || defined(PJ_WIN32_WINCE)
    /*
     * Implementation on Windows, using WSAStringToAddress().
     * Should also work on Unicode systems.
     */
    {
	PJ_DECL_UNICODE_TEMP_BUF(wtempaddr,PJ_INET6_ADDRSTRLEN)
	pj_sockaddr sock_addr;
	int addr_len = sizeof(sock_addr);
	int rc;

	sock_addr.addr.sa_family = (pj_uint16_t)af;
	rc = WSAStringToAddress(
		PJ_STRING_TO_NATIVE(tempaddr,wtempaddr,sizeof(wtempaddr)), 
		af, NULL, (LPSOCKADDR)&sock_addr, &addr_len);
	if (rc != 0) {
	    /* If you get rc 130022 Invalid argument (WSAEINVAL) with IPv6,
	     * check that you have IPv6 enabled (install it in the network
	     * adapter).
	     */
	    pj_status_t status = pj_get_netos_error();
	    if (status == PJ_SUCCESS)
		status = PJ_EUNKNOWN;

	    return status;
	}

	if (sock_addr.addr.sa_family == PJ_AF_INET) {
	    pj_memcpy(dst, &sock_addr.ipv4.sin_addr, 4);
	    return PJ_SUCCESS;
	} else if (sock_addr.addr.sa_family == PJ_AF_INET6) {
	    pj_memcpy(dst, &sock_addr.ipv6.sin6_addr, 16);
	    return PJ_SUCCESS;
	} else {
	    pj_assert(!"Shouldn't happen");
	    return PJ_EBUG;
	}
    }
#elif !defined(PJ_HAS_IPV6) || PJ_HAS_IPV6==0
    /* IPv6 support is disabled, just return error without raising assertion */
    return PJ_EIPV6NOTSUP;
#else
    pj_assert(!"Not supported");
    return PJ_EIPV6NOTSUP;
#endif
}
Exemplo n.º 23
0
int redisContextConnectTcp(redisContext *c, const char *addr, int port, struct timeval *timeout) {
    int s;
    int blocking = (c->flags & REDIS_BLOCK);
    struct sockaddr_in sa;
#ifdef HIREDIS_WIN
    int ssa = sizeof(sa);
    char buf[255];
    snprintf(buf, 255, "%s:%d", addr, port);
#endif
    
    if ((s = redisCreateSocket(c,AF_INET)) < 0)
        return REDIS_ERR;
    if (redisSetBlocking(c,s,0) != REDIS_OK)
        return REDIS_ERR;

    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
#ifdef HIREDIS_WIN
    if (WSAStringToAddress(buf, AF_INET, NULL, (LPSOCKADDR)&sa, &ssa) == 0) {
#else
    if (inet_pton(AF_INET, addr, &sa.sin_addr) == 0) {
#endif      
        struct hostent *he;

        he = gethostbyname(addr);
        if (he == NULL) {
            char buf[128];
            snprintf(buf,sizeof(buf),"Can't resolve: %s", addr);
            __redisSetError(c,REDIS_ERR_OTHER,buf);
            close(s);
            return REDIS_ERR;
        }
        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
    }
#ifdef HIREDIS_WIN
    else {
      int wserr = WSAGetLastError();
      switch (wserr) {
      case WSAEFAULT:
        printf("The specified Address buffer is too small. Pass in a larger buffer.");
        break;
      case WSAEINVAL:
        printf("Unable to translate the string into a sockaddr.");
        break;
      case WSANOTINITIALISED:
        printf("ws2.dll has not been initialized. The application must first call WSAStartup before calling any Windows Sockets functions.");
        break;
      case WSA_NOT_ENOUGH_MEMORY:
        printf("There was insufficient memory to perform the operation.");
        break;
      default:
        break;
      }
    }
#endif
      
    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        SETERRNO;
        if (errno == EINPROGRESS && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,s,timeout) != REDIS_OK)
                return REDIS_ERR;
        }
    }

    /* Reset socket to be blocking after connect(2). */
    if (blocking && redisSetBlocking(c,s,1) != REDIS_OK)
        return REDIS_ERR;

    if (redisSetTcpNoDelay(c,s) != REDIS_OK)
        return REDIS_ERR;

    c->fd = s;
    c->flags |= REDIS_CONNECTED;
    return REDIS_OK;
}

#ifndef HIREDIS_WIN
int redisContextConnectUnix(redisContext *c, const char *path, struct timeval *timeout) {
    int s;
    int blocking = (c->flags & REDIS_BLOCK);
    struct sockaddr_un sa;

    if ((s = redisCreateSocket(c,AF_LOCAL)) < 0)
        return REDIS_ERR;
    if (redisSetBlocking(c,s,0) != REDIS_OK)
        return REDIS_ERR;

    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,s,timeout) != REDIS_OK)
                return REDIS_ERR;
        }
    }

    /* Reset socket to be blocking after connect(2). */
    if (blocking && redisSetBlocking(c,s,1) != REDIS_OK)
        return REDIS_ERR;

    c->fd = s;
    c->flags |= REDIS_CONNECTED;
    return REDIS_OK;
}
Exemplo n.º 24
0
int main(int argc, char *argv[])
{
	int retval;

	// 윈속 초기화
	WSADATA wsa;
	if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
		return 1;

	// socket()
	SOCKET sock = socket(AF_INET6, SOCK_DGRAM, 0);
	if(sock == INVALID_SOCKET) err_quit("socket()");

	// SO_REUSEADDR 옵션 설정
	BOOL optval = TRUE;
	retval = setsockopt(sock, SOL_SOCKET,
		SO_REUSEADDR, (char *)&optval, sizeof(optval));
	if(retval == SOCKET_ERROR) err_quit("setsockopt()");

	// bind()
	SOCKADDR_IN6 localaddr;
	ZeroMemory(&localaddr, sizeof(localaddr));
	localaddr.sin6_family = AF_INET6;
	localaddr.sin6_addr = in6addr_any;
	localaddr.sin6_port = htons(LOCALPORT);
	retval = bind(sock, (SOCKADDR *)&localaddr, sizeof(localaddr));
	if(retval == SOCKET_ERROR) err_quit("bind()");

	// 주소 변환(문자열 -> IPv6)
	SOCKADDR_IN6 tmpaddr;
	int addrlen = sizeof(tmpaddr);
	WSAStringToAddress(MULTICASTIP, AF_INET6, NULL,
		(SOCKADDR *)&tmpaddr, &addrlen);

	// 멀티캐스트 그룹 가입
	struct ipv6_mreq mreq;
	mreq.ipv6mr_multiaddr = tmpaddr.sin6_addr;
	mreq.ipv6mr_interface = 0;
	retval = setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
		(char *)&mreq, sizeof(mreq));
	if(retval == SOCKET_ERROR) err_quit("setsockopt()");

	// 데이터 통신에 사용할 변수
	SOCKADDR_IN6 peeraddr;
	char buf[BUFSIZE+1];

	// 멀티캐스트 데이터 받기
	while(1){
		// 데이터 받기
		addrlen = sizeof(peeraddr);
		retval = recvfrom(sock, buf, BUFSIZE, 0,
			(SOCKADDR *)&peeraddr, &addrlen);
		if(retval == SOCKET_ERROR){
			err_display("recvfrom()");
			continue;
		}

		// 주소 변환(IPv6 -> 문자열)
		char ipaddr[50];
		DWORD ipaddrlen = sizeof(ipaddr);
		WSAAddressToString((SOCKADDR *)&peeraddr, sizeof(peeraddr),
			NULL, ipaddr, &ipaddrlen);

		// 받은 데이터 출력
		buf[retval] = '\0';
		printf("[UDP/%s] %s\n", ipaddr, buf);
	}

	// 멀티캐스트 그룹 탈퇴
	retval = setsockopt(sock, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
		(char *)&mreq, sizeof(mreq));
	if(retval == SOCKET_ERROR) err_quit("setsockopt()");

	// closesocket()
	closesocket(sock);

	// 윈속 종료
	WSACleanup();
	return 0;
}
Exemplo n.º 25
0
int mad_rlc_process_rx_sp(alc_session_t *s) {

  static char addrs[MAX_CHANNELS_IN_SESSION][INET6_ADDRSTRLEN];	/* multicast addresses */
  static char ports[MAX_CHANNELS_IN_SESSION][MAX_PORT_LENGTH];	/* local port numbers  */

  struct sockaddr_in ipv4;
  struct sockaddr_in6 ipv6;

#ifdef _MSC_VER
  int addr_size;
#endif

  int retcode;
  
  int retval = 0;
  
  if(s->rlc->rx_nblost_since_sp <= s->rlc->loss_accepted
     && s->rlc->rx_nblate_since_sp <= s->rlc->late_accepted) {
    
    if(s->addr_family == PF_INET) {
      if(s->addr_type == 1) {
	ipv4.sin_addr.s_addr = htonl(ntohl(inet_addr(s->ch_list[s->nb_channel - 1]->addr)));
      }
      else {
	ipv4.sin_addr.s_addr = htonl(ntohl(inet_addr(s->ch_list[s->nb_channel - 1]->addr)) + 1);
      }
      
      memset(addrs[s->nb_channel], 0, INET6_ADDRSTRLEN);
      sprintf(addrs[s->nb_channel], "%s", inet_ntoa(ipv4.sin_addr));
      
      memset(ports[s->nb_channel], 0, MAX_PORT_LENGTH);
      sprintf(ports[s->nb_channel], "%i", (atoi(s->ch_list[s->nb_channel - 1]->port) + 1));
    }
    else if(s->addr_family == PF_INET6) {
      
#ifdef _MSC_VER
	addr_size = sizeof(struct sockaddr_in6);
	WSAStringToAddress((char*)s->ch_list[s->nb_channel - 1]->addr, AF_INET6, NULL, (struct sockaddr*)&ipv6, &addr_size);
#else 
	inet_pton(AF_INET6, s->ch_list[s->nb_channel - 1]->addr, &ipv6.sin6_addr);
#endif

      if(s->addr_type == 0) {
	if(increase_ipv6_address(&ipv6.sin6_addr) == -1) {
	  printf("Increasing IPv6 address %s is not possible\n", s->ch_list[s->nb_channel - 1]->addr);
	  return -1;
	}
      }
      
      memset(addrs[s->nb_channel], 0, INET6_ADDRSTRLEN);

#ifdef _MSC_VER
	  addr_size = sizeof(addrs[s->nb_channel]);
      WSAAddressToString((struct sockaddr*)&ipv6, sizeof(struct sockaddr_in6),
			NULL, addrs[s->nb_channel], &addr_size);
#else
	  inet_ntop(AF_INET6, &ipv6.sin6_addr, addrs[s->nb_channel], sizeof(addrs[s->nb_channel]));
#endif
      
      memset(ports[s->nb_channel], 0, MAX_PORT_LENGTH);
      sprintf(ports[s->nb_channel], "%i", (atoi(s->ch_list[s->nb_channel - 1]->port) + 1));
    }
    
    retcode = add_alc_channel(s->s_id, ports[s->nb_channel], addrs[s->nb_channel],
			      s->ch_list[s->nb_channel - 1]->intface,
			      s->ch_list[s->nb_channel - 1]->intface_name);
    
    if(!(retcode < 0)) {
      s->rlc->rx_nblost_since_sp = 0;
      s->rlc->rx_nblate_since_sp = 0;
      retval = 1;
    }
  }
  
  return retval;
}
Exemplo n.º 26
0
DWORD WINAPI RTMPPublisher::CreateConnectionThread(RTMPPublisher *publisher)
{
    //------------------------------------------------------
    // set up URL

    bool bRetry = false;
    bool bSuccess = false;
    bool bCanRetry = false;

    String failReason;
    String strBindIP;

    int    serviceID    = AppConfig->GetInt   (TEXT("Publish"), TEXT("Service"));
    String strURL       = AppConfig->GetString(TEXT("Publish"), TEXT("URL"));
    String strPlayPath  = AppConfig->GetString(TEXT("Publish"), TEXT("PlayPath"));

    strURL.KillSpaces();
    strPlayPath.KillSpaces();

    LPSTR lpAnsiURL = NULL, lpAnsiPlaypath = NULL;
    RTMP *rtmp = NULL;

    //--------------------------------
    // unbelievably disgusting hack for elgato devices

    String strOldDirectory;
    UINT dirSize = GetCurrentDirectory(0, 0);
    strOldDirectory.SetLength(dirSize);
    GetCurrentDirectory(dirSize, strOldDirectory.Array());

    OSSetCurrentDirectory(API->GetAppPath());

    //--------------------------------

    if(!strURL.IsValid())
    {
        failReason = TEXT("No server specified to connect to");
        goto end;
    }

    if(serviceID != 0)
    {
        XConfig serverData;
        if(!serverData.Open(TEXT("services.xconfig")))
        {
            failReason = TEXT("Could not open services.xconfig");
            goto end;
        }

        XElement *services = serverData.GetElement(TEXT("services"));
        if(!services)
        {
            failReason = TEXT("Could not find any services in services.xconfig");
            goto end;
        }

        XElement *service = NULL;
        DWORD numServices = services->NumElements();
        for(UINT i=0; i<numServices; i++)
        {
            XElement *curService = services->GetElementByID(i);
            if(curService->GetInt(TEXT("id")) == serviceID)
            {
                service = curService;
                break;
            }
        }

        if(!service)
        {
            failReason = TEXT("Could not find the service specified in services.xconfig");
            goto end;
        }

        XElement *servers = service->GetElement(TEXT("servers"));
        if(!servers)
        {
            failReason = TEXT("Could not find any servers for the service specified in services.xconfig");
            goto end;
        }

        XDataItem *item = servers->GetDataItem(strURL);
        if(!item)
            item = servers->GetDataItemByID(0);

        strURL = item->GetData();

        Log(TEXT("Using RTMP service: %s"), service->GetName());
        Log(TEXT("  Server selection: %s"), strURL.Array());
    }

    //------------------------------------------------------
    // now back to the elgato directory if it needs the directory changed still to function *sigh*

    OSSetCurrentDirectory(strOldDirectory);

    //------------------------------------------------------

    rtmp = RTMP_Alloc();
    RTMP_Init(rtmp);

    RTMP_LogSetCallback(librtmpErrorCallback);

    //RTMP_LogSetLevel(RTMP_LOGERROR);

    lpAnsiURL = strURL.CreateUTF8String();
    lpAnsiPlaypath = strPlayPath.CreateUTF8String();

    if(!RTMP_SetupURL2(rtmp, lpAnsiURL, lpAnsiPlaypath))
    {
        failReason = Str("Connection.CouldNotParseURL");
        goto end;
    }

    char *rtmpUser = AppConfig->GetString(TEXT("Publish"), TEXT("Username")).CreateUTF8String();
    char *rtmpPass = AppConfig->GetString(TEXT("Publish"), TEXT("Password")).CreateUTF8String();

    if (rtmpUser)
    {
        rtmp->Link.pubUser.av_val = rtmpUser;
        rtmp->Link.pubUser.av_len = (int)strlen(rtmpUser);
    }

    if (rtmpPass)
    {
        rtmp->Link.pubPasswd.av_val = rtmpPass;
        rtmp->Link.pubPasswd.av_len = (int)strlen(rtmpPass);
    }

    RTMP_EnableWrite(rtmp); //set it to publish

    rtmp->Link.swfUrl.av_len = rtmp->Link.tcUrl.av_len;
    rtmp->Link.swfUrl.av_val = rtmp->Link.tcUrl.av_val;
    /*rtmp->Link.pageUrl.av_len = rtmp->Link.tcUrl.av_len;
    rtmp->Link.pageUrl.av_val = rtmp->Link.tcUrl.av_val;*/
    rtmp->Link.flashVer.av_val = "FMLE/3.0 (compatible; FMSc/1.0)";
    rtmp->Link.flashVer.av_len = (int)strlen(rtmp->Link.flashVer.av_val);

    //-----------------------------------------

    UINT tcpBufferSize = AppConfig->GetInt(TEXT("Publish"), TEXT("TCPBufferSize"), 64*1024);

    if(tcpBufferSize < 8192)
        tcpBufferSize = 8192;
    else if(tcpBufferSize > 1024*1024)
        tcpBufferSize = 1024*1024;

    rtmp->m_outChunkSize = 4096;//RTMP_DEFAULT_CHUNKSIZE;//
    rtmp->m_bSendChunkSizeInfo = TRUE;

    rtmp->m_bUseNagle = TRUE;

    strBindIP = AppConfig->GetString(TEXT("Publish"), TEXT("BindToIP"), TEXT("Default"));
    if (scmp(strBindIP, TEXT("Default")))
    {
        rtmp->m_bindIP.addr.sin_family = AF_INET;
        rtmp->m_bindIP.addrLen = sizeof(rtmp->m_bindIP.addr);
        if (WSAStringToAddress(strBindIP.Array(), AF_INET, NULL, (LPSOCKADDR)&rtmp->m_bindIP.addr, &rtmp->m_bindIP.addrLen) == SOCKET_ERROR)
        {
            // no localization since this should rarely/never happen
            failReason = TEXT("WSAStringToAddress: Could not parse address");
            goto end;
        }
    }

    LogInterfaceType(rtmp);

    //-----------------------------------------

    if(!RTMP_Connect(rtmp, NULL))
    {
        failReason = Str("Connection.CouldNotConnect");
        failReason << TEXT("\r\n\r\n") << RTMPPublisher::GetRTMPErrors();
        bCanRetry = true;
        goto end;
    }

    if(!RTMP_ConnectStream(rtmp, 0))
    {
        failReason = Str("Connection.InvalidStream");
        failReason << TEXT("\r\n\r\n") << RTMPPublisher::GetRTMPErrors();
        bCanRetry = true;
        goto end;
    }

    //-----------------------------------------

    OSDebugOut(TEXT("Connected: %u\r\n"), OSGetTime());

    publisher->RequestKeyframe(1000);

    //-----------------------------------------

    bSuccess = true;

end:

    if (lpAnsiURL)
        Free(lpAnsiURL);

    if (lpAnsiPlaypath)
        Free(lpAnsiPlaypath);

    if(!bSuccess)
    {
        if(rtmp)
        {
            RTMP_Close(rtmp);
            RTMP_Free(rtmp);
        }

        if(failReason.IsValid())
            App->SetStreamReport(failReason);

        if(!publisher->bStopping)
            PostMessage(hwndMain, OBS_REQUESTSTOP, bCanRetry ? 0 : 1, 0);

        Log(TEXT("Connection to %s failed: %s"), strURL.Array(), failReason.Array());

        publisher->bStopping = true;
    }
    else
    {
        publisher->Init(rtmp, tcpBufferSize);
        publisher->bConnected = true;
        publisher->bConnecting = false;
    }

    return 0;
}
Exemplo n.º 27
0
int comms_init(struct th_data *data) {
	INT ret;
	DWORD err;
#if HAVE_GETADDRINFO

	odprintf("comms[init]: node=%s service=%s", data->node, data->service);

	data->hbuf[0] = 0;
	data->sbuf[0] = 0;
	data->addrs_res = NULL;
	data->addrs_cur = NULL;

	data->hints.ai_flags = 0;
	data->hints.ai_family = AF_UNSPEC;
	data->hints.ai_socktype = SOCK_STREAM;
	data->hints.ai_protocol = IPPROTO_TCP;
	data->hints.ai_addrlen = 0;
	data->hints.ai_addr = NULL;
	data->hints.ai_canonname = NULL;
	data->hints.ai_next = NULL;

	SetLastError(0);
	ret = getaddrinfo(data->node, data->service, &data->hints, &data->addrs_res);
	err = GetLastError();
	odprintf("getaddrinfo: %d (%d)", ret, err);
	if (ret != 0) {
		mbprintf(TITLE, MB_OK|MB_ICONERROR, "Unable to resolve node \"%s\" service \"%s\" (%d)", data->node, data->service, ret);
		return 1;
	}

	if (data->addrs_res == NULL) {
		odprintf("no results");
		mbprintf(TITLE, MB_OK|MB_ICONERROR, "No results resolving node \"%s\" service \"%s\"", data->node, data->service);
		return 1;
	}

	data->addrs_cur = data->addrs_res;
#else
	int sa4_len = sizeof(data->sa4);
	int sa6_len = sizeof(data->sa6);

	odprintf("comms[init]: node=%s service=%s", data->node, data->service);

	data->family = AF_UNSPEC;
	data->sa = NULL;
	data->sa_len = 0;

	SetLastError(0);
	ret = WSAStringToAddress(data->node, AF_INET, NULL, (LPSOCKADDR)&data->sa4, &sa4_len);
	err = GetLastError();
	odprintf("WSAStringToAddress[IPv4]: %d (%ld)", ret, err);
	if (ret == 0) {
		data->family = AF_INET;
		data->sa4.sin_family = AF_INET;
		data->sa4.sin_port = htons(strtoul(data->service, NULL, 10));

		data->sa = (struct sockaddr*)&data->sa4;
		data->sa_len = sa4_len;
	}

	SetLastError(0);
	ret = WSAStringToAddress(data->node, AF_INET6, NULL, (LPSOCKADDR)&data->sa6, &sa6_len);
	err = GetLastError();
	odprintf("WSAStringToAddress[IPv6]: %d (%ld)", ret, err);
	if (ret == 0) {
		data->family = AF_INET6;
		data->sa6.sin6_family = AF_INET6;
		data->sa6.sin6_port = htons(strtoul(data->service, NULL, 10));

		data->sa = (struct sockaddr*)&data->sa6;
		data->sa_len = sa6_len;
	}

	odprintf("family=%d", data->family);
	if (data->family == AF_UNSPEC) {
		mbprintf(TITLE, MB_OK|MB_ICONERROR, "Unable to connect: Invalid IP \"%s\"", data->node);
		return 1;
	}
#endif

	data->s = INVALID_SOCKET;
	return 0;
}
Exemplo n.º 28
0
int StartServer(HWND hWnd,serverStruct *server)
{
	sockaddr_in sAddr;
	char strPortNo[10]="";
	WORD wVersionRequested = MAKEWORD(2, 2);
	WSADATA wsaData;
	BOOLEAN bOptVal = TRUE;
	int wsaError=0;
	int ipSize=INET_ADDRSTRLEN;

	TCHAR hostName[50];

	DisplayError(NULL,TEXT(__FUNCSIG__),0,LOG,NOTICE);

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

	if ((WSAStartup(wVersionRequested, &wsaData) != 0) || //not correct Winsock version
		(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2))
	{
		WSACleanup();
		wsaError=WSAGetLastError();
		DisplayError(NULL,TEXT("Error in StartServer - WSA Start-up "),wsaError,ALL,ERRORFOUND);
		return wsaError;
	}

	_tcscpy(hostName,TEXT(""));

	if(GetHostNameW(hostName,50)!=SOCKET_ERROR)
	{
		TCHAR hostNameEXT[50];
		StringCbPrintf(hostNameEXT,100,_T("Server on hostname: %s"),hostName);
		DisplayError(NULL,hostNameEXT,0,LOG,NOTICE);
	}
	else
		DisplayError(NULL,TEXT("Can't get host"),WSAGetLastError(),LOG|POPMSG,ERRORFOUND);

	WSAStringToAddress(server->ipAddress,AF_INET,NULL,(LPSOCKADDR) &sAddr,&ipSize);

	sAddr.sin_port = htons(server->portNo);
	server->inSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(server->inSocket==INVALID_SOCKET )
	{
		wsaError=WSAGetLastError();
		DisplayError(NULL,TEXT("Socket Error"),server->inSocket,ALL,ERRORFOUND);
		return wsaError;
	}
	if ( WSAAsyncSelect( server->inSocket,hWnd,WM_SERVER_SOCKET,FD_ACCEPT | FD_READ | FD_CLOSE)== SOCKET_ERROR)
	{
		wsaError=WSAGetLastError(); // in case it changes after close socket
		closesocket(server->inSocket);
		WSACleanup();
		DisplayError(NULL,TEXT("WSAAsyncSelect Error"),wsaError,ALL,ERRORFOUND);
		return wsaError;
	}

	if(setsockopt(server->inSocket, SOL_SOCKET, SO_REUSEADDR, (char *) &bOptVal, sizeof(int)) == SOCKET_ERROR)
	{
		wsaError=WSAGetLastError();
		DisplayError(NULL,TEXT("SetSockOpt Error"),WSAGetLastError(),ALL,ERRORFOUND);
		return wsaError;
	}

	if ( bind(server->inSocket, (SOCKADDR *) &sAddr, sizeof(sAddr)) == SOCKET_ERROR )
	{
		wsaError=WSAGetLastError();
		DisplayError(NULL,TEXT("Bind Error"),wsaError,ALL,ERRORFOUND);
		return wsaError;
	}

	if (listen(server->inSocket, server->noConnections) == SOCKET_ERROR)
	{
		wsaError=WSAGetLastError();
		DisplayError(NULL,TEXT("Listen Error"),wsaError,ALL,ERRORFOUND);
		return wsaError;
	}
	server->isConnected=(wsaError==0);
	return wsaError;
}
Exemplo n.º 29
0
BOOLEAN ConnectToServer(HWND hWnd,serverStruct *server,clientStruct client)
{
	sockaddr_in sAddr;
	char strPortNo[10]="";
	WORD wVersionRequested = MAKEWORD(2, 2);
	WSADATA wsaData;
	int connErr=0;
	int ipSize;

	DisplayError(NULL,TEXT(__FUNCSIG__),0,LOG,NOTICE);

	ipSize=sizeof(sAddr);
	server->isConnected=TRUE;													// It will be changed to FALSE on errors
	wVersionRequested = MAKEWORD(2, 2);

	if (WSAStartup(wVersionRequested, &wsaData) != 0)
	{
		server->isConnected=FALSE;
		return server->isConnected;
	}

	if ( LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
	{
		WSACleanup();
		server->isConnected=FALSE;
		return server->isConnected;
	}

	memset( &sAddr, 0, sizeof (sAddr));
	server->inSocket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if(server->inSocket==INVALID_SOCKET)
	{
		connErr=WSAGetLastError();
		DisplayError(NULL,TEXT("Invalid Socket"),WSAGetLastError(),ALL,ERRORFOUND);
		server->isConnected=FALSE;
		return server->isConnected;
	}
	if(  WSAAsyncSelect( server->inSocket, hWnd,WM_CLIENT_SOCKET, FD_CONNECT | FD_READ ) == SOCKET_ERROR )
	{
		connErr=WSAGetLastError();
		DisplayError(hWnd,TEXT("WSAAsyncSelect Error"),connErr,ALL,ERRORFOUND);
		server->isConnected=FALSE;
		closesocket(server->inSocket);
		WSACleanup();
		return server->isConnected;
	}

	WSAStringToAddress(server->ipAddress,AF_INET,NULL,(LPSOCKADDR) &sAddr,&ipSize);
	sAddr.sin_port = htons(server->portNo);

	if(connErr=connect(server->inSocket,(SOCKADDR*)&sAddr,sizeof(SOCKADDR))==SOCKET_ERROR)
	{
		connErr=WSAGetLastError();
		if(connErr!=10035)                  // This error can be ignore so we are connected
		{
			DisplayError(NULL,TEXT("Connection Error"),connErr,LOG,ERRORFOUND);
			server->isConnected=FALSE;
		}
		else
			DisplayError(NULL,TEXT("WSA Block"),connErr,LOG,WARNING);
	}

	return server->isConnected;
}
Exemplo n.º 30
0
int parse_sdp_file(arguments_t *a, char addrs[MAX_CHANNELS_IN_SESSION][INET6_ADDRSTRLEN],
		   char ports[MAX_CHANNELS_IN_SESSION][MAX_PORT_LENGTH], char *sdp_buf) {
  int i;
  int m_lines = 0;
  int j = 0;
  int number_of_port;
  int number_of_address;
  int nb_of_accepted_ch = 0;
  int nb_of_defined_ch = 0;
  
  struct sockaddr_in ipv4;
  struct sockaddr_in6 ipv6;
  
  int position = 0;
  
#ifdef _MSC_VER
  int addr_size;
#else
  char *ep;
#endif
  
  int m_line_att_pos;
  char *att_name;
  char *att_value;
  BOOL supported_fec = FALSE;
  BOOL fec_inst_exists = FALSE;

  char *addr_type = NULL;
  char *source_filter = NULL;
  char *tsi = NULL;
  char *flute_ch = NULL;
  int flute_ch_number;
  char *start_time = NULL;
  char *stop_time = NULL;
  fec_dec_t *fec_dec;
  fec_dec_t *current_fec_dec;
  
  sdp_message_init(&a->sdp);

  if(sdp_message_parse(a->sdp, sdp_buf) != 0) {
    printf("Error: sdp_parse()\n");
    fflush(stdout);
    return -1;
  }
  
  if((source_filter = sdp_attr_get(a->sdp, "source-filter")) == NULL) {
    printf("Error: Invalid SDP, source-filter not present.\n");
    fflush(stdout);
	return -1;
  }
  else {
	  a->src_filt = sf_char2struct(source_filter);
	  a->alc_a.src_addr = a->src_filt->src_addr;
  }

  if((tsi = sdp_attr_get(a->sdp, "flute-tsi")) == NULL) {
    printf("Error: Invalid SDP, TSI not present.\n");
    fflush(stdout);
	return -1;
  }
  else {
	a->alc_a.tsi = (unsigned int)atoi(tsi);
  }

  /* Default channel number is one and it is overwrited if there is
     'a:flute-ch' in the SDP file. */
  
  flute_ch_number = 1;
  flute_ch = sdp_attr_get(a->sdp, "flute-ch");
  
  if(flute_ch != NULL) {
    flute_ch_number = (unsigned int)atoi(flute_ch);
  }

  if((addr_type = sdp_message_c_addrtype_get(a->sdp, 0, 0)) == NULL) {
    printf("Error: Invalid SDP, no valid 'c' field.\n");
    fflush(stdout);
	return -1;
  }
  else {
	if(strcmp(addr_type, "IP4") == 0) {
		a->alc_a.addr_family = PF_INET;
	}
	else if(strcmp(addr_type, "IP6") == 0) {
		a->alc_a.addr_family = PF_INET6;
	}
	else {
		printf("Error: Invalid SDP, address type invalid.\n");
		fflush(stdout);
		return -1;
	}
  }
  
  /* fetch session starttime */
  
  start_time = sdp_message_t_start_time_get (a->sdp, 0);
  
  if(start_time != NULL) {
#ifdef _MSC_VER			  
    a->alc_a.start_time = _atoi64(start_time);
    
    if(a->alc_a.start_time > (unsigned long long)0xFFFFFFFFFFFFFFFF) {
      printf("Error: Invalid SDP, start time too big.\n");
      fflush(stdout);   
      return -1;
    }
#else				
    a->alc_a.start_time = strtoull(start_time, &ep, 10);
    
    if(errno == ERANGE && a->alc_a.start_time == 0xFFFFFFFFFFFFFFFFULL) {
      printf("Error: Invalid SDP, start time too big.\n");
      fflush(stdout); 
      return -1;
    }
#endif	
  }
  
  /* fetch session stoptime */
  
  stop_time = sdp_message_t_stop_time_get (a->sdp, 0);
  
  if(stop_time != NULL) {
#ifdef _MSC_VER			  
    a->alc_a.stop_time = _atoi64(stop_time);
    
    if(a->alc_a.stop_time > (unsigned long long)0xFFFFFFFFFFFFFFFF) {
      printf("Error: Invalid SDP, stop time too big.\n");
      fflush(stdout);   
      return -1;
    }
#else				
    a->alc_a.stop_time = strtoull(stop_time, &ep, 10);
    
    if(errno == ERANGE && a->alc_a.stop_time == 0xFFFFFFFFFFFFFFFFULL) {
      printf("Error: Invalid SDP, stop time too big.\n");
      fflush(stdout); 
      return -1;
    }
#endif
	if(a->alc_a.stop_time == 0) {
		a->cont = TRUE;
	}
  }
  
  /* Session level FEC declaration */
  fec_dec = sdp_fec_dec_get(a->sdp);
  
  /* Search how many m-lines is defined in SDP */

  while(1) {
	  if(sdp_message_endof_media(a->sdp, position) == 0) {
		  /* check that 'proto' field is FLUTE/UDP */
		  if(strcmp(sdp_message_m_proto_get(a->sdp, position), "FLUTE/UDP") == 0) {
			  /* check that payload number exists */
			  if(sdp_message_m_payload_get(a->sdp, position, 0) != NULL) {
				  m_lines++;
			  }
		  }
		  position++;
	  }
	  else {
		  break;
	  }
  }
  
  if(m_lines == 0) {
    printf("Error: Invalid SDP, no valid 'm' field.\n");
    fflush(stdout);
    fec_dec_free(fec_dec);
    return -1;
  }
  
  for(i = 0; i < m_lines; i++) {
    
    m_line_att_pos = 0;
    
    while((att_name = sdp_message_a_att_field_get(a->sdp, i, m_line_att_pos)) != NULL) {
      
      if(strcmp(att_name, "FEC") == 0) {
	fec_inst_exists = TRUE;
	att_value = sdp_message_a_att_value_get(a->sdp, i, m_line_att_pos);
	
	if(fec_dec == NULL) {
	  printf("Error: Invalid SDP, FEC-declaration does not exists.\n");
	  fflush(stdout);
	  return -1;
	}
	
	current_fec_dec = fec_dec;
	
	while(current_fec_dec != NULL) {
	  
	  if(current_fec_dec->index == (unsigned int)atoi(att_value)) {
	    
	    if(current_fec_dec->fec_enc_id == COM_NO_C_FEC_ENC_ID) {
	      a->alc_a.fec_enc_id = COM_NO_C_FEC_ENC_ID;
	      a->alc_a.fec_inst_id = 0;
	      supported_fec = TRUE;
	    }
	    else if(current_fec_dec->fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) {
	      a->alc_a.fec_enc_id = SIMPLE_XOR_FEC_ENC_ID;
	      a->alc_a.fec_inst_id = 0;
	      supported_fec = TRUE;
	    }
	    else if(current_fec_dec->fec_enc_id  == RS_FEC_ENC_ID) {
              a->alc_a.fec_enc_id = RS_FEC_ENC_ID;
              a->alc_a.fec_inst_id = 0;
              supported_fec = TRUE;
        }
	    else if(current_fec_dec->fec_enc_id  == SB_SYS_FEC_ENC_ID &&
		    current_fec_dec->fec_inst_id == REED_SOL_FEC_INST_ID) {
	      a->alc_a.fec_enc_id = SB_SYS_FEC_ENC_ID;
	      a->alc_a.fec_inst_id = REED_SOL_FEC_INST_ID;
	      supported_fec = TRUE;
	    }
	  }
	  current_fec_dec = current_fec_dec->next;
	}
      }
      else if(strcmp(att_name, "FEC-declaration") == 0) {
	fec_inst_exists = TRUE;
	att_value = sdp_message_a_att_value_get(a->sdp, i, m_line_att_pos);
	
	current_fec_dec = fec_dec_char2struct(att_value);
	
	if(current_fec_dec->fec_enc_id == COM_NO_C_FEC_ENC_ID) {
	  a->alc_a.fec_enc_id = COM_NO_C_FEC_ENC_ID;
	  a->alc_a.fec_inst_id = 0;
	  supported_fec = TRUE;
	}
	else if(current_fec_dec->fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) {
	  a->alc_a.fec_enc_id = SIMPLE_XOR_FEC_ENC_ID;
	  a->alc_a.fec_inst_id = 0;
	  supported_fec = TRUE;
	}
	else if(current_fec_dec->fec_enc_id  == RS_FEC_ENC_ID) {
	  a->alc_a.fec_enc_id = RS_FEC_ENC_ID;
	  a->alc_a.fec_inst_id = 0;
	  supported_fec = TRUE;
	}
	else if(current_fec_dec->fec_enc_id == SB_SYS_FEC_ENC_ID &&
		current_fec_dec->fec_inst_id == REED_SOL_FEC_INST_ID) {
	  a->alc_a.fec_enc_id = SB_SYS_FEC_ENC_ID;
	  a->alc_a.fec_inst_id = REED_SOL_FEC_INST_ID;
	  supported_fec = TRUE;
	}
	
	fec_dec_free(current_fec_dec);
      }
      m_line_att_pos++;
    }
  
    if(fec_inst_exists == FALSE) {
      supported_fec = TRUE;
      a->alc_a.fec_enc_id = COM_NO_C_FEC_ENC_ID;
      a->alc_a.fec_inst_id = 0;
    }
  
    /* how many ports in m-line */
    
    if(sdp_message_m_number_of_port_get(a->sdp, i) == NULL) {
      number_of_port = 1;
    }
    else {
      number_of_port = atoi(sdp_message_m_number_of_port_get(a->sdp, i));
    }
    
    /* how many addresses in c-line */
    
    if(sdp_message_c_addr_multicast_int_get(a->sdp, i, 0) == NULL) {
      number_of_address = 1;
    }
    else {
      number_of_address = atoi(sdp_message_c_addr_multicast_int_get(a->sdp, i, 0));
    }
    
    if(((number_of_port != 1) && (number_of_address != 1))) {
      printf("Error: Invalid SDP, confusing number of ports and addresses.\n");
      fflush(stdout);
      fec_dec_free(fec_dec);   
      return -1;
    }
    
    if(number_of_address == 1) {

      for(j = 0; j < number_of_port; j++) {	
	if(supported_fec == TRUE) {
	  memset(ports[nb_of_accepted_ch], 0, MAX_PORT_LENGTH);
	  memset(addrs[nb_of_accepted_ch], 0, INET6_ADDRSTRLEN); 
	  sprintf(ports[nb_of_accepted_ch], "%i", (atoi(sdp_message_m_port_get(a->sdp, i)) + j));
	  strcpy(addrs[nb_of_accepted_ch], sdp_message_c_addr_get(a->sdp, i, 0));

	  nb_of_accepted_ch++;
	}
	nb_of_defined_ch++;
      }
    }
    else if(number_of_port == 1) {

      for(j = 0; j < number_of_address; j++) {
	if(supported_fec == TRUE) {
	  if(a->alc_a.addr_family == PF_INET) {
	    memset(addrs[nb_of_accepted_ch], 0, INET6_ADDRSTRLEN);
	    ipv4.sin_addr.s_addr = htonl(ntohl(inet_addr(a->alc_a.addr)) + j);
	    sprintf(addrs[j], "%s", inet_ntoa(ipv4.sin_addr));
	    
	    memset(ports[nb_of_accepted_ch], 0, MAX_PORT_LENGTH);
	    sprintf(ports[nb_of_accepted_ch], "%i",  atoi(sdp_message_m_port_get(a->sdp, i)));
	  }
	  else if(a->alc_a.addr_family == PF_INET6) {
#ifdef _MSC_VER
	    addr_size = sizeof(struct sockaddr_in6);
	    WSAStringToAddress((char*)a->alc_a.addr, AF_INET6, NULL, (struct sockaddr*)&ipv6, &addr_size);
#else 
	    inet_pton(AF_INET6, a->alc_a.addr, &ipv6.sin6_addr);
#endif
	    
	    memset(addrs[nb_of_accepted_ch], 0, INET6_ADDRSTRLEN);

#ifdef _MSC_VER
	    addr_size = sizeof(addrs[nb_of_accepted_ch]);
		WSAAddressToString((struct sockaddr*)&ipv6, sizeof(struct sockaddr_in6),
			NULL, addrs[nb_of_accepted_ch], &addr_size);
#else
	    inet_ntop(AF_INET6, &ipv6.sin6_addr, addrs[nb_of_accepted_ch], sizeof(addrs[nb_of_accepted_ch]));
#endif
	    
	    memset(ports[nb_of_accepted_ch], 0, MAX_PORT_LENGTH);
	    sprintf(ports[nb_of_accepted_ch], "%i",  atoi(sdp_message_m_port_get(a->sdp, i)));
	    
	    if(j < (a->alc_a.nb_channel - 1)) {
	      if(increase_ipv6_address(&ipv6.sin6_addr) == -1) {
		printf("Increasing IPv6 address %s is not possible\n", addrs[j]);
		fec_dec_free(fec_dec);
		return -1;
	      }
	    }
	  }
	  nb_of_accepted_ch++;
	}
	nb_of_defined_ch++;
      }
    }
  }
    
  if(flute_ch_number != nb_of_defined_ch) {
    printf("Error: Invalid SDP, channel number not correct.\n");
    fflush(stdout);
    fec_dec_free(fec_dec);
    return -1;
  }
  
  a->alc_a.nb_channel = nb_of_accepted_ch;
  
  fec_dec_free(fec_dec);
  
  return 0;
}