计算机网络W5：HTTP /邮件协议

HTTP/邮件协议

Socket:SMTP协议，邮件代理客户端

注意应用程序和应用层的协议之间的关系

Client-server:客户端与客户端之间并不会相互通讯。

而P2P存在相互对等。

通讯理解为进程间通讯的问题，通过sockets通讯 between client process and server process.

一个IP地址确定的主机上，如何确定进程呢，是通过端口号。

HTTP

  • web page objects
  • hTML-file
  • Object be accessed by url

Apahce web server

  1. http : request(向服务器)
  2. http : response

HTTP:无状态的，即不会记录客户端任何消息，即它不认识客户端，所以使HTTP的管理相对简单。

HTTP：建立连接，传输消息，关闭连接

两种连接方式

非持续连接

连接时最多只有一个对象只发送一个对象即关闭了

持续连接

可以发很多的对象

RTT

整个花费的时间

2RTT+file transmission

真实的是多线程流水线的方式

http无状态：不保留消息

例再次登陆的时候不需要再次输入用户名和密码?

user-server state:cookie

本地仍会有cookie的文件，相当于状态，在web服务器端记录下了client端的状态。

web caches(proxy server)

代理服务器，不需要跑到原始的服务器那里去拿。

好处：在isp这边缓存了网站部分，使访问速度会变快。

问题：缓存的数据是否是最新的?

展开全文 >>

计算机网络W4: Application Layer

Application layer

无论是分布式或者网络应用也好，现在我们更关注的是性能，所以我们更经常地会用到是多线程。

很多大型的底层系统基本只有两个语言的要求C++/JAVA。

花多一些时间在java上

期末大项目 使用java语言自己完成一个http server:重点在于性能的提升。

编程不是智商的问题，而是是否练习的问题。

对于本科生而言，拥有良好的代码能力都是一个非常好的技能点。

Web and HTTP;

electronic mail

JAVA soket API

more >>

展开全文 >>

操作系统W4 project1 shell

shell说明文档

文档大纲

截屏2020-03-31下午5.13.17.png

编译方法

在目录下输入clang -o shell shell.c tool.c command.c mytop.c即可编译。

输入./shell即可运行。

支持的功能

内置

Cd/mytop(top)/exit/histoy n

program

管道/重定向/带参数运行的程序。

支持的样例

  1. cd/your/path

  2. ls(-a/-l -a)

  3. ls -a -l > outfile

  4. vi file

  5. grep “parameters” < inputfile

  6. Ls -a -l | grep a

  7. vi file &

  8. mytop

  9. history n

  10. Exit

各文件说明

shell.c

shell函数的主体框架：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int main()
{
   /*主体循环*/
    while(1)
    {
        printf("$");
        /*fgets从文件标准输入一次读一行，
        当键入文件结束符（ctrl+D),fgets返回一个null指针*/
        fgets(buf,MAXLINE,stdin);
        /*把末尾的回车去掉*/
        char *find;
        find=strchr(buf,'\n');
        if(find)
            *find='\0';
      /*保存历史命令*/
        char *tmp = (char*)malloc(sizeof(buf));
        strcpy(tmp,buf);
        history[historycount]=tmp ;
        historycount++;
      /*解析命令*/
        struct cmdline l=parse_line(buf);
      /*执行命令*/
        execmd(l,history,historycount);

    }
    exit(0);

}

shell.h

包含函数声明/常数定义/编译所用的头文件

1
2
3
4
#define MAXLINE 1024 /*命令最大长度*/
#define STD_INPUT 0/*标准输入*/
#define STD_OUTPUT 1/*标准输出*/
#define MAX_ARGC 5/*程序命令programA argv1 argv2参数最大大小*/

命令行结构：

1
2
3
4
5
6
7
8
9
10
11
struct cmdline
{
    char *buf;/*键盘键入的原始字符串*/
    char *parameters[MAXLINE];/*按空格分割的参数args*/
    int argc;/*参数个数*/
    int is_background;/*是否是后置命令*/
    int is_special;/*是否有特殊符号，如>,<,>>,|*/
    int special_position;/*特殊符号位置*/
    int cmdnumber;/*程序个数*/

};

函数声明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int issamestring(const char *a,const char *b);/*辅助函数，判断字符串是否相等*/
struct cmdline parse_line(char buf[]);/*parse*/
void execmd(struct cmdline l,char *history[],int historycount);

/*built-in cmds*/
void exe_mytop();
void exe_cd(char *parameters[],char* history[],int historycount);
void exe_history(char *parameters[],char* history[],int historycount);

/*支持的program*/
void exe_ls(struct cmdline oneline);
void  exe_grep(struct cmdline oneline);
void exe_vi(struct cmdline oneline);

/*redirection and pipe*/
void redirect(struct cmdline oneline);
void pipeline(struct cmdline oneline);
void pipel(char *process1[],char *process2[]);

tool.c

包含了解析命令行、判断是否相等字符串、判断是否内置命令、执行命令的函数。

command.c

Shell.h中声明的函数的执行。

program命令

ls/grep

