ruby-fcp 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ba6b44aeaf59819305d4f97364ec8693595a876
+  data.tar.gz: 7bac921fc48e3ef3a2668b968b32c053a4ce0346
+SHA512:
+  metadata.gz: 573214e4b8d49f2438c2c5a327a4dd1fcd4f750647f98b4aab55a272a5724be12aa75a68c5bef14c60f867731e25a3ed74476f59774b5ca8bde246aa8bd14f6b
+  data.tar.gz: 64790ef14cc9a85ad2519ba7b68a53a91c0151a75b106a25e8b4d6e6335e397143d5d050d878026c31874bbc6416a7bca1ce6651ff57635816f135a7313d0e49

data/bin/fget

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'securerandom'
+require 'ruby-fcp'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: fput.rb [options]"
+  
+  opts.on("-u", "--uri URI",
+    "CHK@, USK@,SSK@") do |u|
+    options[:uri] = u
+  end
+  
+  opts.on("-p", "--path path",
+    "if this is directory make sure you specified -d option") do |p|
+    options[:path] = p
+  end
+  
+  opts.on("-s", "--server host:port",
+    "Must be a freenet client protocol server") do |s|
+    options[:server] = s
+  end
+  
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+if options.has_key? :uri and options.has_key? :path
+  
+  if options.has_key? :server
+    server = options[:server].chomp.lstrip.split(':')
+    client = FCPClient.new("fput-#{SecureRandom.hex}",server[0],server[1])
+  else
+    client = FCPClient.new("fput-#{SecureRandom.hex}")
+  end
+  
+  client.simple_get(options[:uri].chomp.lstrip,options[:path].chomp.chomp('/').lstrip)
+  client.close
+
+else
+ puts "-u and -p are mandatory type -h or --help for usage information"
+ exit
+end

data/bin/fput

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'securerandom'
+require 'pathname'
+require 'ruby-fcp/fcp_client'
+
+options = { index: 'index.html' }
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+  
+  opts.on("-u", "--uri URI",
+    "CHK@, USK@(requires insert uri),SSK@(requires inserturi)") do |u|
+    options[:uri] = u
+  end
+  opts.on("-p", "--path path",
+    "if this is directory make sure you specified -d option") do |p|
+    options[:path] = p
+  end
+  
+  opts.on("-i", "--index defaultfile",
+    "default file for directory uploads, I believe it defaults to index.html") do |i|
+    options[:index] = i
+  end
+  
+  opts.on("-s", "--server host:port",
+    "Must be a freenet client protocol server") do |s|
+    options[:server] = s
+  end
+  
+  opts.on("-d", "--directory", "You are uploading a directory") do |d|
+    options[:directory] = d
+  end
+  
+  opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+  end
+  
+end.parse!
+
+if options.has_key? :uri and options.has_key? :path
+  
+  if options.has_key? :server
+    server = options[:server].chomp.lstrip.split(':')
+    client = FCPClient.new("fput-#{SecureRandom.hex}",server[0],server[1])
+  else
+    client = FCPClient.new("fput-#{SecureRandom.hex}")
+  end
+  
+  if options[:directory]
+    client.simple_dir_put(options[:uri].chomp.lstrip,options[:path].chomp.chomp('/').lstrip,true,{"DefaultName" => options[:index]})
+  else
+    client.simple_put(options[:uri].chomp.lstrip,options[:path].chomp.lstrip)
+  end
+  client.close
+
+else
+ puts "-u and -p are mandatory type -h or --help for usage information"
+ exit
+end

data/lib/ruby-fcp/communicator.rb

