#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>

#define PORT htons(21212)

void ObsluzPolaczenie(int gn) //ServeConnection
{
    char sciezka[512]; //path (for a file)
    long dl_pliku, wyslano, wyslano_razem, przeczytano;
    struct stat fileinfo;
    FILE* plik; //file
    unsigned char bufor[1024]; //buffer
    
    memset(sciezka, 0, 512); //path
    if (recv(gn, sciezka, 512, 0) <= 0)
    {
	printf("Potomny: blad przy odczycie sciezki\nChild (process): error while reading a path\n");
	return;
    }
    
    printf("Potomny: klient chce plik (Child: client wants a file) %s\n", sciezka);
    
    if (stat(sciezka, &fileinfo) < 0)
    {
	printf("Potomny: nie moge pobrac informacji o pliku\n(Child: I can't obtain information about a file)\n");
	return;
    }
    
    if (fileinfo.st_size == 0)
    {
	printf("Potomny: rozmiar pliku (child: filesize) 0\n");
	return;
    }
    
    printf("Potomny: dlugosc pliku (child: filesize): %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 (error at sending a file)\n");
	return;
    }
    
    dl_pliku = fileinfo.st_size;
    wyslano_razem = 0;
    plik = fopen(sciezka, "rb");
    if (plik == NULL)
    {
	printf("Potomny: blad przy otwarciu pliku (error at opening a file)\n");
	return;
    }
    
    while (wyslano_razem < dl_pliku)
    {
	przeczytano = fread(bufor, 1, 1024, plik);
	wyslano = send(gn, bufor, przeczytano, 0); //sent, buffer, read
	if (przeczytano != wyslano) //read (received) !=sent
	    break;
	wyslano_razem += wyslano;
	printf("Potomny: wyslano %ld bajtow (total sent)\n", wyslano_razem);
    }
    
    if (wyslano_razem == dl_pliku)
	printf("Potomny: plik wyslany poprawnie (child: file sent ok)\n");
    else
	printf("Potomny: blad przy wysylaniu pliku (child: file sending error)\n"); //error at se
    fclose(plik);
    return;    
}


int main(void)
{
    int gn_nasluch, gn_klienta; //gn_listen, gn_of_the_client
    struct sockaddr_in adr;
    socklen_t dladr = sizeof(struct sockaddr_in);
    
    gn_nasluch = socket(PF_INET, SOCK_STREAM, 0);
    adr.sin_family = AF_INET;
    adr.sin_port = PORT;
    adr.sin_addr.s_addr = INADDR_ANY;
    memset(adr.sin_zero, 0, sizeof(adr.sin_zero));
    
    if (bind(gn_nasluch, (struct sockaddr*) &adr, dladr) < 0)
    {
	printf("Glowny: bind nie powiodl sie (Parent: bind failed)\n");
	return 1;
    }
    
    listen(gn_nasluch, 10);
    
    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 (Parent: accept error)\n");
	    continue;
	}
	printf("Glowny: polaczenie od (Parent: connection from) %s:%u\n", 
	    inet_ntoa(adr.sin_addr),
	    ntohs(adr.sin_port)
	    );
	printf("Glowny: tworze proces potomny (Parent: I'm creating child process)\n");
	if (fork() == 0)
	{
	    /* proces potomny */
	    printf("Potomny: zaczynam obsluge (Child: start serving)\n");
	    ObsluzPolaczenie(gn_klienta);
	    printf("Potomny: zamykam gniazdo (Child: closing socket)\n");
	    close(gn_klienta);
	    printf("Potomny: koncze proces (Child: end of the process)\n");
	    exit(0);
	}
	else
	{
	    /* proces macierzysty */
	    printf("Glowny: wracam do nasluchu (parent: return to listening)\n");
	    continue;
	}
    }
    return 0;
}