BlogJava-There can be miracles when you believe.-文章分类-SOCKET

MINA 使用 Apache MINA 开发高性能网络应用程序(IBM)

goto — Thu, 25 Sep 2008 07:23:00 GMT

本文将通过一个简单的问候程序 HelloServer 来介绍 MINA 的基础架构的同时演示如何使用 MINA 开发网络应用程序。

Apache MINA(Multipurpose Infrastructure for Network Applications) 是 Apache 组织一个较新的项目，它为开发高性能和高可用性的网络应用程序提供了非常便利的框架。当前发行的 MINA 版本支持基于 Java NIO 技术的 TCP/UDP 应用程序开发、串口通讯程序（只在最新的预览版中提供），MINA 所支持的功能也在进一步的扩展中。

目前正在使用 MINA 的软件包括有：Apache Directory Project、AsyncWeb、AMQP（Advanced Message Queuing Protocol）、RED5 Server（Macromedia Flash Media RTMP）、ObjectRADIUS、Openfire 等等。

本文将通过一个简单的问候程序 HelloServer 来介绍 MINA 的基础架构的同时演示如何使用MINA 开发网络应用程序。

环境准备

首先到官方网站下载最新的 MINA 版本，地址是：http://mina.apache.org/downloads.html。下载之前先介绍一下 MINA 的两个版本：1.0.x 适合运行环境为 JDK1.4，1.1.x 适合 JDK1.5 的版本，两者的编译环境都需要 JDK1.5。JDK1.5 已经是非常普遍了，本文中使用 1.1.5 版本的 MINA，编译和运行所需的文件是 mina-core-1.1.5.jar。
下载 MINA 的依赖包 slf4j。MINA 使用此项目作为日志信息的输出，而 MINA 本身并不附带此项目包，请到http://www.slf4j.org/download.html 地址下载 slf4j 包，slf4j 项目解压后有很多的文件，本例中只需要其中的 slf4j-api-1.4.3.jar 和 slf4j-simple-1.4.3.jar 这两个 jar 文件。如果没有这两个文件就会导致启动例子程序的时候报 org/slf4j/LoggerFactory 类没找到的错误。
当然要求机器上必须装有 1.5 或者更新版本的 JDK。
最好你应该选择一个顺手的 Java 开发环境例如 Eclipse 或者 NetBeans 之类的，可以更方便的编码和调试，虽然我们的最低要求只是一个简单的文本编辑器而已。

回页首

编写代码并执行

编写代码 HelloServer.java 如下
package demo.mina.echo;



            import java.io.IOException;

            import java.net.InetSocketAddress;



            import org.apache.mina.common.*;

            import org.apache.mina.transport.socket.nio.*;

            import org.apache.mina.filter.codec.ProtocolCodecFilter;

            import org.apache.mina.filter.codec.textline.TextLineCodecFactory;



            /**

            * HelloServer演示程序

            * @author liudong (

            http://www.dlog.cn/javayou

            )

            */

            public class HelloServer {



            private static final int PORT = 8080;

            /**

            * @param args

            * @throws IOException

            */

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

            IoAcceptor acceptor = new SocketAcceptor();

            IoAcceptorConfig config = new SocketAcceptorConfig();

            DefaultIoFilterChainBuilder chain = config.getFilterChain();

            //使用字符串编码

            chain.addLast("codec",

            new ProtocolCodecFilter(new TextLineCodecFactory()));

            //启动HelloServer

            acceptor.bind(new InetSocketAddress(PORT), new HelloHandler(), config);

            System.out.println("HelloServer started on port " + PORT);

            }

            }



            /**

            * HelloServer的处理逻辑

            * @author liudong

            */

            class HelloHandler extends IoHandlerAdapter {

            /**

            * 当有异常发生时触发

            */

            @Override

            public void exceptionCaught(IoSession ssn, Throwable cause) {

            cause.printStackTrace();

            ssn.close();

            }



            /**

            * 有新连接时触发

            */

            @Override

            public void sessionOpened(IoSession ssn) throws Exception {

            System.out.println("session open for " + ssn.getRemoteAddress());

            }



            /**

            * 连接被关闭时触发

            */

            @Override

            public void sessionClosed(IoSession ssn) throws Exception {

            System.out.println("session closed from " + ssn.getRemoteAddress());

            }



            /**

            * 收到来自客户端的消息

            */

            public void messageReceived(IoSession ssn, Object msg) throws Exception {

            String ip = ssn.getRemoteAddress().toString();

            System.out.println("===> Message From " + ip +" : " + msg);

            ssn.write("Hello " + msg);

            }

            }

