oswrap_win.c

Atheros AP Test with Agilent N4010A source code

//TONY		

    ffd = fileno(stdout);
	wVersionRequested = MAKEWORD( 2, 2 );
 
	res = WSAStartup( wVersionRequested, &wsaData );
	if ( res != 0 ) {
		uiPrintf("socketConnect: Could not find windows socket library\n");
		return -1;
	}
 
	if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 ) {
		uiPrintf("socketConnect: Could not find windows socket library\n");
		WSACleanup( );
		return -1; 
	}

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

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

    /* Allow immediate reuse of port */
    q_uiPrintf("setsockopt SO_REUSEADDR start\n");
    i = 1;
    res = setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof(i));
    if (res != 0) {
	    uiPrintf("ERROR::socketConnect: setsockopt SO_REUSEADDR 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(sfd, IPPROTO_TCP, TCP_NODELAY, (char *) &i, sizeof(i));
    if (res != 0) {
	    uiPrintf("ERROR::socketCreateAccept: setsockopt TCP_NODELAY failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }	
    q_uiPrintf("setsockopt TCP_NODELAY end\n");

    q_uiPrintf("gethostbyname start\n");
    q_uiPrintf("socket_connect: target_hostname = '%s'\n", target_hostname);
    hostent = gethostbyname(target_hostname);
    q_uiPrintf("gethostbyname end\n");
    if (!hostent) {
	    uiPrintf("ERROR::socketConnect: gethostbyname failed: %d\n", WSAGetLastError());
        WSACleanup( );
	    return -1;
    }	

    memcpy(ip_addr, hostent->h_addr_list[0], hostent->h_length);
    *ip_addr = ntohl(*ip_addr);
    memset(&sin,'\0',sizeof(struct sockaddr_in));
    sin.sin_family = AF_INET;
    memcpy(&sin.sin_addr.s_addr, hostent->h_addr_list[0], hostent->h_length);
    sin.sin_port = htons((short)target_port_num);
	//printf("****sin_port :%d\n",sin.sin_port);
	//printf("***************sin_addr :%s\n",(sin.sin_addr.s_addr));
	//TONY
    for (i = 0; i < 20; i++) {
		//printf("***CONNECT ******\n");
        q_uiPrintf("connect start %d\n", i);
	    res = connect(sfd, (struct sockaddr *) &sin, sizeof(sin));
        q_uiPrintf("connect end %d\n", i);
			//printf("***CONNECT END  ******\n");
	    if (res == 0) {
	        break;
	    }
	    milliSleep(1);
    }
    if (i == 20) {
//TONY
printf("Problem with ART Target - Crystal problem?");
	if( (fStream = fopen("ArtLog.txt", "w+")) == NULL ) {
                        printf("\nFailed to open ArtLog.txt\n");
            return;
        }
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'0',fStream);
	fputc((int)'1',fStream);

	fclose(fStream);
	exit(0);
//TONY
	    uiPrintf("ERROR::connect failed completely\n");
        WSACleanup( );
	    return -1;
    }

    return sfd;
}

A_UINT32 semInit
(
	void
) 
{
	HANDLE hSemaphore;

	hSemaphore = CreateSemaphore(NULL, 1, 1, NULL);

	if (hSemaphore == NULL) {
		return 0;
	}

	return (A_UINT32)hSemaphore;
}

A_INT32 semLock
(
	A_UINT32 sem
)
{
	HANDLE hSemaphore;

	hSemaphore = (HANDLE)sem;
	if (WaitForSingleObject(hSemaphore, INFINITE) == WAIT_FAILED) {
		return -1;
	}

	return 0;
}

A_INT32 semUnLock
(
	A_UINT32 sem
)
{
	HANDLE hSemaphore;

	hSemaphore = (HANDLE)sem;
	if (ReleaseSemaphore(hSemaphore, 1, NULL) == 0) {
		return -1;
	}

	return 0;
}

A_INT32 semClose
(
	A_UINT32 sem
)
{
	HANDLE hSemaphore;

	hSemaphore = (HANDLE)sem;
	if (CloseHandle(hSemaphore) == 0) {
		return -1;
	}

	return 0;
}

A_UINT32 os_com_open(OS_SOCK_INFO *pOSSock) {
    DCB          dcb;
    A_UINT32 nComErr=0;
    A_UINT32 err=0;

	// Close the port 
    (void)os_com_close(pOSSock);

    // device handle
    pOSSock->sockfd = (A_UINT32) CreateFile( pOSSock->hostname,                             // port name
                       GENERIC_READ | GENERIC_WRITE,     // allow r/w access
                       0,                                // always no sharing
                       0,                                // no security atributes for file
                       OPEN_EXISTING,                    // always open existing
                       //FILE_FLAG_OVERLAPPED,            // overlapped operation   
                       FILE_FLAG_NO_BUFFERING,            // non-overlapped operation   
                       0);                               // always no file template

    if ((HANDLE)pOSSock->sockfd == INVALID_HANDLE_VALUE) {
       nComErr = nComErr | COM_ERROR_GETHANDLE;
       return 0;
    }

    // port configuration
    FillMemory (&dcb, sizeof(dcb),0);
    dcb.DCBlength = sizeof(dcb);
//    if (!BuildCommDCB("19200,n,8,1", &dcb)) {
    if (!BuildCommDCB("38400,n,8,1", &dcb)) {
    //if (!BuildCommDCB("115200,n,8,1", &dcb)) {
       nComErr = nComErr | COM_ERROR_BUILDDCB;
       return nComErr;
    }
    dcb.fOutX = FALSE;
    dcb.fInX = FALSE;
    dcb.fDtrControl = DTR_CONTROL_DISABLE;
    dcb.fRtsControl = RTS_CONTROL_DISABLE;
    dcb.fOutxCtsFlow = FALSE;
    dcb.fOutxDsrFlow = FALSE;
    dcb.fDsrSensitivity = FALSE;
    if (!SetCommState((HANDLE) pOSSock->sockfd, &dcb)) {
       nComErr = nComErr | COM_ERROR_CONFIGDEVICE;
       return nComErr;
    }
    if (!SetupComm((HANDLE) pOSSock->sockfd, READ_BUF_SIZE, WRITE_BUF_SIZE)) {
       nComErr = nComErr | COM_ERROR_CONFIGBUFFERS;
       return nComErr;
    }
    if (!EscapeCommFunction((HANDLE) pOSSock->sockfd, SETDTR)) {
       nComErr = nComErr | COM_ERROR_SETDTR;
       return nComErr;
    }
    if (!PurgeComm((HANDLE) pOSSock->sockfd, PURGE_RXABORT | PURGE_RXCLEAR |
                       PURGE_TXABORT | PURGE_TXCLEAR)) {
       nComErr = nComErr | COM_ERROR_PURGEBUFFERS;
       return nComErr;
    }
	

    // set mask to notify thread if a character was received
    if (!SetCommMask((HANDLE) pOSSock->sockfd, EV_RXCHAR|EV_BREAK|EV_RXFLAG)) {
       // error setting communications event mask
       nComErr = nComErr | COM_ERROR_CONFIGDEVICE;
       return nComErr;
    }


    return 0;
}

A_UINT32 os_com_close(OS_SOCK_INFO *pOSSock) { 

    // reset error byte
    A_UINT32 nComErr = 0;

    if (inSignalHandler == TRUE) return -1;

    if (!EscapeCommFunction((HANDLE) pOSSock->sockfd, CLRDTR)) {
       nComErr = nComErr | COM_ERROR_CLEARDTR;
       return nComErr;
    }
    if (!PurgeComm((HANDLE) pOSSock->sockfd, PURGE_RXABORT | PURGE_RXCLEAR |
                       PURGE_TXABORT | PURGE_TXCLEAR)) {
       nComErr = nComErr | COM_ERROR_PURGEBUFFERS;
       return nComErr;
    }

    // device handle
    CloseHandle((HANDLE) pOSSock->sockfd);
	

    return 0;

}

A_UINT32 write_device(OS_SOCK_INFO *pOSSock, A_UINT8 *buf, A_INT32 *len) {
    A_UINT32 nComErr; A_INT32 written_len, tmp_len;
    A_UINT32 status, jIndex=0, numblocks, remaining_bytes;

    	// reset error byte
    	nComErr = 0;
	written_len = *len;
	// split the write

	numblocks = (*len/WRITE_BUF_SIZE); 
	remaining_bytes = *len - (numblocks * WRITE_BUF_SIZE);
#ifdef _DEBUG
	q_uiPrintf("write_device::sockfd=%x:", pOSSock->sockfd);
	q_uiPrintf("numblocks = %d:remainingbytes = %x\n", numblocks, remaining_bytes);
#endif
	for(jIndex=0; jIndex<numblocks; jIndex++) {
       status = WriteFile((HANDLE) pOSSock->sockfd, (const char *)&buf[jIndex * WRITE_BUF_SIZE], WRITE_BUF_SIZE, (A_UINT32 *)&tmp_len, NULL);
       if (!status || tmp_len != WRITE_BUF_SIZE) {
           //nComErr = nComErr | COM_ERROR_WRITE;
           nComErr = GetLastError();
			uiPrintf("write_device::Error=%x", nComErr);
           return nComErr;
       }
	  // milliSleep(5);
	}
	if (remaining_bytes) {	
    // write the com port
       status = WriteFile((HANDLE) pOSSock->sockfd, (const char *)&buf[jIndex * WRITE_BUF_SIZE], remaining_bytes, (A_UINT32 *)&tmp_len, NULL);
       if (!status || tmp_len != (A_INT32) remaining_bytes) {
           nComErr = nComErr | COM_ERROR_WRITE;
           nComErr = GetLastError();
		   uiPrintf("write_device::Error=%x", nComErr);
           return nComErr;
       }
	}

    return 0;

}

A_UINT32 os_com_read(OS_SOCK_INFO *pOSSock, A_UINT8 *buf, A_INT32 *len) {

    A_UINT32 dwCommEvent;
    DWORD dwRead, pos = 0, numCharsToRead, numCharsInBuffer, iIndex;
	A_UINT8 *chReadBuf;
    A_UINT32 nComErr;

    // reset error byte
    nComErr = 0;
#ifdef _DEBUG
	uiPrintf("os_com_read::");
	uiPrintf("enter while loop::with *len = %d\n", *len);
#endif

	chReadBuf=buf;


    while(pos < (A_UINT32)*len) {


	  numCharsInBuffer = getBytesBuffered((HANDLE)pOSSock->sockfd, IN_QUEUE);

	  if (numCharsInBuffer == 0) { 

		  // Wait for the event

#ifdef _DEBUG
	      uiPrintf("Waiting for Event:numCharsInBuffer = %d\n", numCharsInBuffer);
#endif

          if ( WaitCommEvent((HANDLE) pOSSock->sockfd, &dwCommEvent, NULL)) {
#ifdef _DEBUG
			  uiPrintf("Event obtained = %x:pos=%d:*len=%d\n", dwCommEvent, pos, *len);
#endif
	         if (!(dwCommEvent&EV_RXCHAR) ) continue;
	      }
	      else continue;

	  }

       // read receive buffer
	  dwRead=0;

	  numCharsInBuffer = getBytesBuffered((HANDLE)pOSSock->sockfd, IN_QUEUE);
	
	  if (numCharsInBuffer == 0)  continue;

	  if (numCharsInBuffer > (A_UINT32)(*len-pos))
		numCharsToRead = (*len-pos);
	  else
		numCharsToRead = numCharsInBuffer;
		  
#ifdef _DEBUG
	  	//	printf("pos=%d:len=%d\n", pos, *len);
		//	printf("Number of bytes in buffer=%d:to request=%d:pos=%d:total to read=%d\n", numCharsInBuffer, numCharsToRead, pos, *len);
#endif

      if (ReadFile((HANDLE) pOSSock->sockfd, chReadBuf, numCharsToRead, &dwRead, NULL)) {
		 if (dwRead != numCharsToRead) {
			printf("WARNING:: Number of bytes in buffer=%d:requested=%d:read=%d\n", numCharsInBuffer, numCharsToRead, dwRead);
		 }
		 for(iIndex=0; iIndex<dwRead; iIndex++) {
#ifdef _DEBUG
	        uiPrintf("%x ", buf[pos]);
#endif
			pos++;
		    chReadBuf++;
		 }
      }
      else {
        nComErr = nComErr | COM_ERROR_READ;
        return nComErr;
      }
	} 
    *len=pos;
    return 0;

}

A_UINT32 read_device(OS_SOCK_INFO *pOSSock, A_UINT8 *buf, A_INT32 *len) {
    A_UINT32 pos = 0, dwRead;
    A_UINT32 nComErr=0;

#ifdef _DEBUG
       q_uiPrintf("Read %d bytes from device::\n", *len);
#endif
          // read receive buffer
          if (ReadFile((HANDLE) pOSSock->sockfd, lpBuffer, *len, &dwRead, NULL)) {
#ifdef _DEBUG
                  q_uiPrintf("read_device::number of bytes read=%d\n", dwRead);
#endif
				  for(pos=0;pos<dwRead;pos++) {
					buf[pos]=lpBuffer[pos];
#ifdef _DEBUG
					q_uiPrintf("%x ", buf[pos]);
#endif
				  }

          }
          else {
             nComErr =  GetLastError();
             uiPrintf("ERROR:read_device::Error=%x", nComErr);
          }
       return nComErr;

}



DWORD getBytesBuffered(HANDLE handle, DWORD queueType) {

    COMSTAT comStat;
	DWORD dwErrors;

	if (!ClearCommError(handle, &dwErrors, &comStat)) {
		printf("ERROR:: ClearCommError :%x\n", GetLastError());
		return 0;
	}

	switch(queueType) {
	  case IN_QUEUE:
			return comStat.cbInQue;
			break;
	  case OUT_QUEUE:
			return comStat.cbOutQue;
			break;
	}
    return 0;
}