librats 0.5.0 → 0.5.1

package/native-src/src/tracker.h

@@ -0,0 +1,268 @@
+    #pragma once
+
+#include "bittorrent.h"
+#include "socket.h"
+#include <string>
+#include <vector>
+#include <memory>
+#include <functional>
+#include <chrono>
+#include <atomic>
+#include <mutex>
+
+namespace librats {
+
+// Forward declarations
+class TrackerClient;
+class HttpTrackerClient;
+class UdpTrackerClient;
+
+// Tracker announce event types (BEP 3)
+enum class TrackerEvent {
+    NONE = 0,
+    COMPLETED = 1,
+    STARTED = 2,
+    STOPPED = 3
+};
+
+// Tracker response structure
+struct TrackerResponse {
+    std::string failure_reason;
+    std::string warning_message;
+    uint32_t interval;           // Seconds until next announce
+    uint32_t min_interval;       // Minimum announce interval
+    std::string tracker_id;      // Tracker ID for subsequent requests
+    uint32_t complete;           // Number of seeders
+    uint32_t incomplete;         // Number of leechers
+    uint32_t downloaded;         // Number of times downloaded (scrape only)
+    std::vector<Peer> peers;     // Peer list
+    bool success;
+    
+    TrackerResponse() 
+        : interval(1800), min_interval(900), complete(0), incomplete(0), 
+          downloaded(0), success(false) {}
+};
+
+// Tracker announce request parameters
+struct TrackerRequest {
+    InfoHash info_hash;
+    PeerID peer_id;
+    uint16_t port;
+    uint64_t uploaded;
+    uint64_t downloaded;
+    uint64_t left;
+    TrackerEvent event;
+    std::string ip;              // Optional IP address
+    uint32_t numwant;            // Number of peers wanted (default 50)
+    std::string tracker_id;      // Tracker ID from previous response
+    
+    TrackerRequest()
+        : port(0), uploaded(0), downloaded(0), left(0), 
+          event(TrackerEvent::NONE), numwant(50) {}
+};
+
+// Callback for tracker responses
+using TrackerResponseCallback = std::function<void(const TrackerResponse& response, const std::string& tracker_url)>;
+
+// Base tracker client interface
+class TrackerClient {
+public:
+    virtual ~TrackerClient() = default;
+    
+    // Announce to tracker
+    virtual bool announce(const TrackerRequest& request, TrackerResponseCallback callback) = 0;
+    
+    // Scrape tracker (optional, not all trackers support this)
+    virtual bool scrape(const std::vector<InfoHash>& info_hashes, TrackerResponseCallback callback) = 0;
+    
+    // Get tracker URL
+    virtual std::string get_url() const = 0;
+    
+    // Get last announce time
+    virtual std::chrono::steady_clock::time_point get_last_announce_time() const = 0;
+    
+    // Get announce interval
+    virtual uint32_t get_interval() const = 0;
+    
+    // Check if tracker is working
+    virtual bool is_working() const = 0;
+};
+
+// HTTP/HTTPS Tracker Client (BEP 3)
+class HttpTrackerClient : public TrackerClient {
+public:
+    explicit HttpTrackerClient(const std::string& tracker_url);
+    ~HttpTrackerClient() override;
+    
+    bool announce(const TrackerRequest& request, TrackerResponseCallback callback) override;
+    bool scrape(const std::vector<InfoHash>& info_hashes, TrackerResponseCallback callback) override;
+    
+    std::string get_url() const override { return tracker_url_; }
+    std::chrono::steady_clock::time_point get_last_announce_time() const override { return last_announce_time_; }
+    uint32_t get_interval() const override { return interval_; }
+    bool is_working() const override { return is_working_; }
+    
+private:
+    std::string tracker_url_;
+    std::chrono::steady_clock::time_point last_announce_time_;
+    uint32_t interval_;
+    std::atomic<bool> is_working_;
+    std::string tracker_id_;
+    
+    // Build announce URL with parameters
+    std::string build_announce_url(const TrackerRequest& request);
+    
+    // Build scrape URL
+    std::string build_scrape_url(const std::vector<InfoHash>& info_hashes);
+    
+    // Parse tracker response (bencode format)
+    TrackerResponse parse_response(const std::vector<uint8_t>& data);
+    
+    // Parse compact peer list (BEP 23)
+    std::vector<Peer> parse_compact_peers(const std::string& peer_data);
+    
+    // Parse dictionary peer list
+    std::vector<Peer> parse_dict_peers(const BencodeValue& peers_list);
+    
+    // HTTP GET request
+    std::vector<uint8_t> http_get(const std::string& url);
+    
+    // URL encode string
+    std::string url_encode(const std::string& str);
+    
+    // URL encode binary data (for info_hash)
+    std::string url_encode_binary(const uint8_t* data, size_t len);
+};
+
+// UDP Tracker Client (BEP 15)
+class UdpTrackerClient : public TrackerClient {
+public:
+    explicit UdpTrackerClient(const std::string& tracker_url);
+    ~UdpTrackerClient() override;
+    
+    bool announce(const TrackerRequest& request, TrackerResponseCallback callback) override;
+    bool scrape(const std::vector<InfoHash>& info_hashes, TrackerResponseCallback callback) override;
+    
+    std::string get_url() const override { return tracker_url_; }
+    std::chrono::steady_clock::time_point get_last_announce_time() const override { return last_announce_time_; }
+    uint32_t get_interval() const override { return interval_; }
+    bool is_working() const override { return is_working_; }
+    
+private:
+    std::string tracker_url_;
+    std::string hostname_;
+    uint16_t port_;
+    socket_t socket_;
+    std::chrono::steady_clock::time_point last_announce_time_;
+    std::chrono::steady_clock::time_point connection_expire_time_;
+    uint32_t interval_;
+    std::atomic<bool> is_working_;
+    int64_t connection_id_;
+    std::mutex socket_mutex_;
+    
+    // UDP tracker protocol constants
+    static constexpr int64_t PROTOCOL_ID = 0x41727101980LL;
+    static constexpr uint32_t ACTION_CONNECT = 0;
+    static constexpr uint32_t ACTION_ANNOUNCE = 1;
+    static constexpr uint32_t ACTION_SCRAPE = 2;
+    static constexpr uint32_t ACTION_ERROR = 3;
+    
+    // Parse tracker URL
+    bool parse_url();
+    
+    // Connect to UDP tracker (get connection ID)
+    bool connect();
+    
+    // Check if connection is still valid
+    bool is_connection_valid();
+    
+    // Send UDP request and receive response
+    std::vector<uint8_t> send_request(const std::vector<uint8_t>& request, int timeout_ms = 15000);
+    
+    // Build connect request
+    std::vector<uint8_t> build_connect_request(uint32_t transaction_id);
+    
+    // Build announce request
+    std::vector<uint8_t> build_announce_request(const TrackerRequest& request, uint32_t transaction_id);
+    
+    // Build scrape request
+    std::vector<uint8_t> build_scrape_request(const std::vector<InfoHash>& info_hashes, uint32_t transaction_id);
+    
+    // Parse connect response
+    bool parse_connect_response(const std::vector<uint8_t>& data, uint32_t expected_transaction_id);
+    
+    // Parse announce response
+    TrackerResponse parse_announce_response(const std::vector<uint8_t>& data, uint32_t expected_transaction_id);
+    
+    // Parse scrape response
+    TrackerResponse parse_scrape_response(const std::vector<uint8_t>& data, uint32_t expected_transaction_id);
+    
+    // Parse error response
+    std::string parse_error_response(const std::vector<uint8_t>& data);
+    
+    // Generate random transaction ID
+    uint32_t generate_transaction_id();
+    
+    // Read 32-bit big-endian integer
+    static uint32_t read_uint32_be(const uint8_t* data);
+    
+    // Write 32-bit big-endian integer
+    static void write_uint32_be(uint8_t* data, uint32_t value);
+    
+    // Read 64-bit big-endian integer
+    static int64_t read_int64_be(const uint8_t* data);
+    
+    // Write 64-bit big-endian integer
+    static void write_int64_be(uint8_t* data, int64_t value);
+};
+
+// Tracker Manager - manages multiple trackers for a torrent
+class TrackerManager {
+public:
+    explicit TrackerManager(const TorrentInfo& torrent_info);
+    ~TrackerManager();
+    
+    // Add tracker from URL
+    bool add_tracker(const std::string& tracker_url);
+    
+    // Announce to all trackers
+    void announce(const TrackerRequest& request, TrackerResponseCallback callback);
+    
+    // Announce to best tracker only
+    void announce_to_best(const TrackerRequest& request, TrackerResponseCallback callback);
+    
+    // Scrape all trackers
+    void scrape(TrackerResponseCallback callback);
+    
+    // Get number of working trackers
+    size_t get_working_tracker_count() const;
+    
+    // Get all tracker URLs
+    std::vector<std::string> get_tracker_urls() const;
+    
+    // Check if it's time to announce
+    bool should_announce() const;
+    
+    // Get next announce time
+    std::chrono::steady_clock::time_point get_next_announce_time() const;
+    
+private:
+    std::vector<std::shared_ptr<TrackerClient>> trackers_;
+    mutable std::mutex trackers_mutex_;
+    InfoHash info_hash_;
+    std::chrono::steady_clock::time_point last_announce_time_;
+    uint32_t announce_interval_;
+    
+    // Create tracker client based on URL scheme
+    std::shared_ptr<TrackerClient> create_tracker_client(const std::string& tracker_url);
+    
+    // Sort trackers by priority (working trackers first)
+    void sort_trackers_by_priority();
+};
+
+// Utility functions
+std::string tracker_event_to_string(TrackerEvent event);
+TrackerEvent string_to_tracker_event(const std::string& event_str);
+
+} // namespace librats
+

