linux网络编程

最新推荐文章于 2024-05-20 17:07:25 发布
最新推荐文章于 2024-05-20 17:07:25 发布
阅读量563 收藏 1
点赞数 2
文章标签： linux 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmlkl/article/details/10714493
版权

OSI模型七层结构

open systems interconnection 

由高级到低级依次为：应用层、表示层、会话层、传输层、网络层、链路层、物理层

TCP/IP协议族的体系结构

一共有四层由高到低依次为：应用层、传输层、网络层、网络接口和物理层

TCP和UDP协议

TCP（即传输控制协议）：是一种面向连接的传输层协议，它是提供高可靠性通信（即数据无误、数据无丢失、数据无失序、数据无重复到达的通信）

UDP（即用户数据报协议）：是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输

TCP/IP网络编程预备知识：socket、IP地址、端口号、字节序

1、socket：是一个程序接口，是一种特殊的文件描述符。在OSI模型中，主要位于会话层和传输层之间。

socket类型：流式套接字（SOCK_STREAM） 用于TCP

数据报套接字（SOCK_DGRAM）用于UDP

原始套接字（SOCK_RAW）可以对较低层协议如IP、ICMP直接访问

2、IP地址：IP地址是Internet中主机的标识

表示形式：常用点分十进制形式，如192.168.1.66，最后都要转换为一个32位的无符号整数

IP地址的转换：

发送 inet_aton（）和inet_addr（）都是将strptr所指的字符串转换成32位的网络字节序二进制值。in_addr_t inet_addr（const char *strptr）；

接收 inet_nota（）将32位网络字节序二进制地址转换成点分十进制的字符串。 char *inet_ntoa（stuct in_addr inaddr）；

3、端口号：为了区分一台主机接收到的数据包应该转交给哪个进程来进行处理，使用端口号来区别。

tcp和udp端口号独立

网络进程标识三元组：ip 、port 、协议（TCP UDP）  

打个比喻：如果把网络数据包的投递过程看成是给远方的一位朋友寄一封信，那么：IP地址就是这位朋友的所在地址，端口号就是这位朋友的名字。

4、字节序

网络字节序：使用同一的字节顺序，避免兼容性的问题。是大端

小端是字节的地位放在低地址。

字节序转换函数：主机字节序到网络字节序 u_long htonl（u_long hostlong）；   u_short htons （u_short short）；

网络字节序到主机字节序u_long ntohl（u_long hostlong）；   u_short ntohs（u_short short）；


网络编程的相关函数介绍


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


(二)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一样 

(三)listen 
  int listen(int sockfd,int backlog) 

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

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


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

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

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

(五)connect 
   int connect(int sockfd, struct sockaddr * serv_addr,int addrlen) 

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

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

   addrlen:serv_addr的长度 

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

TCP服务器/客户端

TCP服务器端流程 ： socket->填充地址->bind->listen->accept->send/recv->close

TCP客户端流程  ：socket->bind(可选)->connect->send/recv->close

UDP服务器/客户端

UDP服务器端流程 ： socket->bind->recvfrom->sendto

UDP客户端流程 ： socket->bind(可选)->sendto->recvfrom


例：聊天室




server.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <strings.h>

#define N 128
#define L 1
#define B 2
#define Q 3

typedef struct{
int type;
char name[N];
char data[N];
}MSG;

typedef struct node{
struct sockaddr_in addr;
struct node *next;
}listnode, *linklist;

typedef struct sockaddr SA;

linklist linklist_create();

void process_login(int sockfd, linklist H, struct sockaddr_in cli_addr, MSG *msg);
void process_chat(int sockfd, linklist H, struct sockaddr_in cli_addr, MSG *msg);
void process_quit(int sockfd, linklist H, struct sockaddr_in cli_addr, MSG *msg);

int main(int argc, char **argv)
{
int sockfd;

struct sockaddr_in ser_addr, cli_addr;
if(argc != 3)
{
printf("plz input %s <ip> <port>\n", argv[0]);
exit(-1);
}

if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("socket");
exit(-1);
}

bzero(&ser_addr, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_addr.s_addr = inet_addr(argv[1]);
ser_addr.sin_port = htons(atoi(argv[2]));

if(bind(sockfd, (SA *)&ser_addr, sizeof(ser_addr)) == -1)
{
perror("bind");
exit(-1);
}

pid_t pid;
MSG msg;

if((pid = fork()) < 0)
{
perror("fork");
exit(-1);
}

else if(pid == 0)//child sendto
{
msg.type = B;
strcpy(msg.name, "server");
while(1)
{
printf(">");
fgets(msg.data, N, stdin);
msg.data[strlen(msg.data) - 1] = '\0';

sendto(sockfd, &msg, sizeof(MSG), 0, (SA *)&ser_addr, sizeof(ser_addr));
}
}
else //parent recvfrom
{
linklist H = linklist_create();
socklen_t len = sizeof(cli_addr);
while(1)
{
recvfrom(sockfd, &msg, sizeof(MSG), 0, (SA *)&cli_addr, &len);//MSG type : L B Q name data : chat

printf("type = %d, name = %s, data = %s\n", msg.type, msg.name, msg.data);

switch (msg.type)
{
case L:
process_login(sockfd, H, cli_addr, &msg);
break;
case B:
process_chat(sockfd, H, cli_addr, &msg);
break;
case Q:
process_quit(sockfd, H, cli_addr, &msg);
}
}
}
close(sockfd);
return 0;
}


