peer_connection.h File Reference

#include <stdint.h>
#include <pthread.h>

Go to the source code of this file.

Data Structures
struct	bitcoin_msg_header
struct	Node
	The structure to store information about a connected peer. More...

Macros
#define	MAX_NODES   100
#define	BITCOIN_MAINNET_MAGIC   0xD9B4BEF9
#define	BITCOIN_MAINNET_PORT   8333
#define	htole16(x)   ((uint16_t)((((x) & 0xFF) << 8) | (((x) >> 8) & 0xFF)))
#define	htole32(x)   ((uint32_t)((((x) & 0xFF) << 24) | (((x) >> 8) & 0xFF00) | (((x) >> 16) & 0xFF) | (((x) >> 24) & 0xFF000000)))
#define	htole64(x)   ((uint64_t)((((x) & 0xFF) << 56) | (((x) >> 8) & 0xFF00) | (((x) >> 16) & 0xFF0000) | (((x) >> 24) & 0xFF000000) | (((x) >> 32) & 0xFF00000000) | (((x) >> 40) & 0xFF0000000000) | (((x) >> 48) & 0xFF000000000000) | (((x) >> 56) & 0xFF00000000000000)))
#define	MAX_LOCATOR_COUNT   10
#define	GENESIS_BLOCK_HASH   "0000000000000000000000000000000000000000000000000000000000000000"
#define	HEADERS_FILE   "headers.dat"
#define	MAX_HEADERS_COUNT   2000

Functions
void	list_connected_nodes ()
	Lists all connected nodes and their details.
int	get_idx (const char *ip_address)
	Get the index of the node with the given IP address.
void	send_getaddr_and_wait (int idx)
	Sends a 'getaddr' message to the peer and waits for a response.
int	connect_to_peer (const char *ip_addr)
	Connects to a peer using the specified IP address.
void	disconnect (int node_id)
	Disconnects from the node specified by the node ID.
unsigned char *	load_blocks_from_file (const char *filename, size_t *payload_len)
void	send_getheaders_and_wait (int idx)
	Sends a 'getheaders' message to the peer and waits for a response.
void	send_headers (int idx, const unsigned char *start_hash, const unsigned char *stop_hash)
	Sends a 'headers' message to the peer.
void	send_getblocks_and_wait (int idx)
	Sends a 'getblocks' message to the peer and waits for a response.
void	send_getdata_and_wait (int idx, const unsigned char *hashes, size_t hash_count)
	Sends a 'getdata' message to the peer and waits for a response.
void	send_inv_and_wait (int idx, const unsigned char *inv_data, size_t inv_count)
	Sends an 'inv' message to the peer and waits for a response.
void	send_tx (int idx, const unsigned char *tx_data, size_t tx_size)
	Sends a 'tx' message to the specified node.

Variables
Node	nodes [MAX_NODES]

Macro Definition Documentation

BITCOIN_MAINNET_MAGIC

#define BITCOIN_MAINNET_MAGIC   0xD9B4BEF9

Definition at line 11 of file peer_connection.h.

BITCOIN_MAINNET_PORT

#define BITCOIN_MAINNET_PORT   8333

Definition at line 14 of file peer_connection.h.

GENESIS_BLOCK_HASH

#define GENESIS_BLOCK_HASH   "0000000000000000000000000000000000000000000000000000000000000000"

Definition at line 21 of file peer_connection.h.

HEADERS_FILE

#define HEADERS_FILE   "headers.dat"

Definition at line 22 of file peer_connection.h.

htole16

#define htole16

(

x

)

((uint16_t)((((x) & 0xFF) << 8) | (((x) >> 8) & 0xFF)))

Definition at line 16 of file peer_connection.h.

htole32

#define htole32

(

x

)

((uint32_t)((((x) & 0xFF) << 24) | (((x) >> 8) & 0xFF00) | (((x) >> 16) & 0xFF) | (((x) >> 24) & 0xFF000000)))

Definition at line 17 of file peer_connection.h.

htole64

#define htole64

(

x

)

((uint64_t)((((x) & 0xFF) << 56) | (((x) >> 8) & 0xFF00) | (((x) >> 16) & 0xFF0000) | (((x) >> 24) & 0xFF000000) | (((x) >> 32) & 0xFF00000000) | (((x) >> 40) & 0xFF0000000000) | (((x) >> 48) & 0xFF000000000000) | (((x) >> 56) & 0xFF00000000000000)))

Definition at line 18 of file peer_connection.h.

MAX_HEADERS_COUNT

#define MAX_HEADERS_COUNT   2000

Definition at line 23 of file peer_connection.h.

MAX_LOCATOR_COUNT

#define MAX_LOCATOR_COUNT   10

Definition at line 20 of file peer_connection.h.

MAX_NODES

#define MAX_NODES   100

Definition at line 8 of file peer_connection.h.

Function Documentation

connect_to_peer()

int connect_to_peer

(

const char *

ip_addr

)

Connects to a peer using the specified IP address.

This function attempts to establish a connection to a peer using the given IP address. It returns a socket file descriptor if the connection is successful, or -1 if it fails.

Parameters

