oswrap_win.c

Atheros AP Test with Agilent N4010A source code

	    mach_name++;
    }
    for (cp = mach_name; (*cp != '\0') && (*cp != '\\'); cp++) {
    }
    *cp = '\0';
    
#ifdef _DEBUG
    q_uiPrintf("osSockConnect: starting mach_name = '%s'\n", mach_name);
#endif

    if (!strcmp(mach_name, ".")) {
	    /* A windows convention meaning "local machine" */
	    mach_name = "localhost";
    }

    q_uiPrintf("osSockConnect: revised mach_name = '%s'\n", mach_name);

    pOSSock = (OS_SOCK_INFO *) A_MALLOC(sizeof(OS_SOCK_INFO));
    if(!pOSSock) {
		uiPrintf("ERROR::osSockConnect: malloc failed for pOSSock\n");
        return NULL;
	}

    strncpy(pOSSock->hostname, mach_name, sizeof(pOSSock->hostname));
    pOSSock->hostname[sizeof(pOSSock->hostname) - 1] = '\0';

    pOSSock->port_num = SOCK_PORT_NUM;

	if (!stricmp(pOSSock->hostname, "COM1")) {
       pOSSock->port_num = COM1_PORT_NUM;
	}
	if (!stricmp(pOSSock->hostname, "COM2")) {
       pOSSock->port_num = COM2_PORT_NUM;
	}
	if (!stricmp(pOSSock->hostname, "COM3")) {
       pOSSock->port_num = COM3_PORT_NUM;
	}
	if (!stricmp(pOSSock->hostname, "COM4")) {
       pOSSock->port_num = COM4_PORT_NUM;
	}
	if (!stricmp(pOSSock->hostname, "USB")) {
       pOSSock->port_num = USB_PORT_NUM;
	}

    switch(pOSSock->port_num) {
       case USB_PORT_NUM: {
             pOSSock->sockDisconnect = 0;
             pOSSock->sockClose = 0;
             handle = open_device(USB_FUNCTION, 0, inPipe);
             pOSSock->inHandle  = (A_INT32) handle;
             if (handle == INVALID_HANDLE_VALUE) {
                printf("Error:osSockConnect::Invalid Handle to inPipe:%s\n", inPipe);
                A_FREE(pOSSock);
	            return NULL;
             }
             handle = open_device(USB_FUNCTION, 0, outPipe);
             pOSSock->outHandle  = (A_INT32) handle;
             if (handle == INVALID_HANDLE_VALUE) {
                printf("Error:osSockConnect::Invalid Handle outPipe:%s\n", outPipe);
                A_FREE(pOSSock);
	            return NULL;
             }
             break;
             }
       case COM1_PORT_NUM:
       case COM2_PORT_NUM:
       case COM3_PORT_NUM: 
	   case COM4_PORT_NUM:   {
          pOSSock->sockDisconnect = 0;
          pOSSock->sockClose = 0;
          if ((err=os_com_open(pOSSock)) != 0) {
              uiPrintf("ERROR::osSockConnect::Com port open failed with error = %x\n", err);
              exit(0);
          }
       break;
       } // end of case
       case SOCK_PORT_NUM: {
         res = socketConnect(pOSSock->hostname, pOSSock->port_num,
				      &pOSSock->ip_addr);;
         if (res < 0) {
   	      uiPrintf("ERROR::osSockConnect: pipe connect failed\n");
          A_FREE(pOSSock);
	      return NULL;
         }
	     q_uiPrintf("osSockConnect: Connected to pipe\n");

	     q_uiPrintf("ip_addr = %d.%d.%d.%d\n",
	        (pOSSock->ip_addr >> 24) & 0xff,
	        (pOSSock->ip_addr >> 16) & 0xff,
	        (pOSSock->ip_addr >> 8) & 0xff,
                  (pOSSock->ip_addr >> 0) & 0xff);
               pOSSock->sockfd = res;
               break;
	   } // end of else
    }

	return pOSSock;
}



/* osSockAccept - Wait for a connection
*
*/
OS_SOCK_INFO *osSockAccept
	(
	OS_SOCK_INFO *pOSSock
	)
{
	OS_SOCK_INFO *pOSNewSock;
	int		i;
	int		sfd;
	struct sockaddr_in	sin;

	pOSNewSock = (OS_SOCK_INFO *) A_MALLOC(sizeof(*pOSNewSock));
	if (!pOSNewSock) {
		uiPrintf("ERROR::osSockAccept: malloc failed for pOSNewSock \n");
		return NULL;
	}

	i = sizeof(sin);
	sfd = accept(pOSSock->sockfd, (struct sockaddr *) &sin, (int *)&i);
	if (sfd == INVALID_SOCKET) {
		A_FREE(pOSNewSock);
		uiPrintf("ERROR::osSockAccept: accept failed: %d\n", WSAGetLastError());
		WSACleanup( );
		return NULL;
	}
   	
  	strcpy(pOSNewSock->hostname, inet_ntoa(sin.sin_addr));
	pOSNewSock->port_num = sin.sin_port;
	
	pOSNewSock->sockClose = 0;
	pOSNewSock->sockDisconnect = 0;
	pOSNewSock->sockfd = sfd;

	return pOSNewSock;
}

