ACE_FIFO_Recv用于从管道文件中读取数据。如果该管道文件不存在，则它会创建一个，这在该类实例的初始化时进行。与之相反，ACE_FIFO_Send在指定的管道文件中写数据，如果该管道文件不存在，则会出错。

一般情况下，我们会按照如下的例程来开始从一个指定的管道文件中读入数据：

       char pipename[]=”/thispipe”;

ACE_FIFO_Recv reader(pipename);

        char buf[1024]＝｛0｝;

        int len＝0;

       if( (len=reader.recv(buf,1024))>0 )

                     ……//error handle

管道的标识pipename将被用于生成管道文件，所以对它的命名应该遵循文件的命名方式，上例中即表示在根目录下使用名为thispipe的管道文件。recv()方法会阻塞到管道中有数据可读。

下面则是典型的写入端方法：

               ACE_FIFO_Send writer(pipename);

               if( (len=writer.send(buf,len+6))<0 )

                                   ……//error handle

要注意的是，如果writer被初始化的时候该管道文件不存在，则writer的初始化会出错。随后的send()方法也会出错。

如果要利用这一设施进行双向通信，有两种方案可以采用：

一：使用一个管道文件：接收方开启管道等待接收数据，发送方利用同一管道标识写入。接收方在接收数据以后，用同样的标识实例化一个ACE_FIFO_Send，以写入数据，而同时在原发送方建立一个同样的接收过程，等待接收这个反馈数据。

但是，这种方法存在冲突，需要小心避免：如果接收方是以循环接收的方式等待读取数据的，那么它写回的反馈数据可能被它自己的下一个循环接收，陷入自己跟自己通信的混乱状态。这种可能性在实践中接近百分之百，理论上则是出于操作系统的时间片轮换的调度策略。

二：使用两个管道文件：接收方开启监听管道等待数据，发送方用该管道标识写入数据，然后，发送方“马上“建立另一个管道，以等待接收方的反馈数据。同时，接收方在接收到数据处理后，执行对另一管道的写入操作。为了实现同步，可以采用在接收方的接收数据和发送数据之间插入一个睡眠动作以保障同步。

下面附一个可运行的示例：

notify程序用于向指定进程发送某些字符串的消息，p1程序则接收该消息，并且进行处理（附加一段字符串），然后返回这段经过修改的数据。略做修改，该示例可扩展成为notify向多个进程同时发送消息进行进程间通信。

//notify.cpp

＃i nclude "ace/FIFO_Send.h"

＃i nclude "ace/FIFO_Recv.h"

＃i nclude "ace/Log_Msg.h"

const char *pipename[] ={"/p1","/p2","/p3"};

const char *pipename_[]={"/p1_","/p2_","/p3_"};

const int num = 1;

int ACE_TMAIN(int,ACE_TCHAR *[])

{

        ACE_FIFO_Send *writer=NULL;

        ACE_FIFO_Recv *reader=NULL;

        char buf[1024]={0};

        strcpy(buf,"this is a message!");

        for(int i=0;i<num;i++)

        {      

                writer = new ACE_FIFO_Send(pipename[i]);

                if( 0>=writer->send(buf,strlen(buf)) )

                        ACE_ERROR_RETURN((LM_ERROR,"send to %s error,exit!\n",pipename[i]),-1);

                memset(buf,0,1024);

                reader = new ACE_FIFO_Recv(pipename_[i]);

                int n = reader->recv(buf,1024);

                if( n>0 )

                        ACE_DEBUG((LM_INFO,"recv %d bytes message back:[%s]\n",n,buf));

        }

        return 0;

}

//p1.cpp

＃i nclude "ace/FIFO_Send.h"

＃i nclude "ace/FIFO_Recv.h"

＃i nclude "ace/Log_Msg.h"

int main(int argc,char *argv[])

{

        char pipename[16]={0};

        char pipename_[16]={0};

        strcpy(pipename,"/p1");

        ACE_FIFO_Recv reader(pipename);

        sprintf(pipename_,"%s_",pipename);

        char buf[1024];

        int len;

        while(1)

        {

                memset(buf,0,1024);

                len = 0;

                if( (len=reader.recv(buf,1024))>0 )

                {

                        ACE_DEBUG((LM_INFO,"recv %d:\t[%s]\n",len,buf));

                        sprintf(buf+len,"--back");

                        ACE_OS::sleep(1);

                        ACE_FIFO_Send writer(pipename_);

                        if( (len=writer.send(buf,len+6))<0 )

                                ACE_ERROR_RETURN((LM_ERROR,"send error!\n"),-1);                }

        }

        return 0;

}

★     整体设计思想

       对每个要发送的包，libnet维护一个libnet­_t结构，这个结构是理解整个libnet的关键，也是libnet得以实现它强大功能的关键。让我们先从它入手，从整体到细节地揭开libnet的面纱。下面左图是libnet_t这个结构的示例。

其中的fd就是发送数据包将要用到的socket套接字，injection_type将会被设置成libnet_init()中的第一个参数，即你选择发送的方式，是基于link_layer的链路层数据包？还是基于IP层的raw数据包？后一种情况又分为IP4和IP6两种。protocol_blocks 和protocol_end都是指针，指向一个libnet自定义的libnet_pblock_t结构，由此管理一个libnet_pblock_t的链表。而libnet_pblock_t则表述各个协议，维护各个协议给发送的数据包添加的数据块，它的具体选项下面再说。link_type表示链路层的类型，link_offset则指向链路层也就是最底层协议包头的偏移地址。aligner是为了维护最后的数据包的字对齐而设置的，字符串指针device则指向通讯所用的设备，比如eth0.state是一个结构，与ptag_state一起，记录包在建立过程中的一些信息。label是一个字符数组。每当有错误发生的时候，errbuf数组就被用来记录错误信息。全部的数据包长度和保存于total_size中。

