$0 / argv[0] per Bash script setzen

Wieso soll's denn unbedingt $0 sein? - Kannst du nicht einfach einen x-beliebigen anderen Variablennamen nehmen?

Meines Wissens nach ist $0 einer der wenigen fest definierten Namen, die dafür gedacht sind, sich nicht ändern zu lassen.

Hai,

probiers doch einfach mal mit einem Link:

ln -s foo.sh hello\ world

Hai nomml,

wird Dein script von cups als command aufgerufen, oder willst Du cups aufrufen?

Wenn es um Weiterreichung geht, brauchst Du $0 garnicht patchen.
Du könntest das array kopieren und dann den ersten Eintrag austauschen. Dann ist das ein ganz normaler Variablen-Vorgang.

Wenn Du aufgerufen wirst, wird argv[0] doch sicher $1 entsprechen - oder etwas nich?

Hallo pram,

Ich habe mal einen flüchtigen Blick in cups1.1 geworfen und wenn ich nicht an der falschen Stelle gelandet bin, ist das, was Dir Kopfweh bereitet ist ein ganz normales array, welches "zufällig" argv heißt. Das könnte auch Hugo heißen und somit ist argv[0] einfach nur das erste Element und keineswegs geschützt.

Wenn Du mal schaust, wo das array verwendet wird, steht dort

pid = start_process(command, argv, envp, filterfds[!slot][0] ...

bzw.

execve(command, argv, envp);

was bedeutet, dass Dein Scriptname in der Variablen command steht und nicht in argv[0].

Dein Vorhaben sollte sich also realisieren lassen, ohne unanständig trixen zu müssen

Gruß Geronimo

Ich glaube dein Problem liegt im Dateisystem selbst. Ich vermute, dass argv[0] sowieso immer die aktuelle Datei ist und du somit gar keinen Einfluss darauf hast, es sei denn du machst einen Node-Eintrag ins Dateisystem. Und nur das kannst du an Cups weiterleiten. Daher mein Vorschlag: machs doch mit named pipes, die gibts auch in Bash. Die schreiben einen I-Node auf die Festplatte, so dass sie wie eine gültige Datei aussehen und dann rufst du cups mit diesem Pipe auf. Sobald das Lesen der Datei beendet ist, wird der Node wieder gelöscht und deine Platte ist sauber. Was hältst du davon?

Zitat

In der von dir erwähnten Codestelle wäre also:
command = /usr/.../socket
argv[0] = socket://ip:9100
argv[1..n]... uninteressant

Ich möchte jetzt "um" den Socket ein Wrapperscript basteln, damit ich die Daten abgreifen kann. Also ein einfaches Bash-Script. Die Device URI lautet dann z.B. socketwrapper://ip:port.

Also ich gehe man davon aus, dass /usr/.../socket eine ausführbare Datei ist, um die Du Deinen Wrapper legen willst. Wenn Dein Script mit verschiedenen "command"s arbeiten kann, dann würde ich das wrapperscript symlinken, sodass für jedes original-Command ein anderer Dateiname zu tragen komme ($0 in Deinem Script).

Aus dem $0 kannst Du dann ablesen, welches Command wirklich aufgerufen werden soll.

Ich gehe weiterhin davon aus, dass socket://... eine Protokollart, bzw. ein mime-Typ ist. Solange Du also keine Protokollart, bzw. keinen Mimetyp implementierst, wird es socketwrapper:// nicht geben. Du musst also Deinen Dienst so konfigurieren:
command = /usr/.../socketwrapper
argv[0] = socket://ip:9100

In Deinem Wrapperscript wertest Du dann $0 aus und verwendest den Wert (z.B. basename) als Trigger für den Dienst, den dann Dein Script aufruft. Somit rufst Du den eigentlichen Service aus Deinem Script auf - und nur so wäre es ein richtiger Wrapper. Das was Du bisher vorgeschlagen hattest war das "man in the middle"-Prinzip und das geht natürlich nicht ohne cups zu patchen.

Falls cups aus dem URL das command extrahiert und command und argv[0] mit dem gleichen Wert belegt, müsstest Du eben in Deinem Wrapperscript $1 (also den URI) auch patchen. Beides sollte machbar sein.

Gruß Geronimo

Yo,

darfst mich ruhig als Depp ansehen - habe auch nie Dein Script oder Dein Wissen über Cups in Frage gestellt.

Für mich geht es "nur" um die Problemstellung von $0 - und da denke ich auch, dass wir aneinander vorbei reden. Du willst $0 in Deinem Script verändern und ich wollte Dir klarmachen, dass das garnicht notwendig ist, denn das, was bei cups argv[0] ist, ist in Deinem Script $1

... und in dem codeschnippsel wird genau das gemacht, was ich Dir in meinem letzten Beitrag vorgeschlagen hatte. Dort wird nämlich auch der Pfad aufgetrennt, wieder neu zusammen gebaut und anschließend ein Befehl aufgerufen.

Das geht genauso auch mit Bash oder was immer Du nehmen willst.

Die Krux ist doch, dass Du wissen musst, was Du auswerten willst und woher Du Dein Ziel bekommst. Wenn Du dafür ne Environment-Variable nehmen willst, spricht ja nix dagegen.

Wenn Du allerdings die Daten eines Socket abgreifen willst, ohne das Programm (cups) oder dessen Konfiguration zu ändern, dann würde es mich sehr beruhigen, wenn Du damit nicht (!) erfolgreich würdest.
Schließlich gilt eine Socket-Verbindung als rel. sicher - und einen Wrapper einzubringen, ohne das cups was mitbekommt, würde die Sicherheit ad absurdum führen. So zumindest meine Ansicht!

Gruß Geronimo

Zitat

Originally posted by pram
Ich hoff jetzt mal, dass auf dem "Problemserver" python installiert ist...

noe, ich glaub da tut's auch nen K&R-style C

fixarg0.c:
main(argc, argv)
    char **argv;
{
    char *str = "more args\n";
    char *file;


    if (argc > 2) {
        file = *(argv + 2);
        *(argv + 2) = *(argv + 1);
        if (execvp(file, argv + 2)) {
            perror(*argv);
            exit(2);
        }
    } else {
        write(2, str, strlen(str));
        exit(1);
    }
}


printmyargs.c:
main(argc, argv)
    char **argv;
{
    if (argc > 0) printf("*(argv + 0): %s\n", *(argv + 0));
    if (argc > 1) printf("*(argv + 1): %s\n", *(argv + 1));
    if (argc > 2) printf("*(argv + 2): %s\n", *(argv + 2));
    /* ... */
}

du kannst dem 'fixarg0' als erstes Argument irgendwas Beliebiges geben, was dann fuer das aufgerufene prog als *(argv + 0)) erscheint.

