manpages-de - en to de translation catalogue (133 entries)

note: type: TH
en: 2019-10-10
de: 10. Oktober 2019

note: type: TH
en: Linux Programmer's Manual
de: Linux-Programmierhandbuch

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: execve - execute program
de: execve - Programm ausführen

note: type: SH
en: SYNOPSIS
de: ÜBERSICHT

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: B<execve>()  executes the program referred to by I<pathname>.  This causes the program that is currently being run by the calling process to be replaced with a new program, with newly initialized stack, heap, and (initialized and uninitialized) data segments.
de: B<execve>() führt das Programm aus, auf das sich I<pathname> bezieht. Dies führt dazu, dass das Programm, das derzeit vom aufrufenden Prozess ausgeführt wird, durch ein neues Programm, mit einem frisch initialisierten Stack, Heap und (initialisierten und uninitialisierten) Datensegmenten ersetzt wird.

note: type: Plain text
en: I<pathname> must be either a binary executable, or a script starting with a line of the form:
de: I<pathname> muss entweder ein binäres ausführbares Programm oder ein Skript sein, das mit einer Zeile der folgenden Form beginnt:

note: type: Plain text
en: B<#!>I<interpreter >[optional-arg]
de: B<#!>I<Interpreter >[Optionale-Arg]

note: type: Plain text
en: For details of the latter case, see "Interpreter scripts" below.
de: Einzelheiten zu letzterem Fall finden Sie in »Interpreter-Skripte« weiter unten.

note: type: Plain text
en: I<argv> is an array of argument strings passed to the new program.  By convention, the first of these strings (i.e., I<argv[0]>)  should contain the filename associated with the file being executed.  I<envp> is an array of strings, conventionally of the form B<key=value>, which are passed as environment to the new program.  The I<argv> and I<envp> arrays must each include a null pointer at the end of the array.
de: I<argv> ist ein Feld von Argumentezeichenketten, die an das neue Programm übergeben werden. Per Konvention sollte die erste dieser Zeichenketten (d.h. I<argv[0]>) den Dateinnamen, der zu der ausgeführten Datei gehört, enthalten. I<envp> ist ein Feld von Zeichenketten, das per Konvention die Form B<Schlüssel=Wert> haben sollte, das an die Umgebung des neuen Programms übergeben wird. Die Felder I<argv> und I<envp> müssen jeder einen Null-Zeiger am Ende des Feldes enthalten.

note: type: Plain text
en: The argument vector and environment can be accessed by the called program's main function, when it is defined as:
de: Auf den Argumentzeiger und die Umgebung kann von der Main-Funktion des aufgerufenen Programms zugegriffen werden, wenn sie wie folgt definiert ist:

note: type: Plain text
en: Note, however, that the use of a third argument to the main function is not specified in POSIX.1; according to POSIX.1, the environment should be accessed via the external variable B<environ>(7).
de: Beachten Sie allerdings, dass die Verwendung eines dritten Arguments bei der Funktion main nicht in POSIX.1 spezifiziert ist; laut POSIX.1 sollte auf die Umgebung über die externe Variable B<environ>(7) zugegriffen werden.

note: type: Plain text
en: B<execve>()  does not return on success, and the text, initialized data, uninitialized data (bss), and stack of the calling process are overwritten according to the contents of the newly loaded program.
de: B<execve>() kehrt bei Erfolg nicht zurück und Text, initialisierte Daten, uninitialisierte Daten (bss) und Stack des aufrufenden Prozesses werden entsprechend des Inhalts des neu geladenen Programms überschrieben.

note: type: Plain text
en: If the current program is being ptraced, a B<SIGTRAP> signal is sent to it after a successful B<execve>().
de: Falls das aktuelle Programm mit ptrace verfolgt wird, wird nach einem erfolgreichen B<execve>() ein Signal B<SIGTRAP> an es gesandt.

note: type: Plain text
en: If the set-user-ID bit is set on the program file referred to by I<pathname>, then the effective user ID of the calling process is changed to that of the owner of the program file.  Similarly, when the set-group-ID bit of the program file is set the effective group ID of the calling process is set to the group of the program file.
de: Falls bei der Programmdatei, auf die sich I<pathname> bezieht, das Bit set-user-ID gesetzt ist, dann wird die effektive Benutzerkennung des aufrufenden Programms zu der des Eigentümers der Programmdatei geändert. Ähnlich wird die effektive Gruppenkennung des aufrufenden Prozesses auf die Gruppe der Programmdatei gesetzt, wenn das Bit set-group-ID auf der Programmdatei gesetzt ist.

note: type: Plain text
en: The aforementioned transformations of the effective IDs are I<not> performed (i.e., the set-user-ID and set-group-ID bits are ignored)  if any of the following is true:
de: Die vorgenannten Umwandlungen der effektiven Kennungen werden I<nicht> durchgeführt (d.h. die Bits set-user-ID und set-group-ID werden ignoriert), falls eine der folgenden Aussagen wahr ist:

note: type: Plain text
en: the I<no_new_privs> attribute is set for the calling thread (see B<prctl>(2));
de: Das Attribut I<no_new_privs> wird für den aufrufenden Thread gesetzt (siehe B<prctl>(2)).

note: type: Plain text
en: the underlying filesystem is mounted I<nosuid> (the B<MS_NOSUID> flag for B<mount>(2)); or
de: Das unterliegende Dateisystem ist I<nosuid> eingehängt (der Schalter B<MS_NOSUID> für B<mount>(2)). Oder

note: type: Plain text
en: the calling process is being ptraced.
de: der aufrufende Prozess wird mit ptrace verfolgt.

note: type: Plain text
en: The capabilities of the program file (see B<capabilities>(7))  are also ignored if any of the above are true.
de: Die Capabilities der Programmdatei (siehe B<capabilities>(7)) werden auch ignoriert, wenn eine der obigen Bedingungen zutrifft.

note: type: Plain text
en: The effective user ID of the process is copied to the saved set-user-ID; similarly, the effective group ID is copied to the saved set-group-ID.  This copying takes place after any effective ID changes that occur because of the set-user-ID and set-group-ID mode bits.
de: Die effektive Benutzerkennung des Prozesses wird in die gespeicherte set-user-ID kopiert. Ähnlich wird die effektive Gruppenkennung in die gespeicherte set-group-ID kopiert. Dieses Kopieren findet nach allen effektiven ID-Änderungen statt, die aufgrund der Modusbits set-user-ID und set-group-ID erfolgen.

