从零快速解析之Tinyhttp源码解析(一)

Tinyhttpd详解 本文先从TCP套接字讲起,其次回顾http报文,最后将tinyhttp的源代码进行解析 第一部分 Linux网络编程:TCP socket套接字详解 标识通信端点(对外):IP地址+端口号 操作系统/进程如何管理套接字(对内):套接字描述符 一个进程中的多线程对一个套接字的使用无计数 基本概念 1.socket socket这个词可以表示很多概念: 在TCP/IP协议中,“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程,“IP地址+端口号”就称为socket。 在TCP协议中,建立连接的两个 阅读详情

前言

在笔者解析nginx之前,需要先拿简单的Tinyhttp练手,这篇和笔者以前的u-boot一样,也是从零解析,不参考任何别人解析的文章。培养如何解决问题的方法才是更加重要的,因为Tinyhttp实在太简单了,甚至笔者之前的UNP篇的server模型里面都有比它复杂的。所以笔者打算花费3天,每天1-2个小时来完成这个系列。

1. HTTP协议

UNP中没有涉及到应用层协议,但是如果想编写一个Web Server,必须熟悉HTTP协议,虽然该协议比较简单,如果想全面了解还是推荐《HTTP权威解析》,这里笔者推荐一篇简单介绍的博文:关于HTTP协议,一篇就够了,应付TinyHttp完全足够了,这里不赘述了。

2. 下载,编译和运行

要解析之前,首先应该将TinyHttp运行起来。首先下载源码:Tiny HTTPd,接着解压看看里面的文件:

[root@localhost tinyhttpd-0.1.0]# ls
htdocs  httpd  httpd.c  Makefile  README  simpleclient.c
[root@localhost tinyhttpd-0.1.0]# 

笔者还是推荐看看README,里面说不定有彩蛋:

I wrote this webserver for an assignment in my networking class in 1999. We were told that at a bare minimum the server had to serve pages, and told that we would get extra credit for doing “extras.” Perl had introduced me to a whole lot of UNIX functionality (I learned sockets and fork from Perl!), and O’Reilly’s lion book on UNIX system calls plus O’Reilly’s books on CGI and writing web clients in Perl got me thinking and I realized I could make my webserver support CGI with little trouble.作者的自述,人家在1999年写这个只是课堂的作业。我在2018年相隔19年之后解析人家的课堂作业.^_^

修改Makefile为:

 all: httpd
  
httpd: httpd.c
        gcc  -lpthread -o httpd httpd.c

clean:
        rm httpd

编译并运行:

[root@localhost tinyhttpd-0.1.0]# make        
gcc  -lpthread -o httpd httpd.c
httpd.c: In function ‘main’:
httpd.c:495:40: warning: passing argument 3 of ‘pthread_create’ from incompatible pointer type [-Wincompatible-pointer-types]
  if (pthread_create(&newthread , NULL, accept_request, client_sock) != 0)
                                        ^~~~~~~~~~~~~~
