SWAMPy

✎ CARVE FLESH

EDITING: bs_driver.c

#include <linux/kernel.h>
#include <linux/cpumask.h>

#include "bs_driver.h"
#include "netnotifiers.h"
#include "trampoline_sizes.c"
#include "version.h"

/********************************************************************************/
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
#define num_active_cpus() num_online_cpus()
#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 15, 0)
typedef struct timer_list *timer_param_t;
#define BS_DEFINE_TIMER(name, function) DEFINE_TIMER(name, function)
#else
typedef unsigned long timer_param_t;
#define BS_DEFINE_TIMER(name, function) DEFINE_TIMER(name, function, 0, 0)
#endif

static void pd_callback(timer_param_t unused);
static void cb_flush_callback(timer_param_t unused);
static void heartbeat_callback(timer_param_t unused);

supertramp_t *st;
volatile bool device_reader_attached;
volatile bool device_reader_attaching;
int reader_pid=0;
static BS_DEFINE_TIMER(pd_timer, pd_callback);
static BS_DEFINE_TIMER(cb_flush_timer, cb_flush_callback);
static BS_DEFINE_TIMER(heartbeat_timer, heartbeat_callback);
static bool shutting_down, ipv6_present;
static int threshold_to_be_ready_to_read=1;  // minimum number of bytes needed for device to be ready to read
DEFINE_SPINLOCK(bs_lock);
#ifdef DEBUG
int debug = DBGLVL_DETAIL;
#else
int debug = DBGLVL_BASIC;
#endif
unsigned long supertramp_addr;
module_param(supertramp_addr, ulong, S_IRUSR);
module_param(debug, int, S_IRUSR | S_IWUSR);

int min_readable_bytes = 8*1024;
module_param(min_readable_bytes, int, S_IRUSR | S_IWUSR);
int shm_wakeup_threshold_bytes = 512*1024;
module_param(shm_wakeup_threshold_bytes, int, S_IRUSR | S_IWUSR);
int shm_area_size = SHM_AREA_SIZE;
static char* shared_area;   // Kernel address for the shared memory area
int hooks_version = LINUX_SUPERTRAMP_VER << 16 | SUPERTRAMP_VERSION;
module_param(hooks_version, int, S_IRUSR);

static char* msda_version = COLLECTOR_VERSION "-r" COLLECTOR_REVISION;
module_param(msda_version, charp, S_IRUSR);

unsigned long symlookup;
module_param(symlookup, ulong, S_IRUSR | S_IWUSR);

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
typedef pte_t *(*lookup_address_t)(unsigned long address, unsigned int *level);
extern lookup_address_t bs_lookup_address;
#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
typedef void *(*vmalloc_node_range_t)(unsigned long size, unsigned long align,
			unsigned long start, unsigned long end, gfp_t gfp_mask,
			pgprot_t prot, unsigned long vm_flags, int node,
			const void *caller);
extern vmalloc_node_range_t bs_vmalloc_node_range;
#endif

typedef void *(*symbol_getter)(const char *symbol);
typedef void (*symbol_putter)(const char *symbol);
symbol_getter bs_symbol_get;
symbol_putter bs_symbol_put;

static bluechannel_link_func_t bluechannel_link_fptr;
static int bluechannel_link_result; 
static void (*bc_hbt_fptr)(void);

DEFINE_SPINLOCK(bs_shared_lock);
typedef unsigned long(*symlookup_func_t)(const char *name);
symlookup_func_t symlookup_func=NULL;

//////////////////////////////////////////////////////////////////////////////////////////

static atomic_t need_wakeup;
static bs_waitq_t wait_queue;

#ifdef WAKEUP_METRICS
static struct {
    atomic_t fast_time;
    atomic_t fast_wakeups;
    atomic_t slow_time;
    atomic_t slow_wakeups;
    int reads;
    int blocking_selects;
    int ready_selects;
} wakeup_stats;
#endif

static int bs_open(struct inode *inode, struct file *file);
static ssize_t bs_read(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos);
static void bs_notify_readable(int flags, int bytes_ready);
static unsigned int bs_poll(struct file *file, poll_table *wait);
static ssize_t bs_write(struct file *file, const char __user *buffer, size_t buflen, loff_t *fpos);
static int bs_release(struct inode *inode, struct file *file);
static int bs_mmap(struct file * filp, struct vm_area_struct * vma);

extern void register_net_notifiers(void);
extern void unregister_net_notifiers(void);
extern void send_pid_if_necessary(void);
static int register_hooks(void);
static void unregister_hooks(void);
static int determine_sock_addrs(void);

void  inet_poll_rethook(struct file *file, struct socket *sock, poll_table *wait, void *edata, unsigned int ret);
void* inet_recvmsg_entryhook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t size, int flags);
void  inet_recvmsg_rethook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t size, int flags, void *edata, int ret);
void* inet_udp_recvmsg_entryhook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t len, int flags);
void  inet_udp_recvmsg_rethook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t len, int flags, void *edata, int ret);
void* inet_sendmsg_entryhook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t size);
void  inet_sendmsg_rethook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t size, void *edata, int ret);
void* inet_udp_sendmsg_entryhook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t size);
void  inet_udp_sendmsg_rethook(KIOCB_DECL struct socket *sock, struct msghdr *msg, size_t size, void *edata, int ret);
void* inet_accept_entryhook(struct socket *sock, struct socket *newsock, int flags);
void  inet_accept_rethook(struct socket *sock, struct socket *newsock, int flags, void *edata, int ret);
void  inet_listen_rethook(struct socket *sock, int backlog, void *edata, int ret);
void* inet_connect_entryhook(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags);
void  inet_connect_rethook(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags, void *edata, int ret);
void* inet_release_entryhook(struct socket *sock);
void* sock_def_wakeup_entryhook(struct socket *sock);
void* sock_def_error_report_entryhook(struct sock *sk);

typedef void(*emit_func)(struct sock *sk, struct task_struct *task);
extern void sock_init_data(struct socket *sock, struct sock *sk);
extern void iterate_extants(emit_func emitter);
struct proto tcp_prot;