从libnet_t已经大概可以看出libnet的设计思想了：程序员决定一些参数，并且通过函数调用中的参数把相关的数据交给libnet.libnet则在程序员每要求购建一个协议包头的时候，为其创建一个libnet_pblock_t的结构保存这些数据，并将该结构入链表。当所有的准备工作完成，程序员一声令下，libnet就将协议块链（由protocol_blocks开始，终于pblock_end）中的协议包头以及数据组合成一个合乎规格的包，通过硬件发送出去。如果任何一个步骤出了差错，程序员都可以从errbuf中获取出错信息。最后，libnet从程序员手中接过一个指令，进行所有的善后工作。

每种协议的包头将在前期被实现为一个libnet_pblock_t的结构。libnet为它所支持的协议都定义了相应的数据结构，例如TCP包头的定义：

struct libnet_tcp_hdr

{

    u_int16_t th_sport;       /* source port */

    u_int16_t th_dport;       /* destination port */

    u_int32_t th_seq;          /* sequence number */

    u_int32_t th_ack;          /* acknowledgement number */

#if (LIBNET_LIL_ENDIAN)

    u_int8_t th_x2:4,         /* (unused) */

           th_off:4;        /* data offset */

#endif

#if (LIBNET_BIG_ENDIAN)

    u_int8_t th_off:4,        /* data offset */

           th_x2:4;         /* (unused) */

#endif

    u_int8_t  th_flags;       /* control flags */

    …….

    u_int16_t th_win;         /* window */

    u_int16_t th_sum;         /* checksum */

    u_int16_t th_urp;         /* urgent pointer */

};

它的长度是：

#define           LIBNET_TCP_H      0x14    /**< TCP header:          20 bytes */

当程序员调用libnet_built_tcp()构建一个TCP包头时，libnet会分配一个这样的结构，并且按照程序员的意愿填充这个结构的各个字段。并且生成一个libnet_pblock_t结构，使它的buf指针指向这个数据包头结构，并用b_len保存这个包头的长度（20字节）。这个libnet_pblock_t的其它相关字段将会被按规则填充。之后，这个libnet_pblock_t会被加入到libnet_t结构所维护的协议块链的适当位置。所谓“适当位置”，将会在后面加以说明。下图是进程中一种可能出现的情形：

利益于这种精巧的整体架构，libnet的具体实现就不显得困难了，而我们对它的理解也因此受益。剩下来的只是一些细节性的东西需要去把握，这一点显然更适合亲自去阅读代码。

下面是大概的处理流程。

在开始之前，需要插入一点说明：libnet使用条件编译的方式消除平台间的差异，由此产生了很多同名的函数（当然它们都在内部被调用），比如libnet_open_link（）有五个。程序在运行时选择哪一个调用取决于你使用的平台或者你强加于编译器的预编译选项。

一般情况下事情会从libnet_init()开始。libnet_init()首先开启系统的网络功能：在linux下面，它会验证是否具有超级用户权限（这也就意味着低权限的用户不能使用成功）,而如果是在windows下面，则会调用大名鼎鼎的WSAStartup()函数。之后分配一块内存区域建立libnet_t结构。在简单的初始化后，根据程序员传入的发送类型参数，进行相应的操作：如果是基于链路层的发送方式（LIBNET_LINK,LIBNET_LINK_ADV）,则会向操作系统申请设备，并开启底层的socket服务。如果是基于IP层的发送方式，则开启该层的socket服务。

准备工作做好之后，转入直接的建包工作,这一工作实际表现为建一系列的协议包头。程序员需要按照自顶向下的顺序建协议包头，而要发送的正文数据往往被作为第一个协议包头的“有效荷载（payload）”被加载。此外，某些协议可能具有可选数据项，这一部分被libnet独立出来，由一个单独的libnet_pblock_t来负责，libnet同时也为此提供相应的功能函数，其名称被定为libnet_build_*_options().在这种情况下，libnet会自动调整这些协议块在链表中的位置，使payload的数据块在前面，中间是options块，其后跟随着该层协议的固定包头。

在合适的时候，libnet会把计算校验和这样的繁琐的工作优雅地完成，你甚至感觉不到它已经为你这样做了。

这样，只要程序员的使用正确，数据以及协议包头已经在链表中按顺序排列了，这为简化后面的工作极为有益。在libnet_write()过程中，链表中的数据被按顺序地拷贝到一个大的缓冲内。拷贝虽然是按照从高层协议到低层协议的顺序进行，但是却是从缓冲的后部向前部拷贝，从这里，我们可以看到“协议栈”的思想在闪光。

当一切工作完成之后，程序员简单地调用libnet_destroy()函数，关闭使用的网络通讯设备，释放占用的内存。程序员的工作是如此地简单：他甚至仅仅需要传递一个参数给这个简短的函数。

除了完成这样一些最直接的工作以外，libnet还提供了一组丰富实用的功能。它提供的地址解析功能能够实现IP地址在网络字节顺序、域名、点分形式之间的转换，它也提供了一套完整的随机数生成方案供你使用，如此等等。这一些功能使得它得以从一套单纯的库跃升为一个完整的系统。

但是，如果我们对那些系统自动给我们做的工作感兴趣，希望与发送的数据作“面对面”的接触，libnet则会是一个不错的选择。

libnet是UNIX系统同台上网络安全工具开发的重要的库，它和libpcap、libnids一起，给网络安全工具的开发人员提供了一组丰富而且完全的武器，使之得以很方便地编写出结构化强、健壮性好、可移植性高等特点的程序。

libnet提供一系列的接口函数，实现和封装了数据包的构造和发送过程。利用它可以亲自构造从应用层到链路层的各层协议的数据包头，并将这些包头与有效数据有序地组合在一起发送出去。当然，它也是基于tcp/ip协议族模型的。

