as_echo.c

windows 网络编程。pdf文档

        /* Assign an icon to dialog box */
#ifndef WIN32
	SetClassWord(hDlg,GCW_HICON,
#else		
	SetClassLong(hDlg,GCL_HICON,
#endif
          (WORD)LoadIcon(hInst,MAKEINTRESOURCE(AS_ECHO)));

        /* Open logfile, if logging enabled */
        hLogFile = _lcreat (szLogFile, 0);
        if (hLogFile == HFILE_ERROR) { 
          MessageBox (hWinMain, "Unable to open logfile",
            "File Error", MB_OK | MB_ICONASTERISK);
        }
        /* Center dialog box */
        CenterWnd (hDlg, NULL, TRUE);
        break;
             
      default:
        break;
  } /* end switch (msg) */

  return (bRet);
} /* end Dlg_Main() */

/*---------------------------------------------------------------
 * Function: InitLstnSock()
 *
 * Description: Get a stream socket, and start listening for 
 *  incoming connection requests.
 */
BOOL InitLstnSock(int iLstnPort, PSOCKADDR_IN pstSockName, 
  HWND hWnd, u_int nAsyncMsg)
{
  int nRet;
  SOCKET hLstnSock;
  int nLen = SOCKADDR_LEN;
  
  /* Get a TCP socket to use for data connection listen */
  hLstnSock = socket (AF_INET, SOCK_STREAM, 0);
  if (hLstnSock == INVALID_SOCKET)  {
    WSAperror(WSAGetLastError(), "socket()", hInst);
  } else {
    /* Request async notification for most events */
    nRet = WSAAsyncSelect(hLstnSock, hWnd, nAsyncMsg, 
           (FD_ACCEPT | FD_READ | FD_WRITE | FD_CLOSE));
    if (nRet == SOCKET_ERROR) {
      WSAperror(WSAGetLastError(), "WSAAsyncSelect()", hInst);
    } else {
                   
      /* Name the local socket with bind() */
      pstSockName->sin_family = PF_INET;
      pstSockName->sin_port   = (u_short) htons((u_short)iLstnPort);  
      nRet = bind(hLstnSock,(LPSOCKADDR)pstSockName,SOCKADDR_LEN);
      if (nRet == SOCKET_ERROR) {
	    WSAperror(WSAGetLastError(), "bind()", hInst);
      } else {

        /* Listen for incoming connection requests */
        nRet = listen(hLstnSock, 5);
        if (nRet == SOCKET_ERROR) {
          WSAperror(WSAGetLastError(), "listen()", hInst);
        }
      }
    }
    /* If we had an error then we have a problem.  Clean up */
    if (nRet == SOCKET_ERROR) {
	  closesocket(hLstnSock);
	  hLstnSock = INVALID_SOCKET;
    }
  }
  return (hLstnSock);
} /* end InitLstnSock() */

/*--------------------------------------------------------------
 * Function: AcceptConn()
 *
 * Description: Accept an incoming connection request (this is
 *  called in response to an FD_ACCEPT event notification).
 */
SOCKET AcceptConn(SOCKET hLstnSock, PSOCKADDR_IN pstName)
{
  SOCKET hNewSock;
  int nRet, nLen = SOCKADDR_LEN;
  
  hNewSock = accept (hLstnSock, (LPSOCKADDR)pstName, (LPINT)&nLen);
  if (hNewSock == SOCKET_ERROR) {
    int WSAErr = WSAGetLastError();
    if (WSAErr != WSAEWOULDBLOCK)
      WSAperror (WSAErr, "accept", hInst);
  } else if (bReAsync) {
    /* This SHOULD be unnecessary, since all new sockets are supposed
     *  to inherit properties of the listening socket (like all the
     *  asynch events registered but some WinSocks don't do this.
     * Request async notification for most events */
    nRet = WSAAsyncSelect(hNewSock, hWinMain, WSA_ASYNC, 
           (FD_READ | FD_WRITE | FD_CLOSE));
    if (nRet == SOCKET_ERROR) {
      WSAperror(WSAGetLastError(), "WSAAsyncSelect()", hInst);
    }
    /* Try to get lots of buffer space */
    GetBuf(hNewSock, INPUT_SIZE, SO_RCVBUF);
    GetBuf(hNewSock, INPUT_SIZE, SO_SNDBUF);
  }
  return (hNewSock);
} /* end AcceptConn() */