@@ -0,0 +1,133 @@
+require 'socket'
+require 'thread'
+require 'ruby-fcp/utils'
+
+class Communicator 
+  attr_reader   :ConnectionIdentifier
+  attr_accessor :responses, :heartbeat
+  
+  def initialize(client,host, port, version = 2.0)
+    @utils = Utils.new
+    @version = version
+    @ConnectionIdentifier = ""
+    @host = host
+    @port = port
+    @client = client
+    @responses = { peers: [],dda: [], default: [], error: [], datalengths: [] }
+    @tex = Mutex.new
+    @state = false
+    @queue = Queue.new
+    @heartbeat = 300
+    connect
+  end
+ 
+  def connect
+    @sock = TCPSocket.new @host ,@port
+    @sock.write @utils.packet_mangler({"Name" => @client,"ExpectedVersion" => @version},"ClientHello")
+    response = grab_response
+    unless response[:state] == -1
+      @sock_thrd = Thread.new {sock_thrd}
+      @ConnectionIdentifier = response["ConnectionIdentifier"]
+      @state = true
+      keep_alive
+    end
+  end
+  
+  def sock_thrd
+    @threads = []
+    loop do
+      @threads.each do |thrd|
+        begin 
+          @threads.delete thrd if thrd.join(0.5)
+        rescue RequestFinished => req
+          @responses[:error].push req 
+        rescue Exception => excpt
+          puts "#{excpt}"
+          @threads.delete thrd 
+        end
+        if thrd.status == false
+          @threads.delete thrd 
+        elsif thrd.status == nil
+          @threads.delete thrd 
+        end
+      end
+      
+      @sock.close Thread.exit if @state == false
+      
+      begin
+        while packet = @queue.pop(true)
+          @tex.synchronize{@sock.write packet}
+          #sort_out(packet)
+        end
+      rescue ThreadError => err
+      end
+      
+      begin 
+        if select([@sock], nil,nil,2)
+          packet = @tex.synchronize{grab_response}
+          sort_out(packet)
+        end
+      rescue
+        @sock.close Thread.exit
+        state = false
+        connect
+      end
+    end
+  end
+  
+  def sort_out(packet)
+    if packet[:head].include? "NodeHello"
+      @ConnectionIdentifier = packet["ConnectionIdentifier"]
+    elsif packet[:head].include? "CloseConnectionDuplicateClientName"
+      @state = false
+    elsif packet.has_key? "Identifier"
+      if @responses.has_key? packet["Identifier"]
+        @responses[packet["Identifier"]].push packet
+      else
+        @responses[packet["Identifier"]] = [packet]
+      end
+    elsif packet[:head].include? "DDA"
+      @responses[:dda].push packet 
+    elsif packet[:state] == -1
+      @responses[:error].push packet
+    elsif packet[:head].include? "Peer"
+      @responses[:peers].push packet
+    else packet
+      @responses[:default].push packet
+    end
+  end
+  
+  def send_packet(message)
+    @queue.push message
+  end
+
+  def grab_response
+    response = { state: 1 }
+    line = @sock.readline
+    response[:state] = -1 if line =~ /ClosedConnectionDuplicateClientName|ProtocolError/
+    response[:head] = line.chomp
+    until line =~ /EndMessage|^Data$/
+      response[line.split('=')[0]] = line.split('=')[1].chomp if line.split('=').size == 2
+      line = @sock.readline
+    end
+    @responses[:datalengths] << response["DataLength"].to_i if response.has_key? "DataLength"
+    response[:data] = @sock.read @responses[:datalengths].pop if response[:head] =~ /AllData/
+    response
+  end
+  
+  def keep_alive
+    Thread.start do
+      loop do
+       send_packet "Void\nEndMessage\n"
+       sleep @heartbeat
+       break if @state == false
+      end
+    end
+  end
+  
+  def close
+    @tex.synchronize{@sock.write "Disconnect EndMessage\n"}
+    @sock.close
+  end
+  
+end

data/lib/ruby-fcp/fcp_client.rb