Beispiel:

fixarg0 http://www.vdr-portal.de/ printmyargs arg1 arg2 arg3 ...

*(argv + 0): http://www.vdr-portal.de/
*(argv + 1): arg1
*(argv + 2): arg2

Zitat

Originally posted by pram
Falls es kein python gibt (Der Server ist leider ne Marke Uralt...) dann muss wohl C herhalten...

also dieses neumodische objektorientierte Zeug wie C++ oder python - ich weiss ja nicht...

plain C ist doch immer noch das Beste

Moin, moin,

Zitat

geronimo, sry, ...

Paßt schon! - Ich habe weder von cups ne Ahnung, noch wüsste ich, ob und wo man z.B. tea4Cups als Resource-Protokoll anmelden muss.

Aber ich kann C und bash und soweit ich es verstanden habe, ist das, was sparkie Dir vorschlägt, locker auch mit bash möglich:
fixarg.sh

#!/bin/bash
$2 $1 [$3 ... $9]

... das was ich Dir rüberbringen wollte, hat Sparkie mit seinen Codezeilen komprimiert:
Dein Problem hängt nicht am $0, oder daran, dass Du $0 verändern müsstest, sondern daran, dass Du die URI bzw. Deinen $0 parsen solltest ...

Zitat

tea4cups://socket://1.2.3.4:9100

Hm - Ich weiß jetzt nicht, ob das ein gültiger URI ist. Wahrscheinlich müsste es ohne socket:// auskommen, bzw. nach socket müsste ein anderer Trenner kommen.

Wenn Du Dein Script als Wrapper einbringen wolltest, würde ich statt socket://... das wrapperSocket:// verwenden. In dem wrapperSocket-Skript könnte man dann $0 aufteilen in "wrapper" und "Socket", bei "Socket" den ersten Buchstaben wieder kleinmachen und könnte dann aus dem wrapperSocket-Skript ein socket:// aufrufen.
Die Behandlung des "neuen" URIs sollte also problemlos im Skript machbar sein.

Wenn Du dann neben dem socket:// auch ein file:// wrappen wolltest, könntest Du einen Softlink wrapperFile auf wrapperSocket machen. Somit wäre das wrapperSocket-Skript schon generisch für 2 verschiedene URIs tauglich.

Der Punkt ist nur, ich weiß nicht, was Du tun must, damit ein wrapperSocket://... als URI von cups akzeptiert wird.

Also wenn Du schon soweit bist, dass Dein Skript von Cups aufgerufen werden kann, dann mach doch mal einen Test ala:

#!/bin/sh
echo "myself: $0"
for i in $*; do
   echo "arg: $i";
done

Vielleicht ist es ja einfacher, wenn Du die Parameter vor Dir siehst. Die Ausgabe ist einfach zu deuten - myself ist $0 und jede Zeile ist fortlaufend zu nummerieren. Wenn Du dann in den Ausgaben siehst, aus welchen Parametern Du den neuen Befehl zusammen stellen willst, brauchst Du nur die entsprechenden Werte aufführen:

$2 $1 $3

Gruß Geronimo