path: root/src/build/hwpf/prcd_server.tcl

# IBM_PROLOG_BEGIN_TAG
# This is an automatically generated prolog.
#
# $Source: src/build/hwpf/prcd_server.tcl $
#
# OpenPOWER HostBoot Project
#
# COPYRIGHT International Business Machines Corp. 2011,2014
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing
# permissions and limitations under the License.
#
# IBM_PROLOG_END_TAG
# the next line restarts using tclsh\
exec tclsh "$0" "$@"


# Name: prcd_server.tcl - Compile a hardware procedure provided by a client.
#
# Based on if_server.tcl by Doug Gilbert


set PNOR_version "1.4"
set version "1.5"

############################################################################
# Accept is called when a new client request comes in
# An event is forked that calls AquireData whenever the socket becomes 
# readable the main thread continues to run looking for more client requests
############################################################################
proc Accept { sock addr port} {
    global socklist
    global log
    global keepsandbox
    global fulldirectory

    # reset some per-connection variables that don't always get sent
    set keepsandbox 0
    set fulldirectory 0

    puts "[clock format [clock seconds]]: Accept $sock from $addr port $port"
    puts $log "$port: [clock format [clock seconds]]: Accept $sock from $addr port $port"
    set socklist(addr,$sock) [list $addr $port]
    fconfigure $sock -buffering line
    fileevent $sock readable [list AquireData $sock]
}

