int SockConnector::connect(SockStream &stream, BaseAddr &addr)
{
//struct sockaddr_in _addr;
//memcpy(&_addr, addr.get_addr(), addr.get_addr_size());
//LOG_PRN((LM_INFO, "SockConnector:: connect %s:%d\n", inet_ntoa(_addr.sin_addr), addr.port()));
if(stream.get_handle() == INVALID_SOCKET)
{
stream.open(AF_INET);
if(stream.get_handle() == INVALID_SOCKET)
{
perror("socket");
#ifdef WIN32
return GetLastError();
#else
return errno;
#endif
}
}
int res = ::connect(stream.get_handle() , reinterpret_cast<struct sockaddr *> (addr.get_addr()), (socklen_t)addr.get_size());
if (res ==SOCKET_ERROR )
{
LOG_PRN((LM_WARNING, "SockConnector::connect() failed\n"));
return -1;
}
return 0;
}
int SockConnector::connect(SockStream &stream, BaseAddr &addr, TimeValue &tv)
{
int rv = 0;
// non-block socket
stream.set_nonblocking();
// connect
rv = ::connect(stream.get_handle(), reinterpret_cast<struct sockaddr *> (addr.get_addr()), (socklen_t)addr.get_size());
if (rv == 0) { // connect success
}
else {
#ifdef _WIN32
int sock_errcode = WSAGetLastError();
#else
int sock_errcode = errno;
#endif
// printf("SockConnector::connect(): addr.get_size()=%d, addr.get_type()=%X\n", addr.get_size(), addr.get_type());
if (addr.get_type() == AF_UNIX) {
//const UnixAddr &unixaddr = dynamic_cast<const UnixAddr &> (addr);
//printf("SockConnector:: UNIX ADDR: %s\n", unixaddr.get_path());
}
else {
//InetAddr &inetaddr = dynamic_cast<InetAddr &> (addr);
//printf("SockConnector:: INET ADDR: %s : %d\n",
// inetaddr.get_host_addr(),
// inetaddr.get_port_number());
}
// if socket error other than EINPROGRESS, return -1;
if (sock_errcode == EINPROGRESS || sock_errcode == EINTR) {
//printf("SockConnector: EINPROGRESS[%d]\n", sock_errcode);
int revent = stream.poll_out(tv);
//printf("SockConnector: revent=%02X\n", revent);
if (IS_POLL_W(revent))
rv = 0;
else if (IS_POLL_E(revent))
rv = -1;
}
else {
printf("SockConnector::connect() error: %d\n", sock_errcode);
rv = -1;
}
}
// restore file status flags
stream.set_blocking();
return rv;
}
HERRCODE ChatClient::sendFileTransferRequest(const std::wstring& email, const RequestFilesInfo& fileInfo, time_t timestamp)
{
SockStream os;
os.writeInt(net::kCommandType_FileTransferRequest);
os.writeInt(0);
os.writeString(email);
os.writeString(fileInfo.fileName);
os.writeInt(fileInfo.fileSize);
os.writeInt64(timestamp);
os.flushSize();
queueSendRequest(sock_, os);
return H_OK;
}
HERRCODE ChatClient::loginImpl(int type, const std::wstring& username, const std::wstring& credential)
{
sockaddr_in addr = { 0 };
addr.sin_port = htons(serverPort_);
addr.sin_family = AF_INET;
IN_ADDR in_addr;
InetPton(AF_INET, serverAddr_.c_str(), &in_addr);
addr.sin_addr = in_addr;
if (::connect(sock_, (const sockaddr*)&addr, sizeof(sockaddr_in)) != 0) {
return H_NETWORK_ERROR;
}
SockStream stream;
stream.writeInt(net::kCommandType_Login);
stream.writeInt(0);
stream.writeInt(type);
stream.writeString(username);
stream.writeString(credential);
stream.flushSize();
auto ret = ::send(sock_, stream.getBuf(), stream.getSize(), 0);
if (ret == SOCKET_ERROR) {
return H_NETWORK_ERROR;
}
buffer buf(200);
int rc = ::recv(sock_, buf.data(), buf.size(), 0);
if (rc) {
SockStream ss(buf.data(), rc);
assert(net::kCommandType_LoginAck == ss.getInt());
auto size = ss.getInt();
auto ack = ss.getInt();
if (ack == net::kLoginAck_Succeeded) {
email_ = username;
authKey_ = ss.getString();
auto hr = initSocks(sock_);
if (hr != H_OK)
return hr;
return H_OK;
} else {
return H_AUTH_FAILED;
}
} else {
return H_NETWORK_ERROR;
}
}
void Acceptor::accept(SockStream& stream)
{
int socket;
struct sockaddr_in clientaddr;
unsigned int addrlen = sizeof(clientaddr);
if((socket = ::accept(socket_, (struct sockaddr *)&clientaddr, &addrlen)) == -1)
{
throw exception("Can't accept connection");
}
stream.set_handle(socket);
}
HERRCODE ChatClient::logout()
{
SockStream stream;
stream.writeInt(net::kCommandType_Logout);
stream.writeInt(0);
stream.writeString(email_);
stream.flushSize();
auto ret = ::send(sock_, stream.getBuf(), stream.getSize(), 0);
if (ret == SOCKET_ERROR) {
return H_NETWORK_ERROR;
}
quit(true);
return H_OK;
}
int
SockConnector::connect
(
SockStream& stream,
const SockAddr& sockAddr,
int reuseAddr,
int protocolFamily,
int protocol
)
{
TRACE_CALL;
if (stream.handleInvalid ())
{
// open on a new socket descriptor
if (stream.open (SOCK_STREAM,
protocolFamily,
protocol,
reuseAddr) < 0)
return -1; // cannot open
}
sockaddr* remoteAddr = 0;
if (sockAddr.clone (remoteAddr) != -1)
{
size_t size = sockAddr.size ();
REACTOR_HANDLE handle = stream.handleGet ();
if (::connect (handle, remoteAddr, size) < 0)
stream.close ();
#if 0
if (::bind (handle, remoteAddr, size) < 0)
stream.close ();
else if (::connect (handle, remoteAddr, size) < 0)
stream.close ();
#endif
}
delete remoteAddr;
return stream.handleInvalid () ? -1 : 0;
}
HERRCODE ChatClient::sendMessage(const std::wstring& username, const std::wstring& message, time_t timestamp)
{
if (message.find(L"<img") == -1) {
SockStream stream;
stream.writeInt(net::kCommandType_Message);
stream.writeInt(0);
stream.writeString(email_);
stream.writeString(username);
stream.writeInt64(timestamp);
stream.writeString(message);
stream.flushSize();
queueSendRequest(sock_, stream);
msgMan_.addMessageRequest(timestamp, username, timestamp);
} else {
ChatOverlappedData* ol = new ChatOverlappedData(net::kAction_SendMessage);
ImageMessageForSend* msg = new ImageMessageForSend;
msg->setRawMessage(message, username, timestamp);
ol->setProp((int)msg);
PostQueuedCompletionStatus(hComp_, 0, kServerKey, ol);
}
return H_OK;
}
HERRCODE ChatClient::confirmFileTransferRequest(const std::wstring& username, time_t timestamp,
bool recv, const std::wstring& savePath)
{
if (!recv) {
SockStream os;
os.writeInt(net::kCommandType_FileTransferRequestAck);
os.writeInt(0);
os.writeString(username);
os.writeInt64(timestamp);
os.writeBool(false);
os.flushSize();
queueSendRequest(sock_, os);
} else {
SockStream os;
os.writeInt(net::kCommandType_FileTransferRequestAck);
os.writeInt(0);
os.writeString(username);
os.writeInt64(timestamp);
os.writeBool(true);
os.flushSize();
queueSendRequest(sock_, os);
}
return H_OK;
}
int SockConnector::connect(SockStream &stream, InetAddr &addr, TimeValue &tv)
{
int rv = 0;
// non-block socket
stream.set_nonblocking();
#ifdef _WIN32
// connect
rv = ::connect(stream.get_handle(), (const struct sockaddr *) addr.get_addr(), (socklen_t)addr.get_addr_size());
if (rv != -1) {
rv = 0;
}
else {
if (WSAGetLastError() == WSAEWOULDBLOCK)
{
//printf("connect InProgress [%d]\n", sock);
fd_set rset;
fd_set wset;
FD_ZERO(&rset);
FD_ZERO(&wset);
FD_SET(stream.get_handle(), &rset);
FD_SET(stream.get_handle(), &wset);
rv = ::select(0, &rset, &wset, NULL, (struct timeval*)tv.timeval());
if (rv == 0) {
perror("connect timeout");
rv = -1;
}
else if (FD_ISSET(stream.get_handle(), &rset) || FD_ISSET(stream.get_handle(), &wset)) {
int error = 0;
socklen_t len = sizeof(error);
if (getsockopt(stream.get_handle(), SOL_SOCKET, SO_ERROR, (char *)&error, &len) == 0) {
// select error
if (error == 0) {
rv = 0;
}
else {
closesocket(stream.get_handle());
perror("connect");
rv = -1;
}
}
}
else {
perror("connect");
rv = -1;
}
}
else {
perror("connect");
rv = -1;
}
}
#endif
// restore file status flags
stream.set_blocking();
return rv;
}
