Linux, Pamięć Dzielona

0

Dzień Dobry,

Musze na jutro oddac projekcik :D, ostatni i mam problem.
pliki server_czas i server.h są wykładowcy.

W moim pliku Client_czas wyswietla sie blad:
tworzenie segmentu: Invalid argument
Nie udestepniono segmentu udostepnianie segmentu: Invalid argument
Naruszenie ochrony pamięci
Byłbym bardzo wdzięczny jak by mi ktoś pomógł

server.h

#include<sys/shm.h>
#include<sys/sem.h>

/****************************************
makrodefinicja: stanserwera

stanserwera(1) :
-tworzy blok pamieci wspolnej
-wpisuje tam swoj pid
stanserwera(0) :
-otwiera blok pamieci wspolnej
-odczytuje z niej pid
-wysyla sygnal do procesu pid
-usuwa segment pamieci wspolnej
*****************************************/

#define kluczs 7800

#define stanserwera(typ)  {\
int shmid,id;\
void *pw;\
if (typ==1) {\
if ( (shmid=shmget(kluczs,sizeof(int),0660|IPC_CREAT|IPC_EXCL)) < 0) {\
    perror("server start");\
     exit(0);}\
if ( (pw=shmat(shmid,0,0)) == (char*)-1) perror("server start");\
 *((int*)pw)=getpid();\
 shmdt(pw);}\
if (typ==0) {\
if ( (shmid=shmget(kluczs,sizeof(int),0660)) < 0) {\
perror("server start");\
exit(0);}\
 if ( (pw=shmat(shmid,0,0)) == (char*)-1) perror("server stop");\
 id=*((int*)pw);\
 kill (id,SIGTERM);\
 shmdt(pw);\
 shmctl(shmid,IPC_RMID,0);}}

server_czas

 #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<fcntl.h>
#include<sys/shm.h>
#include<sys/wait.h>
#include<sys/ioctl.h>
#include "server.h"
#include<signal.h>
#define klucz 8001
#define prawa 0660

struct czas {
int sid,cid;     // identyfikatory procesu  servera i klienta 
char t[40];      // pole do przechowania czasu
};

/* funkcje bliblioteczne

    (1) bcopy(source,dest,ilosc_bajtow) - kopiuje bajty
    (2) bzero(p,ilosc bajtow) - zeruje blok bajtow wskazywany przez p  
*/

int shmid,id;
void *pw=0;
struct czas cz;

void zapis() {  // wykonuje zapis czasu do bloku pamieci wspolnej

//Moje dodanie
//printf("Otzymalem od klienta zapytanie i wpisuje czas do wspolnego bufora");

time_t czas=time(0);
bcopy(pw,&cz,sizeof(cz));  // kopiuje do struktury zawartosc bloku pw
              // teraz struktura cz ma wypelnione pola sid i cid

strcpy(cz.t,ctime(&czas)); // kopiuje czas do struktury cz
bcopy(&cz,pw,sizeof(cz));  // kopiuje strukture cz do pw
}

void zakoncz(){       // po otrzymaniu sygnalu odlacza pamiec wspolna
shmdt(pw);
}

main(int arg, char **argv)
{
int pid=-1;
int ch=getpid(),s,fd;

 signal(SIGCLD,SIG_IGN); //proces macierzysty nie musi czekac na zakonczenie
//                         procesu potomnego
//                         zapobiega tworzeniu procesow zombie 

// oznaczenia:
// S - oczekiwanie nie aktywne (drzemie)
// T - proces zawieszony
// Z - proces zombie
// R - proces aktywny

if ( arg < 2) {
 puts("server start|stop"); exit(0);
return 0;}

if (strcmp(argv[1],"stop")!=0 && (strcmp(argv[1],"start")!=0 )){
   puts("server start|stop"); exit(0);} 

if (strcmp(argv[1],"stop")==0 ) {     // zatrzymywanie  servera
              stanserwera(0);
              exit(0);
}

signal(SIGUSR1,zapis);
signal(SIGTERM,zakoncz);

if ((ch=fork())== -1) perror("can't fork"); //tworzy proces potomny

if (ch==0) {
pid=getpid();
if (strcmp(argv[1],"start")==0 ) {      // uruchamia server jako demon

stanserwera(1);                        // wpisuje do p.w swoj numer procesu

//moja modyfikacja
printf("server startuje i jego pid to %d", getpid());   
}

setpgrp();  // zmienia grupe procesow

if((fd=open("/dev/tty",O_RDWR))>=0)    // odlacza terminal sterujacy       
{
ioctl(fd,TIOCNOTTY,0);
close(fd);
}

// zamyka deskryptory plikow
//close(0);
//close(1);

// dzialanie servera

// tworzy segment pamieci wspolnej
if ( (shmid=shmget(klucz,40*sizeof(char),IPC_CREAT|prawa)) < 0) 
    perror("blad servera");

// udostepnia segment pw.
if ( (pw=shmat(shmid,0,0)) == (char*)-1) 
  perror("server start stop");

bzero(&cz,sizeof(cz));
cz.sid=getpid();
bcopy(&cz,pw,sizeof(cz));

while (1) {
     pause();  // po nadejsciu sygnalu SIGUSR1 budzi sie i wykonuje funkcje zapis
     kill(cz.cid,SIGUSR1); // wysyla sygnal do klienta ze blok pw zawiera czas
     }

}

else{ }

return 0;
}

client_czas

/* funkcja fork tworzy kopie procesu wywolujacego ta funkcje */

#include <stdlib.h>
#include<stdio.h>
#include<strings.h>
#include<time.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/wait.h>
#include<sys/ioctl.h>
#include<signal.h>

#define klucz 8001
#define prawa 0660

struct czas {
int sid,cid;     // identyfikatory procesu  servera i klienta 
char t[40];      // pole do przechowania czasu
};

char *buf;
int shmid;
void *pw;
int pidServera = 3490;

struct czas cz;

void wyswietl()
{
  bcopy(&cz,pw,sizeof(cz));
  printf("Czas pobrany ze serwera to %s \n", cz.t);
}

main(int arg, char **argv)
{
  cz.cid = getpid();
  // dostep do wspolnej pamieci
  void *pw;
  if ( (shmid=shmget(klucz,sizeof(cz),prawa|IPC_CREAT)) < 0) perror("blad: tworzenie segmentu");
  //Gdy wartość zmiennej addres jest równa NULL system sam nadawartość adresowi po którym widziany jest dołączany segment pamięci
  if ( (pw=shmat(shmid,NULL,0)) == (char*)-1) perror("Nie udestepniono segmentu udostepnianie segmentu"); 
  bcopy(pw,&cz,sizeof(cz));
  kill(cz.sid, SIGUSR1);
  signal(SIGUSR1,wyswietl);

  //proces odlaczna segment
  if(shmdt(pw) == -1) perror("Nie udalo sie odlaczyc segmentu pamieci wspolnej");

return 0;
}
0

Generuj klucze funkcją ftok()

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0