;;;
;;; cookie.scm - parse and construct http state information
;;;  
;;;   Copyright (c) 2000-2003 Shiro Kawai, All rights reserved.
;;;   
;;;   Redistribution and use in source and binary forms, with or without
;;;   modification, are permitted provided that the following conditions
;;;   are met:
;;;   
;;;   1. Redistributions of source code must retain the above copyright
;;;      notice, this list of conditions and the following disclaimer.
;;;  
;;;   2. Redistributions in binary form must reproduce the above copyright
;;;      notice, this list of conditions and the following disclaimer in the
;;;      documentation and/or other materials provided with the distribution.
;;;  
;;;   3. Neither the name of the authors nor the names of its contributors
;;;      may be used to endorse or promote products derived from this
;;;      software without specific prior written permission.
;;;  
;;;   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;;   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;;   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;;   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;;   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;;   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
;;;   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;;;   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;;;   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;;   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;;   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;  
;;;  Ported to Chicken by Reed Sheridan
;;;

;; Parser and constructor of http "Cookies" defined in
;; RFC 2965 HTTP state managemnet mechanism
;;   <ftp://ftp.isi.edu/in-notes/rfc2965.txt>
;; See also
;; RFC 2964 Use of HTTP state management
;;   <ftp://ftp.isi.edu/in-notes/rfc2964.txt>
;; The parser also supports the old Netscape spec
;;   <http://www.netscape.com/newsref/std/cookie_spec.html>


(require-extension srfi-1 srfi-13 srfi-14 regex)
(declare (export parse-cookie-string construct-cookie-string))

#>
#include <time.h>
<#

(define fmt-time
  (foreign-lambda* c-string ((long secs_since_epoch))
    "static char buf[256];"
    "time_t t = (time_t) secs_since_epoch;"
    "strftime(buf, sizeof(buf), \"%a, %d-%b-%Y %H:%M:%S GMT\", gmtime(&t));"
    "return(buf);"))

