示例#1
0
int32
yahoo_io_thread( void * _data )
{
	YahooConnection * conn = (YahooConnection*)_data;
	register_callbacks();

	conn->fID = yahoo_init_with_attributes(conn->fYahooID, conn->fPassword,
				"local_host", "95.252.70.62",
				"pager_port", 5050, NULL);

	LOG("yahoo_io_thread: id: %s, pass: %s\n", conn->fYahooID, conn->fPassword );

	gYahooConnections[conn->fID] = conn;

	yahoo_login(conn->fID, YAHOO_STATUS_AVAILABLE);

	int lfd = 0;

	fd_set inp, outp;
	struct timeval tv;

	while (conn->IsAlive()) {
		snooze(10000);
		FD_ZERO(&inp);
		FD_ZERO(&outp);

		tv.tv_sec=3;
		tv.tv_usec=1E4;
		lfd=0;
		int i;
		
		for(i = 0; i < conn->CountConnections(); i++) {
			struct conn_handler *c = conn->ConnectionAt(i);
			if(c->remove) {
				conn->RemoveConnection(c);
				c->remove = 0;
				free(c);
			} else {
				if(c->cond & YAHOO_INPUT_READ)
					FD_SET(c->con->fd, &inp);
				if(c->cond & YAHOO_INPUT_WRITE)
					FD_SET(c->con->fd, &outp);
				if(lfd < c->con->fd)
					lfd = c->con->fd;
			}
		}

		select(lfd + 1, &inp, &outp, NULL, &tv);
		time(&curTime);

		for(i = 0; i < conn->CountConnections(); i++) {
			struct conn_handler *c = conn->ConnectionAt(i);
			if(c->con->remove) {
				free(c->con);
				c->con = NULL;
				break;
			}
			if(c->remove)
				continue;
			if(FD_ISSET(c->con->fd, &inp))
				yahoo_callback(c, YAHOO_INPUT_READ);
			if(FD_ISSET(c->con->fd, &outp))
				yahoo_callback(c, YAHOO_INPUT_WRITE);
		}

		if(expired(pingTimer))
			yahoo_ping_timeout_callback(conn->fID);
	//	if(expired(webcamTimer))	yahoo_webcam_timeout_callback(webcam_id);
	}
	LOG("Exited loop");

	for(int i = 0; i < conn->CountConnections(); i++) {
		struct conn_handler *c = conn->ConnectionAt(i);
		free(c);
		conn->RemoveConnection(c);
	}
	return 0;
}
示例#2
0
void __cdecl CYahooProto::server_main(void *empty)
{
	enum yahoo_status status = (enum yahoo_status) (int)empty;
	time_t lLastPing, lLastKeepAlive, t;
	YList *l;
	NETLIBSELECTEX nls = { 0 };
	int recvResult, ridx = 0, widx = 0, i;

	debugLogA("Server Thread Starting status: %d", status);

	do_yahoo_debug = YAHOO_LOG_DEBUG;
	yahoo_set_log_level((yahoo_log_level)do_yahoo_debug);

	poll_loop = 1; /* set this so we start looping */

	ext_login(status);

	lLastKeepAlive = lLastPing = time(NULL);

	while (poll_loop) {
		nls.cbSize = sizeof(nls);
		nls.dwTimeout = 1000; // 1000 millis = 1 sec 

		FD_ZERO(&nls.hReadStatus);
		FD_ZERO(&nls.hWriteStatus);
		FD_ZERO(&nls.hExceptStatus);
		nls.hExceptConns[0] = NULL;
		ridx = 0; widx = 0;

		for (l = m_connections; l;) {
			struct _conn *c = (_conn *)l->data;
			//LOG(("Connection tag:%d id:%d fd:%d remove:%d", c->tag, c->id, c->fd, c->remove));
			if (c->remove) {
				YList *n = y_list_next(l);
				//LOG(("Removing id:%d fd:%d tag:%d", c->id, c->fd, c->tag));
				m_connections = y_list_remove_link(m_connections, l);
				y_list_free_1(l);
				FREE(c);
				l = n;
			}
			else {
				if (c->cond & YAHOO_INPUT_READ) {
					//LOG(("[YAHOO_INPUT_READ] Waiting on read. Tag: %d fd: %d", c->tag, c->fd ));
					nls.hReadConns[ridx++] = (HANDLE)c->fd;
				}

				if (c->cond & YAHOO_INPUT_WRITE) {
					//LOG(("[YAHOO_INPUT_WRITE] Waiting on write. Tag: %d fd: %d", c->tag, c->fd ));
					nls.hWriteConns[widx++] = (HANDLE)c->fd;
				}

				l = y_list_next(l);
			}
		}

		//debugLogA("[Yahoo_Server] ridx:%d widx:%d", ridx, widx);

		nls.hReadConns[ridx] = NULL;
		nls.hWriteConns[widx] = NULL;

		if (m_connections == NULL) {
			debugLogA("Last connection closed.");
			break;
		}
		recvResult = CallService(MS_NETLIB_SELECTEX, 0, (LPARAM)&nls);

		/* do the timer check */
		if (m_id > 0) {
#ifdef	HTTP_GATEWAY			
			//debugLogA("HTTPGateway: %d", iHTTPGateway);
			if	(!iHTTPGateway) {
#endif					
				t = time(NULL);

				if (m_bLoggedIn && t - lLastKeepAlive >= 60) {
					LOG(("[TIMER] Sending a keep alive message"));
					yahoo_keepalive(m_id);

					lLastKeepAlive = t;
				}

				if (m_bLoggedIn && t - lLastPing >= 3600) {
					LOG(("[TIMER] Sending ping"));
					yahoo_send_ping(m_id);

					lLastPing = t;
				}

#ifdef HTTP_GATEWAY					
			} else {
				debugLogA("[SERVER] Got packets: %d", ylad->rpkts);

				if ( m_bLoggedIn && ( (ylad->rpkts > 0 && (time(NULL) - lLastSend) >=3) ||
					( (time(NULL) - lLastSend) >= 13)) ) {

					LOG(("[TIMER] Sending an idle message..."));
					yahoo_send_idle_packet(m_id);
				}

				//
				// need to sleep, cause netlibselectex is too fast?
				//
				SleepEx(500, TRUE);
			}
#endif				
		}
		/* do the timer check ends */

		for (l = m_connections; l; l = y_list_next(l)) {
			struct _conn *c = (_conn *)l->data;

			if (c->remove)
				continue;

			/* are we waiting for a Read request? */
			if (c->cond & YAHOO_INPUT_READ) {

				for (i = 0; i < ridx; i++) {
					if ((HANDLE)c->fd == nls.hReadConns[i]) {
						if (nls.hReadStatus[i]) {
							//LOG(("[YAHOO_INPUT_READ] Read Ready. Tag: %d fd: %d", c->tag, c->fd ));
							yahoo_callback(c, YAHOO_INPUT_READ);
						}
					}//if c->fd=
				}//for i = 0

			}

			/* are we waiting for a Write request? */
			if (c->cond & YAHOO_INPUT_WRITE) {

				for (i = 0; i < widx; i++) {
					if ((HANDLE)c->fd == nls.hWriteConns[i]) {
						if (nls.hWriteStatus[i]) {
							//LOG(("[YAHOO_INPUT_WRITE] Write ready. Tag: %d fd: %d", c->tag, c->fd ));
							yahoo_callback(c, YAHOO_INPUT_WRITE);
						}
					} // if c->fd == nls
				}// for i = 0
			}

		}// for l=connections

		/* Check for Miranda Exit Status */
		if (Miranda_Terminated()) {
			debugLogA("Miranda Exiting... stopping the loop.");
			break;
		}
	}
	debugLogA("Exited loop");

	/* cleanup the data stuff and close our connection handles */
	while (m_connections) {
		YList *tmp = m_connections;
		struct _conn * c = (_conn *)m_connections->data;
		Netlib_CloseHandle((HANDLE)c->fd);
		FREE(c);
		m_connections = y_list_remove_link(m_connections, m_connections);
		y_list_free_1(tmp);
	}

	yahoo_close(m_id);

	m_bLoggedIn = FALSE;

	m_status = YAHOO_STATUS_OFFLINE;
	m_id = 0;

	/* now set ourselves to offline */
	BroadcastStatus(ID_STATUS_OFFLINE);
	logoff_buddies();

	debugLogA("Server thread ending");
}
示例#3
0
int32
yahoo_io_thread( void * _data )
{
	YahooConnection * conn = (YahooConnection*)_data;
	
/*	conn->fID = yahoo_init_with_attributes(
		conn->fYahooID, conn->fPassword,
		//"local_host", local_host,
		"pager_port", 23,
		NULL
	);
*/	
	conn->fID = yahoo_init(
		conn->fYahooID, conn->fPassword
	);
	
	LOG(kProtocolName, liDebug, "yahoo_io_thread: id: %s, pass: %s", conn->fYahooID, conn->fPassword );
	
	gYahooConnections[conn->fID] = conn;
	
	yahoo_login( conn->fID, YAHOO_STATUS_AVAILABLE );

	int lfd=0;
	
	fd_set inp, outp;
	struct timeval tv;
	
	LOG(kProtocolName, liDebug, "yahoo_io_thread: Starting loop");
	
	while( conn->IsAlive() ) {
		FD_ZERO(&inp);
		FD_ZERO(&outp);
		tv.tv_sec=1;
		tv.tv_usec=0;
		lfd=0;
		
		for(int i=0; i<conn->CountConnections(); i++) {
			struct fd_conn *c = conn->ConnectionAt(i);
			
			if(c->remove) {
//				LOG(kProtocolName, liDebug, "yahoo_io_thread: Removing id:%d fd:%d", c->id, c->fd);
				conn->RemoveConnection(c);
				free(c);
			} else {
				if(c->cond & YAHOO_INPUT_READ) {
					FD_SET(c->fd, &inp);
				}
				if(c->cond & YAHOO_INPUT_WRITE) {
					FD_SET(c->fd, &outp);
				}
				if(lfd < c->fd)
					lfd = c->fd;
			}
		}
		
		select(lfd + 1, &inp, &outp, NULL, &tv);
		time(&curTime);
		
		for(int i=0; i<conn->CountConnections(); i++) {
			struct fd_conn *c = conn->ConnectionAt(i);
			if(c->remove)
				continue;
			if(FD_ISSET(c->fd, &inp)) {
//				LOG(kProtocolName, liDebug, "yahoo_io_thread: data to read");
				yahoo_callback(c, YAHOO_INPUT_READ);
				FD_CLR(c->fd, &inp);
			}
			if(FD_ISSET(c->fd, &outp)) {
				//LOG(kProtocolName, liDebug, "yahoo_io_thread: data to write");
				yahoo_callback(c, YAHOO_INPUT_WRITE);
				FD_CLR(c->fd, &outp);
			}
		}
		
		if(expired(pingTimer))
			yahoo_ping_timeout_callback(conn->fID, pingTimer);
	}
	LOG(kProtocolName, liDebug, "yahoo_io_thread: Exited loop");
	
	while( conn->CountConnections() > 0 ) {
		struct fd_conn * c = conn->ConnectionAt(0);
		conn->RemoveConnection(c);
		close(c->fd);
		FREE(c);
	}
	
	return 0;
}