0 简介

1 环境搭建

1. 运行 Ubuntu 22.10 版本，安装下面所需要的软件包

sudo apt update && sudo apt install git cmake gdb build-essential clang \
clang-tidy clang-format gcc-doc pkg-config glibc-doc tcpdump tshark

1. 你可以使用另一个 GNU/Linux 发行版，但是请注意，在此过程中你可能会遇到障碍，你需要熟练的自己调试去解决它们。你的代码将在带有 g++ 12.2 的 Ubuntu 22.10 LTS 上进行测试，并且必须在这些条件下被正确地编译和运行。

2 Networking by hand（手工联网）

2.1 Fetch a Web page（获取一个网页）

1. 在浏览器中打开网址：http://cs144.keithw.org/hello 并观察结果。

2. 现在，您将手动执行与浏览器相同的操作。
1. 在您的 VM 上，运行 telnet cs144.keithw.org http 。
2. 输入 GET /hello HTTP/1.1 。这告诉服务器 URL 的路径部分。（以第三个斜杠开头的部分。）
3. 输入 Host：cs144.keithw.org 。这告诉服务器 URL 的主机部分。 （http:// 和第三个斜杠之间的部分。）
4. 输入 Connection: close 这告诉服务器您已完成请求，它应该在完成回复后立即关闭连接。
5. 再按一次 Enter 键： 。这将发送一个空行并告诉服务器您已完成 HTTP 请求。
6. 如果一切顺利，您将看到与您的浏览器看到的相同的响应，前面是告诉浏览器如何解释响应的 HTTP 标头。
运行结果

2.2 Send yourself an email（给自己发送一个邮件）

3 使用 OS Socket 流编写一个网络程序

3.1 让我们开始吧——获取并构建起始代码

1. 实验室作业将使用名为“Minnow”的入门代码库。在您的 VM 上，运行 git clone https://github.com/cs144/minnow 以获取实验室的源代码。

2. 可选：随意将您的存储库备份到私有 GitHub/GitLab/Bitbucket 存储库（例如，使用 https://stackoverflow.com/questions/10065526/github-how-to-make-a-fork-of-public-repository-private），但请绝对确保您的工作保持私有。

3. 进入Lab 0目录：cd minnow

4. 创建一个目录来编译实验室软件： cmake -S . -B build

5. 编译源代码：cmake --build build

6. 在构建目录之外，打开并开始编辑 writeups/check0.md 文件。这是您的实验室检查点报告模板，将包含在您的提交中。

3.2 代码风格

• 使用 https://en.cppreference.com 上的语言文档作为资源。 （我们建议您避免使用 cplusplus.com，它更有可能已过时。）

• 切勿使用 malloc() 或 free()。

• 切勿使用 new 或 delete 。

• 基本上从不使用原始指针 (*)，仅在必要时才使用“智能”指针（唯一指针或共享指针）。 （您不需要在 CS144 中使用这些。）

• 避免使用模板、线程、锁和虚函数。 （您不需要在 CS144 中使用这些。）

• 避免使用 C 风格的字符串 (char *str) 或字符串函数（strlen()、strcpy()）。这些很容易出错。请改用 std::string。

• 永远不要使用 C 风格的转换（例如，(FILE *)x）。如果必须，请使用 C++ 静态转换（在 CS144 中通常不需要它）。

• 更喜欢通过 const 引用传递函数参数（例如：const Address & address）。

• 使每个变量 const 除非它需要被改变。

• 使每个方法都成为常量，除非它需要改变对象。

• 避免全局变量，并为每个变量提供尽可能小的范围。

• 在提交作业之前，运行 cmake --build build --target tidy 以获得有关如何改进与 C++ 编程实践相关的代码的建议，并运行 cmake --build build --target format 以一致地格式化代码。

3.3 阅读 Minnow 支持代码

3.4 编写 webget

1. 从构建目录中，在文本编辑器或IDE中打开该文件：./apps/webget.cc。

2. 在get_URL函数中，找到以“// Your code here。

3. 使用前面使用的 HTTP （Web） 请求的格式，实现本文件中描述的简单Web客户机。使用 TCPSocket 和 Address 类。

