第一篇 网络编程简单通信实例

原创 于 2013-04-26 08:49:12 发布 · 645 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了一个简单的网络编程案例，包括服务器端和客户端的代码实现。通过对原始代码进行模块化封装，提高了代码的可读性和可维护性。文章还介绍了如何使用socket API进行网络通信，并提供了完整的代码示例。

首先看一下 转载的2篇网络编程入门介绍：点击打开链接    网络编程入门

看一下实例代码：

服务器端代码：

#include<stdio.h>
#include<arpa/inet.h> /* internet socket */
#include<string.h>
//#define NDEBUG
#include<assert.h>
#define PORT 					5001
#define IP_ADDR 				"192.168.2.108"
#define MAX_CONNECT_QUEUE		1024
#define MAX_BUF_LEN				1024
int main()
{
	int sockfd = -1;
	char buf[MAX_BUF_LEN];
	
	struct sockaddr_in clientaddr;
	socklen_t clientaddr_len = sizeof(struct sockaddr_in);
	
	
	//初始化服务器节点信息
	struct sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_port = htons(PORT);
	addr.sin_addr.s_addr = inet_addr(IP_ADDR);
	//bzero(&(addr.sin_zero), 8);/* in string.h */
	memset(&addr.sin_zero, 0, 8);
	
	
	//开启服务器节点
	sockfd = socket(PF_INET,SOCK_STREAM,0);
	assert((sockfd != -1));
	
	
	//bind
	int ret = bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr));
	
	
	if(ret == -1)
	{
		fprintf(stderr,"Bind Error,%s:%d,",__FILE__,__LINE__);
		fprintf(stderr,"%s:%d\n",(char*)inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));
		close(sockfd);
		return -1;
	}
	
	
	
	//监听
	ret = listen(sockfd,MAX_CONNECT_QUEUE);
	assert((ret == 0));
	
	//和客户交互
	while(1)
	{
		int newfd = accept(sockfd,(struct sockaddr *)&clientaddr,&clientaddr_len);
		if(newfd == -1)
		{
			fprintf(stderr,"Accept Error,%s:%d\n",__FILE__,__LINE__);
		}
		else
		{
		/* talk with client here */
			ret = recv(newfd,buf,MAX_BUF_LEN,0);
			if(ret > 0)
			{
				printf("recv  \"%s\"%s:%d\n",buf,(char*)inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));
			}
			ret = send(newfd,"hi",sizeof("hi"),0);
			if(ret > 0)
			{
			printf("rely \"hi\" from %s:%d\n",(char*)inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));
			}
			close(newfd);
		}
	}
	close(sockfd);
	return 0;
}
客户端代码： 

#include<stdio.h>
#include<arpa/inet.h> /* internet socket */
#include<string.h>
//#define NDEBUG
#include<assert.h>
#define PORT					5001
//#define IP_ADDR 				"127.0.0.1"
#define MAX_CONNECT_QUEUE		1024
#define MAX_BUF_LEN  			1024

char IP_ADDR[MAX_BUF_LEN];

int main()
{
	int sockfd = -1;
	char buf[MAX_BUF_LEN];
	
	printf("Input server ip :\n");
	scanf(" %s",IP_ADDR);
	
	//初始化服务器节点信息
	struct sockaddr_in serveraddr;
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(PORT);
	serveraddr.sin_addr.s_addr = inet_addr(IP_ADDR);
	//bzero(&(serveraddr.sin_zero), 8);/* in string.h */
	memset(&serveraddr.sin_zero, 0, 8);
	
	
	
	sockfd = socket(PF_INET,SOCK_STREAM,0);
	assert((sockfd != -1));
	int ret = connect(sockfd,(struct sockaddr *)&serveraddr,sizeof(struct sockaddr));
	if(ret == -1)
	{
		fprintf(stderr,"Connect Error,%s:%d\n",__FILE__,__LINE__);
		return -1;
	}
	/* talk with client here */
	ret = send(sockfd,"hello",sizeof("hello"),0);
	if(ret > 0)
	{
		printf("send \"hello\" to %s:%d\n",(char*)inet_ntoa(serveraddr.sin_addr),ntohs(serveraddr.sin_port));
	}
	ret = recv(sockfd,buf,MAX_BUF_LEN,0);
	if(ret > 0)
	{
		printf("Server rely:%s\n",buf);
	}
	close(sockfd);
	return 0;
}
分别编译 运行，看执行结果：