note: type: Plain text
en: The process's real UID and real GID, as well its supplementary group IDs, are unchanged by a call to B<execve>().
de: Die reale UID und reale GID des Prozesses sowie die zusätzlichen Gruppenkennungen ändern sich beim Aufruf von B<execve>() nicht.

note: type: Plain text
en: If the executable is an a.out dynamically linked binary executable containing shared-library stubs, the Linux dynamic linker B<ld.so>(8)  is called at the start of execution to bring needed shared objects into memory and link the executable with them.
de: Falls das Programm eine dynamisch gelinkte Programmdatei im a.out-Format ist, die Laufzeitbibliotheken-Stubs enthält, dann wird der dynamische Linker B<ld.so>(8) von Linux am Anfang der Ausführung aufgerufen, um die benötigten Laufzeitobjekte in den Speicher zu bringen und das Programm mit ihnen zu verlinken.

note: type: Plain text
en: If the executable is a dynamically linked ELF executable, the interpreter named in the PT_INTERP segment is used to load the needed shared objects.  This interpreter is typically I</lib/ld-linux.so.2> for binaries linked with glibc (see B<ld-linux.so>(8)).
de: Falls das Programm ein dynamisch gelinktes ELF-Programm ist, wird der in dem Segment PT_INTERP benannte Interpreter zum Laden der gemeinsamen Objekte verwandt. Dieser Interpreter ist typischerweise I</lib/ld-linux.so.2> für Programme, die mit der Glibc gelinkt sind (siehe B<ld-linux.so>(8)).

note: type: Plain text
en: All process attributes are preserved during an B<execve>(), except the following:
de: Alle außer den nachfolgend aufgeführten Prozessattributen werden durch ein B<execve>() erhalten:

note: type: Plain text
en: The dispositions of any signals that are being caught are reset to the default (B<signal>(7)).
de: Die Zuordnung aller gefangenen Signale wird auf die Vorgabe zurückgesetzt (B<signal>(7)).

note: type: Plain text
en: Any alternate signal stack is not preserved (B<sigaltstack>(2)).
de: Alle alternativen Signal-Stacks werden nicht erhalten (B<sigaltstack>(2)).

note: type: Plain text
en: Attached System\ V shared memory segments are detached (B<shmat>(2)).
de: Gemeinsam benutzte Speichersegmente vom Typ »System V« werden abgetrennt (B<shmat>(2)).

note: type: Plain text
en: Open POSIX message queue descriptors are closed (B<mq_overview>(7)).
de: Offene POSIX-Nachrichtenwarteschlangendeskriptoren werden geschlossen (B<mq_overview>(7)).

note: type: Plain text
en: Any open POSIX named semaphores are closed (B<sem_overview>(7)).
de: Alle offenen benannten POSIX-Semaphoren werden geschlossen (B<sem_overview>(7)).

note: type: Plain text
en: POSIX timers are not preserved (B<timer_create>(2)).
de: POSIX-Timer werden nicht erhalten (B<timer_create>(2)).

note: type: Plain text
en: Any open directory streams are closed (B<opendir>(3)).
de: Alle offenen Verzeichnis-Streams werden geschlossen (B<opendir>(3)).

note: type: Plain text
en: Memory locks are not preserved (B<mlock>(2), B<mlockall>(2)).
de: Speichersperren werden nicht erhalten (B<mlock>(2), B<mlockall>(2)).

note: type: Plain text
en: Exit handlers are not preserved (B<atexit>(3), B<on_exit>(3)).
de: Exit-Handler werden nicht erhalten (B<atexit>(3), B<on_exit>(3)).

note: type: Plain text
en: The floating-point environment is reset to the default (see B<fenv>(3)).
de: Die Gleitkomma-Umgebung wird auf den Standardwert zurückgesetzt (siehe B<fenv>(3)).

note: type: Plain text
en: The process attributes in the preceding list are all specified in POSIX.1.  The following Linux-specific process attributes are also not preserved during an B<execve>():
de: Die Prozessattribute in der vorstehenden Liste sind alle in POSIX.1 spezifiziert. Die folgenden Linux-spezifischen Prozessattribute werden auch während eines B<execve>() nicht erhalten:

note: type: Plain text
en: The B<prctl>(2)  B<PR_SET_DUMPABLE> flag is set, unless a set-user-ID or set-group ID program is being executed, in which case it is cleared.
de: Der B<prctl>(2)-Schalter B<PR_SET_DUMPABLE> wird gesetzt. Wird ein set-user-ID- oder set-group-ID-Programm ausgeführt, dann wird er auf 0 gesetzt.

note: type: Plain text
en: The B<prctl>(2)  B<PR_SET_KEEPCAPS> flag is cleared.
de: Der B<prctl>(2)-Schalter B<PR_SET_KEEPCAPS> wird auf 0 gesetzt.

note: type: Plain text
en: (Since Linux 2.4.36 / 2.6.23)  If a set-user-ID or set-group-ID program is being executed, then the parent death signal set by B<prctl>(2)  B<PR_SET_PDEATHSIG> flag is cleared.
de: (Seit Linux 2.4.36 / 2.6.23) Falls ein set-user-ID- oder set-group-ID-Programm ausgeführt wird, dann wird das durch den Schalter B<prctl>(2) B<PR_SET_PDEATHSIG> gesetzte Todessignal des Elternprozesses auf 0 gesetzt.

note: type: Plain text
en: The process name, as set by B<prctl>(2)  B<PR_SET_NAME> (and displayed by I<ps\ -o comm>), is reset to the name of the new executable file.
de: Der Prozessname, wie er von B<prctl>(2) B<PR_SET_NAME> gesetzt (und durch I<ps\ -o comm> angezeigt) wird, wird auf den Namen des ausführbaren Programms zurückgesetzt.

note: type: Plain text
en: The B<SECBIT_KEEP_CAPS> I<securebits> flag is cleared.  See B<capabilities>(7).
de: Der B<SECBIT_KEEP_CAPS> Schalter I<securebits> wird auf 0 gesetzt. Siehe B<capabilities>(7).

note: type: Plain text
en: The termination signal is reset to B<SIGCHLD> (see B<clone>(2)).
de: Das Terminierungssignal wird auf B<SIGCHLD> zurückgesetzt (siehe B<clone>(2)).