OS_SOCK_INFO* osSockListen(A_UINT32 acceptFlag, A_UINT16 port)
{
    OS_SOCK_INFO *pOSSock;
	OS_SOCK_INFO *pOSNewSock;
    A_UINT32 err;


    pOSSock = (OS_SOCK_INFO *) A_MALLOC(sizeof(OS_SOCK_INFO));
    if(!pOSSock) {
		uiPrintf("ERROR::osSockListen: malloc failed for pOSSock\n");
        return NULL;
	}

	pOSSock->port_num = port;
	switch(pOSSock->port_num) {
			case COM1_PORT_NUM:
    			strcpy(pOSSock->hostname, "COM1");
				break;
			case COM2_PORT_NUM:
    			strcpy(pOSSock->hostname, "COM2");
				break;
			case COM3_PORT_NUM:
    			strcpy(pOSSock->hostname, "COM3");
				break;
			case COM4_PORT_NUM:
    			strcpy(pOSSock->hostname, "COM4");
				break;

			case SOCK_PORT_NUM:
    			strcpy(pOSSock->hostname, "localhost");
				break;
	}
	pOSSock->sockDisconnect = 0;
	pOSSock->sockClose = 0;

	if (port == SOCK_PORT_NUM) {	
       pOSSock->sockfd = socketListen(pOSSock);
	   if(pOSSock->sockfd < 0) {
	   	   uiPrintf("ERROR::osPipeCreate: socket creation failed\n");
           A_FREE(pOSSock);
		   return NULL;
	   }

	   if (acceptFlag) {
		   pOSNewSock = osSockAccept(pOSSock);
		   if (!pOSNewSock) {
			   uiPrintf("ERROR::osSockListen: malloc failed for pOSSock \n");
			   osSockClose(pOSSock);
			   return NULL;
		   }
		   osSockClose(pOSSock);
		   pOSSock = pOSNewSock;
	   }
	}
	else {
		if ((err=os_com_open(pOSSock)) != 0) {
			uiPrintf("osSockListen::Com port open failed\n");
		}
	}

	return pOSSock;
}