libnet当前的版本是1.1.2，相对于1.0.*版本有比较大的变化。

全部源代码包括18,000 行代码，109个导出函数，其中包括67个建包函数。这使得它支持现有的TCP/IP族的所有协议。此外，它支持多平台，Windows,OS X,BSD,Linux, Solaris,HPUX都能使用。

下图是它支持的协议：

libnet库可以被划分为4个功能部分：内存管理、地址解析、包处理、以及其他一些支持函数。

★ 内存管理函数 

  单数据包内存初始化及环境建立： 

libnet_t *libnet_init(int injection_type, char *device, char *err_buf);

  资源释放： 

    void libnet_destroy(libnet_t *l);

★ 地址解析函数 

  地址解析： 

char *libnet_addr2name4(u_int32_t in, u_int8_t use_name); 

libnet_name2addr4(libnet_t *l, char *host_name, u_int8_t use_name); 

struct libnet_in6_addr libnet_name2addr6(libnet_t *l, char *host_name, u_int8_t use_name); 

void libnet_addr2name6_r(struct libnet_in6_addr addr, u_int8_t use_name,

char *host_name, int host_name_len);

  获取接口设备IP地址： 

    u_int32_t libnet_get_ipaddr4(libnet_t *l);

    struct libnet_in6_addr libnet_get_ipaddr6(libnet_t *l);

  获取接口设备硬件地址： 

    struct libnet_ether_addr *libnet_get_hwaddr(libnet_t *l);

★ 数据包构造函数

   （这一部分函数较多，都以libnet_build_*()的形式出现，在此略过）

★ 数据包发送函数

    int libnet_write(libnet_t *l);

★ 相关的支持函数 

  随机数种子生成器： 

    int libnet_seed_prand(libnet_t *l);

  获取随机数： 

    u_int32_t libnet_get_prand(int mod);

端口列表链初始化： 

    int libnet_plist_chain_new(libnet_t *l, libnet_plist_t **plist, char *token_list);

  获取端口列表链的下一项(端口范围)： 

    int libnet_plist_chain_next_pair(libnet_plist_t *plist, u_int16_t *bport,

u_int16_t *eport);

  端口列表链输出显示： 

    int libnet_plist_chain_dump(libnet_plist_t *plist);

  获取端口列表链： 

    char *libnet_plist_chain_dump_string(libnet_plist_t *plist);

  端口列表链内存释放： 

    int libnet_plist_chain_free(libnet_plist_t *plist);

对它的使用也非常简单，只要你了解自己要做什么事情、应该把哪些参数放在什么位置。利用libnet函数库开发应用程序的基本步骤非常简单： 

1、数据包内存初始化； 

2、构造数据包； 

3、发送数据； 

4、释放资源； 

例： libnet的发行包里提供了很多示例程序，其中/libnet/sample/tcp1.c如果省略掉一些参数的设置和错误处理，则程序简化为：

#if (H***E_CONFIG_H)

＃i nclude "../include/config.h"

#endif

＃i nclude "libnet_test.h"

#ifdef __WIN32__

＃i nclude "../include/win32/getopt.h"

#endif

int

main(int argc, char *argv[])

{

   //…….

    l = libnet_init(

            LIBNET_LINK,                            /* injection type */

            NULL,                                   /* network interface */

            errbuf);                                /* error buffer */

    //……

    t = libnet_build_tcp_options(

"\003\003\012\001\002\004\001\011\010\012\077\077\077\077\000\000\000\000\000\000",

        20,

        l,

        0);

    //……

    t = libnet_build_tcp(src_prt, dst_prt, 0x01010101, 0x02020202, TH_SYN, 32767, 0,  10,                                       

        LIBNET_TCP_H + 20 + payload_s, payload, payload_s, l, 0);                                       

    t = libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_TCP_H + 20 + payload_s, 0, 242, 0, 64,                                     

        IPPROTO_TCP, 0,  src_ip, dst_ip, NULL, 0, l,  0);                                     

    t = libnet_build_ethernet(enet_dst, enet_src, ETHERTYPE_IP, NULL, 0, l, 0);                                 

    c = libnet_write(l);

     libnet_destroy(l);

    return (EXIT_SUCCESS);

bad:

    libnet_destroy(l);

    return (EXIT_FAILURE);

}

#if defined(__WIN32__)

＃i nclude <../include/win32/getopt.h>

＃i nclude <winsock2.h>

＃i nclude <ws2tcpip.h>

#endif  /* __WIN32__ */

/* EOF */

ACE Service Configurator框架是Component Configurator模式的一种实现。使用它可以在运行时动态地配置服务和流，无论它们是动态地链接进你的程序的，还是其对象是从共享库中动态加载的。你既可以配置服务（对象），也可以配置流（基于配置文件而非在编译时装配模块）。

配置静态服务

静态服务是代码已经链接进可执行的服务。ACE Service Configurator使我们能把服务构建成静态链接的、可配置的服务：将所有代码都链接进可执行程序中，但是在框架显式地激活服务之前，服务不会实例化或者激活。

配置静态服务牺牲了一定的灵活性换取更好的安全性。对于某些服务来说――它们必须只含有受信任的、静态链接的服务（代码）――这是非常有用的。

激活静态服务可以从代码中设置激活方法，也可以在配置文件中进行配置。

服务要求被设计成为一个ACE_Service_Object的子类。我们将会实现一个最简单地服务：它什么都不做，除了在激活、挂起、恢复、移除时打印出一行消息。

class MyStaticObj : public ACE_Service_Object 

{

public:

       MyStaticObj(ACE_Reactor *r = ACE_Reactor::instance())

