1 TCP

1.
(host) stream socket. 20
byte . byte
, 256 byte.

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <netdb.h>
int s,ls;
struct sockaddr_in clientaddr_in, myaddr_in;
struct hostent *hp;
struct servent *sp;
main (){
memset ((char *)&myaddr_in,0,sizeof(struct sockaddr_in));
memset ((char *)&clientaddr_in,0,sizeof(struct sockaddr_in));
hp=gethostbyname("dazhbog");
sp=getservbyname("primer","tcp");
myaddr_in.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
myaddr_in.sin_port=sp->s_port;
myaddr_in.sin_family=AF_INET;
ls=socket(AF_INET,SOCK_STREAM,0);
if (ls==-1) exit(1);
if (bind(ls,&myaddr_in,sizeof(struct sockaddr_in))==-1)
exit(1);
if (listen(ls,5)==-1) exit(1);
while(1){
int clientaddr_len;
s=accept(ls,&clientaddr_in,&clientaddr_len);
if (s==-1) exit (1);
switch (fork()){
case -1: exit(1);
case 0: server(); exit(0);
default: close(s);
}//switch
}//while
}//main

server(){
int f;
char status[1], databuf[256], buf[20];
int len=0, len1, lendata;
close(ls); //ne slusaj
while (len = recv(s, buf, 20, 0)){
if (len==-1) exit (1);

. -. 1/22

while (len<20){
len1=recv(s, &buf[len], 20-len, 0);
//prima so nadovrzuvanje dodeka ne se soberat 20B
if (len==-1) exit(1);
len+=len1;
}//while (len<20)
}//while
if (-1==(f=open(buf, O_RDONLY, 0))){
status[0]='\000';
send(s, status, 1, 0);
}
else{
status[0]='\001';
l=send(s, status, 1, 0);
if (-1==l) exit(1);
while (lendata=read(f, databuf, 256))
send(s, databuf, lendata, 0);
}//if_else
close(s);
}//server;

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in/h>
#include <signal.h>
#include <stdio.h>
#include <netdb.h>
struct sockaddr_in myaddr, servaddr;
struct hostent *hp;
struct servent *sp;
int l, s;
main(){
char *name=" proba.txt";
int f;
char status[], buf[256];
hp=gethostbyname("dazhbog");
sp=getservbyname("primer", "tcp");
servaddr.sin_family=AF_INET;
servaddr.sin_port=sp->s_port;
servaddr.sin_addr.s_addr=((struct in_addr *)(hp ->h_addr))->s_addr;
s=socket(AF_INET, SOCK_STREAM, 0);
if (s==-1) exit (1);
if (connect(s, &servaddr, sizeof(struct sockaddr_in))==-1) exit (1);
send(s, name, 20, 0);
recv(s, status, 1, 0);
if (status[0]='\000') exit (0);
f=open(name, O_CREATE, USER_RW);
while (l=recv(s, buf, 256, 0))
write(f, buf, l);
}//main;

. -. 2/22

2. .
2 UFID-
, 2B. .
(int = 2B).
.
. READ
byte 0
1 .
. byte
0 1 .
stream socket. sort serv,
prati1 prati2 serv1 serv2
. serv .

