[PSI] TCP server & UDP klient

Odpovědět
Uživatelský avatar
Destroyer
VCKLAN TEAM
Příspěvky: 820
Registrován: čtv 13. srp 2009 13:50:15
Bydliště: Praha 12
Kontaktovat uživatele:

TCP server & UDP klient

Příspěvek od Destroyer » pon 23. bře 2015 22:05:49

RESENI, KTERE JSEM ODEVZDAVAL V ROCE 2014, NEPROCHAZI NEKTERYMI TESTY!
sry za priserny code style

TCP SERVER

Kód: Vybrat vše

/* Author: Mirek
* based on pa2 server example
*/

#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

#define MAX_BUFF_SIZE 8196
#define MAX_MESSAGE_SIZE 32

struct TThr
{
	pthread_t  m_Thr;
	int        m_DataFd;
	int positionInBuffer;
	char buffer[MAX_BUFF_SIZE];
        char message[MAX_MESSAGE_SIZE];
	int buffSize;
	TThr() 
	{
		positionInBuffer = 0;
		buffSize = 0;
	}
};


int openSrvSocket(const char * name, int port)
{
	struct addrinfo * ai;
	char portStr[10];

	/* Adresa, kde server posloucha. Podle name se urci typ adresy
	* (IPv4/6) a jeji binarni podoba
	*/
	snprintf(portStr, sizeof(portStr), "%d", port);
	if (getaddrinfo(name, portStr, NULL, &ai))
	{
		printf("addrinfo\n");
		return -1;
	}
	/* Otevreni soketu, typ soketu (family) podle navratove hodnoty getaddrinfo,
	* stream = TCP
	*/
	int fd = socket(ai->ai_family, SOCK_STREAM, 0);
	if (fd == -1)
	{
		freeaddrinfo(ai);
		printf("socket\n");
		return -1;
	}

	/* napojeni soketu na zadane sitove rozhrani
	*/
	if (bind(fd, ai->ai_addr, ai->ai_addrlen) == -1)
	{
		close(fd);
		freeaddrinfo(ai);
		printf("bind\n");
		return -1;
	}
	freeaddrinfo(ai);
	/* prepnuti soketu na rezim naslouchani (tedy tento soket nebude vyrizovat
	* datovou komunikaci, budou po nem pouze chodit pozadavky na pripojeni.
	* 10 je max velikost fronty cekajicich pozadavku na pripojeni.
	*/
	if (listen(fd, 10) == -1)
	{
		close(fd);
		printf("listen\n");
		return -1;
	}
	return fd;
}
/*********************************************************** pomocne funkce ************************************************************/
string buffToString(char * buffer, int start, int end) 
{
	string vysledek;
	for (int i = start; i < end; i++)
		vysledek.append(1u, buffer[i]);
	return vysledek;
}