              :ACE_Service_Object(r){;}

       virtual ~MyStaticObj(){;}

  //初始化。服务激活时调用。若返回－1表示出错，此时服务会被移除。

       virtual int init (int argc, ACE_TCHAR *argv[])

       {

              printf("---MyStaticObj::init\n");

              return 0;

       }

  //服务结束。移除时

       virtual int fini()

       {

              printf("---MyStaticObj::fini\n");

              return 0;

       }

       virtual int suspend(){

              printf("---MyStaticObj::suspend\n");

              return 0;

       }

       virtual int resume(){

              printf("---MyStaticObj::resume\n");

              return 0;

       }

};

ACE_FACTORY_DEFINE (ACE_Local_Service, MyStaticObj)

ACE_STATIC_SVC_DEFINE (

  MyStaticObj-Discriptor,

  ACE_TEXT ("MyStaticObj"),

  ACE_SVC_OBJ_T,

  &ACE_SVC_NAME (MyStaticObj),

  ACE_Service_Type::DELETE_THIS

  | ACE_Service_Type::DELETE_OBJ,

  0 // This object is not initially active.

)

ACE_STATIC_SVC_REQUIRE (MyStaticObj-Discriptor)

说明

后面三行是ACE Service Configurator设计的一些宏。ACE把已知的、可配置的静态服务放在一个内部仓库中。每个静态服务都必须用ACE提供的一些宏把一些薄记信息插入这个仓库。这样框架就能实例化一个MyStaticObj对象，以在服务激活时执行服务。

ACE_FACTORY_DEFINE (CLS,SERVICE_CLASS)

它生成不依赖于编译器的工厂方法，并且一致地管理动态内存

CLS是我们的程序/库用来导入/导出声明的标识符，如果服务工厂不需要导出到DLL外部，可以使用特殊符号ACE_Local_Service。

SERVICE_CLASS是从ACE_Service_Object派生的类的名称。

ACE_STATIC_SVC_DEFINE (SERVICE_VAR,NAME,TYPE, FACTORY,FLAGS,ACTIVE)

这个宏利用上一个宏展开的工厂方法创建一个类的实例，并且向ACE Service Configurator仓库登记服务的相关消息，这样我们可以在需要的时候对服务进行管理。

SERVICE_VAR是将被创建的对象的名称，即实例名。

NAME。一个不包含空格的文本串，在服务配置文件中将用该名称来标识这个服务。

TYPE.正在登记的对象类型。构建服务使用ACE_SVC_OBJ_T。

FACTORY。一个指针，指向用于创建服务对象的工厂函数。

FLAGS。指定在服务关闭时，怎样处置与服务相关的对象。

ACTIVE。如果为1，则服务会在程序启动时激活，但不能传给它任何参数。如果是0，服务就会根据服务配置文件中的指令进行初始化。

ACE_STATIC_SVC_REQUIRE (SERVICE_VAR)

确保在程序启动时，创建服务对象的一个实例。

启动程序

我们在main()函数中开始。

main.cpp

int ACE_TMAIN (int argc, ACE_TCHAR *argv[])

{

       ACE_STATIC_SVC_REGISTER (MyStaticObj-Discriptor);

       ACE_Service_Config::open

              (argc, argv, ACE_DEFAULT_LOGGER_KEY, 0);

       ACE_Reactor::instance ()->run_reactor_event_loop ();

       return 0;

}

       ACE_STATIC_SVC_REGISTER (MyStaticObj-Discriptor);

这个宏是为了获得最好的移植性而调用的，在有的平台上不需要。但是建议使用它。ACE会视情况把它处理成一些有效操作或者空操作。

ACE_Service_Config类

open()：配置服务必须调用。在默认情况下，open()会尝试处理当前目录下的名为svc.conf的文件，读取其中的指令进行操作。第四个参数ignore_static_svcs默认定义为1。如果配置了静态服务，则需要把0传递过去。

配置文件svc.conf

如果现在编译运行这个程序，由于没有配置文件，程序将不会激活我们已经定义的静态服务。要激活这个服务，需要编辑配置文件。默认的文件是svc.conf。编辑内容（如下）之后，再运行就可以发现服务已经激活、挂起、恢复、移除了。

static MyStaticObj ""

suspend MyStaticObj

resume MyStaticObj

remove MyStaticObj

可以写入以下格式的命令对程序进行控制：

初始化静态服务：static svc-name [ “argc/argv options” ]：

svc-name为我们为静态服务配置的服务名称，后面跟随着argc/argv风格的参数。

动态链接和初始化服务：dynamic svc-name svc-type DLL-name:factory_func() [ “argc/argv options”]

svc-name为服务名称

svc-type指定服务的类型，可以是Service_Object*、Module*或者是Stream*。

DLL-name是含有factory_fun()符号的动态链接库的名称。

factory_func()是一个创建svc-type的对象的工厂方法。

完全移除服务：remove svc-name

挂起服务：suspend svc-name

恢复先前挂起的服务：resume svc-name

初始化一系列有序的层次相关的模块：stream svc-name ‘{‘module-list’};

配置动态服务

ACE Service Configurator框架更强大的功能表现在配置动态服务上。如果在运行时收到指示，动态服务器可以从共享库（DLL）中动态加载。这种能力允许你在运行时替换服务，从而提供极大的灵活性。

ACE Service Configurator框架简化了全部的冗余工作。我们只需要按照设计规格实现我们需要的服务，把它载入到一个动态链接库中，编辑配置文件即可。换句话说：我们只需要创建一个合乎规格的动态链接库，然后在上例的svc.conf里面添加一两行指令，再次运行该程序即可加载此动态服务，我们甚至不需要对该程序进行重新编译。

动态链接库Mydll

确定我们将要设计的动态链接库名字为Mydll

