Usage: test.rb [OPTION]
-h,  --help               view help
-e                        encode String (default)
-d                        decode String
-p,  --pass=PASSWD  password

require 'getopts'
getopts('hed', 'help', 'p:', 'pass:')
p $OPT

#gem install getopt  -v 1.4.0
require "getopt/long"
opts = Getopt::Long.getopts(
  ["--help", "-h"],
  ["-e"],
  ["-d"],
  ["--pass", "-p", 0]
)
p opts

REQUIRED  = 0 # Argument is required if switch is provided.
BOOLEAN   = 1 # Value of argument is true if provided, false otherwise.
OPTIONAL  = 2 # Argument is optional if switch is provided.
INCREMENT = 3 # Argument is incremented by 1 each time the switch appears.

#test_s.rb
require 'TransferFile.rb'
require 'socket'

s = TCPServer.new(1088)
while true
  sock = s.accept()
  Thread.new() {
    printf "%s already conn!\n", sock
    begin
      tf = TransferFile.new()
      tf.file_client(sock,"./temp/")
      tf.incept
    rescue
      p $!
    end
    printf "%s close!\n", sock
  }
end

#test_c.rb
require 'TransferFile.rb'
require 'socket'

socket = TCPSocket.new('127.0.0.1', 1088)
file = "11.exe"
p file
begin
  tf = TransferFile.new()
  tf.file_server(socket, file)
  tf.send
rescue
  p $!
end

#
#TransferFile.rb
#

require 'timeout'
class TFSSocketWriteError < StandardError
end
class TFSReadFileInfoError < StandardError
end
class TFCSocketReadError < StandardError
end
class TFCReadHeaderError < StandardError
end
class TFCWriteFileError < StandardError
end

class TransferFile
  def initialize
    @socket = nil
    @file = nil
    @send_header = ''
    @call_header = {}
    @read_once_size = defined?(READ_ONCE_SIZE) ? READ_ONCE_SIZE : 102400
    @transfer_size = 0
    @sleep_sec = 0.05
    @sock_write_timeout_sec = 30
    @sock_read_timeout_sec = 30
  end

  #server
  def file_server(socket, file)
    @socket = socket
    @file = file
    begin
      @file_name = File.basename(@file)
      @file_size = File.size(@file)
      @file_mtime = File.mtime(@file)
    rescue
      raise TFSReadFileInfoError, format("read file info Err [%s]", $!)
    end
  end
  def defined_send_header_file()
    @send_header.concat(format("file-name: %s\r\n", @file_name))
    @send_header.concat(format("file-size: %s\r\n", @file_size))
    @send_header.concat(format("file-mtime: %s\r\n", @file_mtime))
    if @send_header.length < 1024
      @send_header.concat(" " * (1024 - @send_header.length))
    end
  end
  def send()
    #new thread sending
    sending = Thread.new() {
      defined_send_header_file()
      sock_write @send_header
      ###send for bytes
      #File.open(@file, "rb") do |f|
      #  @send_ok = false
      #  while not f.eof?
      #    sock_write f.read(@read_once_size)
      #    @transfer_size += @read_once_size
      #  end
      #end
      ###send for line
      @send_ok = false
      File.open(@file, "rb").each_line do |line|
        sock_write line
        @transfer_size += line.length
      end
      @send_ok = true
    }
    while true
      while not defined?(@send_ok)
        printf "\rtransfering initialize ..."
        sleep @sleep_sec
      end
      printf "\rtransfering[%s:%sbytes] %s%%", @file_name, @file_size, @transfer_size * 100 / (@file_size + 1)
      unless sending.status
        if @send_ok
          printf "\rtransfering[%s:%sbytes] 100%%", @file_name, @file_size
          printf " OK\n"
          return true
        else
          printf " ERR\n"
          return false
        end
      end
      sleep @sleep_sec
    end
  end
  def sock_write(data='')
    #p data
    begin
      timeout(@sock_write_timeout_sec) {@socket.write(data)}
    rescue
      raise TFSSocketWriteError, format("send data Err [%s]", $!)
    rescue TimeoutError
      raise TFSSocketWriteError, "timeout"
    end
  end

  #client
  def file_client(socket, dir='.')
    @socket = socket
    @dir = dir
  end
  def defined_file_info()
    resp = sock_readpartial(1024)
    raise TFCReadHeaderError, "read header Err" unless resp.length == 1024 and resp.count("\r\n")
    resp.each_line do |line|
      if line =~ /^(.*)+:[ ]?(.*)+$/
        @call_header[$1.strip] = $2.strip
      end
    end
    @file_name = @call_header["file-name"] || nil
    @file_size = @call_header["file-size"].to_i || nil
    raise TFCReadHeaderError, "defined file-name Err" unless @file_name
    raise TFCReadHeaderError, "defined file-size Err" unless @file_size
  end
  def incept()
    #new thread calling
    calling = Thread.new() {
      defined_file_info()
      begin
        f = File.new(@dir + '/' + @file_name, "wb+")
      rescue
        raise TFCWriteFileError, format("create file Err [%s]", $!)
      end
      @transfer_ok = false
      while true
        resp = sock_readpartial @read_once_size
        break if resp.empty?
        f.write resp
        f.flush
        @transfer_size = File.size(f)
      end
      if File.size(f) == @file_size
        f.close
        @transfer_ok = true
      else
        File.delete(f)
      end
    }
    while true
      while not defined?(@transfer_ok)
        printf "\rtransfering initialize ..."
        sleep @sleep_sec
      end
      printf "\rtransfering[%s:%sbytes] %s%%", @file_name, @file_size, @transfer_size * 100 / (@file_size + 1)
      unless calling.status
        if @transfer_ok
          printf "\rtransfering[%s:%sbytes] 100%%", @file_name, @file_size
          printf " OK\n"
          return true
        else
          printf " ERR\n"
          return false
        end
      end
      sleep @sleep_sec
    end
  end

  def sock_readpartial(len=1024)
    begin
      if @socket.eof?
        ''
      else
        resp = timeout(@sock_read_timeout_sec) {@socket.readpartial(len)}
        resp
      end
    rescue
      raise TFCSocketReadError, format("incept data Err [%s]", $!)
    end
  end