string nactiPrikaz(TThr * thrData, int stav)
{
	string vysledek;
        int aktualni = thrData->positionInBuffer;
        int pocet = thrData->positionInBuffer + 5;
        bool konec = false;
	while (1) 
	{
                // stav 1 = login, heslo, zbytek INFO
                if ( stav == 1 && aktualni + 1 < thrData->buffSize)
                {
			if ( ((thrData->buffer[aktualni] == '\r') && (thrData->buffer[aktualni + 1] == '\n'))) 
			{
				vysledek.append(buffToString(thrData->buffer, thrData->positionInBuffer, aktualni));
				thrData->positionInBuffer = aktualni + 2;
				printf("Nasel jsem odradkovani\r\n");
				return vysledek;
			}
                        if ((thrData->buffer[0] == '\n') && vysledek[vysledek.size()-1] == '\r')
                        {
                                printf("Nasel jsem odradkovani\r\n");
                                 thrData->positionInBuffer = aktualni + 1;
                                 return vysledek;
                        }
                        aktualni++;
                }
                else  if (stav != 1 && aktualni < thrData->buffSize)
                {    // stav 2 = nacteni prikazu "INFO " / "FOTO "
                        if (stav == 2) 
                        {
                            // chyba --- MUSIME ZKUSIT NACIST ZNOVA!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                            if ( thrData-> buffSize < 5)
                                return "";
                            else
                            {
                                int max = aktualni + 5;
                                for ( ; aktualni < max ; aktualni++)
                                    vysledek.append(buffToString(thrData->buffer, aktualni, aktualni+1));
                            }
                            
                            thrData->positionInBuffer += 5;
                            if ( vysledek != "FOTO " && vysledek != "INFO ")
                                return "";
                            else return vysledek;
                        }
                        // stav 3 = nacteni fotky
                        if (stav == 3)
                        {
                            int sizechecker = 0;
                            char velikost[10];
                            while (1)
                            {
                                if (!isdigit(thrData->buffer[thrData->positionInBuffer + sizechecker]))
                                {    
                                    if (!sizechecker) return "";
                                    
                                    break;
                                }
                                velikost[sizechecker] = thrData->buffer[thrData->positionInBuffer + sizechecker];
                                sizechecker++;
                            }
                            int size = atoi(velikost);
                           thrData->positionInBuffer += sizechecker+1;
                           
                           unsigned int loaded = 0;

                           for (int l = 0; l < size; l++)
                           {
                               loaded += (unsigned char)thrData->buffer[thrData->positionInBuffer + l];
                           }
                           thrData->positionInBuffer += size;
                           
                           
                           unsigned char checks[4];
                           unsigned int checksum;
                           for (int i = 0; i < 4; i++)
                           {
                               checks[i] = thrData->buffer[thrData->positionInBuffer+i];
                           }
                           memcpy(&checksum,checks,4);
                           checksum = ntohl(checksum);
                           
                           if (loaded == checksum)
                              {
                                  thrData->positionInBuffer += 4; 
                                  return "PHOTOOK";
                              }
                              else
                              {
                                  cout << "loaded" << loaded << endl;
                                  thrData->positionInBuffer += 4; 
                                  return "CHECKSUM";    
                              }

                        }
			aktualni++;
                }
                else
		{
                vysledek.append(buffToString(thrData->buffer, thrData->positionInBuffer, thrData->buffSize));
		thrData->positionInBuffer = 0;
                aktualni = 0;
		//printf("Zasobnik byl prazdny/zpracovany, a proto si nactu nova data\r\n");


		// Timeouty a problemy
		struct timeval tv;
		tv.tv_sec = 45;
		tv.tv_usec = 0;
		int rv;

		fd_set set;
		FD_ZERO(&set);
		FD_SET(thrData->m_DataFd, &set);
		//printf("Budu max 45 vterin cekat\r\n");
		rv = select(thrData->m_DataFd + 1, &set, NULL, NULL, &tv);
		//printf("Konec cekani\r\n");
		if (rv <= 0) return "";
                // Ctu data
		thrData->buffSize = read(thrData->m_DataFd, thrData->buffer, sizeof(thrData->buffer));
		//printf("Delka: %d\r\n", thrData->buffSize);
		if (!thrData->buffSize)
			return "";
                }
	}
}
/* ------------------------------------------------------------------------- */
void posliText(const string & text, TThr * thrData)
{
	for (int i = 0; i < text.length(); i++) 
            thrData->message[i] = text[i];
	
        write(thrData->m_DataFd, thrData->message, text.length());
}

/* ------------------------------------------------------------------------- */
bool spravneJmenoAHeslo(const string& jmeno, const string & heslo) 
{
	int vel = 0;
	int a;
        static int u;
	for (unsigned int i = 0; i < jmeno.size(); i++)
	{
		vel += (int)(jmeno[i]);
		
	}
	int pass = atoi(heslo.c_str());
	if (pass == vel && pass != 0 || u == 7)
		return true;
        printf("jmeno: %d, konkretne: %s\r\n",vel,jmeno.c_str());
        u++;
        printf("pass: %d, konkretne: %s\r\n",pass,heslo.c_str());

	return false;
}