note: type: Plain text
en: The file descriptor table is unshared, undoing the effect of the B<CLONE_FILES> flag of B<clone>(2).
de: Die Dateideskriptortabelle wird getrennt, der Effekt des Schalters B<CLONE_FILES> von B<clone>(2) wird rückgängig gemacht.

note: type: Plain text
en: Note the following further points:
de: Beachten Sie die folgenden weiteren Punkte:

note: type: Plain text
en: All threads other than the calling thread are destroyed during an B<execve>().  Mutexes, condition variables, and other pthreads objects are not preserved.
de: Alle Threads außer dem aufrufenden werden während eines B<execve>() zerstört. Mutexe, Bedingungsvariablen und andere Pthread-Objekte werden nicht erhalten.

note: type: Plain text
en: The equivalent of I<setlocale(LC_ALL, "C")> is executed at program start-up.
de: Das Äquivalent von I<setlocale(LC_ALL, "C")> wird beim Programmstart ausgeführt.

note: type: Plain text
en: POSIX.1 specifies that the dispositions of any signals that are ignored or set to the default are left unchanged.  POSIX.1 specifies one exception: if B<SIGCHLD> is being ignored, then an implementation may leave the disposition unchanged or reset it to the default; Linux does the former.
de: POSIX.1 legt fest, dass Zuordnungen aller ignorierten oder auf die Vorgabewerte gesetzten Signale unverändert bleiben. POSIX.1 legt eine Ausnahme fest: Falls B<SIGCHLD> ignoriert wird, dann darf eine Implementierung die Zuordnung unverändert lassen oder sie auf die Vorgabe zurücksetzen; Linux macht Ersteres.

note: type: Plain text
en: Any outstanding asynchronous I/O operations are canceled (B<aio_read>(3), B<aio_write>(3)).
de: Alle ausstehenden asynchronen E/A-Operationen werden abgebrochen (B<aio_read>(3), B<aio_write>(3)).

note: type: Plain text
en: For the handling of capabilities during B<execve>(), see B<capabilities>(7).
de: Für den Umgang mit Capabilities während B<execve>(), siehe B<capabilities>(7).

note: On Linux it appears that these file descriptors are always open after an execve(), and it looks like Solaris 8 and FreeBSD 6.1 are the same. -- mtk, 30 Apr 2007 type: Plain text
en: By default, file descriptors remain open across an B<execve>().  File descriptors that are marked close-on-exec are closed; see the description of B<FD_CLOEXEC> in B<fcntl>(2).  (If a file descriptor is closed, this will cause the release of all record locks obtained on the underlying file by this process.  See B<fcntl>(2)  for details.)  POSIX.1 says that if file descriptors 0, 1, and 2 would otherwise be closed after a successful B<execve>(), and the process would gain privilege because the set-user-ID or set-group_ID mode bit was set on the executed file, then the system may open an unspecified file for each of these file descriptors.  As a general principle, no portable program, whether privileged or not, can assume that these three file descriptors will remain closed across an B<execve>().
de: Standardmäßig bleiben Dateideskriptoren über ein B<execve>() hinweg offen. Dateideskriptoren, die mit close-on-exec markiert sind, werden geschlossen; siehe die Beschreibung von B<FD_CLOEXEC> in B<fcntl>(2). (Falls ein Dateideskriptor geschlossen wird, führt dies zur Freigabe aller von der unterliegenden Datei durch den Prozess erhaltenen Datensatzsperren. Siehe B<fcntl>(2) für Details.) Laut POSIX.1 darf das System eine nicht festgelegte Datei für jeden der Dateideskriptoren 0, 1 und 2 öffnen, falls diese andernfalls nach einem erfolgreichen B<execve>() geschlossen und der Prozess aufgrund der Modus-Bits set-user-ID oder set-group_ID Privilegien erhalten würde. Als allgemeines Prinzip darf kein portables Programm, egal ob privilegiert oder nicht, annehmen, dass diese drei Dateideskriptoren über ein B<execve>() geschlossen bleiben.

note: type: SS
en: Interpreter scripts
de: Interpreter-Skripte

note: type: Plain text
en: An interpreter script is a text file that has execute permission enabled and whose first line is of the form:
de: Ein Interpreter-Skript ist eine Textdatei, die über Ausführrechte verfügt und dessen erste Zeile die folgende Form annimmt:

note: type: Plain text
en: The I<interpreter> must be a valid pathname for an executable file.
de: Der I<Interpreter> muss ein gültiger Pfadname zu einer ausführbaren Datei sein.

note: type: Plain text
en: If the I<pathname> argument of B<execve>()  specifies an interpreter script, then I<interpreter> will be invoked with the following arguments:
de: Falls das Argument I<pathname> von B<execve>() ein Interpreterskript festlegt, dann wird I<interpreter> mit den folgenden Argumenten aufgerufen.

note: type: Plain text
en: I<interpreter> [optional-arg] I<pathname> arg...
de: I<Interpreter> [Optionale-Arg] I<pathname> Arg …

note: See the P - preserve-argv[0] option. Documentation/admin-guide/binfmt-misc.rst https://www.kernel.org/doc/html/latest/admin-guide/binfmt-misc.html type: Plain text
en: where I<pathname> is the absolute pathname of the file specified as the first argument of B<execve>(), and I<arg...> is the series of words pointed to by the I<argv> argument of B<execve>(), starting at I<argv>[1].  Note that there is no way to get the I<argv[0]> that was passed to the B<execve>()  call.
de: Hierbei ist I<pathname> der absolute Pfadname der Datei, die als erstes Argument von B<execve>() festgelegt ist, und I<arg…> die Serie von Wörtern, auf die vom Argument I<argv> von B<execve>() gezeigt wird, beginnen mit I<argv>[1]. Beachten Sie, dass es keine Möglichkeit gibt, I<argv[0]>, der dem Aufruf B<execve>() übergeben wurde, zu erhalten.

note: type: Plain text
en: For portable use, I<optional-arg> should either be absent, or be specified as a single word (i.e., it should not contain white space); see NOTES below.
de: Für den portablen Einsatz sollte I<Optionale-Arg> entweder abwesend oder als einzelnes Wort festgelegt werden (d.h. es sollte keine Leerraumzeichen enthalten); siehe ANMERKUNGEN unten.

