msgsnd mit variabler Text-Länge

warum dann nicht den speicher zur laufzeit anfordern?

struct MSGBUF {
    int mtyp;
    size_t size;
    char* text;
}


MSGBUF data;
data.size = 5;
data.text = (char*)malloc( data.size );

Hi Peter

Danke für die schnell Antwort... ein Problem das ich vergessen hatte zu 
erwähnen, und die Sache erst so richtig kompliziert macht ist, daß ich 
die Daten zwischen zwei verschiedenen Prozessen (Programmen) austauschen 
muß. Diese Programme haben unterschiedliche Adressbereiche, daher kann 
ich in der Struktur auch nicht mit Zeigern arbeiten. Zumindest kommst da 
beim Emfpänger nur Blödsinn an. Auf das verwenden von Shared Memory 
wolle ich verzichten, da es eigentlich mehrere Prozesse werden soll, und 
dadurch der Speicherzugriff zur Laufzeit nicht wirklich vorhersehbar 
ist.

LG Daniel

dann geht es nicht, entweder im den maximalen Platz vorsehen oder mit 
zeigern arbeiten.

gibt es keine Möglichkeit bei der Erstellung eines char Feldes TEXT[XX] 
die Länge "XX" mit Hilfe einer Vairbale anzugeben?
Oder vielleicht auch TEXT[] zuerst zu definieren und anschließen 
mithilfe von irgendweiner Fkt (memset oder malloc) die Felddimension 
festzulegen?

LeDan schrieb:
> gibt es keine Möglichkeit bei der Erstellung eines char Feldes TEXT[XX]
> die Länge "XX" mit Hilfe einer Vairbale anzugeben?

nein, meines wissens nicht. Entweder macht es der Compieler oder man 
muss es zur Laufzeit mit zeigern machen.

LeDan schrieb:
> Auf das verwenden von Shared Memory
>
> wolle ich verzichten, da es eigentlich mehrere Prozesse werden soll, und
>
> dadurch der Speicherzugriff zur Laufzeit nicht wirklich vorhersehbar
>
> ist.

Hi,

kannst du doch, wenn du Semaphoren verwendest, dann ist alles 
abgesichert gegen gleichzeitigen zugriff, und welche prozess auch immer 
zugreift, schnappt sich das token, liest oder schreibt und gibt das 
token wieder frei...

Ich denke das gerade SharedMemorie mit semaphoren deine probleme lösen 
sollten

eventuell ist es ja auch sinnvoll zum Datenaustasuch eine Strukur mit 
das maximalen größe zu verwenden und intern mit zeigern zu arbeiten, 
wenn jetzt daten gesendet werden müssen dann einfach in die 
Sende-Struktur reinkopieren.

ich hänge mal hier die beiden funktionsschnipsel an...

//! Sende-Prozess 1
int WLME_WMIB_GET_REQUEST(int TEST){

  typedef struct PARABUF {
      int mtyp;
      int pid;
      char msg[TEST]; //!< message field
  };

  PARABUF para;

  int qid2;

  // Warteschlangen-ID
  qid2 = msgget(KEY_WLME, 0600);

  para.msg[0]='G';
  para.mtyp = 12;
  msgsnd(qid2, &para, sizeof (PARABUF), 0)

  return 0;
}

//! \Empfänger-Prozess 2
void GET_PARAMETER(int qid){

  //! \struct PARABUF structure for message transmit
  typedef struct PARABUF {
      int mtyp;
      int pid;
      char* msg; //!< message field
  };

  PARABUF parabuf;

  msgrcv(qid, &parabuf, sizeof(PARABUF), 12,IPC_NOWAIT)
}

Es wäre vielleicht gut, wenn Du uns sagst um welche Plattform und 
welches OS es sich handelt und vor allem mal zumindest die Deklaration 
von msgsnd (msg.h), besser noch einen Link auf die Beschreibung postest.

Ich kenne OS die feste Längen voraussetzen und solche die Zeiger 
versenden. Im ersteren Fall haben die oft noch eine weitere Funktion für 
das versenden von Zeigern.
Aber das ist ja alles nur Vermutung.

