uint32 Archive::WriteString(char const* str)
{
uint32 serialized_count = 0;
if (IsWriting())
serialized_count = Serialize((void*)str, (uint32)strlen(str));
return serialized_count;
}
int CConnect::Writev()
{
std::vector<DataBuff*>& vWrite = buffmanage_->GetWriteList();
const int iov_count = vWrite.size();
if(iov_count == 0)
{
if(IsWriting())
DisWriting();
return 0;
}
struct iovec iow[iov_count];
for (int i = 0; i < iov_count; ++i)
{
iow[i].iov_base = vWrite[i]->data + vWrite[i]->cur;
iow[i].iov_len = vWrite[i]->len - vWrite[i]->cur;
}
ssize_t cur_iov = 0;
ssize_t nwritenum = 0;
int ntotalwrite = buffmanage_->GetWritable();
while(ntotalwrite > nwritenum)
{
ssize_t n = writev(pSocket_->Get_Fd(), &iow[cur_iov], iov_count - cur_iov);
if(n > 0)
{
nwritenum += n;
while(static_cast<unsigned int>(n) >= iow[cur_iov].iov_len)
n -= iow[cur_iov++].iov_len;
iow[cur_iov].iov_base = (char*)iow[cur_iov].iov_base+n;
iow[cur_iov].iov_len -= n;
}
else if(n < 0)
{
if(errno == EAGAIN || errno == EWOULDBLOCK)
break;
else if(errno == EINTR)
continue;
else
{
Handle_Error();
break;
}
}
else
{
break;
}
}
if(ntotalwrite >= nwritenum) // no data in send buff, cancal write event
DisWriting();
buffmanage_->ReduceWriteNum(nwritenum);
return nwritenum;
}
void CConnect::SendMsg(CMessage* Msg)
{
if(state_ != CON_CONNECTED)
{
CMessageAlloctor::FreeMSG(&Msg);
return;
}
// Msg->PrintData();
if(MsgList_.empty())
{
int msglen = Msg->len_ - Msg->cur_;
ssize_t size = write(pSocket_->Get_Fd(), Msg->data_+Msg->cur_, msglen);
if(size >= msglen)
{
CMessageAlloctor::FreeMSG(&Msg);
State_send_info(size);
return;
}
else if(size >= 0)
{
Msg->cur_ += size;
MsgList_.push_back(Msg);
State_send_info(size);
if(!IsWriting())
SetWriting();
}
else
{
if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
Handle_Error();
}
}
else
{
MsgList_.push_back(Msg);
if(!IsWriting())
SetWriting();
}
}
void CConnect::SendAllMsg()
{
if(state_ != CON_CONNECTED)
return;
if(MsgList_.empty())
{
if(IsWriting())
DisWriting();
}
else
{
int msgnum = MsgList_.size();
const int iov_count = MIN(msgnum, (IOV_MAX));
struct iovec iow[iov_count];
std::list<CMessage*>::iterator it = MsgList_.begin();
int i = 0;
int ntotalwrite = 0;
for(; it != MsgList_.end(); ++it)
{
CMessage *Msg = *it;
int msglen = Msg->len_ - Msg->cur_;
iow[i].iov_base = Msg->data_ + Msg->cur_;
iow[i].iov_len = msglen;
ntotalwrite += msglen;
i++;
if(i >= iov_count)
break;
}
ssize_t cur_iov = 0;
ssize_t nwritenum = 0;
while(ntotalwrite > nwritenum)
{
ssize_t n = writev(pSocket_->Get_Fd(), &iow[cur_iov], iov_count - cur_iov);
// printf("total = %d writenum = %d n = %d\n", ntotalwrite, nwritenum, n);
if(n > 0)
{
nwritenum += n;
while(static_cast<unsigned int>(n) >= iow[cur_iov].iov_len)
{
n -= iow[cur_iov++].iov_len;
it = MsgList_.begin();
CMessageAlloctor::FreeMSG(&(*it));
MsgList_.erase(it);
}
if(n > 0)
{
iow[cur_iov].iov_base = (char*)iow[cur_iov].iov_base+n;
iow[cur_iov].iov_len -= n;
it = MsgList_.begin();
(*it)->cur_ += n;
}
if(MsgList_.empty() && IsWriting())
DisWriting();
}
else if(n < 0)
{
if(errno == EAGAIN || errno == EWOULDBLOCK)
break;
else if(errno == EINTR)
continue;
else
{
Handle_Error();
break;
}
}
else
{
break;
}
}
State_send_info(nwritenum);
// all pending msg has beeb send
/* if(static_cast<unsigned int>(iov_count) >= MsgList_.size() && ntotalwrite >= nwritenum)
{
it = MsgList_.begin();
for(; it != MsgList_.end(); ++it)
CMessageAlloctor::FreeMSG(&(*it));
MsgList_.clear();
if(IsWriting())
DisWriting();
}
else
{
for(it = MsgList_.begin(); it != MsgList_.end()&& ntotalwrite>0; )
{
CMessage *msg = *it;
int msglen = msg->len_ - msg->cur_;
if(msglen <= ntotalwrite)
{
CMessageAlloctor::FreeMSG(&msg);
it = MsgList_.erase(it);
ntotalwrite -= msglen;
}
else
{
msg->cur_ += ntotalwrite;
ntotalwrite = 0;
}
}
if(!IsWriting())
SetWriting();
}
*/ }
}
