path: root/usr/src/lib/libshell/common/scripts/shnote.sh

#!/usr/bin/ksh93

#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#

#
# Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
#

# Solaris needs /usr/xpg6/bin:/usr/xpg4/bin because the tools in /usr/bin are not POSIX-conformant
export PATH=/usr/xpg6/bin:/usr/xpg4/bin:/bin:/usr/bin

# Make sure all math stuff runs in the "C" locale to avoid problems
# with alternative # radix point representations (e.g. ',' instead of
# '.' in de_DE.*-locales). This needs to be set _before_ any
# floating-point constants are defined in this script).
if [[ "${LC_ALL}" != "" ]] ; then
    export \
        LC_MONETARY="${LC_ALL}" \
        LC_MESSAGES="${LC_ALL}" \
        LC_COLLATE="${LC_ALL}" \
        LC_CTYPE="${LC_ALL}"
        unset LC_ALL
fi
export LC_NUMERIC=C

function fatal_error
{
	print -u2 "${progname}: $*"
	exit 1
}

function encode_multipart_form_data
{
	nameref formdata="$1"
	nameref content="formdata.content"
	integer numformelements=${#formdata.form[*]}
	integer i
	typeset tmp
    
	content=""
    
	# todo: add support to upload files
	for (( i=0 ; i < numformelements ; i++ )) ; do
		nameref element="formdata.form[${i}]"

		content+="--${formdata.boundary}\n"
		content+="Content-Disposition: form-data; name=\"${element.name}\"\n"
		content+="\n"
		# make sure we quote the '\' properly since we pass these data to one instance of
		# "print" when putting the content on the wire.
		content+="${element.data//\\/\\\\}\n" # fixme: may need encoding for non-ASCII data
	done
    
	# we have to de-quote the content before we can count the real numer of bytes in the payload
	tmp="$(print -- "${content}")"
	formdata.content_length=${#tmp}

	# add content tail (which MUST not be added to the content length)
	content+="--${formdata.boundary}--\n"

	return 0
}

# parse HTTP return code, cookies etc.
function parse_http_response
{
	nameref response="$1"
	typeset h statuscode statusmsg i
    
	# we use '\r' as additional IFS to filter the final '\r'
	IFS=$' \t\r' read -r h statuscode statusmsg  # read HTTP/1.[01] <code>
	[[ "$h" != ~(Eil)HTTP/.* ]]         && { print -u2 -f $"%s: HTTP/ header missing\n" "$0" ; return 1 ; }
	[[ "$statuscode" != ~(Elr)[0-9]* ]] && { print -u2 -f $"%s: invalid status code\n"  "$0" ; return 1 ; }
	response.statuscode="$statuscode"
	response.statusmsg="$statusmsg"
    
	# skip remaining headers
	while IFS='' read -r i ; do
		[[ "$i" == $'\r' ]] && break

		# strip '\r' at the end
		i="${i/~(Er)$'\r'/}"

		case "$i" in
			~(Eli)Content-Type:.*)
				response.content_type="${i/~(El).*:[[:blank:]]*/}"
				;;
			~(Eli)Content-Length:[[:blank:]]*[0-9]*)
				integer response.content_length="${i/~(El).*:[[:blank:]]*/}"
				;;
			~(Eli)Transfer-Encoding:.*)
				response.transfer_encoding="${i/~(El).*:[[:blank:]]*/}"
				;;
		esac
	done

	return 0
}

function cat_http_body
{
	typeset emode="$1"
	typeset hexchunksize="0"
	integer chunksize=0 
    
	if [[ "${emode}" == "chunked" ]] ; then
		while IFS=$'\r' read hexchunksize &&
			[[ "${hexchunksize}" == ~(Elri)[0-9abcdef]+ ]] &&
			(( chunksize=$( printf "16#%s\n" "${hexchunksize}" ) )) && (( chunksize > 0 )) ; do
			dd bs=1 count="${chunksize}" 2>/dev/null
		done
	else
		cat
	fi

	return 0
}

function history_write_record
{
	# rec: history record:
	#     rec.title
	#     rec.description
	#     rec.provider
	#     rec.providertoken
	#     rec.url
	nameref rec="$1"
	integer histfd

	mkdir -p "${HOME}/.shnote"
    
	{
		# write a single-line record which can be read
		# as a compound variable back into the shell
		printf "title=%q description=%q date=%q provider=%q providertoken=%q url=%q\n" \
			"${rec.title}" \
			"${rec.description}" \
			"$(date)" \
			"${rec.provider}" \
			"${rec.providertoken}" \
			"${rec.url}"	    
	} >>"${history_file}"

	return $?
}

