ruby-msg 1.2.17

data/lib/msg.rb

@@ -0,0 +1,505 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__)
+
+require 'yaml'
+require 'base64'
+
+require 'support'
+require 'ole/storage'
+require 'msg/properties'
+require 'msg/rtf'
+require 'mime'
+
+#
+# = Introduction
+#
+# Primary class interface to the vagaries of .msg files.
+#
+# The core of the work is done by the <tt>Msg::Properties</tt> class.
+#
+
+class Msg
+	VERSION = '1.2.17'
+	# we look here for the yaml files in data/, and the exe files for support
+	# decoding at the moment.
+	SUPPORT_DIR = File.dirname(__FILE__) + '/..'
+
+	Log = Logger.new_with_callstack
+
+	attr_reader :root, :attachments, :recipients, :headers, :properties
+	attr_accessor :close_parent
+	alias props :properties
+
+	# Alternate constructor, to create an +Msg+ directly from +arg+ and +mode+, passed
+	# directly to Ole::Storage (ie either filename or seekable IO object).
+	def self.open arg, mode=nil
+		msg = Msg.new Ole::Storage.open(arg, mode).root
+		# we will close the ole when we are #closed
+		msg.close_parent = true
+		msg
+	end
+
+	# Create an Msg from +root+, an <tt>Ole::Storage::Dirent</tt> object
+	def initialize root
+		@root = root
+		@close_parent = false
+		@attachments = []
+		@recipients = []
+		@properties = Properties.load @root
+
+		# process the children which aren't properties
+		@properties.unused.each do |child|
+			if child.dir?
+				case child.name
+				# these first 2 will actually be of the form
+				# 1\.0_#([0-9A-Z]{8}), where $1 is the 0 based index number in hex
+				# should i parse that and use it as an index?
+				when /__attach_version1\.0_/
+					attach = Attachment.new(child)
+					@attachments << attach if attach.valid?
+				when /__recip_version1\.0_/
+					@recipients << Recipient.new(child)
+				when /__nameid_version1\.0/
+					# FIXME: ignore nameid quietly at the moment
+				else ignore child
+				end
+			end
+		end
+
+		# if these headers exist at all, they can be helpful. we may however get a
+		# application/ms-tnef mime root, which means there will be little other than
+		# headers. we may get nothing.
+		# and other times, when received from external, we get the full cigar, boundaries
+		# etc and all.
+		# sometimes its multipart, with no boundaries. that throws an error. so we'll be more
+		# forgiving here
+		@mime = Mime.new props.transport_message_headers.to_s, true
+		populate_headers
+	end
+
+	def close
+		@root.ole.close if @close_parent
+	end
+
+	def headers
+		@mime.headers
+	end
+
+	# copy data from msg properties storage to standard mime. headers
+	# i've now seen it where the existing headers had heaps on stuff, and the msg#props had
+	# practically nothing. think it was because it was a tnef - msg conversion done by exchange.
+	def populate_headers
+		# construct a From value
+		# should this kind of thing only be done when headers don't exist already? maybe not. if its
+		# sent, then modified and saved, the headers could be wrong?
+		# hmmm. i just had an example where a mail is sent, from an internal user, but it has transport
+		# headers, i think because one recipient was external. the only place the senders email address
+		# exists is in the transport headers. so its maybe not good to overwrite from.
+		# recipients however usually have smtp address available.
+		# maybe we'll do it for all addresses that are smtp? (is that equivalent to 
+		# sender_email_address !~ /^\//
+		name, email = props.sender_name, props.sender_email_address
+		if props.sender_addrtype == 'SMTP'
+			headers['From'] = if name and email and name != email
+				[%{"#{name}" <#{email}>}]
+			else
+				[email || name]
+			end
+		elsif !headers.has_key?('From')
+			# some messages were never sent, so that sender stuff isn't filled out. need to find another
+			# way to get something
+			# what about marking whether we thing the email was sent or not? or draft?
+			# for partition into an eventual Inbox, Sent, Draft mbox set?
+			# i've now seen cases where this stuff is missing, but exists in transport message headers,
+			# so maybe i should inhibit this in that case.
+			if email
+				Log.warn "* no smtp sender email address available (only X.400). creating fake one"
+				# this is crap. though i've specially picked the logic so that it generates the correct
+				# email addresses in my case (for my organisation).
+				# this user stuff will give valid email i think, based on alias.
+				user = name ? name.sub(/(.*), (.*)/, "\\2.\\1") : email[/\w+$/].downcase
+				domain = (email[%r{^/O=([^/]+)}i, 1].downcase + '.com' rescue email)
+				headers['From'] = [name ? %{"#{name}" <#{user}@#{domain}>} : "<#{user}@#{domain}>" ]
+			elsif name
+				# we only have a name? thats screwed up.
+				Log.warn "* no smtp sender email address available (only name). creating fake one"
+				headers['From'] = [%{"#{name}"}]
+			else
+				Log.warn "* no sender email address available at all. FIXME"
+			end
+		# else we leave the transport message header version
+		end
+
+		# for all of this stuff, i'm assigning in utf8 strings.
+		# thats ok i suppose, maybe i can say its the job of the mime class to handle that.
+		# but a lot of the headers are overloaded in different ways. plain string, many strings
+		# other stuff. what happens to a person who has a " in their name etc etc. encoded words
+		# i suppose. but that then happens before assignment. and can't be automatically undone
+		# until the header is decomposed into recipients.
+		recips_by_type = recipients.group_by { |r| r.type }
+		# i want to the the types in a specific order.
+		[:to, :cc, :bcc].each do |type|
+			# don't know why i bother, but if we can, we try to sort recipients by the numerical part
+			# of the ole name, or just leave it if we can't
+			recips = recips_by_type[type]
+			recips = (recips.sort_by { |r| r.obj.name[/\d{8}$/].hex } rescue recips)
+			# are you supposed to use ; or , to separate?
+			# recips.empty? is strange. i wouldn't have thought it possible, but it was right?
+			headers[type.to_s.sub(/^(.)/) { $1.upcase }] = [recips.join('; ')] unless recips.empty?
+		end
+		headers['Subject'] = [props.subject] if props.subject
+
+		# fill in a date value. by default, we won't mess with existing value hear
+		if !headers.has_key?('Date')
+			# we want to get a received date, as i understand it.
+			# use this preference order, or pull the most recent?
+			keys = %w[message_delivery_time client_submit_time last_modification_time creation_time]
+			time = keys.each { |key| break time if time = props.send(key) }
+			time = nil unless Date === time
+			# can employ other methods for getting a time. heres one in a similar vein to msgconvert.pl,
+			# ie taking the time from an ole object
+			time ||= @root.ole.dirents.map(&:time).compact.sort.last
+
+			# now convert and store
+			# this is a little funky. not sure about time zone stuff either?
+			# actually seems ok. maybe its always UTC and interpreted anyway. or can be timezoneless.
+			# i have no timezone info anyway.
+			# in gmail, i see stuff like 15 Jan 2007 00:48:19 -0000, and it displays as 11:48.
+			# can also add .localtime here if desired. but that feels wrong.
+			require 'time'
+			headers['Date'] = [Time.iso8601(time.to_s).rfc2822] if time
+		end
+
+		if !headers.has_key?('Message-ID') and props.internet_message_id
+			headers['Message-ID'] = [props.internet_message_id]
+		end
+		if !headers.has_key?('In-Reply-To') and props.in_reply_to_id
+			headers['In-Reply-To'] = [props.in_reply_to_id]
+		end
+	end
+
+	def ignore obj
+		Log.warn "* ignoring #{obj.name} (#{obj.type.to_s})"
+	end
+
+	# redundant?
+	def type
+		props.message_class[/IPM\.(.*)/, 1].downcase rescue nil
+	end
+
+	# shortcuts to some things from the headers
+	%w[From To Cc Bcc Subject].each do |key|
+		define_method(key.downcase) { headers[key].join(' ') if headers.has_key?(key) }
+	end
+
+	def inspect
+		str = %w[from to cc bcc subject type].map do |key|
+			send(key) and "#{key}=#{send(key).inspect}"
+		end.compact.join(' ')
+		"#<Msg #{str}>"
+	end
+
+	# --------
+	# beginnings of conversion stuff
+
+	def convert
+		# 
+		# for now, multiplex between returning a Mime object,
+		# a Vpim::Vcard object,
+		# a Vpim::Vcalendar object
+		#
+		# all of which should support a common serialization,
+		# to save the result to a file.
+		#
+	end
+
+	def body_to_mime
+		# to create the body
+		# should have some options about serializing rtf. and possibly options to check the rtf
+		# for rtf2html conversion, stripping those html tags or other similar stuff. maybe want to
+		# ignore it in the cases where it is generated from incoming html. but keep it if it was the
+		# source for html and plaintext.
+		if props.body_rtf or props.body_html
+			# should plain come first?
+			mime = Mime.new "Content-Type: multipart/alternative\r\n\r\n"
+			# its actually possible for plain body to be empty, but the others not.
+			# if i can get an html version, then maybe a callout to lynx can be made...
+			mime.parts << Mime.new("Content-Type: text/plain\r\n\r\n" + props.body) if props.body
+			# this may be automatically unwrapped from the rtf if the rtf includes the html
+			mime.parts << Mime.new("Content-Type: text/html\r\n\r\n"  + props.body_html) if props.body_html
+			# temporarily disabled the rtf. its just showing up as an attachment anyway.
+			#mime.parts << Mime.new("Content-Type: text/rtf\r\n\r\n"   + props.body_rtf)  if props.body_rtf
+			# its thus currently possible to get no body at all if the only body is rtf. that is not
+			# really acceptable FIXME
+			mime
+		else
+			# check no header case. content type? etc?. not sure if my Mime class will accept
+			Log.debug "taking that other path"
+			# body can be nil, hence the to_s
+			Mime.new "Content-Type: text/plain\r\n\r\n" + props.body.to_s
+		end
+	end
+
+	def to_mime
+		# intended to be used for IPM.note, which is the email type. can use it for others if desired,
+		# YMMV
+		Log.warn "to_mime used on a #{props.message_class}" unless props.message_class == 'IPM.Note'
+		# we always have a body
+		mime = body = body_to_mime
+
+		# If we have attachments, we take the current mime root (body), and make it the first child
+		# of a new tree that will contain body and attachments.
+		unless attachments.empty?
+			mime = Mime.new "Content-Type: multipart/mixed\r\n\r\n"
+			mime.parts << body
+			# i don't know any better way to do this. need multipart/related for inline images
+			# referenced by cid: urls to work, but don't want to use it otherwise...
+			related = false
+			attachments.each do |attach|
+				part = attach.to_mime
+				related = true if part.headers.has_key?('Content-ID') or part.headers.has_key?('Content-Location')
+				mime.parts << part
+			end
+			mime.headers['Content-Type'] = ['multipart/related'] if related
+		end
+
+		# at this point, mime is either
+		# - a single text/plain, consisting of the body ('taking that other path' above. rare)
+		# - a multipart/alternative, consiting of a few bodies (plain and html body. common)
+		# - a multipart/mixed, consisting of 1 of the above 2 types of bodies, and attachments.
+		# we add this standard preamble if its multipart
+		# FIXME preamble.replace, and body.replace both suck.
+		# preamble= is doable. body= wasn't being done because body will get rewritten from parts
+		# if multipart, and is only there readonly. can do that, or do a reparse...
+		# The way i do this means that only the first preamble will say it, not preambles of nested
+		# multipart chunks.
+		mime.preamble.replace "This is a multi-part message in MIME format.\r\n" if mime.multipart?
+
+		# now that we have a root, we can mix in all our headers
+		headers.each do |key, vals|
+			# don't overwrite the content-type, encoding style stuff
+			next if mime.headers.has_key? key
+			# some new temporary hacks
+			next if key =~ /content-type/i and vals[0] =~ /base64/
+			next if mime.headers.keys.map(&:downcase).include? key.downcase
+			mime.headers[key] += vals
+		end
+		# just a stupid hack to make the content-type header last, when using OrderedHash
+		mime.headers['Content-Type'] = mime.headers.delete 'Content-Type'
+
+		mime
+	end
+
+	def to_vcard
+		require 'rubygems'
+		require 'vpim/vcard'
+		# a very incomplete mapping, but its a start...
+		# can't find where to set a lot of stuff, like zipcode, jobtitle etc
+		# FIXME all the .to_s stuff is because i was to lazy to not set if nil. and setting when nil breaks
+		# the Vcard#to_s later. find a neater way that scales to many properties like this.
+		# property map perhaps, like:
+		# { 
+		#   :location => 'work',
+		#   :street   => :business_address_street,
+		#   :locality => proc { |props| [props.business_address_city, props.business_address_state].compact.join ', ' },
+		#   ...
+		# and then have the vcard filled in according to this (1-way) translation map.
+		card = Vpim::Vcard::Maker.make2 do |m|
+			# these are all standard mapi properties
+			m.add_name do |n|
+				n.given = props.given_name.to_s
+				n.family = props.surname.to_s
+				n.fullname = props.subject.to_s
+			end
+
+			# outlook seems to eschew the mapi properties this time,
+			# like postal_address, street_address, home_address_city
+			# so we use the named properties
+			m.add_addr do |a|
+				a.location = 'work'
+				a.street = props.business_address_street.to_s
+				# i think i can just assign the array
+				a.locality = [props.business_address_city, props.business_address_state].compact.join ', '
+				a.country = props.business_address_country.to_s
+				a.postalcode = props.business_address_postal_code.to_s
+			end
+
+			# right type?
+			m.birthday = props.birthday if props.birthday
+			m.nickname = props.nickname.to_s
+
+			# photo available?
+			# FIXME finish, emails, telephones etc
+		end
+	end
+
+	class Attachment
+		attr_reader :obj, :properties
+		alias props :properties
+
+		def initialize obj
+			@obj = obj
+			@properties = Properties.load @obj
+			@embedded_ole = nil
+			@embedded_msg = nil
+
+			@properties.unused.each do |child|
+				# FIXME temporary hack. this is fairly messy stuff.
+				if child.dir? and child.name =~ Properties::SUBSTG_RX and
+					 $1 == '3701' and $2.downcase == '000d'
+					@embedded_ole = child
+					class << @embedded_ole
+						def compobj
+							return nil unless compobj = self["\001CompObj"]
+							compobj.read[/^.{32}([^\x00]+)/m, 1]
+						end
+
+						def embedded_type
+							temp = compobj and return temp
+							# try to guess more
+							if children.select { |child| child.name =~ /__(substg|properties|recip|attach|nameid)/ }.length > 2
+								return 'Microsoft Office Outlook Message'
+							end
+							nil
+						end
+					end
+					if @embedded_ole.embedded_type == 'Microsoft Office Outlook Message'
+						@embedded_msg = Msg.new @embedded_ole
+					end
+				end
+				# FIXME warn
+			end
+		end
+
+		def valid?
+			# something i started to notice when handling embedded ole object attachments is
+			# the particularly strange case where they're are empty attachments
+			props.raw.keys.length > 0
+		end
+
+		def filename
+			props.attach_long_filename || props.attach_filename
+		end
+
+		def data
+			@embedded_msg || @embedded_ole || props.attach_data
+		end
+
+		# with new stream work, its possible to not have the whole thing in memory at one time,
+		# just to save an attachment
+		#
+		# a = msg.attachments.first
+		# a.save open(File.basename(a.filename || 'attachment'), 'wb') 
+		def save io
+			raise "can only save binary data blobs, not ole dirs" if @embedded_ole
+			data.each_read { |chunk| io << chunk }
+		end
+
+		def to_mime
+			# TODO: smarter mime typing.
+			mimetype = props.attach_mime_tag || 'application/octet-stream'
+			mime = Mime.new "Content-Type: #{mimetype}\r\n\r\n"
+			mime.headers['Content-Disposition'] = [%{attachment; filename="#{filename}"}]
+			mime.headers['Content-Transfer-Encoding'] = ['base64']
+			mime.headers['Content-Location'] = [props.attach_content_location] if props.attach_content_location
+			mime.headers['Content-ID'] = [props.attach_content_id] if props.attach_content_id
+			# data.to_s for now. data was nil for some reason.
+			# perhaps it was a data object not correctly handled?
+			# hmmm, have to use read here. that assumes that the data isa stream.
+			# but if the attachment data is a string, then it won't work. possible?
+			data_str = if @embedded_msg
+				mime.headers['Content-Type'] = 'message/rfc822'
+				# lets try making it not base64 for now
+				mime.headers.delete 'Content-Transfer-Encoding'
+				# not filename. rather name, or something else right?
+				# maybe it should be inline?? i forget attach_method / access meaning
+				mime.headers['Content-Disposition'] = [%{attachment; filename="#{@embedded_msg.subject}"}]
+				@embedded_msg.to_mime.to_s
+			elsif @embedded_ole
+				# kind of hacky
+				io = StringIO.new
+				Ole::Storage.new io do |ole|
+					ole.root.type = :dir
+					Ole::Storage::Dirent.copy @embedded_ole, ole.root
+				end
+				io.string
+			else
+				data.read.to_s
+			end
+			mime.body.replace @embedded_msg ? data_str : Base64.encode64(data_str).gsub(/\n/, "\r\n")
+			mime
+		end
+
+		def inspect
+			"#<#{self.class.to_s[/\w+$/]}" +
+				(filename ? " filename=#{filename.inspect}" : '') +
+				(@embedded_ole ? " embedded_type=#{@embedded_ole.embedded_type.inspect}" : '') + ">"
+		end
+	end
+
+	#
+	# +Recipient+ serves as a container for the +recip+ directories in the .msg.
+	# It has things like office_location, business_telephone_number, but I don't
+	# think enough to make a vCard out of?
+	#
+	class Recipient
+		attr_reader :obj, :properties
+		alias props :properties
+
+		def initialize obj
+			@obj = obj
+			@properties = Properties.load @obj
+			@properties.unused.each do |child|
+				# FIXME warn
+			end
+		end
+
+		# some kind of best effort guess for converting to standard mime style format.
+		# there are some rules for encoding non 7bit stuff in mail headers. should obey
+		# that here, as these strings could be unicode
+		# email_address will be an EX:/ address (X.400?), unless external recipient. the
+		# other two we try first.
+		# consider using entry id for this too.
+		def name
+			name = props.transmittable_display_name || props.display_name
+			# dequote
+			name[/^'(.*)'/, 1] or name rescue nil
+		end
+
+		def email
+			props.smtp_address || props.org_email_addr || props.email_address
+		end
+
+		RECIPIENT_TYPES = { 0 => :orig, 1 => :to, 2 => :cc, 3 => :bcc }
+		def type
+			RECIPIENT_TYPES[props.recipient_type]
+		end
+
+		def to_s
+			if name = self.name and !name.empty? and email && name != email
+				%{"#{name}" <#{email}>}
+			else
+				email || name
+			end
+		end
+
+		def inspect
+			"#<#{self.class.to_s[/\w+$/]}:#{self.to_s.inspect}>"
+		end
+	end
+end
+
+if $0 == __FILE__
+	quiet = if ARGV[0] == '-q'
+		ARGV.shift
+		true
+	end
+	# just shut up and convert a message to eml
+	Msg::Log.level = Logger::WARN
+	Msg::Log.level = Logger::FATAL if quiet
+	msg = Msg.open ARGV[0]
+	puts msg.to_mime.to_s
+	msg.close
+end
+

data/lib/ole/base.rb

@@ -0,0 +1,5 @@
+
+module Ole # :nodoc:
+	Log = Logger.new_with_callstack
+end
+

data/lib/ole/file_system.rb

@@ -0,0 +1,181 @@
+#
+# = Introduction
+#
+# This file intends to provide file system-like api support, a la <tt>zip/zipfilesystem</tt>.
+#
+# Ideally, this will be the recommended interface, allowing Ole::Storage, Dir, and
+# Zip::ZipFile to be used exchangablyk. It should be possible to write recursive copy using
+# the plain api, such that you can copy dirs/files agnostically between any of ole docs, dirs,
+# and zip files.
+#
+# = Usage
+#
+# Currently you can do something like the following:
+#
+#   Ole::Storage.open 'test.doc' do |ole|
+#     ole.dir.entries '/'         # => [".", "..", "\001Ole", "1Table", "\001CompObj", ...]
+#     ole.file.read "\001CompObj" # => "\001\000\376\377\003\n\000\000\377\377..."
+#   end
+#
+# = Notes
+#
+# *** This file is very incomplete
+# 
+# i think its okay to have an api like this on top, but there are certain things that ole
+# does that aren't captured.
+# <tt>Ole::Storage</tt> can have multiple files with the same name, for example, or with
+# / in the name, and other things that are probably invalid anyway.
+# i think this should remain an addon, built on top of my core api.
+# but still the ideas can be reflected in the core, ie, changing the read/write semantics.
+#
+# once the core changes are complete, this will be a pretty straight forward file to complete.
+#
+
+require 'ole/base'
+
+module Ole # :nodoc:
+	class Storage
+		def file
+			@file ||= FileParent.new self
+		end
+
+		def dir
+			@dir ||= DirParent.new self
+		end
+
+		def dirent_from_path path_str
+			path = path_str.sub(/^\/*/, '').sub(/\/*$/, '')
+			dirent = @root
+			return dirent if path.empty?
+			path = path.split /\/+/
+			until path.empty?
+				raise "invalid path #{path_str.inspect}" if dirent.file?
+				if tmp = dirent[path.shift]
+					dirent = tmp
+				else
+					# allow write etc later.
+					raise "invalid path #{path_str.inspect}"
+				end
+			end
+			dirent
+		end
+
+		class FileParent
+			def initialize ole
+				@ole = ole
+			end
+
+			def open path_str, mode='r', &block
+				dirent = @ole.dirent_from_path path_str
+				# like Errno::EISDIR
+				raise "#{path_str.inspect} is a directory" unless dirent.file?
+				dirent.open(&block)
+			end
+
+			alias new :open
+
+			def read path
+				open(path) { |f| f.read }
+			end
+
+			# crappy copy from Dir.
+			def unlink path
+				dirent = @ole.dirent_from_path path
+				# EPERM
+				raise "operation not permitted #{path.inspect}" unless dirent.file?
+				# i think we should free all of our blocks. i think the best way to do that would be
+				# like:
+				# open(path) { |f| f.truncate 0 }. which should free all our blocks from the
+				# allocation table. then if we remove ourself from our parent, we won't be part of
+				# the bat at save time.
+				# i think if you run repack, all free blocks should get zeroed.
+				open(path) { |f| f.truncate 0 }
+				parent = @ole.dirent_from_path(('/' + path).sub(/\/[^\/]+$/, ''))
+				parent.children.delete dirent
+				1 # hmmm. as per ::File ?
+			end
+		end
+
+		class DirParent
+			def initialize ole
+				@ole = ole
+			end
+
+			def open path_str
+				dirent = @ole.dirent_from_path path_str
+				# like Errno::ENOTDIR
+				raise "#{path_str.inspect} is not a directory" unless dirent.dir?
+				dir = Dir.new dirent, path_str
+				if block_given?
+					yield dir
+				else
+					dir
+				end
+			end
+
+			# certain Dir class methods proxy in this fashion:
+			def entries path
+				open(path) { |dir| dir.entries }
+			end
+
+			# there are some other important ones, like:
+			# chroot (!), mkdir, chdir, rmdir, glob etc etc. for now, i think
+			# mkdir, and rmdir are the main ones we'd need to support
+			def rmdir path
+				dirent = @ole.dirent_from_path path
+				# repeating myself
+				raise "#{path.inspect} is not a directory" unless dirent.dir?
+				# ENOTEMPTY:
+				raise "directory not empty #{path.inspect}" unless dirent.children.empty?
+				# now delete it, how to do that? the canonical representation that is
+				# maintained is the root tree, and the children array. we must remove it
+				# from the children array.
+				# we need the parent then. this sucks but anyway:
+				parent = @ole.dirent_from_path path.sub(/\/[^\/]+$/, '') || '/'
+				# note that the way this currently works, on save and repack time this will get
+				# reflected. to work properly, ie to make a difference now it would have to re-write
+				# the dirent. i think that Ole::Storage#close will handle that. and maybe include a
+				# #repack.
+				parent.children.delete dirent
+				0 # hmmm. as per ::Dir ?
+			end
+
+			class Dir
+				include Enumerable
+				attr_reader :dirent, :path, :entries, :pos
+
+				def initialize dirent, path
+					@dirent, @path = dirent, path
+					@pos = 0
+					# FIXME: hack, and probably not really desired
+					@entries = %w[. ..] + @dirent.children.map(&:name)
+				end
+
+				def each(&block)
+					@entries.each(&block)
+				end
+
+				def close
+				end
+
+				def read
+					@entries[@pos]
+				ensure
+					@pos += 1 if @pos < @entries.length
+				end
+
+				def pos= pos
+					@pos = [[0, pos].max, @entries.length].min
+				end
+
+				def rewind
+					@pos = 0
+				end
+
+				alias tell :pos
+				alias seek :pos=
+			end
+		end
+	end
+end
+