int main (){
printf("Lora Fabian gateway running...\n");
setup();
while(1){
loop();
checkRequest();
}
return (0);
}
// Do HTTP method.
void UploadFileServlet::doMethod(IHttpServletRequest& request, IHttpServletResponse& response){
if (!checkRequest(request, response)){
return;
}
// Create the file. The current file will be overrided.
std::string name = request.getParameter("file_name");
createFolderForFile(folder + name);
std::ofstream fout;
fout.open(folder + name, std::ofstream::out | std::ofstream::binary);
if (!fout){
response.sendErrorWithMessage(500, "Cannot open the file.");
return;
}
// Read input
bool error = true;
std::istream& in = request.getInputStream();
std::string chunkSizeLine;
std::string tmp;
int chunkSize;
std::getline(in, chunkSizeLine);
char* buf = NULL;
int bufSize = 0;
while (in){
if (!readOneChunk(in, chunkSize, chunkSizeLine, error, buf, bufSize, fout, response)){
break;
}
// Read the next chunk
std::getline(in, chunkSizeLine);
}
if (buf != NULL){
delete buf;
}
// close the file
fout.close();
// Send error if occurred
if (error){
if (!response.isCommitted()){
response.sendErrorWithMessage(400, "Wrong chunked format");
}
// throw an exception to close connection
throw std::logic_error("Wrong chunked format");
}
else{
LOG(INFO) << "Saved the file \"" << folder << name << "\".";
}
}
// PUBLIC METHOD
// triggered by any change to the calibrator request variable
void EyeCalibrator::notifyRequest(const Datum& dictionaryData, MWTime timeUS) {
lock(); // DDC added
// check if this calibrator should respond
bool validRequest = checkRequest(dictionaryData); // base class method (minimal checking)
if (!validRequest){
unlock(); // DDC added
return; // not meant for this calibrator or improperly formatted
}
// determine the requested action
CalibratorRequestedAction requestedAction = getRequestedAction(dictionaryData); // overridable base class method
switch (requestedAction) {
case CALIBRATOR_NO_ACTION:
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Request sent to calibrator %s resulted in no action.", uniqueCalibratorName.c_str());
unlock(); // DDC added
return;
break;
case CALIBRATOR_ACTION_SET_PARAMS_TO_DEFAULTS:
//mwarning(M_SYSTEM_MESSAGE_DOMAIN,
// "Request to update params sent to calibrator %s, BUT METHOD NOT YET WRITTEN. Request ignored.", uniqueCalibratorName);
if (VERBOSE_EYE_CALIBRATORS) mprintf("An eye calibrator is processing a request to set its parameters to defaults.");
setParametersToDefaults();
break;
break;
case CALIBRATOR_ACTION_SET_PARAMS_TO_CONTAINED:
if (VERBOSE_EYE_CALIBRATORS) mprintf("An eye calibrator is processing a request to set its parameters to specific values.");
tryToUseDataToSetParameters(dictionaryData);
break;
}
unlock(); // DDC added
}
/**
*INICIO DO PROGRAMA PRINCIPAL
*/
int main (int argc, char **argv) {
/* Os sockets. Um que será o socket que vai escutar pelas conexões
* e o outro que vai ser o socket específico de cada conexão */
int listenfd, connfd;
/* Informações sobre o socket (endereço e porta) ficam nesta struct */
struct sockaddr_in servaddr;
/* Retorno da função fork para saber quem é o processo filho e quem
* é o processo pai */
pid_t childpid;
/* Armazena linhas recebidas do cliente */
char recvline[MAXLINE + 1];
/* Armazena o tamanho da string lida do cliente */
ssize_t n;
if (argc != 2) {
fprintf(stderr,"Uso: %s <Porta>\n",argv[0]);
fprintf(stderr,"Vai rodar um servidor HTTP <Porta> TCP\n");
exit(1);
}
/* Criação de um socket. Eh como se fosse um descritor de arquivo. Eh
* possivel fazer operacoes como read, write e close. Neste
* caso o socket criado eh um socket IPv4 (por causa do AF_INET),
* que vai usar TCP (por causa do SOCK_STREAM), já que o HTTP
* funciona sobre TCP, e será usado para uma aplicação convencional sobre
* a Internet (por causa do número 0) */
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket :(\n");
exit(2);
}
/* Agora é necessário informar os endereços associados a este
* socket. É necessário informar o endereço / interface e a porta,
* pois mais adiante o socket ficará esperando conexões nesta porta
* e neste(s) endereços. Para isso é necessário preencher a struct
* servaddr. É necessário colocar lá o tipo de socket (No nosso
* caso AF_INET porque é IPv4), em qual endereço / interface serão
* esperadas conexões (Neste caso em qualquer uma -- INADDR_ANY) e
* qual a porta. Neste caso será a porta que foi passada como
* argumento no shell (atoi(argv[1]))
*/
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
perror("bind :(\n");
exit(3);
}
/* Como este código é o código de um servidor, o socket será um
* socket passivo. Para isto é necessário chamar a função listen
* que define que este é um socket de servidor que ficará esperando
* por conexões nos endereços definidos na função bind. */
if (listen(listenfd, LISTENQ) == -1) {
perror("listen :(\n");
exit(4);
}
system("clear");
printf("[Servidor no ar. Aguardando conexoes na porta %s]\n",argv[1]);
printf("[Para finalizar, pressione CTRL+c ou rode um kill ou killall]\n");
/* O servidor no final das contas é um loop infinito de espera por
* conexões e processamento de cada uma individualmente */
for (;;) {
/* O socket inicial que foi criado é o socket que vai aguardar
* pela conexão na porta especificada. Mas pode ser que existam
* diversos clientes conectando no servidor. Por isso deve-se
* utilizar a função accept. Esta função vai retirar uma conexão
* da fila de conexões que foram aceitas no socket listenfd e
* vai criar um socket específico para esta conexão. O descritor
* deste novo socket é o retorno da função accept. */
if ((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) == -1 ) {
perror("accept :(\n");
exit(5);
}
/* Agora o servidor precisa tratar este cliente de forma
* separada. Para isto é criado um processo filho usando a
* função fork. O processo vai ser uma cópia deste. Depois da
* função fork, os dois processos (pai e filho) estarão no mesmo
* ponto do código, mas cada um terá um PID diferente. Assim é
* possível diferenciar o que cada processo terá que fazer. O
* filho tem que processar a requisição do cliente. O pai tem
* que voltar no loop para continuar aceitando novas conexões */
/* Se o retorno da função fork for zero, é porque está no
* processo filho. */
if ( (childpid = fork()) == 0) {
/**** PROCESSO FILHO ****/
printf("[Uma conexao aberta]\n");
/* Já que está no processo filho, não precisa mais do socket
* listenfd. Só o processo pai precisa deste socket. */
close(listenfd);
/* Agora pode ler do socket e escrever no socket. Isto tem
* que ser feito em sincronia com o cliente. Não faz sentido
* ler sem ter o que ler. Ou seja, neste caso está sendo
* considerado que o cliente vai enviar algo para o servidor.
* O servidor vai processar o que tiver sido enviado e vai
* enviar uma resposta para o cliente (Que precisará estar
* esperando por esta resposta)
*/
/* ========================================================= */
/* ========================================================= */
/* EP1 INÍCIO */
/* ========================================================= */
/* ========================================================= */
/* TODO: É esta parte do código que terá que ser modificada
* para que este servidor consiga interpretar comandos HTTP */
/* Definindo o cliente */
Host cliente;
cliente.destino = servaddr;
cliente.socket = connfd;
/* Ler a requisição do cliente*/
Request client_request = readRequest(cliente);
/* Mostrar na tela as requisições dos clientes */
printf("*********************************************************************");
printf("\n [Metodo requisitado]: %s \n", client_request.metodo);
printf("\n [Recurso solicitado]: %s \n", client_request.recurso);
printf("\n [Protocolo]: %s \n", client_request.protocolo);
/* checar a Request do client */
CR_returns returns = checkRequest(cliente, client_request);
/* enviar resposta da requisição para o cliente */
if (strcmp(client_request.metodo,"GET")==0) {
sendGETRequest(cliente, returns);
}
else if (strcmp(client_request.metodo,"POST")==0) {
sendPOSTRequest(cliente, returns,client_request);
}
/* ========================================================= */
/* ========================================================= */
/* EP1 FIM */
/* ========================================================= */
/* ========================================================= */
/* Após ter feito toda a troca de informação com o cliente,
* pode finalizar o processo filho */
printf("[Uma conexao fechada]\n");
exit(0);
}
/**** PROCESSO PAI ****/
/* Se for o pai, a única coisa a ser feita é fechar o socket
* connfd (ele é o socket do cliente específico que será tratado
* pelo processo filho) */
close(connfd);
}
exit(0);
}
//===== Main program =========================================================
int main() {
#ifdef WIN
WORD wVersionRequested = MAKEWORD(1, 1); // Stuff for WSA functions
WSADATA wsaData; // Stuff for WSA functions
#endif
int server_s; // Server socket descriptor
struct sockaddr_in server_addr; // Server Internet address
struct sockaddr_in client_addr; // Client Internet address
int addr_len; // Internet address length
char out_buf[4096]; // Output buffer for data
char in_buf[4096]; // Input buffer for data
int retcode; // Return code
#ifdef WIN
// This stuff initializes winsock
WSAStartup(wVersionRequested, & wsaData);
#endif
// Create a socket
server_s = socket(AF_INET, SOCK_DGRAM, 0);
if (server_s < 0) {
printf("*** ERROR - socket() failed \n");
exit(-1);
}
// Fill-in my socket's address information
server_addr.sin_family = AF_INET; // Address family to use
server_addr.sin_port = htons(PORT_NUM); // Port number to use
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // Listen on any IP address
retcode = bind(server_s, (struct sockaddr * ) & server_addr,
sizeof(server_addr));
if (retcode < 0) {
printf("*** ERROR - bind() failed \n");
exit(-1);
}
FILE *file;
//Loop forever
while (1) {
//open file
file = fopen("usernames.txt", "a+");
// Wait to receive a message from client
printf("Waiting for recvfrom() to complete... \n");
addr_len = sizeof(client_addr);
retcode = recvfrom(server_s, in_buf, sizeof(in_buf), 0, (struct sockaddr * ) & client_addr, & addr_len);
if (retcode < 0) {
printf("*** ERROR - recvfrom() failed \n");
exit(-1);
}
printf(" Received from client: %s \n", in_buf);
char buffer[400];
char *test = buffer;
switch(checkRequest(in_buf))
{
case 1:
if(testString(&in_buf))
{
fprintf(file, "%s\n", in_buf);
sprintf(buffer, "ROK;");
strcpy(out_buf, buffer);
}
else
{
sprintf(buffer, "INU;");
strcpy(out_buf, buffer);
}
break;
case 2:
break;
case 3:
break;
case 4:
break;
}
fclose(file);
// Send out_buf to the client using the server socket
retcode = sendto(server_s, out_buf, (strlen(out_buf) + 1), 0, (struct sockaddr * ) & client_addr, sizeof(client_addr));
if (retcode < 0) {
printf("*** ERROR - sendto() failed \n");
exit(-1);
}
printf(" Sent to client: %s \n", out_buf);
}
// Close all open sockets
#ifdef WIN
retcode = closesocket(server_s);
if (retcode < 0) {
printf("*** ERROR - closesocket() failed \n");
exit(-1);
}
#endif
#ifdef BSD
retcode = close(server_s);
if (retcode < 0) {
printf("*** ERROR - close() failed \n");
exit(-1);
}
#endif
#ifdef WIN
// This stuff cleans-up winsock
WSACleanup();
#endif
// Return zero and terminate
return (0);
}
