OPENSSL error: could not find native static library `C`, perhaps an -L flag is missing?

[aishwaryagm1999]

I get the following error when I try to run the below code for a DTLS client server program using rust through visual studio code and its terminal. I have already installed openssl libraries using vcpkg and set the environment variables. I have also installed the c/c++ extensions for vscode.

Error: error: could not find native static library C, perhaps an -L flag is missing? How do I resolve this error? My DTLS code is given below along with build.rs and cargo.toml. I get the same error when I try to run any openssl-dependant codes in C/C++/Rust.

MAIN.rs

use openssl::ssl::SslMethod;
use std::{ io::{Read, Write},
net::UdpSocket, thread, time::Duration, };
use udp_dtls::{Certificate, DtlsAcceptor, DtlsConnector, Identity, SrtpProfile};
use udp_dtls::{DtlsAcceptorBuilder, UdpChannel};
fn main() { let buffer = include_bytes!("../test/identity.p12");
let identity = Identity::from_pkcs12(buffer, "mypass").unwrap();
let root_ca = include_bytes!("../test/root-ca.der"); let root_ca = Certificate::from_der(root_ca).unwrap();
let acceptor = DtlsAcceptor::builder(identity).build().unwrap();

let connector = DtlsConnector::builder() .add_srtp_profile(SrtpProfile::Aes128CmSha180) .add_srtp_profile(SrtpProfile::AeadAes256Gcm) .add_root_certificate(root_ca) .build() .unwrap(); let server = UdpSocket::bind("127.0.0.1:0").unwrap(); let client = UdpSocket::bind("127.0.0.1:0").unwrap(); let server_addr = server.local_addr().unwrap(); let client_addr = client.local_addr().unwrap(); let server_channel = UdpChannel { socket: server, remote_addr: client_addr, }; let client_channel = UdpChannel { socket: client, remote_addr: server_addr, }; let guard = thread::spawn(move || { let mut dtls_server = acceptor.accept(server_channel).unwrap(); let mut count = 0; while true { let mut received = [0; 5]; dtls_server.read_exact(&mut received); println!( "{:?} {:?}", count, String::from_utf8_lossy(received.as_ref()) ); count = count + 1; thread::sleep(Duration::from_millis(2)); } }); let mut dtls_client = connector.connect("foobar.com", client_channel).unwrap(); while true { let mut buf = [0; 5]; let buf = b"hello"; dtls_client.write_all(buf); thread::sleep(Duration::from_millis(30)); } } CARGO.toml

[package]
name = "udp-dtls"
version = "0.1.0"
authors = ["Timon Post <https://github.com/TimonPost>"]
edition = "2018"
description = "DTLS abstraction ontop of UDP"
repository = "https://github.com/TimonPost/udp-dtls"
documentation = "https://docs.rs/udp-dtls/"
license = "MIT"
keywords = ["DTLS", "UDP", "connection", "openssl", "ssl"] exclude = ["target", "Cargo.lock"] readme = "README.md" [dependencies] openssl = "0.10.19" openssl-probe = "0.1.2" log = "0.4.6" bytes = "0.4.11" [features] vendored = ["openssl/vendored"]

BUILD.rs