ip_addr

The IP address of the peer to connect to.

Definition at line 1032 of file peer_connection.c.

{
    // Create the socket
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        fprintf(stderr, "[Error] socket creation failed: %s\n", strerror(errno));
        return -1;
    }
 
    struct timeval timeout;
    timeout.tv_sec = 3; // seconds
    timeout.tv_usec = 0; // microseconds
 
    // Set timeout for recv
    if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0)
    {
        perror("setsockopt failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    // Set timeout for connect()
    if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0)
    {
        perror("setsockopt failed");
        close(sockfd);
        return -1;
    }
 
    // Prepare the sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(BITCOIN_MAINNET_PORT);
 
    if (inet_pton(AF_INET, ip_addr, &servaddr.sin_addr) <= 0)
    {
        fprintf(stderr, "[Error] inet_pton failed (IP '%s'): %s\n",
            ip_addr, strerror(errno));
        close(sockfd);
        return -1;
    }
 
    // Connect
    if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
    {
        fprintf(stderr, "[Error] connect to %s:%d failed: %s\n",
            ip_addr, BITCOIN_MAINNET_PORT, strerror(errno));
        close(sockfd);
        return -1;
    }
 
    printf("[+] Connected to peer %s:%d\n", ip_addr, BITCOIN_MAINNET_PORT);
 
    // Build the 'version' payload
    unsigned char version_payload[200];
    size_t version_payload_len = build_version_payload(
        version_payload, sizeof(version_payload));
    if (version_payload_len == 0)
    {
        fprintf(stderr, "[Error] build_version_payload() failed.\n");
        close(sockfd);
        return -1;
    }
 
    // Create the full 'version' message
    unsigned char version_msg[256];
    size_t version_msg_len = build_message(
        version_msg,
        sizeof(version_msg),
        "version",
        version_payload,
        version_payload_len
    );
    if (version_msg_len == 0)
    {
        fprintf(stderr, "[Error] build_message() failed for 'version'.\n");
        close(sockfd);
        return -1;
    }
 
    // Send the 'version' message
    ssize_t bytes_sent = send(sockfd, version_msg, version_msg_len, 0);
    if (bytes_sent < 0)
    {
        fprintf(stderr, "[Error] send() of 'version' failed: %s\n", strerror(errno));
        close(sockfd);
        return -1;
    }
    printf("[+] Sent 'version' message (%zd bytes).\n", bytes_sent);
 
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log",
        ip_addr);
    init_logging(log_filename);
    // Read loop - up to 10 messages
    unsigned char recv_buf[2048];
    bool connected = false;
    for (int i = 0; i < 4; ++i)
    {
        printf("[d] Executing %dth receive loop iteration\n", i);
        ssize_t n = recv(sockfd, recv_buf, sizeof(recv_buf), 0);
        if (n < 0)
        {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
            {
                log_message(LOG_WARN, log_filename, __FILE__,
                    "recv() timed out, continuing...");
                continue;
            }
            fprintf(stderr, "[Error] recv() failed: %s\n", strerror(errno));
            break;
        }
        if (n == 0)
        {
            // Peer closed the connection
            printf("[i] Peer closed the connection.\n");
            break;
        }
 
        // If we have at least a full header, parse it
        if (n < (ssize_t)sizeof(bitcoin_msg_header))
        {
            printf("[!] Received %zd bytes (less than header size 24).\n", n);
            continue;
        }
 
        printf("[<] Received %zd bytes.\n", n);
 
        // Cast to a header
        bitcoin_msg_header* hdr = (bitcoin_msg_header*)recv_buf;
 
        // Check the magic
        if (hdr->magic == BITCOIN_MAINNET_MAGIC)
        {
            char cmd_name[13];
            memset(cmd_name, 0, sizeof(cmd_name));
            memcpy(cmd_name, hdr->command, 12);
 
            printf("[<] Received command: '%s'\n", cmd_name);
 
            // Determine the payload length & pointer
            size_t payload_len = hdr->length;
 
            if (n < (ssize_t)(sizeof(bitcoin_msg_header) + payload_len))
            {
                printf("[!] Incomplete message; got %zd bytes, expected %zu.\n",
                    n, sizeof(bitcoin_msg_header) + payload_len);
                continue;
            }
 
            // Handle known commands
            if (strcmp(cmd_name, "version") == 0)
            {
                // Send verack once we get their version
                ssize_t verack_sent = send_verack(sockfd, ip_addr);
                if (verack_sent < 0)
                {
                    fprintf(stderr, "[Error] sending verack: %s\n", strerror(errno));
                }
                else
                {
                    printf("[+] Sent 'verack' message.\n");
                }
                connected = true;
            }
            else if (strcmp(cmd_name, "verack") == 0)
            {
                connected = true;
                break;
            }
            else
            {
                // Unhandled command
                printf("[!] Unhandled command: '%s' (payload size=%u)\n",
                    cmd_name, hdr->length);
            }
        }
        else
        {
            printf("[!] Unexpected magic bytes (0x%08X).\n", hdr->magic);
        }
    }
    if (connected == true)
    {
        for (int j = 0; j < MAX_NODES; ++j)
        {
            if (nodes[j].is_connected == 0)
            {
                guarded_print_line("connected to node: %s | %d.", ip_addr, j);
                initialize_node(&nodes[j], ip_addr, 8333, sockfd);
                create_peer_thread(&nodes[j]);
                break;
            }
        }
    }
    else
    {
        guarded_print_line("Couldn't connect to node\n");
        close(sockfd);
    }
    return 0;
}

