windows socket编程

转载 2012年03月31日 16:14:48

一、TCP/IP 体系结构与特点

  1、TCP/IP体系结构

  TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务,而IP则是提供网络层服务。TCP/IP包括以下协议:(结构如图1.1)


(图1.1)

  IP: 网间协议(Internet Protocol) 负责主机间数据的路由和网络上数据的存储。同时为ICMP,TCP,   UDP提供分组发送服务。用户进程通常不需要涉及这一层。

  ARP: 地址解析协议(Address Resolution Protocol)
   此协议将网络地址映射到硬件地址。

  RARP: 反向地址解析协议(Reverse Address Resolution Protocol)
   此协议将硬件地址映射到网络地址

  ICMP: 网间报文控制协议(Internet Control Message Protocol)
   此协议处理信关和主机的差错和传送控制。

  TCP: 传送控制协议(Transmission Control Protocol)
   这是一种提供给用户进程的可靠的全双工字节流面向连接的协议。它要为用户进程提供虚电路服务,并为数据可靠传输建立检查。(注:大多数网络用户程序使用TCP)

  UDP: 用户数据报协议(User Datagram Protocol)
   这是提供给用户进程的无连接协议,用于传送数据而不执行正确性检查。

  FTP: 文件传输协议(File Transfer Protocol)
   允许用户以文件操作的方式(文件的增、删、改、查、传送等)与另一主机相互通信。

  SMTP: 简单邮件传送协议(Simple Mail Transfer Protocol)
   SMTP协议为系统之间传送电子邮件。

  TELNET:终端协议(Telnet Terminal Procotol)
   允许用户以虚终端方式访问远程主机

  HTTP: 超文本传输协议(Hypertext Transfer Procotol)
  
  TFTP: 简单文件传输协议(Trivial File Transfer Protocol)

  2、TCP/IP特点

  TCP/IP协议的核心部分是传输层协议(TCP、UDP),网络层协议(IP)和物理接口层,这三层通常是在操作系统内核中实现。因此用户一般不涉及。编程时,编程界面有两种形式:一、是由内核心直接提供的系统调用;二、使用以库函数方式提供的各种函数。前者为核内实现,后者为核外实现。用户服务要通过核外的应用程序才能实现,所以要使用套接字(socket)来实现。

  图1.2是TCP/IP协议核心与应用程序关系图。


(图1.2)

  二、专用术语

  1、套接字

  套接字是网络的基本构件。它是可以被命名和寻址的通信端点,使用中的每一个套接字都有其类型和一个与之相连听进程。套接字存在通信区域(通信区域又称地址簇)中。套接字只与同一区域中的套接字交换数据(跨区域时,需要执行某和转换进程才能实现)。WINDOWS 中的套接字只支持一个域——网际域。套接字具有类型。

  WINDOWS SOCKET 1.1 版本支持两种套接字:流套接字(SOCK_STREAM)和数据报套接字(SOCK_DGRAM)

  2、WINDOWS SOCKETS 实现

  一个WINDOWS SOCKETS 实现是指实现了WINDOWS SOCKETS规范所描述的全部功能的一套软件。一般通过DLL文件来实现

  3、阻塞处理例程

  阻塞处理例程(blocking hook,阻塞钩子)是WINDOWS SOCKETS实现为了支持阻塞套接字函数调用而提供的一种机制。

  4、多址广播(multicast,多点传送或组播)

  是一种一对多的传输方式,传输发起者通过一次传输就将信息传送到一组接收者,与单点传送
(unicast)和广播(Broadcast)相对应。

一、客户机/服务器模式

  在TCP/IP网络中两个进程间的相互作用的主机模式是客户机/服务器模式(Client/Server model)。该模式的建立基于以下两点:1、非对等作用;2、通信完全是异步的。客户机/服务器模式在操作过程中采取的是主动请示方式:

  首先服务器方要先启动,并根据请示提供相应服务:(过程如下)

  1、打开一通信通道并告知本地主机,它愿意在某一个公认地址上接收客户请求。

  2、等待客户请求到达该端口。

  3、接收到重复服务请求,处理该请求并发送应答信号。

  4、返回第二步,等待另一客户请求

  5、关闭服务器。

  客户方:

  1、打开一通信通道,并连接到服务器所在主机的特定端口。

  2、向服务器发送服务请求报文,等待并接收应答;继续提出请求……

  3、请求结束后关闭通信通道并终止。

  二、基本套接字

  为了更好说明套接字编程原理,给出几个基本的套接字,在以后的篇幅中会给出更详细的使用说明。

  1、创建套接字——socket()

  功能:使用前创建一个新的套接字

  格式:SOCKET PASCAL FAR socket(int af,int type,int procotol);

  参数:af: 通信发生的区域

  type: 要建立的套接字类型

  procotol: 使用的特定协议

  2、指定本地地址——bind()

  功能:将套接字地址与所创建的套接字号联系起来。

  格式:int PASCAL FAR bind(SOCKET s,const struct sockaddr FAR * name,int namelen);

  参数:s: 是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。

  其它:没有错误,bind()返回0,否则SOCKET_ERROR

  地址结构说明:

