在线观看亚洲,欧美私人啪啪vps,亚洲国产精品一区二区第一页

linux RPC ��试�Q��{载）

周强 — Sun, 07 Aug 2011 08:44:00 GMT

转自:

http://www.justwinit.cn/post/3960/

RPC是glibc提供的函数参�?�q�回值封装服�? �q�将��装�l�果通过�|�络传到服务�?
RPC服务端首先要启动portmapper服务.
��试一个简单的RPC传输�C�Z��, 先定义一个模板文件test.x

program TESTPROG{
        version VERSION{
                int int_echo(int)=1;
                int get_str_len(string)=2;
                int add ( int, int ) = 3;
        }=1;
}=30000;

内含3个函�? 注意其中一个有2个参�?
然后可以用rpcgen生成一个Makefile:

rpcgen -a -N test.x

�q�会生成Makefile, 客户端和服务端的�E�序, 和函数示�?
我们手工修改一下Makefile

# This is a template Makefile generated by rpcgen
# Parameters
CLIENT = test_client
SERVER = test_server
SOURCES_CLNT.c =
SOURCES_CLNT.h =
SOURCES_SVC.c =
SOURCES_SVC.h =
SOURCES.x = test.x
TARGETS_SVC.c = test_svc.c test_server.c test_xdr.c
TARGETS_CLNT.c = test_clnt.c test_client.c test_xdr.c
TARGETS = test.h test_xdr.c test_clnt.c test_svc.c
OBJECTS_CLNT = $(SOURCES_CLNT.c:%.c=%.o) $(TARGETS_CLNT.c:%.c=%.o)
OBJECTS_SVC = $(SOURCES_SVC.c:%.c=%.o) $(TARGETS_SVC.c:%.c=%.o)
# Compiler flags
CFLAGS += -g -pipe
LDLIBS += -lnsl
RPCGENFLAGS = -N
# Targets
all : $(CLIENT) $(SERVER)
$(TARGETS) : $(SOURCES.x)
        rpcgen $(RPCGENFLAGS) $(SOURCES.x)
$(OBJECTS_CLNT) : $(SOURCES_CLNT.c) $(SOURCES_CLNT.h) $(TARGETS_CLNT.c)
$(OBJECTS_SVC) : $(SOURCES_SVC.c) $(SOURCES_SVC.h) $(TARGETS_SVC.c)
$(CLIENT) : $(OBJECTS_CLNT)
        $(LINK.c) -o $(CLIENT) $(OBJECTS_CLNT) $(LDLIBS)
$(SERVER) : $(OBJECTS_SVC)
        $(LINK.c) -o $(SERVER) $(OBJECTS_SVC) $(LDLIBS)
clean:
         $(RM) core $(TARGETS) $(OBJECTS_CLNT) $(OBJECTS_SVC) $(CLIENT) $(SERVER)

修改test_server.c服务端的处理函数, 提供3�U�服�?

/*
* This is sample code generated by rpcgen.
* These are only templates and you can use them
* as a guideline for developing your own functions.
*/
#include "test.h"
int *
int_echo_1_svc(int arg1,  struct svc_req *rqstp)
{
        static int  result;
        //echo.
        result=arg1;
        printf("[RPC1] source=%d, echo=%d\n", arg1, result);
        return &result;
}
int *
get_str_len_1_svc(char *arg1,  struct svc_req *rqstp)
{
        static int  result;
        //get strlen.
        result=strlen(arg1);
        printf("[PRC2] str=%s, len=%d\n", arg1, result);
        return &result;
}
int *
add_1_svc(int arg1, int arg2,  struct svc_req *rqstp)
{
        static int  result;
        result=arg1+arg2;
        printf("[RPC3] %d+%d=%d\n", arg1, arg2, result);
        return &result;
}

客户端test_client.c, 调用�q�三�U�服�?

/*
* This is sample code generated by rpcgen.
* These are only templates and you can use them
* as a guideline for developing your own functions.
*/
#include "test.h"
void
testprog_1(char *host)
{
        CLIENT *clnt;
        int  *result_1;
        int int_echo_1_arg1=55;
        int  *result_2;
        char *get_str_len_1_arg1="Hello, world";
        int  *result_3;
        int add_1_arg1=10;
        int add_1_arg2=20;
        clnt = clnt_create (host, TESTPROG, VERSION, "udp");
        if (clnt == NULL) {
                clnt_pcreateerror (host);
                exit (1);
        }
        result_1 = int_echo_1(int_echo_1_arg1, clnt);
        if (result_1 == (int *) NULL) {
                clnt_perror (clnt, "call failed");
        }
        else
                printf("[PRC1] echo %d, source %d\n", *result_1,
                        int_echo_1_arg1);
        result_2 = get_str_len_1(get_str_len_1_arg1, clnt);
        if (result_2 == (int *) NULL) {
                clnt_perror (clnt, "call failed");
        }
        else
                printf("[RPC2] return %d, should %d\n", *result_2,
                        strlen(get_str_len_1_arg1));
        result_3 = add_1(add_1_arg1, add_1_arg2, clnt);
        if (result_3 == (int *) NULL) {
                clnt_perror (clnt, "call failed");
        }
        else
                printf("[PRC3] %d+%d=%d\n", add_1_arg1, add_1_arg2,
                        *result_3);
        clnt_destroy (clnt);
}

OK, 可以调用make�?
生成可执行程序test_server和test_client.
我们启动./test_server, 用rpcinfo看看:

$rpcinfo -p 127.0.0.1
program vers proto port
100000 2 tcp 111 portmapper
30000 1 udp 36307
30000 1 tcp 34883
Bingo! 启动成功.

再开个终�? ��试一下调�?

./test_client 127.0.0.1
[PRC1] echo 55, source 55
[RPC2] return 12, should 12
[PRC3] 10+20=30

正是我们期望�?

Add By�Q�Jackxiang

make -f Makefile.test

周强 2011-08-07 16:44 发表评论

周强 — Mon, 04 Apr 2011 11:38:00 GMT

参�?nbsp; unix�|�络�~�程
客户/服务器程序设计范式有
�Q?�Q��P代服务器�Q�无�q�程控制)
�Q?�Q��ƈ发服务器�Q�每个客戯��求fork 一个子�q�程
�Q?�Q�预先派生子�q�程�Q�每个子�q�程无保护地调用accept
�Q?�Q�预先派生子�q�程�Q��用文件上锁保护accept
�Q?�Q�预先派生子�q�程�Q��用线�E�互斥锁保护accept�Q�共享内�?
�Q?�Q�预先派生子�q�程�Q�父�q�程向子�q�程传递套接口描述�?br>�Q?�Q��ƈ发服务器�Q�每个客戯��求创��Z��个线�E?br>�Q?�Q�预先创建线�E�服务器�Q��用互斥锁上锁保护accept
�Q?�Q�预先创建线�E�服务器�Q�由�ȝ��E�调用accept.

