Not logged in. · Lost password · Register

ingonör
Member since May 2013
67 posts
Subject: Klausur 2010-07
Hallo,

ich hatte einen Stolperstein in der Aufgabe. Man soll den Referenzzeitpunkt ermitteln. Dazu muss ich ja st_mtime der backup.timestamp prüfen.
In Zeile 20 könnt ihr sehen, wie ich das mache. Ist das Vorgehen so in Ordnung? Eigentlich hätte ich mit strcat() gearbeitet, weil wir das so in der Übung gemacht hätten. Aber die string.h ist ja nicht inkludiert.
Passt auch meine Argumentenprüfung in Zeile 13 oder soll man da noch mehr prüfen?

Vielen Dank und liebe Grüße
ingonör

  1.  
  2. #include <dirent.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <errno.h>
  6. #include <sys/stat.h>
  7. #include <unistd.h>
  8.  
  9. /* Funktion main */
  10. int main(int argc, char **argv) {
  11.  
  12. /* Aufrufargument pruefen, Referenzzeitpunkt ermitteln */
  13.         if (argc < 2) {
  14.                 fprintf(stderr, "no path given. terminating\n");
  15.                 exit(1);
  16.         }
  17.  
  18.         char path[1024];
  19.         struct stat buf;
  20.         sprintf(path, "%s%s", argv[1], "/backup.timestamp");
  21.         stat(path, &buf);
  22.         time_t backup = buf.st_mtime;
  23.  
  24. /* Verzeichnis oeffnen und durchsuchen, Dateinamen ausgeben */
  25.         DIR *directory;
  26.         struct dirent *entry;
  27.  
  28.         if ((directory = opendir(argv[1])) == NULL) {
  29.                 perror("opendir");
  30.                 exit(1);
  31.         }
  32.  
  33.         while (errno = 0, (entry = readdir(directory)) != NULL) {
  34.                 sprintf(path, "%s%s%s", argv[1], "/", entry->d_name);
  35.                 stat(path, &buf);
  36.                 if (entry->d_name[0] != '.' && (S_ISREG(buf.st_mode) == 1) && \
  37.                         buf.st_mtime > backup) {
  38.                         printf("%s\n", path);
  39.                 }
  40.         }
  41.  
  42.         if(errno) {
  43.                 perror("readdir");
  44.                 exit(1);
  45.         }
  46.         closedir(directory);
  47.  
  48. /* Ende der Funktion main */
  49. }


Edit: Und mag noch jemand kurz über meine Lösungsvorschläge für die Theoriefragen drüberschauen? Bin mir vor allem bei der letzten Aufgabe nicht so sicher, wo man die Speicherbelegung der "reg"-Variablen einzeichnen soll.
[Image: https://dl.dropboxusercontent.com/u/7261736/Foren/SPIC2010-07.JPG]
This post was edited on 2013-07-22, 12:39 by ingonör.
Raim
GSPiC-Guru
Member since May 2011
79 posts
Quote by ingonör:
Aber die string.h ist ja nicht inkludiert.

Daraus würden wir dir bei der Korrektur sicherlich keinen Strick drehen. Die Funktion strcat() ist ja aus den Übungen bekannt. Und wenn du ganz sicher gehen willst, schreibst du das #include <string.h> halt noch dazu ;-)

Alternativ lässt sich das auch mit chdir() lösen, dann entfällt das Zusammensetzen der Pfade.
Musil
Member since Jul 2013
10 posts
Wenn es heißt: "reguläre" Dateien, sind dann automatisch alle versteckten Dateien ausgeschlossen?

Ich hab auch nochmal eine Lösung mit strcpy und strcat, würde die funktionieren? (also ich meine damit, ob es auf irgendwas davon Punktabzug geben würde)
Sry, ich hab weder Linux, noch eine Shell, noch irgendeine Programmierumgebung und vor allem keine Ahnung, wie ich das testen sollte.
  1. /*Funktion main*/
  2. int main(int argc, char **argv){   
  3.  
  4.     /*Aufrufargument pruefen, Referenzzeitpunkt ermitteln*/
  5.    
  6.     if(argc!=2){
  7.         fprintf(stderr, "wrong amout of arguments");
  8.         exit(EXIT_FAILURE);
  9.     }
  10.     char path[1024];
  11.     strcpy(path, argv[1]);
  12.     strcat(path, "/back.timestamp");
  13.     struct stat inf;
  14.     time_t backup;
  15.     if(lstat(path,&inf)==0){
  16.         backup = inf.st_mtime;
  17.     } else{
  18.         perror("lstat");
  19.         exit(EXIT_FAILURE);
  20.     }
  21.  
  22.    
  23.     /*Verzeichnis oeffnen*/
  24.     DIR* ver = opendir(argv[1]);
  25.     if(ver==NULL){
  26.         perror("opendir");
  27.         exit(EXIT_FAILURE);
  28.     }
  29.    
  30.     for(struct dirent *eintrag; (eintrag = readdir(ver)) != NULL; errno =0){
  31.         char name[1024];
  32.         struct stat buf;
  33.         strcpy(name, argv[1]);
  34.         strcat(name, "/");
  35.         strcat(name, eintrag->d_name);
  36.         if(lstat(name, &inf)==0){
  37.             if(S_ISREG(inf.st_mode)){
  38.                 if(inf.st_mtime>backup){
  39.                     printf("%s\n", name);
  40.                 }
  41.             }
  42.         } else {
  43.             perror("lstat");
  44.             exit(EXIT_FAILURE);
  45.         }
  46.        
  47.     }   
  48.        
  49.     }
  50.     if(errno){
  51.         perror("readdir");
  52.         exit(EXIT_FAILURE);
  53.     }
  54.     if(closdir(ver)){
  55.         perror("closedir");
  56.         exit(EXIT_FAILURE);
  57.     }
  58. }