编译执行

先不用试着去读懂每一行代码的具体意思，用你顺手的编译器编译 HelloServer.java，如果报错请确认是否已将前面提到的三个 jar 文件添加至类路径中。如果一切顺利接着就可以启动HelloServer 程序，启动后提示：HelloServer started on port 8080 表示启动成功，如果启动失败，问题无外乎是类没找到或者端口占用。如果端口被占用的话，换一个罗，修改 PORT 常量值后再次编译并启动。

测试服务器

打开命令行窗口，输入 telnet localhost 8080 后，输入您的英文名或者其他一些乱七八糟的字符后回车再去看看刚启动的服务程序有何反应。我的反应如下：

HelloServer started on port 8080

            session open for /127.0.0.1:3023

            ===> Message From /127.0.0.1:3023 :hello

            ===> Message From /127.0.0.1:3023 :hello

            ===> Message From /127.0.0.1:3023 :liudong

            ===> Message From /127.0.0.1:3023 :Winter Lau

好了，一切正常，恭喜你的第一个使用 MINA 开发的网络程序已经成功运行了。

回页首

MINA 基本类的描述

在介绍架构之前先认识几个接口：

IoAccepter 相当于网络应用程序中的服务器端

IoConnector 相当于客户端

IoSession 当前客户端到服务器端的一个连接实例

IoHandler 业务处理逻辑

IoFilter 过滤器用于悬接通讯层接口与业务层接口

回页首

MINA 的基础架构

下图是 MINA 的架构图，

图 1：MINA 的架构图

在图中的模块链中，IoService 便是应用程序的入口，相当于我们前面代码中的 IoAccepter，IoAccepter 便是 IoService 的一个扩展接口。IoService 接口可以用来添加多个 IoFilter，这些 IoFilter 符合责任链模式并由 IoProcessor 线程负责调用。而 IoAccepter 在 ioService 接口的基础上还提供绑定某个通讯端口以及取消绑定的接口。在上面的例子中，我们是这样使用 IoAccepter 的：

IoAcceptor acceptor = new SocketAcceptor();

相当于我们使用了 Socket 通讯方式作为服务的接入，当前版本的 MINA 还提供了除 SocketAccepter 外的基于数据报文通讯的 DatagramAccepter 以及基于管道通讯的 VmPipeAccepter。另外还包括串口通讯接入方式，目前基于串口通讯的接入方式已经在最新测试版的 MINA 中提供。你也可以自行实现 IoService 接口来使用自己的通讯方式。

而在上图中最右端也就是 IoHandler，这便是业务处理模块。相当于前面例子中的 HelloHandler 类。在业务处理类中不需要去关心实际的通讯细节，只管处理客户端传输过来的信息即可。编写 Handler 类就是使用 MINA 开发网络应用程序的重心所在，相当于 MINA 已经帮你处理了所有的通讯方面的细节问题。为了简化 Handler 类，MINA 提供了 IoHandlerAdapter 类，此类仅仅是实现了 IoHandler 接口，但并不做任何处理。

一个 IoHandler 接口中具有如下一些方法（摘自 MINA 的 API 文档）：

void exceptionCaught(IoSession session, Throwable cause)
当接口中其他方法抛出异常未被捕获时触发此方法

void messageReceived(IoSession session, Object message)
当接收到客户端的请求信息后触发此方法.

void messageSent(IoSession session, Object message)
当信息已经传送给客户端后触发此方法.

void sessionClosed(IoSession session)
当连接被关闭时触发，例如客户端程序意外退出等等.