��试用例客户创徏5个进�E�，每个发�v500个连接，每个�q�接写四个字节数�?br>                          �ȝ��用户旉��Q�秒�Q?               �ȝ��pȝ��旉��Q�秒�Q?br>�Q?�Q?                     0.012                                   0.16001
�Q?�Q?    0.008 0.256016
�Q?�Q?    0.016 0.268016
�Q?�Q?    0.020001 0.380023
�Q?�Q?    0.012 0.308019
�Q?�Q?    0.068003 0.464029
�Q?�Q?    0.024001 0.224014
�Q?�Q?    0.012 0.280017
�Q?�Q?    0.0160001 0.268016

周强 2011-04-04 19:38 发表评论

周强 — Tue, 15 Mar 2011 13:57:00 GMT

Linux 下飞鸽传书设计实�?span lang="EN-US">

1.�pȝ��功能

�Ҏ��飞鸽传书协议�?span lang="EN-US"> linux 下实现飞鸽传输程�?span lang="EN-US">,�q�且�?span lang="EN-US"> windows 下飞鸽兼宏V��具体功能模块包括用户上�U?span lang="EN-US">,下线,��h��查看在线用户,收发消息,传送文�?span lang="EN-US">/文�g夹功能模块�?span lang="EN-US">

2.具体实现

2.1 关键数据�l�构

/*命��o的结�?span lang="EN-US">*/

typedef struct _command

{

int version;/*命��o的版�?span lang="EN-US">*/

int seq;/*包编�?span lang="EN-US">*/

char srcName[100];/*发送者姓�?span lang="EN-US">*/

char srcHost[100];/*发送者主机名*/

int flag;/*命��o*/

char addtion[100];/*附加字段*/

}command;

/*在线用户信息*/

typedef struct _userInfo

{

char name[MAXLINE]; /*姓名*/

char host[MAXLINE]; /*��L��?span lang="EN-US">*/

char group[MAXLINE]; /*所在的�l�名*/

struct sockaddr_in addr; /*地址信息*/

struct _userInfo next; /*链表中下一�?span lang="EN-US">*/

}userInfo;

/*在线用户列表*/

typedef struct _uList

{

userInfo *userListHead; /*链表�?span lang="EN-US">*/

userInfo userListTail; /*链表��?span lang="EN-US">*/

}uList;