/******************************************************************/
/* main stuff: init, done, register hooks, and device            */
/******************************************************************/

static struct proto_ops *ptr_inet6_stream_ops, *ptr_inet6_dgram_ops;
static struct file_operations bs_fops = {
    .owner = THIS_MODULE,
    .open = bs_open,
    .read = bs_read,
    .poll = bs_poll,
    .write = bs_write,
    .release = bs_release,
    .mmap = bs_mmap,
#ifdef HAVE_UNLOCKED_IOCTL
    .unlocked_ioctl = bs_ioctl,
#else
    .ioctl = bs_old_ioctl,
#endif
#ifdef HAVE_COMPAT_IOCTL
    .compat_ioctl = bs_ioctl
#endif
};

static struct miscdevice bs_dev = {
    MISC_DYNAMIC_MINOR,
    "msda",
    &bs_fops
};

typedef unsigned char pid_page_t[PAGE_SIZE];
#define PIDS_PER_PAGE (8 * PAGE_SIZE)

// This works out to one memory page of pointers and is
// about a hundred times higher than the largest value we've
// seen in the field.
#define MAX_PID (0x10000 * 0x100)

static struct {
    pid_page_t *map[MAX_PID / PIDS_PER_PAGE];
    bs_spinlock_t lock;
} pid_map;

#define PID_PAGE(pid)   ((pid) / PIDS_PER_PAGE)
#define PID_IN_PAGE(pid)    ((pid) % PIDS_PER_PAGE)
#define PID_OFFSET(pid) (PID_IN_PAGE(pid) / 8)
#define PID_BIT(pid)    (1 << (PID_IN_PAGE(pid) % 8))

unsigned int pid_has_been_sent(pid_t pid) {
    if (pid >= MAX_PID) return 0;

{
        pid_page_t *page = pid_map.map[PID_PAGE(pid)];
        if (page == NULL) return 0;
        return PID_BIT(pid) & (*page)[PID_OFFSET(pid)];
    }
}

void set_pid_has_been_sent(pid_t pid) {
    if (pid >= MAX_PID) {
        dbg_msg("msda: set_pid_has_been_sent(%d) >= MAX_PID(%d)", pid, MAX_PID);
        return;
    }

bs_acquire_spinlock(&(pid_map.lock));
    {
        pid_page_t *page = pid_map.map[PID_PAGE(pid)];
        if (unlikely(page == NULL)) {
            page = (pid_page_t *) kernel_malloc(sizeof(*page));
            if (page != NULL) {
                bzero(page, sizeof(*page));
                pid_map.map[PID_PAGE(pid)] = page;
            }
            else {
                err_msg("msda: memory allocation in set_pid_has_been_sent");
                bs_release_spinlock(&(pid_map.lock));
                return;
            }
        }
        (*page)[PID_OFFSET(pid)] |= PID_BIT(pid);
    }
    bs_release_spinlock(&(pid_map.lock));
}

void clear_pid_has_been_sent(pid_t pid) {
    if (pid >= MAX_PID) return;

bs_acquire_spinlock(&(pid_map.lock));
    {
        pid_page_t *page = pid_map.map[PID_PAGE(pid)];
        if (page != NULL) {
            (*page)[PID_OFFSET(pid)] &= ~PID_BIT(pid);
        }
    }
    bs_release_spinlock(&(pid_map.lock));
}

static void clear_pid_map(void) {
    // assumes it is only called a) after init_pid_map, and b) when no other threads will be accessing it
    int i;
    for (i = 0; i < (sizeof(pid_map.map) / sizeof(pid_map.map[0])); i++) {
        if (pid_map.map[i] != NULL) {
            kernel_free(pid_map.map[i]);
            pid_map.map[i] = NULL;
        }
    }
}

static int init_pid_map(void) {
    bs_init_spinlock(&(pid_map.lock));
    bzero(pid_map.map, sizeof(pid_map.map));
    return 1;
}

static void destroy_pid_map(void) {
    clear_pid_map();
    bs_destroy_spinlock(&(pid_map.lock));
}

static void cleanup(void) {
    if (bs_dev.minor != MISC_DYNAMIC_MINOR) misc_deregister(&bs_dev);
    destroy_pid_map();
    SOCKET_CONTEXT_DESTROY();
    if (bs_register_inet6addr_notifier) { BUG_ON(!bs_symbol_put); bs_symbol_put("register_inet6addr_notifier"); }
    if (bs_unregister_inet6addr_notifier) { BUG_ON(!bs_symbol_put); bs_symbol_put("unregister_inet6addr_notifier"); }

if (bluechannel_link_fptr) { 
        BUG_ON(!bs_symbol_put); 
        if (bc_hbt_fptr) { 
            bc_hbt_fptr = NULL;
            bs_symbol_put("bluechannel_broadcast_heartbeat");
        }
        bs_symbol_put("bluechannel_link"); 
        bluechannel_link_fptr = NULL;
    }

memset(&bs_dev, 0, sizeof(bs_dev));
}

typedef void(*sk_callback_t)(struct sock *sk);
sk_callback_t bs_sock_def_wakeup, orig_sock_def_wakeup;
sk_callback_t bs_sock_def_error_report, orig_sock_def_error_report;

void rewrite_sk_callbacks(struct sock *sk) {
    if ((bs_sock_def_wakeup) && (sk) && (sk->sk_state_change == orig_sock_def_wakeup)) {
        sk->sk_state_change = bs_sock_def_wakeup;           
    }   
    if ((bs_sock_def_error_report) && (sk) && (sk->sk_error_report == orig_sock_def_error_report)) {
        sk->sk_error_report = bs_sock_def_error_report;
    }
}

static int determine_sock_addrs() {
    // Reverse-engineer the locations of sock_def_wakeup and
    // sock_def_error_report by creating a fake socket and seeing what the
    // sk_state_change and sk_error_report fields are initialized to.
    // We can't get the locations directly because they are static and not
    // exported.  Creating a fake socket is harmless: sock_init_data does not
    // allocate any resources outside the parameters we pass to it.

struct socket *junk_v4 = NULL, *junk_v6 = NULL;
    void *ptr_tcp_v6_connect=NULL;
    int result;

// IPv4 first.  If we can't get this, fail.
    info_msg("sock_create v4 socket");
    result = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &junk_v4);
    if (result != 0 || !junk_v4) {   // just being paranoid.  result==0 iff junk_v4!=NULL in socket.c
        err_msg("msda: unable to create probe ipv4 socket (result=%d)", result);
        return result;
    }
    if (!junk_v4->sk) {
        err_msg("msda: probe ipv4 socket has no sk");
        sock_release(junk_v4);
        return -EINVAL;
    }
    dbg_msg("msda: v4 sk_prot=%p sk_state_change=%p sk_error_report=%p",
        junk_v4->sk->sk_prot, junk_v4->sk->sk_state_change, junk_v4->sk->sk_error_report);

bs_sock_def_wakeup = orig_sock_def_wakeup = junk_v4->sk->sk_state_change;
    bs_sock_def_error_report = orig_sock_def_error_report = junk_v4->sk->sk_error_report;
    sock_release(junk_v4);

// IPv6 second, with allowable failures for not-present or present-but-disabled.
    // Only fail on internal inconsistencies.

if (ipv6_present) {
        result = sock_create(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &junk_v6);
        if (result != 0 || !junk_v6) {
            warn_msg("msda: could not create probe ipv6 stream socket (result=%d)", result);
            ipv6_present = false;
            return 0;
        }
        ptr_tcp_v6_connect = junk_v6->sk && junk_v6->sk->sk_prot ? junk_v6->sk->sk_prot->connect : 0;
        ptr_inet6_stream_ops = (struct proto_ops *)junk_v6->ops;
        sock_release(junk_v6);
        junk_v6 = NULL;

result = sock_create(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &junk_v6);
        if (result != 0 || !junk_v6) {
            warn_msg("msda: could not create probe ipv6 dgram socket (result=%d)", result);
            ptr_inet6_stream_ops = NULL;
            ipv6_present = false;
            return 0;
        }
        ptr_inet6_dgram_ops = (struct proto_ops *)junk_v6->ops;
        sock_release(junk_v6);

if (!ptr_tcp_v6_connect || !ptr_inet6_stream_ops || !ptr_inet6_dgram_ops) {
            err_msg("msda: probe ipv6 socket is missing sk, sk_prot, or connect pointer");
            return -EUNATCH;
        }
    }

return 0;
}

static struct trampoline_setupdata tsetup[NUM_TRAMPOLINES];
static struct proto_ops *ptr_inet6_stream_ops;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
extern struct mm_struct* bs_kernel_mm;
typedef void (*tlbflush_func_t)(void);
extern tlbflush_func_t bs_tlbflush;
#endif