ls/grep两个命令均是对文件IO逻辑的考察，逻辑相同，下以ls为例进行说明。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void exe_ls(struct cmdline oneline){
  /*如果没有特殊符号*/
    if(oneline.is_special==0){
        int pid,status;
        pid=fork();
        if(pid<0)
            printf("fork error!");
        else if(pid ==0){
            execvp("ls",oneline.parameters);
        }
        else{
                waitpid(-1,&status,0);
        }
    }
    else{
      /*如果有特殊符号，判断特殊符号的类别*/
        if ((issamestring(">", 	oneline.parameters[oneline.special_position]) == 1)||(issamestring("<", oneline.parameters[oneline.special_position]) == 1)||(issamestring(">>", oneline.parameters[oneline.special_position]) == 1))
          /*特殊符号为重定向时*/
            redirect(oneline);
        else{  
           /*特殊符号为管道时*/
            pipeline(oneline);
        }
    }
vi and background job

linux的vi file &很奇怪，是通过将子进程的标准输入输出映射到/dev/null实现的。

我自己在minix3环境下实验了一下，发现无论是我自己的shell还是minix3原来的shell，都有如下提示：

Vi's standard input and output must be a terminal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void exe_vi(struct cmdline oneline)
{

    int pid,status;
    pid=fork();
    if(pid<0){
        printf("fork error!");
        exit(1);
    }
    if(pid ==0) {
        if (oneline.is_background == 1) {
            /*子进程的标准输入、输出映射成/Dev/null*/
            close(0);//关闭标准输入
            open("/dev/null", O_RDONLY);//标准输入0指向空文件
            close(1);//关闭标准输出
            open("/dev/null", O_RDONLY);//标准输入1指向空文件
            signal(SIGCHLD, SIG_IGN);
            execvp("vi", oneline.parameters);
        } else {
            execvp("vi", oneline.parameters);
        }
    }
    else{
        waitpid(-1,&status,0);
    }

}

其余的background文件的实施 需要看父进程是否wait子进程。

redirection
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/*管道和重定向*/
void redirect(struct cmdline oneline) {
		/*提取特殊符号前的数组argv1,argv2*/
    char *argv1[MAX_ARGC];
    char *argv2[MAX_ARGC];
    for(int i=0;i<MAX_ARGC;i++){
        argv1[i]=NULL;
        argv2[i]=NULL;
    }
    for (int i = 0; i < oneline.special_position; i++) {
        argv1[i] = oneline.parameters[i];
    }
  /*注意execvp和NULL */
    argv1[oneline.special_position] = NULL;

    int j=oneline.special_position+1;
    for (int i = 0; i < oneline.argc - oneline.special_position-1; i++) {
        argv2[i] = oneline.parameters[j];
        j++;
    }
    argv2[oneline.argc-oneline.special_position] = NULL;//execvp使用；提取特殊命令后的programA 和program B//


    int pid, status, fd;


    if ((issamestring(">", oneline.parameters[oneline.special_position]) == 1)||(issamestring(">>", oneline.parameters[oneline.special_position]) == 1)){
        fd = dup(1);//复制标准输出,此时dup返回的是最新空闲,即让一个最新空闲fd也指向1
        close(1);//关闭标准输出
     }
    else {
        fd = dup(0);//复制，此时最新空闲的是fd
        close(0);//关闭标准输入
}
     /*先看文件是否存在，存在就覆盖写，不存在就创建写入*/
        /*fd要设置成全局变量，便于父进程对于文件描述符的恢复*/
    pid = fork();
    if (pid < 0) {
            printf("fork error!");
            exit(1);
    }
    else if (pid == 0) {
      /*子进程*/
        if(issamestring(">", oneline.parameters[oneline.special_position]) == 1){
            open(argv2[0], O_WRONLY | O_CREAT | O_TRUNC);//返回的fd是1
        }
        else if(issamestring(">>", oneline.parameters[oneline.special_position]) == 1){
            open(argv2[0],  O_WRONLY | O_CREAT | O_APPEND);//返回的fd是1
        }
        else
        {
            open(argv2[0], O_RDONLY);
        }
        execvp(argv1[0],argv1);
    }
    else{
      /*父进程*/
        waitpid(-1, &status, 0);
        if ((issamestring(">", oneline.parameters[oneline.special_position]) == 1)||(issamestring(">>", oneline.parameters[oneline.special_position]) == 1))
            close(1);
        else
            close(0);
        dup(fd);//将当前最小的文件描述符1，指向fd指向的；
        close(fd);//不让fd再指向1，即恢复最开始的状态
    }
    /*这里注意文件标识符的恢复问题*/
    /*文件表示符的恢复应该放在父进程里"执行*/
 }
pipe

pipe的主体框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*提取Program A /B,此处同redirection*/				
			char *argv1[MAX_ARGC];
       char *argv2[MAX_ARGC];
       for(int i=0;i<MAX_ARGC;i++){
           argv1[i]=NULL;
           argv2[i]=NULL;
       }
       for (int i = 0; i < oneline.special_position; i++) {
           argv1[i] = oneline.parameters[i];
       }
       argv1[oneline.special_position] = NULL;
       int j=oneline.special_position+1;
       for (int i = 0; i < oneline.argc - oneline.special_position-1; i++){
           argv2[i] = oneline.parameters[j];
           j++;
       }
       argv2[oneline.argc-oneline.special_position] = NULL;


	/*fork出两个子进程分别执行programA/programB */
       int status;
       if(fork()==0){
           pipel(argv1,argv2);
           exit(0);
       }
       else{
           waitpid(-1,&status,0);
       }

mytop命令

mytop框架如下，参照minix3的top.c框架

输出内容：

1. 总体内存大小，空闲内存大小，缓存大小；

   2. 总体CPU使用占比。
1
2
3
4
5
void exe_mytop(){
    print_memifo();
    getkinfo();
    print_cpu();
}

下面对mytop.c的函数做具体解释，部分宏定义来源于top.c参考源码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*在psinfo文件下解析进程*/
struct proc {
    int p_flags;
    endpoint_t p_endpoint;
    pid_t p_pid;
    u64_t p_cpucycles[CPUTIMENAMES];
    int p_priority;
    endpoint_t p_blocked;
    time_t p_user_time;
    vir_bytes p_memory;
    uid_t p_effuid;
    int p_nice;
};
struct tp {
    struct proc *p;
    u64_t ticks;
};
/*注意ticks的动态变化*/
struct proc *proc = NULL, *prev_proc = NULL;

/*mytop的主体函数*/
void print_memifo(void);
void getkinfo(void);
void print_cpu(void);

/* print_cpu组成函数
1.getprocs->parsedir->parsefile;
2.printprocs->cputicks的计算*/
void get_procs(void);
void print_procs(struct proc *prev_proc,struct proc *proc,int cputimemode);
void parse_dir(void);
void parse_file(pid_t pid);
/*print_procs*/
u64_t cputicks(struct proc *p1, struct proc *p2, int timemode);

展开全文 >>

计算机网络W3 TCP/IP 协议栈

计算机网络W3 TCP/IP 协议栈

  • 分组交换/电路交换都是一种物理的交换方式。
  • 实际万维网使用分组交换
  • 逻辑距离/物理距离。
  • POP:入网点

1.4/1.5是重点

丢包和延时

延时：传输延时/排队延时

丢包是不可避免的，缓冲区满时必然会丢包。

延时

  1. 节点处理$d_{proc}$

    Check errors/

    determine output link/ typically < msec

  2. 排队延时

  3. 传输延时$d_{trans}$

    虽然排队排到了

  4. 传播延时$d_{prop}$

    3和4概念辨析：

   3：将包从门里塞出去：与packet长度和带宽R(把带宽理解成门的大小)

   4：赛出门以后，到达另一个节点的时间，与具体的路径长度有关(传输媒介的物理介质)

   长度/传播塑料

即propagation和transmission的区别

流量强度

定义

La/R

L是packet比特数

La/R要小于1

晕塞控制

接收方和发送方的速率的匹配

一般不会有无限长队列，超过某一时常一般会丢包。

吞吐

理论：接受者每秒能收到的比特数量，接受者真正能体验到的每秒钟能接收到的比特数，分瞬时和平均。管子跟流水一样，保证通畅是最小值。

吞吐是带宽的最小值

吞吐更强调端系统，取决于整个链路的瓶颈带宽。

带宽是一段更取决于物理介质，点名哪里到哪里，这里的哪里不一定是端了。

邮寄

收发是对等的。

发：分发

收：收起来

1.6 协议的层次结构

重点强调 对等的概念

层层之间功能服务的提供；

分层协议栈（对等）

向上提供

向下使用

有时相邻，很少跨层

公共基础设施模块化

透明：不关心细节

好处：服务无变化时，上层不关心。

http协议是被实现在哪里的？

​ 被实现在http客户端和服务器.

我们所写的网站是运行在服务器的，写的是服务器端的网站。浏览器的作用仅仅是前端显示。

把浏览器端的文件下载过来在客户端显示。

TCP/IP协议栈

appliction：支持各种应用

端口：标示运行在机器上的进程HTTP/FTP/SMTP

transport：运行在两个主机上的一对进程之间的通讯TCP/UDP

Network:一对端系统（主机）源到目的主机 Port/IP

Link:相邻节点：网络层传输时会经过很多不同的介质，介质是透明MAC

Physical：如何将比特从一个穿到另一个（比特流）

进程间通讯：

同一台主机上进程的通讯：管道、信号｜ (共享内存)

不同主机上：在网络上一堆进程如何通讯，就利用端口。

ISO/OSI refence model

Encapsulation

交换机两层

router三层

Crash 好乱啊Orz

栈的理解：协议一个个向下遵守，再从下向上遵守。

展开全文 >>

本站总访问量次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br><br>个人随笔笔记为主<br>有很多不足<br>谢谢大家～<br><br>可以搜索我的微信号联系我：Habseligkeit030<br><br><br>也可以给我发邮件xinning_chi@163.com