BUILD.rs use std::fs::File; use std::io::Write; use std::process::Command; use std::env; fn main() -> std::io::Result<()> {

if let Ok(v) = env::var("DEP_OPENSSL_VERSION_NUMBER") {
    let version = u64::from_str_radix(&v, 16).unwrap();

    if version >= 0x1_01_01_00_0 {
        println!("cargo:rustc-cfg=openssl111");
    }
}

let certs_dir = "src/certs";
let keys_dir = "src/keys";
let scratch_dir = "openssl-temp";
let server_ext = &format!("{}/server_ext", scratch_dir);
let client_ext = &format!("{}/client_ext", scratch_dir);

for dir in &[certs_dir, keys_dir, scratch_dir] {
    // create if dir does not exist
    match std::fs::create_dir(dir) {
        _ => {}
    }
}

let mut file = File::create(server_ext).unwrap();
file.write(b"basicConstraints=CA:false\nkeyUsage=critical,keyEncipherment")?;

let mut file = File::create(client_ext).unwrap();
file.write(b"basicConstraints=CA:false\nkeyUsage=critical,digitalSignature")?;

// Generate self-signed CA
Command::new("openssl")
    .args(&[
        "req",
        "-x509",
        "-newkey",
        "rsa:2048",
        "-subj",
        "/CN=ca",
        "-nodes",
        "-keyout",
        &format!("{}/ca-key.pem", keys_dir),
        "-out",
        &format!("{}/ca-cert.pem", certs_dir),
        "-addext",
        "keyUsage=critical,keyCertSign",
    ])
    .output()?;

// Generate server key and CSR
Command::new("openssl")
    .args(&[
        "req",
        "-newkey",
        "rsa:2048",
        "-subj",
        "/CN=server",
        "-nodes",
        "-keyout",
        &format!("{}/server-key.pem", keys_dir),
        "-out",
        &format!("{}/server-csr.pem", scratch_dir),
    ])
    .output()?;

// Sign server CSR
Command::new("openssl")
    .args(&[
        "x509",
        "-req",
        "-CAcreateserial",
        "-CA",
        &format!("{}/ca-cert.pem", certs_dir),
        "-CAkey",
        &format!("{}/ca-key.pem", keys_dir),
        "-in",
        &format!("{}/server-csr.pem", scratch_dir),
        "-out",
        &format!("{}/server-cert.pem", certs_dir),
        "-extfile",
        server_ext,
    ])
    .output()?;

// Generate client key and CSR
Command::new("openssl")
    .args(&[
        "req",
        "-newkey",
        "rsa:2048",
        "-subj",
        "/CN=client",
        "-nodes",
        "-keyout",
        &format!("{}/client-key.pem", keys_dir),
        "-out",
        &format!("{}/client-csr.pem", scratch_dir),
    ])
    .output()?;

// Sign client CSR
Command::new("openssl")
    .args(&[
        "x509",
        "-req",
        "-CAcreateserial",
        "-CA",
        &format!("{}/ca-cert.pem", certs_dir),
        "-CAkey",
        &format!("{}/ca-key.pem", keys_dir),
        "-in",
        &format!("{}/client-csr.pem", scratch_dir),
        "-out",
        &format!("{}/client-cert.pem", certs_dir),
        "-extfile",
        client_ext,
    ])
    .output()?;

std::fs::remove_dir_all(scratch_dir)?;

Ok(())

} For further reference please check this link for full code: https://github.com/TimonPost/udp-dtls

[ehuss]

I'm going to close as this appears to be an issue with using a third-party library. The rust-lang/rust issue tracker is for issues specific to the compiler. Questions like these are best asked on one of the user forums (and it looks like you have asked on https://users.rust-lang.org/t/openssl-error-could-not-find-native-static-library-c-perhaps-an-l-flag-is-missing/75476).

Also, some tips for more likely getting some assistance:

• Try to format your message using markdown. Currently it looks quite jumbled. Code blocks can be placed in triple backticks. Sites like https://www.markdownguide.org/ can help you with formatting.
• Try to minimize your example. Does it happen with just the openssl dependency? Can you remove chunks of your code? The more minimal your example is the more likely someone can help. See Minimal, Reproducible Example
• The sample repo you linked to (https://github.com/TimonPost/udp-dtls) does not match the code you posted in your message (it is not entirely clear how they are related).
• Include the exact error message displayed by cargo. That is, copy and paste the entire output.
• Indicate how you ran cargo. Which version of Rust are you using? Which platform are you targeting? x86_64-pc-windows-msvc or x86_64-pc-windows-gnu? Or something else?