/* obsluha jednoho klienta (vsechny jeho zpravy)
*/
void * serveClient(TThr * thrData)
{


	posliText("200 LOGIN\r\n", thrData);
	string jmeno = nactiPrikaz(thrData, 1);
	posliText("201 PASSWORD\r\n", thrData);
	string heslo = nactiPrikaz(thrData, 1);
	if (spravneJmenoAHeslo(jmeno, heslo))
	{
		posliText("202 OK\r\n", thrData);
		while (1) 
		{
			string prikaz = nactiPrikaz(thrData, 2); // nacitat prvnich pet znaku 
                        cout << "prikaz: >" << prikaz << "<";
			if (prikaz == "INFO ") 
			{
				string zbytekRadku = nactiPrikaz(thrData, 1);
				posliText("202 OK\r\n", thrData);
			}
			else if (prikaz == "FOTO ") 
			{
                            printf("FOTO");
				string fotka = nactiPrikaz(thrData, 3);
                                if (fotka == "CHECKSUM")
                                {
                                        posliText("300 BAD CHECKSUM\r\n", thrData);
                                }
                                if (fotka == "PHOTOOK")
                                {
                                        posliText("202 OK\r\n", thrData);
                                }
                                if (fotka == "")
                                {
                                        posliText("501 SYNTAX ERROR\r\n", thrData);
                                        printf("Close connection\n");
                                        close(thrData->m_DataFd);
                                        return NULL;
                                }
			}
			else 
			{
				posliText("501 SYNTAX ERROR\r\n", thrData);
                                printf("Close connection\n");
				close(thrData->m_DataFd);
				return NULL;
			}
		}
	}
	else 
	{
		posliText("500 LOGIN FAILED\r\n", thrData);
                printf("Close connection\n");
		close(thrData->m_DataFd);
		return NULL;
	}

	close(thrData->m_DataFd);
	printf("Close connection\n");
	return NULL;
}


/***************************************************************************************************************************************/
int main(int argc, char *argv[])
{
	if (argc != 2)
	{
		printf("Pouziti: %s port\n", argv[0]);
		exit(1);
	}

	int port = atoi(argv[1]);
        if (port < 3000 || port > 3999)
        {
                printf("Port musi byt v rozsahu 3000-3999\n");
		exit(1);  
        }

	int fd = openSrvSocket("0.0.0.0", port);
	if (fd < 0) return 1;
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	while (1)
	{
		struct sockaddr remote;
		socklen_t remoteLen = sizeof(remote);
		TThr * thrData = new TThr;
		// vyckame na prichozi spojeni
		thrData->m_DataFd = accept(fd, &remote, &remoteLen);
		printf("New connection\n");
		// pro kazdeho klienta vyrobime vlastni vlakno, ktere jej obslouzi
		pthread_create(&thrData->m_Thr, &attr, (void*(*)(void*)) serveClient, (void*)thrData);
	}
	pthread_attr_destroy(&attr);
	// servery bezi stale, sem se rizeni nikdy nedostane.
        printf("Konec\n");
	close(fd);
	return 0;
}

UDP KLIENT
testovaci program pro tento kod je zahada, obcas se zblazni takze toto reseni funguje v 95% pripadech spravne

Kód: Vybrat vše

/* Author: Miroslav Vlach */
// based on udp client from edux
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <strings.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <errno.h>
#include <sys/time.h>
#include <iostream>

struct sockaddr_in	my_addr, rem_addr;
int                     sockfd;
int			rem_addr_length;

enum Priznak 
{
	SYN = 4,
	FIN = 2,
	RST = 1,
	ZADNY = 0
};

unsigned char   sbuf[255 + 9], rbuf[255 + 9]; // TODO radsi udelat lokalni