Und noch eine Frage zu strcpy:
z.B:
  1. char buf[100];
  2. strcpy(buf, "Marmelade");
  3. strcpy(buf, "Brot");
steht jetzt in buf nur "Brot" oder "Brotelade" oder etwas ganz anderes?
morty
SPiC-Meister
(Moderator)
Member since May 2011
331 posts
Du solltest noch mit der Länge aufpassen. Wenn dein Pfad länger als 1024 Zeichen wird krachts!

Was strcpy angeht.
char *strcpy(char *dest, const char *src);
The  strcpy() function copies the string pointed to by src, including the terminating null byte ('\0'), to the buffer pointed to by dest.
yk53avux
Member since Sep 2011
3 posts
Steht das mit der Größe eines Unions im Skript drin?
Ich finde das jedenfalls nicht...
ingonör
Member since May 2013
67 posts
Die Seite half mir recht gut.

http://openbook.galileocomputing.de/c_von_a_bis_z/015_c_st…
yk53avux
Member since Sep 2011
3 posts
struct test1 {
   char a;
   int b;
   double c;
};

Müsste diese Struktur nicht 13 Byte haben? Also Double (8 Byte) + integer (4 Byte) + char (1 Byte)
Auf der Seite steht, dass diese Struktur 16 Byte benötigt.
morty
SPiC-Meister
(Moderator)
Member since May 2011
331 posts
Quote by yk53avux:
struct test1 {
   char a;
   int b;
   double c;
};

Müsste diese Struktur nicht 13 Byte haben? Also Double (8 Byte) + integer (4 Byte) + char (1 Byte)
Auf der Seite steht, dass diese Struktur 16 Byte benötigt.

Sie benötigt mindestens 13 Byte. Auf dem AVR ist das auch der Fall. Im Standard steht aber, dass der Compiler da Füllbytes einfügen darf.  Erklärt wird das hier: (vgl. http://openbook.galileocomputing.de/c_von_a_bis_z/015_c_st…) Dass das vom Betriebssystem abhängt ist allerdings falsch! Dies hängt von meinem Compiler ab vgl https://de.wikipedia.org/wiki/Bin%C3%A4rschnittstelle.
Close Smaller – Larger + Reply to this post:
Verification code: VeriCode Please enter the word from the image into the text field below. (Type the letters only, lower case is okay.)
Smileys: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O :troll:
Special characters:
Go to forum
Powered by the Unclassified NewsBoard software, 20110527-dev, © 2003-8 by Yves Goergen