@@ -0,0 +1,290 @@
+# The simple interface to FCP from ruby
+# Implements raw fcp packets with sane defaults and automates some task
+
+require 'digest'
+require 'base64'
+require 'ruby-fcp/communicator'
+
+class FCPClient
+
+  attr_accessor :utils, :com
+
+  # clients name must be unique
+  # This performs NodeHello operations upon initialization.
+  # Communicator handles packet sending and recieving and sorting
+  def initialize(client, host = "127.0.0.1", port = 9481)
+    @utils = Utils.new
+    @com = Communicator.new(client,host,port)
+  end
+  
+  # Simple attribute reader for you ConnectionIdentifier
+  def identifier
+    @com.ConnectionIdentifier
+  end
+  
+  # Simple attribute reader to display all responses recieved
+  def responses
+    @com.responses
+  end
+
+  # return last response from request defined by Identifier
+  def last_response(id)
+    @com.responses[id].last
+  end
+
+  # Simple interface to put a single file onto freenet from your disk uses ClientPut message
+  # ==Possible values of uri:
+  # * CHK@ will generate and return the key your data is acessible at
+  # * SSK@ must have insert key provided by GenerateSSK or the method new_ssk_pair
+  # * KSK@filename
+  def simple_put(uri, filename, wait = true, opts = {})
+    id = @utils.id_generate
+    options = { "URI" => uri, "Identifier" => id, "UploadFrom" => 'disk', "Filename" => filename, "FileHash" => @utils.filehash_maker(id, filename,identifier) }.merge(opts)
+    @com.send_packet @utils.packet_mangler(options,"ClientPut")
+    #@com.fcpackets.client_put uri, id, options
+    if wait
+      wait_for id, /PutFailed|PutSuccessful/
+    else
+      id
+    end
+  end
+  
+  # Another interface to ClientPut that allows you to directly put data pnto freenet
+  # data is your data
+  # ==Possible values of uri:
+  # * CHK@ will generate and return the key your data is acessible at
+  # * SSK@ must have insert key provided by  GenerateSSK or the method new_ssk_pair
+  # * KSK@filename
+  def direct_put(uri,data, wait = true, opts = {})
+    id = @utils.id_generate
+    options = {"Identifier" => id, "URI" => uri ,"UploadFrom" =>  "direct", "DataLength" => data.bytesize }.merge(opts)
+    @com.send_packet @utils.packet_mangler(options,"ClientPut").sub! "EndMessage\n", "Data\n#{data}"
+    if wait
+      wait_for id,/PutFailed|PutSuccessful/
+    else
+      id
+    end
+  end
+  
+  # Simple directory upload, upload one directory all at once
+  # automates the TestDDA for you just provide uri and directory
+  # Implements ClientPutDiskDir
+  # * CHK@ will generate and return the key your data is acessible at
+  # * SSK@ must have insert key provided by  GenerateSSK or the method new_ssk_pair
+  # * KSK@filename
+  def simple_dir_put(uri, dir, wait = true, opts={})
+    id = @utils.id_generate
+    ddarun(dir,true,false)
+    options = {"Identifier" => id,"URI" => uri,"Filename" => dir, "Global" => 'true', "AllowUnreadableFiles" => 'true', "IncludeHiddenValues" => 'false'}.merge(opts)
+    @com.send_packet @utils.packet_mangler(options,"ClientPutDiskDir")
+    if wait
+      wait_for(id,/PutFailed|PutSuccessful/) 
+    else
+      id
+    end
+  end
+  
+  # simpler staight forward interface to ClientPutComplexDir, you provide with
+  # ==Possible values of uri:
+  # * CHK@ will generate and return the key your data is acessible at
+  # * SSK@ must have insert key provided by  GenerateSSK or the method new_ssk_pair
+  # * KSK@filename
+  # As well as a list of hashes for files you want to put
+  # ==File hashlist format:
+  # * name: lib/hello or index.html, / will interperate as directory nesting
+  # * filename: in case of disk location of file on disk
+  # * uploadfrom: 'direct', 'disk' or 'redirect'
+  # * targeturi: in case of redirect, the location your are redirecting to
+  # * mimetype: not needed, but can be helpful
+  # * data: only nessecery in direct mode
+  def put_complex_dir(uri, files, wait = true,opts = {})
+    dirs = []
+    id = @utils.id_generate
+    files.each{ |f| dirs << f[:filename].split('/')[0...-1].join('/') + '/' if f.has_key? :filename }
+    (dirs.uniq).each { |dir| ddarun(dir,true,false) }
+    options = {"URI" => uri, "Identifier" => id}.merge(opts)
+    files.each_with_index do |file, index|
+      options["Files.#{index}.Name"] = file[:name]
+      options["Files.#{index}.UploadFrom"] = file[:uploadfrom]
+      options["Files.#{index}.DataLength"] = file[:data].bytesize if file.has_key? :data
+      options["Files.#{index}.Filename"] = file[:filename] if file[:uploadfrom].include? 'disk'
+      options["Files.#{index}.TargetURI"] = file[:targeturi] if file[:uploadfrom].include? 'redirect'
+      options["Files.#{index}.Metadata.ContentType"] = file[:mimetype] if file.has_key? :mimetype
+    end
+    message = @utils.packet_mangler(options,"ClientPutComplexDir")
+    files.each { |f| message << f[:data] if f.has_key? :data}
+    puts message
+    @com.send_packet message
+    if wait
+     wait_for(id,/PutFailed|PutSuccessful/)  
+    else
+     id
+    end
+  end
+  
+  # performs TestDDARequest and TestDDAResponse automagically
+  # read and write are true or false values
+  def ddarun(directory,read, write)
+    @com.send_packet @utils.packet_mangler({"Directory" => directory,"WantReadDirectory" => read, "WantWriteDirectory" => write} ,"TestDDARequest")
+    res = wait_for(:dda, /TestDDAReply/).pop
+    content = nil
+    if write
+      f = File.open(res["WriteFilename"],'w+')
+      f.write res["ContentToWrite"]
+      f.close
+    elsif read
+      content = File.open(res["ReadFilename"],'r').read
+    end
+    @com.send_packet @utils.packet_mangler({"Directory" => directory,"ReadContent" => content}, "TestDDAResponse")
+    response = wait_for(:dda ,/TestDDAComplete/).pop
+    File.delete(res["WriteFilename"]) if write
+    response
+  end
+  
+  # just provide uri and download path/directory
+  # Implements ClientGet
+  def simple_get(uri,directory,wait = true, opts={})
+    id = @utils.id_generate
+    saveloc = File.join directory, uri.split('/')[-1]
+    ddarun(directory,false, true)
+    options = {"URI" => uri, "Identifier" => id, "ReturnType" => 'disk', "Filename" => saveloc, "TempFilename" => saveloc+".tmp" , "Persistence" => 'forever', "Global" => false, "Verbosity" => 1111111}.merge(opts)
+    @com.send_packet @utils.packet_mangler(options,"ClientGet")
+    if wait
+     wait_for(id,/GetFailed|DataFound/) 
+    else
+     id
+    end
+  end
+  
+  def direct_get(uri ,wait = true, opts={})
+    id = @utils.id_generate
+    options = {"URI" => uri, "Identifier" => id, "ReturnType" => 'direct', "Global" => false}.merge(opts)
+    @com.send_packet @utils.packet_mangler(options,"ClientGet")
+    if wait
+     wait_for(id,/AllData|GetFailed/) 
+    else
+     id
+    end
+  end
+  # returns information on plugin, must be full class name as listed in freenet interface
+  # Implements GetPluginInfo
+  def get_plugin_info(pluginname, detailed = false)
+    id = @utils.id_generate
+    @com.send_packet @utils.packet_mangler({"PluginName" => pluginname, "Identifier" => id, "Detailed" => detailed },"GetPluginInfo")
+    wait_for id, /PluginInfo/
+  end
+  
+  # Straigt forward, ListPeers, sometimes it may choke up and give you end list peers before your peers, in that case check the id
+  def listpeers
+    id = @utils.id_generate
+    @com.send_packet @utils.packet_mangler({"Identifier" => id, "WithMetaData" => true, "WithVolatile" => false},"ListPeers")
+    wait_for id, /EndListPeers/
+  end
+  
+  #Uses GenerateSSK
+  def new_ssk_pair
+    id = @utils.id_generate
+    @com.send_packet @utils.packet_mangler({"Identifier" => id}, "GenerateSSK")
+    wait_for id, /SSKKeypair/
+  end
+  
+  # returns information on a given peer not peers implements ListPeer
+  def peerinfo(peer)
+    @com.send_packet @utils.packet_mangler({"NodeIdentifier" => peer,"WithVolatile" => false,"WithMetadata" => true}, "ListPeer")
+    wait_for :peer, /Peer/
+  end
+  
+  # List all persistent request just implements ListPersistentRequest
+  def list_persistent_requests
+    @com.send_packet "ListPersistentRequests\nEndMessage\n"
+    wait_for :default ,/EndListPersistentRequests/
+  end
+  
+  def modify_persistent_request(id,clienttoken,priorityclass)
+    @com.send_packet @utils.packet_mangler({"Identifier" => id,"ClientToken" => clienttoken, "PriorityClass" => priorityclass}, "ModifyPersistentRequest")
+    wait_for id, /PersistentRequestModified/
+  end
+  
+  #subscirbe to a usk, have to poll it yourself by using responses[id]
+  def subscribe_usk(uri, wait=false ,opts ={})
+    id = @utils.id_generate
+    @com.send_packet @utils.packet_mangler({"URI" => uri, "Identifier" => id} ,"SubscribeUSK")
+    id
+  end
+  
+  def unsubscribe_usk(id)
+    @com.send_packet "UnsubscribeUSK\nIdentifier=#{id}\nEndMessage\n"
+    id
+  end
+  
+  def proberequest(type,hopstolive=25,wait = true)
+    id = @utils.id_generate
+    @com.send_packet @utils.packet_mangler({"Identifier" => id,"Type" => type,"HopsToLive" => hopstolive}, "ProbeRequest")
+    if wait
+      wait_for id,/Probe/
+    else
+     id
+    end
+  end
+  
+  # Waits for a specific pattern in a message identified by ID
+  def wait_for(id, pattern)
+    response = [ ]
+    loop do
+      begin
+      x = @com.responses[id].pop
+      print @com.responses[:error].pop
+      rescue
+      sleep(2)
+      end
+      unless x.nil?
+        if x[:head] =~ pattern
+          response << x
+          x.each { |key, value| puts "#{key}=#{value}" }
+          break
+        elsif x[:head] =~ /ProtocolError/
+          response << x
+          x.each { |key, value| puts "#{key}=#{value}" }
+          break
+        else
+          response << x
+          x.each { |key, value| puts "#{key}=#{value}" }
+        end
+      else
+        sleep(1)
+      end
+    end
+    response
+  end
+  
+  # Just wait and wait given a id
+  def wait_for_ever(id)
+    loop do
+      begin
+        x = @com.responses[id].pop
+      rescue
+        print '.'
+        sleep(2)
+        print @com.responses[:error]
+        print @com.responses[:default]
+      end
+      unless x.nil?
+        x.each { |key, value| puts "#{key}=#{value}" }
+      else
+        print '.'
+        sleep(1)
+        puts @com.responses[:error]
+        print @com.responses[:default]
+      end
+    end
+  end
+  
+  # Send disconnect message and close the socket
+  def close
+    @com.close
+  end
+  
+  def killswitch
+    @com.send_packet "Shutdown\nEndMessage\n"
+  end
+end

