文档库
文档库 最新最全的文档下载
当前位置：文档库 › 实验二 网络基础编程实验

实验二 网络基础编程实验

实验二 网络基础编程实验
实验二 网络基础编程实验

《计算机网络》实验报告

信息安全

2015年4月1日

实验二网络基础编程实验

一、实验目的

通过本实验，学习采用Socket（套接字）设计简单的网络数据收发程序，理解应用数据包是如何通过传输层进行传送的。

二、实验内容

2.1、编写TCP进行数据发送的简单程序（java）

T C P C l i e n t.j a v a T C P S e r v e r.j a v a

2.2、编写UDP进行数据发送的简单程序（java）

UDPServer.java UDPClient.java

2.3多线程\线程池对比

TCPEchoClient.java

TCPEchoServer.java TCPEchoServerThread.java TCPEchoServerPool.java

2.4写一个简单的chat程序，编程语言不限。

三、实验程序

（1）TCP客户端TcpClient.java

import java.io.*;

import https://www.wendangku.net/doc/d09478232.html,.*;

public class TcpClient{

public static void main(String argv[]) throws Exception {

String sentence;//定义客户消息

String modifiedSentence;//定义服务器消息

InetAddress address = InetAddress.getLocalHost();//获取本机端口

BufferedReader inFromUser = new BufferedReader( new InputStreamReader(Syst em.in)); //创建客户输入流

//创建一个Scoket实例：构造函数向指定的远程主机和端口建立一个TCP连接。add ress.getHostName()为本机IP地址；6789为TCP服务器端口

Socket clientSocket = new Socket(address.getHostName(),6789); //客户套接字 //通过套接字的输入输出流(I/O streams)进行通信

DataOutputStream outToServer = new DataOutputStream( clientSocket.getOutput Stream()); //创建客户端到服务器的输出流

BufferedReader inFromServer = new BufferedReader( new InputStreamReader(cli entSocket.getInputStream())); //创建服务端输入流

sentence = inFromUser.readLine();//客户端读取客户输入消息

outToServer.writeBytes(sentence+'\n'); //客户端发送消息到服务器端

modifiedSentence =inFromServer.readLine();//客户端接收来自服务器的消息

System.out.println("client receive from TCP server:" + modifiedSentence);/ /客户端显示服务器发送过来的消息

clientSocket.close(); //客户端关闭套接字

}

}

（2）TCP服务器端TcpServer.java

import java.io.*;

import https://www.wendangku.net/doc/d09478232.html,.*;

public class TcpServer {

public static void main(String argV[]) throws Exception {

String clientSentence;//定义接收的消息

String capitalizedSentence;//定义发送的消息

ServerSocket welcomeSocket= new ServerSocket(6789);

//创建一个ServerSocket实例，并指定本地端口，侦听该指定端口收到的连接

while(true){

Socket connectionSocket = welcomeSocket.accept();

//调用ServerSocket的accept()方法以获取下一个客户端连接，基于新建立的客户端连接，创建一个Socket实例，并由accept()方法返回。

BufferedReader inFromClient = new BufferedReader( new InputStreamReade r(connectionSocket.getInputStream()));//创建客户端输入流

DataOutputStream outToClient = new DataOutputStream(connectionSocket.g etOutputStream());//创建服务器输出流

//使用所返回的Socket实例的InputStream和OutputStream与客户端进行通信。

clientSentence = inFromClient.readLine(); //接收客户发送的信息 capitalizedSentence = clientSentence.toUpperCase()+'\n'; //转换接收到的信息，小写变大写

outToClient.writeBytes("TCP accept "+capitalizedSentence);//输出给客户端

}

}

}

（3）UDP通信服务器端 UDPServer.java

import java.io.*;

import https://www.wendangku.net/doc/d09478232.html,.*;

