コード例 #1
0
ファイル: SXSocket.c プロジェクト: prankymat/spartanX
SXSocketRef SXCreateClientSocket(const char * ipaddr,
                                 unsigned short port,
                                 int domain,
                                 int type,
                                 int protocol,
                                 SXError * err_ret)
{
    SXSocketRef sockPtr = (SXSocketRef)sx_calloc(1, sizeof(sx_socket_t));

    if (sockPtr == NULL)
        ERR_RET(SX_ERROR_MEM_ALLOC);
    
    sockPtr->protocol = protocol;
    sockPtr->type = type;
    sockPtr->domain = domain;
    sx_obj_init(&sockPtr->obj, &SXFreeSocket);
    socklen_t addrlen;

    memset(&sockPtr->addr, 0, sizeof(struct sockaddr_storage));
    
    if ((sockPtr->sockfd = socket(domain, type, protocol)) == -1) {
        perror("socket");
        ERR_RET(SX_ERROR_SYS_SOCKET);
    }
    
    switch (domain) {
        case AF_INET:
            sockaddr_in(sockPtr->addr).sin_port = htons(port);
            sockaddr_in(sockPtr->addr).sin_len = sizeof(struct sockaddr_in);
            addrlen = sizeof(struct sockaddr_in);
            inet_pton(AF_INET, ipaddr, &sockaddr_in(sockPtr->addr).sin_addr);
            break;
        case AF_INET6:
            sockaddr_in6(sockPtr->addr).sin6_port = htons(port);
            sockaddr_in6(sockPtr->addr).sin6_len = sizeof(struct sockaddr_in6);
            addrlen = sizeof(struct sockaddr_in6);
            inet_pton(AF_INET6, ipaddr, &sockaddr_in6(sockPtr->addr).sin6_addr);
            break;
        default:
            ERR_RET(SX_ERROR_INVALID_IPADDR);
            return NULL;
    }
    
    int yes = 1;
    
    if (setsockopt(sockPtr->sockfd, SOL_SOCKET, SO_NOSIGPIPE, &yes, sizeof(int)) == -1) {
        perror("setsockopt");
        ERR_RET(SX_ERROR_SYS_SETSOCKOPT);
    }
    
    sockPtr->addr.ss_family = domain;
    
    ERR_RET(SX_SUCCESS);
    
    return sockPtr;
}
コード例 #2
0
ファイル: SXSocket.c プロジェクト: prankymat/spartanX
SXError dns_lookup(SXSocketRef socket, const char * hostname, const char * service, struct addrinfo * hint) {
    struct addrinfo * info, * cinfo;
    
    if (getaddrinfo(hostname, service, hint, &info) != 0)
        return SX_ERROR_SYS_GET_ADDR_INFO;
    
    
    cinfo = info;
    
    while (cinfo != NULL) {
        cinfo = cinfo->ai_next;
        short port = htons(getservbyname(service, NULL)->s_port);
        memset(&socket->addr, 0, sizeof(struct sockaddr_storage));
        switch (cinfo->ai_family) {
            case AF_INET:
                socket->domain = AF_INET;
                socket->type = cinfo->ai_socktype;
                socket->protocol = cinfo->ai_protocol;
                
                sockaddr_in(socket->addr).sin_len = sizeof(struct sockaddr_in);
                sockaddr_in(socket->addr).sin_family = AF_INET;
                sockaddr_in(socket->addr).sin_addr = sockaddr_in(cinfo->ai_addr).sin_addr;
                sockaddr_in(socket->addr).sin_port = port;
                goto clean;
            case AF_INET6:
                sockaddr_in6(socket->addr).sin6_len = sizeof(struct sockaddr_in6);
                sockaddr_in6(socket->addr).sin6_family = AF_INET6;
                sockaddr_in6(socket->addr).sin6_port = port;
                sockaddr_in6(socket->addr).sin6_addr = sockaddr_in6(cinfo->ai_addr).sin6_addr;
                goto clean;
            default:
                goto cont;
        }
        
    cont:
        continue;
    }
    
clean:
    freeaddrinfo(info);
    
    return SX_SUCCESS;
}
コード例 #3
0
    bool Accept(TcpSocket& connection, bool blocking = true) const
    {
      if (!IsListening())
      {
        throw std::runtime_error("TcpSocket.Accept - Called on a socket that does not have listening mode enabled");
      }

      auto newSocket = SOCKET(0);
      auto address = sockaddr_in();
      auto tryAgain = bool();

      do
      {
        tryAgain = false;
        if (!Winsock::Accept(socket, address, newSocket))
        {
          switch (WSAGetLastError())
          {
          case WSAEWOULDBLOCK:
            //if (!IsBlocking())
            //{
            //  throw std::runtime_error("TcpSocket.Accept - Received would-block error for non-blocking socket");
            //}
            return false;

          case WSAECONNRESET:
            tryAgain = true;
            break;

          default:
            return false;
          }
        }
      } while (tryAgain);

      if (connection.IsOpen())
      {
        connection.Close();
      }

      connection.socket = newSocket;
      connection.isListening = false;

      if (!Winsock::IoctlSocket(connection.socket, blocking))
      {
        throw std::runtime_error("TcpSocket.Accept - Unable to set blocking mode on new connection");
      }
      connection.isBlocking = blocking;

      return true;
    }
