}

		return $retval
	}

	return "unknown"
}

proc ::rivetstarkit::puts_log {logfd msg} {
	if {$logfd == ""} {
		return
	}

	catch {
		tcl_puts $logfd $msg

		flush $logfd
	}
}

proc print_help {} {
	tcl_puts "Usage: [file tail [info nameofexecutable]] {--server \[--address <address>\]"
	tcl_puts "       \[--port <port>\] \[--foreground {yes|no}\] \[--init <scp>\]"
	tcl_puts "       \[--logfile {-|<file>}\] \[--errorlog {-|<file>}\] \[--maxthreads <num>\]"
	tcl_puts "       \[--sslport <port>\] \[--sslcert <file>\] \[--sslkey <file>\]"
	tcl_puts "       \[--sslcafile <file>\] \[--sslcadir <dir>\] \[--sslreqcert {yes|no}\]"

}

proc rivet_cgi_tls_callback {logfd elogfd mode args} {
	switch -- $mode {
		"error" {
			foreach {chan msg} $args break


			::rivetstarkit::puts_log $elogfd "($chan) TLS error: $msg"


			return 1
		}
		"verify" {
			foreach {chan depth cert rc err} $args break

			# Only care about client certificates, all others follow normal rules
			if {$depth != 0} {
				return $rc
			}

			if {$rc != "1"} {
				# Do not note that this certificate is valid, but return OK


				::rivetstarkit::puts_log $elogfd "($chan) Invalid cert $cert: $err"


				set ::rivet_cgi_tls_verified($chan) 0

				return 1
			}

			if {![info exists ::rivet_cgi_tls_verified($chan)]} {

			if {![info exists ::rivetstarkit::threadinfo]} {
				array set ::rivetstarkit::threadinfo {}
			}

			unset -nocomplain threadId
			foreach {thread isInUse} [array get ::rivetstarkit::threadinfo] {
				if {!$isInUse} {
					::rivetstarkit::puts_log $elogfd "Using existing thread: $thread"

					set threadId $thread
					break
				}
			}

			# If none found, make sure we haven't exceeded the maximum number of threads
			if {![info exists threadId]} {
				set numthreads [llength [thread::names]]
				if {$numthreads > $maxthreads} {
					::rivetstarkit::puts_log $elogfd "Exceeded maximum number of threads ($maxthreads): $numthreads, closing socket!"

					unset -nocomplain ::rivet_cgi_tls_verified($sock)

					close $sock

					return
				}
			}

			# If none found, create one...
			if {![info exists threadId]} {
				# Create an empty interpreter in a new thread
				set threadId [thread::create]
				::rivetstarkit::puts_log $elogfd "Creating thread: $threadId"

				# Load the needed packages in the new thread
				thread::send $threadId [list package require tclrivet]
				thread::send $threadId [list set ::rivet::parsestack [info script]]

				# Copy the appropriate namespaces to the new thread
				foreach ns [list ::rivetstarkit] {

						thread::send $threadId [list set $var [set $var]]
					} else {
						thread::send $threadId [list unset -nocomplain $var]
					}
				}

				# Copy the appropriate procedures to the new thread
				foreach proc [list rivet_cgi_server_request_data rivet_cgi_server_request call_page ::rivetstarkit::puts_log] {
					if {[namespace qualifiers $var] != ""} {
						thread::send $threadId [list namespace eval [namespace qualifiers $var] ""]
					}

					set procargs [list]
					foreach arg [info args $proc] {
						if {[info default $proc $arg defval]} {
							lappend procargs [list $arg $defval]
						} else {
							lappend procargs $arg
						}
					}

					thread::send $threadId [list proc $proc $procargs [info body $proc]]
				}

				::rivetstarkit::puts_log $elogfd " ... done creating thread ($threadId)"
			}

			# Mark the specified thread as in-use
			set ::rivetstarkit::threadinfo($threadId) 1

			# Perform the bottom-half of the processing (we are required to re-enter the event loop)
			after idle [list rivet_cgi_server_request $hostport $logfd $elogfd "thread-parent" 0 $httpmode $sock $addr $port $threadId]

			return
		}
		"thread-parent" {
			set pmodel "thread"

			# Transfer the socket to the thread, and specify our thread Id
			thread::transfer $threadId $sock

			::rivetstarkit::puts_log $elogfd "Calling child thread to handle request ($threadId) in background"
			thread::send -async $threadId [list rivet_cgi_server_request $hostport "" "" "thread-child" 0 $httpmode $sock $addr $port [thread::id]]
			::rivetstarkit::puts_log $elogfd " ... done ($threadId)."

			return
		}
		"thread-child" {
			set pmodel "thread"

			set parentThreadId $threadId
			unset threadId

		unset -nocomplain ::rivet_cgi_tls_verified($sock)

		catch {
			close $sock
		}
	} err]} {

		::rivetstarkit::puts_log $elogfd "Error while installing callback: \"$err\""

	}

	switch -- $pmodel {
		"fork" {
			exit
		}
		"thread" {
			# Mark the thread as free

			::rivetstarkit::puts_log $elogfd "Marking thread as free ([thread::id])"


			thread::send -async $parentThreadId [list set ::rivetstarkit::threadinfo([thread::id]) 0]


			::rivetstarkit::puts_log $elogfd " ... done ([thread::id])."

		}
	}
}

proc rivet_cgi_server_request_data {sock addr hostport logfd elogfd pmodel} {
	if {[catch {
		array set sockinfo $::rivetstarkit::sockinfo($sock)

			if {[catch {
				if {$pmodel == "flat"} {
					set result [call_page [array get myenv] 1]
				} else {
					set result [call_page [array get myenv] 0]
				}


				::rivetstarkit::puts_log $logfd "$addr - - \[[clock format [clock seconds] -format {%d/%b/%Y:%H:%M:%S %z}]\] \"$sockinfo(requestline)\" 200 0 \"-\" \"$ua\""


			} err]} {

				::rivetstarkit::puts_log $logfd "$addr - - \[[clock format [clock seconds] -format {%d/%b/%Y:%H:%M:%S %z}]\] \"$sockinfo(requestline)\" 500 0 \"-\" \"$ua\" \"Error: [join [split $err {"\n}]]\""




				::rivetstarkit::puts_log $elogfd "($sock/$addr/[pid]) $err"
				::rivetstarkit::puts_log $elogfd "($sock/$addr/[pid]) $::errorInfo"


			}

			# Cleanup
			unset sockinfo
			set sockinfo(state) NEW

			if {$headers(CONNECTION) != "keep-alive" || $result != "keep-alive"} {
				# Tell the event loop that we're done here.
				set ::rivetstarkit::finished($sock) 1
			} else {
				fconfigure $sock -buffering line
				fconfigure $sock -translation crlf
				fileevent $sock readable [list rivet_cgi_server_request_data $sock $addr $hostport $logfd $elogfd $pmodel]
			}
		}
 
		set ::rivetstarkit::sockinfo($sock) [array get sockinfo]
	}] == "1"} {
		# In case of error, abort.
		set ::rivetstarkit::finished($sock) 1

		::rivetstarkit::puts_log $elogfd "($sock/$addr/[pid]) $::errorInfo"


	}
}


# Determine if we are being called as a CGI, or from the command line
if {![info exists ::env(GATEWAY_INTERFACE)]} {
	set cmd [lindex $argv 0]