linklist linklist_create()
{
linklist H;

H = (linklist)malloc(sizeof(listnode));
H->next = NULL;


return H;
}
/**/
void process_login(int sockfd, linklist H, struct sockaddr_in cli_addr, MSG *msg)
{
linklist p = H->next;

//XXXX login
sprintf(msg->data, "%s login", msg->name);

while(p)
{
sendto(sockfd, msg, sizeof(MSG), 0, (SA *)&p->addr, sizeof(p->addr));
p = p->next;
}

p = (linklist)malloc(sizeof(listnode));

p->next = H->next;
H->next = p;
p->addr = cli_addr;
return;
}
void process_chat(int sockfd, linklist H, struct sockaddr_in cli_addr, MSG *msg)
{

//XXXX said XXXX
char buf[N] = {0};
sprintf(buf, "%s said %s", msg->name, msg->data);
strcpy(msg->data, buf);

linklist p = H->next;
while(p)
{
puts("--------");
if(memcmp(&cli_addr, &p->addr, sizeof(cli_addr)) != 0)
{
sendto(sockfd, msg, sizeof(MSG), 0, (SA *)&p->addr, sizeof(p->addr));
}
p = p->next;
}
return;
}
void process_quit(int sockfd, linklist H, struct sockaddr_in cli_addr, MSG *msg)
{
linklist p = H, q;
sprintf(msg->data, "%s offline", msg->name);

while(p->next)
{
if(memcmp(&cli_addr, &p->next->addr, sizeof(p->next->addr)) == 0)
{
q = p->next;
p->next = q->next;
free(q);
}
else
{
sendto(sockfd, msg, sizeof(MSG), 0, (SA *)&p->next->addr, sizeof(p->next->addr));
p = p->next;
}
}

return;
}


client.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <strings.h>
#include <signal.h>

#define N 128
#define L 1
#define B 2
#define Q 3

typedef struct{
int type;
char name[N];
char data[N];
}MSG;

typedef struct sockaddr SA;

int main(int argc, char **argv)
{
int sockfd;

MSG msg;
struct sockaddr_in ser_addr;
if(argc != 3)
{
printf("plz input %s <ip> <port>\n", argv[0]);
exit(-1);
}

if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("socket");
exit(-1);
}

bzero(&ser_addr, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_addr.s_addr = inet_addr(argv[1]);
ser_addr.sin_port = htons(atoi(argv[2]));


/****login******/
memset(&msg, 0, sizeof(MSG));
printf("input your name > ");
fgets(msg.name, N, stdin);
msg.name[strlen(msg.name) - 1] = '\0';
msg.type = L;

sendto(sockfd, &msg, sizeof(MSG), 0, (SA *)&ser_addr, sizeof(ser_addr));

/***********/
pid_t pid;
if((pid = fork()) < 0)
{
perror("fork");
exit(-1);
}
else if(pid == 0)//child sendto B or Q
{
while(1)
{
printf(">");
fgets(msg.data, N, stdin);
if(strncmp(msg.data, "quit", 4) == 0)
{
msg.type = Q;
sendto(sockfd, &msg, sizeof(MSG), 0, (SA *)&ser_addr, sizeof(ser_addr));
kill(getppid(), SIGKILL);
exit(0);
}
else
{
msg.type = B;
sendto(sockfd, &msg, sizeof(MSG), 0, (SA *)&ser_addr, sizeof(ser_addr));
}
}
}
else
{
while(recvfrom(sockfd, &msg, sizeof(MSG), 0, NULL, NULL) > 0)
{
//msg.data
printf("%s\n", msg.data);
}
}
close(sockfd);
return 0;
}