void sessionCreated(IoSession session)
当一个新客户端连接后触发此方法.

void sessionIdle(IoSession session, IdleStatus status)
当连接空闲时触发此方法.

void sessionOpened(IoSession session)
当连接后打开时触发此方法，一般此方法与 sessionCreated 会被同时触发

前面我们提到 IoService 是负责底层通讯接入，而 IoHandler 是负责业务处理的。那么 MINA 架构图中的 IoFilter 作何用途呢？答案是你想作何用途都可以。但是有一个用途却是必须的，那就是作为 IoService 和 IoHandler 之间的桥梁。IoHandler 接口中最重要的一个方法是 messageReceived，这个方法的第二个参数是一个 Object 型的消息，总所周知，Object 是所有 Java 对象的基础，那到底谁来决定这个消息到底是什么类型呢？答案也就在这个 IoFilter 中。在前面使用的例子中，我们添加了一个 IoFilter 是 new ProtocolCodecFilter(new TextLineCodecFactory())，这个过滤器的作用是将来自客户端输入的信息转换成一行行的文本后传递给 IoHandler，因此我们可以在 messageReceived 中直接将 msg 对象强制转换成 String 对象。

而如果我们不提供任何过滤器的话，那么在 messageReceived 方法中的第二个参数类型就是一个 byte 的缓冲区，对应的类是 org.apache.mina.common.ByteBuffer。虽然你也可以将解析客户端信息放在 IoHandler 中来做，但这并不是推荐的做法，使原来清晰的模型又模糊起来，变得 IoHandler 不只是业务处理，还得充当协议解析的任务。

MINA自身带有一些常用的过滤器，例如LoggingFilter（日志记录）、BlackListFilter（黑名单过滤）、CompressionFilter（压缩）、SSLFilter（SSL加密）等。

回页首

其他

MINA 不仅仅是用来开发网络服务器端应用程序，它一样可以使用 IoConnector 来连接到各种各样的网络服务程序。

通过本文中 HelloServer 这个例子，我们在惊叹 MINA 可以带来多么大便利的同时，还不得不为其卓越的性能而骄傲，据称使用MINA开发服务器程序的性能已经逼近使用 C/C++ 语言开发的网络服务。作为 MINA 的入门文章，性能问题不在本文讨论范围内。

另外在 MINA 压缩包中附带有不少比 HelloServer 要好得多的例子，通过这些例子可以进一步的了解并掌握 MINA。

参考资料

http://mina.apache.org MINA 官方网站

MINA 框架简介

1。MINA 框架简介

当客户首次访问采用MINA编写的程序时，IoAcceptor作为线程运行，负责接受来自客户的请求。当有客户请求连接时，创建一个 Session，该Session与IoProcessor、SocketChannel以及IOService联系起来。IoProcessor也作为另外一个线程运行，定时检查客户是否有数据到来，并对客户请求进行处理，依次调用在IOService注册的各个IoFilter，最后调用 IoHandler进行最终的逻辑处理，再将处理后的结果Filter后返回给客户端。

2。IoSession

Session可以理解为服务器与客户端的特定连接，该连接由服务器地址、端口以及客户端地址、端口来决定。客户端发起请求时，指定服务器地址和端口，客户端也会指定或者根据网络路由信息自动指定一个地址、自动分配一个端口。这个地址、端口对构成一个Session。

Session是服务器端对这种连接的抽象，MINA对其进行了封装，定义了IoSession接口，用来代表客户端与服务器的连接，在服务器端来指代客户端，实现对客户端的操作、绑定与客户端有关的信息与对象。通过利用Session的这个概念，编写程序时就可以在服务器端非常方便地区分出是当前处理的是哪个客户端的请求、维持客户端的状态信息、可以实现客户端之间相互通讯。

IoSession提供以下一些常用方法：

（1）setAttribute(Object key, Object value) getAttribute(Object key)

设置/获取用户定义的属性。