运行$ACE_ROOT/bin/generate_export_file.pl Mydll,将输出写入Mydll_Export.h中去。

设计我们的服务的类，在类的源文件中包含该文件，并将关键字

＃i nclude “Mydll_Export.h”

class  Mydll_Export MyDynamicObj : public ACE_Service_Object 

{

public:

       MyDynamicObj();

       virtual ~MyDynamicObj();

       virtual int init (int argc, ACE_TCHAR *argv[])

       {

              printf("MyDynamicObj::init------\n");

              return 0;

       }

       virtual int fini()

       {

              printf("MyDynamicObj::fini-----\n");

              return 0;

       }

};

ACE_FACTORY_DEFINE(Mydll,MyDynamicObj)

编译，并在svc.conf里面加入如下指令，再运行，发现动态服务已被加载、移除。

dynamic MyDynamicObj Service_Object* Mydll:_make_MyDynamicObj() ""

remove MyDynamicObj

ACE Streams框架是ACE提供的“流”概念解决方案，实现了Pipes and Filters(管道与过滤器)模式。对于由一组有序步骤组成的过程而言，这个框架是一种极好的建模方式。过程中的每个步骤都被实现成ACE_Task的派生类。当每个步骤完成时，数据会通过ACE_Task对象的消息队列，交给下一个步骤继续进行处理。如果数据能进行并行处理，则各个步骤可以是多线程的，从而增加吞吐量。

ACE Streams框架允许你把一组模块灵活地装配进一个流中，并且可以对其进行动态配置：信息将在这个流中移动。每个模块都有机会操纵流中的数据，并可以在把数据传给下一个模块之前对其进行修改、移动或增加内容。数据在流中双向流动，，流中的每个模块都有reader和writer任务――每个数据方向上有一个。

流的工作方式包括“顺流”（down-stream）和“溯流”(up-stream)两种。当顺流任务向下游移动时，你可以认为它们是在移出你的主应用。溯流任务则正好相反。

ACE Stream模式要求将流动于流中的数据装入ACE_Message_Block ，这样就能够使用ACE所设计的ACE_Message_Block和ACE_Message_Queue这样的高效设施。

二、工作方式

使用ACE_Stream处理流式事件重点使用三个类：ACE_Task的子类用于处理各个分离的业务，ACE_Module将这些处理方法包装成模块，置入ACE_Stream（或其子类）中。可以认为：ACE_Stream代表了整个地“流”，而ACE_Task则是流的各个段落， ACE_Module则用于做接合工作。因此，一个程序中会有一个ACE_Stream、多个ACE_Module以及与之等量的ACE_Task（或者它们的子类），而每个ACE_Task可以派生多个进程来处理它任内的事务，只要它需要而且愿意这么做。一看到多线程就免不了要考虑令人头痛的并发控制，但是不用担心，ACE的信号机制已经完全承接了这些痛苦，我们要做的，仅仅是选择一下用哪一种方式而已。

一般都使用如下的一些模板类

typedef ACE_Stream<ACE_MT_SYNCH> MT_Stream;

typedef ACE_Module<ACE_MT_SYNCH> MT_Module;

typedef ACE_Task<ACE_MT_SYNCH> MT_Task;

为了方便说明，下面统一用Stream来表述ACE_Stream或者是自定义的派生自它的类。与此类似，Module、Task也具有同样的意义。

工作流程如下：

1、  创建一系列的Task实例，开启多个线程等待处理事务。

2、  将这些Task“装”入Module

3、  将这些Module依序压入Stream

4、  把要处理的数据以ACE_Message_Block的形式置入队列。刚才派生出来的多线程会依次处理它们

5、  工作完成，移出各个模块，关闭各个线程。

三、示例

下面，我们通过一个示例来看一下ACE Streams的使用方法。这个示例选自《The ACE Programmer’s Guide》p312.为了简化，我把操作进行了改写。

示例的总体思路是：把一个已经接受了连接的ACE_SOCK_Stream传给流，流中的模块依次接收数据、解析数据、获取连接对端方的地址名、进行应答，并把解析好的数据返还给上层。我们把前面一部分的任务配置成顺流任务，而把后面的返还过程配置成溯流任务，由此实现一个完整的双向流。

示例中，CommandStream维护整个的流，这个流由四个Module构成：RecordMessageModule, PlayMessageModule, RetrieveCallerIDModule, AnswerCallModule,每个Module维护两个Task：一个顺流方向的writer端Task（*DownstreamTask）,和一个溯流方向的reader端Task(*UpstreamTask).

四、实现

Command

这个类是我们返还给上层的数据结构的载体。之所以将它设计成一个类，是为了利用ACE_Message_Block的自动析构功能。在更健壮地应用中，我们可以进一步创建它的派生对象，而非像这里这样：将成员变量设置成为public属性

class Command : public ACE_Data_Block 

{

public:

       enum {

              PASS      = 1,

                     SUCCESS      = 0,

                     FAILURE = -1

       };

       enum {

              UNKNOWN                        = -1,

              ANSWER_CALL                  = 10,

              RETRIEVE_CALLER_ID      = 8,

              PLAY_MESSAGE             = 4,

              RECORD_MESSAGE           = 2

       }commands;

       int flags_;

       int command_;

       char *extra_data_;

       int numeric_result_;

       char name[MAXHOSTNAMELEN];

       char cmd[16];

       char param[16];

       Command()

       {

              extra_data_ = NULL;

              memset(name,0,MAXHOSTNAMELEN);

              memset(cmd,0,16);

              memset(param,0,16);

       }

};

CommandTask族

CommandTask派生自ACE_Task<ACE_MT_SYNCH>，构成示例中全部Task类的基类。用于实现各个任务的默认处理方式。

声明