function print_history
{
	integer histfd # http stream number
	typeset line

	(( $# != 0 && $# != 1 )) && { print -u2 -f $"%s: Wrong number of arguments.\n" "$0" ; return 1 ; }

	# default output format is:
	# <access url>/<title> <date> <access url>
	[[ "$1" == "-l" ]] || printf "# %s\t\t\t\t\t%s\t%s\n" "<url>" "<title>" "<date>"

	# no history file ?     
	if [[ ! -f "${history_file}" ]] ; then
		return 0
	fi

	# open history file
	redirect {histfd}<> "${history_file}"
	(( $? != 0 )) && { print -u2 "Could not open history file." ;  return 1 ; }
    
	while read -u${histfd} line ; do
		compound rec
	
		printf "( %s )\n" "${line}"  | read -C rec
	
		if [[ "$1" == "-l" ]] ; then 
			print -- "${rec}"
		else
			printf "%q\t%q\t%q\n" "${rec.url}" "${rec.title}" "${rec.date}"
		fi
	
		unset rec
	done
    
	# close history file
	redirect {histfd}<&-
	
	return 0
}

function put_note_pastebin_ca
{
	# key to autheticate this script against pastebin.ca
	typeset -r pastebin_ca_key="9CFXFyeNC3iga/vthok75kTBu5kSSLPD"
	# site setup
	typeset url_host="opensolaris.pastebin.ca"
	typeset url_path="/quiet-paste.php?api=${pastebin_ca_key}"
	typeset url="http://${url_host}${url_path}"
	integer netfd # http stream number
	compound httpresponse
	
	(( $# != 1 )) && { print -u2 -f $"%s: Wrong number of arguments.\n" "$0" ; return 1 ; }
	(( ${#1} == 0 )) && { print -u2 -f $"%s: No data.\n" "$0" ; return 1 ; }

	# argument for "encode_multipart_form_data"
	compound mimeform=(
		# input
		typeset boundary
		typeset -a form
		# output
		typeset content
		integer content_length
	)
     
	typeset request=""
	typeset content=""

	typeset -r boundary="--------shnote_${RANDOM}_Xfish_${RANDOM}_Yeats_${RANDOM}_Zchicken_${RANDOM}monster_--------"

	mimeform.boundary="${boundary}"
	mimeform.form=( # we use explicit index numbers since we rely on them below when filling the history
		[0]=( name="name"		data="${LOGNAME}" )
		[1]=( name="expiry"		data="Never" )
		[2]=( name="type"		data="1" )
		[3]=( name="description"	data="logname=${LOGNAME};hostname=$(hostname);date=$(date)" )
		[4]=( name="content"		data="$1" )
	)
	encode_multipart_form_data mimeform
          
	content="${mimeform.content}"

	request="POST ${url_path} HTTP/1.1\r\n"
	request+="Host: ${url_host}\r\n"
	request+="User-Agent: ${http_user_agent}\r\n"
	request+="Connection: close\r\n"
	request+="Content-Type: multipart/form-data; boundary=${boundary}\r\n"
	request+="Content-Length: $(( mimeform.content_length ))\r\n"

	redirect {netfd}<> "/dev/tcp/${url_host}/80" 
	(( $? != 0 )) && { print -u2 -f $"%s: Could not open connection to %s.\n" "$0" "${url_host}" ;  return 1 ; }

	# send http post
	{
		print -n -- "${request}\r\n"
		print -n -- "${content}\r\n"
	}  >&${netfd}

	# process reply
	parse_http_response httpresponse <&${netfd}
	response="$(cat_http_body "${httpresponse.transfer_encoding}" <&${netfd})"

	# close connection
	redirect {netfd}<&-
    
	if [[ "${response}" == ~(E).*SUCCESS.* ]] ; then
		typeset response_token="${response/~(E).*SUCCESS:/}"

		printf "SUCCESS: http://opensolaris.pastebin.ca/%s\n" "${response_token}"
	
		# write history entry
		compound histrec=(
			title="${mimeform.form[0].data}"
			description="${mimeform.form[3].data}"
			providertoken="${response_token}"
			provider="opensolaris.pastebin.ca"
			url="http://opensolaris.pastebin.ca/${response_token}"
		)	

		history_write_record histrec
		return 0
	else
		printf "ERROR: %s\n" "${response}"
		return 1
	fi
	
	# not reached
}

function get_note_pastebin_ca
{
	typeset recordname="$1"
	integer netfd # http stream number

	(( $# != 1 )) && { print -u2 -f $"%s: No key or key URL.\n" "$0" ; return 1 ; }
    
	case "${recordname}" in
		~(Elr)[0-9][0-9]*)
			# pass-through
			;;
		~(Elr)http://opensolaris.pastebin.ca/raw/[0-9]*)
			recordname="${recordname/~(El)http:\/\/opensolaris.pastebin.ca\/raw\//}"
			;;
		~(Elr)http://opensolaris.pastebin.ca/[0-9]*)
			recordname="${recordname/~(El)http:\/\/opensolaris.pastebin.ca\//}"
			;;
		*)
			fatal_error $"Unsupported record name ${recordname}."
	esac
    
	print -u2 -f "# Record name is '%s'\n" "${recordname}"

	typeset url_host="opensolaris.pastebin.ca"
	typeset url_path="/raw/${recordname}"
	typeset url="http://${url_host}${url_path}"
	# I hereby curse Solaris for not having an entry for "http" in /etc/services

	# open TCP channel
	redirect {netfd}<> "/dev/tcp/${url_host}/80"
	(( $? != 0 )) && { print -u2 -f $"%s: Could not open connection to %s.\n" "$0" "${url_host}" ; return 1 ; }

	# send HTTP request    
	request="GET ${url_path} HTTP/1.1\r\n"
	request+="Host: ${url_host}\r\n"
	request+="User-Agent: ${http_user_agent}\r\n"
	request+="Connection: close\r\n"
	print -u${netfd} -- "${request}\r\n"
    
	# collect response and send it to stdout
	parse_http_response httpresponse <&${netfd}
	cat_http_body "${httpresponse.transfer_encoding}" <&${netfd}
    
	# close connection
	redirect {netfd}<&-
    
	print # add newline
    
	return 0
}

function usage
{
	OPTIND=0
	getopts -a "${progname}" "${USAGE}" OPT '-?'
	exit 2
}

# program start
builtin basename
builtin cat
builtin date
builtin uname

typeset progname="${ basename "${0}" ; }"

# HTTP protocol client identifer
typeset -r http_user_agent="shnote/ksh93 (2010-03-27; $(uname -s -r -p))"

# name of history log (the number after "history" is some kind of version
# counter to handle incompatible changes to the history file format)
typeset -r history_file="${HOME}/.shnote/history0.txt"

typeset -r shnote_usage=$'+
[-?\n@(#)\$Id: shnote (Roland Mainz) 2010-03-27 \$\n]
[-author?Roland Mainz <roland.mainz@nrubsig.org>]
[+NAME?shnote - read/write text data to internet clipboards]
[+DESCRIPTION?\bshnote\b is a small utilty which can read and write text
	data to internet "clipboards" such as opensolaris.pastebin.ca.]
[+?The first arg \bmethod\b describes one of the methods, "put" saves a string
	to the internet clipboard, returning an identifer and the full URL
	where the data are stored. The method "get" retrives the raw
	information using the identifer from the previous "put" action.
	The method "hist" prints a history of transactions created with the
	"put" method and the keys to retrive them again using the "get" method.]
[+?The second arg \bstring\b contains either the string data which should be
	stored on the clipboard using the "put" method, the "get" method uses
	this information as identifer to retrive the raw data from the
	clipboard.]

method [ string ]

[+SEE ALSO?\bksh93\b(1), \brssread\b(1), \bshtwitter\b(1), \bshtinyurl\b(1), http://opensolaris.pastebin.ca]
'

while getopts -a "${progname}" "${shnote_usage}" OPT ; do 
#	printmsg "## OPT=|${OPT}|, OPTARG=|${OPTARG}|"
	case ${OPT} in
		*)	usage ;;
	esac
done
shift $((OPTIND-1))

# expecting at least one more argument, the single method below will do
# the checks for more arguments if needed ("put" and "get" methods need
# at least one extra argument, "hist" none).
(($# >= 1)) || usage

typeset method="$1"
shift

case "${method}" in
	put)	put_note_pastebin_ca "$@" ; exit $? ;;
	get)	get_note_pastebin_ca "$@" ; exit $? ;;
	hist)	print_history "$@"        ; exit $? ;;
	*)	usage ;;
esac

fatal_error $"not reached."
# EOF.