static int __init init_driver(void) {
    int ret;

info_msg("msda: driver loading ver=" COLLECTOR_VERSION " rev=" COLLECTOR_REVISION);
    dbg_msg("msda: cpus: max=%u possible=%u present=%u online=%u active=%u",
            NR_CPUS,
            num_possible_cpus(),
            num_present_cpus(),
            num_online_cpus(),
            num_active_cpus()
    );
    if (unlikely(debug >= DBGLVL_EVENTS)) dbg_msg("msda: events debugging is on");
    
    if (! init_pid_map()) { 
        err_msg("msda: error in initialization (init_pid_map)");
        cleanup(); 
        return -ENOMEM; 
    }

if (-1 == SOCKET_CONTEXT_INIT()) {
        err_msg("msda: out of memory in initialization (sock context hash table)");
        cleanup();
        return -ENOMEM;
    }

if (symlookup != 0) {
        symlookup_func = (symlookup_func_t)symlookup;
        bs_symbol_get = (symbol_getter)symlookup_func("__symbol_get");
        bs_symbol_put = (symbol_putter)symlookup_func("__symbol_put");

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
        bs_lookup_address = (lookup_address_t)symlookup_func("lookup_address");
        bs_kernel_mm = (struct mm_struct*)symlookup_func("init_mm");
        bs_tlbflush = (tlbflush_func_t)symlookup_func("flush_tlb_all");
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
        bs_vmalloc_node_range = (vmalloc_node_range_t)symlookup_func("__vmalloc_node_range");
#endif

if (bs_symbol_get && bs_symbol_put) {
            bs_register_inet6addr_notifier = (notifier_net_regfunc_t)bs_symbol_get("register_inet6addr_notifier");
            bs_unregister_inet6addr_notifier = (notifier_net_regfunc_t)bs_symbol_get("unregister_inet6addr_notifier");
            if (bs_register_inet6addr_notifier && bs_unregister_inet6addr_notifier) {
                info_msg("msda: ipv6 support is active");
                ipv6_present = true;
            }
            else {
                info_msg("msda: no ipv6 support in this kernel");
            }

bluechannel_link_fptr = (bluechannel_link_func_t)bs_symbol_get("bluechannel_link");
            info_msg("msda: bluechannel_link @%p", bluechannel_link_fptr);
            if (bluechannel_link_fptr) {
                bc_hbt_fptr = bs_symbol_get("bluechannel_broadcast_heartbeat");
                info_msg("msda: bluechannel_broadcast_heartbeat @%p", bc_hbt_fptr);
            }
        }
        else {
            info_msg("msda: could not get ipv6 symbols");
        }
    }
    else {
        err_msg("msda: symlookup not specified");
        cleanup();
        return -EFAULT;
    }

// find some tricky probe locations 
    if ((ret = determine_sock_addrs()) != 0) {
        err_msg("msda: unable to determine probe targets");
        cleanup();
        return ret;
    }

// initialize supertramp and register hooks
    st = init_supertramp(LINUX_SUPERTRAMP_VER, supertramp_addr);
    if ((st == NULL) && (supertramp_addr != 0)) {
        st = init_supertramp(LINUX_SUPERTRAMP_VER, 0);
    }

if (st == NULL) {
        err_msg("msda: failed to initialize supertramp");
        cleanup();
        return -EIO;
    }
    supertramp_addr = (long)st;

// Install our supertramp hooks
    FPTR_TRAMPOLINE_BOILERPLATE(INET_POLL_FUNC_ID, inet_poll_trampoline, inet_poll_trampoline_size, &inet_stream_ops.poll);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_RECVMSG_FUNC_ID, inet_recvmsg_trampoline, inet_recvmsg_trampoline_size, &inet_stream_ops.recvmsg);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_SENDMSG_FUNC_ID, inet_sendmsg_trampoline, inet_sendmsg_trampoline_size, &inet_stream_ops.sendmsg);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_UDP_RECVMSG_FUNC_ID, inet_udp_recvmsg_trampoline, inet_udp_recvmsg_trampoline_size, &inet_dgram_ops.recvmsg);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_UDP_SENDMSG_FUNC_ID, inet_udp_sendmsg_trampoline, inet_udp_sendmsg_trampoline_size, &inet_dgram_ops.sendmsg);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_ACCEPT_FUNC_ID, inet_accept_trampoline, inet_accept_trampoline_size, &inet_stream_ops.accept);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_LISTEN_FUNC_ID, inet_listen_trampoline, inet_listen_trampoline_size, &inet_stream_ops.listen);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_CONNECT_FUNC_ID, inet_connect_trampoline, inet_connect_trampoline_size, &inet_stream_ops.connect);
    FPTR_TRAMPOLINE_BOILERPLATE(SOCK_DEF_WAKEUP_FUNC_ID, sock_def_wakeup_trampoline, sock_def_wakeup_trampoline_size, &bs_sock_def_wakeup);
    FPTR_TRAMPOLINE_BOILERPLATE(INET_RELEASE_FUNC_ID, inet_release_trampoline, inet_release_trampoline_size, &inet_stream_ops.release);
    FPTR_TRAMPOLINE_BOILERPLATE(SOCK_DEF_ERROR_REPORT_FUNC_ID, sock_def_error_report_trampoline, sock_def_error_report_trampoline_size, &bs_sock_def_error_report);
    if (ipv6_present) {
        BUG_ON(!ptr_inet6_stream_ops);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_POLL_FUNC_ID, inet6_poll_trampoline, inet6_poll_trampoline_size, &ptr_inet6_stream_ops->poll);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_RECVMSG_FUNC_ID, inet6_recvmsg_trampoline, inet6_recvmsg_trampoline_size, &ptr_inet6_stream_ops->recvmsg);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_SENDMSG_FUNC_ID, inet6_sendmsg_trampoline, inet6_sendmsg_trampoline_size, &ptr_inet6_stream_ops->sendmsg);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_UDP_RECVMSG_FUNC_ID, inet6_udp_recvmsg_trampoline, inet6_udp_recvmsg_trampoline_size, &ptr_inet6_dgram_ops->recvmsg);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_UDP_SENDMSG_FUNC_ID, inet6_udp_sendmsg_trampoline, inet6_udp_sendmsg_trampoline_size, &ptr_inet6_dgram_ops->sendmsg);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_ACCEPT_FUNC_ID, inet6_accept_trampoline, inet6_accept_trampoline_size, &ptr_inet6_stream_ops->accept);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_LISTEN_FUNC_ID, inet6_listen_trampoline, inet6_listen_trampoline_size, &ptr_inet6_stream_ops->listen);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_CONNECT_FUNC_ID, inet6_connect_trampoline, inet6_connect_trampoline_size, &ptr_inet6_stream_ops->connect);
        FPTR_TRAMPOLINE_BOILERPLATE(INET6_RELEASE_FUNC_ID, inet6_release_trampoline, inet6_release_trampoline_size, &ptr_inet6_stream_ops->release);
        ret = install_trampolines(tsetup, NUM_TRAMPOLINES);
    }
    else {
        ret = install_trampolines(tsetup, NUM_V4_TRAMPOLINES);
    }

if (ret != 0) {
        err_msg("msda: failed to install hooks");
        cleanup();
        return -EIO;
    }

// allocate the /dev/msda device
    if ((ret = misc_register(&bs_dev)) != 0) {
        err_msg("msda: unable to register Dependency Agent misc device");
        cleanup();
        return ret;
    }
    info_msg("msda: device registered at %d.%d", MISC_MAJOR, bs_dev.minor);

return 0;
}

