2017-2018-1 20155304 《信息安全系统设计基础》第八周学习总结

课上测试补充

第八周测试-2

把第一个练习中的代码在X86-64（Ubuntu）中反汇编，给出汇编代码和机器码的截图

把X86-64汇编翻译成Y86-64汇编，并给出相应机器码的截图（使用附件中的Y86-64模拟器）

原代码：

#include <stdlib.h>  
#include <stdio.h> 
 
int main(int argc,char *argv[])  
{  
    int i,sum=0;  
    for(i=0;i<argc;i++)  
    {  
        sum+=atoi(argv[i]);  
    }  
    printf("Total: %d\n",sum);  
    return 0;  
}

X86-64汇编：

.file   "sum.c"

    .section    .rodata

.LC0:

    .string "Total: %d\n"

    .text

    .globl  main

    .type   main, @function

main:

.LFB2:

    .cfi_startproc

    pushq   %rbp

    .cfi_def_cfa_offset 16

    .cfi_offset 6, -16

    movq    %rsp, %rbp

    .cfi_def_cfa_register 6

    subq    $32, %rsp

    movl    %edi, -20(%rbp)

    movq    %rsi, -32(%rbp)

    movl    $0, -4(%rbp)

    movl    $0, -8(%rbp)

    jmp .L2

.L3:

    movl    -8(%rbp), %eax

    cltq

    leaq    0(,%rax,8), %rdx

    movq    -32(%rbp), %rax

    addq    %rdx, %rax

    movq    (%rax), %rax

    movq    %rax, %rdi

    call    atoi

    addl    %eax, -4(%rbp)

    addl    $1, -8(%rbp)

.L2:

    movl    -8(%rbp), %eax

    cmpl    -20(%rbp), %eax

    jl  .L3

    movl    -4(%rbp), %eax

    movl    %eax, %esi

    movl    $.LC0, %edi

    movl    $0, %eax

    call    printf

    movl    $0, %eax

    leave

    .cfi_def_cfa 7, 8

    ret

    .cfi_endproc

.LFE2:

    .size   main, .-main

    .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609"

    .section    .note.GNU-stack,"",@progbits

机器码：

0000000000000000 <main>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   48 83 ec 20             sub    $0x20,%rsp
   8:   89 7d ec                mov    %edi,-0x14(%rbp)
   b:   48 89 75 e0             mov    %rsi,-0x20(%rbp)
   f:   c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%rbp)
  16:   c7 45 f8 00 00 00 00    movl   $0x0,-0x8(%rbp)
  1d:   eb 26                   jmp    45 <main+0x45>
  1f:   8b 45 f8                mov    -0x8(%rbp),%eax
  22:   48 98                   cltq   
  24:   48 8d 14 c5 00 00 00    lea    0x0(,%rax,8),%rdx
  2b:   00 
  2c:   48 8b 45 e0             mov    -0x20(%rbp),%rax
  30:   48 01 d0                add    %rdx,%rax
  33:   48 8b 00                mov    (%rax),%rax
  36:   48 89 c7                mov    %rax,%rdi
  39:   e8 00 00 00 00          callq  3e <main+0x3e>
  3e:   01 45 fc                add    %eax,-0x4(%rbp)
  41:   83 45 f8 01             addl   $0x1,-0x8(%rbp)
  45:   8b 45 f8                mov    -0x8(%rbp),%eax
  48:   3b 45 ec                cmp    -0x14(%rbp),%eax
  4b:   7c d2                   jl     1f <main+0x1f>
  4d:   8b 45 fc                mov    -0x4(%rbp),%eax
  50:   89 c6                   mov    %eax,%esi
  52:   bf 00 00 00 00          mov    $0x0,%edi
  57:   b8 00 00 00 00          mov    $0x0,%eax
  5c:   e8 00 00 00 00          callq  61 <main+0x61>
  61:   b8 00 00 00 00          mov    $0x0,%eax
  66:   c9                      leaveq 
  67:   c3                      retq

