国产成人亚洲综合,欧美色就是色,欧美色综合一区二区三区

MINA 使用 Apache MINA 开发高性能�|�络应用�E�序(IBM)

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

本文��通过一个简单的问候程�?HelloServer 来介�l?MINA 的基��架构的同时演�C�如何��?MINA 开发网�l�应用程序�?/blockquote>
Apache MINA(Multipurpose Infrastructure for Network Applications) �?Apache �l�织一个较新的��目�Q�它为开发高性能和高可用性的�|�络应用�E�序提供了非�怾�利的框架。当前发行的 MINA 版本支持��Z�� Java NIO 技术的 TCP/UDP 应用�E�序开发、串口通讯�E�序�Q�只在最新的预览版中提供�Q�，MINA 所支持的功能也在进一步的扩展中�?/p>
�? 前正在��?MINA 的��Y件包括有�Q�Apache Directory Project、AsyncWeb、AMQP�Q�Advanced Message Queuing Protocol�Q�、RED5 Server�Q�Macromedia Flash Media RTMP�Q�、ObjectRADIUS、Openfire �{�等�?/p>
本文��通过一个简单的问候程�?HelloServer 来介�l?MINA 的基��架构的同时演�C�如何��用MINA 开发网�l�应用程序�?/p>
环境准备

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

回页�?/strong>

�~�写代码 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演示�E�序

            * @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();

            //使用字符串编�?/span>

            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 {

            /**

            * 当有异常发生时触�?br />
            */

            @Override

            public void exceptionCaught(IoSession ssn, Throwable cause) {

            cause.printStackTrace();

            ssn.close();

            }



            /**

            * 有新�q�接时触�?br />
            */

            @Override

            public void sessionOpened(IoSession ssn) throws Exception {

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

            }



            /**

            * �q�接被关闭时触发

            */

            @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�Q�如果报错请��认是否已将前面提到的三�?jar 文�g��d��至类路径中。如果一切顺利接着��可以启动HelloServer �E�序�Q�启动后提示�Q?code>HelloServer started on port 8080 表示启动成功�Q�如果启动失败，问题无外乎是�c�L��扑ֈ�或者端口占用。如果端口被占用的话�Q�换一个罗�Q�修�?PORT 帔R��值后再次�~�译�q�启动�?/p>

��试服务�?/li>

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

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

好了�Q�一切正常，恭喜你的�W�一个��?MINA 开发的�|�络�E�序已经成功�q�行了�?/p>

回页�?/strong>

MINA 基本�cȝ��描述

在介�l�架构之前先认识几个接口�Q?/p>
IoAccepter 相当于网�l�应用程序中的服务器�?/p>
IoConnector 相当于客��L��

IoSession 当前客户端到服务器端的一个连接实�?/p>
IoHandler 业务处理逻辑

IoFilter �q��o器用于悬接通讯层接口与业务层接�?/p>

回页�?/strong>

MINA 的基��架构

下图�?MINA 的架构图�Q?/p>
�?1�Q�MINA 的架构图

�? 图中的模块链中，IoService 便是应用�E�序的入口，相当于我们前面代码中�?IoAccepter�Q�IoAccepter 便是 IoService 的一个扩展接口。IoService 接口可以用来��d��多个 IoFilter�Q�这�?IoFilter �W�合责�Q链模式�ƈ�? IoProcessor �U�程负责调用。�?IoAccepter �?ioService 接口的基��上还提供�l�定某个通讯端口以及取消�l�定的接口。在上面的例子中�Q�我们是�q�样使用 IoAccepter 的：
IoAcceptor acceptor = new SocketAcceptor();

            
相当于我们��用了 Socket 通讯方式作�ؓ服务的接入，当前版本�?MINA �q�提供了�?SocketAccepter 外的��Z��数据报文通讯�? DatagramAccepter 以及��Z��道通讯�? VmPipeAccepter。另外还包括串口通讯接入方式�Q�目前基于串口通讯的接入方式已�l�在最新测试版�?MINA 中提供。你也可以自行实�? IoService 接口来��用自��q��通讯方式�?/p>
而在上图中最右端也就�? IoHandler�Q�这便是业务处理模块。相当于前面例子中的 HelloHandler �c�R��在业务处理�c�M��不需要去兛_��实际的通讯�l�节�Q�只��处理客��L��传输�q�来的信息即可。编�?Handler �c�d��是��?MINA 开发网�l�应用程序的重心所在，相当�?MINA 已经帮你处理了所有的通讯斚w��的细节问题。�ؓ了简�?Handler �c�，MINA 提供�? IoHandlerAdapter �c�，此类仅仅是实��C�� IoHandler 接口�Q�但�q�不做�Q何处理�?/p>
一�?IoHandler 接口中具有如下一些方法（摘自 MINA �?API 文档�Q�：

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

void messageReceived(IoSession session, Object message)
当接收到客户端的��h��信息后触发此�Ҏ��.

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

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

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

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

void sessionOpened(IoSession session)
当连接后打开时触发此�Ҏ��Q�一般此�Ҏ��?sessionCreated 会被同时触发

前面我们提到 IoService 是负责底层通讯接入�Q��?IoHandler 是负责业务处理的。那�?MINA 架构图中�?IoFilter 作何用途呢�Q�答案是你想作何用途都可以。但是有一个用途却是必��ȝ��Q�那��是作�ؓ IoService �?IoHandler 之间的桥梁。IoHandler 接口中最重要的一个方法是 messageReceived�Q�这个方法的�W�二个参数是一�?Object 型的消息�Q��L��周知�Q�Object 是所�?Java 对象的基��Q�那到底谁来军_��q�个消息到底是什么类型呢�Q�答案也��在�q�个 IoFilter 中。在前面使用的例子中�Q�我们添加了一�?IoFilter �?new ProtocolCodecFilter(new TextLineCodecFactory())�Q�这个过滤器的作用是��来自客��L��输入的信息�{换成一行行的文本后传递给 IoHandler�Q�因此我们可以在 messageReceived 中直接将 msg 对象强制转换�?String 对象�?/p>
�? 如果我们不提供�Q何过滤器的话�Q�那么在 messageReceived �Ҏ��中的�W�二个参数类型就是一�?byte 的缓冲区�Q�对应的�c�L�� org.apache.mina.common.ByteBuffer。虽然你也可以将解析客户端信息放�?IoHandler 中来做，但这�q�不是推荐的做法�Q��原来清晰的模型又模糊��h��Q�变�?IoHandler 不只是业务处理，�q�得充当协议解析的�Q务�?/p>
MINA自��n带有一些常用的�q��o器，例如LoggingFilter�Q�日志记录）、BlackListFilter�Q�黑名单�q��o�Q�、CompressionFilter�Q�压�~�）、SSLFilter�Q�SSL加密�Q�等�?/p>

回页�?/strong>

其他

MINA 不仅仅是用来开发网�l�服务器端应用程序，它一样可以��?IoConnector 来连接到各种各样的网�l�服务程序�?/p>
�? �q�本文中 HelloServer �q�个例子�Q�我们在惊叹 MINA 可以带来多么大便利的同时�Q�还不得不�ؓ其卓��的性能而骄�Ԍ��据称使用MINA开发服务器�E�序的性能已经��D��使用 C/C++ 语言开发的�|�络服务。作�? MINA 的入门文章，性能问题不在本文讨论范围内�?/p>
另外�?MINA 压羃包中附带有不��比 HelloServer 要好得多的例子，通过�q�些例子可以�q�一步的了解�q�掌�?MINA�?/p>

参考资�?
http://mina.apache.org MINA 官方�|�站

MINA 框架��?/span>

1。MINA 框架��?/p>

当客户首�ơ访问采用MINA�~�写的程序时�Q�IoAcceptor作�ؓ�U�程�q�行�Q�负责接受来自客��L��h��。当有客戯��求连接时�Q�创��Z��? Session�Q�该Session与IoProcessor、SocketChannel以及IOService联系��h��。IoProcessor也作�? 另外一个线�E�运行，定时��查客��h��否有数据到来�Q��ƈ对客戯��求进行处理，依次调用在IOService注册的各个IoFilter�Q�最后调�? IoHandler�q�行最�l�的逻辑处理�Q�再��处理后的结果Filter后返回给客户端�?/p>
2。IoSession

Session可以理解为服务器与客��L��的特定连接，该连接由服务器地址、端口以及客��L��地址、端口来军_��。客��L��发�v��h��Ӟ��指定服务器地址和端口，客户端也会指定或者根据网�l��\�׃��息自动指定一个地址、自动分配一个端口。这个地址、端口对构成一个Session�?/p>
Session是服务器端对�q�种�q�接的抽象，MINA对其�q�行了封装，定义了IoSession接口�Q�用来代表客��L��与服务器的连接，在服务器端来指代客户端，实现对客��L��的操作、绑定与客户端有关的信息与对象。通过利用Session的这个概念，�~�写�E�序时就可以在服务器端非常方便地区分出是当前处理的是哪个客户端的��h��、维持客��L��的状态信息、可以实现客��L��之间�怺�通讯�?/p>
IoSession提供以下一些常用方法：

�Q?�Q�setAttribute(Object key, Object value) getAttribute(Object key)

讄��/获取用户定义的属性�?/p>
��该属性与session联系��h��Q�方便以后处理用戯��求时使用。比如如果要求用��L��录后才能�l�箋�q�行操作�Q�那么在用户成功登陆后，可以通过 setAttribute()讄��一个属性，当用户以后��l�请求时�Q�可以通过getAttribute()获取该属性来判断用户是否��d��?/p>
�Q?�Q�getRemoteAddress()

获取�q�程客户端地址�?/p>
�Q?�Q�getId() getCreationTime() getLastIoTime() getConfig()

获取Session的Id、创建时间、上�ơIO旉��、配�|�信息�?/p>
�Q?�Q�write(Object message)

��数据发送给客户端�?/p>
�Q?�Q�close()

关闭Session�?/p>
说明�Q�可以在Session中发送数据，但是Session没有提供��d��数据的方法，��d��数据通过另一套机制在IoHandler的messageReceived()中实现�?/p>
3。Event

MINA可以看成是事仉��动的。通常在网�l�通讯中，可以��整个过�E�划分�ؓ几个基本的阶�D�，如徏立连接、数据通信、关闭连接�?/p>
数据通信一般包括数据的发送和接收�Q�由于在通信�q�程中，可能要多�ơ发送和接收数据�Q�以�q�行不同的业务交互�?/p>
不可能一直都接收和发送数据，因此��有Idle出现�Q�在MINA中，如果在设定的旉��内没有数据发送或接收�Q�那么就会触发一个Idle事�g�?/p>
�׃��某种原因�Q�可能会发生错误�Q�导致系�l�异常发生，引发exception�?/p>
因此�Q�如果从事�g发生的角度看的话�Q�就可以在MINA中将通信看成�׃��个徏立链接（sessionCreated �?sessionOpened �Q�、多个数据接收和发送、一个关闭连接事件以及多个Idle事�g�{?�U�事件组成的�q�程�?/p>
Session是对双方�怺�通信的抽象，因此通信的过�E�就是一�p�d��与Session相关的事件�?/p>
在MINA现在对TCP的实��C��Q�sessionCreated �?sessionOpened 没有区别。因此严格来��_��?�U�类型的事�g�?/p>
4。IoHandler

从以上MINA框架��囑֏�以看出，�Ҏ��自客��L��数据最�l�处理是在IoHandler中处理的。IoHandler��装了来自客��L��不同事�g的处理，如果�Ҏ��个事件感兴趣�Q�可以实现相应的�Ҏ��Q�当该事件发生时�Q�IoHandler中的�Ҏ��׃��被触发执行。IoHandler��d��?个方法对�?个事 �Ӟ��

�Q?�Q�void exceptionCaught(IoSession session, Throwable cause)

有异常发生时被触发�?/p>
�Q?�Q�void messageReceived(IoSession session, Object message)

有消息到达时被触发，message代表接收到的消息�?/p>
�Q?�Q�void messageSent(IoSession session, Object message)

发送消息时时被触发�Q�即在调用IoSession.write()时被触发�Q�message代表��要发送的消息�?/p>
�Q?�Q�void sessionClosed(IoSession session)

当连接关闭时被触发，即Session�l�止时被触发�?/p>
�Q?�Q�void sessionCreated(IoSession session)

当创��Z��个新�q�接时被触发�Q�即当开始一个新的Session时被触发�?/p>
�Q?�Q�void sessionIdle(IoSession session, IdleStatus status)

当连接空闲时被触发。��用IoSessionConfig中的setIdleTime(IdleStatus status, int idleTime)�Ҏ��可以讄��session的空闲时间。如果该Session的空闲时间超�q�设�|�的��|��该方法被触发�Q�可以通过 session.getIdleCount(status)来获取sessionIdle被触发的�ơ数�?/p>
�Q?�Q�void sessionOpened(IoSession session)

当打开一个连接时被触发。在目前的实��C��Q�好�?sessionOpened �?sessionCreated 没有太大区别�Q�sessionCreated �?sessionOpened 之前被触发�?/p>
IoHandler是一个接口，一般情冉|��有必要直接实现该接口的每一个方法。MINA提供了一个IoHandlerAdapter�c�，该类实现�? IoHandler要求的方法，但是都没有做��M��处理。当我们要编写自��q��Handler�Ӟ��可以扩展IoHandlerAdapter�Q�重写我们关心的事�g�Ҏ��卛_��。比如，一般情况，我们比较兛_��是否接收到数据这个时��_��那么我们��可以覆盖messageReceived�Ҏ��Q�不用管其他�Ҏ��?/p>
5。IoFilter

IoFilter用来对客��L��h��或发送给客户的数据进行filter。与IoHandler一��P��Filter也是��Z��事�g的，通过实现IoFilter接口�Q�就可以寚w��信�q�程中的Session的事件进行处理�?/p>
Filter是一�U�链式结构，与IoHandler不同�Q�处理每一�U�Session事�g的函��C��Q�除了传入session对象外，�q�传入了 NextFilter对象�Q�用来代表下一个Filter。一般情况，在处理结束后�Q�调用下一个filter的相应方法作�q�一步处理。Filter也可以针对特定的通信或数据，不进行进一步处理，��可以不用调用NextFilter的相应方法�?/p>
除了与Session相应�?�U�事件外�Q�在IoFilter中还可以对Filter的init、destroy以及add、remove�{�时间爱女作出处理�?/p>
MINA提供了一个IoFilterAdapter�c�，我们要编写自��q��Filter�Ӟ��可以扩展IoFilterAdapter�Q�不用直接实现IoFilter接口�?/p>
Apache MINA提供一个LoggingFilter�c�，用来log通信�q�程�?/p>

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

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

�U�程�l�式�?br /> 每客户一�U�程的模式增加了服务端的负荷�Q�那么我们可以简单的重用服务端处理线�E��?br /> 服务端重用一定的�U�程来处理客��L��h��Q�客��L��h��被放�|�到一个池中供�q�发�U�程取出处理

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 {


    //启动服务端监�?/span>
    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");
        }
    }

    //创徏处理�U�程�l?/span>
    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;

    //�q�发处理�U�程�?/span>
    private int threadNum = 3;

    private boolean runFlag = true;
}

//处理�c?/span>
class ClientHandle implements Runnable{

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

    //处理客户�?/span>
    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 发表评论

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

多线�E�式�Q?br /> 在实际��用过�E�中我们都会希望服务端能同时为多个客��L��提供服务
最直接的办法就是每个客��L��一个线�E?br /> �q�种方式会在一定意义上占用更多�pȝ��资源

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 {

    //启动服务端监�?/span>
    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;
        }

        //处理客户端请�?/span>
        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 发表评论

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

客户端输入一串字�W�串服务端反序输�?quit退出来学习java socket�~�程�?br /> 1�Q�阻塞模�?
一�ơ只能�ؓ一个客��L��服务�Q�这�U��用在实际使用�q�程中基本没有用�?br />

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();
  /*数据的传输结�?/span>*/
  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中填入测试数�?/span>*/
      //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:
              /*父进�E�中处理*/
             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"

   /*数据的传输结�?/span>*/
  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 发表评论