本文详细介绍了一个简单的网络编程案例，包括服务器端和客户端的代码实现。通过对原始代码进行模块化封装，提高了代码的可读性和可维护性。文章还介绍了如何使用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;
}然后我们继续看程序，在最开始的时候 要初始化 服务器的信息， 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
/*
* 接受客户端请求并返回一个新的 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;
}
}
/*
* 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);
#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 ./clientOK,这样我们封装就完成了。
有的时候我们在连续的 执行两次 Server执行文件的时候，会出现bind Error的时候，如下图所示：
这里的原因 是 上次的接口没有释放掉，（个人理解，如有错误，请指出）。所以在server的代码之中 我们在bind后要来测试一下 端口号有没有申请成功，如果没有，则直接退出程序。
int status;
status = ConfigureServer(serverfd);
//判断是否获得成功端口号
if(status == FAILURE)
return -1;
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