我们下一步的任务是将 这些代码封装起来：先仔细规划下 服务器端和 客户端 执行的步骤。将每个步骤封装起来。

首先我们可以规划一下要划分哪些模块。

 Linux系统是通过提供套接字(socket)来进行网络编程的.网络程序通过socket和其它几个函数的调用,
   会返回一个 通讯的文件描述符,我们可以将这个描述符看成普通的文件的描述符来操作,这就是linux的设备无关性的好处.
   我们可以通过向描述符读写操作实现网络之间的数据交流. 


1.  int socket(int domain, int type,int protocol)

  domain:说明我们网络程序所在的主机采用的通讯协族(AF_UNIX和AF_INET等). 
        AF_UNIX只能够用于单一的Unix 系统进程间通信,
        而AF_INET是针对Internet的,因而可以允许在远程 
        主机之间通信(当我们 man socket时发现 domain可选项是 PF_*而不是AF_*,因为glibc是posix的实现所以用PF代替了AF,
        不过我们都可以使用的).

  type:我们网络程序所采用的通讯协议(SOCK_STREAM,SOCK_DGRAM等) 
        SOCK_STREAM表明我们用的是TCP 协议,这样会提供按顺序的,可靠,双向,面向连接的比特流. 
        SOCK_DGRAM 表明我们用的是UDP协议,这样只会提供定长的,不可靠,无连接的通信.

  protocol:由于我们指定了type,所以这个地方我们一般只要用0来代替就可以了 socket为网络通讯做基本的准备.
  成功时返回文件描述符,失败时返回-1,看errno可知道出错的详细情况.


我们这里可以写一个 获取socket 的函数 int GetSocketFd()

int GetSocketFd()
{
	int socketfd = -1;
    if(FAILURE == (socketfd = socket(PF_INET, SOCK_STREAM, 0)))
    {
        fprintf(stderr, "#error:get socketfd.\n");
        return FAILURE;
    }
	
    return socketfd;
}
这个函数 是适合用于 server 和client端口的

然后我们继续看程序，在最开始的时候 要初始化 服务器的信息， void InitServerSocket(char *s_addr,UINT32 port)

/*
 * 初始化服务器节点信息通过 传递进来特定的指针和端口号
 */
void InitServerSocket(char *s_addr, UINT32 port)  //前面会定义全局变量 serverAddr 和 typedef unsigned int UNIT32
{
    socklen_t addr_len = sizeof(SOCKADDR);
    serverAddr.sin_family = PF_INET;
    serverAddr.sin_port = htons(port);
    (serverAddr.sin_addr).s_addr = inet_addr(s_addr);
    memset(&(serverAddr.sin_zero), SUCCESS, 8);
}

服务端下面要做的是  bind 和 listen  ：

2.bind 
  int bind(int sockfd, struct sockaddr *my_addr, int addrlen)

  sockfd:是由socket调用返回的文件描述符.

  addrlen:是sockaddr结构的长度.

  my_addr:是一个指向sockaddr的指针. 在中有 sockaddr的定义

        struct sockaddr{
                unisgned short  as_family;
                char            sa_data[14];
        };

  不过由于系统的兼容性,我们一般不用这个头文件,而使用另外一个结构(struct sockaddr_in) 来代替.在中有sockaddr_in的定义 
        struct sockaddr_in{
                unsigned short          sin_family;     
                unsigned short int      sin_port;
                struct in_addr          sin_addr;
                unsigned char           sin_zero[8];
        }
  我们主要使用Internet所以
        sin_family一般为AF_INET,
        sin_addr设置为INADDR_ANY表示可以和任何的主机通信,
        sin_port是我们要监听的端口号.sin_zero[8]是用来填充的. 
  bind将本地的端口同socket返回的文件描述符捆绑在一起.成功是返回0,失败的情况和socket一样

