2491.pppui100664 1100 330 17136 6363440732 11077 0ustar amyljedit#!/bin/sh # Customary tcl hackery... \ exec wish "$0" "$@" # # PPPui: X-based front end to the PPP utilities, implemented as a wish # script. # # Usage: $0 [-small title] ppp_start_cmd ppp_stop_cmd \ # [ppp_device (defaults to ppp0)] # # By Nathan Meyers, nmeyers@teleport.com. # $Date: 1997/07/12 15:34:11 $ # # The script starts up the PPP connection, then runs a visible timer # until the connection is closed. A button on the GUI closes the # connection. Note that the "ppp_device" arg is not used for startup # or shutdown, but rather to ascertain when you've actually gone online -- # by scanning for its presence in the /proc/net/route file -- in order to # start the clock. # # One important modification required to PPP scripts: the ppp_start_cmd # must not run in the background. This script considers the connection # dead when that command terminates, so you need to add "-detach" to the # options passed to pppd in the startup script. # # The PPPui GUI includes a console that captures any output generated by # the startup and shutdown commands. It also captures any output written # into a named pipe whose name is advertised in the $PPPUI_PIPE environment # variable. So any downstream descendant (such as, for example, the dialer # script) has a direct path to the console for posting messages. # # Dependencies: wish4.2, The X Window System, /bin/sh, /proc file system # proc Usage {} { global argv0 puts -nonewline stderr "Usage: $argv0 \[-small title\] ppp_start_cmd " puts stderr "ppp_stop_cmd \[ppp_device\]" puts stderr "\n ppp_device defaults to ppp0" exit 1 } proc PPPQuit {} { # This procedure calls the PPP shutdown script. It's called in response # to the Quit button or the WM_DELETE_WINDOW event global stop_cmd global shell_cmd catch { # Launch the shutdown command, but don't quit. We continue waiting # until the startup command terminates. If the shutdown command # cannot figure out how to stop the startup command (as, for # example, before the login completes), that's not our problem # to solve. set fromstop [ open "| [ concat $shell_cmd [ list $stop_cmd ] ] \ 2>@ stdout" r ] # Capture its output fconfigure $fromstop -blocking 0 fileevent $fromstop readable [ list HandleStopOutput $fromstop ] } } proc ToConsole { txt } { .console.term configure -state normal .console.term insert end $txt .console.term see end .console.term configure -state disabled } proc HandleStartOutput { pipe } { global pipename # This procedure handles output from the PPP startup script. We don't # expect any output, other than EOF when the script is done -- which # is what we're really interested in. If anything else comes in, # we'll send it to the console if [ eof $pipe ] { exec /bin/rm -f $pipename exit 0 } set buf [ read $pipe 1024 ] ToConsole $buf } proc HandleStopOutput { pipe } { # This procedure handles output from the PPP shutdown script and # sends it to the console. if [ eof $pipe ] { catch { close $pipe } return } set buf [ read $pipe 1024 ] ToConsole $buf } proc HandleFIFOInput { pipe pipename } { # This procedure handles input sent to us over the named FIFO # and sends it to the console. if [ eof $pipe ] { catch { # The FIFO was closed. Reopen it in case someone else wants # to talk close $pipe set fifo [ open $pipename { RDONLY NONBLOCK } ] fconfigure $fifo -blocking 0 fileevent $fifo readable [ list HandleFIFOInput $fifo $pipename ] } return } set buf [ read $pipe 1024 ] ToConsole $buf } proc PostTime {} { global starttime global makesmall # This procedure updates the display of how long we've been connected. # There's danger of an occasional skip because we can only read the # time to the nearest second (unless we mess with "clicks"), but that's # hardly a critical problem. set currtime [ clock seconds ] set timestring [ clock format [ expr $currtime - $starttime ] \ -format %T -gmt true ] # Tell everyone if { $makesmall } { .controls.clock configure -text "$timestring" } { wm title . "PPP: $timestring" .controls.clock configure -text "PPP: $timestring" } after 1000 PostTime } proc CheckPPPDevice {} { global device global starttime global makesmall global smalltitle # This procedure checks every .5 seconds whether a route has been # added for the ppp device. Once it appears, we turn on the stopwatch # for the duration set routes [ open /proc/net/route r ] # Toss the header line gets $routes # Scan for a line beginning with our device name set done 0 while { [ gets $routes line ] >= 0 && !$done } { if { [ string first $device $line ] == 0 } { set starttime [ clock seconds ] PostTime set done 1 # Change our geometry if requested if { $makesmall } { pack forget .console pack .controls.clock -side top pack .controls.quit -side bottom wm title . $smalltitle } } } close $routes # If we didn't find our route, check again in half a second if { !$done } { after 500 CheckPPPDevice } } # Process command line set nargs [ llength $argv ] set makesmall 0 if { $nargs > 1 && [ string compare [ lindex $argv 0 ] "-small" ] == 0 } { set makesmall 1 set smalltitle [ lindex $argv 1 ] set argv [ lreplace $argv 0 1 ] set nargs [ expr $nargs - 2 ] } if { $nargs != 2 && $nargs != 3 } { Usage } # Process our command-line args set start_cmd [ lindex $argv 0 ] set stop_cmd [ lindex $argv 1 ] if { $nargs == 2 } { set device ppp0 } { set device [ lindex $argv 2 ] } # We'll actually be scanning for "device-name" followed by a tab append device "\t" # Set the shell command to interpret the startup and shutdown commands. # We use a shell so the user can assume common shell syntax for a # command and not the odd syntax of tcl's exec command set shell_cmd "/bin/sh -c" # Simple GUI: label... frame .controls label .controls.clock -text "PPP Not Connected" pack .controls.clock -side left # ... quit button button .controls.quit -text "Quit" -pady 2 -command PPPQuit pack .controls.quit -side right pack .controls -fill x # ... and scrolled text console ... frame .console text .console.term -setgrid true -state disabled \ -yscrollcommand { .console.scroll set } scrollbar .console.scroll -command { .console.term yview } pack .console.scroll -side right -fill y pack .console.term -side left -fill both -expand true pack .console -side top -fill both -expand true if [ catch { # Create a named pipe, in case anyone wants to send us console # output set pipename "/tmp/PPP" append pipename [ pid ] exec /bin/rm -rf $pipename exec /bin/mkfifo $pipename set fifo [ open $pipename { RDONLY NONBLOCK } ] fconfigure $fifo -blocking 0 fileevent $fifo readable [ list HandleFIFOInput $fifo $pipename ] # Advertise the pipe set env(PPPUI_PIPE) $pipename # Run PPP startup script in a process pipeline set fromstart [ open "| [ concat $shell_cmd [ list $start_cmd ] ] \ 2>@ stdout" r ] # Capture its output fconfigure $fromstart -blocking 0 fileevent $fromstart readable [ list HandleStartOutput $fromstart ] # Handle the WM_DELETE_WINDOW event wm protocol . WM_DELETE_WINDOW PPPQuit # Check whether we're on line yet CheckPPPDevice # Hang around until we're done tkwait window . } result ] { puts stderr $result } exit 2491.rscript100664 1100 330 16625 6362233124 11424 0ustar amyljedit#include #include #include #include #include #include #include #define CMD_LINE_LEN 1024 /* * rscript: Run those pesky execute-only scripts. Although you're * allowed to execute them, you can't read them to pass to an * interpreter -- hence can't *really* execute them. This program, * running with euid of root, opens the troublesome script, drops * its privileges, and runs the interpreter specified by the script. * * This script's activities depend on the ability of the interpreter * to accept input from stdin while allowing positional parameters. For * example: "sh -s foo bar" runs a shell to stdin, while interpreting * "foo" and "bar" as positional parameters $1 and $2. * * Unfortunately, the syntax for achieving this behavior varies with * the choice of interpreter, so we must retain some knowledge of how * to do it for the interpreters we're most likely to encounter, and * bomb out on the interpreters we don't recognize. * * Additional restriction: this only works with scripts that don't * expect anything from stdin, since stdin is already engaged. * * Usage: $0 scriptname [ ...args... ] * * By Nathan Meyers, nmeyers@teleport.com * $Date: 1997/07/12 17:15:22 $ */ /* Define the interpreters we recognize and their relevant arguments */ typedef struct interp_option_s { const char *basename; const char *option; } interp_option; interp_option interpreters[] = { { "sh", "-s" }, { "ksh", "-s" }, { "bash", "-s" }, { "csh", "-s" }, { "tcsh", "-s" }, { "perl", "-" }, { "tcsh", "--" }, { "wish", "--" } }; int main(int argc, const char *argv[]) { char script_path[MAXPATHLEN + 1]; char cmd_line[CMD_LINE_LEN + 1]; const char *path; const char *default_path = "/bin:/usr/bin"; FILE *script_fd; int i; char *cmd, *arg1; const char *basename, *option = 0; char const **arg_vector; /* Any script specified? */ if (argc < 2) { /* No :-( */ fprintf(stderr, "Usage: %s scriptname [ ...args... ]\n", argv[0]); exit(1); } /* User specified a path? */ if (strchr(argv[1], '/')) { /* Yes. Have we the right to look at and run it? Answer to this question necessarily based on the real userid, not euid */ if (access(argv[1], X_OK | F_OK) == -1) { /* Tough luck */ perror(argv[1]); exit(1); } path = argv[1]; } else { /* No. Step through the search path. */ int cmd_len = strlen(argv[1]); if (!(path = getenv("PATH"))) path = default_path; while (*path) { /* Figure out where current path component ends */ int path_len; const char *path_end = strchr(path, ':'); if (!path_end) path_end = path + strlen(path); path_len = path_end - path; /* Does path len + command len fit in MAXPATHLEN? */ if (cmd_len + path_len < MAXPATHLEN - 1) { /* Yes... check for the executable. Start by assembling the name */ strncpy(script_path, path, path_len); script_path[path_len] = '/'; strcpy(script_path + path_len + 1, argv[1]); /* Have we the right to look at and run it? Answer to this question necessarily based on the real userid, not euid */ if (!access(script_path, X_OK | F_OK)) break; /* Yes! We found our script */ } /* Point at the next path component */ path = path_end + (*path_end ? 1 : 0); } /* Did we find something we could run? */ if (!*path) { /* No... report the last access failure. */ perror(argv[1]); exit(1); } /* Yes... record path to executable script. */ path = script_path; } /* We've established that we're allowed to execute the script. Now open it. */ if (!(script_fd = fopen(path, "r"))) { /* Couldn't open it. Probably not really setuid root :-(. */ perror(path); exit(1); } /* File's open... party's over. Drop our privileges. We could get clever and check the setuid and setgid bits on the script and change our own ids appropriately. But out of respect for those who consider setuid/setgid scripts to be security holes, we won't. We'll just become ourselves. */ setreuid(getuid(), getuid()); /* Read the first line from the script */ if (!fgets(cmd_line, CMD_LINE_LEN + 1, script_fd)) { /* Failure. Shouldn't happen, but it did. */ perror(path); exit(1); } /* We're done reading the script. Set the file pointer, which stdio offset by some multiple of buffer size, back to 0. */ if (lseek(fileno(script_fd), 0, SEEK_SET) == -1) { perror(path); exit(1); } /* Set our stdin to the script */ dup2(fileno(script_fd), fileno(stdin)); fclose(script_fd); /* Now we need to parse the interpreter name from the script. Lots of divergent practices on how to do this. Some shells allow as little as 32 bytes for the command + argument[s]; most shells allow at most one argument. We'll compromise: allow a long command line, but only one argument. */ /* First, verify that it's a script */ if (strncmp(cmd_line, "#!", 2)) { fprintf(stderr, "%s: Not a script\n", path); exit(1); } /* Find the start of the command */ for (cmd = cmd_line + 2; *cmd && isspace(*cmd); cmd++); if (!*cmd) { fprintf(stderr, "%s: No interpreter name found\n", path); exit(1); } /* Find the end of the command */ for (arg1 = cmd; *arg1 && !isspace(*arg1); arg1++); /* End of cmd_line string? */ if (*arg1) { /* No... Terminate the cmd name and search for the first arg. Otherwise (if we didn't enter this clause) we've found null-terminated cmd name and we're done. Start by terminating cmd name and finding beginning of $1 parm. */ for (*(arg1++) = 0; *arg1 && isspace(*arg1); arg1++); /* Found? */ if (*arg1) { /* Yes. Null-terminate it. */ char *arg1_end; for (arg1_end = arg1; *arg1_end && !isspace(*arg1_end); arg1_end++); *arg1_end = 0; } else arg1 = 0; } else arg1 = 0; /* We've got interpreter path and possible first argument. Time to look for an interpreter we recognize. */ basename = strrchr(cmd, '/'); basename = basename ? basename + 1 : cmd; for (i = 0; i < sizeof(interpreters)/sizeof(interp_option); i++) { if (!strcmp(interpreters[i].basename, basename)) { option = interpreters[i].option; break; } } if (!option) { fprintf(stderr, "%s: Unrecognized interpreter\n", cmd); exit(1); } /* Ready to roll! Put together a command line */ arg_vector = (char const **)malloc(sizeof(char *) * (argc + 2)); i = 0; arg_vector[i++] = path; if (arg1) arg_vector[i++] = arg1; /* Add option to read from stdin, which replaces the usual occurrence of the script path in #! script execution. */ arg_vector[i++] = option; /* Append command-line arguments */ for (argc -= 2, argv += 2; argc; argc--) arg_vector[i++] = *argv++; /* Null-terminate */ arg_vector[i] = 0; /* It's showtime! */ execv(cmd, (char *const *)arg_vector); /* We're here only if exec failed */ perror(cmd); exit(1); }