References BITCOIN_MAINNET_MAGIC, BITCOIN_MAINNET_PORT, build_message(), build_version_payload(), bitcoin_msg_header::command, create_peer_thread(), guarded_print_line(), init_logging(), initialize_node(), bitcoin_msg_header::length, log_message(), LOG_WARN, bitcoin_msg_header::magic, MAX_NODES, nodes, and send_verack().

Referenced by cli_connect().

disconnect()

void disconnect

(

int

node_id

)

Disconnects from the node specified by the node ID.

This function disconnects from the node specified by the given node ID. It closes the socket, terminates the thread, and logs the disconnection.

Parameters

node_id

The ID of the node in the nodes array to disconnect from.

Definition at line 1236 of file peer_connection.c.

{
    if (node_id < 0 || node_id >= MAX_NODES || !nodes[node_id].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node ID or node not connected.\n");
        return;
    }
 
    Node* node = &nodes[node_id];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log",
        node->ip_address);
 
    log_message(LOG_INFO, log_filename, __FILE__, "Disconnecting from node %s:%u",
        node->ip_address, node->port);
 
    close(node->socket_fd);
 
    node->is_connected = 0;
 
    if (pthread_cancel(node->thread) != 0)
    {
        perror("Failed to cancel thread for peer");
    }
 
    log_message(LOG_INFO, log_filename, __FILE__,
        "Successfully disconnected from node %s:%u", node->ip_address,
        node->port);
}

References Node::ip_address, Node::is_connected, LOG_INFO, log_message(), MAX_NODES, nodes, Node::port, Node::socket_fd, and Node::thread.

Referenced by cli_disconnect().

get_idx()

int get_idx

(

const char *

ip_address

)

Get the index of the node with the given IP address.

Parameters

ip_address

The IP address of the node.

Returns

The index of the node in the global array.

Definition at line 291 of file peer_connection.c.

{
    for (int i = 0; i < MAX_NODES; ++i)
    {
        if (nodes[i].is_connected == 1 && strcmp(nodes[i].ip_address, ip_address) == 0)
        {
            return i;
        }
    }
    return -1;
}

References MAX_NODES, and nodes.

Referenced by peer_communication().

list_connected_nodes()

void list_connected_nodes

(

)

Lists all connected nodes and their details.

This function iterates through the list of nodes and prints the details of each node that is currently connected.

Definition at line 269 of file peer_connection.c.

{
    for (int i = 0; i < MAX_NODES; ++i)
    {
        if (nodes[i].is_connected == 1)
        {
            guarded_print_line("Node %d:", i);
            guarded_print_line(" IP Address: %s", nodes[i].ip_address);
            guarded_print_line(" Port: %u", nodes[i].port);
            guarded_print_line(" Socket FD: %d", nodes[i].socket_fd);
            guarded_print_line(" Thread ID: %lu", nodes[i].thread);
            guarded_print_line(" Is Connected: %d", nodes[i].is_connected);
            guarded_print_line(" Is operation in progress: %d",
                nodes[i].operation_in_progress);
            guarded_print_line(" Compact blocks: %lu",
                nodes[i].compact_blocks);
            guarded_print_line(" Fee_rate: %lu",
                nodes[i].fee_rate);
        }
    }
}

References guarded_print_line(), MAX_NODES, and nodes.

Referenced by cli_list().

load_blocks_from_file()

unsigned char * load_blocks_from_file	(	const char *	filename,
		size_t *	payload_len
	)

Definition at line 1491 of file peer_connection.c.

{
    FILE* file = fopen(filename, "rb");
    if (!file)
    {
        perror("Failed to open file for reading");
        return NULL;
    }
 
    fseek(file, 0, SEEK_END);
    *payload_len = ftell(file);
    fseek(file, 0, SEEK_SET);
 
    unsigned char* payload = (unsigned char*)malloc(*payload_len);
    if (!payload)
    {
        perror("Failed to allocate memory");
        fclose(file);
        return NULL;
    }
 
    fread(payload, 1, *payload_len, file);
    fclose(file);
    guarded_print("Blocks loaded from file: %s\n", filename);
    return payload;
}

References guarded_print().

Referenced by cli_inv(), and peer_communication().

send_getaddr_and_wait()

void send_getaddr_and_wait

(

int

idx

)

Sends a 'getaddr' message to the peer and waits for a response.

This function sends a 'getaddr' message to the peer identified by the given index and waits for a response. It is used to request a list of known peers from the connected peer.

Parameters

idx	The index of the peer in the nodes array.