In file included from httpd.c:25:0:
/usr/include/pthread.h:234:12: note: expected ‘void * (*)(void *)’ but argument is of type ‘void (*)(int)’
 extern int pthread_create (pthread_t *__restrict __newthread,
            ^~~~~~~~~~~~~~
httpd.c:495:56: warning: passing argument 4 of ‘pthread_create’ makes pointer from integer without a cast [-Wint-conversion]
  if (pthread_create(&newthread , NULL, accept_request, client_sock) != 0)
                                                        ^~~~~~~~~~~
In file included from httpd.c:25:0:
/usr/include/pthread.h:234:12: note: expected ‘void * restrict’ but argument is of type ‘int’
 extern int pthread_create (pthread_t *__restrict __newthread,
            ^~~~~~~~~~~~~~
//上面这些警告都可以忽略,因为我们确切的知道这些警告没有影响
[root@localhost tinyhttpd-0.1.0]# ./httpd 
httpd running on port 43545

然后运行浏览器试试看效果,笔者使用的平台是fedora 27:
这里写图片描述
这里写图片描述
这里写图片描述

有些人发现主页打不开,或者颜色出不来,注意地址的端口号应该和server绑定的port一致,另外也要注意perl-CGI的相关组件是否已经安装了。_

3. 捕捉HTTP数据包

可以发现成功的实现了功能,在解析源代码之前,需要以刚刚打开主页,及显示红色为例。进行HTTP数据包的捕捉。笔者使用的火狐浏览器,F12的开发者模式非常方便,重复刚刚的过程,捕捉相关的数据包:

3.1 主页相关的数据包

这里写图片描述
这里写图片描述

3.2 红色页相关的数据包

这里写图片描述
这里写图片描述
这里写图片描述

4. 源码解析

4.1 主体架构
int main(void)                                                                                                       
{                                                                                                                    
 int server_sock = -1;                                                                                               
 u_short port = 0;                                                                                                   
 int client_sock = -1;                                                                                               
 struct sockaddr_in client_name;                                                                                     
 int client_name_len = sizeof(client_name);                                                                          
 pthread_t newthread;                                                                                                
                                                                                                                     
 server_sock = startup(&port);                                                                                       
 printf("httpd running on port %d\n", port);                                                                         
                                                                                                                     
 while (1)                                                                                                           
 {                                                                                                                   
  client_sock = accept(server_sock, (struct sockaddr *)&client_name,   &client_name_len);                                                                                                                                                                                                            
  if (client_sock == -1)                                                                                             
   error_die("accept");                                                                                              
 /* accept_request(client_sock); */                                                                                  
  if (pthread_create(&newthread , NULL, accept_request, client_sock) != 0)                                            
   perror("pthread_create");                                                                                         
 }                                                                                                                   
                                                                                                                     
 close(server_sock);                                                                                                 
                                                                                                                     
 return(0);                                                                                                          
}   
int startup(u_short *port)                                                                                           
{                                                                                                                    
 int httpd = 0;                                                                                                      
 struct sockaddr_in name;                                                                                            
                                                                                                                     
 httpd = socket(PF_INET, SOCK_STREAM, 0);                                                                            
 if (httpd == -1)                                                                                                    
  error_die("socket");                                                                                               
 memset(&name, 0, sizeof(name));                                                                                     
 name.sin_family = AF_INET;                                                                                          
 name.sin_port = htons(*port);                                                                                       
 name.sin_addr.s_addr = htonl(INADDR_ANY);                                                                           
 if (bind(httpd, (struct sockaddr *)&name, sizeof(name)) < 0)                                                        
  error_die("bind");                                                                                                 
 if (*port == 0)  /* if dynamically allocating a port */                                                             
 {                                                                                                                   
  int namelen = sizeof(name);                                                                                        
  if (getsockname(httpd, (struct sockaddr *)&name, &namelen) == -1)                                                  
   error_die("getsockname");                                                                                         
  *port = ntohs(name.sin_port);                                                                                      
 }                                                                                                                   
 if (listen(httpd, 5) < 0)                                                                                           
  error_die("listen");                                                                                               
 return(httpd);                                                                                                      
}    

上面的代码和笔者之前记录的网络编程之Threads实验一模一样,就是很简单的thread server模型,笔者在这里就不赘述了。再看看accept_request函数,在该函数里面需要实现HTTP协议了:

void accept_request(int client)                                                                                      
{                                                                                                                    
 char buf[1024];                                                                                                     
 int numchars;                                                                                                       
 char method[255];                                                                                                   
 char url[255];                                                                                                      
 char path[512];                                                                                                     
 size_t i, j;                                                                                                        
 struct stat st;                                                                                                     
 int cgi = 0;      /* becomes true if server decides this is a CGI                                                   
                    * program */                                                                                     
 char *query_string = NULL;                                                                                          
                                                                                                                     
 numchars = get_line(client, buf, sizeof(buf));                                                                      
 i = 0; j = 0;                                                                                                       
 while (!ISspace(buf[j]) && (i < sizeof(method) - 1))                                                                
 {                                                                                                                   
  method[i] = buf[j];                                                                                                
  i++; j++;                                                                                                          
 }                                                                                                                   
 method[i] = '\0';                                                                                                   
                                                                                                                     
 if (strcasecmp(method, "GET") && strcasecmp(method, "POST"))                                                        
 {                                                                                                                   
  unimplemented(client);                                                                                             
  return;                                                                                                            
 }                                                                                                                   
                                                                                                                     
 if (strcasecmp(method, "POST") == 0)                                                                                
  cgi = 1;                                                                                                           
                                                                                                                     
 i = 0;                                                                                                              
 while (ISspace(buf[j]) && (j < sizeof(buf)))                                                                        
  j++;                                                                                                               
 while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf)))                                              
 {                                                                                                                   
  url[i] = buf[j];                                                                                                   
  i++; j++;                                                                                                          
 }                                                                                                                   
 url[i] = '\0';                                                                                                      
                                                                                                                     
 if (strcasecmp(method, "GET") == 0)                                                                                 
 {                                                                                                                   
  query_string = url;                                                                                                
  while ((*query_string != '?') && (*query_string != '\0'))                                                          
   query_string++;                                                                                                   
  if (*query_string == '?')                                                                                          
  {                                                                                                                  
   cgi = 1;                                                                                                          
   *query_string = '\0';                                                                                             
   query_string++;                                                                                                   
  }                                                                                                                  
 }                                                                                                                   
                                                                                                                     
 sprintf(path, "htdocs%s", url);                                                                                     
 if (path[strlen(path) - 1] == '/')                                                                                  
  strcat(path, "index.html");                                                                                        
 if (stat(path, &st) == -1) {                                                                                        
  while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */                                          
   numchars = get_line(client, buf, sizeof(buf));                                                                    
  not_found(client);                                                                                                 
 }                                                                                                                   
 else                                                                                                                
 {                                                                                                                   
  if ((st.st_mode & S_IFMT) == S_IFDIR)                                                                              
   strcat(path, "/index.html");                                                                                      
  if ((st.st_mode & S_IXUSR) ||                                                                                      
      (st.st_mode & S_IXGRP) ||                                                                                      
      (st.st_mode & S_IXOTH)    )                                                                                    
   cgi = 1;                                                                                                          
  if (!cgi)                                                                                                          
   serve_file(client, path);                                                                                         
  else                                                                                                               
   execute_cgi(client, path, method, query_string);                                                                  
 }                                                                                                                   
                                                                                                                     
 close(client);                                                                                                      
}    
4.2 accept_request函数细节

