::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__;