/*消息队列*/

typedef struct _mesList

{

command *mesHead;

command *mesTail;

}mesList;

2.2 �E�序主要�l�构

本程序主要采用多�U�程�l�构,分�ؓ receive(接收消息), process(处理收到的消�?span lang="EN-US">), sendData(发送文�?span lang="EN-US">) 三个子线�E�。线�E�间通信互斥锁与 Posix 信号量进行通信�?span lang="EN-US">

2.3 函数接口

(1) /*从文件描�q�符fd中读�?span lang="EN-US">count个字�W�存�?span lang="EN-US">buf�?span lang="EN-US">*/

ssize_t readn(int fd,void *buf,size_t count)�Q?span lang="EN-US">

(2) /*��?span lang="EN-US">buf所指向的存储区中的len个字�W�吸入文件描�q�符fd�?span lang="EN-US">*/

ssize_t writen(int fd,char *buf,int len);

(3) /*用于字符串�{�?span lang="EN-US">,�|�络传输中用gb2312�~�码�Q?span lang="EN-US">linux�?span lang="EN-US">gtk�?span lang="EN-US">utf-8�~�码�Q�需要进行�{�?span lang="EN-US">*/

int code_convert(char *from_charset,char *to_charset,char *inbuf,int inlen,char *outbuf,int outlen);

(4) /*在用户链表中加入新用户信息，加入成功�q�回1�Q�否则返�?span lang="EN-US">0,使用userInfoMutex�q�行�U�程间通信控制*/

int pushBack(uList *list,userInfo user);

(5) /*在用户链表中删除指定地址信息的用��P��删除成功后返�?span lang="EN-US">1�Q�否则返�?span lang="EN-US">0�Q��?span lang="EN-US">userInfoMutex�q�行�U�程间控�?span lang="EN-US">*/

int delUser(uList *list, struct sockaddr_in addr);

(6) /*判断该用��h��否已�l�存在，已经存在则返�?span lang="EN-US">1�Q�否则返�?span lang="EN-US">0,使用userInfoMutex�q�行�U�程间控�?span lang="EN-US">*/

int isExist(uList *list,struct sockaddr_in addr);

(7)清空用户链表�Q�释攄��_��用于用户退出和用户��h��旉��攄��?span lang="EN-US">,使用userInfoMutex�q�行�U�程间控�?span lang="EN-US">*/

int destroyList(uList *list);

(8)/*创徏命��o�?span lang="EN-US">,com��q�回的命令字,flag 为消息标�?span lang="EN-US">,addtion 为附加标�?span lang="EN-US">*/

void createCmd(command & com,int flag,char addtion[])

(9)/*发送消息，com��发送的消息�Q?span lang="EN-US">servaddr��发送的地址�Q?span lang="EN-US">attach为文仉��件信�?span lang="EN-US">*/

void sendCmd(command com, struct sockaddr_in servaddr,char attach[]);

(10) /*把收到的消息加入到消息队列中*/

void addMes(mesList *mHead,command cmd);

(11) /*把消息队列中头部的节�Ҏ��息提取出来用于处�?span lang="EN-US">*/

int delMes(mesList *mHead,command *cmd);

(12)/*初始化操作，飞鸽��d��时初始化消息链表�Q�用户链表，信号量，套接字信�?span lang="EN-US">*/

void init();

(13)/*��d��操作,发送用户上�U�消�?span lang="EN-US">*/

void login();

(14)/*解析收到的消息命令，提取各个字段*/

int analysisCmd(command *cmd,char *buf);

(15) /*接收消息�U�程处理函数,��收到的消息加入消息队列中，通过信号�?span lang="EN-US">waitNoFull�?span lang="EN-US">waitNoEmpty和消息处理线�E�进行通信。消息队列用mesMutex与其他线�E�进行通信�Q�保证消息队列的正确�?span lang="EN-US">*/

void *receive(void *arg);

(16)/*gtk界面中显�C�在�U�用户信�?span lang="EN-US">*/

void showUser(uList *list);

(17)/*�?span lang="EN-US">gtk界面中显�C�消�?span lang="EN-US">*/

void showMessage(char *message);

(18)/*昄��收到的信�?span lang="EN-US">*/

void showRecvMessage(char *host,char *message);

(19)/*分析文�g的信息，提取有用的字�D?span lang="EN-US">*/

void fileAnalysis(char *recv,int *fNum,char *fName,int *fSize,int *fTime,int *fType);

(20) /*保存收到的单个文�?span lang="EN-US">,saveName��Z��存的文�g�?span lang="EN-US">*/

