int main(int argc, char * argv[]) {
struct sockaddr_in adr_moj, adr_serw, adr_x;
int s, i, slen=sizeof(adr_serw), snd, blen=sizeof(msgt),rec;
char buf[BUFLEN];
msgt msg;
s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(s < 0) blad("socket");
printf("Gniazdko %d utworzone\n",s);
memset((char *) &adr_serw, 0, sizeof(adr_serw));
adr_serw.sin_family = AF_INET;
adr_serw.sin_port = htons(PORT);
if (inet_aton(argv[1], &adr_serw.sin_addr)==0) {
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
for (i=0; i<KROKI; i++) {
printf("Sending packet %d\n", i);
msg.typ = 1;
sprintf(msg.buf, "Komunikat %d", i);
snd = sendto(s, &msg, blen, 0, &adr_serw, slen);
if(snd < 0) blad("sendto()");
printf("Wyslano komunikat res: %d\n", snd);
rec = recvfrom(s, &msg, blen, 0, &adr_x, &slen);
if(rec < 0) blad("recvfrom()");
sleep(1);
}
close(s);
return 0;
}
int main(int argc, char * argv[]) {
struct sockaddr_in adr_serw, adr_x;
int s, i=0, slen=sizeof(adr_serw), snd, blen=sizeof(msgt),rec;
// char buf[BUFLEN];
msgt msg;
fd_set socks;
struct timeval t;
int reply = 0;
s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(s < 0) blad("socket");
printf("Gniazdko %d utworzone\n",s);
memset((char *) &adr_serw, 0, sizeof(adr_serw));
adr_serw.sin_family = AF_INET;
adr_serw.sin_port = htons(PORT);
if (inet_aton(argv[1], &adr_serw.sin_addr)==0) {
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
while(++i) {
printf("--> Wysyłanie %d\n", i);
msg.typ = 1;
sprintf(msg.buf, "Komunikat %d", i);
snd = sendto(s, &msg, blen, 0, &adr_serw, slen);
if(snd < 0) blad("sendto()");
printf(" Wyslano komunikat. res: %d\n", snd);
reply = 0;
while(1){
FD_ZERO(&socks);
FD_SET(s, &socks);
t.tv_sec = 1;
if(select(s+1, &socks, NULL, NULL, &t)){
rec = recvfrom(s, &msg, blen, 0, &adr_x, &slen);
if(rec < 0) blad("recvfrom()");
printf(" Odpowiedz: %s\n", msg.buf);
break;
} else {
if(reply > 4){
printf("!! Brak odpowiedzi !!\n");
break;
} else {
reply++;
printf(" * oczekiwanie na odpowiedz... %d\n", reply);
}
}
}
sleep(1);
}
close(s);
return 0;
}
void leks (struct leksem* lk)
// zasadnicza funkcja programu;
// jej wywo³anie powoduje wczytanie odpowiedniej liczby charów z
// wej¶cia i z³o¿enie z nich leksemu (lub sygnalizacjê b³êdu);
// zak³adamy, ¿e w momencie wywo³ania w zmiennej globalnej wejscie
// jest ju¿ wczytany jeden char z wej¶cia;
// po zakoñczeniu dzia³ania tej funkcji w tej zmiennej jest ju¿
// wczytany jeden char na zapas
{
Stany q, q1;
Znaki z;
Boolean koniec;
q1 = STAN_POCZ; lk->dlug = 0; koniec = FALSE;
do
{ z = kategoria(wejscie);
q = q1; q1 = tab_symb[q][z];
if (q1 == STAN_NIEOKR) { /* b³±d */ q1 = q; koniec = TRUE; } else
if (q1 > STAN_AS)
{ /* koniec leksemu */
lk->zaw[lk->dlug] = wejscie; lk->dlug++; scanf("%c", &wejscie);
/* Uwaga: brak sygnalizacji przepe³nienia tablicy lk->zaw */
koniec = TRUE;
}
else
{ lk->zaw[lk->dlug] = wejscie; lk->dlug++; scanf("%c", &wejscie);
/* Uwaga: brak sygnalizacji przepe³nienia tablicy lk->zaw */
}
}
while (! koniec);
// po zakoñczeniu powy¿szej pêtli w q1 jest stan, na którym
// automat zakoñczy³ dzia³anie; pozostaje sprawdziæ, czy to jest
// stan akceptuj±cy i co akceptuj±cy
switch (q1)
{ case STAN_POCZ : blad("Nieoczekiwany znak", wejscie); break;
case STAN_A : blad("Mialo byc 'A' a jest", wejscie); break;
case STAN_AD : blad("Mialo byc 'AD' a jest", wejscie); break;
case STAN_ADA : blad("Mialo byc 'AS' a jest", wejscie); break;
case STAN_ASI : blad(" a jest", wejscie); break;
case STAN_KA : blad("Mialo byc 'KA' a jest", wejscie); break;
case STAN_KAM : blad("Mialo byc 'KAM' a jest", wejscie); break;
case STAN_KAMI : blad("Mialo byc 'KAMI' a jest", wejscie); break;
case STAN_K : blad("Mialo byc 'K' a jest", wejscie); break;
case STAN_KAMIL : lk->jed = MEZCZYZNA; break;
case STAN_ADA : lk->jed = KOBIETA; break;
case STAN_KAMILA : lk->jed = KOBIETA; break;
case STAN_ADAM : lk->jed = MEZCZYZNA; break;
case STAN_ASIA :lk->jed = KOBIETA; break;
case STAN_NIEOKR : blad("Nieoczekiwany znak", wejscie); break;
}
}
/**
* Kopiuje wejście na wyjście, permutując kolumny w sposób określony
* argumentami programu.
*/
int main(int argc, char *argv[])
{
int k, n, a;
int *p = NULL;
int *q = NULL;
bool odwracanie = false;
char *s = NULL;
int rozmiar;
n = argc - 1;
k = 1;
if (argc > 1 && strcmp(argv[1], ARG_ODWRACANIE) == 0) {
odwracanie = true;
--n;
++k;
}
rozmiar = (n > 0) ? n : 1;
if ((p = malloc(rozmiar * sizeof *p)) == NULL) {
blad(BRAK_MIEJSCA);
}
if ((a = wpisz_permutacje(argv + k, p, n)) != 0) {
free(p);
blad(a);
}
if (odwracanie) {
if ((q = malloc(rozmiar * sizeof *p)) == NULL) {
free(p);
blad(BRAK_MIEJSCA);
}
odwrotna(p, n, q);
free(p);
p = q;
}
if ((s = malloc(rozmiar * sizeof *s)) == NULL) {
free(p);
blad(BRAK_MIEJSCA);
}
permutuj(p, n, s);
free(s);
free(p);
return EXIT_SUCCESS;
}
int main(void)
{
long long int wartosc;
wartosc=wyrazenie();
if (ost_wyraz != '=' && ost_wyraz != EOF)
blad("Brak znaku = na końcu wyrażenia");
printf("%lld\n",wartosc);
return 0;
}
// <T> ::= b <T> c | e
Boolean SS (drzewo* drz) {
drzewo drz1;
if (nowyleks('('))
if (WW(&drz1))
if (nowyleks(')')) {
// Rozpoznalismy w <T> , robimy z tego drzewo:
drz->czyterm = FALSE;
drz->ntm = S;
drz->il_syn = 3;
drz->syn[0] = (drzewo*)malloc(sizeof(drzewo));
drz->syn[0]->czyterm = TRUE;
drz->syn[0]->lk = '(';
drz->syn[1] = (drzewo*)malloc(sizeof(drzewo));
*(drz->syn[1]) = drz1;
drz->syn[2] = (drzewo*)malloc(sizeof(drzewo));
drz->syn[2]->czyterm = TRUE;
drz->syn[2]->lk = ')';
return TRUE;
}
else return blad("( <W> ??? -- oczekiwalem ')' ");
else return blad("( ??? -- oczekiwalem <W> ");
else
if(nowyleks('a')) {
// Rozpoznalismy tylko e , robimy z niego drzewo:
drz->czyterm = FALSE;
drz->ntm = S;
drz->il_syn = 1;
drz->syn[0] = (drzewo*)malloc(sizeof(drzewo));
drz->syn[0]->czyterm = TRUE;
drz->syn[0]->lk = 'a';
return TRUE;
}
else return FALSE;
}
main () {
char znak;
char znak2;
int liczniki[30][30] ,j , i;
// inicjalizacja licznikow:
for (i=0; i<DL_ALFABETU; i++)
for(j=0; j<DL_ALFABETU; j++)
liczniki[i][j] = 0;
// wczytywanie tekstu i zliczanie liter:
znak2 = getchar();
if(znak2 == EOF){
blad("Wejscie powinno miec wiecej niz 1 znak!"); }
znak = getchar();
while (znak != EOF && znak2!=EOF) {
if(znak == ' ' || znak == '\n'){
znak2 = getchar();
if(znak2 != EOF){
znak = getchar(); }
else break; }
i = numer_litery(znak);
j = numer_litery(znak2);
if (i>=0 && j>=0) liczniki[j][i] = liczniki[j][i]+1;
znak2 = znak;
znak = getchar(); }
printf("\n");
// drukowanie statystyki:
printf("\nSTATYSTYKA:\n ");
for (i=0; i<DL_ALFABETU; i++)
printf(" %c ", litera_o_numerze(i));
for (i=0; i<DL_ALFABETU; i++){
printf("\n%c ", litera_o_numerze(i));
for(j=0; j<DL_ALFABETU; j++)
printf(" %i ", liczniki[i][j]); }
printf("\n");
//drukowanie statystyki lista
for (i=0; i<DL_ALFABETU; i++)
for (j=0; j<DL_ALFABETU; j++)
printf(" %c%c: %4i\n", litera_o_numerze(i), litera_o_numerze(j), liczniki[i][j]);
printf("\n");
return 0; }
static long long int czytaj_arg(void)
{
long long int n=0;
int znak;
while (isspace(ost_znak) && (ost_znak=getchar()) != EOF) ;
znak=(ost_znak == '-' ? -1 : 1);
if (ost_znak == '+' || ost_znak == '-')
ost_znak=getchar();
if (isdigit(ost_znak))
do {
n=10 * n + (ost_znak-'0');
ost_znak=getchar();
} while (isdigit(ost_znak));
else blad("brak argumentu");
n*=znak;
ost_wyraz=ARGUMENT;
return n;
}
int main(int argc, char* argv[]){
if (argc < 7) blad();
int dom = atoi(argv[1]);
int rodzice = atoi(argv[2]);
int bank = atoi(argv[3]);
int ang = atoi(argv[4]);
int weze = atoi(argv[5]);
int zw = atoi(argv[6]);
/*if (strcmp(argv[1], "t") || strcmp(argv[1], "T")) dom = 1;
else dom = 0;
if (strcmp(argv[2], "t") || strcmp(argv[2], "T")) rodzice = 1;
else rodzice = 0;
if (strcmp(argv[3], "t") || strcmp(argv[3], "T")) bank = 1;
else bank = 0;
if (strcmp(argv[4], "t") || strcmp(argv[4], "T")) ang = 1;
else ang = 0;
if (strcmp(argv[5], "t") || strcmp(argv[5], "T")) weze = 1;
else weze = 0;*/
if ( ((dom != 1))
|| ( ((rodzice != 2) || ((( ang != 0) || (zw <= 0)) && ((weze != 0) || (bank != 0))))
&& (( rodzice != 0) || (zw != 1) || (bank != 1) || (weze != 1) || (ang != 1))) ) {
printf("Dostaniesz sie");
return 1;
}
else printf("Nie dostaniesz sie");
return 0;
}
char litera_o_numerze (int n) {
if (0<=n && n<DL_ALFABETU) return (char)((int)'a'+n);
else blad("zly numer litery");
}
char litera_o_numerze (int n) {
// jesli n<0 lub n>=DL_ALFABETU -- sygnal bledu
if (0<=n && n<DL_ALFABETU) return (char)((int)'a'+n);
else blad("zly numer litery");
}
int main(int argc, char * argv[]) {
int fhbuf;
struct sockaddr_in adr_moj, adr_cli;
int s, i;
unsigned int slen = sizeof(adr_cli), blen = sizeof(msgt);
int snd, rec;
char buf[BUFLEN];
msgt msg;
gethostname(buf, sizeof(buf));
printf("Host: %s\n", buf);
s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (s < 0)
blad("socket");
printf("Gniazdko %d utworzone\n", s);
// Ustalenie adresu IP nadawcy
memset((char *) &adr_moj, 0, sizeof(adr_moj));
adr_moj.sin_family = AF_INET;
adr_moj.sin_port = htons(PORT);
adr_moj.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(s, (struct sockaddr *) &adr_moj, sizeof(adr_moj)) == -1)
blad("bind");
enum MSGTYPE {
WELCOME = 9,
OPENWR = 0,
OPENRD = 1,
WRITE = 2,
READ = 3,
OPENDIR = 4,
READDIR = 5,
FCLOSE = 6,
STAT = 7,
FSTAT = 8
};
const *CMDS[20] = { "OPEN", "OPENRD", "WRITE", "READ", "OPENDIR",
"READDIR", "FCLOSE", "STAT", "FSTAT", "WELCOME" };
while (1) {
rec = recvfrom(s, &msg, blen, 0, (struct sockaddr *) &adr_cli, &slen);
if (rec < 0)
blad("recvfrom()");
//if (rec == 0)
// continue;
printf("odebrano cos\n");
if (0)
printf(
msg.buf,
"SERWER: Odebrano komunikat z %s:%d reclen %d\n Typ: %d %s\n",
inet_ntoa(adr_cli.sin_addr), ntohs(adr_cli.sin_port), rec,
msg.typ, msg.buf);
char cmd[100], arg[100], arg2[100];
msg.typ = 100;
printf("probuje sparsowac komende %s\n", msg.buf);
sscanf(msg.buf, "%s %s %s", cmd, arg, arg2);
printf("udalo mi sie wczytac komende: %s z argumentami %s %s\n", cmd, arg, arg2);
for (i = 0; i < 10; ++i)
if (strcmp(CMDS[i], cmd)==0)
msg.typ = i;
system("pwd");
switch (msg.typ) {
case WELCOME:
sprintf(
msg.buf,
"Hi %s talking to me on %d port. I've received %d bytes. \n Typ: %d\n",
inet_ntoa(adr_cli.sin_addr), ntohs(adr_cli.sin_port), rec,
msg.typ//, msg.buf
);
printf(msg.buf);
break;
case OPENWR:
msg.fh = open((const char*) arg, O_RDWR);
break;
case OPENRD:
msg.fh = open((const char*) arg, O_RDONLY);
break;
case WRITE:
fhbuf = msg.fh;
printf("probuje zapisac do pliku %s tresc %s\n", arg, arg2);
msg.fh = open((const char*) arg, O_RDWR | O_CREAT);
msg.ile = write(msg.fh, (const char*) arg2, BUFLEN);
close(msg.fh);
msg.fh = fhbuf;
break;
case READ:
fhbuf = msg.fh;
msg.fh = open((const char*) arg, O_RDONLY);
printf("KTOS CHCE PLIK Z KOMENDY (POLICJI) %s\n", msg.buf);
if (msg.fh > 0){
msg.ile = read(msg.fh, (const char*) msg.buf, BUFLEN);
printf("odczytalem z pliku %s\n", msg.buf);
}
else
perror("ERROR IN CASE READ!");
close(msg.fh);
msg.fh = fhbuf;
break;
case OPENDIR:
msg.fh = opendir(arg);
break;
case READDIR:
// fhbuf = msg.fh;
// DIR *dir = opendir(arg);
// do {
// errno = 0;
// if ((dp = readdir(dirp)) != NULL) {
// if (strcmp(dp->d_name, arg) != 0)
// continue;
//
//
// (void) printf("found %s\n", arg);
// (void) closedir(dirp);
// return;
//
//
// }
// msg.fh = fhbuf;
break;
case FCLOSE:
close(msg.fh);
case STAT:
perror("BRAK KOMENDY... \7\7POLICJI\n");
break;
case FSTAT:
perror("BRAK KOMENDY... \7\7POLICJI\n");
break;
}
snd = sendto(s, &msg, blen, 0, (struct sockaddr *) &adr_cli, slen);
if (snd < 0)
blad("sendto()");
else {
printf("wyslano");
}
}
atexit(closeSocket);
return 0;
}
int main(void) {
struct sockaddr_in adr_moj, adr_cli;
int s, i, slen=sizeof(adr_cli),snd, rec, blen=sizeof(msgt);
char buf[BUFLEN];
mms_t msg;
gethostname(buf,sizeof(buf));
printf("Host: %s\n",buf);
s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(s < 0) blad("socket");
printf("Gniazdko %d utworzone\n",s);
// Ustalenie adresu IP nadawcy
memset((char *) &adr_moj, 0, sizeof(adr_moj));
adr_moj.sin_family = AF_INET;
adr_moj.sin_port = htons(PORT);
adr_moj.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(s,(struct sockaddr *) &adr_moj, sizeof(adr_moj))==-1)
blad("bind");
// Odbior komunikatow ------------
int run = 1;
int result;
while (run) {
rec = recvfrom(s, &msg, blen, 0,(struct sockaddr *) &adr_cli, &slen);
if(rec < 0) blad("recvfrom()");
printf("Odebrano komunikat z %s:%d res %d\n Typ: %d %s\n",
inet_ntoa(adr_cli.sin_addr), ntohs(adr_cli.sin_port), rec,msg.typ,msg.buf);
// Odpowiedz -----
switch(msg.typ){
case OPENW:
printf("open O_WRONLY - nazwa: \"%s\"\n", msg.buf);
msg.fh = open(msg.buf, O_WRONLY |O_CREAT, 0666);
printf("Deskryptor pliku: %d\n", msg.fh);
break;
case OPENR:
printf("open O_RDONLY - nazwa: \"%s\"\n", msg.buf);
msg.fh = open(msg.buf, O_RDONLY);
printf("Deskryptor pliku: %d\n", msg.fh);
break;
case READ:
printf("read - fd: %d, count: %d\n", msg.fh, msg.ile);
msg.ile = read(msg.fh, msg.buf, msg.ile);
printf("Odczytano: %d bajtow\n", msg.ile);
break;
case CLOSE:
printf("close - fh: %d\n", msg.fh);
result = close(msg.fh);
printf("Wynik: %d\n", result);
break;
case WRITE:
printf("write - fd: %d, count: %d\n", msg.fh, msg.ile);
msg.ile = write(msg.fh, msg.buf, msg.ile);
printf("Zapisano: %d bajtow\n", msg.ile);
break;
case STOP:
printf("Zamykanie serwera\n");
run = 0;
break;
}
snd = sendto(s, &msg, blen, 0,(struct sockaddr *) &adr_cli, slen);
if(snd < 0) blad("sendto()");
printf("wyslano odpowiedz -res %d\n",snd);
}
close(s);
return 0;
}
