Ultrix root password

From: Tom Uban <uban_at_ubanproductions.com>
Date: Thu Apr 11 14:45:36 2002

At 03:10 PM 4/11/02 -0400, you wrote:
>It was thus said that the Great Kris Kirby once stated:
>>
>> On Mon, 1 Apr 2002, ajp166 wrote:
>> > Boot to non-timesharing then use ED (sorry no other choice usually)
>> > to edit passwd file. set the Root user password to NULL (no characters).
>> > boot to timeshare level and then log in as root with no password.
>>
>> For those of us "young'uns", would someone point me to a guide on "ED"?
>
> Isn't it like vi, only without being full screen, and without prompts?
>
> -spc (Or am I thinking of ex?)
>
>
>

No, it is strictly a line oriented editor. Here is the manual page for ED(1).

--tom

----------------------------------------------------------------------------
----
ED(1)                                                       ED(1)
NAME
       ed - text editor
SYNOPSIS
       ed [-] [-sx] [-p string] [file]
DESCRIPTION
       ed  is a line-oriented text editor.  It is used to create,
       display, modify and otherwise manipulate text files.
       If invoked with a file argument, then a copy  of  file  is
       read  into  the editor's buffer.  Changes are made to this
       copy and not directly to file itself.  Upon  quitting  ed,
       any  changes  not explicitly saved  with a `w' command are
       lost.
       Editing is done in two distinct modes: command and  input.
       When  first  invoked, ed is in command mode.  In this mode
       commands are read from the standard input and executed  to
       manipulate  the  contents of the editor buffer.  A typical
       command might look like:
              ,s/old/new/g
       which replaces all occurences of the string old with  new.
       When  an input command, such as `a' (append), `i' (insert)
       or `c' (change), is given, ed enters input mode.  This  is
       the primary means of adding text to a file.  In this mode,
       no commands are available; instead, the standard input  is
       written  directly  to the editor buffer.  Lines consist of
       text up to and including a newline character.  Input  mode
       is  terminated by entering a single period  (.) on a line.
       All ed commands operate on whole lines or ranges of lines;
       e.g., the `d' command deletes lines; the `m' command moves
       lines, and so on.  It is possible to modify only a portion
       of  a  line  by  means  of  replacement, as in the example
       above.  However even here, the `s' command is  applied  to
       whole lines at a time.
       In  general,  ed  commands  consist  of  zero or more line
       addresses, followed by a single character command and pos-
       sibly  additional  parameters;  i.e.,  commands  have  the
       structure:
              [address [,address]]command[parameters]
       The address(es) indicate the line or range of lines to  be
       affected  by  the  command.   If fewer addresses are given
       than the command accepts, then default addresses are  sup-
       plied.
                           21 May 1993                          1
ED(1)                                                       ED(1)
   OPTIONS
       -s      Suppresses  diagnostics.  This  should  be used if
               ed's standard input is from a script.
       -x      Prompts for an encryption key to be used in subse-
               quent reads and writes (see the `x' command).
       -p string
               Specifies  a  command prompt.  This may be toggled
               on and off with the `P' command.
       file    Specifies the name of a file to read.  If file  is
               prefixed  with  a bang (!), then it is interpreted
               as a shell command.  In this case, what is read is
               the  standard  output  of file executed via sh(1).
               To read a file whose name begins with a bang, pre-
               fix  the  name  with a backslash (\).  The default
               filename is set to file only if it is not prefixed
               with a bang.
   LINE ADDRESSING
       An  address represents the number of a line in the buffer.
       ed maintains a current address which is typically supplied
       to commands as the default address when none is specified.
       When a file is first read,  the current address is set  to
       the  last  line  of  the  file.   In  general, the current
       address is set to the last line affected by a command.
       A line address is constructed from one of the bases in the
       list  below, optionally followed by a numeric offset.  The
       offset may include any combination  of  digits,  operators
       (i.e.,  +,  -  and  ^) and whitespace.  Addresses are read
       from left to right, and their values are computed relative
       to the current address.
       One  exception  to  the rule that addresses represent line
       numbers is the address 0 (zero).  This means  "before  the
       first line," and is legal wherever it makes sense.
       An  address  range  is two addresses separated either by a
       comma or semi-colon. The value of the first address  in  a
       range  cannot exceed the value of the second.  If only one
       address is given in a range, then the  second  address  is
       set  to  the given address.  If an n-tuple of addresses is
       given where n > 2, then the corresponding range is  deter-
       mined  by  the last two addresses in the n-tuple.  If only
       one address is expected, then the last address is used.
       Each address in a  comma-delimited  range  is  interpreted
       relative   to  the  current  address.   In  a  semi-colon-
                           21 May 1993                          2
ED(1)                                                       ED(1)
       delimited range, the first address is used to set the cur-
       rent  address, and the second address is interpreted rela-
       tive to the first.
       The following address symbols are recognized.
       .       The current line (address) in the buffer.
       $       The last line in the buffer.
       n       The nth, line in the buffer where n is a number in
               the range [0,$].
       - or ^  The  previous  line.  This is equivalent to -1 and
               may be repeated with cumulative effect.
       -n or ^n
               The nth previous line, where n is  a  non-negative
               number.
       +       The  next  line.  This is equivalent to +1 and may
               be repeated with cumulative effect.
       +n or whitespacen
               The nth next line, where n is a non-negative  num-
               ber.   whitespace followed by a number n is inter-
               preted as +n.
       , or %  The first through last lines in the buffer.   This
               is equivalent to the address range 1,$.
       ;       The  current  through  last  lines  in the buffer.
               This is equivalent to the address range .,$.
       /re/    The next line containing  the  regular  expression
               re.   The  search  wraps  to  the beginning of the
               buffer and continues down to the current line,  if
               necessary.  // repeats the last search.
       ?re?    The  previous  line containing the regular expres-
               sion re.  The search  wraps  to  the  end  of  the
               buffer  and  continues  up to the current line, if
                           21 May 1993                          3
ED(1)                                                       ED(1)
               necessary.  ?? repeats the last search.
       'lc     The line previously marked by a  `k'  (mark)  com-
               mand, where lc is a lower case letter.
   REGULAR EXPRESSIONS
       Regular  expressions  are patterns used in selecting text.
       For example, the ed command
              g/string/
       prints all lines containing string.   Regular  expressions
       are also used by the `s' command for selecting old text to
       be replaced with new.
       In addition  to  a  specifying  string  literals,  regular
       expressions  can  represent  classes  of strings.  Strings
       thus represented are said to be matched by the correspond-
       ing  regular  expression.  If it is possible for a regular
       expression to match several strings in a  line,  then  the
       left-most longest match is the one selected.
       The  following  symbols  are  used in constructing regular
       expressions:
       c       Any character c not listed below,  including  `{',
               '}', `(', `)', `<' and `>', matches itself.
       \c      Any backslash-escaped character c, except for `{',
               '}', `(', `)', `<' and `>', matches itself.
       Matches any single character.
       [char-class]
               Matches any single character  in  char-class.   To
               include a  `]' in char-class, it must be the first
               character.  A range of characters may be specified
               by separating the end characters of the range with
               a `-', e.g., `a-z' specifies the lower case  char-
               acters.   The  following  literal  expressions can
               also be used in  char-class  to  specify  sets  of
               characters:
                 [:alnum:]  [:cntrl:]  [:lower:]  [:space:]
                 [:alpha:]  [:digit:]  [:print:]  [:upper:]
                 [:blank:]  [:graph:]  [:punct:]  [:xdigit:]
               If  `-'  appears as the first or last character of
                           21 May 1993                          4
ED(1)                                                       ED(1)
               char-class, then it  matches  itself.   All  other
               characters in char-class match themselves.
               Patterns in char-class of the form:
                 [.col-elm.] or,   [=col-elm=]
               where  col-elm  is  a collating element are inter-
               preted according to locale(5) (not currently  sup-
               ported).  See regex(3) for an explanation of these
               constructs.
       [^char-class]
               Matches any single character, other than  newline,
               not  in  char-class.   char-class  is  defined  as
               above.
       ^       If `^' is the first character of a regular expres-
               sion,  then  it  anchors the regular expression to
               the beginning of a line.   Otherwise,  it  matches
               itself.
       $       If  `$' is the last character of a regular expres-
               sion, it anchors the regular expression to the end
               of a line.  Otherwise, it matches itself.
       \<      Anchors the single character regular expression or
               subexpression  immediately  following  it  to  the
               beginning of a word.  (This may not be available)
       \>      Anchors the single character regular expression or
               subexpression immediately following it to the  end
               of a word.  (This may not be available)
       \(re\)  Defines a subexpression re.  Subexpressions may be
               nested.  A subsequent backreference  of  the  form
               `\n',  where  n  is  a  number in the range [1,9],
               expands to the text matched by the nth  subexpres-
               sion.    For   example,   the  regular  expression
               `\(.*\)\1' matches any string consisting of  iden-
               tical  adjacent  substrings.   Subexpressions  are
               ordered relative to their left delimiter.
       *       Matches the single character regular expression or
               subexpression  immediately  preceding  it  zero or
               more times.  If '*' is the first  character  of  a
               regular   expression  or  subexpression,  then  it
               matches itself.  The `*' operator sometimes yields
               unexpected  results.   For  example,  the  regular
               expression  `b*'  matches  the  beginning  of  the
               string `abbb' (as opposed to the substring `bbb'),
               since a null match is the only left-most match.
                           21 May 1993                          5
