int main(int argc, char* argv[]) {
int port;
int serverSocket, clientSocket;
struct httpParams httpParam;
system("clear");
if (argc != 2) {
fprintf(stderr, "Usage: %s <Server Port>\n", argv[0]);
exit(1);
}
port = atoi(argv[1]);
serverSocket = initializeServer(port);
while(1) {
clientSocket = getRequest(serverSocket);
readFromClient(clientSocket);
httpParam = prepareGetQuery();
sendToClient(clientSocket, httpParam);
exit(1);
}
}
void mySocket(int myfd, char ** readBuff, int * bufLen)
{
int ClientConn;
unsigned int sinsize;
struct sockaddr_in addrClient;
sinsize = sizeof(struct sockaddr_in);
if((ClientConn = accept(myfd,(struct sockaddr *)&addrClient, &sinsize)) == -1)
{
perror("server accept() error!");
exit(1);
}
readFromClient(ClientConn,readBuff,bufLen);
write(ClientConn,*readBuff,*bufLen);
close(ClientConn);
return;
}
bool WorkStation::qt_invoke( int _id, QUObject* _o )
{
switch ( _id - staticMetaObject()->slotOffset() ) {
case 0: updateTimer(); break;
case 1: status(); break;
case 2: user(); break;
case 3: connectionClosedByClient(); break;
case 4: readFromClient(); break;
case 5: socketError((int)static_QUType_int.get(_o+1)); break;
case 6: sendCommand(); break;
case 7: sendCommandTime(); break;
case 8: blockSlot(); break;
case 9: delayBlocked(); break;
case 10: wakeUp(); break;
case 11: connectionTimeout(); break;
default:
return QObject::qt_invoke( _id, _o );
}
return TRUE;
}
int ClientDefinitions::receiveClientMessage( char* readString )
{
bool lastCharWasCR = false;
bool lastCharWasLF = false;
int readStringIndex = 0;
unsigned char crlfCount = 0;
// empty readString
memset( readString, NULL, CLIENT_BUFFER_LENGTH );
while ( client.available( ) )
{
readFromClient( readString, &lastCharWasCR, &lastCharWasLF, &readStringIndex, &crlfCount );
//Serial.print( "readFromClient result: " );
//Serial.println( readString );
}
Serial.println( "Successfully read message." );
Serial.print("Free ram: ");
Serial.println(freeRam());
return readStringIndex;
}
void Communicator::handleClientConnection(int socket)
{
mSocket = socket;
int keep_alive = 1;
struct timeval timeout;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
if (setsockopt (mSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
syslog(LOG_ERR, "RCVTIMEO setsockopt failed");
if (setsockopt (mSocket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
syslog(LOG_ERR, "SNDTIMEO setsockopt failed");
// if (setsockopt (mSocket, SOL_SOCKET, TCP_USER_TIMEOUT, &keep_alive, sizeof(int)) < 0 )
// syslog(LOG_ERR, "KEEPALIVE setsockopt failed");
if (setsockopt(mSocket, SOL_SOCKET, SO_KEEPALIVE, &keep_alive, sizeof(int)) < 0)
syslog(LOG_ERR, "KEEPALIVE setsockopt failed");
// send welcome message
sendWelcomeMessage();
while(true) {
if (!readFromClient()) {
syslog(LOG_ERR, "Stoping client");
break;
}
}
sleep(2);
closeUsbDevice();
close(mSocket);
}
void* connection_handler(void *arg){
tdata_t* data = (tdata_t*)arg;
int sockfd = -1;
int clientsock = 0;
int * x = NULL;
char* buffer = NULL;
char* key = NULL;
priqueue_t *queue = data->queue, *jobs = data->jobs;
sem_t* semaphore = data->sem;
while(!done) {
sem_wait(semaphore);
if(done)
break;
pthread_mutex_lock(&job_mutex);
x = (int*)priqueue_delete_min(jobs);
pthread_mutex_unlock(&job_mutex);
if(x == NULL)
continue;
sockfd = *x;
if(sockfd == -1) {
free(x);
continue;
}
/* Recv request from client */
buffer = readFromClient(sockfd);
if(buffer == NULL || done) {
closeSocket(sockfd);
if(buffer != NULL)
free(buffer);
free(x);
if(!done)
continue;
break;
}
key = requestToKey(buffer);
/* Check cache and serve if possible */
if(checkCache(sockfd, queue, key) || done) {
closeSocket(sockfd);
free(key);
free(buffer);
free(x);
if(!done)
continue;
break;
}
/* Parse request for host since not in cache */
clientsock = initHostRequest(buffer);
if(clientsock == -1 || done) {
free(buffer);
free(key);
free(x);
closeSocket(sockfd);
if(!done)
continue;
break;
}
/* Actually get the data from the server */
processHostRequest(buffer, key, data->queue, clientsock, sockfd);
closeSocket(clientsock);
closeSocket(sockfd);
free(key);
free(buffer);
free(x);
}
return NULL;
}
/* service traffic from clients and drivers */
void
indiRun(void)
{
fd_set rs, ws;
int maxfd=0;
int i, s;
/* init with no writers or readers */
FD_ZERO(&ws);
FD_ZERO(&rs);
if (fifo.name && fifo.fd >=0)
{
FD_SET(fifo.fd, &rs);
maxfd = fifo.fd;
}
/* always listen for new clients */
FD_SET(lsocket, &rs);
if (lsocket > maxfd)
maxfd = lsocket;
/* add all client readers and client writers with work to send */
for (i = 0; i < nclinfo; i++) {
ClInfo *cp = &clinfo[i];
if (cp->active) {
FD_SET(cp->s, &rs);
if (nFQ(cp->msgq) > 0)
FD_SET(cp->s, &ws);
if (cp->s > maxfd)
maxfd = cp->s;
}
}
/* add all driver readers and driver writers with work to send */
for (i = 0; i < ndvrinfo; i++)
{
DvrInfo *dp = &dvrinfo[i];
if (dp->active)
{
FD_SET(dp->rfd, &rs);
if (dp->rfd > maxfd)
maxfd = dp->rfd;
if (dp->pid != REMOTEDVR)
{
FD_SET(dp->efd, &rs);
if (dp->efd > maxfd)
maxfd = dp->efd;
}
if (nFQ(dp->msgq) > 0)
{
FD_SET(dp->wfd, &ws);
if (dp->wfd > maxfd)
maxfd = dp->wfd;
}
}
}
/* wait for action */
s = select (maxfd+1, &rs, &ws, NULL, NULL);
if (s < 0) {
fprintf (stderr, "%s: select(%d): %s\n", indi_tstamp(NULL), maxfd+1,
strerror(errno));
Bye();
}
/* new command from FIFO? */
if (s > 0 && fifo.fd >= 0 && FD_ISSET(fifo.fd, &rs))
{
newFIFO();
s--;
}
/* new client? */
if (s > 0 && FD_ISSET(lsocket, &rs)) {
newClient();
s--;
}
/* message to/from client? */
for (i = 0; s > 0 && i < nclinfo; i++) {
ClInfo *cp = &clinfo[i];
if (cp->active) {
if (FD_ISSET(cp->s, &rs)) {
if (readFromClient(cp) < 0)
return; /* fds effected */
s--;
}
if (s > 0 && FD_ISSET(cp->s, &ws)) {
if (sendClientMsg(cp) < 0)
return; /* fds effected */
s--;
}
}
}
/* message to/from driver? */
for (i = 0; s > 0 && i < ndvrinfo; i++) {
DvrInfo *dp = &dvrinfo[i];
if (dp->pid != REMOTEDVR && FD_ISSET(dp->efd, &rs)) {
if (stderrFromDriver(dp) < 0)
return; /* fds effected */
s--;
}
if (s > 0 && FD_ISSET(dp->rfd, &rs)) {
if (readFromDriver(dp) < 0)
return; /* fds effected */
s--;
}
if (s > 0 && FD_ISSET(dp->wfd, &ws) && nFQ(dp->msgq) > 0) {
if (sendDriverMsg(dp) < 0)
return; /* fds effected */
s--;
}
}
}
void
getEntry(int *team, int *stype)
{
int switching = -1; /* confirm switches 7/27/91 TC */
inputMask = CP_OUTFIT;
for (;;) {
/* updateShips so he knows how many players on each team */
if (blk_flag)
updateShips();
sendMaskPacket(tournamentMask(me->p_team));
if (blk_flag)
briefUpdateClient();
flushSockBuf();
/* Have we been busted? */
if (me->p_status == PFREE) {
me->p_status = PDEAD;
me->p_explode = 600;
}
socketPause();
readFromClient();
if (isClientDead()) {
int i;
if (noressurect)
exitGame();
printf("Ack! The client went away!\n");
printf("I will attempt to resurrect him!\n");
/* UDP fail-safe */
commMode = COMM_TCP;
if (udpSock >= 0)
closeUdpConn();
/* For next two minutes, we try to restore connection */
shutdown(sock, 2);
sock = -1;
for (i = 0;; i++) {
switch (me->p_status) {
case PFREE:
me->p_status = PDEAD;
me->p_explode = 600;
break;
case PALIVE:
case POBSERVE:
me->p_ghostbuster = 0;
break;
case PDEAD:
me->p_explode = 600;
break;
default:
me->p_explode = 600;
me->p_ghostbuster = 0;
break;
}
sleep(5);
if (connectToClient(host, nextSocket))
break;
if (i == 23) {
printf("Oh well, maybe I'm getting rusty!\n");
switch (me->p_status) {
case PFREE:
break;
case PALIVE:
case POBSERVE:
me->p_ghostbuster = 100000;
break;
case PDEAD:
me->p_explode = 0;
break;
default:
me->p_explode = 0;
me->p_ghostbuster = 100000;
break;
}
exitGame();
}
}
printf("A miracle! He's alive!\n");
teamPick = -1;
updateSelf();
updateShips();
flushSockBuf();
}
if (teamPick != -1) {
if (teamPick < 0 || teamPick > 3) {
warning("Get real!");
sendPickokPacket(0);
teamPick = -1;
continue;
}
if (!(tournamentMask(me->p_team) & (1 << teamPick))) {
warning("I cannot allow that. Pick another team");
sendPickokPacket(0);
teamPick = -1;
continue;
}
if (((1 << teamPick) != me->p_team) &&
(me->p_team != ALLTEAM)) /* switching teams 7/27/91 TC */
if ((switching != teamPick)
&& (me->p_whydead != KGENOCIDE)
&& !status2->league
) {
switching = teamPick;
warning("Please confirm change of teams. Select the new team again.");
sendPickokPacket(0);
teamPick = -1;
continue;
}
/* His team choice is ok. */
if (shipPick < 0 || shipPick >= NUM_TYPES) {
warning("That is an illegal ship type. Try again.");
sendPickokPacket(0);
teamPick = -1;
continue;
}
if (!allowed_ship(1 << teamPick, mystats->st_rank, mystats->st_royal, shipPick)) {
sendPickokPacket(0);
teamPick = -1;
continue;
}
if (shipvals[shipPick].s_nflags & SFNMASSPRODUCED) {
warning("o)utpost, u)tility, or s)tandard?");
sendPickokPacket(0);
tmpPick = shipPick;
continue;
}
break;
}
if (me->p_status == PTQUEUE) {
if (status->tourn)
detourneyqueue();
/* You don't time out on the tourney queue */
me->p_ghostbuster = 0;
}
}
*team = teamPick;
if ((shipvals[tmpPick].s_nflags & SFNMASSPRODUCED) &&
((shipvals[shipPick].s_numports) || (shipPick == SCOUT))) {
*stype = tmpPick;
tmpPick = CRUISER;
}
else {
*stype = shipPick;
tmpPick = CRUISER;
}
sendPickokPacket(1);
flushSockBuf();
}