static int	
socketCreateAccept(int port_num)
{
    int	   sockfd;
    struct protoent *	proto;
    int	   res;
    struct sockaddr_in sin;
    int	   i;
    int	   sfd;
	WORD   wVersionRequested;
	WSADATA wsaData;
 
	wVersionRequested = MAKEWORD( 2, 2 );
 
	res = WSAStartup( wVersionRequested, &wsaData );
	if ( res != 0 ) {
		uiPrintf("socketCreateAccept: Could not find windows socket library\n");
		return -1;
	}
 
	if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 ) {
		uiPrintf("socketCreateAccept: Could not find windows socket library\n");
		WSACleanup( );
		return -1; 
	}

    if((proto = getprotobyname("tcp")) == NULL) {
    	uiPrintf("socketCreateAccept: getprotobyname failed: %d\n", WSAGetLastError());
   		WSACleanup( );
	    return -1;
    }

    q_uiPrintf("socket start\n");
    sockfd = WSASocket(PF_INET, SOCK_STREAM, proto->p_proto, NULL, (GROUP)NULL, 0);
    q_uiPrintf("socket end\n");
    if (sockfd == INVALID_SOCKET) {
	    uiPrintf("socketCreateAccept: socket failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    /* Allow immediate reuse of port */
    q_uiPrintf("setsockopt SO_REUSEADDR start\n");
    i = 1;
    res = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof(i));
    if (res != 0) {
	    uiPrintf("socketCreateAccept: setsockopt failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }	
    q_uiPrintf("setsockopt SO_REUSEADDR end\n");

    /* Set TCP Nodelay */
    q_uiPrintf("setsockopt TCP_NODELAY start\n");
    i = 1;
    res = setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *) &i, sizeof(i));
    if (res != 0) {
	    uiPrintf("socketCreateAccept: setsockopt failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }	
    q_uiPrintf("setsockopt TCP_NODELAY end\n");

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr =  INADDR_ANY;
    sin.sin_port = htons((A_UINT16) port_num);

    q_uiPrintf("bind start\n");
    res = bind(sockfd, (struct sockaddr *) &sin, sizeof(sin));
    q_uiPrintf("bind end\n");
    if (res != 0) {
	    uiPrintf("socketCreateAccept: bind failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    q_uiPrintf("listen start\n");
    res = listen(sockfd, 4);
    q_uiPrintf("listen end\n");
    if (res != 0) {
	    uiPrintf("socketCreateAccept: listen failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    /* Call accept */
    q_uiPrintf("accept start\n");
    i = sizeof(sin);
    uiPrintf("* socket created, waiting for connection...\n");
    sfd = accept(sockfd, (struct sockaddr *) &sin, &i);
    q_uiPrintf("accept end\n");
    if (sfd == INVALID_SOCKET) {
	    uiPrintf("socketCreateAccept: accept failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    q_uiPrintf("accept: sin.sin_family=0x%x\n", (int) sin.sin_family);
    q_uiPrintf("accept: sin.sin_port=0x%x (%d)\n", (int) sin.sin_port,
	    (int) ntohs(sin.sin_port));
    q_uiPrintf("accept: sin.sin_addr=0x%08x\n", (int) ntohl(sin.sin_addr.s_addr));

    res = closesocket(sockfd);
    if (res != 0) {
	    uiPrintf("socketCreateAccept: closesocket failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    return sfd;
}


ART_SOCK_INFO*
osSockCreate(char *pname)
{
    ART_SOCK_INFO *pOSSock;

    pOSSock = (ART_SOCK_INFO *) A_MALLOC(sizeof(ART_SOCK_INFO));
    if(!pOSSock) {
		uiPrintf("osSockCreate: malloc failed for pOSSock\n");
        return NULL;
	}

    strcpy(pOSSock->hostname, "localhost");
    pOSSock->port_num = SOCK_PORT_NUM;

    pOSSock->sockfd = socketCreateAccept(pOSSock->port_num);
	if(pOSSock->sockfd < 0) {
		uiPrintf("osPipeCreate: socket creation failed\n");
        A_FREE(pOSSock);
		return NULL;
	}

    return pOSSock;
}

static int	socketListen(OS_SOCK_INFO* pOSSock)
{
    int	   sockfd;
    struct protoent *	proto;
    int	   res;
    struct sockaddr_in sin;
    int	   i;
	WORD   wVersionRequested;
	WSADATA wsaData;
 
	wVersionRequested = MAKEWORD( 2, 2 );
 
	res = WSAStartup( wVersionRequested, &wsaData );
	if ( res != 0 ) {
		uiPrintf("socketCreateAccept: Could not find windows socket library\n");
		return -1;
	}
 
	if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 ) {
		uiPrintf("socketCreateAccept: Could not find windows socket library\n");
		WSACleanup( );
		return -1; 
	}

    if((proto = getprotobyname("tcp")) == NULL) {
    	uiPrintf("ERROR::socketCreateAccept: getprotobyname failed: %d\n", WSAGetLastError());
   		WSACleanup( );
	    return -1;
    }

    q_uiPrintf("socket start\n");
    sockfd = WSASocket(PF_INET, SOCK_STREAM, proto->p_proto, NULL, (GROUP)NULL, 0);
    q_uiPrintf("socket end\n");
    if (sockfd == INVALID_SOCKET) {
	    uiPrintf("ERROR::socketCreateAccept: socket failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    /* Allow immediate reuse of port */
    q_uiPrintf("setsockopt SO_REUSEADDR start\n");
    i = 1;
    res = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof(i));
    if (res != 0) {
	    uiPrintf("ERROR::socketCreateAccept: setsockopt failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }	
    q_uiPrintf("setsockopt SO_REUSEADDR end\n");

    /* Set TCP Nodelay */
    q_uiPrintf("setsockopt TCP_NODELAY start\n");
    i = 1;
    res = setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *) &i, sizeof(i));
    if (res != 0) {
	    uiPrintf("ERROR::socketCreateAccept: setsockopt failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }	
    q_uiPrintf("setsockopt TCP_NODELAY end\n");

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr =  INADDR_ANY;
    sin.sin_port = htons(pOSSock->port_num);

    q_uiPrintf("bind start\n");
    res = bind(sockfd, (struct sockaddr *) &sin, sizeof(sin));
    q_uiPrintf("bind end\n");
    if (res != 0) {
	    uiPrintf("ERROR::socketCreateAccept: bind failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    q_uiPrintf("listen start\n");
    res = listen(sockfd, 4);
    q_uiPrintf("listen end\n");
    if (res != 0) {
	    uiPrintf("ERROR::socketCreateAccept: listen failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }

    return sockfd;
}

static int
socketConnect(char *target_hostname, int target_port_num, A_UINT32 *ip_addr)
{
    int	   sfd;
    struct protoent *	proto;
    int	   res;
    struct sockaddr_in	sin;
    int	   i;
    int	   ffd;
    struct hostent *hostent;
	WORD   wVersionRequested;
	WSADATA wsaData;
//TONY
FILE *fStream;