void saveSignalFile(char *saveName);

(21)/*分析目录附�g�Q�获得目录文件的文�g名，文�g大小�Q�文件类�?span lang="EN-US">*/

void getDirInfo(char *recv,char *fName,int *fSize,int *fType);

(22) /*保存目录,saveName��保存的目�?span lang="EN-US">*/

void saveDir(char *saveName);

(23)/*保存文�g,recvType=1��Z��存文�Ӟ��recvType=2��Z��存的目录,使用fileMutex来设�|�互斥�?span lang="EN-US">*/

void saveFile();

(24)/*收到单个文�g*/

void receiveSignalFile(char *recvFileName);

(25)/*收到单个目录*/

void receiveDir(char *recvDirName);

(26)/*接收文�g*/

void receiveFile(command cmd);

(27)/*信号处理�U�程,从消息队列中取出消息�q�行处理*/

void *process(void *arg);

(28)/*发送消�?span lang="EN-US">*/

int sendMes();

(29) /*��文件名�q�行转换*/

char *transName(char *fileName);

(30)/*发送文�?span lang="EN-US">*/

void sendFile();

(31)/*发送文件夹*/

void sendDir();

(32)/*用户点击��h��,��h��在线用户*/

void refresh();

(33) /*用户退�?span lang="EN-US">*/

void quit();

(34)/*传输文�g�Ҏ��据，递归函数*/

void transferDir(int fd,char *dir);

(35)/*监听TCP套接口，发送文件与文�g夹线�E?span lang="EN-US">*/

void *sendData(void *arg);

(36)/*创徏菜单*/

static void create_popup_menu(GtkWidget *menu,GtkWidget *view);

(37)/*叛_��选中treeview,昄��传送文件与文�g夹菜�?span lang="EN-US">*/

static gboolean showTreeView(GtkWidget *eventBox,GdkEventButton *event,GtkWidget *menu);

(38)/*选择要发送的文�g */

static void selectFile();

(39)/*选择要发送的文�g�?span lang="EN-US">*/

static void selectDir();

(40)/*选择要保存的文�g名或文�g夹名*/

static void selectSaveFile();

3.�ȝ��

实现�?span lang="EN-US">linux下飞鸽传书的基本功能�Q��ƈ且能�?span lang="EN-US">window下飞鸽进行通信�Q�传文�g。熟悉了linux下网�l�编�E�，多线�E�编�E�及�U�程间通信�Q�主要用��C��号量与互斥锁�Q�。但加密解密那块没有完成�Q�程序结构不是很好，界面做得太差。有�I�应该看看设计模�?span lang="EN-US">.

界面截图�Q�界面比较垃�?�Q?/p>

附：

飞鸽协议�Q?http://bbs.chinaunix.net/viewthread.php?tid=1015775

周强 2011-03-15 21:57 发表评论

