linux网络编程服务端客户端-出错处理封装函数

出错处理函数头文件wrap.h

#ifndef __WRAP_H_
#define __WRAP_H_

void perr_exit(const char *s);
int Accept(int fd,struct sockaddr *sa,socklen_t *salenptr);
int Bind(int fd,const struct sockaddr *sa,socklen_t salen);
int Connect(int fd,const struct sockaddr *sa,socklen_t salen);
int Listen(int fd,int backlog);
int Socket(int family,int type,int protocol);
ssize_t Read(int fd,void *ptr,size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd,void *vptr,size_t n);
ssize_t Writen(int fd,const void *vptr,size_t n);
ssize_t my_read(int fd,char *ptr);
ssize_t Readline(int fd,void *vptr,size_t maxlen);

#endif

出错处理函数wrap.c

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>

void perr_exit(const char *s)
{
	perror(s);
	exit(-1);
}

int Accept(int fd,struct sockaddr *sa,socklen_t *salenptr)
{
	int n;
	
again:
	if((n=accept(fd,sa,salenptr))<0){
		if((errno==ECONNABORTED)||(errno==EINTR))
			goto again;
		else
			perr_exit("accept error");
	}
	return n;
}

int Bind(int fd,const struct sockaddr *sa,socklen_t salen)
{
	int n;

	if((n=bind(fd,sa,salen))<0)
		perr_exit("Bind error");

	return n;
}

int Connect(int fd,const struct sockaddr *sa,socklen_t salen)
{
	int n;
	printf("----------------in wrap before connect() \n");
	n=connect(fd,sa,salen);
	printf("----------------in wrap connect() return %d\n",n);
	if(n<0){
		perr_exit("connect error");
	}

	return 0;
}

int Listen(int fd,int backlog)
{
	int n;
	if((n=listen(fd,backlog))<0)
		perr_exit("listen error");

	return n;
}

int Socket(int family,int type,int protocol)
{
	int n;

	if((n=socket(family,type,protocol))<0)
		perr_exit("socket error");

	return n;
}

ssize_t Read(int fd,void *ptr,size_t nbytes)
{
	ssize_t n;
again:
	if((n=read(fd,ptr,nbytes))==-1){
		if(errno==EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

ssize_t Write(int fd,const void *ptr,size_t nbytes)
{
	ssize_t n;
again:
	if((n=write(fd,ptr,nbytes))==-1){
		if(errno==EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

int Close(int fd)
{
	int n;
	if((n=close(fd))==-1)
		perr_exit("close error");
	return n;
}

/*参三：应该读取的字节数*/
ssize_t Readn(int fd,void *vptr,size_t n)
{
	size_t nleft;//usigned int 剩余未读取的字节数
	ssize_t nread;//int 实际读到的字节数
	char *ptr;

	ptr=vptr;
	nleft=n;//n 未读取字节数

	while(nleft>0){
		if((nread=read(fd,ptr,nleft))<0){
			if(errno==EINTR)
				nread=0;
			else
				return -1;
		}else if(nread==0)
			break;
		nleft-=nread;
		ptr+=nread;
	}
	return n-nleft;
}

ssize_t Writen(int fd,const void *vptr,size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr=vptr;
	nleft=n;
	while(nleft>0){
		if((nwritten=write(fd,ptr,nleft))<=0){
			if(nwritten<0&&errno==EINTR)
				nwritten=0;
			else
				return -1;
		}
		nleft-=nwritten;
		ptr+=nwritten;
	}
	return n;
}

static ssize_t my_read(int fd,char *ptr)
{
	static int read_cnt;
	static char *read_ptr;
	static char read_buf[100];
	
	if(read_cnt<=0){
again:
		if((read_cnt=read(fd,read_buf,sizeof(read_buf)))<0){
			if(errno==EINTR)
				goto again;
			return -1;
		}else if(read_cnt==0)
			return 0;
		read_ptr=read_buf;
	}
	read_cnt--;
	*ptr=*read_ptr++;

	return 1;
}

/*readline --- fgets*/
//传出参数 vptr
ssize_t Readline(int fd,void *vptr,size_t maxlen)
{
	ssize_t n,rc;
	char c,*ptr;

	ptr=vptr;

	for(n=1;n<maxlen;n++){
		if((rc=my_read(fd,&c))==1){
			*ptr++=c;
			if(c=='\n')
				break;
		}else if(rc==0){
			*ptr=0;
			return n-1;
		}else
			return -1;
	}
	*ptr=0;

	return n;
}

客户端client.c

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>

#include "wrap.h"

#define SERV_IP "127.0.0.1"
#define SERV_PORT 6666

int main(void)
{
	int sfd,len;
	struct sockaddr_in serv_addr;
	char buf[BUFSIZ];

	sfd=Socket(AF_INET,SOCK_STREAM,0);

	bzero(&serv_addr,sizeof(serv_addr));

	serv_addr.sin_family=AF_INET;
	
	inet_pton(AF_INET,SERV_IP,&serv_addr.sin_addr.s_addr);
	serv_addr.sin_port=htons(SERV_PORT);
	
	Connect(sfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));

	while(1){
		fgets(buf,sizeof(buf),stdin);
		int r=Writen(sfd,buf,strlen(buf));
		printf("Write r========%d\n",r);
		len=Read(sfd,buf,sizeof(buf));
		printf("Read len=======%d\n",len);
		Writen(STDOUT_FILENO,buf,len);
	}
	Close(sfd);
	return 0;
}

服务端server.c

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>

#include "wrap.h"

#define SERV_IP "127.0.0.1"
#define SERV_PORT 6666

int main(void)
{
	int sfd,cfd;
	int len,i;
	char buf[BUFSIZ],clie_IP[BUFSIZ];

	struct sockaddr_in serv_addr,clie_addr;
	socklen_t clie_addr_len;

	sfd=Socket(AF_INET,SOCK_STREAM,0);

	bzero(&serv_addr,sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_addr.sin_port=htons(SERV_PORT);//把本地字节序转化为网络字节序

	Bind(sfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
	Listen(sfd,2);

	printf("wait for client connect ...\n");
	clie_addr_len=sizeof(clie_addr_len);

	cfd=Accept(sfd,(struct sockaddr *)&clie_addr,&clie_addr_len);

	printf("cfd=----%d",cfd);
	printf("client IP:%s port:%d\n",
			inet_ntop(AF_INET,&clie_addr.sin_addr.s_addr,clie_IP,sizeof(clie_IP)),
			ntohs(clie_addr.sin_port));

	while(1){
		len=Read(cfd,buf,sizeof(buf));
		Writen(STDOUT_FILENO,buf,len);

		for(i=0;i<len;i++)
			buf[i]=toupper(buf[i]);
		Writen(cfd,buf,len);
	}
	Close(sfd);
	Close(cfd);
	return 0;
}

makefile

src=$(wildcard *.c)                                                             
obj=$(patsubst %.c,%.c,$(src))

all:server client

server: server.o wrap.o
        gcc server.o wrap.o -o server -Wall
client: client.o wrap.o
        gcc client.o wrap.o -o client -Wall

%.c:%.c
        gcc -c $< -Wall

.PHONY: clean all 
clean:
        -rm -rf server client $(obj)

在终端输入make，启动服务端

make
./server

再启动一个终端，启动客户端

./client