miquels

trait SystemTimeToUnixTime {
    fn unixtime(&self) -> i64;
    fn unixtime_ns(&self) -> i64;
}

impl SystemTimeToUnixTime for std::time::SystemTime {
    fn unixtime(&self) -> i64 {
        match self.duration_since(std::time::SystemTime::UNIX_EPOCH) {
            Ok(n) => n.as_secs().try_into().unwrap_or(i64::MAX), 
            Err(t) => t.duration().as_secs().try_into().map(|t: i64| -t).unwrap_or(i64::MIN),

miquels

The Rust Box::new(X) method first creates X on the stack, then allocates memory and copies X from the stack to the heap. That is very wasteful if X is large.

• Github issue: rust-lang/rust#49733
• Workaround crate: https://github.com/kvark/copyless

Now, it turns out that there is a compiler intrinsic that you can use to allocate a Box and initialize it right on the heap. It's not directly exposed via the standard library, but it is used by the vec! macro here.

So you can use vec! to initialize structures right on the stack. But what if you wanted a Box and not a Vec? Use this macro:

miquels

use std::{
    fs::File,
    io::{Read, Write},
    time::Instant,
};
use tokio::task::{self, JoinHandle};

async fn compute() {
    let handles: Vec<JoinHandle<_>> = (0..1000)
        .map(|_| {

miquels

[package]
name = "wc"
version = "0.1.0"
edition = "2018"

[dependencies]
regex = "1"
lazy_static = "1"

miquels

#
# Calculate the center/average of multiple GeoLocation coordinates
# Expects an array of array refs: ([lat, long], [lat, long]).
#
# @url http://stackoverflow.com/a/14231286/538646
#
use warnings;
use strict;

sub PI() { 4 * atan2(1, 1) }

miquels

#include <sys/time.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <resolv.h>
#include <netdb.h>

miquels

/* cc -DTEST -Wall -o pamtest pam.c -lpam */

#include <security/pam_appl.h>
#include <sys/resource.h>
#include <string.h>
#include <stdlib.h>

struct creds {
    char *user;
    char *password;

miquels

extern crate futures;

use futures::prelude::*;
use std::io;

macro_rules! trait_alias {
    ($alias:ident = $($trait_:tt)*) => {
        trait $alias: $($trait_)* {}
        impl<T: $($trait_)*> $alias for T {}
    }

miquels

use std::io::{self,Error,ErrorKind};
use std::path::Path;

use openssl::pkey::PKey;
use openssl::x509::X509;
use openssl::pkcs12::Pkcs12;
use openssl::stack::Stack;
use native_tls::{self,Identity};

fn read_pems(key: impl AsRef<Path>, cert: impl AsRef<Path>, password: &str) -> io::Result<Vec<u8>> {

miquels

extern crate libc;
extern crate tokio_uds;

use std::os::unix::io::AsRawFd;

// this is automatically enabled on stream socket - only for
// datagram sockets do you need to manually enable it.
fn enable_so_passcred(unix_socket: &tokio_uds::UnixListener) {
    let fd = unix_socket.as_raw_fd();
    let val: libc::c_int = 1;