package/native-src/src/version.cpp

@@ -0,0 +1,24 @@
+#include "version.h"
+#include <iostream>
+#include <iomanip>
+#include "rats_export.h"
+
+namespace librats {
+    namespace version {
+        
+        RATS_API void rats_print_version_info() {
+            std::cout << "Version: " << STRING << std::endl;
+            std::cout << "Git: " << GIT_DESCRIBE << std::endl;
+            std::cout << "Build: " << BUILD << std::endl;
+        }
+        
+        RATS_API void rats_print_header() {
+            std::cout << ASCII_HEADER << std::endl;
+            std::cout << "           Version: " << std::left << std::setw(10) << STRING 
+                      << "  Build: " << BUILD << std::endl;
+            std::cout << "           Git: " << GIT_DESCRIBE << std::endl;
+            std::cout << "        ========================================        " << std::endl;
+            std::cout << std::endl;
+        }
+    }
+}

package/native-src/src/version.h.in

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "rats_export.h"
+
+// This file is auto-generated by CMake. Do not edit manually.
+#define LIBRATS_VERSION_MAJOR @VERSION_MAJOR@
+#define LIBRATS_VERSION_MINOR @VERSION_MINOR@
+#define LIBRATS_VERSION_PATCH @VERSION_PATCH@
+#define LIBRATS_VERSION_BUILD @VERSION_BUILD@
+#define LIBRATS_VERSION_STRING "@VERSION_STRING@"
+#define LIBRATS_GIT_DESCRIBE "@GIT_DESCRIBE@"
+
+// ASCII Art Header
+#define LIBRATS_ASCII_HEADER \
+"        #######    #####   ########  #######       \n" \
+"        ##    ##  ##   ##     ##     ##            \n" \
+"        ##    ##  ##   ##     ##     ##            \n" \
+"        #######   #######     ##     #######       \n" \
+"        ##  ##    ##   ##     ##           ##      \n" \
+"        ##   ##   ##   ##     ##           ##      \n" \
+"        ##    ##  ##   ##     ##     #######       \n" \
+"                                                    \n" \
+"           P2P Network Communication Library       \n" \
+"        ======================================      \n"
+
+namespace librats {
+    namespace version {
+        // Version information
+        const int MAJOR = LIBRATS_VERSION_MAJOR;
+        const int MINOR = LIBRATS_VERSION_MINOR;
+        const int PATCH = LIBRATS_VERSION_PATCH;
+        const int BUILD = LIBRATS_VERSION_BUILD;
+        const char* const STRING = LIBRATS_VERSION_STRING;
+        const char* const GIT_DESCRIBE = LIBRATS_GIT_DESCRIBE;
+        
+        // ASCII header
+        const char* const ASCII_HEADER = LIBRATS_ASCII_HEADER;
+        
+        // Print version info
+        RATS_API void rats_print_version_info();
+        
+        // Print ASCII header with version
+        RATS_API void rats_print_header();
+    }
+}