Definition at line 303 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log",
        node->ip_address);
 
    // Build the 'getaddr' message
    unsigned char getaddr_msg[sizeof(bitcoin_msg_header)];
    size_t msg_len = build_message(getaddr_msg, sizeof(getaddr_msg), "getaddr", NULL,
        0);
    if (msg_len == 0)
    {
        fprintf(stderr, "[Error] Failed to build 'getaddr' message.\n");
        return;
    }
 
    // Send the 'getaddr' message
    ssize_t bytes_sent = send(node->socket_fd, getaddr_msg, msg_len, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'getaddr' message: %s", strerror(errno));
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'getaddr' message.");
    node->operation_in_progress = 1;
 
    // Wait for 10 seconds for a response
    struct timeval tv;
    tv.tv_sec = 3;
    tv.tv_usec = 0;
    setsockopt(node->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
 
    char buffer[32768];
    size_t total_bytes_received = 0;
    ssize_t bytes_received;
 
    // Receive the message in parts
    while (total_bytes_received < sizeof(bitcoin_msg_header))
    {
        log_message(LOG_INFO, log_filename, __FILE__, "first while receiving");
        bytes_received = recv(node->socket_fd, buffer + total_bytes_received,
            sizeof(buffer) - total_bytes_received - 1, 0);
        if (bytes_received <= 0)
        {
            log_message(LOG_INFO, log_filename, __FILE__, "Recv 1 failed: %s",
                strerror(errno));
            node->is_connected = 0;
            node->operation_in_progress = 0;
            return;
        }
        total_bytes_received += bytes_received;
    }
 
    bitcoin_msg_header* hdr = (bitcoin_msg_header*)buffer;
    size_t payload_len = hdr->length;
    size_t message_size = sizeof(bitcoin_msg_header) + payload_len;
    int retry_count = 0;
    const int max_retries = 1;
 
    while (total_bytes_received < message_size)
    {
        log_message(LOG_INFO, log_filename, __FILE__, "second while receiving");
        bytes_received = recv(node->socket_fd, buffer + total_bytes_received,
            sizeof(buffer) - total_bytes_received - 1, 0);
        if (bytes_received <= 0)
        {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
            {
                log_message(LOG_INFO, log_filename, __FILE__,
                    "second while receiving inside if errno");
                // Resource temporarily unavailable, continue receiving
 
                if (++retry_count >= max_retries)
                {
                    log_message(LOG_WARN, log_filename, __FILE__,
                        "Max retries reached, stopping recv.");
                    node->is_connected = 0;
                    node->operation_in_progress = 0;
                    break;
                }
                continue;
            }
            log_message(LOG_INFO, log_filename, __FILE__, "Recv failed: %s",
                strerror(errno));
            node->is_connected = 0;
            node->operation_in_progress = 0;
            return;
        }
        total_bytes_received += bytes_received;
    }
 
    buffer[total_bytes_received] = '\0'; // Null-terminate the received data
 
    if (hdr->magic == BITCOIN_MAINNET_MAGIC)
    {
        char cmd_name[13];
        memset(cmd_name, 0, sizeof(cmd_name));
        memcpy(cmd_name, hdr->command, 12);
 
        log_message(LOG_INFO, log_filename, __FILE__, "[!] Received %s command ",
            cmd_name);
 
        const unsigned char* payload_data = (unsigned char*)buffer + sizeof(
            bitcoin_msg_header);
 
 
        if (strcmp(cmd_name, "addr") == 0)
        {
            size_t offset = 0;
 
            // Check if the payload length is sufficient to read the count of address entries
            if (payload_len < 1)
            {
                log_message(LOG_WARN, log_filename, __FILE__,
                    "Insufficient payload length to read address count");
                return;
            }
 
            // Read the count of address entries (var_int)
            uint64_t count = read_var_int(payload_data + offset, &offset);
 
            // Log the count of address entries
            log_message(LOG_INFO, log_filename, __FILE__, "Address count: %llu", count);
 
            // Ensure count does not exceed the maximum allowed entries
            if (count > 1000)
            {
                log_message(LOG_WARN, log_filename, __FILE__,
                    "Address count exceeds maximum allowed: %llu", count);
                return;
            }
 
            for (uint64_t i = 0; i < count; i++)
            {
                if (offset + 30 > payload_len)
                {
                    log_message(LOG_WARN, log_filename, __FILE__,
                        "Insufficient payload length for address entry");
                    return;
                }
 
                // Read timestamp (4 bytes)
                uint32_t timestamp;
                memcpy(&timestamp, payload_data + offset, 4);
                timestamp = ntohl(timestamp);
                offset += 4;
 
                // Read services (8 bytes, skip for now)
                offset += 8;
 
                // Read IP address (16 bytes)
                struct in6_addr ip_addr;
                memcpy(&ip_addr, payload_data + offset, 16);
                offset += 16;
 
                // Read port (2 bytes)
                uint16_t port;
                memcpy(&port, payload_data + offset, 2);
                port = ntohs(port);
                offset += 2;
 
                // Convert IP to string
                char ip_str[INET6_ADDRSTRLEN];
                inet_ntop(AF_INET6, &ip_addr, ip_str, INET6_ADDRSTRLEN);
 
                // Determine if the address is IPv4-mapped or IPv6
                const char* ip_type = "IPv6";
                if (IN6_IS_ADDR_V4MAPPED(&ip_addr))
                {
                    struct in_addr ipv4_addr;
                    memcpy(&ipv4_addr, &ip_addr.s6_addr[12], 4);
                    inet_ntop(AF_INET, &ipv4_addr, ip_str, INET_ADDRSTRLEN);
                    ip_type = "IPv4";
                }
 
                // Check if it's a valid IPv4 address
                if (strcmp(ip_type, "IPv4") == 0 && is_valid_ipv4(ip_str) && !
                    is_in_private_network(ip_str))
                {
                    // Guarded print of the IP address and port
                    guarded_print_line("Valid IPv4 Peer: %s:%u (timestamp: %u)", ip_str,
                        port, timestamp);
 
                    // Add to peer queue
                    add_peer_to_queue(ip_str, port);
 
                    // Log the result if valid
                    log_message(LOG_INFO, log_filename, __FILE__,
                        "Received valid IPv4 address: %s:%u (timestamp: %u)",
                        ip_str, port, timestamp);
                }
                else if (strcmp(ip_type, "IPv6") == 0)
                {
                    // Log the IPv6 addresses if needed
                    log_message(LOG_INFO, log_filename, __FILE__,
                        "Received IPv6 address: %s:%u (timestamp: %u)",
                        ip_str, port, timestamp);
                }
            }
 
            if (offset != payload_len)
            {
                log_message(LOG_WARN, log_filename, __FILE__,
                    "Remaining bytes after processing: %zu",
                    payload_len - offset);
            }
        }
    }
    else
    {
        log_message(LOG_WARN, log_filename, __FILE__,
            "else hdr->magic ");
    }
 
    node->operation_in_progress = 0;
}

References add_peer_to_queue(), BITCOIN_MAINNET_MAGIC, build_message(), bitcoin_msg_header::command, guarded_print_line(), Node::ip_address, Node::is_connected, is_in_private_network(), is_valid_ipv4(), bitcoin_msg_header::length, LOG_INFO, log_message(), LOG_WARN, bitcoin_msg_header::magic, MAX_NODES, nodes, Node::operation_in_progress, read_var_int(), and Node::socket_fd.

Referenced by cli_getaddr().

send_getblocks_and_wait()

void send_getblocks_and_wait

(

int

idx

)

Sends a 'getblocks' message to the peer and waits for a response.

This function sends a 'getblocks' message to the peer identified by the given index and waits for a response. It is used to request a list of blocks from the connected peer. The response is processed and the blocks are saved to a file.

Parameters

idx	The index of the peer in the nodes array.

Definition at line 1518 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log", node->ip_address);
 
    // Define block locator and locator count
    unsigned char block_locator[MAX_LOCATOR_COUNT * 32];
    int locator_count = 1; // Set to 1 to request blocks starting from the latest known block
 
    // Load the latest known block hash
    load_latest_known_block_hash(block_locator);
 
    // Build the 'getblocks' message
    unsigned char getblocks_msg[sizeof(bitcoin_msg_header) + 4 + 1 + (MAX_LOCATOR_COUNT * 32) + 32];
    size_t msg_len = build_getblocks_message(getblocks_msg, sizeof(getblocks_msg), block_locator, locator_count);
    if (msg_len == 0)
    {
        fprintf(stderr, "[Error] Failed to build 'getblocks' message.\n");
        return;
    }
 
    // Send the 'getblocks' message
    ssize_t bytes_sent = send(node->socket_fd, getblocks_msg, msg_len, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'getblocks' message: %s", strerror(errno));
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'getblocks' message.");
    node->operation_in_progress = 1;
 
    // Wait for 10 seconds for a response
    struct timeval tv;
    tv.tv_sec = 10;
    tv.tv_usec = 0;
    setsockopt(node->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
 
    // Increase buffer size to handle larger responses
    unsigned char buffer[32768];
    size_t total_bytes_received = 0;
    ssize_t bytes_received;
 
    // Receive the message in parts
    while ((bytes_received = recv(node->socket_fd, buffer + total_bytes_received, sizeof(buffer) - total_bytes_received - 1, 0)) > 0)
    {
        total_bytes_received += bytes_received;
    }
 
    if (bytes_received < 0 && errno != EAGAIN && errno != EWOULDBLOCK)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to receive response: %s", strerror(errno));
        node->operation_in_progress = 0;
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Received response to 'getblocks' message.");
    node->operation_in_progress = 0;
 
    // Process the response and print to CLI
    guarded_print("Received response to 'getblocks' message:\n");
    parse_inv_message(buffer, total_bytes_received);
 
    // Save the blocks to a file
    save_blocks_to_file(buffer, total_bytes_received, "blocks.dat");
}

References build_getblocks_message(), guarded_print(), Node::ip_address, load_latest_known_block_hash(), LOG_INFO, log_message(), MAX_LOCATOR_COUNT, MAX_NODES, nodes, Node::operation_in_progress, parse_inv_message(), save_blocks_to_file(), and Node::socket_fd.

Referenced by cli_getblocks().

send_getdata_and_wait()

void send_getdata_and_wait	(	int	idx,
		const unsigned char *	hashes,
		size_t	hash_count
	)

Sends a 'getdata' message to the peer and waits for a response.

This function sends a 'getdata' message to the peer identified by the given index and waits for a response. It is used to request specific blocks or transactions from the connected peer based on the provided hashes. The response is saved to a file and logged to the Bitlab logs.

Parameters

idx	The index of the peer in the nodes array.
hashes	An array of hashes representing the blocks or transactions to request.
hash_count	The number of hashes in the array.

Definition at line 1728 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    if (hash_count == 0 || hash_count > 50000)
    {
        fprintf(stderr, "[Error] Invalid hash count. Must be between 1 and 50000.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log", node->ip_address);
 
    // Build the 'getdata' message
    unsigned char getdata_msg[sizeof(bitcoin_msg_header) + 1 + (hash_count * 36)];
    size_t msg_len = build_getdata_message(getdata_msg, sizeof(getdata_msg), hashes, hash_count);
    if (msg_len == 0)
    {
        fprintf(stderr, "[Error] Failed to build 'getdata' message.\n");
        return;
    }
 
    // Send the 'getdata' message
    ssize_t bytes_sent = send(node->socket_fd, getdata_msg, msg_len, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'getdata' message: %s", strerror(errno));
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'getdata' message.");
    node->operation_in_progress = 1;
 
    // Wait for 20 seconds for a response (increased timeout)
    struct timeval tv;
    tv.tv_sec = 20;
    tv.tv_usec = 0;
    setsockopt(node->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
 
    // Receive the response
    unsigned char buffer[32768];
    ssize_t bytes_received;
 
    while ((bytes_received = recv(node->socket_fd, buffer, sizeof(buffer), 0)) > 0)
    {
        bitcoin_msg_header* hdr = (bitcoin_msg_header*)buffer;
        if (hdr->magic == BITCOIN_MAINNET_MAGIC)
        {
            char cmd_name[13];
            memset(cmd_name, 0, sizeof(cmd_name));
            memcpy(cmd_name, hdr->command, 12);
 
            if (strcmp(cmd_name, "block") == 0)
            {
                log_message(LOG_INFO, log_filename, __FILE__, "Received 'block' message.");
                decode_transactions(buffer + sizeof(bitcoin_msg_header), hdr->length);
            }
        }
    }
 
    if (bytes_received < 0 && errno != EAGAIN && errno != EWOULDBLOCK)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to receive block message: %s", strerror(errno));
    }
 
    node->operation_in_progress = 0;
}

References BITCOIN_MAINNET_MAGIC, build_getdata_message(), bitcoin_msg_header::command, decode_transactions(), Node::ip_address, bitcoin_msg_header::length, LOG_INFO, log_message(), bitcoin_msg_header::magic, MAX_NODES, nodes, Node::operation_in_progress, and Node::socket_fd.

Referenced by cli_getdata(), and handle_inv_message().

send_getheaders_and_wait()

void send_getheaders_and_wait

(

int

idx

)

Sends a 'getheaders' message to the peer and waits for a response.

This function sends a 'getheaders' message to the peer identified by the given index and waits for a response. It is used to request a list of known peers from the connected peer.

Parameters

idx	The index of the peer in the nodes array.

Definition at line 1330 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log", node->ip_address);
 
    // Define block locator and locator count
    unsigned char block_locator[MAX_LOCATOR_COUNT * 32];
    int locator_count = 1; // Set to 1 to request headers starting from the latest known block
 
    // Load the latest known block hash
    load_latest_known_block_hash(block_locator);
 
    // Build the 'getheaders' message
    unsigned char getheaders_msg[sizeof(bitcoin_msg_header) + 4 + 1 + (MAX_LOCATOR_COUNT * 32) + 32];
    size_t msg_len = build_getheaders_message(getheaders_msg, sizeof(getheaders_msg), block_locator, locator_count);
    if (msg_len == 0)
    {
        fprintf(stderr, "[Error] Failed to build 'getheaders' message.\n");
        return;
    }
 
    // Send the 'getheaders' message
    ssize_t bytes_sent = send(node->socket_fd, getheaders_msg, msg_len, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'getheaders' message: %s", strerror(errno));
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'getheaders' message.");
    node->operation_in_progress = 1;
 
    // Wait for 10 seconds for a response
    struct timeval tv;
    tv.tv_sec = 10;
    tv.tv_usec = 0;
    setsockopt(node->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
 
    // Receive the response
    unsigned char buffer[4096];
    ssize_t bytes_received = recv(node->socket_fd, buffer, sizeof(buffer), 0);
    if (bytes_received < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to receive response: %s", strerror(errno));
        node->operation_in_progress = 0;
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Received response to 'getheaders' message.");
    node->operation_in_progress = 0;
 
    // Process the response and print to CLI
    guarded_print("Received response to 'getheaders' message:\n");
    parse_headers_message(buffer, bytes_received);
}

References build_getheaders_message(), guarded_print(), Node::ip_address, load_latest_known_block_hash(), LOG_INFO, log_message(), MAX_LOCATOR_COUNT, MAX_NODES, nodes, Node::operation_in_progress, parse_headers_message(), and Node::socket_fd.

Referenced by cli_getheaders().

send_headers()

void send_headers	(	int	idx,
		const unsigned char *	start_hash,
		const unsigned char *	stop_hash
	)

Sends a 'headers' message to the peer.

This function sends a 'headers' message to the peer identified by the given index. It retrieves the block headers from the local storage starting from the specified start hash up to the stop hash or the maximum number of headers allowed.

Parameters

idx	The index of the peer in the nodes array.
start_hash	The hash of the first block header to send.
stop_hash	The hash of the last block header to send.

Definition at line 1395 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log", node->ip_address);
 
    // Open the headers file
    FILE* file = fopen(HEADERS_FILE, "rb");
    if (!file)
    {
        perror("Failed to open headers file");
        return;
    }
 
    // Find the starting block header
    unsigned char buffer[81];
    size_t headers_count = 0;
    int found_start = 0;
    while (fread(buffer, 80, 1, file) == 1)
    {
        if (memcmp(buffer, start_hash, 32) == 0)
        {
            found_start = 1;
            break;
        }
    }
 
    if (!found_start)
    {
        fclose(file);
        fprintf(stderr, "[Error] Start hash not found in headers file.\n");
        return;
    }
 
    // Build the 'headers' message
    unsigned char headers_msg[sizeof(bitcoin_msg_header) + 1 + (MAX_HEADERS_COUNT * 81)];
    size_t offset = sizeof(bitcoin_msg_header);
    headers_msg[offset++] = 0; // Placeholder for count
 
    while (headers_count < MAX_HEADERS_COUNT && fread(buffer, 80, 1, file) == 1)
    {
        memcpy(headers_msg + offset, buffer, 80);
        offset += 80;
        headers_msg[offset++] = 0; // Transaction count (var_int, 0 for headers only)
        headers_count++;
 
        if (memcmp(buffer, stop_hash, 32) == 0)
        {
            break;
        }
    }
 
    fclose(file);
 
    // Set the count
    headers_msg[sizeof(bitcoin_msg_header)] = headers_count;
 
    // Build the message header
    bitcoin_msg_header* header = (bitcoin_msg_header*)headers_msg;
    header->magic = htole32(BITCOIN_MAINNET_MAGIC);
    strncpy(header->command, "headers", 12);
    header->length = htole32(offset - sizeof(bitcoin_msg_header));
    compute_checksum(headers_msg + sizeof(bitcoin_msg_header), offset - sizeof(bitcoin_msg_header), header->checksum);
 
    // Send the 'headers' message
    ssize_t bytes_sent = send(node->socket_fd, headers_msg, offset, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'headers' message: %s", strerror(errno));
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'headers' message.");
}

References BITCOIN_MAINNET_MAGIC, compute_checksum(), HEADERS_FILE, htole32, Node::ip_address, LOG_INFO, log_message(), bitcoin_msg_header::magic, MAX_HEADERS_COUNT, MAX_NODES, nodes, and Node::socket_fd.

Referenced by peer_communication().

send_inv_and_wait()

void send_inv_and_wait	(	int	idx,
		const unsigned char *	inv_data,
		size_t	inv_count
	)

Sends an 'inv' message to the peer and waits for a response.

This function sends an 'inv' message to the peer identified by the given index and waits for a response. It is used to advertise the knowledge of one or more objects (blocks or transactions). The inventory data is provided as input to the function.

Parameters

idx	The index of the peer in the nodes array.
inv_data	An array of inventory vectors (type + hash).
inv_count	The number of inventory vectors in the array.

Sends an 'inv' message to the peer and waits for a response.

This function sends an 'inv' message to the peer identified by the given index. It is used to advertise the knowledge of one or more objects (blocks or transactions). The inventory data is provided as input to the function.

Parameters

idx	The index of the peer in the nodes array.
inv_data	An array of inventory vectors (type + hash).
inv_count	The number of inventory vectors in the array.

Definition at line 1866 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    if (inv_count == 0 || inv_count > 50000)
    {
        fprintf(stderr, "[Error] Invalid inventory count. Must be between 1 and 50000.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log", node->ip_address);
 
    size_t var_int_size = write_var_int(NULL, inv_count); // Get the size of the var_int encoding
    size_t payload_size = var_int_size + (inv_count * 36); // var_int size + 36 bytes per inventory vector
    size_t inv_msg_size = sizeof(bitcoin_msg_header) + payload_size;
 
    printf("inv_count: %zu, inv_msg_size: %zu\n", inv_count, inv_msg_size);
 
    unsigned char* inv_msg = (unsigned char*)malloc(inv_msg_size);
    if (!inv_msg)
    {
        fprintf(stderr, "[Error] Failed to allocate memory for 'inv' message.\n");
        return;
    }
 
    size_t msg_len = build_inv_message(inv_msg, inv_msg_size, inv_data, inv_count);
    printf("msg_len: %zu\n", msg_len);
    if (msg_len == 0)
    {
        fprintf(stderr, "[Error] Failed to build 'inv' message.\n");
        free(inv_msg);
        return;
    }
 
    // Send the 'inv' message
    ssize_t bytes_sent = send(node->socket_fd, inv_msg, msg_len, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'inv' message: %s", strerror(errno));
        free(inv_msg);
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'inv' message.");
    printf("Sent 'inv' message.\n");
    node->operation_in_progress = 1;
 
    // Wait for 10 seconds for a response
    struct timeval tv;
    tv.tv_sec = 10;
    tv.tv_usec = 0;
    setsockopt(node->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
 
    // Receive the response
    unsigned char buffer[32768];
    ssize_t bytes_received = recv(node->socket_fd, buffer, sizeof(buffer), 0);
    if (bytes_received < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to receive response: %s", strerror(errno));
        node->operation_in_progress = 0;
        free(inv_msg);
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Received response to 'inv' message.");
    printf("Received response to 'inv' message.\n");
    node->operation_in_progress = 0;
 
    // Process the response
    if (bytes_received >= (ssize_t)sizeof(bitcoin_msg_header))
    {
        bitcoin_msg_header* hdr = (bitcoin_msg_header*)buffer;
        if (hdr->magic == BITCOIN_MAINNET_MAGIC)
        {
            char cmd_name[13];
            memset(cmd_name, 0, sizeof(cmd_name));
            memcpy(cmd_name, hdr->command, 12);
 
            printf("Received command: '%s'\n", cmd_name);
 
            if (strcmp(cmd_name, "inv") == 0)
            {
                printf("Received 'inv' response:\n");
                handle_inv_message(idx, buffer + sizeof(bitcoin_msg_header), bytes_received - sizeof(bitcoin_msg_header));
            }
            else
            {
                printf("Unhandled command: '%s'\n", cmd_name);
            }
        }
        else
        {
            printf("Unexpected magic bytes (0x%08X).\n", hdr->magic);
        }
    }
    else
    {
        printf("Received incomplete message.\n");
    }
 
    free(inv_msg);
}

References BITCOIN_MAINNET_MAGIC, build_inv_message(), bitcoin_msg_header::command, handle_inv_message(), Node::ip_address, LOG_INFO, log_message(), bitcoin_msg_header::magic, MAX_NODES, nodes, Node::operation_in_progress, Node::socket_fd, and write_var_int().

Referenced by cli_inv().

send_tx()

void send_tx	(	int	idx,
		const unsigned char *	tx_data,
		size_t	tx_size
	)

Sends a 'tx' message to the specified node.

This function sends a 'tx' message to the node identified by the given index with the provided transaction data. It constructs the message with the appropriate Bitcoin protocol header and sends it over the network socket associated with the node.

Parameters

idx	The index of the node in the nodes array.
tx_data	A pointer to the transaction data in hexadecimal format.
tx_size	The size of the transaction data in bytes.

Definition at line 2047 of file peer_connection.c.

{
    if (idx < 0 || idx >= MAX_NODES || !nodes[idx].is_connected)
    {
        fprintf(stderr, "[Error] Invalid node index or node not connected.\n");
        return;
    }
 
    Node* node = &nodes[idx];
    char log_filename[256];
    snprintf(log_filename, sizeof(log_filename), "peer_connection_%s.log", node->ip_address);
 
    if (!tx_data || tx_size == 0)
    {
        fprintf(stderr, "[Error] Invalid transaction data.\n");
        return;
    }
 
    // Build the 'tx' message with the appropriate header
    unsigned char tx_msg[sizeof(bitcoin_msg_header) + tx_size];
 
    // Build the message header
    bitcoin_msg_header* header = (bitcoin_msg_header*)tx_msg;
    header->magic = htole32(BITCOIN_MAINNET_MAGIC);
    strncpy(header->command, "tx", 12);
    header->length = htole32(tx_size);
    compute_checksum(tx_data, tx_size, header->checksum);
 
    // Copy the transaction data
    memcpy(tx_msg + sizeof(bitcoin_msg_header), tx_data, tx_size);
 
    // Send the 'tx' message
    ssize_t bytes_sent = send(node->socket_fd, tx_msg, sizeof(bitcoin_msg_header) + tx_size, 0);
    if (bytes_sent < 0)
    {
        log_message(LOG_INFO, log_filename, __FILE__,
            "[Error] Failed to send 'tx' message: %s", strerror(errno));
        return;
    }
 
    log_message(LOG_INFO, log_filename, __FILE__, "Sent 'tx' message (%zu bytes).", tx_size);
}

References BITCOIN_MAINNET_MAGIC, compute_checksum(), htole32, Node::ip_address, LOG_INFO, log_message(), bitcoin_msg_header::magic, MAX_NODES, nodes, and Node::socket_fd.

Referenced by cli_tx().

Variable Documentation

nodes

Node nodes[MAX_NODES]

extern

Definition at line 26 of file peer_connection.c.

Referenced by connect_to_peer(), disconnect(), get_idx(), list_connected_nodes(), send_getaddr_and_wait(), send_getblocks_and_wait(), send_getdata_and_wait(), send_getheaders_and_wait(), send_headers(), send_inv_and_wait(), and send_tx().