#!/usr/bin/env python
# College of Creative Studies
#   Password Daemon
#
# Douglas Thrift
#
# $Id$

import common
import ctypes
import ctypes.util
from datetime import datetime
import fnmatch
from M2Crypto import SSL
import os
import socket, SocketServer
import struct
import sys
import time
import traceback

ADDRESS = ('', common.PORT)
debug = False

class PasswordHandler(SocketServer.StreamRequestHandler):
	def handle(self):
		self._client()

		if self.rfile.read(8) != common.HANDSHAKE[0]:
			return

		self.wfile.write(struct.pack('<HB', *common.HANDSHAKE[1]))
		self.wfile.flush()

		command = struct.unpack('<B', self.rfile.read(1))[0]

		if command == common.CHANGE:
			self.__reply(self._change(self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0]), self.rfile.read(struct.unpack('<H', self.rfile.read(2))[0]), self.rfile.read(struct.unpack('<H', self.rfile.read(2))[0])))
		elif command == common.RESET:
			self.__reply(self._reset(self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0]), self.rfile.read(struct.unpack('<H', self.rfile.read(2))[0])))
		elif command == common.ADD:
			self.__reply(self._add(self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0]), self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0]), self.rfile.read(struct.unpack('<H', self.rfile.read(2))[0])))
		elif command == common.CHFN:
			self.__reply(self._chfn(self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0]), self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0])))
		elif command == common.CHSH:
			user = self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0])
			shell = self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0])
			shells = []
			
			for item in xrange(struct.unpack('<B', self.rfile.read(1))[0]):
				shells.append(self.rfile.read(struct.unpack('<B', self.rfile.read(1))[0]))

			self.__reply(self._chsh(user, shell, shells))
		elif command == common.BOOT:
			self.__reply(self.__boot())
		else:
			self.__reply(NotImplementedError('Unknown command: %u.' % command))

	def _client(self):
		if debug:
			print '%s:%u' % self.client_address

	def _change(self, user, old_password, new_password):
		return NotImplementedError('Not implemented.')

	def _reset(self, user, password):
		return NotImplementedError('Not implemented.')

	def _add(self, user, name, password):
		return NotImplementedError('Not implemented.')

	def _chfn(self, user, name):
		return NotImplementedError('Not implemented.')

	def _chsh(self, user, shell, shells):
		return NotImplementedError('Not implemented.')

	def __boot(self):
		try:
			return struct.pack('<d', _boot())
		except Exception, error:
			if debug:
				traceback.print_exc()

			return error

	def __reply(self, reply):
		if reply is None:
			self.wfile.write(struct.pack('<B', 0))
		elif not isinstance(reply, Exception):
			self.wfile.write(struct.pack('<B', 0) + str(reply))
		else:
			self.wfile.write(struct.pack('<B', 1) + str(reply))

class SSLServerMixIn(object):
	def _handle_request_noblock(self):
		try:
			self.handle_request()
		except socket.error:
			return

class Boot(object):
	def __call__(self):
		raise NotImplementedError("Unknown platform: '%s'." % sys.platform)

	def __str__(self):
		return str(self.__class__.__name__)

class ProcUptimeBoot(Boot):
	if sys.platform.startswith('freebsd'):
		PROC_UPTIME = '/compat/linux/proc/uptime'
	else:
		PROC_UPTIME = '/proc/uptime'

	def __init__(self):
		with open(self.PROC_UPTIME):
			pass

	def __call__(self):
		with open(self.PROC_UPTIME) as uptime:
			return time.time() - float(uptime.read().split(None, 1)[0])

class SysCtlBoot(Boot):
	class timeval(ctypes.Structure):
		_fields_ = [
			('tv_sec', ctypes.c_long),
			('tv_usec', ctypes.c_int if sys.platform == 'darwin' else ctypes.c_long),
		]

	def __init__(self):
		self.libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno = True)
		self.size = ctypes.c_uint(0)

		self._size()

	def __call__(self):
		boot = self.timeval()

		self._boot(boot)

		return boot.tv_sec + boot.tv_usec / 1e6

	def _size(self):
		self.mib = (ctypes.c_int * 2)(1, 21) # CTL_KERN, KERN_BOOTTIME

		if self.libc.sysctl(self.mib, len(self.mib), None, ctypes.byref(self.size), None, 0):
			status = ctypes.get_errno()

			raise OSError(status, os.strerror(status))

	def _boot(self, boot):
		if self.libc.sysctl(self.mib, len(self.mib), ctypes.byref(boot), ctypes.byref(self.size), None, 0):
			status = ctypes.get_errno()

			raise OSError(status, os.strerror(status))

