#include "peer_queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "utils.h"

Functions
void	add_peer_to_queue (const char *ip, int port)
	Add a peer to the queue.

bool	is_peer_queue_empty ()
	Check if the peer queue is empty.

bool	get_peer_from_queue (char *buffer, size_t buffer_size)
	Get a peer from the queue.

void	clear_peer_queue ()
	Clear the peer queue.

void	print_peer_queue ()
	Print the peer queue.

Peer *	get_peer_queue (int *count)
	Get the peer queue.

Variables
static Peer	peer_queue [MAX_PEERS]

static int	peer_queue_start = 0

static int	peer_queue_end = 0

static pthread_mutex_t	peer_queue_mutex = PTHREAD_MUTEX_INITIALIZER

Function Documentation

◆ add_peer_to_queue()

void add_peer_to_queue	(	const char *	ip,
		int	port
	)

Add a peer to the queue.

Parameters

ip	The IP address of the peer.
port	The port of the peer.

Definition at line 15 of file peer_queue.c.

{
    pthread_mutex_lock(&peer_queue_mutex);
 
    // Check if the IP-port pair already exists in the queue
    for (int i = peer_queue_start; i != peer_queue_end; i = (i + 1) % MAX_PEERS)
    {
        if (strcmp(peer_queue[i].ip, ip) == 0 && peer_queue[i].port == port)
        {
            // IP-port pair already exists, don't add it again
            log_message(LOG_INFO, BITLAB_LOG, __FILE__,
                "Duplicate peer: %s:%d, not added", ip, port);
            pthread_mutex_unlock(&peer_queue_mutex);
            return;
        }
    }
 
    // Check if the queue is full
    if ((peer_queue_end + 1) % MAX_PEERS == peer_queue_start)
    {
        log_message(LOG_WARN, BITLAB_LOG, __FILE__,
            "Peer queue is full, cannot add peer: %s:%d", ip, port);
        pthread_mutex_unlock(&peer_queue_mutex);
        return;
    }
 
    // Extract the port if not provided
    if (port == 0)
    {
        char* colon_pos = strrchr(ip, ':');
        if (colon_pos != NULL)
        {
            port = atoi(colon_pos + 1);
            strncpy(peer_queue[peer_queue_end].ip, ip, colon_pos - ip);
            peer_queue[peer_queue_end].ip[colon_pos - ip] = '\0';
        }
        else
        {
            log_message(LOG_WARN, BITLAB_LOG, __FILE__,
                "Invalid IP format, cannot extract port: %s", ip);
            pthread_mutex_unlock(&peer_queue_mutex);
            return;
        }
    }
    else
    {
        strncpy(peer_queue[peer_queue_end].ip, ip,
            sizeof(peer_queue[peer_queue_end].ip));
    }
 
    // Add the IP-port pair to the queue
    peer_queue[peer_queue_end].port = port;
    peer_queue_end = (peer_queue_end + 1) % MAX_PEERS;
 
    pthread_mutex_unlock(&peer_queue_mutex);
}

References BITLAB_LOG, Peer::ip, LOG_INFO, log_message(), LOG_WARN, MAX_PEERS, peer_queue, peer_queue_end, peer_queue_mutex, peer_queue_start, and Peer::port.

Referenced by handle_peer_discovery(), and send_getaddr_and_wait().

◆ clear_peer_queue()

void clear_peer_queue ( )

Clear the peer queue.

Definition at line 95 of file peer_queue.c.

{
    pthread_mutex_lock(&peer_queue_mutex);
    peer_queue_start = 0;
    peer_queue_end = 0;
    pthread_mutex_unlock(&peer_queue_mutex);
}

References peer_queue_end, peer_queue_mutex, and peer_queue_start.

◆ get_peer_from_queue()

bool get_peer_from_queue	(	char *	buffer,
		size_t	buffer_size
	)

Get a peer from the queue.

Parameters

buffer	The buffer to store the peer.
buffer_size	The size of the buffer.

Returns: True if the peer was successfully retrieved, false otherwise.

Definition at line 80 of file peer_queue.c.

{
    pthread_mutex_lock(&peer_queue_mutex);
    if (peer_queue_start == peer_queue_end)
    {
        pthread_mutex_unlock(&peer_queue_mutex);
        return false;
    }
    snprintf(buffer, buffer_size, "%s:%d", peer_queue[peer_queue_start].ip,
        peer_queue[peer_queue_start].port);
    peer_queue_start = (peer_queue_start + 1) % MAX_PEERS;
    pthread_mutex_unlock(&peer_queue_mutex);
    return true;
}

References MAX_PEERS, peer_queue, peer_queue_end, peer_queue_mutex, and peer_queue_start.

◆ get_peer_queue()

Peer * get_peer_queue ( int * count )

Get the peer queue.

Definition at line 118 of file peer_queue.c.

{
    pthread_mutex_lock(&peer_queue_mutex);
 
    if (peer_queue_start == peer_queue_end)
    {
        *count = 0;
        pthread_mutex_unlock(&peer_queue_mutex);
        return NULL;
    }
 
    int size = (peer_queue_end >= peer_queue_start)
        ? (peer_queue_end - peer_queue_start)
        : (MAX_PEERS - peer_queue_start + peer_queue_end);
 
    Peer* peers = malloc(size * sizeof(Peer));
    if (peers == NULL)
    {
        *count = 0;
        pthread_mutex_unlock(&peer_queue_mutex);
        return NULL;
    }
 
    for (int i = 0, j = peer_queue_start; j != peer_queue_end; j = (j + 1) % MAX_PEERS,
        i++)
    {
        peers[i] = peer_queue[j];
    }
 
    *count = size;
    pthread_mutex_unlock(&peer_queue_mutex);
    return peers;
}

References MAX_PEERS, peer_queue, peer_queue_end, peer_queue_mutex, and peer_queue_start.

Referenced by send_addr().

◆ is_peer_queue_empty()

bool is_peer_queue_empty ( )

Check if the peer queue is empty.

Returns: True if the peer queue is empty, false otherwise.

Definition at line 72 of file peer_queue.c.

{
    pthread_mutex_lock(&peer_queue_mutex);
    bool empty = (peer_queue_start == peer_queue_end);
    pthread_mutex_unlock(&peer_queue_mutex);
    return empty;
}

References peer_queue_end, peer_queue_mutex, and peer_queue_start.

◆ print_peer_queue()

void print_peer_queue ( )

Print the peer queue.

Definition at line 103 of file peer_queue.c.

{
    pthread_mutex_lock(&peer_queue_mutex);
    if (peer_queue_start == peer_queue_end)
    {
        guarded_print_line("Peer queue is empty");
        pthread_mutex_unlock(&peer_queue_mutex);
        return;
    }
    int k = 1;
    for (int i = peer_queue_start; i != peer_queue_end; i = (i + 1) % MAX_PEERS)
        guarded_print_line("%d | %s:%d", k++, peer_queue[i].ip, peer_queue[i].port);
    pthread_mutex_unlock(&peer_queue_mutex);
}