コード例 #4
0
ファイル: utils.cpp プロジェクト: MantisCinema/tiscamera
sockaddr_in fillAddr (const std::string &address, const unsigned short port)
{
    sockaddr_in retv = sockaddr_in();
    retv.sin_family = AF_INET;

    hostent *host;  // Resolve name
    if ((host = gethostbyname(address.c_str())) == NULL)
    {
        // TODO throw exception
    }
    retv.sin_addr.s_addr = *((unsigned long *) host->h_addr_list[0]);

    retv.sin_port = htons(port);     // Assign port in network byte order

    return retv;
}
コード例 #5
0
ファイル: SXSocket.c プロジェクト: prankymat/spartanX
SXSocketRef SXCreateServerSocket(unsigned short port,
                                 int domain,
                                 int type,
                                 int protocol,
                                 SXError * err_ret)
{
    SXSocketRef sockPtr = (SXSocketRef)sx_calloc(1, sizeof(sx_socket_t));
    
    if (sockPtr == NULL)
        ERR_RET(SX_ERROR_MEM_ALLOC);
    
    sockPtr->domain = domain;
    sockPtr->type = type;
    sockPtr->protocol = protocol;
    sockPtr->ref_count = 1;
    sockPtr->port = port;
    socklen_t addrlen;
    
    memset(&sockPtr->addr, 0, sizeof(struct sockaddr_storage));
    
    if ((sockPtr->sockfd = socket(domain, type, protocol)) == -1) {
        perror("socket");
        ERR_RET(SX_ERROR_SYS_SOCKET);
    }
    
    switch (domain) {
        case AF_INET:
            sockaddr_in(sockPtr->addr).sin_addr.s_addr = INADDR_ANY;
            sockaddr_in(sockPtr->addr).sin_port = htons(port);
            sockaddr_in(sockPtr->addr).sin_len = sizeof(struct sockaddr_in);
            addrlen = sizeof(struct sockaddr_in);
            break;
        case AF_INET6:
            sockaddr_in6(sockPtr->addr).sin6_addr = in6addr_any;
            sockaddr_in6(sockPtr->addr).sin6_port = htons(port);
            sockaddr_in6(sockPtr->addr).sin6_len = sizeof(struct sockaddr_in6);
            addrlen = sizeof(struct sockaddr_in6);
            break;
        default:
            ERR_RET(SX_ERROR_INVALID_IPADDR);
            return NULL;
    }
    
    sockPtr->addr.ss_family = domain;
    
    int yes=1;
    
    if (setsockopt(sockPtr->sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
        perror("setsockopt");
        ERR_RET(SX_ERROR_SYS_SETSOCKOPT);
    }
    
    if (bind(sockPtr->sockfd, (struct sockaddr *)&sockPtr->addr, addrlen) == -1) {
        perror("bind");
        ERR_RET(SX_ERROR_SYS_BIND);
    }
    
    ERR_RET(SX_SUCCESS);
    
    return sockPtr;
}
コード例 #6
0
ファイル: NClient.cpp プロジェクト: Intueor/Dar
// ¬ Ћё„≈Ќ»я.

#include "NClient.h"

// »Ќ»÷»јЋ»«ј÷»я —“ј“»„≈— »’ ѕ≈–≈ћ≈ЌЌџ’.

WSADATA NClient::wsadata = WSADATA();
sockaddr_in NClient::ssin = sockaddr_in();
sockaddr_in NClient::SocketAddress = sockaddr_in();
SOCKET NClient::p_Socket = NULL;
int NClient::iResult = 0, NClient::iSended = 0;

// ‘”Ќ ÷»»  Ћј——ќ¬.

//==  ласс клиента.

//== —тарт клиента.
bool NClient::Start()
{
	WSAStartup(MAKEWORD(2, 2), &wsadata);
	p_Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (p_Socket == SOCKET_ERROR)
	{
		printf("!! Error when creating socket.\n");
		WSACleanup();
		return false;
	}
	ssin.sin_family = AF_INET;
	ssin.sin_addr.s_addr = inet_addr("127.0.0.1");
	ssin.sin_port = htons(SRV_PORT);
	printf("Client is running.\n");