从服务器向客户端发送消息时出错

弹出一个错误：

error: no method named `write` found for type `std::io::BufWriter<&&mut std::net::TcpStream>` in the current scope
  --> <anon>:89:28
   |
89 |                     writer.write(b"OK");
   |                            ^^^^^
   |
   = note: the method `write` exists but the following trait bounds were not satisfied: `&&mut std::net::TcpStream : std::io::Write`

我不知道如何在收到他的数据包后向客户端发送“OK”消息。

游乐场网址和Git 网址

use std::net::{TcpListener, TcpStream};
use std::io::{BufReader, BufWriter};
use std::io::prelude::*;
use std::thread;
//use commands;

pub struct LoginServer {
    address: String,
    //    reader: BufReader<TcpStream>,
}

impl LoginServer {
    pub fn new(hostname: &str, port: &str) -> LoginServer {
        let address = format!("{}:{}", hostname, port);
        //        let stream = TcpStream::connect(&*address).unwrap();

        LoginServer {
            address: address,
            //            reader: BufReader::new(stream),
        }
    }

    pub fn start(&mut self) -> bool {
        let listener = match TcpListener::bind(&*self.address) {
            Ok(data) => data,
            Err(e) => {
                println!("Ошибка открытия порта: {}", e);
                return false;
            },
        };

        for stream in listener.incoming() {
            match stream {
                Ok(mut stream) => {
                    let address = self.address.clone();

                    thread::spawn(move || {
                        handle_client(address, &mut stream);
                    });
                },
                Err(e) => {
                    println!("Ошибка при запуске сервера: {}", e);
                    return false;
                }
            }
        }

        fn handle_client(address: String, client_stream: &mut TcpStream) {
            /*println!("Подключен неизвестный клиент, ip: {}:{}",
                     reader.get_ref().local_addr().unwrap().ip(),
                     reader.get_ref().local_addr().unwrap().port());*/

            let mut writer = BufWriter::new(&client_stream);

            loop {
                let mut data = String::new();

                let result = {
                    let mut reader = BufReader::new(client_stream);


                    match reader.read_line(&mut data).unwrap() {
                        0 => {
                            println!("Неизвестный клиент был отключен, ip: {}:{}",
                                     reader.get_ref().local_addr().unwrap().ip(),
                                     reader.get_ref().local_addr().unwrap().port());
                            return;
                        },
                        _ => (),
                    }

                    let mut server_stream = TcpStream::connect(&*address).unwrap();

                    println!("Принял данные: {}", data);

                    let data = data.trim();
                    let data: Vec<&str> = data.split_whitespace().collect();

                    match data[0] {
                        "login" => true, //commands::login(reader.get_mut(), &mut server_stream, &data[1..]),
                        "register" => true, //commands::new_account(&data[1..]),
                        _ => false,
                    }
                };

                if !result {
                    println!("Неверная команда");
                } else {
                    writer.write(b"OK");
                    //let client_reference = client_stream.by_ref();
                    //let _ = client_reference.write(b"OK");
                }
            }
        }

        true
    }
}