public class UDPServer {

public static void main(String argV[]) throws Exception {

DatagramSocket serverSocket = new DatagramSocket (9876); //构造数据包套接字并将其绑定到主机上的端口9876

byte[] receiveData = new byte[1024]; //服务器从客户端接收到的信息

byte[] sendData = new byte[1024]; //服务器发送给客户端的信息

while(true){

DatagramPacket receivePacket = new DatagramPacket(receiveData,receiveD ata.length); //创建从客户端数据包

serverSocket.receive(receivePacket); //服务器从客户端接收数据包

String sentence = new String(receivePacket.getData()); //服务器接打开数据包得到消息

InetAddress IPAddress = receivePacket.getAddress();//获取客户端的IP地址

int port = receivePacket.getPort();//获取客户端端口

String capitalizedSentence = sentence.toUpperCase();//将接收的信息转为大写

sendData = capitalizedSentence.getBytes(); //转换后的消息

//服务器发送给客户端的数据包，将转换后的消息打包

DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.lengt h,IPAddress,port);

serverSocket.send(sendPacket);//服务器发送数据包给客户端 }

}

}

（4）UDP通信客户端 UDPClient.java

import java.io.*;

import https://www.wendangku.net/doc/d09478232.html,.*;

public class UDPClient{

public static void main(String argv[]) throws Exception {

byte[] receiveData = new byte[1024]; //客户端接收的消息

byte[] sendData = new byte[1024]; //客户端发送的消息

BufferedReader inFromReader = new BufferedReader( new InputStreamReader(Sy stem.in));//客户输入流

DatagramSocket clientSocket = new DatagramSocket (); //客户端数据包套接字 InetAddress IPAddress = InetAddress.getLocalHost(); //获取本机IP地址

String sentence = inFromReader.readLine(); //客户端读取用户所输入的消息 sendData = sentence.getBytes(); //复制到要发送的消息

//客户端发送的数据包，这里将客户端要发送的消息，客户端的IP地址，端口打包 DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,IP Address,9876);

clientSocket.send(sendPacket);//客户端套接字发送数据包

//客户端接收的数据包，数据包包含从服务器接收的消息，消息长度

DatagramPacket receivePacket = new DatagramPacket(receiveData,receiveData. length);

clientSocket.receive(receivePacket); //客户端接收数据包

String modifiedSentence = new String(receivePacket.getData()); //将接收的数据包解开

System.out.println("client receive from UDP server: " + modifiedSentence + " from from the client!"); //客户端显示数据包里的消息

clientSocket.close(); //关闭套接字

}}

(5)通过TCP协议与回馈服务器（echo server）进行通信的客户端TCPEchoClient.java import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import https://www.wendangku.net/doc/d09478232.html,.ServerSocket;

import https://www.wendangku.net/doc/d09478232.html,.Socket;

import https://www.wendangku.net/doc/d09478232.html,.SocketAddress;

public class TCPEchoServer{

private static final int BUFSIZE = 32;

public static void main(String[] args) throws IOException{

if (args.length != 1)//获取启动服务的端口

throw new IllegalArgumentException("Parameter(s): ");

int servPort = Integer.parseInt(args[0]);

//分配一个端口用于启动server端

ServerSocket servSock = new ServerSocket(servPort);

int recvMsgSize;

byte[] receiveBuf = new byte[BUFSIZE];

while (true){

Socket clntSock = servSock.accept(); //接收客户端的主动连接

SocketAddress clientAddress = clntSock.getRemoteSocketAddress();

System.out.println("Handling client at " + clientAddress);

InputStream in = clntSock.getInputStream();

OutputStream out = clntSock.getOutputStream();

while ((recvMsgSize = in.read(receiveBuf)) != -1)

out.write(receiveBuf, 0, recvMsgSize);

clntSock.close();

}}}

(6)为前面的客户端程序实现回馈服务器TCPEchoServer.java

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import https://www.wendangku.net/doc/d09478232.html,.Socket;

import https://www.wendangku.net/doc/d09478232.html,.SocketException;

public class TCPEchoClient{

public static void main(String[] args) throws IOException{

if ((args.length < 2) || (args.length > 3)) // 传入的数据在2~3之间，0：地址 1：传输字符 <2：端口>

throw new IllegalArgumentException("Parameter(s): []");

String server = args[0]; // ip地址或主机名称

byte[] data = args[1].getBytes();

int servPort = (args.length == 3) ? Integer.parseInt(args[2]) : 7; //默认端口为7

Socket socket = new Socket(server, servPort);

System.out.println("Connected to server...sending echo string");

InputStream in = socket.getInputStream();

OutputStream out = socket.getOutputStream();

out.write(data);

int totalBytesRcvd = 0;

int bytesRcvd;

while (totalBytesRcvd < data.length) {

if ((bytesRcvd = in.read(data, totalBytesRcvd,data.length - totalB ytesRcvd)) == -1)

throw new SocketException("Connection closed prematurely");

totalBytesRcvd += bytesRcvd;

}

System.out.println("Received: " + new String(data));

socket.close();

}}

