小编use*_*648的帖子

该文件提供了一个例子-不幸的是它不会编译; 很多东西都被重命名了，ClientSession构造函数的接口也发生了变化。我设法将错误修复到可以编译的程度，但不能修复到可以工作的程度。

这是我使最小示例工作的最佳尝试：

extern crate rustls;

use io::Read;
use io::Write;
use rustls::Session;
use std::io;

fn main() {
    let mut socket = std::net::TcpStream::connect("www.google.com:443").unwrap();
    let mut config = rustls::ClientConfig::new();
    config
        .root_store
        .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
    let arc = std::sync::Arc::new(config);
    let dns_name = webpki::DNSNameRef::try_from_ascii_str("www.google.com").unwrap();
    let mut client = rustls::ClientSession::new(&arc, dns_name);
    client.write(b"GET https://www.google.com\r\n\r\n").unwrap();
    loop {
        if client.wants_read() {
            client.read_tls(&mut socket).unwrap();
            client.process_new_packets().unwrap();
            let mut plaintext = Vec::new();
            client.read_to_end(&mut plaintext).unwrap();
            io::stdout().write(&plaintext).unwrap();
        }
        if client.wants_write() {
            client.write_tls(&mut socket).unwrap();
        }
        // For testing purposes only
        std::thread::sleep_ms(1000);
    } …

我试图smtp.SendMail()在go程序中使用。但是它会阻塞，直到超时才返回。这使我无法找出问题所在。

我的代码：

to := []string{"recepient@example.com"}
err := smtp.SendMail("smtp.web.de:25", smtp.CRAMMD5Auth("example@web.de", "password"), "example@web.de", to, []byte("hi"))
if err != nil {
    fmt.Println(err)
}else{
    fmt.Println("Success")
}

长时间后，出现以下错误：

to := []string{"recepient@example.com"}
err := smtp.SendMail("smtp.web.de:25", smtp.CRAMMD5Auth("example@web.de", "password"), "example@web.de", to, []byte("hi"))
if err != nil {
    fmt.Println(err)
}else{
    fmt.Println("Success")
}

有什么想法可能是真正的问题吗？

我正在构建一个使用 websockets 的服务器。
目前，每个连接的客户端都使用两个 goroutine。一本用于阅读，一本用于写作。编写 goroutine 基本上会监听它应该发送的消息的通道，然后尝试传递它们。

type User struct{
    send chan []byte
    ...
}

func (u *User) Send(msg []byte){
    u.send <- msg
}

问题是，从客户端 A 读取可能会导致写入客户端 B。假设到 B 的连接有一些问题（例如非常慢）并且它的发送通道已经满了。当前的行为是，尝试向通道添加消息现在开始阻塞，直到从通道中删除某些内容。这意味着，现在 A 等待直到 B 的缓冲区不再满。

我想像这样解决它：

func (u *User) Send(msg []byte) err{
    u.send, err <- msg
    if err != nil{
        //The channels buffer is full.
        //Writing currently not possible.
        //Needs appropriate error handling.
        return err
    }
    return nil
}

基本上，我想要错误处理而不是阻塞，以防缓冲区已满。我如何做到最好？

我已经阅读了一些关于 C++ 中 printf() 的安全性。例如可以在这里找到示例。这让我想知道fmt.Printf()来自 golang 是否安全。更具体地说，如果格式化字符串本身可以伪造是否安全。

inputString := "String from user"
x := "test"
fmt.Printf(inputString, x, 15)

当试图从 C++ 复制漏洞时，golang 似乎并不容易受到攻击。

例如fmt.Printf("%s%s%s%s%s%s%s%s%s%s%s%s\n")，不会使 golang 中的程序崩溃。

当然，这样的分析并不能证明这在 golang 中是安全的。所以我想在这里问：go 的开发人员是否对其 printf 函数进行了万无一失？

编辑：通过万无一失，我的意思是它没有任何意外的副作用。我当然希望得到的字符串完全受到损害。我不希望用户能够获得特权信息（例如未传递给 printf 的变量内容），或者用户能够写入任何内存（例如，为 x 分配新值）。

我想使用 Collidable 接口实现一个碰撞库

type Collidable interface{
    BoundingBox() (float64,float64,float64,float64)
    FastCollisionCheck(c2 Collidable) bool
    DoesCollide(c2 Collidable) bool
    Collide(c2 Collidable)
}

它具有预定义的形状，例如。

type Circle struct{
X,Y,Radius float64
}

这个想法是我可以做到

type Rock struct{
    collision.Circle
    ....
}

然后实现接口 Collidable，所以我可以将它传递给一个空间哈希映射（期望一个可碰撞的）。唯一需要做的就是根据我的需要覆盖 Collide() 函数。

但是type circle中的函数不能处理type rock，即使是强硬的它嵌入了一个圆圈。

func (c1 *Circle) DoesCollide(i Collidable) bool{
    switch c2 := value.(type) {
    case Circle:
    //doesn't fire, as it is of type Rock (unknown in this package)
    //Needed is something like
    //if i_embeds_Circle then c2 := i_to_Circle 
    }
}

这可能吗？有没有更好的办法？

我想通过 golang 制作一个自定义的网络服务器。它需要 root 才能绑定到端口 80。但是我想尽快删除 root。 syscall.SetUid()根据票证 #1435返回“不支持” 。

我总是可以通过 iptables 将端口 80 重新路由到其他地方，但是这会打开任何非 root 进程以伪装成我的网络服务器 - 我不希望这是可能的。

我如何放弃我的应用程序的权限（或者干净地解决这个问题）。

我最近注意到你可以做类似的事情

void foo(){ }
//...
std::cout<<foo<<std::endl;

无论传递的函数如何,这都会打印出"1".

现在我很好奇:这究竟是做什么的？