PC World Komputer 1999 March B/SCO_CASTOR4RRT.iso/inet/root.2/usr/lib/scoadmin/netosa/dhcpOsa/dhcpOsa~

Text File | 1998-08-19 | 56KB | 1,996 lines

# Copyright (c) 1992-1998 The Santa Cruz Operation, Inc.. All Rights Reserved.
#
#        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE
#                   SANTA CRUZ OPERATION INC.
#
#   The copyright notice above does not evidence any actual or intended
#   publication of such source code.

#******************************************************************************
#
#    Copyright (C) 1992-1998 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.
#
#===============================================================================
#@package: SCO_DHCPOSA_MSGS SCO_DHCPOSA_MSGS
proc SCO_DHCPOSA_MSGS {} {}
global SCO_DHCPOSA_MSGS
set SCO_DHCPOSA_MSGS(@catalog@) {dhcpOsa.cat@sa 1}
set SCO_DHCPOSA_MSGS(ERR_NO_OPT_FILE) {1 {Cannot open option configuration file: %1$s}}
set SCO_DHCPOSA_MSGS(ERR_WRITE_PERMISSION) {2 {Cannot write to %1$s}}
set SCO_DHCPOSA_MSGS(ERR_WRITE_BACKUP) {3 {Backup of %1$s failed}}
set SCO_DHCPOSA_MSGS(ERR_OPEN) {4 {Failed to open %1$s}}
set SCO_DHCPOSA_MSGS(ERR_NO_DEFINITION) {5 {Configuration error: option %1$d is only valid when defined as part of a %2$d definition.}}
set SCO_DHCPOSA_MSGS(ERR_INVALID_DEFINITION) {6 {Configuration error: %1$s definition option %2$s defined for %3$s definition}}
set SCO_DHCPOSA_MSGS(ERR_INVALID_CLIENT_IP) {7 {Configuration error: invalid ip address %1$s}}
set SCO_DHCPOSA_MSGS(ERR_UNEXPECTED_OPTION) {8 {Configuration error: Unexpected definition for option %1$s}}
set SCO_DHCPOSA_MSGS(ERR_READ_PERMISSION) {9 {Cannot read %1$s}}
set SCO_DHCPOSA_MSGS(ERR_UNEXPECTED_DEFINITION) {10 {Configuration error: unexpected start of %1$s definition when a %2$s definition has already been started.}}
set SCO_DHCPOSA_MSGS(ERR_INVALID_SUBNET) {11 {Invalid IP address %1$s for subnet definition}}
set SCO_DHCPOSA_MSGS(ERR_DEF_EXISTS) {12 {A %1$s definition already exists for %2$s.}}
set SCO_DHCPOSA_MSGS(ERR_UNEXPECTED_ARRAY) {13 {Configuration error: Unexpected array definition %1$s}}
set SCO_DHCPOSA_MSGS(ERR_DEF_TERMINATION) {14 {Configuration error: Unexpected definition termination}}
set SCO_DHCPOSA_MSGS(ERR_ARRAY_TERMINATION) {15 {Configuration error: Unexpected array termination}}
set SCO_DHCPOSA_MSGS(ERR_INVALID_OPTION_TYPE) {16 {Configuration error: The option %1$s must be a decimal number - %2$s.}}
set SCO_DHCPOSA_MSGS(ERR_INVALID_OPTION_RANGE) {17 {Configuration error: The option %1$s must be in the range 128 to 254 - %2$s.}}
set SCO_DHCPOSA_MSGS(ERR_OPTION_BOOLEAN_VALUE) {18 {Configuration error: The option %1$s should be a boolean value - %2$s}}
set SCO_DHCPOSA_MSGS(ERR_NO_FILE) {19 {File %1$s does not exist}}
set SCO_DHCPOSA_MSGS(ERR_CONFIG) {20 {Configuration error: the format of the file %1$s is not correct}}
set SCO_DHCPOSA_MSGS(ERR_UNIX) {21 %s}
set SCO_DHCPOSA_MSGS(ERR_SACADM_STOP) {22 {sacadm failed to stop %1$s}}
set SCO_DHCPOSA_MSGS(ERR_SACADM_START) {23 {sacadm failed to start %1$s}}
set sco_dhcpVendorClass_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpVendorClass_CDT(groups) {}
set sco_dhcpVendorClass_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpVendorClass_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpVendorClass_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpVendorClass_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpVendorClass_list }
        }
    }
}
set sco_dhcpVendorClass_CDT(class) {sco dhcpVendorClass}
set sco_dhcpVendorClass_CDT(superior) {sco dhcpVendorClass}
set sco_dhcpVendorClass_CDT(subordinates) {{sco dhcpVendorClass}}
set sco_dhcpServer_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpServer_CDT(groups) {}
set sco_dhcpServer_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpServer_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpServer_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpServer_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpServer_list }
        }
    }
}
set sco_dhcpServer_CDT(class) {sco dhcpServer}
set sco_dhcpServer_CDT(superior) {sco dhcpServer}
set sco_dhcpServer_CDT(subordinates) {{sco dhcpServer}}
set sco_dhcpGlobal_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpGlobal_CDT(groups) {}
set sco_dhcpGlobal_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpGlobal_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpGlobal_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpGlobal_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpGlobal_list }
        }
    }
}
set sco_dhcpGlobal_CDT(class) {sco dhcpGlobal}
set sco_dhcpGlobal_CDT(superior) {sco dhcpGlobal}
set sco_dhcpGlobal_CDT(subordinates) {{sco dhcpGlobal}}
set sco_dhcpOption_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpOption_CDT(groups) {}
set sco_dhcpOption_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpOption_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpOption_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpOption_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpOption_list }
        }
    }
}
set sco_dhcpOption_CDT(class) {sco dhcpOption}
set sco_dhcpOption_CDT(superior) {sco dhcpOption}
set sco_dhcpOption_CDT(subordinates) {{sco dhcpOption}}
set sco_dhcpUserClass_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpUserClass_CDT(groups) {}
set sco_dhcpUserClass_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpUserClass_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpUserClass_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpUserClass_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpUserClass_list }
        }
    }
}
set sco_dhcpUserClass_CDT(class) {sco dhcpUserClass}
set sco_dhcpUserClass_CDT(superior) {sco dhcpUserClass}
set sco_dhcpUserClass_CDT(subordinates) {{sco dhcpUserClass}}
set sco_dhcpClient_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpClient_CDT(groups) {}
set sco_dhcpClient_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpClient_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpClient_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpClient_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpClient_list }
        }
    }
}
set sco_dhcpClient_CDT(class) {sco dhcpClient}
set sco_dhcpClient_CDT(superior) {sco dhcpClient}
set sco_dhcpClient_CDT(subordinates) {{sco dhcpClient}}
set sco_dhcpStandard_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpStandard_CDT(groups) {}
set sco_dhcpStandard_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpStandard_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpStandard_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpStandard_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpStandard_list }
        }
    }
}
set sco_dhcpStandard_CDT(class) {sco dhcpStandard}
set sco_dhcpStandard_CDT(superior) {sco dhcpStandard}
set sco_dhcpStandard_CDT(subordinates) {{sco dhcpStandard}}
set sco_dhcpSubnet_CDT(attributes) {
    {
        options
        {
            { validOperations {get add remove} }
            { validFilters {} }
            { dataType set }
        }
    }
}
set sco_dhcpSubnet_CDT(groups) {}
set sco_dhcpSubnet_CDT(operations) {
    {
        get
        {
            { granularity perObject }
            { function dhcpSubnet_get }
        }
    }
    {
        add
        {
            { granularity perObject }
            { function dhcpSubnet_add }
        }
    }
    {
        remove
        {
            { granularity perObject }
            { function dhcpSubnet_remove }
        }
    }
    {
        list
        {
            { granularity perObject }
            { function dhcpSubnet_list }
        }
    }
}
set sco_dhcpSubnet_CDT(class) {sco dhcpSubnet}
set sco_dhcpSubnet_CDT(superior) {sco dhcpSubnet}
set sco_dhcpSubnet_CDT(subordinates) {{sco dhcpSubnet}}
#@package: lineman lm_construct lm_destruct \
    lm_addLine lm_remLine lm_isValidIndex lm_getLine lm_putLine \
    lm_firstIndex lm_nextIndex lm_prevIndex lm_numLines