end

#Example:
require 'SMTPTLS'

host = 'smtp.gmail.com'
port = 25
user = 'vkill.net@gmail.com'
secret = '*******'
to = []
to << '122755990@qq.com'
to << 'vkill.net@hotmail.com'

msgstr = <<-MSGEND
From: "vkill.net" <vkill.net@gmail.com>
To: 122755990@qq.com
Subject: test,sendmail
Date: Thu, 16 Jul 2009 18:35:03 +0800
MIME-Version: 1.0
Content-Type: multipart/mixed;
    boundary="===ruby-vkmailsend[0.3919741430011]==="
X-mailer: ruby-vkmailsend [cn]

--===ruby-vkmailsend[0.3919741430011]===
Content-Type: text/plain;
    charset="gb2312"
Content-Transfer-Encoding: base64

dGVzdA==

--===ruby-vkmailsend[0.3919741430011]===--
MSGEND

begin
  smtp = SMTPTLS.new()
  smtp.set_debug_output
  #smtp.enable_ssl()
  smtp.start(host, 25, user, secret)
  smtp.send_message(msgstr, user, to) #smtp.send_message(msgstr, user) ##send mail to me
  puts "send mail ok!" if smtp.state
rescue
  if $!.message =~ /\[([^\]]+)\]/
    printf "ERR->[%s]\n", $1
  else
    printf "ERR->[%s]\n", $!.message
  end
end

require 'highline/import'
def getpass(msg="Enter password:")
  ask(msg,String) {|p| p.echo = false}
end

##Usage:
while true
  printf "please enter password: "
  if (pass = getpass('')) !~ /^$/
    break
  else
    next
  end
end
printf "your password is: %s",pass

#!/usr/bin/env ruby
#
# ruby Download progress 2
# by:vkill     last change:28/6/2009
# Usage: *.rb http://xxx.net/xxx.xxx
#
require 'socket'
require 'uri'

RECV_DATA_LEN = 1024
have_read = 0
url = ($*[0]||"http://avira.vkill.net/upd/vdf/antivir3.vdf.gz")

u = URI.parse(url)
fileName = File.basename(u.path)

begin
  $s = TCPsocket.new(u.host,u.port)
rescue
  puts "create socket Err, #{$!}"
  exit
end

downing = Thread.new {
  header = {"User-Agent" => "antivir-ruby"}
  req = "GET "+url+" HTTP/1.0\r\n"
  header.each do |k,v|
    req += k+":"+v+"\r\n"
  end
  begin
    $s.write(req+"\r\n")
  rescue
    puts "download file Err, #{$!}"
    self.kill
  end
}