struct sockaddr_in
{
short sin_family;//AF_INET
u_short sin_port;//16位端口号,网络字节顺序
struct in_addr sin_addr;//32位IP地址,网络字节顺序
char sin_zero[8];//保留
}

  3、建立套接字连接——connect()和accept()

  功能:共同完成连接工作

  格式:int PASCAL FAR connect(SOCKET s,const struct sockaddr FAR * name,int namelen);

  SOCKET PASCAL FAR accept(SOCKET s,struct sockaddr FAR * name,int FAR * addrlen);

  参数:同上

  4、监听连接——listen()

  功能:用于面向连接服务器,表明它愿意接收连接。

  格式:int PASCAL FAR listen(SOCKET s, int backlog);

  5、数据传输——send()与recv()

  功能:数据的发送与接收

  格式:int PASCAL FAR send(SOCKET s,const char FAR * buf,int len,int flags);

  int PASCAL FAR recv(SOCKET s,const char FAR * buf,int len,int flags);

  参数:buf:指向存有传输数据的缓冲区的指针。

  6、多路复用——select()

  功能:用来检测一个或多个套接字状态。

  格式:int PASCAL FAR select(int nfds,fd_set FAR * readfds,fd_set FAR * writefds,
fd_set FAR * exceptfds,const struct timeval FAR * timeout);

  参数:readfds:指向要做读检测的指针

     writefds:指向要做写检测的指针

     exceptfds:指向要检测是否出错的指针

     timeout:最大等待时间

  7、关闭套接字——closesocket()

  功能:关闭套接字s

  格式:BOOL PASCAL FAR closesocket(SOCKET s);

三、典型过程图

  2.1 面向连接的套接字的系统调用时序图

 



  2.2 无连接协议的套接字调用时序图



     2.3 面向连接的应用程序流程图


Windows Socket 程序设计

一、简介

  Windows Sockets 是从 Berkeley Sockets 扩展而来的,其在继承 Berkeley Sockets 的基础上,又进行了新的扩充。这些扩充主要是提供了一些异步函数,并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。

  Windows Sockets由两部分组成:开发组件和运行组件。

  开发组件:Windows Sockets 实现文档、应用程序接口(API)引入库和一些头文件。

  运行组件:Windows Sockets 应用程序接口的动态链接库(WINSOCK.DLL)。

  二、主要扩充说明

  1、异步选择机制:

  Windows Sockets 的异步选择函数提供了消息机制的网络事件选择,当使用它登记网络事件发生时,应用程序相应窗口函数将收到一个消息,消息中指示了发生的网络事件,以及与事件相关的一些信息。

  Windows Sockets 提供了一个异步选择函数 WSAAsyncSelect(),用它来注册应用程序感兴趣的网络事件,当这些事件发生时,应用程序相应的窗口函数将收到一个消息。

  函数结构如下:

int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);

  参数说明:

   hWnd:窗口句柄

   wMsg:需要发送的消息

   lEvent:事件(以下为事件的内容)

值: 含义:
FD_READ 期望在套接字上收到数据(即读准备好)时接到通知
FD_WRITE 期望在套接字上可发送数据(即写准备好)时接到通知
FD_OOB 期望在套接字上有带外数据到达时接到通知
FD_ACCEPT 期望在套接字上有外来连接时接到通知
FD_CONNECT 期望在套接字连接建立完成时接到通知
FD_CLOSE 期望在套接字关闭时接到通知

  例如:我们要在套接字读准备好或写准备好时接到通知,语句如下:

rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE);

  如果我们需要注销对套接字网络事件的消息发送,只要将 lEvent 设置为0

  2、异步请求函数

  在 Berkeley Sockets 中请求服务是阻塞的,WINDOWS SICKETS 除了支持这一类函数外,还增加了相应的异步请求函数(WSAAsyncGetXByY();)。

  3、阻塞处理方法

  Windows Sockets 为了实现当一个应用程序的套接字调用处于阻塞时,能够放弃CPU让其它应用程序运行,它在调用处于阻塞时便进入一个叫“HOOK”的例程,此例程负责接收和分配WINDOWS消息,使得其它应用程序仍然能够接收到自己的消息并取得控制权。

  WINDOWS 是非抢先的多任务环境,即若一个程序不主动放弃其控制权,别的程序就不能执行。因此在设计Windows Sockets 程序时,尽管系统支持阻塞操作,但还是反对程序员使用该操作。但由于 SUN 公司下的 Berkeley Sockets 的套接字默认操作是阻塞的,WINDOWS 作为移植的 SOCKETS 也不可避免对这个操作支持。

  在Windows Sockets 实现中,对于不能立即完成的阻塞操作做如下处理:DLL初始化→循环操作。在循环中,它发送任何 WINDOWS 消息,并检查这个 Windows Sockets 调用是否完成,在必要时,它可以放弃CPU让其它应用程序执行(当然使用超线程的CPU就不会有这个麻烦了^_^)。我们可以调用 WSACancelBlockingCall() 函数取消此阻塞操作。

  在 Windows Sockets 中,有一个默认的阻塞处理例程 BlockingHook() 简单地获取并发送 WINDOWS 消息。如果要对复杂程序进行处理,Windows Sockets 中还有 WSASetBlockingHook() 提供用户安装自己的阻塞处理例程能力;与该函数相对应的则是 SWAUnhookBlockingHook(),它用于删除先前安装的任何阻塞处理例程,并重新安装默认的处理例程。请注意,设计自己的阻塞处理例程时,除了函数 WSACancelBlockingHook() 之外,它不能使用其它的 Windows Sockets API 函数。在处理例程中调用 WSACancelBlockingHook()函数将取消处于阻塞的操作,它将结束阻塞循环。

  4、出错处理

  Windows Sockets 为了和以后多线程环境(WINDOWS/UNIX)兼容,它提供了两个出错处理函数来获取和设置当前线程的最近错误号。(WSAGetLastEror()和WSASetLastError())

  5、启动与终止

  使用函数 WSAStartup() 和 WSACleanup() 启动和终止套接字。

 

来自网络

实例

static void* listenconnect(void* param)
{
int sockfd = socket (PF_UNIX, SOCK_SEQPACKET, 0); //创建本地套接字
fcntl(sockfd, F_SETFL, O_NONBLOCK);
sockaddr_un myaddr;
memset (&myaddr, 0, sizeof(myaddr));
myaddr.sun_family = PF_UNIX;
strcpy (myaddr.sun_path, "@/brainaire_nvr/trans_serv/socket"); //套接字的名字,任意取
myaddr.sun_path[0] = 0;
bind (sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)); //将套接字与它的名字绑定
listen(sockfd, 50);