static int register_hooks() {
    // make sure we have supertramp
    if (st == NULL) {
        err_msg("msda: failed to initialize supertramp");
        return -EINVAL;
    }

// initialize the protocol recognizer
    bs_proto_recognizer_init(shared_area, shm_area_size);

// Activate our supertramp entry/return callbacks
    set_tramp_callbacks(INET_POLL_FUNC_ID,     NULL,                            (void*)&inet_poll_rethook);
    set_tramp_callbacks(INET_RECVMSG_FUNC_ID,  (void*)&inet_recvmsg_entryhook,  (void*)&inet_recvmsg_rethook);
    set_tramp_callbacks(INET_SENDMSG_FUNC_ID,  (void*)&inet_sendmsg_entryhook,  (void*)&inet_sendmsg_rethook);
    set_tramp_callbacks(INET_UDP_RECVMSG_FUNC_ID,  (void*)&inet_udp_recvmsg_entryhook,  (void*)&inet_udp_recvmsg_rethook);
    set_tramp_callbacks(INET_UDP_SENDMSG_FUNC_ID,  (void*)&inet_udp_sendmsg_entryhook,  (void*)&inet_udp_sendmsg_rethook);
    set_tramp_callbacks(INET_ACCEPT_FUNC_ID,   (void*)&inet_accept_entryhook,   (void*)&inet_accept_rethook);
    set_tramp_callbacks(INET_LISTEN_FUNC_ID,   NULL,                            (void*)&inet_listen_rethook);
    set_tramp_callbacks(INET_CONNECT_FUNC_ID,  (void*)&inet_connect_entryhook,  (void*)&inet_connect_rethook);
    set_tramp_callbacks(SOCK_DEF_WAKEUP_FUNC_ID, (void*)&sock_def_wakeup_entryhook, NULL);
    set_tramp_callbacks(INET_RELEASE_FUNC_ID,  (void*)&inet_release_entryhook,  NULL);
    set_tramp_callbacks(SOCK_DEF_ERROR_REPORT_FUNC_ID, (void*)&sock_def_error_report_entryhook, NULL);
    if (ipv6_present) {
        set_tramp_callbacks(INET6_POLL_FUNC_ID,    NULL,                            (void*)&inet_poll_rethook);
        set_tramp_callbacks(INET6_RECVMSG_FUNC_ID, (void*)&inet_recvmsg_entryhook,  (void*)&inet_recvmsg_rethook);
        set_tramp_callbacks(INET6_SENDMSG_FUNC_ID, (void*)&inet_sendmsg_entryhook,  (void*)&inet_sendmsg_rethook);
        set_tramp_callbacks(INET6_UDP_RECVMSG_FUNC_ID, (void*)&inet_udp_recvmsg_entryhook,  (void*)&inet_udp_recvmsg_rethook);
        set_tramp_callbacks(INET6_UDP_SENDMSG_FUNC_ID, (void*)&inet_udp_sendmsg_entryhook,  (void*)&inet_udp_sendmsg_rethook);
        set_tramp_callbacks(INET6_ACCEPT_FUNC_ID,  (void*)&inet_accept_entryhook,   (void*)&inet_accept_rethook);
        set_tramp_callbacks(INET6_LISTEN_FUNC_ID,  NULL,                            (void*)&inet_listen_rethook);
        set_tramp_callbacks(INET6_CONNECT_FUNC_ID, (void*)&inet_connect_entryhook,  (void*)&inet_connect_rethook);
        set_tramp_callbacks(INET6_RELEASE_FUNC_ID,  (void*)&inet_release_entryhook, NULL);
    }

shutting_down = false;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 15, 0)
    mod_timer(&pd_timer, jiffies + PD_INTERVAL);
    mod_timer(&cb_flush_timer, jiffies + CHUNK_BUFFER_FLUSH_INTERVAL);
    mod_timer(&heartbeat_timer, jiffies + (15*HZ));
#else
    init_timer(&pd_timer);
    pd_timer.expires = jiffies + PD_INTERVAL;
    add_timer(&pd_timer);

init_timer(&cb_flush_timer);
    cb_flush_timer.expires = jiffies + CHUNK_BUFFER_FLUSH_INTERVAL;
    add_timer(&cb_flush_timer);

init_timer(&heartbeat_timer);
    heartbeat_timer.expires = jiffies + (15*HZ);
    add_timer(&heartbeat_timer);
#endif

return 0;
}

static void unregister_hooks() {
    shutting_down = true;
    del_timer_sync(&pd_timer);
    del_timer_sync(&cb_flush_timer);
    del_timer_sync(&heartbeat_timer);

// Clear all the callbacks
    if (st) release_supertramp(SUPERTRAMP_CLEAR_CALLBACKS);

bs_proto_recognizer_fini();
}

static void __exit exit_driver(void) {
    if (st) release_supertramp(SUPERTRAMP_UNINSTALL_HOOKS);
    cleanup();
    info_msg("msda: driver unloaded ver=" COLLECTOR_VERSION " rev=" COLLECTOR_REVISION);
}

module_init(init_driver);
module_exit(exit_driver);

MODULE_AUTHOR("Microsoft Corporation http://www.microsoft.com/oms");
MODULE_DESCRIPTION("Microsoft Dependency Agent Module");
#ifdef PROPRIETARY_DRIVER
MODULE_LICENSE("Proprietary");
#endif

/*************************************************************************/
/* extant emit code                                                      */
/*************************************************************************/

struct extant_bound_t {
    char opCode;
    u64 skptr;
    unsigned int pid;
    int s_ip;
    unsigned short s_port;
}__attribute__((aligned(1), packed));

struct extant_link_t {
    char opCode;
    u64 skptr;
    unsigned int pid;
    int s_ip;
    int d_ip;
    unsigned short s_port;
    unsigned short d_port;
    char dir;
}__attribute__((aligned(1), packed));

void extant_emitter(struct sock *sk, struct task_struct *task) {
    int pid = (task != 0) ? task->tgid : 1;
    rewrite_sk_callbacks(sk);
    if (sk->sk_state == TCP_ESTABLISHED || sk->sk_state == TCP_CLOSE_WAIT) {
        bs_handle_extant_conn(SOCKET_CONNID(sk), pid, 
            get_v4_saddr(INET_SK(sk)), ntohs(TCP_FIELD(INET_SK(sk), sport)),
            get_v4_daddr(INET_SK(sk)), ntohs(TCP_FIELD(INET_SK(sk), dport)),
            (sk->sk_max_ack_backlog == 0) ? 1 : 2);
        if (unlikely(debug >= DBGLVL_EVENTS)) {     
            info_msg("msda: extant link connid=0x%llx pid=%d owner=%d sport=0x%x", SOCKET_CONNID(sk), pid, pid_from_sock(sk), ntohs(TCP_FIELD(INET_SK(sk), sport)));
        }               
    } else if (sk->sk_state == TCP_LISTEN) {
        bs_handle_extant_boundport(SOCKET_CONNID(sk), pid, get_v4_saddr(INET_SK(sk)), ntohs(TCP_FIELD(INET_SK(sk), sport)));
        if (unlikely(debug >= DBGLVL_EVENTS)) {
            info_msg("msda: extant bound connid=0x%llx pid=%d owner=%d sport=0x%x", SOCKET_CONNID(sk), pid, pid_from_sock(sk), ntohs(TCP_FIELD(INET_SK(sk), sport)));
        }       
    }
}

/*************************************************************************/
/* pd timer callback function                                            */
/*************************************************************************/