Y86-64汇编：

.file   "sum.c"

    .section    .rodata

.LC0:

    .string "Total: %d\n"

    .text

    .globl  main

    .type   main, @function

main:

.LFB2:

    .cfi_startproc

    pushq   %rbp

    .cfi_def_cfa_offset 16

    .cfi_offset 6, -16

    movq    %rsp, %rbp

    .cfi_def_cfa_register 6

    subq    $32, %rsp

    irmovq  %edi, -20(%rbp)

    irmovq  %rsi, -32(%rbp)

    irmovlq $0, -4(%rbp)

    irmovlq $0, -8(%rbp)

    jmp .L2

.L3:

    movl    -8(%rbp), %eax

    cltq

    leaq    0(,%rax,8), %rdx

    movq    -32(%rbp), %rax

    addq    %rdx, %rax

    movq    (%rax), %rax

    movq    %rax, %rdi

    call    atoi

    addl    %eax, -4(%rbp)

    addl    $1, -8(%rbp)

.L2:

    movlq   -8(%rbp), %eax

    cmpl    -20(%rbp), %eax

    jl  .L3

    movl    -4(%rbp), %eax

    movl    %eax, %esi

    movl    $.LC0, %edi

    movl    $0, %eax

    call    printf

    movl    $0, %eax

    leave

    .cfi_def_cfa 7, 8

    ret

    .cfi_endproc

.LFE2:

    .size   main, .-main

    .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609"

    .section    .note.GNU-stack,"",@progbits

第八周测试-3

基于socket 使用教材的csapp.h csapp.c,实现daytime(13)服务器（端口我们使用13+后三位学号）和客户端
服务器响应消息格式是

“

客户端IP：XXXX

服务器实现者学号：XXXXXXXX

当前时间： XX：XX：XX

”

多进程实现daytime服务器

服务器端原代码：

#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <stdio.h>        // for printf
#include <stdlib.h>        // for exit
#include <string.h>        // for bzero
#include <unistd.h>        // for fork
#include <sys/signal.h> // for signal
#include <sys/wait.h>    // for wait
#include <time.h>
#include <arpa/inet.h>
#define HELLO_WORLD_SERVER_PORT    6666 
#define LENGTH_OF_LISTEN_QUEUE  20
#define BUFFER_SIZE 1024
void reaper(int sig)
{
    int status;
    //调用wait3读取子进程的返回值,使zombie状态的子进程彻底释放
    while(wait3(&status,WNOHANG,(struct rusage*)0) >=0)
        ;
}
int main(int argc, char **argv)
{
    //设置一个socket地址结构server_addr,代表服务器internet地址, 端口
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(server_addr)); //把一段内存区的内容全部设置为0
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);

    time_t t;


    //创建用于internet的流协议(TCP)socket,用server_socket代表服务器socket
    int server_socket = socket(AF_INET,SOCK_STREAM,0);
    if( server_socket < 0)
    {
        printf("Create Socket Failed!\n");
        exit(1);
    }
    
    //把socket和socket地址结构联系起来
    if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
    {
        printf("Server Bind Port : %d Failed!\n", HELLO_WORLD_SERVER_PORT); 
        exit(1);
    }
    
    //server_socket用于监听
    if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
    {
        printf("Server Listen Failed!"); 
        exit(1);
    }
    //通知操作系统,当收到子进程的退出信号(SIGCHLD)时,执行reaper函数,释放zombie状态的进程
    (void)signal(SIGCHLD,reaper);
    
    while (1) //服务器端要一直运行
    {
        //定义客户端的socket地址结构client_addr
        struct sockaddr_in client_addr;
        socklen_t length = sizeof(client_addr);

        //接受一个到server_socket代表的socket的一个连接
        //如果没有连接请求,就等待到有连接请求--这是accept函数的特性
        //accept函数返回一个新的socket,这个socket(new_server_socket)用于同连接到的客户的通信
        //new_server_socket代表了服务器和客户端之间的一个通信通道
        //accept函数把连接到的客户端信息填写到客户端的socket地址结构client_addr中

        int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
        if ( new_server_socket < 0)
        {
            printf("Server Accept Failed!\n");
            break;
        }
        int child_process_pid = fork(); //fork()后,子进程是主进程的拷贝
        //在主进程和子进程中的区别是fork()的返回值不同.
        if(child_process_pid == 0 )//如果当前进程是子进程,就执行与客户端的交互
        {
             t=time(NULL);
            close(server_socket); //子进程中不需要被复制过来的server_socket
            char buffer[BUFFER_SIZE];
            bzero(buffer, BUFFER_SIZE);
            //strcpy(buffer,"20155304实现");
            strcat(buffer,"\n"); //C语言字符串连接              
            
            //发送buffer中的字符串到new_server_socket,实际是给客户端
            send(new_server_socket,buffer,BUFFER_SIZE,0);
            printf("服务器实现者学号：20155304\n");
        printf("客户端IP：%s \n",inet_ntoa(client.sin_addr));
            printf("当前时间： %s\n",ctime(&t));
            send(new_server_socket,(void *)&t,sizeof(time_t),0);

            bzero(buffer,BUFFER_SIZE);
            //接收客户端发送来的信息到buffer中
            length = recv(new_server_socket,buffer,BUFFER_SIZE,0);
            if (length < 0)
            {
                printf("Server Recieve Data Failed!\n");
                exit(1);
            }
            printf("\n%s\n",buffer);
            //关闭与客户端的连接
            close(new_server_socket); 
            exit(0);         
        }
        else if(child_process_pid > 0)     //如果当前进程是主进程 
            close(new_server_socket);    //主进程中不需要用于同客户端交互的new_server_socket
    }
    //关闭监听用的socket
    close(server_socket);
    return 0;
}