class SysCtlByNameBoot(SysCtlBoot):
	def _size(self):
		if self.libc.sysctlbyname('kern.boottime', None, ctypes.byref(self.size), None, 0):
			status = ctypes.get_errno()

			raise OSError(status, os.strerror(status))

	def _boot(self, boot):
		if self.libc.sysctlbyname('kern.boottime', ctypes.byref(boot), ctypes.byref(self.size), None, 0):
			status = ctypes.get_errno()

			raise OSError(status, os.strerror(status))

class WindowsBoot(Boot):
	def __init__(self):
		self.libnet = ctypes.WinDLL('netapi32')

	def __call__(self):
		class TIME_OF_DAY_INFO(ctypes.Structure):
			_fields_ = [
				('tod_elapsedt', ctypes.c_ulong),
				('tod_msecs', ctypes.c_ulong),
				('tod_hours', ctypes.c_ulong),
				('tod_mins', ctypes.c_ulong),
				('tod_secs', ctypes.c_ulong),
				('tod_hunds', ctypes.c_ulong),
				('tod_timezone', ctypes.c_long),
				('tod_tinterval', ctypes.c_ulong),
				('tod_day', ctypes.c_ulong),
				('tod_month', ctypes.c_ulong),
				('tod_year', ctypes.c_ulong),
				('tod_weekday', ctypes.c_ulong),
			]

		LPTIME_OF_DAY_INFO = ctypes.POINTER(TIME_OF_DAY_INFO)
		info = LPTIME_OF_DAY_INFO()
		status = self.libnet.NetRemoteTOD(None, ctypes.byref(info))

		if status:
			raise ctypes.WinError(status)

		return time.time() - info.contents.tod_msecs / 1e3

if sys.platform.startswith('linux'):
	_boot = ProcUptimeBoot()
elif sys.platform.startswith('openbsd'):
	_boot = SysCtlBoot()
elif fnmatch.fnmatchcase(sys.platform, '*bsd*') or sys.platform == 'darwin' or sys.platform.startswith('dragonfly'):
	_boot = SysCtlByNameBoot()
elif sys.platform == 'win32':
	_boot = WindowsBoot()
else:
	_boot = Boot()

boots = fnmatch.filter(dir(), '[!_]*Boot')

if __name__ == '__main__':
	if sys.platform != 'win32':
		import admin

		parser = admin.parser()
	else:
		import optparse
		import subprocess
		import win32api
		import _winreg

		commands = ('install', 'update', 'remove', 'start', 'stop', 'restart', 'debug')
		parser = optparse.OptionParser(prog = os.path.splitext(os.path.basename(sys.argv[0]))[0], usage = '%%prog [options] [%s] [...]' % '|'.join(commands))

		def version(option, opt_str, value, parser, *args, **kwargs):
			version = subprocess.Popen('svnversion', stdout = subprocess.PIPE, cwd = os.path.dirname(__file__)).communicate()[0].strip()

			if version == 'exported':
				key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r'Software\Microsoft\Windows\CurrentVersion\Uninstall\CCS CS Password Daemon')
				version = _winreg.QueryValueEx(key, 'DisplayVersion')[0]

				_winreg.CloseKey(key)

			parser.version = '%%prog %s (CCS CS Lab) - ' % version
			version = win32api.GetVersionEx(1)

			if version[:2] == (5, 1) or version[:2] == (5, 2) and version[8] == 0x1:
				parser.version += 'Windows XP'
			elif version[:2] == (5, 2):
				parser.version += 'Windows Server 2003'

				if win32api.GetSystemMetrics(89):
					parser.version += ' R2'
			elif version[:2] == (6, 0):
				if version[8] == 1:
					parser.version += 'Windows Vista'
				else:
					parser.version += 'Windows Server 2008'
			elif version[:2] == (6, 1):
				if version[8] == 1:
					parser.version += 'Windows 7'
				else:
					parser.version += 'Windows Server 2008 R2'
			else:
				parser.version += 'Windows NT %u.%u' % version[:2]

			if version[4]:
				parser.version += ' ' + version[4]

			arch = win32api.GetNativeSystemInfo()

			if arch[0] in (0, 6, 9):
				parser.version += ' '

				if arch[0] == 0:
					parser.version += 'x86'
				elif arch[0] == 6:
					parser.version += 'ia64'
				else:
					parser.version += 'amd64'

			parser.print_version()
			parser.exit()

		parser.add_option('-V', '--version', action = 'callback', callback = version, help = 'show version information and exit')

	def boot(option, opt_str, value, parser, *args, **kwargs):
		try:
			exec '_boot = %s()' % value in globals()

			parser.values.boot = value
		except Exception, error:
			parser.error('option %s: %s: %s' % (opt_str, value, error))

	def uptime(option, opt_str, value, parser, *args, **kwargs):
		if not parser.rargs:
			try:
				boot = _boot()

				print datetime.now() - datetime.fromtimestamp(boot), boot

				parser.exit()
			except Exception, error:
				sys.exit('%s: %s' % (parser.prog, error))
		elif set(option._short_opts + option._long_opts).isdisjoint(parser.rargs):
			parser.rargs.append(opt_str)

	parser.add_option('-b', '--boot', action = 'callback', type = 'choice', choices = boots, callback = boot, help = 'set the boot time method to BOOT; available: %s; default: %s' % (', '.join(boots), _boot))
	parser.add_option('-u', '--uptime', action = 'callback', callback = uptime, help = 'show the uptime given by the boot time method')