将该属性与session联系起来，方便以后处理用户请求时使用。比如如果要求用户登录后才能继续进行操作，那么在用户成功登陆后，可以通过 setAttribute()设置一个属性，当用户以后继续请求时，可以通过getAttribute()获取该属性来判断用户是否登录。

（2）getRemoteAddress()

获取远程客户端地址。

（3）getId() getCreationTime() getLastIoTime() getConfig()

获取Session的Id、创建时间、上次IO时间、配置信息。

（4）write(Object message)

将数据发送给客户端。

（5）close()

关闭Session。

说明：可以在Session中发送数据，但是Session没有提供读取数据的方法，读取数据通过另一套机制在IoHandler的messageReceived()中实现。

3。Event

MINA可以看成是事件驱动的。通常在网络通讯中，可以将整个过程划分为几个基本的阶段，如建立连接、数据通信、关闭连接。

数据通信一般包括数据的发送和接收，由于在通信过程中，可能要多次发送和接收数据，以进行不同的业务交互。

不可能一直都接收和发送数据，因此就有Idle出现，在MINA中，如果在设定的时间内没有数据发送或接收，那么就会触发一个Idle事件。

由于某种原因，可能会发生错误，导致系统异常发生，引发exception。

因此，如果从事件发生的角度看的话，就可以在MINA中将通信看成由一个建立链接（sessionCreated 和 sessionOpened ）、多个数据接收和发送、一个关闭连接事件以及多个Idle事件等7种事件组成的过程。

Session是对双方相互通信的抽象，因此通信的过程就是一系列与Session相关的事件。

在MINA现在对TCP的实现中，sessionCreated 和 sessionOpened 没有区别。因此严格来说，有6种类型的事件。

4。IoHandler

从以上MINA框架简图可以看出，对来自客户端数据最终处理是在IoHandler中处理的。IoHandler封装了来自客户端不同事件的处理，如果对某个事件感兴趣，可以实现相应的方法，当该事件发生时，IoHandler中的方法就会被触发执行。IoHandler总共有7个方法对应7个事件：

（1）void exceptionCaught(IoSession session, Throwable cause)

有异常发生时被触发。

（2）void messageReceived(IoSession session, Object message)

有消息到达时被触发，message代表接收到的消息。

（3）void messageSent(IoSession session, Object message)

发送消息时时被触发，即在调用IoSession.write()时被触发，message代表将要发送的消息。

（4）void sessionClosed(IoSession session)

当连接关闭时被触发，即Session终止时被触发。

（5）void sessionCreated(IoSession session)

当创建一个新连接时被触发，即当开始一个新的Session时被触发。

（6）void sessionIdle(IoSession session, IdleStatus status)

当连接空闲时被触发。使用IoSessionConfig中的setIdleTime(IdleStatus status, int idleTime)方法可以设置session的空闲时间。如果该Session的空闲时间超过设置的值，该方法被触发，可以通过 session.getIdleCount(status)来获取sessionIdle被触发的次数。

（7）void sessionOpened(IoSession session)

当打开一个连接时被触发。在目前的实现中，好像 sessionOpened 和 sessionCreated 没有太大区别，sessionCreated 在 sessionOpened 之前被触发。

IoHandler是一个接口，一般情况没有必要直接实现该接口的每一个方法。MINA提供了一个IoHandlerAdapter类，该类实现了 IoHandler要求的方法，但是都没有做任何处理。当我们要编写自己的Handler时，可以扩展IoHandlerAdapter，重写我们关心的事件方法即可。比如，一般情况，我们比较关心是否接收到数据这个时间，那么我们就可以覆盖messageReceived方法，不用管其他方法。

5。IoFilter

IoFilter用来对客户的请求或发送给客户的数据进行filter。与IoHandler一样，Filter也是基于事件的，通过实现IoFilter接口，就可以对通信过程中的Session的事件进行处理。

Filter是一种链式结构，与IoHandler不同，处理每一种Session事件的函数中，除了传入session对象外，还传入了 NextFilter对象，用来代表下一个Filter。一般情况，在处理结束后，调用下一个filter的相应方法作进一步处理。Filter也可以针对特定的通信或数据，不进行进一步处理，就可以不用调用NextFilter的相应方法。