客户端原代码：

#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <stdio.h>        // for printf
#include <stdlib.h>        // for exit
#include <string.h>        // for bzero
#include <time.h>
#define HELLO_WORLD_SERVER_PORT    6666 
#define BUFFER_SIZE 1024

void talk_to_server(char ** argv)
{
    //设置一个socket地址结构client_addr,代表客户机internet地址, 端口
    struct sockaddr_in client_addr;
    bzero(&client_addr,sizeof(client_addr)); //把一段内存区的内容全部设置为0
    client_addr.sin_family = AF_INET;    //internet协议族
    client_addr.sin_addr.s_addr = htons(INADDR_ANY);//INADDR_ANY表示自动获取本机地址
    client_addr.sin_port = htons(0);    //0表示让系统自动分配一个空闲端口
    //创建用于internet的流协议(TCP)socket,用client_socket代表客户机socket
    int client_socket = socket(AF_INET,SOCK_STREAM,0);
    time_t t;
    if( client_socket < 0)
    {
        printf("Create Socket Failed!\n");
        exit(1);
    }
    //把客户机的socket和客户机的socket地址结构联系起来
    if( bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr)))
    {
        printf("Client Bind Port Failed!\n"); 
        exit(1);
    }

    //设置一个socket地址结构server_addr,代表服务器的internet地址, 端口
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //服务器的IP地址来自程序的参数
    {
        printf("Server IP Address Error!\n");
        exit(1);
    }
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    socklen_t server_addr_length = sizeof(server_addr);
    //向服务器发起连接,连接成功后client_socket代表了客户机和服务器的一个socket连接
    if(connect(client_socket,(struct sockaddr*)&server_addr, server_addr_length) < 0)
    {
        printf("Can Not Connect To %s!\n",argv[1]);
        exit(1);
    }

    char buffer[BUFFER_SIZE];
    bzero(buffer,BUFFER_SIZE);
    //从服务器接收数据到buffer中
    int length = recv(client_socket,buffer,BUFFER_SIZE,0);
    if(length < 0)
    {
        printf("Recieve Data From Server %s Failed!\n", argv[1]);
        exit(1);
    }
    printf("From Server %s :\t%s\n",argv[1],buffer);
    length = recv(client_socket,(void *)&t,sizeof(time_t),0);
    if(length < 0)
    {
        printf("Recieve Data From Server %s Failed!\n", argv[1]);
        exit(1);
    }
    printf("当前时间： %s \n",ctime(&t));
    bzero(buffer,BUFFER_SIZE);
    //strcpy(buffer,"Thanks!");
    //向服务器发送buffer中的数据
    send(client_socket,buffer,BUFFER_SIZE,0);
    //关闭socket
    close(client_socket);
}
int main(int argc, char **argv)
{
    if (argc != 2)
    {
        printf("Usage: .\%s ServerIPAddress\n",argv[0]);
        exit(1);
    }
    talk_to_server(argv);

    return 0;
}

