socket编程实验

Ⅰ 怎样用C语言做socket网络编程

mfc只是对socket进行了一些封装，大部分人做网络编程都是用的原始的socket，比如如下接口都可以在c下进行调用
1.socket()
2.bind()
3.connect()
4.listen()
5.accept()
6.send() 和recv()
7.sendto() 和recvfrom()
8.close() 和shutdown()
9.getpeername()
10.gethostname()
这些接口是在Winsock2.h中定义的不是在mfc中定义的，你只需要包含Winsock2.h头文件和Ws2_32.lib库就可以了。

Ⅱ Java的Socket编程

要通信首先要建立socket链接。
1 ab客户端与服务端建立socket链接
2 a客户端发送消息到服务端
3 服务端收到消息后，发送到指定的b客户端
4 b客户端处理来自服务端的消息

Ⅲ Socket编程

假设你和我称作A和B，当A向服务器请求的时候会得到ss.accept()方法返回的socket，该段代码执行完以后，因为是放在while(true)的范围里面的，所以服务器会立马再执行ss.accept()等待下一个请求，这时B去连的时候就是和A连的逻辑一样。就好比你去饭店，饭店的服务生看到你进门了肯定先服务你，把你安顿下来后服务生不可能就下班了，服务生还要到门口迎接下一位顾客

Ⅳ socket实现过程，具体用的方法;怎么实现异步socket

基于C#的socket编程的TCP异步实现
一、摘要
本篇博文阐述基于TCP通信协议的异步实现。

二、实验平台
Visual Studio 2010

三、异步通信实现原理及常用方法
3.1 建立连接
在同步模式中，在服务器上使用Accept方法接入连接请求，而在客户端则使用Connect方法来连接服务器。相对地，在异步模式下，服务器可以使用BeginAccept方法和EndAccept方法来完成连接到客户端的任务，在客户端则通过BeginConnect方法和EndConnect方法来实现与服务器的连接。

BeginAccept在异步方式下传入的连接尝试，它允许其他动作而不必等待连接建立才继续执行后面程序。在调用BeginAccept之前，必须使用Listen方法来侦听是否有连接请求，BeginAccept的函数原型为：

BeginAccept(AsyncCallback AsyncCallback, Ojbect state)
参数：

AsyncCallBack：代表回调函数

state：表示状态信息，必须保证state中包含socket的句柄

使用BeginAccept的基本流程是：
(1)创建本地终节点，并新建套接字与本地终节点进行绑定；
(2)在端口上侦听是否有新的连接请求；
(3)请求开始接入新的连接，传入Socket的实例或者StateOjbect的实例。

参考代码：

复制代码
//定义IP地址
IPAddress local = IPAddress.Parse("127.0,0,1");
IPEndPoint iep = new IPEndPoint(local,13000);
//创建服务器的socket对象
Socket server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
server.Bind(iep);
server.Listen(20);
server.BeginAccecpt(new AsyncCallback(Accept),server);
复制代码
当BeginAccept()方法调用结束后，一旦新的连接发生，将调用回调函数，而该回调函数必须包括用来结束接入连接操作的EndAccept()方法。

该方法参数列表为 Socket EndAccept(IAsyncResult iar)

下面为回调函数的实例：

复制代码
void Accept(IAsyncResult iar)
{
//还原传入的原始套接字
Socket MyServer = (Socket)iar.AsyncState;
//在原始套接字上调用EndAccept方法，返回新的套接字
Socket service = MyServer.EndAccept(iar);
}
复制代码
至此，服务器端已经准备好了。客户端应通过BeginConnect方法和EndConnect来远程连接主机。在调用BeginConnect方法时必须注册相应的回调函数并且至少传递一个Socket的实例给state参数，以保证EndConnect方法中能使用原始的套接字。下面是一段是BeginConnect的调用：

Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp)
IPAddress ip=IPAddress.Parse("127.0.0.1");
IPEndPoint iep=new IPEndPoint(ip,13000);
socket.BeginConnect(iep, new AsyncCallback(Connect),socket);
EndConnect是一种阻塞方法，用于完成BeginConnect方法的异步连接诶远程主机的请求。在注册了回调函数后必须接收BeginConnect方法返回的IASynccReuslt作为参数。下面为代码演示：