除了与Session相应的7种事件外，在IoFilter中还可以对Filter的init、destroy以及add、remove等时间爱女作出处理。

MINA提供了一个IoFilterAdapter类，我们要编写自己的Filter时，可以扩展IoFilterAdapter，不用直接实现IoFilter接口。

Apache MINA提供一个LoggingFilter类，用来log通信过程。

goto 2008-09-25 15:23 发表评论

JAVA SOCKET系列（三）

goto — Fri, 19 Sep 2008 07:35:00 GMT

线程组式模
每客户一线程的模式增加了服务端的负荷，那么我们可以简单的重用服务端处理线程。
服务端重用一定的线程来处理客户端请求，客户端请求被放置到一个池中供并发线程取出处理

package com.lei.socket.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class PooledClientServer {


    //启动服务端监听
    public void start(){
        try{
            setUpHandlers();
            ServerSocket server = new ServerSocket(port);
            Socket client = null;
            while(runFlag){
                client = server.accept();
                System.out.println("accept client " + client.getInetAddress().getHostAddress());
                ClientHandle.handleClient(client);
            }
            server.close();
        }catch(IOException e){
            System.out.println("start error");
        }
    }

    //创建处理线程组
    public void setUpHandlers() {
        for (int i = 0; i < threadNum; i++) {
            ClientHandle ch = new ClientHandle();
            new Thread(ch, "Handler " + i).start();
        }
    }

    public static void main(String[] args){
        PooledClientServer s = new PooledClientServer();
        s.start();
    }


    private int port = 3000;

    //并发处理线程数
    private int threadNum = 3;

    private boolean runFlag = true;
}

//处理类
class ClientHandle implements Runnable{

    public static void handleClient(Socket client) {
        synchronized (pool) {
            pool.add(client);
            pool.notifyAll();
        }
    }

    //处理客户端
    private void handleClient(){
        try{
            BufferedReader inReader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            BufferedWriter outWriter = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            while(true){
                outWriter.write("please input String->");
                outWriter.flush();
                String str = inReader.readLine();
                if(str.equalsIgnoreCase("quit")){
                    outWriter.write("quit ok");
                    client.close();
                    break;
                }
                else{
                    outWriter.write("reulst is :" + new StringBuffer(str).reverse().toString());
                    outWriter.write("\r\n");
                }
            }
        }catch(IOException e){
            System.out.println("Handle client error");
        }
    }

    public void run(){
        while (true) {
            synchronized (pool) {
                while (pool.isEmpty()) {
                    try {
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        return;
                    }
                }
                client = (Socket) pool.remove(0);
            }
            handleClient();
        }
    }

    private Socket client;
    private static ArrayList pool = new ArrayList();
}

goto 2008-09-19 15:35 发表评论

JAVA SOCKET系列（二）

goto — Fri, 19 Sep 2008 06:33:00 GMT

多线程式：
在实际使用过程中我们都会希望服务端能同时为多个客户端提供服务
最直接的办法就是每个客户端一个线程
这种方式会在一定意义上占用更多系统资源

package com.lei.socket.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class MultiThreadServer {

    //启动服务端监听
    public void start(){
        try{
            ServerSocket server = new ServerSocket(port);
            Socket client = null;
            while(runFlag){
                client = server.accept();
                System.out.println("accept client " + client.getInetAddress().getHostAddress());
                new Thread(new ClientHandle(client)).start();
            }
            server.close();
        }catch(IOException e){
            System.out.println("start error");
        }
    }

    public static void main(String[] args){
        MultiThreadServer s = new MultiThreadServer();
        s.start();
    }

    class ClientHandle implements Runnable{
        public ClientHandle(Socket s){
            this.client = s;
        }

        //处理客户端请求
        public void handleClient(){
            try{
                BufferedReader inReader = new BufferedReader(new InputStreamReader(client.getInputStream()));
                BufferedWriter outWriter = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
                while(true){
                    outWriter.write("please input String->");
                    outWriter.flush();
                    String str = inReader.readLine();
                    if(str.equalsIgnoreCase("quit")){
                        outWriter.write("quit ok");
                        client.close();
                        break;
                    }
                    else{
                        outWriter.write("reulst is :" + new StringBuffer(str).reverse().toString());
                        outWriter.write("\r\n");
                    }
                }
            }catch(IOException e){
                System.out.println("Handle client error");
            }
        }

        public void run(){
            handleClient();
        }

        private Socket client;
    }

    private int port = 3000;

    private boolean runFlag = true;
}