Dann schreibst Du "Prozess (Programm)":
Es gäbe dann auch noch Threads. Und das hängt noch mit der Plattform und 
dem OS zusammen. Das müsste man genau wissen. Während Programme 
wahrscheinlich am besten über Pipes oder interne Porst kommunizieren, 
gibt es sicherlich auch Platformen in den der Speicher nicht von einer 
MMU  voneinander getrennt wird. Dann geht Karls Methode, sonst nicht.

Ansonsten hindert Dich nichts, in dem char Feld fester Länge einen 
Zeiger zu speichern. Die Gegenstelle muss nur wissen, was sie zu 
erwarten hat.

Also: Einfach mehr Informationen liefern, bitte.

ich versuche mich mal an dem Vorschlag von Karl Hein und hänge aber 
trotzdem mal meine beiden Funktionsschnipsel hier an.

//! Sende-Prozess 1
int WLME_WMIB_GET_REQUEST(int TEST){

  typedef struct PARABUF {
      int mtyp; //!< \var int mtyp: defines direction for receive 
messages (2=to DME, 1=from DME)
      int pid;
      char msg[TEST]; //!< message field
  };

  PARABUF para;

  int qid2;

  // Warteschlangen-ID
  qid2 = msgget(KEY_WLME, 0600);

  para.msg[0]='G';
  para.mtyp = 12;
  msgsnd(qid2, &para, sizeof (PARABUF), 0)

  return 0;
}

//! \Empfänger-Prozess 2
void GET_PARAMETER(int BUFFERLENGTH, int qid){


  //! \struct PARABUF structure for message transmit
  typedef struct PARABUF {
      int mtyp; //!< \var int mtyp: defines direction for receive 
messages (2=to DME, 1=from DME)
      int pid;
      char* msg; //!< message field
  };

  PARABUF parabuf;

  msgrcv(qid, &parabuf, sizeof(PARABUF), 12,IPC_NOWAIT)
}

also sorry für das doppelte senden der Funktionen... mein Internet hing 
gerade

Also ich verwende Ubuntu 8.04 und es sollte C- Programmiersprache sein 
(da ich mich hier am ehesten auskenne)

Die beiden Prozesse... sind wirklich eigenständige Programme... PThreads 
oder Folks fallen hier also leider raus.

Ich hatte bereits mal versuche eine Zeigeradresse mittels Char zu 
übertragen... hatte auch funktioniert.. nur ist eben dann beim Zugriff 
auf den Speicher eine Fehlermeldung zwecks Speicherverletzung gekommen.

Karl heinz Buchegger schrieb:
> LeDan schrieb:
>> ich hänge mal hier die beiden funktionsschnipsel an...

an der Stelle mit dem msg[TEST] steigt er mir eben aus.. na ich versuche 
noch etwas weiter

über msgsnd sollen halt verschiedene Parameter übertragen werden, welche 
dann eben vom Empfängerprogramm ausgwertet werden sollen.

Karl heinz Buchegger schrieb:
> Es hängt alles davon ab, was dieses ominöse msgsend tatsächlich mit den
> übergebenen Daten macht und ob das Message Queue System mtatsächlich mit
> Messages unterschiedlicher Länge umgehen kann.