wmlkl
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux编程学习笔记：网络编程
a568713197的博客
02-03 3407
一、Linux网络概述     Linux为用户提供了完善的、强大的网络功能     1、完善的内置网络，其他操作系统不包含如此紧密的和内核结合的网络部分     2、Linux免费提供了大量支持Internet的软件，Internet是在Unix领域中建立并繁荣起来的，在这方面使用Linux是相当方便的，用户能用Linux与世界上的其他人通过Internet网络进行通信     3、用户...
socket编程之bind()函数
weixin_30407099的博客
12-21 2055
名称 bind() 把名字和套接字相关联 使用格式 #include <sys/types.h> #include <sys/socket.h> int bind(int sockfd, const struct sockaddr *addr,socklen_t *addrlen); 功能描述 当用socket()函数创建套接字以后，套接字在名称空...
Linux网络编程
gogoingad的博客
01-28 1387
Socket服务器和客户端的开发步骤：
Linux网络编程——UDP编程
weixin_52109967的博客
08-15 2470
UDP通信的相关函数和实际案例代码。
Linux网络编程 | UDP编程
大柳_的博客。
06-01 2707
浅谈UDP。UDP是一种不可靠的、无连接的、数据报服务。发送端应用程序每执行一次写操作，UDP 模块就将其封装成一个 UDP 数据报发送。接收端必须及时针对每一个 UDP 数据报执行读操作，否则就会丢包。并且，如果用户没有指定足够的应用程序缓冲区来读取 UDP 数据，则 UDP 数据将被截断。 因此，采用UDP协议时必须要求接收端可以一次性收取完发送端一次发送的数据，不然就会造成数据丢失。 2.客户端 3.输出结果 UDP是一种无连接的传输方式，所以可以多个客户端同时发送。 服务器端关闭立马重启，客户
Linux网络编程_01_网络基础
柿子__
07-19 1326
Linux网络编程-网络基础
Linux 网络编程学习笔记——四、HTTP 通信
热门推荐
BeZer0的学习笔记
03-22 1万+
在 HTTP 通信链上，客户端和目标服务器之间通常存在某些中转代 理服务器，它们提供对目标资源的中转访问。一个 HTTP 请求可能被多个代理服务器转发，后面的服务器称为前面服务器的上游服务器。
Linux网络编程 | TCP详解
大柳_的博客。
06-01 3282
总结TCP相关问题TCP是一种面向链接的，可靠的，流式服务。TCP 字节流的特点，发送端执行的写操作次数和接收端执行的读操作次数之间没有任何数量关系，应用程序对数据的发送和接收是没有边界限制的。 此时可以看到 此时可以看到，发送端分别发送了hello world linux，而在接收端一次性收取完成，无法有效区分出三个单词，这就造成粘包问题 解决方法： 1.发送端每次发送之后要收到接收端的回复再进行下一次发送 2.制定协议，比如长宽高分别用【长】【宽】【高】表示。可靠性： 超时重传，应答确认，乱序重排流量控
Linux网络编程基础3：数据读写
sinat_28294665的博客
01-27 1553
tcp udp的数据读写
Linux网络编程.pdf
07-22
Linux网络编程
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
Linux 三十六章
一怀明月的博客
05-17 1213
信号量 sem_init sem_destroy sem_wait sem_post 基于环形队列的CP问题 环形队列的生产者消费者模型 线程池 localtime时间戳转化 mkdir系统调用 bind绑定成员函数 懒汉饿汉单例模式 懒汉模式： 饿汉模式： 懒汉和饿汉相同点： 线程池源码实现
Linux “如何添加用户/组和修改用户/组”
y2162484776的博客
05-20 544
我们首先要知道Linux中用户时必须的吗！？？？用户是标识计算机的资源归属的。
【linux】linux中免交互命令expect原理与应用实战
景天科技苑
05-20 3418
Expect 是基于 Tcl 的相对简单的一个免费的脚本编程工具语言，用来实现 自动和交互式任务程序进行通信，无需人的手工干预。比如 SSH、FTP 等，这些 程序正常情况都需要手工与它们进行交互，而使用 Expect 就可以模拟人手工交 互的过程，实现自动的和远程的程序交互，从而达到自动化运维的目的。
Linux——进程信号
m0_75186846的博客
05-19 1039
介绍了Linux信号的产生、保存与处理
Linux：网络管理命令之ss
hhd1988的专栏
05-17 838
Linux：网络管理命令之ss
linux基于LD_PRELOAD机制的内存泄露检测工具
Hi20240217的博客
05-17 767
Valgrind影响性能且某些程序会报错,同时我们希望跳过初始化阶段,在程序稳定运行之后再去检测内存是否会持续增涨,为了更高效的记录内存分配情况,采用b+树.该程序会拦截malloc,free,calloc,realloc,new,delete。记录10层的PC指针,方便解析脚本定位调用的代码位置.
【Linux】-Zookeeper安装部署[17]
最新发布
weixin_63106307的博客
05-20 501
除了为Hadoop和Hbase提供协调服务外，ZooKeeper也被其他软件采用作为其分布式状态一致性的依赖，比如Kafka，又或者一些软件项目中，也经常能见到ZooKeeper作为一致性协调服务存在。10、【在node1、node2、node3上分别执行】启动zookeeper。11、【在node1、node2、node3上分别执行】检查zookeeper。7、【node1上操作】 将zookeeper 复制到node2和node3。2、【node1上操作】下载ZooKeeper安装包，并解压。
linux 网络编程
03-17
Linux 网络编程是在 Linux 操作系统中使用网络通信协议进行编程的过程。它可以使用各种编程语言，如 C、C++、Python、Java 等，来实现各种网络应用程序。常用的网络编程接口有 sockets，它提供了一组标准的接口来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值