3.listen 
  int listen(int sockfd,int backlog)

  sockfd:是bind后的文件描述符.

  backlog:设置请求排队的最大长度.当有多个客户端程序和服务端相连时, 使用这个表示可以介绍的排队长度. 
  listen函数将bind的文件描述符变为监听套接字.返回的情况和bind一样.

这两个函数可以合起来封装一个  int ConfigureServer(int serverfd)

/*
 * 服务器开启bind和listen 根据sockfd 和监听端口
 */
int ConfigureServer(int serverfd)
{
    socklen_t addr_len = sizeof(SOCKADDR);

    if(FAILURE == bind(serverfd, (PSOCKADDR)&serverAddr, sizeof(PSOCKADDR)))
    {
        fprintf(stderr,"#error:bind %d.\n",serverfd);
        close(serverfd);
        return FAILURE;
    }

    if(FAILURE == listen(serverfd, MAX_CONNECT_QUEUE))
    {
        fprintf(stderr,"#error:listen %d.\n",serverfd);
        return FAILURE;
    }

    return SUCCESS;
}


4 accept 
  int accept(int sockfd, struct sockaddr *addr,int *addrlen)

  sockfd:是listen后的文件描述符.

  addr,addrlen是用来给客户端的程序填写的,服务器端只要传递指针就可以了. bind,listen和accept是服务器端用的函数,
  accept调用时,服务器端的程序会一直阻塞到有一个 客户程序发出了连接. accept成功时返回最后的服务器端的文件描述符,
  这个时候服务器端可以向该描述符写信息了. 失败时返回-1

可以将这个动作单独封装成为一个函数： int AcceptClient(int serverfd) 
/*
 * 接受客户端请求并返回一个新的 sockfd
 * link the server and the client.
 */
int AcceptClient(int serverfd)
{
    socklen_t addr_len = sizeof(SOCKADDR);
    int clientfd = accept(serverfd,(PSOCKADDR)&clientAddr, &addr_len);
    if(FAILURE == clientfd)
    {
        fprintf(stderr,"#error:Accept Error: %s:%d.\n",__FILE__,__LINE__);
        return FAILURE;
    }
    return clientfd;
}


5.connect 
   int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)

   sockfd:socket返回的文件描述符.

   serv_addr:储存了服务器端的连接信息.其中sin_add是服务端的地址

   addrlen:serv_addr的长度

   connect函数是客户端用来同服务端连接的.成功时返回0,sockfd是同服务端通讯的文件描述符 失败时返回-1.

可以给 客户端连接服务器 单独写一个函数：int SelfConnectServer(int clientfd) 
/*
 *客户端链接服务器根据clientfd和服务器结构信息 
 */
int SelfConnectServer(int clientfd)
{
    int ret = connect(clientfd, (PSOCKADDR)&serverAddr,sizeof(SOCKADDR));
    if(ret == FAILURE)
    {
        fprintf(stderr, "#error:connect:%d.\n",clientfd);
        
        return FAILURE;
    }
    return SUCCESS;

}

下面就是 接收和发送消息了，封装成2个函数。 
/*
 * 从newfd接收消息
 */
int RecvMsg(int newfd, char *buf)
{
    int ret = recv(newfd,buf,MAX_BUF_LEN,0);
    if(ret > 0)
    {
    	printf("Server rely: %s\n",buf);
        return SUCCESS;      
    }
    return FAILURE;
}

/*
 * 向newfd 发送消息
 */
int SendMsg(int newfd, char *buf)
{
    int ret = send(newfd,buf,strlen(buf)+1,0);
    if(ret > 0)
    {
    	printf("send \"%s\" %s:%d\n",buf,(char *)inet_ntoa(serverAddr.sin_addr),ntohs(serverAddr.sin_port));
        return SUCCESS;
    }
}