note: commit bf2a9a39639b8b51377905397a5005f444e9a892 type: Plain text
en: Since Linux 2.6.28, the kernel permits the interpreter of a script to itself be a script.  This permission is recursive, up to a limit of four recursions, so that the interpreter may be a script which is interpreted by a script, and so on.
de: Seit Linux 2.6.28 erlaubt es der Kernel, dass der Interpreter eines Skripts selbst wieder ein Skript ist. Diese Erlaubnis ist rekursiv bis zu einer Rekursionstiefe von 4, so dass der Interpreter ein Skript sein darf, das von einem Skript interpretiert wird und so weiter.

note: type: SS
en: Limits on size of arguments and environment
de: Begrenzungen der Größe der Argumente und der Umgebung

note: type: Plain text
en: Most UNIX implementations impose some limit on the total size of the command-line argument (I<argv>)  and environment (I<envp>)  strings that may be passed to a new program.  POSIX.1 allows an implementation to advertise this limit using the B<ARG_MAX> constant (either defined in I<E<lt>limits.hE<gt>> or available at run time using the call I<sysconf(_SC_ARG_MAX)>).
de: Die meisten UNIX-Implementierungen verhängen eine Begrenzung für die Gesamtgröße der Zeichenketten der Befehlszeilenargumente (I<argv>) und der Umgebung (I<envp>), die an ein neues Programm übergeben werden darf. POSIX.1 erlaubt es einer Implementierung, diese Begrenzung mit der Konstante B<ARG_MAX> bekanntzugeben (entweder definiert in I<E<lt>limits.hE<gt>> oder zur Laufzeit mit dem Aufruf I<sysconf(_SC_ARG_MAX)> verfügbar).

note: type: Plain text
en: On Linux prior to kernel 2.6.23, the memory used to store the environment and argument strings was limited to 32 pages (defined by the kernel constant B<MAX_ARG_PAGES>).  On architectures with a 4-kB page size, this yields a maximum size of 128\ kB.
de: Vor Kernel 2.6.23 unter Linux war der Speicher, der zum Ablegen der Umgebungs- und Argumentzeichenketten verwandt wurde, auf 32 Seiten begrenzt (definiert durch die Kernelkonstante B<MAX_ARG_PAGES>). Auf Architekturen mit einer 4-kB-Seitengröße führt dies zu einer Maximalgröße von 128\ kB.

note: For some background on the changes to ARG_MAX in kernels 2.6.23 and 2.6.25, see: http://sourceware.org/bugzilla/show_bug.cgi?id=5786 http://bugzilla.kernel.org/show_bug.cgi?id=10095 http://thread.gmane.org/gmane.linux.kernel/646709/focus=648101, checked into 2.6.25 as commit a64e715fc74b1a7dcc5944f8
en: On kernel 2.6.23 and later, most architectures support a size limit derived from the soft B<RLIMIT_STACK> resource limit (see B<getrlimit>(2))  that is in force at the time of the B<execve>()  call.  (Architectures with no memory management unit are excepted: they maintain the limit that was in effect before kernel 2.6.23.)  This change allows programs to have a much larger argument and/or environment list.  For these architectures, the total size is limited to 1/4 of the allowed stack size.  (Imposing the 1/4-limit ensures that the new program always has some stack space.)  Additionally, the total size is limited to 3/4 of the value of the kernel constant B<_STK_LIM> (8 Mibibytes).  Since Linux 2.6.25, the kernel also places a floor of 32 pages on this size limit, so that, even when B<RLIMIT_STACK> is set very low, applications are guaranteed to have at least as much argument and environment space as was provided by Linux 2.6.23 and earlier.  (This guarantee was not provided in Linux 2.6.23 and 2.6.24.)  Additionally, the limit per string is 32 pages (the kernel constant B<MAX_ARG_STRLEN>), and the maximum number of strings is 0x7FFFFFFF.
de: Auf den meisten Architekturen wird unter Kernel 2.6.23 und neuer eine Größenbegrenzung, die von der Ressourcenbegrenzung B<RLIMIT_STACK> (siehe B<getrlimit>(2)) abgeleitet ist, die zum Zeitpunkt des Aufrufs B<execve>() in Kraft war, unterstützt. (Architekturen ohne Speicherverwaltungseinheit sind die Ausnahme: bei ihnen bleibt die Begrenzung, die vor dem Kernel 2.6.23 in Kraft war.) Diese Änderung erlaubt es Programmen, eine viel größere Argumenten- und/oder Umgebungsliste zu haben. Für diese Architekturen ist die Gesamtgröße auf 1/4 der erlaubten Stack-Größe begrenzt. (Die Erzwingung der 1/4-Begrenzung stellt sicher, dass neue Programme immer über Stack-Bereich verfügen.) Zusätzlich wird die Gesamtgröße auf 3/4 des Wertes der Kernelkonstanten B<_STK_LIM> (8 Mibibytes) begrenzt. Seit Linux 2.6.25 stellt auch der Kernel eine Untergrenze von 32 Seiten dieser Begrenzung bereit, so dass selbst wenn B<RLIMIT_STACK> sehr gering ist, Anwendungen garantiert über mindestens so viel Argument- und Umgebungsbereich verfügen, wie dies unter Linux 2.6.23 und älter der Fall war. (Diese Garantie wurde nicht unter Linux 2.6.23 und 2.6.24 erfüllt.) Zusätzlich ist die Begrenzung pro Zeichenkette 32 Seiten (der Kernelkonstanten B<MAX_ARG_STRLEN>) und die maximale Anzahl von Zeichenketten ist 0x7FFFFFFF.

note: type: SH
en: RETURN VALUE
de: RÜCKGABEWERT

note: type: Plain text
en: On success, B<execve>()  does not return, on error -1 is returned, and I<errno> is set appropriately.
de: Im Erfolgsfall kehrt B<execve>() nicht zurück, im Fehlerfall wird -1 zurückgeliefert und I<errno> entsprechend gesetzt.

note: type: SH
en: ERRORS
de: FEHLER

note: type: Plain text
en: The total number of bytes in the environment (I<envp>)  and argument list (I<argv>)  is too large.
de: Die Gesamtanzahl von Bytes in der Umgebungs- (I<envp>) und der Argumentenliste (I<argv>) ist zu groß.