(7)一客户一线程

//二、每个客户端请求都新启一个线程的Tcp服务端：import java.io.IOException; import https://www.wendangku.net/doc/d09478232.html,.ServerSocket;

import https://www.wendangku.net/doc/d09478232.html,.Socket;

import java.util.logging.Logger;

public class TCPEchoServerThread {

public static void main(String[] args) throws Exception {//IOException

ServerSocket servSock = new ServerSocket(5500);

Logger logger = Logger.getLogger("practical");

while (true) {

Socket clntSock = servSock.accept(); // Block waiting for connectio Thread thread = new Thread(new EchoProtocol(clntSock, logger));

thread.start();

https://www.wendangku.net/doc/d09478232.html,("Created and started Thread " + thread.getName()); }}}

(8)线程池

//三、固定线程数的Tcp服务端

import java.io.IOException;

import https://www.wendangku.net/doc/d09478232.html,.ServerSocket;

import https://www.wendangku.net/doc/d09478232.html,.Socket;

import java.util.logging.Level;

import java.util.logging.Logger;

public class TCPEchoServerPool {

public static void main(String[] args) throws IOException {

int threadPoolSize = 3; // Fixed ThreadPoolSize

final ServerSocket servSock = new ServerSocket(5500);

final Logger logger = Logger.getLogger("practical");

for (int i = 0; i < threadPoolSize; i++) {

Thread thread = new Thread() {

public void run() {

while (true) {

try {

Socket clntSock = servSock.accept(); //等待连接 EchoProtocol.handleEchoClient(clntSock, logger); // 等待 } catch (IOException ex) {

logger.log(Level.WARNING, "Client accept failed", e x);

}}}};

thread.start();

https://www.wendangku.net/doc/d09478232.html,("Created and started Thread = " + thread.getName()); }}}

(9)聊天程序服务器端 NetChatServerDlg.cpp

#include "stdafx.h"

#include "NetChatServer.h"

#include "NetChatServerDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

CNetChatServerDlg::CNetChatServerDlg(CWnd* pParent /*=NULL*/)

: CDialog(CNetChatServerDlg::IDD, pParent)

{

m_serverPort = 1130;

m_serverSocket = INVALID_SOCKET;

m_clientSocket = INVALID_SOCKET;

memset(&m_clientAddr, 0, sizeof(m_clientAddr));

m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

}

void CNetChatServerDlg::DoDataExchange(CDataExchange* pDX){

//{{AFX_DATA_MAP(CNetChatServerDlg)

DDX_Control(pDX, IDC_PORT, m_portCtrl);

DDX_Control(pDX, IDC_EDIT_MSG, m_editMsg);

DDX_Control(pDX, IDC_SHOW_MSG, m_showMsg);

DDX_Text(pDX, IDC_PORT, m_serverPort);

}

BEGIN_MESSAGE_MAP(CNetChatServerDlg, CDialog)

//{{AFX_MSG_MAP(CNetChatServerDlg)

ON_MESSAGE(WM_SOCKET,OnSocket)

ON_WM_SYSCOMMAND()

ON_WM_PAINT()

ON_WM_QUERYDRAGICON()

ON_BN_CLICKED(IDC_START_SERVER, OnStartServer)

ON_BN_CLICKED(IDC_SEND_MSG, OnSendMsg)

ON_EN_MAXTEXT(IDC_SHOW_MSG, OnMaxtextShowMsg)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

BOOL CNetChatServerDlg::OnInitDialog(){

CDialog::OnInitDialog();

SetIcon(m_hIcon, TRUE); // Set big icon

SetIcon(m_hIcon, FALSE); // Set small icon

// TODO: Add extra initialization here

CtrlState(FALSE);

m_portCtrl.SetLimitText(5);//65535

return TRUE; // return TRUE unless you set the focus to a control }

void CNetChatServerDlg::OnSysCommand(UINT nID, LPARAM lParam){ if((nID & 0xFFF0) == SC_CLOSE && m_serverSocket != INVALID_SOCKET) OnStartServer();

CDialog::OnSysCommand(nID, lParam);

}

void CNetChatServerDlg::OnPaint() {

if (IsIconic()){

CPaintDC dc(this); // device context for painting

SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

int cxIcon = GetSystemMetrics(SM_CXICON);

int cyIcon = GetSystemMetrics(SM_CYICON);

CRect rect;

GetClientRect(&rect);

int x = (rect.Width() - cxIcon + 1) / 2;

int y = (rect.Height() - cyIcon + 1) / 2;

dc.DrawIcon(x, y, m_hIcon);

}

else

CDialog::OnPaint();

}

HCURSOR CNetChatServerDlg::OnQueryDragIcon(){

return (HCURSOR) m_hIcon;

}

BOOL CNetChatServerDlg::PreTranslateMessage(MSG* pMsg) {

return CDialog::PreTranslateMessage(pMsg);

}

void CNetChatServerDlg::CtrlState(BOOL state){

m_editMsg.EnableWindow(state);

GetDlgItem(IDC_SEND_MSG)->EnableWindow(state);

}

void CNetChatServerDlg::OnStartServer() {

CString msg;

m_showMsg.GetWindowText(msg);

if(m_serverSocket != INVALID_SOCKET)//已经启动服务器，则停止服务器{ if(m_clientSocket != INVALID_SOCKET)

::closesocket(m_clientSocket);

::closesocket(m_serverSocket);

::WSACleanup();

CtrlState(FALSE);

GetDlgItem(IDC_START_SERVER)->SetWindowText("启动服务器");

m_portCtrl.EnableWindow(TRUE);

m_serverSocket = INVALID_SOCKET;

m_clientSocket = INVALID_SOCKET;

msg += "\r\n服务器已停止!";

}

else//启动服务器{

UpdateData(TRUE);

if(m_serverPort > 65535){

AfxMessageBox("服务器端口溢出!请重新设定!");

return;

}

WSADATA data;

if(::WSAStartup(MAKEWORD(2, 2), &data)){

AfxMessageBox("启动套接字失败!");

return;

}

sockaddr_in addr;

addr.sin_family = AF_INET;

addr.sin_port = htons(m_serverPort);

addr.sin_addr.S_un.S_addr = INADDR_ANY;

m_serverSocket = ::socket(AF_INET,SOCK_STREAM,0);

if(INVALID_SOCKET == m_serverSocket ||

::bind(m_serverSocket, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ER ROR ||

::listen(m_serverSocket, 1) == SOCKET_ERROR ||

::WSAAsyncSelect(m_serverSocket, this->m_hWnd, WM_SOCKET, FD_ACCEPT |FD_READ|FD_CLOSE) == SOCKET_ERROR){

AfxMessageBox("创建服务器失败!");

::WSACleanup();

m_serverSocket = INVALID_SOCKET;

return;

}

m_portCtrl.EnableWindow(FALSE);

GetDlgItem(IDC_START_SERVER)->SetWindowText("停止服务器");

msg += "\r\n服务器已启动";

}

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

void CNetChatServerDlg::OnSendMsg() {

if(m_clientSocket != INVALID_SOCKET){

char send[500] = {0};

m_editMsg.GetWindowText(send, sizeof(send) - 1);

int strlength = strlen(send);

if(strlength < 1){

MessageBox("发送内容不能为空!");

return;

}

CString msg;

m_showMsg.GetWindowText(msg);

if(::send(m_clientSocket, send, strlength, 0) != SOCKET_ERROR){ msg += "\r\n本机:\r\n";

msg += send;

}

else

msg += "\r\n本机: 消息发送失败!";

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

}

void CNetChatServerDlg::OnSocket(WPARAM wParam,LPARAM lParam){

switch (lParam){

case FD_ACCEPT:{

int lenth = sizeof(m_clientAddr);

if(m_clientSocket != INVALID_SOCKET){

sockaddr_in addr;

lenth = sizeof(addr);

SOCKET s = ::accept(m_serverSocket, (sockaddr *)&addr, &lenth);

::closesocket(s);

break;

}

m_clientSocket = ::accept(m_serverSocket, (sockaddr *)&m_clientAddr, &lenth);

if(INVALID_SOCKET != m_clientSocket){

CString msg;

m_showMsg.GetWindowText(msg);

msg += "\r\n有客户端连接:";

msg += ::inet_ntoa(m_clientAddr.sin_addr);

CtrlState(TRUE);

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

}

break;

case FD_READ:{

char get[500] = {0};

::recv(m_clientSocket, get, sizeof(get) - 1, 0);

CString msg;

m_showMsg.GetWindowText(msg);

msg += "\r\n";

msg += ::inet_ntoa(m_clientAddr.sin_addr);

msg += ":\r\n";

msg += get;

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

break;

case FD_CLOSE:{

m_clientSocket = INVALID_SOCKET;

CString msg;

m_showMsg.GetWindowText(msg);

msg += "\r\n客户端断开:";

CtrlState(FALSE);

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

break;

}

}

void CNetChatServerDlg::OnMaxtextShowMsg() {

m_showMsg.SetWindowText("消息，自动清理!");

}

(10)聊天程序客户端 NetChatClientDlg.cpp

#include "stdafx.h"

#include "NetChatClient.h"

#include "NetChatClientDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

// CNetChatClientDlg dialog

CNetChatClientDlg::CNetChatClientDlg(CWnd* pParent /*=NULL*/) : CDialog(CNetChatClientDlg::IDD, pParent)

{

//{{AFX_DATA_INIT(CNetChatClientDlg)

m_port = 1130;

//}}AFX_DATA_INIT

m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

m_clientSocket = INVALID_SOCKET;

}

void CNetChatClientDlg::DoDataExchange(CDataExchange* pDX){ CDialog::DoDataExchange(pDX);

//{{AFX_DATA_MAP(CNetChatClientDlg)

DDX_Control(pDX, IDC_SHOW_MSG, m_showMsg);

DDX_Control(pDX, IDC_EDIT_MSG, m_editMsg);

DDX_Control(pDX, IDC_IPADDR, m_ipAddr);

DDX_Control(pDX, IDC_PORT, m_portCtrl);

DDX_Text(pDX, IDC_PORT, m_port);

//}}AFX_DATA_MAP

}

BEGIN_MESSAGE_MAP(CNetChatClientDlg, CDialog)

//{{AFX_MSG_MAP(CNetChatClientDlg)

ON_WM_SYSCOMMAND()

ON_WM_PAINT()

ON_WM_QUERYDRAGICON()

ON_BN_CLICKED(IDC_SEND, OnSend)

ON_BN_CLICKED(IDC_CONNECT, OnConnect)

ON_WM_TIMER()

ON_MESSAGE(WM_SOCKET,OnSocket)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

BOOL CNetChatClientDlg::OnInitDialog(){

CDialog::OnInitDialog();

SetIcon(m_hIcon, TRUE); // Set big icon

SetIcon(m_hIcon, FALSE); // Set small icon

m_ipAddr.SetWindowText("192.168.1.104");

CtrlState(TRUE);

return TRUE; // return TRUE unless you set the focus to a control }

void CNetChatClientDlg::OnSysCommand(UINT nID, LPARAM lParam){ if ((nID & 0xFFF0) == SC_CLOSE && m_clientSocket != INVALID_SOCKET) OnConnect();

CDialog::OnSysCommand(nID, lParam);

}

void CNetChatClientDlg::OnPaint(){

if (IsIconic()){

CPaintDC dc(this); // device context for painting

SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

int cxIcon = GetSystemMetrics(SM_CXICON);

int cyIcon = GetSystemMetrics(SM_CYICON);

CRect rect;

GetClientRect(&rect);

int x = (rect.Width() - cxIcon + 1) / 2;

int y = (rect.Height() - cyIcon + 1) / 2;

dc.DrawIcon(x, y, m_hIcon);

}

else

CDialog::OnPaint();

}

HCURSOR CNetChatClientDlg::OnQueryDragIcon(){

return (HCURSOR) m_hIcon;

}

BOOL CNetChatClientDlg::PreTranslateMessage(MSG* pMsg) {

return CDialog::PreTranslateMessage(pMsg);

}

void CNetChatClientDlg::OnSend() {

if(m_clientSocket != INVALID_SOCKET){

char send[500] = {0};

m_editMsg.GetWindowText(send, sizeof(send) - 1);

int strlength = strlen(send);

if(strlength < 1){

MessageBox("发送内容不能为空!");

return;

}

CString msg;

m_showMsg.GetWindowText(msg);

if(::send(m_clientSocket, send, strlength, 0) != SOCKET_ERROR){ msg += "\r\n本机: \r\n";

msg += send;

}

else

msg += "\r\n本机: 消息发送失败!";

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

}

void CNetChatClientDlg::CtrlState(BOOL state){

m_portCtrl.EnableWindow(state);

m_ipAddr.EnableWindow(state);

SetDlgItemText(IDC_CONNECT, state == TRUE ? "连接" : "断开");

GetDlgItem(IDC_SEND)->EnableWindow(!state);

m_editMsg.EnableWindow(!state);

}

void CNetChatClientDlg::OnConnect() {

CString msg;

m_showMsg.GetWindowText(msg);

if(m_clientSocket != INVALID_SOCKET)//已经启动服务器，则停止服务器{ ::closesocket(m_clientSocket);

::WSACleanup();

CtrlState(TRUE);

m_clientSocket = INVALID_SOCKET;

msg += "\r\n已断开!";

}

else//启动服务器{

UpdateData(TRUE);

if(m_port > 65535){

AfxMessageBox("端口溢出!请重新设定!");

return;

}

WSADATA data;

if(::WSAStartup(MAKEWORD(2, 2), &data)){

AfxMessageBox("启动套接字失败!");

return;

}

sockaddr_in addr;

addr.sin_family = AF_INET;

addr.sin_port = htons(m_port);

m_ipAddr.GetAddress(addr.sin_addr.S_un.S_un_b.s_b1, addr.sin_addr.S_un. S_un_b.s_b2,

addr.sin_addr.S_un.S_un_b.s_b3, addr.sin_addr.S_un.S_un_b.s_b4);

m_clientSocket = ::socket(AF_INET, SOCK_STREAM, 0);

if(INVALID_SOCKET == m_clientSocket ||

::WSAAsyncSelect(m_clientSocket, this->m_hWnd, WM_SOCKET, FD_CONNEC T|FD_READ|FD_CLOSE) == SOCKET_ERROR){

AfxMessageBox("连接失败!");

::WSACleanup();

m_clientSocket = INVALID_SOCKET;

return;

}

::connect(m_clientSocket, (sockaddr*)&addr, sizeof(addr));

SetTimer(1, 4000, NULL);

msg += "\r\n正在连接...";

}

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

void CNetChatClientDlg::OnSocket(WPARAM wParam,LPARAM lParam){ switch (lParam){

case FD_CONNECT:{

KillTimer(1);

CtrlState(FALSE);

CString msg;

m_showMsg.GetWindowText(msg);

msg += "\r\n连接成功!";

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

break;

case FD_READ:{

char get[500] = {0};

::recv(m_clientSocket, get, sizeof(get) - 1, 0);

CString msg;

m_showMsg.GetWindowText(msg);

msg += "\r\n对方:";

msg += get;

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

}

break;

case FD_CLOSE:{

CtrlState(TRUE);

CString msg;

m_showMsg.GetWindowText(msg);

msg += "\r\n连接断开!";

m_showMsg.SetWindowText(msg);

m_showMsg.LineScroll(m_showMsg.GetLineCount());

m_clientSocket = INVALID_SOCKET;

}

break;

}

}

void CNetChatClientDlg::OnTimer(UINT nIDEvent){

// TODO: Add your message handler code here and/or call default if(nIDEvent == 1){

KillTimer(1);

MessageBox("连接服务器失败!");

::WSACleanup();

m_clientSocket = INVALID_SOCKET;

}

CDialog::OnTimer(nIDEvent);

}

四、程序流程图

（1）TCPClient.java TCPServer.java

(2)UDPClient.java UDPSever.java

（3）TCP多线程跟（1）相似

（4）聊天程序

A.客户端窗口

B.服务器端窗口

C.聊天程序流程图

五、实验步骤

编写程序->测试->分析结果

（1） TCP测试流程（2） UDP测试流程

（3）TCP多线程同（1）相似（4）聊天程序测试流程

六、实验结果

(1)TCP

相关文档
相关文档
最新文档

侵权投诉  © 2013-2023 www.wendangku.net  站点地图 | 手机版

闽ICP备11023808号-7  本站文档均来自互联网及网友上传分享，本站只负责收集和整理，有任何问题可通过上访投诉通道进行反馈