class CommandTask : public ACE_Task<ACE_MT_SYNCH> 

{

public:

       typedef ACE_Task<ACE_MT_SYNCH> inherited;

       virtual int open(void * = 0);

       int put(ACE_Message_Block *message,ACE_Time_Value *timeout);

       virtual int svc(void);

       virtual int close(u_long flags);

protected:

       int command_;

       CommandTask(int command);

       virtual int process(Command *message);

};

工作方式：可以实现为两种工作方式：

如果本任务接收到数据之后直接处理数据，只需在int put()里面添加代码即可，因为这个函数将会在传递数据给本任务时被调用。

如果我们需要使用主动对象模式的子线程来处理数据，则可以在int open()方法里面开启多线程，子线程将运行int svc()里面的代码。int put()方法将数据交给已经被ACE置入的ACE_Message_Queue，之后各个子线程即可从其中取中数据进行处理。在关闭时，要注意协调与各个子线程的退出。

实现：我们演示后一种工作方式

CommandTask::CommandTask(int command)

:inherited(),command_(command)

{

}

int CommandTask::open(void *)

{

       return this->activate();

}

int CommandTask::put(ACE_Message_Block *message, ACE_Time_Value *timeout)

{

       return this->putq(message,timeout);

}

int CommandTask::svc()

{

       ACE_Message_Block *message;

       for(;;){

              if( -1 == this->getq(message) )

                     return -1;

              if(message->msg_type() == ACE_Message_Block::MB_HANGUP ){

                     ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t)%s thread close\n"),this->module()->name()));

                     this->putq(message->duplicate());

                     message->release();

                     return 0;

              }

              Command *command = (Command*)message->data_block();

              if( command->command_ != this->command_ )

                     this->put_next(message->duplicate());

              else {

                     int result = this->process(command);

          //处理失败？丢弃

                     if( result == Command::FAILURE )

                            command->numeric_result_ = -1;

           //处理后需要下一个模块任务处理？

                     else if( result == Command::PASS){

                            this->put_next(message->duplicate());

                     }

          //处理完成？

                     else {

              //在顺流方向？转向溯流方向

                            if(this->is_writer())

                                  this->sibling()->putq(message->duplicate());

                            else

                                   this->put_next(message->duplicate());

                     }

              }

              message->release();

       }

       return 0;

}

int CommandTask::close(u_long flags)

VC下的安装

１．解压后放在D盘（或者自定义也可）

D:\ACE_wrappers

２．在D:\ACE_wrappers\ace目录下新建文件config.h加入一行
    ＃i nclude "ace/config-win32.h"

３．编译：用VC6.0打开D:\ACE_wrappers\ace\ace.dsw
    左侧显示    ACE DLL classes
               ACE LIB classes
    或1、从菜单上选择“编译”，“放置可远行配置”，选择你需要的工程配置
        “编译”，“重建全部”（或任一，如ACE DLL - Win32 MFC Debug）
        此过程可能持续半小时至一个小时不等
    或2、从菜单上选择“编译”，“批构建”，选择你需要的工程配置
        此过程可能持续二至四个钟头
       
    产生的.lib文件位于D:\ACE_wrappers\ace\下，
    产生的.dll文件位于D:\ACE_wrappers\bin\下

4．为系统变量PATH加上D:\ACE_wrappers\bin
   

VC下的ACE使用

１．建立工程

２．修改配置

project-->settings…-->C/C++ àCategory:Code Generation àUse run-time library设置为“Debug Multithreaded DLL”

project-->settings…-->C/C++ àCategory:Preprocessor àAdditional include directories中添加D:\ACE_wrappers

project-->settings…àLink àCategory:Input àObject/library modules:中添加aced.lib,并在下面的Additional library path里面添加路径D:\ACE_wrappers\ace

３．新建文件编辑代码

４．编译运行

５．若不能编译release版本，需在工程首处定义宏 _WIN32_WINNT为0x0400

Linux下的安装

１   先设置ACE_ROOT环境，命令： 

   “vi /etc/profile”

   在其中加入4行 

   ACE_ROOT=/opt/ACE

   export ACE_ROOT

   LD_LIBRARY_PATH=$ACE_ROOT/ace:$LD_LIBRARY_PATH

   export LD_LIBRARY_PATH

可以加在“export PATH USER….”后的。完成后将/etc/profile执行一次，命令： 

         “/etc/profile”

这样我们的ACE_ROOT就设置好了，可以用如下命令查看ACE_ROOT是否设置好了： 

                  “echo $ACE_ROOT”

这个时候最好reboot启动一次linux。

２．假设安装文件的位置如下：/home/my/ACE/ACE-5.4+TAO-1.4+CIAO-0.4.tar.gz

从其中解压出单个文件ACE-install.sh：

 “tar –zxvf ACE-5.4+TAO-1.4+CIAO-0.4.tar.gz ACE_wrappers/ACE-install.sh”

解好后，会出来一个新的子目录“ACE_wrappers”。修改其中的ACE-install.sh文件的如下选项：

(1)        先找到“MY_ACEDIR=${HOME}/aceconfig”，将其改成“MY_ACEDIR=/home/my/ACE”，就是改成我们自己建的、放有ACE-5.4+TAO-1.4+CIAO-0.4.tar.gz文件的目录，之后去掉前面的注释“#”号。

(2)        找到“MY_ACE_CONFIG=config-sunos5.4-sunc++-4.x.h”，将其修改成“MY_ACE_CONFIG=config-linux.h”。

(3)        找到“MY_ACE_GNU_MACROS=platform_sunos5_sunc++.GNU”，将其改成“MY_ACE_GNU_MACROS=platform_linux.GNU”。

  保存。

３．运行该文件

./ACE-install.sh

４．将$ACE_ROOT/ace下面的libACE.so.5.4.0拷贝到/lib/目录下。

