Advertisement
LA77

Untitled

May 19th, 2025
581
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 4.07 KB | None | 0 0
  1. #include <arpa/inet.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <stdbool.h>
  8.  
  9. struct Transfer {
  10.     char request;
  11.     char filename[64];
  12.     int fileSize;
  13. };
  14.  
  15. struct TransferResponse {
  16.     char response;
  17.     int fileSize;
  18. };
  19.  
  20. int main(int argc, char** argv){
  21.    
  22.     char ip[16];
  23.     int port;
  24.  
  25.     scanf("%s %d", ip, &port); // reading the IP and PORT
  26.  
  27.     struct sockaddr_in serverAdress;
  28.     memset(&serverAdress, 0, sizeof(serverAdress));
  29.    
  30.     serverAdress.sin_family = AF_INET; // IPv4
  31.     serverAdress.sin_port = htons(port); // convert port to network byte order
  32.     serverAdress.sin_addr.s_addr = inet_addr(ip);
  33.  
  34.     /// Creating a TCP socket
  35.     int sock = socket(AF_INET, SOCK_STREAM, 0);
  36.     int connectionResult = connect(sock, (struct sockaddr*)&serverAdress, sizeof(serverAdress));
  37.  
  38.     if(connectionResult < 0) {printf("Connection failed :<");}
  39.    
  40.     while(true)
  41.     {
  42.         char b1; scanf("%c", &b1);
  43.         char operation;
  44.         scanf("%c", &operation);
  45.  
  46.         if(operation == 'D')
  47.         {
  48.             char buff;
  49.             scanf("%c", &buff); // reading the space
  50.  
  51.             char filename[64];
  52.             scanf("%s", filename);
  53.  
  54.             struct Transfer t;
  55.             memset(&t, 0, sizeof(t));
  56.             t.request = operation;
  57.             strcpy(t.filename, filename);
  58.             t.fileSize = 0;
  59.  
  60.             // Sending a transfer request to the server            
  61.             send(sock, &t, sizeof(t), 0);
  62.  
  63.             struct TransferResponse r;
  64.             recv(sock, &r, sizeof(r), 0);
  65.  
  66.             if(r.response == 'N')
  67.             {
  68.                 printf("File %s does not exist on server.\n", filename);
  69.                 continue;
  70.             }
  71.  
  72.             // receiving the file content
  73.             char buffer[1024];
  74.             int bytesR = 0;
  75.             if(!(r.fileSize <= 0 || r.fileSize > 1024))
  76.             {
  77.                 bytesR = recv(sock, buffer, r.fileSize, 0);
  78.             }
  79.  
  80.             FILE *dwn = fopen(filename, "w");
  81.             fwrite(buffer, sizeof(char), bytesR, dwn);
  82.             fclose(dwn);
  83.             buffer[bytesR] = '\0';
  84.             printf("File %s downloaded.\n", filename);
  85.             printf("%s\n", buffer);
  86.         }
  87.         if(operation == 'U')
  88.         {
  89.             char buff;
  90.             scanf("%c", &buff); // skip space
  91.  
  92.             char filename[64];
  93.             scanf("%s", filename);
  94.  
  95.             // Open file to read content
  96.             FILE* file = fopen(filename, "r");
  97.             if (!file)
  98.             {
  99.                 printf("File %s not found.\n", filename);
  100.                 continue;
  101.             }
  102.  
  103.             // Determine file size
  104.             fseek(file, 0, SEEK_END);
  105.             int fileSize = ftell(file);
  106.             rewind(file); // reset pointer to beginning
  107.  
  108.             // Read file content into buffer
  109.             char buffer[1024];
  110.             fread(buffer, sizeof(char), fileSize, file);
  111.             fclose(file);
  112.  
  113.             // Prepare Transfer struct
  114.             struct Transfer t = {0};
  115.             t.request = 'U';
  116.             strcpy(t.filename, filename);
  117.             t.fileSize = fileSize;
  118.  
  119.             // Send Transfer struct
  120.             send(sock, &t, sizeof(t), 0);
  121.  
  122.             // Receive server response
  123.             struct TransferResponse r;
  124.             recv(sock, &r, sizeof(r), 0);
  125.  
  126.             if (r.response == 'N') {
  127.                 printf("File %s already exists on server.\n", filename);
  128.                 continue;
  129.             }
  130.  
  131.             // Send file content
  132.             send(sock, buffer, fileSize, 0);
  133.             printf("File %s uploaded.\n", filename);
  134.  
  135.         }
  136.         if(operation == 'C')
  137.         {
  138.             struct Transfer t;
  139.             memset(&t, 0, sizeof(t));
  140.             t.request = operation;
  141.             strcpy(t.filename, "");
  142.             t.fileSize = 0;
  143.             send(sock, &t, sizeof(t), 0);
  144.             close(sock);
  145.  
  146.             break;
  147.         }
  148.     }
  149.    
  150.     return 0;
  151. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement