httpclient

#!/usr/bin/env guile
!#

;; A command line http client written in guile scheme.
(use-modules (ice-9 format)
             (ice-9 rdelim)
             (ice-9 getopt-long)
             (web uri)
             (web request)
             (web response)
             (web client)
             (rnrs bytevectors))

;; command line options' specification
(define option-spec
    '( (version (single-char #\v))
       (help    (single-char #\h))
       (method  (single-char #\m) (value #t))
       (body    (single-char #\b) (value #t))))

(define options (getopt-long (command-line) option-spec))
(define args (option-ref options '() '()))
(define program (car (command-line)))
(define version "1.0")

;; print usage and exit with errno
(define (usage errno)
    (let ((errport (current-error-port)))
          (format errport "Usage: ~a [options] request-url~%" program)
          (for-each (lambda (opt desc) (format errport "\t~a: ~a~%" opt desc))
                '("--version,-v"
                  "--help,-h"
                  "--method,-m"
                  "--body,-b")
                '("print version information"
                  "print this help message"
                  "specify http request method, eg: GET POST"
                  "specify http request body")))
          (exit errno))

;; print version and exit normaly
(define (print-version)
    (format #t "Version: ~a\n" version)
    (exit 0))

;; perform a http request
(define (http-request req-uri)
    (define req (build-request req-uri
                     #:method (string->symbol
                                  (option-ref options 'method "GET"))))
    (define req-body (option-ref options 'body #f))
    (define sport (open-socket-for-uri req-uri))
    (let ((opened-request (write-request req sport)))
         (if req-body
             (write-request-body opened-request (string->utf8 req-body))))
    (force-output sport)
    (shutdown sport 1)

    ;; get result and print out
    (let loop ((line (read-line sport)))
         (if (eof-object? line)
             (write-line "")
             (begin
                 (write-line line)
                 (loop (read-line sport))))))

;; main entry point
(define (main)
    (if (option-ref options 'help #f)
         (usage 0))
    (if (option-ref options 'version #f)
         (print-version))
    (if (= (length args) 1)
         (let ((request-uri (string->uri (car args))))
             (if request-uri
                 (http-request request-uri)
                 (format (current-error-port) "Illegal url: ~a~%" (car args))))
         (begin
             (format (current-error-port) "Wrong number of arguments~%")
             (usage 1))))

(main)