;; utility fn.  breaks  ``attr=value;attr=value ... '' into alist.
;; version is a cookie version.  if version>0, we allow comma as the
;; delimiter as well as semicolon.
(define (parse-av-pairs input version)
  (define attr-regexp
    (if (= version 0)
        (regexp "\\s*([\\w$_-]+)\\s*([=\\;]\\s*)?")
        (regexp "\\s*([\\w$_-]+)\\s*([=\\;,]\\s*)?")))
  (define attr-delim
    (if (= version 0) #\; (char-set #\, #\\ #\;)))
  
  (define (read-attr input r)
    (cond ((string-null? input) (reverse! r))
          ((string-search attr-regexp input)
           => (lambda (m)
                (if (and-let* ((delimiter (third m))) ;;is an attr_value pai
		      (string-prefix? "=" delimiter))
                    (let ((attr (second m))
                          (rest (string-search-after attr-regexp input)))
                      (if (string-prefix? "\"" rest)
                          (read-token-quoted attr (string-drop rest 1) r)
                          (read-token attr rest r)))
                    (read-attr (string-search-after attr-regexp input) ;; Skip ahead if broken input?
                               (alist-cons (second m) #f r)))))
          (else
           ;; the input is broken; for now, we ignore the rest.
           (reverse! r))))
  (define (read-token attr input r)
    (cond ((string-index input attr-delim)
           => (lambda (i)
                (read-attr (string-drop input (+ i 1))
                           (alist-cons attr
				       (string-trim-right (string-take input i))
				       r))))
          (else
           (reverse! (alist-cons attr (string-trim-right input) r)))))
  (define (read-token-quoted attr input r)
    (let loop ((input input)
               (partial '()))
      (cond ((string-index input (char-set #\\ #\"))
             => (lambda (i)
                  (let ((c (string-ref input i)))
                    (if (char=? c #\\)
                        (if (< (string-length input) (+ i 1))
                            (error-unterminated attr)
                            (loop (string-drop input (+ i 2))
                                  (cons* (string (string-ref input (+ i 1)))
                                         (string-take input i)
                                         partial)))
                        (read-attr (string-drop input (+ i 1))
                                   (alist-cons attr
					       (string-concatenate-reverse
						(cons (string-take input i)
						      partial))
					       r))))))
            (else (error-unterminated attr)))))
  (define (error-unterminated attr)
    (error "Unterminated quoted value given for attribute" attr))

  (read-attr input '()))

;; Parses the header value of "Cookie" request header.
;; If cookie version is known by "Cookie2" request header, it should
;; be passed to version (as integer).  Otherwise, it figures out
;; the cookie version from input.
;;
;; Returns the following format.
;;   ((<name> <value> [:path <path>] [:domain <domain>] [:port <port>])
;;    ...)

(define (parse-cookie-string input #!optional version)
  (let ((ver (cond ((integer? version) version)
                   ((string-search "^\\s*\\$Version\\s*=\\s*(\\d+)" input)
                    => (lambda (m)
                         (string->number (cadr m))))
                   (else 0))))
    (let loop ((av-pairs (parse-av-pairs input ver))
               (r '())
               (current '()))
      (cond ((null? av-pairs)
             (if (null? current)
                 (reverse r)
                 (reverse (cons (reverse current) r))))
            ((string-ci=? "$path" (caar av-pairs))
             (loop (cdr av-pairs) r (cons* (cdar av-pairs) path: current)))
            ((string-ci=? "$domain" (caar av-pairs))
             (loop (cdr av-pairs) r (cons* (cdar av-pairs) domain: current)))
            ((string-ci=? "$port" (caar av-pairs))
             (loop (cdr av-pairs) r (cons* (cdar av-pairs) port: current)))
            (else
             (if (null? current)
                 (loop (cdr av-pairs) r (list (cdar av-pairs) (caar av-pairs)))
                 (loop (cdr av-pairs)
                       (cons (reverse current) r)
                       (list (cdar av-pairs) (caar av-pairs)))))))))

;; Construct a cookie string suitable for Set-Cookie or Set-Cookie2 header.
;; specs is the following format.
;;
;;   ((<name> <value> [:comment <comment>] [:comment-url <comment-url>]
;;                    [:discard <bool>] [:domain <domain>]
;;                    [:max-age <age>] [:path <value>] [:port <port-list>]
;;                    [:secure <bool>] [:version <version>] [:expires <date>]
;;    ) ...)
;;
;; Returns a list of cookie strings for each <name>=<value> pair.  In the
;; ``new cookie'' implementation, you can join them by comma and send it
;; at once with Set-cookie2 header.  For the old netscape protocol, you
;; must send each of them by Set-cookie header.


(define (construct-cookie-string specs #!optional (version 1))
  (map (lambda (spec) (construct-cookie-string-1 spec version))
       specs))

(define (construct-cookie-string-1 spec ver)
  (when (< (length spec) 2)
    (error "bad cookie spec: at least <name> and <value> required" spec))
  (let ((name (car spec))
        (value (cadr spec)))
    (let loop ((attr (cddr spec))
               (r    (list (if value
                               (string-append name "="
                                              (quote-if-needed value))
                               name))))
      (define (next s) (loop (cddr attr) (cons s r)))
      (define (ignore) (loop (cddr attr) r))
      (cond
       ((null? attr) (string-join (reverse r) ";"))
       ((null? (cdr attr))
        (error (conc "bad cookie spec: attribute " (car attr) " requires value" )))
       ((eqv? comment: (car attr))
        (if (> ver 0)
	    (next (string-append "Comment=" (quote-if-needed (cadr attr))))
            (ignore)))
       ((eqv? comment-url: (car attr))
        (if (> ver 0)
            (next (string-append "CommentURL=" (quote-value (cadr attr))))
            (ignore)))
       ((eqv? discard: (car attr))
        (if (and (> ver 0) (cadr attr)) (next "Discard") (ignore)))
       ((eqv? domain: (car attr))
        (next (string-append "Domain=" (cadr attr))))
       ((eqv? max-age: (car attr))
        (if (> ver 0)
            (next (sprintf "Max-Age=~a" (cadr attr)))
            (ignore)))
       ((eqv? path: (car attr))
        (next (string-append "Path=" (quote-if-needed (cadr attr)))))
       ((eqv? port: (car attr))
        (if (> ver 0)
            (next (string-append "Port=" (quote-value (cadr attr))))
            (ignore)))
       ((eqv? secure: (car attr))
        (if (cadr attr) (next "Secure") (ignore)))
       ((eqv? version: (car attr))
        (if (> ver 0)
            (next (sprintf "Version=~a" (cadr attr)))
            (ignore)))
       ((eqv? expires: (car attr))
        (if (> ver 0)
            (ignore)
            (next (make-expires-attr (cadr attr)))))
       (else (error "Unknown cookie attribute" (car attr))))
      ))
  )


;; (define (quote-value value)
;;   (string-append "\"" (regexp-replace-all #/\"|\\/ value "\\\\\\0") "\""))

(define (quote-value value)
  (string-append "\"" (string-substitute* value '(("\\\"" . "\\\"") ("\\\\" . "\\\\"))) "\""))

(define quote-if-needed
  (let ((rx (regexp "[\\\",;\\\\ \\t\\n]")))
    (lambda (value)
      (if (string-search rx value)
	  (quote-value value)
	  value))))

(define (make-expires-attr time)
  (sprintf "Expires=~a"
	   (if (number? time)
	       (fmt-time time)
	       time)))

;;;; Added support functions from my utils, split this out

(define (string-search-after r s #!optional (start 0))
  (and-let* ((match-indices (string-search-positions r s start))
	     (right-match (second (first match-indices))))
    (substring s right-match)))

;; hashtable
;;   |-formname --> <formdat> 'form-name=formname
;;   |                        'form-data=hashtable
;;   |                                       | name => value
;;
;; New data format is only the <formdat> portion from above

(define-class <formdat> ()
   (form-data
   ))
;; (define-class <formdat> ()
;;    (form-data
;;    ))
(define (make-formdat:formdat)(make-vector (hash-table)))
(define-inline (formdat:formdat-get-data   vec)    (vector-ref  vec 0))
(define-inline (formdat:formdat-set-data!  vec val)(vector-set! vec 0 val))

(define-method (initialize (self <formdat>) initargs)
(define (formdat:initialize self)
  (call-next-method)
  (slot-set! self 'form-data (make-hash-table))
  (formdat:formdat-set-data! self (make-hash-table)))
  (initialize-slots self initargs))

(define-method (formdat:get (self <formdat>) key)
  (hash-table-ref/default (slot-ref self 'form-data) key #f))
(define (formdat:get self key)
  (hash-table-ref/default (formdat:formdat-get-data self) key #f))

;; change to convert data to list and append val if already exists
;; or is a list
(define-method (formdat:set! (self <formdat>) key val)
(define (formdat:set! self key val)
  (let ((prev-val (formdat:get self key))
        (ht       (slot-ref self 'form-data)))
        (ht       (formdat:formdat-get-data self)))
    (if prev-val
        (if (list? prev-val)
            (hash-table-set! ht key (cons val prev-val))
            (hash-table-set! ht key (list val prev-val)))
        (hash-table-set! ht key val))
    self))

(define-method (formdat:keys (self <formdat>))
  (hash-table-keys (slot-ref self 'form-data)))
(define (formdat:keys self)
  (hash-table-keys (formdat:formdat-get-data self)))

(define-method (formdat:printall (self <formdat>) printproc)
(define (formdat:printall self printproc)
  (printproc "formdat:printall " (formdat:keys self))
  (for-each (lambda (k)
	      (printproc k " => " (formdat:get self k)))
	    (formdat:keys self)))

(define-method (formdat:all->strings (self <formdat>))
(define (formdat:all->strings self)
  (let ((res '()))
    (for-each (lambda (k)
                 (set! res (cons (conc k "=>" (formdat:get self k)) res)))
              (formdat:keys self))
        res))

;; call with *one* of the lists in the list of lists created by CGI:url-unquote
(define-method (formdat:load (self <formdat>) formlist)
  (let ((ht             (slot-ref self 'form-data)))
(define (formdat:load self formlist)
  (let ((ht             (formdat:formdat-get-data self)))
    (if (null? formlist) self ;; no values provided, return self for no good reason
        (let loop ((head (car formlist))
                   (tail (cdr formlist)))
          (let ((key (car head))
                (val (cdr head)))
            ;; (err:log "key=" key " val=" val)
	    (if (> (length val) 1)

  (let ((request-method (getenv "REQUEST_METHOD")))
    (if (and request-method
	     (string=? request-method "POST"))
	(formdat:load-all-port (current-input-port)))))

;; (s:process-cgi-input (caaar dat))
(define (formdat:load-all-port inp)
  (let* ((formdat        (make <formdat>)))
  (let* ((formdat        (make-formdat:formdat)))
;;	 (debugp         (open-output-file (conc (slot-ref s:session 'sroot) "/delme-" (current-user-id) ".log"))))
    ;; (write-string (read-string #f inp) #f debugp)
    (let ((alldats (formdat:dat->list inp 10e6)))
      
      ;; (format debugp "formdat : alldats: ~A\n" alldats)
      (let ((firstitem   (car alldats))
	    (multipass #f)) 

;; create table session_vars (id serial not null,session_id integer,page text,key text,value text);

;; TODO
;;  Concept of order num incremented with each page access
;;     if a branch is taken then a new session would need to be created
;;

;; make-vector-record session session dbtype dbinit conn params path-params session-key session-id domain toppage page curr-page content-type page-type sroot twikidir pagedat alt-page-dat pagevars pagevars-before sessionvars sessionvars-before globalvars globalvars-before logpt formdat request-method session-cookie curr-err log-port logfile seen-pages page-dir-style debugmode
(define-class <session> ()
  (dbtype       ;; 'pg or 'sqlite3
   dbinit
(define (make-session:sdat)(make-vector 33))
(define-inline (session:sdat-get-dbtype               vec)    (vector-ref  vec 0))
(define-inline (session:sdat-get-dbinit               vec)    (vector-ref  vec 1))
   conn
   params       ;; params from the key=val&key1=val2 string
   path-params  ;; remaining params from the path
   session-key
   session-id
   domain
   toppage      ;; defaults to "index" - override in .stml.config if desired
   page         ;; the page name - defaults to home
   curr-page    ;; the current page being evaluated
   content-type ;; the default content type is text/html, override to deliver other stuff
   page-type    ;; use in conjunction with content-type to deliver other payloads
   sroot
   twikidir     ;; location for twikis - needs to be fully writable by web server
   pagedat
   alt-page-dat
   pagevars     ;; session vars specific to this page
   pagevars-before
   sessionvars  ;; session vars visible to all pages
   sessionvars-before
   globalvars   ;; global vars visible to all sessions
   globalvars-before
   logpt
   formdat
   request-method
   session-cookie
   curr-err
   log-port
   logfile
   seen-pages
   page-dir-style  ;; #t = new style, #f = old style
   debugmode))
(define-inline (session:sdat-get-conn                 vec)    (vector-ref  vec 2))
(define-inline (session:sdat-get-params               vec)    (vector-ref  vec 3))
(define-inline (session:sdat-get-path-params          vec)    (vector-ref  vec 4))
(define-inline (session:sdat-get-session-key          vec)    (vector-ref  vec 5))
(define-inline (session:sdat-get-session-id           vec)    (vector-ref  vec 6))
(define-inline (session:sdat-get-domain               vec)    (vector-ref  vec 7))
(define-inline (session:sdat-get-toppage              vec)    (vector-ref  vec 8))
(define-inline (session:sdat-get-page                 vec)    (vector-ref  vec 9))
(define-inline (session:sdat-get-curr-page            vec)    (vector-ref  vec 10))
(define-inline (session:sdat-get-content-type         vec)    (vector-ref  vec 11))
(define-inline (session:sdat-get-page-type            vec)    (vector-ref  vec 12))
(define-inline (session:sdat-get-sroot                vec)    (vector-ref  vec 13))
(define-inline (session:sdat-get-twikidir             vec)    (vector-ref  vec 14))
(define-inline (session:sdat-get-pagedat              vec)    (vector-ref  vec 15))
(define-inline (session:sdat-get-alt-page-dat         vec)    (vector-ref  vec 16))
(define-inline (session:sdat-get-pagevars             vec)    (vector-ref  vec 17))
(define-inline (session:sdat-get-pagevars-before      vec)    (vector-ref  vec 18))
(define-inline (session:sdat-get-sessionvars          vec)    (vector-ref  vec 19))
(define-inline (session:sdat-get-sessionvars-before   vec)    (vector-ref  vec 20))
(define-inline (session:sdat-get-globalvars           vec)    (vector-ref  vec 21))
(define-inline (session:sdat-get-globalvars-before    vec)    (vector-ref  vec 22))
(define-inline (session:sdat-get-logpt                vec)    (vector-ref  vec 23))
(define-inline (session:sdat-get-formdat              vec)    (vector-ref  vec 24))
(define-inline (session:sdat-get-request-method       vec)    (vector-ref  vec 25))
(define-inline (session:sdat-get-session-cookie       vec)    (vector-ref  vec 26))
(define-inline (session:sdat-get-curr-err             vec)    (vector-ref  vec 27))
(define-inline (session:sdat-get-log-port             vec)    (vector-ref  vec 28))
(define-inline (session:sdat-get-logfile              vec)    (vector-ref  vec 29))
(define-inline (session:sdat-get-seen-pages           vec)    (vector-ref  vec 30))
(define-inline (session:sdat-get-page-dir-style       vec)    (vector-ref  vec 31))
(define-inline (session:sdat-get-debugmode            vec)    (vector-ref  vec 32))
(define-inline (session:sdat-set-dbtype!              vec val)(vector-set! vec 0 val))
(define-inline (session:sdat-set-dbinit!              vec val)(vector-set! vec 1 val))
(define-inline (session:sdat-set-conn!                vec val)(vector-set! vec 2 val))
(define-inline (session:sdat-set-params!              vec val)(vector-set! vec 3 val))
(define-inline (session:sdat-set-path-params!         vec val)(vector-set! vec 4 val))
(define-inline (session:sdat-set-session-key!         vec val)(vector-set! vec 5 val))
(define-inline (session:sdat-set-session-id!          vec val)(vector-set! vec 6 val))
(define-inline (session:sdat-set-domain!              vec val)(vector-set! vec 7 val))
(define-inline (session:sdat-set-toppage!             vec val)(vector-set! vec 8 val))
(define-inline (session:sdat-set-page!                vec val)(vector-set! vec 9 val))
(define-inline (session:sdat-set-curr-page!           vec val)(vector-set! vec 10 val))
(define-inline (session:sdat-set-content-type!        vec val)(vector-set! vec 11 val))
(define-inline (session:sdat-set-page-type!           vec val)(vector-set! vec 12 val))
(define-inline (session:sdat-set-sroot!               vec val)(vector-set! vec 13 val))
(define-inline (session:sdat-set-twikidir!            vec val)(vector-set! vec 14 val))
(define-inline (session:sdat-set-pagedat!             vec val)(vector-set! vec 15 val))
(define-inline (session:sdat-set-alt-page-dat!        vec val)(vector-set! vec 16 val))
(define-inline (session:sdat-set-pagevars!            vec val)(vector-set! vec 17 val))
(define-inline (session:sdat-set-pagevars-before!     vec val)(vector-set! vec 18 val))
(define-inline (session:sdat-set-sessionvars!         vec val)(vector-set! vec 19 val))
(define-inline (session:sdat-set-sessionvars-before!  vec val)(vector-set! vec 20 val))
(define-inline (session:sdat-set-globalvars!          vec val)(vector-set! vec 21 val))
(define-inline (session:sdat-set-globalvars-before!   vec val)(vector-set! vec 22 val))
(define-inline (session:sdat-set-logpt!               vec val)(vector-set! vec 23 val))
(define-inline (session:sdat-set-formdat!             vec val)(vector-set! vec 24 val))
(define-inline (session:sdat-set-request-method!      vec val)(vector-set! vec 25 val))
(define-inline (session:sdat-set-session-cookie!      vec val)(vector-set! vec 26 val))
(define-inline (session:sdat-set-curr-err!            vec val)(vector-set! vec 27 val))
(define-inline (session:sdat-set-log-port!            vec val)(vector-set! vec 28 val))
(define-inline (session:sdat-set-logfile!             vec val)(vector-set! vec 29 val))
(define-inline (session:sdat-set-seen-pages!          vec val)(vector-set! vec 30 val))
(define-inline (session:sdat-set-page-dir-style!      vec val)(vector-set! vec 31 val))
(define-inline (session:sdat-set-debugmode!           vec val)(vector-set! vec 32 val))

;; (define-class <session> ()
;;   (dbtype       ;; 'pg or 'sqlite3
;;    dbinit
;;    conn
;;    params       ;; params from the key=val&key1=val2 string
;;    path-params  ;; remaining params from the path
;;    session-key
;;    session-id
;;    domain
;;    toppage      ;; defaults to "index" - override in .stml.config if desired
;;    page         ;; the page name - defaults to home
;;    curr-page    ;; the current page being evaluated
;;    content-type ;; the default content type is text/html, override to deliver other stuff
;;    page-type    ;; use in conjunction with content-type to deliver other payloads
;;    sroot
;;    twikidir     ;; location for twikis - needs to be fully writable by web server
;;    pagedat
;;    alt-page-dat
;;    pagevars     ;; session vars specific to this page
;;    pagevars-before
;;    sessionvars  ;; session vars visible to all pages
;;    sessionvars-before
;;    globalvars   ;; global vars visible to all sessions
;;    globalvars-before
;;    logpt
;;    formdat
;;    request-method
;;    session-cookie
;;    curr-err
;;    log-port
;;    logfile
;;    seen-pages
;;    page-dir-style  ;; #t = new style, #f = old style
;;    debugmode))

;; SPLIT INTO STRAIGHT FORWARD INIT AND COMPLEX INIT
(define-method (initialize (self <session>) initargs)
(define (initialize self)
  (call-next-method)
  (slot-set! self 'dbtype      'pg)
  (slot-set! self 'page        "home")        ;; these are defaults
  (slot-set! self 'curr-page   "home")
  (slot-set! self 'content-type "Content-type: text/html; charset=iso-8859-1\n\n")
  (slot-set! self 'page-type   'html)
  (slot-set! self 'toppage     "index")
  (slot-set! self 'params      '())           ;;
  (slot-set! self 'path-params '())
  (slot-set! self 'session-key #f)
  (slot-set! self 'pagedat     '())
  (slot-set! self 'alt-page-dat #f)
  (slot-set! self 'sroot       "./")
  (slot-set! self 'session-cookie #f)
  (slot-set! self 'curr-err #f)
  (slot-set! self 'log-port (current-error-port))
  (slot-set! self 'seen-pages '())
  (slot-set! self 'page-dir-style #t) ;; #t : pages/<pagename>_(view|cntl).scm
  (session:sdat-set-dbtype! self      'pg)
  (session:sdat-set-page! self        "home")        ;; these are defaults
  (session:sdat-set-curr-page! self   "home")
  (session:sdat-set-content-type! self "Content-type: text/html; charset=iso-8859-1\n\n")
  (session:sdat-set-page-type! self   'html)
  (session:sdat-set-toppage! self     "index")
  (session:sdat-set-params! self      '())           ;;
  (session:sdat-set-path-params! self '())
  (session:sdat-set-session-key! self #f)
  (session:sdat-set-pagedat! self     '())
  (session:sdat-set-alt-page-dat! self #f)
  (session:sdat-set-sroot! self       "./")
  (session:sdat-set-session-cookie! self #f)
  (session:sdat-set-curr-err! self #f)
  (session:sdat-set-log-port! self (current-error-port))
  (session:sdat-set-seen-pages! self '())
  (session:sdat-set-page-dir-style! self #t) ;; #t : pages/<pagename>_(view|cntl).scm
                                      ;; #f : pages/<pagename>/(view|control).scm 
  (slot-set! self 'debugmode #f)
  (session:sdat-set-debugmode! self #f)
  (for-each (lambda (slot-name)
              (slot-set! self slot-name (make-hash-table)))
              (session:sdat-set-lot-name! self (make-hash-table)))
            (list 'pagevars 'sessionvars 'globalvars 'pagevars-before 
		  'sessionvars-before 'globalvars-before))
  (slot-set! self 'domain "locahost")   ;; end of defaults
  (session:sdat-set-domain! self "locahost")   ;; end of defaults
  (initialize-slots self (session:read-config self))

  ;; FIXME - NOT AUTOMATICALLY TRANSLATED
  ;; some values read in from the config file need to be evaled
  (for-each (lambda (slot-name)
	      (slot-set! self slot-name (eval (slot-ref self slot-name))))
	    (list 'dbtype))
  (initialize-slots self initargs))
  (session:sdat-set-dbtype! self (eval (session:sdat-get-dbtype self))))


(define-method (session:setup (self <session>))
  (let ((dbtype (slot-ref self 'dbtype))
	(dbinit (eval (slot-ref self 'dbinit)))
(define (session:setup self)
  (let ((dbtype (session:sdat-get-dbtype self))
	(dbinit (eval (session:sdat-get-dbinit self)))
	(dbexists #f))
    (let ((dbfname (alist-ref 'dbname dbinit)))
      (if (eq? dbtype 'sqlite3)
	  (if (file-exists? dbfname)
	      (begin
		;; (session:log self "setting dbexists to #t")
		(set! dbexists #t))))
      ;; (session:log self "dbtype: " dbtype " dbfname: " dbfname " dbexists: " dbexists))
      )
    (slot-set! self 'conn (dbi:open dbtype dbinit))
    (session:sdat-set-conn! self (dbi:open dbtype dbinit))
    (if (and (not dbexists)(eq? dbtype 'sqlite3))
 	(begin
	  (print "WARNING: Setting up session db with sqlite3")
	  (session:setup-db self)))
    (session:process-url-path self)
    (session:setup-session-key self)
    ;; capture stdin if this is a POST
    (slot-set! self 'request-method (getenv "REQUEST_METHOD"))
    (slot-set! self 'formdat (formdat:load-all))))
    (session:sdat-set-request-method! self (getenv "REQUEST_METHOD"))
    (session:sdat-set-formdat! self (formdat:load-all))))

;; setup the db with session tables, works for sqlite only right now
(define-method (session:setup-db (self <session>))
  (let ((conn (slot-ref self 'conn)))
(define (session:setup-db self)
  (let ((conn (session:sdat-get-conn self)))
    (for-each 
     (lambda (stmt)
       (dbi:exec conn stmt))
     (list "CREATE TABLE session_vars (id INTEGER PRIMARY KEY,session_id INTEGER,page TEXT,key TEXT,value TEXT);"
	   "CREATE TABLE sessions (id INTEGER PRIMARY KEY,session_key TEXT,last_used TIMESTAMP);"
           "CREATE TABLE metadata (id INTEGER PRIMARY KEY,key TEXT,value TEXT);"))))
;;  ;; if we have a session_key look up the session-id and store it
;;  (slot-set! self 'session-id (session:get-id self)))
;;  (session:sdat-set-session-id! self (session:get-id self)))

;; only set session-cookie when a new session is created
(define-method (session:setup-session-key (self <session>))  
(define (session:setup-session-key self)  
  (let* ((sk  (session:extract-session-key self))
         (sid (if sk (session:get-id self sk) #f)))
    (if (not sid) ;; need a new key
        (let* ((new-key (session:get-new-key self))
               (new-sid (session:get-id self new-key)))
          (slot-set! self 'session-key new-key)
          (slot-set! self 'session-id new-sid)
          (slot-set! self 'session-cookie (session:make-cookie self)))
        (slot-set! self 'session-id sid))))
          (session:sdat-set-session-key! self new-key)
          (session:sdat-set-session-id! self new-sid)
          (session:sdat-set-session-cookie! self (session:make-cookie self)))
        (session:sdat-set-session-id! self sid))))

(define-method (session:make-cookie (self <session>))
  ;; (list (conc "session_key=" (slot-ref self 'session-key) "; Path=/; Domain=." (slot-ref self 'domain) "; Max-Age=" (* 86400 14) "; Version=1"))) 
(define (session:make-cookie self)
  ;; (list (conc "session_key=" (session:sdat-get-session-key self) "; Path=/; Domain=." (session:sdat-get-domain self) "; Max-Age=" (* 86400 14) "; Version=1"))) 
  (list (string-substitute 
	 ";" "; " 
	 (car (construct-cookie-string 
	       ;; warning! messing up this itty bitty bit of code will cost much time!
	       `(("session_key" ,(slot-ref self 'session-key)
	       `(("session_key" ,(session:sdat-get-session-key self)
		  expires: ,(+ (current-seconds) (* 14 86400)) 
		  max-age: (* 14 86400)
		  path: "/" ;; 
		  domain: ,(string-append "." (slot-ref self 'domain))
		  domain: ,(string-append "." (session:sdat-get-domain self))
		  version: 1)) 0)))))

;; look up a given session key and return the id if found, #f if not found
(define-method (session:get-id (self <session>) session-key)
  ;; (let ((session-key (slot-ref self 'session-key)))
(define (session:get-id self session-key)
  ;; (let ((session-key (session:sdat-get-session-key self)))
  (if session-key
      (let ((query (string-append "SELECT id FROM sessions WHERE session_key='" session-key "'"))
            (conn (slot-ref self 'conn))
            (conn (session:sdat-get-conn self))
            (result #f))
	(dbi:for-each-row 
	 (lambda (tuple)
	   (set! result (vector-ref tuple 0)))
	 conn query)
	(if result (dbi:exec conn (conc "UPDATE sessions SET last_used=" (dbi:now conn) " WHERE session_key=?;") session-key))
        result)
      #f))

;; 
(define-method (session:process-url-path (self <session>))
(define (session:process-url-path self)
  (let ((path-info    (getenv "PATH_INFO"))
	(query-string (getenv "QUERY_STRING")))
    ;; (session:log self "path-info=" path-info " query-string=" query-string)
    (if path-info
	(let* ((parts    (string-split path-info "/"))
	       (numparts (length parts)))
	  (if (> numparts 0)
	      (slot-set! self 'page (car parts)))
	      (session:sdat-set-page! self (car parts)))
	  ;; (session:log self "url-path=" url-path " parts=" parts)
	  (if (> numparts 1)
	      (slot-set! self 'path-params (cdr parts)))
	      (session:sdat-set-path-params! self (cdr parts)))
          (if query-string
              (slot-set! self 'params (string-split query-string "&")))))))
              (session:sdat-set-params! self (string-split query-string "&")))))))

;; BUGGY!
(define-method (session:get-new-key (self <session>))
  (let ((conn   (slot-ref self 'conn))
(define (session:get-new-key self)
  (let ((conn   (session:sdat-get-conn self))
        (tmpkey (session:make-rand-string 20))
        (status #f))
    (dbi:for-each-row (lambda (tuple)
			(set! status #t))
		      conn (string-append "INSERT INTO sessions (session_key) VALUES ('" tmpkey "')"))
    tmpkey))

;; returns session key IFF it is in the HTTP_COOKIE 
(define-method (session:extract-session-key (self <session>))
(define (session:extract-session-key self)
  (let ((http-session (getenv "HTTP_COOKIE")))
    (if http-session 
        (session:extract-key-from-param self (list http-session) "session_key")
        #f)))

(define-method (session:get-session-id (self <session>) session-key)
(define (session:get-session-id self session-key)
  (let ((query "SELECT id FROM sessions WHERE session_key=?;")
        (result #f))
    ;;     (pg:query-for-each (lambda (tuple)
    ;;                          (set! result (vector-ref tuple 0))) ;; (vector-ref tuple 0)))
    ;;                        (s:sqlparam query session-key)
    ;;                        (slot-ref self 'conn))
    ;;                        (session:sdat-get-conn self))
    ;;                        conn)
    (dbi:for-each-row (lambda (tuple)
			(set! result (vector-ref tuple 0))) ;; (vector-ref tuple 0)))
		      (slot-ref self 'conn)
		      (session:sdat-get-conn self)
		      (s:sqlparam query session-key))
    result))

;; delete all records for a session
;;
(define-method (session:delete-session (self <session>) session-key)
(define (session:delete-session self session-key)
  (let ((session-id (session:get-session-id self session-key))
        (qry        (conc "BEGIN;"
			  "DELETE FROM session_vars WHERE session_id=?;"
                          "DELETE FROM sessions WHERE id=?;"
			  "COMMIT;"))
        (conn              (slot-ref self 'conn)))
        (conn              (session:sdat-get-conn self)))
    (if session-id
        (begin
          (dbi:exec conn qry session-id session-id)
	  (initialize self '())
	  (session:setup self)))
    (not (session:get-session-id self session-key))))

;; (define-method (session:delete-session (self <session>) session-key)
;; (define (session:delete-session self session-key)
;;   (let ((session-id (session:get-session-id self session-key))
;;         (queries    (list "BEGIN;"
;; 			  "DELETE FROM session_vars WHERE session_id=?;"
;;                           "DELETE FROM sessions WHERE id=?;"
;; 			  "COMMIT;"))
;;         (conn              (slot-ref self 'conn)))
;;         (conn              (session:sdat-get-conn self)))
;;     (if session-id
;;         (begin
;;           (for-each
;;            (lambda (query)
;;              (dbi:exec conn query session-id))
;; 	   queries)
;; 	  (initialize self '())
;; 	  (session:setup self)))
;;     (not (session:get-session-id self session-key))))

(define-method (session:extract-key (self <session>) key)
  (let ((params (slot-ref self 'params)))
(define (session:extract-key self key)
  (let ((params (session:sdat-get-params self)))
    (session:extract-key-from-param self params key)))

(define-method (session:extract-key-from-param (self <session>) params key)
(define (session:extract-key-from-param self params key)
  (let ((r1     (regexp (string-append "^" key "=([^=]+)$"))))
    (if (< (length params) 1) #f
	(let loop ((head   (car params))
		   (tail   (cdr params)))
	  (let ((match (string-match r1 head)))
	    (cond
	     (match
	      (let ((session-key (list-ref match 1)))
		(slot-set! self 'session-key (list-ref match 1))
		(session:sdat-set-session-key! self (list-ref match 1))
		session-key))
	     ((null? tail)
	      #f)
	     (else
	      (loop (car tail)
		    (cdr tail)))))))))

(define-method (session:set-page! (self <session>) page_name)
  (slot-set! self 'page page_name))
(define (session:set-page! self page_name)
  (session:sdat-set-page! self page_name))

(define-method (session:close (self <session>))
  (dbi:close (slot-ref self 'conn)))
;; (close-output-port (slot-ref self 'logpt))
(define (session:close self)
  (dbi:close (session:sdat-get-conn self)))
;; (close-output-port (session:sdat-get-logpt self))

(define-method (session:err-msg (self <session>) msg)
  (hash-table-set! (slot-ref self 'sessionvars) "ERROR_MSG"
(define (session:err-msg self msg)
  (hash-table-set! (session:sdat-get-sessionvars self) "ERROR_MSG"
		   (string-intersperse (map s:any->string msg) " ")))

(define-method (session:prev-err (self <session>))
  (let ((prev-err (hash-table-ref/default (slot-ref self 'sessionvars-before) "ERROR_MSG" #f))
	(curr-err (hash-table-ref/default (slot-ref self 'sessionvars) "ERROR_MSG" #f)))
(define (session:prev-err self)
  (let ((prev-err (hash-table-ref/default (session:sdat-get-sessionvars-before self) "ERROR_MSG" #f))
	(curr-err (hash-table-ref/default (session:sdat-get-sessionvars self) "ERROR_MSG" #f)))
    (if prev-err prev-err
	(if curr-err curr-err #f))))

;; session vars
;; 1. keys are always a string NOT a symbol
;; 2. values are always a string conversion is the responsibility of the 
;;    consuming function (at least for now, I'd like to change this)

;; set a session var for the current page
;;
(define-method (session:set! (self <session>) key value)
  (hash-table-set! (slot-ref self 'pagevars) (s:any->string key) (s:any->string value)))
(define (session:set! self key value)
  (hash-table-set! (session:sdat-get-pagevars self) (s:any->string key) (s:any->string value)))

;; del a var for the current page
;;
(define-method (session:del! (self <session>) key)
  (hash-table-delete! (slot-ref self 'pagevars) (s:any->string key)))
(define (session:del! self key)
  (hash-table-delete! (session:sdat-get-pagevars self) (s:any->string key)))

;; get the appropriate hash given a page "*sessionvars*, *globalvars* or page
;;
(define-method (session:get-page-hash (self <session>) page)
(define (session:get-page-hash self page)
  (if (string=? page "*sessionvars*")
      (slot-ref self 'sessionvars)
      (session:sdat-get-sessionvars self)
      (if (string=? page "*globalvars*")
	  (slot-ref self 'globalvars)
	  (slot-ref self 'pagevars))))
	  (session:sdat-get-globalvars self)
	  (session:sdat-get-pagevars self))))

;; set a session var for a given page
;;
(define-method (session:set! (self <session>) page key value)
(define (session:set! self page key value)
  (let ((ht (session:get-page-hash self page)))
    (hash-table-set! ht (s:any->string key) (s:any->string value))))

;; get session vars for the current page
;;
(define-method (session:get (self <session>) key)
  (hash-table-ref/default (slot-ref self 'pagevars) key #f))
(define (session:get self key)
  (hash-table-ref/default (session:sdat-get-pagevars self) key #f))

;; get session vars for a specified page
;;
(define-method (session:get (self <session>) page key)
(define (session:get self page key)
  (let ((ht (session:get-page-hash self page)))
    (hash-table-ref/default ht key #f)))

;; delete a session var for a specified page
;;
(define-method (session:del! (self <session>) page key)
(define (session:del! self page key)
  (let ((ht (session:get-page-hash self page)))
    (hash-table-delete! ht key)))

;; get ALL keys for this page and store in the session pagevars hash
;;
(define-method (session:get-vars (self <session>))
  (let ((session-id  (slot-ref self 'session-id)))
(define (session:get-vars self)
  (let ((session-id  (session:sdat-get-session-id self)))
    (if (not session-id)
	(err:log "ERROR: No session id in session object! session:get-vars")
	(let* ((result             #f)
	       (conn               (slot-ref self 'conn))
	       (pagevars-before    (slot-ref self 'pagevars-before))
	       (sessionvars-before (slot-ref self 'sessionvars-before))
	       (globalvars-before  (slot-ref self 'globalvars-before))
	       (pagevars           (slot-ref self 'pagevars))
	       (sessionvars        (slot-ref self 'sessionvars))
	       (globalvars         (slot-ref self 'globalvars))
	       (page-name          (slot-ref self 'page))
	       (session-key        (slot-ref self 'session-key))
	       (conn               (session:sdat-get-conn self))
	       (pagevars-before    (session:sdat-get-pagevars-before self))
	       (sessionvars-before (session:sdat-get-sessionvars-before self))
	       (globalvars-before  (session:sdat-get-globalvars-before self))
	       (pagevars           (session:sdat-get-pagevars self))
	       (sessionvars        (session:sdat-get-sessionvars self))
	       (globalvars         (session:sdat-get-globalvars self))
	       (page-name          (session:sdat-get-page self))
	       (session-key        (session:sdat-get-session-key self))
	       (query              (string-append
				    "SELECT key,value FROM session_vars INNER JOIN sessions ON session_vars.session_id=sessions.id "
				    "WHERE session_key=? AND page=?;")))
	  ;; first the page specific vars
	  (dbi:for-each-row (lambda (tuple)
			      (let ((k (vector-ref tuple 0))
				    (v (vector-ref tuple 1)))

				    (v (vector-ref tuple 1)))
				(hash-table-set! globalvars-before k v)
				(hash-table-set! globalvars        k v)))
			    conn
			    (s:sqlparam query session-key "*globalvars"))
	  ))))

(define-method (session:save-vars (self <session>))
  (let ((session-id  (slot-ref self 'session-id)))
(define (session:save-vars self)
  (let ((session-id  (session:sdat-get-session-id self)))
    (if (not session-id)
	(err:log "ERROR: No session id in session object! session:get-vars")
	(let* ((status      #f)
	       (conn        (slot-ref self 'conn))
	       (page-name   (slot-ref self 'page))
	       (conn        (session:sdat-get-conn self))
	       (page-name   (session:sdat-get-page self))
	       (del-query   "DELETE FROM session_vars WHERE session_id=? AND page=? AND key=?;")
	       (ins-query   "INSERT INTO session_vars (session_id,page,key,value) VALUES(?,?,?,?);")
	       (upd-query   "UPDATE session_vars set value=? WHERE key=? AND session_id=? AND page=?;")
	       (changed-count 0))
	  ;; save the delta only
	  (for-each
	   (lambda (page) ;; page is: "*globalvars*" "*sessionvars*" or otherstring
	     (let* ((master-slot-name (cond
				       ((string=? page "*sessionvars*") 'sessionvars)
				       ((string=? page "*globalvars*")  'globalvars)
				       (else 'pagevars)))
		    (before-slot-name (string->symbol (string-append (symbol->string master-slot-name)
								     "-before")))
		    (master-ht   (slot-ref self master-slot-name))
		    (before-ht   (slot-ref self before-slot-name))
		    (master-ht   (session:sdat-get-aster-slot-name self))
		    (before-ht   (session:sdat-get-efore-slot-name self))
		    (master-keys (hash-table-keys master-ht))
		    (before-keys (hash-table-keys before-ht))
		    (all-keys (delete-duplicates (append master-keys before-keys))))
	       (for-each 
		(lambda (key)
		  (let ((master-value (hash-table-ref/default master-ht key #f))
			(before-value (hash-table-ref/default before-ht key #f)))

;;                                                      (hash-table-ref sessionvars key))
;; 					 conn))
;; 		    (hash-table-keys sessionvars))
;;           ;; global vars will require a little more care - delaying for now.
;;           ))))

;; (pg:sql-null-object? element)
(define-method (session:read-config (self <session>))
(define (session:read-config self)
  (let ((name (string-append "." (pathname-file (car (argv))) ".config")))
    (if (not (file-exists? name))
	(print name " not found at " (current-directory))
	(let* ((fp (open-input-file name))
	       (initargs (read fp)))
	  (close-input-port fp)
	  initargs))))

      (if (eof-object? hed)
	  res
	  (loop (read-line p)(append res (list hed)))))))

;; May 2011, putting all pages into one directory for the following reasons:
;;   1. want filename to reflect page name (emacs limitation)
;;   2. that's it! no other reason. could make it configurable ...
(define-method (session:call-parts (self <session>) page parts)
  (slot-set! self 'curr-page page)
  ;; (session:log self "page-dir-style: " (slot-ref self 'page-dir-style))
  (let* ((dir-style ;; (equal? (slot-ref self 'page-dir-style) "onedir")) ;; flag #t for onedir, #f for old style
	  (slot-ref self 'page-dir-style))
	 (dir     (string-append (slot-ref self 'sroot) 
(define (session:call-parts self page parts)
  (session:sdat-set-curr-page! self page)
  ;; (session:log self "page-dir-style: " (session:sdat-get-page-dir-style self))
  (let* ((dir-style ;; (equal? (session:sdat-get-page-dir-style self) "onedir")) ;; flag #t for onedir, #f for old style
	  (session:sdat-get-page-dir-style self))
	 (dir     (string-append (session:sdat-get-sroot self) 
				 (if dir-style 
				     (conc "/pages/")
				     (conc "/pages/" page))))
	 (control (string-append dir (if dir-style 
					 (conc page "_ctrl.scm")
					 "/control.scm")))
	 (view    (string-append dir (if dir-style 

			 (else '())))
		      (port-map eval (lambda ()(read p))))))
	  ;; (map close-input-port inps)
	  (close-input-port p)
	  dat)
	(list "<p>Page not found " page " </p>"))))

(define-method (session:call (self <session>) page)
(define (session:call self page)
  (session:call-parts self page 'both))

(define-method (session:call (self <session>) page parts)
(define (session:call self page parts)
  (session:call-parts self page 'both))

(define-method (session:load-model (self <session>) model)
  (let ((model.scm (string-append (slot-ref self 'sroot) "/models/" model ".scm"))
	(model.so  (string-append (slot-ref self 'sroot) "/models/" model ".so")))
(define (session:load-model self model)
  (let ((model.scm (string-append (session:sdat-get-sroot self) "/models/" model ".scm"))
	(model.so  (string-append (session:sdat-get-sroot self) "/models/" model ".so")))
    (if (file-exists? model.so)
	(load model.so)
	(if (file-exists? model.scm)
	    (load model.scm)
	    (s:log "ERROR: model " model.scm " not found")))))

(define-method (session:model-path (self <session>) model)
  (string-append (slot-ref self 'sroot) "/models/" model ".scm"))
(define (session:model-path self model)
  (string-append (session:sdat-get-sroot self) "/models/" model ".scm"))

(define-method (session:pp-formdat (self <session>))
  (let ((dat (formdat:all->strings (slot-ref self 'formdat))))
(define (session:pp-formdat self)
  (let ((dat (formdat:all->strings (session:sdat-get-formdat self))))
    (string-intersperse dat "<br> ")))

(define (session:param->string params)
  ;; (err:log "params=" params)
  (if (< (length params) 1)
      ""
      (let loop ((key (car params))
		 (val (cadr params))
		 (tail (cddr params))
		 (result '()))
	(let ((newresult (cons (string-append (s:any->string key) "=" (s:any->string val))
			       result)))
	  (if (< (length tail) 1) ;; true if done
	      (string-intersperse newresult "&")
	      (loop (car tail)(cadr tail)(cddr tail) newresult))))))

(define-method (session:link-to (self <session>) page params)
(define (session:link-to self page params)
  (let* ((server    (if (getenv "HTTP_HOST")
			(getenv "HTTP_HOST")
			(getenv "SERVER_NAME")))
	 (script (let ((script-name (string-split (getenv "SCRIPT_NAME") "/")))
		   (if (> (length script-name) 1)
		       (string-append (car script-name) "/" (cadr script-name))
		       (getenv "SCRIPT_NAME")))) ;; build script name from first two elements. This is a hangover from before I used ? in the URL.
	 (session-key (slot-ref self 'session-key))
	 (session-key (session:sdat-get-session-key self))
	 (paramstr (session:param->string params)))
    ;; (session:log self "server=" server " script=" script " page=" page)
    (string-append "http://" server "/" script "/" page "?" paramstr))) ;; "/sn=" session-key)))

(define-method (session:cgi-out (self <session>))
  (let* ((content  (list (slot-ref self 'content-type))) ;; '("Content-type: text/html; charset=iso-8859-1\n\n"))
	 (header   (let ((cookie (slot-ref self 'session-cookie)))
(define (session:cgi-out self)
  (let* ((content  (list (session:sdat-get-content-type self))) ;; '("Content-type: text/html; charset=iso-8859-1\n\n"))
	 (header   (let ((cookie (session:sdat-get-session-cookie self)))
		     (if cookie
			 (cons (string-append "Set-Cookie: " (car cookie))
			       content)
			 content)))
	 (pagedat  (slot-ref self 'pagedat)))
	 (pagedat  (session:sdat-get-pagedat self)))
    (s:cgi-out 
     (cons header pagedat))))

(define-method (session:log (self <session>) . msg)
  (with-output-to-port (slot-ref self 'log-port) ;; (slot-ref self 'logpt)
(define (session:log self . msg)
  (with-output-to-port (session:sdat-get-log-port self) ;; (session:sdat-get-logpt self)
    (lambda () 
      (apply print msg))))

(define-method (session:get-param (self <session>) key)
(define (session:get-param self key)
  ;; (session:log s:session "params=" (slot-ref s:session 'params))
  (let ((params (slot-ref self 'params)))
  (let ((params (session:sdat-get-params self)))
    (session:get-param-from params key)))

;; This one will get the first value found regardless of form
(define-method (session:get-input (self <session>) key)
  (let* ((formdat (slot-ref self 'formdat)))
(define (session:get-input self key)
  (let* ((formdat (session:sdat-get-formdat self)))
    (if (not formdat) #f
	(if (or (string? key)(number? key)(symbol? key))
	    (if (eq? (class-of formdat) <formdat>)
		(formdat:get formdat key)
		(begin
		  (session:log self "ERROR: formdat: " formdat " is not of class <formdat>")
		  #f))
	    (session:log self "ERROR: bad key " key)))))

(define-method (session:run-actions (self <session>))
(define (session:run-actions self)
  (let* ((action    (session:get-param self 'action))
	 (page      (slot-ref self 'page)))
	 (page      (session:sdat-get-page self)))
    ;; (print "action=" action " page=" page)
    (if action
	(let ((action-lst  (string-split action ".")))
	  ;; (print "action-lst=" action-lst)
	  (if (not (= (length action-lst) 2)) 
	      (err:log "Action should be of form: module.action")
	      (let* ((targ-page   (car action-lst))

		    ((eval (string->symbol proc-name)) targ-action) ;; unsafe execution
		    (condition-case ((eval (string->symbol proc-name)) targ-action)
				    ((exn file) (s:log "file error"))
				    ((exn i/o)  (s:log "i/o error"))
				    ((exn )     (s:log "Action not implemented: " proc-name " action: " targ-action))
				    (var ()     (s:log "Unknown Error"))))))))))

(define-method (session:never-called-page? (self <session>) page)
(define (session:never-called-page? self page)
  (session:log self "Checking for page: " page)
  (not (member page (slot-ref self 'seen-pages))))
  (not (member page (session:sdat-get-seen-pages self))))

(define-method (session:set-called! (self <session>) page)
  (slot-set! self 'seen-pages (cons page (slot-ref self 'seen-pages))))
(define (session:set-called! self page)
  (session:sdat-set-seen-pages! self (cons page (session:sdat-get-seen-pages self))))

;;======================================================================
;; Alternative data type delivery
;;======================================================================

(define-method (session:alt-out (self <session>))
  (let ((dat (slot-ref self 'alt-page-dat)))
(define (session:alt-out self)
  (let ((dat (session:sdat-get-alt-page-dat self)))
    ;; (s:log "dat is: " dat)
    ;; (print "HTTP/1.1 200 OK")
    (print "Date: " (time->string (seconds->utc-time (current-seconds))))
    (print "Content-Type: " (slot-ref self 'content-type))
    (print "Content-Type: " (session:sdat-get-content-type self))
    (print "Accept-Ranges: bytes")
    (print "Content-Length: " (if (blob? dat)
				  (blob-size dat)
				  0))
    (print "Keep-Alive: timeout=15, max=100")
    (print "Connection: Keep-Alive")
    (print "")
    (write-string (blob->string dat) #f (current-output-port))))

#!/usr/local/bin/csi -q

;; Copyright 2007-2008, Matthew Welland.
;; 
;;  This program is made available under the GNU GPL version 2.0 or
;;  greater. See the accompanying file COPYING for details.
;; 
;;  This program is distributed WITHOUT ANY WARRANTY; without even the
;;  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;;  PURPOSE.

;; (require-extension syntax-case)
(declare (run-time-macros))
;; (declare (run-time-macros))

(use dbi)
(require-library dbi)

(define getenv get-environment-variable)
(include "requirements.scm")
(include "cookie.scm")
(include "html-filter.scm")
(include "misc-stml.scm")
(include "formdat.scm")
(include "stml.scm")
;; (include "dbi.scm")
(include "session.scm")
(include "setup.scm") ;; s:session gets created here
(include "sqltbl.scm")
(include "keystore.scm")
(include "sugar.scm")
;; (include "sugar.scm")

(slot-set! s:session 'log-port ;; (current-error-port))
	   (open-output-file (slot-ref s:session 'logfile) #:append))

;; (s:log "HTTP_COOKIE" (getenv "HTTP_COOKIE"))
;; (s:log "stdin-dat=" (slot-ref s:session 'stdin-dat))

#!/usr/local/bin/csi -q 

;; Copyright 2007-2008, Matthew Welland.
;; 
;;  This program is made available under the GNU GPL version 2.0 or
;;  greater. See the accompanying file COPYING for details.
;; 
;;  This program is distributed WITHOUT ANY WARRANTY; without even the
;;  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;;  PURPOSE.

(use test md5 dbi)
(use test md5)
(require-library dbi)

(load "./requirements.scm")
(load "./misc-stml.scm")
(load "./formdat.scm")
(load "./stml.scm")
(load "./session.scm")
(load "./sqltbl.scm")

(test "misc:non-zero-string \"\"" #f (misc:non-zero-string ""))
(test "misc:non-zero-string #f" #f (misc:non-zero-string #f))
(test "misc:non-zero-string 'blah" #f (misc:non-zero-string 'blah))

;; forms
(define form #f)
(test "make <formdat>" #t (let ((f (make <formdat>)))
(test "make <formdat>" #t (let ((f (make-formdat:formdat)))
			    (set! form f)
			    #t))
(test "formdat: set!/get" "Yep!" (begin
				   (formdat:set! form "blah" "Yep!")
				   (formdat:get  form "blah")))

(test "s:string->pgint"   123 (s:any->pgint "123"))