##################################################
proc lm_construct {} {
    global lm_gen lm_indices lm_next
    if {![info exists lm_gen]} {
        set lm_gen 0
    }
    set lmh $lm_gen
    incr lm_gen
    set lm_indices($lmh) ""
    set lm_next($lmh) 1
    return $lmh
}
proc lm_destruct {lmh} {
    global lm_indices
    foreach index $lm_indices($lmh) {
        lm_remLine $lmh $index
    }
}
proc lm_addLine {lmh where line} {
    global lm_indices lm_lines lm_next
    set new_index new_${lmh}_$lm_next($lmh)
    incr lm_next($lmh)
    set lm_lines($new_index) $line
    if {[cequal $where end]} {
        set pos $where
    } else {
        set pos [lsearch $lm_indices($lmh) $where]
        if {$pos == -1} {
            set pos end
        }
    }
    set lm_indices($lmh) [linsert $lm_indices($lmh) $pos $new_index]
    return $new_index
}
proc lm_remLine {lmh index} {
    global lm_indices lm_lines
    set pos [lsearch $lm_indices($lmh) $index]
    if {$pos == -1} {
        return 1
    }
    unset lm_lines($index)
    lvarpop lm_indices($lmh) $pos
    return 0
}
proc lm_isValidIndex {lmh index} {
    global lm_indices
    set pos [lsearch $lm_indices($lmh) $index]
    if {$pos == -1} {
        return 0
    }
    return 1
}
proc lm_getLine {lmh index} {
    global lm_indices lm_lines
    set pos [lsearch $lm_indices($lmh) $index]
    if {$pos == -1} {
        return ""
    }
    return $lm_lines($index)
}
proc lm_putLine {lmh index line} {
    global lm_indices lm_lines
    set pos [lsearch $lm_indices($lmh) $index]
    if {$pos == -1} {
        return ""
    }
    set lm_lines($index) $line
    return $lm_lines($index)
}
proc lm_firstIndex {lmh} {
    global lm_indices
    if {[lempty $lm_indices($lmh)]} {
        return -1
    }
    return [lindex $lm_indices($lmh) 0]
}
proc lm_nextIndex {lmh index} {
    global lm_indices
    set pos [lsearch $lm_indices($lmh) $index]
    if {$pos == -1} {
        return $pos
    }
    incr pos
    if {$pos >= [llength $lm_indices($lmh)]} {
        return -1
    }
    return [lindex $lm_indices($lmh) $pos]
}
proc lm_prevIndex {lmh index} {
    global lm_indices
    set pos [lsearch $lm_indices($lmh) $index]
    if {$pos == -1} {
        return $pos
    }
    incr pos -1
    if {$pos < 0} {
        return -1
    }
    return [lindex $lm_indices($lmh) $pos]
}
proc lm_numLines {lmh} {
    global lm_indices
    return [llength $lm_indices($lnh)]
}
##################################################
#@packend
proc checkIPaddr {addr} {
    if { [lempty $addr] } {
    return 0
    }
    set match [regsub {^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$} $addr \
           {\1 \2 \3 \4} octets]
    if { ! $match } {
    return 0
    } else {
    foreach octet $octets {
        if { $octet < 0 || $octet > 255 } {
        return 0
        }
    }
    }
    return 1
}
proc checkIPwidgetCB {form cbs} {
    set value  [keylget cbs value]
    set widget [keylget cbs widget]
    set a_addr [VxGetVar $form a_addr]
    set b_addr [VxGetVar $form b_addr]
    set c_addr [VxGetVar $form c_addr]
    set d_addr [VxGetVar $form d_addr]
    set userCheckIPwidget [VxGetVar $form userCheckIPwidget]
    set skip 0
    set length [string length $value]
    if {$length == 0} {
    return
    }
    if {$length >= 3} {
    set skip 1
    }
    if {[string range $value [expr $length - 1] end] == "."} {
    set skip 1
    set value [string range $value 0 [expr $length - 2]]
    VtSetValues $widget -value $value
    }
    if {![ctype digit $value]} then {
    VtBeep
    VtSetValues $widget -value ""
    return
    }
    if {$value < 0 || $value > 255} then {
    VtBeep
    VtSetValues $widget -value ""
    return
    }
    if {$skip} then {
    if {$widget == $a_addr} {VtSetFocus $b_addr}
    if {$widget == $b_addr} {VtSetFocus $c_addr}
    if {$widget == $c_addr} {VtSetFocus $d_addr}
    }
    if {[string length $userCheckIPwidget]} {
    $userCheckIPwidget $cbs
    }
}
proc getIPwidgetValue {widget} {
    set a_addr [VxGetVar $widget a_addr]
    set b_addr [VxGetVar $widget b_addr]
    set c_addr [VxGetVar $widget c_addr]
    set d_addr [VxGetVar $widget d_addr]
    set value "[VtGetValues $a_addr -value]"
    append value "."
    append value "[VtGetValues $b_addr -value]"
    append value "."
    append value "[VtGetValues $c_addr -value]"
    append value "."
    append value "[VtGetValues $d_addr -value]"
    return $value
}
proc setIPwidgetValue {widget value} {
    set a_addr [VxGetVar $widget a_addr]
    set b_addr [VxGetVar $widget b_addr]
    set c_addr [VxGetVar $widget c_addr]
    set d_addr [VxGetVar $widget d_addr]
    set values [split $value "."]
    VtSetValues $a_addr -value [lindex $values 0]
    VtSetValues $b_addr -value [lindex $values 1]
    VtSetValues $c_addr -value [lindex $values 2]
    VtSetValues $d_addr -value [lindex $values 3]
    VtSetFocus    $a_addr
}
proc createIPwidget {form value shortHelp {userCheckIPwidget {}}} {
    set values [split $value "."]
    set a_addr [VtText $form.a -columns 3 \
        -value [lindex $values 0] \
        -callback "SaSetFocus next" \
        -valueChangedCallback "checkIPwidgetCB $form" \
        -shortHelpCallback SaShortHelpCB \
        -shortHelpString "[IntlLocalizeMsg $shortHelp]" ]
    set a_label [VtLabel $form.al -label "." \
        -leftOffset 0 \
        -leftSide $a_addr -alignTop $a_addr]
    set b_addr [VtText $form.b -columns 3 \
        -value [lindex $values 1] \
        -callback "SaSetFocus next" \
        -valueChangedCallback "checkIPwidgetCB $form" \
        -leftOffset 0 \
        -leftSide $a_label -alignTop $a_label \
        -shortHelpCallback SaShortHelpCB \
        -shortHelpString "[IntlLocalizeMsg $shortHelp]" ]
    set b_label [VtLabel $form.bl -label "." \
        -leftOffset 0 \
        -leftSide $b_addr -alignTop $b_addr]
    set c_addr [VtText $form.c -columns 3 \
        -value [lindex $values 2] \
        -callback "SaSetFocus next" \
        -valueChangedCallback "checkIPwidgetCB $form" \
        -leftOffset 0 \
        -leftSide $b_label -alignTop $b_label \
        -shortHelpCallback SaShortHelpCB \
        -shortHelpString "[IntlLocalizeMsg $shortHelp]" ]
    set c_label [VtLabel $form.cl -label "." \
        -leftOffset 0 \
        -leftSide $c_addr -alignTop $c_addr]
    set d_addr [VtText $form.d -columns 3 \
        -value [lindex $values 3] \
        -callback "SaSetFocus next" \
        -valueChangedCallback "checkIPwidgetCB $form" \
        -leftSide $c_label -alignTop $c_label \
        -leftOffset 0 \
        -shortHelpCallback SaShortHelpCB \
        -shortHelpString "[IntlLocalizeMsg $shortHelp]" ]
    VxSetVar $form a_addr $a_addr
    VxSetVar $form b_addr $b_addr
    VxSetVar $form c_addr $c_addr
    VxSetVar $form d_addr $d_addr
    VxSetVar $form userCheckIPwidget $userCheckIPwidget
}
##################################################
##################################################
proc dhcp:init_standard_opts {} {
    global DHCP_OPTS_FILE standard_list
    if {![owner file readable $DHCP_OPTS_FILE]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_OPT_FILE $DHCP_OPTS_FILE
    return
    }
    if {[info exists standard_list]} {
    unset standard_list
    }
    net:for_file entry $DHCP_OPTS_FILE {
    if {[cindex $entry 0] == "#" || \
        [cindex $entry 0] == "" || \
        [cindex $entry 0] == "\n"} {
        continue
    }
    set code    [lindex $entry 0]
    set name    [lindex $entry 1]
    set comment [lindex $entry 2]
    set type [lindex $entry 3]
    if {[crange $type 0 0] == "+"} {
        set array 1
        set type [crange $type 1 end]
    } else {
        set array 0
    }
    set default [lindex $entry 4]
    keylset option code    $code
    keylset option comment $comment
    keylset option type    $type
    keylset option array   $array
    keylset option default $default
    set standard_list($name) $option
    }
    return
} ;# init_standard_opts
proc dhcp:write {} {
    global DHCP_CONF_FILE dhcp_lmh dhcp_lmi
    if {[owner file exists $DHCP_CONF_FILE]} {
    if {![owner file writable $DHCP_CONF_FILE]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_WRITE_PERMISSION \
        "$DHCP_CONF_FILE"
        return
    }
    if {[catch {owner exec /bin/cp $DHCP_CONF_FILE ${DHCP_CONF_FILE}-}]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_WRITE_BACKUP "$DHCP_CONF_FILE"
        return
    }
    set inet_add 0
    } else {
    set inet_add 1
    }
    if {[catch {ownerOpen writefile $DHCP_CONF_FILE w} fd]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_OPEN "$DHCP_CONF_FILE"
    return
    }
    set lmi [lm_firstIndex $dhcp_lmh]
    if {$lmi == -1} {
        close $fd
    owner unlink -nocomplain $DHCP_CONF_FILE
    ErrorCatch {} 1 "dhcp:inet_remove_entry" ret
    } else {
    while {$lmi != -1} {
        puts $fd [lm_getLine $dhcp_lmh $lmi]
        set lmi [lm_nextIndex $dhcp_lmh $lmi]
    }
        close $fd
    if {$inet_add} {
        ErrorCatch {} 1 "dhcp:inet_add_entry" ret
    }
    }
} ;# dhcp:write
proc ServerGetDefaultInfo {} {
    keylset entry lease_res       600
    keylset entry lease_pad       1
    keylset entry address_probe   true
    keylset entry option_overload false
    return $entry
} ;# ServerGetDefaultInfo
proc ServerAddDefault {serverInfo} {
    set serverDefault [ServerGetDefaultInfo]
    set defaultKeys [keylkeys serverDefault]
    set keys [keylkeys serverInfo]
    set results [intersect3 $defaultKeys $keys]
    set unused [lindex $results 0]
    foreach key $unused {
    keylset serverInfo $key [keylget serverDefault $key]
    }
    return $serverInfo
} ;# ServerAddDefault
proc ServerRemDefault {serverInfo} {
    set serverDefault [ServerGetDefaultInfo]
    set defaultKeys [keylkeys serverDefault]
    set keys [keylkeys serverInfo]
    set results [intersect3 $defaultKeys $keys]
    set used [lindex $results 1]
    foreach key $used {
    keylget serverDefault $key defValue
    keylget serverInfo $key value
    if {[cequal $value $defValue]} {
        keyldel serverInfo $key
    }
    }
    return $serverInfo
} ;# ServerRemDefault
proc dhcp:comment_get_option {type tag parameter line lmi} {
    global subnet_list       subnet_lmi
    global client_list       client_lmi
    global user_class_list   user_class_lmi
    global vendor_class_list vendor_class_lmi
    global global_list       global_lmi
    global option_list         option_lmi
    if {![cequal comment $parameter]} {
    return 0
    }
    set entryTypes [list subnet client user_class vendor_class global option]
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter valid"
    return -1
    }
    if {[lsearch $entryTypes $type] == -1} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_UNEXPECTED_OPTION "$parameter"
    return -1
    }
    regexp {^[     ]*comment[     ]+([^     ].*)} $line tmp value
    set def_list [format %s_list(%s) $type $tag]
    set def_lmi  [format %s_lmi(%s) $type $tag]
    set entry [set $def_list]
    keylset entry $parameter $value
    set $def_list $entry
    lappend $def_lmi $lmi
    return 1
} ;# dhcp:comment_get_option
proc dhcp:subnet_get_options {type tag parameter value lmi} {
    global subnet_list subnet_lmi
    if {[lsearch [list mask pool lease_dflt lease_max t1 t2] $parameter] \
    == -1} {
    return 0
    }
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter subnet"
    return -1
    }
    if {![cequal $type subnet]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_DEFINITION "subnet mask \
        $type"
    return -1
    }
    switch $parameter {
    mask {
    }
    pool {
    }
    lease_dflt {
    }
    lease_max {
    }
    t1 {
    }
    t2 {
    }
    }
    set entry $subnet_list($tag)
    keylset entry $parameter $value
    set subnet_list($tag) $entry
    lappend subnet_lmi($tag) $lmi
    return 1
} ;# dhcp:subnet_get_options
proc dhcp:client_get_options {type tag parameter value lmi} {
    global client_list client_lmi
    if {[lsearch [list ip_address] $parameter] == -1} {
    return 0
    }
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter client"
    return -1
    }
    if {![cequal $type client]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_DEFINITION "client mask \
        $type"
    return -1
    }
    switch $parameter {
    ip_address {
        if {![checkIPaddr $value]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_CLIENT_IP "$value"
        return -1
        }
    }
    }
    set entry $client_list($tag)
    keylset entry $parameter $value
    set client_list($tag) $entry
    lappend client_lmi($tag) $lmi
    return 1
} ;# dhcp:client_get_options
proc dhcp:option_get_options {type tag parameter line lmi} {
    global option_list option_lmi
    if {[lsearch [list name type min_val max_val min_length max_length] \
    $parameter] == -1} {
    return 0
    }
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter option"
    return -1
    }
    if {![cequal $type option]} {
    return 0
    }
    switch $parameter {
    type {
        set type  {}
        set array {}
            regexp {^[     ]*type[     ]*([^     ]*)[     ]*([^     ]*)} $line \
        tmp type array
        if {[string length $array]} {
        set value "$type $array"
        } else {
        set value $type
        }
    }
    name       -
    min_val       -
    max_val       -
    min_length -
    max_length {
            regexp {^[     ]*([^     ]*)[     ]*([^     ]*)[     ]*} $line tmp \
        ptmp value
    }
    }
    set entry $option_list($tag)
    keylset entry $parameter $value
    set option_list($tag) $entry
    lappend option_lmi($tag) $lmi
    return 1
} ;# dhcp:option_get_options
proc dhcp:server_get_options {type tag parameter value lmi} {
    global server_list server_lmi
    if {[lsearch [list name option_overload lease_res lease_pad address_probe] \
    $parameter] == -1} {
    return 0
    }
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter server"
    return -1
    }
    if {![cequal $type server]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_DEFINITION "server $parameter \
        $type"
    return -1
    }
    switch $parameter {
    option_overload -
    address_probe {
        if {![cequal $value true] && ![cequal $value false]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_OPTION_BOOLEAN_VALUE \
        "$parameter $value"
        return -1
        }
    }
    default {
        if {![ctype digit $value]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_OPTION_TYPE \
        "$parameter $value"
        return -1
        }
    }
    }
    set entry $server_list($tag)
    keylset entry $parameter $value
    set server_list($tag) $entry
    lappend server_lmi($tag) $lmi
    return 1
} ;# dhcp:server_get_options
proc dhcp:standard_get_options {type tag parameter value lmi} {
    global subnet_list       subnet_lmi
    global client_list       client_lmi
    global user_class_list   user_class_lmi
    global vendor_class_list vendor_class_lmi
    global global_list       global_lmi
    global standard_list     standard_lmi
    set standardOpts [array names standard_list]
    if {[lsearch $standardOpts $parameter] == -1} {
    return 0
    }
    set entryTypes [list subnet client user_class vendor_class global]
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter valid"
    return -1
    }
    if {[lsearch $entryTypes $type] == -1} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_UNEXPECTED_OPTION "$parameter"
    return -1
    }
    set std_list [format %s_list(%s) $type $tag]
    set std_lmi  [format %s_lmi(%s) $type $tag]
    set entry [set $std_list]
    keylset entry $parameter $value
    set $std_list $entry
    lappend $std_lmi $lmi
    return 1
} ;# dhcp:standard_get_options
proc dhcp:user_get_options {type tag parameter value lmi} {
    global subnet_list       subnet_lmi
    global client_list       client_lmi
    global user_class_list   user_class_lmi
    global vendor_class_list vendor_class_lmi
    global global_list       global_lmi
    global option_list       option_lmi
    if {![regexp {option([0-9]*)} $parameter t_all code]} {
    return 0
    }
    if [info exists option_list] {
    set options [array names option_list]
    } else {
    set options {}
    }
    if {[lsearch $options $code] == -1} {
    return 0
    }
    set entryTypes [list subnet client user_class vendor_class global]
    if {$type == 0} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_DEFINITION "$parameter valid"
    return -1
    }
    if {[lsearch $entryTypes $type] == -1} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_UNEXPECTED_OPTION "$parameter"
    return -1
    }
    set std_list [format %s_list(%s) $type $tag]
    set std_lmi  [format %s_lmi(%s) $type $tag]
    set entry [set $std_list]
    keylset entry $parameter $value
    set $std_list $entry
    lappend $std_lmi $lmi
    return 1
} ;# dhcp:user_get_options
proc dhcp:read {} {
    global DHCP_CONF_FILE dhcp_lmh
    global client_list       client_lmi
    global global_list       global_lmi
    global option_list       option_lmi
    global server_list         server_lmi
    global subnet_list       subnet_lmi
    global user_class_list   user_class_lmi
    global vendor_class_list vendor_class_lmi
    global standard_list
    if {[info exists subnet_list]} {
    unset subnet_list
    }
    if {[info exists subnet_lmi]} {
    unset subnet_lmi
    }
    set dhcp_lmh [lm_construct]
    set defType   {}
    set defTag    {}
    set arrayType {}
    if {![owner file exists $DHCP_CONF_FILE]} {
    return
    }
    if {![owner file readable $DHCP_CONF_FILE]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_READ_PERMISSION "$DHCP_CONF_FILE"
    return
    }
    if {[catch {ownerOpen readfile $DHCP_CONF_FILE r} fd]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_OPEN "$DHCP_CONF_FILE"
    return
    }
    set sc [scancontext create]
    scanmatch $sc {^.*} {
    set lmi [lm_addLine $dhcp_lmh end "$matchInfo(line)"]
    }
    scanmatch $sc {^[    ]*$} {
    continue
    }
    scanmatch $sc {^[    ]*#.*$} {
    continue
    }
    set entryTypes [list client global option server subnet user_class \
    vendor_class]
    scanmatch $sc {\{[     ]*$} {
    set line $matchInfo(line)
    regexp \
        {^[     ]*([a-z_0-9]*)[     ]*([^     ]*)[     ]*([^     ]*)[     ]*} \
        $line tmp type tag var
    if {[lsearch $entryTypes $type] != -1} {
        if {[string length $defType]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_UNEXPECTED_DEFINITION "$type \
            $defType"
        return
        } else {
        set defType $type
        }
        set entry {}
        switch $type {
        client {
            if {[cequal opaque $tag]} {
            set defTag [string trim $var "\""]
                keylset entry identifier_type opaque
            } else {
            set defTag [format "%s_%s" $tag $var]
                keylset entry identifier_type hardware
            }
        }
        global {
            set defTag global
        }
        option {
            if {![ctype digit $tag]} {
            ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_OPTION_TYPE \
                "code $defTag"
            return
            }
            if {$tag < 128 || $tag > 254} {
            ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_OPTION_RANGE \
                "code $defTag"
            }
            set defTag $tag
        }
        server {
            set defTag server
        }
        subnet {
            set defTag  $tag
            if {![checkIPaddr $defTag]} {
            ErrorPush {} 1 SCO_DHCPOSA_ERR_INVALID_SUBNET "$defTag"
            return
            }
        }
        user_class {
            set defTag [string trim $tag "\""]
        }
        vendor_class {
            set defTag [string trim $tag "\""]
        }
        }
        set list [format %s_list $type]
        if {[info exists $list] && \
        [lsearch [array names $list] $defTag] != -1} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_DEF_EXISTS "$defType $defTag"
        return
        } else {
        set list_entry [format %s_list(%s) $defType $defTag]
        set lmi_entry  [format %s_lmi(%s)  $defType $defTag]
        set $list_entry $entry
        lappend $lmi_entry $lmi
        }
    } else {
        if {![string length $defType] || \
        [lsearch $entryTypes $defType] == -1 ||
        ![string length $defTag]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_UNEXPECTED_ARRAY "$type"
        return
        }
        set standardOpts [array names standard_list]
        if [info exists option_list] {
        set userOpts [array names option_list]
        } else {
        set userOpts {}
        }
        set found 0
        if {[regexp {option([0-9]*)} $type t_all code]} {
        if {[lsearch $userOpts $code] != -1} {
            set found 1
        }
        }
        if {!$found && [lsearch $standardOpts $type] == -1} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_UNEXPECTED_ARRAY "$type"
        return
        }
        set arrayType  $type
        set array_list {}
        lappend array_lmi $lmi
    }
    continue
    }
    scanmatch $sc {^[     ]*\}[     ]*$} {
    if {![string length $defType] || ![info exists tag]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_DEF_TERMINATION
        return
    }
    if {[string length $arrayType]} {
        if {![info exists array_list] || ![info exists array_lmi]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_ARRAY_TERMINATION
        return
        }
        set list_entry [format %s_list(%s) $defType $defTag]
        set lmi_entry  [format %s_lmi(%s)  $defType $defTag]
        set entry [set $list_entry]
        keylset entry $arrayType $array_list
        set $list_entry $entry
        lappend array_lmi $lmi
        set $lmi_entry [concat [set $lmi_entry] $array_lmi]
        set arrayType {}
    } else {
        set lmi_entry  [format %s_lmi(%s)  $defType $defTag]
        lappend $lmi_entry $lmi
        set defType {}
        set defTag  {}
    }
    continue
    }
    scanmatch $sc {^[     ]*([^     ]*)[     ]*([^     ]*)[     ]*} {
        set line    $matchInfo(line)
    set parameter    $matchInfo(submatch0)
    set value    $matchInfo(submatch1)
    if {[dhcp:comment_get_option $defType $defTag $parameter $line $lmi]} {
        continue
    }
    if {[dhcp:subnet_get_options $defType $defTag $parameter $value $lmi]} {
        continue
    }
    if {[dhcp:client_get_options $defType $defTag $parameter $value $lmi]} {
        continue
    }
    if {[dhcp:option_get_options $defType $defTag $parameter $line $lmi]} {
        continue
    }
    if {[dhcp:standard_get_options $defType $defTag $parameter $value \
        $lmi]} {
        continue
    }
    if {[dhcp:user_get_options $defType $defTag $parameter $value \
        $lmi]} {
        continue
    }
    if {[dhcp:server_get_options $defType $defTag $parameter $value \
        $lmi]} {
        continue
    }
    if {[string length $arrayType]} {
        set array_list [concat $array_list $line]
        lappend array_lmi  $lmi
        continue
    }
    }
    scanfile $sc $fd
    close $fd
    scancontext delete $sc
} ;# dhcp:read
proc dhcp:defAdd {type object optionList} {
    global dhcp_lmh
    global client_lmi       client_list
    global global_lmi       global_list
    global option_lmi       option_list
    global server_lmi        server_list
    global subnet_lmi       subnet_list
    global user_class_lmi   user_class_list
    global vendor_class_lmi vendor_class_list
    if {![llength $optionList]} {
    return 0
    }
    switch $type {
    client {
        if {[keylget optionList identifier_type identifier_type]} {
        keyldel optionList identifier_type
        if {[cequal $identifier_type opaque]} {
            set id  "$type opaque \"$object\""
        } elseif {[cequal $identifier_type hardware]} {
            lassign [split "$object" _] hwtype hwaddr
            set id "$type $hwtype $hwaddr"
        } else {
            return -1
        }
        } else {
        return -1
        }
    }
    global {
        set id global
    }
    option {
        set id "$type $object"
    }
    server {
        set id server
        set optionList [ServerRemDefault $optionList]
        if {![llength $optionList]} {
        return 0
        }
    }
    subnet {
        set id "$type $object"
    }
    user_class    -
    vendor_class {
        set id  "$type \"$object\""
    }
    default {
        return -1
    }
    }
    set def_lmi  [format "%s_lmi(%s)"  $type $object]
    set def_list [format "%s_list(%s)" $type $object]
    set $def_lmi [lm_addLine $dhcp_lmh end "$id {"]
    foreach option [keylkeys optionList] {
    keylget optionList $option valueList
    set length [llength $valueList]
    if {$length == 0} {
        continue
    } elseif {[llength $valueList] == 1 || [cequal $option comment] ||
        [cequal $option name] || [cequal $option type]} {
        lappend $def_lmi [lm_addLine $dhcp_lmh end "\t$option $valueList"]
    } else {
        lappend $def_lmi [lm_addLine $dhcp_lmh end "\t$option {"]
        foreach value $valueList {
        lappend $def_lmi [lm_addLine $dhcp_lmh end "\t$value"]
        }
        lappend $def_lmi [lm_addLine $dhcp_lmh end "\t}"]
    }
    }
    lappend $def_lmi [lm_addLine $dhcp_lmh end "}"]
    set $def_list $optionList
    return 1
} ;# dhcp:defAdd
proc dhcp:defRemove {type object {item {}}} {
    global dhcp_lmh
    global client_lmi       client_list
    global global_lmi       global_list
    global option_lmi       option_list
    global server_lmi       server_list
    global subnet_lmi       subnet_list
    global user_class_lmi   user_class_list
    global vendor_class_lmi vendor_class_list
    set defTypes [list client global option server subnet user_class \
    vendor_class]
    if {[lsearch $defTypes $type] == -1} {
    return
    }
    set def_lmi  [format "%s_lmi(%s)"  $type $object]
    set def_list [format "%s_list(%s)" $type $object]
    set lmi_entry [set $def_lmi]
    set itemLen   [string length $item]
    if {$itemLen} {
    set keys [keylkeys $def_list]
    set index [lsearch $keys $item]
    lvarpop $def_list $index
    set lmi [lvarpop $def_lmi [incr index]]
    lm_remLine $dhcp_lmh $lmi
    }
    set keys [keylkeys $def_list]
    if {!$itemLen || ![llength $keys]} {
    foreach lmi $lmi_entry {
        lm_remLine $dhcp_lmh $lmi
    }
    unset $def_lmi
    unset $def_list
    }
} ;# dhcp:defRemove
proc dhcp:inet_read {} {
    global INET_CONF_FILE inet_lmh
    global un_boot_list boot_list
    global un_boot_alt_list boot_alt_list
    set inet_lmh [lm_construct]
    if {![owner file exists $INET_CONF_FILE]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_NO_FILE "$INET_CONF_FILE"
    return
    }
    if {![owner file readable $INET_CONF_FILE]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_READ_PERMISSION "$INET_CONF_FILE"
    return
    }
    if {[catch {ownerOpen readfile $INET_CONF_FILE r} fd]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_OPEN "$INET_CONF_FILE"
    return
    }
    set sc [scancontext create]
    scanmatch $sc {^.*} {
    set lmi [lm_addLine $inet_lmh end "$matchInfo(line)"]
    }
    scanmatch $sc {^[    ]*$} {
    continue
    }
    scanmatch $sc {^[     ]*#bootps-alt[     ]*} {
    set line $matchInfo(line)
    set un_boot_alt_list($lmi) $line
    continue
    }
    scanmatch $sc {^[     ]*bootps-alt[     ]*} {
    set line $matchInfo(line)
    if {[info exists boot_alt_list]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
        return
    } else {
        set boot_alt_list($lmi) $line
    }
    continue
    }
    scanmatch $sc {^[     ]*#bootps[     ]*} {
    set line $matchInfo(line)
    set un_boot_list($lmi) $line
    continue
    }
    scanmatch $sc {^[     ]*bootps[     ]*} {
    set line $matchInfo(line)
    if {[info exists boot_list]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
        return
    } else {
        set boot_list($lmi) $line
    }
    continue
    }
    scanfile $sc $fd
    close $fd
    scancontext delete $sc
} ;# dhcp:inet_read
proc dhcp:inet_write {} {
    global INET_CONF_FILE inet_lmh
    global un_boot_list boot_list
    global un_boot_alt_list boot_alt_list
    if {[owner file exists $INET_CONF_FILE]} {
    if {![owner file writable $INET_CONF_FILE]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_WRITE_PERMISSION \
        "$INET_CONF_FILE"
        return
    }
    if {[catch {owner exec /bin/cp $INET_CONF_FILE ${INET_CONF_FILE}-}]} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_WRITE_BACKUP "$INET_CONF_FILE"
        return
    }
    }
    if {[catch {ownerOpen writefile $INET_CONF_FILE w} fd]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_OPEN "$INET_CONF_FILE"
    return
    }
    set lmi [lm_firstIndex $inet_lmh]
    while {$lmi != -1} {
    puts $fd [lm_getLine $inet_lmh $lmi]
    set lmi [lm_nextIndex $inet_lmh $lmi]
    }
    close $fd
    ErrorCatch {} 1 "dhcp:inet_restart" ret
} ;# dhcp:inet_write
proc dhcp:inet_add_bootp_entry {} {
    global inet_lmh
    global un_boot_list boot_list
    set indexList [array names un_boot_list]
    set found 0
    foreach index $indexList {
    set line $un_boot_list($index)
    set name [lindex $line 6]
    if {![string compare $name "in.dhcpd"]} {
        set args [lrange $line 7 end]
        if {[lsearch $args "-b"] == -1} {
        lvarpop line 0 "bootps"
        set found 1
        break
        }
    }
    }
    if {!$found} {
    set line "bootps dgram/i udp wait root /usr/sbin/in.dhcpd in.dhcpd"
    }
    set lmi [lm_addLine $inet_lmh end $line]
    set boot_list($lmi) $line
} ;# dhcp:inet_add_bootp_entry
proc dhcp:inet_add_bootp_alt_entry {{bootp_line {}}} {
    global inet_lmh
    global un_boot_list boot_list
    global un_boot_alt_list boot_alt_list
    set indexList [array names un_boot_list]
    set found 0
    foreach index $indexList {
    set line $un_boot_list($index)
    set name [lindex $line 6]
    if {![string compare $name "in.dhcpd"]} {
        set args [lrange $line 7 end]
        if {[lsearch $args "-b"] != -1} {
        lvarpop line 0 "bootps"
        set found 1
        break
        }
    }
    }
    if {!$found} {
    set line "bootps dgram/i udp wait root /usr/sbin/in.dhcpd in.dhcpd -b bootps-alt"
    }
    set lmi [lm_addLine $inet_lmh end $line]
    set boot_list($lmi) $line
    if {[info exists bootp_line] && [llength $bootp_line]} {
    set line $bootp_line
    lvarpop line 0 "bootps-alt"
    set args [lrange $line 7 end]
    if {[lsearch $args "-S"] == -1} {
        lappend line "-S"
    }
    set found 1
    } else {
    set indexList [array names un_boot_alt_list]
    set found 0
    foreach index $indexList {
        set line $un_boot_alt_list($index)
        set name [lindex $line 6]
        if {![string compare $name "in.bootpd"]} {
        set args [lrange $line 7 end]
        if {[lsearch $args "-S"] != -1} {
            lvarpop line 0 "bootps-alt"
            set found 1
            break
        }
        }
    }
    }
    if {!$found} {
    set line "bootps-alt dgram udp wait root /usr/sbin/in.bootpd in.bootpd -S"
    }
    set lmi [lm_addLine $inet_lmh end $line]
    set boot_alt_list($lmi) $line
} ;# dhcp:inet_add_bootp_alt_entry
proc dhcp:inet_add_entry {} {
    global INET_CONF_FILE inet_lmh
    global un_boot_list boot_list
    global un_boot_alt_list boot_alt_list
    if {[info exists boot_list] && [info exists boot_alt_list]} {
    return
    } elseif {[info exists boot_list]} {
    set lmi_list [array names boot_list]
    set length [llength $lmi_list]
    if {$length == 0} {
        dhcp:inet_add_bootp_entry
    } elseif {$length != 1}  {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
        return
    } else {
        set lmi  [lindex $lmi_list 0]
        set line $boot_list($lmi)
        set name [lindex $line 6]
        if {![string compare $name "in.dhcpd"]} {
        return
        } elseif {![string compare $name "in.bootpd"]} {
        lm_remLine $inet_lmh $lmi
        unset boot_list($lmi)
        dhcp:inet_add_bootp_alt_entry $line
        } else {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
        return
        }
    }
    } elseif {[info exists boot_alt_list]} {
    ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
    return
    } else {
    dhcp:inet_add_bootp_entry
    }
    ErrorCatch {} 1 "dhcp:inet_write" ret
} ;# dhcp:inet_add_entry
proc dhcp:inet_remove_bootp_entry {type} {
    global inet_lmh un_boot_list boot_list
    set lmi_list [array names boot_list]
    set length [llength $lmi_list]
    if {$length == 1} {
    set lmi [lindex $lmi_list 0]
    set line $boot_list($lmi)
    set name [lindex $line 6]
    if {![string compare $name $type]} {
        lm_remLine $inet_lmh $lmi
        unset boot_list($lmi)
    }
    } elseif {$length != 0} {
    return -1
    }
    return 0
} ;# dhcp:inet_remove_bootp_entry
proc dhcp:inet_remove_bootp_alt_entry {} {
    global inet_lmh un_boot_alt_list boot_alt_list
    set lmi_list [array names boot_alt_list]
    set length [llength $lmi_list]
    if {$length == 1} {
    set lmi [lindex $lmi_list 0]
    set line $boot_alt_list($lmi)
    set name [lindex $line 6]
    if {![string compare $name "in.bootpd"]} {
        lm_remLine $inet_lmh $lmi
        unset boot_alt_list($lmi)
        lvarpop line 0 "bootps"
        set index [lsearch $line "-S"]
        if {$index > 6} {
        lvarpop line $index
        }
            set lmi [lm_addLine $inet_lmh end $line]
        set boot_list($lmi) $line
    }
    } elseif {$length != 0} {
    return -1
    }
    return 0
} ;# dhcp:inet_remove_bootp_alt_entry
proc dhcp:inet_remove_entry {} {
    global INET_CONF_FILE inet_lmh
    global un_boot_list boot_list
    global un_boot_alt_list boot_alt_list
    if {[info exists boot_list] && [info exists boot_alt_list]} {
    if {[dhcp:inet_remove_bootp_entry "in.dhcpd"] < 0} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
    }
    if {[dhcp:inet_remove_bootp_alt_entry] < 0} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
    }
    } elseif {[info exists boot_list]} {
    if {[dhcp:inet_remove_bootp_entry "in.dhcpd"] < 0} {
        ErrorPush {} 1 SCO_DHCPOSA_ERR_CONFIG "$INET_CONF_FILE"
    }
    } else {
    return
    }
    ErrorCatch {} 1 "dhcp:inet_write" ret
} ;# dhcp:inet_remove_entry
proc dhcp:inet_restart {} {
    OwnerCallNonStdCmd /usr/sbin/sacadm "-k -p inetd" \
    SCO_DHCPOSA_ERR_UNIX errStack SCO_DHCPOSA_ERR_SACADM_STOP "inet"]
    if {[info exists errStack] && [string length $errStack]} {
    ErrorThrow errStack
    return
    }
    OwnerCallNonStdCmd /usr/sbin/sacadm "-s -p inetd" \
    SCO_DHCPOSA_ERR_UNIX errStack SCO_DHCPOSA_ERR_SACADM_START "inet"]
    if {[info exists errStack] && [string length $errStack]} {
    ErrorThrow errStack
    return
    }
}
proc dhcp:init {} {
    global OS DHCP_CONF_FILE DHCP_OPTS_FILE INET_CONF_FILE option_list
    if {[catch {exec /bin/uname -r} OS]} {
    set OS 4
    }
    switch -exact $OS {
    3.2 {
        set SA_LIB_DIR /etc/sysadm.d/lib
        set CONFIG_DIR /etc
    }
    default {
        set SA_LIB_DIR /usr/lib
        set CONFIG_DIR /etc/inet
    }
    }
    loadlibindex ${SA_LIB_DIR}/sysadm.tlib
    set DHCP_CONF_FILE ${CONFIG_DIR}/dhcpd.conf
    set DHCP_OPTS_FILE ${CONFIG_DIR}/dhcp.opts
    set INET_CONF_FILE ${CONFIG_DIR}/inetd.conf
    dhcp:init_standard_opts
    dhcp:read
    dhcp:inet_read
} ;# dhcp:init
proc dhcpSubnet_get {class object refObject op subOp data attr attrValueList osaData} {
    global subnet_list
    set result {}
    if {![info exists subnet_list] || \
    [lsearch [array names subnet_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options $subnet_list($object)
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpSubnet_add {class object refObject op subOp data attr attrValueList osaData} {
    global subnet_list
    if {[info exists subnet_list] && \
    [lsearch [array names subnet_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return
    }
    keylget attrValueList options options
    dhcp:defAdd subnet $object $options
    dhcp:write
    return
}
proc dhcpSubnet_remove {class object refObject op subOp data attr attrValueList osaData} {
    global subnet_list
    if {![info exists subnet_list] || \
    [lsearch [array names subnet_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE [list $object]
    return
    }
    dhcp:defRemove subnet $object
    dhcp:write
}
proc dhcpSubnet_list {class object refObject op subOp data attr attrValueList osaData} {
    global subnet_list
    set names {}
    if {[info exists subnet_list]} {
    set names [array names subnet_list]
    }
    return $names
}
proc dhcpClient_get {class object refObject op subOp data attr attrValueList osaData} {
    global client_list
    set result {}
    if {![info exists client_list] || \
    [lsearch [array names client_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options $client_list($object)
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpClient_add {class object refObject op subOp data attr attrValueList osaData} {
    global client_list
    if {[info exists client_list] && \
    [lsearch [array names client_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return
    }
    keylget attrValueList options options
    dhcp:defAdd client $object $options
    dhcp:write
}
proc dhcpClient_remove {class object refObject op subOp data attr attrValueList osaData} {
    global client_list
    if {![info exists client_list] || \
    [lsearch [array names client_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE [list $object]
    return
    }
    dhcp:defRemove client $object
    dhcp:write
}
proc dhcpClient_list {class object refObject op subOp data attr attrValueList osaData} {
    global client_list
    set names {}
    if {[info exists client_list]} {
    set names [array names client_list]
    }
    return $names
}
proc dhcpUserClass_get {class object refObject op subOp data attr attrValueList osaData} {
    global user_class_list
    set result {}
    if {![info exists user_class_list] || \
    [lsearch [array names user_class_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options $user_class_list($object)
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpUserClass_add {class object refObject op subOp data attr attrValueList osaData} {
    global user_class_list
    if {[info exists user_class_list] && \
    [lsearch [array names user_class_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return
    }
    keylget attrValueList options options
    dhcp:defAdd user_class $object $options
    dhcp:write
}
proc dhcpUserClass_remove {class object refObject op subOp data attr attrValueList osaData} {
    global user_class_list
    if {![info exists user_class_list] || \
    [lsearch [array names user_class_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE [list $object]
    return
    }
    dhcp:defRemove user_class $object
    dhcp:write
}
proc dhcpUserClass_list {class object refObject op subOp data attr attrValueList osaData} {
    global user_class_list
    set names {}
    if {[info exists user_class_list]} {
    set names [array names user_class_list]
    }
    return $names
}
proc dhcpVendorClass_get {class object refObject op subOp data attr attrValueList osaData} {
    global vendor_class_list
    set result {}
    if {![info exists vendor_class_list] || \
    [lsearch [array names vendor_class_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options $vendor_class_list($object)
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpVendorClass_add {class object refObject op subOp data attr attrValueList osaData} {
    global vendor_class_list
    if {[info exists vendor_class_list] && \
    [lsearch [array names vendor_class_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return
    }
    keylget attrValueList options options
    dhcp:defAdd vendor_class $object $options
    dhcp:write
}
proc dhcpVendorClass_remove {class object refObject op subOp data attr attrValueList osaData} {
    global vendor_class_list
    if {![info exists vendor_class_list] || \
    [lsearch [array names vendor_class_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE [list $object]
    return
    }
    dhcp:defRemove vendor_class $object
    dhcp:write
}
proc dhcpVendorClass_list {class object refObject op subOp data attr attrValueList osaData} {
    global vendor_class_list
    set names {}
    if {[info exists vendor_class_list]} {
    set names [array names vendor_class_list]
    }
    return $names
}
proc dhcpOption_get {class object refObject op subOp data attr attrValueList osaData} {
    global option_list
    set result {}
    if {![info exists option_list] || \
    [lsearch [array names option_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options $option_list($object)
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpOption_add {class object refObject op subOp data attr attrValueList osaData} {
    global option_list
    if {[info exists option_list] && \
    [lsearch [array names option_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return
    }
    keylget attrValueList options options
    dhcp:defAdd option $object $options
    dhcp:write
}
proc dhcpOption_remove {class object refObject op subOp data attr attrValueList osaData} {
    global option_list
    if {![info exists option_list] || \
    [lsearch [array names option_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE [list $object]
    return
    }
    dhcp:defRemove option $object
    dhcp:write
}
proc dhcpOption_list {class object refObject op subOp data attr attrValueList osaData} {
    global option_list
    set names {}
    if {[info exists option_list]} {
    set names [array names option_list]
    }
    return $names
}
proc dhcpGlobal_get {class object refObject op subOp data attr attrValueList osaData} {
    global global_list
    set result {}
    if {![info exists global_list] || \
    [lsearch [array names global_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options $global_list($object)
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpGlobal_add {class object refObject op subOp data attr attrValueList osaData} {
    global global_list
    if {[info exists global_list] && \
    [lsearch [array names global_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return
    }
    keylget attrValueList options options
    dhcp:defAdd global $object $options
    dhcp:write
}
proc dhcpGlobal_remove {class object refObject op subOp data attr attrValueList osaData} {
    global global_list
    if {![info exists global_list] || \
    [lsearch [array names global_list] $object] == -1} {
    return
    }
    if {[keylget attrValueList options options]} {
    foreach key [keylkeys options] {
        dhcp:defRemove global $object $key
    }
    } else {
    dhcp:defRemove global $object
    }
    dhcp:write
}
proc dhcpGlobal_list {class object refObject op subOp data attr attrValueList osaData} {
    global global_list
    set names {}
    if {[info exists global_list]} {
    set names [array names global_list]
    }
    return $names
}
proc dhcpStandard_get {class object refObject op subOp data attr attrValueList osaData} {
    global standard_list
    set result {}
    if {![info exists standard_list] || \
    [lsearch [array names standard_list] $object] == -1} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    } else {
    foreach attr [keylkeys attrValueList $attr] {
        switch -exact $attr {
        options {
            keylset result options $standard_list($object)
        }
        default {
            ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
        }
    }
    }
    return $result
}
proc dhcpStandard_add {class object refObject op subOp data attr attrValueList osaData} {
}
proc dhcpStandard_remove {class object refObject op subOp data attr attrValueList osaData} {
}
proc dhcpStandard_list {class object refObject op subOp data attr attrValueList osaData} {
    global standard_list
    set names {}
    if {[info exists standard_list]} {
    set names [array names standard_list]
    }
    return $names
}
proc dhcpServer_get {class object refObject op subOp data attr attrValueList osaData} {
    global server_list
    set result {}
    if {![cequal $object server]} {
    ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_OBJECT_INSTANCE \
        [list $object]
    }
    if {![info exists server_list] || \
    [lsearch [array names server_list] $object] == -1} {
    set serverInfo {}
    } else {
    set serverInfo $server_list($object)
    }
    foreach attr [keylkeys attrValueList $attr] {
    switch -exact $attr {
        options {
        keylset result options \
            [ServerAddDefault $serverInfo]
        }
        default {
        ErrorPush {} 1 SCO_OSA_ERR_NO_SUCH_ATTRIBUTE \
            [list $attr] [list $class]
        }
    }
    }
    return $result
}
proc dhcpServer_add {class object refObject op subOp data attr attrValueList osaData} {
    global server_list
    if {[info exists server_list] && \
    [lsearch [array names server_list] $object] != -1} {
    ErrorPush {} 1 SCO_OSA_ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE \
        [list $object]
    return -1
    }
    keylget attrValueList options options
    set ret [dhcp:defAdd server $object $options]
    if {$ret > 0} {
    dhcp:write
    }
    return $ret
}
proc dhcpServer_remove {class object refObject op subOp data attr attrValueList osaData} {
    global server_list
    if {![info exists server_list] || \
    [lsearch [array names server_list] $object] == -1} {
    return
    }
    dhcp:defRemove server $object
    dhcp:write
}
proc dhcpServer_list {class object refObject op subOp data attr attrValueList osaData} {
    return server
}
OFBinding sco_dhcpSubnet_CDT
OFBinding sco_dhcpClient_CDT
OFBinding sco_dhcpUserClass_CDT
OFBinding sco_dhcpVendorClass_CDT
OFBinding sco_dhcpOption_CDT
OFBinding sco_dhcpGlobal_CDT
OFBinding sco_dhcpStandard_CDT
OFBinding sco_dhcpServer_CDT
dhcp:init