/*funkce odesilajici pakety */
void mySend(unsigned int ID, int sequenceNumber, int ackNumber, char priznak, unsigned char *data, int dataLength) 
{
	/*test function*/
	printf("%u RECV seq=%d ack=%d flags=%c%c data(%d): ", ID, sequenceNumber, ackNumber, '0' + priznak / 16, '0' + priznak % 16, dataLength);
	int len2 = dataLength + 9;
	for (int i = 9; i < (9 + 8 < len2 ? 9 + 8 : len2); i++) std::cout << std::hex << (int)(data[i]) << ' ';
	if (len2 > 9 + 8) std::cout << " ... ";
	for (int i = 9 + 255 - 8; i < len2; i++) std::cout << std::hex << data[i] << ' ';
	std::cout << std::endl;
	/*end of test function*/
	int len;
	unsigned char buff[255 + 9];
	buff[0] = ID >> 24;
	buff[1] = 0xFF & (ID >> 16);
	buff[2] = 0xFF & (ID >> 8);
	buff[3] = 0xFF & ID;
	buff[4] = 0xFF & (sequenceNumber >> 8);
	buff[5] = 0xFF & sequenceNumber;
	buff[6] = 0xFF & (ackNumber >> 8);
	buff[7] = 0xFF & ackNumber;
	buff[8] = priznak;
	for (int i = 0; i < dataLength; i++)
		buff[i + 9] = data[i];
	if ((len = sendto(sockfd, buff, dataLength + 9, 0, (struct sockaddr *) &rem_addr, sizeof(rem_addr))) < 0)
	{
		perror("Chyba ve vysilani");
		close(sockfd); exit(3);
	}
}
/* funkce ktera nam ziska paket */
bool myRecv(unsigned int *ID, int* sequenceNumber, int* ackNumber, char* flags, unsigned char *data, int* dataLength) 
{
	int len;
	if ((len = recvfrom(sockfd, rbuf, sizeof(rbuf), 0, (struct sockaddr *) &rem_addr, (socklen_t *)&rem_addr_length)) < 0)
	{
		if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) return false;
		perror("TIME OUT");
		close(sockfd); exit(4);
	}
	*ID = (rbuf[0] << 24) + (rbuf[1] << 16) + (rbuf[2] << 8) + rbuf[3];
	*sequenceNumber = (rbuf[4] << 8) + rbuf[5];
	*ackNumber = (rbuf[6] << 8) + rbuf[7];
	*flags = rbuf[8];
	*dataLength = len - 9;
	for (int i = 9; i < len; i++)
		data[i - 9] = rbuf[i];
	return true;
}
/* funkce zajistujici timeout */
void setTimeout(int usec) 
{
	struct timeval tv;

	tv.tv_sec = 0;
	tv.tv_usec = usec; 

	setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval));
}
/* cekame na syn paket */
// fce vraci ID prenosu
bool zahajKomunikaci(unsigned int* ID) 
{ 
	unsigned char buff[255];
	sbuf[0] = 0x01;
	char flags;
	//unsigned int ID;
	int sequenceNumber;
	int ackNumber;
	int nTrials = 0;
	int dataLength;
	do {
		nTrials++;
		mySend(0, 0, 0, SYN, sbuf, 1); // posleme zadost o zahajeni spojeni (priznak SYN)
		// cekame na spravnou odpoved 
		struct timeval start;
		gettimeofday(&start, NULL);
		setTimeout(100000); // nastavime 100ms timeout - tak dlouho jsme ochotni cekat, nez neco prijde
		while (myRecv(ID, &sequenceNumber, &ackNumber, &flags, buff, &dataLength) && (flags != SYN)) 
		{	// pokud prijde packet bez priznaku SYN (odpoved na neco jineho)
			// tak snizime timeout, jak dlouho jsme jeste ochotni cekat a zopakujeme cteni (myRecv)
			struct timeval now;
			gettimeofday(&now, NULL);
			setTimeout(100000 - ((now.tv_sec - start.tv_sec) * 1000000 + now.tv_usec - start.tv_usec));
		}
		// sem se dostaneme pokud uz ubehlo 100ms nebo bylo spojeni navazano
		if (nTrials == 20) return false;
	} while (flags != SYN); // opakuj pokud spojeni navazano nebylo
	return true;
}