多线程实现daytime服务器

服务器源代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <errno.h>
#include <time.h>
#define PORT 1234
#define BACKLOG 2
#define MAXDATASIZE 1000
void process_cli(int connectfd,struct sockaddr_in client);
void sig_handler(int s);
int main()
{
    int opt,listenfd,connectfd;
    pid_t pid;
    struct sockaddr_in server;
    struct sockaddr_in client;
    int sin_size;
    struct sigaction act;
    struct sigaction oact;
    act.sa_handler=sig_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags=0;
    printf("服务器实现者学号：20155304\n");
    if(sigaction(SIGCHLD,&act,&oact)<0)
    {
        perror("Sigaction failed!\n");
        exit(1);
    }
    if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        perror("Creating socket failed.\n");
        exit(1);
    }
    opt=SO_REUSEADDR;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    bzero(&server,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_port=htons(PORT);
    server.sin_addr.s_addr=htonl(INADDR_ANY);
    if(bind(listenfd,(struct sockaddr *)&server,sizeof(struct sockaddr))==-1)
    {
        perror("Bind error.\n");
        exit(1);
    }
    if(listen(listenfd,BACKLOG)==-1)
    {
        perror("listen() error.\n");
        exit(1);
    }
    sin_size=sizeof(struct sockaddr_in);
    while(1)
    {
        if((connectfd=accept(listenfd,(struct sockaddr *)&client,&sin_size))==-1)
        {
            if(errno==EINTR) continue;
            perror("accept() error.\n");
            exit(1);
        }
        if((pid=fork())>0)
        {
            close(connectfd);
            continue;
        }
        else if(pid==0)
        {
            close(listenfd);
            process_cli(connectfd,client);
            exit(0);
        }
        else
        {
            printf("fork error.\n");
            exit(1);
        }
    }
    close(listenfd);
    return 0;
}
void process_cli(int connectfd,struct sockaddr_in client)
{
    int i,num;
    char recvbuf[MAXDATASIZE];
    char sendbuf[MAXDATASIZE];
    char cli_name[MAXDATASIZE];
    time_t t;
    t=time(NULL);
    printf("客户端IP：%s \n",inet_ntoa(client.sin_addr));
    
    num=recv(connectfd,cli_name,MAXDATASIZE,0);
    if(num==0)
    {
        close(connectfd);
        printf("Client disconnected.\n");
        return;
    }
    send(connectfd,(void *)&t,sizeof(time_t),0);
    while(num=recv(connectfd,recvbuf,MAXDATASIZE,0))
    {
        recvbuf[num]='\0';
        printf("当前时间：%s\n",ctime(&t));
        //send(connectfd,(void *)&t,sizeof(time_t),0);
    }
    
    close(connectfd);
}
void sig_handler(int s)
{
    pid_t pid;
    int stat;
    while((pid=waitpid(-1,&stat,WNOHANG))>0)
        printf("子进程 %d 关闭。\n",pid);
    return;
}

客户端源代码：

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <stdlib.h>

#include <time.h>