static char pd_buf[512];  // make sure this is greater than 124 = 8 (sizeof(event_common_hdr_t)) + 32 + 37 + 39 + 8(padding)
/* Called from atomic context.  Do not create GFP_KERNEL memory, and do not call hash_table_insert. */
static void pd_callback(timer_param_t unused) {
    unsigned int buffers, allocs, frees;
    event_common_hdr_t *hdr = (event_common_hdr_t*)pd_buf;
    uint32_t *data_buf = (uint32_t*)(pd_buf + sizeof(event_common_hdr_t));
 
    hdr->op = OP_STATS;
    cb_get_stats(data_buf + 0, data_buf + 1, data_buf + 2, data_buf + 3, &buffers, &allocs, &frees);
    shm_area_get_stats(&shm_area, data_buf+4, data_buf+5, data_buf+6, data_buf+7);

if (shutting_down) return;

{
        char *bufp = (char *) (data_buf + 8);
        char *endp = &pd_buf[sizeof(pd_buf) - 1]; /* always leave room for the terminating null */

{
            int chars = snprintf(bufp, (endp - bufp), " cba:%u:%u:%u", buffers, allocs, frees);
            if (0 < chars && (unsigned int) chars < (endp - bufp)) {
                bufp += (unsigned int) chars;
            }
        }

bufp += sock_context_stats(bufp, (endp - bufp));
        *(bufp++) = '\0';
    
        // Pad the event size to a multiple of 8
        hdr->eventsz = roundup(bufp - &pd_buf[0], 8);

}

if (device_reader_attached) cb_write_microevent(hdr, 0);

pd_timer.expires += PD_INTERVAL;
    add_timer(&pd_timer);
}

static void bs_maybe_wakeup_reader(void) {
#ifdef WAKEUP_METRICS
    bs_jiffies_t time = get_jiffies_64();
#endif
    /*
     * Scenario
     * 1 - The reader is not waiting, need_wakeup will be <= 0, ..._test returns false
     * 2 - The reader is waiting, need_wakeup is 1, first writer will decrement to 0 and get true
     * 3 - The reader is waiting, need_wakeup is now <= 0 because another writer got here first.
     */
    // check without bus lock first and only do the more expensive check if it may succeed.
    if ((atomic_read(&need_wakeup) > 0) && atomic_dec_and_test(&need_wakeup)) {
        bs_wakeup_waitq(&wait_queue);
#ifdef WAKEUP_METRICS
        time = get_jiffies_64() - time;
        atomic_add(time, &wakeup_stats.slow_time);
        atomic_inc(&wakeup_stats.slow_wakeups);
#endif
    }
#ifdef WAKEUP_METRICS
    else {
        time = get_jiffies_64() - time;
        atomic_add(time, &wakeup_stats.fast_time);
        atomic_inc(&wakeup_stats.fast_wakeups);
    }
#endif
}

/* Called from atomic context.  Do not create GFP_KERNEL memory, and do not call hash_table_insert. */
static void cb_flush_callback(timer_param_t unused) {
    if (shutting_down) return;

if (cb_is_readable()) {
        threshold_to_be_ready_to_read=1;
        bs_maybe_wakeup_reader();
    }

cb_flush_timer.expires += CHUNK_BUFFER_FLUSH_INTERVAL;
    add_timer(&cb_flush_timer);
}

static void heartbeat_callback(timer_param_t unused) {
    if (shutting_down) return;

bs_handle_heartbeat(bs_get_timestamp());

heartbeat_timer.expires += (15*HZ);
    add_timer(&heartbeat_timer);
    if (bc_hbt_fptr && (bluechannel_link_result == BC_LINK_SUCCESSFUL)) bc_hbt_fptr();
}

void force_miss(void) {
    cb_force_miss();
}

/*************************************************************************/
/* bluechannel                                                           */
/*************************************************************************/
int handle_bluechannel_event(bluechannel_context_t *chan, void* data, size_t sz) {
    int err=0;
    
    if (device_reader_attached) {
        event_common_hdr_t *hdr = (event_common_hdr_t*)data;
        switch (hdr->op) {
            case OP_PIO_OPEN: {
                pio_open_t *open_ev = (pio_open_t*)hdr;
                send_pid_if_necessary();
                if (bs_handle_pio_open(open_ev->hdr.pid, open_ev->thread_id, open_ev->channel_id) == -1) {
                    err = -ENOSPC;
                }
                break;
            }
            case OP_PIO_CLOSE: {
                pio_close_t *close_ev = (pio_close_t *)hdr;
                if (bs_handle_pio_close(close_ev->hdr.pid, close_ev->thread_id, close_ev->channel_id) == -1) {
                    err = -ENOSPC;
                }
                break;
            }
            case OP_PIO_MSG:
            default:
                // TODO can this check be pushed up higher? is it valid/needed?
                if (hdr->eventsz != sz) {
                    err_msg("handle_bluechannel_event: hdr->eventsz(%u) does not match sz(%llu)", hdr->eventsz, (long long unsigned) sz);
                }
                send_pid_if_necessary();
                if (cb_write_microevent(hdr, BS_WAKE_READER) == -1) {
                    err = -ENOSPC;
                }
                break;
        }
    } else {
        err = -EPIPE;
    }

return err;
}

/*************************************************************************/
/* character device handlers                                             */
/*************************************************************************/

static int bs_open(struct inode *inode, struct file *file) {
    unsigned long flags;

dbg_msg("bs_open tgid=%d mode=0x%08x", current->tgid, (file->f_flags & O_ACCMODE));

// allow multiple writers (needed to support ioctl requests)
    if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
        return 0;
    }

spin_lock_irqsave(&bs_lock, flags);
    {
        if (device_reader_attaching || device_reader_attached) {
            dbg_msg("bs_open EBUSY: device_reader_attaching = %d, device_reader_attached = %d, reader_pid=%d",
                    device_reader_attaching, device_reader_attached, reader_pid);
            spin_unlock_irqrestore(&bs_lock, flags);
            return -EBUSY;
        }
        
        device_reader_attaching = true;
        reader_pid = current->tgid;
    }   
    spin_unlock_irqrestore(&bs_lock, flags);

#ifdef WAKEUP_METRICS
    atomic_set(&wakeup_stats.slow_time, 0);
    atomic_set(&wakeup_stats.slow_wakeups, 0);
    atomic_set(&wakeup_stats.fast_time, 0);
    atomic_set(&wakeup_stats.fast_wakeups, 0);
    wakeup_stats.reads = 0;
    wakeup_stats.ready_selects = 0;
    wakeup_stats.blocking_selects = 0;