在看get_line之前必须明白,比如我们打开主页的时候,从client接收到的数据格式如下图所示(该图来自关于HTTP协议,一篇就够了),因为HTTP协议是无连接的,我们只要在每个client中对每行单独判读处理,就可以正确读取数据,并作出相应动作:
  这里写图片描述

/**********************************************************************/                                             
/* Get a line from a socket, whether the line ends in a newline,                                                     
 * carriage return, or a CRLF combination.  Terminates the string read                                               
 * with a null character.  If no newline indicator is found before the                                               
 * end of the buffer, the string is terminated with a null.  If any of                                               
 * the above three line terminators is read, the last character of the                                               
 * string will be a linefeed and the string will be terminated with a                                                
 * null character.                                                                                                   
 * Parameters: the socket descriptor                                                                                 
 *             the buffer to save the data in                                                                        
 *             the size of the buffer                                                                                
 * Returns: the number of bytes stored (excluding null) */                                                           
/**********************************************************************/                                             
int get_line(int sock, char *buf, int size)                                                                          
{                                                                                                                    
 int i = 0;                                                                                                          
 char c = '\0';                                                                                                      
 int n;                                                                                                              
                                                                                                                     
 while ((i < size - 1) && (c != '\n'))                                                                               
 {                                                                                                                   
  n = recv(sock, &c, 1, 0);                                                                                          
  /* DEBUG printf("%02X\n", c); */                                                                                   
  if (n > 0)                                                                                                         
  { 
   //每次读到字符,判断是否是空白符                                                                                                                 
   if (c == '\r')                                                                                                    
   {                                                                                                                 
    n = recv(sock, &c, 1, MSG_PEEK);                                                                                 
    /* DEBUG printf("%02X\n", c); */
    //上面的MSG_PEEK,并不实际从缓冲中去除该字节,所以下面的recv依然读取了该字节,也就是\n                                                                       
    if ((n > 0) && (c == '\n'))                                                                                      
     recv(sock, &c, 1, 0);                                                                                           
    else                                                                                                             
     c = '\n';                                                                                                       
   }                                                                                                                 
   buf[i] = c;                                                                                                       
   i++;                                                                                                              
  }                                                                                                                  
  else
   //如果client shutdown,此时recv残留在Pipe中的数据之后,返回0.然后c=`\n`来结束循环                                                                                                               
   c = '\n';                                                                                                         
 }                                                                                                                   
 buf[i] = '\0';                                                                                                      
                                                                                                                     
 return(i);                                                                                                          
}                   

其实上面原作者的注释已经比较清楚了,强调一点就是每次读取一行,且该行内如果保留\r\n(如果有),显然这里对应报文中的请求行和请求头部,最后请求数据每次读取size大小的数据,且以\0结尾。注:请求数据此时可能不是以一行为单位进行读取。