/*--------------------------------------------------------------
 * Function: SendData()
 *
 * Description: Send data received back to client that sent it.
 */
int SendData(SOCKET hSock, LPSTR lpOutBuf, int cbTotalToSend)
{
  int cbTotalSent  = 0;
  int cbLeftToSend = cbTotalToSend;
  int nRet, WSAErr;

  /* Send as much data as we can */
  while (cbLeftToSend > 0) {
  
    /* Send data to client */
    nRet = send (hSock, lpOutBuf+cbTotalSent, 
      cbLeftToSend < MTU_SIZE ? cbLeftToSend : MTU_SIZE, 0);

    if (nRet == SOCKET_ERROR) {
      WSAErr = WSAGetLastError();
      /* Display significant errors, then close connection */
      if (WSAErr != WSAEWOULDBLOCK) {
        WSAperror(WSAErr, (LPSTR)"send()", hInst);
        PostMessage(hWinMain, WSA_ASYNC, hSock, WSAMAKEASYNCREPLY(FD_CLOSE,0));
      }
      break;
    } else {
      /* Update byte counter, and display. */
      cbTotalSent += nRet;
    }
    /* calculate what's left to send */
    cbLeftToSend = cbTotalSent - cbTotalToSend; 
  }
  return (cbTotalSent);
} /* end SendData() */

/*--------------------------------------------------------------
 * Function: RecvData()
 *
 * Description: Receive data into buffer 
 */
int RecvData(SOCKET hSock, LPSTR lpInBuf, int cbTotalToRecv)
{
  int cbTotalRcvd = 0;
  int cbLeftToRecv = cbTotalToRecv;
  int nRet=0, WSAErr;

  /* Read as much as we can buffer from client */
  while (cbLeftToRecv > 0) {

    nRet = recv (hSock,lpInBuf+cbTotalRcvd, cbLeftToRecv, 0);
    if (nRet == SOCKET_ERROR) {
      WSAErr = WSAGetLastError();
      /* Display significant errors */
      if (WSAErr != WSAEWOULDBLOCK) {
        WSAperror(WSAErr, (LPSTR)"recv()", hInst);
        PostMessage(hWinMain, WSA_ASYNC, hSock, WSAMAKEASYNCREPLY(FD_CLOSE,0));
      }
      /* exit recv() loop on any error */
      break;
    } else if (nRet == 0) { /* Other side closed socket */
      /* quit if server closed connection */
      break;
    } else {
      /* Update byte counter */
      cbTotalRcvd += nRet;
    }
    cbLeftToRecv = cbTotalToRecv - cbTotalRcvd;
  }
  return (cbTotalRcvd);
} /* end RecvData() */

/*--------------------------------------------------------------
 * Function: DoStats()
 *
 * Description: Display the connection data rate statistics
 *  (called after a connection closes in response to FD_CLOSE).
 */
