1 """Core objects for the mudpy engine."""
3 # Copyright (c) 2004-2008 Jeremy Stanley <fungi@yuggoth.org>. Permission
4 # to use, copy, modify, and distribute this software is granted under
5 # terms provided in the LICENSE file distributed with this software.
7 # import some things we need
8 from ConfigParser import RawConfigParser
9 from md5 import new as new_md5
10 from os import _exit, R_OK, W_OK, access, chdir, chmod, close, fork, getcwd, getpid, listdir, makedirs, remove, rename, setsid, stat, umask
11 from os.path import abspath, basename, dirname, exists, isabs, join as path_join
12 from random import choice, randrange
14 from signal import SIGHUP, SIGTERM, signal
15 from socket import AF_INET, SO_REUSEADDR, SOCK_STREAM, SOL_SOCKET, socket
16 from stat import S_IMODE, ST_MODE
17 from string import digits, letters, punctuation, uppercase
18 from sys import argv, stderr
19 from syslog import LOG_PID, LOG_INFO, LOG_DAEMON, closelog, openlog, syslog
20 from telnetlib import DO, DONT, ECHO, EOR, GA, IAC, LINEMODE, SB, SE, SGA, WILL, WONT
21 from time import asctime, sleep
22 from traceback import format_exception
25 """An element of the universe."""
26 def __init__(self, key, universe, filename=None):
27 """Set up a new element."""
29 # keep track of our key name
32 # keep track of what universe it's loading` into
33 self.universe = universe
35 # clone attributes if this is replacing another element
36 if self.key in self.universe.contents:
37 old_element = self.universe.contents[self.key]
38 for attribute in vars(old_element).keys():
39 exec("self." + attribute + " = old_element." + attribute)
40 if self.owner: self.owner.avatar = self
42 # i guess this is a new element then
45 # not owned by a user by default (used for avatars)
48 # no contents in here by default
51 # parse out appropriate category and subkey names, add to list
52 if self.key.find(":") > 0:
53 self.category, self.subkey = self.key.split(":", 1)
55 self.category = "other"
56 self.subkey = self.key
57 if not self.category in self.universe.categories:
58 self.category = "other"
59 self.subkey = self.key
61 # get an appropriate filename for the origin
62 if not filename: filename = self.universe.default_origins[self.category]
63 if not isabs(filename): filename = abspath(filename)
65 # add the file if it doesn't exist yet
66 if not filename in self.universe.files: DataFile(filename, self.universe)
68 # record or reset a pointer to the origin file
69 self.origin = self.universe.files[filename]
71 # add a data section to the origin if necessary
72 if not self.origin.data.has_section(self.key):
73 self.origin.data.add_section(self.key)
75 # add or replace this element in the universe
76 self.universe.contents[self.key] = self
77 self.universe.categories[self.category][self.subkey] = self
80 """Create a new element and replace this one."""
81 new_element = Element(self.key, self.universe, self.origin.filename)
84 """Remove an element from the universe and destroy it."""
85 self.origin.data.remove_section(self.key)
86 del self.universe.categories[self.category][self.subkey]
87 del self.universe.contents[self.key]
90 """Return a list of non-inherited facets for this element."""
91 if self.key in self.origin.data.sections():
92 return self.origin.data.options(self.key)
94 def has_facet(self, facet):
95 """Return whether the non-inherited facet exists."""
96 return facet in self.facets()
97 def remove_facet(self, facet):
98 """Remove a facet from the element."""
99 if self.has_facet(facet):
100 self.origin.data.remove_option(self.key, facet)
101 self.origin.modified = True
103 """Return a list of the element's inheritance lineage."""
104 if self.has_facet("inherit"):
105 ancestry = self.getlist("inherit")
106 for parent in ancestry[:]:
107 ancestors = self.universe.contents[parent].ancestry()
108 for ancestor in ancestors:
109 if ancestor not in ancestry: ancestry.append(ancestor)
112 def get(self, facet, default=None):
113 """Retrieve values."""
114 if default is None: default = ""
115 if self.origin.data.has_option(self.key, facet):
116 return self.origin.data.get(self.key, facet)
117 elif self.has_facet("inherit"):
118 for ancestor in self.ancestry():
119 if self.universe.contents[ancestor].has_facet(facet):
120 return self.universe.contents[ancestor].get(facet)
122 def getboolean(self, facet, default=None):
123 """Retrieve values as boolean type."""
124 if default is None: default=False
125 if self.origin.data.has_option(self.key, facet):
126 return self.origin.data.getboolean(self.key, facet)
127 elif self.has_facet("inherit"):
128 for ancestor in self.ancestry():
129 if self.universe.contents[ancestor].has_facet(facet):
130 return self.universe.contents[ancestor].getboolean(facet)
132 def getint(self, facet, default=None):
133 """Return values as int/long type."""
134 if default is None: default = 0
135 if self.origin.data.has_option(self.key, facet):
136 return self.origin.data.getint(self.key, facet)
137 elif self.has_facet("inherit"):
138 for ancestor in self.ancestry():
139 if self.universe.contents[ancestor].has_facet(facet):
140 return self.universe.contents[ancestor].getint(facet)
142 def getfloat(self, facet, default=None):
143 """Return values as float type."""
144 if default is None: default = 0.0
145 if self.origin.data.has_option(self.key, facet):
146 return self.origin.data.getfloat(self.key, facet)
147 elif self.has_facet("inherit"):
148 for ancestor in self.ancestry():
149 if self.universe.contents[ancestor].has_facet(facet):
150 return self.universe.contents[ancestor].getfloat(facet)
152 def getlist(self, facet, default=None):
153 """Return values as list type."""
154 if default is None: default = []
155 value = self.get(facet)
156 if value: return makelist(value)
158 def getdict(self, facet, default=None):
159 """Return values as dict type."""
160 if default is None: default = {}
161 value = self.get(facet)
162 if value: return makedict(value)
164 def set(self, facet, value):
166 if not self.has_facet(facet) or not self.get(facet) == value:
167 if type(value) is long: value = str(value)
168 elif not type(value) is str: value = repr(value)
169 self.origin.data.set(self.key, facet, value)
170 self.origin.modified = True
171 def append(self, facet, value):
172 """Append value tp a list."""
173 if type(value) is long: value = str(value)
174 elif not type(value) is str: value = repr(value)
175 newlist = self.getlist(facet)
176 newlist.append(value)
177 self.set(facet, newlist)
179 def new_event(self, action, when=None):
180 """Create, attach and enqueue an event element."""
182 # if when isn't specified, that means now
183 if not when: when = self.universe.get_time()
185 # events are elements themselves
186 event = Element("event:" + self.key + ":" + counter)
188 def send(self, message, eol="$(eol)", raw=False, flush=False, add_prompt=True, just_prompt=False):
189 """Convenience method to pass messages to an owner."""
190 if self.owner: self.owner.send(message, eol, raw, flush, add_prompt, just_prompt)
192 def can_run(self, command):
193 """Check if the user can run this command object."""
195 # has to be in the commands category
196 if command not in self.universe.categories["command"].values(): result = False
198 # avatars of administrators can run any command
199 elif self.owner and self.owner.account.getboolean("administrator"): result = True
201 # everyone can run non-administrative commands
202 elif not command.getboolean("administrative"): result = True
204 # otherwise the command cannot be run by this actor
207 # pass back the result
210 def update_location(self):
211 """Make sure the location's contents contain this element."""
212 location = self.get("location")
213 if location in self.universe.contents:
214 self.universe.contents[location].contents[self.key] = self
215 def clean_contents(self):
216 """Make sure the element's contents aren't bogus."""
217 for element in self.contents.values():
218 if element.get("location") != self.key:
219 del self.contents[element.key]
220 def go_to(self, location):
221 """Relocate the element to a specific location."""
222 current = self.get("location")
223 if current and self.key in self.universe.contents[current].contents:
224 del universe.contents[current].contents[self.key]
225 if location in self.universe.contents: self.set("location", location)
226 self.universe.contents[location].contents[self.key] = self
227 self.look_at(location)
229 """Relocate the element to its default location."""
230 self.go_to(self.get("default_location"))
231 self.echo_to_location("You suddenly realize that " + self.get("name") + " is here.")
232 def move_direction(self, direction):
233 """Relocate the element in a specified direction."""
234 self.echo_to_location(self.get("name") + " exits " + self.universe.categories["internal"]["directions"].getdict(direction)["exit"] + ".")
235 self.send("You exit " + self.universe.categories["internal"]["directions"].getdict(direction)["exit"] + ".", add_prompt=False)
236 self.go_to(self.universe.contents[self.get("location")].link_neighbor(direction))
237 self.echo_to_location(self.get("name") + " arrives from " + self.universe.categories["internal"]["directions"].getdict(direction)["enter"] + ".")
238 def look_at(self, key):
239 """Show an element to another element."""
241 element = self.universe.contents[key]
243 name = element.get("name")
244 if name: message += "$(cyn)" + name + "$(nrm)$(eol)"
245 description = element.get("description")
246 if description: message += description + "$(eol)"
247 portal_list = element.portals().keys()
250 message += "$(cyn)[ Exits: " + ", ".join(portal_list) + " ]$(nrm)$(eol)"
251 for element in self.universe.contents[self.get("location")].contents.values():
252 if element.getboolean("is_actor") and element is not self:
253 message += "$(yel)" + element.get("name") + " is here.$(nrm)$(eol)"
254 elif element is not self:
255 message += "$(grn)" + element.get("impression") + "$(nrm)$(eol)"
258 """Map the portal directions for a room to neighbors."""
260 if match("""^location:-?\d+,-?\d+,-?\d+$""", self.key):
261 coordinates = [(int(x)) for x in self.key.split(":")[1].split(",")]
262 directions = self.universe.categories["internal"]["directions"]
263 offsets = dict([(x, directions.getdict(x)["vector"]) for x in directions.facets()])
264 for portal in self.getlist("gridlinks"):
265 adjacent = map(lambda c,o: c+o, coordinates, offsets[portal])
266 neighbor = "location:" + ",".join([(str(x)) for x in adjacent])
267 if neighbor in self.universe.contents: portals[portal] = neighbor
268 for facet in self.facets():
269 if facet.startswith("link_"):
270 neighbor = self.get(facet)
271 if neighbor in self.universe.contents:
272 portal = facet.split("_")[1]
273 portals[portal] = neighbor
275 def link_neighbor(self, direction):
276 """Return the element linked in a given direction."""
277 portals = self.portals()
278 if direction in portals: return portals[direction]
279 def echo_to_location(self, message):
280 """Show a message to other elements in the current location."""
281 for element in self.universe.contents[self.get("location")].contents.values():
282 if element is not self: element.send(message)
285 """A file containing universe elements."""
286 def __init__(self, filename, universe):
287 self.filename = filename
288 self.universe = universe
291 """Read a file and create elements accordingly."""
292 self.modified = False
293 self.data = RawConfigParser()
294 if access(self.filename, R_OK): self.data.read(self.filename)
295 if not hasattr(self.universe, "files"): self.universe.files = {}
296 self.universe.files[self.filename] = self
297 if self.data.has_option("__control__", "include_files"):
298 includes = makelist(self.data.get("__control__", "include_files"))
300 if self.data.has_option("__control__", "default_files"):
301 origins = makedict(self.data.get("__control__", "default_files"))
302 for key in origins.keys():
303 if not isabs(origins[key]):
304 origins[key] = path_join(dirname(self.filename), origins[key])
305 if not origins[key] in includes: includes.append(origins[key])
306 self.universe.default_origins[key] = origins[key]
307 if not key in self.universe.categories:
308 self.universe.categories[key] = {}
309 if self.data.has_option("__control__", "private_files"):
310 for item in makelist(self.data.get("__control__", "private_files")):
311 if not item in includes: includes.append(item)
312 if not item in self.universe.private_files:
314 item = path_join(dirname(self.filename), item)
315 self.universe.private_files.append(item)
316 for section in self.data.sections():
317 if section != "__control__":
318 Element(section, self.universe, self.filename)
319 for include_file in includes:
320 if not isabs(include_file):
321 include_file = path_join(dirname(self.filename), include_file)
322 if include_file not in self.universe.files or not self.universe.files[include_file].is_writeable():
323 DataFile(include_file, self.universe)
325 """Write the data, if necessary."""
327 # when modified, writeable and has content or the file exists
328 if self.modified and self.is_writeable() and ( self.data.sections() or exists(self.filename) ):
330 # make parent directories if necessary
331 if not exists(dirname(self.filename)):
332 makedirs(dirname(self.filename))
335 if self.data.has_option("__control__", "backup_count"):
336 max_count = self.data.has_option("__control__", "backup_count")
337 else: max_count = universe.categories["internal"]["limits"].getint("default_backup_count")
338 if exists(self.filename) and max_count:
340 for candidate in listdir(dirname(self.filename)):
341 if match(basename(self.filename) + """\.\d+$""", candidate):
342 backups.append(int(candidate.split(".")[-1]))
345 for old_backup in backups:
346 if old_backup >= max_count-1:
347 remove(self.filename+"."+str(old_backup))
348 elif not exists(self.filename+"."+str(old_backup+1)):
349 rename(self.filename+"."+str(old_backup), self.filename+"."+str(old_backup+1))
350 if not exists(self.filename+".0"):
351 rename(self.filename, self.filename+".0")
354 file_descriptor = file(self.filename, "w")
356 # if it's marked private, chmod it appropriately
357 if self.filename in self.universe.private_files and oct(S_IMODE(stat(self.filename)[ST_MODE])) != 0600:
358 chmod(self.filename, 0600)
360 # write it back sorted, instead of using ConfigParser
361 sections = self.data.sections()
363 for section in sections:
364 file_descriptor.write("[" + section + "]\n")
365 options = self.data.options(section)
367 for option in options:
368 file_descriptor.write(option + " = " + self.data.get(section, option) + "\n")
369 file_descriptor.write("\n")
371 # flush and close the file
372 file_descriptor.flush()
373 file_descriptor.close()
375 # unset the modified flag
376 self.modified = False
377 def is_writeable(self):
378 """Returns True if the __control__ read_only is False."""
379 return not self.data.has_option("__control__", "read_only") or not self.data.getboolean("__control__", "read_only")
384 def __init__(self, filename="", load=False):
385 """Initialize the universe."""
388 self.default_origins = {}
390 self.pending_events_long = {}
391 self.pending_events_short = {}
392 self.private_files = []
393 self.reload_flag = False
394 self.startdir = getcwd()
395 self.terminate_flag = False
398 possible_filenames = [
404 "/usr/local/mudpy/mudpy.conf",
405 "/usr/local/mudpy/etc/mudpy.conf",
406 "/etc/mudpy/mudpy.conf",
409 for filename in possible_filenames:
410 if access(filename, R_OK): break
411 if not isabs(filename):
412 filename = path_join(self.startdir, filename)
413 self.filename = filename
417 """Load universe data from persistent storage."""
419 # the files dict must exist and filename needs to be read-only
420 if not hasattr(self, "files") or not ( self.filename in self.files and self.files[self.filename].is_writeable() ):
422 # clear out all read-only files
423 if hasattr(self, "files"):
424 for data_filename in self.files.keys():
425 if not self.files[data_filename].is_writeable():
426 del self.files[data_filename]
428 # start loading from the initial file
429 DataFile(self.filename, self)
431 # make a list of inactive avatars
432 inactive_avatars = []
433 for account in self.categories["account"].values():
434 inactive_avatars += [ (self.contents[x]) for x in account.getlist("avatars") ]
435 for user in self.userlist:
436 if user.avatar in inactive_avatars:
437 inactive_avatars.remove(user.avatar)
439 # go through all elements to clear out inactive avatar locations
440 for element in self.contents.values():
441 location = element.get("location")
442 if element in inactive_avatars and location:
443 if location in self.contents and element.key in self.contents[location].contents:
444 del self.contents[location].contents[element.key]
445 element.set("default_location", location)
446 element.remove_facet("location")
448 # another pass to straighten out all the element contents
449 for element in self.contents.values():
450 element.update_location()
451 element.clean_contents()
454 """Create a new, empty Universe (the Big Bang)."""
455 new_universe = Universe()
456 for attribute in vars(self).keys():
457 exec("new_universe." + attribute + " = self." + attribute)
458 new_universe.reload_flag = False
463 """Save the universe to persistent storage."""
464 for key in self.files: self.files[key].save()
466 def initialize_server_socket(self):
467 """Create and open the listening socket."""
469 # create a new ipv4 stream-type socket object
470 self.listening_socket = socket(AF_INET, SOCK_STREAM)
472 # set the socket options to allow existing open ones to be
473 # reused (fixes a bug where the server can't bind for a minute
474 # when restarting on linux systems)
475 self.listening_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
477 # bind the socket to to our desired server ipa and port
478 host = self.categories["internal"]["network"].get("host")
479 port = self.categories["internal"]["network"].getint("port")
480 self.listening_socket.bind((host, port))
482 # disable blocking so we can proceed whether or not we can
484 self.listening_socket.setblocking(0)
486 # start listening on the socket
487 self.listening_socket.listen(1)
489 # note that we're now ready for user connections
490 if not host: host = "0.0.0.0"
491 log("Listening for Telnet connections on: " + host + ":" + str(port))
494 """Convenience method to get the elapsed time counter."""
495 return self.categories["internal"]["counters"].getint("elapsed")
498 """This is a connected user."""
501 """Default values for the in-memory user variables."""
504 self.authenticated = False
506 self.connection = None
509 self.input_queue = []
510 self.last_address = ""
511 self.last_input = universe.get_time()
512 self.menu_choices = {}
513 self.menu_seen = False
514 self.negotiation_pause = 0
515 self.output_queue = []
516 self.partial_input = ""
517 self.password_tries = 0
518 self.received_newline = True
519 self.state = "initial"
520 self.terminator = IAC+GA
523 """Log, close the connection and remove."""
524 if self.account: name = self.account.get("name")
526 if name: message = "User " + name
527 else: message = "An unnamed user"
528 message += " logged out."
530 self.deactivate_avatar()
531 self.connection.close()
534 def check_idle(self):
535 """Warn or disconnect idle users as appropriate."""
536 idletime = universe.get_time() - self.last_input
537 linkdead_dict = universe.categories["internal"]["time"].getdict("linkdead")
538 if self.state in linkdead_dict: linkdead_state = self.state
539 else: linkdead_state = "default"
540 if idletime > linkdead_dict[linkdead_state]:
541 self.send("$(eol)$(red)You've done nothing for far too long... goodbye!$(nrm)$(eol)", flush=True, add_prompt=False)
542 logline = "Disconnecting "
543 if self.account and self.account.get("name"): logline += self.account.get("name")
544 else: logline += "an unknown user"
545 logline += " after idling too long in a " + self.state + " state."
547 self.state = "disconnecting"
548 self.menu_seen = False
549 idle_dict = universe.categories["internal"]["time"].getdict("idle")
550 if self.state in idle_dict: idle_state = self.state
551 else: idle_state = "default"
552 if idletime == idle_dict[idle_state]:
553 self.send("$(eol)$(red)If you continue to be unproductive, you'll be shown the door...$(nrm)$(eol)")
556 """Save, load a new user and relocate the connection."""
558 # get out of the list
561 # create a new user object
564 # set everything equivalent
565 for attribute in vars(self).keys():
566 exec("new_user." + attribute + " = self." + attribute)
568 # the avatar needs a new owner
569 if new_user.avatar: new_user.avatar.owner = new_user
572 universe.userlist.append(new_user)
574 # get rid of the old user object
577 def replace_old_connections(self):
578 """Disconnect active users with the same name."""
580 # the default return value
583 # iterate over each user in the list
584 for old_user in universe.userlist:
586 # the name is the same but it's not us
587 if hasattr(old_user, "account") and old_user.account and old_user.account.get("name") == self.account.get("name") and old_user is not self:
590 log("User " + self.account.get("name") + " reconnected--closing old connection to " + old_user.address + ".", 2)
591 old_user.send("$(eol)$(red)New connection from " + self.address + ". Terminating old connection...$(nrm)$(eol)", flush=True, add_prompt=False)
593 # close the old connection
594 old_user.connection.close()
596 # replace the old connection with this one
597 old_user.send("$(eol)$(red)Taking over old connection from " + old_user.address + ".$(nrm)")
598 old_user.connection = self.connection
599 old_user.last_address = old_user.address
600 old_user.address = self.address
602 # may need to tell the new connection to echo
604 old_user.send(get_echo_sequence(old_user.state, self.echoing), raw=True)
606 # take this one out of the list and delete
612 # true if an old connection was replaced, false if not
615 def authenticate(self):
616 """Flag the user as authenticated and disconnect duplicates."""
617 if not self.state is "authenticated":
618 log("User " + self.account.get("name") + " logged in.", 2)
619 self.authenticated = True
620 if self.account.subkey in universe.categories["internal"]["limits"].getlist("default_admins"):
621 self.account.set("administrator", "True")
624 """Send the user their current menu."""
625 if not self.menu_seen:
626 self.menu_choices = get_menu_choices(self)
627 self.send(get_menu(self.state, self.error, self.echoing, self.terminator, self.menu_choices), "")
628 self.menu_seen = True
630 self.adjust_echoing()
632 def adjust_echoing(self):
633 """Adjust echoing to match state menu requirements."""
634 if self.echoing and not menu_echo_on(self.state): self.echoing = False
635 elif not self.echoing and menu_echo_on(self.state): self.echoing = True
638 """Remove a user from the list of connected users."""
639 universe.userlist.remove(self)
641 def send(self, output, eol="$(eol)", raw=False, flush=False, add_prompt=True, just_prompt=False):
642 """Send arbitrary text to a connected user."""
644 # unless raw mode is on, clean it up all nice and pretty
647 # strip extra $(eol) off if present
648 while output.startswith("$(eol)"): output = output[6:]
649 while output.endswith("$(eol)"): output = output[:-6]
650 extra_lines = output.find("$(eol)$(eol)$(eol)")
651 while extra_lines > -1:
652 output = output[:extra_lines] + output[extra_lines+6:]
653 extra_lines = output.find("$(eol)$(eol)$(eol)")
655 # we'll take out GA or EOR and add them back on the end
656 if output.endswith(IAC+GA) or output.endswith(IAC+EOR):
659 else: terminate = False
661 # start with a newline, append the message, then end
662 # with the optional eol string passed to this function
663 # and the ansi escape to return to normal text
665 if not self.output_queue or not self.output_queue[-1].endswith("\r\n"):
666 output = "$(eol)$(eol)" + output
667 elif not self.output_queue[-1].endswith("\r\n"+chr(27)+"[0m"+"\r\n") and not self.output_queue[-1].endswith("\r\n\r\n"):
668 output = "$(eol)" + output
669 output += eol + chr(27) + "[0m"
671 # tack on a prompt if active
672 if self.state == "active":
673 if not just_prompt: output += "$(eol)"
676 mode = self.avatar.get("mode")
677 if mode: output += "(" + mode + ") "
679 # find and replace macros in the output
680 output = replace_macros(self, output)
682 # wrap the text at 79 characters
683 output = wrap_ansi_text(output, 79)
685 # tack the terminator back on
686 if terminate: output += self.terminator
688 # drop the output into the user's output queue
689 self.output_queue.append(output)
691 # if this is urgent, flush all pending output
692 if flush: self.flush()
695 """All the things to do to the user per increment."""
697 # if the world is terminating, disconnect
698 if universe.terminate_flag:
699 self.state = "disconnecting"
700 self.menu_seen = False
702 # check for an idle connection and act appropriately
703 else: self.check_idle()
705 # if output is paused, decrement the counter
706 if self.state == "initial":
707 if self.negotiation_pause: self.negotiation_pause -= 1
708 else: self.state = "entering_account_name"
710 # show the user a menu as needed
711 elif not self.state == "active": self.show_menu()
713 # flush any pending output in teh queue
716 # disconnect users with the appropriate state
717 if self.state == "disconnecting": self.quit()
719 # check for input and add it to the queue
722 # there is input waiting in the queue
724 handle_user_input(self)
727 """Try to send the last item in the queue and remove it."""
728 if self.output_queue:
729 if self.received_newline:
730 self.received_newline = False
731 if self.output_queue[0].startswith("\r\n"):
732 self.output_queue[0] = self.output_queue[0][2:]
734 self.connection.send(self.output_queue[0])
735 del self.output_queue[0]
740 def enqueue_input(self):
741 """Process and enqueue any new input."""
743 # check for some input
745 input_data = self.connection.recv(1024)
752 # tack this on to any previous partial
753 self.partial_input += input_data
755 # reply to and remove any IAC negotiation codes
756 self.negotiate_telnet_options()
758 # separate multiple input lines
759 new_input_lines = self.partial_input.split("\n")
761 # if input doesn't end in a newline, replace the
762 # held partial input with the last line of it
763 if not self.partial_input.endswith("\n"):
764 self.partial_input = new_input_lines.pop()
766 # otherwise, chop off the extra null input and reset
767 # the held partial input
769 new_input_lines.pop()
770 self.partial_input = ""
772 # iterate over the remaining lines
773 for line in new_input_lines:
775 # remove a trailing carriage return
776 if line.endswith("\r"): line = line.rstrip("\r")
778 # log non-printable characters remaining
779 removed = filter(lambda x: (x < " " or x > "~"), line)
781 logline = "Non-printable characters from "
782 if self.account and self.account.get("name"): logline += self.account.get("name") + ": "
783 else: logline += "unknown user: "
784 logline += repr(removed)
787 # filter out non-printables
788 line = filter(lambda x: " " <= x <= "~", line)
790 # strip off extra whitespace
793 # put on the end of the queue
794 self.input_queue.append(line)
796 def negotiate_telnet_options(self):
797 """Reply to/remove partial_input telnet negotiation options."""
799 # start at the begining of the input
802 # make a local copy to play with
803 text = self.partial_input
805 # as long as we haven't checked it all
806 while position < len(text):
808 # jump to the first IAC you find
809 position = text.find(IAC, position)
811 # if there wasn't an IAC in the input, skip to the end
812 if position < 0: position = len(text)
814 # replace a double (literal) IAC if there's an LF later
815 elif len(text) > position+1 and text[position+1] == IAC:
816 if text.find("\n", position) > 0: text = text.replace(IAC+IAC, IAC)
820 # this must be an option negotiation
821 elif len(text) > position+2 and text[position+1] in (DO, DONT, WILL, WONT):
823 negotiation = text[position+1:position+3]
825 # if we turned echo off, ignore the confirmation
826 if not self.echoing and negotiation == DO+ECHO: pass
829 elif negotiation == WILL+LINEMODE: self.send(IAC+DO+LINEMODE, raw=True)
831 # if the client likes EOR instead of GA, make a note of it
832 elif negotiation == DO+EOR: self.terminator = IAC+EOR
833 elif negotiation == DONT+EOR and self.terminator == IAC+EOR:
834 self.terminator = IAC+GA
836 # if the client doesn't want GA, oblige
837 elif negotiation == DO+SGA and self.terminator == IAC+GA:
839 self.send(IAC+WILL+SGA, raw=True)
841 # we don't want to allow anything else
842 elif text[position+1] == DO: self.send(IAC+WONT+text[position+2], raw=True)
843 elif text[position+1] == WILL: self.send(IAC+DONT+text[position+2], raw=True)
845 # strip the negotiation from the input
846 text = text.replace(text[position:position+3], "")
848 # get rid of IAC SB .* IAC SE
849 elif len(text) > position+4 and text[position:position+2] == IAC+SB:
850 end_subnegotiation = text.find(IAC+SE, position)
851 if end_subnegotiation > 0: text = text[:position] + text[end_subnegotiation+2:]
854 # otherwise, strip out a two-byte IAC command
855 elif len(text) > position+2: text = text.replace(text[position:position+2], "")
857 # and this means we got the begining of an IAC
860 # replace the input with our cleaned-up text
861 self.partial_input = text
863 def new_avatar(self):
864 """Instantiate a new, unconfigured avatar for this user."""
866 while "avatar:" + self.account.get("name") + ":" + str(counter) in universe.categories["actor"].keys(): counter += 1
867 self.avatar = Element("actor:avatar:" + self.account.get("name") + ":" + str(counter), universe)
868 self.avatar.append("inherit", "archetype:avatar")
869 self.account.append("avatars", self.avatar.key)
871 def delete_avatar(self, avatar):
872 """Remove an avatar from the world and from the user's list."""
873 if self.avatar is universe.contents[avatar]: self.avatar = None
874 universe.contents[avatar].destroy()
875 avatars = self.account.getlist("avatars")
876 avatars.remove(avatar)
877 self.account.set("avatars", avatars)
879 def activate_avatar_by_index(self, index):
880 """Enter the world with a particular indexed avatar."""
881 self.avatar = universe.contents[self.account.getlist("avatars")[index]]
882 self.avatar.owner = self
883 self.state = "active"
884 self.avatar.go_home()
886 def deactivate_avatar(self):
887 """Have the active avatar leave the world."""
889 current = self.avatar.get("location")
891 self.avatar.set("default_location", current)
892 self.avatar.echo_to_location("You suddenly wonder where " + self.avatar.get("name") + " went.")
893 del universe.contents[current].contents[self.avatar.key]
894 self.avatar.remove_facet("location")
895 self.avatar.owner = None
899 """Destroy the user and associated avatars."""
900 for avatar in self.account.getlist("avatars"): self.delete_avatar(avatar)
901 self.account.destroy()
903 def list_avatar_names(self):
904 """List names of assigned avatars."""
905 return [ universe.contents[avatar].get("name") for avatar in self.account.getlist("avatars") ]
908 """Turn string into list type."""
909 if value[0] + value[-1] == "[]": return eval(value)
910 else: return [ value ]
913 """Turn string into dict type."""
914 if value[0] + value[-1] == "{}": return eval(value)
915 elif value.find(":") > 0: return eval("{" + value + "}")
916 else: return { value: None }
918 def broadcast(message, add_prompt=True):
919 """Send a message to all connected users."""
920 for each_user in universe.userlist: each_user.send("$(eol)" + message, add_prompt=add_prompt)
922 def log(message, level=0):
925 # a couple references we need
926 file_name = universe.categories["internal"]["logging"].get("file")
927 max_log_lines = universe.categories["internal"]["logging"].getint("max_log_lines")
928 syslog_name = universe.categories["internal"]["logging"].get("syslog")
929 timestamp = asctime()[4:19]
931 # turn the message into a list of lines
932 lines = filter(lambda x: x!="", [(x.rstrip()) for x in message.split("\n")])
934 # send the timestamp and line to a file
936 if not isabs(file_name):
937 file_name = path_join(universe.startdir, file_name)
938 file_descriptor = file(file_name, "a")
939 for line in lines: file_descriptor.write(timestamp + " " + line + "\n")
940 file_descriptor.flush()
941 file_descriptor.close()
943 # send the timestamp and line to standard output
944 if universe.categories["internal"]["logging"].getboolean("stdout"):
945 for line in lines: print(timestamp + " " + line)
947 # send the line to the system log
949 openlog(syslog_name, LOG_PID, LOG_INFO | LOG_DAEMON)
950 for line in lines: syslog(line)
953 # display to connected administrators
954 for user in universe.userlist:
955 if user.state == "active" and user.account.getboolean("administrator") and user.account.getint("loglevel") <= level:
956 # iterate over every line in the message
959 full_message += "$(bld)$(red)" + timestamp + " " + line + "$(nrm)$(eol)"
960 user.send(full_message, flush=True)
962 # add to the recent log list
964 while 0 < len(universe.loglines) >= max_log_lines: del universe.loglines[0]
965 universe.loglines.append((level, timestamp + " " + line))
967 def get_loglines(level, start, stop):
968 """Return a specific range of loglines filtered by level."""
970 # filter the log lines
971 loglines = filter(lambda x: x[0]>=level, universe.loglines)
973 # we need these in several places
974 total_count = str(len(universe.loglines))
975 filtered_count = len(loglines)
977 # don't proceed if there are no lines
980 # can't start before the begining or at the end
981 if start > filtered_count: start = filtered_count
982 if start < 1: start = 1
984 # can't stop before we start
985 if stop > start: stop = start
986 elif stop < 1: stop = 1
989 message = "There are " + str(total_count)
990 message += " log lines in memory and " + str(filtered_count)
991 message += " at or above level " + str(level) + "."
992 message += " The matching lines from " + str(stop) + " to "
993 message += str(start) + " are:$(eol)$(eol)"
995 # add the text from the selected lines
996 if stop > 1: range_lines = loglines[-start:-(stop-1)]
997 else: range_lines = loglines[-start:]
998 for line in range_lines:
999 message += " (" + str(line[0]) + ") " + line[1] + "$(eol)"
1001 # there were no lines
1003 message = "None of the " + str(total_count)
1004 message += " lines in memory matches your request."
1009 def wrap_ansi_text(text, width):
1010 """Wrap text with arbitrary width while ignoring ANSI colors."""
1012 # the current position in the entire text string, including all
1013 # characters, printable or otherwise
1014 absolute_position = 0
1016 # the current text position relative to the begining of the line,
1017 # ignoring color escape sequences
1018 relative_position = 0
1020 # whether the current character is part of a telnet IAC sequence
1023 # whether the current character is part of a color escape sequence
1026 # iterate over each character from the begining of the text
1027 for each_character in text:
1029 # the current character is the telnet IAC character
1030 if each_character == IAC and not iac_counter:
1033 # the current character is within an IAC sequence
1036 # the current character is another IAC,
1037 # terminating the sequence
1038 if each_character == IAC:
1041 # otherwise, decrement the IAC counter
1045 # the current character is the escape character
1046 elif each_character == chr(27) and not escape:
1049 # the current character is within an escape sequence
1052 # the current character is m, which terminates the
1054 if each_character == "m":
1057 # the current character is a newline, so reset the relative
1058 # position (start a new line)
1059 elif each_character == "\n":
1060 relative_position = 0
1062 # the current character meets the requested maximum line width,
1063 # so we need to backtrack and find a space at which to wrap
1064 elif relative_position == width and not each_character == "\r":
1066 # distance of the current character examined from the
1070 # count backwards until we find a space
1071 while text[absolute_position - wrap_offset] != " ":
1074 # insert an eol in place of the space
1075 text = text[:absolute_position - wrap_offset] + "\r\n" + text[absolute_position - wrap_offset + 1:]
1077 # increase the absolute position because an eol is two
1078 # characters but the space it replaced was only one
1079 absolute_position += 1
1081 # now we're at the begining of a new line, plus the
1082 # number of characters wrapped from the previous line
1083 relative_position = wrap_offset
1085 # as long as the character is not a carriage return and the
1086 # other above conditions haven't been met, count it as a
1087 # printable character
1088 elif each_character != "\r":
1089 relative_position += 1
1091 # increase the absolute position for every character
1092 absolute_position += 1
1094 # return the newly-wrapped text
1097 def weighted_choice(data):
1098 """Takes a dict weighted by value and returns a random key."""
1100 # this will hold our expanded list of keys from the data
1103 # create thee expanded list of keys
1104 for key in data.keys():
1105 for count in range(data[key]):
1106 expanded.append(key)
1108 # return one at random
1109 return choice(expanded)
1112 """Returns a random character name."""
1114 # the vowels and consonants needed to create romaji syllables
1115 vowels = [ "a", "i", "u", "e", "o" ]
1116 consonants = ["'", "k", "z", "s", "sh", "z", "j", "t", "ch", "ts", "d", "n", "h", "f", "m", "y", "r", "w" ]
1118 # this dict will hold our weighted list of syllables
1121 # generate the list with an even weighting
1122 for consonant in consonants:
1123 for vowel in vowels:
1124 syllables[consonant + vowel] = 1
1126 # we'll build the name into this string
1129 # create a name of random length from the syllables
1130 for syllable in range(randrange(2, 6)):
1131 name += weighted_choice(syllables)
1133 # strip any leading quotemark, capitalize and return the name
1134 return name.strip("'").capitalize()
1136 def replace_macros(user, text, is_input=False):
1137 """Replaces macros in text output."""
1139 # third person pronouns
1141 "female": { "obj": "her", "pos": "hers", "sub": "she" },
1142 "male": { "obj": "him", "pos": "his", "sub": "he" },
1143 "neuter": { "obj": "it", "pos": "its", "sub": "it" }
1146 # a dict of replacement macros
1149 "bld": chr(27) + "[1m",
1150 "nrm": chr(27) + "[0m",
1151 "blk": chr(27) + "[30m",
1152 "blu": chr(27) + "[34m",
1153 "cyn": chr(27) + "[36m",
1154 "grn": chr(27) + "[32m",
1155 "mgt": chr(27) + "[35m",
1156 "red": chr(27) + "[31m",
1157 "yel": chr(27) + "[33m",
1160 # add dynamic macros where possible
1162 account_name = user.account.get("name")
1164 macros["account"] = account_name
1166 avatar_gender = user.avatar.get("gender")
1168 macros["tpop"] = pronouns[avatar_gender]["obj"]
1169 macros["tppp"] = pronouns[avatar_gender]["pos"]
1170 macros["tpsp"] = pronouns[avatar_gender]["sub"]
1175 # find and replace per the macros dict
1176 macro_start = text.find("$(")
1177 if macro_start == -1: break
1178 macro_end = text.find(")", macro_start) + 1
1179 macro = text[macro_start+2:macro_end-1]
1180 if macro in macros.keys():
1181 replacement = macros[macro]
1183 # this is how we handle local file inclusion (dangerous!)
1184 elif macro.startswith("inc:"):
1185 incfile = path_join(universe.startdir, macro[4:])
1187 incfd = file(incfile)
1190 if line.endswith("\n") and not line.endswith("\r\n"):
1191 line = line.replace("\n", "\r\n")
1193 # lose the trailing eol
1194 replacement = replacement[:-2]
1197 log("Couldn't read included " + incfile + " file.", 6)
1199 # if we get here, log and replace it with null
1203 log("Unexpected replacement macro " + macro + " encountered.", 6)
1205 # and now we act on the replacement
1206 text = text.replace("$(" + macro + ")", replacement)
1208 # replace the look-like-a-macro sequence
1209 text = text.replace("$_(", "$(")
1213 def escape_macros(text):
1214 """Escapes replacement macros in text."""
1215 return text.replace("$(", "$_(")
1217 def first_word(text, separator=" "):
1218 """Returns a tuple of the first word and the rest."""
1220 if text.find(separator) > 0: return text.split(separator, 1)
1221 else: return text, ""
1225 """The things which should happen on each pulse, aside from reloads."""
1227 # open the listening socket if it hasn't been already
1228 if not hasattr(universe, "listening_socket"):
1229 universe.initialize_server_socket()
1231 # assign a user if a new connection is waiting
1232 user = check_for_connection(universe.listening_socket)
1233 if user: universe.userlist.append(user)
1235 # iterate over the connected users
1236 for user in universe.userlist: user.pulse()
1238 # add an element for counters if it doesn't exist
1239 if not "counters" in universe.categories["internal"]:
1240 universe.categories["internal"]["counters"] = Element("internal:counters", universe)
1242 # update the log every now and then
1243 if not universe.categories["internal"]["counters"].getint("mark"):
1244 log(str(len(universe.userlist)) + " connection(s)")
1245 universe.categories["internal"]["counters"].set("mark", universe.categories["internal"]["time"].getint("frequency_log"))
1246 else: universe.categories["internal"]["counters"].set("mark", universe.categories["internal"]["counters"].getint("mark") - 1)
1248 # periodically save everything
1249 if not universe.categories["internal"]["counters"].getint("save"):
1251 universe.categories["internal"]["counters"].set("save", universe.categories["internal"]["time"].getint("frequency_save"))
1252 else: universe.categories["internal"]["counters"].set("save", universe.categories["internal"]["counters"].getint("save") - 1)
1254 # pause for a configurable amount of time (decimal seconds)
1255 sleep(universe.categories["internal"]["time"].getfloat("increment"))
1257 # increase the elapsed increment counter
1258 universe.categories["internal"]["counters"].set("elapsed", universe.categories["internal"]["counters"].getint("elapsed") + 1)
1261 """Reload all relevant objects."""
1262 for user in universe.userlist[:]: user.reload()
1263 for element in universe.contents.values():
1264 if element.origin.is_writeable(): element.reload()
1267 def check_for_connection(listening_socket):
1268 """Check for a waiting connection and return a new user object."""
1270 # try to accept a new connection
1272 connection, address = listening_socket.accept()
1276 # note that we got one
1277 log("Connection from " + address[0], 2)
1279 # disable blocking so we can proceed whether or not we can send/receive
1280 connection.setblocking(0)
1282 # create a new user object
1285 # associate this connection with it
1286 user.connection = connection
1288 # set the user's ipa from the connection's ipa
1289 user.address = address[0]
1291 # let the client know we WILL EOR
1292 user.send(IAC+WILL+EOR, raw=True)
1293 user.negotiation_pause = 2
1295 # return the new user object
1298 def get_menu(state, error=None, echoing=True, terminator="", choices=None):
1299 """Show the correct menu text to a user."""
1301 # make sure we don't reuse a mutable sequence by default
1302 if choices is None: choices = {}
1304 # begin with a telnet echo command sequence if needed
1305 message = get_echo_sequence(state, echoing)
1307 # get the description or error text
1308 message += get_menu_description(state, error)
1310 # get menu choices for the current state
1311 message += get_formatted_menu_choices(state, choices)
1313 # try to get a prompt, if it was defined
1314 message += get_menu_prompt(state)
1316 # throw in the default choice, if it exists
1317 message += get_formatted_default_menu_choice(state)
1319 # display a message indicating if echo is off
1320 message += get_echo_message(state)
1322 # tack on EOR or GA to indicate the prompt will not be followed by CRLF
1323 message += terminator
1325 # return the assembly of various strings defined above
1328 def menu_echo_on(state):
1329 """True if echo is on, false if it is off."""
1330 return universe.categories["menu"][state].getboolean("echo", True)
1332 def get_echo_sequence(state, echoing):
1333 """Build the appropriate IAC WILL/WONT ECHO sequence as needed."""
1335 # if the user has echo on and the menu specifies it should be turned
1336 # off, send: iac + will + echo + null
1337 if echoing and not menu_echo_on(state): return IAC+WILL+ECHO
1339 # if echo is not set to off in the menu and the user curently has echo
1340 # off, send: iac + wont + echo + null
1341 elif not echoing and menu_echo_on(state): return IAC+WONT+ECHO
1343 # default is not to send an echo control sequence at all
1346 def get_echo_message(state):
1347 """Return a message indicating that echo is off."""
1348 if menu_echo_on(state): return ""
1349 else: return "(won't echo) "
1351 def get_default_menu_choice(state):
1352 """Return the default choice for a menu."""
1353 return universe.categories["menu"][state].get("default")
1355 def get_formatted_default_menu_choice(state):
1356 """Default menu choice foratted for inclusion in a prompt string."""
1357 default_choice = get_default_menu_choice(state)
1358 if default_choice: return "[$(red)" + default_choice + "$(nrm)] "
1361 def get_menu_description(state, error):
1362 """Get the description or error text."""
1364 # an error condition was raised by the handler
1367 # try to get an error message matching the condition
1369 description = universe.categories["menu"][state].get("error_" + error)
1370 if not description: description = "That is not a valid choice..."
1371 description = "$(red)" + description + "$(nrm)"
1373 # there was no error condition
1376 # try to get a menu description for the current state
1377 description = universe.categories["menu"][state].get("description")
1379 # return the description or error message
1380 if description: description += "$(eol)$(eol)"
1383 def get_menu_prompt(state):
1384 """Try to get a prompt, if it was defined."""
1385 prompt = universe.categories["menu"][state].get("prompt")
1386 if prompt: prompt += " "
1389 def get_menu_choices(user):
1390 """Return a dict of choice:meaning."""
1391 menu = universe.categories["menu"][user.state]
1392 create_choices = menu.get("create")
1393 if create_choices: choices = eval(create_choices)
1398 for facet in menu.facets():
1399 if facet.startswith("demand_") and not eval(universe.categories["menu"][user.state].get(facet)):
1400 ignores.append(facet.split("_", 2)[1])
1401 elif facet.startswith("create_"):
1402 creates[facet] = facet.split("_", 2)[1]
1403 elif facet.startswith("choice_"):
1404 options[facet] = facet.split("_", 2)[1]
1405 for facet in creates.keys():
1406 if not creates[facet] in ignores:
1407 choices[creates[facet]] = eval(menu.get(facet))
1408 for facet in options.keys():
1409 if not options[facet] in ignores:
1410 choices[options[facet]] = menu.get(facet)
1413 def get_formatted_menu_choices(state, choices):
1414 """Returns a formatted string of menu choices."""
1416 choice_keys = choices.keys()
1418 for choice in choice_keys:
1419 choice_output += " [$(red)" + choice + "$(nrm)] " + choices[choice] + "$(eol)"
1420 if choice_output: choice_output += "$(eol)"
1421 return choice_output
1423 def get_menu_branches(state):
1424 """Return a dict of choice:branch."""
1426 for facet in universe.categories["menu"][state].facets():
1427 if facet.startswith("branch_"):
1428 branches[facet.split("_", 2)[1]] = universe.categories["menu"][state].get(facet)
1431 def get_default_branch(state):
1432 """Return the default branch."""
1433 return universe.categories["menu"][state].get("branch")
1435 def get_choice_branch(user, choice):
1436 """Returns the new state matching the given choice."""
1437 branches = get_menu_branches(user.state)
1438 if choice in branches.keys(): return branches[choice]
1439 elif choice in user.menu_choices.keys(): return get_default_branch(user.state)
1442 def get_menu_actions(state):
1443 """Return a dict of choice:branch."""
1445 for facet in universe.categories["menu"][state].facets():
1446 if facet.startswith("action_"):
1447 actions[facet.split("_", 2)[1]] = universe.categories["menu"][state].get(facet)
1450 def get_default_action(state):
1451 """Return the default action."""
1452 return universe.categories["menu"][state].get("action")
1454 def get_choice_action(user, choice):
1455 """Run any indicated script for the given choice."""
1456 actions = get_menu_actions(user.state)
1457 if choice in actions.keys(): return actions[choice]
1458 elif choice in user.menu_choices.keys(): return get_default_action(user.state)
1461 def handle_user_input(user):
1462 """The main handler, branches to a state-specific handler."""
1464 # if the user's client echo is off, send a blank line for aesthetics
1465 if user.echoing: user.received_newline = True
1467 # check to make sure the state is expected, then call that handler
1468 if "handler_" + user.state in globals():
1469 exec("handler_" + user.state + "(user)")
1471 generic_menu_handler(user)
1473 # since we got input, flag that the menu/prompt needs to be redisplayed
1474 user.menu_seen = False
1476 # update the last_input timestamp while we're at it
1477 user.last_input = universe.get_time()
1479 def generic_menu_handler(user):
1480 """A generic menu choice handler."""
1482 # get a lower-case representation of the next line of input
1483 if user.input_queue:
1484 choice = user.input_queue.pop(0)
1485 if choice: choice = choice.lower()
1487 if not choice: choice = get_default_menu_choice(user.state)
1488 if choice in user.menu_choices:
1489 exec(get_choice_action(user, choice))
1490 new_state = get_choice_branch(user, choice)
1491 if new_state: user.state = new_state
1492 else: user.error = "default"
1494 def handler_entering_account_name(user):
1495 """Handle the login account name."""
1497 # get the next waiting line of input
1498 input_data = user.input_queue.pop(0)
1500 # did the user enter anything?
1503 # keep only the first word and convert to lower-case
1504 name = input_data.lower()
1506 # fail if there are non-alphanumeric characters
1507 if name != filter(lambda x: x>="0" and x<="9" or x>="a" and x<="z", name):
1508 user.error = "bad_name"
1510 # if that account exists, time to request a password
1511 elif name in universe.categories["account"]:
1512 user.account = universe.categories["account"][name]
1513 user.state = "checking_password"
1515 # otherwise, this could be a brand new user
1517 user.account = Element("account:" + name, universe)
1518 user.account.set("name", name)
1519 log("New user: " + name, 2)
1520 user.state = "checking_new_account_name"
1522 # if the user entered nothing for a name, then buhbye
1524 user.state = "disconnecting"
1526 def handler_checking_password(user):
1527 """Handle the login account password."""
1529 # get the next waiting line of input
1530 input_data = user.input_queue.pop(0)
1532 # does the hashed input equal the stored hash?
1533 if new_md5(user.account.get("name") + input_data).hexdigest() == user.account.get("passhash"):
1535 # if so, set the username and load from cold storage
1536 if not user.replace_old_connections():
1538 user.state = "main_utility"
1540 # if at first your hashes don't match, try, try again
1541 elif user.password_tries < universe.categories["internal"]["limits"].getint("password_tries") - 1:
1542 user.password_tries += 1
1543 user.error = "incorrect"
1545 # we've exceeded the maximum number of password failures, so disconnect
1547 user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)")
1548 user.state = "disconnecting"
1550 def handler_entering_new_password(user):
1551 """Handle a new password entry."""
1553 # get the next waiting line of input
1554 input_data = user.input_queue.pop(0)
1556 # make sure the password is strong--at least one upper, one lower and
1557 # one digit, seven or more characters in length
1558 if len(input_data) > 6 and len(filter(lambda x: x>="0" and x<="9", input_data)) and len(filter(lambda x: x>="A" and x<="Z", input_data)) and len(filter(lambda x: x>="a" and x<="z", input_data)):
1560 # hash and store it, then move on to verification
1561 user.account.set("passhash", new_md5(user.account.get("name") + input_data).hexdigest())
1562 user.state = "verifying_new_password"
1564 # the password was weak, try again if you haven't tried too many times
1565 elif user.password_tries < universe.categories["internal"]["limits"].getint("password_tries") - 1:
1566 user.password_tries += 1
1569 # too many tries, so adios
1571 user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)")
1572 user.account.destroy()
1573 user.state = "disconnecting"
1575 def handler_verifying_new_password(user):
1576 """Handle the re-entered new password for verification."""
1578 # get the next waiting line of input
1579 input_data = user.input_queue.pop(0)
1581 # hash the input and match it to storage
1582 if new_md5(user.account.get("name") + input_data).hexdigest() == user.account.get("passhash"):
1585 # the hashes matched, so go active
1586 if not user.replace_old_connections(): user.state = "main_utility"
1588 # go back to entering the new password as long as you haven't tried
1590 elif user.password_tries < universe.categories["internal"]["limits"].getint("password_tries") - 1:
1591 user.password_tries += 1
1592 user.error = "differs"
1593 user.state = "entering_new_password"
1595 # otherwise, sayonara
1597 user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)")
1598 user.account.destroy()
1599 user.state = "disconnecting"
1601 def handler_active(user):
1602 """Handle input for active users."""
1604 # get the next waiting line of input
1605 input_data = user.input_queue.pop(0)
1610 # split out the command and parameters
1612 mode = actor.get("mode")
1613 if mode and input_data.startswith("!"):
1614 command_name, parameters = first_word(input_data[1:])
1615 elif mode == "chat":
1616 command_name = "say"
1617 parameters = input_data
1619 command_name, parameters = first_word(input_data)
1621 # lowercase the command
1622 command_name = command_name.lower()
1624 # the command matches a command word for which we have data
1625 if command_name in universe.categories["command"]:
1626 command = universe.categories["command"][command_name]
1627 else: command = None
1629 # if it's allowed, do it
1630 if actor.can_run(command): exec(command.get("action"))
1632 # otherwise, give an error
1633 elif command_name: command_error(actor, input_data)
1635 # if no input, just idle back with a prompt
1636 else: user.send("", just_prompt=True)
1638 def command_halt(actor, parameters):
1639 """Halt the world."""
1642 # see if there's a message or use a generic one
1643 if parameters: message = "Halting: " + parameters
1644 else: message = "User " + actor.owner.account.get("name") + " halted the world."
1647 broadcast(message, add_prompt=False)
1650 # set a flag to terminate the world
1651 universe.terminate_flag = True
1653 def command_reload(actor):
1654 """Reload all code modules, configs and data."""
1657 # let the user know and log
1658 actor.send("Reloading all code modules, configs and data.")
1659 log("User " + actor.owner.account.get("name") + " reloaded the world.", 8)
1661 # set a flag to reload
1662 universe.reload_flag = True
1664 def command_quit(actor):
1665 """Leave the world and go back to the main menu."""
1667 actor.owner.state = "main_utility"
1668 actor.owner.deactivate_avatar()
1670 def command_help(actor, parameters):
1671 """List available commands and provide help for commands."""
1673 # did the user ask for help on a specific command word?
1674 if parameters and actor.owner:
1676 # is the command word one for which we have data?
1677 if parameters in universe.categories["command"]:
1678 command = universe.categories["command"][parameters]
1679 else: command = None
1681 # only for allowed commands
1682 if actor.can_run(command):
1684 # add a description if provided
1685 description = command.get("description")
1687 description = "(no short description provided)"
1688 if command.getboolean("administrative"): output = "$(red)"
1689 else: output = "$(grn)"
1690 output += parameters + "$(nrm) - " + description + "$(eol)$(eol)"
1692 # add the help text if provided
1693 help_text = command.get("help")
1695 help_text = "No help is provided for this command."
1698 # list related commands
1699 see_also = command.getlist("see_also")
1701 really_see_also = ""
1702 for item in see_also:
1703 if item in universe.categories["command"]:
1704 command = universe.categories["command"][item]
1705 if actor.can_run(command):
1707 really_see_also += ", "
1708 if command.getboolean("administrative"):
1709 really_see_also += "$(red)"
1711 really_see_also += "$(grn)"
1712 really_see_also += item + "$(nrm)"
1714 output += "$(eol)$(eol)See also: " + really_see_also
1716 # no data for the requested command word
1718 output = "That is not an available command."
1720 # no specific command word was indicated
1723 # give a sorted list of commands with descriptions if provided
1724 output = "These are the commands available to you:$(eol)$(eol)"
1725 sorted_commands = universe.categories["command"].keys()
1726 sorted_commands.sort()
1727 for item in sorted_commands:
1728 command = universe.categories["command"][item]
1729 if actor.can_run(command):
1730 description = command.get("description")
1732 description = "(no short description provided)"
1733 if command.getboolean("administrative"): output += " $(red)"
1734 else: output += " $(grn)"
1735 output += item + "$(nrm) - " + description + "$(eol)"
1736 output += "$(eol)Enter \"help COMMAND\" for help on a command named \"COMMAND\"."
1738 # send the accumulated output to the user
1741 def command_move(actor, parameters):
1742 """Move the avatar in a given direction."""
1743 if parameters in universe.contents[actor.get("location")].portals():
1744 actor.move_direction(parameters)
1745 else: actor.send("You cannot go that way.")
1747 def command_look(actor, parameters):
1749 if parameters: actor.send("You can't look at or in anything yet.")
1750 else: actor.look_at(actor.get("location"))
1752 def command_say(actor, parameters):
1753 """Speak to others in the same room."""
1755 # check for replacement macros
1756 if replace_macros(actor.owner, parameters, True) != parameters:
1757 actor.send("You cannot speak $_(replacement macros).")
1759 # the user entered a message
1762 # get rid of quote marks on the ends of the message
1763 message = parameters.strip("\"'`")
1765 # match the punctuation used, if any, to an action
1766 actions = universe.categories["internal"]["language"].getdict("actions")
1767 default_punctuation = universe.categories["internal"]["language"].get("default_punctuation")
1769 for mark in actions.keys():
1770 if message.endswith(mark):
1771 action = actions[mark]
1774 # add punctuation if needed
1776 action = actions[default_punctuation]
1777 if message and not message[-1] in punctuation:
1778 message += default_punctuation
1780 # decapitalize the first letter to improve matching
1781 if message and message[0] in uppercase:
1782 message = message[0].lower() + message[1:]
1784 # iterate over all words in message, replacing typos
1785 typos = universe.categories["internal"]["language"].getdict("typos")
1786 words = message.split()
1787 for index in range(len(words)):
1789 bare_word = word.strip(punctuation)
1790 if bare_word in typos.keys():
1791 words[index] = word.replace(bare_word, typos[bare_word])
1792 message = " ".join(words)
1794 # capitalize the first letter
1795 message = message[0].upper() + message[1:]
1798 actor.echo_to_location(actor.get("name") + " " + action + "s, \"" + message + "\"")
1799 actor.send("You " + action + ", \"" + message + "\"")
1801 # there was no message
1803 actor.send("What do you want to say?")
1805 def command_chat(actor):
1806 """Toggle chat mode."""
1807 mode = actor.get("mode")
1809 actor.set("mode", "chat")
1810 actor.send("Entering chat mode (use $(grn)!chat$(nrm) to exit).")
1811 elif mode == "chat":
1812 actor.remove_facet("mode")
1813 actor.send("Exiting chat mode.")
1814 else: actor.send("Sorry, but you're already busy with something else!")
1816 def command_show(actor, parameters):
1817 """Show program data."""
1819 arguments = parameters.split()
1820 if not parameters: message = "What do you want to show?"
1821 elif arguments[0] == "time":
1822 message = universe.categories["internal"]["counters"].get("elapsed") + " increments elapsed since the world was created."
1823 elif arguments[0] == "categories":
1824 message = "These are the element categories:$(eol)"
1825 categories = universe.categories.keys()
1827 for category in categories: message += "$(eol) $(grn)" + category + "$(nrm)"
1828 elif arguments[0] == "files":
1829 message = "These are the current files containing the universe:$(eol)"
1830 filenames = universe.files.keys()
1832 for filename in filenames:
1833 if universe.files[filename].is_writeable(): status = "rw"
1835 message += "$(eol) $(red)(" + status + ") $(grn)" + filename + "$(nrm)"
1836 elif arguments[0] == "category":
1837 if len(arguments) != 2: message = "You must specify one category."
1838 elif arguments[1] in universe.categories:
1839 message = "These are the elements in the \"" + arguments[1] + "\" category:$(eol)"
1840 elements = [(universe.categories[arguments[1]][x].key) for x in universe.categories[arguments[1]].keys()]
1842 for element in elements:
1843 message += "$(eol) $(grn)" + element + "$(nrm)"
1844 else: message = "Category \"" + arguments[1] + "\" does not exist."
1845 elif arguments[0] == "file":
1846 if len(arguments) != 2: message = "You must specify one file."
1847 elif arguments[1] in universe.files:
1848 message = "These are the elements in the \"" + arguments[1] + "\" file:$(eol)"
1849 elements = universe.files[arguments[1]].data.sections()
1851 for element in elements:
1852 message += "$(eol) $(grn)" + element + "$(nrm)"
1853 else: message = "Category \"" + arguments[1] + "\" does not exist."
1854 elif arguments[0] == "element":
1855 if len(arguments) != 2: message = "You must specify one element."
1856 elif arguments[1] in universe.contents:
1857 element = universe.contents[arguments[1]]
1858 message = "These are the properties of the \"" + arguments[1] + "\" element (in \"" + element.origin.filename + "\"):$(eol)"
1859 facets = element.facets()
1861 for facet in facets:
1862 message += "$(eol) $(grn)" + facet + ": $(red)" + escape_macros(element.get(facet)) + "$(nrm)"
1863 else: message = "Element \"" + arguments[1] + "\" does not exist."
1864 elif arguments[0] == "result":
1865 if len(arguments) < 2: message = "You need to specify an expression."
1868 message = repr(eval(" ".join(arguments[1:])))
1870 message = "Your expression raised an exception!"
1871 elif arguments[0] == "log":
1872 if len(arguments) == 4:
1873 if match("^\d+$", arguments[3]) and int(arguments[3]) >= 0:
1874 stop = int(arguments[3])
1877 if len(arguments) >= 3:
1878 if match("^\d+$", arguments[2]) and int(arguments[2]) > 0:
1879 start = int(arguments[2])
1882 if len(arguments) >= 2:
1883 if match("^\d+$", arguments[1]) and 0 <= int(arguments[1]) <= 9:
1884 level = int(arguments[1])
1886 elif 0 <= actor.owner.account.getint("loglevel") <= 9:
1887 level = actor.owner.account.getint("loglevel")
1889 if level > -1 and start > -1 and stop > -1:
1890 message = get_loglines(level, start, stop)
1891 else: message = "When specified, level must be 0-9 (default 1), start and stop must be >=1 (default 10 and 1)."
1892 else: message = "I don't know what \"" + parameters + "\" is."
1895 def command_create(actor, parameters):
1896 """Create an element if it does not exist."""
1897 if not parameters: message = "You must at least specify an element to create."
1898 elif not actor.owner: message = ""
1900 arguments = parameters.split()
1901 if len(arguments) == 1: arguments.append("")
1902 if len(arguments) == 2:
1903 element, filename = arguments
1904 if element in universe.contents: message = "The \"" + element + "\" element already exists."
1906 message = "You create \"" + element + "\" within the universe."
1907 logline = actor.owner.account.get("name") + " created an element: " + element
1909 logline += " in file " + filename
1910 if filename not in universe.files:
1911 message += " Warning: \"" + filename + "\" is not yet included in any other file and will not be read on startup unless this is remedied."
1912 Element(element, universe, filename)
1914 elif len(arguments) > 2: message = "You can only specify an element and a filename."
1917 def command_destroy(actor, parameters):
1918 """Destroy an element if it exists."""
1920 if not parameters: message = "You must specify an element to destroy."
1922 if parameters not in universe.contents: message = "The \"" + parameters + "\" element does not exist."
1924 universe.contents[parameters].destroy()
1925 message = "You destroy \"" + parameters + "\" within the universe."
1926 log(actor.owner.account.get("name") + " destroyed an element: " + parameters, 6)
1929 def command_set(actor, parameters):
1930 """Set a facet of an element."""
1931 if not parameters: message = "You must specify an element, a facet and a value."
1933 arguments = parameters.split(" ", 2)
1934 if len(arguments) == 1: message = "What facet of element \"" + arguments[0] + "\" would you like to set?"
1935 elif len(arguments) == 2: message = "What value would you like to set for the \"" + arguments[1] + "\" facet of the \"" + arguments[0] + "\" element?"
1937 element, facet, value = arguments
1938 if element not in universe.contents: message = "The \"" + element + "\" element does not exist."
1940 universe.contents[element].set(facet, value)
1941 message = "You have successfully (re)set the \"" + facet + "\" facet of element \"" + element + "\". Try \"show element " + element + "\" for verification."
1944 def command_delete(actor, parameters):
1945 """Delete a facet from an element."""
1946 if not parameters: message = "You must specify an element and a facet."
1948 arguments = parameters.split(" ")
1949 if len(arguments) == 1: message = "What facet of element \"" + arguments[0] + "\" would you like to delete?"
1950 elif len(arguments) != 2: message = "You may only specify an element and a facet."
1952 element, facet = arguments
1953 if element not in universe.contents: message = "The \"" + element + "\" element does not exist."
1954 elif facet not in universe.contents[element].facets(): message = "The \"" + element + "\" element has no \"" + facet + "\" facet."
1956 universe.contents[element].remove_facet(facet)
1957 message = "You have successfully deleted the \"" + facet + "\" facet of element \"" + element + "\". Try \"show element " + element + "\" for verification."
1960 def command_error(actor, input_data):
1961 """Generic error for an unrecognized command word."""
1963 # 90% of the time use a generic error
1965 message = "I'm not sure what \"" + input_data + "\" means..."
1967 # 10% of the time use the classic diku error
1969 message = "Arglebargle, glop-glyf!?!"
1971 # send the error message
1975 """Fork and disassociate from everything."""
1976 if universe.contents["internal:process"].getboolean("daemon"):
1978 from resource import getrlimit, RLIMIT_NOFILE
1979 log("Disassociating from the controlling terminal.")
1985 for stdpipe in range(3): close(stdpipe)
1986 sys.stdin = sys.__stdin__ = file("/dev/null", "r")
1987 sys.stdout = sys.stderr = sys.__stdout__ = sys.__stderr__ = file("/dev/null", "w")
1989 def create_pidfile(universe):
1990 """Write a file containing the current process ID."""
1992 log("Process ID: " + pid)
1993 file_name = universe.contents["internal:process"].get("pidfile")
1995 if not isabs(file_name):
1996 file_name = path_join(universe.startdir, file_name)
1997 file_descriptor = file(file_name, 'w')
1998 file_descriptor.write(pid + "\n")
1999 file_descriptor.flush()
2000 file_descriptor.close()
2002 def remove_pidfile(universe):
2003 """Remove the file containing the current process ID."""
2004 file_name = universe.contents["internal:process"].get("pidfile")
2006 if not isabs(file_name):
2007 file_name = path_join(universe.startdir, file_name)
2008 if access(file_name, W_OK): remove(file_name)
2010 def excepthook(excepttype, value, traceback):
2011 """Handle uncaught exceptions."""
2013 # assemble the list of errors into a single string
2014 message = "".join(format_exception(excepttype, value, traceback))
2016 # try to log it, if possible
2017 try: log(message, 9)
2020 # try to write it to stderr, if possible
2021 try: stderr.write(message)
2024 def sighook(what, where):
2025 """Handle external signals."""
2028 message = "Caught signal: "
2030 # for a hangup signal
2032 message += "hangup (reloading)"
2033 universe.reload_flag = True
2035 # for a terminate signal
2036 elif what == SIGTERM:
2037 message += "terminate (halting)"
2038 universe.terminate_flag = True
2040 # catchall for unexpected signals
2041 else: message += str(what) + " (unhandled)"
2046 # redefine sys.excepthook with ours
2048 sys.excepthook = excepthook
2050 # assign the sgnal handlers
2051 signal(SIGHUP, sighook)
2052 signal(SIGTERM, sighook)
2054 # if there is no universe, create an empty one
2055 if not "universe" in locals():
2056 if len(argv) > 1: conffile = argv[1]
2058 universe = Universe(conffile, True)
2059 elif universe.reload_flag:
2060 universe = universe.new()