#include <site.h>
#define READ 1
struct hostent *hp;
struct servent *sp;
struct sockaddr_in my, cl, s1, s2; //soketi za klientot i dvata serveri
int l, s, so1, so2, len, dat1, dat2, i, l1, l2;
struct poraka{
int tip;
int dat;
} msg;
char odg1, odg2, odg;
int int1, int2;
main(){
hp=gethostbyname("serv");
sp=getservbyname("sort", "tcp");
my.sin_family=AF_INET;
my.sin_port=sp->s_port;
my.sin_addr.s_addr=(struct in_addr *)(hp->h_haddr)->s_addr;
if (-1==(ls=socket(AF_INET, SOCK_STREAM, 0)) exit(1)
if (bind(ls, &my, sizeof(my))==-1) exit(1);
if (listen(ls, 7)==-1) exit(1);
while (1){
len=sizeof(cl);
s=accept(ls, &cl, &len);
switch (fork()){
case -1: exit(1);
case 0: server();
exit(0);
default: close(s);
}//switch;
}//while
}//main
server(){
close (ls);
hp=gethostbyname("serv1"); //socket za prvata datoteka
sp=getservbyname("prati1", "tcp");
s1.sin_family=AF_INET;
s1.sin_port=sp->s_port;
s1.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
so1=socket(AF_INET, SOCK_STREAM, 0);

. -. 3/22

hp=gethostbyname("serv2"); //socket za vtorata datoteka
sp=getservbyname("prati2", "tcp");
s2.sin_family=AF_INET;
s2.sin_port=sp->s_port;
s2.sin_addr.s_addr=(struct in_addr *)(hp->h_addr)->s_addr;
so2=socket(AF_INET, SOCK_STREAM, 0);
if ((l=recv(s, &dat1, sizeof(int), 0))==-1) exit(1); // Otvorame dva
if ((l=recv(s, &dat2, sizeof(int), 0))==-1) exit(1); // socket-i
connect(so1, &s1, sizeof(s1));
connect(so2, &s2, sizeof(s2));
msg.tip=READ;
msg.dat=dat1;
send(so1, &msg, sizeof(msg), 0);
msg.dat=dat2;
send(so2, &msg, sizeof(msg), 0);
recv(so1, &odg1, sizeof(char), 0);
recv(so2, &odg2, sizeof(char), 0);
if (odg1!=1 || odg2!=1){
odg=0;
send(s,&odg, sizeof(char), 0);
close(so1);
close(so2);
close(s);
exit(0);
}
odg=1;
send(s, &odg, sizeof(char), 0);
l1=recv(so1, &int1, sizeof(int), 0);
l2=recv(so2, &int2, sizof(int), 0);
while (l1!=0 && l2!=0){
if (int1<int2){
send(s, &int1, sizeof(int), 0);
l1=recv(so1, &int1, sizof(int), 0);
}
else{
send(s, &int2, sizeof(int), 0);
l2=recv(so2, &int2, sizeof(int), 0);
}
}//while
while(l1!=0){
send(s, &int1, sizeof(int), 0);
l1=recv(so1, &int1, sizeof(int), 0);
}
while(l2!=0){
send(s, &int2, sizeof(int), 0);
l2=recv(so2, &int2, sizeof(int), 0);
}
close(so1);
close(so2);
close(s);
}//server

. -. 4/22


2 UDP
1. 10
cerera vezba1. i UDP .
OK.
. vezba1.

#include <site.h>
struct sockaddr_in myaddr, claddr;
struct servent *sp;
int s;
int l, len;
main(){
char msg[10];
sp=getservbyname ("vezba1", "udp");
myaddr.sin_family=AF_INET;
myaddr.sin_port=sp->s_port;
myaddr.sin_addr.s_addr=INADDR_ANY;
s=socket(AF_INET, SOCK_DGRAM, 0);
if (bind(s, &myaddr, sizeof(myaddr))==-1) exit(1);
// samo serverot pravi bind
len=sizeof(struct sockaddr_in);
l=recvfrom(s, msg, 10, 0, &claddr, &len);
printf("%s\n", msg);
sendto(s, "OK", 3, 0, &claddr, len);
close(s);
}//main_server

#include <site.h>
struct sockaddr_in myaddr, servaddr;
struct hostent *hp;
struct servent *sp;
int s, len, l;
char msg[10], msg1[3];
main (){
hp=gethostbyname("cerrera");
sp=getservbyname("vezba1", "udp");
servaddr.sin_family=AF_INET;
servaddr.sin_port=sp->s_port;
servaddr.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
s=socket(AF_INET, SOCK_DGRAM, 0); // kaj klientot nema BIND
len=sizeof(struct sockaddr_in);
sendto(s, "zdravo", 7, 0, &servaddr, len);
recvfrom(s, msg1, 3, 0, &servaddr, &len);
printf("%s\n", msg1);
close(s);
}//main_client

. -. 5/22

2. 3 .
.
f(arg1, arg2). UDP.

#include <site.h>
struct poraka{
int vrednost;
int br_proces;
} msg1, msg2;
struct sockaddr_in myaddr, claddr1, claddr2;
struct servent *sp;
int s, len, rezultat;
main (){
sp=getservbyname("funkcija", "udp");
myaddr.sin_family=AF_INET;
myaddr.sin_port=sp->s_port;
myaddr.sin_addr.s_addr=INADDR_ANY;
s=socket(AF_INET, SOCK_DGRAM, 0);
if (bind(s, &myaddr, sizeof(myaddr))==-1) exit(1);
recvfrom(s, &msg1, sizeof(msg1), 0, &claddr1, &len1);
recvfrom(s, &msg2, sizeof(msg2), 0, &claddr2, &len2);
if (msg1.br_proces==1)
rezultat=f(msg1.vrednost, msg2.vrednost);
else
rezultat=f(msg2.vrednost, msg1.vrednost);
//?
close(s);
}//main_server

. -. 6/22

3.
. .
. :
ime_grupa.ime_host.poraka.
.. . 10 .

#include <site.h>
#define BR_GRUPI 10
#define EVER 1
struct serveri{
struct sockaddr_in adresa;
char *grupa;
}
struct poraka{
char grupa[10];
char host[10];
char sodrzina[50];
}msg;
struct sockaddr_in myaddr;
struct servent *sp;
int l, s, i ;
struct serveri tabela[100]; // najmnogu 100 serveri
main(){
sp=getservbyname("gl_serv", "udp");
myaddr.sin_family=AF_INET;
myaddr.sin_port=sp->s_port;
myaddr.sin_addr=INADDR_ANY;
s=socket(AF_INET, SOCK_DGRAM, 0);
if(bind(s, &myaddr, sizeof(myaddr))==-1) exit(1);
for(;EVER;){
l=recvfrom(s, &msg, sizeof(msg), 0, 0, 0);
for (i=0;i<=BR_GRUPI;i++){
if (strcmp(msg.grupa, tabela[i].grupa)==0){
sendto(
s,
&msg,sizeof(msg),
0,
&tabela[i].adresa,
sizeof(struct sockaddr_in)
);
break;
}//if
}//for
}//for EVER
}//main

. -. 7/22


3
1. f(x,y).
.

//vo komentar e daden kodot za TCP bazirano resenie

int f(int x, int y, int br){
struct poraka{
int br_funkcija;
int x;
int y;
int rezultat;
} msg;
int s;
struct hostent *hp;
struct servent *sp;
struct sockaddr_in serv;
sp=getservbyname("funk", "udp"); // sp=getservbyname("funk", "tcp");
hp=gethostbyname ("cerera");
serv.sin_port=sp->s_port;
serv.sin_family=AF_INET;
serv.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
s=socket(AF_INET, SOCK_DGRAM, 0); // s=socket(AF_INET, SOCK_STREAM, 0);
msg.x=x;
msg.y=y;
msg.br_funkcija=br;
// connect(s,&serv,sizeof(serv));
sendto(s, &msg, sizeof(msg), 0, &serv, sizeof(struct sockaddr_in));
// send(s, &msg, sizeof(msg), 0);
recvfrom(s, &msg, sizeof(msg), 0, 0, 0);
// recv(s, &msg, sizeof(msg),0);
return(msg.rezultat);
close(s);
}//f
// Stolb rutina samo prosleduva informacii taa ne se grizi za presmetkite,
serverot gi pravi potrebnite presmetki

. -. 8/22


#include <site.h>
struct poraka{
int br_funkcija;
int x;
int y;
int rezultat;
} msg;
struct sockaddr_in myaddr, claddr;
struct servent *sp;
int s, len, l;
main(){
sp=getservbyname("ime_servis", "udp");
myaddr.sin_family=AF_INET;
myaddr.sin_port=sp->s_port;
myaddr.sin_addr.s_addr=INADDR_ANY;
s=socket(AF_INET,SOCK_DGRAM,0);
if (bind(s, &myaddr, sizeof(myaddr))==-1) exit(1);
while(1){
len=sizeof(struct sockaddr_in);
l=sizeof(msg);
recvfrom(s, &msg, l, 0, &claddr, &len);
switch (msg.br_funkcija){
case 1: {
msg.rezultat=funk1(msg.x, msg.y);
sendto(s, &msg, l, 0, &claddr, len);
break;
}
case 2: {
//
//
//
//
}
}//switch
}//while
}//main_server

. -. 9/22

2. ,
.
.
100
.

int f (char * sting){

int l, prateno, primeno, prati;
int len, paket_size=100;
struct poraka {
int size;
int pozicija;
char string[100];
int br_funkcija;
int rezultat;
}msg, msg1, msg2, msg0;
struct servent *sp;
struct hostent *hp;
struct sockaddr_in saddr, raddr, claddr;
sp=getservbyname("ime_servis", "udp");
hp=gethostbyname("ime_na_host");
saddr.sin_family=AF_INET;
saddr.sin_port=sp->s_port;
saddr.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
s=socket(AF_INET, SOCK_DGRAM, 0);
l=strlen(string)+1;
prateno=0;
msg.size=l;
sendto(s, &msg, sizeof(msg), 0, &saddr, sizeof(saddr));
len=sizeof(raddr);
recvfrom(s, &msg0, sizeof(msg0), 0, &raddr, &len);
// ovde ja doznavame novata adresa
do {
msg1.pozicija=prateno;
if (l-prateno>paket_size) prati=paket_size;
else prati=l-prateno;
strcpy(msg1.string, string+prateno, prati);
sendto(s, &msg1, sizeof(msg1), 0, &raddr, len);
prateno+=prati;
}
while (prateno<l); // ova e blok za prakanje na stringot
recvfrom(s, &msg2, sizeof(msg2), 0, &raddr, &len);
// vo msg2 e rezultatot
primeno=0;
do {
recvfrom(s, &msg1, sizeof(msg1), 0, 0, 0);
strcpy(string+primeno, msg1.string, msg1.size);
primeno+=msg1.size;
}
while (primeno<l); // se prima modiciraniot string
return (msg2.rezultat);
}//f

. -. 10/22


4
1.
. UDP,
cerera, primi. TFTP.

#include <site.h>
struct sockaddr_in myaddr, saddr, raddr;
struct hostent *hp;
struct servent *sp;
struct poraka {
int br_paket; int size_paket; int kraj;
char block[512]; char ime[20];
int blocksize;
} msg, msg0;
int s, st, len, f, br_paket;
main() {
sp=getservbyname("primi", "udp");
hp=gethostbyname("cerera");
saddr.sin_family=AF_INET;
saddr.sin_port=sp->s_port;
saddr.sin_addr=((struct in_addr *)(hp->h_addr))->s_addr;
s=socket(AF_INET, SOCK_DGRAM, 0);
strcpy(msg.ime, "dat1.dat");
while(1) {
sendto(s, &msg, sizeof(msg),0, &saddr, sizeof(saddr));
alarm(20);
len=sizeof(raddr);
st=recvfrom(s, &msg, sizeof(msg),0. &raddr, &len);
if (st==-1) continue; else break;
}//while
f=open("moja.dat", O_WRITE, 0);
br_paket=1; //od tuka pocnuvame so prakanje
while(1) {
while(1) {
msg.br_paket=br_paket;
sendto(s, &msg, sizeof(msg), 0, &addr, len);
again:alarm(20);
st=recvfrom(s, &msg0, sizeof(msg0), 0, &raddr, &len);
if(st==-1) continue;
if(msg0.br_paket!=br_paket) goto again;
break; //sum dobil sto sum baral
}
write(f, msg0.block, msg0.block_size);
br_paket++;
if(msg0.kraj==1) break;
}
close(f); close(s);
}//main_klient

. -. 11/22


#include <site.h>
struct sockaddr_in myaddr, claddr;
struct servent *sp;
struct porka {
int br_paket;
int size_paket;
int kraj;
char block[512];
char ime[20];
int blocksize;
} msg, msg0;
int s, st, s1, len, pid, f, l, br_paket;
main() {
sp=getservbyname("primi", "udp");
myaddr.sin_family=AF_INET;
myaddr.sin_port=sp->s_port;
myaddr.sin_addr=INADDR_ANY;
s=socket(AF_INET, SOCK_DGRAM, 0);
bind(s, &myaddr, sizeof(myaddr));
while(1) {
len=sizeof(claddr);
st=recvfrom(s, &msg, sizeof(msg), 0, &claddr, &len);
if (in_log(&msg, &claddr)) kill (getlog ( &msg, &claddr));
pid=fork();
if (pid>0) put_in_log(pid, &msg, &claddr);
else {
close(s);
s1=socket(AF_INET, SOCK_DGRAM, 0);
sendto(s1, &msg, sizeof(msg), 0, &claddr, sizeof(claddr));
f=otvori_c(msg.ime);
l=read(f, msg0.block, 512);
msg.blocksize=l;
if (l<512) msg0.kraj=1;
else msg0.kraj=0;
br_paket=1;
while(1) {
alarm(20);
st=recvfrom(s1, &msg1, sizeof(msg1), &claddr, &len);
if (st==-1) break;
if(msg.br_paket==br_paket);
sendto(s1, &msg0, sizeof(msg0), 0, &claddr, len);
else {
l=read(f, msg0.block, 512);
msg0.blocksize=l;
if (l<512) msg0.kraj=1;
else msg0.kraj=0;
brpaket++;
}//else
}//while
close(s1); close(f);
exit(0);
}//else_ fork
}//while
}//main_server

. -. 12/22

2.
. 10 .
: 1: ; 2: . -1
1 . : char
datoteka, int blok, char *blok. 10 .
.

#define DAJ_VERZIJA 1
#define DAJ_BLOK 2
#define BR_SERV 10
#include <site.h>
struct sockaddr_in servaddr, myaddr, raddr;
struct hostent *hp;
struct servent *sp;
struct poraka {
int tip;
int block;
int verzija;
char datoteka [10];
} msg;
int citaj (char *dat, int blok, char *blok1) {
struct d-serv {
sockaddr_in addr;
char ime[10];
} tabela[BR_SERV]; //prethodno popolneta
int verzija[BR_SERV];
int counter, s, i, j, s1, maxver;
hp=gethostbyname("??");
sp=getservbyname("??", "udp");
servaddr.sin_family=AF_INET;
servaddr.sin_port=sp->s_port;
servaddr.sin_addr.s_addr=((struct sockaddr_in *)(hp->h_addr))->s_addr;
s=socket(AF_INET, SOCK_DGRAM, 0);
counter=0;
msg.tip=DAJ_VERZIJA;
kopiraj(msg.datoteka, dat, 10);
for (i=0;i<BR_SERV;i++){
sendto(s, &msg, sizeof(msg), 0, &tabela[i].addr,
sizeof(struct sockaddr_in));
again: alarm(20);
st=recvfrom(s, &msg, sizeof(msg), 0, &raddr, &len);
if(st==-1) continue;
if (memcmp(&raddr, &tabela[i].addr, sizeof(raddr))==0) {
counter++;
vrezija[i]=msg.verzija;
}
else goto again;
}//for
if (counter>BR_SERV/2){
maxver=0;
for (i=0;i< BR_SERV; i++)
if (verzija[i]>maxver) maxver=verzija[i];
for (j=0;j< BR_SERV;j++) {

. -. 13/22

if (verzija[j]==maxver) {
msg.tip=DAJ_BLOK;
kopiraj(msg.dat, datoteka,10);
sendto(s, &msg, sizeof(msg), 0, &tabela[j].addr,
sizeof(raddr));
recvfrom(s, &msg, sizeof(msg), 0, 0, 0);
break;
}//if
}//for j
if (j==BR_SERV) return (-1);
else {
memcpy(blok, msg.blok, 512);
return(1);
}//else
}//if counter
else return (-1);
}//kopiraj

3.
UDP commit .
, abort .
commit, abort,
empty.

#include <site.h>
#define TRANSAKCIJA 002
#define CAN_COMMIT 004
#define EMPTY 000
#define DO_COMMIT 005
#define ABORT 006
//poslednive tri se mozni sostojbi na statusot na transakcijata
struct servent *sp;
struct sockaddr_in claddr, is1addr, is2addr, myaddr;
struct poraka
{//struktura na porakata
int tr_id;
int data;
int tip;
}msg,msg1;
//....
main() {
int s, len;
sp=getservbyname("...", "udp");
//setiranje na adresi
s=socket(AF_INET, SOCK_DGRAM, 0);
//binduvanje na soketot
while (1) {
len=sizeof(claddr);
recvfrom(s, &msg, sizeof(msg), 0,
&claddr, &len);
if(msg.tip==TRANSAKCIJA) {//kod b
status=gettr(msg.tr_id);

. -. 14/22

if (status==EMPTY) {// kod a
msg1.tr_id=msg.tr_id;
msg1.data=msg.data;
msg1.tip=CAN_COMMIT;
sendto(s, &msg1, sizeof(msg1), 0,
&is1addr, sizeof(is1addr));
sendto(s, &msg1, sizeof(msg1), 0,
&is2addr, sizeof(is2addr));
alarm(5);
flag_is1=0;
flag_is2=0;
while(1) {
st=recvfrom(s, &msg1, sizeof(msg1), 0,
&raddr, &len);
if (st==-1) break;
if (msg1.tip==ABORT) break;
if (memcmp(&raddr, &is1addr, len)==0) flag_is1=1;
else flag_is2=1;
if (flag_is1 && flag_is2) break;
}
if (flag_is1 && flag_is2) {
put_tr(msg.tr_id, DO_COMMIT);
msg1.tip=DO_COMMIT;
sendto(s, &msg1, sizeof(msg1), 0,
&is1addr, sizeof(is1addr));
sendto(s, &msg1, sizeof(msg1), 0,
&is2addr, sizeof(is2addr));
sendto(s, &msg1, sizeof(msg), 0,
&claddr, len);
}
else {
put_tr(msg.tr_id, ABORT);
msg1.tip=ABORT;
sendto(s, &msg1, sizeof(msg1), 0,
&is1addr, sizeof(is1addr));
sendto(s, &msg1, sizeof(msg1), 0,
&is2addr, sizeof(is2addr));
sendto(s, &msg1, sizeof(msg1), 0,
&claddr, len);
}
}
else {//kod a- statusot ne e EMPTY
msg.tip=status;
sendto(s, &msg, sizeof(msg), 0,
&claddr, sizeof(claddr));
}
else {//kod b - poraka e DAJ_STATUS
status=get_tr(msg.tr_id);
msg.tip=status;
sendto(s, &msg, sizeof(msg), 0,
&claddr, len);
}//else
}
}//za while
}//kraj

. -. 15/22


5 P2P
1. P2P . :
, . . SERV
INFORMA (
20 ) .
. TCP PEER P2P.
,
ACTV, (),
: , ,
.
. :
( ZEMI, ,
, 20 . , ,
.
DADI,
20 .
256 .
DADI, , ,
, 20 . ,
256 .
KRAJ,
. .

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <netdb.h>
#include <mem.h>
#include <string.h>
#define AKTV 1
#define KRAJ 2
#define DADI 3
#define ZEMI 4
int s,ls;
struct sockaddr_in myaddr, claddr;
struct hostent *hp;
struct servent *sp;
#define BR_RESURSI 10000 //maksimalen broj resursi
struct resursi {
struct sockaddr_in adresa;
char file_name[20];
};
struct resursi tabela[BR_RESURSI];

. -. 16/22

int no_resources=0; //broj na evidentirani resursi
main () {
hp=gethostbyname("serv");
sp=getservbyname("informa","tcp");
myaddr.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
myaddr.sin_port=sp->s_port;
myaddr.sin_family=AF_INET;
if (-1==(ls=socket(AF_INET,SOCK_STREAM,0))) exit(1);
if (-1==bind(ls,&myaddr,sizeof(struct sockaddr_in))) exit(1);
if (-1==listen(ls,5)) exit(1);
while (1) {
int clientaddr_len;
s=accept(ls,&claddr,&clientaddr_len);
if (-1==s) exit (1);
switch (fork()) {
case -1: exit(1);
case 0: server();
exit(0);
default: close(s);
}//switch
}//while
}//main
server() {
struct sockaddr_in *retaddr;
char filename[20];
int no_file_names, baranje;
close(ls); //ne slusaj
recv(s, baranje, 2, 0);
if (baranje==AKTV) {
recv(s, no_file_names, 2, 0); //prima broj na iminja na datoteki
while (no_file_names) {
recv(s, filename, 20, 0); //prima iminja na datoteki
no_resources ++;
//se zgolemil za eden brojot na evidentirani resursi
memcpy (&tabela[no_resources].adresa, claddr, clientaddr_len);
strcpy (tabela[no_resources].file_name, file_name, 20);
//smesti ime vo tabela so adresa na resurs i
//ime na datoteka sto si ja primil
no_file_names--;
}//while
} //if
if (baranje==KRAJ) {
int i, j;
//brisi klient od tablela na resursi
for (i=0;i<=no_resources;i++) {
if (memcmp(tabela[i].adresa, claddr,
sizeof (struct sockaddr_in))==0) {
for (j=i+1;j<=no_resources;j++)
memcpy(tabela[j-1], tabela[j],
sizeof (struct resursi));
//pomesti go za eden
break;
}//if
}//for
no_resources--;//se namaluva brojot na resursi
}

. -. 17/22

if (baranje==ZEMI) {
recv(s, file_name, 20, 0); //prima ime na datoteka
// prebaruva od tabela so ime na datoteka i vo ret_addr smestuva
// prva adresa kade e najdeno toa ime
int i;
for (i=0;i<=no_resourses; i++) {
if (0==strcmp(file_name, tabela[i].file_name)) {
memcpy (retaddr, &tabela[i].adresa,
sizeof(struct sockaddr_in));
break;
}//if
}//for
send(s, retaddr, size of (struct sockaddr_in),0);
}
}//server;

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <netdb.h>
#define AKTV 1
#define KRAJ 2
#define DADI 3
#define ZEMI 4
int s,ls, scl,sfile;
struct sockaddr_in myaddr, claddr, *retaddr, servaddr;
struct hostent *hp, *hp1;
struct servent *sp, sp1;
int brojdelividat(){ //vraka broj na delivi datoteki
//?.
}
char* vratiime(){ //vraka edno ime na deliva dateteka
//?.
}
int s, ls, scl, sfile;
main() {
char databuf[256];
int lendata;
hp=gethostbyname("serv");
sp=getservbyname("informa","tcp");
servaddr.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
servaddr.sin_port=sp->s_port;
servaddr.sin_family=AF_INET;
scl=socket(AF_INET, SOCK_STREAM, 0);
if (-1==s) exit (1);
//kako klient gi prijavuva na serverot site delivi datoteki
if (connect(scl, &servaddr, sizeof(struct sockaddr-in))==-1) exit (1);
send(scl, AKTV, 2, 0);
no_files= brojdelividat();
//funkcija sto go vraca brojot na delivi datoteki
send (scl , no_files,2,0);

. -. 18/22

for(i=0, i<no_files, i++) {
send(scl, vratiime(),20,0);
//vrati ime vraca iminja na delivi datoteki vo golemina od 20 bajti
}
//sega osven klient stanuva i server -listener
hp1=gethostbyname("peer");
sp1=getservbyname("p2p","tcp");
myaddr.sin_addr.s_addr=((struct in_addr *)(hp1->h_addr))->s_addr;
myaddr.sin_port=sp1->s_port;
myaddr.sin_family=AF_INET;
ls=socket(AF_INET,SOCK_STREAM,0)
if (-1==ls) exit(1);
if (bind(ls,&myaddr_in,sizeof(struct sockaddr_in))==-1)
exit(1);
if (-1==listen(ls,5)) exit(1);
while (1) {
int clientaddr_len;
s=accept(ls,&claddr,&clientaddr_len);
if (s==-1) exit (1); //ne pravi fork, ima dva soketa s i ls
recv(s, baranje, 2, 0);
if (baranje==DADI) {
recv(s, file_name, 20, 0); //prima ime na datoteka
f=open(file_name, O_RDONLY, 0);
//otvara datotaka i ja praca vo 256 bajti
while (lendata=read(f, databuf, 256))
send(s, databuf, lendata, 0);
}
if (baranje==ZEMI) {
recv(s, file_name, 20, 0);
//prima ime na datoteka i treba da go preprati na serverot so se baranjeto
send (scl, ZEMI, 2, 0);
send (scl, file_name, 20, 0);
recv(scl, retaddr, sizeof(struct (sockaddr_in),0));
//ja dobiva adresata na jazelot sto ja ima atotekata
//treba da se konektira na drug listener cija adresa ja
//dobil od serverot i toa kako klient
sfile=socket(AF_INET, SOCK_STREAM, 0);
connect(sfile, retaddr, sizeof(struct sockaddr_in));
send(sfile,DADI, 2, 0);
send(sfile,file_ name, 20, 0);
f=open(file_name, O_CREATE, USER_RW);
while (lendata=recv(sfile, databuf, 256, 0))
write(f, databuf, lendata);
close(sfile);
}
if (baranje==KRAJ) {
send (scl, KRAJ, 2, 0);
//na serverot prepraca KRAJ i se isklucuva
close (s);
break; //se misli na while(1)
}
close(s);
}//while(1)
close(scl);
}//main

. -. 19/22


A
1.
(host) stream socket. 20
byte . byte
, 256 byte.

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <netdb.h>
int s,ls; // sekoj soket e identifikuvan so nekoj cel broj
struct sockaddr_in clientaddr_in, myaddr_in;
// adresata na socket-ite e struktura vo koja se sodrzat poveke podatoci od
// koi samo nekoi ni ke gi popolnuvame, drugite ne se bitni vo slucajot
struct hostent *hp; // hp e pokazuvak kon struktura za entitetot host
struct servent *sp; // sp e pokazuvac kon struktura za entitetot servis
main (){
memset ((char *)&myaddr_in,0,sizeof(struct sockaddr_in));
memset ((char *)&clientaddr_in,0,sizeof(struct sockaddr_in));
// (char *)&myaddr_in = adresata na myaddr_in ja pravi da bide pokazuvak
// kon pole od znaci (casting)
// poplnuvanje na vrednosta na strukturata myaddr i claddr so 0
hp=gethostbyname("dazhbog");
//zemanje na vrednosta za adresata od DNS serverot spored imeto
sp=getservbyname("primer","tcp");
//zemanje na vrednosta na servisnata porta spored imeto i tipot na servisot
myaddr_in.sin_addr.s_addr=((struct in_addr *)(hp->h_addr))->s_addr;
myaddr_in.sin_port=sp->s_port;
myaddr_in.sin_family=AF_INET;
// polnuvanje na potrebnite informacii od adresnata struktura
//sledi kreiranje na slusacki soket za TCP baziran server
ls=socket(AF_INET,SOCK_STREAM,0);
if (ls==-1) exit(1);
// moze da se obedini vo eden red koj vo slucajot na bind bi izgledal vaka
if (bind(ls,&myaddr_in,sizeof(struct sockaddr_in))==-1) exit(1);
if (listen(ls,5)==-1) exit(1);
// slushaj za socketot ls i koga ke dobiesh baranje za povrzuvanje odi vo
// beskonecnata jamka
while(1){
int clientaddr_len;
s=accept(ls,&clientaddr_in,&clientaddr_len);
// prifati i na identifikatorot na socketot shto komunicira so dadeniot
// klient stavi smesti go vo promelivata s
if (s==-1) exit (1);
// ako s == -1 togash e neuspeshno pa terminiraj go procesot

. -. 20/22

switch (fork()){
// kloniraj go tekovniot proces i proveri dali si vo orginalniot proces ili
// vo klonot. Ako doshlo do greshka izlezi
case -1: exit(1);
case 0: server(); exit(0); // ako sum deteto (klonot)
default: close(s); // ako sum roditelot (orginalot)
}//switch
}//while
}//main

server(){
int f;
char status[1], databuf[256], buf[20];
int len=0, len1, lendata;
close(ls); //ne slusaj
while (len = recv(s, buf, 20, 0)){
if (len==-1) exit (1);
while (len<20){
len1=recv(s, &buf[len], 20-len, 0);
//prima so nadovrzuvanje dodeka ne se soberat 20B
if (len==-1) exit(1);
len+=len1;
}//while (len<20)
}//while
if (-1==(f=open(buf, O_RDONLY, 0))){
status[0]='\000';
send(s, status, 1, 0);
}
else{
status[0]='\001';
l=send(s, status, 1, 0);
if (-1==l) exit(1);
while (lendata=read(f, databuf, 256))
send(s, databuf, lendata, 0);
}//if_else
close(s);
}//server;

. -. 21/22


#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in/h>
#include <signal.h>
#include <stdio.h>
#include <netdb.h>
struct sockaddr_in myaddr, servaddr;
struct hostent *hp;
struct servent *sp;
int l, s;
main(){
char *name=" proba.txt";
int f;
char status[], buf[256];
hp=gethostbyname("dazhbog"); // zemi adresa na serverot
sp=getservbyname("primer", "tcp"); // i adresa na servisot
servaddr.sin_family=AF_INET;
servaddr.sin_port=sp->s_port;
servaddr.sin_addr.s_addr=((struct in_addr *)(hp ->h_addr))->s_addr;
// pokazuvacot hp pokazuva na struktura vo koja ima element h_addr
// toj clen e pokazuvac koj shto pokazuva kon struktura kade shto se sodrzi
// s_addr. Toj e isto taka pokazuvac. Neka nekovata uloga se smeni taka da
// toj stane pokazuvac kon struktura od tip in_addr, (casting)
// t.e. vrednosta kade shto pokazuva s_addr ja tretirame kako da e od tip
// in_addr. Takviot pokazuvac neka e elementot s_addr od strukturata
// sin_addr od strukturata servaddr.
s=socket(AF_INET, SOCK_STREAM, 0); //otvori socket
if (s==-1) exit (1); // ako ne si uspeal izlezi
if (connect(s, &servaddr, sizeof(struct sockaddr_in))==-1) exit (1);
// povrzi se na portata na serverot cija adresa ja prosleduvame
send(s, name, 20, 0);
// prati na veke poznatiot server
recv(s, status, 1, 0);
// primi od istiot server
if (status[0]='\000') exit (0);
f=open(name, O_CREATE, USER_RW);
while (l=recv(s, buf, 256, 0))
write(f, buf, l); // primaj i zapishuvaj vo datoteka
}//main;

. -. 22/22