if sys.platform == 'win32':
	import servicemanager
	import win32net, win32service, win32serviceutil

	common.SSL_ROOT = os.path.dirname(os.path.abspath(__file__))

	class Win32PasswordHandler(PasswordHandler):
		def _change(self, user, old_password, new_password):
			try:
				win32net.NetUserChangePassword(None, user, old_password, new_password)
			except win32net.error, error:
				return error

		def _reset(self, user, password):
			try:
				win32net.NetUserSetInfo(None, user, 1003, {'password': password})
			except win32net.error, error:
				return error

		def _add(self, user, name, password):
			try:
				win32net.NetUserAdd(None, 2, {'name': user, 'password': password, 'priv': 1, 'flags': 0x10201, 'full_name': name, 'acct_expires': -1, 'max_storage': -1, })

				info = [{'sid': win32net.NetUserGetInfo(None, user, 4)['user_sid']}]

				win32net.NetLocalGroupAddMembers(None, 'Users', 0, info)
				win32net.NetLocalGroupAddMembers(None, 'Administrators', 0, info)
			except win32net.error, error:
				return error

		def _chfn(self, user, name):
			try:
				win32net.NetUserSetInfo(None, user, 1011, {'full_name': name})
			except win32net.error, error:
				return error

	class PasswordServerService(win32serviceutil.ServiceFramework, SSLServerMixIn, SSL.ThreadingSSLServer):
		_svc_name_ = 'CCSCSLabPassword'
		_svc_display_name_ = 'CCS CS Lab Password'
		_svc_description_ = 'Provides remote password administration.'
		_svc_deps_ = ('lanmanworkstation',)

		def __init__(self, args):
			for boot in set(boots).intersection(fnmatch.filter(args, '[!_]*Boot')):
				exec '_boot = %s()' % boot in globals()

			win32serviceutil.ServiceFramework.__init__(self, args)
			SSL.ThreadingSSLServer.__init__(self, ADDRESS, Win32PasswordHandler if socket.getfqdn() in common.HOSTS else PasswordHandler, common._context())

			global debug

			debug = servicemanager.Debugging()

		def handle_error(self, request, client_address):
			if not debug:
				servicemanager.LogErrorMsg(traceback.format_exc())
			else:
				SSL.ThreadingSSLServer.handle_error(self, request, client_address)

		def SvcDoRun(self):
			self.serve_forever()

		def SvcStop(self):
			self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
			self.shutdown()

	if __name__ == '__main__':
		def internal(option, opt_str, value, parser, *args, **kwargs):
			try:
				win32serviceutil.usage()
			except SystemExit, error:
				parser.exit()

		parser.add_option('--help-internal', action = 'callback', callback = internal, help = optparse.SUPPRESS_HELP)

		group = optparse.OptionGroup(parser, 'Options for install/update')
		startup = ('manual', 'auto', 'disabled')

		def option(option, opt_str, value, parser, *args, **kwargs):
			parser.values.args.append(option._long_opts[0])

			if value is not None:
				parser.values.args.append(str(value))

		group.add_option('-U', '--username', action = 'callback', type = 'string', dest = 'args', callback = option, help = 'set the service user to USERNAME', metavar = 'USERNAME')
		group.add_option('-P', '--password', action = 'callback', type = 'string', dest = 'args', callback = option, help = 'set the service password to PASSWORD', metavar = 'PASSWORD')
		group.add_option('-p', '--prompt', action = 'store_true', help = 'prompt for the service user and password')
		group.add_option('-s', '--startup', action = 'callback', type = 'choice', dest = 'args', choices = startup, callback = option, help = 'set the startup method; available: %s; default: %s' % (', '.join(startup), startup[0]), metavar = 'STARTUP')
		group.add_option('--interactive', action = 'callback', callback = option, help = optparse.SUPPRESS_HELP)
		group.add_option('--perfmonini', action = 'callback', type = 'string', dest = 'args', callback = option, help = optparse.SUPPRESS_HELP)
		group.add_option('--perfmondll', action = 'callback', type = 'string', dest = 'args', callback = option, help = optparse.SUPPRESS_HELP)
		parser.add_option_group(group)

		group = optparse.OptionGroup(parser, 'Options for start/stop')

		group.add_option('-w', '--wait', action = 'callback', type = 'int', dest = 'args', default = sys.argv[:1], callback = option, metavar = 'WAIT')
		parser.add_option_group(group)

		options, args = parser.parse_args()

		if not args:
			parser.print_help()
			parser.exit(1)
		elif args[0] not in commands:
			parser.error("invalid command: '%s'" % args[0])

		if options.prompt:
			import win32console

			win32console.SetConsoleTitle(PasswordServerService._svc_display_name_)

			while True:
				try:
					username = raw_input('User: ')

					if not username:
						print 'Empty account name.'
						continue

					options.args += ['--username', '.\\' + username, '--password', common.new_password('Password')]
				except common.PasswordError, error:
					print error
				except KeyboardInterrupt:
					print
				else:
					break

		if options.boot:
			args.append(options.boot)

		win32serviceutil.HandleCommandLine(PasswordServerService, argv = options.args + args)
