::std::streampos seekoff(::std::streamoff off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which = ::std::ios_base::in | ::std::ios_base::out) { if ( which & ::std::ios_base::in ) { int64_t abstarget = 0; int64_t const cur = symsread - (egptr()-gptr()); if ( way == ::std::ios_base::cur ) abstarget = cur + off; else if ( way == ::std::ios_base::beg ) abstarget = off; else // if ( way == ::std::ios_base::end ) abstarget = static_cast<int64_t>(filesize) + off; // no movement if ( abstarget - cur == 0 ) { return abstarget; } // move right but within buffer else if ( (abstarget - cur) > 0 && (abstarget - cur) <= (egptr()-gptr()) ) { setgchecked( eback(), gptr()+(abstarget-cur), egptr() ); return abstarget; } // move left within buffer else if ( (abstarget - cur) < 0 && (cur-abstarget) <= (gptr()-eback()) ) { setgchecked( eback(), gptr()-(cur-abstarget), egptr() ); return abstarget; } // move target is outside currently buffered region // -> use absolute move else { return seekpos(abstarget,which); } } return -1; }
std::streampos SimpleStreamBuf::seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode which) { if (dir == std::ios_base::beg) { return seekpos(off, which); } else if (dir == std::ios_base::end) { return seekpos((pptr() - m_buffer) - off, which); } else if (dir == std::ios_base::cur) { if(which == std::ios_base::in) { return seekpos((gptr() - m_buffer) + off, which); } else { return seekpos((pptr() - m_buffer) + off, which); } } return off_type(-1); }
/** Internal do not use * \param[in] off * \param[in] way */ bool SdStreamBase::seekoff(off_type off, seekdir way) { pos_type pos; switch (way) { case beg: pos = off; break; case cur: pos = curPosition() + off; break; case end: pos = fileSize() + off; break; default: return false; } return seekpos(pos); }
::std::streampos seekoff(::std::streamoff off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which = ::std::ios_base::in | ::std::ios_base::out) { if ( which & ::std::ios_base::in ) { int64_t abstarget = 0; int64_t const cur = symsread - (egptr()-gptr()); if ( way == ::std::ios_base::cur ) abstarget = cur + off; else if ( way == ::std::ios_base::beg ) abstarget = off; else // if ( way == ::std::ios_base::end ) abstarget = n + (addterm?1:0) + off; if ( abstarget - cur == 0 ) { return abstarget; } else if ( (abstarget - cur) > 0 && (abstarget - cur) <= (egptr()-gptr()) ) { setg(eback(),gptr()+(abstarget-cur),egptr()); return abstarget; } else if ( (abstarget - cur) < 0 && (cur-abstarget) <= (gptr()-eback()) ) { setg(eback(),gptr()-(cur-abstarget),egptr()); return abstarget; } else { return seekpos(abstarget,which); } } return -1; }
MemStreamBuf::pos_type MemStreamBuf::seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode) { if((mode&std::ios_base::out)) return traits_type::eof(); pos_type pos; switch(whence) { case std::ios_base::beg: pos = pos_type(offset); break; case std::ios_base::cur: pos = pos_type(memInfo.Pos) - pos_type(egptr()-gptr()); pos += offset; break; case std::ios_base::end: pos = memInfo.Length + pos_type(offset); break; default: return traits_type::eof(); } return seekpos(pos, mode); }
int32 DCCSend::Transfer(void* arg) { BMessenger msgr(reinterpret_cast<DCCSend*>(arg)); BMessage reply, ipdata; BLooper* looper(NULL); if (msgr.IsValid()) msgr.SendMessage(M_DCC_GET_CONNECT_DATA, &reply); BMessenger callmsgr; reply.FindMessenger("caller", &callmsgr); callmsgr.SendMessage(M_GET_IP, &ipdata); BPath path(reply.FindString("name")); BString fileName, status; struct sockaddr_in address; struct in_addr sendaddr; memset(&sendaddr, 0, sizeof(struct in_addr)); int sd, dccSock(-1); fileName.Append(path.Leaf()); fileName.ReplaceAll(" ", "_"); if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { UpdateStatus(msgr, S_DCC_ESTABLISH_ERROR); return 0; } memset(&address, 0, sizeof(struct sockaddr_in)); address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons(atoi(reply.FindString("port"))); int sin_size; sin_size = (sizeof(struct sockaddr_in)); UpdateStatus(msgr, S_DCC_LOCK_ACQUIRE B_UTF8_ELLIPSIS); vision_app->AcquireDCCLock(); if (!msgr.IsValid() || bind(sd, (sockaddr*)&address, sin_size) < 0) { UpdateStatus(msgr, S_DCC_ESTABLISH_ERROR); vision_app->ReleaseDCCLock(); close(sd); return 0; } UpdateStatus(msgr, S_DCC_ACK_WAIT); sendaddr.s_addr = inet_addr(ipdata.FindString("ip")); if (msgr.IsValid()) { status = "PRIVMSG "; status << reply.FindString("nick") << " :\1DCC SEND " << fileName << " " << htonl(sendaddr.s_addr) << " " << reply.FindString("port") << " " << reply.FindString("size") << "\1"; BMessage msg(M_SERVER_SEND); msg.AddString("data", status.String()); if (callmsgr.IsValid()) callmsgr.SendMessage(&msg); UpdateStatus(msgr, S_DCC_LISTEN_CALL); if (listen(sd, 1) < 0) { UpdateStatus(msgr, S_DCC_ESTABLISH_ERROR); vision_app->ReleaseDCCLock(); close(sd); return 0; } } struct timeval t; t.tv_sec = 2; t.tv_usec = 0; uint32 try_count(0); while (msgr.Target(&looper) != NULL) { fd_set rset; FD_ZERO(&rset); FD_SET(sd, &rset); if (select(sd + 1, &rset, 0, 0, &t) < 0) { UpdateStatus(msgr, S_DCC_ESTABLISH_ERROR); vision_app->ReleaseDCCLock(); close(sd); return 0; } if (FD_ISSET(sd, &rset)) { dccSock = accept(sd, (sockaddr*)&address, (socklen_t*)&sin_size); UpdateStatus(msgr, S_DCC_ESTABLISH_SUCCEEDED); break; } ++try_count; status = S_DCC_WAIT_FOR_CONNECTION; status << try_count << "."; UpdateStatus(msgr, status.String()); } vision_app->ReleaseDCCLock(); char set[4]; memset(set, 1, sizeof(set)); close(sd); BFile file; file.SetTo(reply.FindString("name"), B_READ_ONLY); int32 bytes_sent(0L), seekpos(0L); BMessage resumeData; msgr.SendMessage(M_DCC_GET_RESUME_POS, &resumeData); if (resumeData.HasInt32("pos")) { resumeData.FindInt32("pos", &seekpos); file.Seek(seekpos, SEEK_SET); UpdateBar(msgr, seekpos, 0, 0, true); bytes_sent = seekpos; } status = S_DCC_SEND1; status << path.Leaf() << S_DCC_SEND2 << reply.FindString("nick") << "."; UpdateStatus(msgr, status.String()); int cps(0); if (file.InitCheck() == B_NO_ERROR) { bigtime_t last(system_time()), now; const uint32 DCC_BLOCK_SIZE(atoi(vision_app->GetString("dccBlockSize"))); #ifdef __INTEL__ char buffer[DCC_BLOCK_SIZE]; #else char* buffer = new char[DCC_BLOCK_SIZE]; #endif int period(0); ssize_t count(0); bigtime_t start = system_time(); while ((msgr.Target(&looper) != NULL) && (count = file.Read(buffer, DCC_BLOCK_SIZE - 1)) > 0) { int sent; if ((sent = send(dccSock, buffer, count, 0)) < count) { UpdateStatus(msgr, S_DCC_WRITE_ERROR); break; } uint32 confirm(0), newSize(bytes_sent + count); fd_set rset, eset; FD_ZERO(&rset); FD_ZERO(&eset); FD_SET(dccSock, &rset); t.tv_sec = 0; t.tv_usec = 10; while ((confirm < newSize) && (recv(dccSock, &confirm, sizeof(confirm), 0) > 0)) { confirm = ntohl(confirm); bytes_sent = confirm; } BMessage msg(M_DCC_UPDATE_TRANSFERRED); msg.AddInt32("transferred", bytes_sent); msgr.SendMessage(&msg); now = system_time(); period += sent; bool hit(false); if (now - last > 500000) { cps = (int)ceil((bytes_sent - seekpos) / ((now - start) / 1000000.0)); BMessage updmsg(M_DCC_UPDATE_AVERAGE); updmsg.AddInt32("average", cps); msgr.SendMessage(&updmsg); last = now; period = 0; hit = true; } UpdateBar(msgr, sent, cps, bytes_sent, hit); } #ifndef __INTEL__ delete[] buffer; #endif } if (msgr.IsValid()) { BMessage msg(M_DCC_STOP_BUTTON); msgr.SendMessage(&msg); } if (dccSock > 0) { close(dccSock); } if (file.InitCheck() == B_OK) file.Unset(); return 0; }
streammarker::~streammarker() { if (saving()) { // Unlink from sb's chain. register streammarker **ptr = &((backupbuf*)_sbuf)->_markers; for (; ; ptr = &(*ptr)->_next) if (*ptr == NULL) break; else if (*ptr == this) { *ptr = _next; return; } } #if 0 if _sbuf has a backup area that is no longer needed, should we delete it now, or wait until underflow()? #endif } #define BAD_DELTA EOF int streammarker::delta(streammarker& other_mark) { if (_sbuf != other_mark._sbuf) return BAD_DELTA; if (saving() && other_mark.saving()) return _pos - other_mark._pos; else if (!saving() && !other_mark.saving()) return _spos - other_mark._spos; else return BAD_DELTA; } int streammarker::delta() { if (_sbuf == NULL) return BAD_DELTA; if (saving()) { int cur_pos; if (_sbuf->in_backup()) cur_pos = _sbuf->_gptr - _sbuf->_egptr; else cur_pos = _sbuf->_gptr - _sbuf->_eback; return _pos - cur_pos; } else { if (_spos == EOF) return BAD_DELTA; int cur_pos = _sbuf->seekoff(0, ios::cur); if (cur_pos == EOF) return BAD_DELTA; return _pos - cur_pos; } } int streambuf::seekmark(streammarker& mark, int delta /* = 0 */) { if (mark._sbuf != this) return EOF; if (!mark.saving()) { return seekpos(mark._spos, ios::in); } else if (mark._pos >= 0) { if (in_backup()) switch_to_main_get_area(); _gptr = _eback + mark._pos; } else { if (!in_backup()) switch_to_backup_area(); _gptr = _egptr + mark._pos; } return 0; } void streambuf::unsave_markers() { register streammarker *mark =_markers; if (_markers) { streampos offset = seekoff(0, ios::cur, ios::in); if (offset != EOF) { offset += eGptr() - Gbase(); for ( ; mark != NULL; mark = mark->_next) mark->set_streampos(mark->_pos + offset); } else { for ( ; mark != NULL; mark = mark->_next) mark->set_streampos(EOF); } _markers = 0; } free_backup_area(); } int backupbuf::pbackfail(int c) { if (_gptr <= _eback) { // Need to handle a filebuf in write mode (switch to read mode). FIXME! if (have_backup() && !in_backup()) { switch_to_backup_area(); } if (!have_backup()) { // No backup buffer: allocate one. // Use short buffer, if unused? (probably not) FIXME int backup_size = 128; _other_gbase = new char [backup_size]; _other_egptr = _other_gbase + backup_size; _aux_limit = _other_egptr; switch_to_backup_area(); } else if (gptr() <= eback()) { // Increase size of existing backup buffer. size_t new_size; size_t old_size = egptr() - eback(); new_size = 2 * old_size; char* new_buf = new char [new_size]; memcpy(new_buf+(new_size-old_size), eback(), old_size); delete [] eback(); setg(new_buf, new_buf+(new_size-old_size), new_buf+new_size); _aux_limit = _gptr; } } _gptr--; if (c != EOF && *_gptr != c) *_gptr = c; return (unsigned char)*_gptr; } unsigned __adjust_column(unsigned start, const char *line, int count) { register const char *ptr = line + count; while (ptr > line) if (*--ptr == '\n') return line + count - ptr - 1; return start + count; } int ios::readable() { return !(rdbuf()->_flags & _S_NO_READS); } int ios::writable() { return !(rdbuf()->_flags & _S_NO_WRITES); } int ios::is_open() { return rdbuf() && (rdbuf()->_flags & _S_NO_READS+_S_NO_WRITES) != _S_NO_READS+_S_NO_WRITES; } #if defined(linux) #define IO_CLEANUP ; #endif #ifdef IO_CLEANUP IO_CLEANUP #else struct __io_defs { __io_defs() { } ~__io_defs() { streambuf::flush_all(); } }; __io_defs io_defs__;