int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)

Risket fucked around with this message at 17:23 on Nov 23, 2014

asur fucked around with this message at 17:43 on Nov 23, 2014

Risket fucked around with this message at 18:01 on Nov 23, 2014

OddObserver fucked around with this message at 14:02 on Nov 25, 2014

Risket fucked around with this message at 19:48 on Nov 25, 2014

Risket fucked around with this message at 20:27 on Nov 25, 2014

#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <netdb.h>
#include <iostream>
#include <string.h>

int main()
{
    struct addrinfo structHints, *pResult;
    memset(&structHints, 0, sizeof structHints);
    structHints.ai_family = AF_UNSPEC;
    structHints.ai_socktype = SOCK_STREAM;
    char strPort[6];
    sprintf(strPort, "%u", 1321);
    getaddrinfo("192.168.0.2", strPort, &structHints, &pResult);
    //getaddrinfo("192.168.0.5", strPort, &structHints, &pResult);
    int socketClient = socket(pResult->ai_family,
            pResult->ai_socktype,
            pResult->ai_protocol);
    int nFlagToSet = 1;
    // just to be safe and make sure we're not buffering
    int nResult = setsockopt(socketClient,
                            IPPROTO_TCP,
                            TCP_NODELAY,
                            (char *) &nFlagToSet,
                            sizeof(int));
    std::cout << "Trying to connect..." << std::endl;
    int nConnectReturn = -1;
    nResult = connect(socketClient, pResult->ai_addr, pResult->ai_addrlen);
    std::cout << "Connected." << std::endl;
    int nCount = 0;
    std::string strToSend;
    while (strToSend.size() < 999)
        strToSend.push_back('a');
    char strServerReply[1000];
    while (nCount < 1000)
    {
        printf("Waiting to receive message.\n");
        ::recv(socketClient , strServerReply , 1000 , 0);
        printf("Received from server: %s\n",strServerReply);
        printf("Sending to server.\n");
        int nBytes = ::send(socketClient, strToSend.c_str(), 1000, 0);
        nCount++;
    }
    return 0;
}

#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <netdb.h>
#include <iostream>
#include <string.h>
#include <fcntl.h>

int main()
{
    sockaddr_in *addressServer = (sockaddr_in *) malloc(sizeof(struct sockaddr_in));
    memset(addressServer, 0, sizeof(struct sockaddr_in));
    addressServer->sin_family = AF_INET;
    addressServer->sin_addr.s_addr = htonl(INADDR_ANY);
    addressServer->sin_port = htons(1321);
    int socketServer = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
    int nFlagToSet = 1;
    setsockopt(socketServer, IPPROTO_TCP, SO_REUSEADDR, &nFlagToSet, sizeof(nFlagToSet));
    ::bind(socketServer, (sockaddr *)addressServer, sizeof(*addressServer));
    while (true)
    {
        std::cout << "Listening." << std::endl;
        ::listen(socketServer, 1);

        sockaddr_in *clientAddr;
        long unsigned int caSize = sizeof(clientAddr);
        int socketClient = accept(socketServer, (struct sockaddr *)&clientAddr, (socklen_t *)&caSize);
        // just to be safe and make sure we're not buffering
        setsockopt(socketServer, IPPROTO_TCP, TCP_NODELAY, &nFlagToSet, sizeof(nFlagToSet));

        // On OSX, this loop is terribly slow unless this is uncommented. If
        // it's commented, send() and recv() frequently return -1.
        //fcntl(socketClient,F_SETFL,fcntl(socketClient,F_GETFL)|O_NONBLOCK);

        // Confirm that socket is in blocking mode
        std::cout << "Value of fcntl(socketClient,F_GETFL): "
            << fcntl(socketClient,F_GETFL) << ","
               << "Value of fcntl(socketClient,F_GETFL) | O_NONBLOCK): "
               << (fcntl(socketClient,F_GETFL) | O_NONBLOCK) <<
                  ", Press enter to continue." << std::endl;
        std::cin.ignore();

        std::cout << "Got connection. Beginning data loop." << std::endl;
        bool bConnected = true;
        int nCount = 0;
        std::string strToSend;
        while (strToSend.size() < 999)
            strToSend.push_back('a');
        char strClientReply[1000];
        while (nCount < 1000)
        {
            printf("Sending to client.\n");
            int nResult = ::send(socketClient, strToSend.c_str(), 1000, 0);
            printf("Sent. Waiting to receive message.\n");
            nResult = ::recv(socketClient , strClientReply , 1000 , 0);

            printf("Received from server: %s\n",strClientReply);
            nCount++;
        }
    }
    return 0;
}

The Gay Bean fucked around with this message at 17:26 on Nov 28, 2014