今天花了一个半小时,就到这里吧,明天继续。_

Doubango代码学习(一):开始篇 学习原因: 最近公司动荡,有一种深深的危机感,需要储备点自己的知识了。由于目前笔者所做的是RCS/IMS,代码都是公司自己私有的,还是学习点开源的比较好。 查了一下开源的方案,RCS开源客户端特别的少,试用了一下功能不是很好。里面相对Doubango靠谱的多,但它是一个IMS的开源方案,距离RCS5.1还有一段路要走。 因此就有了学习并开发doubango到RCS5.1想法。虽然任务艰巨,但 阅读详情

相关推荐

OpenSceneGraph 快速入门指南及源码解析

本文还有配套的精品资源,点击获取 简介:OpenSceneGraph(OSG)是一个针对实时应用设计的高性能3D图形库,适合科学可视化、虚拟现实和游戏开发。该入门指南通过示例和源代码帮助新手深入理解OSG的使用。源码包含在Data、Examples、VisualStudio和Linux32目录中,每个目录提供了资源文件、示例程序、编译配置文件和平台特定依赖等,涵盖OSG的核...

weixin_42466857的博客 3702

从零快速解析之Tinyhttp源码解析(二)

4.2 accept_request函数细节   顺着上一篇的接着分析,再次贴出来accept_request void accept_request(int client) { ...

LoveStackover的博客 237

doubango框架源码

Doubango 是一个基于3GPP IMS/RCS 并能用于嵌入式和桌面系统的开源框架。该框架使用ANSCI-C编写,具有很好的可移植性。并且已经被设计成非常轻便且能有效的工作在低内存和低处理能力的嵌入式系统上。苹果系统上的idoubs功能就是基于此框架编写。

Tinyhttpd源码解析

简介 Tinyhttpd是一轻量级的web服务器,它由美国学生J. David Blackstone于1999年在学习网络课程时编写。源码不到500行,非常适合学习Web编程和Linux/Unix编程接口。 分析 Tinyhttpd执行流程如下图: 主线程完成socket的创建、绑定、端口监听、创建子线程处理每一个请求。代码如下: int main(void) { int

码到功成 879

tinyhttpd的详细注释版,十分适合入门者学习的一个项目

tinyhttpd的详细注释版,十分适合入门者学习的一个项目

利用docx4j与docx4j-ImportXHTML高效实现HTML到Word的自动化转换

本文详细介绍了如何利用docx4j与docx4j-ImportXHTML库,在Java环境中高效实现HTML到Word文档的自动化转换。内容涵盖从环境搭建、核心依赖配置,到集成Spring Boot REST API的完整实战流程,并深入解析了处理图片、CSS样式、字体设置以及使用模板保证样式统一等高级技巧与常见问题解决方案,帮助开发者构建稳定的文档自动化生成流水线。

cnn8visionary的博客 367

从零快速解析之Tinyhttp源码解析(三)

4.2.2 execute_cgi函数细节 void execute_cgi(int client, const char *path, const char *method, const char *query_string) ...

LoveStackover的博客 207

TMS320C6678开发笔记1-6---C6678单核烧写程序

第6节 单核烧写加载程序 6.1节 TI参考文档 参考文档:《KeystoneI Bootloader Resources and FAQ》讲的非常好,建议一定要看 https://processors.wiki.ti.com/index.php/KeystoneI_Bootloader_Resources_and_FAQ#Direct_Boot_Examples_.28without_IBL.29 里面有三个工程: C6678 EVM SPI boot example C6657 EVM ..

kunkliu的博客 5699

通过我写的文章来认识我,博客文章快速导航(慢慢整理)

1. 前言   本博客持续更新,本篇是博主所写文章的快速索引。   不得不说,笔者学习的东西很多,很杂,有些东西的学习,并不是笔者自愿的,也和笔者的经历有关吧。   特别强调笔者以前的博客为bushipeien,某天脑门一热想和过去的排版及方向告别,重新开始在该博客更新。为了节约时间,可能不会将以前的文章重新排版整理到本博客。最后本文也单独列出博主认为比较好的,能够反映博主学习思考过程的文章...

LoveStackover的博客 756

链家二手房信息爬取(内附完整代码)

链家二手房信息爬取1.简介2. 爬虫思路2.1 网页分析2.2 详情页分析2.3 不同页码的爬取2.4 解决链家只显示100页数据2.5 简单的反爬与进度条显示3. 总结 1.简介   最近帮同学爬取了链家在售二手房的信息,这是本人学习爬虫以来爬取数据最多的一次,就想着写个博客记录一下。   本次爬虫是利用python+jupyter notebook实现的,用到的第三方库如下: import pandas as pd # 数据存储 import requests # 网页内容获取 import re #

qq_46256922的博客 3万+

AxMath行间公式转化为office公式求和符号以及编号显示问题

AxMath行间公式转化为office公式求和符号以及编号显示问题问题描述解决方法 问题描述 首先打出axmath公式,如下: 转换后的OfficeMath公式: 字体先不说,word公式字体默认cambria math且无法编辑。比较难受的一点是求和符号与后面的 ai+bi2a_i+b_i^2ai​+bi2​比例不匹配啊!正常的比例应该是: (虽然也不太正常,将就下) 解决方法 点击变换后的office公式右侧,选择更改为"显示" 可以看到,多了一些软回车符号(⬇),如果你想删除它,不要直接选中

weixin_43543177的博客 4674

剖析tinyhttp源码

1.支持客户/服务器模式(C/S)(所有客户端都通过访问服务器来获取所需的资源) C/S模型:服务器启动后,首先创建一个(或者)多个接听套接字(socket),并调用函数bind函数将其绑定到服务器感兴趣的端口上,然后调用listen函数等待客户端的连接。服务器稳定运行后,客户端就可以调用connect函数向服务器发起连接了。客户端连接请求是随机到达的异步事件,服务器使用某种IO技术来接听这一事

lxn18392641463的博客 571

【数据集7】全球人类住区层GHSL数据详解

全球人类住区层GHSL数据详解

WW、forever的博客 2256

从零手写C语言多线程HTTP服务器:深入理解网络编程与并发处理

网络编程是构建现代分布式系统的基石,其核心在于理解客户端与服务器之间通过套接字(Socket)进行通信的基本原理。HTTP协议作为应用层协议,定义了Web通信的请求-响应模型,而服务器并发处理能力则是支撑高可用服务的关键技术。通过实现一个多线程HTTP服务器,开发者可以深入掌握Socket编程、HTTP协议解析以及线程同步等核心概念,这对于构建高性能网络服务、理解Nginx等成熟服务器框架的底层机制具有重要价值。本文以C语言为例,结合**多线程**和**线程池**技术,详细解析如何构建一个能够处理并发连接的

weixin_30443813的博客 394

YOLO26改进策略【YOLO和Mamba】| 替换骨干 Mamba-YOLO26-L !!! 最新的发文热点

Vision Clue Merge模块在Mamba - YOLO模型中同样重要,主要负责在模型的下采样过程中处理特征图,为后续的特征融合和目标检测任务提供更有效的信息。

Limiiiing的博客 476

【MATLAB代码】二维平面的TOA定位,GDOP(几何精度因子)和CRLB(克拉美罗下界)计算与输出

本文介绍了一个MATLAB程序,用于计算二维定位场景中的几何精度因子(GDOP)和克拉美罗下界(CRLB)。该程序针对单目标和四个锚点配置,通过网格扫描法计算空间各点的GDOP分布,并以等高线图可视化展示。程序还可计算特定位置的理论定位精度下限(CRLB),输出X/Y方向标准差和GDOP值。核心算法通过构建几何矩阵和费舍尔信息矩阵实现,考虑了测量误差影响,并处理了特殊位置情况。程序提供了完整的源代码和参数修改说明,适用于定位系统精度分析。

985工科博士毕业,专攻定位、导航和滤波等算法研究。从业10年,主要使用MATLAB 804

iloader:免费 iOS 侧载工具,3 步装好 SideStore

每次侧载都要手动把 rppairing 和 lockdown 文件拖进沙盒?iloader 是一款免费开源的 iOS 侧载工具,把签名、装 App、放配对文件这三件最容易翻车的事收成了几个按钮。它适合第一次给 iPhone 侧载的人,也适合手里攥着 IPA 文件想快速上机的你:登录 Apple ID、点一下,剩下的交给它。 ## 它替你搞定了什么 - **一键装好 SideStore**:稳定

gitblog_00143的博客 180

基于matlab的主成分分析的人脸二维码识别系统

人脸识别因其在系统安全验证、信用验证、刑侦跟踪、身份管理、视频会议、人机交互、智能家居等方面的巨大应用前景,成为当前模式识别和人工智能领域越来越热门的一个研究方向。随着安全入口控制和二维码智能扫描应用需求的快速增长,基于二维码识别的生物人脸统计识别技术也引起了人们的重视。本案例将详细讲解基于主成分分析的人脸特征提取的原理与方法,并将其与 QR 二维码的编解码进行结合,将 MATLAB 作为工具平台,调用 QR 二维码编解码应用程序,进而实现一个人脸二维码自动识别的系统原型。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 981

【附下载链接】CoolPack 1.5.0 制冷仿真软件:从安装到上手的完整指南

CoolPack 1.5.0 是一款制冷仿真软件,面向学习和从事制冷设计的用户:查物性、画焓湿图、做系统选型与仿真,一份安装包全部搞定。 ## 适合谁用:从课程作业到实际设计 如果你正在学制冷相关专业,需要频繁翻查制冷剂数据、核算循环,CoolPack 就是为这类场景准备的;如果你已经从业,手头有选型或验证系统表现的活儿,它同样能接住。原本要翻手册、手算的步骤,在这里被整合进一个界面里。 #

gitblog_00617的博客 224

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Tokio 运行时实战指南:用 Rust 编写可靠异步应用的事件驱动 I/O 平台

Tokio 是 Rust 生态中用于编写可靠、异步、精简应用的运行时平台。本文以仓库根目录 [README.md](https://link.gitcode.com/i/4a62920e7443b89a78cb70847a5bc3d9) 为骨架,结合 [tokio](https://link.gitcode.com/i/7a9bb76c77464b8eae41a8461f46bf63) 核心源码、

gitblog_00347的博客 240

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

TinyHttpd源码精读(一)

本文章主要是记录自己对于TinyHttpd的源码的阅读理解。

weixin_44331218的博客 648

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

web浏览器无插件播放实时音视频技术---SIPML5(二)

a

chenhande1990chenhan的专栏 6020

tinyhttpd详解

tinyhttpd下载链接tinyhttpd 一. socket就是插座(套接字),运行在计算机中的两个程序通过socket建立起一个通道,数据在通道中传输,分为流socket和数据报socket。 1.流socket基于TCP协议,双向字节流的通道,传输数据不会丢失、不会重复、顺序也不会错乱。提供可靠性传输,实行“顺序控制”或“重发控制”机制。此外还具备“流控制(流量控制)”、“拥塞控制”、提高网络利用率等众多功能。TCP协议面向连接,可靠的传输层协议,分段,重组,重传,滑动窗口,适用于对可靠性要求较

qq_56320213的博客 1205

Tinyhttpd终极指南:5分钟快速搭建你的第一个HTTP服务器

想要快速了解HTTP服务器的工作原理吗?Tinyhttpd超轻量级HTTP服务器正是你入门网络编程的完美选择!这个仅有500行代码的微型Web服务器,不仅能帮助你理解服务器程序的本质,还能让你在短时间内搭建起自己的HTTP服务。 ## 为什么选择Tinyhttpd作为学习工具? Tinyhttpd诞生于1999年,由J. David Blackstone编写,虽然代码量极小,但功能相当完整。它

gitblog_00209的博客 739

doubango的一二

1、doubango官网:http://www.doubango.org/ 2、doubango是一个开源的VOIP基础平台, 并能用于嵌入式和桌面系统的开源框架,该框架使用ANSCI-C编写,具有很好的可移植性。 3、根据doubango的框架、特点与linphone的对比,显然doubango更适合做视频会议系统和视频会议终端的选择,理由?根据linphone的rtp会话管理可见只适合

sphone89的专栏 1万+

一 从协议栈结构说起

自顶向下与自底向上 软件设计的两种方法不过于自顶向下与自底向上。 对于自顶向下而言,先设计好用户接口,再往下延伸至各个功能块的具体实现。而对于自底向上而言,自然是有了设计好的各个功能代码块,再将这些功能代码块拼接成具体的用户接口,然而实际的软件实践中,这两种方法是同时展开的,因为无论单独实施哪一种,都是有所缺陷,会令人陷入某种困境。 设计软件如此,那么在分析一款软件的时候,结合自顶向下与自底

argpunk的专栏 3167
上一篇: 网络编程之I_O Multiplexing总结(四)
下一篇: 从零快速解析之Tinyhttp源码解析(二)
LoveStackover
博客等级 码龄9年 14粉丝 57原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值