fd_set watchset, listenset, clientset;
FD_ZERO(&clientset);
FD_ZERO(&watchset);
FD_ZERO(&listenset);
FD_SET(sockfd, &listenset);
int max_listen = sockfd + 1;
int max_client = 0;
    while (!process_exit)
    {
   watchset = listenset;
   struct timeval tv;
   tv.tv_sec = 0;
   tv.tv_usec = 1000;
   if (select(max_listen, &watchset, NULL, NULL, &tv) > 0 && FD_ISSET(sockfd, &watchset))
   {
    struct sockaddr addr;
    socklen_t len;
    int clientfd = accept(sockfd, &addr, &len);
    if (clientfd < 0)
     perror("accept");
    else
    {
     if (clientfd >= max_client)
      max_client = clientfd + 1;
     FD_SET(clientfd, &clientset);
    }
   }
   watchset = clientset;
   tv.tv_sec = 0;
   tv.tv_usec = 1000;
   int ret = select(max_client, &watchset, NULL, NULL, &tv);
   if (ret > 0)
   {
    for (int clientfd = max_client - 1; clientfd > 0; clientfd--)
    {
     int flags = 0;
     char buff[BUFSIZ];
     int len;
     if (FD_ISSET(clientfd, &watchset))
     {
      len = recv(clientfd, buff, sizeof(buff), flags);
      if (len <= 0)
      {
       FD_CLR(clientfd, &clientset);
       fprintf(stderr, "[nvradmin] client socket %d closed.\n", clientfd);
       close(clientfd);
       if (clientfd == max_client - 1)
        max_client --;
      }
      else
      {
       bool monitorworking = false;
       buff[len] = 0;
       int monitorID = atoi(buff);
       if (monitorID != 0)
       {
        MyRW_Lock mylock(&monitorlock);
#if THREAD_NUM
        list<MonitorDaemon>& monitors = monitorslists[monitorID%THREAD_NUM];
#endif
        for (list<MonitorDaemon>::iterator intr = monitors.begin(); intr
          != monitors.end(); intr ++)
        {
         MonitorDaemon m_daemon = *intr;
         if (m_daemon.monitor == NULL)
          break;
         if (m_daemon.monitor->Id() == monitorID)
         {
          fprintf(stderr, "[nvradmin] Start Transmitting RealPlay Data to client socket %d\n", clientfd);
          monitorworking = (0 == m_daemon.monitor->StartTransData(clientfd));
         }
        }
       }
       else
        fprintf(stderr, "[nvradmin] Received Msgs: len %d, content: %s\n", len, buff);

       if(!monitorworking)
       {
        FD_CLR(clientfd, &clientset);
        fprintf(stderr, "[nvradmin] Cannot Start Tranmitting, client Socket %d Closed.\n", clientfd);
        close(clientfd);
        if (clientfd == max_client - 1)
         max_client --;
       }
      }
     }
    }
   }
   if(ret < 0)
    perror("Select Connected Sockets");
   usleep(0);
    }
    close(sockfd);
    return 0;
}

三、MFC CAsyncSocket

    但由于都是直接利用动态连接库wsock32.dll进行操作,实现比较繁琐。其实,为简化套接字编程,MFC 定义了两个套接字类:CAsyncSocket、CSocket。CAsyncSocket类在低层次上对 Windows Sockets API 进行了封装,其成员函数和 Windows Sockets API 函数直接相对应 。一个CAsyncSocket对 象 就 代 表 了一 个 套 接 字。而CSocket继承于CAsyncSocket 类,是对 Windows Sockets API 的高级封装。
    建立Socket的WSAStartup过程和bind过程被简化成为Create过程,IP地址类型转换、主机名和IP地址转换的过程中许多复杂的变量类型都被简化成字符串和整数操作,特别是CAsyncSocket类的异步特点,完全可以替代繁琐的线程操作。
一、1.CAsyncSocket 类直接派生于CObject类,称为异步套接字对象。由于 CAsyncSocket类的构造函数不带参数
,需要调用起成员函数 Create 来创建底层的套接字句柄,决定套接字对象的具体特性,并绑定它的地址。
BOOL Create( UINT nSocketPort=0,
    Int nSocketType = SOCK_STREAM,
    Long Ievent=FD_READ|FD_WRITE|FD_OOB|FD_ACCEPT|FD_CONNECT|FD_CLOSE,
    LPCTSTR lpszSocketAddress = NULL );

CAsyncSocket 类的 6 种网络事件
事 件     涵    义                           对应处理函数
FD_ACCEPT 通知侦听套接字当前有连接请求可以接受    OnAccept(int nErrorCode);
FD_CONNECT 通知请求连接的套接字,连接要求已被处理 OnConnect(int nErrorCode);
FD_CLOSE   通知套接字与其连接的套接字已关闭        OnClose(int nErrorCode);
FD_READ    通知有数据到达                          OnReceive(int nErrorCode);
FD_WRITE   通知可以发送数据                        OnSend(int nErrorCode);
FD_OOB     通知将有外带数据到达                    OnOutOfBandData(int ErrorCode);

      当某个网络事件发生时,MFC 框架把消息发送给相应的套接字对象,相当于给了该对象一个通知,告诉它某个重要的事件已经发生,接着自动调用该对象的事件处理函数。

2.如果从 CAsyncSocket 类派生了自己的套接字类,则必须重载某些网络事件所对应的通知函数。
3.服务器端
   与Winsock不同,CAsyncSocket服务端不用绑定(Bind),不用连接(Connect)。

   正常情况下,服务器端必须首先创建一个 CAsyncSocket 套接字对象,并调用它的 Create成员函数创建底层套接字
