Projekt_SIK/server/server.c

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
//Połączenia z wieloma klientami
void ObsluzPolaczenie(int gn)
{
    char sciezka[512];
    long dl_pliku, wyslano, wyslano_razem, przeczytano;
    struct stat fileinfo;
    FILE* plik;
    unsigned char bufor[1024];
    
    memset(sciezka, 0, 512);
    if (recv(gn, sciezka, 512, 0) <= 0)
    {
        printf("Potomny: blad przy odczycie sciezki\n");
        return;
    }
    
    printf("Potomny: klient chce plik %s\n", sciezka);
    
    if (stat(sciezka, &fileinfo) < 0)
    {
        printf("Potomny: nie moge pobrac informacji o pliku\n");
        return;
    }
    
    if (fileinfo.st_size == 0)
    {
        printf("Potomny: rozmiar pliku 0\n");
        return;
    }
    
    printf("Potomny: dlugosc pliku: %d\n", fileinfo.st_size);
    
    dl_pliku = htonl((long) fileinfo.st_size);
    
    if (send(gn, &dl_pliku, sizeof(long), 0) != sizeof(long))
    {
        printf("Potomny: blad przy wysylaniu wielkosci pliku\n");
        return;
    }
    
    dl_pliku = fileinfo.st_size;
    wyslano_razem = 0;
    plik = fopen(sciezka, "rb");
    if (plik == NULL)
    {
        printf("Potomny: blad przy otwarciu pliku\n");
        return;
    }
    
    while (wyslano_razem < dl_pliku)
    {
        przeczytano = fread(bufor, 1, 1024, plik);
        wyslano = send(gn, bufor, przeczytano, 0);
        if (przeczytano != wyslano)
            break;
        wyslano_razem += wyslano;
        printf("Potomny: wyslano %d bajtow\n", wyslano_razem);
    }
    
    if (wyslano_razem == dl_pliku)
        printf("Potomny: plik wyslany poprawnie\n");
    else
        printf("Potomny: blad przy wysylaniu pliku\n");
    fclose(plik);
    return;    
  
  	/*
    char Msg[1024];
    char Sciezka[1024];
    
    while (1) {
    	//recv() <- czeka na wiadomość
        memset(Msg, 0, 1024);
        recv(Gniazdo_Klient, Msg, 1024, 0);
        
        //Porównywanie wiadomości
      	If (Msg == "wyślij") {

      	} else (Msg = "pobierz") {
			
      	} else (Msg == "exit") {
        	close(Gniazdo_Klient);
            close(Gniazdo_Server);
        } else {
			//wyślij do wszystkich wiadomość
            //(opconalne)nadpisz plik z historią rozmów - plik tekstowy
            for(each gniazdo in readfs [select]){
            	send(gniazdo,wiadomość, );
            }
      	}
    }
    */
}

//Main Server


int main(void) {
    char bufor[1024]; //wiadomosc
    int gniazdo, gniazdo2;
    struct sockaddr_in adr, nadawca;
    socklen_t dl = sizeof(struct sockaddr_in);
 
    gniazdo = socket(PF_INET, SOCK_STREAM, 0);
    adr.sin_family = AF_INET;
    adr.sin_port = htons(44444); //port
    adr.sin_addr.s_addr = INADDR_ANY;

    printf("Slucham na %s:%d\n", inet_ntoa(adr.sin_addr), ntohs(adr.sin_port));

    if (bind(gniazdo, (struct sockaddr*) &adr, sizeof(adr)) < 0) { //bind
        printf("Bind nie powiodl sie.\n");
        return 1;
    }
    if (listen(gniazdo, 10) < 0) { //listen
        printf("Listen nie powiodl sie.\n");
        return 1; 
    }
    printf("Czekam na polaczenie ...\n");
    while ((gniazdo2 = accept(gniazdo, (struct sockaddr*) &nadawca, &dl)) > 0) { //odbieranie
        memset(bufor, 0, 1024);
        recv(gniazdo2, bufor, 1024, 0);
        printf("Wiadomosc od %s: %s\n", inet_ntoa(nadawca.sin_addr), bufor);
        close(gniazdo2);
    }
  	//Połączenie z wieloma Klientami
  /*
  while(1)
    {
        dladr = sizeof(struct sockaddr_in);
        gn_klienta = accept(gn_nasluch, (struct sockaddr*) &adr, &dladr);
        if (gn_klienta < 0)
        {
            printf("Glowny: accept zwrocil blad\n");
            continue;
        }
        printf("Glowny: polaczenie od %s:%u\n", 
            inet_ntoa(adr.sin_addr),
            ntohs(adr.sin_port)
            );
        printf("Glowny: tworze proces potomny\n");
        if (fork() == 0)
        {
            //proces potomny 
            printf("Potomny: zaczynam obsluge\n");
            ObsluzPolaczenie(gn_klienta);
            printf("Potomny: zamykam gniazdo\n");
            close(gn_klienta);
            printf("Potomny: koncze proces\n");
            exit(0);
        }
        else
        {
            // proces macierzysty
            printf("Glowny: wracam do nasluchu\n");
            continue;
        }
    }
  */
    //Polączenie z wieloma klientami
    
  
    close(gniazdo); 
    return 0; 
}