ED(1)                                                       ED(1)
       \{n,m\} or \{n,\} or \{n\}
               Matches the single character regular expression or
               subexpression  immediately preceding it at least n
               and at most m times.  If m  is  omitted,  then  it
               matches  at  least  n times.  If the comma is also
               omitted, then it matches exactly n times.
       Additional regular expression  operators  may  be  defined
       depending on the particular regex(3) implementation.
   COMMANDS
       All ed commands are single characters, though some require
       additonal parameters.  If a  command's  parameters  extend
       over  several  lines,  then  each line except for the last
       must be terminated with a backslash (\).
       In general, at most one command is allowed per line.  How-
       ever, most commands accept a print suffix, which is any of
       `p' (print), `l' (list) , or `n' (enumerate), to print the
       last line affected by the command.
       An interrupt (typically ^C) has the effect of aborting the
       current command and returning the editor to command  mode.
       ed  recognizes  the  following commands.  The commands are
       shown together with the default address or  address  range
       supplied if none is specified (in parenthesis).
       (.)a    Appends  text  to  the  buffer after the addressed
               line.  Text is entered in input mode.  The current
               address is set to last line entered.
       (.,.)c  Changes  lines in the buffer.  The addressed lines
               are deleted from the buffer, and text is  appended
               in  their  place.   Text is entered in input mode.
               The current address is set to last line entered.
       (.,.)d  Deletes the addressed lines from the  buffer.   If
               there  is a line after the deleted range, then the
               current address is set to this line. Otherwise the
               current  address  is  set  to  the line before the
               deleted range.
       e file  Edits file, and sets  the  default  filename.   If
               file  is not specified, then the  default filename
               is used.  Any lines  in  the  buffer  are  deleted
               before  the new file is read.  The current address
               is set to the last line read.
       e !command
               Edits the  standard  output  of  `!command',  (see
               !command   below).    The   default   filename  is
               unchanged.  Any lines in the  buffer  are  deleted
               before the output of command is read.  The current
                           21 May 1993                          6
ED(1)                                                       ED(1)
               address is set to the last line read.
       E file  Edits file unconditionally.  This  is  similar  to
               the  e  command, except that unwritten changes are
               discarded without warning.  The current address is
               set to the last line read.
       f file  Sets the default filename to file.  If file is not
               specified, then the default unescaped filename  is
               printed.
       (1,$)g/re/command-list
               Applies  command-list  to  each  of  the addressed
               lines matching a regular expression re.  The  cur-
               rent  address is set to the line currently matched
               before command-list is executed.  At  the  end  of
               the `g' command, the current address is set to the
               last line affected by command-list.
               Each command in command-list must be on a separate
               line,  and  every line except for the last must be
               terminated by a backslash (\).  Any  commands  are
               allowed,  except  for  `g',  `G', `v', and `V'.  A
               newline alone in command-list is equivalent  to  a
               `p' command.
       (1,$)G/re/
               Interactively edits the addressed lines matching a
               regular expression re.  For  each  matching  line,
               the  line  is printed, the current address is set,
               and the user is prompted to enter a  command-list.
               At the end of the `G' command, the current address
               is set to the last line  affected  by  (the  last)
               command-list.
               The  format of command-list is the same as that of
               the `g' command.  A newline alone acts as  a  null
               command  list.  A single `&' repeats the last non-
               null command list.
       H       Toggles the printing of  error  explanations.   By
               default, explanations are not printed.  It is rec-
               ommended that ed scripts begin with  this  command
               to aid in debugging.
       h       Prints an explanation of the last error.
       (.)i    Inserts  text  in  the  buffer  before the current
               line.  Text is entered in input mode.  The current
               address is set to the last line entered.
       (.,.+1)j
               Joins  the  addressed  lines.  The addressed lines
               are deleted from the  buffer  and  replaced  by  a
                           21 May 1993                          7
ED(1)                                                       ED(1)
               single  line  containing  their  joined text.  The
               current address is set to the resultant line.
       (.)klc  Marks a line with a lower  case  letter  lc.   The
               line  can then be addressed as 'lc (i.e., a single
               quote followed by lc  )  in  subsequent  commands.
               The  mark is not cleared until the line is deleted
               or otherwise modified.
       (.,.)l  Prints the addressed lines  unambiguously.   If  a
               single line fills for than one screen (as might be
               the  case  when  viewing  a   binary   file,   for
               instance),  a  `--More--' prompt is printed on the
               last line.  ed  waits  until  the  RETURN  key  is
               pressed  before  displaying  the next screen.  The
               current address is set to the last line printed.
       (.,.)m(.)
               Moves lines in the buffer.   The  addressed  lines
               are  moved  to  after  the  right-hand destination
               address, which may be the address 0  (zero).   The
               current address is set to the last line moved.
       (.,.)n  Prints  the  addressed lines along with their line
               numbers.  The current address is set to  the  last
               line printed.
       (.,.)p  Prints the addressed lines. The current address is
               set to the last line printed.
       P       Toggles the command prompt on and off.   Unless  a
               prompt  was  specified by with command-line option
               -p string, the command prompt is by default turned
               off.
       q       Quits ed.
       Q       Quits  ed unconditionally.  This is similar to the
               q command, except that unwritten changes are  dis-
               carded without warning.
       ($)r file
               Reads  file  to after the addressed line.  If file
               is not specified, then  the  default  filename  is
               used.   If  there was no default filename prior to
               the command, then the default filename is  set  to
               file.    Otherwise,   the   default   filename  is
               unchanged.  The current address is set to the last
               line read.
       ($)r !command
               Reads  to  after  the  addressed line the standard
               output of `!command', (see  the  !command  below).
               The  default  filename  is unchanged.  The current
                           21 May 1993                          8
ED(1)                                                       ED(1)
               address is set to the last line read.
       (.,.)s/re/replacement/
       (.,.)s/re/replacement/g
       (.,.)s/re/replacement/n
               Replaces text in the addressed  lines  matching  a
               regular   expression   re  with  replacement.   By
               default, only the first  match  in  each  line  is
               replaced.   If  the  `g' (global) suffix is given,
               then every match to be replaced.  The `n'  suffix,
               where  n  is a postive number, causes only the nth
               match to be replaced.  It is an error if  no  sub-
               stitutions  are  performed on any of the addressed
               lines.  The current address is set the  last  line
               affected.
               re and replacement may be delimited by any charac-
               ter other than space and newline (see the `s' com-
               mand below).  If one or two of the last delimiters
               is omitted, then the last line affected is printed
               as though the print suffix `p' were specified.
               An unescaped `&' in replacement is replaced by the
               currently matched text.   The  character  sequence
               `\m',  where  m is a number in the range [1,9], is
               replaced by the mth  backreference  expression  of
               the  matched  text.   If replacement consists of a
               single `%', then replacement from the last substi-
               tution  is  used.   Newlines  may  be  embedded in
               replacement if they are escaped with  a  backslash
               (\).
       (.,.)s  Repeats  the  last substitution.  This form of the
               `s' command accepts a count  suffix  `n',  or  any
               combination  of  the characters `r', `g', and `p'.
               If a count suffix `n' is given, then only the  nth
               match is replaced.  The `r' suffix causes the reg-
               ular expression of the  last  search  to  be  used
               instead of the that of the last substitution.  The
               `g' suffix toggles the global suffix of  the  last
               substitution.   The  `p'  suffix toggles the print
               suffix  of  the  last  substitution  The   current
               address is set to the last line affected.
       (.,.)t(.)
               Copies  (i.e.,  transfers)  the addressed lines to
               after the right-hand  destination  address,  which
               may  be the address 0 (zero).  The current address
               is set to the last line copied.
       u       Undoes the last command and restores  the  current
               address  to  what  it was before the command.  The
               global commands  `g',  `G',  `v',  and  `V'.   are
                           21 May 1993                          9
ED(1)                                                       ED(1)
               treated  as  a single command by undo.  `u' is its
               own inverse.
       (1,$)v/pat/command-list
               Applies command-list  to  each  of  the  addressed
               lines  not matching a regular expression re.  This
               is similar to the `g' command.
       (1,$)V/re/
               Interactively edits the addressed lines not match-
               ing  a  regular expression re.  This is similar to
               the `G' command.
       (1,$)w file
               Writes the addressed lines to file.  Any  previous
               contents  of  file  is  lost  without warning.  If
               there is no default  filename,  then  the  default
               filename   is   set   to  file,  otherwise  it  is
               unchanged.  If no filename is specified, then  the
               default  filename is used.  The current address is
               unchanged.
       (1,$)wq file
               Writes the addressed lines to file, and then  exe-
               cutes a `q' command.
       (1,$)w !command
               Writes  the  addressed lines to the standard input
               of `!command',  (see  the  !command  below).   The
               default   filename   and   current   address   are
               unchanged.
       (1,$)W file
               Appends the addressed lines to the  end  of  file.
               This  is  similar  to the `w' command, expect that
               the previous contents of file  is  not  clobbered.
               The current address is unchanged.
       x       Prompts  for  an  encryption  key which is used in
               subsequent reads and writes.  If a  newline  alone
               is  entered  as the key, then encryption is turned
               off.  Otherwise, echoing is disabled while  a  key
               is  read.  Encryption/decryption is done using the
               bdes(1) algorithm.
       (.+1)zn Scrolls n lines at a time  starting  at  addressed
               line.   If  n  is  not specified, then the current
               window size is used.  The current address  is  set
               to the last line printed.
       !command
               Executes  command via sh(1).  If the first charac-
               ter of command is `!', then it is replaced by text
               of  the  previous `!command'.  ed does not process
                           21 May 1993                         10
ED(1)                                                       ED(1)
               command for backslash (\)  escapes.   However,  an
               unescaped `%' is replaced by the default filename.
               When the shell returns from execution, a  `!'   is
               printed  to the standard output.  The current line
               is unchanged.
       ($)=    Prints the line number of the addressed line.
       (.+1)newline
               Prints the addressed line, and  sets  the  current
               address to that line.
FILES
       /tmp/ed.*           Buffer file
       ed.hup              The file to which ed attempts to write
                           the  buffer if the terminal hangs  up.
SEE ALSO
       vi(1), sed(1), regex(3), bdes(1), sh(1).
       USD:12-13
       B.  W. Kernighan and P. J. Plauger, Software Tools in Pas-
       cal , Addison-Wesley, 1981.
LIMITATIONS
       ed processes file arguments for backslash  escapes,  i.e.,
       in  a filename, any characters preceded by a backslash (\)
       are interpreted literally.
       If a text (non-binary) file is not terminated by a newline
       character,  then ed appends one on reading/writing it.  In
       the case of a binary file, ed does not append a newline on
       reading/writing.
       per line overhead: 4 ints
DIAGNOSTICS
       When  an  error occurs, ed prints a `?' and either returns
       to command mode or exits if its input is  from  a  script.
       An  explanation  of the last error can be printed with the
       `h' (help) command.
       Since the `g' (global)  command   masks  any  errors  from
       failed  searches and substitutions, it can be used to per-
       form conditional operations in scripts; e.g.,
              g/old/s//new/
       replaces any occurrences of old  with  new.   If  the  `u'
       (undo)  command  occurs in a global command list, then the
       command list is executed only once.
       If diagnostics are not disabled, attempting to quit ed  or
                           21 May 1993                         11
ED(1)                                                       ED(1)
       edit another file before writing a modified buffer results
       in an error.  If the command is entered a second time,  it
       succeeds, but any changes to the buffer are lost.
Received on Thu Apr 11 2002 - 14:45:36 BST

This archive was generated by hypermail 2.3.0 : Fri Oct 10 2014 - 23:34:30 BST