句柄。这个套接字对象专门用来侦听来自客户机的连接请求,所以称它为侦听套接字对象。再调用侦听套接字对象的

Listen 函数,使侦听套接字对象开始侦听来自客户端的连接请求。
(1) 当 Listen 函数确认并接纳了一个客户端连接请求后,触发 FD_ACCEPT 事件,侦听套接字收到通知,MFC 框
自动调用侦听套接字的 OnAccept 事件处理函数。一般需要重载 OnAccept 函数,再在其中调用侦听套接字对象的

Accept 函数。
(2) 创建一个新的空套接字对象,专门用来与客户端连接并进行数据的传输,一般称为连接套接字,并作为参数传
递给下一步的 Accept 成员函数。m_sListenSocket.Accept(m_sConnectSocket);
4.客户端
   客户端请求连接到服务器端,在服务器端套接字对象已经进入侦听状态之后,客户应用程序可以调用CAsyncSocket类的 Connect 成员函数,向服务器发出一个连接请求。调用结束返回时发生FD_CONNECT事件,MFC 框架会自动调用
户端套接字的 OnConnect 事件处理函数。
CSocket 类是 CAsyncSocket 的派生类。创建 CSocket 对象时,首先要调用 CSocket 类
的构造函数创建一个空的 CSocket 对象,再调用其 Create 成员函数,创建对象的底层套
接字。

BOOL Create(
      UINT nSocketPort = 端口号,
      Int nSocketPort = SOCK_STREAM | SOCK_DGRAM,
      LPCTSTR lpszSocketAddress = 套接字所用的网络地址 );
二、CSocket 类使用基类 CAsyncSocket 的同名成员函数 Connect、Listen、Accept 来建立服务器和客户机套接字之
间的连接,使用方法基本相同。在创建 CSocket 类对象后,对于流式套接字,首先在服务器和客户机之间建立连接,然后使用 Send 函数、Receive 函数来发送和接收数据。
    需要注意的是,CSocket对象从不调用OnConnect和OnSend事件处理函数。CSocket类继承了 CAsyncSocket 类的许
多成员函数,用法基本一致。CSocket类的高级性主要表现在3个方面。
(1) CSocket 结合 CArchive 类来使用套接字。
(2) CSocket 管理了通信的许多方面,比如字节顺序问题和字符串转换问题。
(3) CSocket 类为 Windows 消息的后台处理提供了阻塞的工作模式。有关阻塞的概念读者可参阅相关文献资料,此处
不再赘述。
因此,一般将 CSocket 与 CArchive、CSocketFile 类相结合,来发送和接收数据,这将使编程更为简单。

===============================================================================
---- 一个Echo例程来介绍CAsyncSocket类的用法。

---- 一. 客户端

---- 1. 创建一个Dialog Based项目:CSockClient。

---- 2. 设计对话框

---- 去掉Ok和Cancle两个按钮,增加ID_Connect(连接)、ID_Send(发送)、ID_Exit(关闭)按钮,增加ListBox控件IDC_LISTMSG和Edit控件IDC_EDITMSG,并按下表在ClassWizard中为CCSockClientDlg类添加变量。

Control ID Type Member
   
IDC_EDITMSG CEdit m_MSG
IDC_LISTMSG ClistBox m_MSGS

---- 3. CAsyncSocket类用DoCallBack函数处理MFC消息,当一个网络事件发生时,DoCallBack函数按网络事件类型:FD_READ、FD_WRITE、FD_ACCEPT、FD_CONNECT分别调用OnReceive、OnSend、OnAccept、OnConnect函数。由于MFC把这些事件处理函数定义为虚函数,所以要生成一个新的C++类,以重载这些函数,做法如下:

---- 以Public方式继承CAsyncSocket类,生成新类MySock;

---- 为MySock类添加虚函数OnReceive、OnConnect、OnSend

---- 4. 在MySock.**中添加以下代码

#include "CSockClient.h"
#include "CSockClientDlg.h"

---- 5. 在MySock.h中添加以下代码

public:
      BOOL m_bConnected;    //是否连接
      UINT m_nLength;        //消息长度
      char m_szBuffer[4096];    //消息缓冲区

---- 6. 在MySock.**中重载各函数

