LNE_NAMESPACE_USING
void TestClient()
{
TimeValue tv(3);
SockAddr addr("www.google.com:80");
SockConnector *connector = SockConnector::NewInstance(addr, &tv);
if(connector == NULL) {
printf("connector cannot create\n");
return;
}
SockPad skpad;
if(connector->Connect(skpad) != LNERR_OK) {
printf("connector cannot connect\n");
connector->Release();
return;
}
SockWaves *stream = SockWaves::NewInstance(skpad);
const char *query = "GET / HTTP/1.1\r\n\r\n";
DataBlock *block = DataBlock::NewInstance(1024 * 1024);
strcpy(block->buffer(), query);
block->set_size(static_cast<LNE_UINT>(strlen(block->buffer())));
stream->Send(block);
while(stream->Recv(block, tv) == LNERR_OK) {
block->buffer()[block->size()] = '\0';
puts(block->buffer());
}
block->Release();
SockAddr addr_sock, addr_peer;
stream->GetSockAddr(addr_sock);
stream->GetPeerAddr(addr_peer);
printf("connect %s => %s\n", addr_sock.addr_text(), addr_peer.addr_text());
stream->Release();
connector->Release();
}
void DatabaseAdapter_DataBlock::Writer::store( DatabaseTransactionInterface* transaction, const DataBlock& blk)
{
m_dbkey.resize( m_domainKeySize);
m_dbkey.addElem( blk.id());
transaction->write( m_dbkey.ptr(), m_dbkey.size(), blk.charptr(), blk.size());
}
DataBlock(const DataBlock& rhs) :
data_(std::malloc(rhs.size())),
size_(rhs.size())
{
std::memcpy(data(), rhs.data(), size());
}
void SockSpray::__HandleRead(void)
{
bool to_handle = true;
// ignore when shutdown
shutdown_lock_.Lock();
if(shutdown_state_.already || shutdown_state_.query)
to_handle = false;
shutdown_lock_.Unlock();
if(!to_handle)
return;
// lock recv process
recv_lock_.Lock();
if(recv_state_.already) {
to_handle = false;
recv_state_.ready = true;
} else {
recv_state_.ready = false;
recv_state_.already = true;
}
recv_lock_.Unlock();
if(!to_handle)
return;
ssize_t len;
DataBlock *block;
bool continue_recv = false, to_shutdown = false;
recv_data_next:
do {
block = pool_->Alloc();
if(block == NULL)
to_shutdown = true;
else {
do {
len = recv(skpad_.socket(), block->buffer_free(), block->free_size(), 0);
if(len > 0)
block->set_size(block->size() + len);
#if defined(LNE_WIN32)
} while(len > 0 && !block->IsFull());
#else
}
while((len > 0 && !block->IsFull()) || (len < 0 && errno == EINTR));
#endif
if(len > 0)
continue_recv = true;
#if defined(LNE_WIN32)
else if(len == 0 || WSAGetLastError() != WSAEWOULDBLOCK)
#else
else if(len == 0 || errno != EWOULDBLOCK)
#endif
to_shutdown = true;
else
continue_recv = false;
// process data
if(!block->IsEmpty())
handler_->HandleData(this, block);
block->Release();
if(continue_recv) {
shutdown_lock_.Lock();
if(shutdown_state_.query) {
to_shutdown = true;
continue_recv = false;
}
shutdown_lock_.Unlock();
}
#if defined(LNE_WIN32)
if(!continue_recv && !to_shutdown) {
DWORD bytes, flags = 0;
iocp_lock_.Lock();
int rc = WSARecv(skpad_.socket(), &iocp_data_.buffer, 1, &bytes, &flags, &iocp_data_.overlap[IOCP_READ], NULL);
if(rc == SOCKET_ERROR && WSAGetLastError() != ERROR_IO_PENDING)
to_shutdown = true;
else
++iocp_data_.count;
iocp_lock_.Unlock();
}
#endif
}
}
while(continue_recv && !to_shutdown);
// check shutdown
shutdown_lock_.Lock();
if(!shutdown_state_.already && to_shutdown)
__Shutdown();
shutdown_lock_.Unlock();
// lock unlock process
to_handle = false;
recv_lock_.Lock();
if(!recv_state_.ready || to_shutdown)
recv_state_.already = false;
else
{
to_handle = true;
recv_state_.ready = false;
}
recv_lock_.Unlock();
if(to_handle)
goto recv_data_next;
}