else:
	import ldap
	import MySQLdb
	import psycopg2
	import signal

	class UnixPasswordHandler(PasswordHandler):
		def _change(self, user, old_password, new_password):
			try:
				admin.passwd(user, old_password, new_password)
			except (ldap.LDAPError, MySQLdb.MySQLError), error:
				return error

		def _reset(self, user, password):
			try:
				admin.passwd(user, None, password)
			except (ldap.LDAPError, MySQLdb.MySQLError), error:
				return error

		def _add(self, user, name, password):
			try:
				admin.adduser(user, name, password)
			except (ldap.LDAPError, OSError, MySQLdb.MySQLError, psycopg2.Error, psycopg2.Warning), error:
				return error

		def _chfn(self, user, name):
			try:
				admin.chfn(user, name)
			except ldap.LDAPError, error:
				return error

		def _chsh(self, user, shell, shells):
			try:
				admin.chsh(user, shell, shells)
			except ldap.LDAPError, error:
				return error

	class PasswordServer(SSLServerMixIn, SSL.ThreadingSSLServer):
		def __init__(self):
			host = socket.gethostname().split('.', 1)[0]

			SSL.ThreadingSSLServer.__init__(self, ADDRESS, UnixPasswordHandler if admin.master() else PasswordHandler, common._context())

	if __name__ == '__main__':
		parser.add_option('-d', '--daemon', action = 'store_true', help = 'run in the background as a daemon')
		parser.add_option('-D', '--debug', action = 'store_true', help = 'stay in the foreground and print debug messages')
		parser.add_option('-k', '--kill', action = 'store_true', help = 'kill the currently running daemon')

		options = parser.parse_args()[0]

		if options.kill:
			if os.path.exists('/var/run/CCSpasswdd.pid'):
				with open('/var/run/CCSpasswdd.pid', 'rb') as pid_file:
					pid = int(pid_file.readline())

				print 'killing %u' % pid

				os.kill(pid, signal.SIGTERM)

				while True:
					try:
						os.kill(pid, 0)
						time.sleep(1)
					except OSError:
						break

			if not options.daemon and not options.debug:
				sys.exit(0)

		if not options.daemon and not options.debug:
			parser.error('no option specified')

		server = PasswordServer()
		debug = options.debug

		if not debug:
			pid = os.fork()

			if pid != 0:
				with open('/var/run/CCSpasswdd.pid', 'wb') as pid_file:
					pid_file.write('%u\n' % pid)

				sys.exit(0)

			def cleanup(signum, frame):
				os.unlink('/var/run/CCSpasswdd.pid')
				sys.exit(0)

			signal.signal(signal.SIGTERM, cleanup)

			sys.stdin = open('/dev/null')
			sys.stdout = open('/var/log/CCSpasswdd.log', 'ab', 1)
			sys.stderr = sys.stdout

			server.serve_forever()
		else:
			try:
				server.serve_forever()
			except KeyboardInterrupt:
				pass

# vim: noexpandtab tabstop=4