Class: Net::FTPS::Implicit

Inherits:
Net::FTP
  • Object
show all
Defined in:
lib/net/ftps_implicit.rb

Constant Summary collapse

FTP_PORT = 
990

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(host = nil, user = nil, passwd = nil, acct = nil, verify_mode = OpenSSL::SSL::VERIFY_PEER) ⇒ Implicit

Returns a new instance of Implicit.



20
21
22
23
24
25
26
27
28
 
# File 'lib/net/ftps_implicit.rb', line 20

def initialize(host=nil, user=nil, passwd=nil, acct=nil, verify_mode=OpenSSL::SSL::VERIFY_PEER)
  super(host, user, passwd, acct)
  @passive = true
  @binary = false
  @debug_mode = true
  @data_protection = 'P'
  @data_protected = false
  @verify_mode = verify_mode
end

Instance Attribute Details

#data_protection ⇒ Object

Returns the value of attribute data_protection.



29
30
31
 
# File 'lib/net/ftps_implicit.rb', line 29

def data_protection
  @data_protection
end

Instance Method Details

#abort ⇒ Object 



67
68
69
 
# File 'lib/net/ftps_implicit.rb', line 67

def abort
  voidcmd("ABOR") rescue EOFError
end

#close ⇒ Object 



75
76
77
78
 
# File 'lib/net/ftps_implicit.rb', line 75

def close
  @sock.close # SSL
  @sock.io.close # TCP
end

#connect(host, port = FTP_PORT) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/net/ftps_implicit.rb', line 54

def connect(host, port=FTP_PORT)
  @sock = open_socket(host, port)
  mon_initialize
  getresp
  at_exit {
    if @sock && !@sock.closed?
      voidcmd("ABOR") rescue EOFError
      voidcmd("QUIT") rescue EOFError
      close
    end
  }
end

#get_data(sock, blocksize = 1024) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/net/ftps_implicit.rb', line 90

def get_data(sock,blocksize=1024)
  timeout = 10
  starttime = Time.now
  buffer = ''
  timeouts = 0
  catch :done do
    loop do
      event = select([sock],nil,nil,0.5)
      if event.nil? # nil would be a timeout, we'd do nothing and start loop over. Of course here we really have no timeout...
        timeouts += 0.5
        break if timeouts > timeout
      else
        event[0].each do |sock| # Iterate through all sockets that have pending activity
          if sock.eof? # Socket's been closed by the client
            throw :done
          else
            buffer << sock.readpartial(blocksize)
            if block_given? # we're in line-by-line mode
              lines = buffer.split(/\r?\n/)
              buffer = buffer =~ /\n$/ ? '' : lines.pop
              lines.each do |line|
                yield(line)
              end
            end
          end
        end
      end
    end
  end
  sock.close
  buffer
end

#quit ⇒ Object 



71
72
73
 
# File 'lib/net/ftps_implicit.rb', line 71

def quit
  voidcmd("QUIT") rescue EOFError
end

#retrbinary(cmd, blocksize, rest_offset = nil) ⇒ Object

:yield: data



80
81
82
83
84
85
86
87
88
 
# File 'lib/net/ftps_implicit.rb', line 80

def retrbinary(cmd, blocksize, rest_offset = nil) # :yield: data
  synchronize do
    voidcmd("TYPE I")
    conn = transfercmd(cmd, rest_offset)
    data = get_data(conn,blocksize)
    yield(data)
    voidresp
  end
end

#retrlines(cmd) ⇒ Object

:yield: line



123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/net/ftps_implicit.rb', line 123

def retrlines(cmd) # :yield: line
  synchronize do
    voidcmd("TYPE A")
    voidcmd("STRU F")
    voidcmd("MODE S")
    conn = transfercmd(cmd)
    get_data(conn) do |line|
      yield(line)
    end
    getresp
  end
end

#storbinary(cmd, file, blocksize, rest_offset = nil, &block) ⇒ Object

Puts the connection into binary (image) mode, issues the given server-side command (such as “STOR myfile”), and sends the contents of the file named file to the server. If the optional block is given, it also passes it the data, in chunks of blocksize characters.



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/net/ftps_implicit.rb', line 142

def storbinary(cmd, file, blocksize, rest_offset = nil, &block) # :yield: data
  if rest_offset
    file.seek(rest_offset, IO::SEEK_SET)
  end
  synchronize do
    voidcmd("TYPE I")
    conn = transfercmd(cmd, rest_offset)
    loop do
      buf = file.read(blocksize)
      break if buf == nil
      conn.write(buf)
      yield(buf) if block
    end
    conn.close # closes the SSL
    conn.io.close # closes the TCP below it
    voidresp
  end
end

#storlines(cmd, file, &block) ⇒ Object

Puts the connection into ASCII (text) mode, issues the given server-side command (such as “STOR myfile”), and sends the contents of the file named file to the server, one line at a time. If the optional block is given, it also passes it the lines.



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/net/ftps_implicit.rb', line 167

def storlines(cmd, file, &block) # :yield: line
  synchronize do
    voidcmd("TYPE A")
    conn = transfercmd(cmd)
    loop do
      buf = file.gets
      break if buf == nil
      if buf[-2, 2] != CRLF
        buf = buf.chomp + CRLF
      end
      conn.write(buf)
      yield(buf) if block
    end
    conn.close # closes the SSL
    conn.io.close # closes the TCP below it
    voidresp
  end
end