void DoStats (long lByteCount, long lStartTime, LPCONNDATA lpstSock) {
  LONG dByteRate;
  LONG lMSecs;

  /* Calculate data transfer rate, and display */
  lMSecs = (LONG) GetTickCount() - lStartTime;
  if (lMSecs <= 55)
    lMSecs = 27;  /* about half of 55Msec PC clock resolution */
              
  if (lByteCount > 0L) {
    if (lpstSock) {
      wsprintf (achTempBuf,
      "<<< socket: %d disconnected from %s\r\n", 
        lpstSock->hSock, 
        inet_ntoa(lpstSock->stRmtName.sin_addr));
      _lwrite(hLogFile, achTempBuf, strlen(achTempBuf));
    }
    dByteRate = (lByteCount/lMSecs); /* data rate (bytes/Msec) */
    wsprintf (achTempBuf,
      "%ld bytes in %ld.%ld seconds (%ld.%ld Kbytes/sec)\n",
      lByteCount, 
      lMSecs/1000, lMSecs%1000, 
      (dByteRate*1000)/1024, (dByteRate*1000)%1024);
    SetDlgItemText (hWinMain, IDC_DATA_RATE, achTempBuf);
    if (hLogFile != HFILE_ERROR)
      _lwrite (hLogFile, achTempBuf, strlen(achTempBuf));
  }
} /* end DoStats() */            

/*---------------------------------------------------------------
 * Function:NewConn()
 *
 * Description: Create a new socket structure and put in list
 */
LPCONNDATA NewConn (SOCKET hSock, PSOCKADDR_IN pstRmtName) {
  int nAddrSize = sizeof(SOCKADDR);
  LPCONNDATA lpstSockTmp, lpstSock = (LPCONNDATA)0;
  HLOCAL hConnData;

  /* Allocate memory for the new socket structure */
  hConnData = LocalAlloc (LMEM_ZEROINIT, sizeof(CONNDATA));
  
  if (hConnData != 0) {
    /* Lock it down and link it into the list */
    lpstSock = LocalLock(hConnData);
    
    if (!lpstSockHead) {
      lpstSockHead = lpstSock;
    } else {
      for (lpstSockTmp = lpstSockHead; 
           lpstSockTmp && lpstSockTmp->lpstNext; 
           lpstSockTmp = lpstSockTmp->lpstNext);
      lpstSockTmp->lpstNext = lpstSock;
    }
  
    /* Initialize socket structure */
    lpstSock->hSock = hSock;
    _fmemcpy ((LPSTR)&(lpstSock->stRmtName), 
              (LPSTR)pstRmtName, sizeof(SOCKADDR));
    lpstSock->lStartTime = GetTickCount();
        
    /* Log the new connection */
    if (hLogFile != HFILE_ERROR) {
      wsprintf(achTempBuf, 
        ">>> socket: %d connected from %s\r\n", hSock, 
        inet_ntoa(lpstSock->stRmtName.sin_addr));
      _lwrite(hLogFile, achTempBuf, strlen(achTempBuf));
    }
  } else {
    MessageBox (hWinMain, "Unable allocate memory for connection",
      "LocalAlloc() Error", MB_OK | MB_ICONASTERISK);
  }
  return (lpstSock);
} /* end NewConn() */  

/*---------------------------------------------------------------
 * Function: FindConn()
 *
 * Description: Find socket structure for connection
 */
LPCONNDATA FindConn (SOCKET hSock) {
  LPCONNDATA lpstSockTmp;
  
  for (lpstSockTmp = lpstSockHead; 
       lpstSockTmp;
       lpstSockTmp = lpstSockTmp->lpstNext) {
    if (lpstSockTmp->hSock == hSock)
      break;
  }
       
  return (lpstSockTmp);
} /* end FindConn() */  

/*---------------------------------------------------------------
 * Function: RemoveConn()
 *
 * Description: Free the memory for socket structure
 */
void RemoveConn (LPCONNDATA lpstSock) {
  LPCONNDATA lpstSockTmp;
  HLOCAL hSock;

  if (lpstSock == lpstSockHead) {
    lpstSockHead = lpstSock->lpstNext;
  } else {  
    for (lpstSockTmp = lpstSockHead; 
         lpstSockTmp;
         lpstSockTmp = lpstSockTmp->lpstNext) {
      if (lpstSockTmp->lpstNext == lpstSock)
        lpstSockTmp->lpstNext = lpstSock->lpstNext;
    }     
  }
  hSock = LocalHandle(lpstSock);
  LocalUnlock (hSock);
  LocalFree (hSock);
} /* end RemoveConn() */