５．上述编译方法得到的为debug版本，若需获得release版本的，可在$ACE_ROOT/ace目录下重新make,命令：“#make debug=0”.

Linux下ACE的使用

　　Linux下的ACE项目往往需要使用makefile,相关问题参考书上教程或者示例的Makefile文件。也可以使用MW和CMPC工具生成，在此不再累述。

高手当然不用愁了：多看看资料了解一下什么VxWorks、Solaris下的API函数几下就搞定了。对于咱们这种手没有那么高的一般人，对还远远没有达到草木竹石均可为剑境界的凡人来说，难道非要熬上N个通宵再加上N的N次方的调试？

非也！

牛顿告诉我们：若能站在巨人的肩上，岂不是能做得更好？我国古人则说：工欲善其事，必先利其器。

如果能够觅得传说中的巨人，寻到那传说中的利器，一切还不迎刃而解？

就在这个伟大的时刻，ACE横空出世！

ACE的全名是ADAPTIVE Communication Environment，是一组可以自由使用的（免费？）、开放源码的面向对象（OO）的构架。使用它可以藐视各个平台间的差异，大大地简化网络编程，减少出错的机会，而且更可以――打住！且先把这茬儿说清楚。

ACE对各个操作系统的接口函数API进行封装，并且用统一的接口形式提供给程序员。换句话说，你只需要简单地调用ACE提供的函数形式（这些形式和常见的系统API非常相像），ACE就会自动地把它转换成你所在的平台上的函数：VxWorks的，或者Solaris，当然更不用说大名鼎鼎的WINDOWS和Linux了。实现方式么，用脚指头都能想出来：使用了非常多的条件编译，把不同系统上的功能相似的API函数统一起来，如果没有则模拟实现，如果有则简单地inline就可以了，还可以不折损效率。此其一也！

想不到还有其二吧？ACE将面向对象的思想运用到这些函数里面，对网络编程等部分的功能进行改造，建立起面向对象的模型。比如，ACE将连接的一方处理成为一个对象，将一个连接处理成为一个对象，先前的操作则被封装成为对象的功能。切不可小觑这一点。要知道，这样就可以运用面向对象的思想来构建应用，而且OO的类型保护机制可以把一大批错误从运行时提前到编译阶段。当然，如果有谁特别有个性，特别喜欢用那种C语言的函数方式的，ACE也提供有那样的形式的函数来满足这种不一般的胃口。

光说不练是没有用的，且让我用一个小例子来镇一镇那些不服的眼睛。（限于篇幅，我只在这里列出最核心的代码：

int main(int, char *[])

{

       ACE_INET_Addr port_to_listen (9999);

       ACE_SOCK_Acceptor acceptor;

       acceptor.open (port_to_listen, 1);

       while (1)

    {

              ACE_SOCK_Stream peer;

              ACE_INET_Addr peer_addr;

              ACE_Time_Value timeout (10, 0);

              if( 0 == acceptor.accept (peer, &peer_addr, &timeout, 0))

              {

                     char buffer[4096];

                     ssize_t bytes_received;

                     while ((bytes_received = peer.recv (buffer, sizeof(buffer))) != -1)

                     {

                            peer.send_n (buffer, bytes_received);

                     }

                     peer.close ();

        }

    }

       return 0;

}

寥寥数行代码，就已经实现了一个完整的服务器：它在9999端口上开始侦听，接受一个TCP连接，把它发过来的数据返还回去。如果业务完成，则断开连接，接受下个连接，开始下一个循环。只要给这段代码包含进需要的头文件，加上几句错误处理，放到ACE的编译环境下――无论是WINDOWS, Linux的，还是UNIX的――都可以编译运行。

如果ACE的功能仅限于此，可能还不足以支持它取得如此大的成就：ACE在西方的应用已经遍及电信、航空、保险、军事、天文、游戏等众多的领域。事实上，上面所说的功能仅仅占据了ACE代码的10％左右。剩下的部分，ACE实现了更为了不起的功能。

ACE融合通讯领域的各个优秀的模式，利用它已经建立起来的可移植到多平台的OS层函数（就是上面所说的那一部分），建立起一个个精巧的框架。这些模式都是作者等众多的工程师在实践中积累起来的优秀经验。实际上，利益于开源的思想，现在全世界有一千七百多位工作者和数百人的核心团队进行ACE的进一步开发。可以这么说，使用ACE，你不是站在一位巨人的肩膀上，而是站在全世界一千七百多人的肩膀上。由此你只需对现有框架进行扩展，大大缩短开发的过程，并且极大地提高程序对硬件的使用效率――而这是已经被证明的。

ACE主要提供以下几种框架供网络程序的开发：

l      事件多路分离组件：ACE Reactor(反应堆)和Proactor（前摄器）是可扩展的面向对象多路分离器，它们分派应用特有的处理器，以响应多种类型的基于I/O、定时器、信号和同步的事件。

l      服务初始化组件：ACE Acceptor（接受器）和Connector（连接器）组件分别使主动和被动的初始化任务与初始化一旦完成后通信服务所执行的应用特有的任务去耦合。

l       进程和线程管理：提供多进程和多线程的派生和管理方法，消除了平台的差异性。

l         服务配置组件：ACE Service Configurator（服务配置器）支持应用的配置，这些应用的服务可在安装时和/或运行时动态装配。

l      分层的流组件：ACE Stream组件简化了像用户级协议栈这样的由分层服务组成的通信软件应用的开发。

l      命名服务：ACE NamingService提供了单进程命名上下文、同一节点共享命名上下文和在网络上命名上下文的服务设施。 

除此以外，ACE还提供了信号、线程安全与同步、内存管理等等多种丰富的功能。ACE已经成长成为一个完善的系统，在网络编程方面，能够提供非常丰富的服务。

