Pointer übergabe führt zum Absturz?

[Steffen W. (Gast)]

Moin,

kurze Frage. Was mache ich falsch?

Wenn ich den Pointer übergebe, stürzt das Programm ab.

char *inBuff = "+ADDR:1234:56:abcdef";

Mache ich es via. Array, klappt es.

char inBuff[] = "+ADDR:1234:56:abcdef";

int8_t srchCmd(char *inBuff, char *srchCmd)
{
     char *cmdBeginn   = NULL;
     char *cmdEnd       = NULL;
     char *rawData    = NULL;    
   char cmdStrLen      = strlen(srchCmd);
   char inBuffStrLen  = strlen(inBuff);
   char rawData_    = 0;

   if(inBuffStrLen < cmdStrLen)
   return -1;

   /*
   *  how much raw data we will received?
   */
   rawData = strchr(srchCmd,'x');   
   if(rawData != NULL)
   {
     while(*rawData++ != NULL){rawData_++;}
   }

[Walter S. (avatar)]

das Programm kann nicht abstürzen, das Unterprogramm wird nirgends 
aufgerufen
Ansonsten liegt der String vielleicht im ROM?
Welcher Prozessor/Compiler?

[Steffen W. (Gast)]

Hier noch mal komplett.

int8_t srchCmd(char *inBuff, char *srchCmd)
{
     char *cmdBeginn   = NULL;
     char *cmdEnd       = NULL;
     char *rawData    = NULL;    
   char cmdStrLen      = strlen(srchCmd);
   char inBuffStrLen  = strlen(inBuff);
   char rawData_    = 0;

   if(inBuffStrLen < cmdStrLen)
   return -1;

   /*
   *  how much raw data we will received?
   */
   rawData = strchr(srchCmd,'x');   
   if(rawData != NULL)
   {
     while(*rawData++ == 'x'){rawData_++;}
   }
      
     /*
     *    search first character from our string without nx
     */
   char *cmdBeginn_ = malloc(sizeof(char)*cmdStrLen);
   strcpy(cmdBeginn_,srchCmd);
     
     /*
     *  mask the nx out
     */ 
   cmdBeginn_ += (cmdStrLen-rawData_);
     *cmdBeginn_ = '\0';
     cmdBeginn_ -= (cmdStrLen-rawData_);
        
     cmdBeginn = strstr(inBuff,cmdBeginn_);
   if(cmdBeginn == NULL)
     return -2;
     
     /*
     *    search last character from our string
     */     
     cmdEnd = strrchr(cmdBeginn,cmdBeginn_[cmdStrLen-rawData_]);
     if(cmdEnd == NULL)
     return -3;

     /*
     *    terminate end of serached string
     */
     cmdBeginn+=cmdStrLen;
     *cmdBeginn = '\0';
     cmdBeginn-=cmdStrLen;

     /*
     *    copy the command to "inBuff"
     */
     strcpy(inBuff,cmdBeginn);

     return 0;
}

int main(int argc, char *argv[]){

  char *inBuff = "+ADDR:1234:56:abcdef";  
  
  printf("Function Result.: %d\r\n",srchCmd(inBuff,"+ADDR:xxxxxxxxxxxxxx"));
  
  return 0;
}

[Sebastian V. (sebi_s)]

Ist die Funktion so vollständig? Es fehlt wenigstens die letzte 
schließende Klammer. Überprüfe mal ob inBuf in der Funktion nicht 
verändert wird und wenn nicht mache sie const. Wenn du einen Pointer mit 
einem String Literal initialisierst dann zeigt der Pointer auf einen 
const String und dementsprechend sollte der Pointer hier ebenfalls const 
sein.

Ansonsten zeig mal wie du die Funktion aufrufst mit beiden Varianten.

Edit: Wie schon vermutet schreibst du in deinen Pointer der eigentlich 
const sein müsste:

strcpy(inBuff,cmdBeginn);

[DanVet (Gast)]

Bei der Zeigervariante liegt dein String eventuell im ROM/Flash.
Bei der Arrayvariante liegt dein String im Array, also RAM.

Je nach Zielsystem kann nicht einfach auf das ROM/Flash zugegriffen 
werden.
Welches ist dein Zielsystem?

Dein Beispiel mit einem PC-Programm umgesetzt funktioniert :-)

[Steffen W. (Gast)]

DanVet schrieb:
> Bei der Zeigervariante liegt dein String eventuell im ROM/Flash.
> Bei der Arrayvariante liegt dein String im Array, also RAM.
>
> Je nach Zielsystem kann nicht einfach auf das ROM/Flash zugegriffen
> werden.
> Welches ist dein Zielsystem?
>
> Dein Beispiel mit einem PC-Programm umgesetzt funktioniert :-)

Ich nutze es auf dem PC. DevC++

[Steffen W. (Gast)]

Ihr hattet Recht.
Wenn ich vorher für den Pointer Speicher reserviere, klappt es!

int main(int argc, char *argv[]){


  char *inBuff = malloc(sizeof(char)*50);
  strcpy(inBuff,"+ADDR:1234:56:abcdef");
  
  printf("Function Result.: %d\r\n",srchCmd(inBuff,"+ADDR:xxxxxxxxxxxxxx"));
  printf(getBlthAddr(inBuff));
  
  return 0;
}

[Mampf F. (mampf)]

Steffen W. schrieb:
> char *cmdBeginn_ = malloc(sizeof(char)*cmdStrLen);
>    strcpy(cmdBeginn_,srchCmd);

Da ist kein Platz für die 0-Terminierung ... Du brauchst 1 Byte mehr als 
der String lang ist.

Sicherheitshalber sollte man eh kein strcpy verwenden sondern strncpy

[fop (Gast)]

Mal in's blaue geraten : Dein C-Compiler Bildet aus den ASCII-Werten von 
+ADD
eine 32-bittige Zahl und castet sie auf eine Speicheradresse. Auf diese 
Adresse zeigt dann Dein Pointer. Das ist natürlich gequirlter Quatsch 
und gar nicht, was Du willst.

[Konstante (Gast)]

Steffen W. schrieb:
> int8_t srchCmd(char *inBuff, char *srchCmd)

besser

... srchCmd(char *inBuff, const char* const srchCmd)...

dann sieht man, was man ändern darf und was nicht.