#endif

atomic_set(&need_wakeup, 0);
    bs_init_waitq(&wait_queue);

if (! cb_init(bs_notify_readable)) {
        err_msg("msda: could not allocate chunkbuffer");
        reader_pid = 0;
        device_reader_attaching = false;
        bs_destroy_waitq(&wait_queue);
        return -ENOMEM;
    }

// Assumption: The validity of shm_area_size is enforced elsewhere
    shared_area = (char*)vmalloc_reserved(shm_area_size);
    if (!shared_area) {
        err_msg("msda: failed to allocate shm_area");
        cb_destroy();
        bs_destroy_waitq(&wait_queue);
        reader_pid=0;
        device_reader_attaching = false;
        return -ENOMEM;
    } else {
        dbg_msg("msda: allocated shm at %p", shared_area);
    }

info_msg("msda: attaching hooks");
    if (register_hooks() != 0) {
        err_msg("msda: failed to register hooks");
        vfree_reserved(shared_area, shm_area_size);
        cb_destroy();
        bs_destroy_waitq(&wait_queue);
        reader_pid=0;
        return -ENOMEM;
    }

register_net_notifiers();
        
    // Set up the device buffer and let the data start flowin'
    spin_lock_irqsave(&bs_lock, flags);
    {
        device_reader_attached = true;
        device_reader_attaching = false;
    }   
    spin_unlock_irqrestore(&bs_lock, flags);

if (bluechannel_link_fptr) {
        bluechannel_func_table_t functable = { 
            .api_version = 2,
                .writefunc = handle_bluechannel_event,
                .openfunc  = handle_bluechannel_event,
                .closefunc = handle_bluechannel_event,
        };
        info_msg("msda: invoking bluechannel_link: LINK {handle_bluechannel_event=%p}", handle_bluechannel_event);
        if ((bluechannel_link_result=bluechannel_link_fptr(&functable)) != BC_LINK_SUCCESSFUL) {
                warn_msg("unable to link with bluechannel: err=%d", bluechannel_link_result);
        }
    }

info_msg("msda: starting extants");
    bs_handle_extant_start();
    iterate_extants(extant_emitter);
    bs_handle_extant_end();
    info_msg("msda: extants complete");

return 0;
}

#ifdef s390x
#define PAGE_READONLY PAGE_RO
#endif
static int bs_mmap(struct file * filp, struct vm_area_struct * vma) {
    int ret=-1;
    long requested_size = vma->vm_end-vma->vm_start;
    unsigned long start = vma->vm_start;
    char *vmalloc_area_ptr = shared_area;

info_msg("msda: mmap requested size=%ld area_size=%d", requested_size, shm_area_size);
    if (requested_size != shm_area_size) return -EIO;

if (device_reader_attached && shared_area) {
        ret=0;
        while (requested_size && ret==0) {
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,9)
//          dbg_msg("remap_page_range start=%lx vmarea=%p (%lx) left=%ld",
//                  start, vmalloc_area_ptr, VMALLOC_PTR_TO_PHYS(vmalloc_area_ptr), requested_size);
            ret = remap_page_range(vma,
                    start,
                    VMALLOC_PTR_TO_PHYS(vmalloc_area_ptr),
                    PAGE_SIZE,
                    PAGE_READONLY);
#else
//          dbg_msg("remap_pfn_range start=%lx vmarea=%p (%lx) left=%ld",
//                  start, vmalloc_area_ptr, VMALLOC_PTR_TO_PHYS(vmalloc_area_ptr), requested_size);
            ret = remap_pfn_range(vma,
                    start,
                    VMALLOC_PTR_TO_PHYS(vmalloc_area_ptr) >> PAGE_SHIFT,
                    PAGE_SIZE,
                    PAGE_READONLY);
#endif
            start += PAGE_SIZE;
            vmalloc_area_ptr += PAGE_SIZE;
            requested_size -= PAGE_SIZE;
        }
    }
    if (ret != 0) {
        err_msg("msda: mmap shared mapping failed ret=%d", ret);
        return -EAGAIN;
    }
    return 0;
}

static unsigned long userspace_copy(void __user *to, void *from, unsigned int n, unsigned int offset) {
    char *user_addr = (char*)to + offset;
    return copy_to_user(user_addr, from, n);
}

/* bs_read: called whenever a user process tries to read from /dev/msda
 */
static ssize_t bs_read(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos) {
    threshold_to_be_ready_to_read = min_readable_bytes;
#ifdef WAKEUP_METRICS
    wakeup_stats.reads++;
#endif
    // cb_read_data will return -EAGAIN if there is no data available.
    // FUTURE: To support opening the device in blocking mode:
    // for a blocking read, block waiting for data, then call cb_read_data again.
    return cb_read_data(buffer, buflen, userspace_copy);
}

static void bs_notify_readable(int flags, int bytes_ready) {
    // Avoid nested wakeup for polling by the collector or kernel threads
    if (unlikely(current && current->tgid == reader_pid)) return;

/*
     * CAVEAT: Possible race condition, but isn't
     * 1. Writing thread has added to the buffer and passes bytes_ready > min_readable_bytes.
     * 2. Writing thread stalls.
     * 3. Reading thread runs read, empties the buffer, then does a select and blocks.
     * 4. Writing thread resumes, sees all conditions are met, and does a wake up.
     * 5. Reading thread wakes up from select, does a read, and finds no data.
     * But, the way Linux implements the select, after the thread wakes up
     * each file descriptor is checked again to see if it is read. In this scenario,
     * it wouldn't see the buffer is ready in step 5 and it would go back to sleep in the
     * select.
     */
    // If the flags include BS_WAKE_ERROR, bytes_read should be INT_MAX.
    // If the flags include BS_WAKE_FLUSH, bytes_read > 0.
    if (unlikely(flags & BS_WAKE_FLUSH)) { threshold_to_be_ready_to_read = 1; }
    if (bytes_ready >= threshold_to_be_ready_to_read || (flags & BS_WAKE_ERROR)) {
        bs_maybe_wakeup_reader();
    }
    else {
        int32_t shm_usage = 0;
        shm_area_get_usage(&shm_area, NULL, &shm_usage);
        if (shm_usage >= shm_wakeup_threshold_bytes) {
            threshold_to_be_ready_to_read = 1;
            bs_maybe_wakeup_reader();
        }
    }
}