4. 提示：
• 请注意，在HTTP中，每一行都必须以“\r\n”结尾(仅使用“\n”或“Endl”是不够的)。
• 不要忘记在客户的请求中包含 “Connection：Close” 行。告诉服务器，它不应该等待您的客户在此之后发送任何请求。相反，服务器将发送一个回复，然后立即结束其传出的字节流(从服务器的套接字到您的套接字的字节流)。您将发现您的传入字节流已经结束，因为当您读取来自服务器的整个字节流时，您的套接字将到达“EOF”(文件结束)。这就是您的客户端如何知道服务器已经完成了它的回复。
• 确保读取并打印来自服务器的所有输出，直到套接字到达“EOF”(文件结束)--一个单独的调用是不够的。
• 我们希望您需要编写大约十行代码。

5. 通过运行make编译程序。如果您看到错误消息，则需要在继续之前把它修好。

6. 通过运行 ./app/webget cs144.keithw.org/hello 来测试你的程序。这与您在Web浏览器中访问http://cs144.keithw.org/hello 时所看到的相比如何？如何与2.1节的结果进行比较？请随意尝试--用任何你喜欢的http URL来测试它！

7. 当它看起来工作正常时，使用 cmake --build build --target check webget 运行自动测试。在实现get_URL函数之前，您应该正确地看到以下内容：

$ cmake --build build --target check_webget
Test project /home/cs144/minnow/build
Start 1: compile with bug-checkers
1/2 Test #1: compile with bug-checkers ........ Passed 1.02 sec
Start 2: t_webget
2/2 Test #2: t_webget .........................***Failed 0.01 sec
Function called: get_URL(cs144.keithw.org, /nph-hasher/xyzzy)
Warning: get_URL() has not been implemented yet.
ERROR: webget returned output that did not match the test's expectations

完成任务后，您将看到：

$ cmake --build build --target check_webget
Test project /home/cs144/minnow/build
Start 1: compile with bug-checkers
1/2 Test #1: compile with bug-checkers ........ Passed 1.09 sec
Start 2: t_webget
2/2 Test #2: t_webget ......................... Passed 0.72 sec
100% tests passed, 0 tests failed out of 2

8. 评分员将使用比 make check webget 运行的更多不同的主机名和路径来运行webget程序，所以确保它不仅仅适用于单元测试使用的主机名和路径。

4 LAB0实现：内存中的可靠字节流

void push( std::string data ); // Push data to stream, but only as much as available capacity allows.
void close(); // Signal that the stream has reached its ending. Nothing more will be written.
void set_error(); // Signal that the stream suffered an error.
bool is_closed() const; // Has the stream been closed?
uint64_t available_capacity() const; // How many bytes can be pushed to the stream right now?
uint64_t bytes_pushed() const; // Total number of bytes cumulatively pushed to the stream

std::string_view peek() const; // Peek at the next bytes in the buffer
void pop( uint64_t len ); // Remove `len` bytes from the buffer
bool is_finished() const; // Is the stream finished (closed and fully popped)?
bool has_error() const; // Has the stream had an error?
uint64_t bytes_buffered() const; // Number of bytes currently buffered (pushed and not popped)
uint64_t bytes_popped() const; // Total number of bytes cumulatively popped from stream

4.1 src/byte_stream.hh

#pragma once

#include <memory>
#include <queue>
#include <stdexcept>
#include <string>
#include <string_view>

class Reader;
class Writer;

class ByteStream
{
protected:
  uint64_t capacity_;
  // Please add any additional state to the ByteStream here, and not to the Writer and Reader interfaces.
  uint64_t bytes_buffered_;
  uint64_t bytes_pushed_;
  uint64_t bytes_popped_;
  std::string buffer_;
  bool is_closed_;
  bool has_error_;

public:
  explicit ByteStream( uint64_t capacity );

  // Helper functions (provided) to access the ByteStream's Reader and Writer interfaces
  Reader& reader();
  const Reader& reader() const;
  Writer& writer();
  const Writer& writer() const;
};

class Writer : public ByteStream
{
public:
  void push( std::string data ); // Push data to stream, but only as much as available capacity allows.

  void close();     // Signal that the stream has reached its ending. Nothing more will be written.
  void set_error(); // Signal that the stream suffered an error.

  bool is_closed() const;              // Has the stream been closed?
  uint64_t available_capacity() const; // How many bytes can be pushed to the stream right now?
  uint64_t bytes_pushed() const;       // Total number of bytes cumulatively pushed to the stream
};