在最后关闭 端口：void CloseSocketfd(int socketfd) 

/*
 * Close the socketfd;
 */
void CloseSocketfd(int socketfd)
{
    close(socketfd);
}

OK ，到此  封装结束。

将这些函数 单独 写在一个文件中。

先看头文件：socket.h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <string.h>
#include <assert.h>
#include <fcntl.h>

#define PORT 					5001
#define IP_ADDR 				"127.0.0.1"

#define MAX_CONNECT_QUEUE		1024
#define MAX_BUF_LEN				1024
#define SUCCESS 				0
#define FAILURE 				(-1)
typedef unsigned int UINT32;

typedef struct sockaddr_in SOCKADDR;
typedef struct sockaddr *  PSOCKADDR;




SOCKADDR serverAddr;
SOCKADDR clientAddr;

char buf[MAX_BUF_LEN];

/*
**获取socketfd
*/
int GetSocketFd();

/*
 * 初始化服务器节点信息通过 传递进来特定的指针和端口号
 */
void InitServerSocket(char *s_addr, UINT32 port);


/*
 * 初始化客户端节点信息通过传递进来特定的指针和端口号
 */
void InitClientSocket(char *s_addr, UINT32 port);


/*
 * 服务器开启bind和listen 根据sockfd 和监听端口
 */
int ConfigureServer(int serverfd);



/*
 * 接受客户端请求并返回一个新的 sockfd
 * link the server and the client.
 */
int AcceptClient(int serverfd);




/*
 *客户端链接服务器根据clientfd和服务器结构信息 
 */
int SelfConnectServer(int clientfd);



/*
 * 从newfd接收消息
 */
int RecvMsg(int newfd, char *buf);


/*
 * 向newfd 发送消息
 */
int SendMsgToServer(int newfd, char *buf);


int SendMsgToClient(int newfd, char *buf);



/*
 * Close the socketfd;
 */
void CloseSocketfd(int socketfd);
然后socket.c 

#include "socket.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*
**获取socketfd
*/
int GetSocketFd()
{
	int socketfd = -1;
    if(FAILURE == (socketfd = socket(PF_INET, SOCK_STREAM, 0)))
    {
        fprintf(stderr, "#error:get socketfd.\n");
        return FAILURE;
    }

    return socketfd;
}


/*
 * 初始化服务器节点信息通过 传递进来特定的指针和端口号
 */
void InitServerSocket(char *s_addr, UINT32 port)
{
    socklen_t addr_len = sizeof(SOCKADDR);
    serverAddr.sin_family = PF_INET;
    serverAddr.sin_port = htons(port);
    (serverAddr.sin_addr).s_addr = inet_addr(s_addr);
    memset(&(serverAddr.sin_zero), SUCCESS, 8);
}


/*
 * 初始化客户端节点信息通过传递进来特定的指针和端口号
 */
void InitClientSocket(char *s_addr, UINT32 port)
{
    socklen_t addr_len = sizeof(SOCKADDR);
    clientAddr.sin_family = AF_INET;
    clientAddr.sin_port = htons(port);
    (clientAddr.sin_addr).s_addr = inet_addr(s_addr);
    memset(&(clientAddr.sin_zero), SUCCESS, 8);

}

/*
 * 服务器开启bind和listen 根据sockfd 和监听端口
 */
int ConfigureServer(int serverfd)
{
    socklen_t addr_len = sizeof(SOCKADDR);

    if(FAILURE == bind(serverfd, (struct sockaddr *)&serverAddr, sizeof(struct sockaddr )))
    {
        fprintf(stderr,"#error:bind %d.\n",serverfd);
        close(serverfd);
        return FAILURE;
    }

    if(FAILURE == listen(serverfd, MAX_CONNECT_QUEUE))
    {
        fprintf(stderr,"#error:listen %d.\n",serverfd);
        return FAILURE;
    }

    return SUCCESS;
}



