int main(int argc, char *argv[]){
if (argc == 3){ // Nome do arquivo (argv[0]) mais os dois parâmetros
char entrada[40] = "entrada/";
char saida[40] = "saida/";
int k; // Instâncias de palavras
char *palavra;
palavra = (char *) malloc (MAXCHAR * sizeof(char));
int tamPalavra;
Matriz estados; // Matriz n x 2, onde n é o tamanho da string e possui dois estados, o atual e o anterior.
strcat(entrada,argv[1]);
strcat(saida,argv[2]);
FILE * inp = abreArquivoLeitura(entrada);
FILE * out = abreArquivoEscrita(saida);
fscanf(inp, "%d ", &k); // Lê as k instâncias de problemas
for (int l=0; l<k; l++){
fscanf(inp,"%s\n",palavra);
tamPalavra = strlen(palavra);
criaMatriz(2,tamPalavra+1,&estados);
preencheMatriz(0,&estados); // Preenche matriz toda com 0
fprintf(out,"%d\n",lcs(palavra, tamPalavra, &estados));
//imprimeMatriz(estados);
destroiMatriz(&estados);
}
free(palavra);
fechaArquivo(inp);
fechaArquivo(out);
}
else{
printf("Número incorreto de parâmetros. Fazer seguir exemplo:\n\n\t./tp2 input.txt output.txt\n\n"); exit(0);
}
return 0;
}
int main(void) {
int sock;
int porta;
metadados_t id;
struct sockaddr_in cliente;
FILE *fp;
char nomeArquivo[TAMNOME];
char nomeServidor[TAMNOME];
struct hostent *hp;
int tamArquivo;
int tamSocket = sizeof (cliente);
printf("Entre com a porta de conexão\n");
scanf (" %d", &porta);
printf("Entre com o caminho do arquivo a ser enviado\n");
setbuf (stdin, NULL);
scanf(" %[^\n]", nomeArquivo);
printf("Entre com o nome que o arquivo vai receber no servidor\n");
setbuf (stdin, NULL);
scanf(" %[^\n]", nomeServidor);
printf("\nServidor: %s", IP);
printf(":%d\n", porta);
printf("Arquivo enviado: %s\n", nomeArquivo);
fp = abrirArquivo(nomeArquivo);
tamArquivo = tamanhoArquivo(fp);
/**
* Os dados do arquivo a ser enviado são alocados
* na struct correspondente.
*/
strcpy(id.nome, nomeServidor);
id.tamanho = tamArquivo;
/**
* Criação do socket para comunicão entre cliente e servidor
*/
sock = criaSocket();
/**
* Configurando o endereço do socket do servidor.
*/
cliente.sin_family = AF_INET;
/**
* Estabelecimento de conexão se o cliente e servidor estiverem
* rodando no mesmo computador.
*/
if (strcmp(IP, "localhost") == 0) {
if (strcmp(nomeArquivo, nomeServidor) == 0) {
perror("Tentativa de sobreescrever o arquivo no mesmo computador!\n");
fechaArquivo(fp);
fechaSocket(sock);
exit(1);
}
/**
* Pega o endereço de IP de 32-bit do host
* por frescurite pode entrar com o dominio em vez do IP
*/
hp = gethostbyname(IP);
if (hp == 0) {
perror("FALHA ao pegar endereço de IP!");
fechaArquivo(fp);
fechaSocket(sock);
exit(1);
}
//Se estamos aqui deu tudo certo com IP do servidor
memcpy(&cliente.sin_addr, hp->h_addr, hp->h_length);
} else {
/**
* Estabelecimento de conexão se o cliente e servidor estiverem
* rodando em computadores diferentes.
*/
cliente.sin_addr.s_addr = inet_addr(IP);
}
/**
* Vinculando a porta informada ao socket do cliente.
*/
cliente.sin_port = htons(porta);
/**
* Enviando os dados para o servidor.
*/
if (sendto(sock, &id, sizeof (id), 0, (struct sockaddr *) &cliente, tamSocket) <= 0) {
perror("Falha ao enviar!");
fechaArquivo(fp);
fechaSocket(sock);
exit(1);
}
printf("\nChecando o estabelecimento de conexão: enviando %s ", id.nome);
printf("com %d bytes\n", id.tamanho);
/**
* Enviando o arquivo
*/
enviarArquivo(fp, sock, cliente);
/**
* O arquivo foi transferido com sucesso.
* Todos os arquivos e sockets são fechados.
*/
printf("\nO arquivo foi enviado com sucesso!\n");
fechaArquivo(fp);
fechaSocket(sock);
return 0;
}
int main(void) {
metadados_t id;
int sock;
struct sockaddr_in servidor;
int mysock;
int porta;
char buff[5];
int rval;
FILE *fp;
segmentos_t segmento;
ack_t ack_msg;
unsigned tamSocket = sizeof (servidor);
int seqNum = 1;
/**
* Enquanto não for informada uma porta válida,
* o servidor ficará impedido de ser ativado.
*/
printf("Entre com o valor da porta para conexão\n");
scanf (" %d", &porta);
/**
* Criação do socket para comunicão entre cliente e servidor.
*/
sock = criaSocket();
/**
* Setando as opoções para permitir que uma porta seja
* reutilizada, logo após o servidor ser fechado.
*/
int reuseAddr = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuseAddr, sizeof (reuseAddr)) == -1) {
perror("ERRO ao setar as opções do socket!\n");
fechaSocket(sock);
exit(-1);
}
/**
* Configurando o endereço do socket do servidor.
*/
memset((void *) &servidor, 0, sizeof (servidor));
servidor.sin_family = AF_INET;
servidor.sin_port = htons(porta);
servidor.sin_addr.s_addr = htonl(INADDR_ANY);
/**
* Vinculando a porta informada ao socket do servidor.
*/
if (bind(sock, (struct sockaddr *) &servidor, sizeof (servidor)) == -1) {
perror("FALHA ao vincular a porta ao socket!");
fechaSocket(sock);
exit(-1);
}
printf("Aguardando por conexão...\n\n");
/**
* Os dados de cabeçalho são enviados para a criação do novo arquivo.
* @param nome [nome do novo arquivo]
* @param tamanho [tamanho do novo arquivo]
*/
mysock = sock;
if ((rval = recvfrom(mysock, &id, sizeof (id), 0, (struct sockaddr *) &servidor, &tamSocket)) < 0) {
perror("ERRO ao ler o fluxo de mensagens!\n");
} else if (rval == 0) {
printf("Finalizando conexão...\n");
} else {
printf("MSG RECEBIDA -->[arquivo]: %s ", id.nome);
printf("- [tamanho]: %d bytes\n", id.tamanho);
}
/**
* De fato aqui o novo arquivo é criado no servidor.
*/
memset(buff, 0, sizeof (buff));
printf("Copia do arquivo iniciada...\n\n");
fp = criaArquivo(id.nome);
int read_bytes = 0;
/**
* Finalmente iniciamos o envido dos pacotes do cliente para o servidor.
*/
while (read_bytes < id.tamanho) {
fd_set select_fds; /* fd's usado por select */
struct timeval timeout; /* Valor de tempo para timeout */
/* -----------------------------------------
Setando a descrição para o select()
----------------------------------------- */
FD_ZERO(&select_fds); /* Limpando o fd's */
FD_SET(mysock, &select_fds); /* Setando o bit que corresponde ao socket */
/* -----------------------------------------
Setando o valor do timeout
----------------------------------------- */
timeout.tv_sec = 5; /* Timeout setado para 5 segundos + 0 micro segundos*/
timeout.tv_usec = 0;
printf("Esperando pela mensagem...\n");
/**
* Espera pela mensagem do cliente.
*/
if (select(32, &select_fds, NULL, NULL, &timeout) == 0) {
/**
* [TEMPORIZADOR]
* Perda de conexão.
* O tempo maximo permitido é de 5 segundos;
*/
printf("\nO temporizador estourou!\nFALHA na transferência do arquivo!\n\n");
fechaArquivo(fp);
fechaSocket(mysock);
exit(1);
} else {
rval = recvfrom(mysock, &segmento, sizeof (segmento), 0,
(struct sockaddr *) &servidor, &tamSocket);
}
if (rval < 0) {
perror("ERRO ao ler o fluxo de mensagens!\n");
} else if (rval == 0) {
printf("Finalizando conexão...\n");
} else {
unsigned int x = checksum(segmento.buff, segmento.tamanho);
/**
* Se o checksum calculado for o mesmo que o checksum recebido,
* enviamos um ACK para o pacote correspondente.
*/
printf("Checksum calculado : %d\n", x);
printf("MSG VÁLIDA %d recebida: ", segmento.seqNum);
printf("tamanho:%d ", segmento.tamanho);
printf("checksum:%d\n", segmento.checksum);
ack_msg.seqNum = seqNum; // número de sequencia esperado
ack_msg.limite = segmento.limite; // temporizador
/**
* Tentamos enviar o pacote pelo numero de sequência solicitado.
*/
if ((x == segmento.checksum) && (segmento.seqNum == seqNum)) {
ack_msg.flag = 0;
++seqNum;
/**
* Enviando ACK de confirmação ao cliente.
*/
printf("Enviando ACK %d\n", ack_msg.seqNum);
if ((rval = sendto(mysock, &ack_msg, sizeof (ack_msg), 0,
(struct sockaddr *) &servidor, tamSocket)) < 0) {
perror("ERRO ao ler o fluxo de mensagens!\n");
} else if (rval == 0) {
printf("Finalizando conexão...\n");
} else {
/**
* Gravação dos bytes que vem dos pacotes no arquivo no servidor.
*/
fwrite(&segmento.buff[0], segmento.tamanho, 1, fp);
printf("ACK ENVIADO.\n\n");
read_bytes += segmento.tamanho;
}
/**
* Caso o pacote tenha sido perdido, é feita a solicitação novamente.
* E também é iniciado o temporizador.
*/
} else {
ack_msg.flag = 1;
printf("PACOTE PERDIDO OU DEFEITUOSO...\n");
ack_msg.seqNum -= 1;
if (ack_msg.limite <= (TENTE - 1)) {
printf("Reenviando ACK %d - ", ack_msg.seqNum);
printf("Tentativa %d\n", ack_msg.limite + 1);
if ((rval = sendto(mysock, &ack_msg, sizeof (ack_msg), 0,
(struct sockaddr *) &servidor, tamSocket)) < 0) {
perror("ERRO ao ler o fluxo de mensagens!\n");
} else if (rval == 0) {
printf("Finalizando conexão...\n");
} else {
printf("ACK REENVIADO.\n\n");
}
} else {
printf("\nO temporizador estourou!\n FALHA na transferência do arquivo!\n");
fechaArquivo(fp);
fechaSocket(mysock);
return 0;
}
}
}
}
/**
* O arquivo foi transferido com sucesso.
* Todos os arquivos e sockets são fechados.
*/
printf("Cópia do arquivo completada com sucesso!\n");
fechaArquivo(fp);
fechaSocket(mysock);
return 0;
}
int main(int argc, char *argv[]){
if (argc == 3){ // Nome do arquivo (argv[0]) mais os dois parâmetros
char entrada[40] = "entrada/";
char saida[40] = "saida/";
int k; // instâncias a serem simuladas
int tam_mem_fis, tam_pagina, n_acessos; // tamanho (em bytes) da memória física, de cada página e o número n de acessos
int num_paginas; // Quantas páginas a memória primária terá
int posicao_acessada;
TipoCelula pagina_atual;
strcat(entrada,argv[1]);
strcat(saida,argv[2]);
FILE * inp = abreArquivoLeitura(entrada);
FILE * out = abreArquivoEscrita(saida);
fscanf(inp, "%d ", &k); // Lê as k instâncias de problemas
for (int l=0; l<k; l++){
fscanf(inp, "%d %d %d\n", &tam_mem_fis, &tam_pagina, &n_acessos);
num_paginas = tam_mem_fis / tam_pagina; // Num de páginas é a razão do tam da memória com o tamanho de cada página
TipoLista memoria_fifo, memoria_lru, memoria_lfu;
Cria(&memoria_fifo);
Cria(&memoria_lru);
Cria(&memoria_lfu);
memoria_fifo.paginas_livres = num_paginas;
memoria_lru.paginas_livres = num_paginas;
memoria_lfu.paginas_livres = num_paginas;
for (int a=0; a<n_acessos; a++){
fscanf(inp, "%d", &posicao_acessada);
pagina_atual.pagina = posicao_acessada / tam_pagina;
pagina_atual.num_acessos = 1;
FIFO(&memoria_fifo, pagina_atual);
LRU(&memoria_lru, pagina_atual);
LFU(&memoria_lfu, pagina_atual);
}
fprintf(out,"%d ",memoria_fifo.misses);
fprintf(out,"%d ",memoria_lru.misses);
fprintf(out,"%d\n",memoria_lfu.misses);
LiberaLista(&memoria_fifo);
LiberaLista(&memoria_lru);
LiberaLista(&memoria_lfu);
}
fechaArquivo(inp);
fechaArquivo(out);
}
}