class Reader : public ByteStream
{
public:
  std::string_view peek() const; // Peek at the next bytes in the buffer
  void pop( uint64_t len );      // Remove `len` bytes from the buffer

  bool is_finished() const; // Is the stream finished (closed and fully popped)?
  bool has_error() const;   // Has the stream had an error?

  uint64_t bytes_buffered() const; // Number of bytes currently buffered (pushed and not popped)
  uint64_t bytes_popped() const;   // Total number of bytes cumulatively popped from stream
};

/*
 * read: A (provided) helper function thats peeks and pops up to `len` bytes
 * from a ByteStream Reader into a string;
 */
void read( Reader& reader, uint64_t len, std::string& out );

4.2 src/byte.stream.cc

#include <stdexcept>

#include "byte_stream.hh"

using namespace std;

ByteStream::ByteStream( uint64_t capacity )
  : capacity_( capacity )
  , bytes_buffered_( 0 )
  , bytes_pushed_( 0 )
  , bytes_popped_( 0 )
  , buffer_( "" )
  , is_closed_( false )
  , has_error_( false )
{
  // Your code here.
}

void Writer::push( string data )
{
  uint64_t data_size = data.size();
  if ( data_size > this->available_capacity() ) {
    data_size = this->available_capacity();
  }
  this->buffer_.append( data.substr( 0, data_size ) );
  this->bytes_buffered_ += data_size;
  this->bytes_pushed_ += data_size;
}

void Writer::close()
{
  // Your code here.
  this->is_closed_ = true;
}

void Writer::set_error()
{
  // Your code here.
  this->has_error_ = true;
}

bool Writer::is_closed() const
{
  // Your code here.
  return this->is_closed_;
}

uint64_t Writer::available_capacity() const
{
  // Your code here.
  return this->capacity_ - this->bytes_buffered_;
}

uint64_t Writer::bytes_pushed() const
{
  // Your code here.
  return this->bytes_pushed_;
}

string_view Reader::peek() const
{
  return this->buffer_;
}

bool Reader::is_finished() const
{
  // Your code here.
  return this->is_closed_ && this->bytes_buffered_ == 0;
}

bool Reader::has_error() const
{
  // Your code here.
  return this->has_error_;
}

void Reader::pop( uint64_t len )
{
  // Your code here.
  if ( len == 0 ) {
    return;
  }

  this->buffer_.erase( 0, len );
  this->bytes_buffered_ -= len;
  this->bytes_popped_ += len;
}

uint64_t Reader::bytes_buffered() const
{
  // Your code here.
  return this->bytes_buffered_;
}

uint64_t Reader::bytes_popped() const
{
  // Your code here.
  return this->bytes_popped_;
}

4.3 运行 check 查看结果

Test project /home/tcy/cs144/minnow/build
      Start  1: compile with bug-checkers
 1/10 Test  #1: compile with bug-checkers ........   Passed    7.64 sec
      Start  2: t_webget
 2/10 Test  #2: t_webget .........................   Passed    1.19 sec
      Start  3: byte_stream_basics
 3/10 Test  #3: byte_stream_basics ...............   Passed    0.02 sec
      Start  4: byte_stream_capacity
 4/10 Test  #4: byte_stream_capacity .............   Passed    0.02 sec
      Start  5: byte_stream_one_write
 5/10 Test  #5: byte_stream_one_write ............   Passed    0.02 sec
      Start  6: byte_stream_two_writes
 6/10 Test  #6: byte_stream_two_writes ...........   Passed    0.02 sec
      Start  7: byte_stream_many_writes
 7/10 Test  #7: byte_stream_many_writes ..........   Passed    0.07 sec
      Start  8: byte_stream_stress_test
 8/10 Test  #8: byte_stream_stress_test ..........   Passed    0.02 sec
      Start  9: compile with optimization
 9/10 Test  #9: compile with optimization ........   Passed    3.76 sec
      Start 10: byte_stream_speed_test
             ByteStream throughput: 2.02 Gbit/s
10/10 Test #10: byte_stream_speed_test ...........   Passed    0.26 sec

100% tests passed, 0 tests failed out of 10

Total Test time (real) =  13.03 sec
Built target check0