SHARE
TWEET

Untitled

a guest Jun 18th, 2017 72 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <fcntl.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  7. #include <string.h>
  8. #include <arpa/inet.h>
  9. #include <sys/socket.h>
  10. #include <errno.h>
  11.  
  12. #define PUERTO 6666
  13. #define MAX_USER 100
  14. #define MAX_PASS 300
  15. #define MAX 512
  16.  
  17. ssize_t read_n(int fd, void*datos, int n);
  18. ssize_t write_n(int fd, void*datos, int n);
  19.  
  20. ssize_t copiaf (char* fich_destino, char* fich_origen, char*usuario, char*contrasena);
  21.  
  22. int main(int argc, char*argv[])
  23. {
  24.     if(argc<5){
  25.         printf("Uso %s <dest> <orig> <user> <pass>\n", argv[0]);
  26.         exit(1);
  27.     }
  28.    
  29.     //Variables
  30.     int sockfd;
  31.     int long_user = strlen(argv[3]);
  32.     int long_pass = strlen(argv[4]);
  33.     int retorno;
  34.     uint32_t longBE;
  35.     struct sockaddr_in destino;
  36.     socklen_t addrlen = sizeof(destino);
  37.    
  38.     //Preparamos la direccion de memoria
  39.     memset((char*)&destino, 0, sizeof(destino));
  40.     destino.sin_family = AF_INET;
  41.     destino.sin_port = htons(PUERTO);
  42.    
  43.     //Abrimos el socket
  44.     if((sockfd=socket(PF_INET, SOCK_STREAM, 0))<0){
  45.         perror("socket");
  46.         exit(1);
  47.     }
  48.    
  49.     //Metemos la direccion IP
  50.     uint32_t dir = inet_addr("127.0.0.1");
  51.     memcpy(&destino.sin_addr, &dir, 4);
  52.    
  53.     //Nos conectamos al servidor
  54.    
  55.     if(connect(sockfd, (struct sockaddr*)&destino, addrlen)<0){
  56.         perror("connect");
  57.         close(sockfd);
  58.         exit(1);
  59.     }
  60.    
  61.     //Enviamos longitud y user
  62.    
  63.     longBE = htonl(long_user);
  64.    
  65.     if(write_n(sockfd, &longBE, sizeof(longBE))!=sizeof(longBE)){
  66.         perror("write long user");
  67.         close(sockfd);
  68.         exit(1);
  69.     }
  70.    
  71.    
  72.     if(write_n(sockfd, argv[3], long_user)!= long_user){
  73.         perror("write user");
  74.         close(sockfd);
  75.         exit(1);
  76.     }
  77.    
  78.     //Recibimos el retorno del user
  79.    
  80.     if(read_n(sockfd, &longBE, sizeof(longBE))!=sizeof(longBE)){
  81.         perror("read ret user");
  82.         close(sockfd);
  83.         exit(1);
  84.     }
  85.    
  86.     retorno = ntohl(longBE);
  87.    
  88.     if(retorno==-1){
  89.         printf("El user no se encuentra en el sistema\n");
  90.         close(sockfd);
  91.         exit(1);
  92.     }else{
  93.         printf("Se envía la contraseña\n");
  94.        
  95.         //Enviamos longitud y contraseña
  96.         longBE = htonl(long_pass);
  97.        
  98.         if(write_n(sockfd, &longBE, sizeof(longBE))!=sizeof(longBE)){
  99.             perror("write long pass");
  100.             close(sockfd);
  101.             exit(1);
  102.         }
  103.        
  104.         if(write_n(sockfd, argv[4], long_pass)!=long_pass){
  105.             perror("write pass");
  106.             close(sockfd);
  107.             exit(1);
  108.         }
  109.        
  110.         //Recibimos el retorno de la contraseña
  111.        
  112.         if(read_n(sockfd, &longBE, sizeof(longBE))!=sizeof(longBE)){
  113.             perror("read ret pass");
  114.             close(sockfd);
  115.             exit(1);
  116.         }
  117.        
  118.         retorno = ntohl(longBE);
  119.        
  120.         if(retorno==-1){
  121.             printf("La contraseña no coincide con el user\n");
  122.             close(sockfd);
  123.             exit(1);
  124.         }else{
  125.             printf("Se procede a hacer una copia de los ficheros\n");
  126.             retorno = copiaf(argv[1], argv[2], argv[3], argv[4]);
  127.             if(retorno>0){
  128.                 printf("Se han copiado %d bytes\n", retorno);
  129.             }
  130.            
  131.             if(close(sockfd)<0){
  132.                 perror("close");
  133.                 exit(1);
  134.             }
  135.            
  136.         }
  137.        
  138.        
  139.     }//else de haber metido bien el user
  140.     return 0;
  141. }
  142.  
  143. ssize_t read_n(int fd, void*datos, int n)
  144. {
  145.     ssize_t totalLeidos = 0;
  146.     ssize_t intentandoLeer = n;
  147.     ssize_t leidos;
  148.     do{
  149.         errno = 0;
  150.         leidos=read(fd, totalLeidos + datos, intentandoLeer);
  151.         if(leidos>0){
  152.             totalLeidos += leidos;
  153.             intentandoLeer -= leidos;
  154.         }
  155.     }while(((totalLeidos <n)&&(leidos>0))||(errno==EINTR));
  156.    
  157.     if(leidos<0){
  158.         return leidos;
  159.     }else{
  160.         return totalLeidos;
  161.     }
  162. }
  163.  
  164. ssize_t write_n(int fd, void*datos, int n)
  165. {
  166.     ssize_t totalLeidos = 0;
  167.     ssize_t intentandoLeer = n;
  168.     ssize_t leidos;
  169.     do{
  170.         errno = 0;
  171.         leidos=write(fd, totalLeidos + datos, intentandoLeer);
  172.         if(leidos>0){
  173.             totalLeidos += leidos;
  174.             intentandoLeer -= leidos;
  175.         }
  176.     }while(((totalLeidos <n)&&(leidos>0))||(errno==EINTR));
  177.    
  178.     if(leidos<0){
  179.         return leidos;
  180.     }else{
  181.         return totalLeidos;
  182.     }
  183. }
  184.  
  185. ssize_t copiaf (char* fich_destino, char* fich_origen, char*usuario, char*contrasena)
  186. {
  187.     ssize_t copiados = 0;
  188.     int ret = -1;
  189.    
  190.     //Abrimos los ficheros
  191.    
  192.     int fdest = open(fich_destino, O_WRONLY|O_TRUNC|O_CREAT, 0644);
  193.    
  194.     if(fdest<0){
  195.         perror("open dest");
  196.         exit(1);
  197.     }
  198.    
  199.     int forig = open(fich_origen, O_RDONLY);
  200.    
  201.     if(forig<0){
  202.         perror("open origen");
  203.         exit(1);
  204.     }
  205.    
  206.     //Leemos del fichero de claves
  207.    
  208.     FILE * file = fopen("claves.txt", "r");
  209.    
  210.     //printf("Se ha abierto todo\n");
  211.    
  212.     char linea[500];
  213.     char buffer[MAX];
  214.     char *user;
  215.     char *pass;
  216.    
  217.     while((fgets(linea, 500-1, file)!=NULL)){
  218.        
  219.         linea[strlen(linea)-1] = '\0';
  220.         //printf("%s\n", linea);
  221.        
  222.         char*puntero = strstr(linea, "@");
  223.         *puntero = '\0';
  224.         user = linea;
  225.         pass = puntero + 1;
  226.        
  227.         if(strcmp(usuario,user)==0){
  228.             //printf("%s %s\n", pass, contrasena);
  229.             if(strcmp(pass, contrasena)!=0){
  230.                 ret = -2;
  231.             }else{
  232.                 int leidos;
  233.                 do{
  234.                     leidos = read(forig, buffer, MAX);
  235.                     if(leidos<0){
  236.                         perror("read orig");
  237.                         exit(1);
  238.                     }
  239.                    
  240.                     int escritos= write(fdest, buffer, leidos);
  241.                     if(escritos<0){
  242.                         perror("write dest");
  243.                         exit(1);
  244.                     }
  245.                    
  246.                     copiados+=escritos;
  247.                    
  248.                 }while(leidos>0);
  249.                
  250.                 ret = copiados;
  251.                 break;
  252.             }
  253.         }
  254.     }
  255.    
  256.     return ret;
  257. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top