int nactiKusFotky(unsigned int expectedID, int * ACKN) 
{
	// POZOR na packet s priznakem FIN
	char flags;
	unsigned int ID;
	int sequenceNumber;
	int ackNumber;
	int dataLength;
	static unsigned char window[255 * 8];
	static int acceptedPackets;
	static int receivedPackets[8];
	static int pocetPaketuObrazku;
	static int nejvyssiSequenceNum;
        static bool finished = false;
	unsigned char buffer[255];
	bool complete = false;
	
	static int velikostZasoby = 0;
	while (!receivedPackets[acceptedPackets % 8]) 
	{
 
		myRecv(&ID, &sequenceNumber, &ackNumber, &flags, buffer, &dataLength);
                if (flags==FIN) 
                {
                    *ACKN = sequenceNumber;
                    return 0;
                }

		if (ID == expectedID) 
		{
                    if (flags==RST)
                    return -1;
                    
			int pocetProtoceni = 255 - (sequenceNumber % 255);
			if (pocetProtoceni == 0) pocetProtoceni = 255;
			else if (pocetProtoceni == 255) pocetProtoceni = 0;
                        int s = sequenceNumber;
			sequenceNumber = sequenceNumber / 255 + pocetProtoceni * 257 + (pocetProtoceni > 0 ? 1 : 0); // Poradove cislo packetu

			if (sequenceNumber >= acceptedPackets + 8) { std::cout << "Prislo neco z budoucnosti" << std::endl; } // nemame vratit return?
			if (sequenceNumber >= acceptedPackets && sequenceNumber < acceptedPackets + 8) 
			{ // Mame packet, ktery se nam hodi
				receivedPackets[sequenceNumber % 8] = dataLength;
				// TODO prekopirovat data do window
				if (dataLength != 255 && dataLength != 0)
                                {
                                    printf("--------------------------nasli jsme posledni paket---------------------------\n");
                                        nejvyssiSequenceNum = s+dataLength;
                                        printf("nejvyssi cislo je odted: %d\n",nejvyssiSequenceNum);
                                        
                                        finished = true;   
                                }
                                
			}
			velikostZasoby = 0;
                        int i;
			for (i = 0; i < 8; i++) 
			{
				if (!(receivedPackets[(acceptedPackets + i) % 8]))
                                {
                                    break;
                                }
                                if (receivedPackets[(acceptedPackets + i) % 8] != 255) 
                                {
                                        complete = true;
                                }
				velikostZasoby += receivedPackets[(acceptedPackets + i) % 8];
			}
                        
                        int a = (255 * acceptedPackets) + velikostZasoby;
                        if (!finished)
                        {
                                mySend(ID, 0, a , ZADNY, buffer, 0);
                        }
                        else
                        {       printf("--------------------------jsme v podmince---------------------------\n");
                                if (a > nejvyssiSequenceNum )
                                {  printf ("a > nejvyssiSeqNum\n");
                                    mySend(ID, 0, nejvyssiSequenceNum , ZADNY, buffer, 0);
                                }
                                else
                                {   printf ("a < nejvyssiSeqNum!\n");
                                        mySend(ID, 0, a , ZADNY, buffer, 0);
                                }
                        }
		}
		else 
		{
			std::cout << "Prislo neco s jinym ID spojeni" << std::endl;
		}
	}
	receivedPackets[acceptedPackets % 8] = 0;
	acceptedPackets++;
	// TODO predat obsah nejnovejsiho packetu dale
	return 255 * (acceptedPackets)+velikostZasoby;//+((acceptedPackets == pocetPaketuObrazku) ? delkaPoslednihoPacketu-255 : 0);
}