ACE会因此而满足吗？当然不，那样它只能逐渐被淘汰。当前ACE正在完善它的高级分布式计算中间件组件，并且制定了多个项目计划进一步扩充和发展ACE的功能。所以，使用ACE不用担心所学的知识会因时间而贬值，而事实上正好与此相反。

利剑在手，当然要学会怎么运用才能发挥它的最大功用了。ACE的创建者为我们写好了三本教材，一套两卷的《C++网络编程》和一本《ACE程序员指南》，都有中译本发行。此外，网上有大量的资料可供查询。如果对ACE的设计感兴趣，那再简单不过了：你可以阅读它的全部的源代码：ACE是完全开源的！

Graphics 类表示封装 GDI+ 绘图面,比如画长方形,圆形等更加复杂的图形.

常用属性和方法:

属性 说明
Clip 获取或设置Region对象，该对象限定此Graphics对象的绘图区域。
ClipBounds 获取RectangleF结构，该结构限定此Graphics对象的剪辑区域。
DpiX 获取此Graphics对象的水平分辨率。
DpiY 获取此Graphics对象的垂直分辨率。
PageScale 获取或设置此Graphics对象的全局单位和页单位之间的比例。
PageUnit 获取或设置用于此Graphics对象中的页坐标的度量单位。
PixelOffsetMode 获取或设置一个值，该值指定在呈现此Graphics对象的过程中像素如何偏移。
RenderingOrigin 为抵色处理和阴影画笔获取或设置此Graphics对象的呈现原点。
SmoothingMode 获取或设置此Graphics对象的呈现质量。
TextRenderingHint 获取或设置与此Graphics对象关联的文本的呈现模式。
Transform 获取或设置此Graphics对象的全局变换。
VisibleClipBounds 获取或设置此Graphics对象的可见剪辑区域的边框。

方法 说明
Clear 清除整个绘图面并以指定背景色填充。
Dispose 释放由此Graphics对象使用的所有资源。
DrawArc 绘制一段弧线，它表示由一对坐标、宽度和高度指定的椭圆部分。
DrawEllipse 绘制一个由边框定义的椭圆。
DrawIcon 在指定坐标处绘制由指定的Icon对象表示的图像。
DrawIconUnstretched 绘制指定的Icon对象表示的图像，而不缩放该图像。
DrawImage 在指定位置并且按原始大小绘制指定的Image对象。
DrawImageUnscaled 在坐标对所指定的位置并且按其原始大小绘制指定的Image对象。
DrawLine 绘制一条连接由坐标对指定的两个点的线条。
DrawLines 绘制一系列连接一组Point结构的线段。
DrawPie 绘制一个扇形，该扇形由一个坐标对、宽度和高度以及两条射线所指定的椭圆定义。
DrawPolygon 绘制由一组Point结构定义的多边形。
DrawRectangle 绘制由坐标对、宽度和高度指定的矩形。
DrawRectangles 绘制一系列由Rectangle结构指定的矩形。
DrawString 在指定位置并且用指定的Brush和Font对象绘制指定的文本字符串。
FillClosedCurve 填充由Point结构数组定义的闭合基数样条曲线的内部。
FillEllipse 填充边框所定义的椭圆的内部，该边框由一对坐标、一个宽度和一个高度指定。
FillPie 填充由一对坐标、一个宽度、一个高度以及两条射线指定的椭圆所定义的扇形区的内部。
FillPolygon
填充Point结构指定的点数组所定义的多边形的内部。
FillRectangle 填充由一对坐标、一个宽度和一个高度指定的矩形的内部。
FillRectangles 填充由Rectangle结构指定的一系列矩形的内部。
FillRegion 填充Region 对象的内部。
Flush 强制执行所有挂起的图形操作并立即返回而不等待操作完成。
FromHdc 从设备上下文的指定句柄创建新的Graphics对象。
FromHwnd 从窗口的指定句柄创建新的Graphics对象。
FromImage 从指定的Image对象创建新Graphics对象。
GetHdc 获取与此Graphics对象关联的设备上下文的句柄。
ReleaseHdc 释放通过以前对此Graphics对象GetHdc方法的调用获得的设备上下文句柄。
ResetClip 将此Graphics对象的剪辑区域重置为无限区域。
ResetTransform 将此Graphics对象的全局变换矩阵重置为单位矩阵。

　　　　　　　　　　　
画一个矩形
DrawRectangle 绘制由坐标对、宽度和高度指定的矩形

public void DrawRectangle(Pen, int, int, int, int);

绘制由坐标对、宽度和高度指定的矩形

使用颜色

Color 结构表示 ARGB 颜色

颜色包含a,R,G,B

Color mycolor;
mycolor = Color.FromName("blue");
//FromName方法把颜色字符串换成GDI+颜色
mycolor = Color.FromArgb(255, 0, 0);
//FromArgb方法设置RGB值
mycolor = Color.FromArgb(100,255, 0, 0);
//FromArgb方法设置a,RGB值

用ColorTranslator类在HTML颜色和GDI+颜色之间转换
mycolor = ColorTranslator.FromHtml("#00FF00");

使用画笔

Brush 类用于填充图形形状（如矩形、椭圆形、扇形、多边形和封闭路径）内部的对象

System.Drawing.Drawing2D.HatchBrush 用阴影样式、前景色和背景色定义矩形画笔
System.Drawing.Drawing2D.LinearGradientBrush 使用线性渐变封装 Brush 对象
System.Drawing.Drawing2D.PathGradientBrush 封装 Brush 对象，它通过渐变填充 GraphicsPath 对象的内部
System.Drawing.SolidBrush 定义单色画刷
System.Drawing.TextureBrush 使用图像来填充形状的内部