void ElevatorController::waitForGDRequest() {
char* request;
try {
request = receiveTCP(MAX_GD_REQUEST_SIZE);
}
catch (Exception e) {
rt_printf("GD comm failed for EC%d, enabling supervisor thread\n", (unsigned int)this->getID());
this->eStat.setGDFailed(true);
return;
}
char requestType = request[0];
switch (requestType) {
case STATUS_REQUEST:
// rt_printf("EC%d: Status Request\n", (unsigned int)this->getID());
this->sendStatus();
break;
case HALL_CALL_ASSIGNMENT:
rt_printf("EC%d: Received hall call for floor %d in %s direction\n",
(unsigned int)this->getID(), (unsigned int)request[HCA_FLOOR_INDEX],
((request[HCA_DIRECTION_INDEX] == DIRECTION_DOWN) ? "downward" : "upward"));
this->addHallCall(request[HCA_FLOOR_INDEX], request[HCA_DIRECTION_INDEX]);
break;
default:
rt_printf("EC%d: Unknown Message Type\n", (unsigned int)this->getID());
}
}
/*DEPRECATED*/
static status
ListenMovie(FILE *fd,char *port,char *ticket)
{
int passive_s,ssock;
unsigned long total_packets;
unsigned long n_packet;
boolean exit;
download_t header;
download_start_t start;
void *packet;
void *data;
u_size size;
u_size header_size;
/* Preparo el puerto que va a escuchar la conexion */
if( (passive_s=prepareTCP(client_host,port,prepareServer)) < 0 ) {
return FATAL_ERROR;
}
if( (listenTCP(passive_s,10)) < 0 ) {
return FATAL_ERROR;
}
/* Mando la senial al server pidiendo el inicio de la descarga */
strcpy(start.port,port);
strcpy(start.ip,client_host);
strcpy(start.ticket,ticket);
size = GetDownloadStartData(start, &data);
if( SendSignal(__DOWNLOAD_START_OK__, data, size) == ERROR )
return ERROR;
free(data);
exit = FALSE;
n_packet = 0;
ssock=acceptTCP(passive_s);
while (!exit) {
/* Recibo un paquete */
packet = receiveTCP(ssock);
if(packet==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
header_size = GetDownloadPack(packet,&header);
/* Lo bajo a disco */
PutFileData(fd,_FILE_SIZE_, header.n_packet,packet+header_size,header.size);
/* Verifico la cantidad total de paquetes a descargar */
total_packets = header.total_packets;
free(packet);
n_packet++;
/* Me fijo si llego a la cantidad total de paquetes bajados */
if( n_packet >= total_packets )
exit = TRUE;
}
closeTCP(ssock);
closeTCP(passive_s);
return OK;
}
/*-------------------------------------------------------------------------------------------------------------------------------------
FUNCTION: ServerRoutine
INTERFACE: void CALLBACK ServerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags)
RETURNS: void
NOTES: Gets called when there is an I/O request on the socket. Checks for control information and EOF on the socket, and
normal packet data. Once data is received, it is written to a file for analysis
--------------------------------------------------------------------------------------------------------------------------------------*/
void CALLBACK ServerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags)
{
DWORD RecvBytes = 0, Index;
DWORD Flags = 0;
WSAEVENT EventArray[1] = { 0 };
WSAEVENT acceptEvent;
// Reference the WSAOVERLAPPED structure as a SOCKET_INFORMATION structure
LPSOCKET_INFORMATION SI = (LPSOCKET_INFORMATION)Overlapped;
initSockInfo(SI, SI->Buffer, DATA_BUFSIZE);
if (Error != 0)
{
int i = WSAGetLastError();
formatMessage("I/O operation failed");
}
if (checkControlFormat(SI))
{
formatMessage("Initial Packet Received");
sscanf(SI->DataBuf.buf, "%*s %d %d", &fileInfo->sizeOfPackets, &fileInfo->numberOfPackets);
QueryPerformanceFrequency(&fileInfo->frequency);
QueryPerformanceCounter(&fileInfo->startTimeStamp);
}
if (checkEOFFormat(SI))
{
formatMessage("Final Packet Received");
exitThread = true;
QueryPerformanceCounter(&fileInfo->endTimeStamp);
fileInfo->protocol = protocol;
return;
}
initSockInfo(SI, SI->Buffer, fileInfo->sizeOfPackets);
//UDP
if (protocol == UDP)
{
if ((acceptEvent = WSACreateEvent()) == WSA_INVALID_EVENT)
{
formatMessage("WSACreateEvent() failed");
ExitThread(1);
}
Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, 2000, TRUE);
if (Index == WSA_WAIT_TIMEOUT)
{
formatMessage("Timeout in UDP Server");
exitThread = true;
return;
}
receiveUDP(SI, serverUDP, BytesTransferred, Flags);
}
if (protocol == TCP)
receiveTCP(SI, RecvBytes, Flags);
//Gather data
logCommStats(SI, fileInfo, BytesTransferred);
fwrite(SI->DataBuf.buf, sizeof(char), SI->DataBuf.len, serverFP);
}
static unsigned long
SendRequest(u_size op_code,u_size total_objects,void *packet, u_size size)
{
header_t header;
void *to_send;
int socket;
int ret;
ack_t *ack_ptr;
void *data;
u_size header_size;
/* Tipo de pedido */
header.opCode = op_code;
header.total_objects = total_objects;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &data);
/* Concateno los paquetes header y pedido */
if( (to_send = malloc(header_size+size)) == NULL )
return CONNECT_ERROR;
memmove(to_send, data, header_size);
free(data);
/* Chequeo si realmente se manda un paquete asociado al pedido */
if( packet != NULL ) {
memmove(to_send+header_size, packet, size);
}
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return CONNECT_ERROR;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return TIMEOUT_ERROR;
}
/* Espero por la respuesta del servidor */
ack_ptr = receiveTCP(socket);
if(ack_ptr==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
ret = ack_ptr->ret_code;
free(ack_ptr);
/* Cierro la conexion????? */
close(socket);
return ret;
}
/*-------------------------------------------------------------------------------------------------------------------------------------
FUNCTION: TCPWorkerThread
INTERFACE: DWORD WINAPI TCPWorkerThread(LPVOID lpParameter)
RETURNS: DWORD
NOTES: Waits for a connect request from a client. The accept call is called, the function will assume that there is
data waiting on the socket and then call the completion routine.
--------------------------------------------------------------------------------------------------------------------------------------*/
DWORD WINAPI TCPWorkerThread(LPVOID lpParameter)
{
DWORD Flags = 0;
LPSOCKET_INFORMATION SocketInfo;
WSAEVENT EventArray[1];
DWORD Index;
DWORD RecvBytes = 0;
// Save the accept event in the event array.
EventArray[0] = (WSAEVENT)lpParameter;
while (TRUE)
{
while (TRUE)
{
Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, WSA_INFINITE, TRUE);
if (Index == WSA_WAIT_FAILED)
{
formatMessage("WSAWaitForMultipleEvents failed");
return FALSE;
}
if (Index != WAIT_IO_COMPLETION)
{
// An accept() call event is ready - break the wait loop
break;
}
if (Index == WAIT_IO_COMPLETION && exitThread == true)
{
formatMessage("Server Terminating");
exitThread = false;
closesocket(SocketInfo->Socket);
logDataFile(fileInfo);
free(fileInfo);
fclose(serverFP);
WSACleanup();
return TRUE;
}
}
WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
// Create a socket information structure to associate with the accepted socket.
if ((SocketInfo = (LPSOCKET_INFORMATION)GlobalAlloc(GPTR, sizeof(SOCKET_INFORMATION))) == NULL)
{
formatMessage("GlobalAlloc() failed");
return FALSE;
}
// Fill in the details of our accepted socket.
SocketInfo->Socket = acceptSocket;
initSockInfo(SocketInfo, SocketInfo->Buffer, DATA_BUFSIZE);
receiveTCP(SocketInfo, RecvBytes, Flags);
}
GlobalFree(SocketInfo);
}
static download_header_t
SendDownloadRequest(void *packet, u_size size)
{
header_t header;
void *to_send;
int socket;
download_header_t download_info;
void *data;
u_size header_size;
void *ack_data;
download_info.ret_code = CONNECT_ERROR;
/* Tipo de pedido */
header.opCode = __DOWNLOAD__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &data);
/* Concateno los paquetes header y pedido */
if( (to_send = malloc(header_size+size)) == NULL )
return download_info;
memmove(to_send, data, header_size);
memmove(to_send+header_size, packet, size);
free(data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return download_info;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return download_info;
}
/* Espero por la respuesta del servidor */
ack_data = receiveTCP(socket);
if(ack_data==NULL)
{
close(socket);
return download_info;
}
GetDownloadHeaderPack(ack_data, &download_info);
/* Cierro la conexion????? */
close(socket);
return download_info;
}
int main (int argc, char* argv[]){
int n;
int udp = 1;
if (argc == 2){
udp = 0;
}
if(udp){
printf("UDP\n");
n=receiveUDP();
if(n!=0){
printf("receiveUDP error %d\n", n);
}
}
else{
printf("TCP\n");
n=receiveTCP();
if(n!=0){
printf("receiveTCP error %d\n", n);
}
}
return 0;
}
static int
SendListMoviesRequest(void *data, u_size size, movie_t ***out_ptr)
{
header_t header;
header_t ack_header;
void *ack_movies;
void *to_send;
void * ackHeader;
int socket;
void *header_data;
u_size header_size;
/* Tipo de pedido */
header.opCode = __LIST_MOVIES_BY_GEN__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &header_data);
/* Concateno los paquetes header y pedido */
if( (to_send = malloc(header_size+size)) == NULL )
return CONNECT_ERROR;
memmove(to_send, header_data, header_size);
free(header_data);
/* Chequeo si realmente se manda un paquete asociado al pedido */
memmove(to_send+header_size, data, size);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return -1;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return TIMEOUT_ERROR;
}
/* Espero por la respuesta del servidor */
ackHeader=receiveTCP(socket);
if(ackHeader==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
GetHeaderPack(ackHeader,&ack_header);
fflush(stdout);
if( ack_header.opCode == __LIST_OK__ ) {
ack_movies = receiveTCP(socket);
if(ack_movies==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
*out_ptr = GetMovies(ack_movies,ack_header.total_objects);
free(ack_movies);
}
else
ack_header.total_objects = 0;
close(socket);
return ack_header.total_objects;
}
static int
SendListUsersRequest(client_t ***out_ptr)
{
header_t header;
header_t ack_header;
void *ack_users;
void * ackHeader;
int socket;
void *header_data;
u_size header_size;
char * decripted;
/* Tipo de pedido */
header.opCode = __LIST_USERS__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &header_data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(header_data);
return -1;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, header_data,header_size);
free(header_data);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return -1;
}
/* Espero por la respuesta del servidor */
ackHeader=receiveTCP(socket);
if(ackHeader==NULL)
{
close(socket);
return -1;
}
GetHeaderPack(ackHeader,&ack_header);
if( ack_header.opCode == __LIST_USERS_OK__ ) {
ack_users = receiveTCP(socket);
if(ack_users==NULL)
{
close(socket);
return -1;
}
decripted=Decypher(ack_users,ack_header.total_objects*(MAX_USER_LEN+MAX_USER_MAIL+MAX_USER_DESC+sizeof(unsigned char)),log_passwd);
*out_ptr = GetUsersList(decripted,ack_header.total_objects);
free(decripted);
free(ack_users);
}
else {
if( ack_header.opCode == __USER_ACCESS_DENY__ || ack_header.opCode == __USER_IS_NOT_LOG__ )
return -2;
else
return -1;
}
close(socket);
return ack_header.total_objects;
}
static int
SendListGensRequest(list_movie_request_t ***out_ptr)
{
header_t header;
header_t ack_header;
void *ack_gens;
void * dataAux;
int socket;
void *header_data;
u_size header_size;
/* Tipo de pedido */
header.opCode = __LIST_GENS__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &header_data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(header_data);
return -1;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, header_data,header_size);
free(header_data);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return -1;
}
/* Espero por la respuesta del servidor */
dataAux=receiveTCP(socket);
if(dataAux==NULL)
{
close(socket);
return -1;
}
GetHeaderPack(dataAux,&ack_header);
if( ack_header.opCode == __LIST_OK__ ) {
ack_gens = receiveTCP(socket);
if(ack_gens==NULL)
{
close(socket);
return -1;
}
*out_ptr = GetGenList(ack_gens,ack_header.total_objects);
free(ack_gens);
}
else {
return -1;
}
close(socket);
return ack_header.total_objects;
}
static status
NewDownload(int ssock)
{
unsigned long total_packets;
unsigned long n_packet;
boolean exit;
download_t header;
void *packet;
char name[MAX_MOVIE_LEN];
u_size header_size;
FILE *fd;
/* Recibo el primer paquete */
n_packet = 0;
exit = FALSE;
packet = receiveTCP(ssock);
if(packet==NULL)
{
raise(SIGINT);
}
header_size = GetDownloadPack(packet,&header);
fd = fopen(header.title,"wb+");
strcpy(name,header.title);
/* Lo bajo a disco */
PutFileData(fd,_FILE_SIZE_, header.n_packet,packet+header_size,header.size);
/* Verifico la cantidad total de paquetes a descargar */
total_packets = header.total_packets;
free(packet);
n_packet++;
/* Me fijo si llego a la cantidad total de paquetes bajados */
if( n_packet >= total_packets )
exit = TRUE;
while (!exit) {
/* Recibo un paquete */
fflush(0);
packet = receiveTCP(ssock);
if(packet==NULL)
{
raise(SIGINT);
}
header_size = GetDownloadPack(packet,&header);
/* Lo bajo a disco */
PutFileData(fd,_FILE_SIZE_, header.n_packet,packet+header_size,header.size);
/* Verifico la cantidad total de paquetes a descargar */
total_packets = header.total_packets;
free(packet);
n_packet++;
/* Me fijo si llego a la cantidad total de paquetes bajados */
if( n_packet >= total_packets )
exit = TRUE;
}
printf("Termine de transmitir %s\n",name);
fclose(fd);
closeTCP(ssock);
return OK;
}