复制代码
void Connect(IAsyncResult iar)
{
Socket client=(Socket)iar.AsyncState;
try
{
client.EndConnect(iar);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{

}
}
复制代码

除了采用上述方法建立连接之后，也可以采用TcpListener类里面的方法进行连接建立。下面是服务器端对关于TcpListener类使用BeginAccetpTcpClient方法处理一个传入的连接尝试。以下是使用BeginAccetpTcpClient方法和EndAccetpTcpClient方法的代码：

复制代码
public static void DoBeginAccept(TcpListener listner)
{
//开始从客户端监听连接
Console.WriteLine("Waitting for a connection");
//接收连接
//开始准备接入新的连接，一旦有新连接尝试则调用回调函数DoAcceptTcpCliet
listner.BeginAcceptTcpClient(new AsyncCallback(DoAcceptTcpCliet), listner);
}

//处理客户端的连接
public static void DoAcceptTcpCliet(IAsyncResult iar)
{
//还原原始的TcpListner对象
TcpListener listener = (TcpListener)iar.AsyncState;

//完成连接的动作，并返回新的TcpClient
TcpClient client = listener.EndAcceptTcpClient(iar);
Console.WriteLine("连接成功");
}
复制代码
代码的处理逻辑为：
(1)调用BeginAccetpTcpClient方法开开始连接新的连接，当连接视图发生时，回调函数被调用以完成连接操作；
(2)上面DoAcceptTcpCliet方法通过AsyncState属性获得由BeginAcceptTcpClient传入的listner实例；
(3)在得到listener对象后，用它调用EndAcceptTcpClient方法，该方法返回新的包含客户端信息的TcpClient。

BeginConnect方法和EndConnect方法可用于客户端尝试建立与服务端的连接，这里和第一种方法并无区别。下面看实例：

复制代码
public void doBeginConnect(IAsyncResult iar)
{
Socket client=(Socket)iar.AsyncState;
//开始与远程主机进行连接
client.BeginConnect(serverIP[0],13000,requestCallBack,client);
Console.WriteLine("开始与服务器进行连接");
}
private void requestCallBack(IAsyncResult iar)
{
try
{
//还原原始的TcpClient对象
TcpClient client=(TcpClient)iar.AsyncState;
//
client.EndConnect(iar);
Console.WriteLine("与服务器{0}连接成功",client.Client.RemoteEndPoint);
}
catch(Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{

}
}
复制代码
以上是建立连接的两种方法。可根据需要选择使用。

3.2 发送与接受数据
在建立了套接字的连接后，就可以服务器端和客户端之间进行数据通信了。异步套接字用BeginSend和EndSend方法来负责数据的发送。注意在调用BeginSend方法前要确保双方都已经建立连接，否则会出异常。下面演示代码：

复制代码
private static void Send(Socket handler, String data)
{
// Convert the string data to byte data using ASCII encoding.
byte[] byteData = Encoding.ASCII.GetBytes(data);
// Begin sending the data to the remote device.
handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
Socket handler = (Socket)ar.AsyncState;
// Complete sending the data to the remote device.
int bytesSent = handler.EndSend(ar);
Console.WriteLine("Sent {0} bytes to client.", bytesSent);
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
复制代码
接收数据是通过BeginReceive和EndReceive方法：

复制代码
private static void Receive(Socket client)
{
try
{
// Create the state object.
StateObject state = new StateObject();
state.workSocket = client;
// Begin receiving the data from the remote device.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
// Retrieve the state object and the client socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.workSocket;
// Read data from the remote device.
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.

state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// Get the rest of the data.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
}
else
{
// All the data has arrived; put it in response.
if (state.sb.Length > 1)
{
response = state.sb.ToString();
}
// Signal that all bytes have been received.
receiveDone.Set();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
复制代码
上述代码的处理逻辑为：

(1)首先处理连接的回调函数里得到的通讯套接字client，接着开始接收数据；
(2)当数据发送到缓冲区中，BeginReceive方法试图从buffer数组中读取长度为buffer.length的数据块，并返回接收到的数据量bytesRead。最后接收并打印数据。除了上述方法外，还可以使用基于NetworkStream相关的异步发送和接收方法，下面是基于NetworkStream相关的异步发送和接收方法的使用介绍。
NetworkStream使用BeginRead和EndRead方法进行读操作，使用BeginWreite和EndWrete方法进行写操作，下面看实例：

复制代码
static void DataHandle(TcpClient client)
{
TcpClient tcpClient = client;
//使用TcpClient的GetStream方法获取网络流
NetworkStream ns = tcpClient.GetStream();
//检查网络流是否可读
if(ns.CanRead)
{
//定义缓冲区
byte[] read = new byte[1024];
ns.BeginRead(read,0,read.Length,new AsyncCallback(myReadCallBack),ns);
}
else
{
Console.WriteLine("无法从网络中读取流数据");
}
}

public static void myReadCallBack(IAsyncResult iar)
{
NetworkStream ns = (NetworkStream)iar.AsyncState;
byte[] read = new byte[1024];
String data = "";
int recv;

recv = ns.EndRead(iar);
data = String.Concat(data, Encoding.ASCII.GetString(read, 0, recv));

//接收到的消息长度可能大于缓冲区总大小，反复循环直到读完为止
while (ns.DataAvailable)
{
ns.BeginRead(read, 0, read.Length, new AsyncCallback(myReadCallBack), ns);
}
//打印
Console.WriteLine("您收到的信息是" + data);
}
复制代码
3.3 程序阻塞与异步中的同步问题
.Net里提供了EventWaitHandle类来表示一个线程的同步事件。EventWaitHandle即事件等待句柄，他允许线程通过操作系统互发信号和等待彼此的信号来达到线程同步的目的。这个类有2个子类，分别为AutoRestEevnt(自动重置)和ManualRestEvent(手动重置)。下面是线程同步的几个方法：
(1)Rset方法：将事件状态设为非终止状态，导致线程阻塞。这里的线程阻塞是指允许其他需要等待的线程进行阻塞即让含WaitOne()方法的线程阻塞；
(2)Set方法：将事件状态设为终止状态，允许一个或多个等待线程继续。该方法发送一个信号给操作系统，让处于等待的某个线程从阻塞状态转换为继续运行，即WaitOne方法的线程不在阻塞；
(3)WaitOne方法：阻塞当前线程，直到当前的等待句柄收到信号。此方法将一直使本线程处于阻塞状态直到收到信号为止，即当其他非阻塞进程调用set方法时可以继续执行。

复制代码
public static void StartListening()
{
// Data buffer for incoming data.
byte[] bytes = new Byte[1024];
// Establish the local endpoint for the socket.
// The DNS name of the computer
// running the listener is "host.contoso.com".
//IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
//IPAddress ipAddress = ipHostInfo.AddressList[0];
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local
//endpoint and listen for incoming connections.
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
while (true)
{
// Set the event to nonsignaled state.
allDone.Reset();
// Start an asynchronous socket to listen for connections.
Console.WriteLine("Waiting for a connection...");
listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
// Wait until a connection is made before continuing.
allDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.WriteLine("\nPress ENTER to continue...");
Console.Read();
}
复制代码

上述代码的逻辑为：

(1)试用了ManualRestEvent对象创建一个等待句柄，在调用BeginAccept方法前使用Rest方法允许其他线程阻塞；
(2)为了防止在连接完成之前对套接字进行读写操作，务必要在BeginAccept方法后调用WaitOne来让线程进入阻塞状态。

当有连接接入后系统会自动调用会调用回调函数，所以当代码执行到回调函数时说明连接已经成功，并在函数的第一句就调用Set方法让处于等待的线程可以继续执行

Ⅳ 计算机网络课设 socket 编程

目的及要求：熟悉ICMP协议的作用，利用ICMP的回送请求和回送应答来进行检测出到达网络上任何一台目的主机途中所经过的路由器，并将结果显示在标准输出上。通过本实验，使学生更加熟悉ICMP报文的结构，对ICMP协议有更好的理解和认识。l 具体内容（1）定义好IP分组、ICMP报文相关的数据结构；（2）在WINDOWS环境下实现程序；（3）在命令提示符下输入：“mytrace IP地址 或 主机名 或 域名”；数）持续发送ICMP回送请求数据包，其中的IP首部TTL字段依次增加，如果是中途路由器收到TTL为0的IP分组后，将会发回超时的错误报告ICMP响应报文，如果到达最后的主机，将会发回ICMP回送应答

Ⅵ 怎样进行SOCKET编程

#include <winsock2.h>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")

void main(){
WSADATA wsaData;
int iResult=WSAStartup(MAKEWORD(2,2),&wsaData);
SOCKET server;
server=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
sockaddr_in service;
service.sin_family=AF_INET;
service.sin_addr.s_addr=inet_addr("127.0.0.1");
service.sin_port=htons(27015);
bind(server,(SOCKADDR*)&service,sizeof(service));
listen(server,1);

SOCKET AcceptSocket;
while(1){
AcceptSocket=SOCKET_ERROR;
while(AcceptSocket==SOCKET_ERROR){
AcceptSocket=accept(server,NULL,NULL);
}
server=AcceptSocket;
break;
}
int bytesSent;
int bytesRecv=SOCKET_ERROR;
char sendbuf[32]="Server:Dending Data.";
char recvbuf[32]="";
bytesRecv=recv(server,recvbuf,32,0);
printf("%ld\n",bytesRecv);

bytesSent=send(server,sendbuf,strlen(sendbuf),0);
printf("%ld\n",bytesSent);

return;

}

Ⅶ SOCKET编程

#include <string.h>
#include <winsock.h>
#include <windows.h>
#include <iostream.h>
#pragma comment (lib,"ws2_32.lib")
int main (int argc, char *argv[])
{
int iportFrom,iportTo;
int testsocket;
int iopenedport = 0;
struct sockaddr_in target_addr;
WSADATA wsaData;
WORD wVersionRequested=MAKEWORD(1,1);
if (argc <= 3)
{
cout << "使用格式 : " << argv[0] << " 主机IP地址 开始端口号 结束端口号\n" << endl;
exit(1);
}
if (atoi (argv[2]) > atoi (argv[3]))
{
cout << "错误！开始端口号必须小于结束端口号" << endl;
exit(1);
}
else
{
if (WSAStartup (wVersionRequested , &wsaData) )
{
cout << "连接socket库失败，请检查版本号是否为1.1\n" << endl;
exit(1);
}
iportFrom=atoi (argv[2]);
iportTo=atoi (argv[3]);
for (int i=iportFrom; i <= iportTo; i++)
{
cout << "正在建立socket................................" << endl;
if ((testsocket=socket (AF_INET,SOCK_STREAM,0) ) == INVALID_SOCKET)
{
cout << "Socket建立失败！" << endl;
exit(0);
}
target_addr.sin_family = AF_INET;
target_addr.sin_port = htons(i);
target_addr.sin_addr.s_addr = inet_addr (argv[1]);
cout << "正在扫描端口：" << i << endl;
if (connect (testsocket, (struct sockaddr *) &target_addr, sizeof(struct sockaddr)) == SOCKET_ERROR)
cout << "端口" << i << "关闭！" << endl;
else
{
iopenedport++;
cout << "端口" << i << "开放\n" << endl;
}
}
cout << "目标主机" << argv[1] << "从" << iportFrom << "--" << iportTo << "共有" << iopenedport << "个端口开放" << endl;
closesocket (testsocket);
WSACleanup();
}
return 0;
}

vc6.0 下 编译

Ⅷ 实验 面向TCP Socket编程 2 ．实验任务 使用Java编写网络选课模拟程序，它由 client 和 server 两部分组成

这位兄台，你还真是抠门，这么复杂的东西才给5分啊，汗