package/native-src/version.rc.in

@@ -0,0 +1,31 @@
+#include <windows.h>
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION @VERSION_MAJOR@,@VERSION_MINOR@,@VERSION_PATCH@,@VERSION_BUILD@
+PRODUCTVERSION @VERSION_MAJOR@,@VERSION_MINOR@,@VERSION_PATCH@,@VERSION_BUILD@
+FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+FILEFLAGS 0x0L
+FILEOS VOS__WINDOWS32
+FILETYPE VFT_APP
+FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "librats Project"
+            VALUE "FileDescription", "librats P2P Networking Library - Legitimate networking software"
+            VALUE "FileVersion", "@VERSION_STRING@"
+            VALUE "ProductName", "librats P2P Networking Library"
+            VALUE "ProductVersion", "@VERSION_STRING@"
+            VALUE "LegalCopyright", "Copyright (c) librats contributors - MIT License"
+            VALUE "OriginalFilename", "rats-client.exe"
+            VALUE "InternalName", "librats"
+            VALUE "Comments", "Open source peer-to-peer networking library implementing BitTorrent DHT, ICE/STUN NAT traversal, and secure encryption protocols (@GIT_DESCRIBE@)"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -56,13 +56,7 @@
     "scripts/**/*",
     "binding.gyp",
     "README.md",