#define PORT 1234

#define MAXDATASIZE 1000

void process(FILE *fp,int sockfd);

char *getMessage(char *sendline,int len,FILE *fp);

int main(int argc,char *argv[])

{

    int fd;

    struct hostent *he;

    struct sockaddr_in server;

    if(argc!=2)

    {

        printf("Usage: %s <IP Address>\n",argv[0]);

        exit(1);

    }

    if((he=gethostbyname(argv[1]))==NULL)

    {

        printf("gethostbyname error.\n");

        exit(1);

    }

    if((fd=socket(AF_INET,SOCK_STREAM,0))==-1)

    {

        perror("socket() error.\n");

        exit(1);

    }

    bzero(&server,sizeof(server));

    server.sin_family=AF_INET;

    server.sin_port=htons(PORT);

    server.sin_addr=*((struct in_addr *)he->h_addr);

    if(connect(fd,(struct sockaddr *)&server,sizeof(struct sockaddr))==-1)

    {

        perror("connect() error.\n");

        exit(1);

    }

    process(stdin,fd);

    close(fd);

    return 0;

}

void process(FILE *fp,int sockfd)

{

    char sendbuf[MAXDATASIZE];

    char recvbuf[MAXDATASIZE];

    int num;

    time_t t;

    t=time(NULL);

    printf("用户名：\n");

    if(fgets(sendbuf,MAXDATASIZE,fp)==NULL)

    {

        printf("lease enter your name,now you have exit.\n");

        return;

    }

    

    send(sockfd,sendbuf,strlen(sendbuf),0);

    while(getMessage(sendbuf,MAXDATASIZE,fp)!=NULL)

    {

        send(sockfd,sendbuf,strlen(sendbuf),0);

        if((num=recv(sockfd,recvbuf,MAXDATASIZE,0))==0)

        {

            printf("Server no send you any data.\n");

            return;

        }

        recvbuf[num]='\0';

        printf("服务器消息：%s\n",ctime(&t));

    }

    printf("Exit.\n");

}

char *getMessage(char *sendline,int len,FILE *fp)

{

    printf("请输入请求:\n");

    return(fgets(sendline,len,fp));

}

课下作业

第八周课下作业1

1 完成家庭作业4.47，4.48，4.49

2 相应代码反汇编成X86-64汇编

3 把上述X86-64汇编翻译成Y86汇编，并给出相应机器码

源代码：

void bubble(int *data, int count) { 

if(count == 0)
return;
int i, j;
int *p, *q; 
for(i=count-1; i!=0; i--){
p = data, q = data + 1;
for(j=0; j!=i; ++j)
{ 
if( *p > *q )
{ 
int t = *p;*p = *q;
*q = t;
} 
p++, q++;}
}}

X86-64汇编

00000000 <bubble_p>:
   0:   56                      push   %esi
   1:   53                      push   %ebx
   2:   8b 44 24 10             mov    0x10(%esp),%eax
   6:   8b 54 24 0c             mov    0xc(%esp),%edx
   a:   8d 70 ff                lea    -0x1(%eax),%esi
   d:   85 f6                   test   %esi,%esi
   f:   7e 2d                   jle    3e <bubble_p+0x3e>
  11:   8d b4 26 00 00 00 00    lea    0x0(%esi,%eiz,1),%esi
  18:   31 c0                   xor    %eax,%eax
  1a:   8d b6 00 00 00 00       lea    0x0(%esi),%esi
  20:   8b 4c 82 04             mov    0x4(%edx,%eax,4),%ecx
  24:   8b 1c 82                mov    (%edx,%eax,4),%ebx
  27:   39 d9                   cmp    %ebx,%ecx
  29:   7d 07                   jge    32 <bubble_p+0x32>
  2b:   89 5c 82 04             mov    %ebx,0x4(%edx,%eax,4)
  2f:   89 0c 82                mov    %ecx,(%edx,%eax,4)
  32:   83 c0 01                add    $0x1,%eax
  35:   39 f0                   cmp    %esi,%eax
  37:   7c e7                   jl     20 <bubble_p+0x20>
  39:   83 ee 01                sub    $0x1,%esi
  3c:   75 da                   jne    18 <bubble_p+0x18>
  3e:   5b                      pop    %ebx
  3f:   5e                      pop    %esi
  