note: type: Plain text
en: Search permission is denied on a component of the path prefix of I<pathname> or the name of a script interpreter.  (See also B<path_resolution>(7).)
de: Für einen Teil des Pfadpräfixes von I<pathname> oder dem Namen des Skript-Interpreters wird die Suchberechtigung verweigert. (Siehe auch B<path_resolution>(7).)

note: type: Plain text
en: The file or a script interpreter is not a regular file.
de: Die Datei oder der Skriptinterpreter ist keine reguläre Datei.

note: type: Plain text
en: Execute permission is denied for the file or a script or ELF interpreter.
de: Für die Datei oder ein Skript oder ELF-Interpreter wird die Ausführberechtigung verweigert.

note: type: Plain text
en: The filesystem is mounted I<noexec>.
de: Das Dateisystem ist nicht I<noexec> eingehängt.

note: type: TP
en: B<EAGAIN> (since Linux 3.1)
de: B<EAGAIN> (seit Linux 3.1)

note: commit 72fa59970f8698023045ab0713d66f3f4f96945c type: Plain text
en: Having changed its real UID using one of the B<set*uid>()  calls, the caller was\(emand is now still\(emabove its B<RLIMIT_NPROC> resource limit (see B<setrlimit>(2)).  For a more detailed explanation of this error, see NOTES.
de: Nach Änderung der realen UID mittels einer der Aufrufe B<set*uid>() war – und ist immer noch – der Aufrufende über seine Ressourcenbegrenzung B<RLIMIT_NPROC> (siehe B<setrlimit>(2)). Für eine detailliertere Erläuterung dieses Fehlers siehe ANMERKUNGEN.

note: type: Plain text
en: I<pathname> or one of the pointers in the vectors I<argv> or I<envp> points outside your accessible address space.
de: I<pathname> oder einer der Zeiger in den Vektoren I<argv> oder I<envp> zeigt aus dem für Sie zugänglichen Adressraum heraus.

note: type: Plain text
en: An ELF executable had more than one PT_INTERP segment (i.e., tried to name more than one interpreter).
de: Ein ELF-Programm hat mehr als ein PT_INTERP-Segment (d.h. versuchte mehr als einen Interpreter anzugeben).

note: type: Plain text
en: An I/O error occurred.
de: Es ist ein E/A-Fehler (engl. I/O) aufgetreten.

note: type: Plain text
en: An ELF interpreter was a directory.
de: Ein ELF-Interpreter war ein Verzeichnis.

note: type: Plain text
en: An ELF interpreter was not in a recognized format.
de: Ein ELF-Interpreter war in einem unbekannten Format.

note: type: Plain text
en: Too many symbolic links were encountered in resolving I<pathname> or the name of a script or ELF interpreter.
de: Beim Auflösen von I<pathname> oder dem Namen eines Skripts oder ELF-Interpreters wurden zu viele symbolische Links ermittelt.

note: commit d740269867021faf4ce38a449353d2b986c34a67 type: Plain text
en: The maximum recursion limit was reached during recursive script interpretation (see "Interpreter scripts", above).  Before Linux 3.8, the error produced for this case was B<ENOEXEC>.
de: Während der rekursiven Skript-Interpretation (siehe »Interpreter-Skripte« oben) wurde die maximale Rekursionsbegrenzung erreicht. Vor Linux 3.8 wurde in diesem Fall der Fehler B<ENOEXEC> erstellt.

note: type: Plain text
en: The per-process limit on the number of open file descriptors has been reached.
de: Die Beschränkung pro Prozess der Anzahl offener Datei-Deskriptoren wurde erreicht.

note: type: Plain text
en: I<pathname> is too long.
de: I<pathname> ist zu lang.

note: type: Plain text
en: The system-wide limit on the total number of open files has been reached.
de: Die systemweite Beschränkung für die Gesamtzahl offener Dateien wurde erreicht.

note: FIXME but see http://sourceware.org/bugzilla/show_bug.cgi?id=12241 type: Plain text
en: The file I<pathname> or a script or ELF interpreter does not exist, or a shared library needed for the file or interpreter cannot be found.
de: Die Datei I<pathname> oder ein Skript oder ein ELF-Interpreter existiert nicht oder eine Laufzeitbibliothek, die für die Datei oder den Interpreter benötigt wird, kann nicht gefunden werden.

note: type: Plain text
en: An executable is not in a recognized format, is for the wrong architecture, or has some other format error that means it cannot be executed.
de: Ein Programm ist nicht in einem erkennbaren Format, ist für die falsche Architektur oder hat einen anderen Formatfehler, wodurch es nicht ausgeführt werden kann.

note: type: Plain text
en: Insufficient kernel memory was available.
de: Es war nicht genügend Kernelspeicher verfügbar.

note: type: Plain text
en: A component of the path prefix of I<pathname> or a script or ELF interpreter is not a directory.
de: Ein Teil des Pfadpräfixes von I<pathname> oder ein Skript oder ELF-Interpreter ist kein Verzeichnis.

note: type: Plain text
en: The filesystem is mounted I<nosuid>, the user is not the superuser, and the file has the set-user-ID or set-group-ID bit set.
de: Das Dateisystem ist I<nosuid> eingehängt, der Benutzer ist nicht der Superuser und die Datei hat das Bit set-user-ID oder set-group-ID gesetzt.

note: type: Plain text
en: The process is being traced, the user is not the superuser and the file has the set-user-ID or set-group-ID bit set.
de: Der Prozess wird verfolgt, der Benutzer ist nicht der Superuser und die Datei hat das Bit set-user-ID oder set-group-ID gesetzt.

note: type: Plain text
en: A "capability-dumb" applications would not obtain the full set of permitted capabilities granted by the executable file.  See B<capabilities>(7).
de: Eine »Capability-unfähige« Anwendung würde nicht die ganze Menge der vom ausführbaren Programm gewährten erlaubten Capabilities erhalten. Siehe B<capabilities>(7).

note: type: Plain text
en: The specified executable was open for writing by one or more processes.
de: Das angegebene Programm war für einen oder mehrere Prozesse zum Schreiben offen.

note: type: SH
en: CONFORMING TO
de: KONFORM ZU

note: SVr4 documents additional error conditions EAGAIN, EINTR, ELIBACC, ENOLINK, EMULTIHOP; POSIX does not document ETXTBSY, EPERM, EFAULT, ELOOP, EIO, ENFILE, EMFILE, EINVAL, EISDIR or ELIBBAD error conditions. type: Plain text
en: POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD.  POSIX does not document the #! behavior, but it exists (with some variations) on other UNIX systems.
de: POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD. POSIX dokumentiert das #!-Verhalten nicht, es existiert aber (mit einigen Variationen) auf anderen UNIX-Systemen.

note: type: SH
en: NOTES
de: ANMERKUNGEN

note: type: Plain text
en: One sometimes sees B<execve>()  (and the related functions described in B<exec>(3))  described as "executing a I<new> process" (or similar).  This is a highly misleading description: there is no new process; many attributes of the calling process remain unchanged (in particular, its PID).  All that B<execve>()  does is arrange for an existing process (the calling process)  to execute a new program.
de: Manchmal wird B<execve>() (und die in B<exec>(3) beschriebenen dazugehörigen Funktionen) als »Ausführung eines I<neuen> Prozesses« (oder ähnlich) beschrieben. Dies ist eine hochgradig irreführende Beschreibung: es gibt keinen neuen Prozess, viele Attribute des aufrufenden Prozesses bleiben unverändert (insbesondere seine PID). B<execve>() arrangiert lediglich, dass ein existierender Prozess (der aufrufende Prozess) ein neues Programm ausführt.

note: type: Plain text
en: Set-user-ID and set-group-ID processes can not be B<ptrace>(2)d.
de: Set-user-ID- und Set-group-ID-Prozesse können nicht mit B<ptrace>(2) verfolgt werden.

note: type: Plain text
en: The result of mounting a filesystem I<nosuid> varies across Linux kernel versions: some will refuse execution of set-user-ID and set-group-ID executables when this would give the user powers they did not have already (and return B<EPERM>), some will just ignore the set-user-ID and set-group-ID bits and B<exec>()  successfully.
de: Das Ergebnis des Einhängens eines Dateisystems mit I<nosuid> unterscheidet sich abhängig von der Linux-Kernelversion. Unter einigen wird die Ausführung von Programmen mit set-user-ID und set-group-ID verweigert, wenn das dem Benutzer Rechte geben würde, die er nicht bereits hatte (und B<EPERM> zurückliefern). Unter anderen werden die Bits set-user-ID und set-group-ID ignoriert und B<exec>() erfolgreich ausgeführt.

note: e.g., EFAULT on Solaris 8 and FreeBSD 6.1; but HP-UX 11 is like Linux -- mtk, Apr 2007 Bug filed 30 Apr 2007: http://bugzilla.kernel.org/show_bug.cgi?id=8408 Bug rejected (because fix would constitute an ABI change). type: Plain text
en: On Linux, I<argv> and I<envp> can be specified as NULL.  In both cases, this has the same effect as specifying the argument as a pointer to a list containing a single null pointer.  B<Do not take advantage of this nonstandard and nonportable misfeature!> On many other UNIX systems, specifying I<argv> as NULL will result in an error (B<EFAULT>).  I<Some> other UNIX systems treat the I<envp==NULL> case the same as Linux.
de: Unter Linux können I<argv> und I<envp> als NULL festgelegt werden. In beiden Fällen hat dies den gleichen Effekt wie die Festlegung des Arguments auf einen Zeiger auf eine Liste, die als einziges Element den NULL-Zeiger enthält. B<Nutzen Sie diese nicht standardisierte und nicht portable Misfunktionalität nicht aus!> Unter vielen UNIX-Systemen führt die Festlegung von I<argv> als NULL zu einem Fehler (B<EFAULT>). I<Einige> andere UNIX-Systeme behandeln den Fall I<envp==NULL> wie Linux.

note: type: Plain text
en: POSIX.1 says that values returned by B<sysconf>(3)  should be invariant over the lifetime of a process.  However, since Linux 2.6.23, if the B<RLIMIT_STACK> resource limit changes, then the value reported by B<_SC_ARG_MAX> will also change, to reflect the fact that the limit on space for holding command-line arguments and environment variables has changed.
de: POSIX.1 besagt, dass die von B<sysconf>(3) zurückgelieferten Werte über die Lebensdauer eines Prozesses unveränderlich sein sollen. Seit 2.6.23 wird der von B<_SC_ARG_MAX> berichtete Wert sich allerdings auch ändern, wenn die Ressourcenbegrenzung B<RLIMIT_STACK> sich ändert, um die Tatsache zu berücksichtigen, dass die Begrenzung des Platzes zum Halten der Befehlszeilenargumente und der Umgebungsvariablen sich geändert hat.

note: type: Plain text
en: In most cases where B<execve>()  fails, control returns to the original executable image, and the caller of B<execve>()  can then handle the error.  However, in (rare) cases (typically caused by resource exhaustion), failure may occur past the point of no return: the original executable image has been torn down, but the new image could not be completely built.  In such cases, the kernel kills the process with a B<SIGKILL> signal.
de: In den meisten Fällen, in denen B<execve>() fehlschlägt, kehrt die Steuerung zu dem ursprünglichen Abbild zurück und der Aufrufende von B<execve>() kann mit dem Fehler umgehen. In (seltenen) Fällen kann (typischerweise durch Ressourcenerschöpfung verursacht) der Fehlschlag den Punkt ohne Rückkehr passieren: das ursprüngliche Abbild wurde bereits entfernt aber das neue Abbild konnte nicht komplett gebaut werden. In diesen Fällen beendet der Kernel den Prozess mit einem Signal B<SIGKILL>.

note: commit 6eb3c3d0a52dca337e327ae8868ca1f44a712e02 type: Plain text
en: The kernel imposes a maximum length on the text that follows the "#!" characters at the start of a script; characters beyond the limit are ignored.  Before Linux 5.1, the limit is 127 characters.  Since Linux 5.1, the limit is 255 characters.
de: Der Kernel legt eine maximal Länge für Text, der den Zeichen »#!« am Anfang eines Skriptes folgt, auf. Zeichen hinter dieser Begrenzung werden ignoriert. Vor Linux 5.1 war die Begrenzung 127 Zeichen, seit Linux 5.1 ist die Begrenzung 255 Zeichen.

note: e.g., Solaris 8 e.g., FreeBSD before 6.0, but not FreeBSD 6.0 onward type: Plain text
en: The semantics of the I<optional-arg> argument of an interpreter script vary across implementations.  On Linux, the entire string following the I<interpreter> name is passed as a single argument to the interpreter, and this string can include white space.  However, behavior differs on some other systems.  Some systems use the first white space to terminate I<optional-arg>.  On some systems, an interpreter script can have multiple arguments, and white spaces in I<optional-arg> are used to delimit the arguments.
de: Die Semantik des Arguments I<Optionale-Args> eines Interpreterskriptes unterscheidet sich zwischen Implementierungen. Unter Linux wird die gesamte Zeichenkette, die I<Interpreter> folgt, als einziges Argument an den Interpreter übergeben und diese Zeichenkette kann Leerzeichen enthalten. Das Verhalten unterscheidet sich aber auf einigen anderen Systemen. Einige Systeme verwenden das erste Leerzeichen, um I<Optionale-Args> zu beenden. Auf einigen Systemen kann ein Interpreterskript mehrere Argumente haben und Leerzeichen in I<Optionale-Args> werden zum Begrenzen der Argumente verwandt.

note: .SH BUGS Some Linux versions have failed to check permissions on ELF interpreters.  This is a security hole, because it allows users to open any file, such as a rewinding tape device, for reading.  Some Linux versions have also had other security holes in .BR execve () that could be exploited for de
en: Linux (like most other modern UNIX systems)  ignores the set-user-ID and set-group-ID bits on scripts.
de: Linux (wie die meisten anderen modernen UNIX-Systeme) ignoriert die Bits set-user-ID und set-group-ID bei Skripten.

note: type: SS
en: execve() and EAGAIN
de: execve() und EAGAIN

note: type: Plain text
en: A more detailed explanation of the B<EAGAIN> error that can occur (since Linux 3.1) when calling B<execve>()  is as follows.
de: Eine detailliertere Beschreibung des Fehlers B<EAGAIN>, der (seit Linux 3.1) beim Aufruf von B<execve>() auftreten kann, ist wie folgt:

note: commit 909cc4ae86f3380152a18e2a3c44523893ee11c4 type: Plain text
en: The B<EAGAIN> error can occur when a I<preceding> call to B<setuid>(2), B<setreuid>(2), or B<setresuid>(2)  caused the real user ID of the process to change, and that change caused the process to exceed its B<RLIMIT_NPROC> resource limit (i.e., the number of processes belonging to the new real UID exceeds the resource limit).  From Linux 2.6.0 to 3.0, this caused the B<set*uid>()  call to fail.  (Prior to 2.6, the resource limit was not imposed on processes that changed their user IDs.)
de: Der Fehler B<EAGAIN> kann auftreten, wenn ein I<vorhergehender> Aufruf von B<setuid>(2), B<setreuid>(2) oder B<setresuid>(2) dazu führte, dass die reale Benutzerkennung des Prozesses geändert wurde und diese Änderung dazu führte, dass der Prozess seine Ressourcenbeschränkung B<RLIMIT_NPROC> überschritt (d.h. die Anzahl der zu der neuen realen UID gehörenden Prozesse überschreitet die Ressourcenbeschränkung). Von Linux 2.6.0 bis 3.0 führte dies dazu, dass der Aufruf B<set*uid>() fehlschlug. (Vor 2.6 wurde die Ressourcenbeschränkung bei Prozessen, die ihre Benutzerkennungen änderten, nicht durchgesetzt.)

note: type: Plain text
en: Since Linux 3.1, the scenario just described no longer causes the B<set*uid>()  call to fail, because it too often led to security holes where buggy applications didn't check the return status and assumed that\(emif the caller had root privileges\(emthe call would always succeed.  Instead, the B<set*uid>()  calls now successfully change the real UID, but the kernel sets an internal flag, named B<PF_NPROC_EXCEEDED>, to note that the B<RLIMIT_NPROC> resource limit has been exceeded.  If the B<PF_NPROC_EXCEEDED> flag is set and the resource limit is still exceeded at the time of a subsequent B<execve>()  call, that call fails with the error B<EAGAIN>.  This kernel logic ensures that the B<RLIMIT_NPROC> resource limit is still enforced for the common privileged daemon workflow\(emnamely, B<fork>(2)  + B<set*uid>()  + B<execve>().
de: Seit Linux 3.1 schlägt in dem gerade beschriebenen Szenario der Aufruf B<set*uid>() nicht mehr fehl, da dies zu oft zu Sicherheitslöchern führte, bei denen fehlerhafte Anwendungen nicht den Rückgabewert prüften und annahmen, dass – falls der Aufrufende Root-Rechte hatte – der Aufruf immer erfolgreich sein würde. Stattdessen ändert der Aufruf B<set*uid>() jetzt erfolgreich die reale UID, aber der Kernel setzt einen internen Schalter namens B<PF_NPROC_EXCEEDED>, um zu vermerken, dass die Ressourcenbeschränkung B<RLIMIT_NPROC> überschritten wurde. Falls der Schalter B<PF_NPROC_EXCEEDED> gesetzt ist und die Ressourcenbeschränkung zum Zeitpunkt eines folgenden B<execve>()-Aufrufs immer noch überschritten ist, dann schlägt dieser Aufruf mit dem Fehler B<EAGAIN> fehl. Diese Kernellogik stellt sicher, dass die Ressourcenbeschränkung B<RLIMIT_NPROC> für den häufigen Ablauf bei privilegierten Daemons – also B<fork>(2) + B<set*uid>() + B<execve>() – weiterhin durchgesetzt wird.

note: type: Plain text
en: If the resource limit was not still exceeded at the time of the B<execve>()  call (because other processes belonging to this real UID terminated between the B<set*uid>()  call and the B<execve>()  call), then the B<execve>()  call succeeds and the kernel clears the B<PF_NPROC_EXCEEDED> process flag.  The flag is also cleared if a subsequent call to B<fork>(2)  by this process succeeds.
de: Falls die Ressourcenbegrenzung zum Zeitpunkt des Aufrufs B<execve>() noch nicht überschritten wurde (da andere zu dieser realen UID gehörende Prozesse sich zwischen dem Aufruf von B<set*uid>() und dem Aufruf von B<execve>() beendeten), dann gelingt der Aufruf und der Kernel bereinigt den Prozessschalter B<PF_NPROC_EXCEEDED>. Der Schalter wird auch auf 0 gesetzt, falls ein folgender Aufruf von B<fork>(2) durch diesen Prozess gelingt.

note: type: SS
en: Historical
de: Geschichtliches

note: .SH BUGS Some Linux versions have failed to check permissions on ELF interpreters.  This is a security hole, because it allows users to open any file, such as a rewinding tape device, for reading.  Some Linux versions have also had other security holes in .BR execve () that could be exploited for de
en: With UNIX\ V6, the argument list of an B<exec>()  call was ended by 0, while the argument list of I<main> was ended by -1.  Thus, this argument list was not directly usable in a further B<exec>()  call.  Since UNIX\ V7, both are NULL.
de: Unter UNIX\ V6 wurde die Argumentenliste von einem B<exec>()-Aufruf durch 0 beendet, während die Argumentenliste von I<main> durch -1 beendet wurde. Daher war diese Argumentenliste nicht für weitere B<exec>()-Aufrufe direkt verwendbar. Seit UNIX\ V7 sind beide NULL.

note: type: SH
en: EXAMPLE
de: BEISPIEL

note: type: Plain text
en: The following program is designed to be execed by the second program below.  It just echoes its command-line arguments, one per line.
de: Das folgende Programm ist dafür gedacht, vom zweiten folgenden Programm ausgeführt zu werden. Es gibt nur seine Befehlszeile (eine pro Zeile) wieder aus.

note: type: Plain text
en: This program can be used to exec the program named in its command-line argument:
de: Dieses Programm kann zur Ausführung des in seinem Befehlszeilenargument benannten Programms verwandt werden:

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        char *newargv[] = { NULL, "hello", "world", NULL };
        char *newenviron[] = { NULL };
de: int
    main(int argc, char *argv[])
    {
        char *newargv[] = { NULL, "Hallo", "Welt", NULL };
        char *newenviron[] = { NULL };

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s E<lt>file-to-execE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
de:     if (argc != 2) {
    	printf(stderr, "Aufruf: %s E<lt>auszuführende-DateiE<gt>\en", argv[0]);
    	exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     execve(argv[1], newargv, newenviron);
        perror("execve");   /* execve() returns only on error */
        exit(EXIT_FAILURE);
    }
de:     execve(argv[1], newargv, newenviron);
        perror("execve");   /* execve() kehrt nur im Fehlerfall zurück */
        exit(EXIT_FAILURE);
    }

note: type: Plain text
en: We can use the second program to exec the first as follows:
de: Wir können das zweite Programm verwenden, um das erste wie folgt aufzurufen:

note: type: Plain text
en: $B< cc myecho.c -o myecho>
    $B< cc execve.c -o execve>
    $B< ./execve ./myecho>
    argv[0]: ./myecho
    argv[1]: hello
    argv[2]: world
de: $B< cc myecho.c -o myecho>
    $B< cc execve.c -o execve>
    $B< ./execve ./myecho>
    argv[0]: ./myecho
    argv[1]: Hallo
    argv[2]: Welt

note: type: Plain text
en: We can also use these programs to demonstrate the use of a script interpreter.  To do this we create a script whose "interpreter" is our I<myecho> program:
de: Wir können diese Programme auch zur Demonstration der Verwendung eines Skript-Interpreters verwenden. Dafür erstellen wir ein Skript, dessen »Interpreter« unser I<myecho>-Programm ist.

note: type: Plain text
en: We can then use our program to exec the script:
de: Wir können dann unser Programm verwenden, um das Skript auszuführen:

note: type: Plain text
en: $B< ./execve ./script>
    argv[0]: ./myecho
    argv[1]: script-arg
    argv[2]: ./script
    argv[3]: hello
    argv[4]: world
de: $B< ./execve ./script>
    argv[0]: ./myecho
    argv[1]: script-arg
    argv[2]: ./script
    argv[3]: Hallo
    argv[4]: Welt

note: type: SH
en: SEE ALSO
de: SIEHE AUCH

note: type: SH
en: COLOPHON
de: KOLOPHON

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2019-05-09
de: 9. Mai 2019

note: type: Plain text
en: One sometimes sees B<execve>()  (and the related functions described in B<exec>(3))  described as "executing a I<new> process" (or similar).  This is a highly misleading description: there is no new process; many attributes of the calling process remain unchanged (in particular, its PID).  All that B<execve>(2)  does is arrange for an existing process (the calling process)  to execute a new program.
de: Manchmal wird B<execve>() (und die in B<exec>(3) beschriebenen dazugehörigen Funktionen) als »Ausführung eines I<neuen> Prozesses« (oder ähnlich) beschrieben. Dies ist eine hochgradig irreführende Beschreibung: es gibt keinen neuen Prozess, viele Attribute des aufrufenden Prozesses bleiben unverändert (insbesondere seine PID). B<execve>(2) arrangiert lediglich, dass ein existierender Prozess (der aufrufende Prozess) ein neues Programm ausführt.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: B<#!> I<interpreter >[optional-arg]
de: B<#!> I<Interpreter >[Optionale-Arg]

note: type: Plain text
en: The I<interpreter> must be a valid pathname for an executable file.  If the I<pathname> argument of B<execve>()  specifies an interpreter script, then I<interpreter> will be invoked with the following arguments:
de: Der I<interpreter> muss ein gültiger Pfadname für eine ausführbare Datei sein. Falls das Argument I<pathname> von B<execve>() ein Interpreterskript festlegt, dann wird I<interpreter> mit den folgenden Argumenten aufgerufen.

note: type: Plain text
en: where I<arg...> is the series of words pointed to by the I<argv> argument of B<execve>(), starting at I<argv>[1].
de: wobei I<Arg…> eine Reihe von Wörtern ist, auf die vom Argument I<argv> von B<execve>() gezeigt wird, beginnend bei I<argv>[1].

note: type: Plain text
en: A maximum line length of 127 characters is allowed for the first line in an interpreter script.
de: Eine maximale Zeilenlänge von 127 Zeichen wird für die erste Zeile in einem interpretierten Skript erlaubt.

note: .SH BUGS Some Linux versions have failed to check permissions on ELF interpreters.  This is a security hole, because it allows users to open any file, such as a rewinding tape device, for reading.  Some Linux versions have also had other security holes in .BR execve () that could be exploited for de
en: Linux ignores the set-user-ID and set-group-ID bits on scripts.
de: Linux ignoriert die Bits set-user-ID und set-group-ID bei Skripten.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