data/lib/ruby-fcp/utils.rb

@@ -0,0 +1,18 @@
+require 'securerandom'
+require 'digest'
+require 'base64'
+
+class Utils
+  def filehash_maker(ident,filename,conid)
+    content = File.read(filename)
+    (Digest::SHA256.new << conid + "-#{ident}-" + content).base64digest
+  end
+
+  def packet_mangler(sash,header)
+    header +"\n"+ sash.map{|k,v| "#{k}=#{v}"}.join("\n") + "\nEndMessage\n"
+  end
+  
+  def id_generate
+    SecureRandom.hex
+  end
+end

data/lib/ruby-fcp.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'socket'
+require 'digest'
+require 'base64'
+
+%w[ fcp_client communicator utils ].each do |file|
+ require "ruby-fcp/#{file}"
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: ruby-fcp
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- hikiko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-31 00:00:00.000000000 Z
+dependencies: []
+description: A gem interface for Freenet Client Protocol
+email: kerben@i2pmail.org
+executables:
+- fget
+- fput
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/fget
+- bin/fput
+- lib/ruby-fcp.rb
+- lib/ruby-fcp/communicator.rb
+- lib/ruby-fcp/fcp_client.rb
+- lib/ruby-fcp/utils.rb
+homepage: https://github.com/kerben/ruby-fcp
+licenses:
+- Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: FCPClient
+test_files: []
+has_rdoc: