Send response (Action *Var)

Klaus schrieb:
> könnt ihr mir sagen, was diese Befehlszeile zu bedeuten hat ins C?

 LOL.
 Das soll Befehlszeile sein ?

Klaus schrieb:
> gib er mir ne Fehlermeldung...
Welcher Compiler? Welche Toolchain? Welcher Target?

> Ich möchte gerne statt a oder b etwas längeres senden
Dann solltest du dir ansehen, wie in C aus einzelnen Chars dann 
komplette Strings zusammengebaut und iwe dei dann dargestellt und 
bearbeitet werden.

> Das ist der Befehlssatz, den ich nicht verstehe.
Das findet sich in jedem x-beliebigen C-Buch ganz weit vorne...

Klaus schrieb:
> Send response (Action *Var)
>      uint_8 success = '1';
>
>      openDocument();
>
>     switch (ab->action) {
>     case 'a':
>     LED_High;
>     _no_operation();
>     break;
>
>     case 'b':
>     LED_LOW
>     break;

Der Code ist so ganz sicher nicht korrekt. Es fehlen geschweifte 
Klammern, mindestes ein Semikolon, zwischen Send und response stand 
vermutlich ein Unterstrich, ...

Klaus schrieb:
> Semikolon und geschweifte Klammer ist beim abschreiben vergessen wurden,
> alles andere passt

Klaus schrieb:
> 2. eventuell könnt ihr mir Tipps geben, wie ich mehr Zeichen senden kann

Könnten wir. Aber die vergisst Du dann eh. ;-)

Im Ernst: Code schreibt man nicht von Hand ab. Dafür gibt es 
Copy-and-Paste.

Klaus schrieb:
> alles andere passt,

Ziemlich sicher nicht.

Im Switch-Statement wird ein Pointer "ab" deferenziert, übergeben wird 
ein Pointer vom Typ "Action", der "Var" heißt.

Nee. So wird das nichts.

Klaus schrieb:
> 1. will ich eigentlich nur den Sinn verstehen.

Dazu muss er erstmal einen Sinn ergeben.

Klaus schrieb:
> 2. eventuell könnt ihr mir Tipps geben, wie ich mehr Zeichen senden kann

Da wird nix gesendet. Der gezeigte Code reagiert auf eine Eingabe 
(Tastendruck?), indem er eine LED bei "a" oder "b" jeweils an- oder 
abschaltet (oder nix tut, falls was anderes eingegeben wurde).

Zusätzlich wird noch eine Funktion "openDocument()" und 
"closeDocument()" aufgerufen, von der wir nur raten können, was sie tut, 
weil sie nicht gezeigt wird.

"Wichtige Regeln - erst lesen, dann posten!", hast Du nicht gelesen, 
oder?

Hallo,

um das zu erweitern, muss einiges umgeschrieben werden. Das Programm 
beinhaltet anscheinend einen (Mikro-)Web-Server, der ankommende Requests 
auseinander nimmt und dann in einer Action-Struktur speichert. Dabei 
wird anscheinend der erste Buchstabe im "action"-Feld gespeichert und 
mögliche weitere Parameter (wie auch immer die in die URI hineinkodiert 
werden) in den folgenden Feldern der Action-Struktur. Im Anschluss wird 
dann sendResponse aufgerufen, in der die Action-Struktur ausgewertet 
wird.

Du muss also mindestens die Action-Struktur erweitern (action darf nicht 
uint8 sein, sondern muss etwas anderes sein, z.B. eine Zeichenkette), 
den URI-Parser des Webservers abändern (damit der die übergebene Adresse 
anders auswertet und den gewünschten Teil korrekt in der Action-Struktur 
speichert), und erst dann lohnt es sich, über Änderungen an sendResponse 
zu reden.

Ausgehend von Deinem scheinbaren Wissensstand könnte das eine steile 
Lernkurve für Dich werden, die - so befürchte ich - beim Erlernen der 
C-Grundlagen beginnen muss.

Schöne Grüße,
Martin

P.S.: Um Deine Frage auch noch zu beantworten: "void sendResponse 
(Action *a) {....}" definiert eine Funktion namens sendResponse, der ein 
Parameter vom Typ "Zeiger auf eine Action-Struktur" übergeben werden 
muss. Diese Funktion wird irgendwo anders in dem Programm dann mit 
"sendResponse(Parameter);" aufgerufen.

Klaus schrieb:
> Da, ich es für eine Schulaufgabe brauche, könntest du mir ein paar
> weitere Tipps geben?

Die Informationslage ist dazu nicht Ausreichend. Du musst erst 
herausfinden, woher das Action objekt kommt und wo es mit Werten befüllt 
wird, dies wurde ja bereits gesagt. Du musst schauen, wo sendResponse 
aufgerufen wird. Dort wird ein Parameter übergeben, welcher auch 
irgendwoher kommt. Irgendwo wird dann den Objekteigenschaften/membern 
ein Wert zugewiesen.

Unter linux kannst du einfach mit grep danach Suchen:

1

grep -rn 'sendResponse' /src/dir/path/

Du wirst dabei vermutlich irgendwo eine Deklaration finden:

1

void sendResponse (Action *a);

2

//oder

3

void sendResponse (Action*);

4

//oder

5

void sendResponse ();

Die ist erstmal uninteressant. Du suchst nach soetwasem:

1

sendResponse(beliebigeVariable);

2

// oder

3

sendResponse(&beliebigeVariable);

4

// oder

5

sendResponse(beliebiger->ausdruck);

6

// etc.

Es kann auch sein das dass Action-objekt noch weiteren Funktionen 
mitgegeben wird, oder von einer zurückgegeben wird, etc. Dort muss du 
dann auch nach der Initialisierung des Members action suchen.

Solltest du soetwas wie folgendes finden, wird es viel komplizierter:

1

irgendwas = &sendResponse;

Irgendwo müsste dann der Member action des Action objekts initialisiert 
werden. dies ist eine der stellen, wo etwas geändert werdwn muss:

1

irgendwas->action = irgendwasanderes;

2

//oder

3

irgendwas.action = irgendwasanderes;

4

// oder komplexer

5

uint8_t* x = &irgendwas.action;

6

...

7

*x = irgendwasanderes;

8

//etc.

Wir können nicht hellsehen, wo was im Code steht, es gibt noch unzählige 
andere möglichkeiten, wie das Action objekt initialisiert werden könnte 
oder sendResponse aufgerufen werden könnte.

Interresant. Die Funktion sendResponse wird im Code offenbar nirgens 
Referenziert, ich gehe davon aus, dass diese von einer Library aus 
aufgerufen wird. Das Action objekt scheint auch in der Library 
allociiert zu werden. Falls diese Library nicht Open Source sein sollte 
kann das struct Action möglicherweise nicht geändert werden, aber dass 
kann ich nicht mit absoluter Sicherheit sagen.

Es sieht so aus, als ob "handleAction" jeweils mit einer 
nullterminierten URL in "parserBuffer" aufgerufen wird, und 
"handleParameter" mit einem GET Parameternamen oder Parameterwert. Dabei 
findet keine Urldecodierung statt.

Die Auswertung muss in "handleAction" und "parserBuffer" erfolgen.
Jenachdem was für Adressen man verarbeiten will muss man unterschiedlich 
vorgehen.

Ich würde es umsetzen, indem ich eine Liste der Aktionen zu den URLs + 
ein Enum pro Aktion erstelle.
Das könnte dann so aussehen: (ungetestet, könnte also noch fehler 
beinhalten)

1

#define MAX_PARAM_COUNT 4

2

typedef const char* action_parameter_name_list_t[MAX_PARAM_COUNT];

3

4

#define MY_ACTION_LIST \

5

  X( LED_ON , "led/on" , ("id") ) \

6

  X( LED_OFF, "led/off", ("id") )

7

8

#define X( ACTION, PATH, PARAMS ) { PATH, { Y PARAMS } },

9

#define Y(...) __VA_ARGS__

10

typedef struct {

11

  const char* path;

12

  action_parameter_name_list_t params;

13

} my_action_info_t;

14

my_action_info_t my_action_info[] = {

15

  MY_ACTION_LIST

16

};

17

#undef Y

18

#undef X

19

#define X( ACTION, PATH, PARAMS ) MY_ACTION_TYPE_ ## ACTION,

20

enum  my_action_type {

21

  MY_ACTION_LIST

22

  MY_ACTION_TYPE_COUNT,

23

  MY_ACTION_TYPE_INVALID = MY_ACTION_TYPE_COUNT

24

};

25

#undef X

26

27

28

void handleAction(Action *a) {

29

30

  memset( a, 0, sizeof(*a) );

31

32

  const char* location = (const char*)parserBuffer;

33

  enum my_action_type action;

34

35

  for( action = 0; action < MY_ACTION_TYPE_COUNT; action++ )

36

    if( !strcmp( my_action_info[action].path, location ) )

37

      break;

38

39

  a->action = action;

40

41

}

42

43

void handleParameter( Action *a, uint8_t state ){

44

45

  if( a->action == MY_ACTION_TYPE_INVALID )

46

    return;

47

48

  static int pind = -1;

49

  const char* value = (const char*)parserBuffer;

50

  my_action_info_t* inf = my_action_info + action;

51

52

  if( status == PARAM_NAME ){

53

    int i;

54

    for( i=MAX_PARAM_COUNT; i--; )

55

      if( inf->params[i] && !strcmp( inf->params[i], value ) )

56

        break;

57

    pind = i;

58

  }

59

60

  if( status == PARAM_VALUE && i >= 0 ){

61

    uint8_t* pvals = &a->param1 + i; // Lazy hack

62

    *pvals = atoi( value ); // Parameter als Integer interpretieren

63

  }

64

65

}

66

67

void sendResponse(Action *a) {

68

  uint8_t success = '1';

69

  openDocument();

70

71

  enum my_action_type action = a->action;

72

73

  switch( action ){

74

    case LED_ON: { // http://192.168.6.2/led/on?id=X

75

      if( a->param1 == 1 ){ // wenn parameter id 1 ist

76

        LED1_HIGH; // dann LED1 an

77

        __no_operation();                       // For debugger

78

      }

79

    } break;

80

    case LED_OFF: { // http://192.168.6.2/led/off?id=X

81

      if( a->param1 == 1 ){ // wenn parameter id 1 ist

82

        LED1_LOW; // LED1 aus

83

        __no_operation();                       // For debugger

84

      }

85

    } break;

86

    case MY_ACTION_TYPE_INVALID: break;

87

  }

88

89

  closeDocument(success);

90

}

Klaus schrieb:

>
> also den deinen Code habe ich eingebaut, aber der hat mir soviel Fehler
> ausgelistet. Waren zuviele, um hier zu posten.

Man kann auch Dateien anhängen.