while downing.status == "run" or downing.status == "sleep" do
  #read header
  $s.recv(1024).each_line do |d|
    if $dataStart
      have_read += d.length
      $f.write(d)
      next
    end
    if (/^HTTP\//i =~ d) != nil
      $statu = d.split(" ")[1]
      if not /^(200)$/ =~ $statu
        puts "download file Err, statu #{$statu}"
        downing.kill
        exit
      end
      next
    end
    if (/^Content-Length:[\t ]*[\d]+[\r\n]*$/i =~ d) != nil
      $totalLength = d.gsub(/.*:[\t ]*/,"").to_i
      next
    end
    if (/^[\r\n]*$/ =~ d) != nil
      $dataStart = true
      $f = File.new(fileName, "wb+")
      next
    end
  end
  if not $dataStart
    puts "download file Err, parser httpHeader error"
    downing.kill
    exit
  end
  $totalLength ||= 1

  #read data
  while true
    printf "\rdowning #{fileName}...[#{$totalLength}bytes] #{(have_read*100) / $totalLength}%"
    begin
      resp = $s.recv(RECV_DATA_LEN)
    rescue
      puts "download file Err, #{$!}"
      downing.kill
      exit
    end
    if resp == ""
      printf "\rdowning #{fileName}...[#{$totalLength}bytes] 100%\n"
      break
    end
    have_read += resp.length
    $f.write(resp)
  end
end

$f.close()

case downing.status
  when false
    puts "downing normally quit"
  when nil
    puts "downing unnormally quit"
  else
    puts "downing nuknow quit"
end

import socket

READ_ONCE_SIZE = 512
have_read = 0

fd = open("c:\\test.rar", "wb")

s = socket.socket()
s.connect(("blog.vkill.net", 80))
s.sendall("GET http://blog.vkill.net/attachment/1221875343_6600827a.rar HTTP/1.0\n\n")


content = s.recv(READ_ONCE_SIZE)

while True:
    start = 0;
    start = content.find('\n')
    if content[start+1] == '\n':
        content = content[start+2:]
        break;
    if content[start+1] == '\r' and content[start+2] == '\n':
        content = content[start+3:]
        break;
    if content.startswith("Content-Length"):
        totalLength = int(content[:start].split()[1])
    content = content[start+1:]
            
have_read += len(content)

fd.write(content)

while True:
    print "\rtest.rar.....%d\t\t%5d%%" % (totalLength, have_read*100/totalLength),
    content = s.recv(READ_ONCE_SIZE)
    if not content:
        print "\rtest.rar.....%d\t\t%5d%%\n" % (totalLength, 100),
        break
    fd.write(content)
    have_read += len(content)

fd.close()

#!/usr/bin/env ruby
#
# ruby Download progress
# by:vkill 23/6/2009
#
require 'net/http'
require 'uri'

url = "http://127.0.0.1/upd/vdf/antivir3.vdf.gz"
u = URI.parse(url)
fileName = File.basename(u.path)
http = Net::HTTP.new(u.host,u.port)
req = Net::HTTP::Head.new(u.path)
resp = http.request(req)
totalLenght = resp["Content-Length"].to_i
partLenght = 20480

if totalLenght > 10240000
  puts "request downing file size GTR 10M, program quit!!!"
  exit
end

downing = Thread.new {
  $transLenght = 0
  $data = ""
  while $transLenght <= totalLenght do
    lenghts = $transLenght
    lenghte = $transLenght + partLenght - 1
    lenghte = totalLenght if lenghte > totalLenght
    header = {"Range" => "bytes=#{lenghts}-#{lenghte}"}
    req = Net::HTTP::Get.new(u.path,header)
    if (resp = http.request(req) rescue false) == false
      self.kill
    else
      $transLenght += partLenght
      $data = $data.concat(resp.body)
    end
  end
}

while downing.status == "run" or downing.status == "sleep" do
  printf "\rdowning #{fileName}...[#{totalLenght}bytes] #{$transLenght/(totalLenght/100)}%"
  sleep 0.5
end

if totalLenght == $data.size
  printf "\rdowning #{fileName}...[#{totalLenght}bytes] 100%\n"
  f = File.new(fileName,"wb+")
  f << $data
  f.flush
  f.close
else
  printf "...Err\n"
end

case downing.status
  when false
    puts "downing normally quit"
  when nil
    puts "downing unnormally quit"
  else
    puts "downing nuknow quit"
end