Linux套接字
套接字是一种通信机制,凭借这种机制,客户/服务器系统的开发工作既可以在本地单机上进行,也可以跨网络进行。套接字的特性有三个属性确定,它们是:域(domain),类型(type),和协议(protocol)。套接字还用地址作为它的名字。地址的格式随域(又被称为协议族,protocol family)的不同而不同。每个协议族又可以使用一个或多个地址族定义地址格式。
1.套接字的域
域指定套接字通信中使用的网络介质。最常见的套接字域是AF_INET,它是指Internet网络,许多Linux局域网使用的都是该网络,当然,因特网自身用的也是它。其底层的协议——网际协议(IP)只有一个地址族,它使用一种特定的方式来指定网络中的计算机,即IP地址。
在计算机系统内部,端口通过分配一个唯一的16位的整数来表示,在系统外部,则需要通过IP地址和端口号的组合来确定。
2.套接字类型
流套接字(在某些方面类似域标准的输入/输出流)提供的是一个有序,可靠,双向字节流的连接。
流套接字由类型SOCK_STREAM指定,它们是在AF_INET域中通过TCP/IP连接实现的。他们也是AF_UNIX域中常见的套接字类型。
数据包套接字
与流套接字相反,由类型SOCK_DGRAM指定的数据包套接字不建立和维持一个连接。它对可以发送的数据包的长度有限制。数据报作为一个单独的网络消息被传输,它可能会丢失,复制或乱序到达。
数据报套接字实在AF_INET域中通过UDP/IP连接实现,它提供的是一种无需的不可靠服务。
3.套接字协议
只要底层的传输机制允许不止一个协议来提供要求的套接字类型,我们就可以为套接字选择一个特定的协议。
创建套接字
socket系统调用创建一个套接字并返回一个描述符,该描述符可以用来访问该套接字。
#include<sys/types.h>
#include<sys/socket.h>
int socket(int domain , int type , int protocol);
创建的套接字是一条通信线路的一个端点。domain参数指定协议族,type参数指定这个套接字的通信类型,protocol参数指定使用的协议。
domain参数可以指定的协议族如下
域 说明
AF_UNIX UNIX域协议(文件系统套接字)
AF_INET ARPA因特网协议(UNIX网络套接字)
AF_ISO ISO标准协议
AF_NS 施乐(XEROX)网络系统协议
AF_IPX NOVELL IPX协议
AF_APPLETALK
Appletalk DDS
最常见的套接字域是AF_UNIX和AF_INET,前者用于通过Unix和Linux文件系统实现的本地套接字,后者用于Unix网络套接字。AF_INET套接字可以用于通过包括因特网在内的TCP/IP网络进行通信的程序。微软Windows系统的winsock接口也提供了对这个套接字域的访问功能。
socket函数的参数type指定用于新套接字的通信特性。它的取值包括SOCK_STREAM和SOCK_DGRAM。
SOCK_STREAM是一个有序、可靠、面向连接的双字节流。通过TCP连接来实现。
SOCK_DGRAM是数据包服务,我们可以用它来发送最大长度固定的消息。但消息是否会被正确传递或消息是否不会乱序到达没有保证。
套接字地址结构
结构struct sockaddr_un 定义了一种通用的套接字地址,它的类型是:
struct sockaddr_un
{
sa_family_t sun_family; /*AF_UNIX*/
char sun_path; /*pathname*/
};
这是一种通用的定义,一般都不用。TCP/IP使用的是自己的结构体struct sockaddr_in,格式如下:
struct sockaddr_in
{
short int sin_family; //地址类型,一般为AF_INET
unsigned short int sin_port; //端口号
struct in_addr sin_addr; //IP地址
};
这里的struct in_addr的定义如下:
struct in_addr
{
unsigned long int s_addr;
};
结构体sockaddr和sockaddr_in的长度都是16字节。一般在编TCP/IP程序时,一般使用结构体sockaddr_in来设置地址,然后在需要的时候,通过强制类型转换成sockaddr类型。
建立连接
函数connect用来在一个指定的套接字上创建一个连接,函数原型:
[cpp] view plain copy print?
int connect(int socket, const struct sockaddr *address, size_t address_len);
参数sockfd是一个由函数socket创建的套接字;
参数address是一个地址结构,需要连接的地址;
参数address_len为参数addr_addr的长度。
函数执行成功返回0,有错误发生则返回-1。
如果套接字类型是TCP,则该函数用于向服务器发出连接请求,服务器的IP地址和端口号由参数serv_addr指定;如果套接字类型是UDP,则该函数并不建立真正的连接,它只是告诉内核与该套接字进行通信的目的地址(由第二个参数指定),只有该目的地址发来的数据才会被该socket接收。
通常一个面向连接的套接字只能调用一次connect函数;而对于无连接的套接字则可以多次调用connect函数以改变与目的地址的绑定。
在套接字上监听
函数listen把套接字转化为被动监听,函数原型:
int listen(int s, int backlog);
参数s指定了一个套接字;
参数backlog指定了该连接队列的最大长度,如果已达到最大,则之后的连接请求将被服务器拒绝。
函数执行成功赶回0,有错误发生则返回-1。
由函数socket创建的套接字是主动套接字,这种套接字可以用来主动请求连接到某个服务器上。(通过connect()函数)。
作为服务器端的程序,通常在某个端口上监听等待来自客户端的连接请求。在服务器端,一般是先调用函数socket创建一个主动套接字,然后调用函数bind将该套接字绑定到某个端口上,接着再调用函数listen将该套接字转化为监听套接字,等待来自于客户端的连接请求。
函数listen只是将套接字设置为倾听模式以等待连接请求,它并不能接收连接请求,真正的接收客户端连接请求的是accept()函数。
接收连接
函数accept用来接收一个连接请求,函数原型:
int accept(int s, struct sockaddr *addr, socklen_t *addrlen);
参数s是由socket创建,经函数bind绑定到本地某一端口上,然后通过函数listen转化而来的监听套接字;
参数addr用来保存发起连接请求的主机的地址和端口;
参数addrlen是addr所指向的结构体的大小。
函数执行成功返回一个新的代表客户端的套接字,出错则返回-1。
只能对面向连接的套接字使用accept函数。accept执行成功时,将创建一个新的套接字,并且这个新的套接字分配一个套接字描述符,并返回这个新的套接字描述符。这个新的套接字描述符与打开文件返回的文件描述符类似,进程可以利用这个新的套接字描述符与客户端交换数据,参数s所指定的套接字继续等待客户端的连接请求。
[cpp] view plain copy print?
/* Make the necessary includes and set up the variables. */
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
int sockfd;
int len;
struct sockaddr_un address;
int result;
char ch = 'A';
/* Create a socket for the client. */
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
/* Name the socket, as agreed with the server. */
address.sun_family = AF_UNIX;
strcpy(address.sun_path, "server_socket");
len = sizeof(address);
/* Now connect our socket to the server's socket. */
result = connect(sockfd, (struct sockaddr *)&address, len);
if(result == -1) {
perror("oops: client1");
exit(1);
}
/* We can now read/write via sockfd. */
write(sockfd, &ch, 1);
read(sockfd, &ch, 1);
printf("char from server = %c\n", ch);
close(sockfd);
exit(0);
}
[cpp] view plain copy print?
/* Make the necessary includes and set up the variables. */
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_un server_address;
struct sockaddr_un client_address;
/* Remove any old socket and create an unnamed socket for the server. */
unlink("server_socket");
server_sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
/* Name the socket. */
server_address.sun_family = AF_UNIX;
strcpy(server_address.sun_path, "server_socket");
server_len = sizeof(server_address);
bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
/* Create a connection queue and wait for clients. */
listen(server_sockfd, 5);
while(1) {
char ch;
printf("server waiting\n");
/* Accept a connection. */
client_len = sizeof(client_address);
client_sockfd = accept(server_sockfd,
(struct sockaddr *)&client_address, &client_len);
/* We can now read/write to client on client_sockfd. */
read(client_sockfd, &ch, 1);
ch++;
write(client_sockfd, &ch, 1);
close(client_sockfd);
}
}
========
Linux 下基于socket的简单网络聊天室(服务器与客户端)
本程序分为服务端与客户端,服务器建立一个共享内存区,用于存贮各个客户端发送过来的消息,服务器接收一个客户端登陆后,即开启一个子进程,原父进程返回等待新客户的登陆,子进程用于接收客户的消息,并把共享内存里面的全部的内容发送给客户端。为了便于处理数据的方便,在处理客户消息的子进程中再创建一个子进程,一个用于接收子进程消息,存于共享内存区;另一个子进程用于发送共享内存给客户端。客户端接收到共享内存的内容后,根据实际情况显示共享内存里面的内容。后登陆的用户可以看到前面用户的聊天内容。
本设计锻炼了linux中socket的基本应用,服务端建立套接字的大致步骤:
1,建立socket。
2,bind 绑定特定的端口。
3,listen 监听特定的端口。
4,accept,当有客户端连接服务器端口时,accept接收信息,并返回新的套接字描述符,提供给操作
5,根据实际需求,write,read,send,recv等操作
6,关闭套接字。
客户端大致步骤:
1,创建socket.
2,根据服务器地址,connect连接到特定服务器。
3,write,read等读写操作。
4,关闭套接字。
在程序调试过程中,要特别注意清空常用的载体。留意sizeof和strlen的区别。
留意各进程之间的关系的梳理,各循环的起始条件,运行情况。
服务器:server.c
#include <sys/types.h>
#include <sys/socket.h> // 包含套接字函数库
#include <stdio.h>
#include <netinet/in.h> // 包含AF_INET相关结构
#include <arpa/inet.h> // 包含AF_INET相关操作的函数
#include <unistd.h>
#include<string.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/shm.h>
#define PORT 8888;
#define MYKEY 12345
#define SIZE 10240
int main()
{
int shmid;
char *shmaddr; //定义子进程共用的共享内存
shmid = shmget(MYKEY, SIZE, IPC_CREAT | 0600);
shmaddr= (char *) shmat(shmid, 0, 0);
if(shmid==-1)
{
printf("shmid error\n");
}
memset(shmaddr,0,SIZE);
int i=0;
char buf[100];
memset(buf,0,100);
int server_sockfd,client_sockfd;
int server_len,client_len;
struct sockaddr_in server_sockaddr,client_sockaddr;
server_sockfd = socket(AF_INET,SOCK_STREAM, 0); // 定义套接字类型
server_sockaddr.sin_family=AF_INET;
server_sockaddr.sin_port=PORT;
server_sockaddr.sin_addr.s_addr=INADDR_ANY;
server_len=sizeof(server_sockaddr);
//允许重复使用本地地址和套接字绑定
int j=1;
setsockopt(server_sockfd,SOL_SOCKET,SO_REUSEADDR,&j,sizeof(j));
//绑定端口
if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,server_len)==-1)
{
perror("bind:");
exit(1);
}
if(listen(server_sockfd,5)==-1)
{
perror("listen:");
exit(1);
}
printf("Listening...\n");
client_len=sizeof(client_sockaddr);
pid_t ppid,pid;
while(1)
{
if((client_sockfd=accept(server_sockfd,(struct sockaddr *)&client_sockaddr,&client_len))==-1)
{
perror("accept error:");
exit(1);
}
printf("%s登录服务器\n",inet_ntoa(client_sockaddr.sin_addr));
ppid=fork();
if(ppid==-1)
{
printf("fork 1 failed:");
}
if(ppid==0) //子进程用于接收客户端信息并发送
{
pid=fork();
if(pid==-1)
{
printf("fork 2 failed:");
exit(1);
}
int recvbytes;
if(pid==0) //子子进程用于接收消息
{
while(1)
{
if((recvbytes=recv(client_sockfd,buf,100,0))==-1)
{
perror("read client_sockfd failed:");
}
// printf("recvbytes=%d\n",recvbytes);
usleep(10000);
printf("client send buf=%s\n",buf);
for(i=0;i<1000;i++)
{
if(*(shmaddr+100*i)==0)
{
strcpy(shmaddr+100*i,buf);
break;
}
}
}
}
if(pid>0) //子进程用于发送消息
{
while(1)
{
if(*(shmaddr+i*100)!=0)
{
// strcpy(&buf,shmaddr+100*i);
// buf++;
write(client_sockfd,shmaddr,SIZE);
// send(client_sockfd,buf,strlen(buf),0);
// printf("the server is send buf=%c",buf);
// printf("send client :%s\n",(shmaddr+i*100)) ;
i++;
}
}
}
}
if(ppid>0) //总父进程返回等待接收消息
{
close(client_sockfd);
}
}
}
客户端:client.c
#include <sys/types.h>
#include <sys/socket.h> // 包含套接字函数库
#include <stdio.h>
#include <netinet/in.h> // 包含AF_INET相关结构
#include <arpa/inet.h> // 包含AF_INET相关操作的函数
#include <unistd.h>
#include<string.h>
#include<time.h>
#define PORT 8888
#define IP_ADDR "192.168.110.185"
#define SIZE 10240
int main()
{
struct tm *timeptr;
time_t timeval;
char tm[50];
//(void)time(&timeval);
//printf("the date is %s\n",ctime(&timeval));
// printf("The time is %s\n",tm);
int sockfd; // 用于保存客户套接字标识符
int len; // 用于客户消息长度
struct sockaddr_in address; // 定义客户套接字地址
int result;
sockfd = socket(AF_INET,SOCK_STREAM, 0); // 定义套接字类型
address.sin_family = AF_INET; // 定义套接字地址中的域
address.sin_addr.s_addr = inet_addr(IP_ADDR); // 定义套接字地址
address.sin_port = htons(PORT); // 定义套接字端口
char buf[100]; // 定义要传送的消息
memset(buf,0,100);
char str[90]; //存贮输入的语句
char shmaddr[SIZE]; //接受服务器发送的全部聊天数据
int i=0;
char myname[100];
char say[10]={"说:"};
printf("欢迎来到聊天室,请输入你的姓名:\n");
scanf("%s",myname);
len = sizeof(address);
result = connect(sockfd, (struct sockaddr *) &address, len); // 请求连接
if (result == -1)
{
perror("Connect failed");
return 1;
}
printf("%s成功登录服务器:\n",myname);
pid_t pid;
pid=fork();
if(pid==-1)
{
printf("fork failed");
}
int sendbytes=0;
if(pid==0) //子进程用于发送数据
{
while(1)
{
printf("请输入语句:\n");
scanf("%s",str);
(void)time(&timeval);
strcpy(tm,ctime(&timeval));
strcpy(buf,myname); //姓名传入buf中
strcat(buf,tm); //时间传入buf中
strcat(buf,say);
strcat(buf,str); //语句传入bufz中
//read(0,buf,strlen(buf));
// send(sockfd,buf,strlen(buf),0);
// getchar();
if((sendbytes=write(sockfd, buf, 100))==-1)
{
perror("send to server failed:");
} // 向服务器传送消息
// printf("sendbytes=%d\n",sendbytes);
// printf("buf=%s\n",buf);
// printf("input buf=%s\n",buf);
usleep(1000);
memset(buf,0,100);
memset(tm,0,50);
}
}
if(pid>0) //父进程用于接受消息并读取
{
while(1)
{
read(sockfd,shmaddr,SIZE);
// printf("server send shmaddr=%s\n",shmaddr);
if(*(shmaddr+i*100)!=0)
{
printf("%s\n",(shmaddr+i*100)) ;
i++;
}
usleep(1000);
}
}
close(sockfd);
return 0;
}
========
linux网络编程:用C语言实现的聊天程序(异步通信)
本片文章,在上一篇:linux网络编程:用C语言实现的聊天程序(同步通信) 的基础上,增加了IO复用的功能,实现了聊天程序的异步通讯!
1、使用IO复用可以在等待的时候加入了超时的时间,如果等待的时间没有达到超时时间,那么该情况与阻塞的情况一致。而当超时的时间到达时,仍没有数据接收到,系统回返回0,不再等待。select函数就实现了这个功能。
2、select函数原型
int select (int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, const struct timeval * timeout);
a)返回值
>0:就绪的描述符
-1:出错
0 :超时
struct timeval{
long tv_sec; // seconds
long tv_usec; // microseconds
}
b)具体解释select的参数
int maxfdp是一个整数值,是指集合中所有文件描述符的范围,即所有文件描述符的最大值加1;
fd_set*readfds 文件描述符集合内,是否有数据可读;
fd_set*writefds 文件描述符集合内,是否有数据可写;
fd_set *errorfds 文件描述符集合内,是否有文件发生错误;
struct timeval *timeout是select的超时时间,它可以使select处于三种状态,第一,若将NULL以形参传入,就是将select置于阻塞状态;第二,若将时间值设为0秒0毫秒,就变成一个纯粹的非阻塞函数,不管文件描述符是否有变化,都立刻返回继续执行,文件无变化返回0,有变化返回一个正值;第三,timeout的值大于0,这就是等待的超时时间,即select在timeout时间内阻塞。
c)4个宏可以操作文件描述符的集合
void FD_ZERO (fd_set *fdset); // 初始化文件描述集合
void FD_SET (int fd, fd_set *fdset); // 将描述符加入到集合中
void FD_CLR (int fd, fd_set *fdset); // 将描述符中集合中删除
int FD_ISSET (int fd, fd_set *fdset); // 检查描述符集合中指定的文件描述符是否可读写
3、客户端源代码:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#define BUFLEN 1024
int main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in s_addr;
socklen_t len;
unsigned int port;
char buf[BUFLEN];
fd_set rfds;
struct timeval tv;
int retval, maxfd;
/*建立socket*/
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(errno);
}else
printf("socket create success!\n");
/*设置服务器端口*/
if(argv[2])
port = atoi(argv[2]);
else
port = 4567;
/*设置服务器ip*/
bzero(&s_addr, sizeof(s_addr));
s_addr.sin_family = AF_INET;
s_addr.sin_port = htons(port);
if (inet_aton(argv[1], (struct in_addr *)&s_addr.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
/*开始连接服务器*/
if(connect(sockfd,(struct sockaddr*)&s_addr,sizeof(struct sockaddr)) == -1){
perror("connect");
exit(errno);
}else
printf("conncet success!\n");
while(1){
/*把可读文件描述符的集合清空*/
FD_ZERO(&rfds);
/*把标准输入的文件描述符加入到集合中*/
FD_SET(0, &rfds);
maxfd = 0;
/*把当前连接的文件描述符加入到集合中*/
FD_SET(sockfd, &rfds);
/*找出文件描述符集合中最大的文件描述符*/
if(maxfd < sockfd)
maxfd = sockfd;
/*设置超时时间*/
tv.tv_sec = 5;
tv.tv_usec = 0;
/*等待聊天*/
retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
if(retval == -1){
printf("select出错,客户端程序退出\n");
break;
}else if(retval == 0){
printf("客户端没有任何输入信息,并且服务器也没有信息到来,waiting...\n");
continue;
}else{
/*服务器发来了消息*/
if(FD_ISSET(sockfd,&rfds)){
/******接收消息*******/
bzero(buf,BUFLEN);
len = recv(sockfd,buf,BUFLEN,0);
if(len > 0)
printf("服务器发来的消息是:%s,共有字节数是: %d\n",buf,len);
else{
if(len < 0 )
printf("接受消息失败!\n");
else
printf("服务器退出了,聊天终止!\n");
break;
}
}
/*用户输入信息了,开始处理信息并发送*/
if(FD_ISSET(0, &rfds)){
_retry:
/******发送消息*******/
bzero(buf,BUFLEN);
/*fgets函数:从流中读取BUFLEN-1个字符*/
fgets(buf,BUFLEN,stdin);
/*打印发送的消息*/
//fputs(buf,stdout);
if(!strncasecmp(buf,"quit",4)){
printf("client 请求终止聊天!\n");
break;
}
/*如果输入的字符串只有"\n",即回车,那么请重新输入*/
if(!strncmp(buf,"\n",1)){
printf("输入的字符只有回车,这个是不正确的!!!\n");
goto _retry;
}
/*如果buf中含有'\n',那么要用strlen(buf)-1,去掉'\n'*/
if(strchr(buf,'\n'))
len = send(sockfd,buf,strlen(buf)-1,0);
/*如果buf中没有'\n',则用buf的真正长度strlen(buf)*/
else
len = send(sockfd,buf,strlen(buf),0);
if(len > 0)
printf("\t消息发送成功,本次共发送的字节数是:%d\n",len);
else{
printf("消息发送失败!\n");
break;
}
}
}
}
/*关闭连接*/
close(sockfd);
return 0;
}
4、服务器源代码:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#define BUFLEN 1024
int main(int argc, char **argv)
{
int sockfd, newfd;
struct sockaddr_in s_addr, c_addr;
char buf[BUFLEN];
socklen_t len;
unsigned int port, listnum;
fd_set rfds;
struct timeval tv;
int retval,maxfd;
/*建立socket*/
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(errno);
}else
printf("socket create success!\n");
/*设置服务器端口*/
if(argv[2])
port = atoi(argv[2]);
else
port = 4567;
/*设置侦听队列长度*/
if(argv[3])
listnum = atoi(argv[3]);
else
listnum = 3;
/*设置服务器ip*/
bzero(&s_addr, sizeof(s_addr));
s_addr.sin_family = AF_INET;
s_addr.sin_port = htons(port);
if(argv[1])
s_addr.sin_addr.s_addr = inet_addr(argv[1]);
else
s_addr.sin_addr.s_addr = INADDR_ANY;
/*把地址和端口帮定到套接字上*/
if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
perror("bind");
exit(errno);
}else
printf("bind success!\n");
/*侦听本地端口*/
if(listen(sockfd,listnum) == -1){
perror("listen");
exit(errno);
}else
printf("the server is listening!\n");
while(1){
printf("*****************聊天开始***************\n");
len = sizeof(struct sockaddr);
if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) == -1){
perror("accept");
exit(errno);
}else
printf("正在与您聊天的客户端是:%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));
while(1){
/*把可读文件描述符的集合清空*/
FD_ZERO(&rfds);
/*把标准输入的文件描述符加入到集合中*/
FD_SET(0, &rfds);
maxfd = 0;
/*把当前连接的文件描述符加入到集合中*/
FD_SET(newfd, &rfds);
/*找出文件描述符集合中最大的文件描述符*/
if(maxfd < newfd)
maxfd = newfd;
/*设置超时时间*/
tv.tv_sec = 5;
tv.tv_usec = 0;
/*等待聊天*/
retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
if(retval == -1){
printf("select出错,与该客户端连接的程序将退出\n");
break;
}else if(retval == 0){
printf("服务器没有任何输入信息,并且客户端也没有信息到来,waiting...\n");
continue;
}else{
/*用户输入信息了,开始处理信息并发送*/
if(FD_ISSET(0, &rfds)){
_retry:
/******发送消息*******/
bzero(buf,BUFLEN);
/*fgets函数:从流中读取BUFLEN-1个字符*/
fgets(buf,BUFLEN,stdin);
/*打印发送的消息*/
//fputs(buf,stdout);
if(!strncasecmp(buf,"quit",4)){
printf("server 请求终止聊天!\n");
break;
}
/*如果输入的字符串只有"\n",即回车,那么请重新输入*/
if(!strncmp(buf,"\n",1)){
printf("输入的字符只有回车,这个是不正确的!!!\n");
goto _retry;
}
/*如果buf中含有'\n',那么要用strlen(buf)-1,去掉'\n'*/
if(strchr(buf,'\n'))
len = send(newfd,buf,strlen(buf)-1,0);
/*如果buf中没有'\n',则用buf的真正长度strlen(buf)*/
else
len = send(newfd,buf,strlen(buf),0);
if(len > 0)
printf("\t消息发送成功,本次共发送的字节数是:%d\n",len);
else{
printf("消息发送失败!\n");
break;
}
}
/*客户端发来了消息*/
if(FD_ISSET(newfd, &rfds)){
/******接收消息*******/
bzero(buf,BUFLEN);
len = recv(newfd,buf,BUFLEN,0);
if(len > 0)
printf("客户端发来的信息是:%s,共有字节数是: %d\n",buf,len);
else{
if(len < 0 )
printf("接受消息失败!\n");
else
printf("客户端退出了,聊天终止!\n");
break;
}
}
}
}
/*关闭聊天的套接字*/
close(newfd);
/*是否退出服务器*/
printf("服务器是否退出程序:y->是;n->否? ");
bzero(buf, BUFLEN);
fgets(buf,BUFLEN, stdin);
if(!strncasecmp(buf,"y",1)){
printf("server 退出!\n");
break;
}
}
/*关闭服务器的套接字*/
close(sockfd);
return 0;
}
5、编译源代码:
new@new-desktop:~/linux/c$ gcc -Wall async-server.c -o async-server
new@new-desktop:~/linux/c$ gcc -Wall async-client.c -o async-client
6、服务器运行:
new@new-desktop:~/linux/c$ ./async-server 127.0.0.1
socket create success!
bind success!
the server is listening!
*****************聊天开始***************
正在与您聊天的客户端是:127.0.0.1: 37648
服务器没有任何输入信息,并且客户端也没有信息到来,waiting...
hello
消息发送成功,本次共发送的字节数是:5
服务器没有任何输入信息,并且客户端也没有信息到来,waiting...
客户端发来的信息是:renwen,共有字节数是: 6
7、客户端运行:
new@new-desktop:~/linux/c$ ./async-client 127.0.0.1
socket create success!
conncet success!
客户端没有任何输入信息,并且服务器也没有信息到来,waiting...
服务器发来的消息是:hello,共有字节数是: 5
客户端没有任何输入信息,并且服务器也没有信息到来,waiting...
renwen
消息发送成功,本次共发送的字节数是:6
客户端没有任何输入信息,并且服务器也没有信息到来,waiting...
客户端没有任何输入信息,并且服务器也没有信息到来,waiting...
客户端没有任何输入信息,并且服务器也没有信息到来,waiting...
========
资源链接
http://www.codeceo.com/article/linux-chart.html基于Linux的多功能聊天室