#include"stdafx.h"

#include"iostream"

#include "algorithm"

#include"string"

#include"vector"

#include"set"

#include"map"

#include "iostream"

#include "thread"

#include <iostream>

#include <algorithm>

#include <vector>

#include <iterator>

#include "rapidxml.hpp"

#include "rapidxml_utils.hpp"

#include <winsock2.h>

#include <windows.h>

#define MAX_PATH  256

#pragma comment( lib, "ws2_32.lib") 

int

evutil_socketpair(int family, int type, int protocol, int fd[])

{

    /* This code is originally from Tor.  Used with permission. */

    /* This socketpair does not work when localhost is down. So

    * it's really not the same thing at all. But it's close enough

    * for now, and really, when localhost is down sometimes, we

    * have other problems too.

    */

    int listener = -;

    int connector = -;

    int acceptor = -;

    struct sockaddr_in listen_addr;

    struct sockaddr_in connect_addr;

    int size;

    int saved_errno = -;

    listener = socket(AF_INET, type, );

    if (listener < )

    {

        return -;

    }

    memset(&listen_addr, , sizeof(listen_addr));

    listen_addr.sin_family = AF_INET;

    listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    listen_addr.sin_port = ;    /* kernel chooses port.     */

    int err;

    if (SOCKET_ERROR == bind(listener, (struct sockaddr *) &listen_addr, sizeof(listen_addr)))

        return -;

    if (listen(listener, ) == -)

        goto tidy_up_and_fail;

    connector = socket(AF_INET, type, );

    if (connector < )

        goto tidy_up_and_fail;

    /* We want to find out the port number to connect to.  */

    size = sizeof(connect_addr);

    if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -)

        goto tidy_up_and_fail;

    if (size != sizeof(connect_addr))

        goto abort_tidy_up_and_fail;

    if (connect(connector, (struct sockaddr *) &connect_addr,

        sizeof(connect_addr)) == -)

        goto tidy_up_and_fail;

    size = sizeof(listen_addr);

    acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);

    if (acceptor < )

        goto tidy_up_and_fail;

    if (size != sizeof(listen_addr))

        goto abort_tidy_up_and_fail;

    /* Now check we are talking to ourself by matching port and host on the

    two sockets.     */

    if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -)

        goto tidy_up_and_fail;

    if (size != sizeof(connect_addr)

        || listen_addr.sin_family != connect_addr.sin_family

        || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr

        || listen_addr.sin_port != connect_addr.sin_port)

        goto abort_tidy_up_and_fail;

    fd[] = connector;

    fd[] = acceptor;

    return ;

abort_tidy_up_and_fail:

    saved_errno = WSAECONNABORTED;

tidy_up_and_fail:

    return -;

}

void main(){

    WORD    wVersionRequested;

    WSADATA wsaData;

    int     err, iLen;

    wVersionRequested = MAKEWORD(, );//create 16bit data

    err = WSAStartup(wVersionRequested, &wsaData); //load win socket

    int ev_signal_pair[];

    evutil_socketpair(

        AF_UNIX, SOCK_STREAM, , ev_signal_pair);

    send(ev_signal_pair[], "nihao", , );

    char c[] = {  };

    recv(ev_signal_pair[], c, , );

    std::cout << c;

    system("pause");

}