############################################################################
# AquireData is called whenever there is data avaiable from a client.
# with line buffering on sock, this means when a line is 
# Processes commands and collect data from client
############################################################################
proc AquireData { sock } {
    global socklist
    global sandbox
    global forever
    global sb_dir
    global sbname
    global hwpfile
    global git_sh
    global backing
    global log
    global running
    global driver
    global keepsandbox
    global client_version
    global fulldirectory
    global fips_dir

    if { [eof $sock] || [catch {gets $sock line}] } {
        puts "ERROR: Client closed unexpectedly"
        puts $log "$sock: Client closed unexpectedly"
        CloseOut $sock
    } else {
        if { [string compare $line "quit"] == 0 } {
            close $socklist(main)
            puts $sock "hw procedure compiler server is terminating"
            puts $log "$sock: hw procedure compiler server is terminating"
            CloseOut $sock
            set forever 0
        } elseif {[regexp {:DRIVER +(.+) +(.+)} $line a b c] } {

            ################################################################
            # Make a unique sandbox backed to the driver specified
            # Do a workon to the sandbox.
            ################################################################
            set fipslevel $b
            set driver $c
            puts $log "$sock: Input: fipslevel \"$fipslevel\", driver \"$driver\""

            # if either is default, determine proper.
            if {[string compare $fipslevel "default"] == 0} {
                if {[string compare $driver "default"] == 0} {
                    set driver master
                 }
            } else {
                set lvl [ string trimleft $fipslevel 'abcdefghijklmnopqrstuvwxyz0123456789_' ]
                set lvl [ string trimleft $lvl '.' ]
                set fips_dir "/esw/fips$lvl/Builds/$fipslevel/"
                if {[string compare $driver "default"] == 0} {
                    # use the fips build to determine the hostboot driver
                    set fips_notes "$fips_dir/src/hbfw/releaseNotes.html"
                    if { [catch {set driver [ exec sed -n "s%<h1>Level: %%p" $fips_notes ] } ] } {
                        puts $sock "ERROR: bad FIPS level - can't find $fips_notes\n"
                        puts $log "$sock: bad FIPS level - can't find $fips_notes\n)"
                        flush $log
                        CloseOut $sock
                        return
                    } else {
                        set pos [ string last "</h1>" $driver ]
                        incr pos -1
                        set driver [ string range $driver 0 $pos ]
                    }
                }
            }
            puts $log "$sock: Using: fipslevel \"$fipslevel\", driver \"$driver\""

            ################################################################
            # create git repository
            ################################################################
            set sbname($sock) "sb[string range [clock seconds] 4 end]"

            puts $sock "$sbname($sock)"
            puts $log "$sock: $sbname($sock)"
            flush $log

            # Make sure sandbox dir exists
            if {[catch {file mkdir "$sb_dir/$sbname($sock)"} res ] } {
                puts $sock "ERROR: sandbox mkdir failed\n"
                puts $log "$sock: sandbox mkdir failed\n)"
                CloseOut $sock
            } else {
                set git_sh($sock) [open "|bash" r+]
                fconfigure $git_sh($sock) -buffering none
                fileevent $git_sh($sock) readable [list IfResult $git_sh($sock) $sock $sbname($sock)]

                ExtractSandbox $sock $git_sh($sock)
            }

        } elseif {[regexp {:HWP_FILE +(.+) +(.+)} $line a b c] } {

            ################################################################
            # Open the hw procedure file in the hw procedure directory
            ################################################################
            #puts $log "$sock: Input File $b $c"
            #flush $log

            if { ![info exists sbname($sock)] } {
                puts $sock "ERROR: No sandbox found"
                puts $log "$sock: No sandbox found"
                CloseOut $sock
                return
            }

            ################################################################
            # Find the path to the file in the git sandbox
            # We will only look in the hwpf/hwp directories (usr and include/usr)
            # which should be enough. ANY file in there can be replaced, though
            # the prcd_compile.tcl script inforces *.{c,C,h,H,initfile,xml} files only.
            ################################################################

            set src_path $sb_dir/$sbname($sock)/src/usr/hwpf/hwp
            set inc_path $sb_dir/$sbname($sock)/src/include/usr/hwpf/hwp
            if { $fulldirectory == 1 } {
              set filename [file tail $b]
            } else {
              set filename $b
            }

            if { ![file exists $src_path] } {
                puts $sock "ERROR: sandbox directory not found"
                puts $log "$sock: sandbox directory not found"
                CloseOut $sock
                return
            }

            # we can't just find -name $filename because that won't find path/filename. -wholename does
            #  that, but we need the $filename to not have any ./ prefix if the user included that.
            # additionally, find usually outputs the file(s) separated by a newline. if there
            #  is a filename that's not unique, we need to flag that as an erorr, so we use the
            #  -printf to force them all onto 1 line.
            set filen [ exec find $src_path $inc_path -type f -wholename */[ string trimleft $filename "./" ] -printf "%p\t" ] 
            # and then truncate the last \t. yeah, hackish..
            set filen [ string trimright $filen "\t" ]
            #puts $log "$sock: find found in hostboot sandbox: \"$filen\""
            # error if filen is not just 1 file
            set filesfound [regexp -all {[^\t]+} $filen ]
            if { $filesfound == 0 } {
              if { $fulldirectory == 1 } {
                # do nothing..
                puts $log "$sock: Ignoring Input File - $filename - file not found in hostboot sandbox"
                puts $sock "Ignoring Input File - $filename - file not found in hostboot sandbox"
                # read the file and just throw it away
                if {[catch {set devnull [open "/dev/null" w] } res ] } {
                    puts $sock "ERROR: Server can't open /dev/null"
                    puts $log "$sock: Server can't open /dev/null"
                    CloseOut $sock
                } else {
                    fconfigure $devnull -translation binary
                    fconfigure $sock -translation binary
                    fcopy $sock $devnull -size $c
                    close $devnull
                    fconfigure $sock -translation auto
                    puts $sock ":DONE"
                    puts $log "$sock: DONE"
                    flush $log
                }
                return
              } else {
                puts $sock "ERROR: Invalid Input File - $filename - file not found in hostboot sandbox"
                puts $log "$sock: Invalid Input File - $filename - file not found in hostboot  sandbox"
                CloseOut $sock
                return
              }
            }
            if { $filesfound > 1 } {
              if { $fulldirectory == 1 } {
                # do nothing..
                puts $log "$sock: Ignoring Input File - $filename - file not unique in hostboot sandbox"
                puts $sock "Ignoring Input File - $filename - file not unique in hostboot sandbox"
                # read the file and just throw it away
                if {[catch {set devnull [open "/dev/null" w] } res ] } {
                    puts $sock "ERROR: Server can't open /dev/null"
                    puts $log "$sock: Server can't open /dev/null"
                    CloseOut $sock
                } else {
                    fconfigure $devnull -translation binary
                    fconfigure $sock -translation binary
                    fcopy $sock $devnull -size $c
                    close $devnull
                    fconfigure $sock -translation auto
                    puts $sock ":DONE"
                    puts $log "$sock: DONE"
                    flush $log
                }
                return
              } else {
                puts $sock "ERROR: Invalid Input File - $filename - filename NOT unique in hostboot sandbox"
                puts $log "$sock: Invalid Input File - $filename - filename NOT unique in hostboot sandbox"
                CloseOut $sock
                return
              }
            }

            puts $sock "INFO: Input File - $filename - found in hostboot sandbox"
            puts $log "$sock: INFO: Input File - $filename - found in hostboot sandbox"
            # Open with create/overwrite option
            if {[catch {set hwpfile($sock) [open "$filen" w+] } res ] } {
                puts $sock "ERROR: Server can't open $filen"
                puts $log "$sock: Server can't open $filen"
                CloseOut $sock
            } else {
                fconfigure $hwpfile($sock) -translation binary
                fconfigure $sock -translation binary
                fcopy $sock $hwpfile($sock) -size $c
                close $hwpfile($sock)
                fconfigure $sock -translation auto
                puts $sock ":DONE"
                puts $log "$sock: DONE"
                flush $sock
            }
        } elseif {[string compare $line ":HWP_COMPILE"] == 0} {
            set git_sh($sock) [open "|bash" r+]
            fconfigure $git_sh($sock) -buffering none
            fileevent $git_sh($sock) readable [list IfResult $git_sh($sock) $sock $sbname($sock)]
            puts $git_sh($sock) "cd $sb_dir/$sbname($sock)"
            SendSandbox $sock $git_sh($sock)
            puts $sock ":DONE"
            puts $log "$sock: DONE"
            flush $sock
            flush $log
        } elseif {[regexp {:HWP_FILE_NEW +(.+) +(.+)} $line a b c] } {

            ################################################################
            # Open the hw procedure file in the hw procedure directory
            ################################################################
            #puts $log "$sock: Input New File $b $c"
            #flush $log

            if { ![info exists sbname($sock)] } {
                puts $sock "ERROR: No sandbox found"
                puts $log "$sock: No sandbox found"
                CloseOut $sock
                return
            }

            ################################################################
            # determine the path to the file in the git sandbox
            ################################################################
            set newdir $sb_dir/$sbname($sock)/src/usr/hwpf/hwp/mss_new
            set basename [file tail $b]
            set filen $newdir/$basename
            if {![file exists $newdir]} {
                #puts $log "$sock: mkdir \"$newdir\""; flush $log
                eval {exec} "mkdir -p $newdir"
            }

            puts $sock "INFO: Using File - $b"
            puts $log "$sock: INFO: Using File - $b"
            # Open with create/overwrite option
            if {[catch {set hwpfile($sock) [open "$filen" w+] } res ] } {
                puts $sock "ERROR: Server can't open $filen"
                puts $log "$sock: Server can't open $filen"
                CloseOut $sock
            } else {
                fconfigure $hwpfile($sock) -translation binary
                fconfigure $sock -translation binary
                fcopy $sock $hwpfile($sock) -size $c
                close $hwpfile($sock)
                fconfigure $sock -translation auto
                puts $sock ":DONE"
                puts $log "$sock: DONE"
                flush $sock
            }
        } elseif {[string compare $line ":HWP_COMPILE_NEW"] == 0} {
            set git_sh($sock) [open "|bash" r+]
            fconfigure $git_sh($sock) -buffering none
            fileevent $git_sh($sock) readable [list IfResult $git_sh($sock) $sock $sbname($sock)]
            puts $git_sh($sock) "cd $sb_dir/$sbname($sock)"

            ##################################################################
            # create the new tmp makefile
            ##################################################################
            set newdir $sb_dir/$sbname($sock)/src/usr/hwpf/hwp/mss_new
            set new_makefile $newdir/makefile
            #puts $log "$sock: creating makefile \"$new_makefile\"";flush $log
          
            set mkfile {}
            set mkfile [open "$new_makefile" w 0666]
            puts $mkfile "ROOTPATH = ../../../../.."
            puts $mkfile "MODULE = mss_volt"
            puts $mkfile "EXTRAINCDIR += \${ROOTPATH}/src/include/usr/ecmddatabuffer \${ROOTPATH}/src/include/usr/hwpf/fapi \\"
            puts $mkfile "\${ROOTPATH}/src/include/usr/hwpf/plat \${ROOTPATH}/src/include/usr/hwpf/hwp \\"
            puts $mkfile "\${ROOTPATH}/src/usr/hwpf/hwp/include ."
            puts $mkfile "SRCS_c = \$(wildcard *.c)"
            puts $mkfile "SRCS_C = \$(wildcard *.C)"
            puts $mkfile "OBJS = \$(SRCS_c:.c=.o) \$(SRCS_C:.C=.o)"
            puts $mkfile "include \${ROOTPATH}/config.mk"
            flush $mkfile
            close $mkfile

            SendSandboxNew $sock $git_sh($sock)
            puts $sock ":DONE"
            puts $log "$sock: DONE"
            flush $sock
            flush $log
        } elseif {[string compare $line ":HWP_RETRIEVE"] == 0} {
            if { [catch {SendObjFiles $sock "$sb_dir/$sbname($sock)/img"} res]} {
                puts $log "$sock: ERROR: SendObjFiles interrupted: $res\n"
                flush $log
            } else {
                puts $sock ":DONE"
                puts $log "$sock: DONE"
                flush $sock
            }
            if { [catch {SendPnorFiles $sock "$sb_dir/$sbname($sock)/prcd_fsp/obj/ppc/hbfw/img"} res]} {
                puts $log "$sock: ERROR: SendPnorFiles interrupted: $res\n"
                flush $log
            } else {
                puts $sock ":DONE"
                puts $log "$sock: DONE"
                flush $sock
            }
        } elseif {[string compare $line ":HWP_FULL_DIRECTORY"] == 0} {
            puts $log "$sock: HWP_FULL_DIRECTORY"
            puts $log "$sock: DONE"
            puts $sock ":DONE"
            flush $log
            flush $sock
            set fulldirectory 1
        } elseif {[string compare $line ":HWP_DONE"] == 0} {
            puts $sock ":DONE"
            puts $log "$sock: DONE"
            CloseOut $sock
            set line ""
        } elseif {[regexp {:INFO keepsandbox} $line a] } {
            puts $sock ":DONE"
            puts $log "$sock: $a"
            set keepsandbox 1
            flush $sock
            flush $log
        } elseif {[regexp {:INFO userid +(.+) version +(.+)} $line a b c ] } {
            puts $sock ":DONE"
            puts $log "$sock: $a"
            set client_version $c
            flush $sock
            flush $log
        } else {
            # Unrecognized command
            # if it's just blank line then skipt it - else report it
            if {[string length $line] > 0 } {
                puts "Unknown command:$line"
                puts $sock "Unknown command: $line"
                puts $log "$sock: Unknown command: $line"
            }
            if { [catch {puts $sock ":DONE"} res]} {
                puts $log "$sock: ERROR: puts failed: $res\n"
                flush $log
            } else {
                puts $log "$sock: DONE"
                flush $log
                flush $sock
            }
        }
    }
}