/*
 * 接受客户端请求并返回一个新的 sockfd
 * link the server and the client.
 */
int AcceptClient(int serverfd)
{
    socklen_t addr_len = sizeof(SOCKADDR);
    int clientfd = accept(serverfd,(struct sockaddr *)&clientAddr, &addr_len);
    if(FAILURE == clientfd)  //clientfd == -1
    {
        fprintf(stderr,"Accept Error: %s:%d.\n",__FILE__,__LINE__);
        close(serverfd);
        return FAILURE;
    }
    return clientfd;
}


/*
 *客户端链接服务器根据clientfd和服务器结构信息 
 */
int SelfConnectServer(int clientfd)
{
  
    int ret = connect(clientfd, (PSOCKADDR)&serverAddr,
                      sizeof(SOCKADDR));
    if(ret == FAILURE)
    {
        fprintf(stderr, "#error:connect:%d.\n",clientfd); 
        return FAILURE;
    }
    return SUCCESS;

}


/*
 * 从newfd接收消息
 */
int RecvMsg(int newfd, char *buf)
{
    int ret = recv(newfd,buf,MAX_BUF_LEN,0);
    if(ret > 0)
    {
    	printf("Server rely: %s\n",buf);
        return SUCCESS;      
    }
    return FAILURE;
}



/*
 * 向newfd 发送消息
 */
int SendMsgToServer(int newfd, char *buf)
{
    int ret = send(newfd,buf,strlen(buf)+1,0);
    if(ret > 0)
    {
    	printf("send \"%s\" %s:%d\n", buf,(char *)inet_ntoa(serverAddr.sin_addr),ntohs(serverAddr.sin_port));
        return SUCCESS;
    }
}

int SendMsgToClient(int newfd, char *buf)
{
    int ret = send(newfd,buf,strlen(buf)+1,0);
    if(ret > 0)
    {
    	printf("send \"%s\" %s:%d\n", buf,(char *)inet_ntoa(clientAddr.sin_addr),ntohs(clientAddr.sin_port));
        return SUCCESS;
    }
}

/*
 * Close the socketfd;
 */
void CloseSocketfd(int socketfd)
{
    close(socketfd);
}

然后server.c 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include "socket.h"
	
int main()
{
	int serverfd = -1;
	int clientfd = -1;
	
	InitServerSocket(IP_ADDR,PORT);
	serverfd = GetSocketFd();
	int status;
	status = ConfigureServer(serverfd);
	//判断是否获得成功端口号
	if(status == FAILURE)
		return -1;
	while(1)
	{
		clientfd = AcceptClient(serverfd);
		RecvMsg(clientfd,buf);
		SendMsgToClient(clientfd,"hi");
		CloseSocketfd(clientfd);
	}
	CloseSocketfd(serverfd);
	return 0;
	
}


client.c 

#include "socket.h"
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <string.h>




int main()
{
	int clientfd = -1;
	
	InitServerSocket(IP_ADDR,PORT);
	clientfd = GetSocketFd();
	
	SelfConnectServer(clientfd);
	
	SendMsgToServer(clientfd,"hi");
	RecvMsg(clientfd,buf);
	CloseSocketfd(clientfd);

	return 0;
	
}


编译 过程：

gcc client.c socket.c socket.h -o client

gcc server.c socket.c socket.h -o server


./server   ./client

OK,这样我们封装就完成了。

有的时候我们在连续的 执行两次 Server执行文件的时候，会出现bind Error的时候，如下图所示：


这里的原因 是 上次的接口没有释放掉，（个人理解，如有错误，请指出）。所以在server的代码之中 我们在bind后要来测试一下 端口号有没有申请成功，如果没有，则直接退出程序。

int status;
	status = ConfigureServer(serverfd);
	//判断是否获得成功端口号
	if(status == FAILURE)
		return -1;
status 记录状态，用来测试是否bind成功。



评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值