InputLIRC::InputLIRC(QObject* parent) : InputBase(parent)
{
socket = new QLocalSocket(this);
socketNotifier = NULL;
connect(socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this,
SLOT(socketerror(QLocalSocket::LocalSocketError)));
connect(socket, SIGNAL(connected()), this, SLOT(connected()));
connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));
}
/*
** Login to the Authentication server
**
** Returns - 0 - failed to login for some reason.
** 1 - Logged in successfully
*/
int login(struct session * s)
{
int err;
char credentials[16];
time_t logintime;
int authsocket;
struct transaction t;
INT2 transactiontype;
int addrsize;
s->localaddr.sin_port = htons(0);
authsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
err = bind(authsocket,(struct sockaddr *)&s->localaddr,sizeof(struct sockaddr_in));
if(err)
{
socketerror(s,"Error binding auth socket");
closesocket(authsocket);
return 0;
}
err = connect(authsocket,(struct sockaddr *)&s->authhost,sizeof(struct sockaddr_in));
if(err)
{
socketerror(s,"Cant connect to auth server");
closesocket(authsocket);
return 0;
}
addrsize = sizeof(struct sockaddr_in);
err = getsockname(authsocket,(struct sockaddr *)&s->localipaddress,&addrsize);
/*
** start the negotiation
*/
start_transaction(&t,T_MSG_PROTOCOL_NEG_REQ,s->sessionid);
add_field_INT2(s,&t,T_PARAM_CLIENT_VERSION,LOGIN_VERSION * 100);
add_field_string(s,&t,T_PARAM_OS_IDENTITY,s->osname);
add_field_string(s,&t,T_PARAM_OS_VERSION,s->osrelease);
add_field_INT2(s,&t,T_PARAM_PROTOCOL_LIST,T_PROTOCOL_CHAL);
send_transaction(s,authsocket,&t);
transactiontype = receive_transaction(s,authsocket,&t);
if(transactiontype != T_MSG_PROTOCOL_NEG_RESP)
{
s->debug(0,"T_MSG_PROTOCOL_NEG_RESP - error transaction type (%d)",transactiontype);
return 0;
}
extract_valueINT2(s,&t,T_PARAM_STATUS_CODE,&s->retcode);
extract_valuestring(s,&t,T_PARAM_LOGIN_SERVER_HOST,s->loginserverhost);
extract_valueINT2(s,&t,T_PARAM_PROTOCOL_SELECT,&s->protocol);
if(s->protocol != T_PROTOCOL_CHAL)
{
s->debug(0,"T_MSG_PROTOCOL_NEG_RESP - Unsupported protocol (%d)",s->protocol);
return 0;
}
switch(s->retcode)
{
case T_STATUS_SUCCESS:
case T_STATUS_LOGIN_SUCCESS_SWVER:
break;
case T_STATUS_LOGIN_FAIL_SWVER:
{
s->debug(0,"T_MSG_PROTOCOL_NEG_RESP - Login failure: software version");
return 0;
}
case T_STATUS_LOGIN_FAIL_INV_PROT:
{
s->debug(0,"T_MSG_PROTOCOL_NEG_RESP - Login failure: invalid protocol");
return 0;
}
case T_STATUS_LOGIN_UNKNOWN:
{
s->debug(0,"T_MSG_PROTOCOL_NEG_RESP - Login failure: unknown");
return 0;
}
}
closesocket(authsocket);
authsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
err = bind(authsocket,(struct sockaddr *)&s->localaddr,sizeof(struct sockaddr_in));
if(err)
{
socketerror(s,"Error binding auth socket 2");
closesocket(authsocket);
return 0;
}
err = connect(authsocket,(struct sockaddr *)&s->authhost,sizeof(struct sockaddr_in));
if(err)
{
socketerror(s,"Error connecting auth socket 2");
closesocket(authsocket);
return 0;
}
start_transaction(&t,T_MSG_LOGIN_REQ,s->sessionid);
add_field_string(s,&t,T_PARAM_USERNAME,s->username);
add_field_INT2(s,&t,T_PARAM_CLIENT_VERSION,LOGIN_VERSION * 100);
add_field_string(s,&t,T_PARAM_OS_IDENTITY,s->osname);
add_field_string(s,&t,T_PARAM_OS_VERSION,s->osrelease);
add_field_INT2(s,&t,T_PARAM_REASON_CODE,T_LOGIN_REASON_CODE_NORMAL);
add_field_INT2(s,&t,T_PARAM_REQ_PORT,s->listenport);
send_transaction(s,authsocket,&t);
transactiontype = receive_transaction(s,authsocket,&t);
if(transactiontype == T_MSG_LOGIN_RESP)
goto skippo;
if(transactiontype != T_MSG_AUTH_RESP)
{
s->debug(0,"T_MSG_AUTH_RESP - error transaction type (%d)",transactiontype);
return 0;
}
if(!extract_valueINT2(s,&t,T_PARAM_HASH_METHOD,&s->hashmethod))
{
s->debug(0,"T_MSG_AUTH_RESP - no hashmethod provided");
return 0;
}
if(!extract_valuestring(s,&t,T_PARAM_NONCE,s->nonce))
{
s->debug(0,"T_MSG_AUTH_RESP - no nonce supplied");
return 0;
}
if(s->hashmethod == T_AUTH_MD5_HASH)
{
genmd5(s->password,strlen(s->password),s->password);
}
start_transaction(&t,T_MSG_LOGIN_AUTH_REQ,s->sessionid);
s->timestamp = time(NULL);
makecredentials(credentials,s,T_MSG_LOGIN_AUTH_REQ,s->timestamp);
add_field_data(s,&t,T_PARAM_AUTH_CREDENTIALS,credentials,16);
add_field_INT4(s,&t,T_PARAM_TIMESTAMP,s->timestamp);
send_transaction(s,authsocket,&t);
transactiontype = receive_transaction(s,authsocket,&t);
skippo:
if(transactiontype != T_MSG_LOGIN_RESP)
{
s->debug(0,"T_MSG_LOGIN_RESP - error transaction type (%d)",transactiontype);
return 0;
}
extract_valueINT2(s,&t,T_PARAM_STATUS_CODE,&s->retcode);
switch(s->retcode)
{
case T_STATUS_SUCCESS:
case T_STATUS_LOGIN_SUCCESSFUL_SWVER:
case T_STATUS_LOGIN_SUCCESSFUL_ALREADY_LOGGED_IN:
break;
case T_STATUS_USERNAME_NOT_FOUND:
{
s->debug(0,"T_MSG_LOGIN_RESP - Login failure: username not known");
return 0;
}
case T_STATUS_INCORRECT_PASSWORD:
{
s->debug(0,"T_MSG_LOGIN_RESP - Login failure: incorrect password");
return 0;
}
case T_STATUS_ACCOUNT_DISABLED:
{
s->debug(0,"T_MSG_LOGIN_RESP - Login failure: Account disabled");
return 0;
}
case T_STATUS_LOGIN_RETRY_LIMIT:
case T_STATUS_USER_DISABLED:
case T_STATUS_FAIL_USERNAME_VALIDATE:
case T_STATUS_FAIL_PASSWORD_VALIDATE:
case T_STATUS_LOGIN_UNKNOWN:
{
s->debug(0,"T_MSG_LOGIN_RESP - Login failure: other error");
return 0;
}
}
extract_valueINT2(s,&t,T_PARAM_LOGOUT_SERVICE_PORT,&s->logoutport);
extract_valueINT2(s,&t,T_PARAM_STATUS_SERVICE_PORT,&s->statusport);
extract_valuestring(s,&t,T_PARAM_TSMLIST,s->tsmlist);
extract_valuestring(s,&t,T_PARAM_RESPONSE_TEXT,s->resptext);
{
int i,n;
char * p = s->tsmlist;
char t[200];
s->tsmcount = 0;
while((n = strcspn(p," ,"))!=0)
{
strncpy(t,p,n);
t[n] = 0;
p += n +1;
strcpy(s->tsmlist_s[s->tsmcount],t);
strcat(s->tsmlist_s[s->tsmcount++],s->authdomain);
}
for(i=0;i<s->tsmcount;i++)
{
struct hostent * he;
he = gethostbyname(s->tsmlist_s[i]);
if(he)
{
s->tsmlist_in[i].sin_addr.s_addr = *((int*)(he->h_addr_list[0]));
}
else
{
s->tsmlist_in[i].sin_addr.s_addr = inet_addr(s->tsmlist_s[i]);
}
s->debug(1,"Will accept heartbeats from %s = %s\n",s->tsmlist_s[i],inet_ntoa(s->tsmlist_in[i].sin_addr));
}
}
logintime = time(NULL);
s->debug(0,"Logged on as %s - successful at %s",s->username,asctime(localtime(&logintime)));
s->sequence = 0;
s->lastheartbeat = time(NULL);
s->recenthb = 0;
closesocket(authsocket);
return 1;
}
/*
** Logout of the BIDS2 system
**
** Returns - 0 - Could not connect to logout.
** 1 - Logout successful.
*/
int logout(INT2 reason,struct session * s)
{
int err;
char credentials[16];
time_t logintime;
int authsocket;
struct transaction t;
INT2 transactiontype;
s->localaddr.sin_port = htons(0);
authsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
err = bind(authsocket,(struct sockaddr *)&s->localaddr,sizeof(struct sockaddr_in));
if(err)
{
socketerror(s,"Error binding logout auth socket");
closesocket(authsocket);
return 0;
}
err = connect(authsocket,(struct sockaddr *)&s->authhost,sizeof(struct sockaddr_in));
if(err)
{
socketerror(s,"Error connecting logout auth socket");
closesocket(authsocket);
return 0;
}
/*
** start the negotiation
*/
start_transaction(&t,T_MSG_LOGOUT_REQ,s->sessionid);
add_field_string(s,&t,T_PARAM_USERNAME,s->username);
add_field_INT2(s,&t,T_PARAM_CLIENT_VERSION,LOGIN_VERSION * 100);
add_field_string(s,&t,T_PARAM_OS_IDENTITY,s->osname);
add_field_string(s,&t,T_PARAM_OS_VERSION,s->osrelease);
add_field_INT2(s,&t,T_PARAM_REASON_CODE,reason);
send_transaction(s,authsocket,&t);
transactiontype = receive_transaction(s,authsocket,&t);
if(transactiontype != T_MSG_AUTH_RESP)
{
s->critical("logic error");
}
if(!extract_valueINT2(s,&t,T_PARAM_HASH_METHOD,&s->hashmethod))
{
s->critical("AUTH: no hashmethod");
}
if(!extract_valuestring(s,&t,T_PARAM_NONCE,s->nonce))
{
s->critical("Auth: no nonce");
}
if(s->hashmethod == T_AUTH_MD5_HASH)
{
genmd5(s->password,strlen(s->password),s->password);
}
start_transaction(&t,T_MSG_LOGOUT_AUTH_RESP,s->sessionid);
s->timestamp = time(NULL);
makecredentials(credentials,s,T_MSG_LOGOUT_AUTH_RESP,s->timestamp);
add_field_data(s,&t,T_PARAM_AUTH_CREDENTIALS,credentials,16);
add_field_INT4(s,&t,T_PARAM_TIMESTAMP,s->timestamp);
send_transaction(s,authsocket,&t);
transactiontype = receive_transaction(s,authsocket,&t);
if(transactiontype != T_MSG_LOGOUT_RESP)
{
s->critical("logic error");
}
extract_valueINT2(s,&t,T_PARAM_STATUS_CODE,&s->retcode);
switch(s->retcode)
{
case T_STATUS_SUCCESS:
case T_STATUS_LOGOUT_SUCCESSFUL_ALREADY_DISCONNECTED:
break;
case T_STATUS_USERNAME_NOT_FOUND:
s->critical("Login failure: username not known");
case T_STATUS_INCORRECT_PASSWORD:
s->critical("Login failure: incorrect password");
case T_STATUS_ACCOUNT_DISABLED:
s->critical("Login failure: disabled");
case T_STATUS_LOGIN_RETRY_LIMIT:
case T_STATUS_USER_DISABLED:
case T_STATUS_FAIL_USERNAME_VALIDATE:
case T_STATUS_FAIL_PASSWORD_VALIDATE:
case T_STATUS_LOGIN_UNKNOWN:
s->critical("Login failure: other error");
}
extract_valueINT2(s,&t,T_PARAM_LOGOUT_SERVICE_PORT,&s->logoutport);
extract_valueINT2(s,&t,T_PARAM_STATUS_SERVICE_PORT,&s->statusport);
extract_valuestring(s,&t,T_PARAM_TSMLIST,s->tsmlist);
extract_valuestring(s,&t,T_PARAM_RESPONSE_TEXT,s->resptext);
logintime = time(NULL);
s->debug(0,"Logged out successful at %s",asctime(localtime(&logintime)));
closesocket(authsocket);
return 1;
}
CURLcode Curl_connecthost(struct connectdata *conn, /* context */
struct Curl_dns_entry *remotehost, /* use this one */
int port, /* connect to this */
int *sockconn, /* the connected socket */
Curl_ipconnect **addr, /* the one we used */
bool *connected) /* really connected? */
{
struct SessionHandle *data = conn->data;
int rc;
int sockfd=-1;
int aliasindex=0;
char *hostname;
struct timeval after;
struct timeval before = Curl_tvnow();
/*************************************************************
* Figure out what maximum time we have left
*************************************************************/
long timeout_ms=300000; /* milliseconds, default to five minutes */
*connected = FALSE; /* default to not connected */
if(data->set.timeout || data->set.connecttimeout) {
double has_passed;
/* Evaluate in milliseconds how much time that has passed */
has_passed = Curl_tvdiff(Curl_tvnow(), data->progress.start);
#ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
/* get the most strict timeout of the ones converted to milliseconds */
if(data->set.timeout && data->set.connecttimeout) {
if (data->set.timeout < data->set.connecttimeout)
timeout_ms = data->set.timeout*1000;
else
timeout_ms = data->set.connecttimeout*1000;
}
else if(data->set.timeout)
timeout_ms = data->set.timeout*1000;
else
timeout_ms = data->set.connecttimeout*1000;
/* subtract the passed time */
timeout_ms -= (long)has_passed;
if(timeout_ms < 0) {
/* a precaution, no need to continue if time already is up */
failf(data, "Connection time-out");
return CURLE_OPERATION_TIMEOUTED;
}
}
hostname = data->change.proxy?conn->proxyhost:conn->hostname;
infof(data, "About to connect() to %s%s%s:%d\n",
conn->bits.ipv6_ip?"[":"",
hostname,
conn->bits.ipv6_ip?"]":"",
port);
#ifdef ENABLE_IPV6
/*
* Connecting with IPv6 support is so much easier and cleanly done
*/
{
struct addrinfo *ai;
port =0; /* prevent compiler warning */
for (ai = remotehost->addr; ai; ai = ai->ai_next, aliasindex++) {
sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (sockfd < 0)
continue;
if(conn->data->set.device) {
/* user selected to bind the outgoing socket to a specified "device"
before doing connect */
CURLcode res = bindlocal(conn, sockfd);
if(res)
return res;
}
/* set socket non-blocking */
Curl_nonblock(sockfd, TRUE);
rc = connect(sockfd, ai->ai_addr, ai->ai_addrlen);
if(-1 == rc) {
int error=Curl_ourerrno();
switch (error) {
case EINPROGRESS:
case EWOULDBLOCK:
#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
/* On some platforms EAGAIN and EWOULDBLOCK are the
* same value, and on others they are different, hence
* the odd #if
*/
case EAGAIN:
#endif
case EINTR:
/* asynchronous connect, wait for connect or timeout */
if(data->state.used_interface == Curl_if_multi)
/* don't hang when doing multi */
timeout_ms = 0;
rc = waitconnect(sockfd, timeout_ms);
break;
case ECONNREFUSED: /* no one listening */
default:
/* unknown error, fallthrough and try another address! */
failf(data, "Failed connect to %s: %d", hostname, error);
break;
}
}
if(0 == rc) {
/* we might be connected, if the socket says it is OK! Ask it! */
int err;
err = socketerror(sockfd);
if ((0 == err) || (EISCONN == err)) {
/* we are connected, awesome! */
*connected = TRUE; /* this is truly a connect */
break;
}
failf(data, "socket error: %d", err);
/* we are _not_ connected, it was a false alert, continue please */
}
else if(2 == rc)
/* waitconnect() returned error */
;
else if(data->state.used_interface == Curl_if_multi) {
/* When running the multi interface, we bail out here */
rc = 0;
break;
}
/* connect failed or timed out */
sclose(sockfd);
sockfd = -1;
/* get a new timeout for next attempt */
after = Curl_tvnow();
timeout_ms -= Curl_tvdiff(after, before);
if(timeout_ms < 0) {
failf(data, "connect() timed out!");
return CURLE_OPERATION_TIMEOUTED;
}
before = after;
continue;
}
if (sockfd < 0)
return CURLE_COULDNT_CONNECT;
/* leave the socket in non-blocking mode */
if(addr)
*addr = ai; /* the address we ended up connected to */
}
#else
/*
* Connecting with IPv4-only support
*/
if(!remotehost->addr->h_addr_list[0]) {
/* If there is no addresses in the address list, then we return
error right away */
failf(data, "no address available");
return CURLE_COULDNT_CONNECT;
}
/* create an IPv4 TCP socket */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(-1 == sockfd) {
failf(data, "couldn't create socket");
return CURLE_COULDNT_CONNECT; /* big time error */
}
if(conn->data->set.device) {
/* user selected to bind the outgoing socket to a specified "device"
before doing connect */
CURLcode res = bindlocal(conn, sockfd);
if(res)
return res;
}
/* Convert socket to non-blocking type */
Curl_nonblock(sockfd, TRUE);
/* This is the loop that attempts to connect to all IP-addresses we
know for the given host. One by one. */
for(rc=-1, aliasindex=0;
rc && (struct in_addr *)remotehost->addr->h_addr_list[aliasindex];
aliasindex++) {
struct sockaddr_in serv_addr;
/* do this nasty work to do the connect */
memset((char *) &serv_addr, '\0', sizeof(serv_addr));
memcpy((char *)&(serv_addr.sin_addr),
(struct in_addr *)remotehost->addr->h_addr_list[aliasindex],
sizeof(struct in_addr));
serv_addr.sin_family = remotehost->addr->h_addrtype;
serv_addr.sin_port = htons((unsigned short)port);
rc = connect(sockfd, (struct sockaddr *)&serv_addr,
sizeof(serv_addr));
if(-1 == rc) {
int error=Curl_ourerrno();
switch (error) {
case EINPROGRESS:
case EWOULDBLOCK:
#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
/* On some platforms EAGAIN and EWOULDBLOCK are the
* same value, and on others they are different, hence
* the odd #if
*/
case EAGAIN:
#endif
/* asynchronous connect, wait for connect or timeout */
if(data->state.used_interface == Curl_if_multi)
/* don't hang when doing multi */
timeout_ms = 0;
rc = waitconnect(sockfd, timeout_ms);
break;
default:
/* unknown error, fallthrough and try another address! */
failf(data, "Failed to connect to %s IP number %d: %d",
hostname, aliasindex+1, error);
break;
}
}
/* The '1 == rc' comes from the waitconnect(), and not from connect().
We can be sure of this since connect() cannot return 1. */
if((1 == rc) && (data->state.used_interface == Curl_if_multi)) {
/* Timeout when running the multi interface, we return here with a
CURLE_OK return code. */
rc = 0;
break;
}
if(0 == rc) {
int err = socketerror(sockfd);
if ((0 == err) || (EISCONN == err)) {
/* we are connected, awesome! */
*connected = TRUE; /* this is a true connect */
break;
}
/* nope, not connected for real */
rc = -1;
}
if(0 != rc) {
/* get a new timeout for next attempt */
after = Curl_tvnow();
timeout_ms -= Curl_tvdiff(after, before);
if(timeout_ms < 0) {
failf(data, "Connect timeout on IP number %d", aliasindex+1);
break;
}
before = after;
continue; /* try next address */
}
break;
}
if(0 != rc) {
/* no good connect was made */
sclose(sockfd);
*sockconn = -1;
failf(data, "Connect failed");
return CURLE_COULDNT_CONNECT;
}
/* leave the socket in non-blocking mode */
if(addr)
/* this is the address we've connected to */
*addr = (struct in_addr *)remotehost->addr->h_addr_list[aliasindex];
#endif
/* allow NULL-pointers to get passed in */
if(sockconn)
*sockconn = sockfd; /* the socket descriptor we've connected */
return CURLE_OK;
}
CURLcode Curl_is_connected(struct connectdata *conn,
int sockfd,
bool *connected)
{
int rc;
struct SessionHandle *data = conn->data;
*connected = FALSE; /* a very negative world view is best */
if(data->set.timeout || data->set.connecttimeout) {
/* there is a timeout set */
/* Evaluate in milliseconds how much time that has passed */
long has_passed = Curl_tvdiff(Curl_tvnow(), data->progress.start);
/* subtract the most strict timeout of the ones */
if(data->set.timeout && data->set.connecttimeout) {
if (data->set.timeout < data->set.connecttimeout)
has_passed -= data->set.timeout*1000;
else
has_passed -= data->set.connecttimeout*1000;
}
else if(data->set.timeout)
has_passed -= data->set.timeout*1000;
else
has_passed -= data->set.connecttimeout*1000;
if(has_passed > 0 ) {
/* time-out, bail out, go home */
failf(data, "Connection time-out");
return CURLE_OPERATION_TIMEOUTED;
}
}
if(conn->bits.tcpconnect) {
/* we are connected already! */
*connected = TRUE;
return CURLE_OK;
}
/* check for connect without timeout as we want to return immediately */
rc = waitconnect(sockfd, 0);
if(0 == rc) {
int err = socketerror(sockfd);
if ((0 == err) || (EISCONN == err)) {
/* we are connected, awesome! */
*connected = TRUE;
return CURLE_OK;
}
/* nope, not connected for real */
failf(data, "Connection failed, socket error: %d", err);
return CURLE_COULDNT_CONNECT;
}
else if(1 != rc) {
int error = Curl_ourerrno();
failf(data, "Failed connect to %s:%d, errno: %d",
conn->hostname, conn->port, error);
return CURLE_COULDNT_CONNECT;
}
/*
* If the connection phase is "done" here, we should attempt to connect
* to the "next address" in the Curl_hostaddr structure that we resolved
* before. But we don't have that struct around anymore and we can't just
* keep a pointer since the cache might in fact have gotten pruned by the
* time we want to read this... Alas, we don't do this yet.
*/
return CURLE_OK;
}
/*
** Main processing loop. Logs in, handles heartbeats, and logs out on request
**
** Returns - 0 - We are no longer connected, and should not retry.
** 1 - We are no longer connnected and should retry.
*/
int mainloop(struct session * s)
{
int err;
struct sockaddr_in listenaddr;
struct hostent * he;
int addrsize;
int sockoptval = 1;
s->lastheartbeat = 0;
s->sequence = 0;
if((s->listensock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
{
socketerror(s,"Error creating listen socket");
return 0;
}
if(setsockopt(s->listensock, SOL_SOCKET, SO_REUSEADDR, &sockoptval, sizeof(sockoptval)) < 0)
{
socketerror(s,"Error setting listen socket options");
closesocket(s->listensock);
return 0;
}
s->localaddr.sin_family = AF_INET;
s->localaddr.sin_port = htons(s->localport);
if(strcmp(s->localaddress,""))
{
s->debug(0,"Using local address %s\n",s->localaddress);
he = gethostbyname(s->localaddress);
if(he)
{
s->localaddr.sin_addr.s_addr = *((int*)(he->h_addr_list[0]));
}
else
{
s->localaddr.sin_addr.s_addr = inet_addr(s->localaddress);
}
}
else
{
s->localaddr.sin_addr.s_addr = INADDR_ANY;
}
addrsize = sizeof(struct sockaddr_in);
err = bind(s->listensock,(struct sockaddr *)&s->localaddr,sizeof(s->localaddr));
if(err)
{
socketerror(s,"Error binding listen socket");
closesocket(s->listensock);
return 0;
}
err = getsockname(s->listensock,(struct sockaddr *)&listenaddr,&addrsize);
if(err)
{
socketerror(s,"Error getting listen socket name");
closesocket(s->listensock);
return 0;
}
s->sessionid = time(NULL);
s->listenport = ntohs(listenaddr.sin_port);
strcpy(s->osname,"whocares");
strcpy(s->osrelease,"notme");
he = gethostbyname(s->authserver);
if(he)
{
s->authhost.sin_addr.s_addr = *((int*)(he->h_addr_list[0]));
}
else
{
s->authhost.sin_addr.s_addr = inet_addr(s->authserver);
}
s->authhost.sin_port = htons(s->authport);
s->authhost.sin_family = AF_INET;
s->debug(0,"Auth host = %s:%d\n",s->authserver,s->authport);
s->debug(0,"Listening on port %d\n",s->listenport);
if(login(s))
{
s->onconnected(s->listenport);
if(!handle_heartbeats(s))
{
int i;
s->ondisconnected(1);
s->noncritical("Sleeping for 60 seconds");
for(i=0;i<60;i++)
{
if(s->shutdown) {
closesocket(s->listensock);
return 0;
}
else
sleep(1);
}
}
else
{
closesocket(s->listensock);
return 0;
}
closesocket(s->listensock);
}
else
{
int i;
s->noncritical("Sleeping for 60 seconds");
for(i=0;i<60;i++)
{
if(s->shutdown) {
closesocket(s->listensock);
return 0;
}
else
sleep(1);
}
closesocket(s->listensock);
}
return 1;
}