Disassembly of section .text.startup:

00000000 <main>:
   0:   31 c0                   xor    %eax,%eax

Y86汇编：

0x0000:                        | Disassembly of section .text:
                               | 
0x0000:                        | 00000000 <bubble_p>:
0x0000:                        |    0:  56                      push   %esi
0x0000:                        |    1:  53                      push   %ebx
0x0000:                        |    2:  8b 44 24 10             mov    0x10(%esp),%eax
0x0000:                        |    6:  8b 54 24 0c             mov    0xc(%esp),%edx
0x0000:                        |    a:  8d 70 ff                lea    -0x1(%eax),%esi
0x0000:                        |    d:  85 f6                   test   %esi,%esi
0x0000:                        |    f:  7e 2d                   jle    3e <bubble_p+0x3e>
0x0000:                        |   11:  8d b4 26 00 00 00 00    lea    0x0(%esi,%eiz,1),%esi
0x0000:                        |   18:  31 c0                   xor    %eax,%eax
0x0000:                        |   1a:  8d b6 00 00 00 00       lea    0x0(%esi),%esi
0x0000:                        |   20:  8b 4c 82 04             mov    0x4(%edx,%eax,4),%ecx
0x0000:                        |   24:  8b 1c 82                mov    (%edx,%eax,4),%ebx
0x0000:                        |   27:  39 d9                   cmp    %ebx,%ecx
0x0000:                        |   29:  7d 07                   jge    32 <bubble_p+0x32>
0x0000:                        |   2b:  89 5c 82 04             mov    %ebx,0x4(%edx,%eax,4)
0x0000:                        |   2f:  89 0c 82                mov    %ecx,(%edx,%eax,4)
0x0000:                        |   32:  83 c0 01                add    $0x1,%eax
0x0000:                        |   35:  39 f0                   cmp    %esi,%eax
0x0000:                        |   37:  7c e7                   jl     20 <bubble_p+0x20>
0x0000:                        |   39:  83 ee 01                sub    $0x1,%esi
0x0000:                        |   3c:  75 da                   jne    18 <bubble_p+0x18>
0x0000:                        |   3e:  5b                      pop    %ebx
0x0000:                        |   3f:  5e                      pop    %esi
                               |   
0x0000:                        | Disassembly of section .text.startup:
                               | 
0x0000:                        | 00000000 <main>:
0x0000:                        |    0:  31 c0                   xor    %eax,%eax
                               |   
                               |

第八周课下作业2

把课上练习3的daytime服务器分别用多进程和多线程实现成并发服务器并测试

用多进程实现并发服务器

修改源代码如下：

while (1) {
    connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);
    if (Fork() == 0) { 
        Close(listenfd); /* Child closes its listening socket */
        echo(connfd);    /* Child services client */
        Close(connfd);   /* Child closes connection with client */
        exit(0);         /* Child exits */
    }
    Close(connfd); /* Parent closes connected socket (important!) */
    }

用线程实现并发服务器

#include "csapp.h"

void echo(int connfd);
void *thread(void *vargp);

int main(int argc, char **argv) 
{
    int listenfd, *connfdp, port, clientlen=sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    pthread_t tid; 

    if (argc != 2) {
    fprintf(stderr, "usage: %s <port>\n", argv[0]);
    exit(0);
    }
    port = atoi(argv[1]);

    listenfd = Open_listenfd(port);
    while (1) {
    connfdp = Malloc(sizeof(int));
    *connfdp = Accept(listenfd, (SA *) &clientaddr, &clientlen);
    Pthread_create(&tid, NULL, thread, connfdp);
    }
}