##################################################################
# Clean up and close the socket
##################################################################
proc CloseOut { sock } {
    global socklist
    global sandbox
    global sbname
    global sb_dir
    global git_sh
    global backing
    global log
    global keepsandbox

    if {![eof $sock]} { flush $sock }

    puts $log "$sock [clock format [clock seconds]]: Close $socklist(addr,$sock)- "
    flush $log
    close $sock
    puts "[clock format [clock seconds]]: Close $socklist(addr,$sock)- "
    unset socklist(addr,$sock)
    if {[info exists git_sh($sock)] } {
        if { $keepsandbox != 1 } {
            eval {exec} "rm -rf $sb_dir/$sbname($sock)"
        }
        unset git_sh($sock)
        #unset sandbox($sbname($sock))
    }

    if {[info exists sbname($sock)]} { unset sbname($sock) }
    if {[info exists backint($sock)]} { unset backing($sock) }
}

##################################################################
# Sets up the sandbox with the required code from git
##################################################################
proc ExtractSandbox { sock git_sh} {
    global sandbox
    global running
    global sbname
    global sb_dir
    global driver
    global log

    ############################################################
    # Create GIT repository and extract input driver
    # Open a separate pipe which does the extraction and 
    # compiling
    ############################################################
    puts $git_sh "cd $sb_dir/$sbname($sock)"
    puts $git_sh {git init}
    puts $git_sh {git remote add gerrit ssh://jenkins.localhost/hostboot}
    #puts $git_sh {git remote add gerrit ssh://hostboot.gerrit/hostboot}
    puts $git_sh {git fetch gerrit}
    puts $git_sh {git fetch gerrit --tags}

    if {[string compare $driver "master"] == 0} {
        puts $log "$sock: Using master branch"
        puts $git_sh "git checkout -b master gerrit/master"
    } else {
        puts $log "$sock: Using $driver branch"
        puts $git_sh "git checkout -b $sbname($sock) $driver"
    }
                
    ##################################################
    # tell the workon shell to terminate
    ##################################################
    puts $git_sh {echo :DONE}
    flush $git_sh

    ############################################################
    ## if the git_sh is not done by 60 sec, it probably crashed
    ## keep a list of running sandboxes
    ## hopefully processes timeout in the same order they were started
    ## Kick off an event that waits 60 sec then executes
    ############################################################
    lappend running $sbname($sock)
    set timoutid [after 60000 {
        set sandbox([lindex $running 0]) crashed
        lreplace $running 0 0
    } ]

    ############################################################
    ## This thread now waits until an event changes sandbox($sbname)
    ##   either the simulator exits or times out
    ############################################################
    vwait sandbox($sbname($sock))

    ############################################################
    # If the git_sh workon crashed then close the workon shell 
    # else cancel the timout event
    ############################################################
    if { [string compare $sandbox($sbname($sock)) "crashed"] == 0 } {
        if { [catch {close $git_sh} res]} {
            puts $sock "Failed: $res\n"
            puts $log "$sock: Failed: $res\n"
        }
        set sandbox($sbname($sock)) idle
    } else {
        after cancel $timoutid
    }
    flush $sock
    flush $log

    ## just a flag to indicate sandbox is being used
    set sandbox($sbname($sock)) running
    puts $sock ":DONE"
    puts $log "$sock: DONE"
    flush $sock
}

##################################################################
# Sets up the sandbox for the ifcompiler & sends commands
# sets up an event to collect the simulation results
# closes and deletes the sandbox
##################################################################
proc SendSandbox { sock git_sh} {
    global sandbox
    global running
    global sbname
    global log
    global fips_dir

    ##################################################################
    # Start Compile
    ##################################################################

    if {[string length $fips_dir ] > 0} {
        # need to overwrite bbuild
        puts $git_sh "echo $fips_dir > src/build/citest/etc/bbuild;"
    }

    puts $git_sh "source env.bash; BUILD_MINIMAL=1 make -j4;"

    puts $git_sh "export SANDBOXROOT=`pwd`; export SANDBOXNAME=prcd_fsp;\
                  echo \"./hb fipssetup && ./hb prime\" > hbdo; chmod +x hbdo;\
                  SHELL=./hbdo ./hb workon;"

    ##################################################################
    # tell the workon shell to terminate
    ##################################################################
    puts $git_sh {echo :DONE}
    flush $git_sh

    ##################################################################
    ## if the git_sh is not done by 600 sec, it probably crashed
    ## keep a list of running sandboxes
    ## hopefully processes timeout in the same order they were started
    ## Kick off an event that waits 360 sec then executes
    ##################################################################
    lappend running $sbname($sock)
    set timoutid [after 600000 {
       set sandbox([lindex $running 0]) crashed
       lreplace $running 0 0
    } ]

    ##################################################################
    ## This thread now waits until an event changes sandbox($sbname)
    ##   either the simulator exits or timesout
    ##################################################################
    vwait sandbox($sbname($sock))

    ##################################################################
    # If the git_sh workon crashed then close the workon shell else cancel the 
    # timout event
    ##################################################################
    if { [string compare $sandbox($sbname($sock)) "crashed"] == 0 } {
            if { [catch {close $git_sh} res]} {
                puts $sock "Fail: $res\n"
                puts $log "$sock: Fail: $res\n"
            }
        set sandbox($sbname($sock)) idle
    } else {
        after cancel $timoutid
    }

    flush $sock
    flush $log
}

##################################################################
# Sets up the sandbox for the ifcompiler & sends commands
# create a makefile to build the new HWP and build
# sets up an event to collect the simulation results
# closes and deletes the sandbox
##################################################################
proc SendSandboxNew { sock git_sh} {
    global sandbox
    global running
    global sbname
    global log

    ##################################################################
    # Start Compile
    ##################################################################
    set newdir src/usr/hwpf/hwp/mss_new
    puts $git_sh "source env.bash; BUILD_MINIMAL=1 make -j4; make -C $newdir"

    ##################################################################
    # tell the workon shell to terminate
    ##################################################################

    puts $git_sh {echo :DONE}
    flush $git_sh

    ##################################################################
    ## if the git_sh is not done by 600 sec, it probably crashed
    ## keep a list of running sandboxes
    ## hopefully processes timeout in the same order they were started
    ## Kick off an event that waits 600 sec then executes
    ##################################################################
    lappend running $sbname($sock)
    set timoutid [after 600000 {
       set sandbox([lindex $running 0]) crashed
       lreplace $running 0 0
    } ]

    ##################################################################
    ## This thread now waits until an event changes sandbox($sbname)
    ##   either the simulator exits or timesout
    ##################################################################
    vwait sandbox($sbname($sock))

    ##################################################################
    # If the git_sh workon crashed then close the workon shell else cancel the 
    # timout event
    ##################################################################
    if { [string compare $sandbox($sbname($sock)) "crashed"] == 0 } {
            if { [catch {close $git_sh} res]} {
                puts $sock "Fail: $res\n"
            puts $log "$sock: Fail: $res\n"
            }
        set sandbox($sbname($sock)) idle
    } else {
        after cancel $timoutid
    }

    flush $sock
    flush $log
}

##################################################################
# This is a list of regular expressions.  Any line sent to stdout during
# mk processing that matches one of these expressions will be sent to the 
# client.  Note: Everything from stderr gets returned
##################################################################

set explist [list  {^make.*Error.*} {.*NOT FOUND.*} {ERROR:.*} {error:.*} {^IfScrub..E>.*} {^Parse Error.*} {^Error.*} {^exception caught.*} ]

##################################################################
## This event catches the output of the sandbox when the pipe become readable
## and sends it back to the client.
## The git_sh pipe is closed when the full result has been processed
##################################################################
proc IfResult { git_sh sock sbname_sock } {
    global sandbox
    global explist
    global log

    if { [eof $git_sh] || [catch {gets $git_sh line}] } {
        puts $sock "compile unexpectedly terminated. sandbox $sbname_sock"
        puts $log "$sock: compile unexpectedly terminated. sandbox $sbname_sock"

        if { [catch {close $git_sh} res] } {
            puts $sock "error is $res\n"
            puts $log "$sock: error is $res\n"
        }
        set sandbox($sbname_sock) "idle"
    } else {

        # Uncomment to send back all compile output
        #puts $sock "$sock $line"
        #puts $log "$sock: $line"
        #flush $log

        if { [string compare $line ":DONE"] == 0 } {
            if { [catch {close $git_sh} res]} {
                #res has the stderr
                # Need to weed out the junk
                set rlines [split $res "\n"]
                foreach rline $rlines {
                    # weed out the errors from mk
                    foreach exp $explist {
                        if {[regexp $exp $rline a] } {
                            puts $sock "error: $rline"
                            puts $log "$sock: error: $rline"
                        }
                    }
                }
            }

            puts $sock "Exit Sandbox"
            puts $log "$sock: Exit Sandbox"
            flush $log
            set sandbox($sbname_sock) "idle"

        } else {
            foreach exp $explist {
               if {[regexp $exp $line a]} {
                   puts $sock "error: $line"
                   puts $log "$sock: error: $line"
               }
            }
        }
    }
    flush $log
}


##################################################################
# send the *.bin, *.sims and hbotStringFile files from the compile 
#  back to the client
##################################################################
proc SendObjFiles { sock obj_dir } {
    global log

    set img_files {}

    # Send the image files
    if {[catch {set img_files [glob -dir $obj_dir hbi*syms hbi*list hbi*modinfo *pnor *dat hbotStringFile errlparser isteplist.csv]} res]} {
        puts $sock "ERROR: Needed image files not found in $obj_dir"
        puts $log "$sock: Needed image files not found in $obj_dir"
    } else {
        SendFiles "OBJ_FILE" $sock $img_files
    }

    flush $sock
    flush $log
}

##################################################################
#  back to the client
##################################################################
proc SendPnorFiles { sock obj_dir } {
    global log
    global PNOR_version
    global client_version

    set pnor_files {}

    # Send the image files
    if {[catch {set pnor_files [glob -dir $obj_dir hostboot.header.bin hostboot_extended.header.bin hostboot_runtime.header.bin]} res]} {
        puts $sock "ERROR: Needed image files not found in $obj_dir"
        puts $log "$sock: Needed image files not found in $obj_dir"
    } else {
        if { $client_version < $PNOR_version } {
            # client can't handle PNOR_FILE type, so just send the files
            #  back and they'll get put into the <outputdir>
            SendFiles "OBJ_FILE" $sock $pnor_files
        } else {
            # tell client to put these in <outputdir>/pnor
            SendFiles "PNOR_FILE" $sock $pnor_files
        }
    }

    flush $sock
    flush $log
}

##################################################################
# Send a file to the client
##################################################################
proc SendFiles { type sock files } {
    global log

    foreach f $files {
        set size [file size $f]
        puts $sock ":$type [file tail $f] $size"
        puts $log "$sock: :$type [file tail $f] $size"
        fconfigure $sock -translation binary
        set fp [open $f r]
        fconfigure $fp -translation binary
        fcopy $fp $sock -size $size
        close $fp
        fconfigure $sock -translation auto
    }
    flush $log
}

##################################################################
# main
##################################################################
set forever 1
#set base_dir "./"
set base_dir "/tmp"
set home_dir $::env(HOME)
set logfile "$home_dir/prcd_server.log"
set log {}
set keepsandbox 0
set client_version 0
set fulldirectory 0
set fips_dir ""

# Where are we running?
foreach {host site c d} [split [exec hostname] .]  break
if {[string compare $host {gfw160}] == 0} {
    set sb_dir "$base_dir/hwp/"
    eval {exec} "mkdir -p $sb_dir"
} else {
    puts "Invalid Location to run server!"
    exit -1
}

# array to keep track of ode sandboxes and thier state
array set sandbox {
    sb00000000 idle
}

array set backing {}

if { [file exists $logfile] } {
    set log [open "$logfile" a]
} else {
    set log [open "$logfile" w 0666]
}

puts "Logfile: $logfile $log"
exec chmod 666 $logfile

puts "[clock format [clock seconds]]: HWP compiler Server is starting"
puts $log "[clock format [clock seconds]]: HWP compiler Server is starting"
flush $log

set socklist(main) [socket -server Accept 7779]

# By catching errors from vwait- we can ignore them
catch {vwait forever}