Habe ich ja geschrieben. :-{

LeDan schrieb:
> Ubuntu 8.04

Hmm. Platform wissen wir zwar immer noch nicht, aber es wird wohl was 
Intel-Artiges groesser als Pentium II sein.

Dann ist auch das erklärbar:

> Ich hatte bereits mal versuche eine Zeigeradresse mittels Char zu
> übertragen... hatte auch funktioniert.. nur ist eben dann beim Zugriff
> auf den Speicher eine Fehlermeldung zwecks Speicherverletzung gekommen.

Die Intels haben nämlich eine MMU, die vom Kernel auch fleissig benutzt 
wird um eben das zu verhindern, was Du gerade versuchst.

Poste doch mal welchen Compiler mit welchen Libs Du verwendest. Am 
besten einen Link auf die Doku posten. Dann können wir selbst gucken.

> Die beiden Prozesse... sind wirklich eigenständige Programme... PThreads
> oder Folks fallen hier also leider raus.
Jetzt fühle ich mich gerade veralbert. Sind es nun zwei Programme oder 
zwei Prozesse? Kennst Du den Unterschied? OK. "ps" zeigt Dir auch 
"Programme" an aber von OS-Sicht aus sind das im allgemeinen zwei paar 
Schuhe.

Was sind denn bitte "Folks"?

Karl heinz Buchegger schrieb:
> Grrrr schrieb:
>> Karl heinz Buchegger schrieb:
>>> Es hängt alles davon ab, was dieses ominöse msgsend tatsächlich mit den
>>> übergebenen Daten macht und ob das Message Queue System mtatsächlich mit
>>> Messages unterschiedlicher Länge umgehen kann.
>>
>> Habe ich ja geschrieben. :-{
>
> MMU hat nichts damit zu tun

Doch. Auch.
Wenn nur Zeiger gesendet werden dann sind die auf einem System mit MMU 
von dem anderen Prozess/Programm/wasauchimmer wegen der MMU nicht 
verwendbar. Wenn die aber Daten sendet, dann schon. Aber ist denn dieses 
msgsend überhaupt geeignet über Prozess-/Programm-/wasauchimmer-Grenzen 
hinweg Daten zu übertragen?

Abgesehen von diesem kleinen "Konflikt" zwischen uns, leuchtet mir auch 
nicht ein was es bringen soll, der msgsend Funktion irgendeine Struktur 
beliebiger Länge aufzudrücken wenn Du nur eine bestimmte Länge kann. 
Woher weisst Du das msgsend als zweiten Parameter die Länge hat, oder 
kennst Du die Funktion? Wenn Du sie aber kennst, würde ich annehmen, das 
Du wüsstest was sie tut?

Mann, der Server hängt aber heute...

Karl heinz Buchegger schrieb:
> Grrrr schrieb:
>> Karl heinz Buchegger schrieb:
>>> Es hängt alles davon ab, was dieses ominöse msgsend tatsächlich mit den
>>> übergebenen Daten macht und ob das Message Queue System mtatsächlich mit
>>> Messages unterschiedlicher Länge umgehen kann.
>>
>> Habe ich ja geschrieben. :-{
>
> MMU hat nichts damit zu tun

Doch. Auch.
Wenn nur Zeiger gesendet werden dann sind die auf einem System mit MMU 
von dem anderen Prozess/Programm/wasauchimmer wegen der MMU nicht 
verwendbar. Wenn die aber Daten sendet, dann schon. Aber ist denn dieses 
msgsend überhaupt geeignet über Prozess-/Programm-/wasauchimmer-Grenzen 
hinweg Daten zu übertragen?

Abgesehen von diesem kleinen "Konflikt" zwischen uns, leuchtet mir auch 
nicht ein was es bringen soll, der msgsend Funktion irgendeine Struktur 
beliebiger Länge aufzudrücken wenn Du nur eine bestimmte Länge kann. 
Woher weisst Du das msgsend als zweiten Parameter die Länge hat, oder 
kennst Du die Funktion? Wenn Du sie aber kennst, würde ich annehmen, das 
Du wüsstest was sie tut?

@ Karl

Mist. Ich habe nicht geschaltet. Da Du die Daten kopierst, hat das mit 
einer MMU nichts zu tun. Das ist schon richtig.

Ich hätte eigentlich so auf Dich antworten müssen:

Ich meinte mit:
> vor allem mal zumindest die Deklaration
> von msgsnd (msg.h), besser noch einen Link auf die Beschreibung postest.
ausgedrückt zu haben, das alles von dem abhängt was die Funktion 
tatsächlich tut.
Das mit der MMU war nur ein Teilaspekt, berührt aber nicht die 
Hauptfrage.

Naja. Whatever... Schieb' mal ein Bier rüber.

Angebote schreiben macht mich durstig... :-)

also...

sorry für die verwirrungen in Programmiertechnischen Dingen bin ich noch 
nicht so sehr bewandert.. aber ich gebe mein bestes....

ich arbeite mit nem Intel Core2Duo Chip.

mit FOLKs meine ich die follk() funktion mit dessen Hilfe man ähnlich 
wie bei PTreads Childprozesse erstellen kann.

Ich arbeite mit 2 verschiedenen Programmen... eigentlich 3. Jeder 
simuliert bei mir eine Art Teil des OSI Schichtmodells die eben 
miteinander kommunizieren wollen.

Compilieren tue ich es im Moment immer mit g++ DME.cpp -o DME
hoffe mal das das so ok ist... ist für mich wie gesagt noch ziemliches 
Neuland.

Ich habe den Codehaufen mal als Zipgepackt hier angehangen.Zum 
verständnis... mit ALME_MSG_CLIENT.cpp übergebe ich nur einen Wert an 
die DME.cpp.. zum Beispiel 8 (das ist mein jetziger Testlauf)
die DME prüft den Wert... führt einige zuordnungen aus und übergibt 
wiederum eine entsprechende Routine an WLP.cpp. Diese soll mit nun eben 
in der Funktion WLME_WMIB_GET_REQUEST (WLP_FUNCTIONS/WLME_FUNCTION.h) 
einen Parameter an die DME zurückgeben. Dabei will ich nur versenden was 
auch wirklcih nötig ist, daher muß eben das char.msg Feld irgendwie 
dynamisch sein. In dem Beispiel sende ich nur erstmal einen Buchstaben 
zum Testen. Später sollen es dann ganze Zeichenketten sein, die eben in 
der Länge variieren.
Hoffe ihr seht bei dem Codehaufen durch. Aber vorweg schonmal Danke für 
eure Hilfe.

PS... bei der Lösung von Karl Heinz hänge ich gerade irgendwie fest... 
und er meckert von wegen Typverletzung mit meiner Struktur.

jetzt hab ich doch glatt die files vergessen

ja sorry.. ich meinte natürlich fork()... tststs... es ist Freitag.. 
verzeiht mir

ich gehe mal es hängt und steht alles nur mit in der Funktion 
WLME_WMIB_GET_REQUEST()  (/WLP_FUNCTIONS/WLME_FUNCTIONS.h)

Karl heinz Buchegger schrieb:
> Dein Message Mechanismus. Ist das der hier
>
> http://opengroup.org/onlinepubs/007908775/xsh/sysmsg.h.html

das kommt mir arg bekannt vor... also JA.

Komisch, das einzige msgsnd das ich auf die schnelle finden konnte, kann 
variable Längen.

Du schriebst aber:
LeDan schrieb:
> Nun verlangt die Fkt msgsnd (msg.h) einen Struktur
> mit einem char-Feld fester Länge.

Wie bist Du darauf gekommen? Weil die Beispiele für die Struktur in der 
Message mit einer bestimmten Zahl als Feldgrösse dastehen?

Jedenfalls passt Karls Lösung dann doch.

ich weiß ich weiß... ich bin ja auch noch Anfänger, also bitte nicht so 
streng sein.

der TEst der von oben kommt, soll dann mal später verarbeitet werden... 
spielt im Grunde für das eigentlich Problem erstmal keine Rolle.

Im Grunde wird es viele derartige Funktionen geben, einige senden eine 
feste Anzahl von Zeichen, die in verschiedenen Variablen gespeichert 
zusammngtragen wird, einige sollen eben Zeichen verschicken, deren 
Anzahl sich im Laufe des Betriebes verändert. (Es geht hier um 
Netzwerkverbindungen... Clients und Nodes... und die Anzahl der Clients 
variiert natürlich im Laufe der Zeit), mein Beispiel sendet derzeit nur 
erstmal ein einziges Zeichen um zu sehen wie es funktioniert.. dabei 
will ich aber eben gleich austesten, wie es variabel möglich ist. Da ich 
mir eben sonst an der Grundarchitektur des Programmes etwas anderes 
einfallen lassen muß... daher auch mein Hilfeschrei hier in diesem 
Forum. Mit shared memory könnte ich mir vorstellen, das es zu kristisch 
ist, da innerhalb eines Programmes verschiedene Funktionen gestartet und 
in einem childprozess laufen können, damit kann es eben Konflikte in der 
Laufzeit gben wenn ich gleichzeitig verschiedene Settings hin und 
herschicke und die Prozesse eben nicht stehen bleiben dürfen. Zur Not 
muß ich aber eben doch darauf zurückkommen. Hatte eben nur gehofft das 
ich es irgendwie mit den msgsnd und msgrcv hinbekomme.

ok... muß jetzt erstmal los.. bin aber später wieder online. danke 
nochmal für eure hilfe.

Naja. Das sind dann aber mindestens zwei Probleme, die Du da hast.
Das eine ist recht simpel. msgsnd kann variable Messagelängen.
Aber das andere ist ein Designproblem. Andere Ebene. Schreib doch mal 
was das Ganze soll.

LeDan schrieb:
> Mit shared memory könnte ich mir vorstellen, das es zu kristisch
> ist, da innerhalb eines Programmes verschiedene Funktionen gestartet und
> in einem childprozess laufen können, damit kann es eben Konflikte in der
> Laufzeit gben wenn ich gleichzeitig verschiedene Settings hin und
> herschicke und die Prozesse eben nicht stehen bleiben dürfen.

Warum sollen die nicht stehenbleiben? Schadet doch nichts. Und zur 
Synchronisation gibt es Semaphoren oder Messages etcpp.

ok... hier also nochmal kurz besagte Funktion mit einer übetragung der 
Idee von Karl Heinz... zumidnest so wie ich es verstanden habe.

wenn ich die Funktion ersetzt und laufen lasse, kommt bei der DME eben 
nix oder was falsches an.

int WLME_WMIB_GET_REQUEST(char MSG[]){

  MSGBUF buf;

  struct PARABUF {
      int mtyp; //!< \var int mtyp: defines direction for receive 
messages (2=to DME, 1=from DME)
      int pid;
      char* msg; //!< message field
  };

  PARABUF para;
  para.msg=(char*)malloc(5);

  int qid;
  int qid2;
  int Zahl;

  Zahl=sizeof(WLPInfoBase);

  printf("zu übertragene Zahl: %d\n",Zahl);


  // Buffer leer räumen, damit kein Datenmüll übertragen wird
  memset(buf.msg,0,SIZE);


  // Warteschlangen-ID
  qid = msgget(KEY_WLME, 0600);
  qid2 = msgget(KEY_PLME, 0600);

  //! \TODO complete
  buf.msg[0]=(char)12;
  buf.msg[1]=Zahl&0x000000ff;
  buf.msg[2]=Zahl>>8&0x000000ff;
  buf.msg[3]=Zahl>>16&0x000000ff;
  buf.msg[4]=Zahl>>24&0x000000ff;

  para.msg[0]='G';
  para.mtyp = 12;
  printf("Größe des Strings %d\n", strlen(para.msg));
  msgsnd(qid2, &para, sizeof (PARABUF), 0);

  buf.mtyp = 999;
  msgsnd(qid, &buf, sizeof (MSGBUF), 0);

  printf("zu übertragen ist folgendes Zeichen: %d\n", para.msg[0]);

  printf("in WLME_WMIB_GET_REQUEST - out WLME_WMIB_GET_CONFIRM!!\n");

  //printf("Die Subfunktion WMIB erfolgreich an WLME_P 
übertragen!!\n");

  return 0;

}

meld mich dann später nochmal von wegen sinnhafitgkeit meines vorhabens.

Karl heinz Buchegger schrieb:
> struct MSGBUF* msg = malloc( sizeof( struct MSGBUF) + textlen );

Hi Karl-Hein

ich habe deine Variante jetzt mal nahezu 1:1 übernommen. allerdings 
springt er bei mir bei der obigen Zelle mit der Fehlermeldung aus: 
"ungültige Umwandlung von >>void*<< in >>MSGBUF2*<<"

Was muß ich hier noch ändern?

Karl heinz Buchegger schrieb:
> struct MSGBUF* msg = (struct MSGBUF*) malloc( sizeof( struct MSGBUF) + textlen 
);

Hallo Karl Heinz und auch an alle anderen die hier geschrieben haben.

Ein riesengroßs dickes Dankeschön... Es funzt. Es werden Daten in 
variabler Länge über MSGSND übertragen.
Ich werd mir auf jeden Fall das Thema Shared Memory nochmal anschauen, 
aber das mache ich erst später. Jetzt werd ich erstmal alles etwas 
Dokumentieren und ich bin in meiner Diplomarbeit einen weiteren großen 
Schritt vorangekommen... also nochmal VIELEN VIELEN DANK für eure 
schnelle Hilfe. (Auch wenn ich manchmal ziemlich zu tun hatte dem 
Fachgesimpel zu folgen... aber es hatte sich am Ende gelohnt)

DANKE DANKE DANKE!!

von mir aus kann das Thema geschlossen werden.