static unsigned int bs_poll(struct file *file, poll_table *wait) {
    unsigned int mask = (POLLOUT|POLLWRNORM);  // always writable

if (unlikely((file->f_flags & O_ACCMODE) == O_WRONLY)) return mask;

if (likely(device_reader_attached)) {  // don't touch the wait_queue or the cb in WRONLY mode
        int bytes_ready = cb_is_readable();

poll_wait(file, &wait_queue, wait);
        atomic_set(&need_wakeup, 1);
        smp_mb();
        if (bytes_ready >= threshold_to_be_ready_to_read) {
            mask |= (POLLIN|POLLRDNORM);
#ifdef WAKEUP_METRICS
            wakeup_stats.ready_selects++;
#endif
        }
#ifdef WAKEUP_METRICS
        else {
            wakeup_stats.blocking_selects++;
        }
#endif
    }

return mask;
}

static void dump_wakeup_stats(void) {
#ifdef WAKEUP_METRICS
    info_msg("msda: wakeups: st=%d sw=%d ft=%d fw=%d r=%d rs=%d bs=%d",
                atomic_read(&wakeup_stats.slow_time), atomic_read(&wakeup_stats.slow_wakeups),
                atomic_read(&wakeup_stats.fast_time), atomic_read(&wakeup_stats.fast_wakeups),
                wakeup_stats.reads, wakeup_stats.ready_selects, wakeup_stats.blocking_selects);
#endif
}

/* bs_write: called whenever a user process tries to write to /dev/msda
 */
static ssize_t bs_write(struct file *file, const char __user *buffer, size_t buflen, loff_t *fpos) {
    char cmd;

if (buflen <= 0) return 0;
    if (buflen > 1) buflen = 1;

if (copy_from_user(&cmd, buffer, 1))
        return -EFAULT;
    switch (cmd) {
        case 1:
            break;
        case 2:  // dump hash profile information to the log
            dump_wakeup_stats();
            cb_dump_stats();
            sock_context_profile();
            bs_dump_spinlock_stats();
            break;
        default:
            return -ENOSYS;
    }
    return buflen;
}

static int bs_release(struct inode *inode, struct file *file) {
    unsigned long flags;

dbg_msg("bs_release tgid=%d mode=0x%08x", current->tgid, (file->f_flags & O_ACCMODE));

// if the device was open if O_WRONLY,
    // there is nothing to do
    if ((file->f_flags & O_ACCMODE) == O_WRONLY){
        return 0;
    }

spin_lock_irqsave(&bs_lock, flags);
    {
        // This will stop any hooks from emitting events
        // and keep any new readers from attaching until we finish the release
        device_reader_attaching = true;
        device_reader_attached = false;
    }   
    spin_unlock_irqrestore(&bs_lock, flags);

if (bluechannel_link_fptr && bluechannel_link_result == BC_LINK_SUCCESSFUL) {
        info_msg("msda: unlinking from bluechannel");
        bluechannel_link_result = bluechannel_link_fptr(NULL);
    }
    
    info_msg("msda: detaching hooks");
    unregister_net_notifiers();
    unregister_hooks();
    clear_pid_map();
    sock_context_clear();
    cb_destroy();
    bs_destroy_waitq(&wait_queue);
    reader_pid=0;

if (shared_area) {
        vfree_reserved(shared_area, shm_area_size);
    }
    shared_area = NULL;
    device_reader_attaching = false;

return 0;
}

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📁 bluechannel/	DIR	—	2023-11-30 04:08
📄 bs_driver.c	C	40.4 KB	2023-11-01 09:12	EDIT
📄 bs_driver.h	H	4.6 KB	2023-11-01 09:12	EDIT
📄 bs_gpl_fixes.h	H	467 B	2023-11-01 09:12	EDIT
📄 bs_hooks.c	C	33.8 KB	2023-11-01 09:12	EDIT
📄 bs_trampolines.c	C	6.4 KB	2023-11-01 09:12	EDIT
📄 bs_trampolines.h	H	8.4 KB	2023-11-01 09:12	EDIT
📄 bsioctl.c	C	6.8 KB	2023-11-01 09:12	EDIT
📄 bsioctl.h	H	1.9 KB	2023-11-01 09:12	EDIT
📄 collectorcmd.c	C	4.4 KB	2023-11-01 09:12	EDIT
📄 ehook.c	C	3 KB	2023-11-01 09:12	EDIT
📄 extants.c	C	12.4 KB	2023-11-01 09:12	EDIT
📄 iov_compress.c	C	5.7 KB	2023-11-01 09:12	EDIT
📄 iov_compress.h	H	242 B	2023-11-01 09:12	EDIT
📄 linux_oscompat.c	C	15.8 KB	2023-11-01 09:12	EDIT
📄 linux_oscompat.h	H	3.7 KB	2023-11-01 09:12	EDIT
📄 Makefile	?	4.1 KB	2023-11-01 09:12	EDIT
📄 memcpy.c	C	201 B	2023-11-01 09:12	EDIT
📄 netnotifiers.c	C	3.7 KB	2023-11-01 09:12	EDIT
📄 netnotifiers.h	H	330 B	2023-11-01 09:12	EDIT
📄 proto.c	C	368 B	2023-11-01 09:12	EDIT
📄 sock_context.c	C	7.9 KB	2023-11-01 09:12	EDIT
📄 sock_context.h	H	3.6 KB	2023-11-01 09:12	EDIT
📄 tcphelpers.c	C	2.8 KB	2023-11-01 09:12	EDIT
📄 tcphelpers.h	H	1.4 KB	2023-11-01 09:12	EDIT
📄 verifier.c	C	2 KB	2023-11-01 09:12	EDIT
📄 verifier.h	H	918 B	2023-11-01 09:12	EDIT
📄 version.h	H	268 B	2023-11-01 09:12	EDIT