-    "../src/**/*.cpp",
-    "../src/**/*.h",
-    "../src/**/*.in",
-    "../3rdparty/**/*",
-    "../CMakeLists.txt",
-    "../LICENSE",
-    "!../src/main.cpp"
+    "native-src/**/*"
   ],
   "gypfile": true
 }

package/scripts/build-librats.js

@@ -12,14 +12,47 @@ const isLinux = process.platform === 'linux';
 
 // Paths
 const nodejsRoot = path.resolve(__dirname, '..');
-const projectRoot = path.resolve(__dirname, '..', '..');
-const buildDir = path.resolve(nodejsRoot, 'build-native');  // Build dir inside nodejs/
-const srcDir = path.resolve(projectRoot, 'src');
-const cmakeLists = path.resolve(projectRoot, 'CMakeLists.txt');
+const buildDir = path.resolve(nodejsRoot, 'build-native');
+
+// Determine source location:
+// 1. When installed from npm: sources are in nodejs/native-src/
+// 2. When developing locally: sources are in project root (../../ from scripts)
+let projectRoot;
+let srcDir;
+let cmakeLists;
+
+const nativeSrcDir = path.resolve(nodejsRoot, 'native-src');
+const devProjectRoot = path.resolve(__dirname, '..', '..');
+
+if (fs.existsSync(path.join(nativeSrcDir, 'CMakeLists.txt'))) {
+    // npm install scenario: use native-src directory
+    projectRoot = nativeSrcDir;
+    srcDir = path.resolve(nativeSrcDir, 'src');
+    cmakeLists = path.resolve(nativeSrcDir, 'CMakeLists.txt');
+    console.log('Using bundled source files from native-src/');
+} else if (fs.existsSync(path.join(devProjectRoot, 'CMakeLists.txt'))) {
+    // Development scenario: use parent directory
+    projectRoot = devProjectRoot;
+    srcDir = path.resolve(devProjectRoot, 'src');
+    cmakeLists = path.resolve(devProjectRoot, 'CMakeLists.txt');
+    console.log('Using source files from project root (development mode)');
+} else {
+    console.error('ERROR: Cannot find librats source files.');
+    console.error('');
+    console.error('Checked locations:');
+    console.error(`  - ${nativeSrcDir} (npm install)`);
+    console.error(`  - ${devProjectRoot} (development)`);
+    console.error('');
+    console.error('If you installed from npm, the package may be corrupted.');
+    console.error('Try: npm cache clean --force && npm install librats');
+    console.error('');
+    console.error('If you are developing locally, make sure you are in the librats repository.');
+    process.exit(1);
+}
 
 console.log('Building librats native library...');
 console.log(`Platform: ${process.platform}`);