> Wenn ich http://192.168.6.2/ab sende, dann macht er genau die selben
> Aktionen wie oben, das heist, er speichert auch das b in den Buffer.
> Aber bei
>
> void handleAction(Action *a) {
>   uint8_t byte = parserBuffer[0]; //hier
>   a->action = byte;
>
> holt er sich hier nur das a statt auch das b.
> liegt das am uint8_t byte? wie kann ich es verändern, dass er auch das b
> holt?

Wie ich bereits sagte, es befindet sich eine nullterminierten URL in 
"parserBuffer". Bei obiger Beispiel URL wären in "parserBuffer" die 
Zeichen 'a', 'b' und '\0' vorhanden. Wäre die URL 
http://192.168.6.2/ab?bc wären es immernoch 'a', 'b' und '\0'. Ein 
C-String ist ein char Array, welches nullterminiert ist. parserBuffer[0] 
ist das nullte Element in "parserBuffer", also ein (uint8_t)'a', 
parserBuffer[1] wäre ein (uint8_t)'b' und parserBuffer[2] wäre 0. 
"uint8_t" ist normalerweise das selbe wie "unsigned char", wärend ein 
Zeichen eines c-string den Type "char" mit unbekannter signedness hat. 
Der C-String selbst hat dann den Typ "char[n]" oder "char*".
Ein "unsigned char" ist gleichgross wie ein "char" und somit meistens 
gleich gross wie ein "uint8_t", hat also nur Platz für 1 Zeichen. 
(Nebenbei, ein uint8_t wird normalerweise für Zahlen statt Zeichen 
verwendet)

Es ist also nicht möglich mehr als ein Zeichen im Member action des 
Objects a zu Speichern. Es kann auch kein Pointer auf den String 
gespeichert werden (ausser man kopiert ihn vorher), da dieser in 
"parserBuffer" enthalten ist und der Inhalt von "parserBuffer" nach dem 
Verlassen der Funktion "handleAction" überschrieben wird. Ausserdem ist 
unklar, ob das Strukt Action verändert werden Darf.

Unter diesen Voraussetzungen hatt man eigentlich nicht viel mehr 
Möglichkeiten, als den URLs nummern zuzuordnen und die Nummer in 
a->action zu speichern. Die URLs kann man mit strcmp in "handleAction" 
vergleichen:

1

// Cast von uint8_t Array nach C-String (char array)

2

const char* location = (const char*)parserBuffer;

3

if( !strcmp(location,"ab") ){

4

  a->action = 1; // location war ab, setze a->action auf 1

5

}else if( !strcmp(location,"test") ){

6

  a->action = 2; // location war test, setze a->action auf 2

7

}else{

8

  a->action = 0; // location entsprach keinem Vergleich, setze a->action auf 0

9

}

Klaus schrieb:
> Daniel A. schrieb:
>> Wäre die URL
>> http://192.168.6.2/ab?bc wären es immernoch 'a', 'b' und '\0'.
>
> Die URL kann nach 192.168.6.2/ sein, wie ich  eswill. es gibt keine
> feste vorgaben, nur das mehr als ein Zeichen gesendet werden soll.

Darauf wollte ich eigentlich nicht hinaus. Wie dem auch sei, die Zeichen 
werden hier doch nur Empfangen und Ausgewertet, aber doch nirgens 
gesendet?

> Daniel A. schrieb:
>> Es kann auch kein Pointer auf den String
>> gespeichert werden (ausser man kopiert ihn vorher), da dieser in
>> "parserBuffer" enthalten ist und der Inhalt von "parserBuffer" nach dem
>> Verlassen der Funktion "handleAction" überschrieben wird. Ausserdem ist
>> unklar, ob das Strukt Action verändert werden Darf.
>
> Ja, die Structure darf verändert werdeen, ansonsten kopieren wir ihn
> vorher.

Gut, wenn du dir da wirklich sicher bist, dann könnte man in 
"typedefs.h" aus dem uint8_t action ein uint8_t oder char array machen 
"char action[32];". Die Zahl zeigt die Anzahl Elemente im Arrays an, 
wobei bei c-strings das Letzte Zeichen den wert 0 haben muss. Somit 
haben darin Maximal zahl-1 Zeichen Platz.

> Daniel A. schrieb:
>> Wie ich bereits sagte, es befindet sich eine nullterminierten URL in
>> "parserBuffer".
>
> Kann ich die nicht so verändern, dass sie nicht nullterminiert ist. dann
> köönnte man einen geeigneten Datentypen wählen.

Das eine hat mit dem Anderen nichts zu tun. Nullterminiert bedeutet nur, 
dass das letzte Zeichen den Wert 0 hat. Ein derartiges zeichen nennt man 
auch Nullbyte, es unterscheidet sich nicht von den Anderen Zeichen und 
wurde der Einfachheit halber zur Markerung des Endes des Strings 
verwendet. Dies ist eine Konvention an die bis Heute fast alle C 
Programme festhalten. Mit dem Datentyp hat dies nichts zutun.

> Ansonsten, könnte man doch jedes Zeichen in eine
> Variable speichern und später alle zusammen auswerten

Das würden zuviele Variablen. Deshalb gibt es Arrays, das sind 
eigentlich Listen mit Elementen eines Typs. Wäre a->action ein char oder 
uint8_t array, könnte man mit 
"strncpy((char*)a->action,(char*)parserBuffer,sizeof(a->action));" 
mehrere Zeichen in dieses Array kopieren. Ich glaube aber nicht, dass 
dies sinnvoll ist, da schlussendlich ja nur die Auswertung woanders 
stattfindet, oder brauchst du wirklich diese Zeichenkette?

Im Anhang sind 2 Versionen von 2 meiner Vorschläge, die eigentlich 
kompilierbar sein sollten.