MySock::MySock()
{
m_nLength=0;
memset(m_szBuffer,0,sizeof(m_szBuffer));
m_bConnected=FALSE;
}

MySock::~MySock()
{
//关闭套接字
if(m_hSocket!=INVALID_SOCKET)
      Close();
}

void MySock::OnReceive(int nErrorCode)
{
m_nLength=Receive(m_szBuffer,sizeof(m_szBuffer),0);
//下面两行代码用来获取对话框指针
CCSockClientApp* pApp=(CCSockClientApp*)AfxGetApp();
CCSockClientDlg* pDlg=(CCSockClientDlg*)pApp- >m_pMainWnd;
pDlg- >m_MSGS.InsertString(0,m_szBuffer);
memset(m_szBuffer,0,sizeof(m_szBuffer));
CAsyncSocket::OnReceive(nErrorCode);
}

void MySock::OnSend(int nErrorCode)
{
Send(m_szBuffer,m_nLength,0);
m_nLength=0;
memset(m_szBuffer,0,sizeof(m_szBuffer));
//继续提请一个“读”的网络事件,接收Server消息
AsyncSelect(FD_READ);
CAsyncSocket::OnSend(nErrorCode);
}

void MySock::OnConnect(int nErrorCode)
{
if (nErrorCode==0)
{
      m_bConnected=TRUE;
      CCSockClientApp* pApp=(CCSockClientApp*)AfxGetApp();
      CCSockClientDlg* pDlg=(CCSockClientDlg*)pApp- >m_pMainWnd;
      memcpy(m_szBuffer,"Connected to ",13);
      strncat(m_szBuffer,pDlg- >m_szServerAdr,
          sizeof(pDlg- >m_szServerAdr));
      pDlg- >m_MSGS.InsertString(0,m_szBuffer);
      AsyncSelect(FD_READ);    ////提请一个“读”的网络事件,准备接收
}
CAsyncSocket::OnConnect(nErrorCode);
}

---- 7. 新建对话框IDD_Addr,用来输入IP地址和Port;生成新类CAddrDlg。增加两个Edit控件:IDC_Addr、IDC_Port按下表在ClassWizard中为CAddrDlg类添加变量。

Control ID Type Member

IDC_Addr CString m_Addr
IDC_Port Int m_Port

---- 8. 在CSockClientDlg.h中添加代码

#include "AddrDlg.h"
protected:
int TryCount;
MySock m_clientSocket;
UINT m_szPort;
public:
char m_szServerAdr[256];

---- 9. 双击IDD_CSOCKCLIENT_DIALOG对话框中的“连接”按钮,添加以下代码

void CCSockClientDlg::OnConnect()
{
m_clientSocket.ShutDown(2);
m_clientSocket.m_hSocket=INVALID_SOCKET;
m_clientSocket.m_bConnected=FALSE;
CAddrDlg m_Dlg;
//默认端口1088
m_Dlg.m_Port=1088;
if (m_Dlg.DoModal()==IDOK && !m_Dlg.m_Addr.IsEmpty())
{
      memcpy(m_szServerAdr,m_Dlg.m_Addr,sizeof(m_szServerAdr));
      m_szPort=m_Dlg.m_Port;
      //建立计时器,每1秒尝试连接一次,直到连上或TryCount>10
SetTimer(1,1000,NULL);
      TryCount=0;
}
}

---- 10. 添加Windows消息WM_TIMER响应函数OnTimer

void CCSockClientDlg::OnTimer(UINT nIDEvent)
{
if (m_clientSocket.m_hSocket==INVALID_SOCKET)
{
      BOOL bFlag=m_clientSocket.Create(0,SOCK_STREAM,FD_CONNECT);
      if(!bFlag)
      {
       AfxMessageBox("Socket Error!");
       m_clientSocket.Close();
       PostQuitMessage(0);
       return;
      }
}
m_clientSocket.Connect(m_szServerAdr,m_szPort);
TryCount++;
if (TryCount >=10 || m_clientSocket.m_bConnected)
{
      KillTimer(1);
      if (TryCount >=10)
       AfxMessageBox("Connect Failed!");
      return;
}
CDialog::OnTimer(nIDEvent);
}

---- 11. 双击IDD_CSOCKCLIENT_DIALOG对话框中的“发送”按钮,添加以下代码

