socket编程实验(计算机网络socket linux下用c或c++写)
大家好，今天给各位分享socket编程实验的一些知识，其中也会对计算机网络socket linux下用c或c++写进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！
socket句柄是什么意思
用过 WinSock API网友们知道：WinSock编程中有一很方便的地方便是其
息驱动机制，不管是底层 API的 WSAAsyncSelect()还是 MFC的异步Socket类：
CAsyncSocket，都提供了诸如 FD_ACCEPT、FD_READ、FD_CLOSE之类的消息
供编程人员捕捉并处理。FD_ACCEPT通知进程有客户方Socket请求连接，
FD_READ通知进程本地Socket有东东可读，FD_CLOSE通知进程对方Socket已
关闭。那么，BSD Socket是不是真的相形见拙呢？
非也！'cause cpu love unix so.
BSD UNIX中有一系统调用芳名select()完全可以提供类似的消息驱动机制。
cpu郑重宣布：WinSock的WSAAsyncSeclet()不过是此select()的fork版！
bill也是fork出来的嘛，xixi.
select()的机制中提供一fd_set的数据结构，实际上是一long类型的数组，
每一个数组元素都能与一打开的文件句柄（不管是Socket句柄,还是其他
文件或命名管道或设备句柄）建立联系，建立联系的工作由程序员完成，
当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执
行了select()的进程哪一Socket或文件可读，下面具体解释：
#include<sys/types.h>
#include<sys/times.h>
#include<sys/select.h>
int select(nfds, readfds, writefds, exceptfds, timeout)
int nfds;
fd_set*readfds,*writefds,*exceptfds;
struct timeval*timeout;
ndfs：select监视的文件句柄数，视进程中打开的文件数而定,一般设为呢要监视各文件
中的最大文件号加一。
readfds：select监视的可读文件句柄集合。
writefds: select监视的可写文件句柄集合。
exceptfds：select监视的异常文件句柄集合。
timeout：本次select()的超时结束时间。（见/usr/sys/select.h，
可精确至百万分之一秒！）
当readfds或writefds中映象的文件可读或可写或超时，本次select()
就结束返回。程序员利用一组系统提供的宏在select()结束时便可判
断哪一文件可读或可写。对Socket编程特别有用的就是readfds。
几只相关的宏解释如下：
FD_ZERO(fd_set*fdset)：清空fdset与所有文件句柄的联系。
FD_SET(int fd, fd_set*fdset)：建立文件句柄fd与fdset的联系。
FD_CLR(int fd, fd_set*fdset)：清除文件句柄fd与fdset的联系。
FD_ISSET(int fd, fdset*fdset)：检查fdset联系的文件句柄fd是否
可读写，>0表示可读写。
（关于fd_set及相关宏的定义见/usr/include/sys/types.h）
这样，你的socket只需在有东东读的时候才读入，大致如下：
...
int sockfd;
fd_set fdR;
struct timeval timeout=..;
...
for(;;){
FD_ZERO(&fdR);
FD_SET(sockfd,&fdR);
switch(select(sockfd+ 1,&fdR, NULL,&timeout)){
case-1:
error handled by u;
case 0:
timeout hanled by u;
default:
if(FD_ISSET(sockfd)){
now u read or recv something;
/* if sockfd is father and
server socket, u can now
accept()*/
}
}
}
所以一个FD_ISSET(sockfd)就相当通知了sockfd可读。
至于struct timeval在此的功能，请man select。不同的timeval设置
使使select()表现出超时结束、无超时阻塞和轮询三种特性。由于
timeval可精确至百万分之一秒，所以Windows的SetTimer()根本不算
什么。你可以用select()做一个超级时钟。
FD_ACCEPT的实现？依然如上，因为客户方socket请求连接时，会发送
连接请求报文，此时select()当然会结束，FD_ISSET(sockfd)当然大
于零，因为有报文可读嘛！至于这方面的应用，主要在于服务方的父
Socket，你若不喜欢主动accept()，可改为如上机制来accept()。
至于FD_CLOSE的实现及处理，颇费了一堆cpu处理时间，未完待续。
--
讨论关于利用select()检测对方Socket关闭的问题：
仍然是本地Socket有东东可读，因为对方Socket关闭时，会发一个关闭连接
通知报文，会马上被select()检测到的。关于TCP的连接（三次握手）和关
闭（二次握手）机制，敬请参考有关TCP/IP的书籍。
不知是什么原因，UNIX好象没有提供通知进程关于Socket或Pipe对方关闭的
信号，也可能是cpu所知有限。总之，当对方关闭，一执行recv()或read()，
马上回返回-1，此时全局变量errno的值是115，相应的sys_errlist[errno]
为"Connect refused"（请参考/usr/include/sys/errno.h）。所以，在上
篇的for(;;)...select()程序块中，当有东西可读时，一定要检查recv()或
read()的返回值，返回-1时要作出关断本地Socket的处理，否则select()会
一直认为有东西读，其结果曾几令cpu伤心欲断针脚。不信你可以试试：不检
查recv()返回结果，且将收到的东东（实际没收到）写至标准输出...
在有名管道的编程中也有类似问题出现。具体处理详见拙作：发布一个有用
的Socket客户方原码。
至于主动写Socket时对方突然关闭的处理则可以简单地捕捉信号SIGPIPE并作
出相应关断本地Socket等等的处理。SIGPIPE的解释是：写入无读者方的管道。
在此不作赘述，请详man signal。
以上是cpu在作tcp/ip数据传输实验积累的经验，若有错漏，请狂炮击之。
唉，昨天在hacker区被一帮孙子轰得差点儿没短路。ren cpu(奔腾的心) z80
补充关于select在异步(非阻塞)connect中的应用,刚开始搞socket编程的时候
我一直都用阻塞式的connect,非阻塞connect的问题是由于当时搞proxy scan
而提出的呵呵
通过在网上与网友们的交流及查找相关FAQ,总算知道了怎么解决这一问题.同样
用select可以很好地解决这一问题.大致过程是这样的:
1.将打开的socket设为非阻塞的,可以用fcntl(socket, F_SETFL, O_NDELAY)完
成(有的系统用FNEDLAY也可).
2.发connect调用,这时返回-1,但是errno被设为EINPROGRESS,意即connect仍旧
在进行还没有完成.
3.将打开的socket设进被监视的可写(注意不是可读)文件集合用select进行监视,
如果可写,用
getsockopt(socket, SOL_SOCKET, SO_ERROR,&error, sizeof(int));
来得到error的值,如果为零,则connect成功.
在许多unix版本的proxyscan程序你都可以看到类似的过程,另外在solaris精华
区->编程技巧中有一个通用的带超时参数的connect模块.
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 linux下用c或c++写
我这有一段最简单的SOCKET连接服务端的～！前阵子装Ubuntu 10后写着实验用的，这是最基本的TCP服务端框架。各种函数的条用跟 WINDOWS下的一样(我说的WINDOWS下可不是MFC喔～！)客户端自己琢磨，不懂的话再发你～！至于你要的细节，我感觉还是自己写的好
人不能太懒～！必须深入认识否则你领略不到 C程序设计的精髓～！
//////////代码如下//////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
///////////////////////// H*F*W 2010.05.21 In GuangZhou///////////////////////////
///////////////////////// LINUX SOCKET实验最简单服务端///////////////////////////
/////////////////////// linux编程 SOCKET,GTK有共同兴趣的朋友+我 Q: 176469428////////
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
int Hlisten(unsigned short hport)
{
int hsock,rhsock,cc,alen,ret;
struct sockaddr_in hlsock;
char hbuf[65535];
if((hsock=socket(AF_INET,SOCK_STREAM,0))==-1){printf("Error in socket()\n");return 0;}//建立套接字
memset(&hlsock,0,sizeof(hlsock));//初始化SOCKET空间
hlsock.sin_family=AF_INET;
hlsock.sin_port=htons(hport);///监听端口
hlsock.sin_addr.s_addr=htonl(INADDR_ANY);///地址族
ret=1;
setsockopt(hsock,SOL_SOCKET,SO_REUSEADDR,&ret,sizeof(ret));
if(bind(hsock,(struct sockaddr*)&hlsock,sizeof(hlsock))==-1){printf("Error in bind()\n");return 0;}//帮定
if(listen(hsock,0)==-1){printf("Error in listen()\n");return 0;}///进入监听状态
alen=sizeof(hlsock);
rhsock=accept(hsock,(struct sockaddr*)&hlsock,&alen);///接受客户端接入
while(1)
{
memset(hbuf,0,sizeof(hbuf));
cc=recv(rhsock,hbuf,sizeof(hbuf),0);///等待接收数据
if(cc==-1)break;
printf("%s",hbuf);///显示接收内容
}
close(hsock);//关闭连接
return 0;
}
int main(int argc,char*argv[])
{
//if(argc<=1){printf("usge: [port]");return 0;}
Hlisten(330);//调用监听过程传入监听端口
return 0;
}
///////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
//////////////////使用gcc编译直接就可以看到效果////////////////
/////////////////////////////////////////////////////////////////
感谢您的阅读！希望本文对解决您关于socket编程实验的问题有所帮助。如果您还有其他疑问，欢迎随时向我们提问。