epoll模型�Q��{载）

周强 — Wed, 02 Mar 2011 04:23:00 GMT

epoll�_�N��

在linux的网�l�编�E�中�Q�很长的旉��都在使用select来做事�g触发。在linux新的内核中，有了一�U�替换它的机�Ӟ��是epoll�?br> 相比于select�Q�epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的�Q�轮询的fd数目��多�Q�自然耗时��多。�ƈ且，在linux/posix_types.h头文件有�q�样的声明：
#define __FD_SETSIZE    1024
表示select最多同时监�?024个fd�Q�当�Ӟ��可以通过修改头文件再重编译内核来扩大�q�个数目�Q�但�q�似乎�ƈ不治本�?br>
epoll的接口非常简单，一共就三个函数�Q?br> 1. int epoll_create(int size);
�? ��Z��个epoll的句柄，size用来告诉内核�q�个监听的数目一共有多大。这个参��C��同于select()中的�W�一个参敎ͼ��l�出最大监听的fd+1的倹{�? 需要注意的是，当创建好epoll句柄后，它就是会占用一个fd��|��在linux下如果查�?proc/�q�程id/fd/�Q�是能够看到�q�个fd的，所以在使用完epoll后，必须调用close()关闭�Q�否则可能导致fd被耗尽�?br>

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函敎ͼ�它不同与select()是在监听事�g时告诉内核要监听什么类型的事�g�Q�而是在这里先注册要监听的事�g�c�d��。第一个参数是epoll_create()的返回��|��W�二个参数表�C�动作，用三个宏来表�C�：
EPOLL_CTL_ADD�Q�注册新的fd到epfd中；
EPOLL_CTL_MOD�Q�修改已�l�注册的fd的监听事�Ӟ��
EPOLL_CTL_DEL�Q�从epfd中删除一个fd�Q?br> �W�三个参数是需要监听的fd�Q�第四个参数是告诉内栔R��要监听什么事�Q�struct epoll_event�l�构如下�Q?br> struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

events可以是以下几个宏的集合：
EPOLLIN �Q�表�C�对应的文�g描述�W�可以读�Q�包括对端SOCKET正常关闭�Q�；
EPOLLOUT�Q�表�C�对应的文�g描述�W�可以写�Q?br> EPOLLPRI�Q�表�C�对应的文�g描述�W�有紧急的数据可读�Q�这里应该表�C�有带外数据到来�Q�；
EPOLLERR�Q�表�C�对应的文�g描述�W�发生错误；
EPOLLHUP�Q�表�C�对应的文�g描述�W�被挂断�Q?br> EPOLLET�Q?��EPOLL设�ؓ边缘触发(Edge Triggered)模式�Q�这是相对于水��^触发(Level Triggered)来说的�?br> EPOLLONESHOT�Q�只监听一�ơ事�Ӟ��当监听完�q�次事�g之后�Q�如果还需要��l�监听这个socket的话�Q�需要再�ơ把�q�个socket加入到EPOLL队列�?br>

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
�{? 待事件的产生�Q�类��g��select()调用。参数events用来从内核得��C��件的集合�Q�maxevents告之内核�q�个events有多大，�q�个 maxevents的��g��能大于创建epoll_create()时的size�Q�参数timeout是超时时��_��毫秒�Q?会立卌��回，-1��不��定�Q�也�? 说法说是�怹��d��Q�。该函数�q�回需要处理的事�g数目�Q�如�q�回0表示已超时�?br>
--------------------------------------------------------------------------------------------

从man手册中，得到ET和LT的具体描�q�如�?br>
EPOLL事�g有两�U�模型：
Edge Triggered (ET)
Level Triggered (LT)

假如有这样一个例子：
1. 我们已经把一个用来从��道中读取数据的文�g句柄(RFD)��d��到epoll描述�W?br> 2. �q�个时候从��道的另一端被写入�?KB的数�?br> 3. 调用epoll_wait(2)�Q��ƈ且它会返回RFD�Q�说明它已经准备好读取操�?br> 4. 然后我们��d��?KB的数�?br> 5. 调用epoll_wait(2)......

Edge Triggered 工作模式�Q?br> �? 果我们在�W?步将RFD��d��到epoll描述�W�的时候��用了EPOLLET标志�Q�那么在�W?步调用epoll_wait(2)之后��有可能会挂��P��因�ؓ�? 余的数据�q�存在于文�g的输入缓冲区内，而且数据发出端还在等待一个针对已�l�发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时�?ET 工作模式才会汇报事�g。因此在�W?步的时候，调用者可能会攑ּ��{�待仍在存在于文件输入缓冲区内的剩余数据。在上面的例子中�Q�会有一个事件��生在RFD句柄上，因�ؓ在第2步执行了一个写操作�Q�然后，事�g��会在第3步被销毁。因为第4步的��d��操作没有�ȝ��文�g输入�~�冲区内的数据，因此我们在第5步调�? epoll_wait(2)完成后，是否挂�v是不��定的。epoll工作在ET模式的时候，必须使用非阻塞套接口�Q�以避免�׃��一个文件句柄的��d��?��d�� 写操作把处理多个文�g描述�W�的��d��饿死。最好以下面的方式调用ET模式的epoll接口�Q�在后面会介�l�避免可能的�~�陷�?br>    i    ��Z��非阻塞文件句�?br>    ii   只有当read(2)或者write(2)�q�回EAGAIN时才需要挂��P��{�待�?span style="font-weight: bold; color: #0001ff;">但这�q�不是说每次read()旉��需要��@环读�Q�直到读��C�生一个EAGAIN才认为此�ơ事件处理完成，当read()�q�回的读到的数据长度��于��h��的数据长度时�Q�就可以��定此时�~�冲中已没有数据了，也就可以认�ؓ此事��M��件已处理完成�?/span>

Level Triggered 工作模式
�? 反的�Q�以LT方式调用epoll接口的时候，它就相当于一个速度比较快的poll(2)�Q��ƈ且无论后面的数据是否被��用，因此他们��h��同样的职能。因为即使��用ET模式的epoll�Q�在收到多个chunk的数据的时候仍然会产生多个事�g。调用者可以设定EPOLLONESHOT标志�Q�在 epoll_wait(2)收到事�g后epoll会与事�g兌��的文件句柄从epoll描述�W�中��止掉。因此当EPOLLONESHOT讑֮�后，使用带有 EPOLL_CTL_MOD标志的epoll_ctl(2)处理文�g句柄��成��用者必��M��的事情�?br>

然后详细解释ET, LT:

LT(level triggered)是缺省的工作方式�Q��ƈ且同时支持block和no-block socket.在这�U�做法中�Q�内核告诉你一个文件描�q�符是否��q�A了，然后你可以对�q�个��q�A的fd�q�行IO操作。如果你不作��M��操作�Q�内核还是会�l�箋通知�? 的，所以，�q�种模式�~�程出错误可能性要��一炏V��传�l�的select/poll都是�q�种模型的代表．

ET(edge-triggered) 是高速工作方式，只支持no-block socket。在�q�种模式下，当描�q�符从未��q�A变�ؓ��q�A�Ӟ��内核通过epoll告诉你。然后它会假设你知道文�g描述�W�已�l�就�l�，�q�且不会再�ؓ那个文�g描述 �W�发送更多的��q�A通知�Q�直��C��做了某些操作��D��那个文�g描述�W�不再�ؓ��q�A状态了(比如�Q�你在发送，接收或者接收请求，或者发送接收的数据��于一定量时导�? 了一个EWOULDBLOCK 错误�Q�。但是请注意�Q�如果一直不对这个fd作IO操作(从而导致它再次变成未就�l?�Q�内�怸�会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark��认�Q�这句话不理解）�?/span>

�? 许多��试中我们会看到如果没有大量的idle -connection或者dead-connection�Q�epoll的效率�ƈ不会比select/poll高很多，但是当我们遇到大量的idle- connection(例如WAN环境中存在大量的慢速连�?�Q�就会发现epoll的效率大大高于select/poll。（未测试）

另外�Q�当使用epoll的ET模型来工作时�Q�当产生了一个EPOLLIN事�g后，
��L��据的时候需要考虑的是当recv()�q�回的大��如果等于请求的大小�Q�那么很有可能是�~�冲��有数据未��d��Q�也意味着该次事�g�q�没有处理完�Q�所以还需要再�ơ读�?/span> �Q?br> while(rs)
{
buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0);
if(buflen < 0)
{
    // �׃��是非��d��的模�?所以当errno为EAGAIN�?表示当前�~�冲区已无数据可�?br>     // 在这里就当作是该�ơ事件已处理�?
    if(errno == EAGAIN)
     break;
    else
     return;
   }
   else if(buflen == 0)
   {
     // �q�里表示对端的socket已正常关�?
   }
   if(buflen == sizeof(buf)
     rs = 1;   // 需要再�ơ读�?/span>
   else
     rs = 0;
}

�q? 有，假如发送端��量大于接收端的��量(意思是epoll所在的�E�序��L��转发的socket要快),�׃��是非��d��的socket,那么send()函数虽然 �q�回,但实际缓冲区的数据�ƈ未真正发�l�接收端,�q�样不断的读和发�Q�当�~�冲区满后会产生EAGAIN错误(参考man send),同时,不理会这�ơ请求发送的数据.所�?需要封装socket_send()的函数用来处理这�U�情�?该函��C��量��数据写完再�q�回�Q�返�? -1表示出错。在socket_send()内部,当写�~�冲已满(send()�q�回-1,且errno为EAGAIN),那么会等待后再重�?�q�种方式�q? 不很完美,在理��Z��可能会长旉��的阻塞在socket_send()内部,但暂没有更好的办�?

ssize_t socket_send(int sockfd, const char* buffer, size_t buflen)
{
ssize_t tmp;
size_t total = buflen;
const char *p = buffer;

while(1)
{
    tmp = send(sockfd, p, total, 0);
    if(tmp < 0)
    {
      // 当send收到信号�?可以�l�箋�?但这里返�?1.
      if(errno == EINTR)
        return -1;

      // 当socket是非��d��?如返回此错误,表示写缓冲队列已�?
      // 在这里做延时后再重试.
      if(errno == EAGAIN)
      {
        usleep(1000);
        continue;
      }

      return -1;
    }

    if((size_t)tmp == total)
      return buflen;

    total -= tmp;
    p += tmp;
}

return tmp;
}

周强 2011-03-02 12:23 发表评论

epoll模型实例�Q��{载）

周强 — Wed, 02 Mar 2011 04:22:00 GMT

epoll学习�W�记

epoll有两�U�模�?Edge Triggered(��U�ET) �?Level Triggered(��U�LT).在采用这两种模式时要注意的是,如果采用ET模式,那么仅当状态发生变化时才会通知,而采用LT模式�c�M��于原来的 select/poll操作,只要�q�有没有处理的事件就会一直通知.

以代码来说明问题:
首先�l�出server的代�?需要说明的是每�ơaccept的连�?加入可读集的时候采用的都是ET模式,而且接收�~�冲区是5字节�?也就是每�ơ只接收5字节的数�?

#include < iostream >
#include < sys / socket.h >
#include < sys / epoll.h >
#include < netinet / in.h >
#include < arpa / inet.h >
#include < fcntl.h >
#include < unistd.h >
#include < stdio.h >
#include < errno.h >

using namespace std;

#define MAXLINE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000

void setnonblocking( int sock)
{
     int opts;
    opts = fcntl(sock,F_GETFL);
     if (opts < 0 )
    {
        perror( " fcntl(sock,GETFL) " );
         exit ( 1 );
    }
    opts = opts|O_NONBLOCK;
     if (fcntl(sock,F_SETFL,opts) < 0 )
    {
        perror( " fcntl(sock,SETFL,opts) " );
         exit ( 1 );
    }
}

int main()
{
     int i, maxi, listenfd, connfd, sockfd,epfd,nfds;
    ssize_t n;
    char line[MAXLINE];
    socklen_t clilen;
     // 声明epoll_event�l�构体的变量,ev用于注册事�g,数组用于回传要处理的事�g
    struct epoll_event ev,events[ 20 ];
     // 生成用于处理accept的epoll专用的文件描�q�符
    epfd = epoll_create( 256 );
    struct sockaddr_in clientaddr;
    struct sockaddr_in serveraddr;
    listenfd = socket(AF_INET, SOCK_STREAM, 0 );
     // 把socket讄��为非��d��方式
     // setnonblocking(listenfd);
     // 讄��与要处理的事件相关的文�g描述�W?br>     ev.data.fd = listenfd;
     // 讄��要处理的事�g�c�d��
    ev.events = EPOLLIN|EPOLLET;
     // ev.events = EPOLLIN;
     // 注册epoll事�g
    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd, & ev);
    bzero( & serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char * local_addr = " 127.0.0.1 " ;
    inet_aton(local_addr, & (serveraddr.sin_addr)); // htons(SERV_PORT);
    serveraddr.sin_port = htons(SERV_PORT);
    bind(listenfd,(sockaddr * ) & serveraddr, sizeof(serveraddr));
    listen(listenfd, LISTENQ);
    maxi = 0 ;
     for ( ; ; ) {
         // �{�待epoll事�g的发�?br>         nfds = epoll_wait(epfd,events, 20 , 500 );
         // 处理所发生的所有事�?nbsp;
         for (i = 0 ;i < nfds; ++ i)
        {
             if (events[i].data.fd == listenfd)
            {

                clilen=sizeof(struct sockaddr);
                connfd = accept(listenfd,(struct sockaddr * ) & clientaddr, & clilen);
                 if (connfd < 0 ){
                    perror( " connfd<0 " );
                     exit ( 1 );
                }
                 // setnonblocking(connfd);
                char * str = inet_ntoa(clientaddr.sin_addr);
                cout << " accapt a connection from " << str << endl;
                 // 讄��用于��L��作的文�g描述�W?br>                 ev.data.fd = connfd;
                 // 讄��用于注测的读操作事�g
                ev.events = EPOLLIN|EPOLLET;
                 // ev.events = EPOLLIN;
                 // 注册ev
                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd, & ev);
            }
             else if (events[i].events & EPOLLIN)
            {
                cout << " EPOLLIN " << endl;
                 if ( (sockfd = events[i].data.fd) < 0 )
                    continue;
                 if ( (n = read(sockfd, line, MAXLINE)) < 0 ) {
                     if (errno == ECONNRESET) {
                        close(sockfd);
                        events[i].data.fd = - 1 ;
                    } else
                        std::cout << " readline error " << std::endl;
                } else if (n == 0 ) {
                    close(sockfd);
                    events[i].data.fd = - 1 ;
                }
                line[n] = ' \0';
                cout << " read " << line << endl;
                 // 讄��用于写操作的文�g描述�W?br>                 ev.data.fd = sockfd;
                 // 讄��用于注测的写操作事�g
                ev.events = EPOLLOUT|EPOLLET;
                 // 修改sockfd上要处理的事件�ؓEPOLLOUT
                 // epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd, & ev);
            }
             else if (events[i].events & EPOLLOUT)
            {
                sockfd = events[i].data.fd;
                write(sockfd, line, n);
                 // 讄��用于��L��作的文�g描述�W?br>                 ev.data.fd = sockfd;
                 // 讄��用于注测的读操作事�g
                ev.events = EPOLLIN|EPOLLET;
                 // 修改sockfd上要处理的事件�ؓEPOLIN
                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd, & ev);
            }
        }
    }
    return 0 ;
}

下面�l�出��试所用的Perl写的client�?在client中发�?0字节的数�?同时让client在发送完数据之后�q�入��d�@�? 也就是在发送完之后�q�接的状态不发生改变--既不再发送数�? 也不关闭�q�接,�q�样才能观察出server的状�?

#! / usr / bin / perl

use IO::Socket;

my $host = " 127.0.0.1 " ;
my $port = 5000 ;

my $socket = IO::Socket::INET -> new ( " $host:$port " ) or die " create socket error $@ " ;
my $msg_out = " 1234567890 " ;
print $socket $msg_out;
print " now send over, go to sleep \n " ;

while ( 1 )
{
sleep( 1 );
}

�q�行server和client发现,server仅仅��d��?字节的数�?而client其实发送了10字节的数�?也就是说,server仅当�W�一��? 监听��C��EPOLLIN事�g,�׃��没有��d��完数�?而且采用的是ET模式,状态在此之后不发生变化,因此server再也接收不到EPOLLIN事�g�?
(友情提示:上面的这个测试客��L��,当你关闭它的时候会再次出发IO可读事�g�l�server,此时server��׃��去读取剩下的5字节数据�?但是�q�一事�g与前面描�q�的ET性质�q�不矛盾.)

如果我们把client改�ؓ�q�样:

可以发现,在server接收�?字节的数据之后一直监听不到client的事�?而当client休眠5�U�之后重新发送数�?server再次监听��C��变化,只不�q�因为只是读取了5个字�?仍然�?0个字节的数据(client�W�二�ơ发送的数据)没有接收�?

如果上面的实验中,对accept的socket都采用的是LT模式,那么只要�q�有数据留在buffer�?server��׃��l�箋得到通知,读者可以自行改动代码进行实�?

�? 于这两个实验,可以得出�q�样的结�?ET模式仅当状态发生变化的时候才获得通知,�q�里所谓的状态的变化�q�不包括�~�冲��Z��q�有未处理的数据,也就是说,如果要采用ET模式,需要一直read/write直到出错为止,很多人反映�ؓ什么采用ET模式只接收了一部分数据��再也得不到通知�?大多因�ؓ�q�样;而LT 模式是只要有数据没有处理��׃��一直通知下去�?

补充说明一下这里一直强调的"状态变�?是什�?

1)对于监听可读事�g�?如果是socket是监听socket,那么当有新的��d��q�接到来为状态发生变�?对一般的socket而言,协议栈中相应的缓冲区有新的数据�ؓ状态发生变�?但是,如果在一个时间同时接收了N个连�?N>1),但是监听socket只accept了一个连�?那么其它�? accept的连接将不会在ET模式下给监听socket发出通知,此时状态不发生变化;对于一般的socket,��如例子中而言,如果对应的缓冲区本��n 已经有了N字节的数�?而只取出了小于N字节的数�?那么�D�存的数据不会造成状态发生变�?

2)对于监听可写事�g�?同理可推,不再详述.

而不论是监听可读�q�是可写,�Ҏ��关闭socket�q�接都将造成状态发生变�?比如在例子中,如果��中断client脚本,也就是主动中断了socket�q�接,那么都将造成server端发生状态的变化,从而server得到通知,��已�l�在本方�~�冲��Z��的数据读�?

把前面的描述可以�ȝ��如下:仅当�Ҏ��的动�?发出数据,关闭�q�接�{?造成的事件才能导致状态发生变�?而本方协议栈中已�l�处理的事�g(包括接收了对方的�? �?接收了对方的��d��q�接��h��)�q�不是造成状态发生变化的必要条�g,状态变化一定是�Ҏ��造成�?所以在ET模式下的,必须一直处理到出错或者完全处理完 �?才能�q�行下一个动�?否则可能会发生错�?

另外,从这个例子中,也可以阐�q�C��些基本的�|�络�~�程概念.首先,�q�接的两端中,一端发送成功�ƈ不代表着�Ҏ��上层应用�E�序接收成功, ��拿上面的client��试�E�序来说,10字节的数据已�l�发送成�?但是上层的server�q�没有调用read��d��数据,因此发送成功仅仅说明了数据被对方的协议栈接收存攑֜�了相应的buffer�?而上层的应用�E�序是否接收了这部分数据不得而知;同样�?��d��数据时也只代表着本方协议栈的对应 buffer中有数据可读,而此时时候在对端是否在发送数据也不得而知.