-console.log(`Project root: ${projectRoot}`);
+console.log(`Source root: ${projectRoot}`);
 console.log(`Build directory: ${buildDir}`);
 
 // Check if CMake is installed
@@ -46,17 +79,17 @@ try {
     process.exit(1);
 }
 
-// Check if CMakeLists.txt exists
+// Verify CMakeLists.txt exists
 if (!fs.existsSync(cmakeLists)) {
-    console.error('ERROR: CMakeLists.txt not found in project root.');
-    console.error('Make sure all source files are included in the npm package.');
+    console.error('ERROR: CMakeLists.txt not found.');
+    console.error(`Expected at: ${cmakeLists}`);
     process.exit(1);
 }
 
-// Check if src directory exists
+// Verify src directory exists
 if (!fs.existsSync(srcDir)) {
     console.error('ERROR: src directory not found.');
-    console.error('Make sure all source files are included in the npm package.');
+    console.error(`Expected at: ${srcDir}`);
     process.exit(1);
 }
 
@@ -64,6 +97,19 @@ if (!fs.existsSync(srcDir)) {
 if (!fs.existsSync(buildDir)) {
     console.log(`Creating build directory: ${buildDir}`);
     fs.mkdirSync(buildDir, { recursive: true });
+} else {
+    // Clear CMake cache if it exists to avoid source directory mismatch errors
+    const cmakeCache = path.join(buildDir, 'CMakeCache.txt');
+    if (fs.existsSync(cmakeCache)) {
+        console.log('Clearing existing CMake cache...');
+        fs.unlinkSync(cmakeCache);
+        
+        // Also remove CMakeFiles directory for a clean reconfigure
+        const cmakeFiles = path.join(buildDir, 'CMakeFiles');
+        if (fs.existsSync(cmakeFiles)) {
+            fs.rmSync(cmakeFiles, { recursive: true, force: true });
+        }
+    }
 }
 
 // Helper function to execute commands
@@ -121,7 +167,9 @@ try {
         cmakeArgs.push('-G "Unix Makefiles"');
     }
 
-    const cmakeConfigCmd = `cmake ${cmakeArgs.join(' ')} ../..`;
+    // Calculate the relative path from build directory to source root
+    const relativePath = path.relative(buildDir, projectRoot);
+    const cmakeConfigCmd = `cmake ${cmakeArgs.join(' ')} "${relativePath}"`;
     exec(cmakeConfigCmd);
 
     // Build the library
@@ -191,4 +239,3 @@ try {
     
     process.exit(1);
 }
-