PC World Komputer 1999 March B/SCO_CASTOR4RRT.iso/scoadmin/root.3/etc/mail/admin/mailadmin/mailadmin~

Text File | 1998-08-19 | 222KB | 8,484 lines

#!/bin/osavtcl
#******************************************************************************
#
#    Copyright (C) 1993-1997 The Santa Cruz Operation, Inc.
#        All Rights Reserved.
#
#    The information in this file is provided for the exclusive use of
#    the licensees of The Santa Cruz Operation, Inc.  Such users have the
#    right to use, modify, and incorporate this code into other products
#    for purposes authorized by the license agreement provided they include
#    this notice and the associated copyright notice with any such product.
#    The information in this file is provided "AS IS" without warranty.
#
#===============================================================================
loadlibindex /usr/lib/sysadm.tlib
proc SCO_MAIL_ADMIN_MSGS {} {}
global SCO_MAIL_ADMIN_MSGS
set SCO_MAIL_ADMIN_MSGS(@catalog@) {mag.cat@mail 1}
set SCO_MAIL_ADMIN_MSGS(MSG_HELPBOOK) {1 mailadmin}
set SCO_MAIL_ADMIN_MSGS(MSG_TITLE) {2 {Mail Settings on %1$s}}
set SCO_MAIL_ADMIN_MSGS(MSG_APP_TITLE) {3 {Mail Manager}}
set SCO_MAIL_ADMIN_MSGS(MSG_WIN_TITLE) {4 {Mail Manager on %1$s}}
set SCO_MAIL_ADMIN_MSGS(ERR_CF_COPY_OUT) {5 {Unable to fetch %1$s\nIs it ok to restore the factory version?}}
set SCO_MAIL_ADMIN_MSGS(ERR_CF_FACTORY_RESTORE) {6 {Unable to restore %1$s factory defaults.\nCheck /etc/mail/sendmail.factory.}}
set SCO_MAIL_ADMIN_MSGS(ERR_CF_INVALID) {7 {%1$s appears to have been hand edited\nDo you wish to continue?}}
set SCO_MAIL_ADMIN_MSGS(ERR_CF_OPEN_FAIL) {8 {Unable to open file: %1$s}}
set SCO_MAIL_ADMIN_MSGS(ERR_CF_PARSE) {9 {Unable to parse %1$s\nIs it ok to restore the factory version?}}
set SCO_MAIL_ADMIN_MSGS(ERR_MS1_PARSE) {10 {%1$s has parse errors.\nBad lines will be dropped.\nAlternatively you can restore the factory defaults file.\nDo you wish to restore the factory defaults file?}}
set SCO_MAIL_ADMIN_MSGS(ERR_CF_WRITE) {11 {Unable to write %1$s.}}
set SCO_MAIL_ADMIN_MSGS(ERR_COPY_BACK) {12 {Unable to copy back to %1$s.}}
set SCO_MAIL_ADMIN_MSGS(ERR_FQDN) {13 {Must specify a fully qualified domain name.}}
set SCO_MAIL_ADMIN_MSGS(ERR_INTEGER) {14 {Invalid numeric value (%1$s).}}
set SCO_MAIL_ADMIN_MSGS(ERR_INVALID) {15 {Invalid entry (%1$s).}}
set SCO_MAIL_ADMIN_MSGS(ERR_INVALID_TABLE) {16 {Invalid table type (%1$s).}}
set SCO_MAIL_ADMIN_MSGS(ERR_INVALID_NAME) {17 {Invalid channel name (%1$s).}}
set SCO_MAIL_ADMIN_MSGS(ERR_NULL) {18 {Entry cannot be empty.}}
set SCO_MAIL_ADMIN_MSGS(ERR_AFILE_ONLY) {19 {Can only edit alias files.}}
set SCO_MAIL_ADMIN_MSGS(ERR_USER_FIRST) {20 {Must set non-default user first.}}
set SCO_MAIL_ADMIN_MSGS(ERR_CONFLICT) {21 {Name conflict or restricted name.}}
set SCO_MAIL_ADMIN_MSGS(ERR_CH_NOT_LAST) {22 {Channel is not last.}}
set SCO_MAIL_ADMIN_MSGS(ERR_BADUSER_ONLY) {23 {There can only be one baduser channel.}}
set SCO_MAIL_ADMIN_MSGS(ERR_NOHOST) {24 {Host (%1$s) not found.}}
set SCO_MAIL_ADMIN_MSGS(ERR_BADHOST) {25 {Host (%1$s) not responding.\nPlease check the following:\n   * your network configuration\n   * your network connection\n   * rhost permissions on the remote site\n   * that SCOadmin is installed at the remote site}}
set SCO_MAIL_ADMIN_MSGS(ERR_INVALID_CLASS) {26 {Classname (%1$s) is invalid, unable to edit.}}
set SCO_MAIL_ADMIN_MSGS(ERR_EXEC) {27 {Unable to exec (%1$s).}}
set SCO_MAIL_ADMIN_MSGS(ERR_NO_MAP) {28 {No map created for %1$s, file contents may be invalid.}}
set SCO_MAIL_ADMIN_MSGS(ERR_FILE_ONLY) {29 {This item is only used for File Lookups.}}
set SCO_MAIL_ADMIN_MSGS(ERR_TFADMIN) {30 {Failure in tfadmin authorization check}}
set SCO_MAIL_ADMIN_MSGS(ERR_SENDMAIL_RESTART) {31 {Failed to restart sendmail}}
set SCO_MAIL_ADMIN_MSGS(MSG_DIRTY) {32 {Do you wish to save your changes?}}
set SCO_MAIL_ADMIN_MSGS(MSG_CONT_DEFAULT) {33 {This will reset all items in the folder to their default values\nDo you wish to continue?}}
set SCO_MAIL_ADMIN_MSGS(MSG_ALIAS1) {34 {Alias File or NIS MAP}}
set SCO_MAIL_ADMIN_MSGS(MSG_ALIAS2) {35 {Examples: btree:/etc/mail/aliases, nis:mail.aliases@domain}}
set SCO_MAIL_ADMIN_MSGS(MSG_NOEXIST) {36 {%1$s does not exist.}}
set SCO_MAIL_ADMIN_MSGS(MSG_NOEXIST_IGNORE) {37 {%1$s does not exist.\nContinue?}}
set SCO_MAIL_ADMIN_MSGS(MSG_EDIT_DTABLE) {38 {Do you wish to edit the domain table?}}
set SCO_MAIL_ADMIN_MSGS(MSG_GO_BACK) {39 {Do you wish to return to host (%1$s)?}}
set SCO_MAIL_ADMIN_MSGS(MSG_UUCP_UPDATE) {40 {The UUCP Systems file map (%1$s) is out of date.\nDo you wish to rebuild it?}}
set SCO_MAIL_ADMIN_MSGS(MSG_SAVING) {41 {Saving configuration...}}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_YES) {42 Yes}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_NO) {43 No}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_CANCEL) {44 Cancel}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_OK) {45 Ok}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_SELECT) {46 Select...}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_NONE) {47 None}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_NONE_DELAY) {48 None/Delay}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_EDIT_ALIAS) {49 {Edit Alias File...}}
set SCO_MAIL_ADMIN_MSGS(MSG_STR_EDIT_CTABLE) {50 {Edit Channel Table File...}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_HOST) {51 Host}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_HOST_MN) {52 t}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_OPEN) {53 {Open Host...}}
set SCO_MAIL_ADMIN_MSGS(MSG_TITLE_OPEN) {54 {Open Host}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_OPEN_MN) {55 O}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_EXIT) {56 Exit}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_EXIT_MN) {57 x}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_EDIT) {58 Edit}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_EDIT_MN) {59 E}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_ADD) {60 Add...}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_ADD_MN) {61 A}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_DEL) {62 Delete}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_DEL_MN) {63 D}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_MOD) {64 Modify...}
set SCO_MAIL_ADMIN_MSGS(MSG_TITLE_MOD) {65 Modify}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_MOD_MN) {66 M}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_UP) {67 {Move Up}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_UP_MN) {68 U}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_DN) {69 {Move Down}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_DN_MN) {70 o}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_SET) {71 Settings}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_SET_MN) {72 S}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_DEF) {73 Defaults}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_DEF_MN) {74 D}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_BADHOST) {75 {Bad Host Forwarding/Delay}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_BADHOST_MN) {76 H}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_BADUSER) {77 {Bad User Enable/Disable}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_BADUSER_MN) {78 U}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_MHOME) {79 {Multihome Enable/Disable}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_MHOME_MN) {80 M}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_UUCP) {81 {UUCP Enable/Disable}}
set SCO_MAIL_ADMIN_MSGS(MSG_MENU_UUCP_MN) {82 C}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_OPEN) {83 {Manage mail on another host}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_EXIT) {84 {Exit Mail Manager}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_ADD) {85 {Add item to selected list}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_DEL) {86 {Delete selected list-item}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_MOD) {87 {Modify selected item}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_UP) {88 {Move selected list-item up}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_DN) {89 {Most selected list-item down}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_DEF) {90 {Restore factory Defaults to selected item}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_BADHOST) {91 {Forward mail from unknown hosts}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_BADUSER) {92 {Forward mail from unknown users}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_UUCP) {93 {Enable or disable the UUCP channel}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_MHOME) {94 {Enable or disable the multihome channel}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_FOLDER_DIR) {95 {If null, users' home directories are used}}
set SCO_MAIL_ADMIN_MSGS(MSG_SHORT_FOLDER_NAME) {96 {If null, users' login names are used}}
set SCO_MAIL_ADMIN_MSGS(MSG_HOST) {97 {Host Name}}
set SCO_MAIL_ADMIN_MSGS(MSG_FROM) {98 {Mail Comes From}}
set SCO_MAIL_ADMIN_MSGS(MSG_DTABLE) {99 {Domain Table Enabled}}
set SCO_MAIL_ADMIN_MSGS(MSG_DTABLE_FILE) {100 {Domain Table File}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_LOCATION) {101 {Users' INBOX Location}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_SYSTEM) {102 {System Spool Directory}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_HOME) {103 {User's Home Directory}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_CUSTOM) {104 {Custom Location}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_DIR) {105 {Folder Directory}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_NAME) {106 {Folder Name}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_FORMAT) {107 {Default Folder Format}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_SENDMAIL) {108 Sendmail}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_MMDF) {109 MMDF}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_FSYNC) {110 {Folder Synchronize to Disk}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_CCHECK) {111 {Folder Consistency Checking}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_NORMAL) {112 Normal}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_EXT) {113 Extended}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_INCORE) {114 {Folders Cached in Memory}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_THRESHOLD) {115 {Folder Garbage Collection Threshold}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_TIMEOUT) {116 {Folder Lock Timeout}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_FILELOCK) {117 {File Based Locking Enabled}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER_UMASK) {118 {File/Directory Creation Umask}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_NAME) {119 {Channel Name}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_PROGRAM) {120 {Channel Program (P=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_ARGS) {121 {Channel Program Arguments (A=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_PROGDIR) {122 {Channel Program Run Directory (D=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_TABLE) {123 {Channel Table Type}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_FILE) {124 {Channel Table File}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_HOST) {125 {Forward all Channel Mail to}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_FLAGS) {126 {Channel Flags (F=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_EOL) {127 {Channel End of Line Character (E=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_MAXMSG) {128 {Channel Maximum Message Size (M=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_MAXLINE) {129 {Channel Maximum Line Size (L=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_NICE) {130 {Channel Program Nice Increment (N=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_USER) {131 {Channel Program Runs as User (U=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_GROUP) {132 {Channel Program Runs as Group (U=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_RECIP) {133 {Recipient Envelope Ruleset (R=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_HRECIP) {134 {Recipient Header Ruleset (R=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_SENDER) {135 {Sender Envelope Ruleset (S=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_CH_HSENDER) {136 {Sender Header Ruleset (S=)}}
set SCO_MAIL_ADMIN_MSGS(MSG_MAP) {137 {NIS Map}}
set SCO_MAIL_ADMIN_MSGS(MSG_FILE) {138 File}
set SCO_MAIL_ADMIN_MSGS(MSG_ALTERNATE) {139 {Alternate Name}}
set SCO_MAIL_ADMIN_MSGS(MSG_BASIC) {140 {Basic Configuration}}
set SCO_MAIL_ADMIN_MSGS(MSG_FOLDER) {141 {Folder Configuration}}
set SCO_MAIL_ADMIN_MSGS(MSG_ALIAS) {142 {Alias Files and Maps}}
set SCO_MAIL_ADMIN_MSGS(MSG_ALTNAME) {143 {Alternate Host Names}}
set SCO_MAIL_ADMIN_MSGS(MSG_CHANNEL) {144 {Mail Delivery Channels}}
set SCO_MAIL_ADMIN_MSGS(MSG_LOADING) {145 Loading...}
set SCO_MAIL_ADMIN_MSGS(MSG_NEW_CHANNEL) {146 {New Channel}}
set SCO_MAIL_ADMIN_MSGS(MSG_NONE) {147 <None>}
set SCO_MAIL_ADMIN_MSGS(MSG_DEFAULT) {148 <Default>}
set SCO_MAIL_ADMIN_MSGS(MSG_RULEDEF) {149 {<Same as Envelope>}}
set SCO_MAIL_ADMIN_MSGS(MSG_LOCAL) {150 Local}
set SCO_MAIL_ADMIN_MSGS(MSG_NEW) {151 New}
set SCO_MAIL_ADMIN_MSGS(MSG_CLOCAL) {152 Local}
set SCO_MAIL_ADMIN_MSGS(MSG_CBADHOST) {153 Badhost}
set SCO_MAIL_ADMIN_MSGS(MSG_CBADUSER) {154 Baduser}
set SCO_MAIL_ADMIN_MSGS(MSG_CMHOME) {155 Multihome}
set SCO_MAIL_ADMIN_MSGS(MSG_TTBADUSER) {156 {Match Unknown Users}}
set SCO_MAIL_ADMIN_MSGS(MSG_TTDNS) {157 {Look in Name Service}}
set SCO_MAIL_ADMIN_MSGS(MSG_TTUUCP) {158 {Match UUCP Configuration (Systems file)}}
set SCO_MAIL_ADMIN_MSGS(MSG_TTREMOTE) {159 {Match Non-Local Users}}
set SCO_MAIL_ADMIN_MSGS(MSG_TTLOCAL) {160 {Match Local Users}}
set SCO_MAIL_ADMIN_MSGS(MSG_TTFILE) {161 {File Lookup}}
set SCO_MAIL_ADMIN_MSGS(MSG_FLAGS_LIST1) {162 {Flags Not Set}}
set SCO_MAIL_ADMIN_MSGS(MSG_FLAGS_LIST2) {163 {Flags Set}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_UNKNOWN) {164 {Unknown User Specified Flag}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_a) {165 {Try ESMTP always instead of auto-sensing}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_A) {166 {Look up user in the alias database, usually local mailers only}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_b) {167 {Force blank line on end of a message}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_c) {168 {Do not include comments in addresses}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_C) {169 {Add @domain part for recipients that do not have it, the @domain part is taken from the sender address, it doesn't work reliably}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_d) {170 {Do not include angle brackets around route-syntax addresses, useful for shell script mailers}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_D) {171 {This mailer wants a date 'Date:' header line}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_e) {172 {Expensive mailer to connect to, connect only on queue runs}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_E) {173 {Escape lines beginning with 'From' in the message with a '>' sign}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_f) {174 {Pass -f from flag to mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_F) {175 {This mailer wants a 'From:' header line}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_g) {176 {Internally generated messages are from 'MAILER_DAEMON' ($u), instead of null}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_h) {177 {Upper case should be preserved in host names for this mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_I) {178 {This mailer will be speaking SMTP to another sendmail - use special protocol features of sendmail}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_j) {179 {Do User Database rewriting on recipients as well as senders}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_k) {180 {Disable SMTP loopback check}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_K) {181 {Currently unimplemented, reserved for chunking}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_l) {182 {This mailer is local, final delivery will be performed}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_L) {183 {Limit line lengths as specified in RFC821, L= should be used instead of this flag, this flag also sets the 7 flag}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_m) {184 {Mailer can handle multiple users, $u will be expanded as needed}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_M) {185 {This mailer wants a 'Message-Id:' header line}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_n) {186 {Do not insert a UNIX-style 'From' line on the front of the message}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_o) {187 {Always run as the user of the recipient mailbox, ignored if S is set}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_p) {188 {Use route-addr style reverese-path in the SMTP 'MAIL FROM:' command rather than just the return address}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_P) {189 {This mailer wants a 'Return-Path:' header line}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_q) {190 {Addresses for this mailer are verified as local by the SMTP verify command, i.e. 250 responses are generated instead of 252 responses}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_r) {191 {Same as f, but send -r flag}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_s) {192 {Strip quote characters (\" and \\) off of the address before calling the mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_S) {193 {Don't reset the userid before calling the mailer, if U= is also specified, then that user and group is used}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_u) {194 {Upper case should be preserved in user names for this mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_U) {195 {This mailer wants UUCP-style 'From' lines with the 'remote from host' on the end}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_w) {196 {The user must have a valid account on this machine or the mail will bounce, this is required to enable .forward capability}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_x) {197 {This mailer wants a 'Full-Name:' header line}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_X) {198 {This mailer wants to use the hidden dot algorithm described in RFC821}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_0) {199 {Don't look up MX records for hosts send via SMTP}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_3) {200 {When encoding quoted printable, include those characters that don't map cleanly between ASCII and EBCDIC}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_5) {201 {Enable ruleset 5 processing for this mailer, aliasing must be enabled (A flag)}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_7) {202 {Strip all output to seven bits, L flag sets this by default}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_8) {203 {Strip all output to seven bits, done after any 8 to 7 bit conversion}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_9) {204 {Do limited 7 to 8 bit MIME conversion, text/plain messages only}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_COLON) {205 {Check addresses to see if they begin with ':include:', if they do convert them to the '*include*' mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_PIPE) {206 {Check addresses to see if they begin with a '|', if they do convert them to the 'prog' mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_SLASH) {207 {Check addresses to see if they begin with a '/', if they do convert them to the '*file*' mailer}}
set SCO_MAIL_ADMIN_MSGS(MSG_F_AT) {208 {Look up addresses in the user database}}
proc \
mag_setcat { catname } \
{
    global mag_catname
    set mag_catname $catname
}
proc \
mag_msg { msg } \
{
    global mag_catname
    return [IntlLocalizeMsg ${mag_catname}_MSG_$msg]
}
proc \
mag_msg1 { msg arg } \
{
    global mag_catname
    return [IntlLocalizeMsg ${mag_catname}_MSG_$msg [list $arg]]
}
proc \
mag_err { msg } \
{
    global mag_catname
    return [IntlLocalizeMsg ${mag_catname}_ERR_$msg]
}
proc \
mag_err1 { msg arg } \
{
    global mag_catname
    return [IntlLocalizeMsg ${mag_catname}_ERR_$msg [list $arg]]
}
proc \
mag_query_eyn { msg arg } \
{
    global app
    set ret [VtErrorDialog $app.err -block \
        -message [mag_err1 $msg $arg] \
        -ok -okLabel [mag_msg STR_YES] \
        -apply -applyLabel [mag_msg STR_NO]]
    switch "$ret" {
    "OK"     {
        return yes
    }
    "APPLY"     {
        return no
    }
    "CANCEL" {
        return cancel
    }
    }
    error "mag_query_eyn: Unknown result code: $ret"
}
proc \
mag_query_eok { msg arg } \
{
    global app
    set ret [VtErrorDialog $app.err -block \
        -message [mag_err1 $msg $arg] \
        -ok -okLabel [mag_msg STR_OK]]
    if {"$ret" == "OK"} {
        return yes
    }
    error "mag_query_eok: Unknown result code: $ret"
}
proc \
mag_query_qync { msg arg } \
{
    global app
    set ret [VtQuestionDialog $app.err -block \
        -message [mag_msg1 $msg $arg] \
        -ok -okLabel [mag_msg STR_YES] \
        -apply -applyLabel [mag_msg STR_NO] \
        -cancel -cancelLabel [mag_msg STR_CANCEL]]
    switch "$ret" {
     "OK"     {
         return yes
     }
    "APPLY"     {
        return no
    }
    "CANCEL" {
        return cancel
    }
    }
    error "mag_query_qync: Unknown result code: $ret"
}
proc \
mag_query_qyn { msg arg } \
{
    global app
    set ret [VtQuestionDialog $app.err -block \
        -message [mag_msg1 $msg $arg] \
        -ok -okLabel [mag_msg STR_YES] \
        -apply -applyLabel [mag_msg STR_NO]]
    switch "$ret" {
     "OK"     {
         return yes
     }
    "APPLY"     {
        return no
    }
    }
    error "mag_query_qyn: Unknown result code: $ret"
}
proc \
mag_error { msg } \
{
    global app
    VtErrorDialog $app.err -block -ok -message [mag_err $msg]
}
proc \
mag_error1 { msg arg } \
{
    global app
    VtErrorDialog $app.err -block -ok -message [mag_err1 $msg $arg]
}
proc \
mag_warn1 { msg arg } \
{
    global app
    VtWarningDialog $app.err -block -ok -message [mag_msg1 $msg $arg]
}
proc \
mag_short_name_default {} \
{
    global mag_host_name
    set fqdn $mag_host_name
    set list [split $fqdn "."]
    return [lindex $list 0]
}
proc \
mag_num_to_bool num \
{
    if {$num == 0} {
        return [mag_msg STR_NO]
    }
    if {$num == 1} {
        return [mag_msg STR_YES]
    }
    error "Unknown boolean numeric $num"
}
proc \
mag_bool_to_num bool \
{
    if {"$bool" == "[mag_msg STR_NO]"} {
        return 0
    }
    if {"$bool" == "[mag_msg STR_YES]"} {
        return 1
    }
    error "Unknown boolean string $bool"
}
proc \
mag_string_to_bool str \
{
    set str [string toupper $str]
    if {"$str" == "FALSE"} {
        return [mag_msg STR_NO]
    }
    if {"$str" == "TRUE"} {
        return [mag_msg STR_YES]
    }
    error "Unknown boolean string $str"
}
proc \
mag_bool_to_string bool \
{
    if {"$bool" == "[mag_msg STR_NO]"} {
        return FALSE
    }
    if {"$bool" == "[mag_msg STR_YES]"} {
        return TRUE
    }
    error "Unknown boolean string $bool"
}
proc \
mag_ms1_location {} \
{
    global MAILSPOOL
    set inboxdir [ma_ms1_get MS1_INBOX_DIR]
    set inboxname [ma_ms1_get MS1_INBOX_NAME]
    # system spool directory
    if {"$inboxdir" == "$MAILSPOOL" && "$inboxname" == ""} {
        return [mag_msg FOLDER_SYSTEM]
    }
    if {"$inboxdir" == "" && "$inboxname" == ".mailbox"} {
        return [mag_msg FOLDER_HOME]
    }
    return [mag_msg FOLDER_CUSTOM]
}
proc \
mag_ms1_format {} \
{
    global MAILSPOOL
    set format [ma_ms1_get MS1_FOLDER_FORMAT]
    # case insensitive compares
    set format [string toupper $format]
    if {"$format" == "SENDMAIL"} {
        return [mag_msg FOLDER_SENDMAIL]
    }
    if {"$format" == "MMDF"} {
        return [mag_msg FOLDER_MMDF]
    }
    error "Unknown folder format: $format"
}
proc \
mag_table_to_internal { ttype } \
{
    if {"$ttype" == "[mag_msg TTBADUSER]"} {
        return baduser
    }
    if {"$ttype" == "[mag_msg TTDNS]"} {
        return DNS
    }
    if {"$ttype" == "[mag_msg TTUUCP]"} {
        return UUCP
    }
    if {"$ttype" == "[mag_msg TTREMOTE]"} {
        return remote
    }
    if {"$ttype" == "[mag_msg TTLOCAL]"} {
        return local
    }
    if {"$ttype" == "[mag_msg TTFILE]"} {
        return file
    }
    error "Unknown table type $ttype."
}
proc \
mag_table_enum {} \
{
    set list [list \
        [mag_msg TTBADUSER] \
        [mag_msg TTDNS] \
        [mag_msg TTUUCP] \
        [mag_msg TTREMOTE] \
        [mag_msg TTLOCAL] \
        [mag_msg TTFILE] \
    ]
    return $list
}
proc \
mag_table_to_external { ttype } \
{
    if {"$ttype" == "baduser"} {
        return [mag_msg TTBADUSER]
    }
    if {"$ttype" == "DNS"} {
        return [mag_msg TTDNS]
    }
    if {"$ttype" == "UUCP"} {
        return [mag_msg TTUUCP]
    }
    if {"$ttype" == "remote"} {
        return [mag_msg TTREMOTE]
    }
    if {"$ttype" == "local"} {
        return [mag_msg TTLOCAL]
    }
    if {"$ttype" == "file"} {
        return [mag_msg TTFILE]
    }
    error "Unknown table type $ttype."
}
proc \
mag_channel_to_alias { chname } \
{
    switch "$chname" {
    "local" {
        return [mag_msg CLOCAL]
    }
    "badhost" {
        return [mag_msg CBADHOST]
    }
    "baduser" {
        return [mag_msg CBADUSER]
    }
    "multihome" {
        return [mag_msg CMHOME]
    }
    }
    # no change
    return $chname
}
proc \
mag_channel_to_internal { chname } \
{
    if {"$chname" == "[mag_msg CLOCAL]"} {
        return local
    }
    if {"$chname" == "[mag_msg CBADHOST]"} {
        return badhost
    }
    if {"$chname" == "[mag_msg CBADUSER]"} {
        return baduser
    }
    if {"$chname" == "[mag_msg CMHOME]"} {
        return multihome
    }
    # no change
    return $chname
}
proc \
mag_rebuild_uucp_map { prompt } \
{
    global PID UUCP UUCPDB MAKEMAP
    # check if any UUCP channels
    set channels [mai_ch_names_get]
    set found no
    foreach chname $channels {
        set type [ma_ch_table_type_get $chname]
        if {"$type" == "UUCP"} {
            set found yes
            break
        }
    }
    if {"$found" == "no"} {
        return ok
    }
    # yes, check if UUCP map is out of date.
    set tmp1 "/tmp/systems.$PID"
    set tmp1db "/tmp/systems.$PID.db"
    set tmp2db "/tmp/systems.1.$PID.db"
    system "rm -f $tmp1 $tmp1db $tmp2db"
    set ret [mag_remote_copyin $UUCP $tmp1]
    set ret [mag_remote_copyin $UUCPDB $tmp2db]
    # now make a map
    if {[file exists $tmp1] == 1} {
        set copy no
        catch {system "$MAKEMAP hash $tmp1 < $tmp1 >/dev/null 2>&1"} ret
        if {$ret != 0} {
            if {"$prompt" == "yes"} {
                VtUnLock
                mag_error1 NO_MAP $UUCP
                VtLock
            }
            system "rm -f $tmp1 $tmp1db $tmp2db"
            return fail
        }
        # no previous map, always copy back
        if {[file exists $tmp2db] == 0} {
            set copy yes
        } else {
            catch {system "cmp $tmp1db $tmp2db > /dev/null 2>&1"} tmp
            # files are different
            if {$tmp == 1} {
                set copy yes
            }
        }
        if {"$prompt" == "no"} {
            set copy yes
        }
        if {"$copy" == "no"} {
            system "rm -f $tmp1 $tmp1db $tmp2db"
            return ok
        }
        # prompt if copy is ok.
        set ret yes
        if {"$prompt" == "yes"} {
            VtUnLock
            set ret [mag_query_qyn UUCP_UPDATE $UUCPDB]
            VtLock
        }
        if {"$ret" == "yes"} {
            set ret [mag_remote_copyout $tmp1db $UUCPDB]
            if {"$ret" == "fail"} {
                if {"$prompt" == "yes"} {
                    VtUnLock
                    mag_error1 COPY_BACK $UUCPDB
                    VtLock
                }
                system "rm -f $tmp1 $tmp1db $tmp2db"
                return fail
            }
        }
        system "rm -f $tmp1 $tmp1db $tmp2db"
    }
    return ok
}
proc \
mag_build_ruleset { env hdr } \
{
    if {"$hdr" == ""} {
        set value "$env"
    } else {
        if {"$env" != ""} {
            set value "$env/$hdr"
        } else {
            set value "0/$hdr"
        }
    }
    return $value
}
proc \
mag_escape { string } \
{
    set list [split $string "$$"]
    set newlist [join $list "\\$"]
    return $newlist
}
proc \
mag_trim_zero { value } \
{
    set sign ""
    set test $value
    if {"[csubstr $value 0 1]" == "-"} {
        set sign "-"
        set test [csubstr $value 1 end]
    }
    set test [string trimleft $test "0"]
    if {"$test" == ""} {
        set test "0"
    }
    set value "$sign$test"
    return $value
}
proc \
mao_init {} \
{
    global mainscreen_db
    set db ""
    set list [list container "" config 0 "" [mag_msg BASIC] closed]
    lappend db $list
    set list [list container "" folder 0 "" [mag_msg FOLDER] closed]
    lappend db $list
    set list [list container "" alias 0 add [mag_msg ALIAS] closed]
    lappend db $list
    set list [list container "" altname 0 add [mag_msg ALTNAME] closed]
    lappend db $list
    set list [list container "" channels 0 add [mag_msg CHANNEL] closed]
    lappend db $list
    set mainscreen_db $db
}
proc \
mao_activate { index } \
{
    global mainscreen_db MS
    set list [lindex $mainscreen_db $index]
    set class [lindex $list $MS(class)]
    if {"$class" == "property"} {
        set action [lindex $list $MS(action)]
        mai_modify $index
        return
    }
    set state [lindex $list $MS(state)]
    if {"$state" == "closed"} {
        mai_expand $index
        return
    }
    if {"$state" == "open"} {
        mai_collapse $index
        return
    }
    error "unknown state $state"
}
proc \
mao_default { index prompt } \
{
    global mainscreen_db MS MAILALIASES DIRTY SLOCAL
    set list [lindex $mainscreen_db $index]
    set class [lindex $list $MS(class)]
    if {"$class" == "property"} {
        set newlist [mai_prop_def $list]
        if {"$newlist" != "$list"} {
            set DIRTY 1
            set newlist [mai_prop_set $list $newlist]
            set mainscreen_db [lreplace $mainscreen_db \
                $index $index $newlist]
            # check other state changes
            mai_state $list $newlist $index
            # redraw main screen
            set stop [expr $index + 1]
            mag_display_mainlist $index $stop $index
        }
        return
    }
    set type [lindex $list $MS(type)]
    set state [lindex $list $MS(state)]
    if {"$prompt" == "yes"} {
        VtUnLock
        set ret [mag_query_qyn CONT_DEFAULT ""]
        VtLock
        if {"$ret" == "no"} {
            return
        }
    }
    set DIRTY 1
    # default all elements inside a container
    switch $type {
    "config" {
        if {"$state" == "open"} {
            mai_collapse $index
        }
        set children [mai_get_children $list]
        foreach child $children {
            set list [mai_prop_def $child]
            mai_prop_set $child $list
        }
        if {"$state" == "open"} {
            mai_expand $index
            return
        }
        return
    }
    "folder" {
        # same code as "config"
        if {"$state" == "open"} {
            mai_collapse $index
        }
        set children [mai_get_children $list]
        foreach child $children {
            set list [mai_prop_def $child]
            mai_prop_set $child $list
        }
        if {"$state" == "open"} {
            mai_expand $index
            return
        }
        return
    }
    "alias" {
        # the list of alias names must change
        # collapse if needed
        if {"$state" == "open"} {
            mai_collapse $index
        }
        ma_aliases_set $MAILALIASES
        if {"$state" == "open"} {
            mai_expand $index
        }
        return
    }
    "altname" {
        # the list of alternate names must change
        # collapse if needed
        if {"$state" == "open"} {
            mai_collapse $index
        }
        ma_alternate_names_set ""
        if {"$state" == "open"} {
            mai_expand $index
        }
        return
    }
    "channels" {
        # delete all channels and add back in the default ones.
        # collapse if needed
        if {"$state" == "open"} {
            mai_collapse $index
        }
        set children [mai_get_children $list]
        foreach child $children {
            set chname [lindex $child $MS(name)]
            ma_ch_delete $chname
        }
        ma_ch_create local
            ma_ch_sequence_set local 0
            ma_ch_equate_set local P $SLOCAL
            ma_ch_table_type_set local local
        ma_ch_create SMTP
            ma_ch_sequence_set SMTP 1
            ma_ch_equate_set SMTP P "\[IPC\]"
            ma_ch_table_type_set SMTP DNS
        ma_ch_create badhost
            ma_ch_sequence_set badhost 2
            ma_ch_equate_set badhost P "\[IPC\]"
            ma_ch_table_type_set badhost remote
        # set the channel props to defaults for new children
        set children [mai_get_children $list]
        foreach child $children {
            # get props for this channel
            set tmpchildren [mai_get_children $child]
            foreach tmpchild $tmpchildren {
                set tmplist [mai_prop_def $tmpchild]
                mai_prop_set $tmpchild $tmplist
            }
        }
        # don't preserve individual channel expansions as they might
        # not be there any more.
        if {"$state" == "open"} {
            mai_expand $index
        }
        return
    }
    "channel" {
        if {"$state" == "open"} {
            mai_collapse $index
        }
        # get props for this channel
        set children [mai_get_children $list]
        foreach child $children {
            set tmplist [mai_prop_def $child]
            mai_prop_set $child $tmplist
        }
        if {"$state" == "open"} {
            mai_expand $index
        }
        return
    }
    }
}
proc \
mao_select { index } \
{
    global mainscreen_db MS
    global btn_mod btn_add btn_del btn_up btn_dn
    global menu_mod menu_add menu_del menu_up menu_dn
    set list [lindex $mainscreen_db $index]
    set actions [lindex $list $MS(action)]
    set add FALSE
    set del FALSE
    set mod FALSE
    set mov FALSE
    foreach i $actions {
        if {"$i" == "mod"} {
            set mod TRUE
            continue
        }
        if {"$i" == "add"} {
            set add TRUE
            continue
        }
        if {"$i" == "mov"} {
            set mov TRUE
            continue
        }
        if {"$i" == "del"} {
            set del TRUE
            continue
        }
        error "unknown action $i"
    }
    if {[VtInfo -charm] == 0} {
        VtSetSensitive $btn_mod $mod
        VtSetSensitive $btn_add $add
        VtSetSensitive $btn_up $mov
        VtSetSensitive $btn_dn $mov
        VtSetSensitive $btn_del $del
    }
    VtSetSensitive $menu_mod $mod
    VtSetSensitive $menu_add $add
    VtSetSensitive $menu_up $mov
    VtSetSensitive $menu_dn $mov
    VtSetSensitive $menu_del $del
}
proc \
mao_move { index direction } \
{
    global mainscreen_db MS DIRTY
    # find number of children of current object
    set childcount [mai_child_length $index]
    # total length of current object
    set length [expr $childcount + 1]
    # length of mainlist
    set mainlen [llength $mainscreen_db]
    # our current object
    set list [lindex $mainscreen_db $index]
    set level [lindex $list $MS(level)]
    # index of last predecessor - 1
    set start [expr $index - 1]
    set stop 0
    set newlevel 0
    while {$start >= $stop} {
        set newlist [lindex $mainscreen_db $start]
        set newlevel [lindex $newlist $MS(level)]
        if {$newlevel <= $level} {
            break
        }
        set start [expr $start - 1]
    }
    if {$newlevel == $level} {
        set prev $start
    } else {
        set prev $index
    }
    # index of successor + 1
    set start [expr $index + 1]
    set stop $mainlen
    set newlevel 0
    while {$start < $stop} {
        set newlist [lindex $mainscreen_db $start]
        set newlevel [lindex $newlist $MS(level)]
        if {$newlevel <= $level} {
            break
        }
        set start [expr $start + 1]
    }
    if {$newlevel == $level} {
        set nextobj $start
        set next $start
        # open object check
        set class [lindex $newlist $MS(class)]
        if {"$class" == "container"} {
            set state [lindex $newlist $MS(state)]
            if {"$state" == "open"} {
                set tmpchildren [mai_get_children $newlist]
                set tmplength [llength $tmpchildren]
                set next [expr $next + $tmplength]
            }
        }
    } else {
        set next $index
    }
    # check if no-op
    if {"$direction" == "up" && $prev == $index} {
        return
    }
    if {"$direction" == "down"} {
        if {$next == $index} {
            return
        }
        # now check if next cannot be moved (baduser check)
        set action [lindex $newlist $MS(action)]
        if {[lsearch $action mov] == -1} {
            return
        }
    }
    set DIRTY 1
    # now fix internal database
    # can move three types, alias maps, alternate names, and channels
    set class [lindex $list $MS(class)]
    if {"$class" == "container"} {
        set type channel
    } else {
        set type [lindex $list $MS(name)]
    }
    # swap list with other
    if {"$direction" == "up"} {
        set other [lindex $mainscreen_db $prev]
    } else {
        set other [lindex $mainscreen_db $nextobj]
    }
    switch "$type" {
    "channel" {
        set chname1 [lindex $list $MS(name)]
        set chname2 [lindex $other $MS(name)]
        set order1 [ma_ch_sequence_get $chname1]
        set order2 [ma_ch_sequence_get $chname2]
        ma_ch_sequence_set $chname1 $order2
        ma_ch_sequence_set $chname2 $order1
    }
    "altname" {
        set alts [ma_alternate_names_get]
        set alt1 [lindex $list $MS(value)]
        set alt2 [lindex $other $MS(value)]
        set order1 [lsearch $alts $alt1]
        set order2 [lsearch $alts $alt2]
        set alts [lreplace $alts $order1 $order1 $alt2]
        set alts [lreplace $alts $order2 $order2 $alt1]
        ma_alternate_names_set $alts
    }
    "alias" {
        set aliases [ma_aliases_get]
        set alias1 [lindex $list $MS(value)]
        set alias2 [lindex $other $MS(value)]
        set order1 [lsearch $aliases $alias1]
        set order2 [lsearch $aliases $alias2]
        set aliases [lreplace $aliases $order1 $order1 $alias2]
        set aliases [lreplace $aliases $order2 $order2 $alias1]
        ma_aliases_set $aliases
    }
    }
    # ready to do mainscreen_db and main_list
    # first delete this item, both from mainscreen_db and main_list.
    set start $index
    set stop [expr $index + $childcount]
    set tmplist [lrange $mainscreen_db $start $stop]
    set mainscreen_db [lreplace $mainscreen_db $start $stop]
    set minus1 [expr $index - 1]
    mag_delete_mainlist $minus1 $length
    mag_display_mainlist $minus1 $index -1
    # update next index
    set next [expr $next - $length]
    # ready to insert at the appropriate location
    if {"$direction" == "up"} {
        # insert mainscreen_db before this index
        set insert $prev
    }
    if {"$direction" == "down"} {
        # insert mainscreen_db before this index
        set insert [expr $next + 1]
    }
    set pos $insert
    loop i 0 $length {
        set insertlist [lindex $tmplist $i]
        set mainscreen_db [linsert $mainscreen_db $pos $insertlist]
        set pos [expr $pos + 1]
    }
    # put new inserted data on screen
    set newstart [expr $insert - 1]
    mag_insert_mainlist $newstart $length
    # must redraw previous object through end of mainlist to get lines right
    mag_display_mainlist $start $mainlen $insert
}
proc \
mao_add { index } \
{
    global mainscreen_db DIRTY MS
    # we can add three types, alias maps, alternate names, and channels
    #
    # for maps and alt names our strategy is to create an empty
    # object onscreen named "new" and call mai_modify.  If mai_modify
    # returns yes, we keep the object otherwise we delete it.
    #
    # alias and altname are similar enough to share code,
    # channels are special.
    set container [lindex $mainscreen_db $index]
    set type [lindex $container $MS(type)]
    # new channel
    if {"$type" == "channels"} {
        mag_channel_create $index
        return
    }
    # common code for new alias or altername name
    # collapse onscreen container
    mai_collapse $index
    # add new item to top of list
    if {"$type" == "alias"} {
        set list [ma_aliases_get]
        set list "[mag_msg NEW] $list"
        ma_aliases_set $list
    }
    if {"$type" == "altname"} {
        set list [ma_alternate_names_get]
        set list "[mag_msg NEW] $list"
        ma_alternate_names_set $list
    }
    # make it visible
    mai_expand $index
    # select it
    set start [expr $index + 1]
    mag_display_mainlist $start $start $start
    # call mai_modify
    set ret [mai_modify $start]
    # keep the new entry
    if {"$ret" == "yes"} {
        set DIRTY 1
        return
    }
    # delete the new entry
    mao_delete $start
    # select the container
    mag_display_mainlist $index $index $index
}
proc \
mao_delete { index } \
{
    global mainscreen_db MS DIRTY
    set DIRTY 1
    # can delete three types, alias maps, alternate names, and channels
    set list [lindex $mainscreen_db $index]
    set class [lindex $list $MS(class)]
    set childcount 0
    if {"$class" == "container"} {
        set state [lindex $list $MS(state)]
        if {"$state" == "open"} {
            set children [mai_get_children $list]
            set childcount [llength $children]
        }
    }
    # first delete from the database
    if {"$class" == "container"} {
        set type channel
    } else {
        set type [lindex $list $MS(name)]
    }
    switch "$type" {
    "channel" {
        set chname [lindex $list $MS(name)]
        set channels [mai_ch_names_get]
        set order 0
        # resequence channels
        foreach i $channels {
            if {"$i" == "$chname"} {
                ma_ch_delete $chname
                continue
            }
            ma_ch_sequence_set $i $order
            set order [expr $order + 1]
        }
    }
    "altname" {
        set alts [ma_alternate_names_get]
        set alt [lindex $list $MS(value)]
        set order [lsearch $alts $alt]
        set alts [lreplace $alts $order $order]
        ma_alternate_names_set $alts
    }
    "alias" {
        set aliases [ma_aliases_get]
        set alias [lindex $list $MS(value)]
        set order [lsearch $aliases $alias]
        set aliases [lreplace $aliases $order $order]
        ma_aliases_set $aliases
    }
    }
    # now delete from the screen
    set length [expr $childcount + 1]
    set stop [expr $index + $childcount]
    set mainscreen_db [lreplace $mainscreen_db $index $stop]
    set start [expr $index - 1]
    mag_delete_mainlist $start $length
    # just reset current selected item
    set length [llength $mainscreen_db]
    if {$length == $index} {
        set select $start
    } else {
        set select $index
    }
    mag_display_mainlist $start [expr $start + 1] $select
    # check if current container needs to be redrawn,
    # last item is channel attribute
    set list [lindex $mainscreen_db $select]
    if {$select == $start && [lindex $list $MS(level)] == 2} {
        set start [mai_ch_find $select]
        mag_display_mainlist $start [expr $select + 1] -1
    }
}
proc \
mai_expand { index } \
{
    global mainscreen_db MS
    set list [lindex $mainscreen_db $index]
    set children [mai_get_children $list]
    # set open state
    set list [lreplace $list $MS(state) $MS(state) open]
    set mainscreen_db [lreplace $mainscreen_db $index $index $list]
    # redraw open folder before insert for appropriate visual effect
    set stop [expr $index + 1]
    mag_display_mainlist $index $stop -1
    # add to mainscreen_db
    set length [llength $mainscreen_db]
    set insert [expr $index + 1]
    # yes we can "insert" after the end of a list
    set length [llength $children]
    loop i 0 $length {
        set tmplist [lindex $children $i]
        set mainscreen_db [linsert $mainscreen_db $insert $tmplist]
        set insert [expr $insert + 1]
        if {$i == 0} {
            # redraw container to add line
            set stop [expr $index + 1]
            mag_display_mainlist $index $stop -1
        }
    }
    # update screen
    mag_insert_mainlist $index $length
    # reset selected item
    mag_display_mainlist $index $index $index
}
proc \
mai_collapse { index } \
{
    global mainscreen_db MS
    # find length of collapse operation
    set length [mai_child_length $index]
    if {$length > 0} {
        set start [expr $index + 1]
        set stop [expr $start + $length - 1]
        set mainscreen_db [lreplace $mainscreen_db $start $stop]
        mag_delete_mainlist $index $length
    }
    # set closed state
    set list [lindex $mainscreen_db $index]
    set list [lreplace $list $MS(state) $MS(state) closed]
    set mainscreen_db [lreplace $mainscreen_db $index $index $list]
    # redraw container
    set stop [expr $index + 1]
    mag_display_mainlist $index $stop $index
}
proc \
mai_child_length { index } \
{
    global mainscreen_db MS
    set list [lindex $mainscreen_db $index]
    set length 0
    set level [lindex $list $MS(level)]
    set start [expr $index + 1]
    set stop [llength $mainscreen_db]
    while {$start < $stop} {
        set list [lindex $mainscreen_db $start]
        set newlevel [lindex $list $MS(level)]
        if {$newlevel <= $level} {
            break
        }
        set start [expr $start + 1]
        set length [expr $length + 1]
    }
    return $length
}
proc \
mai_get_children { object } \
{
    global mainscreen_db MS
    global MAILSPOOL INBOXNAME
    set list $object
    set class [lindex $list $MS(class)]
    set type [lindex $list $MS(type)]
    set children ""
    switch $type {
    "config" {
        set child [list property host fqdn 1 mod [mag_msg HOST] ""]
        set child [mai_prop_get $child]
        lappend children $child
        set child [list property from fromdom 1 mod [mag_msg FROM] "" ""]
        set child [mai_prop_get $child]
        lappend children $child
        set child [list property domain boolean 1 mod \
            [mag_msg DTABLE] ""]
        set child [mai_prop_get $child]
        lappend children $child
        set child [list property dtable domtable 1 mod \
            [mag_msg DTABLE_FILE] ""]
        set child [mai_prop_get $child]
        lappend children $child
    }
    "folder" {
        # folder location
        set enum [list [mag_msg FOLDER_SYSTEM] [mag_msg FOLDER_HOME] \
            [mag_msg FOLDER_CUSTOM]]
        set child [list property flocation enum 1 mod \
            [mag_msg FOLDER_LOCATION] "" $enum ""]
        set child [mai_prop_get $child]
        lappend children $child
        # folder format
        set enum [list [mag_msg FOLDER_SENDMAIL] [mag_msg FOLDER_MMDF]]
        set child [list property fformat enum 1 mod \
            [mag_msg FOLDER_FORMAT] "" $enum]
        set child [mai_prop_get $child]
        lappend children $child
        # folder sync
        set child [list property fsync boolean 1 mod \
            [mag_msg FOLDER_FSYNC] ""]
        set child [mai_prop_get $child]
        lappend children $child
        # folder checks
        set child [list property fccheck boolean 1 mod \
            [mag_msg FOLDER_CCHECK] ""]
        set child [mai_prop_get $child]
        lappend children $child
        # folders incore
        set child [list property fincore boolean 1 mod \
            [mag_msg FOLDER_INCORE] ""]
        set child [mai_prop_get $child]
        lappend children $child
        # expunge threshold
        set range [list 0 100]
        set child [list property fthreshold intrange 1 mod \
            [mag_msg FOLDER_THRESHOLD] "" $range]
        set child [mai_prop_get $child]
        lappend children $child
        # lock timeout
        set range [list 1 999]
        set child [list property ftimeout intrange 1 mod \
            [mag_msg FOLDER_TIMEOUT] "" $range]
        set child [mai_prop_get $child]
        lappend children $child
        # file based locking
        set child [list property ffilelock boolean 1 mod \
            [mag_msg FOLDER_FILELOCK] ""]
        set child [mai_prop_get $child]
        lappend children $child
        # umask
        set child [list property fumask umask 1 mod \
            [mag_msg FOLDER_UMASK] ""]
        set child [mai_prop_get $child]
        lappend children $child
    }
    "alias" {
        set aliases [ma_aliases_get]
        set action [list mov del mod]
        foreach i $aliases {
            set test [csubstr $i 0 4]
            if {"$test" == "nis:"} {
                set label [mag_msg MAP]
            } else {
                set label [mag_msg FILE]
            }
            set child [list property alias alias 1 $action \
                $label $i]
            lappend children $child
        }
    }
    "altname" {
        set alternates [ma_alternate_names_get]
        set action [list mov del mod]
        foreach i $alternates {
            set child [list property altname fqdn 1 $action \
                [mag_msg ALTERNATE] $i]
            lappend children $child
        }
    }
    "channels" {
        set channels [mai_ch_names_get]
        # default action list
        set action1 [list mov del]
        # bad user channel does not have "mov" action
        set action2 [list del]
        foreach i $channels {
            set chtable [ma_ch_table_type_get $i]
            if {"$chtable" != "baduser"} {
                set action $action1
            } else {
                set action $action2
            }
            set child [list container $i channel 1 $action \
                "" closed]
            set child [mai_prop_get $child]
            lappend children $child
        }
    }
    "channel" {
        set chname [lindex $list $MS(name)]
        # channel name
        set child [list property cname rstring 2 mod \
            [mag_msg CH_NAME] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # program name
        set child [list property cprogram chpath 2 mod \
            [mag_msg CH_PROGRAM] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # program arguments
        set child [list property cargs string 2 mod \
            [mag_msg CH_ARGS] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel program directory
        set child [list property cdir path 2 mod \
            [mag_msg CH_PROGDIR] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel table type
        set enum [mag_table_enum]
        set child [list property ctable enum 2 mod \
            [mag_msg CH_TABLE] "" $enum $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel file
        set child [list property cfile chtable 2 mod \
            [mag_msg CH_FILE] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel host
        set child [list property chost ofqdn 2 mod \
            [mag_msg CH_HOST] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel flags
        set child [list property cflags flags 2 mod \
            [mag_msg CH_FLAGS] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel EOL
        set child [list property ceol rstring 2 mod \
            [mag_msg CH_EOL] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel max msg size
        set range [list 0 2000000000]
        set child [list property cmaxmsg ointrange 2 mod \
            [mag_msg CH_MAXMSG] "" $range $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel max line size
        set range [list 0 10000]
        set child [list property cmaxline ointrange 2 mod \
            [mag_msg CH_MAXLINE] "" $range $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel program nice value
        set range [list -20 20]
        set child [list property cnice intrange 2 mod \
            [mag_msg CH_NICE] "" $range $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel user
        set child [list property cuser user 2 mod \
            [mag_msg CH_USER] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # channel group
        set child [list property cgroup group 2 mod \
            [mag_msg CH_GROUP] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # recipient envelope ruleset
        set child [list property crecip ruleset 2 mod \
            [mag_msg CH_RECIP] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # recipient header ruleset
        set child [list property chrecip ruleset 2 mod \
            [mag_msg CH_HRECIP] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # sender envelope ruleset
        set child [list property csender ruleset 2 mod \
            [mag_msg CH_SENDER] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
        # sender header ruleset
        set child [list property chsender ruleset 2 mod \
            [mag_msg CH_HSENDER] "" "" $chname]
        set child [mai_prop_get $child]
        lappend children $child
    }
    }
    return $children
}
proc \
mai_ch_names_get {} \
{
    set list [ma_ch_names_get]
    set order ""
    foreach i $list {
        lappend order [ma_ch_sequence_get $i]
    }
    set sorted ""
    set length [llength $list]
    loop i 0 $length {
        # find the appropriate one in order
        loop j 0 $length {
            set item [lindex $order $j]
            if {$item == $i} {
                lappend sorted [lindex $list $j]
                break
            }
        }
    }
    return $sorted
}
proc \
mai_prop_def { object } \
{
    global mainscreen_db MS
    global MAILSPOOL INBOXNAME MAILTABLE MQUEUE UUX
    global MDOMAINDB
    global mag_host_name
    set list $object
    set class [lindex $list $MS(class)]
    set name [lindex $list $MS(name)]
    switch $name {
    "host" {
        set value $mag_host_name
    }
    "from" {
        set value $mag_host_name
    }
    "domain" {
        set value [mag_num_to_bool 0]
    }
    "dtable" {
        # does nothing, keep original value
        set value [lindex $list $MS(value)]
    }
    }
    # folder properties
    switch $name {
    "flocation" {
        set value [mag_msg FOLDER_SYSTEM]
        set custom [list $MAILSPOOL ""]
        set list [lreplace $list $MS(custom) $MS(custom) $custom]
    }
    "fformat" {
        set value [mag_msg FOLDER_SENDMAIL]
    }
    "fsync" {
        set value [mag_num_to_bool 0]
    }
    "fccheck" {
        set value [mag_num_to_bool 0]
    }
    "fincore" {
        set value [mag_num_to_bool 0]
    }
    "fthreshold" {
        set value 50
    }
    "ftimeout" {
        set value 10
    }
    "ffilelock" {
        set value [mag_num_to_bool 0]
    }
    "fumask" {
        set value "077"
    }
    }
    # alias and altname properties
    switch $name {
    "alias" {
        set value [lindex $list $MS(value)]
    }
    "altname" {
        set value [lindex $list $MS(value)]
    }
    }
    # if a channel property, get channel name from backlink
    if {[catch {set tmp $value}] != 0} {
        set chname [lindex $list $MS(chname)]
        set chprogram [ma_ch_equate_get $chname P]
        if {"$chprogram" == "\[IPC\]"} {
            set chprogram SMTP
        }
        set chtable [ma_ch_table_type_get $chname]
    }
    # channel properties with no defaults
    switch $name {
    "cname" {
        set value [lindex $list $MS(value)]
    }
    "cprogram" {
        set value $chprogram
    }
    "ctable" {
        set value [mag_table_to_external $chtable]
    }
    }
    # channel properties with defaults based upon the above values
    switch $name {
    "cargs" {
        set prog $chprogram
        # default value
        set base [exec basename $prog]
        set value "$base \$u"
        # special cases
        switch $base {
        "SMTP" {
            set value "IPC \$h"
        }
        "uux" {
            set value "uux - -r -a\$f -gmedium \$h!rmail (\$u)"
        }
        "slocal" {
            set value "slocal \$u"
        }
        }
    }
    "cdir" {
        set value $MQUEUE
    }
    "cfile" {
        # note that the file is not renamed
        if {"[exec basename $chprogram]" == "multihome"} {
            set value $MDOMAINDB
        } elseif {"$chtable" == "file"} {
            set value "$MAILTABLE/$chname"
        } else {
            set value ""
        }
    }
    "chost" {
        set value [mag_msg NONE]
    }
    "cflags" {
        # custom same as SMTP
        set value "mlsDFMPeu8"
        switch [exec basename $chprogram] {
        "SMTP" {
            set value "mlsDFMPeu8"
        }
        "uux" {
            set value "mDFMhuU8"
        }
        "slocal" {
            set value "lsDFMPhoAw5:|/@8"
        }
        }
    }
    "ceol" {
        if {"$chprogram" == "SMTP"} {
            set value "\\r\\n"
        } else {
            set value "\\n"
        }
    }
    "cmaxmsg" {
        if {"[exec basename $chprogram]" == "uux"} {
            set value 100000
        } else {
            #set value [mag_msg NONE]
            set value 20000000
        }
    }
    "cmaxline" {
        if {"$chprogram" == "SMTP"} {
            set value 990
        } else {
            set value [mag_msg NONE]
        }
    }
    "cnice" {
        set value 0
    }
    "cuser" {
        set value [mag_msg DEFAULT]
    }
    "cgroup" {
        set value [mag_msg DEFAULT]
    }
    "crecip" {
        set value ap822_re
        switch [exec basename $chprogram] {
        "SMTP" {
            set value ap822_re
        }
        "uux" {
            set value ap976_re
        }
        "slocal" {
            set value aplocal_re
        }
        }
    }
    "chrecip" {
        set value ap822_rh
        switch [exec basename $chprogram] {
        "SMTP" {
            set value ap822_rh
        }
        "uux" {
            set value ap976_rh
        }
        "slocal" {
            set value aplocal_rh
        }
        }
    }
    "csender" {
        set value ap822_se
        switch [exec basename $chprogram] {
        "SMTP" {
            set value ap822_se
        }
        "uux" {
            set value ap976_se
        }
        "slocal" {
            set value aplocal_se
        }
        }
    }
    "chsender" {
        set value ap822_sh
        switch [exec basename $chprogram] {
        "SMTP" {
            set value ap822_sh
        }
        "uux" {
            set value ap976_sh
        }
        "slocal" {
            set value aplocal_sh
        }
        }
    }
    }
    set list [lreplace $list $MS(value) $MS(value) $value]
    return $list
}
proc \
mai_prop_get { object } \
{
    global mainscreen_db MS mag_host_name
    global MAILSPOOL INBOXNAME MAILTABLE MQUEUE
    set list $object
    set class [lindex $list $MS(class)]
    set name [lindex $list $MS(name)]
    set type [lindex $list $MS(type)]
    switch $name {
    "host" {
        set value [ma_machine_name_get]
        if {"$value" == ""} {
            set value $mag_host_name
        }
    }
    "from" {
        set value [ma_from_domain_get]
        if {"$value" == ""} {
            set value $mag_host_name
        }
    }
    "domain" {
        set value [mag_num_to_bool [ma_domain_table_enabled_get]]
    }
    "dtable" {
        set value [ma_domain_table_file_get]
    }
    }
    # folder properties
    switch $name {
    "flocation" {
        set dir [ma_ms1_get MS1_INBOX_DIR]
        set name [ma_ms1_get MS1_INBOX_NAME]
        set value [mag_msg FOLDER_CUSTOM]
        if {"$dir" == "$MAILSPOOL" && "$name" == ""} {
            set value [mag_msg FOLDER_SYSTEM]
        }
        if {"$dir" == "" && "$name" == "$INBOXNAME"} {
            set value [mag_msg FOLDER_HOME]
        }
        set tmplist [list $dir $name]
        set list [lreplace $list \
            $MS(custom) $MS(custom) $tmplist]
    }
    "fformat" {
        set tmp [ma_ms1_get MS1_FOLDER_FORMAT]
        if {"$tmp" == "Sendmail"} {
            set value [mag_msg FOLDER_SENDMAIL]
        }
        if {"$tmp" == "MMDF"} {
            set value [mag_msg FOLDER_MMDF]
        }
    }
    "fsync" {
        set value [mag_string_to_bool [ma_ms1_get MS1_FSYNC]]
    }
    "fccheck" {
        set value [mag_string_to_bool [ma_ms1_get MS1_EXTENDED_CHECKS]]
    }
    "fincore" {
        set value [mag_string_to_bool [ma_ms1_get MS1_FOLDERS_INCORE]]
    }
    "fthreshold" {
        set value [ma_ms1_get MS1_EXPUNGE_THRESHOLD]
    }
    "ftimeout" {
        set value [ma_ms1_get MS1_LOCK_TIMEOUT]
    }
    "ffilelock" {
        set value [mag_string_to_bool [ma_ms1_get MS1_FILE_LOCKING]]
    }
    "fumask" {
        set value [ma_ms1_get MS1_UMASK]
    }
    }
    if {"$type" == "channel"} {
        # a channel container, special work here
        # here the label rather than the value is changed
        set chname [lindex $list $MS(name)]
        set label [mag_channel_to_alias $chname]
        set list [lreplace $list $MS(label) $MS(label) $label]
        return $list
    }
    # is a channel property, get chname
    set chname [lindex $list $MS(chname)]
    switch $name {
    "cname" {
        set value [mag_channel_to_alias $chname]
    }
    "cprogram" {
        set value [ma_ch_equate_get $chname P]
        if {"$value" == "\[IPC\]"} {
            set value SMTP
        }
    }
    "cargs" {
        set value [ma_ch_equate_get $chname A]
    }
    "cdir" {
        set value [ma_ch_equate_get $chname D]
        if {"$value" == ""} {
            set value $MQUEUE
        }
    }
    "ctable" {
        set value [ma_ch_table_type_get $chname]
        set value [mag_table_to_external $value]
    }
    "cfile" {
        set value [ma_ch_table_file_get $chname]
    }
    "chost" {
        set value [ma_ch_host_get $chname]
        if {"$value" == ""} {
            set value [mag_msg NONE]
        }
    }
    "cflags" {
        set value [ma_ch_equate_get $chname F]
    }
    "ceol" {
        set value [ma_ch_equate_get $chname E]
        if {"$value" == ""} {
            set value "\\n"
        }
    }
    "cmaxmsg" {
        set value [ma_ch_equate_get $chname M]
        if {"$value" == ""} {
            set value [mag_msg NONE]
        }
    }
    "cmaxline" {
        set value [ma_ch_equate_get $chname L]
        if {"$value" == ""} {
            set value [mag_msg NONE]
        }
    }
    "cnice" {
        set value [ma_ch_equate_get $chname N]
        if {"$value" == ""} {
            set value 0
        }
    }
    "cuser" {
        set both [ma_ch_equate_get $chname U]
        if {"$both" == ""} {
            set value [mag_msg DEFAULT]
        } else {
            set tmplist [split $both ":"]
            set value [lindex $tmplist 0]
        }
    }
    "cgroup" {
        set both [ma_ch_equate_get $chname U]
        if {"$both" == ""} {
            set value [mag_msg DEFAULT]
        } else {
            set tmplist [split $both ":"]
            set value [lindex $tmplist 1]
            if {"$value" == ""} {
                set value [mag_msg DEFAULT]
            }
        }
    }
    "crecip" {
        set recip [ma_ch_equate_get $chname R]
        set reciplist [split $recip "/"]
        set value [lindex $reciplist 0]
        if {"$value" == "" || "$value" == "0"} {
            set value [mag_msg NONE]
        }
    }
    "chrecip" {
        set recip [ma_ch_equate_get $chname R]
        set reciplist [split $recip "/"]
        set value [lindex $reciplist 1]
        if {"$value" == "" || "$value" == "0"} {
            set value [mag_msg RULEDEF]
        }
    }
    "csender" {
        set sender [ma_ch_equate_get $chname S]
        set senderlist [split $sender "/"]
        set value [lindex $senderlist 0]
        if {"$value" == "" || "$value" == "0"} {
            set value [mag_msg NONE]
        }
    }
    "chsender" {
        set sender [ma_ch_equate_get $chname S]
        set senderlist [split $sender "/"]
        set value [lindex $senderlist 1]
        if {"$value" == "" || "$value" == "0"} {
            set value [mag_msg RULEDEF]
        }
    }
    }
    set list [lreplace $list $MS(value) $MS(value) $value]
    return $list
}
proc \
mai_prop_set { oldobject newobject } \
{
    global mainscreen_db MS mag_host_name
    global MAILSPOOL INBOXNAME MAILTABLE MQUEUE
    set list $newobject
    set class [lindex $list $MS(class)]
    set name [lindex $list $MS(name)]
    set value [lindex $list $MS(value)]
    switch $name {
    "host" {
        if {"$value" == "$mag_host_name"} {
            set value ""
        }
        ma_machine_name_set $value
        set set ok
    }
    "from" {
        if {"$value" == "$mag_host_name"} {
            set value ""
        }
        ma_from_domain_set $value
        set set ok
    }
    "domain" {
        ma_domain_table_enabled_set [mag_bool_to_num $value]
        set set ok
    }
    "dtable" {
        # does nothing
        set set ok
    }
    }
    # have to remove old name, put in new name, preserve order
    # no check for name conflicts yet
    if {"$name" == "alias" || "$name" == "altname"} {
        set oldname [lindex $oldobject $MS(value)]
        set newname $value
        # get old list
        switch "$name" {
        "alias" {
            set tmplist [ma_aliases_get]
        }
        "altname" {
            set tmplist [ma_alternate_names_get]
        }
        }
        # replace item
        set index [lsearch $tmplist $oldname]
        set tmplist [lreplace $tmplist $index $index $newname]
        switch "$name" {
        "alias" {
            set tmplist [ma_aliases_set $tmplist]
        }
        "altname" {
            set tmplist [ma_alternate_names_set $tmplist]
        }
        }
        set set ok
    }
    # folder properties
    switch $name {
    "flocation" {
        if {"$value" == "[mag_msg FOLDER_SYSTEM]"} {
            ma_ms1_set MS1_INBOX_DIR $MAILSPOOL
            ma_ms1_set MS1_INBOX_NAME ""
            set set ok
        }
        if {"$value" == "[mag_msg FOLDER_HOME]"} {
            ma_ms1_set MS1_INBOX_DIR ""
            ma_ms1_set MS1_INBOX_NAME $INBOXNAME
            set set ok
        }
        # use custom spot for custom values
        if {"$value" == "[mag_msg FOLDER_CUSTOM]"} {
            set tmplist [lindex $list $MS(custom)]
            ma_ms1_set MS1_INBOX_DIR [lindex $tmplist 0]
            ma_ms1_set MS1_INBOX_NAME [lindex $tmplist 1]
            set set ok
        }
    }
    "fformat" {
        if {"$value" == "[mag_msg FOLDER_SENDMAIL]"} {
            ma_ms1_set MS1_FOLDER_FORMAT Sendmail
            set set ok
        }
        if {"$value" == "[mag_msg FOLDER_MMDF]"} {
            ma_ms1_set MS1_FOLDER_FORMAT MMDF
            set set ok
        }
    }
    "fsync" {
        ma_ms1_set MS1_FSYNC [mag_bool_to_string $value]
        set set ok
    }
    "fccheck" {
        ma_ms1_set MS1_EXTENDED_CHECKS [mag_bool_to_string $value]
        set set ok
    }
    "fincore" {
        ma_ms1_set MS1_FOLDERS_INCORE [mag_bool_to_string $value]
        set set ok
    }
    "fthreshold" {
        ma_ms1_set MS1_EXPUNGE_THRESHOLD $value
        set set ok
    }
    "ftimeout" {
        ma_ms1_set MS1_LOCK_TIMEOUT $value
        set set ok
    }
    "ffilelock" {
        ma_ms1_set MS1_FILE_LOCKING [mag_bool_to_string $value]
        set set ok
    }
    "fumask" {
        ma_ms1_set MS1_UMASK $value
        set set ok
    }
    }
    # is a channel property, get chname
    set chname [lindex $list $MS(chname)]
    switch $name {
    "cname" {
        set newvalue [mag_channel_to_internal $value]
        set oldvalue [lindex $oldobject $MS(chname)]
        # rename channel
        set set [ma_ch_rename $oldvalue $newvalue]
        if {"$set" != "ok"} {
            # return error code if one.
            set newobject $set
        } else {
            # set new name in channel-name object
            # the alias has already been set
            set newobject [lreplace $newobject \
                $MS(chname) $MS(chname) $newvalue]
        }
    }
    "cprogram" {
        if {"$value" == "SMTP"} {
            set value "\[IPC\]"
        }
        ma_ch_equate_set $chname P $value
        set set ok
    }
    "cargs" {
        ma_ch_equate_set $chname A $value
        set set ok
    }
    "cdir" {
        if {"$value" == "$MQUEUE"} {
            set value ""
        }
        ma_ch_equate_set $chname D $value
        set set ok
    }
    "ctable" {
        ma_ch_table_type_set $chname [mag_table_to_internal $value]
        set set ok
    }
    "cfile" {
        ma_ch_table_file_set $chname $value
        set set ok
    }
    "chost" {
        if {"$value" == "[mag_msg NONE]"} {
            set value ""
        }
        ma_ch_host_set $chname $value
        set set ok
    }
    "cflags" {
        ma_ch_equate_set $chname F $value
        set set ok
    }
    "ceol" {
        if {"$value" == "\\n"} {
            set value ""
        }
        ma_ch_equate_set $chname E $value
        set set ok
    }
    "cmaxmsg" {
        if {"$value" == "[mag_msg NONE]"} {
            set value ""
        }
        ma_ch_equate_set $chname M $value
        set set ok
    }
    "cmaxline" {
        if {"$value" == "[mag_msg NONE]"} {
            set value ""
        }
        ma_ch_equate_set $chname L $value
        set set ok
    }
    "cnice" {
        if {$value == 0} {
            set value ""
        }
        ma_ch_equate_set $chname N $value
        set set ok
    }
    "cuser" {
        if {"$value" == "[mag_msg DEFAULT]"} {
            set value ""
        }
        set both [ma_ch_equate_get $chname U]
        set tmplist [split $both ":"]
        set user [lindex $tmplist 0]
        set group [lindex $tmplist 1]
        if {"$value" == ""} {
            set group ""
        }
        if {"$group" != ""} {
            set both "$value:$group"
        } else {
            set both $value
        }
        ma_ch_equate_set $chname U $both
        set set ok
    }
    "cgroup" {
        if {"$value" == "[mag_msg DEFAULT]"} {
            set value ""
        }
        set both [ma_ch_equate_get $chname U]
        set tmplist [split $both ":"]
        set user [lindex $tmplist 0]
        set group [lindex $tmplist 1]
        # assume user is set first
        if {"$value" != ""} {
            set both "$user:$value"
        } else {
            set both $user
        }
        ma_ch_equate_set $chname U $both
        set set ok
    }
    "crecip" {
        set recip [ma_ch_equate_get $chname R]
        set reciplist [split $recip "/"]
        set env [lindex $reciplist 0]
        set hdr [lindex $reciplist 1]
        set env $value
        if {"$value" == "[mag_msg NONE]"} {
            set env ""
        }
        set value [mag_build_ruleset $env $hdr]
        ma_ch_equate_set $chname R $value
        set set ok
    }
    "chrecip" {
        set recip [ma_ch_equate_get $chname R]
        set reciplist [split $recip "/"]
        set env [lindex $reciplist 0]
        set hdr [lindex $reciplist 1]
        set hdr $value
        if {"$value" == "[mag_msg RULEDEF]"} {
            set hdr ""
        }
        set value [mag_build_ruleset $env $hdr]
        ma_ch_equate_set $chname R $value
        set set ok
    }
    "csender" {
        set sender [ma_ch_equate_get $chname S]
        set senderlist [split $sender "/"]
        set env [lindex $senderlist 0]
        set hdr [lindex $senderlist 1]
        set env $value
        if {"$value" == "[mag_msg NONE]"} {
            set env ""
        }
        set value [mag_build_ruleset $env $hdr]
        ma_ch_equate_set $chname S $value
        set set ok
    }
    "chsender" {
        set sender [ma_ch_equate_get $chname S]
        set senderlist [split $sender "/"]
        set env [lindex $senderlist 0]
        set hdr [lindex $senderlist 1]
        set hdr $value
        if {"$value" == "[mag_msg RULEDEF]"} {
            set hdr ""
        }
        set value [mag_build_ruleset $env $hdr]
        ma_ch_equate_set $chname S $value
        set set ok
    }
    }
    return $newobject
}
proc \
mai_ch_find { index } \
{
    global mainscreen_db MS
    loop i $index 0 -1 {
        set list [lindex $mainscreen_db $i]
        set class [lindex $list $MS(class)]
        if {"$class" == "container"} {
            return $i
        }
    }
}
proc \
mai_prop_find { index name } \
{
    global mainscreen_db MS
    set start [expr $index + 1]
    set stop [llength $mainscreen_db]
    loop i $start $stop {
        set list [lindex $mainscreen_db $i]
        set class [lindex $list $MS(class)]
        set tmpname [lindex $list $MS(name)]
        if {"$tmpname" == "$name"} {
            return $i
        }
    }
}
proc \
mai_modify { index } \
{
    global mainscreen_db DIRTY MS
    set object [lindex $mainscreen_db $index]
    set newobject [mai_pre $object $index]
    if {"$newobject" == ""} {
        return no
    }
    set newobject [mai_edit $newobject]
    if {"$newobject" == ""} {
        return no
    }
    set newobject [mai_post $newobject $index]
    if {"$newobject" == ""} {
        return no
    }
    if {"$object" != "$newobject"} {
        set DIRTY 1
        set value [lindex $newobject $MS(value)]
        set newobject [mai_prop_set $object $newobject]
        switch "$newobject" {
        "conflict" {
            VtUnLock
            mag_error CONFLICT
            VtLock
            return no
        }
        "badname" {
            VtUnLock
            mag_error1 INVALID $value
            VtLock
            return no
        }
        }
        set mainscreen_db [lreplace $mainscreen_db $index $index $newobject]
        # redraw main screen
        set stop [expr $index + 1]
        mag_display_mainlist $index $stop $index
        mai_state $object $newobject $index
    }
    return yes
}
proc \
mai_pre { object index } \
{
    global mainscreen_db MS
    set type [lindex $object $MS(type)]
    set value [lindex $object $MS(value)]
    set name [lindex $object $MS(name)]
    switch "$type" {
    "chtable" {
        # cannot edit if channel not of type table.
        set chindex [mai_ch_find $index]
        # find channel table type
        set ctindex [mai_prop_find $chindex ctable]
        set tmpobject [lindex $mainscreen_db $ctindex]
        set ctable [lindex $tmpobject $MS(value)]
        if {"$ctable" != "[mag_msg TTFILE]"} {
            VtUnLock
            mag_error FILE_ONLY
            VtLock
            return ""
        }
    }
    "group" {
        # user must be set before group can be set
        set chindex [mai_ch_find $index]
        # find channel user setting
        set ctindex [mai_prop_find $chindex cuser]
        set tmpobject [lindex $mainscreen_db $ctindex]
        set cuser [lindex $tmpobject $MS(value)]
        if {"$cuser" == "[mag_msg DEFAULT]"} {
            VtUnLock
            mag_error USER_FIRST
            VtLock
            return ""
        }
    }
    "fromdom" {
        # build enumerated list from host name
        # find host name
        set length [llength $mainscreen_db]
        loop i 0 $length {
            set tmplist [lindex $mainscreen_db $i]
            set tmpclass [lindex $tmplist $MS(class)]
            if {"$tmpclass" == "container"} {
                continue
            }
            set tmpname  [lindex $tmplist $MS(name)]
            if {"$tmpname" == "host"} {
                set hindex $i
                break
            }
        }
        # build enumerated list
        set host [lindex $tmplist $MS(value)]
        set tokens [split $host "."]
        set base [lindex $tokens 0]
        set enum ""
        set length [llength $tokens]
        set length [expr $length - 1]
        loop i 0 $length {
            set itemlist "[lrange $tokens $i end]"
            set item [join $itemlist "."]
            lappend enum $item
        }
        lappend enum $base
        set object [lreplace $object $MS(criteria) $MS(criteria) $enum]
    }
    }
    return $object
}
proc \
mai_edit { object } \
{
    global ME PID mag_host_name
    # file is used to pass results to preserve stdout for child process.
    set file "/tmp/mag.$PID"
    system "rm -f $file"
    VtControl -suspend
    set escape [mag_escape $object]
    system "$ME -h $mag_host_name -mag_stand_edit \"$escape\" $file"
    VtControl -resume
    if {[file exists $file] == 1} {
        set newobject [exec cat $file]
        system "rm -f $file"
    } else {
        set newobject ""
    }
    return $newobject
}
proc \
mai_post { object index } \
{
    global mainscreen_db MS
    set oldobject [lindex $mainscreen_db $index]
    set type [lindex $object $MS(type)]
    set name [lindex $object $MS(name)]
    set value [lindex $object $MS(value)]
    set criteria [lindex $object $MS(criteria)]
    set error ""
    set arg $value
    # type checking
    switch "$type" {
    "fqdn" {
        if {"$value" == ""} {
            set error FQDN
        }
        # no blanks allowed
        if {[string first " " $value] >= 0} {
            set error FQDN
        }
    }
    "ofqdn" {
        if {"$value" == ""} {
            set value [mag_msg NONE]
            set object [lreplace $object \
                $MS(value) $MS(value) $value]
        }
        # no blanks allowed
        if {[string first " " $value] >= 0} {
            set error FQDN
        }
    }
    "fromdom" {
        # no blanks allowed
        if {[string first " " $value] >= 0} {
            set error FQDN
        }
    }
    "intrange" {
        if {[catch {expr $value}] != 0} {
            set value "1"
            set error INTEGER
        }
        if {"$value" == ""} {
            set error NULL
            set value 1
        }
        set test [mag_trim_zero $value]
        if {"$test" != "$value"} {
            set value $test
            set arg $test
            set object [lreplace $object $MS(value) $MS(value) $value]
        }
        if {"[csubstr $value 0 1]" == "-"} {
            set test [csubstr $value 1 end]
        }
        if {[ctype digit $test] == 0} {
            set error INTEGER
        } else {
            set t1 [lindex $criteria 0]
            set t2 [lindex $criteria 1]
            if {$value < $t1 || $value > $t2} {
                set error INTEGER
            }
        }
    }
    "ointrange" {
        if {"$value" == ""} {
            set value [mag_msg NONE]
            set object [lreplace $object $MS(value) $MS(value) $value]
        }
        if {"$value" != "[mag_msg NONE]"} {
            if {[catch {expr $value}] != 0} {
                set value [lindex $criteria 0]
                set error INTEGER
            }
            set test [mag_trim_zero $value]
            if {"$test" != "$value"} {
                set value $test
                set arg $test
                set object [lreplace $object $MS(value) $MS(value) $value]
            }
            if {"[csubstr $value 0 1]" == "-"} {
                set test [csubstr $value 1 end]
            }
            if {[ctype digit $test] == 0} {
                set error INTEGER
            } else {
                set t1 [lindex $criteria 0]
                set t2 [lindex $criteria 1]
                if {$value < $t1 || $value > $t2} {
                    set error INTEGER
                }
            }
        }
    }
    "enum" {
        # check is one of the list
        if {"$value" == ""} {
            set error NULL
        } else {
            set error INVALID
            foreach i $criteria {
                if {"$i" == "$value"} {
                    set error ""
                    break
                }
            }
        }
    }
    "umask" {
        if {"$value" == ""} {
            set error NULL
            set value "01"
        }
        if {[ctype digit $value] == 0} {
            set error INVALID
        }
                if {[string first 8 $value] >= 0} {
            set error INVALID
        }
        if {[string first 9 $value] >= 0} {
            set error INVALID
        }
        if {"[cindex $value 0]" != "0"} {
            set value "0$value"
            set object [lreplace $object \
                $MS(value) $MS(value) $value]
        }
        if {"$error" == ""} {
            if {$value > 0777} {
                set error INVALID
            }
        }
    }
    "alias" {
        if {"$value" == ""} {
            set error NULL
        } else {
            # have to modify label
            set test [csubstr $value 0 4]
            if {"$test" == "nis:"} {
                set label [mag_msg MAP]
            } else {
                set label [mag_msg FILE]
            }
            set object [lreplace $object \
                $MS(label) $MS(label) $label]
        }
    }
    "rstring" {
        if {"$value" == ""} {
            set error NULL
        }
        # no blanks allowed
        if {[string first " " $value] >=0} {
            set error INVALID
        }
    }
    "string" {
    }
    "path" {
        if {"$value" == ""} {
            set error NULL
        }
        # no blanks allowed
        if {[string first " " $value] >=0} {
            set error INVALID
        }
        # warning if path does not exist
        if {"$error" == ""} {
            if {[mag_remote_file_exists $value] == 0} {
                VtUnLock
                mag_warn1 NOEXIST $value
                VtLock
            }
        }
    }
    "chpath" {
        # warn if path not exist, same as path
        if {"$value" == ""} {
            set error NULL
        }
        # no blanks allowed
        if {[string first " " $value] >=0} {
            set error INVALID
        }
        # warning if path does not exist
        if {"$error" == "" && "$value" != "SMTP"} {
            if {[mag_remote_file_exists $value] == 0} {
                VtUnLock
                mag_warn1 NOEXIST $value
                VtLock
            }
        }
    }
    "chtable" {
        if {"$value" == ""} {
            set error NULL
        }
        # no blanks allowed
        if {[string first " " $value] >=0} {
            set error INVALID
        }
        # warning if path does not exist
        if {"$error" == ""} {
            if {[mag_remote_file_exists $value] == 0} {
                VtUnLock
                mag_warn1 NOEXIST $value
                VtLock
            }
        }
    }
    "flags" {
        # no blanks allowed
        if {[string first " " $value] >=0} {
            set error INVALID
        }
    }
    "user" {
        # must be in list if not a number
        if {[ctype digit $value] == 0} {
            set users "[mag_msg DEFAULT] [mag_list_users]"
            if {[lsearch $users $value] == -1} {
                set error INVALID
            }
        }
    }
    "group" {
        # must be in list if not a number
        if {[ctype digit $value] == 0} {
            set groups "[mag_msg DEFAULT] [mag_list_groups]"
            if {[lsearch $groups $value] == -1} {
                set error INVALID
            }
        }
    }
    }
    switch $name {
    "ctable" {
        # validate channel table type
        set list [mag_table_enum]
        if {[lsearch $list $value] == -1} {
            VtUnLock
            mag_error1 INVALID $value
            VtLock
            return ""
        }
        # cannot switch to baduser if not last channel.
        set old [mag_table_to_internal [lindex $oldobject $MS(value)]]
        set new [mag_table_to_internal $value]
        if {"$old" != "baduser" && "$new" == "baduser"} {
            set chname [lindex $object $MS(chname)]
            set chlist [mai_ch_names_get]
            set chindex [lsearch $chlist $chname]
            set chlen [llength $chlist]
            set expect [expr $chlen - 1]
            # channel not last
            if {$chindex != $expect} {
                VtUnLock
                mag_error CH_NOT_LAST
                VtLock
                return ""
            }
            # now remove "mov" action from our channel object
            set chindex [mai_ch_find $index]
            set channel [lindex $mainscreen_db $chindex]
            set action [lindex $channel $MS(action)]
            set mov [lsearch $action mov]
            if {$mov >= 0} {
                set action [lreplace $action $mov $mov]
            }
            set channel [lreplace $channel \
                $MS(action) $MS(action) $action]
            set mainscreen_db [lreplace $mainscreen_db \
                $chindex $chindex $channel]
        }
        if {"$old" == "baduser" && "$new" != "baduser"} {
            # restore "mov" action to our channel object
            set chindex [mai_ch_find $index]
            set channel [lindex $mainscreen_db $chindex]
            set action [lindex $channel $MS(action)]
            set mov [lsearch $action mov]
            if {$mov == -1} {
                lappend action mov
            }
            set channel [lreplace $channel \
                $MS(action) $MS(action) $action]
            set mainscreen_db [lreplace $mainscreen_db \
                $chindex $chindex $channel]
        }
    }
    "cargs" {
        # channel program arguments cannot be null
        if {"$value" == ""} {
            set error NULL
        }
    }
    }
    if {"$error" != ""} {
        VtUnLock
        mag_error1 $error "$arg"
        VtLock
        return ""
    }
    return $object
}
proc \
mai_state { oldobject object index } \
{
    global mainscreen_db MS
    set type [lindex $object $MS(type)]
    set name [lindex $object $MS(name)]
    set value [lindex $object $MS(value)]
    set criteria [lindex $object $MS(criteria)]
    # Now do state changes where changing one property affects another.
    # This switch is on name, not type like the others in this file
    switch $name {
    "ctable" {
        set old [mag_table_to_internal [lindex $oldobject $MS(value)]]
        set new [mag_table_to_internal $value]
        # if switching to file type and filename is empty, default it.
        if {"$old" != "file" && "$new" == "file"} {
            set chindex [mai_ch_find $index]
            # find channel table file
            set ctindex [mai_prop_find $chindex cfile]
            set tmpobject [lindex $mainscreen_db $ctindex]
            set cfile [lindex $tmpobject $MS(value)]
            if {"$cfile" == ""} {
                set tmpnewobject [mai_prop_def $tmpobject]
                set tmpnewobject [mai_prop_set $tmpobject $tmpnewobject]
                set mainscreen_db [lreplace $mainscreen_db \
                    $ctindex $ctindex $tmpnewobject]
                # redraw line item
                set stop [expr $ctindex + 1]
                mag_display_mainlist $ctindex $stop -1
            }
        }
        # if switching to non-file type, blank out the filename.
        if {"$old" == "file" && "$new" != "file"} {
            set chindex [mai_ch_find $index]
            # find channel table file
            set ctindex [mai_prop_find $chindex cfile]
            set tmpobject [lindex $mainscreen_db $ctindex]
            set cfile [lindex $tmpobject $MS(value)]
            if {"$cfile" != ""} {
                set tmpnewobject [lreplace $tmpobject $MS(value) $MS(value) ""]
                set tmpnewobject [mai_prop_set $tmpobject $tmpnewobject]
                set mainscreen_db [lreplace $mainscreen_db \
                    $ctindex $ctindex $tmpnewobject]
                # redraw line item
                set stop [expr $ctindex + 1]
                mag_display_mainlist $ctindex $stop -1
            }
        }
    }
    "cuser" {
        # if user is changed to default, we must default the group too
        set old [lindex $oldobject $MS(value)]
        set new $value
        set default [mag_msg DEFAULT]
        if {"$old" != "$default" && "$new" == "$default"} {
            set chindex [mai_ch_find $index]
            # find channel table group
            set ctindex [mai_prop_find $chindex cgroup]
            set tmpobject [lindex $mainscreen_db $ctindex]
            set cgroup [lindex $tmpobject $MS(value)]
            if {"$cgroup" != "$default"} {
                set tmpnewobject [mai_prop_def $tmpobject]
                set tmpnewobject [mai_prop_set $tmpobject $tmpnewobject]
                set mainscreen_db [lreplace $mainscreen_db \
                    $ctindex $ctindex $tmpnewobject]
                # redraw line item
                set stop [expr $ctindex + 1]
                mag_display_mainlist $ctindex $stop -1
            }
        }
    }
    "cname" {
        # channel name must change all back links and folder name
        set calias $value
        set chname [mag_channel_to_internal $calias]
        # update channel container
        set chindex [mai_ch_find $index]
        set tmpobject [lindex $mainscreen_db $chindex]
        set tmpobject [lreplace $tmpobject \
            $MS(name) $MS(name) $chname]
        set tmpobject [lreplace $tmpobject \
            $MS(label) $MS(label) $calias]
        set mainscreen_db [lreplace $mainscreen_db \
            $chindex $chindex $tmpobject]
        # update all children
        set start [expr $chindex + 1]
        set length [llength $mainscreen_db]
        loop i $start $length {
            set tmpobject [lindex $mainscreen_db $i]
            set indent [lindex $tmpobject $MS(level)]
            if {$indent != 2} {
                break
            }
            set tmpobject [lreplace $tmpobject \
                $MS(chname) $MS(chname) $chname]
            set mainscreen_db [lreplace $mainscreen_db \
                $i $i $tmpobject]
        }
        # redraw channel container item
        set chindex [mai_ch_find $index]
        set stop [expr $chindex + 1]
        mag_display_mainlist $chindex $stop -1
    }
    "host" {
        # setting host to a non-default name and v.v. affects altnames
        # the back end takes care of this, all we do is close and
        # reopen altnames if it is open.
        set length [llength $mainscreen_db]
        loop i 0 $length {
            set item [lindex $mainscreen_db $i]
            if {"[lindex $item $MS(type)]" == "altname"} {
                break
            }
        }
        # have altname in item and it's index in i.
        set state [lindex $item $MS(state)]
        if {"$state" == "open"} {
            mai_collapse $i
            mai_expand $i
            # reselect hostname
            mag_display_mainlist $index $index $index
        }
    }
    }
}
proc \
mag_stand_edit { object file } \
{
    global app MS
    global UUX SLOCAL MULTIHOME
    global mag_stand_object mag_stand_form
    global mag_stand_toggle mag_stand_text mag_stand_combo
    global mag_stand_fdir mag_stand_fname mag_stand_outfile
    set type [lindex $object $MS(type)]
    set name [lindex $object $MS(name)]
    set label [lindex $object $MS(label)]
    set value [lindex $object $MS(value)]
    set criteria [lindex $object $MS(criteria)]
    set custom [lindex $object $MS(custom)]
    # globals for callbacks
    set mag_stand_object $object
    set mag_stand_outfile $file
    # init widget server
    set app [VtOpen mailchild "mailadmin"]
    mag_setcat SCO_MAIL_ADMIN
    # std dialog box
    set mag_stand_form [ \
        VtFormDialog $app.mailchild \
        -title [mag_msg TITLE_MOD] \
        -resizable FALSE \
        -ok -okCallback mag_stand_ok \
        -cancel -cancelCallback mag_stand_quit \
        -wmCloseCallback mag_stand_quit \
    ]
    set ok [VtGetValues $mag_stand_form -ok]
    # setup dialog box
    switch "$type" {
    "boolean" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_toggle [ \
            VtToggleButton $mag_stand_form.toggle \
            -label $label \
            -value [mag_bool_to_num $value] \
        ]
        set focus $mag_stand_toggle
    }
    "fqdn" {
        set parms ""
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -topSide $tmplabel \
            -columns 40 \
            -callback "mag_stand_jump $ok" \
        ]
        VtSetValues $mag_stand_text -value $value
        VtPushButton $mag_stand_form.browse \
            -leftSide $mag_stand_text \
            -topSide $tmplabel \
            -callback mag_stand_fqdn_browse \
            -label [mag_msg STR_SELECT]
        set focus $mag_stand_text
    }
    "ofqdn" {
        set parms ""
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -topSide $tmplabel \
            -columns 40 \
            -callback "mag_stand_jump $ok" \
        ]
        VtSetValues $mag_stand_text -value $value
        VtPushButton $mag_stand_form.browse \
            -leftSide $mag_stand_text \
            -topSide $tmplabel \
            -callback mag_stand_fqdn_browse \
            -label [mag_msg STR_SELECT]
        if {"$name" == "chost" && \
            "[lindex $object $MS(chname)]" == "badhost" } {
            set nonelabel [mag_msg STR_NONE_DELAY]
        } else {
            set nonelabel [mag_msg STR_NONE]
        }
        VtPushButton $mag_stand_form.btn \
            -topSide $mag_stand_text \
            -leftSide FORM -rightSide FORM \
            -label "$nonelabel" \
            -callback mag_stand_none
        set focus $mag_stand_text
    }
    "fromdom" {
        VtLabel $mag_stand_form.label -label $label
        set mag_stand_combo [ \
            VtComboBox $mag_stand_form.combo \
            -itemList $criteria \
            -leftSide FORM -rightSide FORM \
            -value $value \
            -callback "mag_stand_jump $ok" \
        ]
        set focus $mag_stand_combo
    }
    "intrange" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 10 \
            -callback "mag_stand_jump $ok" \
        ]
        set t1 [lindex $criteria 0]
        set t2 [lindex $criteria 1]
        VtLabel $mag_stand_form.range \
            -label "($t1-$t2)" \
            -leftSide $mag_stand_text \
            -topSide $tmplabel
        VtSetValues $mag_stand_text -value $value
        set focus $mag_stand_text
    }
    "ointrange" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 10 \
            -callback "mag_stand_jump $ok" \
        ]
        set t1 [lindex $criteria 0]
        set t2 [lindex $criteria 1]
        VtLabel $mag_stand_form.range \
            -label "($t1-$t2)" \
            -leftSide $mag_stand_text \
            -topSide $tmplabel
        VtSetValues $mag_stand_text -value $value
        VtPushButton $mag_stand_form.btn \
            -topSide $mag_stand_text \
            -leftSide FORM -rightSide FORM \
            -label [mag_msg STR_NONE] \
            -callback mag_stand_none
        set focus $mag_stand_text
    }
    "enum" {
        VtLabel $mag_stand_form.label -label $label
        set mag_stand_combo [ \
            VtComboBox $mag_stand_form.combo \
            -itemList $criteria \
            -leftSide FORM -rightSide FORM \
            -value $value \
            -callback "mag_stand_jump $ok" \
        ]
        if {"$name" == "flocation"} {
            # add custom folder location callback
            VtSetValues $mag_stand_combo \
                -valueChangedCallback mag_stand_custom
            # add custom folder location text widgets
            VtLabel $mag_stand_form.label1 \
                -label [mag_msg FOLDER_DIR]
            VtLabel $mag_stand_form.label2 \
                -label [mag_msg SHORT_FOLDER_DIR]
            set mag_stand_fdir [ \
                VtText $mag_stand_form.fdir \
                -columns 50 \
            ]
            VtLabel $mag_stand_form.label3 \
                -label [mag_msg FOLDER_NAME]
            VtLabel $mag_stand_form.label4 \
                -label [mag_msg SHORT_FOLDER_NAME]
            set mag_stand_fname [ \
                VtText $mag_stand_form.fname \
                -columns 50 \
            ]
            VtSetValues $mag_stand_fdir \
                -value [lindex $custom 0] \
                -callback "mag_stand_jump $mag_stand_fname"
            VtSetValues $mag_stand_fname \
                -value [lindex $custom 1] \
                -callback "mag_stand_jump $ok"
            mag_stand_custom cbs
        }
        set focus $mag_stand_combo
    }
    "umask" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 6 \
            -callback "mag_stand_jump $ok" \
        ]
        VtLabel $mag_stand_form.range \
            -label "(0-0777)" \
            -leftSide $mag_stand_text \
            -topSide $tmplabel
        VtSetValues $mag_stand_text -value $value
        set focus $mag_stand_text
    }
    "alias" {
        VtLabel $mag_stand_form.label -label [mag_msg ALIAS1]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 50 \
            -callback "mag_stand_jump $ok" \
        ]
        set tmp [VtLabel $mag_stand_form.label2 -label [mag_msg ALIAS2]]
        VtSetValues $mag_stand_text -value $value
        VtPushButton $mag_stand_form.btn \
            -topSide $tmp \
            -leftSide FORM -rightSide FORM \
            -label [mag_msg STR_EDIT_ALIAS] \
            -callback mag_stand_alias_edit
        set focus $mag_stand_text
    }
    "rstring" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 50 \
            -callback "mag_stand_jump $ok" \
        ]
        VtSetValues $mag_stand_text -value $value
        set focus $mag_stand_text
    }
    "string" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 50 \
            -callback "mag_stand_jump $ok" \
        ]
        VtSetValues $mag_stand_text -value $value
        set focus $mag_stand_text
    }
    "path" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 50 \
            -callback "mag_stand_jump $ok" \
        ]
        VtSetValues $mag_stand_text -value $value
        set focus $mag_stand_text
    }
    "chpath" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set programs [list $SLOCAL SMTP $UUX $MULTIHOME]
        set mag_stand_combo [ \
            VtComboBox $mag_stand_form.combo \
            -itemList $programs \
            -leftSide FORM -rightSide FORM \
            -value $value \
            -callback "mag_stand_jump $ok" \
        ]
        set focus $mag_stand_combo
    }
    "chtable" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 50 \
            -callback "mag_stand_jump $ok" \
        ]
        VtSetValues $mag_stand_text -value $value
        VtPushButton $mag_stand_form.btn \
            -topSide $mag_stand_text \
            -leftSide FORM -rightSide FORM \
            -label [mag_msg STR_EDIT_CTABLE] \
            -callback mag_stand_ctable_edit
        set focus $mag_stand_text
    }
    "domtable" {
        set ret [mag_query_qyn EDIT_DTABLE ""]
        if {"$ret" == "yes"} {
            mag_stand_dtable_edit
        }
        mag_stand_quit cbs
    }
    "flags" {
        set tmplabel [VtLabel $mag_stand_form.label -label $label]
        set mag_stand_text [ \
            VtText $mag_stand_form.text \
            -columns 40 \
            -callback "mag_stand_jump $ok" \
        ]
        VtPushButton $mag_stand_form.btn \
            -topSide $tmplabel \
            -leftSide $mag_stand_text -rightSide FORM \
            -label [mag_msg STR_SELECT] \
            -callback mag_stand_flags
        VtSetValues $mag_stand_text -value $value
        set focus $mag_stand_text
    }
    "user" {
        VtLabel $mag_stand_form.label -label $label
        set users "[mag_list_users]"
        set users [lsort $users]
        set users "[mag_msg DEFAULT] $users"
        set mag_stand_combo [ \
            VtComboBox $mag_stand_form.combo \
            -itemList $users \
            -leftSide FORM -rightSide FORM \
            -value $value \
            -callback "mag_stand_jump $ok" \
        ]
        set focus $mag_stand_combo
    }
    "group" {
        VtLabel $mag_stand_form.label -label $label
        set groups "[mag_list_groups]"
        set groups [lsort $groups]
        set groups "[mag_msg DEFAULT] $groups"
        set mag_stand_combo [ \
            VtComboBox $mag_stand_form.combo \
            -itemList $groups \
            -leftSide FORM -rightSide FORM \
            -value $value \
            -callback "mag_stand_jump $ok" \
        ]
        set focus $mag_stand_combo
    }
    "ruleset" {
        VtLabel $mag_stand_form.label -label $label
        set none [mag_msg NONE]
        switch $name {
        "crecip" {
            set suffix re
        }
        "chrecip" {
            set suffix rh
            set none [mag_msg RULEDEF]
        }
        "csender" {
            set suffix se
        }
        "chsender" {
            set suffix sh
            set none [mag_msg RULEDEF]
        }
        }
        set items [list \
            $none \
            ap822_$suffix \
            aplocal_$suffix \
            ap976_$suffix \
        ]
        set mag_stand_combo [ \
            VtComboBox $mag_stand_form.combo \
            -itemList $items \
            -leftSide FORM -rightSide FORM \
            -value $value \
            -callback "mag_stand_jump $ok" \
        ]
        set focus $mag_stand_combo
    }
    }
    VtShow $mag_stand_form
    VtSetFocus $focus
    VtMainLoop
}
proc \
mag_stand_ok { cbs } \
{
    global mag_stand_object MS
    global mag_stand_toggle mag_stand_text mag_stand_combo
    global mag_stand_fdir mag_stand_fname mag_stand_outfile
    set object $mag_stand_object
    set type [lindex $object $MS(type)]
    set name [lindex $object $MS(name)]
    # extract value and type check it if needed.
    switch "$type" {
    "boolean" {
        set value [VtGetValues $mag_stand_toggle -value]
        set value [mag_num_to_bool $value]
    }
    "fqdn" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "ofqdn" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "fromdom" {
        set value [VtGetValues $mag_stand_combo -value]
    }
    "intrange" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "ointrange" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "enum" {
        set value [VtGetValues $mag_stand_combo -value]
        if {"$name" == "flocation"} {
            set fdir [VtGetValues $mag_stand_fdir -value]
            set fname [VtGetValues $mag_stand_fname -value]
            set custom [list $fdir $fname]
            set object [lreplace $object $MS(custom) $MS(custom) $custom]
        }
    }
    "umask" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "alias" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "rstring" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "string" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "path" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "chpath" {
        set value [VtGetValues $mag_stand_combo -value]
    }
    "chtable" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "flags" {
        set value [VtGetValues $mag_stand_text -value]
    }
    "user" {
        set value [VtGetValues $mag_stand_combo -value]
    }
    "group" {
        set value [VtGetValues $mag_stand_combo -value]
    }
    "ruleset" {
        set value [VtGetValues $mag_stand_combo -value]
    }
    }
    set object [lreplace $object $MS(value) $MS(value) $value]
    # our return value is sent to outfile
    if {[catch {open $mag_stand_outfile w} fd] == 0} {
        puts $fd $object
        close $fd
    }
    VtClose
    exit 0
}
proc \
mag_stand_quit { cbs } \
{
    VtClose
    exit 0
}
proc \
mag_stand_jump { widget cbs } \
{
    VtSetFocus $widget
}
proc \
mag_stand_fqdn_browse { cbs } \
{
    global mag_stand_object MS
    global mag_stand_form
    keylset parms parent $mag_stand_form
    keylset parms instance abc
    keylset parms labeltext [lindex $mag_stand_object $MS(label)]
    keylset parms buttontext [mag_msg STR_SELECT]
    keylset parms userproc mag_stand_fqdn_browse_done
    SaSelectHostDialog $parms $cbs
}
proc \
mag_stand_fqdn_browse_done { cbs } \
{
    global mag_stand_text mag_stand_form
    set value [SaSelectHostGetSelection abc]
    VtSetValues $mag_stand_text -value $value
    set ok [VtGetValues $mag_stand_form -ok]
    mag_stand_jump $ok $cbs
}
proc \
mag_stand_none { cbs } \
{
    global mag_stand_text
    VtSetValues $mag_stand_text -value [mag_msg NONE]
}
proc \
mag_stand_alias_edit { cbs } \
{
    global mag_stand_text
    global MS app
    global ALIAS_EDITOR
    set value [VtGetValues $mag_stand_text -value]
    set test [csubstr $value 0 4]
    if {"$test" == "nis:"} {
        VtErrorDialog $app.err -block -ok -message [mag_err AFILE_ONLY]
        return
    }
    mag_stand_call_editor $ALIAS_EDITOR $value
}
proc \
mag_stand_ctable_edit { cbs } \
{
    global mag_stand_object MS app
    global CTABLE_EDITOR
    set object $mag_stand_object
    set value [lindex $object $MS(value)]
    # call channel table editor
    mag_stand_call_editor $CTABLE_EDITOR $value
}
proc \
mag_stand_dtable_edit {} \
{
    global mag_stand_object MS app
    global DTABLE_EDITOR
    set object $mag_stand_object
    set value [lindex $object $MS(value)]
    mag_stand_call_editor $DTABLE_EDITOR $value
}
proc \
mag_stand_custom { cbs } \
{
    global mag_stand_object
    global mag_stand_combo
    global mag_stand_fdir mag_stand_fname mag_stand_form
    global MAILSPOOL INBOXNAME
    set value [VtGetValues $mag_stand_combo -value]
    # update sensitivity and fields
    if {"$value" != "[mag_msg FOLDER_CUSTOM]"} {
        VtSetValues $mag_stand_fdir -sensitive 0
        VtSetValues $mag_stand_fname -sensitive 0
        if {"$value" == "[mag_msg FOLDER_SYSTEM]"} {
            VtSetValues $mag_stand_fdir -value $MAILSPOOL
            VtSetValues $mag_stand_fname -value ""
        } else {
            VtSetValues $mag_stand_fdir -value ""
            VtSetValues $mag_stand_fname -value "$INBOXNAME"
        }
        set ok [VtGetValues $mag_stand_form -ok]
        VtSetValues $mag_stand_combo \
            -callback "mag_stand_jump $ok"
    } else {
        VtSetValues $mag_stand_fdir -sensitive 1
        VtSetValues $mag_stand_fname -sensitive 1
        VtSetValues $mag_stand_combo \
            -callback "mag_stand_jump $mag_stand_fdir"
    }
}
proc \
mag_stand_call_editor { editor file } \
{
    global PID mag_host_name mag_local_host
    VtLock
    # first strip off class if there
    set class ""
    set fname $file
    set pos [string first ":" $file]
    if {$pos >= 0} {
        set class [csubstr $file 0 $pos]
        set start [expr $pos + 1]
        set fname [csubstr $file $start end]
        set class [string trim $class]
        set fname [string trim $fname]
        if {"$class" != "dbm" && "$class" != "hash" &&
            "$class" != "btree" && "$class" != "implicit" } {
            VtUnLock
            mag_error1 INVALID_CLASS $class
            return
        }
    }
    # tmp file names
    set fnamedb "$fname.db"
    set base [exec basename $editor]
    set tmp1 "/tmp/$base.$PID"
    set tmp1db "/tmp/$base.$PID.db"
    set tmp2 "/tmp/$base.1.$PID"
    set tmp2db "/tmp/$base.1.$PID.db"
    # copy in files
    system "rm -fr $tmp1 $tmp1db $tmp2 $tmp2db"
    set ret [mag_remote_copyin $fname $tmp1]
    set ret [mag_remote_copyin $fname $tmp2]
    set ret [mag_remote_copyin $fnamedb $tmp1db]
    set host ""
    if {"$mag_host_name" != "$mag_local_host"} {
        set host "-h $mag_host_name"
    }
    if {"$class" != ""} {
        set cmd "$editor $host -f $class:$tmp2"
    } else {
        set cmd "$editor $host -f $tmp2"
    }
    VtControl -suspend
    catch {system "$cmd"} ret
    VtControl -resume
    if {$ret != 0} {
        VtUnLock
        mag_error1 EXEC $editor
        system "rm -f $tmp1 $tmp1db $tmp2 $tmp2db"
        return
    }
    # copy back main file
    set ret ok
    if {[file exists $tmp2] == 1} {
        if {[file exists $tmp1] == 1} {
            catch {system "cmp $tmp2 $tmp1 > /dev/null 2>&1"} tmp
            # files are different
            if {$tmp == 1} {
                set ret [mag_remote_copyout $tmp2 $fname]
            }
        } else {
            set ret [mag_remote_copyout $tmp2 $fname]
        }
    }
    if {"$ret" != "ok"} {
        VtUnLock
        mag_error1 COPY_BACK $fname
        system "rm -f $tmp1 $tmp1db $tmp2 $tmp2db"
        return
    }
    # copy back db file
    set ret ok
    if {[file exists $tmp2db] == 1} {
        if {[file exists $tmp1db] == 1} {
            catch {system "cmp $tmp2db $tmp1db > /dev/null 2>&1"} tmp
            # files are different
            if {$tmp == 1} {
                set ret [mag_remote_copyout $tmp2db $fnamedb]
            }
        } else {
            set ret [mag_remote_copyout $tmp2db $fnamedb]
        }
    }
    if {"$ret" != "ok"} {
        VtUnLock
        mag_error1 COPY_BACK $fnamedb
        system "rm -f $tmp1 $tmp1db $tmp2 $tmp2db"
        return
    }
    system "rm -f $tmp1 $tmp1db $tmp2 $tmp2db"
    VtUnLock
}
proc \
mag_stand_flags { cbs } \
{
    global app RESPATH MS
    global mag_stand_text
    global mag_stand_text mag_two_form mag_two_list1 mag_two_list2
    # get flags from text widget
    set value [VtGetValues $mag_stand_text -value]
    set isCharm [VtInfo -charm]
    set mag_two_form [ \
        VtFormDialog $app.mailchild.flags \
        -title [mag_msg CH_FLAGS] \
        -ok -okCallback mag_stand_flags_ok \
        -wmCloseCallback mag_stand_flags_quit \
    ]
    VtLabel $mag_two_form.label1 -label [mag_msg FLAGS_LIST1]
    set lists [mag_stand_flags_to_lists $value]
    set fieldlist1 [lindex $lists 0]
    set fieldlist2 [lindex $lists 1]
    # get longest entry
    set max [mag_stand_two_max $fieldlist1 $fieldlist2]
    set formatlist [list [list STRING 3] [list STRING $max]]
    set mag_two_list1 [ \
        VtDrawnList $mag_two_form.list1 \
        -leftSide FORM -rightSide FORM \
        -columns 75 \
        -rows 8 \
        -selection MULTIPLE \
        -formatList $formatlist \
        -recordList $fieldlist1 \
        -horizontalScrollBar 1 \
    ]
    set tmp [VtLabel $mag_two_form.label2 -label [mag_msg FLAGS_LIST2]]
    set tmp1 [VtPushButton $mag_two_form.btndn \
        -leftSide 44 \
        -topSide $mag_two_list1 \
        -callback mag_stand_two_dn \
    ]
    set tmp2 [VtPushButton $mag_two_form.btnup \
        -leftSide $tmp1 \
        -topSide $mag_two_list1 \
        -callback mag_stand_two_up]
    if {$isCharm} {
        VtSetValues $tmp1 \
            -label [mag_msg MENU_DN] \
            -labelCenter
        VtSetValues $tmp2 \
            -label [mag_msg MENU_UP] \
            -labelCenter
    } else {
        VtSetValues $tmp1 \
            -pixmap $RESPATH/next.px
        VtSetValues $tmp2 \
            -pixmap $RESPATH/prev.px
    }
    set mag_two_list2 [ \
        VtDrawnList $mag_two_form.list2 \
        -leftSide FORM -rightSide FORM \
        -bottomSide FORM \
        -columns 75 \
        -rows 7 \
        -selection MULTIPLE \
        -formatList $formatlist \
        -recordList $fieldlist2 \
        -horizontalScrollBar 1 \
    ]
    mag_stand_two_drawnlist_bug $mag_two_list1
    mag_stand_two_drawnlist_bug $mag_two_list2
    VtShow $mag_two_form
}
proc \
mag_stand_flags_ok { cbs } \
{
    global mag_stand_text
    global mag_two_list1 mag_two_list2 mag_two_form
    # get flags from drawn list
    set items [VtDrawnListGetItem $mag_two_list2 -all]
    set flags ""
    foreach item $items {
        set flag [lindex $item 0]
        set flags "$flags$flag"
    }
    # put value back into text widget
    VtSetValues $mag_stand_text -value $flags
    VtDestroy $mag_two_form
}
proc \
mag_stand_flags_quit { cbs } \
{
    global mag_two_form
    VtDestroy $mag_two_form
}
proc \
mag_stand_flags_to_lists { flags } \
{
    # build master list of characters and description strings
    set allflags "aAbcCdDeEfFghIjkKlLmMnopPqrsSuUwxX035789:|/@"
    set regularflags aAbcCdDeEfFghIjkKlLmMnopPqrsSuUwxX035789
    set specialflags [list ": COLON" "| PIPE" "/ SLASH" "@ AT"]
    set length [clength $regularflags]
    set list1 ""
    set list2 ""
    # regular flags
    loop i 0 $length {
        set flag [cindex $regularflags $i]
        set which [string first $flag $flags]
        eval "set mname F_$flag"
        set msg [mag_msg $mname]
        set item [list $flag $msg]
        if {$which < 0} {
            lappend list1 $item
        } else {
            lappend list2 $item
        }
    }
    # special flags, characters that aren't valid in a msg cat name
    foreach i $specialflags {
        set flag [lindex $i 0]
        set name [lindex $i 1]
        set which [string first $flag $flags]
        eval "set mname F_$name"
        set msg [mag_msg $mname]
        set item [list $flag $msg]
        if {$which < 0} {
            lappend list1 $item
        } else {
            lappend list2 $item
        }
    }
    # now check for unknown flags
    set length [clength $flags]
    loop i 0 $length {
        set flag [cindex $flags $i]
        set found [string first $flag $allflags]
        if {$found >= 0} {
            continue
        }
        set item [list $flag [mag_msg F_UNKNOWN]]
        lappend list2 $item
    }
    set list1 [lsort $list1]
    set list2 [lsort $list2]
    return [list $list1 $list2]
}
proc \
mag_stand_two_up { cbs } \
{
    global mag_two_list1 mag_two_list2
    set newitems [VtDrawnListGetSelectedItem $mag_two_list2 -byRecordList]
    if {"$newitems" == ""} {
        return
    }
    set positions [VtDrawnListGetSelectedItem $mag_two_list2 -byPositionList]
    VtDrawnListDeleteItem $mag_two_list2 -positionList $positions
    set items [VtDrawnListGetItem $mag_two_list1 -all]
    # merge two lists
    set list "$items $newitems"
    set list [lsort $list]
    VtDrawnListDeleteItem $mag_two_list1 -all
    VtDrawnListAddItem $mag_two_list1 -recordList $list
    # now select the items that were moved so that undo is possible
    VtDrawnListDeselectItem $mag_two_list1 -all
    set positionlist ""
    foreach item $newitems {
        set pos [lsearch $list $item]
        set pos [expr $pos + 1]
        lappend positionlist $pos
    }
    VtDrawnListSelectItem $mag_two_list1 -positionList $positionlist
    mag_stand_two_drawnlist_bug $mag_two_list1
}
proc \
mag_stand_two_dn { cbs } \
{
    global mag_two_list1 mag_two_list2
    set newitems [VtDrawnListGetSelectedItem $mag_two_list1 -byRecordList]
    if {"$newitems" == ""} {
        return
    }
    set positions [VtDrawnListGetSelectedItem $mag_two_list1 -byPositionList]
    VtDrawnListDeleteItem $mag_two_list1 -positionList $positions
    set items [VtDrawnListGetItem $mag_two_list2 -all]
    # merge two lists
    set list "$items $newitems"
    set list [lsort $list]
    VtDrawnListDeleteItem $mag_two_list2 -all
    VtDrawnListAddItem $mag_two_list2 -recordList $list
    # now select the items that were moved so that undo is possible
    VtDrawnListDeselectItem $mag_two_list2 -all
    set positionlist ""
    foreach item $newitems {
        set pos [lsearch $list $item]
        set pos [expr $pos + 1]
        lappend positionlist $pos
    }
    VtDrawnListSelectItem $mag_two_list2 -positionList $positionlist
    mag_stand_two_drawnlist_bug $mag_two_list2
}
proc \
mag_stand_two_max { l1 l2 } \
{
    set max 0
    foreach item $l1 {
        set str [lindex $item 1]
        set len [clength $item]
        if {$max < $len} {
            set max $len
        }
    }
    foreach item $l2 {
        set str [lindex $item 1]
        set len [clength $item]
        if {$max < $len} {
            set max $len
        }
    }
    return $max
}
proc \
mag_stand_two_drawnlist_bug { widget } \
{
    # add and delete a dummy (blank) item
    set list [list "dum" "dum"]
    VtDrawnListAddItem $widget -fieldList $list
    VtDrawnListDeleteItem $widget -field 0 "dum"
}
proc \
mao_badhost {} \
{
    mai_badchan badhost
}
proc \
mao_baduser {} \
{
    mai_badchan baduser
}
proc \
mai_badchan { badchan } \
{
    global mainscreen_db MS main_list DIRTY
    # find channels container
    set length [llength $mainscreen_db]
    loop i 0 $length {
        set channels [lindex $mainscreen_db $i]
        set type [lindex $channels $MS(type)]
        if {"$type" == "channels"} {
            break
        }
    }
    # have channels container
    set chs_index $i
    set chs_state [lindex $channels $MS(state)]
    if {"$chs_state" == "open"} {
        mai_collapse $chs_index
    }
    # setup for search
    set chans [mai_ch_names_get]
    set found [lsearch $chans $badchan]
    # check that baduser channel does not already exist under another name.
    # We always need to know this for channel ordering later as
    # the baduser channel must always go last.
    set baduserfound -1
    set last [llength $chans]
    set badalias $badchan
    if {$last > 0} {
        set last [expr $last - 1]
        set lastname [lindex $chans $last]
        set lasttype [ma_ch_table_type_get $lastname]
        # found it
        if {"$lasttype" == "baduser"} {
            set baduserfound $last
            if {"$badchan" == "baduser"} {
                set found $last
                set badalias $lastname
            }
        }
    }
    # create channel if needed
    if {$found == -1} {
        set ret [ma_ch_create $badchan]
        ma_ch_equate_set $badchan P "\[IPC\]"
        if {"$badchan" == "badhost"} {
            ma_ch_table_type_set $badchan remote
        }
        if {"$badchan" == "baduser"} {
            ma_ch_table_type_set $badchan baduser
        }
        # have channel name, need to get channel object
        set children [mai_get_children $channels]
        foreach child $children {
            # default for our new channel
            set tmpname [lindex $child $MS(name)]
            if {"$tmpname" != "$badchan"} {
                continue
            }
            set tmpchildren [mai_get_children $child]
            foreach tmpchild $tmpchildren {
                set tmplist [mai_prop_def $tmpchild]
                mai_prop_set $tmpchild $tmplist
            }
            break
        }
        # now set ordering
        mai_channel_order_set $badchan
    }
    # now expand the channels container and $badchan channel.
    # and select the host field and call mai_modify on it.
    mai_expand $chs_index
    # looking for badalias now
    set length [llength $mainscreen_db]
    loop i 0 $length {
        set channel [lindex $mainscreen_db $i]
        set type [lindex $channel $MS(type)]
        if {"$type" != "channel"} {
            continue
        }
        set name [lindex $channel $MS(name)]
        if {"$name" == "$badalias"} {
            set badchanindex $i
            break
        }
    }
    # have our $badchan index, find host field
    mai_expand $badchanindex
    set length [llength $mainscreen_db]
    loop i $badchanindex $length {
        set prop [lindex $mainscreen_db $i]
        set class [lindex $prop $MS(class)]
        if {"$class" != "property"} {
            continue
        }
        set name [lindex $prop $MS(name)]
        if {"$name" == "chost"} {
            set hostindex $i
            break
        }
    }
    # have our host index, select in onscreen
    mag_display_mainlist $hostindex $hostindex $hostindex
    # now scroll if necessary to get selected item on screen
    set rows [VtGetValues $main_list -rows]
    set pos [VtGetValues $main_list -topItemPosition]
    set spos [expr $hostindex - $pos + 2]
    # if offscreen then fix up so host is last line on screen
    if {$spos >= $rows || $spos < 0} {
        set mpos [expr $hostindex - $rows + 2]
        VtSetValues $main_list -topItemPosition $mpos
    }
    # call mai_modify
    set modret [mai_modify $hostindex]
    # get host property's value:
    #       - if NONE, and this is baduser channel then we must always
    #         delete this channel
    #       - if this is badhost channel, host can be either NONE or
    #         a hostname-- so we delete only if the user had pressed
    #         Cancel, and the channel did not already exist!
    set object [lindex $mainscreen_db $hostindex]
    set value [lindex $object $MS(value)]
    if {"$badchan" == "baduser" && "$value" == "[mag_msg NONE]" || \
        "$badchan" == "badhost" && "$modret" == "no" && $found == -1} {
        # select our $badchan container
        mao_delete $badchanindex
    }
    if {"$badchan" == "badhost" && "$modret" == "yes"} {
        set DIRTY 1
    }
}
proc \
mao_mhome {} \
{
    global mainscreen_db MS main_list MULTIHOME MDOMAINDB DIRTY
    # find channels container
    set length [llength $mainscreen_db]
    loop i 0 $length {
        set channels [lindex $mainscreen_db $i]
        set type [lindex $channels $MS(type)]
        if {"$type" == "channels"} {
            break
        }
    }
    # have channels container
    set chs_index $i
    set chs_state [lindex $channels $MS(state)]
    if {"$chs_state" == "open"} {
        mai_collapse $chs_index
    }
    # setup for search
    set chans [mai_ch_names_get]
    # check if a multihome channel exists, we depend on the name
    set mhomefound 0
    set mhomeindex [lsearch -exact $chans multihome]
    if {$mhomeindex >= 0} {
        set mhomefound 1
    }
    if {$mhomefound == 0} {
        # create multihome channel
        set ret [ma_ch_create multihome]
        ma_ch_equate_set multihome P $MULTIHOME
        ma_ch_table_type_set multihome file
        set children [mai_get_children $channels]
        foreach child $children {
            # default for our new channel
            set tmpname [lindex $child $MS(name)]
            if {"$tmpname" != "multihome"} {
                continue
            }
            set tmpchildren [mai_get_children $child]
            foreach tmpchild $tmpchildren {
                set tmplist [mai_prop_def $tmpchild]
                mai_prop_set $tmpchild $tmplist
            }
            break
        }
        ma_ch_table_file_set multihome $MDOMAINDB
        # set the V macro-- check_rcpt depends upon this to
        # know whether virtual domains map exists, and it should
        # check hosts in the map
        ma_multihome_macro_set 1
        # now set ordering
        ma_ch_sequence_set multihome 0
        set order 1
        foreach i $chans {
            ma_ch_sequence_set $i $order
            set order [expr $order + 1]
        }
    } else {
        # delete multihome channel
        set order 0
        foreach i $chans {
            if {"$i" == "multihome"} {
                ma_ch_delete multihome
                continue
            }
            ma_ch_sequence_set $i $order
            set order [expr $order + 1]
        }
        # unset the V macro-- check_rcpt depends upon this to
        # know whether virtual domains map exists and it should
        # check hosts in the map
        ma_multihome_macro_set 0
    }
    # now expand the channels container
    mai_expand $chs_index
    # now scroll if necessary to make all channels visible
    set rows [VtGetValues $main_list -rows]
    set pos [VtGetValues $main_list -topItemPosition]
    set last [llength $mainscreen_db]
    set spos [expr $last - $pos + 2]
    # if offscreen then fix up so last channel is last line on screen
    if {$spos >= $rows || $spos < 0} {
        set mpos [expr $last - $rows + 2]
        VtSetValues $main_list -topItemPosition $mpos
    }
    set DIRTY 1
}
proc \
mao_uucp {} \
{
    global mainscreen_db MS main_list UUX UUCPDB DIRTY
    # find channels container
    set length [llength $mainscreen_db]
    loop i 0 $length {
        set channels [lindex $mainscreen_db $i]
        set type [lindex $channels $MS(type)]
        if {"$type" == "channels"} {
            break
        }
    }
    # have channels container
    set chs_index $i
    set chs_state [lindex $channels $MS(state)]
    if {"$chs_state" == "open"} {
        mai_collapse $chs_index
    }
    # setup for search
    set chans [mai_ch_names_get]
    # check if a UUCP channel exists, we depend on the name
    set uucpfound 0
    set uucpindex [lsearch -exact $chans UUCP]
    if {$uucpindex >= 0} {
        set uucpfound 1
    }
    if {$uucpfound == 0} {
        # create UUCP channel
        set ret [ma_ch_create UUCP]
        ma_ch_equate_set UUCP P $UUX
        ma_ch_table_type_set UUCP UUCP
        set children [mai_get_children $channels]
        foreach child $children {
            # default for our new channel
            set tmpname [lindex $child $MS(name)]
            if {"$tmpname" != "UUCP"} {
                continue
            }
            set tmpchildren [mai_get_children $child]
            foreach tmpchild $tmpchildren {
                set tmplist [mai_prop_def $tmpchild]
                mai_prop_set $tmpchild $tmplist
            }
            break
        }
        # now set ordering
        ma_ch_sequence_set UUCP 0
        set order 1
        foreach i $chans {
            ma_ch_sequence_set $i $order
            set order [expr $order + 1]
        }
    } else {
        # delete UUCP channel
        set order 0
        foreach i $chans {
            if {"$i" == "UUCP"} {
                ma_ch_delete UUCP
                continue
            }
            ma_ch_sequence_set $i $order
            set order [expr $order + 1]
        }
    }
    # now expand the channels container
    mai_expand $chs_index
    # now scroll if necessary to make all channels visible
    set rows [VtGetValues $main_list -rows]
    set pos [VtGetValues $main_list -topItemPosition]
    set last [llength $mainscreen_db]
    set spos [expr $last - $pos + 2]
    # if offscreen then fix up so last channel is last line on screen
    if {$spos >= $rows || $spos < 0} {
        set mpos [expr $last - $rows + 2]
        VtSetValues $main_list -topItemPosition $mpos
    }
    set DIRTY 1
}
proc \
mag_channel_create { index } \
{
    global mainscreen_db MS MAILTABLE
    # initial values
    set name [mag_msg NEW]
    set program /etc/mail/$name
    set table [mag_table_to_external file]
    set done no
    while {"$done" == "no"} {
        # call channel dialog first to get new channel data
        set list [list $name $program $table]
        set list [mai_channel_dialog $list]
        # user hit cancel
        if {"$list" == ""} {
            return
        }
        # validate new values
        set name [lindex $list 0]
        set program [lindex $list 1]
        set table [lindex $list 2]
        # channel name cannot conflict
        set list [ma_ch_names_get]
        if {[lsearch $list $name] >= 0} {
            VtUnLock
            mag_error CONFLICT
            VtLock
            continue
        }
        # program name must be entered
        if {"$program" == ""} {
            VtUnLock
            mag_error NULL
            VtLock
            continue
        }
        # no blanks allowed
        if {[string first " " $program] >=0} {
            VtUnLock
            mag_error1 INVALID $program
            VtLock
            continue
        }
        # program name should exist
        if {"$program" != "SMTP"} {
            if {[mag_remote_file_exists $program] == 0} {
                VtUnLock
                set ret [mag_query_qyn NOEXIST_IGNORE $program]
                VtLock
                if {"$ret" == "no"} {
                    continue
                }
            }
        }
        # table type must be one of several enumerated values.
        set list [mag_table_enum]
        if {[lsearch $list $table] == -1} {
            VtUnLock
            mag_error1 INVALID_TABLE $table
            VtLock
            continue
        }
        # have picked a set of valid values, now create the channel
        set ret [ma_ch_create $name]
        switch $ret {
        "conflict" {
            VtUnLock
            mag_error CONFLICT
            VtLock
            continue
        }
        "badname" {
            VtUnLock
            mag_error1 INVALID_NAME $name
            VtLock
            continue
        }
        }
        # everything appears ok
        break
    }
    # finish off channel parameters
    ma_ch_equate_set $name P $program
    ma_ch_table_type_set $name [mag_table_to_internal $table]
    # set ordering, add to end, or next to end if baduser is last, we could
    # be baduser as well.  Only one baduser is allowed.
    set ret [mai_channel_order_set $name]
    if {"$ret" != "ok"} {
        ma_ch_delete $name
        # error
        VtUnLock
        mag_error BADUSER_ONLY
        VtLock
        return
    }
    # channel now exists in the back-end, we have to draw it onscreen.
    # collapse onscreen channels container
    mai_collapse $index
    # expand back again, this adds the new channel onscreen.
    mai_expand $index
    # now find the new channel.
    set start [expr $index + 1]
    set stop [llength $mainscreen_db]
    loop i $start $stop {
        set channel [lindex $mainscreen_db $i]
        set tmpname [lindex $channel $MS(name)]
        if {"$name" == "$tmpname"} {
            set found $i
            break
        }
    }
    # set all values in the channel to default values
    mao_default $found no
    # select the new channel
    mag_display_mainlist $found $found $found
    # expand the new channel
    mai_expand $found
}
proc \
mai_channel_dialog { list } \
{
    global ME PID
    # file is used to pass results to preserve stdout for child process.
    set file "/tmp/mag.PID"
    system "rm -f $file"
    VtControl -suspend
    set escape [mag_escape $list]
    system "$ME -mag_stand_channel \"$escape\" $file"
    VtControl -resume
    if {[file exists $file] == 1} {
        set result [exec cat $file]
        system "rm -f $file"
    } else {
        set result ""
    }
    return $result
}
proc \
mag_stand_channel { list file } \
{
    global app MS SLOCAL UUX MULTIHOME
    global mag_stand_name mag_stand_program mag_stand_table
    global mag_stand_outfile
    set app [VtOpen mailchild "mailadmin"]
    mag_setcat SCO_MAIL_ADMIN
    set name [lindex $list 0]
    set program [lindex $list 1]
    set table [lindex $list 2]
    set mag_stand_outfile $file
    # std dialog box.
    set mag_stand_form [ \
        VtFormDialog $app.mailchild \
        -title [mag_msg NEW_CHANNEL] \
        -resizable FALSE \
        -ok -okCallback mag_stand_channel_ok \
        -cancel -cancelCallback mag_stand_channel_quit \
        -wmCloseCallback mag_stand_channel_quit
    ]
    VtLabel $mag_stand_form.label1 -label [mag_msg CH_NAME]
    set mag_stand_name [ \
        VtText $mag_stand_form.name \
        -columns 50 \
        -value $name \
    ]
    VtLabel $mag_stand_form.label2 -label [mag_msg CH_PROGRAM]
    set programs [list $SLOCAL SMTP $UUX $MULTIHOME]
    set mag_stand_program [ \
        VtComboBox $mag_stand_form.program \
        -itemList $programs \
        -leftSide FORM -rightSide FORM \
        -value $program \
    ]
    VtLabel $mag_stand_form.label3 -label [mag_msg CH_TABLE]
    set enum [mag_table_enum]
    set mag_stand_table [ \
        VtComboBox $mag_stand_form.table \
        -itemList $enum \
        -leftSide FORM -rightSide FORM \
        -value $table \
    ]
    VtSetValues $mag_stand_name \
        -callback "mag_stand_jump $mag_stand_program"
    VtSetValues $mag_stand_program \
        -callback "mag_stand_jump $mag_stand_table"
    VtSetValues $mag_stand_table \
        -callback "mag_stand_jump [VtGetValues $mag_stand_form -ok]"
    VtShow $mag_stand_form
    VtSetFocus $mag_stand_name
    VtMainLoop
}
proc \
mag_stand_channel_ok { cbs } \
{
    global mag_stand_name mag_stand_program mag_stand_table
    global mag_stand_outfile
    set name [VtGetValues $mag_stand_name -value]
    set program [VtGetValues $mag_stand_program -value]
    set table [VtGetValues $mag_stand_table -value]
    set list [list $name $program $table]
    # our return value is sent to outfile
    if {[catch {open $mag_stand_outfile w} fd] == 0} {
        puts $fd $list
        close $fd
    }
    VtClose
    exit 0
}
proc \
mag_stand_channel_quit { cbs } \
{
    VtClose
    exit 0
}
proc \
mai_channel_order_set { name } \
{
    # find out if any other bad user channels
    set names [mai_ch_names_get]
    set found ""
    foreach channel $names {
        if {"$channel" == "$name"} {
            continue
        }
        set type [ma_ch_table_type_get $channel]
        if {"$type" == "baduser"} {
            set found $channel
            break
        }
    }
    # find out if we are baduser
    set type [ma_ch_table_type_get $name]
    if {"$type" == "baduser" && "$found" != ""} {
        # there can only be one baduser channel
        if {"$found" != ""} {
            return fail
        }
    }
    set len [llength $names]
    # subtract ourself off
    set len [expr $len - 1]
    set prev [expr $len - 1]
    if {"$found" == ""} {
        # add to end of list
        ma_ch_sequence_set $name $len
    } else {
        # add in front of bad user channel
        ma_ch_sequence_set $name $prev
        ma_ch_sequence_set $found $len
    }
    return ok
}
proc \
mag_open_host {} \
{
    global mag_host_name mag_host_label mag_host_resolv outerMainForm
    global mainscreen_db
    # first save any previous changes, but keep open for cancel.
    set ret [mag_all_put]
    switch $ret {
    "ok" {
    }
    "fail" {
        return
    }
    "cancel" {
        return
    }
    }
    # put up open host dialog and get result
    set newhost [mag_open_host_dialog]
    if {"$newhost" == ""} {
        return
    }
    # get full name of remote machine
    set newhost [mag_host_resolv $newhost]
    # save old host name for backout
    set oldhost $mag_host_name
    # check if new host there
    set ret [mag_host_check $newhost]
    if {"$ret" != "ok"} {
        VtUnLock
        mag_error1 BADHOST $newhost
        VtLock
        return
    }
    # set new host name
    set mag_host_name $newhost
    set ret [mag_cf_get]
    if {"$ret" == "no"} {
        mag_host_backout $oldhost
        return
    }
    if {"$ret" == "fail"} {
        mag_host_backout $oldhost
        return
    }
    set ret [mag_ms1_get]
    if {"$ret" == "no"} {
        mag_host_backout $oldhost
        return
    }
    if {"$ret" == "fail"} {
        mag_host_backout $oldhost
        return
    }
    VtSetValues $outerMainForm -title [mag_msg1 WIN_TITLE \
        [mag_short_name_default]]
    VtSetValues $mag_host_label -label [mag_msg1 TITLE $mag_host_name]
    # clear and redraw main list
    mag_delete_mainlist -1 [llength $mainscreen_db]
        mao_init
        mag_insert_mainlist -1 [llength $mainscreen_db]
        mag_display_mainlist 0 1 0
}
proc \
mag_host_backout { oldhost } \
{
    global mag_host_name mag_host_label DIRTY
    VtUnLock
    set ret [mag_query_qyn GO_BACK $oldhost]
    VtLock
    if {"$ret" != "yes"} {
        quit
    }
    set mag_host_name $oldhost
    set DIRTY 0
    set ret [mag_cf_get]
    if {"$ret" == "no"} {
        quit
    }
    if {"$ret" == "fail"} {
        quit
    }
    set ret [mag_ms1_get]
    if {"$ret" == "no"} {
        quit
    }
    if {"$ret" == "fail"} {
        quit
    }
}
proc \
mag_open_host_dialog {} \
{
    global ME PID
    # file is used to pass results to preserve stdout for child process.
    set file "/tmp/mag.$PID"
    system "rm -f $file"
    VtControl -suspend
    system "$ME -mag_stand_host $file"
    VtControl -resume
    if {[file exists $file] == 1} {
        set result [exec cat $file]
        system "rm -f $file"
    } else {
        set result ""
    }
    return $result
}
proc \
mag_stand_host { file } \
{
    global app
    global mag_stand_text mag_stand_outfile mag_stand_form
    # globals for callbacks
    set mag_stand_outfile $file
    # init widget server
    set app [VtOpen mailchild "mailadmin"]
    mag_setcat SCO_MAIL_ADMIN
    # std dialog box.
    set mag_stand_form [ \
        VtFormDialog $app.mailchild \
        -title [mag_msg TITLE_OPEN] \
        -resizable FALSE \
        -ok -okCallback mag_stand_host_ok \
        -cancel -cancelCallback mag_stand_open_quit \
        -wmCloseCallback mag_stand_open_quit \
    ]
    set mag_stand_text [ \
        VtText $mag_stand_form.text \
        -columns 40 \
        -callback mag_stand_host_jump \
    ]
    VtPushButton $mag_stand_form.browse \
        -leftSide $mag_stand_text \
        -topSide FORM \
        -callback mag_stand_host_browse \
        -label [mag_msg STR_SELECT]
    VtShow $mag_stand_form
    VtSetFocus $mag_stand_text
    VtMainLoop
}
proc \
mag_stand_host_jump { cbs } \
{
    global mag_stand_form
    set ok [VtGetValues $mag_stand_form -ok]
    VtSetFocus $ok
}
proc \
mag_stand_host_browse { cbs } \
{
    global mag_stand_form
    keylset parms parent $mag_stand_form
    keylset parms instance abc
    keylset parms labeltext [mag_msg MENU_HOST]
    keylset parms buttontext [mag_msg STR_SELECT]
    keylset parms userproc mag_stand_host_browse_done
    SaSelectHostDialog $parms $cbs
}
proc \
mag_stand_host_browse_done { cbs } \
{
    global mag_stand_text
    set value [SaSelectHostGetSelection abc]
    VtSetValues $mag_stand_text -value $value
}
proc \
mag_stand_host_ok { cbs } \
{
    global mag_stand_text mag_stand_outfile
    set value [VtGetValues $mag_stand_text -value]
    if {[catch {open $mag_stand_outfile w} fd] == 0} {
        puts $fd $value
        close $fd
    }
    VtClose
    exit 0
}
proc \
mag_stand_open_quit { cbs } \
{
    VtClose
    exit 0
}
proc \
mag_host_check { host } \
{
    global mag_host_name mag_local_host
    if {"$host" == "$mag_local_host"} {
        return "ok"
    }
    set class [ list sco remoteCommand ]
    set instance [GetInstanceList NULL $host]
    set command [list ObjectAction $class $instance uname "-n"]
    set result [SaMakeObjectCall $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        return fail
    }
    set retStr [BmipResponseActionInfo result]
    return ok
}
proc \
mag_remote_copyout { src dst } \
{
    global mag_host_name mag_local_host
    if {"$mag_host_name" == "$mag_local_host"} {
        return [mag_local_copy $src $dst]
    }
    set host $mag_host_name
    set instance [GetInstanceList NULL $host]
    set uid [id effective userid]
    if {$uid == 0} {
        if {[catch {system "/bin/rcp $src $host:$dst >/dev/null 2>&1"} ret] == 0} {
            return ok
        } else {
            return fail
        }
    } else {
        # first copy to a temp file on remote machine
        set tmp "/tmp/[file tail $src].[pid]"
        if {[catch {system "/bin/rcp $src $host:$tmp >/dev/null 2>&1"} ret] != 0} {
            return fail
        }
        # then on remote machine, copy the temp file to destination,
        # using tfadmin cpfile
        set class [list sco remoteCommand]
        set command [list ObjectAction $class $instance /sbin/tfadmin "cpfile $tmp $dst"]
        set result [SaMakeObjectCall $command]
        set result [lindex $result 0]
        if {[BmipResponseErrorIsPresent result]} {
            return fail
        }
        # now remove the temp file on remote machine
        set class [list sco remoteCommand]
        set command [list ObjectAction $class $instance /bin/rm "-f $tmp"]
        set result [SaMakeObjectCall $command]
        return ok
    }
}
proc \
mag_remote_copyin { src dst } \
{
    global mag_host_name mag_local_host
    if {"$mag_host_name" == "$mag_local_host"} {
        return [mag_local_copy $src $dst]
    }
    set host $mag_host_name
    set instance [GetInstanceList NULL $host]
    set uid [id effective userid]
    if {$uid == 0} {
        if {[catch {system "/bin/rcp $mag_host_name:$src $dst >/dev/null 2>&1"} ret] == 0} {
            return ok
        } else {
            return fail
        }
    } else {
        # copy to a temp file on remote machine, using tfadmin
        set tmp "/tmp/[file tail $src].[pid]"
        set class [list sco remoteCommand]
        set command [list ObjectAction $class $instance /sbin/tfadmin "cpfile $src $tmp"]
        set result [SaMakeObjectCall $command]
        set result [lindex $result 0]
        if {[BmipResponseErrorIsPresent result]} {
            return fail
        }
        # copy the remote temp file in to local destination using rcp
        if {[catch {system "/bin/rcp $mag_host_name:$tmp $dst >/dev/null 2>&1"} ret] != 0} {
                        return fail
                }
        # remove the temp file on remote machine
        set class [list sco remoteCommand]
        set command [list ObjectAction $class $instance /bin/rm "-f $tmp"]
        set result [SaMakeObjectCall $command]
        return ok
    }
}
proc \
mag_local_copy { src dst } \
{
    set uid [id effective userid]
    if {$uid == 0} {
        catch {system "copy $src $dst > /dev/null 2>&1"} ret
    } else {
        catch {system "/sbin/tfadmin cpfile $src $dst > /dev/null 2>&1"} ret
    }
    if {"$ret" == 0} {
        return ok
    } else {
        return fail
    }
}
proc \
GetInstanceList { names host } \
{
    set instanceList {}
    if { $host == "localhost" } {
        foreach name $names {
            set instance [list $name]
            lappend instanceList $instance
        }
    } else {
        foreach name $names {
            set instance [list [list systemId $host] [list $name]]
            lappend instanceList $instance
        }
    }
    return $instanceList
}
proc \
mag_restart_sendmail { prompt } \
{
    global mag_host_name mag_local_host SENDMAILPID
    set uid [id effective userid]
    if {"$mag_host_name" == "$mag_local_host"} {
        if {$uid == 0} {
            system "kill -HUP `head -1 $SENDMAILPID`"
        } else {
            system "/sbin/tfadmin kill -HUP `head -1 $SENDMAILPID`"
        }
        return ok
    }
    set class [ list sco remoteCommand ]
    set instance [GetInstanceList NULL $mag_host_name]
    if {$uid == 0} {
        set command [list ObjectAction $class $instance \
            "/usr/bin/kill" "-HUP `head -1 $SENDMAILPID`"]
    } else {
        set command [list ObjectAction $class $instance \
            "/sbin/tfadmin" "kill -HUP `head -1 $SENDMAILPID`"]
    }
    set result [SaMakeObjectCall $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        if {"$prompt" == "yes"} {
            VtUnLock
            mag_error SENDMAIL_RESTART
            VtLock
        }
        return fail
    }
    return ok
}
proc \
mag_host_local {} \
{
    set localhost [exec uname -n]
    set fqdn [mag_host_resolv $localhost]
    return $fqdn
}
proc \
mag_host_resolv { hostname } \
{
    global RESOLVER
    set ret [catch {exec $RESOLVER $hostname} hostlist]
    if {"$ret" != "0"} {
        return $hostname
    }
    set newhost [lindex $hostlist 0]
    return $newhost
}
proc \
mag_list_users {} \
{
    global mag_host_name mag_local_host
    if {"$mag_host_name" == "$mag_local_host"} {
        return [SaUsersGet]
    } else {
        return [SaUsersGet $mag_host_name]
    }
}
proc \
mag_list_groups {} \
{
    global mag_host_name mag_local_host
    if {"$mag_host_name" == "$mag_local_host"} {
        return [SaGroupsGet]
    } else {
        return [SaGroupsGet $mag_host_name]
    }
}
proc \
mag_remote_file_exists { path } \
{
    global mag_host_name mag_local_host
    if {"$mag_host_name" == "$mag_local_host"} {
        return [file exists $path]
    }
    set host $mag_host_name
    set class [list sco remoteCommand]
    set instance [GetInstanceList NULL $host]
    set command [list ObjectAction $class $instance file $path]
    set result [SaMakeObjectCall $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        return 0
    }
    return 1
}
proc \
mag_cmd_line_main {} \
{
    global argv argv0 mag_host_name DIRTY
    if {"$argv" == ""} {
        return
    }
        # check if remote host is there
        if {"[mag_host_check $mag_host_name]" != "ok"} {
                echo "mailadmin: Unable to connect to host $mag_host_name"
                exit 0
        }
    # check authorizations
    if {"[mag_authorized $mag_host_name]" == "fail"} {
        echo "mailadmin: You are not authorized to run the Mail Manager on [mag_short_name_default]"
        exit 0
    }
    # get our remote files from the appropriate host
    mag_cmd_file_get
    set DIRTY 0
    # now process rest of command line
    while {"$argv" != ""} {
        # do one command
        mag_cmd_one
    }
    # put our remote files
    mag_cmd_file_put
    mag_cmd_quit 0
}
proc \
mag_cmd_one {} \
{
    global CMD argv DIRTY
    set cmd [mag_cmd_popargv]
    set CMD $cmd
    switch -- "$cmd" {
    "sendmail" {
        set action [mag_cmd_popargv]
        if {"$action" != "restart"} {
            echo "mailadmin: Unknown sendmail action: $action"
            mag_cmd_quit 1
        }
        mag_restart_sendmail no
    }
    "uucp" {
        set action [mag_cmd_popargv]
        if {"$action" != "rebuild"} {
            echo "mailadmin: Unknown uucp action: $action"
            mag_cmd_quit 1
        }
        mag_rebuild_uucp_map no
    }
    "add" {
        set DIRTY 1
        set type [mag_cmd_popargv]
        set name [mag_cmd_popargv]
        switch "$type" {
        "map" {
            set list [ma_aliases_get]
            if {[lsearch $list $name] >= 0} {
                echo "mailadmin: Duplicate map name for add: $name"
                mag_cmd_quit 1
            }
            lappend list $name
            ma_aliases_set $list
        }
        "altname" {
            set list [ma_alternate_names_get]
            if {[lsearch $list $name] >= 0} {
                echo "mailadmin: Duplicate altname for add: $name"
                mag_cmd_quit 1
            }
            lappend list $name
            ma_alternate_names_set $list
        }
        "channel" {
            set list [mai_ch_names_get]
            set program [mag_cmd_popargv]
            set table [mag_cmd_popargv]
            if {[lsearch $list $name] >= 0} {
                echo "mailadmin: Duplicate channel name for add: $name"
                mag_cmd_quit 1
            }
            set ret [ma_ch_create $name]
            switch "$ret" {
            "conflict" {
                echo "mailadmin: Name conflict or reserved name: $name"
                mag_cmd_quit 1
            }
            "badname" {
                echo "mailadmin: Invalid channel name: $name"
                mag_cmd_quit 1
            }
            }
            ma_ch_equate_set $name P $program
            mag_cmd_table_type_check $table
            ma_ch_table_type_set $name $table
            set ret [mai_channel_order_set $name]
            if {"$ret" != "ok"} {
                echo "mailadmin: Only one baduser channel may exist."
                mag_cmd_quit 1
            }
            # now set all channel properties to default values.
            set list [mag_cmd_channel_prop_list]
            foreach item $list {
                set propname [list $name $item]
                mag_cmd_default $propname
            }
        }
        default {
            echo "mailadmin: Unknown add type: $type"
            mag_cmd_quit 1
        }
        }
    }
    "del" {
        set DIRTY 1
        set type [mag_cmd_popargv]
        set name [mag_cmd_popargv]
        switch "$type" {
        "map" {
            set list [ma_aliases_get]
            set index [lsearch $list $name]
            if {$index == -1} {
                echo "mailadmin: Map name not found: $name"
                mag_cmd_quit 1
            }
            set list [lreplace $list $index $index]
            ma_aliases_set $list
        }
        "altname" {
            set list [ma_alternate_names_get]
            set index [lsearch $list $name]
            if {$index == -1} {
                echo "mailadmin: Altname not found: $name"
                mag_cmd_quit 1
            }
            set list [lreplace $list $index $index]
            ma_alternate_names_set $list
        }
        "channel" {
            set list [mai_ch_names_get]
            set index [lsearch $list $name]
            if {$index == -1} {
                echo "mailadmin: Channel name not found: $name"
                mag_cmd_quit 1
            }
            ma_ch_delete $name
        }
        default {
            echo "mailadmin: Invalid del type: $type"
            mag_cmd_quit 1
        }
        }
    }
    "order" {
        set DIRTY 1
        set type [mag_cmd_popargv]
        set neworder ""
        set item [mag_cmd_popargv]
        while {"$item" != "" && "$item" != "--"} {
            lappend neworder $item
            if {"$argv" != ""} {
                set item [mag_cmd_popargv]
            } else {
                set item ""
            }
        }
        switch "$type" {
        "maps" {
            set oldorder [ma_aliases_get]
            mag_cmd_vfy_lists $neworder $oldorder
            ma_aliases_set $neworder
        }
        "altnames" {
            set oldorder [ma_alternate_names_get]
            mag_cmd_vfy_lists $neworder $oldorder
            ma_alternate_names_set $neworder
        }
        "channels" {
            set oldorder [mai_ch_names_get]
            mag_cmd_vfy_lists $neworder $oldorder
            # now verify that new order doesn't have a
            # baduser channel in the wrong place.
            set length [llength $neworder]
            set stop [expr $length - 1]
            loop index 0 $stop {
                set chname [lindex $neworder $index]
                set table [ma_ch_table_type_get $chname]
                if {"$table" == "baduser"} {
                    echo "mailadmin: New order has a baduser channel that is not the last channel."
                    mag_cmd_quit 1
                }
            }
            # now set the new order
            loop index 0 $length {
                set chname [lindex $neworder $index]
                ma_ch_sequence_set $chname $index
            }
        }
        default {
            echo "mailadmin: Invalid order type: $type"
            mag_cmd_quit 1
        }
        }
    }
    "list" {
        set type [mag_cmd_popargv]
        switch "$type" {
        "maps" {
            set list [ma_aliases_get]
        }
        "altnames" {
            set list [ma_alternate_names_get]
        }
        "channels" {
            set list [mai_ch_names_get]
        }
        default {
            echo "mailadmin: Invalid list type: $type"
            mag_cmd_quit 1
        }
        }
        foreach item $list {
            echo $item
        }
    }
    "get" {
        set propname [mag_cmd_getprop]
        mag_cmd_get $propname
    }
    "set" {
        set propname [mag_cmd_getprop]
        set value [mag_cmd_popargv]
        mag_cmd_set $propname $value
    }
    "def" {
        set propname [mag_cmd_getprop]
        mag_cmd_default $propname
    }
    default {
        echo "mailadmin: Unknown command: $cmd"
        mag_cmd_usage
        mag_cmd_quit 1
    }
    }
}
proc \
mag_cmd_get { propname } \
{
    global mag_host_name MQUEUE
    set chname ""
    if {[llength $propname] == 2} {
        set chname [lindex $propname 0]
        set propname [lindex $propname 1]
    }
    # regular properties
    if {"$chname" == ""} {
        switch $propname {
        host {
            set value [ma_machine_name_get]
            if {"$value" == ""} {
                set value $mag_host_name
            }
            echo $value
        }
        from {
            set value [ma_from_domain_get]
            if {"$value" == ""} {
                set value $mag_host_name
            }
            echo $value
        }
        domain {
            set ret [ma_domain_table_enabled_get]
            if {"$ret" == "1"} {
                echo TRUE
            } else {
                echo FALSE
            }
        }
        fdir {
            echo [ma_ms1_get MS1_INBOX_DIR]
        }
        fname {
            echo [ma_ms1_get MS1_INBOX_NAME]
        }
        fformat {
            set ret [ma_ms1_get MS1_FOLDER_FORMAT]
            set ret [string tolower $ret]
            switch "$ret" {
            "mmdf" {
                echo MMDF
            }
            "sendmail" {
                echo Sendmail
            }
            }
        }
        fsync {
            echo [string toupper [ma_ms1_get MS1_FSYNC]]
        }
        fccheck {
            echo [string toupper [ma_ms1_get MS1_EXTENDED_CHECKS]]
        }
        fincore {
            echo [string toupper [ma_ms1_get MS1_FOLDERS_INCORE]]
        }
        fthreshold {
            echo [ma_ms1_get MS1_EXPUNGE_THRESHOLD]
        }
        ftimeout {
            echo [ma_ms1_get MS1_LOCK_TIMEOUT]
        }
        ffilelock {
            echo [string toupper [ma_ms1_get MS1_FILE_LOCKING]]
        }
        fumask {
            echo [ma_ms1_get MS1_UMASK]
        }
        }
    } else {
        # channel properties
        switch "$propname" {
        name {
            echo $chname
        }
        program {
            echo [ma_ch_equate_get $chname P]
        }
        args {
            echo [ma_ch_equate_get $chname A]
        }
        dir {
            set ret [ma_ch_equate_get $chname D]
            if {"$ret" == ""} {
                set ret $MQUEUE
            }
            echo $ret
        }
        table {
            echo [ma_ch_table_type_get $chname]
        }
        file {
            echo [ma_ch_table_file_get $chname]
        }
        host {
            echo [ma_ch_host_get $chname]
        }
        flags {
            echo [ma_ch_equate_get $chname F]
        }
        eol {
            set value [ma_ch_equate_get $chname E]
            if {"$value" == ""} {
                set value "\\n"
            }
            echo $value
        }
        maxmsg {
            set value [ma_ch_equate_get $chname M]
            if {"$value" == ""} {
                set value 0
            }
            echo $value
        }
        maxline {
            set value [ma_ch_equate_get $chname L]
            if {"$value" == ""} {
                set value 0
            }
            echo $value
        }
        nice {
            set value [ma_ch_equate_get $chname N]
            if {"$value" == ""} {
                set value 0
            }
            echo $value
        }
        user {
            echo [ma_ch_equate_get $chname U]
        }
        rruleset {
            echo [ma_ch_equate_get $chname R]
        }
        sruleset {
            echo [ma_ch_equate_get $chname S]
        }
        }
    }
}
proc \
mag_cmd_set { propname value } \
{
    global MQUEUE DIRTY mag_host_name
    set DIRTY 1
    set chname ""
    if {[llength $propname] == 2} {
        set chname [lindex $propname 0]
        set propname [lindex $propname 1]
    }
    # regular properties
    if {"$chname" == ""} {
        switch $propname {
        host {
            if {"$value" == "$mag_host_name"} {
                set value ""
            }
            ma_machine_name_set $value
        }
        from {
            if {"$value" == "$mag_host_name"} {
                set value ""
            }
            ma_from_domain_set $value
        }
        domain {
            set bool [mag_cmd_check_tf $value]
            ma_domain_table_enabled_set $bool
        }
        fdir {
            ma_ms1_set MS1_INBOX_DIR $value
        }
        fname {
            ma_ms1_set MS1_INBOX_NAME $value
        }
        fformat {
            set test [string tolower $value]
            switch "$test" {
            "mmdf" {
                set value MMDF
            }
            "sendmail" {
                set value Sendmail
            }
            default {
                echo "mailadmin: Folder format must be MMDF or Sendmail: $value"
                mag_cmd_quit 1
            }
            }
            ma_ms1_set MS1_FOLDER_FORMAT $value
        }
        fsync {
            mag_cmd_check_tf $value
            ma_ms1_set MS1_FSYNC [string toupper $value]
        }
        fccheck {
            mag_cmd_check_tf $value
            ma_ms1_set MS1_EXTENDED_CHECKS [string toupper $value]
        }
        fincore {
            mag_cmd_check_tf $value
            ma_ms1_set MS1_FOLDERS_INCORE [string toupper $value]
        }
        fthreshold {
            set value [mag_cmd_number $value 0 100]
            ma_ms1_set MS1_EXPUNGE_THRESHOLD $value
        }
        ftimeout {
            set value [mag_cmd_number $value 1 999]
            ma_ms1_set MS1_LOCK_TIMEOUT $value
        }
        ffilelock {
            mag_cmd_check_tf $value
            ma_ms1_set MS1_FILE_LOCKING [string toupper $value]
        }
        fumask {
            mag_cmd_check_umask $value
            ma_ms1_set MS1_UMASK $value
        }
        }
    } else {
        # channel properties
        switch "$propname" {
        name {
            # wants to rename channel
            set newname $value
            set oldname $chname
            set ret [ma_ch_rename $oldname $newname]
            switch "$ret" {
            "conflict" {
                echo "mailadmin: Channel name conflict: $newname"
                mag_cmd_quit 1
            }
            "badname" {
                echo "mailadmin: Channel name invalid: $newname"
                mag_cmd_quit 1
            }
            }
        }
        program {
            ma_ch_equate_set $chname P $value
        }
        args {
            ma_ch_equate_set $chname A $value
        }
        dir {
            if {"$value" == "$MQUEUE"} {
                set value ""
            }
            ma_ch_equate_set $chname D $value
        }
        table {
            mag_cmd_table_type_check $value
            ma_ch_table_type_set $chname $value
        }
        file {
            ma_ch_table_file_set $chname $value
        }
        host {
            ma_ch_host_set $chname $value
        }
        flags {
            ma_ch_equate_set $chname F $value
        }
        eol {
            if {"$value" == "\\n"} {
                set value ""
            }
            ma_ch_equate_set $chname E $value
        }
        maxmsg {
            set value [mag_cmd_number $value 0 2000000000]
            if {$value == 0} {
                set value ""
            }
            ma_ch_equate_set $chname M $value
        }
        maxline {
            set value [mag_cmd_number $value 0 10000]
            if {$value == 0} {
                set value ""
            }
            ma_ch_equate_set $chname L $value
        }
        nice {
            set value [mag_cmd_number $value -20 20]
            if {$value == 0} {
                set value ""
            }
            ma_ch_equate_set $chname N $value
        }
        user {
            ma_ch_equate_set $chname U $value
        }
        rruleset {
            ma_ch_equate_set $chname R $value
        }
        sruleset {
            ma_ch_equate_set $chname S $value
        }
        }
    }
}
proc \
mag_cmd_default { propname } \
{
    global MQUEUE MAILSPOOL MAILTABLE DIRTY mag_host_name
    set DIRTY 1
    set chname ""
    if {[llength $propname] == 2} {
        set chname [lindex $propname 0]
        set propname [lindex $propname 1]
    }
    # regular properties
    if {"$chname" == ""} {
        switch $propname {
        host {
            ma_machine_name_set ""
        }
        from {
            ma_from_domain_set ""
        }
        domain {
            ma_domain_table_enabled_set 0
        }
        fdir {
            ma_ms1_set MS1_INBOX_DIR $MAILSPOOL
        }
        fname {
            ma_ms1_set MS1_INBOX_NAME ""
        }
        fformat {
            ma_ms1_set MS1_FOLDER_FORMAT Sendmail
        }
        fsync {
            ma_ms1_set MS1_FSYNC FALSE
        }
        fccheck {
            ma_ms1_set MS1_EXTENDED_CHECKS FALSE
        }
        fincore {
            ma_ms1_set MS1_FOLDERS_INCORE FALSE
        }
        fthreshold {
            ma_ms1_set MS1_EXPUNGE_THRESHOLD 50
        }
        ftimeout {
            ma_ms1_set MS1_LOCK_TIMEOUT 10
        }
        ffilelock {
            ma_ms1_set MS1_FILE_LOCKING FALSE
        }
        fumask {
            ma_ms1_set MS1_UMASK 077
        }
        }
    } else {
        # channel properties
        switch "$propname" {
        name {
            # does nothing
        }
        program {
            # does nothing
        }
        table {
            # does nothing
        }
        args {
            # default based on channel program
            set chprogram [ma_ch_equate_get $chname P]
            set base [exec basename $chprogram]
            set value "$base \$u"
            switch $base {
            "\[IPC\]" {
                set value "IPC \$h"
            }
            "uux" {
                set value "uux - -r -a\$f -gmedium \$h!rmail (\$u)"
            }
            "slocal" {
                set value "slocal \$u"
            }
            }
            ma_ch_equate_set $chname A $value
        }
        dir {
            ma_ch_equate_set $chname D ""
        }
        file {
            # based on table type
            set table [ma_ch_table_type_get $chname]
            if {"$table" == "file"} {
                set value "$MAILTABLE/$chname"
            } else {
                set value ""
            }
            ma_ch_table_file_set $chname $value
        }
        host {
            ma_ch_host_set $chname ""
        }
        flags {
            # default based on channel program
            set chprogram [ma_ch_equate_get $chname P]
            # custom same as SMTP
            set value "mlsDFMPeu8"
            switch [exec basename $chprogram] {
            "\[IPC\]" {
                set value "mlsDFMPeu8"
            }
            "uux" {
                set value "mDFMhuU8"
            }
            "slocal" {
                set value "lsDFMPhoAw5:|/@8"
            }
            }
            ma_ch_equate_set $chname F $value
        }
        eol {
            set chprogram [ma_ch_equate_get $chname P]
            if {"$chprogram" == "\[IPC\]"} {
                set value "\\r\\n"
            } else {
                set value ""
            }
            ma_ch_equate_set $chname E $value
        }
        maxmsg {
            set chprogram [ma_ch_equate_get $chname P]
            if {"[exec basename $chprogram]" == "uux"} {
                set value 100000
            } else {
                #set value ""
                set value 20000000
            }
            ma_ch_equate_set $chname M $value
        }
        maxline {
            set chprogram [ma_ch_equate_get $chname P]
            if {"$chprogram" == "\[IPC\]"} {
                set value 990
            } else {
                set value ""
            }
            ma_ch_equate_set $chname L $value
        }
        nice {
            ma_ch_equate_set $chname N ""
        }
        user {
            ma_ch_equate_set $chname U ""
        }
        rruleset {
            # default based on channel program
            set chprogram [ma_ch_equate_get $chname P]
            # custom same as SMTP
            set value "ap822_re/ap822_rh"
            switch [exec basename $chprogram] {
            "\[IPC\]" {
                set value "ap822_re/ap822_rh"
            }
            "uux" {
                set value "ap976_re/ap976_rh"
            }
            "slocal" {
                set value "aplocal_re/aplocal_rh"
            }
            }
            ma_ch_equate_set $chname R $value
        }
        sruleset {
            # default based on channel program
            set chprogram [ma_ch_equate_get $chname P]
            # custom same as SMTP
            set value "ap822_se/ap822_sh"
            switch [exec basename $chprogram] {
            "\[IPC\]" {
                set value "ap822_se/ap822_sh"
            }
            "uux" {
                set value "ap976_se/ap976_sh"
            }
            "slocal" {
                set value "aplocal_se/aplocal_sh"
            }
            }
            ma_ch_equate_set $chname S $value
        }
        }
    }
}
proc \
mag_cmd_usage {} \
{
    global MQUEUE
echo "Usage:"
echo "mailadmin"
echo "    invoke GUI"
echo "mailadmin \[-h host\] command \[arguments\]"
echo "    Command line mode, following are the commands and their arguments."
echo "    Multiple command may be strung together on the command line."
echo "    If any of them fail no changes to the config files are made."
echo "    Commands with a variable number of arguments may be terminated with --."
echo
echo "sendmail restart - stop and restart the sendmail daemon"
echo "    Sendmail should be restarted after all changes are completed."
echo "    The GUI does this automatically."
echo
echo "uucp rebuild - rebuild /etc/mail/table/uucp.db from /usr/lib/uucp/Systems."
echo "    This only needs to be done if a UUCP channel exists and the Systems file"
echo "    has been changed.  The GUI does this automatically."
echo
echo "add map name - add an nis alias map or alias file entry.
echo "    formats are nis:mapname or a full pathname for an alias file."
echo "add altname name - add an alternate name for this host."
echo "add channel name program type - add a new channel entry."
echo "    table type is one of: DNS UUCP local remote baduser file."
echo
echo "del map name - delete an alias map or alias file by name."
echo "del altname name - delete an alternate name entry by name."
echo "del channel name - delete a channel entry by name."
echo
echo "order maps list - give new alias map order."
echo "order altnames list - give new alternate names order."
echo "order channels list - give new channel order."
echo "    channels using the baduser table type must go last,"
echo "    and there can be at most one such channel."
echo
echo "list maps - output alias map names in order."
echo "list altnames - output alternate names in order."
echo "list channels - output channel names in order."
echo
echo "The following commands deal with individual properties."
echo
echo "def propname - set a given property to it's default value."
echo "get propname - display current value of the given property."
echo "set propname value - set a given property to the given value."
echo
echo "Propnames can be a single token or they can be a channel name,"
echo "followed by a colon and then the property name."
echo
echo "Valid property names and their values are as follows:"
echo
echo "General Mail Properties"
echo "host - Host Name, default is to use the system name."
echo "from - From Domain Name, default (systemid) is used."
echo "domain - TRUE/FALSE, Domain Table Enabled (/etc/mail/table/domain)."
echo
echo "Message Store (Folder) properties"
echo "fdir - inbox directory, zero length string means use user's home directories."
echo "fname - inbox name, zero length string means use user's login name."
echo "fformat - MMDF/Sendmail, default folder format."
echo "fsync - TRUE/FALSE, enable O_FSYNC on folders."
echo "fccheck - TRUE/FALSE, enable extended consistency checks."
echo "fincore - TRUE/FALSE, enable incore caching of entire mail folders."
echo "fthreshold - 0-100, percent of file that must be maintained as valid."
echo "    set 100 for maximum compatibility, 50 for higher performance."
echo "ftimeout - 1-999, file lock timeout for mail folders."
echo "ffilelock - TRUE/FALSE, enable file based locking on mail folders."
echo "    folder.lock files will be used.  Kernel locking is always enabled."
echo "    This option adds file based locking."
echo "fumask - 0-0777, set mask for folder and directory creation for mail system."
echo
echo "Channel properties (must be preceeded with channel name and a colon)."
echo "name - channel name, no white space in name, domain is a reserved name,"
echo "    names must be unique.  baduser, badhost, multihome, and local are treated"
echo "    specially, they are translated into local names in the GUI based on LOCALE."
echo "program - channel program (P=), either a path name or \[IPC\] for SMTP."
echo "args - channel program arguments (A=), \$h and \$u are special to sendmail."
echo "    See sendmail documentation on mailer arguments."
echo "dir - channel program execution directory, default is $MQUEUE."
echo "table - DNS, UUCP, remote, local, file, baduser, channel table type."
echo "   baduser channel is special, it must be last and there can be only one."
echo "file - channel table file, only used for channel tables of type file."
echo "host - route all mail for this channel through this host."
echo "   set this option to the zero length string to remove this routing."
echo "   This value is ignored for file table channels."
echo "flags - channel program flags (F=), see sendmail doc on mailer flags."
echo "eol - channel program end of line (usually \\n although SMTP wants \\r\\n)."
echo "maxmsg - maximum message size, zero means no maximum."
echo "maxline - maximum line size, zero means no maximum, 990 is expected to be"
echo "    set for all channels that use SMTP, most others use 0."
echo "nice - -20-20 (N=), channel program nice increment, 0 is use default value."
echo "user - user:group (U=), user and group to run channel program as. If set to"
echo "    zero length string, then bin:bin (1:1) is used."
echo "rruleset - envelope\[/header\], envelope and header recipient rulesets."
echo "    We define ap822_re/ap822_rh for SMTP, ap975_re/ap976_rh for UUCP,"
echo "    and aplocal_re/aplocal_rh for local delivery."
echo "    Custom channels will generally want the rfc822 rewriting rules."
echo "    See the sendmail doc if you to add your own rulesets to sendmail.cf."
echo "sruleset - envelope\[/header\], envelope and header sender rulesets."
echo "    We define ap822_se/ap822_sh for SMTP, ap975_se/ap976_sh for UUCP,"
echo "    and aplocal_se/aplocal_sh for local delivery."
}
proc \
mag_cmd_table_type_check { table } \
{
    set list [list baduser DNS UUCP remote local file]
    if {[lsearch $list $table] == -1} {
        echo "mailadmin: Unknown channel table type: $table"
        mag_cmd_quit 1
    }
}
proc \
mag_cmd_vfy_lists { newlist oldlist } \
{
    set slist1 [lsort $newlist]
    set slist2 [lsort $oldlist]
    if {"$slist1" != "$slist2"} {
        echo "mailadmin: Ordering lists don't have the same items:"
        echo "    new list: $newlist"
        echo "    old list: $oldlist"
        mag_cmd_quit 1
    }
}
proc \
mag_cmd_popargv {} \
{
    global argv CMD
    if {"$argv" == ""} {
        echo "mailadmin: Not enough arguments for command: $CMD"
        mag_cmd_quit 1
    }
    return [lvarpop argv]
}
proc \
mag_cmd_getprop {} \
{
    set propname [mag_cmd_popargv]
    # have a channel property
    set colon [string first ":" $propname]
    if {$colon >= 0} {
        set end [expr $colon - 1]
        set chname [csubstr $propname 0 $colon]
        if {"$chname" == ""} {
            echo "mailadmin: Null channel name"
            mag_cmd_quit 1
        }
        set channels [mai_ch_names_get]
        if {[lsearch $channels $chname] == -1} {
            echo "mailadmin: Unknown channel name: $chname"
            mag_cmd_quit 1
        }
        set start [expr $colon + 1]
        set propname [csubstr $propname $start end]
        mag_cmd_channel_prop_vfy $propname
        return [list $chname $propname]
    }
    # regular property
    mag_cmd_regular_prop_vfy $propname
    return $propname
}
proc \
mag_cmd_channel_prop_vfy { propname } \
{
    if {"$propname" == ""} {
        echo "mailadmin: Null channel property name"
        mag_cmd_quit 1
    }
    set list [mag_cmd_channel_prop_list]
    if {[lsearch $list $propname] == -1} {
        echo "mailadmin: Invalid channel property name: $propname"
        mag_cmd_quit 1
    }
}
proc \
mag_cmd_channel_prop_list {} \
{
    set list [list name program args dir table file host flags eol maxmsg maxline nice user rruleset sruleset]
    return $list
}
proc \
mag_cmd_regular_prop_vfy { propname } \
{
    if {"$propname" == ""} {
        echo "mailadmin: Null property name"
        mag_cmd_quit 1
    }
    set list [list host from domain fdir fname fformat fsync fccheck fincore fthreshold ftimeout ffilelock fumask]
    if {[lsearch $list $propname] == -1} {
        echo "mailadmin: Invalid property name: $propname"
        mag_cmd_quit 1
    }
}
proc \
mag_cmd_check_tf { value } \
{
    set test [string toupper $value]
    if {"$test" == "TRUE"} {
        return 1
    }
    if {"$test" == "FALSE"} {
        return 0
    }
    echo "mailadmin: Invalid TRUE/FALSE value: $value"
    mag_cmd_quit 1
}
proc \
mag_cmd_check_umask { value } \
{
    if {[ctype digit $value] == 0} {
        echo "mailadmin: Invalid umask value: $value"
        mag_cmd_quit 1
    }
    if {[string first 8 $value] >= 0} {
        echo "mailadmin: Invalid umask, not an octal number: $value"
        mag_cmd_quit 1
    }
    if {[string first 9 $value] >= 0} {
        echo "mailadmin: Invalid umask, not an octal number: $value"
        mag_cmd_quit 1
    }
    if {"[cindex $value 0]" != "0"} {
        echo "mailadmin: First digit of a umask must be 0"
        mag_cmd_quit 1
    }
    if {$value > 0777} {
        echo "mailadmin: Invalid umask value, greater than 0777: $value"
        mag_cmd_quit 1
    }
}
proc \
mag_cmd_number { value min max } \
{
    set test $value
    if {"[csubstr $value 0 1]" == "-"} {
        set test [csubstr $value 1 end]
    }
    if {[ctype digit $test] == 0} {
        echo "mailadmin: Invalid numeric value: $value"
        mag_cmd_quit 1
    }
    set value [mag_trim_zero $value]
    if {$value < $min} {
        echo "mailadmin: Number less than minimum value of $min: $value"
        mag_cmd_quit 1
    }
    if {$value > $max} {
        echo "mailadmin: Number greater than maximum value of $max: $value"
        mag_cmd_quit 1
    }
    return $value
}
proc \
mag_cmd_file_get {} \
{
    global MAILCF MAILCFTMP MAILDEF MAILDEFTMP mag_host_name
    system "rm -fr $MAILCFTMP $MAILDEFTMP"
    set ret [mag_remote_copyin $MAILCF $MAILCFTMP]
    if {"$ret" != "ok"} {
        echo "mailadmin: Unable to access $mag_host_name:$MAILCF"
        mag_cmd_quit 1
    }
    set ret [mag_remote_copyin $MAILDEF $MAILDEFTMP]
    if {"$ret" != "ok"} {
        echo "mailadmin: Unable to access $mag_host_name:$MAILDEF"
        mag_cmd_quit 1
    }
    # now open them
    set ret [ma_cf_open $MAILCFTMP]
    if {"$ret" != "ok"} {
        echo "mailadmin: Unable to parse $mag_host_name:$MAILCF"
        mag_cmd_quit 1
    }
    set ret [ma_ms1_open $MAILDEFTMP]
    if {"$ret" != "ok"} {
        echo "mailadmin: Unable to parse $mag_host_name:$MAILDEF"
        mag_cmd_quit 1
    }
}
proc \
mag_cmd_file_put {} \
{
    global MAILCF MAILCFTMP MAILDEF MAILDEFTMP mag_host_name DIRTY
    if {$DIRTY == 1} {
        set ret [ma_cf_write]
        if {"$ret" != "ok"} {
            echo "mailadmin: Unable to save: $MAILCF"
            mag_cmd_quit 1
        }
        set ret [ma_ms1_write]
        if {"$ret" != "ok"} {
            echo "mailadmin: Unable to save: $MAILDEF"
            mag_cmd_quit 1
        }
        set ret [mag_remote_copyout $MAILCFTMP $MAILCF]
        if {"$ret" != "ok"} {
            echo "mailadmin: Unable to save $mag_host_name:$MAILCF"
            mag_cmd_quit 1
        }
        set ret [mag_remote_copyout $MAILDEFTMP $MAILDEF]
        if {"$ret" != "ok"} {
            echo "mailadmin: Unable to save $mag_host_name:$MAILDEF"
            mag_cmd_quit 1
        }
    }
}
proc \
mag_cmd_quit { code } \
{
    cleanup
    exit $code
}
proc \
ma_ms1_open { path } \
{
    global ma_ms1_db ma_ms1_path ma_ms1_index
    set ma_ms1_path $path
    if {[catch {open $path r} fd] != 0} {
        return fail
    }
    # read in file
    set ma_ms1_db ""
    set ma_ms1_index ""
    set linenum -1
    while {[gets $fd line] != -1} {
        set linenum [expr $linenum + 1]
        lappend ma_ms1_db $line
        # check that line is valid syntax
        if {[mai_ms1_skip_line $line] == "ok"} {
            continue
        }
        set list [mai_ms1_parse_line $line]
        if {$list == "parserr"} {
            close $fd
            return parserr
        }
        # check if valid keyword
        set keyword [lindex $list 0]
        if {[catch {ma_ms1_default $keyword}] != 0} {
            return parserr
        }
        set value [lindex $list 1]
        if {"[mai_ms1_valid $keyword $value]" == "fail"} {
            return parserr
        }
        set list [list $keyword $linenum]
        lappend ma_ms1_index $list
    }
    close $fd
    return ok
}
proc \
ma_ms1_get { keyword } \
{
    global ma_ms1_db
    set index [mai_ms1_find $keyword]
    if {$index == -1} {
        return [ma_ms1_default $keyword]
    }
    set line [lindex $ma_ms1_db $index]
    set list [mai_ms1_parse_line $line]
    set value [lindex $list 1]
    return $value
}
proc \
ma_ms1_set { keyword value } \
{
    global ma_ms1_db
    set index [mai_ms1_find $keyword]
    if {"[mai_ms1_valid $keyword $value]" == "fail"} {
        error "Invalid value for $keyword: $value"
    }
    if {$index == -1} {
        # not exist
        lappend ma_ms1_db "${keyword}=${value}"
    } else {
        # exists
        set ma_ms1_db [lreplace $ma_ms1_db $index $index "${keyword}=${value}"]
    }
}
proc \
ma_ms1_default { keyword } \
{
    switch $keyword {
    "MS1_FOLDER_FORMAT" {
        return "MMDF"
    }
    "MS1_INBOX_DIR" {
        return "/var/mail"
    }
    "MS1_INBOX_NAME" {
        return ""
    }
    "MS1_FSYNC" {
        return "FALSE"
    }
    "MS1_EXTENDED_CHECKS" {
        return "FALSE"
    }
    "MS1_EXPUNGE_THRESHOLD" {
        return "50"
    }
    "MS1_FOLDERS_INCORE" {
        return "FALSE"
    }
    "MS1_FILE_LOCKING" {
        return "FALSE"
    }
    "MS1_LOCK_TIMEOUT" {
        return "10"
    }
    "MS1_UMASK" {
        return "077"
    }
    }
    error "Unknown keyword: $keyword"
}
proc \
ma_ms1_write {} \
{
    global ma_ms1_db ma_ms1_path
    if {[catch {open $ma_ms1_path w} fd] != 0} {
        return fail
    }
    # write out file
    foreach item $ma_ms1_db {
        puts $fd $item
    }
    close $fd
    return ok
}
proc \
mai_ms1_valid { keyword value } \
{
    switch $keyword {
    "MS1_FOLDER_FORMAT" {
        set val [string toupper $value]
        if {"$val" == "SENDMAIL"} {
            return ok
        }
        if {"$val" == "MMDF"} {
            return ok
        }
        return fail
    }
    "MS1_INBOX_DIR" { return ok }
    "MS1_INBOX_NAME" { return ok }
    "MS1_FSYNC" {
        set val [string toupper $value]
        if {"$val" == "TRUE"} {
            return ok
        }
        if {"$val" == "FALSE"} {
            return ok
        }
        return fail
    }
    "MS1_EXTENDED_CHECKS" {
        set val [string toupper $value]
        if {"$val" == "TRUE"} {
            return ok
        }
        if {"$val" == "FALSE"} {
            return ok
        }
        return fail
    }
    "MS1_EXPUNGE_THRESHOLD" {
        if {[ctype digit $value] == 0} {
            return fail
        }
        while {"[csubstr $value 0 1]" == "0" && $value != 0} {
            return fail
        }
        if {$value > 100} {
            return fail
        }
        return ok
    }
    "MS1_FOLDERS_INCORE" {
        set val [string toupper $value]
        if {"$val" == "TRUE"} {
            return ok
        }
        if {"$val" == "FALSE"} {
            return ok
        }
        return fail
    }
    "MS1_FILE_LOCKING" {
        set val [string toupper $value]
        if {"$val" == "TRUE"} {
            return ok
        }
        if {"$val" == "FALSE"} {
            return ok
        }
        return fail
    }
    "MS1_UMASK" {
        if {[ctype digit $value] == 0} {
            return fail
        }
        if {[string first 8 $value] >= 0} {
            return fail
        }
        if {[string first 9 $value] >= 0} {
            return fail
        }
        # first digit must be zero
        if {"[cindex $value 0]" != "0"} {
            return fail
        }
        # valid octal number, now do range check,
        # leading zero makes base 8 in tcl just like in C.
        if {$value > 0777} {
            return fail
        }
        return ok
    }
    "MS1_LOCK_TIMEOUT" {
        if {[ctype digit $value] == 0} {
            return fail
        }
        if {$value > 0} {
            return ok
        }
        return fail
    }
    }
    error "Unknown keyword: $keyword"
}
proc \
mai_ms1_find { keyword } \
{
    global ma_ms1_index
    set count [llength $ma_ms1_index]
    set value ""
    loop i 0 $count {
        set list [lindex $ma_ms1_index $i]
        set lkeyword [lindex $list 0]
        if {$lkeyword == $keyword} {
            return [lindex $list 1]
        }
    }
    return -1
}
proc \
mai_ms1_skip_line { line } \
{
    if {[string length $line] == 0} {
        return ok
    }
    if {[cindex $line 0] == "#"} {
        return ok
    }
    return fail
}
proc \
mai_ms1_parse_line { line } \
{
    set index [string first "=" $line]
    if {$index == "-1"} {
        return parserr
    }
    set left [csubstr $line 0 $index]
    set left [string trim $left]
    set index [expr $index + 1]
    set right [csubstr $line $index end]
    set right [string trim $right]
    set right [string trim $right "\""]
    if {$left == ""} {
        return parserr
    }
    set list [list "$left" "$right"]
    lappend list $left $right
    return $list
}
set CF_MaxLine    80
array set optionNames {\
            7    SevenBitInput \
            8    EightBitMode \
            A    AliasFile \
            a    AliasWait \
            B    BlankSub \
            b    MinFreeBlocks \
            C    CheckpointInterval \
            c    HoldExpensive \
            D    AutoRebuildAliases \
            d    DeliveryMode \
            E    ErrorHeader \
            e    ErrorMode \
            f    SaveFromLine \
            F    TempFileMode \
            G    MatchGECOS \
            H    HelpFile \
            h    MaxHopCount \
            i    IgnoreDots \
            I    ResolverOptions \
            J    ForwardPath \
            j    SendMimeErrors \
            k    ConnectionCacheSize \
            K    ConnectionCacheTimeout \
            L    LogLevel \
            l    UseErrorsTo \
            m    MeToo \
            n    CheckAliases \
            O    DaemonPortOptions \
            o    OldStyleHeaders \
            P    PostmasterCopy \
            p    PrivacyOptions \
            Q    QueueDirectory \
            q    QueueFactor \
            R    DontPruneRoutes \
            S    StatusFile \
            s    SuperSafe \
            t    TimeZoneSpec \
            u    DefaultUser \
            U    UserDatabaseSpec \
            V    FallbackMXhost \
            v    Verbose \
            w    TryNullMXList \
            x    QueueLA \
            X    RefuseLA \
            Y    ForkEachJob \
            y    RecipientFactor \
            z    ClassFactor \
            Z    RetryFactor}
array set listOptions {AliasFile "," \
               DaemonPortOptions "," \
               PrivacyOptions "," \
               ResolverOptions " "}
proc CF:OptionFullname {id} {
    global optionNames
    if {[clength $id] == 1 && [info exists optionNames($id)]} {
    return $optionNames($id)
    } else {
    return $id
    }
}
proc CF:CommaListOption {id} {
    global listOptions
    set id [CF:OptionFullname $id]
    if {[info exists listOptions($id)] && $listOptions($id) == ","} {
    return 1
    } else {
    return 0
    }
}
proc CF:ReadCB {fileID fp} {
    Table:SetOption $fileID newFirst 1
    set context [scancontext create]
    scanmatch $context {^D\{(.*)\}(.*)} {
    Table:ProcessLine $fileID macro $matchInfo(submatch0) \
        $matchInfo(submatch1)
    }
    scanmatch $context {^D([^\{])(.*)} {
    Table:ProcessLine $fileID macro $matchInfo(submatch0) \
        $matchInfo(submatch1)
    }
    scanmatch $context {^O ([^     =]+)([     =]*)?(.*)} {
    Table:ProcessLine $fileID option $matchInfo(submatch0) \
        $matchInfo(submatch2)
    }
    scanmatch $context {^O([^ ])(.*)} {
    Table:ProcessLine $fileID option \
        [CF:OptionFullname $matchInfo(submatch0)] $matchInfo(submatch1)
    }
    scanmatch $context {^K([^     ]*)(.*)} {
    Table:ProcessLine $fileID map $matchInfo(submatch0) \
        $matchInfo(submatch1)
    }
    scanmatch $context {^C\{(.*)\}(.*)} {
    Table:ProcessLine $fileID class $matchInfo(submatch0) \
        $matchInfo(submatch1)
    }
    scanmatch $context {^C([^\{])(.*)} {
    Table:ProcessLine $fileID class $matchInfo(submatch0) \
        $matchInfo(submatch1)
    }
    scanmatch $context {^S(.*)} {
    Table:ProcessLine $fileID ruleset $matchInfo(submatch0) {}
    }
    scanmatch $context {^R.*} {
    Table:ProcessLine $fileID CONTINUATION {} $matchInfo(line)
    }
    scanmatch $context {^M([^,]*),(.*)} {
    Table:ProcessLine $fileID mailer $matchInfo(submatch0) \
        $matchInfo(submatch1)
    }
    scanmatch $context {^[     ]+[^     ]+} {
    global Table_lastType
    #if {$Table_lastType == "header" || $Table_lastType == "mailer"} {
        Table:ProcessLine $fileID CONTINUATION {} $matchInfo(line)
    #} else {
    #    Table:ProcessLine $fileID COMMENT {} $matchInfo(line)
    #}
    }
    scanmatch $context {
    Table:ProcessLine $fileID COMMENT {} $matchInfo(line)
    }
    scanfile $context $fp
    scancontext delete $context
}
proc CF:WriteCB {fileID fp type id data} {
    case $type {
    macro {
        if {[string length $id] > 1} {
        puts $fp "D\{${id}\}${data}"
        } else {
        puts $fp "D$id$data"
        }
    }
    option {
        if {[string length $id] > 1} {
        puts $fp "O $id=$data"
        } else {
        puts $fp "O$id$data"
        }
    }
    map {
        puts $fp "K$id$data"
    }
    class {
        if {[clength $id] > 1} {
        puts $fp "C\{${id}\}${data}"
        } else {
        puts $fp "C$id$data"
        }
    }
    ruleset {
        if {[clength $data] > 0} {
        puts $fp "S${id}\n${data}"
        } else {
        puts $fp "S$id"
        }
    }
    mailer {
        if {$id != {}} {
        puts $fp "M$id," nonewline
        }
        puts $fp $data
    }
    default {
        puts $fp $data
    }
    }
}
proc CF:Open {fileName {mode 0644}} {
    return [Table:Open $fileName CF:ReadCB CF:WriteCB $mode]
}
proc CF:Write {fileID {fileName {}}} {
    return [Table:Write $fileID $fileName]
}
proc CF:Close {fileID} {
    return [Table:Close $fileID]
}
proc CF:ForceWrites {fileID} {
    return [Table:ForceWrites $fileID]
}
proc CF:Get {fileID type id} {
    if {$type == "option"} {
    set id [CF:OptionFullname $id]
    if {[CF:CommaListOption $id]} {
        set result [Table:Get $fileID $type $id ","]
    } else {
        set result [Table:Get $fileID $type $id " "]
    }
    } elseif {$type == "ruleset"} {
    set result [Table:Get $fileID $type $id "\n"]
    set result [string trim $result " \n"]
    } else {
    set result [Table:Get $fileID $type $id " "]
    }
    return $result
}
proc CF:Set {fileID type id data} {
    case $type {
    {class mailer option} {
        return [CF:SetList $fileID $type $id $data]
    }
    default {
        return [Table:Set $fileID $type $id $data]
    }
    }
}
proc CF:Unset {fileID type id} {
    return [Table:Unset $fileID $type $id]
}
proc CF:SetList {fileID type id value} {
    global CF_MaxLine
    set separator " "
    set continuation 0
    # some option values are separated by commas, not whitespace
    case $type {
    option {
        set continuation 1
        set id [CF:OptionFullname $id]
        if {[CF:CommaListOption $id]} {
        set valueList {}
        foreach item [split $value {,}] {
            lappend valueList [string trim $item]
        }
        set value $valueList
        set separator ","
        }
        set data "[lvarpop value]$separator"
        if {[clength $id] > 1} {
        set length [expr \
            [string length $data] + [string length $id] + 3]
        } else {
        set length [expr [string length $data] + 2]
           }
    }
    mailer {
        set continuation 1
        set valueList {}
        foreach item [split $value {,}] {
        lappend valueList [string trim $item]
        }
        set value $valueList
        set separator ", "
            set data " [lvarpop value]$separator"
        set length [expr [string length $data] + [string length $id] + 2]
    }
    class {
        set continuation 1
        set data "[lvarpop value]$separator"
        if {[clength $id] > 1} {
        set length [expr \
            [string length $data] + [string length $id] + 3]
        } else {
        set length [expr [string length $data] + 2]
        }
    }
    }
    set separatorLength [string length $separator]
    set first 1
    foreach word $value {
    set wordLen [string length $word]
    if {[expr "$length + $wordLen + $separatorLength"] <= $CF_MaxLine} {
        append data "${word}${separator}"
        set length [expr "$length + $wordLen + $separatorLength"]
    } else {
        if {$first} {
        Table:Set $fileID $type $id $data
        } else {
        if {$continuation} {
            Table:AppendLine $fileID CONTINUATION $id $data
        }
        }
        set first 0
        if {$continuation} {
        set data "\t${word}${separator}"
        set length [expr 8 + $wordLen + $separatorLength]
        }
    }
    }
    set data [string trimright $data $separator]
    if {$first} {
    return [Table:Set $fileID $type $id $data]
    } else {
    if {$continuation} {
        return [Table:AppendLine $fileID CONTINUATION $id $data]
    }
    }
}
proc CF:AddValue {fileID type id addValue} {
    set currentValue [CF:Get $fileID $type $id]
    set newValue [union $currentValue $addValue]
    return [CF:SetList $fileID $type $id $newValue]
}
proc CF:RemoveValue {fileID type id removeValue} {
    set currentValue [CF:Get $fileID $type $id]
    set newValue [lindex [intersect3 $currentValue $removeValue] 0]
    return [CF:SetList $fileID $type $id $newValue]
}
proc CF:GetMapInfo {fileID mapName} {
    global optarg optind
    if {[set data [CF:Get $fileID map $mapName]] == {}} {
    return {}
    }
    keylset info name $mapName
    keylset info class [ctoken data " \t"]
    while {[set item [ctoken data " \t"]] != {}} {
    lappend argv $item
    }
    set count [expr [llength $argv] - 1]
    keylset info pathName [lindex $argv $count]
    return $info
}
set MA_SENDMAIL_FILEID        -1
set MA_CH_MODIFIED        0
set MA_CH_TABLE_DIRECTORY "/etc/mail/table"
array set MA_CH_TABLE_TYPE {\
    dns_TBL        DNS \
    uucp_TBL    UUCP \
    local_TBL    local \
    remote_TBL    remote \
    baduser_TBL    baduser}
array set MA_CH_RULESET {\
    DNS        dns_TBL \
    UUCP        uucp_TBL \
    local        local_TBL \
    remote        remote_TBL \
    baduser        baduser_TBL}
set MA_CH_TABLE_TYPE_LIST [list \
    "DNS" \
    "UUCP" \
    "local" \
    "remote" \
    "baduser" \
    "file"]
set MA_CH_RESERVED_NAMES [list \
    "error" \
    "prog" \
    "*file*" \
    "*include*"]
proc ma_cf_valid {filename} {
    set retval "ok"
    if {[catch {open $filename r} fd] != 0} {
        return "fail"
    }
    if {[gets $fd line] != -1} {
    if {[regexp {^# checksum:(.*)$} $line match recordedSum] == 1} {
        set tmp /tmp/ma_cf_valid.[pid]
        set ret [catch {open $tmp w} tmpfd]
        if {$ret != 0} {
        error "Unable to open $tmp"
        }
        copyfile $fd $tmpfd
        set csum [exec sum -r $tmp]
        set currentSum [ctoken csum " \t"]
        if {$currentSum != $recordedSum} {
        set retval "fail"
        }
        close $tmpfd
        system "rm -f $tmp"
    } else {
        set retval "fail"
    }
    } else {
    set retval "fail"
    }
    close $fd
    return $retval
}
proc ma_cf_open {filename} {
    global MA_SENDMAIL_FILEID MA_SENDMAIL_FILEPATH MA_SENDMAIL_FILESUM
    if {$MA_SENDMAIL_FILEID != -1} {
        ma_cf_close
    }
    if {![file exists $filename]} {
    return "fail"
    }
    set MA_SENDMAIL_FILEID [CF:Open $filename]
    #
    # For compatibility with the GUI, sendmail.cf file must have...
    #
    # a csumline
    if {[ConfigFile:GetLine \
    $MA_SENDMAIL_FILEID 1.0 dummy dummy csumline] == -1} {
    ma_cf_close
    return "parserr"
    }
    if {[regexp {^# checksum:(.*)$} $csumline match csum] == 1} {
    set MA_SENDMAIL_FILESUM $csum
    } else {
    ma_cf_close
    return "parserr"
    }
    # correctly defined channels
    if {[catch mai_ch_structure_init errorMsg] != 0} {
    ma_cf_close
    return "parserr"
    }
    # the users map (for baduser channel table)
    if {[CF:Get $MA_SENDMAIL_FILEID map users] == ""} {
    ma_cf_close
    return "parserr"
    }
    # the uucp map (for uucp channel table)
    if {[CF:Get $MA_SENDMAIL_FILEID map uucp] == ""} {
    ma_cf_close
    return "parserr"
    }
    # the domain table map
    if {[CF:Get $MA_SENDMAIL_FILEID map domain] == ""} {
    ma_cf_close
    return "parserr"
    }
    # macros, classes for domain table
    if {[CF:Get $MA_SENDMAIL_FILEID class P] != "." || \
    [CF:Get $MA_SENDMAIL_FILEID class D] != "DMNTAB"} {
    ma_cf_close
    return "parserr"
    }
    # the rulesets for domain table parsing
    if {[CF:Get $MA_SENDMAIL_FILEID ruleset domains] == "" || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset domains_helper] == ""} {
    ma_cf_close
    return "parserr"
    }
    # all the rulesets for built-in channel tables
    if {[CF:Get $MA_SENDMAIL_FILEID ruleset local_TBL] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset dns_TBL] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset uucp_TBL] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset remote_TBL] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset baduser_TBL] == ""} {
    ma_cf_close
    return "parserr"
    }
    # all the rulesets for built-in R=, S= equates
    if {[CF:Get $MA_SENDMAIL_FILEID ruleset ap822_se] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap822_sh] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap822_re] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap822_rh] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap976_se] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap976_sh] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap976_re] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset ap976_rh] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset aplocal_se] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset aplocal_sh] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset aplocal_re] == ""    || \
    [CF:Get $MA_SENDMAIL_FILEID ruleset aplocal_rh] == ""} {
    ma_cf_close
    return "parserr"
    }
    set MA_SENDMAIL_FILEPATH $filename
    return ok
}
proc ma_cf_close {} {
    global MA_SENDMAIL_FILEID MA_CH_MODIFIED MA_SENDMAIL_FILESUM channels
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    Table:CloseNoWrite $MA_SENDMAIL_FILEID
    set MA_SENDMAIL_FILEID -1
    set MA_CH_MODIFIED 0
    if {[info exists MA_SENDMAIL_FILESUM]} {
    unset MA_SENDMAIL_FILESUM
    }
    if {[info exists channels]} {
    unset channels
    }
}
proc ma_cf_write {} {
    global MA_SENDMAIL_FILEID MA_SENDMAIL_FILEPATH MA_SENDMAIL_FILESUM
    global MA_CH_MODIFIED
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    if {$MA_CH_MODIFIED} {
    if {[catch mai_ch_structure_commit errorMsg] != 0} {
       return "fail"
    }
    }
    CF:Write $MA_SENDMAIL_FILEID
    # get a checksum of contents, *without* the csum line
    set ret [catch {open $MA_SENDMAIL_FILEPATH r} fd]
    if {$ret != 0} {
        return "fail"
    }
    set ret [gets $fd line]
    if {$ret == -1} {
        return "fail"
    }
    set tmp /tmp/ma_cf_write.[pid]
    set ret [catch {open $tmp w} tmpfd]
    if {$ret != 0} {
    return "fail"
    }
    copyfile $fd $tmpfd
    close $fd
    close $tmpfd
    set csum [exec sum -r $tmp]
    set currentSum [ctoken csum " \t"]
    if {$currentSum != $MA_SENDMAIL_FILESUM} {
    set newCsumline "# checksum:$currentSum"
    set type "COMMENT"
    set id ""
    ConfigFile:ReplaceLine $MA_SENDMAIL_FILEID 1.0 $type $id newCsumline
    CF:ForceWrites $MA_SENDMAIL_FILEID
    CF:Close $MA_SENDMAIL_FILEID
    }
    system "rm -f $tmp"
    return "ok"
}
proc ma_machine_name_get {} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    # NOTE: If the j macro is in turned defined by other macros, these
    #         are not expanded, but are passed as is to the front end.
    set machineName [CF:Get $MA_SENDMAIL_FILEID macro j]
    return $machineName
}
proc ma_machine_name_set {name} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    # NOTE: We are assuming that we would never want to intentionally
    #        set the j macro to a null string, or white space
    #        Also, if the j macro is in turn defined by other
    #        macros, then the macros are not expanded.
    if {[ctype space $name]} {
    set name ""
    }
    set currentName [ma_machine_name_get]
    if {[cequal $name $currentName ]} {
    return
    }
    if {[cequal $name ""]} {
    # unset the machine name in sendmail.cf, which allows
    # sendmail itself to internally define these
    CF:RemoveValue $MA_SENDMAIL_FILEID class w \
        [list [CF:Get $MA_SENDMAIL_FILEID macro j] \
              [CF:Get $MA_SENDMAIL_FILEID macro w]]
    CF:Unset $MA_SENDMAIL_FILEID macro j
    CF:Unset $MA_SENDMAIL_FILEID macro w
    CF:Unset $MA_SENDMAIL_FILEID macro m
    CF:Unset $MA_SENDMAIL_FILEID macro k
    } else {
    set fqdn $name
    set host [ctoken name "."]
    set domain [string trim $name "."]
    if {"$currentName" != ""} {
        if {[regexp {([^\.]+)\..+} $currentName \
            match currentHost] == 1} {
            set removeList [list $currentName $currentHost]
        } else {
            set removeList [list $currentName]
        }
        CF:RemoveValue $MA_SENDMAIL_FILEID class w $removeList
    }
    CF:Set $MA_SENDMAIL_FILEID macro w $host
    CF:Set $MA_SENDMAIL_FILEID macro m $domain
    CF:Set $MA_SENDMAIL_FILEID macro j $fqdn
    CF:Set $MA_SENDMAIL_FILEID macro k $host
    CF:AddValue $MA_SENDMAIL_FILEID class w \
        [list $host $fqdn]
    }
}
proc ma_alternate_names_get {} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    set list [CF:Get $MA_SENDMAIL_FILEID class w]
    if { [lindex $list 0] == "\$M" } {
        set list [lrange $list 1 end]
    }
    return $list
}
proc ma_alternate_names_set {nameList} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    if {[llength $nameList] == 0} {
    CF:Set $MA_SENDMAIL_FILEID class w "\$M"
    } else {
    CF:Set $MA_SENDMAIL_FILEID class w "\$M $nameList"
    }
}
proc ma_from_domain_get {} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    return [CF:Get $MA_SENDMAIL_FILEID macro M]
}
proc ma_from_domain_set {domain} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    CF:Set $MA_SENDMAIL_FILEID macro M $domain
}
proc ma_aliases_get {} {
    global MA_SENDMAIL_FILEID
    set result {}
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    foreach aliasFile \
    [split [CF:Get $MA_SENDMAIL_FILEID option AliasFile] {,}] {
    lappend result "[string trim $aliasFile]"
    }
    return $result
}
proc ma_aliases_set {aliasFileList} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    set cfString ""
    foreach aliasFile $aliasFileList {
    append cfString "$aliasFile,"
    }
    set cfString [string trimright $cfString ","]
    CF:Set $MA_SENDMAIL_FILEID option AliasFile $cfString
}
proc ma_domain_table_enabled_get {} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    set cfString [CF:Get $MA_SENDMAIL_FILEID macro D]
    if {[clength $cfString] == 0} {
    return 0
    } else {
    return 1
    }
}
proc ma_domain_table_enabled_set {enable} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    if {$enable} {
    CF:Set $MA_SENDMAIL_FILEID macro D DMNTAB
    } else {
    CF:Set $MA_SENDMAIL_FILEID macro D ""
    }
}
proc ma_domain_table_file_get {} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    set mapInfo [CF:GetMapInfo $MA_SENDMAIL_FILEID domain]
    keylget mapInfo pathName mapFile
    return $mapFile
}
proc mai_ch_default_equates {} {
    set equateList {}
    keylset equateList P "\[IPC\]"
    keylset equateList F "mDFMuXa"
    keylset equateList S "ap822_se/ap822_sh"
    keylset equateList R "ap822_re/ap822_rh"
    keylset equateList E "\\r\\n"
    keylset equateList L "990"
    keylset equateList A "IPC \$h"
    return $equateList
}
proc mai_ch_equates_get { mailer } {
    global MA_SENDMAIL_FILEID
    set equateStr [CF:Get $MA_SENDMAIL_FILEID mailer $mailer]
    set equateList {}
    set equatesAttr {}
    set listitem ""
    while {[set token [ctoken equateStr ","]] != {}} {
    set i [expr [clength $token] - 1]
    set backslashes 0
    # if there is a \ before the comma, we have to count the
    # number of \'s before the comma, since \\ is acceptable
    # as well as \,
    while {$i >= 0 && [cindex $token $i] == "\\"} {
        incr backslashes
        set i [expr $i - 1]
    }
    if {[expr $backslashes % 2] == 1} {
        set listitem "${listitem}${token},"
    } else {
        set listitem "${listitem}${token}"
        lappend equateList $listitem
        set listitem ""
    }
    }
    foreach equate $equateList {
    if {[regexp {([A-Z]).*=[     ]*(.*)} $equate \
        match equateLetter equateValue] == 1} {
        keylset equatesAttr $equateLetter [string trim $equateValue]
    }
    }
    return $equatesAttr
}
proc mai_ch_order {chName1 chName2} {
    global channels
    set seq1 [lindex $channels($chName1) 0]
    set seq2 [lindex $channels($chName2) 0]
    if {$seq1 < $seq2} {
    return -1
    } elseif {$seq1 == $seq2} {
    return 0
    } else {
    return 1
    }
}
proc mai_ch_valid_table_type {type} {
    global MA_CH_TABLE_TYPE_LIST
    if {[lsearch -exact $MA_CH_TABLE_TYPE_LIST $type] == -1} {
    return 0
    } else {
    return 1
    }
}
proc mai_ch_valid_name {name} {
    global MA_SENDMAIL_FILEID MA_CH_RESERVED_NAMES channels
    # check if this channel already exists
    set currentNames [ma_ch_names_get]
    if {[lsearch -exact $currentNames $name] != -1} {
        return 0
    }
    # check if this channel name is a reserved name
    if {[lsearch -exact $MA_CH_RESERVED_NAMES $name] != -1} {
    return 0
    }
    # check if this channel name already exists as a ruleset or mailer name
    set rulesetAndMailerNames [union [Table:List $MA_SENDMAIL_FILEID ruleset] \
                [Table:List $MA_SENDMAIL_FILEID mailer]]
    if {[lsearch -exact $rulesetAndMailerNames $name] != -1} {
    return 0
    }
    # would this channel name have a conflict with the map name ${name}_MAP ?
    set mapNames [Table:List $MA_SENDMAIL_FILEID map]
    if {[lsearch -exact $mapNames ${name}_MAP] != -1} {
    return 0
    }
    return 1
}
proc mai_ch_valid_chars {name} {
    global MA_SENDMAIL_FILEID
    # get the characters that sendmail uses internally as separation chars
    set oValue [CF:Get $MA_SENDMAIL_FILEID macro o]
    set invalidChars "${oValue}()<>,;\\\"\r\n\t "
    if {[llength [split $name $invalidChars]] > 1} {
    return 0
    }
    return 1
}
proc mai_ch_structure_init {} {
    global MA_SENDMAIL_FILEID MA_CH_TABLE_TYPE channels MA_CH_TABLE_DIRECTORY
    set channelsRuleset [CF:Get $MA_SENDMAIL_FILEID ruleset channels]
    if {$channelsRuleset == ""} {
    error "Ruleset \"channels\" doesn't exist; config file not compatible."
    }
    set channelsList [split $channelsRuleset "\n"]
    set thisSeq 0
    foreach rule $channelsList {
    if {[regexp {^R\$\*[    ]+\$:[ ]*\$>[ ]*([^ ]+)[ ]+\$1} \
        $rule match chName] == 1} {
        set sequenceAttr $thisSeq
        set channelRulesList \
        [split [CF:Get $MA_SENDMAIL_FILEID ruleset $chName] "\n"]
        set rule1 [lindex $channelRulesList 0]
        set rule2 [lindex $channelRulesList 1]
        #
        # Determine table type, table file...
        #
        if {[regexp {\$:[ ]*\$>[ ]*([^ ]+)[ ]*\$} \
        $rule1 match table] == 1} {
        # See if a built in table (ruleset)
        if {[info exists MA_CH_TABLE_TYPE($table)]} {
            # this is a built-in table type
            set tableTypeAttr "$MA_CH_TABLE_TYPE($table)"
        } else {
            # we don't know what table type this is
            error "Unknown table type \"$table\""
        }
        set tableFileAttr ""
        } elseif {[regexp {\$:[ ]*<[ ]*\$\(([^ ]+)[ ]+.*\$\)[ ]*>} \
            $rule1 match mapName] == 1} {
        # Otherwise, see if a there's a table map file
        set tableTypeAttr "file"
        set mapConfigStr [CF:Get $MA_SENDMAIL_FILEID map $mapName]
        if {[clength $mapConfigStr] != 0} {
            set tableFileAttr "[lindex $mapConfigStr end]"
        } else {
            set tableFileAttr "$MA_CH_TABLE_DIRECTORY/${chName}"
        }
        } else {
            # This channel is not defined within expected conventions
        error "Invalid channel \"$chName\": cannot determine table"
        }
        #
        # Determine delivery agent...
        #
        set equatesAttr {}
        if {[regexp {\$#[ ]*([^ ]+)[ ]+} \
        $rule2 match mailer] == 1} {
        # By convention, the mailer name should be the same as the
        # channel name.
        if {![cequal $mailer $chName]} {
            error "Channel \"$chName\" has different mailer name \"$mailer\""
        }
        set equatesAttr [mai_ch_equates_get $mailer]
        } else {
            # This channel is not defined within expected conventions
        error "Invalid channel \"$chName\": cannot determine deliver agent"
        }
        if {[lempty $equatesAttr]} {
        error "Invalid channel \"$chName\": no delivery agent equates"
        }
        #
        # Determine forwarding host (if any)...
        #
        if {[regexp {\$@[ ]*([^ ]+)[ ]*\$:} \
        $rule2 match host] == 1} {
        if {[regexp {\$[0-9]+} $host] == 1} {
           # $@ is a positional parameter
            set forwardHostAttr ""
        } else {
            # Note: This allows host= to be a defined macro
            set forwardHostAttr $host
        }
        } else {
        # No $@ host specification (probably a channel that
        # does local delivery)
        set forwardHostAttr ""
        }
        set attributeList [list $sequenceAttr\
                    $tableTypeAttr \
                    $tableFileAttr \
                    $forwardHostAttr \
                    $equatesAttr]
        set channels($chName) $attributeList
        incr thisSeq
    }
    }
    #
    # Determine if baduser host is configured
    #
    set lastRuleset5 \
    [lindex [split [CF:Get $MA_SENDMAIL_FILEID ruleset 5] "\n" ] end]
    if {[regexp {\$:[ ]*\$>([^ ]+)[ ]*\$1} $lastRuleset5 \
    match subroutineName] == 1} {
    set subroutineRules \
        [split [CF:Get $MA_SENDMAIL_FILEID ruleset $subroutineName] "\n"]
    if {[regexp {\$:[ ]*\$>([^ ]*)[ ]*} [lindex $subroutineRules 0] \
        match tableRoutine] == 1 && [cequal $tableRoutine "baduser_TBL"]} {
        set chName $subroutineName
        set sequenceAttr $thisSeq
        set tableTypeAttr "baduser"
        set tableFileAttr ""
        set forwardHostAttr ""
        set equatesAttr {}
        # get mailer's equates
        if {[regexp {\$#[ ]*([^ ]+)[ ]+} \
        [lindex $subroutineRules 1] match mailer] == 1} {
        if {![cequal $mailer $chName]} {
            error "Channel \"$chName\" has different mailer name \"$mailer\""
        }
        set equatesAttr [mai_ch_equates_get $mailer]
        }
        if {[lempty $equatesAttr]} {
        error "Invalid channel \"$chName\": no delivery agent equates"
        }
        # get the forwarding host
        if {[regexp {\$@[ ]*([^ ]*)[ ]*\$:} \
        [lindex $subroutineRules 1] match host] == 1} {
            # NOTE: By convention, we always put the
            # name of the forwarding host in the $@ portion
            # of the triple.  But the cf file could be hand
            # edited to put some macro, or operator there-- these
            # are simply passed up for now, but maybe some error
            # checks should be put in?
            set forwardHostAttr $host
        }
        set attributeList [list \
        $sequenceAttr \
        $tableTypeAttr \
        $tableFileAttr \
        $forwardHostAttr \
        $equatesAttr]
        set channels($chName) $attributeList
    }
    }
}
proc mai_ch_structure_commit {} {
    global MA_SENDMAIL_FILEID MA_CH_RULESET MA_CH_TABLE_DIRECTORY channels
    set orderedNames [ma_ch_names_get]
    set numChannels [llength $orderedNames]
    set channelsRuleset ""
    loop index 1 [expr $numChannels + 1] {
    set chName [lvarpop orderedNames]
    set tableType [lindex $channels($chName) 1]
    set tableFile [lindex $channels($chName) 2]
    set forwardingHost [lindex $channels($chName) 3]
    set equateList [lindex $channels($chName) 4]
    #
    # Construct the ruleset for this channel, depending upon the table type
    #
    set thisChannelRuleset ""
    case $tableType {
        file {
        if {[clength $tableFile] == 0 || [ctype space $tableFile]} {
            error "Channel \"$chName\" has table type \"file\" but no table file defined."
        }
        append thisChannelRuleset \
        "R\$*<@\$+.>\$*\t\t\$: <\$(${chName}_MAP \$2 \$)> \$1<@\$2.>\$3\n"
        append thisChannelRuleset \
        "R<\$+.FOUND>\$+\t\t\$# $chName \$@ \$1 \$: \$2\n"
        append thisChannelRuleset \
        "R<\$+>\$+\t\t\t$@ \$2"
        # Add call to this channel's ruleset to Schannels
        append channelsRuleset "R\$*\t\t\t\$: \$>${chName} \$1\n"
        # Add the K map command too
        CF:Set $MA_SENDMAIL_FILEID map ${chName}_MAP \
            " hash -o -a.FOUND $tableFile"
        }
        local {
        append thisChannelRuleset \
        "R\$*\t\t\t\$: \$>local_TBL \$1\n"
        if {[clength $forwardingHost] == 0} {
            append thisChannelRuleset \
            "R<FOUND>\$+\t\t\$# $chName \$: \$1"
        } else {
            append thisChannelRuleset \
            "R<FOUND>\$+\t\t\$# $chName \$@ $forwardingHost \$: \$1"
        }
        # Add call to this channel's ruleset to Schannels
        append channelsRuleset "R\$*\t\t\t\$: \$>${chName} \$1\n"
        }
        baduser {
        if {$index != $numChannels} {
            error "Baduser channel \"$chName\" is not last in order"
        }
        append thisChannelRuleset \
        "R\$+\t\t\t\$: \$>baduser_TBL \$1\n"
        if {[clength $forwardingHost] == 0} {
            append thisChannelRuleset \
            "R<FOUND>\$+\t\t\$# $chName \$: \$1"
        } else {
            append thisChannelRuleset \
            "R<FOUND>\$+\t\t\$# $chName \$@ $forwardingHost \$: \$1"
        }
        # Add call to baduser ruleset to S5,
        # if not already there
        set baduserRule "\nR\$*\t\t\t\$: \$>${chName} \$1"
        set exp "\\\$>${chName}"
        set ruleset5 [CF:Get $MA_SENDMAIL_FILEID ruleset 5]
        set lastRuleset5 [lindex [split $ruleset5 "\n"] end]
        if {[regexp $exp $lastRuleset5] == 0} {
            append ruleset5 $baduserRule
            CF:Set $MA_SENDMAIL_FILEID ruleset 5 $ruleset5
        }
        }
        default {
        append thisChannelRuleset \
        "R\$*<@\$+.>\$*\t\t\$: \$>$MA_CH_RULESET($tableType) \$1<@\$2.>\$3\n"
        if {[clength $forwardingHost] == 0} {
            append thisChannelRuleset \
            "R<FOUND>\$*<@\$+.>\$*\t\$# $chName \$@ \$2 \$: \$1<@\$2.>\$3"
        } else {
            append thisChannelRuleset \
            "R<FOUND>\$*<@\$+.>\$*\t\$# $chName \$@ $forwardingHost \$: \$1<@\$2.>\$3"
        }
        # Add call to this channel's ruleset to Schannels
        append channelsRuleset "R\$*\t\t\t\$: \$>${chName} \$1\n"
        }
    }
    # Set this channel's ruleset in the cf file
    CF:Set $MA_SENDMAIL_FILEID ruleset $chName $thisChannelRuleset
    # Set the mailer for this channel
    set equateString ""
    set fields [keylkeys equateList]
    set indexA [lsearch -exact $fields "A"]
    if {$indexA != -1} {
        lvarpop fields $indexA
        set argA [keylget equateList A]
    }
    foreach field $fields {
        set arg [keylget equateList $field]
        append equateString "${field}=${arg},"
    }
    if {$indexA != -1} {
        append equateString "A=${argA}"
    }
    if {[clength $equateString] == 0} {
        error "Channel \"$chName\" has no delivery agent equates specified"
    }
    CF:Set $MA_SENDMAIL_FILEID mailer $chName \
        [string trim $equateString " \t,"]
    }
    # Set the Schannels in the cf file
    CF:Set $MA_SENDMAIL_FILEID ruleset channels \
    [string trim $channelsRuleset "\n"]
}
proc ma_ch_names_get {} {
    global MA_SENDMAIL_FILEID channels
    set result {}
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    if {[info exists channels]} {
    set allNames [array names channels]
    set result [lsort -command mai_ch_order $allNames]
    }
    return $result
}
proc ma_ch_sequence_get {chName} {
    global channels
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    return [lindex $channels($chName) 0]
}
proc ma_ch_sequence_set {chName sequence} {
    global channels MA_CH_MODIFIED
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    lvarpop channels($chName)
    lvarpush channels($chName) $sequence
    set MA_CH_MODIFIED 1
}
proc ma_ch_table_type_get {chName} {
    global channels
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    return [lindex $channels($chName) 1]
}
proc ma_ch_table_type_set {chName type} {
    global channels MA_CH_MODIFIED
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    if {[mai_ch_valid_table_type $type]} {
    lvarpop channels($chName) 1
    lvarpush channels($chName) $type 1
    set MA_CH_MODIFIED 1
    } else {
    error "Unknown channel table type \"$type\""
    }
}
proc ma_ch_table_file_get {chName} {
    global channels
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    return [lindex $channels($chName) 2]
}
proc ma_ch_table_file_set {chName file} {
    global channels MA_CH_MODIFIED
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    lvarpop channels($chName) 2
    lvarpush channels($chName) $file 2
    set MA_CH_MODIFIED 1
}
proc ma_ch_host_get {chName} {
    global channels
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    return [lindex $channels($chName) 3]
}
proc ma_ch_host_set {chName host} {
    global channels MA_CH_MODIFIED
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    lvarpop channels($chName) 3
    lvarpush channels($chName) $host 3
    set MA_CH_MODIFIED 1
}
proc ma_ch_equate_get {chName equate} {
    global channels
    set equateValue ""
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    set equateList [lindex $channels($chName) 4]
    keylget equateList $equate equateValue
    return $equateValue
}
proc ma_ch_equate_set {chName equateName equateValue} {
    global channels MA_CH_MODIFIED
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    set equateList [lindex $channels($chName) 4]
    if {[clength $equateValue] == 0} {
    set currentEquates [keylkeys equateList]
    if {[lsearch -exact $currentEquates $equateName] != -1} {
        keyldel equateList $equateName
    } else {
        return
    }
    } else {
    keylset equateList $equateName $equateValue
    }
    set oldChannel $channels($chName)
    set newChannel [lreplace $oldChannel 4 4 $equateList]
    set channels($chName) $newChannel
    set MA_CH_MODIFIED 1
}
proc ma_ch_create {chName} {
    global channels MA_CH_MODIFIED
    if {![mai_ch_valid_chars $chName]} {
    return "badname"
    }
    if {[cequal "$chName" ""]} {
    return "badname"
    }
    if {![mai_ch_valid_name $chName]} {
    return "conflict"
    }
    set sequence [llength [ma_ch_names_get]]
    set tableType "DNS"
    set tableFile ""
    set host ""
    set equates [mai_ch_default_equates]
    set channels($chName) [list $sequence $tableType $tableFile $host $equates]
    set MA_CH_MODIFIED 1
    return "ok"
}
proc ma_ch_delete {chName} {
    global MA_SENDMAIL_FILEID MA_CH_MODIFIED channels
    if {![info exists channels($chName)]} {
    error "Unknown channel \"$chName\""
    }
    CF:Unset $MA_SENDMAIL_FILEID ruleset $chName
    CF:Unset $MA_SENDMAIL_FILEID mailer $chName
    set tableType [lindex $channels($chName) 1]
    # if there is a channel table file, remove associated map config cmd
    if {[cequal $tableType "file"]} {
    CF:Unset $MA_SENDMAIL_FILEID map "${chName}_MAP"
    }
    # if this is the baduser channel, then remove subroutine call in S5
    if {[cequal $tableType "baduser"]} {
    set ruleset5 [split [CF:Get $MA_SENDMAIL_FILEID ruleset 5] "\n" ]
    set lastLine [lindex $ruleset5 end]
    if {[regexp {\$:[ ]*\$>([^ ]+)[ ]*\$1} $lastLine \
        match subroutineName] == 1 && [cequal $subroutineName $chName]} {
        lvarpop ruleset5 end
        set newRuleset5 [join $ruleset5 "\n"]
        CF:Set $MA_SENDMAIL_FILEID ruleset 5 $newRuleset5
    }
    }
    unset channels($chName)
    set MA_CH_MODIFIED 1
}
proc ma_ch_rename {oldName newName} {
    global MA_SENDMAIL_FILEID MA_CH_MODIFIED channels
    if {![info exists channels($oldName)]} {
    error "Unknown channel \"$oldName\""
    }
    if {![mai_ch_valid_chars $newName]} {
    return "badname"
    }
    if {[cequal "$newName" ""]} {
    return "badname"
    }
    if {![mai_ch_valid_name $newName]} {
    return "conflict"
    }
    # create a new channel in our internal channel data structure,
    # using the old channel's data
    set channels($newName) $channels($oldName)
    # unset the cf lines associated with the old channel
    # (we don't have to set them here-- that will be done anyway in
    # mai_ch_structure_commit)
    CF:Unset $MA_SENDMAIL_FILEID ruleset $oldName
    CF:Unset $MA_SENDMAIL_FILEID mailer $oldName
    set tableType [lindex $channels($oldName) 1]
    if {[cequal $tableType "file"]} {
    CF:Unset $MA_SENDMAIL_FILEID map "${oldName}_MAP"
    }
    # if this is the baduser channel, want to remove the last rule in
    # ruleset 5
    if {[cequal $tableType "baduser"]} {
    set ruleset5 [split [CF:Get $MA_SENDMAIL_FILEID ruleset 5] "\n" ]
    set lastLine [lindex $ruleset5 end]
    if {[regexp {\$:[ ]*\$>([^ ]+)[ ]*\$1} $lastLine \
        match subroutineName] == 1 && [cequal $subroutineName $oldName]} {
        lvarpop ruleset5 end
        set newRuleset5 [join $ruleset5 "\n"]
        CF:Set $MA_SENDMAIL_FILEID ruleset 5 $newRuleset5
    }
    }
    # remove the old channel from our internal channel data structure
    unset channels($oldName)
    set MA_CH_MODIFIED 1
    return "ok"
}
proc ma_multihome_macro_set {enable} {
    global MA_SENDMAIL_FILEID
    if {$MA_SENDMAIL_FILEID == -1} {
    error "Sendmail configuration file is not open"
    }
    if {$enable} {
    CF:Set $MA_SENDMAIL_FILEID macro V VIRTDOMAINS
    } else {
    CF:Set $MA_SENDMAIL_FILEID macro V ""
    }
}
proc ConfigFile:Open {} {
    global Config_next
    if {![info exists Config_next]} {
    set Config_next 0
    }
    set file "config$Config_next"
    incr Config_next
    upvar #0 Config_${file}_next file_next
    set file_next "1.0"
    return $file
}
proc ConfigFile:Close {file} {
    upvar #0 Config_$file fileList
    upvar #0 Config_${file}_next file_next
    unset file_next
    foreach line [ConfigFile:GetList $file] {
    unset fileList($line)
    }
}
proc ConfigFile:Compare {line1 line2} {
    set subLine1 [ctoken line1 "."]
    set subLine2 [ctoken line2 "."]
    if {$subLine1 == "" && $subLine2 == ""} {
    return 0
    } elseif {$subLine1 == ""} {
    return -1
    }  elseif {$subLine2 == ""} {
    return 1
    } elseif {$subLine1 < $subLine2} {
    return -1
    } elseif {$subLine1 > $subLine2} {
    return 1
    } else {
    set line1 [string trimleft $line1 "."]
    set line2 [string trimleft $line2 "."]
    return [ConfigFile:Compare $line1 $line2]
    }
}
proc ConfigFile:ReplaceLine {file line type id dataVar} {
    upvar #0 Config_$file fileList
    upvar #0 Config_${file}_next file_next
    upvar $dataVar data
    keylset fileList($line) type $type
    keylset fileList($line) data $data
    keylset fileList($line) id $id
    if {[ConfigFile:Compare $line $file_next] == 1} {
    set temp $line
    set file_next [ctoken temp "."]
    incr file_next
    set file_next "${file_next}.0"
    }
}
proc ConfigFile:AppendLine {file line type id dataVar} {
    upvar #0 Config_$file fileList
    upvar #0 Config_${file}_next file_next
    upvar $dataVar data
    if {$line == -1} {
    set line $file_next
    set temp [ctoken file_next "."]
    incr temp
    set file_next "${temp}.0"
    } else {
    set found 0
    set left [ctoken line "."]
    set right [ctoken line "."]
    if {$right == "0"} {
        set tryNext $left
        incr tryNext
        set tryNext "${tryNext}.0"
        if {![info exists fileList($tryNext)]} {
        set found 1
        }
    }
    if {!$found} {
        set lastDigit [cindex $right end]
        if {$lastDigit < 9} {
            incr lastDigit
            set tryNext "${left}.[csubstr $right 0 end]${lastDigit}"
            if {![info exists fileList($tryNext)]} {
            set found 1
            }
        }
    }
    if {!$found} {
        set leadingZeros ""
        set tryNext "${left}.${right}.1"
        while {[info exists fileList($tryNext)]} {
        set leadingZeros "${leadingZeros}.0"
        set tryNext "${left}.${right}${leadingZeros}.1"
        }
    }
    set line $tryNext
    }
    keylset fileList($line) type $type
    keylset fileList($line) id $id
    keylset fileList($line) data $data
    if {[string compare $line $file_next] == 1} {
    set temp $line
    set file_next [ctoken temp "."]
    incr file_next
    set file_next "${file_next}.0"
    }
    return $line
}
proc ConfigFile:GetLine {file line typeVar idVar dataVar} {
    upvar #0 Config_$file fileList
    upvar $typeVar type
    upvar $idVar id
    upvar $dataVar data
    if {![info exists fileList($line)]} {
    set type {}
    set id {}
    set data {}
    return -1
    }
    keylget fileList($line) type type
    keylget fileList($line) id id
    keylget fileList($line) data data
    return 0
}
proc ConfigFile:RemoveLine {file line} {
    upvar #0 Config_$file fileList
    if {![info exists fileList($line)]} {
    # already gone
    return
    }
    unset fileList($line)
}
proc ConfigFile:GetList {file} {
    upvar #0 Config_$file fileList
    if {![info exists fileList]} {
    return {}
    }
    return [lsort -command ConfigFile:Compare [array names fileList]]
}
proc Table:ProcessLine {fileID type id data} {
    global Table_lastType Table_lastID
    set lineNum [ConfigFile:AppendLine $fileID -1 $type $id data]
    if {[Table:GetOption $fileID makelower] != {}} {
    set id [string tolower $id]
    }
    case $type {
    CONTINUATION {
        set type $Table_lastType
        set id $Table_lastID
    }
    COMMENT {
    }
    default {
        set Table_lastType $type
        set Table_lastID $id
    }
    }
    if {$id != {}} {
    upvar #0 Table_${fileID}_$type typeList
    lappend typeList($id) $lineNum
    }
}
proc Table:Read {fileName callBack mode} {
    global Table_info
    if {[info exists Table_info($fileName.ID)]} {
    return $Table_info($fileName.ID)
    }
    set fileID [ConfigFile:Open]
    set Table_info($fileID.mode) $mode
    if {![file exists $fileName]} {
    return $fileID
    }
    set fp [open $fileName r]
    set Table_info($fileName.ID) $fileID
    set Table_info($fileID.fileName) $fileName
    eval $callBack $fileID $fp
    close $fp
    return $fileID
}
proc Table:Write {fileID {fileName {}} {callBack {}}} {
    global Table_info
    if {[info exists Table_info($fileID.deferred)]} {
    return
    }
    if {![info exists Table_info($fileID.modified)] && $fileName == {}} {
    return
    }
    if {$callBack == {}} {
    set callBack $Table_info($fileID.writeCB)
    }
    if {$fileName == {}} {
    set fileName $Table_info($fileID.fileName)
    set clearModified 1
    } else {
    set clearModified 0
    }
    #
    # If the file exists, make sure the new file has the
    # same owner and perms.  Otherwise, make sure the
    # parent directory exists.
    #
    if {[file exists $fileName]} {
    file stat $fileName info
    set Table_info($fileID.uid) $info(uid)
    set Table_info($fileID.gid) $info(gid)
    set Table_info($fileID.mode) $info(mode)
    } else {
    set directory [file dirname $fileName]
    set oldUmask [umask]
    umask 0222
    if {![file isdirectory $directory]} {
        mkdir -path $directory
    }
    umask $oldUmask
    }
    set fp [open ${fileName}.new w]
    chmod $Table_info($fileID.mode) ${fileName}.new
    if {[info exists Table_info($fileID.uid)]} {
    chown [list $Table_info($fileID.uid) $Table_info($fileID.gid)] \
        ${fileName}.new
    }
    foreach line [ConfigFile:GetList $fileID] {
    if {[ConfigFile:GetLine $fileID $line type id data] != 0} {
        continue
    }
    eval "$callBack $fileID $fp {$type} {$id} {$data}"
    }
    close $fp
    if {[file exists $fileName]} {
    unlink $fileName
    }
    frename ${fileName}.new $fileName
    if {$clearModified} {
    unset Table_info($fileID.modified)
    }
}
proc Table:Open {fileName readCB writeCB {mode 0666}} {
    global Table_info
    set fileID [Table:Read $fileName $readCB $mode]
    set Table_info($fileID.fileName) $fileName
    set Table_info($fileID.readCB) $readCB
    set Table_info($fileID.writeCB) $writeCB
    set Table_info($fileName.ID) $fileID
    return $fileID
}
proc Table:Close {fileID {fileName {}}} {
    global Table_info
    if {![info exists Table_info($fileID.fileName)]} {
    return
    }
    if {[info exists Table_info($fileID.deferred)]} {
    unset Table_info($fileID.deferred)
    }
    Table:Write $fileID $fileName $Table_info($fileID.writeCB)
    if {$fileName == {}} {
    set fileName $Table_info($fileID.fileName)
    }
    unset Table_info($fileID.fileName)
    unset Table_info($fileName.ID)
    ConfigFile:Close $fileID
}
proc Table:CloseNoWrite {fileID {fileName {}}} {
    global Table_info
    if {![info exists Table_info($fileID.fileName)]} {
    return
    }
    if {[info exists Table_info($fileID.deferred)]} {
    unset Table_info($fileID.deferred)
    }
    if {$fileName == {}} {
    set fileName $Table_info($fileID.fileName)
    }
    unset Table_info($fileID.fileName)
    unset Table_info($fileName.ID)
    ConfigFile:Close $fileID
}
proc Table:DeferWrites {fileID} {
    global Table_info
    set Table_info($fileID.deferred) 1
}
proc Table:ForceWrites {fileID} {
    global Table_info
    if {[info exists Table_info($fileID.deferred)]} {
    unset Table_info($fileID.deferred)
    }
    set Table_info($fileID.modified) 1
}
proc Table:SetOption {fileID option {value 1}} {
    global Table_options
    set Table_options($fileID.$option) $value
}
proc Table:HasOption {fileID option} {
    return [info exists Table_options($fileID.$option)]
}
proc Table:GetOption {fileID option} {
    global Table_options
    if {![info exists Table_options($fileID.$option)]} {
    return {}
    }
    return $Table_options($fileID.$option)
}
proc Table:Modified {fileID} {
    global Table_info
    if {[info exists Table_info($fileID.modified)]} {
    return $Table_info($fileID.modified)
    } else {
    return 0
    }
}
proc Table:GetLineList {fileID type {idList {}}} {
    upvar #0 Table_${fileID}_$type typeList
    if {![info exists typeList]} {
    return {}
    }
    if {$idList == {}} {
    set idList [array names typeList]
    }
    set lineList {}
    foreach id $idList {
    if {[info exists typeList($id)]} {
        append lineList " $typeList($id)"
    }
    }
    return [lsort -command ConfigFile:Compare $lineList]
}
proc Table:Get {fileID type id {separator {}}} {
    upvar #0 Table_${fileID}_$type typeList
    if {[Table:GetOption $fileID makelower] != {}} {
    set id [string tolower $id]
    }
    set value {}
    if {![info exists typeList($id)]} {
    return $value
    }
    set numLines [llength [Table:GetLineList $fileID $type $id]]
    set thisLine 1
    foreach line $typeList($id) {
    ConfigFile:GetLine $fileID $line dummy dummy data
    if {$thisLine == $numLines} {
        append value "$data"
    } else {
        set data [string trim $data "$separator"]
        append value "$data$separator"
    }
    incr thisLine
    }
    set value [string trimleft $value $separator]
    return $value
}
proc Table:Set {fileID type id data} {
    upvar #0 Table_${fileID}_${type} typeList
    global Table_info
    global Table_lastType Table_lastID
    set name $id
    if {[Table:GetOption $fileID makelower] != {}} {
    set id [string tolower $id]
    }
    if {[info exists typeList($id)]} {
    foreach line $typeList($id) {
        ConfigFile:RemoveLine $fileID $line
    }
    set line [lindex $typeList($id) 0]
    unset typeList($id)
    } else {
    if {[set lineList [Table:GetLineList $fileID $type]] != {}} {
        set line [lindex $lineList end]
    } else {
        if {[Table:GetOption $fileID newFirst] == 1} {
        set line 0
        } else {
        set line -1
        }
    }
    }
    lappend typeList($id) [ConfigFile:AppendLine $fileID $line \
    $type $name data]
    set Table_lastType $type
    set Table_lastID $id
    set Table_info($fileID.modified) 1
}
proc Table:Unset {fileID type id} {
    upvar #0 Table_${fileID}_$type typeList
    global Table_info
    if {[Table:GetOption $fileID makelower] != {}} {
    set id [string tolower $id]
    }
    if {![info exists typeList($id)]} {
    return
    }
    foreach line $typeList($id) {
    ConfigFile:RemoveLine $fileID $line
    }
    unset typeList($id)
    set Table_info($fileID.modified) 1
}
proc Table:AppendLine {fileID type id value {line {}}} {
    global Table_lastType Table_lastID
    global Table_info
    if {$type == "CONTINUATION"} {
    upvar #0 Table_${fileID}_$Table_lastType typeList
    } else {
    upvar #0 Table_${fileID}_$type typeList
    }
    if {[Table:GetOption $fileID makelower] != {}} {
    set id [string tolower $id]
    }
    if {$line == ""} {
    if {[info exists typeList($id)]} {
        set line [lindex $typeList($id) end]
    } else {
        if {[set lineList [Table:GetLineList $fileID $type]] == {}} {
        set line [lindex $lineList end]
        } else {
        if {[Table:GetOption $fileID newFirst] == 1} {
            set line 0
        } else {
            set line -1
        }
        }
    }
    }
    if {$type == "CONTINUATION"} {
    lappend typeList($id) \
        [ConfigFile:AppendLine $fileID $line $type {} value]
    } else {
    lappend typeList($id) \
        [ConfigFile:AppendLine $fileID $line $type $id value]
    }
    set Table_info($fileID.modified) 1
}
proc Table:RemoveLine {fileID type id deleteLine} {
    upvar #0 Table_${fileID}_$type typeList
    global Table_info
    if {[Table:GetOption $fileID makelower] != {}} {
    set id [string tolower $id]
    }
    if {![info exists typeList($id)]} {
    return
    }
    set index 0
    foreach line $typeList($id) {
    if {$line == $deleteLine} {
        lvarpop typeList($id) $index
        ConfigFile:RemoveLine $fileID $line
        break
    }
    incr index
    }
    set Table_info($fileID.modified) 1
}
proc Table:ReplaceLine {fileID type replaceLine id data} {
    global Table_info
    upvar #0 Table_${fileID}_$type typeList
    if {[ConfigFile:GetLine $fileID $replaceLine oldType oldId oldData] == 0} {
    if {$oldId != ""} {
            upvar #0 Table_${fileID}_$oldType oldTypeList
        set index [lsearch -exact $oldTypeList($oldId) $replaceLine]
        if {$index != -1} {
        lvarpop oldTypeList($oldId) $index
        if {[lempty $oldTypeList($oldId)]} {
            unset oldTypeList($oldId)
        }
        }
    }
    }
    ConfigFile:ReplaceLine $fileID $replaceLine $type $id data
    if {$id != ""} {
    if {![info exists typeList($id)]} {
        set typeList($id) {}
    }
    lappend typeList($id) $replaceLine
    }
    set Table_info($fileID.modified) 1
}
proc Table:List {fileID type {ordered 0}} {
    upvar #0 Table_${fileID}_$type typeList
    if {![info exists typeList]} {
    return {}
    }
    if {[Table:GetOption $fileID makelower] == {} && $ordered == 0} {
    return [array names typeList]
    }
    #
    # We have to go get the original ids from before they were converted
    # to lower case, or they want the ids in the order they appear anyway.
    #
    set returnList {}
    foreach line [Table:GetLineList $fileID $type] {
    ConfigFile:GetLine $fileID $line dummy id dummy
    append returnList " $id"
    }
    return [string trimleft $returnList]
}
set versionNumber [SaGetSSOVersion]
set RESPATH /etc/mail/admin/px
set PID [pid]
set ME "/etc/mail/admin/mailadmin"
set MAILDEF /etc/default/mail
set MAILDEFTMP /tmp/mail$PID
set MAILDEFDEF /etc/mail/mail.factory
set MAILCF /etc/sendmail.cf
set MAILCFTMP /tmp/sendmail.cf$PID
set MAILCFDEF /etc/mail/sendmailcf.factory
set UUCP /usr/lib/uucp/Systems
set UUCPDB /etc/mail/table/uucp.db
set MAILTABLE /etc/mail/table
set MAILALIASES /etc/mail/aliases
set ALIAS_EDITOR /etc/mail/admin/aliases
set CTABLE_EDITOR /etc/mail/admin/channel
set DTABLE_EDITOR /etc/mail/admin/domain
set MAKEMAP /etc/mail/makemap
set SENDMAILPID /etc/sendmail.pid
set SLOCAL /etc/mail/slocal
set UUX /usr/bin/uux
set MULTIHOME /etc/mail/multihome
set MDOMAINDB /var/internet/ip/127.0.0.1/mail/virtdomains
set MQUEUE /var/spool/mqueue
set MAILSPOOL /var/mail
set INBOXNAME .mailbox
set mag_iconinit 0
set main_list_length 0
set RESOLVER /usr/sbin/host
set mag_host_name [mag_host_local]
set mag_local_host $mag_host_name
set MS(class) 0
set MS(name) 1
set MS(type) 2
set MS(level) 3
set MS(action) 4
set MS(label) 5
set MS(value) 6
set MS(state) 6
set MS(criteria) 7
set MS(chname) 8
set MS(custom) 8
proc \
mag_display_item { index } \
{
    global main_list mainscreen_db MS
    set list [lindex $mainscreen_db $index]
    set class [lindex $list $MS(class)]
    set name [lindex $list $MS(name)]
    set type [lindex $list $MS(type)]
    set level [lindex $list $MS(level)]
    set action [lindex $list $MS(action)]
    set label [lindex $list $MS(label)]
    if {"$class" == "container"} {
        set container 1
        set state [lindex $list $MS(state)]
        if {"$state" == "open"} {
            set container 2
        }
    } else {
        set container 0
        set value [lindex $list $MS(value)]
        if {[llength $list] == 8} {
            set criteria [lindex $list $MS(criteria)]
        } else {
            set criteria ""
        }
    }
    # make iconlist and formatlist
    #
    # to do this we need to check at each level if
    # equal or higher levels of indents occur for each
    # level we are already at, simulating a parent-child
    # relationship for each level, only two levels supported here.
    # any more indent level one children?
    set more1children 0
    set length [llength $mainscreen_db]
    loop j [expr $index + 1] $length {
        set nextlist [lindex $mainscreen_db $j]
        set nextlevel [lindex $nextlist $MS(level)]
        if {$nextlevel == 2} {
            continue
        }
        if {$nextlevel == 0} {
            break
        }
        if {$nextlevel == 1} {
            set more1children 1
            break
        }
        error "Unknown indent level 1 $nextlevel"
    }
    set more2children 0
    loop j [expr $index + 1] $length {
        set nextlist [lindex $mainscreen_db $j]
        set nextlevel [lindex $nextlist $MS(level)]
        if {$nextlevel == 1} {
            break
        }
        if {$nextlevel == 0} {
            break
        }
        if {$nextlevel == 2} {
            set more2children 1
            break
        }
        error "Unknown indent level 2 $nextlevel"
    }
    # now we index a table of icons to draw using the values
    # container, level, more1children and more2children.
    set icons [mag_get_icons $container $level \
        $more1children $more2children]
    # now build formatlist and fieldlist
    set formatlist ""
    set fieldlist ""
    foreach j $icons {
        # all our icons are two chars wide
        lappend formatlist "ICON 1"
        lappend fieldlist $j
    }
    if {"$class" == "container"} {
        lappend formatlist "STRING 75"
        lappend fieldlist $label
    } else {
        lappend formatlist "STRING 46"
        lappend fieldlist $label:
        set len [clength $value]
        set len [expr $len + 2]
        lappend formatlist "STRING $len"
        lappend fieldlist $value
    }
    return [list $fieldlist $formatlist]
}
proc \
mag_display_mainlist { start stop index } \
{
    global main_list mainscreen_db MS
    set length [llength $mainscreen_db]
    if {$stop == 0} {
        set stop $length
    }
    loop i $start $stop {
        set list [mag_display_item $i]
        set fieldlist [lindex $list 0]
        set formatlist [lindex $list 1]
        set position [expr $i + 1]
        VtDrawnListSetItem $main_list \
            -position $position \
            -fieldList $fieldlist \
            -formatList $formatlist
    }
    if {$index >= 0} {
        set select [expr $index + 1]
        VtDrawnListSelectItem $main_list -position $select
        mao_select $index
    }
}
proc \
mag_insert_mainlist { index count } \
{
    global main_list
    loop i 0 $count {
        set item [expr $index + $i + 1]
        set list [mag_display_item $item]
        set fieldlist [lindex $list 0]
        set formatlist [lindex $list 1]
        set position [expr $index + $i + 2]
        VtDrawnListAddItem $main_list -position $position \
            -fieldList $fieldlist -formatList $formatlist
    }
}
proc \
mag_delete_mainlist { index count } \
{
    global main_list
    set delete [expr $index + 2]
    set deletelist ""
    loop i 0 $count {
        lappend deletelist [expr $delete + $i]
    }
    VtDrawnListDeleteItem $main_list -positionList $deletelist
}
proc \
mag_get_icons { con in c1 c2 } \
{
    global mag_iconarray mag_iconinit
    if {$mag_iconinit == 0} {
        # last two bits are don't care for these,
        # but we have to set them all.
        set mag_iconarray("0000") 0
        set mag_iconarray("0001") 0
        set mag_iconarray("0010") 0
        set mag_iconarray("0011") 0
        # last bit is don't care for these
        set mag_iconarray("1000") 1
        set mag_iconarray("1001") 1
        set mag_iconarray("2000") 9
        set mag_iconarray("2001") 9
        set mag_iconarray("1010") 2
        set mag_iconarray("1011") 2
        set mag_iconarray("2010") 10
        set mag_iconarray("2011") 10
        set mag_iconarray("0100") [list 5 8]
        set mag_iconarray("0101") [list 5 8]
        set mag_iconarray("0110") [list 6 8]
        set mag_iconarray("0111") [list 6 8]
        # all bits are significant for the rest
        # containers
        set mag_iconarray("1100") [list 5 3]
        set mag_iconarray("1101") [list 5 4]
        set mag_iconarray("1110") [list 6 3]
        set mag_iconarray("1111") [list 6 4]
        set mag_iconarray("2100") [list 5 11]
        set mag_iconarray("2101") [list 5 12]
        set mag_iconarray("2110") [list 6 11]
        set mag_iconarray("2111") [list 6 12]
        # simple objects
        set mag_iconarray("0200") [list 0 5 8]
        set mag_iconarray("0201") [list 0 6 8]
        set mag_iconarray("0210") [list 7 5 8]
        set mag_iconarray("0211") [list 7 6 8]
        set mag_iconinit 1
    }
    set key "$con$in$c1$c2"
    set icons $mag_iconarray("$key")
    return $icons
}
proc \
mag_build_widgets { parent } \
{
    global RESPATH main_list status_line
    global btn_mod btn_add btn_del btn_up btn_dn
    global menu_mod menu_add menu_del menu_up menu_dn
    global mag_host_name mag_host_label
    # menubar
    set menuBar [VtMenuBar $parent.menubar \
        -helpMenuItemList [SaHelpGetOptionsList]]
    set hostMenu [VtPulldown $menuBar.hostMenu -label [mag_msg MENU_HOST] \
        -mnemonic [mag_msg MENU_HOST_MN]]
    VtPushButton $hostMenu.open -label [mag_msg MENU_OPEN] \
        -mnemonic [mag_msg MENU_OPEN_MN] \
        -callback mag_open_host_cb \
        -shortHelpString [mag_msg SHORT_OPEN] \
        -shortHelpCallback mag_short_help
    VtPushButton $hostMenu.exit -label [mag_msg MENU_EXIT] \
        -mnemonic [mag_msg MENU_EXIT_MN] \
        -callback "quit_cb 1"\
        -shortHelpString [mag_msg SHORT_EXIT] \
        -shortHelpCallback mag_short_help
    set editMenu [VtPulldown $menuBar.editMenu -label [mag_msg MENU_EDIT] \
        -mnemonic [mag_msg MENU_EDIT_MN]]
    set menu_mod [VtPushButton $editMenu.Mod -label [mag_msg MENU_MOD] \
        -mnemonic [mag_msg MENU_MOD_MN] \
        -callback mag_modify_cb \
        -shortHelpString [mag_msg SHORT_MOD] \
        -shortHelpCallback mag_short_help]
    VtSeparator $editMenu.sep1
    set menu_add [VtPushButton $editMenu.Add -label [mag_msg MENU_ADD] \
        -mnemonic [mag_msg MENU_ADD_MN] \
        -callback mag_add_cb \
        -shortHelpString [mag_msg SHORT_ADD] \
        -shortHelpCallback mag_short_help]
    set menu_del [VtPushButton $editMenu.del -label [mag_msg MENU_DEL] \
        -mnemonic [mag_msg MENU_DEL_MN] \
        -callback mag_delete_cb \
        -shortHelpString [mag_msg SHORT_DEL] \
        -shortHelpCallback mag_short_help]
    VtSeparator $editMenu.sep2
    set menu_up [VtPushButton $editMenu.up -label [mag_msg MENU_UP] \
        -mnemonic [mag_msg MENU_UP_MN] \
        -callback mag_up_cb \
        -shortHelpString [mag_msg SHORT_UP] \
        -shortHelpCallback mag_short_help]
    set menu_dn [VtPushButton $editMenu.dn -label [mag_msg MENU_DN] \
        -mnemonic [mag_msg MENU_DN_MN] \
        -callback mag_down_cb \
        -shortHelpString [mag_msg SHORT_DN] \
        -shortHelpCallback mag_short_help]
    set setMenu [VtPulldown $menuBar.setMenu -label [mag_msg MENU_SET] \
        -mnemonic [mag_msg MENU_SET_MN]]
    VtPushButton $setMenu.def -label [mag_msg MENU_DEF] \
        -mnemonic [mag_msg MENU_DEF_MN] \
        -callback mag_default_cb \
        -shortHelpString [mag_msg SHORT_DEF] \
        -shortHelpCallback mag_short_help
    VtPushButton $setMenu.badhost -label [mag_msg MENU_BADHOST] \
        -mnemonic [mag_msg MENU_BADHOST_MN] \
        -callback mag_badhost_cb \
        -shortHelpString [mag_msg SHORT_BADHOST] \
        -shortHelpCallback mag_short_help
    VtPushButton $setMenu.baduser -label [mag_msg MENU_BADUSER] \
        -mnemonic [mag_msg MENU_BADUSER_MN] \
        -callback mag_baduser_cb \
        -shortHelpString [mag_msg SHORT_BADUSER] \
        -shortHelpCallback mag_short_help
    VtPushButton $setMenu.uucp -label [mag_msg MENU_UUCP] \
        -mnemonic [mag_msg MENU_UUCP_MN] \
        -callback mag_uucp_cb \
        -shortHelpString [mag_msg SHORT_UUCP] \
        -shortHelpCallback mag_short_help
    VtPushButton $setMenu.mhome -label [mag_msg MENU_MHOME] \
        -mnemonic [mag_msg MENU_MHOME_MN] \
        -callback mag_mhome_cb \
        -shortHelpString [mag_msg SHORT_MHOME] \
        -shortHelpCallback mag_short_help
    # toolbar widget
    if {[VtInfo -charm] == 0} {
        set frameBar [VtFrame $parent.framebar \
            -topSide $menuBar \
            -topOffset 1 \
            -leftSide FORM \
            -leftOffset 2 \
            -rightSide FORM \
            -rightOffset 2 \
            -marginWidth 0 \
            -marginHeight 0 \
            -horizontalSpacing 0 \
            -verticalSpacing 0 \
            -shadowType IN \
        ]
        set toolBar [VtForm $frameBar.toolbar \
            -leftSide FORM \
            -rightSide FORM \
            -borderWidth 0 \
            -marginHeight 0 \
            -marginWidth 0 \
            -horizontalSpacing 0 \
            -verticalSpacing 0 \
        ]
        set btn_mod [VtPushButton $toolBar.mod \
            -label [mag_msg MENU_MOD] \
            -leftSide FORM \
            -topSide FORM \
            -bottomSide FORM \
            -callback mag_modify_cb \
            -shortHelpString [mag_msg SHORT_MOD] \
            -shortHelpCallback mag_short_help \
        ]
        set tmp1 [VtLabel $toolBar.sep1 \
            -label "  " \
            -leftSide $btn_mod \
            -topSide FORM \
        ]
        set btn_add [VtPushButton $toolBar.add \
            -label [mag_msg MENU_ADD] \
            -leftSide $tmp1 \
            -topSide FORM \
            -bottomSide FORM \
            -callback mag_add_cb \
            -shortHelpString [mag_msg SHORT_ADD] \
            -shortHelpCallback mag_short_help \
        ]
        set btn_del [VtPushButton $toolBar.del \
            -label [mag_msg MENU_DEL] \
            -leftSide $btn_add \
            -topSide FORM \
            -bottomSide FORM \
            -callback mag_delete_cb \
            -shortHelpString [mag_msg SHORT_DEL] \
            -shortHelpCallback mag_short_help \
        ]
        set tmp2 [VtLabel $toolBar.sep2 \
            -label "  " \
            -leftSide $btn_del \
            -topSide FORM \
        ]
        set btn_up [VtPushButton $toolBar.up -pixmap $RESPATH/prev.px \
            -callback mag_up_cb \
            -leftSide $tmp2 \
            -topSide FORM \
            -shortHelpString [mag_msg SHORT_UP] \
            -shortHelpCallback mag_short_help \
        ]
        set btn_dn [VtPushButton $toolBar.dn -pixmap $RESPATH/next.px \
            -callback mag_down_cb \
            -leftSide $btn_up \
            -topSide FORM \
            -rightSide NONE \
            -shortHelpString [mag_msg SHORT_DN] \
            -shortHelpCallback mag_short_help \
        ]
    }
    # Top status line
    set mag_host_label [VtLabel $parent.toplab \
        -leftSide FORM -rightSide FORM \
        -label [mag_msg1 TITLE $mag_host_name] \
    ]
    # list widget
    set main_list [VtDrawnList $parent.list -columns 78 -rows 16 \
        -autoSelect TRUE -selection BROWSE \
        -callback mag_select_cb \
        -defaultCallback mag_activate_cb \
        -leftSide FORM -rightSide FORM \
        -horizontalScrollBar 1 \
        -iconList [list \
            $RESPATH/blank.px \
            $RESPATH/folder_alone.px \
            $RESPATH/folder_has.px \
            $RESPATH/folder_next_alone.px \
            $RESPATH/folder_next_has.px \
            $RESPATH/item_last.px \
            $RESPATH/item_middle.px \
            $RESPATH/vbar.px \
            $RESPATH/hbar.px \
            $RESPATH/folder_open_alone.px \
            $RESPATH/folder_open_has.px \
            $RESPATH/folder_open_next_alone.px \
            $RESPATH/folder_open_next_has.px \
        ]]
    # status line
    set status_line [SaStatusBar $parent.status 1]
    SaStatusBarSet $status_line [mag_msg LOADING]
    VtSetValues $main_list -bottomSide $status_line
}
proc \
mag_open_host_cb { cbs } \
{
    VtLock
    mag_open_host
    VtUnLock
}
proc \
mag_select_cb { cbs } \
{
    VtLock
    set index [keylget cbs itemPosition]
    set index [expr $index - 1]
    mao_select $index
    VtUnLock
}
proc \
mag_activate_cb { cbs } \
{
    VtLock
    set index [keylget cbs itemPosition]
    set index [expr $index - 1]
    mao_activate $index
    VtUnLock
}
proc \
mag_default_cb { cbs } \
{
    global main_list
    VtLock
    set index [VtDrawnListGetSelectedItem $main_list]
    set index [expr $index - 1]
    mao_default $index yes
    VtUnLock
}
proc \
mag_modify_cb { cbs } \
{
    global main_list
    VtLock
    set index [VtDrawnListGetSelectedItem $main_list]
    set index [expr $index - 1]
    mao_activate $index
    VtUnLock
}
proc \
mag_add_cb { cbs } \
{
    global main_list
    VtLock
    set index [VtDrawnListGetSelectedItem $main_list]
    set index [expr $index - 1]
    mao_add $index
    VtUnLock
}
proc \
mag_delete_cb { cbs } \
{
    global main_list
    VtLock
    set index [VtDrawnListGetSelectedItem $main_list]
    set index [expr $index - 1]
    mao_delete $index
    VtUnLock
}
proc \
mag_up_cb { cbs } \
{
    global main_list
    VtLock
    set index [VtDrawnListGetSelectedItem $main_list]
    set index [expr $index - 1]
    mao_move $index up
    VtUnLock
}
proc \
mag_down_cb { cbs } \
{
    global main_list
    VtLock
    set index [VtDrawnListGetSelectedItem $main_list]
    set index [expr $index - 1]
    mao_move $index down
    VtUnLock
}
proc \
mag_badhost_cb { cbs } \
{
    VtLock
    mao_badhost
    VtUnLock
}
proc \
mag_baduser_cb { cbs } \
{
    VtLock
    mao_baduser
    VtUnLock
}
proc \
mag_uucp_cb { cbs } \
{
    VtLock
    mao_uucp
    VtUnLock
}
proc \
mag_mhome_cb { cbs } \
{
    VtLock
    mao_mhome
    VtUnLock
}
proc \
mag_short_help { cbs } \
{
    global status_line
    set helpstring [keylget cbs helpString]
    SaStatusBarSet $status_line $helpstring
}
proc \
mag_cf_get {} \
{
    global MAILCF MAILCFTMP MAILCFDEF DIRTY
    system "rm -fr $MAILCFTMP"
    set ret [mag_remote_copyin $MAILCF $MAILCFTMP]
    if {$ret != "ok"} {
        VtUnLock
        set ret [mag_query_eyn CF_COPY_OUT $MAILCF]
        VtLock
        if {$ret == "no"} {
            return no
        }
        # restore factory file
        VtUnLock
        set ret [mag_local_copy $MAILCFDEF $MAILCFTMP]
        VtLock
        if {$ret != "ok"} {
            VtUnLock
            mag_error1 CF_FACTORY_RESTORE $MAILCF
            VtLock
            return fail
        }
        set DIRTY 1
    } else {
        # validate old file
        if {[ma_cf_valid $MAILCFTMP] == "fail"} {
            # invalid old file
            VtUnLock
            set ret [mag_query_eyn CF_INVALID $MAILCF]
            VtLock
            if {$ret == "no"} {
                return no
            }
        }
    }
    # ready to attempt open.
    set ret start
    while {"$ret" != "ok"} {
        set ret [ma_cf_open $MAILCFTMP]
        switch $ret {
        "ok"    {
        }
        "fail"    {
            VtUnLock
            mag_error1 CF_OPEN_FAIL $MAILCFTMP
            VtLock
            return fail
        }
        "parserr" {
            VtUnLock
            set ret [mag_query_eyn CF_PARSE $MAILCF]
            VtLock
            if {$ret == "no"} {
                return no
            }
            # restore factory file
            set ret [mag_local_copy $MAILCFDEF $MAILCFTMP]
            if {$ret != "ok"} {
                VtUnLock
                mag_error1 CF_FACTORY_RESTORE $MAILCF
                VtLock
                return fail
            }
            set ret retry
            set DIRTY 1
        }
        }
    }
    return ok
}
proc \
mag_ms1_get {} \
{
    global MAILDEF MAILDEFTMP MAILDEFDEF DIRTY
    system "rm -fr $MAILDEFTMP"
    set ret [mag_remote_copyin $MAILDEF $MAILDEFTMP]
    if {$ret != "ok"} {
        VtUnLock
        set ret [mag_query_eyn CF_COPY_OUT $MAILDEF]
        VtLock
        if {$ret == "no"} {
            return no
        }
        # restore factory file
        set ret [mag_local_copy $MAILDEFDEF $MAILDEFTMP]
        if {$ret != "ok"} {
            VtUnLock
            mag_error1 CF_FACTORY_RESTORE $MAILDEF
            VtLock
            return fail
        }
        set DIRTY 1
    }
    # ready to attempt open.
    set ret start
    while {"$ret" != "ok"} {
        set ret [ma_ms1_open $MAILDEFTMP]
        switch $ret {
        "ok"     {
        }
        "fail"    {
            VtUnLock
            mag_error1 CF_OPEN_FAIL $MAILDEFTMP
            VtLock
            return fail
        }
        "parserr" {
            VtUnLock
            set ret [mag_query_eyn MS1_PARSE $MAILDEF]
            VtLock
            if {$ret == "yes"} {
                # restore factory file
                set ret [mag_local_copy $MAILDEFDEF $MAILDEFTMP]
                if {$ret != "ok"} {
                    VtUnLock
                    mag_error1 CF_FACTORY_RESTORE $MAILDEF
                    VtLock
                    return fail
                }
                # to re-load the new MAILDEFTMP
                set ret "parserr"
            } else {
                set ret "ok"
            }
            set DIRTY 1
        }
        }
    }
    return ok
}
proc \
mag_all_put {} \
{
    global app DIRTY
    global MAILCF MAILCFTMP MAILDEF MAILDEFTMP
    set saved 0
    if {$DIRTY == 1} {
        VtUnLock
        set ret [mag_query_qync DIRTY notused]
        VtLock
        if {"$ret" == "cancel"} {
            return cancel
        }
        if {"$ret" == "yes"} {
            set ret [ma_cf_write]
            if {"$ret" != "ok"} {
                VtUnLock
                mag_query_eok CF_WRITE $MAILCFTMP
                VtLock
                return fail
            }
            set ret [mag_remote_copyout $MAILCFTMP $MAILCF]
            if {"$ret" != "ok"} {
                VtUnLock
                mag_query_eok COPY_BACK $MAILCF
                VtLock
                return fail
            }
            set ret [ma_ms1_write]
            if {"$ret" != "ok"} {
                VtUnLock
                mag_query_eok CF_WRITE $MAILDEFTMP
                VtLock
                return fail
            }
            set ret [mag_remote_copyout $MAILDEFTMP $MAILDEF]
            if {"$ret" != "ok"} {
                VtUnLock
                mag_query_eok COPY_BACK $MAILDEF
                VtLock
                return fail
            }
            set saved 1
        }
        set DIRTY 0
    }
    mag_rebuild_uucp_map yes
    if {"$saved" == 1} {
        mag_restart_sendmail yes
    }
    return ok
}
proc \
mag_remoteCommand {host cmd args errMsgId} \
{
        set class    [list sco remoteCommand]
        set instance [GetInstanceList NULL $host]
        set command [list ObjectAction $class $instance $cmd $args]
        set result [SaMakeObjectCall $command]
        set result [lindex $result 0]
        if { [BmipResponseErrorIsPresent result] } {
        set errorStack [BmipResponseErrorStack result]
        set topErrorCode [lindex [lindex $errorStack 0] 0]
        if { $topErrorCode != "SCO_SA_ERRHANDLER_ERR_CONNECT_FAIL" } {
            ErrorPush errorStack 1 $errMsgId
            return {}
        } else {
            ErrorThrow errorStack
            return
        }
    }
    set retVal [BmipResponseActionInfo result]
    return $retVal
}
proc \
mag_authorized {host} \
{
    set uid [id effective userid]
    if {$uid != 0} {
        set cmd "/sbin/tfadmin"
        set args1 "-t mailadmin"
        set args2 "-t cpfile"
        set args3 "-t kill"
        if {[ErrorCatch errStack 0 {mag_remoteCommand $host \
            $cmd $args1 SCO_MAIL_ADMIN_ERR_TFADMIN} ret1] || \
            [ErrorCatch errStack 0 {mag_remoteCommand $host \
            $cmd $args2 SCO_MAIL_ADMIN_ERR_TFADMIN} ret2] || \
            [ErrorCatch errStack 0 {mag_remoteCommand $host \
            $cmd $args3 SCO_MAIL_ADMIN_ERR_TFADMIN} ret3]} {
            return fail
        }
    }
    return ok
}
proc \
quit_cb { {save {}} cbs  } \
{
    global status_line
    set ret "ok"
    # save everything
    if {"$save" == "" || $save == 1} {
        VtLock
        SaStatusBarSet $status_line [mag_msg SAVING]
        set ret [mag_all_put]
        VtUnLock
    }
    switch $ret {
    "ok" {
        quit
    }
    "fail" {
        return
    }
    "cancel" {
        return
    }
    }
    error "unknown quit"
}
proc \
quit {} \
{
    VtClose
    cleanup
    exit 0
}
proc \
cleanup {} \
{
    global MAILDEFTMP MAILCFTMP
    system "rm -fr $MAILDEFTMP $MAILCFTMP"
}
proc \
main {} \
{
    global app DIRTY status_line main_list outerMainForm mainscreen_db
    global mag_host_name versionNumber
    # if command line mode, this routine does not return
    mag_cmd_line_main
    mag_setcat SCO_MAIL_ADMIN
    set app [VtOpen mailadmin [mag_msg HELPBOOK]]
    set versionString [mag_msg APP_TITLE]
    set versionString "$versionString $versionNumber"
    VtSetAppValues $app -versionString $versionString
    set outerMainForm [ \
        VtFormDialog $app.main \
        -resizable FALSE \
        -wmCloseCallback "quit_cb 1"\
        -title [mag_msg1 WIN_TITLE [mag_short_name_default]] \
        ]
    mag_build_widgets $outerMainForm
    VtShow $outerMainForm
    VtLock
    # form is visible and we are locked, now init stuff
    set DIRTY 0
        # check if host if ok
        if {"[mag_host_check $mag_host_name]" != "ok"} {
                VtUnLock
                mag_error1 BADHOST $mag_host_name
                quit
        }
    # check if authorized
    if {"[mag_authorized $mag_host_name]" == "fail"} {
        SaDisplayNoAuths $outerMainForm.noAuths [mag_msg APP_TITLE] \
            "quit_cb 0" [mag_short_name_default]
        VtUnLock
        VtMainLoop
        return
    }
    # get sendmail.cf either current one or new factory default one
    if {"[mag_cf_get]" != "ok"} {
        quit
    }
    # get /etc/default/mail either current or new one.
    if {"[mag_ms1_get]" != "ok"} {
        quit
    }
    # build onscreen db
    mao_init
    mag_insert_mainlist -1 [llength $mainscreen_db]
    mag_display_mainlist 0 1 0
    VtUnLock
    SaStatusBarClear $status_line
    VtMainLoop
}
ErrorTopLevelCatch {
if {"[lindex $argv 0]" == "-h"} {
    lvarpop argv
    set mag_host_name [lvarpop argv]
    if {"$mag_host_name" == ""} {
        echo "mailadmin: No host name"
        exit 1
    }
}
if {[lindex $argv 0] == "-mag_stand_edit"} {
    mag_stand_edit [lindex $argv 1] [lindex $argv 2]
    exit
}
if {[lindex $argv 0] == "-mag_stand_channel"} {
    mag_stand_channel [lindex $argv 1] [lindex $argv 2]
    exit
}
if {[lindex $argv 0] == "-mag_stand_host"} {
    mag_stand_host [lindex $argv 1]
    exit
}
main} "mailadmin"