Exemplo n.º 1
0
//
// Constructor
//
SSLSocket::SSLSocket(const InetAddress& address, in_port_t port, SSLContext* context)
  throw(IOException, SystemException)
  : Socket(address, port), _context(context), _session(NULL)
{
  // TODO: check if context is != NULL

  /* Connect the SSL socket */
  _ssl  = SSL_new(_context->_ctx);
  _sbio = BIO_new_socket(_impl->_fd, BIO_NOCLOSE);
  SSL_set_bio(_ssl, _sbio, _sbio);

  //SSL_set_connect_state(_ssl);

  // Verify certificate
  if (SSL_get_verify_result(_ssl) != X509_V_OK) {
    throw IOException("SSLSocket: Certificate doesn't verified");
  }

  _session_creation = true;
  _use_client_mode = true;
}
// Close the file handle.
void FileHandleImplUNIX::close()
{
   vprDEBUG(vprDBG_ALL, vprDBG_VERB_LVL)
      << "[vpr::FileHandleImplUNIX::close()] Closing file descriptor "
      << mFdesc << std::endl << vprDEBUG_FLUSH;

   if ( ::close(mFdesc) == -1 )
   {
      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
         << "[vpr::FileHandleImplUNIX::close()] Could not close " << mName
         << ": " << strerror(errno) << std::endl << vprDEBUG_FLUSH;

      throw IOException("[vpr::FileHandleImplUNIX::close()] Could not close "
         + mName + ": " + std::string(strerror(errno)), VPR_LOCATION);
   }
   else
   {
      mFdesc = -1;
      mOpen  = false;
   }
}
// Open the file handle.
void FileHandleImplUNIX::open()
{
   int open_flags(mOpenMode);

   if ( ! mOpenBlocking )
   {
      open_flags |= O_NONBLOCK;
   }

   mFdesc = ::open(mName.c_str(), open_flags);

   // If the file handle was not returned successfully, print an error
   // message explaining why.
   if ( mFdesc == -1 )
   {
      // If we are opening in non-blocking mode, we do not want to bomb out.
      if ( errno == EWOULDBLOCK && ! mOpenBlocking )
      {
         mOpen = true;
         throw WouldBlockException("Would block.", VPR_LOCATION);
      }
      // Otherwise, report the error.
      else
      {
         mOpen = false;
         vprDEBUG(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
            << "[vpr::FileHandleImplUNIX::open()] Could not open " << mName
            << ": " << strerror(errno) << std::endl << vprDEBUG_FLUSH;

         throw IOException("[vpr::FileHandleImplUNIX::open()] Could not open "
            + mName + ": " + std::string(strerror(errno)), VPR_LOCATION);
      }
   }
   // Otherwise, set mOpen to true.
   else
   {
      mOpen     = true;
      mBlocking = mOpenBlocking;
   }
}
Exemplo n.º 4
0
void
NoSeekFile::fill_cache(std::streamsize size)
{
#ifdef GNASH_NOSEEK_FD_VERBOSE
    std::cerr << boost::format(" fill_cache(%d) called") % size << std::endl;
#endif

    assert(size >= 0);

    // See how big is the cache
    while (_cached < static_cast<size_t>(size)) {

#ifdef GNASH_NOSEEK_FD_VERBOSE
        size_t bytesNeeded = size - _cached;
        bytesNeeded = std::min<size_t>(bytesNeeded, chunkSize);
        std::cerr << boost::format(" bytes needed = %d") % bytesNeeded <<
            std::endl;
#endif

        std::streamsize bytesRead = ::read(_fd, _buf, chunkSize);
        if (bytesRead < 0) {
            std::cerr << boost::format(_("Error reading %d bytes from "
                        "input stream")) % chunkSize << std::endl;
            _running = false;
            // this looks like a CRITICAL error (since we don't handle it..)
            throw IOException("Error reading from input stream");
        }

        if (bytesRead < chunkSize) {
            if (bytesRead == 0) {
#ifdef GNASH_NOSEEK_FD_VERBOSE
                std::cerr << "EOF reached" << std::endl;
#endif
                _running = false;
                return;
            }
        }
        cache(_buf, bytesRead);
    }
}
StringSet SourceHighlightUtils::getFileNames(const std::string path,
        const std::string fileExtension) {
    StringSet strings;

    DIR *dp;
    struct dirent *ep;

    dp = opendir(path.c_str());
    if (dp != NULL) {
        while ((ep = readdir(dp))) {
            const string name(ep->d_name);
            if (get_file_extension(name) == fileExtension) {
                strings.insert(name);
            }
        }
        (void) closedir(dp);
    } else {
        throw IOException("Couldn't open the directory", path);
    }

    return strings;
}
Exemplo n.º 6
0
void MemoryStream::Seek(sint64 offset, sint32 origin)
{
    uint64 newPosition;
    switch (origin) {
    default:
    case STREAM_SEEK_BEGIN:
        newPosition = offset;
        break;
    case STREAM_SEEK_CURRENT:
        newPosition = GetPosition() + offset;
        break;
    case STREAM_SEEK_END:
        newPosition = _dataSize + offset;
        break;
    }

    if (newPosition > _dataSize)
    {
        throw IOException("New position out of bounds.");
    }
    _position = (void*)((uintptr_t)_data + (uintptr_t)newPosition);
}
Exemplo n.º 7
0
void BinTreeNodeReader::fillArray(QByteArray& buffer, quint32 len)
{
    char data[1025];

    buffer.clear();

    // bool ready = true;

    /*
    if (socket->bytesAvailable() < 1)
    {
        Utilities::logData("fillArray() waiting for bytes");
        ready = socket->waitForReadyRead(READ_TIMEOUT);
    }

    if (!ready)
    {
        Utilities::logData("fillArray() not ready / timed out");
        throw IOException(socket->error());
    }
    */

    int needToRead = len;
    while (needToRead > 0)
    {
        int bytesRead = socket->read(data,(needToRead > 1024) ? 1024 : needToRead);

        if (bytesRead < 0)
            throw IOException(socket->error());
        if (bytesRead == 0)
            // socket->waitForReadyRead(READ_TIMEOUT);
            qApp->processEvents();
        else
        {
            needToRead -= bytesRead;
            buffer.append(data,bytesRead);
        }
    }
}
Exemplo n.º 8
0
CDEC_NS_BEGIN
// -------------------------------------------------------------------------- //

#if !defined(X_OS_WINDOWS)

#include <unistd.h>
#include <fcntl.h>

void FileWrapper::Open(PCWSTR path, AccessMode access, ShareMode share, bool fCreate)
{
	ASSERT(!IsOpen() && path != NULL && *path != 0);

	size_t len = wstrlen16(path);
	std::string patha = cdec::Encoding::get_Default()->FromUnicode(path, len);

	int oflag = 0;
	switch (access)
	{
	case AccessMode::AccessRead:
		oflag |= O_RDONLY;
		break;
	case AccessMode::AccessWrite:
		oflag |= O_WRONLY;
		break;
	case AccessMode::AccessReadWrite:
		oflag |= O_RDWR;
		break;
	default:
		cdec_throw(IOException(EC_InvalidArg));
	}

	if (fCreate)
		m_fd = open(patha.c_str(), oflag | O_CREAT, S_IRWXU);
	else
		m_fd = open(patha.c_str(), oflag);

	if (m_fd == -1)
		cdec_throw_stdc_lasterr(IOException);
}
Exemplo n.º 9
0
qint64 BgzfReader::read(char *buff, qint64 maxSize) {
    if(0 == maxSize) {
        return 0;
    }
    stream.next_out = (Bytef *)buff;
    stream.avail_out = maxSize;
    while(stream.avail_out > 0) {
        if(0 == stream.avail_in) {
            qint64 returnedValue = ioAdapter.readBlock(buffer, sizeof(buffer));
            if(-1 == returnedValue) {
                coreLog.error(QString("in BgzfReader::read, failed to read %1 bytes from ioAdapter, after %2 bytes already read. %3")
                              .arg(sizeof(buffer))
                              .arg(ioAdapter.bytesRead())
                              .arg(ioAdapter.errorString()));
                throw IOException(BAMDbiPlugin::tr("Can't read input"));
            } else if(0 == returnedValue) {
                endOfFile = true;
                break;
            } else {
                stream.avail_in = returnedValue;
                stream.next_in = (Bytef *)buffer;
            }
        }
        int returnedValue = inflate(&stream, Z_SYNC_FLUSH);
        if(Z_STREAM_END == returnedValue) {
            nextBlock();
        } else if(Z_OK != returnedValue) {
            coreLog.error(QString("in BgzfReader::read, failed to decompress %1 bytes, after %2 raw bytes already read")
                          .arg(sizeof(buffer))
                          .arg(ioAdapter.bytesRead()));
            throw InvalidFormatException(BAMDbiPlugin::tr("Can't decompress data"));
        }
    }
    if(0 == stream.avail_in) {
        nextBlock();
    }
    qint64 bytesRead = maxSize - stream.avail_out;
    return bytesRead;
}
Exemplo n.º 10
0
std::vector<std::vector<unsigned char> > SerialThrustMasterBase::read() {
    std::vector<std::vector<unsigned char> > results;

    int availableBytes;
    if (ioctl(handle, FIONREAD, &availableBytes) == -1) {
        throw IOException("Failed to get number of bytes available for " + name + ": " + std::strerror(errno));
    }

    // If a full packet is available or a timeout has occurred, process all available data.
    if (availableBytes >= 9 || getTime() > timeout) {
        int remainingBytes = availableBytes;
        std::vector<unsigned char> buffer(remainingBytes);

        /**
         * While we know how many bytes are avialable, read can still be interrupted by signals,
         * so call it in a loop.
         */
        while (remainingBytes) {
            remainingBytes -= SerialDevice::read(&buffer[0] + (availableBytes - remainingBytes), remainingBytes);
        }

        /**
         * Only return the data to the caller if exactly one full packet arrived. If a timeout
         * occurred or extra bytes arrived, discard all of the data.
         */
        if (availableBytes == 9) {
            results.push_back(buffer);
        }

        /**
         * Request the next state update from the device. Sending requests too quickly can corrupt
         * the device's output, so we only send a new request when at least a full packet has
         * arrived or a timeout occured.
         */
        requestData();
    }

    return results;
}
Exemplo n.º 11
0
void
Thread::StartNonDetachedWithCleanup()
{
    if(! runnable_)
    {
        LOG_ERROR("Null runnable, Thread already started??");
        throw fungi::IOException("Thread already started");
    }


    ManagedRunnable* wrapper = new ManagedRunnable(*runnable_, true);
    runnable_ = 0;
    int res = pthread_create(&thread_,
                             &attr_,
                             thread_start_util_,
                             wrapper);

    if (res != 0) {
        throw IOException("Thread::start", "pthread_create", res);
    }

}
Exemplo n.º 12
0
void DownloadOperation::onDownloadReply()
{

  if (m_fos != NULL) {
    try { m_fos->close(); } catch (...) { }
    delete m_fos;
  }
  if (m_file != NULL) {
    delete m_file;
  }

  m_file = new File(m_pathToTargetFile.getString());

  if (m_fileOffset == 0) {
    m_file->truncate();
  }

  try {
    m_fos = new FileOutputStream(m_file);

    FileSeeker fileSeeker(m_fos->getFD());
    if (!fileSeeker.seek((INT64)m_fileOffset)) {
      throw IOException(_T("Cannot seek to initial file position"));
    }

    m_totalBytesCopied += m_fileOffset;
  } catch (IOException &ioEx) {
    notifyFailedToDownload(ioEx.getMessage());
    gotoNext();
    return ;
  }

  UINT32 dataSize = 1024 * 8;
  bool compression = m_replyBuffer->isCompressionSupported();

  m_sender->sendDownloadDataRequest(dataSize,
                                    compression);
}
Exemplo n.º 13
0
void FileOutputStream::open(const String fileName, bool append)
{
    Locker locker(m_mutex);

    if (m_fileDescriptor != -1)
    {
        close();
    }

    // Write access, create if needed
    int flags = O_WRONLY | O_CREAT;

    // Support large files if the OS supports it
#ifdef O_LARGEFILE
    flags |= O_LARGEFILE;
#endif

    // If passed in append, mask on the append option,
    // otherwise truncate the file
    if (append)
    {
        flags |= O_APPEND;
    }
    else
    {
        flags |= O_TRUNC;
    }

    m_fileDescriptor = UnixUtil::sys_open(fileName.c_str(), // File name
                                          flags, // Creation flags, see above
                                          0666); // File mask if created

    if (m_fileDescriptor == -1)
    {
        throw IOException(String("Failed to open file: ") +
                          UnixUtil::getLastErrorMessage());
    }
}
Exemplo n.º 14
0
void
Thread::StartWithoutCleanup()
{

    if(! runnable_)
    {
        LOG_ERROR("Null runnable, Thread already started??");
        throw fungi::IOException("Thread already started");
    }

    std::pair<Runnable*, Thread*>* pa= new std::pair<Runnable*, Thread*>(runnable_, this);
    runnable_ = 0;
    int res = pthread_create(&thread_,
                             &attr_,
                             &::second_thread_start_util,
                             pa);

    if (res != 0) {
        throw IOException("Thread::start", "pthread_create", res);
    }


}
vpr::Uint32 SerialPortImplWin32::write_i(const void* buffer,
                                         const vpr::Uint32 length,
                                         const vpr::Interval& timeout)
{
   unsigned long bytes;

   if ( vpr::Interval::NoTimeout != timeout )
   {
      vprDEBUG(vprDBG_ALL,vprDBG_WARNING_LVL)
         << "[vpr::SerialPortImplWin32::write_i()] Timeout not supported\n"
         << vprDEBUG_FLUSH;
   }

   if ( ! WriteFile(mHandle, buffer, length, &bytes, NULL) )
   {
      std::stringstream msg_stream;
      msg_stream << "Failed to write to serial port " << mName << ": "
                 << getErrorMessageWithCode(GetLastError());
      throw IOException(msg_stream.str(), VPR_LOCATION);
   }

   return bytes;
}
Exemplo n.º 16
0
DeflatingStreamBuf::DeflatingStreamBuf(std::ostream& ostr, StreamType type, int level): 
	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::out),
	_pIstr(0),
	_pOstr(&ostr),
	_eof(false)
{
	_zstr.zalloc    = Z_NULL;
	_zstr.zfree     = Z_NULL;
	_zstr.opaque    = Z_NULL;
	_zstr.next_in   = 0;
	_zstr.avail_in  = 0;
	_zstr.next_out  = 0;
	_zstr.avail_out = 0;

	_buffer = new char[DEFLATE_BUFFER_SIZE];

	int rc = deflateInit2(&_zstr, level, Z_DEFLATED, 15 + (type == STREAM_GZIP ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
	if (rc != Z_OK) 
	{
		delete [] _buffer;
		throw IOException(zError(rc)); 
	}
}
Exemplo n.º 17
0
int SerialChannelImpl::writeImpl(const std::string& data)
{
	if (0 == data.length()) return 0;

	std::string d = data;

	if (_config.getUseEOFImpl()) 
	{
		size_t pos = d.find(_config.getEOFCharImpl());
		if (pos != d.npos) d = d.substr(0, pos+1);
	}

	DWORD written = 0;
	DWORD length = static_cast<DWORD>(d.length());

	if (!WriteFile(_handle, d.data(), length, &written, NULL) || 
		((written != length) && (0 != written)))
		handleError(_name);
	else if (0 == written)
		throw IOException("Error writing to " + _name);

	return written;
}
Exemplo n.º 18
0
ByteArray TCPSocket::read(size_t maxSize)
{
    ByteArray ba(maxSize);

    // Return empty array if size is 0
    if (maxSize == 0)
    {
        return ba;
    }

    // Read from socket
    ssize_t size = ::read(d->fd, ba.data(), ba.size());

    // Check for errors
    if (size < 0)
    {
        switch (errno)
        {
        case EAGAIN:
        case ETIMEDOUT:
            throw TimeoutException("TCPSocket::read", strerror(errno));
        case EPIPE:
            throw DisconnectedException("TCPSocket::read", strerror(errno));
        default:
            throw IOException("TCPSocket::read", strerror(errno));
        }
    }

    // If size is 0, means the socket is disconnected
    if (size == 0)
    {
        throw DisconnectedException("TCPSocket::read", "Disconnected");
    }

    // Return a byte-array of the actual read size
    return ByteArray(ba.constData(), size);
}
Exemplo n.º 19
0
vector<string>
resolveHostname(const string &hostname, unsigned int port, bool shuffle) {
	string portString = toString(port);
	struct addrinfo hints, *res, *current;
	vector<string> result;
	int ret;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family   = PF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	ret = getaddrinfo(hostname.c_str(), (port == 0) ? NULL : portString.c_str(),
		&hints, &res);
	if (ret != 0) {
		throw IOException(string("Error resolving ") + hostname + ": "
			+ gai_strerror(ret));
	}

	for (current = res; current != NULL; current = current->ai_next) {
		char host[NI_MAXHOST];

		ret = getnameinfo(current->ai_addr, current->ai_addrlen,
			host, sizeof(host) - 1,
			NULL, 0,
			NI_NUMERICHOST);
		if (ret == 0) {
			result.push_back(host);
		} else {
			P_WARN("Cannot get name info for one of the resolved "
				"IP addresses in host name " << hostname);
		}
	}
	freeaddrinfo(res);
	if (shuffle) {
		random_shuffle(result.begin(), result.end());
	}
	return result;
}
// Get the character size (the bits per byte).
vpr::SerialTypes::CharacterSizeOption SerialPortImplWin32::getCharacterSize()
   const
{
   vpr::SerialTypes::CharacterSizeOption size;

   DCB dcb;
   if ( GetCommState(mHandle, &dcb) )
   {
      switch ( dcb.ByteSize )
      {
         case 5:
            size = vpr::SerialTypes::CS_BITS_5;
            break;
         case 6:
            size = vpr::SerialTypes::CS_BITS_6;
            break;
         case 7:
            size = vpr::SerialTypes::CS_BITS_7;
            break;
         case 8:
            size = vpr::SerialTypes::CS_BITS_8;
            break;
      }
   }
   else
   {
      std::stringstream msg_stream;
      msg_stream << "Failed to acquire bits/byte: "
                 << getErrorMessageWithCode(GetLastError());
      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
         << clrOutBOLD(clrYELLOW, "WARNING") << ": " << msg_stream.str()
         << std::endl << vprDEBUG_FLUSH;
      throw IOException(msg_stream.str(), VPR_LOCATION);
   }

   return size;
}
Exemplo n.º 21
0
void FileImpl::handleLastErrorImpl(const std::string& path)
{
	switch (errno)
	{
	case EIO:
		throw IOException(path, errno);
	case EPERM:
		throw FileAccessDeniedException("insufficient permissions", path, errno);
	case EACCES:
		throw FileAccessDeniedException(path, errno);
	case ENOENT:
		throw FileNotFoundException(path, errno);
	case ENOTDIR:
		throw OpenFileException("not a directory", path, errno);
	case EISDIR:
		throw OpenFileException("not a file", path, errno);
	case EROFS:
		throw FileReadOnlyException(path, errno);
	case EEXIST:
		throw FileExistsException(path, errno);
	case ENOSPC:
		throw FileException("no space left on device", path, errno);
	case EDQUOT:
		throw FileException("disk quota exceeded", path, errno);
#if !defined(_AIX)
	case ENOTEMPTY:
		throw FileException("directory not empty", path, errno);
#endif
	case ENAMETOOLONG:
		throw PathSyntaxException(path, errno);
	case ENFILE:
	case EMFILE:
		throw FileException("too many open files", path, errno);
	default:
		throw FileException(std::strerror(errno), path, errno);
	}
}
Exemplo n.º 22
0
void TCPSocket::flush()
{
    size_t sent = 0;
    while (sent < d->sendbuf.size())
    {
        ssize_t size = ::write(d->fd, d->sendbuf.data(), d->sendbuf.size());

        if (size < 0)
        {
            switch (errno)
            {
            case EAGAIN:
            case ETIMEDOUT:
                throw TimeoutException("TCPSocket::flush", strerror(errno));
            case EPIPE:
                throw DisconnectedException("TCPSocket::flush", strerror(errno));
            default:
                throw IOException("TCPSocket::flush", strerror(errno));
            }
        }
        sent += size;
    }
    d->sendbuf.clear();
}
Exemplo n.º 23
0
void DFA::read(Source &r)
{
#undef pt
#define pt(a) //pr(a)

	reset();
	int v;
	r >> v;
	pt((" version = %d\n",v));
	
	if (v != VERSION)
		throw IOException("Bad version in DFA");
	short sCnt;
	short sState;
	short tokenNameCount;
	r >> sCnt >> sState >> tokenNameCount;

	pt((" # states=%d, start=%d\n",sCnt,sState));

	for (int i = 0; i < sCnt; i++) {
		addState(i);
		DFAState &s = getState(i);
		pt((" reading state %d\n",i));
		s.read(r);
	}
	setStartState(sState);

	for (int i = 0; i < tokenNameCount; i++) {
		String n;
		r >> n;
		tokenNames_.add(n);
		pt((" token %d= %s\n",i,n.chars() ));
	}

	pt((" done reading\n"));
}
Exemplo n.º 24
0
string GetInputFileName(string prompt)
{
	string temp = "";
	bool validFileName = true;
	do{
		cin.clear();

		//Prompt the user to enter a value.
		cout << prompt;
		//place the value in string temp
		getline(cin, temp);

		//check to see if CTRL-Z has been pressed
		if (cin.eof()){
			throw IOException(ERROR_EOF, EXIT);
			cin.clear();
			return 0;
		}

		validFileName = ValidateFileName(temp);

	} while (!validFileName);//end while loop
	return temp;
}
Exemplo n.º 25
0
uint64 CStdFile::GetPosition()
{
	long long pos = _ftelli64(m_fp);
	if (pos == -1LL)
	{
		char* msg;

		switch (errno)
		{
		case EBADF: msg = "Handle is not a valid file pointer or the file is not open";
			break;

		case EINVAL: msg = "Handle is not a valid file stream";
			break;

		default:
			msg = "IO error";
		}

		raise(IOException(msg));
	}

	return (uint64)pos;
}
InflatingStreamBuf::InflatingStreamBuf(std::istream& istr, int windowBits):
    BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in),
    _pIstr(&istr),
    _pOstr(0),
    _eof(false),
    _check(false)
{
    _zstr.zalloc    = Z_NULL;
    _zstr.zfree     = Z_NULL;
    _zstr.opaque    = Z_NULL;
    _zstr.next_in   = 0;
    _zstr.avail_in  = 0;
    _zstr.next_out  = 0;
    _zstr.avail_out = 0;

    _buffer = new char[INFLATE_BUFFER_SIZE];

    int rc = inflateInit2(&_zstr, windowBits);
    if (rc != Z_OK)
    {
        delete [] _buffer;
        throw IOException(zError(rc));
    }
}
Exemplo n.º 27
0
		OldUDPSocket::OldUDPSocket(const IPv4Address &addr, int _port){
#ifdef USE_EMBEDDED_CLASSNAMES
			setClassName(__xvr2_Net_OldUDPSocket);
#endif
			flags = MSG_NOSIGNAL;
			port = _port;
			bzero(&ipv4addr, sizeof(struct ::sockaddr_in));
			ipv4addr.sin_family = AF_INET;
			ipv4addr.sin_port   = htons(_port);
			ipv4addr.sin_addr   = *addr.address();
			tsock = socket(ipv4addr.sin_family, SOCK_DGRAM, 0);
			if(tsock < 0){
				switch(errno){
					case EMFILE:
						throw ProcOutOfFileDescriptors();
					break;
					case ENFILE:
						throw SysOutOfFileDescriptors();
					break;
					default:
						throw IOException();
				}
			}
		}
Exemplo n.º 28
0
BitInputStream::BitInputStream(std::string filename):
	InputStream()
{
	jcommon::Object::SetClassName("jio::BitInputStream");
	
	haveByte = false;
	show = false;
	currentMask = 0;
	currentByte = 0;
     
	 try {
		 file = new File(filename);
		 stream = new FileInputStream(file);
	 } catch (...) {
		 if (file != NULL) {
			 delete file;
		 }

		 file = NULL;
		 stream = NULL;
		 
		 throw IOException("Cannot open file in BitInputStream");
	 }
}
InflatingStreamBuf::InflatingStreamBuf(std::ostream& ostr, StreamType type):
    BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::out),
    _pIstr(0),
    _pOstr(&ostr),
    _eof(false),
    _check(type != STREAM_ZIP)
{
    _zstr.zalloc    = Z_NULL;
    _zstr.zfree     = Z_NULL;
    _zstr.opaque    = Z_NULL;
    _zstr.next_in   = 0;
    _zstr.avail_in  = 0;
    _zstr.next_out  = 0;
    _zstr.avail_out = 0;

    _buffer = new char[INFLATE_BUFFER_SIZE];

    int rc = inflateInit2(&_zstr, 15 + (type == STREAM_GZIP ? 16 : 0));
    if (rc != Z_OK)
    {
        delete [] _buffer;
        throw IOException(zError(rc));
    }
}
Exemplo n.º 30
-1
void
InflaterIOChannel::go_to_end()
{
    if (m_error) {
        throw IOException("InflaterIOChannel is in error condition, "
                "can't seek to end");
    }

    // Keep reading until we can't read any more.

    unsigned char temp[ZBUF_SIZE];

    // Seek forwards.
    for (;;) {
        const std::streamsize bytes_read = inflate_from_stream(temp, ZBUF_SIZE);
        if (!bytes_read) {
            // We've seeked as far as we can.
            break;
        }
    }
}