/* thread routine */
void *thread(void *vargp) 
{  
    int connfd = *((int *)vargp);
    Pthread_detach(pthread_self()); 
    Free(vargp);
    echo(connfd);
    Close(connfd);
    return NULL;
}
void echo(int connfd)
{
    size_t n;
    char buf[MAXLINE];
    rio_t rio;
    
    Rio_readinitb(&rio, connfd);
    while((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0) {
        printf("客户端IP:127.0.0.1\n");
        printf("服务器实现学号:20155218\n");
        printf("server received %d bytes\n", n);
        time_t t;
        time(&t);
        printf("当前时间:%s\n",ctime(&t));
        Rio_writen(connfd, buf, n);
    }
}

教材学习内容总结

进程

构造并发程序最简单的方法就是用进程。

一个构造并发服务器的自然方法就是，在父进程中接受客户端连接请求，然后创建一个新的子进程来为每个新客户端提供服务。

基于进程的并发服务器

通常服务器会运行很长的时间，所以我们必须要包括一个 SIGCHLD 处理程序，来回收僵死 (zombie) 子进程的资源。当 SIGCHLD 处理程序执行时， SIGCHLD 信号是阻塞的，而 Unix 信号是不排队的。

父子进程必须关闭它们各自的 connfd 拷贝。父进程必须关闭它的已连接描述符，以避免存储器泄漏。直到父子进程的 connfd 都关闭了，到客户端的连接才会终止。

进程的优劣

优点：一个进程不可能不小心覆盖另一个进程的虚拟存储器，这就消除了许多令人迷惑的错误。

缺点：独立的地址空间使得进程共享状态信息变得更加困难。为了共享信息，它们必须使用显式的IPC(进程间通信)机制。基于进程的设计的另一个缺点是，它们往往比较慢，因为进程控制和 IPC 的开销很高。

线程

线程定义：线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。
线程种类：线程有两种。一种是用户级线程：管理过程全部由用户程序完成，操作系统内核心只对进程进行管理。另外一种是核心级线程：由操作系统内核进行管理。操作系统内核给应用程序提供相应的系统调用和应用程序接口API，以使用户程序可以创建、执行、撤消线程。
进程与线程区别：

地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
调度和切换：线程上下文切换比进程上下文切换要快得多。
在多线程OS中，进程不是一个可执行的实体。

I/O多路复用

可以用作并发事件驱动程序的基础。
将逻辑流模型化为状态机：由一组状态、输入事件和转移，其中转移就是将状态和输入事件映射到状态。
比基于进程的设计给了程序员更多的对程序行为的控制，是运行在单一进程上下文中的。但是代码复杂，不能充分利用多核处理器。

教材学习中的问题和解决过程

无

代码调试中的问题和解决过程

无

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	47/100	1/1	10/10
第二周	180/200	1/1	10/10
第三周	200/300	1/1	10/10
第五周	190/300	1/1	10/10
第六周	220/300	2/2	10/10
第七周	320/500	2/2	10/10
第八周	320/500	3/3	10/10

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。
耗时估计的公式
：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

参考：软件工程软件的估计为什么这么难，软件工程估计方法

计划学习时间:XX小时
实际学习时间:XX小时
改进情况：

(有空多看看现代软件工程课件
软件工程师能力自我评价表)

posted @ 2017-11-12 20:31 田宜楠20155304 阅读(146) 评论(0) 编辑收藏举报

刷新页面返回顶部

田宜楠20155304

2017-2018-1 20155304 《信息安全系统设计基础》第八周学习总结

2017-2018-1 20155304 《信息安全系统设计基础》第八周学习总结

课上测试补充

第八周测试-2

第八周测试-3

课下作业

第八周课下作业1

第八周课下作业2

教材学习内容总结

进程

线程

I/O多路复用

教材学习中的问题和解决过程

代码调试中的问题和解决过程

学习进度条

参考资料

公告