getutent(3) Library Functions Manual getutent(3) BEZEICHNUNG getutent, getutid, getutline, pututline, setutent, endutent, utmpname - auf Eintrage der utmp-Datei zugreifen BIBLIOTHEK Standard-C-Bibliothek (libc, -lc) UBERSICHT #include struct utmp *getutent(void); struct utmp *getutid(const struct utmp *ut); struct utmp *getutline(const struct utmp *ut); struct utmp *pututline(const struct utmp *ut); void setutent(void); void endutent(void); int utmpname(const char *Datei); BESCHREIBUNG Neue Applikationen sollten die in POSIX.1 spezifizierten >>utmpx<<-Versionen dieser Funktionen verwenden, siehe STANDARDS. utmpname() setzt den Namen der Datei im utmp-Format, auf die die anderen utmp-Funktionen zugreifen. Wenn utmpname() nicht benutzt wird, um den Dateinamen zu setzen bevor die anderen Funktionen benutzt werden, wird von diesen _PATH_UTMP angenommen, wie in definiert. setutent() setzt den Dateizeiger auf den Anfang der Datei utmp zuruck. Im Allgemeinen ist es sinnvoll, dies vor Verwendung der anderen Funktionen aufzurufen. endutent() schliesst die Datei utmp. Sie sollte aufgerufen werden, wenn die Verwendung der anderen Funktionen im Benutzercode beendet ist. getutent() liest eine Zeile ab der aktuellen Dateiposition in der Datei utmp. Es wird ein Zeiger auf eine Struktur zuruckgegeben, welche die Felder der Zeile enthalt. Die Definition dieser Struktur ist in utmp(5) aufgeschlusselt. getutid() sucht ab der aktuellen Dateiposition in der Datei utmp vorwarts, basierend auf ut. Wenn ut->ut_type gleich RUN_LVL, BOOT_TIME, NEW_TIME oder OLD_TIME ist, findet getutid() den ersten Eintrag, dessen Feld ut_type ut->ut_type entspricht. Wenn ut->ut_type gleich INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS oder DEAD_PROCESS ist, findet getutid() den ersten Eintrag, dessen Feld ut_id ut->ut_id entspricht. getutline() sucht ab der aktuellen Dateiposition in der Datei utmp vorwarts. Die Funktion uberpruft Eintrage, deren Feld ut_type gleich USER_PROCESS oder LOGIN_PROCESS ist und gibt den ersten Eintrag zuruck, dessen Feld ut_line ut->ut_line entspricht. pututline() schreibt die utmp-Struktur ut in die Datei utmp. Die Funktion benutzt getutid(), um den geeigneten Platz in der Datei fur das Einfugen des neuen Eintrags zu finden. Wenn kein geeigneter Platz fur ut gefunden werden kann, hangt pututline() den neuen Eintrag am Ende der Datei an. RUCKGABEWERT getutent(), getutid() und getutline() liefern bei Erfolg einen Zeiger auf eine struct utmp-Struktur zuruck und NULL bei Fehlern (dies schliesst den Fall ein, dass ein Eintrag nicht gefunden wird, >>record not found<<). Die Struktur struct utmp wird als statischer Speicher alloziert und kann von nachfolgenden Aufrufen uberschrieben werden. Bei Erfolg gibt pututline() ut zuruck; bei Fehlern gibt die Funktion NULL zuruck. Wenn der Name erfolgreich gespeichert wurde, gibt utmpname() 0 zuruck, bei Fehlern -1. Im Fehlerfall setzen diese Funktionen errno, um den Fehler anzuzeigen. FEHLER ENOMEM Speicher aufgebraucht. ESRCH Eintrag nicht gefunden. setutent(), pututline() und die getut*()-Funktionen konnen aus den gleichen Grunden fehlschlagen wie in open(2) beschrieben. DATEIEN /var/run/utmp Datenbank aktuell angemeldeter Benutzer /var/log/wtmp Datenbank fruherer Benutzeranmeldungen ATTRIBUTE Siehe attributes(7) fur eine Erlauterung der in diesem Abschnitt verwandten Ausdrucke. +--------------+-------------------------+-----------------------------+ |Schnittstelle | Attribut | Wert | +--------------+-------------------------+-----------------------------+ |getutent() | Multithread-Fahigkeit | MT-Unsicher init race:utent | | | | race:utentbuf sig:ALRM | | | | timer | +--------------+-------------------------+-----------------------------+ |getutid(), | Multithread-Fahigkeit | MT-Unsicher init race:utent | |getutline() | | sig:ALRM timer | +--------------+-------------------------+-----------------------------+ |pututline() | Multithread-Fahigkeit | MT-Unsicher race:utent | | | | sig:ALRM timer | +--------------+-------------------------+-----------------------------+ |setutent(), | Multithread-Fahigkeit | MT-Unsicher race:utent | |endutent(), | | | |utmpname() | | | +--------------+-------------------------+-----------------------------+ In der obigen Tabelle bedeutet utent in race:utent, dass, falls eine der Funktionen setutent(), getutent(), getutid(), getutline(), pututline(), utmpname() oder endutent() in verschiedenen Threads eines Programms parallel verwandt werden, konkurrierende Zugriffe auf Daten (>>data races<<) auftreten konnten. STANDARDS Keine. GESCHICHTE XPG2, SVr4. In XPG2 und SVID 2 ist dokumentiert, dass die Funktion pututline() void zuruckgibt und das tut sie auch auf vielen Systemen (AIX, HP-UX). HP-UX fuhrt eine neue Funktion _pututline() mit dem oben angegebenen Prototyp fur pututline() ein. Alle diese Funktionen sind jetzt auf Nicht-Linux-Systemen uberholt. POSIX.1-2001 und POSIX.1-2008 folgt SUSv1 und erwahnt keine dieser Funktionen, sondern nutzt #include struct utmpx *getutxent(void); struct utmpx *getutxid(const struct utmpx *); struct utmpx *getutxline(const struct utmpx *); struct utmpx *pututxline(const struct utmpx *); void setutxent(void); void endutxent(void); Diese Funktionen werden von der Glibc bereitgestellt und erledigen die gleiche Aufgabe wie ihre Aquivalente ohne das >>x<<, aber verwenden struct utmpx, welche unter Linux als das Gleiche wie struct utmp definiert ist. Der Vollstandigkeit wegen stellt Glibc auch utmpxname() bereit, obwohl diese Funktion nicht von POSIX.1 beschrieben wird. Auf manchen anderen Systemen ist die utmpx-Struktur eine Obermenge der utmp-Struktur mit zusatzlichen Feldern und grosseren Versionen der vorhandenen Felder. Zudem werden auch parallele Dateien unterstutzt, oft /var/*/utmpx und /var/*/wtmpx. Die Linux-Glibc auf der anderen Seite verwendet keine parallele utmpx-Datei, weil ihre utmp-Struktur schon gross genug ist. Die oben aufgefuhrten >>x<<-Funktionen sind nur Aliase fur ihre Gegenstucke ohne >>x<< (z. B. ist getutxent() ein Alias fur getutent()). ANMERKUNGEN Anmerkungen zur Glibc Die oben erwahnten Funktionen sind nicht multithread-fahig. Glibc fugt ablaufinvariante Versionen hinzu. #include int getutent_r(struct utmp *ubuf, struct utmp **ubufp); int getutid_r(struct utmp *ut, struct utmp *ubuf, struct utmp **ubufp); int getutline_r(struct utmp *ut, struct utmp *ubuf, struct utmp **ubufp); Mit Glibc erforderliche Feature-Test-Makros (siehe feature_test_macros(7)): getutent_r(), getutid_r(), getutline_r(): _GNU_SOURCE || /* Seit Glibc 2.19: */ _DEFAULT_SOURCE || /* Glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE Diese Funktionen sind GNU-Erweiterungen, Gegenstucke der Funktionen gleichen Namens ohne den Suffix _r. Das Argument ubuf gibt diesen Funktionen einen Ort fur die Speicherung ihrer Ergebnisse. Bei Erfolg geben Sie 0 zuruck und schreiben einen Zeiger auf das Ergebnis in * ubufp. Tritt ein Fehler auf, geben diese Funktionen -1 zuruck. Es gibt keine utmpx-Aquivalente dieser Funktionen. (POSIX.1 beschreibt diese Funktionen nicht.) BEISPIELE Das folgende Beispiel erstellt und entfernt einen umtp-Datensatz. Es wird angenommen, dass es in einem Pseudo-Terminal lauft. Zur Verwendung in einer realen Anwendung sollten Sie die Ruckgabewerte von getpwuid(3) und ttyname(3) prufen. #include #include #include #include #include #include int main(void) { struct utmp entry; system("echo Vor dem Hinzufugen des Eintrags:;who"); entry.ut_type = USER_PROCESS; entry.ut_pid = getpid(); strcpy(entry.ut_line, ttyname(STDIN_FILENO) + strlen("/dev/")); /* stimmt nur fur ptys namens /dev/tty[pqr][0-9a-z] */ strcpy(entry.ut_id, ttyname(STDIN_FILENO) + strlen("/dev/tty")); entry.ut_time = time(NULL); strcpy(entry.ut_user, getpwuid(getuid())->pw_name); memset(entry.ut_host, 0, UT_HOSTSIZE); entry.ut_addr = 0; setutent(); pututline(&entry); system("echo Nach dem Hinzufugen des Eintrags:;who"); entry.ut_type = DEAD_PROCESS; memset(entry.ut_line, 0, UT_LINESIZE); entry.ut_time = 0; memset(entry.ut_user, 0, UT_NAMESIZE); setutent(); pututline(&entry); system("echo Nach dem Entfernen des Eintrags:;who"); endutent(); exit(EXIT_SUCCESS); } SIEHE AUCH getutmp(3), utmp(5) UBERSETZUNG Die deutsche Ubersetzung dieser Handbuchseite wurde von Martin Eberhard Schauer , Mario Blattermann , Dr. Tobias Quathamer und Helge Kreutzmann erstellt. Diese Ubersetzung ist Freie Dokumentation; lesen Sie die GNU General Public License Version 3 oder neuer bezuglich der Copyright-Bedingungen. Es wird KEINE HAFTUNG ubernommen. Wenn Sie Fehler in der Ubersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-Mail an die Mailingliste der Ubersetzer . Linux man-pages 6.06 31. Oktober 2023 getutent(3)