void CCSockClientDlg::OnSend()
{
if (m_clientSocket.m_bConnected)
{
m_clientSocket.m_nLength=m_MSG.GetWindowText
(m_clientSocket.m_szBuffer, sizeof(m_clientSocket.m_szBuffer));
      m_clientSocket.AsyncSelect(FD_WRITE);
      m_MSG.SetWindowText("");
}
}

---- 12. 双击IDD_CSOCKCLIENT_DIALOG对话框中的“关闭”按钮,添加以下代码

void CCSockClientDlg::OnExit()
{
//关闭Socket
m_clientSocket.ShutDown(2);
//关闭对话框
EndDialog(0);
}

----
12.运行此项目,连接时输入主机名或IP均可,CAsyncSocket类会自动处理。
----
二. 服务端
----
Server端的编程与Client端的类似,下面主要介绍他的Listen及Accept函数
----
1. 建立一个CNewSocket类,重载CAsyncSocket类的OnReceive、OnSend函数,如何进行信息的显示和发送可以参考
Client程序。本例中采用将收到信息原封不动发回的方法来实现Echo功能,代码如下
CNewSocket::OnReceive(int nErrorCOde)
{
m_nLength=Receive(m_szBuffer,sizeof(m_szBuffer),0);
// 直接转发消息
AsyncSelect(FD_WRITE);
}

CNewSocket::OnSend(int nErrorCode)
{
Send(m_szBuffer,m_nLength,0);
}

----
2. 建立一个CMyServerSocket类,重载CAsyncSocket类的OnAccept函数代码如下
----
在MyServerSocket.h中声明变量
public::
CNewSocket*    m_pSocket;

void CMyServerSocket::OnAccept(int nErrorCode)
{
//侦听到连接请求,调用Accept函数
CNewSocket* pSocket = new CNewSocket();
if (Accept(*pSocket))
{
      pSocket- >AsyncSelect(FD_READ);
m_pSocket=pSocket;
}
else
      delete pSocket;
}

----
3. 为对话框添加一个“侦听”按钮,添加如下代码
----
在CsockServerDlg.**中声明变量
public:
CMyServerSocket    m_srvrSocket;
void CCSockServerDlg::OnListen()
{
if (m_srvrSocket.m_hSocket==INVALID_SOCKET)
{
      BOOL bFlag=m_srvrSocket.Create
         (UserPort,SOCK_STREAM,FD_ACCEPT);
      if (!bFlag)
      {
       AfxMessageBox(“Socket Error!”);
       M_srvrSocket.Close();
       PostQuitMessage(0);
       Return;
      }
}
//“侦听”成功,等待连接请求
if (!m_srvrSocket。Listen(1))
{
      int nErrorCode = m_srvrSocket.GetLastError();
      if (nError!=WSAEWOULDBLOCK)
      {
       AfxMessageBox(“Socket Error!”);
       M_srvrSocket.Close();
       PostQuitMessage(0);
       Return;
      }
}
}

----
4. 目前程序只能实现Echo功能,将信息原封不动的转发,若能将Accept中由CNewSocket* pSocket =    new
CNewSocket();得到的Socket指针存入一个CList或一个数组中,便像Client端那样,对所有的连接进行读写控制。

相关文章推荐

windows_socket编程实战

  • 2014-07-14 11:14
  • 1.62MB
  • 下载

Windows下C语言的Socket编程例子(TCP和UDP)

http://www.cnblogs.com/churi/archive/2013/02/27/2935427.html UDP sERVER

Windows Socket 编程资料

  • 2013-01-09 17:51
  • 528KB
  • 下载

windows socket编程

  • 2011-09-26 00:20
  • 10MB
  • 下载

Windows Socket编程简介

WinSock编程使用WinSock API的编程,应该了解TCP/IP的基础知识。虽然你可以直接使用WinSock API来写网络应用程序,但是,要写出优秀的网络应用程序,还是必须对TCP/IP协议...

windows socket编程

  • 2011-09-25 23:46
  • 10MB
  • 下载

Windows Socket 网络编程

  • 2008-01-10 00:04
  • 301KB
  • 下载

Windows Socket 编程_ 简单的服务器/客户端程序 .

Windows Socket 编程_ 简单的服务器/客户端程序  分类: 【Windows编程】【Windows网络编程】2012-04-13 19:07173人阅读评论(4)举报 ...

windows_socket编程实战.pdf

  • 2012-05-25 12:30
  • 392KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)