goto 2008-09-19 14:33 发表评论

JAVA SOCKET系列（一）

goto — Fri, 19 Sep 2008 06:02:00 GMT

客户端输入一串字符串服务端反序输出 quit退出来学习java socket编程。
1：阻塞模式
一次只能为一个客户端服务，这种使用在实际使用过程中基本没有用处

goto 2008-09-19 14:02 发表评论

UNIX 下socket编程例子

goto — Thu, 18 Sep 2008 03:10:00 GMT

server.c

  #include   <sys/types.h>
  #include   <sys/socket.h>
  #include   <arpa/inet.h>
  #include   <netinet/in.h>
  #include   <sys/param.h>
  #include   <sys/types.h>
  #include   <errno.h>
  #include   <sys/stat.h>
  #include   <stdio.h>
  #include   <stdlib.h>
  #include   <unistd.h>
  #include   <stropts.h>
  #include   <string.h>
  #include   <pthread.h>
  #include   <strings.h>
  #include   <signal.h>

  #define   SERV_PORT   1685
  #define   STRINGLEN   255
  #define   DATALENGTH   1024
  #define IP "172.18.215.24"

   void alarm_timeout();
  /*数据的传输结构*/
  struct DataInfo
  {
      char   chRemotePath[STRINGLEN];
      char   chFileName[STRINGLEN];
      int    iFileLen;
      int    iDataLen;
      char   chData[DATALENGTH];
  };
  typedef struct DataInfo S_DataInfo;

  int   main(int   argc,   char   **argv)
  {
      int   iSockfd,   iNewSockfd;
      int remote_len;
      char  remote_ip[64];
      struct   sockaddr_in   MyAddr;
      struct   sockaddr_in   TheirAddr;
      struct sockaddr_in cli_addr = {AF_INET};
      int   iSinSize;
      S_DataInfo  data, *buffer;
      buffer   =   (S_DataInfo*)malloc(sizeof(S_DataInfo));

      bzero(&MyAddr,   sizeof(MyAddr));
      bzero(&data,   sizeof(data));

      /*往data中填入测试数据*/
      //strcpy(data.chData,   "\"This   sentence   is   from   server.\"");
      //data.iDataLen   =   strlen(data.chData);

      if((iSockfd   =   socket(AF_INET,   SOCK_STREAM,   0))   ==   -1)
      {
          perror("socket()");
          exit(-1);
      }
      MyAddr.sin_family   =   AF_INET;
      MyAddr.sin_port   =   htons(SERV_PORT);
      MyAddr.sin_addr.s_addr   =   inet_addr(IP);
      if(bind(iSockfd,   (struct   sockaddr_in   *)&MyAddr,   sizeof(struct   sockaddr_in))   ==   -1)
      {
          close(iSockfd);
          perror("bind()");
          exit(-1);
      }
      if(listen(iSockfd,   10)   ==   -1)
      {
          close(iSockfd);
          perror("listen()");
          exit(-1);
      }
      signal(SIGCLD,SIG_IGN);
      for(;;)
      {
      iSinSize   =   sizeof(struct   sockaddr_in);
      printf("Waiting\n");
      if((iNewSockfd   =   accept(iSockfd,   (struct   sockaddr_in   *)&TheirAddr,   &iSinSize))   ==   -1)
      {
          close(iSockfd);
          perror("accept()");
          exit(-1);
      }
      printf("Server:   got   connection   from   %s\n",   inet_ntoa(TheirAddr.sin_addr));
      int i = 0;
      switch(fork())
      {
          case   -1:
              close(iSockfd);
              close(iNewSockfd);
              perror("fork()");
              exit(-1);
          case   0:

               //sleep(120);
               //printf("sleep ok\n");
              while (i++ < 2)
              {
                  /*

                   getpeername(iNewSockfd,(struct sockaddr *)&cli_addr,&remote_len);
                                 strcpy(remote_ip,(char *)inet_ntoa(cli_addr.sin_addr));
                                 printf("client ip is %s \n",remote_ip);
                                 signal( SIGALRM, alarm_timeout );
                                 alarm(200);
                  if(read(iNewSockfd,   buffer,   sizeof(S_DataInfo))   <=   0)
                  {
                      close(iSockfd);
                      close(iNewSockfd);
                      printf("read data error !!");
                      exit(-1);
                  }
                  alarm(0);
                  printf("read data success ,datalen = %d,data =[%s]\n",buffer->iDataLen,buffer->chData);
                  */
                  //sleep(10);
                  sleep(11);
                      strcpy(data.chData, "server receive data ");
                      strcat(data.chData, buffer->chData);
                            data.iDataLen   =   strlen(data.chData);

                  if(write(iNewSockfd,   &data,   sizeof(S_DataInfo))   ==   -1)
                  {
                      close(iSockfd);
                      close(iNewSockfd);
                      perror("write()");
                      exit(-1);
                  }

                  //if( (data.iDataLen == 4) && (strcmp(data.chData,"exit") == 0) )
                  //    break;
              }

              printf("send and receive is   complete.\n");
              close(iNewSockfd);
              exit(0);
      default:
              /*父进程中处理*/
             close(iNewSockfd);
      }/*end   switch*/

      }  /*end for(;;)*/
      free(buffer);
      return   0;
  }

  void alarm_timeout()
{
    printf("alarm_timeout ok\n");
    exit(0);

}

