[ruby-core:79908] [Ruby trunk Bug#13280] net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size

[ruby-core:79908] [Ruby trunk Bug#13280] net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size

[markdblackwell01]

Issue #13280 has been reported by Mark D Blackwell.

----------------------------------------
Bug #13280: net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size
https://bugs.ruby-lang.org/issues/13280

* Author: Mark D Blackwell
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
I searched this issue list (for Descriptions including `ftp`), but didn't find this problem discussed.

Recently, in the process of developing a new program, I invoked `putbinaryfile` (in passive mode) on a large file (about 1.3 megabytes) without specifying its `blocksize` argument. Invariably, the server terminated the transfer about five seconds after its start. (BTW, this approximates the duration in which other FTP clients completely send this entire file—with my setup.)

Much smaller files transferred fine.

Eventually, using a test file of about 63 kilobytes, I discovered that if I specified a `blocksize` identical to the file length (in bytes), it worked. And the transfer failed when the `blocksize` was one byte smaller.

Now, I've added code (in my own program) in order to obtain the file size of every file I want to send, and set the `blocksize` argument to that size (exactly). (Except that, for empty files, I need to set it to `1`: otherwise it hangs.)

Since then, I've sent hundreds of files (many of which are approximately 1 or 2 megabytes in size) without experiencing this problem.

Why should I need to set the `blocksize` in this way? It seems undocumented, to say the least.

I'm on Windows 7 — and I'm using an old version of Ruby (for the moment). Nevertheless, (supposedly) this problem may still exist:

~~~
> ruby -v
ruby 2.2.4p230 (2015-12-16 revision 53155) [x64-mingw32]
~~~



-- 
https://bugs.ruby-lang.org/

[ruby-core:80119] [Ruby trunk Bug#13280][Assigned] net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size

[shyouhei]

Issue #13280 has been updated by Shyouhei Urabe.

Status changed from Open to Assigned
Assignee set to Shugo Maeda

----------------------------------------
Bug #13280: net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size
https://bugs.ruby-lang.org/issues/13280#change-63545

* Author: Mark D Blackwell
* Status: Assigned
* Priority: Normal
* Assignee: Shugo Maeda
* Target version: 
* ruby -v: 
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
I searched this issue list (for Descriptions including `ftp`), but didn't find this problem discussed.

Recently, in the process of developing a new program, I invoked `putbinaryfile` (in passive mode) on a large file (about 1.3 megabytes) without specifying its `blocksize` argument. Invariably, the server terminated the transfer about five seconds after its start. (BTW, this approximates the duration in which other FTP clients completely send this entire file—with my setup.)

Much smaller files transferred fine.

Eventually, using a test file of about 63 kilobytes, I discovered that if I specified a `blocksize` identical to the file length (in bytes), it worked. And the transfer failed when the `blocksize` was one byte smaller.

Now, I've added code (in my own program) in order to obtain the file size of every file I want to send, and set the `blocksize` argument to that size (exactly). (Except that, for empty files, I need to set it to `1`: otherwise it hangs.)

Since then, I've sent hundreds of files (many of which are approximately 1 or 2 megabytes in size) without experiencing this problem.

Why should I need to set the `blocksize` in this way? It seems undocumented, to say the least.

I'm on Windows 7 — and I'm using an old version of Ruby (for the moment). Nevertheless, (supposedly) this problem may still exist:

~~~
> ruby -v
ruby 2.2.4p230 (2015-12-16 revision 53155) [x64-mingw32]
~~~



-- 
https://bugs.ruby-lang.org/

[ruby-core:80148] [Ruby trunk Bug#13280] net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size

[shugo]

Issue #13280 has been updated by shugo (Shugo Maeda).


I couldn't reproduce the problem in any of 2.2.4p230 (x86_64-linux), 2.3.3p222 (x86_64-linux),
2.4.0p0 (x86_64-linux), and 2.3.3p222 (x64-mingw32).

Could you send us debug output by setting Net::FTP#debug_mode to true?
Make sure the output doesn't contain any sensitive information.


----------------------------------------
Bug #13280: net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size
https://bugs.ruby-lang.org/issues/13280#change-63577

* Author: MarkDBlackwell (Mark D Blackwell)
* Status: Assigned
* Priority: Normal
* Assignee: shugo (Shugo Maeda)
* Target version: 
* ruby -v: 
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
I searched this issue list (for Descriptions including `ftp`), but didn't find this problem discussed.

Recently, in the process of developing a new program, I invoked `putbinaryfile` (in passive mode) on a large file (about 1.3 megabytes) without specifying its `blocksize` argument. Invariably, the server terminated the transfer about five seconds after its start. (BTW, this approximates the duration in which other FTP clients completely send this entire file—with my setup.)

Much smaller files transferred fine.

Eventually, using a test file of about 63 kilobytes, I discovered that if I specified a `blocksize` identical to the file length (in bytes), it worked. And the transfer failed when the `blocksize` was one byte smaller.

Now, I've added code (in my own program) in order to obtain the file size of every file I want to send, and set the `blocksize` argument to that size (exactly). (Except that, for empty files, I need to set it to `1`: otherwise it hangs.)

Since then, I've sent hundreds of files (many of which are approximately 1 or 2 megabytes in size) without experiencing this problem.

Why should I need to set the `blocksize` in this way? It seems undocumented, to say the least.

I'm on Windows 7 — and I'm using an old version of Ruby (for the moment). Nevertheless, (supposedly) this problem may still exist:

~~~
> ruby -v
ruby 2.2.4p230 (2015-12-16 revision 53155) [x64-mingw32]
~~~



-- 
https://bugs.ruby-lang.org/

[ruby-core:81639] [Ruby trunk Bug#13280] net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size

[markdblackwell01]

Issue #13280 has been updated by MarkDBlackwell (Mark D Blackwell).


Just now, I returned to my client's site. I couldn't reproduce the problematic reported behavior, either.

Presumably, some system misconfiguration (such as, Ping packets being blocked somewhere by a firewall?) has since been corrected.

----------------------------------------
Bug #13280: net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size
https://bugs.ruby-lang.org/issues/13280#change-65334

* Author: MarkDBlackwell (Mark D Blackwell)
* Status: Assigned
* Priority: Normal
* Assignee: shugo (Shugo Maeda)
* Target version: 
* ruby -v: 
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
I searched this issue list (for Descriptions including `ftp`), but didn't find this problem discussed.

Recently, in the process of developing a new program, I invoked `putbinaryfile` (in passive mode) on a large file (about 1.3 megabytes) without specifying its `blocksize` argument. Invariably, the server terminated the transfer about five seconds after its start. (BTW, this approximates the duration in which other FTP clients completely send this entire file—with my setup.)

Much smaller files transferred fine.

Eventually, using a test file of about 63 kilobytes, I discovered that if I specified a `blocksize` identical to the file length (in bytes), it worked. And the transfer failed when the `blocksize` was one byte smaller.

Now, I've added code (in my own program) in order to obtain the file size of every file I want to send, and set the `blocksize` argument to that size (exactly). (Except that, for empty files, I need to set it to `1`: otherwise it hangs.)

Since then, I've sent hundreds of files (many of which are approximately 1 or 2 megabytes in size) without experiencing this problem.

Why should I need to set the `blocksize` in this way? It seems undocumented, to say the least.

I'm on Windows 7 — and I'm using an old version of Ruby (for the moment). Nevertheless, (supposedly) this problem may still exist:

~~~
> ruby -v
ruby 2.2.4p230 (2015-12-16 revision 53155) [x64-mingw32]
~~~



-- 
https://bugs.ruby-lang.org/

[ruby-core:82111] [Ruby trunk Bug#13280][Rejected] net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size

[shugo]

Issue #13280 has been updated by shugo (Shugo Maeda).

Status changed from Assigned to Rejected

MarkDBlackwell (Mark D Blackwell) wrote:
> Just now, I returned to my client's site. I couldn't reproduce the problematic reported behavior, either. (And the Windows and Ruby versions remain unchanged.)
> 
> Presumably, some system misconfiguration (such as, Ping packets being blocked somewhere by a firewall?) has since been corrected.

So I close this issue.  Thanks.


----------------------------------------
Bug #13280: net/ftp: Putbinaryfile (on Windows) requires blocksize equal to file size
https://bugs.ruby-lang.org/issues/13280#change-65852

* Author: MarkDBlackwell (Mark D Blackwell)
* Status: Rejected
* Priority: Normal
* Assignee: shugo (Shugo Maeda)
* Target version: 
* ruby -v: 
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
I searched this issue list (for Descriptions including `ftp`), but didn't find this problem discussed.

Recently, in the process of developing a new program, I invoked `putbinaryfile` (in passive mode) on a large file (about 1.3 megabytes) without specifying its `blocksize` argument. Invariably, the server terminated the transfer about five seconds after its start. (BTW, this approximates the duration in which other FTP clients completely send this entire file—with my setup.)

Much smaller files transferred fine.

Eventually, using a test file of about 63 kilobytes, I discovered that if I specified a `blocksize` identical to the file length (in bytes), it worked. And the transfer failed when the `blocksize` was one byte smaller.

Now, I've added code (in my own program) in order to obtain the file size of every file I want to send, and set the `blocksize` argument to that size (exactly). (Except that, for empty files, I need to set it to `1`: otherwise it hangs.)

Since then, I've sent hundreds of files (many of which are approximately 1 or 2 megabytes in size) without experiencing this problem.

Why should I need to set the `blocksize` in this way? It seems undocumented, to say the least.

I'm on Windows 7 — and I'm using an old version of Ruby (for the moment). Nevertheless, (supposedly) this problem may still exist:

~~~
> ruby -v
ruby 2.2.4p230 (2015-12-16 revision 53155) [x64-mingw32]
~~~



-- 
https://bugs.ruby-lang.org/