中国电信CDN规范解析INDEX文件的C代码实现

最新推荐文章于 2022-09-29 19:45:28 发布
最新推荐文章于 2022-09-29 19:45:28 发布
阅读量2.6k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langeldep/article/details/8870517
版权


编译命令  g++ -g -o parseIndex parseIndex.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <assert.h>


typedef unsigned char BYTE;

#pragma pack(1)
typedef struct _IndexHead
{
	char Indentify[32];
	BYTE MajorVersion;
	BYTE MinorVersion;
	char Generation[24];
	BYTE Count;
	char Creator[32];

}IndexHead;

typedef struct _Tag
{
	unsigned int   flag;
	unsigned short vlen;
}Tag;


typedef struct 
{
	unsigned int flag;
	const char*  name;
}_TagInfo;

#pragma pack()

_TagInfo TagInfo[] = {
	{0x00 	        ,"Skip one byte"}, 
	{0x11000001 	,"Index Info"}, 
	{0x110001FF 	,"Content Info"}, 
	{0x15000105 	,"Source URI"}, 
	{0x13000107	    ,"Index Type"}, 
	{0x13000106 	,"File Type"}, 
	{0x1300010E 	,"Video Frame Rate Tickets"}, 
	{0x1300010F 	,"Video Frame Rate Time Scale"}, 
	{0x1300010C 	,"Video Horizontal Size"}, 
	{0x1300010D 	,"Video Vertical Size"}, 
	{0x13000116	    ,"Elementary Stream Count"}, 
	{0x13000109 	,"Bitrate"}, 
	{0x13000117 	,"Sub File Count"}, 
	{0x13000108	    ,"Schedule Fragment Count"}, 
	{0x1500010A	    ,"Schedule Start Time"}, 
	{0x1300010B	    ,"Schedule Fragment Duration"}, 
	{0x13000118	    ,"Time Shift Time"}, 
	{0x1400011B 	,"Open for Write"}, 
	{0x1500011C	    ,"ProviderID"}, 
	{0x1500011D 	,"ContentID"}, 
	{0x1500011E	    ,"PhysicalChannelID"}, 
	{0x110004FF 	,"Control Info"}, 
	{0x16000401 	,"Program Association Table"}, 
	{0x16000403 	,"Program Map Table"}, 
	{0x15000410	    ,"SDP"}, 
	{0x110005FF 	,"Sub File Info"}, 
	{0x13000501 	,"Sub File ID"}, 
	{0x15000502 	,"Sub File URI"}, 
	{0x13000503 	,"Sub File Type"}, 
	{0x13000504 	,"Sub File Data Start"}, 
	{0x13000505 	,"Sub File Data end"}, 
	{0x1300050A 	,"Sub File Duration"}, 
	{0x1200050C 	,"Sub File Scale"}, 
	{0x13000520	    ,"Sub File IDR Frames Count"}, 
	{0x1300050E 	,"Sub File I Frames Count"}, 
	{0x1300050F 	,"Sub File P Frames Count"}, 
	{0x13000510 	,"Sub File B Frames Count"}, 
	{0x13000521	    ,"Sub File Index Data Start"}, 
	{0x13000522	    ,"Sub File Index Data End"}, 
	{0x110003FF 	,"Elementary Stream Info"}, 
	{0x13000301 	,"Elementary Stream Type"}, 
	{0x13000303	    ,"Elementary Stream PID"}, 
	{0x16000305 	,"elementary stream sequence"}, 
	{0x16000306 	,"elementary stream extended sequence"}, 
	{0x16000307	    ,"elementary stream sequence parameter set"}, 
	{0x13000701 	,"Index Rate"}, 
	{0x13000702 	,"Worst Case Offset"}, 
	{0x11000FFF	    ,"Schedule Fragment Info"}, 
	{0x13000F01	    ,"Fragment ID"}, 
	{0x15000F02	    ,"Fragment Content ID"}, 
	{0x13000F03	    ,"Fragment Start Time"}, 
	{0x13000F04	    ,"Fragment Duration"}
};


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

	if (argc < 2)
	{
		printf ("%s indexFileName\n", argv[0]);
		return -1;
	}
	char* fileName = argv[1];
	
	struct stat stbuf;
	stat (fileName, &stbuf);
	
	char* fdata = (char*) malloc (stbuf.st_size);
	
	
	FILE* fp = fopen (fileName, "rb");
	if (fp == NULL)
	{
		printf ("file %s is not exists\n", fileName);
		return -1;
	}
	
	fread (fdata, sizeof(char), stbuf.st_size, fp);
	fclose (fp);
	int offset = 0;
	if (fdata[0]=='0' && fdata[1]=='5' && fdata[2]=='9' && fdata[3]=='E' && fdata[4]=='\r' && fdata[5]=='\n')
	offset += 6;
	
	
	IndexHead  fHead;
	
	memcpy (&fHead, fdata+offset, sizeof(fHead));
	assert (sizeof(fHead) == 91);
	
	printf ("----------------------HEAD----------------------\n");
	printf ("Indentify = %s\n", fHead.Indentify);
	printf ("MajorVersion = %d\n", fHead.MajorVersion);
	printf ("MinorVersion = %d\n", fHead.MinorVersion);
	printf ("Generation = %s\n", fHead.Generation);
	printf ("Count = %d\n", fHead.Count);
	printf ("Creator = %s\n", fHead.Creator);
	printf ("------------------------------------------------\n\n");	
	offset += 91;
	
	while (offset < stbuf.st_size)
	{
		Tag        tag;
		if ((BYTE)fdata[offset] == 0x00)
		{
			offset ++;
			continue;
		}
		else
		{
			memcpy (&tag, fdata+offset, sizeof(Tag));
			offset += sizeof(Tag);
			
			if (tag.flag == 0x11000001)
			{	
				printf("---------------------Index Info---------------------\n");//TLV
				continue;
			}
			if (tag.flag == 0x110001FF)
			{
				printf("@@:Content Info\n");//TLV
				continue;
			}
			if (tag.flag == 0x15000105)
			{
				char* data = (char*)calloc(1, tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf ("------Source URI = %s\n", data);
				continue;
			}
			if (tag.flag == 0x13000107)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf ("------Index Type = %d\n", t);
				continue;
			}
			if (tag.flag == 0x13000106)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------File Type = %d\n", t);
				continue;
			}
			if (tag.flag == 0x1300010E)
			{
				unsigned int i;
				assert (tag.vlen <= 4);
				memcpy (&i, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Video Frame Rate Tickets = %d\n", i);
				continue;
			}
			if (tag.flag == 0x1300010F)
			{
				unsigned int i;
				assert (tag.vlen <= 4);
				memcpy (&i, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Video Frame Rate Time Scale = %d\n", i);
				continue;
			}
			if (tag.flag == 0x1300010C)
			{
				unsigned short s;
				assert (tag.vlen <= 2);
				memcpy (&s, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Video Horizontal Size = %d\n", s);
				continue;
			}
			if (tag.flag == 0x1300010D)
			{
				unsigned short s;
				assert (tag.vlen <= 2);
				memcpy (&s, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Video Vertical Size = %d\n", s);
				continue;
			}
			if (tag.flag == 0x13000116)
			{
				BYTE s;
				assert (tag.vlen == 1);
				memcpy (&s, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Elementary Stream Count = %d\n", s);
				continue;
			}
			if (tag.flag == 0x13000109)
			{
				double b = 0;
				assert (tag.vlen <= sizeof(b));
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Bitrate = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x13000117)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Count = %d\n", t);
				continue;
			}
			if (tag.flag == 0x13000108)
			{
				unsigned short t = 0;
				assert (tag.vlen == 2);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Schedule Fragment Count = %d\n", t);
				continue;
			}
			if (tag.flag == 0x1500010A)
			{
				char* data = (char*)calloc (1, tag.vlen+1);
				assert (tag.vlen <= 24);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Schedule Start Time = %s\n", data);
				continue;
			}
			if (tag.flag == 0x1300010B)
			{
				double b = 0;
				assert (tag.vlen <= 8);
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Schedule Fragment Duration = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x13000118)
			{
				unsigned int t;
				assert (tag.vlen <= 4);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Time Shift Time = %d\n", t);
				continue;
			}
			if (tag.flag == 0x1400011B)
			{
				BYTE t;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Open for Write = %s\n", t==0?"false":"true");
				continue;
			}
			if (tag.flag == 0x1500011C)
			{
				char* data = (char*)calloc(1, tag.vlen+1);
				assert (tag.vlen <= 32);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------ProviderID = %s\n", data);
				continue;
			}
			if (tag.flag == 0x1500011D)
			{
				char* data = (char*)calloc(1, tag.vlen+1);
				assert (tag.vlen <= 512);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------ContentID = %s\n", data);
				continue;
			}
			if (tag.flag == 0x1500011E)
			{
				char* data = (char*)calloc(1, tag.vlen+1);
				assert (tag.vlen <= 32);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------PhysicalChannelID = %s\n", data);
				continue;
			}
			if (tag.flag == 0x110004FF)
			{
				printf("@@:Control Info\n");//TLV
				continue;
			}
			if (tag.flag == 0x16000401)
			{
				char* data = (char*)calloc (1, tag.vlen+1);
				assert (tag.vlen <= 188);//binary data
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Program Association Table = binary data, len = %d\n", tag.vlen);
				continue;
			}
			if (tag.flag == 0x16000403)
			{
				char* data = (char*)calloc (1, tag.vlen+1);
				assert (tag.vlen <= 188);//binary data
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Program Map Table = binary data, len = %d\n", tag.vlen);
				continue;
			}
			if (tag.flag == 0x15000410)
			{
				char* data = (char*)calloc(1, tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------SDP = %s\n", data);
				continue;
			}
			if (tag.flag == 0x110005FF)
			{
				printf("@@:Sub File Info\n");//TLV
				continue;
			}
			if (tag.flag == 0x13000501)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File ID = %d\n", t);
				continue;
			}
			if (tag.flag == 0x15000502)
			{
				char* data = (char*)calloc(1, tag.vlen+1);
				assert (tag.vlen <= 512);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File URI = %s\n", data);
				continue;
			}
			if (tag.flag == 0x13000503)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				switch (t)
				{
					case 0:
					printf("------Sub File Type = %d, TS\n", t);
					break;
					case 2:
					printf("------Sub File Type = %d, FLV\n", t);
					break;
					case 3:
					printf("------Sub File Type = %d, 3GP\n", t);
					break;
					case 4:
					printf("------Sub File Type = %d, MP4\n", t);
					break;
					default:
					printf("------Sub File Type = %d, file type is unknown\n", t);
					break;
				}
				
				continue;
			}
			if (tag.flag == 0x13000504)
			{
				double b = 0;
				assert (tag.vlen <= 5);
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Data Start = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x13000505)
			{
				double b = 0;
				assert (tag.vlen <= 5);
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Data end = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x1300050A)
			{
				double b = 0;
				assert (tag.vlen <= sizeof(b));
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Duration = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x1200050C)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Scale = %d\n", t);
				continue;
			}
			if (tag.flag == 0x13000520)
			{
				unsigned int t = 0;
				assert (tag.vlen <= 4);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File IDR Frames Count = %d\n", t);
				continue;
			}
			if (tag.flag == 0x1300050E)
			{
				unsigned int t = 0;
				assert (tag.vlen <= 4);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File I Frames Count = %d\n", t);
				continue;
			}
			if (tag.flag == 0x1300050F)
			{
				unsigned int t = 0;
				assert (tag.vlen <= 4);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File P Frames Count = %d\n", t);
				continue;
			}
			if (tag.flag == 0x13000510)
			{
				unsigned int t = 0;
				assert (tag.vlen <= 4);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File B Frames Count = %d\n", t);
				continue;
			}
			if (tag.flag == 0x13000521)
			{
				double b = 0;
				assert (tag.vlen <= 5);
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Index Data Start = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x13000522)
			{
				double b = 0;
				assert (tag.vlen <= 5);
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Sub File Index Data End = %ld\n", b);
				continue;
			}
			if (tag.flag == 0x110003FF)
			{
				printf("@@:Elementary Stream Info\n");//TLV
				continue;
			}
			if (tag.flag == 0x13000301)
			{
				BYTE t = 0;
				assert (tag.vlen == 1);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Elementary Stream Type = %d, %s\n", t, t==1?"MP3G2":"H.264");
				continue;
			}
			if (tag.flag == 0x13000303)
			{
				unsigned short t;
				assert (tag.vlen == 2);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Elementary Stream PID = %d\n", t);
				continue;
			}
			if (tag.flag == 0x16000305)
			{
				char* data = (char*)malloc (tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------elementary stream sequence = binary data, len = %d\n", tag.vlen);//binary
				continue;
			}
			if (tag.flag == 0x16000306)
			{
				char* data = (char*)malloc (tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------elementary stream extended sequence = binary data, len = %d\n", tag.vlen);//binary
				continue;
			}
			if (tag.flag == 0x16000307)
			{
				char* data = (char*)malloc (tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------elementary stream sequence parameter set = binary data, len=%d\n", tag.vlen);
				continue;
			}
			if (tag.flag == 0x13000701)
			{
				char* data = (char*)malloc (tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Index Rate\n");//文档里没有该字段的描述
				continue;
			}
			if (tag.flag == 0x13000702)
			{
				char* data = (char*)malloc (tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Worst Case Offset\n");//文档里没有该字段的描述
				continue;
			}
			if (tag.flag == 0x11000FFF)
			{
				printf("@@:Schedule Fragment Info\n");//TLV
				continue;
			}
			if (tag.flag == 0x13000F01)
			{
				unsigned short t = 0;
				assert (tag.vlen == 2);
				memcpy (&t, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Fragment ID    = %d\n", t);
				continue;
			}
			if (tag.flag == 0x15000F02)
			{
				char* data = (char*)calloc (1, tag.vlen+1);
				memcpy (data, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Fragment Content ID = %s\n", data);
				continue;
			}
			if (tag.flag == 0x13000F03)
			{
				double b = 0;
				assert (tag.vlen == sizeof(b));
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Fragment Start Time = %ld\n", b);
				continue;	
			}
			if (tag.flag == 0x13000F04)
			{
				double b = 0;
				assert (tag.vlen == sizeof(b));
				memcpy (&b, fdata+offset, tag.vlen);
				offset += tag.vlen;
				printf("------Fragment Duration   = %ld\n", b);
				continue;
			}
			
			
			printf ("\nunknown tag = 0x%x, vlen = %d, offset = %d\n", tag.flag, tag.vlen, offset);
			char* datas = (char*)calloc (1, tag.vlen+1);
			memcpy (datas, fdata+offset, tag.vlen);
			offset += tag.vlen;
			continue;
			
		}
	}

	printf ("\n-------------------------------------------------------\n");
	printf ("\nParse file  finish\n");
	return 0;

}



langeldep
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
CDN技术详解
06-25
《cdn技术详解》内容包括cdn技术的发展历程、关键技术、商业化服务现状，以及对未来的发展展望，对构成cdn系统的关键功能模块gslb、slb、cache进行了重点讲解，除技术原理之外，还对实现这些功能模块所涉及的一些协议和开发工具进行了讲解，希望能帮助读者了解cdn这项技术，并对cdn系统的设计和开发有一些初步的体会。 《cdn技术详解》适合从事互联网开发和运营工作的专业人士、电信运营服务从业人员，以及相关专业的高校学生。
CDN详解
qq_40276626的博客
09-23 3771
CDN简介 CDN的全称是 Content Delivery Network，也就是基于内容的转发网络。 网络归根结底还是通过光纤或者电缆传播，距离越近，对应的时延肯定越小。 假如一个上海的主机想要访问北京的主机的一些数据，那么数据肯定要走几百公里的路程。能不能在上海设置一个代理主机来缓存北京的主机对应的数据，这样的话，上海的主机直接访问上海的代理主机而不用在访问源服务器了，大大的减少了时延。 这就是CDN，基于内容的转发网络，通过设置代理服务器来大大的减少了客户端请求的网络时延。 CDN结构 首先说下CD
如何将第三方包用cdn地址引入到index.html中保证运行？
最新发布
m0_65812066的博客
09-29 1460
但是第一次运行开发环境的速度会有点慢，所以开发环境下想要webpack引入本地的node_modules那些第三方包。生产环境，打包时会以public/index.html,也有那些第三方的cdn地址，所以也能正常运行。dist瘦身：影响dist的体积，其他第三方包用cdn地址引入到index.html中保证运行。把一些静态资源：css， .js，图片，视频放在第三方的CDN服务器上，可以加速访问速度。打包dist和开发环境都会使用这套配置（cdn地址），并排除掉第三方。问题：我们虽然排除调了第三方的包。
CDN的实现原理
weixin_34218890的博客
02-19 254
在描述CDN的实现原理，让我们先看传统的未加缓存服务的访问过程，以便了解CDN缓存访问方式与未加缓存访问方式的差别： 用户提交域名→浏览器对域名进行解释→得到目的主机的IP地址→根据IP地址访问发出请求→得到请求数据并回复 由上可见，用户访问未使用CDN缓存网站的过程为: 1)、用户向浏览器提供要访问的域名； 2)、浏览器调用域名解析函数库对域名进行解析，以得到此域名对应的IP地址； 3...
CDN和本地文件
c8621的博客
09-19 3841
对于重要的文件，最好还是提供本地文件的冗余，以应对CDN文件不可用的情况。以jquery为例： src="https://ajax.googleapis.com/ajax/libs/jquery1.4.3/jquery.min.js"> !window.jQuery && document.write(" src=\"scripts/jquery-1.4.3.min.js\">" + "")
中国电信CDN网络介绍
09-19
### 中国电信CDN网络知识点详解 #### 一、CDN的概念与背景 **CDN（Content Delivery Network）**，即内容分发网络，是一种构建在现有互联网基础之上的虚拟网络，通过分布在不同地理位置的服务器集群，为用户提供更...
element-ui官网CDN下载方法，java代码实现
10-29
本篇文章将详细讲解如何通过 Java 代码实现从 Element UI 官网获取 CDN 下载资源的方法，以及在过程中涉及的 httpclient 代理设置和 HTTPS 认证。 首先，我们需要了解 Element UI 官网上提供的 CDN 链接。这些链接...
利用CDN加速react webpack打包后的文件详解
08-27
本文将详细介绍如何利用CDN来加速React应用Webpack打包后的文件。 1. **Webpack配置** 在`webpack.config.js`中，我们需要修改`output.publicPath`字段，将它设置为CDN的URL前缀。例如： ```javascript output: ...
static-cdn
03-06
index.html
CDN：静态资源加速访问
02-25
CDN 静态资源加速访问
CDN 科普
代码技巧
03-21 829
一、概述1.1 含义CDN 的全称是 Content Delivery Network，即内容分发网络。CDN 是构建在网络之上的内容分发网络，依靠部署在各地的边缘服务器...
视频播放网站CDN内容分发网络简单代码实现
weixin_34321977的博客
07-16 131
视频播放如果只有一台视频服务器，当访问用户过多时，服务器将承受不了负载。 所以我们需要在视频服务器下面增加边缘服务器，下面以视频服务器加三台边缘服务器为例。 网络环境图： 1. 用户可通过PC机或手机访问网站。 2. 网站将用户请求转向到负载较小的边缘服务器。 3. 边缘服务器接收到用户请求，先在本地检查用户请求文件是否存在。 4. 如果存在则直接返回本地文件进行播...
如何自己架设部署CDN？
热门推荐
haima1998的专栏
03-15 1万+
转自：https://www.zhihu.com/question/21771529作者：视界云链接：https://www.zhihu.com/question/21771529/answer/190036779来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。关于企业是否需要部署自己的CDN，这个需要结合最优的性价比、自身的需求和业务规模以及自身的能力等综合因素来衡...
网站架构探索(2)-CDN基本常识 王泽宾
weixin_30364147的博客
03-12 121
在介绍网站架构之前，我们先介绍一些网站架构中最基础和常见的概念，以便更好的理解后面的有关负载均衡和分布式存储等技术。第一个，首先讲讲CDN。 1、CDN是什么 CDN（Content Delivery Network），就是内容发布网或者内容分发网，它的主要目的：通过在现有的Internet中增加一层新的网络架构，将网站的内容发布到最接近用户的网络边缘，使用户可以就近取...
CCDN学习第一天
wawjsqj123的博客
07-20 6366
CCNA（主要讲解） 1.osi七层模型（高层与数据流层）： 层（layer）：描述了所有需求的有效的通讯过程，并把这些过程逻辑上的组叫做层。 高层：            1、应用层：提供用户接口；               用户接口：与其他计算机进行通讯的一个应用，对应应用程序的通信服务。               常见应用层协议：Telnet、SMTP、HTTP、FTP  ...
CDN进入牌照时代 工信部规范和清理CDN市场
weixin_34362875的博客
08-01 349
12月12日消息，近日工信部发布关于开展互联网基础管理专项行动的通知。加强内容分发网络业务(简称CDN)及IP地址的管理被列为互联网基础管理专项行动工作方案的重点任务。 《互联网基础管理专项行动工作方案》提出，各地通信管理局应依据《电信业务分类目录(2015年版)》，开展CDN企业增值电信业务经营许可管理工作，逐步规范和清理CDN业务市场。同时，指导属...
中国电信CDN网络服务与技术解析
"中国电信CDN网络介绍.pdf" 本文档详细介绍了中国电信的CDN（内容分发网络）服务，包括其产生背景、基本概念、工作原理、关键技术、网络设计规划思想、网络技术和业务模式。 1. CDN的产生背景与基本概念： CDN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

langeldep

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值