client.c

  #include   <stdio.h>
  #include   <string.h>
  #include   <errno.h>
  #include   <sys/types.h>
  #include   <sys/socket.h>
  #include   <netinet/in.h>
  #include   <arpa/inet.h>

  #define   SERV_PORT   1685
  #define   STRINGLEN   255
  #define   DATALENGTH   1024
  #define IP "172.16.215.149"

   /*数据的传输结构*/
  struct DataInfo
  {
      char   chRemotePath[STRINGLEN];
      char   chFileName[STRINGLEN];
      int    iFileLen;
      int    iDataLen;
      char   chData[DATALENGTH];
  };
  typedef struct DataInfo S_DataInfo;

  int   main()
  {
      int   sock;
      struct   sockaddr_in   sin;
      S_DataInfo  data, *buffer;
      buffer   =   (S_DataInfo*)malloc(sizeof(S_DataInfo));

      bzero(&data,   sizeof(data));

      sock   =   socket(AF_INET,   SOCK_STREAM,   0);
      if   (sock   ==   -1)
      {
          perror("client   socket");
          return   -1;
      }

      memset(&sin,   0,   sizeof(sin));
      sin.sin_family   =   AF_INET;
      sin.sin_addr.s_addr   =   inet_addr(IP);
      sin.sin_port   =   htons(SERV_PORT);

      if   (connect(sock,   (struct   sockaddr   *)&sin,   sizeof(sin))   ==   -1)
      {
          perror("client   connect   error");
          return   -1;
      }
      int i = 0;
      //sleep(120);
      printf("sleep ok\n");
      while (i++ < 10)
      {
          data.iDataLen = 1;
          data.chData[0] = i + 48;

          //send
          if(write(sock,    &data,   sizeof(S_DataInfo))   <= 0){
                     printf("send data %d error\n",i);
                     return   -1;
            }
            printf("send data [%s] ok\n",data.chData);

            //receive
            /*
               if (read(sock,  buffer,   sizeof(S_DataInfo)) <= 0){
                     printf("revdata %d error",i);
                     return   -1;
            }
            printf("receive data [%s] ok\n",buffer->chData);
            */

      }

      close(sock);
  }

goto 2008-09-18 11:10 发表评论