Description:
------------
As many have noted, the zip extension does not handle at all 
managing the 
various OS-dependent limits which govern the zipping process 
(max open 
file descriptors or max memory available).  Basically, the 
extension 
seems set up to fail unless the developer writes in basic 
error checking 
and control themselves.  However, options are not really 
available to the 
developer to handle these limits in an effective manner.  In 
our current 
situation, we need to be able to zip a virtually unlimited # 
of files and 
streams into one file.  While we can monitor limits and 
close and reopen 
the file to get around them, this is very taxing on the 
servers - when 
your storage is on NFS, and you tell the server to close a 
6GB zip file 
and then reopen it to continue, multiple times in one 
operation... this 
has actually brought my site to a standstill a couple times 
now and as 
such we are now considering switching the entire download 
facility to 
ruby, whose rubyzip extension does not require such drastic 
workarounds.

If you're not going to automatically handle limits like 
memory and file 
descriptors, please provide a function which allows us to 
flush changes 
to disk (as if a close were happening) while holding the zip 
file open 
for further changes.

This must be possible, otherwise no zip software in 
existence would be 
able to create such a large zip file without closing and 
reopening 
repeatedly (yet, they can - in fact, this PHP extension is 
the only zip 
software I know of with such limitations, even compared to 
other 
extensions for other languages).  It is very frustrating 
that PHP 
continues for so long to have these issues, even while 
offering a zip API 
that has so many other features (many of which, while I'm 
sure are well 
intentioned, aren't really nearly as important as a stable 
extension 
which does not regularly cause fatal errors or max out 
storage 
bandwidth).  Please throw us a bone and add just this one 
method so my 
poor server's NIC can struggle just a little less.