> | # MFC TCP Server Sample ## Introduction This sample demonstrates how to write a TCP server application using the MFC socket architecture to communicate with a SG15. For the purpose of this demonstration, the server application creates a networking socket it uses to listen for incoming networking connections. A TCP connection is initiated by the SG15 to the sample application. Once the connection is established, the sample application attempts to transmit and receive data from the SG15. ## SG15 Setup This sample was designed to operate with the SG15 operating in TCP Client mode. Configure the SG15 1. Use the SG15 configuration tool to access the settings of this specific SG15. 2. Choose the "Network" tab from the Configuration menu. 3. Configure the module to function as a TCP client by doing the following: a. Check "TCP" and "Client" in the Connect Mode section. b. Enter the IP address of the PC running the sample in the "Remote IP" field. c. Specify 9101 as the TCP port number. d. Click "Apply now". ## How To Build This sample has been written and tested with Microsoft Visual C++® 6.0. It contains a Developer Studio Workspace file (.dsw), that can be opened in the development environment for editing and compiling. To build this sample from within Microsoft Visual C++® 6.0 1. Select File > Open Workspace... from the main menu. 2. Locate and open the .dsw file for this sample. 3. Select Build > Rebuild All menu items to compile the sample. ## Step-by-Step 1. Initialize Windows Sockets The following initialization code should be in the main `CWinApp` derived object's overridable `InitInstance` function.
>     if (!AfxSocketInit())
>     {
>        AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
>        return FALSE;
>     }
> Initializing Windows Sockets is critical. Failing to initialize Windows Sockets will cause all other socket function calls to fail. 2. Create a local socket The call to create a socket looks like this:
>     m_ListenSocket.Create(9101);
> In this sample, the listening socket is represented by the `CAsyncSocket` derived class `CMySocket`. An object of `CMySocket` type is declared as a private member variable of the main dialog class and named `m_ListenSocket`. `m_ListenSocket` is unusable until its `Create` member function is called, which is done in the main dialog's `OnInitDialog` overridable function. Since this sample demonstrates a server application, the port (`9101`) is supplied to the call to `Create`. The same port is also used by the. The remaining default parameters of the `Create` function are sufficient for the application's purposes. 3. Listen for incoming connections Start listening for incoming connection requests by calling the `Listen` member function.
>     m_ListenSocket.Listen(1);
> Calling `Listen` puts the socket into a relatively inactive mode where it waits for incoming connection requests from a client. Connection requests are queued until processed in a "backlog". The size of this backlog is specified in the single parameter to the call to `Listen`. The socket object is notified of incoming connection requests via its `OnAccept` overridable notification function. 4. Accept incoming connection When notified of an incoming connection request, call `Accept`.
>     m_ListenSocket.Accept(m_ConnectedSocket);
> By calling `Accept`, you accept the first incoming connection request in the backlog queue and establish a TCP session to the client, The new connection is represented by the socket object passed in as the first argument (`m_ConnectedSocket`). The listening socket remains in the passive listening mode, and the connected socket object is used to communicate with the client. 5. Transmit data Transmitting data is done by calling the connected socket's `Send` member functions.
>     m_ConnectedSocket.Send(Data, Length);
> Once the incoming connection request has been accepted, and the new connected socket object is valid, the sample uses it to transmit some data. The sample is not concerned about sending out-of-band data or routing of the TCP packet, so the only parameters needed for the `Send` function are: `Data` which is a pointer to a buffer containing the data to transmit, and `Length` which is the number of bytes of data in the buffer. 7. Receive data To retrieve data, the socket's `Receive` member function is called. In the function call the sample provides a buffer (`Data`) to store the incoming data, and the length (`sizeof(Data)`) of that buffer in bytes.
>     m_ConnectedSocket.Receive(Data, sizeof(Data));
> With the SG15 setup in TCP Client mode, a scanned barcode will be sent directly to the sample application. The socket is notified that data has arrived for it when it receives the `OnReceive` notification. 8. Close the connected socket Accomplish this task by calling the following two functions:
>     m_ConnectedSocket.ShutDown(CAsyncSocket::both);
>     m_ConnectedSocket.Close();
The sample application's connected socket will be notified that the connection has been closed by the client when it receives the `OnClose` notification. The socket should then be terminated properly (`ShutDown`) and any resources it may be using should be released (`Close`). ## File List HexDumpData.cpp HexDumpData.h MySocket.cpp MySocket.h resource.h StdAfx.cpp StdAfx.h TCPServer.cpp TCPServer.dsp TCPServer.h TCPServer.rc TCPServerDlg.cpp TCPServerDlg.h res\TCPServer.ico res\TCPServer.rc2 ## Keywords CAsyncSocket::Create; CAsyncSocket::Connect; CAsyncSocket::OnConnect; CAsyncSocket::Send; CAsyncSocket::Receive; CAsyncSocket::OnReceive