[C] Bytes x-y aus char-array lesen

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [C] Bytes x-y aus char-array lesen

    Hi,
    gibt es einen besseren weg um eine sequenz von byte x bis byte y aus einem char-array zu lesen als eine for-schleife?

    Vielen Dank,
    Luke

    PS: [entfernt]
    Zuletzt geändert von wahsaga; 16.10.2006, 15:02.

  • #2
    Re: [C] Bytes x-y aus char-array lesen

    Per "P.S.: [link]" auf andere Threads von dir hinzuweisen, weil du vielleicht Angst hast, sie könnten übersehen werden, fällt in die Rubrik Aufdringlichkeit und Drängelei, und unterbleibt bitte zukünftig.
    I don't believe in rebirth. Actually, I never did in my whole lives.

    Kommentar


    • #3
      ok

      Kommentar


      • #4
        Re: [C] Bytes x-y aus char-array lesen

        Original geschrieben von Luke
        Hi,
        gibt es einen besseren weg um eine sequenz von byte x bis byte y aus einem char-array zu lesen als eine for-schleife?

        Vielen Dank,
        Luke

        PS: [entfernt]
        z.B. strncpy

        Kommentar


        • #5
          Hm, strncopy hat das Problem dass man zwar eine länge aber kein offset angeben kann. memcpy würde vielleicht gehen wenn man man einen Pointer so verändern könnte dass er auf die entsprechende Stelle zeigt. Bsp (pseudo-code):

          ( array[5]-array[10] lesen):
          char * pArray = &array+5;
          memcpy(stringAusschnitt, pArray, 5);

          Kommentar


          • #6
            Hi,

            was willst du genau machen ? Was hab ich mir unter squenz vorzustellen ?
            Wofür sollen die extrahierten bytes verwendet werden ?

            Schickst du strukturierte daten als char*-pointer durch die gegend ?
            Wenn ja, dann structur einfach drauf-casten.

            Wenn es wirklich nur um strings geht, dann nochmal ein kapitel zu
            zeigerarithmetik durchlesen. Es ist einfacher als gedacht


            greets
            (((call/cc call/cc) (lambda (x) x)) "Scheme just rocks! and Ruby is magic!")

            Kommentar


            • #7
              Lang:

              Was ich machen will ist folgendes: Ich sende einen String über TCP (ach, wenn ich hier von string rede, muss ich dazu sagen dass es in C geschrieben und somit ein Char-Array ist), in dem eine Liste von (Musik-)Künstlern und deren Alben ist. Das ganze in eine proprietären format (á la, 3bytes für die länge des Künstlernamens, dann der Name selbst gefolgt von 3 bytes der anzahl der alben, gefolgt von [...]). Diesen String möchte ich nun entschlüsseln, dafür muss ich 3 bytes für die länge lesen, dann von dem offset aus die ausgelesene länge für den künstlernamen und so weiter.

              Kurz:

              Ich will von einem bestimmten Offset aus eine bestimmte Länge aus einem String (genau genommen einem Char-Array (C-kein-plus-plus)) auslesen. Das ganze mit memcpy, weiß ich jeztzt, so (aus einem String von Position 5, 5 Zeichen auslesen):

              Code:
              memcpy(stringAusschnitt, &array[5], 5);

              Kommentar


              • #8
                Die lange beschreibung hört sich an wie ein anwendungsfall
                für strkturen mit bitfeldern. Wenn du die struktur definiert hast,
                kanns du sie dann einfach draufcasten. Das geht für die header-daten.
                Also längen uns solche geschichten.

                Die kurze beschreibung hört sich wirklich wie ein fall für strncpy an.
                Du addierst x bytes zum anfang des strings und kopierst dann.

                greets
                (((call/cc call/cc) (lambda (x) x)) "Scheme just rocks! and Ruby is magic!")

                Kommentar


                • #9
                  Original geschrieben von closure
                  Die lange beschreibung hört sich an wie ein anwendungsfall
                  für strkturen mit bitfeldern. Wenn du die struktur definiert hast,
                  kanns du sie dann einfach draufcasten. Das geht für die header-daten.
                  Also längen uns solche geschichten.
                  Versteh ich nciht ganz; Ist das so was wie (un)serialisieren?

                  Kommentar


                  • #10
                    Naja so ähnlich nur ohne großes serialisieren.
                    Wenn man sich mal netzwerklibs anschaut sieht man sowas.
                    Hier mal beispielhaft, wie man an den ip-header aus einem
                    tcp-packet kommt. Die header-code stammt aus libnet.

                    Code:
                    struct libnet_ip_hdr
                    {
                    #if (LIBNET_LIL_ENDIAN)
                        u_char ip_hl:4,         /* header length */
                                ip_v:4;         /* version */
                    #endif
                    #if (LIBNET_BIG_ENDIAN)
                        u_char ip_v:4,          /* version */
                                ip_hl:4;        /* header length */
                    #endif
                        u_char ip_tos;          /* type of service */
                        u_short ip_len;         /* total length */
                        u_short ip_id;          /* identification */
                        u_short ip_off;
                    #ifndef IP_RF
                    #define IP_RF 0x8000        /* reserved fragment flag */
                    #endif
                    #ifndef IP_DF
                    #define IP_DF 0x4000        /* dont fragment flag */
                    #endif
                    #ifndef IP_MF
                    #define IP_MF 0x2000        /* more fragments flag */
                    #endif 
                    #ifndef IP_OFFMASK
                    #define IP_OFFMASK 0x1fff   /* mask for fragmenting bits */
                    #endif
                        u_char ip_ttl;          /* time to live */
                        u_char ip_p;            /* protocol */
                        u_short ip_sum;         /* checksum */
                        struct in_addr ip_src, ip_dst; /* source and dest address */
                    };
                    Ein netzwerkpacket wiederum ist nun nur eine folge von bytes.
                    Wie bekommt man die also in so eine structur ?
                    Naja in C gehts einfach

                    Code:
                    /*packet von irgendwo her gelesen*/
                    /* packet ist vom typ char* */
                    struct libnet_ip_hdr *ip_h = (struct libnet_ip_hdr*)packet;
                    printf("%d %d %d",ip_h->ip_tos,ip_h->len,ip_h->ip_id);
                    Das meinte ich. Sowas ähnliches lässt sich sicher auch mit
                    deinen daten machen.

                    greets
                    (((call/cc call/cc) (lambda (x) x)) "Scheme just rocks! and Ruby is magic!")

                    Kommentar


                    • #11
                      Du meinst man kann einfach ein struckt nehmen (in meinem Fall ein Array eines Struckts), es per send(socket, strucktArray, sizeof(strucktArray), 0); verschicken, und dann per typumwandlung auf dem Client einfach wieder benutzen? Das wär genial! Ich werd's mal ausprobieren...

                      PS: geht das auch wenn die Structs char-arrays variabler länge enthalten (album- und küstlernamen)?
                      Zuletzt geändert von Luke; 16.10.2006, 18:54.

                      Kommentar


                      • #12
                        Jupp mein ich. Man sagt dem c-compiler mit dem cast:
                        "Hey ich weiss was ich tue, ich will dass du die bytes deren
                        anfangsaddresse im pointer xy gespeichert ist, als folgende
                        struktur interpretierst."

                        Zur zweiten frage. Naja so direkt geht es nicht aber man kann
                        zumindest mal in header-daten und payload unterscheiden.
                        Da informationen über den payload im header enthalten sind,
                        kann man dann dynamisch speicher anfordern und den payload
                        rüberkopieren.


                        greets
                        (((call/cc call/cc) (lambda (x) x)) "Scheme just rocks! and Ruby is magic!")

                        Kommentar


                        • #13
                          Original geschrieben von closure
                          Zur zweiten frage. Naja so direkt geht es nicht aber man kann
                          zumindest mal in header-daten und payload unterscheiden.
                          Da informationen über den payload im header enthalten sind,
                          kann man dann dynamisch speicher anfordern und den payload
                          rüberkopieren.
                          So ganz versteh ich das nicht. Das Problem ist doch nicht die Länge eines bereits gesendeten Strings (/char-arrays) herauszufinden (obwohl das auf zum Problem werden könnte), sondern das senden der Strings, da wenn du Strings (/char-arrays) in nem Struct dynamisch halten willst, pointer verwenden und nachträglich Speicher alloziieren musst, so dass beim senden nur die Pointer und nicht die Strings (/char-blabla) gesendet werden.

                          Bsp:

                          Code:
                          typedef struct {
                          	char * name;
                          	int num_albums;
                          	char ** albums;
                          } artist_entry;
                          
                          artist_list[ i ].name = (char*)malloc(artist_name_lenght);
                          Warum ich den speicher nachträglich alloziieren will? Weil ich ein Array artist_list habe das aus artist_entrys besteht und da natürlich artists (musikkünstler) unterschiedlicher namenlängen drin sind (max. artistlänge möchte ich wenn möglich vermeiden). Das bringt mich aber zur 2ten Frage: Kann man auch Arrays von Structs verschicken? Und wie macht man ne typenumwandlung von nem String zu nem struct-array?

                          Kommentar


                          • #14
                            Original geschrieben von closure
                            Naja so ähnlich nur ohne großes serialisieren.
                            Wenn man sich mal netzwerklibs anschaut sieht man sowas.
                            Hier mal beispielhaft, wie man an den ip-header aus einem
                            tcp-packet kommt. Die header-code stammt aus libnet.

                            greets
                            Dringende Nachfrage dazu: Wie komme ich in PHP an die TCP/IP Header Informationen?

                            Ich brauche den MTU/MSS Wert aus dem IP Header und die Fenstergröße aus dem TCP Header. Und von PHP habe ich nur wenig Ahnung...


                            Gruß Holger

                            Kommentar


                            • #15
                              Und von PHP habe ich nur wenig Ahnung...
                              Und warum willst du es dann mit C probieren ???? Ich vermute mal stark, dass du da in ne Wand läufst...
                              Ah jetzt habe ichs gesehen, du hast nur ins falsche Forum gepostet.

                              Gruss

                              tobi
                              Gutes Tutorial | PHP Manual | MySql Manual | PHP FAQ | Apache | Suchfunktion für eigene Seiten

                              [color=red]"An error does not become truth by reason of multiplied propagation, nor does truth become error because nobody sees it."[/color]
                              Mohandas Karamchand Gandhi (Mahatma Gandhi) (Source)

                              Kommentar

                              Lädt...
                              X