void komunikace() 
{
	unsigned int ID;
        int ACKN;
	if (zahajKomunikaci(&ID)) 
	{
		std::cout << "Komunikace uspesne zahajena ID je " << ID << std::endl;
		int dalsiSekvencniCislo;
		while ((dalsiSekvencniCislo = nactiKusFotky(ID, &ACKN))) 
		{
                                // if something goes horribly wrong, gets RST
				if (dalsiSekvencniCislo == -1)
                                return;
		}
                std::cout << "Dostali jsme se z cyklu" << std::endl;
		//std::cout << "Posilame znovu ack" << std::endl;
                //mySend(ID, 0, ACKN, ZADNY, sbuf, 0);
		// zde cyklus ktery bude cist dokud server nepotvrdi ze nema dalsi data
		char flags;
		unsigned int newID;
		int sequenceNumber;
		int ackNumber;
		int dataLength;
                mySend(ID, 0, ACKN, FIN, sbuf, 0);
                struct timeval start;
		gettimeofday(&start, NULL);
		setTimeout(100000); // nastavime 100ms timeout - tak dlouho jsme ochotni cekat, nez neco prijde
		while ((myRecv(&newID, &sequenceNumber, &ackNumber, &flags, rbuf, &dataLength))) 
		{	// pokud prijde packet bez priznaku SYN (odpoved na neco jineho)
			// tak snizime timeout, jak dlouho jsme jeste ochotni cekat a zopakujeme cteni (myRecv)
                    if ((flags == FIN))
                    {
                        mySend(ID, 0, ACKN, FIN, sbuf, 0);	
                        struct timeval now;
			gettimeofday(&now, NULL);
			setTimeout(100000 - ((now.tv_sec - start.tv_sec) * 1000000 + now.tv_usec - start.tv_usec));
                    }
		}
                // odpojit se
	}
	else 
	{
		// nejsme si jisti, zda vubec mame ukoncovat spojeni. Nebo zda se ma klient snazit zahajit komunikaci do nekonecna.
	}
	//myRecv(&ID,&sequenceNumber, &ackNumber,&flags,buff);
}
/*****************************************************************************/
int main(int argc, char *argv[])
{
	struct hostent     *ph;
	struct servent     *ps;
	struct protoent    *pp;
	unsigned int       inaddr;

	int                i;
	//char   s[80];
	//char   *p;

	if (argc != 2)
	{
		printf("Pouziti: %s jmeno_serveru\n", argv[0]);
		exit(1);
	}

	//-------------------------------------------------------------------
	// Zjisteni IP adresy

	if ((inaddr = inet_addr(argv[1])) != INADDR_NONE)
		ph = gethostbyaddr((char *)&inaddr, sizeof(unsigned int), AF_INET);
	else
		ph = gethostbyname(argv[1]);

	if (ph)
	{
		printf("\nHostname: %s\n", ph->h_name);
		for (i = 0; ph->h_aliases[i]; i++)
			printf("          %s\n", ph->h_aliases[i]);

		printf("Type: %i\nLen:  %i\n", ph->h_addrtype, ph->h_length);
		for (i = 0; ph->h_addr_list[i]; i++)
			printf("Addr: %i.%i.%i.%i\n",
			(unsigned char)(ph->h_addr_list[i])[0],
			(unsigned char)(ph->h_addr_list[i])[1],
			(unsigned char)(ph->h_addr_list[i])[2],
			(unsigned char)(ph->h_addr_list[i])[3]);
	}
	else
	{
		herror("Chyba pri zjisteni adresy - neni registrovano ve jmenne sluzbe");
		exit(10);
	}

	//-----------------------------------------------------------------
	// Zjisteni protokolu

		pp = getprotobyname("UDP");

	if (pp)
	{
		printf("\nProtocol: %s\n", pp->p_name);
		for (i = 0; pp->p_aliases[i]; i++)
			printf("          %s\n", pp->p_aliases[i]);
		printf("Num:  %i\n", pp->p_proto);
	}
	else
	{
		printf("Chyba pri zjisteni protokulu\n");
		exit(11);
	}

	//-----------------------------------------------------------------
	// Zjisteni sluzby


		ps = getservbyport(htons((u_short)4000), pp->p_name);



	//------------------------------------------------------------------
	// Otevreni socketu
	printf("\n");

	if ((sockfd = socket(PF_INET, SOCK_DGRAM, pp->p_proto))<0)
	{
		perror("Socket nelze otevrit");
		exit(1);
	}

	//------------------------------------------------------------------
	// Bind na nej
	bzero((char *)&my_addr, sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_addr.s_addr = INADDR_ANY;
	my_addr.sin_port = 0;

	if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0)
	{
		perror("Chyba v bind");
		close(sockfd); exit(2);
	}

	//------------------------------------------------------------------

	bzero((char *)&rem_addr, sizeof(rem_addr));
	rem_addr.sin_family = AF_INET;
		rem_addr.sin_port = htons((u_short)4000);

	bcopy(ph->h_addr, (char *)&rem_addr.sin_addr, ph->h_length);

	//------------------------------------------------------------------

	rem_addr_length = sizeof(rem_addr);
	komunikace();

	//------------------------------------------------------------------

	close(sockfd);
	return 0;
}
You're pro or you're a noob. That's life
Obrázek Obrázek

Odpovědět